Azure Functions verbinden met Azure Cosmos DB met behulp van Visual Studio Code

Azure Functions kunt u Azure services en andere resources verbinden met functies zonder dat u uw eigen integratiecode hoeft te schrijven. Deze zogenaamde bindingen, die zowel invoer als uitvoer vertegenwoordigen, worden gedeclareerd binnen de functiedefinitie. Gegevens van bindingen worden als parameters doorgegeven aan de functie. Een trigger is een speciaal type invoerbinding. Hoewel een functie slechts één trigger heeft, kan deze meerdere invoer- en uitvoerbindingen hebben. Zie Azure Functions concepten voor triggers en bindingen voor meer informatie.

In dit artikel leest u hoe u Visual Studio Code gebruikt om Azure Cosmos DB te verbinden met de functie die u in het vorige quickstart-artikel hebt gemaakt. De uitvoerbinding die u aan deze functie toevoegt, schrijft gegevens uit de HTTP-aanvraag naar een JSON-document dat is opgeslagen in een Azure Cosmos DB-container.

Voordat u begint, moet u de quickstart voltooien: Een C#-functie maken in Azure met behulp van Visual Studio Code. Als u resources al aan het einde van dat artikel hebt opgeschoond, voert u de stappen opnieuw uit om de functie-app en gerelateerde resources in Azure opnieuw te maken.

Voordat u begint, moet u de quickstart: Een JavaScript-functie maken in Azure met behulp van Visual Studio Code. Als u resources al aan het einde van dat artikel hebt opgeschoond, voert u de stappen opnieuw uit om de functie-app en gerelateerde resources in Azure opnieuw te maken.

Notitie

Dit artikel ondersteunt Node.js v4 voor Functions.

Voordat u begint, moet u de quickstart voltooien: Een Python-functie maken in Azure met behulp van Visual Studio Code. Als u resources al aan het einde van dat artikel hebt opgeschoond, voert u de stappen opnieuw uit om de functie-app en gerelateerde resources in Azure opnieuw te maken.

Uw omgeving configureren

Voordat je begint, zorg ervoor dat je de extensie Azure Databases voor Visual Studio Code installeert.

Uw Azure Cosmos DB-account maken

U maakt nu een Azure Cosmos DB-account als een serverloze accounttype. Deze modus op basis van verbruik maakt Azure Cosmos DB een sterke optie voor serverloze workloads.

Selecteer in Visual Studio Code View>Command Palette... zoekt u vervolgens in het opdrachtenpalet naar Azure Databases: Create Server...

Geef de volgende informatie op bij de prompts:

Aansporing	Selectie
Selecteer een Azure DatabaseServer	Kies Core (NoSQL) om een documentdatabase te maken die u kunt opvragen met behulp van een SQL-syntaxis of een Query Copilot (Preview) waarbij prompts in natuurlijke taal worden geconverteerd naar query's. Meer informatie over de Azure Cosmos DB.
Accountnaam	Voer een unieke naam in om uw Azure Cosmos DB-account te identificeren. De accountnaam moet tussen de 3 en 31 tekens lang zijn en mag alleen kleine letters, cijfers en afbreekstreepjes bevatten.
Een capaciteitsmodel selecteren	Selecteer Serverless om een account te maken in de modus serverless.
Selecteer een resourcegroep voor nieuwe resources	Kies de resourcegroep waarin u uw functie-app hebt gemaakt in het vorige artikel.
Selecteer een locatie voor nieuwe resources	Selecteer een geografische locatie om uw Azure Cosmos DB-account te hosten. Gebruik de locatie die zich het dichtst bij u of uw gebruikers bevindt om de snelste access aan uw gegevens te krijgen.

Nadat uw nieuwe account is ingericht, wordt er een bericht weergegeven in het meldingsgebied.

Een Azure Cosmos DB-database en -container maken

Selecteer het pictogram Azure in de activiteitenbalk, vouw Resources>Azure Cosmos DB uit, klik met de rechtermuisknop op uw account (Ctrl+selecteer macOS) en selecteer Database maken... .

Geef de volgende informatie op bij de prompts:

Aansporing	Selectie
Databasenaam	Typ `my-database`.
Voer en id in voor uw verzameling	Typ `my-container`.
Voer de partitiesleutel voor de verzameling in	Typ `/id` als de partitiesleutel.

Selecteer OK om de container en database te maken.

De instellingen van uw functie-app bijwerken

In het artikel previous quickstart hebt u een functie-app gemaakt in Azure. In dit artikel werkt u uw app bij om JSON-documenten te schrijven naar de Azure Cosmos DB-container die u hebt gemaakt. Als u verbinding wilt maken met uw Azure Cosmos DB-account, moet u de bijbehorende connection string toevoegen aan uw app-instellingen. Vervolgens downloadt u de nieuwe instelling naar uw local.settings.json-bestand, zodat u lokaal kunt verbinding maken met uw Azure Cosmos DB-account wanneer u lokaal werkt.

Klik in Visual Studio Code met de rechtermuisknop (Ctrl+selecteer op macOS) op uw nieuwe Azure Cosmos DB-account en selecteer Verbindingsreeks kopiëren.
Druk op F1 om het opdrachtenpalet te openen en zoek en voer de opdracht uit Azure Functions: Add New Setting....

Kies de functie-app die u in het vorige artikel hebt gemaakt. Geef de volgende informatie op bij de prompts:

Aansporing	Selectie
Voer de naam van de nieuwe app-instelling in	Typ `CosmosDbConnectionString`.
Voer de waarde in voor CosmosDbConnectionString	Plak de connection string van uw Azure Cosmos DB-account die u hebt gekopieerd. U kunt Microsoft Entra-identiteit ook configureren als alternatief.

Hiermee maakt u een toepassingsinstelling met de naam verbinding CosmosDbConnectionString in uw functie-app in Azure. U kunt deze instelling nu downloaden naar uw local.settings.json-bestand.

Druk nogmaals op F1 om het opdrachtenpalet te openen en zoek en voer de opdracht Azure Functions: Download Remote Settings... uit.
Kies de functie-app die u in het vorige artikel hebt gemaakt. Selecteer Ja op alle om de bestaande lokale instellingen te overschrijven.

Hiermee downloadt u alle instellingen van Azure naar uw lokale project, inclusief de nieuwe connection string-instelling. De meeste gedownloade instellingen worden niet gebruikt wanneer ze lokaal worden uitgevoerd.

Binding-extensies registreren

Omdat u een Azure Cosmos DB-uitvoerbinding gebruikt, moet de bijbehorende bindingsextensie zijn geïnstalleerd voordat u de project uitvoert.

Met uitzondering van HTTP- en timertriggers worden bindingen geïmplementeerd als uitbreidingspakketten. Voer de volgende opdracht dotnet add package uit in het Terminal-venster om het Azure Cosmos DB-extensiepakket toe te voegen aan uw project.

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

Uw project is geconfigureerd voor het gebruik van extension-bundels, waarmee automatisch een vooraf gedefinieerde set extensiepakketten wordt geïnstalleerd.

Het gebruik van extensiebundels is ingeschakeld in het bestand host.json in de hoofdmap van het project, dat als volgt wordt weergegeven:

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

Uw project is geconfigureerd voor het gebruik van extension-bundels, waarmee automatisch een vooraf gedefinieerde set extensiepakketten wordt geïnstalleerd.

Het gebruik van extensiebundels is ingeschakeld in het bestand host.json in de hoofdmap van het project, dat als volgt wordt weergegeven:

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

U kunt nu de Azure Cosmos DB-uitvoerbinding toevoegen aan uw project.

Een uitvoerbinding toevoegen

In een C#-klassebibliotheek project worden de bindingen gedefinieerd als bindingskenmerken in de functiemethode.

Open het bestand HttpExample.cs project en voeg de volgende klassen toe:

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

De MyDocument klasse definieert een object dat naar de database wordt geschreven. De connection string voor het Storage-account wordt ingesteld door de eigenschap Connection. In dit geval kunt u Connection weglaten omdat u al het standaardaccount storage gebruikt.

Met de klasse MultiResponse kunt u beide schrijven naar de opgegeven verzameling in de Azure Cosmos DB en een HTTP-geslaagd bericht retourneren. Omdat u een MultiResponse object moet retourneren, moet u ook de handtekening van de methode bijwerken.

Specifieke kenmerken geven de naam van de container en de naam van de bovenliggende database op. De connection string voor uw Azure Cosmos DB-account wordt ingesteld door de CosmosDbConnectionString.

Bindingskenmerken worden rechtstreeks in uw functiecode gedefinieerd. De Azure Cosmos DB-uitvoerconfiguratie beschrijft de velden die vereist zijn voor een Azure Cosmos DB-uitvoerbinding.

Voor dit MultiResponse scenario moet u een extraOutputs uitvoerbinding toevoegen aan de functie.

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

Voeg de volgende eigenschappen toe aan de bindingsconfiguratie:

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

Bindingskenmerken worden rechtstreeks in het function_app.py-bestand gedefinieerd. U gebruikt de cosmos_db_output decorator om een Azure Cosmos DB-uitvoerbinding toe te voegen:

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

In deze code identificeert arg_name de bindingsparameter waarnaar in uw code wordt verwezen, database_name en container_name de database- en verzamelingsnamen waarnaar de binding schrijft, en connection is de naam van een toepassingsinstelling die de connection string voor het Azure Cosmos DB-account bevat. Deze bevindt zich in de CosmosDbConnectionString-instelling in het bestand local.settings.json.

Code toevoegen die gebruikmaakt van de uitvoerbinding

Vervang de bestaande Run methode door de volgende code:

[Function("HttpExample")]
public MultiResponse Run([HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequest req)
{
    _logger.LogInformation("C# HTTP trigger function processed a request.");

    var message = "Welcome to Azure Functions!";

    // 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 = new OkObjectResult(message)
    };
}

Voeg code toe die gebruikmaakt van het uitvoerbindingsobject extraInputs op context om een JSON-document te verzenden naar de benoemde uitvoerbindingsfunctie, sendToCosmosDb. Voeg deze code toe vóór de instructie return.

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

Op dit moment moet uw functie er als volgt uit zien:

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

Deze code retourneert nu een MultiResponse object dat zowel een document als een HTTP-antwoord bevat.

Werk function_app.py bij zodat deze overeenkomt met de volgende code. Voeg de outputDocument parameter toe aan de functiedefinitie en outputDocument.set() onder de if name: instructie:

import azure.functions as func
import logging

app = func.FunctionApp()

@app.function_name(name="HttpTrigger1")
@app.route(route="hello", auth_level=func.AuthLevel.FUNCTION)
@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="CosmosDbConnectionString")
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
                )

Het document {"id": "name"} wordt gemaakt in de databaseverzameling die is opgegeven in de binding.

De functie lokaal uitvoeren

Visual Studio Code kan worden geïntegreerd met Azure Functions Core-hulpprogramma's zodat u deze project kunt uitvoeren op uw lokale ontwikkelcomputer voordat u naar Azure publiceert. Als u Core Tools nog niet lokaal hebt geïnstalleerd, wordt u gevraagd deze te installeren wanneer u uw project voor het eerst uitvoert.

Om de functie op te roepen, drukt u op F5 om het project van de functie-app te starten. In het terminalvenster wordt de uitvoer van Core Tools weergegeven. Uw app wordt gestart in het deelvenster Terminal . U kunt het URL-eindpunt van uw lokaal uitgevoerde, door HTTP geactiveerde functie zien.

Als u Core Tools nog niet hebt geïnstalleerd, selecteert u Install om Core Tools te installeren wanneer hierom to do wordt gevraagd.
Als u problemen ondervindt met windows, controleert u of de standaardterminal voor Visual Studio Code niet is ingesteld op WSL Bash.
Als de Core Tools worden uitgevoerd, gaat u naar het gebied Azure: Functions. Vouw onder FunctiesLocal Project>Functions uit. Klik met de rechtermuisknop (Windows) of Ctrl - klik op de HttpExample functie (macOS) en kies Nu functie uitvoeren....
Druk in de hoofdtekst van de Enter-aanvraag op Enter om een aanvraagbericht naar uw functie te verzenden.
Wanneer de functie lokaal wordt uitgevoerd en een antwoord retourneert, wordt er een melding gegenereerd in Visual Studio Code. Informatie over de uitvoering van de functie wordt weergegeven in het deelvenster Terminal .
Druk op CTRL + C om Core Tools te stoppen en de verbinding met het foutopsporingsprogramma te verbreken.

De functie lokaal uitvoeren

Net als in het vorige artikel drukt u op F5 om het functie-app-project en Core Tools te starten.
Als Core Tools wordt uitgevoerd, gaat u naar het gebied Azure: Functions. Vouw onder FunctiesLocal Project>Functions uit. Klik met de rechtermuisknop op de HttpExample functie (Ctrl-klik op Mac) en kies Nu functie uitvoeren....
In Enter request body ziet u de berichttekstwaarde van { "name": "Azure" }. Druk op Enter om dit aanvraagbericht naar uw functie te verzenden.
Nadat een antwoord is geretourneerd, drukt u op Ctrl+C om Core Tools te stoppen.

Controleer of er een JSON-document is gemaakt

Navigeer op het Azure-portaal terug naar uw Azure Cosmos DB-account en selecteer Data Explorer.
Vouw uw database en container uit en selecteer Items om de documenten weer te geven die in uw container zijn gemaakt.
Controleer of er een nieuw JSON-document is gemaakt door de uitvoerbinding.

De bijgewerkte app opnieuw implementeren en verifiëren

Druk in Visual Studio Code op F1 om het opdrachtenpalet te openen. Zoek naar en selecteer in het opdrachtenpalet Azure Functions: Deploy to function app....
Kies de functie-app die u in het eerste artikel hebt gemaakt. Omdat u uw project opnieuw implementeert in dezelfde app, selecteert u Deploy om de waarschuwing over het overschrijven van bestanden te sluiten.
Nadat de implementatie is voltooid, kunt u de Execute-functie nu opnieuw gebruiken... functie om de functie in Azure te activeren. Met deze opdracht wordt automatisch de functie toegangssleutel opgehaald en gebruikt bij het aanroepen van de HTTP-trigger-eindpunt.
Controleer opnieuw controleer de documenten die zijn gemaakt in uw Azure Cosmos DB-container om te controleren of de uitvoerbinding opnieuw een nieuw JSON-document genereert.

De middelen opschonen

In Azure verwijzen resources naar functie-apps, functies, storage accounts enzovoort. Deze zijn gegroepeerd in resourcegroepen. U kunt alle resources in een groep verwijderen door de groep zelf te verwijderen.

U hebt hulpmiddelen aangemaakt om deze snelstarts te voltooien. Mogelijk wordt u gefactureerd voor deze resources, afhankelijk van de accountstatus en serviceprijzen. Als u de resources niet meer nodig hebt, kunt u ze als volgt verwijderen:

Druk in Visual Studio Code op F1 om het opdrachtenpalet te openen. Zoek naar en selecteer in het opdrachtenpalet Azure: Open in portal.
Kies uw functie-app en druk op Enter. De pagina van de functie-app wordt geopend in de Azure portal.
Selecteer op het tabblad Overzicht de benoemde koppeling naast Resourcegroep.
Controleer op de pagina Resourcegroep de lijst met opgenomen resources en controleer of ze de resources zijn die u wilt verwijderen.
Selecteer Resourcegroep verwijderen en volg de instructies.

Verwijderen kan enkele minuten duren. Wanneer dit is voltooid, verschijnt een aantal seconden een melding in beeld. U kunt ook het belpictogram bovenaan de pagina selecteren om de melding te bekijken.

Volgende stappen

U hebt de door HTTP geactiveerde functie bijgewerkt om JSON-documenten naar een Azure Cosmos DB-container te schrijven. Nu vindt u meer informatie over het ontwikkelen van Functies met behulp van Visual Studio Code:

Voorbeelden van volledige functieprojecten in Python.
ontwikkelaarshandleiding voor Azure Functions Python

Feedback

Is deze pagina nuttig?

Last updated on 2026-03-11

Delen via

Azure Functions verbinden met Azure Cosmos DB met behulp van Visual Studio Code

Uw omgeving configureren

Uw Azure Cosmos DB-account maken

Een Azure Cosmos DB-database en -container maken

De instellingen van uw functie-app bijwerken

Binding-extensies registreren

Een uitvoerbinding toevoegen

Code toevoegen die gebruikmaakt van de uitvoerbinding

De functie lokaal uitvoeren

De functie lokaal uitvoeren

Controleer of er een JSON-document is gemaakt

De bijgewerkte app opnieuw implementeren en verifiëren

De middelen opschonen

Volgende stappen

Feedback

Aanvullende resources