Dela via

Http-utlösare för Azure Functions

  • Artikel

Med HTTP-utlösaren kan du anropa en funktion med en HTTP-begäran. Du kan använda en HTTP-utlösare för att skapa serverlösa API:er och svara på webhooks.

Standardreturvärdet för en HTTP-utlöst funktion är:

  • HTTP 204 No Content med en tom brödtext i Functions 2.x och senare
  • HTTP 200 OK med en tom brödtext i Functions 1.x

Om du vill ändra HTTP-svaret konfigurerar du en utdatabindning.

Mer information om HTTP-bindningar finns i översikts- och utdatabindningsreferensen.

Dricks

Om du planerar att använda HTTP- eller WebHook-bindningarna planerar du att undvika portöverbelastning som kan orsakas av felaktig instansiering av HttpClient. Mer information finns i Hantera anslutningar i Azure Functions.

Viktigt!

Den här artikeln använder flikar för att stödja flera versioner av Node.js programmeringsmodellen. V4-modellen är allmänt tillgänglig och är utformad för att ha en mer flexibel och intuitiv upplevelse för JavaScript- och TypeScript-utvecklare. Mer information om hur v4-modellen fungerar finns i utvecklarguiden för Azure Functions Node.js. Mer information om skillnaderna mellan v3 och v4 finns i migreringsguiden.

Azure Functions stöder två programmeringsmodeller för Python. Hur du definierar dina bindningar beror på din valda programmeringsmodell.

Med programmeringsmodellen Python v2 kan du definiera bindningar med hjälp av dekoratörer direkt i python-funktionskoden. Mer information finns i utvecklarguiden för Python.

Den här artikeln stöder båda programmeringsmodellerna.

Exempel

En C#-funktion kan skapas med något av följande C#-lägen:

  • Isolerad arbetsmodell: Kompilerad C#-funktion som körs i en arbetsprocess som är isolerad från körningen. Isolerad arbetsprocess krävs för att stödja C#-funktioner som körs på LTS- och icke-LTS-versioner .NET och .NET Framework. Tillägg för isolerade arbetsprocessfunktioner använder Microsoft.Azure.Functions.Worker.Extensions.* namnområden.
  • Processmodell: Kompilerad C#-funktion som körs i samma process som Functions-körningen. I en variant av den här modellen kan Functions köras med C#-skript, vilket främst stöds för redigering av C#-portalen. Tillägg för in-process-funktioner använder Microsoft.Azure.WebJobs.Extensions.* namnområden.

Viktigt!

Supporten upphör för den pågående modellen den 10 november 2026. Vi rekommenderar starkt att du migrerar dina appar till den isolerade arbetsmodellen för fullt stöd.

Koden i den här artikeln är som standard .NET Core-syntax, som används i Functions version 2.x och senare. Information om 1.x-syntaxen finns i 1.x-funktionsmallarna.

I följande exempel visas en HTTP-utlösare som returnerar ett "hello, world"-svar som en IActionResult med hjälp av ASP.NET Core-integrering i .NET Isolerad:

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

I följande exempel visas en HTTP-utlösare som returnerar ett "hello world"-svar som ett HttpResponseData-objekt :

[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;
}

Det här avsnittet innehåller följande exempel:

I följande exempel visas HTTP-utlösarbindningen.

Läs parametern från frågesträngen

Det här exemplet läser en parameter med namnet id, från frågesträngen och använder den för att skapa ett JSON-dokument som returneras till klienten med innehållstypen 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();
    }
}

Läs brödtext från en POST-begäran

I det här exemplet läss brödtexten i en POST-begäran som en String, och används för att skapa ett JSON-dokument som returneras till klienten med innehållstypen 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();
        }
    }

Läsa parametern från en väg

Det här exemplet läser en obligatorisk parameter med namnet id, och en valfri parameter name från vägsökvägen och använder dem för att skapa ett JSON-dokument som returneras till klienten med innehållstypen 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();
    }
}

Läsa POJO-brödtext från en POST-begäran

Här är koden för ToDoItem klassen som refereras i det här exemplet:


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 + "}";
  }
}

I det här exemplet läss brödtexten i en POST-begäran. Begärandetexten av serialiseras automatiskt till ett ToDoItem objekt och returneras till klienten med innehållstypen application/json. Parametern ToDoItem serialiseras av Functions-körningen eftersom den body tilldelas egenskapen för HttpMessageResponse.Builder klassen.

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

I följande exempel visas en TYPEScript-funktion för HTTP-utlösare. Funktionen söker efter en name parameter antingen i frågesträngen eller brödtexten i HTTP-begäran.

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,
});

I följande exempel visas en JAVAScript-funktion för HTTP-utlösare. Funktionen söker efter en name parameter antingen i frågesträngen eller brödtexten i HTTP-begäran.

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}!` };
    },
});

I följande exempel visas en utlösarbindning i en function.json-fil och en PowerShell-funktion. Funktionen söker efter en name parameter antingen i frågesträngen eller brödtexten i HTTP-begäran.

{
  "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
})

I det här exemplet används HTTP-strömmar för att returnera segmenterade svarsdata.

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")

Mer information, inklusive hur du aktiverar HTTP-strömmar i projektet, finns i HTTP-strömmar.

Det här exemplet visar en utlösarbindning och en Python-funktion som använder bindningen. Funktionen söker efter en name parameter antingen i frågesträngen eller brödtexten i HTTP-begäran.

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
        )

Attribut

Både den isolerade arbetsmodellen och den processbaserade modellen använder HttpTriggerAttribute för att definiera utlösarbindningen. C#-skriptet använder i stället en function.json konfigurationsfil enligt beskrivningen i C#-skriptguiden.

I funktionsappar för HttpTriggerAttribute isolerade arbetsmodeller stöder följande parametrar:

Parametrar beskrivning
AuthLevel Avgör vilka nycklar, om några, som måste finnas på begäran för att anropa funktionen. För värden som stöds, se auktoriseringsnivå.
Metoder En matris med DE HTTP-metoder som funktionen svarar på. Om den inte anges svarar funktionen på alla HTTP-metoder. Se anpassa HTTP-slutpunkten.
Rutt Definierar routningsmallen och styr till vilka url:er för begäran som din funktion svarar på. Standardvärdet om inget anges är <functionname>. Mer information finns i anpassa HTTP-slutpunkten.

Dekoratörer

Gäller endast för python v2-programmeringsmodellen.

För Python v2-funktioner som definierats med hjälp av en dekoratör definieras följande egenskaper för en utlösare i dekoratören route , som lägger till HttpTrigger- och HttpOutput-bindning:

Property beskrivning
route Väg för http-slutpunkten. Om Inget anges till funktionsnamn om det finns ett användardefinierat python-funktionsnamn.
trigger_arg_name Argumentnamn för HttpRequest. Standardvärdet är "req".
binding_arg_name Argumentnamn för HttpResponse. Standardvärdet är "$return".
methods En tupplar av DE HTTP-metoder som funktionen svarar på.
auth_level Avgör vilka nycklar, om några, som måste finnas på begäran för att anropa funktionen.

Information om Python-funktioner som definierats med hjälp av function.json finns i avsnittet Konfiguration .

Kommentarer

I Java Functions-körningsbiblioteket använder du HttpTrigger-kommentaren, som stöder följande inställningar:

Konfiguration

Gäller endast programmeringsmodellen Python v1.

I följande tabell förklaras de egenskaper som du kan ange för objektet options som skickas app.http() till metoden.

Property beskrivning
authLevel Avgör vilka nycklar, om några, som måste finnas på begäran för att anropa funktionen. För värden som stöds, se auktoriseringsnivå.
metoder En matris med DE HTTP-metoder som funktionen svarar på. Om den inte anges svarar funktionen på alla HTTP-metoder. Se anpassa HTTP-slutpunkten.
väg Definierar routningsmallen och styr till vilka url:er för begäran som din funktion svarar på. Standardvärdet om inget anges är <functionname>. Mer information finns i anpassa HTTP-slutpunkten.

I följande tabell förklaras de egenskaper för utlösarkonfiguration som du anger i filen function.json , som skiljer sig beroende på körningsversion.

I följande tabell förklaras de bindningskonfigurationsegenskaper som du anger i filen function.json .

function.json egenskap beskrivning
typ Obligatoriskt – måste anges till httpTrigger.
riktning Obligatoriskt – måste anges till in.
Namn Obligatoriskt – variabelnamnet som används i funktionskoden för begäran eller begärandetexten.
authLevel Avgör vilka nycklar, om några, som måste finnas på begäran för att anropa funktionen. För värden som stöds, se auktoriseringsnivå.
metoder En matris med DE HTTP-metoder som funktionen svarar på. Om den inte anges svarar funktionen på alla HTTP-metoder. Se anpassa HTTP-slutpunkten.
väg Definierar routningsmallen och styr till vilka url:er för begäran som din funktion svarar på. Standardvärdet om inget anges är <functionname>. Mer information finns i anpassa HTTP-slutpunkten.

Förbrukning

Det här avsnittet beskriver hur du konfigurerar http-utlösarfunktionens bindning.

HttpTrigger-kommentaren ska tillämpas på en metodparameter av någon av följande typer:

  • HttpRequestMessage<T>.
  • Alla inbyggda Java-typer som int, String, byte[].
  • Null-värden med valfritt.
  • Alla oformaterade Java-objekt (POJO) typ.

Nyttolast

Indatatypen utlösare deklareras som en av följande typer:

Typ Beskrivning
HttpRequest Användning av den här typen kräver att appen har konfigurerats med ASP.NET Core-integrering i .NET Isolerad.
Detta ger dig fullständig åtkomst till begärandeobjektet och övergripande HttpContext.
HttpRequestData En projektion av begärandeobjektet.
En anpassad typ När begärans brödtext är JSON försöker körningen parsa den för att ange objektegenskaperna.

När utlösarparametern är av typen HttpRequestData eller HttpRequestkan anpassade typer också bindas till andra parametrar med hjälp av Microsoft.Azure.Functions.Worker.Http.FromBodyAttribute. Användning av det här attributet kräver Microsoft.Azure.Functions.Worker.Extensions.Http version 3.1.0 eller senare. Det här är en annan typ än det liknande attributet i Microsoft.AspNetCore.Mvc. När du använder ASP.NET Core-integrering behöver du en fullständigt kvalificerad referens eller using instruktion. Det här exemplet visar hur du använder attributet för att bara hämta brödtextinnehållet samtidigt som du har åtkomst till hela HttpRequest, med hjälp av ASP.NET Core-integrering:

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

Anpassa HTTP-slutpunkten

Som standard när du skapar en funktion för en HTTP-utlösare kan funktionen adresseras med en väg i formuläret:

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

Du kan anpassa den här vägen med den valfria route egenskapen på HTTP-utlösarens indatabindning. Du kan använda valfri vägbegränsning för webb-API:et med dina parametrar.

Följande funktionskod accepterar två parametrar category och id i vägen och skriver ett svar med båda parametrarna.

[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;
}

Routningsparametrar definieras med hjälp route av inställningen för anteckningen HttpTrigger . Följande funktionskod accepterar två parametrar category och id i vägen och skriver ett svar med båda parametrarna.

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

Till exempel definierar följande TypeScript-kod en route egenskap för en HTTP-utlösare med två parametrar och category id. Exemplet läser parametrarna från begäran och returnerar deras värden i svaret.

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,
});

Följande JavaScript-kod definierar till exempel en route egenskap för en HTTP-utlösare med två parametrar category och id. Exemplet läser parametrarna från begäran och returnerar deras värden i svaret.

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}` };
    },
});

Följande kod definierar till exempel en route egenskap för en HTTP-utlösare med två parametrar category och id:

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

Routningsparametrar som deklareras i function.json-filen är tillgängliga som en egenskap för $Request.Params objektet.

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

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

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

Funktionskörningskontexten exponeras via en parameter som deklareras som func.HttpRequest. Med den här instansen kan en funktion komma åt datavägsparametrar, frågesträngsvärden och metoder som gör att du kan returnera HTTP-svar.

När de har definierats är routningsparametrarna tillgängliga för funktionen genom att anropa route_params metoden.

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)

Med den här konfigurationen kan funktionen nu adresseras med följande väg i stället för den ursprungliga vägen.

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

Med den här konfigurationen kan funktionskoden stödja två parametrar i adress, kategori och ID. Mer information om hur routningsparametrar tokeniseras i en URL finns i Routning i ASP.NET Core.

Som standard är alla funktionsvägar prefix med api. Du kan också anpassa eller ta bort prefixet extensions.http.routePrefix med hjälp av egenskapen i filen host.json . I följande exempel tar du bort routningsprefixet api med hjälp av en tom sträng för prefixet i host.json-filen.

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

Använda vägparametrar

Routningsparametrar som definierade en funktions route mönster är tillgängliga för varje bindning. Om du till exempel har en väg definierad som "route": "products/{id}" kan en tabelllagringsbindning använda värdet för parametern {id} i bindningskonfigurationen.

Följande konfiguration visar hur parametern {id} skickas till bindningens 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}"
}

När du använder routningsparametrar skapas en invoke_URL_template automatiskt för din funktion. Dina klienter kan använda URL-mallen för att förstå de parametrar som de behöver för att skicka in URL:en när de anropar funktionen med hjälp av dess URL. Gå till en av dina HTTP-utlösta funktioner i Azure Portal och välj Hämta funktions-URL.

Du kan programmatiskt komma åt invoke_URL_template med hjälp av Azure Resource Manager-API:erna för listfunktioner eller Hämta funktion.

HTTP-strömmar

Nu kan du strömma begäranden till och svar från HTTP-slutpunkten i Node.js v4-funktionsappar. Mer information finns i HTTP-strömmar.

HTTP-strömmar

Med stöd för HTTP-strömmar i Python kan du acceptera och returnera data från dina HTTP-slutpunkter med hjälp av Api:er för FastAPI-begäran och svar aktiverat i dina funktioner. Med dessa API:er kan värden bearbeta data i HTTP-meddelanden som segment i stället för att behöva läsa ett helt meddelande i minnet. Mer information finns i HTTP-strömmar i Python

Viktigt!

STÖD för HTTP-strömmar för Python är för närvarande i förhandsversion och stöds endast för python v2-programmeringsmodellen.

Arbeta med klientidentiteter

Om din funktionsapp använder App Service-autentisering/auktorisering kan du visa information om autentiserade klienter från koden. Den här informationen är tillgänglig som begärandehuvuden som matas in av plattformen.

Du kan också läsa den här informationen från bindningsdata.

Kommentar

Åtkomst till autentiserad klientinformation är för närvarande endast tillgänglig för .NET-språk. Det stöds inte heller i version 1.x av Functions-körningen.

Information om autentiserade klienter är tillgänglig som en ClaimsPrincipal, som är tillgänglig som en del av begärandekontexten enligt följande exempel:

Den autentiserade användaren är tillgänglig via HTTP-huvuden.

Den autentiserade användaren är tillgänglig via HTTP-huvuden.

Auktoriseringsnivå

Auktoriseringsnivån är ett strängvärde som anger vilken typ av auktoriseringsnyckel som krävs för att få åtkomst till funktionsslutpunkten. För en HTTP-utlöst funktion kan auktoriseringsnivån vara något av följande värden:

Nivåvärde beskrivning
anonym Ingen åtkomstnyckel krävs.
funktion En funktionsspecifik nyckel krävs för att få åtkomst till slutpunkten.
Admin Huvudnyckeln krävs för att få åtkomst till slutpunkten.

När en nivå inte uttryckligen har angetts är auktoriseringen standard på nivån function .

När en nivå inte uttryckligen anges beror standardauktoriseringen på versionen av Node.js modellen:

Auktorisering är standardnivå anonymous .

Funktionsåtkomstnycklar

Med Functions kan du använda åtkomstnycklar för att göra det svårare att komma åt funktionsslutpunkterna. Om inte auktoriseringsnivån för en HTTP-utlöst funktion har angetts till anonymousmåste begäranden innehålla en åtkomstnyckel i begäran. Mer information finns i Arbeta med åtkomstnycklar i Azure Functions.

Åtkomstnyckelauktorisering

De flesta HTTP-utlösarmallar kräver en åtkomstnyckel i begäran. Så din HTTP-begäran ser normalt ut som följande URL:

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

Nyckeln kan inkluderas i en frågesträngsvariabel med namnet code, som tidigare nämnts. Det kan också ingå i ett x-functions-key HTTP-huvud. Värdet för nyckeln kan vara valfri funktionsnyckel som definierats för funktionen eller valfri värdnyckel.

Du kan tillåta anonyma begäranden som inte kräver nycklar. Du kan också kräva att huvudnyckeln används. Du ändrar standardauktoriseringsnivån med hjälp authLevel av egenskapen i bindnings-JSON.

Kommentar

När du kör funktioner lokalt inaktiveras auktoriseringen oavsett den angivna inställningen för auktoriseringsnivå. När du har publicerat till Azure authLevel tillämpas inställningen i utlösaren. Nycklar krävs fortfarande när du kör lokalt i en container.

Webhook

Kommentar

Webhook-läget är endast tillgängligt för version 1.x av Functions-körningen. Den här ändringen gjordes för att förbättra prestandan för HTTP-utlösare i version 2.x och senare.

I version 1.x tillhandahåller webhook-mallar en annan validering för webhook-nyttolaster. I version 2.x och senare fungerar fortfarande den grundläggande HTTP-utlösaren och är den rekommenderade metoden för webhooks.

WebHook-typ

Bindningsegenskapen webHookType anger typen om webhook stöds av funktionen, vilket också avgör vilken nyttolast som stöds. Webhook-typen kan vara något av följande värden:

Typvärde beskrivning
genericJson En webhook-slutpunkt för generell användning utan logik för en specifik provider. Den här inställningen begränsar begäranden till endast de som använder HTTP POST och med application/json innehållstypen.
github Funktionen svarar på GitHub-webhooks. Använd authLevel inte egenskapen med GitHub-webhooks.
slack Funktionen svarar på Slack-webhooks. Använd inte egenskapen authLevel med Slack-webhooks.

När du anger webHookType egenskapen anger methods du inte heller egenskapen för bindningen.

GitHub-webhooks

Om du vill svara på GitHub-webhooks skapar du först funktionen med en HTTP-utlösare och anger egenskapen webHookType till github. Kopiera sedan dess URL och API-nyckel till sidan Lägg till webhook på din GitHub-lagringsplats.

Skärmbild som visar hur du lägger till en webhook för din funktion.

Slack webhooks

Slack-webhooken genererar en token åt dig i stället för att låta dig ange den, så du måste konfigurera en funktionsspecifik nyckel med token från Slack. Se Auktoriseringsnycklar.

Webhooks och nycklar

Webhook-auktorisering hanteras av webhook-mottagarkomponenten, en del av HTTP-utlösaren, och mekanismen varierar beroende på typen webhook. Varje mekanism förlitar sig på en nyckel. Som standard används funktionsnyckeln med namnet "default". Om du vill använda en annan nyckel konfigurerar du webhook-providern för att skicka nyckelnamnet med begäran på något av följande sätt:

  • Frågesträng: Providern skickar nyckelnamnet i frågesträngsparametern clientid , till exempel https://<APP_NAME>.azurewebsites.net/api/<FUNCTION_NAME>?clientid=<KEY_NAME>.
  • Begärandehuvud: Providern skickar nyckelnamnet i x-functions-clientid rubriken.

Innehållstyper

Om du skickar binära data och formulärdata till en icke-C#-funktion måste du använda rätt rubrik av innehållstyp. Innehållstyper som stöds omfattar octet-stream binära data och typer av flera delar.

Kända problem

I icke-C#-funktioner resulterar begäranden som skickas med innehållstypen image/jpeg i ett string värde som skickas till funktionen. I sådana fall kan du manuellt konvertera string värdet till en bytematris för att få åtkomst till de binära rådata.

Gränser

Längden på HTTP-begäranden är begränsad till 100 MB (104 857 600 byte) och URL-längden är begränsad till 4 kB (4 096 byte). Dessa gränser anges av elementet i httpRuntime körningens Web.config-fil.

Om en funktion som använder HTTP-utlösaren inte slutförs inom 230 sekunder överskrider Azure Load Balancer tidsgränsen och returnerar ett HTTP 502-fel. Funktionen fortsätter att köras men kan inte returnera ett HTTP-svar. För långvariga funktioner rekommenderar vi att du följer asynkrona mönster och returnerar en plats där du kan pinga status för begäran. Information om hur länge en funktion kan köras finns i Skala och hantera – Förbrukningsplan.

Nästa steg