Azure Functions JavaScript fejlesztői útmutatóAzure Functions JavaScript developer guide

Ez az útmutató a JavaScript-Azure Functions írásának bonyolult adatait tartalmazza.This guide contains information about the intricacies of writing Azure Functions with JavaScript.

A JavaScript-függvény egy olyan exportált @no__t – 0, amely az aktiváláskor fut (a triggerek a function. JSON fájlban vannak konfigurálva).A JavaScript function is an exported function that executes when triggered (triggers are configured in function.json). Az összes függvénynek átadott első argumentum egy context objektum, amely a kötési adatok fogadására és küldésére, a naplózásra és a futtatókörnyezettel folytatott kommunikációra szolgál.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.

Ez a cikk azt feltételezi, hogy már elolvasta a Azure functions fejlesztői referenciát.This article assumes that you have already read the Azure Functions developer reference. Az első függvény létrehozásához a Visual Studio Code használatával vagy a portálonhajtsa végre a functions rövid útmutatót.Complete the Functions quickstart to create your first function, using Visual Studio Code or in the portal.

Ez a cikk a írógéppel való alkalmazásfejlesztéstámogatását is támogatja.This article also supports TypeScript app development.

Mappa szerkezeteFolder structure

A JavaScript-projekthez szükséges mappastruktúrát a következőhöz hasonlóan néz ki.The required folder structure for a JavaScript project looks like the following. Ez az alapértelmezett érték módosítható.This default can be changed. További információért lásd az alábbi scriptFile szakaszt.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

A projekt gyökerében található egy megosztott Host. JSON fájl, amely a Function alkalmazás konfigurálására használható.At the root of the project, there's a shared host.json file that can be used to configure the function app. Minden függvényhez tartozik egy, a saját programkódját (. js) és a kötési konfigurációs fájlt (function. JSON) tartalmazó mappa.Each function has a folder with its own code file (.js) and binding configuration file (function.json). @No__t-0 szülőjének neve mindig a függvény neve.The name of function.json's parent directory is always the name of your function.

A functions futtatókörnyezet 2. x verziójában szükséges kötési kiterjesztések a extensions.csproj fájlban vannak meghatározva, a bin mappában található tényleges függvénytár-fájlokkal.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. Helyi fejlesztés esetén regisztrálnia kell a kötési bővítményeket.When developing locally, you must register binding extensions. A Azure Portal funkcióinak fejlesztésekor ez a regisztráció történik.When developing functions in the Azure portal, this registration is done for you.

Függvény exportálásaExporting a function

A JavaScript-függvényeket module.exports (vagy exports) használatával kell exportálni.JavaScript functions must be exported via module.exports (or exports). Az exportált függvénynek JavaScript-függvénynek kell lennie, amely az aktiváláskor végrehajtódik.Your exported function should be a JavaScript function that executes when triggered.

Alapértelmezés szerint a functions futtatókörnyezet index.js értékben keresi a függvényt, ahol a index.js a hozzá tartozó function.json.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. Az alapértelmezett esetben az exportált függvény csak a fájlból, vagy a run vagy index nevű exportálásból exportálható.In the default case, your exported function should be the only export from its file or the export named run or index. A fájl helyének és a függvény exportálási nevének konfigurálásához olvassa el a függvény belépési pontjának konfigurálását alább.To configure the file location and export name of your function, read about configuring your function's entry point below.

Az exportált függvény számos argumentumot adott meg a végrehajtáskor.Your exported function is passed a number of arguments on execution. Az első szükséges argumentum mindig egy context objektum.The first argument it takes is always a context object. Ha a függvény szinkronban van (nem ad vissza ígéretet), akkor meg kell adnia a context objektumot, mivel a helyes használat érdekében a context.done hívása szükséges.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();
};

Aszinkron függvény exportálásaExporting an async function

Ha az async function deklarációt vagy az egyszerű JavaScriptet ígéri a functions futtatókörnyezet 2. x verziójában, nem kell explicit módon meghívnia a context.done visszahívást, hogy jelezze a függvény befejezését.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. A függvény akkor fejeződik be, amikor az exportált aszinkron függvény/ígéret befejeződik.Your function completes when the exported async function/Promise completes. Az 1. x verziójú futtatókörnyezetet célzó függvények esetén a kód végrehajtásának végrehajtásakor továbbra is a context.done hívást kell meghívni.For functions targeting the version 1.x runtime, you must still call context.done when your code is done executing.

A következő példa egy egyszerű függvény, amely naplózza, hogy elindították, és azonnal befejezi a végrehajtást.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.');
};

Aszinkron függvény exportálásakor beállíthatja a kimeneti kötést is, hogy a return értéket adja meg.When exporting an async function, you can also configure an output binding to take the return value. Ez akkor ajánlott, ha csak egy kimeneti kötése van.This is recommended if you only have one output binding.

Ha return használatával szeretne kimenetet rendelni, módosítsa a name tulajdonságot a következőre: $return, function.json.To assign an output using return, change the name property to $return in function.json.

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

Ebben az esetben a függvénynek a következő példához hasonlóan kell kinéznie: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!"
    };
}

KötésekBindings

A JavaScriptben a kötések konfigurálva és definiálva vannak egy függvény function. JSON fájljában.In JavaScript, bindings are configured and defined in a function's function.json. A függvények számos módon működnek együtt a kötésekkel.Functions interact with bindings a number of ways.

BemenetekInputs

A bemenet két kategóriára oszlik Azure Functionsban: az egyik az trigger bemenete, a másik pedig a további bemenet.Input are divided into two categories in Azure Functions: one is the trigger input and the other is the additional input. A trigger és más bemeneti kötések (direction === "in") kötései háromféle módon olvashatók be a függvényekben:Trigger and other input bindings (bindings of direction === "in") can be read by a function in three ways:

  • [Ajánlott] A függvénynek átadott paraméterek.[Recommended] As parameters passed to your function. A függvénynek a function. JSONfájlban megadott sorrendben adják át őket.They are passed to the function in the same order that they are defined in function.json. A function. JSON fájlban definiált name tulajdonságnak nem kell megegyeznie a paraméter nevével, bár ez a következő:.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) { ... };
    
  • A context.bindings objektum tagjaként.As members of the context.bindings object. Az egyes tagok neve a function. JSONfájlban megadott name tulajdonság.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);
    };
    
  • A JavaScript arguments objektumot használó bemenetként.As inputs using the JavaScript arguments object. Ez lényegében ugyanaz, mint a bemenetek paraméterként való továbbítása, de lehetővé teszi a bemenetek dinamikus kezelését.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]);
    };
    

KimenetekOutputs

A kimeneteket (direction === "out") a függvény számos módon képes írni.Outputs (bindings of direction === "out") can be written to by a function in a number of ways. A kötés a function. JSON fájlban megadott name tulajdonsága minden esetben megfelel a függvényben írt Object tag nevének.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.

Az alábbi módszerek egyikével rendelhet adatokat a kimeneti kötésekhez (ne kombinálja ezeket a metódusokat):You can assign data to output bindings in one of the following ways (don't combine these methods):

  • [Több kimenet esetén ajánlott) Objektum visszaadása.[Recommended for multiple outputs] Returning an object. Ha aszinkron/Promise returning függvényt használ, a hozzárendelt kimeneti adatokat tartalmazó objektumot adhat vissza.If you are using an async/Promise returning function, you can return an object with assigned output data. Az alábbi példában a kimeneti kötések neve "httpResponse" és "queueOutput" a function. JSONfájlban.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
        };
    };
    

    Ha szinkron függvényt használ, ezt az objektumot context.done (lásd: példa) használatával adhatja vissza.If you are using a synchronous function, you can return this object using context.done (see example).

  • [Egyetlen kimenethez ajánlott Közvetlenül egy értéket ad vissza, és a $return kötési nevet használja.[Recommended for single output] Returning a value directly and using the $return binding name. Ez csak az aszinkron/Promise Returns függvények esetében működik.This only works for async/Promise returning functions. Lásd: példa az aszinkron függvények exportálására.See example in exporting an async function.

  • Értékek Kiosztása context.bindings értékre Az értékeket közvetlenül is hozzárendelheti a Context. kötésekhez.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;
    };
    

Kötések adattípusaBindings data type

Egy bemeneti kötés adattípusának megadásához használja a dataType tulajdonságot a kötés definíciójában.To define the data type for an input binding, use the dataType property in the binding definition. Ha például bináris formátumban szeretné beolvasni egy HTTP-kérelem tartalmát, használja a binary típust: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"
}

A dataType beállításai: binary, stream és string.Options for dataType are: binary, stream, and string.

környezeti objektumcontext object

A futásidejű context objektum használatával továbbítja az adatokhoz a függvényt, és lehetővé teszi a kommunikációt a futtatókörnyezettel.The runtime uses a context object to pass data to and from your function and to let you communicate with the runtime. A környezeti objektum használható a kötések adatainak olvasására és beállítására, a naplók írására és a context.done visszahívás használatára, ha az exportált függvény szinkronban van.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.

A context objektum mindig a függvény első paramétere.The context object is always the first parameter to a function. A csomagnak szerepelnie kell, mert olyan fontos módszerekkel rendelkezik, mint a context.done és a context.log.It should be included because it has important methods such as context.done and context.log. Megadhatja az objektum nevét, amit szeretne (például ctx vagy 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();
};

Context. binds tulajdonságcontext.bindings property

context.bindings

Egy elnevezett objektumot ad vissza, amely a kötési adatok olvasására vagy hozzárendelésére szolgál.Returns a named object that is used to read or assign binding data. A bemeneti és trigger kötési adatokat a context.bindings tulajdonság tulajdonságainak olvasásával érheti el.Input and trigger binding data can be accessed by reading properties on context.bindings. A kimeneti kötési adatokat hozzá lehet rendelni a context.bindings értékhez való hozzáadásávalOutput binding data can be assigned by adding data to context.bindings

Például a function. JSON következő kötési definíciói lehetővé teszik egy üzenetsor tartalmának elérését context.bindings.myInput értékről, és kimenetek hozzárendelését egy várólistához context.bindings.myOutput használatával.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 };

Kiválaszthatja, hogy a context.binding objektum helyett a context.done metódussal definiálja a kimeneti kötési adatokat (lásd alább).You can choose to define output binding data using the context.done method instead of the context.binding object (see below).

Context. bindingData tulajdonságcontext.bindingData property

context.bindingData

Egy elnevezett objektumot ad vissza, amely trigger-metaadatokat és függvény Meghívási adatokat tartalmaz (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). Az eseményindító metaadatainak példáját itt tekintheti meg: példa az Event hub-ra.For an example of trigger metadata, see this event hubs example.

Context. Done metóduscontext.done method

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

Lehetővé teszi, hogy a futtatókörnyezet tudja, hogy a kód befejeződött.Lets the runtime know that your code has completed. Ha a függvény a async function deklarációt használja, nincs szükség a context.done() használatára.When your function uses the async function declaration, you do not need to use context.done(). A context.done visszahívás implicit módon van meghívva.The context.done callback is implicitly called. Az aszinkron függvények a 8. csomópontban vagy egy újabb verzióban érhetők el, amelyhez a functions futtatókörnyezet 2. x verziója szükséges.Async functions are available in Node 8 or a later version, which requires version 2.x of the Functions runtime.

Ha a függvény nem aszinkron függvény, meg kell hívnia a context.done, hogy tájékoztassa a futtatókörnyezetet arról, hogy a függvény kész.If your function is not an async function, you must call context.done to inform the runtime that your function is complete. Ha hiányzik a végrehajtás, időtúllépés történik.The execution times out if it is missing.

A context.done módszer lehetővé teszi, hogy a felhasználó által definiált hibát visszaadja a futtatókörnyezetnek, valamint egy olyan JSON-objektumot, amely kimeneti kötési adatokat tartalmaz.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. A (z) context.done értékre átadott tulajdonságok felülírják a context.bindings objektumon beállított összes értéket.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

Context. log metóduscontext.log method

context.log(message)

Lehetővé teszi, hogy az alapértelmezett nyomkövetési szinten írjon a streaming Function naplóiba.Allows you to write to the streaming function logs at the default trace level. @No__t – 0 esetén további naplózási módszerek érhetők el, amelyek lehetővé teszik a függvények naplóinak más nyomkövetési szinteken való írását:On context.log, additional logging methods are available that let you write function logs at other trace levels:

MódszerMethod LeírásDescription
hiba (üzenet)error(message) A hiba szintű naplózás vagy az alacsonyabb értékre ír.Writes to error level logging, or lower.
Figyelmeztetés (üzenet)warn(message) Figyelmeztetési szintű naplózás vagy alacsonyabb értékre írás.Writes to warning level logging, or lower.
információ (üzenet)info(message) Az adatszintű naplózás vagy az alacsonyabb értékre írja az adatokat.Writes to info level logging, or lower.
részletes (üzenet)verbose(message) Írás a részletes szintű naplózásba.Writes to verbose level logging.

A következő példa egy naplót ír a figyelmeztetési nyomkövetési szintre:The following example writes a log at the warning trace level:

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

A naplózási szint küszöbértékét beállíthatja a Host. JSON fájlban való bejelentkezéshez.You can configure the trace-level threshold for logging in the host.json file. A naplók írásával kapcsolatos további információkért lásd: nyomkövetési kimenetek írása alább.For more information on writing logs, see writing trace outputs below.

Olvassa el a figyelési Azure functions , ha többet szeretne megtudni a függvények naplóinak megtekintéséről és lekérdezéséről.Read monitoring Azure Functions to learn more about viewing and querying function logs.

Nyomkövetési kimenet írása a konzolraWriting trace output to the console

A functions-ben a context.log metódusokkal írhat nyomkövetési kimenetet a konzolra.In Functions, you use the context.log methods to write trace output to the console. A functions v2. x-ben a console.log értéket használó nyomkövetési kimenetek a függvényalkalmazás szinten vannak rögzítve.In Functions v2.x, trace outputs using console.log are captured at the Function App level. Ez azt jelenti, hogy a console.log kimenetei nem kötődnek egy adott függvény meghívásához, és nem jelennek meg egy adott függvény naplóiban.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. Azonban a Application Insights propagálják őket.They do, however, propagate to Application Insights. A függvények v1. x verziójában nem használhatja a console.log értéket a konzolra való íráshoz.In Functions v1.x, you cannot use console.log to write to the console.

Ha context.log() hívást hív meg, az üzenet a konzolra kerül az alapértelmezett nyomkövetési szinten, amely az adatok nyomkövetési szintje.When you call context.log(), your message is written to the console at the default trace level, which is the info trace level. A következő kód a-konzolra ír az információs nyomkövetési szinten:The following code writes to the console at the info trace level:

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

Ez a kód egyenértékű a fenti kóddal:This code is equivalent to the code above:

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

Ez a kód a konzolon a hiba szintjén írja a következőt:This code writes to the console at the error level:

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

Mivel a hiba a legmagasabb nyomkövetési szint, ez a nyomkövetés minden nyomkövetési szinten a kimenetbe kerül, amíg a naplózás engedélyezve van.Because error is the highest trace level, this trace is written to the output at all trace levels as long as logging is enabled.

Az összes context.log módszer ugyanazt a paraméter-formátumot támogatja, amelyet a Node. js util. Format metódusatámogat.All context.log methods support the same parameter format that's supported by the Node.js util.format method. Vegye figyelembe a következő kódot, amely az alapértelmezett nyomkövetési szinttel írja be a függvény naplóit: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));

Ugyanezt a kódot a következő formátumban is megírhatja: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));

A konzol naplózási szintjének konfigurálásaConfigure the trace level for console logging

Az 1. x függvények lehetővé teszik a küszöbérték nyomkövetési szintjének meghatározását a konzolra való íráshoz, így könnyen szabályozható, hogy a rendszer hogyan írja a nyomkövetéseket a konzolra a függvényből.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. A konzolra írt összes nyomkövetés küszöbértékének megadásához használja a tracing.consoleLevel tulajdonságot a Host. JSON fájlban.To set the threshold for all traces written to the console, use the tracing.consoleLevel property in the host.json file. Ez a beállítás a Function alkalmazás összes függvényére érvényes.This setting applies to all functions in your function app. A következő példa a nyomkövetési küszöbértéket állítja be a részletes naplózás engedélyezéséhez:The following example sets the trace threshold to enable verbose logging:

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

A consoleLevel értékei megfelelnek az context.log metódusok neveinek.Values of consoleLevel correspond to the names of the context.log methods. Ha le szeretné tiltani az összes nyomkövetési naplózást a konzolon, állítsa a consoleLevel beállítást _ki_értékre.To disable all trace logging to the console, set consoleLevel to off. További információ: Host. JSON-dokumentáció.For more information, see host.json reference.

HTTP-eseményindítók és-kötésekHTTP triggers and bindings

A HTTP-és webhook-eseményindítók és a HTTP-kimeneti kötések a HTTP-üzenetküldést a kérelmek és válaszok objektumok használatával jelölik.HTTP and webhook triggers and HTTP output bindings use request and response objects to represent the HTTP messaging.

Kérelem objektumRequest object

A context.req (kérelem) objektum a következő tulajdonságokkal rendelkezik:The context.req (request) object has the following properties:

TulajdonságProperty LeírásDescription
törzsebody Egy objektum, amely tartalmazza a kérelem törzsét.An object that contains the body of the request.
fejlécekheaders Egy objektum, amely a kérések fejléceit tartalmazza.An object that contains the request headers.
metódusmethod A kérelem HTTP-metódusa.The HTTP method of the request.
originalUrloriginalUrl A kérelem URL-címe.The URL of the request.
paramétereiparams Egy objektum, amely a kérelem útválasztási paramétereit tartalmazza.An object that contains the routing parameters of the request.
lekérdezésquery Egy objektum, amely tartalmazza a lekérdezési paramétereket.An object that contains the query parameters.
rawBodyrawBody Az üzenet törzse sztringként.The body of the message as a string.

VálaszobjektumResponse object

A context.res (Response) objektum a következő tulajdonságokkal rendelkezik:The context.res (response) object has the following properties:

TulajdonságProperty LeírásDescription
törzsebody Egy objektum, amely tartalmazza a válasz törzsét.An object that contains the body of the response.
fejlécekheaders Egy objektum, amely tartalmazza a válasz fejléceit.An object that contains the response headers.
isRawisRaw Azt jelzi, hogy a válasz formátuma kimarad.Indicates that formatting is skipped for the response.
állapotastatus A válasz HTTP-állapotkódot.The HTTP status code of the response.

A kérelem és válasz eléréseAccessing the request and response

HTTP-eseményindítók használata esetén a HTTP-kérelem és a válasz-objektumok többféleképpen is elérhetők:When you work with HTTP triggers, you can access the HTTP request and response objects in a number of ways:

  • A context objektum req és res tulajdonságai közül.From req and res properties on the context object. Ily módon a környezeti objektumból a HTTP-adatok eléréséhez a hagyományos mintázatot használhatja ahelyett, hogy a teljes context.bindings.name mintát kellene használnia.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. Az alábbi példa bemutatja, hogyan érheti el a req és a res objektumokat a 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!' }; 
    
  • Az elnevezett bemeneti és kimeneti kötések közül.From the named input and output bindings. Így a HTTP-trigger és a kötések ugyanúgy működnek, mint bármely más kötés.In this way, the HTTP trigger and bindings work the same as any other binding. A következő példa egy elnevezett response kötés használatával állítja be a válasz objektumot: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." };
    
  • [Válasz csak] @No__t-2 meghívásával.[Response only] By calling context.res.send(body?: any). A rendszer egy HTTP-választ hoz létre a body bemenettel a válasz törzsében.An HTTP response is created with input body as the response body. a context.done() implicit módon van meghívva.context.done() is implicitly called.

  • [Válasz csak] @No__t-2 meghívásával.[Response only] By calling context.done(). A speciális HTTP-kötés a context.done() metódusnak átadott választ adja vissza.A special type of HTTP binding returns the response that is passed to the context.done() method. A következő HTTP kimeneti kötés a $return kimeneti paramétert definiálja: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);   
    

Csomópont verziójaNode version

A következő táblázat a függvények futtatókörnyezetének egyes főbb verziói által használt Node. js-verziót mutatja be:The following table shows the Node.js version used by each major version of the Functions runtime:

Függvények verziójaFunctions version Node. js-verzióNode.js version
1. x1.x 6.11.2 (a futtatókörnyezet zárolta)6.11.2 (locked by the runtime)
2. x2.x Aktív LTS -és karbantartási LTS Node. js-verziók (~ 10 ajánlott).Active LTS and Maintenance LTS Node.js versions (~10 recommended). A verzió megcélzása az Azure-ban a WEBSITE_NODE_DEFAULT_VERSION alkalmazás beállításának ~10 értékre való beállításával.Target the version in Azure by setting the WEBSITE_NODE_DEFAULT_VERSION app setting to ~10.

A futtatókörnyezet által használt aktuális verziót úgy tekintheti meg, ha ellenőrzi a fenti alkalmazás beállítását, vagy a process.version bármely függvényből való nyomtatásával.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.

FüggőségkezelésDependency management

Ha a JavaScript-kódban a közösségi kódtárakat szeretné használni, ahogy az az alábbi példában is látható, gondoskodnia kell arról, hogy az Azure-ban minden függőség telepítve legyen az függvényalkalmazás.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'});

Megjegyzés

@No__t-0 fájlt kell megadnia a függvényalkalmazás gyökerében.You should define a package.json file at the root of your Function App. A fájl definiálása lehetővé teszi, hogy az alkalmazás összes funkciója ugyanazt a gyorsítótárazott csomagot használja, amely a legjobb teljesítményt biztosítja.Defining the file lets all functions in the app share the same cached packages, which gives the best performance. Ha ütközés lép fel, azt megoldhatja egy package.json fájl hozzáadásával egy adott függvény mappájába.If a version conflict arises, you can resolve it by adding a package.json file in the folder of a specific function.

Ha a forrásoldali vezérlőből telepíti a függvények alkalmazásait, a tárházban található bármelyik @no__t 0 fájl az üzembe helyezés során egy npm install-et indít el a mappájába.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. Ha azonban a portálon vagy a CLI-n keresztül végzi a telepítést, manuálisan kell telepítenie a csomagokat.But when deploying via the Portal or CLI, you will have to manually install the packages.

A függvényalkalmazás kétféleképpen telepíthet csomagokat:There are two ways to install packages on your Function App:

Üzembe helyezés függőségekkelDeploying with Dependencies

  1. Telepítse az összes szükséges csomagot helyileg a npm install futtatásával.Install all requisite packages locally by running npm install.

  2. Telepítse a kódot, és ellenőrizze, hogy a node_modules mappa szerepel-e a központi telepítésben.Deploy your code, and ensure that the node_modules folder is included in the deployment.

A kudu használataUsing Kudu

  1. Nyissa meg a következőt: https://<function_app_name>.scm.azurewebsites.net.Go to https://<function_app_name>.scm.azurewebsites.net.

  2. Kattintson a Debug Console > cmdelemre.Click Debug Console > CMD.

  3. Lépjen a D:\home\site\wwwroot elemre, majd húzza a Package. JSON fájlt a wwwroot mappába az oldal felső felén.Go to D:\home\site\wwwroot, and then drag your package.json file to the wwwroot folder at the top half of the page.
    Más módokon is feltölthet fájlokat a Function alkalmazásba.You can upload files to your function app in other ways also. További információ: Function app Files frissítése.For more information, see How to update function app files.

  4. A Package. JSON fájl feltöltése után futtassa a npm install parancsot a kudu távoli végrehajtási konzolon.After the package.json file is uploaded, run the npm install command in the Kudu remote execution console.
    Ez a művelet letölti a Package. JSON fájlban jelzett csomagokat, és újraindítja a Function alkalmazást.This action downloads the packages indicated in the package.json file and restarts the function app.

Környezeti változókEnvironment variables

A függvények, az Alkalmazásbeállítások, például a szolgáltatási kapcsolatok karakterláncai a végrehajtás során környezeti változókként jelennek meg.In Functions, app settings, such as service connection strings, are exposed as environment variables during execution. Ezekhez a beállításokhoz process.env használatával férhet hozzá, ahogy az itt látható a második és harmadik hívásban context.log(), ahol a AzureWebJobsStorage és a WEBSITE_SITE_NAME környezeti változót naplózzák: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"]);
};

A Function app-beállítások több módon is hozzáadhatók, frissíthetők és törölhetők:There are several ways that you can add, update, and delete function app settings:

Helyileg futtatva az Alkalmazásbeállítások a Local. Settings. JSON Project fájlból lesznek beolvasva.When running locally, app settings are read from the local.settings.json project file.

Függvény belépési pontjának konfigurálásaConfigure function entry point

Az exportált függvény helyének és nevének konfigurálásához a function.json tulajdonságok scriptFile és a entryPoint használható.The function.json properties scriptFile and entryPoint can be used to configure the location and name of your exported function. Ezek a tulajdonságok akkor lehetnek fontosak, ha a JavaScript transpiled.These properties can be important when your JavaScript is transpiled.

@No__t-0 használataUsing scriptFile

Alapértelmezés szerint a JavaScript-függvény index.js, egy olyan fájl, amely ugyanazokat a szülő könyvtárat osztja meg, mint a megfelelő function.json.By default, a JavaScript function is executed from index.js, a file that shares the same parent directory as its corresponding function.json.

a scriptFile használható a következő példához hasonló mappa-struktúra beszerzéséhez: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

A myNodeFunction function.json értékének tartalmaznia kell egy scriptFile tulajdonságot, amely a fájlra mutat, és az exportált függvénnyel fut.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": [
    ...
  ]
}

@No__t-0 használataUsing entryPoint

@No__t-0 (vagy index.js) esetében a függvényt az module.exports használatával kell exportálni, hogy azok megtalálhatók és fussanak.In scriptFile (or index.js), a function must be exported using module.exports in order to be found and run. Alapértelmezés szerint az aktiváláskor végrehajtandó függvény az egyetlen Exportálás az adott fájlból, az run nevű exportálás, vagy a index nevű exportálás.By default, the function that executes when triggered is the only export from that file, the export named run, or the export named index.

Ez a function.json entryPoint használatával konfigurálható, ahogy az alábbi példában is látható:This can be configured using entryPoint in function.json, as in the following example:

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

A (z) v2. x függvényben, amely támogatja a this paramétert a felhasználói függvényekben, a függvény kódja a következő példához hasonlóan lehet: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;

Ebben a példában fontos megjegyezni, hogy bár egy objektum exportálása folyamatban van, nincs garancia a végrehajtások állapotának megőrzésére.In this example, it is important to note that although an object is being exported, there are no guarantees for preserving state between executions.

Helyi hibakeresésLocal Debugging

Ha a --inspect paraméterrel indult el, a Node. js folyamat egy hibakeresési ügyfelet figyel a megadott porton.When started with the --inspect parameter, a Node.js process listens for a debugging client on the specified port. Azure Functions 2. x verzióban megadhat argumentumokat, amelyek a kódot futtató Node. js-folyamatba kerülnek, ha a környezeti változót vagy az Alkalmazásbeállítások languageWorkers:node:arguments = <args> értéket adja hozzá.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>.

A helyi hibakereséshez adja hozzá a "languageWorkers:node:arguments": "--inspect=5858" értéket a Local. Settings. JSON fájl Values eleméhez, és csatolja a hibakeresőt az 5858-as porthoz.To debug locally, add "languageWorkers:node:arguments": "--inspect=5858" under Values in your local.settings.json file and attach a debugger to port 5858.

A VS Code használatakor a rendszer automatikusan hozzáadja a --inspect paramétert a projekt Launch. JSON fájljának port értékének használatával.When debugging using VS Code, the --inspect parameter is automatically added using the port value in the project's launch.json file.

Az 1. x verzióban a languageWorkers:node:arguments beállítás nem fog működni.In version 1.x, setting languageWorkers:node:arguments will not work. A hibakeresési portot a Azure Functions Core Tools --nodeDebugPort paraméterrel lehet kiválasztani.The debug port can be selected with the --nodeDebugPort parameter on Azure Functions Core Tools.

TypeScriptTypeScript

Ha a functions futtatókörnyezet 2. x verzióját célozza meg, a Visual Studio Code -hoz és a Azure functions Core Tools -hoz egyaránt Azure functions is létrehozhat Function apps-alkalmazásokat olyan sablon használatával, amely támogatja az írógéppel Function app-projekteket.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. A sablon package.json és tsconfig.json projektfájlt hoz létre, amelyek egyszerűbbé teszik a JavaScript-függvények transpile, futtatását és közzétételét az eszközökön.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.

A generált .funcignore fájl használatával jelezheti, hogy mely fájlok ki vannak zárva, amikor egy projekt közzé van téve az Azure-ban.A generated .funcignore file is used to indicate which files are excluded when a project is published to Azure.

Az transpiled (. TS) a dist kimeneti könyvtárban lévő JavaScript-fájlokba (. js) kerülnek.TypeScript files (.ts) are transpiled into JavaScript files (.js) in the dist output directory. Az írógéppel sablon a scriptFile paramétert használja function.json értékben, hogy jelezze a megfelelő. js fájl helyét a dist mappában.TypeScript templates use the scriptFile parameter in function.json to indicate the location of the corresponding .js file in the dist folder. A kimeneti helyet a sablon állítja be úgy, hogy outDir paramétert használ az tsconfig.json fájlban.The output location is set by the template by using outDir parameter in the tsconfig.json file. Ha módosítja ezt a beállítást vagy a mappa nevét, a futtatókörnyezet nem találja a futtatandó kódot.If you change this setting or the name of the folder, the runtime is not able to find the code to run.

Megjegyzés

Az írógéppel való kísérleti támogatás létezik a functions futtatókörnyezet 1. x verziója.Experimental support for TypeScript exists version 1.x of the Functions runtime. A kísérleti verzió transpiles írógéppel fájlokat a JavaScript-fájlokba a függvény meghívásakor.The experimental version transpiles TypeScript files into JavaScript files when the function is invoked. A 2. x verzióban ezt a kísérleti támogatást felváltotta az eszköz által vezérelt módszer, amely a gazdagép inicializálása előtt és a telepítési folyamat során transpilation.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.

A helyi fejlesztés és üzembe helyezés módja a fejlesztői eszköztől függ.The way that you locally develop and deploy from a TypeScript project depends on your development tool.

Visual Studio-kódVisual Studio Code

A Visual Studio Code bővítményhez készült Azure functions lehetővé teszi a függvények fejlesztését a géppel.The Azure Functions for Visual Studio Code extension lets you develop your functions using TypeScript. Az alapvető eszközök a Azure Functions bővítmény követelménye.The Core Tools is a requirement of the Azure Functions extension.

Ha a Visual Studio Code-ban szeretne létrehozni egy írógéppel Function-alkalmazást, válassza a TypeScript lehetőséget a Function-alkalmazás létrehozásakor.To create a TypeScript function app in Visual Studio Code, choose TypeScript as your language when you create a function app.

Amikor lenyomja az F5 billentyűt az alkalmazás helyi futtatásához, a transpilation a gazdagép (a (z). exe) inicializálása előtt történik.When you press F5 to run the app locally, transpilation is done before the host (func.exe) is initialized.

Ha a Function alkalmazást az Azure-ban az üzembe helyezés az alkalmazásban... gomb használatával helyezi üzembe, a Azure functions-bővítmény először a JavaScript-fájlok éles környezetben való létrehozására kész buildjét hozza létre a géppel készített forrásfájlok közül.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

A központi eszközök használata során többféleképpen is eltérhetnek a JavaScript-projekttől.There are several ways in which a TypeScript project differs from a JavaScript project when using the Core Tools.

Projekt létrehozásaCreate project

Ha a Core Tools használatával szeretne létrehozni egy írógéppel Function app-projektet, a Function alkalmazás létrehozásakor meg kell adnia az írógéppel nyelvi beállítást.To create a TypeScript function app project using Core Tools, you must specify the TypeScript language option when you create your function app. Ezt a következő módszerek egyikével teheti meg:You can do this in one of the following ways:

  • Futtassa a func init parancsot, válassza a node elemet a nyelvi verem elemnél, majd válassza a typescript lehetőséget.Run the func init command, select node as your language stack, and then select typescript.

  • Futtassa a következő parancsot: func init --worker-runtime typescript.Run the func init --worker-runtime typescript command.

Helyi FuttatásRun local

Ha a Function app-kódot helyileg szeretné futtatni a Core Tools használatával, használja a következő parancsokat a func host start helyett:To run your function app code locally using Core Tools, use the following commands instead of func host start:

npm install
npm start

A npm start parancs egyenértékű a következő parancsokkal:The npm start command is equivalent to the following commands:

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

Közzététel az Azure platformonPublish to Azure

Mielőtt a func azure functionapp publish parancsot használja az Azure-ba való üzembe helyezéshez, létrehoz egy, a JavaScript-fájlok gyártásra kész buildjét a géppel készített forrásfájlok közül.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.

A következő parancsok a géppel készített projekt előkészítését és közzétételét teszik közzé a Core Tools használatával:The following commands prepare and publish your TypeScript project using Core Tools:

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

Ebben a parancsban cserélje le a <APP_NAME> értéket a Function alkalmazás nevével.In this command, replace <APP_NAME> with the name of your function app.

A JavaScript-függvények szempontjaiConsiderations for JavaScript functions

Ha JavaScript-függvényekkel dolgozik, vegye figyelembe a következő részekben ismertetett szempontokat.When you work with JavaScript functions, be aware of the considerations in the following sections.

VCPU App Service csomagok kiválasztásaChoose single-vCPU App Service plans

Ha a App Service csomagot használó Function-alkalmazást hoz létre, azt javasoljuk, hogy egyetlen vCPU csomagot válasszon, nem pedig több vCPU rendelkező csomagot.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. Napjainkban a függvények a JavaScript-funkciókat hatékonyabban futtatják az vCPU virtuális gépeken, a nagyobb méretű virtuális gépek használata azonban nem eredményezi a várt teljesítményt.Today, Functions runs JavaScript functions more efficiently on single-vCPU VMs, and using larger VMs does not produce the expected performance improvements. Ha szükséges, manuálisan is kibővítheti a további vCPU virtuálisgép-példányok hozzáadásával, vagy engedélyezheti az autoskálázást is.When necessary, you can manually scale out by adding more single-vCPU VM instances, or you can enable autoscale. További információ: a Példányszám manuális vagy automatikus skálázása.For more information, see Scale instance count manually or automatically.

HidegindítóCold Start

Azure Functions a kiszolgáló nélküli üzemeltetési modellben való fejlesztésekor a hideg indítás a valóság.When developing Azure Functions in the serverless hosting model, cold starts are a reality. A hidegindító kifejezés arra utal, hogy amikor a Function alkalmazás első alkalommal indul el egy adott időszak után, a folyamat hosszabb időt vesz igénybe.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. Ha a JavaScript-függvények nagy függőségi fákkal rendelkeznek, akkor a hideg indítás jelentős lehet.For JavaScript functions with large dependency trees in particular, cold start can be significant. A hidegindító folyamat felgyorsításához futtassa a függvényeket csomagfájlként , ha lehetséges.To speed up the cold start process, run your functions as a package file when possible. Számos üzembe helyezési módszer alapértelmezés szerint a Futtatás a csomag modelljével történik, de ha nagy mennyiségű hideg indul el, és nem fut így, ez a változás jelentős javulást nyújthat.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.

Kapcsolatok korlátaiConnection Limits

Ha egy Azure Functions-alkalmazásban szolgáltatás-specifikus ügyfelet használ, ne hozzon létre új ügyfelet minden függvény meghívásával.When you use a service-specific client in an Azure Functions application, don't create a new client with every function invocation. Ehelyett hozzon létre egyetlen, statikus ügyfelet a globális hatókörben.Instead, create a single, static client in the global scope. További információ: kapcsolatok kezelése Azure Functionsban.For more information, see managing connections in Azure Functions.

@No__t-0 és await használataUse async and await

A JavaScript-Azure Functions írásakor a async és a await kulcsszó használatával kell kódot írnia.When writing Azure Functions in JavaScript, you should write code using the async and await keywords. A kód async és await helyett a visszahívások vagy a .then, valamint a .catch használata az ígéretekkel segít elkerülni a két gyakori problémát:Writing code using async and await instead of callbacks or .then and .catch with Promises helps avoid two common problems:

  • A Node. js folyamat összeomlásamiatt fellépő nem kezelt kivételek eldobása, ami hatással van más függvények végrehajtására.Throwing uncaught exceptions that crash the Node.js process, potentially affecting the execution of other functions.
  • Váratlan viselkedés, például hiányzó naplók a Context. log naplófájlból, a nem megfelelően várt aszinkron hívások miatt.Unexpected behavior, such as missing logs from context.log, caused by asynchronous calls that are not properly awaited.

Az alábbi példában a (z) fs.readFile aszinkron metódust egy hiba-első visszahívási függvény hívja meg második paramétereként.In the example below, the asynchronous method fs.readFile is invoked with an error-first callback function as its second parameter. Ez a kód a fent említett problémákat is okozhatja.This code causes both of the issues mentioned above. A megfelelő hatókörben nem kifejezetten bekövetkező kivétel összeomlott a teljes folyamaton (a probléma #1).An exception that is not explicitly caught in the correct scope crashed the entire process (issue #1). A visszahívási függvény hatókörén kívüli @no__t – 0 hívása azt jelenti, hogy a függvény meghívása a fájl olvasása előtt megszűnik (probléma #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). Ebben a példában a context.done() túl korai eredményt hívja a hiányzó naplóbejegyzések Data from file: kezdetű bejegyzéseivel.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();
}

A async és a await kulcsszó használata segít elkerülni mindkét hibát.Using the async and await keywords helps avoid both of these errors. A (util.promisify Node. js segédprogrammal kapcsolja be a hiba-első visszahívási stílus függvényeit a várt függvényekbe.You should use the Node.js utility function util.promisify to turn error-first callback-style functions into awaitable functions.

Az alábbi példában a függvény végrehajtása során felmerülő kezeletlen kivételek csak a kivételt okozó egyéni hívás meghiúsulnak.In the example below, any unhandled exceptions thrown during the function execution only fail the individual invocation that raised an exception. A await kulcsszó azt jelenti, hogy csak a readFile befejezése után hajtja végre a következő readFileAsync műveletet.The await keyword means that steps following readFileAsync only execute after readFile is complete. A async és a await esetében nem kell meghívnia a context.done() visszahívást.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) {
    try {
        const 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}`);
}

Következő lépésekNext steps

További információkért lásd a következőket:For more information, see the following resources: