Déployer un exemple d'application de workflows transactionnels dans une architecture de microservices sur Google Cloud

---

Ce document explique comment déployer un exemple d'application à l'aide de Cloud Run, Pub/Sub, Workflows et Firestore en mode Datastore (Datastore). Il est destiné aux développeurs d'applications qui souhaitent mettre en œuvre des workflows transactionnels dans une application basée sur des microservices.

Ce document fait partie d'une série composée des éléments suivants :

• Workflows transactionnels dans une architecture de microservices sur Google Cloud : présentation de l'exemple d'application de workflows transactionnels que vous déployez dans ce tutoriel.
• Déployer un exemple d'application de workflows transactionnels dans une architecture de microservices sur Google Cloud (ce document).

L'exemple d'application que vous déployez dans ce tutoriel implémente des microservices pour deux modèles architecturaux :

• Un modèle Saga basé sur la chorégraphie
• Un modèle d'orchestration synchrone

L'application contient un client Web. Vous pouvez tester ces deux modèles depuis Google Cloud CLI et le client Web.

Objectifs

• Déployer des composants côté serveur pour l'architecture Saga basée sur la chorégraphie
• Déployer des composants côté serveur pour l'architecture d'orchestration synchrone
• Tester les composants côté serveur avec la commande curl
• Déployer une application Web et exécuter des workflows via celle-ci

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

• Cloud Run
• Datastore
• Pub/Sub
• Workflows
• Cloud Scheduler
• Cloud Build
• Firebase

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

1. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

   Remarque : Si vous ne comptez pas conserver les ressources créées dans cette procédure, créez un projet au lieu de sélectionner un projet existant. Après avoir suivi ces étapes, vous pouvez supprimer le projet. Cela entraîne la suppression de toutes les ressources qui lui sont associées.

   Accéder au sélecteur de projet

2. Vérifiez que la facturation est activée pour votre projet Google Cloud.

3. Activer les API Cloud Services, Cloud Run, Workflows, Cloud Build, and Cloud Scheduler.

   Activer les API

Cloner le code source

Dans cette section, vous définissez l'ID de votre projet et clonez le code source dans Cloud Shell.

1. Dans Cloud Shell, définissez l'ID de votre projet :

   PROJECT_ID=PROJECT_ID
   

   Remplacez PROJECT_ID par l'ID du projet Google Cloud que vous avez créé précédemment.

2. Définissez l'ID du projet :

   gcloud config set project $PROJECT_ID
   

3. Clonez le dépôt du tutoriel :

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

Déployer des composants côté serveur pour des architectures Saga basées sur la chorégraphie

Dans cette section, vous allez déployer des composants côté serveur de l'exemple d'application. L'application met en œuvre des architectures Saga basées sur la chorégraphie, telles que des microservices sur Cloud Run, des programmations de publication d'événements sur Cloud Scheduler et des sujets Pub/Sub.

Créer et déployer des images de conteneurs

1. Dans Cloud Shell, créez une image de conteneur pour le service Order nommé order-async, puis déployez-la sur 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
   

2. Créez une image de conteneur pour le service Customer nommé customer-async, puis déployez-la sur 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
   

3. Créez une image de conteneur pour le service event-publisher, puis déployez-la sur 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"
   

Créer un index pour Datastore

Dans cette section, vous allez créer un index pour Datastore. Cet index est utilisé par le service event-publisher pour sélectionner les événements qui doivent être publiés.

1. Dans la console Google Cloud, dans le menu Datastore, sélectionnez Mode Datastore.

2. Cliquez sur Choisir où stocker de vos données, puis sélectionnez us-east1 comme emplacement. Cliquez ensuite sur Créer une base de données.

3. Créez un index pour Datastore :

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

4. Dans la console Google Cloud, dans le menu Datastore, sélectionnez Index et attendez que l'état de l'index passe d'Indexation à Diffusion. Ce processus peut prendre quelques minutes.

Créer un compte de service pour appeler des microservices sur Cloud Run

• Dans Cloud Shell, créez le compte de service 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"
  

  Vous utiliserez ce compte de service ultérieurement dans ce tutoriel pour appeler les API REST pour les microservices exécutés sur Cloud Run.

Définir une programmation pour appeler le service d'éditeur d'événements

Dans cette section, vous allez définir une programmation pour appeler l'éditeur d'événements nommé event-publisher à intervalles d'une minute.

1. Dans Cloud Shell, attribuez le rôle run.invoker au service 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
   

2. Définissez une programmation pour appeler le service Event publisher nommé event-publisher à intervalles d'une minute à l'aide du compte de service 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
   

Créer des sujets Pub/Sub

• Dans Cloud Shell, créez les sujets Pub/Sub suivants :

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

Le sujet order-service-event est utilisé par le service Order et le service event-publisher pour publier des événements à partir du service Order. Le sujet customer-service-event permet de publier des événements à partir du service Customer.

Définir un sujet pour envoyer des notifications d'événement à des microservices

Dans cette section, vous allez définir le sujet push-subscription pour envoyer les messages dans les sujets Pub/Sub aux microservices.

1. Dans Cloud Shell, attribuez le rôle iam.serviceAccountTokenCreator au compte de service Pub/Sub du projet :

   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
   

   Cette commande permet au compte de service de créer un jeton d'accès pour appeler des microservices sur Cloud Run.

2. Attribuez le rôle run.invoker au service 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
   

3. Créez un sujet 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
   

   Ce sujet envoie les messages dans le sujet order-service-event au service Customer à l'aide du compte de service cloud-run-invoker.

4. Attribuez le rôle run.invoker au service 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
   

5. Créez un sujet 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
   

   Le sujet push-subscription envoie les messages du sujet customer-service-event au service Order à l'aide du compte de service cloud-run-invoker.

Déployer des composants côté serveur pour une architecture d'orchestration synchrone

Dans cette section, vous allez déployer les composants côté serveur pour l'exemple d'application. Ces composants mettent en œuvre une architecture d'orchestration synchrone sur Cloud Run, ainsi qu'un workflow qui est exécuté avec Workflows.

Créer et déployer des images de conteneurs

Dans cette section, vous allez créer des images de conteneurs pour des microservices et les déployer sur Cloud Run.

1. Dans Cloud Shell, créez une image de conteneur pour le service Order nommé order-sync, puis déployez-la sur 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
   

2. Créez une image de conteneur pour le service Customer nommé customer-sync, puis déployez-la sur 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
   

3. Créez une image de conteneur pour le service de processeur Order nommé order-processor, puis déployez-la sur 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"
   

Créer un compte de service pour appeler des microservices sur Cloud Run

Dans cette section, vous allez réutiliser le compte de service cloud-run-invoker que vous avez créé dans la section Créer un compte de service pour appeler des microservices sur Cloud Run.

Déployer un workflow pour traiter une commande

1. Dans Cloud Shell, attribuez les rôles run.invoker et run.viewer au compte de service cloud-run-invoker pour le service 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
   

2. Attribuez les rôles run.invoker et run.viewer au compte de service cloud-run-invoker pour le service 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
   

3. Utilisez le compte de service cloud-run-invoker pour déployer un workflow :

   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
   

Tester les composants de l'architecture Saga basée sur la chorégraphie

Dans cette section, vous allez tester les composants déployés sur l'architecture Saga basée sur la chorégraphie à l'aide de la commande curl.

• Dans Cloud Shell, définissez des variables d'environnement qui pointent vers des URL de points de terminaison d'API pour les microservices customer-service-async et 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}")
  

Créer une entrée client

• Dans Cloud Shell, créez un ID client nommé customer01 en envoyant une requête API au service Customer nommé 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 .
  

  Le résultat ressemble à ce qui suit :

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

Envoyer une commande

Dans cette section, vous allez envoyer une commande et déclencher une attribution d'ID de commande pour celle-ci.

1. Dans Cloud Shell, exécutez une commande en envoyant une requête API au service Order nommé 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 .
   

   Dans ce cas, vous commandez 10 articles en spécifiant la valeur suivante : "number": 10

   Le résultat ressemble à ce qui suit :

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

   L'option "order_id" dans la sortie affiche l'ID de commande unique qui est attribué à la commande. Copiez cet ID, car vous l'utiliserez à l'étape suivante.

2. Définissez l'ID de commande dans une variable d'environnement :

   ORDER_ID=ORDER_ID
   

   Remplacez ORDER_ID par l'option "order_id" que vous avez copiée à l'étape précédente.

Vérifier l'état d'une commande

Dans cette section, vous allez vérifier l'évolution de l'état d'une commande.

1. Dans Cloud Shell, obtenez l'état de la commande en envoyant une requête API au service Order nommé 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 .
   

   Le résultat se présente comme suit :

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

   L'option "status" dans la sortie indique l'état de la commande. Si le processus transactionnel est toujours en cours d'exécution, l'état est "pending". Dans ce cas, attendez quelques minutes et vérifiez à nouveau l'état en exécutant la même commande. Une fois le processus transactionnel terminé, l'état indique "accepted".

2. Obtenez des informations sur le client pour l'ID client 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 .
   

   Le résultat se présente comme suit :

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

   L'option "credit" indique l'utilisation actuelle du crédit du client. Il augmente de 1 000, car la logique métier de cette transaction consiste à augmenter le crédit de 100 pour un article.

   Vous pouvez répéter le processus de commande en répétant les étapes de la section Envoyer une commande. Si vous commandez 100 articles en spécifiant "number": 100, l'état final de la commande est "rejected", car l'utilisation du crédit dépasse la limite.

Tester les composants de l'architecture d'orchestration synchrone

Dans cette section, vous allez tester les composants déployés de l'architecture d'orchestration synchrone à l'aide de la commande curl.

• Dans Cloud Shell, définissez les variables d'environnement qui pointent vers les URL des points de terminaison d'API des microservices customer-service-sync, order-service-sync et 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}")
  

Créer une entrée client

• Dans Cloud Shell, envoyez une requête API au service Customer nommé customer-service-sync pour créer un ID client nommé 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 .
  

  Le résultat se présente comme suit :

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

Envoyer une commande

Dans cette section, vous allez envoyer une commande et vérifier le résultat.

1. Dans Cloud Shell, exécutez une commande en envoyant une requête API au service Order nommé order-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 .
   

   Dans ce cas, vous commandez 10 articles en spécifiant "number": 10.

   Le résultat ressemble à ce qui suit :

   {
     "customer_id": "customer02",
     "number": 10,
     "order_id": "fb6d5087-dd99-4d5a-84c2-0e381016b9d3",
     "status": "accepted"
   }
   

   Comme le workflow transactionnel est effectué de manière synchrone, le client voit immédiatement le résultat. Dans ce cas, l'état final est le suivant : "accepted"

2. Obtenez les informations sur le client avec l'ID client de 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 .
   

   Le résultat ressemble à ce qui suit :

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

   L'utilisation du crédit du client augmente de 1 000. Pour répéter le processus de commande, répétez ces étapes. Si vous commandez 100 articles en spécifiant la valeur "number": 100, le client obtient immédiatement le résultat "rejected", car l'utilisation du crédit dépasse la limite.

Facultatif : Déployer une application Web

Dans cette section, en tant qu'extension facultative du tutoriel, vous allez déployer un exemple d'application Web qui exécute le workflow transactionnel en plus des microservices que vous avez déployés dans la section précédente. Vous utilisez Firebase Hosting pour déployer une application Web qui interagit avec des microservices de backend exécutés sur Cloud Run.

Firebase Hosting dispose d'une intégration à Cloud Run, ce qui vous permet d'héberger les services de l'application Web et des microservices de backend dans le même domaine. Dans d'autres types de déploiements, vous pouvez rencontrer des problèmes de Cross-Origin Resource Sharing (CORS). Pour en savoir plus, consultez la page Authentifier les utilisateurs finaux.

L'intégration de Firebase Hosting effectue les opérations suivantes :

• Elle héberge les éléments statiques de l'application Web.
• Elle redirige l'accès aux API vers les services de backend suivants sur Cloud Run :
  • De /customer-service-sync/* à customer-service-sync
  • De /customer-service-async/* à customer-service-async
  • De /order-service-sync/* à order-service-sync
  • De /order-service-async/* à order-service-async
  • De /order-processor-service/* à order-processor-service
• Elle renvoie les éléments statiques de l'application Web.

Configurer Firebase

Dans cette section, vous allez configurer Firebase pour héberger l'application Web sur Firebase Hosting.

1. Dans Cloud Shell, mettez à jour Node.js vers la dernière version LTS pour utiliser la CLI Firebase :

   nvm install lts/gallium
   

2. Ajoutez des ressources Firebase au projet Google Cloud existant :

   firebase projects:addfirebase $PROJECT_ID
   

3. Ajoutez un alias de projet par défaut pour la CLI Firebase :

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

Déployer l'application Web

Dans cette section, vous allez déployer l'application Web sur Firebase Hosting.

1. Dans Cloud Shell, créez l'application d'interface Web :

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

2. Déployez l'application Web sur Firebase Hosting :

   firebase deploy
   

Utiliser l'application Web

• Dans votre navigateur, saisissez l'URL d'hébergement que vous avez copiée dans la section précédente. La page d'accueil de l'application Web s'affiche.

Initialiser l'application Web avec un jeton d'identité

Dans cette section, vous allez initialiser l'application Web avec votre jeton d'identité et accéder à la page Shopping.

1. Dans Cloud Shell, imprimez le jeton d'identité :

   gcloud auth print-identity-token
   

2. Copiez la sortie de la commande précédente et collez-la dans la zone de texte.

3. Cliquez sur Continuer. Vous êtes redirigé vers la page Shopping si le jeton d'identité est valide.

Ajouter des articles à un panier

• Dans l'application Web, cliquez sur Ajouter au panier pour ajouter des articles à un panier.

Vérifier les articles d'un panier

• Dans l'application Web, cliquez sur l'icône du panier dans la barre de navigation pour accéder à la page Règlement. Des articles s'affichent dans le panier.

Envoyer une commande à l'aide du service asynchrone

1. Dans l'application Web, cliquez sur l'icône du panier dans la barre de navigation pour accéder à la page Règlement.
2. Cliquez sur Envoyer la commande (asynchrone). Vous êtes redirigé vers la page Historique des commandes si la commande a bien été envoyée.

Envoyer une commande à l'aide du service synchrone

1. Dans l'application Web, cliquez sur l'icône du panier dans la barre de navigation pour accéder à la page Règlement.
2. Cliquez sur Envoyer la commande (synchrone). Vous serez redirigé vers la page Historique des commandes si la commande a bien été envoyée.

Vérifier l'historique des commandes

• Dans l'application Web, cliquez sur Commandes dans la barre de navigation pour accéder à la page Historique des commandes.

Mettre à jour l'état d'une commande incomplète

1. Dans l'application Web, cliquez sur Commandes dans la barre de navigation pour accéder à la page Historique des commandes.
2. Cliquez sur l'icône d'actualisation d'une commande individuelle. L'icône ne s'affiche que si la commande est traitée de manière asynchrone et que l'état est pending.

Vérifier le budget actuel d'un client

• Dans l'application Web, cliquez sur le nom du client (customer-nombre) dans la barre de navigation pour accéder à sa page de profil.

Réinitialiser l'état dans l'application Web

• Dans votre navigateur, actualisez l'application Web. Les états tels que les articles dans le panier, l'historique des commandes et les informations client sont réinitialisés, et vous êtes redirigé vers la page d'accueil.

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Attention : La suppression d'un projet aura les effets suivants :

• Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches de ce document, lorsque vous le supprimez, vous supprimez également tout autre travail effectué dans le projet.
• Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

1. Dans la console Google Cloud, accédez à la page Gérer les ressources.

   Accéder à la page Gérer les ressources

2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Supprimer des ressources individuelles

Dans cette section, vous allez supprimer les ressources individuelles que vous avez utilisées dans ce tutoriel.

Désactiver Firebase Hosting

• Dans Cloud Shell, exécutez la commande suivante pour cesser de diffuser le trafic Firebase Hosting :

   firebase hosting:disable -f
  

Supprimer les services sur Cloud Run

• Dans Cloud Shell, supprimez les services sur 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
  

Supprimer les images de conteneurs utilisées par Cloud Run

• Dans Cloud Shell, supprimez les images de conteneur que vous avez créées pour ce tutoriel :

  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
  

Supprimer le workflow

• Dans Cloud Shell, supprimez le workflow :

  gcloud beta workflows delete order_workflow --quiet
  

Supprimer les abonnements et les sujets Pub/Sub

1. Dans Cloud Shell, supprimez les abonnements Pub/Sub :

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

2. Supprimez les sujets Pub/Sub :

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

Supprimer les enregistrements de Datastore

1. Dans le menu Datastore de la console Google Cloud, ouvrez la page Entités.
2. Vérifiez toutes les entités dans le champ Customer.
3. Cliquez sur Supprimer, puis sur Confirmer pour supprimer définitivement les entités.
4. Répétez les étapes 2 et 3 de cette procédure pour les champs suivants :
   1. Event
   2. Order
   3. ProcessedEvent

Supprimer la tâche sur Cloud Scheduler

• Dans Cloud Shell, supprimez la tâche en cours d'exécution sur Cloud Scheduler :

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

Supprimer le compte de service

• Dans Cloud Shell, supprimez le compte de service :

  gcloud iam service-accounts delete $SERVICE_ACCOUNT_EMAIL --quiet
  

Supprimer les éléments du tutoriel

• Dans Cloud Shell, supprimez les éléments que vous avez utilisés pour ce tutoriel :

  cd $HOME
  rm -rf transactional-microservice-examples
  

Étapes suivantes

• Consultez la série suivante pour en savoir plus sur la conception, la création et le déploiement de microservices :
  • Présentation des microservices
  • Refactoriser un monolithe en microservices
  • Communication interservices dans une configuration à microservices
  • Traçage distribué dans une application à microservices
• Découvrez les avantages et les défis des monolithes et des microservices.
• Découvrez comment définir des limites de service et refactoriser des monolithes.
• Découvrez comment répartir des transactions entre les microservices.
• Apprenez à configurer un traçage distribué dans un environnement polyglotte.
• Découvrez comment mettre en œuvre des maillages de services dans une architecture de microservices.
• Pour découvrir d'autres architectures de référence, schémas et bonnes pratiques, consultez le Centre d'architecture cloud.