Verbinding maken Azure Functions voor Azure Cosmos DB met behulp van Visual Studio Code

Met Azure Functions kunt u Azure-services en andere resource verbinden met services zonder dat u zelf integratiecode moet 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 triggers and bindings concepts (Concepten van Azure Functions-triggers en -bindingen) voor meer informatie.

In dit artikel wordt beschreven hoe u Visual Studio code gebruikt om verbinding Azure Cosmos DB maken met de functie die u in het vorige quickstart-artikel hebt gemaakt. De uitvoerbinding die u aan deze functie toevoegt, schrijft gegevens van de HTTP-aanvraag naar een JSON-document dat is opgeslagen in een Azure Cosmos DB container.

Uw omgeving configureren

Voordat u aan de slag gaat, moet u de Azure Databases-extensie voor Visual Studio Code installeren.

Uw Azure Cosmos DB maken

1. Kies Visual Studio Code het pictogram Azure in de activiteitenbalk.

2. Klik in het gebied Azure: Databases met de rechtermuisknop (Ctrl+klik op macOS) op het Azure-abonnement waar u de functie-app in het vorige artikel hebt gemaakt en selecteer Server maken...

   

3. Geef de volgende informatie op bij de prompts:

   Prompt	Selectie
   Een Azure Database-server selecteren	Kies Core (SQL) ervoor om een documentdatabase te maken die u kunt opvragen met behulp van een SQL syntaxis. Meer informatie over de Azure Cosmos DB SQL API.
   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 Serverloos om een account te maken in de modus serverloos.
   Selecteer een resourcegroep voor nieuwe resources	Kies de resourcegroep waarin u de functie-app in het vorige artikel hebt gemaakt.
   Een locatie voor nieuwe resources selecteren	Selecteer een geografische locatie waar u het Azure Cosmos DB-account wilt hosten. Gebruik de locatie die het dichtst bij u of uw gebruikers ligt om de snelste toegang tot uw gegevens te krijgen.

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

Een database Azure Cosmos DB container maken

1. Klik met de rechtermuisknop op uw account en selecteer Database maken....

2. Geef de volgende informatie op bij de prompts:

   Prompt	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.

3. Selecteer OK om de container en database te maken.

De instellingen van uw functie-app bijwerken

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

1. Klik Visual Studio Code met de rechtermuisknop (Ctrl+klik op macOS) op uw nieuwe Azure Cosmos DB-account en selecteer Verbindingsreeks kopiëren.

   

2. Druk op F1 om het opdrachtenpalet te openen, zoek en voer de opdracht Azure Functions: Add New Setting... uit.

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

   Prompt	Selectie
   Naam van nieuwe app-instelling invoeren	Typ CosmosDbConnectionString.
   Voer de waarde in voor 'CosmosDbConnectionString'	Plak de connection string van uw Azure Cosmos DB account dat u zojuist hebt gekopieerd.

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

4. Druk nogmaals op F1 om het opdrachtenpalet te openen, zoek en voer de opdracht Azure Functions: Download Remote Settings... uit.

5. 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, met inbegrip van de nieuwe connection string instelling. De meeste gedownloade instellingen worden niet gebruikt wanneer ze lokaal worden uitgevoerd.

Binding-extensies registreren

Omdat u een uitvoerbinding Azure Cosmos DB, moet u de bijbehorende bindingsextensie hebben geïnstalleerd voordat u het project kunt uitvoeren.

dotnet add package Microsoft.Azure.WebJobs.Extensions.CosmosDB 

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

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

U kunt nu de uitvoerbinding Azure Cosmos DB project toevoegen.

Een uitvoerbinding toevoegen

In functies moet voor elk type binding een direction, typeen een unieke name worden gedefinieerd in het bestand function.json. De manier waarop u deze kenmerken definieert, is afhankelijk van de taal van uw functie-app.

[CosmosDB(databaseName: "my-database", collectionName: "my-container",
    ConnectionStringSetting = "CosmosDbConnectionString"
    )]IAsyncCollector<dynamic> documentsOut,

public class MultiResponse
{
    [CosmosDBOutput("my-database", "my-container",
        ConnectionStringSetting = "CosmosDbConnectionString", 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; }
}

{
    "type": "cosmosDB",
    "direction": "out",
    "name": "outputDocument",
    "databaseName": "my-database",
    "collectionName": "my-container",
    "createIfNotExists": "false",
    "connectionStringSetting": "CosmosDbConnectionString"
}

Code toevoegen die gebruikmaakt van de uitvoerbinding

if (!string.IsNullOrEmpty(name))
{
    // Add a JSON document to the output container.
    await documentsOut.AddAsync(new
    {
        // create a random ID
        id = System.Guid.NewGuid().ToString(),
        name = name
    });
}

[FunctionName("HttpExample")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req,
    [CosmosDB(
        databaseName: "my-database",
        collectionName: "my-container",
        ConnectionStringSetting = "CosmosDbConnectionString")]IAsyncCollector<dynamic> documentsOut,
    ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    string name = req.Query["name"];

    string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
    dynamic data = JsonConvert.DeserializeObject(requestBody);
    name = name ?? data?.name;

    if (!string.IsNullOrEmpty(name))
    {
        // Add a JSON document to the output container.
        await documentsOut.AddAsync(new
        {
            // create a random ID
            id = System.Guid.NewGuid().ToString(),
            name = name
        });
    }

    string responseMessage = string.IsNullOrEmpty(name)
        ? "This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response."
        : $"Hello, {name}. This HTTP triggered function executed successfully.";

    return new OkObjectResult(responseMessage);
}

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

if (name) {
    context.bindings.outputDocument = JSON.stringify({
        // create a random ID
        id: new Date().toISOString() + Math.random().toString().substr(2,8),
        name: name
    });
}

module.exports = async function (context, req) {
    context.log('JavaScript HTTP trigger function processed a request.');

    const name = (req.query.name || (req.body && req.body.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.";

    if (name) {
        context.bindings.outputDocument = JSON.stringify({
            // create a random ID
            id: new Date().toISOString() + Math.random().toString().substr(2,8),
            name: name
        });
    }

    context.res = {
        // status: 200, /* Defaults to 200 */
        body: responseMessage
    };
}

Controleren of er een JSON-document is gemaakt

1. Ga op Azure Portal pagina terug naar uw Azure Cosmos DB account en selecteer Data Explorer.

2. Vouw uw database en container uit en selecteer Items om de documenten weer te geven die in uw container zijn gemaakt.

3. Controleer of er een nieuw JSON-document is gemaakt door de uitvoerbinding.

   

De bijgewerkte app opnieuw implementeren en verifiëren

1. Druk in Visual Studio Code op F1 om het opdrachtenpalet te openen. In het opdrachtenpalet zoekt en selecteert u Azure Functions: Deploy to function app....

2. Kies de functie-app die u in het eerste artikel hebt gemaakt. Omdat u uw project opnieuw implementeert voor dezelfde app, selecteert u Implementeren om de waarschuwing over het overschrijven van bestanden te negeren.

3. Nadat de implementatie is voltooid, kunt u opnieuw de functie Nu uitvoeren gebruiken om de functie in Azure te activeren.

4. Controleer opnieuw de documenten die zijn gemaakt in Azure Cosmos DB container om te controleren of de uitvoerbinding opnieuw een nieuw JSON-document genereert.

Resources opschonen

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

U hebt resources gemaakt om deze snelstartgidsen te voltooien. Deze resources kunnen bij u in rekening worden gebracht, afhankelijk van de accountstatus en serviceprijzen. Als u de resources niet meer nodig hebt, kunt u ze als volgt verwijderen:

1. Druk in Visual Studio Code op F1 om het opdrachtenpalet te openen. In het opdrachtenpalet zoekt en selecteert u Azure Functions: Open in portal.

2. Kies uw functie-app en druk op Enter. De functie-app wordt geopend in de Azure-portal.

3. Selecteer op het tabblad Overzicht de benoemde koppeling naast Resourcegroep.

   

4. Bekijk op de pagina Resourcegroep de lijst met opgenomen resources en controleer of dit de resources zijn die u wilt verwijderen.

5. 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 boven aan de pagina selecteren om de melding te bekijken.

Volgende stappen

U hebt de http-geactiveerde functie bijgewerkt om JSON-documenten te schrijven naar Azure Cosmos DB container. Nu kunt u meer informatie vinden over het ontwikkelen van functies met Visual Studio Code:

• Azure Functions ontwikkelen met Visual Studio Code

• Azure Functions-triggers en -bindingen.