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:
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 | ||
Kotlin et Micronaut | ||
Kotlin et Quarkus | ||
Java et Spring Boot | ||
Java et Quarkus | ||
Go | ||
Node.js et Express | ||
Python et Flask |
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.
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.
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:
- [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
- [Dans Cloud Shell] Téléchargez le fichier ZIP sur votre machine:
cloudshell download-file cloudbowl-sample.zip
- [Sur votre machine] Décompressez le fichier, puis effectuez et testez les modifications
- [Sur votre ordinateur] Installez gcloud CLI.
- [Sur votre ordinateur] Connectez-vous à Google Cloud:
gcloud auth login
- [Sur votre machine] Définissez les variables d'environnement
PROJECT_ID
etSAMPLE
sur les mêmes valeurs que dans Cloud Shell. - [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
- [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:
- Se connecter à GitHub
- Créer un dépôt
- 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
- Suivez les instructions pour utiliser Git sur HTTPS avec un jeton d'accès personnel.
- Sélectionnez le champ d'application "dépôt".
- 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"
- 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
- 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
- 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
- Téléchargez votre code en suivant les instructions de l'atelier précédent "Développer en local".
- Installez GitHub Desktop, lancez-le et connectez-vous.
- Cloner le dépôt que vous venez de créer
- Ouvrez l'explorateur de fichiers et copiez votre projet dans le nouveau dépôt.
- Valider vos modifications
- 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.
- Dans la console Cloud, accédez à votre service Cloud Run.
- Cliquez sur le bouton "CONFIGURER LE DÉPLOYEMENT CONTINU".
- Authentifier avec GitHub et sélectionner le dépôt de votre microservice
- Sélectionnez votre dépôt GitHub et définissez la branche sur:
^main$
- Définir le type de compilation pour utiliser Buildpacks
- 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
- Recherchez votre service dans la liste des services Cloud Run.
- Cliquez sur le nom de votre service pour accéder à son tableau de bord des métriques.
- Cliquez sur le menu ⋮ d'une métrique, puis sélectionnez "Afficher dans l'explorateur de métriques".
- 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:
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:
Dans les journaux Cloud Run, vous pouvez filtrer par gravité. Pour plus de souplesse, cliquez sur:
Alertes
- Créez une URL de vérification de l'état pour votre service.
- Pour Spring Boot, il vous suffit d'ajouter la dépendance suivante:
org.springframework.boot:spring-boot-starter-actuator
- 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
- 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
- Tester l'alerte
- 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 !