Aller au contenu principal

Chapitre 1: Préparation pour Production

Introduction​

Avant de déployer, il faut préparer votre application. Ce chapitre couvre le packaging, les profils, et la gestion des configurations.

🎯 Objectifs du Chapitre​

À la fin de ce chapitre, vous saurez:

  1. ✅ Créer un JAR exécutable
  2. ✅ Configurer les profils Spring
  3. ✅ Externaliser la configuration
  4. ✅ Gérer les secrets de manière sécurisée
  5. ✅ Optimiser pour la production

1. Packaging: JAR vs WAR​

JAR Exécutable (Recommandé)​

Spring Boot crée un fat JAR contenant tout:

# Build
mvn clean package

# Exécuter
java -jar target/myapp-1.0.0.jar

Avantages:

  • ✅ Serveur Tomcat embarqué
  • ✅ Simple à déployer
  • ✅ Portable
  • ✅ Parfait pour Docker

WAR (Serveur externe)​

Pour déployer sur Tomcat/JBoss existant:

<!-- pom.xml -->
<packaging>war</packaging>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-tomcat</artifactId>
        <scope>provided</scope>
    </dependency>
</dependencies>
// Modifier la classe principale
@SpringBootApplication
public class Application extends SpringBootServletInitializer {
    
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(Application.class);
    }
    
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

Recommandation​

JAR pour:
- Docker / Kubernetes
- Cloud (Heroku, Railway, AWS)
- Microservices

WAR pour:
- Infrastructure legacy
- Serveurs d'applications existants

2. Profils Spring​

Définir des Profils​

src/main/resources/
├── application.properties          # Configuration commune
├── application-dev.properties      # Développement
├── application-prod.properties     # Production
└── application-test.properties     # Tests

application.properties (commun)​

spring.application.name=myapp
server.port=8080

# Profil par défaut
spring.profiles.active=dev

application-dev.properties​

# Base de données H2 en mémoire
spring.datasource.url=jdbc:h2:mem:devdb
spring.datasource.driver-class-name=org.h2.Driver
spring.h2.console.enabled=true

# JPA
spring.jpa.hibernate.ddl-auto=create-drop
spring.jpa.show-sql=true

# Logging verbose
logging.level.com.myapp=DEBUG
logging.level.org.hibernate.SQL=DEBUG

# Actuator: tout exposer en dev
management.endpoints.web.exposure.include=*

application-prod.properties​

# PostgreSQL en production
spring.datasource.url=${DATABASE_URL}
spring.datasource.username=${DB_USERNAME}
spring.datasource.password=${DB_PASSWORD}

# JPA
spring.jpa.hibernate.ddl-auto=validate
spring.jpa.show-sql=false

# Logging minimal
logging.level.root=WARN
logging.level.com.myapp=INFO

# Actuator: sécurisé
management.endpoints.web.exposure.include=health,info,prometheus
management.endpoint.health.show-details=when_authorized

# Sécurité
server.error.include-stacktrace=never

Activer un Profil​

# Via argument JVM
java -jar myapp.jar --spring.profiles.active=prod

# Via variable d'environnement
export SPRING_PROFILES_ACTIVE=prod
java -jar myapp.jar

# Via Docker
docker run -e SPRING_PROFILES_ACTIVE=prod myapp

3. Configuration Externalisée​

Ordre de Priorité​

Spring Boot charge la configuration dans cet ordre (priorité croissante):

1. application.properties (dans le JAR)
2. application-{profile}.properties (dans le JAR)
3. application.properties (hors du JAR)
4. application-{profile}.properties (hors du JAR)
5. Variables d'environnement
6. Arguments de ligne de commande

Variables d'Environnement​

# application.properties
spring.datasource.url=${DATABASE_URL:jdbc:h2:mem:default}
spring.datasource.username=${DB_USER:sa}
spring.datasource.password=${DB_PASS:}
# Définir les variables
export DATABASE_URL=jdbc:postgresql://localhost:5432/mydb
export DB_USER=myuser
export DB_PASS=secret

java -jar myapp.jar

Configuration YAML (alternative)​

# application.yml
spring:
  application:
    name: myapp
  profiles:
    active: dev

---
spring:
  config:
    activate:
      on-profile: dev
  datasource:
    url: jdbc:h2:mem:devdb
  h2:
    console:
      enabled: true

---
spring:
  config:
    activate:
      on-profile: prod
  datasource:
    url: ${DATABASE_URL}
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}

4. Gestion des Secrets​

❌ Ne Jamais Faire​

# JAMAIS dans le code source!
spring.datasource.password=MySecretPassword123
api.key=sk-1234567890abcdef

✅ Bonnes Pratiques​

Option 1: Variables d'Environnement​

export DB_PASSWORD=secret
export API_KEY=sk-xxx

Option 2: Fichier .env (local seulement)​

# .env (ajouter à .gitignore!)
DATABASE_URL=jdbc:postgresql://localhost:5432/mydb
DB_PASSWORD=secret
API_KEY=sk-xxx

Option 3: Secrets Managers​

# Kubernetes Secret
apiVersion: v1
kind: Secret
metadata:
  name: myapp-secrets
type: Opaque
data:
  db-password: c2VjcmV0  # base64

Option 4: Spring Cloud Config​

# Pour les secrets centralisés
spring:
  cloud:
    config:
      uri: http://config-server:8888

.gitignore​

# Secrets
.env
*.pem
*.key
application-local.properties
secrets/

5. Optimisations Production​

Configuration JVM​

# Production JVM settings
java -Xms512m -Xmx1024m \
     -XX:+UseG1GC \
     -XX:MaxGCPauseMillis=200 \
     -Djava.security.egd=file:/dev/./urandom \
     -jar myapp.jar

application-prod.properties​

# Compression des réponses
server.compression.enabled=true
server.compression.mime-types=application/json,text/html,text/css
server.compression.min-response-size=1024

# Connection pool optimisé
spring.datasource.hikari.maximum-pool-size=20
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.idle-timeout=300000

# Cache des templates
spring.thymeleaf.cache=true

# Désactiver les features de dev
spring.devtools.restart.enabled=false
spring.h2.console.enabled=false

Graceful Shutdown​

# Attendre la fin des requêtes en cours
server.shutdown=graceful
spring.lifecycle.timeout-per-shutdown-phase=30s

6. Build pour Production​

Maven​

# Build avec profil prod
mvn clean package -Pprod -DskipTests

# Ou avec le profil Spring
mvn clean package -Dspring.profiles.active=prod

pom.xml - Profils Maven​

<profiles>
    <profile>
        <id>dev</id>
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
        <properties>
            <spring.profiles.active>dev</spring.profiles.active>
        </properties>
    </profile>
    
    <profile>
        <id>prod</id>
        <properties>
            <spring.profiles.active>prod</spring.profiles.active>
        </properties>
    </profile>
</profiles>

<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <filtering>true</filtering>
        </resource>
    </resources>
</build>

Vérifier le JAR​

# Contenu du JAR
jar tf target/myapp-1.0.0.jar

# Tester localement
java -jar target/myapp-1.0.0.jar --spring.profiles.active=prod

7. Résumé​

Checklist Production​

□ JAR exécutable créé
□ Profils configurés (dev, prod, test)
□ Secrets externalisés (pas dans le code)
□ Variables d'environnement documentées
□ Logging configuré (pas DEBUG en prod)
□ Actuator sécurisé
□ Compression activée
□ Connection pool configuré
□ Graceful shutdown activé

Fichiers de Configuration​

application.properties        → Configuration commune
application-dev.properties    → H2, DEBUG, tout exposé
application-prod.properties   → PostgreSQL, WARN, sécurisé
application-test.properties   → H2, pour les tests

Variables Essentielles​

SPRING_PROFILES_ACTIVE=prod
DATABASE_URL=jdbc:postgresql://...
DB_USERNAME=myuser
DB_PASSWORD=secret
SERVER_PORT=8080

🎯 Prochaine Étape​

L'application est prête. Maintenant, conteneurisons-la avec Docker!

➡️ Chapitre 2: Conteneurisation Docker

⬅️ Retour au Module 12