Associazione di output dello stato dapr per Funzioni di Azure

Nell'esempio seguente viene illustrato l'uso dell'associazione di output dello stato dapr per rendere persistente un nuovo stato nell'archivio stati.

[FunctionName("StateOutputBinding")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Function, "post", Route = "state/{key}")] HttpRequest req,
    [DaprState("statestore", Key = "{key}")] IAsyncCollector<string> state,
    ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
    await state.AddAsync(requestBody);

    return new OkResult();
}

More samples for the Dapr output state binding are available in the GitHub repository.

[Function("StateOutputBinding")]
[DaprStateOutput("statestore", Key = "{key}")]
public static string Run(
    [HttpTrigger(AuthorizationLevel.Function, "post", Route = "state/{key}")] HttpRequestData req,
    FunctionContext functionContext)
{
    var log = functionContext.GetLogger("StateOutputBinding");
    log.LogInformation("C# HTTP trigger function processed a request.");

    string requestBody = new StreamReader(req.Body).ReadToEnd();

    return requestBody;
}

Nell'esempio seguente, l'associazione di output dello stato dapr viene associata a un trigger HTTP, registrato dall'oggetto app :

const { app, trigger } = require('@azure/functions');

app.generic('StateOutputBinding', {
    trigger: trigger.generic({
        type: 'httpTrigger',
        authLevel: 'anonymous',
        methods: ['POST'],
        route: "state/{key}",
        name: "req"
    }),
    return: daprStateOutput,
    handler: async (request, context) => {
        context.log("Node HTTP trigger function processed a request.");

        const payload = await request.text();
        context.log(JSON.stringify(payload));

        return { value : payload };
    }
});

The following examples show Dapr triggers in a function.json file and JavaScript code that uses those bindings.

Here's the function.json file for daprState output:

{
  "bindings": 
    {
      "type": "daprState",
      "direction": "out",
      "name": "dapr",
      "stateStore": "statestore",
      "key": "{key}",
      "daprAddress": "%daprAddress%"
    }
}

For more information about function.json file properties, see the Configuration section.

Ecco il codice JavaScript:

module.exports = async function (context, req) {
    context.log('JavaScript HTTP trigger function processed a request.');

    context.bindings.dapr = {
        // stateStore: 'statestore-if-not-in-function.json'
        // key: 'key-if-not-in-function.json'
        value: req.body
    };
};

L'esempio seguente mostra un'associazione di output dapr State, che usa il modello di programmazione Python v2. Per usare daprState nel codice dell'app per le funzioni Python:

import logging
import json
import azure.functions as func

app = func.FunctionApp()

@app.function_name(name="HttpTriggerFunc")
@app.route(route="req", auth_level=dapp.auth_level.ANONYMOUS)
@app.dapr_state_output(arg_name="state", state_store="statestore", key="newOrder")
def main(req: func.HttpRequest, state: func.Out[str] ) -> str:
    # request body must be passed this way '{\"value\": { \"key\": \"some value\" } }'
    body = req.get_body()
    if body is not None:
        state.set(body.decode('utf-8'))
        logging.info(body.decode('utf-8'))
    else:
        logging.info('req body is none')
    return 'ok'

L'esempio seguente mostra un'associazione di output Dapr State, che usa il modello di programmazione Python v1.

Here's the function.json file for daprState:

{
  "scriptFile": "__init__.py",
  "bindings": 
    {
      "type": "daprState",
      "stateStore": "%StateStoreName%",
      "direction": "out",
      "name": "order",
      "key": "order"
    }
}

For more information about function.json file properties, see the Configuration section.

Ecco il codice Python:

import logging
import json
import azure.functions as func

def main(payload,
         order: func.Out[str]) -> None:
    logging.info('Python function processed a CreateNewOrder request from the Dapr Runtime.')  
    payload_json = json.loads(payload)
    logging.info(payload_json["data"])
    order.set(json.dumps(payload_json["data"]))

In the in-process model, use the DaprState to define a Dapr state output binding, which supports these parameters:

Nel modello di lavoro isolato usare per definire un'associazione DaprStateOutput di output dello stato dapr, che supporta questi parametri:

Nella tabella seguente vengono illustrate le proprietà di configurazione dell'associazione impostate nel codice.

Nella tabella seguente sono illustrate le proprietà di configurazione dell'associazione impostate nel file function.json.

La tabella seguente illustra le proprietà di configurazione dell'associazione per @dapp.dapr_state_output impostate nel codice Python.

The following table explains the binding configuration properties that you set in the function.json file.

Per usare daprState in Python v2, configurare il progetto con le dipendenze corrette.

1. Creare e attivare un ambiente virtuale.

2. Nel file requirements.text aggiungere la riga seguente:

   azure-functions==1.18.0b3
   

3. Nel terminale installare la libreria Python.

   pip install -r .\requirements.txt
   

4. Modificare il file local.setting.json con la configurazione seguente:

   "PYTHON_ISOLATE_WORKER_DEPENDENCIES":1
   

Il modello Python v1 non richiede modifiche aggiuntive, a parte la configurazione dell'archivio di stati.