İşlev zincirleme

İşlev zincirleme, bir işlev dizisini sırayla çalıştırdığınız bir desendir. Bir işlevin çıkışını bir sonrakinin girişine geçirmek yaygın bir işlemdir. Bu makalede, Durable Functions hızlı başlangıcı (C#, JavaScript tamamladığınızda oluşturduğunuz zincirleme dizisi açıklanmaktadır. TypeScript, Python, PowerShell veya Java). Durable Functions genel bakış hakkında daha fazla bilgi edinin.

Önkoşullar

İşlev zincirleme, bir etkinlik dizisini sırayla çalıştırdığınız bir desendir. Bir etkinliğin çıkışını bir sonraki etkinliğin girişine geçirmek yaygın bir işlemdir. Bu makalede .NET, JavaScript, Python ve Java için Dayanıklı Görev SDK'larının zincirleme sırası açıklanmaktadır.

Functions

Bu makalede, örnek uygulamadaki şu işlevler açıklanmaktadır:

E1_HelloSequence: Bir orchestrator işlevi, sırayla birden çok kez E1_SayHello çağırır. Her çıkışı depolar ve sonuçları kaydeder.
E1_SayHello: Dizenin başlangıcına "Hello" ekleyen bir etkinlik işlevi .
HttpStart: Düzenleyicinin bir örneğini başlatan HTTP ile tetiklenen dayanıklı istemci işlevi.

Bu makalede, örnek uygulamadaki şu bileşenler açıklanmaktadır:

GreetingOrchestration, greetingOrchestrator, function_chaining_orchestratorveya ActivityChaining: Birden çok etkinliği sırayla çağıran bir düzenleyici. Her çıkışı depolar ve sonuçları kaydeder.
Etkinlik işlevleri: Girişi işleyen ve sonuçları döndüren etkinlikler. Her etkinlik, giriş üzerinde basit bir dönüştürme gerçekleştirir.
İstemci: Bir orkestratör örneğini başlatan ve sonucu bekleyen bir istemci uygulaması.

Orchestrator

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

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

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

Tüm C# düzenleme işlevlerinin DurableOrchestrationContext derlemesinde bulunan Microsoft.Azure.WebJobs.Extensions.DurableTask türünde bir parametresi olmalıdır. Bu bağlam nesnesi, diğer etkinlik işlevlerini çağırmanızı ve yöntemini kullanarak giriş parametrelerini geçirmenizi CallActivityAsync sağlar.

Kod, farklı parametre değerleriyle sırayla üç kez çağırır E1_SayHello . Her çağrının dönüş değeri, işlevin outputs sonunda döndürülen listeye eklenir.

V3 programlama modeli

function.json

Visual Studio Code veya Azure portalında geliştirme yapıyorsanız, işte bu orchestrator function.json dosyası.

{
  "bindings": [
    {
      "name": "context",
      "type": "orchestrationTrigger",
      "direction": "in"
    }
  ],
  "disabled": false
}

Anahtar ayarı orchestrationTrigger bağlama türüdür. Tüm düzenleyici işlevleri bu tetikleyici türünü kullanmalıdır.

Uyarı

Düzenleyici işlevleri için "G/Ç yok" kuralını uygulamak amacıyla, orchestrationTrigger tetikleyici bağlamasıyla birlikte giriş ya da çıkış bağlamalarını kullanmayın. Diğer giriş veya çıkış bağlamalarına ihtiyacınız varsa, bunları orkestratörün çağırdığı işlevlerde activityTrigger kullanın. Daha fazla bilgi için bkz. orchestrator işlev kodu kısıtlamaları.

index.js

Orchestrator işlevi şu şekildedir:

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

module.exports = df.orchestrator(function* (context) {
    context.log("Starting chain sample");
    const output = [];
    output.push(yield context.df.callActivity("E1_SayHello", "Tokyo"));
    output.push(yield context.df.callActivity("E1_SayHello", "Seattle"));
    output.push(yield context.df.callActivity("E1_SayHello", "London"));

    return output;
});

Tüm JavaScript uyumlama işlevleri durable-functions modülünü içermelidir. JavaScript'te Durable Functions yazmanızı sağlayan bir kitaplıktır. Orchestrator işlevi ile diğer JavaScript işlevleri arasındaki üç önemli fark:

Orchestrator işlevi bir oluşturucu işlevidir.
İşlev, durable-functions modülünün orchestrator yöntemine yapılan bir çağrıda sarılır (burada df).
İşlev senkron. orchestrator yöntemi context.done çağırdığı için, işlevi döndürür.

context nesnesi, diğer df işlevlerini çağırmanıza ve callActivity yöntemini kullanarak giriş parametrelerini iletmenize olanak tanıyan dayanıklı bir df düzenleme bağlamı nesnesi içerir. Kod, E1_SayHello'u farklı parametre değerleriyle sırayla üç kez çağırır. Yürütmenin, zaman uyumsuz etkinlik işlev çağrılarının dönüşünü beklemesi gerektiğini belirtmek için yield kullanılır. Her çağrının dönüş değeri, işlevin outputs sonunda döndürülen diziye eklenir.

V4 programlama modeli

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

const helloActivityName = "sayHello";

df.app.orchestration("helloSequence", function* (context) {
    context.log("Starting chain sample");

    const output = [];
    output.push(yield context.df.callActivity(helloActivityName, "Tokyo"));
    output.push(yield context.df.callActivity(helloActivityName, "Seattle"));
    output.push(yield context.df.callActivity(helloActivityName, "Cairo"));

    return output;
});

Tüm JavaScript orkestrasyon işlevleri durable-functions modülünü içermelidir. Bu modül JavaScript'te Durable Functions yazmanızı sağlar. V4 düğüm programlama modelini kullanmak için v3.x sürümünü durable-functions yüklemeniz gerekir.

Orchestrator işlevi ile diğer JavaScript işlevleri arasındaki iki önemli fark:

Orchestrator işlevi bir oluşturucu işlevidir.
İşlev senkron. Fonksiyon bir değer döndürür.

context nesnesi, diğer aktivite işlevlerini çağırmanıza ve callActivity yöntemini kullanarak giriş parametrelerini geçirmenize olanak tanıyan dayanıklı bir df düzenleme bağlam nesnesi içerir. Kod, sayHello'yi farklı parametre değerleriyle sırayla üç kez çağırır ve yield kullanarak yürütmenin zaman uyumsuz etkinlik işlev çağrılarının dönmesini beklemesi gerektiğini belirtir. Her çağrının dönüş değeri, işlevin outputs sonunda döndürülen diziye eklenir.

Not

Python Durable Functions yalnızca İşlevler 3.0 çalışma zamanı için kullanılabilir.

function.json

Geliştirme için Visual Studio Code veya Azure portalı kullanıyorsanız, orchestrator işlevi için function.json dosyasının içeriği aşağıdadır. Çoğu orchestrator function.json dosyası neredeyse tam olarak böyle görünür.

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "name": "context",
      "type": "orchestrationTrigger",
      "direction": "in"
    }
  ]
}

Önemli olan bağlama türüdür orchestrationTrigger . Tüm düzenleyici işlevleri bu tetikleyici türünü kullanmalıdır.

Uyarı

Orchestrator işlevlerinin "G/Ç yok" kuralına uymak için orchestrationTrigger tetikleyici bağlamasını kullanırken herhangi bir giriş veya çıkış bağlaması kullanmayın. Diğer giriş veya çıkış bağlamaları gerekiyorsa, bunun yerine düzenleyici tarafından çağrılan işlevler bağlamında activityTrigger kullanılmalıdır. Daha fazla bilgi için orchestrator işlev kodu kısıtlamaları makalesine bakın.

init.py

Orchestrator işlevi şu şekildedir:

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


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

main = df.Orchestrator.create(orchestrator_function)

Tüm Python düzenleme işlevleri durable-functions paketini içermelidir. Python'da Durable Functions yazmanızı sağlayan bir kitaplıktır. Orchestrator işleviyle diğer Python işlevleri arasındaki iki önemli fark:

Orchestrator işlevi bir oluşturucu işlevidir.
Dosya, main = df.Orchestrator.create(<orchestrator function name>) orchestrator işlevini dosyanın sonunda belirterek kaydeder. Bu, dosyada bildirilen diğer yardımcı işlevlerden ayırt edilebilmesine yardımcı olur.

context nesnesi, diğer etkinlik işlevlerini çağırmanızı ve yöntemini kullanarak giriş parametrelerini geçirmenizi call_activity sağlar. Kod, E1_SayHello'yi farklı parametre değerleriyle sırayla üç kez çağırır ve yield kullanarak yürütmenin zaman uyumsuz etkinlik işlev çağrılarının dönmesini beklemesi gerektiğini belirtir. Her çağrının dönüş değeri işlevin sonunda döndürülür.

Bu kod, sırayla üç etkinliği çağıran ve her çıkışı bir sonraki etkinliğe geçiren bir düzenleyici gösterir:

using Microsoft.DurableTask;

[DurableTask]
public class GreetingOrchestration : TaskOrchestrator<string, string>
{
    public override async Task<string> RunAsync(TaskOrchestrationContext context, string name)
    {
        // Step 1: Say hello to the person
        string greeting = await context.CallActivityAsync<string>(nameof(SayHelloActivity), name);

        // Step 2: Process the greeting
        string processedGreeting = await context.CallActivityAsync<string>(nameof(ProcessGreetingActivity), greeting);

        // Step 3: Finalize the response
        string finalResponse = await context.CallActivityAsync<string>(nameof(FinalizeResponseActivity), processedGreeting);

        return finalResponse;
    }
}

Tüm .NET orkestratörleri TaskOrchestrator<TInput, TOutput>'dan devralır. TaskOrchestrationContext kullanarak CallActivityAsync etkinlikleri çağırmanızı sağlar. Kod, her etkinliğin önceki etkinliğin çıkışını aldığı sırayla üç etkinliği çağırır.

Aşağıdaki kod, sırayla üç etkinliği çağıran bir düzenleyiciyi gösterir:

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

const greetingOrchestrator: TOrchestrator = async function* (
  ctx: OrchestrationContext,
  name: string
): any {
  // Step 1: Say hello to the person
  const greeting: string = yield ctx.callActivity(sayHello, name);

  // Step 2: Process the greeting
  const processedGreeting: string = yield ctx.callActivity(processGreeting, greeting);

  // Step 3: Finalize the response
  const finalResponse: string = yield ctx.callActivity(finalizeResponse, processedGreeting);

  return finalResponse;
};

Tüm JavaScript orkestratörleri, etkinlikleri çağırmak için async function* kullanan (yield) oluşturucu işlevlerdir. Orkestrasyon bağlamının callActivity yöntemi, etkinlik yürütmesini zamanlar. Kod, her etkinliğin çıkışını sonrakine geçirerek sırayla üç etkinliği çağırır.

Aşağıdaki kod, sırayla üç etkinliği çağıran bir düzenleyiciyi gösterir:

from durabletask import task

# Orchestrator function
def function_chaining_orchestrator(ctx: task.OrchestrationContext, name: str) -> str:
    """Orchestrator that demonstrates function chaining pattern."""

    # Call first activity
    greeting = yield ctx.call_activity(say_hello, input=name)

    # Call second activity with the result from first activity
    processed_greeting = yield ctx.call_activity(process_greeting, input=greeting)

    # Call third activity with the result from second activity
    final_response = yield ctx.call_activity(finalize_response, input=processed_greeting)

    return final_response

Tüm Python düzenleyicileri, etkinlikleri çağırmak için yield kullanan oluşturucu işlevleridir. Düzenleme bağlamının call_activity yöntemi, etkinlik yürütülmesini planlar. Kod, her etkinliğin çıkışını sonrakine geçirerek sırayla üç etkinliği çağırır.

Aşağıdaki kod, sırayla üç etkinliği çağıran bir düzenleyiciyi gösterir:

import com.microsoft.durabletask.*;

DurableTaskGrpcWorker worker = DurableTaskSchedulerWorkerExtensions.createWorkerBuilder(connectionString)
    .addOrchestration(new TaskOrchestrationFactory() {
        @Override
        public String getName() { return "ActivityChaining"; }

        @Override
        public TaskOrchestration create() {
            return ctx -> {
                String input = ctx.getInput(String.class);

                // Call activities in sequence, passing output from one to the next
                String x = ctx.callActivity("Reverse", input, String.class).await();
                String y = ctx.callActivity("Capitalize", x, String.class).await();
                String z = ctx.callActivity("ReplaceWhitespace", y, String.class).await();

                ctx.complete(z);
            };
        }
    })
    .build();

Java'de, düzenleyiciler TaskOrchestrationFactory kullanılarak tanımlanır. Bağlamın callActivity yöntemi aktivite yürütmeyi planlar ve await() sonucu bekler. Kod, her etkinliğin çıkışını sonrakine geçirerek sırayla üç etkinliği çağırır.

Activity

[FunctionName("E1_SayHello")]
public static string SayHello([ActivityTrigger] IDurableActivityContext context)
{
    string name = context.GetInput<string>();
    return $"Hello {name}!";
}

Etkinlikler özniteliğini ActivityTrigger kullanır. "IDurableActivityContext, GetInput<T> ile giriş okumak gibi etkinlik eylemleri için kullanın."

E1_SayHello bir selamlama stringini biçimlendirir.

IDurableActivityContext yerine, doğrudan aktivite fonksiyonuna geçirilen tipe bağlanın. Örneğin:

[FunctionName("E1_SayHello_DirectInput")]
public static string SayHelloDirectInput([ActivityTrigger] string name)
{
    return $"Hello {name}!";
}

V3 programlama modeli

E1_SayHello/function.json

function.json dosyası, öğesinin dosyasına benzer, ancak bağlama türü yerine bağlama türü kullanır.

{
  "bindings": [
    {
      "name": "name",
      "type": "activityTrigger",
      "direction": "in"
    }
  ],
  "disabled": false
}

Not

Düzenleme işlevinin çağırdığı tüm etkinlik işlevleri için activityTrigger bağlamasını kullanın.

uygulaması E1_SayHello , nispeten önemsiz bir dize biçimlendirme işlemidir.

E1_SayHello/index.js

module.exports = function (context) {
    context.done(null, `Hello ${context.bindings.name}!`);
};

Düzenleme işlevinin aksine, bir etkinlik işlevinin özel kuruluma ihtiyacı yoktur. Orchestrator, activityTrigger adı altında context.bindings nesnesine girdi gönderir; bu durumda, context.bindings.name. Dışarı aktarılan işlevin parametresini, örnekte olduğu gibi doğrudan erişim sağlamak için bağlama adı olarak ayarlayın.

V4 programlama modeli

sayHello bir selamlama dizesini biçimlendirir.

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

const helloActivityName = "sayHello";

df.app.activity(helloActivityName, {
    handler: function (input) {
        return `Hello ${input}`;
    },
});

Düzenleme işlevinin aksine, bir etkinlik işlevinin özel kuruluma ihtiyacı yoktur. Orkestratör, girişi işlevin ilk bağımsız değişkeni olarak geçirir. İkinci bağımsız değişken, bu örnekte kullanılmayan çağrı bağlamıdır.

E1_SayHello/function.json

Etkinlik işlevi için dosyası, E1_HelloSequence öğesine benzer, ancak orchestrationTrigger bağlama türü yerine activityTrigger bağlama türü kullanır.

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "name": "name",
      "type": "activityTrigger",
      "direction": "in"
    }
  ]
}

Not

Orkestrasyon işlevi tarafından çağrılan tüm etkinlik işlevleri activityTrigger bağlamasını kullanmalıdır.

uygulaması E1_SayHello , nispeten önemsiz bir dize biçimlendirme işlemidir.

E1_SayHello/init.py

def main(name: str) -> str:
    return f"Hello {name}!"

Orchestrator işlevinin aksine, bir etkinlik işlevinin özel bir kuruluma ihtiyacı yoktur. Orchestrator işlevi tarafından ona geçirilen girişe, işlevin parametresi olarak doğrudan erişilebilir.

Dayanıklı Görev SDK'sındaki etkinlikler TaskActivity<TInput, TOutput>'dan devralınır.

using Microsoft.DurableTask;
using Microsoft.Extensions.Logging;

[DurableTask]
public class SayHelloActivity : TaskActivity<string, string>
{
    private readonly ILogger<SayHelloActivity> _logger;

    public SayHelloActivity(ILogger<SayHelloActivity> logger)
    {
        _logger = logger;
    }

    public override Task<string> RunAsync(TaskActivityContext context, string name)
    {
        _logger.LogInformation("Activity SayHello called with name: {Name}", name);
        return Task.FromResult($"Hello {name}!");
    }
}

[DurableTask]
public class ProcessGreetingActivity : TaskActivity<string, string>
{
    public override Task<string> RunAsync(TaskActivityContext context, string greeting)
    {
        return Task.FromResult($"{greeting} How are you today?");
    }
}

[DurableTask]
public class FinalizeResponseActivity : TaskActivity<string, string>
{
    public override Task<string> RunAsync(TaskActivityContext context, string response)
    {
        return Task.FromResult($"{response} I hope you're doing well!");
    }
}

gibi ILoggerhizmetleri almak için bağımlılık ekleme özelliğini kullanın. Çalışan ile etkinliğini kaydetmek için [DurableTask] özniteliğini ekleyin.

Dayanıklı Görev SDK'sı etkinlikleri basit işlevlerdir:

import { ActivityContext } from "@microsoft/durabletask-js";

const sayHello = async (_ctx: ActivityContext, name: string): Promise<string> => {
  return `Hello ${name}!`;
};

const processGreeting = async (_ctx: ActivityContext, greeting: string): Promise<string> => {
  return `${greeting} How are you today?`;
};

const finalizeResponse = async (_ctx: ActivityContext, response: string): Promise<string> => {
  return `${response} I hope you're doing well!`;
};

Düzenleyicilerin aksine, etkinlikler HTTP çağrıları, veritabanı sorguları ve dosya erişimi gibi G/Ç işlemlerini gerçekleştirebilir. Giriş doğrudan parametre olarak geçirilir.

Dayanıklı Görev SDK'sı etkinlikleri basit işlevlerdir:

from durabletask import task

def say_hello(ctx: task.ActivityContext, name: str) -> str:
    """First activity that greets the user."""
    return f"Hello {name}!"

def process_greeting(ctx: task.ActivityContext, greeting: str) -> str:
    """Second activity that processes the greeting."""
    return f"{greeting} How are you today?"

def finalize_response(ctx: task.ActivityContext, response: str) -> str:
    """Third activity that finalizes the response."""
    return f"{response} I hope you're doing well!"

Düzenleyicilerin aksine, etkinlikler HTTP çağrıları, veritabanı sorguları ve dosya erişimi gibi G/Ç işlemlerini gerçekleştirebilir. Giriş doğrudan parametre olarak geçirilir.

Java etkinlikleri TaskActivityFactory kullanılarak tanımlanır:

import com.microsoft.durabletask.*;

.addActivity(new TaskActivityFactory() {
    @Override
    public String getName() { return "Reverse"; }

    @Override
    public TaskActivity create() {
        return ctx -> {
            String input = ctx.getInput(String.class);
            StringBuilder builder = new StringBuilder(input);
            builder.reverse();
            return builder.toString();
        };
    }
})
.addActivity(new TaskActivityFactory() {
    @Override
    public String getName() { return "Capitalize"; }

    @Override
    public TaskActivity create() {
        return ctx -> ctx.getInput(String.class).toUpperCase();
    }
})
.addActivity(new TaskActivityFactory() {
    @Override
    public String getName() { return "ReplaceWhitespace"; }

    @Override
    public TaskActivity create() {
        return ctx -> {
            String input = ctx.getInput(String.class);
            return input.trim().replaceAll("\\s", "-");
        };
    }
})

Her etkinliği addActivity kullanarak çalışan oluşturucuya kaydedin. Etkinlikler G/Ç işlemleri gerçekleştirebilir ve sonuçları düzenleyiciye döndürebilir.

Müşteri

bir istemci işlevinden orchestrator işlev örneğini başlatın. HttpStart örneklerini başlatmak için HTTP tetiklemeli işlevi kullanın.

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

Düzenleyicilerle etkileşime geçmek için bir DurableClient giriş bağlaması ekleyin. İstemciyi kullanarak bir düzenleme başlatın ve yeni düzenlemenin durumunu denetlemek için URL'ler içeren bir HTTP yanıtı döndürin.

V3 programlama modeli

HttpStart/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
  }

Düzenleyicilerle etkileşime geçmek için bir durableClient giriş bağlaması ekleyin.

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

df.getClient kullanarak bir DurableOrchestrationClient nesnesi edinin. İstemciyi kullanarak bir düzenleme başlatın ve yeni düzenlemenin durumunu denetlemek için URL'ler içeren bir HTTP yanıtı döndürin.

V4 programlama modeli

const df = require("durable-functions");
const { app } = require("@azure/functions");

app.http("httpStart", {
    route: "orchestrators/{orchestratorName}",
    extraInputs: [df.input.durableClient()],
    handler: async (request, context) => {
        const client = df.getClient(context);
        const body = await request.json();
        const instanceId = await client.startNew(request.params.orchestratorName, { input: body });

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

        return client.createCheckStatusResponse(request, instanceId);
    },
});

Düzenleyicileri yönetmek ve bunlarla etkileşime geçmek için bir durableClient giriş bağlaması ekleyin. İşlevi kaydederken extraInputs argümanında bağlamayı belirtin. df.input.durableClient() çağrısı yaparak durableClient girişini alın.

df.getClient kullanarak bir DurableClient nesnesi edinin. İstemciyi kullanarak bir düzenleme başlatın ve yeni düzenlemenin durumunu denetlemek için URL'ler içeren bir HTTP yanıtı döndürin.

HttpStart/function.json

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

Düzenleyicilerle etkileşime geçmek için işlevin bir giriş bağlaması içermesi durableClient gerekir.

HttpStart/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)
    instance_id = await client.start_new(req.route_params["functionName"], None, None)

    logging.info(f"Started orchestration with ID = '{instance_id}'.")

    return client.create_check_status_response(req, instance_id)

Durable Functions istemcisi oluşturmak için DurableOrchestrationClient oluşturucuyu kullanın. İstemciyi kullanarak bir düzenleme başlatın ve yeni düzenlemenin durumunu denetlemek için URL'ler içeren bir HTTP yanıtı döndürin.

İstemci uygulamasından düzenleme başlatın. Müşteri orkestrasyonu zamanlar ve tamamlanmasını bekleyebilir.

using Microsoft.DurableTask.Client;

// Create the client
var client = DurableTaskClientBuilder.UseDurableTaskScheduler(connectionString).Build();

// Schedule a new orchestration instance
string instanceId = await client.ScheduleNewOrchestrationInstanceAsync(
    nameof(GreetingOrchestration),
    input: "World");

Console.WriteLine($"Started orchestration with ID: {instanceId}");

// Wait for the orchestration to complete
OrchestrationMetadata result = await client.WaitForInstanceCompletionAsync(
    instanceId,
    getInputsAndOutputs: true);

Console.WriteLine($"Orchestration completed with result: {result.ReadOutputAs<string>()}");

Dayanıklı Görev Zamanlayıcı'ya bağlanmak için bağlantı dizesi kullanarak DurableTaskClient oluşturun. ScheduleNewOrchestrationInstanceAsync kullanarak bir orkestrasyon başlatın ve WaitForInstanceCompletionAsync tamamlanmasını bekleyin.

import {
  DurableTaskAzureManagedClientBuilder,
} from "@microsoft/durabletask-js-azuremanaged";

const connectionString =
  process.env.DURABLE_TASK_SCHEDULER_CONNECTION_STRING ||
  "Endpoint=http://localhost:8080;Authentication=None;TaskHub=default";

const client = new DurableTaskAzureManagedClientBuilder()
  .connectionString(connectionString)
  .build();

// Schedule a new orchestration instance
const instanceId = await client.scheduleNewOrchestration(greetingOrchestrator, "World");
console.log(`Started orchestration with ID: ${instanceId}`);

// Wait for the orchestration to complete
const state = await client.waitForOrchestrationCompletion(instanceId, true, 30);
console.log(`Orchestration completed with result: ${state?.serializedOutput}`);

Dayanıklı Görev Zamanlayıcı'ya bağlanmak için bağlantı dizesi kullanarak DurableTaskAzureManagedClientBuilder oluşturun. scheduleNewOrchestration bir orkestrasyonu başlatmak ve tamamlanmasını beklemek için waitForOrchestrationCompletion kullanın.

from durabletask.azuremanaged.client import DurableTaskSchedulerClient

# Create the client
client = DurableTaskSchedulerClient(
    host_address=endpoint,
    secure_channel=endpoint != "http://localhost:8080",
    taskhub=taskhub_name,
    token_credential=credential
)

# Schedule a new orchestration instance
instance_id = client.schedule_new_orchestration(
    function_chaining_orchestrator,
    input="World"
)

print(f"Started orchestration with ID: {instance_id}")

# Wait for the orchestration to complete
result = client.wait_for_orchestration_completion(instance_id, timeout=60)

if result and result.runtime_status == OrchestrationStatus.COMPLETED:
    print(f"Orchestration completed with result: {result.serialized_output}")

DurableTaskSchedulerClient, Dayanıklı Görev Zamanlayıcı'ya bağlanır. schedule_new_orchestration bir orkestrasyon başlatmak için ve wait_for_orchestration_completion tamamlanmasını beklemek için kullanın.

import com.microsoft.durabletask.*;
import com.microsoft.durabletask.azuremanaged.DurableTaskSchedulerClientExtensions;

// Create the client
DurableTaskClient client = DurableTaskSchedulerClientExtensions
    .createClientBuilder(connectionString)
    .build();

// Schedule a new orchestration instance
String instanceId = client.scheduleNewOrchestrationInstance(
    "ActivityChaining",
    new NewOrchestrationInstanceOptions().setInput("Hello, world!"));

System.out.println("Started orchestration with ID: " + instanceId);

// Wait for the orchestration to complete
OrchestrationMetadata result = client.waitForInstanceCompletion(
    instanceId,
    Duration.ofSeconds(30),
    true);

System.out.println("Orchestration completed with result: " + result.readOutputAs(String.class));

connection string kullanarak DurableTaskClient oluşturun. scheduleNewOrchestrationInstance kullanarak bir düzenleme başlatın ve tamamlanmasını beklemek için waitForInstanceCompletion kullanın.

Örneği çalıştırma

Orkestrasyonu E1_HelloSequence çalıştırmak için, bu HTTP POST isteğini HttpStart işlevine gönderin.

POST http://{host}/orchestrators/E1_HelloSequence

Not

Önceki HTTP kod parçacığı, örneğin host.json dosyasının tüm HTTP tetikleyicisi işlev URL'lerinden varsayılan api/ ön eki kaldırmış olduğunu varsayar. Bu yapılandırmayı örneğin host.json dosyasında bulabilirsiniz.

Örneğin, myfunctionapp adlı bir işlev uygulamasında örneği çalıştırıyorsanız, myfunctionapp.azurewebsites.net değerini {host} ile değiştirin.

İstek HTTP 202 döndürür (kısa olması için kırpılır):

HTTP/1.1 202 Accepted
Content-Length: 719
Content-Type: application/json; charset=utf-8
Location: http://{host}/runtime/webhooks/durabletask/instances/96924899c16d43b08a536de376ac786b?taskHub=DurableFunctionsHub&connection=Storage&code={systemKey}

(...trimmed...)

Orkestrasyon kuyrukları oluşturulur ve hemen çalışmaya başlar. Yürütme durumunu denetlemek için üst bilgideki Location URL'yi kullanın.

GET http://{host}/runtime/webhooks/durabletask/instances/96924899c16d43b08a536de376ac786b?taskHub=DurableFunctionsHub&connection=Storage&code={systemKey}

Yanıt düzenleme durumunu gösterir. Hızlı bir şekilde tamamlandığından, örnek genellikle Tamamlandı durumundadır ve şuna benzer bir yanıt döndürür (kısa süre için kırpılır):

HTTP/1.1 200 OK
Content-Length: 179
Content-Type: application/json; charset=utf-8

{"runtimeStatus":"Completed","input":null,"output":["Hello Tokyo!","Hello Seattle!","Hello London!"],"createdTime":"2017-06-29T05:24:57Z","lastUpdatedTime":"2017-06-29T05:24:59Z"}

Örneği runtimeStatusTamamlandı'dır ve output orchestrator işlevi yürütmesinin JSON serileştirilmiş sonucunu içerir.

Not

, queueTriggerveya eventHubTriggergibi timerTriggerdiğer tetikleyici türleri için benzer başlangıç mantığı uygulayın.

İşlev yürütme günlüklerini gözden geçirin. İşlev, E1_HelloSequenceorkestrasyon güvenilirliğinde açıklanan yeniden yürütme davranışı nedeniyle birden fazla kez başlar ve tamamlanır. Ancak etkinlik işlevi yürütmeleri yeniden yürütülmediğinden E1_SayHello yalnızca üç kez çalışır.

Örneği çalıştırmak için şunları yapmanız gerekir:

Dayanıklı Görev Zamanlayıcı öykünücüsü 'ni başlatın (yerel geliştirme için):

docker run -d -p 8080:8080 -p 8082:8082 --name dts-emulator mcr.microsoft.com/dts/dts-emulator:latest

Düzenleyiciyi ve etkinlikleri kaydetmek için çalışanı başlatın.
Bir düzenleme zamanlamak ve sonucu beklemek için istemciyi çalıştırın.

İstemci çıktısı zincirleme orkestrasyon sonucunu gösterir.

Started orchestration with ID: abc123
Orchestration completed with result: "Hello World! How are you today? I hope you're doing well!"

Çalışan günlük kayıtları, her etkinliğin ardışık olarak çalıştığını ve çıktısını bir sonraki etkinliğe aktardığını gösterir.

Sonraki adımlar

Bu örnek, basit bir işlev zincirleme orkestrasyonunu göstermektedir. Ardından, fan-out/fan-in desenini uygulayın.

Fan-out/fan-in örneğini çalıştırın

Bu örnek, basit bir işlev zincirleme orkestrasyonunu göstermektedir. Ardından, daha fazla desen keşfedin.

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

Tam JavaScript SDK örnekleri için bkz . Dayanıklı Görev JavaScript SDK örnekleri.

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2026-03-11

Aracılığıyla paylaş

İşlev zincirleme

Önkoşullar

Functions

Orchestrator

Activity

Müşteri

Örneği çalıştırma

Sonraki adımlar

Geri Bildirim

Ek kaynaklar