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 acessar esses argumentos 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. Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.
  2. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar o seletor de projetos

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

  4. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar o seletor de projetos

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

  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 saber qual conta de serviço está associada a um fluxo de trabalho, consulte Verificar a conta de serviço associada a um fluxo de trabalho.

    Para criar um recurso e anexar uma conta de serviço, é necessário permissões para criar esse recurso e personificar a conta de serviço que vai ser anexada ao recurso. Para mais informações, consulte Permissões da conta de serviço.

  7. Implantar 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 no console do Google Cloud, usando a CLI gcloud ou enviando uma solicitação para a API REST do Workflows.

Bibliotecas de cliente

As amostras 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 espera exponencial) até que ela seja finalizada.
    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)"]
    

Console

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

    Acessar fluxos de trabalho

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

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

  7. Na página Detalhes da execução, é possível ver 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 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. Há duas maneiras de executar o fluxo de trabalho:

    • 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 geração de registros 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 for bem-sucedida, a saída será semelhante à a seguir, com um state indicando o sucesso do fluxo de trabalho e um status que especifica a etapa final do fluxo de trabalho.

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

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 fluxo de trabalho (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, faça as substituições a seguir:

  • PROJECT_NUMBER: o número do projeto do Google Cloud listado na página Configurações de IAM e administrador.
  • LOCATION: a região em que o fluxo de trabalho é implantado, por exemplo, us-central1.
  • WORKFLOW_ID: 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 do ambiente de execução que ele é transmitido como parte de uma solicitação de execução, adicione ao corpo da solicitação uma string formatada em JSON cujo valor é um ou mais pares de parâmetro/valor com escape, por exemplo, "{\"searchTerm\":\"asia\"}".
  • VALUE: opcional. O valor de um par de parâmetro/valor que seu fluxo de trabalho pode receber como argumento de ambiente 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 geração de registros seja especificado, mas 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 geração de registros é 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 será aplicado e terá precedência sobre o nível de registro do fluxo de trabalho.
    • LOG_ERRORS_ONLY: registra todas as exceções capturadas 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.

Solicitar corpo JSON:

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

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

Se bem-sucedido, o corpo da resposta vai ter uma instância recém-criada de Execution:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION/workflows/WORKFLOW_ID/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 aguardar até que a última execução seja concluída e retornar o resultado dela, insira o seguinte comando:

    gcloud workflows executions wait-last
    

    Se você fez uma tentativa de execução anterior na mesma sessão gcloud, o comando aguardará a conclusão dessa tentativa e retornará os resultados da execução concluída. Se não houver uma tentativa anterior, gcloud retornará o seguinte erro:

    ERROR: (gcloud.workflows.executions.wait-last) [NOT FOUND] There are no cached executions available.
    
  • Para ver 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 gcloud, o comando retornará 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.
    

A seguir