Exécuter un workflow

L'exécution d'un workflow exécute la définition actuelle du workflow associé au workflow.

Vous pouvez transmettre des arguments d'exécution dans une requête d'exécution de workflow et y accéder à l'aide d'une variable de workflow. Pour en savoir plus, consultez Transmettre des arguments d'exécution dans une requête d'exécution.

Une fois l'exécution du workflow terminée, son historique et ses résultats sont conservés pendant une durée limitée. Pour en savoir plus, consultez la page Quotas et limites.

Avant de commencer

Les contraintes de sécurité définies par votre organisation peuvent vous empêcher d'effectuer les étapes suivantes. Pour obtenir des informations de dépannage, consultez la page Développer des applications dans un environnement Google Cloud limité.

  1. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.

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

    Go to project selector

  3. Vérifiez que la facturation est activée pour votre projet 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. Vérifiez que la facturation est activée pour votre projet Google Cloud.

  6. Si un workflow accède à d'autres ressources Google Cloud, assurez-vous qu'il est associé à un compte de service disposant des autorisations appropriées pour le faire. Pour savoir quel compte de service est associé à un workflow existant, consultez Validez un compte de service associé au workflow.

    Notez que pour créer une ressource et lui associer un compte de service, vous devez les autorisations requises pour créer cette ressource et emprunter l'identité du compte de service que vous allez rattacher à la ressource. Pour en savoir plus, consultez Autorisations de compte de service

  7. Déployer un workflow à l'aide de la méthode Console Google Cloud ou à la Google Cloud CLI.

Exécuter un workflow

Vous pouvez exécuter un workflow à l'aide des bibliothèques clientes, dans la console Google Cloud à l'aide de la gcloud CLI, ou en envoyant une requête au API REST Workflows

Console

  1. Pour exécuter un workflow, dans la console Google Cloud, accédez à Page Workflows:

    Accéder à "Workflows"

  2. Sur la page Workflows, sélectionnez un workflow pour accéder aux page d'informations.

  3. Sur la page Détails du workflow, cliquez sur Exécuter.

  4. Sur la page Execute workflow (Exécuter le workflow), dans le volet Input (Entrée), vous pouvez saisir des arguments d'exécution facultatifs à transmettre à votre workflow avant l'exécution. Les arguments doivent être au format JSON. Exemple : {"animal":"cat"} Si votre workflow n'utilise pas d'arguments d'exécution, laissez ce champ vide.

  5. Vous pouvez également spécifier le niveau la journalisation des appels souhaitée à appliquer à l'exécution du workflow. Dans Call log level (Niveau des journaux d'appels) sélectionnez l'une des options suivantes:

    • Non spécifié: aucun niveau de journalisation n'est spécifié. Il s'agit de l'option par défaut. Un niveau de journalisation d'exécution est prioritaire sur tout niveau de journalisation de workflow, sauf si celui-ci n'est pas spécifié (valeur par défaut). Dans ce cas, le niveau de journalisation du workflow s'applique.
    • Erreurs uniquement: consigne toutes les exceptions interceptées, ou lorsqu'un appel est arrêté en raison d'une exception.
    • Tous les appels: consigne tous les appels aux sous-workflows ou aux fonctions de la bibliothèque, ainsi que leurs résultats.
    • Aucun journal: aucun journal d'appels.

  6. Cliquez sur Exécuter.

  7. Sur la page Détails de l'exécution, vous pouvez consulter les résultats de y compris les sorties, l'ID et l'état de l'exécution, ainsi que à l'étape actuelle ou finale de l'exécution du workflow. Pour plus d'informations, voir Accédez aux résultats de l'exécution du workflow.

    <ph type="x-smartling-placeholder">.

gcloud

  1. Ouvrez un terminal.

  2. Recherchez le nom du workflow que vous souhaitez exécuter. Si vous ne connaissez pas le nom du workflow, vous pouvez saisir la commande suivante pour répertorier tous vos workflows:

    gcloud workflows list

  3. Vous pouvez exécuter le workflow à l'aide de la méthode gcloud workflows run ou gcloud workflows execute :

    • Exécutez le workflow et attendez la fin de l'exécution:

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

    • Exécutez le workflow sans attendre la fin de la tentative d'exécution:

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

      Remplacez les éléments suivants :

      • WORKFLOW_NAME: nom du workflow.

      • CALL_LOGGING_LEVEL (facultatif): niveau de la journalisation des appels à appliquer pendant l'exécution. Peut être une valeur parmi :

        • none: aucun niveau de journalisation n'est spécifié. Il s'agit de l'option par défaut. Un niveau de journalisation d'exécution est prioritaire sur un niveau de journalisation de workflow, sauf si celui-ci n'est pas spécifié (valeur par défaut). Dans ce cas, le niveau de journalisation du workflow s'applique.
        • log-errors-only: journalise toutes les exceptions interceptées, ou lorsqu'un appel est arrêté en raison d'une exception.
        • log-all-calls: journalise tous les appels aux sous-workflows ou aux fonctions de la bibliothèque, ainsi que leurs résultats.
        • log-none: aucune journalisation des appels.

      • DATA (facultatif): arguments d'exécution pour votre workflow au format JSON.

  4. Si vous avez exécuté gcloud workflows execute, l'ID unique de la tentative d'exécution du workflow est renvoyé et le résultat ressemble à ce qui suit:

     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

    Pour afficher l'état de l'exécution, saisissez la commande renvoyée à l'étape précédente.

Si la tentative d'exécution réussit, le résultat est semblable à suivante, un state indiquant la réussite du workflow et un status qui spécifie la dernière étape du workflow de l'exécution. 

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

Bibliothèques clientes

Les exemples suivants supposent que vous avez déjà déployé un workflow, myFirstWorkflow

  1. Installez la bibliothèque cliente et configurez votre environnement de développement. Pour consultez les Présentation des bibliothèques clientes Workflows

  2. Clonez le dépôt de l'exemple d'application sur votre machine locale :

    Java

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

    Vous pouvez également télécharger l'exemple en tant que fichier ZIP et l'extraire.

    Node.js

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

    Vous pouvez également télécharger l'exemple en tant que fichier ZIP et l'extraire.

    Python 

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

    Vous pouvez également télécharger l'exemple en tant que fichier ZIP et l'extraire.

  3. Accédez au répertoire contenant l'exemple de code 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. Consultez l'exemple de code :

    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'exemple effectue les opérations suivantes:

    1. Configure les bibliothèques clientes Cloud pour Workflows.
    2. Exécute un workflow.
    3. Interroge l'exécution du workflow (en utilisant un intervalle exponentiel entre les tentatives) jusqu'à l'exécution prend fin.
    4. Imprime les résultats d'exécution.

  5. Pour exécuter l'exemple, commencez par installer les dépendances:

    Java

    mvn compile

    Node.js (JavaScript) 

    npm install

    Node.js (TypeScript) 

    npm install && npm run build

    Python

    pip3 install -r requirements.txt

  6. Exécutez le 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

    Remplacez les éléments suivants :

    • PROJECT_ID (obligatoire): ID du projet Projet Google Cloud
    • CLOUD_REGION: emplacement du workflow (par défaut: us-central1)
    • WORKFLOW_NAME: ID du workflow (par défaut: myFirstWorkflow)

    Le résultat ressemble à ce qui suit :

    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

Pour créer une exécution à l'aide de la dernière révision d'un workflow donné, utilisez la projects.locations.workflows.executions.create .

Notez que pour vous authentifier, vous aurez besoin d'un compte de service disposant d'une pour exécuter le workflow. Par exemple, vous pouvez accorder à un service le rôle Demandeur de workflows. (roles/workflows.invoker) pour que le compte soit autorisé à déclencher l'exécution de votre workflow. Pour en savoir plus, consultez Appeler Workflows

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_NUMBER: votre compte Google Cloud le numéro de projet indiqué dans la console d'administration IAM & Administrateur Paramètres.
  • LOCATION: le région dans laquelle le workflow est déployé, par exemple us-central1
  • WORKFLOW_NAME: nom défini par l'utilisateur pour le workflow, par exemple, myFirstWorkflow.
  • PARAMETER : Facultatif. Si le workflow que vous exécutez peuvent recevoir des arguments d'exécution que vous les transmettez dans le cadre d'une requête d'exécution, vous pouvez ajouter au corps de la requête une chaîne au format JSON dont la valeur est un ou plusieurs caractères d'échappement paires paramètre-valeur (par exemple, "{\"searchTerm\":\"asia\"}").
  • VALUE : Facultatif. La valeur d'un que votre workflow peut recevoir en tant qu'argument d'exécution.
  • CALL_LOGGING_LEVEL : Facultatif. Niveau de journalisation des appels à appliquer lors de l'exécution. Par défaut, aucun niveau de journalisation spécifié, et le niveau de journalisation du workflow s'applique à la place. Pour en savoir plus, consultez Envoyez des journaux à Logging. L'une des suivantes: <ph type="x-smartling-placeholder">
      </ph>
    • CALL_LOG_LEVEL_UNSPECIFIED: aucun niveau de journalisation n'est spécifié et le niveau de journalisation du workflow s'applique à la place. Il s'agit de l'option par défaut. Sinon, le niveau de journalisation s'applique et prévaut sur le niveau de journalisation du workflow.
    • LOG_ERRORS_ONLY: journalise toutes les exceptions interceptées. ou lorsqu'un appel est arrêté en raison d'une exception.
    • LOG_ALL_CALLS: journalise tous les appels de sous-workflows ou de fonctions de bibliothèque et leurs résultats.
    • LOG_NONE: aucune journalisation des appels.

Corps JSON de la requête :

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

Pour envoyer votre requête, développez l'une des options suivantes :

Si la requête aboutit, le corps de la réponse contient une nouvelle instance de Execution: 

{
  "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": {}
}

Vérifier l'état des exécutions

Plusieurs commandes vous permettent de vérifier l'état d'exécution d'un workflow.

  • Pour récupérer la liste des tentatives d'exécution d'un workflow et de leurs ID, saisissez la commande suivante:

    gcloud workflows executions list WORKFLOW_NAME

    Remplacez WORKFLOW_NAME par le nom du workflow.

    La commande renvoie une valeur NAME semblable à ce qui suit:

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

    Copiez l'ID d'exécution à utiliser dans la commande suivante.

  • Pour vérifier l'état d'une tentative d'exécution et attendre la fin de la tentative, saisissez la commande suivante:

    gcloud workflows executions wait EXECUTION_ID

    Remplacez EXECUTION_ID par l'ID de la tentative d'exécution.

    La commande attend la fin de la tentative d'exécution, puis renvoie les résultats.

  • Pour attendre la fin de la dernière exécution, puis renvoyer le résultat de la est terminée, saisissez la commande suivante:

    gcloud workflows executions wait-last

    Si vous avez effectué une tentative d'exécution précédente dans la même session gcloud, le attend la fin de la tentative d'exécution précédente, puis renvoie les résultats de l'exécution terminée. Si aucune tentative précédente n'existe, gcloud renvoie l'erreur suivante:

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

  • Pour connaître l'état de la dernière exécution, saisissez le la commande suivante:

    gcloud workflows executions describe-last

    Si vous avez effectué une tentative d'exécution précédente dans la même session gcloud, le renvoie les résultats de la dernière exécution, même si elle est en cours d'exécution. Si aucune tentative précédente n'existe, gcloud renvoie l'erreur suivante:

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

Filtrer les exécutions

Vous pouvez appliquer des filtres à la liste des exécutions de workflow renvoyées par Méthode workflows.executions.list.

Vous pouvez filtrer les données en fonction des champs suivants:

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

Par exemple, pour filtrer les données à l'aide d'un libellé (labels."fruit":"apple"), vous pouvez définir une Requête d'API semblable à celle-ci:

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"

Où :

  • view=full spécifie une vue définissant les champs à renseigner dans le a renvoyé des exécutions ; dans ce cas, toutes les données
  • labels.%22fruit%22%3A%22apple%22 est la syntaxe du filtre encodée au format URL.

Pour en savoir plus, consultez la page Filtrage AIP-160.

Étape suivante