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 pro třídu, na který odkazuje v tomto příkladu ToDoItem :


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

Následující příklad ukazuje vazbu triggeru a funkci Pythonu, která používá vazbu. Funkce hledá name parametr buď v řetězci dotazu, nebo v textu požadavku HTTP. Tento příklad závisí na tom, jestli používáte programovací model v1 nebo v2 Pythonu.

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

Knihovny C# v procesu i izolovaného pracovního 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 HttpTriggerAttribute funkcí izolovaného pracovního procesu 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.
Postupu 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.
Postupu 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ím parametrem HttpRequestDataHttpRequest, mohou být vlastní typy také vázány na další 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ší. Všimněte si, že se jedná o jiný typ než podobný atribut v Microsoft.AspNetCore.Mvca při použití integrace ASP.NET Core budete potřebovat plně kvalifikovaný odkaz nebo using příkaz. Následující 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 trasy rozhraní API pomocí prázdného řetězce pro předponu v souboru host.json .

{
    "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 (Preview)

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.

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. Tato funkce je k dispozici pouze pro modul runtime Služby Functions ve verzi 2.x a vyšší. V současné době je k dispozici pouze pro jazyky .NET.

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í Nevyžaduje se žádný klíč rozhraní API. Toto je výchozí hodnota, pokud není nastavená úroveň.
Funkce Vyžaduje se klíč rozhraní API specifický pro funkci.
Admin Je vyžadován hlavní klíč.
Hodnota úrovně Popis
Anonymní Nevyžaduje se žádný klíč rozhraní API.
Funkce Vyžaduje se klíč rozhraní API specifický pro funkci. Toto je výchozí hodnota, pokud není nastavená úroveň.
Admin Je vyžadován hlavní klíč.

Přístupové klávesy funkce

Funkce umožňují používat klíče, které znesnadní přístup ke koncovým bodům funkce HTTP během vývoje. Pokud není anonymousnastavená úroveň přístupu HTTP u funkce aktivované protokolem HTTP, musí požadavky do požadavku obsahovat přístupový klíč rozhraní API.

Zatímco klíče poskytují výchozí mechanismus zabezpečení, můžete zvážit další možnosti zabezpečení koncového bodu HTTP v produkčním prostředí. Například není vhodné distribuovat sdílený tajný kód ve veřejných aplikacích. Pokud se vaše funkce volá z veřejného klienta, můžete zvážit implementaci jiného mechanismu zabezpečení. Další informace najdete v tématu Zabezpečení koncového bodu HTTP v produkčním prostředí.

Když obnovíte hodnoty klíče funkce, musíte aktualizované hodnoty klíče ručně distribuovat všem klientům, kteří vaši funkci volají.

Obory autorizace (úroveň funkce)

Pro klíče na úrovni funkce existují dva obory přístupu:

  • Funkce: Tyto klíče platí jenom pro konkrétní funkce, pod kterými jsou definované. Pokud se používá jako klíč rozhraní API, umožňují přístup pouze k této funkci.

  • Hostitel: Klíče s oborem hostitele je možné použít pro přístup ke všem funkcím v aplikaci funkcí. Pokud se používá jako klíč rozhraní API, umožňují přístup k libovolné funkci v aplikaci funkcí.

Každý klíč má název pro referenci a na úrovni funkce a hostitele je k dispozici výchozí klíč (s názvem "default"). Klíče funkcí mají přednost před klíči hostitele. Pokud jsou definovány dva klíče se stejným názvem, použije se vždy klíč funkce.

Hlavní klíč (úroveň správce)

Každá aplikace funkcí má také klíč hostitele na úrovni správce s názvem _master. Kromě poskytování přístupu na úrovni hostitele ke všem funkcím v aplikaci poskytuje hlavní klíč také přístup pro správu k rozhraním REST API modulu runtime. Tento klíč nelze odvolat. Když nastavíte úroveň adminpřístupu , požadavky musí používat hlavní klíč; všechny ostatní klíče způsobí selhání přístupu.

Upozornění

Vzhledem ke zvýšeným oprávněním v aplikaci funkcí udělených hlavním klíčem byste tento klíč neměli sdílet s třetími stranami ani ho distribuovat v nativních klientských aplikacích. Při výběru úrovně přístupu správce buďte opatrní.

Získání klíčů

Klíče se ukládají jako součást vaší aplikace funkcí v Azure a šifrují se neaktivní uložená data. Pokud chcete zobrazit klíče, vytvořit nové nebo vrátit klíče k novým hodnotám, přejděte na některou z funkcí aktivovaných protokolem HTTP na webu Azure Portal a vyberte Klíče funkcí.

Můžete také spravovat klíče hostitele. Přejděte do aplikace funkcí na webu Azure Portal a vyberte Klíče aplikace.

Klíče funkcí a hostitelů můžete získat programově pomocí rozhraní API Azure Resource Manageru. K dispozici jsou rozhraní API pro výpis klíčů funkcí a klíče hostitele seznamu a při použití slotů nasazení jsou ekvivalentní rozhraní API Slot klíče funkcí a Slot seznamu klíčů hostitele.

Nové funkce a klíče hostitele můžete také vytvořit programově pomocí tajného kódu funkce Create Or Update, slotu pro vytvoření nebo aktualizaci tajného kódu funkce, vytvoření nebo aktualizace tajného kódu hostitele a rozhraní API pro vytvoření nebo aktualizaci tajného kódu hostitele.

Klíče funkcí a hostitelů lze odstranit programově pomocí rozhraní API pro odstranění tajného klíče funkce, odstranění tajného kódu funkce, odstranění tajného klíče hostitele a rozhraní API pro odstranění tajného kódu hostitele.

K získání klíčů funkcí můžete použít také starší rozhraní API pro správu klíčů, ale místo toho se doporučuje použít rozhraní API Azure Resource Manageru.

Autorizace klíče rozhraní API

Většina šablon triggerů HTTP vyžaduje v požadavku klíč rozhraní API. 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 je uvedeno výše. 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. Další informace najdete v tématu Trigger – konfigurace.

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.

Zabezpečení koncového bodu HTTP v produkčním prostředí

Pokud chcete plně zabezpečit koncové body funkcí v produkčním prostředí, měli byste zvážit implementaci jedné z následujících možností zabezpečení na úrovni aplikace funkcí. Pokud používáte některou z těchto metod zabezpečení na úrovni aplikace funkcí, měli byste nastavit úroveň autorizace funkce aktivovanou protokolem HTTP na anonymoushodnotu .

Povolení ověřování/autorizace služby App Service

Platforma App Service umožňuje k ověřování klientů používat ID Microsoft Entra a několik zprostředkovatelů identity třetích stran. Tuto strategii můžete použít k implementaci vlastních autorizačních pravidel pro vaše funkce a můžete pracovat s informacemi o uživateli z kódu funkce. Další informace najdete v tématu Ověřování a autorizace ve službě Aplikace Azure Service a práce s identitami klientů.

Použití služby Azure API Management (APIM) k ověřování požadavků

APIM poskytuje různé možnosti zabezpečení rozhraní API pro příchozí požadavky. Další informace najdete v tématu Zásady ověřování služby API Management. Pomocí služby APIM můžete nakonfigurovat aplikaci funkcí tak, aby přijímala požadavky pouze z IP adresy vaší instance APIM. Další informace najdete v tématu Omezení IP adres.

Nasazení aplikace funkcí izolovaně

Aplikace Azure Service Environment (ASE) poskytuje vyhrazené hostitelské prostředí, ve kterém můžete spouštět funkce. Služba ASE umožňuje nakonfigurovat jednu front-endovou bránu, kterou můžete použít k ověřování všech příchozích požadavků. Další informace najdete v tématu Konfigurace firewallu webových aplikací (WAF) pro službu App Service Environment.

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

Šablony webhooků ve verzi 1.x 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