Framework Java Spring et GitHub Actions
Ce cours offre une introduction complète aux pratiques de Développement Continu (Continuous Development) et d'Intégration Continue (Continuous Integration), avec un focus particulier sur l'implémentation avec le framework Java Spring et l'utilisation de GitHub Actions pour l'automatisation des pipelines CI/CD.
Les étudiants apprendront à concevoir, configurer et maintenir des pipelines CI/CD efficaces pour des applications Spring Boot, en automatisant les processus de build, test, et déploiement. Le cours couvre les meilleures pratiques de l'industrie, les outils modernes, et les stratégies de déploiement automatisé.
L'Intégration Continue (Continuous Integration) est une pratique de développement logiciel où les développeurs intègrent fréquemment leur code dans un dépôt partagé, idéalement plusieurs fois par jour. Chaque intégration déclenche automatiquement un build et des tests automatisés pour détecter rapidement les erreurs d'intégration.
Principes fondamentaux de l'Intégration Continue :
Avantages de l'Intégration Continue :
Le Déploiement Continu (Continuous Deployment) est une extension de l'Intégration Continue qui automatise le déploiement des applications en production après chaque build réussi. Le Déploiement Continu permet de livrer rapidement de nouvelles fonctionnalités aux utilisateurs finaux.
Différence entre Continuous Delivery et Continuous Deployment :
Avantages du Déploiement Continu :
Un pipeline CI/CD est une série d'étapes automatisées qui transforment le code source en une application déployée. Un pipeline typique comprend :
Spring Boot est particulièrement bien adapté aux pratiques CI/CD grâce à ses caractéristiques :
Un projet Spring Boot bien structuré pour CI/CD doit inclure :
Spring Boot supporte à la fois Maven et Gradle comme outils de build. Les deux permettent de :
Commandes Maven essentielles :
mvn clean : Nettoie le répertoire targetmvn compile : Compile le code sourcemvn test : Exécute les testsmvn package : Crée le JAR/WARmvn install : Installe l'artefact dans le dépôt localmvn spring-boot:run : Lance l'application Spring BootCommandes Gradle essentielles :
./gradlew clean : Nettoie le répertoire build./gradlew build : Compile, teste et crée l'artefact./gradlew test : Exécute les tests./gradlew bootRun : Lance l'application Spring BootSpring Boot fournit un support complet pour les tests avec Spring Test, Mockito, et JUnit 5. Les types de tests incluent :
Les tests Spring Boot peuvent utiliser @SpringBootTest pour charger le contexte complet
de l'application, ou @WebMvcTest pour tester uniquement la couche web.
GitHub Actions est une plateforme d'automatisation CI/CD intégrée directement dans GitHub. Elle permet d'automatiser les workflows de développement logiciel directement depuis votre dépôt GitHub, sans nécessiter de serveur externe.
Avantages de GitHub Actions :
Les workflows GitHub Actions sont définis dans des fichiers YAML placés dans le répertoire
.github/workflows/. Un workflow typique comprend :
Voici un exemple de workflow GitHub Actions complet pour une application Spring Boot :
name: CI/CD Pipeline
on:
push:
branches: [ main, develop ]
pull_request:
branches: [ main ]
jobs:
build-and-test:
runs-on: ubuntu-latest
strategy:
matrix:
java-version: [11, 17]
steps:
- uses: actions/checkout@v3
- name: Set up JDK ${{ matrix.java-version }}
uses: actions/setup-java@v3
with:
java-version: ${{ matrix.java-version }}
distribution: 'temurin'
cache: maven
- name: Build with Maven
run: mvn clean compile
- name: Run tests
run: mvn test
- name: Generate test report
uses: dorny/test-reporter@v1
if: always()
with:
name: Maven Tests
path: target/surefire-reports/*.xml
reporter: java-junit
- name: Build JAR
run: mvn package -DskipTests
- name: Upload artifacts
uses: actions/upload-artifact@v3
with:
name: application-jar
path: target/*.jar
docker-build:
needs: build-and-test
runs-on: ubuntu-latest
if: github.ref == 'refs/heads/main'
steps:
- uses: actions/checkout@v3
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v2
- name: Login to Docker Hub
uses: docker/login-action@v2
with:
username: ${{ secrets.DOCKER_USERNAME }}
password: ${{ secrets.DOCKER_PASSWORD }}
- name: Build and push Docker image
uses: docker/build-push-action@v4
with:
context: .
push: true
tags: username/app:latest
deploy:
needs: docker-build
runs-on: ubuntu-latest
if: github.ref == 'refs/heads/main'
steps:
- name: Deploy to production
uses: appleboy/ssh-action@master
with:
host: ${{ secrets.HOST }}
username: ${{ secrets.USERNAME }}
key: ${{ secrets.SSH_KEY }}
script: |
docker pull username/app:latest
docker-compose up -dPlusieurs actions populaires sont disponibles pour les projets Spring Boot :
GitHub Actions permet de tester votre application sur plusieurs versions de Java et systèmes d'exploitation simultanément en utilisant une stratégie de matrice :
strategy:
matrix:
java-version: [11, 17, 21]
os: [ubuntu-latest, windows-latest, macos-latest]
fail-fast: falseCette configuration exécutera les tests sur 9 combinaisons différentes (3 versions Java × 3 OS), permettant de détecter les problèmes de compatibilité rapidement.
GitHub Actions fournit un système sécurisé pour gérer les secrets (mots de passe, clés API, tokens, etc.) :
${{ secrets.SECRET_NAME }}Exemples de secrets typiques pour un projet Spring Boot :
GitHub Actions permet de contrôler l'exécution des workflows avec des conditions :
Exemple d'utilisation des environnements pour protéger la production :
deploy-production:
runs-on: ubuntu-latest
environment: production
steps:
- name: Deploy
run: ./deploy.shUne stratégie de branches bien définie est essentielle pour un CI/CD efficace :
Les tests doivent être organisés en plusieurs niveaux dans le pipeline :
Le principe du "test pyramid" suggère d'avoir beaucoup de tests unitaires rapides, moins de tests d'intégration, et encore moins de tests end-to-end lents.
Les applications doivent être testées dans plusieurs environnements avant la production :
Chaque environnement doit avoir sa propre configuration (base de données, services externes, etc.) gérée via des variables d'environnement ou des profils Spring.
Un pipeline CI/CD robuste doit inclure des stratégies de rollback :
Le monitoring est crucial pour détecter les problèmes en production :
Spring Boot Actuator fournit des endpoints de monitoring prêts à l'emploi pour la santé de l'application, les métriques, et plus encore.
Containeriser une application Spring Boot avec Docker permet d'assurer la cohérence entre les environnements. Voici un exemple de Dockerfile optimisé :
# Stage 1: Build
FROM maven:3.8.6-eclipse-temurin-17 AS build
WORKDIR /app
COPY pom.xml .
RUN mvn dependency:go-offline
COPY src ./src
RUN mvn clean package -DskipTests
# Stage 2: Runtime
FROM eclipse-temurin:17-jre-alpine
WORKDIR /app
COPY --from=build /app/target/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]Ce Dockerfile utilise un build multi-stage pour créer une image finale légère, ne contenant que le JAR et le runtime Java.
GitHub Actions peut automatiquement builder et publier des images Docker vers des registries comme Docker Hub, GitHub Container Registry, ou AWS ECR. Cela permet de déployer facilement des applications containerisées.
Le déploiement automatique peut être configuré pour différents environnements :
Les workflows GitHub Actions peuvent envoyer des notifications :
L'analyse statique de code peut être intégrée dans le pipeline :
À l'issue de ce cours, les étudiants seront capables de :
L'évaluation du cours comprend des projets pratiques où les étudiants doivent :
Les étudiants sont attendus de démontrer leur compréhension des concepts CI/CD, leur capacité à configurer des pipelines automatisés, et leur maîtrise des outils modernes de développement continu à travers leurs implémentations pratiques.