Guía para el desarrollador de JavaScript para Azure FunctionsAzure Functions JavaScript developer guide

Esta guía contiene información acerca de las complejidades de la escritura de Azure Functions con JavaScript.This guide contains information about the intricacies of writing Azure Functions with JavaScript.

Una función de JavaScript es una función exportada (function) que ejecuta al desencadenarse (los desencadenadores están configurados en function.json).A JavaScript function is an exported function that executes when triggered (triggers are configured in function.json). El primer argumento pasado a cada función es un context objeto, que se usa para el envío y recepción enlace de datos, registro y la comunicación con el tiempo de ejecución.The first argument passed to every function is a context object, which is used for receiving and sending binding data, logging, and communicating with the runtime.

En este artículo se supone que ya ha leído Referencia para desarrolladores de Azure Functions.This article assumes that you have already read the Azure Functions developer reference. Completar el inicio rápido de Functions para crear su primera función, mediante Visual Studio Code o en el portal de.Complete the Functions quickstart to create your first function, using Visual Studio Code or in the portal.

En este artículo también admite desarrollo de aplicaciones de TypeScript.This article also supports TypeScript app development.

Estructura de carpetasFolder structure

La estructura de carpetas necesaria para un proyecto de JavaScript tiene el siguiente aspecto.The required folder structure for a JavaScript project looks like the following. Este valor predeterminado se puede cambiar.This default can be changed. Para más información, consulte la sección scriptFile a continuación.For more information, see the scriptFile section below.

FunctionsProject
 | - MyFirstFunction
 | | - index.js
 | | - function.json
 | - MySecondFunction
 | | - index.js
 | | - function.json
 | - SharedCode
 | | - myFirstHelperFunction.js
 | | - mySecondHelperFunction.js
 | - node_modules
 | - host.json
 | - package.json
 | - extensions.csproj

En la raíz del proyecto, hay un archivo host.json compartido que se puede usar para configurar la aplicación de función.At the root of the project, there's a shared host.json file that can be used to configure the function app. Cada función tiene una carpeta con su propio archivo de código (.js) y archivo de configuración de enlace (function.json).Each function has a folder with its own code file (.js) and binding configuration file (function.json). El nombre del directorio primario de function.json siempre es el nombre de la función.The name of function.json's parent directory is always the name of your function.

Las extensiones de enlace necesarias en la versión 2.x del tiempo de ejecución de Functions se definen en el archivo extensions.csproj, con los archivos de biblioteca de la carpeta bin.The binding extensions required in version 2.x of the Functions runtime are defined in the extensions.csproj file, with the actual library files in the bin folder. Al desarrollar de forma local, debe registrar las extensiones de enlace.When developing locally, you must register binding extensions. Al desarrollar funciones en Azure Portal, este registro se realiza automáticamente.When developing functions in the Azure portal, this registration is done for you.

Exportación de una funciónExporting a function

Deben exportarse las funciones de JavaScript mediante module.exports (o exports).JavaScript functions must be exported via module.exports (or exports). La función exportada debe ser una función JavaScript que se ejecute al desencadenarse.Your exported function should be a JavaScript function that executes when triggered.

De forma predeterminada, el tiempo de ejecución de Functions busca la función en index.js, donde index.js comparte el mismo directorio primario que su function.json correspondiente.By default, the Functions runtime looks for your function in index.js, where index.js shares the same parent directory as its corresponding function.json. En el caso predeterminado, la función exportada debe ser la única exportación de su archivo, o bien la exportación denominada run o index.In the default case, your exported function should be the only export from its file or the export named run or index. Para configurar la ubicación del archivo y el nombre de exportación de la función, obtenga información sobre la configuración del punto de entrada de la función a continuación.To configure the file location and export name of your function, read about configuring your function's entry point below.

Varios argumentos se pasan a la función exportada durante la ejecución.Your exported function is passed a number of arguments on execution. El primer argumento que toma siempre es un objeto context.The first argument it takes is always a context object. Si la función es sincrónica (no devuelve una promesa), debe pasar el objeto context, ya que se requiere la llamada a context.done para que el uso sea correcto.If your function is synchronous (does not return a Promise), you must pass the context object, as calling context.done is required for correct use.

// You should include context, other arguments are optional
module.exports = function(context, myTrigger, myInput, myOtherInput) {
    // function logic goes here :)
    context.done();
};

Exportación de una función asincrónicaExporting an async function

Cuando se usa la declaración async function o las promesas de JavaScript sin formato en la versión 2.x del tiempo de ejecución de Functions, no tiene que llamar explícitamente a la devolución de llamada context.done para indicar que la función se ha completado.When using the async function declaration or plain JavaScript Promises in version 2.x of the Functions runtime, you do not need to explicitly call the context.done callback to signal that your function has completed. La función se completa cuando la función asincrónica o la promesa exportada se completa.Your function completes when the exported async function/Promise completes. Para las funciones destinadas a la versión 1.x del tiempo de ejecución, debe llamar a context.done cuando el código finalice la ejecución.For functions targeting the version 1.x runtime, you must still call context.done when your code is done executing.

El ejemplo siguiente es una función simple que registra que se ha desencadenado y completa la ejecución inmediatamente.The following example is a simple function that logs that it was triggered and immediately completes execution.

module.exports = async function (context) {
    context.log('JavaScript trigger function processed a request.');
};

Al exportar una función asincrónica, también puede configurar en enlace de salida para tomar el valor return.When exporting an async function, you can also configure an output binding to take the return value. Esto se recomienda si solo tiene un enlace de salida.This is recommended if you only have one output binding.

Para asignar una salida mediante return, cambie la propiedad name a $return en function.json.To assign an output using return, change the name property to $return in function.json.

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

En este caso, la función debe tener el aspecto del ejemplo siguiente:In this case, your function should look like the following example:

module.exports = async function (context, req) {
    context.log('JavaScript HTTP trigger function processed a request.');
    // You can call and await an async method here
    return {
        body: "Hello, world!"
    };
}

EnlacesBindings

En JavaScript, los enlaces se configuran y definen en el archivo function.json de una función.In JavaScript, bindings are configured and defined in a function's function.json. Las funciones interactúan con los enlaces de varias maneras.Functions interact with bindings a number of ways.

EntradasInputs

Las entradas se dividen en dos categorías Azure Functions: una es la entrada del desencadenador y la otra es una entrada adicional.Input are divided into two categories in Azure Functions: one is the trigger input and the other is the additional input. Una función puede leer los enlaces del desencadenador y de entrada (enlaces de direction === "in") de tres maneras:Trigger and other input bindings (bindings of direction === "in") can be read by a function in three ways:

  • ** [Recomendada] Como parámetros pasados a la función.**[Recommended] As parameters passed to your function. Se pasan a la función en el mismo orden en que se definen en function.json.They are passed to the function in the same order that they are defined in function.json. El name propiedad definida en function.json no necesita coincidir con el nombre del parámetro, aunque lo que debería.The name property defined in function.json does not need to match the name of your parameter, although it should.

    module.exports = async function(context, myTrigger, myInput, myOtherInput) { ... };
    
  • Como miembros del objeto context.bindings.As members of the context.bindings object. Cada miembro se denomina mediante la propiedad name definida en el archivo function.json.Each member is named by the name property defined in function.json.

    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);
    };
    
  • Como entradas mediante el objeto arguments de JavaScript.As inputs using the JavaScript arguments object. Es básicamente lo mismo que pasar entradas como parámetros, pero permite controlar las entradas de manera dinámica.This is essentially the same as passing inputs as parameters, but allows you to dynamically handle inputs.

    module.exports = async function(context) { 
        context.log("This is myTrigger: " + arguments[1]);
        context.log("This is myInput: " + arguments[2]);
        context.log("This is myOtherInput: " + arguments[3]);
    };
    

SalidasOutputs

Las salidas (enlaces de direction === "out") se pueden escribir mediante una función de varias maneras.Outputs (bindings of direction === "out") can be written to by a function in a number of ways. En todos los casos, la propiedad name del enlace tal como se define en el archivo function.json corresponde al nombre del miembro de objeto escrito en la función.In all cases, the name property of the binding as defined in function.json corresponds to the name of the object member written to in your function.

Puede asignar datos a los enlaces de salida en una de las maneras siguientes (no combinar estos métodos):You can assign data to output bindings in one of the following ways (don't combine these methods):

  • ** [Recomendado para varias salidas] Devolución de un objeto.**[Recommended for multiple outputs] Returning an object. Si usas un async/promesa devuelve la función, puede devolver un objeto con datos de salida asignado.If you are using an async/Promise returning function, you can return an object with assigned output data. En el ejemplo siguiente, los enlaces de salida se denominan "httpResponse" y "queueOutput" en el archivo function.json.In the example below, the output bindings are named "httpResponse" and "queueOutput" in function.json.

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

    Si utiliza una función sincrónica, puede devolver este objeto mediante context.done (vea el ejemplo).If you are using a synchronous function, you can return this object using context.done (see example).

  • ** [Recomendado para una salida única] Devolución de un valor directamente y uso del nombre de enlace $return.**[Recommended for single output] Returning a value directly and using the $return binding name. Este método solo funciona con las funciones de devolución asincrónicas o de promesa.This only works for async/Promise returning functions. Vea el ejemplo de Exportación de una función asincrónica.See example in exporting an async function.

  • Asignación de valores a context.bindings . Puede asignar valores directamente a context.bindings.Assigning values to context.bindings You can assign values directly to context.bindings.

    module.exports = async function(context) {
        let retMsg = 'Hello, world!';
        context.bindings.httpResponse = {
            body: retMsg
        };
        context.bindings.queueOutput = retMsg;
        return;
    };
    

Tipo de datos de enlacesBindings data type

Para definir el tipo de datos para un enlace de entrada, use la propiedad dataType de la definición del enlace.To define the data type for an input binding, use the dataType property in the binding definition. Por ejemplo, para leer el contenido de una solicitud HTTP en formato binario, use el tipo binary:For example, to read the content of an HTTP request in binary format, use the type binary:

{
    "type": "httpTrigger",
    "name": "req",
    "direction": "in",
    "dataType": "binary"
}

Las opciones para dataType son: binary, stream y string.Options for dataType are: binary, stream, and string.

objeto de contextocontext object

El sistema en tiempo de ejecución usa un objeto context para transmitir datos desde la función y hacia esta, así como para posibilitar la comunicación con dicho sistema en tiempo de ejecución.The runtime uses a context object to pass data to and from your function and to let you communicate with the runtime. El objeto de contexto se puede usar para leer y establecer los datos de los enlaces, escribir registros y usar la devolución de llamada context.done cuando la función exportada es sincrónica.The context object can be used for reading and setting data from bindings, writing logs, and using the context.done callback when your exported function is synchronous.

El objeto context siempre es el primer parámetro para una función.The context object is always the first parameter to a function. Debe incluirse porque tiene métodos importantes, tales como context.done y context.log.It should be included because it has important methods such as context.done and context.log. Puede asignar el nombre que desee al objeto (por ejemplo, ctx o c).You can name the object whatever you would like (for example, ctx or c).

// You must include a context, but other arguments are optional
module.exports = function(ctx) {
    // function logic goes here :)
    ctx.done();
};

Propiedad context.bindingscontext.bindings property

context.bindings

Devuelve un objeto con nombre que se usa para leer o asignar el enlace de datos.Returns a named object that is used to read or assign binding data. Desencadenador de enlace de datos de entrada y salida pueden obtenerse mediante la lectura de propiedades en context.bindings.Input and trigger binding data can be accessed by reading properties on context.bindings. Enlace de datos de salida se puede asignar mediante la adición de datos a context.bindingsOutput binding data can be assigned by adding data to context.bindings

Por ejemplo, las siguientes definiciones de enlace del archivo function.json permiten acceder al contenido de una cola desde context.bindings.myInput y asignar salidas a una cola mediante context.bindings.myOutput.For example, the following binding definitions in your function.json let you access the contents of a queue from context.bindings.myInput and assign outputs to a queue using context.bindings.myOutput.

{
    "type":"queue",
    "direction":"in",
    "name":"myInput"
    ...
},
{
    "type":"queue",
    "direction":"out",
    "name":"myOutput"
    ...
}
// myInput contains the input data, which may have properties such as "name"
var author = context.bindings.myInput.name;
// Similarly, you can set your output data
context.bindings.myOutput = { 
        some_text: 'hello world', 
        a_number: 1 };

Puede optar por definir datos de enlace de salida a través del método context.done en lugar del objeto context.binding (consulte a continuación).You can choose to define output binding data using the context.done method instead of the context.binding object (see below).

Propiedad context.bindingDatacontext.bindingData property

context.bindingData

Devuelve un objeto con nombre que contiene los metadatos de desencadenar y los datos de invocación de función (invocationId, sys.methodName, sys.utcNow y sys.randGuid).Returns a named object that contains trigger metadata and function invocation data (invocationId, sys.methodName, sys.utcNow, sys.randGuid). Para obtener un ejemplo de metadatos de desencadenador, consulte este ejemplo de centros de eventos.For an example of trigger metadata, see this event hubs example.

Método context.donecontext.done method

context.done([err],[propertyBag])

Permite que el tiempo de ejecución sepa que el código se ha completado.Lets the runtime know that your code has completed. Si su función usa la declaración async function, no es necesario que utilice context.done().When your function uses the async function declaration, you do not need to use context.done(). La devolución de llamada context.done se realiza implícitamente.The context.done callback is implicitly called. Las funciones asincrónicas están disponibles en Node 8 o una versión posterior, que requiere la versión 2.x del tiempo de ejecución de Functions.Async functions are available in Node 8 or a later version, which requires version 2.x of the Functions runtime.

Si la función no es una función asincrónica, debe llamar a context.done para informar al entorno en tiempo de ejecución que la función está completa.If your function is not an async function, you must call context.done to inform the runtime that your function is complete. La ejecución agota el tiempo de espera si no está presente.The execution times out if it is missing.

El método context.done le permite devolver un error definido por el usuario al entorno en tiempo de ejecución y un objeto JSON que contiene los datos de enlace de salida.The context.done method allows you to pass back both a user-defined error to the runtime and a JSON object containing output binding data. Las propiedades que se pasan a context.done sobrescriben lo que ha definido en el objeto context.bindings.Properties passed to context.done overwrite anything set on the context.bindings object.

// Even though we set myOutput to have:
//  -> text: 'hello world', number: 123
context.bindings.myOutput = { text: 'hello world', number: 123 };
// If we pass an object to the done function...
context.done(null, { myOutput: { text: 'hello there, world', noNumber: true }});
// the done method overwrites the myOutput binding to be: 
//  -> text: 'hello there, world', noNumber: true

Método context.logcontext.log method

context.log(message)

Permite escribir en los registros de la función de streaming en el nivel de seguimiento predeterminado.Allows you to write to the streaming function logs at the default trace level. Hay métodos de registro adicionales disponibles en context.log que permiten escribir registros de la función en otros niveles de seguimiento:On context.log, additional logging methods are available that let you write function logs at other trace levels:

MétodoMethod DESCRIPCIÓNDescription
error(message)error(message) Escribe en el registro de nivel de error o inferior.Writes to error level logging, or lower.
warn(message)warn(message) Escribe en el registro de nivel de advertencia o inferior.Writes to warning level logging, or lower.
info(message)info(message) Escribe en el registro de nivel de información o inferior.Writes to info level logging, or lower.
verbose(message)verbose(message) Escribe en el registro de nivel detallado.Writes to verbose level logging.

En el ejemplo siguiente se escribe un registro en el nivel de seguimiento de advertencia:The following example writes a log at the warning trace level:

context.log.warn("Something has happened."); 

Puede configurar el umbral de nivel de seguimiento de los registros en el archivo host.json.You can configure the trace-level threshold for logging in the host.json file. Para más información sobre cómo escribir registros, consulte cómo escribir resultados de seguimiento a continuación.For more information on writing logs, see writing trace outputs below.

Consulte cómo supervisar Azure Functions para obtener más información sobre cómo ver y consultar registros de la función.Read monitoring Azure Functions to learn more about viewing and querying function logs.

Escribir las salidas de seguimiento en la consolaWriting trace output to the console

En Functions, use los métodos context.log para escribir la salida de seguimiento en la consola.In Functions, you use the context.log methods to write trace output to the console. En Functions 2.x, las salidas de seguimiento mediante console.log se capturan en el nivel de Function App.In Functions v2.x, trace outputs using console.log are captured at the Function App level. Esto significa que las salidas de console.log no están asociados a una invocación de función específicos y no se muestran en los registros de una función específica.This means that outputs from console.log are not tied to a specific function invocation and aren't displayed in a specific function's logs. No obstante, se propagan a Application Insights.They do, however, propagate to Application Insights. En Functions 1.x, no puede usar console.log para escribir en la consola.In Functions v1.x, you cannot use console.log to write to the console.

Cuando se llama a context.log(), el mensaje se escribe en la consola en el nivel de seguimiento predeterminado, que es el nivel de seguimiento de información.When you call context.log(), your message is written to the console at the default trace level, which is the info trace level. El siguiente código escribe en la consola en el nivel de seguimiento de información:The following code writes to the console at the info trace level:

context.log({hello: 'world'});  

Este código es equivalente al código anterior:This code is equivalent to the code above:

context.log.info({hello: 'world'});  

Este código escribe en la consola en el nivel de seguimiento de error:This code writes to the console at the error level:

context.log.error("An error has occurred.");  

Dado que error es el nivel de seguimiento más alto, este seguimiento se escribe en la salida en todos los niveles de seguimiento, siempre y cuando el registro esté habilitado.Because error is the highest trace level, this trace is written to the output at all trace levels as long as logging is enabled.

Todos los métodos context.log admiten el mismo formato de parámetro que el método util.format de Node.js.All context.log methods support the same parameter format that's supported by the Node.js util.format method. Considere el siguiente código que escribe registros de función mediante el nivel de seguimiento predeterminado:Consider the following code, which writes function logs by using the default trace level:

context.log('Node.js HTTP trigger function processed a request. RequestUri=' + req.originalUrl);
context.log('Request Headers = ' + JSON.stringify(req.headers));

También puede escribir el mismo código con el formato siguiente:You can also write the same code in the following format:

context.log('Node.js HTTP trigger function processed a request. RequestUri=%s', req.originalUrl);
context.log('Request Headers = ', JSON.stringify(req.headers));

Configuración del nivel de seguimiento para el registro de la consolaConfigure the trace level for console logging

Functions 1.x permite definir el nivel de seguimiento de umbral para escribir en la consola, que facilita el control de la forma en que se escriben los seguimientos en la consola desde la función.Functions 1.x lets you define the threshold trace level for writing to the console, which makes it easy to control the way traces are written to the console from your function. Para establecer el umbral para todos los seguimientos que se escriben en la consola, use la propiedad tracing.consoleLevel en el archivo host.json .To set the threshold for all traces written to the console, use the tracing.consoleLevel property in the host.json file. Esta configuración se aplica a todas las funciones de Function App.This setting applies to all functions in your function app. En el ejemplo siguiente se establece el umbral de seguimiento para habilitar el registro detallado:The following example sets the trace threshold to enable verbose logging:

{
    "tracing": {
        "consoleLevel": "verbose"
    }
}  

Los valores de consoleLevel corresponden a los nombres de los métodos context.log.Values of consoleLevel correspond to the names of the context.log methods. Para deshabilitar todos los registros de seguimiento en la consola, establezca consoleLevel en off.To disable all trace logging to the console, set consoleLevel to off. Para más información, consulte la referencia sobre host.json.For more information, see host.json reference.

Desencadenadores y enlaces HTTPHTTP triggers and bindings

Los desencadenadores HTTP y de webhook trigger y los enlaces de salida HTTP usan objetos de solicitud y respuesta para representar la mensajería HTTP.HTTP and webhook triggers and HTTP output bindings use request and response objects to represent the HTTP messaging.

Objeto de solicitudRequest object

El objeto context.req (solicitud) tiene las siguientes propiedades:The context.req (request) object has the following properties:

PropiedadProperty DESCRIPCIÓNDescription
bodybody Objeto que contiene el cuerpo de la solicitud.An object that contains the body of the request.
headersheaders Objeto que contiene los encabezados de la solicitud.An object that contains the request headers.
methodmethod Método HTTP de la solicitud.The HTTP method of the request.
originalUrloriginalUrl Dirección URL de la solicitud.The URL of the request.
paramsparams Objeto que contiene los parámetros de enrutamiento de la solicitud.An object that contains the routing parameters of the request.
queryquery Objeto que contiene los parámetros de consulta.An object that contains the query parameters.
rawBodyrawBody Cuerpo del mensaje como una cadena.The body of the message as a string.

Objeto de respuestaResponse object

El objeto context.res (respuesta) tiene las siguientes propiedades:The context.res (response) object has the following properties:

PropiedadProperty DESCRIPCIÓNDescription
bodybody Objeto que contiene el cuerpo de la respuesta.An object that contains the body of the response.
headersheaders Objeto que contiene los encabezados de la respuesta.An object that contains the response headers.
isRawisRaw Indica que se omite el formato en la respuesta.Indicates that formatting is skipped for the response.
estadostatus Código de estado HTTP de la respuesta.The HTTP status code of the response.

Acceso a solicitudes y respuestasAccessing the request and response

Cuando se trabaja con desencadenadores HTTP, hay varias maneras de acceder a los objetos de solicitud y respuesta HTTP:When you work with HTTP triggers, you can access the HTTP request and response objects in a number of ways:

  • Desde las propiedades req y res del objeto context.From req and res properties on the context object. De esta manera, puede usar el patrón convencional para acceder a los datos HTTP desde el objeto de contexto, en lugar de tener que utilizar el patrón context.bindings.name completo.In this way, you can use the conventional pattern to access HTTP data from the context object, instead of having to use the full context.bindings.name pattern. En el ejemplo siguiente se muestra cómo acceder a los objetos req y res en context:The following example shows how to access the req and res objects on the context:

    // You can access your http request off the context ...
    if(context.req.body.emoji === ':pizza:') context.log('Yay!');
    // and also set your http response
    context.res = { status: 202, body: 'You successfully ordered more coffee!' }; 
    
  • Desde los enlaces de entrada y salida con nombre.From the named input and output bindings. De esta manera, el desencadenador HTTP y los enlaces funcionan igual que cualquier otro enlace.In this way, the HTTP trigger and bindings work the same as any other binding. En el ejemplo siguiente se establece el objeto de respuesta mediante un enlace response con nombre:The following example sets the response object by using a named response binding:

    {
        "type": "http",
        "direction": "out",
        "name": "response"
    }
    
    context.bindings.response = { status: 201, body: "Insert succeeded." };
    
  • ** [Solo respuesta] Llamando a context.res.send(body?: any).**[Response only] By calling context.res.send(body?: any). Se crea una respuesta HTTP con la entrada body como cuerpo de la respuesta.An HTTP response is created with input body as the response body. Se llama a context.done() implícitamente.context.done() is implicitly called.

  • ** [Solo respuesta] Llamando a context.done().**[Response only] By calling context.done(). Un tipo especial de enlace HTTP que devuelve la respuesta que se pasa al método context.done().A special kind of HTTP binding returns the response that is passed to the context.done() method. El enlace de salida HTTP siguiente define un parámetro de salida $return:The following HTTP output binding defines a $return output parameter:

    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    }
    
     // Define a valid response object.
    res = { status: 201, body: "Insert succeeded." };
    context.done(null, res);   
    

Versión de NodeNode version

En la tabla siguiente se muestra la versión de Node.js que se usa en cada versión principal del entorno de tiempo de ejecución de Functions:The following table shows the Node.js version used by each major version of the Functions runtime:

Versión de FunctionsFunctions version Versión de Node.jsNode.js version
1.x1.x 6.11.2 (bloqueado por el entorno de tiempo de ejecución)6.11.2 (locked by the runtime)
2.x2.x Active LTS y las versiones actuales de Node.js con la numeración correspondiente (se recomienda 8.11.1 y 10.14.1).Active LTS and even-numbered Current Node.js versions (8.11.1 and 10.14.1 recommended). Establezca la versión con la configuración de aplicación WEBSITE_NODE_DEFAULT_VERSION.Set the version by using the WEBSITE_NODE_DEFAULT_VERSION app setting.

Puede ver la versión actual que el entorno de tiempo de ejecución usa consultando la configuración de aplicación anterior o mediante la impresión de process.version desde cualquier función.You can see the current version that the runtime is using by checking the above app setting or by printing process.version from any function.

Administración de dependenciasDependency management

Para poder utilizar bibliotecas de la comunidad en el código de JavaScript, como se muestra en el ejemplo siguiente, debe asegurarse de que todas las dependencias estén instaladas en Function App en Azure.In order to use community libraries in your JavaScript code, as is shown in the below example, you need to ensure that all dependencies are installed on your Function App in Azure.

// Import the underscore.js library
var _ = require('underscore');
var version = process.version; // version === 'v6.5.0'

module.exports = function(context) {
    // Using our imported underscore.js library
    var matched_names = _
        .where(context.bindings.myInput.names, {first: 'Carla'});

Nota

Debe definir un archivo package.json en la raíz de Function App.You should define a package.json file at the root of your Function App. La definición del archivo permite que todas las funciones de la aplicación compartan los mismos paquetes almacenados en caché, de tal manera que se ofrece el mejor rendimiento.Defining the file lets all functions in the app share the same cached packages, which gives the best performance. Cuando hay conflictos con una versión, puede resolverlo mediante la adición de un archivo package.json en la carpeta de una función específica.If a version conflict arises, you can resolve it by adding a package.json file in the folder of a specific function.

Al implementar aplicaciones de función desde el control de código fuente, cualquier archivo package.json presente en el repositorio desencadenará un elemento npm install en su carpeta durante la implementación.When deploying Function Apps from source control, any package.json file present in your repo, will trigger an npm install in its folder during deployment. Sin embargo, al implementarlas mediante el portal o la CLI, tendrá que instalar los paquetes manualmente.But when deploying via the Portal or CLI, you will have to manually install the packages.

Hay dos maneras de instalar paquetes en Function App:There are two ways to install packages on your Function App:

Implementación con dependenciasDeploying with Dependencies

  1. Instale todos los paquetes necesarios localmente mediante la ejecución de npm install.Install all requisite packages locally by running npm install.

  2. Implemente el código y asegúrese de que la carpeta node_modules se incluye en la implementación.Deploy your code, and ensure that the node_modules folder is included in the deployment.

Mediante KuduUsing Kudu

  1. Vaya a https://<function_app_name>.scm.azurewebsites.net.Go to https://<function_app_name>.scm.azurewebsites.net.

  2. Haga clic en Consola de depuración > CMD.Click Debug Console > CMD.

  3. Vaya a D:\home\site\wwwroot y luego arrastre el archivo package.json a la carpeta wwwroot en la mitad superior de la página.Go to D:\home\site\wwwroot, and then drag your package.json file to the wwwroot folder at the top half of the page.
    También puede cargar archivos en Function App de otras formas.You can upload files to your function app in other ways also. Para obtener más información, vea Actualización de los archivos de aplicación de función.For more information, see How to update function app files.

  4. Una vez cargado el archivo package.json, ejecute el comandonpm install en la consola de ejecución remota de Kudu.After the package.json file is uploaded, run the npm install command in the Kudu remote execution console.
    Esta acción descarga los paquetes indicados en el archivo package.json y se reinicia Function App.This action downloads the packages indicated in the package.json file and restarts the function app.

Variables de entornoEnvironment variables

En Functions, la configuración de la aplicación, como las cadenas de conexión del servicio, se exponen como variables de entorno durante la ejecución.In Functions, app settings, such as service connection strings, are exposed as environment variables during execution. Puede tener acceso a estas opciones mediante process.env, como se muestra en la segunda y terceros llamadas a context.log() donde se inicie la AzureWebJobsStorage y WEBSITE_SITE_NAME variables de entorno:You can access these settings using process.env, as shown here in the second and third calls to context.log() where we log the AzureWebJobsStorage and WEBSITE_SITE_NAME environment variables:

module.exports = async function (context, myTimer) {
    var timeStamp = new Date().toISOString();

    context.log('Node.js timer trigger function ran!', timeStamp);
    context.log("AzureWebJobsStorage: " + process.env["AzureWebJobsStorage"]);
    context.log("WEBSITE_SITE_NAME: " + process.env["WEBSITE_SITE_NAME"]);
};

Hay varias maneras de agregar, actualizar y eliminar opciones de configuración de la aplicación de función:There are several ways that you can add, update, and delete function app settings:

Cuando se ejecuta localmente, la configuración de la aplicación se lee desde el archivo del proyecto local.settings.json.When running locally, app settings are read from the local.settings.json project file.

Configuración del punto de entrada de la funciónConfigure function entry point

Las propiedades de function.json scriptFile y entryPoint pueden usarse para configurar la ubicación y el nombre de la función exportada.The function.json properties scriptFile and entryPoint can be used to configure the location and name of your exported function. Estas propiedades pueden ser importantes si se transpila el código JavaScript.These properties can be important when your JavaScript is transpiled.

Uso de scriptFileUsing scriptFile

De forma predeterminada, se ejecuta una función de JavaScript desde index.js, un archivo que comparte el mismo directorio primario que su archivo function.json correspondiente.By default, a JavaScript function is executed from index.js, a file that shares the same parent directory as its corresponding function.json.

scriptFile se puede usar para obtener una estructura de carpetas que tenga el aspecto del ejemplo siguiente:scriptFile can be used to get a folder structure that looks like the following example:

FunctionApp
 | - host.json
 | - myNodeFunction
 | | - function.json
 | - lib
 | | - sayHello.js
 | - node_modules
 | | - ... packages ...
 | - package.json

function.json para myNodeFunction debe incluir una propiedad scriptFile que señala al archivo con la función exportada que ejecutar.The function.json for myNodeFunction should include a scriptFile property pointing to the file with the exported function to run.

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

Uso de entryPointUsing entryPoint

En scriptFile (o index.js), una función debe exportarse con module.exports para que se pueda encontrar y ejecutar.In scriptFile (or index.js), a function must be exported using module.exports in order to be found and run. De forma predeterminada, la función que se ejecuta cuando se desencadena es la única exportación de ese archivo, la exportación denominada run o la exportación denominada index.By default, the function that executes when triggered is the only export from that file, the export named run, or the export named index.

Se puede configurar mediante entryPoint en function.json, como en el ejemplo siguiente:This can be configured using entryPoint in function.json, as in the following example:

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

En Functions 2.x, que admite el parámetro this en funciones de usuario, el código de la función podría ser similar al del ejemplo siguiente:In Functions v2.x, which supports the this parameter in user functions, the function code could then be as in the following example:

class MyObj {
    constructor() {
        this.foo = 1;
    };

    logFoo(context) { 
        context.log("Foo is " + this.foo); 
        context.done(); 
    }
}

const myObj = new MyObj();
module.exports = myObj;

En este ejemplo, es importante tener en cuenta que aunque se exporta un objeto, no hay ninguna garantía para conservar el estado entre ejecuciones.In this example, it is important to note that although an object is being exported, there are no guarantees for preserving state between executions.

Depuración localLocal Debugging

Cuando se inicia con la --inspect parámetro, un proceso de Node.js escucha para un cliente de depuración en el puerto especificado.When started with the --inspect parameter, a Node.js process listens for a debugging client on the specified port. En Azure Functions 2.x, puede especificar argumentos para pasar el proceso de Node.js que se ejecuta el código mediante la adición de la variable de entorno o configuración de la aplicación languageWorkers:node:arguments = <args>.In Azure Functions 2.x, you can specify arguments to pass into the Node.js process that runs your code by adding the environment variable or App Setting languageWorkers:node:arguments = <args>.

Para depurar de forma local, agregue "languageWorkers:node:arguments": "--inspect=5858" en Values en su local.settings.json de archivos y adjuntar un depurador al puerto 5858.To debug locally, add "languageWorkers:node:arguments": "--inspect=5858" under Values in your local.settings.json file and attach a debugger to port 5858.

Al depurar con VS Code, la --inspect parámetro se agrega automáticamente mediante el port valor en el archivo del proyecto launch.json.When debugging using VS Code, the --inspect parameter is automatically added using the port value in the project's launch.json file.

En la versión 1.x, establecer languageWorkers:node:arguments no funcionará.In version 1.x, setting languageWorkers:node:arguments will not work. Se puede seleccionar el puerto de depuración con el --nodeDebugPort parámetro en Azure Functions Core Tools.The debug port can be selected with the --nodeDebugPort parameter on Azure Functions Core Tools.

TypeScriptTypeScript

Cuando el destino versión 2.x de Functions runtime, ambos Azure Functions para Visual Studio Code y Azure Functions Core Tools le permiten crear aplicaciones de función mediante una plantilla que admiten Proyectos de aplicación de función de TypeScript.When you target version 2.x of the Functions runtime, both Azure Functions for Visual Studio Code and the Azure Functions Core Tools let you create function apps using a template that support TypeScript function app projects. La plantilla genera package.json y tsconfig.json archivos de proyecto que resulte más fácil para transpilar, ejecutar y publicar las funciones de JavaScript desde el código de TypeScript con estas herramientas.The template generates package.json and tsconfig.json project files that make it easier to transpile, run, and publish JavaScript functions from TypeScript code with these tools.

Una generada .funcignore archivo se usa para indicar qué archivos se excluyen cuando se publica un proyecto en Azure.A generated .funcignore file is used to indicate which files are excluded when a project is published to Azure.

Archivos de TypeScript (TS) están transpilado a archivos JavaScript (.js) en el dist directorio de salida.TypeScript files (.ts) are transpiled into JavaScript files (.js) in the dist output directory. Usan plantillas de TypeScript el scriptFile parámetro en function.json para indicar la ubicación del archivo .js correspondiente en el dist carpeta.TypeScript templates use the scriptFile parameter in function.json to indicate the location of the corresponding .js file in the dist folder. La ubicación de salida se establece mediante la plantilla mediante outDir parámetro en el tsconfig.json archivo.The output location is set by the template by using outDir parameter in the tsconfig.json file. Si cambia esta configuración o el nombre de la carpeta, el tiempo de ejecución no es capaz de encontrar el código que se ejecutará.If you change this setting or the name of the folder, the runtime is not able to find the code to run.

Nota

Compatibilidad experimental con TypeScript existe versión 1.x de Functions runtime.Experimental support for TypeScript exists version 1.x of the Functions runtime. Los archivos de TypeScript en archivos de JavaScript cuando se invoca la función de versión experimental transpiles.The experimental version transpiles TypeScript files into JavaScript files when the function is invoked. En la versión 2.x, esta compatibilidad experimental se ha sustituido por el método controlado por la herramienta que no transpilación antes de que se inicializa el host y durante el proceso de implementación.In version 2.x, this experimental support has been superseded by the tool-driven method that does transpilation before the host is initialized and during the deployment process.

La manera en que desarrolla e implementa desde un proyecto de TypeScript localmente depende de la herramienta de desarrollo.The way that you locally develop and deploy from a TypeScript project depends on your development tool.

Visual Studio CodeVisual Studio Code

El Azure Functions para Visual Studio Code extensión le permite desarrollar las funciones con TypeScript.The Azure Functions for Visual Studio Code extension lets you develop your functions using TypeScript. Core Tools es un requisito de la extensión de Azure Functions.The Core Tools is a requirement of the Azure Functions extension.

Para crear una aplicación de función de TypeScript en Visual Studio Code, basta con elegir TypeScript al crear una aplicación de función y se le pide que elija el idioma.To create a TypeScript function app in Visual Studio Code, you simply choose TypeScript when you create a function app and are asked to choose the language.

Al presionar F5 para ejecutar la aplicación localmente, transpilación se realiza antes de inicializa el host (func.exe).When you press F5 to run the app locally, transpilation is done before the host (func.exe) is initialized.

Al implementar la aplicación de función en Azure mediante el implementar en la aplicación de función... botón, la extensión de Azure Functions genera primero una compilación lista para producción de archivos JavaScript desde los archivos de origen de TypeScript.When you deploy your function app to Azure using the Deploy to function app... button, the Azure Functions extension first generates a production-ready build of JavaScript files from the TypeScript source files.

Azure Functions Core ToolsAzure Functions Core Tools

Para crear un proyecto de aplicación de función de TypeScript con herramientas de Core, debe especificar la opción de lenguaje typescript al crear la aplicación de función.To create a TypeScript function app project using Core Tools, you must specify the typescript language option when you create your function app. Puede hacerlo en una de las maneras siguientes:You can do this in one of the following ways:

  • Ejecute el func init comandos, seleccione node como la pila de lenguaje y, a continuación, seleccione typescript.Run the func init command, select node as your language stack, and then select typescript.

  • Ejecute el comando func init --worker-runtime typescript.Run the func init --worker-runtime typescript command.

Para ejecutar el código de aplicación de función localmente mediante herramientas de Core, use el npm start comando, en lugar de func host start.To run your function app code locally using Core Tools, use the npm start command, instead of func host start. El npm start comando es equivalente a los siguientes comandos:The npm start command is equivalent to the following commands:

  • npm run build
  • func extensions install
  • tsc
  • func start

Antes de usar el func azure functionapp publish de comandos para implementar en Azure, primero debe ejecutar el npm run build:production comando.Before you use the func azure functionapp publish command to deploy to Azure, you must first run the npm run build:production command. Este comando crea una compilación lista para producción de archivos JavaScript desde los archivos de origen de TypeScript que se pueden implementar mediante func azure functionapp publish .This command creates a production-ready build of JavaScript files from the TypeScript source files that can be deployed using func azure functionapp publish.

Consideraciones para las funciones de JavaScriptConsiderations for JavaScript functions

Cuando se trabaja con las funciones de JavaScript, tenga en cuenta las consideraciones de las secciones siguientes.When you work with JavaScript functions, be aware of the considerations in the following sections.

Elección de los planes de App Service de una sola vCPUChoose single-vCPU App Service plans

Al crear una aplicación de función que usa el plan de App Service, se recomienda que seleccione un plan de una sola vCPU, en lugar de un plan con varias vCPU.When you create a function app that uses the App Service plan, we recommend that you select a single-vCPU plan rather than a plan with multiple vCPUs. En la actualidad, Functions ejecuta funciones de JavaScript con más eficacia en VM con una sola vCPU; el uso de máquinas virtuales más grandes no produce las mejoras de rendimiento esperadas.Today, Functions runs JavaScript functions more efficiently on single-vCPU VMs, and using larger VMs does not produce the expected performance improvements. Cuando sea necesario, manualmente, puede escalar horizontalmente agregando más instancias de máquina virtual única vCPU, o puede habilitar el escalado automático.When necessary, you can manually scale out by adding more single-vCPU VM instances, or you can enable autoscale. Para obtener más información, consulte Escalación del recuento de instancias de forma manual o automática.For more information, see Scale instance count manually or automatically.

Arranque en fríoCold Start

Al desarrollar Azure Functions en el modelo de hospedaje sin servidor, los arranques en frío son una realidad.When developing Azure Functions in the serverless hosting model, cold starts are a reality. Arranque en frío hace referencia al hecho de que cuando se inicia Function App por primera vez tras un período de inactividad, tarda más tiempo en iniciarse.Cold start refers to the fact that when your function app starts for the first time after a period of inactivity, it takes longer to start up. Especialmente para las funciones de JavaScript con árboles de dependencias de gran tamaño, el arranque en frío puede ser importante.For JavaScript functions with large dependency trees in particular, cold start can be significant. Para acelerar el proceso de arranque en frío, ejecute sus funciones como un archivo de paquete cuando sea posible.To speed up the cold start process, run your functions as a package file when possible. Muchos métodos de implementación utilizan el modelo de ejecución desde paquete de forma predeterminada, pero si experimenta arranques en frío prolongados y no ejecuta sus funciones de este modo, este cambio puede mejorar la situación considerablemente.Many deployment methods use the run from package model by default, but if you're experiencing large cold starts and are not running this way, this change can offer a significant improvement.

Límites de conexionesConnection Limits

Cuando se usa un cliente específico de servicio en una aplicación de Azure Functions, no cree a un nuevo cliente con cada invocación de función.When you use a service-specific client in an Azure Functions application, don't create a new client with every function invocation. En su lugar, cree a un cliente único y estático en el ámbito global.Instead, create a single, static client in the global scope. Para obtener más información, consulte administrar conexiones en Azure Functions.For more information, see managing connections in Azure Functions.

Pasos siguientesNext steps

Para obtener más información, consulte los siguientes recursos:For more information, see the following resources: