Déployer une application Java Spring Boot dans Kubernetes sur Google Kubernetes Engine

1. Avant de commencer

Kubernetes est un projet Open Source qui peut s'exécuter dans de nombreux environnements différents : des ordinateurs portables aux clusters multinœuds à haute disponibilité, des clouds publics aux déploiements sur site, et des instances de machines virtuelles (VM) aux machines dédiées.

Dans cet atelier de programmation, vous allez déployer une application Web Java Spring Boot simple sur Kubernetes sur GKE. L'objectif est de vous permettre d'exécuter votre application Web en tant qu'application répliquée sur Kubernetes. Vous allez transformer le code que vous avez développé sur votre machine en une image de conteneur Docker, que vous exécuterez ensuite sur GKE.

Vous utiliserez GKE, un service Kubernetes entièrement géré sur Google Cloud, pour vous concentrer sur la découverte de Kubernetes plutôt que sur la configuration de l'infrastructure sous-jacente.

Si vous souhaitez exécuter Kubernetes sur votre appareil local, par exemple votre ordinateur portable de développement, n'hésitez pas à utiliser Minikube, qui permet de configurer facilement un cluster Kubernetes à nœud unique à des fins de développement et de test. Si vous le souhaitez, vous pouvez utiliser Minikube dans cet atelier de programmation.

Cet atelier de programmation utilisera l'exemple de code du guide Créer une application avec Spring Boot.

Prérequis

• Connaissances du langage et des outils de programmation Java
• Connaissance des éditeurs de texte Linux standards tels que Vim, Emacs et nano

Objectifs de l'atelier

• Empaqueter une application Java simple en tant que conteneur Docker
• Créez votre cluster Kubernetes sur GKE.
• Déployez votre application Java sur Kubernetes sur GKE.
• Effectuer un scaling à la hausse et déployer une mise à niveau de votre service
• Accédez au tableau de bord, une interface utilisateur Kubernetes basée sur le Web.

Prérequis

• Un projet Google Cloud
• Un navigateur tel que Google Chrome

2. Préparation

Configuration de l'environnement au rythme de chacun

1. Connectez-vous à la console Google Cloud, puis créez un projet ou réutilisez un projet existant. (Si vous ne possédez pas encore de compte Gmail ou Google Workspace, vous devez en créer un.)

• Le nom du projet est le nom à afficher pour les participants au projet. Il s'agit d'une chaîne de caractères non utilisée par les API Google. Vous pourrez toujours le modifier.
• L'ID du projet est unique parmi tous les projets Google Cloud et non modifiable une fois défini. La console Cloud génère automatiquement une chaîne unique (en général, vous n'y accordez d'importance particulière). Dans la plupart des ateliers de programmation, vous devrez indiquer l'ID de votre projet (généralement identifié par PROJECT_ID). Si l'ID généré ne vous convient pas, vous pouvez en générer un autre de manière aléatoire. Vous pouvez également en spécifier un et voir s'il est disponible. Après cette étape, l'ID n'est plus modifiable et restera donc le même pour toute la durée du projet.
• Pour information, il existe une troisième valeur (le numéro de projet) que certaines API utilisent. Pour en savoir plus sur ces trois valeurs, consultez la documentation.

Attention : Un ID de projet est unique. Une fois que vous l'avez choisi, personne d'autre ne peut l'employer. Vous en êtes le seul utilisateur. Même si un projet est supprimé, son ID ne peut pas être réutilisé.

Remarque : Si vous utilisez un compte Gmail, vous pouvez conserver l'emplacement par défaut défini sur Aucune organisation. Si vous utilisez un compte Google Workspace, choisissez un emplacement qui ait du sens pour votre organisation.

2. Vous devez ensuite activer la facturation dans la console Cloud pour utiliser les ressources/API Cloud. L'exécution de cet atelier de programmation est très peu coûteuse, voire sans frais. Pour désactiver les ressources et éviter ainsi que des frais ne vous soient facturés après ce tutoriel, vous pouvez supprimer le projet ou les ressources que vous avez créées. Les nouveaux utilisateurs de Google Cloud peuvent participer au programme d'essai sans frais pour bénéficier d'un crédit de 300 $.

Activer Cloud Shell

1. Dans Cloud Console, cliquez sur Activer Cloud Shell .

Si vous démarrez Cloud Shell pour la première fois, un écran intermédiaire s'affiche pour vous expliquer de quoi il s'agit. Si cet écran s'est affiché, cliquez sur Continuer.

Le provisionnement et la connexion à Cloud Shell ne devraient pas prendre plus de quelques minutes.

Cette machine virtuelle contient tous les outils de développement nécessaires. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud, ce qui améliore nettement les performances du réseau et l'authentification. Vous pouvez réaliser une grande partie, voire la totalité, des activités de cet atelier de programmation dans un navigateur.

Une fois connecté à Cloud Shell, vous êtes en principe authentifié, et le projet est défini avec votre ID de projet.

2. Exécutez la commande suivante dans Cloud Shell pour vérifier que vous êtes authentifié :

gcloud auth list

Résultat de la commande

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

Remarque : gcloud est l'outil de ligne de commande performant et unifié de Google Cloud. Il est préinstallé dans Cloud Shell. Il est également compatible avec la saisie semi-automatique via la touche de tabulation. Pour en savoir plus, consultez la section de présentation de l'outil de ligne de commande gcloud.

3. Exécutez la commande suivante dans Cloud Shell pour vérifier que la commande gcloud connaît votre projet :

gcloud config list project

Résultat de la commande

[core]
project = <PROJECT_ID>

Si vous obtenez un résultat différent, exécutez cette commande :

gcloud config set project <PROJECT_ID>

Résultat de la commande

Updated property [core/project].

Remarque : Si vous suivez ce tutoriel en dehors de Cloud Shell, suivez Configurer les identifiants par défaut de l'application.

3. Obtenir le code source

Une fois l'environnement Cloud Shell lancé, vous pouvez utiliser la ligne de commande pour cloner l'exemple de code source dans le répertoire d'accueil.

$ git clone https://github.com/spring-guides/gs-spring-boot.git
$ cd gs-spring-boot/complete

4. Exécuter l'application en local

1. Assurez-vous que JAVA_HOME est défini sur la bonne version :

$ export JAVA_HOME=/usr/lib/jvm/java-1.17.0-openjdk-amd64

2. Vous pouvez démarrer l'application Spring Boot normalement avec le plug-in Spring Boot.

$ ./mvnw -DskipTests spring-boot:run

3. Une fois l'application démarrée, cliquez sur Aperçu sur le Web dans la barre d'outils Cloud Shell, puis sélectionnez Prévisualiser sur le port 8080.

Un onglet s'ouvre dans votre navigateur et se connecte au serveur que vous venez de démarrer.

5. Empaqueter l'application Java en tant que conteneur Docker

Préparez ensuite votre application à s'exécuter sur Kubernetes. La première étape consiste à définir le conteneur et son contenu.

1. Créez le fichier JAR déployable pour l'application.

$ ./mvnw -DskipTests package

2. Activez l'API Artifact Registry pour stocker l'image de conteneur que vous allez créer.

$ gcloud services enable artifactregistry.googleapis.com

3. Créez un dépôt Docker s'il n'en existe pas encore. Vous devez créer un dépôt pour pouvoir y transférer des images :

$ gcloud artifacts repositories create codelabrepo     --repository-format=docker --location=us-central1 

4. Votre image doit être au format suivant :

{LOCATION}-docker.pkg.dev/{PROJECT-ID}/{REPOSITORY}/{IMAGE-NAME}

Par exemple, si vous avez créé le dépôt dans l'emplacement us-central1 et que vous l'avez nommé codelabrepo, et que vous souhaitez nommer votre image hello-java:v1, l'image sera :

us-central1-docker.pkg.dev/{PROJECT-ID}/codelabrepo/hello-java:v1

5. Utilisez Jib pour créer l'image de conteneur et la transférer vers Artifact Registry.

$ export GOOGLE_CLOUD_PROJECT=`gcloud config list --format="value(core.project)"`

$ ./mvnw -DskipTests com.google.cloud.tools:jib-maven-plugin:build -Dimage=us-central1-docker.pkg.dev/${GOOGLE_CLOUD_PROJECT}/codelabrepo/hello-java:v1

6. Vous devriez pouvoir voir l'image de conteneur listée dans la console en accédant à la page Images Artifacts Registry dans la console Cloud. Vous disposez maintenant d'une image Docker pour l'ensemble du projet. Comme vous le verrez dans quelques minutes, vous pouvez accéder à cette image et l'orchestrer grâce à Kubernetes.
7. (Facultatif) Une fois l'opération terminée (le téléchargement et l'extraction de tous les éléments prendront un certain temps), testez l'image avec la commande suivante, qui exécutera un conteneur Docker en tant que daemon sur le port 8080 à partir de l'image de conteneur que vous venez de créer. Si vous rencontrez des problèmes d'autorisation, exécutez d'abord gcloud auth configure-docker us-central1-docker.pkg.dev :

$ docker run -ti --rm -p 8080:8080 \
  us-central1-docker.pkg.dev/$GOOGLE_CLOUD_PROJECT/codelabrepo/hello-java:v1

8. Exploitez une fois de plus la fonctionnalité d'aperçu sur le Web de Cloud Shell.

9. La page par défaut devrait s'afficher dans un nouvel onglet. Une fois que vous avez vérifié que l'application s'exécute en local dans un conteneur Docker, vous pouvez arrêter le conteneur en cours d'exécution en appuyant sur Control+C.

6. Créer votre cluster

Vous êtes prêt à créer votre cluster GKE. Un cluster se compose d'un serveur d'API Kubernetes géré par Google et d'un ensemble de nœuds de calcul. Les nœuds de calcul sont des VM Compute Engine.

1. Commencez par vous assurer que les fonctionnalités d'API associées sont activées.

$ gcloud services enable compute.googleapis.com container.googleapis.com

2. Créez un cluster avec deux nœuds n1-standard-1 (cette opération prend quelques minutes).

$ gcloud container clusters create hello-java-cluster \
  --num-nodes 2 \
  --machine-type n1-standard-1 \
  --zone us-central1-c

Une fois l'opération terminée, vous devez voir le cluster créé.

Creating cluster hello-java-cluster...done.
Created [https://container.googleapis.com/v1/projects/...].
kubeconfig entry generated for hello-dotnet-cluster.
NAME                  ZONE            MASTER_VERSION  
hello-java-cluster  us-central1-c  ...

Remarque : Vous pouvez également créer le cluster dans la console Cloud. Pour y accéder, cliquez sur Menu de navigation > Kubernetes Engine > Clusters > Créer un cluster. Vous pouvez créer un cluster dans une autre zone, mais il est recommandé de rester dans la même région que le bucket de stockage utilisé par Container Registry.

Vous devez maintenant disposer d'un cluster Kubernetes entièrement fonctionnel, fourni par GKE.

Vous pouvez à présent déployer votre application conteneurisée sur le cluster Kubernetes. À partir de maintenant, vous utiliserez la ligne de commande kubectl (déjà configurée dans votre environnement Cloud Shell). Dans la suite de l'atelier, vous devrez utiliser les versions client et serveur 1.2 ou ultérieures de Kubernetes. kubectl version affiche la version actuelle de la commande.

7. Déployer votre application sur Kubernetes

1. Un déploiement Kubernetes peut créer, gérer et mettre à l'échelle plusieurs instances de votre application à l'aide de l'image de conteneur que vous avez créée. Déployez une instance de votre application sur Kubernetes à l'aide de la commande kubectl run.

$ kubectl create deployment hello-java --image=us-central1-docker.pkg.dev/$GOOGLE_CLOUD_PROJECT/codelabrepo/hello-java:v1

2. Pour afficher le déploiement que vous avez créé, exécutez simplement la commande suivante :

$ kubectl get deployments

NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-java   1         1         1            1           37s

3. Pour afficher les instances d'application créées par le déploiement, exécutez la commande suivante :

$ kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE
hello-java-714049816-ztzrb   1/1       Running   0          57s

À ce stade, votre conteneur devrait être sous le contrôle de Kubernetes, mais vous devez quand même le rendre accessible depuis l'extérieur.

8. Autoriser le trafic externe

Par défaut, le pod n'est accessible que par le biais de son adresse IP interne au sein du cluster. Pour rendre le conteneur hello-java accessible depuis l'extérieur du réseau virtuel Kubernetes, vous devez exposer le pod en tant que service Kubernetes.

1. Dans Cloud Shell, vous pouvez exposer le pod à Internet en créant un service Kubernetes LoadBalancer.

$ kubectl create service loadbalancer hello-java --tcp=8080:8080

Notez que vous exposez directement le déploiement, et non le pod. Par conséquent, le service obtenu va répartir le trafic sur tous les pods gérés par le déploiement (dans le cas présent, un seul pod, mais vous ajouterez des instances répliquées par la suite).

Le maître Kubernetes crée l'équilibreur de charge et les règles de transfert Compute Engine associées, les pools cibles et les règles de pare-feu afin de rendre le service entièrement accessible depuis l'extérieur de Google Cloud.

2. Pour trouver l'adresse IP publiquement accessible du service, demandez simplement à kubectl de lister tous les services du cluster.

$ kubectl get services

NAME         CLUSTER-IP     EXTERNAL-IP      PORT(S)    AGE
hello-java   10.3.253.62    aaa.bbb.ccc.ddd  8080/TCP    1m
kubernetes   10.3.240.1     <none>           443/TCP    5m

Remarque : La disponibilité et la visibilité de EXTERNAL-IP peuvent nécessiter quelques minutes. Si EXTERNAL-IP ne s'affiche pas, patientez quelques minutes, puis réessayez.

3. Vous devez maintenant pouvoir accéder au service en utilisant l'adresse suivante dans votre navigateur : http://<EXTERNAL_IP>:8080.

9. Faire évoluer votre service

L'une des puissantes fonctionnalités de Kubernetes est le scaling de votre application, qui se fait très simplement. Supposons que vous ayez soudainement besoin de plus de capacité pour votre application. Il vous suffit de demander au contrôleur de réplication de gérer un certain nombre de nouvelles instances répliquées pour votre application.

$ kubectl scale deployment hello-java --replicas=3

deployment "hello-java" scaled

$ kubectl get deployment
NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-java   3         3         3            3           22m

Notez l'approche déclarative. Plutôt que de démarrer ou d'arrêter des instances, vous déclarez le nombre d'instances à exécuter en permanence. Les boucles de réconciliation de Kubernetes veillent simplement à ce que la réalité corresponde à votre demande et prennent des mesures si nécessaire.

10. Déployer une mise à niveau sur votre service

À un moment donné, l'application que vous avez déployée en production nécessitera des corrections de bugs ou l'ajout de nouvelles fonctionnalités. Kubernetes peut vous aider à déployer une nouvelle version en production sans affecter les utilisateurs.

1. Ouvrez l'éditeur de code en cliquant sur Ouvrir l'éditeur dans le menu Cloud Shell.
2. Accédez à src/main/java/com/example/springboot/HelloController.java et modifiez la valeur de la réponse.

package com.example.springboot;

import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;

@RestController
public class HelloController {

    @RequestMapping("/")
    public String index() {
        return "Greetings from Google Kubernetes Engine!";
    }
}

3. Utilisez Jib pour créer et transférer une nouvelle version de l'image de conteneur. La création et le transfert de cette image mise à jour doivent être beaucoup plus rapides grâce à la mise en cache.

$ ./mvnw -DskipTests package com.google.cloud.tools:jib-maven-plugin:build -Dimage=us-central1-docker.pkg.dev/$GOOGLE_CLOUD_PROJECT/codelabrepo/hello-java:v2

Vous êtes prêt à ce que Kubernetes mette à jour votre contrôleur de réplication de manière fluide et installe la nouvelle version de l'application.

4. Afin de modifier le libellé de l'image pour votre conteneur en cours d'exécution, vous devez modifier le déploiement hello-java existant et remplacer l'image us-central1-docker.pkg.dev/PROJECT_ID/codelabrepo/hello-java:v1

vers us-central1-docker.pkg.dev/PROJECT_ID/codelabrepo/hello-java:v2

5. Vous pouvez utiliser la commande kubectl set image pour demander à Kubernetes de déployer la nouvelle version de votre application sur l'ensemble du cluster, une instance à la fois, à l'aide de mises à jour continues.

$ kubectl set image deployment/hello-java hello-java=us-central1-docker.pkg.dev/$GOOGLE_CLOUD_PROJECT/codelabrepo/hello-java:v2

deployment "hello-java" image updated

Remarque : Pendant cette opération, les utilisateurs des services peuvent rencontrer des interruptions, car aucune vérification de l'état n'a été configurée. Il s'agit d'une configuration légèrement plus avancée qui dépasse le cadre de cet atelier de programmation.

6. Vérifiez à nouveau http://EXTERNAL_IP:8080 pour voir si la nouvelle réponse est renvoyée.

11. Rollback

Petit problème… Vous avez fait une erreur avec une nouvelle version de l'application ? Peut-être que la nouvelle version contenait une erreur et que vous devez rapidement la rétablir. Avec Kubernetes, vous pouvez facilement revenir à l'état précédent. Rétablissez l'application en exécutant la commande suivante :

$ kubectl rollout undo deployment/hello-java

L'ancienne réponse devrait s'afficher lorsque vous vérifiez à nouveau http://EXTERNAL_IP:8080.

12. Félicitations

Vous avez appris à créer et à déployer une application Web basée sur Java sur Kubernetes sur GKE.

Nettoyage

$ gcloud container clusters delete hello-java-cluster --zone us-central1-c

$ gcloud container images delete us-central1-docker.pkg.dev/$GOOGLE_CLOUD_PROJECT/codelabrepo/hello-java:v1 us-central1-docker.pkg.dev/$GOOGLE_CLOUD_PROJECT/codelabrepo/hello-java:v2

En savoir plus

• Java sur Google Cloud
• Exemples de code Java
• Kubernetes sur GKE : des bases aux fonctionnalités avancées