Bezserwerowy interfejs API języka TypeScript: przechowywanie danych w bazie danych MongoDB za pomocą usługi Azure Functions

Utwórz interfejs API funkcji platformy Azure do przechowywania danych za pomocą interfejsu API usługi Mongoose w usłudze Azure Cosmos DB, a następnie wdróż aplikację funkcji w chmurze platformy Azure na potrzeby hostowania przy użyciu publicznego punktu końcowego HTTP.

Uwaga

W tym artykule jest używany model programowania Azure Functions Node.js w wersji 4 obecnie w wersji zapoznawczej.

przygotowywanie środowiska programistycznego

Zainstaluj następujące oprogramowanie:

• Tworzenie bezpłatnej subskrypcji platformy Azure
• Instalowanie środowiska Node.js LTS w wersji 18 lub nowszej
• TypeScript v4+
• Usługa Azurite zainstalowana globalnie na potrzeby lokalnego magazynu programistycznego
• Środowisko uruchomieniowe usługi Azure Functions w wersji 4.16 lub nowszej
• Narzędzia Azure Functions Core Tools w wersji 4.0.5095 lub nowszej (jeśli są uruchomione lokalnie) zainstalowane globalnie na potrzeby programowania lokalnego
• Zainstaluj program Visual Studio Code i użyj następujących rozszerzeń:
  • Azure Resources (Zasoby platformy Azure)
  • Azure Functions
  • Bazy danych platformy Azure

1. Zaloguj się do platformy Azure w programie Visual Studio Code

Jeśli używasz już rozszerzeń usługi platformy Azure, musisz już się zalogować i pominąć ten krok.

Po zainstalowaniu rozszerzenia usługi platformy Azure w programie Visual Studio Code musisz zalogować się do konta platformy Azure.

1. W programie Visual Studio Code otwórz eksploratora platformy Azure, wybierając ikonę platformy Azure na pasku bocznym podstawowym lub używając skrótu klawiaturowego (Shift + Alt + A).

2. W sekcji Zasoby wybierz pozycję Zaloguj się na platformie Azure i postępuj zgodnie z monitami.

   

3. Po zalogowaniu sprawdź, czy adres e-mail konta platformy Azure jest wyświetlany na pasku stanu, a subskrypcje są wyświetlane w Eksploratorze platformy Azure :

   

2. Tworzenie grupy zasobów platformy Azure

Grupa zasobów to kolekcja zasobów oparta na regionie. Tworząc grupę zasobów, a następnie tworząc zasoby w tej grupie, na końcu samouczka możesz usunąć grupę zasobów bez konieczności usuwania poszczególnych zasobów osobno.

1. Utwórz nowy folder w systemie lokalnym, który będzie używany jako katalog główny projektu usługi Azure Functions.

2. Otwórz ten folder w programie Visual Studio Code.

3. W programie Visual Studio Code otwórz eksploratora platformy Azure, wybierając ikonę platformy Azure na pasku bocznym podstawowym lub używając skrótu klawiaturowego (Shift + Alt + A).

4. Znajdź subskrypcję w obszarze Zasoby i wybierz ikonę + , a następnie wybierz pozycję Utwórz grupę zasobów.

5. Aby ukończyć monity, użyj poniższej tabeli:

   Monit	Wartość
   Wprowadź nazwę nowej grupy zasobów.	azure-tutorial
   Wybierz lokalizację nowych zasobów.	Wybierz blisko siebie region geograficzny.

3. Tworzenie lokalnej aplikacji usługi Functions

Utwórz lokalną aplikację usługi Azure Functions (bezserwerową), która zawiera funkcję wyzwalacza HTTP.

1. W programie Visual Studio Code otwórz paletę poleceń (Ctrl + Shift + P).

2. Wyszukaj i wybierz pozycję Azure Functions: Create New Project (Utwórz nowy projekt ).

3. Użyj poniższej tabeli, aby zakończyć tworzenie lokalnego projektu funkcji platformy Azure:

   Monit	Wartość	Uwagi
   Wybierz folder, który będzie zawierać projekt funkcji	Wybierz bieżący (domyślny) folder.
   Wybierz język	TypeScript
   Wybieranie modelu programowania TypeScript	Model V4 (wersja zapoznawcza)
   Wybieranie szablonu dla pierwszej funkcji projektu	Wyzwalacz HTTP	Interfejs API jest wywoływany z żądaniem HTTP.
   Podaj nazwę funkcji	blogposts	Trasa interfejsu API to /api/blogposts

4. Gdy program Visual Studio Code utworzy projekt, wyświetl kod interfejsu ./src/functions/blogposts.ts API w pliku.

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

   Ten kod jest standardowy standardowy w nowym modelu programowania w wersji 4. Nie jest przeznaczony do wskazania jedynego sposobu pisania warstwy interfejsu API za pomocą funkcji POST i GET.

5. Zastąp poprzedni kod poniższym kodem, aby zezwolić na zwracanie wszystkich wpisów w blogu tylko żądań 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
   });
   

   W tym kodzie należy zwrócić uwagę na kilka zmian w modelu programowania Node.js w wersji 4 usługi Azure Functions:

   • Nazwa getBlobPostsfunkcji , wskazująca, że jest to żądanie GET, pomoże wyizolować funkcję w dziennikach.
   • Właściwość jest ustawiona route na blogposts, która jest częścią domyślnej trasy interfejsu API podanej: /api/blogposts.
   • Właściwość methods została usunięta i jest niepotrzebna, ponieważ app użycie get obiektu wskazuje, że jest to żądanie GET. Poniżej wymieniono funkcje metody. Jeśli masz inną metodę, możesz wrócić do używania methods właściwości .
     • deleteRequest()
     • get()
     • patch()
     • post()
     • put()

4. Uruchamianie lokalnego emulatora magazynu Azurite

Tworzenie funkcji na komputerze lokalnym wymaga emulatora usługi Storage (wersja bezpłatna) lub konta usługi Azure Storage (płatne).

W osobnym terminalu uruchom emulator magazynu lokalnego Azurite .

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

Jest to wymagane do lokalnego uruchomienia usługi Azure Functions przy użyciu lokalnego emulatora usługi Azure Storage. Emulator magazynu lokalnego local.settings.json jest określony w pliku z właściwością AzureWebJobsStorage o wartości UseDevelopmentStorage=true.

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

Podfolder azurite został już dodany do pliku .gitignore .

5. Uruchamianie lokalnej funkcji bezserwerowej

Uruchom projekt usługi Azure Functions lokalnie, aby przetestować go przed wdrożeniem na platformie Azure.

1. W programie Visual Studio Code ustaw punkt przerwania na instrukcji return na końcu funkcji getBlogPosts .

2. W programie Visual Studio Code naciśnij klawisz F5 , aby uruchomić debuger i dołączyć go do hosta usługi Azure Functions.

   Możesz również użyć polecenia menu Debuguj >rozpocznij debugowanie.

3. Dane wyjściowe są wyświetlane na panelu Terminal .

4. W programie Visual Studio Code otwórz eksploratora platformy Azure, wybierając ikonę platformy Azure na pasku bocznym podstawowym lub używając skrótu klawiaturowego (Shift + Alt + A).

5. W sekcji Obszar roboczy znajdź i rozwiń węzeł Projekt lokalny ->Functions ->getBlogPosts.

6. Kliknij prawym przyciskiem myszy nazwę funkcji, getBlogPosts, a następnie wybierz pozycję Kopiuj adres URL funkcji.

   

7. W przeglądarce wklej adres URL i wybierz klawisz Enter lub użyj następującego polecenia cURL w terminalu:

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

   Odpowiedź pustej tablicy wpisów w blogu jest zwracana jako:

   *   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. W programie VS Code zatrzymaj debuger, Shift + F5.

6. Tworzenie aplikacji funkcji platformy Azure w programie Visual Studio Code

W tej sekcji utworzysz zasób aplikacji funkcji w chmurze i powiązane zasoby w ramach subskrypcji platformy Azure.

1. W programie Visual Studio Code otwórz paletę poleceń (Ctrl + Shift + P).

2. Wyszukaj i wybierz pozycję Azure Functions: Utwórz aplikację funkcji na platformie Azure (zaawansowane).

3. Podaj następujące informacje po wyświetleniu monitów:

   Monit	Wybór
   Wprowadź globalnie unikatową nazwę aplikacji funkcji	Wpisz nazwę prawidłową w ścieżce adresu URL, na przykład first-function. Popend 3 znaki, aby adres URL był globalnie unikatowy. Typ nazwy jest weryfikowany, aby upewnić się, że jest on unikatowy w usłudze Azure Functions.
   Wybieranie stosu środowiska uruchomieniowego	Wybierz pozycję Node.js 18 LTS lub nowszą wersję.
   Wybieranie systemu operacyjnego	Wybierz pozycję Linux.
   Wybierz grupę zasobów dla nowych zasobów	Utwórz nową grupę zasobów o nazwie azure-tutorial-first-function. Ta grupa zasobów będzie mieć w końcu kilka zasobów: Azure Function, Azure Storage i Cosmos DB for MongoDB API.
   Wybieranie planu hostingu	Wybierz pozycję Zużycie.
   Wybieranie konta magazynu	Wybierz pozycję Utwórz nowe konto magazynu i zaakceptuj nazwę domyślną.
   Wybierz zasób aplikacji Szczegółowe informacje dla aplikacji.	Wybierz pozycję Utwórz nową aplikację Szczegółowe informacje zasobu i zaakceptuj nazwę domyślną.

   Poczekaj, aż powiadomienie potwierdzi utworzenie aplikacji.

7. Wdrażanie aplikacji funkcji platformy Azure na platformie Azure w programie Visual Studio Code

Ważne

Wdrażanie w istniejącej aplikacji funkcji zawsze zastępuje zawartość tej aplikacji na platformie Azure.

1. Wybierz ikonę platformy Azure na pasku działań, a następnie w obszarze Zasoby kliknij prawym przyciskiem myszy zasób aplikacji funkcji i wybierz pozycję Wdróż w aplikacji funkcji.
2. Jeśli zostanie wyświetlony monit o to, czy na pewno chcesz wdrożyć, wybierz pozycję Wdróż.
3. Po zakończeniu wdrażania zostanie wyświetlone powiadomienie z kilkoma opcjami. Wybierz pozycję Wyświetl dane wyjściowe , aby wyświetlić wyniki. Jeśli przegapisz powiadomienie, wybierz ikonę dzwonka w prawym dolnym rogu, aby zobaczyć je ponownie.

8. Dodawanie ustawienia aplikacji do aplikacji w chmurze

1. Wybierz ikonę platformy Azure na pasku działań, a następnie w obszarze Zasoby rozwiń zasób aplikacji funkcji, a następnie kliknij prawym przyciskiem myszy pozycję Aplikacja Ustawienia.

2. Wybierz pozycję Dodaj nowe ustawienie i dodaj następujące ustawienie, aby włączyć model programowania Node.js v4 (wersja zapoznawcza).

   Ustawienie	Wartość
   AzureWebJobsFeatureFlags	EnableWorkerIndexing

9. Uruchamianie zdalnej funkcji bezserwerowej

1. W programie Visual Studio Code otwórz eksploratora platformy Azure, wybierając ikonę platformy Azure na pasku bocznym podstawowym lub używając skrótu klawiaturowego (Shift + Alt + A).

2. W sekcji Zasoby rozwiń zasób aplikacji funkcji platformy Azure. Kliknij prawym przyciskiem myszy nazwę funkcji i wybierz pozycję Kopiuj adres URL funkcji.

3. Wklej adres URL do przeglądarki. Ta sama pusta tablica jest zwracana jak podczas lokalnego uruchamiania funkcji.

   {"blogposts":[]}
   

10. Dodawanie integracji interfejsu API usługi Azure Cosmos DB dla bazy danych MongoDB

Usługa Azure Cosmos DB udostępnia interfejs API bazy danych MongoDB w celu zapewnienia znanego punktu integracji.

1. W programie Visual Studio Code otwórz eksploratora platformy Azure, wybierając ikonę platformy Azure na pasku bocznym podstawowym lub używając skrótu klawiaturowego (Shift + Alt + A).

2. W sekcji Zasoby wybierz pozycję Utwórz +serwer bazy danych. Skorzystaj z poniższej tabeli, aby ukończyć monity o utworzenie nowego zasobu usługi Azure Cosmos DB.

   Monit	Wartość	Uwagi
   Wybieranie serwera usługi Azure Database	Interfejs API usługi Azure Cosmos DB dla bazy danych MongoDB
   Podaj nazwę konta usługi Azure Cosmos DB.	cosmosdb-mongodb-database	Postpend trzy znaki, aby utworzyć unikatową nazwę. Nazwa staje się częścią adresu URL interfejsu API.
   Wybierz model pojemności.	Praca bezserwerowa
   Wybierz grupę zasobów dla nowych zasobów.	azure-tutorial-first-function	Wybierz grupę zasobów utworzoną w poprzedniej sekcji.
   Wybierz lokalizację nowych zasobów.	Wybierz zalecany region.

11. Instalowanie zależności mongoose

W terminalu programu Visual Studio Code naciśnij klawisze Ctrl + Shift + `, a następnie zainstaluj pakiet npm:

npm install mongoose

12. Dodawanie kodu mongoose dla wpisów w blogu

1. W programie Visual Studio Code utwórz podkatalog o nazwie lib pod ./src/adresem , utwórz plik o nazwie ./database.ts i skopiuj do niego następujący kod.

   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. W programie Visual Studio Code otwórz ./src/functions/blogposts plik i zastąp kod całego pliku następującym kodem:

   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. Dodawanie parametry połączenia do aplikacji lokalnej

1. W eksploratorze platformy Azure programu Visual Studio Code wybierz sekcję Azure Cosmos DB i rozwiń, aby kliknąć prawym przyciskiem myszy pozycję Wybierz nowy zasób.

2. Wybierz pozycję Kopiuj parametry połączenia.

3. W programie Visual Studio Code otwórz plik ./local.settings.jsonza pomocą Eksploratora plików.

4. Dodaj nową właściwość o nazwie MONGODB_URI i wklej wartość parametry połączenia.

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

   Wpisy tajne w ./local.settings.json pliku:

   • Nie jest wdrażana na platformie Azure, ponieważ jest ona zawarta ./.funcignore w pliku.
   • Nie jest zaewidencjonowany w kontroli źródła, ponieważ znajduje się w ./.gitignore pliku.

5. Uruchom aplikację lokalnie i przetestuj interfejs API przy użyciu tego samego adresu URL w poprzedniej sekcji.

14. Dodawanie parametry połączenia do aplikacji zdalnej

1. W programie Visual Studio Code otwórz eksploratora platformy Azure, wybierając ikonę platformy Azure na pasku bocznym podstawowym lub używając skrótu klawiaturowego (Shift + Alt + A).
2. W sekcji Zasoby znajdź wystąpienie usługi Azure Cosmos DB. Kliknij prawym przyciskiem myszy zasób i wybierz polecenie Kopiuj ciąg Połączenie ion.
3. W tej samej sekcji Zasoby znajdź aplikację funkcji i rozwiń węzeł.
4. Kliknij prawym przyciskiem myszy pozycję Aplikacja Ustawienia i wybierz pozycję Dodaj nowe ustawienie.
5. Wprowadź nazwę ustawienia aplikacji, MONGODB_URI a następnie naciśnij klawisz Enter.
6. Wklej skopiowaną wartość i naciśnij klawisz Enter.

15. Dodawanie interfejsów API do tworzenia, aktualizowania i usuwania wpisów w blogu

1. W programie Visual Studio Code użyj palety poleceń, aby znaleźć i wybrać pozycję Azure Functions: Utwórz funkcję.

2. Wybierz pozycję Wyzwalacz HTTP i nadaj mu blogpost nazwę (pojedyncza).

3. Skopiuj następujący kod do pliku.

   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. Uruchom ponownie funkcję lokalną za pomocą debugera. Dostępne są następujące interfejsy 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. Użyj interfejsu blogpost API (pojedynczego) z polecenia cURL, aby dodać kilka wpisów w blogu.

   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. Użyj interfejsu blogposts API (w liczbie mnogiej) z polecenia cURL, aby uzyskać wpisy w blogu.

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

16. Wyświetlanie wszystkich danych za pomocą rozszerzenia programu Visual Studio Code dla usługi Azure Cosmos DB

1. W programie Visual Studio Code otwórz eksploratora platformy Azure, wybierając ikonę platformy Azure na pasku bocznym podstawowym lub używając skrótu klawiaturowego (Shift + Alt + A).

2. W sekcji Zasoby kliknij prawym przyciskiem myszy bazę danych usługi Azure Cosmos DB i wybierz pozycję Odśwież.

3. Rozwiń węzeł testowej bazy danych i blogpostów kolekcji, aby wyświetlić dokumenty.

4. Wybierz jeden z wymienionych elementów, aby wyświetlić dane w wystąpieniu usługi Azure Cosmos DB.

   

17. Ponowne wdrażanie aplikacji funkcji w celu uwzględnienia kodu bazy danych

1. W programie Visual Studio Code otwórz eksploratora platformy Azure, wybierając ikonę platformy Azure na pasku bocznym podstawowym lub używając skrótu klawiaturowego (Shift + Alt + A).
2. W sekcji Zasoby kliknij prawym przyciskiem myszy aplikację funkcji platformy Azure i wybierz polecenie Wdróż w aplikacji funkcji.
3. W oknie podręcznym z pytaniem, czy na pewno chcesz wdrożyć, wybierz pozycję Wdróż.
4. Przed kontynuowaniem poczekaj na zakończenie wdrażania.

18. Korzystanie z funkcji platformy Azure opartej na chmurze

1. Nadal w eksploratorze platformy Azure w obszarze Funkcje wybiera i rozwija funkcję, a następnie węzeł Funkcje , który zawiera listę interfejsów API
2. Kliknij prawym przyciskiem myszy jeden z interfejsów API i wybierz pozycję Kopiuj adres URL funkcji.
3. Edytuj poprzednie polecenia cURL, aby użyć zdalnego adresu URL zamiast lokalnego adresu URL. Uruchom polecenia, aby przetestować zdalny interfejs API.

19. Wykonywanie zapytań dotyczących dzienników funkcji platformy Azure

Aby przeszukać dzienniki, użyj witryny Azure Portal.

1. W programie Visual Studio Code wybierz eksploratora platformy Azure, a następnie w obszarze Funkcje kliknij prawym przyciskiem myszy aplikację funkcji, a następnie wybierz polecenie Otwórz w portalu.

   Spowoduje to otwarcie witryny Azure Portal dla funkcji platformy Azure.

2. W Ustawienia wybierz pozycję Aplikacja Szczegółowe informacje, a następnie wybierz pozycję Wyświetl dane Szczegółowe informacje aplikacji.

   

   Ten link umożliwia przejście do oddzielnego zasobu metryk utworzonego podczas tworzenia funkcji platformy Azure za pomocą programu Visual Studio Code.

3. W sekcji Monitorowanie wybierz pozycję Dzienniki. Jeśli zostanie wyświetlone okno podręczne Zapytania, wybierz ikonę X w prawym górnym rogu wyskakującego okienka, aby go zamknąć.

4. W okienku Nowe zapytanie 1 na karcie Tabele kliknij dwukrotnie tabelę śladów .

   Spowoduje to wprowadzenie zapytaniatraces Kusto w oknie zapytania.

5. Edytuj zapytanie, aby wyszukać dzienniki niestandardowe:

   traces 
   | where message startswith "***"
   

6. Wybierz Uruchom.

   Jeśli dziennik nie wyświetli żadnych wyników, może to być spowodowane kilkuminutowym opóźnieniem między żądaniem HTTP a dostępnością dziennika w usłudze Kusto. Zaczekaj kilka minut i ponownie uruchom zapytanie.

   Nie trzeba wykonywać żadnych dodatkowych czynności, aby uzyskać te informacje rejestrowania:

   • Kod użył context.log funkcji udostępnionej przez platformę funkcji. Za pomocą polecenia contextzamiast consolefunkcji można filtrować rejestrowanie do określonej funkcji indywidualnej. Jest to przydatne, jeśli aplikacja funkcji ma wiele funkcji.
   • Aplikacja funkcji dodała Szczegółowe informacje aplikacji.
   • Narzędzie Kusto Query znajduje się w witrynie Azure Portal.
   • Możesz wybrać traces zamiast nauczyć się pisać zapytanie Kusto, aby uzyskać nawet minimalne informacje z dzienników.

20. Czyszczenie zasobów

Ponieważ użyto pojedynczej grupy zasobów, można usunąć wszystkie zasoby, usuwając grupę zasobów.

1. W programie Visual Studio Code otwórz eksploratora platformy Azure, wybierając ikonę platformy Azure na pasku bocznym podstawowym lub używając skrótu klawiaturowego (Shift + Alt + A).
2. Wyszukaj i wybierz pozycję Azure: Grupuj według grupy zasobów.
3. Kliknij prawym przyciskiem myszy pozycję Wybierz grupę zasobów i wybierz polecenie Usuń grupę zasobów.
4. Wprowadź nazwę grupy zasobów, aby potwierdzić usunięcie.

Dostępny kod źródłowy

Pełny kod źródłowy dla tej aplikacji funkcji platformy Azure:

• Przykładowy kod

Następne kroki

Tworzenie funkcji platformy Azure do zarządzania zasobami platformy Azure