Verzování orchetrace v Durable Functions (Azure Functions) – veřejná ukázka

Správa verzí orchestrace řeší hlavní výzvu při nasazování změn do funkcí orchestrátoru při zachování deterministického prováděcího modelu, který Durable Functions vyžaduje. Bez této funkce by zásadní změny logiky orchestratoru nebo signatur funkcí aktivit způsobovaly selhání běžících instancí orchestrace během přehrání, jelikož by narušily požadavek determinismu, který zajišťuje spolehlivé provedení orchestrace. Tato integrovaná funkce poskytuje automatickou izolaci verzí s minimální konfigurací. Je nezávislá na back-endu, takže ji můžou používat aplikace, které využívají některého z poskytovatelů úložiště Durable Function, včetně Plánovače úloh Durable.

Note

Pokud jako uživatelé Plánovače úloh Durable používáte sady SDK Durable Task místo Durable Functions, měli byste se podívat na článek o verzování sad SDK Durable Task.

Terminology

Tento článek používá dva související, ale odlišné termíny:

• Funkce orchestratoru (nebo jednoduše orchestrátor): Odkazuje na kód funkce, který definuje logiku pracovního postupu – šablonu nebo podrobný plán pro způsob provádění pracovního postupu.
• Instance orchestrace (nebo jednoduše "orchestrace"): Odkazuje na konkrétní běžící proces orchestrační funkce s vlastním stavem, ID instance a vstupy. Více instancí orchestrace může běžet souběžně ze stejné funkce orchestrátoru.

Pochopení tohoto rozdílu je zásadní pro správu verzí orchestrace, kdy kód funkce orchestrátoru obsahuje logiku podporující verzi, zatímco instance orchestrace jsou při vytváření trvale přidružené ke konkrétní verzi.

Jak to funguje

Funkce verzování orchestrace funguje na těchto základních principech:

• Přidružení verze: Při vytvoření instance orchestrace je k ní trvale přidružena verze.

• Spouštění s podporou verzí: Kód funkce orchestratoru může odpovídajícím způsobem zkoumat hodnotu verze přidruženou k aktuální instanci orchestrace a provádění větví.

• Zpětná kompatibilita: Pracovní procesy s novějšími verzemi orchestratoru můžou pokračovat ve spouštění instancí orchestrace vytvořených staršími verzemi orchestrátoru.

• Forward Protection: Modul runtime automaticky brání pracovníkům, kteří používají starší verze orchestrátoru, aby spouštěly orchestrace spuštěné novějšími verzemi orchestratoru.

Important

Správa verzí orchestrace je aktuálně ve verzi Public Preview.

Požadavky

Před použitím správy verzí orchestrace se ujistěte, že máte požadované verze balíčků pro váš programovací jazyk.

Pokud používáte jazyk non-.NET (JavaScript, Python, PowerShell nebo Java) s sadami rozšíření, musí vaše aplikace funkcí odkazovat na sadu rozšíření bundle verze 4.26.0 nebo novější. Nakonfigurujte rozsah extensionBundle takhost.json, aby minimální verze byla alespoň 4.26.0, například:

{
    "version": "2.0",
    "extensionBundle": {
        "id": "Microsoft.Azure.Functions.ExtensionBundle",
        "version": "[4.26.0, 5.0.0)"
    }
}

Podrobnosti o výběru a aktualizaci verzí sady najdete v dokumentaci ke konfiguraci sady rozšíření .

C#

Použijte Microsoft.Azure.Functions.Worker.Extensions.DurableTask verzi 1.5.0 nebo novější.

JavaScript

Použijte durable-functions verzi 3.2.0 nebo novější.

Python

Použijte azure-functions-durable verzi 1.3.3 nebo novější.

PowerShell

Použijte AzureFunctions.PowerShell.Durable.SDK verzi 2.0.0 nebo novější. Ujistěte se, že používáte samostatnou sadu Durable Functions PowerShell SDK.

Java

Použijte durabletask-azure-functions verzi 1.6.1 nebo novější.

Základní použití

Nejběžnějším případem použití pro verzování orchestrace je situace, kdy potřebujete provést zásadní změny v logice orchestrátoru, zatímco stávající instance orchestrace běží s jejich původní verzí. Stačí aktualizovat defaultVersion ve vašem host.json a upravit kód orchestrátoru tak, aby zkontroloval verzi orchestrace a podle toho vykonal větev. Pojďme si projít požadované kroky.

Note

Chování popsané v této části je zaměřeno na nejběžnější situace, a to je to, co poskytuje výchozí konfigurace. V případě potřeby je ale možné ho upravit (podrobnosti najdete v části Rozšířené využití ).

Krok 1: výchozí konfigurace verze

Pokud chcete nakonfigurovat výchozí verzi pro orchestrace, musíte přidat nebo aktualizovat defaultVersion nastavení v souboru v host.json projektu Azure Functions:

{
  "extensions": {
    "durableTask": {
      "defaultVersion": "<version>"
    }
  }
}

Řetězec verze může postupovat podle libovolného formátu, který vyhovuje vaší strategii správy verzí:

• Vícečástové verzování: "1.0.0", "2.1.0"
• Jednoduché číslování: "1", "2"
• Na základě data: "2025-01-01"
• Vlastní formát: "v1.0-release"

Po nastavení defaultVersionbudou všechny nové instance orchestrace trvale přidruženy k této verzi.

Pravidla porovnání verzí

Pokud je vybrána strategie Strict nebo CurrentOrOlder (viz Shoda verzí), runtime porovná verzi instance orchestrace s hodnotou defaultVersion workeru podle následujících pravidel:

• Prázdné nebo null verze jsou považovány za stejné.
• Prázdná nebo null verze je považována za starší než jakákoli definovaná verze.
• Pokud se obě verze dají analyzovat jako System.Version, použije se CompareTo metoda.
• V opačném případě se provede porovnání řetězců bez rozlišování malých a velkých písmen.

Krok 2: Logika funkce orchestratoru

K implementaci logiky pracující s verzí ve funkci orchestrátoru můžete použít kontextový parametr předaný orchestrátoru pro přístup k aktuální verzi instance orchestrace, která umožňuje rozvětvení logiky orchestrátoru na základě verze.

Important

Při implementaci logiky podporující verze je důležité zachovat přesnou logiku orchestrátoru pro starší verze. Jakékoli změny sekvence, pořadí nebo podpisu volání aktivit v existujících verzích mohou narušit deterministické přehrávání a způsobit selhání probíhajících orchestrací nebo nesprávné výsledky. Cesty kódu staré verze musí po nasazení zůstat beze změny.

C#

[Function("MyOrchestrator")]
public static async Task<string> RunOrchestrator(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    if (context.Version == "1.0")
    {
        // Original logic for version 1.0
        ...
    }
    else if (context.Version == "2.0")
    {
        // New logic for version 2.0
        ...
    }
    ...
}

JavaScript

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

df.app.orchestrator(function* (context) {
    if (context.df.version === "1.0") {
        // Original logic for version 1.0
        // ...
    } else if (context.df.version === "2.0") {
        // New logic for version 2.0
        // ...
    }
    // ...
});

Python

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

myApp = df.DFApp(http_auth_level=func.AuthLevel.FUNCTION)

@myApp.orchestration_trigger(context_name="context")
def orchestrator_function(context: df.DurableOrchestrationContext):
    if context.version == "1.0":
        # Original logic for version 1.0
        # ...
    elif context.version == "2.0":
        # New logic for version 2.0
        # ...
    # ...

PowerShell

param($Context)

if ($Context.Version -eq "1.0") {
    # Original logic for version 1.0
    # ...
} elseif ($Context.Version -eq "2.0") {
    # New logic for version 2.0
    # ...
}
# ...

Java

@FunctionName("MyOrchestrator")
public String myOrchestrator(
    @DurableOrchestrationTrigger(name = "context") 
    TaskOrchestrationContext context) {
    
    String version = context.getVersion();
    if ("1.0".equals(version)) {
        // Original logic for version 1.0
        // ...
    } else if ("2.0".equals(version)) {
        // New logic for version 2.0
        // ...
    }
    // ...
}

Note

Vlastnost context.Version je jen pro čtení a odráží verzi, která byla trvale přidružena k instanci orchestrace při jeho vytvoření. Tuto hodnotu nelze změnit během provádění orchestrace. Pokud chcete zadat verzi jiným způsobem, host.jsonnež je , můžete to udělat při spuštění instance orchestrace pomocí rozhraní API klienta orchestrace (viz Spuštění nových orchestrací a dílčích orchestrací s konkrétními verzemi).

Tip

Pokud právě začínáte používat správu verzí orchestrace a už máte orchestrace v testovací verzi vytvořené dříve, než jste zadali defaultVersion, můžete toto nastavení stále přidat defaultVersion do svého host.json počítače. U všech dříve vytvořených orchestrací context.Version vrátí null (nebo ekvivalentní hodnotu závislou na jazyce), což vám umožňuje strukturovat logiku orchestrátoru tak, aby zpracovávala jak starší verze (nulová verze), tak nové verzované orchestrace. Následují hodnoty závislé na jazyce, které je třeba zkontrolovat pro starší případ:

• C#: context.Version == null nebo context.Version is null
• JavaScript: context.df.version == null
• Python: context.version is None
• PowerShell: $null -eq $Context.Version
• Java: context.getVersion() == null Všimněte si také, že zadání "defaultVersion": null v host.json je ekvivalentní tomu, když ho vůbec neuvedete.

Tip

V závislosti na vaší situaci můžete preferovat větvení na různých úrovních. Místní změnu můžete provést přesně tam, kde je tato změna požadovaná, podobně jako v příkladu. Alternativně můžete rozvětvit na vyšší úrovni, například na úrovni celé implementace orchestrátoru, což vede k určité duplikaci kódu, ale může zachovat přehledný tok provádění. Je na vás, abyste zvolili přístup, který nejlépe vyhovuje vašemu scénáři a stylu psaní kódu.

Co se stane po nasazení

Jakmile nasadíte aktualizovanou funkci orchestrátoru s logikou nové verze, můžete očekávat toto:

• Koexistence pracovního procesu: Pracovní procesy obsahující nový kód funkce orchestrátoru se spustí, zatímco někteří pracovníci se starým kódem jsou potenciálně stále aktivní.

• Přiřazení verze pro nové instance: Všechny nové orchestrace a dílčí orchestrace vytvořené novými pracovními procesy získají verzi přiřazenou defaultVersion k nim.

• Kompatibilita nových pracovníků: Noví pracovníci budou schopni zpracovat jak nově vytvořené orchestrace, tak i dříve existující orchestrace, protože změny provedené v kroku 2 předchozí části zajišťují zpětnou kompatibilitu prostřednictvím verzově orientované logiky větvení.

• Omezení pro staré pracovníky: Staří pracovníci budou mít povoleno zpracovávat pouze orchestrace s verzí , která je rovna nebo nižší než verze zadaná ve vlastní defaultVersion v host.json, protože se neočekává, že mají kód orchestrátoru kompatibilní s novějšími verzemi. Toto omezení zabraňuje chybám spuštění a neočekávanému chování.

Note

Správa verzí orchestrace nemá vliv na životní cyklus pracovní jednotky. Platforma Azure Functions spravuje zřizování pracovníků a jejich vyřazování na základě pravidelných pravidel v závislosti na možnostech hostování.

Příklad: Nahrazení aktivity v posloupnosti

Tento příklad ukazuje, jak nahradit jednu aktivitu jinou aktivitou uprostřed sekvence pomocí správy verzí orchestrace.

Verze 1.0

konfiguracehost.json:

{
  "extensions": {
    "durableTask": {
      "defaultVersion": "1.0"
    }
  }
}

Funkce Orchestrator:

C#

[Function("ProcessOrderOrchestrator")]
public static async Task<string> ProcessOrder(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    var orderId = context.GetInput<string>();
    
    await context.CallActivityAsync("ValidateOrder", orderId);
    await context.CallActivityAsync("ProcessPayment", orderId);
    await context.CallActivityAsync("ShipOrder", orderId);
    
    return "Order processed successfully";
}

JavaScript

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

df.app.orchestrator(function* (context) {
    const orderId = context.df.getInput();
    
    yield context.df.callActivity("ValidateOrder", orderId);
    yield context.df.callActivity("ProcessPayment", orderId);
    yield context.df.callActivity("ShipOrder", orderId);
    
    return "Order processed successfully";
});

Python

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

myApp = df.DFApp(http_auth_level=func.AuthLevel.FUNCTION)

@myApp.orchestration_trigger(context_name="context")
def orchestrator_function(context: df.DurableOrchestrationContext):
    order_id = context.get_input()
    
    yield context.call_activity("ValidateOrder", order_id)
    yield context.call_activity("ProcessPayment", order_id)
    yield context.call_activity("ShipOrder", order_id)
    
    return "Order processed successfully"

PowerShell

param($Context)

$orderId = $Context.Input

Invoke-DurableActivity -FunctionName "ValidateOrder" -Input $orderId
Invoke-DurableActivity -FunctionName "ProcessPayment" -Input $orderId
Invoke-DurableActivity -FunctionName "ShipOrder" -Input $orderId

return "Order processed successfully"

Java

@FunctionName("ProcessOrderOrchestrator")
public String processOrder(
    @DurableOrchestrationTrigger(name = "context") 
    TaskOrchestrationContext context) {
    
    String orderId = context.getInput(String.class);
    
    context.callActivity("ValidateOrder", orderId).await();
    context.callActivity("ProcessPayment", orderId).await();
    context.callActivity("ShipOrder", orderId).await();
    
    return "Order processed successfully";
}

Verze 2.0 se zpracováním slev

konfiguracehost.json:

{
  "extensions": {
    "durableTask": {
      "defaultVersion": "2.0"
    }
  }
}

Funkce Orchestrator:

C#

using DurableTask.Core.Settings;

[Function("ProcessOrderOrchestrator")]
public static async Task<string> ProcessOrder(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    var orderId = context.GetInput<string>();

    await context.CallActivityAsync("ValidateOrder", orderId);

    if (VersioningSettings.CompareVersions(context.Version, "1.0") <= 0)
    {
        // Preserve original logic for existing instances
        await context.CallActivityAsync("ProcessPayment", orderId);
    }
    else // a higher version (including 2.0)
    {
        // New logic with discount processing (replaces payment processing)
        await context.CallActivityAsync("ApplyDiscount", orderId);
        await context.CallActivityAsync("ProcessPaymentWithDiscount", orderId);
    }
    
    await context.CallActivityAsync("ShipOrder", orderId);

    return "Order processed successfully";
}

JavaScript

const df = require("durable-functions");
import semver from 'semver';

df.app.orchestrator(function* (context) {
    const orderId = context.df.getInput();

    yield context.df.callActivity("ValidateOrder", orderId);

    if (compareVersions(context.df.version, "1.0") <= 0) {
        // Preserve original logic for existing instances
        yield context.df.callActivity("ProcessPayment", orderId);
    } else {
        // New logic with discount processing (replaces payment processing)
        yield context.df.callActivity("ApplyDiscount", orderId);
        yield context.df.callActivity("ProcessPaymentWithDiscount", orderId);
    }
    
    yield context.df.callActivity("ShipOrder", orderId);

    return "Order processed successfully";
});

function compareVersions(version1, version2) {
  // Feel free to implement your own version comparison logic
  const v1 = semver.coerce(version1);
  const v2 = semver.coerce(version2);

  if (!v1 || !v2) {
    throw new Error(`Invalid version string(s): "${version1}" vs "${version2}"`);
  }
  return semver.compare(v1, v2);
}

Python

import azure.functions as func
import azure.durable_functions as df
from packaging import version

myApp = df.DFApp(http_auth_level=func.AuthLevel.FUNCTION)

@myApp.orchestration_trigger(context_name="context")
def orchestrator_function(context: df.DurableOrchestrationContext):
    order_id = context.get_input()

    yield context.call_activity("ValidateOrder", order_id)

    if compare_versions(context.version, "1.0") <= 0:
        # Preserve original logic for existing instances
        yield context.call_activity("ProcessPayment", order_id)
    else:
        # New logic with discount processing (replaces payment processing)
        yield context.call_activity("ApplyDiscount", order_id)
        yield context.call_activity("ProcessPaymentWithDiscount", order_id)
    
    yield context.call_activity("ShipOrder", order_id)

    return "Order processed successfully"

def compare_versions(version1, version2):
    # Feel free to implement your own version comparison logic
    v1 = version.parse(version1)
    v2 = version.parse(version2)

    if v1 < v2:
        return -1
    elif v1 > v2:
        return 1
    return 0

PowerShell

param($Context)

$orderId = $Context.Input

Invoke-DurableActivity -FunctionName "ValidateOrder" -Input $orderId

if (Compare-Version $Context.Version "1.0" -le 0) {
    # Preserve original logic for existing instances
    Invoke-DurableActivity -FunctionName "ProcessPayment" -Input $orderId
} else {
    # New logic with discount processing (replaces payment processing)
    Invoke-DurableActivity -FunctionName "ApplyDiscount" -Input $orderId
    Invoke-DurableActivity -FunctionName "ProcessPaymentWithDiscount" -Input $orderId
}

Invoke-DurableActivity -FunctionName "ShipOrder" -Input $orderId

return "Order processed successfully"

function Compare-Version([string]$version1, [string]$version2) {
    # Feel free to implement your own version comparison logic
    $v1 = [Version]$version1
    $v2 = [Version]$version2

    if ($v1 -lt $v2) { return -1 }
    elseif ($v1 -gt $v2) { return 1 }
    else { return 0 }
}

Java

import org.apache.maven.artifact.versioning.ComparableVersion;

@FunctionName("ProcessOrderOrchestrator")
public String processOrder(
    @DurableOrchestrationTrigger(name = "taskOrchestrationContext") 
    TaskOrchestrationContext context) {
    
    String orderId = context.getInput(String.class);

    context.callActivity("ValidateOrder", orderId).await();

    if (compareVersions(context.getVersion(), "1.0") <= 0) {
        // Preserve original logic for existing instances
        context.callActivity("ProcessPayment", orderId).await();
    } else {
        // New logic with discount processing (replaces payment processing)
        context.callActivity("ApplyDiscount", orderId).await();
        context.callActivity("ProcessPaymentWithDiscount", orderId).await();
    }
    
    context.callActivity("ShipOrder", orderId).await();

    return "Order processed successfully";
}

private int compareVersions(String version1, String version2) {
    // Feel free to implement your own version comparison logic
    ComparableVersion v1 = new ComparableVersion(version1);
    ComparableVersion v2 = new ComparableVersion(version2);
    return v1.compareTo(v2);
}

Pokročilé využití

V případě složitějších scénářů správy verzí můžete nakonfigurovat další nastavení, která určují, jak modul runtime zpracovává shody verzí a neshody.

Tip

Pro většinu scénářů použijte výchozí konfiguraci (CurrentOrOlder s Reject) a povolte tak bezpečné postupné nasazení při zachování stavu orchestrace během přechodů verzí. Doporučujeme pokračovat s pokročilou konfigurací jenom v případě, že máte specifické požadavky, které nelze splnit s výchozím chováním.

Porovnávání verzí

Nastavení versionMatchStrategy určuje, jak modul runtime odpovídá verzím orchestrace při načítání funkcí orchestrátoru. Řídí, které orchestrační instance může pracovník zpracovat na základě kompatibility verzí.

Configuration

{
  "extensions": {
    "durableTask": {
      "defaultVersion": "<version>",
      "versionMatchStrategy": "CurrentOrOlder"
    }
  }
}

Dostupné strategie

• None (nedoporučuje se): Zcela ignorovat verzi orchestrace. Veškerá přijatá práce se zpracovává bez ohledu na verzi. Tato strategie efektivně zakazuje kontrolu verzí a umožňuje všem pracovníkům zpracovávat jakoukoli instanci orchestrace.

• Strict: Zpracovávejte pouze úlohy z orchestrací s přesně stejnou verzí jako verze určená defaultVersion ve host.json pracovníka. Tato strategie poskytuje nejvyšší úroveň izolace verzí, ale vyžaduje pečlivou koordinaci nasazení, aby nedocházelo k osamoceným orchestracím. Důsledky neshody verzí jsou popsány v části Zpracování neshod verzí .

• CurrentOrOlder (výchozí): Zpracování úloh z orchestrací, jejichž verze je menší nebo rovna verzi určené defaultVersion v pracovní jednotce host.json. Tato strategie umožňuje zpětnou kompatibilitu, což novějším pracovníkům umožňuje zpracovávat orchestrace spuštěné staršími verzemi orchestrátoru a zároveň zabránit starším pracovníkům ve zpracování novějších orchestrací. Důsledky neshody verzí jsou popsány v části Zpracování neshod verzí .

Zpracování neshod verzí

Nastavení versionFailureStrategy určuje, co se stane, když verze instance orchestrace neodpovídá aktuální defaultVersionverzi .

Configuration:

{
  "extensions": {
    "durableTask": {
      "defaultVersion": "<version>",
      "versionFailureStrategy": "Reject"
    }
  }
}

Dostupné strategie:

• Reject (výchozí): Nezpracovávejte orchestraci. Instance orchestrace zůstává v aktuálním stavu a můžete ji později opakovat, jakmile bude k dispozici kompatibilní pracovní proces. Tato strategie je nejbezpečnější možností, protože zachovává stav orchestrace.

• Fail: Orchestrace se nezdaří. Tato strategie okamžitě ukončí instanci orchestrace se stavem selhání, což může být vhodné ve scénářích, kdy neshody verzí značí vážné problémy s nasazením.

Spouštění nových orchestrací a dílčích orchestrací s konkrétními verzemi

Ve výchozím nastavení jsou všechny nové instance orchestrace vytvořeny s aktuální hodnotou defaultVersion, jak je uvedeno ve vaší host.json konfiguraci. Můžete ale mít scénáře, kdy potřebujete vytvořit orchestrace s konkrétní verzí, i když se liší od aktuálního výchozího nastavení.

Kdy použít konkrétní verze:

• Postupné migrace: Chcete dál vytvářet orchestrace se starší verzí i po nasazení novější verze.
• Testovací scénáře: Potřebujete otestovat konkrétní chování verzí v produkčním prostředí.
• Situace vrácení zpět: Musíte se dočasně vrátit k vytváření instancí s předchozí verzí.
• Pracovní postupy specifické pro jednotlivé verze: Různé obchodní procesy vyžadují různé verze orchestrace.

Výchozí verzi můžete přepsat zadáním konkrétní hodnoty verze při vytváření nových instancí orchestrace pomocí klientských rozhraní API orchestrace. To umožňuje jemně odstupňovanou kontrolu nad tím, jakou verzi každá nová instance orchestrace používá.

C#

[Function("HttpStart")]
public static async Task<HttpResponseData> HttpStart(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestData req,
    [DurableClient] DurableTaskClient client,
    FunctionContext executionContext)
{
    var options = new StartOrchestrationOptions
    {
        Version = "1.0"
    };
    
    string instanceId = await client.ScheduleNewOrchestrationInstanceAsync("ProcessOrderOrchestrator", orderId, options);

    // ...
}

JavaScript

Spuštění orchestrace s verzí odlišnou od aktuální specifikované v defaultVersion ve vašem host.json není v jazyce JavaScript v současné době podporováno.

Python

Spuštění orchestrace s konkrétní verzí odlišnou od aktuálního defaultVersion zadaného v host.json pythonu se v současné době nepodporuje.

PowerShell

Spuštění orchestrace s konkrétní verzí, která se liší od aktuální defaultVersion zadané ve vašem host.json prostředí, není v PowerShellu v současné době podporováno.

Java

@FunctionName("HttpStart")
public HttpResponseMessage httpStart(
    @HttpTrigger(name = "req", methods = {HttpMethod.GET, HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) 
    HttpRequestMessage<Optional<String>> request,
    @DurableClientInput(name = "durableContext") 
    DurableClientContext durableContext,
    final ExecutionContext context) {
    
    DurableTaskClient client = durableContext.getClient();

    NewOrchestrationInstanceOptions options = new NewOrchestrationInstanceOptions().setVersion("1.0");

    String instanceId = client.scheduleNewOrchestrationInstance("ProcessOrderOrchestrator", orderId, options);

    // ...
}

V rámci funkce orchestrátoru můžete také spustit dílčí orchestrace s konkrétními verzemi:

C#

[Function("MainOrchestrator")]
public static async Task<string> RunMainOrchestrator(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    var subOptions = new SubOrchestratorOptions
    {
        Version = "1.0"
    };
    
    var result = await context.CallSubOrchestratorAsync<string>("ProcessPaymentOrchestrator", orderId, subOptions);
    
    // ...
}

JavaScript

Spuštění dílčí orchestrace s konkrétní verzí, která se liší od aktuální verze zadané ve vašem defaultVersion, se v současné době nepodporuje v JavaScriptu.

Python

Spuštění dílčí orchestrace s konkrétní verzí odlišnou od aktuálního defaultVersion uvedeného ve vašem host.json se v Pythonu v současné době nepodporuje.

PowerShell

Spuštění dílčí orchestrace s konkrétní verzí, která se liší od aktuálního defaultVersion zadaného v host.json PowerShellu, se v současné době nepodporuje.

Java

@FunctionName("MainOrchestrator")
public String runMainOrchestrator(
    @DurableOrchestrationTrigger(name = "taskOrchestrationContext") 
    TaskOrchestrationContext context) {

    NewSubOrchestrationInstanceOptions subOptions = new NewSubOrchestrationInstanceOptions().setVersion("1.0");

    String result = context.callSubOrchestrator("ProcessPaymentOrchestrator", orderId, String.class, subOptions).await();
    
    // ...
}

Odebrání zastaralých cest kódu

V průběhu času můžete chtít z funkcí orchestrátoru odebrat starší cesty kódu, abyste zjednodušili údržbu a snížili technický dluh. Odebrání kódu je však nutné provést pečlivě, aby nedošlo k přerušení existujících instancí orchestrace.

Pokud je bezpečné odebrat starší verzi kódu:

• Všechny instance orchestrace používající starou verzi byly dokončeny (úspěšné, neúspěšné nebo ukončené)
• Ve staré verzi se nevytvoří žádné nové instance orchestrace.
• Ověřili jste se prostřednictvím monitorování nebo dotazování, že ve starší verzi nejsou spuštěné žádné instance.
• Dostatek časového období uplynulo od posledního nasazení staré verze (vzhledem k vašim požadavkům na provozní kontinuitu)

Osvědčené postupy pro odebrání:

• Monitorování aktivně spuštěných instancí: Pomocí rozhraní API pro správu Durable Functions můžete zadávat dotazy na instance pomocí konkrétních verzí.
• Nastavit zásady uchovávání informací: Definujte, jak dlouho chcete zachovat zpětnou kompatibilitu pro každou verzi.
• Odebrání přírůstkově: Zvažte odebrání jedné verze současně místo více verzí.
• Odebrání dokumentu: Udržujte jasné záznamy o tom, kdy byly verze odebrány a proč.

Warning

Odebrání zastaralých cest kódu, zatímco instance orchestrace stále používají tyto verze, může způsobit deterministické chyby při opakování nebo neočekávané chování. Před odebráním kódu vždy ověřte, že žádné instance nepoužívají starší verzi.

Osvědčené postupy

Správa verzí

• Použití vícedílné správy verzí: Přijmout konzistentní schéma správy verzí, jako je major.minor.patch.
• Zásadní změny dokumentu: Jasně zdokumentujte, jaké změny vyžadují novou verzi.
• Plánování životního cyklu verzí: Definujte, kdy odebrat legacy cesty kódu.

Organizace kódu

• Samostatná logika verze: Pro různé verze použijte jasné větvení nebo samostatné metody.
• Zachování determinismu: Vyhněte se úpravě existující logiky verze po nasazení. Pokud jsou změny naprosto nezbytné (například kritické opravy chyb), ujistěte se, že udržují deterministické chování a nemění posloupnost operací nebo očekávají, že novější verze orchestrátoru selžou při zpracování starších orchestrací.
• Důkladně otestujte: Otestujte všechny cesty verzí, zejména během přechodů.

Monitorování a pozorovatelnost

• Verze záznamu: Zahrňte do záznamů verzi, abyste usnadnili ladění.
• Monitorování distribuce verzí: Sledujte, které verze aktivně běží.
• Nastavení upozornění: Monitorujte případné chyby související s verzí.

Troubleshooting

Běžné problémy

• Problém: Instance orchestrace vytvořené s verzí 1.0 selhávají po nasazení verze 2.0

  • Řešení: Ujistěte se, že cesta kódu verze 1.0 v orchestrátoru zůstane úplně stejná. Jakékoli změny v pořadí provádění mohou narušit deterministickou replikaci.

• Problém: Pracovní procesy se staršími verzemi orchestratoru nemůžou spouštět nové orchestrace

  • Řešení: Toto chování je očekávané. Modul runtime záměrně brání starším pracovníkům v provádění orchestrací s novějšími verzemi pro zachování bezpečnosti. Ujistěte se, že jsou všichni pracovníci aktualizováni na nejnovější verzi orchestrátoru a jejich defaultVersion nastavení host.json se odpovídajícím způsobem aktualizuje. Toto chování můžete v případě potřeby upravit pomocí rozšířených možností konfigurace (podrobnosti najdete v části Rozšířené využití ).

• Problém: Informace o verzi nejsou v orchestratoru dostupné (context.Version nebo context.getVersion() mají hodnotu null bez ohledu na defaultVersion nastavení).

  • Řešení: Zkontrolujte část Požadavky a ujistěte se, že vaše prostředí splňuje všechny požadavky na správu verzí orchestrace.

• Problém: Orchestrace novější verze postupují velmi pomalu nebo jsou zcela zablokované

  • Řešení: Problém může mít různé původní příčiny:
    1. Nedostatek novějších pracovníků: Ujistěte se, že je nasazeno dostatečné množství pracovníků obsahujících stejnou nebo vyšší verzi v defaultVersion, aby bylo možné zvládnout novější orkestrace.
    2. Orchestrace směrování interference ze starších pracovních procesů: Staré pracovní procesy můžou kolidovat s mechanismem směrování orchestrace, což znesnadňuje novým pracovníkům sběr orchestrací pro zpracování. To může být zvlášť patrné při použití určitých poskytovatelů úložiště (Azure Storage nebo MSSQL). Za normálních okolností platforma Azure Functions zajišťuje rychlé uvolnění starších pracovníků po nasazení, takže jakékoli zpoždění obvykle není významné. Pokud ale používáte konfiguraci, která umožňuje řídit životní cyklus starších pracovních procesů, ujistěte se, že starší pracovní procesy jsou nakonec vypnuté. Případně zvažte použití Plánovače trvalých úloh, protože poskytuje vylepšený mechanismus směrování, který je méně náchylný k tomuto problému.

Další kroky

Informace o strategiích nasazení bez výpadku

Další informace o obecných strategiích správy verzí