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

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

Configuration de l'environnement au rythme de chacun

1. Connectez-vous à la console Cloud, puis créez un projet ou réutilisez un projet existant. (Si vous n'avez pas encore de compte Gmail ou G Suite, vous devez en créer un.)

Remarque : Vous pouvez facilement accéder à la console Cloud en mémorisant son URL, à savoir console.cloud.google.com.

Mémorisez l'ID du projet. Il s'agit d'un nom unique permettant de différencier chaque projet Google Cloud (le nom ci-dessus est déjà pris ; vous devez en trouver un autre). Il sera désigné par le nom PROJECT_ID tout au long de cet atelier de programmation.

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 G Suite, choisissez un emplacement pertinent pour votre organisation.

2. Vous devez ensuite activer la facturation dans la console Cloud pour pouvoir utiliser les ressources Google Cloud.

Suivre cet atelier de programmation ne devrait pas vous coûter plus d'un euro. Cependant, cela peut s'avérer plus coûteux si vous décidez d'utiliser davantage de ressources ou si vous ne les interrompez pas.

Les nouveaux utilisateurs de Google Cloud peuvent s'inscrire à un essai sans frais pour bénéficier d'un crédit de 300$valable pour un essai sans frais.

Activer Cloud Shell

1. Dans la console Cloud, cliquez sur Activer Cloud Shell.

Si vous n'avez encore jamais démarré Cloud Shell, un écran intermédiaire s'affiche en dessous de la ligne de séparation pour décrire de quoi il s'agit. Si tel est le cas, cliquez sur Continuer (cet écran ne s'affiche qu'une seule fois). Voici à quoi il ressemble :

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 intègre un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud, ce qui améliore nettement les performances réseau et l'authentification. Vous pouvez réaliser une grande partie, voire la totalité, des activités de cet atelier dans un simple navigateur ou sur votre Chromebook.

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 présentation de l'outil de ligne de commande gcloud.

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

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

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

$ ./mvnw -DskipTests spring-boot:run

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

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 Container Registry pour stocker l'image de conteneur que vous allez créer.

$ gcloud services enable containerregistry.googleapis.com

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

$ ./mvnw -DskipTests com.google.cloud.tools:jib-maven-plugin:build \
  -Dimage=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v1

4. Si tout se passe bien, vous devriez voir l'image de conteneur listée dans la console en accédant à Container Registry > Images. 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.

Remarque : Dans cet exemple, un domaine générique a été utilisé pour le registre (gcr.io). Mais si vous le souhaitez, vous pouvez préciser la zone et le bucket à utiliser. Pour en savoir plus, consultez la documentation de Container Registry.

5. Une fois l'opération terminée (le téléchargement et l'extraction de tous les éléments prendront un certain temps), vous pouvez tester l'image en local 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 :

$ docker run -ti --rm -p 8080:8080 \
  gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v1

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

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

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
Operation "operations/..." finished successfully

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.

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=gcr.io/$GOOGLE_CLOUD_PROJECT/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.

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 présenter le pod au réseau Internet public avec la commande kubectl expose associée à l'option --type=LoadBalancer. Cette option est obligatoire pour créer une adresse IP accessible depuis l'extérieur.

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

L'option utilisée dans la commande spécifie que vous allez utiliser l'équilibreur de charge fourni par l'infrastructure sous-jacente. 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. Remarquez que deux adresses IP accessibles par le port 8080 sont répertoriées pour votre service. L'une est l'adresse IP interne visible uniquement au sein de votre cloud privé virtuel. L'autre est l'adresse IP externe à équilibrage de charge. Dans l'exemple, l'adresse IP externe est aaa.bbb.ccc.ddd. Vous devez maintenant pouvoir accéder au service en utilisant l'adresse http://<EXTERNAL_IP>:8080 dans votre navigateur.

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.

À 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 Lancer l'éditeur dans le menu Cloud Shell.
2. Accédez à src/main/java/hello/HelloController.java et modifiez la valeur de la réponse.

package hello;

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.

$ ./mvnw -DskipTests package \
  com.google.cloud.tools:jib-maven-plugin:build \
  -Dimage=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v2

Remarque  : La création et le transfert de l'image mise à jour doivent être beaucoup plus rapides grâce à la mise en cache.

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 gcr.io/PROJECT_ID/hello-java:v1 par gcr.io/PROJECT_ID/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=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v2

deployment "hello-java" image updated

Remarque  : Pendant cette opération, les utilisateurs des services peuvent rencontrer des interruptions, mais cela est dû à l'absence de vérification de l'état 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. Consultez à nouveau http://EXTERNAL_IP:8080 pour vérifier que la nouvelle réponse est renvoyée.

Petit problème… Avez-vous commis 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

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

En savoir plus

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