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 aux autres participants ? Sinon, essayez-le un jour ! Mais maintenant, au lieu de risquer de recevoir une gifle physique, vous pouvez créer un petit service accessible au 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 "lance-t-il" un arc-en-ciel vers 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. Votre microservice répond ensuite avec une commande indiquant 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 (parmi les démarreurs Go, Java, Kotlin, Scala, NodeJS ou Python), puis le déployer sur Google Cloud. Une fois le déploiement effectué, vous nous indiquerez l'URL de votre microservice, et nous l'ajouterons à l'arène.

L'arène contient tous les joueurs d'un combat donné. 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 appelle votre microservice, lui envoie l'état actuel de l'arène (où se trouvent les joueurs) et votre microservice répond avec une commande indiquant ce qu'il doit 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 sur trois cases dans la direction du joueur. Si l'arc-en-ciel "touche" un autre joueur, le lanceur gagne un point et le joueur touché perd un point. La taille de l'arène est automatiquement ajustée en fonction du nombre actuel de joueurs.

Voici à quoi ressemble une arène passée:

20628e6bd442bd11.png

Exemple d'arène Battle One

Conflits récurrents

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

Regarder le combat

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

API Battle

Pour interagir avec notre gestionnaire d'arènes, votre microservice devra implémenter une API spécifique. 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 au code d'état 200 (OK), avec un corps de réponse contenant votre prochain coup, encodé en tant que caractère majuscule unique parmi les suivants:

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

Le plus important ! Déployez 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 crédit à 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 GSuite, car les administrateurs GSuite empêchent parfois leurs utilisateurs d'utiliser certaines fonctionnalités Google Cloud. De plus, la console Web que nous utiliserons devrait fonctionner parfaitement avec Chrome ou Firefox, mais elle peut rencontrer des problèmes dans 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 qu'il respecte l'API Battle. Pour vous faciliter la tâche, nous allons vous aider à partir d'un exemple de service et à le déployer sur Cloud Run.

Choisir un échantillon pour commencer

Vous pouvez partir 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 "Déployer sur Cloud Run" ci-dessus. Cloud Shell (une console Web pour une machine virtuelle dans le cloud) se lance, où la source est clonée, puis intégrée dans un package déployable (une image de conteneur Docker), qui est 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 du microservice.

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

La chaîne de réponse doit être F, L, R ou T.

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

Pour participer au Rainbow Rumpus, vous devez rejoindre une arène. Ouvrez rainbowrumpus.dev, puis cliquez sur "Joindre" 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 sur le projet GCP et l'exemple que vous avez utilisé. Commencez par lister vos projets GCP:

gcloud projects list

Vous ne disposez probablement que d'un seul projet. Copiez PROJECT_ID dans 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 suivantes:

export PROJECT_ID=YOUR_PROJECT_ID

Définissez maintenant une autre variable d'environnement pour l'exemple que vous avez utilisé afin que nous puissions spécifier le nom de répertoire et 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 le code source de votre microservice depuis 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 apporter 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 d'être 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 la transférer vers Google Container Registry afin qu'elle puisse ê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)

Pour travailler sur votre projet localement à l'aide de votre propre IDE, procédez comme suit:

  1. [Dans Cloud Shell] Zippez l'exemple:
# 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 machine:
cloudshell download-file cloudbowl-sample.zip
  1. [Sur votre machine] Décompressez le fichier, puis effectuez et testez les modifications
  2. [Sur votre ordinateur] Installez gcloud CLI.
  3. [Sur votre ordinateur] 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 ordinateur] 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 ordinateur local, 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 devez utiliser la CLI git. Pour obtenir le code de votre microservice sur GitHub, suivez les instructions de la CLI ou de GitHub Desktop.

Transférer votre code avec la CLI git

  1. Suivez les instructions pour utiliser Git sur HTTPS avec un jeton d'accès personnel.
  2. Sélectionnez le champ d'application "dépôt".
  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éfinir des 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. Une fois les modifications effectuées, vous pouvez les valider et les transférer vers GitHub:
git add .
git status
git diff --staged
git commit -am "my changes"
git push

Transférer votre code avec GitHub pour ordinateur

  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 livraison continue 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 une intégration continue qui exécute vos tests avant le déploiement, mais cette étape vous a été laissée en 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ÉPLOYEMENT CONTINU".
  3. 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 pour utiliser 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 de 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-les 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, les filtres, le regroupement et d'autres options des ressources. 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 journal de base depuis la page d'administration du service Cloud Run, par exemple:

40058a82c9299cff.png

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

Alertes

  1. Créez une URL de vérification de l'état 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 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 créé et déployé un microservice qui peut s'affronter avec d'autres microservices. Bonne chance !

Documentation de référence