Liaison de sortie Dapr Invoke pour Azure Functions

L’exemple suivant illustre l’utilisation d’une liaison de sortie d’appel Dapr pour effectuer une opération d’appel de service Dapr hébergée dans une autre application daprisée. Dans cet exemple, la fonction agit comme un proxy.

[FunctionName("InvokeOutputBinding")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Function, "get", Route = "invoke/{appId}/{methodName}")] HttpRequest req,
    [DaprInvoke(AppId = "{appId}", MethodName = "{methodName}", HttpVerb = "post")] IAsyncCollector<InvokeMethodParameters> output,
    ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

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

    var outputContent = new InvokeMethodParameters
    {
        Body = requestBody
    };

    await output.AddAsync(outputContent);

    return new OkResult();
}

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

[Function("InvokeOutputBinding")]
[DaprInvokeOutput(AppId = "{appId}", MethodName = "{methodName}", HttpVerb = "post")]
public static async Task<InvokeMethodParameters> Run(
    [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = "invoke/{appId}/{methodName}")] HttpRequestData req, FunctionContext functionContext)
{
    var log = functionContext.GetLogger("InvokeOutputBinding");
    log.LogInformation("C# HTTP trigger function processed a request.");

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

    var outputContent = new InvokeMethodParameters
    {
        Body = requestBody
    };

    return outputContent;
}

Dans l’exemple suivant, la liaison de sortie d’appel Dapr est associée à un déclencheur HTTP, qui est inscrit par l’objet app :

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

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

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

        return { body: 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 daprInvoke:

{
  "bindings":
    {
      "type": "daprInvoke",
      "direction": "out",
      "appId": "{appId}",
      "methodName": "{methodName}",
      "httpVerb": "post",
      "name": "payload"
    }
}

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

Voici le code JavaScript :

module.exports = async function (context, req) {
    context.log("Node HTTP trigger function processed a request.");
    context.bindings.output = { body: req.body };
    context.done(null);
};

L’exemple suivant montre une liaison de sortie Dapr Invoke, qui utilise le modèle de programmation Python v2. Pour utiliser daprInvoke dans le code de votre application de fonction Python :

import logging
import json
import azure.functions as func

app = func.FunctionApp()

@app.function_name(name="InvokeOutputBinding")
@app.route(route="invoke/{appId}/{methodName}", auth_level=dapp.auth_level.ANONYMOUS)
@app.dapr_invoke_output(arg_name = "payload", app_id = "{appId}", method_name = "{methodName}", http_verb = "post")
def main(req: func.HttpRequest, payload: func.Out[str] ) -> str:
    # request body must be passed this way "{\"body\":{\"value\":{\"key\":\"some value\"}}}" to use the InvokeOutputBinding, all the data must be enclosed in body property.
    logging.info('Python function processed a InvokeOutputBinding request from the Dapr Runtime.')

    body = req.get_body()
    logging.info(body)
    if body is not None:
        payload.set(body)
    else:
        logging.info('req body is none')
    return 'ok'

L’exemple suivant montre une liaison de sortie Dapr Invoke, qui utilise le modèle de programmation Python v1.

Here's the function.json file for daprInvoke:

{
  "scriptFile": "__init__.py",
  "bindings":
    {
      "type": "daprInvoke",
      "direction": "out",
      "appId": "{appId}",
      "methodName": "{methodName}",
      "httpVerb": "post",
      "name": "payload"
    }
}

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

Voici le code Python :

def main(req: func.HttpRequest,
         payload: func.Out[bytes]) -> func.HttpResponse:
    logging.info('Python InvokeOutputBinding processed a request.')
    data = req.params.get('data')

In the in-process model, use the DaprInvoke attribute to define a Dapr invoke output binding, which supports these parameters:

Dans le modèle worker isolé, utilisez l’attribut DaprInvokeOutput pour définir une liaison de sortie d’appel Dapr, qui prend en charge ces paramètres :

Le tableau suivant décrit les propriétés de configuration de liaison que vous définissez dans le code.

Le tableau suivant décrit les propriétés de configuration de liaison que vous définissez dans le fichier function.json.

Le tableau suivant explique les propriétés de configuration de liaison pour @dapp.dapr_invoke_output que vous définissez dans votre code Python.

Le tableau suivant décrit les propriétés de configuration de liaison que vous définissez dans le fichier function.json.

Pour utiliser daprInvoke dans Python v2, configurez votre projet avec les dépendances appropriées.

1. Créer et activer un environnement virtuel.

2. Dans votre fichier requirements.text, ajoutez la ligne suivante :

   azure-functions==1.18.0b3
   

3. Dans le terminal, installez la bibliothèque Python.

   pip install -r .\requirements.txt
   

4. Modifiez votre fichier local.setting.json avec la configuration suivante :

   "PYTHON_ISOLATE_WORKER_DEPENDENCIES":1
   

Le modèle Python v1 ne nécessite aucune modification supplémentaire, à part la configuration des composants d’appel de service.