Serverlose TypeScript-API: Speichern von Daten in MongoDB mit Azure-Funktionen

Erstellen Sie eine Azure-Funktions-API zum Speichern von Daten mit der Mongoose-API in Azure Cosmos DB, und stellen Sie dann die Funktionsanwendung für das Hosting mit einem öffentlichen HTTP-Endpunkt in der Azure-Cloud bereit.

Hinweis

In diesem Artikel wird das Programmiermodell azure Functions Node.js v4 zurzeit in der Vorschau verwendet.

Vorbereiten Ihrer Entwicklungsumgebung

Installieren Sie die folgende Software:

• Erstellen eines kostenlosen Azure-Abonnements
• Installieren von Node.js LTS v18+
• TypeScript v4 oder höher
• Azurite weltweit für den lokalen Entwicklungsspeicher installiert
• Azure Functions-Runtime v4.16 oder höher
• Azure Functions Core Tools v4.0.5095+ (wenn lokal ausgeführt) global für die lokale Entwicklung installiert
• Installieren Sie Visual Studio Code, und verwenden Sie die folgenden Erweiterungen:
  • Azure-Ressourcen
  • Azure-Funktionen
  • Azure-Datenbanken

1. Anmelden bei Azure in Visual Studio Code

Wenn Sie die Azure-Diensterweiterungen bereits verwenden, sollten Sie bereits angemeldet sein, und Sie können diesen Schritt überspringen.

Nachdem Sie eine Azure-Diensterweiterung in Visual Studio Code installiert haben, müssen Sie sich bei Ihrem Azure-Konto anmelden.

1. Öffnen Sie in Visual Studio Code den Azure-Explorer, indem Sie das Azure-Symbol in der primären Seitenleiste auswählen oder die Tastenkombination (UMSCHALT + ALT + A) verwenden.

2. Wählen Sie im Abschnitt "Ressourcen " die Option " Bei Azure anmelden" aus, und folgen Sie den Anweisungen.

   

3. Vergewissern Sie sich nach der Anmeldung, dass die E-Mail-Adresse Ihres Azure-Kontos auf der Statusleiste und Ihre Abonnements in Azure Explorer angezeigt werden:

   

2. Erstellen einer Azure-Ressourcengruppe

Eine Ressourcengruppe ist eine regionsbasierte Sammlung mit Ressourcen. Wenn Sie eine Ressourcengruppe und anschließend Ressourcen in dieser Gruppe erstellen, können Sie am Ende des Tutorials die Ressourcengruppe löschen, ohne die Ressourcen einzeln löschen zu müssen.

1. Erstellen Sie einen neuen Ordner in Ihrem lokalen System, der als Stamm des Azure-Funktionsprojekts verwendet werden soll.

2. Öffnen Sie diesen Ordner in Visual Studio Code.

3. Öffnen Sie in Visual Studio Code den Azure-Explorer, indem Sie das Azure-Symbol in der primären Seitenleiste auswählen oder die Tastenkombination (UMSCHALT + ALT + A) verwenden.

4. Suchen Sie Ihr Abonnement unter "Ressourcen", und wählen Sie das + Symbol und dann "Ressourcengruppe erstellen" aus.

5. Gehen Sie bei den Aufforderungen gemäß der folgenden Tabelle vor:

   Prompt	Wert
   Geben Sie den Namen der neuen Ressourcengruppe ein.	azure-tutorial
   Select a location for your new resources. (Wählen Sie einen Standort für Ihre neuen Ressourcen aus.)	Wählen Sie eine geografische Region in Ihrer Nähe aus.

3. Erstellen der lokalen Funktionen-App

Erstellen Sie eine lokale (serverlose) Azure Functions-Anwendung, die eine Funktion mit einem HTTP-Trigger enthält.

1. Öffnen Sie in Visual Studio Code die Befehlspalette (STRG + UMSCHALT + P).

2. Suchen und wählen Sie Azure-Funktionen aus: Neues Projekt erstellen .

3. Schließen Sie die Erstellung des lokalen Azure-Funktionsprojekts anhand der folgenden Tabelle ab:

   Prompt	Wert	Hinweise
   Wählen Sie den Ordner aus, der Ihr Funktionsprojekt enthält.	Wählen Sie den aktuellen Ordner (Standardordner) aus.
   Sprache auswählen	TypeScript
   Wählen Sie ein TypeScript-Programmiermodell aus.	Modell V4 (Vorschau)
   Auswählen einer Vorlage für die erste Funktion Ihres Projekts	HTTP-Trigger	Die API wird mit einer HTTP-Anforderung aufgerufen.
   Angeben eines Funktionsnamens	blogposts	Die API-Route lautet /api/blogposts.

4. Wenn Visual Studio Code das Projekt erstellt, zeigen Sie den API-Code in der ./src/functions/blogposts.ts Datei an.

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

   Dieser Code ist Standardbaustein im neuen v4-Programmiermodell. Es ist nicht vorgesehen, die einzige Möglichkeit zum Schreiben einer API-Ebene mit POST und GET anzugeben.

5. Ersetzen Sie den vorherigen Code durch den folgenden Code, damit nur GET-Anforderungen alle Blogbeiträge zurückgeben können.

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

   Es gibt mehrere Programmiermodelländerungen von Azure Functions Node.js v4 in diesem Code, die Sie beachten sollten:

   • Der Funktionsname von getBlobPosts, der angibt, dass es sich um eine GET-Anforderung ist, hilft Ihnen, die Funktion in den Protokollen zu isolieren.
   • Die route Eigenschaft ist auf blogposts, die Teil der bereitgestellten Standard-API-Route ist, /api/blogpostsfestgelegt.
   • Die methods Eigenschaft wurde entfernt und ist unnötig, da die app Verwendung get des Objekts angibt, dass es sich um eine GET-Anforderung handelt. Die Methodenfunktionen sind unten aufgeführt. Wenn Sie über eine andere Methode verfügen, können Sie zur Verwendung der methods Eigenschaft zurückkehren.
     • deleteRequest()
     • get()
     • patch()
     • post()
     • put()

4. Start Azurite lokaler Speicher-Emulator

Für die Entwicklung von Funktionen auf Ihrem lokalen Computer ist entweder ein Speicheremulator (kostenlos) oder ein Azure Storage-Konto (kostenpflichtig) erforderlich.

Starten Sie in einem separaten Terminal den Lokalen Speicheremulator Azurite .

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

Dies ist erforderlich, um die Azure Functions lokal mit einem lokalen Azure Storage-Emulator auszuführen. Der lokale Speicheremulator wird in der local.settings.json Datei mit der AzureWebJobsStorage-Eigenschaft mit dem Wert " UseDevelopmentStorage=true.

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

Der azurite Unterordner wurde ihrer Datei bereits hinzugefügt .gitignore .

5. Ausführen der lokalen serverlosen Funktion

Führen Sie das Azure Functions-Projekt lokal aus, um es vor der Bereitstellung in Azure zu testen.

1. Legen Sie in Visual Studio Code am Ende der getBlogPosts-Funktion einen Haltepunkt für die return Anweisung fest.

2. Drücken Sie in Visual Studio Code F5, um den Debugger zu starten und an den Azure Functions-Host anzufügen.

   Sie können auch den Menübefehl Debuggen>Debugging starten verwenden.

3. Die Ausgabe wird im Terminalbereich angezeigt.

4. Öffnen Sie in Visual Studio Code den Azure-Explorer, indem Sie das Azure-Symbol in der primären Seitenleiste auswählen oder die Tastenkombination (UMSCHALT + ALT + A) verwenden.

5. Suchen und erweitern Sie im Abschnitt "Arbeitsbereich" das lokale Projekt ->Functions ->getBlogPosts.

6. Klicken Sie mit der rechten Maustaste auf den Funktionsnamen, getBlogPosts, und wählen Sie dann "Funktions-URL kopieren" aus.

   

7. Fügen Sie in Ihrem Browser die URL ein, und wählen Sie die EINGABETASTE aus, oder verwenden Sie den folgenden cURL-Befehl im Terminal:

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

   Die Antwort eines leeren Arrays von Blogbeiträgen wird wie folgt zurückgegeben:

   *   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. Beenden Sie in VS Code den Debugger, UMSCHALT + F5.

6. Erstellen der Azure-Funktions-App in Visual Studio Code

In diesem Abschnitt erstellen Sie eine Funktions-App-Cloudressource und zugehörige Ressourcen in Ihrem Azure-Abonnement.

1. Öffnen Sie in Visual Studio Code die Befehlspalette (STRG + UMSCHALT + P).

2. Suchen und wählen Sie Azure-Funktionen aus: Erstellen der Funktions-App in Azure (Erweitert) .

3. Geben Sie nach entsprechender Aufforderung Folgendes ein:

   Prompt	Auswahl
   Eingeben eines global eindeutigen Namens für die Funktions-App	Geben Sie einen Namen ein, der in einem URL-Pfad gültig ist, z first-function. B. . Postpend 3 Zeichen, um die URL global eindeutig zu machen. Der eingegebene Name wird überprüft, um sicherzustellen, dass er in Azure Functions eindeutig ist.
   Auswählen eines Runtimestapels	Wählen Sie Node.js 18 LTS oder eine neuere Version aus.
   Auswählen eines Betriebssystems	Wählen Sie Linux aus.
   Select a resource group for new resources. (Wählen Sie eine Ressourcengruppe für neue Ressourcen aus.)	Erstellen Sie eine neue Ressourcengruppe namens azure-tutorial-first-function. Diese Ressourcengruppe verfügt schließlich über mehrere Ressourcen: Azure Function, Azure Storage und die Cosmos DB für die MongoDB-API.
   Auswählen eines Hostingplans	Wählen Sie "Verbrauch" aus.
   Auswählen eines Speicherkontos	Wählen Sie "Neues Speicherkonto erstellen" aus, und akzeptieren Sie den Standardnamen.
   Wählen Sie eine Application Insights-Ressource für Ihre App aus.	Wählen Sie "Neue Application Insights-Ressource erstellen" aus, und akzeptieren Sie den Standardnamen.

   Warten Sie, bis die Benachrichtigung bestätigt, dass die App erstellt wurde.

7. Bereitstellen der Azure-Funktions-App in Azure in Visual Studio Code

Wichtig

Bei der Bereitstellung in einer vorhandenen Funktions-App wird der Inhalt dieser App in Azure immer überschrieben.

1. Wählen Sie das Azure-Symbol in der Aktivitätsleiste aus, und klicken Sie dann im Bereich "Ressourcen" mit der rechten Maustaste auf die Ressourcenressource der Funktions-App, und wählen Sie die Option "In Funktions-App bereitstellen" aus.
2. Wenn Sie gefragt werden, ob Sie sicher sind, dass Sie bereitstellen möchten, wählen Sie "Bereitstellen" aus.
3. Nach Abschluss der Bereitstellung wird eine Benachrichtigung mit mehreren Optionen angezeigt. Wählen Sie "Ausgabe anzeigen" aus, um die Ergebnisse anzuzeigen. Wenn Sie die Benachrichtigung übersehen haben, wählen Sie das Glockensymbol in der unteren rechten Ecke aus, um sie erneut anzuzeigen.

8. Hinzufügen der Anwendungseinstellung zur Cloud-App

1. Wählen Sie das Azure-Symbol in der Aktivitätsleiste aus, und erweitern Sie dann im Bereich "Ressourcen" Die App-Ressource der Funktion, und klicken Sie mit der rechten Maustaste auf "Anwendung Einstellungen".

2. Wählen Sie "Neue Einstellung hinzufügen" aus, und fügen Sie die folgende Einstellung hinzu, um das Programmiermodell Node.js v4 (Vorschau) zu aktivieren.

   Einstellung	Wert
   AzureWebJobsFeatureFlags	EnableWorkerIndexing

9. Ausführen der Remoteserverless-Funktion

1. Öffnen Sie in Visual Studio Code den Azure-Explorer, indem Sie das Azure-Symbol in der primären Seitenleiste auswählen oder die Tastenkombination (UMSCHALT + ALT + A) verwenden.

2. Erweitern Sie im Abschnitt "Ressourcen " Ihre Azure Function-App-Ressource. Klicken Sie mit der rechten Maustaste auf den Funktionsnamen, und wählen Sie "Funktions-URL kopieren" aus.

3. Fügen Sie die URL in einen Browser ein. Dasselbe leere Array wird zurückgegeben, wie wenn Sie die Funktion lokal ausgeführt haben.

   {"blogposts":[]}
   

10. Hinzufügen der Azure Cosmos DB für die MongoDB-API-Integration

Azure Cosmos DB stellt eine MongoDB-API bereit, um einen vertrauten Integrationspunkt bereitzustellen.

1. Öffnen Sie in Visual Studio Code den Azure-Explorer, indem Sie das Azure-Symbol in der primären Seitenleiste auswählen oder die Tastenkombination (UMSCHALT + ALT + A) verwenden.

2. Wählen Sie im Abschnitt "Ressourcen " die + Option "Datenbankserver erstellen" aus. Halten Sie sich bei den Aufforderungen zum Erstellen einer neuen Azure Cosmos DB-Ressource an die folgende Tabelle:

   Prompt	Wert	Hinweise
   Select an Azure Database Server. (Wählen Sie einen Azure-Datenbankserver aus.)	Azure Cosmos DB für MongoDB-API
   Geben Sie einen Azure Cosmos DB-Kontonamen an.	cosmosdb-mongodb-database	Postpend drei Zeichen, um einen eindeutigen Namen zu erstellen. Der Name wird Teil der API-URL.
   Select a capacity model. (Wählen Sie ein Kapazitätsmodell aus.)	Serverlos
   „Select a resource group for new resources.“ (Wählen Sie eine Ressourcengruppe für neue Ressourcen aus.)	azure-tutorial-first-function	Wählen Sie die Ressourcengruppe aus, die Sie in einem vorherigen Abschnitt erstellt haben.
   Wählen Sie einen Standort für neue Ressourcen aus.	Wählen Sie die empfohlene Region aus.

11. Installieren sie mongoose Abhängigkeit

Installieren Sie in einem Visual Studio Code-Terminal STRG + UMSCHALT + `, und installieren Sie dann das npm-Paket:

npm install mongoose

12. Hinzufügen von Mongoosecode für Blogbeiträge

1. Erstellen Sie in Visual Studio Code ein Unterverzeichnis namens "lib at ./src/", erstellen Sie eine Datei mit dem Namen ./database.ts und kopieren Sie den folgenden Code in das Verzeichnis.

   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. Öffnen Sie in Visual Studio Code die Datei ./src/functions/blogposts, und ersetzen Sie den Code der gesamten Datei durch Folgendes:

   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. Hinzufügen von Verbindungszeichenfolge zur lokalen App

1. Wählen Sie im Azure-Explorer von Visual Studio Code den Azure Cosmos DB-Abschnitt aus, und erweitern Sie, um mit der rechten Maustaste auf Ihre neue Ressource auszuwählen.

2. Wählen Sie "Verbindungszeichenfolge kopieren" aus.

3. Verwenden Sie in Visual Studio Code den Datei-Explorer, um zu öffnen ./local.settings.json.

4. Fügen Sie eine neue Eigenschaft hinzu, die aufgerufen wirdMONGODB_URI, und fügen Sie den Wert Ihres Verbindungszeichenfolge ein.

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

   Die geheimen Schlüssel in der ./local.settings.json Datei:

   • Wird nicht in Azure bereitgestellt, da sie in der ./.funcignore Datei enthalten ist.
   • Ist nicht in die Quellcodeverwaltung eingecheckt, da sie in der ./.gitignore Datei enthalten ist.

5. Führen Sie die Anwendung lokal aus, und testen Sie die API mit derselben URL im vorherigen Abschnitt.

14. Hinzufügen von Verbindungszeichenfolge zur Remote-App

1. Öffnen Sie in Visual Studio Code den Azure-Explorer, indem Sie das Azure-Symbol in der primären Seitenleiste auswählen oder die Tastenkombination (UMSCHALT + ALT + A) verwenden.
2. Suchen Sie im Abschnitt "Ressourcen " Ihre Azure Cosmos DB-Instanz. Klicken Sie mit der rechten Maustaste auf die Ressource, und wählen Sie "Verbinden ionzeichenfolge kopieren" aus.
3. Suchen Sie im gleichen Abschnitt "Ressourcen " Ihre Funktions-App, und erweitern Sie den Knoten.
4. Klicken Sie mit der rechten Maustaste auf Anwendungseinstellungen, und wählen Sie Neue Einstellung hinzufügen aus.
5. Geben Sie den Namen der App-Einstellung ein, MONGODB_URI und drücken Sie die EINGABETASTE.
6. Fügen Sie den kopierten Wert ein, und drücken Sie die EINGABETASTE.

15. Hinzufügen von APIs zum Erstellen, Aktualisieren und Löschen von Blogposts

1. Verwenden Sie in Visual Studio Code die Befehlspalette, um Azure-Funktionen zu suchen und auszuwählen : Funktion erstellen.

2. Wählen Sie HTTP-Trigger aus, und nennen Sie ihn blogpost (Singular).

3. Kopieren Sie den folgenden Code in die Datei.

   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. Starten Sie die lokale Funktion erneut mit dem Debugger. Die folgenden APIs sind verfügbar:

   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. Verwenden Sie die blogpost (Singular)-API aus einem cURL-Befehl, um ein paar Blogbeiträge hinzuzufügen.

   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. Verwenden Sie die blogposts (Plural)-API aus einem cURL-Befehl, um die Blogbeiträge abzurufen.

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

16. Anzeigen aller Daten mit der Visual Studio Code-Erweiterung für Azure Cosmos DB

1. Öffnen Sie in Visual Studio Code den Azure-Explorer, indem Sie das Azure-Symbol in der primären Seitenleiste auswählen oder die Tastenkombination (UMSCHALT + ALT + A) verwenden.

2. Klicken Sie im Abschnitt "Ressourcen" mit der rechten Maustaste auf Ihre Azure Cosmos DB-Datenbank, und wählen Sie "Aktualisieren" aus.

3. Erweitern Sie die Knoten der Testdatenbank und der Blogposts-Sammlung , um die Dokumente anzuzeigen.

4. Wählen Sie eines der aufgelisteten Elemente aus, um die Daten in der Azure Cosmos DB-Instanz anzuzeigen.

   

17. Erneutes Bereitstellen der Funktions-App, um Datenbankcode einzuschließen

1. Öffnen Sie in Visual Studio Code den Azure-Explorer, indem Sie das Azure-Symbol in der primären Seitenleiste auswählen oder die Tastenkombination (UMSCHALT + ALT + A) verwenden.
2. Klicken Sie im Abschnitt "Ressourcen" mit der rechten Maustaste auf Ihre Azure-Funktions-App, und wählen Sie "In Funktions-App bereitstellen" aus.
3. Wählen Sie im Popup mit der Frage, ob Sie sicher sind, dass Sie bereitstellen möchten, "Bereitstellen" aus.
4. Warten Sie, bis die Bereitstellung abgeschlossen ist, bevor Sie fortfahren.

18. Verwenden der cloudbasierten Azure-Funktion

1. Wählen Sie im Azure-Explorer im Bereich "Funktionen" Ihre Funktion aus und erweitert sie dann den Knoten "Funktionen", der die APIs auflistet.
2. Klicken Sie mit der rechten Maustaste auf eine der APIs, und wählen Sie "Funktions-URL kopieren" aus.
3. Bearbeiten Sie die vorherigen cURL-Befehle, um die Remote-URL anstelle der lokalen URL zu verwenden. Führen Sie die Befehle aus, um die Remote-API zu testen.

19. Abfragen Ihrer Azure-Funktionsprotokolle

Verwenden Sie das Azure-Portal, um die Protokolle zu durchsuchen.

1. Wählen Sie in Visual Studio Code den Azure-Explorer aus, und klicken Sie dann unter "Funktionen" mit der rechten Maustaste auf Ihre Funktions-App, und wählen Sie dann "Im Portal öffnen" aus.

   Das Azure-Portal wird mit Ihrer Azure-Funktion geöffnet.

2. Wählen Sie in Einstellungen "Application Insights" und dann "Application Insights-Daten anzeigen" aus.

   

   Über diesen Link gelangen Sie zu Ihrer separaten Metrikressource, die für Sie erstellt wurde, als Sie Ihre Azure-Funktion mit Visual Studio Code erstellt haben.

3. Wählen Sie im Abschnitt "Überwachung" die Option "Protokolle" aus. Wählen Sie im angezeigten Popupfenster Abfragen oben rechts das X aus, um das Fenster zu schließen.

4. Doppelklicken Sie im Bereich Neue Abfrage 1 auf der Registerkarte Tabellen auf die Tabelle traces.

   Die Kusto-Abfragetraces wird in das Abfragefenster eingegeben.

5. Bearbeiten Sie die Abfrage so, dass nach den benutzerdefinierten Protokollen gesucht wird:

   traces 
   | where message startswith "***"
   

6. Ausführen auswählen.

   Wenn das Protokoll keine Ergebnisse anzeigt, liegt dies möglicherweise daran, dass zwischen der HTTP-Anforderung an die Azure-Funktion und der Protokollverfügbarkeit in Kusto ein paar Minuten verzögerung. Warten Sie einige Minuten, und führen Sie die Abfrage dann erneut durch.

   Sie mussten keine zusätzlichen Schritte ausführen, um diese Protokollierungsinformationen zu erhalten:

   • Der Code verwendet die context.log vom Funktionsframework bereitgestellte Funktion. Durch Die Verwendung contextder Protokollierung kann anstelle der consoleProtokollierung auf die jeweilige einzelne Funktion gefiltert werden. Dies ist nützlich, wenn Ihre Funktions-App über viele Funktionen verfügt.
   • Die Funktions-App hat Application Insights für Sie hinzugefügt.
   • Das Kusto-Abfragetool ist im Azure-Portal enthalten.
   • Sie können auswählen traces , anstatt zu lernen, eine Kusto-Abfrage zu schreiben, um sogar die Mindestinformationen aus Ihren Protokollen abzurufen.

20. Bereinigen von Ressourcen

Da Sie eine einzelne Ressourcengruppe verwendet haben, können Sie alle Ressourcen löschen, indem Sie die Ressourcengruppe löschen.

1. Öffnen Sie in Visual Studio Code den Azure-Explorer, indem Sie das Azure-Symbol in der primären Seitenleiste auswählen oder die Tastenkombination (UMSCHALT + ALT + A) verwenden.
2. Suchen Und wählen Sie Azure: Gruppieren nach Ressourcengruppe aus.
3. Klicken Sie mit der rechten Maustaste auf Ihre Ressourcengruppe, und wählen Sie "Ressourcengruppe löschen" aus.
4. Geben Sie den Namen der Ressourcengruppe ein, um den Löschvorgang zu bestätigen.

Quellcode verfügbar

Vollständiger Quellcode für diese Azure Function-App:

• Beispielcode

Nächste Schritte

Erstellen einer Azure-Funktion zum Verwalten von Azure-Ressourcen