Battle One – A Microservices Battle Ground

1. Introduction

Dernière mise à jour : 26/08/2020

Microservices Battle Arena

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 taper sur les doigts, vous pouvez créer un petit service accessible au réseau (un microservice) qui participera à une bataille épique contre d'autres microservices. Comme nous organisons cette bataille de microservices à SpringOne, nos microservices lanceront des feuilles au lieu de boules de neige.

Vous vous demandez peut-être... Mais comment un microservice "lance-t-il" une feuille à 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 Java, Kotlin ou Scala), puis le déployer sur Google Cloud. Une fois déployé, vous remplirez un formulaire pour nous indiquer l'URL de votre microservice. Nous l'ajouterons ensuite à l'arène.

L'arène contient tous les joueurs d'une même bataille. La conférence SpringOne aura sa propre arène. Chaque joueur représente un microservice qui se déplace et lance des feuilles 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 une feuille. Une feuille lancée peut parcourir jusqu'à trois espaces dans la direction à laquelle le joueur fait face. Si une feuille "touche" un autre joueur, le lanceur 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 :

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.

Premiers pas et connexion

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 commencer avec deux exemples de microservices de combat :

Java et Spring Boot	Source	Déployer sur Cloud Run
Kotlin et Spring Boot	Source	Déployer sur Cloud Run

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.

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 "Your application is now live here") :

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 devrait s'afficher.

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

Pour participer à l'arène, vous devez envoyer un message au canal Slack #3-sponsor-google-cloud en indiquant votre nom, l'URL de votre service Cloud Run et, éventuellement, votre nom d'utilisateur GitHub pour son avatar / photo de profil. Une fois que nous aurons validé les informations, votre joueur apparaîtra dans l'arène.

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=java-springboot
export SAMPLE=kotlin-springboot

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.

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

Après avoir enregistré vos modifications, démarrez l'application dans Cloud Shell :

cd cloudbowl-microservice-game/samples/$SAMPLE
./mvnw spring-boot:run

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).

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\
          --memory=512Mi\
          --allow-unauthenticated

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

6. Développer en local

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 :

cd ~/cloudbowl-microservice-game/samples; zip -r cloudbowl-sample.zip $SAMPLE

2. [Dans Cloud Shell] Téléchargez le fichier ZIP sur votre ordinateur :

cloudshell download-file cloudbowl-sample.zip

3. [Sur votre machine] Décompressez le fichier, puis apportez et testez vos modifications
4. [Sur votre machine] Installez la gcloud CLI.
5. [Sur votre machine] Connectez-vous à Google Cloud :

gcloud auth login

6. [Sur votre machine] Définissez les variables d'environnement PROJECT_ID et SAMPLE sur les mêmes valeurs que dans Cloud Shell.
7. [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

8. [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 --memory=512Mi --allow-unauthenticated

7. Félicitations

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

Poursuivre la formation

• Autres ateliers de programmation Spring

Documents de référence

• Documentation Cloud Run

8. Questions fréquentes

Pourquoi mon microservice ne s'affiche-t-il pas dans l'arène ?

L'ajout de nouveaux robots à l'arène est un processus manuel qui peut prendre jusqu'à 15 minutes. Vous pouvez rechercher votre service dans le fichier de configuration de sauvegarde : https://github.com/cloudbowl/arenas/blob/master/springone.json.