Megosztás a következőn keresztül:

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ódját ToDoItem az alábbi példában találja:


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

Ez a példa HTTP-streamekkel adja vissza az adattömbök válaszadatait.

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

További információkért, beleértve a HTTP-streamek projektben való engedélyezését, tekintse meg a HTTP-streameket.

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

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

Az izolált feldolgozói modell és a folyamaton belüli modell is ezt HttpTriggerAttribute használja 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ómodell-függvényalkalmazá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 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 típusa HttpRequestData vagy HttpRequesttípusa, az egyéni típusok más paraméterekhez is köthetők a 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 Ez egy másik típus, mint a hasonló attribútum a .Microsoft.AspNetCore.Mvc A ASP.NET Core-integráció használatakor teljes körűen minősített referencia vagy using utasítás szükséges. Ez a 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 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 category id 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 category id 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 category id. 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 category id. 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 előtaggal apivan el van kapcsolva. Az előtagot a host.json fájl tulajdonságával extensions.http.routePrefix is testre szabhatja vagy eltávolíthatja . Az alábbi példa egy üres sztring használatával távolítja el az api útvonalelő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

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.

HTTP-streamek

A PYTHON HTTP-streamek támogatása lehetővé teszi, hogy a függvényekben engedélyezett FastAPI kérés- és válasz API-k használatával fogadjon és küldjön vissza adatokat a HTTP-végpontokról. Ezek az API-k lehetővé teszik a gazdagép számára, hogy a HTTP-üzenetekben lévő adatokat adattömbökként dolgozza fel ahelyett, hogy egy teljes üzenetet kellene beolvasnia a memóriába. További információ: HTTP-streamek a Pythonban

Fontos

A Python HTTP-streamek támogatása jelenleg előzetes verzióban érhető el, és csak a Python v2 programozási modell esetében támogatott.

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

Feljegyzés

A hitelesített ügyféladatokhoz való hozzáférés jelenleg csak .NET-nyelvek esetén érhető el. A Functions-futtatókörnyezet 1.x-es verziójában sem támogatott.

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 hozzáférési kulcsra.
funkció A végpont eléréséhez függvényspecifikus kulcs szükséges.
Admin A végpont eléréséhez a főkulcs szükséges.

Ha egy szint nincs explicit módon beállítva, az engedélyezés alapértelmezés szerint a function szintre lesz beállítva.

Ha egy szint nincs explicit módon beállítva, az alapértelmezett engedélyezés a Node.js modell verziójától függ:

Az engedélyezés alapértelmezés szerint a szintre van kapcsolva anonymous .

Függvényelérési kulcsok

A függvények lehetővé teszik a hozzáférési kulcsok használatát, hogy megnehezítse a függvényvégpontok elérését. Ha a HTTP által aktivált függvény engedélyezési szintje nincs beállítva anonymous, a kéréseknek tartalmazniuk kell egy hozzáférési kulcsot a kérelemben. További információ: A hozzáférési kulcsok használata az Azure Functionsben.

Hozzáférési kulcs engedélyezése

A legtöbb HTTP-eseményindító-sablonhoz hozzáférési 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 korábban említett lekérdezési sztringváltozóban code. 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.

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.

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 webhook-sablonok egy másik 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