Déployer son application Spring Boot dans le cloud
Partie 1 – Configurer son environnement de cloud avec Minikube, Kubernetes et Docker Compose en local
Rédigé par : Adnene Hamdouni
Chaque semaine, retrouvez sur notre blog un article relatif à notre série « Guide pratique dédié à la sécurisation d’une application Java Spring Boot et son déploiement dans le Cloud AWS ». L’objectif est de réaliser, pas à pas, la configuration d’un environnement sécurisé, la création d’une API et in fine, son déploiement dans le cloud.
Introduction
Après avoir abordé la question des applications micro-frontends dans l’article précédent, nous vous guidons aujourd’hui, pas à pas, dans la configuration de votre environnement cloud avec Minikube, Kubernetes et Docker Compose.
Visualisez quelques minutes : imaginez-vous entrain de déployer votre application Spring Boot backend avec une intégration Keycloak, tout ça sur votre propre machine locale. Et bien c’est l’objectif cette première partie. Nous allons préparer notre environnement cloud. Dans la partie suivante qui sera publiée la semaine prochaine, nous vous donnerons les clés pour déployer votre application Spring Boot backend.
Prérequis et configuration initiale
Avant de plonger dans le code, assurez-vous d’avoir les outils nécessaires :
- Java 17 : pour profiter des dernières fonctionnalités,
- Spring Boot 3+ : pour rester à jour et profiter des meilleures pratiques,
- Docker : pour containeriser nos applications,
- Minikube : pour un cluster Kubernetes local,
- Kubectl : pour interagir avec Kubernetes,
- Maven : pour construire et gérer notre projet Java.
Installation des outils
1. Docker
Docker est essentiel pour containériser notre application. Voici comment l’installer :
- Télécharger et installer Docker :
Sous Linux :
curl -fsSL https://get.docker.com -o get-docker.sh sh get-dcker.sh
Sous macOS :
- Téléchargez Docker Desktop depuis docker.com
- Suivez les instructions d’installation.
Sous Windows :
- Téléchargez Docker Desktop depuis docker.com
- Suivez les instructions d’installation.
2. Vérifiez l’installation
2. Minikube
Minikube va nous permettre de créer un cluster Kubernetes local. Voici comment l’installer :
- Télécharger et installer Minikube :
Sous Linux :
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube
Sous macOS :
brew install minikube
Sous Windows :
- Téléchargez Minikube depuis ce lien.
- Suivez les instructions d’installation.
- Ensuite, démarrez Minikube :
minikube start
3. Kubectl
Kubectl est l’outil de ligne de commande pour interagir avec Kubernetes.
- Télécharger et installer Kubectl :
Sous Linux :
curl -LO « https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl »
chmod +x kubectl
sudo mv kubectl /usr/local/bin/
Sous macOS :
brew install kubectl
Sous Windows :
- Téléchargez Kubectl depuis ce lien.
- Suivez les instructions d’installation.
- Vérifiez l’installation :
kubectl version –client
4. Maven
Maven sera notre gestionnaire de build pour Java.
- Télécharger et installer Maven :
Sous Linux :
sudo apt update
sudo apt install maven
Sous macOS :
brew install maven
Sous Windows :
- Téléchargez Maven depuis ce lien.
- Décompressez ensuite le fichier et ajoutez bin à votre PATH.
- Vérifiez l’installation :
Configuration initiale
Une fois que tous les outils sont installés, nous devons nous assurer que Docker est en cours d’exécution et que Minikube peut interagir avec Docker :
1. Lancez Docker (si ce n’est pas déjà fait) :
sudo systemctl start docker
2. Configurez Minikube pour utiliser Docker comme runtime de conteneur :
minikube config set driver docker
3. Démarrez Minikube :
minikube start
4. Vérifiez que tout fonctionne :
kubectl get nodes
Si tout est en ordre, vous devriez voir votre cluster Minikube en cours d’exécution.
Containérisation et déploiement de l’application Spring Boot backend
Maintenant, entrons dans le vif du sujet avec l’application Spring Boot backend. Tout d’abord, assurons-nous que notre application Spring Boot est prête à être containérisée.
1. Dockerfile pour l’application Spring Boot backend
Créez un fichier Dockerfile pour l’application backend :
Dockerfile – Backend
FROM openjdk:17-jdk-slim
VOLUME /tmp
COPY target/oauthclient-backend.jar oauthclient-backend.jar
ENTRYPOINT [« java »,-jar »/oauthclient-backend.jar »]
Assurez-vous que l’application est prête pour être construite avec Maven :
mvn clean package
Ensuite, construisons notre image Docker :
docker build -t oauthclient-backend:latest -f Dockerfile .
Et voilà ! L’application backend est désormais une image Docker prête à être déployée.
2. Utilisation de Docker Compose pour exécuter le Dockerfile
Nous allons à présent utiliser Docker Compose pour exécuter notre Dockerfile et lancer notre application backend ainsi que Keycloak. Voici comment configurer Docker Compose pour cette tâche.
Créez un fichier docker-compose.yml pour orchestrer les services :
Dans ce fichier docker-compose.yml, nous avons deux services : Keycloak et notre application backend. Keycloak est configuré pour utiliser une base de données H2 en mémoire, et notre application backend est construite à partir du Dockerfile que nous avons créé précédemment.
Pour exécuter les services, lancez simplement :
docker-compose up –build -d
Cette commande va construire l’image Docker pour l’application backend et démarrer les deux services en arrière-plan.
3. Vérification et gestion des services
Pour vérifier que les services sont en cours d’exécution, utilisez :
docker-compose ps
Vous devriez voir les deux services (Keycloak et backend-app) en cours d’exécution. Pour voir les logs des services, utilisez :
docker-compose logs -f
La commande ci-dessus vous permettra de suivre les logs en temps réel, ce qui est utile pour le débogage et la vérification du bon fonctionnement de votre application.
4. Mise en place de Kubernetes et Minikube
Notre cluster Minikube est désormais en route. Il nous faut maintenant le configurer pour notre application backend. Créez les fichiers de déploiement pour l’application backend :
Appliquez ce fichier à votre cluster Kubernetes :
kubectl apply -f deployment-backend.yaml
Vérifiez ensuite que tout fonctionne :
kubectl get deployments
kubectl get pods
Accès au tableau de bord Kubernetes
Le tableau de bord Kubernetes est un outil graphique très utile pour gérer et surveiller votre cluster Kubernetes. Voici comment l’installer et y accéder :
1. Déployer le tableau de bord Kubernetes :
kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/v2.2.0/aio/deploy/recommended.yaml
2. Créer un compte administrateur pour le tableau de bord :
apiVersion: v1
kind: ServiceAccount
metadata:
name: admin-user
namespace: kubernetes-dashboard
—
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
name: admin-user
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: cluster-admin
subjects:
– kind: ServiceAccount
name: admin-user
namespace: kubernetes-dashboard
3. Appliquer cette configuration :
kubectl apply -f admin-user.yaml
4. Accéder au tableau de bord :
kubectl proxy
L’interface s’affiche via l’url : http://localhost:8001/api/v1/namespaces/kubernetes-dashboard/services/https:kubernetes-dashboard:/proxy/#/login
Tableau de bord Kubernetes
Ouvrez votre navigateur et allez à http://localhost:8001/api/v1/namespaces/kubernetes-dashboard/services/https:kubernetes-dashboard:/proxy/.
5. Obtenez un token de connexion via la commande :
kubectl -n kubernetes-dashboard create token admin-user
Voici un exemple de token :
Utilisez ensuite ce token pour vous connecter au tableau de bord Kubernetes.
Interface Kubernetes – Déploiements actifs
Bonnes pratiques en développement backend et cloud
Pour garantir la sécurité, la scalabilité et l’efficacité de votre application, suivez ces bonnes pratiques :
- Sécurisez vos endpoints : utilisez OAuth2, JWT, et Keycloak pour des API bien protégées.
- Scalabilité : configurez vos réplicas dans Kubernetes pour gérer la charge.
- Automatisation : utilisez des pipelines CI/CD pour automatiser les déploiements (par exemple, GitHub Actions ou Jenkins).
Gestion DevOps et suivi des Logs
Pour rappel, nous avons couvert dans cet article les étapes de base pour déployer votre application Spring Boot sur un cluster Kubernetes local avec Minikube. Cependant, pour une gestion et un suivi complets dans un environnement de production, il existe d’autres aspects importants à prendre en compte.
Conclusion
Félicitations ! Vous devez normalement avoir réussi à configurer Kubernetes via Minikube et à poser les premières briques de la configuration de votre application Spring Boot dans le cloud. Cependant, la configuration de l’environnement n’est que la première étape.
Dans le prochain article, nous explorerons en profondeur les aspects liés au déploiement de votre application Spring Boot sur un cluster Kubernetes local via Minikube et Docker Compose, tout en suivant les meilleures pratiques de développement backend et cloud. Dans les prochains articles, vous découvrirez également les aspects du déploiement continu (CI/CD), des tests, de la surveillance des pods et de la gestion des logs pour une application Spring Boot déployée sur Kubernetes dans un environnement de production, en utilisant des outils comme Grafana et Prometheus. Continuez à explorer et à apprendre, car le monde du cloud et du DevOps est vaste et plein de possibilités.
