Hantera instanser i Durable Functions i Azure

Orkestreringar i Durable Functions är långvariga tillståndskänsliga funktioner som kan startas, frågas, pausas, återupptas och avslutas med hjälp av inbyggda hanterings-API:er. Flera andra API:er för instanshantering exponeras också av durable functions-orkestreringsklientbindningen, till exempel att skicka externa händelser till instanser, rensa instanshistorik osv. Den här artikeln innehåller information om alla instanshanteringsåtgärder som stöds.

Starta instanser

Metoden start-new (eller schedule-new) på orkestreringsklientbindningen startar en ny orkestreringsinstans. Internt skriver den här metoden ett meddelande via Durable Functions-lagringsprovidern och returnerar sedan. Det här meddelandet utlöser asynkront starten av en orkestreringsfunktion med det angivna namnet.

Parametrarna för att starta en ny orkestreringsinstans är följande:

• Namn: Namnet på orkestreringsfunktionen som ska schemaläggas.
• Indata: Alla JSON-serialiserbara data som ska skickas som indata till orchestrator-funktionen.
• InstanceId: (Valfritt) Instansens unika ID. Om du inte anger den här parametern använder metoden ett slumpmässigt ID.

Dricks

Använd en slumpmässig identifierare för instans-ID:t när det är möjligt. Slumpmässiga instans-ID:er hjälper till att säkerställa en lika belastningsfördelning när du skalar orkestreringsfunktioner över flera virtuella datorer. Rätt tid att använda icke-slumpmässiga instans-ID är när ID:t måste komma från en extern källa eller när du implementerar singleton orchestrator-mönstret .

Följande kod är en exempelfunktion som startar en ny orkestreringsinstans:

C#

[FunctionName("HelloWorldQueueTrigger")]
public static async Task Run(
    [QueueTrigger("start-queue")] string input,
    [DurableClient] IDurableOrchestrationClient starter,
    ILogger log)
{
    string instanceId = await starter.StartNewAsync("HelloWorld", input);
    log.LogInformation($"Started orchestration with ID = '{instanceId}'.");
}

Kommentar

Den tidigare C#-koden är för Durable Functions 2.x. För Durable Functions 1.x måste du använda OrchestrationClient attributet i stället för DurableClient attributet och du måste använda DurableOrchestrationClient parametertypen i stället för IDurableOrchestrationClient. Mer information om skillnaderna mellan versioner finns i artikeln Durable Functions-versioner .

JavaScript

Om inget annat anges använder exemplen på den här sidan HTTP-utlösaren med följande function.json.

function.json

{
  "bindings": [
    {
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": ["post"]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "name": "starter",
      "type": "durableClient",
      "direction": "in"
    }
  ],
  "disabled": false
}

Kommentar

Det här exemplet är avsett för Durable Functions version 2.x. I version 1.x använder du orchestrationClient i stället för durableClient.

index.js

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

module.exports = async function(context, input) {
    const client = df.getClient(context);

    const instanceId = await client.startNew("HelloWorld", undefined, input);
    context.log(`Started orchestration with ID = ${instanceId}.`);
};

Python

Om inget annat anges använder exemplen på den här sidan HTTP-utlösaren med följande function.json.

function.json

{
  "scriptFile": "__init__.py",
  "bindings": [    
    {
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": ["post"]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "name": "starter",
      "type": "durableClient",
      "direction": "in"
    }
  ],
  "disabled": false
}

Kommentar

Det här exemplet är avsett för Durable Functions version 2.x. I version 1.x använder du orchestrationClient i stället för durableClient.

__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('HelloWorld', None, None)
    logging.log(f"Started orchestration with ID = ${instance_id}.")

PowerShell

Om inget annat anges använder exemplen på den här sidan HTTP-utlösaren med följande function.json.

function.json

{
  "bindings": [    
    {
      "name": "Request",
      "type": "httpTrigger",
      "direction": "in",
      "methods": ["post"]
    },
    {
      "name": "Response",
      "type": "http",
      "direction": "out"
    },
    {
      "name": "starter",
      "type": "durableClient",
      "direction": "in"
    }
  ],
  "disabled": false
}

Kommentar

Det här exemplet är avsett för Durable Functions version 2.x. I version 1.x använder du orchestrationClient i stället för durableClient.

run.ps1

param($Request, $TriggerMetadata)

$InstanceId = Start-DurableOrchestration -FunctionName 'HelloWorld'
Write-Host "Started orchestration with ID = '$InstanceId'"

Java

@FunctionName("HelloWorldQueueTrigger")
public void helloWorldQueueTrigger(
        @QueueTrigger(name = "input", queueName = "start-queue", connection = "Storage") String input,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext,
        final ExecutionContext context) {
    DurableTaskClient client = durableContext.getClient();        
    String instanceID = client.scheduleNewOrchestrationInstance("HelloWorld");
    context.getLogger().info("Scheduled orchestration with ID = " + instanceID);
}

Om du vill vänta tills orkestratorn startar innan du återvänder från funktionen kan du också använda waitForInstanceStart() metoden.

// wait up to 30 seconds for the scheduled orchestration to enter the "Running" state
client.waitForInstanceStart(instanceID, Duration.ofSeconds(30));

Azure Functions Core Tools

Du kan också starta en instans direkt med hjälp func durable start-new av kommandot i Core Tools, som tar följande parametrar:

• function-name (krävs): Namnet på funktionen som ska startas.
• input (valfritt): Indata till funktionen, antingen infogad eller via en JSON-fil. För filer lägger du till ett prefix i sökvägen till filen med @, till exempel @path/to/file.json.
• id (valfritt): ID för orkestreringsinstansen. Om du inte anger den här parametern använder kommandot ett slumpmässigt GUID.
• connection-string-setting(valfritt): Namnet på programinställningen som innehåller lagringen anslutningssträng att använda. Standardvärdet är AzureWebJobsStorage.
• task-hub-name (valfritt): Namnet på uppgiftshubben Durable Functions som ska användas. Standardvärdet är DurableFunctionsHub. Du kan också ange detta i host.json med durableTask:HubName.

Kommentar

Core Tools-kommandon förutsätter att du kör dem från rotkatalogen i en funktionsapp. Om du uttryckligen anger parametrarna connection-string-setting och task-hub-name kan du köra kommandona från valfri katalog. Även om du kan köra de här kommandona utan att en funktionsappvärd körs kan det hända att du inte kan se några effekter om inte värden körs. Kommandot skickar till exempel start-new ett startmeddelande till måluppgiftshubben, men orkestreringen körs inte om det inte finns en värdprocess för funktionsappen som kan bearbeta meddelandet.

Kommentar

Core Tools-kommandona stöds för närvarande endast när azure storage-standardprovidern används för att bevara körningstillståndet.

Följande kommando startar funktionen med namnet HelloWorld och skickar innehållet i filen counter-data.json till den:

func durable start-new --function-name HelloWorld --input @counter-data.json --task-hub-name TestTaskHub

Frågeinstanser

När du har startat nya orkestreringsinstanser behöver du förmodligen köra frågor mot deras körningsstatus för att lära dig om de körs, har slutförts eller har misslyckats.

Metoden get-status på orkestreringsklientbindningen frågar statusen för en orkestreringsinstans.

Det tar en instanceId (obligatorisk), showHistory (valfritt), showHistoryOutput (valfritt) och showInput (valfritt) som parametrar.

• showHistory: Om det är inställt på trueinnehåller svaret körningshistoriken.
• showHistoryOutput: Om värdet är trueinställt på innehåller körningshistoriken aktivitetsutdata.
• showInput: Om det är inställt falsepå innehåller svaret inte indata för funktionen. Standardvärdet är true.

Metoden returnerar ett objekt med följande egenskaper:

• Namn: Namnet på orkestreringsfunktionen.
• InstanceId: Instans-ID:t för orkestreringen (bör vara samma som instanceId indata).
• CreatedTime: Den tid då orkestreringsfunktionen började köras.
• LastUpdatedTime: Den tid då orkestreringen senast kontrollpunktades.
• Indata: Indata för funktionen som ett JSON-värde. Det här fältet fylls inte i om showInput det är falskt.
• CustomStatus: Anpassad orkestreringsstatus i JSON-format.
• Utdata: Utdata för funktionen som ett JSON-värde (om funktionen har slutförts). Om orkestreringsfunktionen misslyckades innehåller den här egenskapen information om felet. Om orkestreringsfunktionen pausades eller avslutades innehåller den här egenskapen orsaken till avstängningen eller avslutningen (om någon).
• RuntimeStatus: Ett av följande värden:
  • Väntar: Instansen har schemalagts men har ännu inte börjat köras.
  • Körs: Instansen har börjat köras.
  • Slutförd: Instansen har slutförts normalt.
  • ContinuedAsNy: Instansen har startat om sig själv med en ny historik. Det här tillståndet är ett tillfälligt tillstånd.
  • Misslyckades: Instansen misslyckades med ett fel.
  • Avslutad: Instansen stoppades plötsligt.
  • Pausad: Instansen avbröts och kan återupptas vid en senare tidpunkt.
• Historik: Orkestreringens körningshistorik. Det här fältet fylls bara i om showHistory är inställt på true.

Kommentar

En orkestrerare markeras inte som Completed förrän alla schemalagda aktiviteter har slutförts och orkestratorn har återvänt. Med andra ord räcker det inte att en orkestrerare når sin return instruktion för att markeras som Completed. Detta är särskilt relevant för fall där WhenAny används. Dessa orkestratorer ofta return innan alla schemalagda aktiviteter har utförts.

Den här metoden returnerar null (.NET och Java), undefined (JavaScript) eller None (Python) om instansen inte finns.

C#

[FunctionName("GetStatus")]
public static async Task Run(
    [DurableClient] IDurableOrchestrationClient client,
    [QueueTrigger("check-status-queue")] string instanceId)
{
    DurableOrchestrationStatus status = await client.GetStatusAsync(instanceId);
    // do something based on the current status.
}

Kommentar

Den tidigare C#-koden är för Durable Functions 2.x. För Durable Functions 1.x måste du använda OrchestrationClient attributet i stället för DurableClient attributet och du måste använda DurableOrchestrationClient parametertypen i stället för IDurableOrchestrationClient. Mer information om skillnaderna mellan versioner finns i artikeln Durable Functions-versioner .

JavaScript

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

module.exports = async function(context, instanceId) {
    const client = df.getClient(context);

    const status = await client.getStatus(instanceId);
    // do something based on the current status.
    // example: if status.runtimeStatus === df.OrchestrationRuntimeStatus.Running: ...
}

Se Startinstanser för konfigurationen av function.json.

Python

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

async def main(req: func.HttpRequest, starter: str, instance_id: str) -> func.HttpResponse:
    client = df.DurableOrchestrationClient(starter)

    status = await client.get_status(instance_id)
    # do something based on the current status
    # example: if (existing_instance.runtime_status is df.OrchestrationRuntimeStatus.Running) { ...

PowerShell

param($Request, $TriggerMetadata)

# Get instanceid from body
$InstanceId = $Request.Body.InstanceId

$Status = Get-DurableStatus -InstanceId $InstanceId -ShowHistory -ShowHistoryOutput -ShowInput
Write-Host "Status: $($Status | ConvertTo-Json)"

# Do something based on status
# example: if ($Status.runtimeStatus -eq 'Running') { ... }

Java

@FunctionName("GetStatus")
public void getStatus(
        @QueueTrigger(name = "instanceID", queueName = "check-status-queue", connection = "Storage") String instanceID,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext,
        final ExecutionContext context) {
    DurableTaskClient client = durableContext.getClient();        
    OrchestrationMetadata metadata = client.getInstanceMetadata(instanceID, false);
    if (metadata != null) {
        OrchestrationRuntimeStatus status = metadata.getRuntimeStatus();
        switch (status) {
            // do something based on the current status
        }
    }
}

Azure Functions Core Tools

Du kan också hämta status för en orkestreringsinstans direkt med hjälp func durable get-runtime-status av kommandot i Core Tools.

Kommentar

Core Tools-kommandon stöds för närvarande endast när azure storage-standardprovidern används för att bevara körningstillståndet.

Kommandot durable get-runtime-status tar följande parametrar:

• id (krävs): ID för orkestreringsinstansen.
• show-input (valfritt): Om värdet är inställt truepå innehåller svaret indata för funktionen. Standardvärdet är false.
• show-output (valfritt): Om värdet är inställt på trueinnehåller svaret utdata för funktionen. Standardvärdet är false.
• connection-string-setting(valfritt): Namnet på programinställningen som innehåller lagringen anslutningssträng att använda. Standardvärdet är AzureWebJobsStorage.
• task-hub-name (valfritt): Namnet på uppgiftshubben Durable Functions som ska användas. Standardvärdet är DurableFunctionsHub. Den kan också anges i host.json med durableTask:HubName.

Följande kommando hämtar statusen (inklusive indata och utdata) för en instans med ett orkestreringsinstans-ID för 0ab8c55a66644d68a3a8b220b12d209c. Det förutsätter att du kör func kommandot från funktionsappens rotkatalog:

func durable get-runtime-status --id 0ab8c55a66644d68a3a8b220b12d209c --show-input true --show-output true

Du kan använda durable get-history kommandot för att hämta historiken för en orkestreringsinstans. Det tar följande parametrar:

• id (krävs): ID för orkestreringsinstansen.
• connection-string-setting(valfritt): Namnet på programinställningen som innehåller lagringen anslutningssträng att använda. Standardvärdet är AzureWebJobsStorage.
• task-hub-name (valfritt): Namnet på uppgiftshubben Durable Functions som ska användas. Standardvärdet är DurableFunctionsHub. Den kan också anges i host.json med durableTask:HubName.

func durable get-history --id 0ab8c55a66644d68a3a8b220b12d209c

Fråga alla instanser

Du kan använda API:er i ditt språk-SDK för att fråga efter status för alla orkestreringsinstanser i aktivitetshubben. Det här "list-instances" eller "get-status" -API:et returnerar en lista över objekt som representerar orkestreringsinstanserna som matchar frågeparametrarna.

C#

[FunctionName("GetAllStatus")]
public static async Task Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestMessage req,
    [DurableClient] IDurableOrchestrationClient client,
    ILogger log)
{
    var noFilter = new OrchestrationStatusQueryCondition();
    OrchestrationStatusQueryResult result = await client.ListInstancesAsync(
        noFilter,
        CancellationToken.None);
    foreach (DurableOrchestrationStatus instance in result.DurableOrchestrationState)
    {
        log.LogInformation(JsonConvert.SerializeObject(instance));
    }
    
    // Note: ListInstancesAsync only returns the first page of results.
    // To request additional pages provide the result.ContinuationToken
    // to the OrchestrationStatusQueryCondition's ContinuationToken property.
}

Kommentar

Den tidigare C#-koden är för Durable Functions 2.x. För Durable Functions 1.x måste du använda OrchestrationClient attributet i stället för DurableClient attributet och du måste använda DurableOrchestrationClient parametertypen i stället för IDurableOrchestrationClient. Mer information om skillnaderna mellan versioner finns i artikeln Durable Functions-versioner .

JavaScript

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

module.exports = async function(context, req) {
    const client = df.getClient(context);

    const instances = await client.getStatusAll();
    instances.forEach((instance) => {
        context.log(JSON.stringify(instance));
    });
};

Se Startinstanser för konfigurationen av function.json.

Python

import logging
import json
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)

    instances = await client.get_status_all()

    for instance in instances:
        logging.log(json.dumps(instance))

Se Startinstanser för konfigurationen av function.json.

PowerShell

Kommentar

Den här funktionen stöds för närvarande inte i PowerShell, men kan uppnås med http-API:et durable functions.

Java

@FunctionName("GetAllStatus")
public String getAllStatus(
        @HttpTrigger(name = "req", methods = {HttpMethod.GET}) HttpRequestMessage<?> req,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext) {
    DurableTaskClient client = durableContext.getClient();
    OrchestrationStatusQuery noFilter = new OrchestrationStatusQuery();
    OrchestrationStatusQueryResult result = client.queryInstances(noFilter);
    return "Found " + result.getOrchestrationState().size() + " orchestrations.";
}

Azure Functions Core Tools

Det är också möjligt att fråga instanser direkt med hjälp func durable get-instances av kommandot i Core Tools.

Kommentar

Core Tools-kommandona stöds för närvarande endast när azure storage-standardprovidern används för att bevara körningstillståndet.

Kommandot durable get-instances tar följande parametrar:

• top (valfritt): Det här kommandot stöder växling. Den här parametern motsvarar antalet instanser som hämtats per begäran. Standardvärdet är 10.
• continuation-token (valfritt): En token som anger vilken sida eller vilket avsnitt av instanser som ska hämtas. Varje get-instances körning returnerar en token till nästa uppsättning instanser.
• connection-string-setting(valfritt): Namnet på programinställningen som innehåller lagringen anslutningssträng att använda. Standardvärdet är AzureWebJobsStorage.
• task-hub-name (valfritt): Namnet på uppgiftshubben Durable Functions som ska användas. Standardvärdet är DurableFunctionsHub. Den kan också anges i host.json med durableTask:HubName.

func durable get-instances

Fråga instanser med filter

Vad händer om du inte behöver all information som en standardinstansfråga kan ge? Vad händer om du till exempel bara letar efter orkestreringsgenereringstiden eller orkestreringskörningsstatusen? Du kan begränsa frågan genom att använda filter.

C#

[FunctionName("QueryStatus")]
public static async Task Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestMessage req,
    [DurableClient] IDurableOrchestrationClient client,
    ILogger log)
{
    // Get the first 100 running or pending instances that were created between 7 and 1 day(s) ago
    var queryFilter = new OrchestrationStatusQueryCondition
    {
        RuntimeStatus = new[]
        {
            OrchestrationRuntimeStatus.Pending,
            OrchestrationRuntimeStatus.Running,
        },
        CreatedTimeFrom = DateTime.UtcNow.Subtract(TimeSpan.FromDays(7)),
        CreatedTimeTo = DateTime.UtcNow.Subtract(TimeSpan.FromDays(1)),
        PageSize = 100,
    };
    
    OrchestrationStatusQueryResult result = await client.ListInstancesAsync(
        queryFilter,
        CancellationToken.None);
    foreach (DurableOrchestrationStatus instance in result.DurableOrchestrationState)
    {
        log.LogInformation(JsonConvert.SerializeObject(instance));
    }
}

Kommentar

Den tidigare C#-koden är för Durable Functions 2.x. För Durable Functions 1.x måste du använda OrchestrationClient attributet i stället för DurableClient attributet och du måste använda DurableOrchestrationClient parametertypen i stället för IDurableOrchestrationClient. Mer information om skillnaderna mellan versioner finns i artikeln Durable Functions-versioner .

JavaScript

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

module.exports = async function(context, req) {
    const client = df.getClient(context);

    const runtimeStatus = [
        df.OrchestrationRuntimeStatus.Completed,
        df.OrchestrationRuntimeStatus.Running,
    ];
    const instances = await client.getStatusBy(
        new Date(2021, 3, 10, 10, 1, 0),
        new Date(2021, 3, 10, 10, 23, 59),
        runtimeStatus
    );
    instances.forEach((instance) => {
        context.log(JSON.stringify(instance));
    });
};

Se Startinstanser för konfigurationen av function.json.

Python

import logging
from datetime import datetime
import json
import azure.functions as func
import azure.durable_functions as df
from azure.durable_functions.models.OrchestrationRuntimeStatus import OrchestrationRuntimeStatus

async def main(req: func.HttpRequest, starter: str) -> func.HttpResponse:
    client = df.DurableOrchestrationClient(starter)

    runtime_status = [OrchestrationRuntimeStatus.Completed, OrchestrationRuntimeStatus.Running]

    instances = await client.get_status_by(
        datetime(2021, 3, 10, 10, 1, 0),
        datetime(2021, 3, 10, 10, 23, 59),
        runtime_status
    )

    for instance in instances:
        logging.log(json.dumps(instance))

PowerShell

Kommentar

Den här funktionen stöds för närvarande inte i PowerShell, men kan uppnås med http-API:et durable functions.

Java

@FunctionName("GetRunningInstances")
public String getRunningInstances(
        @HttpTrigger(name = "req", methods = {HttpMethod.GET}) HttpRequestMessage<?> req,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext) {
    DurableTaskClient client = durableContext.getClient();
    OrchestrationStatusQuery filter = new OrchestrationStatusQuery()
        .setRuntimeStatusList(List.of(OrchestrationRuntimeStatus.PENDING, OrchestrationRuntimeStatus.RUNNING))
        .setCreatedTimeFrom(Instant.now().minus(Duration.ofDays(7)))
        .setCreatedTimeTo(Instant.now().minus(Duration.ofDays(1)));
    OrchestrationStatusQueryResult result = client.queryInstances(filter);
    return "Found " + result.getOrchestrationState().size() + " orchestrations.";
}

Azure Functions Core Tools

I Azure Functions Core Tools kan du också använda durable get-instances kommandot med filter. Förutom de ovan nämnda topparametrarna , continuation-token, connection-string-settingoch task-hub-name kan du använda tre filterparametrar (created-after, created-beforeoch runtime-status).

Kommentar

Core Tools-kommandona stöds för närvarande endast när azure storage-standardprovidern används för att bevara körningstillståndet.

Följande är parametrarna durable get-instances för kommandot.

• created-after (valfritt): Hämta de instanser som skapats efter detta datum/tid (UTC). ISO 8601-formaterade datetimes accepteras.
• created-before (valfritt): Hämta de instanser som skapats före detta datum/tid (UTC). ISO 8601-formaterade datetimes accepteras.
• runtime-status (valfritt): Hämta instanserna med en viss status (till exempel köra eller slutförda). Kan ge flera (blankstegsavgränsade) statusar.
• top (valfritt): Antal instanser som hämtats per begäran. Standardvärdet är 10.
• continuation-token (valfritt): En token som anger vilken sida eller vilket avsnitt av instanser som ska hämtas. Varje get-instances körning returnerar en token till nästa uppsättning instanser.
• connection-string-setting(valfritt): Namnet på programinställningen som innehåller lagringen anslutningssträng att använda. Standardvärdet är AzureWebJobsStorage.
• task-hub-name (valfritt): Namnet på uppgiftshubben Durable Functions som ska användas. Standardvärdet är DurableFunctionsHub. Den kan också anges i host.json med durableTask:HubName.

Om du inte anger några filter (created-after, created-beforeeller runtime-status) hämtar top kommandot bara instanser, utan hänsyn till körningsstatus eller skapandetid.

func durable get-instances --created-after 2021-03-10T13:57:31Z --created-before  2021-03-10T23:59Z --top 15

Avsluta instanser

Om du har en orkestreringsinstans som tar för lång tid att köra, eller om du bara behöver stoppa den innan den slutförs av någon anledning, kan du avsluta den.

De två parametrarna för termins-API:et är ett instans-ID och en orsakssträng som skrivs till loggar och till instansstatusen.

C#

[FunctionName("TerminateInstance")]
public static Task Run(
    [DurableClient] IDurableOrchestrationClient client,
    [QueueTrigger("terminate-queue")] string instanceId)
{
    string reason = "Found a bug";
    return client.TerminateAsync(instanceId, reason);
}

Kommentar

Den tidigare C#-koden är för Durable Functions 2.x. För Durable Functions 1.x måste du använda OrchestrationClient attributet i stället för DurableClient attributet och du måste använda DurableOrchestrationClient parametertypen i stället för IDurableOrchestrationClient. Mer information om skillnaderna mellan versioner finns i artikeln Durable Functions-versioner .

JavaScript

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

module.exports = async function(context, instanceId) {
    const client = df.getClient(context);

    const reason = "Found a bug";
    return client.terminate(instanceId, reason);
};

Se Startinstanser för konfigurationen av function.json.

Python

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

async def main(req: func.HttpRequest, starter: str, instance_id: str) -> func.HttpResponse:
    client = df.DurableOrchestrationClient(starter)

    reason = "Found a bug"
    return await client.terminate(instance_id, reason)

PowerShell

param($Request, $TriggerMetadata)

# Get instance id from body
$InstanceId = $Request.Body.InstanceId
$Reason = 'Found a bug'

Stop-DurableOrchestration -InstanceId $InstanceId -Reason $Reason

Java

@FunctionName("TerminateInstance")
public void terminateInstance(
        @HttpTrigger(name = "req", methods = {HttpMethod.POST}) HttpRequestMessage<String> req,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext) {
    String instanceID = req.getBody();
    String reason = "Found a bug";
    durableContext.getClient().terminate(instanceID, reason);
}

En avslutad instans övergår så småningom till tillståndet Terminated . Den här övergången sker dock inte omedelbart. I stället placeras avsluta-åtgärden i aktivitetshubben tillsammans med andra åtgärder för den instansen. Du kan använda API:erna för instansfrågor för att veta när en avslutad instans faktiskt har nått Terminated tillståndet.

Kommentar

Instansavslut sprids för närvarande inte. Aktivitetsfunktioner och underorkestreringar körs till slutförande, oavsett om du har avslutat orkestreringsinstansen som anropade dem.

Pausa och återuppta instanser

Om du pausar en orkestrering kan du stoppa en orkestrering som körs. Till skillnad från avslutning har du möjlighet att återuppta en pausad orkestrerare vid en senare tidpunkt.

De två parametrarna för det pausade API:et är ett instans-ID och en orsakssträng som skrivs till loggar och till instansstatusen.

C#

[FunctionName("SuspendResumeInstance")]
public static async Task Run(
    [DurableClient] IDurableOrchestrationClient client,
    [QueueTrigger("suspend-resume-queue")] string instanceId)
{
    string suspendReason = "Need to pause workflow";
    await client.SuspendAsync(instanceId, suspendReason);
    
    // Wait for 30 seconds to ensure that the orchestrator state is updated to suspended. 
    DateTime dueTime = context.CurrentUtcDateTime.AddSeconds(30);
    await context.CreateTimer(dueTime, CancellationToken.None);
    
    string resumeReason = "Continue workflow";
    await client.ResumeAsync(instanceId, resumeReason);
}

JavaScript

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

module.exports = async function(context, instanceId) {
    const client = df.getClient(context);

    const suspendReason = "Need to pause workflow";
    await client.suspend(instanceId, suspendReason);

    // Wait for 30 seconds to ensure that the orchestrator state is updated to suspended.  
    const deadline = DateTime.fromJSDate(context.df.currentUtcDateTime, {zone: 'utc'}).plus({ seconds: 30 });
    yield context.df.createTimer(deadline.toJSDate());

    const resumeReason = "Continue workflow";
    await client.resume(instanceId, resumeReason);
};

Python

import azure.functions as func
import azure.durable_functions as df
from datetime import timedelta

async def main(req: func.HttpRequest, starter: str, instance_id: str):
    client = df.DurableOrchestrationClient(starter)

    suspend_reason = "Need to pause workflow"
    await client.suspend(instance_id, suspend_reason)

    # Wait for 30 seconds to ensure that the orchestrator state is updated to suspended. 
    due_time = context.current_utc_datetime + timedelta(seconds=30)
    yield context.create_timer(due_time)

    resume_reason = "Continue workflow"
    await client.resume(instance_id, resume_reason)

PowerShell

param($Request, $TriggerMetadata)

# Get instance id from body
$InstanceId = $Request.Body.InstanceId
$SuspendReason = 'Need to pause workflow'

Suspend-DurableOrchestration -InstanceId $InstanceId -Reason $SuspendReason

# Wait for 30 seconds to ensure that the orchestrator state is updated to suspended.
$duration = New-TimeSpan -Seconds 30
Start-DurableTimer -Duration $duration

$ResumeReason = 'Continue workflow'
Resume-DurableOrchestration -InstanceId $InstanceId -Reason $ResumeReason

Java

@FunctionName("SuspendResumeInstance")
public void suspendResumeInstance(
        @HttpTrigger(name = "req", methods = {HttpMethod.POST}) HttpRequestMessage<String> req,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext) {
    String instanceID = req.getBody();
    DurableTaskClient client = durableContext.getClient();  
    String suspendReason = "Need to pause workflow";
    client.suspendInstance(instanceID, suspendReason);

    // Wait for 30 seconds to ensure that the orchestrator state is updated to suspended. 
    ctx.createTimer(Duration.ofSeconds(30)).await();

    String resumeReason = "Continue workflow";
    client.getClient().resumeInstance(instanceID, resumeReason);
}

En pausad instans övergår så småningom till tillståndet Suspended . Den här övergången sker dock inte omedelbart. I stället placeras pausåtgärden i kö i aktivitetshubben tillsammans med andra åtgärder för den instansen. Du kan använda api:erna för instansfrågor för att veta när en instans som körs faktiskt har nått tillståndet Pausat.

När en pausad orkestrerare återupptas ändras dess status tillbaka till Running.

Azure Functions Core Tools

Du kan också avsluta en orkestreringsinstans direkt med hjälp func durable terminate av kommandot i Core Tools.

Kommentar

Core Tools-kommandona stöds för närvarande endast när azure storage-standardprovidern används för att bevara körningstillståndet.

Kommandot durable terminate tar följande parametrar:

• id (krävs): ID för orkestreringsinstansen som ska avslutas.
• reason (valfritt): Orsak till uppsägning.
• connection-string-setting(valfritt): Namnet på programinställningen som innehåller lagringen anslutningssträng att använda. Standardvärdet är AzureWebJobsStorage.
• task-hub-name (valfritt): Namnet på uppgiftshubben Durable Functions som ska användas. Standardvärdet är DurableFunctionsHub. Den kan också anges i host.json med durableTask:HubName.

Följande kommando avslutar en orkestreringsinstans med ett ID för 0ab8c55a66644d68a3a8b220b12d209c:

func durable terminate --id 0ab8c55a66644d68a3a8b220b12d209c --reason "Found a bug"

Skicka händelser till instanser

I vissa scenarier måste orkestreringsfunktioner vänta och lyssna efter externa händelser. Exempelscenarier där detta är användbart är scenarier för övervakning och mänsklig interaktion .

Du kan skicka händelsemeddelanden till instanser som körs med hjälp av api:et för att skapa händelse i orkestreringsklienten. Orkestreringar kan lyssna och svara på dessa händelser med hjälp av väntan på extern händelseorkestrerings-API .

Parametrarna för höjningshändelsen är följande:

• Instans-ID: Instansens unika ID.
• Händelsenamn: Namnet på den händelse som ska skickas.
• Händelsedata: En JSON-serialiserbar nyttolast som ska skickas till instansen.

C#

[FunctionName("RaiseEvent")]
public static Task Run(
    [DurableClient] IDurableOrchestrationClient client,
    [QueueTrigger("event-queue")] string instanceId)
{
    int[] eventData = new int[] { 1, 2, 3 };
    return client.RaiseEventAsync(instanceId, "MyEvent", eventData);
}

Kommentar

Den tidigare C#-koden är för Durable Functions 2.x. För Durable Functions 1.x måste du använda OrchestrationClient attributet i stället för DurableClient attributet och du måste använda DurableOrchestrationClient parametertypen i stället för IDurableOrchestrationClient. Mer information om skillnaderna mellan versioner finns i artikeln Durable Functions-versioner .

JavaScript

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

module.exports = async function(context, instanceId) {
    const client = df.getClient(context);

    const eventData = [ 1, 2, 3 ];
    return client.raiseEvent(instanceId, "MyEvent", eventData);
};

Se Startinstanser för konfigurationen av function.json.

Python

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

async def main(req: func.HttpRequest, starter: str, instance_id: str) -> func.HttpResponse:
    client = df.DurableOrchestrationClient(starter)

    event_data = [1, 2 ,3]
    return await client.raise_event(instance_id, 'MyEvent', event_data)

PowerShell

param($Request, $TriggerMetadata)

# Get instance id from body
$InstanceId = $Request.Body.InstanceId
$EventName = 'MyEvent'
$EventData = @(1,2,3)

Send-DurableExternalEvent -InstanceId $InstanceId -EventName $EventName -EventData $EventData

Java

@FunctionName("RaiseEvent")
public void raiseEvent(
        @HttpTrigger(name = "req", methods = {HttpMethod.POST}) HttpRequestMessage<String> req,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext) {
    String instanceID = req.getBody();
    String eventName = "MyEvent";
    int[] eventData = { 1, 2, 3 };
    durableContext.getClient().raiseEvent(instanceID, eventName, eventData);
}

Kommentar

Om det inte finns någon orkestreringsinstans med det angivna instans-ID:t ignoreras händelsemeddelandet. Om det finns en instans men den ännu inte väntar på händelsen lagras händelsen i instanstillståndet tills den är redo att tas emot och bearbetas.

Azure Functions Core Tools

Du kan också skapa en händelse till en orkestreringsinstans direkt med hjälp func durable raise-event av kommandot i Core Tools.

Kommentar

Core Tools-kommandona stöds för närvarande endast när azure storage-standardprovidern används för att bevara körningstillståndet.

Kommandot durable raise-event tar följande parametrar:

• id (krävs): ID för orkestreringsinstansen.
• event-name: Namnet på händelsen som ska genereras.
• event-data (valfritt): Data som ska skickas till orkestreringsinstansen. Det kan vara sökvägen till en JSON-fil, eller så kan du ange data direkt på kommandoraden.
• connection-string-setting(valfritt): Namnet på programinställningen som innehåller lagringen anslutningssträng att använda. Standardvärdet är AzureWebJobsStorage.
• task-hub-name (valfritt): Namnet på uppgiftshubben Durable Functions som ska användas. Standardvärdet är DurableFunctionsHub. Den kan också anges i host.json med durableTask:HubName.

func durable raise-event --id 0ab8c55a66644d68a3a8b220b12d209c --event-name MyEvent --event-data @eventdata.json

func durable raise-event --id 1234567 --event-name MyOtherEvent --event-data 3

Vänta tills orkestrering har slutförts

I långvariga orkestreringar kanske du vill vänta och få resultatet av en orkestrering. I dessa fall är det också användbart att kunna definiera en tidsgräns för orkestreringen. Om tidsgränsen överskrids ska orkestreringens tillstånd returneras i stället för resultatet.

API:et "vänta på slutförande eller skapa kontrollstatussvar" kan användas för att hämta faktiska utdata från en orkestreringsinstans synkront. Som standard har den här metoden en standardtimeout på 10 sekunder och ett avsökningsintervall på 1 sekund.

Här är ett exempel på en HTTP-utlösarfunktion som visar hur du använder det här API:et:

C#

// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.

using System;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.DurableTask;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.Extensions.Logging;

namespace VSSample
{
    public static class HttpSyncStart
    {
        private const string Timeout = "timeout";
        private const string RetryInterval = "retryInterval";

        [FunctionName("HttpSyncStart")]
        public static async Task<HttpResponseMessage> Run(
            [HttpTrigger(AuthorizationLevel.Function, methods: "post", Route = "orchestrators/{functionName}/wait")]
            HttpRequestMessage req,
            [DurableClient] IDurableOrchestrationClient 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}'.");

            TimeSpan timeout = GetTimeSpan(req, Timeout) ?? TimeSpan.FromSeconds(30);
            TimeSpan retryInterval = GetTimeSpan(req, RetryInterval) ?? TimeSpan.FromSeconds(1);
            
            return await starter.WaitForCompletionOrCreateCheckStatusResponseAsync(
                req,
                instanceId,
                timeout,
                retryInterval);
        }

        private static TimeSpan? GetTimeSpan(HttpRequestMessage request, string queryParameterName)
        {
            string queryParameterStringValue = request.RequestUri.ParseQueryString()[queryParameterName];
            if (string.IsNullOrEmpty(queryParameterStringValue))
            {
                return null;
            }

            return TimeSpan.FromSeconds(double.Parse(queryParameterStringValue));
        }
    }
}

JavaScript

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

const timeout = "timeout";
const retryInterval = "retryInterval";

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}'.`);

    const timeoutInMilliseconds = getTimeInSeconds(req, timeout) || 30000;
    const retryIntervalInMilliseconds = getTimeInSeconds(req, retryInterval) || 1000;

    const response = client.waitForCompletionOrCreateCheckStatusResponse(
        context.bindingData.req,
        instanceId,
        timeoutInMilliseconds,
        retryIntervalInMilliseconds
    );
    return response;
};

function getTimeInSeconds(req, queryParameterName) {
    const queryValue = req.query[queryParameterName];
    return queryValue
        ? queryValue * 1000 // expected to be in seconds
        : undefined;
}

Se Startinstanser för konfigurationen av function.json.

Python

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

timeout = "timeout"
retry_interval = "retryInterval"

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, req.get_body())
    logging.log(f"Started orchestration with ID = '${instance_id}'.")

    timeout_in_milliseconds = get_time_in_seconds(req, timeout)
    timeout_in_milliseconds = timeout_in_milliseconds if timeout_in_milliseconds != None else 30000
    retry_interval_in_milliseconds = get_time_in_seconds(req, retry_interval)
    retry_interval_in_milliseconds = retry_interval_in_milliseconds if retry_interval_in_milliseconds != None else 1000

    return await client.wait_for_completion_or_create_check_status_response(
        req,
        instance_id,
        timeout_in_milliseconds,
        retry_interval_in_milliseconds
    )

def get_time_in_seconds(req: func.HttpRequest, query_parameter_name: str):
    query_value = req.params.get(query_parameter_name)
    return query_value if query_value != None else 1000

PowerShell

Kommentar

PowerShell har för närvarande inte något inbyggt kommando för det här scenariot.

Java

Java har för närvarande inte en enda metod för det här scenariot. Den kan dock implementeras med några extra kodrader.

@FunctionName("HttpStartAndWait")
public HttpResponseMessage httpStartAndWait(
        @HttpTrigger(name = "req", route = "orchestrators/{functionName}/wait", methods = {HttpMethod.POST}) HttpRequestMessage<?> req,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext,
        @BindingName("functionName") String functionName,
        final ExecutionContext context) {

    DurableTaskClient client = durableContext.getClient();
    String instanceId = client.scheduleNewOrchestrationInstance(functionName);
    context.getLogger().info("Created new Java orchestration with instance ID = " + instanceId);
    try {
        String timeoutString = req.getQueryParameters().get("timeout");
        Integer timeoutInSeconds = Integer.parseInt(timeoutString);
        OrchestrationMetadata orchestration = client.waitForInstanceCompletion(
                instanceId,
                Duration.ofSeconds(timeoutInSeconds),
                true /* getInputsAndOutputs */);
        return req.createResponseBuilder(HttpStatus.OK)
                .body(orchestration.getSerializedOutput())
                .header("Content-Type", "application/json")
                .build();
    } catch (TimeoutException timeoutEx) {
        // timeout expired - return a 202 response
        return durableContext.createCheckStatusResponse(req, instanceId);
    }
}

Anropa funktionen med följande rad. Använd 2 sekunder för tidsgränsen och 0,5 sekunder för återförsöksintervallet:

curl -X POST "http://localhost:7071/orchestrators/E1_HelloSequence/wait?timeout=2&retryInterval=0.5"

Kommentar

Ovanstående cURL-kommando förutsätter att du har en orchestrator-funktion med namnet E1_HelloSequence i projektet. På grund av hur HTTP-utlösarfunktionen skrivs kan du ersätta den med namnet på valfri orkestreringsfunktion i projektet.

Beroende på den tid som krävs för att hämta svaret från orkestreringsinstansen finns det två fall:

• Orkestreringsinstanserna slutförs inom den definierade tidsgränsen (i det här fallet 2 sekunder) och svaret är den faktiska orkestreringsinstansens utdata, som levereras synkront:

HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Date: Thu, 14 Dec 2021 06:14:29 GMT
Transfer-Encoding: chunked

[
    "Hello Tokyo!",
    "Hello Seattle!",
    "Hello London!"
]

• Orkestreringsinstanserna kan inte slutföras inom den definierade tidsgränsen och svaret är standardvärdet som beskrivs i HTTP API URL-identifiering:

HTTP/1.1 202 Accepted
Content-Type: application/json; charset=utf-8
Date: Thu, 14 Dec 2021 06:13:51 GMT
Location: http://localhost:7071/runtime/webhooks/durabletask/instances/d3b72dddefce4e758d92f4d411567177?taskHub={taskHub}&connection={connection}&code={systemKey}
Retry-After: 10
Transfer-Encoding: chunked

{
    "id": "d3b72dddefce4e758d92f4d411567177",
    "sendEventPostUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/d3b72dddefce4e758d92f4d411567177/raiseEvent/{eventName}?taskHub={taskHub}&connection={connection}&code={systemKey}",
    "statusQueryGetUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/d3b72dddefce4e758d92f4d411567177?taskHub={taskHub}&connection={connection}&code={systemKey}",
    "terminatePostUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/d3b72dddefce4e758d92f4d411567177/terminate?reason={text}&taskHub={taskHub}&connection={connection}&code={systemKey}",
    "suspendPostUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/d3b72dddefce4e758d92f4d411567177/suspend?reason={text}&taskHub={taskHub}&connection={connection}&code={systemKey}",
    "resumePostUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/d3b72dddefce4e758d92f4d411567177/resume?reason={text}&taskHub={taskHub}&connection={connection}&code={systemKey}"
}

Kommentar

Formatet på webhook-URL:erna kan variera beroende på vilken version av Azure Functions-värden du kör. Föregående exempel är för Azure Functions 3.0-värden.

Hämta HTTP-hanteringswebbhooks-URL:er

Du kan använda ett externt system för att övervaka eller för att skapa händelser till en orkestrering. Externa system kan kommunicera med Durable Functions via webhook-URL:er som ingår i standardsvaret som beskrivs i HTTP API URL-identifiering. Webhook-URL:erna kan också nås programmatiskt med hjälp av orkestreringsklientbindningen. Mer specifikt kan API:et skapa HTTP-hanteringsnyttolast användas för att hämta ett serialiserbart objekt som innehåller dessa webhook-URL:er.

API:et för att skapa HTTP-hanteringsnyttolast har en parameter:

• Instans-ID: Instansens unika ID.

Metoderna returnerar ett objekt med följande strängegenskaper:

• ID: Instans-ID för orkestreringen (bör vara samma som InstanceId indata).
• StatusQueryGetUri: Status-URL:en för orkestreringsinstansen.
• SendEventPostUri: URL:en "raise event" för orkestreringsinstansen.
• TerminatePostUri: URL:en "avsluta" för orkestreringsinstansen.
• PurgeHistoryDeleteUri: URL:en för "rensningshistorik" för orkestreringsinstansen.
• suspendPostUri: URL:en "pausa" för orkestreringsinstansen.
• resumePostUri: URL:en "återuppta" för orkestreringsinstansen.

Funktioner kan skicka instanser av dessa objekt till externa system för att övervaka eller skapa händelser på motsvarande orkestreringar, enligt följande exempel:

C#

[FunctionName("SendInstanceInfo")]
public static void SendInstanceInfo(
    [ActivityTrigger] IDurableActivityContext ctx,
    [DurableClient] IDurableOrchestrationClient client,
    [CosmosDB(
        databaseName: "MonitorDB",
        containerName: "HttpManagementPayloads",
        Connection = "CosmosDBConnectionSetting")]out dynamic document)
{
    HttpManagementPayload payload = client.CreateHttpManagementPayload(ctx.InstanceId);

    // send the payload to Azure Cosmos DB
    document = new { Payload = payload, id = ctx.InstanceId };
}

Kommentar

Den tidigare C#-koden är för Durable Functions 2.x. För Durable Functions 1.x måste du använda DurableActivityContext i stället för IDurableActivityContext, du måste använda OrchestrationClient attributet i stället för DurableClient attributet och du måste använda DurableOrchestrationClient parametertypen i stället för IDurableOrchestrationClient. Mer information om skillnaderna mellan versioner finns i artikeln Durable Functions-versioner .

JavaScript

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

modules.exports = async function(context, ctx) {
    const client = df.getClient(context);

    const payload = client.createHttpManagementPayload(ctx.instanceId);

    // send the payload to Azure Cosmos DB
    context.bindings.document = JSON.stringify({
        id: ctx.instanceId,
        payload,
    });
};

Se Startinstanser för konfigurationen av function.json.

Python

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

async def main(req: func.HttpRequest, starter: str, instance_id: str) -> func.cosmosdb.cdb.Document:
    client = df.DurableOrchestrationClient(starter)

    payload = client.create_check_status_response(req, instance_id).get_body().decode()

    return func.cosmosdb.CosmosDBConverter.encode({
        id: instance_id,
        payload: payload
    })

PowerShell

using namespace System.Net

param($Request, $TriggerMetadata)

$InstanceId = $Request.Body.InstanceId
$Response = New-DurableOrchestrationCheckStatusResponse -Request $Request -InstanceId $InstanceId
Push-OutputBinding -Name Response -Value $Response

Java

Kommentar

Den här funktionen stöds för närvarande inte i Java.

Spola tillbaka instanser (förhandsversion)

Om du har ett orkestreringsfel av en oväntad anledning kan du spola tillbaka instansen till ett tidigare felfritt tillstånd med hjälp av ett API som skapats för detta ändamål.

Kommentar

Det här API:et är inte avsett att ersätta korrekt felhantering och återförsöksprinciper. I stället är det avsett att endast användas i fall där orkestreringsinstanser misslyckas av oväntade skäl. Orkestreringar i andra tillstånd än Failed (t.ex. , Running, TerminatedPending, ) Completedkan inte "återskapas". Mer information om felhantering och återförsöksprinciper finns i artikeln Felhantering .

RewindAsync Använd metoden (.NET) eller rewind (JavaScript) för orkestreringsklientbindningenför att återställa orkestreringen till körningstillståndet. Den här metoden kör även om de aktivitets- eller underorkestreringskörningsfel som orsakade orkestreringsfelet.

Anta till exempel att du har ett arbetsflöde som omfattar en rad mänskliga godkännanden. Anta att det finns en serie aktivitetsfunktioner som meddelar någon att deras godkännande behövs och väntar ut realtidssvaret. När alla godkännandeaktiviteter har fått svar eller överskriden tidsgräns antar du att en annan aktivitet misslyckas på grund av en programfelkonfiguration, till exempel en ogiltig databas anslutningssträng. Resultatet är ett orkestreringsfel djupt in i arbetsflödet. Med API:et RewindAsync (.NET) eller rewind (JavaScript) kan en programadministratör åtgärda konfigurationsfelet och spola tillbaka den misslyckade orkestreringen till tillståndet omedelbart före felet. Inget av stegen för mänsklig interaktion behöver godkännas på nytt och orkestreringen kan nu slutföras.

Kommentar

Återspolningsfunktionen har inte stöd för att spola tillbaka orkestreringsinstanser som använder varaktiga timers.

C#

[FunctionName("RewindInstance")]
public static Task Run(
    [DurableClient] IDurableOrchestrationClient client,
    [QueueTrigger("rewind-queue")] string instanceId)
{
    string reason = "Orchestrator failed and needs to be revived.";
    return client.RewindAsync(instanceId, reason);
}

Kommentar

Den tidigare C#-koden är för Durable Functions 2.x. För Durable Functions 1.x måste du använda OrchestrationClient attributet i stället för DurableClient attributet och du måste använda DurableOrchestrationClient parametertypen i stället för IDurableOrchestrationClient. Mer information om skillnaderna mellan versioner finns i artikeln Durable Functions-versioner .

JavaScript

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

module.exports = async function(context, instanceId) {
    const client = df.getClient(context);

    const reason = "Orchestrator failed and needs to be revived.";
    return client.rewind(instanceId, reason);
};

Se Startinstanser för konfigurationen av function.json.

Python

Kommentar

Den här funktionen stöds för närvarande inte i Python.

PowerShell

Kommentar

Den här funktionen stöds för närvarande inte i PowerShell.

Java

Kommentar

Den här funktionen stöds för närvarande inte i Java.

Azure Functions Core Tools

Du kan också spola tillbaka en orkestreringsinstans direkt med hjälp func durable rewind av kommandot i Core Tools.

Kommentar

Core Tools-kommandona stöds för närvarande endast när azure storage-standardprovidern används för att bevara körningstillståndet.

Kommandot durable rewind tar följande parametrar:

• id (krävs): ID för orkestreringsinstansen.
• reason (valfritt): Orsak till att orkestreringsinstansen spolas tillbaka.
• connection-string-setting(valfritt): Namnet på programinställningen som innehåller lagringen anslutningssträng att använda. Standardvärdet är AzureWebJobsStorage.
• task-hub-name (valfritt): Namnet på uppgiftshubben Durable Functions som ska användas. Som standard används namnet på aktivitetshubben i host.json-filen.

func durable rewind --id 0ab8c55a66644d68a3a8b220b12d209c --reason "Orchestrator failed and needs to be revived."

Rensa instanshistorik

Om du vill ta bort alla data som är associerade med en orkestrering kan du rensa instanshistoriken. Du kanske till exempel vill ta bort alla lagringsresurser som är associerade med en slutförd instans. Det gör du genom att använda rensningsinstans-API:et som definierats av orkestreringsklienten.

Det här första exemplet visar hur du rensar en enda orkestreringsinstans.

C#

[FunctionName("PurgeInstanceHistory")]
public static Task Run(
    [DurableClient] IDurableOrchestrationClient client,
    [QueueTrigger("purge-queue")] string instanceId)
{
    return client.PurgeInstanceHistoryAsync(instanceId);
}

JavaScript

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

module.exports = async function(context, instanceId) {
    const client = df.getClient(context);
    return client.purgeInstanceHistory(instanceId);
};

Se Startinstanser för konfigurationen av function.json.

Python

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

async def main(req: func.HttpRequest, starter: str, instance_id: str) -> func.HttpResponse:
    client = df.DurableOrchestrationClient(starter)

    return await client.purge_instance_history(instance_id)

PowerShell

Kommentar

Den här funktionen stöds för närvarande inte i PowerShell, men kan uppnås med http-API:et durable functions.

Java

@FunctionName("PurgeInstance")
public HttpResponseMessage purgeInstance(
        @HttpTrigger(name = "req", methods = {HttpMethod.POST}, route = "purge/{instanceID}") HttpRequestMessage<?> req,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext,
        @BindingName("instanceID") String instanceID) {
    PurgeResult result = durableContext.getClient().purgeInstance(instanceID);
    if (result.getDeletedInstanceCount() == 0) {
        return req.createResponseBuilder(HttpStatus.NOT_FOUND)
                .body("No completed instance with ID '" + instanceID + "' was found!")
                .build();
    } else {
        return req.createResponseBuilder(HttpStatus.OK)
                .body("Successfully purged data for " + instanceID)
                .build();
    }
}

I nästa exempel visas en timerutlöst funktion som rensar historiken för alla orkestreringsinstanser som har slutförts efter det angivna tidsintervallet. I det här fallet tar den bort data för alla instanser som slutfördes för 30 dagar sedan. Den här exempelfunktionen är schemalagd att köras en gång per dag kl. 12:00 UTC:

C#

[FunctionName("PurgeInstanceHistory")]
public static Task Run(
    [DurableClient] IDurableOrchestrationClient client,
    [TimerTrigger("0 0 12 * * *")] TimerInfo myTimer)
{
    return client.PurgeInstanceHistoryAsync(
        DateTime.MinValue,
        DateTime.UtcNow.AddDays(-30),  
        new List<OrchestrationStatus>
        {
            OrchestrationStatus.Completed
        });
}

Kommentar

Den tidigare C#-koden är för Durable Functions 2.x. För Durable Functions 1.x måste du använda OrchestrationClient attributet i stället för DurableClient attributet och du måste använda DurableOrchestrationClient parametertypen i stället för IDurableOrchestrationClient. Mer information om skillnaderna mellan versioner finns i artikeln Durable Functions-versioner .

JavaScript

Metoden purgeInstanceHistoryBy kan användas för att villkorligt rensa instanshistorik för flera instanser.

function.json

{
  "bindings": [
    {
      "schedule": "0 0 12 * * *",
      "name": "myTimer",
      "type": "timerTrigger",
      "direction": "in"
    },
    {
      "name": "starter",
      "type": "durableClient",
      "direction": "in"
    }
  ],
  "disabled": false
}

Kommentar

Det här exemplet är avsett för Durable Functions version 2.x. I version 1.x använder du orchestrationClient i stället för durableClient.

index.js

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

module.exports = async function (context, myTimer) {
    const client = df.getClient(context);
    const createdTimeFrom = new Date(0);
    const createdTimeTo = new Date().setDate(today.getDate() - 30);
    const runtimeStatuses = [ df.OrchestrationRuntimeStatus.Completed ];
    return client.purgeInstanceHistoryBy(createdTimeFrom, createdTimeTo, runtimeStatuses);
};

PowerShell

Kommentar

Den här funktionen stöds för närvarande inte i PowerShell, men kan uppnås med http-API:et durable functions.

Python

import azure.functions as func
import azure.durable_functions as df
from azure.durable_functions.models.DurableOrchestrationStatus import OrchestrationRuntimeStatus
from datetime import datetime, timedelta

async def main(req: func.HttpRequest, starter: str, instance_id: str) -> func.HttpResponse:
    client = df.DurableOrchestrationClient(starter)
    created_time_from = datetime.min
    created_time_to = datetime.today() + timedelta(days = -30)
    runtime_statuses = [OrchestrationRuntimeStatus.Completed]

    return await client.purge_instance_history_by(created_time_from, created_time_to, runtime_statuses)

Java

@FunctionName("PurgeInstances")
public void purgeInstances(
        @TimerTrigger(name = "purgeTimer", schedule = "0 0 12 * * *") String timerInfo,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext,
        ExecutionContext context) throws TimeoutException {
    PurgeInstanceCriteria criteria = new PurgeInstanceCriteria()
            .setCreatedTimeFrom(Instant.now().minus(Duration.ofDays(60)))
            .setCreatedTimeTo(Instant.now().minus(Duration.ofDays(30)))
            .setRuntimeStatusList(List.of(OrchestrationRuntimeStatus.COMPLETED));
    PurgeResult result = durableContext.getClient().purgeInstances(criteria);
    context.getLogger().info(String.format("Purged %d instance(s)", result.getDeletedInstanceCount()));
}

Kommentar

För att rensningshistoriken ska lyckas måste körningsstatusen för målinstansen vara Slutförd, Avslutad eller Misslyckad.

Azure Functions Core Tools

Du kan rensa orkestreringsinstansens historik med hjälp func durable purge-history av kommandot i Core Tools. I likhet med det andra C#-exemplet i föregående avsnitt rensas historiken för alla orkestreringsinstanser som skapats under ett angivet tidsintervall. Du kan ytterligare filtrera rensade instanser efter körningsstatus.

Kommentar

Core Tools-kommandona stöds för närvarande endast när azure storage-standardprovidern används för att bevara körningstillståndet.

Kommandot durable purge-history har flera parametrar:

• created-after (valfritt): Rensa historiken för instanser som skapats efter detta datum/tid (UTC). ISO 8601-formaterade datetimes accepteras.
• created-before (valfritt): Rensa historiken för instanser som skapats före detta datum/tid (UTC). ISO 8601-formaterade datetimes accepteras.
• runtime-status (valfritt): Rensa historiken för instanser med en viss status (till exempel att köra eller slutföra). Kan ge flera (blankstegsavgränsade) statusar.
• connection-string-setting(valfritt): Namnet på programinställningen som innehåller lagringen anslutningssträng att använda. Standardvärdet är AzureWebJobsStorage.
• task-hub-name (valfritt): Namnet på uppgiftshubben Durable Functions som ska användas. Som standard används namnet på aktivitetshubben i host.json-filen.

Följande kommando tar bort historiken för alla misslyckade instanser som skapades före den 14 november 2021 kl. 19:35 (UTC).

func durable purge-history --created-before 2021-11-14T19:35:00.0000000Z --runtime-status failed

Ta bort en aktivitetshubb

func durable delete-task-hub Med kommandot i Core Tools kan du ta bort alla lagringsartefakter som är associerade med en viss aktivitetshubb, inklusive Azure-lagringstabeller, köer och blobar.

Kommentar

Core Tools-kommandona stöds för närvarande endast när azure storage-standardprovidern används för att bevara körningstillståndet.

Kommandot durable delete-task-hub har två parametrar:

• connection-string-setting(valfritt): Namnet på programinställningen som innehåller lagringen anslutningssträng att använda. Standardvärdet är AzureWebJobsStorage.
• task-hub-name (valfritt): Namnet på uppgiftshubben Durable Functions som ska användas. Som standard används namnet på aktivitetshubben i host.json-filen.

Följande kommando tar bort alla Azure Storage-data som är associerade med UserTest aktivitetshubben.

func durable delete-task-hub --task-hub-name UserTest

Nästa steg

Lär dig hur du hanterar versionshantering

Inbyggd HTTP API-referens för instanshantering