Executar um fluxo de trabalho

Quando um fluxo de trabalho é executado, a definição atual associada a ele também é.

É possível transmitir argumentos de ambiente de execução em uma solicitação de execução de fluxo de trabalho e acessá-los usando uma variável de fluxo de trabalho. Para mais informações, consulte Transmitir argumentos de ambiente de execução em uma solicitação de execução.

Depois que uma execução de fluxo de trabalho é concluída, o histórico e os resultados dela são retidos por um tempo limitado. Para mais informações, consulte Cotas e limites.

Antes de começar

As restrições de segurança definidas pela sua organização podem impedir que você conclua as etapas a seguir. Para informações sobre solução de problemas, consulte Desenvolver aplicativos em um ambiente restrito do Google Cloud.

  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.

    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.

    Go to project selector

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

  6. Se um fluxo de trabalho acessar outros recursos do Google Cloud, verifique se ele está associado a uma conta de serviço que tenha as permissões corretas para fazer isso. Para saber qual conta de serviço está associada a um fluxo de trabalho atual, consulte Verificar a conta de serviço associada a um fluxo de trabalho.

    Para criar um recurso e anexar uma conta de serviço, você precisa de permissões para criar esse recurso e se passar pela conta de serviço que você anexará ao recurso. Para mais informações, consulte Permissões da conta de serviço.

  7. Implante um fluxo de trabalho usando o console do Google Cloud ou a Google Cloud CLI.

Executar um fluxo de trabalho

É possível executar um fluxo de trabalho usando as bibliotecas de cliente, o console do Google Cloud, a CLI gcloud ou enviando uma solicitação para a API REST do Workflows.

Console

  1. Para executar um fluxo de trabalho, acesse a página Workflows no console do Google Cloud:

    Acessar fluxos de trabalho

  2. Na página Fluxos de trabalho, selecione um fluxo de trabalho para acessar a página de detalhes dele.

  3. Na página Detalhes do fluxo de trabalho, clique em Executar.

  4. No painel Entrada da página Executar fluxo de trabalho, insira argumentos de ambiente de execução opcionais para transmitir ao fluxo de trabalho antes da execução. Os argumentos precisam estar no formato JSON, por exemplo, {"animal":"cat"}. Se o fluxo de trabalho não usa argumentos de ambiente de execução, deixe em branco.

  5. Se quiser, especifique o nível de registro de chamadas que você quer aplicar à execução do fluxo de trabalho. Na lista Nível de registro de chamadas, selecione uma das seguintes opções:

    • Não especificado: nenhum nível de registro foi especificado. Esse é o padrão. Um nível de registro de execução tem precedência sobre qualquer nível de registro de fluxo de trabalho, a menos que o nível de registro de execução não seja especificado (o padrão). Nesse caso, o nível de registro de fluxo de trabalho é aplicado.
    • Somente erros: registra todas as exceções identificadas; ou quando uma chamada é interrompida devido a uma exceção.
    • Todas as chamadas: registre todas as chamadas para subfluxos de trabalho ou funções de biblioteca e os respectivos resultados.
    • Sem registros: nenhum registro de chamadas.

  6. Clique em Executar.

  7. Na página Detalhes da execução, você pode conferir os resultados da execução, incluindo qualquer saída, o ID e o estado da execução e a etapa atual ou final da execução do fluxo de trabalho. Para mais informações, consulte Acessar os resultados da execução do fluxo de trabalho.

gcloud

  1. Abra um terminal.

  2. Encontre o nome do fluxo de trabalho que você quer executar. Se você não souber o nome dele, insira o seguinte comando para listar todos os fluxos de trabalho:

    gcloud workflows list
  3. É possível executar o fluxo de trabalho usando o comando gcloud workflows run ou o comando gcloud workflows execute:

    • Executar o fluxo de trabalho e aguardar o fim da execução:

      gcloud workflows run WORKFLOW_NAME \
          --call-log-level=CALL_LOGGING_LEVEL \
          --data=DATA
    • Executar o fluxo de trabalho sem aguardar o fim da execução:

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

      Substitua:

      • WORKFLOW_NAME: o nome do fluxo de trabalho.
      • CALL_LOGGING_LEVEL (opcional): nível de registro de chamadas a ser aplicado durante a execução. Pode ser um dos seguintes:

        • none: nenhum nível de registro foi especificado. Esse é o padrão. Um nível de registro de execução tem precedência sobre qualquer nível de registro de fluxo de trabalho, a menos que o nível de registro de execução não seja especificado (o padrão). Nesse caso, o nível de registro de fluxo de trabalho é aplicado.
        • log-errors-only: registra todas as exceções identificadas. ou quando uma chamada é interrompida devido a uma exceção.
        • log-all-calls: registra todas as chamadas para subfluxos de trabalho ou funções de biblioteca e os resultados delas.
        • log-none: nenhum registro de chamadas.
      • DATA (opcional): argumentos de ambiente de execução para seu fluxo de trabalho no formato JSON.

  4. Se você executou gcloud workflows execute, o ID exclusivo da tentativa de execução do fluxo de trabalho é retornado e a saída é semelhante a esta:

     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

    Para visualizar o status da execução, insira o comando retornado pela etapa anterior.

Se a tentativa de execução tiver êxito, a saída será semelhante a esta, com um state indicando o sucesso do fluxo de trabalho e um status que especifica a etapa final do fluxo de trabalho da execução.

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

Bibliotecas de cliente

Os exemplos a seguir pressupõem que você já tenha implantado um fluxo de trabalho, myFirstWorkflow.

  1. Instale a biblioteca de cliente e configure o ambiente de desenvolvimento. Para detalhes, consulte a Visão geral das bibliotecas de cliente do Workflows.

  2. Clone o repositório do app de amostra na máquina local:

    Java

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

    Outra alternativa é fazer o download da amostra como um arquivo ZIP e extraí-lo.

    Node.js

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

    Outra alternativa é fazer o download da amostra como um arquivo ZIP e extraí-lo.

    Python

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

    Outra alternativa é fazer o download da amostra como um arquivo ZIP e extraí-lo.

  3. Altere para o diretório que contém o código de amostra do 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. Confira o código de amostra:

    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
    
    

    O exemplo faz o seguinte:

    1. Configura as bibliotecas de cliente do Cloud para o Workflows.
    2. Executa um fluxo de trabalho.
    3. Pesquisa a execução do fluxo de trabalho (usando a espera exponencial) até que ela seja encerrada.
    4. Exibe os resultados da execução.
  5. Para executar a amostra, primeiro instale as dependências:

    Java

    mvn compile

    Node.js (JavaScript)

    npm install

    Node.js (TypeScript)

    npm install && npm run build

    Python

    pip3 install -r requirements.txt

  6. Execute o 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

    Substitua:

    • PROJECT_ID: (obrigatório) o ID do projeto do Google Cloud
    • CLOUD_REGION: o local do fluxo de trabalho (padrão: us-central1)
    • WORKFLOW_NAME: o ID do fluxo de trabalho (padrão: myFirstWorkflow)

    O resultado será assim:

    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

Para criar uma nova execução usando a revisão mais recente de um determinado fluxo de trabalho, use o método projects.locations.workflows.executions.create.

Para autenticar, você precisará de uma conta de serviço com privilégios suficientes para executar o fluxo de trabalho. Por exemplo, é possível conceder a uma conta de serviço o papel de Invocador do Workflows (roles/workflows.invoker) para que ela tenha permissão para acionar a execução do fluxo de trabalho. Para mais informações, consulte Invocar fluxos de trabalho.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • PROJECT_NUMBER: o número do projeto do Google Cloud listado na página Configurações do IAM e do administrador.
  • LOCATION: a região em que o fluxo de trabalho é implantado, por exemplo, us-central1.
  • WORKFLOW_NAME: o nome definido pelo usuário para o fluxo de trabalho. Por exemplo, myFirstWorkflow.
  • PARAMETER: opcional. Se o fluxo de trabalho que você está executando puder receber argumentos de execução que você transmita como parte de uma solicitação de execução, adicione ao corpo da solicitação uma string formatada em JSON cujo valor seja um ou mais pares de valor-parâmetro de escape, por exemplo, "{\"searchTerm\":\"asia\"}".
  • VALUE: opcional. O valor de um par de parâmetro-valor que o fluxo de trabalho pode receber como um argumento de execução.
  • CALL_LOGGING_LEVEL: opcional. O nível de registro de chamadas a ser aplicado durante a execução. O padrão é que nenhum nível de registro seja especificado e o nível de registro do fluxo de trabalho seja aplicado. Para mais informações, consulte Enviar registros para o Logging. Uma das seguintes opções:
    • CALL_LOG_LEVEL_UNSPECIFIED: nenhum nível de registro foi especificado, e o nível de registro do fluxo de trabalho é aplicado. Esse é o padrão. Caso contrário, o nível de registro de execução é aplicado e tem precedência sobre o nível de registro do fluxo de trabalho.
    • LOG_ERRORS_ONLY: registra todas as exceções identificadas. ou quando uma chamada é interrompida devido a uma exceção.
    • LOG_ALL_CALLS: registra todas as chamadas para subfluxos de trabalho ou funções de biblioteca e os resultados delas.
    • LOG_NONE: nenhum registro de chamadas.
  • BACKLOG_EXECUTION: opcional. Se definido como true, a execução não será acumulada quando a cota de simultaneidade for esgotada. Para mais informações, consulte Gerenciar a defasagem de execução.

Corpo JSON da solicitação:

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

Para enviar a solicitação, expanda uma destas opções:

Se a solicitação for concluída, o corpo da resposta conterá uma instância 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": {}
}

Verificar o status das execuções

Há vários comandos para ajudar você a verificar o status de uma execução de fluxo de trabalho.

  • Para recuperar uma lista das tentativas de execução de um fluxo de trabalho e os respectivos IDs, digite o seguinte comando:

    gcloud workflows executions list WORKFLOW_NAME

    Substitua WORKFLOW_NAME pelo nome do fluxo de trabalho.

    O comando retorna um valor NAME semelhante a este:

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

    Copie o ID de execução para usar no próximo comando.

  • Para verificar o status de uma tentativa de execução e aguardar ela ser concluída, digite o seguinte comando:

    gcloud workflows executions wait EXECUTION_ID

    Substitua EXECUTION_ID pelo ID da tentativa de execução.

    O comando aguarda a conclusão da tentativa de execução e, em seguida, retorna os resultados.

  • Para aguardar a conclusão da última execução e retornar o resultado dela, digite o seguinte comando:

    gcloud workflows executions wait-last

    Se você fez uma tentativa de execução anterior na mesma sessão do gcloud, o comando aguarda a conclusão da tentativa de execução anterior e, em seguida, retorna os resultados da execução concluída. Se não houver nenhuma tentativa anterior, gcloud vai retornar o seguinte erro:

    ERROR: (gcloud.workflows.executions.wait-last) [NOT FOUND] There are no cached executions available.
    
  • Para conferir o status da última execução, digite o seguinte comando:

    gcloud workflows executions describe-last

    Se você fez uma tentativa de execução anterior na mesma sessão de gcloud, o comando retorna os resultados da última execução, mesmo que ela esteja em execução. Se não houver nenhuma tentativa anterior, o gcloud retornará o seguinte erro:

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

Execuções de filtro

É possível aplicar filtros à lista de execuções de fluxo de trabalho retornadas pelo método workflows.executions.list.

É possível filtrar pelos seguintes campos:

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

Por exemplo, para filtrar um rótulo (labels."fruit":"apple"), faça uma solicitação de API semelhante a esta:

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"

Em que:

  • view=full especifica uma visualização que define quais campos devem ser preenchidos nas execuções retornadas. Neste caso, todos os dados
  • labels.%22fruit%22%3A%22apple%22 é a sintaxe do filtro codificado por URL

Para mais informações, consulte Filtragem AIP-160.

Gerenciar a execução de backlogging

É possível usar o backlogging de execução para evitar novas tentativas do lado do cliente, remover atrasos de execução e maximizar a taxa de transferência. As execuções pendentes são executadas automaticamente assim que a cota de simultaneidade de execução fica disponível.

Há um número máximo de execuções de fluxo de trabalho ativas que podem ser executadas simultaneamente. Quando essa cota for esgotada e se a execução de backlogging estiver desativada ou se a cota para execuções em backlogging for atingida, todas as novas execuções vão falhar com um código de status HTTP 429 Too many requests. Com o backlogging de execução ativado, as novas execuções são bem-sucedidas e criadas em um estado QUEUED. Assim que a cota de simultaneidade de execução fica disponível, as execuções são executadas automaticamente e entram em um estado ACTIVE.

Por padrão, o backlogging de execução é ativado para todas as solicitações (incluindo as acionadas pelo Cloud Tasks) com as seguintes exceções:

  • Ao criar uma execução usando um conector executions.run ou executions.create em um fluxo de trabalho, o backlogging de execução é desativado por padrão. É possível configurá-lo definindo explicitamente o campo disableConcurrencyQuotaOverflowBuffering da execução como false.
  • Para execuções acionadas pelo Pub/Sub, o backlogging de execução é desativado e não pode ser configurado.

Observe o seguinte:

  • As execuções em fila são iniciadas em ordem de primeira a chegar, primeira a sair (FIFO, na sigla em inglês), com o melhor esforço possível.
  • Um campo de carimbo de data/hora createTime indica quando uma execução é criada. O carimbo de data/hora startTime indica quando uma execução é aberta automaticamente da fila de pendências e começa a ser executada. Para execuções que não estão em atraso, os dois valores de carimbo de data/hora são idênticos.
  • O limite de execuções pendentes pode ser observado usando a métrica de cota workflowexecutions.googleapis.com/executionbacklogentries. Para mais informações, consulte Conferir e gerenciar cotas.

Desativar o backlogging de execução

É possível desativar o backlogging de execução definindo uma flag ao usar a Google Cloud CLI. Exemplo:

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

Ou desative o acúmulo de execuções definindo o campo disableConcurrencyQuotaOverflowBuffering como true no corpo do JSON de solicitação ao enviar uma solicitação de execução para a API REST do Workflows. Exemplo:

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

Para mais informações, consulte Executar um fluxo de trabalho.

A seguir