Tutorial sull'utilizzo di Workflows con Cloud Run e Cloud Run Functions

Esegui il deployment del primo servizio di funzioni Cloud Run

Dopo aver ricevuto una richiesta HTTP, questa funzione HTTP genera un numero casuale compreso tra 1 e 100, quindi restituisce il numero in formato JSON.

1. Crea una directory denominata randomgen e passa a quella directory:

   mkdir ~/randomgen
   cd ~/randomgen

2. Crea un file di testo con il nome main.py che contenga quanto segue. Codice 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. Per supportare una dipendenza da Flask per l'elaborazione HTTP, crea un file di testo per il gestore dei pacchetti pip. Assegna il nome requirements.txt al file e aggiungi quanto segue:

   flask>=1.0.2
   functions-framework==3.0.0

4. Crea un account di servizio da utilizzare per i flussi di lavoro:

   export SERVICE_ACCOUNT=workflows-sa
   gcloud iam service-accounts create ${SERVICE_ACCOUNT}

5. consentire all'account di servizio di chiamare Cloud Run autenticato assegna il ruolo run.invoker a Workflows account di servizio:

   gcloud projects add-iam-policy-binding PROJECT_ID \
       --member "serviceAccount:${SERVICE_ACCOUNT}@PROJECT_ID.iam.gserviceaccount.com" \
       --role "roles/run.invoker"

6. Esegui il deployment della funzione con un trigger HTTP e consenti l'accesso non autenticato:

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

   Il deployment della funzione potrebbe richiedere alcuni minuti. In alternativa, puoi utilizzare l'interfaccia delle funzioni Cloud Run nella console Google Cloud per eseguire il deployment della funzione.

7. Una volta eseguito il deployment della funzione randomgen, puoi verificare Proprietà httpsTrigger.url:

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

8. Salva l'URL. Dovrai aggiungerlo al file di origine di Workflow negli esercizi successivi.

9. Puoi provare la funzione con il seguente comando curl:

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

   Viene generato e restituito un numero casualmente.

Esegui il deployment del secondo servizio di funzioni Cloud Run

Dopo aver ricevuto una richiesta HTTP, questa funzione HTTP estrae input dal corpo JSON, lo moltiplica per 2 e restituisce il risultato in formato JSON.

1. Torna alla home directory:

   cd ~

2. Crea una directory denominata multiply e passa a quella directory:

   mkdir ~/multiply
   cd ~/multiply

3. Crea un file di testo con il nome main.py che contenga quanto segue. Codice 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. Per supportare una dipendenza da Flask per l'elaborazione HTTP, crea un file di testo per il gestore dei pacchetti pip. Assegna il nome requirements.txt al file e aggiungi quanto segue:

   flask>=1.0.2
   functions-framework==3.0.0

5. Esegui il deployment della funzione con un trigger HTTP e consenti l'accesso non autenticato:

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

   Il deployment della funzione potrebbe richiedere alcuni minuti.In alternativa, puoi Usa l'interfaccia delle funzioni di Cloud Run nella console Google Cloud per eseguire il deployment della funzione.

6. Una volta eseguita il deployment della funzione multiply, puoi confermare la proprietà httpsTrigger.url:

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

7. Salva l'URL. Dovrai aggiungerlo al file di origine di Workflow negli esercizi successivi.

8. Puoi provare la funzione con il seguente comando curl:

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

   Deve essere restituito il numero 10.

Collega i due servizi di funzioni Cloud Run in un flusso di lavoro

Un flusso di lavoro è costituito da una serie di passaggi descritti utilizzando la sintassi di Workflows, che può essere scritta in formato YAML o JSON. Questa è la definizione del flusso di lavoro. Per una spiegazione dettagliata, consulta Pagina Riferimento per la sintassi.

1. Torna alla home directory:

   cd ~

2. Crea un file di testo con il nome workflow.yaml che contenga quanto segue. contenuti:

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

   • Sostituisci RANDOMGEN_FUNCTION_URL con l'URL della funzione randomgen.
   • Sostituisci MULTIPLY_FUNCTION_URL con l'URL del tuo Funzione multiply.

   Questo file di origine collega le due funzioni HTTP e restituisce un risultato finale.

3. Dopo aver creato il flusso di lavoro, puoi eseguirne il deployment, in modo che sia pronto dell'esecuzione.

   gcloud workflows deploy WORKFLOW_NAME \
       --source=workflow.yaml

   Sostituisci WORKFLOW_NAME con un nome per il flusso di lavoro.

4. Esegui il flusso di lavoro:

   gcloud workflows run WORKFLOW_NAME

   Un'esecuzione è una singola esecuzione della logica contenuta nella definizione di un flusso di lavoro. Tutte le esecuzioni dei flussi di lavoro sono indipendenti e la rapida scalabilità Workflows consente un numero elevato di esecuzioni simultanee.

   Dopo l'esecuzione del flusso di lavoro, l'output dovrebbe essere simile al seguente:

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

Collega un servizio REST pubblico nel flusso di lavoro

Aggiorna il flusso di lavoro esistente e collega un'API REST pubblica (math.js) che può valutare le espressioni matematiche. Ad esempio, curl https://api.mathjs.org/v4/?'expr=log(56)'.

Tieni presente che, dopo aver eseguito il deployment del flusso di lavoro, puoi modificarlo anche tramite la pagina Flussi di lavoro nella console Google Cloud.

1. Modifica il file di origine del flusso di lavoro e sostituiscilo con i seguenti contenuti:

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

   • Sostituisci RANDOMGEN_FUNCTION_URL con l'URL della funzione randomgen.
   • Sostituisci MULTIPLY_FUNCTION_URL con l'URL della funzione multiply.

   Questo collega il servizio REST esterno ai servizi delle funzioni Cloud Run. e restituisce un risultato finale.

2. Esegui il deployment del flusso di lavoro modificato:

   gcloud workflows deploy WORKFLOW_NAME \
       --source=workflow.yaml

Esegui il deployment di un servizio Cloud Run

Eseguire il deployment di un servizio Cloud Run che, dopo aver ricevuto un messaggio HTTP richiesta, estrae input dal corpo JSON, ne calcola math.floor e restituisce il risultato.

1. Crea una directory denominata floor e passa a questa directory:

   mkdir ~/floor
   cd ~/floor

2. Crea un file di testo con il nome app.py che contenga quanto segue. Codice 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. Nella stessa directory, crea un file Dockerfile con il seguente contenuto:

   # 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 repository standard Artifact Registry in cui archiviare i tuoi Immagine container Docker:

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

   Sostituisci REPOSITORY con un nome univoco per repository Git.

5. Crea l'immagine container:

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

6. Esegui il deployment dell'immagine container in Cloud Run, assicurandoti che accetti solo chiamate autenticate:

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

Quando vedi l'URL del servizio, il deployment è completato. Dovrai specificare questo URL durante l'aggiornamento della definizione del flusso di lavoro.

connetti il servizio Cloud Run nel flusso di lavoro

Aggiorna il flusso di lavoro esistente e specifica l'URL per Cloud Run completamente gestito di Google Cloud.

1. Modifica il file di origine per il flusso di lavoro e sostituiscilo con quanto segue contenuti:

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

   • Sostituisci RANDOMGEN_FUNCTION_URL con l'URL della funzione randomgen.
   • Sostituisci MULTIPLY_FUNCTION_URL con l'URL del tuo Funzione multiply.
   • Sostituisci CLOUD_RUN_SERVICE_URL con l'URL del servizio Cloud Run.

   Questa operazione connette il servizio Cloud Run nel flusso di lavoro. Nota che la chiave auth garantisca il passaggio di un token di autenticazione la chiamata al servizio Cloud Run. Per saperne di più, consulta Eseguire richieste autenticate da un flusso di lavoro.

2. Esegui il deployment del flusso di lavoro modificato:

   gcloud workflows deploy WORKFLOW_NAME \
       --source=workflow.yaml

3. Esegui il flusso di lavoro finale:

   gcloud workflows run WORKFLOW_NAME

   L'output dovrebbe essere simile al seguente:

   result: '{"Floor":{"body":"4","code":200
     ...
     "Log":{"body":"4.02535169073515","code":200
     ...
     "Multiply":{"body":{"multiplied":56},"code":200
     ...
     "Random":{"body":{"random":28},"code":200
     ...
   startTime: '2023-11-13T21:22:56.782669001Z'
   state: SUCCEEDED
   

Complimenti! Hai eseguito il deployment ed eseguito un flusso di lavoro che connette una serie di servizi.

Per creare flussi di lavoro più complessi utilizzando espressioni, salti condizionali, Codifica o decodifica Base64, flussi di lavoro secondari e altro ancora, fai riferimento all' Riferimento per la sintassi di Workflows e la panoramica della Libreria standard.