Guía para desarrolladores de Azure Functions Node.js

El modelo v3 registra una función según la existencia de dos archivos. En primer lugar, necesita un archivo ubicado en una carpeta un nivel por debajo de la raíz de la aplicación. En segundo lugar, necesitará un archivo JavaScript que exporte la función. De forma predeterminada, el modelo busca un archivo en la misma carpeta que . Si usa TypeScript, deberá usar la propiedad en para que apunte al archivo JavaScript compilado. Para personalizar la ubicación del archivo o el nombre de exportación de la función, consulte la configuración del punto de entrada de la función.

La función que exporta siempre debe declararse como en el modelo v3. Puede exportar una función sincrónica, pero debe llamar a para indicar que la función se ha completado, lo que está en desuso y no se recomienda.

La función recibe una invocación como primer argumento y las entradas como argumentos restantes.

El ejemplo siguiente es una función simple que registra que se ha desencadenado y responde con :

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

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

{
  "bindings": [
    {
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "authLevel": "anonymous",
      "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,
  request: HttpRequest
): Promise<void> {
  context.log("Http function was triggered.");
  context.res = { body: "Hello, world!" };
};

export default httpTrigger;

El modelo de programación carga las funciones en función del campo de . Puede establecer el campo en un único archivo o en varios archivos mediante un patrón global. La siguiente tabla muestra valores de ejemplo para el campo :

Para registrar una función, debe importar el objeto desde el módulo npm y llamar al método específico del tipo de desencadenador. El primer argumento al registrar una función es el nombre de la función. El segundo argumento es un objeto que especifica la configuración del desencadenador, el controlador y cualquier otra entrada o salida. En algunos casos en los que la configuración del desencadenador no sea necesaria, puede pasar el controlador directamente como segundo argumento en lugar de un objeto .

El registro de una función se puede realizar desde cualquier archivo del proyecto, siempre y cuando ese archivo se cargue (directa o indirectamente) en función del campo del archivo . La función debe registrarse en un ámbito global porque no se pueden registrar funciones una vez que se inicien las ejecuciones.

El ejemplo siguiente es una función simple que registra que se ha desencadenado y responde con :

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

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

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

async function helloWorld1(
  request: HttpRequest,
  context: InvocationContext
): Promise<HttpResponseInit> {
  context.log("Http function was triggered.");
  return { body: "Hello, world!" };
}

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

La función es necesaria para tener exactamente una entrada principal denominada desencadenador. También puede tener entradas secundarias o salidas. Las entradas y salidas se configuran en los archivos y también se conocen como enlaces.

Entradas

Las entradas son enlaces con establecido en . La principal diferencia entre un desencadenador y una entrada secundaria es que para un desencadenador finaliza en ; por ejemplo, el tipo en comparación con el tipo . La mayoría de las funciones solo usan un desencadenador y no se admiten muchos tipos de entrada secundarios.

Se puede acceder a las entradas de varias maneras:

• [Recomendado] Como argumentos pasados a la función: use los argumentos en el mismo orden en que se definen en . La propiedad definida en no tiene que coincidir con el nombre de tu argumento; sin embargo, recomendamos hacerlo por razones de organización.

  • JavaScript
  • TypeScript

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

• Como propiedades de : use la clave que coincide con la propiedad definida en .

  • JavaScript
  • TypeScript

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

Salidas

Las salidas son enlaces con establecido en y se pueden establecer de varias maneras:

• [Recomendado para una salida única] Devuelva el valor directamente: si usa una función asincrónica, puede devolver el valor directamente. Debe cambiar la propiedad del enlace de salida a en como en el ejemplo siguiente:

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

  • JavaScript
  • TypeScript

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

• [Recomendado para varias salidas] Devuelva un objeto que contenga todas las salidas: si usa una función asincrónica, puede devolver un objeto con una propiedad que coincida con el nombre de cada enlace de . En el ejemplo siguiente se usan enlaces de salida denominados "httpResponse" y "queueOutput":

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

  • JavaScript
  • TypeScript

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

• Establezca valores en : si no usa una función asincrónica o no quiere usar las opciones anteriores, puede establecer los valores directamente en , en los que la clave coincide con el nombre del enlace. En el ejemplo siguiente se usan enlaces de salida denominados "httpResponse" y "queueOutput":

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

  • JavaScript
  • TypeScript

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

Tipo de datos de enlaces

Puede usar la propiedad en un enlace de entrada para cambiar el tipo de entrada. Sin embargo, el enfoque tiene algunas limitaciones:

• En Node.js, solo se admiten y ( no).
• En el caso de las entradas HTTP, se omite la propiedad . En su lugar, use propiedades en el objeto para obtener el cuerpo en el formato que quiera. Para obtener más información, consulte Solicitud HTTP.

En el ejemplo siguiente de un desencadenador de cola de almacenamiento, el tipo predeterminado de es , pero si se establece en , el tipo cambia a de Node.js.

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

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

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

import { AzureFunction, Context } from "@azure/functions";
import { Buffer } from "node:buffer";

const queueTrigger1: AzureFunction = async function (
  context: Context,
  myQueueItem: string | Buffer
): Promise<void> {
  if (typeof myQueueItem === "string") {
    context.log("myQueueItem is a string");
  } else if (Buffer.isBuffer(myQueueItem)) {
    context.log("myQueueItem is a buffer");
  }
};

export default queueTrigger1;

La función es necesaria para tener exactamente una entrada principal denominada desencadenador. También puede tener entradas secundarias, una salida principal denominada salida de retorno o salidas secundarias. Las entradas y salidas también se conocen como enlaces fuera del contexto del modelo de programación de Node.js. Antes de la versión v4 del modelo, estos enlaces se configuraron en archivos .

Entrada del desencadenador

El desencadenador es la única entrada o salida necesaria. Para la mayoría de los tipos de desencadenador, se registra una función mediante un método en el objeto denominado después del tipo de desencadenador. Puede especificar la configuración específica del desencadenador directamente en el argumento . Por ejemplo, un desencadenador HTTP permite especificar una ruta. Durante la ejecución, el valor correspondiente a este desencadenador se pasa como primer argumento al controlador.

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

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

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

async function helloWorld1(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    ...
};

app.http('helloWorld1', {
    route: 'hello/world',
    handler: helloWorld1
});

Salida de devolución

La salida de devolución es opcional y, en algunos casos, está configurada de forma predeterminada. Por ejemplo, un desencadenador HTTP registrado con está configurado para devolver automáticamente una salida de respuesta HTTP. Para la mayoría de los tipos de salida, especifique la configuración de devolución en el argumento con la ayuda del objeto exportado desde el módulo . Durante la ejecución, esta salida se establece devolviendo desde el controlador.

En el ejemplo siguiente se usa un desencadenador de temporizador y una salida de cola de almacenamiento:

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

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

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

async function timerTrigger1(myTimer: Timer, context: InvocationContext): Promise<any> {
    return { hello: 'world' }
}

app.timer('timerTrigger1', {
    schedule: '0 */5 * * * *',
    return: output.storageQueue({
        connection: 'storage_APPSETTING',
        ...
    }),
    handler: timerTrigger1
});

Entradas y salidas adicionales

Además del desencadenador y la devolución, puede especificar entradas o salidas adicionales en el argumento al registrar una función. Los objetos y exportados desde el módulo proporcionan métodos específicos del tipo para ayudar a construir la configuración. Durante la ejecución, obtiene o establece los valores con o , pasando el objeto de configuración original como primer argumento.

El ejemplo siguiente es una función desencadenada por una cola de almacenamiento, con una entrada de blob de almacenamiento adicional que se copia en una salida de blob adicional. El mensaje de cola debe ser el nombre de un archivo y reemplaza como nombre de blob que se va a copiar, con la ayuda de una expresión de enlace.

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

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

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

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

import { app, InvocationContext, input, output } from "@azure/functions";

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

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

async function copyBlob1(
  queueItem: unknown,
  context: InvocationContext
): Promise<void> {
  const blobInputValue = context.extraInputs.get(blobInput);
  context.extraOutputs.set(blobOutput, blobInputValue);
}

app.storageQueue("copyBlob1", {
  queueName: "copyblobqueue",
  connection: "storage_APPSETTING",
  extraInputs: [blobInput],
  extraOutputs: [blobOutput],
  handler: copyBlob1,
});

Entradas y salidas genéricas

Los objetos , , y exportados por el módulo proporcionan métodos específicos del tipo para la mayoría de los tipos. Para todos los tipos que no se admiten, se proporciona un método para que pueda especificar manualmente la configuración. El método también se puede usar si desea cambiar la configuración predeterminada proporcionada por un método específico del tipo.

El ejemplo siguiente es una función simple desencadenada por HTTP mediante métodos genéricos en lugar de métodos específicos del tipo.

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

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

Tipos de SDK

Ahora, varias extensiones de enlace permiten trabajar directamente con los tipos de Azure SDK.

Almacenamiento de blobs de Azure

La funcionalidad de enlaces de SDK en Azure Functions permite trabajar directamente con los tipos de SDK de Blob Storage de Azure, como BlobClient y ContainerClient en lugar de datos sin procesar. Esto proporciona acceso completo a todos los métodos del SDK al trabajar con blobs.

Para configurar el proyecto para que funcione con los tipos de SDK:

1. Agregue los paquetes de vista previa de extensión al archivo del proyecto, que debe incluir al menos estos paquetes:

"dependencies": {
  "@azure/functions": "4.7.2-preview",
  "@azure/functions-extensions-blob": "0.2.0-preview"
},

2. Agregue a para admitir tipos de streaming:

import { app } from '@azure/functions';

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

En este ejemplo se muestra cómo obtener el BlobClient de un desencadenador de Storage Blob y del enlace de entrada en un desencadenador HTTP:

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

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

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

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

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

En este ejemplo se explica cómo obtener el a través de un enlace de entrada de Storage Blob mediante un desencadenador HTTP:

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

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

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

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

  return { jsonBody: { blobs } };
}

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

Tenga en cuenta estas consideraciones al trabajar con tipos de SDK:

• Siempre tenga primero en sus archivos para asegurarse de que se ejecutan efectos secundarios.
• Establezca en la configuración de enlace.
• Use el tipo de cliente adecuado para la operación:
  • para operaciones en un único blob
  • para operaciones en un contenedor
• Maneje los errores adecuadamente con los bloques
• En el caso de las operaciones de blobs grandes, considere la posibilidad de usar métodos de streaming para evitar problemas de memoria.

Para obtener más información, consulte estas muestras de enlaces del SDK de Blob Storage para Node.js: para obtener más ejemplos sobre cómo incorporar enlaces del SDK de Blob en su aplicación de funciones.

• BlobClient
• ContainerClient
• Readable Stream

Azure Service Bus

En este ejemplo se usa el tipo de SDK ServiceBusReceivedMessage obtenido de ServiceBusMessageContext proporcionado por el desencadenador de Service Bus:

import '@azure/functions-extensions-servicebus'; // Ensure the Service Bus extension is imported
import { app, InvocationContext } from '@azure/functions';
import { ServiceBusMessageContext } from '@azure/functions-extensions-servicebus';
import { parseBody } from '../servicebus-helpers'; // Interim helper until #50 lands

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

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

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

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

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

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

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

Para obtener otro ejemplo del uso de tipos de SDK, consulte el ejemplo de estrategia de retroceso exponencial .

Cada invocación de la función recibe un objeto de invocación , que se usa para leer entradas, establecer salidas, escribir en registros y leer varios metadatos. En el modelo v3, el objeto de contexto siempre es el primer argumento pasado al controlador.

El objeto tiene las siguientes propiedades:

context.executionContext

El objeto tiene las siguientes propiedades:

context.executionContext.retryContext

El objeto tiene las siguientes propiedades:

context.bindings

El objeto se usa para leer entradas o establecer salidas. El ejemplo siguiente es un desencadenador de cola de almacenamiento, que usa para copiar una entrada de blob de almacenamiento a una salida de blob de almacenamiento. El contenido del mensaje de la cola reemplaza como nombre de archivo que se va a copiar, con la ayuda de una expresión de enlace.

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

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;

context.done

Este método está en desuso. Antes de que se admitieran las funciones asincrónicas, se indicaba que la función había terminado mediante una llamada a :

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

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;

Recomendamos que quite la llamada a y marcar la función como asincrónica para que devuelva una promesa (incluso si no aplica a nada). Tan pronto como finalice la función (en otras palabras, se resuelva la promesa devuelta), el modelo v3 sabrá que la función ha terminado.

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

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;

Cada invocación de la función recibe un objeto de invocación, con información adicional sobre el contexto y los métodos usados para el registro. En el modelo v4, el objeto suele ser el segundo argumento pasado al controlador.

La clase tiene las siguientes propiedades:

Contexto de reintento

El objeto tiene las siguientes propiedades:

Para más información, consulte .

Para el seguimiento distribuido en el modelo de programación de Node.js v4, puede usar el paquete en lugar del SDK de Application Insights. Este paquete proporciona instrumentación automática basada en OpenTelemetry para Azure Functions. Para obtener más información, consulte el repositorio OpenTelemetry Azure Functions Instrumentation for Node.js GitHub.

Los desencadenadores HTTP y de webhook usan objetos de solicitud y respuesta para representar mensajes HTTP.

Los desencadenadores HTTP y de webhook usan objetos y para representar mensajes HTTP. Las clases representan un subconjunto del estándar de captura, mediante el paquete de Node.js.

Se puede acceder a una solicitud de varias maneras:

• Como segundo argumento de la función:

  • JavaScript
  • TypeScript

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

• Desde la propiedad :

  • JavaScript
  • TypeScript

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

• Desde los enlaces de entrada con nombre: esta opción funciona igual que cualquier enlace no HTTP. El nombre del enlace de debe coincidir con la clave en , o "request1" en el ejemplo siguiente:

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

  • JavaScript
  • TypeScript

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

El objeto tiene las siguientes propiedades:

Se puede acceder a la solicitud como primer argumento para el controlador de una función desencadenada por HTTP.

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

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

El objeto tiene las siguientes propiedades:

Para acceder al cuerpo de una solicitud o respuesta, se pueden usar los métodos siguientes:

La respuesta se puede establecer de varias maneras:

• Establezca la propiedad :

  • JavaScript
  • TypeScript

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

• Devuelva la respuesta: si la función es asincrónica y establece el nombre de enlace en en , puede devolver la respuesta directamente en lugar de establecerla en .

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

  • JavaScript
  • TypeScript

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

• Establezca el enlace de entrada con nombre: esta opción funciona igual que cualquier enlace no HTTP. El nombre del enlace de debe coincidir con la clave en , o "response1" en el ejemplo siguiente:

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

  • JavaScript
  • TypeScript

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

• Llame a : esta opción está en desuso. Llama implícitamente a y no se puede usar en una función asincrónica.

  • JavaScript
  • TypeScript

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

Si crea un objeto nuevo al establecer la respuesta, dicho objeto debe coincidir con la interfaz , que tiene las siguientes propiedades:

También puede modificar el objeto sin sobrescribirlo. El objeto predeterminado usa la interfaz , que admite los métodos siguientes además de las propiedades :

La respuesta se puede establecer de varias maneras:

• Como interfaz sencilla con el tipo : esta opción es la forma más concisa de devolver respuestas.

  • JavaScript
  • TypeScript

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

La interfaz tiene las propiedades siguientes:

• Como clase con tipo : esta opción proporciona métodos auxiliares para leer y modificar varias partes de la respuesta, como los encabezados.

  • JavaScript
  • TypeScript

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

La clase acepta un opcional como argumento para su constructor y tiene las siguientes propiedades:

Requisitos previos

• El paquete npm versión 4.3.0 o posterior.
• Azure Functions runtime versión 4.28 o posterior.
• Azure Functions Core Tools versión 4.0.5530 o posterior, que contiene la versión en tiempo de ejecución correcta.

Habilitación de secuencias

Siga estos pasos para habilitar flujos HTTP en la aplicación de funciones en Azure y en los proyectos locales:

1. Si planea transmitir grandes cantidades de datos, modifique la configuración de FUNCTIONS_REQUEST_BODY_SIZE_LIMIT en Azure. El tamaño máximo de cuerpo predeterminado permitido es , que limita las solicitudes a un tamaño de ~100 MB.

2. Para el desarrollo local, agregue también al archivo local.settings.json.

3. Agregue el código siguiente a la aplicación en cualquier archivo incluido en el campo principal.

   • JavaScript
   • TypeScript

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

Ejemplos de secuencias

En este ejemplo se muestra una función desencadenada por HTTP que recibe datos a través de una solicitud HTTP POST y la función transmite estos datos a un archivo de salida especificado:

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

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

En este ejemplo se muestra una función desencadenada por HTTP que transmite el contenido de un archivo como respuesta a las solicitudes HTTP GET entrantes:

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

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

Para obtener una aplicación de ejemplo lista para ejecutar mediante secuencias, consulte este ejemplo en GitHub.

Consideraciones sobre secuencias

• Use para obtener la ventaja máxima del uso de secuencias. Todavía puede seguir usando métodos como , que siempre devuelven el cuerpo como una cadena.

Los enlaces no se admiten en el modelo v3. Actualice al modelo v4 para usar enlaces.

Use un enlace para ejecutar código en distintos puntos del ciclo de vida de Azure Functions. Los enlaces se ejecutan en el orden en que están registrados y se pueden registrar desde cualquier archivo de la aplicación. Actualmente hay dos ámbitos de enlaces, nivel "aplicación" e "invocación".

Enlaces de invocación

Los enlaces de invocación se ejecutan una vez por cada invocación de su función, ya sea antes en un enlace o después en un enlace . De manera predeterminada, su enlace se ejecuta para todos los tipos de desencadenador, pero también puede filtrar por tipo. En el ejemplo siguiente se muestra cómo registrar un enlace de invocación y filtrar por tipo de desencadenador:

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

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

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

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

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

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

El primer argumento para el controlador de enlace es un objeto de contexto específico de ese tipo de enlace.

El objeto tiene las siguientes propiedades:

El objeto tiene las siguientes propiedades:

Enlaces de aplicación

Los enlaces de aplicación se ejecutan una vez por cada instancia de su aplicación, ya sea durante el inicio en un enlace de o durante la finalización en un enlace de . Los enlaces de finalización de aplicación tienen un tiempo limitado para ejecutarse y no se ejecutan en todos los escenarios.

El entorno de ejecución de Azure Functions actualmente no admite el registro de contexto fuera de una invocación. Use el paquete npm de Application Insights para registrar los datos durante los enlaces a nivel de aplicación.

En el ejemplo siguiente se registran enlaces de aplicación:

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

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

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

import { app, AppStartContext, AppTerminateContext } from '@azure/functions';

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

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

El primer argumento para el controlador de enlace es un objeto de contexto específico de ese tipo de enlace.

El objeto tiene las siguientes propiedades:

El objeto tiene las siguientes propiedades:

Configuración del punto de entrada de la función

Las propiedades de y pueden usarse para configurar la ubicación y el nombre de la función exportada. La propiedad es necesaria cuando se usa TypeScript y se debe apuntar al JavaScript compilado.

Usar

De forma predeterminada, se ejecuta una función de JavaScript desde , un archivo que comparte el mismo directorio primario que su archivo correspondiente.

se puede usar para obtener una estructura de carpetas que tenga el aspecto del ejemplo siguiente:

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

para debe incluir una propiedad que señala al archivo con la función exportada que ejecutar.

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

Usar

En el modelo v3, una función debe exportarse con para que se pueda encontrar y ejecutar. De forma predeterminada, la función que se ejecuta cuando se desencadena es la única exportación de ese archivo, la exportación denominada o la exportación denominada . El ejemplo siguiente establece en un valor personalizado, "logHello":

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

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

module.exports = { logHello };

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

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

export default { logHello };

En el ejemplo siguiente, se invoca el método asincrónico con una función de devolución de llamada error-first como segundo parámetro. Este código provoca los dos problemas mencionados anteriormente. Una excepción no detectada explícitamente en el ámbito correcto puede bloquear todo el proceso (problema 1). Regresar sin asegurarse de que el callback termine significa que la respuesta HTTP a veces tiene un cuerpo vacío (ver problema n.º 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 };
    },
});

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

En el ejemplo siguiente, se invoca el método asincrónico con una función de devolución de llamada error-first como segundo parámetro. Este código provoca los dos problemas mencionados anteriormente. Una excepción no detectada explícitamente en el ámbito correcto puede bloquear todo el proceso (problema 1). Llamar al método en desuso fuera del ámbito de la devolución de llamada puede indicar que la función ha terminado antes de que se lea el archivo (problema 2). En este ejemplo, una llamada a demasiado pronto provoca la ausencia de las entradas de registro que empiezan por .

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

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

Con y , tampoco es necesario llamar a la devolución de llamada .

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

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