Ejecuta un flujo de trabajo

Ejecuta la definición actual del flujo de trabajo asociada con el flujo de trabajo.

Puedes pasar argumentos del entorno de ejecución en una solicitud de ejecución de flujo de trabajo y acceder a esos argumentos con una variable de flujo de trabajo. Para obtener más información, consulta Pasar argumentos del entorno de ejecución en una solicitud de ejecución

Una vez que se completa la ejecución de un flujo de trabajo, su historial y resultados se retienen durante un tiempo limitado. Para obtener más información, consulta Cuotas y límites.

Antes de comenzar

Es posible que las restricciones de seguridad que define tu organización no te permitan completar los siguientes pasos. Para obtener información sobre la solución de problemas, consulta Desarrolla aplicaciones en un entorno de Google Cloud restringido.

1. Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

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

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

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

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

5. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

6. Si un flujo de trabajo accede a otros recursos de Google Cloud, asegúrate de que asociada con una cuenta de servicio que tenga los permisos correctos para hacerlo. Para saber qué cuenta de servicio está asociada con un flujo de trabajo existente, consulta Verifica un la cuenta de servicio asociada del flujo de trabajo.

   Ten en cuenta que, para crear un recurso y conectar una cuenta de servicio, necesitas permisos para crear ese recurso y actuar en nombre de la cuenta de servicio que conectarás al recurso. Para obtener más información, consulta Permisos de la cuenta de servicio.

7. Implementa un flujo de trabajo con la consola de Google Cloud o Google Cloud CLI.

Nota: Para enviar registros a Cloud Logging, asegúrate de que la cuenta de servicio que ejecuta el flujo de trabajo tenga un rol que incluya el permiso logging.logEntries.create (por ejemplo, el rol Logs Writer).

Ejecuta un flujo de trabajo

Puedes ejecutar un flujo de trabajo con las bibliotecas cliente, en la consola de Google Cloud, con la CLI de gcloud o enviando una solicitud a la API de REST de Workflows.

Console

1. Para ejecutar un flujo de trabajo, en la consola de Google Cloud, ve a la página Workflows:

   Ir a Workflows

2. En la página Flujos de trabajo, selecciona un flujo de trabajo para ir a su página de detalles.

3. En la página Detalles del flujo de trabajo, haz clic en Ejecución.

4. En la página Ejecutar flujo de trabajo, en el panel Entrada, puedes ingresar argumentos de entorno de ejecución opcionales para pasarlos a tu flujo de trabajo antes de la ejecución. Los argumentos deben estar en formato JSON, por ejemplo, {"animal":"cat"}. Si tu flujo de trabajo no usa argumentos de tiempo de ejecución, déjalo en blanco.

5. De manera opcional, especifica el nivel de registro de llamadas que deseas aplicar a la ejecución del flujo de trabajo. En la lista Nivel de registro de llamadas, selecciona una de las siguientes opciones:

   • No especificado: No se especifica ningún nivel de registro. Esta es la opción predeterminada. Un nivel de registro de ejecución tiene prioridad sobre cualquier nivel de registro de flujo de trabajo, a menos que no se especifique el nivel de registro de ejecución (predeterminado). En ese caso, se aplica el nivel de registro del flujo de trabajo.
   • Solo errores: Registra todas las excepciones detectadas, o cuando se detiene una llamada debido a una excepción.
   • Todas las llamadas: Registra todas las llamadas a subflujos de trabajo o funciones de biblioteca y sus resultados.
   • Sin registros: Sin registro de llamadas.

6. Haz clic en Ejecutar.

7. En la página Detalles de la ejecución, puedes ver los resultados de la ejecución, incluidos los resultados, el ID y el estado de la ejecución, y el paso actual o final de la ejecución del flujo de trabajo. Para obtener más información, consulta Cómo acceder a los resultados de la ejecución de un flujo de trabajo.

   Nota: Para acceder a la página Detalles de la ejecución, debes tener un rol. que contiene los objetos workflows.workflows.get, workflows.executions.get y workflows.stepEntries.list. Para obtener más información, consulta Los roles de Workflows y permisos y Administra el acceso.

gcloud

1. Abre una terminal.

2. Busca el nombre del flujo de trabajo que deseas ejecutar. Si no conoces el del flujo de trabajo, puedes ingresar el siguiente comando para enumerar todos flujos de trabajo:

   gcloud workflows list

3. Puedes ejecutar el flujo de trabajo usando el comando gcloud workflows run gcloud workflows execute :

   • Ejecuta el flujo de trabajo y espera a que se complete la ejecución:

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

   • Ejecuta el flujo de trabajo sin esperar a que finalice el intento de ejecución:

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

     Reemplaza lo siguiente:

     • WORKFLOW_NAME: Es el nombre del flujo de trabajo.

     • CALL_LOGGING_LEVEL (opcional): Es el nivel de registro de llamadas que se aplicará durante la ejecución. Puede ser una de las siguientes opciones:

       • none: No se especifica ningún nivel de registro. Esta es la opción predeterminada. Un nivel de registro de ejecución tiene prioridad sobre cualquier nivel de registro de flujo de trabajo, a menos que no se especifique el nivel de registro de ejecución (predeterminado). En ese caso, se aplica el nivel de registro del flujo de trabajo.
       • log-errors-only: Registra todas las excepciones detectadas; o cuando se detiene una llamada debido a una excepción.
       • log-all-calls: Registra todas las llamadas a subflujos de trabajo o funciones de biblioteca y sus resultados.
       • log-none: Sin registro de llamadas.

     • DATA (opcional): Argumentos de tiempo de ejecución para tu de Terraform en formato JSON.

4. Si ejecutaste gcloud workflows execute, se muestra el ID único del intento de ejecución del flujo de trabajo y el resultado es similar al siguiente:

    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 ver el estado de la ejecución, ingresa el comando paso anterior.

Si el intento de ejecución se realiza correctamente, el resultado será similar al siguiente: a continuación, con un state que indica el éxito del flujo de trabajo y un status que especifique el paso final del flujo de trabajo de la ejecución.

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 cliente

En los siguientes ejemplos, se supone que ya implementaste un flujo de trabajo, myFirstWorkflow.

1. Instala la biblioteca cliente y configura tu entorno de desarrollo. Para detalles, consulta la Descripción general de las bibliotecas cliente de Workflows.

2. Clona el repositorio de la app de muestra en tu máquina local:

   Java

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

   De manera opcional, puedes descargar la muestra como un archivo zip y extraerla.

   Node.js

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

   De manera opcional, puedes descargar la muestra como un archivo zip y extraerla.

   Python

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

   De manera opcional, puedes descargar la muestra como un archivo zip y extraerla.

3. Ve al directorio que contiene el código de muestra de 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. Ve el código de muestra:

   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
   
   

   En el ejemplo, se hace lo siguiente:

   1. Configura las bibliotecas cliente de Cloud para Workflows.
   2. Ejecuta un flujo de trabajo.
   3. Sondea la ejecución del flujo de trabajo (con una retirada exponencial) hasta que se complete.
   4. Imprime los resultados de la ejecución.

5. Para ejecutar la muestra, primero instala las dependencias:

   Java

   mvn compile

   Node.js (JavaScript)

   npm install

   Node.js (TypeScript)

   npm install && npm run build

   Python

   pip3 install -r requirements.txt

6. Ejecuta la secuencia de comandos:

   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

   Reemplaza lo siguiente:

   • PROJECT_ID (obligatorio): Es el ID del proyecto de la Proyecto de Google Cloud
   • CLOUD_REGION: Es la ubicación del flujo de trabajo. (valor predeterminado: us-central1)
   • WORKFLOW_NAME: Es el ID del flujo de trabajo. (valor predeterminado: myFirstWorkflow)

   El resultado es similar a este:

   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 de REST

Para crear una ejecución nueva con la revisión más reciente de un flujo de trabajo determinado, usa el método projects.locations.workflows.executions.create.

Ten en cuenta que, para autenticarte, necesitarás una cuenta de servicio con privilegios suficientes para ejecutar el flujo de trabajo. Por ejemplo, puedes otorgarle a un servicio cuenta el rol de Invocador de flujos de trabajo (roles/workflows.invoker) para que la cuenta tenga permiso para activar la ejecución del flujo de trabajo. Para obtener más información, consulta Invoca flujos de trabajo.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

• PROJECT_NUMBER: Es el número de tu proyecto de Google Cloud que aparece en la página Configuración de IAM y administración.
• LOCATION: el región en la que se implementa el flujo de trabajo, por ejemplo, us-central1
• WORKFLOW_NAME: Es el nombre definido por el usuario para el flujo de trabajo, por ejemplo, myFirstWorkflow.
• PARAMETER: es opcional. Si el flujo de trabajo que ejecutas pueden recibir argumentos de tiempo de ejecución que pasas como parte de una solicitud de ejecución puedes agregar al cuerpo de la solicitud una cadena con formato JSON cuyo valor sea uno o más caracteres pares parámetro-valor, por ejemplo, "{\"searchTerm\":\"asia\"}".
• VALUE: es opcional. Es el valor de un par clave-valor que tu flujo de trabajo puede recibir como argumento de tiempo de ejecución.
• CALL_LOGGING_LEVEL: es opcional. El nivel de registro de llamadas que se aplicará durante la ejecución. La opción predeterminada es que no se especifique ningún nivel de registro y, en su lugar, se aplique el nivel de registro del flujo de trabajo. Para obtener más información, consulta Envía registros a Logging. Uno de los lo siguiente:
  • CALL_LOG_LEVEL_UNSPECIFIED: No se especifica ningún nivel de registro. se aplica el nivel de registro del flujo de trabajo. Esta es la opción predeterminada. De lo contrario, se aplica el nivel de registro de ejecución y tiene prioridad sobre el nivel de registro de flujo de trabajo.
  • LOG_ERRORS_ONLY: registra todas las excepciones capturadas. o cuando una llamada sea se detuvo debido a una excepción.
  • LOG_ALL_CALLS: Registra todas las llamadas a subflujos de trabajo o funciones de biblioteca. y sus resultados.
  • LOG_NONE: Sin registro de llamadas.
• BACKLOG_EXECUTION: Opcional. Si se configura como true, la ejecución no se acumula cuando la simultaneidad se agote la cuota. Para obtener más información, consulta Administra el backlogging de ejecución.

Cuerpo JSON de la solicitud:

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

Para enviar tu solicitud, expande una de estas opciones:

curl (Linux, macOS o Cloud Shell)

Nota: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login, o a través del uso de Cloud Shell, que accede de forma automática a la CLI de gcloud. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json. Ejecuta el comando siguiente en la terminal para crear o reemplazar este archivo en el directorio actual:

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

Luego, ejecuta el siguiente comando para enviar tu solicitud de 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)

Nota: El siguiente comando supone que accediste a la CLI de gcloud con tu cuenta de usuario mediante la ejecución de gcloud init o gcloud auth login. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json. Ejecuta el comando siguiente en la terminal para crear o reemplazar este archivo en el directorio actual:

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

Luego, ejecuta el siguiente comando para enviar tu solicitud de 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

Explorador de APIs (navegador)

Copia el cuerpo de la solicitud y abre la página de referencia del método. El panel del Explorador de API se abre en la parte derecha de la página. Puedes interactuar con esta herramienta para enviar solicitudes. Pega el cuerpo de la solicitud en esta herramienta, completa cualquier otro campo obligatorio y haz clic en Ejecutar.

Si el proceso se realiza de forma correcta, el cuerpo de la respuesta contiene una instancia recién creada 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": {}
}

Verifica el estado de las ejecuciones

Hay varios comandos para ayudarte a verificar el estado de un flujo de trabajo ejecución.

• Para recuperar una lista de los intentos de ejecución de un flujo de trabajo y sus IDs, ingresa el siguiente comando:

  gcloud workflows executions list WORKFLOW_NAME

  Reemplaza WORKFLOW_NAME por el nombre del flujo de trabajo.

  El comando muestra un valor NAME similar al siguiente:

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

  Copia el ID de ejecución para usarlo en el siguiente comando.

• Para verificar el estado de un intento de ejecución y esperar a que el intento finaliza, ingresa el siguiente comando:

  gcloud workflows executions wait EXECUTION_ID

  Reemplaza EXECUTION_ID por el ID del intento de ejecución.

  El comando espera a que finalice el intento de ejecución y, luego, muestra el resultados.

• Esperar hasta que se complete la última ejecución y, luego, mostrar el resultado del se completó la ejecución, ingresa el siguiente comando:

  gcloud workflows executions wait-last

  Si realizaste un intento de ejecución anterior en la misma sesión de gcloud, el comando espera a que finalice el intento de ejecución anterior y, luego, muestra los resultados de la ejecución completada. Si no existe ningún intento anterior, gcloud muestra el siguiente error:

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

• Para obtener el estado de la última ejecución, ingresa el siguiente comando:

  gcloud workflows executions describe-last

  Si realizaste un intento de ejecución anterior en la misma sesión de gcloud, el muestra los resultados de la última ejecución, incluso si está en ejecución. Si la respuesta es no existe un intento anterior, gcloud muestra el siguiente error:

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

Filtrar ejecuciones

Puedes aplicar filtros a la lista de ejecuciones de flujos de trabajo que muestra el método workflows.executions.list.

Puedes filtrar según los siguientes campos:

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

Por ejemplo, para filtrar según una etiqueta (labels."fruit":"apple"), puedes establecer un Una solicitud a la API similar a la siguiente:

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"

Aquí:

• view=full especifica una vista que define qué campos se deben completar en las ejecuciones que se muestran; en este caso, todos los datos
• labels.%22fruit%22%3A%22apple%22 es la sintaxis del filtro codificada en URL.

Para obtener más información, consulta Filtrado de AIP-160.

Administrar las tareas pendientes de ejecución

Vista previa

Esta función está sujeta a las "Condiciones de las Ofertas de Fase Previa a la DG" de la sección Condiciones Generales del Servicio de las Condiciones Específicas del Servicio. Las funciones de fase previa a la DG están disponibles “tal cual” y podrían tener asistencia limitada. Para obtener más información, consulta las descripciones de la etapa de lanzamiento.

Puedes usar el backlogging de ejecución para evitar los reintentos del cliente, quitar la ejecución las demoras y maximizar la capacidad de procesamiento. Las ejecuciones pendientes se ejecutan automáticamente en cuanto la cuota de simultaneidad de ejecución esté disponible.

Existe una cantidad máxima de flujos de trabajo activos ejecuciones que se pueden ejecutar simultáneamente. Una vez que se agote esta cuota y si se inhabilita el almacenamiento en cola de ejecuciones o si se alcanza la cuota para las ejecuciones en cola, las ejecuciones nuevas fallarán con un código de estado HTTP 429 Too many requests. Con el almacenamiento en cola de ejecuciones habilitado, las ejecuciones nuevas se realizan correctamente y se crean en un estado QUEUED. En cuanto la cuota de simultaneidad de ejecución pasa a ser disponible, las ejecuciones se ejecutan automáticamente y pasan a un estado ACTIVE.

De forma predeterminada, el almacenamiento en cola de ejecución está habilitado para todas las solicitudes (incluidas las que activa Cloud Tasks) con las siguientes excepciones:

• Cuando creas una ejecución con un conector executions.run o executions.create en un flujo de trabajo, el almacenamiento en cola de ejecución se inhabilita de forma predeterminada. Para configurarlo, establece de forma explícita el campo disableConcurrencyQuotaOverflowBuffering de la ejecución en false.
• Para las ejecuciones que activa Pub/Sub, el trabajo pendiente de ejecución es inhabilitado y no se puede configurar.

Ten en cuenta lo siguiente:

• Las ejecuciones en cola se inician en el orden de primero en entrar, primero en salir (FIFO), en un del mejor esfuerzo.
• El campo de marca de tiempo createTime indica cuando se crea una ejecución. La marca de tiempo startTime indica cuándo se quita automáticamente una ejecución de la cola de tareas pendientes y comienza a ejecutarse. Para las ejecuciones que no están pendientes, ambos valores de marca de tiempo son idénticos.
• El límite de las ejecuciones pendientes se puede observar a través del Métrica de cuota de workflowexecutions.googleapis.com/executionbacklogentries. Para obtener más información, consulta Visualiza y administra las cuotas.

Inhabilita el almacenamiento en cola de ejecución

Puedes inhabilitar el almacenamiento en cola de ejecución configurando una marca cuando uses Google Cloud CLI. Por ejemplo:

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

También puedes inhabilitar el trabajo pendiente de ejecución estableciendo la Campo disableConcurrencyQuotaOverflowBuffering como true en el JSON de la solicitud cuando se envía una solicitud de ejecución a la API de REST de Workflows. Por ejemplo:

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

Para obtener más información, consulta Ejecuta un flujo de trabajo.

¿Qué sigue?

• Actualiza un flujo de trabajo existente

• Controla el orden de ejecución en un flujo de trabajo