Microservice Rainbow Rumpus

1. Introduction

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

Microservice Rainbow Rumpus

Vous est-il déjà arrivé de vous déplacer et de lancer des boules de neige sur d'autres joueurs en vous amusant ? Si ce n'est pas le cas, essayez un jour ! Mais au lieu de risquer d'être physiquement bloqué, vous pouvez créer un petit service accessible au réseau (un microservice) qui participera à une bataille épique contre d'autres microservices, produisant 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 pour d'autres microservices ? Un microservice peut recevoir des requêtes réseau (généralement via HTTP) et renvoyer des réponses. Il existe un « gestionnaire de l'arène » qui enverra à votre microservice l'état actuel de l'arène, puis il répondra avec une commande spécifiant ce qu'il doit faire.

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

Comment ça marche ?

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

L'arène contient tous les joueurs d'une bataille donnée. Le Rumpus arc-en-ciel aura ses propres arènes. Chaque joueur représente un microservice qui se déplace et envoie des arcs-en-ciel aux autres joueurs.

Environ une fois par seconde, notre responsable de l'arène appelle votre microservice et envoie l'état actuel de l'arène (où se trouvent les joueurs). Votre microservice répond ensuite en 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 jusqu'à trois zones dans la direction vers laquelle le joueur fait face. Si l'arc-en-ciel "hit" un autre joueur, le lanceur obtient un point et le joueur touché perd un point. La taille de l'arène est ajustée automatiquement en fonction du nombre actuel de joueurs.

Voici à quoi ressemble une ancienne arène:

20628e6bd442bd11.png

Exemple d'arène Battle One

Conflits tournants

Dans l'arène, il est possible que plusieurs joueurs essaient 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 qui offre le temps de réponse le plus rapide l'emporte.

Regarder la bataille

Pour connaître les performances de votre microservice dans la bataille, consultez l'arène en direct.

API Battle

Pour que vous puissiez travailler avec notre responsable de l'arène, votre microservice devra implémenter une API spécifique pour participer à l'arène. Le gestionnaire de l'arène enverra l'état actuel de l'arène dans une requête POST HTTP à l'URL que vous nous avez fournie, 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 comporter le code d'état 200 (OK) avec un corps de réponse contenant le prochain coup, encodé sous la forme d'un seul caractère majuscule correspondant à l'un des éléments suivants:

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

Le plus important ! Voyons maintenant comment déployer 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 alors un crédit à votre compte et vous n'aurez pas besoin d'indiquer les informations relatives à votre carte de paiement. Il est généralement moins problématique d'utiliser un compte personnel (par exemple, gmail.com) au lieu d'un compte G Suite, car il arrive que les administrateurs G Suite empêchent leurs utilisateurs d'accéder à certaines fonctionnalités Google Cloud. De plus, la console Web que nous allons utiliser devrait fonctionner parfaitement avec Chrome ou Firefox, mais elle peut présenter 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 soit conforme à 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.

Choisissez votre échantillon pour commencer

Vous pouvez commencer par de nombreux exemples de microservices de type "batt" :

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 AdWords Express

Source

Python et Flasque

Source

Après avoir choisi l'exemple par lequel commencer, cliquez sur "Déployer sur Cloud Run" bouton ci-dessus. Cette opération lance Cloud Shell (une console Web sur une machine virtuelle dans le cloud). 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 et déployé sur Cloud Run.

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

La capture d'écran ci-dessous montre le résultat de Cloud Shell pour la création et le déploiement de microservices.

d88e40430706a32b.png

Vérifier que le microservice fonctionne

Dans Cloud Shell, vous pouvez envoyer une requête au microservice que vous venez de déployer, 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 active 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 F, L, R ou T doit s'afficher.

4. Demander à participer à l'arène

Pour rejoindre la Rumpus arc-en-ciel, vous devrez rejoindre une arène. Ouvrez rainbowrumpus.dev et cliquez sur "Rejoindre" sur une arène dans laquelle vous indiquerez l'URL de votre microservice.

5. Marque et Déployer les modifications

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

gcloud projects list

Vous n'avez probablement qu'un seul projet. Copiez la valeur PROJECT_ID de la première colonne et collez-la dans la commande suivante (en remplaçant YOUR_PROJECT_ID par l'ID de votre projet) 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é. Ainsi, dans les commandes ultérieures, nous pourrons spécifier le répertoire et le nom de service corrects:

# 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 depuis Cloud Shell. Pour ouvrir l'éditeur Web de Cloud Shell, exécutez la commande suivante:

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

Des instructions supplémentaires s'affichent alors pour vous permettre d'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 que vous vous trouvez 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, créez votre projet dans Cloud Shell à l'aide de la commande pack. Cette commande utilise 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 que Cloud Run puisse y accéder:

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 votre nouvelle version !

6. Développer en local (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'exemple dans un fichier ZIP:
# 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 créez et tester vos modifications
  2. [Sur votre machine] Installer 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 afin de 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 git (CLI) ou l'application IUG de bureau GitHub (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 de Git via https avec un jeton d'accès personnel.
  2. Sélectionnez "dépôt". champ d'application
  3. Configuration de 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 appliquer à GitHub:
git add .
git status
git diff --staged
git commit -am "my changes"
git push

Transférer votre code avec le bureau GitHub

  1. Téléchargez votre code en suivant les instructions de l'étape précédente "Développer en local". atelier
  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. Validez vos modifications

5f3c1552e30ad7c5.png

  1. Publier votre branche principale sur GitHub

Configurer le déploiement continu Cloud Run

Avec la configuration de SCM sur GitHub, vous pouvez maintenant configurer la livraison continue. Ainsi, chaque fois que de nouveaux commits sont envoyés vers la branche main, Cloud Build génère et déploie automatiquement les modifications. Vous pouvez également ajouter l'intégration continue, qui exécute vos tests avant le déploiement, mais cette étape a été laissée comme un 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" bouton
  3. Authentifiez-vous avec GitHub et sélectionnez le dépôt de votre microserivce

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é

Des choses se brisent. L'observabilité nous permet de savoir quand cela se produit et d'en diagnostiquer les causes. Les métriques nous montrent des données sur l'état et l'utilisation de notre service. Les journaux nous indiquent les informations d'instrumentation manuelle émises par notre service. Les alertes nous permettent d'être avertis en cas de problème. Explorons 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, les filtres, les regroupements et d'autres options des ressources. Par exemple, vous pouvez afficher les latences moyennes de tous les services:

f0d666d8f4221d45.png

Journaux

Les résultats STDOUT des services sont envoyés au système Google Cloud Logging. Vous pouvez accéder à une vue de journal de base à partir de la page d'administration du service Cloud Run, par exemple:

40058a82c9299cff.png

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

Alertes

  1. Créez une URL de vérification de la santé pour votre service.
  2. Pour Spring Boot, ajoutez simplement la dépendance suivante:
org.springframework.boot:spring-boot-starter-actuator
  1. Créez ou mettez à jour 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 venez de créer et de déployer un microservice qui peut être confronté à d'autres microservices. Bonne chance !

Documentation de référence