Tutoriel Utiliser des workflows avec Cloud Run et Cloud Run Functions

Déployer les premières fonctions Cloud Run

Après avoir reçu une requête HTTP, cette fonction HTTP génère un nombre aléatoire compris entre 1 et 100, puis renvoie le nombre au format JSON.

1. Créez un répertoire nommé randomgen et remplacez les éléments par ce qui suit :

   mkdir ~/randomgen
   cd ~/randomgen

2. Créez un fichier texte avec le nom de fichier main.py contenant le code Python suivant :

   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. Pour être compatible avec Flask pour le traitement HTTP, créez un fichier texte pour le gestionnaire de paquets pip. Attribuez-lui le nom de fichier requirements.txt et ajoutez les éléments suivants :

   flask>=1.0.2
   functions-framework==3.0.0

4. Déployer la fonction avec un déclencheur HTTP et autoriser les accès non authentifiés :

   gcloud functions deploy randomgen-function \
       --gen2 \
       --runtime python310 \
       --entry-point=randomgen \
       --trigger-http \
       --allow-unauthenticated

   Le déploiement de la fonction peut prendre quelques minutes. Vous pouvez également utiliser l'interface Cloud Run Functions dans la console Google Cloud pour déployer la fonction.

5. Une fois la fonction randomgen déployée, vous pouvez confirmer la propriété httpsTrigger.url :

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

6. Enregistrez l'URL. Vous devrez l'ajouter à votre fichier source Workflows dans les exercices suivants.

7. Vous pouvez essayer la fonction à l'aide de la commande curl suivante :

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

   Un nombre est généré de manière aléatoire et renvoyé.

Déployer les deuxièmes fonctions Cloud Run

Après avoir reçu une requête HTTP, cette fonction HTTP extrait le input du corps JSON, le multiplie par 2 et renvoie le résultat au format JSON.

1. Revenez à votre répertoire d'accueil :

   cd ~

2. Créez un répertoire nommé multiply et remplacez les éléments par ce qui suit :

   mkdir ~/multiply
   cd ~/multiply

3. Créez un fichier texte avec le nom de fichier main.py contenant le code Python suivant :

   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. Pour être compatible avec Flask pour le traitement HTTP, créez un fichier texte pour le gestionnaire de paquets pip. Attribuez-lui le nom de fichier requirements.txt et ajoutez les éléments suivants :

   flask>=1.0.2
   functions-framework==3.0.0

5. Déployer la fonction avec un déclencheur HTTP et autoriser les accès non authentifiés :

   gcloud functions deploy multiply-function \
       --gen2 \
       --runtime python310 \
       --entry-point=multiply \
       --trigger-http \
       --allow-unauthenticated

   Le déploiement de la fonction peut prendre quelques minutes. Vous pouvez également utiliser l'interface Cloud Run Functions dans la console Google Cloud pour déployer la fonction.

6. Une fois la fonction multiply déployée, vous pouvez confirmer la propriété httpsTrigger.url :

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

7. Enregistrez l'URL. Vous devrez l'ajouter à votre fichier source Workflows dans les exercices suivants.

8. Vous pouvez essayer la fonction à l'aide de la commande curl suivante :

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

   Le nombre 10 doit être renvoyé.

Connecter les deux fonctions Cloud Run dans un workflow

Un workflow est constitué d'une série d'étapes décrites à l'aide de la syntaxe Workflows, qui peut être écrite au format YAML ou JSON. Il s'agit de la définition du workflow. Pour une explication détaillée, consultez la page de documentation de référence sur la syntaxe.

1. Revenez à votre répertoire d'accueil :

   cd ~

2. Créez un fichier texte portant le nom de fichier workflow.yaml avec le contenu suivant :

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

   • Remplacez RANDOMGEN_FUNCTION_URL par l'URL de votre fonction randomgen.
   • Remplacez MULTIPLY_FUNCTION_URL par l'URL de votre fonction multiply.

   Ce fichier source associe les deux fonctions HTTP et renvoie un résultat final.

3. Une fois le workflow créé, vous pouvez le déployer afin qu'il soit prêt à être exécuté.

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

   Remplacez WORKFLOW_NAME par le nom que vous souhaitez donner à votre workflow.

4. Exécutez le workflow :

   gcloud workflows run WORKFLOW_NAME

   Il s'agit d'une exécution unique de la logique contenue dans la définition d'un workflow. Toutes les exécutions de workflow sont indépendantes, et le scaling rapide de Workflows permet d'effectuer un grand nombre d'exécutions simultanées.

   Une fois le workflow exécuté, le résultat devrait ressembler à ceci :

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

Connecter un service REST public dans le workflow

Mettez à jour votre workflow existant et connectez une API REST publique (math.js) capable d'évaluer des expressions mathématiques. Exemple : curl https://api.mathjs.org/v4/?'expr=log(56)'.

Notez que dans la mesure où vous avez déployé votre workflow, vous pouvez également le modifier sur la page Workflows de la console Google Cloud.

1. Modifiez le fichier source de votre workflow et remplacez-le par le contenu suivant :

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

   • Remplacez RANDOMGEN_FUNCTION_URL par l'URL de votre fonction randomgen.
   • Remplacez MULTIPLY_FUNCTION_URL par l'URL de votre fonction multiply.

   Cela a pour effet d'associer le service REST externe aux fonctions Cloud Run et de renvoyer un résultat final.

2. Déployez le workflow modifié :

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

Déployer un service Cloud Run

Déployez un service Cloud Run qui, après avoir reçu une requête HTTP, extrait la valeur input du corps JSON, calcule sa valeur math.floor et renvoie le résultat.

1. Créez un répertoire nommé floor et remplacez les éléments par ce qui suit :

   mkdir ~/floor
   cd ~/floor

2. Créez un fichier texte avec le nom de fichier app.py contenant le code Python suivant :

   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. Dans le même répertoire, créez un Dockerfile avec le contenu suivant :

   # 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. Créez un dépôt standard Artifact Registry dans lequel vous pouvez stocker votre image de conteneur Docker:

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

   Remplacez REPOSITORY par un nom unique pour le dépôt.

5. Créez l'image du conteneur :

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

6. Déployez l'image de conteneur dans Cloud Run, en veillant à ce qu'elle n'accepte que les appels authentifiés :

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

Lorsque l'URL du service s'affiche, cela signifie que le déploiement est terminé. Vous devrez spécifier cette URL lors de la mise à jour de la définition du workflow.

Connecter le service Cloud Run dans le workflow

Mettez à jour votre workflow existant et spécifiez l'URL du service Cloud Run.

1. Revenez à votre répertoire d'accueil :

   cd ~

2. Modifiez le fichier source de votre workflow et remplacez-le par le contenu suivant :

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

   • Remplacez RANDOMGEN_FUNCTION_URL par l'URL de votre fonction randomgen.
   • Remplacez MULTIPLY_FUNCTION_URL par l'URL de votre fonction multiply.
   • Remplacez CLOUD_RUN_SERVICE_URL par l'URL de votre service Cloud Run.

   Cela permet de connecter le service Cloud Run dans le workflow. Notez que la clé auth garantit qu'un jeton d'authentification est transmis dans l'appel au service Cloud Run. Pour plus d'informations, consultez la page Effectuer des requêtes authentifiées à partir d'un workflow.

3. Déployez le workflow modifié :

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

4. Exécutez le workflow final :

   gcloud workflows run WORKFLOW_NAME

   Le résultat doit ressembler à ceci :

   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
   

Félicitations ! Vous avez déployé et exécuté un workflow qui connecte une série de services.

Consultez la documentation de référence sur la syntaxe de workflows et la page Présentation de la bibliothèque standard pour créer des workflows plus complexes à l'aide d'expressions, de sauts conditionnels, de l'encodage ou du décodage en Base64, de sous-workflows, etc.