Workflow ausführen

Bei der Ausführung eines Workflows wird die aktuelle Workflowdefinition ausgeführt, die dem Workflow zugeordnet ist.

Sie können Laufzeitargumente in einer Workflow-Ausführungsanfrage übergeben und mithilfe einer Workflowvariable auf diese Argumente zugreifen. Weitere Informationen finden Sie unter Laufzeitargumente in einer Ausführungsanfrage übergeben.

Nach Abschluss einer Workflowausführung werden der Verlauf und die Ergebnisse für einen begrenzten Zeitraum gespeichert. Weitere Informationen finden Sie unter Kontingente und Limits.

Hinweise

Von Ihrer Organisation definierte Sicherheitsbeschränkungen verhindern möglicherweise, dass die folgenden Schritte ausgeführt werden. Informationen zur Fehlerbehebung finden Sie unter Anwendungen in einer eingeschränkten Google Cloud-Umgebung entwickeln.

  1. Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.
  2. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

  3. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

  4. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

  5. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

  6. Wenn ein Workflow auf andere Google Cloud-Ressourcen zugreift, muss er einem Dienstkonto mit den entsprechenden Berechtigungen zugeordnet sein. Informationen dazu, welches Dienstkonto mit einem vorhandenen Workflow verknüpft ist, finden Sie unter Mit einem Workflow verknüpftes Dienstkonto überprüfen.

    Zum Erstellen einer Ressource und zum Anhängen eines Dienstkontos benötigen Sie Berechtigungen zum Erstellen dieser Ressource und zum Übernehmen der Identität des Dienstkontos, das Sie an die Ressource anhängen werden. Weitere Informationen finden Sie unter Dienstkontoberechtigungen.

  7. Stellen Sie einen Workflow mithilfe der Google Cloud Console oder der Google Cloud CLI bereit.

Workflow ausführen

Sie können einen Workflow mithilfe der Clientbibliotheken, in der Google Cloud Console, über die gcloud CLI oder durch Senden einer Anfrage an die Workflows REST API ausführen.

Clientbibliotheken

In den folgenden Beispielen wird davon ausgegangen, dass Sie bereits den Workflow myFirstWorkflow bereitgestellt haben.

  1. Installieren Sie die Clientbibliothek und richten Sie Ihre Entwicklungsumgebung ein. Weitere Informationen finden Sie unter Übersicht über Clientbibliotheken für Workflows.

  2. Klonen Sie das Repository der Beispiel-App auf Ihren lokalen Computer:

    Java

    git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git

    Sie können auch das Beispiel als ZIP-Datei herunterladen und extrahieren.

    Node.js

    git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git

    Sie können auch das Beispiel als ZIP-Datei herunterladen und extrahieren.

    Python

    git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git

    Sie können auch das Beispiel als ZIP-Datei herunterladen und extrahieren.

  3. Wechseln Sie in das Verzeichnis, das den Workflows-Beispielcode enthält:

    Java

    cd java-docs-samples/workflows/cloud-client/

    Node.js

    cd nodejs-docs-samples/workflows/quickstart/

    Python

    cd python-docs-samples/workflows/cloud-client/

  4. Sehen Sie sich den Beispielcode an:

    Java

    // Imports the Google Cloud client library
    
    import com.google.cloud.workflows.executions.v1.CreateExecutionRequest;
    import com.google.cloud.workflows.executions.v1.Execution;
    import com.google.cloud.workflows.executions.v1.ExecutionsClient;
    import com.google.cloud.workflows.executions.v1.WorkflowName;
    import java.io.IOException;
    import java.util.concurrent.ExecutionException;
    
    public class WorkflowsQuickstart {
    
      private static final String PROJECT = System.getenv("GOOGLE_CLOUD_PROJECT");
      private static final String LOCATION = System.getenv().getOrDefault("LOCATION", "us-central1");
      private static final String WORKFLOW =
          System.getenv().getOrDefault("WORKFLOW", "myFirstWorkflow");
    
      public static void main(String... args)
          throws IOException, InterruptedException, ExecutionException {
        if (PROJECT == null) {
          throw new IllegalArgumentException(
              "Environment variable 'GOOGLE_CLOUD_PROJECT' is required to run this quickstart.");
        }
        workflowsQuickstart(PROJECT, LOCATION, WORKFLOW);
      }
    
      private static volatile boolean finished;
    
      public static void workflowsQuickstart(String projectId, String location, String workflow)
          throws IOException, InterruptedException, ExecutionException {
        // Initialize client that will be used to send requests. This client only needs
        // to be created once, and can be reused for multiple requests. After completing all of your
        // requests, call the "close" method on the client to safely clean up any remaining background
        // resources.
        try (ExecutionsClient executionsClient = ExecutionsClient.create()) {
          // Construct the fully qualified location path.
          WorkflowName parent = WorkflowName.of(projectId, location, workflow);
    
          // Creates the execution object.
          CreateExecutionRequest request =
              CreateExecutionRequest.newBuilder()
                  .setParent(parent.toString())
                  .setExecution(Execution.newBuilder().build())
                  .build();
          Execution response = executionsClient.createExecution(request);
    
          String executionName = response.getName();
          System.out.printf("Created execution: %s%n", executionName);
    
          long backoffTime = 0;
          long backoffDelay = 1_000; // Start wait with delay of 1,000 ms
          final long backoffTimeout = 10 * 60 * 1_000; // Time out at 10 minutes
          System.out.println("Poll for results...");
    
          // Wait for execution to finish, then print results.
          while (!finished && backoffTime < backoffTimeout) {
            Execution execution = executionsClient.getExecution(executionName);
            finished = execution.getState() != Execution.State.ACTIVE;
    
            // If we haven't seen the results yet, wait.
            if (!finished) {
              System.out.println("- Waiting for results");
              Thread.sleep(backoffDelay);
              backoffTime += backoffDelay;
              backoffDelay *= 2; // Double the delay to provide exponential backoff.
            } else {
              System.out.println("Execution finished with state: " + execution.getState().name());
              System.out.println("Execution results: " + execution.getResult());
            }
          }
        }
      }
    }

    Node.js (JavaScript)

    const {ExecutionsClient} = require('@google-cloud/workflows');
    const client = new ExecutionsClient();
    /**
     * TODO(developer): Uncomment these variables before running the sample.
     */
    // const projectId = 'my-project';
    // const location = 'us-central1';
    // const workflow = 'myFirstWorkflow';
    // const searchTerm = '';
    
    /**
     * Executes a Workflow and waits for the results with exponential backoff.
     * @param {string} projectId The Google Cloud Project containing the workflow
     * @param {string} location The workflow location
     * @param {string} workflow The workflow name
     * @param {string} searchTerm Optional search term to pass to the Workflow as a runtime argument
     */
    async function executeWorkflow(projectId, location, workflow, searchTerm) {
      /**
       * Sleeps the process N number of milliseconds.
       * @param {Number} ms The number of milliseconds to sleep.
       */
      function sleep(ms) {
        return new Promise(resolve => {
          setTimeout(resolve, ms);
        });
      }
      const runtimeArgs = searchTerm ? {searchTerm: searchTerm} : {};
      // Execute workflow
      try {
        const createExecutionRes = await client.createExecution({
          parent: client.workflowPath(projectId, location, workflow),
          execution: {
            // Runtime arguments can be passed as a JSON string
            argument: JSON.stringify(runtimeArgs),
          },
        });
        const executionName = createExecutionRes[0].name;
        console.log(`Created execution: ${executionName}`);
    
        // Wait for execution to finish, then print results.
        let executionFinished = false;
        let backoffDelay = 1000; // Start wait with delay of 1,000 ms
        console.log('Poll every second for result...');
        while (!executionFinished) {
          const [execution] = await client.getExecution({
            name: executionName,
          });
          executionFinished = execution.state !== 'ACTIVE';
    
          // If we haven't seen the result yet, wait a second.
          if (!executionFinished) {
            console.log('- Waiting for results...');
            await sleep(backoffDelay);
            backoffDelay *= 2; // Double the delay to provide exponential backoff.
          } else {
            console.log(`Execution finished with state: ${execution.state}`);
            console.log(execution.result);
            return execution.result;
          }
        }
      } catch (e) {
        console.error(`Error executing workflow: ${e}`);
      }
    }
    
    executeWorkflow(projectId, location, workflowName, searchTerm).catch(err => {
      console.error(err.message);
      process.exitCode = 1;
    });
    

    Node.js (TypeScript)

    import {ExecutionsClient} from '@google-cloud/workflows';
    const client: ExecutionsClient = new ExecutionsClient();
    /**
     * TODO(developer): Uncomment these variables before running the sample.
     */
    // const projectId = 'my-project';
    // const location = 'us-central1';
    // const workflow = 'myFirstWorkflow';
    // const searchTerm = '';
    
    /**
     * Executes a Workflow and waits for the results with exponential backoff.
     * @param {string} projectId The Google Cloud Project containing the workflow
     * @param {string} location The workflow location
     * @param {string} workflow The workflow name
     * @param {string} searchTerm Optional search term to pass to the Workflow as a runtime argument
     */
    async function executeWorkflow(
      projectId: string,
      location: string,
      workflow: string,
      searchTerm: string
    ) {
      /**
       * Sleeps the process N number of milliseconds.
       * @param {Number} ms The number of milliseconds to sleep.
       */
      function sleep(ms: number): Promise<unknown> {
        return new Promise(resolve => {
          setTimeout(resolve, ms);
        });
      }
      const runtimeArgs = searchTerm ? {searchTerm: searchTerm} : {};
      // Execute workflow
      try {
        const createExecutionRes = await client.createExecution({
          parent: client.workflowPath(projectId, location, workflow),
          execution: {
            // Runtime arguments can be passed as a JSON string
            argument: JSON.stringify(runtimeArgs),
          },
        });
        const executionName = createExecutionRes[0].name;
        console.log(`Created execution: ${executionName}`);
    
        // Wait for execution to finish, then print results.
        let executionFinished = false;
        let backoffDelay = 1000; // Start wait with delay of 1,000 ms
        console.log('Poll every second for result...');
        while (!executionFinished) {
          const [execution] = await client.getExecution({
            name: executionName,
          });
          executionFinished = execution.state !== 'ACTIVE';
    
          // If we haven't seen the result yet, wait a second.
          if (!executionFinished) {
            console.log('- Waiting for results...');
            await sleep(backoffDelay);
            backoffDelay *= 2; // Double the delay to provide exponential backoff.
          } else {
            console.log(`Execution finished with state: ${execution.state}`);
            console.log(execution.result);
            return execution.result;
          }
        }
      } catch (e) {
        console.error(`Error executing workflow: ${e}`);
      }
    }
    
    executeWorkflow(projectId, location, workflowName, searchTerm).catch(
      (err: Error) => {
        console.error(err.message);
        process.exitCode = 1;
      }
    );

    Python

    import time
    
    from google.cloud import workflows_v1
    from google.cloud.workflows import executions_v1
    from google.cloud.workflows.executions_v1 import Execution
    from google.cloud.workflows.executions_v1.types import executions
    
    def execute_workflow(
        project: str, location: str = "us-central1", workflow: str = "myFirstWorkflow"
    ) -> Execution:
        """Execute a workflow and print the execution results.
    
        A workflow consists of a series of steps described using the Workflows syntax, and can be written in either YAML or JSON.
    
        Args:
            project: The Google Cloud project id which contains the workflow to execute.
            location: The location for the workflow
            workflow: The ID of the workflow to execute.
    
        Returns:
            The execution response.
        """
        # Set up API clients.
        execution_client = executions_v1.ExecutionsClient()
        workflows_client = workflows_v1.WorkflowsClient()
        # Construct the fully qualified location path.
        parent = workflows_client.workflow_path(project, location, workflow)
    
        # Execute the workflow.
        response = execution_client.create_execution(request={"parent": parent})
        print(f"Created execution: {response.name}")
    
        # Wait for execution to finish, then print results.
        execution_finished = False
        backoff_delay = 1  # Start wait with delay of 1 second
        print("Poll for result...")
        while not execution_finished:
            execution = execution_client.get_execution(request={"name": response.name})
            execution_finished = execution.state != executions.Execution.State.ACTIVE
    
            # If we haven't seen the result yet, wait a second.
            if not execution_finished:
                print("- Waiting for results...")
                time.sleep(backoff_delay)
                # Double the delay to provide exponential backoff.
                backoff_delay *= 2
            else:
                print(f"Execution finished with state: {execution.state.name}")
                print(f"Execution results: {execution.result}")
                return execution
    
    

    Das Beispiel führt folgende Schritte aus:

    1. Richtet die Cloud-Clientbibliotheken für Workflows ein.
    2. Führt einen Workflow aus.
    3. Fragt die Ausführung des Workflows (mit exponentiellem Backoff) bis zum Ende der Ausführung ab.
    4. Druckt die Ausführungsergebnisse.
  5. Installieren Sie zuerst die Abhängigkeiten, um das Beispiel auszuführen:

    Java

    mvn compile

    Node.js (JavaScript)

    npm install

    Node.js (TypeScript)

    npm install && npm run build

    Python

    pip3 install -r requirements.txt

  6. Führen Sie das Skript aus:

    Java

    GOOGLE_CLOUD_PROJECT=PROJECT_ID LOCATION=CLOUD_REGION WORKFLOW=WORKFLOW_NAME mvn compile exec:java -Dexec.mainClass=com.example.workflows.WorkflowsQuickstart

    Node.js (JavaScript)

    npm start PROJECT_ID CLOUD_REGION WORKFLOW_NAME

    Node.js (TypeScript)

    npm start PROJECT_ID CLOUD_REGION WORKFLOW_NAME

    Python

    GOOGLE_CLOUD_PROJECT=PROJECT_ID LOCATION=CLOUD_REGION WORKFLOW=WORKFLOW_NAME python3 main.py

    Ersetzen Sie Folgendes:

    • PROJECT_ID (erforderlich): die Projekt-ID des Google Cloud-Projekts
    • CLOUD_REGION: der Speicherort des Workflows (Standardeinstellung: us-central1)
    • WORKFLOW_NAME: die ID des Workflows (Standard: myFirstWorkflow)

    Die Ausgabe sieht in etwa so aus:

    Execution finished with state: SUCCEEDED
    ["Sunday","Sunday in the Park with George","Sunday shopping","Sunday Bloody Sunday","Sunday Times Golden Globe Race","Sunday All Stars","Sunday Night (South Korean TV series)","Sunday Silence","Sunday Without God","Sunday Independent (Ireland)"]
    

Console

  1. Rufen Sie zum Ausführen eines Workflows in der Google Cloud Console die Seite Workflows auf:

    Zur Seite "Workflows"

  2. Wählen Sie auf der Seite Workflows einen Workflow aus, um die zugehörige Detailseite aufzurufen.

  3. Klicken Sie auf der Seite Workflowdetails auf Ausführen.

  4. Auf der Seite Workflow ausführen können Sie im Bereich Eingabe optionale Laufzeitargumente eingeben, die vor der Ausführung an Ihren Workflow übergeben werden. Argumente müssen im JSON-Format vorliegen. Beispiel: {"animal":"cat"}. Wenn Ihr Workflow keine Laufzeitargumente verwendet, lassen Sie dieses Feld leer.

  5. Geben Sie optional die Ebene des Aufruf-Loggings an, die Sie auf die Ausführung des Workflows anwenden möchten. Wählen Sie in der Liste Anruflogebene eine der folgenden Optionen aus:

    • Nicht angegeben: Es wird keine Logging-Ebene angegeben. Das ist die Standardeinstellung. Eine Ausführungslogebene hat Vorrang vor einer Workflow-Logebene, sofern keine Ausführungslogebene angegeben ist (Standardeinstellung); In diesem Fall wird die Workflow-Logebene genutzt.
    • Nur Fehler: Alle erfassten Ausnahmen sowie das Beenden eines Aufrufs aufgrund einer Ausnahme werden protokolliert.
    • Alle Aufrufe: Alle Aufrufe von untergeordneten Workflows oder Bibliotheksfunktionen und deren Ergebnisse werden protokolliert.
    • Keine Protokolle: keine Anrufprotokollierung.

  6. Klicken Sie auf Execute.

  7. Auf der Seite Ausführungsdetails können Sie die Ergebnisse der Ausführung ansehen, einschließlich der Ausgabe, der Ausführungs-ID und des Ausführungsstatus sowie des aktuellen oder letzten Schritts der Workflowausführung. Weitere Informationen finden Sie unter Auf Ergebnisse der Workflowausführung zugreifen.

gcloud

  1. Öffnen Sie ein Terminalfenster.

  2. Suchen Sie den Namen des Workflows, den Sie ausführen möchten. Wenn Sie den Namen des Workflows nicht kennen, können Sie den folgenden Befehl eingeben, um alle Workflows aufzulisten:

    gcloud workflows list
    
  3. Sie können den Workflow auf zwei Arten ausführen:

    • Führen Sie den Workflow aus und warten Sie, bis die Ausführung abgeschlossen ist:

      gcloud workflows run WORKFLOW_NAME \
      --call-log-level=CALL_LOGGING_LEVEL \
      --data=DATA
      
    • Führen Sie den Workflow aus, ohne auf den Abschluss des Ausführungsversuchs zu warten:

      gcloud workflows execute WORKFLOW_NAME \
      --call-log-level=CALL_LOGGING_LEVEL \
      --data=DATA
      

      Ersetzen Sie Folgendes:

      • WORKFLOW_NAME: Der Name des Workflows.
      • CALL_LOGGING_LEVEL (optional): Stufe des Aufruf-Loggings, die während der Ausführung angewendet werden soll. Kann einer der folgenden Werte sein:

        • none: Es ist keine Logging-Ebene angegeben. Das ist die Standardeinstellung. Eine Ausführungslogebene hat Vorrang vor einer Workflow-Logebene, sofern keine Ausführungslogebene angegeben ist (Standardeinstellung); In diesem Fall wird die Workflow-Logebene genutzt.
        • log-errors-only: Es werden alle erfassten Ausnahmen sowie das Beenden eines Aufrufs aufgrund einer Ausnahme protokolliert
        • log-all-calls: Alle Aufrufe von untergeordneten Workflows oder Bibliotheksfunktionen und deren Ergebnisse werden protokolliert.
        • log-none: Kein Aufruf-Logging.
      • DATA (optional): Laufzeitargumente für Ihren Workflow im JSON-Format.

  4. Wenn Sie gcloud workflows execute ausgeführt haben, wird die eindeutige ID des Workflow-Ausführungsversuchs zurückgegeben und die Ausgabe sieht in etwa so aus:

     To view the workflow status, you can use following command:
     gcloud workflows executions describe b113b589-8eff-4968-b830-8d35696f0b33 --workflow workflow-2 --location us-central1

    Geben Sie den im vorherigen Schritt zurückgegebenen Befehl ein, um den Status der Ausführung aufzurufen.

Wenn der Ausführungsversuch erfolgreich ist, sieht die Ausgabe in etwa so aus, wobei ein state den Erfolg des Workflows und ein status den letzten Workflowschritt der Ausführung angibt.

argument: '{"searchTerm":"Friday"}'
endTime: '2022-06-22T12:17:53.086073678Z'
name: projects/1051295516635/locations/us-central1/workflows/myFirstWorkflow/executions/c4dffd1f-13db-46a0-8a4a-ee39c144cb96
result: '["Friday","Friday the 13th (franchise)","Friday Night Lights (TV series)","Friday
    the 13th (1980 film)","Friday the 13th","Friday the 13th (2009 film)","Friday the
    13th Part III","Friday the 13th Part 2","Friday (Rebecca Black song)","Friday Night
    Lights (film)"]'
startTime: '2022-06-22T12:17:52.799387653Z'
state: SUCCEEDED
status:
    currentSteps:
    - routine: main
        step: returnOutput
workflowRevisionId: 000001-ac2

REST API

Verwenden Sie die Methode projects.locations.workflows.executions.create, um eine neue Ausführung mit der neuesten Überarbeitung eines bestimmten Workflows zu erstellen.

Für die Authentifizierung benötigen Sie zum Ausführen des Workflows ein Dienstkonto mit ausreichenden Berechtigungen. Sie können einem Dienstkonto beispielsweise die Rolle Workflow-Aufrufer (roles/workflows.invoker) zuweisen, sodass das Konto die Berechtigung hat, die Ausführung des Workflows auszulösen. Weitere Informationen finden Sie unter Workflows aufrufen.

Bevor Sie die Anfragedaten verwenden, ersetzen Sie die folgenden Werte:

  • PROJECT_NUMBER ist die Nummer Ihres Google Cloud-Projekts, die auf der Seite IAM & Verwaltung aufgeführt ist.
  • LOCATION: Region, in der der Workflow bereitgestellt wird, z. B. us-central1.
  • WORKFLOW_ID: der benutzerdefinierte Name des Workflows, z. B. myFirstWorkflow.
  • PARAMETER: Optional. Wenn der ausgeführte Workflow Laufzeitargumente empfangen kann, die Sie als Teil einer Ausführungsanfrage übergeben, können Sie dem Anfragetext einen JSON-formatierten String hinzufügen, dessen Wert aus einem oder mehreren maskierten Parameter/Wert-Paaren besteht, z. B. "{\"searchTerm\":\"asia\"}".
  • VALUE: Optional. Der Wert eines Parameterwertpaars, das Ihr Workflow als Laufzeitargument empfangen kann.
  • CALL_LOGGING_LEVEL: Optional. Die Aufruf-Logging-Ebene, die während der Ausführung angewendet werden soll. Standardmäßig ist keine Logging-Ebene angegeben. Stattdessen wird die Workflow-Log-Ebene angewendet. Weitere Informationen finden Sie unter Logs an Logging senden. Eine der folgenden Optionen:
    • CALL_LOG_LEVEL_UNSPECIFIED: Es wird keine Logging-Ebene angegeben. Stattdessen wird die Workflow-Logebene angewendet. Das ist die Standardeinstellung. Andernfalls gilt die Ausführungslogebene und hat Vorrang vor der Workflowlogebene.
    • LOG_ERRORS_ONLY: Protokolliert alle erfassten Ausnahmen oder wenn ein Aufruf aufgrund einer Ausnahme beendet wird.
    • LOG_ALL_CALLS: Protokolliert alle Aufrufe an untergeordnete Workflows oder Bibliotheksfunktionen und deren Ergebnisse.
    • LOG_NONE: Kein Aufruf-Logging.

JSON-Text anfordern:

{
  "argument": "{\"PARAMETER\":\"VALUE\"}",
  "callLogLevel": "CALL_LOGGING_LEVEL"
}

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Wenn der Vorgang erfolgreich ist, enthält der Antworttext eine neu erstellte Instanz von Execution:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION/workflows/WORKFLOW_ID/executions/EXECUTION_ID",
  "startTime": "2023-11-07T14:35:27.215337069Z",
  "state": "ACTIVE",
  "argument": "{\"PARAMETER\":\"VALUE\"}",
  "workflowRevisionId": "000001-2df",
  "callLogLevel": "CALL_LOGGING_LEVEL",
  "status": {}
}

Status von Ausführungen prüfen

Es gibt mehrere Befehle, mit denen Sie den Status einer Workflowausführung prüfen können.

  • Geben Sie den folgenden Befehl ein, um eine Liste der Ausführungsversuche eines Workflows und ihrer IDs abzurufen:

    gcloud workflows executions list WORKFLOW_NAME
    

    Ersetzen Sie WORKFLOW_NAME durch den Namen des Workflows.

    Der Befehl gibt einen NAME-Wert zurück, der etwa so aussieht:

    projects/PROJECT_NUMBER/locations/REGION/workflows/WORKFLOW_NAME/executions/EXECUTION_ID

    Kopieren Sie die Ausführungs-ID, um sie im nächsten Befehl zu verwenden.

  • Geben Sie den folgenden Befehl ein, um den Status eines Ausführungsversuchs zu prüfen und auf den Abschluss des Versuchs zu warten:

    gcloud workflows executions wait EXECUTION_ID
    

    Ersetzen Sie EXECUTION_ID durch die ID des Ausführungsversuchs.

    Der Befehl wartet, bis der Ausführungsversuch abgeschlossen ist, und gibt dann die Ergebnisse zurück.

  • Geben Sie den folgenden Befehl ein, um zu warten, bis die letzte Ausführung abgeschlossen ist, und dann das Ergebnis der abgeschlossenen Ausführung zurückzugeben:

    gcloud workflows executions wait-last
    

    Wenn Sie in derselben gcloud-Sitzung bereits einen Ausführungsversuch unternommen haben, wartet der Befehl, bis der vorherige Ausführungsversuch beendet ist, und gibt dann die Ergebnisse der abgeschlossenen Ausführung zurück. Wenn kein vorheriger Versuch vorhanden ist, gibt gcloud den folgenden Fehler zurück:

    ERROR: (gcloud.workflows.executions.wait-last) [NOT FOUND] There are no cached executions available.
    
  • Geben Sie den folgenden Befehl ein, um den Status der letzten Ausführung abzurufen:

    gcloud workflows executions describe-last
    

    Wenn Sie in derselben gcloud-Sitzung bereits einen Ausführungsversuch unternommen haben, gibt der Befehl die Ergebnisse der letzten Ausführung zurück, auch wenn diese ausgeführt wird. Wenn kein vorheriger Versuch vorhanden ist, gibt gcloud den folgenden Fehler zurück:

    ERROR: (gcloud.beta.workflows.executions.describe-last) [NOT FOUND] There are no cached executions available.
    

Nächste Schritte