Esta página se ha traducido con Cloud Translation API.

Usar flujos de trabajo para conectar servicios

En este tutorial se explica cómo usar Workflows para vincular una serie de servicios. Si conectas dos servicios HTTP públicos mediante funciones de Cloud Run, una API REST externa y un servicio de Cloud Run privado, puedes crear una aplicación flexible y sin servidor.

Objetivos

En este tutorial, usará Google Cloud CLI para crear un solo flujo de trabajo y conectar un servicio cada vez:

Despliega dos funciones de Cloud Run: la primera genera un número aleatorio y, a continuación, lo pasa a la segunda función, que lo multiplica.
Conecta las dos funciones HTTP mediante Workflows. Ejecuta el flujo de trabajo y devuelve un resultado que se envía a una API externa.
Con Workflows, conecta una API HTTP externa que devuelva el log de un número determinado. Ejecuta el flujo de trabajo y devuelve un resultado que se transfiere a un servicio de Cloud Run.
Despliega un servicio de Cloud Run que solo permita el acceso autenticado. El servicio devuelve el math.floor de un número determinado.
Con Workflows, conecta el servicio de Cloud Run, ejecuta todo el flujo de trabajo y devuelve un resultado final.

En el siguiente diagrama se muestra un resumen del proceso y una visualización del flujo de trabajo final:

Costes

En este documento, se utilizan los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costes basada en el uso previsto, utiliza la calculadora de precios.

Los usuarios nuevos Google Cloud pueden disfrutar de una prueba gratuita.

Antes de empezar

Es posible que las restricciones de seguridad definidas por tu organización te impidan completar los siguientes pasos. Para obtener información sobre cómo solucionar problemas, consulta el artículo Desarrollar aplicaciones en un entorno limitado Google Cloud .

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.

Install the Google Cloud CLI.

Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

Para inicializar gcloud CLI, ejecuta el siguiente comando:

gcloud init

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.

Verify that billing is enabled for your Google Cloud project.

Enable the Artifact Registry, Cloud Build, Cloud Run, Cloud Run functions, Cloud Storage, and Workflows APIs:

gcloud services enable artifactregistry.googleapis.com cloudbuild.googleapis.com run.googleapis.com cloudfunctions.googleapis.com storage.googleapis.com workflows.googleapis.com

Install the Google Cloud CLI.

Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

Para inicializar gcloud CLI, ejecuta el siguiente comando:

gcloud init

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.

Verify that billing is enabled for your Google Cloud project.

Enable the Artifact Registry, Cloud Build, Cloud Run, Cloud Run functions, Cloud Storage, and Workflows APIs:

gcloud services enable artifactregistry.googleapis.com cloudbuild.googleapis.com run.googleapis.com cloudfunctions.googleapis.com storage.googleapis.com workflows.googleapis.com

Actualiza los componentes de Google Cloud CLI:
```
gcloud components update
```

Si ejecutas comandos en Cloud Shell, ya te has autenticado con gcloud CLI. De lo contrario, inicia sesión con tu cuenta:
```
gcloud auth login
```

Define la ubicación predeterminada que se usará en este tutorial:

gcloud config set project PROJECT_ID
export REGION=REGION
gcloud config set functions/region ${REGION}
gcloud config set run/region ${REGION}
gcloud config set workflows/location ${REGION}

Sustituye REGION por la ubicación de Workflows admitida que quieras.

Si has creado el proyecto, se te asignará el rol básico Propietario (roles/owner). De forma predeterminada, este rol de gestión de identidades y accesos (IAM) incluye los permisos necesarios para acceder por completo a la mayoría de los recursos Google Cloud, por lo que puedes saltarte este paso.

Si no eres el creador del proyecto, debes conceder los permisos necesarios al principal correspondiente. Por ejemplo, un principal puede ser una cuenta de Google (para usuarios finales) o una cuenta de servicio (para aplicaciones y cargas de trabajo de computación). Para obtener más información, consulta la página Roles y permisos de tu destino de evento.
Permisos obligatorios

Para obtener los permisos que necesitas para completar el tutorial, pide a tu administrador que te conceda los siguientes roles de gestión de identidades y accesos en tu proyecto:
- Editor de Cloud Build (roles/cloudbuild.builds.editor)
- Desarrollador de Cloud Functions (roles/cloudfunctions.developer)
- Administrador de Cloud Run (roles/run.admin)
- Crear cuentas de servicio (roles/iam.serviceAccountCreator)
- Administrador de gestión de identidades y accesos del proyecto (roles/resourcemanager.projectIamAdmin)
- Usuario de cuenta de servicio (roles/iam.serviceAccountUser)
- Consumidor de uso del servicio (roles/serviceusage.serviceUsageConsumer)
- Administrador de almacenamiento (roles/storage.admin)
- Editor de workflows (roles/workflows.editor)
Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar el acceso a proyectos, carpetas y organizaciones.

También puedes conseguir los permisos necesarios a través de roles personalizados u otros roles predefinidos.

Nota: Los roles básicos de gestión de identidades y accesos también pueden contener permisos para completar el tutorial. No debes conceder roles básicos en un entorno de producción, pero sí puedes hacerlo en un entorno de desarrollo o de pruebas.

Cuando despliega un flujo de trabajo, lo asocia a una cuenta de servicio específica. Crea una cuenta de servicio para que la usen los workflows:
```
export SERVICE_ACCOUNT=workflows-sa
gcloud iam service-accounts create ${SERVICE_ACCOUNT}
```

Todos los servicios de Cloud Run se despliegan de forma privada de forma predeterminada y solo pueden llamarlos los propietarios y editores de proyectos, los administradores de Cloud Run y los invocadores de Cloud Run. Para permitir que la cuenta de servicio llame a un servicio de Cloud Run autenticado, asigna el rol run.invoker a la cuenta de servicio de Workflows:
```
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member "serviceAccount:${SERVICE_ACCOUNT}@PROJECT_ID.iam.gserviceaccount.com" \
    --role "roles/run.invoker"
```

Desplegar las primeras funciones de Cloud Run

Después de recibir una solicitud HTTP, esta función HTTP genera un número aleatorio entre 1 y 100 y, a continuación, devuelve el número en formato JSON.

Crea un directorio llamado randomgen y accede a él:
```
mkdir ~/randomgen
cd ~/randomgen
```

Crea un archivo de texto con el nombre main.py que contenga el siguiente código de Python:

import functions_framework
import random
from flask import jsonify


@functions_framework.http
def randomgen(request):
    randomNum = random.randint(1, 100)
    output = {"random": randomNum}
    return jsonify(output)

Para admitir una dependencia de Flask para el procesamiento HTTP, crea un archivo de texto para el gestor de paquetes pip. Asigna el nombre de archivo requirements.txt y añade lo siguiente:
```
flask>=1.0.2
functions-framework==3.0.0
```
Despliega la función con un activador HTTP y permite el acceso sin autenticar:
```
gcloud functions deploy randomgen-function \
    --gen2 \
    --runtime python310 \
    --entry-point=randomgen \
    --trigger-http \
    --allow-unauthenticated
```
La función puede tardar unos minutos en implementarse. También puedes usar la interfaz de funciones de Cloud Run en la Google Cloud consola para desplegar la función.

Una vez que se haya implementado la función randomgen, puede confirmar la propiedad httpsTrigger.url:

gcloud functions describe randomgen-function \
    --gen2 \
    --format="value(serviceConfig.uri)"

Guarda la URL. Tendrás que añadirlo al archivo de origen de tu flujo de trabajo en ejercicios posteriores.

Puedes probar la función con el siguiente comando curl:

curl $(gcloud functions describe randomgen-function \
    --gen2 \
    --format="value(serviceConfig.uri)")

Se genera y devuelve un número aleatorio.

Desplegar la segunda función de Cloud Run

Después de recibir una solicitud HTTP, esta función HTTP extrae el input del cuerpo JSON, lo multiplica por 2 y devuelve el resultado en formato JSON.

Vuelve a tu directorio principal:
```
cd ~
```
Crea un directorio llamado multiply y accede a él:
```
mkdir ~/multiply
cd ~/multiply
```

Crea un archivo de texto con el nombre main.py que contenga el siguiente código de Python:

import functions_framework
from flask import jsonify


@functions_framework.http
def multiply(request):
    request_json = request.get_json()
    output = {"multiplied": 2 * request_json['input']}
    return jsonify(output)

Para admitir una dependencia de Flask para el procesamiento HTTP, crea un archivo de texto para el gestor de paquetes pip. Asigna el nombre de archivo requirements.txt y añade lo siguiente:
```
flask>=1.0.2
functions-framework==3.0.0
```
Despliega la función con un activador HTTP y permite el acceso sin autenticar:
```
gcloud functions deploy multiply-function \
    --gen2 \
    --runtime python310 \
    --entry-point=multiply \
    --trigger-http \
    --allow-unauthenticated
```
La función puede tardar unos minutos en implementarse. También puedes usar la interfaz de funciones de Cloud Run en la Google Cloud consola para desplegar la función.

Una vez que se haya implementado la función multiply, puede confirmar la propiedad httpsTrigger.url:

gcloud functions describe multiply-function \
    --gen2\
    --format="value(serviceConfig.uri)"

Guarda la URL. Tendrás que añadirlo al archivo de origen de tu flujo de trabajo en ejercicios posteriores.

Puedes probar la función con el siguiente comando curl:

curl -X POST MULTIPLY_FUNCTION_URL \
    -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
    -H "Content-Type: application/json" \
    -d '{"input": 5}'

Debería devolver el número 10.

Conectar las dos funciones de Cloud Run en un flujo de trabajo

Un flujo de trabajo se compone de una serie de pasos descritos mediante la sintaxis de Workflows, que se puede escribir en formato YAML o JSON. Esta es la definición del flujo de trabajo. Para obtener una explicación detallada, consulta la página Referencia de sintaxis.

Vuelve a tu directorio principal:
```
cd ~
```
Crea un archivo de texto con el nombre workflow.yaml que contenga lo siguiente:
```
- randomgen_function:
    call: http.get
    args:
        url: RANDOMGEN_FUNCTION_URL
    result: randomgen_result
- multiply_function:
    call: http.post
    args:
        url: MULTIPLY_FUNCTION_URL
        body:
            input: ${randomgen_result.body.random}
    result: multiply_result
- return_result:
    return: ${multiply_result}
```
- Sustituye RANDOMGEN_FUNCTION_URL por la URL de tu función randomgen.
- Sustituye MULTIPLY_FUNCTION_URL por la URL de tu función multiply.
Este archivo de origen vincula las dos funciones HTTP y devuelve un resultado final.

Nota: Para hacer una solicitud a una función de Cloud Run que solo acepte llamadas autenticadas, usa OIDC para autenticarte. Para obtener más información, consulta el artículo Hacer solicitudes autenticadas desde un flujo de trabajo
.
Después de crear el flujo de trabajo, puedes implementarlo para que esté listo para ejecutarse.
```
gcloud workflows deploy WORKFLOW_NAME \
    --source=workflow.yaml \
    --service-account=${SERVICE_ACCOUNT}@PROJECT_ID.iam.gserviceaccount.com
```
Sustituye WORKFLOW_NAME por el nombre que quieras darle al flujo de trabajo.
Ejecuta el flujo de trabajo:
```
gcloud workflows run WORKFLOW_NAME
```
Una ejecución es una sola vez que se ejecuta la lógica contenida en la definición de un flujo de trabajo. Todas las ejecuciones de flujo de trabajo son independientes y el escalado rápido de Workflows permite un gran número de ejecuciones simultáneas.

Una vez que se haya ejecutado el flujo de trabajo, la salida debería ser similar a la siguiente:
```
result: '{"body":{"multiplied":120},"code":200,"headers":{"Alt-Svc":"h3-29=\":443\";
...
startTime: '2021-05-05T14:17:39.135251700Z'
state: SUCCEEDED
...
```

Conectar un servicio REST público en el flujo de trabajo

Actualiza tu flujo de trabajo y conecta una API REST pública (math.js) que pueda evaluar expresiones matemáticas. Por ejemplo, curl https://api.mathjs.org/v4/?'expr=log(56)'.

Ten en cuenta que, como has desplegado el flujo de trabajo, también puedes editarlo en la página Flujos de trabajo de la Google Cloud consola.

Edita el archivo de origen de tu flujo de trabajo y sustitúyelo por el siguiente contenido:

- randomgen_function:
    call: http.get
    args:
        url: RANDOMGEN_FUNCTION_URL
    result: randomgen_result
- multiply_function:
    call: http.post
    args:
        url: MULTIPLY_FUNCTION_URL
        body:
            input: ${randomgen_result.body.random}
    result: multiply_result
- log_function:
    call: http.get
    args:
        url: https://api.mathjs.org/v4/
        query:
            expr: ${"log(" + string(multiply_result.body.multiplied) + ")"}
    result: log_result
- return_result:
    return: ${log_result}

Sustituye RANDOMGEN_FUNCTION_URL por la URL de tu función randomgen.
Sustituye MULTIPLY_FUNCTION_URL por la URL de tu función multiply.

De esta forma, se vincula el servicio REST externo a las funciones de Cloud Run y se devuelve un resultado final.

Despliega el flujo de trabajo modificado:

gcloud workflows deploy WORKFLOW_NAME \
    --source=workflow.yaml \
    --service-account=${SERVICE_ACCOUNT}@PROJECT_ID.iam.gserviceaccount.com

Desplegar un servicio de Cloud Run

Despliega un servicio de Cloud Run que, tras recibir una solicitud HTTP, extrae input del cuerpo JSON, calcula su math.floor y devuelve el resultado.

Crea un directorio llamado floor y accede a él:
```
mkdir ~/floor
cd ~/floor
```

Crea un archivo de texto con el nombre app.py que contenga el siguiente código de Python:

import json
import logging
import os
import math

from flask import Flask, request

app = Flask(__name__)


@app.route('/', methods=['POST'])
def handle_post():
    content = json.loads(request.data)
    input = float(content['input'])
    return f"{math.floor(input)}", 200


if __name__ != '__main__':
    # Redirect Flask logs to Gunicorn logs
    gunicorn_logger = logging.getLogger('gunicorn.error')
    app.logger.handlers = gunicorn_logger.handlers
    app.logger.setLevel(gunicorn_logger.level)
    app.logger.info('Service started...')
else:
    app.run(debug=True, host='0.0.0.0', port=int(os.environ.get('PORT', 8080)))

En el mismo directorio, crea un archivo Dockerfile con el siguiente contenido:

# Use an official lightweight Python image.
# https://hub.docker.com/_/python
FROM python:3.7-slim

# Install production dependencies.
RUN pip install Flask gunicorn

# Copy local code to the container image.
WORKDIR /app
COPY . .

# Run the web service on container startup. Here we use the gunicorn
# webserver, with one worker process and 8 threads.
# For environments with multiple CPU cores, increase the number of workers
# to be equal to the cores available.
CMD exec gunicorn --bind 0.0.0.0:8080 --workers 1 --threads 8 app:app

Crea un repositorio estándar de Artifact Registry donde puedas almacenar tu imagen de contenedor Docker:
```
gcloud artifacts repositories create REPOSITORY \
    --repository-format=docker \
    --location=${REGION}
```
Sustituye REPOSITORY por un nombre único para el repositorio.

Crea la imagen del contenedor:

export SERVICE_NAME=floor
gcloud builds submit --tag ${REGION}-docker.pkg.dev/PROJECT_ID/REPOSITORY/${SERVICE_NAME}

Despliega la imagen de contenedor en Cloud Run y asegúrate de que solo acepte llamadas autenticadas:

gcloud run deploy ${SERVICE_NAME} \
    --image ${REGION}-docker.pkg.dev/PROJECT_ID/REPOSITORY/${SERVICE_NAME}:latest \
    --no-allow-unauthenticated

Cuando veas la URL del servicio, el despliegue se habrá completado. Deberá especificar esa URL al actualizar la definición del flujo de trabajo.

Conectar el servicio de Cloud Run en el flujo de trabajo

Actualiza el flujo de trabajo y especifica la URL del servicio de Cloud Run.

Vuelve a tu directorio principal:
```
cd ~
```

Edita el archivo de origen de tu flujo de trabajo y sustitúyelo por el siguiente contenido:

- randomgen_function:
    call: http.get
    args:
        url: RANDOMGEN_FUNCTION_URL
    result: randomgen_result
- multiply_function:
    call: http.post
    args:
        url: MULTIPLY_FUNCTION_URL
        body:
            input: ${randomgen_result.body.random}
    result: multiply_result
- log_function:
    call: http.get
    args:
        url: https://api.mathjs.org/v4/
        query:
            expr: ${"log(" + string(multiply_result.body.multiplied) + ")"}
    result: log_result
- floor_function:
    call: http.post
    args:
        url: CLOUD_RUN_SERVICE_URL
        auth:
            type: OIDC
        body:
            input: ${log_result.body}
    result: floor_result
- create_output_map:
    assign:
      - outputMap:
          randomResult: ${randomgen_result}
          multiplyResult: ${multiply_result}
          logResult: ${log_result}
          floorResult: ${floor_result}
- return_output:
    return: ${outputMap}

Sustituye RANDOMGEN_FUNCTION_URL por la URL de tu función randomgen.
Sustituye MULTIPLY_FUNCTION_URL por la URL de tu función multiply.
Sustituye CLOUD_RUN_SERVICE_URL por la URL de tu servicio de Cloud Run.

De esta forma, se conecta el servicio de Cloud Run en el flujo de trabajo. Ten en cuenta que la clave auth asegura que se transmita un token de autenticación en la llamada al servicio de Cloud Run. Para obtener más información, consulta el artículo Hacer solicitudes autenticadas desde un flujo de trabajo.

Despliega el flujo de trabajo modificado:

gcloud workflows deploy WORKFLOW_NAME \
    --source=workflow.yaml \
    --service-account=${SERVICE_ACCOUNT}@PROJECT_ID.iam.gserviceaccount.com

Ejecuta el flujo de trabajo final:

gcloud workflows run WORKFLOW_NAME

La salida debería ser similar a la siguiente:

result: '{"floorResult":{"body":"4","code":200
  ...
  "logResult":{"body":"4.02535169073515","code":200
  ...
  "multiplyResult":{"body":{"multiplied":56},"code":200
  ...
  "randomResult":{"body":{"random":28},"code":200
  ...
startTime: '2023-11-13T21:22:56.782669001Z'
state: SUCCEEDED

¡Enhorabuena! Has desplegado y ejecutado un flujo de trabajo que conecta una serie de servicios entre sí.

Para crear flujos de trabajo más complejos con expresiones, saltos condicionales, codificación o decodificación Base64, subflujos de trabajo y más, consulta la referencia de sintaxis de Workflows y la descripción general de la biblioteca estándar.

Limpieza

Si has creado un proyecto para este tutorial, elimínalo. Si has usado un proyecto y quieres conservarlo sin los cambios que has añadido en este tutorial, elimina los recursos creados para el tutorial.

Eliminar el proyecto

La forma más fácil de evitar que te cobren es eliminar el proyecto que has creado para el tutorial.

Para ello, sigue las instrucciones que aparecen a continuación:

Precaución: Eliminar un proyecto tiene los siguientes efectos:

Se elimina todo el contenido del proyecto. Si has usado un proyecto que ya existía para las tareas de este documento, cuando lo elimines, también se eliminará cualquier otro trabajo que hayas realizado en él.
Se pierden los IDs de proyecto personalizados. Cuando creaste este proyecto, es posible que hayas creado un ID de proyecto personalizado que quieras usar en el futuro. Para conservar las URLs que usan el ID del proyecto, como una URL appspot.com, elimina los recursos seleccionados dentro del proyecto en lugar de eliminar todo el proyecto.

Si tienes previsto consultar varias arquitecturas, tutoriales o guías de inicio rápido, reutilizar los proyectos puede ayudarte a no superar los límites de cuota de proyectos.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Eliminar recursos del tutorial

Elimina el servicio de Cloud Run que has desplegado en este tutorial.
Elimina el flujo de trabajo que has creado en este tutorial.
Elimina la imagen de contenedor de Artifact Registry.
Elimina el repositorio de Artifact Registry.

Elimina las configuraciones predeterminadas de Google Cloud CLI que has añadido durante la configuración del tutorial:

gcloud config unset functions/region
gcloud config unset run/region
gcloud config unset workflows/location
gcloud config unset project