Exploring Patterns in Azure Sturdy Features

Azure Sturdy Features is a serverless extension of Azure Features that allows the creation of stateful and sturdy workflows. Whereas it will not be instantly apparent, a storage account is an important element when operating Azure Sturdy Features. On this article, we are going to discover why a storage account is important for operating Sturdy Features and the way it performs a basic function within the functioning of those workflows.

  1. Sturdy Job Framework State Administration
    Azure Sturdy Features depends on the Sturdy Job Framework (DTF), which is an open-source framework for constructing sturdy, stateful workflows. DTF requires a storage mechanism to persist the state of orchestrations and entities throughout executions. A storage account serves as this underlying storage layer. It ensures that the state of your orchestrations and entities is sturdy and may survive throughout restarts and failures.
  2. Orchestration Historical past
    Once you create an Azure Sturdy Perform, the framework robotically shops the execution historical past and checkpoints of the orchestration. This historical past is essential for the framework to take care of the state of the workflow, permitting it to renew from the place it left off in case of interruptions or failures. The historical past knowledge consists of details about perform calls, enter and output values, and different related metadata.
  3. Massive Payloads and Output
    Sturdy Features usually cope with enter and output knowledge that may be bigger than the payload measurement restrict of Azure Features (round 100 MB). By utilizing a storage account to retailer these payloads, Sturdy Features can effectively deal with massive knowledge with out encountering measurement constraints.
  4. Distributed Locks and Coordination
    In eventualities the place Sturdy Features have to coordinate and synchronize a number of situations or handle concurrency, a storage account is used for distributed locking and coordination. It ensures that just one occasion of a perform executes a specific process or acquires a lock at a time, stopping conflicts and race circumstances.
  5. Customized Stateful Entities
    Sturdy Entities, a function of Azure Sturdy Features, can help you create and handle stateful objects. These entities persist their state in a storage account, making them accessible and manageable throughout a number of perform invocations. And not using a storage account, the persistence and state administration of those entities can be unimaginable.

Exploring Completely different Patterns in Azure Sturdy Features

Azure Sturdy Features is a strong serverless extension to Azure Features that permits you to construct scalable, stateful, and event-driven workflows. With Sturdy Features, you possibly can create workflows that coordinate the execution of a number of capabilities in a dependable and environment friendly method. On this article, we are going to discover some frequent patterns and use instances for Azure Sturdy Features, together with code snippets that can assist you get began.


Earlier than we dive into the patterns, be sure to have the next conditions:

  1. An Azure subscription.
  2. Azure Features instruments and SDK put in (Azure Features CLI).
  3. A code editor (e.g., Visual Studio Code).
  4. Primary data of Azure Features.

1. Chaining Features

One of many basic patterns in Sturdy Features is perform chaining, the place you execute a sequence of capabilities in a selected order. This sample is beneficial for eventualities like knowledge processing pipelines.

public async Job<Checklist<string>> RunOrchestrator(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
    var outcomes = new Checklist<string>();

    // Name Function1
    outcomes.Add(await context.CallActivityAsync<string>("Function1", null));

    // Name Function2 with the results of Function1
    outcomes.Add(await context.CallActivityAsync<string>("Function2", outcomes[0]));

    // Name Function3 with the results of Function2
    outcomes.Add(await context.CallActivityAsync<string>("Function3", outcomes[1]));

    return outcomes;

2. Fan-Out/Fan-In

This sample is used when you could execute a number of capabilities concurrently after which combination their outcomes. It is helpful for eventualities like parallel processing.

public async Job<Checklist<string>> RunFanOutFanInOrchestrator(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
    var duties = new Checklist<Job<string>>();

    for (int i = 0; i < 5; i++)
        duties.Add(context.CallActivityAsync<string>("ProcessData", i.ToString()));

    await Job.WhenAll(duties);

    var outcomes = duties.Choose(t => t.Outcome).ToList();
    return outcomes;

3. Human Interplay and Approval

You should use Sturdy Features for human interplay, corresponding to sending approval requests by way of e-mail or Slack and ready for a response earlier than continuing.

public async Job<string> RunApprovalOrchestrator(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
    // Ship an approval request
    var approvalResponse = await context.WaitForExternalEvent<string>("ApprovalEvent");

    if (approvalResponse == "Authorised")
        // Proceed with the workflow
        return "Workflow Authorised!";
        // Deal with rejection logic
        return "Workflow Rejected!";

4. Monitoring and Timeout Dealing with

You should use Sturdy Features to observe the progress of long-running duties and deal with timeouts.

public async Job<string> RunTimeoutOrchestrator(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
    var timeoutDuration = TimeSpan.FromMinutes(30);

    utilizing (var cts = new CancellationTokenSource())
        var timeoutTask = context.CreateTimer(context.CurrentUtcDateTime.Add(timeoutDuration), cts.Token);

        var resultTask = context.CallActivityAsync<string>("LongRunningTask", null);

        var winner = await Job.WhenAny(resultTask, timeoutTask);

        if (winner == resultTask)
            // Job accomplished efficiently
            return await resultTask;
            // Deal with timeout logic
            return "Job Timed Out!";

5. Stateful Entities

Sturdy Entities can help you create and handle stateful objects that can be utilized throughout a number of perform invocations.

public static void Run(
    [EntityTrigger] IDurableEntityContext ctx)
    var currentValue = ctx.GetState<int>();

    swap (ctx.OperationName)
        case "add":
            var valueToAdd = ctx.GetInput<int>();
            currentValue += valueToAdd;
        case "get":
        case "reset":
            currentValue = 0;



Azure Sturdy Features present a variety of patterns and capabilities for constructing dependable and scalable workflows. Whether or not you could chain capabilities, deal with human interactions, implement timeouts, or create stateful entities, Sturdy Features will help you streamline your serverless purposes. Experiment with these patterns and adapt them to your particular use instances to harness the complete energy of Azure Sturdy Features in your initiatives.

Know extra about our firm at Skrots. Know extra about our companies at Skrots Providers, Additionally checkout all different blogs at Weblog at Skrots

Show More

Related Articles

Leave a Reply

Your email address will not be published. Required fields are marked *

Back to top button