Azure Functions Node.js fejlesztői hivatkozás

Ez a hivatkozás bemutatja, hogyan lehet JavaScript és TypeScript segítségével fejleszteni Azure Functions-t az @azure/functions npm csomaggal. Az összes nyelven megosztott Azure Functions fogalmainak általános áttekintését lásd az Azure Functions fejlesztői hivatkozásában.

erőforrás	Hivatkozás
Hozd létre az első JavaScript függvényedet	Visual StudioCodeCLI/
Hozd létre az első TypeScript funkciódat	Visual StudioCodeCLI/
Forgatókönyvek és minták	JavaScript/TypeScript
API-referencia	@azure/functions API

Megjegyzés

Ez a cikk egy adott programozási modell verzió tartalmát mutatja be az oldal tetején található választó alapján. A választott verziónak meg kell egyeznie az @azure/functions npm csomagos verziójával. Nem lehet keverni a v3 és v4 funkciókat ugyanabban az alkalmazásban. Ha a csomag nincs benne a package.json-ban, a v3 az alapértelmezett.

Programozási modell

Azure Functions for Node.js két programozási modellváltozatot támogat. Az új projekteknek v4-et kell használnia.

Funkció	v4 (ajánlott)	v3
Status	GA	GA (karbantartás)
@azure/functions Csomag	4.x	3.x
Függvényregisztráció	Kódközpontú (app.http(), app.timer())	Fájlalapú (function.json)
Fájlstruktúra	Hajlékony	Javítva (egy mappa függvényenként)
Functions futtatókörnyezet verziója	4.25+	4.x
Node.js verziók	24.x, 22.x	24.x, 22.x

A Node.js v4 programozási modellben a függvényeket úgy regisztrálod, hogy az app objektumot @azure/functions importálod és trigger-specifikus metódusokat hívsz. A függvények közvetlenül a kódban definiálódnak, rugalmas fájlstruktúrával. Minden függvénynek egyetlen triggerje van, amely elindítja a futtatását, és lehetnek kötések is, amelyek deklaratív kapcsolatok más szolgáltatásokhoz a bemeneti adatok olvasásához vagy kimeneti adatok írásához. További információért lásd: Triggerek és kötések.

A v4 modellben a következőket teheted:

• A függvényeket trigger-specifikus metódusokkal, például a app.http(), app.timer() és app.storageQueue() használatával regisztrálhatja.
• Az eseményindító bemenetét a kezelőfüggvényed első argumentumaként érheted el (például: HttpRequest).
• Közvetlenül a kezelő funkciótól térítsd vissza az elsődleges kimenetet.
• A context.extraInputs.get() használatával további bemeneti kötésekből, például a Blob Storage-ból olvashat.
• A(z) context.extraOutputs.set() használatával további kimeneti kötéseket, például üzenetsorokat írhat.
• Minden függvénynek pontosan egy triggerje van, de több plusz bemenet és kimenet is lehet.
• Globális változókban is gyorsítótározhatod az adatokat, hogy újra felhasználhasd az invocációk között, de ne támaszkodj arra, hogy ez az állapot megmaradjon. A futás bármikor újrahasznosíthatja a munkásodat.

A Node.js v3 programozási modellben minden függvényt egy function.json konfigurációs fájl és a hozzá tartozó JavaScript vagy TypeScript kód segítségével definiálsz. A függvényeket külön mappákban rendezed, speciális fájlstruktúrákkal. Minden függvénynek egyetlen triggerje van, amely elindítja a futtatását, és lehetnek kötések is, amelyek deklaratív kapcsolatok más szolgáltatásokhoz a bemeneti adatok olvasásához vagy kimeneti adatok írásához. További információért lásd: Triggerek és kötések.

A v3 modellben a következőket teheti:

• Határozd meg a triggereket és kötéseket egy function.json fájlban. Használat direction: "in" bemenetekhez és direction: "out" kimenetekhez.
• Az aktiváló bemenetet a kezelőfüggvényed második argumentumaként érheted el, vagy kiolvashatod a(z) context.bindings elemből.
• A kimeneteket úgy állítsuk be, hogy értékeket rendelünk ( context.bindings például context.bindings.outputQueue). HTTP-hez használd context.res.
• A TypeScript projektek megkövetelnek egy scriptFile tulajdonságot a function.json elemben, amely a lefordított JavaScript-fájlra mutat.
• Minden függvénynek pontosan egy triggerje van, de több bemeneti és kimeneti kötést is tartalmazhat.
• Globális változókban is gyorsítótározhatod az adatokat, hogy újra felhasználhasd az invocációk között, de ne támaszkodj arra, hogy ez az állapot megmaradjon. A futás bármikor újrahasznosíthatja a munkásodat.

Examples

Íme egy egyszerű függvény, amely egy HTTP-kérésre válaszol:

JavaScript

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

app.http('httpTrigger', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    handler: async (request, context) => {
        const name = request.query.get('name') || 'World';
        context.log('HTTP trigger function processed a request.');

        return { body: `Hello, ${name}!` };
    }
});

TypeScript

import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';

export async function httpTrigger(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    const name = request.query.get('name') || 'World';
    context.log('HTTP trigger function processed a request.');

    return { body: `Hello, ${name}!` };
}

app.http('httpTrigger', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    handler: httpTrigger
});

A következő nem HTTP példa időzítő triggert használ:

JavaScript

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

app.timer('cleanupTimer', {
  schedule: '0 */5 * * * *',
  handler: async (myTimer, context) => {
    context.log('Timer trigger function ran at', new Date().toISOString());
  }
});

TypeScript

import { app, InvocationContext, Timer } from '@azure/functions';

export async function cleanupTimer(myTimer: Timer, context: InvocationContext): Promise<void> {
  context.log('Timer trigger function ran at', new Date().toISOString());
}

app.timer('cleanupTimer', {
  schedule: '0 */5 * * * *',
  handler: cleanupTimer
});

Az alábbi példa egy HTTP-eseményindítót mutat be üzenetsor-kimeneti kötéssel:

JavaScript

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

const queueOutput = output.storageQueue({
  queueName: 'work-items',
  connection: 'AzureWebJobsStorage'
});

app.http('submitWorkItem', {
  methods: ['POST'],
  extraOutputs: [queueOutput],
  handler: async (request, context) => {
    const body = await request.json();
    context.extraOutputs.set(queueOutput, JSON.stringify(body));
    return { status: 202, jsonBody: { accepted: true } };
  }
});

TypeScript

import { app, HttpRequest, HttpResponseInit, InvocationContext, output } from '@azure/functions';

const queueOutput = output.storageQueue({
  queueName: 'work-items',
  connection: 'AzureWebJobsStorage'
});

export async function submitWorkItem(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
  const body = await request.json();
  context.extraOutputs.set(queueOutput, JSON.stringify(body));
  return { status: 202, jsonBody: { accepted: true } };
}

app.http('submitWorkItem', {
  methods: ['POST'],
  extraOutputs: [queueOutput],
  handler: submitWorkItem
});

Íme egy egyszerű függvény, amely egy HTTP-kérésre válaszol:

JavaScript

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

module.exports = async function (context, req) {
    const name = (req.query.name || (req.body && req.body.name)) || 'World';
    context.log('HTTP trigger function processed a request.');

    context.res = {
        body: `Hello, ${name}!`
    };
};

TypeScript

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": ["get", "post"]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "res"
    }
  ],
  "scriptFile": "../dist/HttpTrigger1/index.js"
}

import { AzureFunction, Context, HttpRequest } from "@azure/functions";

const httpTrigger: AzureFunction = async function (context: Context, req: HttpRequest): Promise<void> {
    const name = (req.query.name || (req.body && req.body.name)) || 'World';
    context.log('HTTP trigger function processed a request.');

    context.res = {
        body: `Hello, ${name}!`
    };
};

export default httpTrigger;

A következő nem HTTP példa időzítő triggert használ:

JavaScript

{
  "bindings": [
    {
      "name": "myTimer",
      "type": "timerTrigger",
      "direction": "in",
      "schedule": "0 */5 * * * *"
    }
  ]
}

module.exports = async function (context, myTimer) {
    context.log('Timer trigger function ran at', new Date().toISOString());
};

TypeScript

{
  "bindings": [
    {
      "name": "myTimer",
      "type": "timerTrigger",
      "direction": "in",
      "schedule": "0 */5 * * * *"
    }
  ],
  "scriptFile": "../dist/TimerTrigger/index.js"
}

import { AzureFunction, Context } from '@azure/functions';

const timerTrigger: AzureFunction = async function (context: Context, myTimer: unknown): Promise<void> {
    context.log('Timer trigger function ran at', new Date().toISOString());
};

export default timerTrigger;

Az alábbi példa egy HTTP-eseményindítót mutat be üzenetsor-kimeneti kötéssel:

JavaScript

{
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": ["post"]
    },
    {
      "type": "queue",
      "direction": "out",
      "name": "workItems",
      "queueName": "work-items",
      "connection": "AzureWebJobsStorage"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "res"
    }
  ]
}

module.exports = async function (context, req) {
    const payload = req.body || {};
    context.bindings.workItems = JSON.stringify(payload);
    context.res = {
        status: 202,
        body: { accepted: true }
    };
};

TypeScript

{
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": ["post"]
    },
    {
      "type": "queue",
      "direction": "out",
      "name": "workItems",
      "queueName": "work-items",
      "connection": "AzureWebJobsStorage"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "res"
    }
  ],
  "scriptFile": "../dist/HttpTrigger/index.js"
}

import { AzureFunction, Context, HttpRequest } from '@azure/functions';

const httpTrigger: AzureFunction = async function (context: Context, req: HttpRequest): Promise<void> {
    const payload = req.body || {};
    context.bindings.workItems = JSON.stringify(payload);
    context.res = {
        status: 202,
        body: { accepted: true }
    };
};

export default httpTrigger;

A függvényalkalmazás létrehozása

Ez a rész a Node funkciós alkalmazás létrehozásához és strukturálásához szükséges alapvető elemeket tartalmazza, beleértve a@azure/functions könyvtárat, a projektstruktúrát és a csomagkezelést.

A @azure/functions könyvtár

A @azure/functions TypeScript/JavaScript könyvtár tartalmazza azokat az alapvető típusokat és funkciókat, amelyeket az Azure Functions runtime-jával való interakcióhoz használsz. Az összes elérhető típus és metódus megtekintéséhez látogasson el az @azure/functions API-ba.

A függvénykód a következőre használható @azure/functions :

• Regisztrálja a függvényeket és definiálja a triggereket (v4 modell).
• Hozzáférés erősen típusozott trigger bemeneti adatokhoz (például , HttpRequestTimer).
• Hozz létre gépelt kimeneti értékeket (például HttpResponseInit).
• Lépj interakcióba a futásidő által biztosított kontextussal és kötési adatokkal.

Ha az alkalmazásodban használod @azure/functions , tedd bele a projektfüggőségeidbe:

{
  "dependencies": {
    "@azure/functions": "^4.0.0"
  }
}

Megjegyzés

A @azure/functions könyvtár határozza meg a Node.js Azure Functions programozási felületét, de nem általános célú SDK. Kifejezetten az Azure Functions-futtatókörnyezeten belüli függvények készítéséhez és futtatásához használható.

TypeScript konfiguráció

A legjobb TypeScript fejlesztési élményhez győződj meg róla tsconfig.json , hogy a megfelelő konfigurációt tartalmazza:

{
  "compilerOptions": {
    "module": "commonjs",
    "target": "es6",
    "outDir": "dist",
    "rootDir": ".",
    "sourceMap": true,
    "strict": false,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  }
}

Mappastruktúra

JavaScript

Egy JavaScript projekthez a következő példában látható mappa szerkezet szükséges:

<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. Általában ez a fájl a .vscode/ elemet tartalmazza a szerkesztő beállításainak figyelmen kívül hagyására, a test/ elemet a tesztesetek figyelmen kívül hagyására, valamint a local.settings.json fájlt, hogy a helyi alkalmazásbeállítások ne legyenek közzétéve.
• 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ása helyi futtatáskor. Ez a fájl nem lesz közzétéve Azure. További információ: local.settings.file.
• package.json: Tartalmaz konfigurációs opciókat, mint például a csomagfüggőségek listája, a fő belépési pont és a szkriptek.

TypeScript

Egy TypeScript projekt a következő mappastruktúrát igényel:

<project_root>/
 | - .vscode/
 | - dist/
 | - node_modules/
 | - myFirstFunction/
 | | - index.ts
 | | - function.json
 | - mySecondFunction/
 | | - index.ts
 | | - function.json
 | - .funcignore
 | - host.json
 | - local.settings.json
 | - package.json
 | - tsconfig.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.
• dist/: A lefordított JavaScript-kódot tartalmazza a build futtatása után. A mappa nevét a "tsconfig.json" fájlban beállíthatod. Egyeznie kell a scriptFile "function.json" fájlokban szereplő tulajdonsággal.
• 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. TypeScript-projektek esetén ennek a fájlnak tartalmaznia kell egy scriptFile , a lefordított JavaScriptre mutató tulajdonságot.
• myFirstFunction/index.ts: 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. Általában ez a fájl a .vscode/ elemet tartalmazza a szerkesztő beállításainak figyelmen kívül hagyására, a test/ elemet a tesztesetek figyelmen kívül hagyására, valamint a local.settings.json fájlt, hogy a helyi alkalmazásbeállítások ne legyenek közzétéve.
• 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ása helyi futtatáskor. Ez a fájl nem lesz közzétéve Azure. További információ: local.settings.file.
• package.json: Tartalmaz konfigurációs opciókat, mint például a csomagfüggőségek listája, a fő belépési pont és a szkriptek.
• tsconfig.json: TypeScript-fordítóbeállításokat tartalmaz, például a kimeneti könyvtárat.

JavaScript

Egy JavaScript projekt a következő példában ajánlott mappászerkezetet követi:

<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. Általában ez a fájl a .vscode/ elemet tartalmazza a szerkesztő beállításainak figyelmen kívül hagyására, a test/ elemet a tesztesetek figyelmen kívül hagyására, valamint a local.settings.json fájlt, hogy a helyi alkalmazásbeállítások ne legyenek közzétéve.
• 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ása helyi futtatáskor. Ez a fájl nem lesz közzétéve Azure. További információ: local.settings.file.
• package.json: Tartalmaz konfigurációs opciókat, mint például a csomagfüggőségek listája, a fő belépési pont és a szkriptek.

TypeScript

Egy TypeScript projekt a következő példában ajánlott mappászerkezetet követi:

<project_root>/
 | - .vscode/
 | - dist/
 | - node_modules/
 | - src/
 | | - functions/
 | | | - myFirstFunction.ts
 | | | - mySecondFunction.ts
 | - test/
 | | - functions/
 | | | - myFirstFunction.test.ts
 | | | - mySecondFunction.test.ts
 | - .funcignore
 | - host.json
 | - local.settings.json
 | - package.json
 | - tsconfig.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.
• dist/: A lefordított JavaScript-kódot tartalmazza a build futtatása után. A mappa nevét a "tsconfig.json" fájlban beállíthatod.
• 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. Általában ez a fájl a .vscode/ elemet tartalmazza a szerkesztő beállításainak figyelmen kívül hagyására, a test/ elemet a tesztesetek figyelmen kívül hagyására, valamint a local.settings.json fájlt, hogy a helyi alkalmazásbeállítások ne legyenek közzétéve.
• 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ása helyi futtatáskor. Ez a fájl nem lesz közzétéve Azure. További információ: local.settings.file.
• package.json: Tartalmaz konfigurációs opciókat, mint például a csomagfüggőségek listája, a fő belépési pont és a szkriptek.
• tsconfig.json: TypeScript-fordítóbeállításokat tartalmaz, például a kimeneti könyvtárat.

Csomagkezelés

A hatékony csomagkezelés kulcsfontosságú a Node.js Azure Functions projektek számára. Ez a rész a függőségkezelést, a csomagkonfigurációt és a függvényalkalmazás függőségeinek fenntartásának legjobb gyakorlatait tartalmazza.

Függőségek kezelése

Minden Node.js Azure Functions projekt npm-et használ csomagkezeléshez. A package.json fájlod határozza meg a projekt konfigurációját, függőségeket és szkripteket, amelyek szükségesek a funkciók építéséhez és futtatásához.

A package.json alapvető felépítése:

{
  "name": "my-functions-app",
  "version": "1.0.0",
  "description": "Azure Functions Node.js app",
  "main": "src/index.js",
  "scripts": {
    "build": "tsc",
    "watch": "tsc -w",
    "prestart": "npm run build",
    "start": "func start",
    "test": "jest"
  },
  "dependencies": {
    "@azure/functions": "^4.0.0"
  },
  "devDependencies": {
    "@azure/functions-core-tools": "^4.0.4670",
    "@types/node": "^18.0.0",
    "typescript": "^4.0.0",
    "jest": "^29.0.0"
  }
}

Futásidejű és fejlesztési függőségek

Megfelelően különítsd el a függőségeiteket:

Futási időbeli függőségek (dependencies):

• @azure/functions: Az Azure Functions központi függvénytára
• Üzleti logikai könyvtárak (lodash, axios és hasonló csomagok)
• Adatbázis-illesztőprogramok (mongodb, mssql és hasonló csomagok)
• Azure SDK csomagok (@azure/storage-blob, @azure/cosmos, és hasonló csomagok)

Fejlesztési függőségek (devDependencies):

• TypeScript fordító és típusdefiníciók
• Tesztelési keretrendszerek (Jest, Mocha)
• Szerszámok és hátók építése
• Azure Functions Core Tools (helyi fejlesztéshez)

TypeScript-specifikus csomagok

TypeScript projektekhez tartalmazzuk ezeket az alapvető fejlesztési függőségeket:

{
  "devDependencies": {
    "@types/node": "^18.0.0",
    "typescript": "^4.0.0",
    "@typescript-eslint/eslint-plugin": "^5.0.0",
    "@typescript-eslint/parser": "^5.0.0"
  }
}

Biztonság és frissítések

Rendszeresen frissítse függőségeit a biztonsági sehetőségek kezelésére:

# Check for outdated packages
npm outdated

# Update packages
npm update

# Audit for security issues
npm audit
npm audit fix

Futtatás és hibakeresés

Ez a rész a helyi fejlesztést, hibakeresési technikákat és Node.js Azure Functions tesztelési stratégiákat fedi le.

Helyi fejlesztés beállítása

Előfeltételek:

• Node.js 18.x vagy 20.x verzió
• Azure Functions Core Tools v4.x
• Azure CLI (nem kötelező)

Beállítási lépések:

1. Függőségek telepítése:

   npm install
   

2. TypeScript-projektek fordítása:

   npm run build
   

3. Indítsd el a helyi futásidőt:

   npm start
   # or directly:
   func start
   

Környezet konfigurációja

Konfigurálja a helyi fejlesztői környezetet a következő módon:local.settings.json

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "FUNCTIONS_WORKER_RUNTIME": "node",
    "NODE_ENV": "development",
    "CUSTOM_ENV_VARIABLE": "local-value"
  },
  "Host": {
    "LocalHttpPort": 7071,
    "CORS": "*",
    "CORSCredentials": false
  }
}

Hibakeresés

Visual Studio Code hibakeresés:

Hozza létre .vscode/launch.json:

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Attach to Node Functions",
      "type": "node",
      "request": "attach",
      "port": 9229,
      "preLaunchTask": "func: host start"
    }
  ]
}

Hozza létre .vscode/tasks.json:

{
  "version": "2.0.0",
  "tasks": [
    {
      "type": "func",
      "label": "func: host start",
      "command": "host start",
      "problemMatcher": "$func-node-watch",
      "isBackground": true,
      "options": {
        "cwd": "${workspaceFolder}"
      }
    }
  ]
}

Parancssori hibakeresés:

# Start with debugging enabled
func start --p <port>

# For TypeScript, ensure you build first
npm run build
func start --p 9229

Deployment

Ez a rész a telepítési stratégiákat, a CI/CD integrációt és a Node.js Azure Functions gyártási legjobb gyakorlatait tartalmazza.

Üzembe helyezési módszerek

1. Visual Studio Code telepítés:

• Telepítsd az Azure Functions bővítményt.
• Jobb kattintással a funkcióalkalmazásra az Azure panelen.
• Válassza ki a Deploy to Function App-ot.

2. Azure Functions Core Tools:

# Deploy to Azure
func azure functionapp publish <FunctionAppName>

# Deploy with custom settings
func azure functionapp publish <FunctionAppName> --build local --publish-local-settings

3. Azure CLI deployment:

# Deploy from local folder
az functionapp deployment source config-zip \
  --resource-group <ResourceGroupName> \
  --name <FunctionAppName> \
  --src <PathToZipFile>

Gyártási konfiguráció

Alkalmazás beállításai az Azure-ban:

Környezeti változók konfigurálása a termeléshez:

• WEBSITE_NODE_DEFAULT_VERSION: Állítsa ~18 vagy ~20értékre.
• FUNCTIONS_WORKER_RUNTIME: Beállítás: node.
• Kapcsolati stringek és API kulcsok biztonságos alkalmazásbeállításokként.
• NODE_ENV: Beállítás: production.

Eseményindítók és kötések

Az Azure Functions eseményindítókkal indítja el a függvények végrehajtását, és kötésekkel csatlakoztatja a kódot más szolgáltatásokhoz, például tárolókhoz, üzenetsorokhoz és adatbázisokhoz. A Node.js programozási modellben a kötéseket a modellverziótól függően másképp hirdeted.

A kötések két fő típusa létezik:

• Eseményindítók (a függvényt elindító bemenet)
• Bemenetek és kimenetek (további adatforrások vagy célhelyek)

Az elérhető triggerekről és kötésekről további információt az Azure Functions eseményindítói és kötései című témakörben talál.

Példa: Időzítő eseményindító blobbemenettel

Ez a funkció 10 percenként aktiválódik, egy Blobból olvas extra bemenetekkel, és naplózza a Blob tartalmát.

JavaScript

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

let CACHED_BLOB_DATA = null;

const blobInput = input.storageBlob({
    connection: 'BLOB_CONNECTION_SETTING',
    path: 'mycontainer/myblob.txt'
});

app.timer('TimerTriggerWithBlob', {
    schedule: '0 */10 * * * *',
    extraInputs: [blobInput],
    handler: async (myTimer, context) => {
        if (CACHED_BLOB_DATA === null) {
            // Read blob content and cache it
            CACHED_BLOB_DATA = context.extraInputs.get(blobInput);
            context.log(`Blob content cached: ${CACHED_BLOB_DATA?.substring(0, 100)}...`);
        }

        context.log(`Timer function executed at: ${new Date().toISOString()}`);
        context.log(`Using cached data of length: ${CACHED_BLOB_DATA?.length || 0}`);
    }
});

TypeScript

import { app, InvocationContext, Timer, input } from '@azure/functions';

let CACHED_BLOB_DATA: string | null = null;

const blobInput = input.storageBlob({
    connection: 'BLOB_CONNECTION_SETTING',
    path: 'mycontainer/myblob.txt'
});

async function timerTriggerWithBlob(myTimer: Timer, context: InvocationContext): Promise<void> {
    if (CACHED_BLOB_DATA === null) {
        // Read blob content and cache it
        CACHED_BLOB_DATA = context.extraInputs.get(blobInput) as string;
        context.log(`Blob content cached: ${CACHED_BLOB_DATA?.substring(0, 100)}...`);
    }

    context.log(`Timer function executed at: ${new Date().toISOString()}`);
    context.log(`Using cached data of length: ${CACHED_BLOB_DATA?.length || 0}`);
}

app.timer('TimerTriggerWithBlob', {
    schedule: '0 */10 * * * *',
    extraInputs: [blobInput],
    handler: timerTriggerWithBlob
});

Ez a függvény 10 percenként aktiválódik, a Blobból a bindings konfigurációval olvas, és naplózza a Blob tartalmát.

JavaScript

{
  "scriptFile": "index.js",
  "bindings": [
    {
      "name": "myTimer",
      "type": "timerTrigger",
      "direction": "in",
      "schedule": "0 */10 * * * *"
    },
    {
      "name": "blobInput",
      "type": "blob",
      "direction": "in",
      "path": "mycontainer/myblob.txt",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

let CACHED_BLOB_DATA = null;

module.exports = async function (context, myTimer) {
    if (CACHED_BLOB_DATA === null) {
        // Read blob content and cache it
        CACHED_BLOB_DATA = context.bindings.blobInput;
        context.log(`Blob content cached: ${CACHED_BLOB_DATA?.substring(0, 100)}...`);
    }

    context.log(`Timer function executed at: ${new Date().toISOString()}`);
    context.log(`Using cached data of length: ${CACHED_BLOB_DATA?.length || 0}`);
};

TypeScript

{
  "scriptFile": "../dist/TimerTriggerWithBlob/index.js",
  "bindings": [
    {
      "name": "myTimer",
      "type": "timerTrigger",
      "direction": "in",
      "schedule": "0 */10 * * * *"
    },
    {
      "name": "blobInput",
      "type": "blob",
      "direction": "in",
      "path": "mycontainer/myblob.txt",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

import { AzureFunction, Context } from "@azure/functions";

let CACHED_BLOB_DATA: string | null = null;

const timerTriggerWithBlob: AzureFunction = async function (context: Context, myTimer: any): Promise<void> {
    if (CACHED_BLOB_DATA === null) {
        // Read blob content and cache it
        CACHED_BLOB_DATA = context.bindings.blobInput;
        context.log(`Blob content cached: ${CACHED_BLOB_DATA?.substring(0, 100)}...`);
    }

    context.log(`Timer function executed at: ${new Date().toISOString()}`);
    context.log(`Using cached data of length: ${CACHED_BLOB_DATA?.length || 0}`);
};

export default timerTriggerWithBlob;

Példa: sorkimenettel rendelkező HTTP-trigger

Ez a függvény HTTP kérésre aktiválódik, üzenetet ír egy tárolósorba, majd HTTP választ ad.

JavaScript

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

const queueOutput = output.storageQueue({
    connection: 'AzureWebJobsStorage',
    queueName: 'myqueue'
});

app.http('httpTriggerWithQueue', {
    methods: ['GET', 'POST'],
    extraOutputs: [queueOutput],
    handler: async (request, context) => {
        const name = request.query.get('name') || 'World';
        const message = {
            id: context.invocationId,
            name: name,
            timestamp: new Date().toISOString()
        };

        // Write to queue output
        context.extraOutputs.set(queueOutput, JSON.stringify(message));
        context.log(`Message sent to queue: ${JSON.stringify(message)}`);

        return {
            body: `Hello, ${name}! Message queued successfully.`
        };
    }
});

TypeScript

import { app, HttpRequest, HttpResponseInit, InvocationContext, output } from '@azure/functions';

const queueOutput = output.storageQueue({
    connection: 'AzureWebJobsStorage',
    queueName: 'myqueue'
});

interface QueueMessage {
    id: string;
    name: string;
    timestamp: string;
}

async function httpTriggerWithQueue(
    request: HttpRequest,
    context: InvocationContext
): Promise<HttpResponseInit> {
    const name = request.query.get('name') || 'World';
    const message: QueueMessage = {
        id: context.invocationId,
        name: name,
        timestamp: new Date().toISOString()
    };

    // Write to queue output
    context.extraOutputs.set(queueOutput, JSON.stringify(message));
    context.log(`Message sent to queue: ${JSON.stringify(message)}`);

    return {
        body: `Hello, ${name}! Message queued successfully.`
    };
}

app.http('httpTriggerWithQueue', {
    methods: ['GET', 'POST'],
    extraOutputs: [queueOutput],
    handler: httpTriggerWithQueue
});

Ez a függvény HTTP kérésre aktiválódik, üzenetet ír egy tárolósorba, majd HTTP választ ad.

JavaScript

{
  "scriptFile": "index.js",
  "bindings": [
    {
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": ["get", "post"]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    },
    {
      "type": "queue",
      "direction": "out",
      "name": "outputQueue",
      "queueName": "myqueue",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

module.exports = async function (context, req) {
    const name = (req.query.name || (req.body && req.body.name)) || 'World';
    const message = {
        id: context.invocationId,
        name: name,
        timestamp: new Date().toISOString()
    };

    // Write to queue output
    context.bindings.outputQueue = JSON.stringify(message);
    context.log(`Message sent to queue: ${JSON.stringify(message)}`);

    return {
        status: 200,
        body: `Hello, ${name}! Message queued successfully.`
    };
};

TypeScript

{
  "scriptFile": "../dist/HttpTriggerWithQueue/index.js",
  "bindings": [
    {
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": ["get", "post"]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    },
    {
      "type": "queue",
      "direction": "out",
      "name": "outputQueue",
      "queueName": "myqueue",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

import { AzureFunction, Context, HttpRequest } from "@azure/functions";

interface QueueMessage {
    id: string;
    name: string;
    timestamp: string;
}

const httpTriggerWithQueue: AzureFunction = async function (
    context: Context,
    req: HttpRequest
): Promise<any> {
    const name = (req.query.name || (req.body && req.body.name)) || 'World';
    const message: QueueMessage = {
        id: context.invocationId,
        name: name,
        timestamp: new Date().toISOString()
    };

    // Write to queue output
    context.bindings.outputQueue = JSON.stringify(message);
    context.log(`Message sent to queue: ${JSON.stringify(message)}`);

    return {
        status: 200,
        body: `Hello, ${name}! Message queued successfully.`
    };
};

export default httpTriggerWithQueue;

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.

JavaScript

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

TypeScript

import {
  app,
  InvocationContext,
  HttpRequest,
  HttpResponseInit,
  output,
  trigger,
} from "@azure/functions";

async function helloWorld1(
  request: HttpRequest,
  context: InvocationContext
): Promise<HttpResponseInit> {
  context.log(`Http function processed request for url "${request.url}"`);

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

app.generic("helloWorld1", {
  trigger: trigger.generic({
    type: "httpTrigger",
    methods: ["GET", "POST"],
  }),
  return: output.generic({
    type: "http",
  }),
  handler: helloWorld1,
});

::: zóna-vég

Meghívási környezet

A függvény minden meghívásakor kap egy context meghívási objektumot. Ezt az objektumot használhatod a bemenetek olvasására, kimenetek beállítására, naplókba írásra és különféle metaadatok elérésére. A v3 modellben mindig a kontextus objektumot adod át első argumentumként a kezelőnek.

Az context objektum a következő tulajdonságokat tartalmazza:

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	Metaadatok az ehhez a meghíváshoz tartozó triggert jelentő bemenetről, 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	Az a függvény neve, amit idézel. 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

Használd az context.bindings objektumot a bemenetek olvasására vagy kimenetek beállítására. A következő példa egy tárolósor-eseményindító, amely a context.bindings használatával egy blobtároló-bemenetet másol egy blobtároló-kimenetre. 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"
}

JavaScript

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

TypeScript

import { AzureFunction, Context } from "@azure/functions";

const queueTrigger1: AzureFunction = async function (
  context: Context,
  myQueueItem: string
): Promise<void> {
  const blobValue = context.bindings.myInput;
  context.bindings.myOutput = blobValue;
};

export default queueTrigger1;

környezet.kész

A context.done metódus elavult. Mielőtt az Azure Functions támogatni kezdte volna az aszinkron függvényeket, a context.done() meghívásával lehetett jelezni, hogy a függvény befejeződött:

JavaScript

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

TypeScript

import { AzureFunction, Context, HttpRequest } from "@azure/functions";

const httpTrigger: AzureFunction = function (
  context: Context,
  request: HttpRequest
): void {
  context.log("this pattern is now deprecated");
  context.done();
};

export default httpTrigger;

Távolítsa el a(z) context.done() hívást. Jelöld meg a függvényedet async-ként, hogy promise-t adjon vissza (még ha nem is await 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.

JavaScript

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

TypeScript

import { AzureFunction, Context, HttpRequest } from "@azure/functions";

const httpTrigger: AzureFunction = async function (
  context: Context,
  request: HttpRequest
): Promise<void> {
  context.log("you don't need context.done or an awaited call");
};

export default httpTrigger;

A függvény minden meghívásakor kap egy context meghívási objektumot. Ez az objektum információkat tartalmaz az invocációdról és a naplózási módszerekről. A v4 modellben általában a context tárgyat adjuk át második argumentumként a kezelőnek.

Az InvocationContext osztály a következő tulajdonságokat tartalmazza:

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 értékeket explicit módon megadták.

Ú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-ban használd context.log() naplók írására. Azure Functions integrálható a Azure-alkalmazás 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 módszert használod, az alkalmazásszintű naplókat nyomon követik, de nem kapcsolódnak semmilyen konkrét funkcióhoz. Használd context naplózáshoz helyett console , hogy minden napló egy adott funkcióhoz legyen kapcsolva.

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

JavaScript

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

TypeScript

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

Naplózási szintek

Az alapértelmezett context.log módszer mellett a következő módszereket használjuk a naplók írásához bizonyos 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

A funkciók lehetővé teszik, hogy meghatározd a naplók követésének és megtekintésének küszöbértéké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 vonatkozó alapértelmezett szint vagy az egyes függvényekhez tartozó küszöbérték beállítását. További információkért tekintse meg az Azure Functions monitorozásának konfigurálását ismertető témakört.

Egyéni adatok nyomon követése

Alapértelmezés szerint Azure Functions a kimenetet nyomkövetésként írja az Application Insightsba. További irányításért használd az Application Insights Node.js SDK-t egyedi naplók, metrikák és függőségek küldésére az Application Insights instance-odba.

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.

A Node.js v4 programozási modellben elosztott követéshez a @azure/functions-opentelemetry-instrumentation csomagot használja az Application Insights SDK helyett. 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.

JavaScript

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

TypeScript

import { AzureFunction, Context, HttpRequest } from "@azure/functions";
import * as appInsights from "applicationinsights";

appInsights.setup();
const client = appInsights.defaultClient;

const httpTrigger: AzureFunction = async function (
  context: Context,
  request: HttpRequest
): Promise<void> {
  // 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,
  });
};

export default httpTrigger;

A tagOverrides paraméter a operation_Id függvény meghívási azonosítójára állítja be a paramétert. Ez a beállítás lehetővé teszi, hogy összefüggtessed az adott függvényhíváshoz tartozó automatikusan generált és egyedi naplót.

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éshez többféleképpen is hozzáférünk:

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

  JavaScript

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

  TypeScript

  const httpTrigger: AzureFunction = async function (context: Context, request: HttpRequest): Promise<void> {
      context.log(`Http function processed request for url "${request.url}"`);
  

---

• A tulajdonságból context.req :

  JavaScript

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

  TypeScript

  const httpTrigger: AzureFunction = async function (context: Context, request: HttpRequest): Promise<void> {
      context.log(`Http function processed request for url "${context.req.url}"`);
  

---

• A nevelt bemeneti kötésekből: Ez az opció ugyanúgy működik, mint bármely nem HTTP kötelék. 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"]
  }
  

  JavaScript

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

  TypeScript

  const httpTrigger: AzureFunction = async function (context: Context, request: HttpRequest): Promise<void> {
      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. Használd inkább a request.getHeader('header-name') elemet, amely nem érzékeny a kis- és nagybetűkre.
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ést a kezelőfüggvényed első argumentumaként érheted el egy HTTP által kiváltott függvény esetén.

JavaScript

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

TypeScript

async function helloWorld1(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    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.

Egy kérés vagy válasz törzsének eléréséhez használja a következő módszereket:

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ókat csak egyszer lehet futtatni. A következő hívásokat üres stringekkel vagy ArrayBufferekkel oldják meg.

HTTP-válasz

Többféleképpen is beállíthatod a választ. Használhatja például a következőt:

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

  JavaScript

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

  TypeScript

  const httpTrigger: AzureFunction = async function (context: Context, request: HttpRequest): Promise<void> {
      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"
  }
  

  JavaScript

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

  TypeScript

  const httpTrigger: AzureFunction = async function (context: Context, request: HttpRequest): Promise<HttpResponseSimple> {
      return { body: `Hello, world!` };
  

---

• Állítsuk be a nevelt kimeneti kötést: Ez az opció ugyanúgy működik, mint bármely nem HTTP kötelék. 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"
  }
  

  JavaScript

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

  TypeScript

  const httpTrigger: AzureFunction = async function (context: Context, request: HttpRequest): Promise<void> {
      context.bindings.response1 = { body: `Hello, world!` };
  

---

• Hívás context.res.send(): Ez a beállítás már elavult. Ez implicit módon hív context.done() , és nem használhatod aszinkron funkcióban.

  JavaScript

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

  TypeScript

  const httpTrigger: AzureFunction = function (context: Context, request: HttpRequest): void {
      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() szintén támogatott, és ugyanazt csinálja.
getHeader()	Lekéri a fejlécmezőt. MEGJEGYZÉS:res.get() szintén támogatott, és ugyanazt 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 ugyanazt 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.

Többféleképpen is beállíthatod a választ. Használhatja például a következőt:

• Egy egyszerű felület a típussal HttpResponseInit: Ez az opció a legtömörebb módja a válaszok visszaküldésének.

  JavaScript

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

  TypeScript

  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.

  JavaScript

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

  TypeScript

  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 szöveg már el van-e olvasva.

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

• Az @azure/functions npm-csomag 4.3.0-s vagy újabb verziója.
• Azure Functions futtatókörnyezet 4.28-es vagy újabb verziója.
• Azure Functions Core Tools verzió 4.0.5530 vagy újabb, amely tartalmazza a megfelelő futási idejű verziót.

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 testméret 104857600, ami körülbelül 100 MB méretre 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.

   JavaScript

   const { app } = require("@azure/functions");
   
   app.setup({ enableHttpStream: true });
   

   TypeScript

   import { app } from "@azure/functions";
   
   app.setup({ enableHttpStream: true });
   

---

Példák streamelése

A következő példa egy HTTP-vel aktivált függvényt mutat, amely HTTP POST kérésen keresztül fogad adatokat. A függvény ezeket az adatokat egy meghatározott kimeneti fájlba továbbítja:

JavaScript

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

TypeScript

import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
import { createWriteStream } from 'fs';
import { Writable } from 'stream';

export async function httpTriggerStreamRequest(
    request: HttpRequest,
    context: InvocationContext
): Promise<HttpResponseInit> {
    const writeStream = createWriteStream('<output file path>');
    await request.body.pipeTo(Writable.toWeb(writeStream));

    return { body: 'Done!' };
}

app.http('httpTriggerStreamRequest', {
    methods: ['POST'],
    authLevel: 'anonymous',
    handler: httpTriggerStreamRequest,
});

Az alábbi példa egy HTTP-alapú aktivált függvényt mutat, amely a fájl tartalmát streamel, válaszként a bejövő HTTP GET kérésekre:

JavaScript

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

TypeScript

import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
import { createReadStream } from 'fs';

export async function httpTriggerStreamResponse(
    request: HttpRequest,
    context: InvocationContext
): Promise<HttpResponseInit> {
    const body = createReadStream('<input file path>');

    return { body };
}

app.http('httpTriggerStreamResponse', {
    methods: ['GET'],
    authLevel: 'anonymous',
    handler: httpTriggerStreamResponse,
});

Ha egy futtatásra kész, streameket használó mintaalkalmazást keres, nézze meg ezt a GitHubon található példát.

Stream szempontok

• Használd request.body , hogy a streamek használatával a lehető legnagyobb hasznot hozzam. Továbbra is használhatod az olyan metódusokat, mint a request.text(), amelyek mindig karakterláncként adják vissza a törzset.

Kampók

A v3-as modell nem támogatja a hookokat. 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. Az, hogy milyen sorrendben regisztrálod a hookokat, meghatározza, hogy milyen sorrendben hajtják végre azokat. Bármelyik fájlból regisztrálhatod a hookokat az alkalmazásodban. A hookoknak két hatóköre van: „app” szintű és „invocation” szintű.

Meghívási hookok

A meghívási horgok a függvényed minden egyes meghívásakor egyszer futnak le. Egy preInvocation horog fut a függvény futtatása előtt, és egy postInvocation horog a függvény után fut. Alapértelmezés szerint a hook minden triggertípusra fut, de típus szerint is szűrhetsz. Az alábbi példa bemutatja, hogyan regisztrálhat egy meghívási horogot, és hogyan szűrhet triggertípus szerint:

JavaScript

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

// Pre-invocation hook with trigger filtering
app.hook.preInvocation('httpPreInvocation', async (context) => {
  context.hookData.startTime = Date.now();
  context.invocationContext.log(`Pre-invocation hook executed for ${context.invocationContext.functionName}`);

  // Add custom headers or modify function handler if needed
  if (context.functionHandler.name === 'httpTrigger') {
    context.invocationContext.log('HTTP function detected, preparing request processing');
  }
}, {
  filter: ['httpTrigger']
});

// Post-invocation hook
app.hook.postInvocation('httpPostInvocation', async (context) => {
  const duration = Date.now() - context.hookData.startTime;
  context.invocationContext.log(`Function ${context.invocationContext.functionName} completed in ${duration}ms`);

  // Log results or errors
  if (context.error) {
    context.invocationContext.log.error(`Function failed: ${context.error.message}`);
  } else {
    context.invocationContext.log(`Function succeeded with result: ${JSON.stringify(context.result)}`);
  }
}, {
  filter: ['httpTrigger']
});

TypeScript

import { app, PreInvocationContext, PostInvocationContext, HttpRequest, HttpResponseInit } from '@azure/functions';

// Pre-invocation hook with trigger filtering
app.hook.preInvocation('httpPreInvocation', async (context: PreInvocationContext) => {
  context.hookData.startTime = Date.now();
  context.invocationContext.log(`Pre-invocation hook executed for ${context.invocationContext.functionName}`);

  // Add custom headers or modify function handler if needed
  if (context.functionHandler.name === 'httpTrigger') {
    context.invocationContext.log('HTTP function detected, preparing request processing');
  }
}, {
  filter: ['httpTrigger']
});

// Post-invocation hook
app.hook.postInvocation('httpPostInvocation', async (context: PostInvocationContext) => {
  const duration = Date.now() - context.hookData.startTime;
  context.invocationContext.log(`Function ${context.invocationContext.functionName} completed in ${duration}ms`);

  // Log results or errors
  if (context.error) {
    context.invocationContext.log.error(`Function failed: ${context.error.message}`);
  } else {
    context.invocationContext.log(`Function succeeded with result: ${JSON.stringify(context.result)}`);
  }
}, {
  filter: ['httpTrigger']
});

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	Az érvek, amiket az invokációhoz adsz át.
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. Használj egyedi tulajdonságnevet, hogy ne ütközzön más hookok adataival.

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

Tulajdonság	Leírás
inputs	Az érvek, amiket az invokációhoz adsz át.
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. Használj egyedi tulajdonságnevet, hogy ne ütközzön más hookok adataival.

Alkalmazáshookok

A futtatókörnyezet alkalmazáspéldányonként egyszer hajtja végre az alkalmazás hookjait. Indításkor appStart horgokat futtat, leállításkor pedig appTerminate horgokat. 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:

JavaScript

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

// Initialize Application Insights for app-level logging
appInsights.setup().start();
const client = appInsights.defaultClient;

// App start hook
app.hook.appStart('appStartup', async (context) => {
  context.hookData.appStartTime = Date.now();
  context.hookData.initializationData = {};

  // Initialize shared resources, database connections, etc.
  client.trackEvent({
    name: 'FunctionAppStarted',
    properties: {
      timestamp: new Date().toISOString(),
      nodeVersion: process.version
    }
  });

  // Set up global configurations
  process.env.APP_INITIALIZED = 'true';
});

// App terminate hook
app.hook.appTerminate('appShutdown', async (context) => {
  const uptime = Date.now() - context.hookData.appStartTime;

  // Cleanup resources, close connections, etc.
  client.trackEvent({
    name: 'FunctionAppTerminated',
    properties: {
      uptime: uptime,
      timestamp: new Date().toISOString()
    }
  });

  // Flush Application Insights data
  await new Promise((resolve) => client.flush({ callback: resolve }));
});

TypeScript

import { app, AppStartContext, AppTerminateContext } from '@azure/functions';
import * as appInsights from 'applicationinsights';

// Initialize Application Insights for app-level logging
appInsights.setup().start();
const client = appInsights.defaultClient;

interface AppHookData {
  appStartTime: number;
  initializationData: Record<string, any>;
}

// App start hook
app.hook.appStart('appStartup', async (context: AppStartContext) => {
  const hookData = context.hookData as AppHookData;
  hookData.appStartTime = Date.now();
  hookData.initializationData = {};

  // Initialize shared resources, database connections, etc.
  client.trackEvent({
    name: 'FunctionAppStarted',
    properties: {
      timestamp: new Date().toISOString(),
      nodeVersion: process.version
    }
  });

  // Set up global configurations
  process.env.APP_INITIALIZED = 'true';
});

// App terminate hook
app.hook.appTerminate('appShutdown', async (context: AppTerminateContext) => {
  const hookData = context.hookData as AppHookData;
  const uptime = Date.now() - hookData.appStartTime;

  // Cleanup resources, close connections, etc.
  client.trackEvent({
    name: 'FunctionAppTerminated',
    properties: {
      uptime: uptime,
      timestamp: new Date().toISOString()
    }
  });

  // Flush Application Insights data
  await new Promise<void>((resolve) => client.flush({ callback: resolve }));
});

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

Az AppStartContext objektum a következő tulajdonsággal 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. Használj egyedi tulajdonságnevet, hogy ne ütközzön más hookok adataival.

Az AppTerminateContext objektum a következő tulajdonsággal 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. Használj egyedi tulajdonságnevet, hogy ne ütközzön más hookok adataival.

Hook – bevált módszerek

Amikor hookokat használsz az Azure Functions-ban, vegyük figyelembe ezeket a legjobb gyakorlatokat:

Teljesítménnyel kapcsolatos szempontok

• A függvény teljesítményének befolyásolása érdekében tartsd a hook végrehajtási idejét minimális szinten.
• Ahol lehetséges, használj aszinkron műveleteket a blokkolás megelőzésére.
• Vegyük figyelembe a hookok többletterhelését nagy volumenű kérések feldolgozásakor.

Hibakezelés

• Mindig gondoskodj a megfelelő hibakezelésről a hookjaidban.
• Ne hagyd, hogy a kampóhibák funkcióhibákat okozzanak, hacsak nem feltétlenül szükséges.
• Naplózd a hookkal kapcsolatos hibákat megfelelően a hibakereséshez.

Adatmegosztás

• Használd a hookData elemet arra, hogy információt ossz meg a meghívás előtti és utáni hookok között.
• Használj egyedi tulajdonságneveket, hogy elkerüld az ütközéseket más hookokkal.
• Tisztítsd meg a hook adatokat, amikor már nincs rá szükség, hogy megelőzze a memória szivárgását.

Szűrés

• Használj trigger típus szűrést, hogy a hookok csak releváns funkciókhoz futjanak.
• Légy konkrét a szűrőkkel a teljesítmény optimalizálása érdekében.

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. Az Azure Functions beépített (a felhasználó által nem konfigurálható) küszöbértékeket használ a különböző eseményindító-típusokhoz annak eldöntésére, hogy mikor kell példányokat hozzáadni, például a QueueTrigger esetében az üzenetek kora és az üzenetsor mérete alapján. 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 minden olyan gazdagépre vonatkozik, amelyet az Azure Functions az Ön alkalmazásának igény szerinti skálázása során 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álod, egy csomagfájlból futva ellensúlyozhatja 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.

Windows

Amikor Windows-on fut, állítsd be a Node.js verziót az WEBSITE_NODE_DEFAULT_VERSION alkalmazás beállításával. Ezt a beállítást frissítse az Azure CLI használatával vagy az Azure portálon.

Linux

Amikor a funkcióalkalmazás Linuxon fut, a linuxFxVersion oldalbeállítás határozza meg a Node.js verziót. Ezt a beállítást frissítheted Azure CLI használatával.

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.

Azure parancssori felület

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>

Ez a parancs az WEBSITE_NODE_DEFAULT_VERSION alkalmazás beállítását a támogatott LTS verzióra ~22állítja be.

Azure portál

A Node.js verziójának módosításához kövesse az alábbi lépéseket:

1. A Azure portálon keresse meg a függvényalkalmazást, és válassza a Settings>Configuration lehetőséget a bal oldalon.

2. Válassza a Függvény futtatókörnyezet beállításai lapot, és ellenőrizze, hogy a függvényalkalmazás a Functions-futtatókörnyezet legújabb verzióján fut-e.

3. Válassza az Általános beállítások lapot, és frissítse a Node.js verziót a legújabb verzióra. Ideális esetben már helyileg ellenőrizte, hogy a függvények a kiválasztott verzión futnak-e.

4. Amikor értesítést kap az újraindításról, válassza a Folytatás, majd a Mentés lehetőséget.

Azure parancssori felület

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

az functionapp config set --linux-fx-version "node|22" --name "<FUNCTION_APP_NAME>" \
 --resource-group "<RESOURCE_GROUP_NAME>"

Ez a parancs a Linux funkcióalkalmazás alapképét Node.js 22-es verzióra állítja.

Azure portál

Megjegyzés

Nem tudod megváltoztatni a Node.js verziót a Azure portálban, amikor a funkciós alkalmazásod Linuxon fut fogyasztási tervben. Ehelyett használd az Azure CLI-t.

Prémium és dedikált csomagok esetén az alábbi lépésekkel módosíthatja a Node.js verziót:

1. A Azure portálon keresse meg a függvényalkalmazást, és válassza a Settings>Configuration lehetőséget a bal oldalon.

2. Válassza a Függvény futtatókörnyezet beállításai lapot, és ellenőrizze, hogy a függvényalkalmazás a Functions-futtatókörnyezet legújabb verzióján fut-e.

3. Válassza az Általános beállítások lapot, és frissítse a Node.js verziót a legújabb verzióra. Ideális esetben már helyileg ellenőrizte, hogy a függvények a kiválasztott verzión futnak-e.

4. Amikor értesítést kap az újraindításról, válassza a Folytatás, majd a Mentés lehetőséget.

Miután változtattál, a funkciós alkalmazá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

Használj környezeti változókat az üzemeltetési titkok, például a kapcsolati láncok, kulcsok és végpontok kezelésére. Használd őket környezeti beállításokhoz is, például változók profilozásához. Hozzáadj környezeti változókat mind a lokális, mind a felhő környezetedben, és a funkciókódodon process.env keresztül érj el őket.

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

JavaScript

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

TypeScript

const httpTrigger: AzureFunction = async function (
  context: Context,
  request: HttpRequest
): Promise<void> {
  context.log(`WEBSITE_SITE_NAME: ${process.env["WEBSITE_SITE_NAME"]}`);
};

JavaScript

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

TypeScript

async function timerTrigger1(
  myTimer: Timer,
  context: InvocationContext
): Promise<void> {
  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:

• Az Azure portálon
• Az Azure CLI használatával
• Az Azure PowerShell használatával

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

Node.js több függvénykörnyezeti változóval rendelkezik, amelyek specifikusak rá:

languageWorkers__node__arguments

Ezt a beállítást használd egyedi érvek megadásához, amikor elkezded a Node.js folyamatot. Leggyakrabban helyben használod a munkásgép elindításához hibakeresés módban, de Azure-ban is használhatod, ha egyedi argumentumokra van szükséged.

Figyelmeztetés

Ha lehetséges, kerüld az Azure-ban való használatotlanguageWorkers__node__arguments, mert az negatívan befolyásolhatja a hidegindítási időket. Az előmelegített feldolgozók használata helyett a futtatókörnyezetnek az Ön egyéni argumentumait használva a semmiből kell elindítania egy új feldolgozót.

Naplózás logLevelWorker

Ezt a beállítást használd az alapértelmezett napló szintjének állítására Node.js-specifikus munkavállalói naplókhoz. 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

Az ECMAScript-modulok jelenleg előzetes verziójú funkciónak számítanak az Azure Functions Node.js 14-es vagy újabb verzióiban.

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 fut Node.js 14 vagy magasabb szinten, választhatod, hogy az ES modulok szintaxisával írod meg a függvényeidet.

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.

JavaScript

import { v4 as uuidv4 } from "uuid";

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

export default httpTrigger;

TypeScript

import { AzureFunction, Context } from "@azure/functions";
import { v4 as uuidv4 } from "uuid";

const httpTrigger: AzureFunction = async function (
  context: Context,
  request: HttpRequest
): Promise<void> {
  context.res.body = uuidv4();
};

export default httpTrigger;

JavaScript

import { v4 as uuidv4 } from "uuid";

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

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

TypeScript

import {
  app,
  HttpRequest,
  HttpResponseInit,
  InvocationContext,
} from "@azure/functions";
import { v4 as uuidv4 } from "uuid";

async function httpTrigger1(
  request: HttpRequest,
  context: InvocationContext
): Promise<HttpResponseInit> {
  return { body: uuidv4() };
}

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

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

Használd a function.json tulajdonságokat scriptFile és entryPoint a exportált függvény helyét és nevét. Amikor a TypeScriptet használod, szükséged van a scriptFile tulajdonságra, és annak a fordított JavaScriptre kell mutatnia.

Az scriptFile használata

Alapértelmezés szerint egy JavaScript függvény fut a index.js. Ez a fájl ugyanazt a szülőkönyvtárat használja, mint a megfelelő function.json fájl.

Használd scriptFile a mappád szerkezetének rendszerezésére. Az alábbi példa egy módját mutatja be a mappák beállításának:

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

A(z) function.json-hez tartozó myFirstFunction fájlnak tartalmaznia kell egy scriptFile tulajdonságot, amely arra a fájlra mutat, amely a futtatandó exportált függvényt tartalmazza.

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

Az entryPoint használata

A v3 modellben exportálnod kell egy függvényt a(z) module.exports használatával, hogy a függvény megtalálható és futtatható legyen. Alapértelmezés szerint az aktiváláskor futó függvény a fájl egyetlen exportja. Ez lehet a run nevű export vagy a index nevű export is. Az alábbi példa beállítja a entryPoint -t a function.json alatti «logHello» egyéni értékre.

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

JavaScript

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

module.exports = { logHello };

TypeScript

import { AzureFunction, Context } from "@azure/functions";

const logHello: AzureFunction = async function (
  context: Context
): Promise<void> {
  context.log("Hello, world!");
};

export default { logHello };

Ajánlások

Ez a rész több hatásos mintát ír le Node.js alkalmazások esetében, amelyeket követned kell.

Válasszon egyvCPU App Service-csomagokat

Amikor létrehozol egy funkcióalkalmazást, amely az App Service tervet használja, válassz egy egy-CPU-s tervet a több vCPU-val rendelkező csomag helyett. Ma a Functions hatékonyabban futtatja Node.js funkciókat egy-vCPU-s VM-eken, és a nagyobb VM-ek használata nem hozza a várt teljesítményjavulást is. Szükség esetén horizontálisan skálázhatsz további egy vCPU-s VM-példányok hozzáadásával, vagy bekapcsolhatod 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-t fejleszt a szerver nélküli üzemeltetési modellben, a hidegindítások valós jelenségek. 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 telepítési módszer alapértelmezés szerint ezt a működési modellt használja, de ha jelentős hidegindítási késleltetést tapasztalsz, ellenőrizd, hogy valóban ebben a módban futsz-e.

Használja async és await

Amikor Azure Functions ír Node.js-ben, írj kódot az async és await kulcsszavakkal. Ha a kódot async és await használatával írod visszahívások vagy .then és .catch helyett a Promise-okkal, az 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 úgy térünk vissza, hogy nem biztosítjuk a visszahívási függvény befejeződését, a HTTP-válasz törzse néha üres lesz (2. hiba).

JavaScript

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

TypeScript

// DO NOT USE THIS CODE
import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
import * as fs from 'fs';

export async function httpTriggerBadAsync(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    let fileData: Buffer;
    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 };
}

app.http('httpTriggerBadAsync', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    handler: httpTriggerBadAsync,
});

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. Egy olyan kivétel, amely nincs kifejezetten a megfelelő hatókörben, összeomlhatja az egész folyamatot (probléma #1). Az elavult context.done() metódusnak a callback hatókörén kívüli meghívása azt jelezheti, hogy a függvény befejeződött, mielőtt a fájlt beolvasnák (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.

JavaScript

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

TypeScript

// NOT RECOMMENDED PATTERN
import { AzureFunction, Context } from "@azure/functions";
import * as fs from "fs";

const trigger1: AzureFunction = function (context: Context): void {
  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();
};

export default trigger1;

Használd a async és await kulcsszavakat, hogy elkerüld mindkét problémát. A Node.js ökoszisztémában a legtöbb API most már valamilyen formában támogatja az ígéreteket. Például a 14-es verziótól kezdve a Node.js egy fs/promises API-t kínál a fs visszahívási API helyettesítésé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.

JavaScript

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

TypeScript

// Recommended pattern
import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
import * as fs from 'fs/promises';

export async function httpTriggerGoodAsync(
    request: HttpRequest,
    context: InvocationContext
): Promise<HttpResponseInit> {
    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;
    }
}

app.http('httpTriggerGoodAsync', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    handler: httpTriggerGoodAsync,
});

A(z) async és await használatakor nem kell meghívnod a(z) context.done() callbacket.

JavaScript

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

TypeScript

// Recommended pattern
import { AzureFunction, Context } from "@azure/functions";
import * as fs from "fs/promises";

const trigger1: AzureFunction = async function (
  context: Context
): Promise<void> {
  let data: Buffer;
  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}`);
};

export default trigger1;

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:

• Legjobb gyakorlatok az Azure Functions esetében
• Azure Functions fejlesztői referencia
• Azure Functions eseményindítók és kötések