Sdílet prostřednictvím

Trigger HTTP služby Azure Functions

  • Článek

Trigger HTTP umožňuje vyvolat funkci s požadavkem HTTP. Pomocí triggeru HTTP můžete vytvářet bezserverová rozhraní API a reagovat na webhooky.

Výchozí návratová hodnota funkce aktivované protokolem HTTP je:

  • HTTP 204 No Content s prázdným tělem ve funkcích 2.x a vyšších
  • HTTP 200 OK s prázdným tělem ve funkcích 1.x

Pokud chcete upravit odpověď HTTP, nakonfigurujte výstupní vazbu.

Další informace o vazbách HTTP najdete v přehledu a odkazu na výstupní vazbu.

Tip

Pokud plánujete používat vazby HTTP nebo WebHook, naplánujte, aby se zabránilo vyčerpání portů, které může být způsobeno nesprávnou instancí HttpClient. Další informace najdete v tématu Správa připojení ve službě Azure Functions.

Důležité

Tento článek používá karty pro podporu více verzí programovacího modelu Node.js. Model v4 je obecně dostupný a je navržený tak, aby měl flexibilnější a intuitivnější prostředí pro vývojáře v JavaScriptu a TypeScriptu. Další podrobnosti o tom, jak model v4 funguje, najdete v příručce pro vývojáře služby Azure Functions Node.js. Další informace o rozdílech mezi v3 a v4 najdete v průvodci migrací.

Azure Functions podporuje dva programovací modely pro Python. Způsob, jakým definujete vazby, závisí na zvoleném programovacím modelu.

Programovací model Pythonu v2 umožňuje definovat vazby pomocí dekorátorů přímo v kódu funkce Pythonu. Další informace najdete v příručce pro vývojáře Pythonu.

Tento článek podporuje oba programovací modely.

Příklad

Funkci jazyka C# je možné vytvořit pomocí jednoho z následujících režimů jazyka C#:

  • Izolovaný model pracovního procesu: Kompilovaná funkce jazyka C#, která běží v pracovním procesu, který je izolovaný od modulu runtime. Izolovaný pracovní proces je nutný pro podporu funkcí C# spuštěných na LTS a jiných verzích než LTS .NET a rozhraní .NET Framework. Rozšíření pro izolované funkce pracovních procesů používají Microsoft.Azure.Functions.Worker.Extensions.* obory názvů.
  • Model v procesu: Zkompilovaná funkce jazyka C#, která běží ve stejném procesu jako modul runtime služby Functions. Ve variantě tohoto modelu je možné spouštět funkce pomocí skriptování jazyka C#, což je podporováno především pro úpravy portálu C#. Rozšíření pro procesní funkce používají Microsoft.Azure.WebJobs.Extensions.* obory názvů.

Důležité

Podpora modelu v procesu skončí 10. listopadu 2026. Důrazně doporučujeme migrovat aplikace do izolovaného modelu pracovního procesu pro plnou podporu.

Kód v tomto článku ve výchozím nastavení používá syntaxi .NET Core, která se používá ve službě Functions verze 2.x a vyšší. Informace o syntaxi 1.x najdete v šablonách funkcí 1.x.

Následující příklad ukazuje trigger HTTP, který vrátí odpověď "hello, world" jako IActionResult s využitím integrace ASP.NET Core v izolovaném prostředí .NET:

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

Následující příklad ukazuje trigger HTTP, který vrátí odpověď "hello world" jako 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;
}

Tato část obsahuje následující příklady:

Následující příklady ukazují vazbu triggeru HTTP.

Čtení parametru z řetězce dotazu

Tento příklad načte parametr s názvem id, z řetězce dotazu a používá ho k sestavení dokumentu JSON vráceného klientovi s typem application/jsonobsahu .

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

Čtení textu z požadavku POST

Tento příklad přečte text požadavku POST jako Stringa použije ho k vytvoření dokumentu JSON vráceného klientovi s typem application/jsonobsahu .

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

Čtení parametru ze trasy

Tento příklad přečte povinný parametr s názvem ida volitelným parametrem name z cesty trasy a použije je k sestavení dokumentu JSON vráceného klientovi s typem application/jsonobsahu .

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

Čtení textu POJO z požadavku POST

Tady je kód třídy ToDoItem , na který odkazuje tento příklad:


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

Tento příklad přečte text požadavku POST. Tělo požadavku se automaticky de serializuje do objektu ToDoItem a vrátí se klientovi s typem application/jsonobsahu . Parametr ToDoItem je serializován modulem runtime Functions, protože je přiřazen k body vlastnosti HttpMessageResponse.Builder třídy.

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

Následující příklad ukazuje funkci TypeScript triggeru HTTP. Funkce hledá name parametr buď v řetězci dotazu, nebo v textu požadavku HTTP.

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

Následující příklad ukazuje funkci JavaScriptu triggeru HTTP. Funkce hledá name parametr buď v řetězci dotazu, nebo v textu požadavku HTTP.

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

Následující příklad ukazuje vazbu triggeru v souboru function.json a funkci PowerShellu. Funkce hledá name parametr buď v řetězci dotazu, nebo v textu požadavku HTTP.

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

Tento příklad používá streamy HTTP k vrácení dat odpovědi blokovaných dat.

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

Další informace, včetně povolení streamů HTTP v projektu, najdete v tématu Streamy HTTP.

Tento příklad ukazuje vazbu triggeru a funkci Pythonu, která tuto vazbu používá. Funkce hledá name parametr buď v řetězci dotazu, nebo v textu požadavku HTTP.

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
        )

Atributy

Izolovaný model pracovního procesu i model v procesu používají HttpTriggerAttribute k definování vazby triggeru. Skript jazyka C# místo toho používá konfigurační soubor function.json, jak je popsáno v průvodci skriptováním jazyka C#.

V aplikacích funkcí izolovaného HttpTriggerAttribute modelu pracovních procesů podporují následující parametry:

Parametry Popis
AuthLevel Určuje, jaké klíče, pokud existují, musí být na požadavku přítomny, aby bylo možné vyvolat funkci. Podporované hodnoty najdete v tématu Úroveň autorizace.
Metody Pole metod HTTP, na které funkce reaguje. Pokud není zadáno, funkce odpoví na všechny metody HTTP. Viz přizpůsobení koncového bodu HTTP.
Trasa Definuje šablonu trasy, která určuje, na které adresy URL požadavků vaše funkce reaguje. Výchozí hodnota, pokud není k dispozici <functionname>žádná je . Další informace najdete v tématu Přizpůsobení koncového bodu HTTP.

Dekoratéry

Platí pouze pro programovací model Pythonu v2.

Pro funkce Pythonu v2 definované pomocí dekorátoru jsou v dekorátoru route definovány následující vlastnosti triggeru, který přidává vazbu HttpTrigger a HttpOutput:

Vlastnost Popis
route Směrování pro koncový bod HTTP. Pokud žádný, nastaví se na název funkce, pokud je k dispozici nebo uživatelem definovaný název funkce Pythonu.
trigger_arg_name Název argumentu pro HttpRequest. Výchozí hodnota je req.
binding_arg_name Název argumentu pro HttpResponse. Výchozí hodnota je $return.
methods Řazená kolekce metod HTTP, na které funkce reaguje.
auth_level Určuje, jaké klíče, pokud existují, musí být na požadavku přítomny, aby bylo možné vyvolat funkci.

Informace o funkcích Pythonu definovaných pomocí function.json najdete v části Konfigurace .

Poznámky

V knihovně modulu runtime funkcí Java použijte poznámku HttpTrigger, která podporuje následující nastavení:

Konfigurace

Platí pouze pro programovací model Pythonu v1.

Následující tabulka vysvětluje vlastnosti, které můžete nastavit u objektu předaného options metodě app.http() .

Vlastnost Popis
authLevel Určuje, jaké klíče, pokud existují, musí být na požadavku přítomny, aby bylo možné vyvolat funkci. Podporované hodnoty najdete v tématu Úroveň autorizace.
metody Pole metod HTTP, na které funkce reaguje. Pokud není zadáno, funkce odpoví na všechny metody HTTP. Viz přizpůsobení koncového bodu HTTP.
cesta Definuje šablonu trasy, která určuje, na které adresy URL požadavků vaše funkce reaguje. Výchozí hodnota, pokud není k dispozici <functionname>žádná je . Další informace najdete v tématu Přizpůsobení koncového bodu HTTP.

Následující tabulka vysvětluje vlastnosti konfigurace triggeru, které jste nastavili v souboru function.json , které se liší podle verze modulu runtime.

Následující tabulka vysvětluje vlastnosti konfigurace vazby, které jste nastavili v souboru function.json .

vlastnost function.json Popis
type Povinné – musí být nastaveno na httpTriggerhodnotu .
direction Povinné – musí být nastaveno na inhodnotu .
Jméno Povinný argument – název proměnné použité v kódu funkce pro text požadavku nebo požadavku.
authLevel Určuje, jaké klíče, pokud existují, musí být na požadavku přítomny, aby bylo možné vyvolat funkci. Podporované hodnoty najdete v tématu Úroveň autorizace.
metody Pole metod HTTP, na které funkce reaguje. Pokud není zadáno, funkce odpoví na všechny metody HTTP. Viz přizpůsobení koncového bodu HTTP.
cesta Definuje šablonu trasy, která určuje, na které adresy URL požadavků vaše funkce reaguje. Výchozí hodnota, pokud není k dispozici <functionname>žádná je . Další informace najdete v tématu Přizpůsobení koncového bodu HTTP.

Využití

Tato část podrobně popisuje, jak nakonfigurovat vazbu funkce triggeru HTTP.

Poznámka HttpTrigger by se měla použít na parametr metody jednoho z následujících typů:

  • HttpRequestMessage<T>.
  • Všechny nativní typy Javy, jako je int, String, byte[].
  • Hodnoty s možnou hodnotou null pomocí volitelného.
  • Libovolný typ prostého objektu Java (POJO).

Datová část

Vstupní typ triggeru je deklarován jako jeden z následujících typů:

Typ Popis
HttpRequest Použití tohoto typu vyžaduje, aby byla aplikace nakonfigurovaná s integrací ASP.NET Core v izolovaném prostředí .NET.
Tím získáte úplný přístup k objektu požadavku a celkovému httpContextu.
HttpRequestData Projekce objektu požadavku.
Vlastní typ Když je text požadavku JSON, modul runtime se ho pokusí analyzovat a nastavit vlastnosti objektu.

Pokud je aktivační parametr typu HttpRequestData nebo HttpRequest, vlastní typy mohou být vázány také na jiné parametry pomocí Microsoft.Azure.Functions.Worker.Http.FromBodyAttribute. Použití tohoto atributu vyžaduje Microsoft.Azure.Functions.Worker.Extensions.Http verzi 3.1.0 nebo novější. Toto je jiný typ než podobný atribut v Microsoft.AspNetCore.Mvc. Při použití integrace ASP.NET Core potřebujete plně kvalifikovaný odkaz nebo using příkaz. Tento příklad ukazuje, jak pomocí atributu získat pouze základní obsah a přitom mít přístup k úplnému HttpRequestpoužití integrace ASP.NET Core:

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

Přizpůsobení koncového bodu HTTP

Ve výchozím nastavení při vytváření funkce pro trigger HTTP je funkce adresovatelná pomocí trasy formuláře:

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

Tuto trasu můžete přizpůsobit pomocí volitelné route vlastnosti vstupní vazby triggeru HTTP. S parametry můžete použít libovolné omezení směrování webového rozhraní API.

Následující kód funkce přijímá dva parametry category a id v trase a zapíše odpověď pomocí obou parametrů.

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

Parametry trasy se definují pomocí route nastavení poznámky HttpTrigger . Následující kód funkce přijímá dva parametry category a id v trase a zapíše odpověď pomocí obou parametrů.

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

Například následující kód TypeScript definuje route vlastnost triggeru HTTP se dvěma parametry category a id. Příklad načte parametry z požadavku a vrátí jejich hodnoty v odpovědi.

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

Například následující javascriptový kód definuje route vlastnost triggeru HTTP se dvěma parametry category a id. Příklad načte parametry z požadavku a vrátí jejich hodnoty v odpovědi.

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

Následující kód například definuje route vlastnost triggeru HTTP se dvěma parametry category a id:

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

Parametry trasy deklarované v souboru function.json jsou přístupné jako vlastnost objektu $Request.Params .

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

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

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

Kontext spuštění funkce je zpřístupněn prostřednictvím parametru deklarovaného jako func.HttpRequest. Tato instance umožňuje funkci přistupovat k parametrům směrování dat, hodnotám řetězce dotazu a metodám, které umožňují vrátit odpovědi HTTP.

Po definování jsou parametry trasy pro funkci k dispozici voláním route_params metody.

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)

Pomocí této konfigurace je teď funkce adresovatelná s následující trasou místo původní trasy.

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

Tato konfigurace umožňuje kódu funkce podporovat dva parametry v adrese, kategorii a ID. Další informace o tom, jak se parametry trasy tokenizují v adrese URL, najdete v tématu Směrování v ASP.NET Core.

Ve výchozím nastavení mají všechny trasy funkcí předponu api. Předponu můžete také přizpůsobit nebo odebrat pomocí extensions.http.routePrefix vlastnosti v souboru host.json . Následující příklad odebere předponu api trasy pomocí prázdného řetězce pro předponu v host.json souboru.

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

Použití parametrů trasy

Parametry trasy, které definovaly vzor funkce route , jsou k dispozici pro každou vazbu. Pokud máte například definovanou trasu, jako "route": "products/{id}" je vazba úložiště tabulek, může použít hodnotu {id} parametru v konfiguraci vazby.

Následující konfigurace ukazuje, jak {id} je parametr předán vazbě 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}"
}

Když použijete parametry trasy, invoke_URL_template automaticky se pro vaši funkci vytvoří. Vaši klienti můžou pomocí šablony URL porozumět parametrům, které potřebují k předání adresy URL při volání funkce pomocí její adresy URL. Na webu Azure Portal přejděte na některou z funkcí aktivovaných protokolem HTTP a vyberte Získat adresu URL funkce.

K rozhraním API Azure Resource Manageru invoke_URL_template pro funkce List functions nebo Get Functions můžete přistupovat prostřednictvím kódu programu.

Streamy HTTP

V aplikacích funkcí Node.js v4 teď můžete streamovat požadavky na koncový bod HTTP a odpovědi na ně. Další informace najdete v tématu Streamy HTTP.

Streamy HTTP

Podpora datových proudů HTTP v Pythonu umožňuje přijímat a vracet data z koncových bodů HTTP pomocí rozhraní API požadavků FastAPI a odpovědí povolených ve vašich funkcích. Tato rozhraní API umožňují hostiteli zpracovávat data ve zprávách HTTP jako bloky, aniž by museli číst celou zprávu do paměti. Další informace najdete v tématu Streamy HTTP v Pythonu.

Důležité

Podpora datových proudů HTTP pro Python je aktuálně ve verzi Preview a podporuje se pouze pro programovací model Pythonu v2.

Práce s identitami klientů

Pokud vaše aplikace funkcí používá ověřování nebo autorizaci služby App Service, můžete z kódu zobrazit informace o ověřených klientech. Tyto informace jsou k dispozici jako hlavičky požadavků vložené platformou.

Tyto informace si také můžete přečíst z dat vazby.

Poznámka:

Přístup k ověřeným informacím o klientovi je aktuálně k dispozici pouze pro jazyky .NET. Nepodporuje se ani ve verzi 1.x modulu runtime Functions.

Informace týkající se ověřených klientů jsou k dispozici jako ClaimsPrincipal, které jsou k dispozici jako součást kontextu požadavku, jak je znázorněno v následujícím příkladu:

Ověřený uživatel je k dispozici prostřednictvím hlaviček HTTP.

Ověřený uživatel je k dispozici prostřednictvím hlaviček HTTP.

Úroveň autorizace

Úroveň autorizace je řetězcová hodnota, která označuje typ autorizačního klíče , který je nutný pro přístup ke koncovému bodu funkce. Pro funkci aktivovanou protokolem HTTP může mít úroveň autorizace jednu z následujících hodnot:

Hodnota úrovně Popis
anonymní Není vyžadován žádný přístupový klíč.
funkce Pro přístup ke koncovému bodu se vyžaduje klíč specifický pro funkci.
Admin Pro přístup ke koncovému bodu se vyžaduje hlavní klíč.

Pokud úroveň není explicitně nastavená, autorizační nastavení se nastaví na function úroveň.

Pokud úroveň není explicitně nastavená, výchozí autorizace závisí na verzi modelu Node.js:

Ve výchozím nastavení se autorizace nastaví na anonymous úroveň.

Přístupové klávesy funkce

Funkce umožňují používat přístupové klíče, které znesnadní přístup ke koncovým bodům funkce. Pokud není úroveň autorizace pro funkci aktivovanou protokolem HTTP nastavená na anonymous, požadavky musí v požadavku obsahovat přístupový klíč. Další informace najdete v tématu Práce s přístupovými klíči ve službě Azure Functions.

Autorizace přístupového klíče

Většina šablon triggerů HTTP vyžaduje v požadavku přístupový klíč. Váš požadavek HTTP tedy obvykle vypadá jako následující adresa URL:

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

Klíč lze zahrnout do proměnné řetězce dotazu s názvem code, jak jsme zmínili dříve. Může být také součástí hlavičky x-functions-key HTTP. Hodnota klíče může být libovolný klíč funkce definovaný pro funkci nebo jakýkoli klíč hostitele.

Můžete povolit anonymní požadavky, které nevyžadují klíče. Můžete také vyžadovat použití hlavního klíče. Výchozí úroveň autorizace změníte pomocí authLevel vlastnosti ve formátu JSON vazby.

Poznámka:

Při místním spouštění funkcí je autorizace zakázaná bez ohledu na zadané nastavení úrovně autorizace. Po publikování do Azure authLevel se vynutí nastavení ve vašem triggeru. Klíče se stále vyžadují při místním spuštění v kontejneru.

Webhooky

Poznámka:

Režim Webhooku je k dispozici pouze pro modul runtime Služby Functions verze 1.x. Tato změna byla provedena kvůli zlepšení výkonu triggerů HTTP ve verzi 2.x a vyšší.

Ve verzi 1.x šablony webhooku poskytují další ověření datových částí webhooku. Ve verzi 2.x a vyšší funguje základní trigger HTTP a doporučuje se pro webhooky.

Typ webhooku

Vlastnost webHookType vazby označuje typ, pokud webhook podporuje funkci, která také určuje podporovanou datovou část. Typ webhooku může být jedna z následujících hodnot:

Hodnota typu Popis
genericJson Koncový bod webhooku pro obecné účely bez logiky pro konkrétního poskytovatele Toto nastavení omezuje požadavky jenom na ty, kteří používají HTTP POST a s typem application/json obsahu.
github Funkce reaguje na webhooky GitHubu. Nepoužívejte authLevel vlastnost s webhooky GitHubu.
slack Funkce reaguje na webhooky Slack. Nepoužívejte authLevel vlastnost s webhooky Slack.

Při nastavování webHookType vlastnosti také nenastavujte methods vlastnost u vazby.

Webhooky GitHubu

Pokud chcete reagovat na webhooky GitHubu, nejprve vytvořte funkci pomocí triggeru HTTP a nastavte vlastnost webHookType na github. Potom zkopírujte jeho adresu URL a klíč rozhraní API na stránku Přidat webhook úložiště GitHub.

Snímek obrazovky, který ukazuje, jak přidat webhook pro vaši funkci

Slack webhooks

Webhook Slack pro vás vygeneruje token místo toho, abyste ho mohli zadat, takže musíte nakonfigurovat klíč specifický pro funkci s tokenem ze Slacku. Viz Autorizační klíče.

Webhooky a klíče

Autorizaci webhooku zpracovává komponenta příjemce webhooku, část triggeru HTTP a mechanismus se liší podle typu webhooku. Každý mechanismus spoléhá na klíč. Ve výchozím nastavení se používá klíč funkce s názvem "default". Pokud chcete použít jiný klíč, nakonfigurujte zprostředkovatele webhooku tak, aby odeslal název klíče s požadavkem jedním z následujících způsobů:

  • Řetězec dotazu: Zprostředkovatel předá název klíče v parametru clientid řetězce dotazu, například https://<APP_NAME>.azurewebsites.net/api/<FUNCTION_NAME>?clientid=<KEY_NAME>.
  • Hlavička požadavku: Zprostředkovatel předá název klíče v x-functions-clientid hlavičce.

Typy obsahu

Předání binárních dat a dat formuláře do funkce jiného typu než C# vyžaduje, abyste použili odpovídající hlavičku typu obsahu. Mezi podporované typy obsahu patří octet-stream binární data a typy s více částmi.

Známé problémy

V jiných funkcích než C# mají požadavky odeslané s typem image/jpeg obsahu za následek hodnotu předanou string funkci. V takových případech můžete hodnotu ručně převést string na bajtové pole pro přístup k nezpracovaným binárním datům.

Omezení

Délka požadavků HTTP je omezená na 100 MB (104 857 600 bajtů) a délka adresy URL je omezená na 4 kB (4 096 bajtů). Tato omezení jsou určena httpRuntime elementem souboru Web.config modulu runtime.

Pokud se funkce, která používá trigger HTTP, nedokončí do 230 sekund, vyprší časový limit služby Azure Load Balancer a vrátí chybu HTTP 502. Funkce bude dál spuštěná, ale nebude moct vrátit odpověď HTTP. U dlouhotrvajících funkcí doporučujeme postupovat podle asynchronních vzorů a vrátit umístění, ve kterém můžete otestovat stav požadavku příkazem ping. Informace o tom, jak dlouho může funkce běžet, najdete v tématu Škálování a hostování – plán Consumption.

Další kroky