Migrera till version 4 av Node.js programmeringsmodellen för Azure Functions

Denna artikel diskuterar skillnaderna mellan version 3 och version 4 av Node.js programmeringsmodellen och hur man uppgraderar en befintlig v3-app. Om du vill skapa en ny v4-app i stället för att uppgradera en befintlig v3-app kan du läsa självstudien för antingen Visual Studio Code (VS Code) eller Azure Functions Core Tools. Den här artikeln använder tipsaviseringar för att belysa de viktigaste konkreta åtgärder som du bör vidta för att uppgradera din app. Version 4 är utformad för att ge Node.js utvecklare följande fördelar:

• Ge en välbekant och intuitiv upplevelse för Node.js utvecklare.
• Gör filstrukturen flexibel med stöd för fullständig anpassning.
• Växla till en kodcentrerad metod för att definiera funktionskonfiguration.

Att tänka på

• Programmeringsmodellen Node.js ska inte förväxlas med Azure Functions-körningen:
  • Programmeringsmodell: Definierar hur du skapar din kod och är specifik för JavaScript och TypeScript.
  • Körningsmiljö: Definierar det underliggande beteendet för Azure Functions och delas av alla språk.
• Versionen av programmeringsmodellen är strikt kopplad till versionen av @azure/functions npm-paketet. Den versioneras oberoende av körmiljön. Både körningsmiljön och programmeringsmodellen har siffran 4 som senaste huvudversion, men det är en tillfällighet.
• Du kan inte blanda programmeringsmodellerna v3 och v4 i samma funktionsapp. Så snart du registrerar en v4-funktion i din app ignoreras alla v3-funktioner som är registrerade i function.json filer.

Krav

Version 4 av Node.js programmeringsmodell kräver följande lägsta versioner:

Inkludera npm-paketet

I v4 @azure/functions innehåller npm-paketet den primära källkoden som stöder Node.js programmeringsmodellen. I tidigare versioner levererades den koden direkt i Azure, och npm-paketet innehöll endast TypeScript-typerna. Nu måste du inkludera det här paketet för både TypeScript- och JavaScript-appar. Du kan inkludera paketet för befintliga v3-appar, men det krävs inte.

npm install @azure/functions

Ange startpunkt för din app

I v4 i programmeringsmodellen kan du strukturera koden hur du vill. De enda filer som du behöver i appens rot är host.json och package.json.

Annars definierar du filstrukturen genom att ange fältet main i din package.json-fil . Du kan ange fältet main till en enskild fil eller flera filer med hjälp av ett globmönster. I följande tabell visas exempelvärden för fältet main :

Växla ordning på argument

Indata från utlösaren, i stället för anropskontexten, är nu det första argumentet till din funktionshanterare. Anropskontexten, som nu är det andra argumentet, har förenklats i v4 och är inte lika nödvändig som indata från utlösaren. Du kan låta det vara avstängt om du inte använder det.

Definiera din funktion i kod

Du behöver inte längre skapa och underhålla dessa separata function.json konfigurationsfiler. Nu kan du helt definiera dina funktioner direkt i TypeScript- eller JavaScript-filerna. Dessutom har många egenskaper nu standardvärden så att du inte behöver ange dem varje gång.

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

app.http('httpTrigger1', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    handler: async (request, context) => {
        context.log(`Http function processed request for url "${request.url}"`);

        const name = request.query.get('name') || (await request.text()) || 'world';

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

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

    const name = req.query.name || req.body || 'world';

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

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

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

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

    const name = request.query.get('name') || (await request.text()) || 'world';

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

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

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

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

    const name = req.query.name || req.body || 'world';

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

export default httpTrigger;

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

Granska din användning av kontext

I v4 context förenklas objektet för att minska dupliceringen och göra det enklare att skriva enhetstester. Vi effektiviserade till exempel de primära indata och utdata så att de endast används som argument och returnerar värdet för funktionshanteraren.

Du kan inte längre komma åt de primära indata och utdata på context objektet, men du måste fortfarande komma åt sekundära indata och utdata på context objektet. Mer information om sekundära indata och utdata finns i utvecklarguiden för Node.js.

Hämta de primära indata som ett argument

Den primära indata kallas också för utlösare och är den enda obligatoriska indata eller utdata. Du måste ha en (och bara en) utlösare.

async function httpTrigger1(request, context) {
  const onlyOption = request;

async function httpTrigger1(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
  const onlyOption = request;

async function httpTrigger1(context, request) {
    const option1 = request;
    const option2 = context.req;
    const option3 = context.bindings.req;

async function httpTrigger1(context: Context, req: HttpRequest): Promise<void> {
    const option1 = request;
    const option2 = context.req;
    const option3 = context.bindings.req;

Ange de primära utdata som ditt returvärde

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

async function httpTrigger1(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    // ...
    return { 
      body: `Hello, ${name}!` 
    };
}

// Option 1
context.res = {
    body: `Hello, ${name}!`
};
// Option 2, but you can't use this option with any async code:
context.done(null, {
    body: `Hello, ${name}!`
});
// Option 3, but you can't use this option with any async code:
context.res.send(`Hello, ${name}!`);
// Option 4, if "name" in function.json is "res":
context.bindings.res = {
    body: `Hello, ${name}!`
}
// Option 5, if "name" in function.json is "$return":
return {
    body: `Hello, ${name}!`
};

Kontextloggning

I v4 flyttades loggningsmetoder till rotobjektet context enligt följande exempel. Mer information om loggning finns i utvecklarguiden för Node.js.

context.log('This is an info log');
context.error('This is an error');
context.warn('This is an error');

context.log('This is an info log');
context.log.error('This is an error');
context.log.warn('This is an error');

Skapa en testkontext

Version 3 stöder inte att skapa en anropskontext utanför Azure Functions-körningen, så det kan vara svårt att redigera enhetstester. Med version 4 kan du skapa en instans av anropskontexten, men informationen under testerna är inte detaljerad om du inte lägger till den själv.

const testInvocationContext = new InvocationContext({
  functionName: 'testFunctionName',
  invocationId: 'testInvocationId'
});

Granska din användning av HTTP-typer

HTTP-begärande- och svarstyperna är nu en delmängd av hämtningsstandarden. De är inte längre unika för Azure Functions.

Typerna använder paketet undici i Node.js. Det här paketet följer hämtningsstandarden och håller för närvarande på att integreras i Node.js kärna.

HttpRequest

HttpResponse

Felsöka

Se felsökningsguiden för Node.js.