Azure Cosmos DB-uitvoerbinding voor Azure Functions 2.x en hoger

  • Artikel

Met de Azure Cosmos DB-uitvoerbinding kunt u een nieuw document schrijven naar een Azure Cosmos DB-database met behulp van de SQL-API.

Zie het overzicht voor informatie over het instellen en configureren van details.

Belangrijk

In dit artikel worden tabbladen gebruikt ter ondersteuning van meerdere versies van het Node.js programmeermodel. Het v4-model is algemeen beschikbaar en is ontworpen voor een flexibelere en intuïtievere ervaring voor JavaScript- en TypeScript-ontwikkelaars. Raadpleeg de ontwikkelaarshandleiding voor Azure Functions Node.js voor meer informatie over hoe het v4-model werkt. Raadpleeg de migratiehandleiding voor meer informatie over de verschillen tussen v3 en v4.

Azure Functions ondersteunt twee programmeermodellen voor Python. De manier waarop u uw bindingen definieert, is afhankelijk van het gekozen programmeermodel.

Met het Python v2-programmeermodel kunt u bindingen definiëren met behulp van decorators rechtstreeks in uw Python-functiecode. Zie de Ontwikkelaarshandleiding voor Python voor meer informatie.

Dit artikel ondersteunt beide programmeermodellen.

U kunt een C#-functie maken met behulp van een van de volgende C#-modi:

  • Geïsoleerd werkrolmodel: gecompileerde C#-functie die wordt uitgevoerd in een werkproces dat is geïsoleerd van de runtime. Geïsoleerd werkproces is vereist voor de ondersteuning van C#-functies die worden uitgevoerd op LTS- en niet-LTS-versies .NET en .NET Framework. Extensies voor geïsoleerde werkprocesfuncties maken gebruik van Microsoft.Azure.Functions.Worker.Extensions.* naamruimten.
  • In-process model: gecompileerde C#-functie die wordt uitgevoerd in hetzelfde proces als de Functions-runtime. In een variatie van dit model kunnen functies worden uitgevoerd met behulp van C#-scripting. Dit wordt voornamelijk ondersteund voor het bewerken van de C#-portal. Extensies voor in-process-functies maken gebruik van Microsoft.Azure.WebJobs.Extensions.* naamruimten.

Belangrijk

De ondersteuning wordt beëindigd voor het in-process model op 10 november 2026. We raden u ten zeerste aan uw apps te migreren naar het geïsoleerde werkrolmodel voor volledige ondersteuning.

Opmerking

Tenzij anders vermeld, zijn voorbeelden in dit artikel gericht op versie 3.x van de Azure Cosmos DB-extensie. Voor gebruik met extensieversie 4.x moet u de tekenreeks collection in eigenschaps- en kenmerknamen vervangen door container en connection_string_setting door connection.

Met de volgende code wordt een MyDocument type gedefinieerd:

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

    public string Text { get; set; }

    public int Number { get; set; }

    public bool Boolean { get; set; }
}

In het volgende voorbeeld is het retourtype een IReadOnlyList<T>, een gewijzigde lijst met documenten van de parameter triggerbinding:

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

Wachtrijtrigger, bericht opslaan in database via retourwaarde

In het volgende voorbeeld ziet u een Java-functie waarmee een document wordt toegevoegd aan een database met gegevens uit een bericht in Queue Storage.

@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 + " }";
   }

HTTP-trigger, één document opslaan in database via retourwaarde

In het volgende voorbeeld ziet u een Java-functie waarvan de handtekening is voorzien @CosmosDBOutput van aantekeningen en de retourwaarde van het type Stringheeft. Het JSON-document dat door de functie wordt geretourneerd, wordt automatisch geschreven naar de bijbehorende Azure Cosmos DB-verzameling.

    @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;
    }

HTTP-trigger, één document opslaan in de database via OutputBinding

In het volgende voorbeeld ziet u een Java-functie waarmee een document naar Azure Cosmos DB wordt geschreven via een OutputBinding<T> uitvoerparameter. In dit voorbeeld moet de outputItem parameter worden voorzien van aantekeningen, @CosmosDBOutputniet de functiehandtekening. Met behulp van OutputBinding<T> deze functie kunt u profiteren van de binding om het document naar Azure Cosmos DB te schrijven, terwijl u ook een andere waarde kunt retourneren aan de functie-aanroeper, zoals een JSON- of XML-document.

    @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();
    }

HTTP-trigger, meerdere documenten opslaan in database via OutputBinding

In het volgende voorbeeld ziet u een Java-functie waarmee meerdere documenten naar Azure Cosmos DB worden geschreven via een OutputBinding<T> uitvoerparameter. In dit voorbeeld wordt de outputItem parameter geannoteerd met @CosmosDBOutput, niet de functiehandtekening. De uitvoerparameter outputItem heeft een lijst ToDoItem met objecten als sjabloonparametertype. Met behulp van OutputBinding<T> kunt u uw functie profiteren van de binding om de documenten naar Azure Cosmos DB te schrijven, terwijl u ook een andere waarde kunt retourneren aan de functie-aanroeper, zoals een JSON- of XML-document.

    @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();
    }

Gebruik in de Runtime-bibliotheek van Java-functies de @CosmosDBOutput aantekening voor parameters die naar Azure Cosmos DB worden geschreven. Het parametertype annotatie moet zijn OutputBinding<T>, waarbij T het systeemeigen Java-type of een POJO is.

In het volgende voorbeeld ziet u een door een opslagwachtrij geactiveerde TypeScript-functie voor een wachtrij die JSON ontvangt in de volgende indeling:

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

Met de functie worden Azure Cosmos DB-documenten gemaakt in de volgende indeling voor elke record:

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

Dit is de TypeScript-code:

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

Als u meerdere documenten wilt uitvoeren, retourneert u een matrix in plaats van één object. Voorbeeld:

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

In het volgende voorbeeld ziet u een JavaScript-functie die door een opslagwachtrij is geactiveerd voor een wachtrij die JSON ontvangt in de volgende indeling:

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

Met de functie worden Azure Cosmos DB-documenten gemaakt in de volgende indeling voor elke record:

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

Dit is de JavaScript-code:

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

Als u meerdere documenten wilt uitvoeren, retourneert u een matrix in plaats van één object. Voorbeeld:

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

In het volgende voorbeeld ziet u hoe u gegevens naar Azure Cosmos DB schrijft met behulp van een uitvoerbinding. De binding wordt gedeclareerd in het configuratiebestand van de functie (functions.json) en haalt gegevens uit een wachtrijbericht en schrijft naar een Azure Cosmos DB-document.

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

In het bestand run.ps1 wordt het object dat is geretourneerd van de functie toegewezen aan een EmployeeDocument object, dat in de database wordt bewaard.

param($QueueItem, $TriggerMetadata) 

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

In het volgende voorbeeld ziet u hoe u een document schrijft naar een Azure Cosmos DB-database als uitvoer van een functie. Het voorbeeld is afhankelijk van of u het python-programmeermodel v1 of v2 gebruikt.

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'

Kenmerken

Zowel in-processals geïsoleerde werkproces C#-bibliotheken gebruiken kenmerken om de functie te definiëren. C#-script maakt in plaats daarvan gebruik van een function.json configuratiebestand, zoals beschreven in de handleiding voor C#-scripts.

Kenmerkeigenschap Beschrijving
Verbinding De naam van een app-instelling of verzameling die aangeeft hoe verbinding moet worden gemaakt met het Azure Cosmos DB-account dat wordt bewaakt. Zie Verbinding maken ions voor meer informatie.
Databasenaam De naam van de Azure Cosmos DB-database met de container die wordt bewaakt.
ContainerName De naam van de container die wordt bewaakt.
CreateIfNotExists Een Booleaanse waarde om aan te geven of de container wordt gemaakt wanneer deze niet bestaat. De standaardwaarde is onwaar omdat nieuwe containers worden gemaakt met gereserveerde doorvoer, wat gevolgen heeft voor de kosten. Zie voor meer informatie de pagina met prijzen.
PartitionKey Wanneer CreateIfNotExists is waar, definieert het partitiesleutelpad voor de gemaakte container. Kan bindingsparameters bevatten.
ContainerThroughput Wanneer CreateIfNotExists is waar, wordt de doorvoer van de gemaakte container gedefinieerd.
PreferredLocations (Optioneel) Definieert voorkeurslocaties (regio's) voor geo-gerepliceerde databaseaccounts in de Azure Cosmos DB-service. Waarden moeten door komma's worden gescheiden. Bijvoorbeeld: East US,South Central US,North Europe.

Decorators

Is alleen van toepassing op het Python v2-programmeermodel.

Voor Python v2-functies die zijn gedefinieerd met behulp van een decorator, zijn de volgende eigenschappen op het cosmos_db_outputvolgende:

Eigenschappen Beschrijving
arg_name De naam van de variabele die wordt gebruikt in functiecode die de lijst met documenten met wijzigingen vertegenwoordigt.
database_name De naam van de Azure Cosmos DB-database met de verzameling die wordt bewaakt.
collection_name De naam van de Azure Cosmos DB-verzameling die wordt bewaakt.
create_if_not_exists Een Booleaanse waarde die aangeeft of de database en verzameling moeten worden gemaakt als deze niet bestaan.
connection_string_setting De verbindingsreeks van de Azure Cosmos DB die wordt bewaakt.

Zie de sectie Configuratie voor Python-functies die zijn gedefinieerd met behulp van function.json.

Aantekeningen

Gebruik vanuit de Runtime-bibliotheek van Java-functies de @CosmosDBOutput aantekening voor parameters die naar Azure Cosmos DB schrijven. De aantekening ondersteunt de volgende eigenschappen:

Configuratie

Is alleen van toepassing op het Python v1-programmeermodel.

In de volgende tabel worden de eigenschappen uitgelegd die u kunt instellen voor het options object dat aan de output.cosmosDB() methode is doorgegeven. De typeeigenschappen en directionname eigenschappen zijn niet van toepassing op het v4-model.

In de volgende tabel worden de bindingsconfiguratie-eigenschappen uitgelegd die u in het function.json-bestand hebt ingesteld, waarbij de eigenschappen verschillen per extensieversie:

function.json-eigenschap Beschrijving
verbinding De naam van een app-instelling of verzameling die aangeeft hoe verbinding moet worden gemaakt met het Azure Cosmos DB-account dat wordt bewaakt. Zie Verbinding maken ions voor meer informatie.
Databasenaam De naam van de Azure Cosmos DB-database met de container die wordt bewaakt.
containerName De naam van de container die wordt bewaakt.
createIfNotExists Een Booleaanse waarde om aan te geven of de container wordt gemaakt wanneer deze niet bestaat. De standaardwaarde is onwaar omdat nieuwe containers worden gemaakt met gereserveerde doorvoer, wat gevolgen heeft voor de kosten. Zie voor meer informatie de pagina met prijzen.
partitionKey Wanneer createIfNotExists is waar, definieert het partitiesleutelpad voor de gemaakte container. Kan bindingsparameters bevatten.
containerThroughput Wanneer createIfNotExists is waar, wordt de doorvoer van de gemaakte container gedefinieerd.
preferredLocations (Optioneel) Definieert voorkeurslocaties (regio's) voor geo-gerepliceerde databaseaccounts in de Azure Cosmos DB-service. Waarden moeten door komma's worden gescheiden. Bijvoorbeeld: East US,South Central US,North Europe.

Zie de sectie Voorbeeld voor volledige voorbeelden.

Gebruik

Wanneer u naar de uitvoerparameter in uw functie schrijft, wordt er standaard een document in uw database gemaakt. Geef de document-id van het uitvoerdocument op door de id eigenschap op te geven in het JSON-object dat is doorgegeven aan de uitvoerparameter.

Notitie

Wanneer u de id van een bestaand document opgeeft, wordt het overschreven door het nieuwe uitvoerdocument.

Het parametertype dat wordt ondersteund door de Cosmos DB-uitvoerbinding, is afhankelijk van de runtimeversie van Functions, de versie van het extensiepakket en de gebruikte C#-modaliteit.

Wanneer u wilt dat de functie naar één document schrijft, kan de Cosmos DB-uitvoerbinding worden gekoppeld aan de volgende typen:

Type Description
JSON serialiseerbare typen Een object dat de JSON-inhoud van een document vertegenwoordigt. Functions probeert een normaal oud CLR-objecttype (POCO) te serialiseren in JSON-gegevens.

Wanneer u wilt dat de functie naar meerdere documenten schrijft, kan de Cosmos DB-uitvoerbinding worden gekoppeld aan de volgende typen:

Type Description
T[] waar T is JSON serialiseerbare type Een matrix met meerdere documenten. Elke vermelding vertegenwoordigt één document.

Voor andere uitvoerscenario's maakt en gebruikt u rechtstreeks typen van Microsoft.Azure.Cosmos .

Connecties

De connectionStringSetting/connection en leaseConnectionStringSetting/leaseConnection eigenschappen zijn verwijzingen naar de omgevingsconfiguratie die aangeeft hoe de app verbinding moet maken met Azure Cosmos DB. Ze kunnen het volgende opgeven:

Als de geconfigureerde waarde zowel een exacte overeenkomst is voor één instelling als een voorvoegselovereenkomst voor andere instellingen, wordt de exacte overeenkomst gebruikt.

Connection string

De verbindingsreeks voor uw databaseaccount moet worden opgeslagen in een toepassingsinstelling met een naam die overeenkomt met de waarde die is opgegeven door de verbindingseigenschap van de bindingsconfiguratie.

Op identiteit gebaseerde verbindingen

Als u versie 4.x of hoger van de extensie gebruikt, in plaats van een verbindingsreeks met een geheim te gebruiken, kunt u de app een Microsoft Entra-identiteit laten gebruiken. Hiervoor definieert u instellingen onder een gemeenschappelijk voorvoegsel dat is toegewezen aan de verbindingseigenschap in de trigger- en bindingsconfiguratie.

In deze modus vereist de extensie de volgende eigenschappen:

Eigenschappen Sjabloon voor omgevingsvariabele Beschrijving Voorbeeldwaarde
Accounteindpunt <CONNECTION_NAME_PREFIX>__accountEndpoint De eindpunt-URI van het Azure Cosmos DB-account. <https:// database_account_name.documents.azure.com:443/>

Er kunnen extra eigenschappen worden ingesteld om de verbinding aan te passen. Zie Algemene eigenschappen voor op identiteit gebaseerde verbindingen.

Wanneer deze worden gehost in de Azure Functions-service, maken identiteitsverbindingen gebruik van een beheerde identiteit. De door het systeem toegewezen identiteit wordt standaard gebruikt, hoewel een door de gebruiker toegewezen identiteit kan worden opgegeven met de credential en clientID eigenschappen. Houd er rekening mee dat het configureren van een door de gebruiker toegewezen identiteit met een resource-id niet wordt ondersteund. Wanneer uw ontwikkelaarsidentiteit wordt uitgevoerd in andere contexten, zoals lokale ontwikkeling, wordt in plaats daarvan uw ontwikkelaarsidentiteit gebruikt, hoewel dit kan worden aangepast. Zie Lokale ontwikkeling met op identiteit gebaseerde verbindingen.

Toestemming verlenen aan de identiteit

Elke identiteit die wordt gebruikt, moet machtigingen hebben om de beoogde acties uit te voeren. Voor de meeste Azure-services betekent dit dat u een rol in Azure RBAC moet toewijzen met behulp van ingebouwde of aangepaste rollen die deze machtigingen bieden.

Belangrijk

Sommige machtigingen worden mogelijk weergegeven door de doelservice die niet nodig is voor alle contexten. Waar mogelijk moet u zich houden aan het principe van minimale bevoegdheid, waarbij de identiteit alleen vereiste bevoegdheden verleent. Als de app bijvoorbeeld alleen uit een gegevensbron moet kunnen lezen, gebruikt u een rol die alleen gemachtigd is om te lezen. Het zou ongepast zijn om een rol toe te wijzen die ook schrijfbewerkingen naar die service toestaat, omdat dit overmatige machtigingen zou zijn voor een leesbewerking. Op dezelfde manier wilt u ervoor zorgen dat de roltoewijzing alleen is afgestemd op de resources die moeten worden gelezen.

Cosmos DB maakt geen gebruik van Azure RBAC voor gegevensbewerkingen. In plaats daarvan wordt een ingebouwd RBAC-systeem van Cosmos DB gebruikt dat is gebaseerd op vergelijkbare concepten. U moet een roltoewijzing maken die tijdens runtime toegang biedt tot uw databaseaccount. Azure RBAC-beheerrollen zoals Eigenaar zijn niet voldoende. De volgende tabel bevat ingebouwde rollen die worden aanbevolen bij het gebruik van de Azure Cosmos DB-extensie in normale werking. Uw toepassing vereist mogelijk extra machtigingen op basis van de code die u schrijft.

Bindingstype Voorbeeld van ingebouwde rollen1
Trigger2 Inzender voor ingebouwde Cosmos DB-gegevens
Invoerbinding Ingebouwde gegevenslezer van Cosmos DB
Uitvoerbinding Inzender voor ingebouwde Cosmos DB-gegevens

1 Deze rollen kunnen niet worden gebruikt in een Azure RBAC-roltoewijzing. Raadpleeg de ingebouwde RBAC-systeemdocumentatie van Cosmos DB voor meer informatie over het toewijzen van deze rollen.

2 Wanneer u identiteit gebruikt, behandelt Cosmos DB het maken van containers als een beheerbewerking. Het is niet beschikbaar als een gegevensvlakbewerking voor de trigger. U moet ervoor zorgen dat u de containers maakt die nodig zijn voor de trigger (inclusief de leasecontainer) voordat u uw functie instelt.

Uitzonderingen en retourcodes

Binding Verwijzing
Azure Cosmos DB HTTP-statuscodes voor Azure Cosmos DB

Volgende stappen