Connecter Azure Functions à Azure Cosmos DB avec Visual Studio Code

Avant de commencer, vous devez suivre le guide de Démarrage rapide : Créer une fonction C# dans Azure à l’aide de Visual Studio code. Si vous avez déjà nettoyé les ressources à la fin de cet article, suivez à nouveau les étapes pour recréer l’application Functions et les ressources associées dans Azure.

Avant de commencer, vous devez suivre le guide de Démarrage rapide : Créer une fonction JavaScript dans Azure à l’aide de Visual Studio code. Si vous avez déjà nettoyé les ressources à la fin de cet article, suivez à nouveau les étapes pour recréer l’application Functions et les ressources associées dans Azure.

Avant de commencer, vous devez suivre le guide de Démarrage rapide : Créer une fonction Python dans Azure à l’aide de Visual Studio Code. Si vous avez déjà nettoyé les ressources à la fin de cet article, suivez à nouveau les étapes pour recréer l’application Functions et les ressources associées dans Azure.

À 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 de terminal pour ajouter le package d’extension Azure Cosmos DB à votre projet.

dotnet add package Microsoft.Azure.Functions.Worker.Extensions.CosmosDB

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

L’utilisation des bundles d’extension est activée dans le fichier host.json, à la racine du projet, et se présente de la façon suivante :

{
  "version": "2.0",
  "logging": {
    "applicationInsights": {
      "samplingSettings": {
        "isEnabled": true,
        "excludedTypes": "Request"
      }
    }
  },
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[4.*, 5.0.0)"
  },
  "concurrency": {
    "dynamicConcurrencyEnabled": true,
    "snapshotPersistenceEnabled": true
  },
  "extensions": {
    "cosmosDB": {
      "connectionMode": "Gateway"
    }
  }
}

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

L’utilisation des bundles d’extension est activée dans le fichier host.json, à la racine du projet, et se présente de la façon suivante :

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

Dans un projet de bibliothèque de classes C#, les liaisons sont définies comme attributs de liaison sur la méthode de fonction.

Ouvrez le fichier projet HttpExample.cs et ajoutez les classes suivantes :

public class MultiResponse
{
    [CosmosDBOutput("my-database", "my-container",
        Connection = "CosmosDbConnectionSetting", CreateIfNotExists = true)]
    public MyDocument Document { get; set; }
    public HttpResponseData HttpResponse { get; set; }
}
public class MyDocument {
    public string id { get; set; }
    public string message { get; set; }
}

La classe MyDocument définit un objet qui est écrit dans la base de données. La chaîne de connexion du compte de stockage est définie par la propriété Connection. Dans ce cas, vous pourriez omettre Connection, car vous utilisez déjà le compte de stockage par défaut.

La classe MultiResponse vous permet d’écrire à la fois dans la collection spécifiée de la base de données Azure Cosmos et de retourner un message de réussite HTTP. Étant donné que vous devez retourner un objet MultiResponse, vous devez également mettre à jour la signature de la méthode.

Des attributs spécifiques définissent le nom du conteneur et le nom de sa base de données parente. La chaîne de connexion pour votre compte Azure Cosmos DB est définie par CosmosDbConnectionSetting.

Les attributs de liaison sont définis directement dans votre code de fonction. La configuration de sortie d’Azure Cosmos DB décrit les champs requis pour une liaison de sortie d’Azure Cosmos DB.

Pour ce scénario MultiResponse, vous devez ajouter une liaison de sortie extraOutputs à la fonction.

app.http('HttpExample', {
  methods: ['GET', 'POST'],
  extraOutputs: [sendToCosmosDb],
  handler: async (request, context) => {

Ajoutez les propriétés suivantes à la configuration de liaison :

const sendToCosmosDb = output.cosmosDB({
  databaseName: 'my-database',
  containerName: 'my-container',
  createIfNotExists: false,
  connection: 'CosmosDBConnectionString',
});

Les attributs de liaison sont définis directement dans le fichier function_app.py. Vous utilisez le décorateur cosmos_db_output pour ajouter une liaison de sortie Azure Cosmos DB :

@app.cosmos_db_output(arg_name="outputDocument", database_name="my-database", 
    container_name="my-container", connection="CosmosDbConnectionSetting")

Dans ce code, arg_name identifie le paramètre de liaison référencé dans votre code. database_name et container_name sont les noms de la base de données et de la collection où la liaison écrit, et connection est le nom d’un paramètre d’application contenant la chaîne de connexion pour le compte Azure Cosmos DB, qui se trouve dans le paramètre CosmosDbConnectionSetting du fichier local.settings.json.

Remplacez la méthode Run existante par le code suivant :

[Function("HttpExample")]
public static MultiResponse Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestData req,
    FunctionContext executionContext)
{
    var logger = executionContext.GetLogger("HttpExample");
    logger.LogInformation("C# HTTP trigger function processed a request.");

    var message = "Welcome to Azure Functions!";

    var response = req.CreateResponse(HttpStatusCode.OK);
    response.Headers.Add("Content-Type", "text/plain; charset=utf-8");
    response.WriteString(message);

    // Return a response to both HTTP trigger and Azure Cosmos DB output binding.
    return new MultiResponse()
    {
         Document = new MyDocument
        {
            id = System.Guid.NewGuid().ToString(),
            message = message
        },
        HttpResponse = response
    };
}

Ajoutez du code qui utilise l’objet de liaison de sortie extraInputs sur context pour envoyer un document JSON à la fonction de liaison de sortie nommée, sendToCosmosDb. Ajoutez ce code avant l’instruction return.

context.extraOutputs.set(sendToCosmosDb, {
  // create a random ID
  id:
    new Date().toISOString() + Math.random().toString().substring(2, 10),
  name: name,
});

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

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

const sendToCosmosDb = output.cosmosDB({
  databaseName: 'my-database',
  containerName: 'my-container',
  createIfNotExists: false,
  connection: 'CosmosDBConnectionString',
});

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

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

      if (!name) {
        return { status: 404, body: 'Missing required data' };
      }

      // Output to Database
      context.extraOutputs.set(sendToCosmosDb, {
        // create a random ID
        id:
          new Date().toISOString() + Math.random().toString().substring(2, 10),
        name: name,
      });

      const responseMessage = name
        ? 'Hello, ' +
          name +
          '. This HTTP triggered function executed successfully.'
        : 'This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response.';

      // Return to HTTP client
      return { body: responseMessage };
    } catch (error) {
      context.log(`Error: ${error}`);
      return { status: 500, body: 'Internal Server Error' };
    }
  },
});

Ce code retourne à présent un objet MultiResponse qui contient à la fois un document et une réponse HTTP.

Mettez à jour HttpExample\function_app.py pour qu’il corresponde au code suivant. Ajoutez le paramètre outputDocument à la définition de fonction et outputDocument.set() sous l’instruction if name: :

import azure.functions as func
import logging

app = func.FunctionApp()

@app.function_name(name="HttpTrigger1")
@app.route(route="hello", auth_level=func.AuthLevel.ANONYMOUS)
@app.queue_output(arg_name="msg", queue_name="outqueue", connection="AzureWebJobsStorage")
@app.cosmos_db_output(arg_name="outputDocument", database_name="my-database", container_name="my-container", connection="CosmosDbConnectionSetting")
def test_function(req: func.HttpRequest, msg: func.Out[func.QueueMessage],
    outputDocument: func.Out[func.Document]) -> func.HttpResponse:
     logging.info('Python HTTP trigger function processed a request.')
     logging.info('Python Cosmos DB 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:
        outputDocument.set(func.Document.from_dict({"id": name}))
        msg.set(name)
        return func.HttpResponse(f"Hello {name}!")
     else:
        return func.HttpResponse(
                    "Please pass a name on the query string or in the request body",
                    status_code=400
                )

Le {"id": "name"} du document est créé dans la collection de bases de données spécifiée dans la liaison.

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 : Functions. Sous Fonctions, développez Projet local>Fonctions. Cliquez avec le bouton droit (Ctrl-clic sur Mac) sur la fonction HttpExample, puis choisissez Exécuter la fonction maintenant.

   

3. Dans Entrer le corps de la demande figure la valeur { "name": "Azure" } pour le corps du message de la demande. 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.

• 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 Python

• Guide du développeur Python sur Azure Functions