Instructivo para usar flujos de trabajo con Cloud Run y Cloud Run Functions

Implementa las primeras funciones de Cloud Run

Después de recibir una solicitud HTTP, esta función de HTTP genera un número aleatorio entre 1 y 100 y, luego, lo muestra en formato JSON.

1. Crea un directorio llamado randomgen y cámbialo como se indica a continuación:

   mkdir ~/randomgen
   cd ~/randomgen

2. Crea un archivo de texto con el nombre de archivo 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)

3. A fin de admitir una dependencia en Flask para el procesamiento de HTTP, crea un archivo de texto destinado al administrador de paquetes pip. Asígnale el nombre requirements.txt y agrega lo siguiente:

   flask>=1.0.2
   functions-framework==3.0.0

4. Implementa la función con un activador de HTTP y permite el acceso no autenticado:

   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 Cloud Run Functions en la consola de Google Cloud para implementar la función.

5. Una vez que se implementa la función randomgen, puedes confirmar la propiedad httpsTrigger.url:

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

6. Guarda la URL. Deberás agregarlo a tu archivo fuente de flujo de trabajo en ejercicios posteriores.

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

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

   Se genera y se muestra un número de forma aleatoria.

Implementa las segundas funciones de Cloud Run

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

1. Regresa al directorio principal:

   cd ~

2. Crea un directorio llamado multiply y cámbialo como se indica a continuación:

   mkdir ~/multiply
   cd ~/multiply

3. Crea un archivo de texto con el nombre de archivo 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)

4. A fin de admitir una dependencia en Flask para el procesamiento de HTTP, crea un archivo de texto destinado al administrador de paquetes pip. Asígnale el nombre requirements.txt y agrega lo siguiente:

   flask>=1.0.2
   functions-framework==3.0.0

5. Implementa la función con un activador de HTTP y permite el acceso no autenticado:

   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 Cloud Run Functions en la consola de Google Cloud para implementar la función.

6. Una vez que se implementa la función multiply, puedes confirmar la propiedad httpsTrigger.url:

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

7. Guarda la URL. Deberás agregarlo a tu archivo fuente de flujo de trabajo en ejercicios posteriores.

8. 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}'

   Se debería mostrar el número 10.

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

Un flujo de trabajo está compuesto por una serie de pasos descritos con la sintaxis de Workflows, que se pueden 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.

1. Regresa al directorio principal:

   cd ~

2. Crea un archivo de texto con el nombre de archivo workflow.yaml que incluya 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
   - return_result:
       return: ${multiply_result}
   

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

   Este archivo fuente vincula las dos funciones de HTTP y muestra un resultado final.

3. Después de crear el flujo de trabajo, puedes implementarlo, con lo que estará listo para ejecutarse.

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

   Reemplaza WORKFLOW_NAME por un nombre para tu VPC.

4. Ejecuta el flujo de trabajo:

   gcloud workflows run WORKFLOW_NAME

   Una ejecución es una ejecución única de la lógica que se incluye en la definición de un flujo de trabajo. Todas las ejecuciones de flujos de trabajo son independientes, y el escalamiento rápido Workflows permite una gran cantidad de ejecuciones simultáneas.

   Una vez que se ejecuta el flujo de trabajo, el resultado debería ser similar al siguiente:

   result: '{"body":{"multiplied":120},"code":200,"headers":{"Alt-Svc":"h3-29=\":443\";
   ...
   startTime: '2021-05-05T14:17:39.135251700Z'
   state: SUCCEEDED
   ...
   

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

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

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

1. Edita el archivo fuente de tu flujo de trabajo y reemplázalo 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}
   

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

   Esto vincula el servicio de REST externo a las funciones de Cloud Run y muestra un resultado final.

2. Implementa el flujo de trabajo modificado:

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

Implementa un servicio de Cloud Run

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

1. Crea un directorio llamado floor y cámbialo como se indica a continuación:

   mkdir ~/floor
   cd ~/floor

2. Crea un archivo de texto con el nombre de archivo 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)))

3. En el mismo directorio, crea un 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

4. Crea un repositorio estándar de Artifact Registry en el que puedas almacenar la imagen de contenedor de Docker:

   gcloud artifacts repositories create REPOSITORY \
       --repository-format=docker \
       --location=${REGION}

   Reemplaza REPOSITORY por un nombre único para el repositorio.

5. Compila la imagen del contenedor:

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

6. Implementa 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, se completará la implementación. Deberás especificar esa URL cuando actualices la definición del flujo de trabajo.

Conecta el servicio de Cloud Run en el flujo de trabajo

Actualiza tu flujo de trabajo existente y especifica la URL para el servicio de Cloud Run.

1. Regresa al directorio principal:

   cd ~

2. Edita el archivo fuente de tu flujo de trabajo y reemplázalo 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}
   

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

   Esto conecta el servicio de Cloud Run en el flujo de trabajo. Ten en cuenta que la clave auth garantiza que se transmita un token de autenticación en la llamada al servicio de Cloud Run. Para obtener más información, consulta Realiza solicitudes autenticadas desde un flujo de trabajo.

3. Implementa el flujo de trabajo modificado:

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

4. Ejecuta el flujo de trabajo final:

   gcloud workflows run WORKFLOW_NAME

   El resultado debe parecerse al 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
   

¡Felicitaciones! Implementaste y ejecutaste un flujo de trabajo que conecta una serie de servicios.

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