Esegui il deployment di un'applicazione per flussi di lavoro transazionali di esempio in un'architettura di microservizi su Google Cloud

Questo documento descrive come eseguire il deployment di un'applicazione di esempio utilizzando Cloud Run, Pub/Sub, Flussi di lavoro e Firestore in modalità Datastore (Datastore). È destinata agli sviluppatori di applicazioni che vogliono implementare flussi di lavoro transazionali in un'applicazione basata su microservizi.

Il documento fa parte di una serie composta da:

Flussi di lavoro transazionali in un'architettura di microservizi su Google Cloud: una panoramica dell'architettura dell'applicazione di flussi di lavoro transazionali di esempio di cui esegui il deployment in questo tutorial.
Deployment di un'applicazione per flussi di lavoro transazionali di esempio in un'architettura di microservizi su Google Cloud (questo documento).

Questa applicazione di esempio di cui esegui il deployment in questo tutorial implementa microservizi per due pattern architetturali:

Una saga basata sulla coreografia
Orchestrazione sincrona

L'applicazione contiene un client web. Puoi sperimentare con entrambi i pattern da Google Cloud CLI e dal client web.

Obiettivi

Esegui il deployment dei componenti lato server per l'architettura della saga basata sulla coreografia
Esegui il deployment dei componenti lato server per l'architettura di orchestrazione sincrona
Testa i componenti lato server con il comando curl
Esegui il deployment di un'applicazione web ed esegui flussi di lavoro tramite questa applicazione

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.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Prima di iniziare

Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

Nota: se non prevedi di conservare le risorse create in questa procedura, crea un progetto anziché selezionarne uno esistente. Dopo aver completato questi passaggi, puoi eliminare il progetto, rimuovendo tutte le risorse associate.

Vai al selettore progetti
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
Abilita le API Cloud Services, Cloud Run, Workflows, Cloud Build, and Cloud Scheduler.
Abilita le API

Clona il codice sorgente

In questa sezione imposterai l'ID progetto e clonirai il codice sorgente in Cloud Shell.

In Cloud Shell, imposta l'ID progetto:
```
PROJECT_ID=PROJECT_ID
```
Sostituisci PROJECT_ID con l'ID del progetto Google Cloud che hai creato in precedenza.
Imposta l'ID progetto:
```
gcloud config set project $PROJECT_ID
```

Clona il repository del tutorial:

cd $HOME
git clone https://github.com/GoogleCloudPlatform/transactional-microservice-examples

Esegui il deployment dei componenti lato server per le architetture di saga basate sulla coreografia

In questa sezione eseguirai il deployment dei componenti lato server dell'applicazione di esempio. L'applicazione implementa architetture di saga basate su coreografie, come i microservizi su Cloud Run, le pianificazioni di pubblicazione di eventi su Cloud Scheduler e gli argomenti Pub/Sub.

Crea ed esegui il deployment delle immagini container

In Cloud Shell, crea un'immagine container per il servizio Order denominato order-async ed eseguine il deployment su Cloud Run:

cd $HOME/transactional-microservice-examples/services/order-async
gcloud builds submit --tag gcr.io/$PROJECT_ID/order-service-async
gcloud run deploy order-service-async \
  --image gcr.io/$PROJECT_ID/order-service-async \
  --platform=managed --region=us-central1 \
  --no-allow-unauthenticated

Crea un'immagine container per il servizio Customer denominato customer-async ed eseguine il deployment in Cloud Run:

cd $HOME/transactional-microservice-examples/services/customer-async
gcloud builds submit --tag gcr.io/$PROJECT_ID/customer-service-async
gcloud run deploy customer-service-async \
  --image gcr.io/$PROJECT_ID/customer-service-async \
  --platform=managed --region=us-central1 \
  --no-allow-unauthenticated

Crea un'immagine container per il servizio event-publisher ed eseguine il deployment in Cloud Run:

cd $HOME/transactional-microservice-examples/services/event-publisher
gcloud builds submit --tag gcr.io/$PROJECT_ID/event-publisher
gcloud run deploy event-publisher \
  --image gcr.io/$PROJECT_ID/event-publisher \
  --platform=managed --region=us-central1 \
  --no-allow-unauthenticated \
  --set-env-vars "PROJECT_ID=$PROJECT_ID"

Crea un indice per Datastore

In questa sezione creerai un indice per Datastore. Questo indice viene utilizzato dal servizio event-publisher per selezionare gli eventi che devono essere pubblicati.

Nel menu Datastore della console Google Cloud, seleziona Modalità Datastore .
Fai clic su Scegli dove archiviare i tuoi dati e seleziona us-east1 come sede. Quindi, fai clic su Crea database.

Crea un indice per Datastore:

cd $HOME/transactional-microservice-examples/services/event-publisher
gcloud datastore indexes create index.yaml --quiet

Nel menu Datastore della console Google Cloud, seleziona Indici e attendi che lo stato dell'indice passi da Indicizzazione a Elaborazione. Questa procedura potrebbe richiedere alcuni minuti.

Crea un account di servizio per richiamare i microservizi su Cloud Run

In Cloud Shell, crea l'account di servizio cloud-run-invoker:

SERVICE_ACCOUNT_NAME="cloud-run-invoker"
SERVICE_ACCOUNT_EMAIL=${SERVICE_ACCOUNT_NAME}@${PROJECT_ID}.iam.gserviceaccount.com
gcloud iam service-accounts create $SERVICE_ACCOUNT_NAME \
  --display-name "Cloud Run Invoker"

Utilizzerai questo account di servizio più avanti in questo tutorial per richiamare le API REST per i microservizi in esecuzione su Cloud Run.

Definisci una pianificazione per chiamare il servizio del publisher dell'evento

In questa sezione definisci una pianificazione per richiamare il publisher di eventi denominato event-publisher a intervalli di un minuto.

In Cloud Shell, assegna il ruolo run.invoker al servizio event publisher.

SERVICE_NAME="event-publisher"
gcloud run services add-iam-policy-binding $SERVICE_NAME \
  --member=serviceAccount:$SERVICE_ACCOUNT_EMAIL \
  --role=roles/run.invoker \
  --platform=managed --region=us-central1

Definisci una pianificazione per chiamare il servizio Event publisher denominato event-publisher a intervalli di un minuto utilizzando l'account di servizio cloud-run-invoker:

SERVICE_NAME="event-publisher"
SERVICE_URL=$(gcloud run services list --platform managed \
  --format="table[no-heading](URL)"
  --filter="SERVICE:${SERVICE_NAME}")
SERVICE_URL="${SERVICE_URL}/api/v1/event/publish"
gcloud scheduler jobs create http event-publisher-scheduler \
  --schedule='* * * * *' \
  --http-method=GET \
  --uri=$SERVICE_URL \
  --oidc-service-account-email=$SERVICE_ACCOUNT_EMAIL \
  --oidc-token-audience=$SERVICE_URL \
  --location=us-central1

Crea argomenti Pub/Sub

In Cloud Shell, crea i seguenti argomenti Pub/Sub:

gcloud pubsub topics create order-service-event
gcloud pubsub topics create customer-service-event

L'argomento order-service-event è utilizzato dal servizio Order e dal servizio event-publisher per pubblicare eventi dal servizio Order. L'argomento customer-service-event viene utilizzato per pubblicare eventi dal servizio Customer.

Definisci un argomento per inviare notifiche di eventi ai microservizi

In questa sezione definirai l'argomento push-subscription per consegnare i messaggi negli argomenti Pub/Sub ai microservizi.

In Cloud Shell, assegna il ruolo iam.serviceAccountTokenCreator all'account di servizio Pub/Sub del progetto:

PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format "value(projectNumber)")
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member=serviceAccount:service-${PROJECT_NUMBER}@gcp-sa-pubsub.iam.gserviceaccount.com \
  --role=roles/iam.serviceAccountTokenCreator

Questo comando consente all'account di servizio di creare un token di accesso per richiamare i microservizi su Cloud Run.

Assegna il ruolo run.invoker al servizio customer-service-async:

SERVICE_NAME="customer-service-async"
gcloud run services add-iam-policy-binding $SERVICE_NAME \
  --member=serviceAccount:$SERVICE_ACCOUNT_EMAIL \
  --role=roles/run.invoker \
  --platform=managed --region=us-central1

Crea un argomento push-subscription:

SERVICE_URL=$(gcloud run services list --platform managed \
  --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")
SERVICE_URL="${SERVICE_URL}/api/v1/customer/pubsub"
gcloud pubsub subscriptions create push-order-to-customer \
  --topic order-service-event \
  --push-endpoint=$SERVICE_URL \
  --push-auth-service-account=$SERVICE_ACCOUNT_EMAIL

Questo argomento consegna i messaggi dell'argomento order-service-event al servizio Customer utilizzando l'account di servizio cloud-run-invoker.

Assegna il ruolo run.invoker al servizio order-service-async:

SERVICE_NAME="order-service-async"
gcloud run services add-iam-policy-binding $SERVICE_NAME \
  --member=serviceAccount:$SERVICE_ACCOUNT_EMAIL \
  --role=roles/run.invoker \
  --platform=managed --region=us-central1

Crea un argomento push-subscription:

SERVICE_URL=$(gcloud run services list --platform managed \
  --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")
SERVICE_URL="${SERVICE_URL}/api/v1/order/pubsub"
gcloud pubsub subscriptions create push-customer-to-order \
  --topic customer-service-event \
  --push-endpoint=$SERVICE_URL \
  --push-auth-service-account=$SERVICE_ACCOUNT_EMAIL

L'argomento push-subscription consegna i messaggi dell'argomento customer-service-event al servizio Order utilizzando l'account di servizio cloud-run-invoker.

Esegui il deployment dei componenti lato server per un'architettura di orchestrazione sincrona

In questa sezione eseguirai il deployment dei componenti lato server per l'applicazione di esempio. Questi componenti implementano un'architettura di orchestrazione sincrona su Cloud Run, nonché un flusso di lavoro eseguito con Workflows.

Crea ed esegui il deployment delle immagini container

In questa sezione creerai immagini container per microservizi e ne eseguirai il deployment in Cloud Run.

In Cloud Shell, crea un'immagine container per il servizio Order denominato order-sync ed eseguine il deployment su Cloud Run:

cd $HOME/transactional-microservice-examples/services/order-sync
gcloud builds submit --tag gcr.io/$PROJECT_ID/order-service-sync
gcloud run deploy order-service-sync \
  --image gcr.io/$PROJECT_ID/order-service-sync \
  --platform=managed --region=us-central1 \
  --no-allow-unauthenticated

Crea un'immagine container per il servizio Customer denominato customer-sync ed eseguine il deployment in Cloud Run:

cd $HOME/transactional-microservice-examples/services/customer-sync
gcloud builds submit --tag gcr.io/$PROJECT_ID/customer-service-sync
gcloud run deploy customer-service-sync \
  --image gcr.io/$PROJECT_ID/customer-service-sync \
  --platform=managed --region=us-central1 \
  --no-allow-unauthenticated

Crea un'immagine container per il servizio processore Order denominato order-processor ed eseguine il deployment in Cloud Run:

cd $HOME/transactional-microservice-examples/services/order-processor
gcloud builds submit --tag gcr.io/$PROJECT_ID/order-processor-service
gcloud run deploy order-processor-service \
  --image gcr.io/$PROJECT_ID/order-processor-service \
  --platform=managed --region=us-central1 \
  --no-allow-unauthenticated \
  --set-env-vars "PROJECT_ID=$PROJECT_ID"

Crea un account di servizio per richiamare i microservizi su Cloud Run

In questa sezione riutilizzerai l'account di servizio cloud-run-invoker che hai creato in Creare un account di servizio per richiamare i microservizi su Cloud Run.

Esegui il deployment di un flusso di lavoro per l'elaborazione di un ordine

In Cloud Shell, assegna i ruoli run.invoker e run.viewer all'account di servizio cloud-run-invoker per il servizio order-service-sync.

SERVICE_NAME="order-service-sync"
gcloud run services add-iam-policy-binding $SERVICE_NAME \
  --member=serviceAccount:$SERVICE_ACCOUNT_EMAIL \
  --role=roles/run.invoker \
  --platform=managed --region=us-central1
gcloud run services add-iam-policy-binding $SERVICE_NAME \
  --member=serviceAccount:$SERVICE_ACCOUNT_EMAIL \
  --role=roles/run.viewer \
  --platform=managed --region=us-central1

Assegna i ruoli run.invoker e run.viewer all'account di servizio cloud-run-invoker per il servizio customer-service-sync:

SERVICE_NAME="customer-service-sync"
gcloud run services add-iam-policy-binding $SERVICE_NAME \
  --member=serviceAccount:$SERVICE_ACCOUNT_EMAIL \
  --role=roles/run.invoker \
  --platform=managed --region=us-central1
gcloud run services add-iam-policy-binding $SERVICE_NAME \
  --member=serviceAccount:$SERVICE_ACCOUNT_EMAIL \
  --role=roles/run.viewer \
  --platform=managed --region=us-central1

Utilizza l'account di servizio cloud-run-invoker per eseguire il deployment di un flusso di lavoro:

SERVICE_NAME="order-service-sync"
ORDER_SERVICE_URL=$(gcloud run services list --platform managed \
  --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")

SERVICE_NAME="customer-service-sync"
CUSTOMER_SERVICE_URL=$(gcloud run services list --platform managed \
  --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")

cd $HOME/transactional-microservice-examples/services/order-processor
cp order_workflow.yaml.template order_workflow.yaml
sed -i "s#ORDER-SERVICE-URL#${ORDER_SERVICE_URL}#" order_workflow.yaml
sed -i "s#CUSTOMER-SERVICE-URL#${CUSTOMER_SERVICE_URL}#" order_workflow.yaml

gcloud beta workflows deploy order_workflow \
  --source=order_workflow.yaml \
  --service-account=$SERVICE_ACCOUNT_EMAIL

Testa i componenti dell'architettura della saga basati sulla coreografia

In questa sezione testerai i componenti di cui è stato eseguito il deployment nell'architettura della saga basata sulla coreografia utilizzando il comando curl.

In Cloud Shell, imposta variabili di ambiente che fanno riferimento a URL di endpoint API per i microservizi customer-service-async e order-service-async:

SERVICE_NAME="customer-service-async"
CUSTOMER_SERVICE_URL=$(gcloud run services list --platform managed \
  --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")

SERVICE_NAME="order-service-async"
ORDER_SERVICE_URL=$(gcloud run services list --platform managed \
  --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")

Crea una voce cliente

In Cloud Shell, crea un ID cliente denominato customer01 inviando una richiesta API al servizio Customer denominato customer-service-async:

curl -X POST -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
  -H "Content-Type: application/json" \
  -d '{"customer_id":"customer01", "limit":10000}' \
  -s ${CUSTOMER_SERVICE_URL}/api/v1/customer/limit | jq .

L'output è simile al seguente:

{
  "credit": 0,
  "customer_id": "customer01",
  "limit": 10000
}

Invia un ordine

In questa sezione devi inviare un ordine e attivare la relativa assegnazione di ID ordine.

In Cloud Shell, invia un ordine inviando una richiesta API al servizio Order denominato order-service-async:

curl -X POST -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
  -H "Content-Type: application/json" \
  -d '{"customer_id":"customer01", "number":10}' \
  -s ${ORDER_SERVICE_URL}/api/v1/order/create | jq .

In questo caso, ordini 10 articoli specificando quanto segue: "number": 10

L'output è simile al seguente:

{
  "customer_id": "customer01",
  "number": 10,
  "order_id": "720d1305-b6fd-4f57-aaf4-fd2ca5bdfe1e",
  "status": "pending"
}

Il flag "order_id" nell'output mostra l'ID ordine univoco assegnato all'ordine. Copia questo ID perché lo utilizzerai nel passaggio successivo.

Imposta l'ID ordine in una variabile di ambiente:
```
ORDER_ID=ORDER_ID
```
Sostituisci ORDER_ID con il flag "order_id" che hai copiato nel passaggio precedente.

Controllare lo stato di un ordine

In questa sezione puoi verificare come cambia lo stato di un ordine.

In Cloud Shell, ottieni lo stato dell'ordine inviando una richiesta API al servizio Order denominato order-service-async:
```
curl -X POST -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
  -H "Content-Type: application/json" \
  -d "{\"customer_id\":\"customer01\", \"order_id\":\"$ORDER_ID\"}" \
  -s ${ORDER_SERVICE_URL}/api/v1/order/get | jq .
```
L'output è simile al seguente:
```
{
  "customer_id": "customer01",
  "number": 10,
  "order_id": "720d1305-b6fd-4f57-aaf4-fd2ca5bdfe1e",
  "status": "pending"
}
```
Il flag "status" nell'output mostra lo stato dell'ordine. Se il processo transazionale è ancora in esecuzione, lo stato è "pending". In questo caso, attendi qualche minuto e controlla di nuovo lo stato eseguendo lo stesso comando. Al termine della procedura di transazione, lo stato visualizzato sarà "accepted".
Ottieni le informazioni sul cliente per l'ID cliente customer01:
```
curl -X POST -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
  -H "Content-Type: application/json" \
  -d '{"customer_id":"customer01"}' \
  -s ${CUSTOMER_SERVICE_URL}/api/v1/customer/get | jq .
```
L'output è simile al seguente:
```
{
  "credit": 1000,
  "customer_id": "customer01",
  "limit": 10000
}
```
Il flag "credit" mostra l'utilizzo corrente del credito da parte del cliente. Aumenta di 1000 perché la logica di business per questa transazione prevede di aumentare il credito di 100 per un elemento.

Puoi ripetere la procedura dell'ordine ripetendo i passaggi descritti in Inviare un ordine. Se ordini 100 articoli specificando "number": 100, lo stato finale dell'ordine è "rejected" perché il credito utilizzato supera il limite.

Testare i componenti dell'architettura di orchestrazione sincrona

In questa sezione testerai i componenti di cui è stato eseguito il deployment dell'architettura di orchestrazione sincrona utilizzando il comando curl.

In Cloud Shell, imposta le variabili di ambiente che rimandano agli URL per gli endpoint API dei microservizi customer-service-sync, order-service-sync e order-processor-service:

SERVICE_NAME="customer-service-sync"
CUSTOMER_SERVICE_URL=$(gcloud run services list --platform managed \
  --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")

SERVICE_NAME="order-service-sync"
ORDER_SERVICE_URL=$(gcloud run services list --platform managed \
  --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")

SERVICE_NAME="order-processor-service"
ORDER_PROCESSOR_URL=$(gcloud run services list --platform managed \
  --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")

Crea una voce cliente

In Cloud Shell, invia una richiesta API al servizio Customer denominato customer-service-sync per creare un ID cliente denominato customer02:

curl -X POST -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
  -H "Content-Type: application/json" \
  -d '{"customer_id":"customer02", "limit":10000}' \
  -s ${CUSTOMER_SERVICE_URL}/api/v1/customer/limit | jq .

L'output è simile al seguente:

{
  "credit": 0,
  "customer_id": "customer02",
  "limit": 10000
}

Invia un ordine

In questa sezione devi inviare un ordine e verificare il risultato.

In Cloud Shell, invia un ordine inviando una richiesta API al servizio Orderorder-processor-service:
```
curl -X POST -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
  -H "Content-Type: application/json" \
  -d '{"customer_id":"customer02", "number":10}' \
  -s ${ORDER_PROCESSOR_URL}/api/v1/order/process | jq .
```
In questo caso, ordini 10 articoli specificando "number": 10.

L'output è simile al seguente:
```
{
  "customer_id": "customer02",
  "number": 10,
  "order_id": "fb6d5087-dd99-4d5a-84c2-0e381016b9d3",
  "status": "accepted"
}
```
Poiché il flusso di lavoro transazionale viene condotto in modo sincrono, il client vede immediatamente il risultato. In questo caso, lo stato finale è il seguente: "accepted"
Recupera le informazioni sul cliente con l'ID cliente customer02:
```
curl -X POST -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
  -H "Content-Type: application/json" \
  -d '{"customer_id":"customer02"}' \
  -s ${CUSTOMER_SERVICE_URL}/api/v1/customer/get | jq .
```
L'output è simile al seguente:
```
{
  "credit": 1000,
  "customer_id": "customer02",
  "limit": 10000
}
```
L'utilizzo del credito da parte del cliente aumenta di 1000. Per ripetere la procedura di ordinazione, ripeti questi passaggi. Se ordini 100 articoli specificando il valore "number": 100, il cliente ottiene immediatamente il risultato "rejected" perché il credito utilizzato supera il limite.

(Facoltativo) Esegui il deployment di un'applicazione web

In questa sezione, come estensione facoltativa del tutorial, eseguirai il deployment di un'applicazione web di esempio che esegue il flusso di lavoro transazionale sui microservizi di cui hai eseguito il deployment nella sezione precedente. Puoi utilizzare Firebase Hosting per eseguire il deployment di un'applicazione web che interagisce con i microservizi di backend in esecuzione su Cloud Run.

Firebase Hosting dispone di un'integrazione Cloud Run integrata, che consente di ospitare l'applicazione web e i servizi di microservizi di backend nello stesso dominio. In altri tipi di deployment, potrebbero verificarsi problemi di condivisione delle risorse tra origini (CORS). Per maggiori informazioni, consulta Autenticazione degli utenti finali.

Integrazione di applicazioni web.

L'integrazione di Firebase Hosting esegue quanto segue:

Ospita asset statici per l'applicazione web.
Reindirizza l'accesso alle API ai seguenti servizi di backend su Cloud Run:
- Da /customer-service-sync/* a customer-service-sync
- Da /customer-service-async/* a customer-service-async
- Da /order-service-sync/* a order-service-sync
- Da /order-service-async/* a order-service-async
- Da /order-processor-service/* a order-processor-service
Restituisce asset statici dell'applicazione web.

Configura Firebase

In questa sezione, imposterai Firebase per ospitare l'applicazione web su Firebase Hosting.

In Cloud Shell, aggiorna Node.js all'ultima versione LTS per utilizzare l'interfaccia a riga di comando di Firebase:
```
nvm install lts/gallium
```
Aggiungi risorse Firebase al progetto Google Cloud esistente:
```
firebase projects:addfirebase $PROJECT_ID
```

Aggiungi un alias di progetto predefinito per l'interfaccia a riga di comando di Firebase:

jq -n --arg project_id $PROJECT_ID \
  '{"projects": {"default":$project_id}}' > \
  $HOME/transactional-microservice-examples/frontend/.firebaserc

Esegui il deployment dell'applicazione web

In questa sezione eseguirai il deployment dell'applicazione web su Firebase Hosting.

In Cloud Shell, crea l'applicazione frontend web:

cd $HOME/transactional-microservice-examples/frontend
yarn install && yarn build

Esegui il deployment dell'applicazione web su Firebase Hosting:
```
firebase deploy
```

Utilizzare l'applicazione web

Inserisci nel browser l'URL di hosting che hai copiato nella sezione precedente. Vedrai la home page dell'applicazione web.

Inizializzare l'applicazione web con un token di identità

In questa sezione inizializza l'applicazione web con il tuo token di identità e vai alla pagina Shopping.

In Cloud Shell, stampa il token di identità:
```
gcloud auth print-identity-token
```
Copia l'output del comando precedente e incollalo nella casella di testo.
Fai clic su Procedi. Se il token di identità è valido, verrà visualizzata la pagina Shopping.

Aggiungere articoli a un carrello

Nell'applicazione web, fai clic su Aggiungi al carrello per aggiungere articoli al carrello.

Controllare gli articoli di un carrello

Nell'applicazione web, fai clic sull'icona del carrello nella barra di navigazione per andare alla pagina Pagamento. Vedi articoli nel carrello.

Inviare un ordine utilizzando il servizio asincrono

Nell'applicazione web, fai clic sull'icona del carrello degli acquisti nella barra di navigazione per andare alla pagina Pagamento.
Fai clic su Invia ordine (asinc). Se l'ordine è stato inviato correttamente, verrà visualizzata la pagina Cronologia ordini.

Inviare un ordine utilizzando il servizio sincrono

Nell'applicazione web, fai clic sull'icona del carrello degli acquisti sulla barra di navigazione per andare alla pagina Pagamento.
Fai clic su Invia ordine (sincronizzazione). Se l'ordine è stato inviato correttamente, verrà visualizzata la pagina Cronologia ordini.

Controllare la cronologia ordini

Nell'applicazione web, fai clic su Ordini nella barra di navigazione per andare alla pagina Cronologia ordini.

Aggiornare lo stato di un ordine incompleto

Nell'applicazione web, fai clic su Ordini nella barra di navigazione per andare alla pagina Cronologia ordini.
Fai clic sull'icona di aggiornamento per un singolo ordine. L'icona viene visualizzata solo se l'ordine viene elaborato in modo asincrono e lo stato è pending.

Verificare il budget attuale di un cliente

Nell'applicazione web, fai clic sul nome del cliente (numero-cliente) sulla barra di navigazione per andare alla pagina del suo profilo.

Navigazione al profilo del cliente.

Reimposta lo stato nell'applicazione web

Ricarica l'applicazione web nel browser. Gli stati come gli articoli nel carrello, la cronologia degli ordini e i dati del cliente vengono reimpostati e il sistema ti reindirizza alla home page.

Esegui la pulizia

Per evitare che al tuo Account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

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 singole risorse

In questa sezione eliminerai le singole risorse che utilizzi in questo tutorial.

Disattiva Firebase Hosting

In Cloud Shell, esegui questo comando per interrompere la gestione del traffico di Firebase Hosting:
```
 firebase hosting:disable -f
```

Elimina servizi su Cloud Run

In Cloud Shell, elimina i servizi su Cloud Run:

gcloud run services delete order-service-async \
  --platform=managed --region=us-central1 --quiet

gcloud run services delete customer-service-async \
  --platform=managed --region=us-central1 --quiet

gcloud run services delete order-service-sync \
  --platform=managed --region=us-central1 --quiet

gcloud run services delete customer-service-sync \
  --platform=managed --region=us-central1 --quiet

gcloud run services delete order-processor-service \
  --platform=managed --region=us-central1 --quiet

gcloud run services delete event-publisher \
  --platform=managed --region=us-central1 --quiet

Elimina le immagini container utilizzate da Cloud Run

In Cloud Shell, elimina le immagini container che hai creato per questo tutorial:

gcloud container images delete \
  gcr.io/$PROJECT_ID/order-service-async --force-delete-tags --quiet
gcloud container images delete \
  gcr.io/$PROJECT_ID/customer-service-async --force-delete-tags --quiet
gcloud container images delete \
  gcr.io/$PROJECT_ID/event-publisher --force-delete-tags --quiet
gcloud container images delete \
  gcr.io/$PROJECT_ID/order-service-sync --force-delete-tags --quiet
gcloud container images delete \
  gcr.io/$PROJECT_ID/customer-service-sync --force-delete-tags --quiet
gcloud container images delete \
  gcr.io/$PROJECT_ID/order-processor-service --force-delete-tags --quiet

Eliminazione del flusso di lavoro

In Cloud Shell, elimina il flusso di lavoro:

gcloud beta workflows delete order_workflow --quiet

Elimina sottoscrizioni e argomenti Pub/Sub

In Cloud Shell, elimina le sottoscrizioni Pub/Sub:

gcloud pubsub subscriptions delete push-customer-to-order --quiet
gcloud pubsub subscriptions delete push-order-to-customer --quiet

Elimina gli argomenti Pub/Sub:

gcloud pubsub topics delete order-service-event --quiet
gcloud pubsub topics delete customer-service-event --quiet

Elimina record da Datastore

Nel menu Datastore della console Google Cloud, apri Entità.
Seleziona tutte le entità nel campo Customer.
Fai clic su Elimina e poi su Conferma per eliminare definitivamente le entità.
Ripetere i passaggi 2 e 3 di questa procedura per i campi seguenti:
1. Event
2. Order
3. ProcessedEvent

Elimina il job su Cloud Scheduler

In Cloud Shell, elimina il job in esecuzione su Cloud Scheduler:

gcloud scheduler jobs delete event-publisher-scheduler --quiet \
  --location=us-central1

Elimina l'account di servizio

In Cloud Shell, elimina l'account di servizio:

gcloud iam service-accounts delete $SERVICE_ACCOUNT_EMAIL --quiet

Elimina asset tutorial

In Cloud Shell, elimina gli asset che utilizzi per questo tutorial:
```
cd $HOME
rm -rf transactional-microservice-examples
```

Passaggi successivi

Leggi le seguenti serie per saperne di più sulla progettazione, la creazione e il deployment di microservizi:
Scopri i vantaggi e le sfide sia dei monoliti che dei microservizi
Scopri come definire i confini dei servizi ed eseguire il refactoring dei monoliti.
Scopri come distribuire le transazioni tra microservizi
Scopri come configurare il tracciamento distribuito in un ambiente poliglotta
Scopri come implementare mesh di servizi in un'architettura di microservizi
Per ulteriori architetture di riferimento, diagrammi e best practice, esplora il Cloud Architecture Center.