Microservice Rainbow Rumpus

1. Introduction

Dernière mise à jour : 06/05/2021

Microservice Rainbow Rumpus

Avez-vous déjà participé à une bataille de boules de neige où vous vous déplacez et lancez des boules de neige sur les autres joueurs ? Si ce n'est pas le cas, essayez-le un jour ! Mais au lieu de risquer de vous faire mal, vous pouvez créer un petit service accessible sur le réseau (un microservice) qui participera à une bataille épique contre d'autres microservices, en lançant des arcs-en-ciel au lieu de boules de neige.

Vous vous demandez peut-être... Mais comment un microservice peut-il "lancer" un arc-en-ciel à d'autres microservices ? Un microservice peut recevoir des requêtes réseau (généralement via HTTP) et renvoyer des réponses. Un "gestionnaire d'arène" envoie à votre microservice l'état actuel de l'arène, puis votre microservice répond avec une commande spécifiant ce qu'il faut faire.

Bien sûr, l'objectif est de gagner, mais vous apprendrez également à créer et à déployer des microservices sur Google Cloud.

Fonctionnement

Vous allez créer un microservice avec la technologie de votre choix (ou choisir parmi les starters Go, Java, Kotlin, Scala, NodeJS ou Python), puis le déployer sur Google Cloud. Une fois déployé, vous nous indiquerez l'URL de votre microservice, que nous ajouterons ensuite à l'arène.

L'arène contient tous les joueurs d'une même bataille. Le Rainbow Rumpus aura ses propres arènes. Chaque joueur représente un microservice qui se déplace et lance des arcs-en-ciel sur les autres joueurs.

Environ une fois par seconde, notre gestionnaire d'arène appellera votre microservice, en envoyant l'état actuel de l'arène (où se trouvent les joueurs). Votre microservice répondra avec une commande indiquant ce qu'il faut faire. Dans l'arène, vous pouvez avancer, tourner à gauche ou à droite, ou lancer un arc-en-ciel. Un arc-en-ciel se déplace d'au maximum trois cases dans la direction à laquelle le joueur fait face. Si l'arc-en-ciel "touche" un autre joueur, celui qui l'a lancé gagne un point et le joueur touché en perd un. La taille de l'arène s'ajuste automatiquement au nombre actuel de joueurs.

Voici à quoi ressemble une ancienne arène :

20628e6bd442bd11.png

Exemple d'arène de la première bataille

Conflits récurrents

Dans l'arène, il est possible que plusieurs joueurs tentent d'effectuer des actions conflictuelles. Par exemple, deux joueurs peuvent essayer de se déplacer vers le même espace. En cas de conflit, le microservice avec le temps de réponse le plus rapide l'emporte.

Regarder la bataille

Pour voir comment votre microservice se comporte dans la bataille, consultez l'arène en direct !

API Battle

Pour fonctionner avec notre gestionnaire d'arène, votre microservice devra implémenter une API spécifique pour participer à l'arène. Le gestionnaire d'arène enverra l'état actuel de l'arène dans une requête HTTP POST à l'URL que vous nous fournissez, avec la structure JSON suivante :

{
  "_links": {
    "self": {
      "href": "https://YOUR_SERVICE_URL"
    }
  },
  "arena": {
    "dims": [4,3], // width, height
    "state": {
      "https://A_PLAYERS_URL": {
        "x": 0, // zero-based x position, where 0 = left
        "y": 0, // zero-based y position, where 0 = top
        "direction": "N", // N = North, W = West, S = South, E = East
        "wasHit": false,
        "score": 0
      }
      ... // also you and the other players
    }
  }
}

Votre réponse HTTP doit être le code d'état 200 (OK) avec un corps de réponse contenant votre prochain coup, encodé sous la forme d'un seul caractère majuscule parmi les suivants :

F <- move Forward
R <- turn Right
L <- turn Left
T <- Throw

Le plus important ! Déployons un microservice sur Cloud Run, un service Google Cloud permettant d'exécuter des microservices et d'autres applications.

2. Se connecter à Google Cloud

Pour pouvoir déployer votre microservice sur Cloud Run, vous devez vous connecter à Google Cloud. Nous appliquerons un avoir à votre compte et vous n'aurez pas besoin de saisir de carte de crédit. Il est généralement moins problématique d'utiliser un compte personnel (par exemple, gmail.com) plutôt qu'un compte Google Workspace, car les administrateurs Google Workspace empêchent parfois leurs utilisateurs d'utiliser certaines fonctionnalités Google Cloud. De plus, la console Web que nous allons utiliser devrait fonctionner parfaitement avec Chrome ou Firefox, mais peut rencontrer des problèmes avec Safari.

3. Déployer votre microservice

Vous pouvez créer votre microservice avec n'importe quelle technologie et le déployer n'importe où, à condition qu'il soit accessible publiquement et conforme à l'API Battle. Toutefois, pour vous faciliter la tâche, nous vous aiderons à partir d'un exemple de service et à le déployer sur Cloud Run.

Choisir un échantillon pour commencer

Vous pouvez vous appuyer sur de nombreux exemples de microservices de combat :

Kotlin et Spring Boot

Source

Kotlin et Micronaut

Source

Kotlin et Quarkus

Source

Java et Spring Boot

Source

Java et Quarkus

Source

Go

Source

Node.js et Express

Source

Python et Flask

Source

Une fois que vous avez choisi l'exemple avec lequel commencer, cliquez sur le bouton "Deploy on Cloud Run" (Déployer sur Cloud Run) ci-dessus. Cela lancera Cloud Shell (une console Web pour une machine virtuelle dans le cloud) où la source sera clonée, puis intégrée dans un package déployable (une image de conteneur Docker), qui sera ensuite importé dans Google Container Registry, puis déployé sur Cloud Run.

Lorsque vous y êtes invité, spécifiez la région us-central1.

La capture d'écran ci-dessous montre la sortie Cloud Shell pour la compilation et le déploiement de microservices.

d88e40430706a32b.png

Vérifier que le microservice fonctionne

Dans Cloud Shell, vous pouvez envoyer une requête à votre microservice nouvellement déployé, en remplaçant YOUR_SERVICE_URL par l'URL de votre service (qui se trouve dans Cloud Shell après la ligne "Votre application est désormais en ligne ici") :

curl -d '{
  "_links": {
    "self": {
      "href": "https://foo.com"
    }
  },
  "arena": {
    "dims": [4,3],
    "state": {
      "https://foo.com": {
        "x": 0,
        "y": 0,
        "direction": "N",
        "wasHit": false,
        "score": 0
      }
    }
  }
}' -H "Content-Type: application/json" -X POST -w "\n" \
  https://YOUR_SERVICE_URL

Vous devriez voir la chaîne de réponse F, L, R ou T.

4. Demander à être inclus dans l'Arène

Pour rejoindre le Rainbow Rumpus, vous devez rejoindre une arène. Ouvrez rainbowrumpus.dev, puis cliquez sur "Join" (Rejoindre) dans une arène où vous fournirez l'URL de votre microservice.

5. Apporter et déployer des modifications

Avant de pouvoir apporter des modifications, vous devez configurer certaines informations dans Cloud Shell concernant le projet GCP et l'exemple que vous avez utilisé. Commencez par lister vos projets GCP :

gcloud projects list

Vous n'avez probablement qu'un seul projet. Copiez PROJECT_ID depuis la première colonne et collez-le dans la commande suivante (en remplaçant YOUR_PROJECT_ID par votre ID de projet réel) afin de définir une variable d'environnement que nous utiliserons dans les commandes ultérieures :

export PROJECT_ID=YOUR_PROJECT_ID

Définissez maintenant une autre variable d'environnement pour l'exemple que vous avez utilisé afin de pouvoir spécifier le répertoire et le nom de service corrects dans les commandes ultérieures :

# Copy and paste ONLY ONE of these
export SAMPLE=kotlin-micronaut
export SAMPLE=kotlin-quarkus
export SAMPLE=kotlin-springboot
export SAMPLE=java-quarkus
export SAMPLE=java-springboot
export SAMPLE=go
export SAMPLE=nodejs
export SAMPLE=python

Vous pouvez maintenant modifier la source de votre microservice dans Cloud Shell. Pour ouvrir l'éditeur Web Cloud Shell, exécutez la commande suivante :

cloudshell edit cloudbowl-microservice-game/samples/$SAMPLE/README.md

Vous verrez alors d'autres instructions pour effectuer des modifications.

f910c9ef7b51c406.png

Cloud Shell avec l'éditeur et l'exemple de projet ouvert

Après avoir enregistré vos modifications, démarrez l'application dans Cloud Shell à l'aide de la commande du fichier README.md, mais assurez-vous d'abord de vous trouver dans le bon répertoire d'exemple dans Cloud Shell :

cd cloudbowl-microservice-game/samples/$SAMPLE

Une fois l'application en cours d'exécution, ouvrez un nouvel onglet Cloud Shell et testez le service à l'aide de curl :

curl -d '{
  "_links": {
    "self": {
      "href": "https://foo.com"
    }
  },
  "arena": {
    "dims": [4,3],
    "state": {
      "https://foo.com": {
        "x": 0,
        "y": 0,
        "direction": "N",
        "wasHit": false,
        "score": 0
      }
    }
  }
}' -H "Content-Type: application/json" -X POST -w "\n" \
  http://localhost:8080

Lorsque vous êtes prêt à déployer vos modifications, compilez votre projet dans Cloud Shell à l'aide de la commande pack. Cette commande utilise des buildpacks pour détecter le type de projet, le compiler et créer l'artefact déployable (une image de conteneur Docker).

# Make sure you are in a Cloud Shell tab where you set the PROJECT_ID
# and SAMPLE env vars. Otherwise, set them again.
pack build gcr.io/$PROJECT_ID/$SAMPLE \
  --path ~/cloudbowl-microservice-game/samples/$SAMPLE \
  --builder gcr.io/buildpacks/builder

Maintenant que votre image de conteneur a été créée, utilisez la commande Docker (dans Cloud Shell) pour l'importer dans Google Container Registry afin qu'elle puisse ensuite être accessible par Cloud Run :

docker push gcr.io/$PROJECT_ID/$SAMPLE

Déployez maintenant la nouvelle version sur Cloud Run :

gcloud run deploy $SAMPLE \
          --project=$PROJECT_ID \
          --platform=managed \
          --region=us-central1 \
          --image=gcr.io/$PROJECT_ID/$SAMPLE \
          --allow-unauthenticated

L'arène utilisera désormais votre nouvelle version.

6. Développer localement (facultatif)

Vous pouvez travailler sur votre projet localement à l'aide de votre propre IDE en procédant comme suit :

  1. [Dans Cloud Shell] Compressez l'échantillon :
# Make sure the SAMPLE env var is still set. If not, re-set it.
cd ~/cloudbowl-microservice-game/samples
zip -r cloudbowl-sample.zip $SAMPLE
  1. [Dans Cloud Shell] Téléchargez le fichier ZIP sur votre ordinateur :
cloudshell download-file cloudbowl-sample.zip
  1. [Sur votre machine] Décompressez le fichier, puis apportez et testez vos modifications
  2. [Sur votre machine] Installez la gcloud CLI.
  3. [Sur votre machine] Connectez-vous à Google Cloud :
gcloud auth login
  1. [Sur votre machine] Définissez les variables d'environnement PROJECT_ID et SAMPLE sur les mêmes valeurs que dans Cloud Shell.
  2. [Sur votre machine] Utilisez Cloud Build pour créer le conteneur (à partir du répertoire racine du projet) :
gcloud alpha builds submit . \
  --pack=image=gcr.io/$PROJECT_ID/$SAMPLE \
  --project=$PROJECT_ID
  1. [Sur votre machine] Déployez le nouveau conteneur :
gcloud run deploy $SAMPLE \
  --project=$PROJECT_ID \
  --platform=managed \
  --region=us-central1 \
  --image=gcr.io/$PROJECT_ID/$SAMPLE \
  --allow-unauthenticated

7. Livraison continue

Configurer SCM

Configurez GitHub pour pouvoir collaborer avec votre équipe sur votre microservice :

  1. Se connecter à GitHub
  2. Créer un dépôt
  3. Si vous travaillez sur votre machine locale, vous pouvez utiliser l'interface de ligne de commande (CLI) git ou l'application GUI GitHub Desktop (Windows ou Mac). Si vous utilisez Cloud Shell, vous devrez utiliser la CLI git. Pour obtenir le code de votre microservice sur GitHub, suivez les instructions de l'interface de ligne de commande ou de GitHub Desktop.

Envoyer votre code avec l'interface de ligne de commande Git

  1. Suivez les instructions pour utiliser Git sur HTTPS avec un jeton d'accès personnel.
  2. Choisissez le champ d'application "repo".
  3. Configurez Git :
git config --global credential.helper \
  'cache --timeout=172800'
git config --global push.default current
git config --global user.email "YOUR@EMAIL"
git config --global user.name "YOUR NAME"
  1. Définissez les variables d'environnement pour l'organisation et le dépôt GitHub (https://github.com/ORG/REPO).
export GITHUB_ORG=YOUR_GITHUB_ORG
export GITHUB_REPO=YOUR_GITHUB_REPO
  1. Transférer votre code vers le nouveau dépôt
# Make sure the SAMPLE env var is still set. If not, re-set it.
cd ~/cloudbowl-microservice-game/samples/$SAMPLE
git init
git add .
git commit -m init
git remote add origin https://github.com/$GITHUB_ORG/$GITHUB_REPO.git
git branch -M main

# This will now ask for your GitHub username & password
# for the password use the personal access token
git push -u origin main
  1. Après avoir effectué des modifications, vous pouvez les valider et les déployer sur GitHub :
git add .
git status
git diff --staged
git commit -am "my changes"
git push

Transférer votre code avec GitHub Desktop

  1. Téléchargez votre code en suivant les instructions de l'atelier précédent "Développer en local".
  2. Installez GitHub Desktop, lancez-le et connectez-vous.
  3. Cloner le dépôt que vous venez de créer

cf7f38c7c86a91cd.png

  1. Ouvrez l'explorateur de fichiers et copiez votre projet dans le nouveau dépôt.
  2. Valider vos modifications

5f3c1552e30ad7c5.png

  1. Publier votre branche principale sur GitHub

Configurer le déploiement continu Cloud Run

Une fois votre SCM configuré sur GitHub, vous pouvez configurer la Continuous Delivery afin que Cloud Build compile et déploie automatiquement les modifications chaque fois que de nouveaux commits sont envoyés vers la branche main. Vous pouvez également ajouter l'intégration continue, qui exécute vos tests avant le déploiement. Toutefois, cette étape a été laissée en tant qu'exercice, car les exemples prêts à l'emploi ne contiennent aucun test.

  1. Dans la console Cloud, accédez à votre service Cloud Run.
  2. Cliquez sur le bouton "CONFIGURER LE DÉPLOIEMENT CONTINU".
  3. S'authentifier avec GitHub et sélectionner le dépôt de votre microservice

a3b5692f178869bc.png

  1. Sélectionnez votre dépôt GitHub et définissez la branche sur ^main$.

338f1c00f33d2f65.png

  1. Définir le type de compilation sur "Buildpacks"
  2. Cliquez sur "Enregistrer" pour configurer le déploiement continu.

8. Observabilité

Les choses se cassent. L'observabilité nous permet de savoir quand cela se produit et d'en diagnostiquer la cause. Les métriques nous fournissent des données sur l'état et l'utilisation de notre service. Les journaux nous montrent les informations instrumentées manuellement émises par notre service. Les alertes nous permettent d'être avertis en cas de problème. Examinons chacun d'eux plus en détail.

Métriques

  1. Recherchez votre service dans la liste des services Cloud Run.
  2. Cliquez sur le nom de votre service pour accéder à son tableau de bord des métriques.

8491b8ec6bc5b4db.png

  1. Cliquez sur le menu ⋮ d'une métrique, puis sélectionnez "Afficher dans l'explorateur de métriques".
  2. Vous pouvez désormais modifier les métriques de ressources, les filtres, le regroupement et d'autres options. Par exemple, vous pouvez afficher les latences moyennes des services pour tous les services :

f0d666d8f4221d45.png

Journaux

La sortie STDOUT des services est envoyée au système Google Cloud Logging. Vous pouvez accéder à une vue de base des journaux depuis la page d'administration du service Cloud Run, comme suit :

40058a82c9299cff.png

Dans les journaux Cloud Run, vous pouvez filtrer les journaux par niveau de gravité. Pour plus de flexibilité, cliquez sur : 186fdb0e6d39a6ca.png

Alertes

  1. Créez une URL de vérification de l'état de santé pour votre service.
  2. Pour Spring Boot, il vous suffit d'ajouter la dépendance suivante :
org.springframework.boot:spring-boot-starter-actuator
  1. Créez ou mettez à jour le fichier src/main/resources/application.properties et désactivez la vérification de l'espace disque :
management.health.diskspace.enabled=false
  1. Créez une alerte de disponibilité en spécifiant votre protocole, votre nom d'hôte et votre chemin d'accès. Pour Spring Boot, le chemin d'accès est le suivant : /actuator/health
  2. Tester l'alerte

6948d13b263bf573.png

  1. Créer l'alerte

9. Félicitations

Félicitations, vous avez réussi à créer et à déployer un microservice qui peut affronter d'autres microservices ! Bonne chance !

Documents de référence