HTTP-eseményindítók és-kötések Azure FunctionsAzure Functions HTTP triggers and bindings

Ez a cikk azt ismerteti, hogyan használhatók a HTTP-eseményindítók és a kimeneti kötések Azure Functionsban.This article explains how to work with HTTP triggers and output bindings in Azure Functions.

A HTTP-triggerek testreszabhatók a webhookokra való reagáláshoz. An HTTP trigger can be customized to respond to webhooks.

Ez az információ az Azure Functions-fejlesztők számára.This is reference information for Azure Functions developers. Ha most ismerkedik az Azure Functions, indítsa el az alábbi forrásanyagokat:If you're new to Azure Functions, start with the following resources:

Tipp

Ha azt tervezi, használja a HTTP- vagy WebHook kötések, megtervezése elkerülése érdekében, hogy a nem megfelelő példányosítás okozhatja portfogyás HttpClient.If you plan to use the HTTP or WebHook bindings, plan to avoid port exhaustion that can be caused by improper instantiation of HttpClient. További információkért lásd: kezelése az Azure Functions kapcsolatok.For more information, see How to manage connections in Azure Functions.

A cikkben található kód a 2. x függvényt, amely a .NET Core-t használja.The code in this article defaults to Functions 2.x syntax which uses .NET Core. Az 1. x szintaxissal kapcsolatos további információkért tekintse meg az 1. x függvények sablonjait.For information on the 1.x syntax, see the 1.x functions templates.

Csomagok – 1.x függvényekPackages - Functions 1.x

A HTTP-kötések a Microsoft. Azure. webjobs. Extensions. http NuGet csomagban, az 1. x verzióban érhetők el.The HTTP bindings are provided in the Microsoft.Azure.WebJobs.Extensions.Http NuGet package, version 1.x. A csomag forráskódja az Azure-webjobs-SDK-Extensions GitHub- tárházban található.Source code for the package is in the azure-webjobs-sdk-extensions GitHub repository.

Minden fejlesztési környezetek automatikusan nyújtott támogatás a kötéshez.Support for this binding is automatically provided in all development environments. Nem kell manuálisan telepítse a csomagot, vagy a bővítmény regisztrálásához.You don't have to manually install the package or register the extension.

Csomagok – 2.x függvényekPackages - Functions 2.x

A HTTP-kötések a Microsoft. Azure. webjobs. Extensions. http NuGet csomagban, 3. x verzióban érhetők el.The HTTP bindings are provided in the Microsoft.Azure.WebJobs.Extensions.Http NuGet package, version 3.x. A csomag forráskódja az Azure-webjobs-SDK-Extensions GitHub- tárházban található.Source code for the package is in the azure-webjobs-sdk-extensions GitHub repository.

Minden fejlesztési környezetek automatikusan nyújtott támogatás a kötéshez.Support for this binding is automatically provided in all development environments. Nem kell manuálisan telepítse a csomagot, vagy a bővítmény regisztrálásához.You don't have to manually install the package or register the extension.

EseményindítóTrigger

A HTTP-trigger lehetővé teszi a függvények HTTP-kérelemmel való meghívását.The HTTP trigger lets you invoke a function with an HTTP request. HTTP-trigger használatával kiszolgáló nélküli API-kat hozhat létre, és válaszolhat a webhookokra.You can use an HTTP trigger to build serverless APIs and respond to webhooks.

Alapértelmezés szerint a http-triggerek a HTTP 200-es értéket adja vissza egy üres törzstel az 1. x vagy a HTTP 204 nem tartalmaz üres törzstel rendelkező tartalmat a 2. x függvényben.By default, an HTTP trigger returns HTTP 200 OK with an empty body in Functions 1.x, or HTTP 204 No Content with an empty body in Functions 2.x. A válasz módosításához konfigurálja a http kimeneti kötést.To modify the response, configure an HTTP output binding.

Az eseményindító – példaTrigger - example

Tekintse meg az adott nyelvű példa:See the language-specific example:

Eseményindító - C#-példaTrigger - C# example

Az alábbi példa egy olyan C# függvényt mutat be, name amely egy paramétert keres a lekérdezési karakterláncban vagy a HTTP-kérelem törzsében.The following example shows a C# function that looks for a name parameter either in the query string or the body of the HTTP request. Figyelje meg, hogy a rendszer a visszaadott értéket használja a kimeneti kötéshez, de a visszatérési érték attribútum nem kötelező.Notice that the return value is used for the output binding, but a return value attribute isn't required.

[FunctionName("HttpTriggerCSharp")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] 
    HttpRequest req, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    string name = req.Query["name"];

    string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
    dynamic data = JsonConvert.DeserializeObject(requestBody);
    name = name ?? data?.name;

    return name != null
        ? (ActionResult)new OkObjectResult($"Hello, {name}")
        : new BadRequestObjectResult("Please pass a name on the query string or in the request body");
}

Eseményindító - C#-szkript példaTrigger - C# script example

Az alábbi példa egy trigger-kötést mutat be egy function. JSON fájlban, valamint egy olyan C# parancsfájl -függvényt, amely a kötést használja.The following example shows a trigger binding in a function.json file and a C# script function that uses the binding. A függvény a name paramétert a lekérdezési karakterláncban vagy a HTTP-kérelem törzsében keresi.The function looks for a name parameter either in the query string or the body of the HTTP request.

Íme a function.json fájlt:Here's the function.json file:

{
    "disabled": false,
    "bindings": [
        {
            "authLevel": "function",
            "name": "req",
            "type": "httpTrigger",
            "direction": "in",
            "methods": [
                "get",
                "post"
            ]
        },
        {
            "name": "$return",
            "type": "http",
            "direction": "out"
        }
    ]
}

A konfigurációs szakasz mutatja be ezeket a tulajdonságokat.The configuration section explains these properties.

Az alábbi C# parancsfájl- HttpRequestkód a következőhöz kötődik:Here's C# script code that binds to HttpRequest:

#r "Newtonsoft.Json"

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;

public static async Task<IActionResult> Run(HttpRequest req, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    string name = req.Query["name"];

    string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
    dynamic data = JsonConvert.DeserializeObject(requestBody);
    name = name ?? data?.name;

    return name != null
        ? (ActionResult)new OkObjectResult($"Hello, {name}")
        : new BadRequestObjectResult("Please pass a name on the query string or in the request body");
}

A helyett HttpRequestegyéni objektumhoz is köthető.You can bind to a custom object instead of HttpRequest. Ez az objektum a kérelem törzsében jön létre, és JSON-ként van elemezve.This object is created from the body of the request and parsed as JSON. Hasonlóképpen egy típus is átadható a HTTP-válasz kimeneti kötésnek, és a válasz törzsként, valamint egy 200 állapotkódot is visszaküldhető.Similarly, a type can be passed to the HTTP response output binding and returned as the response body, along with a 200 status code.

using System.Net;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;

public static string Run(Person person, ILogger log)
{   
    return person.Name != null
        ? (ActionResult)new OkObjectResult($"Hello, {person.Name}")
        : new BadRequestObjectResult("Please pass an instance of Person.");
}

public class Person {
     public string Name {get; set;}
}

Eseményindító - F# példaTrigger - F# example

Az alábbi példa egy trigger-kötést mutat be egy function. JSON fájlban F# , valamint egy olyan függvényt, amely a kötést használja.The following example shows a trigger binding in a function.json file and an F# function that uses the binding. A függvény a name paramétert a lekérdezési karakterláncban vagy a HTTP-kérelem törzsében keresi.The function looks for a name parameter either in the query string or the body of the HTTP request.

Íme a function.json fájlt:Here's the function.json file:

{
  "bindings": [
    {
      "authLevel": "function",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in"
    },
    {
      "name": "res",
      "type": "http",
      "direction": "out"
    }
  ],
  "disabled": false
}

A konfigurációs szakasz mutatja be ezeket a tulajdonságokat.The configuration section explains these properties.

Íme a F# kódot:Here's the F# code:

open System.Net
open System.Net.Http
open FSharp.Interop.Dynamic

let Run(req: HttpRequestMessage) =
    async {
        let q =
            req.GetQueryNameValuePairs()
                |> Seq.tryFind (fun kv -> kv.Key = "name")
        match q with
        | Some kv ->
            return req.CreateResponse(HttpStatusCode.OK, "Hello " + kv.Value)
        | None ->
            let! data = Async.AwaitTask(req.Content.ReadAsAsync<obj>())
            try
                return req.CreateResponse(HttpStatusCode.OK, "Hello " + data?name)
            with e ->
                return req.CreateErrorResponse(HttpStatusCode.BadRequest, "Please pass a name on the query string or in the request body")
    } |> Async.StartAsTask

Szüksége van egy project.json fájlra, amely a NuGet használatával FSharp.Interop.Dynamic hivatkozik a és Dynamitey szerelvényekre, ahogy az a következő példában látható:You need a project.json file that uses NuGet to reference the FSharp.Interop.Dynamic and Dynamitey assemblies, as shown in the following example:

{
  "frameworks": {
    "net46": {
      "dependencies": {
        "Dynamitey": "1.0.2",
        "FSharp.Interop.Dynamic": "3.0.0"
      }
    }
  }
}

Eseményindító - JavaScript-példaTrigger - JavaScript example

Az alábbi példa egy trigger-kötést mutat be egy function. JSON fájlban, valamint egy JavaScript -függvényt, amely a kötést használja.The following example shows a trigger binding in a function.json file and a JavaScript function that uses the binding. A függvény a name paramétert a lekérdezési karakterláncban vagy a HTTP-kérelem törzsében keresi.The function looks for a name parameter either in the query string or the body of the HTTP request.

Íme a function.json fájlt:Here's the function.json file:

{
    "disabled": false,    
    "bindings": [
        {
            "authLevel": "function",
            "type": "httpTrigger",
            "direction": "in",
            "name": "req"
        },
        {
            "type": "http",
            "direction": "out",
            "name": "res"
        }
    ]
}

A konfigurációs szakasz mutatja be ezeket a tulajdonságokat.The configuration section explains these properties.

A következő JavaScript-kódot:Here's the JavaScript code:

module.exports = function(context, req) {
    context.log('Node.js HTTP trigger function processed a request. RequestUri=%s', req.originalUrl);

    if (req.query.name || (req.body && req.body.name)) {
        context.res = {
            // status defaults to 200 */
            body: "Hello " + (req.query.name || req.body.name)
        };
    }
    else {
        context.res = {
            status: 400,
            body: "Please pass a name on the query string or in the request body"
        };
    }
    context.done();
};

Trigger – Python-példaTrigger - Python example

Az alábbi példa egy trigger-kötést mutat be egy function. JSON fájlban, valamint egy olyan Python -függvényt, amely a kötést használja.The following example shows a trigger binding in a function.json file and a Python function that uses the binding. A függvény a name paramétert a lekérdezési karakterláncban vagy a HTTP-kérelem törzsében keresi.The function looks for a name parameter either in the query string or the body of the HTTP request.

Íme a function.json fájlt:Here's the function.json file:

{
    "scriptFile": "__init__.py",
    "disabled": false,    
    "bindings": [
        {
            "authLevel": "function",
            "type": "httpTrigger",
            "direction": "in",
            "name": "req"
        },
        {
            "type": "http",
            "direction": "out",
            "name": "res"
        }
    ]
}

A konfigurációs szakasz mutatja be ezeket a tulajdonságokat.The configuration section explains these properties.

Itt látható a Python-kód:Here's the Python code:

import logging
import azure.functions as func


def main(req: func.HttpRequest) -> func.HttpResponse:
    logging.info('Python HTTP trigger function processed a request.')

    name = req.params.get('name')
    if not name:
        try:
            req_body = req.get_json()
        except ValueError:
            pass
        else:
            name = req_body.get('name')

    if name:
        return func.HttpResponse(f"Hello {name}!")
    else:
        return func.HttpResponse(
            "Please pass a name on the query string or in the request body",
            status_code=400
        )

Trigger – Java-példákTrigger - Java examples

Az alábbi példák a HTTP-trigger kötését mutatják be egy function. JSON fájlban, valamint a kötést használó megfelelő Java -függvényeket.The following examples show the HTTP trigger binding in a function.json file and the respective Java functions that use the binding.

Íme a function.json fájlt:Here's the function.json file:

{
    "disabled": false,    
    "bindings": [
        {
            "authLevel": "anonymous",
            "type": "httpTrigger",
            "direction": "in",
            "name": "req"
        },
        {
            "type": "http",
            "direction": "out",
            "name": "res"
        }
    ]
}

Paraméter olvasása a lekérdezési karakterláncból (Java)Read parameter from the query string (Java)

Ez a példa egy nevű idparamétert olvas be application/jsona lekérdezési karakterláncból, és felhasználja az ügyfélnek visszaadott JSON-dokumentum létrehozásához.This example reads a parameter, named id, from the query string, and uses it to build a JSON document returned to the client, with content type application/json.

    @FunctionName("TriggerStringGet")
    public HttpResponseMessage run(
            @HttpTrigger(name = "req", 
              methods = {HttpMethod.GET}, 
              authLevel = AuthorizationLevel.ANONYMOUS)
            HttpRequestMessage<Optional<String>> request,
            final ExecutionContext context) {
        
        // Item list
        context.getLogger().info("GET parameters are: " + request.getQueryParameters());

        // Get named parameter
        String id = request.getQueryParameters().getOrDefault("id", "");

        // Convert and display
        if (id.isEmpty()) {
            return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
                          .body("Document not found.")
                          .build();
        } 
        else {
            // return JSON from to the client
            // Generate document
            final String name = "fake_name";
            final String jsonDocument = "{\"id\":\"" + id + "\", " + 
                                         "\"description\": \"" + name + "\"}";
            return request.createResponseBuilder(HttpStatus.OK)
                          .header("Content-Type", "application/json")
                          .body(jsonDocument)
                          .build();
        }
    }

Szövegtörzs beolvasása POST-kérelemből (Java)Read body from a POST request (Java)

Ez a példa egy post-kérelem Stringtörzsét olvassa be application/json, és felhasználja az ügyfélnek visszaadott JSON-dokumentum létrehozásához.This example reads the body of a POST request, as a String, and uses it to build a JSON document returned to the client, with content type application/json.

    @FunctionName("TriggerStringPost")
    public HttpResponseMessage run(
            @HttpTrigger(name = "req", 
              methods = {HttpMethod.POST}, 
              authLevel = AuthorizationLevel.ANONYMOUS)
            HttpRequestMessage<Optional<String>> request,
            final ExecutionContext context) {
        
        // Item list
        context.getLogger().info("Request body is: " + request.getBody().orElse(""));

        // Check request body
        if (!request.getBody().isPresent()) {
            return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
                          .body("Document not found.")
                          .build();
        } 
        else {
            // return JSON from to the client
            // Generate document
            final String body = request.getBody().get();
            final String jsonDocument = "{\"id\":\"123456\", " + 
                                         "\"description\": \"" + body + "\"}";
            return request.createResponseBuilder(HttpStatus.OK)
                          .header("Content-Type", "application/json")
                          .body(jsonDocument)
                          .build();
        }
    }

Paraméter olvasása útvonalból (Java)Read parameter from a route (Java)

Ez a példa egy kötelező paramétert ( idName) és egy opcionális name paramétert olvas be application/jsonaz útvonal elérési útjából, és felhasználja őket az ügyfélnek visszaadott JSON-dokumentum tartalmának kiépítéséhez.This example reads a mandatory parameter, named id, and an optional parameter name from the route path, and uses them to build a JSON document returned to the client, with content type application/json. T?T

    @FunctionName("TriggerStringRoute")
    public HttpResponseMessage run(
            @HttpTrigger(name = "req", 
              methods = {HttpMethod.GET}, 
              authLevel = AuthorizationLevel.ANONYMOUS,
              route = "trigger/{id}/{name=EMPTY}") // name is optional and defaults to EMPTY
            HttpRequestMessage<Optional<String>> request,
            @BindingName("id") String id,
            @BindingName("name") String name,
            final ExecutionContext context) {
        
        // Item list
        context.getLogger().info("Route parameters are: " + id);

        // Convert and display
        if (id == null) {
            return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
                          .body("Document not found.")
                          .build();
        } 
        else {
            // return JSON from to the client
            // Generate document
            final String jsonDocument = "{\"id\":\"" + id + "\", " + 
                                         "\"description\": \"" + name + "\"}";
            return request.createResponseBuilder(HttpStatus.OK)
                          .header("Content-Type", "application/json")
                          .body(jsonDocument)
                          .build();
        }
    }

POJO-törzs olvasása POST-kérelemből (Java)Read POJO body from a POST request (Java)

Itt látható a következő példában hivatkozott ToDoItem osztály kódja:Here is the code for the ToDoItem class, referenced in this example:


public class ToDoItem {

  private String id;
  private String description;  

  public ToDoItem(String id, String description) {
    this.id = id;
    this.description = description;
  }

  public String getId() {
    return id;
  }

  public String getDescription() {
    return description;
  }
  
  @Override
  public String toString() {
    return "ToDoItem={id=" + id + ",description=" + description + "}";
  }
}

Ez a példa egy POST-kérelem törzsét olvassa be.This example reads the body of a POST request. A kérés törzse automatikusan le lesz szerializálva egy ToDoItem objektumba, és a rendszer visszaadja az ügyfélnek a application/jsontartalomtípussal.The request body gets automatically de-serialized into a ToDoItem object, and is returned to the client, with content type application/json. A ToDoItem (z) paramétert a functions futtatókörnyezet szerializálja, mivel az body HttpMessageResponse.Builder osztály tulajdonságához van rendelve.The ToDoItem parameter is serialized by the Functions runtime as it is assigned to the body property of the HttpMessageResponse.Builder class.

    @FunctionName("TriggerPojoPost")
    public HttpResponseMessage run(
            @HttpTrigger(name = "req", 
              methods = {HttpMethod.POST}, 
              authLevel = AuthorizationLevel.ANONYMOUS)
            HttpRequestMessage<Optional<ToDoItem>> request,
            final ExecutionContext context) {
        
        // Item list
        context.getLogger().info("Request body is: " + request.getBody().orElse(null));

        // Check request body
        if (!request.getBody().isPresent()) {
            return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
                          .body("Document not found.")
                          .build();
        } 
        else {
            // return JSON from to the client
            // Generate document
            final ToDoItem body = request.getBody().get();
            return request.createResponseBuilder(HttpStatus.OK)
                          .header("Content-Type", "application/json")
                          .body(body)
                          .build();
        }
    }

Eseményindító - attribútumokTrigger - attributes

Az C# osztályok könyvtáraibanhasználja a HttpTrigger attribútumot.In C# class libraries, use the HttpTrigger attribute.

Megadhatja az engedélyezési szintet és a megengedett HTTP-metódusokat az attribútumok konstruktorának paraméterei között, és a webhook típusa és az útválasztási sablon tulajdonságok is rendelkezésre állnak.You can set the authorization level and allowable HTTP methods in attribute constructor parameters, and there are properties for webhook type and route template. További információ ezekről a beállításokról: trigger-Configuration.For more information about these settings, see Trigger - configuration. Itt egy HttpTrigger attribútum szerepel a metódus-aláírásban:Here's an HttpTrigger attribute in a method signature:

[FunctionName("HttpTriggerCSharp")]
public static Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Anonymous)] HttpRequest req)
{
    ...
}

Egy teljes példa: eseményindító – C#-példa.For a complete example, see Trigger - C# example.

Eseményindító - konfigurációTrigger - configuration

A következő táblázat ismerteti a megadott kötés konfigurációs tulajdonságaiban a function.json fájlt, és a HttpTrigger attribútum.The following table explains the binding configuration properties that you set in the function.json file and the HttpTrigger attribute.

Function.JSON tulajdonságfunction.json property Attribútum tulajdonságaAttribute property LeírásDescription
typetype n/an/a Kötelező – a httpTriggerkövetkezőre kell beállítani:.Required - must be set to httpTrigger.
directiondirection n/an/a Kötelező – a inkövetkezőre kell beállítani:.Required - must be set to in.
namename n/an/a Kötelező – a kérelem vagy a kérelem törzse függvény kódjában használt változó neve.Required - the variable name used in function code for the request or request body.
authLevelauthLevel AuthLevelAuthLevel Meghatározza, hogy a függvény meghívásához szükség van-e a kulcsokra, ha vannak ilyenek.Determines what keys, if any, need to be present on the request in order to invoke the function. Az engedélyezési szint az alábbi értékek egyike lehet:The authorization level can be one of the following values:
  • anonymous—Nincs szükség API-kulcsra.anonymous—No API key is required.
  • function—Function-specifikus API-kulcs szükséges.function—A function-specific API key is required. Ez az alapértelmezett érték, ha nincs megadva.This is the default value if none is provided.
  • admin—A főkulcs megadása kötelező.admin—The master key is required.
További információt az engedélyezési kulcsokcímű szakaszban talál.For more information, see the section about authorization keys.
methodsmethods MethodsMethods A függvény által válaszoló HTTP-metódusok tömbje.An array of the HTTP methods to which the function responds. Ha nincs megadva, a függvény az összes HTTP-metódusra válaszol.If not specified, the function responds to all HTTP methods. Lásd: a http-végpont testreszabása.See customize the http endpoint.
routeroute RouteRoute Meghatározza azt az útválasztási sablont, amely azt szabályozza, hogy a függvény milyen URL-címeket válaszol.Defines the route template, controlling to which request URLs your function responds. Az alapértelmezett érték, <functionname>ha nincs megadva.The default value if none is provided is <functionname>. További információ: a http-végpont testreszabása.For more information, see customize the http endpoint.
webHookTypewebHookType WebHookTypeWebHookType Csak az 1. x verziójú futtatókörnyezet esetében támogatott.Supported only for the version 1.x runtime.

Konfigurálja a HTTP-triggert, amely webhook -fogadóként működik a megadott szolgáltatónál.Configures the HTTP trigger to act as a webhook receiver for the specified provider. Ha ezt a methods tulajdonságot beállítja, ne állítsa be a tulajdonságot.Don't set the methods property if you set this property. A webhook típusa a következő értékek egyike lehet:The webhook type can be one of the following values:
  • genericJson—Egy általános célú webhook-végpont egy adott szolgáltató logikája nélkül.genericJson—A general-purpose webhook endpoint without logic for a specific provider. Ez a beállítás csak a http post és a application/json tartalomtípus használatával korlátozza a kérelmeket.This setting restricts requests to only those using HTTP POST and with the application/json content type.
  • github—A függvény válaszol a GitHub-webhookokra.github—The function responds to GitHub webhooks. Ne használja a authLevel tulajdonságot GitHub-webhookokkal.Do not use the authLevel property with GitHub webhooks. További információt a cikk későbbi, a GitHub-webhookok című szakaszában talál.For more information, see the GitHub webhooks section later in this article.
  • slack—A függvény válaszol a Slackwebhookokra.slack—The function responds to Slack webhooks. Ne használja a authLevel tulajdonságot Slack webhookokkal.Do not use the authLevel property with Slack webhooks. További információt a cikk későbbi, a Slack webhookok című szakaszában talál.For more information, see the Slack webhooks section later in this article.

Eseményindító - használatTrigger - usage

A C# és F# a függvények esetében deklarálhatja az indító bemenet HttpRequest típusát vagy egyéni típusként.For C# and F# functions, you can declare the type of your trigger input to be either HttpRequest or a custom type. Ha úgy dönt HttpRequest, teljes hozzáférést kap a kérelem objektumhoz.If you choose HttpRequest, you get full access to the request object. Egyéni típus esetén a futásidejű megpróbálja elemezni a JSON-kérés törzsét az objektum tulajdonságainak beállításához.For a custom type, the runtime tries to parse the JSON request body to set the object properties.

JavaScript-függvények esetén a functions futtatókörnyezet a kérési objektum helyett a kérelem törzsét biztosítja.For JavaScript functions, the Functions runtime provides the request body instead of the request object. További információ: JavaScript trigger példa.For more information, see the JavaScript trigger example.

A HTTP-végpont testreszabásaCustomize the HTTP endpoint

Alapértelmezés szerint a HTTP-triggerekhez tartozó függvény létrehozásakor a függvény címezhető az űrlap egy útvonalával:By default when you create a function for an HTTP trigger, the function is addressable with a route of the form:

http://<yourapp>.azurewebsites.net/api/<funcname>

Ezt az útvonalat a http-trigger bemeneti route kötésének opcionális tulajdonságával is testreszabhatja.You can customize this route using the optional route property on the HTTP trigger's input binding. Példaként a következő function. JSON fájl definiál egy route tulajdonságot egy http-triggerhez:As an example, the following function.json file defines a route property for an HTTP trigger:

{
    "bindings": [
    {
        "type": "httpTrigger",
        "name": "req",
        "direction": "in",
        "methods": [ "get" ],
        "route": "products/{category:alpha}/{id:int?}"
    },
    {
        "type": "http",
        "name": "res",
        "direction": "out"
    }
    ]
}

Ennek a konfigurációnak a használatával a függvény mostantól a következő útvonalon érhető el az eredeti útvonal helyett.Using this configuration, the function is now addressable with the following route instead of the original route.

http://<yourapp>.azurewebsites.net/api/products/electronics/357

Ez lehetővé teszi, hogy a függvény programkódja támogassa a címben, a kategóriában és az _azonosítóban_szereplő két paramétert. A paraméterekkel bármilyen webes API Route -korlátozást használhat.This allows the function code to support two parameters in the address, category and id. You can use any Web API Route Constraint with your parameters. A következő C# függvény kód mindkét paraméter használatát teszi lehetővé.The following C# function code makes use of both parameters.

public static Task<IActionResult> Run(HttpRequest req, string category, int? id, ILogger log)
{
    if (id == null)
    {
        return (ActionResult)new OkObjectResult($"All {category} items were requested.");
    }
    else
    {
        return (ActionResult)new OkObjectResult($"{category} item with id = {id} has been requested.");
    }
    
    // -----
    log.LogInformation($"C# HTTP trigger function processed a request. RequestUri={req.RequestUri}");
}

Itt látható a Node. js-függvény kódja, amely ugyanazt az útválasztási paramétert használja.Here is Node.js function code that uses the same route parameters.

module.exports = function (context, req) {

    var category = context.bindingData.category;
    var id = context.bindingData.id;

    if (!id) {
        context.res = {
            // status defaults to 200 */
            body: "All " + category + " items were requested."
        };
    }
    else {
        context.res = {
            // status defaults to 200 */
            body: category + " item with id = " + id + " was requested."
        };
    }

    context.done();
}

Alapértelmezés szerint az összes függvény útvonala az API-val előtaggal van ellátva.By default, all function routes are prefixed with api. Az előtagot a http.routePrefix Host. JSON fájlban található tulajdonság használatával is testreszabhatja vagy eltávolíthatja.You can also customize or remove the prefix using the http.routePrefix property in your host.json file. Az alábbi példa eltávolítja az API Route előtagot egy üres karakterlánc használatával a Host. JSON fájlban lévő előtaghoz.The following example removes the api route prefix by using an empty string for the prefix in the host.json file.

{
    "http": {
    "routePrefix": ""
    }
}

Ügyfél-identitások használataWorking with client identities

Ha a Function alkalmazás app Service hitelesítés/engedélyezésfunkciót használja, megtekintheti a kód alapján a hitelesített ügyfelek adatait.If your function app is using App Service Authentication / Authorization, you can view information about authenticated clients from your code. Ez az információ a platform által befecskendezett kérelem fejléckéntérhető el.This information is available as request headers injected by the platform.

Ezeket az információkat a kötési adatokból is elolvashatja.You can also read this information from binding data. Ez a funkció csak a functions 2. x futtatókörnyezetben érhető el.This capability is only available to the Functions 2.x runtime. Emellett jelenleg csak a .NET nyelveken érhető el.It is also currently only available for .NET languages.

.NET-nyelveken ez az információ ClaimsPrincipalérhető el.In .NET languages, this information is available as a ClaimsPrincipal. A ClaimsPrincipal a kérelem környezetének részeként érhető el, ahogy az az alábbi példában is látható:The ClaimsPrincipal is available as part of the request context as shown in the following example:

using System.Net;
using Microsoft.AspNetCore.Mvc;
using System.Security.Claims;

public static IActionResult Run(HttpRequest req, ILogger log)
{
    ClaimsPrincipal identities = req.HttpContext.User;
    // ...
    return new OkObjectResult();
}

Azt is megteheti, hogy a ClaimsPrincipal egyszerűen szerepelhet további paraméterként a függvény aláírása során:Alternatively, the ClaimsPrincipal can simply be included as an additional parameter in the function signature:

#r "Newtonsoft.Json"

using System.Net;
using Microsoft.AspNetCore.Mvc;
using System.Security.Claims;
using Newtonsoft.Json.Linq;

public static void Run(JObject input, ClaimsPrincipal principal, ILogger log)
{
    // ...
    return;
}

Engedélyezési kulcsokAuthorization keys

A függvények lehetővé teszik a kulcsok használatát, hogy a fejlesztés során megnehezíti a HTTP-függvény végpontjának elérését.Functions lets you use keys to make it harder to access your HTTP function endpoints during development. A szabványos HTTP-triggerek esetében előfordulhat, hogy ilyen API-kulcsra van szükség a kérelemben.A standard HTTP trigger may require such an API key be present in the request.

Fontos

Míg a kulcsok segíthetnek a HTTP-végpontok kiépítésében a fejlesztés során, nem céljuk a HTTP-triggerek védelme az éles környezetben.While keys may help obfuscate your HTTP endpoints during development, they are not intended as a way to secure an HTTP trigger in production. További információ: http-végpont biztonságossá tétele éleskörnyezetben.To learn more, see Secure an HTTP endpoint in production.

Megjegyzés

A functions 1. x futtatókörnyezetben a webhook-szolgáltatók több módon is használhatják a kérelmeket, attól függően, hogy mit támogat a szolgáltató.In the Functions 1.x runtime, webhook providers may use keys to authorize requests in a variety of ways, depending on what the provider supports. Ezt a webhookok és kulcsoktartalmazzák.This is covered in Webhooks and keys. A 2. x verziójú futtatókörnyezet nem tartalmaz beépített támogatást a webhook-szolgáltatók számára.The version 2.x runtime does not include built-in support for webhook providers.

A kulcsok két típusa létezik:There are two types of keys:

  • Gazdagép kulcsai: Ezeket a kulcsokat a Function alkalmazásban található összes függvény megosztja.Host keys: These keys are shared by all functions within the function app. API-kulcsként való használata esetén ezek a függvények a Function alkalmazáson belüli bármelyik függvényhez hozzáférhetnek.When used as an API key, these allow access to any function within the function app.
  • Függvények kulcsai: Ezek a kulcsok csak azokra a függvényekre érvényesek, amelyekben definiálva vannak.Function keys: These keys apply only to the specific functions under which they are defined. API-kulcsként való használata esetén ezek csak a funkció elérését teszik lehetővé.When used as an API key, these only allow access to that function.

A rendszer az egyes kulcsokat hivatkozásként nevezi el, és az alapértelmezett kulcs ("default") szerepel a függvény és a gazdagép szintjén.Each key is named for reference, and there is a default key (named "default") at the function and host level. A függvények kulcsai elsőbbséget élveznek a gazdagép kulcsaival szemben.Function keys take precedence over host keys. Ha két kulcs van definiálva ugyanazzal a névvel, a rendszer mindig a függvény kulcsát használja.When two keys are defined with the same name, the function key is always used.

Minden Function alkalmazásnak van egy speciálisfőkulcsa is.Each function app also has a special master key. Ez a kulcs egy nevű _mastergazdagép-kulcs, amely rendszergazdai hozzáférést biztosít a futásidejű API-khoz.This key is a host key named _master, which provides administrative access to the runtime APIs. Ezt a kulcsot nem lehet visszavonni.This key cannot be revoked. Ha az engedélyezési szintjét adminállítja be, a kérelmeknek a főkulcsot kell használniuk; minden más kulcs engedélyezési hibát eredményez.When you set an authorization level of admin, requests must use the master key; any other key results in authorization failure.

Figyelemfelhívás

A főkulcs által biztosított Function app emelt szintű engedélyei miatt ne ossza meg ezt a kulcsot harmadik felekkel, vagy terjessze azt natív ügyfélalkalmazások számára.Due to the elevated permissions in your function app granted by the master key, you should not share this key with third parties or distribute it in native client applications. A rendszergazdai jogosultsági szint kiválasztásakor legyen körültekintő.Use caution when choosing the admin authorization level.

Kulcsok beszerzéseObtaining keys

A kulcsok tárolása az Azure-beli Function-alkalmazás részeként történik, és a rendszer a nyugalmi állapotban van titkosítva.Keys are stored as part of your function app in Azure and are encrypted at rest. Ha meg szeretné tekinteni a kulcsokat, újakat kell létrehoznia, vagy új értékekre kell visszagörgetni a kulcsokat, navigáljon a Azure Portal valamelyik http-triggerrel elindított függvényéhez, és válassza a kezeléslehetőséget.To view your keys, create new ones, or roll keys to new values, navigate to one of your HTTP-triggered functions in the Azure portal and select Manage.

A funkcióbillentyűk kezelése a portálon.

A KULCSKEZELŐ API-val programozott módon szerezheti be a functions-kulcsokat.You may obtain function keys programmatically by using Key management API.

API-kulcs engedélyezéseAPI key authorization

A legtöbb HTTP-trigger sablonhoz API-kulcs szükséges a kérelemben.Most HTTP trigger templates require an API key in the request. Így a HTTP-kérelem általában a következő URL-címhez hasonlít:So your HTTP request normally looks like the following URL:

https://<APP_NAME>.azurewebsites.net/api/<FUNCTION_NAME>?code=<API_KEY>

A kulcs egy nevű codelekérdezési karakterlánc-változóban is szerepelhet, a fentiek szerint.The key can be included in a query string variable named code, as above. Egy x-functions-key HTTP-fejlécben is szerepelhet.It can also be included in an x-functions-key HTTP header. A kulcs értéke lehet a függvényhez definiált bármelyik funkcióbillentyű, vagy bármely gazdagép kulcsa.The value of the key can be any function key defined for the function, or any host key.

Engedélyezheti a névtelen kérelmeket, amelyek nem igénylik a kulcsokat.You can allow anonymous requests, which do not require keys. Azt is megkövetelheti, hogy a főkulcs legyen használatban.You can also require that the master key be used. Az alapértelmezett engedélyezési szintet a kötés JSON authLevel tulajdonságának használatával módosíthatja.You change the default authorization level by using the authLevel property in the binding JSON. További információ: trigger-Configuration.For more information, see Trigger - configuration.

Megjegyzés

A függvények helyi futtatásakor az engedélyezés le van tiltva a megadott hitelesítési szint beállításától függetlenül.When running functions locally, authorization is disabled regardless of the specified authentication level setting. Az Azure-ba való közzététel authLevel után a rendszer kikényszeríti az trigger beállítását.After publishing to Azure, the authLevel setting in your trigger is enforced.

HTTP-végpont biztonságossá tétele éles környezetbenSecure an HTTP endpoint in production

Az üzemi végpontok éles környezetben történő teljes biztonságossá tételéhez érdemes megfontolni a következő Function szintű biztonsági beállítások egyikének megvalósítását:To fully secure your function endpoints in production, you should consider implementing one of the following function app-level security options:

  • Kapcsolja be App Service hitelesítés/engedélyezés funkciót a Function alkalmazáshoz.Turn on App Service Authentication / Authorization for your function app. A App Service platform lehetővé teszi, hogy a Azure Active Directory (HRE) és számos harmadik féltől származó személyazonosság-szolgáltató használatával hitelesítse ügyfeleit.The App Service platform lets use Azure Active Directory (AAD) and several third-party identity providers to authenticate clients. Ezt használhatja a függvények egyéni engedélyezési szabályainak megvalósításához, és a függvény kódjából is dolgozhat a felhasználói adatokkal.You can use this to implement custom authorization rules for your functions, and you can work with user information from your function code. További információ: hitelesítés és engedélyezés Azure app Service és ügyfél-identitások használata.To learn more, see Authentication and authorization in Azure App Service and Working with client identities.

  • Az Azure API Management (APIM) használatával hitelesítheti a kérelmeket.Use Azure API Management (APIM) to authenticate requests. A APIM számos API-biztonsági beállítást biztosít a bejövő kérelmekhez.APIM provides a variety of API security options for incoming requests. További tudnivalók: API Management hitelesítési házirendek.To learn more, see API Management authentication policies. A APIM használatával beállíthatja, hogy a Function alkalmazás csak a APIM-példány IP-címéről fogadjon kérelmeket.With APIM in place, you can configure your function app to accept requests only from the IP address of your APIM instance. További információt az IP-címek korlátozásaicímű témakörben talál.To learn more, see IP address restrictions.

  • A Function alkalmazás üzembe helyezése egy Azure App Service Environment (bevezetési).Deploy your function app to an Azure App Service Environment (ASE). A bevezetési szolgáltatás dedikált üzemeltetési környezetet biztosít a függvények futtatásához.ASE provides a dedicated hosting environment in which to run your functions. A bevezetője lehetővé teszi egyetlen előtér-átjáró konfigurálását, amely az összes bejövő kérelem hitelesítésére használható.ASE lets you configure a single front-end gateway that you can use to authenticate all incoming requests. További információ: webalkalmazási tűzfal (WAF) konfigurálása app Service Environmenthoz.For more information, see Configuring a Web Application Firewall (WAF) for App Service Environment.

Ha ezen alkalmazás-szintű biztonsági módszerek egyikét használja, állítsa be a HTTP által aktivált függvény hitelesítési szintjét a anonymouskövetkezőre:.When using one of these function app-level security methods, you should set the HTTP-triggered function authentication level to anonymous.

webhooksWebhooks

Megjegyzés

A webhook mód csak a functions futtatókörnyezet 1. x verziójához érhető el.Webhook mode is only available for version 1.x of the Functions runtime. Ez a változás a 2. x verzióban a HTTP-eseményindítók teljesítményének javítása érdekében történt.This change was made to improve the performance of HTTP triggers in version 2.x.

Az 1. x verzióban a webhook-sablonok további ellenőrzéseket biztosítanak a webhook hasznos adataihoz.In version 1.x, webhook templates provide additional validation for webhook payloads. A 2. x verzióban az alap HTTP-trigger továbbra is működik, és a webhookok ajánlott megközelítése.In version 2.x, the base HTTP trigger still works and is the recommended approach for webhooks.

GitHub-webhookokGitHub webhooks

A GitHub-webhookokra való reagáláshoz először hozza létre a függvényt egy HTTP-triggerrel , és állítsa githubbe a webHookType tulajdonságot a következőre:.To respond to GitHub webhooks, first create your function with an HTTP Trigger, and set the webHookType property to github. Ezután másolja a saját URL-címét és API-kulcsát a GitHub-adattár Hozzáadás webhook lapjára.Then copy its URL and API key into the Add webhook page of your GitHub repository.

Slack-webhookokSlack webhooks

A Slack webhook létrehoz egy jogkivonatot, és nem adja meg az Ön által megadott értéket, ezért egy függvény-specifikus kulcsot kell konfigurálnia a biztonsági másolatból a Tartalékidőből.The Slack webhook generates a token for you instead of letting you specify it, so you must configure a function-specific key with the token from Slack. Lásd: engedélyezési kulcsok.See Authorization keys.

Webhookok és kulcsokWebhooks and keys

A webhook-engedélyezést a webhook fogadó összetevője kezeli, amely a HTTP-trigger része, és a mechanizmus a webhook típusától függően változik.Webhook authorization is handled by the webhook receiver component, part of the HTTP trigger, and the mechanism varies based on the webhook type. Mindegyik mechanizmus egy kulcsra támaszkodik.Each mechanism does rely on a key. Alapértelmezés szerint a "default" nevű funkcióbillentyű van használatban.By default, the function key named "default" is used. Ha másik kulcsot szeretne használni, konfigurálja úgy a webhook-szolgáltatót, hogy a következő módszerek egyikével küldje el a kulcs nevét a kérelemben:To use a different key, configure the webhook provider to send the key name with the request in one of the following ways:

  • Lekérdezési karakterlánc: A szolgáltató a clientid lekérdezési karakterlánc paraméterében adja át a kulcs nevét, https://<APP_NAME>.azurewebsites.net/api/<FUNCTION_NAME>?clientid=<KEY_NAME>például:.Query string: The provider passes the key name in the clientid query string parameter, such as https://<APP_NAME>.azurewebsites.net/api/<FUNCTION_NAME>?clientid=<KEY_NAME>.
  • Kérelem fejléce: A szolgáltató átadja a kulcs nevét a x-functions-clientid fejlécben.Request header: The provider passes the key name in the x-functions-clientid header.

Trigger – korlátokTrigger - limits

A HTTP-kérés hossza legfeljebb 100 MB (104 857 600 bájt), az URL-cím hossza pedig 4 KB (4 096 bájt) lehet.The HTTP request length is limited to 100 MB (104,857,600 bytes), and the URL length is limited to 4 KB (4,096 bytes). Ezeket a korlátokat a futtatókörnyezet httpRuntime web. config fájljánakeleme határozza meg.These limits are specified by the httpRuntime element of the runtime's Web.config file.

Ha a HTTP-triggert használó függvény nem fejeződött be körülbelül 2,5 percen belül, az átjáró időtúllépést jelez, és HTTP 502-hibát ad vissza.If a function that uses the HTTP trigger doesn't complete within about 2.5 minutes, the gateway will time out and return an HTTP 502 error. A függvény továbbra is futni fog, de nem tud HTTP-választ adni.The function will continue running but will be unable to return an HTTP response. A hosszú ideig futó függvények esetében javasoljuk, hogy kövesse az aszinkron mintákat, és olyan helyet küldjön vissza, amelyben pingelheti a kérés állapotát.For long-running functions, we recommend that you follow async patterns and return a location where you can ping the status of the request. További információ a függvények futtatásának időtartamáról: skálázás és üzemeltetés – fogyasztási terv.For information about how long a function can run, see Scale and hosting - Consumption plan.

Eseményindító - host.json tulajdonságaiTrigger - host.json properties

A Host. JSON fájl olyan beállításokat tartalmaz, amelyek a http-trigger viselkedését vezérlik.The host.json file contains settings that control HTTP trigger behavior.

{
    "http": {
        "routePrefix": "api",
        "maxOutstandingRequests": 200,
        "maxConcurrentRequests": 100,
        "dynamicThrottlesEnabled": true
    }
}
TulajdonságProperty AlapértelmezettDefault LeírásDescription
routePrefixroutePrefix apiapi Az útválasztási előtagot, amely az összes útvonal vonatkozik.The route prefix that applies to all routes. Üres karakterlánc segítségével távolítsa el az alapértelmezett előtag.Use an empty string to remove the default prefix.
maxOutstandingRequestsmaxOutstandingRequests 200*200* Egy adott időpontban tartott szálankénti függőben lévő kérelmek maximális száma.The maximum number of outstanding requests that are held at any given time. Ez a korlátozás kérelmek várólistára kerülnek, de nem kezdték végrehajtása, valamint bármely, a folyamat-végrehajtást tartalmaz.This limit includes requests that are queued but have not started executing, as well as any in progress executions. Minden olyan bejövő kérések át a korlátot 429 "Túlságosan elfoglalt" választ a rendszer elutasítja.Any incoming requests over this limit are rejected with a 429 "Too Busy" response. Amely lehetővé teszi, hogy a hívók időalapú újrapróbálkozási stratégiák használatát tervezni, és vezérelheti a kérések maximális késéseket is segít.That allows callers to employ time-based retry strategies, and also helps you to control maximum request latencies. Ez csak vezérli, üzenetsor-kezelési, amely a gazdagép szkript végrehajtási útvonalát belül történik.This only controls queuing that occurs within the script host execution path. Más várólisták, például az ASP.NET-kérelmek várólistája továbbra is lesz érvényben, és ez a beállítás nem befolyásolja.Other queues such as the ASP.NET request queue will still be in effect and unaffected by this setting. *Az alapértelmezett verzió 1.x korlátlan streameken működő (-1).*The default for version 1.x is unbounded (-1). Az alapértelmezett verzió használatalapú 2.x 200.The default for version 2.x in a consumption plan is 200. Az alapértelmezett verzió 2.x egy dedikált csomagban korlátlan streameken működő (-1).The default for version 2.x in a dedicated plan is unbounded (-1).
maxConcurrentRequestsmaxConcurrentRequests 100*100* Http-függvények, amelyek végrehajtható párhuzamosan maximális számát.The maximum number of http functions that will be executed in parallel. Ez lehetővé teszi a vezérlő egyidejűséget, amelyek segíthetnek az erőforrás-felhasználás kezelése.This allows you to control concurrency, which can help manage resource utilization. Előfordulhat például, hogy egy http-függvény, amely sok rendszererőforrást (memória / / processzorfoglalatok) használja úgy, hogy ha egyidejűség túl magas problémákat okoz.For example, you might have an http function that uses a lot of system resources (memory/cpu/sockets) such that it causes issues when concurrency is too high. Vagy előfordulhat, hogy egy függvényt, amely lehetővé teszi a kimenő kérelmeket egy külső szolgáltatás, és ezeket a hívások sebessége korlátozott kell.Or you might have a function that makes outbound requests to a third party service, and those calls need to be rate limited. Ezekben az esetekben alkalmazása egy késleltetési ide segítségével.In these cases, applying a throttle here can help. *Az alapértelmezett verzió 1.x korlátlan streameken működő (-1).*The default for version 1.x is unbounded (-1). Az alapértelmezett használatalapú 2.x verzió pedig a 100.The default for version 2.x in a consumption plan is 100. Az alapértelmezett verzió 2.x egy dedikált csomagban korlátlan streameken működő (-1).The default for version 2.x in a dedicated plan is unbounded (-1).
dynamicThrottlesEnableddynamicThrottlesEnabled Igaz*true* Ha engedélyezve van, ez a beállítás megadja a kérelemfeldolgozási folyamatba, rendszeres időközönként ellenőrizze a rendszerteljesítményt számlálók, például a kapcsolatokat/szálak/folyamatok/memória/cpu/stb., és ha ezek a számlálók bármelyike egy beépített magas meghaladja a küszöbértéket (80 %), a kérelmek lesz-e. elutasított 429 "Túlságosan elfoglalt" választ, mindaddig, amíg a számláló térjen vissza a normális üzemi szint.When enabled, this setting causes the request processing pipeline to periodically check system performance counters like connections/threads/processes/memory/cpu/etc. and if any of those counters are over a built-in high threshold (80%), requests will be rejected with a 429 "Too Busy" response until the counter(s) return to normal levels. *Az alapértelmezett verzió 1.x értéke hamis.*The default for version 1.x is false. Az alapértelmezett verzió használatalapú 2.x értéke igaz.The default for version 2.x in a consumption plan is true. Az alapértelmezett verzió egy dedikált csomagban 2.x értéke hamis.The default for version 2.x in a dedicated plan is false.

OutputOutput

A http-kimeneti kötés használatával válaszolhat a HTTP-kérelem feladójának.Use the HTTP output binding to respond to the HTTP request sender. Ehhez a kötéshez HTTP-trigger szükséges, és lehetővé teszi az trigger kérelméhez tartozó válasz testreszabását.This binding requires an HTTP trigger and allows you to customize the response associated with the trigger's request. Ha nincs megadva HTTP-kimeneti kötés, a http-trigger a HTTP 200 OK értéket adja vissza üres törzstel az 1. x függvényben, vagy a HTTP 204 nem tartalmaz üres törzstel rendelkező tartalmat a 2. x függvényben.If an HTTP output binding is not provided, an HTTP trigger returns HTTP 200 OK with an empty body in Functions 1.x, or HTTP 204 No Content with an empty body in Functions 2.x.

Kimenete – konfigurációOutput - configuration

A következő táblázat a function. JSON fájlban beállított kötési konfigurációs tulajdonságokat ismerteti.The following table explains the binding configuration properties that you set in the function.json file. Az C# osztályok könyvtáraiban nincsenek a function. JSON -tulajdonságokkal egyező attribútumok.For C# class libraries, there are no attribute properties that correspond to these function.json properties.

TulajdonságProperty LeírásDescription
typetype Meg kell http.Must be set to http.
directiondirection Meg kell out.Must be set to out.
namename A válasz kódjában használt változó neve, vagy $return a visszatérési érték használata.The variable name used in function code for the response, or $return to use the return value.

Kimenet – használatOutput - usage

HTTP-válasz küldéséhez használja a Language-standard Response mintákat.To send an HTTP response, use the language-standard response patterns. A C# vagy C# a szkriptben állítsa vissza a függvény IActionResult visszatérési típusát vagy Task<IActionResult>.In C# or C# script, make the function return type IActionResult or Task<IActionResult>. A C#-ben a Return Value attribútum nem kötelező.In C#, a return value attribute isn't required.

A válaszokat például az trigger példájatartalmazza.For example responses, see the trigger example.

További lépésekNext steps

Tudjon meg többet az Azure functions eseményindítók és kötésekLearn more about Azure functions triggers and bindings