mic-after-work-server-impl-quarkus-main/DEPLOYMENT.md

🚀 Guide de Déploiement AfterWork Server

📋 Vue d'Ensemble

Ce guide décrit le processus de déploiement de l'API AfterWork sur le VPS via lionesctl pipeline.

URL de l'API : https://api.lions.dev/afterwork

---

🔧 Prérequis

Environnement Local

• Java 17 (JDK)
• Maven 3.9+
• Docker 20.10+
• lionesctl CLI installé et configuré

Environnement Serveur

• PostgreSQL 15+
• Kubernetes cluster configuré
• Ingress Controller (nginx)
• Cert-Manager pour les certificats SSL (Let's Encrypt)

---

📁 Fichiers de Configuration

1. Variables d'Environnement Requises

Les variables suivantes doivent être définies dans Kubernetes Secrets :

DB_HOST: postgres          # Hostname du serveur PostgreSQL
DB_PORT: 5432              # Port PostgreSQL
DB_NAME: afterwork_db      # Nom de la base de données
DB_USERNAME: afterwork     # Utilisateur de la base de données
DB_PASSWORD: <secret>      # Mot de passe (à définir dans le secret)

2. Dockerfile.prod

Le fichier Dockerfile.prod utilise une approche multi-stage :

• Stage 1 : Build avec Maven dans une image UBI8 OpenJDK 17
• Stage 2 : Runtime optimisé avec l'uber-jar compilé

3. application-prod.properties

Configuration production avec :

• Context path : /afterwork
• CORS : https://afterwork.lions.dev
• Health checks : /q/health/ready et /q/health/live
• Métriques : /q/metrics

---

🏗️ Build de l'Image Docker

Build Local (Test)

# Build de l'image
docker build -f Dockerfile.prod -t afterwork-api:latest .

# Test local
docker run -p 8080:8080 \
  -e DB_HOST=localhost \
  -e DB_PORT=5432 \
  -e DB_NAME=afterwork_db \
  -e DB_USERNAME=afterwork \
  -e DB_PASSWORD=changeme \
  afterwork-api:latest

Build pour Registry

# Tag pour le registry
docker tag afterwork-api:latest registry.lions.dev/afterwork-api:1.0.0
docker tag afterwork-api:latest registry.lions.dev/afterwork-api:latest

# Push vers le registry
docker push registry.lions.dev/afterwork-api:1.0.0
docker push registry.lions.dev/afterwork-api:latest

---

🚢 Déploiement avec lionesctl

Commande de Déploiement

# Déploiement via lionesctl pipeline
lionesctl pipeline deploy \
  --app afterwork-api \
  --image registry.lions.dev/afterwork-api:1.0.0 \
  --namespace applications \
  --port 8080 \
  --replicas 2

# Ou avec le fichier de configuration
lionesctl pipeline deploy -f kubernetes/afterwork-deployment.yaml

Vérification du Déploiement

# Status du déploiement
lionesctl pipeline status --app afterwork-api

# Logs en temps réel
lionesctl pipeline logs --app afterwork-api --follow

# Health check
curl https://api.lions.dev/afterwork/q/health/ready

---

📦 Structure Kubernetes

1. Secret (kubernetes/afterwork-secrets.yaml)

apiVersion: v1
kind: Secret
metadata:
  name: afterwork-secrets
  namespace: applications
type: Opaque
stringData:
  DB_PASSWORD: "CHANGE_ME_IN_PRODUCTION"

2. ConfigMap (kubernetes/afterwork-configmap.yaml)

apiVersion: v1
kind: ConfigMap
metadata:
  name: afterwork-config
  namespace: applications
data:
  DB_HOST: "postgres"
  DB_PORT: "5432"
  DB_NAME: "afterwork_db"
  DB_USERNAME: "afterwork"
  QUARKUS_PROFILE: "prod"
  TZ: "Africa/Douala"

3. Deployment (kubernetes/afterwork-deployment.yaml)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: afterwork-api
  namespace: applications
  labels:
    app: afterwork-api
    version: 1.0.0
spec:
  replicas: 2
  selector:
    matchLabels:
      app: afterwork-api
  template:
    metadata:
      labels:
        app: afterwork-api
    spec:
      containers:
      - name: afterwork-api
        image: registry.lions.dev/afterwork-api:1.0.0
        imagePullPolicy: Always
        ports:
        - containerPort: 8080
          name: http
          protocol: TCP
        envFrom:
        - configMapRef:
            name: afterwork-config
        - secretRef:
            name: afterwork-secrets
        resources:
          requests:
            memory: "512Mi"
            cpu: "250m"
          limits:
            memory: "1Gi"
            cpu: "1000m"
        livenessProbe:
          httpGet:
            path: /afterwork/q/health/live
            port: 8080
          initialDelaySeconds: 60
          periodSeconds: 30
          timeoutSeconds: 10
          failureThreshold: 3
        readinessProbe:
          httpGet:
            path: /afterwork/q/health/ready
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
          timeoutSeconds: 5
          failureThreshold: 3
      imagePullSecrets:
      - name: registry-credentials

4. Service (kubernetes/afterwork-service.yaml)

apiVersion: v1
kind: Service
metadata:
  name: afterwork-api
  namespace: applications
  labels:
    app: afterwork-api
spec:
  type: ClusterIP
  ports:
  - port: 8080
    targetPort: 8080
    protocol: TCP
    name: http
  selector:
    app: afterwork-api

5. Ingress (kubernetes/afterwork-ingress.yaml)

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: afterwork-api
  namespace: applications
  annotations:
    cert-manager.io/cluster-issuer: "letsencrypt-prod"
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
    nginx.ingress.kubernetes.io/force-ssl-redirect: "true"
    nginx.ingress.kubernetes.io/proxy-body-size: "10m"
    nginx.ingress.kubernetes.io/rewrite-target: /$2
spec:
  ingressClassName: nginx
  tls:
  - hosts:
    - api.lions.dev
    secretName: afterwork-api-tls
  rules:
  - host: api.lions.dev
    http:
      paths:
      - path: /afterwork(/|$)(.*)
        pathType: Prefix
        backend:
          service:
            name: afterwork-api
            port:
              number: 8080

---

🔄 Processus de Déploiement Complet

Étape 1 : Préparation

cd C:\Users\dadyo\PersonalProjects\mic-after-work-server-impl-quarkus-main

# Build Maven
mvn clean package -DskipTests

# Vérifier que le JAR est créé
ls target/*-runner.jar

Étape 2 : Build Docker

# Build l'image de production
docker build -f Dockerfile.prod -t registry.lions.dev/afterwork-api:1.0.0 .

# Test local (optionnel)
docker run --rm -p 8080:8080 \
  -e DB_HOST=postgres \
  -e DB_NAME=afterwork_db \
  -e DB_USERNAME=afterwork \
  -e DB_PASSWORD=test123 \
  registry.lions.dev/afterwork-api:1.0.0

Étape 3 : Push vers Registry

# Login au registry
docker login registry.lions.dev

# Push
docker push registry.lions.dev/afterwork-api:1.0.0
docker tag registry.lions.dev/afterwork-api:1.0.0 registry.lions.dev/afterwork-api:latest
docker push registry.lions.dev/afterwork-api:latest

Étape 4 : Déploiement Kubernetes

# Créer le namespace si nécessaire
kubectl create namespace applications --dry-run=client -o yaml | kubectl apply -f -

# Créer les secrets (MODIFIER LES VALEURS!)
kubectl apply -f kubernetes/afterwork-secrets.yaml

# Créer la ConfigMap
kubectl apply -f kubernetes/afterwork-configmap.yaml

# Déployer l'application
kubectl apply -f kubernetes/afterwork-deployment.yaml
kubectl apply -f kubernetes/afterwork-service.yaml
kubectl apply -f kubernetes/afterwork-ingress.yaml

# Ou via lionesctl pipeline
lionesctl pipeline deploy -f kubernetes/

Étape 5 : Vérification

# Pods
kubectl get pods -n applications -l app=afterwork-api

# Logs
kubectl logs -n applications -l app=afterwork-api --tail=100 -f

# Service
kubectl get svc -n applications afterwork-api

# Ingress
kubectl get ingress -n applications afterwork-api

# Test health
curl https://api.lions.dev/afterwork/q/health/ready
curl https://api.lions.dev/afterwork/q/health/live

# Test API
curl https://api.lions.dev/afterwork/api/users/test

---

🔧 Maintenance

Mise à Jour de l'Application

# 1. Build nouvelle version
mvn clean package -DskipTests
docker build -f Dockerfile.prod -t registry.lions.dev/afterwork-api:1.0.1 .
docker push registry.lions.dev/afterwork-api:1.0.1

# 2. Mise à jour du déploiement
kubectl set image deployment/afterwork-api \
  afterwork-api=registry.lions.dev/afterwork-api:1.0.1 \
  -n applications

# 3. Rollout status
kubectl rollout status deployment/afterwork-api -n applications

Rollback

# Voir l'historique
kubectl rollout history deployment/afterwork-api -n applications

# Rollback à la version précédente
kubectl rollout undo deployment/afterwork-api -n applications

# Rollback à une révision spécifique
kubectl rollout undo deployment/afterwork-api --to-revision=2 -n applications

Scaling

# Scale up
kubectl scale deployment afterwork-api --replicas=3 -n applications

# Scale down
kubectl scale deployment afterwork-api --replicas=1 -n applications

# Autoscaling (HPA)
kubectl autoscale deployment afterwork-api \
  --min=2 --max=10 \
  --cpu-percent=80 \
  -n applications

---

🐛 Troubleshooting

Problème : Pods ne démarrent pas

# Vérifier les événements
kubectl describe pod <pod-name> -n applications

# Vérifier les logs
kubectl logs <pod-name> -n applications

# Vérifier les secrets
kubectl get secret afterwork-secrets -n applications -o yaml

Problème : Base de données inaccessible

# Tester la connexion depuis un pod
kubectl run -it --rm debug --image=postgres:15 --restart=Never -- \
  psql -h postgres -U afterwork -d afterwork_db

# Vérifier le service PostgreSQL
kubectl get svc -n postgresql

Problème : Ingress ne fonctionne pas

# Vérifier l'Ingress
kubectl describe ingress afterwork-api -n applications

# Vérifier les certificats TLS
kubectl get certificate -n applications

# Logs du contrôleur Ingress
kubectl logs -n ingress-nginx -l app.kubernetes.io/name=ingress-nginx

---

📊 Monitoring

Métriques Prometheus

# Accéder aux métriques
curl https://api.lions.dev/afterwork/q/metrics

# Ou via port-forward
kubectl port-forward -n applications svc/afterwork-api 8080:8080
curl http://localhost:8080/q/metrics

Logs Centralisés

# Tous les logs de l'application
kubectl logs -n applications -l app=afterwork-api --tail=1000

# Logs en temps réel
kubectl logs -n applications -l app=afterwork-api -f

# Logs d'un pod spécifique
kubectl logs -n applications <pod-name> --previous

---

🔐 Sécurité

Secrets

• ⚠️ NE JAMAIS commiter les secrets dans Git
• Utiliser Sealed Secrets ou Vault pour la gestion des secrets
• Rotation régulière des mots de passe de base de données

Network Policies

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: afterwork-api-netpol
  namespace: applications
spec:
  podSelector:
    matchLabels:
      app: afterwork-api
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          name: ingress-nginx
    ports:
    - protocol: TCP
      port: 8080
  egress:
  - to:
    - namespaceSelector:
        matchLabels:
          name: postgresql
    ports:
    - protocol: TCP
      port: 5432
  - to:
    - namespaceSelector: {}
    ports:
    - protocol: TCP
      port: 443  # Pour les APIs externes

---

📝 Checklist de Déploiement

Avant le Déploiement

• Tests unitaires passent
• Build Maven réussit
• Image Docker créée
• Variables d'environnement configurées
• Secrets créés dans Kubernetes
• Base de données PostgreSQL prête

Pendant le Déploiement

• Image pushée vers le registry
• Manifests Kubernetes appliqués
• Pods démarrent correctement
• Health checks réussissent
• Ingress configuré avec TLS

Après le Déploiement

• API accessible via HTTPS
• WebSocket fonctionne
• Tests d'intégration passent
• Métriques remontées dans Prometheus
• Logs centralisés fonctionnent
• Documentation mise à jour

---

📞 Support

En cas de problème :

1. Consulter les logs : kubectl logs -n applications -l app=afterwork-api
2. Vérifier les events : kubectl get events -n applications
3. Tester les health checks : curl https://api.lions.dev/afterwork/q/health
4. Contacter l'équipe DevOps

---

Dernière mise à jour : 2026-01-09 Version : 1.0.0