lionsdev/mic-after-work-server-impl-quarkus-main
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
bcbae7c599895232a68cff65af30ffe180d60e57
mic-after-work-server-impl-…/DEPLOYMENT.md
dahoud 9dc9ca591c Refactoring
2026-01-31 16:54:46 +00:00

14 KiB
Raw Blame History

🚀 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 lionsctl pipeline.

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

🔧 Prérequis

Environnement Local

  • Java 17 (JDK)
  • Maven 3.9+
  • Docker 20.10+
  • lionsctl 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. docker/Dockerfile.prod

Le fichier docker/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 (Dockerfiles dans docker/)
docker build -f docker/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 lionsctl pipeline

La commande lionsctl pipeline clone le repo Git, compile (Maven), construit l'image Docker, déploie sur Kubernetes et envoie une notification email. Il n'y a pas de sous-commande deploy : tout est inclus dans lionsctl pipeline.

Commande de déploiement

Remplacez <org> par votre organisation Git (ex. lionsdev, developer) et <email> par l'adresse de notification.

# Déploiement en dev (clone + build + image + déploiement K8s)
lionsctl pipeline \
  -u https://git.lions.dev/<org>/mic-after-work-server-impl-quarkus-main \
  -b develop \
  -j 17 \
  -e dev \
  -c k1 \
  -m <email>

# Déploiement en production sur le cluster k2
lionsctl pipeline \
  -u https://git.lions.dev/<org>/mic-after-work-server-impl-quarkus-main \
  -b main \
  -j 17 \
  -e production \
  -c k2 \
  -m <email> \
  -p prod

# Avec déploiement Helm (charts générés automatiquement)
lionsctl pipeline \
  -u https://git.lions.dev/<org>/mic-after-work-server-impl-quarkus-main \
  -b develop \
  -j 17 \
  -e dev \
  -c k1 \
  -m <email> \
  --use-helm

Options principales :

Option Description Exemple
-u, --url URL du repo Git (obligatoire) https://git.lions.dev/.../mic-after-work-server-impl-quarkus-main
-b, --branch Branche à déployer develop, main
-j, --java-version Version Java (8–21) 17
-e, --environment Environnement (dev / staging / production) dev, production
-c, --cluster Cluster Kubernetes (k1 ou k2) (obligatoire) k1, k2
-m, --mail Email(s) pour les notifications admin@lions.dev
-p, --profile Profil Maven prod pour production
--use-helm Déployer via Helm —

Vérification du déploiement

# Pods et statut (nom d'app dérivé du repo, ex. mic-after-work-server-impl-quarkus-main)
kubectl get pods -n applications -l app=mic-after-work-server-impl-quarkus-main

# Logs en temps réel
kubectl logs -n applications -l app=mic-after-work-server-impl-quarkus-main -f

# 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 (Dockerfiles dans docker/)
docker build -f docker/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 lionsctl pipeline (clone + build + déploiement)
lionsctl pipeline -u https://git.lions.dev/<org>/mic-after-work-server-impl-quarkus-main -b develop -j 17 -e dev -c k1 -m <email>

É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 docker/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