Automatisation du déploiement Docker d'applications Spring Boot et Angular sur un serveur Linux

Le développement d'applications web modernes implique souvent la gestion de plusieurs composants : un backend robuste (comme Spring Boot) et un frontend interactif (comme Angular). Le déploiement de ces architectures sur un serveur de production peut rapidement devenir complexe et source d'erreurs s'il n'est pas géré efficacement. C'est là que l'automatisation, appuyée par des technologies comme Docker, prend toute son importance.

Dans cet article, il est exploré comment les développeurs peuvent rationaliser ce processus en conteneurisant leurs applications Spring Boot et Angular, puis en automatisant leur déploiement sur un serveur Linux. Cette approche, essentielle pour tout Développeur Full Stack, permet non seulement de garantir la cohérence des environnements, mais aussi d'accélérer les cycles de livraison et de minimiser les interventions manuelles.

Laty Gueye Samba, Développeur Full Stack basé à Dakar, Sénégal, spécialiste en Java Spring Boot et Angular, met régulièrement en œuvre ces pratiques d'automatisation. Son expertise dans le déploiement d'applications complexes souligne l'importance de ces méthodologies pour des projets modernes, qu'il s'agisse de systèmes ERP ou d'applications de gestion des risques.

1. Conteneurisation des applications avec Docker

La première étape vers l'automatisation consiste à encapsuler chaque composant de l'application (backend Spring Boot et frontend Angular) dans un conteneur Docker distinct. Un conteneur fournit un environnement isolé et portable, garantissant que l'application s'exécutera de la même manière, quel que soit l'environnement hôte.

Dockerfile pour l'application Spring Boot

Pour une application Spring Boot, le Dockerfile doit compiler le projet (si ce n'est pas déjà fait) et créer une image légère basée sur une distribution Java Runtime Environment (JRE). Il est recommandé d'utiliser une image OpenJDK Alpine pour sa taille réduite.

# Utilisation d'une image JRE optimisée pour les applications Spring Boot
FROM openjdk:17-jre-slim-buster

# Informations sur le mainteneur (optionnel)
LABEL maintainer="Laty Gueye Samba"

# Ajout des arguments pour le fichier JAR
ARG JAR_FILE=target/*.jar

# Copie du fichier JAR de l'application dans le conteneur
COPY ${JAR_FILE} app.jar

# Port exposé par l'application (par défaut pour Spring Boot)
EXPOSE 8080

# Commande pour exécuter l'application Spring Boot
ENTRYPOINT ["java","-jar","/app.jar"]
    

Après avoir placé ce fichier dans le répertoire racine du projet Spring Boot, l'image peut être construite avec la commande :

docker build -t nom-backend-spring .
    

Dockerfile pour l'application Angular

Pour l'application Angular, le processus est légèrement plus complexe. Il faut d'abord compiler le projet Angular pour produire les fichiers statiques de production, puis servir ces fichiers via un serveur web léger comme Nginx.

# Étape 1 : Construction de l'application Angular
FROM node:18-alpine as builder

# Définition du répertoire de travail
WORKDIR /app

# Copie des fichiers package.json et package-lock.json
COPY package.json package-lock.json ./

# Installation des dépendances
RUN npm install

# Copie du reste des fichiers de l'application
COPY . .

# Construction de l'application Angular en mode production
RUN npm run build --configuration=production

# Étape 2 : Servir l'application avec Nginx
FROM nginx:alpine

# Copie des fichiers de configuration Nginx personnalisés (si nécessaire)
# Par exemple, si vous avez un fichier nginx.conf dans un dossier ./nginx
# COPY ./nginx/nginx.conf /etc/nginx/conf.d/default.conf

# Copie des fichiers de construction d'Angular dans le répertoire de service de Nginx
COPY --from=builder /app/dist/votre-projet-angular /usr/share/nginx/html

# Port par défaut de Nginx
EXPOSE 80

# Commande pour démarrer Nginx
CMD ["nginx", "-g", "daemon off;"]
    

De même, après avoir placé ce Dockerfile dans le répertoire racine du projet Angular, l'image est construite via :

docker build -t nom-frontend-angular .
    

2. Orchestration du déploiement avec Docker Compose

Une fois les images Docker des applications Spring Boot et Angular prêtes, Docker Compose devient l'outil idéal pour définir et exécuter des applications multi-conteneurs. Un seul fichier docker-compose.yml permet de décrire les services, les réseaux et les volumes nécessaires à l'ensemble de l'architecture.

Exemple de fichier docker-compose.yml

Ce fichier définit le backend Spring Boot, le frontend Angular (servi par Nginx) et, pour la complétude, une base de données PostgreSQL.

version: '3.8'

services:
  backend:
    image: nom-backend-spring
    container_name: backend-service
    ports:
      - "8080:8080"
    environment:
      SPRING_DATASOURCE_URL: jdbc:postgresql://db:5432/votre_db
      SPRING_DATASOURCE_USERNAME: votre_user
      SPRING_DATASOURCE_PASSWORD: votre_password
    depends_on:
      - db
    networks:
      - app-network

  frontend:
    image: nom-frontend-angular
    container_name: frontend-service
    ports:
      - "80:80"
    depends_on:
      - backend
    networks:
      - app-network

  db:
    image: postgres:13
    container_name: postgres-db
    environment:
      POSTGRES_DB: votre_db
      POSTGRES_USER: votre_user
      POSTGRES_PASSWORD: votre_password
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - app-network

volumes:
  db_data:

networks:
  app-network:
    driver: bridge
    

Pour lancer l'ensemble des services définis, une simple commande suffit :

docker-compose up -d
    

Cette commande construit et démarre tous les conteneurs en arrière-plan, en gérant leurs dépendances et leurs réseaux. La cohérence et la reproductibilité du déploiement sont ainsi grandement améliorées.

3. Automatisation du déploiement sur un serveur Linux

L'automatisation du déploiement sur un serveur Linux implique généralement l'utilisation de scripts et, idéalement, d'outils d'intégration et de déploiement continus (CI/CD). L'objectif est de rendre le processus de mise à jour ou de déploiement initial aussi simple qu'une seule commande ou le push d'un commit.

Pré-requis sur le serveur Linux

Le serveur cible doit avoir Docker et Docker Compose installés. Les clés SSH doivent être configurées pour permettre l'accès au dépôt de code (Gitlab, GitHub, etc.) sans intervention manuelle.

Script de déploiement simple

Pour un début d'automatisation, il est possible de créer un script shell qui exécute les étapes nécessaires au déploiement. Ce script peut être exécuté manuellement ou déclenché par un webhook ou un outil CI/CD.

#!/bin/bash

# Définition des variables
REPO_DIR="/opt/mon-app-fullstack"
GIT_REPO_URL="https://github.com/votre-utilisateur/votre-projet.git" # OU SSH git@github.com:...

# Mettre à jour le code source
echo "Mise à jour du dépôt Git..."
if [ -d "$REPO_DIR" ]; then
  cd "$REPO_DIR"
  git pull origin main # ou la branche appropriée
else
  git clone "$GIT_REPO_URL" "$REPO_DIR"
  cd "$REPO_DIR"
fi

# Construire les images Docker
echo "Construction des images Docker Spring Boot et Angular..."
docker build -t nom-backend-spring -f backend/Dockerfile .
docker build -t nom-frontend-angular -f frontend/Dockerfile .

# Arrêter et supprimer les anciens conteneurs, puis démarrer les nouveaux avec Docker Compose
echo "Redémarrage des services avec Docker Compose..."
docker-compose down # Arrête et supprime les conteneurs et réseaux précédents
docker-compose up -d # Démarre les nouveaux services en arrière-plan

echo "Déploiement terminé !"
    

Ce script, exécuté sur le serveur Linux, permet à Laty Gueye Samba et à tout développeur Full Stack d'automatiser le processus de mise à jour. Pour des déploiements plus avancés, l'intégration avec des outils CI/CD tels que GitHub Actions, GitLab CI ou Jenkins est la prochaine étape logique, permettant des déclenchements automatiques à chaque push sur la branche principale par exemple.

Conclusion

L'automatisation du déploiement Docker d'applications Spring Boot et Angular sur un serveur Linux est une pratique fondamentale pour tout Développeur Full Stack moderne. Elle assure non seulement la cohérence des environnements de développement et de production, mais réduit également considérablement les erreurs manuelles et le temps nécessaire aux mises à jour. Des professionnels comme Laty Gueye Samba, expert en Java Spring Boot et Angular à Dakar, démontrent l'efficacité de ces méthodes dans le développement et le maintien d'applications robustes et performantes.

En adoptant la conteneurisation avec Docker et l'orchestration avec Docker Compose, puis en intégrant ces processus dans des scripts ou des pipelines CI/CD, les équipes peuvent se concentrer davantage sur le développement de fonctionnalités innovantes, plutôt que sur les défis du déploiement. C'est une stratégie gagnante pour améliorer la productivité et la qualité des logiciels.

Ressources supplémentaires :

• Documentation officielle Docker
• Documentation officielle Docker Compose
• Déploiement Spring Boot avec Docker
• Guide de déploiement Angular