Azure Functions HTTP-eseményindító

  • Cikk

A HTTP-eseményindítóval HTTP-kéréssel hívhat meg függvényt. HTTP-eseményindítóval kiszolgáló nélküli API-kat hozhat létre, és válaszolhat a webhookokra.

A HTTP által aktivált függvény alapértelmezett visszatérési értéke a következő:

  • HTTP 204 No Content üres törzstel a Functions 2.x és újabb verzióiban
  • HTTP 200 OK üres törzstel a Functions 1.x-ben

A HTTP-válasz módosításához konfiguráljon egy kimeneti kötést.

A HTTP-kötésekkel kapcsolatos további információkért tekintse meg az áttekintést és a kimeneti kötésre vonatkozó referenciát.

Tipp.

Ha HTTP- vagy WebHook-kötéseket szeretne használni, tervezze meg, hogy elkerülje a portkimerülést, amelyet a nem megfelelő példányosítás HttpClientokozhat. További információ: Kapcsolatok kezelése az Azure Functionsben.

Fontos

Ez a cikk lapokat használ a Node.js programozási modell több verziójának támogatásához. A v4-modell általánosan elérhető, és úgy lett kialakítva, hogy rugalmasabb és intuitívabb felhasználói élményt nyújtson JavaScript- és TypeScript-fejlesztők számára. A v4-modell működésével kapcsolatos további információkért tekintse meg az Azure Functions Node.js fejlesztői útmutatóját. A v3 és a v4 közötti különbségekről a migrálási útmutatóban olvashat bővebben.

Az Azure Functions két Python-programozási modellt támogat. A kötések definiálásának módja a választott programozási modelltől függ.

A Python v2 programozási modell lehetővé teszi, hogy a kötéseket dekorátorokkal definiálja közvetlenül a Python-függvénykódban. További információt a Python fejlesztői útmutatójában talál.

Ez a cikk mindkét programozási modellt támogatja.

Példa

A C#-függvények a következő C#-módok egyikével hozhatók létre:

  • Izolált feldolgozómodell: Lefordított C# függvény, amely a futtatókörnyezettől elkülönített feldolgozói folyamatban fut. Izolált feldolgozói folyamat szükséges az LTS- és nem LTS-verziókon futó C#-függvények támogatásához .NET és .NET-keretrendszer. Az izolált feldolgozói folyamatfüggvények bővítményei névtereket használnak Microsoft.Azure.Functions.Worker.Extensions.* .
  • Folyamaton belüli modell: Lefordított C# függvény, amely ugyanabban a folyamatban fut, mint a Functions-futtatókörnyezet. A modell egy változatában a Functions C#-szkriptekkel futtatható, amely elsősorban a C#-portál szerkesztéséhez támogatott. A folyamaton belüli függvények bővítményei névtereket használnak Microsoft.Azure.WebJobs.Extensions.* .

Fontos

A folyamaton belüli modell támogatása 2026. november 10-én megszűnik. Erősen javasoljuk, hogy az alkalmazásokat az elkülönített feldolgozói modellbe migrálja a teljes támogatás érdekében.

A jelen cikkben szereplő kód alapértelmezés szerint a .NET Core szintaxis, amelyet a Functions 2.x és újabb verziójában használnak. Az 1.x szintaxissal kapcsolatos információkért tekintse meg az 1.x függvénysablonokat.

Az alábbi példa egy HTTP-eseményindítót mutat be, amely egy "hello, world" választ ad vissza IActionResultként, ASP.NET Core-integrációt használva a .NET Izolálva:

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

Az alábbi példa egy HTTP-eseményindítót mutat be, amely egy "hello world" választ ad vissza HttpResponseData-objektumként:

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

Ez a szakasz a következő példákat tartalmazza:

Az alábbi példák a HTTP-eseményindító kötését mutatják be.

Paraméter olvasása a lekérdezési sztringből

Ez a példa beolvassa a lekérdezési sztringből a paramétert id, és az ügyfélnek visszaadott JSON-dokumentumot készít tartalomtípussal 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();
    }
}

Törzs olvasása POST-kérelemből

Ez a példa beolvassa a POST-kérés törzsét egy Stringtartalomtípusú application/jsonJSON-dokumentum létrehozásához, amelyet az ügyfélnek adott vissza.

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

Paraméter beolvasása útvonalról

Ez a példa beolvassa a kötelező paramétert idés egy opcionális paramétert name az útvonal útvonalából, és felhasználja őket az ügyfélnek visszaadott JSON-dokumentum létrehozásához tartalomtípussal application/json.

@FunctionName("TriggerStringRoute")
public HttpResponseMessage run(
        @HttpTrigger(name = "req", 
            methods = {HttpMethod.GET}, 
            authLevel = AuthorizationLevel.ANONYMOUS,
            route = "trigger/{id}/{name=EMPTY}") // name is optional and defaults to EMPTY
        HttpRequestMessage<Optional<String>> request,
        @BindingName("id") String id,
        @BindingName("name") String name,
        final ExecutionContext context) {

    // Item list
    context.getLogger().info("Route parameters are: " + id);

    // Convert and display
    if (id == null) {
        return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
                        .body("Document not found.")
                        .build();
    } 
    else {
        // return JSON from to the client
        // Generate document
        final String jsonDocument = "{\"id\":\"" + id + "\", " + 
                                        "\"description\": \"" + name + "\"}";
        return request.createResponseBuilder(HttpStatus.OK)
                        .header("Content-Type", "application/json")
                        .body(jsonDocument)
                        .build();
    }
}

POJO-törzs olvasása POST-kérelemből

Az osztály kódja ToDoItem az alábbi példában található:


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

Ez a példa egy POST-kérelem törzsét olvassa be. A kérelem törzse automatikusan szériamentessé válik egy ToDoItem objektumban, és a rendszer visszaadja az ügyfélnek tartalomtípussal application/json. A ToDoItem paramétert a Functions-futtatókörnyezet szerializálja, mivel az body az HttpMessageResponse.Builder osztály tulajdonságához van rendelve.

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

Az alábbi példa egy HTTP-eseményindító TypeScript-függvényét mutatja be. A függvény egy paramétert name keres a lekérdezési sztringben vagy a HTTP-kérés törzsében.

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

Az alábbi példa egy HTTP-eseményindító JavaScript-függvényt mutat be. A függvény egy paramétert name keres a lekérdezési sztringben vagy a HTTP-kérés törzsében.

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

Az alábbi példa egy eseményindító kötését mutatja be egy function.json fájlban és egy PowerShell-függvényben. A függvény egy paramétert name keres a lekérdezési sztringben vagy a HTTP-kérés törzsében.

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

Az alábbi példa egy triggerkötést és egy Python-függvényt mutat be, amely a kötést használja. A függvény egy paramétert name keres a lekérdezési sztringben vagy a HTTP-kérés törzsében. A példa attól függ, hogy a v1 vagy v2 Python programozási modellt használja-e.

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
        )

Attribútumok

A folyamaton belüli és az izolált feldolgozói folyamat C#-kódtárai is ezt HttpTriggerAttribute használják az eseményindító kötésének meghatározásához. A C#-szkript ehelyett egy function.json konfigurációs fájlt használ a C#-szkriptelési útmutatóban leírtak szerint.

Izolált feldolgozói folyamatfüggvény-alkalmazásokban a HttpTriggerAttribute következő paraméterek támogatottak:

Paraméterek Leírás
Hitelesítési szint Meghatározza, hogy a függvény meghívásához milyen kulcsoknak kell szerepelnie a kérelemben, ha vannak ilyenek. A támogatott értékekről lásd : Engedélyezési szint.
Módszerek Azon HTTP-metódusok tömbje, amelyekre a függvény válaszol. Ha nincs megadva, a függvény minden HTTP-metódusra válaszol. Lásd a HTTP-végpont testreszabását.
Útvonal Meghatározza az útvonalsablont, amely meghatározza, hogy a függvény melyik kérelem URL-címére válaszol. Az alapértelmezett érték, ha nincs megadva <functionname>. További információ: A HTTP-végpont testreszabása.

Dekorátorok

Csak a Python v2 programozási modellre vonatkozik.

A dekoratőrrel definiált Python v2-függvények esetében az eseményindító alábbi tulajdonságai vannak definiálva a route dekorátorban, amely httpTrigger- és HttpOutput-kötést ad hozzá:

Tulajdonság Leírás
route A HTTP-végpont útvonala. Ha nincs, akkor a függvény neve lesz beállítva, ha jelen van vagy felhasználó által definiált Python-függvény neve.
trigger_arg_name A HttpRequest argumentumneve. Az alapértelmezett érték a "req".
binding_arg_name A HttpResponse argumentumneve. Az alapértelmezett érték a "$return".
methods Azoknak a HTTP-metódusoknak a száma, amelyekre a függvény válaszol.
auth_level Meghatározza, hogy a függvény meghívásához milyen kulcsoknak kell szerepelnie a kérelemben, ha vannak ilyenek.

A function.json használatával definiált Python-függvények esetében lásd a Konfiguráció szakaszt.

Jegyzetek

A Java-függvények futtatókörnyezeti kódtárában használja a HttpTrigger jegyzetet, amely a következő beállításokat támogatja:

Konfiguráció

Csak a Python v1 programozási modellre vonatkozik.

Az alábbi táblázat a metódusnak app.http() átadott objektumon options beállítható tulajdonságokat ismerteti.

Tulajdonság Leírás
authLevel Meghatározza, hogy a függvény meghívásához milyen kulcsoknak kell szerepelnie a kérelemben, ha vannak ilyenek. A támogatott értékekről lásd : Engedélyezési szint.
Módszerek Azon HTTP-metódusok tömbje, amelyekre a függvény válaszol. Ha nincs megadva, a függvény minden HTTP-metódusra válaszol. Lásd a HTTP-végpont testreszabását.
Útvonal Meghatározza az útvonalsablont, amely meghatározza, hogy a függvény melyik kérelem URL-címére válaszol. Az alapértelmezett érték, ha nincs megadva <functionname>. További információ: A HTTP-végpont testreszabása.

Az alábbi táblázat a function.json fájlban beállított triggerkonfigurációs tulajdonságokat ismerteti, amelyek futásidejű verziónként eltérőek.

Az alábbi táblázat a function.json fájlban beállított kötéskonfigurációs tulajdonságokat ismerteti.

function.json tulajdonság Leírás
type Kötelező – a beállításnak httpTriggera következőnek kell lennie: .
direction Kötelező – a beállításnak ina következőnek kell lennie: .
név Kötelező – a kérelem vagy a kérelem törzsének függvénykódjában használt változónév.
authLevel Meghatározza, hogy a függvény meghívásához milyen kulcsoknak kell szerepelnie a kérelemben, ha vannak ilyenek. A támogatott értékekről lásd : Engedélyezési szint.
Módszerek Azon HTTP-metódusok tömbje, amelyekre a függvény válaszol. Ha nincs megadva, a függvény minden HTTP-metódusra válaszol. Lásd a HTTP-végpont testreszabását.
Útvonal Meghatározza az útvonalsablont, amely meghatározza, hogy a függvény melyik kérelem URL-címére válaszol. Az alapértelmezett érték, ha nincs megadva <functionname>. További információ: A HTTP-végpont testreszabása.

Használat

Ez a szakasz a HTTP-eseményindító függvény kötésének konfigurálását ismerteti.

A HttpTrigger-széljegyzetet az alábbi típusok egyikének metódusparaméterére kell alkalmazni:

  • HttpRequestMessage<T>.
  • Bármilyen natív Java-típus, például int, String, byte[].
  • Null értékű értékek opcionális használatával.
  • Bármely egyszerű régi Java-objektumtípus (POJO).

Hasznos adat

Az eseményindító bemeneti típusa a következő típusok egyikeként van deklarálva:

Típus Leírás
HttpRequest Ennek a típusnak a használatához az alkalmazás ASP.NET Core-integrációval van konfigurálva a .NET Izolált szolgáltatásban.
Ez teljes hozzáférést biztosít a kérelemobjektumhoz és az általános HttpContexthez.
HttpRequestData A kérelemobjektum vetülete.
Egyéni típus Ha a kérelem törzse JSON, a futtatókörnyezet megpróbálja elemezni az objektumtulajdonságok beállításához.

Ha az eseményindító paraméter egy HttpRequestDataHttpRequest, az egyéni típusok további paraméterekhez is köthetők a következő használatával Microsoft.Azure.Functions.Worker.Http.FromBodyAttribute: . Az attribútum használatához a 3.1.0-s vagy újabb verzió szükséges.Microsoft.Azure.Functions.Worker.Extensions.Http Vegye figyelembe, hogy ez egy másik típus, mint a hasonló attribútum, Microsoft.AspNetCore.Mvcés ASP.NET Core-integráció használatakor teljes mértékben minősített hivatkozásra vagy using utasításra lesz szüksége. Az alábbi példa bemutatja, hogyan használhatja az attribútumot arra, hogy csak a törzs tartalmát szerezze be, miközben továbbra is hozzáfér a teljes HttpRequesttartalomhoz a ASP.NET Core-integráció használatával:

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

A HTTP-végpont testreszabása

Ha http-eseményindítóhoz hoz létre függvényt, a függvény alapértelmezés szerint az űrlap útvonalával címezhető:

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

Ezt az útvonalat a HTTP-eseményindító bemeneti kötésének opcionális route tulajdonságával szabhatja testre. A paraméterekkel bármilyen webes API-útvonalkorlátozást használhat.

Az alábbi függvénykód két paramétert categoryid fogad el az útvonalon, és mindkét paraméter használatával választ ír.

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

Az útvonalparaméterek a route széljegyzet beállításával HttpTrigger vannak definiálva. Az alábbi függvénykód két paramétert categoryid fogad el az útvonalon, és mindkét paraméter használatával választ ír.

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

A következő TypeScript-kód például egy HTTP-eseményindító tulajdonságát definiálja route két paraméterrel és categoryid. A példa beolvassa a paramétereket a kérelemből, és visszaadja az értékeiket a válaszban.

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

A következő JavaScript-kód például egy HTTP-eseményindító tulajdonságát definiálja route két paraméterrel és categoryid. A példa beolvassa a paramétereket a kérelemből, és visszaadja az értékeiket a válaszban.

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

A következő kód például egy HTTP-eseményindító tulajdonságát definiálja route két paraméterrel, category és ida következőt:

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

A function.json fájlban deklarált útvonalparaméterek az $Request.Params objektum tulajdonságaként érhetők el.

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

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

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

A függvényvégrehajtási környezet egy deklarált func.HttpRequestparaméteren keresztül jelenik meg. Ez a példány lehetővé teszi, hogy egy függvény hozzáférjen az adatútvonal paramétereihez, a lekérdezési sztring értékeihez és a HTTP-válaszok visszaadásához szükséges módszerekhez.

A definiált útvonalparaméterek a metódus meghívásával érhetők el a route_params függvény számára.

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)

Ezzel a konfigurációval a függvény mostantól az eredeti útvonal helyett a következő útvonallal kezelhető.

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

Ez a konfiguráció lehetővé teszi, hogy a függvénykód két paramétert támogatjon a címben, a kategóriában és az azonosítóban. Az útvonalparaméterek URL-címben való tokenizálásáról további információt az Útválasztás a ASP.NET Core-ban című témakörben talál.

Alapértelmezés szerint az összes függvényútvonal api-val van előtaggal el van kapcsolva. Az előtagot a host.json fájl tulajdonságával extensions.http.routePrefixis testre szabhatja vagy eltávolíthatja . Az alábbi példa egy üres sztring használatával távolítja el az api-útvonal előtagot a host.json fájlban lévő előtaghoz.

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

Útvonalparaméterek használata

A függvény mintáját route definiáló útvonalparaméterek minden kötéshez elérhetők. Ha például egy útvonal definiálva "route": "products/{id}" van, akkor a táblatároló-kötés a paraméter értékét használhatja {id} a kötéskonfigurációban.

Az alábbi konfiguráció bemutatja, hogy a {id} paraméter hogyan lesz átadva a kötésnek 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}"
}

Útvonalparaméterek invoke_URL_template használatakor a függvény automatikusan létrejön. Az ügyfelek az URL-sablonnal megismerhetik azokat a paramétereket, amelyeket át kell adniuk az URL-címben a függvény URL-címével való meghívásakor. Keresse meg az egyik HTTP-aktivált függvényt az Azure Portalon, és válassza a Függvény URL-címének lekérése lehetőséget.

A listafüggvényekhez vagy a invoke_URL_template Függvény lekéréséhez használható Azure Resource Manager API-k segítségével programozott módon is elérheti azokat.

HTTP-streamek (előzetes verzió)

Mostantól a HTTP-végpontra irányuló kéréseket és válaszokat streamelheti Node.js v4-függvényalkalmazásokban. További információ: HTTP-streamek.

Ügyfélidentitások használata

Ha a függvényalkalmazás App Service-hitelesítést/engedélyezést használ, megtekintheti a hitelesített ügyfelek adatait a kódból. Ezek az információk a platform által beszúrt kérelemfejlécekként érhetők el.

Ezeket az információkat a kötési adatokból is elolvashatja. Ez a képesség csak a Functions-futtatókörnyezet számára érhető el a 2.x és újabb verziókban. Jelenleg csak .NET-nyelvekhez érhető el.

A hitelesített ügyfelekre vonatkozó információk Jogcímprincipalként érhetők el, amely a kérési környezet részeként érhető el az alábbi példában látható módon:

A hitelesített felhasználó HTTP-fejléceken keresztül érhető el.

A hitelesített felhasználó HTTP-fejléceken keresztül érhető el.

Engedélyszint

Az engedélyezési szint egy sztringérték, amely azt jelzi, hogy milyen típusú engedélyezési kulcs szükséges a függvényvégpont eléréséhez. HTTP-aktivált függvény esetén az engedélyezési szint az alábbi értékek egyike lehet:

Szintérték Leírás
Névtelen Nincs szükség API-kulcsra. Ez az alapértelmezett érték, ha egy szint nincs konkrétan beállítva.
Funkció Függvényspecifikus API-kulcsra van szükség.
Admin A főkulcs megadása kötelező.
Szintérték Leírás
Névtelen Nincs szükség API-kulcsra.
Funkció Függvényspecifikus API-kulcsra van szükség. Ez az alapértelmezett érték, ha egy szint nincs konkrétan beállítva.
Admin A főkulcs megadása kötelező.

Függvényelérési kulcsok

A Functions segítségével kulcsokkal megnehezítheti a HTTP-függvényvégpontok elérését a fejlesztés során. Ha egy HTTP-aktivált függvény HTTP-hozzáférési szintje nincs beállítva anonymous, a kéréseknek tartalmazniuk kell egy API-hozzáférési kulcsot a kérelemben.

Bár a kulcsok alapértelmezett biztonsági mechanizmust biztosítanak, érdemes lehet megfontolni a HTTP-végpontok éles környezetben történő biztonságossá tételének egyéb lehetőségeit. Például nem ajánlott nyilvános alkalmazásokban megosztani a megosztott titkos kódokat. Ha a függvény nyilvános ügyfélről van meghívva, érdemes megfontolnia egy másik biztonsági mechanizmus implementálását. További információ: HTTP-végpont biztonságossá tétele éles környezetben.

A függvénykulcs értékeinek megújításakor manuálisan újra kell terjesztenie a frissített kulcsértékeket az összes olyan ügyfélnek, amely meghívja a függvényt.

Engedélyezési hatókörök (függvényszintű)

A függvényszintű kulcsoknak két hozzáférési hatóköre van:

  • Függvény: Ezek a kulcsok csak azokra a függvényekre vonatkoznak, amelyek alatt definiálva vannak. API-kulcsként való használat esetén ezek csak a függvényhez való hozzáférést teszik lehetővé.

  • Gazdagép: A gazdagép hatókörével rendelkező kulcsok a függvényalkalmazás összes függvényének eléréséhez használhatók. API-kulcsként való használat esetén ezek lehetővé teszik a függvényalkalmazás bármely függvényéhez való hozzáférést.

Az egyes kulcsok neve hivatkozásként van elnevezve, és a függvény és a gazdagép szintjén van egy alapértelmezett kulcs (az "alapértelmezett" név). A függvénykulcsok elsőbbséget élveznek a gazdagépkulcsokkal szemben. Ha két kulcs azonos néven van definiálva, a függvénykulcsot mindig a rendszer használja.

Főkulcs (rendszergazdai szintű)

Minden függvényalkalmazáshoz tartozik egy rendszergazdai szintű gazdagépkulcs is _master. Amellett, hogy gazdagépszintű hozzáférést biztosít az alkalmazás összes függvényéhez, a főkulcs rendszergazdai hozzáférést is biztosít a futtatókörnyezeti REST API-khoz. Ez a kulcs nem vonható vissza. A hozzáférési szint adminbeállításakor a kéréseknek a főkulcsot kell használniuk; minden más kulcs hozzáférési hibát eredményez.

Figyelemfelhívás

A főkulcs által megadott függvényalkalmazás emelt szintű engedélyei miatt nem szabad megosztania ezt a kulcsot harmadik felekkel, és nem szabad natív ügyfélalkalmazásokban terjesztenie. A rendszergazdai hozzáférési szint kiválasztásakor körültekintően járjon el.

Kulcsok beszerzése

A kulcsok a függvényalkalmazás részeként vannak tárolva az Azure-ban, és inaktív állapotban vannak titkosítva. A kulcsok megtekintéséhez, újak létrehozásához vagy kulcsok új értékekhez való gördítéséhez keresse meg az egyik HTTP-aktivált függvényt az Azure Portalon, és válassza a Függvénykulcsok lehetőséget.

A gazdagépkulcsokat is kezelheti. Lépjen a függvényalkalmazásra az Azure Portalon, és válassza az Alkalmazáskulcsok lehetőséget.

A függvény- és gazdakulcsokat programozott módon szerezheti be az Azure Resource Manager API-kkal. Vannak API-k a függvénykulcsok és a listagazdakulcsok listázásához, és az üzembehelyezési pontok használatakor az egyenértékű API-k a Listafüggvénykulcsok pont és a Lista gazdagépkulcs-pont.

Az új függvényeket és gazdagépkulcsokat programozott módon is létrehozhatja a függvény titkos kódjának létrehozásával vagy frissítésével, a függvény titkos kód pontjának létrehozásával vagy frissítésével, a gazdagép titkos kódjának létrehozásával vagy frissítésével, valamint a gazdagép titkos kulcsainak API-iinak létrehozásával vagy frissítésével.

A függvény- és gazdagépkulcsok programozott módon törölhetők a Függvénykulcs törlése, a Függvény titkos kódjának törlése, a Gazdagép titkos kódjának törlése és a Gazdagép titkos kulcsának törlése API-k használatával.

Az örökölt kulcskezelési API-k használatával is beszerezheti a függvénykulcsokat, de az Azure Resource Manager API-k használata ajánlott.

API-kulcs engedélyezése

A LEGTÖBB HTTP-eseményindító-sablonhoz API-kulcs szükséges a kérelemben. A HTTP-kérés tehát általában a következő URL-címhez hasonlóan néz ki:

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

A kulcs szerepelhet a fenti módon elnevezett codelekérdezési sztringváltozóban. EGY HTTP-fejlécben x-functions-key is szerepelhet. A kulcs értéke lehet a függvényhez definiált függvénykulcs vagy bármely gazdagépkulcs.

Engedélyezheti a névtelen kéréseket, amelyekhez nincs szükség kulcsokra. A főkulcs használatát is megkövetelheti. Az alapértelmezett engedélyezési szintet a JSON kötésben lévő tulajdonság használatával authLevel módosíthatja. További információ: Trigger – konfiguráció.

Feljegyzés

A függvények helyi futtatásakor az engedélyezés a megadott engedélyezési szinttől függetlenül le van tiltva. Az Azure-ban való közzététel után a rendszer kikényszeríti az authLevel eseményindítóban lévő beállítást. A kulcsok akkor is szükségesek, ha helyileg futnak egy tárolóban.

HTTP-végpont védelme éles környezetben

A függvényvégpontok éles környezetben történő teljes védelméhez érdemes megfontolni az alábbi függvényalkalmazásszintű biztonsági beállítások egyikének implementálását. A függvényalkalmazás-szintű biztonsági módszerek egyikének használatakor a HTTP által aktivált függvény engedélyezési szintjét kell beállítania anonymous.

App Service-hitelesítés/engedélyezés engedélyezése

Az App Service platform lehetővé teszi a Microsoft Entra ID és több külső identitásszolgáltató használatát az ügyfelek hitelesítéséhez. Ezzel a stratégiával egyéni engedélyezési szabályokat implementálhat a függvényekhez, és használhatja a függvénykód felhasználói adatait. További információ: Hitelesítés és engedélyezés a Azure-alkalmazás szolgáltatásban és az ügyfélidentitások használata.

Kérelmek hitelesítése az Azure API Management (APIM) használatával

Az APIM számos API-biztonsági lehetőséget kínál a bejövő kérésekhez. További információ: API Management hitelesítési szabályzatok. Ha az APIM működik, konfigurálhatja a függvényalkalmazást úgy, hogy csak az APIM-példány IP-címéről fogadjon kérelmeket. További információ: IP-címkorlátozások.

A függvényalkalmazás üzembe helyezése külön-külön

Azure-alkalmazás szolgáltatáskörnyezet (A Standard kiadás) dedikált üzemeltetési környezetet biztosít a függvények futtatásához. A Standard kiadás lehetővé teszi egyetlen előtér-átjáró konfigurálását, amellyel minden bejövő kérést hitelesíthet. További információ: Webalkalmazási tűzfal (WAF) konfigurálása az App Service-környezethez.

Webhookok

Feljegyzés

A Webhook mód csak a Functions-futtatókörnyezet 1.x-es verziójához érhető el. Ez a módosítás a HTTP-eseményindítók 2.x-es és újabb verziójában való teljesítményének javítása érdekében történt.

Az 1.x verzióban a webhooksablonok további ellenőrzést biztosítanak a webhook hasznos adataihoz. A 2.x és újabb verzióban az alap HTTP-eseményindító továbbra is működik, és ez a webhookok ajánlott megközelítése.

WebHook típusa

A webHookType kötés tulajdonság azt a típust jelzi, ha a függvény támogatja a webhookot, amely a támogatott hasznos adatokat is meghatározza. A webhook típusa az alábbi értékek egyike lehet:

Típusérték Leírás
genericJson Általános célú webhook-végpont egy adott szolgáltató logikája nélkül. Ez a beállítás csak a HTTP POST-t és a tartalomtípust használó kérelmekre korlátozza a application/json kérelmeket.
github A függvény válaszol a GitHub-webhookokra. Ne használja a tulajdonságot GitHub-webhookokkal authLevel .
slack A függvény válaszol a Slack-webhookokra. Ne használja a tulajdonságot authLevel Slack-webhookokkal.

A tulajdonság beállításakor webHookType ne állítsa be a tulajdonságot methods a kötésre.

GitHub-webhookok

A GitHub-webhookokra való válaszadáshoz először hozzon létre egy HTTP-eseményindítót a függvényhez, és állítsa a webHookType tulajdonságot a következőre github: . Ezután másolja az URL-címet és az API-kulcsot a GitHub-adattár Webhook hozzáadása lapjára.

Képernyőkép a függvény webhook hozzáadásáról.

Slack-webhookok

A Slack webhook egy jogkivonatot hoz létre Önnek ahelyett, hogy megadja volna, ezért konfigurálnia kell egy függvényspecifikus kulcsot a Slack jogkivonatával. Lásd: Engedélyezési kulcsok.

Webhookok és kulcsok

A webhook-engedélyezést a webhook fogadó összetevője kezeli, amely a HTTP-eseményindító része, és a mechanizmus a webhook típusától függően változik. Minden mechanizmus egy kulcsra támaszkodik. Alapértelmezés szerint az "default" nevű függvénykulcsot használja a rendszer. Másik kulcs használatához konfigurálja a webhook-szolgáltatót úgy, hogy a kéréssel együtt küldje el a kulcs nevét az alábbi módok egyikével:

  • Lekérdezési sztring: A szolgáltató átadja a kulcsnevet a lekérdezési sztring clientid paraméterben, például https://<APP_NAME>.azurewebsites.net/api/<FUNCTION_NAME>?clientid=<KEY_NAME>.
  • Kérelem fejléce: A szolgáltató átadja a kulcs nevét a x-functions-clientid fejlécben.

Tartalomtípusok

Ha bináris és űrlapadatokat ad át egy nem C#-függvénynek, a megfelelő tartalomtípusú fejlécet kell használnia. A támogatott tartalomtípusok közé tartoznak octet-stream a bináris adatok és a többrészes típusok.

Ismert problémák

A nem C#-függvényekben a tartalomtípussal image/jpeg küldött kérelmek a string függvénynek átadott értéket eredményezik. Ilyen esetekben manuálisan konvertálhatja az string értéket bájttömbökké a nyers bináris adatok eléréséhez.

Korlátok

A HTTP-kérelem hossza legfeljebb 100 MB (104 857 600 bájt), az URL-cím hossza pedig legfeljebb 4 KB (4096 bájt) lehet. Ezeket a korlátokat a httpRuntime futtatókörnyezet Web.config fájljának eleme határozza meg.

Ha egy HTTP-eseményindítót használó függvény 230 másodpercen belül nem fejeződik be, az Azure Load Balancer időtúllépést jelez, és HTTP 502-hibát ad vissza. A függvény továbbra is fut, de nem tud HTTP-választ visszaadni. Hosszú ideig futó függvények esetén azt javasoljuk, hogy kövesse az aszinkron mintákat, és adjon vissza egy helyet, ahol pingelheti a kérés állapotát. A függvények futási élettartamával kapcsolatos további információkért lásd: Skálázás és üzemeltetés – Használati terv.

Következő lépések