HTTP-Trigger und -Bindungen in Azure FunctionsAzure Functions HTTP triggers and bindings

In diesem Artikel wird erläutert, wie HTTP-Trigger und -Ausgabebindungen in Azure Functions verwendet werden.This article explains how to work with HTTP triggers and output bindings in Azure Functions.

Ein HTTP-Trigger kann so angepasst werden, dass er auf Webhooks antwortet.An HTTP trigger can be customized to respond to webhooks.

Dies sind Referenzinformationen für Azure Functions-Entwickler.This is reference information for Azure Functions developers. Falls Sie mit Azure Functions noch nicht vertraut sind, beginnen Sie mit den folgenden Ressourcen:If you're new to Azure Functions, start with the following resources:

Tipp

Wenn Sie die HTTP- oder WebHook-Bindungen verwenden möchten, vermeiden Sie die Portauslastung, die durch nicht ordnungsgemäße Instanziierung von HttpClient verursacht werden kann.If you plan to use the HTTP or WebHook bindings, plan to avoid port exhaustion that can be caused by improper instantiation of HttpClient. Weitere Informationen finden Sie unter How to manage connections in Azure Functions (Verwalten von Verbindungen in Azure Functions).For more information, see How to manage connections in Azure Functions.

Der Code in diesem Artikel weist standardmäßig die Functions 2.x-Syntax auf, die .NET Core verwendet.The code in this article defaults to Functions 2.x syntax which uses .NET Core. Informationen zur 1.x-Syntax finden Sie in den 1.x-Functions-Vorlagen.For information on the 1.x syntax, see the 1.x functions templates.

Pakete: Functions 1.xPackages - Functions 1.x

Die HTTP-Bindungen werden im NuGet-Paket Microsoft.Azure.WebJobs.Extensions.Http der Version 1.x bereitgestellt.The HTTP bindings are provided in the Microsoft.Azure.WebJobs.Extensions.Http NuGet package, version 1.x. Den Quellcode für das Paket finden Sie im GitHub-Repository azure-webjobs-sdk-extensions.Source code for the package is in the azure-webjobs-sdk-extensions GitHub repository.

Unterstützung für diese Bindung wird automatisch in allen Entwicklungsumgebungen bereitgestellt.Support for this binding is automatically provided in all development environments. Sie müssen das Paket nicht manuell installieren oder die Erweiterung registrieren.You don't have to manually install the package or register the extension.

Pakete: Functions 2.xPackages - Functions 2.x

Die HTTP-Bindungen werden im NuGet-Paket Microsoft.Azure.WebJobs.Extensions.Http der Version 3.x bereitgestellt.The HTTP bindings are provided in the Microsoft.Azure.WebJobs.Extensions.Http NuGet package, version 3.x. Den Quellcode für das Paket finden Sie im GitHub-Repository azure-webjobs-sdk-extensions.Source code for the package is in the azure-webjobs-sdk-extensions GitHub repository.

Unterstützung für diese Bindung wird automatisch in allen Entwicklungsumgebungen bereitgestellt.Support for this binding is automatically provided in all development environments. Sie müssen das Paket nicht manuell installieren oder die Erweiterung registrieren.You don't have to manually install the package or register the extension.

TriggerTrigger

Mit dem HTTP-Trigger können Sie eine Funktion mit einer HTTP-Anforderung aufrufen.The HTTP trigger lets you invoke a function with an HTTP request. Sie können einen HTTP-Trigger zum Erstellen von serverlosen APIs und zum Antworten auf Webhooks verwenden.You can use an HTTP trigger to build serverless APIs and respond to webhooks.

Standardmäßig gibt ein HTTP-Trigger in Functions 1.x den HTTP-Statuscode 200 „OK“ ohne Text oder in Functions 2.x den HTTP-Statuscode 204 „No Content“ ohne Text zurück.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. Um diese Antwort zu ändern, konfigurieren Sie eine HTTP-Ausgabebindung.To modify the response, configure an HTTP output binding.

Trigger: BeispielTrigger - example

Sehen Sie sich das sprachspezifische Beispiel an:See the language-specific example:

Trigger: C#-BeispielTrigger - C# example

Das folgende Beispiel zeigt eine C#-Funktion, die in der Abfragezeichenfolge oder im Text der HTTP-Anforderung nach einem name-Parameter sucht.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. Beachten Sie, dass der Rückgabewert für die Ausgabebindung verwendet wird, jedoch kein Attribut vom Rückgabewert erforderlich ist.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");
}

Trigger: C#-SkriptbeispielTrigger - C# script example

Das folgende Beispiel zeigt eine Triggerbindung in einer Datei function.json sowie eine C#-Skriptfunktion, die die Bindung verwendet.The following example shows a trigger binding in a function.json file and a C# script function that uses the binding. Die Funktion sucht in der Abfragezeichenfolge oder im Text der HTTP-Anforderung nach einem name-Parameter.The function looks for a name parameter either in the query string or the body of the HTTP request.

Die Datei function.json sieht wie folgt aus: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"
        }
    ]
}

Weitere Informationen zu diesen Eigenschaften finden Sie im Abschnitt Konfiguration.The configuration section explains these properties.

C#-Skriptcode für die Bindung an HttpRequest: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");
}

Sie können anstelle von HttpRequest auch an ein benutzerdefiniertes Objekt binden.You can bind to a custom object instead of HttpRequest. Dieses Objekt wird aus dem Text der Anforderung erstellt und als JSON analysiert.This object is created from the body of the request and parsed as JSON. Analog dazu kann ein Typ an die Ausgabebindung der HTTP-Antwort übergeben und zusammen mit dem Statuscode 200 als Antworttext zurückgegeben werden.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;}
}

Trigger: F#-BeispielTrigger - F# example

Das folgende Beispiel zeigt eine Triggerbindung in einer Datei function.json sowie eine F#-Funktion, die die Bindung verwendet.The following example shows a trigger binding in a function.json file and an F# function that uses the binding. Die Funktion sucht in der Abfragezeichenfolge oder im Text der HTTP-Anforderung nach einem name-Parameter.The function looks for a name parameter either in the query string or the body of the HTTP request.

Die Datei function.json sieht wie folgt aus:Here's the function.json file:

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

Weitere Informationen zu diesen Eigenschaften finden Sie im Abschnitt Konfiguration.The configuration section explains these properties.

Der F#-Code lautet wie folgt: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

Sie benötigen eine Datei project.json, die wie im folgenden Beispiel gezeigt mithilfe von NuGet auf die Assemblys FSharp.Interop.Dynamic und Dynamitey verweist: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"
      }
    }
  }
}

Trigger: JavaScript-BeispielTrigger - JavaScript example

Das folgende Beispiel zeigt eine Triggerbindung in einer Datei function.json sowie eine JavaScript-Funktion, die die Bindung verwendet.The following example shows a trigger binding in a function.json file and a JavaScript function that uses the binding. Die Funktion sucht in der Abfragezeichenfolge oder im Text der HTTP-Anforderung nach einem name-Parameter.The function looks for a name parameter either in the query string or the body of the HTTP request.

Die Datei function.json sieht wie folgt aus:Here's the function.json file:

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

Weitere Informationen zu diesen Eigenschaften finden Sie im Abschnitt Konfiguration.The configuration section explains these properties.

Der JavaScript-Code sieht wie folgt aus: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: Beispiel für PythonTrigger - Python example

Das folgende Beispiel zeigt eine Triggerbindung in einer Datei function.json sowie eine Python-Funktion, die die Bindung verwendet.The following example shows a trigger binding in a function.json file and a Python function that uses the binding. Die Funktion sucht in der Abfragezeichenfolge oder im Text der HTTP-Anforderung nach einem name-Parameter.The function looks for a name parameter either in the query string or the body of the HTTP request.

Die Datei function.json sieht wie folgt aus: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"
        }
    ]
}

Weitere Informationen zu diesen Eigenschaften finden Sie im Abschnitt Konfiguration.The configuration section explains these properties.

Dies ist der Python-Code: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-BeispieleTrigger - Java examples

Das folgende Beispiel zeigt die HTTP-Triggerbindung in einer Datei function.json sowie die entsprechenden Java-Funktionen, die die Bindung verwenden.The following examples show the HTTP trigger binding in a function.json file and the respective Java functions that use the binding.

Die Datei function.json sieht wie folgt aus:Here's the function.json file:

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

Lesen eines Parameters aus der Abfragezeichenfolge (Java)Read parameter from the query string (Java)

Dieses Beispiel liest einen Parameter namens id aus der Abfragezeichenfolge und verwendet ihn zum Erstellen eines JSON-Dokuments mit dem Inhaltstyp application/json, das an den Client zurückgegeben wird.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();
        }
    }

Lesen des Hauptteils aus einer POST-Anforderung (Java)Read body from a POST request (Java)

Dieses Beispiel liest den Hauptteil einer POST-Anforderung als String und verwendet ihn zum Erstellen eines JSON-Dokuments mit dem Inhaltstyp application/json, das an den Client zurückgegeben wird.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();
        }
    }

Lesen eines Parameters aus einer Route (Java)Read parameter from a route (Java)

Dieses Beispiel liest einen obligatorischen Parameter namens id sowie einen optionalen Parameter name aus dem Routenpfad und verwendet sie zum Erstellen eines JSON-Dokuments mit dem Inhaltstyp application/json, das an den Client zurückgegeben wird.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. TT

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

Lesen des POJO-Hauptteils aus einer POST-Anforderung (Java)Read POJO body from a POST request (Java)

Hier sehen Sie den Code für die ToDoItem-Klasse, auf die in diesem Beispiel verwiesen wird: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 + "}";
  }
}

In diesem Beispiel wird der Hauptteil einer POST-Anforderung gelesen.This example reads the body of a POST request. Der Anforderungstext wird automatisch in ein ToDoItem-Objekt deserialisiert und mit dem Inhaltstyp application/json an den Client zurückgegeben.The request body gets automatically de-serialized into a ToDoItem object, and is returned to the client, with content type application/json. Der Parameter ToDoItem wird durch die Functions-Runtime serialisiert, wenn er der Eigenschaft body der HttpMessageResponse.Builder-Klasse zugewiesen wird.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();
        }
    }

Trigger: AttributeTrigger - attributes

Verwenden Sie in C#-Klassenbibliotheken das Attribut HttpTrigger.In C# class libraries, use the HttpTrigger attribute.

Sie können die Autorisierungsebene und die zulässigen HTTP-Methoden in den Konstruktorparametern für das Attribut festlegen. Außerdem gibt es Eigenschaften für den Webhooktyp und die Routenvorlage.You can set the authorization level and allowable HTTP methods in attribute constructor parameters, and there are properties for webhook type and route template. Weitere Informationen zu diesen Einstellungen finden Sie unter Trigger: Konfiguration.For more information about these settings, see Trigger - configuration. Dies ist ein HttpTrigger-Attribut in einer Methodensignatur:Here's an HttpTrigger attribute in a method signature:

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

Ein vollständiges Beispiel finden Sie unter Trigger: C#-Beispiel.For a complete example, see Trigger - C# example.

Trigger: KonfigurationTrigger - configuration

Die folgende Tabelle gibt Aufschluss über die Bindungskonfigurationseigenschaften, die Sie in der Datei function.json und im Attribut HttpTrigger festlegen:The following table explains the binding configuration properties that you set in the function.json file and the HttpTrigger attribute.

Eigenschaft von „function.json“function.json property AttributeigenschaftAttribute property BESCHREIBUNGDescription
typetype n/a Erforderlich – muss auf httpTrigger festgelegt sein.Required - must be set to httpTrigger.
directiondirection n/a Erforderlich – muss auf in festgelegt sein.Required - must be set to in.
namename n/a Erforderlich – der Variablenname, der im Funktionscode für die Anforderung oder den Anforderungstext verwendet wird.Required - the variable name used in function code for the request or request body.
authLevelauthLevel AuthLevelAuthLevel Bestimmt, welche Schlüssel (sofern erforderlich) in der Anforderung vorhanden sein müssen, um die Funktion aufzurufen.Determines what keys, if any, need to be present on the request in order to invoke the function. Bei den Autorisierungsebenen kann es sich um einen der folgenden Werte handeln:The authorization level can be one of the following values:
  • anonymous: Es ist kein API-Schlüssel erforderlich.anonymous—No API key is required.
  • function: Es ist ein funktionsspezifischer API-Schlüssel erforderlich.function—A function-specific API key is required. Dies ist der Standardwert, wenn kein anderer Wert angegeben wird.This is the default value if none is provided.
  • admin: Der Hauptschlüssel ist erforderlich.admin—The master key is required.
Weitere Informationen finden Sie im Abschnitt zu Autorisierungsschlüsseln.For more information, see the section about authorization keys.
methodsmethods MethodenMethods Ein Array der HTTP-Methoden, auf die diese Funktion antwortet.An array of the HTTP methods to which the function responds. Wird dieses Array nicht angegeben, antwortet die Funktion auf alle HTTP-Methoden.If not specified, the function responds to all HTTP methods. Siehe Anpassen des HTTP-Endpunkts.See customize the http endpoint.
routeroute RouteRoute Definiert die Routenvorlage, mit der gesteuert wird, auf welche Anforderungs-URLs die Funktion antwortet.Defines the route template, controlling to which request URLs your function responds. Wenn kein anderer Wert angegeben wird, lautet der Standardwert <functionname>.The default value if none is provided is <functionname>. Weitere Informationen finden Sie unter Anpassen des HTTP-Endpunkts.For more information, see customize the http endpoint.
webHookTypewebHookType WebHookTypeWebHookType Nur für die Laufzeit der Version 1.x unterstützt.Supported only for the version 1.x runtime.

Konfiguriert den HTTP-Trigger so, dass er als Webhookempfänger für den angegebenen Anbieter fungiert.Configures the HTTP trigger to act as a webhook receiver for the specified provider. Legen Sie die methods Eigenschaft nicht fest, wenn Sie diese Eigenschaft festlegen.Don't set the methods property if you set this property. Der Webhooktyp kann folgende Werte annehmen:The webhook type can be one of the following values:
  • genericJson: Ein allgemeiner Webhookendpunkt ohne Logik für einen bestimmten Anbieter.genericJson—A general-purpose webhook endpoint without logic for a specific provider. Diese Einstellung beschränkt Anforderungen auf solche, die HTTP POST verwenden und den Inhaltstyp application/json aufweisen.This setting restricts requests to only those using HTTP POST and with the application/json content type.
  • github: Die Funktion antwortet auf GitHub-Webhooks.github—The function responds to GitHub webhooks. Verwenden Sie die authLevel-Eigenschaft nicht mit GitHub-Webhooks.Do not use the authLevel property with GitHub webhooks. Weitere Informationen finden Sie im Abschnitt zu GitHub-Webhooks weiter unten in diesem Artikel.For more information, see the GitHub webhooks section later in this article.
  • slack: Die Funktion antwortet auf Slack-Webhooks.slack—The function responds to Slack webhooks. Verwenden Sie die authLevel-Eigenschaft nicht mit Slack-Webhooks.Do not use the authLevel property with Slack webhooks. Weitere Informationen finden Sie im Abschnitt zu Slack-Webhooks weiter unten in diesem Artikel.For more information, see the Slack webhooks section later in this article.

Trigger: VerwendungTrigger - usage

Bei C#- und F#-Funktionen können Sie den Typ der Triggereingabe als HttpRequest oder als benutzerdefinierten Typ deklarieren.For C# and F# functions, you can declare the type of your trigger input to be either HttpRequest or a custom type. Wenn Sie HttpRequest auswählen, erhalten Sie Vollzugriff auf das Anforderungsobjekt.If you choose HttpRequest, you get full access to the request object. Bei einem benutzerdefinierten Typ versucht die Laufzeit, den JSON-Anforderungstext zu analysieren, um die Objekteigenschaften festzulegen.For a custom type, the runtime tries to parse the JSON request body to set the object properties.

Für JavaScript-Funktionen stellt die Functions-Runtime den Anforderungstext anstelle des Anforderungsobjekts bereit.For JavaScript functions, the Functions runtime provides the request body instead of the request object. Weitere Informationen finden Sie im JavaScript-Triggerbeispiel.For more information, see the JavaScript trigger example.

Anpassen des HTTP-EndpunktsCustomize the HTTP endpoint

Wenn Sie eine Funktion für einen HTTP-Trigger erstellen, ist die Funktion mit einer Route der folgenden Form erreichbar: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>

Sie können diese Route mit der optionalen route-Eigenschaft in der Eingabebindung des HTTP-Triggers anpassen.You can customize this route using the optional route property on the HTTP trigger's input binding. In diesem Beispiel wird mit der Datei function.json eine route-Eigenschaft für einen HTTP-Trigger definiert: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"
    }
    ]
}

Mit dieser Konfiguration ist die Funktion jetzt über die folgende Route erreichbar, anstatt über die ursprüngliche Route.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

So kann der Funktionscode zwei Parameter in der Adresse unterstützen: category und id. Sie können für Ihre Parameter eine beliebige Web-API-Routeneinschränkung verwenden.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. Im folgenden C#-Funktionscode werden beide Parameter verwendet.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}");
}

Dies ist der Node.js-Funktionscode zur Verwendung der gleichen Routenparameter.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();
}

Standardmäßig verfügen alle Funktionsrouten über das Präfix api.By default, all function routes are prefixed with api. Sie können das Präfix auch mit der http.routePrefix-Eigenschaft in der Datei host.json anpassen oder entfernen.You can also customize or remove the prefix using the http.routePrefix property in your host.json file. Im folgenden Beispiel wird das Routenpräfix api entfernt, indem in der Datei host.json eine leere Zeichenfolge als Präfix verwendet wird.The following example removes the api route prefix by using an empty string for the prefix in the host.json file.

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

Arbeiten mit ClientidentitätenWorking with client identities

Wenn Ihre Funktions-App App Service-Authentifizierung/-Autorisierung verwendet, können Sie Informationen über authentifizierte Clients aus Ihrem Code anzeigen.If your function app is using App Service Authentication / Authorization, you can view information about authenticated clients from your code. Diese Informationen sind als von der Plattform eingefügter Anforderungsheader verfügbar.This information is available as request headers injected by the platform.

Sie können diese Informationen auch aus Datenbindungen auslesen.You can also read this information from binding data. Diese Funktion ist nur für die Functions-Runtime 2.x verfügbar.This capability is only available to the Functions 2.x runtime. Sie ist derzeit auch nur für .NET-Sprachen verfügbar.It is also currently only available for .NET languages.

Bei .NET-Sprachen sind diese Informationen als ClaimsPrincipal verfügbar.In .NET languages, this information is available as a ClaimsPrincipal. „ClaimsPrincipal“ ist als Teil des Anforderungskontextes verfügbar, wie im folgenden Beispiel gezeigt: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();
}

Alternativ kann „ClaimsPrincipal“ einfach als zusätzlicher Parameter in die Funktionssignatur aufgenommen werden: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;
}

AutorisierungsschlüsselAuthorization keys

Mit Functions können Sie Schlüssel verwenden, wodurch der Zugriff auf Ihre HTTP-Funktionsendpunkte während der Entwicklung erschwert wird.Functions lets you use keys to make it harder to access your HTTP function endpoints during development. Möglicherweise wird von einem HTTP-Standardtrigger verlangt, dass solch ein API-Schlüssel in der Anforderung vorhanden ist.A standard HTTP trigger may require such an API key be present in the request.

Wichtig

Schlüssel helfen zwar Ihre HTTP-Endpunkte während der Entwicklung zu verschleiern, sie sind jedoch nicht als Möglichkeit zum Schützen eines HTTP-Triggers in einer Produktionsumgebung vorgesehen.While keys may help obfuscate your HTTP endpoints during development, they are not intended as a way to secure an HTTP trigger in production. Weitere Informationen hierzu finden Sie unter Schützen eines HTTP-Endpunkts in einer Produktionsumgebung.To learn more, see Secure an HTTP endpoint in production.

Hinweis

In der Functions Laufzeit 1.x können Webhookanbieter Schlüssel verwenden, um Anforderungen auf unterschiedliche Arten zu autorisieren, je nachdem, welche Methode vom Anbieter unterstützt wird.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. Dieses Thema wird unter Webhooks und Schlüssel behandelt.This is covered in Webhooks and keys. Die Version 2.x der Laufzeit beinhaltet keine Unterstützung für Webhookanbieter.The version 2.x runtime does not include built-in support for webhook providers.

Es gibt zwei Arten von Schlüsseln:There are two types of keys:

  • Hostschlüssel: Diese Schlüssel werden von allen Funktionen innerhalb der Funktions-App gemeinsam genutzt.Host keys: These keys are shared by all functions within the function app. Bei Verwendung als API-Schlüssel ermöglichen diese Zugriff auf jede Funktion in der Funktionen-App.When used as an API key, these allow access to any function within the function app.
  • Funktionsschlüssel: Diese Schlüssel gelten nur für die Funktionen, für die sie definiert sind.Function keys: These keys apply only to the specific functions under which they are defined. Bei Verwendung als API-Schlüssel ermöglichen diese nur Zugriff auf diese spezielle Funktion.When used as an API key, these only allow access to that function.

Jeder Schlüssel ist zu Referenzzwecken benannt. Auf Funktions- und Hostebene gibt es einen Standardschlüssel (mit dem Namen „default“).Each key is named for reference, and there is a default key (named "default") at the function and host level. Funktionsschlüssel haben Vorrang vor Hostschlüsseln.Function keys take precedence over host keys. Wenn zwei Schlüssel mit dem gleichen Namen definiert wurden, wird immer der Funktionsschlüssel verwendet.When two keys are defined with the same name, the function key is always used.

Jede Funktions-App weist einen speziellen Hauptschlüssel auf.Each function app also has a special master key. Bei diesem Schlüssel handelt es sich um einen Hostschlüssel mit dem Namen _master. Er stellt den Administratorzugriff auf Laufzeit-APIs bereit.This key is a host key named _master, which provides administrative access to the runtime APIs. Dieser Schlüssel kann nicht widerrufen werden.This key cannot be revoked. Wenn Sie die Autorisierungsstufe admin festlegen, muss für Anforderungen der Hauptschlüssel verwendet werden. Alle anderen Schlüssel führen zu einem Autorisierungsfehler.When you set an authorization level of admin, requests must use the master key; any other key results in authorization failure.

Achtung

Aufgrund der erhöhten Berechtigungen, die der Hauptschlüssel in Ihrer Funktions-App gewährt, sollten Sie diesen Schlüssel nicht für Dritte freigeben oder in nativen Clientanwendungen verteilen.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. Gehen Sie umsichtig vor, wenn Sie die Autorisierungsstufe „Administrator“ auswählen.Use caution when choosing the admin authorization level.

Abrufen von SchlüsselnObtaining keys

Schlüssel werden als Teil Ihrer Funktionen-App in Azure gespeichert und sind im Ruhezustand verschlüsselt.Keys are stored as part of your function app in Azure and are encrypted at rest. Um vorhandene Schlüssel anzuzeigen, neue Schlüssel zu erstellen oder Schlüsseln neue Werte zuzuweisen, navigieren Sie im Azure-Portal zu einer Ihrer über HTTP ausgelösten Funktionen, und wählen Sie Verwalten aus.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.

Verwalten Sie Funktionsschlüssel im Portal.

Funktionsschlüssel können mithilfe der Schlüsselverwaltungs-API programmgesteuert abgerufen werden.You may obtain function keys programmatically by using Key management API.

Autorisierung per API-SchlüsselAPI key authorization

Für die meisten HTTP-Triggervorlagen muss in der Anforderung ein API-Schlüssel vorhanden sein.Most HTTP trigger templates require an API key in the request. Ihre HTTP-Anforderung sieht daher normalerweise wie folgende URL aus:So your HTTP request normally looks like the following URL:

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

Der Schlüssel kann in einer Abfragezeichenfolgenvariablen namens code (wie oben zu sehen) enthalten sein.The key can be included in a query string variable named code, as above. Er kann auch in einem x-functions-key-HTTP-Header enthalten sein.It can also be included in an x-functions-key HTTP header. Der Wert des Schlüssels kann ein beliebiger für die Funktion definierter Funktionsschlüssel oder ein beliebiger Hostschlüssel sein.The value of the key can be any function key defined for the function, or any host key.

Sie können anonyme Anforderungen zulassen, die keine Schlüssel erfordern.You can allow anonymous requests, which do not require keys. Sie können auch anfordern, dass der Hauptschlüssel verwendet wird.You can also require that the master key be used. Zum Ändern der Standardautorisierungsstufe verwenden Sie die authLevel-Eigenschaft in der Bindungs-JSON.You change the default authorization level by using the authLevel property in the binding JSON. Weitere Informationen finden Sie unter Trigger: Konfiguration.For more information, see Trigger - configuration.

Hinweis

Beim lokalen Ausführen von Funktionen ist die Autorisierung unabhängig von der festgelegten Authentifizierungsebene deaktiviert.When running functions locally, authorization is disabled regardless of the specified authentication level setting. Die authLevel-Einstellung in Ihrem Trigger wird nach der Veröffentlichung in Azure angewendet.After publishing to Azure, the authLevel setting in your trigger is enforced.

Schützen eines HTTP-Endpunkts in einer ProduktionsumgebungSecure an HTTP endpoint in production

Wenn Sie Ihre Funktionsendpunkte in einer Produktionsumgebung umfassend schützen möchten, sollten Sie eine der folgenden Sicherheitsoptionen auf Funktions-App-Ebene implementieren:To fully secure your function endpoints in production, you should consider implementing one of the following function app-level security options:

  • Aktivieren Sie für Ihre Funktions-App die App Service-Authentifizierung/Autorisierung.Turn on App Service Authentication / Authorization for your function app. Die App Service-Plattform ermöglicht die Verwendung von Azure Active Directory (AAD) sowie von verschiedenen anderen Identitätsanbietern zum Authentifizieren von Clients.The App Service platform lets use Azure Active Directory (AAD) and several third-party identity providers to authenticate clients. Sie können sie zum Implementieren von benutzerdefinierten Autorisierungsregeln für Ihre Funktionen sowie Benutzerinformationen aus Ihrem Funktionscode verwenden.You can use this to implement custom authorization rules for your functions, and you can work with user information from your function code. Weitere Informationen finden Sie unter Authentifizierung und Autorisierung in Azure App Service und Arbeiten mit Clientidentitäten.To learn more, see Authentication and authorization in Azure App Service and Working with client identities.

  • Verwenden Sie Azure API Management (APIM) zum Authentifizieren von Anforderungen.Use Azure API Management (APIM) to authenticate requests. APIM stellt verschiedene API-Sicherheitsoptionen für eingehende Anforderungen bereit.APIM provides a variety of API security options for incoming requests. Weitere Informationen hierzu finden Sie unter API Management-Authentifizierungsrichtlinien.To learn more, see API Management authentication policies. Wenn APIM vorhanden ist, können Sie Ihre Funktions-App so konfigurieren, dass Anforderungen nur von den IP-Adressen Ihrer APIM-Instanz angenommen werden.With APIM in place, you can configure your function app to accept requests only from the IP address of your APIM instance. Weitere Informationen hierzu finden Sie unter Einschränkungen für IP-Adressen.To learn more, see IP address restrictions.

  • Stellen Sie Ihre Funktions-App in einer Azure App Service-Umgebung (ASE, App Service Environment) bereit.Deploy your function app to an Azure App Service Environment (ASE). ASE stellt eine spezielle Hostingumgebung bereit, in der Sie Ihre Funktionen ausführen können.ASE provides a dedicated hosting environment in which to run your functions. Mit ASE können Sie ein Front-End-Gateway konfigurieren, das Sie zum Authentifizieren aller eingehenden Anforderungen verwenden können.ASE lets you configure a single front-end gateway that you can use to authenticate all incoming requests. Weitere Informationen hierzu finden Sie unter Konfigurieren einer Web Application Firewall (WAF) für eine App Service-Umgebung.For more information, see Configuring a Web Application Firewall (WAF) for App Service Environment.

Wenn Sie eine dieser Sicherheitsmethoden auf Funktions-App-Ebene verwenden, sollten Sie die Authentifizierungsebene der über HTTP ausgelösten Funktion auf anonymous festlegen.When using one of these function app-level security methods, you should set the HTTP-triggered function authentication level to anonymous.

webhooksWebhooks

Hinweis

Der Webhookmodus ist nur für die Version 1.x der Functions-Laufzeit verfügbar.Webhook mode is only available for version 1.x of the Functions runtime. Diese Änderung wurde vorgenommen, um die Leistung von HTTP-Triggern in Version 2.x zu verbessern.This change was made to improve the performance of HTTP triggers in version 2.x.

In Version 1.x stellen Webhookvorlagen zusätzliche Überprüfungsoptionen für Webhooknutzlasten bereit.In version 1.x, webhook templates provide additional validation for webhook payloads. In Version 2.x kann der HTTP-Basistrigger weiterhin verwendet werden. Zudem wird er für Webhooks empfohlen.In version 2.x, the base HTTP trigger still works and is the recommended approach for webhooks.

GitHub-WebhooksGitHub webhooks

Erstellen Sie zum Antworten auf GitHub-Webhooks zuerst eine Funktion mit einem HTTP-Trigger, und legen Sie die webHookType-Eigenschaft auf github fest.To respond to GitHub webhooks, first create your function with an HTTP Trigger, and set the webHookType property to github. Kopieren Sie dann die URL und den API-Schlüssel auf die Seite Webhook hinzufügen Ihres GitHub-Repositorys.Then copy its URL and API key into the Add webhook page of your GitHub repository.

Slack-WebhooksSlack webhooks

Der Slack-Webhook lässt Sie das Token nicht angeben, sondern generiert es für Sie. Daher müssen Sie einen funktionsspezifischen Schlüssel mit dem Token aus Slack konfigurieren.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. Weitere Informationen finden Sie unter Autorisierungsschlüssel.See Authorization keys.

Webhooks und SchlüsselWebhooks and keys

Die Webhookautorisierung wird von der Empfangskomponente für Webhooks verarbeitet, die zum HTTP-Trigger gehört. Der Mechanismus variiert je nach Webhooktyp.Webhook authorization is handled by the webhook receiver component, part of the HTTP trigger, and the mechanism varies based on the webhook type. Für jeden Mechanismus wird ein Schlüssel benötigt.Each mechanism does rely on a key. Standardmäßig wird der Funktionsschlüssel namens „default“ verwendet.By default, the function key named "default" is used. Um einen anderen Schlüssel zu verwenden, konfigurieren Sie den Webhookanbieter, sodass der Schlüsselname auf eine der folgenden Arten mit der Anforderung gesendet wird:To use a different key, configure the webhook provider to send the key name with the request in one of the following ways:

  • Abfragezeichenfolge: Der Anbieter übergibt den Schlüsselnamen im clientid-Abfragezeichenfolgenparameter, z. B. https://<APP_NAME>.azurewebsites.net/api/<FUNCTION_NAME>?clientid=<KEY_NAME>.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>.
  • Anforderungsheader: Der Anbieter übergibt den Schlüsselnamen im x-functions-clientid-Header.Request header: The provider passes the key name in the x-functions-clientid header.

Trigger – GrenzwerteTrigger - limits

Die Länge der HTTP-Anforderung ist auf 100 MB (104.857.600 Bytes) und die URL-Länge auf 4 KB (4.096 Bytes) beschränkt.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). Diese Grenzwerte werden durch das httpRuntime-Element der Datei Web.config der Runtime angegeben.These limits are specified by the httpRuntime element of the runtime's Web.config file.

Wenn eine Funktion, die den HTTP-Trigger verwendet, nicht innerhalb von etwa 2,5 Minuten abgeschlossen ist, tritt auf dem Gateway ein Timeout auf, und es wird ein HTTP 502-Fehler zurückgegeben.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. Die Funktion wird weiterhin ausgeführt, kann aber keine HTTP-Antwort zurückgeben.The function will continue running but will be unable to return an HTTP response. Bei Funktionen mit langer Ausführungsdauer empfiehlt es sich, asynchrone Muster zu befolgen und einen Speicherort zurückzugeben, von dem aus Sie den Status der Anforderung pingen können.For long-running functions, we recommend that you follow async patterns and return a location where you can ping the status of the request. Informationen dazu, wie lang eine Funktion ausgeführt werden kann, finden Sie unter Skalierung und Hosting – Verbrauchsplan.For information about how long a function can run, see Scale and hosting - Consumption plan.

Trigger: Eigenschaften von „host.json“Trigger - host.json properties

Die Datei host.json enthält Einstellungen, mit denen das Verhalten des HTTP-Triggers gesteuert werden kann.The host.json file contains settings that control HTTP trigger behavior.

{
    "http": {
        "routePrefix": "api",
        "maxOutstandingRequests": 200,
        "maxConcurrentRequests": 100,
        "dynamicThrottlesEnabled": true
    }
}
EigenschaftProperty StandardDefault BESCHREIBUNGDescription
routePrefixroutePrefix apiapi Das Routenpräfix, das für alle Routen gilt.The route prefix that applies to all routes. Verwenden Sie eine leere Zeichenfolge, um das Standardpräfix zu entfernen.Use an empty string to remove the default prefix.
maxOutstandingRequestsmaxOutstandingRequests 200*200* Die maximale Anzahl ausstehender Anforderungen, die zu einem beliebigen Zeitpunkt gespeichert werden.The maximum number of outstanding requests that are held at any given time. Dieser Grenzwert umfasst Anforderungen in der Warteschlange, deren Ausführung aber noch nicht gestartet ist, sowie alle laufenden Ausführungen.This limit includes requests that are queued but have not started executing, as well as any in progress executions. Alle eingehenden Anforderungen über diesem Grenzwert werden mit der Antwort 429 „Ausgelastet“ zurückgewiesen.Any incoming requests over this limit are rejected with a 429 "Too Busy" response. Das ermöglicht es dem Aufrufer zeitbasierte Strategien für Wiederholungsversuche einzusetzen, und Sie erhalten damit die Möglichkeit, die maximalen Wartezeiten für Anforderungen zu steuern.That allows callers to employ time-based retry strategies, and also helps you to control maximum request latencies. Damit wird nur das Queuing gesteuert, das innerhalb des Ausführungspfads des Skripthosts auftritt.This only controls queuing that occurs within the script host execution path. Andere Warteschlangen, z.B. die ASP.NET-Anforderungswarteschlange, sind von dieser Einstellung nicht betroffen und werden weiterhin verwendet.Other queues such as the ASP.NET request queue will still be in effect and unaffected by this setting. *Der Standardwert für Version 1.x ist unbegrenzt (-1).*The default for version 1.x is unbounded (-1). Der Standardwert für Version 2.x in einem Verbrauchstarif beträgt 200.The default for version 2.x in a consumption plan is 200. Der Standardwert für Version 2.x in einem dedizierten Plan ist unbegrenzt (-1).The default for version 2.x in a dedicated plan is unbounded (-1).
maxConcurrentRequestsmaxConcurrentRequests 100*100* Die maximale Anzahl von HTTP-Funktionen, die parallel ausgeführt werden.The maximum number of http functions that will be executed in parallel. Dadurch können Sie die Parallelität steuern und somit die Verwaltung der Ressourcenverwendung vereinfachen.This allows you to control concurrency, which can help manage resource utilization. Beispielsweise könnten Sie über eine HTTP-Funktion verfügen, die viele Systemressourcen (Speicher/CPU/Sockets) verbraucht und daher Probleme verursacht, wenn die Parallelität zu hoch ist.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. Oder eine Funktion führt ausgehende Anforderungen an einen Dienst eines Drittanbieters durch, und die Rate dieser Aufrufe muss eingeschränkt werden.Or you might have a function that makes outbound requests to a third party service, and those calls need to be rate limited. In diesen Fällen kann eine Drosselung hilfreich sein.In these cases, applying a throttle here can help. *Der Standardwert für Version 1.x ist unbegrenzt (-1).*The default for version 1.x is unbounded (-1). Der Standardwert für Version 2.x in einem Verbrauchstarif beträgt 100.The default for version 2.x in a consumption plan is 100. Der Standardwert für Version 2.x in einem dedizierten Plan ist unbegrenzt (-1).The default for version 2.x in a dedicated plan is unbounded (-1).
dynamicThrottlesEnableddynamicThrottlesEnabled true*true* Bei einer Aktivierung dieser Einstellung überprüft die Pipeline zur Anforderungsverarbeitung regelmäßig Leistungsindikatoren zur Systemleistung wie Verbindungen/Threads/Prozesse/Speicher/CPU usw., und wenn einer dieser Leistungsindikatoren einen integrierten Schwellenwert (80 %) übersteigt, werden Anforderungen mit der Antwort „429 – Ausgelastet“ zurückgewiesen, bis die Leistungsindikatoren wieder ein normales Niveau erreichen.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. *Der Standardwert für Version 1.x lautet „false“.*The default for version 1.x is false. Der Standardwert für Version 2.x in einem Verbrauchstarif lautet „true“.The default for version 2.x in a consumption plan is true. Der Standardwert für Version 2.x in einem dedizierten Tarif lautet „false“.The default for version 2.x in a dedicated plan is false.

OutputOutput

Verwenden Sie die HTTP-Ausgabebindung, um eine Antwort an den Absender der HTTP-Anforderung zu senden.Use the HTTP output binding to respond to the HTTP request sender. Diese Bindung erfordert einen HTTP-Trigger und ermöglicht Ihnen, die Antwort, die der Anforderung des Triggers zugeordnet ist, benutzerdefiniert anzupassen.This binding requires an HTTP trigger and allows you to customize the response associated with the trigger's request. Wenn keine HTTP-Ausgabebindung angegeben wird, gibt ein HTTP-Trigger in Functions 1.x den HTTP-Statuscode 200 „OK“ ohne Text oder in Functions 2.x den HTTP-Statuscode 204 „No Content“ ohne Text zurück.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.

Ausgabe: KonfigurationOutput - configuration

Die folgende Tabelle gibt Aufschluss über die Bindungskonfigurationseigenschaften, die Sie in der Datei function.json festlegen.The following table explains the binding configuration properties that you set in the function.json file. Für C#-Klassenbibliotheken gibt es keine Attributeigenschaften, die den folgenden Eigenschaften der Datei function.json entsprechen.For C# class libraries, there are no attribute properties that correspond to these function.json properties.

EigenschaftProperty BESCHREIBUNGDescription
typetype Muss auf http festgelegt sein.Must be set to http.
directiondirection Muss auf out festgelegt sein.Must be set to out.
namename Der Variablenname, der im Funktionscode für die Antwort verwendet wird, oder $return für die Verwendung des Rückgabewerts.The variable name used in function code for the response, or $return to use the return value.

Ausgabe: VerwendungOutput - usage

Verwenden Sie zum Senden einer HTTP-Antwort die Antwortmuster des Sprachstandards.To send an HTTP response, use the language-standard response patterns. Legen Sie in C# oder im C#-Skript den Funktionsrückgabetyp auf IActionResult oder Task<IActionResult> fest.In C# or C# script, make the function return type IActionResult or Task<IActionResult>. In C# ist kein Attribut des Rückgabewerts erforderlich.In C#, a return value attribute isn't required.

Beispielantworten finden Sie im Triggerbeispiel.For example responses, see the trigger example.

Nächste SchritteNext steps

Konzepte für Azure Functions-Trigger und -BindungenLearn more about Azure functions triggers and bindings