Dayanıklı orkestrasyonlar

Dayanıklı düzenleme, tamamen kodda tanımlanan güvenilir, uzun süre çalışan bir iş akışında diğer işlevlerin yürütülmesini koordine etmek için bir orchestrator işlevi kullanır. Orchestrator işlevleri aşağıdaki özelliklere sahiptir:

yordam kodunu kullanarak iş akışlarını tanımlarlar. Bildirim temelli şemalar veya tasarımcılar gerekmez.
Diğer işlevleri zaman uyumlu ve zaman uyumsuz olarak çağırırlar. Çağrılan işlevlerin çıkışı yerel değişkenlere kaydedilebilir.
İşlev bir await veya yield işlecini çağırdığında otomatik olarak denetim noktası yürütme ilerleme durumunu denetler, bu nedenle işlem geri dönüşüme geçtiğinde veya VM yeniden başlatıldığında yerel durum kaybolmaz.
Uzun süre çalışan işlemleri destekler. Düzenleme örneğinin toplam ömrü saniye, gün veya ay olabilir veya örneği hiç bitmeyecek şekilde yapılandırabilirsiniz.

Bu makalede, orkestrasyon kimliği, olay kaynağı kullanımı, yürütme geçmişi ve alt-orkestrasyonlar, dayanıklı zamanlayıcılar ve hata işleme gibi yaygın iş akışı desenleri dahil olmak üzere dayanıklı orkestrasyonlara genel bir bakış sağlanmaktadır.

Durable Functions uygulamasında kullanılabilen işlev türleri hakkında bilgi için bkz. Durable Task programlama modeli.

Tip

.NET yalıtılmış çalışan modeliyle C# kullanıyorsanız, işlev tabanlı bir yaklaşım (öznitelikleri olan [Function] statik yöntemler) veya sınıf tabanlı bir yaklaşım (öğesinden TaskOrchestrator<TInput, TOutput>devralan sınıflar) kullanarak düzenleme yazabilirsiniz. Sınıf tabanlı yaklaşım , Microsoft.DurableTask.Generators kaynak oluşturucu paketini gerektirir ve kesin olarak belirlenmiş çağrılar sağlar. Daha fazla bilgi için bkz . Kaynak oluşturucular ve sınıf tabanlı söz dizimi. Bu makaledeki C# kod örnekleri her iki yaklaşımı da gösterir.

Dayanıklı Görev SDK'ları, paralel işleme ve olay odaklı koordinasyon ile güvenilir, uzun süre çalışan iş akışları oluşturmak için Dayanıklı İşlevler ile aynı düzenleyici özellikleri sağlar. Dayanıklı İşlevler'in aksine Dayanıklı Görev SDK'sı düzenlemeleri , Dayanıklı Görev Zamanlayıcı tarafından desteklenen tek başına uygulamalar olarak çalışır.

Orkestrasyon kimliği

Orkestrasyonun her örneğinde, örnek kimliği olarak da bilinen bir örnek kimliği vardır. Varsayılan olarak, her örnek kimliği otomatik olarak oluşturulan genel olarak benzersiz bir tanımlayıcıdır (GUID). Ancak örnek kimlikleri, kullanıcı tarafından oluşturulan herhangi bir dize değeri de olabilir. Her düzenleme örneği kimliği bir görev hub'ı içinde benzersiz olmalıdır.

Aşağıdaki kurallar örnek kimlikleri için geçerlidir:

1 ile 100 karakter arasında olmalıdır.
Onlar @ ile başlamamalıdır.
/, \, # veya ? karakterlerini içermemelidir.
Denetim karakterleri içermemelidir.

Uyarı

Mümkün olduğunda otomatik olarak oluşturulan örnek kimliklerini kullanın. Kullanıcı tarafından oluşturulan örnek kimlikleri, bir düzenleme örneği ile satın alma siparişi veya belge gibi uygulamaya özgü dış varlıklar arasında bire bir eşlemenin bulunduğu senaryolar için tasarlanmıştır.

Uyarı

Karakter kısıtlama kurallarının gerçek olarak uygulanması, uygulamanın kullandığı depolama sağlayıcısına bağlı olarak farklılık gösterebilir. Doğru davranışı ve uyumluluğu sağlamaya yardımcı olmak için önceki örnek kimliği kurallarını izleyin.

Düzenlemenin örnek kimliği, çoğu örnek yönetimi işlemi için gerekli bir parametredir. Örnek kimlikleri teşhis amaçları için de önemlidir. Örneğin, sorun giderme veya analiz amacıyla Application Insights'ta düzenleme izleme verilerini ararken bunları kullanırsınız. Bu nedenle, oluşturulan örnek kimliklerini daha sonra başvurmayı kolaylaştıran bir dış konuma (veritabanı veya uygulama günlükleri gibi) kaydedin.

Düzenlemenin örnek kimliği, çoğu örnek yönetimi işlemi için gerekli bir parametredir. Örnek kimlikleri tanılama için de önemlidir, bu nedenle oluşturulan örnek kimliklerini daha sonra başvurmayı kolaylaştıran bir dış konuma kaydedin(veritabanı veya uygulama günlükleri gibi).

Güvenilirlik

Orchestrator işlevleri, yürütme durumlarını güvenilir bir şekilde korumak için olay kaynağı tasarım desenini kullanır. Dayanıklı Görev Çerçevesi, bir orkestrasyonun mevcut durumunu doğrudan depolamak yerine, işlev orkestrasyonunun aldığı tüm eylemleri kaydetmek için yalnızca eklenebilir bir depo kullanır. Yalnızca ekleme deposu, tam çalışma zamanı durumunun dökümünü almayla karşılaştırıldığında birçok avantaja sahiptir. Avantajları arasında daha yüksek performans, ölçeklenebilirlik ve yanıt verme hızı yer alır. Ayrıca işlem verileri, tam denetim izleri ve geçmiş için nihai tutarlılık elde edersiniz. Denetim kayıtları güvenilir telafi eylemlerini destekler.

Dayanıklı Görev Çerçevesi, olay kaynağını saydam olarak kullanır. Arka planda bir düzenleyici işlevi C# dilinde await işlecini ve JavaScript ve Python'de yield işlecini kullanır. Bu operatörler, orkestratör iş parçacığı denetimini Durable Task Framework dağıtıcısına geri verir. Java'da, bir görevde .await() çağrılması, denetimi Throwable özel bir örneği aracılığıyla dağıtıcıya geri verir. Dağıtıcı daha sonra orchestrator işlevinin depolamak üzere planladığı tüm yeni eylemleri taahhüt eder. Eylemlere örnek olarak bir veya daha fazla alt işlevi çağırma veya dayanıklı zamanlayıcı ayarlama verilebilir. Şeffaf taahhüt işlemi, düzenleme örneğinin yürütme geçmişini, sadece ekleme esaslı bir günlük gibi çalışarak, tüm yeni olayları depolama alanına ekleyerek günceller. Benzer şekilde, commit işlemi gerçek işi planlamak için depolamada iletiler oluşturur. Bu noktada orchestrator işlevi bellekten kaldırılabilir.

varsayılan olarak, Durable Functions çalışma zamanı durum deposu olarak Azure Storage kullanır, ancak diğer storage sağlayıcıları da desteklenir.

Düzenleme işlevinin daha fazla işi olduğunda (örneğin, bir yanıt iletisi alındığında veya dayanıklı bir süreölçer sona erdiğinde), düzenleyici uyanır ve tüm işlevi baştan yeniden yürüterek yerel durumu yeniden oluşturur. Tekrar yürütme sırasında, kod bir işlevi çağırmaya çalışırsa (veya başka bir zaman uyumsuz iş yaparsa), Durable Task Framework mevcut orkestrasyonun yürütme geçmişine danışır. Etkinliğin zaten yürütüldüğünü ve bir sonuç verdiğini bulursa, bu işlevin sonucunu yeniden yürütür ve düzenleyici kodu çalışmaya devam eder. Tekrarlama, işlev kodu tamamlanana veya yeni bir asenkron çalışma zamanlanana kadar devam eder.

Uyarı

Yeniden yürütme düzeninin doğru ve güvenilir bir şekilde çalışması için orchestrator işlev kodunun belirleyici olması gerekir. Belirsiz düzenleyici kodu çalışma zamanı hatalarına veya diğer beklenmeyen davranışlara neden olabilir. Orchestrator işlevleri için kod kısıtlamaları hakkında daha fazla bilgi için bkz . Orchestrator işlev kodu kısıtlamaları.

Uyarı

Bir orkestratör işlevi günlük iletileri yayıyorsa, tekrarlama davranışı yinelenen günlük iletilerinin üretilmesine neden olabilir. Bu davranışın neden oluştuğu ve bu davranışın nasıl çözümlendiği hakkında bilgi edinmek için bkz. Güvenli günlüğü yeniden yürütme.

Düzenleme geçmişi

Dayanıklı Görev Çerçevesi'nin olay kaynak oluşturma davranışı, yazdığınız orchestrator işlev koduyla yakından ilişkilidir. Aşağıdaki örnekte olduğu gibi bir etkinlik zincirleme düzenleyici işlevine sahip olduğunuzu varsayalım.

Yalıtılmış çalışan modeli

[Function("HelloCities")]
public static async Task<List<string>> Run(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    var outputs = new List<string>();

    outputs.Add(await context.CallActivityAsync<string>("SayHello", "Tokyo"));
    outputs.Add(await context.CallActivityAsync<string>("SayHello", "Seattle"));
    outputs.Add(await context.CallActivityAsync<string>("SayHello", "London"));

    // Return ["Hello Tokyo!", "Hello Seattle!", "Hello London!"].
    return outputs;
}

Sınıf tabanlı model (yalıtılmış çalışan)

Sınıf tabanlı yaklaşım bir kaynak oluşturucu kullanır ve Microsoft.DurableTask.Generators NuGet paketini gerektirir.

using Microsoft.DurableTask;

[DurableTask]
public class HelloCities : TaskOrchestrator<object?, List<string>>
{
    public override async Task<List<string>> RunAsync(
        TaskOrchestrationContext context, object? input)
    {
        var outputs = new List<string>();

        outputs.Add(await context.CallActivityAsync<string>("SayHello", "Tokyo"));
        outputs.Add(await context.CallActivityAsync<string>("SayHello", "Seattle"));
        outputs.Add(await context.CallActivityAsync<string>("SayHello", "London"));

        // Return ["Hello Tokyo!", "Hello Seattle!", "Hello London!"].
        return outputs;
    }
}

İşlem içi model

[FunctionName("HelloCities")]
public static async Task<List<string>> Run(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    var outputs = new List<string>();

    outputs.Add(await context.CallActivityAsync<string>("SayHello", "Tokyo"));
    outputs.Add(await context.CallActivityAsync<string>("SayHello", "Seattle"));
    outputs.Add(await context.CallActivityAsync<string>("SayHello", "London"));

    // Return ["Hello Tokyo!", "Hello Seattle!", "Hello London!"].
    return outputs;
}

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

df.app.orchestration("helloSequence", function* (context) {
    const output = [];
    output.push(yield context.df.callActivity("sayHello", "Tokyo"));
    output.push(yield context.df.callActivity("sayHello", "Seattle"));
    output.push(yield context.df.callActivity("sayHello", "London"));

    // Return ["Hello Tokyo!", "Hello Seattle!", "Hello London!"].
    return output;
});

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

app = df.DFApp(http_auth_level=func.AuthLevel.ANONYMOUS)

@app.orchestration_trigger(context_name="context")
def orchestrator_function(context: df.DurableOrchestrationContext):
    result1 = yield context.call_activity('SayHello', "Tokyo")
    result2 = yield context.call_activity('SayHello', "Seattle")
    result3 = yield context.call_activity('SayHello', "London")
    return [result1, result2, result3]

param($Context)

$output = @()

$output += Invoke-DurableActivity -FunctionName 'SayHello' -Input 'Tokyo'
$output += Invoke-DurableActivity -FunctionName 'SayHello' -Input 'Seattle'
$output += Invoke-DurableActivity -FunctionName 'SayHello' -Input 'London'

$output

@FunctionName("HelloCities")
public String helloCitiesOrchestrator(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    String result = "";
    result += ctx.callActivity("SayHello", "Tokyo", String.class).await() + ", ";
    result += ctx.callActivity("SayHello", "Seattle", String.class).await() + ", ";
    result += ctx.callActivity("SayHello", "London", String.class).await();
    return result;
}

using Microsoft.DurableTask;

[DurableTask]
public class HelloCities : TaskOrchestrator<object?, List<string>>
{
    public override async Task<List<string>> RunAsync(TaskOrchestrationContext context, object? input)
    {
        var outputs = new List<string>();

        outputs.Add(await context.CallActivityAsync<string>("SayHello", "Tokyo"));
        outputs.Add(await context.CallActivityAsync<string>("SayHello", "Seattle"));
        outputs.Add(await context.CallActivityAsync<string>("SayHello", "London"));

        return outputs;
    }
}

import { OrchestrationContext, TOrchestrator } from "@microsoft/durabletask-js";

const helloCities: TOrchestrator = async function* (ctx: OrchestrationContext): any {
    const result1 = yield ctx.callActivity(sayHello, "Tokyo");
    const result2 = yield ctx.callActivity(sayHello, "Seattle");
    const result3 = yield ctx.callActivity(sayHello, "London");
    return [result1, result2, result3];
};

from durabletask import task

def hello_cities(ctx: task.OrchestrationContext, _):
    result1 = yield ctx.call_activity("say_hello", input="Tokyo")
    result2 = yield ctx.call_activity("say_hello", input="Seattle")
    result3 = yield ctx.call_activity("say_hello", input="London")
    return [result1, result2, result3]

import com.microsoft.durabletask.TaskOrchestration;
import com.microsoft.durabletask.TaskOrchestrationContext;

public class HelloCities implements TaskOrchestration {
    @Override
    public void run(TaskOrchestrationContext ctx) {
        String result = "";
        result += ctx.callActivity("SayHello", "Tokyo", String.class).await() + ", ";
        result += ctx.callActivity("SayHello", "Seattle", String.class).await() + ", ";
        result += ctx.callActivity("SayHello", "London", String.class).await();
        ctx.complete(result);
    }
}

Bir etkinlik işlevi zamanlandığında Dayanıklı Görev Çerçevesi işlevin yürütme durumunu çeşitli denetim noktalarına kaydeder. Her denetim noktasında, çerçeve durumu dayanıklı bir depolama arka ucuna kaydeder. Bu durum düzenleme geçmişi olarak adlandırılır.

Geçmiş tablosu

Dayanıklı Görev Çerçevesi genellikle her denetim noktasında aşağıdakileri yapar:

Yürütme geçmişini dayanıklı depolama alanına kaydeder.
Orchestrator'ın çağırmak istediği işlevler için iletileri sıralar.
Dayanıklı zamanlayıcı iletileri gibi düzenleyicinin kendisi için iletileri sıralar.

Denetim noktası tamamlandığında, orkestratör işlevi yapılacak daha fazla iş olana kadar bellekten kaldırılabilir.

Uyarı

Azure Storage, veriler kaydedildiğinde tablo depolama alanı ile kuyruklar arasında veri tutarlılığı hakkında işlem garantisi sağlamaz. Hataları işlemek için Dayanıklı İşlevler Azure Depolama sağlayıcısı nihai tutarlılık desenlerini kullanır. Bu desenler, bir denetim noktasının ortasında kilitlenme veya bağlantı kaybı olması durumunda veri kaybı olmamasını sağlamaya yardımcı olur. Durable Functions Microsoft SQL Server (MSSQL) depolama sağlayıcısı gibi alternatif depolama sağlayıcıları daha güçlü tutarlılık garantileri sağlayabilir.

Daha önce gösterilen işlev tamamlandığında, geçmişi Tablo Depolama'daki aşağıdaki tabloda yer alan verilere benzer. Girdiler açıklama amacıyla kısaltılmıştır.

PartitionKey (InstanceId)	EtkinlikTürü	Zaman Damgası	Giriş	İsim	Result	Statü
eaee885b	Çalıştırma Başlatıldı	2021-05-05T18:45:28.852Z	sıfır	HelloCities
eaee885b	Orchestrator Başlatıldı	2021-05-05T18:45:32.362Z
eaee885b	Görev Planlandı	2021-05-05T18:45:32.670Z		SayHello
eaee885b	OrkestratörTamamlandı	2021-05-05T18:45:32.670Z
eaee885b	Görev Tamamlandı	2021-05-05T18:45:34.201Z			"""Hello Tokyo!"""
eaee885b	Orchestrator Başlatıldı	2021-05-05T18:45:34.232Z
eaee885b	Görev Planlandı	2021-05-05T18:45:34.435Z		SayHello
eaee885b	OrkestratörTamamlandı	2021-05-05T18:45:34.435Z
eaee885b	Görev Tamamlandı	2021-05-05T18:45:34.763Z			"""Hello Seattle!"""
eaee885b	Orchestrator Başlatıldı	2021-05-05T18:45:34.857Z
eaee885b	Görev Planlandı	2021-05-05T18:45:34.857Z		SayHello
eaee885b	OrkestratörTamamlandı	2021-05-05T18:45:34.857Z
eaee885b	Görev Tamamlandı	2021-05-05T18:45:34.919Z			""Merhaba Londra!"""
eaee885b	Orchestrator Başlatıldı	2021-05-05T18:45:35.032Z
eaee885b	OrkestratörTamamlandı	2021-05-05T18:45:35.044Z
eaee885b	İşlemTamamlandı	2021-05-05T18:45:35.044Z			"[""Hello Tokyo!"","Hello Seattle!"",""Hello London!""]"	Tamamlandı

Tablo sütunları aşağıdaki değerleri içerir:

PartitionKey: Orkestrasyonun örnek kimliği.
EventType: Olayın türü. Tüm geçmiş olay türlerinin ayrıntılı açıklamaları için bkz. Durable Task Framework Geçmiş Olayları.
Zaman damgası: Tarihsel olayın Eşgüdümlü Evrensel Saat zaman damgası.
Giriş: İşlevin JSON biçimli girişi.
Ad: Çağrılan işlevin adı.
Sonuç: İşlevin çıkışı, özellikle de dönüş değeri.

Uyarı

Bu tablo hata ayıklama aracı olarak kullanışlıdır, ancak Durable Functions uzantısı geliştikçe biçimi ve içeriği değişebilir.

Bir görevin tamamlanmasını bekledikten sonra her işlev sürdürüldüğünde, Dayanıklı Görev Çerçevesi orkestratör işlevini baştan yeniden çalıştırır. Her yeniden çalıştırmada, şu anki zaman uyumsuz görevin tamamlanıp tamamlanmadığını belirlemek için yürütme geçmişine başvurur. Eğer yürütme geçmişi görevin zaten tamamlandığını gösteriyorsa, platform bu görevin çıkışını yineleyerek sonraki göreve geçer. Bu işlem, yürütme geçmişinin tamamı yeniden oynatılana kadar devam eder. Geçerli yürütme geçmişi yeniden yürütüldükten sonra yerel değişkenler önceki değerlerine geri yüklenir.

Özellikler ve desenler

Aşağıdaki bölümlerde orchestrator işlevlerinin özellikleri ve desenleri açıklanmaktadır.

Orchestrator işlevlerindeki alt orkestrasyonlar

Orchestrator işlevleri etkinlik işlevlerini çağırabilir, ancak diğer orchestrator işlevlerini de çağırabilir. Örneğin, bir orkestratör işlevleri kitaplığından daha büyük bir orkestrasyon oluşturabilirsiniz. Alternatif olarak, bir orchestrator işlevinin birden çok örneğini paralel olarak çalıştırabilirsiniz.

Daha fazla bilgi ve örnekler için Dayanıklı İşlevler (Azure İşlevleri) içindeki alt düzenlemelere bakın.

Dayanıklı zamanlayıcılar

Orkestrasyonlar, gecikmeleri uygulamak veya eşzamansız işlemlerde zaman aşımı işlemeyi yapılandırmak için dayanıklı zamanlayıcılar zamanlayabilir. Dilde yerel sleep API'ler yerine düzenleyici işlevlerinde dayanıklı zamanlayıcılar kullanın.

Daha fazla bilgi ve örnekler için bkz . Dayanıklı İşlevlerde Zamanlayıcılar (Azure İşlevleri).

Dış olaylar

Orchestrator işlevleri, dış olayların bir düzenleme örneğini güncelleştirmesini bekleyebilir. Bu Dayanıklı İşlevler özelliği genellikle insan etkileşimlerini veya diğer dış geri çağırmaları işlemek için kullanışlıdır.

Daha fazla bilgi ve örnekler için bkz. Durable Functions (Azure Functions)'da dış olayları işleme.

Hata yönetimi

Orchestrator işlevleri, programlama dilinin hata işleme özelliklerini kullanabilir. gibi try/catch mevcut desenler düzenleme kodunda desteklenir.

Orchestrator işlevleri, çağırdıkları etkinlik veya alt düzenleyici işlevlerine yeniden deneme ilkeleri de ekleyebilir. Bir etkinlik veya alt düzenleyici işlevi özel durumla başarısız olursa, belirtilen yeniden deneme ilkesi yürütmeyi otomatik olarak geciktirebilir ve belirtilen sayıda yeniden deneyebilir.

Uyarı

Orchestrator işlevinde işlenmeyen bir özel durum varsa, orkestrasyon örneği bir Failed durumunda tamamlanır. Düzenleme örneği başarısız olduktan sonra yeniden denenemez.

Daha fazla bilgi ve örnekler için bkz. Durable Functions (Azure Functions)'da işleme hataları.

Kritik bölümler (Durable Functions 2.x, şu anda yalnızca .NET)

Orkestrasyon örnekleri tek iş parçacıklı olduğundan, yarış koşulları bir orkestrasyon içinde bir sorun teşkil etmez. Ancak, düzenleme işlemleri dış sistemlerle etkileşime geçtiğinde yarış koşulları mümkündür. Dış sistemlerle etkileşim kurarken yarış koşullarını azaltmak için, orchestrator işlevleri .NET'te bir yöntem kullanarak LockAsync tanımlayabilir.

Aşağıdaki örnek kod, kritik bir bölümü tanımlayan bir orchestrator işlevini gösterir. Kritik bölüme girmek için yöntemini kullanır LockAsync . Bu yöntem, kilit durumunu kalıcı olarak yöneten dayanıklı bir varlığa bir veya daha fazla başvuru geçirmeyi gerektirir. Bu düzenlemenin yalnızca tek bir örneği, kodu kritik bölümde aynı anda yürütebilir.

[FunctionName("Synchronize")]
public static async Task Synchronize(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    var lockId = new EntityId("LockEntity", "MyLockIdentifier");
    using (await context.LockAsync(lockId))
    {
        // Critical section. Only one orchestration can enter at a time.
    }
}

LockAsync yöntemi dayanıklı kilitleri alır ve serbest bırakıldığında kritik bölümü sonlandıran bir IDisposable nesnesi döndürür. Bu IDisposable sonuç, kritik bölümün sentaktik bir gösterimini elde etmek için bir using blokla birlikte kullanılabilir. Düzenleyici işlevi kritik bir bölüme girdiğinde, bu kod bloğunu yalnızca bir örnek yürütebilir. Kritik bölüme girmeye çalışan diğer tüm örnekler, önceki örnek kritik bölümden çıkana kadar engellenir.

Kritik bölüm özelliği, dayanıklı varlıklardaki değişiklikleri koordine etmek için de kullanışlıdır. Kritik bölümler hakkında daha fazla bilgi için bkz. Varlık koordinasyonu.

Uyarı

Kritik bölümler Durable Functions 2.0'da kullanılabilir. Şu anda yalnızca .NET işlem içi düzenlemelerde bu özellik uygulanıyor. Varlıklar ve kritik bölümler, .NET yalıtılmış çalışan düzenlemeleri için Durable Functions'ta henüz kullanılamıyor.

HTTP uç noktalarına yapılan çağrılar (Dayanıklı İşlevler 2.x)

Orchestrator işlev kodu kısıtlamaları bölümünde açıklandığı gibi Orchestrator işlevlerinin G/Ç işlemleri gerçekleştirmesine izin verilmez. Bu sınırlamanın tipik geçici çözümü, bir etkinlik işlevinde G/Ç işlemleri yapması gereken tüm kodları sarmalamadır. Dış sistemlerle etkileşim kuran düzenlemelerde http çağrıları yapmak ve sonuçları düzenlemeye döndürmek için etkinlik işlevleri sıklıkla kullanılır.

Orchestrator işlevleri, bu yaygın düzeni kolaylaştırmak için CallHttpAsync yöntemini kullanarak HTTP API'lerini doğrudan çağırabilir.

Yalıtılmış çalışan modeli

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

    // Make an HTTP GET request to the specified endpoint.
    DurableHttpResponse response = await context.CallHttpAsync(
        method: HttpMethod.Get,
        uri: url,
        content: null,
        retryOptions: null);

    if ((int)response.StatusCode == 400)
    {
        // Handle error codes.
    }
}

İşlem içi model

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

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

    if ((int)response.StatusCode == 400)
    {
        // Handle error codes.
    }
}

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

df.app.orchestration("checkSiteAvailable", function* (context) {
    const url = context.df.getInput();
    var res = yield context.df.callHttp({ method: "GET", url });
    if (res.statusCode >= 400) {
        // Handle error codes.
    }
});

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

app = df.DFApp(http_auth_level=func.AuthLevel.ANONYMOUS)

@app.orchestration_trigger(context_name="context")
def orchestrator_function(context: df.DurableOrchestrationContext):
    url = context.get_input()
    res = yield context.call_http('GET', url)
    if res['statusCode'] >= 400:
        # Handle error codes.

Yöntem, temel istek/yanıt desenlerini desteklemenin yanı sıra ortak zaman uyumsuz HTTP 202 yoklama desenlerinin otomatik olarak işlenmesini de destekler. Ayrıca , yönetilen kimlikleri kullanarak dış hizmetlerle kimlik doğrulamayı destekler.

Daha fazla bilgi ve ayrıntılı örnekler için bkz. HTTP özellikleri.

Uyarı

HTTP uç noktalarını doğrudan orchestrator işlevlerinden çağırmak Durable Functions 2.0 ve sonraki sürümlerde kullanılabilir.

Etkinlik işlevlerine birden çok parametre geçirme

Bir etkinlik işlevine doğrudan birden çok parametre geçirmek mümkün değildir. Öneri, bir nesne dizisi veya bileşik nesneler iletmektir.

Yalıtılmış çalışan modeli

.NET'te, birden çok parametre geçirmek için kayıt gibi serileştirilebilir bir bileşik tür kullanın.

public record CourseInfo(string Major, int UniversityYear);

[Function("GetCourseRecommendations")]
public static async Task<object> RunOrchestrator(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    int universityYear = context.GetInput<int>();
    CourseInfo courseInfo = new("ComputerScience", universityYear);
    object courseRecommendations = await context.CallActivityAsync<object>(
        "CourseRecommendations", courseInfo);
    return courseRecommendations;
}

İşlem içi model

.NET'te birden çok parametre geçirmek için serileştirilebilir bileşik tür kullanın. Aşağıdaki örnek basit bir sınıf kullanır:

public class CourseInfo
{
    public string Major { get; set; }
    public int UniversityYear { get; set; }
}

[FunctionName("GetCourseRecommendations")]
public static async Task<object> RunOrchestrator(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    var input = new CourseInfo
    {
        Major = "ComputerScience",
        UniversityYear = context.GetInput<int>()
    };

    object courseRecommendations = await context.CallActivityAsync<object>(
        "CourseRecommendations",
        input);
    return courseRecommendations;
}

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

df.app.orchestration("getWeatherOrchestrator", function* (context) {
    const location = {
        city: "Seattle",
        state: "WA",
    };
    const weather = yield context.df.callActivity("getWeather", location);

    // ...
});

df.app.activity("getWeather", {
    handler: async (input) => {
        const { city, state } = input; // Destructure properties into variables.
        // ...
    }
});

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

app = df.DFApp(http_auth_level=func.AuthLevel.ANONYMOUS)

@app.orchestration_trigger(context_name="context")
def orchestrator_function(context: df.DurableOrchestrationContext):
    location = {'city': 'Seattle', 'state': 'WA'}

    weather = yield context.call_activity("GetWeather", location)
    # ...

@app.activity_trigger(input_name="location")
def GetWeather(location):
    city = location['city']
    state = location['state']
    return f"Hello {city}, {state}!"

param($Context)

$location = @{
    City = 'Seattle'
    State  = 'WA'
}

Invoke-DurableActivity -FunctionName 'GetWeather' -Input $location

# ...

@FunctionName("GetWeatherOrchestrator")
public String getWeatherOrchestrator(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    var location = new Location();
    location.city = "Seattle";
    location.state = "WA";
    String weather = ctx.callActivity("GetWeather", location, String.class).await();
    return weather;
}

.NET'te çoklu parametreyi tek bir birleşik nesne olarak geçirmek için kayıt türlerini veya tüpleri kullanabilirsiniz.

using Microsoft.DurableTask;

public record LocationInfo(string City, string State);

[DurableTask]
public class GetWeatherOrchestration : TaskOrchestrator<object?, string>
{
    public override async Task<string> RunAsync(TaskOrchestrationContext context, object? input)
    {
        var location = new LocationInfo("Seattle", "WA");
        string weather = await context.CallActivityAsync<string>("GetWeather", location);
        return weather;
    }
}

import { OrchestrationContext, TOrchestrator } from "@microsoft/durabletask-js";

const getWeatherOrchestrator: TOrchestrator = async function* (ctx: OrchestrationContext): any {
    const location = { city: "Seattle", state: "WA" };
    const weather = yield ctx.callActivity(getWeather, location);
    // ...
};

from durabletask import task

def get_weather_orchestrator(ctx: task.OrchestrationContext, _):
    location = {"city": "Seattle", "state": "WA"}
    weather = yield ctx.call_activity("get_weather", input=location)
    # ...

import com.microsoft.durabletask.TaskOrchestration;
import com.microsoft.durabletask.TaskOrchestrationContext;

public class GetWeatherOrchestration implements TaskOrchestration {
    @Override
    public void run(TaskOrchestrationContext ctx) {
        Location location = new Location();
        location.city = "Seattle";
        location.state = "WA";
        String weather = ctx.callActivity("GetWeather", location, String.class).await();
        ctx.complete(weather);
    }
}

Sonraki Adımlar

Orchestrator işlev kodu kısıtlamaları

Dayanıklı Görev SDK'larını kullanmaya başlama

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2026-04-22

Dayanıklı orkestrasyonlar

Orkestrasyon kimliği

Güvenilirlik

Düzenleme geçmişi

Geçmiş tablosu

Özellikler ve desenler

Orchestrator işlevlerindeki alt orkestrasyonlar

Dayanıklı zamanlayıcılar

Dış olaylar

Hata yönetimi

Kritik bölümler (Durable Functions 2.x, şu anda yalnızca .NET)

HTTP uç noktalarına yapılan çağrılar (Dayanıklı İşlevler 2.x)

Etkinlik işlevlerine birden çok parametre geçirme

Sonraki Adımlar

Geri Bildirim

Ek kaynaklar