Esta página foi traduzida pela API Cloud Translation.

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.

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.

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

Go to project selector

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

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

Go to project selector

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

Se um fluxo de trabalho acessar outros recursos do Google Cloud, associadas 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 Confirme um da conta de serviço associada ao 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.
Implante um fluxo de trabalho usando a Console do Google Cloud ou a Google Cloud CLI.

Observação: para enviar registros ao Cloud Logging, verifique se a conta de serviço que executa o fluxo de trabalho recebeu um papel que inclua a permissão logging.logEntries.create, como o Logs Writer.

Executar um fluxo de trabalho

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

Console

Para executar um fluxo de trabalho, no console do Google Cloud, acesse Página Fluxos de trabalho:

Acessar fluxos de trabalho
Na página Fluxos de trabalho, selecione um fluxo de trabalho para acessar o respectivo página de detalhes.
Na página Detalhes do fluxo de trabalho, clique em Executar.
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.
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.
Clique em Executar.
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.

Observação:para acessar a página Detalhes da execução, você precisa ter uma função que contém workflows.workflows.get, workflows.executions.get e workflows.stepEntries.list. Para mais informações, consulte Papéis do Workflows e permissões e Gerencie o acesso.

gcloud

Abra um terminal.
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
```
É possível executar o fluxo de trabalho usando o o comando gcloud workflows run ou o gcloud workflows execute comando:
- 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 para aplicar 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.
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á implantou um fluxo de trabalho, myFirstWorkflow:

Instale a biblioteca de cliente e configure o ambiente de desenvolvimento. Para detalhes, consulte a Visão geral das bibliotecas de cliente do Workflows.
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.

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/

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:

Configura as bibliotecas de cliente do Cloud para o Workflows.
Executa um fluxo de trabalho.
Pesquisa a execução do fluxo de trabalho (usando a espera exponencial) até que ela seja encerrada.
Exibe os resultados da execução.

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
```

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 fazer a autenticação, você precisará de uma conta de serviço com para executar o fluxo de trabalho. Por exemplo, você pode 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: seu Google Cloud de projeto listado no guia de gerenciamento Administrador Configurações.
LOCATION: o 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 será 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.
- 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 o backlogging 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:

curl (Linux, macOS ou Cloud Shell)

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que faz login automaticamente na CLI gcloud. . É possível verificar a conta ativa atual executando gcloud auth list.

Salve o corpo da solicitação em um arquivo chamado request.json. Execute o comando a seguir no terminal para criar ou substituir esse arquivo no diretório atual:

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

Depois execute o comando a seguir para enviar a solicitação 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)

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login . É possível verificar a conta ativa atual executando gcloud auth list.

Salve o corpo da solicitação em um arquivo chamado request.json. Execute o comando a seguir no terminal para criar ou substituir esse arquivo no diretório atual:

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

Depois execute o comando a seguir para enviar a solicitação 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

APIs Explorer (navegador)

Copie o corpo da solicitação e abra a página de referência do método. O painel "APIs Explorer" é aberto no lado direito da página. Interaja com essa ferramenta para enviar solicitações. Cole o corpo da solicitação nessa ferramenta, preencha todos os outros campos obrigatórios e clique em Executar.

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 ao seguinte:

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 esperar até que a última execução seja concluída e, em seguida, retornar o resultado do concluída, insira 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 obter o status da última execução, insira 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 precisam ser preenchidos nas execuções retornadas. Nesse caso, todos os dados
labels.%22fruit%22%3A%22apple%22 é a sintaxe do filtro codificado pelo URL

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

Gerenciar o backlogging de execução

É 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. Execuções programadas são executadas automaticamente assim que possível conforme a cota de simultaneidade de execução é disponibilizada.

Há um número máximo de fluxos de trabalho ativos que podem ser executadas simultaneamente. Depois que essa cota se esgotar, e se o backlogging de execução estiver desativado ou se a cota para execuções acumuladas for atingido, todas as novas execuções falharão com um status HTTP 429 Too many requests o código-fonte. 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 se tornar 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 registro de execução é desativado e não pode ser configurado.

Observe o seguinte:

As execuções em fila são iniciadas em uma ordem FIFO (first-in-first-out), em uma com base no melhor esforço.
Um campo de carimbo de data/hora createTime indica quando uma execução é criada. O O carimbo de data/hora startTime indica quando uma execução é retirada automaticamente na fila do backlog e começa a ser executado. 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 Para mais informações, acesse Ver e gerenciar cotas.

Desativar a defasagem de execução

É possível desativar o backlogging de execução definindo uma flag ao usar a CLI do Google Cloud. 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 da 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.

Executar um fluxo de trabalho

Antes de começar

Executar um fluxo de trabalho

Console

gcloud

Bibliotecas de cliente

Java

Node.js

Python

Java

Node.js

Python

Java

Node.js (JavaScript)

Node.js (TypeScript)

Python

Java

Node.js (JavaScript)

Node.js (TypeScript)

Python

Java

Node.js (JavaScript)

Node.js (TypeScript)

Python

API REST

curl (Linux, macOS ou Cloud Shell)

PowerShell (Windows)

APIs Explorer (navegador)

Verificar o status das execuções

Execuções de filtro

Gerenciar o backlogging de execução

Desativar a defasagem de execução

A seguir