Exemple 3 : Déployer une Application Spring Boot + Angular

Cet exemple illustre l'intégration et le déploiement d'une application composée d'un backend en Spring Boot (Java) et d'un frontend en Angular, communiquant via une API REST.

1. Contexte : L'application `crm-java-angular`

Nous avons une application CRM typique : - Backend (crm-backend) : Une API REST développée avec Spring Boot, utilisant une base de données PostgreSQL. Le code source se trouve dans crm-backend/. - Frontend (crm-frontend) : Une Single Page Application (SPA) développée avec Angular, qui consomme l'API backend. Le code source se trouve dans crm-frontend/.

Objectif : Déployer l'ensemble de manière cohérente et automatisée.

2. Étape 1 : Créer le Dossier et Intégrer le Code

nekristo-cli apps new crm-java-angular

Déplacez les dossiers crm-backend/ et crm-frontend/ dans le nouveau répertoire apps/crm-java-angular/. Votre structure devrait ressembler à :

apps/
└── crm-java-angular/
    ├── crm-backend/
    │   ├── src/
    │   ├── pom.xml ou build.gradle
    │   └── Dockerfile  <-- Important: Dockerfile personnalisé pour Spring Boot
    ├── crm-frontend/
    │   ├── src/
    │   ├── angular.json
    │   └── Dockerfile  <-- Important: Dockerfile personnalisé pour Angular
    └── nekristo.yml    <-- À créer

Note importante sur les Dockerfiles : La plateforme Nekristo fournit des templates pour Python et Node.js. Pour Java (Spring Boot) et Angular (build statique Nginx), vous devrez fournir vos propres Dockerfile optimisés (multi-stage builds recommandés).

crm-backend/Dockerfile : Typiquement, utilise une image JDK (ex: eclipse-temurin) pour compiler/packager (mvn package ou gradle build), puis une image JRE (ex: eclipse-temurin:jre) pour exécuter le .jar final.
crm-frontend/Dockerfile : Typiquement, utilise une image Node.js pour builder (npm run build), puis une image nginx:alpine pour copier les fichiers statiques du dossier dist/ et les servir.

3. Étape 2 : Le Manifeste `nekristo.yml`

Créez le fichier nekristo.yml à la racine de apps/crm-java-angular/. Il décrira les deux composants.

# apps/crm-java-angular/nekristo.yml
app_name: crm-java-angular
version: '1.0'

# Le backend a besoin d'une base de données
infra_dependencies:
  - database

components:
  # --- Composant Backend (API Spring Boot) ---
  - name: backend
    path: ./crm-backend # Chemin vers le code backend
    dockerfile: Dockerfile # Utilise le Dockerfile personnalisé dans crm-backend/

    # Commande pour lancer l'application Spring Boot (ajustez le nom du jar)
    run_command: "java -jar target/crm-backend-0.0.1-SNAPSHOT.jar"

    # Port interne exposé par Spring Boot (souvent 8080)
    # Pas de 'public_port' car l'API n'est pas directement exposée, 
    # le frontend l'appellera en interne ou via Nginx.

    # Configuration pour le développement local
    development:
      # Ex: Lancer avec Maven/Gradle pour le hot-reload Java si configuré
      # run_command: "mvn spring-boot:run" 
      volumes:
        - "./crm-backend:/app" # Monte le code backend
        # Potentiellement monter le cache Maven/Gradle pour accélérer les builds locaux
        # - "~/.m2:/root/.m2" 

    # Le backend a besoin de sa base de données
    database:
      name: "crm_db" # Sera crm_db_staging, crm_db_production...
      # Commande de migration (ex: Flyway ou Liquibase via Maven/Gradle)
      migration_command: "mvn flyway:migrate" 

    # Healthcheck via Spring Boot Actuator
    healthcheck:
      # Note: Nécessite un port exposé, même si non public. 
      # On expose 8080 pour le healthcheck interne Docker.
      path: "/actuator/health" 
      # Ajoutez une dépendance à spring-boot-starter-actuator si nécessaire

    # Déploiement standard pour le backend
    deployment:
      hooks:
        # Exécute les migrations BDD avant le déploiement
        pre_deploy: "mvn flyway:migrate" 

  # --- Composant Frontend (Angular SPA) ---
  - name: frontend
    path: ./crm-frontend # Chemin vers le code frontend
    dockerfile: Dockerfile # Utilise le Dockerfile personnalisé dans crm-frontend/

    # Nginx dans le Dockerfile écoute sur le port 80
    public_port: 80 

    # Configuration pour le développement local (Angular CLI live server)
    # C'est souvent plus simple de lancer `ng serve` localement hors Docker,
    # mais si on veut le conteneuriser :
    development:
       # run_command: "npm start" # Si package.json a "start": "ng serve --host 0.0.0.0"
       volumes:
         - "./crm-frontend:/app"
         - "/app/node_modules"
       # Exposer le port de dev Angular (souvent 4200) pour y accéder directement
       # Note: Ceci est séparé du 'public_port' utilisé par Nginx en prod
       # ports: 
       #   - "4200:4200" # Mappage direct pour `ng serve`

    # Domaines pour accéder à l'interface web
    local_domain: "crm.127.0.0.1.nip.io"
    public_domain: "crm.nekristo.com" # Remplacez par votre domaine
    letsencrypt: true

    # Healthcheck simple pour Nginx
    healthcheck:
      path: "/"
      start_period: "5s"

    # Déploiement sans interruption pour le frontend
    deployment:
      strategy: "blue-green"

# Optionnel: Section tests
# tests:
#  run_command: "mvn test && (cd crm-frontend && npm run test)" # Exemple combiné

4. Étape 3 : Gestion des Secrets

Configurez les secrets nécessaires (ex: SPRING_DATASOURCE_USERNAME, SPRING_DATASOURCE_PASSWORD pour le backend si vous n'utilisez pas les variables par défaut injectées via DATABASE_URL, clés API pour le frontend, etc.) :

nekristo-cli secrets edit --env dev
nekristo-cli secrets edit --env prod

N'oubliez pas nekristo-cli secrets apply --env dev avant le démarrage local. Le CLI injectera automatiquement DATABASE_URL basé sur la section database du backend. Spring Boot peut être configuré pour utiliser cette variable.

5. Étape 4 : Lancement et Test en Local

Infrastructure globale (nekristo-cli up).
Configuration du proxy local (nekristo-cli platform setup-proxy).
Appliquer les secrets dev (nekristo-cli secrets apply --env dev).
Démarrer l'application :

bash nekristo-cli apps start crm-java-angular

Le CLI démarrera le backend et le frontend. La base de données crm_db sera créée automatiquement. Accédez au frontend via http://crm.127.0.0.1.nip.io. Le backend sera accessible depuis le conteneur frontend via http://backend:8080 (Docker Compose crée ce nom DNS). Assurez-vous que votre configuration Angular (ex: environment.ts) utilise l'URL correcte pour l'API en développement et en production.

(Optionnel) Lancer les tests :

bash nekristo-cli apps test crm-java-angular

6. Étape 5 : Préparation au Déploiement

Vérifiez platform.yml.
Générez le workflow CI/CD (nekristo-cli ci gen-workflow).
Configurez les secrets GitHub Actions (via ci setup-secrets ou manuellement).

7. Étape 6 : Déploiement Automatisé

Poussez sur la branche de déploiement. Le workflow va :

Valider, tester.
Construire les images Docker pour le backend et le frontend.
Scanner les images.
Créer la base de données de production (crm_db_production).
Exécuter les migrations (mvn flyway:migrate).
Déployer le backend (rolling update).
Déployer le frontend (blue-green).
Configurer Nginx et SSL pour le frontend.