Megosztás a következőn keresztül:

Azure Functions Node.js fejlesztői útmutató

Ez az útmutató a JavaScript vagy TypeScript használatával végzett Azure Functions fejlesztésének bemutatása. A cikk feltételezi, hogy már elolvasta a Azure Functions fejlesztői útmutatót.

Fontos

A cikk tartalma a Node.js programozási modell választásától függően változik a lap tetején található választóban. A választott verziónak meg kell egyeznie az @azure/functions alkalmazásban használt npm-csomag verziójával. Ha nem szerepel a csomag a package.jsonlistán, az alapértelmezett v3. A migrálási útmutatóban további információt olvashat a v3 és a v4 közötti különbségekről.

Node.js fejlesztőként az alábbi cikkek valamelyike is érdekelheti:

Első lépések Fogalmak Irányított tanulás

Megfontolások

  • A Node.js programozási modellt nem szabad összekeverni a Azure Functions futtatókörnyezettel:
    • Programozási modell: Meghatározza a kód készítésének módját, és a JavaScriptre és a TypeScriptre jellemző.
    • Runtime: Meghatározza a Azure Functions mögöttes viselkedését, és minden nyelven meg van osztva.
  • A programozási modell verziója szigorúan az npm-csomag verziójához @azure/functions van kötve. A verziószámozás független a futtatókörnyezettől. A futtatókörnyezet és a programozási modell is a 4-es számot használja a legújabb főverzióként, de ez véletlen.
  • A v3- és v4-programozási modellek nem keverhetők ugyanabban a függvényalkalmazásban. Amint regisztrál egy v4-függvényt az alkalmazásban, a function.json fájlokban regisztrált v3-függvények figyelmen kívül lesznek hagyva.

Támogatott verziók

Az alábbi táblázat a Node.js programozási modell minden verzióját, valamint a Azure Functions futtatókörnyezet és Node.jstámogatott verzióit mutatja be.

Programozási modell verziója Támogatási szint Függvények Runtime verzió Node.js verzió Leírás
4.x GA 4.25+ 22.x 20.x, 18.x Támogatja az eseményindítók és kötések rugalmas fájlstruktúráját és kódközpontú megközelítését.
3.x GA 4.x 20.x, 18.x, 16.x, 14.x Egy adott fájlstruktúrát igényel, amelyben az eseményindítók és kötések egy "function.json" fájlban deklarálva lesznek
2.x n.a. 3.x 14.x, 12.x, 10.x 2022. december 13-án véget ért a támogatás. További információt a Függvényverziók című témakörben talál.
1.x n.a. 2.x 10.x, 8.x 2022. december 13-án véget ért a támogatás. További információt a Függvényverziók című témakörben talál.

Mappastruktúra

A JavaScript-projektekhez szükséges mappastruktúra a következő példához hasonlóan néz ki:

<project_root>/
 | - .vscode/
 | - node_modules/
 | - myFirstFunction/
 | | - index.js
 | | - function.json
 | - mySecondFunction/
 | | - index.js
 | | - function.json
 | - .funcignore
 | - host.json
 | - local.settings.json
 | - package.json

A fő projektmappa ( <project_root>) a következő fájlokat tartalmazhatja:

  • .vscode/: (Nem kötelező) A tárolt Visual Studio Code konfigurációt tartalmazza. További információ: Visual Studio Code beállítások.
  • myFirstFunction/function.json: A függvény eseményindítójának, bemeneteinek és kimeneteinek konfigurációját tartalmazza. A könyvtár neve határozza meg a függvény nevét.
  • myFirstFunction/index.js: Tárolja a függvénykódot. Az alapértelmezett fájl elérési útjának módosításáról a scriptFile használatával olvashat.
  • .funcignore: (Nem kötelező) Deklarálja azokat a fájlokat, amelyeket nem szabad közzétenni a Azure. Ez a fájl általában .vscode/-t tartalmaz, amely figyelmen kívül hagyja a szerkesztő beállításait, teszteli/ figyelmen kívül hagyja a tesztelési eseteket, és local.settings.json a helyi alkalmazásbeállítások közzétételének megakadályozása érdekében.
  • host.json: Olyan konfigurációs beállításokat tartalmaz, amelyek egy függvényalkalmazás-példány összes függvényét érintik. Ez a fájl közzé lesz téve Azure. Helyi futtatáskor nem minden beállítás támogatott. További információ: host.json.
  • local.settings.json: Alkalmazásbeállítások és kapcsolati sztring tárolására szolgál, ha helyileg fut. Ez a fájl nem lesz közzétéve Azure. További információ: local.settings.file.
  • package.json: Olyan konfigurációs beállításokat tartalmaz, mint a csomagfüggőségek listája, a fő belépési pont és a szkriptek.

Egy JavaScript-projekt ajánlott mappastruktúrája a következő példához hasonlóan néz ki:

<project_root>/
 | - .vscode/
 | - node_modules/
 | - src/
 | | - functions/
 | | | - myFirstFunction.js
 | | | - mySecondFunction.js
 | - test/
 | | - functions/
 | | | - myFirstFunction.test.js
 | | | - mySecondFunction.test.js
 | - .funcignore
 | - host.json
 | - local.settings.json
 | - package.json

A fő projektmappa ( <project_root>) a következő fájlokat tartalmazhatja:

  • .vscode/: (Nem kötelező) A tárolt Visual Studio Code konfigurációt tartalmazza. További információ: Visual Studio Code beállítások.
  • src/functions/: Az összes függvény és azok kapcsolódó eseményindítóinak és kötéseinek alapértelmezett helye.
  • teszt/: (Nem kötelező) A függvényalkalmazás teszteseteit tartalmazza.
  • .funcignore: (Nem kötelező) Deklarálja azokat a fájlokat, amelyeket nem szabad közzétenni a Azure. Ez a fájl általában .vscode/-t tartalmaz, amely figyelmen kívül hagyja a szerkesztő beállításait, teszteli/ figyelmen kívül hagyja a tesztelési eseteket, és local.settings.json a helyi alkalmazásbeállítások közzétételének megakadályozása érdekében.
  • host.json: Olyan konfigurációs beállításokat tartalmaz, amelyek egy függvényalkalmazás-példány összes függvényét érintik. Ez a fájl közzé lesz téve Azure. Helyi futtatáskor nem minden beállítás támogatott. További információ: host.json.
  • local.settings.json: Alkalmazásbeállítások és kapcsolati sztring tárolására szolgál, ha helyileg fut. Ez a fájl nem lesz közzétéve Azure. További információ: local.settings.file.
  • package.json: Olyan konfigurációs beállításokat tartalmaz, mint a csomagfüggőségek listája, a fő belépési pont és a szkriptek.

Függvény regisztrálása

A v3 modell két fájl megléte alapján regisztrál egy függvényt. Először egy function.json olyan fájlra van szüksége, amely egy mappában található egy szinttel lejjebb az alkalmazás gyökerétől. Másodszor, szüksége van egy JavaScript-fájlra, amely exportálja a függvényt. Alapértelmezés szerint a modell egy index.js fájlt keres ugyanabban a mappában, mint az Ön function.json. TypeScript használata esetén az scriptFile tulajdonságot function.json kell használnia, hogy a lefordított JavaScript-fájlra mutatjon. A függvény fájlhelyének vagy exportálási nevének testreszabásához tekintse meg a függvény belépési pontjának konfigurálását.

Az exportált függvényt mindig a v3 modellben async function kell deklarálni. Exportálhat egy szinkron függvényt, de ezután jeleznie context.done() kell, hogy a függvény befejeződött, ami elavult, és nem ajánlott.

A függvénynek első argumentumként egy meghívástcontext adunk át, és a bemeneteket a további argumentumként adjuk át.

Az alábbi példa egy egyszerű függvény, amely naplózza, hogy aktiválódott, és a következővel Hello, world!válaszol:

{
  "bindings": [
    {
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "authLevel": "anonymous",
      "methods": ["get", "post"]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "res"
    }
  ]
}

module.exports = async function (context, request) {
  context.log("Http function was triggered.");
  context.res = { body: "Hello, world!" };
};

A programozási modell a függvényeket a main saját mezője package.jsonalapján tölti be. A main mezőt egy fájlra vagy több fájlra is beállíthatja egy helyettesítő minta használatával. Az alábbi táblázat a mezőhöz tartozó main példaértékeket mutatja be:

Példa Leírás
src/index.js Egyetlen alapfájlból történő függvényregisztrálás.
src/functions/*.js Regisztrálja az egyes függvényeket a saját fájljából.
src/{index.js,functions/*.js} Olyan kombináció, amelyben az egyes függvényeket a saját fájljából regisztrálja, de az általános alkalmazásszintű kódhoz továbbra is rendelkezik gyökérfájllal.

Egy függvény regisztrálásához importálnia kell az objektumot az app@azure/functions npm modulból, és meg kell hívnia az eseményindító típusának megfelelő metódust. A függvények regisztrálásakor az első argumentum a függvény neve. A második argumentum egy options objektum, amely konfigurálja az eseményindítót, a kezelőt és minden más bemenetet vagy kimenetet. Bizonyos esetekben, amikor az eseményindító konfigurálása nem szükséges, a kezelőt közvetlenül a második argumentumként továbbíthatja objektum options helyett.

A függvények regisztrálása a projekt bármely fájljából elvégezhető, feltéve, hogy a fájl betöltése (közvetlenül vagy közvetve) a main fájl mezője package.json alapján történik. A függvényt globális hatókörben kell regisztrálni, mert a végrehajtás megkezdése után nem regisztrálhat függvényeket.

Az alábbi példa egy egyszerű függvény, amely naplózza, hogy aktiválódott, és a következővel Hello, world!válaszol:

const { app } = require("@azure/functions");

app.http("helloWorld1", {
  methods: ["POST", "GET"],
  handler: async (request, context) => {
    context.log("Http function was triggered.");
    return { body: "Hello, world!" };
  },
});

Bemenetek és kimenetek

A függvénynek pontosan egy elsődleges bemenettel, az eseményindítóval kell rendelkeznie. Másodlagos bemenetekkel és/vagy kimenetekkel is rendelkezhet. A bemenetek és kimenetek a fájlokban function.json vannak konfigurálva, és kötéseknek is nevezik.

Bemenetek

A bemenetek olyan kötések, amelyek direction a következőre invannak állítva: . Az eseményindítók és a másodlagos bemenetek közötti fő különbség az, hogy az type eseményindító végződik Trigger, például típus blobTrigger és típus blob. A legtöbb függvény csak eseményindítót használ, és nem sok másodlagos bemeneti típus támogatott.

A bemenetek többféleképpen is elérhetők:

  • [Ajánlott] A függvénynek átadott argumentumok: Használja az argumentumokat ugyanabban a sorrendben, amelyben a függvény definiálva function.jsonvan. A name megadott function.json tulajdonságnak nem kell megegyeznie az argumentum nevével, bár az átláthatóság érdekében javasoljuk.

    module.exports = async function (context, myTrigger, myInput, myOtherInput) { ... };

  • context.bindings tulajdonság tulajdonságaiként használja a következőben namedefiniált tulajdonságnak megfelelő function.json kulcsot:

    module.exports = async function (context) {
  context.log("This is myTrigger: " + context.bindings.myTrigger);
  context.log("This is myInput: " + context.bindings.myInput);
  context.log("This is myOtherInput: " + context.bindings.myOtherInput);
};

Kimenetek

A kimenetek olyan kötések direction , amelyekhez out beállítottak, és többféleképpen is beállíthatók:

  • [Ajánlott egyetlen kimenethez] Az értéket közvetlenül adja vissza: Ha aszinkron függvényt használ, az értéket közvetlenül is visszaadhatja. A kimeneti kötés name tulajdonságát $return értékre kell módosítania a function.json-ban, ahogy az alábbi példa mutatja:

    {
  "name": "$return",
  "type": "http",
  "direction": "out"
}

    module.exports = async function (context, request) {
  return {
    body: "Hello, world!",
  };
};

  • [Több kimenet esetén ajánlott] Minden kimenetet tartalmazó objektumot ad vissza: Ha aszinkron függvényt használ, visszaadhat egy olyan objektumot, amelynek tulajdonsága megegyezik az egyes kötések nevével.function.json Az alábbi példa a "httpResponse" és a "queueOutput" nevű kimeneti kötéseket használja:

    {
    "name": "httpResponse",
    "type": "http",
    "direction": "out"
},
{
    "name": "queueOutput",
    "type": "queue",
    "direction": "out",
    "queueName": "helloworldqueue",
    "connection": "storage_APPSETTING"
}

    module.exports = async function (context, request) {
  let message = "Hello, world!";
  return {
    httpResponse: {
      body: message,
    },
    queueOutput: message,
  };
};

  • Állítsa be az értékeket a következőre context.bindings: Ha nem aszinkron függvényt használ, vagy nem szeretné használni az előző beállításokat, beállíthatja context.bindingsközvetlenül az értékeket, ahol a kulcs megegyezik a kötés nevével. Az alábbi példa a "httpResponse" és a "queueOutput" nevű kimeneti kötéseket használja:

    {
    "name": "httpResponse",
    "type": "http",
    "direction": "out"
},
{
    "name": "queueOutput",
    "type": "queue",
    "direction": "out",
    "queueName": "helloworldqueue",
    "connection": "storage_APPSETTING"
}

    module.exports = async function (context, request) {
  let message = "Hello, world!";
  context.bindings.httpResponse = {
    body: message,
  };
  context.bindings.queueOutput = message;
};

Kötések adattípusa

A bemenet típusának módosításához használhatja a dataType tulajdonságot egy bemeneti kötésen. A megközelítésnek azonban vannak korlátai:

  • A Node.js csak string és binary támogatott (stream nem)
  • HTTP-bemenetek esetén a dataType tulajdonság figyelmen kívül lesz hagyva. Ehelyett az objektum tulajdonságait request használva kérje le a törzset a kívánt formátumban. További információ: HTTP-kérés.

A következő példában egy tárolási üzenetsor-eseményindító alapértelmezett típusa myQueueItem egy string, de ha dataType be van állítva binary, a típus Node.js Buffer változik.

{
  "name": "myQueueItem",
  "type": "queueTrigger",
  "direction": "in",
  "queueName": "helloworldqueue",
  "connection": "storage_APPSETTING",
  "dataType": "binary"
}

const { Buffer } = require("node:buffer");

module.exports = async function (context, myQueueItem) {
  if (typeof myQueueItem === "string") {
    context.log("myQueueItem is a string");
  } else if (Buffer.isBuffer(myQueueItem)) {
    context.log("myQueueItem is a buffer");
  }
};

A függvénynek pontosan egy elsődleges bemenettel, az eseményindítóval kell rendelkeznie. Lehetnek másodlagos bemenetei is, a visszatérési kimenetnek nevezett elsődleges kimenet és/vagy másodlagos kimenetek. A bemeneteket és kimeneteket a Node.js programozási modell környezetén kívül eső kötéseknek is nevezzük. A modell v4-es verziója előtt ezeket a kötéseket function.json fájlokban konfigurálták.

Indító bemenet

Az eseményindító az egyetlen szükséges bemenet vagy kimenet. A legtöbb eseményindító-típus esetében a függvényt az eseményindító típusáról elnevezett objektumon app egy metódus használatával regisztrálja. Az eseményindítóra jellemző konfigurációt közvetlenül az options argumentumon adhatja meg. Egy HTTP-eseményindító például lehetővé teszi egy útvonal megadását. A végrehajtás során az eseményindítónak megfelelő érték lesz átadva első argumentumként a kezelőnek.

const { app } = require('@azure/functions');

app.http('helloWorld1', {
    route: 'hello/world',
    handler: async (request, context) => {
        ...
    }
});

Adja vissza a kimenetet

A visszatérési kimenet nem kötelező, és bizonyos esetekben alapértelmezés szerint konfigurálva van. Egy regisztrált HTTP-eseményindító app.http például úgy van konfigurálva, hogy automatikusan visszaadja a HTTP-válasz kimenetét. A legtöbb kimeneti típus esetében az options argumentum visszatérési konfigurációját a output modulból exportált @azure/functions objektum segítségével adja meg. A végrehajtás során úgy állíthatja be ezt a kimenetet, hogy azt a kezelőből visszaadja.

Az alábbi példa egy időzítő eseményindítót és egy tárolási üzenetsor kimenetét használja:

const { app, output } = require('@azure/functions');

app.timer('timerTrigger1', {
    schedule: '0 */5 * * * *',
    return: output.storageQueue({
        connection: 'storage_APPSETTING',
        ...
    }),
    handler: (myTimer, context) => {
        return { hello: 'world' }
    }
});

További bemenetek és kimenetek

Az eseményindító és a visszatérés mellett további bemeneteket vagy kimeneteket is megadhat az argumentumon egy options függvény regisztrálásakor. A input modulból exportált output és @azure/functions objektumok típusspecifikus metódusaikkal segítik a konfiguráció összeállítását. A végrehajtás során a context.extraInputs.get vagy context.extraOutputs.set segítségével kérheti le vagy állíthatja be az értékeket, az eredeti konfigurációs objektumot első argumentumként megadva.

Az alábbi példa egy storage-üzenetsor által aktivált függvény, amely egy további tárolóblob-bemenettel rendelkezik, amely a további tárolóblobot átmásolja egy tárolóblob-kimenetbe. Az üzenetsor üzenetének egy fájlnevet kell tartalmaznia, amely {queueTrigger} helyébe lép mint a másolandó blobnév, a kapcsolási kifejezés segítségével.

const { app, input, output } = require("@azure/functions");

const blobInput = input.storageBlob({
  connection: "storage_APPSETTING",
  path: "helloworld/{queueTrigger}",
});

const blobOutput = output.storageBlob({
  connection: "storage_APPSETTING",
  path: "helloworld/{queueTrigger}-copy",
});

app.storageQueue("copyBlob1", {
  queueName: "copyblobqueue",
  connection: "storage_APPSETTING",
  extraInputs: [blobInput],
  extraOutputs: [blobOutput],
  handler: (queueItem, context) => {
    const blobInputValue = context.extraInputs.get(blobInput);
    context.extraOutputs.set(blobOutput, blobInputValue);
  },
});

Általános bemenetek és kimenetek

A appmodul által exportált , trigger, inputés output objektumok típusspecifikus @azure/functions metódusokat biztosítanak a legtöbb típushoz. A nem támogatott típusok esetében a rendszer egy generic metódust biztosít, amely lehetővé teszi a konfiguráció manuális megadását. A generic metódus akkor is használható, ha módosítani szeretné egy típusspecifikus metódus által megadott alapértelmezett beállításokat.

Az alábbi példa egy egyszerű HTTP-aktivált függvény, amely típusspecifikus metódusok helyett általános metódusokat használ.

const { app, output, trigger } = require("@azure/functions");

app.generic("helloWorld1", {
  trigger: trigger.generic({
    type: "httpTrigger",
    methods: ["GET", "POST"],
  }),
  return: output.generic({
    type: "http",
  }),
  handler: async (request, context) => {
    context.log(`Http function processed request for url "${request.url}"`);

    return { body: `Hello, world!` };
  },
});

SDK-típusok

Számos kötésbővítmény lehetővé teszi, hogy közvetlenül a Azure SDK típusokkal dolgozzon.

Azure Blob-tároló

Az Azure Functions SDK kötési képessége lehetővé teszi, hogy nyers adatok helyett közvetlenül használja a Azure Blob Storage SDK-típusokat, például BlobClient és ContainerClient. Ez teljes hozzáférést biztosít az összes SDK-metódushoz a blobok használatakor.

Ha úgy szeretné konfigurálni a projektet, hogy SDK-típusok használatával működjön:

  1. Adja hozzá a @azure/functions-extensions-blob bővítmény előzetes verziójú csomagjait a package.json projekt fájljába, amelynek tartalmaznia kell legalább az alábbi csomagokat:
"dependencies": {
  "@azure/functions": "4.7.2-preview",
  "@azure/functions-extensions-blob": "0.2.0-preview"
},
  1. Adja hozzá enableHttpStream: true a app.setup streamelési típusok támogatásához:
import { app } from '@azure/functions';

app.setup({
    enableHttpStream: true,
});

Ez a példa bemutatja, hogyan szerezheti be a BlobClientet egy Storage Blob-eseményindítóból és egy HTTP-eseményindító bemeneti kötéséből:

import "@azure/functions-extensions-blob"; // This is the mandatory first import for SDK binding
import { StorageBlobClient } from "@azure/functions-extensions-blob";
import { app, InvocationContext } from "@azure/functions";

export async function storageBlobTrigger(
  blobStorageClient: StorageBlobClient, // SDK binding provides this client
  context: InvocationContext
): Promise<void> {
  context.log(`Blob trigger processing: ${context.triggerMetadata.name}`);

  // Access to full SDK capabilities
  const blobProperties = await blobStorageClient.blobClient.getProperties();
  context.log(`Blob size: ${blobProperties.contentLength}`);

  // Download blob content
  const downloadResponse = await blobStorageClient.blobClient.download();
  context.log(`Content: ${downloadResponse}`);
}

// Register the function
app.storageBlob("storageBlobTrigger", {
  path: "snippets/{name}",
  connection: "AzureWebJobsStorage",
  sdkBinding: true, // Enable SDK binding
  handler: storageBlobTrigger,
});

Ez a példa bemutatja, hogyan szerezheti be a ContainerClient a Storage Blob bemeneti kötésből egy HTTP-eseményindító használatával.

import "@azure/functions-extensions-blob"; // This is the mandatory first import for SDK binding
import { StorageBlobClient } from "@azure/functions-extensions-blob";
import {
  app,
  HttpRequest,
  HttpResponseInit,
  input,
  InvocationContext,
} from "@azure/functions";

const blobInput = input.storageBlob({
  path: "snippets",
  connection: "AzureWebJobsStorage",
  sdkBinding: true,
});

export async function listBlobs(
  request: HttpRequest,
  context: InvocationContext
): Promise<HttpResponseInit> {
  // Get input binding for a specific container
  const storageBlobClient = context.extraInputs.get(
    blobInput
  ) as StorageBlobClient;

  // List all blobs in the container
  const blobs = [];
  for await (const blob of storageBlobClient.containerClient.listBlobsFlat()) {
    blobs.push(blob.name);
  }

  return { jsonBody: { blobs } };
}

app.http("listBlobs", {
  methods: ["GET"],
  authLevel: "function",
  extraInputs: [blobInput],
  handler: listBlobs,
});

Tartsa szem előtt ezeket a szempontokat az SDK-típusok használatakor:

  • A mellékhatások futtatása érdekében mindig legyen import "@azure/functions-extensions-blob" az első a fájlokban.
  • Állítsa be a sdkBinding: true elemet a kötéskonfigurációban.
  • A művelethez használja a megfelelő ügyféltípust:
    • blobClient egyetlen blob műveleteihez
    • containerClient tárolón végzett műveletekhez
  • Hibák megfelelő kezelése a try/catch blokkok használatával
  • Nagy blobműveletek esetén érdemes lehet streamelési módszereket használni a memóriaproblémák elkerülése érdekében.

További információ: Blob Storage SDK-kötések Node.js mintákhoz: további példák a Blobhoz készült SDK-kötések függvényalkalmazásba való beépítésére.

Azure Service Bus

Ez a példa a Service Bus eseményindító által biztosított ServiceBusReceivedMessage által kapott ServiceBusMessageContext SDK-típust használja:

import '@azure/functions-extensions-servicebus'; // Ensure the Service Bus extension is imported
import { app, InvocationContext } from '@azure/functions';
import { ServiceBusMessageContext, messageBodyAsJson } from '@azure/functions-extensions-servicebus';

// This sample uses sdkBinding = true with manual message completion.
// With v0.4.0, message.body is returned as a raw Buffer instead of auto-parsed object.
export async function serviceBusQueueTrigger(
    serviceBusMessageContext: ServiceBusMessageContext,
    context: InvocationContext
): Promise<void> {
    const message = serviceBusMessageContext.messages[0];

    // v0.4.0: message.body is a Buffer — use messageBodyAsJson<T>() from the extension for one-line parsing
    const bodyData = messageBodyAsJson(message);
    context.log('Parsed message body:', bodyData);

    // Get current retry count from custom properties, default to 0
    const currentRetryCount = message.applicationProperties?.retryCnt
        ? parseInt(message.applicationProperties.retryCnt as string)
        : 0;
    context.log(`Current retry count: ${currentRetryCount}`);

    if (currentRetryCount >= 3) {
        // After 3 retries, complete the message to remove it from the queue
        context.log(`Maximum retry count (3) reached. Completing message to prevent infinite loop.`);
        await serviceBusMessageContext.actions.complete(message);
        context.log('Message completed after maximum retries');
    } else {
        // Abandon with updated retry count
        const newRetryCount = currentRetryCount + 1;
        const propertiesToModify = {
            retryCnt: newRetryCount.toString(),
            lastRetryTime: new Date().toISOString(),
            errorMessage: 'Processing failed',
        };

        context.log(`Abandoning message with retry count: ${newRetryCount}`);
        await serviceBusMessageContext.actions.abandon(message, propertiesToModify);
    }

    context.log('triggerMetadata: ', context.triggerMetadata);
}

app.serviceBusQueue('serviceBusQueueTrigger1', {
    connection: 'ServiceBusConnection',
    queueName: 'testqueue',
    sdkBinding: true,

Az SDK-típusokat használó másik példáért lásd az exponenciális visszalépési stratégia mintát.

Meghívási környezet

A függvény minden egyes meghívása egy meghívási context objektumot ad át, amely bemenetek olvasására, kimenetek beállítására, naplókba írásra és különböző metaadatok olvasására szolgál. A v3-modellben a környezeti objektum mindig az első argumentum, amelyet a kezelőnek ad át.

A context objektum a következő tulajdonságokkal rendelkezik:

Tulajdonság Leírás
invocationId Az aktuális függvényhívás azonosítója.
executionContext Tekintse meg a végrehajtási környezetet.
bindings Lásd a kötéseket.
bindingData A meghívás eseményindító bemenetére vonatkozó metaadatok, magát az értéket nem beleértve. Az eseményközpont eseményindítójának például van tulajdonságaenqueuedTimeUtc.
traceContext Az elosztott nyomkövetés környezete. További információért lásd Trace Context.
bindingDefinitions A bemenetek és kimenetek az alábbi módon kerülnek konfigurálásra: function.json.
req Lásd: HTTP-kérés.
res Lásd: HTTP-válasz.

környezet.végrehajtásiKörnyezet

A context.executionContext objektum a következő tulajdonságokkal rendelkezik:

Tulajdonság Leírás
invocationId Az aktuális függvényhívás azonosítója.
functionName A meghívandó függvény neve. A függvény nevét a function.json fájlt tartalmazó mappa neve határozza meg.
functionDirectory A fájlt tartalmazó function.json mappa.
retryContext Lásd az újrapróbálkozás kontextusát.

context.végrehajtásiKörnyezet.újrapróbálkozásiKörnyezet

A context.executionContext.retryContext objektum a következő tulajdonságokkal rendelkezik:

Tulajdonság Leírás
retryCount Az aktuális újrapróbálkozási kísérletet jelző szám.
maxRetryCount A végrehajtások újrapróbálásának maximális száma. A -1 érték azt jelenti, hogy határozatlan ideig próbálkozik újra.
exception Az újrapróbálkozást okozó kivétel.

környezet.kötések

Az context.bindings objektum bemenetek olvasására vagy kimenetek beállítására szolgál. Az alábbi példa egy tárolási üzenetsor-eseményindító, amely -t használ egy tárolóblob bemenetről egy tárolóblob kimenetre történő másoláshoz. Az üzenetsor-üzenet tartalma lecseréli {queueTrigger} a másolandó fájlnevet egy kötési kifejezés segítségével.

{
    "name": "myQueueItem",
    "type": "queueTrigger",
    "direction": "in",
    "connection": "storage_APPSETTING",
    "queueName": "helloworldqueue"
},
{
    "name": "myInput",
    "type": "blob",
    "direction": "in",
    "connection": "storage_APPSETTING",
    "path": "helloworld/{queueTrigger}"
},
{
    "name": "myOutput",
    "type": "blob",
    "direction": "out",
    "connection": "storage_APPSETTING",
    "path": "helloworld/{queueTrigger}-copy"
}

module.exports = async function (context, myQueueItem) {
  const blobValue = context.bindings.myInput;
  context.bindings.myOutput = blobValue;
};

környezet.kész

A context.done metódus elavult. Az aszinkron függvények támogatása előtt jelezheti, hogy a függvény a következő hívással lett végrehajtva context.done():

module.exports = function (context, request) {
  context.log("this pattern is now deprecated");
  context.done();
};

Javasoljuk, hogy távolítsa el a context.done() hívást, és jelölje meg a függvényt aszinkronnak, hogy egy promise-t adjon vissza (még akkor is, ha nem tesz semmit a await-nel). Amint a függvény befejeződik (vagyis a visszaadott ígéret feloldódik), a v3-as modell tudja, hogy a függvény elkészült.

module.exports = async function (context, request) {
  context.log("you don't need context.done or an awaited call");
};

A függvény minden egyes meghívása egy meghívási context objektumot ad át, amely információkat tartalmaz a hívásról és a naplózáshoz használt módszerekről. A v4 modellben az context objektum általában a kezelőnek átadott második argumentum.

Az InvocationContext osztály a következő tulajdonságokkal rendelkezik:

Tulajdonság Leírás
invocationId Az aktuális függvényhívás azonosítója.
functionName A függvény neve.
extraInputs A további bemenetek értékeinek lekérésére szolgál. További információ: további bemenetek és kimenetek.
extraOutputs A további kimenetek értékeinek beállítására szolgál. További információ: további bemenetek és kimenetek.
retryContext Lásd az újrapróbálkozás kontextusát.
traceContext Az elosztott nyomkövetés környezete. További információért lásd Trace Context.
triggerMetadata A meghívás eseményindító bemenetére vonatkozó metaadatok, magát az értéket nem beleértve. Az eseményközpont eseményindítójának például van tulajdonságaenqueuedTimeUtc.
options A függvény regisztrálásakor használt beállítások, miután érvényesítették őket, és az alapértelmezett beállítások explicit módon vannak megadva.

Újrapróbálkozás kontextus

A retryContext objektum a következő tulajdonságokkal rendelkezik:

Tulajdonság Leírás
retryCount Az aktuális újrapróbálkozási kísérletet jelző szám.
maxRetryCount A végrehajtások újrapróbálásának maximális száma. A -1 érték azt jelenti, hogy határozatlan ideig próbálkozik újra.
exception Az újrapróbálkozást okozó kivétel.

További információért lásd retry-policies.

Naplózás

Az Azure Functions esetén ajánlott a context.log() használata naplók írására. Azure Functions integrálható a Azure Application Insights szolgáltatással a függvényalkalmazás naplóinak jobb rögzítése érdekében. A Azure Monitor részét képező Application Insights lehetővé teszi az alkalmazásnaplók és a nyomkövetési kimenetek gyűjtését, vizuális megjelenítését és elemzését. További információ: monitoring Azure Functions.

Megjegyzés

Ha az alternatív Node.js console.log metódust használja, a naplók az alkalmazás szintjén lesznek nyomon követve, és nem lesznek társítva egyetlen adott függvénnyel sem. Javasoljuk, hogy a naplózáshoz használja context ahelyettconsole, hogy az összes napló egy adott függvényhez legyen társítva.

Az alábbi példa egy naplót ír az alapértelmezett "információ" szinten, beleértve a hívásazonosítót is:

context.log(`Something has happened. Invocation ID: "${context.invocationId}"`);

Naplózási szintek

Az alapértelmezett context.log módszer mellett a következő metódusok is elérhetők, amelyekkel naplókat írhat meghatározott szinteken:

Metódus Leírás
context.log.error() Hibaszintű eseményt ír a naplókba.
context.log.warn() Figyelmeztető szintű eseményt ír a naplókba.
context.log.info() Információszintű eseményt ír a naplókba.
context.log.verbose() Nyomkövetési szintű eseményt ír a naplókba.
Metódus Leírás
context.trace() Nyomkövetési szintű eseményt ír a naplókba.
context.debug() Hibakeresési szintű eseményt ír a naplókba.
context.info() Információszintű eseményt ír a naplókba.
context.warn() Figyelmeztető szintű eseményt ír a naplókba.
context.error() Hibaszintű eseményt ír a naplókba.

Naplószint konfigurálása

Azure Functions lehetővé teszi a naplók nyomon követéséhez és megtekintéséhez használandó küszöbérték meghatározását. A küszöbérték beállításához használja a logging.logLevel fájlban lévő tulajdonságot host.json . Ez a tulajdonság lehetővé teszi az összes függvényre alkalmazott alapértelmezett szint vagy az egyes függvények küszöbértékének meghatározását. További információ: Az Azure Functions.

Egyéni adatok nyomon követése

Alapértelmezés szerint Azure Functions a kimenetet nyomkövetésként írja az Application Insightsba. A további szabályozás érdekében az Application Insights Node.js SDK-val egyéni naplókat, metrikákat és függőségeket küldhet az Application Insights-példánynak.

Megjegyzés

Az Application Insights Node.js SDK metódusai idővel változhatnak. Lehetnek kisebb szintaxisbeli különbségek az itt bemutatott példáktól. A legújabb API-használati példákért tekintse meg az Application Insights Node.js SDK dokumentációját.

Az elosztott nyomkövetéshez a Node.js v4 programozási modellben az Application Insights SDK helyett használhatja a @azure/functions-opentelemetry-instrumentation csomagot. Ez a csomag OpenTelemetry-alapú automatikus rendszerezést biztosít Azure Functions számára. További információ: OpenTelemetry Azure Functions Instrumentation for Node.js GitHub adattár.

const appInsights = require("applicationinsights");
appInsights.setup();
const client = appInsights.defaultClient;

module.exports = async function (context, request) {
  // Use this with 'tagOverrides' to correlate custom logs to the parent function invocation.
  var operationIdOverride = {
    "ai.operation.id": context.traceContext.traceparent,
  };

  client.trackEvent({
    name: "my custom event",
    tagOverrides: operationIdOverride,
    properties: { customProperty2: "custom property value" },
  });
  client.trackException({
    exception: new Error("handled exceptions can be logged with this method"),
    tagOverrides: operationIdOverride,
  });
  client.trackMetric({
    name: "custom metric",
    value: 3,
    tagOverrides: operationIdOverride,
  });
  client.trackTrace({
    message: "trace message",
    tagOverrides: operationIdOverride,
  });
  client.trackDependency({
    target: "http://dbname",
    name: "select customers proc",
    data: "SELECT * FROM Customers",
    duration: 231,
    resultCode: 0,
    success: true,
    dependencyTypeName: "ZSQL",
    tagOverrides: operationIdOverride,
  });
  client.trackRequest({
    name: "GET /customers",
    url: "http://myserver/customers",
    duration: 309,
    resultCode: 200,
    success: true,
    tagOverrides: operationIdOverride,
  });
};

A tagOverrides paraméter a operation_Id függvény meghívási azonosítójára állítja be a paramétert. Ezzel a beállítással korrelálhatja az összes automatikusan létrehozott és egyéni naplót egy adott függvényhíváshoz.

HTTP-eseményindítók

A HTTP- és webhook-eseményindítók kérés- és válaszobjektumokkal jelölik a HTTP-üzeneteket.

A HTTP- és webhook-triggerek HttpRequest és HttpResponse objektumokat használnak a HTTP-üzenetek megjelenítésére. Az osztályok a beolvasási szabvány egy részhalmazát jelölik a Node.js undici csomag használatával.

HTTP-kérés

A kérés többféleképpen is elérhető:

  • A függvény második argumentumaként:

    module.exports = async function (context, request) {
    context.log(`Http function processed request for url "${request.url}"`);

  • A tulajdonságból context.req :

    module.exports = async function (context, request) {
    context.log(`Http function processed request for url "${context.req.url}"`);

  • A névvel ellátott bemeneti kötésekből: Ez a beállítás ugyanúgy működik, mint bármely nem HTTP-kötés. A(z) function.json-ban/-ben a kötés nevének egyeznie kell a(z) context.bindings-on/-en/-ön/-n található kulccsal, vagy a következő példában szereplő "request1" értékkel.

    {
  "name": "request1",
  "type": "httpTrigger",
  "direction": "in",
  "authLevel": "anonymous",
  "methods": ["get", "post"]
}

    module.exports = async function (context, request) {
    context.log(`Http function processed request for url "${context.bindings.request1.url}"`);

A HttpRequest objektum a következő tulajdonságokkal rendelkezik:

Tulajdonság Típus Leírás
method string A függvény meghívásához használt HTTP-kérési metódus.
url string Kérés URLje.
headers Record<string, string> HTTP-kérelemfejlécek. Ez az objektum érzékeny a kis- és nagybetűkre. Ehelyett ajánlott használni request.getHeader('header-name'), ami a kis- és nagybetűket nem érzékenyítő.
query Record<string, string> Sztringparaméter-kulcsok és értékek lekérdezése az URL-címből.
params Record<string, string> Útvonalparaméter-kulcsok és értékek.
user HttpRequestUser \| null A bejelentkezett felhasználót ábrázoló objektum a Functions-hitelesítésen, az SWA-hitelesítésen vagy a null értéken keresztül, ha nincs bejelentkezve ilyen felhasználó.
body Buffer \| string \| any Ha az adathordozó típusa "application/octet-stream" vagy "multipart/*", body akkor puffer. Ha az érték egy JSON-elemzésre képes sztring, body akkor az elemezt objektum. body Egyébként egy karakterlánc.
rawBody string A törzs mint karakterlánc. A név ellenére ez a tulajdonság nem ad vissza puffert.
bufferBody Buffer A test, mint tároló.

A kérés a HTTP által aktivált függvény kezelőjének első argumentumaként érhető el.

async (request, context) => {
    context.log(`Http function processed request for url "${request.url}"`);

A HttpRequest objektum a következő tulajdonságokkal rendelkezik:

Tulajdonság Típus Leírás
method string A függvény meghívásához használt HTTP-kérési metódus.
url string Kérés URLje.
headers Headers HTTP-kérelemfejlécek.
query URLSearchParams Sztringparaméter-kulcsok és értékek lekérdezése az URL-címből.
params Record<string, string> Útvonalparaméter-kulcsok és értékek.
user HttpRequestUser \| null A bejelentkezett felhasználót ábrázoló objektum a Functions-hitelesítésen, az SWA-hitelesítésen vagy a null értéken keresztül, ha nincs bejelentkezve ilyen felhasználó.
body ReadableStream \| null Törzs, mint olvasható stream.
bodyUsed boolean Logikai érték, amely jelzi, hogy a szöveg már el van-e olvasva.

A kérés vagy válasz törzsének eléréséhez a következő módszerek használhatók:

Metódus Visszatérési típus
arrayBuffer() Promise<ArrayBuffer>
blob() Promise<Blob>
formData() Promise<FormData>
json() Promise<unknown>
text() Promise<string>

Megjegyzés

A testfunkciók csak egyszer futtathatók. A későbbi hívások üres sztringekkel/ArrayBuffers-ekkel oldódnak fel.

HTTP-válasz

A válasz többféleképpen állítható be:

  • context.res A tulajdonság beállítása:

    module.exports = async function (context, request) {
    context.res = { body: `Hello, world!` };

  • Adja vissza a választ: Ha a függvény aszinkron, és a $return alatt beállította a kötés nevét function.json, akkor a választ közvetlenül visszaadhatja ahelyett, hogy a context-be állítaná be.

    {
  "type": "http",
  "direction": "out",
  "name": "$return"
}

    module.exports = async function (context, request) {
    return { body: `Hello, world!` };

  • Adja meg a nevesített kimeneti kötést: Ez a beállítás ugyanúgy működik, mint bármely nem HTTP-kötés. A kötés function.json nevének meg kell egyeznie a következő példában szereplő context.bindingskulccsal, vagy a "válasz1" értékkel:

    {
  "type": "http",
  "direction": "out",
  "name": "response1"
}

    module.exports = async function (context, request) {
    context.bindings.response1 = { body: `Hello, world!` };

  • Hívás context.res.send(): Ez a beállítás már elavult. Implicit módon meghívja context.done() , és nem használható aszinkron függvényekben.

    module.exports = function (context, request) {
    context.res.send(`Hello, world!`);

Ha a válasz beállításakor új objektumot hoz létre, az objektumnak meg kell egyeznie a HttpResponseSimple felülettel, amely a következő tulajdonságokkal rendelkezik:

Tulajdonság Típus Leírás
headers Record<string, string> (nem kötelező) HTTP-válaszfejlécek
cookies Cookie[] (nem kötelező) HTTP-válasz cookie-k.
body any (nem kötelező) HTTP-válasz törzse.
statusCode number (nem kötelező) HTTP-válasz állapotkódja. Ha nincs beállítva, az alapértelmezett érték a következő.200
status number (nem kötelező) Ugyanaz, mint a statusCode. Ezt a tulajdonságot a rendszer figyelmen kívül hagyja, ha statusCode be van állítva.

Az objektumot context.res felülírás nélkül is módosíthatja. Az alapértelmezett context.res objektum a HttpResponseFull interfészt használja, amely a HttpResponseSimple tulajdonságok mellett a következő metódusokat is támogatja:

Metódus Leírás
status() Beállítja az állapotot.
setHeader() Állítson be egy fejlécmezőt. MEGJEGYZÉS: res.set() és res.header() támogatottak is, és ugyanezt teszik.
getHeader() Fejlécmező lekérése MEGJEGYZÉS: res.get() szintén támogatott, és ugyanezt teszi.
removeHeader() Eltávolít egy fejlécet.
type() Beállítja a "content-type" fejlécet.
send() Ez a metódus elavultnak nyilvánított. Beállítja a törzset, és meghívja a context.done() parancsot annak jelzésére, hogy a szinkron függvény befejeződött. MEGJEGYZÉS: res.end() szintén támogatott, és ugyanezt teszi.
sendStatus() Ez a metódus elavultnak nyilvánított. Beállítja az állapotkódot és a hívásokat context.done() , hogy jelezzék, hogy a szinkronizálási függvény befejeződött.
json() Ez a metódus elavultnak nyilvánított. A "content-type"-t "application/json" értékre állítja, beállítja a törzset, és hívásokkal context.done() jelzi, hogy a szinkronizálási függvény befejeződött.

A válasz többféleképpen állítható be:

  • Egyszerű felület típussal HttpResponseInit: Ez a lehetőség a válaszok visszaadásának legegyszerűbb módja.

    return { body: `Hello, world!` };

Az HttpResponseInit interfész a következő tulajdonságokkal rendelkezik:

Tulajdonság Típus Leírás
body BodyInit (nem kötelező) HTTP-válasz törzse, mint ArrayBuffer, AsyncIterable<Uint8Array>, Blob, FormData, Iterable<Uint8Array>, NodeJS.ArrayBufferView, URLSearchParams, null vagy string.
jsonBody any (nem kötelező) JSON-szerializálható HTTP-válasz törzse. Ha be van állítva, a HttpResponseInit.body tulajdonság figyelmen kívül lesz hagyva ennek a tulajdonságnak a javára.
status number (nem kötelező) HTTP-válasz állapotkódja. Ha nincs beállítva, az alapértelmezett érték a következő.200
headers HeadersInit (nem kötelező) HTTP-válaszfejlécek
cookies Cookie[] (nem kötelező) HTTP-válasz cookie-k.

  • Típus szerinti HttpResponseosztályként: Ez a beállítás segédmetórákat biztosít a válasz különböző részeinek, például a fejlécek olvasásához és módosításához.

    const response = new HttpResponse({ body: `Hello, world!` });
response.headers.set("content-type", "application/json");
return response;

Az HttpResponse osztály argumentumként elfogad egy választhatót HttpResponseInit a konstruktorhoz, és a következő tulajdonságokkal rendelkezik:

Tulajdonság Típus Leírás
status number HTTP-válasz állapotkódja.
headers Headers HTTP-válaszfejlécek
cookies Cookie[] HTTP-válasz cookie-k.
body ReadableStream | null Törzs, mint olvasható stream.
bodyUsed boolean Logikai érték, amely jelzi, hogy a test már beolvasva lett-e.

HTTP–streamek

A HTTP-streamek olyan funkciók, amelyek megkönnyítik a nagy méretű adatok feldolgozását, az OpenAI-válaszok streamelhetőségét, a dinamikus tartalmak megjelenítését és más alapvető HTTP-forgatókönyvek támogatását. Lehetővé teszi a http-végpontokra irányuló kérések és válaszok streamelését a Node.js függvényalkalmazásban. HTTP-streameket használjon olyan helyzetekben, ahol az alkalmazás valós idejű cserét és interakciót igényel az ügyfél és a kiszolgáló között HTTP-en keresztül. HTTP-streamek használatával is a legjobb teljesítményt és megbízhatóságot érheti el az alkalmazások számára a HTTP használatakor.

Fontos

A HTTP-streamek nem támogatottak a v3-modellben. Frissítsen a v4-modellre a HTTP-streamelési funkció használatához. A 4-ben futó programozási modell meglévő HttpRequest és HttpResponse típusai már támogatják az üzenettörzs kezelésének különböző módjait, beleértve streamként is.

Előfeltételek

Streamek engedélyezése

Az alábbi lépésekkel engedélyezheti a HTTP-streameket a függvényalkalmazásban a Azure és a helyi projektekben:

  1. Ha nagy mennyiségű adatot szeretne streamelni, módosítsa a FUNCTIONS_REQUEST_BODY_SIZE_LIMIT beállítást Azure. Az alapértelmezett maximális megengedett törzsméret az 104857600, amely ~100 MB méretűre korlátozza a kéréseket.

  2. Helyi fejlesztéshez adja hozzá FUNCTIONS_REQUEST_BODY_SIZE_LIMIT a local.settings.json fájlt is.

  3. Adja hozzá az alábbi kódot az alkalmazáshoz a fő mező által tartalmazott bármelyik fájlban.

    const { app } = require("@azure/functions");

app.setup({ enableHttpStream: true });

Példák streamelése

Ez a példa egy HTTP által aktivált függvényt mutat be, amely HTTP POST-kérésen keresztül fogad adatokat, és a függvény ezeket az adatokat egy megadott kimeneti fájlba streameli:

const { app } = require('@azure/functions');
const { createWriteStream } = require('fs');
const { Writable } = require('stream');

app.http('httpTriggerStreamRequest', {
    methods: ['POST'],
    authLevel: 'anonymous',
    handler: async (request, context) => {
        const writeStream = createWriteStream('<output file path>');
        await request.body.pipeTo(Writable.toWeb(writeStream));

        return { body: 'Done!' };
    },
});

Ez a példa egy HTTP által aktivált függvényt mutat be, amely egy fájl tartalmát streameli a bejövő HTTP GET-kérelmekre adott válaszként:

const { app } = require('@azure/functions');
const { createReadStream } = require('fs');

app.http('httpTriggerStreamResponse', {
    methods: ['GET'],
    authLevel: 'anonymous',
    handler: async (request, context) => {
        const body = createReadStream('<input file path>');

        return { body };
    },
});

Ha streameket használó, használatra kész mintaalkalmazást szeretne használni, tekintse meg ezt a példát a GitHub.

Stream szempontok

  • A streamek használatának maximális kihasználtságához használható request.body . Továbbra is használhat olyan metódusokat, mint a request.text(), amelyek mindig sztringként adják vissza a tartalmat.

Kampók

A horgok nem támogatottak a v3-modellben. Frissítsen a v4-modellre , hogy horgokat használjon.

A Azure Functions életciklus különböző pontjain lévő kód végrehajtásához használjon horogot. A hookok azon a sorrendben lesznek végrehajtva, ahogy regisztrálják őket, és az alkalmazás bármely fájljából regisztrálhatók. Jelenleg két hatóköre van a horgoknak, az "alkalmazás" szintnek és az "invocation" szintnek.

Meghívási hookok

A meghívási horgok a függvény minden egyes meghívásakor egyszer kerülnek végrehajtásra, akár a meghívást megelőzően egy preInvocation horogban, akár azt követően egy postInvocation horogban. Alapértelmezés szerint a hook minden eseménytípusnál végrehajtódik, de lehet szűrni típus szerint is. Az alábbi példa bemutatja, hogyan regisztrálhat egy meghívási horogot, és hogyan szűrhet triggertípus szerint:

const { app } = require('@azure/functions');

app.hook.preInvocation((context) => {
    if (context.invocationContext.options.trigger.type === 'httpTrigger') {
        context.invocationContext.log(
            `preInvocation hook executed for http function ${context.invocationContext.functionName}`
        );
    }
});

app.hook.postInvocation((context) => {
    if (context.invocationContext.options.trigger.type === 'httpTrigger') {
        context.invocationContext.log(
            `postInvocation hook executed for http function ${context.invocationContext.functionName}`
        );
    }
});

A horogkezelő első argumentuma az adott horogtípusra jellemző környezeti objektum.

A PreInvocationContext objektum a következő tulajdonságokkal rendelkezik:

Tulajdonság Leírás
inputs A meghívásnak átadott argumentumok.
functionHandler A meghívás függvénykezelője. Az érték módosítása hatással van magára a függvényre.
invocationContext A függvénynek átadott meghívási környezeti objektum.
hookData Az az ajánlott hely, ahol az adatokat ugyanabban a hatókörben tárolhatja és megoszthatja a horgok között. Egyedi tulajdonságnevet kell használnia, hogy az ne ütközzön más hook-ok adataival.

A PostInvocationContext objektum a következő tulajdonságokkal rendelkezik:

Tulajdonság Leírás
inputs A meghívásnak átadott argumentumok.
result A függvény eredménye. Az érték módosítása hatással van a függvény általános eredményére.
error A függvény által kidobott vagy null/nem definiált hiba, ha nincs hiba. Az érték módosítása hatással van a függvény általános eredményére.
invocationContext A függvénynek átadott meghívási környezeti objektum.
hookData Az az ajánlott hely, ahol az adatokat ugyanabban a hatókörben tárolhatja és megoszthatja a horgok között. Egyedi tulajdonságnevet kell használnia, hogy az ne ütközzön más hook-ok adataival.

Alkalmazáshookok

Az alkalmazáshorgokat az alkalmazás minden egyes példányában egyszer hajtja végre, akár az indítás során egy appStart horogban, akár a leállítás során egy appTerminate horogban. Az alkalmazásmegállítási horgok végrehajtására korlátozott idő áll rendelkezésre, és nem minden esetben kerülnek végrehajtásra.

A Azure Functions futtatókörnyezet jelenleg nem támogatja a környezet meghíváson kívüli naplózását. Az Application Insights npm-csomag használatával naplózza az adatokat az alkalmazásszintű hookok során.

Az alábbi példa alkalmazáshookokat regisztrál:

const { app } = require('@azure/functions');

app.hook.appStart((context) => {
    // add your logic here
});

app.hook.appTerminate((context) => {
    // add your logic here
});

A horogkezelő első argumentuma az adott horogtípusra jellemző környezeti objektum.

A AppStartContext objektum a következő tulajdonságokkal rendelkezik:

Tulajdonság Leírás
hookData Az az ajánlott hely, ahol az adatokat ugyanabban a hatókörben tárolhatja és megoszthatja a horgok között. Egyedi tulajdonságnevet kell használnia, hogy az ne ütközzön más hook-ok adataival.

A AppTerminateContext objektum a következő tulajdonságokkal rendelkezik:

Tulajdonság Leírás
hookData Az az ajánlott hely, ahol az adatokat ugyanabban a hatókörben tárolhatja és megoszthatja a horgok között. Egyedi tulajdonságnevet kell használnia, hogy az ne ütközzön más hook-ok adataival.

Skálázás és egyidejűség

Alapértelmezés szerint Azure Functions automatikusan figyeli az alkalmazás terhelését, és szükség szerint több gazdagéppéldányt hoz létre a Node.js számára. Azure Functions beépített (nem felhasználó által konfigurálható) küszöbértékeket használ a különböző triggertípusokhoz, hogy eldöntse, mikor vegye fel a példányokat, például az üzenetek életkorát és a QueueTrigger üzenetsorméretét. További információ: Hogyan működnek a Fogyasztási és Prémium csomagok.

Ez a skálázási viselkedés számos Node.js alkalmazáshoz elegendő. A processzorhoz kötött alkalmazások esetében több nyelvi feldolgozó folyamat használatával tovább javíthatja a teljesítményt. A feldolgozói folyamatok állomásonkénti számát az alapértelmezett 1-ről legfeljebb 10-re növelheti a FUNCTIONS_WORKER_PROCESS_COUNT alkalmazásbeállítással. Azure Functions ezután megpróbálja egyenletesen elosztani az egyidejű függvényhívásokat ezeken a feldolgozókon. Ez a viselkedés kevésbé valószínű, hogy egy processzorigényes függvény blokkolja a többi függvény futtatását. A beállítás az alkalmazás igény szerinti skálázásakor minden olyan gazdagépre vonatkozik, amelyet az Azure Functions hoz létre.

Figyelmeztetés

Óvatosan használja a FUNCTIONS_WORKER_PROCESS_COUNT beállítást. Az ugyanabban a példányban futó folyamatok kiszámíthatatlan viselkedéshez vezethetnek, és növelhetik a függvény betöltési idejét. Ha ezt a beállítást használja, javasoljuk , hogy a csomagfájlból való futtatással ellensúlyozza ezeket a hátrányokat.

Node.js verzió

A futtatókörnyezet aktuális verzióját megtekintheti úgy, hogy bármely függvényből naplózza a process.version értéket. Tekintse meg supported versions az egyes programozási modellek által támogatott Node.js verziók listáját.

A csomópont verziójának beállítása

A Node.js verzió frissítésének módja attól függ, hogy a függvényalkalmazás melyik operációs rendszeren fut.

Ha Windows fut, a Node.js verziót a WEBSITE_NODE_DEFAULT_VERSION alkalmazásbeállítás állítja be. Ez a beállítás a Azure CLI vagy a Azure portálon frissíthető.

A Node.js verziókról további információt a Támogatott verziók című témakörben talál.

A Node.js verzió frissítése előtt győződjön meg arról, hogy a függvényalkalmazás a Azure Functions futtatókörnyezet legújabb verzióján fut. Ha frissítenie kell a futtatókörnyezeti verziót, tekintse meg a Alkalmazások Azure Functions 3.x-es verzióról a 4.x verzióra történő frissítését.

Futtassa a Azure CLI az functionapp config appsettings set parancsot a Windows futó függvényalkalmazás Node.js verziójának frissítéséhez:

az functionapp config appsettings set  --settings WEBSITE_NODE_DEFAULT_VERSION=~22 \
 --name <FUNCTION_APP_NAME> --resource-group <RESOURCE_GROUP_NAME>

Ezzel beállítja az WEBSITE_NODE_DEFAULT_VERSION alkalmazást a támogatott LTS-verzióra ~22.

A módosítások után a függvényalkalmazás újraindul. A Node.js-függvények támogatásával kapcsolatos további információkért lásd a nyelvi futtatókörnyezet támogatási szabályzatát.

Környezeti változók

A környezeti változók hasznosak lehetnek az üzemeltetési titkos kulcsok (kapcsolati sztring, kulcsok, végpontok stb.) vagy környezeti beállítások, például profilkészítési változók esetében. Környezeti változókat a helyi és a felhőbeli környezetekben is hozzáadhat, és a függvénykódban keresztül process.env érheti el őket.

Az alábbi példa naplózza a környezeti változót WEBSITE_SITE_NAME :

module.exports = async function (context) {
  context.log(`WEBSITE_SITE_NAME: ${process.env["WEBSITE_SITE_NAME"]}`);
};

async function timerTrigger1(myTimer, context) {
  context.log(`WEBSITE_SITE_NAME: ${process.env["WEBSITE_SITE_NAME"]}`);
}

Helyi fejlesztési környezetben

Helyi futtatáskor a függvényprojekt tartalmaz egy local.settings.json fájlt, amelyben a környezeti változókat az Values objektumban tárolja.

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "",
    "FUNCTIONS_WORKER_RUNTIME": "node",
    "CUSTOM_ENV_VAR_1": "hello",
    "CUSTOM_ENV_VAR_2": "world"
  }
}

Azure felhőkörnyezetben

Amikor Azure futtat, a függvényalkalmazás lehetővé teszi a Alkalmazási beállítások beállítását és használatát, például szolgáltatáskapcsolati sztringeket, és ezeket a beállításokat környezeti változókként teszi elérhetővé a végrehajtás során.

A függvényalkalmazás beállításai többféleképpen is hozzáadhatók, frissíthetők és törölhetők:

A függvényalkalmazás beállításainak módosításához újra kell indítani a függvényalkalmazást.

Feldolgozói környezeti változók

Az Node.js több Functions környezeti változó is létezik:

LanguageWorkerscsomópontargumentumok

Ezzel a beállítással egyéni argumentumokat adhat meg a Node.js folyamat indításakor. Leggyakrabban helyileg használják a feldolgozó hibakeresési módban való elindításához, de egyéni argumentumok esetén Azure is használható.

Figyelmeztetés

Ha lehetséges, kerülje a languageWorkers__node__arguments használatát az Azure-ban, mert negatív hatással lehet a hidegindítási idők-re. Ahelyett, hogy előre előkészített feldolgozókat használna, a futtatókörnyezetnek új feldolgozót kell kezdenie az ön egyéni argumentumaival.

Naplózás logLevelWorker

Ez a beállítás az Node.js-specifikus feldolgozónaplók alapértelmezett naplószintjének beállítását állítja be. Alapértelmezés szerint csak figyelmeztetési vagy hibanaplók jelennek meg, de beállíthatja information vagy debug értékekre, hogy segítsen diagnosztizálni a Node.js munkamenettel kapcsolatos problémákat. További információkért lásd a naplószintek konfigurálását ismertető témakört.

ECMAScript-modulok (előzetes verzió)

Megjegyzés

Mivel az ECMAScript modulok jelenleg előzetes funkcióként elérhetők a Node.js 14 vagy újabb verzióiban az Azure Functions-ben.

Az ECMAScript-modulok (ES-modulok) a Node.js új hivatalos standard modulrendszerei. A cikkben szereplő kódminták eddig a CommonJS szintaxist használják. Ha Azure Functions Node.js 14-es vagy újabb verzióiban futtatja, az ES-modulok szintaxisával megírhatja a függvényeket.

Ha ES-modulokat szeretne használni egy függvényben, módosítsa a fájlnevét bővítmény használatára .mjs . Az alábbi index.mjs fájl például egy HTTP által aktivált függvény, amely ES-modulok szintaxisával importálja a uuid kódtárat, és visszaad egy értéket.

import { v4 as uuidv4 } from "uuid";

async function httpTrigger1(context, request) {
  context.res.body = uuidv4();
}

export default httpTrigger;

import { v4 as uuidv4 } from "uuid";

async function httpTrigger1(request, context) {
  return { body: uuidv4() };
}

app.http("httpTrigger1", {
  methods: ["GET", "POST"],
  handler: httpTrigger1,
});

Függvény belépési pontjának konfigurálása

Az function.json tulajdonságok scriptFile és entryPoint az exportált függvény helyének és nevének konfigurálásához használhatók. A scriptFile tulajdonságra a TypeScript használatakor van szükség, és a lefordított JavaScriptre kell mutatnia.

Az scriptFile használata

Alapértelmezés szerint egy JavaScript-függvény egy olyan fájlból index.jslesz végrehajtva, amely ugyanazzal a szülőkönyvtárral rendelkezik, mint a megfelelő function.json.

scriptFile a következő példához hasonló mappastruktúra lekérésére használható:

<project_root>/
 | - node_modules/
 | - myFirstFunction/
 | | - function.json
 | - lib/
 | | - sayHello.js
 | - host.json
 | - package.json

A function.json for myFirstFunction fájlnak tartalmaznia kell egy scriptFile olyan tulajdonságot, amely az exportált függvény futtatásával a fájlra mutat.

{
  "scriptFile": "../lib/sayHello.js",
  "bindings": [
    ...
  ]
}

Az entryPoint használata

A v3 modellben egy függvényt module.exports kell exportálni a kereséshez és a futtatáshoz. Alapértelmezés szerint az a függvény hajtódik végre, amely aktiváláskor elindul, ez az egyetlen export az adott fájlból, a run nevű export vagy a index nevű export. Az alábbi példa beállítja a entryPoint -t a function.json alatti «logHello» egyéni értékre.

{
  "entryPoint": "logHello",
  "bindings": [
    ...
  ]
}

async function logHello(context) {
  context.log("Hello, world!");
}

module.exports = { logHello };

Helyi hibakeresés

Javasoljuk, hogy a VS Code-ot használja helyi hibakereséshez, amely automatikusan indítja el a Node.js folyamatot hibakeresési módban, és önnek csatolja a folyamatot. További információkért lásd a függvény helyi futtatását.

Ha másik eszközt használ a hibakereséshez, vagy manuálisan szeretné elindítani a Node.js folyamatot hibakeresési módban, adja hozzá a "languageWorkers__node__arguments": "--inspect" elemet a Values alá a local.settings.json fájlban. Az --inspect argumentum arra utasítja Node.js, hogy alapértelmezés szerint a 9229-s porton figyelje a hibakeresési ügyfelet. További információ: Node.js hibakeresési útmutató.

Ajánlások

Ez a szakasz az ajánlott Node.js-alkalmazások számos hatásosabb mintáját ismerteti.

Válasszon egyvCPU App Service-csomagokat

Amikor az App Service-csomagot használó függvényalkalmazást hoz létre, javasoljuk, hogy több vCPU-t tartalmazó csomag helyett válasszon egy egy-vCPU-csomagot. A Functions ma hatékonyabban futtat Node.js függvényeket egy-vCPU rendszerű virtuális gépeken, és a nagyobb virtuális gépek használata nem eredményez a várt teljesítménybeli javulást. Szükség esetén manuálisan felskálázhatja a skálázást több egy-vCPU virtuálisgép-példány hozzáadásával, vagy engedélyezheti az automatikus skálázást. További információ: Példányok számának manuális vagy automatikus skálázása.

Csomagfájlból futtatás

Amikor Azure Functions fejlesztése történik a szerver nélküli üzemeltetési modellben, a hidegindítások valóságot jelentenek. A hidegindítás azt jelenti, hogy a függvényalkalmazás egy inaktivitási időszak után először indul el, és a kezdés hosszabb időt vesz igénybe. A nagy függőségi fákkal rendelkező Node.js alkalmazások esetében a hidegindítás jelentős lehet. A hidegindítási folyamat felgyorsításához futtassa a függvényeket csomagfájlként , ha lehetséges. Sok üzembe helyezési módszer alapértelmezés szerint ezt a modellt használja, de ha nagy hideget tapasztal, ellenőrizze, hogy így fut-e.

Egyetlen statikus ügyfél használata

Ha szolgáltatásspecifikus ügyfelet használ egy Azure Functions alkalmazásban, ne hozzon létre új ügyfelet minden függvénymeghívással, mert a kapcsolat korlátait is elérheti. Ehelyett hozzon létre egyetlen statikus ügyfelet a globális hatókörben. További információért lásd: kapcsolatok kezelése az Azure Functions-ben.

Használja async és await

Amikor Azure Functions-t ír Node.js-ben, a kódot a async és await kulcsszavak használatával kell írnia. A async és await használata a visszahívások vagy .then és .catch helyett az ígéretekkel segít elkerülni két gyakori problémát:

  • A Node.js folyamatot összeomlást okozó, nem kezelt kivételek eldobása, ami potenciálisan befolyásolhatja más függvények végrehajtását.
  • Váratlan viselkedés, például hiányzó naplók context.log, amelyet az aszinkron hívások megfelelő várakozásának hiánya okoz.

Az alábbi példában az aszinkron metódust fs.readFile egy hibaelső visszahívási függvény hívja meg második paraméterként. Ez a kód mindkét korábban említett problémát okozza. A megfelelő hatókörben nem explicit módon észlelt kivétel a teljes folyamatot összeomlhatja (1. probléma). Ha a visszahívás befejeződése nélkül tér vissza, az azt jelenti, hogy a HTTP-válasznak néha üres törzse van (2. probléma).

// DO NOT USE THIS CODE
const { app } = require('@azure/functions');
const fs = require('fs');

app.http('httpTriggerBadAsync', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    handler: async (request, context) => {
        let fileData;
        fs.readFile('./helloWorld.txt', (err, data) => {
            if (err) {
                context.error(err);
                // BUG #1: This will result in an uncaught exception that crashes the entire process
                throw err;
            }
            fileData = data;
        });
        // BUG #2: fileData is not guaranteed to be set before the invocation ends
        return { body: fileData };
    },
});

Az alábbi példában az aszinkron metódust fs.readFile egy hibaelső visszahívási függvény hívja meg második paraméterként. Ez a kód mindkét korábban említett problémát okozza. A megfelelő hatókörben nem explicit módon észlelt kivétel a teljes folyamatot összeomlhatja (1. probléma). Ha a visszahívás hatókörén kívülre hívja az elavult metódust context.done() , jelezheti, hogy a függvény a fájl olvasása előtt befejeződött (2. probléma). Ebben a példában, ha context.done() hívását túl korán végzik el, hiányoznak a naplóbejegyzések, amelyek Data from file:-tal kezdődnek.

// NOT RECOMMENDED PATTERN
const fs = require("fs");

module.exports = function (context) {
  fs.readFile("./hello.txt", (err, data) => {
    if (err) {
      context.log.error("ERROR", err);
      // BUG #1: This will result in an uncaught exception that crashes the entire process
      throw err;
    }
    context.log(`Data from file: ${data}`);
    // context.done() should be called here
  });
  // BUG #2: Data is not guaranteed to be read before the Azure Function's invocation ends
  context.done();
};

A két probléma elkerüléséhez használja a async és await kulcsszavakat. A Node.js ökoszisztémájának legtöbb API-ja valamilyen formában támogatja az ígéreteket. A 14-es verziótól kezdve például Node.js biztosít egy API-t fs/promises a visszahívási fs API helyére.

Az alábbi példában a függvény végrehajtása során kiváltott nem kezelt kivételek csak a kivételt okozó egyéni meghívást hiúsítják meg. A await kulcsszó azt jelenti, hogy a readFile lépéseket csak annak teljesítése után hajtják végre.

// Recommended pattern
const { app } = require('@azure/functions');
const fs = require('fs/promises');

app.http('httpTriggerGoodAsync', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    handler: async (request, context) => {
        try {
            const fileData = await fs.readFile('./helloWorld.txt');
            return { body: fileData };
        } catch (err) {
            context.error(err);
            // This rethrown exception will only fail the individual invocation, instead of crashing the whole process
            throw err;
        }
    },
});

async és await esetén nem kell meghívnia a context.done() visszahívást sem.

// Recommended pattern
const fs = require("fs/promises");

module.exports = async function (context) {
  let data;
  try {
    data = await fs.readFile("./hello.txt");
  } catch (err) {
    context.log.error("ERROR", err);
    // This rethrown exception will be handled by the Functions Runtime and will only fail the individual invocation
    throw err;
  }
  context.log(`Data from file: ${data}`);
};

Hibaelhárítás

Tekintse meg a Node.js hibaelhárítási útmutatót.

Következő lépések

További információt a következő források tartalmaznak:

  • Last updated on