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 följande exempel visas 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. Exemplet beror på om du använder python-programmeringsmodellen v1 eller v2.

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

C#-biblioteken HttpTriggerAttribute för både processer och isolerade arbetsprocesser använder 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 arbetsprocesser 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 eller 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.
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.

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

Användning

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 brödtexten i begäran är JSON försöker körningen parsa den för att ange objektegenskaperna.

När utlösarparametern är en HttpRequestDataHttpRequestkan anpassade typer också bindas till ytterligare 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. Observera att detta är en annan typ än det liknande attributet i Microsoft.AspNetCore.Mvc, och när du använder ASP.NET Core-integrering behöver du en fullständigt kvalificerad referens eller using instruktion. I följande exempel visas 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-integreringen:

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 categoryid. 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 api-routningsprefixet 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-portalen 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 (förhandsversion)

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.

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. Den här funktionen är endast tillgänglig för Functions-körningen i 2.x och senare. Det är också för närvarande endast tillgängligt för .NET-språk.

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 API-nyckel krävs. Det här är standardvärdet när en nivå inte anges specifikt.
Funktion En funktionsspecifik API-nyckel krävs.
Admin Huvudnyckeln krävs.
Nivåvärde beskrivning
Anonym Ingen API-nyckel krävs.
Funktion En funktionsspecifik API-nyckel krävs. Det här är standardvärdet när en nivå inte anges specifikt.
Admin Huvudnyckeln krävs.

Funktionsåtkomstnycklar

Med Functions kan du använda nycklar för att göra det svårare att komma åt http-funktionsslutpunkterna under utvecklingen. Om inte HTTP-åtkomstnivån på en HTTP-utlöst funktion är inställd anonymouspå måste begäranden innehålla en API-åtkomstnyckel i begäran.

Även om nycklar är en standardsäkerhetsmekanism kanske du vill överväga andra alternativ för att skydda en HTTP-slutpunkt i produktion. Det är till exempel inte en bra idé att distribuera delad hemlighet i offentliga appar. Om funktionen anropas från en offentlig klient kan du överväga att implementera en annan säkerhetsmekanism. Mer information finns i Skydda en HTTP-slutpunkt i produktion.

När du förnyar funktionsnyckelvärdena måste du manuellt omdistribuera de uppdaterade nyckelvärdena till alla klienter som anropar funktionen.

Auktoriseringsomfång (funktionsnivå)

Det finns två åtkomstomfattningar för nycklar på funktionsnivå:

  • Funktion: Dessa nycklar gäller endast för de specifika funktioner som de definieras under. När de används som en API-nyckel tillåter dessa endast åtkomst till den funktionen.

  • Värd: Nycklar med ett värdomfång kan användas för att komma åt alla funktioner i funktionsappen. När de används som en API-nyckel tillåter dessa åtkomst till alla funktioner i funktionsappen.

Varje nyckel är namngiven som referens och det finns en standardnyckel (med namnet "standard") på funktions- och värdnivå. Funktionsnycklar har företräde framför värdnycklar. När två nycklar definieras med samma namn används alltid funktionsnyckeln.

Huvudnyckel (administratörsnivå)

Varje funktionsapp har också en värdnyckel på administratörsnivå med namnet _master. Förutom att ge åtkomst på värdnivå till alla funktioner i appen ger huvudnyckeln även administrativ åtkomst till REST-API:erna för körning. Det går inte att återkalla den här nyckeln. När du anger en åtkomstnivå för adminmåste begäranden använda huvudnyckeln. Alla andra nycklar resulterar i åtkomstfel.

Varning

På grund av de utökade behörigheterna i funktionsappen som har beviljats av huvudnyckeln bör du inte dela den här nyckeln med tredje part eller distribuera den i interna klientprogram. Var försiktig när du väljer administratörsåtkomstnivå.

Hämta nycklar

Nycklar lagras som en del av funktionsappen i Azure och krypteras i vila. Om du vill visa dina nycklar, skapa nya eller rulla nycklar till nya värden navigerar du till en av dina HTTP-utlösta funktioner i Azure-portalen och väljer Funktionsnycklar.

Du kan också hantera värdnycklar. Gå till funktionsappen i Azure-portalen och välj Appnycklar.

Du kan hämta funktions- och värdnycklar programmatiskt med hjälp av Azure Resource Manager-API:erna. Det finns API:er för att visa funktionsnycklar och listvärdnycklar, och när du använder distributionsplatser är motsvarande API:er plats för listfunktionsnycklar och listvärdnycklar.

Du kan också skapa nya funktions- och värdnycklar programmatiskt med hjälp av API:erna Skapa eller uppdatera funktionshemlighet, Skapa eller uppdatera funktionshemlighet, Skapa eller uppdatera värdhemlighets-API:er.

Funktions- och värdnycklar kan tas bort programmatiskt med hjälp av API:erna Ta bort funktionshemlighet, Ta bort funktionshemlighet, Ta bort värdhemlighet och Ta bort värdhemlighetsfack .

Du kan också använda äldre API:er för nyckelhantering för att hämta funktionsnycklar, men du rekommenderas i stället att använda Azure Resource Manager-API:erna.

API-nyckelauktorisering

De flesta HTTP-utlösarmallar kräver en API-nyckel 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 ingå i en frågesträngsvariabel med namnet code, som ovan. 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. Mer information finns i Utlösare – konfiguration.

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.

Skydda en HTTP-slutpunkt i produktion

Om du vill skydda funktionsslutpunkterna fullständigt i produktion bör du överväga att implementera något av följande säkerhetsalternativ på funktionsappnivå. När du använder någon av dessa säkerhetsmetoder på appnivå för funktionen bör du ställa in den HTTP-utlösta funktionsauktoriseringsnivån på anonymous.

Aktivera App Service-autentisering/auktorisering

Med App Service-plattformen kan du använda Microsoft Entra-ID och flera identitetsprovidrar från tredje part för att autentisera klienter. Du kan använda den här strategin för att implementera anpassade auktoriseringsregler för dina funktioner och du kan arbeta med användarinformation från funktionskoden. Mer information finns i Autentisering och auktorisering i Azure App Service och Arbeta med klientidentiteter.

Använda Azure API Management (APIM) för att autentisera begäranden

APIM innehåller en mängd olika API-säkerhetsalternativ för inkommande begäranden. Mer information finns i API Management-autentiseringsprinciper. Med APIM på plats kan du konfigurera funktionsappen så att den endast accepterar begäranden från IP-adressen för din APIM-instans. Mer information finns i BEGRÄNSNINGAR för IP-adresser.

Distribuera funktionsappen isolerat

Azure App Service-miljön (ASE) tillhandahåller en dedikerad värdmiljö där du kan köra dina funktioner. Med ASE kan du konfigurera en enskild klientdelsgateway som du kan använda för att autentisera alla inkommande begäranden. Mer information finns i Konfigurera en brandvägg för webbaserade program (WAF) för App Service-miljön.

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 webhooksmallar ytterligare 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