Kiszolgáló nélküli TypeScript API: Adatok tárolása MongoDB-ben az Azure Functions használatával

Cikk
10/21/2023

Hozzon létre egy Azure Function API-t az adatok Mongoose API-val való tárolásához az Azure Cosmos DB-ben, majd helyezze üzembe a függvényalkalmazást az Azure-felhőben egy nyilvános HTTP-végponttal való üzemeltetéshez.

Megjegyzés:

Ez a cikk a jelenleg előzetes verzióban elérhető Azure Functions Node.js v4 programozási modellt használja.

Flow chart showing path of HTTP request to pass data through Azure Functions and store in Azure Cosmos DB.

A fejlesztőkörnyezet előkészítése

Telepítse a következő szoftvert:

Ingyenes Azure-előfizetés létrehozása
A Node.js LTS v18+ telepítése
TypeScript v4+
Azurite globálisan telepítve van a helyi fejlesztési tárolókhoz
Azure Functions Runtime v4.16+
Az Azure Functions Core Tools v4.0.5095+ (helyi futtatás esetén) globálisan telepítve a helyi fejlesztéshez
Telepítse a Visual Studio Code-ot , és használja a következő bővítményeket:
- Azure Resources (Azure-erőforrások)
- Azure Functions
- Azure-adatbázisok

Ha már használja az Azure-szolgáltatásbővítményeket, akkor már be kell jelentkeznie, és kihagyhatja ezt a lépést.

Miután telepített egy Azure-szolgáltatásbővítményt a Visual Studio Code-ban, be kell jelentkeznie az Azure-fiókjába.

A Visual Studio Code-ban nyissa meg az Azure Explorert az elsődleges oldalsávOn található Azure-ikon kiválasztásával, vagy használja a billentyűparancsot (Shift + Alt + A).
Az Erőforrások szakaszban válassza a Bejelentkezés az Azure-ba lehetőséget, és kövesse az utasításokat.
Bejelentkezés után ellenőrizze, hogy az Azure-fiók e-mail-címe megjelenik-e az állapotsoron, és hogy az előfizetés(ek) megjelennek-e az Azure Explorerben :

2. Azure-erőforráscsoport létrehozása

Az erőforráscsoportok az erőforrások régióalapú gyűjteményei. Ha létrehoz egy erőforráscsoportot, majd abban a csoportban hoz létre erőforrásokat, az oktatóanyag végén anélkül törölheti az erőforráscsoportot, hogy egyenként kellene törölnie az egyes erőforrásokat.

Hozzon létre egy új mappát a helyi rendszeren, amelyet az Azure Functions-projekt gyökereként használhat.
Nyissa meg ezt a mappát a Visual Studio Code-ban.
A Visual Studio Code-ban nyissa meg az Azure Explorert az elsődleges oldalsávOn található Azure-ikon kiválasztásával, vagy használja a billentyűparancsot (Shift + Alt + A).
Keresse meg előfizetését az Erőforrások területen, és válassza az ikont, majd válassza az + Erőforráscsoport létrehozása lehetőséget.
A következő táblázat segítségével fejezze be az utasításokat:

Adatkérés Érték

Adja meg az új erőforráscsoport nevét. azure-tutorial

Válassza ki az új erőforrások helyét. Válasszon ki egy Önhöz közeli földrajzi régiót.

Adatkérés	Érték
Adja meg az új erőforráscsoport nevét.	`azure-tutorial`
Válassza ki az új erőforrások helyét.	Válasszon ki egy Önhöz közeli földrajzi régiót.

3. A helyi Functions-alkalmazás létrehozása

Hozzon létre egy helyi (kiszolgáló nélküli) Azure Functions-alkalmazást, amely egy HTTP-triggerfüggvényt tartalmaz.

A Visual Studio Code-ban nyissa meg a parancspalettát (Ctrl + Shift + P).
Keresse meg és válassza ki az Azure Functions: Create New Project (Új projekt létrehozása) lehetőséget.

A helyi Azure-függvényprojekt létrehozásának befejezéséhez használja az alábbi táblázatot:

Adatkérés	Érték	Jegyzetek
Válassza ki a függvényprojektet tartalmazó mappát	Válassza ki az aktuális (alapértelmezett) mappát.
Válasszon nyelvet	TypeScript
TypeScript programozási modell kiválasztása	V4-modell (előzetes verzió)
Sablon kiválasztása a projekt első függvényéhez	HTTP-eseményindító	Az API-t HTTP-kéréssel hívjuk meg.
Függvénynév megadása	`blogposts`	Az API-útvonal `/api/blogposts`

Amikor a Visual Studio Code létrehozza a projektet, tekintse meg az API-kódját a ./src/functions/blogposts.ts fájlban.

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

Ez a kód az új v4-programozási modell standard sablonja. Nem azt jelenti, hogy csak a POST és a GET használatával lehet API-réteget írni.

Cserélje le az előző kódot a következő kódra, hogy csak a GET-kérések küldhessenek vissza minden blogbejegyzést.
```
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
});
```
A kódban több Azure Functions Node.js v4 programozási modell is módosul :
- A függvény neve getBlobPosts, amely azt jelzi, hogy get kérés, segít elkülöníteni a függvényt a naplókban.
- A route tulajdonság értéke blogpostsa megadott /api/blogpostsalapértelmezett API-útvonal része.
- A methods tulajdonság el lett távolítva, és szükségtelen, mert az app objektum használata get azt jelzi, hogy ez egy GET kérés. A metódusfüggvények az alábbiakban láthatók. Ha más metódussal rendelkezik, visszatérhet a methods tulajdonság használatára.
  - deleteRequest()
  - get()
  - patch()
  - post()
  - put()

4. Az Azurite helyi tárolóemulátor indítása

A helyi számítógépen lévő funkciók fejlesztéséhez egy (ingyenes) Storage-emulátorra vagy egy (fizetős) Azure Storage-fiókra van szükség.

Egy külön terminálban indítsa el az Azurite helyi tárolóemulátort.

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

Ez szükséges az Azure Functions helyi futtatásához egy helyi Azure Storage-emulátor használatával. A helyi tárolóemulátor az local.settings.json AzureWebJobsStorage tulajdonsággal rendelkező UseDevelopmentStorage=truefájlban van megadva.

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

Az azurite almappát már hozzáadta a .gitignore fájlhoz.

5. A helyi kiszolgáló nélküli függvény futtatása

Az Azure Functions-projektet helyileg futtatva tesztelheti, mielőtt üzembe helyezené az Azure-ban.

A Visual Studio Code-ban állítson be egy töréspontot az return utasításra a GetBlogPosts függvény végén.
A Visual Studio Code-ban nyomja le az F5 billentyűt a hibakereső elindításához és az Azure Functions-gazdagéphez való csatoláshoz.

Használhatja a Hibakeresés>indítása hibakeresés parancsot is.
A kimenet megjelenik a Terminál panelen.
A Visual Studio Code-ban nyissa meg az Azure Explorert az elsődleges oldalsávOn található Azure-ikon kiválasztásával, vagy használja a billentyűparancsot (Shift + Alt + A).
A Munkaterület szakaszban keresse meg és bontsa ki a Helyi projekt -Functions ->>getBlogPosts lehetőséget.
Kattintson a jobb gombbal a függvény nevére, kérje le aBlogPosts parancsot, majd válassza a Függvény URL-címének másolása lehetőséget.

A böngészőben illessze be az URL-címet, és válassza az Enter vagy a következő cURL parancsot a terminálban:

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

A blogbejegyzések üres tömbjének válasza a következő:

*   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

A VS Code-ban állítsa le a Shift + F5 hibakeresőt.

6. Az Azure-függvényalkalmazás létrehozása a Visual Studio Code-ban

Ebben a szakaszban egy függvényalkalmazás felhőerőforrását és kapcsolódó erőforrásait hozza létre az Azure-előfizetésében.

A Visual Studio Code-ban nyissa meg a parancspalettát (Ctrl + Shift + P).
Keresse meg és válassza ki az Azure Functions: Függvényalkalmazás létrehozása az Azure-ban (Speciális) lehetőséget.

Amikor a rendszer kéri, adja meg az alábbi információkat:

Adatkérés	Kiválasztás
Adja meg a függvényalkalmazás globálisan egyedi nevét	Írjon be egy URL-elérési úton érvényes nevet, például `first-function`. Az URL-cím globálisan egyedivé tétele 3 karakter után. A beírt név ellenőrzése ellenőrzi, hogy egyedi-e az Azure Functionsben.
Futtatókörnyezeti verem kiválasztása	Válassza a Node.js 18 LTS vagy egy újabb verziót.
Operációs rendszer kiválasztása	Válassza a Linuxot.
Erőforráscsoport kiválasztása új erőforrásokhoz	Hozzon létre egy azure-tutorial-first-function nevű új erőforráscsoportot. Ez az erőforráscsoport végül több erőforrással is rendelkezik: Az Azure Function, az Azure Storage és a Cosmos DB for MongoDB API.
Üzemeltetési csomag kiválasztása	Válassza a Felhasználás lehetőséget.
Tárfiók kiválasztása	Válassza az Új tárfiók létrehozása lehetőséget, és fogadja el az alapértelmezett nevet.
Válasszon egy alkalmazás-Elemzések erőforrást az alkalmazáshoz.	Válassza az Új alkalmazás létrehozása Elemzések erőforrást, és fogadja el az alapértelmezett nevet.

Várjon, amíg az értesítés megerősíti, hogy az alkalmazás létrejött.

7. Az Azure-függvényalkalmazás üzembe helyezése az Azure-ban a Visual Studio Code-ban

Fontos

A meglévő függvényalkalmazásban való üzembe helyezés mindig felülírja az alkalmazás tartalmát az Azure-ban.

Válassza az Azure ikont a Tevékenységsávon, majd az Erőforrások területen kattintson a jobb gombbal a függvényalkalmazás erőforrására, és válassza az Üzembe helyezés függvényalkalmazásban lehetőséget.
Ha a rendszer megkérdezi, hogy biztosan telepíteni szeretné-e, válassza az Üzembe helyezés lehetőséget.
Az üzembe helyezés befejezése után egy értesítés több beállítással is megjelenik. Az eredmények megtekintéséhez válassza a Kimenet megtekintése lehetőséget. Ha nem jelenik meg az értesítés, a jobb alsó sarokban lévő harang ikont választva ismét láthatja.

8. Alkalmazásbeállítás hozzáadása a felhőalkalmazáshoz

Válassza az Azure ikont a Tevékenységsávon, majd az Erőforrások területen bontsa ki a függvényalkalmazás erőforrását, és kattintson a jobb gombbal az Alkalmazás Gépház elemre.
Válassza az Új beállítás hozzáadása lehetőséget, és adja hozzá a következő beállítást a Node.js v4 (előzetes verzió) programozási modell engedélyezéséhez.

Setting Érték

AzureWebJobsFeatureFlags EnableWorkerIndexing

Setting	Érték
AzureWebJobsFeatureFlags	EnableWorkerIndexing

9. Futtassa a távoli kiszolgáló nélküli függvényt

A Visual Studio Code-ban nyissa meg az Azure Explorert az elsődleges oldalsávOn található Azure-ikon kiválasztásával, vagy használja a billentyűparancsot (Shift + Alt + A).
Az Erőforrások szakaszban bontsa ki az Azure-függvényalkalmazás erőforrását. Kattintson a jobb gombbal a függvény nevére, és válassza a Függvény URL-címének másolása parancsot.
Illessze be az URL-címet egy böngészőbe. Ugyanaz az üres tömb lesz visszaadva, mint amikor a függvényt helyileg futtatta.
```
{"blogposts":[]}
```

10. Azure Cosmos DB hozzáadása MongoDB API-integrációhoz

Az Azure Cosmos DB mongoDB API-t biztosít egy ismerős integrációs pont biztosításához.

A Visual Studio Code-ban nyissa meg az Azure Explorert az elsődleges oldalsávOn található Azure-ikon kiválasztásával, vagy használja a billentyűparancsot (Shift + Alt + A).

Az Erőforrások szakaszban válassza az +Adatbázis-kiszolgáló létrehozása lehetőséget. Az alábbi táblázat segítségével fejezze be az új Azure Cosmos DB-erőforrás létrehozására vonatkozó utasításokat.

Adatkérés	Érték	Jegyzetek
Azure Database Server kiválasztása	MongoDB-hez készült Azure Cosmos DB API
Adjon meg egy Azure Cosmos DB-fióknevet.	`cosmosdb-mongodb-database`	Adjon meg három karaktert egyedi név létrehozásához. A név az API URL-címének részévé válik.
Válasszon ki egy kapacitásmodellt.	Kiszolgáló nélküli
Válasszon egy erőforráscsoportot az új erőforrásokhoz.	azure-tutorial-first-function	Válassza ki az előző szakaszban létrehozott erőforráscsoportot.
Válasszon egy helyet az új erőforrásokhoz.	Válassza ki a javasolt régiót.

11. Mongoose-függőség telepítése

Egy Visual Studio Code-terminálban a Ctrl Shift billentyűkombinációval` + + telepítse az npm-csomagot:

npm install mongoose

12. Mongoose-kód hozzáadása blogbejegyzésekhez

A Visual Studio Code-ban hozzon létre egy lib./src/nevű alkönyvtárat, hozzon létre egy nevű ./database.ts fájlt, és másolja be a következő kódot.

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;

A Visual Studio Code-ban nyissa meg a ./src/functions/blogposts fájlt, és cserélje le a teljes fájl kódját a következőre:

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. Kapcsolati sztring hozzáadása a helyi alkalmazáshoz

A Visual Studio Code Azure Explorerében válassza ki az Azure Cosmos DB szakaszt, és bontsa ki a jobb gombbal az új erőforrás kiválasztásához.
Válassza a Másolás kapcsolati sztring lehetőséget.
A Visual Studio Code-ban nyissa meg ./local.settings.jsona Fájlkezelőt.
Adjon hozzá egy új, hívott MONGODB_URI tulajdonságot, és illessze be a kapcsolati sztring értékét.
```
{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "",
    "FUNCTIONS_WORKER_RUNTIME": "node",
    "AzureWebJobsFeatureFlags": "EnableWorkerIndexing",
    "MONGODB_URI": "mongodb://...."
  }
}
```
A fájl titkos kódjai ./local.settings.json :
- Nincs üzembe helyezve az Azure-ban, mert benne van a ./.funcignore fájlban.
- Nincs beadva a forrásvezérlőbe, mert az szerepel a ./.gitignore fájlban.
Futtassa az alkalmazást helyileg, és tesztelje az API-t ugyanazzal az URL-címmel az előző szakaszban.

14. Kapcsolati sztring hozzáadása távoli alkalmazáshoz

A Visual Studio Code-ban nyissa meg az Azure Explorert az elsődleges oldalsávOn található Azure-ikon kiválasztásával, vagy használja a billentyűparancsot (Shift + Alt + A).
Az Erőforrások szakaszban keresse meg az Azure Cosmos DB-példányt. Kattintson a jobb gombbal az erőforrásra, és válassza a Csatlakozás ion-sztring másolása lehetőséget.
Ugyanebben az Erőforrások szakaszban keresse meg a függvényalkalmazást, és bontsa ki a csomópontot.
Kattintson a jobb gombbal az Alkalmazás Gépház elemre, és válassza az Új beállítás hozzáadása lehetőséget.
Adja meg az alkalmazásbeállítás nevét, MONGODB_URI és válassza az Enter lehetőséget.
Illessze be a másolt értéket, és nyomja le az Enter billentyűt.

15. Api-k hozzáadása blogbejegyzések létrehozásához, frissítéséhez és törléséhez

A Visual Studio Code-ban a parancskatalógus használatával keresse meg és válassza ki az Azure Functions: Függvény létrehozása lehetőséget.
Válassza ki a HTTP-eseményindítót , és nevezze el blogpost (egyedi).

Másolja a következő kódot a fájlba.

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

Indítsa el újra a helyi függvényt a hibakeresővel. A következő API-k érhetők el:

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}

Néhány blogbejegyzés hozzáadásához használja a blogpost cURL-parancsból származó (egyedi) API-t.

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

A blogbejegyzések lekéréséhez használja a blogposts (többes szám) API-t egy cURL-parancsból.
```
curl http://localhost:7071/api/blogposts --verbose
```

16. Az összes adat megtekintése az Azure Cosmos DB Visual Studio Code-bővítményével

A Visual Studio Code-ban nyissa meg az Azure Explorert az elsődleges oldalsávOn található Azure-ikon kiválasztásával, vagy használja a billentyűparancsot (Shift + Alt + A).
Az Erőforrások szakaszban kattintson a jobb gombbal az Azure Cosmos DB-adatbázisra, és válassza a Frissítés lehetőséget.
Bontsa ki a tesztadatbázis és a blogposts gyűjtemény csomópontját a dokumentumok megtekintéséhez.
Válassza ki a felsorolt elemek egyikét az Azure Cosmos DB-példány adatainak megtekintéséhez.

17. A függvényalkalmazás ismételt üzembe helyezése adatbáziskód belefoglalásához

A Visual Studio Code-ban nyissa meg az Azure Explorert az elsődleges oldalsávOn található Azure-ikon kiválasztásával, vagy használja a billentyűparancsot (Shift + Alt + A).
Az Erőforrások szakaszban kattintson a jobb gombbal az Azure-függvényalkalmazásra, és válassza az Üzembe helyezés függvényalkalmazásban lehetőséget.
Az előugró ablakban, amely megkérdezi, hogy biztosan üzembe kívánja-e helyezni, válassza az Üzembe helyezés lehetőséget.
A folytatás előtt várjon, amíg az üzembe helyezés befejeződik.

18. Felhőalapú Azure-függvény használata

Az Azure Explorer Függvények területén továbbra is kiválasztja és kibontja a függvényt, majd a Functions csomópontot, amely felsorolja az API-kat
Kattintson a jobb gombbal az egyik API-ra, és válassza a Függvény URL-címének másolása lehetőséget.
Szerkessze az előző cURL-parancsokat, hogy a távoli URL-címet használja a helyi URL-cím helyett. Futtassa a parancsokat a távoli API teszteléséhez.

19. Azure-függvénynaplók lekérdezése

A naplók kereséséhez használja az Azure Portalt.

A Visual Studio Code-ban válassza az Azure Explorert, majd a Függvények területen kattintson a jobb gombbal a függvényalkalmazásra, majd válassza a Megnyitás a portálon lehetőséget.

Ezzel megnyitja az Azure Portalt az Azure-függvényhez.
A Gépház válassza az Alkalmazás Elemzések, majd az Alkalmazás megtekintése Elemzések lehetőséget.

Ez a hivatkozás az Azure-függvény Visual Studio Code-tal való létrehozásakor létrehozott különálló metrikák erőforrására vezet.
A Figyelés szakaszban válassza a Naplók lehetőséget. Ha megjelenik egy Lekérdezések előugró ablak, az előugró ablak jobb felső sarkában lévő X elemet választva zárja be.
Az Új lekérdezés 1 panel Táblák lapján kattintson duplán a nyomkövetési táblára.

Ez beírja a Kusto-lekérdezésttraces a lekérdezési ablakba.
Szerkessze a lekérdezést az egyéni naplók kereséséhez:
```
traces 
| where message startswith "***"
```
Válassza a Futtatás lehetőséget.

Ha a napló nem jelenít meg semmilyen eredményt, annak az lehet az oka, hogy néhány perces késés van az Azure-függvénynek küldött HTTP-kérés és a Napló rendelkezésre állása között a Kusto-ban. Várjon néhány percet, és futtassa újra a lekérdezést.

A naplózási adatok beszerzéséhez nem kellett semmit sem tennie:
- A kód a context.log függvény-keretrendszer által biztosított függvényt használta. contextA naplózás ahelyettconsole, hogy az adott függvényre szűrhető. Ez akkor hasznos, ha a függvényalkalmazás számos függvényt is biztosít.
- A függvényalkalmazás alkalmazás-Elemzések hozzáadott Önnek.
- A Kusto Query eszközt az Azure Portal tartalmazza.
- traces Választhatja ahelyett, hogy meg kellene tanulnia Kusto-lekérdezést írni, hogy még a minimális információkat is lekérje a naplókból.

20. Erőforrások megtisztítása

Mivel egyetlen erőforráscsoportot használt, az erőforráscsoport törlésével törölheti az összes erőforrást.

A Visual Studio Code-ban nyissa meg az Azure Explorert az elsődleges oldalsávOn található Azure-ikon kiválasztásával, vagy használja a billentyűparancsot (Shift + Alt + A).
Keresse meg és válassza ki az Azure-t: Csoportosítás erőforráscsoport szerint.
Kattintson a jobb gombbal az erőforráscsoportra, és válassza az Erőforráscsoport törlése parancsot.
Adja meg az erőforráscsoport nevét a törlés megerősítéséhez.

Elérhető forráskód

Az Azure-függvényalkalmazás teljes forráskódja:

Mintakód

További lépések

Azure-függvény létrehozása Az Azure-erőforrások kezeléséhez

Kiszolgáló nélküli TypeScript API: Adatok tárolása MongoDB-ben az Azure Functions használatával

A fejlesztőkörnyezet előkészítése

2. Azure-erőforráscsoport létrehozása

3. A helyi Functions-alkalmazás létrehozása

4. Az Azurite helyi tárolóemulátor indítása

5. A helyi kiszolgáló nélküli függvény futtatása

6. Az Azure-függvényalkalmazás létrehozása a Visual Studio Code-ban

7. Az Azure-függvényalkalmazás üzembe helyezése az Azure-ban a Visual Studio Code-ban

8. Alkalmazásbeállítás hozzáadása a felhőalkalmazáshoz

9. Futtassa a távoli kiszolgáló nélküli függvényt

10. Azure Cosmos DB hozzáadása MongoDB API-integrációhoz

11. Mongoose-függőség telepítése

12. Mongoose-kód hozzáadása blogbejegyzésekhez

13. Kapcsolati sztring hozzáadása a helyi alkalmazáshoz

14. Kapcsolati sztring hozzáadása távoli alkalmazáshoz

15. Api-k hozzáadása blogbejegyzések létrehozásához, frissítéséhez és törléséhez

16. Az összes adat megtekintése az Azure Cosmos DB Visual Studio Code-bővítményével

17. A függvényalkalmazás ismételt üzembe helyezése adatbáziskód belefoglalásához

18. Felhőalapú Azure-függvény használata

19. Azure-függvénynaplók lekérdezése

20. Erőforrások megtisztítása

Elérhető forráskód

További lépések

Visszajelzés

Visszajelzés

További források

Kiszolgáló nélküli TypeScript API: Adatok tárolása MongoDB-ben az Azure Functions használatával

A fejlesztőkörnyezet előkészítése

1. Bejelentkezés az Azure-ba a Visual Studio Code-ban

2. Azure-erőforráscsoport létrehozása

3. A helyi Functions-alkalmazás létrehozása

4. Az Azurite helyi tárolóemulátor indítása

5. A helyi kiszolgáló nélküli függvény futtatása

6. Az Azure-függvényalkalmazás létrehozása a Visual Studio Code-ban

7. Az Azure-függvényalkalmazás üzembe helyezése az Azure-ban a Visual Studio Code-ban

8. Alkalmazásbeállítás hozzáadása a felhőalkalmazáshoz

9. Futtassa a távoli kiszolgáló nélküli függvényt

10. Azure Cosmos DB hozzáadása MongoDB API-integrációhoz

11. Mongoose-függőség telepítése

12. Mongoose-kód hozzáadása blogbejegyzésekhez

13. Kapcsolati sztring hozzáadása a helyi alkalmazáshoz

14. Kapcsolati sztring hozzáadása távoli alkalmazáshoz

15. Api-k hozzáadása blogbejegyzések létrehozásához, frissítéséhez és törléséhez

16. Az összes adat megtekintése az Azure Cosmos DB Visual Studio Code-bővítményével

17. A függvényalkalmazás ismételt üzembe helyezése adatbáziskód belefoglalásához

18. Felhőalapú Azure-függvény használata

19. Azure-függvénynaplók lekérdezése

20. Erőforrások megtisztítása

Elérhető forráskód

További lépések

Visszajelzés

Visszajelzés

További források