Connecter Azure Functions à Azure Storage à l’aide du code Visual Studio

• Installez les outils CLI .NET Core.

Votre project a été configuré pour utiliser des bundles extension, qui installe automatiquement un ensemble prédéfini de packages d’extension.

Les bundles d’extensions sont déjà activés dans le fichier host.json à la racine du project, qui doit ressembler à l’exemple suivant :

{
  "version": "2.0",
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[3.*, 4.0.0)"
  }
}

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

Votre project a été configuré pour utiliser des bundles extension, qui installe automatiquement un ensemble prédéfini de packages d’extension.

Les bundles d’extensions sont déjà activés dans le fichier host.json à la racine du project, qui doit ressembler à l’exemple suivant :

{
  "version": "2.0",
  "logging": {
    "applicationInsights": {
      "samplingSettings": {
        "isEnabled": true,
        "excludedTypes": "Request"
      }
    }
  },
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[4.*, 5.0.0)"
  }
}

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

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: 'function',
      handler: () => {}
  }
  

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

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

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: 'function',
      handler: () => {}
  }
  

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

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

Dans Functions, chaque type de liaison requiert un direction, type et un name unique. La façon dont vous définissez ces attributs dépend du langage de votre application de fonction.

Les attributs de liaison sont définis dans le fichier function.json pour une fonction donnée. Selon le type de liaison, des propriétés supplémentaires peuvent être requises. La configuration de sortie de file d'attente décrit les champs requis pour une liaison à une file d’attente Azure Storage. L’extension vous permet d’ajouter facilement des liaisons au fichier function.json.

Pour créer une liaison, cliquez avec le bouton droit (Ctrl+Clic sur macOS) sur le fichier function.json dans votre dossier HttpTrigger, puis choisissez Ajouter une liaison... . Suivez les invites pour définir les propriétés de liaison suivantes pour la nouvelle liaison :

Une liaison est ajoutée au tableau bindings dans votre fichier function.json, qui doit ressembler à ce qui suit :

      "name": "msg",
      "queueName": "outqueue",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

Les attributs de liaison sont définis en décorant du code de fonction spécifique dans le fichier function_app.py. Vous utilisez le décorateur queue_output pour ajouter une liaison de sortie Azure Queue storage.

En utilisant le décorateur queue_output, la direction de liaison est implicitement « out » et le type est File d'attente Azure Storage. Ajoutez le décorateur suivant à votre code de fonction dans function_app.py :

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

Dans ce code, 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 fonctionnelle, qui se trouve dans le paramètre AzureWebJobsStorage. Si la propriété queue_name n’existe pas, la liaison la crée lors de la première utilisation.

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 écrites en tant que 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. Au lieu du connection string lui-même, vous passez le paramètre d’application qui contient le connection string du compte Storage.

La définition de la méthode run doit maintenant ressembler à l’exemple suivant :

@FunctionName("HttpExample")
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) {

Ajoutez le code qui utilise l’objet de liaison de sortie sur 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 le code qui utilise l’objet de liaison de sortie sur 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
})

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 name transmis à la fonction dans la chaîne de requête de l’URL.

À 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 ressembler à l’exemple suivant :

@FunctionName("HttpExample")
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);

Exécuter la fonction localement

Visual Studio Code s’intègre à Outils Azure Functions Core pour vous permettre d’exécuter ce projet sur votre ordinateur de développement local avant de le publier sur Azure. Si vous n'avez pas encore installé Core Tools localement, vous êtes invité à l'installer la première fois que vous exécutez votre project.

1. Pour appeler votre fonction, appuyez sur F5 pour démarrer le projet d'application de fonctions. Le panneau Terminal affiche la sortie des outils principaux. Votre application démarre dans le panneau Terminal. Vous pouvez voir le point de terminaison de l’URL de votre fonction déclenchée par HTTP en cours d’exécution localement.

   

   Si vous n'avez pas encore installé Core Tools, sélectionnez Install pour l'installer lorsque vous y êtes invité à le faire.
   Si vous rencontrez des problèmes d'exécution sur Windows, vérifiez que le terminal par défaut pour Visual Studio Code n'est pas défini sur WSL Bash.

2. Une fois les outils principaux en cours d’exécution, accédez à la zone Azure : Functions. Sous Functions, développez Local Project>Functions. Cliquez avec le bouton droit (Windows) ou effectuez Ctrl-clic (macOS) sur la fonction HttpExample, puis choisissez Exécuter la fonction maintenant.

   

3. Dans Entrez le corps de la requête, appuyez sur Entrée pour envoyer un message de requête à votre fonction.

4. Lorsque la fonction s’exécute localement et retourne une réponse, une notification est déclenchée dans Visual Studio Code. Les informations relatives à l’exécution de la fonction sont affichées dans le panneau Terminal.

5. Appuyez sur Ctrl+C pour arrêter Core Tools et déconnecter le débogueur.

Exécuter la fonction localement

1. Comme dans l'article précédent, appuyez sur F5 pour démarrer le projet d'application de fonction et les Core Tools.

2. Une fois les outils principaux en cours d’exécution, accédez à la zone Azure : Functions. Sous Functions, développez Local Project>Functions. Cliquez avec le bouton droit (Ctrl-clic sur Mac) sur la fonction HttpExample, puis sélectionnez Exécuter la fonction maintenant.

   

3. Dans le corps de la requête Enter, vous voyez la valeur du corps du message de requête de { "name": "Azure" }. Appuyez sur Entrée pour envoyer ce message de demande à votre fonction.

4. Une fois la réponse retournée, appuyez sur Ctrl+C pour arrêter Core Tools.

Comme vous utilisez le storage connection string, votre fonction se connecte au compte Azure storage lors de l'exécution locale. Une nouvelle file d’attente nommée outqueue est créée dans votre compte storage par le runtime Functions lorsque la liaison de sortie est utilisée pour la première fois. Vous utiliserez Storage Explorer pour vérifier que la file d'attente a été créée avec le nouveau message.

• 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 en Java.

• Azure Functions guide du développeur Java

• 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