Dayanıklı İşlevler'deki HTTP özellikleri

Durable Functions, dayanıklı düzenlemelerin ve varlıkların HTTP iş akışlarına dahil olmasını kolaylaştıran çeşitli özelliklere sahiptir. Bu makalede bu özelliklerden bazıları hakkında ayrıntılı bilgi verilmektedir.

HTTP API'lerini kullanıma sunma

Düzenleme ve varlıklar HTTP istekleri kullanılarak çağrılabilir ve yönetilebilir. Durable Functions uzantısı yerleşik HTTP API'lerini kullanıma sunar. Ayrıca, HTTP tetiklemeli işlevlerden orkestrasyonlar ve varlıklarla etkileşim sağlamak için API'ler sağlar.

Yerleşik HTTP API'leri

Durable Functions uzantısı, Azure Functions konağına otomatik olarak bir HTTP API'leri kümesi ekler. Bu API'lerle, herhangi bir kod yazmadan düzenlemelerle ve varlıklarla etkileşimde bulunabilir ve bunları yönetebilirsiniz.

Aşağıdaki yerleşik HTTP API'leri desteklenir.

Durable Functions uzantısı tarafından kullanıma sunulan tüm yerleşik HTTP API'lerinin tam açıklaması için HTTP API'ler makalesine bakın.

HTTP API URL'si bulma

Orkestrasyon istemci bağlaması, uygun HTTP yanıt yükleri oluşturabilen API'leri kullanıma sunar. Örneğin, belirli bir düzenleme örneği için yönetim API'lerine bağlantılar içeren bir yanıt oluşturabilir. Aşağıdaki örneklerde, yeni bir düzenleme örneği için bu API'nin nasıl kullanılacağını gösteren bir HTTP tetikleyici işlevi gösterilmektedir:

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

Uyarı

CreateCheckStatusResponse ve ilgili API'ler, şu anda yalnızca HTTP ile tetiklenen işlevlerle çalışırken HttpRequestData ve HttpResponseData türlerini destekler. ASP.NET tanımlı türler şu anda desteklenmiyor.

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

Eğer aynı işlev uygulamasında birden fazla HTTP ile tetiklenen başlatıcı işlev varsa, yol çakışmalarını önlemek için her işlev için benzersiz bir route yapılandırması yapın. gibi orchestrators/{functionName} parametreli bir yol kullanmak (önceki örneklerin birkaçında gösterildiği gibi) tek bir HTTP starter işlevinin herhangi bir düzenleyiciyi ada göre başlatmasını sağlar. Bu genellikle en basit yaklaşımdır.

Daha önce gösterilen HTTP tetikleyici işlevlerini kullanarak bir orchestrator işlevi başlatmak herhangi bir HTTP istemcisi kullanılarak yapılabilir. Aşağıdaki cURL komutu DoWork adlı bir orchestrator işlevi başlatır:

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

İşte kimliği abc123 olan bir orkestrasyon için örnek bir yanıt. Netlik sağlamak için bazı ayrıntılar kaldırıldı.

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

Önceki örnekte, ile biten Uri alanların her biri yerleşik bir HTTP API'sine karşılık gelir. Hedef düzenleme örneğini yönetmek için bu API'leri kullanabilirsiniz.

Uyarı

Web kancası URL'lerinin biçimi, Azure Functions konağın hangi sürümünü çalıştırdığınıza bağlıdır. Önceki örnek, Azure Functions 2.0 konağı içindir.

Tüm yerleşik HTTP API'lerinin açıklaması için bkz. HTTP API başvurusu.

Asenkron operasyon takibi

Daha önce bahsedilen HTTP yanıtı, Durable Functions ile uzun süre çalışan HTTP zaman uyumsuz API'lerinin uygulanmasına yardımcı olmak için tasarlanmıştır. Bu desen bazen sorgulama tüketici deseni olarak adlandırılır. İstemci/sunucu akışı aşağıdaki gibi çalışır:

İstemci, orchestrator işlevi gibi uzun süre çalışan bir işlem başlatmak için bir HTTP isteğinde bulunur.
Hedef HTTP tetikleyicisi, "statusQueryGetUri" değerine sahip bir Konum üst bilgisine sahip bir HTTP 202 yanıtı döndürür.
İstemci, Konum üst bilgisindeki URL'yi sorgular. İstemci, Konum üst bilgisi olan HTTP 202 yanıtlarını görmeye devam eder.
Örnek tamamlandığında veya başarısız olduğunda, Konum üst bilgisindeki uç nokta HTTP 200 döndürür.

Bu protokol, bir HTTP uç noktasını yoklayıp Konum üst bilgisini takip eden dış istemciler veya hizmetlerle uzun süre çalışan işlemlerin koordinasyonunu sağlar. Bu desenin hem istemci hem de sunucu uygulamaları Durable Functions HTTP API'lerinde yerleşiktir.

Uyarı

Varsayılan olarak, Azure Logic Apps tarafından sağlanan tüm HTTP tabanlı eylemler standart zaman uyumsuz işlem düzenini destekler. Bu özellik, Logic Apps iş akışının parçası olarak uzun süre çalışan bir dayanıklı işlev eklemeyi mümkün kılar. Azure Logic Apps iş akışı eylemleri ve tetikleyicileri belgelerinde zaman uyumsuz HTTP desenleri için Logic Apps desteği hakkında daha fazla ayrıntı bulabilirsiniz.

Uyarı

Düzenlemelerle etkileşimler yalnızca HTTP ile tetiklenen işlevlerle değil, herhangi bir işlev türünden gerçekleştirilebilir.

İstemci API'lerini kullanarak düzenleme ve varlıkları yönetme hakkında daha fazla bilgi için Örnek yönetimi makalesine bakın.

HTTP API'lerini kullanma

Orchestrator kod kısıtlamalarında açıklandığı gibi, orchestrator işlevleri doğrudan G/Ç yapamaz. Bunun yerine genellikle G/Ç işlemleri gerçekleştiren etkinlikleri çağırırlar.

Durable Functions 2.0'dan başlayarak, orkestrasyonlar orkestrasyon tetikleyici bağlaması kullanarak HTTP API'lerini yerel olarak tüketebilir.

Aşağıdaki örnek kod, giden HTTP isteğinde bulunan bir orchestrator işlevini gösterir:

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

Uyarı

Bu özelliğin neden yerleşik .NET HttpRequestMessage ve HttpResponseMessage türleri yerine DurableHttpRequest ve DurableHttpResponse türlerini kullandığını merak ediyor olabilirsiniz.

Bu tasarım seçimi kasıtlıdır. Bunun birincil nedeni, özel türlerin kullanıcıların iç HTTP istemcisinin desteklenen davranışları hakkında yanlış varsayımlarda bulunmamasını sağlamaya yardımcı olmasıdır. Durable Functions özgü türler, API tasarımını basitleştirmeyi de mümkün hale getirir. Ayrıca yönetilen kimlik entegrasyonu ve polling tüketici deseni gibi özel özellikleri daha kolay kullanılabilir hale getirir.

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

Uyarı

Bu tasarım seçimi kasıtlıdır. Bunun birincil nedeni, özel türlerin kullanıcıların iç HTTP istemcisinin desteklenen davranışları hakkında yanlış varsayımlarda bulunmamasını sağlamaya yardımcı olmasıdır. Durable Functions özgü türler, API tasarımını basitleştirmeyi de mümkün hale getirir. Ayrıca yerleşik çerçeve türlerinin parçası olmayan özel özellikleri daha kolay kullanılabilir hale getirir.

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)

"HTTP'yi çağır" eylemini kullanarak düzenleyici işlevlerinizde aşağıdaki eylemleri gerçekleştirebilirsiniz:

HTTP API'lerini daha sonra bahsedilen bazı sınırlamalarla doğrudan düzenleme işlevlerinden çağırabilirsiniz.
İstemci tarafı HTTP 202 durum yoklama desenlerini otomatik olarak destekler.
Diğer Azure uç noktalarına yetkili HTTP çağrıları yapmak için Azure Yönetilen Kimlikler kullanın.

HTTP API'lerini doğrudan orchestrator işlevlerinden kullanma özelliği, belirli bir ortak senaryo kümesi için kolaylık sağlamak amacıyla tasarlanmıştır. Etkinlik işlevlerini kullanarak bu özelliklerin tümünü kendiniz uygulayabilirsiniz. Çoğu durumda etkinlik işlevleri size daha fazla esneklik verebilir.

HTTP 202 işlenmesi (yalnızca .NET)

"HTTP çağrısı" API'si, yoklama tüketici deseninin istemci tarafını otomatik olarak uygulayabilir. Çağrılan API, konum üst bilgisi ile birlikte bir HTTP 202 yanıtı döndürürse, orkestratör işlevi, 202 dışındaki bir yanıt alıncaya kadar konum kaynağını otomatik olarak sorgular. Bu yanıt, orchestrator işlev koduna döndürülen yanıt olacaktır.

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

Uyarı

Orchestrator işlevleri, Zaman uyumsuz işlem izleme bölümünde açıklandığı gibi sunucu tarafı yoklama tüketici desenini de yerel olarak destekler. Bu destek, bir işlev uygulamasındaki düzenlemelerin diğer işlev uygulamalarında orchestrator işlevlerini kolayca koordine olabileceği anlamına gelir. Bu, alt düzenleme kavramına benzer, ancak uygulamalar arası iletişimi destekler. Bu destek özellikle mikro hizmet stili uygulama geliştirme için kullanışlıdır.
Yerleşik HTTP yoklama düzeni şu anda yalnızca .NET ana bilgisayarında kullanılabilir.
.NET işlem içi modelinde anket düzeni varsayılan olarak etkinleştirilirken, .NET Isolated modelinde varsayılan olarak devre dışı bırakılır. .NET Isolated'de etkinleştirmek istiyorsanız, örnek koda bakın ve asynchronousPatternEnabled argümanını true olarak ayarlayın.
HTTP otomatik sorgulama deseni, Durable Functions .NET Isolated v1.5.0 veya daha sonraki sürümlerde desteklenmektedir.

Yönetilen kimlikler

Durable Functions, yetkilendirme için Microsoft Entra belirteçleri kabul eden API'lere çağrıları yerel olarak destekler. Bu destek, bu belirteçleri almak için Azure yönetilen kimlikleri kullanır.

Aşağıdaki kod bir orchestrator işlevi örneğidir. İşlev, Azure Resource Manager virtual makineleri REST API kullanarak sanal makineyi yeniden başlatmak için kimliği doğrulanmış çağrılar yapar.

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

Uyarı

yalıtılmış Durable Functions .NET için HTTP özelliğindeki Belirteç Kimlik Bilgileri desteği, v1.6.0 sürümünden itibaren kullanılabilir.

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)

Önceki örnekte tokenSource parametresi Azure Resource Manager için Microsoft Entra belirteçleri almak üzere yapılandırılmıştır. Belirteçler kaynak URI'sine https://management.core.windows.net/.defaultgöre tanımlanır. Örnekte, geçerli işlev uygulamasının yerel olarak çalıştığı veya yönetilen kimliğe sahip bir işlev uygulaması olarak dağıtıldığı varsayılır. Yerel kimliğin veya yönetilen kimliğin, belirtilen kaynak grubundaki myRGVM'leri yönetme iznine sahip olduğu varsayılır.

Çalışma zamanında, yapılandırılan belirteç kaynağı otomatik olarak bir OAuth 2.0 erişim belirteci döndürür. Ardından kaynak, giden isteğin Yetkilendirme üst bilgisine taşıyıcı belirteç olarak belirteci ekler. Bu model, aşağıdaki nedenlerle HTTP isteklerine el ile yetkilendirme üst bilgileri eklemeye göre bir geliştirmedir:

Belirteç yenilemesi otomatik olarak işlenir. Süresi dolan belirteçler konusunda endişelenmeniz gerekmez.
Belirteçler hiçbir zaman kalıcı orkestrasyon durumunda depolanmaz.
Belirteç alımını yönetmek için herhangi bir kod yazmanız gerekmez.

precompiled C# RestartVMs örneğinde daha eksiksiz bir örnek bulabilirsiniz.

Yönetilen kimlikler Azure kaynak yönetimiyle sınırlı değildir. Yönetilen kimlikleri, Microsoft'tan Azure hizmetleri ve iş ortaklarının web uygulamaları da dahil olmak üzere Microsoft Entra taşıyıcı belirteçlerini kabul eden herhangi bir API'ye erişmek için kullanabilirsiniz. İş ortağının web uygulaması başka bir işlev uygulaması bile olabilir. Microsoft'un Microsoft Entra ID kimlik doğrulamasını destekleyen Azure hizmetlerinin listesi için bkz. Microsoft Entra kimlik doğrulamasını destekleyen Azure hizmetleri.

Sınırlamalar

HTTP API'lerini çağırmaya yönelik yerleşik destek kolaylık bir özelliktir. Tüm senaryolar için uygun değildir.

Orchestrator işlevleri tarafından gönderilen HTTP istekleri ve yanıtları, Durable Functions depolama sağlayıcısında ileti olarak serialleştirilmiş ve kalıcı hale getirilmiş şeklindedir. Bu kalıcı kuyruğa alma davranışı, HTTP çağrılarının düzenleme yeniden yürütmesi için güvenilir ve güvenli olmasını sağlar. Ancak, kalıcı kuyruğa alma davranışının da sınırlamaları vardır:

Her HTTP isteği, yerel bir HTTP istemcisiyle karşılaştırıldığında ek gecikme süresi içerir.
Yapılandırılan depolama sağlayıcısına bağlı olarak, büyük istek veya yanıt iletileri düzenleme performansını önemli ölçüde düşürebilir. Örneğin, Azure Storage kullanırken, Azure Kuyruk iletilerine sığamayacak kadar büyük HTTP yükleri sıkıştırılır ve Azure Blob depolamada depolanır.
Akış, parçalanmış ve ikili yükler desteklenmezler.
HTTP istemcisinin davranışını özelleştirme özelliği sınırlıdır.

Bu sınırlamalardan herhangi biri kullanım örneğinizi etkileyebilirse, bunun yerine giden HTTP çağrıları yapmak için etkinlik işlevlerini ve dile özgü HTTP istemci kitaplıklarını kullanmayı göz önünde bulundurun.

Genişletilebilirlik (yalnızca işlem içi .NET)

İşlem içi çalışan için Azure Functions .NET bağımlılık ekleme kullanarak düzenlemenin iç HTTP istemcisinin davranışını özelleştirmek mümkündür. Bu özellik, küçük davranış değişiklikleri yapmak için yararlı olabilir. Sahte nesneler ekleyerek HTTP istemcisini birim testi için de yararlı olabilir.

Aşağıdaki örnekte, dış HTTP uç noktalarını çağıran düzenleyici işlevleri için TLS/SSL sertifika doğrulamasını devre dışı bırakmak için bağımlılık eklemenin kullanılması gösterilmektedir.

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

Sonraki Adımlar

Dayanıklı varlıklar hakkında bilgi edinin

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2026-04-22

Dayanıklı İşlevler'deki HTTP özellikleri

HTTP API'lerini kullanıma sunma

Yerleşik HTTP API'leri

HTTP API URL'si bulma

Asenkron operasyon takibi

HTTP API'lerini kullanma

HTTP 202 işlenmesi (yalnızca .NET)

Yönetilen kimlikler

Sınırlamalar

Genişletilebilirlik (yalnızca işlem içi .NET)

Sonraki Adımlar

Geri Bildirim

Ek kaynaklar