Serverloze TypeScript-API: gegevens opslaan in MongoDB met Azure Functions

Maak een Azure Function-API voor het opslaan van gegevens met Mongoose-API in Azure Cosmos DB en implementeer vervolgens de functietoepassing in de Azure-cloud voor hosting met een openbaar HTTP-eindpunt.

Notitie

In dit artikel wordt gebruikgemaakt van het Azure Functions Node.js v4-programmeermodel dat momenteel in preview is.

Uw ontwikkelomgeving voorbereiden

Installeer de volgende software:

• Een gratis Azure-abonnement maken
• Node.js LTS v18+ installeren
• TypeScript v4+
• Azurite wereldwijd geïnstalleerd voor lokale ontwikkelopslag
• Azure Functions Runtime v4.16+
• Azure Functions Core Tools v4.0.5095+ (indien lokaal uitgevoerd) is geïnstalleerd voor lokale ontwikkeling
• Installeer Visual Studio Code en gebruik de volgende extensies:
  • Azure-resources
  • Azure Functions
  • Azure Databases

1. Meld u aan bij Azure in Visual Studio Code

Als u de Azure-service-extensies al gebruikt, moet u al zijn aangemeld en kunt u deze stap overslaan.

Nadat u een Azure-service-extensie in Visual Studio Code hebt geïnstalleerd, moet u zich aanmelden bij uw Azure-account.

1. Open azure Explorer in Visual Studio Code door het Azure-pictogram in de primaire zijbalk te selecteren of gebruik de sneltoets (Shift + Alt + A).

2. Selecteer In de sectie Resources de optie Aanmelden bij Azure en volg de aanwijzingen.

   

3. Nadat u zich hebt aangemeld, controleert u of het e-mailadres van uw Azure-account wordt weergegeven op de statusbalk en of uw abonnementen worden weergegeven in Azure Explorer:

   

2. Een Azure-resourcegroep maken

Een resourcegroep is een op regio's gebaseerde verzameling resources. Door een resourcegroep te maken en vervolgens resources in die groep te maken, kunt u aan het einde van de zelfstudie de resourcegroep verwijderen zonder dat u elke resource afzonderlijk hoeft te verwijderen.

1. Maak een nieuwe map op uw lokale systeem om te gebruiken als hoofdmap van het Azure Functions-project.

2. Open deze map in Visual Studio Code.

3. Open azure Explorer in Visual Studio Code door het Azure-pictogram in de primaire zijbalk te selecteren of gebruik de sneltoets (Shift + Alt + A).

4. Zoek uw abonnement onder Resources en selecteer het + pictogram en selecteer vervolgens Resourcegroep maken.

5. Gebruik de volgende tabel om de prompts te voltooien:

   Prompt	Weergegeven als
   Voer de naam van de nieuwe resourcegroep in.	azure-tutorial
   Selecteer een locatie voor uw nieuwe resources.	Selecteer een geografische regio bij u in de buurt.

3. De lokale Functions-app maken

Maak een lokale Azure Functions-toepassing (serverloze) die een HTTP-triggerfunctie bevat.

1. Open in Visual Studio Code het opdrachtenpalet (Ctrl + Shift + P).

2. Zoek en selecteer Azure Functions: Nieuw project maken.

3. Gebruik de volgende tabel om het lokale Azure Function-project te maken:

   Prompt	Weergegeven als	Opmerkingen
   Selecteer de map die uw functieproject bevat	Selecteer de huidige (standaard) map.
   Een taal selecteren	TypeScript
   Een TypeScript-programmeermodel selecteren	Model V4 (preview)
   Selecteer een sjabloon voor de eerste functie van uw project	HTTP-trigger	API wordt aangeroepen met een HTTP-aanvraag.
   Geef een functienaam op	blogposts	API-route is /api/blogposts

4. Wanneer Visual Studio Code het project maakt, bekijkt u uw API-code in het ./src/functions/blogposts.ts bestand.

   import { app, HttpRequest, HttpResponseInit, InvocationContext } from "@azure/functions";
   
   export async function blogposts(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
       context.log(`Http function processed request for url "${request.url}"`);
   
       const name = request.query.get('name') || await request.text() || 'world';
   
       return { body: `Hello, ${name}!` };
   };
   
   app.http('blogposts', {
       methods: ['GET', 'POST'],
       authLevel: 'anonymous',
       handler: blogposts
   });
   

   Deze code is standaard standaardstandaard in het nieuwe v4-programmeermodel. Het is niet bedoeld om aan te geven dat er alleen een API-laag met POST en GET kan worden geschreven.

5. Vervang de vorige code door de volgende code, zodat alleen GET-aanvragen alle blogberichten kunnen retourneren.

   import { app, HttpRequest, HttpResponseInit, InvocationContext } from "@azure/functions";
   
   // curl --location 'http://localhost:7071/api/blogposts' --verbose
   export async function getBlogPosts(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
       context.log(`Http function getBlogPosts processed request for url "${request.url}"`);
   
       // Empty array for now ... will fix later
       const blogposts = [];
   
       return {
           status: 200,
           jsonBody: {
               blogposts
           }
       };
   };
   
   app.get('getBlogPosts', {
       route: "blogposts",
       authLevel: 'anonymous',
       handler: getBlogPosts
   });
   

   Er zijn verschillende azure Functions Node.js v4-programmeermodelwijzigingen in deze code die u moet noteren:

   • De functienaam van , waarmee wordt aangegeven dat het een GET-aanvraag is, helpt u bij het isoleren van getBlobPostsde functie in de logboeken.
   • De route eigenschap is ingesteld op blogposts, dat deel uitmaakt van de standaard-API-route, /api/blogposts.
   • De methods eigenschap is verwijderd en is niet nodig omdat het gebruik van get het app object aangeeft dat dit een GET-aanvraag is. De methodefuncties worden hieronder vermeld. Als u een andere methode hebt, kunt u terugkeren naar de methods eigenschap.
     • deleteRequest()
     • get()
     • patch()
     • post()
     • put()

4. Start Azurite lokale opslagemulator

Voor het ontwikkelen van functies op uw lokale computer is een opslagemulator (gratis) of een Azure Storage-account (betaald) vereist.

Start in een aparte terminal de emulator voor lokale opslag van Azurite .

azurite --silent --location ./azurite --debug ./azurite/debug.log

Dit is vereist om de Azure Functions lokaal uit te voeren met behulp van een lokale Azure Storage-emulator. De lokale opslagemulator wordt opgegeven in het local.settings.json bestand met de eigenschap AzureWebJobsStorage met een waarde van UseDevelopmentStorage=true.

{
    "IsEncrypted": false,
    "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "FUNCTIONS_WORKER_RUNTIME": "node",
    "AzureWebJobsFeatureFlags": "EnableWorkerIndexing"
    }
}

De azurite submap is al toegevoegd aan het .gitignore bestand.

5. Voer de lokale serverloze functie uit

Voer het Azure Functions-project lokaal uit om het te testen voordat u implementeert in Azure.

1. Stel in Visual Studio Code een onderbrekingspunt in op de return instructie, aan het einde van de functie getBlogPosts .

2. Druk in Visual Studio Code op F5 om het foutopsporingsprogramma te starten en te koppelen aan de Azure Functions-host.

   U kunt ook de menuopdracht Foutopsporing> starten gebruiken.

3. Uitvoer wordt weergegeven in het deelvenster Terminal .

4. Open azure Explorer in Visual Studio Code door het Azure-pictogram in de primaire zijbalk te selecteren of gebruik de sneltoets (Shift + Alt + A).

5. Zoek en vouw in de sectie Werkruimte het lokale project ->Functions ->getBlogPosts uit.

6. Klik met de rechtermuisknop op de functienaam, getBlogPosts en selecteer functie-URL kopiëren.

   

7. Plak de URL in uw browser en selecteer Enter of gebruik de volgende cURL-opdracht in de terminal:

   curl http://localhost:7071/api/blogposts --verbose
   

   Het antwoord van een lege matrix met blogberichten wordt geretourneerd als:

   *   Trying 127.0.0.1:7071...
   * Connected to localhost (127.0.0.1) port 7071 (#0)
   > GET /api/blogposts HTTP/1.1
   > Host: localhost:7071
   > User-Agent: curl/7.88.1
   > Accept: */*
   >
   < HTTP/1.1 200 OK
   < Content-Type: application/json
   < Date: Mon, 08 May 2023 17:35:24 GMT
   < Server: Kestrel
   < Transfer-Encoding: chunked
   <
   {"blogposts":[]}* Connection #0 to host localhost left intact
   

8. Stop in VS Code het foutopsporingsprogramma, Shift + F5.

6. De Azure Function-app maken in Visual Studio Code

In deze sectie maakt u een cloudresource voor een functie-app en gerelateerde resources in uw Azure-abonnement.

1. Open in Visual Studio Code het opdrachtenpalet (Ctrl + Shift + P).

2. Zoek en selecteer Azure Functions: Functie-app maken in Azure (geavanceerd).

3. Geef de volgende informatie op bij de prompts:

   Prompt	Selectie
   Voer een wereldwijd unieke naam in voor de functie-app	Typ een naam die geldig is in een URL-pad, zoals first-function. Postpend 3 tekens om de URL wereldwijd uniek te maken. De naam die u typt, wordt gevalideerd om er zeker van te zijn dat deze uniek is in Azure Functions.
   Een runtimestack selecteren	Kies Node.js 18 LTS of een recentere versie.
   Een besturingssysteem selecteren	Kies Linux.
   Selecteer een resourcegroep voor nieuwe resources	Maak een nieuwe resourcegroep met de naam azure-tutorial-first-function. Deze resourcegroep heeft uiteindelijk verschillende resources: Azure Function, Azure Storage en de Cosmos DB voor MongoDB-API.
   Een hostingabonnement selecteren	Kies Verbruik.
   Een opslagaccount selecteren	Selecteer Een nieuw opslagaccount maken en accepteer de standaardnaam.
   Selecteer een Application Insights-resource voor uw app.	Selecteer Nieuwe Application Insights-resource maken en accepteer de standaardnaam.

   Wacht totdat de melding bevestigt dat de app is gemaakt.

7. De Azure Function-app implementeren in Azure in Visual Studio Code

Belangrijk

Als u implementeert in een bestaande functie-app, wordt de inhoud van die app altijd overschreven in Azure.

1. Kies het Azure-pictogram op de activiteitenbalk en klik in het gebied Resources met de rechtermuisknop op de resource van uw functie-app en selecteer de functie-app implementeren in functie-app.
2. Als u wordt gevraagd of u zeker weet dat u wilt implementeren, selecteert u Implementeren.
3. Nadat de implementatie is voltooid, wordt er een melding met verschillende opties weergegeven. Selecteer Uitvoer weergeven om de resultaten weer te geven. Als u de melding mist, selecteert u het belpictogram in de rechterbenedenhoek om deze opnieuw weer te geven.

8. Toepassingsinstelling toevoegen aan cloud-app

1. Kies het Azure-pictogram op de activiteitenbalk en vouw vervolgens in het gebied Resources de resource van uw functie-app uit en klik met de rechtermuisknop op Application Instellingen.

2. Selecteer Nieuwe instelling toevoegen en voeg de volgende instelling toe om het programmeermodel Node.js v4 (Preview) in te schakelen.

   Instelling	Weergegeven als
   AzureWebJobsFeatureFlags	EnableWorkerIndexing

9. Voer de externe serverloze functie uit

1. Open azure Explorer in Visual Studio Code door het Azure-pictogram in de primaire zijbalk te selecteren of gebruik de sneltoets (Shift + Alt + A).

2. Vouw in de sectie Resources uw Azure Function-app-resource uit. Klik met de rechtermuisknop op de naam van de functie en selecteer Functie-URL kopiëren.

3. Plak de URL in een browser. Dezelfde lege matrix wordt geretourneerd als toen u de functie lokaal hebt uitgevoerd.

   {"blogposts":[]}
   

10. Integratie van Azure Cosmos DB voor MongoDB-API toevoegen

Azure Cosmos DB biedt een MongoDB-API om een vertrouwd integratiepunt te bieden.

1. Open azure Explorer in Visual Studio Code door het Azure-pictogram in de primaire zijbalk te selecteren of gebruik de sneltoets (Shift + Alt + A).

2. Selecteer in de sectie Resources de + optie Databaseserver maken. Gebruik de volgende tabel om de aanwijzingen te voltooien om een nieuwe Azure Cosmos DB-resource te maken.

   Prompt	Weergegeven als	Opmerkingen
   Een Azure Database Server selecteren	Azure Cosmos DB for MongoDB-API
   Geef een Azure Cosmos DB-accountnaam op.	cosmosdb-mongodb-database	Plaats drie tekens om een unieke naam te maken. De naam wordt onderdeel van de URL van de API.
   Selecteer een capaciteitsmodel.	Serverloos
   Selecteer een resourcegroep voor nieuwe resources.	azure-tutorial-first-function	Selecteer de resourcegroep die u in een vorige sectie hebt gemaakt.
   Selecteer een locatie voor nieuwe resources.	Selecteer de aanbevolen regio.

11. Mongoose-afhankelijkheid installeren

Druk in een Visual Studio Code-terminal op Ctrl + Shift + ` en installeer het npm-pakket:

npm install mongoose

12. Mongoose-code toevoegen voor blogberichten

1. Maak in Visual Studio Code een submap met de naam lib op ./src/, maak een bestand met de naam ./database.ts en kopieer de volgende code erin.

   import { Schema, Document, createConnection, ConnectOptions, model, set } from 'mongoose';
   
   const connectionString = process.env.MONGODB_URI;
   console.log('connectionString', connectionString);
   
   const connection = createConnection(connectionString, {
     useNewUrlParser: true,
     useUnifiedTopology: true,
     autoIndex: true
   } as ConnectOptions);
   
   export interface IBlogPost {
     author: string
     title: string
     body: string
   }
   
   export interface IBlogPostDocument extends IBlogPost, Document {
     id: string
     created: Date
   }
   
   const BlogPostSchema = new Schema({
     id: Schema.Types.ObjectId,
     author: String,
     title: String,
     body: String,
     created: {
       type: Date,
       default: Date.now
     }
   });
   
   BlogPostSchema.set('toJSON', {
     transform: function (doc, ret, options) {
         ret.id = ret._id;
         delete ret._id;
         delete ret.__v;
     }
   }); 
   
   export const BlogPost = model<IBlogPostDocument>('BlogPost', BlogPostSchema);
   
   connection.model('BlogPost', BlogPostSchema);
   
   export default connection;
   

2. Open het ./src/functions/blogposts bestand in Visual Studio Code en vervang de code van het hele bestand door het volgende:

   import { app, HttpRequest, HttpResponseInit, InvocationContext } from "@azure/functions";
   import connection from '../lib/database';
   
   // curl --location 'http://localhost:7071/api/blogposts' --verbose
   export async function getBlogPosts(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
       context.log(`Http function getBlogPosts processed request for url "${request.url}"`);
   
       const blogposts = await connection.model('BlogPost').find({});
   
       return {
           status: 200,
           jsonBody: {
               blogposts
           }
       };
   };
   
   app.get('getBlogPosts', {
       route: "blogposts",
       authLevel: 'anonymous',
       handler: getBlogPosts
   });
   

13. Voeg verbindingsreeks toe aan de lokale app

1. Selecteer in Azure Explorer van Visual Studio Code de sectie Azure Cosmos DB en vouw deze uit om met de rechtermuisknop op uw nieuwe resource te klikken.

2. Selecteer Verbindingsreeks kopiëren.

3. Gebruik in Visual Studio Code de Verkenner om te openen ./local.settings.json.

4. Voeg een nieuwe eigenschap toe met de naam MONGODB_URI en plak de waarde van uw verbindingsreeks.

   {
     "IsEncrypted": false,
     "Values": {
       "AzureWebJobsStorage": "",
       "FUNCTIONS_WORKER_RUNTIME": "node",
       "AzureWebJobsFeatureFlags": "EnableWorkerIndexing",
       "MONGODB_URI": "mongodb://...."
     }
   }
   

   De geheimen in het ./local.settings.json bestand:

   • Wordt niet geïmplementeerd in Azure omdat deze is opgenomen in het ./.funcignore bestand.
   • Is niet ingecheckt bij broncodebeheer omdat deze is opgenomen in het ./.gitignore bestand.

5. Voer de toepassing lokaal uit en test de API met dezelfde URL in de vorige sectie.

14. Verbindingsreeks toevoegen aan externe app

1. Open azure Explorer in Visual Studio Code door het Azure-pictogram in de primaire zijbalk te selecteren of gebruik de sneltoets (Shift + Alt + A).
2. Zoek in de sectie Resources uw Azure Cosmos DB-exemplaar. Klik met de rechtermuisknop op de resource en selecteer Copy Verbinding maken ion String.
3. Zoek uw functie-app in dezelfde sectie Resources en vouw het knooppunt uit.
4. Klik met de rechtermuisknop op De toepassing Instellingen en selecteer Nieuwe instelling toevoegen.
5. Voer de naam MONGODB_URI van de app-instelling in en selecteer Enter.
6. Plak de waarde die u hebt gekopieerd en druk op Enter.

15. API's toevoegen voor het maken, bijwerken en verwijderen van blogposts

1. Gebruik in Visual Studio Code het opdrachtpalet om Azure Functions te zoeken en te selecteren : Functie maken.

2. Selecteer de HTTP-trigger en geef deze blogpost een naam (enkelvoud).

3. Kopieer de volgende code naar het bestand.

   import { app, HttpRequest, HttpResponseInit, InvocationContext } from "@azure/functions";
   import connection, { IBlogPost, IBlogPostDocument }  from '../lib/database';
   
   // curl -X POST --location 'http://localhost:7071/api/blogpost' --header 'Content-Type: application/json' --data '{"author":"john","title":"my first post", "body":"learn serverless node.js"}' --verbose
   export async function addBlogPost(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
       context.log(`Http function addBlogPost processed request for url "${request.url}"`);
   
       const body = await request.json() as IBlogPost;
   
       const blogPostResult = await connection.model('BlogPost').create({
           author: body?.author,
           title: body?.title,
           body: body?.body
       });
   
       return {
           status: 200,
           jsonBody: {
               blogPostResult
           }
       };
   };
   
   // curl -X PUT --location 'http://localhost:7071/api/blogpost/64568e727f7d11e09eab473c' --header 'Content-Type: application/json' --data '{"author":"john jones","title":"my first serverless post", "body":"Learn serverless Node.js with Azure Functions"}' --verbose
   export async function updateBlogPost(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
       context.log(`Http function updateBlogPost processed request for url "${request.url}"`);
   
       const body = await request.json() as IBlogPost;
       const id = request.params.id;
   
       const blogPostResult = await connection.model('BlogPost').updateOne({ _id: id }, {
           author: body?.author,
           title: body?.title,
           body: body?.body
       });
   
       if(blogPostResult.matchedCount === 0) {
           return {
               status: 404,
               jsonBody: {
                   message: 'Blog post not found'
               }
           };
       }
   
       return {
           status: 200,
           jsonBody: {
               blogPostResult
           }
       };
   };
   
   // curl --location 'http://localhost:7071/api/blogpost/6456597918547e37d515bda3' --verbose
   export async function getBlogPost(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
       context.log(`Http function getBlogPosts processed request for url "${request.url}"`);
   
       console.log('request.params.id', request.params.id)
       const id = request.params.id;
   
       const blogPost = await connection.model('BlogPost').findOne({ _id: id });
   
       if(!blogPost) {
           return {
               status: 404,
               jsonBody: {
                   message: 'Blog post not found'
               }
           };
       }
   
       return {
           status: 200,
           jsonBody: {
               blogPost
           }
       };
   };
   
   // curl --location 'http://localhost:7071/api/blogpost/6456597918547e37d515bda3' --request DELETE --header 'Content-Type: application/json' --verbose
   export async function deleteBlogPost(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
       context.log(`Http function deleteBlogPost processed request for url "${request.url}"`);
   
       const id = request.params.id;
   
       const blogPostResult = await connection.model('BlogPost').deleteOne({ _id: id });
   
       if(blogPostResult.deletedCount === 0) {
           return {
               status: 404,
               jsonBody: {
                   message: 'Blog post not found'
               }
           };
       }
   
       return {
           status: 200,
           jsonBody: {
               blogPostResult
           }
       };
   };
   
   app.get('getBlogPost', {
       route: "blogpost/{id}",
       authLevel: 'anonymous',
       handler: getBlogPost
   });
   
   app.post('postBlogPost', {
       route: "blogpost",
       authLevel: 'anonymous',
       handler: addBlogPost
   });
   
   app.put('putBlogPost', {
       route: "blogpost/{id}",
       authLevel: 'anonymous',
       handler: updateBlogPost
   });
   
   app.deleteRequest('deleteBlogPost', {
       route: "blogpost/{id}",
       authLevel: 'anonymous',
       handler: deleteBlogPost
   });
   

4. Start de lokale functie opnieuw met het foutopsporingsprogramma. De volgende API's zijn beschikbaar:

   deleteBlogPost: [DELETE] http://localhost:7071/api/blogpost/{id}
   getBlogPost: [GET] http://localhost:7071/api/blogpost/{id}
   getBlogPosts: [GET] http://localhost:7071/api/blogposts
   postBlogPost: [POST] http://localhost:7071/api/blogpost
   putBlogPost: [PUT] http://localhost:7071/api/blogpost/{id}
   

5. Gebruik de blogpost (singular) API van een cURL-opdracht om een paar blogberichten toe te voegen.

   curl -X POST --location 'http://localhost:7071/api/blogpost' --header 'Content-Type: application/json' --data '{"author":"john","title":"my first post", "body":"learn serverless node.js"}' --verbose
   

6. Gebruik de blogposts (meervoud) API van een cURL-opdracht om de blogberichten op te halen.

   curl http://localhost:7071/api/blogposts --verbose
   

16. Alle gegevens weergeven met de Visual Studio Code-extensie voor Azure Cosmos DB

1. Open azure Explorer in Visual Studio Code door het Azure-pictogram in de primaire zijbalk te selecteren of gebruik de sneltoets (Shift + Alt + A).

2. Klik in de sectie Resources met de rechtermuisknop op uw Azure Cosmos DB-database en selecteer Vernieuwen.

3. Vouw de verzamelingsknooppunten van de testdatabase en blogposts uit om de documenten weer te geven.

4. Selecteer een van de items die worden weergegeven om de gegevens in het Azure Cosmos DB-exemplaar weer te geven.

   

17. Implementeer de functie-app opnieuw om databasecode op te nemen

1. Open azure Explorer in Visual Studio Code door het Azure-pictogram in de primaire zijbalk te selecteren of gebruik de sneltoets (Shift + Alt + A).
2. Klik in de sectie Resources met de rechtermuisknop op uw Azure Function-app en selecteer Implementeren in functie-app.
3. Selecteer Implementeren in het pop-upvenster waarin u wordt gevraagd of u zeker weet dat u wilt implementeren.
4. Wacht totdat de implementatie is voltooid voordat u doorgaat.

18. Cloudgebaseerde Azure-functie gebruiken

1. Nog steeds in Azure Explorer selecteert en vouwt u in het gebied Functions uw functie uit en vouwt u deze uit, vervolgens het Functions-knooppunt , waarin de API's worden vermeld
2. Klik met de rechtermuisknop op een van de API's en selecteer Functie-URL kopiëren.
3. Bewerk de vorige cURL-opdrachten om de externe URL te gebruiken in plaats van de lokale URL. Voer de opdrachten uit om de externe API te testen.

19. Query's uitvoeren op uw Azure-functielogboeken

Als u de logboeken wilt doorzoeken, gebruikt u Azure Portal.

1. Selecteer in Visual Studio Code de Azure Explorer en klik vervolgens onder Functions met de rechtermuisknop op uw functie-app en selecteer Vervolgens Openen in de portal.

   Hiermee opent u Azure Portal naar uw Azure-functie.

2. Selecteer In Instellingen Application Insights en selecteer vervolgens Application Insights-gegevens weergeven.

   

   Met deze koppeling gaat u naar uw afzonderlijke metrische gegevensresource die voor u is gemaakt bij het maken van uw Azure-functie met Visual Studio Code.

3. Selecteer Logboeken in de sectie Bewaking. Als er een pop-upvenster Query's wordt weergegeven, selecteert u de X in de rechterbovenhoek van het pop-upvenster om het venster te sluiten.

4. Dubbelklik in het deelvenster Nieuwe query 1 op het tabblad Tabellen op de tabel Traceringen .

   Hiermee wordt de Kusto-querytraces ingevoerd in het queryvenster.

5. Bewerk de query om te zoeken naar de aangepaste logboeken:

   traces 
   | where message startswith "***"
   

6. Selecteer Uitvoeren.

   Als het logboek geen resultaten weergeeft, kan het zijn dat er een paar minuten vertraging is tussen de HTTP-aanvraag en de beschikbaarheid van het logboek in Kusto. Wacht enkele minuten en voer de query opnieuw uit.

   U hoeft niets extra's te doen om deze logboekgegevens op te halen:

   • De code heeft de context.log functie gebruikt die door het Function-framework wordt geleverd. Met behulp contextvan , in plaats van console, kunt u uw logboekregistratie filteren op de specifieke afzonderlijke functie. Dit is handig als uw functie-app veel functies heeft.
   • De functie-app heeft Application Insights voor u toegevoegd.
   • Het Kusto Query-hulpprogramma is opgenomen in Azure Portal.
   • U kunt in traces plaats van te leren hoe u een Kusto-query schrijft om zelfs de minimale informatie uit uw logboeken op te halen.

20. Resources opschonen

Omdat u één resourcegroep hebt gebruikt, kunt u alle resources verwijderen door de resourcegroep te verwijderen.

1. Open azure Explorer in Visual Studio Code door het Azure-pictogram in de primaire zijbalk te selecteren of gebruik de sneltoets (Shift + Alt + A).
2. Zoek en selecteer Azure: Groeperen op resourcegroep.
3. Klik met de rechtermuisknop op de resourcegroep en selecteer Resourcegroep verwijderen.
4. Voer de naam van de resourcegroep in om het verwijderen te bevestigen.

Beschikbare broncode

Volledige broncode voor deze Azure Function-app:

• Voorbeeldcode

Volgende stappen

Een Azure-functie maken om Azure-resources te beheren