Executar um fluxo de trabalho

Console

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

   Acessar fluxos de trabalho

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

3. Na página Detalhes do fluxo de trabalho, clique em play_arrow 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 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.

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á implantou 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 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:

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

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"

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

$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

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