Verbinding maken Azure Functions naar 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 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 van 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 de resources na voltooiing van dat artikel al had opgeruimd, doorloopt u de stappen voor het maken van de functie-app en de bijbehorende resources opnieuw in Azure.
Voordat u begint, moet u de quickstart voltooien: Een JavaScript-functie maken in Azure met behulp van Visual Studio Code. Als u de resources na voltooiing van dat artikel al had opgeruimd, doorloopt u de stappen voor het maken van de functie-app en de bijbehorende resources opnieuw in Azure.
Notitie
Dit artikel ondersteunt momenteel alleen Node.js v3 voor Functions.
Voordat u begint, moet u de quickstart voltooien: Een Python-functie maken in Azure met behulp van Visual Studio Code. Als u de resources na voltooiing van dat artikel al had opgeruimd, doorloopt u de stappen voor het maken van de functie-app en de bijbehorende resources opnieuw in Azure.
Uw omgeving configureren
Voordat u aan de slag gaat, moet u de Azure Databases-extensie voor Visual Studio Code installeren.
Uw Azure Cosmos DB-account maken
U maakt nu een Azure Cosmos DB-account als serverloos accounttype. Deze modus op basis van verbruik maakt Azure Cosmos DB een sterke optie voor serverloze workloads.
Selecteer in Visual Studio Code het opdrachtenpalet weergeven>... en zoek vervolgens in het opdrachtenpalet naar
Azure Databases: Create Server...Geef de volgende informatie op bij de prompts:
Prompt Selectie Een Azure Database Server selecteren 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 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 Serverloos om een account te maken in de modus serverloos. 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 waar u het Azure Cosmos DB-account wilt hosten. Gebruik de locatie die zich het dichtst bij u of uw gebruikers bevindt om de snelste toegang tot uw gegevens te krijgen. Nadat uw nieuwe account is ingericht, wordt er een bericht weergegeven in het systeemvak.
Een Azure Cosmos DB-database en -container maken
Selecteer het Azure-pictogram in de activiteitenbalk, vouw Resources>Azure Cosmos DB uit, klik met de rechtermuisknop op uw account (Ctrl+selecteer op macOS) en selecteer Database maken....
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 /idals de partitiesleutel.Selecteer OK om de container en database te maken.
De instellingen van uw functie-app bijwerken
In het vorige quickstart-artikel 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 verbindingsreeks toevoegen aan uw app-instellingen. Vervolgens downloadt u de nieuwe instelling naar uw local.settings.json-bestand, zodat u verbinding kunt maken met uw Azure Cosmos DB-account wanneer u lokaal wordt uitgevoerd.
Klik in Visual Studio Code met de rechtermuisknop op (Ctrl+selecteer op macOS) in uw nieuwe Azure Cosmos DB-account en selecteer Verbinding maken ion-tekenreeks kopiëren.
Druk op F1 om het opdrachtenpalet te openen en zoek en voer de opdracht
Azure Functions: Add New Setting...uit.Kies de functie-app die u in het vorige artikel hebt gemaakt. Geef de volgende informatie op bij de prompts:
Prompt Selectie Voer de naam van de nieuwe app-instelling in Typ CosmosDbConnectionSetting.Voer de waarde in voor 'CosmosDb Verbinding maken ionSetting' Plak de verbindingsreeks van uw Azure Cosmos DB-account dat u hebt gekopieerd. U kunt microsoft Entra-identiteit ook configureren als alternatief. Hiermee maakt u een toepassingsinstelling met de naam verbinding
CosmosDbConnectionSettingin 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 verbindingsreeks-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 het project uitvoert.
Met uitzondering van HTTP- en timertriggers worden bindingen geïmplementeerd als uitbreidingspakketten. Voer de volgende dotnet-pakketopdracht toe 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 uitbreidingsbundels, waarmee automatisch een vooraf gedefinieerde set uitbreidingspakketten wordt geïnstalleerd.
Het gebruik van extensiebundels is ingeschakeld in het host.json-bestand in de hoofdmap van het project. Dit wordt als volgt 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 uitbreidingsbundels, waarmee automatisch een vooraf gedefinieerde set uitbreidingspakketten wordt geïnstalleerd.
Het gebruik van extensiebundels is ingeschakeld in het host.json-bestand in de hoofdmap van het project. Dit wordt als volgt 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 bibliotheekproject van de C#-klasse worden de bindingen gedefinieerd als bindingseigenschappen in de functiemethode.
Open het HttpExample.cs projectbestand en voeg de volgende klassen toe:
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; }
}
De MyDocument klasse definieert een object dat naar de database wordt geschreven. De verbindingsreeks voor het opslagaccount wordt ingesteld door de Connection eigenschap. In dit geval kunt u weglaten Connection omdat u al het standaardopslagaccount gebruikt.
Met MultiResponse de klasse kunt u beide schrijven naar de opgegeven verzameling in Azure Cosmos DB en een HTTP-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 verbindingsreeks voor uw Azure Cosmos DB-account wordt ingesteld door de CosmosDbConnectionSetting.
Bindingskenmerken worden rechtstreeks in uw functiecode gedefinieerd. De uitvoerconfiguratie van Azure Cosmos DB 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="CosmosDbConnectionSetting")
In deze code arg_name identificeert u de bindingsparameter waarnaar wordt verwezen in uw code database_name en container_name zijn dit de namen van de database en verzameling waarnaar de binding schrijft. connection Dit is de naam van een toepassingsinstelling die de verbindingsreeks bevat voor het Azure Cosmos DB-account, dat zich in de CosmosDbConnectionSetting instelling in het local.settings.json bestand bevindt.
Code toevoegen die gebruikmaakt van de uitvoerbinding
Vervang de bestaande runmethode door de volgende code:
[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
};
}
Voeg code toe die gebruikmaakt van het extraInputs uitvoerbindingsobject ingeschakeld 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 HttpExample\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.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
)
Het document {"id": "name"} wordt gemaakt in de databaseverzameling die is opgegeven in de binding.
De functie lokaal uitvoeren
Visual Studio Code integreert met Azure Functions Core Tools om u een project te laten uitvoeren vanaf uw lokale ontwikkelaarscomputer voordat u in 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.
Druk op F5 om het functie-app-project te starten en uw functie aan te roepen. In het terminalvenster wordt de uitvoer van Core Tools weergegeven. Uw app wordt gestart in het deelvenster Terminal . Kopieer het URL-eindpunt van uw functie die lokaal wordt uitgevoerd en door HTTP is geactiveerd.
Als u Core Tools nog niet hebt geïnstalleerd, selecteert u Installeren om Core Tools te installeren wanneer u hierom wordt gevraagd.
Als u problemen ondervindt met het uitvoeren op Windows, moet u ervoor zorgen dat de standaardterminal voor Visual Studio Code niet is ingesteld op WSL Bash.Wanneer de Core Tools worden uitgevoerd, gaat u naar het gebied Azure: Functions . Vouw onder Functions lokaal projectfuncties> uit. Klik met de rechtermuisknop (Windows) of Ctrl - klik op de
HttpExamplefunctie (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 worden uitgevoerd, gaat u naar het gebied Azure: Functions . Vouw onder Functions lokaal projectfuncties> uit. Klik met de rechtermuisknop op de
HttpExamplefunctie (Ctrl-klik op Mac) en kies Nu functie uitvoeren....
In de hoofdtekst van de aanvraag wordt de hoofdtekstwaarde van het aanvraagbericht weergegeven.
{ "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
Ga in Azure Portal 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. In het opdrachtenpalet zoekt en selecteert u
Azure Functions: Deploy to function app....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.
Nadat de implementatie is voltooid, kunt u de functie Nu uitvoeren gebruiken... om de functie in Azure te activeren.
Controleer opnieuw de documenten die zijn gemaakt in uw 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. Mogelijk wordt u gefactureerd voor deze resources, afhankelijk van uw 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. In het opdrachtenpalet zoekt en selecteert u
Azure: Open in portal.Kies uw functie-app en druk op Enter. 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 uw door HTTP geactiveerde functie bijgewerkt om JSON-documenten naar een Azure Cosmos DB-container te schrijven. Nu kunt u meer informatie vinden over het ontwikkelen van functies met Visual Studio Code: