Cette page a été traduite par l'API Cloud Translation.

Battle One – A Microservices Battle Ground

1. Introduction

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

Microservices Battle Arena

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 maintenant, 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. Comme nous organisons cette bataille de microservices à SpringOne, nos microservices généreront des feuilles au lieu de boules de neige.

Vous vous demandez peut-être... Mais comment un microservice "lance"-t-il une feuille sur 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 des déclencheurs Java, Kotlin ou Scala), puis le déployer sur Google Cloud. Une fois le microservice déployé, vous devrez remplir 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 bataille donnée. La conférence SpringOne disposera de son propre stade. Chaque joueur représente un microservice qui se déplace et jette des feuilles 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 une feuille. Une feuille lancée se déplace jusqu'à trois coins dans la direction vers laquelle le joueur fait face. Si une feuille "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:

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 deux exemples de microservices "batt" :

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

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.

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

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

4. Demander à participer à l'arène

Pour participer à l'arène, vous devez envoyer un message à la chaîne Slack #3-sponsor-google-cloud en indiquant votre nom, l'URL du service Cloud Run et, éventuellement, votre nom d'utilisateur GitHub pour son avatar ou sa photo de profil. Une fois les informations validées, votre joueur figurera dans l'arène.

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

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.

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

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

L'arène utilisera votre nouvelle version !

6. Développer localement

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

[Dans Cloud Shell] Compressez l'exemple dans un fichier ZIP:

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

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

cloudshell download-file cloudbowl-sample.zip

[Sur votre machine] Décompressez le fichier, puis créez et tester vos modifications
[Sur votre machine] Installer la gcloud CLI
[Sur votre machine] Connectez-vous à Google Cloud:

gcloud auth login

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

[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 venez de créer et de déployer un microservice qui peut être confronté à d'autres microservices. Bonne chance !

Poursuivez votre apprentissage

Autres ateliers Spring Code

Documentation de référence

Documentation sur Cloud Run

8. Questions fréquentes

Pourquoi mon microservice n'apparaît-il pas dans l'arène ?