Guide des développeurs JavaScript sur Azure FunctionsAzure Functions JavaScript developer guide

Ce guide contient des informations détaillées qui vous permettront de développer des fonctions Azure à l’aide de JavaScript.This guide contains detailed information to help you succeed developing Azure Functions using JavaScript.

Si vous êtes développeur Express.js, Node.js ou JavaScript et que vous débutez avec Azure Functions, lisez d’abord l’un des articles suivants :As an Express.js, Node.js, or JavaScript developer, if you are new to Azure Functions, please consider first reading one of the following articles:

Prise en mainGetting started ConceptsConcepts Apprentissage guidéGuided learning

Principes de base sur les fonctions JavaScriptJavaScript function basics

Une fonction JavaScript (Node.js) est une function exportée qui s’exécute quand elle est déclenchée (les déclencheurs sont configurés dans function.json).A JavaScript (Node.js) function is an exported function that executes when triggered (triggers are configured in function.json). Le premier argument transmis à chaque fonction à un objet context qui est utilisé pour la réception et l’envoi des données de liaison, la journalisation et la communication avec le runtime.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.

Structure de dossiersFolder structure

La structure de dossiers requise pour un projet JavaScript est similaire à la structure ci-après.The required folder structure for a JavaScript project looks like the following. Cette valeur par défaut peut être modifiée.This default can be changed. Pour plus d’informations, consultez la section scriptFileci-dessous.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

À la racine du projet se trouve un fichier host.json partagé que vous pouvez utiliser pour configurer l’application de fonction.At the root of the project, there's a shared host.json file that can be used to configure the function app. Chaque fonction a un dossier avec ses propres fichier de code (.js) et fichier de configuration de liaison (function.json).Each function has a folder with its own code file (.js) and binding configuration file (function.json). Le nom du répertoire parent de function.json est toujours le nom de votre fonction.The name of function.json's parent directory is always the name of your function.

Les extensions de liaison requises dans la version 2.x du runtime Functions sont définies dans le fichier extensions.csproj, les fichiers de bibliothèque proprement dits se trouvant dans le dossier 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. Quand vous développez localement, vous devez inscrire les extensions de liaison.When developing locally, you must register binding extensions. Quand vous développez des fonctions dans le portail Azure, cet enregistrement est effectué pour vous.When developing functions in the Azure portal, this registration is done for you.

Exporter une fonctionExporting a function

Les fonctions JavaScript doivent être exportées au moyen de module.exports (ou exports).JavaScript functions must be exported via module.exports (or exports). Votre fonction exportée doit être une fonction JavaScript qui s’exécute quand elle est déclenchée.Your exported function should be a JavaScript function that executes when triggered.

Par défaut, le runtime Functions recherche votre fonction dans index.js, où index.js partage le même répertoire parent en tant que function.json correspondant.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. Dans le cas par défaut, votre fonction exportée doit être la seule exportation à partir de son fichier ou l’export nommé run ou index.In the default case, your exported function should be the only export from its file or the export named run or index. Pour configurer l’emplacement de fichier et le nom d’exportation de votre fonction, consultez les informations relatives à la configuration du point d’entrée de votre fonction plus loin.To configure the file location and export name of your function, read about configuring your function's entry point below.

Votre fonction exportée doit valider un certain nombre d’arguments à l’exécution.Your exported function is passed a number of arguments on execution. Le premier argument est toujours un objet context.The first argument it takes is always a context object. Si votre fonction est synchrone (ne retourne pas un objet Promise), vous devez valider l’objet context, car il est obligatoire d’appeler context.done pour une utilisation correcte.If your function is synchronous (doesn't 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();
};

Exportation d’une fonction asynchroneExporting an async function

Quand vous utilisez la déclaration async function ou l’objet Promises JavaScript simple dans la version 2.x du runtime Functions, vous n’avez pas besoin d’appeler explicitement le rappel context.done pour signaler que votre fonction s’est exécutée.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. Votre fonction s’exécute en même temps que l’exécution de la fonction asynchrone/l’objet Promise exporté.Your function completes when the exported async function/Promise completes. Pour les fonctions ciblant le runtime version 1.x, vous devez toujours appeler context.done lorsque votre code a terminé de s’exécuter.For functions targeting the version 1.x runtime, you must still call context.done when your code is done executing.

L’exemple suivant est une fonction simple qui enregistre qu’elle a été déclenchée et dont l’exécution se termine immédiatement.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.');
};

Quand vous exportez une fonction asynchrone, vous pouvez également configurer une liaison de sortie avec la valeur return.When exporting an async function, you can also configure an output binding to take the return value. Cette approche est recommandée si vous n’avez qu’une seule liaison de sortie.This is recommended if you only have one output binding.

Pour assigner une sortie en utilisant return, remplacez la propriété name par $return dans function.json.To assign an output using return, change the name property to $return in function.json.

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

Dans ce cas, votre fonction doit ressembler à l'exemple suivant :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!"
    };
}

LiaisonsBindings

Dans JavaScript, les liaisons sont configurées et définies dans le fichier function.json d’une fonction.In JavaScript, bindings are configured and defined in a function's function.json. Les fonctions interagissent avec des liaisons de plusieurs façons.Functions interact with bindings a number of ways.

EntréesInputs

Les entrées sont réparties en deux catégories dans Azure Functions : l’une correspond à l’entrée du déclencheur et l’autre, à l’entrée supplémentaire.Input are divided into two categories in Azure Functions: one is the trigger input and the other is the additional input. Le déclencheur et autres liaisons d’entrée (liaisons de direction === "in") peuvent être lus par une fonction de trois façons :Trigger and other input bindings (bindings of direction === "in") can be read by a function in three ways:

  • [Recommandé] En tant que paramètres transmis à votre fonction.[Recommended] As parameters passed to your function. Elles sont transmises à la fonction dans l’ordre dans lequel elles sont définies dans le fichier function.json.They are passed to the function in the same order that they are defined in function.json. La propriété name définie dans function.json n’a pas besoin de correspondre au nom de votre paramètre, même si c’est conseillé.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) { ... };
    
  • En tant que membres de l’objet context.bindings.As members of the context.bindings object. Chaque membre est nommé par la propriété name définie dans 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);
    };
    
  • En tant qu’entrées à l’aide de l’objet arguments JavaScript.As inputs using the JavaScript arguments object. Cette approche revient pratiquement au même que la transmission des entrées en tant que paramètres, mais elle vous permet de gérer des entrées de manière dynamique.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]);
    };
    

SortiesOutputs

Une fonction peut écrire des données dans les sorties (liaisons de direction === "out") de plusieurs façons.Outputs (bindings of direction === "out") can be written to by a function in a number of ways. Dans tous les cas, la propriété name de la liaison, comme définie dans function.json correspond au nom du membre d’objet faisant l’objet d’une écriture dans votre fonction.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.

Vous pouvez assigner des données aux liaisons de sortie de l’une des manières suivantes (ne combinez pas ces méthodes) :You can assign data to output bindings in one of the following ways (don't combine these methods):

  • [Recommandé pour plusieurs sorties] Retourner un objet.[Recommended for multiple outputs] Returning an object. Si vous utilisez une fonction de retour async/Promise, vous pouvez retourner un objet avec des données de sortie assignées.If you are using an async/Promise returning function, you can return an object with assigned output data. Dans l’exemple ci-dessous, les liaisons de sortie sont nommées « httpResponse » et « queueOutput » dans 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 vous utilisez une fonction synchrone, vous pouvez retourner cet objet à l’aide de context.done (voir l’exemple).If you are using a synchronous function, you can return this object using context.done (see example).

  • [Recommandé en cas de sortie unique] Retourner une valeur directement et utiliser le nom de la liaison $return.[Recommended for single output] Returning a value directly and using the $return binding name. Cela fonctionne uniquement pour les fonctions de retour async/Promise.This only works for async/Promise returning functions. Voir l’exemple dans l’exportation en tant que fonction asynchrone.See example in exporting an async function.

  • Assigner des valeurs à context.bindings Vous pouvez affecter des valeurs directement à 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;
    };
    

Type de données de liaisonsBindings data type

Pour définir le type de données pour une liaison d’entrée, utilisez la propriété dataType dans la définition de la liaison.To define the data type for an input binding, use the dataType property in the binding definition. Par exemple, pour lire le contenu d’une requête HTTP au format binaire, utilisez le type 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"
}

Les options pour dataType sont binary, stream et string.Options for dataType are: binary, stream, and string.

Objet de contextecontext object

Le runtime utilise un objet context pour transmettre des données vers et à partir de votre fonction et du runtime.The runtime uses a context object to pass data to and from your function and the runtime. Utilisé pour lire et définir les données de liaisons et pour écrire dans des journaux, l’objet context est toujours le premier paramètre à être transmis à une fonction.Used to read and set data from bindings and for writing to logs, the context object is always the first parameter passed to a function.

Pour les fonctions présentant du code synchrone, l’objet de contexte comprend le rappel done que vous appelez quand le traitement de la fonction est terminé.For functions featuring synchronous code, the context object includes the done callback which you call when the function is done processing. Il n’est pas nécessaire d’appeler explicitement done pendant l’écriture de code asynchrone ; le rappel done est appelé implicitement.Explicitly calling done is unnecessary when writing asynchronous code; the done callback is called implicitly.

module.exports = (context) => {

    // function logic goes here

    context.log("The function has executed.");

    context.done();
};

Le contexte transmis à votre fonction expose une propriété executionContext, qui est un objet avec les propriétés suivantes :The context passed into your function exposes an executionContext property, which is an object with the following properties:

Nom de la propriétéProperty name TypeType DescriptionDescription
invocationId StringString Fournit un identificateur unique pour l’appel de fonction spécifique.Provides a unique identifier for the specific function invocation.
functionName StringString Fournit le nom de la fonction en cours d’exécution.Provides the name of the running function
functionDirectory StringString Fournit le répertoire de l’application Functions.Provides the functions app directory.

L'exemple suivant montre comment retourner invocationId.The following example shows how to return the invocationId.

module.exports = (context, req) => {
    context.res = {
        body: context.executionContext.invocationId
    };
    context.done();
};

Propriété context.bindingscontext.bindings property

context.bindings

Retourne un objet nommé qui est utilisé pour lire ou attribuer des données de liaison.Returns a named object that is used to read or assign binding data. Les données de liaison d’entrée et de déclencheur sont accessibles en consultant les propriétés sur context.bindings.Input and trigger binding data can be accessed by reading properties on context.bindings. Des données de liaison de sortie peuvent être attribuées en ajoutant des données à context.bindingsOutput binding data can be assigned by adding data to context.bindings

Par exemple, les définitions de liaison suivantes dans votre function.json vous permettent d’accéder au contenu d’une file d’attente à partir de l’objet context.bindings.myInput et d’assigner des sorties à une file d’attente à l’aide de 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 };

Vous pouvez choisir de définir les données de liaison de sortie à l’aide de la méthode context.done au lieu de l’objet context.binding (voir ci-dessous).You can choose to define output binding data using the context.done method instead of the context.binding object (see below).

Propriété context.bindingDatacontext.bindingData property

context.bindingData

Retourne un objet nommé qui contient les métadonnées de déclencheur et les données d’appel de fonction (invocationId, sys.methodName, sys.utcNow, sys.randGuid).Returns a named object that contains trigger metadata and function invocation data (invocationId, sys.methodName, sys.utcNow, sys.randGuid). Pour obtenir un exemple de métadonnées de déclencheur, consultez cet exemple de hubs d’événement.For an example of trigger metadata, see this event hubs example.

Méthode context.donecontext.done method

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

Permet au runtime de savoir que votre code s’est exécuté.Lets the runtime know that your code has completed. Lorsque votre fonction utilise la déclaration async function, vous n’avez pas besoin d’utiliser context.done().When your function uses the async function declaration, you do not need to use context.done(). Le rappel context.done est appelé de manière implicite.The context.done callback is implicitly called. Les fonctions asynchrones sont disponibles dans Node 8 ou version ultérieure, qui nécessite la version 2.x du runtime Functions.Async functions are available in Node 8 or a later version, which requires version 2.x of the Functions runtime.

Si votre fonction n’est pas une fonction asynchrone, vous devez appeler context.done pour indiquer au runtime que votre fonction est complète.If your function is not an async function, you must call context.done to inform the runtime that your function is complete. Sinon, l’exécution arrive à expiration.The execution times out if it is missing.

La méthode context.done vous permet de transmettre à la fois une erreur définie par l’utilisateur au runtime et un objet JSON contenant les données de liaison de sortie.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. Les propriétés transmises à context.done remplacent tout ce qui est défini sur l’objet 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éthode context.logcontext.log method

context.log(message)

Vous permet d’écrire dans les journaux d’activité de fonction de streaming au niveau de trace par défaut, avec d’autres niveaux de journalisation disponibles.Allows you to write to the streaming function logs at the default trace level, with other logging levels available. La journalisation du suivi est décrite en détail dans la section suivante.Trace logging is described in detail in the next section.

Écrire la sortie de trace dans les journauxWrite trace output to logs

Dans Functions, vous utilisez les méthodes context.log pour écrire la sortie de trace dans les journaux et la console.In Functions, you use the context.log methods to write trace output to the logs and the console. Lorsque vous appelez context.log(), votre message est écrit dans les journaux au niveau de trace par défaut, qui est le niveau de trace d’informations.When you call context.log(), your message is written to the logs at the default trace level, which is the info trace level. Functions s’intègre à Azure Application Insights pour mieux capturer les journaux de vos applications de fonction.Functions integrates with Azure Application Insights to better capture your function app logs. Application Insights, qui fait partie de Azure Monitor, fournit des fonctionnalités pour la collecte, le rendu visuel et l’analyse des données de télémétrie d’application et de vos sorties de trace.Application Insights, part of Azure Monitor, provides facilities for collection, visual rendering, and analysis of both application telemetry and your trace outputs. Pour en savoir plus, consultez Surveiller l’exécution des fonctions Azure.To learn more, see monitoring Azure Functions.

L’exemple suivant écrit un journal au niveau de la trace des informations, y compris l’ID d’appel :The following example writes a log at the info trace level, including the invocation ID:

context.log("Something has happened. " + context.invocationId); 

Toutes les méthodes context.log prennent en charge le même format de paramètre que celui pris en charge par la méthode util.format Node.js.All context.log methods support the same parameter format that's supported by the Node.js util.format method. Prenons le code suivant, qui écrit des journaux d’activité de fonction en utilisant le niveau de trace par défaut :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));

Vous pouvez écrire ce même code au format suivant :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));

Notes

N’utilisez pas console.log pour écrire des sorties de trace.Don't use console.log to write trace outputs. Étant donné que la sortie de console.log est capturée au niveau de l’application de la fonction, elle n’est pas liée à un appel de fonction spécifique et n’est pas affichée dans les journaux d’une fonction spécifique.Because output from console.log is captured at the function app level, it's not tied to a specific function invocation and isn't displayed in a specific function's logs. En outre, la version 1. x du runtime Functions ne prend pas en charge l’utilisation de console.log pour écrire dans la console.Also, version 1.x of the Functions runtime doesn't support using console.log to write to the console.

Niveaux de traceTrace levels

Outre le niveau par défaut, les méthodes de journalisation suivantes sont disponibles pour vous permettre d’écrire des journaux de fonctions à des niveaux de suivi spécifiques.In addition to the default level, the following logging methods are available that let you write function logs at specific trace levels.

MéthodeMethod DescriptionDescription
error(message)error(message) Écrit un événement au niveau de l’erreur dans les journaux.Writes an error-level event to the logs.
warn(message)warn(message) Écrit un événement de niveau avertissement dans les journaux.Writes a warning-level event to the logs.
info(message)info(message) Écrit dans la journalisation du niveau d’information, ou à un niveau inférieur.Writes to info level logging, or lower.
verbose(message)verbose(message) Écrit dans la journalisation du niveau détaillé.Writes to verbose level logging.

L’exemple suivant écrit le même journal au niveau de la trace d’avertissement, au lieu du niveau information :The following example writes the same log at the warning trace level, instead of the info level:

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

Étant donné que le niveau d’erreur constitue le niveau de trace le plus élevé, cette trace est écrite dans la sortie à tous les niveaux de trace tant que la journalisation est activée.Because error is the highest trace level, this trace is written to the output at all trace levels as long as logging is enabled.

Configurer le niveau de trace pour la journalisationConfigure the trace level for logging

Functions vous permet de définir le seuil de niveau de trace pour l’écriture dans les journaux ou la console.Functions lets you define the threshold trace level for writing to the logs or the console. Les paramètres de seuil spécifiques dépendent de votre version du runtime Functions.The specific threshold settings depend on your version of the Functions runtime.

Utilisez la propriété logging.logLevel dans le fichier host.json pour définir le seuil des traces écrites dans les journaux.To set the threshold for traces written to the logs, use the logging.logLevel property in the host.json file. Cet objet JSON vous permet de définir un seuil par défaut pour toutes les fonctions de votre application de fonction, et vous pouvez définir des seuils spécifiques pour les fonctions individuelles.This JSON object lets you define a default threshold for all functions in your function app, plus you can define specific thresholds for individual functions. Pour plus d’informations, consultez Comment configurer la surveillance de Azure Functions.To learn more, see How to configure monitoring for Azure Functions.

Enregistrer une télémétrie personnaliséeLog custom telemetry

Par défaut, Functions écrit la sortie en tant que traces dans Application Insights.By default, Functions writes output as traces to Application Insights. Pour plus de contrôle, vous pouvez utiliser à la place le kit de développement logiciel Application Insights node.js pour envoyer des données de télémétrie personnalisées à votre instance Application Insights.For more control, you can instead use the Application Insights Node.js SDK to send custom telemetry data to your Application Insights instance.

const appInsights = require("applicationinsights");
appInsights.setup();
const client = appInsights.defaultClient;

module.exports = function (context, req) {
    context.log('JavaScript HTTP trigger function processed a request.');

    // Use this with 'tagOverrides' to correlate custom telemetry to the parent function invocation.
    var operationIdOverride = {"ai.operation.id":context.traceContext.traceparent};

    client.trackEvent({name: "my custom event", tagOverrides:operationIdOverride, properties: {customProperty2: "custom property value"}});
    client.trackException({exception: new Error("handled exceptions can be logged with this method"), tagOverrides:operationIdOverride});
    client.trackMetric({name: "custom metric", value: 3, tagOverrides:operationIdOverride});
    client.trackTrace({message: "trace message", tagOverrides:operationIdOverride});
    client.trackDependency({target:"http://dbname", name:"select customers proc", data:"SELECT * FROM Customers", duration:231, resultCode:0, success: true, dependencyTypeName: "ZSQL", tagOverrides:operationIdOverride});
    client.trackRequest({name:"GET /customers", url:"http://myserver/customers", duration:309, resultCode:200, success:true, tagOverrides:operationIdOverride});

    context.done();
};

Le paramètre tagOverrides définit operation_Id sur l’ID d'appel de la fonction.The tagOverrides parameter sets the operation_Id to the function's invocation ID. Ce paramètre permet de mettre en corrélation toutes les données de télémétrie générées automatiquement et personnalisées pour un appel de fonction donné.This setting enables you to correlate all of the automatically generated and custom telemetry for a given function invocation.

Déclencheurs et liaisons HTTPHTTP triggers and bindings

Les déclencheurs HTTP et webhook ainsi que les liaisons de sortie HTTP utilisent les objets de requête et de réponse pour représenter la messagerie HTTP.HTTP and webhook triggers and HTTP output bindings use request and response objects to represent the HTTP messaging.

Objet RequêteRequest object

L’objet (de demande) context.req comporte les propriétés suivantes :The context.req (request) object has the following properties:

PropriétéProperty DescriptionDescription
bodybody Objet qui contient le corps de la demande.An object that contains the body of the request.
headersheaders Objet qui contient les en-têtes de la demande.An object that contains the request headers.
methodmethod Méthode HTTP de la demande.The HTTP method of the request.
originalUrloriginalUrl URL de la demande.The URL of the request.
paramsparams Objet qui contient les paramètres de routage de la demande.An object that contains the routing parameters of the request.
queryquery Objet qui contient les paramètres de la requête.An object that contains the query parameters.
rawBodyrawBody Corps du message en tant que chaîne.The body of the message as a string.

Objet RéponseResponse object

L’objet (de réponse) context.res comporte les propriétés suivantes :The context.res (response) object has the following properties:

PropriétéProperty DescriptionDescription
bodybody Objet qui contient le corps de la réponse.An object that contains the body of the response.
headersheaders Objet qui contient les en-têtes de la réponse.An object that contains the response headers.
isRawisRaw Indique que la mise en forme est ignorée pour la réponse.Indicates that formatting is skipped for the response.
statutstatus Code d’état HTTP de la réponse.The HTTP status code of the response.
cookiescookies Tableau d’objets cookie HTTP définis dans la réponse.An array of HTTP cookie objects that are set in the response. Un objet cookie HTTP possède un name, value et d’autres propriétés de cookie, comme maxAge ou sameSite.An HTTP cookie object has a name, value, and other cookie properties, such as maxAge or sameSite.

Accès à la demande et à la réponseAccessing the request and response

Quand vous utilisez des déclencheurs HTTP, de nombreuses méthodes vous permettent d’accéder à des objets de demande et de réponse HTTP :When you work with HTTP triggers, you can access the HTTP request and response objects in a number of ways:

  • À partir des propriétés req et res sur l’objet context.From req and res properties on the context object. Avec cette méthode, vous pouvez utiliser le modèle classique pour accéder aux données HTTP à partir de l’objet de contexte, au lieu d’utiliser le modèle context.bindings.name complet.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. L’exemple suivant montre comment accéder aux objets req et res sur 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!' }; 
    
  • À partir de des liaisons dites d’entrée et de sortie.From the named input and output bindings. Avec cette méthode, le déclencheur HTTP et les liaisons fonctionnent de la même manière que toute autre liaison.In this way, the HTTP trigger and bindings work the same as any other binding. L’exemple suivant définit l’objet de réponse en utilisant une liaison nommée response :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." };
    
  • [Réponse uniquement] En appelant context.res.send(body?: any).[Response only] By calling context.res.send(body?: any). Une réponse HTTP est créée avec l’entrée body comme corps de réponse.An HTTP response is created with input body as the response body. context.done() est appelé de manière implicite.context.done() is implicitly called.

  • [Réponse uniquement] En appelant context.done().[Response only] By calling context.done(). Un type spécial de liaison HTTP retourne la réponse transmise à la méthode context.done().A special type of HTTP binding returns the response that is passed to the context.done() method. La liaison de sortie HTTP suivante définit un paramètre de sortie $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);   
    

Mise à l’échelle et accès concurrentielScaling and concurrency

Par défaut, Azure Functions surveille automatiquement la charge sur votre application et crée des instances d’hôte supplémentaires pour Node.js, si nécessaire.By default, Azure Functions automatically monitors the load on your application and creates additional host instances for Node.js as needed. Functions utilise des seuils intégrés (non configurables par l’utilisateur) pour différents types de déclencheurs pour décider quand ajouter des instances, comme l’ancienneté des messages et la taille de la file d’attente pour QueueTrigger.Functions uses built-in (not user configurable) thresholds for different trigger types to decide when to add instances, such as the age of messages and queue size for QueueTrigger. Pour plus d’informations, consultez Fonctionnement des plans Consommation et Premium.For more information, see How the Consumption and Premium plans work.

Ce comportement de mise à l’échelle est suffisant pour de nombreuses applications Node.js.This scaling behavior is sufficient for many Node.js applications. Pour les applications utilisant le processeur de manière intensive, vous pouvez améliorer encore plus les performances en utilisant plusieurs processus Worker de langage.For CPU-bound applications, you can improve performance further by using multiple language worker processes.

Par défaut, chaque instance d’hôte Functions a un seul processus Worker de langage.By default, every Functions host instance has a single language worker process. Vous pouvez augmenter le nombre de processus Worker par hôte (jusqu’à 10) à l’aide du paramètre d’application FUNCTIONS_WORKER_PROCESS_COUNT.You can increase the number of worker processes per host (up to 10) by using the FUNCTIONS_WORKER_PROCESS_COUNT application setting. Azure Functions essaie ensuite de distribuer uniformément les appels de fonction simultanés à ces différents Workers.Azure Functions then tries to evenly distribute simultaneous function invocations across these workers.

FUNCTIONS_WORKER_PROCESS_COUNT s’applique à chaque hôte créé par Functions lors du scale-out de votre application pour répondre à la demande.The FUNCTIONS_WORKER_PROCESS_COUNT applies to each host that Functions creates when scaling out your application to meet demand.

Version de nœudNode version

Le tableau suivant présente les versions Node.js actuellement prises en charge pour chaque version majeure du runtime Functions, par système d’exploitation :The following table shows current supported Node.js versions for each major version of the Functions runtime, by operating system:

Version de FunctionsFunctions version Version de nœud (Windows)Node version (Windows) Version de nœud (Linux)Node Version (Linux)
3.x (version recommandée)3.x (recommended) ~14 (recommandé)~14 (recommended)
~12
~10
node|14 (recommandé)node|14 (recommended)
node|12
node|10
2.x2.x ~12
~10
~8
node|10
node|8
1.x1.x 6.11.2 (verrouillée par le runtime)6.11.2 (locked by the runtime) n/an/a

Vous pouvez voir la version que le runtime utilise en journalisant process.version depuis n’importe quelle fonction.You can see the current version that the runtime is using by logging process.version from any function.

Définition de la version de NodeSetting the Node version

Pour les applications de fonction Windows, ciblez la version dans Azure en définissant le paramètre d’application WEBSITE_NODE_DEFAULT_VERSION sur une version de LTS prise en charge, par exemple ~14.For Windows function apps, target the version in Azure by setting the WEBSITE_NODE_DEFAULT_VERSION app setting to a supported LTS version, such as ~14.

Pour les applications de fonction Linux, exécutez la commande Azure CLI suivante pour mettre à jour la version de Node.For Linux function apps, run the following Azure CLI command to update the Node version.

az functionapp config set --linux-fx-version "node|14" --name "<MY_APP_NAME>" --resource-group "<MY_RESOURCE_GROUP_NAME>"

Gestion des dépendancesDependency management

Pour utiliser les bibliothèques de communauté dans votre code JavaScript, comme indiqué dans l’exemple ci-dessous, vous devez vérifier que toutes les dépendances sont installées sur votre application de fonction dans 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'});

Notes

Vous devez définir un fichier package.json à la racine de votre application de fonction.You should define a package.json file at the root of your Function App. Cela permet à toutes les fonctions de l’application de partager les mêmes packages mis en cache, pour des performances optimales.Defining the file lets all functions in the app share the same cached packages, which gives the best performance. En cas de conflit de version, vous pouvez ajouter un fichier package.json dans le dossier d’une fonction spécifique pour le résoudre.If a version conflict arises, you can resolve it by adding a package.json file in the folder of a specific function.

Quand vous déployez des applications de fonction à partir du contrôle de code source, la présence d’un fichier package.json dans votre référentiel déclenche un npm install dans son dossier pendant le déploiement.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. Toutefois, si vous effectuez le déploiement par le biais du portail ou de l’interface CLI, vous devrez installer manuellement les packages.But when deploying via the Portal or CLI, you will have to manually install the packages.

Vous pouvez installer des packages sur votre application de fonction de deux façons :There are two ways to install packages on your Function App:

Déploiement avec des dépendancesDeploying with Dependencies

  1. Installez tous les packages requis localement en exécutant npm install.Install all requisite packages locally by running npm install.

  2. Déployez votre code, puis vérifiez que le dossier node_modules est inclus dans le déploiement.Deploy your code, and ensure that the node_modules folder is included in the deployment.

Utilisation de KuduUsing Kudu

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

  2. Cliquez sur Console de débogage > CMD.Click Debug Console > CMD.

  3. Accédez à D:\home\site\wwwroot, puis faites glisser le fichier package.json vers le dossier wwwroot dans la partie supérieure de la page.Go to D:\home\site\wwwroot, and then drag your package.json file to the wwwroot folder at the top half of the page.
    Il existe d’autres manières de télécharger des fichiers dans votre Function App.You can upload files to your function app in other ways also. Pour plus d’informations, consultez Comment mettre à jour les fichiers du conteneur de fonctions.For more information, see How to update function app files.

  4. Une fois le fichier package.json chargé, exécutez la commande npm install dans la console d’exécution à distance Kudu.After the package.json file is uploaded, run the npm install command in the Kudu remote execution console.
    Les packages d’actions indiqués dans le fichier package.json sont téléchargés et Function App redémarre.This action downloads the packages indicated in the package.json file and restarts the function app.

Variables d'environnementEnvironment variables

Ajoutez vos propres variables d’environnement à une application de fonction, dans vos environnements locaux et cloud, par exemple des secrets opérationnels (chaînes de connexion, clés et points de terminaison) ou des paramètres de l’environnement (comme des variables de profilage).Add your own environment variables to a function app, in both your local and cloud environments, such as operational secrets (connection strings, keys, and endpoints) or environmental settings (such as profiling variables). Accédez à ces paramètres en utilisant process.env dans le code de votre fonction.Access these settings using process.env in your function code.

Dans un environnement de développement localIn local development environment

Dans le cas d’une exécution locale, votre projet Functions comprend un fichier local.settings.json, où vous stockez vos variables d’environnement dans l’objet Values.When running locally, your functions project includes a local.settings.json file, where you store your environment variables in the Values object.

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "",
    "FUNCTIONS_WORKER_RUNTIME": "node",
    "translatorTextEndPoint": "https://api.cognitive.microsofttranslator.com/",
    "translatorTextKey": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
    "languageWorkers__node__arguments": "--prof"
  }
}

Dans un environnement cloud AzureIn Azure cloud environment

Dans le cas d’une exécution dans Azure, l’application de fonction vous permet de définir des paramètres d’application, comme des chaînes de connexion de service, et expose ces paramètres en tant que variables d’environnement lors de l’exécution.When running in Azure, the function app lets you set uses Application settings, such as service connection strings, and exposes these settings as environment variables during execution.

Plusieurs méthodes sont possibles pour ajouter, mettre à jour et supprimer des paramètres d’une application de fonction :There are several ways that you can add, update, and delete function app settings:

Les changements apportés aux paramètres d’application de fonction nécessitent le redémarrage de votre application de fonction.Changes to function app settings require your function app to be restarted.

Accéder aux variables d’environnement dans le codeAccess environment variables in code

Accédez aux paramètres d’application en utilisant process.env, comme illustré ici dans les deuxième et troisième appels à context.log(), où nous journalisons les variables d’environnement AzureWebJobsStorage et WEBSITE_SITE_NAME :Access application settings as environment variables 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) {

    context.log("AzureWebJobsStorage: " + process.env["AzureWebJobsStorage"]);
    context.log("WEBSITE_SITE_NAME: " + process.env["WEBSITE_SITE_NAME"]);
};

Modules ECMAScript (préversion)ECMAScript modules (preview)

Notes

Les modules ECMAScript étant actuellement qualifiés d’expérimentaux dans Node.js 14, ils sont disponibles en tant que fonctionnalité d’évaluation dans Node.js 14 Azure Functions.As ECMAScript modules are currently labeled experimental in Node.js 14, they're available as a preview feature in Node.js 14 Azure Functions. Jusqu’à ce que la prise en charge des modules ECMAScript par Node.js 14 devienne stable, attendez-vous à d’éventuelles modifications de son API ou de son comportement.Until Node.js 14 support for ECMAScript modules becomes stable, expect possible changes to its API or behavior.

Les modules ECMAScript (modules ES) sont le nouveau système de modules standard officiel pour Node.js.ECMAScript modules (ES modules) are the new official standard module system for Node.js. Jusqu’à présent, les exemples de code de cet article utilisent la syntaxe CommonJS.So far, the code samples in this article use the CommonJS syntax. Lors de l’exécution d’Azure Functions dans Node.js 14, vous pouvez choisir d’écrire vos fonctions en utilisant la syntaxe des modules ES.When running Azure Functions in Node.js 14, you can choose to write your functions using ES modules syntax.

Pour utiliser les modules ES dans une fonction, modifiez son nom de fichier pour qu’elle utilise une extension .mjs.To use ES modules in a function, change its filename to use a .mjs extension. L’exemple de fichier index.mjs suivant est une fonction déclenchée par HTTP qui utilise la syntaxe des modules ES pour importer la bibliothèque uuid et renvoyer une valeur.The following index.mjs file example is an HTTP triggered function that uses ES modules syntax to import the uuid library and return a value.

import { v4 as uuidv4 } from 'uuid';

export default async function (context, req) {
    context.res.body = uuidv4();
};

Configurer le point d’entrée de la fonctionConfigure function entry point

Vous pouvez utiliser les propriétés function.json``scriptFile et entryPoint pour configurer l’emplacement et le nom de votre fonction exportée.The function.json properties scriptFile and entryPoint can be used to configure the location and name of your exported function. Ces propriétés peuvent être importantes lorsque votre code JavaScript est transpilé.These properties can be important when your JavaScript is transpiled.

Utilisation de scriptFileUsing scriptFile

Par défaut, une fonction JavaScript est exécutée à partir de index.js, fichier qui partage le même répertoire parent que son function.json correspondant.By default, a JavaScript function is executed from index.js, a file that shares the same parent directory as its corresponding function.json.

Vous pouvez utiliser la propriété scriptFile pour obtenir une structure de dossiers semblable à l’exemple suivant :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

Le function.json pour myNodeFunction doit inclure une propriété scriptFile qui pointe vers le fichier contenant la fonction exportée à exécuter.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": [
    ...
  ]
}

Utilisation de entryPointUsing entryPoint

Dans scriptFile (ou index.js), une fonction doit être exportée à l’aide de module.exports afin qu’elle soit trouvée et exécutée.In scriptFile (or index.js), a function must be exported using module.exports in order to be found and run. Par défaut, la fonction qui s’exécute quand elle est déclenchée est la seule exportation à partir de ce fichier, l’exportation nommée run ou l’exportation nommée 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.

Cela peut être configuré à l’aide de entryPoint dans function.json, comme dans l’exemple suivant :This can be configured using entryPoint in function.json, as in the following example:

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

Dans Functions v2.x, qui prend en charge le paramètre this dans les fonctions utilisateur, le code de la fonction peut alors se présenter comme dans l’exemple suivant :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;

Dans cet exemple, il est important de noter que même si un objet est en cours d’exportation, rien ne garantit la conservation de l’état d’une exécution à l’autre.In this example, it is important to note that although an object is being exported, there are no guarantees for preserving state between executions.

Débogage localLocal Debugging

Avec le paramètre de démarrage --inspect, un processus Node.js écoute un client de débogage sur le port spécifié.When started with the --inspect parameter, a Node.js process listens for a debugging client on the specified port. Dans Azure Functions 2.x, vous pouvez spécifier des arguments à transmettre au processus Node.js qui exécute votre code en ajoutant la variable d’environnement ou le paramètre d’application 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>.

Pour déboguer localement, ajoutez "languageWorkers:node:arguments": "--inspect=5858" sous Values dans votre fichier local.settings.json et associez un débogueur au port 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.

Lorsque vous déboguez à l’aide de VS Code, le paramètre --inspect est automatiquement ajouté à l’aide de la valeur port au fichier launch.json du projet.When debugging using VS Code, the --inspect parameter is automatically added using the port value in the project's launch.json file.

Dans la version 1.x, le paramètre languageWorkers:node:arguments ne fonctionne pas.In version 1.x, setting languageWorkers:node:arguments will not work. Le port de débogage peut être sélectionné avec le paramètre --nodeDebugPort d’Azure Functions Core Tools.The debug port can be selected with the --nodeDebugPort parameter on Azure Functions Core Tools.

TypeScriptTypeScript

Lorsque vous ciblez la version 2.x du runtime Functions, Azure Functions pour Visual Studio Code et Azure Functions Core Tools vous permettent de créer des applications de fonction à l’aide d’un modèle qui prend en charge des projets d’application de fonction 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. Le modèle génère les fichiers de projet package.json et tsconfig.json qui simplifient la transpilation, l’exécution et la publication de fonctions JavaScript à partir du code TypeScript grâce à ces outils.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.

Un fichier .funcignore généré est utilisé pour indiquer les fichiers exclus lorsqu’un projet est publié dans Azure.A generated .funcignore file is used to indicate which files are excluded when a project is published to Azure.

Les fichiers TypeScript (.ts) sont transpilés en fichiers JavaScript (.js) dans le répertoire de sortie dist.TypeScript files (.ts) are transpiled into JavaScript files (.js) in the dist output directory. Les modèles TypeScript utilisent le scriptFileparamètre dans function.json pour indiquer l’emplacement du fichier .js correspondant dans le dossier dist.TypeScript templates use the scriptFile parameter in function.json to indicate the location of the corresponding .js file in the dist folder. L’emplacement de sortie est défini par le modèle à l’aide du paramètre outDir dans le fichier tsconfig.json.The output location is set by the template by using outDir parameter in the tsconfig.json file. Si vous modifiez ce paramètre ou le nom du dossier, le runtime n’est pas en mesure de trouver le code à exécuter.If you change this setting or the name of the folder, the runtime is not able to find the code to run.

La façon dont vous développez localement et déployez à partir d’un projet TypeScript dépend de votre outil de développement.The way that you locally develop and deploy from a TypeScript project depends on your development tool.

Visual Studio CodeVisual Studio Code

L’extension Azure Functions pour Visual Studio Code vous permet de développer vos fonctions à l’aide de TypeScript.The Azure Functions for Visual Studio Code extension lets you develop your functions using TypeScript. Core Tools est une exigence de l’extension d’Azure Functions.The Core Tools is a requirement of the Azure Functions extension.

Pour créer une application de fonction TypeScript dans Visual Studio Code, choisissez TypeScript comme langage lors de la création d’une application de fonction.To create a TypeScript function app in Visual Studio Code, choose TypeScript as your language when you create a function app.

Lorsque vous appuyez sur F5 pour exécuter l’application localement, une transpilation est effectuée avant l’initialisation de l’hôte (func.exe).When you press F5 to run the app locally, transpilation is done before the host (func.exe) is initialized.

Lorsque vous déployez votre application de fonction sur Azure à l’aide du bouton Deploy to function app... (Déployer vers une application de fonction...), l’extension d’Azure Functions génère d’abord une build prête pour la production de fichiers JavaScript à partir des fichiers source 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

Un projet TypeScript diffère d’un projet JavaScript de plusieurs manières quand vous utilisez Core Tools.There are several ways in which a TypeScript project differs from a JavaScript project when using the Core Tools.

Créer un projetCreate project

Pour créer un projet d’application de fonction TypeScript à l’aide de Core Tools, vous devez spécifier l’option de langage TypeScript lors de la création de votre application de fonction.To create a TypeScript function app project using Core Tools, you must specify the TypeScript language option when you create your function app. Vous pouvez le faire de l’une des manières suivantes :You can do this in one of the following ways:

  • Exécutez la commande func init, sélectionnez node comme pile de langage, puis sélectionnez typescript.Run the func init command, select node as your language stack, and then select typescript.

  • Exécutez la commande func init --worker-runtime typescript.Run the func init --worker-runtime typescript command.

Exécuter localementRun local

Pour exécuter votre code d’application de fonction localement à l’aide de Core Tools, utilisez les commandes suivantes au lieu de func host start :To run your function app code locally using Core Tools, use the following commands instead of func host start:

npm install
npm start

La commande npm start équivaut aux commandes suivantes :The npm start command is equivalent to the following commands:

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

Publication dans AzurePublish to Azure

Avant d’utiliser la commande func azure functionapp publish pour effectuer un déploiement sur Azure, vous créez une build prête pour la production de fichiers JavaScript à partir des fichiers sources TypeScript.Before you use the func azure functionapp publish command to deploy to Azure, you create a production-ready build of JavaScript files from the TypeScript source files.

Les commandes suivantes préparent et publient votre projet TypeScript à l’aide de Core Tools :The following commands prepare and publish your TypeScript project using Core Tools:

npm run build:production 
func azure functionapp publish <APP_NAME>

Dans cette commande, remplacez <APP_NAME> par le nom de votre application de fonction.In this command, replace <APP_NAME> with the name of your function app.

Considérations relatives aux fonctions JavaScriptConsiderations for JavaScript functions

Quand vous utilisez des fonctions JavaScript, tenez compte des considérations décrites dans les sections suivantes.When you work with JavaScript functions, be aware of the considerations in the following sections.

Choisir des plans App Service à processeur virtuel uniqueChoose single-vCPU App Service plans

Lorsque vous créez une application de fonction qui utilise le plan App Service, nous vous recommandons de sélectionner un plan à processeur virtuel unique plutôt qu’un plan à plusieurs processeurs virtuels.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. À l’heure actuelle, Functions exécute les fonctions JavaScript plus efficacement sur des machines virtuelles à processeur virtuel unique. Le recours à de plus grandes machines virtuelles ne produit pas les améliorations de performances attendues.Today, Functions runs JavaScript functions more efficiently on single-vCPU VMs, and using larger VMs does not produce the expected performance improvements. Le cas échéant, vous pouvez effectuer un scale-out manuellement en ajoutant des instances de machine virtuelle à processeur virtuel unique, ou vous pouvez activer la mise à l’échelle automatique.When necessary, you can manually scale out by adding more single-vCPU VM instances, or you can enable autoscale. Pour plus d’informations, consultez Mettre à l’échelle le nombre d’instances manuellement ou automatiquement.For more information, see Scale instance count manually or automatically.

Démarrage à froidCold Start

Quand vous développez des fonctions Azure dans le modèle d’hébergement serverless, les démarrages à froid sont une réalité.When developing Azure Functions in the serverless hosting model, cold starts are a reality. Démarrage à froid fait référence au fait que le démarrage de votre application de fonction prend plus de temps quand elle démarre pour la première fois après une période d’inactivité.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. En particulier, pour les fonctions JavaScript avec de grandes arborescences de dépendances, le démarrage à froid peut prendre un temps considérable.For JavaScript functions with large dependency trees in particular, cold start can be significant. Pour accélérer le processus de démarrage à froid, exécutez vos fonctions en tant que fichier de package lorsque cela est possible.To speed up the cold start process, run your functions as a package file when possible. De nombreuses méthodes de déploiement utilisent par défaut le modèle d’exécution à partir d’un package, mais si vous constatez des démarrages à froid particulièrement lents et que vous n’utilisez pas cette méthode d’exécution, cette approche peut accélérer considérablement le démarrage.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.

Limites de connexionsConnection Limits

Lorsque vous utilisez un client spécifique du service dans une application Azure Functions, ne créez pas de nouveau client à chaque appel de fonction.When you use a service-specific client in an Azure Functions application, don't create a new client with every function invocation. Créez plutôt un client statique unique dans l’étendue globale.Instead, create a single, static client in the global scope. Pour plus d’informations, consultez l’article relatif à la gestion des connexions dans Azure Functions.For more information, see managing connections in Azure Functions.

Utiliser async et awaitUse async and await

Lors de l’écriture d’Azure Functions dans JavaScript, vous devez écrire le code à l’aide des mots clés async et await.When writing Azure Functions in JavaScript, you should write code using the async and await keywords. L’écriture de code à l’aide de async et await au lieu de rappels ou de .then et .catch avec Promises permet d’éviter deux problèmes courants :Writing code using async and await instead of callbacks or .then and .catch with Promises helps avoid two common problems:

  • Levée d’exceptions non interceptées qui bloquent le processus Node.js, affectant ainsi potentiellement l’exécution d’autres fonctions.Throwing uncaught exceptions that crash the Node.js process, potentially affecting the execution of other functions.
  • Comportement inattendu, tels que des journaux manquants dans context.log, dû à des appels asynchrones inattendus.Unexpected behavior, such as missing logs from context.log, caused by asynchronous calls that are not properly awaited.

Dans l’exemple ci-dessous, la méthode asynchrone fs.readFile est appelée avec une fonction de rappel d’erreur en premier comme second paramètre.In the example below, the asynchronous method fs.readFile is invoked with an error-first callback function as its second parameter. Ce code entraîne les deux problèmes mentionnés ci-dessus.This code causes both of the issues mentioned above. Une exception qui n’est pas interceptée explicitement dans l’étendue appropriée a interrompu l’ensemble du processus (problème n°1).An exception that is not explicitly caught in the correct scope crashed the entire process (issue #1). Un appel context.done() en dehors de l’étendue du rappel de fonction signifie que l’appel de fonction peut se terminer avant la lecture du fichier (problème n°2).Calling context.done() outside of the scope of the callback function means that the function invocation may end before the file is read (issue #2). Dans cet exemple, un appel context.done() trop tôt entraîne des entrées de journal manquantes avec Data from file:.In this example, calling context.done() too early results in missing log entries starting with Data from file:.

// NOT RECOMMENDED PATTERN
const fs = require('fs');

module.exports = function (context) {
    fs.readFile('./hello.txt', (err, data) => {
        if (err) {
            context.log.error('ERROR', err);
            // BUG #1: This will result in an uncaught exception that crashes the entire process
            throw err;
        }
        context.log(`Data from file: ${data}`);
        // context.done() should be called here
    });
    // BUG #2: Data is not guaranteed to be read before the Azure Function's invocation ends
    context.done();
}

L’utilisation des mots clés async et await permet d’éviter ces deux erreurs.Using the async and await keywords helps avoid both of these errors. Vous devez utiliser la fonction d’utilitaire Node.js util.promisify pour activer des fonctions de type rappel d’erreur en premier dans des fonctions pouvant être attendues.You should use the Node.js utility function util.promisify to turn error-first callback-style functions into awaitable functions.

Dans l’exemple ci-dessous, les exceptions non gérées levées pendant l’exécution de la fonction entraînent un échec de l’appel individuel qui a levé une exception uniquement.In the example below, any unhandled exceptions thrown during the function execution only fail the individual invocation that raised an exception. Le mot clé await implique que les étapes après readFileAsync ne s’exécutent que lorsque readFile est terminé.The await keyword means that steps following readFileAsync only execute after readFile is complete. Avec async et await, vous n’avez pas besoin d’appeler le rappel context.done() non plus.With async and await, you also don't need to call the context.done() callback.

// Recommended pattern
const fs = require('fs');
const util = require('util');
const readFileAsync = util.promisify(fs.readFile);

module.exports = async function (context) {
    let data;
    try {
        data = await readFileAsync('./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}`);
}

Étapes suivantesNext steps

Pour plus d’informations, consultez les ressources suivantes :For more information, see the following resources: