Connecter Azure Functions à Azure Storage à l’aide d’outils en ligne de commande

Avant de commencer, vous devez suivre l’article Quickstart : Create an Azure Functions project from the command line. Si vous avez déjà nettoyé les ressources à la fin de cet article, passez à nouveau par les étapes pour recréer l’application de fonction et les ressources associées dans Azure.

Avant de commencer, vous devez suivre l’article Quickstart : Create an Azure Functions project from the command line. Si vous avez déjà nettoyé les ressources à la fin de cet article, passez à nouveau par les étapes pour recréer l’application de fonction et les ressources associées dans Azure.

Avant de commencer, vous devez suivre l’article Quickstart : Create an Azure Functions project from the command line. Si vous avez déjà nettoyé les ressources à la fin de cet article, passez à nouveau par les étapes pour recréer l’application de fonction et les ressources associées dans Azure.

Avant de commencer, vous devez suivre l’article Quickstart : Create an Azure Functions project from the command line. Si vous avez déjà nettoyé les ressources à la fin de cet article, passez à nouveau par les étapes pour recréer l’application de fonction et les ressources associées dans Azure.

Avant de commencer, vous devez suivre l’article Quickstart : Create an Azure Functions project from the command line. Si vous avez déjà nettoyé les ressources à la fin de cet article, passez à nouveau par les étapes pour recréer l’application de fonction et les ressources associées dans Azure.

Avant de commencer, vous devez suivre l’article Quickstart : Create an Azure Functions project from the command line. Si vous avez déjà nettoyé les ressources à la fin de cet article, passez à nouveau par les étapes pour recréer l’application de fonction et les ressources associées dans Azure.

Inscrire des extensions de liaison

À l’exception des déclencheurs HTTP et de minuteur, les liaisons sont implémentées en tant que packages d’extension. Exécutez la commande dotnet add package suivante dans la fenêtre terminal pour ajouter le package d’extension Storage à votre project.

dotnet add package Microsoft.Azure.Functions.Worker.Extensions.Storage.Queues --prerelease

dotnet add package Microsoft.Azure.WebJobs.Extensions.Storage 

Vous pouvez maintenant ajouter la liaison de sortie de stockage à votre projet.

Ajouter une définition de liaison de sortie à la fonction

Bien qu’une fonction ne puisse avoir qu’un seul déclencheur, elle peut avoir plusieurs liaisons d’entrée et de sortie, ce qui vous permet de vous connecter à d’autres services et ressources Azure sans écrire de code d’intégration personnalisé.

Lors de l'utilisation du modèle de programmation Node.js v4, les attributs de liaison sont définis directement dans le fichier ./src/functions/HttpExample.js. Depuis le démarrage rapide précédent, votre fichier contient déjà une liaison HTTP définie par la méthode app.http.

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

app.http('httpTrigger', {
  methods: ['GET', 'POST'],
  authLevel: 'anonymous',
  handler: async (request, context) => {
    try {
      context.log(`Http function processed request for url "${request.url}"`);

      const name = request.query.get('name') || (await request.text());
      context.log(`Name: ${name}`);

      if (!name) {
        return { status: 404, body: 'Not Found' };
      }

      return { body: `Hello, ${name}!` };
    } catch (error) {
      context.log(`Error: ${error}`);
      return { status: 500, body: 'Internal Server Error' };
    }
  },
});

Lors de l'utilisation du modèle de programmation Node.js v4, les attributs de liaison sont définis directement dans le fichier ./src/functions/HttpExample.js. Depuis le démarrage rapide précédent, votre fichier contient déjà une liaison HTTP définie par la méthode app.http.

import {
  app,
  HttpRequest,
  HttpResponseInit,
  InvocationContext,
} from '@azure/functions';

export async function httpTrigger1(
  request: HttpRequest,
  context: InvocationContext,
): Promise<HttpResponseInit> {
  context.log(`Http function processed request for url "${request.url}"`);

  const name = request.query.get('name') || (await request.text()) || 'world';

  return { body: `Hello, ${name}!` };
}

app.http('httpTrigger1', {
  methods: ['GET', 'POST'],
  authLevel: 'anonymous',
  handler: httpTrigger1,
});

Vous déclarez ces liaisons dans le fichier function.json situé dans le dossier de la fonction. Compte tenu du guide de démarrage rapide précédent, votre fichier function.json situé dans le dossier HttpExample contient deux liaisons dans la collection bindings :

Lors de l’utilisation du modèle de programmation Python v2, les attributs de liaison sont définis directement dans le fichier function_app.py comme éléments décoratifs. Dans le guide de démarrage rapide précédent, votre fichier function_app.py contient déjà une liaison basée sur un élément décoratif :

import azure.functions as func
import logging

app = func.FunctionApp()

@app.function_name(name="HttpTrigger1")
@app.route(route="hello", auth_level=func.AuthLevel.ANONYMOUS)

L’élément décoratif route ajoute la liaison HttpTrigger et HttpOutput à la fonction, ce qui permet à votre fonction d’être déclenchée lorsque les requêtes HTTP atteignent l’itinéraire spécifié.

Pour écrire dans une file d’attente Azure Storage à partir de cette fonction, ajoutez le décorateur queue_output à votre code de fonction :

@app.queue_output(arg_name="msg", queue_name="outqueue", connection="AzureWebJobsStorage")

Dans le décorateur, arg_name identifie le paramètre de liaison référencé dans votre code, queue_name est le nom de la file d’attente dans laquelle la liaison écrit et connection est le nom d’un paramètre d’application qui contient le connection string du compte Storage. Dans les guides de démarrage rapide, vous utilisez le même compte de stockage que l'application de fonction, qui se trouve dans le paramètre AzureWebJobsStorage, du fichier local.settings.json. Si la propriété queue_name n’existe pas, la liaison la crée lors de la première utilisation.

"bindings": [
  {
    "authLevel": "function",
    "type": "httpTrigger",
    "direction": "in",
    "name": "Request",
    "methods": [
      "get",
      "post"
    ]
  },
  {
    "type": "http",
    "direction": "out",
    "name": "Response"
  }
]

Pour écrire dans une file d’attente Azure Storage :

• Ajouter une propriété extraOutputs à la configuration de liaison

  {
      methods: ['GET', 'POST'],
      extraOutputs: [sendToQueue], // add output binding to HTTP trigger
      authLevel: 'anonymous',
      handler: () => {}
  }
  

• Ajouter une fonction output.storageQueue au-dessus de l'appel app.http

  const sendToQueue: StorageQueueOutput = output.storageQueue({
    queueName: 'outqueue',
    connection: 'AzureWebJobsStorage',
  });
  

La deuxième liaison dans la collection est nommée res. Cette liaison http est une liaison de sortie (out) qui est utilisée pour écrire la réponse HTTP.

Pour écrire dans une file d’attente Azure Storage à partir de cette fonction, ajoutez une liaison out de type queue avec le nom msg, comme indiqué dans le code ci-dessous :

    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "Request",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "Response"
    },
    {
      "type": "queue",
      "direction": "out",
      "name": "msg",
      "queueName": "outqueue",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

Pour un type queue, vous devez spécifier le nom de la file d’attente dans queueName et fournir le nom de la connexion Azure Storage (à partir de local.settings.json) dans connection.

Dans un project C#, les liaisons sont définies en tant qu’attributs de liaison sur la méthode de fonction. Les définitions spécifiques varient selon que votre application s’exécute in-process (bibliothèque de classes C#) ou dans un processus Worker isolé.

public class MultiResponse
{
    [QueueOutput("outqueue", Connection = "AzureWebJobsStorage")]
    public string[] Messages { get; set; }
    public IActionResult HttpResponse { get; set; }
}

[Queue("outqueue"),StorageAccount("AzureWebJobsStorage")] ICollector<string> msg,

[FunctionName("HttpExample")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, 
    [Queue("outqueue"),StorageAccount("AzureWebJobsStorage")] ICollector<string> msg, 
    ILogger log)

Dans un project Java, les liaisons sont définies en tant qu’annotations de liaison sur la méthode de fonction. Le fichier function.json est ensuite généré automatiquement en fonction de ces annotations.

Accédez à l’emplacement de votre code de fonction sous src/main/java, ouvrez le fichier Function.java project et ajoutez le paramètre suivant à la définition de méthode run :

@QueueOutput(name = "msg", queueName = "outqueue", connection = "AzureWebJobsStorage") OutputBinding<String> msg

Le paramètre msg est un type OutputBinding<T>, qui représente une collection de chaînes. Ces chaînes sont écrites sous forme de messages dans une liaison de sortie lorsque la fonction se termine. Dans ce cas, la sortie est une file d'attente de stockage nommée outqueue. Le connection string du compte Storage est défini par la méthode connection. Vous passez le paramètre d’application qui contient la chaîne de connexion du compte de stockage, au lieu de passer la chaîne de connexion elle-même.

La définition de la méthode run doit maintenant être semblable à celle de l’exemple suivant :

@FunctionName("HttpTrigger-Java")
public HttpResponseMessage run(
        @HttpTrigger(name = "req", methods = {HttpMethod.GET, HttpMethod.POST}, authLevel = AuthorizationLevel.FUNCTION)  
        HttpRequestMessage<Optional<String>> request, 
        @QueueOutput(name = "msg", queueName = "outqueue", connection = "AzureWebJobsStorage") 
        OutputBinding<String> msg, final ExecutionContext context) {
    ...
}

Mettez à jour le fichier HttpExample\function_app.py de manière à ce qu’il corresponde au code suivant, en ajoutant le paramètre msg à la définition de fonction et msg.set(name) sous l’instruction if name: :

import azure.functions as func
import logging

app = func.FunctionApp(http_auth_level=func.AuthLevel.ANONYMOUS)

@app.route(route="HttpExample")
@app.queue_output(arg_name="msg", queue_name="outqueue", connection="AzureWebJobsStorage")
def HttpExample(req: func.HttpRequest, msg: func.Out [func.QueueMessage]) -> func.HttpResponse:
    logging.info('Python HTTP trigger function processed a request.')

    name = req.params.get('name')
    if not name:
        try:
            req_body = req.get_json()
        except ValueError:
            pass
        else:
            name = req_body.get('name')

    if name:
        msg.set(name)
        return func.HttpResponse(f"Hello, {name}. This HTTP triggered function executed successfully.")
    else:
        return func.HttpResponse(
             "This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response.",
             status_code=200
        )

Le paramètre msg est une instance du azure.functions.Out class. La méthode set écrit un message de type chaîne dans la file d’attente. Dans ce cas, il s’agit du paramètre name transmis à la fonction dans la chaîne de requête de l’URL.

Ajoutez du code qui utilise l'objet de liaison de sortie context.extraOutputs pour créer un message de file d'attente. Ajoutez ce code avant l’instruction return.

context.extraOutputs.set(sendToQueue, [msg]);

À ce stade, votre fonction doit ressembler à ce qui suit :

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

const sendToQueue = output.storageQueue({
  queueName: 'outqueue',
  connection: 'AzureWebJobsStorage',
});

app.http('HttpExample', {
  methods: ['GET', 'POST'],
  authLevel: 'anonymous',
  extraOutputs: [sendToQueue],
  handler: async (request, context) => {
    try {
      context.log(`Http function processed request for url "${request.url}"`);

      const name = request.query.get('name') || (await request.text());
      context.log(`Name: ${name}`);

      if (name) {
        const msg = `Name passed to the function ${name}`;
        context.extraOutputs.set(sendToQueue, [msg]);
        return { body: msg };
      } else {
        context.log('Missing required data');
        return { status: 404, body: 'Missing required data' };
      }
    } catch (error) {
      context.log(`Error: ${error}`);
      return { status: 500, body: 'Internal Server Error' };
    }
  },
});

Ajoutez du code qui utilise l'objet de liaison de sortie context.extraOutputs pour créer un message de file d'attente. Ajoutez ce code avant l’instruction return.

context.extraOutputs.set(sendToQueue, [msg]);

À ce stade, votre fonction doit ressembler à ce qui suit :

import {
  app,
  output,
  HttpRequest,
  HttpResponseInit,
  InvocationContext,
  StorageQueueOutput,
} from '@azure/functions';

const sendToQueue: StorageQueueOutput = output.storageQueue({
  queueName: 'outqueue',
  connection: 'AzureWebJobsStorage',
});

export async function HttpExample(
  request: HttpRequest,
  context: InvocationContext,
): Promise<HttpResponseInit> {
  try {
    context.log(`Http function processed request for url "${request.url}"`);

    const name = request.query.get('name') || (await request.text());
    context.log(`Name: ${name}`);

    if (name) {
      const msg = `Name passed to the function ${name}`;
      context.extraOutputs.set(sendToQueue, [msg]);
      return { body: msg };
    } else {
      context.log('Missing required data');
      return { status: 404, body: 'Missing required data' };
    }
  } catch (error) {
    context.log(`Error: ${error}`);
    return { status: 500, body: 'Internal Server Error' };
  }
}

app.http('HttpExample', {
  methods: ['GET', 'POST'],
  authLevel: 'anonymous',
  handler: HttpExample,
});

Ajoutez du code qui utilise l’applet de commande Push-OutputBinding pour écrire du texte dans la file d’attente à l’aide de la liaison de sortie msg. Ajoutez ce code avant de définir l’état OK dans l’instruction if.

$outputMsg = $name
Push-OutputBinding -name msg -Value $outputMsg

À ce stade, votre fonction doit se présenter comme suit :

using namespace System.Net

# Input bindings are passed in via param block.
param($Request, $TriggerMetadata)

# Write to the Azure Functions log stream.
Write-Host "PowerShell HTTP trigger function processed a request."

# Interact with query parameters or the body of the request.
$name = $Request.Query.Name
if (-not $name) {
    $name = $Request.Body.Name
}

if ($name) {
    # Write the $name value to the queue, 
    # which is the name passed to the function.
    $outputMsg = $name
    Push-OutputBinding -name msg -Value $outputMsg

    $status = [HttpStatusCode]::OK
    $body = "Hello $name"
}
else {
    $status = [HttpStatusCode]::BadRequest
    $body = "Please pass a name on the query string or in the request body."
}

# Associate values to output bindings by calling 'Push-OutputBinding'.
Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
    StatusCode = $status
    Body = $body
})

À présent, vous pouvez utiliser le nouveau paramètre msg pour écrire dans la liaison de sortie à partir de votre code de fonction. Ajoutez la ligne de code suivante avant la réponse de réussite pour ajouter la valeur de name à la liaison de sortie msg.

msg.setValue(name);

Lorsque vous utilisez une liaison de sortie, vous n'avez pas besoin d'utiliser le code Azure Storage SDK pour l'authentification, d'obtenir une référence de file d'attente ou d'écrire des données. La liaison de sortie de file d’attente et le runtime Functions effectuent ces tâches.

Votre méthode run doit maintenant être semblable à celle de l’exemple suivant :

public HttpResponseMessage run(
        @HttpTrigger(name = "req", methods = {HttpMethod.GET, HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) 
        HttpRequestMessage<Optional<String>> request, 
        @QueueOutput(name = "msg", queueName = "outqueue", 
        connection = "AzureWebJobsStorage") OutputBinding<String> msg, 
        final ExecutionContext context) {
    context.getLogger().info("Java HTTP trigger processed a request.");

    // Parse query parameter
    String query = request.getQueryParameters().get("name");
    String name = request.getBody().orElse(query);

    if (name == null) {
        return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
        .body("Please pass a name on the query string or in the request body").build();
    } else {
        // Write the name to the message queue. 
        msg.setValue(name);

        return request.createResponseBuilder(HttpStatus.OK).body("Hello, " + name).build();
    }
}

Mettre à jour les tests

Étant donné que l’archétype crée également un ensemble de tests, vous devez mettre à jour ces tests pour gérer le nouveau paramètre msg dans la signature de méthode run.

Accédez à l’emplacement de votre code de test sous src/test/java, ouvrez le fichier Function.java project et remplacez la ligne de code sous //Invoke par le code suivant :

@SuppressWarnings("unchecked")
final OutputBinding<String> msg = (OutputBinding<String>)mock(OutputBinding.class);
final HttpResponseMessage ret = new Function().run(req, msg, context);

Dans le dossier LocalFunctionsProj, utilisez la commande func azure functionapp publish pour redéployer le project, en remplaçant<APP_NAME> par le nom de votre application.

func azure functionapp publish <APP_NAME>

Dans le dossier project local, utilisez la commande Maven suivante pour republier votre project :

mvn azure-functions:deploy

• Examples des projets de fonction complets en C#.

• Référence du développeur Azure Functions C#

• Examples des projets de fonction complets en JavaScript.

• Azure Functions guide du développeur JavaScript

• Examples des projets de fonction complets dans TypeScript.

• Azure Functions Guide du développeur TypeScript

• Examples des projets de fonction complets en Python.

• Azure Functions guide du développeur Python

• Examples de projets de fonction complets dans PowerShell.

• Guide du développeur Azure Functions PowerShell