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 Google Cloud restringido.

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
  2. Install the Google Cloud CLI.

  3. To initialize the gcloud CLI, run the following command: 

    gcloud init

  4. Create or select a Google Cloud project.

    • Create a Google Cloud project:

      gcloud projects create PROJECT_ID

      Replace PROJECT_ID with a name for the Google Cloud project you are creating.

    • Select the Google Cloud project that you created:

      gcloud config set project PROJECT_ID

      Replace PROJECT_ID with your Google Cloud project name.

  5. Make sure that billing is enabled for your Google Cloud project.

  6. Enable the Workflows API: 

    gcloud services enable workflows.googleapis.com

  7. Set up authentication:

    1. Create the service account: 

      gcloud iam service-accounts create SERVICE_ACCOUNT_NAME

      Replace SERVICE_ACCOUNT_NAME with a name for the service account.

    2. Grant the roles/owner IAM role to the service account: 

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

      Replace the following:

      • SERVICE_ACCOUNT_NAME: the name of the service account
      • PROJECT_ID: the project ID where you created the service account
    8.
  8. Install the Google Cloud CLI.

  9. To initialize the gcloud CLI, run the following command: 

    gcloud init

  10. Create or select a Google Cloud project.

    • Create a Google Cloud project:

      gcloud projects create PROJECT_ID

      Replace PROJECT_ID with a name for the Google Cloud project you are creating.

    • Select the Google Cloud project that you created:

      gcloud config set project PROJECT_ID

      Replace PROJECT_ID with your Google Cloud project name.

  11. Make sure that billing is enabled for your Google Cloud project.

  12. Enable the Workflows API: 

    gcloud services enable workflows.googleapis.com

  13. Set up authentication:

    1. Create the service account: 

      gcloud iam service-accounts create SERVICE_ACCOUNT_NAME

      Replace SERVICE_ACCOUNT_NAME with a name for the service account.

    2. Grant the roles/owner IAM role to the service account: 

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

      Replace the following:

      • SERVICE_ACCOUNT_NAME: the name of the service account
      • PROJECT_ID: the project ID where you created the service account
    14.
  14. (Opcional) Para enviar registros a Cloud Logging, otorga el rol 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"

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

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

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, muestra la respuesta de la API.

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

    - getCurrentTime:
    call: http.get
    args:
      url: https://timeapi.io/api/Time/current/zone?timeZone=Europe/Amsterdam
    result: currentTime
- readWikipedia:
    call: http.get
    args:
      url: https://en.wikipedia.org/w/api.php
      query:
        action: opensearch
        search: ${currentTime.body.dayOfWeek}
    result: wikiResult
- returnResult:
    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:

    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:

    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 flujos de trabajo.
    2. Ejecuta un flujo de trabajo.
    3. Sondea la ejecución del flujo de trabajo (con la retirada exponencial) hasta que se complete.
    4. Imprime los resultados de la ejecución.

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

PROJECT = os.getenv("GOOGLE_CLOUD_PROJECT")
LOCATION = os.getenv("LOCATION", "us-central1")
WORKFLOW_ID = os.getenv("WORKFLOW", "myFirstWorkflow")


def execute_workflow(project: str, location: str, workflow: str) -> 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


if __name__ == "__main__":
    assert PROJECT, "'GOOGLE_CLOUD_PROJECT' environment variable not set."
    execute_workflow(PROJECT, LOCATION, WORKFLOW_ID)

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 asociada con el flujo de trabajo.

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

    Java 

    mvn compile

    Node.js 

    npm install -D tsx

    Python 

    pip3 install -r requirements.txt

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

    npx tsx index.js

    Python 

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

    Reemplaza lo siguiente:

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

    El resultado es similar a este:

    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 del entorno de ejecución en una solicitud de ejecución. Por ejemplo:

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;

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.

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que se usaron 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 borrará el flujo de trabajo.

¿Qué sigue?