Esegui un flusso di lavoro

L'esecuzione di un flusso di lavoro esegue la definizione attuale del flusso di lavoro associata al flusso di lavoro.

Puoi passare gli argomenti di runtime in una richiesta di esecuzione del flusso di lavoro e accedere a questi argomenti utilizzando una variabile del flusso di lavoro. Per ulteriori informazioni, consulta Passare gli argomenti di runtime in una richiesta di esecuzione.

Al termine dell'esecuzione di un flusso di lavoro, la relativa cronologia e i risultati vengono conservati per un periodo di tempo limitato. Per ulteriori informazioni, consulta Quote e limiti.

Prima di iniziare

I vincoli di sicurezza definiti dalla tua organizzazione potrebbero impedirti di completare i passaggi seguenti. Per informazioni sulla risoluzione dei problemi, vedi Sviluppare applicazioni in un ambiente Google Cloud vincolato.

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

4. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

5. Make sure that billing is enabled for your Google Cloud project.

6. Se un flusso di lavoro accede ad altre risorse Google Cloud, assicurati che sia associato a un account di servizio che disponga delle autorizzazioni corrette per farlo. Per sapere quale account di servizio è associato a un flusso di lavoro esistente, consulta Verificare l'account di servizio associato a un flusso di lavoro.

   Tieni presente che per creare una risorsa e collegare un account di servizio, devi disporre delle autorizzazioni per creare la risorsa e per rubare l'identità dell'account di servizio che collegherai alla risorsa. Per ulteriori informazioni, consulta Autorizzazioni degli account di servizio.

7. Esegui il deployment di un flusso di lavoro utilizzando la console Google Cloud o Google Cloud CLI.

Nota: per inviare i log a Cloud Logging, assicurati che all'account di servizio che esegue il flusso di lavoro sia stato concesso un ruolo che includa l'autorizzazione logging.logEntries.create (ad esempio, il ruolo Logs Writer).

Esegui un flusso di lavoro

Puoi eseguire un flusso di lavoro utilizzando le librerie client, nella console Google Cloud, con la gcloud CLI o inviando una richiesta all'API REST di Workflows.

Console

1. Per eseguire un flusso di lavoro, nella console Google Cloud vai alla pagina Flussi di lavoro:

   Vai a Flussi di lavoro

2. Nella pagina Flussi di lavoro, seleziona un flusso di lavoro per accedere alla relativa pagina dettagli.

3. Nella pagina Dettagli flusso di lavoro, fai clic su Esegui.

4. Nella pagina Esegui flusso di lavoro, nel riquadro Input, puoi inserire argomenti di runtime facoltativi da passare al flusso di lavoro prima dell'esecuzione. Gli argomenti devono essere in formato JSON, ad esempio {"animal":"cat"}. Se il flusso di lavoro non utilizza gli argomenti di runtime, lascia vuoto questo campo.

5. (Facoltativo) Specifica il livello di registrazione delle chiamate da applicare all'esecuzione del flusso di lavoro. Nell'elenco Livello di log delle chiamate, seleziona una delle seguenti opzioni:

   • Non specificato: non è specificato alcun livello di logging. Questa è l'impostazione predefinita. Un livello di log dell'esecuzione ha la precedenza su qualsiasi livello di log del flusso di lavoro, a meno che il livello di log dell'esecuzione non sia specificato (valore predefinito). In questo caso, viene applicato il livello di log del flusso di lavoro.
   • Solo errori: registra tutte le eccezioni rilevate o quando una chiamata viene interrotta a causa di un'eccezione.
   • Tutte le chiamate: registra tutte le chiamate ai flussi di lavoro secondari o alle funzioni della libreria e i relativi risultati.
   • Nessun log: nessuna registrazione delle chiamate.

6. Fai clic su Execute (Esegui).

7. Nella pagina Dettagli esecuzione, puoi visualizzare i risultati dell'esecuzione, inclusi eventuali output, l'ID esecuzione e lo stato, nonché il passaggio corrente o finale dell'esecuzione del flusso di lavoro. Per saperne di più, consulta Accedere ai risultati di esecuzione del flusso di lavoro.

   Nota: per accedere alla pagina Dettagli esecuzione, devi disporre di un ruolo che contenga le autorizzazioni workflows.workflows.get, workflows.executions.get e workflows.stepEntries.list. Per ulteriori informazioni, consulta Ruoli e autorizzazioni dei flussi di lavoro e Gestire l'accesso.

gcloud

1. Apri un terminale.

2. Trova il nome del flusso di lavoro da eseguire. Se non conosci il nome del flusso di lavoro, puoi inserire il seguente comando per elencare tutti i tuoi flussi di lavoro:

   gcloud workflows list

3. Puoi eseguire il flusso di lavoro utilizzando il comando gcloud workflows run o il comando gcloud workflows execute:

   • Esegui il flusso di lavoro e attendi il completamento dell'esecuzione:

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

   • Esegui il flusso di lavoro senza attendere il completamento del tentativo di esecuzione:

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

     Sostituisci quanto segue:

     • WORKFLOW_NAME: il nome del flusso di lavoro.

     • CALL_LOGGING_LEVEL (facoltativo): il livello di registrazione delle chiamate da applicare durante l'esecuzione. Può essere uno dei seguenti:

       • none: non è specificato alcun livello di logging. Questa è l'impostazione predefinita. Un livello di log dell'esecuzione ha la precedenza su qualsiasi livello di log del flusso di lavoro, a meno che il livello di log dell'esecuzione non sia specificato (valore predefinito). In questo caso, viene applicato il livello di log del flusso di lavoro.
       • log-errors-only: registra tutte le eccezioni rilevate o quando una chiamata viene interrotta a causa di un'eccezione.
       • log-all-calls: registra tutte le chiamate ai sottoprocessi o alle funzioni della raccolta e i relativi risultati.
       • log-none: nessun registro chiamate.

     • DATA (facoltativo): argomenti di runtime per il flusso di lavoro in formato JSON.

4. Se hai eseguito gcloud workflows execute, viene restituito l'ID univoco del tentativo di esecuzione del flusso di lavoro e l'output è simile al seguente:

    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

   Per visualizzare lo stato dell'esecuzione, inserisci il comando restituito dal passaggio precedente.

Se il tentativo di esecuzione è riuscito, l'output è simile al seguente, con un state che indica l'esito positivo del flusso di lavoro e un status che specifica il passaggio finale del flusso di lavoro dell'esecuzione.

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

Librerie client

I seguenti esempi presuppongono che tu abbia già implementato un flusso di lavoro,myFirstWorkflow.

1. Installa la libreria client e configura l'ambiente di sviluppo. Per maggiori dettagli, consulta la panoramica delle librerie client di Workflows.

2. Clona il repository dell'app di esempio sulla tua macchina locale:

   Java

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

   In alternativa, puoi scaricare l'esempio come file ZIP ed estrarlo.

   Node.js

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

   In alternativa, puoi scaricare l'esempio come file ZIP ed estrarlo.

   Python

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

   In alternativa, puoi scaricare l'esempio come file ZIP ed estrarlo.

3. Passa alla directory che contiene il codice di esempio di Workflows:

   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. Dai un'occhiata al codice campione:

   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
   
   

   L'esempio esegue le seguenti operazioni:

   1. Configura le librerie client Cloud per Workflows.
   2. Esegue un flusso di lavoro.
   3. Esegue il polling dell'esecuzione del flusso di lavoro (utilizzando il backoff esponenziale) fino al termine dell'esecuzione.
   4. Stampa i risultati dell'esecuzione.

5. Per eseguire il sample, installa prima le dipendenze:

   Java

   mvn compile

   Node.js (JavaScript)

   npm install

   Node.js (TypeScript)

   npm install && npm run build

   Python

   pip3 install -r requirements.txt

6. Esegui lo script:

   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

   Sostituisci quanto segue:

   • PROJECT_ID (obbligatorio): l'ID progetto del progetto Google Cloud
   • CLOUD_REGION: la posizione del flusso di lavoro (valore predefinito: us-central1)
   • WORKFLOW_NAME: l'ID del flusso di lavoro (valore predefinito: myFirstWorkflow)

   L'output è simile al seguente:

   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)"]
   

API REST

Per creare una nuova esecuzione utilizzando l'ultima revisione di un determinato flusso di lavoro, utilizza il metodo projects.locations.workflows.executions.create.

Tieni presente che per l'autenticazione è necessario un account di servizio con privilegi sufficienti per eseguire il flusso di lavoro. Ad esempio, puoi concedere a un account di servizio il ruolo Invoker di Workflows (roles/workflows.invoker) in modo che l'account abbia l'autorizzazione per attivare l'esecuzione del flusso di lavoro. Per saperne di più, consulta Eseguire chiamate a Workflows.

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

• PROJECT_NUMBER: il numero del tuo progetto Google Cloud elencato nella pagina Impostazioni di IAM e amministrazione.
• LOCATION: la regione in cui è stato eseguito il deployment del flusso di lavoro, ad esempio us-central1.
• WORKFLOW_NAME: il nome definito dall'utente per il flusso di lavoro, ad esempio myFirstWorkflow.
• PARAMETER: facoltativo. Se il flusso di lavoro che stai eseguendo può ricevere gli argomenti di runtime che gli passi come parte di una richiesta di esecuzione, puoi aggiungere al corpo della richiesta una stringa in formato JSON il cui valore è costituito da una o più coppie di parametri e valori con caratteri di escape, ad esempio "{\"searchTerm\":\"asia\"}".
• VALUE: facoltativo. Il valore di una coppia parametro-valore che il flusso di lavoro può ricevere come argomento di runtime.
• CALL_LOGGING_LEVEL: facoltativo. Il livello di registrazione delle chiamate da applicare durante l'esecuzione. Per impostazione predefinita, non viene specificato alcun livello di registrazione e viene applicato il livello di log del flusso di lavoro. Per ulteriori informazioni, consulta la sezione Inviare log a Logging. Uno dei seguenti:
  • CALL_LOG_LEVEL_UNSPECIFIED: non è specificato alcun livello di logging e viene applicato il livello di log del flusso di lavoro. Questa è l'impostazione predefinita. In caso contrario, viene applicato il livello di log dell'esecuzione e ha la precedenza sul livello di log del flusso di lavoro.
  • LOG_ERRORS_ONLY: registra tutte le eccezioni rilevate oppure quando una chiamata viene bloccata a causa di un'eccezione.
  • LOG_ALL_CALLS: registra tutte le chiamate ai sottoprocessi o alle funzioni della libreria e i relativi risultati.
  • LOG_NONE: nessun registro chiamate.
• BACKLOG_EXECUTION: facoltativo. Se impostato su true, l'esecuzione non viene inserita in coda quando la quota di concorrenza è esaurita. Per saperne di più, consulta Gestire le code di esecuzione.

Corpo JSON della richiesta:

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

Per inviare la richiesta, espandi una di queste opzioni:

curl (Linux, macOS o Cloud Shell)

Nota: il seguente comando presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti consente di accedere automaticamente all'interfaccia a riga di comando gcloud. Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente:

cat > request.json << 'EOF'
{
  "argument": "{\"PARAMETER\":\"VALUE\"}",
  "callLogLevel": "CALL_LOGGING_LEVEL",
  "disableConcurrencyQuotaOverflowBuffering": "BACKLOG_EXECUTION"
}
EOF

Quindi, esegui il seguente comando per inviare la richiesta REST:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://workflowexecutions.googleapis.com/v1/projects/PROJECT_NUMBER/locations/LOCATION/workflows/WORKFLOW_NAME/executions"

PowerShell (Windows)

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso alla CLI gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente:

@'
{
  "argument": "{\"PARAMETER\":\"VALUE\"}",
  "callLogLevel": "CALL_LOGGING_LEVEL",
  "disableConcurrencyQuotaOverflowBuffering": "BACKLOG_EXECUTION"
}
'@  | Out-File -FilePath request.json -Encoding utf8

Quindi, esegui il seguente comando per inviare la richiesta REST:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://workflowexecutions.googleapis.com/v1/projects/PROJECT_NUMBER/locations/LOCATION/workflows/WORKFLOW_NAME/executions" | Select-Object -Expand Content

Explorer API (browser)

Copia il corpo della richiesta e apri la pagina di riferimento del metodo. Il riquadro Esplora API si apre sul lato destro della pagina. Puoi interagire con questo strumento per inviare richieste. Incolla il corpo della richiesta in questo strumento, compila gli altri campi obbligatori e fai clic su Esegui.

In caso di esito positivo, il corpo della risposta contiene un'istanza di Execution appena creata:

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

Controllare lo stato delle esecuzioni

Esistono diversi comandi che ti aiutano a controllare lo stato dell'esecuzione di un flusso di lavoro.

• Per recuperare un elenco dei tentativi di esecuzione di un flusso di lavoro e dei relativi ID, inserisci il seguente comando:

  gcloud workflows executions list WORKFLOW_NAME

  Sostituisci WORKFLOW_NAME con il nome del flusso di lavoro.

  Il comando restituisce un valore NAME simile al seguente:

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

  Copia l'ID esecuzione da utilizzare nel comando successivo.

• Per controllare lo stato di un tentativo di esecuzione e attendere il completamento del tentativo, inserisci il seguente comando:

  gcloud workflows executions wait EXECUTION_ID

  Sostituisci EXECUTION_ID con l'ID del tentativo di esecuzione.

  Il comando attende il completamento del tentativo di esecuzione e poi restituisce i risultati.

• Per attendere il completamento dell'ultima esecuzione e restituire il risultato dell'esecuzione completata, inserisci il seguente comando:

  gcloud workflows executions wait-last

  Se hai eseguito un tentativo di esecuzione precedente nella stessa sessione gcloud, il comando attende il completamento del tentativo di esecuzione precedente e poi restituisce i risultati dell'esecuzione completata. Se non esiste alcun tentativo precedente, gcloud restituisce il seguente errore:

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

• Per ottenere lo stato dell'ultima esecuzione, inserisci il comando seguente:

  gcloud workflows executions describe-last

  Se hai eseguito un tentativo di esecuzione precedente nella stessa sessione gcloud, il comando restituisce i risultati dell'ultima esecuzione anche se è in esecuzione. Se non esiste alcun tentativo precedente, gcloud restituisce il seguente errore:

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

Filtra esecuzioni

Puoi applicare filtri all'elenco delle esecuzioni del flusso di lavoro restituite dal metodo workflows.executions.list.

Puoi filtrare in base ai seguenti campi:

• createTime
• disableOverflowBuffering
• duration
• endTime
• executionId
• label
• startTime
• state
• stepName
• workflowRevisionId

Ad esempio, per filtrare in base a un'etichetta (labels."fruit":"apple"), puoi effettuare una richiesta API simile alla seguente:

GET https://workflowexecutions.googleapis.com/v1/projects/MY_PROJECT/locations/MY_LOCATION/workflows/MY_WORKFLOW/executions?view=full&filter=labels.%22fruit%22%3A%22apple%22"

Dove:

• view=full specifica una vista che definisce i campi da compilare nelle esecuzioni restituite; in questo caso, tutti i dati
• labels.%22fruit%22%3A%22apple%22è la sintassi del filtro con codifica URL

Per ulteriori informazioni, consulta la sezione Filtro AIP-160.

Gestire il backlog di esecuzione

Anteprima

Questa funzionalità è soggetta ai "Termini delle Offerte pre-GA" nella sezione Termini generali del servizio dei Termini specifici dei servizi. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per saperne di più, consulta le descrizioni della fase di lancio.

Puoi utilizzare la coda di esecuzione per evitare i tentativi di nuovo invio lato client, rimuovere i ritardi di esecuzione e massimizzare il throughput. Le esecuzioni in coda vengono eseguite automaticamente non appena diventa disponibile la quota di concorrenza delle esecuzioni.

Best practice: se l'esecuzione dei flussi di lavoro è soggetta a vincoli di tempo o è sensibile, non è consigliabile accumulare le esecuzioni in coda e dovresti prendere in considerazione la possibilità di disattivare la funzionalità.

Esiste un numero massimo di esecuzioni di flussi di lavoro attivi che possono essere eseguite contemporaneamente. Una volta esaurita questa quota, se la funzionalità di posticipazione delle esecuzioni è disattivata o se viene raggiunta la quota per le esecuzioni in coda, le nuove esecuzioni non vanno a buon fine con un codice di stato HTTP 429 Too many requests. Con l'archiviazione delle esecuzioni abilitata, le nuove esecuzioni riescono e vengono create in uno stato QUEUED. Non appena la quota di concorrenza delle esecuzioni diventa disponibile, le esecuzioni vengono eseguite automaticamente e entrano in uno stato ACTIVE.

Per impostazione predefinita, il backlogging dell'esecuzione è abilitato per tutte le richieste (incluse quelle attivate da Cloud Tasks) con le seguenti eccezioni:

• Quando crei un'esecuzione utilizzando un connettore executions.run o executions.create in un flusso di lavoro, la coda di lavoro delle esecuzioni è disabilitata per impostazione predefinita. Puoi configurarlo impostando esplicitamente il campo disableConcurrencyQuotaOverflowBuffering dell'esecuzione su false.
• Per le esecuzioni attivate da Pub/Sub, il backlog delle esecuzioni è disabilitato e non può essere configurato.

Tieni presente quanto segue:

• Le esecuzioni in coda vengono avviate in ordine di arrivo (FIFO), secondo il criterio del "best effort".
• Un campo timestamp createTime indica quando viene creata un'esecuzione. Il timestamp startTime indica quando un'esecuzione viene estratta automaticamente dalla coda del backlog e inizia a essere eseguita. Per le esecuzioni non in coda, entrambi i valori timestamp sono identici.
• Il limite per le esecuzioni in coda può essere osservato utilizzando la metrica quota workflowexecutions.googleapis.com/executionbacklogentries. Per maggiori informazioni, consulta Visualizzare e gestire le quote.

Disattivare il backlogging dell'esecuzione

Puoi disattivare il backlog di esecuzione impostando un flag quando utilizzi Google Cloud CLI. Ad esempio:

gcloud workflows execute WORKFLOW_NAME
    --disable-concurrency-quota-overflow-buffering

In alternativa, puoi disattivare il backlogging dell'esecuzione impostando il campo disableConcurrencyQuotaOverflowBuffering su true nel corpo JSON della richiesta quando invii una richiesta di esecuzione all'API REST di Workflows. Ad esempio:

{
  "argument": {"arg1":"value1"},
  "callLogLevel": "LOG_NONE",
  "disableConcurrencyQuotaOverflowBuffering": true
}

Per ulteriori informazioni, vedi Eseguire un flusso di lavoro.

Passaggi successivi

• Aggiornare un flusso di lavoro esistente

• Controlla l'ordine di esecuzione in un flusso di lavoro