Referenční příručka pro vývojáře Azure Functions v Node.js

Tato reference pokrývá, jak vyvíjet Azure Functions pomocí JavaScriptu a TypeScriptu s balíčkem @azure/functions npm. Pro obecný přehled konceptů Azure Functions sdílených napříč všemi jazyky viz referenční stránka Azure Functions pro vývojáře.

Resource Link
Vytvořte si svou první JavaScriptovou funkci Visual Studio Code/CLI
Vytvořte si svou první funkci TypeScript Visual Studio Code/CLI
Scénáře a ukázky JavaScript/Strojopis
Referenční informace k rozhraní API @azure/functions API

Poznámka:

Tento článek ukazuje obsah pro konkrétní verzi programovacího modelu založenou na selektoru v horní části stránky. Verze, kterou si vyberete, by měla odpovídat verzi vašeho @azure/functions NPM balíčku. Nemůžeš kombinovat funkce v3 a v4 ve stejné aplikaci. Pokud balíček nemáte ve svém package.json, výchozí je v3.

Programovací model

Azure Functions for Node.js podporuje dvě verze programovacího modelu. Nové projekty by měly používat v4.

funkce V4 (doporučeno) v3
Status GA GA (údržba)
@azure/functions Balíček 4.x 3.x
Registrace funkce Kódově centrické (app.http(), app.timer()) Založené na souborech (function.json)
Struktura souborů Flexibilní Fixed (jedna složka pro funkci)
Verze běhového prostředí Functions 4.25+ 4.x
verze Node.js 24.x, 22.x 24.x, 22.x

V programovacím modelu Node.js v4 registrujete funkce tak, že importujete objekt app z @azure/functions a voláte metody specifické pro aktivační události. Funkce jsou definovány přímo ve vašem kódu s flexibilní strukturou souborů. Každá funkce má jeden spouštěč , který zahajuje její vykonání, a může mít také vazby, což jsou deklarativní spojení s jinými službami pro čtení vstupních dat nebo zápis výstupních dat. Pro více informací viz Triggery a vazby.

V modelu v4 vy:

  • Zaregistrujte funkce pomocí metod specifických pro spouštěč, jako jsou app.http(), app.timer() a app.storageQueue().
  • Přistupujte k trigger vstupu jako k prvnímu argumentu pro svého handlera (například HttpRequest).
  • Vraťte primární výstup přímo z funkce handleru.
  • Používejte context.extraInputs.get() pro čtení z dalších vstupních vazeb jako Blob Storage.
  • Pomocí context.extraOutputs.set() můžete zapisovat do dalších výstupních vazeb, jako jsou fronty.
  • Každá funkce má přesně jeden spouštěč, ale může mít více dalších vstupů a výstupů.
  • Data můžete ukládat do globální proměnných pro opětovné použití napříč voláními, ale nespoléhejte se na tento stav, aby přetrval. Runtime může vašeho pracovníka kdykoli recyklovat.

V programovacím modelu Node.js v3 definujete každou funkci pomocí function.json konfiguračního souboru a odpovídajícího JavaScriptu nebo TypeScript kódu. Funkce organizujete do samostatných složek s konkrétní strukturou souborů. Každá funkce má jeden spouštěč , který zahajuje její vykonání, a může mít také vazby, což jsou deklarativní spojení s jinými službami pro čtení vstupních dat nebo zápis výstupních dat. Pro více informací viz Triggery a vazby.

V modelu v3 vy:

  • Definujte spouštěče a vazby v souboru function.json . Použití direction: "in" pro vstupy a direction: "out" výstupy.
  • Přistupujte ke spouštěcímu vstupu jako druhému argumentu pro vašeho handlera, nebo ho přečtěte z context.bindings.
  • Nastavte výstupy přiřazením hodnot ( context.bindings například context.bindings.outputQueue). Pro HTTP použijte context.res.
  • Projekty TypeScript vyžadují vlastnost scriptFilefunction.json , která ukazuje na zkompilovaný JavaScript soubor.
  • Každá funkce má přesně jeden spouštěč, ale může mít více vstupních a výstupních vazeb.
  • Data můžete ukládat do globální proměnných pro opětovné použití napříč voláními, ale nespoléhejte se na tento stav, aby přetrval. Runtime může vašeho pracovníka kdykoli recyklovat.

Examples

Tady je jednoduchá funkce, která reaguje na požadavek HTTP:

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

Následující ne-HTTP příklad používá časovač spouštěčů:

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

Následující příklad ukazuje trigger HTTP s výstupní vazbou fronty:

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

Tady je jednoduchá funkce, která reaguje na požadavek HTTP:

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

Následující ne-HTTP příklad používá časovač spouštěčů:

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

Následující příklad ukazuje trigger HTTP s výstupní vazbou na frontu:

{
  "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 }
    };
};

Sestavení aplikace funkcí

Tato sekce pokrývá základní komponenty pro tvorbu a strukturování vaší aplikace Node function, včetně knihovny@azure/functions, struktury projektu a správy balíčků.

Knihovna @azure/functions

Knihovna @azure/functions TypeScript/JavaScript poskytuje základní typy a funkce, které používáte k interakci s runtime Azure Functions. Pokud chcete zobrazit všechny dostupné typy a metody, navštivte @azure/functions rozhraní API.

Kód funkce může použít @azure/functions k:

  • Registrujte funkce a definujte spouštěče (model v4).
  • Přistupujte k silně zapsaným spouštěcím vstupním datům (například HttpRequest, Timer).
  • Vytvořte typované výstupní hodnoty (například HttpResponseInit).
  • Pracujte s kontextem a vazebnými daty poskytovanými za běhu.

Pokud ve vaší aplikaci používáte @azure/functions, zahrňte @azure/functions mezi závislosti projektu:

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

Poznámka:

Knihovna @azure/functions definuje programovací plochu pro Node.js Azure Functions, ale není to univerzální SDK. Použijte ho speciálně pro vytváření a spouštění funkcí v Azure Functions runtime.

Konfigurace TypeScriptu

Pro nejlepší zážitek z vývoje TypeScriptu se ujistěte, že máte tsconfig.json správnou konfiguraci:

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

Struktura složek

JavaScriptový projekt vyžaduje strukturu složek, jak je zobrazena v následujícím příkladu:

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

Hlavní složka projektu, <project_root>, může obsahovat následující soubory:

  • .vscode/: (volitelné) Obsahuje uloženou konfiguraci Visual Studio Code. Další informace najdete v tématu nastavení Visual Studio Code.
  • myFirstFunction/function.json: Obsahuje konfiguraci pro aktivační událost, vstupy a výstupy funkce. Název adresáře určuje název vaší funkce.
  • myFirstFunction/index.js: Ukládá kód funkce. Pokud chcete změnit tuto výchozí cestu k souboru, podívejte se na použití scriptFile.
  • .funcignore: (Volitelné) Deklaruje soubory, které by se neměly publikovat do Azure. Obvykle tento soubor obsahuje .vscode/ pro ignorování nastavení editoru, testování /ignorování testovacích případů a local.settings.json pro zabránění publikování lokálních nastavení aplikace.
  • host.json: Obsahuje možnosti konfigurace, které ovlivňují všechny funkce v instanci aplikace funkcí. Tento soubor se publikuje do Azure. Při místním spuštění nejsou všechny možnosti podporovány. Další informace najdete v tématu host.json.
  • local.settings.json: Používá se k ukládání nastavení aplikací a připojovací řetězec při místním spuštění. Tento soubor se nepublikuje do Azure. Další informace najdete v souboru local.settings.file.
  • package.json: Obsahuje konfigurační možnosti jako seznam závislostí balíčků, hlavní vstupní bod a skripty.

JavaScriptový projekt následuje doporučenou strukturu složek v následujícím příkladu:

<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

Hlavní složka projektu, <project_root>, může obsahovat následující soubory:

  • .vscode/: (volitelné) Obsahuje uloženou konfiguraci Visual Studio Code. Další informace najdete v tématu nastavení Visual Studio Code.
  • src/functions/: Výchozí umístění pro všechny funkce a související triggery a vazby.
  • test/: (Volitelné) Obsahuje testovací případy vaší aplikace funkcí.
  • .funcignore: (Volitelné) Deklaruje soubory, které by se neměly publikovat do Azure. Obvykle tento soubor obsahuje .vscode/ pro ignorování nastavení editoru, testování /ignorování testovacích případů a local.settings.json pro zabránění publikování lokálních nastavení aplikace.
  • host.json: Obsahuje možnosti konfigurace, které ovlivňují všechny funkce v instanci aplikace funkcí. Tento soubor se publikuje do Azure. Při místním spuštění nejsou všechny možnosti podporovány. Další informace najdete v tématu host.json.
  • local.settings.json: Používá se k ukládání nastavení aplikací a připojovací řetězec při místním spuštění. Tento soubor se nepublikuje do Azure. Další informace najdete v souboru local.settings.file.
  • package.json: Obsahuje konfigurační možnosti jako seznam závislostí balíčků, hlavní vstupní bod a skripty.

Správa balíčků

Efektivní správa balíčků je pro Node.js Azure Functions projekty zásadní. Tato sekce se zabývá správou závislostí, konfigurací balíčků a osvědčenými postupy pro udržování závislostí vašich funkčních aplikací.

Správa závislostí

Všechny Node.js Azure Functions projekty používají npm pro správu balíčků. Váš soubor definuje package.json konfiguraci projektu, závislosti a skripty potřebné k vytvoření a spuštění vašich funkcí.

Základní struktura package.json:

{
  "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"
  }
}

Runtime závislosti vs. vývojové závislosti

Správně oddělte své závislosti:

Závislosti v běhu (dependencies):

  • @azure/functions: Základní knihovna Azure Functions
  • Knihovny pro obchodní logiku (lodash, axios a podobné balíčky)
  • Ovladače databází (mongodb, mssql a podobné balíčky)
  • Azure SDK balíčky (@azure/storage-blob, @azure/cosmos, a podobné balíčky)

Rozvojové závislosti (devDependencies):

  • TypeScript kompilátory a definice typů
  • Testovací frameworky (Jest, Mocha)
  • Buildovací nástroje a lintery
  • Azure Functions Core Tools (pro lokální vývoj)

Balíčky specifické pro TypeScript

Pro projekty TypeScriptu zahrňte tyto základní vývojové závislosti:

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

Bezpečnost a aktualizace

Pravidelně aktualizujte své závislosti, abyste řešili bezpečnostní zranitelnosti:

# Check for outdated packages
npm outdated

# Update packages
npm update

# Audit for security issues
npm audit
npm audit fix

Spouštění a ladění

Tato sekce se zabývá místním vývojem, ladicími technikami a testovacími strategiemi pro Node.js Azure Functions.

Nastavení lokálního vývojového prostředí

Požadavky:

Postup nastavení:

  1. Nainstalujte závislosti:

    npm install

  2. Sestavte projekty v TypeScriptu:

    npm run build

  3. Spusť lokální runtime:

    npm start
# or directly:
func start

Konfigurace prostředí

Nakonfigurujte své lokální vývojové prostředí pomocí 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
  }
}

Odstraňování chyb

Ladění ve Visual Studio Code:

Vytvořit .vscode/launch.json:

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

Vytvořit .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}"
      }
    }
  ]
}

Ladění příkazové řádky:

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

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

Nasazení

Tato sekce se zabývá strategiemi nasazení, integrací CI/CD a osvědčenými postupy v produkci pro Node.js Azure Functions.

Metody nasazení

1. Nasazení Visual Studio Code:

  • Nainstalujte rozšíření Azure Functions.
  • Klikněte pravým tlačítkem na svou funkční aplikaci v panelu Azure.
  • Vyberte Nasadit do funkční aplikace.

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>

Produkční konfigurace

Nastavení aplikace v Azure:

Konfigurujte proměnné prostředí pro produkci:

  • WEBSITE_NODE_DEFAULT_VERSION: Nastavit na ~18 nebo ~20.
  • FUNCTIONS_WORKER_RUNTIME: Nastaveno na node.
  • Spojovací řetězce a API klíče jako bezpečná nastavení aplikace.
  • NODE_ENV: Nastaveno na production.

Spouštěče a vazby

Azure Functions používá triggery ke spuštění funkce a vazby pro připojení kódu k dalším službám, jako jsou úložiště, fronty a databáze. V Node.js programovacím modelu deklarujete vazby různě podle verze modelu.

Existují dva hlavní typy vazeb:

  • Spouštěče (vstup, který aktivuje funkci)
  • Vstupy a výstupy (další zdroje dat nebo cíle)

Další informace o dostupných triggerech a vazbách najdete v tématu Triggery a vazby ve službě Azure Functions.

Příklad: Trigger časovače s Blob vstupem

Tato funkce se spouští každých 10 minut, čte z blobu pomocí dodatečných vstupů a zaznamenává obsah blobu.

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

Tato funkce se spouští každých 10 minut, čte z blobu pomocí nastavení bindings a zaznamenává obsah blobu.

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

Příklad: aktivační událost HTTP s výstupem do fronty

Tato funkce spustí HTTP požadavek, zapíše zprávu do fronty úložiště a vrátí HTTP odpověď.

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

Tato funkce se spustí při požadavku HTTP, zapíše zprávu do fronty ve službě Storage a vrátí odpověď HTTP.

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

Objekty app, trigger, input a output exportované modulem @azure/functions poskytují metody specifické pro většinu typů. Pro všechny typy, které nejsou podporovány, je k dispozici metoda, generic která vám umožní ručně zadat konfiguraci. Metodu generic lze použít také v případě, že chcete změnit výchozí nastavení poskytovaná metodou specifickou pro konkrétní typ.

Následující příklad je jednoduchá funkce aktivovaná protokolem HTTP, která místo metod specifických pro typ používá obecné metody.

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

::: konec-zóny

Kontext vyvolání

Každé spuštění vaší funkce obdrží objekt spuštění context. Tento objekt použijte ke čtení vstupů, nastavení výstupů, zápisu do logů a přístupu k různým metadatům. V modelu v3 vždy předáte objekt kontextu jako první argument svému handleru.

Objekt context zahrnuje následující vlastnosti:

Vlastnost Popis
invocationId ID aktuálního volání funkce.
executionContext Viz kontext spuštění.
bindings Viz vazby.
bindingData Metadata o spouštěcím vstupu pro toto volání, s výjimkou samotné hodnoty. Například trigger centra událostí má enqueuedTimeUtc vlastnost.
traceContext Kontext distribuovaného trasování. Další informace najdete na webu Trace Context.
bindingDefinitions Konfigurace vašich vstupů a výstupů, jak je definováno v function.json.
req Viz požadavek HTTP.
res Viz odpověď HTTP.

kontext.výkonovýKontext

Objekt context.executionContext má následující vlastnosti:

Vlastnost Popis
invocationId ID aktuálního volání funkce.
functionName Název funkce, kterou vyvoláváte. Název složky obsahující function.json soubor určuje název funkce.
functionDirectory Složka obsahující function.json soubor.
retryContext Viz kontext opakování.

context.executionContext.retryContext

Objekt context.executionContext.retryContext má následující vlastnosti:

Vlastnost Popis
retryCount Číslo představující aktuální pokus o opakování.
maxRetryCount Maximální počet opakování provádění Hodnota -1 znamená pokus opakovatelný do nekonečna.
exception Výjimka, která způsobila opakování

kontext.přiřazení

Použijte context.bindings objekt ke čtení vstupů nebo nastavení výstupů. Následující příklad je aktivační událost fronty úložiště, která používá context.bindings ke zkopírování vstupního objektu blob úložiště do výstupního objektu blob úložiště. Obsah zprávy fronty nahradí {queueTrigger} jako název souboru, který se má zkopírovat, pomocí výrazu pro sestavení vazby.

{
    "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;
};

kontext.hotovo

Metoda context.done je zastaralá. Než Azure Functions podporoval asynchronní funkce, signalizovali jste, že vaše funkce byla provedena, voláním context.done():

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

Odeberte volání context.done(). Označte svou funkci jako asynchronní, aby vám vrátila slib (i když nic nevrátíte await ). Jakmile se vaše funkce dokončí (jinými slovy, vrácený slib se splní), model v3 ví, že je vaše funkce hotová.

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

Při každém volání vaše funkce obdrží objekt volání context. Tento objekt obsahuje informace o vašem volání a metodách logování. V modelu v4 obvykle context předáte objekt jako druhý argument svému handleru.

Třída InvocationContext obsahuje následující vlastnosti:

Vlastnost Popis
invocationId ID aktuálního volání funkce.
functionName Název funkce.
extraInputs Slouží k získání hodnot dodatečných vstupů. Další informace najdete v dalších vstupech a výstupech.
extraOutputs Slouží k nastavení hodnot extra výstupů. Další informace najdete v dalších vstupech a výstupech.
retryContext Viz kontext opakování.
traceContext Kontext distribuovaného trasování. Další informace najdete na webu Trace Context.
triggerMetadata Metadata o vstupu triggeru pro toto vyvolání, nikoli zahrnutí samotné hodnoty. Například trigger centra událostí má enqueuedTimeUtc vlastnost.
options Možnosti použité při registraci funkce, po jejich ověření a nastavení výchozích nastavení jsou explicitně specifikovány.

Kontext opakování

Objekt retryContext má následující vlastnosti:

Vlastnost Popis
retryCount Číslo představující aktuální pokus o opakování.
maxRetryCount Maximální počet opakování provádění Hodnota -1 znamená pokus opakovatelný do nekonečna.
exception Výjimka, která způsobila opakování

Další informace najdete na webu retry-policies.

Protokolování

V Azure Functions se používá context.log() k zápisu logů. Azure Functions se integruje se službou Aplikace Azure Insights, abyste mohli lépe zaznamenávat protokoly aplikace funkcí. Application Insights, která je součástí Azure Monitor, poskytuje zařízení pro shromažďování, vizuální vykreslování a analýzu protokolů aplikací i výstupů trasování. Další informace najdete v tématu monitorování Azure Functions.

Poznámka:

Pokud použijete alternativní Node.js console.log metodu, logy na úrovni aplikace jsou sledovány, ale nejsou spojeny s žádnou konkrétní funkcí. Použijte context pro logování místo console toho, aby byly všechny logy přiřazeny k určité funkci.

Následující příklad zapíše protokol na výchozí úroveň "information", včetně ID vyvolání:

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

Úrovně protokolování

Kromě výchozí context.log metody použijte následující metody pro zápis logů na specifických úrovních:

metoda Popis
context.log.error() Zapíše do protokolů událost na úrovni chyby.
context.log.warn() Zapíše do protokolů událost na úrovni upozornění.
context.log.info() Zapíše do protokolů událost na úrovni informací.
context.log.verbose() Zapíše do protokolů událost na úrovni trasování.
metoda Popis
context.trace() Zapíše do protokolů událost na úrovni trasování.
context.debug() Zapíše událost úrovně ladění do protokolů.
context.info() Zapíše do protokolů událost na úrovni informací.
context.warn() Zapíše do protokolů událost na úrovni upozornění.
context.error() Zapíše do protokolů událost na úrovni chyby.

Nastavit úroveň protokolu

Funkce umožňuje definovat prahovou hodnotu pro sledování a zobrazení protokolů. K nastavení prahové hodnoty použijte logging.logLevel vlastnost v host.json souboru. Tato vlastnost vám umožňuje definovat výchozí úroveň pro všechny funkce nebo práh pro každou jednotlivou funkci. Další informace najdete v tématu Konfigurace monitorování pro Azure Functions.

Sledování vlastních dat

Standardně Azure Functions zapisuje výstup jako záznamy do Application Insights. Pro větší kontrolu použijte Application Insights Node.js SDK k odesílání vlastních logů, metrik a závislostí do vaší instance Application Insights.

Poznámka:

Metody v sadě Application Insights Node.js SDK se můžou v průběhu času měnit. V příkladech uvedených tady můžou být menší rozdíly v syntaxi. Nejnovější příklady použití rozhraní API najdete v dokumentaci k sadě Application Insights Node.js SDK.

Pro distribuované trasování v programovacím modelu Node.js v4 použijte @azure/functions-opentelemetry-instrumentation balíček místo SDK Application Insights. Tento balíček poskytuje automatickou instrumentaci založenou na OpenTelemetry pro Azure Functions. Další informace najdete v OpenTelemetry Azure Functions Instrumentation for Node.js GitHub repository.

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

Parametr tagOverrides nastaví operation_Id na ID vyvolání funkce. Toto nastavení umožňuje korelovat všechny automaticky generované a vlastní logy pro dané volání funkce.

HTTP spouštěče

Triggery HTTP a webhooku používají objekty požadavků a odpovědí k reprezentaci zpráv HTTP.

Triggery HTTP a webhooku používají HttpRequest a HttpResponse objekty k reprezentaci zpráv HTTP. Třídy představují podmnožinu standardu 'fetch', používající balíček Node.jsundici.

požadavek HTTP

K žádosti se dostanete několika způsoby:

  • Jako druhý argument funkce:

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

  • Z vlastnosti context.req:

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

  • Z pojmenovaných vstupních vazeb: Tato možnost funguje stejně jako jakékoli jiné vazby než HTTP. Název function.json vazby musí odpovídat klíči na context.bindings nebo "request1" v následujícím příkladu:

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

Objekt HttpRequest má následující vlastnosti:

Vlastnost Typ Popis
method string Metoda požadavku HTTP použitá k vyvolání této funkce.
url string Adresa URL požadavku.
headers Record<string, string> Hlavičky požadavku HTTP. U tohoto objektu se rozlišují malá a velká písmena. Použijte místo něj request.getHeader('header-name'), který nerozlišuje velikost písmen.
query Record<string, string> Zadejte dotaz na klíče parametrů řetězce a hodnoty z adresy URL.
params Record<string, string> Klíče a hodnoty parametrů trasy.
user HttpRequestUser \| null Objekt představující přihlášeného uživatele, a to buď prostřednictvím ověřování funkcí, ověřování SWA nebo null, pokud se takový uživatel nepřihlašuje.
body Buffer \| string \| any Pokud je typ média "application/octet-stream" nebo "multipart/*", body je buffer. Pokud je hodnota řetězec podporující parsování JSON, body jedná se o parsovaný objekt. body Jinak je to řetězec.
rawBody string Tělo jako řetězec. Navzdory názvu tato vlastnost nevrací Buffer.
bufferBody Buffer Tělo jako vyrovnávací paměť.

K požadavku můžete přistupovat jako k prvnímu argumentu vašemu handleru pro funkci spuštěnou HTTP.

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

Objekt HttpRequest má následující vlastnosti:

Vlastnost Typ Popis
method string Metoda požadavku HTTP použitá k vyvolání této funkce.
url string Adresa URL požadavku.
headers Headers Hlavičky požadavku HTTP.
query URLSearchParams Zadejte dotaz na klíče parametrů řetězce a hodnoty z adresy URL.
params Record<string, string> Klíče a hodnoty parametrů trasy.
user HttpRequestUser \| null Objekt představující přihlášeného uživatele, a to buď prostřednictvím ověřování funkcí, ověřování SWA nebo null, pokud se takový uživatel nepřihlašuje.
body ReadableStream \| null Tělo jako čitelný datový proud
bodyUsed boolean Logická hodnota označující, jestli je tělo již přečtené.

Pro přístup k tělu požadavku nebo odpovědi použijte následující metody:

metoda Návratový typ
arrayBuffer() Promise<ArrayBuffer>
blob() Promise<Blob>
formData() Promise<FormData>
json() Promise<unknown>
text() Promise<string>

Poznámka:

Tělesné funkce můžete spustit jen jednou. Následující volání vracejí prázdné řetězce nebo objekty ArrayBuffer.

Odpověď protokolu HTTP

Odpověď můžete nastavit několika způsoby. Můžete například použít:

  • context.res Nastavte vlastnost:

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

  • Vraťte odpověď: Pokud je vaše funkce asynchronní a nastavíte název $return vazby ve vaší function.json, můžete odpověď vrátit přímo, místo toho, abyste ji nastavili v context.

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

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

  • Nastavte pojmenované výstupní vázání: Tato možnost funguje stejně jako jakékoli jiné vazby než HTTP. Název function.json vazby musí odpovídat klíči na context.bindingsnebo "response1" v následujícím příkladu:

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

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

  • Volání context.res.send(): Tato možnost je zastaralá. Implicitně volá context.done() a nelze to použít v asynchronní funkci.

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

Pokud při nastavování odpovědi vytvoříte nový objekt, musí tento objekt odpovídat HttpResponseSimple rozhraní, které má následující vlastnosti:

Vlastnost Typ Popis
headers Record<string, string> (volitelné) Hlavičky odpovědi HTTP.
cookies Cookie[] (volitelné) Soubory cookie odpovědi HTTP.
body any (volitelné) Text odpovědi HTTP.
statusCode number (volitelné) Stavový kód odpovědi HTTP. Pokud není nastavená, výchozí hodnota 200je .
status number (volitelné) Totéž jako statusCode. Tato vlastnost je ignorována, pokud statusCode je nastavena.

Objekt context.res můžete také upravit bez přepsání. Výchozí context.res objekt používá HttpResponseFull rozhraní, které podporuje následující metody kromě HttpResponseSimple vlastností:

metoda Popis
status() Nastaví stav.
setHeader() Nastaví pole záhlaví. POZNÁMKA:res.set() a res.header() také jsou podporováni a dělají totéž.
getHeader() Získá pole na záhlaví. POZNÁMKA:res.get() je také podporován a dělá totéž.
removeHeader() Odebere záhlaví.
type() Nastaví hlavičku content-type.
send() Tato metoda je zastaralá. Nastaví tělo a zavolá context.done() k označení dokončení synchronizační funkce. POZNÁMKA:res.end() je také podporován a dělá totéž.
sendStatus() Tato metoda je zastaralá. Nastaví stavový kód a volání context.done() , která označují dokončení synchronizační funkce.
json() Tato metoda je zastaralá. Nastaví "content-type" na "application/json", nastaví obsah a volá context.done(), čímž označí, že synchronizační funkce je dokončena.

Odpověď můžete nastavit několika způsoby. Můžete například použít:

  • Jednoduché rozhraní s typem HttpResponseInit: Tato možnost je nejstručnějším způsobem, jak vracet odpovědi.

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

Rozhraní HttpResponseInit má následující vlastnosti:

Vlastnost Typ Popis
body BodyInit (volitelné) Text odpovědi HTTP jako jeden z ArrayBuffer, AsyncIterable<Uint8Array>, BlobFormDataIterable<Uint8Array>NodeJS.ArrayBufferViewURLSearchParams, null, nebo .string
jsonBody any (volitelné) Text odpovědi HTTP, který lze serializovat do formátu JSON. Pokud je nastavena, HttpResponseInit.body vlastnost je ignorována ve prospěch této vlastnosti.
status number (volitelné) Stavový kód odpovědi HTTP. Pokud není nastavená, výchozí hodnota 200je .
headers HeadersInit (volitelné) Hlavičky odpovědi HTTP.
cookies Cookie[] (volitelné) Soubory cookie odpovědi HTTP.

  • Jako třída s typem HttpResponse: Tato možnost poskytuje pomocné metody pro čtení a úpravy různých částí odpovědi, jako jsou hlavičky.

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

Třída HttpResponse přijímá volitelný HttpResponseInit argument jako argument jeho konstruktoru a má následující vlastnosti:

Vlastnost Typ Popis
status number Stavový kód odpovědi HTTP.
headers Headers Hlavičky odpovědi HTTP.
cookies Cookie[] Soubory cookie odpovědi HTTP.
body ReadableStream | null Tělo jako čitelný datový proud
bodyUsed boolean Logická hodnota označující, jestli je tělo již přečtené.

Streamy HTTP

Streamy HTTP jsou funkce, která usnadňuje zpracování velkých dat, streamování odpovědí OpenAI, doručování dynamického obsahu a podporu dalších základních scénářů HTTP. Umožňuje streamovat požadavky a odpovědi z koncových bodů HTTP v rámci vaší funkční aplikace Node.js. Streamy HTTP používejte ve scénářích, kdy vaše aplikace vyžaduje výměnu v reálném čase a interakci mezi klientem a serverem přes PROTOKOL HTTP. Streamy HTTP můžete použít také k zajištění nejlepšího výkonu a spolehlivosti vašich aplikací při používání protokolu HTTP.

Důležité

Streamy HTTP nejsou v modelu v3 podporované. Upgradujte na model verze 4 a použijte funkci streamování HTTP. Existující HttpRequest a HttpResponse typy v programovacím modelu v4 již podporují různé způsoby zpracování textu zprávy, včetně datového proudu.

Požadavky

Povolení datových proudů

Pomocí těchto kroků povolíte streamy HTTP v aplikaci funkcí v Azure a v místních projektech:

  1. Pokud plánujete streamovat velké objemy dat, upravte nastavení FUNCTIONS_REQUEST_BODY_SIZE_LIMIT v Azure. Výchozí maximální povolená velikost těla je 104857600, což omezuje vaše požadavky na přibližně 100 MB.

  2. Pro místní vývoj přidejte FUNCTIONS_REQUEST_BODY_SIZE_LIMIT také do souboru local.settings.json.

  3. Do libovolného souboru, který je součástí hlavního pole, přidejte do aplikace následující kód.

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

app.setup({ enableHttpStream: true });

Příklady streamů

Následující příklad ukazuje funkci spuštěnou HTTP, která přijímá data prostřednictvím HTTP POST požadavku. Funkce tato data streamuje do specifikovaného výstupního souboru:

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

Následující příklad ukazuje funkci spuštěnou HTTP, která streamuje obsah souboru jako odpověď na příchozí HTTP GET požadavky:

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

Pro připravenou ukázkovou aplikaci využívající streamy se podívejte na tento příklad na GitHub.

Aspekty datových proudů

  • Použijte to request.body , abyste z používání streamů získali největší užitek. Stále můžete použít metody, jako je request.text(), které vždy vrátí tělo jako řetězec.

Háčky

Model v3 háky nepodporuje. Upgradujte na model v4, abyste mohli používat háky.

Pomocí háku můžete spustit kód v různých bodech životního cyklu Azure Functions. Pořadí, v jakém háky registrujete, určuje pořadí, v jakém jsou prováděny. Háčky můžete registrovat z jakéhokoliv souboru ve své aplikaci. Existují dva typy háčků: úroveň "aplikace" a úroveň "invokace".

Zavolací háky

Invocation hooky běží jednou za každé vyvolání vaší funkce. Háček běží preInvocation před spuštěním funkce a hák postInvocation běží po jejím spuštění. Ve výchozím nastavení se háček vykonává pro všechny typy spouštěčů, ale můžete také filtrovat podle typu. Následující příklad ukazuje, jak zaregistrovat invokaci hooku a filtrovat podle typu spouštěče.

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

Prvním argumentem obslužné rutiny háku je kontextový objekt specifický pro daný typ háku.

Objekt PreInvocationContext má následující vlastnosti:

Vlastnost Popis
inputs Argumenty, které předáváte při vyvolání.
functionHandler Obslužná rutina pro vyvolání funkce. Změny této hodnoty ovlivňují samotnou funkci.
invocationContext Objekt vyvolání kontextu předaný funkci.
hookData Doporučené místo pro ukládání a sdílení dat mezi hooky ve stejném rozsahu. Použijte unikátní název vlastnosti, aby nekolidoval s daty ostatních háčků.

Objekt PostInvocationContext má následující vlastnosti:

Vlastnost Popis
inputs Argumenty, které předáváte při volání.
result Výsledek funkce. Změny této hodnoty ovlivňují celkový výsledek funkce.
error Chyba vyvolaná funkcí, nebo null/undefined, pokud neexistuje žádná chyba. Změny této hodnoty ovlivňují celkový výsledek funkce.
invocationContext Objekt vyvolání kontextu předaný funkci.
hookData Doporučené místo pro ukládání a sdílení dat mezi hooky ve stejném rozsahu. Použijte unikátní název vlastnosti, aby nekolidoval s daty ostatních háčků.

Háky aplikací

Runtime vykonává app hooky jednou za každou instanci vaší aplikace. Při spuštění spouští appStart hooky a při ukončení appTerminate hooky. Hooky pro ukončení aplikace mají omezený čas na spuštění a nespustí se u všech scénářů.

Modul runtime Azure Functions aktuálně nepodporuje protokolování kontextu mimo vyvolání. Pomocí balíčku npm Application Insights můžete logovat data během aplikačních hooků.

Následující příklad zaregistruje háky aplikací:

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

Prvním argumentem obslužné rutiny háku je kontextový objekt specifický pro daný typ háku.

Objekt AppStartContext má následující vlastnost:

Vlastnost Popis
hookData Doporučené místo pro ukládání a sdílení dat mezi hooky ve stejném rozsahu. Použijte unikátní název vlastnosti, aby nekolidoval s daty ostatních háčků.

Objekt AppTerminateContext má následující vlastnost:

Vlastnost Popis
hookData Doporučené místo pro ukládání a sdílení dat mezi hooky ve stejném rozsahu. Použijte unikátní název vlastnosti, aby nekolidoval s daty ostatních háčků.

Osvědčené postupy pro háčky

Při používání háčků ve vašich Azure Functions zvažte tyto osvědčené postupy:

Důležité informace o výkonu

  • Udržujte dobu provádění hooku na minimum, abyste neovlivnili výkon funkce.
  • Používejte asynchronní operace, kde je to možné, abyste zabránili blokování.
  • Zvažte režijní náklady na háky při zpracování požadavků s velkým objemem.

Zpracování chyb

  • Vždy zahrňte správné zacházení s chybami ve svých hácích.
  • Nenechte selhání háku způsobit poruchy funkce, pokud to není naprosto nutné.
  • Chyby hooků zaznamenávejte vhodným způsobem pro účely ladění.

Sdílení dat

  • Použijte hookData pro sdílení informací mezi háčky před a po vyvolání.
  • Používejte unikátní názvy nemovitostí, abyste se vyhnuli konfliktům s jinými háčky.
  • Vyčistěte data hooku, jakmile už nejsou potřeba, aby se zabránilo únikům paměti.

Filtering

  • Použijte filtrování typů spouštěčů, abyste zajistili, že háčky běží jen pro relevantní funkce.
  • Buďte konkrétní ve svých filtrech, abyste optimalizovali výkon.

Škálování a souběžnost

Ve výchozím nastavení Azure Functions automaticky monitoruje zatížení vaší aplikace a podle potřeby vytvoří více instancí hostitele pro Node.js. Azure Functions používá vestavěné (nejsou uživatelsky konfigurovatelné) prahové hodnoty pro různé typy spouštěčů k rozhodnutí o tom, kdy přidat další instance, například podle stáří zpráv a velikosti fronty u QueueTrigger. Další informace najdete v tématu Jak fungují plány Consumption a Premium.

Toto chování škálování je dostatečné pro mnoho Node.js aplikací. U aplikací vázaných na procesor můžete výkon dále zlepšit pomocí více jazykových pracovních procesů. Pomocí nastavení aplikace FUNCTIONS_WORKER_PROCESS_COUNT můžete zvýšit počet pracovních procesů na hostitele z výchozí hodnoty 1 až na 10. Azure Functions se pak pokusí rovnoměrně distribuovat souběžné vyvolání funkcí napříč těmito pracovními procesy. Díky tomuto chování je méně pravděpodobné, že funkce náročná na procesor blokuje spuštění dalších funkcí. Toto nastavení platí pro každého hostitele, kterého Azure Functions vytvoří při škálování vaší aplikace tak, aby splňovala poptávku.

Varování

FUNCTIONS_WORKER_PROCESS_COUNT Nastavení používejte s opatrností. Několik procesů spuštěných ve stejné instanci může způsobit nepředvídatelné chování a zvýšit dobu načítání funkcí. Pokud použijete toto nastavení, spouštění z balíčku může tyto nevýhody zmírnit.

Verze Node.js

Aktuální verzi, kterou modul runtime používá, můžete zobrazit pomocí protokolování process.version z libovolné funkce. Seznam supported versions verzí Node.js podporovaných každým programovacím modelem

Nastavení verze uzlu

Způsob upgradu Node.js verze závisí na operačním systému, na kterém běží vaše aplikace funkcí.

Když běží na Windows, nastavte Node.js verzi pomocí WEBSITE_NODE_DEFAULT_VERSION nastavení aplikace. Toto nastavení aktualizujte buď pomocí Azure CLI, nebo v portálu Azure.

Další informace o verzích Node.js naleznete v tématu Podporované verze.

Před upgradem Node.js verze se ujistěte, že je vaše aplikace funkcí spuštěná na nejnovější verzi modulu runtime Azure Functions. Pokud potřebujete upgradovat verzi modulu runtime, přečtěte si téma Migrace aplikací z Azure Functions verze 3.x na verzi 4.x.

Spuštěním příkazu Azure CLI az functionapp config appsettings set aktualizujte verzi Node.js aplikace funkcí spuštěnou na Windows:

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

Tento příkaz nastaví WEBSITE_NODE_DEFAULT_VERSION nastavení aplikace na podporovanou verzi ~22LTS .

Po provedení změn se funkční aplikace restartuje. Další informace o podpoře služby Functions pro Node.js najdete v dokumentu Politika podpory runtime jazyka.

Proměnné prostředí

Používejte proměnné prostředí ke správě provozních tajemství, jako jsou řetězce spojení, klíče a koncové body. Používejte je také pro nastavení prostředí, například pro profilování proměnných. Přidejte proměnné prostředí jak v lokálním, tak cloudovém prostředí a přistupujte k nim ve process.env svém funkčním kódu.

Následující příklad zaznamená proměnnou WEBSITE_SITE_NAME prostředí:

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

V místním vývojovém prostředí

Při místním spuštění projekt funkcí obsahuje local.settings.json soubor, do kterého ukládáte proměnné prostředí v objektu Values .

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

V cloudovém prostředí Azure

Když spustíte Azure, aplikace funkcí umožňuje nastavit a používat nastavení Aplication, jako jsou připojovací řetězce služby, a během provádění tato nastavení zpřístupní jako proměnné prostředí.

Nastavení aplikace funkcí můžete přidat, aktualizovat a odstranit několika způsoby:

Změny nastavení aplikace funkcí vyžadují restartování aplikace funkcí.

Proměnné pracovního prostředí

Node.js má několik proměnných prostředí Functions, které jsou pro něj specifické:

languageWorkers__node__arguments

Použijte toto nastavení k určení vlastních argumentů při spuštění procesu Node.js. Nejčastěji ho používáte lokálně k zahájení práce v debug módu, ale můžete ho použít i v Azure, pokud potřebujete vlastní argumenty.

Varování

Pokud je to možné, vyhněte se používání languageWorkers__node__arguments v Azure, protože to může negativně ovlivnit čas studeného startu. Namísto použití předem zahřátých pracovních procesů musí modul runtime spustit nový pracovní proces od začátku s použitím vašich vlastních argumentů.

logovánílogLevelPracovník

Pomocí tohoto nastavení upravíte výchozí úroveň protokolování pro protokoly pracovních procesů specifických pro Node.js. Ve výchozím nastavení se zobrazují pouze protokoly upozornění nebo chyb, ale můžete to nastavit na information nebo debug pro pomoc s diagnostikou problémů s pracovní procesem Node.js. Další informace najdete v tématu konfigurace úrovní protokolu.

Moduly ECMAScript (Náhled)

Poznámka:

ECMAScript moduly jsou v současnosti ukázkovou funkcí v Node.js 14 a vyšších v Azure Functions.

Moduly ECMAScript (moduly ES) jsou novým oficiálním standardním systémem modulů pro Node.js. Zatím ukázky kódu v tomto článku používají syntaxi CommonJS. Při spuštění Azure Functions v Node.js 14 nebo vyšším můžete zvolit psaní funkcí pomocí syntaxe ES modulů.

Pokud chcete ve funkci používat moduly ES, změňte jeho název souboru tak, aby používal příponu .mjs . Následující příklad souboru index.mjs je funkce aktivovaná protokolem HTTP, která k importu uuid knihovny používá syntaxi modulů ES a vrací hodnotu.

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

Konfigurace vstupního bodu funkce

Použijte function.json vlastnosti scriptFile a entryPoint nastavte polohu a název exportované funkce. Když používáte TypeScript, potřebujete vlastnost scriptFile a měla by ukazovat na zkompilovaný JavaScript.

Použití scriptFile

Ve výchozím nastavení běží JavaScriptová funkce z index.js. Tento soubor sdílí stejný nadřazený adresář jako odpovídající function.json soubor.

Použijte scriptFile k organizaci struktury složek. Následující příklad ukazuje jeden způsob, jak nastavit složky:

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

Soubor function.json pro myFirstFunction by měl obsahovat vlastnost scriptFile , která ukazuje na soubor s exportovanou funkcí k běhu.

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

Použití entryPoint

V modelu v3 musíte funkci exportovat pomocí , module.exports aby ji bylo možné najít a spustit. Ve výchozím nastavení je funkce, která se spustí při spuštění, jedinou exportní složkou z tohoto souboru. Může to být také export s názvem run nebo export s názvem index. Následující příklad nastaví entryPoint v function.json na vlastní hodnotu „logHello“:

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

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

module.exports = { logHello };

Doporučení

Tato sekce popisuje několik zásadních vzorců pro Node.js aplikace, které byste měli následovat.

Volba plánů služby App Service s jedním virtuálním procesorem

Když vytváříte funkční aplikaci, která používá plán App Service, zvolte plán s jedním vCPU místo plánu s více vCPU. Dnes Functions běží Node.js funkce efektivněji na VM s jedním vCPU a používání větších VM nepřináší očekávané zlepšení výkonu. Když je to potřeba, můžete škálovat přidáním více instancí VM s jedním vCPU, nebo zapnout automatické škálování. Další informace najdete v tématu Ruční nebo automatické škálování počtu instancí.

Spuštění ze souboru balíčku

Při vývoji Azure Functions v modelu bezserverového hostování jsou studené starty realitou. Studený start označuje první spuštění aplikace využívající funkce po určité době nečinnosti, což způsobí, že spuštění trvá déle. U Node.js aplikací s velkými stromy závislostí může být důležité zejména studené spuštění. Pokud chcete urychlit proces studeného spuštění, spusťte funkce jako soubor balíčku, pokud je to možné. Mnoho způsobů nasazení ve výchozím nastavení používá tento model, ale pokud se setkáváte s dlouhými cold starty, ověřte, že běží tímto způsobem.

Použijte async a await

Při psaní Azure Functions v Node.js pište kód s použitím klíčových slov async a await. Psaní kódu s použitím async a await namísto zpětných volání nebo .then a .catch s přísliby vám pomůže vyhnout se dvěma běžným problémům:

  • Vyvolání nezachycených výjimek, které způsobí pád procesu Node.js, což může negativně ovlivnit provádění jiných funkcí.
  • Neočekávané chování, například chybějící protokoly context.log, způsobené asynchronními voláními, která nejsou správně očekávána.

V následujícím příkladu je asynchronní metoda fs.readFile vyvolána s funkcí zpětného volání typu error-first jako svým druhým parametrem. Tento kód způsobuje oba dříve uvedené problémy. Výjimka, která není explicitně zachycena ve správném oboru, může způsobit havárii celého procesu (problém č. 1). Vrácení bez zajištění dokončení callbacku znamená, že HTTP odpověď někdy zůstává prázdná (problém #2).

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

V následujícím příkladu je asynchronní metoda fs.readFile vyvolána s funkcí zpětného volání typu error-first jako svým druhým parametrem. Tento kód způsobuje oba výše zmíněné problémy. Výjimka, která není explicitně zachycena ve správném rozsahu, může celý proces zhroutit (problém #1). Volání zastaralé context.done() metody mimo rozsah callbacku může signalizovat, že funkce je dokončena dříve, než je soubor přečten (problém #2). V tomto příkladu volání context.done() příliš brzy způsobí chybějící položky protokolu začínající na 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();
};

Pomocí klíčových slov async a await můžete předejít oběma těmto problémům. Většina API v ekosystému Node.js nyní podporuje sliby v nějaké podobě. Například od verze 14 poskytuje Node.js fs/promises API nahrazující callback fs API.

V následujícím příkladu jakékoli neošetřené výjimky vyvolané během provádění funkce způsobí selhání pouze jednotlivého vyvolání, které vyvolalo výjimku. Klíčové await slovo znamená, že následující readFile kroky se spustí až po jeho dokončení.

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

Když použijete async a await, nemusíte volat zpětné volání context.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}`);
};

Odstraňování potíží

Přečtěte si průvodce odstraňováním potíží s Node.js.

Další kroky

Další informace naleznete v následujících zdrojích:

  • Last updated on