Partage via

Liaison de sortie Azure Cosmos DB pour Azure Functions 2.x et versions ultérieures

  • Article

La liaison de sortie Azure Cosmos DB vous permet d’écrire un nouveau document dans une base de données Azure Cosmos DB en utilisant l’API SQL.

Pour plus d’informations sur les détails d’installation et de configuration, consultez la vue d’ensemble.

Important

Cet article utilise des onglets pour prendre en charge plusieurs versions du modèle de programmation Node.js. Le modèle v4 est en disponibilité générale. Il est conçu pour offrir une expérience plus flexible et intuitive aux développeurs JavaScript et TypeScript. Pour plus d’informations sur le fonctionnement du modèle v4, reportez-vous au guide du développeur Azure Functions Node.js. Pour plus d’informations sur les différences entre v3 et v4, consultez le guide de migration.

Azure Functions prend en charge deux modèles de programmation pour Python. La façon dont vous définissez vos liaisons dépend du modèle de programmation choisi.

Le modèle de programmation Python v2 vous permet de définir des liaisons à l'aide d’éléments décoratifs directement dans le code de votre fonction Python. Pour plus d’informations, consultez le guide des développeurs Python.

Cet article prend en compte les deux modèles de programmation.

Une fonction C# peut être créée à l’aide de l’un des modes C# suivants :

  • Modèle worker isolé : fonction C# compilée exécutée dans un processus worker isolé du runtime. Le processus Worker isolé est requis pour prendre en charge les fonctions C# exécutées sur les versions LTS et non-LTS de .NET et de .NET Framework. Les extensions pour les fonctions de processus de travail isolés utilisent des espaces de noms Microsoft.Azure.Functions.Worker.Extensions.*.
  • Modèle In-process : fonction C# compilée exécutée dans le même processus que le runtime Functions. Dans une variation de ce modèle, Functions peut être exécuté à l’aide de scripts C#, principalement pris en charge pour la modification du portail C#. Les extensions pour les fonctions in-process utilisent des espaces de noms Microsoft.Azure.WebJobs.Extensions.*.

Important

La prise en charge du modèle in-process prendra fin le 10 novembre 2026. Pour continuer à bénéficier d’une prise en charge complète, nous vous recommandons vivement de migrer vos applications vers le modèle worker isolé.

Exemple

Sauf indication contraire, les exemples de cet article ciblent la version 3.x de l'extension Azure Cosmos DB. Pour une utilisation avec l’extension version 4.x, vous devez remplacer la chaîne collection dans les noms de propriétés et d’attributs par container et connection_string_setting par connection.

Le code suivant définit un type MyDocument :

public class MyDocument
{
    public string? Id { get; set; }

    public string? Text { get; set; }

    public int Number { get; set; }

    public bool Boolean { get; set; }
}

Dans l’exemple suivant, le type de retour est un IReadOnlyList<T>, qui est une liste de documents modifiée à partir du paramètre de liaison du déclencheur :

using System.Collections.Generic;
using System.Linq;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;

namespace SampleApp
{
    public class CosmosDBFunction
    {
        private readonly ILogger<CosmosDBFunction> _logger;

        public CosmosDBFunction(ILogger<CosmosDBFunction> logger)
        {
            _logger = logger;
        }

        //<docsnippet_exponential_backoff_retry_example>
        [Function(nameof(CosmosDBFunction))]
        [ExponentialBackoffRetry(5, "00:00:04", "00:15:00")]
        [CosmosDBOutput("%CosmosDb%", "%CosmosContainerOut%", Connection = "CosmosDBConnection", CreateIfNotExists = true)]
        public object? Run(
            [CosmosDBTrigger(
                "%CosmosDb%",
                "%CosmosContainerIn%",
                Connection = "CosmosDBConnection",
                LeaseContainerName = "leases",
                CreateLeaseContainerIfNotExists = true)] IReadOnlyList<MyDocument> input,
            FunctionContext context)
        {
            if (input != null && input.Any())
            {
                foreach (var doc in input)
                {
                    _logger.LogInformation("Doc Id: {id}", doc.Id);
                }

                // Cosmos Output
                return input.Select(p => new { id = p.Id });
            }

            return null;
        }
        //</docsnippet_exponential_backoff_retry_example>
    }

Déclencheur de file d’attente, enregistrer un message dans un base de données via une valeur de retour

L’exemple suivant montre une fonction Java qui ajoute un document à une base de données, à l’aide des données fournies dans un message de Stockage File d’attente.

@FunctionName("getItem")
@CosmosDBOutput(name = "database",
  databaseName = "ToDoList",
  collectionName = "Items",
  connectionStringSetting = "AzureCosmosDBConnection")
public String cosmosDbQueryById(
    @QueueTrigger(name = "msg",
      queueName = "myqueue-items",
      connection = "AzureWebJobsStorage")
    String message,
    final ExecutionContext context)  {
     return "{ id: \"" + System.currentTimeMillis() + "\", Description: " + message + " }";
   }

Déclencheur HTTP, enregistrer un document dans une base de données via une valeur de retour

L’exemple suivant illustre une fonction Java dont la signature est annotée avec @CosmosDBOutput et a une valeur de retour de type String. Le document JSON retourné par la fonction sera automatiquement écrit dans la collection Azure Cosmos DB correspondante.

    @FunctionName("WriteOneDoc")
    @CosmosDBOutput(name = "database",
      databaseName = "ToDoList",
      collectionName = "Items",
      connectionStringSetting = "Cosmos_DB_Connection_String")
    public String run(
            @HttpTrigger(name = "req",
              methods = {HttpMethod.GET, HttpMethod.POST},
              authLevel = AuthorizationLevel.ANONYMOUS)
            HttpRequestMessage<Optional<String>> request,
            final ExecutionContext context) {

        // Item list
        context.getLogger().info("Parameters are: " + request.getQueryParameters());

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

        // Generate random ID
        final int id = Math.abs(new Random().nextInt());

        // Generate document
        final String jsonDocument = "{\"id\":\"" + id + "\", " +
                                    "\"description\": \"" + name + "\"}";

        context.getLogger().info("Document to be saved: " + jsonDocument);

        return jsonDocument;
    }

Déclencheur HTTP, enregistrer un document dans une base de données via OutputBinding

L’exemple suivant illustre une fonction Java qui écrit un document dans Azure Cosmos DB via un paramètre de sortie OutputBinding<T>. Dans cet exemple, le paramètre outputItem doit être annoté avec @CosmosDBOutput, non la signature de la fonction. L’utilisation de OutputBinding<T> permet à votre fonction de tirer parti de la liaison pour écrire le document dans Azure Cosmos DB tout en permettant aussi de retourner une valeur différente à l’appelant de la fonction, telle qu’un document JSON ou XML.

    @FunctionName("WriteOneDocOutputBinding")
    public HttpResponseMessage run(
            @HttpTrigger(name = "req",
              methods = {HttpMethod.GET, HttpMethod.POST},
              authLevel = AuthorizationLevel.ANONYMOUS)
            HttpRequestMessage<Optional<String>> request,
            @CosmosDBOutput(name = "database",
              databaseName = "ToDoList",
              collectionName = "Items",
              connectionStringSetting = "Cosmos_DB_Connection_String")
            OutputBinding<String> outputItem,
            final ExecutionContext context) {

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

        // Item list
        context.getLogger().info("Parameters are: " + request.getQueryParameters());

        // Generate random ID
        final int id = Math.abs(new Random().nextInt());

        // Generate document
        final String jsonDocument = "{\"id\":\"" + id + "\", " +
                                    "\"description\": \"" + name + "\"}";

        context.getLogger().info("Document to be saved: " + jsonDocument);

        // Set outputItem's value to the JSON document to be saved
        outputItem.setValue(jsonDocument);

        // return a different document to the browser or calling client.
        return request.createResponseBuilder(HttpStatus.OK)
                      .body("Document created successfully.")
                      .build();
    }

Déclencheur HTTP, enregistrer plusieurs documents dans une base de données via OutputBinding

L’exemple suivant illustre une fonction Java qui écrit plusieurs documents dans Azure Cosmos DB via un paramètre de sortie OutputBinding<T>. Dans cet exemple, le paramètre outputItem est annoté avec @CosmosDBOutput, non la signature de la fonction. Le paramètre de sortie, outputItem, possède une liste d’objets ToDoItem comme type de paramètre de modèle. L’utilisation de OutputBinding<T> permet à votre fonction de tirer parti de la liaison pour écrire le document dans Azure Cosmos DB tout en permettant aussi de retourner une valeur différente à l’appelant de la fonction, telle qu’un document JSON ou XML.

    @FunctionName("WriteMultipleDocsOutputBinding")
    public HttpResponseMessage run(
            @HttpTrigger(name = "req",
              methods = {HttpMethod.GET, HttpMethod.POST},
              authLevel = AuthorizationLevel.ANONYMOUS)
            HttpRequestMessage<Optional<String>> request,
            @CosmosDBOutput(name = "database",
              databaseName = "ToDoList",
              collectionName = "Items",
              connectionStringSetting = "Cosmos_DB_Connection_String")
            OutputBinding<List<ToDoItem>> outputItem,
            final ExecutionContext context) {

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

        // Item list
        context.getLogger().info("Parameters are: " + request.getQueryParameters());

        // Generate documents
        List<ToDoItem> items = new ArrayList<>();

        for (int i = 0; i < 5; i ++) {
          // Generate random ID
          final int id = Math.abs(new Random().nextInt());

          // Create ToDoItem
          ToDoItem item = new ToDoItem(String.valueOf(id), name);

          items.add(item);
        }

        // Set outputItem's value to the list of POJOs to be saved
        outputItem.setValue(items);
        context.getLogger().info("Document to be saved: " + items);

        // return a different document to the browser or calling client.
        return request.createResponseBuilder(HttpStatus.OK)
                      .body("Documents created successfully.")
                      .build();
    }

Dans la bibliothèque du runtime des fonctions Java, utilisez l’annotation @CosmosDBOutput sur les paramètres qui seraient écrits sur Azure Cosmos DB. Le type de paramètre d’annotation doit être OutputBinding<T>, où T désigne un type Java natif ou un POJO.

L’exemple ci-dessous montre une fonction TypeScript déclenchée par une file d’attente de stockage pour une file d’attente qui reçoit des données JSON au format suivant :

{
    "name": "John Henry",
    "employeeId": "123456",
    "address": "A town nearby"
}

La fonction crée des documents Azure Cosmos DB au format suivant pour chaque enregistrement :

{
    "id": "John Henry-123456",
    "name": "John Henry",
    "employeeId": "123456",
    "address": "A town nearby"
}

Voici le code TypeScript :

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

interface MyQueueItem {
    name: string;
    employeeId: string;
    address: string;
}

interface MyCosmosItem {
    id: string;
    name: string;
    employeeId: string;
    address: string;
}

export async function storageQueueTrigger1(queueItem: MyQueueItem, context: InvocationContext): Promise<MyCosmosItem> {
    return {
        id: `${queueItem.name}-${queueItem.employeeId}`,
        name: queueItem.name,
        employeeId: queueItem.employeeId,
        address: queueItem.address,
    };
}

app.storageQueue('storageQueueTrigger1', {
    queueName: 'inputqueue',
    connection: 'MyStorageConnectionAppSetting',
    return: output.cosmosDB({
        databaseName: 'MyDatabase',
        collectionName: 'MyCollection',
        createIfNotExists: true,
        connectionStringSetting: 'MyAccount_COSMOSDB',
    }),
    handler: storageQueueTrigger1,
});

Pour sortir plusieurs documents, retournez un tableau au lieu d’un seul objet. Par exemple :

return [
    {
        id: 'John Henry-123456',
        name: 'John Henry',
        employeeId: '123456',
        address: 'A town nearby',
    },
    {
        id: 'John Doe-123457',
        name: 'John Doe',
        employeeId: '123457',
        address: 'A town far away',
    },
];

L’exemple ci-dessous montre une fonction JavaScript déclenchée par une file d’attente de stockage pour une file d’attente qui reçoit des données JSON au format suivant :

{
    "name": "John Henry",
    "employeeId": "123456",
    "address": "A town nearby"
}

La fonction crée des documents Azure Cosmos DB au format suivant pour chaque enregistrement :

{
    "id": "John Henry-123456",
    "name": "John Henry",
    "employeeId": "123456",
    "address": "A town nearby"
}

Voici le code JavaScript :

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

const cosmosOutput = output.cosmosDB({
    databaseName: 'MyDatabase',
    collectionName: 'MyCollection',
    createIfNotExists: true,
    connectionStringSetting: 'MyAccount_COSMOSDB',
});

app.storageQueue('storageQueueTrigger1', {
    queueName: 'inputqueue',
    connection: 'MyStorageConnectionAppSetting',
    return: cosmosOutput,
    handler: (queueItem, context) => {
        return {
            id: `${queueItem.name}-${queueItem.employeeId}`,
            name: queueItem.name,
            employeeId: queueItem.employeeId,
            address: queueItem.address,
        };
    },
});

Pour sortir plusieurs documents, retournez un tableau au lieu d’un seul objet. Par exemple :

return [
    {
        id: 'John Henry-123456',
        name: 'John Henry',
        employeeId: '123456',
        address: 'A town nearby',
    },
    {
        id: 'John Doe-123457',
        name: 'John Doe',
        employeeId: '123457',
        address: 'A town far away',
    },
];

L’exemple suivant montre comment écrire des données dans Azure Cosmos DB à l’aide d’une liaison de sortie. La liaison, déclarée dans le fichier de configuration de la fonction (functions.json), extrait des données d’un message de file d’attente et écrit dans un document Azure Cosmos DB.

{ 
  "name": "EmployeeDocument",
  "type": "cosmosDB",
  "databaseName": "MyDatabase",
  "collectionName": "MyCollection",
  "createIfNotExists": true,
  "connectionStringSetting": "MyStorageConnectionAppSetting",
  "direction": "out" 
}

Dans le fichier run.ps1, l’objet retourné par la fonction est mis en correspondance avec un objet EmployeeDocument, qui est conservé dans la base de données.

param($QueueItem, $TriggerMetadata) 

Push-OutputBinding -Name EmployeeDocument -Value @{ 
    id = $QueueItem.name + '-' + $QueueItem.employeeId 
    name = $QueueItem.name 
    employeeId = $QueueItem.employeeId 
    address = $QueueItem.address 
}

L’exemple suivant montre comment écrire un document dans une base de données Azure Cosmos DB comme sortie d’une fonction. L’exemple varie selon l’utilisation du modèle de programmation Python v1 ou v2.

import logging
import azure.functions as func

app = func.FunctionApp()

@app.route()
@app.cosmos_db_output(arg_name="documents", 
                      database_name="DB_NAME",
                      collection_name="COLLECTION_NAME",
                      create_if_not_exists=True,
                      connection_string_setting="CONNECTION_SETTING")
def main(req: func.HttpRequest, documents: func.Out[func.Document]) -> func.HttpResponse:
    request_body = req.get_body()
    documents.set(func.Document.from_json(request_body))
    return 'OK'

Attributs

Les bibliothèques C# in-process et de processus Worker isolé utilisent des attributs pour définir la fonction. Le script C# utilise à la place un fichier de configuration function.json comme décrit dans le guide de script C#.

Propriété d’attribut Description
Connection Nom d’un paramètre d’application ou d’une collection de paramètres qui spécifie la façon de se connecter au compte Azure Cosmos DB qui est surveillé. Pour plus d’informations, consultez Connexions.
DatabaseName Nom de la base de données Azure Cosmos DB contenant le conteneur analysé.
ContainerName Nom du conteneur surveillé.
CreateIfNotExists Valeur booléenne indiquant si le conteneur doit être créé s’il n’existe pas encore. La valeur par défaut est false, car les nouveaux conteneurs sont créés avec un débit réservé, ce qui a des conséquences sur la tarification. Pour plus d’informations, consultez la page relative aux prix appliqués.
PartitionKey Lorsque CreateIfNotExists a la valeur true, définit le chemin de la clé de partition pour le conteneur créé. Peut inclure des paramètres de liaison.
ContainerThroughput Lorsque CreateIfNotExists a la valeur true, définit le débit du conteneur créé.
PreferredLocations (Facultatif) Définit les endroits par défaut (régions) des comptes de base de données géorépliqués dans le service Azure Cosmos DB. Les valeurs doivent être séparées par des virgules. Par exemple : East US,South Central US,North Europe.

Décorateurs

S’applique uniquement au modèle de programmation Python v2.

Pour les fonctions Python v2 définies à l’aide d’un élément décoratif, les propriétés suivantes sur cosmos_db_output :

Propriété Description
arg_name Nom de variable utilisé dans le code de fonction, qui représente la liste des documents modifiés.
database_name Nom de la base de données Azure Cosmos DB contenant la collection surveillée.
collection_name Le nom de la collection Azure Cosmos DB est surveillé.
create_if_not_exists Valeur booléenne qui indique si la base de données et la collection doivent être créées si elles n’existent pas.
connection_string_setting Chaîne de connexion d’Azure Cosmos DB surveillée.

Pour les fonctions Python définies à l’aide de function.json, consultez la section Configuration.

Annotations

Dans la bibliothèque du runtime des fonctions Java, utilisez l’annotation @CosmosDBOutput sur des paramètres qui écrivent dans Azure Cosmos DB. L’annotation prend en charge les propriétés suivantes :

Configuration

S’applique uniquement au modèle de programmation Python v1.

Le tableau suivant explique les propriétés que vous pouvez définir pour l’objet options passé à la méthode output.cosmosDB(). Les propriétés type, direction et name ne s’appliquent pas au modèle v4.

Le tableau suivant décrit les propriétés de configuration de la liaison que vous définissez dans le fichier function.json, où les propriétés diffèrent selon la version de l’extension :

Propriété function.json Description
connection Nom d’un paramètre d’application ou d’une collection de paramètres qui spécifie la façon de se connecter au compte Azure Cosmos DB qui est surveillé. Pour plus d’informations, consultez Connexions.
databaseName Nom de la base de données Azure Cosmos DB contenant le conteneur analysé.
containerName Nom du conteneur surveillé.
createIfNotExists Valeur booléenne indiquant si le conteneur doit être créé s’il n’existe pas encore. La valeur par défaut est false, car les nouveaux conteneurs sont créés avec un débit réservé, ce qui a des conséquences sur la tarification. Pour plus d’informations, consultez la page relative aux prix appliqués.
partitionKey Lorsque createIfNotExists a la valeur true, définit le chemin de la clé de partition pour le conteneur créé. Peut inclure des paramètres de liaison.
containerThroughput Lorsque createIfNotExists a la valeur true, définit le débit du conteneur créé.
preferredLocations (Facultatif) Définit les endroits par défaut (régions) des comptes de base de données géorépliqués dans le service Azure Cosmos DB. Les valeurs doivent être séparées par des virgules. Par exemple : East US,South Central US,North Europe.

Pour obtenir des exemples complets, consultez la section Exemple.

Usage

Par défaut, lorsque vous écrivez dans le paramètre de sortie de votre fonction, un document est créé dans votre base de données. Vous devez spécifier l’ID du document de sortie en spécifiant la propriété id dans l’objet JSON transmis au paramètre de sortie.

Remarque

Lorsque vous spécifier l’ID d’un document existant, il est remplacé par le nouveau document de sortie.

Le type de paramètre pris en charge par la liaison de sortie Cosmos DB dépend de la version du runtime Functions, de la version du package d’extension et de la modalité C# utilisée.

Lorsque vous souhaitez que la fonction écrive dans un seul document, la liaison de sortie de Cosmos DB peut se lier aux types suivants :

Type Description
Types sérialisables JSON Objet représentant le contenu JSON d'un document. Functions tente de sérialiser un type d'objet CLR traditionnel (OCT) en données JSON.

Lorsque vous souhaitez que la fonction écrive dans plusieurs documents, la liaison de sortie Cosmos DB peut se lier aux types suivants :

Type Description
T[] where Test un type sérialisable JSON Tableau contenant plusieurs documents. Chaque entrée représente un document.

Pour d’autres scénarios de sortie, créez et utilisez un CosmosClient avec d’autres types de Microsoft.Azure.Cosmos directement. Consultez Inscrire des clients Azure pour obtenir un exemple d’utilisation de l’injection de dépendances pour créer un type de client à partir du Kit de développement logiciel (SDK) Azure.

Connexions

Les propriétés connectionStringSetting/connection et leaseConnectionStringSetting/leaseConnection sont des références à la configuration de l’environnement qui spécifie la façon dont l’application doit se connecter à Azure Cosmos DB. Elles peuvent spécifier :

  • Le nom d’un paramètre d’application contenant une chaîne de connexion
  • Le nom d’un préfixe partagé pour plusieurs paramètres d’application, définissant ensemble une connexion basée sur l’identité. Cette option n’est disponible que pour les versions connection et leaseConnection de la connection.

Si la valeur configurée est à la fois une correspondance exacte pour un paramètre unique et une correspondance de préfixe pour d’autres paramètres, la correspondance exacte est utilisée.

Chaîne de connexion

La chaîne de connexion de votre compte de base de données doit être stockée dans un paramètre d’application dont le nom correspond à la valeur spécifiée par la propriété de connexion de la configuration de la liaison.

Connexions basées sur l’identité

Si vous utilisez la version 4.x ou ultérieure de l’extension, au lieu d’utiliser une chaîne de connexion avec un secret, vous pouvez faire en sorte que l’application utilise une identité Microsoft Entra. Pour ce faire, vous devez définir les paramètres sous un préfixe commun qui correspond à la propriété de connexion dans la configuration des déclencheurs et des liaisons.

Dans ce mode, l’extension nécessite les propriétés suivantes :

Propriété Modèle de variable d’environnement Description Valeur d'exemple
Point de terminaison de compte <CONNECTION_NAME_PREFIX>__accountEndpoint URI du point de terminaison du compte Azure Cosmos DB. https://<database_account_name>.documents.azure.com:443/

Des propriétés supplémentaires peuvent être définies pour personnaliser la connexion. Consultez Propriétés communes pour les connexions basées sur l’identité.

Quand elles sont hébergées dans le service Azure Functions, les connexions basées sur une identité utilisent une identité managée. L’identité attribuée par le système est utilisée par défaut, bien qu’une identité attribuée par l’utilisateur puisse être spécifiée avec les propriétés credential et clientID. Notez que la configuration d’une identité affectée par l’utilisateur avec un ID de ressource n’est pas prise en charge. Lors d’une exécution dans d’autres contextes, tels que le développement local, votre identité de développeur est utilisée à la place, même si cela peut être personnalisé. Consultez Développement local avec connexions basées sur une identité.

Accorder l’autorisation à l’identité

Quelle que soit l’identité utilisée, elle doit avoir les autorisations nécessaires pour effectuer les actions prévues. Pour la plupart des services Azure, cela signifie que vous devez attribuer un rôle dans Azure RBAC en utilisant des rôles intégrés ou personnalisés qui fournissent ces autorisations.

Important

Parmi les autorisations exposées par le service cible, certaines ne sont peut-être pas nécessaires pour tous les contextes. Dans la mesure du possible, adhérez au principe du privilège minimum, en accordant à l’identité uniquement les privilèges nécessaires. Par exemple, si l’application a juste besoin de pouvoir lire à partir d’une source de données, utilisez un rôle qui a uniquement l’autorisation de lecture. Il serait inapproprié d’attribuer un rôle qui autorise aussi l’écriture dans ce service, car ce serait une autorisation excessive pour une opération de lecture. De même, vous voudrez vous assurer que l’attribution de rôle est limitée aux seules ressources qui doivent être lues.

Cosmos DB n’utilise pas Azure RBAC pour les opérations de données. Au lieu de cela, il utilise un système RBAC intégré à Cosmos DB qui repose sur des concepts similaires. Vous devrez créer une attribution de rôle qui donne accès à votre compte de base de données au moment de l’exécution. Les rôles de gestion Azure RBAC comme Propriétaire ne sont pas suffisants. Le tableau suivant présente les rôles intégrés qui sont recommandés lors de l’utilisation de l’extension Azure Cosmos DB dans le cadre d’un fonctionnement normal. Votre application peut nécessiter des autorisations supplémentaires en fonction du code que vous écrivez.

Type de liaison Exemples de rôles intégrés1
Déclencheur2 Contributeur de données intégré Cosmos DB
Liaison d’entrée Lecteur de données intégré Cosmos DB
Liaison de sortie Contributeur de données intégré Cosmos DB

1 Ces rôles ne peuvent pas être utilisés dans une attribution de rôle Azure RBAC. Pour plus d’informations sur l’attribution de ces rôles, consultez la documentation du Système RBAC intégré à Cosmos DB.

2 Lors de l’utilisation de l’identité, Cosmos DB traite la création de conteneurs comme une opération de gestion. Il n’est pas disponible en tant qu’opération de plan de données pour le déclencheur. Vous devez vous assurer de créer les conteneurs nécessaires au déclencheur (y compris le conteneur de bail) avant de configurer votre fonction.

Exceptions et codes de retour

Liaison Informations de référence
Azure Cosmos DB Codes d’état HTTP pour Azure Cosmos DB

Étapes suivantes