Share via

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 dit voorbeeld worden HTTP-streams gebruikt om gesegmenteerde antwoordgegevens te retourneren.

import time

import azure.functions as func
from azurefunctions.extensions.http.fastapi import Request, StreamingResponse

app = func.FunctionApp(http_auth_level=func.AuthLevel.ANONYMOUS)


def generate_sensor_data():
    """Generate real-time sensor data."""
    for i in range(10):
        # Simulate temperature and humidity readings
        temperature = 20 + i
        humidity = 50 + i
        yield f"data: {{'temperature': {temperature}, 'humidity': {humidity}}}\n\n"
        time.sleep(1)


@app.route(route="stream", methods=[func.HttpMethod.GET])
async def stream_sensor_data(req: Request) -> StreamingResponse:
    """Endpoint to stream real-time sensor data."""
    return StreamingResponse(generate_sensor_data(), media_type="text/event-stream")

Zie HTTP-streams voor meer informatie, waaronder het inschakelen van HTTP-streams in uw project.

In dit 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.

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 het geïsoleerde werkrolmodel als het in-procesmodel gebruiken om HttpTriggerAttribute 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 werkmodelfunctie-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 van het type HttpRequestData is of HttpRequest, kunnen aangepaste typen ook worden gebonden aan andere 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. Dit is een ander type dan het vergelijkbare kenmerk in Microsoft.AspNetCore.Mvc. Wanneer u ASP.NET Core-integratie gebruikt, hebt u een volledig gekwalificeerde verwijzing of using instructie nodig. In dit voorbeeld ziet u hoe u het kenmerk gebruikt om alleen de hoofdinhoud op te halen terwijl u nog steeds toegang hebt tot de volledige inhoud HttpRequest, met behulp van 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 category id. 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 category id:

@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

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

HTTP-streams

Met ondersteuning voor HTTP-streams in Python kunt u gegevens van uw HTTP-eindpunten accepteren en retourneren met behulp van FastAPI-aanvraag- en antwoord-API's die zijn ingeschakeld in uw functies. Met deze API's kan de host gegevens in HTTP-berichten verwerken als segmenten in plaats van dat een volledig bericht in het geheugen moet worden gelezen. Zie HTTP-streams in Python voor meer informatie

Belangrijk

Ondersteuning voor HTTP-streams voor Python is momenteel in preview en wordt alleen ondersteund voor het Python v2-programmeermodel.

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.

Notitie

Toegang tot geverifieerde clientgegevens is momenteel alleen beschikbaar voor .NET-talen. Het wordt ook niet ondersteund in versie 1.x van de Functions-runtime.

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
anoniem Er is geen toegangssleutel vereist.
functie Er is een functiespecifieke sleutel vereist voor toegang tot het eindpunt.
admin De hoofdsleutel is vereist voor toegang tot het eindpunt.

Wanneer een niveau niet expliciet is ingesteld, wordt de autorisatie standaard ingesteld op het function niveau.

Wanneer een niveau niet expliciet is ingesteld, is de standaardautorisatie afhankelijk van de versie van het Node.js-model:

Autorisatie wordt standaard ingesteld op het anonymous niveau.

Functietoegangssleutels

Met Functies kunt u toegangssleutels gebruiken om de toegang tot uw functie-eindpunten moeilijker te maken. Tenzij het autorisatieniveau voor een door HTTP geactiveerde functie is ingesteld anonymousop, moeten aanvragen een toegangssleutel in de aanvraag bevatten. Zie Werken met toegangssleutels in Azure Functions voor meer informatie.

Autorisatie van toegangssleutels

Voor de meeste HTTP-triggersjablonen is een toegangssleutel 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 eerder vermeld. 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.

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.

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 nog een 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