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

Questo tutorial mostra come utilizzare Workflows per collegare una serie di servizi. Collegando due servizi HTTP pubblici con Cloud Functions (2nd gen), un'API REST esterna e un servizio Cloud Run privato, puoi creare un'applicazione serverless e flessibile.

Obiettivi

In questo tutorial utilizzerai Google Cloud CLI per creare un singolo flusso di lavoro, connettendo un servizio alla volta:

Esegui il deployment di due servizi Cloud Functions: la prima funzione genera un numero casuale, quindi lo passa alla seconda funzione che lo moltiplica.
Utilizzando Workflows, puoi connettere le due funzioni HTTP. Esegue il flusso di lavoro e restituisce un risultato che viene poi passato a un'API esterna.
Utilizzando Workflows, connetti un'API HTTP esterna che restituisce log per un numero specifico. Esegui il flusso di lavoro e restituisci un risultato che viene quindi passato a un servizio Cloud Run.
Esegui il deployment di un servizio Cloud Run che consente solo l'accesso autenticato. Il servizio restituisce math.floor per un determinato numero.
Con Workflows, connetti il servizio Cloud Run, esegui l'intero flusso di lavoro e restituisci un risultato finale.

Il seguente diagramma mostra sia una panoramica del processo sia una visualizzazione del flusso di lavoro finale:

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud possono essere idonei a una prova senza costi aggiuntivi.

Prima di iniziare

I vincoli di sicurezza definiti dalla tua organizzazione potrebbero impedirti di completare i passaggi seguenti. Per informazioni sulla risoluzione dei problemi, vedi Sviluppare applicazioni in un ambiente Google Cloud vincolato.

Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

Installa Google Cloud CLI.

Per initialize gcloud CLI, esegui questo comando:

gcloud init

Crea o seleziona un progetto Google Cloud.

Crea un progetto Google Cloud:
```
gcloud projects create PROJECT_ID
```
Sostituisci PROJECT_ID con un nome per il progetto Google Cloud che stai creando.
Seleziona il progetto Google Cloud che hai creato:
```
gcloud config set project PROJECT_ID
```
Sostituisci PROJECT_ID con il nome del tuo progetto Google Cloud.

Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

Abilita le API Artifact Registry, Cloud Build, Cloud Functions, Cloud Run, Cloud Storage, and Workflows.

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

Installa Google Cloud CLI.

Per initialize gcloud CLI, esegui questo comando:

gcloud init

Crea o seleziona un progetto Google Cloud.

Crea un progetto Google Cloud:
```
gcloud projects create PROJECT_ID
```
Sostituisci PROJECT_ID con un nome per il progetto Google Cloud che stai creando.
Seleziona il progetto Google Cloud che hai creato:
```
gcloud config set project PROJECT_ID
```
Sostituisci PROJECT_ID con il nome del tuo progetto Google Cloud.

Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

Abilita le API Artifact Registry, Cloud Build, Cloud Functions, Cloud Run, Cloud Storage, and Workflows.

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

Aggiorna i componenti di Google Cloud CLI:
```
gcloud components update
```

Se esegui comandi all'interno di Cloud Shell, hai già eseguito l'autenticazione con gcloud CLI. In caso contrario, accedi utilizzando il tuo account:
```
gcloud auth login
```

Imposta la località predefinita utilizzata in questo 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}

Sostituisci REGION con la località supportata di Workflows scelta da te.

Se sei l'autore del progetto, ti viene concesso il ruolo Proprietario di base (roles/owner). Per impostazione predefinita, questo ruolo Identity and Access Management (IAM) include le autorizzazioni necessarie per l'accesso completo alla maggior parte delle risorse Google Cloud e puoi saltare questo passaggio.

Se non sei l'autore del progetto, le autorizzazioni richieste devono essere concesse per il progetto all'entità appropriata. Ad esempio, un'entità può essere un Account Google (per gli utenti finali) o un account di servizio (per applicazioni e carichi di lavoro di computing). Per ulteriori informazioni, consulta la pagina Ruoli e autorizzazioni per la destinazione dell'evento.
Autorizzazioni obbligatorie

Per ottenere le autorizzazioni necessarie per completare il tutorial, chiedi all'amministratore di concederti i seguenti ruoli IAM sul tuo progetto:
- Editor Cloud Build (roles/cloudbuild.builds.editor)
- Sviluppatore Cloud Functions (roles/cloudfunctions.developer)
- Amministratore Cloud Run (roles/run.admin)
- Crea account di servizio (roles/iam.serviceAccountCreator)
- Amministratore IAM progetto (roles/resourcemanager.projectIamAdmin)
- Utente account di servizio (roles/iam.serviceAccountUser)
- Service Usage Consumer (roles/serviceusage.serviceUsageConsumer)
- Amministratore Storage (roles/storage.admin)
- Workflows Editor (roles/workflows.editor) (Editor flussi di lavoro)
Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso.

Potresti anche essere in grado di ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Nota: anche i ruoli IAM di base potrebbero contenere le autorizzazioni necessarie per completare il tutorial. Non puoi concedere ruoli di base in un ambiente di produzione, ma puoi concederli in un ambiente di sviluppo o di test.

Esegui il deployment del primo servizio Cloud Functions

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.

Crea una directory denominata randomgen e passa alla directory:
```
mkdir ~/randomgen
cd ~/randomgen
```

Crea un file di testo con il nome main.py contenente il seguente 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)

Per supportare una dipendenza su Flask per l'elaborazione HTTP, crea un file di testo per il gestore di pacchetti pip. Assegna il nome file requirements.txt e aggiungi quanto segue:
```
flask>=1.0.2
functions-framework==3.0.0
```

Crea un account di servizio per consentire a Workflows di utilizzare:

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

Per consentire all'account di servizio di chiamare i servizi Cloud Run autenticati, concedi il ruolo run.invoker all'account di servizio Workflows:

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

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 Cloud Functions nella console Google Cloud per eseguire il deployment della funzione.

Dopo il deployment della funzione randomgen, puoi confermare la proprietà httpsTrigger.url:

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

Salva l'URL. Dovrai aggiungerlo al file di origine del flusso di lavoro negli esercizi successivi.
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 in modo casuale.

Esegui il deployment del secondo servizio Cloud Functions

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.

Torna alla tua home directory:
```
cd ~
```
Crea una directory denominata multiply e passa alla directory:
```
mkdir ~/multiply
cd ~/multiply
```

Crea un file di testo con il nome main.py contenente il seguente 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)

Per supportare una dipendenza su Flask per l'elaborazione HTTP, crea un file di testo per il gestore di pacchetti pip. Assegna il nome file requirements.txt e aggiungi quanto segue:
```
flask>=1.0.2
functions-framework==3.0.0
```
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 utilizzare l'interfaccia di Cloud Functions nella console Google Cloud per eseguire il deployment della funzione.

Dopo il deployment della funzione multiply, puoi confermare la proprietà httpsTrigger.url:

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

Salva l'URL. Dovrai aggiungerlo al file di origine del flusso di lavoro negli esercizi successivi.

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.

Connetti i due servizi Cloud Functions in un flusso di lavoro

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

Torna alla tua home directory:
```
cd ~
```
Crea un file di testo con il nome workflow.yaml che include 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
- return_result:
    return: ${multiply_result}
```
- Sostituisci RANDOMGEN_FUNCTION_URL con l'URL della funzione randomgen.
- Sostituisci MULTIPLY_FUNCTION_URL con l'URL della funzione multiply.
Questo file di origine collega le due funzioni HTTP e restituisce un risultato finale.

Nota: per effettuare una richiesta a una funzione Cloud Functions che accetta solo chiamate autenticate, utilizza OIDC per l'autenticazione. Per maggiori informazioni, consulta Effettuare richieste autenticate da un flusso di lavoro.
Dopo aver creato il flusso di lavoro, puoi eseguirne il deployment, in modo che sia pronto per l'esecuzione.
```
gcloud workflows deploy WORKFLOW_NAME \
    --source=workflow.yaml
```
Sostituisci WORKFLOW_NAME con un nome per il flusso di lavoro.
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à di 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
...
```

Connetti un servizio REST pubblico nel flusso di lavoro

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

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

Modifica il file di origine per il flusso di lavoro e sostituiscilo con il seguente contenuto:

- 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 Cloud Functions e restituisce un risultato finale.

Esegui il deployment del flusso di lavoro modificato:

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

esegui il deployment di un servizio Cloud Run

Esegui il deployment di un servizio Cloud Run che, dopo aver ricevuto una richiesta HTTP, estrae input dal corpo JSON, calcola il relativo valore math.floor e restituisce il risultato.

Crea una directory denominata floor e passa alla directory:
```
mkdir ~/floor
cd ~/floor
```

Crea un file di testo con il nome app.py contenente il seguente 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)))

Nella stessa directory, crea un Dockerfile con i seguenti contenuti:

# 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 repository standard Artifact Registry in cui puoi archiviare la tua immagine container Docker:
```
gcloud artifacts repositories create REPOSITORY \
    --repository-format=docker \
    --location=${REGION}
```
Sostituisci REPOSITORY con un nome univoco per il repository.

Crea l'immagine container:

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

Esegui il deployment dell'immagine container su 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 è completo. 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 il servizio Cloud Run.

Modifica il file di origine per il flusso di lavoro e sostituiscilo con il seguente contenuto:

- 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 della funzione multiply.
Sostituisci CLOUD_RUN_SERVICE_URL con l'URL del tuo servizio Cloud Run.

Ciò connette il servizio Cloud Run nel flusso di lavoro. Tieni presente che la chiave auth assicura che venga passato un token di autenticazione nella chiamata al servizio Cloud Run. Per ulteriori informazioni, consulta Effettuare richieste autenticate da un flusso di lavoro.

Esegui il deployment del flusso di lavoro modificato:

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

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 e l'esecuzione di un flusso di lavoro che connette tra loro 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, consulta il riferimento sulla sintassi di Workflows e la panoramica della libreria Standard.

Esegui la pulizia

Se hai creato un nuovo progetto per questo tutorial, elimina il progetto. Se hai utilizzato un progetto esistente e vuoi conservarlo senza le modifiche aggiunte in questo tutorial, elimina le risorse create per il tutorial.

Elimina il progetto

Il modo più semplice per eliminare la fatturazione è eliminare il progetto che hai creato per il tutorial.

Per eliminare il progetto:

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività in questo documento, quando lo elimini elimini anche qualsiasi altro lavoro svolto nel progetto.
Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

Nella console Google Cloud, vai alla pagina Gestisci risorse.
Vai a Gestisci risorse
Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Elimina risorse tutorial

Elimina il servizio Cloud Run di cui hai eseguito il deployment in questo tutorial.
Elimina il flusso di lavoro creato in questo tutorial.
Elimina l'immagine container da Artifact Registry.
Elimina il repository Artifact Registry.

Rimuovi le configurazioni predefinite di Google Cloud CLI che hai aggiunto durante la configurazione del tutorial:

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