Esegui un flusso di lavoro

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

Puoi passare argomenti di runtime in una richiesta di esecuzione di un flusso di lavoro e accedervi utilizzando una variabile di flusso di lavoro. Per ulteriori informazioni, vedi Passare gli argomenti di runtime in una richiesta di esecuzione.

Al termine dell'esecuzione di un flusso di lavoro, la cronologia e i risultati vengono conservati per per un periodo di tempo limitato. Per saperne di più, 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. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

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

    Go to project selector

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

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

    Go to project selector

  5. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  6. Se un flusso di lavoro accede ad altre risorse Google Cloud, assicurati che sia associati a un account di servizio che dispone delle autorizzazioni corrette per farlo. Per sapere quale account di servizio è associato a un flusso di lavoro esistente, consulta Verifica un associato al tuo flusso di lavoro.

    Tieni presente che per creare una risorsa e collegare un account di servizio, le autorizzazioni per creare quella risorsa e impersonare l'account di servizio che collegherai alla risorsa. Per ulteriori informazioni, vedi Autorizzazioni dell'account di servizio.

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

Esegui un flusso di lavoro

Puoi eseguire un flusso di lavoro utilizzando le librerie client nella console Google Cloud, utilizzando gcloud CLI o inviando una richiesta API REST 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 al relativo pagina dei dettagli.

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

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

  5. Facoltativamente, specifica il livello logging delle chiamate che vuoi da applicare all'esecuzione del flusso di lavoro. Nella sezione Livello registro chiamate seleziona una delle seguenti opzioni:

    • Non specificato: non è stato specificato alcun livello di logging. Questa è l'impostazione predefinita. Un livello di log di esecuzione ha la precedenza su qualsiasi livello di log del flusso di lavoro, a meno che il livello di log dell'esecuzione non è 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 a flussi di lavoro secondari o funzioni di libreria e i propri risultati.
    • Nessun log: nessun logging delle chiamate.

  6. Fai clic su Execute (Esegui).

  7. Nella pagina Dettagli esecuzione puoi visualizzare i risultati esecuzione, inclusi eventuali output, l'ID e lo stato di esecuzione e passaggio corrente o finale dell'esecuzione del flusso di lavoro. Per ulteriori informazioni, vedi Accedi ai risultati di esecuzione del flusso di lavoro.

gcloud

  1. Apri un terminale.

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

    gcloud workflows list

  3. Puoi eseguire il flusso di lavoro utilizzando 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 tentativo di esecuzione finire:

      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): livello di registra le chiamate per applicare durante l'esecuzione. Può essere uno dei seguenti:

        • none: nessun livello di logging specificato. Questa è l'impostazione predefinita. Un di log dell'esecuzione ha la precedenza su qualsiasi livello di log del flusso di lavoro a meno che non venga specificato il livello di log dell'esecuzione (predefinito); in questo caso, si applica il livello di log del flusso di lavoro.
        • log-errors-only: registra tutte le eccezioni rilevate; o quando viene effettuata una chiamata interrotto a causa di un'eccezione.
        • log-all-calls: registra tutte le chiamate a flussi di lavoro secondari o libreria e i relativi risultati.
        • log-none: nessun registro chiamate.

      • (Facoltativo) DATA: argomenti di runtime per in formato JSON.

  4. Se hai eseguito gcloud workflows execute, l'ID univoco del flusso di lavoro viene restituito un tentativo di esecuzione 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 ha esito positivo, l'output è simile al di seguito, 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

Gli esempi riportati di seguito presuppongono che tu abbia già eseguito il deployment di un flusso di lavoro. myFirstWorkflow.

  1. Installa la libreria client e configura l'ambiente di sviluppo. Per vedi i dettagli. Panoramica delle librerie client di Workflows.

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

    Java 

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

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

    Node.js 

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

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

    Python 

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

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

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

    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

    Nell'esempio:

    1. Configura le librerie client di Cloud per Workflows.
    2. Esegue un flusso di lavoro.
    3. Sottopone a sondaggio l'esecuzione del flusso di lavoro (utilizzando il backoff esponenziale) fino a quando dell'esecuzione.
    4. Stampa i risultati dell'esecuzione.

  5. Per eseguire l'esempio, 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: posizione per il 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, usa il projects.locations.workflows.executions.create .

Tieni presente che per eseguire l'autenticazione, avrai bisogno di un account di servizio con i privilegi necessari per eseguire il flusso di lavoro. Ad esempio, puoi concedere a un servizio il ruolo Invoker flussi di lavoro (roles/workflows.invoker) in modo che l'account abbia l'autorizzazione a attivare l'esecuzione del flusso di lavoro. Per ulteriori informazioni, vedi Richiama Workflows.

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

  • PROJECT_NUMBER: il tuo account Google Cloud di progetto elencato nella sezione IAM e Amministratore Impostazioni.
  • LOCATION: il valore regione in cui viene eseguito il deployment del flusso di lavoro, ad esempio us-central1.
  • WORKFLOW_NAME: nome definito dall'utente per il flusso di lavoro, ad esempio myFirstWorkflow.
  • PARAMETER: facoltativo. Se il flusso di lavoro che stai eseguendo possono ricevere gli argomenti di runtime, che li passi come parte di una richiesta di esecuzione, puoi aggiungere al corpo della richiesta una stringa in formato JSON il cui valore contiene uno o più caratteri di escape in coppie parametro-valore, ad esempio "{\"searchTerm\":\"asia\"}".
  • VALUE: facoltativo. Il valore di un che il flusso di lavoro può ricevere come argomento di runtime.
  • CALL_LOGGING_LEVEL: facoltativo. Il livello di logging delle chiamate da applicare durante l'esecuzione. L'impostazione predefinita è che nessun livello di logging specificato e al suo posto si applica il livello di log del flusso di lavoro. Per ulteriori informazioni, vedi Invia i log a Logging. Uno dei seguenti:
    • CALL_LOG_LEVEL_UNSPECIFIED: non viene specificato alcun livello di logging e viene applicato il livello di log del flusso di lavoro. Questa è l'impostazione predefinita. In caso contrario, 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; o quando viene effettuata una chiamata interrotto a causa di un'eccezione.
    • LOG_ALL_CALLS: registra tutte le chiamate a flussi di lavoro secondari o funzioni di libreria e i relativi risultati.
    • LOG_NONE: nessun registro chiamate.

Corpo JSON della richiesta: 

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

Per inviare la richiesta, espandi una delle seguenti opzioni:

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 per controllare lo stato di un flusso di lavoro dell'esecuzione.

  • Per recuperare un elenco dei tentativi di esecuzione di un flusso di lavoro e i 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 che venga eseguito inserisci questo 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, quindi restituisce il comando che consentono di analizzare i dati e visualizzare i risultati.

  • attendere il completamento dell'ultima esecuzione e poi restituire il risultato completa l'esecuzione, inserisci il comando seguente:

    gcloud workflows executions wait-last

    Se hai effettuato un precedente tentativo di esecuzione nella stessa sessione di gcloud, il valore il comando attende il completamento del tentativo di esecuzione precedente, quindi restituisce i risultati dell'esecuzione completata. Se non c'è 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 seguente comando:

    gcloud workflows executions describe-last

    Se hai effettuato un precedente tentativo di esecuzione nella stessa sessione di gcloud, il valore restituisce i risultati dell'ultima esecuzione anche se è in esecuzione. In caso contrario tentativo precedente esiste, 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 di esecuzioni del flusso di lavoro restituite dal Metodo workflows.executions.list.

Puoi applicare un filtro nei seguenti campi:

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

Ad esempio, per filtrare in base a un'etichetta (labels."fruit":"apple"), puoi creare 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 esecuzioni restituite; In questo caso, tutti i dati
  • labels.%22fruit%22%3A%22apple%22 è la sintassi del filtro con codifica URL

Per ulteriori informazioni, vedi Filtro AIP-160.

Passaggi successivi