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

Azure Functions HTTP-eseményindító

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 egy HTTP-aktivált függvény, amely HTTP-streameket használ az adattömbök válaszadatainak visszaadásához. Ezekkel a képességekkel olyan forgatókönyveket támogathat, mint az eseményadatok folyamaton keresztüli küldése valós idejű vizualizációhoz, vagy nagy adathalmazok rendellenességeinek észlelése és azonnali értesítések küldése.

import time

import azure.functions as func
from azurefunctions.extensions.http.fastapi import Request, StreamingResponse

app = func.FunctionApp(http_auth_level=func.AuthLevel.FUNCTION)


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 options átadott objektumon app.http() 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
típus Kötelező – a beállításnak httpTriggera következőnek kell lennie: .
irány 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 újabbMicrosoft.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 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 előtaggal apivan 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 ú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.

Előfeltételek

HTTP-streamek engedélyezése

A HTTP-streamek alapértelmezés szerint le vannak tiltva. Engedélyeznie kell ezt a funkciót az alkalmazásbeállításokban, és frissítenie kell a kódot a FastAPI-csomag használatához. Vegye figyelembe, hogy a HTTP-streamek engedélyezésekor a függvényalkalmazás alapértelmezés szerint HTTP-streamelést használ, és az eredeti HTTP-funkció nem fog működni.

  1. Adja hozzá a azurefunctions-extensions-http-fastapi bővítménycsomagot a requirements.txt projekt fájljába, amelynek legalább az alábbi csomagokat kell tartalmaznia:

    azure-functions
azurefunctions-extensions-http-fastapi

  2. Adja hozzá ezt a kódot a function_app.py projekt fájljához, amely importálja a FastAPI-bővítményt:

    from azurefunctions.extensions.http.fastapi import Request, StreamingResponse

  3. Az Azure-ban való üzembe helyezéskor adja hozzá a következő alkalmazásbeállítást a függvényalkalmazáshoz:

    "PYTHON_ENABLE_INIT_INDEXING": "1"

    Helyi futtatáskor ezeket a beállításokat is hozzá kell adnia a local.settings.json projektfájlhoz.

HTTP-streamek – példák

A HTTP-streamelési funkció engedélyezése után olyan függvényeket hozhat létre, amelyek HTTP-en keresztül streamelik az adatokat.

Ez a példa egy HTTP által aktivált függvény, amely valós időben fogad és dolgoz fel streamelési adatokat egy ügyféltől. Bemutatja a streamelési feltöltési képességeket, amelyek hasznosak lehetnek olyan helyzetekben, mint a folyamatos adatfolyamok feldolgozása és az IoT-eszközök eseményadatainak kezelése.

import azure.functions as func
from azurefunctions.extensions.http.fastapi import JSONResponse, Request

app = func.FunctionApp(http_auth_level=func.AuthLevel.FUNCTION)


@app.route(route="streaming_upload", methods=[func.HttpMethod.POST])
async def streaming_upload(req: Request) -> JSONResponse:
    """Handle streaming upload requests."""
    # Process each chunk of data as it arrives
    async for chunk in req.stream():
        process_data_chunk(chunk)

    # Once all data is received, return a JSON response indicating successful processing
    return JSONResponse({"status": "Data uploaded and processed successfully"})


def process_data_chunk(chunk: bytes):
    """Process each data chunk."""
    # Add custom processing logic here
    pass

HTTP-streamek meghívása

Http-ügyfélkódtár használatával kell streamelési hívásokat kezdeményeznie egy függvény FastAPI-végpontjára. Előfordulhat, hogy a használt ügyféleszköz vagy böngésző natív módon nem támogatja a streamelést, vagy csak az adatok első adattömbét tudta visszaadni.

Egy ilyen ügyfélszkripttel streamelési adatokat küldhet egy HTTP-végpontnak:

import httpx # Be sure to add 'httpx' to 'requirements.txt'
import asyncio

async def stream_generator(file_path):
    chunk_size = 2 * 1024  # Define your own chunk size
    with open(file_path, 'rb') as file:
        while chunk := file.read(chunk_size):
            yield chunk
            print(f"Sent chunk: {len(chunk)} bytes")

async def stream_to_server(url, file_path):
    timeout = httpx.Timeout(60.0, connect=60.0)
    async with httpx.AsyncClient(timeout=timeout) as client:
        response = await client.post(url, content=stream_generator(file_path))
        return response

async def stream_response(response):
    if response.status_code == 200:
        async for chunk in response.aiter_raw():
            print(f"Received chunk: {len(chunk)} bytes")
    else:
        print(f"Error: {response}")

async def main():
    print('helloworld')
    # Customize your streaming endpoint served from core tool in variable 'url' if different.
    url = 'http://localhost:7071/api/streaming_upload'
    file_path = r'<file path>'

    response = await stream_to_server(url, file_path)
    print(response)

if __name__ == "__main__":
    asyncio.run(main())

Fontos

A Python HTTP-streamek támogatása általánosan elérhető, é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 tárolókban futó függvényalkalmazások a tárológazda tartományát használják. Az Azure Container Appsben üzemeltetett HTTP-végpontot ebben a Container Apps-üzemeltetési cikkben találja.

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érések mérete és az URL-hosszok a gazdagépen megadott beállítások alapján korlátozottak. További információ: Szolgáltatáskorlátok.

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