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

Az Azure Functions Node.js fejlesztői útmutatója

  • Cikk

Ez az útmutató az Azure Functions JavaScript vagy TypeScript használatával történő fejlesztésének bemutatása. A cikk feltételezi, hogy már elolvasta az Azure Functions fejlesztői útmutatójá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 érték a 3. 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 Oktatócsomag

Megfontolások

  • A Node.js programozási modellt nem szabad összekeverni az 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ő.
    • Futtatókörnyezet: Meghatározza az 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 futtatókörnyezettől függetlenül verziószámozott. 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 az Azure Functions futtatókörnyezet és Node.js támogatott verzióit mutatja be.

Programozási modell verziója Támogatási szint Functions Runtime-verzió Node.js verzió Leírás
4.x FE 4.25+ 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 FE 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 az Azure-ban. 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 megjelenik az Azure-ban. 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 az Azure-ban. 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 az Azure-ban. 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 megjelenik az Azure-ban. 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 az Azure-ban. 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 in tulajdonságot function.json kell használnia, hogy a lefordított JavaScript-fájlra mutasson. 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ény első argumentumként meghívást ad átcontext, a bemeneteket pedig a többi argumentumként.

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 mezőt egy gömbmintával egyetlen fájlra vagy több fájlra állíthatja main be. 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 Függvények regisztrálása egyetlen gyökérfájlból.
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ások megkezdése után nem lehet függvényeket regisztrálni.

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.

Bevitelek

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 a szervezet érdekében ajánlott.

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

  • A következő tulajdonság tulajdonságaiként context.bindingshasználja a következőben function.jsondefiniált tulajdonságnak megfelelő name 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 $return tulajdonságát az alábbi példához function.json hasonlóan kell módosítanianame:

    {
    "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, 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 be van állítvabinarydataType, a típus Node.js Buffervá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 4. verziójának megadása előtt ezek a kötések fájlokban function.json lettek konfigurálva.

Trigger bemenete

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) => {
        ...
    }
});

Kimenet visszaadva

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 a modulból exportált objektum segítségével adja meg az options argumentum visszatérési output konfigurációját @azure/functions . A végrehajtás során ezt a kimenetet úgy állíthatja be, hogy visszaadja a kezelőtől.

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 @azure/functions exportált objektumok típusspecifikus output metódusokkal segítik a konfiguráció összeállítását. A végrehajtás során első argumentumként az eredeti konfigurációs objektummal vagy az eredeti konfigurációs objektummal adja át az értékeket context.extraInputs.get context.extraOutputs.set.

Az alábbi példa egy storage-üzenetsor által aktivált függvény, amely egy további tárolóblob-kimenetbe másolt további tárolóblob-bemenettel rendelkezik. Az üzenetsor üzenetének egy fájlnak kell lennie, és a másolandó blobnév helyett egy kötési kifejezés segítségével kell lecserélni{queueTrigger}.

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

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.

Az 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, beleértve magát az értéket is. 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ó: Trace Context.
bindingDefinitions A bemenetek és kimenetek konfigurációja, a megadott módon function.json.
req Lásd: HTTP-kérés.
res Lásd: HTTP-válasz.

context.executionContext

Az 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.executionContext.retryContext

Az 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 határozatlan ideig újrapróbálkozó eszközök értéke -1 .
exception Az újrapróbálkozást okozó kivétel.

context.bindings

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 egy tárolási blob bemenetének másolását használja context.bindings egy tárolóblob kimenetére. 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;
};

context.done

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

Most javasoljuk, hogy távolítsa el a hívást context.done() , és jelölje meg a függvényt aszinkronként, hogy ígéretet adjon vissza (még akkor is, ha nem await tesz semmit). 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ó: Trace Context.
triggerMetadata A meghívás eseményindító bemenetére vonatkozó metaadatok, beleértve magát az értéket is. 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 környezete

Az 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 határozatlan ideig újrapróbálkozó eszközök értéke -1 .
exception Az újrapróbálkozást okozó kivétel.

További információ: retry-policies.

Naplózás

Az Azure Functionsben ajánlott context.log() naplókat írni. Az Azure Functions integrálható a Azure-alkalmazás Insights szolgáltatással a függvényalkalmazás-naplók jobb rögzítése érdekében. Az 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ókért tekintse meg az Azure Functions monitorozását.

Feljegyzé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. Kifejezetten ajánlott naplózáshoz használnicontext, nem console úgy, 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

Az Azure Functions segítségével meghatározhatja a naplók nyomon követéséhez és megtekintéséhez használandó küszöbértéket. 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 monitorozásának konfigurálása.

Egyéni adatok nyomon követése

Az Azure Functions alapértelmezés szerint nyomkövetésként írja a kimenetet az Application Insightsba. További vezérlés érdekében az Application Insights Node.js SDK-val egyéni adatokat küldhet az Application Insights-példánynak.

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-eseményindítók HTTP-üzeneteket és objektumokat használnak HttpRequest HttpResponse . Az osztályok a beolvasási szabvány egy részhalmazát jelölik Node.js csomagjával undici .

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 kötés nevének meg kell egyeznie a következő példában function.json szereplő kulccsal context.bindingsvagy "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}"`);

Az 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érelem URL-címe.
headers Record<string, string> HTTP-kérelemfejlécek. Ez az objektum megkülönbözteti a kis- és nagybetűk megkülönböztetettségét. Ehelyett ajánlott használni request.getHeader('header-name') , ami a kis- és nagybetűket nem érzékelyí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 Ellenkező esetben egy sztring.
rawBody string A törzs mint sztring. A név ellenére ez a tulajdonság nem ad vissza puffert.
bufferBody Buffer A test mint puffer.

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

Az 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érelem URL-címe.
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 törzs már be van-e olva.

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>

Feljegyzés

A törzsfüggvények csak egyszer futtathatók; az ezt követő hívások üres sztringekkel/ArrayBuffer-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 kötés nevét $return a sajátjában function.jsonállítja be, a válasz közvetlenül ahelyett, hogy contextbe van állítva.

    {
  "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 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 az interfészt HttpResponseFull használja, amely a tulajdonságok mellett HttpResponseSimple a következő metódusokat is támogatja:

Metódus Leírás
status() Beállítja az állapotot.
setHeader() Fejlécmező beállítása. 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 elavult. Beállítja a törzset és a hívásokat context.done() , hogy jelezzék, hogy a szinkronizálási függvény befejeződött. MEGJEGYZÉS: res.end() szintén támogatott, és ugyanezt teszi.
sendStatus() Ez a metódus elavult. 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 elavult. 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 ArrayBuffera következők egyikeként: , BlobAsyncIterable<Uint8Array>, , FormData, NodeJS.ArrayBufferViewIterable<Uint8Array>, URLSearchParams, , nullvagy 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 az Azure-ban és a helyi projektekben:

  1. Ha nagy mennyiségű adatot szeretne streamelni, módosítsa a beállítást az FUNCTIONS_REQUEST_BODY_SIZE_LIMIT Azure-ban. 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ármely 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 GitHubon.

Streamelt 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 törzset.

Hookok

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

Egy horog használatával kódot hajthat végre az Azure Functions életciklusának különböző pontjain. A horgok a regisztráció sorrendjében lesznek végrehajtva, é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 horgok

A hívási horgok a függvény meghívása alapján egyszer lesznek végrehajtva, akár egy horog előtt preInvocation , akár egy postInvocation horog után. Alapértelmezés szerint a horog minden eseményindítótípusra végrehajtva van, de típus szerint is szűrhet. 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.

Az 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özjön más horgok adataival.

Az 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özjön más horgok adataival.

Alkalmazáshookok

Az alkalmazáshohogokat az alkalmazás példányonként egyszer hajtja végre, akár egy horog indításakor, akár egy appStart horogban történő appTerminate leállítás során. Az alkalmazásmegállítási horgok végrehajtására korlátozott idő áll rendelkezésre, és nem minden esetben.

Az Azure Functions-futtatókörnyezet jelenleg nem támogatja a környezetek 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ű horgok 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.

Az 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özjön más horgok adataival.

Az 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özjön más horgok adataival.

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

Alapértelmezés szerint az 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. Az 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 kell példányokat hozzáadni, 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. Az 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 minden olyan gazdagépre vonatkozik, amelyet az Azure Functions hoz létre az alkalmazás igény szerinti skálázása során.

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.

Csomópont verziója

A futtatókörnyezet aktuális verzióját bármely függvényből való naplózással process.version láthatja. 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.

Windows rendszeren való futtatáskor a Node.js verziót az WEBSITE_NODE_DEFAULT_VERSION alkalmazásbeállítás állítja be. Ez a beállítás az Azure CLI-vel vagy az Azure Portalon 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 az Azure Functions-futtatókörnyezet legújabb verzióján fut. Ha frissítenie kell a futtatókörnyezet verzióját, olvassa el az Alkalmazások migrálása az Azure Functions 3.x-es verziójáról a 4.x-es verzióra című témakört.

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

az functionapp config appsettings set  --settings WEBSITE_NODE_DEFAULT_VERSION=~20 \
 --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 ~20.

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

Az Azure-ban való futtatáskor a függvényalkalmazás lehetővé teszi az alkalmazásbeállítások, például a szolgáltatás kapcsolati sztring beállítását és használatát, é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:

languageWorkers__node__arguments

Ezzel a beállítással egyéni argumentumokat adhat meg a Node.js folyamat indításakor. A leggyakrabban helyileg használják a feldolgozó hibakeresési módban való elindításához, de az Azure-ban is használható, ha egyéni argumentumokra van szüksége.

Figyelmeztetés

Ha lehetséges, kerülje az Azure használatát languageWorkers__node__arguments , mert negatív hatással lehet a hideg kezdési időkre. Az előre felmelegített feldolgozók használata helyett a futtatókörnyezetnek új feldolgozót kell kezdenie az egyéni argumentumokkal.

logging__logLevel__Worker

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 debug vagy segíthet diagnosztizálni a Node.js feldolgozóval 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ó)

Feljegyzés

Mivel az ECMAScript-modulok jelenleg előzetes verziójú funkciók az Azure Functions 14-Node.js vagy újabb verziójában.

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 az Azure Functionst Node.js 14-es vagy újabb verzióban futtatja, dönthet úgy, hogy ES-modulok szintaxisával írja 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 exportált függvény helyének és nevének konfigurálásához használható tulajdonságok scriptFile entryPoint . 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 aktivált állapotú függvény az egyetlen exportálás az adott fájlból, a névvel ellátott runexportálásból vagy a névvel ellátott indexexportálásból. Az alábbi példa egy egyéni értékre állítja entryPoint be function.json a "logHello" értéket:

{
  "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 a helyi hibakereséshez, amely automatikusan elindítja a Node.js folyamatot hibakeresési módban, és 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á "languageWorkers__node__arguments": "--inspect" a local.settings.json.Values 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.

Egy-vCPU App Service-csomagok kiválasztása

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.

Futtatás csomagfájlból

Amikor az Azure Functionst kiszolgáló nélküli üzemeltetési modellben fejleszti, a hidegindítás valósággá vált. 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ényhívással, mert elérheti a kapcsolat korlátait. Ehelyett hozzon létre egyetlen statikus ügyfelet a globális hatókörben. További információ: Kapcsolatok kezelése az Azure Functionsben.

Használat async és await

Amikor az Azure Functionst Node.js írja, a kód és await a kulcsszavak használatával kell írniaasync. A visszahívások vagy await az ígéretek .catch .then helyett a kód async írása segít elkerülni a két gyakori problémát:

  • A Node.js folyamatot összeomlást okozó, szokatlan kivételek eldobása, ami más függvények végrehajtását is befolyásolhatja.
  • Váratlan viselkedés, például hiányzó naplók context.log, amelyeket a nem megfelelően várt aszinkron hívások okoznak.

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 lesz (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 a túl korai hívás context.done() azt eredményezi, hogy a naplóbejegyzések nem kezdődnek Data from file:.

// 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 kulcsszavakat és await a async 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 következő readFile lépések csak a végrehajtása után lesznek végrehajtva.

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

awaitA async visszahívást és a visszahívást sem kell meghívniacontext.done().

// 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: