Orchestrator
2023.4
False
Managing Jobs - Standalone 2023.4
Bannerhintergrundbild
Logo
Orchestrator-Anleitung
Letzte Aktualisierung 6. Dez. 2023

Jobs verwalten

Starten eines Jobs

Bevor Sie die folgenden Schritte ausführen, müssen Sie einen Prozess erstellen.

  1. Navigieren Sie in dem Ordner, in dem sich der Prozess befindet, zu Automatisierungen > Aufträge.
  2. Klicken Sie auf Starten. Das Fenster Auftrag starten wird angezeigt.
  3. Wählen Sie in der Dropdownliste Prozessname einen Prozess aus, der zuvor im aktuellen Ordner bereitgestellt wurde.
  4. Konfigurieren Sie die erforderlichen Felder, wie in den folgenden Abschnitten beschrieben.
  5. Klicken Sie auf Starten. Das Fenster Auftrag starten wird geschlossen und wenn im aktuell aktiven Ordner Laufzeiten verfügbar sind, wird der Auftrag auf einem Roboter entsprechend den von Ihnen vorgenommenen Einstellungen gestartet. Der Status des Auftrags wird in Echtzeit auf der Seite Aufträge angezeigt.

Festlegen der Auftragspriorität

Wählen Sie in der Dropdown-Liste Auftragspriorität die Priorität des auszuführenden Auftrags aus, wenn sie sich von der auf Prozessebene festgelegten Priorität unterscheiden soll. Dieses Feld wird automatisch mit der vom Paket geerbten Priorität aufgefüllt.

Auswählen der Ausführungslaufzeit

Wählen Sie aus der Dropdownliste Runtime-Typ den Runtime-Typ aus, der zum Ausführen des Auftrags verwendet wird.

Die Anzahl der verfügbaren und verbundenen Runtimes wird unter der Dropdownliste angezeigt.

  • _ Verfügbar – Die Anzahl der verfügbaren Laufzeiten, berechnet als die Gesamtzahl der Laufzeiten abzüglich der Anzahl der ausgeführten Aufträge.
  • _ Verbunden – Die Gesamtanzahl der Laufzeiten, berechnet als Summe der Laufzeiten auf allen Maschinen, die mit dem Orchestrator verbunden sind, der dem aktiven Ordner zugeordnet ist.

    Runtime-Typ

    Beschreibung

    Produktion (Unattended)

    Der Auftrag wird im Unattended-Modus ausgeführt und verbraucht eine Unattended-Laufzeit.

    Tests

    Der Auftrag wird im Unattended-Modus ausgeführt und verbraucht eine Testing-Laufzeit.

    Nichtproduktiv (NonProduction)

    Der Auftrag wird im Unattended-Modus ausgeführt und verbraucht eine NonProduction-Laufzeit.

    Cloud - Serverless Testing

    Der Auftrag wird im Unattended-Modus auf einer serverlosen Robotermaschine ausgeführt, die für die Ausführung in einer Testumgebung konfiguriert wurde. Die Anzahl der erforderlichen Robot Units ist spezifisch für Testumgebungen und hängt von der Größe der serverlosen Robotermaschine und der Anzahl der Minuten ab, die zum Ausführen eines Auftrags benötigt werden.

    Weitere Informationen finden Sie unter Robot Units – Verbrauch.

    Cloud - Serverless

    Der Auftrag wird im Unattended-Modus auf einer serverlosen Robotermaschine ausgeführt, die für die Ausführung in einer Produktionsumgebung konfiguriert wurde. Die Anzahl der erforderlichen Robotereinheiten ist spezifisch für Produktionsumgebungen und hängt von der Größe der serverlosen Robotermaschine und der Anzahl der Minuten ab, die zum Ausführen eines Auftrags benötigt wird.

    Weitere Informationen finden Sie unter Robot Units – Verbrauch.

    Cloud - VM Testing

    Der Auftrag wird im Unattended-Modus auf einer Cloud-VM ausgeführt, die für die Ausführung in einer Testing- oder Non-Production-Umgebung konfiguriert wurde. Beim Ausführen der VM werden die Robot Units für Testumgebungen verbraucht.

    Weitere Informationen finden Sie unter Robot Units – Verbrauch.

    Cloud – VM

    Der Auftrag wird im Unattended-Modus auf einer Cloud-VM ausgeführt, die für die Ausführung in einer Produktionsumgebung konfiguriert wurde. Beim Ausführen der VM werden die Robot Units für Produktionsumgebungen verbraucht.

    Weitere Informationen finden Sie unter Robot Units – Verbrauch.

Beispiel: Angenommen, Sie haben 2 NonProduction-Laufzeiten und 1 Unattended-Laufzeit auf Maschinenvorlage A sowie 3 NonProduction-Laufzeiten und 2 Unattended-Laufzeiten auf Maschinenvorlage B. Beide sind einem Ordner zugeordnet. Sie verbinden eine Hostmaschine auf beiden Vorlagen. Das ergibt den folgenden Laufzeitstatus:

  • Unattended: 3 Available, 3 Connected
  • NonProduction: 5 Available, 5 Connected

Ein laufender Auftrag, der eine Laufzeit belegt, subtrahiert 1 von der Anzahl der verfügbaren Laufzeiten für diesen Typ.

Hinweis:

Zum Zeitpunkt der Veröffentlichung wählt der Orchestrator eine der verfügbaren Laufzeiten des persönlichen Arbeitsbereichs aus, um den Auftrag auszuführen. Die Laufzeitpriorität ist die folgende:

  • Serverlos (nur für den Orchestrator in der Automation Suite verfügbar)
  • Produktion (Unattended)
  • Nichtproduktiv (NonProduction)

Wenn beispielsweise keine serverlosen Runtimes in Ihrem persönlichen Arbeitsbereich vorhanden sind, verwendet der Orchestrator die verfügbare Production-Runtime. Wenn auch diese nicht vorhanden ist, verwendet der Orchestrator eine verfügbare NonProduction-Runtime. Wenn keine vorhanden ist, schlägt der Auftrag fehl.

Wenn die ausgewählte Laufzeit zwischen Auftragsausführungen nicht verfügbar ist, schlägt die bevorstehende Auftragsausführung fehl, da der Orchestrator nicht nach der nächsten verfügbaren sucht.

Konfigurieren des Ausführungsziels

Konfigurieren Sie Ihr Ausführungsziel, indem Sie die folgenden Optionen auf der Registerkarte Ausführungsziel wie gewünscht festlegen.



Dynamisch zuordnen

Die dynamische Zuweisung ohne explizite Konto- und Maschinenauswahl ermöglicht es Ihnen, einen Vordergrundprozess mehrmals unter dem Konto und der Maschine auszuführen, die zuerst verfügbar werden. Hintergrundprozesse werden für jedes Konto ausgeführt, unabhängig davon, ob es ausgelastet ist oder nicht, solange Sie über genügend Laufzeiten verfügen.

Mit dieser Option können Sie einen Prozess bis zu 10.000 Mal in einem Auftrag ausführen.

Konto

Sie können einen der folgenden Ansätze wählen:

  • Das Angeben eines Kontos bedeutet, dass der Prozess unter diesem speziellen Benutzer- oder Roboterkonto ausgeführt wird.
  • Wenn Sie das Konto und die Maschine angeben, wird der Auftrag auf genau diesem Konto-Maschinen-Paar gestartet. Es stehen nur gültige Konto-Maschinen-Paare zur Auswahl.
  • Wenn Sie kein Konto angeben, weist der Orchestrator das Konto dynamisch zu.

Maschine

Sie können einen der folgenden Ansätze wählen:

  • Das Angeben eines Maschinenobjekts bedeutet, dass der Prozess auf einer der Hostmaschinen ausgeführt wird, die an die ausgewählte Maschinenvorlage angehängt sind. Wählen Sie eine bestimmte Hostmaschine aus dem Pool der verbundenen Hostmaschinen im Feld Verbundene Maschinen aus.
  • Wenn Sie das Konto und die Maschine angeben, wird der Auftrag auf genau diesem Konto-Maschinen-Paar gestartet. Es stehen nur gültige Konto-Maschinen-Paare zur Auswahl.
  • Wenn Sie keine Maschine angeben, weist der Orchestrator die Hostmaschine dynamisch zu.

Stellen Sie sicher, dass Laufzeiten, die dem Auftragstyp entsprechen, der zugeordneten Maschinenvorlage zugewiesen werden. Es werden nur verbundene Hostmaschinen angezeigt, die dem aktiven Ordner zugeordnet sind.

Gültige Zuordnungen zwischen Konten und Maschinen wählen

Wählen Sie aus, welches spezifische Konto-Maschinen-Paar den Auftrag ausführen soll.
docs image
Sie können auf Konto-Maschine-Zuordnung aktivieren klicken, wenn Ihr Auftrag für mehrere solcher Paare ausgeführt werden soll. Daraufhin wird für jedes Konto-Maschinen-Paar ein ausstehender Auftrag erstellt.
Hinweis: Dies funktioniert nur, wenn die Option Benutzer-Maschinen-Zuordnung auf der Registerkarte Allgemein Ihrer Mandanteneinstellungen ausgewählt ist.

Konto-/Maschinenzuweisung bei Wiederaufnahme des Auftrags beibehalten

In diesem Feld können Sie konfigurieren, ob die verschiedenen Fragmente eines Auftrags mit langer Ausführungszeit auf demselben Konto-Maschinen-Paar ausgeführt werden.

Standardmäßig wird ein angehaltener Auftrag auf jedem verfügbaren Roboter auf jeder verfügbaren Maschine fortgesetzt.

Basierend auf Ihren Lizenz- oder Ressourcenanforderungen haben Sie die Möglichkeit, einen Auftrag auf derselben Maschine und im selben Kontokontext fortzusetzen, der den Auftrag gestartet hat.

Angenommen, Sie benötigen eine SAP-Lizenz, um einen Auftrag auszuführen. Anstatt eine SAP-Lizenz auf jeder verfügbaren Maschine zu installieren (erhöhte Kosten), können Sie sie auf einer einzelnen Maschine installieren und diese Maschine verwenden, um den Auftrag zu starten und fortzusetzen. Dieselbe Strategie kann für Benutzerlizenzen gelten. Sie können nur eine Benutzerlizenz zuweisen und zur Ausführung des Auftrags verwenden.

Beenden der Auftragsausführung planen

Die Prozessausführung kann manchmal fehlerhaft sein, was dazu führt, dass der Auftrag im Status „Ausstehend“ verbleibt. Wenn Sie den Umschalter aktivieren, haben Sie folgende Möglichkeiten (zum Erweitern klicken):

  • Wählen Sie Anhalten aus dem Dropdownmenü aus – es wird versucht, die Ausführung ordnungsgemäß zu beenden, nachdem das definierte Zeitintervall vergangen ist, weil der Auftrag im Status „Ausstehend“ festhängt (legen Sie die Zeit auf ein Minimum von 1 Minute, maximal 10 Tage, 23 Stunden und 59 Minuten fest);


  • Wählen Sie Beenden aus der Dropdownliste aus – es wird versucht, die Ausführung zwangsweise zu beenden, nachdem das definierte Zeitintervall vergangen ist, weil der Auftrag im Status „Ausstehend“ feststeckt (legen Sie die Zeit auf ein Minimum von 1 Minute, maximal 10 Tage, 23 Stunden und 59 Minuten fest).


  • Wählen Sie Anhalten aus der Dropdownliste aus, und aktivieren Sie die Option Automatisches „Beenden“ planen, wenn der Auftrag nicht angehalten wird – es wird versucht, die Ausführung ordnungsgemäß zu beenden, nachdem das definierte Zeitintervall vergangen ist, weil sich der Auftrag im Status „Ausstehend“ befindet, und dann wird versucht, ihn zwangsweise zu beenden, nachdem das definierte Zeitintervall vergangen ist, weil sich der Auftrag im Status „Anhalten“ befindet (legen Sie die Zeit auf mindestens 1 Minute fest, maximal 10 Tage, 23 Stunden und 59 Minuten).


Warnung generieren, wenn der Auftrag im Status „Ausstehend“ oder „Fortgesetzt“ festhängt

Durch Aktivieren des Umschalters aktivieren Sie Warnungen zu Aufträgen, die länger als die angegebene Dauer im Status „Ausstehend“ oder „Fortgesetzt“ verbleiben.

Die konfigurierbare Dauer beträgt mindestens eine Minute und maximal elf Tage.

Wenn der Auftrag die konfigurierte Dauer überschreitet, werden Sie in einem Popup-Fenster mit der Schweregradwarnung „Fehler“ mit dem folgenden Text darüber informiert:

"N Aufträge für #process {process_number} sind seit mehr als X Stunden und Y Minuten ausstehend oder werden fortgesetzt.", wo:

  • N – ist die Anzahl der Aufträge, die die Warnung ausgelöst haben.
  • {process_number} – die Prozess-ID
  • X – die konfigurierte Anzahl von Stunden, die der Auftrag überschritten hat, während er den Status „Ausstehend“ oder „Fortgesetzt“ hatte. Tage werden in Stunden konvertiert

  • Y – Die konfigurierte Anzahl von Minuten, die der Auftrag im Status „Ausstehend“ oder „Fortgesetzt“ überschritten hat.

Warnung generieren, wenn der Auftrag gestartet und nicht abgeschlossen wurde

Durch Aktivieren des Umschalters aktivieren Sie Warnungen über Aufträge, die nicht in der angegebenen Dauer abgeschlossen werden.

Die konfigurierbare Dauer beträgt mindestens eine Minute und maximal elf Tage.

Wenn der Auftrag die konfigurierte Dauer überschreitet, werden Sie in einem Popup-Fenster mit der Schweregradwarnung „Fehler“ mit dem folgenden Text darüber informiert:

„Auftrag für #Prozess {process_number} ist ausstehend und wird seit mehr als X Stunden und Y Minuten ausgeführt.“, wobei:

  • {process_number} – die Prozess-ID
  • X – die konfigurierte Anzahl von Stunden, die der Auftrag beim Versuch, ihn abzuschließen, überschritten hat. Tage werden in Stunden konvertiert.

  • Y – Die konfigurierte Anzahl von Minuten, die der Auftrag beim Versuch, ihn abzuschließen, überschritten hat.

Der Orchestrator verhindert das Starten von Aufträgen bei ungültigen Konfigurationen. Der Versuch, einen Auftrag in einem ungültigen Setup zu starten, führt zu einer beschreibenden Fehlermeldung, die Details zum Beheben Ihrer Konfiguration enthält.



Das Starten eines Auftrags mit dynamischer Zuweisung, d. h. es ist keine Maschine oder Konto angegeben, mit einer inkompatiblen Ordnereinrichtung führt zu einem Fehler. Stellen Sie sicher, dass Sie die Einrichtung korrigieren, ansonsten bleiben Aufträge auf unbestimmte Zeit ausstehend. Beispielsweise funktioniert der Versuch, einen .NET Framework 4.6.1-Hintergrundauftrag auszuführen, nicht, wenn sich nur plattformübergreifende Vorlagen im Ordner befinden, da Aufträge ausstehend bleiben, bis die Konfiguration behoben ist.

Hinzufügen von Argumenten

Geben Sie auf der Registerkarte Argumente Eingabeargumente für den ausgewählten Prozess an. Diese Registerkarte wird automatisch mit allen Eingabeargumenten aufgefüllt, die vom ausgewählten Prozess akzeptiert wurden, und den entsprechenden Werten, die vom Paket geerbt wurden.

Starten eines Auftrags über einen API-Trigger

Sie können einen Auftrag über einen API-Trigger in einer Drittanbieteranwendung Ihrer Wahl starten. Befolgen Sie diese folgenden Schritte:

  1. Erstellen Sie einen API-Trigger basierend auf dem Prozess, den Sie ausführen möchten. Dadurch wird die erforderliche URL zum Starten des Auftrags generiert. Befolgen Sie dazu die Anweisungen im Thema.
  2. Erstellen Sie ein dediziertes persönliches Zugriffstoken und gewähren Sie ihm Zugriff auf die erforderlichen Ressourcen. Dies geschieht auf Organisationsebene auf der Seite Einstellungen > Persönliches Zugriffstoken. Kopieren Sie das PAT nach dem Speichern sofort, da es nicht erneut angezeigt wird.
  3. Fügen Sie das persönliche Zugriffstoken in das Feld „Bearer-Token“ ein, um Ihre Anforderung zu autorisieren.
  4. Rufen Sie die Auftrags-URL ab, indem Sie neben dem gewünschten Mandanten in der Triggerliste auf die Option Vollständige Slug-URL kopieren klicken und sie dann in Ihr Tool einfügen.
  5. Konfigurieren Sie Ihre Argumente nach Bedarf.

    Sie können Argumente eingeben als:

    Parameter der Abfragezeichenfolge

    Bei einem Auftrag mit der Slug hw-process und den Argumenten files und folders sieht die cURL, die Sie in der Befehlszeile verwenden können, so aus:
    curl --location --request POST 'https://{yourDomain}/t/6ea73196-ca89-446c-81e1-5279bdd36dc2/hw-process?argument1=files&argument2=folders' \
    --header 'Cookie: __cf_bm=_5E_r3oulk6zLCr6.CUij.RFN4lCeTgYMR31gradWtI-1697542233-0-AdP+xhO+SE5PQ6wnoEum5qRu4wzUgGgOrezRhHrR4dcVvhsvl9yV/V3KAFhi/TmomqMtmxc426WT83lDMoL1seQ='curl --location --request POST 'https://{yourDomain}/t/6ea73196-ca89-446c-81e1-5279bdd36dc2/hw-process?argument1=files&argument2=folders' \
    --header 'Cookie: __cf_bm=_5E_r3oulk6zLCr6.CUij.RFN4lCeTgYMR31gradWtI-1697542233-0-AdP+xhO+SE5PQ6wnoEum5qRu4wzUgGgOrezRhHrR4dcVvhsvl9yV/V3KAFhi/TmomqMtmxc426WT83lDMoL1seQ='

    Formulardaten

    Bei einem Auftrag mit der Slug hw-process und den Argumenten files und folders sieht die cURL, die Sie in der Befehlszeile verwenden können, so aus:
    curl --location 'https://{yourDomain}/t/6ea73196-ca89-446c-81e1-5279bdd36dc2/hw-process' \
    --header 'Cookie: __cf_bm=_5E_r3oulk6zLCr6.CUij.RFN4lCeTgYMR31gradWtI-1697542233-0-AdP+xhO+SE5PQ6wnoEum5qRu4wzUgGgOrezRhHrR4dcVvhsvl9yV/V3KAFhi/TmomqMtmxc426WT83lDMoL1seQ=' \
    --form 'argument1="files"' \
    --form 'argument2="folders"'curl --location 'https://{yourDomain}/t/6ea73196-ca89-446c-81e1-5279bdd36dc2/hw-process' \
    --header 'Cookie: __cf_bm=_5E_r3oulk6zLCr6.CUij.RFN4lCeTgYMR31gradWtI-1697542233-0-AdP+xhO+SE5PQ6wnoEum5qRu4wzUgGgOrezRhHrR4dcVvhsvl9yV/V3KAFhi/TmomqMtmxc426WT83lDMoL1seQ=' \
    --form 'argument1="files"' \
    --form 'argument2="folders"'

    JSON-Haupttext

    Bei einem Auftrag mit der Slug hw-process und den Argumenten files und folders sieht die cURL, die Sie in der Befehlszeile verwenden können, so aus:
    curl --location 'https://{yourDomain}/t/6ea73196-ca89-446c-81e1-5279bdd36dc2/hw-process' \
    --header 'Content-Type: application/json' \
    --data '{
        "argument1" = "files"
        "argument2" = "folders"
    }
    'curl --location 'https://{yourDomain}/t/6ea73196-ca89-446c-81e1-5279bdd36dc2/hw-process' \
    --header 'Content-Type: application/json' \
    --data '{
        "argument1" = "files"
        "argument2" = "folders"
    }
    '

    Argumente können auch durch eine Kombination der oben genannten Methoden eingegeben werden.

  6. Führen Sie den Auftrag aus.

    Je nach Aufrufmodus, den Sie in der Triggerdefinition ausgewählt haben, wird der Auftrag wie folgt ausgeführt:

    • Asynchrones Polling

    • Asynchrones Fire-and-Forget

    • Synchronisierung (Long Polling)

    Beachten Sie, dass der Aufrufmodus in der Abfragezeichenfolge oder im Textkörper mit dem Parameter $callMode überschrieben werden kann.

    Weitere Informationen zu diesen Optionen finden Sie im Abschnitt Erläuterung der Anrufmodi.

Erläuterung der Anrufmodi

API-Trigger-Aufrufmodi wurden speziell für das Erstellen und Folgen von Auftragsausführungen im Orchestrator entwickelt.

Die grundlegende Herausforderung bei der HTTP-basierten Kommunikation besteht darin, dass sie von vornherein synchron ist: Normalerweise sendet der Client eine Anforderung und wartet auf die Antwort vom Server. Im Zusammenhang mit Roboteraufträgen ist es im Orchestrator jedoch nicht möglich, die Verbindung offen zu halten, bis der Auftrag abgeschlossen ist.

Um dies zu umgehen, haben wir das HTTP-Protokoll verwendet, um mehrere Aufrufmodi zu modellieren. Diese Modi verwenden Standard-HTTP-Methoden, Statuscodes und Header, um Aufträge innerhalb des Systems zu erstellen, zu überwachen und das Ergebnis abzurufen, ohne die Verbindung unnötig offen zu halten. Jeder der vorgeschlagenen Aufrufmodi hat Vor- und Nachteile, sodass Sie denjenigen auswählen können, der für Ihre Integrationsanforderungen am besten geeignet ist. Denken Sie daran, dass zur Sicherstellung der sicheren Kommunikation jeder Aufruf eine ordnungsgemäße Authentifizierung durch Bearer-Token erfordert.

Asynchrones Polling

Dieser Aufrufmodus beinhaltet einen Aufruf mit dem vorkonfigurierten HTTP-Verb, um einen neuen Auftrag auszulösen und einen Status-URI zu erhalten. Der Status-URI muss dann manuell abgefragt werden, bis der Auftrag abgeschlossen ist. An diesem Punkt wird der Aufruf an einen anderen Endpunkt umgeleitet, der zum Abrufen des Auftragsergebnisses (Ausgabe oder Fehler) verwendet wird.

Asynchroner Abfrage-Workflow, bei dem die Fertigstellung des Auftrags von zwischenzeitlichen manuellen Aufrufen der Antwortstelle abhängt.

docs image

Der erste Aufruf erfolgt mit dem konfigurierten HTTP-Verb (GET, POST, PUT, DELETE), das den zugehörigen Auftrag im Orchestrator erstellt. Bei der erfolgreichen Auftragserstellung antwortet das System mit einem HTTP-Statuscode 202 (Akzeptiert) und einem Status-URI im Speicherort-Header.

Sobald der Auftrag erstellt wurde, wird erwartet, dass Sie den Status regelmäßig abfragen. Während dieser Abfrage wird bei jeder GET-Anfrage an die Status-URI ein HTTP-Statuscode 200 (OK) zurückgegeben, solange der Auftrag läuft. Wenn der Auftrag abgeschlossen ist, gibt die nächste GET-Anforderung den HTTP-Statuscode 303 (Siehe Sonstige) an den Status-URI zurück und leitet Sie zum Ausgabe-URI (über den Speicherort-Header) um. Es wird erwartet, dass Sie dem Ausgabe-URI folgen, um das Auftragsergebnis (Ausgabe oder Fehler) abzurufen.

Stellen Sie immer sicher, dass Sie ein gültiges Bearer-Token in den Header jedes Aufrufs aufnehmen, um eine erfolgreiche Authentifizierung zu ermöglichen.

JavaScript-Beispiel

Dieses Beispiel veranschaulicht, wie ein Auftrag über einen API-Trigger in einem Browser im asynchronen Abrufmodus gestartet wird.

const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));

const url = 'https://{yourDomain}/t/<INVOKE_URL>';
const token = '<PERSONAL_ACCESS_TOKEN>'; // could also be an access token retrieved via OAuth

const body = {
  'argument1': 123,
  'argument2': 'my string',
  '$callMode': 'AsyncRequestReply' // optional argument to force call mode to AsyncRequestReply
}

// if invocation is done by GET, place the parameters in query string and remove the 'Content-Type' header
const invokeRequestOptions = {
  method: 'POST',
  headers: new Headers({ 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' }),
  body: JSON.stringify(body),
};

const redirectRequestOptions = {
  method: "GET",
  credentials: 'same-origin',
  headers: new Headers({ Authorization: `Bearer ${token}` }),
  redirect: "follow", // this option must be set to follow, otherwise an 'opaqueredirect' response is returned
};

const response = await fetch(url, invokeRequestOptions);
let newLocation = response.headers.get("Location");

// first response should be 202 and have a location header
console.log(`Got ${response.status}, with location: ${newLocation}`);

for (let i = 0; i < 20; i++) {
  await sleep(SLEEP_DURATION);

  // follow the location header to the new endpoint
  const statusResponse = await fetch(newLocation, redirectRequestOptions);

  // if the response was redirected (and automatically followed), then the output endpoint has been reached
  // the output of the job can be found in the body of the response in JSON format
  if (statusResponse.status != 200 || statusResponse.redirected)
  {
    // read the job output
    const output = await statusResponse.json();
    console.log(`Got ${statusResponse.status}, with body: ${JSON.stringify(output)}`);

    break;
}const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));

const url = 'https://{yourDomain}/t/<INVOKE_URL>';
const token = '<PERSONAL_ACCESS_TOKEN>'; // could also be an access token retrieved via OAuth

const body = {
  'argument1': 123,
  'argument2': 'my string',
  '$callMode': 'AsyncRequestReply' // optional argument to force call mode to AsyncRequestReply
}

// if invocation is done by GET, place the parameters in query string and remove the 'Content-Type' header
const invokeRequestOptions = {
  method: 'POST',
  headers: new Headers({ 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' }),
  body: JSON.stringify(body),
};

const redirectRequestOptions = {
  method: "GET",
  credentials: 'same-origin',
  headers: new Headers({ Authorization: `Bearer ${token}` }),
  redirect: "follow", // this option must be set to follow, otherwise an 'opaqueredirect' response is returned
};

const response = await fetch(url, invokeRequestOptions);
let newLocation = response.headers.get("Location");

// first response should be 202 and have a location header
console.log(`Got ${response.status}, with location: ${newLocation}`);

for (let i = 0; i < 20; i++) {
  await sleep(SLEEP_DURATION);

  // follow the location header to the new endpoint
  const statusResponse = await fetch(newLocation, redirectRequestOptions);

  // if the response was redirected (and automatically followed), then the output endpoint has been reached
  // the output of the job can be found in the body of the response in JSON format
  if (statusResponse.status != 200 || statusResponse.redirected)
  {
    // read the job output
    const output = await statusResponse.json();
    console.log(`Got ${statusResponse.status}, with body: ${JSON.stringify(output)}`);

    break;
}
C#-Beispiel

Dieses Beispiel veranschaulicht, wie ein Auftrag über einen API-Trigger aus einer C#-basierten Anwendung gestartet wird, wobei der asynchrone Abrufmodus verwendet wird.

public async Task<string> AsyncPollingExample()
{
    const string url = "https://{yourDomain}/t/<INVOKE_URL>";
    const string token = "<PERSONAL_ACCESS_TOKEN>"; // could also be an access token retrieved via OAuth

    // create an http client that does not follow redirects and adds a bearer token on each call
    var httpClient = new HttpClient(new HttpClientHandler { AllowAutoRedirect = false });
    httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);

    var arguments = new Dictionary<string, object>
    {
        { "argument1", 123 },
        { "argument2", "my string" },
        { "$callMode", "AsyncRequestReply" }, // optional argument to force call mode to AsyncRequestReply
    };

    var httpResponseStart = await httpClient.PostAsJsonAsync(url, arguments);
    var redirectUri = httpResponseStart.Headers.Location;

    if (httpResponseStart.StatusCode != HttpStatusCode.Accepted)
        throw new Exception("Could not invoke workflow");

    while (true)
    {
        var httpPollingResponse = await httpClient.GetAsync(redirectUri);

        if (httpPollingResponse.StatusCode == HttpStatusCode.Redirect)
        {
            var outputLocation = httpPollingResponse.Headers.Location;
            var outputResponse = await httpClient.GetAsync(outputLocation);
            var jobOutput = await outputResponse.Content.ReadAsStringAsync();

            return jobOutput;
        }

        await Task.Delay(1000);
    }
}public async Task<string> AsyncPollingExample()
{
    const string url = "https://{yourDomain}/t/<INVOKE_URL>";
    const string token = "<PERSONAL_ACCESS_TOKEN>"; // could also be an access token retrieved via OAuth

    // create an http client that does not follow redirects and adds a bearer token on each call
    var httpClient = new HttpClient(new HttpClientHandler { AllowAutoRedirect = false });
    httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);

    var arguments = new Dictionary<string, object>
    {
        { "argument1", 123 },
        { "argument2", "my string" },
        { "$callMode", "AsyncRequestReply" }, // optional argument to force call mode to AsyncRequestReply
    };

    var httpResponseStart = await httpClient.PostAsJsonAsync(url, arguments);
    var redirectUri = httpResponseStart.Headers.Location;

    if (httpResponseStart.StatusCode != HttpStatusCode.Accepted)
        throw new Exception("Could not invoke workflow");

    while (true)
    {
        var httpPollingResponse = await httpClient.GetAsync(redirectUri);

        if (httpPollingResponse.StatusCode == HttpStatusCode.Redirect)
        {
            var outputLocation = httpPollingResponse.Headers.Location;
            var outputResponse = await httpClient.GetAsync(outputLocation);
            var jobOutput = await outputResponse.Content.ReadAsStringAsync();

            return jobOutput;
        }

        await Task.Delay(1000);
    }
}
Asynchrones Fire-and-Forget

Der Fire-and-Forget-Aufrufmodus gibt bei erfolgreicher Auftragserstellung den Status „200 OK“ ohne weitere Informationen über den Auftrag zurück.

Asynchroner Fire-and-Forget-Workflow, bei dem der Auftrag ohne Zwischenaufrufe abgeschlossen wird.

docs image
JavaScript-Beispiel

Dieses Beispiel veranschaulicht, wie ein Auftrag über einen API-Trigger in einem Browser gestartet wird, indem der asynchrone Fire-and-Forget-Aufrufmodus verwendet wird.

const url = 'https://{yourDomain}/t/<INVOKE_URL>';
const token = '<PERSONAL_ACCESS_TOKEN>'; // could also be an access token retrieved via OAuth
  
const body = {
  'argument1': 123,
  'argument2': 'my string',
  '$callMode': 'FireAndForget' // optional argument to force call mode to FireAndForget
}

const options = {
  method: 'POST',
  headers: new Headers({ 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' }),
  body: JSON.stringify(body),
};

let response = await fetch(url, options);

console.log(`Got ${response.status}`);const url = 'https://{yourDomain}/t/<INVOKE_URL>';
const token = '<PERSONAL_ACCESS_TOKEN>'; // could also be an access token retrieved via OAuth
  
const body = {
  'argument1': 123,
  'argument2': 'my string',
  '$callMode': 'FireAndForget' // optional argument to force call mode to FireAndForget
}

const options = {
  method: 'POST',
  headers: new Headers({ 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' }),
  body: JSON.stringify(body),
};

let response = await fetch(url, options);

console.log(`Got ${response.status}`);
C#-Beispiel

Dieses Beispiel veranschaulicht, wie ein Auftrag über einen API-Trigger aus einer C#-basierten Anwendung unter Verwendung des asynchronen Fire-and-Forget-Aufrufmodus gestartet wird.

public async Task FireAndForgetExample()
{
    const string url = "https://{yourDomain}/t/<INVOKE_URL>";
    const string token = "<PERSONAL_ACCESS_TOKEN>"; // could also be an access token retrieved via OAuth

    // create an http client that does not follow redirects and adds Bearer <token> on each call
    // if the follow redirects option is enabled, C# will not add a bearer token by default after the redirect
    var httpClient = new HttpClient(new HttpClientHandler { AllowAutoRedirect = false });
    httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);

    var arguments = new Dictionary<string, object>
    {
        { "argument1", 123 },
        { "argument2", "my string" },
        { "$callMode", "FireAndForget" }, // optional argument to force call mode to LongPolling
    };

    var response = await httpClient.PostAsJsonAsync(url, arguments);

    Console.WriteLine(response.StatusCode);
}public async Task FireAndForgetExample()
{
    const string url = "https://{yourDomain}/t/<INVOKE_URL>";
    const string token = "<PERSONAL_ACCESS_TOKEN>"; // could also be an access token retrieved via OAuth

    // create an http client that does not follow redirects and adds Bearer <token> on each call
    // if the follow redirects option is enabled, C# will not add a bearer token by default after the redirect
    var httpClient = new HttpClient(new HttpClientHandler { AllowAutoRedirect = false });
    httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);

    var arguments = new Dictionary<string, object>
    {
        { "argument1", 123 },
        { "argument2", "my string" },
        { "$callMode", "FireAndForget" }, // optional argument to force call mode to LongPolling
    };

    var response = await httpClient.PostAsJsonAsync(url, arguments);

    Console.WriteLine(response.StatusCode);
}
Synchronisierung (Long Polling)

Dieser Aufrufmodus beinhaltet einen ersten Aufruf, der blockiert und eine Weile wartet, bis der Auftrag abgeschlossen ist, gefolgt von mehreren möglichen blockierenden Aufrufen und Umleitungen. Schließlich wird nach Abschluss des Auftrags das Auftragsergebnis (Ausgabe oder Fehler) abgerufen.

Je nach Mandanteneinstellungen kann die Authentifizierung für alle Aufrufe oder nur für den ersten Aufruf erforderlich sein.

Synchronisierter Workflow (Long Polling), bei dem das Ergebnis, ob erfolgreich oder nicht, mit dem ersten Aufruf zurückgegeben wird.

docs image

Synchronisierter Workflow (mit langen Abrufen), bei dem mehrere Aufrufe automatisch für den Auftragsabschluss durchgeführt werden.

docs image

Der erste Aufruf erfolgt mit dem konfigurierten HTTP-Verb (GET, POST, PUT, DELETE), das den zugehörigen Auftrag im Orchestrator erstellt. Bei erfolgreicher Auftragserstellung blockiert das System den aktuellen Aufruf, während es auf den Abschluss des Auftrags wartet. Wenn der Auftrag abgeschlossen ist, wird der blockierte Aufruf freigegeben und eine Antwort mit den Auftragsausgabeargumenten wird zurückgesendet.

Wenn der Auftrag nach einer Zeitüberschreitung noch nicht abgeschlossen ist, antwortet das System mit einem HTTP-Statuscode 303 (siehe „Sonstige“) und leitet zur Status-URI weiter (über den Header „Speicherort“). Es wird erwartet, dass Sie dem Status-URI folgen, der bis zum Abschluss des Auftrags gesperrt ist. Wenn der Auftrag nach einer Zeitüberschreitung nicht abgeschlossen ist, werden Sie erneut zur Status-URI umgeleitet, wodurch eine Umleitungsschleife entsteht. Nach erfolgreichem Abschluss des Auftrags wird das Auftragsergebnis (Ausgabe oder Fehler) als Teil der HTTP-Antwort abgerufen.

Standardmäßig müssen alle Aufrufe ein gültiges Bearer-Token zur Autorisierung enthalten. Wenn jedoch die Option Authentifizierungs-Header für Umleitungen von synchronen API-Triggern erforderlich in den Mandanteneinstellungen nicht ausgewählt ist, erfordert nur der erste Aufruf des Triggers den Authentifizierungs-Header. Nachfolgende Aufrufe des Statusendpunkts können ohne Autorisierungsheader erfolgen.

Die maximale Auftragsdauer für diesen Anrufmodus beträgt 15 Minuten.

JavaScript-Beispiel

Dieses Beispiel veranschaulicht, wie ein Auftrag über einen API-Trigger in einem Browser gestartet wird, wobei der Synchronisierungsaufrufmodus (Long Polling) verwendet wird.

const url = 'https://{yourDomain}/t/<INVOKE_URL>';
const token = '<PERSONAL_ACCESS_TOKEN>'; // could also be an access token retrieved via OAuth

const body = {
  'argument1': 123,
  'argument2': 'my string',
  '$callMode': 'LongPolling' // optional argument to force call mode to LongPolling
}

const options = {
  method: 'POST',
  headers: new Headers({ 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' }),
  body: JSON.stringify(body),
  redirect: "follow", // follow redirects automatically
};

let response = await fetch(url, options);
const output = await response.json();

console.log(`Got ${response.status} with body ${JSON.stringify(output)}`);const url = 'https://{yourDomain}/t/<INVOKE_URL>';
const token = '<PERSONAL_ACCESS_TOKEN>'; // could also be an access token retrieved via OAuth

const body = {
  'argument1': 123,
  'argument2': 'my string',
  '$callMode': 'LongPolling' // optional argument to force call mode to LongPolling
}

const options = {
  method: 'POST',
  headers: new Headers({ 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' }),
  body: JSON.stringify(body),
  redirect: "follow", // follow redirects automatically
};

let response = await fetch(url, options);
const output = await response.json();

console.log(`Got ${response.status} with body ${JSON.stringify(output)}`);
C#-Beispiel

Dieses Beispiel veranschaulicht, wie ein Auftrag über einen API-Trigger aus einer C#-basierten Anwendung gestartet wird, wobei der Synchronisierungsaufrufmodus (Long Polling) verwendet wird.

public async Task SyncExample()
{
    const string url = "https://{yourDomain}/t/<INVOKE_URL>";
    const string token = "<PERSONAL_ACCESS_TOKEN>"; // could also be an access token retrieved via OAuth

    // create an http client that does not follow redirects and adds Bearer <token> on each call
    // if the follow redirects option is enabled, C# will not add a bearer token by default after the redirect
    var httpClient = new HttpClient(new HttpClientHandler { AllowAutoRedirect = false });
    httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);

    var arguments = new Dictionary<string, object>
    {
        { "argument1", 123 },
        { "argument2", "my string" },
        { "$callMode", "LongPolling" }, // optional argument to force call mode to LongPolling
    };

    var response = await httpClient.PostAsJsonAsync(url, arguments);

    while(response.StatusCode == HttpStatusCode.Redirect)
    {
        // in case of redirection, keep following the latest location in the header
        var location = response.Headers.Location;
        response = await httpClient.GetAsync(location);
    }

    // read the job output/error from the last request
    var jobOutput = response.Content.ReadAsStringAsync();

    Console.WriteLine(jobOutput);
}public async Task SyncExample()
{
    const string url = "https://{yourDomain}/t/<INVOKE_URL>";
    const string token = "<PERSONAL_ACCESS_TOKEN>"; // could also be an access token retrieved via OAuth

    // create an http client that does not follow redirects and adds Bearer <token> on each call
    // if the follow redirects option is enabled, C# will not add a bearer token by default after the redirect
    var httpClient = new HttpClient(new HttpClientHandler { AllowAutoRedirect = false });
    httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);

    var arguments = new Dictionary<string, object>
    {
        { "argument1", 123 },
        { "argument2", "my string" },
        { "$callMode", "LongPolling" }, // optional argument to force call mode to LongPolling
    };

    var response = await httpClient.PostAsJsonAsync(url, arguments);

    while(response.StatusCode == HttpStatusCode.Redirect)
    {
        // in case of redirection, keep following the latest location in the header
        var location = response.Headers.Location;
        response = await httpClient.GetAsync(location);
    }

    // read the job output/error from the last request
    var jobOutput = response.Content.ReadAsStringAsync();

    Console.WriteLine(jobOutput);
}

Ratenbegrenzung

Die Anzahl der Anforderungen, die an den Statusendpunkt gestellt werden können, ist für jeden gestarteten Auftrag auf 10 pro 10 Sekunden begrenzt.

Grenzwert für ausstehende Aufträge

Die maximale Anzahl der ausstehenden Aufträge, die über API-Trigger gestartet wurden, ist 100. Dies kann mit der Einstellung Trigger – API-Trigger – Maximale Grenze für ausstehende Aufträge auf Mandantenebene geändert werden, die einen Standardwert von 10 hat.

Anhalten eines Jobs

Kicken Sie auf die entsprechende Schaltfläche Weitere Aktionen (More Actions) und dann auf Stopp (Stop). Das Automationsprojekt wird so lange ausgeführt, bis es eine Sollte anhalten (Should stop) Aktivität antrifft. Während dieser Zeit befindet sich der Job im Status Anhalten (Stopping). Wird die Aktivität angetroffen, wird die Ausführung angehalten und der Endstatus des Jobs ist Erfolgreich. Wenn keine Sollte anhalten (Should Stop) Aktivität angetroffen wird, hält die Jobausführung nicht an, bis das Projektende erreicht wurde. In diesem Fall ist der Endstatus ebenfalls Erfolgreich (Successful).

Hinweis:
  • Ein über den Orchestrator gestarteter Auftrag kann nur über den Orchestrator angehalten werden.
  • Ein über den Assistant gestarteter Auftrag kann sowohl über den Orchestrator auf der Seite Aufträge als auch über den UiPath Assistant angehalten werden.
  • Sobald ein Auftrag angehalten wurde, gehen die Zeitpläne für die Beendigung des Auftrags verloren und Sie müssen die Optionen zum Zeitplan der Beendigung der Auftragsausführung beim Neustart des Auftrags neu konfigurieren.

Fortsetzen eines Auftrags

Klicken Sie auf die entsprechende Schaltfläche Weitere Aktionen und dann Fortsetzen.

Abbrechen eines Jobs

Kicken Sie auf die entsprechende Schaltfläche Weitere Aktionen (More Actions) und dann auf Eliminieren (Kill). Das Automationsprojekt wird zwangsweise gestoppt, der Job wird als Angehalten (Stopped) markiert und im Fenster Jobdetails (Job Details) wird „Abgebrochen“ angezeigt.

Hinweis:
  • Ein über den Orchestrator gestarteter Auftrag kann sowohl über den Orchestrator auf der Seite Aufträge als auch über den UiPath Assistant beendet werden.
  • Ein über den Assistant gestarteter Auftrag kann sowohl über den Orchestrator auf der Seite Aufträge als auch über den UiPath Assistant beendet werden.
  • Sobald ein Auftrag beendet wurde, gehen die Zeitpläne für die Beendigung des Auftrags verloren und Sie müssen die Optionen zum Zeitplan der Beendigung der Auftragsausführung beim Neustart des Auftrags neu konfigurieren.

Neustarten eines Auftrags

Mit dieser Funktion können Sie einen Auftrag schnell über die Auftragsliste ausführen, ohne das Konfigurieren des Auftrags durchlaufen zu müssen. Sie können jeden Auftrag mit einem endgültigen Status neu starten – Angehalten, Fehlerhaft oder Erfolgreich.

Hinweis:
  • Sie können keine Aufträge neu starten, die von Agenten wie dem Assistant oder durch Remote-Debugging-Sitzungen von Studio ausgelöst wurden.
  • Wenn Sie einen Auftrag neu starten, bei dem die Optionen Beenden der Auftragsausführung planen aktiv waren, müssen Sie diese Optionen neu konfigurieren.

Dieses Verfahren startet mit der Annahme, dass Sie vorher einen Auftrag gestartet haben, der bereits einen endgültigen Status erreicht hat.

  1. Klicken Sie auf die entsprechende Schaltfläche Weitere Aktionen und wählen Sie Neu Starten (Restart) aus. Das Fenster Starten Job wird mit den Anfangseinstellungen des Jobs angezeigt.
  2. Nehmen Sie die gewünschten Änderungen vor.
  3. Klicken Sie auf Starten. Das Fenster Aufträge starten wird geschlossen und die Ausführung startet. Der Status der einzelnen Aufträge wird in Echtzeit auf der Seite Aufträge angezeigt.

Jobprotokolle anzeigen

Um die Protokolle eines bestimmten Jobs anzuzeigen, klicken Sie auf die entsprechende Schaltfläche Weitere Aktionen (More Actions) und dann auf Protokolle anzeigen (View Logs). Die Seite Protokolle (Logs) wird angezeigt. Sie enthält die Daten des angegebenen Jobs.

Hinweis: Protokolle für Aufträge, die über Remote-Debugging-Sitzungen gestartet wurden, sind nicht auf der Seite Auftragsprotokolle verfügbar. Sie finden sie auf der globalen Seite Protokolle.

Anzeigen von Jobdetails

Um Details zu einem bestimmten Auftrag anzuzeigen, klicken Sie auf die entsprechende Schaltfläche Details anzeigen. Dadurch wird das Fenster Auftragsdetails angezeigt, in dem Sie verschiedene Informationen finden, z. B.:

  • Den Namen des zugrunde liegenden Prozesses
  • Den ausführenden Roboter und die Maschine
  • Die Gründe für das Scheitern von Aufträgen
  • die Gründe dafür, warum der Auftrag nicht startet
  • mögliche Aktionen, um Probleme zu beheben und den Start des Auftrags auszulösen

Details zum abgeschlossenen Auftrag



Details zum ausstehenden Auftrag

docs image
Hinweis: Im Feld Info werden keine weiteren Aspekte der Lizenzierung für fehlgeschlagene Aufträge angezeigt. Verwenden Sie die Überwachungsfunktion für Details zur Lizenzierung.

Herunterladen der Ausführungsmedien

Um die Aufzeichnung für einen fehlgeschlagenen Auftrag herunterzuladen, klicken Sie auf Weitere Optionen > Aufzeichnung herunterladen. Das Ausführungsmedium wird gemäß Ihren Einstellungen heruntergeladen.

Symbol für Support und Dienste
Hilfe erhalten
UiPath Academy-Symbol
RPA lernen – Automatisierungskurse
Symbol für UiPath-Forum
UiPath Community-Forum
UiPath Logo weiß
Vertrauen und Sicherheit
© 2005-2024 UiPath. All rights reserved.