Ejecuta un flujo de trabajo con las bibliotecas cliente de Cloud

Ejecuta un flujo de trabajo con las bibliotecas cliente de Cloud

En esta guía de inicio rápido, se muestra cómo ejecutar un flujo de trabajo y ver los resultados de la ejecución con las bibliotecas cliente de Cloud.

Para obtener más información sobre cómo instalar las bibliotecas cliente de Cloud y configurar tu entorno de desarrollo, consulta la descripción general de las bibliotecas cliente de Workflows.

Puedes completar los siguientes pasos con Google Cloud CLI en la terminal o en Cloud Shell.

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.

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.

Instala Google Cloud CLI.

Si usas un proveedor de identidad externo (IdP), primero debes acceder a la gcloud CLI con tu identidad federada.

Para inicializar gcloud CLI, ejecuta el siguiente comando:

gcloud init

Crea o selecciona un Google Cloud proyecto.

Roles necesarios para seleccionar o crear un proyecto

• Selecciona un proyecto: Para seleccionar un proyecto, no se requiere un rol de IAM específico. Puedes seleccionar cualquier proyecto en el que se te haya otorgado un rol.
• Crear un proyecto: Para crear un proyecto, necesitas el rol de Creador de proyectos (roles/resourcemanager.projectCreator), que contiene el permiso resourcemanager.projects.create. Obtén más información para otorgar roles.

Nota: Si no planeas conservar los recursos que creaste durante este procedimiento, crea un proyecto en lugar de seleccionar uno existente. Cuando termines, puedes borrar el proyecto y quitar todos los recursos asociados con él.

• Crea un proyecto de Google Cloud :

  gcloud projects create PROJECT_ID

  Reemplaza PROJECT_ID por un nombre para el proyecto Google Cloud que estás creando.

• Selecciona el proyecto Google Cloud que creaste:

  gcloud config set project PROJECT_ID

  Reemplaza PROJECT_ID por el nombre de tu Google Cloud proyecto.

Si usas un proyecto existente en esta guía, verifica que tengas los permisos necesarios para completarla. Si creaste un proyecto nuevo, ya tienes los permisos necesarios.

Verifica que la facturación esté habilitada para tu proyecto de Google Cloud .

Habilita la API de Workflows:

Roles necesarios para habilitar las APIs

Para habilitar las APIs, necesitas el rol de IAM de administrador de Service Usage (roles/serviceusage.serviceUsageAdmin), que contiene el permiso serviceusage.services.enable. Obtén más información para otorgar roles.

gcloud services enable workflows.googleapis.com

Instala Google Cloud CLI.

Si usas un proveedor de identidad externo (IdP), primero debes acceder a la gcloud CLI con tu identidad federada.

Para inicializar gcloud CLI, ejecuta el siguiente comando:

gcloud init

Crea o selecciona un Google Cloud proyecto.

Roles necesarios para seleccionar o crear un proyecto

• Selecciona un proyecto: Para seleccionar un proyecto, no se requiere un rol de IAM específico. Puedes seleccionar cualquier proyecto en el que se te haya otorgado un rol.
• Crear un proyecto: Para crear un proyecto, necesitas el rol de Creador de proyectos (roles/resourcemanager.projectCreator), que contiene el permiso resourcemanager.projects.create. Obtén más información para otorgar roles.

Nota: Si no planeas conservar los recursos que creaste durante este procedimiento, crea un proyecto en lugar de seleccionar uno existente. Cuando termines, puedes borrar el proyecto y quitar todos los recursos asociados con él.

• Crea un proyecto de Google Cloud :

  gcloud projects create PROJECT_ID

  Reemplaza PROJECT_ID por un nombre para el proyecto Google Cloud que estás creando.

• Selecciona el proyecto Google Cloud que creaste:

  gcloud config set project PROJECT_ID

  Reemplaza PROJECT_ID por el nombre de tu Google Cloud proyecto.

Si usas un proyecto existente en esta guía, verifica que tengas los permisos necesarios para completarla. Si creaste un proyecto nuevo, ya tienes los permisos necesarios.

Verifica que la facturación esté habilitada para tu proyecto de Google Cloud .

Habilita la API de Workflows:

Roles necesarios para habilitar las APIs

Para habilitar las APIs, necesitas el rol de IAM de administrador de Service Usage (roles/serviceusage.serviceUsageAdmin), que contiene el permiso serviceusage.services.enable. Obtén más información para otorgar roles.

gcloud services enable workflows.googleapis.com

1. Configura la autenticación:

   1. Asegúrate de tener los roles de IAM de creador de cuentas de servicio (roles/iam.serviceAccountCreator) y administrador de IAM del proyecto (roles/resourcemanager.projectIamAdmin). Obtén más información para otorgar roles.

   2. Crea la cuenta de servicio:

      gcloud iam service-accounts create SERVICE_ACCOUNT_NAME

      Reemplaza SERVICE_ACCOUNT_NAME por un nombre para la cuenta de servicio.

   3. Otorga el rol de IAM roles/logging.logWriter a la cuenta de servicio.

      gcloud projects add-iam-policy-binding PROJECT_ID --member="serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com" --role=roles/logging.logWriter

      Reemplaza lo siguiente:

      • SERVICE_ACCOUNT_NAME: el nombre de la cuenta de servicio
      • PROJECT_ID: el ID del proyecto en el que creaste la cuenta de servicio
      Nota: La marca --role afecta a qué recursos puede acceder la cuenta de servicio en tu proyecto. Puedes revocar estas funciones o asignar otras más adelante.

Para obtener más información sobre los roles y permisos de las cuentas de servicio, consulta Cómo otorgar permiso a un flujo de trabajo para acceder a recursos deGoogle Cloud .

2. Si es necesario, descarga e instala la herramienta de administración de código fuente de Git.

Roles obligatorios

Si quieres obtener los permisos que necesitas para completar esta guía de inicio rápido, pídele a tu administrador que te otorgue los siguientes roles de IAM en tu proyecto:

• Usuario de la cuenta de servicio (roles/iam.serviceAccountUser)
• Administrador de Workflows (roles/workflows.admin)

Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios a través de roles personalizados o cualquier otro rol predefinido.

Implementa un flujo de trabajo de muestra

Después de definir un flujo de trabajo, debes implementarlo para que esté disponible para su ejecución. El paso de implementación también valida que se pueda ejecutar el archivo de origen.

El siguiente flujo de trabajo envía una solicitud a una API pública y, luego, devuelve la respuesta de la API.

1. Crea un archivo de texto con el nombre myFirstWorkflow.yaml que incluya el siguiente contenido:

   # This workflow accepts an optional "searchTerm" argument for the Wikipedia API.
   # If no input arguments are provided or "searchTerm" is absent,
   # it will fetch the day of the week in Amsterdam and use it as the search term.
   
   main:
       params: [input]
       steps:
       - validateSearchTermAndRedirectToReadWikipedia:
           switch:
               - condition: '${map.get(input, "searchTerm") != null}'
                 assign:
                   - searchTerm: '${input.searchTerm}'
                 next: readWikipedia
       - getCurrentTime:
           call: http.get
           args:
               url: https://timeapi.io/api/Time/current/zone?timeZone=Europe/Amsterdam
           result: currentTime
       - setFromCallResult:
           assign:
               - searchTerm: '${currentTime.body.dayOfWeek}'
       - readWikipedia:
           call: http.get
           args:
               url: 'https://en.wikipedia.org/w/api.php'
               query:
                   action: opensearch
                   search: '${searchTerm}'
           result: wikiResult
       - returnOutput:
               return: '${wikiResult.body[1]}'

2. Después de crear el flujo de trabajo, puedes implementarlo, pero no lo ejecutes:

   gcloud workflows deploy myFirstWorkflow \
       --source=myFirstWorkflow.yaml \
       --service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
       --location=CLOUD_REGION

   Reemplaza CLOUD_REGION por una ubicación compatible para el flujo de trabajo. La región predeterminada que se usa en las muestras de código es us-central1.

Obtén el código de muestra

Puedes clonar el código de muestra desde GitHub.

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

   C#

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

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

   Go

   git clone https://github.com/GoogleCloudPlatform/golang-samples.git

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

   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.

2. Ve al directorio que contiene el código de muestra de Workflows:

   C#

   cd dotnet-docs-samples/workflows/api/Workflow.Samples/

   Go

   cd golang-samples/workflows/executions/

   Java

   cd java-docs-samples/workflows/cloud-client/

   Node.js

   cd nodejs-docs-samples/workflows/quickstart/

   Python

   cd python-docs-samples/workflows/cloud-client/

3. Ve el código de muestra. Cada app de ejemplo 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 retirada exponencial) hasta que finaliza la ejecución.
   4. Imprime los resultados de la ejecución.

   C#

   
   using Google.Cloud.Workflows.Common.V1;
   using Google.Cloud.Workflows.Executions.V1;
   using System;
   using System.Threading;
   using System.Threading.Tasks;
   
   public class ExecuteWorkflowSample
   {
       /// <summary>
       /// Execute a workflow and return the execution operation.
       /// </summary>
       /// <param name="projectID">Your Google Cloud Project ID.</param>
       /// <param name="locationID">The region where your workflow is located.</param>
       /// <param name="workflowID">Your Workflow ID.</param>
       /// <returns>
       /// An Execute object representing the completed workflow execution.
       /// </returns>
       public async Task<Execution> ExecuteWorkflow(
           string projectId = "YOUR-PROJECT-ID",
           string locationID = "YOUR-LOCATION-ID",
           string workflowID = "YOUR-WORKFLOW-ID")
       {
           // Initialize the client.
           ExecutionsClient client = await ExecutionsClient.CreateAsync();
   
           // Build the parent location path.
           WorkflowName parent = new WorkflowName(projectId, locationID, workflowID);
   
           // Create an execution request.
           CreateExecutionRequest createExecutionRequest = new CreateExecutionRequest
           {
               ParentAsWorkflowName = parent,
           };
   
           // Execute the operation.
           Execution execution = await client.CreateExecutionAsync(createExecutionRequest);
           Console.WriteLine("- Execution started...");
   
           TimeSpan backoffDelay = TimeSpan.FromSeconds(1);
           TimeSpan maxBackoffDelay = TimeSpan.FromSeconds(16);
   
           // Keep polling the state until the execution finishes, using exponential backoff.
           while (execution.State == Execution.Types.State.Active)
           {
               await Task.Delay(backoffDelay);
   
               // Implement exponential backoff by doubling the delay, but limiting it to a practical duration.
               backoffDelay = (backoffDelay < maxBackoffDelay) ? backoffDelay * 2 : maxBackoffDelay;
   
               execution = await client.GetExecutionAsync(execution.Name);
           }
   
           // Print results.
           Console.WriteLine($"Execution finished with state: {execution.State}");
           Console.WriteLine($"Execution results: {execution.Result}");
   
           // Return the fetched execution.
           return execution;
       }
   }

   Go

   import (
   	"context"
   	"fmt"
   	"io"
   	"time"
   
   	workflowexecutions "google.golang.org/api/workflowexecutions/v1"
   )
   
   // Execute a workflow and print the execution results.
   //
   // For more information about Workflows see:
   // https://cloud.google.com/workflows/docs/overview
   func executeWorkflow(w io.Writer, projectID, workflowID, locationID string) error {
   	// TODO(developer): Uncomment and update the following lines:
   	// projectID := "YOUR_PROJECT_ID"
   	// workflowID := "YOUR_WORKFLOW_ID"
   	// locationID := "YOUR_LOCATION_ID"
   
   	ctx := context.Background()
   
   	// Construct the location path.
   	parent := fmt.Sprintf("projects/%s/locations/%s/workflows/%s", projectID, locationID, workflowID)
   
   	// Create execution client.
   	client, err := workflowexecutions.NewService(ctx)
   	if err != nil {
   		return fmt.Errorf("workflowexecutions.NewService error: %w", err)
   	}
   
   	// Get execution service.
   	service := client.Projects.Locations.Workflows.Executions
   
   	// Build and run the new workflow execution.
   	res, err := service.Create(parent, &workflowexecutions.Execution{}).Do()
   	if err != nil {
   		return fmt.Errorf("service.Create.Do error: %w", err)
   	}
   	fmt.Fprintln(w, "- Execution started...")
   
   	// Set initial value for backoff delay in one second.
   	backoffDelay := time.Second
   
   	for res.State == "ACTIVE" {
   		time.Sleep(backoffDelay)
   
   		// Request the updated state for the execution.
   		getReq := service.Get(res.Name)
   		res, err = getReq.Do()
   		if err != nil {
   			return fmt.Errorf("getReq error: %w", err)
   		}
   
   		// Double the delay to provide exponential backoff (capped at 16 seconds).
   		if backoffDelay < time.Second*16 {
   			backoffDelay *= 2
   		}
   	}
   
   	fmt.Fprintf(w, "Execution finished with state: %s\n", res.State)
   	fmt.Fprintf(w, "Execution results: %s\n", res.Result)
   
   	return nil
   }
   

   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

   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;
   });
   

   Python

   import time
   
   from google.cloud import workflows_v1
   from google.cloud.workflows import executions_v1
   
   from google.cloud.workflows.executions_v1.types import executions
   
   # TODO(developer): Update and uncomment the following lines.
   # project_id = "YOUR_PROJECT_ID"
   # location = "YOUR_LOCATION"  # For example: us-central1
   # workflow_id = "YOUR_WORKFLOW_ID"  # For example: myFirstWorkflow
   
   # Initialize API clients.
   execution_client = executions_v1.ExecutionsClient()
   workflows_client = workflows_v1.WorkflowsClient()
   
   # Construct the fully qualified location path.
   parent = workflows_client.workflow_path(project_id, location, workflow_id)
   
   # 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...")
   
   # Keep polling the state until the execution finishes,
   # using exponential backoff.
   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, keep waiting.
       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}")

Ejecuta el código de muestra

Puedes ejecutar el código de muestra y ejecutar tu flujo de trabajo. Ejecuta la definición del flujo de trabajo implementado asociado con el flujo de trabajo.

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

   C#

   dotnet restore

   Go

   go mod download

   Java

   mvn compile

   Node.js

   npm install -D tsx

   Python

   pip3 install -r requirements.txt

2. Ejecuta la secuencia de comandos:

   C#

   GOOGLE_CLOUD_PROJECT=PROJECT_ID LOCATION=CLOUD_REGION WORKFLOW=WORKFLOW_NAME dotnet run

   Go

   GOOGLE_CLOUD_PROJECT=PROJECT_ID LOCATION=CLOUD_REGION WORKFLOW=WORKFLOW_NAME go run .

   Java

   GOOGLE_CLOUD_PROJECT=PROJECT_ID LOCATION=CLOUD_REGION WORKFLOW=WORKFLOW_NAME mvn compile exec:java -Dexec.mainClass=com.example.workflows.WorkflowsQuickstart

   Node.js

   npx tsx index.js

   Python

   GOOGLE_CLOUD_PROJECT=PROJECT_ID LOCATION=CLOUD_REGION WORKFLOW=WORKFLOW_NAME python3 main.py

   Reemplaza lo siguiente:

   • PROJECT_ID: El nombre de tu proyecto de Google Cloud
   • CLOUD_REGION: Es la ubicación de tu flujo de trabajo (el valor predeterminado es us-central1).
   • WORKFLOW_NAME: El nombre de tu flujo de trabajo (el valor predeterminado es myFirstWorkflow).

   El resultado es similar a lo siguiente:

   Execution finished with state: SUCCEEDED
   Execution results: ["Thursday","Thursday Night Football","Thursday (band)","Thursday Island","Thursday (album)","Thursday Next","Thursday at the Square","Thursday's Child (David Bowie song)","Thursday Afternoon","Thursday (film)"]
   

Cómo pasar datos en una solicitud de ejecución

Según el lenguaje de la biblioteca cliente, también puedes pasar un argumento de tiempo de ejecución en una solicitud de ejecución. Por ejemplo:

C#

public class ExecuteWorkflowWithArgumentsSample
{
    /// <summary>
    /// Execute a workflow with arguments and return the execution operation.
    /// </summary>
    /// <param name="projectID">Your Google Cloud Project ID.</param>
    /// <param name="locationID">The region where your workflow is located.</param>
    /// <param name="workflowID">Your Workflow ID.</param>
    /// <returns>
    /// An Execute object representing the completed workflow execution.
    /// </returns>
    public async Task<Execution> ExecuteWorkflowWithArguments(
        string projectId = "YOUR-PROJECT-ID",
        string locationID = "YOUR-LOCATION-ID",
        string workflowID = "YOUR-WORKFLOW-ID")
    {
        // Initialize the client.
        ExecutionsClient client = await ExecutionsClient.CreateAsync();

        // Build the parent location path.
        WorkflowName parent = new WorkflowName(projectId, locationID, workflowID);

        // Serialize the argument.
        string argument = JsonSerializer.Serialize(new
        {
            searchTerm = "Cloud"
        });

        // Create an execution request.
        CreateExecutionRequest createExecutionRequest = new CreateExecutionRequest
        {
            ParentAsWorkflowName = parent,
            Execution = new Execution
            {
                Argument = argument,
            }
        };

        // Execute the operation and recieve the execution.
        Execution execution = await client.CreateExecutionAsync(createExecutionRequest);
        Console.WriteLine("- Execution started...");

        TimeSpan backoffDelay = TimeSpan.FromSeconds(1);
        TimeSpan maxBackoffDelay = TimeSpan.FromSeconds(16);

        // Keep polling the state until the execution finishes, using exponential backoff.
        while (execution.State == Execution.Types.State.Active)
        {
            await Task.Delay(backoffDelay);

            // Implement exponential backoff by doubling the delay, but limiting it to a practical duration.
            backoffDelay = (backoffDelay < maxBackoffDelay) ? backoffDelay * 2 : maxBackoffDelay;

            execution = await client.GetExecutionAsync(execution.Name);
        }

        // Print results.
        Console.WriteLine($"Execution finished with state: {execution.State}");
        Console.WriteLine($"Execution results: {execution.Result}");

        // Return the fetched execution.
        return execution;
    }
}

Go

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"time"

	workflowexecutions "google.golang.org/api/workflowexecutions/v1"
)

// Execute a workflow with arguments and print the execution results.
//
// For more information about Workflows see:
// https://cloud.google.com/workflows/docs/overview
func executeWorkflowWithArguments(w io.Writer, projectID, workflowID, locationID string) error {
	// TODO(developer): Uncomment and update the following lines:
	// projectID := "YOUR_PROJECT_ID"
	// workflowID := "YOUR_WORKFLOW_ID"
	// locationID := "YOUR_LOCATION_ID"

	ctx := context.Background()

	// Construct the location path.
	parent := fmt.Sprintf("projects/%s/locations/%s/workflows/%s", projectID, locationID, workflowID)

	// Create execution client.
	client, err := workflowexecutions.NewService(ctx)
	if err != nil {
		return fmt.Errorf("workflowexecutions.NewService error: %w", err)
	}

	// Get execution service.
	service := client.Projects.Locations.Workflows.Executions

	// Create argument.
	argument := struct {
		SearchTerm string `json:"searchTerm"`
	}{
		SearchTerm: "Cloud",
	}

	// Encode argument to JSON.
	argumentEncoded, err := json.Marshal(argument)
	if err != nil {
		return fmt.Errorf("json.Marshal error: %w", err)
	}

	// Build and run the new workflow execution adding the argument.
	res, err := service.Create(parent, &workflowexecutions.Execution{
		Argument: string(argumentEncoded),
	}).Do()
	if err != nil {
		return fmt.Errorf("service.Create.Do error: %w", err)
	}
	fmt.Fprintln(w, "- Execution started...")

	// Set initial value for backoff delay in one second.
	backoffDelay := time.Second

	for res.State == "ACTIVE" {
		time.Sleep(backoffDelay)

		// Request the updated state for the execution.
		getReq := service.Get(res.Name)
		res, err = getReq.Do()
		if err != nil {
			return fmt.Errorf("getReq error: %w", err)
		}

		// Double the delay to provide exponential backoff (capped at 16 seconds).
		if backoffDelay < time.Second*16 {
			backoffDelay *= 2
		}
	}

	fmt.Fprintf(w, "Execution finished with state: %s\n", res.State)
	fmt.Fprintf(w, "Execution arguments: %s", res.Argument)
	fmt.Fprintf(w, "Execution results: %s\n", res.Result)

	return nil
}

Java

// Creates the execution object
CreateExecutionRequest request =
    CreateExecutionRequest.newBuilder()
        .setParent(parent.toString())
        .setExecution(Execution.newBuilder().setArgument("{\"searchTerm\":\"Friday\"}").build())
        .build();

Node.js

// Execute workflow
try {
  const createExecutionRes = await client.createExecution({
    parent: client.workflowPath(projectId, location, workflow),
    execution: {
      argument: JSON.stringify({"searchTerm": "Friday"})
    }
});
const executionName = createExecutionRes[0].name;

Python

import time

from google.cloud import workflows_v1
from google.cloud.workflows import executions_v1

from google.cloud.workflows.executions_v1.types import executions

# TODO(developer): Update and uncomment the following lines.
# project_id = "YOUR_PROJECT_ID"
# location = "YOUR_LOCATION"  # For example: us-central1
# workflow_id = "YOUR_WORKFLOW_ID"  # For example: myFirstWorkflow

# Initialize API clients.
execution_client = executions_v1.ExecutionsClient()
workflows_client = workflows_v1.WorkflowsClient()

# Construct the fully qualified location path.
parent = workflows_client.workflow_path(project_id, location, workflow_id)

# Execute the workflow adding an dictionary of arguments.
# Find more information about the Execution object here:
# https://cloud.google.com/python/docs/reference/workflows/latest/google.cloud.workflows.executions_v1.types.Execution
execution = executions_v1.Execution(
    name=parent,
    argument='{"searchTerm": "Cloud"}',
)

response = execution_client.create_execution(
    parent=parent,
    execution=execution,
)
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...")

# Keep polling the state until the execution finishes,
# using exponential backoff.
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, keep waiting.
    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}")

Para obtener más información sobre cómo pasar argumentos del entorno de ejecución, consulta Cómo pasar argumentos del entorno de ejecución en una solicitud de ejecución.

Realiza una limpieza

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en esta página, borra el proyecto de Google Cloud que tiene los recursos.

1. Borra el flujo de trabajo que creaste:

   gcloud workflows delete myFirstWorkflow
   

2. Cuando se te pregunte si deseas continuar, ingresa y.

Se borró el flujo de trabajo.

¿Qué sigue?

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

• Actualiza un flujo de trabajo existente

• Flujos de trabajo de ejemplo

• Referencia de la sintaxis de Workflows