HTTP-trigger voor Azure Functions

  • Artikel

Met de HTTP-trigger kunt u een functie aanroepen met een HTTP-aanvraag. U kunt een HTTP-trigger gebruiken om serverloze API's te bouwen en te reageren op webhooks.

De standaard retourwaarde voor een door HTTP geactiveerde functie is:

  • HTTP 204 No Content met een lege hoofdtekst in Functions 2.x en hoger
  • HTTP 200 OK met een lege hoofdtekst in Functions 1.x

Als u het HTTP-antwoord wilt wijzigen, configureert u een uitvoerbinding.

Zie de overzichts - en uitvoerbindingsreferentie voor meer informatie over HTTP-bindingen.

Tip

Als u van plan bent om de HTTP- of WebHook-bindingen te gebruiken, plan dan om uitputting van de poort te voorkomen. Dat kan worden veroorzaakt door onjuiste instantie-instellingen van HttpClient. Raadpleeg Verbindingen beheren in Azure Functions voor meer informatie.

Belangrijk

In dit artikel worden tabbladen gebruikt ter ondersteuning van meerdere versies van het Node.js programmeermodel. Het v4-model is algemeen beschikbaar en is ontworpen voor een flexibelere en intuïtievere ervaring voor JavaScript- en TypeScript-ontwikkelaars. Raadpleeg de ontwikkelaarshandleiding voor Azure Functions Node.js voor meer informatie over hoe het v4-model werkt. Raadpleeg de migratiehandleiding voor meer informatie over de verschillen tussen v3 en v4.

Azure Functions ondersteunt twee programmeermodellen voor Python. De manier waarop u uw bindingen definieert, is afhankelijk van het gekozen programmeermodel.

Met het Python v2-programmeermodel kunt u bindingen definiëren met behulp van decorators rechtstreeks in uw Python-functiecode. Zie de Ontwikkelaarshandleiding voor Python voor meer informatie.

Dit artikel ondersteunt beide programmeermodellen.

Opmerking

U kunt een C#-functie maken met behulp van een van de volgende C#-modi:

  • Geïsoleerd werkrolmodel: gecompileerde C#-functie die wordt uitgevoerd in een werkproces dat is geïsoleerd van de runtime. Geïsoleerd werkproces is vereist voor de ondersteuning van C#-functies die worden uitgevoerd op LTS- en niet-LTS-versies .NET en .NET Framework. Extensies voor geïsoleerde werkprocesfuncties maken gebruik van Microsoft.Azure.Functions.Worker.Extensions.* naamruimten.
  • In-process model: gecompileerde C#-functie die wordt uitgevoerd in hetzelfde proces als de Functions-runtime. In een variatie van dit model kunnen functies worden uitgevoerd met behulp van C#-scripting. Dit wordt voornamelijk ondersteund voor het bewerken van de C#-portal. Extensies voor in-process-functies maken gebruik van Microsoft.Azure.WebJobs.Extensions.* naamruimten.

Belangrijk

De ondersteuning wordt beëindigd voor het in-process model op 10 november 2026. We raden u ten zeerste aan uw apps te migreren naar het geïsoleerde werkrolmodel voor volledige ondersteuning.

De code in dit artikel is standaard ingesteld op .NET Core-syntaxis, die wordt gebruikt in Functions versie 2.x en hoger. Zie de 1.x-functiessjablonen voor meer informatie over de syntaxis van 1.x.

In het volgende voorbeeld ziet u een HTTP-trigger die een antwoord 'hallo wereld' retourneert als een IActionResult, met behulp van ASP.NET Core-integratie in .NET Isolated:

[Function("HttpFunction")]
public IActionResult Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get")] HttpRequest req)
{
    return new OkObjectResult($"Welcome to Azure Functions, {req.Query["name"]}!");
}

In het volgende voorbeeld ziet u een HTTP-trigger die een 'hallo wereld'-antwoord retourneert als een HttpResponseData-object :

[Function(nameof(HttpFunction))]
public static HttpResponseData Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestData req,
    FunctionContext executionContext)
{
    var logger = executionContext.GetLogger(nameof(HttpFunction));
    logger.LogInformation("message logged");

    var response = req.CreateResponse(HttpStatusCode.OK);
    response.Headers.Add("Content-Type", "text/plain; charset=utf-8");
    response.WriteString("Welcome to .NET isolated worker !!");

    return response;
}

Deze sectie bevat de volgende voorbeelden:

In de volgende voorbeelden ziet u de HTTP-triggerbinding.

Parameter lezen uit de querytekenreeks

In dit voorbeeld wordt een parameter met de naam id, uit de querytekenreeks gelezen en gebruikt om een JSON-document te bouwen dat wordt geretourneerd naar de client, met inhoudstype 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();
    }
}

Hoofdtekst lezen van een POST-aanvraag

In dit voorbeeld wordt de hoofdtekst van een POST-aanvraag gelezen, als een String, en wordt gebruikt om een JSON-document te bouwen dat wordt geretourneerd aan de client, met inhoudstype 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();
        }
    }

Parameter van een route lezen

In dit voorbeeld wordt een verplichte parameter, benoemd iden een optionele parameter name uit het routepad gelezen en gebruikt om een JSON-document te bouwen dat wordt geretourneerd naar de client, met inhoudstype application/json.

@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-hoofdtekst lezen uit een POST-aanvraag

Hier volgt de code voor de ToDoItem klasse waarnaar in dit voorbeeld wordt verwezen:


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 dit voorbeeld wordt de hoofdtekst van een POST-aanvraag gelezen. De aanvraagbody wordt automatisch gedeserialiseerd in een ToDoItem object en wordt geretourneerd naar de client, met inhoudstype application/json. De ToDoItem parameter wordt geserialiseerd door de Functions-runtime omdat deze is toegewezen aan de body eigenschap van de HttpMessageResponse.Builder klasse.

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

In het volgende voorbeeld ziet u een TypeScript-functie voor een HTTP-trigger. De functie zoekt naar een name parameter in de querytekenreeks of de hoofdtekst van de HTTP-aanvraag.

import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';

export async function httpTrigger1(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log(`Http function processed request for url "${request.url}"`);

    const name = request.query.get('name') || (await request.text()) || 'world';

    return { body: `Hello, ${name}!` };
}

app.http('httpTrigger1', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    handler: httpTrigger1,
});

In het volgende voorbeeld ziet u een JavaScript-functie voor een HTTP-trigger. De functie zoekt naar een name parameter in de querytekenreeks of de hoofdtekst van de HTTP-aanvraag.

const { app } = require('@azure/functions');

app.http('httpTrigger1', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    handler: async (request, context) => {
        context.log(`Http function processed request for url "${request.url}"`);

        const name = request.query.get('name') || (await request.text()) || 'world';

        return { body: `Hello, ${name}!` };
    },
});

In het volgende voorbeeld ziet u een triggerbinding in een function.json-bestand en een PowerShell-functie. De functie zoekt naar een name parameter in de querytekenreeks of de hoofdtekst van de HTTP-aanvraag.

{
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "Request",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "Response"
    }
  ]
}

using namespace System.Net

# Input bindings are passed in via param block.
param($Request, $TriggerMetadata)

# Write to the Azure Functions log stream.
Write-Host "PowerShell HTTP trigger function processed a request."

# Interact with query parameters or the body of the request.
$name = $Request.Query.Name
if (-not $name) {
    $name = $Request.Body.Name
}

$body = "This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response."

if ($name) {
    $body = "Hello, $name. This HTTP triggered function executed successfully."
}

# Associate values to output bindings by calling 'Push-OutputBinding'.
Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
    StatusCode = [HttpStatusCode]::OK
    Body       = $body
})

In het volgende voorbeeld ziet u een triggerbinding en een Python-functie die gebruikmaakt van de binding. De functie zoekt naar een name parameter in de querytekenreeks of de hoofdtekst van de HTTP-aanvraag. Het voorbeeld is afhankelijk van of u het python-programmeermodel v1 of v2 gebruikt.

import azure.functions as func
import logging

app = func.FunctionApp()

@app.function_name(name="HttpTrigger1")
@app.route(route="hello", auth_level=func.AuthLevel.ANONYMOUS)
def test_function(req: func.HttpRequest) -> func.HttpResponse:
    logging.info('Python HTTP trigger function processed a request.')
    return func.HttpResponse(
        "This HTTP triggered function executed successfully.",
        status_code=200
        )

Kenmerken

Zowel in-processals geïsoleerde werkproces C#-bibliotheken gebruiken de HttpTriggerAttribute om de triggerbinding te definiëren. C#-script maakt in plaats daarvan gebruik van een function.json configuratiebestand, zoals beschreven in de handleiding voor C#-scripts.

In geïsoleerde werkprocesfunctie-apps ondersteunt de HttpTriggerAttribute volgende parameters:

Parameters Beschrijving
AuthLevel Bepaalt welke sleutels aanwezig moeten zijn in de aanvraag om de functie aan te roepen. Zie Autorisatieniveau voor ondersteunde waarden.
Methoden Een matrix van de HTTP-methoden waarop de functie reageert. Als deze niet is opgegeven, reageert de functie op alle HTTP-methoden. Zie het HTTP-eindpunt aanpassen.
Route Definieert de routesjabloon, waarmee wordt bepaald op welke aanvraag-URL's uw functie reageert. De standaardwaarde als er geen is opgegeven, is <functionname>. Zie het HTTP-eindpunt aanpassen voor meer informatie.

Decorators

Is alleen van toepassing op het Python v2-programmeermodel.

Voor Python v2-functies die zijn gedefinieerd met behulp van een decorator, worden de volgende eigenschappen voor een trigger gedefinieerd in de route decorator, waarmee HttpTrigger- en HttpOutput-binding wordt toegevoegd:

Eigenschappen Beschrijving
route Route voor het HTTP-eindpunt. Als geen, wordt deze ingesteld op functienaam als deze aanwezig is of door de gebruiker gedefinieerde python-functienaam.
trigger_arg_name Argumentnaam voor HttpRequest. De standaardwaarde is 'req'.
binding_arg_name Argumentnaam voor HttpResponse. De standaardwaarde is '$return'.
methods Een tuple van de HTTP-methoden waarop de functie reageert.
auth_level Bepaalt welke sleutels aanwezig moeten zijn in de aanvraag om de functie aan te roepen.

Zie de sectie Configuratie voor Python-functies die zijn gedefinieerd met behulp van function.json.

Aantekeningen

Gebruik in de Runtime-bibliotheek van Java-functies de aantekening httpTrigger , die de volgende instellingen ondersteunt:

Configuratie

Is alleen van toepassing op het Python v1-programmeermodel.

In de volgende tabel worden de eigenschappen uitgelegd die u kunt instellen voor het options object dat aan de app.http() methode is doorgegeven.

Eigenschappen Beschrijving
authLevel Bepaalt welke sleutels aanwezig moeten zijn in de aanvraag om de functie aan te roepen. Zie Autorisatieniveau voor ondersteunde waarden.
Methoden Een matrix van de HTTP-methoden waarop de functie reageert. Als deze niet is opgegeven, reageert de functie op alle HTTP-methoden. Zie het HTTP-eindpunt aanpassen.
Route Definieert de routesjabloon, waarmee wordt bepaald op welke aanvraag-URL's uw functie reageert. De standaardwaarde als er geen is opgegeven, is <functionname>. Zie het HTTP-eindpunt aanpassen voor meer informatie.

In de volgende tabel worden de eigenschappen van de triggerconfiguratie uitgelegd die u hebt ingesteld in het function.json-bestand , wat verschilt per runtimeversie.

In de volgende tabel worden de bindingsconfiguratie-eigenschappen uitgelegd die u in het function.json-bestand hebt ingesteld.

function.json-eigenschap Beschrijving
type Vereist - moet worden ingesteld op httpTrigger.
direction Vereist - moet worden ingesteld op in.
name Vereist: de naam van de variabele die wordt gebruikt in functiecode voor de aanvraag- of aanvraagbody.
authLevel Bepaalt welke sleutels aanwezig moeten zijn in de aanvraag om de functie aan te roepen. Zie Autorisatieniveau voor ondersteunde waarden.
Methoden Een matrix van de HTTP-methoden waarop de functie reageert. Als deze niet is opgegeven, reageert de functie op alle HTTP-methoden. Zie het HTTP-eindpunt aanpassen.
Route Definieert de routesjabloon, waarmee wordt bepaald op welke aanvraag-URL's uw functie reageert. De standaardwaarde als er geen is opgegeven, is <functionname>. Zie het HTTP-eindpunt aanpassen voor meer informatie.

Gebruik

In deze sectie wordt beschreven hoe u uw HTTP-triggerfunctiebinding configureert.

De aantekening van HttpTrigger moet worden toegepast op een methodeparameter van een van de volgende typen:

  • HttpRequestMessage<T>.
  • Systeemeigen Java-typen, zoals int, tekenreeks, byte[].
  • Null-waarden met optioneel.
  • Elk normaal Java-objecttype (POJO).

Nettolading

Het invoertype trigger wordt gedeclareerd als een van de volgende typen:

Type Description
HttpRequest Gebruik van dit type vereist dat de app is geconfigureerd met ASP.NET Core-integratie in .NET Isolated.
Hiermee hebt u volledige toegang tot het aanvraagobject en de algemene HttpContext.
HttpRequestData Een projectie van het aanvraagobject.
Een aangepast type Wanneer de hoofdtekst van de aanvraag JSON is, probeert de runtime deze te parseren om de objecteigenschappen in te stellen.

Wanneer de triggerparameter een HttpRequestDataHttpRequestis, kunnen aangepaste typen ook worden gebonden aan aanvullende parameters met behulp van Microsoft.Azure.Functions.Worker.Http.FromBodyAttribute. Voor het gebruik van dit kenmerk is versie 3.1.0 of hoger vereistMicrosoft.Azure.Functions.Worker.Extensions.Http. Houd er rekening mee dat dit een ander type is dan het vergelijkbare kenmerk in Microsoft.AspNetCore.Mvc, en wanneer u ASP.NET Core-integratie gebruikt, hebt u een volledig gekwalificeerde verwijzing of using instructie nodig. In het volgende voorbeeld ziet u hoe u het kenmerk gebruikt om alleen de hoofdtekstinhoud op te halen terwijl u nog steeds toegang hebt tot het volledige HttpRequest, met behulp van de ASP.NET Core-integratie:

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.Functions.Worker;
using FromBodyAttribute = Microsoft.Azure.Functions.Worker.Http.FromBodyAttribute;

namespace AspNetIntegration
{
    public class BodyBindingHttpTrigger
    {
        [Function(nameof(BodyBindingHttpTrigger))]
        public IActionResult Run([HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequest req,
            [FromBody] Person person)
        {
            return new OkObjectResult(person);
        }
    }

    public record Person(string Name, int Age);
}

Het HTTP-eindpunt aanpassen

Wanneer u een functie voor een HTTP-trigger maakt, is de functie standaard adresseerbaar met een route van het formulier:

https://<APP_NAME>.azurewebsites.net/api/<FUNCTION_NAME>

U kunt deze route aanpassen met behulp van de optionele route eigenschap op de invoerbinding van de HTTP-trigger. U kunt elke web-API-routebeperking gebruiken met uw parameters.

De volgende functiecode accepteert twee parameters category en id in de route en schrijft een antwoord met behulp van beide parameters.

[Function("HttpTrigger1")]
public static HttpResponseData Run([HttpTrigger(AuthorizationLevel.Function, "get", "post",
Route = "products/{category:alpha}/{id:int?}")] HttpRequestData req, string category, int? id,
FunctionContext executionContext)
{
    var logger = executionContext.GetLogger("HttpTrigger1");
    logger.LogInformation("C# HTTP trigger function processed a request.");

    var message = String.Format($"Category: {category}, ID: {id}");
    var response = req.CreateResponse(HttpStatusCode.OK);
    response.Headers.Add("Content-Type", "text/plain; charset=utf-8");
    response.WriteString(message);

    return response;
}

Routeparameters worden gedefinieerd met behulp van de route instelling van de HttpTrigger aantekening. De volgende functiecode accepteert twee parameters category en id in de route en schrijft een antwoord met behulp van beide parameters.

package com.function;

import java.util.*;
import com.microsoft.azure.functions.annotation.*;
import com.microsoft.azure.functions.*;

public class HttpTriggerJava {
    public HttpResponseMessage<String> HttpTrigger(
            @HttpTrigger(name = "req",
                         methods = {"get"},
                         authLevel = AuthorizationLevel.FUNCTION,
                         route = "products/{category:alpha}/{id:int}") HttpRequestMessage<String> request,
            @BindingName("category") String category,
            @BindingName("id") int id,
            final ExecutionContext context) {

        String message = String.format("Category  %s, ID: %d", category, id);
        return request.createResponseBuilder(HttpStatus.OK).body(message).build();
    }
}

Als voorbeeld definieert de volgende TypeScript-code een route eigenschap voor een HTTP-trigger met twee parameters en idcategory . In het voorbeeld worden de parameters uit de aanvraag gelezen en worden de waarden in het antwoord geretourneerd.

import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';

export async function httpTrigger1(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    const category = request.params.category;
    const id = request.params.id;

    return { body: `Category: ${category}, ID: ${id}` };
}

app.http('httpTrigger1', {
    methods: ['GET'],
    authLevel: 'anonymous',
    route: 'products/{category:alpha}/{id:int?}',
    handler: httpTrigger1,
});

De volgende JavaScript-code definieert bijvoorbeeld een route eigenschap voor een HTTP-trigger met twee parameters en categoryid. In het voorbeeld worden de parameters uit de aanvraag gelezen en worden de waarden in het antwoord geretourneerd.

const { app } = require('@azure/functions');

app.http('httpTrigger1', {
    methods: ['GET'],
    authLevel: 'anonymous',
    route: 'products/{category:alpha}/{id:int?}',
    handler: async (request, context) => {
        const category = request.params.category;
        const id = request.params.id;

        return { body: `Category: ${category}, ID: ${id}` };
    },
});

Als voorbeeld definieert de volgende code een route eigenschap voor een HTTP-trigger met twee parameters en categoryid:

@app.function_name(name="httpTrigger")
@app.route(route="products/{category:alpha}/{id:int?}")

Routeparameters die zijn gedeclareerd in het function.json-bestand , zijn toegankelijk als een eigenschap van het $Request.Params object.

$Category = $Request.Params.category
$Id = $Request.Params.id

$Message = "Category:" + $Category + ", ID: " + $Id

Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
    StatusCode = [HttpStatusCode]::OK
    Body = $Message
})

De uitvoeringscontext van de functie wordt weergegeven via een parameter die is gedeclareerd als func.HttpRequest. Met dit exemplaar kan een functie toegang krijgen tot parameters voor gegevensroute, querytekenreekswaarden en -methoden waarmee u HTTP-antwoorden kunt retourneren.

Zodra de routeparameters zijn gedefinieerd, zijn de routeparameters beschikbaar voor de functie door de methode aan te route_params roepen.

import logging

import azure.functions as func

def main(req: func.HttpRequest) -> func.HttpResponse:

    category = req.route_params.get('category')
    id = req.route_params.get('id')
    message = f"Category: {category}, ID: {id}"

    return func.HttpResponse(message)

Met deze configuratie is de functie nu adresseerbaar met de volgende route in plaats van de oorspronkelijke route.

https://<APP_NAME>.azurewebsites.net/api/products/electronics/357

Met deze configuratie kan de functiecode twee parameters in het adres, de categorie en de id ondersteunen. Zie Routering in ASP.NET Core voor meer informatie over hoe routeparameters worden getokend in een URL.

Standaard worden alle functieroutes voorafgegaan door api. U kunt het voorvoegsel ook aanpassen of verwijderen met behulp van de extensions.http.routePrefix eigenschap in uw host.json bestand. In het volgende voorbeeld wordt het api-routevoorvoegsel verwijderd met behulp van een lege tekenreeks voor het voorvoegsel in het host.json-bestand .

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

Routeparameters gebruiken

Routeparameters die het patroon van route een functie hebben gedefinieerd, zijn beschikbaar voor elke binding. Als u bijvoorbeeld een route hebt gedefinieerd als "route": "products/{id}" een tabelopslagbinding, kan de waarde van de {id} parameter in de bindingsconfiguratie worden gebruikt.

De volgende configuratie laat zien hoe de {id} parameter wordt doorgegeven aan de binding rowKey.

@app.table_input(arg_name="product", table_name="products", 
                 row_key="{id}", partition_key="products",
                 connection="AzureWebJobsStorage")

import { app, HttpRequest, HttpResponseInit, input, InvocationContext } from '@azure/functions';

const tableInput = input.table({
    connection: 'MyStorageConnectionAppSetting',
    partitionKey: 'products',
    tableName: 'products',
    rowKey: '{id}',
});

export async function httpTrigger1(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    return { jsonBody: context.extraInputs.get(tableInput) };
}

app.http('httpTrigger1', {
    methods: ['GET'],
    authLevel: 'anonymous',
    route: 'products/{id}',
    extraInputs: [tableInput],
    handler: httpTrigger1,
});

const { app, input } = require('@azure/functions');

const tableInput = input.table({
    connection: 'MyStorageConnectionAppSetting',
    partitionKey: 'products',
    tableName: 'products',
    rowKey: '{id}',
});

app.http('httpTrigger1', {
    methods: ['GET'],
    authLevel: 'anonymous',
    route: 'products/{id}',
    extraInputs: [tableInput],
    handler: async (request, context) => {
        return { jsonBody: context.extraInputs.get(tableInput) };
    },
});

{
    "type": "table",
    "direction": "in",
    "name": "product",
    "partitionKey": "products",
    "tableName": "products",
    "rowKey": "{id}"
}

Wanneer u routeparameters gebruikt, wordt er automatisch een invoke_URL_template gemaakt voor uw functie. Uw clients kunnen de URL-sjabloon gebruiken om inzicht te hebben in de parameters die ze nodig hebben om de URL door te geven bij het aanroepen van uw functie met behulp van de URL. Navigeer naar een van uw door HTTP geactiveerde functies in Azure Portal en selecteer Functie-URL ophalen.

U kunt programmatisch toegang krijgen tot de invoke_URL_template api's van Azure Resource Manager voor Lijstfuncties of Functie ophalen.

HTTP-streams (preview)

U kunt nu aanvragen naar en antwoorden van uw HTTP-eindpunt streamen in Node.js v4-functie-apps. Zie HTTP-streams voor meer informatie.

Werken met clientidentiteiten

Als uw functie-app gebruikmaakt van App Service-verificatie/-autorisatie, kunt u informatie over geverifieerde clients bekijken vanuit uw code. Deze informatie is beschikbaar als aanvraagheaders die door het platform worden geïnjecteerd.

U kunt deze informatie ook lezen uit bindingsgegevens. Deze mogelijkheid is alleen beschikbaar voor de Functions-runtime in 2.x en hoger. Het is momenteel ook alleen beschikbaar voor .NET-talen.

Informatie met betrekking tot geverifieerde clients is beschikbaar als een ClaimsPrincipal, die beschikbaar is als onderdeel van de aanvraagcontext, zoals wordt weergegeven in het volgende voorbeeld:

De geverifieerde gebruiker is beschikbaar via HTTP-headers.

De geverifieerde gebruiker is beschikbaar via HTTP-headers.

Autorisatieniveau

Het autorisatieniveau is een tekenreekswaarde die het type autorisatiesleutel aangeeft dat is vereist voor toegang tot het functie-eindpunt. Voor een door HTTP geactiveerde functie kan het autorisatieniveau een van de volgende waarden zijn:

Niveauwaarde Beschrijving
Anonieme Er is geen API-sleutel vereist. Dit is de standaardwaarde wanneer een niveau niet specifiek is ingesteld.
Functie Er is een functiespecifieke API-sleutel vereist.
Admin De hoofdsleutel is vereist.
Niveauwaarde Beschrijving
Anonieme Er is geen API-sleutel vereist.
Functie Er is een functiespecifieke API-sleutel vereist. Dit is de standaardwaarde wanneer een niveau niet specifiek is ingesteld.
Admin De hoofdsleutel is vereist.

Functietoegangssleutels

Met Functions kunt u sleutels gebruiken om tijdens de ontwikkeling moeilijker toegang te krijgen tot uw HTTP-functie-eindpunten. Tenzij het HTTP-toegangsniveau voor een door HTTP geactiveerde functie is ingesteld anonymousop, moeten aanvragen een API-toegangssleutel in de aanvraag bevatten.

Hoewel sleutels een standaardbeveiligingsmechanisme bieden, kunt u andere opties overwegen om een HTTP-eindpunt in productie te beveiligen. Het is bijvoorbeeld geen goede gewoonte om gedeeld geheim te distribueren in openbare apps. Als uw functie wordt aangeroepen vanuit een openbare client, kunt u overwegen een ander beveiligingsmechanisme te implementeren. Zie Een HTTP-eindpunt beveiligen in productie voor meer informatie.

Wanneer u uw functiesleutelwaarden vernieuwt, moet u de bijgewerkte sleutelwaarden handmatig distribueren naar alle clients die uw functie aanroepen.

Autorisatiebereiken (functieniveau)

Er zijn twee toegangsbereiken voor sleutels op functieniveau:

  • Functie: Deze sleutels zijn alleen van toepassing op de specifieke functies waaronder ze zijn gedefinieerd. Wanneer deze worden gebruikt als API-sleutel, staan deze alleen toegang tot die functie toe.

  • Host: Sleutels met een hostbereik kunnen worden gebruikt voor toegang tot alle functies in de functie-app. Wanneer deze worden gebruikt als API-sleutel, hebben deze toegang tot elke functie in de functie-app.

Elke sleutel wordt genoemd als referentie en er is een standaardsleutel (met de naam 'standaard') op het functie- en hostniveau. Functietoetsen hebben voorrang op hostsleutels. Wanneer twee sleutels met dezelfde naam worden gedefinieerd, wordt de functiesleutel altijd gebruikt.

Hoofdsleutel (beheerniveau)

Elke functie-app heeft ook een hostsleutel op beheerniveau met de naam _master. Naast het bieden van toegang op hostniveau tot alle functies in de app, biedt de hoofdsleutel ook beheerderstoegang tot de RUNTIME REST API's. Deze sleutel kan niet worden ingetrokken. Wanneer u een toegangsniveau instelt admin, moeten aanvragen de hoofdsleutel gebruiken. Elke andere sleutel resulteert in toegangsfouten.

Let op

Vanwege de verhoogde machtigingen in uw functie-app die zijn verleend door de hoofdsleutel, moet u deze sleutel niet delen met derden of distribueren in systeemeigen clienttoepassingen. Wees voorzichtig bij het kiezen van het beheerderstoegangsniveau.

Sleutels verkrijgen

Sleutels worden opgeslagen als onderdeel van uw functie-app in Azure en worden at-rest versleuteld. Als u uw sleutels wilt weergeven, nieuwe sleutels wilt maken of sleutels wilt samendraaien naar nieuwe waarden, gaat u naar een van uw door HTTP geactiveerde functies in Azure Portal en selecteert u Functiesleutels.

U kunt ook hostsleutels beheren. Navigeer naar de functie-app in Azure Portal en selecteer App-sleutels.

U kunt functie- en hostsleutels programmatisch verkrijgen met behulp van de Azure Resource Manager-API's. Er zijn API's voor het weergeven van functiesleutels en het vermelden van hostsleutels. Wanneer u implementatiesites gebruikt, zijn de bijbehorende API's site voor lijstfunctiesleutels en site voor lijsthostsleutels.

U kunt ook programmatisch nieuwe functie- en hostsleutels maken met behulp van het functiegeheim maken of bijwerken, functiegeheimsite maken of bijwerken, hostgeheim maken of bijwerken en API's voor hostgeheimen maken of bijwerken.

Functie- en hostsleutels kunnen programmatisch worden verwijderd met behulp van het Functiegeheim verwijderen, Functiegeheimsite verwijderen, Hostgeheim verwijderen en Hostgeheim-API's verwijderen.

U kunt ook de verouderde sleutelbeheer-API's gebruiken om functiesleutels te verkrijgen, maar het gebruik van de Azure Resource Manager-API's wordt aanbevolen.

Autorisatie van API-sleutel

Voor de meeste HTTP-triggersjablonen is een API-sleutel in de aanvraag vereist. Uw HTTP-aanvraag ziet er normaal gesproken uit als de volgende URL:

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

De sleutel kan worden opgenomen in een queryreeksvariabele met de naam code, zoals hierboven. Het kan ook worden opgenomen in een x-functions-key HTTP-header. De waarde van de sleutel kan elke functiesleutel zijn die is gedefinieerd voor de functie of een hostsleutel.

U kunt anonieme aanvragen toestaan, waarvoor geen sleutels zijn vereist. U kunt ook vereisen dat de hoofdsleutel wordt gebruikt. U wijzigt het standaardautorisatieniveau met behulp van de authLevel eigenschap in de bindingS-JSON. Zie Trigger - configuratie voor meer informatie.

Notitie

Wanneer u functies lokaal uitvoert, wordt autorisatie uitgeschakeld, ongeacht de opgegeven instelling voor autorisatieniveau. Na publicatie naar Azure wordt de authLevel instelling in uw trigger afgedwongen. Sleutels zijn nog steeds vereist bij lokaal uitvoeren in een container.

Een HTTP-eindpunt beveiligen in productie

Als u uw functie-eindpunten volledig wilt beveiligen in productie, moet u overwegen een van de volgende beveiligingsopties op functie-app-niveau te implementeren. Wanneer u een van deze beveiligingsmethoden op functie-app-niveau gebruikt, moet u het autorisatieniveau van de HTTP-geactiveerde functie instellen op anonymous.

App Service-verificatie/-autorisatie inschakelen

Met het App Service-platform kunt u Microsoft Entra ID en verschillende id-providers van derden gebruiken om clients te verifiëren. U kunt deze strategie gebruiken om aangepaste autorisatieregels voor uw functies te implementeren en u kunt werken met gebruikersgegevens uit uw functiecode. Zie Verificatie en autorisatie in Azure-app Service en werken met clientidentiteiten voor meer informatie.

Azure API Management (APIM) gebruiken om aanvragen te verifiëren

APIM biedt diverse API-beveiligingsopties voor binnenkomende aanvragen. Zie API Management-verificatiebeleidsregels voor meer informatie. Met APIM kunt u uw functie-app zo configureren dat alleen aanvragen worden geaccepteerd vanaf het IP-adres van uw APIM-exemplaar. Zie IP-adresbeperkingen voor meer informatie.

Uw functie-app in isolatie implementeren

Azure-app Service Environment (ASE) biedt een toegewezen hostingomgeving waarin u uw functies kunt uitvoeren. Met ASE kunt u één front-endgateway configureren die u kunt gebruiken om alle binnenkomende aanvragen te verifiëren. Zie Een WaF (Web Application Firewall) configureren voor App Service Environment voor meer informatie.

Webhooks

Notitie

De webhookmodus is alleen beschikbaar voor versie 1.x van de Functions-runtime. Deze wijziging is aangebracht om de prestaties van HTTP-triggers in versie 2.x en hoger te verbeteren.

In versie 1.x bieden webhooksjablonen extra validatie voor webhookpayloads. In versie 2.x en hoger werkt de basis-HTTP-trigger nog steeds en is dit de aanbevolen methode voor webhooks.

WebHooktype

De webHookType bindingseigenschap geeft het type aan als de webhook wordt ondersteund door de functie, die ook de ondersteunde nettolading bepaalt. Het type webhook kan een van de volgende waarden zijn:

Typewaarde Beschrijving
genericJson Een webhookeindpunt voor algemeen gebruik zonder logica voor een specifieke provider. Met deze instelling worden aanvragen beperkt tot alleen aanvragen die HTTP POST gebruiken en met het application/json inhoudstype.
github De functie reageert op GitHub-webhooks. Gebruik de authLevel eigenschap niet met GitHub-webhooks.
slack De functie reageert op Slack-webhooks. Gebruik de authLevel eigenschap niet met Slack-webhooks.

Wanneer u de webHookType eigenschap instelt, moet u de eigenschap niet ook instellen methods voor de binding.

GitHub-webhooks

Als u wilt reageren op GitHub-webhooks, maakt u eerst uw functie met een HTTP-trigger en stelt u de eigenschap webHookType in op github. Kopieer vervolgens de URL en API-sleutel naar de pagina Webhook toevoegen van uw GitHub-opslagplaats.

Schermopname van het toevoegen van een webhook voor uw functie.

Slack-webhooks

De Slack-webhook genereert een token voor u in plaats van het op te geven, dus u moet een functiespecifieke sleutel configureren met het token van Slack. Zie Autorisatiesleutels.

Webhooks en sleutels

Webhookautorisatie wordt verwerkt door het webhookontvangeronderdeel, onderdeel van de HTTP-trigger en het mechanisme varieert op basis van het type webhook. Elk mechanisme is afhankelijk van een sleutel. Standaard wordt de functiesleutel met de naam 'standaard' gebruikt. Als u een andere sleutel wilt gebruiken, configureert u de webhookprovider om de sleutelnaam met de aanvraag op een van de volgende manieren te verzenden:

  • Querytekenreeks: de provider geeft de sleutelnaam door in de clientid querytekenreeksparameter, zoals https://<APP_NAME>.azurewebsites.net/api/<FUNCTION_NAME>?clientid=<KEY_NAME>.
  • Aanvraagheader: de provider geeft de sleutelnaam door in de x-functions-clientid header.

Inhoudstypen

Als u binaire en formuliergegevens doorgeeft aan een niet-C#-functie, moet u de juiste inhoudstypeheader gebruiken. Ondersteunde inhoudstypen zijn onder andere octet-stream voor binaire gegevens en typen met meerdere onderdelen.

Bekende problemen

In niet-C#-functies worden aanvragen verzonden met de inhoudstyperesultaten image/jpeg in een string waarde die aan de functie is doorgegeven. In dergelijke gevallen kunt u de string waarde handmatig converteren naar een bytematrix om toegang te krijgen tot de onbewerkte binaire gegevens.

Limieten

De lengte van de HTTP-aanvraag is beperkt tot 100 MB (104.857.600 bytes) en de URL-lengte is beperkt tot 4 kB (4.096 bytes). Deze limieten worden opgegeven door het element van het httpRuntime Web.config-bestand van de runtime.

Als een functie die gebruikmaakt van de HTTP-trigger niet binnen 230 seconden wordt voltooid, treedt er een time-out op en retourneert de Azure Load Balancer een HTTP 502-fout. De functie blijft actief, maar kan geen HTTP-antwoord retourneren. Voor langlopende functies raden we u aan asynchrone patronen te volgen en een locatie te retourneren waar u de status van de aanvraag kunt pingen. Zie Schaal en hosting - Verbruiksabonnement voor meer informatie over hoe lang een functie kan worden uitgevoerd.

Volgende stappen