Instanties in Durable Functions in azure beherenManage instances in Durable Functions in Azure

Als u de extensie Durable functions gebruikt voor Azure functions of als u dit wilt doen, moet u ervoor zorgen dat u het beste kunt profiteren.If you're using the Durable Functions extension for Azure Functions, or want to start doing so, make sure you're getting the best use out of it. U kunt uw Durable Functions Orchestration-instanties optimaliseren door te leren hoe u deze beheert.You can optimize your Durable Functions orchestration instances by learning more about how to manage them. In dit artikel worden de details van elke bewerking van exemplaar beheer beschreven.This article goes into the details of each instance management operation.

U kunt bijvoorbeeld exemplaren starten en beëindigen, en u kunt een query uitvoeren op instanties, met inbegrip van de mogelijkheid om query's uit te zoeken op alle exemplaren en query instanties met filters.You can start and terminate instances, for example, and you can query instances, including the ability to query all instances and query instances with filters. Daarnaast kunt u gebeurtenissen naar instanties verzenden, wachten op de Orchestration-voltooiing en de HTTP Management-webhook-Url's ophalen.Additionally, you can send events to instances, wait for orchestration completion, and retrieve HTTP management webhook URLs. In dit artikel worden ook andere beheer bewerkingen behandeld, zoals het terugspoelen van instanties, het opschonen van de exemplaar geschiedenis en het verwijderen van een taak hub.This article covers other management operations, too, including rewinding instances, purging instance history, and deleting a task hub.

In Durable Functions kunt u kiezen hoe u elk van deze beheer bewerkingen wilt implementeren.In Durable Functions, you have options for how you want to implement each of these management operations. In dit artikel vindt u voor beelden van de Azure functions core tools voor .netC#() en Java script.This article provides examples that use the Azure Functions Core Tools for both .NET (C#) and JavaScript.

Instanties startenStart instances

Het is belang rijk om een instantie van indeling te kunnen starten.It's important to be able to start an instance of orchestration. Dit wordt vaak gedaan wanneer u een Durable Functions binding in de trigger van een andere functie gebruikt.This is commonly done when you are using a Durable Functions binding in another function's trigger.

Met de methode StartNewAsync op de DurableOrchestrationClient (.net) startNew of op DurableOrchestrationClient de (Java script) wordt een nieuw exemplaar gestart.The StartNewAsync method on the DurableOrchestrationClient (.NET) or startNew on the DurableOrchestrationClient (JavaScript) starts a new instance. U verkrijgt instanties van deze klasse met behulp van de orchestrationClient binding.You acquire instances of this class by using the orchestrationClient binding. Intern in deze methode een bericht in de controle wachtrij, waarmee vervolgens het begin van een functie wordt geactiveerd met de opgegeven naam die de orchestrationTrigger trigger binding gebruikt.Internally, this method enqueues a message into the control queue, which then triggers the start of a function with the specified name that uses the orchestrationTrigger trigger binding.

Deze asynchrone bewerking is voltooid wanneer het Orchestration-proces is gepland.This async operation completes when the orchestration process is successfully scheduled. Het Orchestration-proces moet binnen 30 seconden beginnen.The orchestration process should start within 30 seconds. Als het langer duurt, ziet u een TimeoutException.If it takes longer, you'll see a TimeoutException.

.NET.NET

De para meters voor StartNewAsync zijn als volgt:The parameters to StartNewAsync are as follows:

  • Naam: De naam van de Orchestrator-functie die moet worden gepland.Name: The name of the orchestrator function to schedule.
  • Invoer: Alle JSON-serialiseerbare gegevens die moeten worden door gegeven als invoer voor de Orchestrator-functie.Input: Any JSON-serializable data that should be passed as the input to the orchestrator function.
  • InstanceId: Beschrijving De unieke ID van het exemplaar.InstanceId: (Optional) The unique ID of the instance. Als u deze para meter niet opgeeft, gebruikt de methode een wille keurige ID.If you don't specify this parameter, the method uses a random ID.

Hier volgen enkele voorbeelden:Here are some examples:

C#C#

[FunctionName("HelloWorldManualStart")]
public static async Task Run(
    [ManualTrigger] string input,
    [OrchestrationClient] DurableOrchestrationClient starter,
    ILogger log)
{
    string instanceId = await starter.StartNewAsync("HelloWorld", input);
    log.LogInformation($"Started orchestration with ID = '{instanceId}'.");
}

Java script (alleen functies 2. x)JavaScript (Functions 2.x only)

De para meters startNew zijn als volgt:The parameters to startNew are as follows:

  • Naam: De naam van de Orchestrator-functie die moet worden gepland.Name: The name of the orchestrator function to schedule.
  • InstanceId: Beschrijving De unieke ID van het exemplaar.InstanceId: (Optional) The unique ID of the instance. Als u deze para meter niet opgeeft, gebruikt de methode een wille keurige ID.If you don't specify this parameter, the method uses a random ID.
  • Invoer: Beschrijving Alle JSON-serialiseerbare gegevens die moeten worden door gegeven als invoer voor de Orchestrator-functie.Input: (Optional) Any JSON-serializable data that should be passed as the input to the orchestrator function.

Hier volgt een eenvoudig voor beeld van Java script:Here is a simple JavaScript example:

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

Tip

Gebruik een wille keurige id voor de exemplaar-ID.Use a random identifier for the instance ID. Dit zorgt voor een gelijke belasting verdeling wanneer u Orchestrator-functies op meerdere Vm's wilt schalen.This helps ensure an equal load distribution when you're scaling orchestrator functions across multiple VMs. De juiste tijd voor het gebruik van niet-wille keurig exemplaar-Id's is wanneer de ID afkomstig moet zijn van een externe bron of wanneer u het Singleton-Orchestrator -patroon implementeert.The proper time to use non-random instance IDs is when the ID must come from an external source, or when you're implementing the singleton orchestrator pattern.

Azure Functions Core ToolsAzure Functions Core Tools

U kunt een exemplaar ook rechtstreeks starten met behulp van de Azure functions core tools durable start-new opdracht.You can also start an instance directly by using the Azure Functions Core Tools durable start-new command. Hierbij worden de volgende para meters gebruikt:It takes the following parameters:

  • (vereist): function-name De naam van de functie die moet worden gestart.function-name (required): Name of the function to start.
  • (optioneel): input Invoer voor de functie, hetzij inline of door middel van een JSON-bestand.input (optional): Input to the function, either inline or through a JSON file. Voor bestanden voegt u een voor voegsel toe aan het pad naar het @bestand met, @path/to/file.jsonzoals.For files, add a prefix to the path to the file with @, such as @path/to/file.json.
  • (optioneel): id ID van het Orchestration-exemplaar.id (optional): ID of the orchestration instance. Als u deze para meter niet opgeeft, gebruikt de opdracht een wille keurige GUID.If you don't specify this parameter, the command uses a random GUID.
  • (optioneel): connection-string-setting De naam van de toepassings instelling die de opslag connection string bevat die moet worden gebruikt.connection-string-setting (optional): Name of the application setting containing the storage connection string to use. De standaard waarde is AzureWebJobsStorage.The default is AzureWebJobsStorage.
  • (optioneel): task-hub-name De naam van de Durable Functions taak-hub die moet worden gebruikt.task-hub-name (optional): Name of the Durable Functions task hub to use. De standaard waarde is DurableFunctionsHub.The default is DurableFunctionsHub. U kunt dit ook instellen in host. json met behulp van DurableTask: HubName.You can also set this in host.json by using durableTask:HubName.

Notitie

In de kern Hulpprogramma's opdrachten wordt ervan uitgegaan dat u ze uitvoert vanuit de hoofdmap van een functie-app.Core Tools commands assume you are running them from the root directory of a function app. Als u de connection-string-setting para meters task-hub-name en expliciet opgeeft, kunt u de opdrachten vanuit elke directory uitvoeren.If you explicitly provide the connection-string-setting and task-hub-name parameters, you can run the commands from any directory. Hoewel u deze opdrachten kunt uitvoeren zonder dat er een functie-app wordt uitgevoerd, is het mogelijk dat u niet kunt zien wat sommige gevolgen hebben, tenzij de host wordt uitgevoerd.Although you can run these commands without a function app host running, you might find that you can't observe some effects unless the host is running. De start-new opdracht in bijvoorbeeld een start bericht naar de doel taak hub, maar de indeling wordt niet daad werkelijk uitgevoerd, tenzij er een functie-app-hostproces wordt uitgevoerd die het bericht kan verwerken.For example, the start-new command enqueues a start message into the target task hub, but the orchestration doesn't actually run unless there is a function app host process running that can process the message.

Met de volgende opdracht wordt de functie HelloWorld gestart en wordt de inhoud van het bestand counter-data.json door gegeven:The following command starts the function named HelloWorld, and passes the contents of the file counter-data.json to it:

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

Query-exemplarenQuery instances

Als onderdeel van uw inspanningen om uw orchestrations te beheren, moet u waarschijnlijk informatie verzamelen over de status van een Orchestration-exemplaar (bijvoorbeeld of het normaal of mislukt is voltooid).As part of your effort to manage your orchestrations, you'll most likely need to gather information about the status of an orchestration instance (for example, whether it has completed normally or failed).

De methode GetStatusAsync voor de klasse DurableOrchestrationClient (.net) of de getStatus methode in de DurableOrchestrationClient klasse (Java script) voert een query uit op de status van een Orchestration-exemplaar.The GetStatusAsync method on the DurableOrchestrationClient class (.NET) or the getStatus method on the DurableOrchestrationClient class (JavaScript) queries the status of an orchestration instance.

Het duurt een instanceId (vereist showHistory ), ( showHistoryOutput optioneel), (optioneel) en showInput (optioneel, alleen .net) als para meters.It takes an instanceId (required), showHistory (optional), showHistoryOutput (optional), and showInput (optional, .NET only) as parameters.

  • showHistory : Als deze is trueingesteld op, bevat het antwoord de uitvoerings geschiedenis.showHistory: If set to true, the response contains the execution history.
  • showHistoryOutput : Als deze is trueingesteld op, bevat de uitvoerings geschiedenis activiteiten uitvoer.showHistoryOutput: If set to true, the execution history contains activity outputs.
  • showInput : Als deze optie falseis ingesteld op, bevat het antwoord niet de invoer van de functie.showInput: If set to false, the response won't contain the input of the function. De standaardwaarde is true.The default value is true. (Alleen .NET)(.NET only)

De methode retourneert een JSON-object met de volgende eigenschappen:The method returns a JSON object with the following properties:

  • Naam: De naam van de Orchestrator-functie.Name: The name of the orchestrator function.
  • InstanceId: De exemplaar-id van de indeling (moet hetzelfde zijn als de instanceId invoer).InstanceId: The instance ID of the orchestration (should be the same as the instanceId input).
  • CreatedTime: Het tijdstip waarop de Orchestrator-functie is gestart.CreatedTime: The time at which the orchestrator function started running.
  • LastUpdatedTime: Het tijdstip waarop de indeling voor het laatst door een controle punt is ingesteld.LastUpdatedTime: The time at which the orchestration last checkpointed.
  • Invoer: De invoer van de functie als een JSON-waarde.Input: The input of the function as a JSON value. Dit veld wordt niet ingevuld als showInput is ingesteld op false.This field isn't populated if showInput is false.
  • CustomStatus: Aangepaste Orchestration-status in JSON-indeling.CustomStatus: Custom orchestration status in JSON format.
  • Uitvoer: De uitvoer van de functie als een JSON-waarde (als de functie is voltooid).Output: The output of the function as a JSON value (if the function has completed). Als de Orchestrator-functie is mislukt, bevat deze eigenschap de fout Details.If the orchestrator function failed, this property includes the failure details. Als de Orchestrator-functie is beëindigd, bevat deze eigenschap de reden voor de beëindiging (indien van toepassing).If the orchestrator function was terminated, this property includes the reason for the termination (if any).
  • RuntimeStatus: Een van de volgende waarden:RuntimeStatus: One of the following values:
    • In behandeling: Het exemplaar is gepland, maar is nog niet gestart.Pending: The instance has been scheduled but has not yet started running.
    • Uitvoeren: De uitvoering van het exemplaar is gestart.Running: The instance has started running.
    • Voltooid: Het exemplaar is normaal voltooid.Completed: The instance has completed normally.
    • ContinuedAsNew: Het exemplaar is opnieuw opgestart met een nieuwe geschiedenis.ContinuedAsNew: The instance has restarted itself with a new history. Dit is een tijdelijke status.This is a transient state.
    • Mislukt: Het exemplaar is mislukt met een fout.Failed: The instance failed with an error.
    • Beëindigd: Het exemplaar is abrupt gestopt.Terminated: The instance was stopped abruptly.
  • Geschiedenis: De uitvoerings geschiedenis van de indeling.History: The execution history of the orchestration. Dit veld wordt alleen ingevuld als showHistory deze is ingesteld op. trueThis field is only populated if showHistory is set to true.

Met deze methode null wordt geretourneerd of het exemplaar niet bestaat of nog niet is gestart.This method returns null if the instance either doesn't exist or has not yet started running.

C#C#

[FunctionName("GetStatus")]
public static async Task Run(
    [OrchestrationClient] DurableOrchestrationClient client,
    [ManualTrigger] string instanceId)
{
    var status = await client.GetStatusAsync(instanceId);
    // do something based on the current status.
}

Java script (alleen functies 2. x)JavaScript (Functions 2.x only)

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.
}

Azure Functions Core ToolsAzure Functions Core Tools

Het is ook mogelijk om de status van een indelings exemplaar rechtstreeks op te halen met behulp van de Azure functions core tools durable get-runtime-status opdracht.It's also possible to get the status of an orchestration instance directly, by using the Azure Functions Core Tools durable get-runtime-status command. Hierbij worden de volgende para meters gebruikt:It takes the following parameters:

  • (vereist): id ID van het Orchestration-exemplaar.id (required): ID of the orchestration instance.
  • (optioneel): show-input Als deze optie trueis ingesteld op, bevat het antwoord de invoer van de functie.show-input (optional): If set to true, the response contains the input of the function. De standaardwaarde is false.The default value is false.
  • (optioneel): show-output Als deze optie trueis ingesteld op, bevat het antwoord de uitvoer van de functie.show-output (optional): If set to true, the response contains the output of the function. De standaardwaarde is false.The default value is false.
  • (optioneel): connection-string-setting De naam van de toepassings instelling die de opslag connection string bevat die moet worden gebruikt.connection-string-setting (optional): Name of the application setting containing the storage connection string to use. De standaardwaarde is AzureWebJobsStorage.The default is AzureWebJobsStorage.
  • (optioneel): task-hub-name De naam van de Durable Functions taak-hub die moet worden gebruikt.task-hub-name (optional): Name of the Durable Functions task hub to use. De standaardwaarde is DurableFunctionsHub.The default is DurableFunctionsHub. Het kan ook in host. jsonworden ingesteld met behulp van DurableTask: HubName.It can also be set in host.json, by using durableTask:HubName.

Met de volgende opdracht wordt de status (inclusief invoer en uitvoer) opgehaald van een exemplaar met een indelings exemplaar-ID van 0ab8c55a66644d68a3a8b220b12d209c.The following command retrieves the status (including input and output) of an instance with an orchestration instance ID of 0ab8c55a66644d68a3a8b220b12d209c. Hierbij wordt ervan uitgegaan dat u de func opdracht uitvoert vanuit de hoofdmap van de functie-app:It assumes that you are running the func command from the root directory of the function app:

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

U kunt de durable get-history opdracht gebruiken om de geschiedenis van een Orchestration-exemplaar op te halen.You can use the durable get-history command to retrieve the history of an orchestration instance. Hierbij worden de volgende para meters gebruikt:It takes the following parameters:

  • (vereist): id ID van het Orchestration-exemplaar.id (required): ID of the orchestration instance.
  • (optioneel): connection-string-setting De naam van de toepassings instelling die de opslag connection string bevat die moet worden gebruikt.connection-string-setting (optional): Name of the application setting containing the storage connection string to use. De standaardwaarde is AzureWebJobsStorage.The default is AzureWebJobsStorage.
  • (optioneel): task-hub-name De naam van de Durable Functions taak-hub die moet worden gebruikt.task-hub-name (optional): Name of the Durable Functions task hub to use. De standaardwaarde is DurableFunctionsHub.The default is DurableFunctionsHub. Het kan ook in host. json worden ingesteld met behulp van durableTask: HubName.It can also be set in host.json, by using durableTask:HubName.
func durable get-history --id 0ab8c55a66644d68a3a8b220b12d209c

Query's uitvoeren op alle instantiesQuery all instances

In plaats van één exemplaar tegelijk in uw indeling te gebruiken, is het wellicht efficiënter om in één keer op alle query's te zoeken.Rather than query one instance in your orchestration at a time, you might find it more efficient to query all of them at once.

U kunt de GetStatusAsync (.net) of getStatusAll (Java script)-methode gebruiken om de status van alle indelings instanties op te vragen.You can use the GetStatusAsync (.NET) or getStatusAll (JavaScript) method to query the statuses of all orchestration instances. In .net kunt u een CancellationToken object door geven als u dit wilt annuleren.In .NET, you can pass a CancellationToken object in case you want to cancel it. De methode retourneert objecten met dezelfde eigenschappen als de GetStatusAsync methode met para meters.The method returns objects with the same properties as the GetStatusAsync method with parameters.

C#C#

[FunctionName("GetAllStatus")]
public static async Task Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")]HttpRequestMessage req,
    [OrchestrationClient] DurableOrchestrationClient client,
    ILogger log)
{
    IList<DurableOrchestrationStatus> instances = await client.GetStatusAsync(); // You can pass CancellationToken as a parameter.
    foreach (var instance in instances)
    {
        log.LogInformation(JsonConvert.SerializeObject(instance));
    };
}

Java script (alleen functies 2. x)JavaScript (Functions 2.x only)

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

Azure Functions Core ToolsAzure Functions Core Tools

Het is ook mogelijk rechtstreeks een query uit te zoeken op instanties met behulp van de Azure functions core tools durable get-instances opdracht.It's also possible to query instances directly, by using the Azure Functions Core Tools durable get-instances command. Hierbij worden de volgende para meters gebruikt:It takes the following parameters:

  • (optioneel): top Met deze opdracht wordt paginering ondersteund.top (optional): This command supports paging. Deze para meter komt overeen met het aantal exemplaren dat per aanvraag wordt opgehaald.This parameter corresponds to the number of instances retrieved per request. De standaard waarde is 10.The default is 10.
  • (optioneel): continuation-token Een token om aan te geven welke pagina of sectie met instanties moet worden opgehaald.continuation-token (optional): A token to indicate which page or section of instances to retrieve. Elke get-instances uitvoering retourneert een token naar de volgende set exemplaren.Each get-instances execution returns a token to the next set of instances.
  • (optioneel): connection-string-setting De naam van de toepassings instelling die de opslag connection string bevat die moet worden gebruikt.connection-string-setting (optional): Name of the application setting containing the storage connection string to use. De standaardwaarde is AzureWebJobsStorage.The default is AzureWebJobsStorage.
  • (optioneel): task-hub-name De naam van de Durable Functions taak-hub die moet worden gebruikt.task-hub-name (optional): Name of the Durable Functions task hub to use. De standaardwaarde is DurableFunctionsHub.The default is DurableFunctionsHub. Het kan ook in host. jsonworden ingesteld met behulp van DurableTask: HubName.It can also be set in host.json, by using durableTask:HubName.
func durable get-instances

Query's uitvoeren op exemplaren met filtersQuery instances with filters

Wat gebeurt er als u niet alle informatie nodig hebt die een Standard-exemplaar query kan bieden?What if you don't really need all the information that a standard instance query can provide? Wat als u bijvoorbeeld alleen zoekt naar de Orchestration-aanmaak tijd of de Orchestration runtime-status?For example, what if you're just looking for the orchestration creation time, or the orchestration runtime status? U kunt uw query beperken door filters toe te passen.You can narrow your query by applying filters.

Gebruik de GetStatusAsync (.net) of getStatusBy (Java script)-methode om een lijst op te halen met indelings instanties die overeenkomen met een set vooraf gedefinieerde filters.Use the GetStatusAsync (.NET) or getStatusBy (JavaScript) method to get a list of orchestration instances that match a set of predefined filters.

C#C#

[FunctionName("QueryStatus")]
public static async Task Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")]HttpRequestMessage req,
    [OrchestrationClient] DurableOrchestrationClient client,
    ILogger log)
{
    IEnumerable<OrchestrationRuntimeStatus> runtimeStatus = new List<OrchestrationRuntimeStatus> {
        OrchestrationRuntimeStatus.Completed,
        OrchestrationRuntimeStatus.Running
    };
    IList<DurableOrchestrationStatus> instances = await starter.GetStatusAsync(
        new DateTime(2018, 3, 10, 10, 1, 0),
        new DateTime(2018, 3, 10, 10, 23, 59),
        runtimeStatus
    ); // You can pass CancellationToken as a parameter.
    foreach (var instance in instances)
    {
        log.LogInformation(JsonConvert.SerializeObject(instance));
    };
}

Java script (alleen functies 2. x)JavaScript (Functions 2.x only)

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(2018, 3, 10, 10, 1, 0),
        new Date(2018, 3, 10, 10, 23, 59),
        runtimeStatus
    );
    instances.forEach((instance) => {
        context.log(JSON.stringify(instance));
    });
};

Azure Functions Core ToolsAzure Functions Core Tools

In de Azure functions core tools kunt u ook de durable get-instances opdracht met filters gebruiken.In the Azure Functions Core Tools, you can also use the durable get-instances command with filters. topNaast de voor noemde continuation-token``created-after runtime-status created-before,, task-hub-name , en-para meters kunt u drie filter parameters (, en) gebruiken. connection-string-settingIn addition to the aforementioned top, continuation-token, connection-string-setting, and task-hub-name parameters, you can use three filter parameters (created-after, created-before, and runtime-status).

  • (optioneel): created-after De instanties ophalen die zijn gemaakt na deze datum/tijd (UTC).created-after (optional): Retrieve the instances created after this date/time (UTC). ISO 8601 ingedeelde datum/tijd geaccepteerd.ISO 8601 formatted datetimes accepted.
  • (optioneel): created-before De instanties ophalen die zijn gemaakt voor deze datum/tijd (UTC).created-before (optional): Retrieve the instances created before this date/time (UTC). ISO 8601 ingedeelde datum/tijd geaccepteerd.ISO 8601 formatted datetimes accepted.
  • (optioneel): runtime-status Haal de instanties met een bepaalde status op (bijvoorbeeld uitgevoerd of voltooid).runtime-status (optional): Retrieve the instances with a particular status (for example, running or completed). Kan meerdere (spaties gescheiden) statussen bieden.Can provide multiple (space separated) statuses.
  • (optioneel): top Aantal opgehaalde exemplaren per aanvraag.top (optional): Number of instances retrieved per request. De standaard waarde is 10.The default is 10.
  • (optioneel): continuation-token Een token om aan te geven welke pagina of sectie met instanties moet worden opgehaald.continuation-token (optional): A token to indicate which page or section of instances to retrieve. Elke get-instances uitvoering retourneert een token naar de volgende set exemplaren.Each get-instances execution returns a token to the next set of instances.
  • (optioneel): connection-string-setting De naam van de toepassings instelling die de opslag connection string bevat die moet worden gebruikt.connection-string-setting (optional): Name of the application setting containing the storage connection string to use. De standaardwaarde is AzureWebJobsStorage.The default is AzureWebJobsStorage.
  • (optioneel): task-hub-name De naam van de Durable Functions taak-hub die moet worden gebruikt.task-hub-name (optional): Name of the Durable Functions task hub to use. De standaardwaarde is DurableFunctionsHub.The default is DurableFunctionsHub. Het kan ook in host. jsonworden ingesteld met behulp van DurableTask: HubName.It can also be set in host.json, by using durableTask:HubName.

Als u geen filterscreated-after(, created-before, of runtime-status) opgeeft, wordt met de opdracht simpelweg top instanties opgehaald, zonder rekening te houden met de runtime status of de aanmaak tijd.If you don't provide any filters (created-after, created-before, or runtime-status), the command simply retrieves top instances, with no regard to runtime status or creation time.

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

Exemplaren beëindigenTerminate instances

Als u een indelings instantie hebt die te lang duurt om uit te voeren, of als u deze alleen wilt stoppen voordat deze is voltooid, hebt u de mogelijkheid om deze te beëindigen.If you have an orchestration instance that is taking too long to run, or you just need to stop it before it completes for any reason, you have the option to terminate it.

U kunt de methode TerminateAsync van de klasse DurableOrchestrationClient (.net) of de terminate methode van de DurableOrchestrationClient klasse (Java script) gebruiken.You can use the TerminateAsync method of the DurableOrchestrationClient class (.NET), or the terminate method of the DurableOrchestrationClient class (JavaScript). De twee para meters instanceId zijn een reason en een teken reeks, die worden geschreven naar Logboeken en de status van het exemplaar.The two parameters are an instanceId and a reason string, which are written to logs and to the instance status. Een beëindigd exemplaar stopt zodra het await volgende (.net) of yield (Java script)-punt wordt bereikt, of het wordt onmiddellijk beëindigd als het al op een await of yieldis.A terminated instance stops running as soon as it reaches the next await (.NET) or yield (JavaScript) point, or it terminates immediately if it's already on an await or yield.

C#C#

[FunctionName("TerminateInstance")]
public static Task Run(
    [OrchestrationClient] DurableOrchestrationClient client,
    [ManualTrigger] string instanceId)
{
    string reason = "It was time to be done.";
    return client.TerminateAsync(instanceId, reason);
}

Java script (alleen functies 2. x)JavaScript (Functions 2.x only)

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

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

    const reason = "It was time to be done.";
    return client.terminate(instanceId, reason);
};

Notitie

Het beëindigen van het exemplaar wordt momenteel niet door gegeven.Instance termination doesn't currently propagate. Activiteit functies en subcontains worden uitgevoerd om te worden voltooid, ongeacht of u het Orchestrator-exemplaar dat deze heeft aangeroepen, hebt beëindigd.Activity functions and sub-orchestrations run to completion, regardless of whether you've terminated the orchestration instance that called them.

Azure Functions Core ToolsAzure Functions Core Tools

U kunt een Orchestration-exemplaar ook rechtstreeks beëindigen met behulp van de Azure functions core tools durable terminate opdracht.You can also terminate an orchestration instance directly, by using the Azure Functions Core Tools durable terminate command. Hierbij worden de volgende para meters gebruikt:It takes the following parameters:

  • (vereist): id ID van het te beëindigen Orchestrator-exemplaar.id (required): ID of the orchestration instance to terminate.
  • (optioneel): reason Reden voor beëindiging.reason (optional): Reason for termination.
  • (optioneel): connection-string-setting De naam van de toepassings instelling die de opslag connection string bevat die moet worden gebruikt.connection-string-setting (optional): Name of the application setting containing the storage connection string to use. De standaardwaarde is AzureWebJobsStorage.The default is AzureWebJobsStorage.
  • (optioneel): task-hub-name De naam van de Durable Functions taak-hub die moet worden gebruikt.task-hub-name (optional): Name of the Durable Functions task hub to use. De standaardwaarde is DurableFunctionsHub.The default is DurableFunctionsHub. Het kan ook in host. jsonworden ingesteld met behulp van DurableTask: HubName.It can also be set in host.json, by using durableTask:HubName.

Met de volgende opdracht wordt een Orchestrator-exemplaar met de ID 0ab8c55a66644d68a3a8b220b12d209c beëindigd:The following command terminates an orchestration instance with an ID of 0ab8c55a66644d68a3a8b220b12d209c:

func durable terminate --id 0ab8c55a66644d68a3a8b220b12d209c --reason "It was time to be done."

Gebeurtenissen naar instanties verzendenSend events to instances

In sommige gevallen is het belang rijk dat uw Orchestrator-functies kunnen wachten op externe gebeurtenissen en er kan worden geluisterd.In some scenarios, it's important for your orchestrator functions to be able to wait and listen for external events. Dit omvat controle functies en-functies die wachten op menselijke interactie.This includes monitor functions and functions that are waiting for human interaction.

Verzend gebeurtenis meldingen naar actieve instanties met behulp van de methode RaiseEventAsync van de klasse DurableOrchestrationClient (.net) raiseEvent of de methode DurableOrchestrationClient van de klasse (Java script).Send event notifications to running instances by using the RaiseEventAsync method of the DurableOrchestrationClient class (.NET) or the raiseEvent method of the DurableOrchestrationClient class (JavaScript). Exemplaren die deze gebeurtenissen kunnen afhandelen, zijn de instanties die wachten op het aanroepen van WaitForExternalEvent waitForExternalEvent (.net) of (Java script).Instances that can handle these events are those that are awaiting a call to WaitForExternalEvent (.NET) or waitForExternalEvent (JavaScript).

De para meters voor RaiseEventAsync (.net raiseEvent ) en (Java script) zijn als volgt:The parameters to RaiseEventAsync (.NET) and raiseEvent (JavaScript) are as follows:

  • InstanceId: De unieke ID van het exemplaar.InstanceId: The unique ID of the instance.
  • Eventname: De naam van de gebeurtenis die moet worden verzonden.EventName: The name of the event to send.
  • Event Data: Een JSON-serialiseerbare Payload die naar het exemplaar moet worden verzonden.EventData: A JSON-serializable payload to send to the instance.

C#C#

[FunctionName("RaiseEvent")]
public static Task Run(
    [OrchestrationClient] DurableOrchestrationClient client,
    [ManualTrigger] string instanceId)
{
    int[] eventData = new int[] { 1, 2, 3 };
    return client.RaiseEventAsync(instanceId, "MyEvent", eventData);
}

Java script (alleen functies 2. x)JavaScript (Functions 2.x only)

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

Belangrijk

Als er geen Orchestrator-exemplaar met de opgegeven exemplaar-ID is, of als het exemplaar niet op de opgegeven gebeurtenis naam wacht, wordt het gebeurtenis bericht verwijderd.If there is no orchestration instance with the specified instance ID, or if the instance is not waiting on the specified event name, the event message is discarded. Zie het github-probleemvoor meer informatie over dit gedrag.For more information about this behavior, see the GitHub issue.

Azure Functions Core ToolsAzure Functions Core Tools

U kunt ook rechtstreeks een gebeurtenis naar een Orchestration-instantie verhogen met behulp van de Azure functions core tools durable raise-event opdracht.You can also raise an event to an orchestration instance directly, by using the Azure Functions Core Tools durable raise-event command. Hierbij worden de volgende para meters gebruikt:It takes the following parameters:

  • (vereist): id ID van het Orchestration-exemplaar.id (required): ID of the orchestration instance.
  • (optioneel): event-name De naam van de gebeurtenis die moet worden verhoogd.event-name (optional): Name of the event to raise. De standaardwaarde is $"Event_{RandomGUID}".The default is $"Event_{RandomGUID}".
  • (optioneel): event-data Gegevens die naar de indelings instantie moeten worden verzonden.event-data (optional): Data to send to the orchestration instance. Dit kan het pad naar een JSON-bestand zijn, of u kunt de gegevens rechtstreeks op de opdracht regel opgeven.This can be the path to a JSON file, or you can provide the data directly on the command line.
  • (optioneel): connection-string-setting De naam van de toepassings instelling die de opslag connection string bevat die moet worden gebruikt.connection-string-setting (optional): Name of the application setting containing the storage connection string to use. De standaardwaarde is AzureWebJobsStorage.The default is AzureWebJobsStorage.
  • (optioneel): task-hub-name De naam van de Durable Functions taak-hub die moet worden gebruikt.task-hub-name (optional): Name of the Durable Functions task hub to use. De standaardwaarde is DurableFunctionsHub.The default is DurableFunctionsHub. Het kan ook in host. jsonworden ingesteld met behulp van DurableTask: HubName.It can also be set in host.json, by using 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

Wachten op de Orchestration-voltooiingWait for orchestration completion

In langlopende indelingen wilt u mogelijk wachten en de resultaten van een indeling ophalen.In long-running orchestrations, you may want to wait and get the results of an orchestration. In dergelijke gevallen is het ook handig om een time-outperiode in te stellen voor de indeling.In these cases, it's also useful to be able to define a timeout period on the orchestration. Als de time-out wordt overschreden, moet de status van de indeling worden geretourneerd in plaats van de resultaten.If the timeout is exceeded, the state of the orchestration should be returned instead of the results.

De klasse DurableOrchestrationClient toont een WaitForCompletionOrCreateCheckStatusResponseAsync -API in .net.The DurableOrchestrationClient class exposes a WaitForCompletionOrCreateCheckStatusResponseAsync API in .NET. U kunt deze API gebruiken om de daad werkelijke uitvoer van een Orchestration-exemplaar synchroon op te halen.You can use this API to get the actual output from an orchestration instance synchronously. In Java script maakt DurableOrchestrationClient de klasse een waitForCompletionOrCreateCheckStatusResponse API voor hetzelfde doel.In JavaScript, the DurableOrchestrationClient class exposes a waitForCompletionOrCreateCheckStatusResponse API for the same purpose. Als ze niet zijn ingesteld, gebruiken de methoden een standaard waarde van 10 seconden voor timeouten 1 seconde voor. retryIntervalWhen they are not set, the methods use a default value of 10 seconds for timeout, and 1 second for retryInterval.

Hier volgt een voor beeld van een HTTP-activerings functie die laat zien hoe u deze API gebruikt:Here is an example HTTP-trigger function that demonstrates how to use this API:

// 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.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,
            [OrchestrationClient] DurableOrchestrationClientBase starter,
            string functionName,
            ILogger log)
        {
            // Function input comes from the request content.
            dynamic 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));
        }
    }
}
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;

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

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

Roep de functie aan met de volgende regel.Call the function with the following line. Gebruik 2 seconden voor de time-out en 0,5 seconden voor het interval voor nieuwe pogingen:Use 2 seconds for the timeout and 0.5 seconds for the retry interval:

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

Afhankelijk van de tijd die nodig is om de reactie van de Orchestration-instantie op te halen, zijn er twee situaties:Depending on the time required to get the response from the orchestration instance, there are two cases:

  • De indelings instanties worden binnen de gedefinieerde time-out (in dit geval 2 seconden) voltooid en het antwoord is de daad werkelijke indelings uitvoer van het exemplaar dat synchroon wordt bezorgd:The orchestration instances complete within the defined timeout (in this case 2 seconds), and the response is the actual orchestration instance output, delivered synchronously:

        HTTP/1.1 200 OK
        Content-Type: application/json; charset=utf-8
        Date: Thu, 14 Dec 2017 06:14:29 GMT
        Server: Microsoft-HTTPAPI/2.0
        Transfer-Encoding: chunked
    
        [
            "Hello Tokyo!",
            "Hello Seattle!",
            "Hello London!"
        ]
    
  • De indelings instanties kunnen niet binnen de ingestelde time-out worden voltooid en het antwoord is de standaard die wordt beschreven in http API-URL-detectie:The orchestration instances can't complete within the defined timeout, and the response is the default one described in HTTP API URL discovery:

        HTTP/1.1 202 Accepted
        Content-Type: application/json; charset=utf-8
        Date: Thu, 14 Dec 2017 06:13:51 GMT
        Location: http://localhost:7071/admin/extensions/DurableTaskExtension/instances/d3b72dddefce4e758d92f4d411567177?taskHub={taskHub}&connection={connection}&code={systemKey}
        Retry-After: 10
        Server: Microsoft-HTTPAPI/2.0
        Transfer-Encoding: chunked
    
        {
            "id": "d3b72dddefce4e758d92f4d411567177",
            "sendEventPostUri": "http://localhost:7071/admin/extensions/DurableTaskExtension/instances/d3b72dddefce4e758d92f4d411567177/raiseEvent/{eventName}?taskHub={taskHub}&connection={connection}&code={systemKey}",
            "statusQueryGetUri": "http://localhost:7071/admin/extensions/DurableTaskExtension/instances/d3b72dddefce4e758d92f4d411567177?taskHub={taskHub}&connection={connection}&code={systemKey}",
            "terminatePostUri": "http://localhost:7071/admin/extensions/DurableTaskExtension/instances/d3b72dddefce4e758d92f4d411567177/terminate?reason={text}&taskHub={taskHub}&connection={connection}&code={systemKey}",
            "rewindPostUri": "https://localhost:7071/admin/extensions/DurableTaskExtension/instances/d3b72dddefce4e758d92f4d411567177/rewind?reason={text}&taskHub={taskHub}&connection={connection}&code={systemKey}"
        }
    

Notitie

De indeling van de webhook-Url's kan verschillen, afhankelijk van de versie van de Azure Functions host die u uitvoert.The format of the webhook URLs might differ, depending on which version of the Azure Functions host you are running. Het vorige voor beeld is voor de host Azure Functions 2. x.The preceding example is for the Azure Functions 2.x host.

Url's voor HTTP Management webhook ophalenRetrieve HTTP management webhook URLs

U kunt een extern systeem gebruiken om gebeurtenissen in een indeling te controleren of te verhogen.You can use an external system to monitor or raise events to an orchestration. Externe systemen kunnen communiceren met Durable Functions via de webhook-Url's die deel uitmaken van het standaard antwoord dat wordt beschreven in http API-URL-detectie.External systems can communicate with Durable Functions through the webhook URLs that are part of the default response described in HTTP API URL discovery. De webhook-Url's zijn echter ook programmatisch toegankelijk in de Orchestration-client of in een activiteit functie.However, the webhook URLs also can be accessed programmatically in the orchestration client or in an activity function. Doe dit met behulp van de methode CreateHttpManagementPayload van de klasse DurableOrchestrationClient (.net) of createHttpManagementPayload de methode van DurableOrchestrationClient de klasse (Java script).Do this by using the CreateHttpManagementPayload method of the DurableOrchestrationClient class (.NET), or the createHttpManagementPayload method of the DurableOrchestrationClient class (JavaScript).

CreateHttpManagementPayload en createHttpManagementPayload hebben één para meter:CreateHttpManagementPayload and createHttpManagementPayload have one parameter:

  • instanceId: De unieke ID van het exemplaar.instanceId: The unique ID of the instance.

De methoden retour neren een exemplaar van HttpManagementPayload (.net) of een object (Java script) met de volgende teken reeks eigenschappen:The methods return an instance of HttpManagementPayload (.NET) or an object (JavaScript), with the following string properties:

  • Id: De exemplaar-id van de indeling (moet hetzelfde zijn als de InstanceId invoer).Id: The instance ID of the orchestration (should be the same as the InstanceId input).
  • StatusQueryGetUri: De status-URL van het Orchestrator-exemplaar.StatusQueryGetUri: The status URL of the orchestration instance.
  • SendEventPostUri: De URL van de functie ' raise ' van het Orchestrator-exemplaar.SendEventPostUri: The "raise event" URL of the orchestration instance.
  • TerminatePostUri: De ' Terminate ' URL van het Orchestrator-exemplaar.TerminatePostUri: The "terminate" URL of the orchestration instance.
  • RewindPostUri: De ' rewinde ' URL van het Orchestrator-exemplaar.RewindPostUri: The "rewind" URL of the orchestration instance.

Activiteit functies kunnen een exemplaar van deze objecten naar externe systemen verzenden om gebeurtenissen te controleren of te verhogen naar een indeling:Activity functions can send an instance of these objects to external systems to monitor or raise events to an orchestration:

C#C#

[FunctionName("SendInstanceInfo")]
public static void SendInstanceInfo(
    [ActivityTrigger] DurableActivityContext ctx,
    [OrchestrationClient] DurableOrchestrationClient client,
    [DocumentDB(
        databaseName: "MonitorDB",
        collectionName: "HttpManagementPayloads",
        ConnectionStringSetting = "CosmosDBConnection")]out dynamic document)
{
    HttpManagementPayload payload = client.CreateHttpManagementPayload(ctx.InstanceId);

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

Java script (alleen functies 2. x)JavaScript (Functions 2.x only)

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 Cosmos DB
    context.bindings.document = JSON.stringify({
        id: ctx.instanceId,
        payload,
    });
};

Instanties terugspoelen (preview-versie)Rewind instances (preview)

Als u een indelings fout hebt om een onverwachte reden, kunt u het exemplaar terugspoelen naar een eerder gezonde status door gebruik te maken van een API die hiervoor is gemaakt.If you have an orchestration failure for an unexpected reason, you can rewind the instance to a previously healthy state by using an API built for that purpose.

Notitie

Deze API is niet bedoeld als vervanging voor het correct afhandelen van fouten en het beleid voor opnieuw proberen.This API is not intended to be a replacement for proper error handling and retry policies. In plaats daarvan is het alleen bedoeld om te worden gebruikt in gevallen waarin indelings instanties om onverwachte redenen mislukken.Rather, it is intended to be used only in cases where orchestration instances fail for unexpected reasons. Zie het onderwerp fout afhandeling voor meer informatie over het verwerken van fouten en het opnieuw proberen van het beleid.For more details on error handling and retry policies, see the Error handling topic.

Gebruik de API van RewindAsync (.net rewindAsync ) of (Java script) om de indeling weer in te stellen op de status wordt uitgevoerd .Use the RewindAsync (.NET) or rewindAsync (JavaScript) API to put the orchestration back into the Running state. Voer de activiteit of de uitvoerings fouten van de suborchestrator die de Orchestration-fout hebben veroorzaakt, opnieuw uit.Rerun the activity or suborchestration execution failures that caused the orchestration failure.

Stel bijvoorbeeld dat u een werk stroom hebt met een reeks Human goed keuringen.For example, let's say you have a workflow involving a series of human approvals. Stel dat er een reeks activiteit functies zijn die iemand verwittigen dat hun goed keuring nodig is, en wacht de realtime respons.Suppose there are a series of activity functions that notify someone that their approval is needed, and wait out the real-time response. Wanneer alle goedkeurings activiteiten antwoorden hebben ontvangen of een time-out hebben, wordt ervan uitgegaan dat een andere activiteit mislukt als gevolg van een onjuiste configuratie van een toepassing, zoals een ongeldige data base connection string.After all of the approval activities have received responses or timed out, suppose that another activity fails due to an application misconfiguration, such as an invalid database connection string. Het resultaat is een indelings fout diep in de werk stroom.The result is an orchestration failure deep into the workflow. Met de RewindAsync API (.net) rewindAsync of (Java script) kan een toepassings beheerder de configuratie fout herstellen en de mislukte indeling terugspoelen naar de status direct vóór de fout.With the RewindAsync (.NET) or rewindAsync (JavaScript) API, an application administrator can fix the configuration error, and rewind the failed orchestration back to the state immediately before the failure. Geen van de stappen voor menselijke interactie moet opnieuw worden goedgekeurd en de indeling kan nu worden voltooid.None of the human-interaction steps need to be reapproved, and the orchestration can now complete successfully.

Notitie

De functie rewenteling biedt geen ondersteuning voor het terugspoelen van indelings instanties die gebruikmaken van duurzame timers.The rewind feature doesn't support rewinding orchestration instances that use durable timers.

C#C#

[FunctionName("RewindInstance")]
public static Task Run(
    [OrchestrationClient] DurableOrchestrationClient client,
    [ManualTrigger] string instanceId)
{
    string reason = "Orchestrator failed and needs to be revived.";
    return client.RewindAsync(instanceId, reason);
}

Java script (alleen functies 2. x)JavaScript (Functions 2.x only)

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

Azure Functions Core ToolsAzure Functions Core Tools

U kunt een Orchestration-exemplaar ook rechtstreeks terugspoelen met behulp van de Azure functions core tools durable rewind opdracht.You can also rewind an orchestration instance directly by using the Azure Functions Core Tools durable rewind command. Hierbij worden de volgende para meters gebruikt:It takes the following parameters:

  • (vereist): id ID van het Orchestration-exemplaar.id (required): ID of the orchestration instance.
  • (optioneel): reason De reden voor het terugspoelen van het Orchestration-exemplaar.reason (optional): Reason for rewinding the orchestration instance.
  • (optioneel): connection-string-setting De naam van de toepassings instelling die de opslag connection string bevat die moet worden gebruikt.connection-string-setting (optional): Name of the application setting containing the storage connection string to use. De standaardwaarde is AzureWebJobsStorage.The default is AzureWebJobsStorage.
  • (optioneel): task-hub-name De naam van de Durable Functions taak-hub die moet worden gebruikt.task-hub-name (optional): Name of the Durable Functions task hub to use. De standaardwaarde is DurableFunctionsHub.The default is DurableFunctionsHub. Het kan ook in host. jsonworden ingesteld met behulp van DurableTask: HubName.It can also be set in host.json, by using durableTask:HubName.
func durable rewind --id 0ab8c55a66644d68a3a8b220b12d209c --reason "Orchestrator failed and needs to be revived."

Instantie geschiedenis opschonenPurge instance history

Als u alle gegevens wilt verwijderen die zijn gekoppeld aan een indeling, kunt u de instantie geschiedenis wissen.To remove all the data associated with an orchestration, you can purge the instance history. Zo wilt u misschien Azure Table-rijen en grote bericht-blobs verwijderen, indien aanwezig.For example, you might want to get rid of Azure Table rows and large message blobs, if they exist. Als u dit wilt doen, gebruikt u de PurgeInstanceHistoryAsync -API.To do so, use the PurgeInstanceHistoryAsync API.

Notitie

De PurgeInstanceHistoryAsync API is momenteel alleen beschikbaar voor C#.The PurgeInstanceHistoryAsync API is currently available only for C#.

De methode heeft twee Overloads.The method has two overloads. De eerste keer dat de geschiedenis wordt gewist met de ID van het Orchestrator-exemplaar:The first one purges history by the ID of the orchestration instance:

C#C#

[FunctionName("PurgeInstanceHistory")]
public static Task Run(
    [OrchestrationClient] DurableOrchestrationClient client,
    [ManualTrigger] string instanceId)
{
    return client.PurgeInstanceHistoryAsync(instanceId);
}

In het tweede voor beeld ziet u een door een timer geactiveerde functie die de geschiedenis van alle Orchestration-instanties die zijn voltooid na het opgegeven tijds interval verwijdert.The second example shows a timer-triggered function that purges the history for all orchestration instances that completed after the specified time interval. In dit geval worden gegevens verwijderd voor alle exemplaren die 30 of meer dagen geleden zijn voltooid.In this case, it removes data for all instances completed 30 or more days ago. Het is gepland om één keer per dag uit te voeren, om 12 uur:It's scheduled to run once per day, at 12 AM:

C#C#

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

Notitie

De runtime status moet worden voltooid, beëindigdof misluktals het functie proces met tijd activering slaagt.For the time-triggered function process to succeed, the runtime status must be Completed, Terminated, or Failed.

Azure Functions Core ToolsAzure Functions Core Tools

U kunt de geschiedenis van een Orchestrator-exemplaar opschonen met behulp van de Azure functions core tools durable purge-history opdracht.You can purge an orchestration instance's history by using the Azure Functions Core Tools durable purge-history command. Net als bij het C# tweede voor beeld in de voor gaande sectie, wordt de geschiedenis van alle Orchestration-instanties die tijdens een opgegeven tijds interval zijn gemaakt, verwijderd.Similar to the second C# example in the preceding section, it purges the history for all orchestration instances created during a specified time interval. U kunt opschoonde instanties verder filteren op runtime status.You can further filter purged instances by runtime status. De opdracht heeft verschillende para meters:The command has several parameters:

  • (optioneel): created-after De geschiedenis van exemplaren die zijn gemaakt na deze datum/tijd (UTC) opschonen.created-after (optional): Purge the history of instances created after this date/time (UTC). ISO 8601 ingedeelde datum/tijd geaccepteerd.ISO 8601 formatted datetimes accepted.
  • (optioneel): created-before De geschiedenis van exemplaren die zijn gemaakt voor deze datum/tijd (UTC) opschonen.created-before (optional): Purge the history of instances created before this date/time (UTC). ISO 8601 ingedeelde datum/tijd geaccepteerd.ISO 8601 formatted datetimes accepted.
  • (optioneel): runtime-status De geschiedenis van instanties met een bepaalde status opschonen (bijvoorbeeld uitgevoerd of voltooid).runtime-status (optional): Purge the history of instances with a particular status (for example, running or completed). Kan meerdere (spaties gescheiden) statussen bieden.Can provide multiple (space separated) statuses.
  • (optioneel): connection-string-setting De naam van de toepassings instelling die de opslag connection string bevat die moet worden gebruikt.connection-string-setting (optional): Name of the application setting containing the storage connection string to use. De standaardwaarde is AzureWebJobsStorage.The default is AzureWebJobsStorage.
  • (optioneel): task-hub-name De naam van de Durable Functions taak-hub die moet worden gebruikt.task-hub-name (optional): Name of the Durable Functions task hub to use. De standaardwaarde is DurableFunctionsHub.The default is DurableFunctionsHub. Het kan ook in host. jsonworden ingesteld met behulp van DurableTask: HubName.It can also be set in host.json, by using durableTask:HubName.

Met de volgende opdracht wordt de geschiedenis van alle mislukte instanties verwijderd die zijn gemaakt vóór 14 november 2018 om 7:35 uur (UTC).The following command deletes the history of all failed instances created before November 14, 2018 at 7:35 PM (UTC).

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

Een task hub verwijderenDelete a task hub

Met de Azure functions core tools durable delete-task-hub opdracht kunt u alle opslag artefacten verwijderen die zijn gekoppeld aan een bepaalde taak hub.Using the Azure Functions Core Tools durable delete-task-hub command, you can delete all storage artifacts associated with a particular task hub. Dit omvat Azure Storage-tabellen,-wacht rijen en-blobs.This includes Azure storage tables, queues, and blobs. De opdracht heeft twee para meters:The command has two parameters:

  • (optioneel): connection-string-setting De naam van de toepassings instelling die de opslag connection string bevat die moet worden gebruikt.connection-string-setting (optional): Name of the application setting containing the storage connection string to use. De standaardwaarde is AzureWebJobsStorage.The default is AzureWebJobsStorage.
  • (optioneel): task-hub-name De naam van de Durable Functions taak-hub die moet worden gebruikt.task-hub-name (optional): Name of the Durable Functions task hub to use. De standaardwaarde is DurableFunctionsHub.The default is DurableFunctionsHub. Het kan ook in host. jsonworden ingesteld met behulp van DurableTask: HubName.It can also be set in host.json, by using durableTask:HubName.

Met de volgende opdracht worden alle Azure Storage-gegevens verwijderd UserTest die zijn gekoppeld aan de taak hub.The following command deletes all Azure storage data associated with the UserTest task hub.

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

Volgende stappenNext steps