Connecter Azure Functions à Stockage Azure avec Visual Studio Code

• Installez les outils CLI .NET Core.

• Suivez les étapes de la partie 1 du guide de démarrage rapide de Visual Studio Code.

• Suivez les étapes de la partie 1 du guide de démarrage rapide de Visual Studio Code.

• Suivez les étapes de la partie 1 du guide de démarrage rapide de Visual Studio Code.

• Suivez les étapes de la partie 1 du guide de démarrage rapide de Visual Studio Code.

• Suivez les étapes de la partie 1 du guide de démarrage rapide de Visual Studio Code.

• Suivez les étapes de la partie 1 du guide de démarrage rapide de Visual Studio Code.

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

Un bundle d’extension est déjà activé dans le fichier host.json, à la racine du projet, et devrait se présenter comme 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 projet a été configuré pour utiliser des bundles d’extension, et installe automatiquement un ensemble prédéfini de packages d’extension.

Un bundle d’extension est déjà activé dans le fichier host.json, à la racine du projet, et devrait se présenter comme 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 stockage Azure :

• 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 = output.storageQueue({
    queueName: 'outqueue',
    connection: 'AzureWebJobsStorage',
  });
  

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

• 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',
  });
  

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 la sortie de la file d’attente décrit les champs requis pour une liaison de file d’attente Stockage Azure. 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 l’élément décoratif queue_output pour ajouter une liaison de sortie de file d'attente Azure.

En utilisant l’élément décoratif queue_output, la direction de liaison est implicitement « out » et le type est File d’attente de stockage Azure. Ajoutez l’élément décoratif suivant au code de votre fonction dans HttpExample\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 sur laquelle la liaison écrit et connection est le nom d’un paramètre d’application qui contient la chaîne de connexion pour le compte de stockage. Dans les démarrages rapides, vous utilisez le même compte de stockage que l’application de fonction, 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 projet C#, les liaisons sont définies comme des 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 HttpResponseData HttpResponse { get; set; }
}

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

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

Dans un projet Java, les liaisons sont définies comme 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 projet Function.java, puis ajoutez le paramètre suivant à la définition de la 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 à une liaison de sortie quand la fonction se termine. Dans ce cas, la sortie est une file d’attente de stockage nommée outqueue. La chaîne de connexion pour le compte de stockage est définie par la méthode connection. Au lieu de passer la chaîne de connexion proprement dite, vous passez le paramètre d’application qui contient la chaîne de connexion du compte de stockage.

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 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
})

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 de la 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.

À 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 de recourir au code du Kit de développement logiciel (SDK) Stockage Azure pour l’authentification, l’obtention d’une référence de file d’attente ou l’écriture de 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 projet Function.java 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 à Azure Functions Core Tools pour vous permettre d’exécuter ce projet sur votre ordinateur de développement local avant toute publication sur Azure. Si Core Tools n’est pas déjà installé localement, vous êtes invité à l’installer la première fois que vous exécutez votre projet.

1. Pour appeler votre fonction, appuyez sur F5 pour démarrer le projet d’application de fonction. 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 Core Tools n’est pas déjà installé, sélectionnez Installer pour installer Core Tools lorsque vous y êtes invité.
   Si vous rencontrez des problèmes d’exécution sur Windows, assurez-vous que le terminal par défaut pour Visual Studio Code n’est pas défini sur WSL Bash.

2. Une fois Core Tools en cours d’exécution, accédez à la zone Azure : Fonctions. Sous Fonctions, développez Projet local>Fonctions. 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. Quand la fonction s’exécute localement et retourne une réponse, une notification est généré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 Core Tools.

2. Une fois Core Tools en cours d’exécution, accédez à la zone Azure : Fonctions. Sous Fonctions, développez Projet local>Fonctions. Cliquez avec le bouton droit (Ctrl-clic sur Mac) sur la fonction HttpExample, puis sélectionnez Exécuter la fonction maintenant.

   

3. Dans Entrer le corps de la requête, vous pouvez voir la valeur du corps du message 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.

Dans la mesure où vous utilisez la chaîne de connexion de stockage, votre fonction se connecte au compte de stockage Azure quand elle s’exécute localement. Le runtime Functions crée une file d’attente nommée outqueue dans votre compte de stockage lors de la première utilisation de la liaison de sortie. Vous allez utiliser l’Explorateur Stockage pour vérifier que la file d’attente a été créée ainsi que le nouveau message.

• Exemples de projets Functions complets en C#.

• Informations de référence pour les développeurs C# sur Azure Functions

• Exemples de projets Functions complets en JavaScript.

• Guide des développeurs JavaScript sur Azure Functions

• Exemples de projets Functions complets en Java.

• Guide des développeurs Java sur Azure Functions

• Exemples de projets Functions complets en TypeScript.

• Guide du développeur TypeScript sur Azure Functions

• Exemples de projets Functions complets en Python

• Guide du développeur Python sur Azure Functions

• Exemples de projets Functions complets dans PowerShell.

• Guide du développeur PowerShell sur Azure Functions