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

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

À propos de cet atelier de programmation

Dernière mise à jour : avr. 22, 2020

Rédigé par une Googleuse ou un Googleur

1. Avant de commencer

Kubernetes est un projet Open Source pouvant s'exécuter dans de nombreux environnements, qu'il s'agisse d'ordinateurs portables, de clusters multinœuds à haute disponibilité, de clouds publics ou de déploiements sur site, et d'instances de machines virtuelles (VM) en passant par la solution Bare Metal.

Dans cet atelier de programmation, vous allez déployer une application Web Java Spring Boot simple sur Kubernetes sur GKE afin d'exécuter votre application Web en tant qu'application dupliquée sur Kubernetes. Vous allez utiliser le code que vous développez sur votre machine, le transformer en image de conteneur Docker et l'exécuter sur GKE.

Vous allez utiliser GKE, un service Kubernetes entièrement géré sur Google Cloud, pour vous concentrer sur l'expérience Kubernetes, plutôt que de configurer l'infrastructure sous-jacente.

Si vous souhaitez exécuter Kubernetes sur votre ordinateur local, par exemple un ordinateur portable de développement, utilisez Minikube, qui propose une configuration simple d'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.

Il utilise l'exemple de code du guide Créer une application avec Spring Boot.

Conditions préalables

• Bonne connaissance des outils et du langage de programmation Java
• Une bonne 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.
• Faites évoluer votre service et déployez une mise à niveau.
• accéder au tableau de bord, une interface utilisateur Kubernetes Web ;

Prérequis

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

2. Prérequis

Configuration de l'environnement au rythme de chacun

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

Remarque : Vous pouvez facilement accéder à Cloud Console 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 Cloud Console afin d'utiliser les ressources Google Cloud.

Le coût de cet atelier de programmation ne devrait pas vous coûter plus que quelques dollars, mais il pourrait être plus élevé si vous décidez d'utiliser davantage de ressources ou de les laisser s'exécuter.

Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai offert de 300 $.

Activer Cloud Shell

1. Dans Cloud Console, 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: L'outil de ligne de commande gcloud est l'outil de ligne de commande puissant 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 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].

3. Obtenir le code source

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

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

Vous devez ensuite préparer votre application pour qu'elle s'exécute sur Kubernetes. La première étape consiste à définir le conteneur et son contenu.

1. Créer 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. À l'aide de Jib, créez l'image de conteneur et transférez-la 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 déroule correctement, vous pouvez voir l'image de conteneur répertoriée dans la console en accédant à Container Registry >Images. Vous disposez maintenant d'une image Docker à l'échelle du projet, que Kubernetes peut accéder et orchestrer comme vous le verrez en quelques minutes.

Remarque : Vous avez utilisé un domaine générique pour le registre (gcr.io), mais vous pouvez également définir une zone et un bucket plus spécifiques. Pour en savoir plus, consultez la documentation sur Container Registry.

5. Une fois l'opération terminée (le téléchargement et l'extraction de l'image peuvent prendre du temps), vous pouvez tester localement l'image à l'aide de 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. Profitez à nouveau de la fonctionnalité d'aperçu sur le Web de Cloud Shell.

7. La page par défaut devrait s'afficher dans un nouvel onglet. Après avoir vérifié que l'application s'exécute localement 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 contient un serveur d'API Kubernetes géré par Google et 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 Cloud Console. Pour y accéder, cliquez sur le menu de navigation > Kubernetes Engine>Clusters>Créer un cluster. Vous pouvez créer un cluster dans une autre zone, mais nous vous recommandons 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, optimisé par GKE.

Il est temps de déployer votre application en conteneur sur le cluster Kubernetes. Vous allez maintenant utiliser la ligne de commande kubectl (déjà configurée dans votre environnement Cloud Shell). Le reste de l'atelier de programmation nécessite la version 1.2 ou ultérieure du client et du serveur 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 faire évoluer 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 doit s'exécuter sous Kubernetes, mais vous devez tout de même le rendre accessible à l'extérieur.

8. Autoriser le trafic externe

Par défaut, le pod n'est accessible que par son adresse IP interne dans le 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 à l'Internet public à l'aide de la commande kubectl expose associée à l'option --type=LoadBalancer. Cette option est obligatoire pour créer une adresse IP accessible en externe.

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

L'indicateur utilisé dans la commande indique que vous allez utiliser l'équilibreur de charge fourni par l'infrastructure sous-jacente. Notez que vous déployez directement le déploiement, et non le pod. Le service obtenu équilibrera ainsi le trafic entre tous les pods gérés par le déploiement (dans le cas présent, un seul pod, mais vous ajouterez des instances dupliquées ultérieurement).

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 pour rendre le service entièrement accessible en dehors de Google Cloud.

2. Pour trouver l'adresse IP du service accessible publiquement, demandez simplement à kubectl de répertorier 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 : Plusieurs minutes peuvent s'écouler avant que le EXTERNAL-IP ne soit disponible et visible. Si l'élément EXTERNAL-IP est manquant, attendez quelques minutes et réessayez.

3. Notez que votre service utilise deux adresses IP, chacune servant le port 8080. à savoir l'adresse IP interne qui n'est visible que dans votre cloud privé virtuel. L'autre est l'adresse IP externe avec équilibrage de charge. Dans l'exemple, l'adresse IP externe est aaa.bbb.ccc.ddd. Vous devriez maintenant pouvoir accéder au service en pointant vers http://<EXTERNAL_IP>:8080.

9. Faire évoluer votre service

L'une des puissantes fonctionnalités de Kubernetes est la simplicité de scaling de votre application. Supposons que vous ayez soudainement besoin de plus de capacité pour votre application. Vous pouvez simplement indiquer au contrôleur de réplication de gérer un nouveau nombre d'instances dupliquées pour vos instances d'applications.

$ 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 de nouvelles instances, vous déclarez le nombre d'instances à exécuter en permanence. Les boucles de rapprochement Kubernetes s'assurent simplement que la réalité correspond à ce que vous avez demandé et prend les mesures nécessaires, si nécessaire.

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

À un moment donné, des corrections de bugs ou des fonctionnalités supplémentaires seront nécessaires pour l'application que vous avez déployée en production. Kubernetes peut vous aider à déployer une nouvelle version en production sans impact sur vos utilisateurs.

1. Ouvrez l'éditeur de code en cliquant sur Launch editor (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 devraient être beaucoup plus rapides, car vous profitez pleinement de la mise en cache.

Vous êtes prêt à utiliser Kubernetes pour mettre à jour votre contrôleur de réplication de façon fluide avec la nouvelle version de l'application.

4. Pour changer le libellé de l'image de 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 par une à l'aide de mises à jour progressives.

$ kubectl set image deployment/hello-java \
  hello-java=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v2

deployment "hello-java" image updated

Remarque : Pendant ce processus, les utilisateurs des services peuvent être interrompus, mais cela peut être dû au fait qu'aucune vérification de l'état n'a été configurée. C'est une configuration légèrement plus avancée qui dépasse le cadre de l'atelier de programmation.

6. Consultez à nouveau la page http://EXTERNAL_IP:8080 pour vérifier qu'il renvoie la nouvelle réponse.

11. Rollback

Petit problème… Avez-vous fait une erreur avec une nouvelle version de l'application ? La nouvelle version contenait peut-être une erreur, et vous devez effectuer un rollback rapide. Avec Kubernetes, vous pouvez facilement revenir à l'état précédent. Effectuez un rollback de l'application en exécutant la commande suivante:

$ kubectl rollout undo deployment/hello-java

12. Félicitations

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

En savoir plus

• Java sur Google Cloud
• Exemples de code Java
• Kubernetes sur GKE : principes de base à l'édition avancée