HTTP-funkciók a Durable Functionsben

Durable Functions számos olyan funkcióval rendelkezik, amelyek megkönnyítik a tartós vezénylések és entitások HTTP-munkafolyamatokba való beépítését. Ez a cikk részletesen ismerteti ezen funkciók némelyikét.

HTTP API-k elérhetővé tétele

A vezénylések és entitások HTTP-kérésekkel hívhatók meg és kezelhetők. A Durable Functions bővítmény beépített HTTP API-kat tesz elérhetővé. Emellett API-kat biztosít a vezénylések és entitások HTTP-triggerelt függvényeken keresztül történő kezeléséhez.

Beépített HTTP API-k

A Durable Functions bővítmény automatikusan hozzáad egy készlet HTTP API-t az Azure Functions gazdagéphez. Ezekkel az API-kkal kódírás nélkül léphet kapcsolatba az orchestrationökkel és kezelheti az entitásokat.

A következő beépített HTTP API-k támogatottak.

A Durable Functions bővítmény által közzétett beépített HTTP API-k teljes leírását a HTTP API-król szóló cikkben találja.

HTTP API URL-felderítés

A orchestration klienskötés olyan API-kat tesz elérhetővé, amelyek képesek kényelmes HTTP-válasz terheléseket létrehozni. Például létrehozhat egy választ, amely egy adott orchestrációs példány menedzsment API-ira mutató hivatkozásokat tartalmaz. Az alábbi példák egy HTTP-trigger függvényt mutatnak be, amely bemutatja, hogyan használhatja ezt az API-t egy új vezénylési példányhoz:

// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.

using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.DurableTask;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.Extensions.Logging;

namespace VSSample
{
    public static class HttpStart
    {
        [FunctionName("HttpStart")]
        public static async Task<HttpResponseMessage> Run(
            [HttpTrigger(AuthorizationLevel.Function, methods: "post", Route = "orchestrators/{functionName}")] HttpRequestMessage req,
            [DurableClient] IDurableClient starter,
            string functionName,
            ILogger log)
        {
            // Function input comes from the request content.
            object eventData = await req.Content.ReadAsAsync<object>();
            string instanceId = await starter.StartNewAsync(functionName, eventData);

            log.LogInformation($"Started orchestration with ID = '{instanceId}'.");

            return starter.CreateCheckStatusResponse(req, instanceId);
        }
    }
}

/// <summary>
/// HTTP-triggered function that starts the <see cref="HelloCitiesUntyped"/> orchestration.
/// </summary>
/// <param name="req">The HTTP request that was used to trigger this function.</param>
/// <param name="client">The DurableTask client that is used to start and manage orchestration instances.</param>
/// <param name="executionContext">The Azure Functions execution context, which is available to all function types.</param>
/// <returns>Returns an HTTP response with more information about the started orchestration instance.</returns>
[Function(nameof(StartHelloCitiesUntyped))]
public static async Task<HttpResponseData> StartHelloCitiesUntyped(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestData req,
    [DurableClient] DurableTaskClient client,
    FunctionContext executionContext)
{
    ILogger logger = executionContext.GetLogger(nameof(StartHelloCitiesUntyped));

    string instanceId = await client.ScheduleNewOrchestrationInstanceAsync(nameof(HelloCitiesUntyped));
    logger.LogInformation("Created new orchestration with instance ID = {instanceId}", instanceId);

    // Returns an HTTP response with a payload that includes links to built-in HTTP management payloads
    return client.CreateCheckStatusResponse(req, instanceId);
}

Note

Jelenleg a CreateCheckStatusResponse és a hozzá kapcsolódó API-k csak a HttpRequestData és HttpResponseData típusokat támogatják a HTTP által aktivált függvények használatakor. ASP.NET definiált típusok jelenleg nem támogatottak.

index.js

const df = require("durable-functions");

module.exports = async function (context, req) {
    const client = df.getClient(context);
    const instanceId = await client.startNew(req.params.functionName, undefined, req.body);

    context.log(`Started orchestration with ID = '${instanceId}'.`);

    return client.createCheckStatusResponse(context.bindingData.req, instanceId);
};

function.json

{
    "bindings": [
      {
        "authLevel": "anonymous",
        "name": "req",
        "type": "httpTrigger",
        "direction": "in",
        "route": "orchestrators/{functionName}",
        "methods": ["post"]
      },
      {
        "name": "$return",
        "type": "http",
        "direction": "out"
      },
      {
        "name": "starter",
        "type": "orchestrationClient",
        "direction": "in"
      }
    ],
    "disabled": false
  }

init.py

import logging
import azure.functions as func
import azure.durable_functions as df

async def main(req: func.HttpRequest, starter: str) -> func.HttpResponse:
    client = df.DurableOrchestrationClient(starter)
    function_name = req.route_params['functionName']
    event_data = req.get_body()

    instance_id = await client.start_new(function_name, instance_id, event_data)
    
    logging.info(f"Started orchestration with ID = '{instance_id}'.")
    return client.create_check_status_response(req, instance_id)

function.json

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "authLevel": "function",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "route": "orchestrators/{functionName}",
      "methods": [
        "post",
        "get"
      ]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "name": "starter",
      "type": "orchestrationClient",
      "direction": "in"
    }
  ]
}

run.ps1

$FunctionName = $Request.Params.FunctionName
$InstanceId = Start-NewOrchestration -FunctionName $FunctionName
Write-Host "Started orchestration with ID = '$InstanceId'"

$Response = New-OrchestrationCheckStatusResponse -Request $Request -InstanceId $InstanceId
Push-OutputBinding -Name Response -Value $Response

function.json

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "name": "Request",
      "type": "httpTrigger",
      "direction": "in",
      "route": "orchestrators/{FunctionName}",
      "methods": [
        "post",
        "get"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "Response"
    },
    {
      "name": "starter",
      "type": "orchestrationClient",
      "direction": "in"
    }
  ]
}

@FunctionName("HttpStart")
public HttpResponseMessage httpStart(
        @HttpTrigger(name = "req", route = "orchestrators/{functionName}") HttpRequestMessage<?> req,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext,
        @BindingName("functionName") String functionName,
        final ExecutionContext context) {

    DurableTaskClient client = durableContext.getClient();
    String instanceId = client.scheduleNewOrchestrationInstance(functionName);
    context.getLogger().info("Created new Java orchestration with instance ID = " + instanceId);
    return durableContext.createCheckStatusResponse(req, instanceId);
}

Tip

Ha ugyanabban a függvényalkalmazásban több HTTP-aktivált kezdőfüggvény is van, konfiguráljon egyedit route minden függvényhez az útvonalütközések elkerülése érdekében. Egy olyan paraméteres útvonal használata, mint ( orchestrators/{functionName} ahogy az az előző példákban is látható) lehetővé teszi, hogy egyetlen HTTP starter függvény név alapján indítsa el a vezénylőt, ami gyakran a legegyszerűbb módszer.

A vezénylőfüggvények indítása a korábban bemutatott HTTP-trigger függvények használatával bármely HTTP-ügyfél használatával elvégezhető. A következő cURL-parancs elindít egy vezénylő függvényt DoWork:

curl -X POST https://localhost:7071/orchestrators/DoWork -H "Content-Length: 0" -i

A következő példa egy olyan orchestrációra adott válasz, amelynek azonosítója abc123. Néhány részlet el lett távolítva az egyértelműség kedvéért.

HTTP/1.1 202 Accepted
Content-Type: application/json; charset=utf-8
Location: http://localhost:7071/runtime/webhooks/durabletask/instances/abc123?code=XXX
Retry-After: 10

{
    "id": "abc123",
    "purgeHistoryDeleteUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/abc123?code=XXX",
    "sendEventPostUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/abc123/raiseEvent/{eventName}?code=XXX",
    "statusQueryGetUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/abc123?code=XXX",
    "terminatePostUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/abc123/terminate?reason={text}&code=XXX"
}

Az előző példában Uri a végződő mezők mindegyike egy beépített HTTP API-nak felel meg. Ezekkel az API-kkal kezelheti a célba vett orchestration példányt.

Note

A webhook URL-címeinek formátuma attól függ, hogy a Azure Functions-gazdagép melyik verzióját futtatja. Az előző példa az Azure Functions 2.0-s gazdagéphez.

Az összes beépített HTTP API leírását a HTTP API-referencia ismerteti.

Aszinkron műveletek nyomon követése

A korábban említett HTTP-válasz célja, hogy segítse a hosszú ideig futó HTTP aszinkron API-k implementálását a Durable Functions segítségével. Ezt a mintát néha lekérdezési fogyasztói mintának is nevezik. Az ügyfél-kiszolgáló folyamat a következőképpen működik:

Az ügyfél HTTP-kérést ad ki egy hosszú ideig futó folyamat, például egy vezénylőfüggvény elindításához.
A cél HTTP-eseményindító egy HTTP 202 választ ad vissza egy Location fejléccel, amelynek az értéke "statusQueryGetUri".
Az ügyfél lekérdezi az URL-címet a Hely fejlécben. Az ügyfél továbbra is a HTTP 202-válaszokat látja egy Hely fejléccel.
Ha a példány befejeződik vagy meghiúsul, a Location fejléc végpontja HTTP 200 státuszkódot küld vissza.

Ez a protokoll lehetővé teszi a hosszú ideig futó folyamatok összehangolását olyan külső ügyfelekkel vagy szolgáltatásokkal, amelyek LEkérdezhetnek egy HTTP-végpontot, és követhetik a Hely fejlécet. A minta ügyfél- és kiszolgálói implementációi is a Durable Functions HTTP API-kba vannak beépítve.

Note

Alapértelmezés szerint az Azure Logic Apps támogatja a szabványos aszinkron műveleti mintát. Ez a funkció lehetővé teszi egy hosszú ideig futó tartós függvény beágyazását egy Logic Apps-munkafolyamat részeként. Az aszinkron HTTP-minták Logic Apps-támogatásáról a Azure Logic Apps munkafolyamat-műveletek és eseményindítók dokumentációjában talál további információt.

Note

Az orchestrationokkal való interakciók bármilyen függvénytípusból elvégezhetők, nem csak a HTTP-triggerelt függvényekből.

A vezénylések és entitások ügyfél API-k használatával történő kezelésével kapcsolatos további információkért tekintse meg a Példánykezelési cikket.

HTTP API-k használata

A vezénylési kód korlátaiban leírtak szerint a vezénylő függvények nem végezhetnek közvetlen I/O-műveleteket. Ehelyett általában I/O-műveleteket végző tevékenységeket neveznek.

A Durable Functions 2.0-tól kezdve a vezénylések natívan használhatják az HTTP API-kat az orchestration trigger kötés használatával.

Az alábbi példakód egy kimenő HTTP-kérést készítő vezénylő függvényt mutat be:

[FunctionName(nameof(CheckSiteAvailable))]
public static async Task CheckSiteAvailable(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    Uri url = context.GetInput<Uri>();

    // Makes an HTTP GET request to the specified endpoint
    DurableHttpResponse response = 
        await context.CallHttpAsync(HttpMethod.Get, url);

    if (response.StatusCode >= 400)
    {
        // handling of error codes goes here
    }
}

Note

Felmerülhet a kérdés, hogy ez a funkció miért használja a DurableHttpRequest és DurableHttpResponse típusokat a beépített .NET HttpRequestMessage és HttpResponseMessage típusok helyett.

Ez a kialakítási döntés szándékos. Az elsődleges ok az, hogy az egyéni típusok segítenek biztosítani, hogy a felhasználók ne tegyenek helytelen feltételezéseket a belső HTTP-ügyfél támogatott viselkedésével kapcsolatban. A Durable Functions jellemző típusok lehetővé teszik az API-tervezés egyszerűsítését is. Emellett egyszerűbben elérhetővé tehetnek olyan speciális funkciókat, mint a felügyelt identitásintegráció és a lekérdezési fogyasztói minta.

[Function(nameof(CheckSiteAvailable))]
public static async Task CheckSiteAvailable(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    Uri url = context.GetInput<Uri>();

    // Makes an HTTP GET request to the specified endpoint
    DurableHttpResponse response =
        await context.CallHttpAsync(HttpMethod.Get, url);

    if (response.StatusCode >= HttpStatusCode.BadRequest)
    {
        // handling of error codes goes here
    }
}

Note

Ez a kialakítási döntés szándékos. Az elsődleges ok az, hogy az egyéni típusok segítenek biztosítani, hogy a felhasználók ne tegyenek helytelen feltételezéseket a belső HTTP-ügyfél támogatott viselkedésével kapcsolatban. A Durable Functions jellemző típusok lehetővé teszik az API-tervezés egyszerűsítését is. Egyszerűbben elérhetővé tehetnek olyan speciális funkciókat is, amelyek nem részei a beépített keretrendszertípusoknak.

const df = require("durable-functions");

module.exports = df.orchestrator(function*(context){
    const url = context.df.getInput();
    const response = yield context.df.callHttp("GET", url)

    if (response.statusCode >= 400) {
        // handling of error codes goes here
    }
});

import azure.functions as func
import azure.durable_functions as df
from datetime import datetime, timedelta

def orchestrator_function(context: df.DurableOrchestrationContext):
    url = context.get_input()
    response = yield context.call_http('GET', url)
    
    if response["statusCode"] >= 400:
        # handling of error codes goes here

main = df.Orchestrator.create(orchestrator_function)

A "http meghívása" művelet használatával a következő műveleteket hajthatja végre a vezénylő függvényekben:

A HTTP API-kat közvetlenül a vezénylési függvényekből hívhatja meg, néhány, később említett korlátozással.
Automatikusan támogatja az ügyféloldali HTTP 202 állapot-lekérdezési mintákat.
A Azure felügyelt identitások használatával engedélyezett HTTP-hívásokat kezdeményezhet más Azure végpontokra.

A HTTP API-k közvetlenül a vezénylő függvényekből való felhasználásának lehetősége bizonyos gyakori forgatókönyvek kényelmét szolgálja. Ezeket a funkciókat saját maga is megvalósíthatja aktivitási függvények használatával. A tevékenységfüggvények sok esetben nagyobb rugalmasságot biztosíthatnak.

HTTP 202 kezelés (csak .NET)

A "call HTTP" API automatikusan implementálhatja a lekérdezési fogyasztói minta ügyféloldalát. Ha egy úgynevezett API egy HTTP 202-választ ad vissza egy Hely fejléccel, a vezénylő függvény automatikusan lekérdezi a Hely erőforrást, amíg nem kap 202-től eltérő választ. Ez a válasz lesz a vezénylő függvény kódjának visszaadott válasza.

[FunctionName(nameof(CheckSiteAvailabilityWithPolling))]
public static async Task CheckSiteAvailabilityWithPolling(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    Uri url = context.GetInput<Uri>();

    // HTTP automatic polling on 202 response is enabled by default in .NET in-process.
    DurableHttpResponse response = 
        await context.CallHttpAsync(HttpMethod.Get, url);
}

[Function(nameof(CheckSiteAvailabilityWithPolling))]
public static async Task CheckSiteAvailabilityWithPolling(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    Uri url = context.GetInput<Uri>();

    // Enable HTTP automatic polling on 202 response by setting asynchronousPatternEnabled to true.
    DurableHttpResponse response =await context.CallHttpAsync(
        HttpMethod.Get,
        url!,
        content: null,
        retryOptions: null,
        asynchronousPatternEnabled: true)
}

Note

Az Orchestrator-függvények natív módon támogatják a kiszolgálóoldali lekérdezési fogyasztói mintát is, az Async-műveletkövetésben leírtak szerint. Ez a támogatás azt jelenti, hogy az egyik függvényalkalmazás vezénylései egyszerűen összehangolhatják a vezénylő függvényeket más függvényalkalmazásokban. Ez hasonló az alvezénylési koncepcióhoz, de támogatja az alkalmazásközi kommunikációt. Ez a támogatás különösen hasznos mikroszolgáltatás-stílusú alkalmazások fejlesztéséhez.
A beépített HTTP-lekérdezési minta jelenleg csak a .NET gazdagépen érhető el.
A lekérdezési minta alapértelmezés szerint engedélyezve van .NET in-process-ben, de alapértelmezés szerint le van tiltva .NET Isolated-ben. Ha engedélyezni szeretné a .NET Isolated környezetben, tekintse meg a mintakódot, és állítsa az asynchronousPatternEnabled argumentumot igazra.
Az automatikus HTTP lekérdezési minta a Durable Functions .NET-ben v1.5.0 vagy újabb verziótól elérhető és támogatott.

Felügyelt identitások

Durable Functions natív módon támogatja azokat az API-kat, amelyek Microsoft Entra jogkivonatokat fogadnak az engedélyezéshez. Ez a támogatás Azure felügyelt identitásokat használ, hogy megszerezze ezeket a tokeneket.

Az alábbi kód egy vezénylő függvény példája. A függvény hitelesített hívásokat indít egy virtuális gép újraindításához a AZURE RESOURCE MANAGER virtual gépek REST API használatával.

[FunctionName("RestartVm")]
public static async Task RunOrchestrator(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    string subscriptionId = "mySubId";
    string resourceGroup = "myRG";
    string vmName = "myVM";
    string apiVersion = "2019-03-01";
    
    // Automatically fetches an Azure AD token for resource = https://management.core.windows.net/.default
    // and attaches it to the outgoing Azure Resource Manager API call.
    var restartRequest = new DurableHttpRequest(
        HttpMethod.Post, 
        new Uri($"https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Compute/virtualMachines/{vmName}/restart?api-version={apiVersion}"),
        tokenSource: new ManagedIdentityTokenSource("https://management.core.windows.net/.default"));
    DurableHttpResponse restartResponse = await context.CallHttpAsync(restartRequest);
    if (restartResponse.StatusCode != HttpStatusCode.OK)
    {
        throw new ArgumentException($"Failed to restart VM: {restartResponse.StatusCode}: {restartResponse.Content}");
    }
}

[Function(nameof(RestartVm))]
public static async Task<string> RestartVm(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    string subscriptionId = "mySubId";
    string resourceGroup = "myRG";
    string vmName = "myVM";
    string apiVersion = "2019-03-01";

    // Automatically fetches an Azure AD token for resource = https://management.core.windows.net/.default
    // and attaches it to the outgoing Azure Resource Manager API call.
    var tokenSource = new ManagedIdentityTokenSource("https://management.core.windows.net/.default");

    var response = await context.CallHttpAsync(
        HttpMethod.Post,
        new Uri($"https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Compute/virtualMachines/{vmName}/restart?api-version={apiVersion}"),
        tokenSource: tokenSource);

    if (restartResponse.StatusCode != HttpStatusCode.OK)
    {
        throw new ArgumentException($"Failed to restart VM: {response.StatusCode}: {response.Content}");
    }
}

Note

Az izolált Durable Functions .NET HTTP-szolgáltatásában a Token Credential támogatása a v1.6.0 verziótól érhető el.

const df = require("durable-functions");

module.exports = df.orchestrator(function*(context) {
    const subscriptionId = "mySubId";
    const resourceGroup = "myRG";
    const vmName = "myVM";
    const apiVersion = "2019-03-01";
    const tokenSource = new df.ManagedIdentityTokenSource("https://management.core.windows.net/.default");

    // get a list of the Azure subscriptions that I have access to
    const restartResponse = yield context.df.callHttp(
        "POST",
        `https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroup}/providers/Microsoft.Compute/virtualMachines/${vmName}/restart?api-version=${apiVersion}`,
        undefined, // no request content
        undefined, // no request headers (besides auth which is handled by the token source)
        tokenSource);

    return restartResponse;
});

import azure.functions as func
import azure.durable_functions as df

def orchestrator_function(context: df.DurableOrchestrationContext):
    subscription_id = "mySubId"
    resource_group = "myRg"
    vm_name = "myVM"
    api_version = "2019-03-01"
    token_source = df.ManagedIdentityTokenSource("https://management.core.windows.net/.default")

    # get a list of the Azure subscriptions that I have access to
    restart_response = yield context.call_http("POST", 
        f"https://management.azure.com/subscriptions/{subscription_id}/resourceGroups/{resource_group}/providers/Microsoft.Compute/virtualMachines/{vm_name}/restart?api-version={api_version}",
        None,
        None,
        token_source)
    return restart_response

main = df.Orchestrator.create(orchestrator_function)

Az előző példában a tokenSource paraméter úgy van beállítva, hogy Microsoft Entra tokeneket szerezzen be az Azure Resource Manager számára. Az tokeneket az erőforrás URI-ja https://management.core.windows.net/.default azonosítja. A példa feltételezi, hogy az aktuális függvényalkalmazás helyileg fut, vagy felügyelt identitással rendelkező függvényalkalmazásként lett üzembe helyezve. A rendszer feltételezi, hogy a helyi identitás vagy a felügyelt identitás rendelkezik engedéllyel a megadott erőforráscsoportban myRGlévő virtuális gépek kezeléséhez.

Futásidőben a konfigurált jogkivonat-forrás automatikusan egy OAuth 2.0 hozzáférési jogkivonatot ad vissza. A forrás ezután tulajdonosi jogkivonatként hozzáadja a jogkivonatot a kimenő kérés engedélyezési fejlécéhez. Ez a modell az engedélyezési fejlécek HTTP-kérelmekhez való manuális hozzáadásának továbbfejlesztése az alábbi okokból:

A tokenek frissítése automatikusan történik. Nem kell aggódnia a lejárt jogkivonatok miatt.
A tokenek soha nincsenek tartósan tárolva a vezénylési állapotban.
A tokenek beszerzésének kezeléséhez nem kell kódot írnia.

A precompiled C# RestartVMs mintában talál egy teljesebb példát.

A felügyelt identitások nem korlátozódnak Azure erőforrás-kezelésre. Felügyelt identitások használatával bármely olyan API-t elérhet, amely elfogad Microsoft Entra tulajdonosi jogkivonatokat, beleértve a Microsofttól származó Azure szolgáltatásokat és a partnerek webalkalmazásait. A partner webalkalmazása akár egy másik függvényalkalmazás is lehet. A Microsoft Microsoft Entra ID hitelesítést támogató Azure szolgáltatásainak listáját a Microsoft Entra hitelesítést támogató Azure szolgáltatásokról talál.

Limitations

A HTTP API-k meghívásának beépített támogatása kényelmi funkció. Ez nem minden esetben megfelelő.

A vezénylő függvények által küldött HTTP-kérések és válaszaik szerializáltak és megmaradnak üzenetekként a Durable Functions társzolgáltatóban. Ez az állandó üzenetsor-kezelés biztosítja, hogy a HTTP-hívások megbízhatóak és biztonságosak legyenek a vezénylési visszajátszáshoz. A folyamatos üzenetsor-kezelési viselkedés azonban korlátozásokkal is rendelkezik:

Minden HTTP-kérés további késést jelent a natív HTTP-ügyfélhez képest.
A konfigurált tárolószolgáltatótól függően a nagy kérés- vagy válaszüzenetek jelentősen csökkenthetik a vezénylés teljesítményét. Amikor például az Azure Storage-ot használja, a túl nagy HTTP-hasznos terhek, amelyek nem férnek el az Azure Queue üzeneteiben, tömörítve és az Azure Blob Storage-ban tárolva lesznek.
A streamelés, a darabolt adatcsomagok és a bináris hasznos adatok nem támogatottak.
A HTTP-ügyfél viselkedésének testreszabása korlátozott.

Ha ezek közül a korlátozások közül bármelyik hatással lehet a használati esetre, érdemes inkább tevékenységfüggvényeket és nyelvspecifikus HTTP-ügyfélkódtárakat használni kimenő HTTP-hívások indításához.

Bővíthetőség (csak .NET folyamaton belüli)

A orchestration belső HTTP-ügyfél viselkedésének testreszabása Azure Functions .NET függőséginjektálás használatával lehetséges a folyamaton belüli munkavégző számára. Ez a képesség hasznos lehet kis viselkedési módosítások elvégzéséhez. A HTTP-ügyfél egységteszteléséhez is hasznos lehet a modellobjektumok injektálásával.

Az alábbi példa a külső HTTP-végpontokat meghívó vezénylő függvények TLS/SSL-tanúsítványérvényesítésének letiltására szolgáló függőséginjektálás használatát mutatja be.

public class Startup : FunctionsStartup
{
    public override void Configure(IFunctionsHostBuilder builder)
    {
        // Register own factory
        builder.Services.AddSingleton<
            IDurableHttpMessageHandlerFactory,
            MyDurableHttpMessageHandlerFactory>();
    }
}

public class MyDurableHttpMessageHandlerFactory : IDurableHttpMessageHandlerFactory
{
    public HttpMessageHandler CreateHttpMessageHandler()
    {
        // Disable TLS/SSL certificate validation (not recommended in production!)
        return new HttpClientHandler
        {
            ServerCertificateCustomValidationCallback =
                HttpClientHandler.DangerousAcceptAnyServerCertificateValidator,
        };
    }
}

Következő lépések

Tudnivalók a tartós entitásokról

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2026-06-03

HTTP-funkciók a Durable Functionsben

HTTP API-k elérhetővé tétele

Beépített HTTP API-k

HTTP API URL-felderítés

Aszinkron műveletek nyomon követése

HTTP API-k használata

HTTP 202 kezelés (csak .NET)

Felügyelt identitások

Limitations

Bővíthetőség (csak .NET folyamaton belüli)

Következő lépések

Visszajelzés

További források