Bezserverové rozhraní TypeScript API: Ukládání dat v MongoDB pomocí Azure Functions

Vytvořte rozhraní API služby Azure Functions pro ukládání dat pomocí rozhraní Mongoose API do služby Azure Cosmos DB a pak nasaďte aplikaci funkcí do cloudu Azure pro hostování s veřejným koncovým bodem HTTP.

Poznámka:

Tento článek používá programovací model Azure Functions Node.js v4, který je aktuálně ve verzi Preview.

Příprava vývojového prostředí

Nainstalujte následující software:

• Vytvoření bezplatného předplatného Azure
• Instalace Node.js LTS v18+
• TypeScript v4+
• Azurite nainstalovaný globálně pro místní vývojové úložiště
• Modul runtime Azure Functions verze 4.16 nebo novější
• Azure Functions Core Tools v4.0.5095+ (pokud běží místně) nainstalovaný globálně pro místní vývoj
• Nainstalujte Visual Studio Code a použijte následující rozšíření:
  • Azure Resources (Prostředky Azure)
  • Azure Functions
  • Azure Databases

1. Přihlášení k Azure v editoru Visual Studio Code

Pokud už používáte rozšíření služeb Azure, měli byste být už přihlášení a můžete tento krok přeskočit.

Po instalaci rozšíření služby Azure v editoru Visual Studio Code se musíte přihlásit ke svému účtu Azure.

1. V editoru Visual Studio Code otevřete Průzkumníka Azure tak, že vyberete ikonu Azure na primárním bočním panelu nebo použijete klávesovou zkratku (Shift + Alt + A).

2. V části Prostředky vyberte Přihlásit se k Azure a postupujte podle pokynů.

   

3. Po přihlášení ověřte, že se e-mailová adresa vašeho účtu Azure zobrazí na stavovém řádku a vaše předplatná se zobrazí v Průzkumníku Azure :

   

2. Vytvoření skupiny prostředků Azure

Skupina prostředků je kolekce prostředků založená na oblasti. Vytvořením skupiny prostředků a následným vytvořením prostředků v této skupině na konci kurzu můžete odstranit skupinu prostředků, aniž byste museli odstranit jednotlivé prostředky.

1. Vytvořte novou složku v místním systému, která se použije jako kořen projektu Azure Functions.

2. Otevřete tuto složku v editoru Visual Studio Code.

3. V editoru Visual Studio Code otevřete Průzkumníka Azure tak, že vyberete ikonu Azure na primárním bočním panelu nebo použijete klávesovou zkratku (Shift + Alt + A).

4. Najděte své předplatné v části Prostředky a vyberte + ikonu a pak vyberte Vytvořit skupinu prostředků.

5. K dokončení výzev použijte následující tabulku:

   Výzva	Hodnota
   Zadejte název nové skupiny prostředků.	azure-tutorial
   Vyberte umístění pro nové prostředky.	Vyberte geografickou oblast blízko vás.

3. Vytvoření místní aplikace Functions

Vytvořte místní aplikaci Azure Functions (bez serveru), která obsahuje funkci triggeru HTTP.

1. V editoru Visual Studio Code otevřete paletu příkazů (Ctrl + Shift + P).

2. Vyhledejte a vyberte Azure Functions: Vytvořit nový projekt .

3. Vytvoření místního projektu funkce Azure Functions dokončíte pomocí následující tabulky:

   Výzva	Hodnota	Notes
   Vyberte složku, která bude obsahovat váš projekt funkcí.	Vyberte aktuální (výchozí) složku.
   Vyberte jazyk	TypeScript
   Výběr programovacího modelu TypeScriptu	Model V4 (Preview)
   Výběr šablony pro první funkci projektu	Trigger HTTP	Rozhraní API se vyvolá s požadavkem HTTP.
   Zadejte název funkce.	blogposts	Trasa rozhraní API je /api/blogposts

4. Když Visual Studio Code vytvoří projekt, zobrazte v souboru kód ./src/functions/blogposts.ts rozhraní API.

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

   Tento kód je standardním standardem v novém programovacím modelu v4. Není určen k označení jediného způsobu, jak napsat vrstvu rozhraní API pomocí POST a GET.

5. Nahraďte předchozí kód následujícím kódem, aby se všechny blogové příspěvky vrátily jenom požadavky GET.

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

   V tomto kódu je několik změn programovacího modelu Azure Functions Node.js v4, které byste si měli uvědomit:

   • Název getBlobPostsfunkce označující, že se jedná o požadavek GET, vám pomůže izolovat funkci v protokolech.
   • Vlastnost route je nastavena na blogposts, která je součástí výchozí zadané trasy rozhraní API. /api/blogposts
   • Vlastnost methods byla odebrána a není nutná, protože app použití objektu get označuje, že se jedná o požadavek GET. Funkce metody jsou uvedeny níže. Pokud máte jinou metodu methods , můžete se vrátit k použití vlastnosti.
     • deleteRequest()
     • get()
     • patch()
     • post()
     • put()

4. Spusťte emulátor místního úložiště Azurite.

Vývoj funkcí na místním počítači vyžaduje buď emulátor úložiště (zdarma), nebo účet Azure Storage (placené).

V samostatném terminálu spusťte emulátor místního úložiště Azurite .

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

To se vyžaduje pro místní spuštění služby Azure Functions pomocí místního emulátoru služby Azure Storage. Emulátor místního úložiště je zadaný v local.settings.json souboru s vlastností AzureWebJobsStorage s hodnotou UseDevelopmentStorage=true.

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

Podsložka azurite už byla přidána do souboru .gitignore .

5. Spusťte místní funkci bez serveru.

Před nasazením do Azure spusťte projekt Azure Functions místně a otestujte ho.

1. V editoru Visual Studio Code nastavte na příkaz na konci funkce getBlogPosts zarážkureturn.

2. V editoru Visual Studio Code stisknutím klávesy F5 spusťte ladicí program a připojte se k hostiteli Azure Functions.

   Můžete také použít >příkaz nabídky Spustit ladění.

3. Výstup se zobrazí na panelu Terminálu .

4. V editoru Visual Studio Code otevřete Průzkumníka Azure tak, že vyberete ikonu Azure na primárním bočním panelu nebo použijete klávesovou zkratku (Shift + Alt + A).

5. V části Pracovní prostor vyhledejte a rozbalte místní projekt ->Functions ->getBlogPosts.

6. Klikněte pravým tlačítkem myši na název funkce, getBlogPosts a pak vyberte Kopírovat adresu URL funkce.

   

7. V prohlížeči vložte adresu URL a vyberte Enter nebo v terminálu použijte následující příkaz cURL:

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

   Odpověď prázdného pole blogových příspěvků se vrátí takto:

   *   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. Ve VS Code zastavte ladicí program Shift + F5.

6. Vytvoření aplikace Funkcí Azure v editoru Visual Studio Code

V této části vytvoříte v předplatném Azure cloudový prostředek aplikace funkcí a související prostředky.

1. V editoru Visual Studio Code otevřete paletu příkazů (Ctrl + Shift + P).

2. Vyhledejte a vyberte Azure Functions: Vytvoření aplikace funkcí v Azure (Upřesnit).

3. Podle pokynů na obrazovce zadejte tyto informace:

   Výzva	Výběr
   Zadejte globálně jedinečný název aplikace funkcí.	Zadejte název, který je platný v cestě URL, například first-function. Postpend 3 znaky, aby adresa URL byla globálně jedinečná. Název, který zadáte, se ověří, aby se zajistilo, že je jedinečný ve službě Azure Functions.
   Výběr zásobníku modulu runtime	Zvolte Node.js 18 LTS nebo novější verzi.
   Výběr operačního systému	Zvolte Linux.
   Výběr skupiny prostředků pro nové prostředky	Vytvořte novou skupinu prostředků s názvem azure-tutorial-first-function. Tato skupina prostředků bude mít nakonec několik prostředků: Azure Functions, Azure Storage a rozhraní API Cosmos DB for MongoDB.
   Výběr plánu hostování	Zvolte Consumption (Spotřeba).
   Výběr účtu úložiště	Vyberte Vytvořit nový účet úložiště a přijměte výchozí název.
   Vyberte prostředek Přehledy aplikace.	Vyberte Vytvořit novou aplikaci Přehledy prostředek a přijměte výchozí název.

   Počkejte, až oznámení potvrdí, že se aplikace vytvořila.

7. Nasazení aplikace Funkcí Azure do Azure v editoru Visual Studio Code

Důležité

Nasazení do existující aplikace funkcí vždy přepíše obsah této aplikace v Azure.

1. Na panelu aktivit zvolte ikonu Azure, pak v oblasti Prostředky klikněte pravým tlačítkem na prostředek aplikace funkcí a vyberte Nasadit do aplikace funkcí.
2. Pokud se zobrazí dotaz, jestli opravdu chcete nasadit, vyberte Nasadit.
3. Po dokončení nasazení se zobrazí oznámení s několika možnostmi. Výběrem možnosti Zobrazit výstup zobrazíte výsledky. Pokud oznámení vynecháte, vyberte ikonu zvonku v pravém dolním rohu a znovu ho zobrazte.

8. Přidání nastavení aplikace do cloudové aplikace

1. Na panelu aktivit zvolte ikonu Azure, pak v oblasti Prostředky rozbalte prostředek aplikace funkcí a klikněte pravým tlačítkem na možnost Aplikace Nastavení.

2. Vyberte Přidat nové nastavení a přidejte následující nastavení pro povolení programovacího modelu Node.js v4 (Preview).

   Nastavení	Hodnota
   AzureWebJobsFeatureFlags	EnableWorkerIndexing

9. Spusťte vzdálenou funkci bez serveru.

1. V editoru Visual Studio Code otevřete Průzkumníka Azure tak, že vyberete ikonu Azure na primárním bočním panelu nebo použijete klávesovou zkratku (Shift + Alt + A).

2. V části Prostředky rozbalte prostředek aplikace Funkcí Azure. Klikněte pravým tlačítkem myši na název funkce a vyberte Kopírovat adresu URL funkce.

3. Vložte adresu URL do prohlížeče. Stejné prázdné pole se vrátí jako při místním spuštění funkce.

   {"blogposts":[]}
   

10. Přidání integrace rozhraní API služby Azure Cosmos DB pro MongoDB

Azure Cosmos DB poskytuje rozhraní MongoDB API, které poskytuje známý integrační bod.

1. V editoru Visual Studio Code otevřete Průzkumníka Azure tak, že vyberete ikonu Azure na primárním bočním panelu nebo použijete klávesovou zkratku (Shift + Alt + A).

2. V části Zdroje vyberte + položku Vytvořit databázový server. Pomocí následující tabulky dokončete výzvy k vytvoření nového prostředku služby Azure Cosmos DB.

   Výzva	Hodnota	Notes
   Výběr databázového serveru Azure	Rozhraní API služby Azure Cosmos DB pro MongoDB
   Zadejte název účtu služby Azure Cosmos DB.	cosmosdb-mongodb-database	Postpend three characters to create a unique name. Název se stane součástí adresy URL rozhraní API.
   Vyberte model kapacity.	Bezserverová architektura
   Vyberte skupinu prostředků pro nové prostředky.	azure-tutorial-first-function	Vyberte skupinu prostředků, kterou jste vytvořili v předchozí části.
   Vyberte umístění pro nové prostředky.	Vyberte doporučenou oblast.

11. Instalace závislosti mongoose

V terminálu editoru Visual Studio Code stiskněte Ctrl + Shift + ` a pak nainstalujte balíček npm:

npm install mongoose

12. Přidání kódu mongoose pro blogové příspěvky

1. V editoru Visual Studio Code vytvořte podadresář s názvem lib at ./src/, vytvořte soubor s názvem ./database.ts a zkopírujte do něj následující kód.

   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. V editoru ./src/functions/blogposts Visual Studio Code otevřete soubor a nahraďte kód celého souboru následujícím kódem:

   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. Přidání připojovací řetězec do místní aplikace

1. V Průzkumníku Azure v editoru Visual Studio Code vyberte část Azure Cosmos DB a rozbalte a kliknutím pravým tlačítkem vyberte nový prostředek.

2. Vyberte Kopírovat připojovací řetězec.

3. V editoru Visual Studio Code otevřete ./local.settings.jsonprůzkumníka souborů .

4. Přidejte novou vlastnost s názvem MONGODB_URI a vložte hodnotu připojovací řetězec.

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

   Tajné kódy ./local.settings.json v souboru:

   • Není nasazená do Azure, protože je součástí ./.funcignore souboru.
   • Není vrácena se změnami do správy zdrojového kódu, protože je součástí ./.gitignore souboru.

5. Spusťte aplikaci místně a otestujte rozhraní API se stejnou adresou URL v předchozí části.

14. Přidání připojovací řetězec do vzdálené aplikace

1. V editoru Visual Studio Code otevřete Průzkumníka Azure tak, že vyberete ikonu Azure na primárním bočním panelu nebo použijete klávesovou zkratku (Shift + Alt + A).
2. V části Prostředky vyhledejte instanci služby Azure Cosmos DB. Klikněte pravým tlačítkem myši na prostředek a vyberte Kopírovat Připojení ion Řetězec.
3. Ve stejné části Prostředky najděte svou aplikaci funkcí a rozbalte uzel.
4. Klikněte pravým tlačítkem na Nastavení aplikace a vyberte Přidat nové nastavení.
5. Zadejte název MONGODB_URI nastavení aplikace a vyberte Enter.
6. Vložte zkopírovanou hodnotu a stiskněte enter.

15. Přidání rozhraní API pro vytváření, aktualizaci a odstraňování blogových příspěvků

1. V editoru Visual Studio Code pomocí palety příkazů vyhledejte a vyberte Azure Functions: Vytvořit funkci.

2. Vyberte trigger HTTP a pojmenujte ho blogpost (v jednotném čísle).

3. Zkopírujte do souboru následující kód.

   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. Znovu spusťte místní funkci s ladicím programem. K dispozici jsou následující rozhraní API:

   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. blogpost Pomocí (jednotného) rozhraní API z příkazu cURL přidejte několik blogových příspěvků.

   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. blogposts K získání blogových příspěvků použijte rozhraní API (množné číslo) z příkazu cURL.

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

16. Zobrazení všech dat pomocí rozšíření Visual Studio Code pro Azure Cosmos DB

1. V editoru Visual Studio Code otevřete Průzkumníka Azure tak, že vyberete ikonu Azure na primárním bočním panelu nebo použijete klávesovou zkratku (Shift + Alt + A).

2. V části Prostředky klikněte pravým tlačítkem na databázi Azure Cosmos DB a vyberte Aktualizovat.

3. Rozbalením uzlu kolekce testovací databáze a blogových příspěvků zobrazte dokumenty.

4. Vyberte jednu z položek uvedených k zobrazení dat v instanci služby Azure Cosmos DB.

   

17. Opětovné nasazení aplikace funkcí tak, aby zahrnovalo kód databáze

1. V editoru Visual Studio Code otevřete Průzkumníka Azure tak, že vyberete ikonu Azure na primárním bočním panelu nebo použijete klávesovou zkratku (Shift + Alt + A).
2. V části Prostředky klikněte pravým tlačítkem na aplikaci Azure Function App a vyberte Nasadit do aplikace funkcí.
3. V automaticky otevíraných oken se dotazem, jestli opravdu chcete nasadit, vyberte Nasadit.
4. Než budete pokračovat, počkejte na dokončení nasazení.

18. Použití cloudové funkce Azure

1. Stále v Průzkumníku Azure v oblasti Functions vybere a rozbalí vaši funkci a pak uzel Functions , který vypíše rozhraní API.
2. Klikněte pravým tlačítkem na jedno z rozhraní API a vyberte Kopírovat adresu URL funkce.
3. Upravte předchozí příkazy cURL tak, aby místo místní adresy URL používaly vzdálenou adresu URL. Spuštěním příkazů otestujte vzdálené rozhraní API.

19. Dotazování protokolů funkcí Azure

Pokud chcete prohledat protokoly, použijte Azure Portal.

1. V editoru Visual Studio Code vyberte Průzkumníka Azure a pak v části Functions klikněte pravým tlačítkem na aplikaci funkcí a pak vyberte Otevřít na portálu.

   Tím se otevře Azure Portal pro vaši funkci Azure Functions.

2. V Nastavení vyberte Přehledy aplikace a pak vyberte Zobrazit data Přehledy aplikace.

   

   Tento odkaz vás provede samostatným prostředkem metrik vytvořeným za vás při vytváření funkce Azure Functions pomocí editoru Visual Studio Code.

3. V části Monitorování vyberte Protokoly. Pokud se zobrazí automaticky otevírané okno Dotazy, výběrem symbolu X v pravém horním rohu automaticky otevíraného okna ho zavřete.

4. V podokně Nový dotaz 1 poklikejte na kartě Tabulky na tabulku trasování.

   Tím se do okna dotazu zadá dotaztraces Kusto.

5. Upravte dotaz a vyhledejte vlastní protokoly:

   traces 
   | where message startswith "***"
   

6. Vyberte Spustit.

   Pokud se v protokolu nezobrazují žádné výsledky, může to být kvůli několikaminutové prodlevě mezi požadavkem HTTP na funkci Azure Functions a dostupností protokolu v Kusto. Počkejte několik minut a spusťte dotaz znovu.

   Abyste získali tyto informace o protokolování, nemusíte dělat nic navíc:

   • Kód použil context.log funkci poskytovanou architekturou Funkcí. Místo contextconsoletoho můžete protokolování filtrovat podle konkrétní jednotlivé funkce. To je užitečné, pokud vaše aplikace funkcí obsahuje mnoho funkcí.
   • Aplikace funkcí pro vás přidala aplikaci Přehledy.
   • Nástroj Kusto Query je součástí webu Azure Portal.
   • Místo toho, abyste se museli naučit psát dotaz Kusto, abyste získali i minimální informace z protokolů, můžete vybrattraces.

20. Vyčištění prostředků

Vzhledem k tomu, že jste použili jednu skupinu prostředků, můžete odstranit všechny prostředky odstraněním skupiny prostředků.

1. V editoru Visual Studio Code otevřete Průzkumníka Azure tak, že vyberete ikonu Azure na primárním bočním panelu nebo použijete klávesovou zkratku (Shift + Alt + A).
2. Vyhledejte a vyberte Azure: Seskupte podle skupiny prostředků.
3. Klikněte pravým tlačítkem na skupinu prostředků a vyberte Odstranit skupinu prostředků.
4. Potvrďte odstranění zadáním názvu skupiny prostředků.

Zdrojový kód je k dispozici

Úplný zdrojový kód pro tuto aplikaci Funkcí Azure:

• Ukázkový kód

Další kroky

Vytvoření funkce Azure Functions pro správu prostředků Azure