​
Aperçu

Ce guide vous accompagne dans le déploiement de CaseBender sur DigitalOcean en utilisant des images Docker préconstruites avec Kubernetes (DOKS) et des services managés.

​
Prérequis

  1. Compte DigitalOcean
  2. doctl CLI installé
  3. kubectl installé
  4. Docker installé

​
Étape 1 : Configuration Initiale

​
Installer et Configurer doctl

# Utilisation de Homebrew
brew install doctl

# Authentification avec un token API

doctl auth init

# Configurer Docker pour le Registre de Conteneurs

doctl registry login

​
Étape 2 : Créer un Cluster Kubernetes

# Créer un cluster DOKS
doctl kubernetes cluster create casebender \
  --region nyc1 \
  --size s-2vcpu-4gb \
  --count 3 \
  --version latest

# Obtenir le kubeconfig
doctl kubernetes cluster kubeconfig save casebender

​
Étape 3 : Configurer les Services Managés

​
Créer des Spaces pour le Stockage d’Objets

# Créer un bucket Spaces
doctl spaces create casebender-storage \
  --region nyc3

# Créer une clé d'accès Spaces
doctl spaces access-key create

# Note : Sauvegardez la clé d'accès et la clé secrète en lieu sûr
# Elles seront nécessaires pour la configuration de l'application

​
Créer une Base de Données PostgreSQL Managée

# Créer un cluster de base de données
doctl databases create \
  --engine pg \
  --name casebender-db \
  --region nyc1 \
  --size db-s-2vcpu-4gb \
  --version 14 \
  --num-nodes 1

# Créer une base de données
doctl databases db create casebender-db casebender

# Obtenir les détails de connexion
doctl databases connection casebender-db --format ConnectionString

​
Créer un Redis Managé

# Créer un cluster Redis
doctl databases create \
  --engine redis \
  --name casebender-redis \
  --region nyc1 \
  --size db-s-1vcpu-2gb \
  --version 7

# Obtenir les détails de connexion
doctl databases connection casebender-redis --format ConnectionString

​
Étape 4 : Configurer le Registre de Conteneurs

# Créer un registre de conteneurs
doctl registry create casebender-registry

# Obtenir le point de terminaison du registre
REGISTRY_ENDPOINT=$(doctl registry get-endpoint)

# Récupérer les images CaseBender
docker pull casebender/casebender:latest
docker pull casebender/workflow-processor:latest
docker pull casebender/misp-processor:latest

# Taguer les images pour le registre
docker tag casebender/casebender:latest registry.digitalocean.com/casebender-registry/app:latest
docker tag casebender/workflow-processor:latest registry.digitalocean.com/casebender-registry/workflow-processor:latest
docker tag casebender/misp-processor:latest registry.digitalocean.com/casebender-registry/misp-processor:latest

# Pousser les images
docker push registry.digitalocean.com/casebender-registry/app:latest
docker push registry.digitalocean.com/casebender-registry/workflow-processor:latest
docker push registry.digitalocean.com/casebender-registry/misp-processor:latest

# Ajouter le registre au cluster Kubernetes
doctl kubernetes cluster registry add casebender

​
Étape 5 : Déployer sur Kubernetes

​
Créer un Namespace

kubectl create namespace casebender

​
Créer des Secrets

# Créer des secrets pour la base de données et Redis
kubectl create secret generic db-credentials \
  --namespace casebender \
  --from-literal=postgres-url="postgresql://doadmin:password@casebender-db-do-user-1234567-0.b.db.ondigitalocean.com:25060/casebender?sslmode=require" \
  --from-literal=redis-url="rediss://default:password@casebender-redis-do-user-1234567-0.b.db.ondigitalocean.com:25061"

# Créer des secrets pour l'application
kubectl create secret generic app-secrets \
  --namespace casebender \
  --from-literal=auth-secret="votre-secret-auth" \
  --from-literal=auth-salt="votre-sel-auth"

​
Déployer les Applications

Créez un fichier deployment.yaml :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: casebender-app
  namespace: casebender
spec:
  replicas: 2
  selector:
    matchLabels:
      app: casebender-app
  template:
    metadata:
      labels:
        app: casebender-app
    spec:
      containers:
        - name: app
          image: registry.digitalocean.com/casebender-registry/app:latest
          ports:
            - containerPort: 3000
          env:
            - name: AUTH_SECRET
              valueFrom:
                secretKeyRef:
                  name: app-secrets
                  key: auth-secret
            - name: AUTH_SALT
              valueFrom:
                secretKeyRef:
                  name: app-secrets
                  key: auth-salt
            - name: POSTGRES_PRISMA_URL
              valueFrom:
                secretKeyRef:
                  name: db-credentials
                  key: postgres-url
            - name: REDIS_URL
              valueFrom:
                secretKeyRef:
                  name: db-credentials
                  key: redis-url
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: workflow-processor
  namespace: casebender
spec:
  replicas: 1
  selector:
    matchLabels:
      app: workflow-processor
  template:
    metadata:
      labels:
        app: workflow-processor
    spec:
      containers:
        - name: processor
          image: registry.digitalocean.com/casebender-registry/workflow-processor:latest
          env:
            - name: POSTGRES_PRISMA_URL
              valueFrom:
                secretKeyRef:
                  name: db-credentials
                  key: postgres-url
            - name: REDIS_URL
              valueFrom:
                secretKeyRef:
                  name: db-credentials
                  key: redis-url
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: misp-processor
  namespace: casebender
spec:
  replicas: 1
  selector:
    matchLabels:
      app: misp-processor
  template:
    metadata:
      labels:
        app: misp-processor
    spec:
      containers:
        - name: processor
          image: registry.digitalocean.com/casebender-registry/misp-processor:latest
          env:
            - name: POSTGRES_PRISMA_URL
              valueFrom:
                secretKeyRef:
                  name: db-credentials
                  key: postgres-url
            - name: REDIS_URL
              valueFrom:
                secretKeyRef:
                  name: db-credentials
                  key: redis-url

Appliquez les déploiements :

kubectl apply -f deployment.yaml

​
Créer des Services

Créez un fichier service.yaml :

apiVersion: v1
kind: Service
metadata:
  name: casebender-app
  namespace: casebender
spec:
  type: ClusterIP
  ports:
    - port: 80
      targetPort: 3000
  selector:
    app: casebender-app

Appliquez le service :

kubectl apply -f service.yaml

​
Étape 7 : Configurer l’Ingress

​
Installer le Contrôleur d’Ingress NGINX

# Ajouter le dépôt Helm
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update

# Installer le Contrôleur d'Ingress NGINX
helm install nginx-ingress ingress-nginx/ingress-nginx \
  --namespace casebender \
  --set controller.publishService.enabled=true

​
Configurer l’Ingress

Créez un fichier ingress.yaml :

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: casebender-ingress
  namespace: casebender
  annotations:
    kubernetes.io/ingress.class: nginx
    cert-manager.io/cluster-issuer: letsencrypt-prod
spec:
  tls:
    - hosts:
        - votre-domaine.com
      secretName: casebender-tls
  rules:
    - host: votre-domaine.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: casebender-app
                port:
                  number: 80

Appliquez l’ingress :

kubectl apply -f ingress.yaml

​
Étape 8 : Configurer SSL avec cert-manager

# Installer cert-manager
kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.8.0/cert-manager.yaml

# Créer un ClusterIssuer
cat <<EOF | kubectl apply -f -
apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: letsencrypt-prod
spec:
  acme:
    server: https://acme-v02.api.letsencrypt.org/directory
    email: votre-email@domaine.com
    privateKeySecretRef:
      name: letsencrypt-prod
    solvers:
    - http01:
        ingress:
          class: nginx
EOF

​
Surveillance et Maintenance

​
Configurer la Surveillance

# Installer le serveur de métriques
kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

# Déployer Prometheus et Grafana
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update

helm install prometheus prometheus-community/kube-prometheus-stack \
  --namespace monitoring \
  --create-namespace

​
Configurer l’Auto-Scaling Horizontal des Pods

Créez un fichier hpa.yaml :

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: casebender-app-hpa
  namespace: casebender
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: casebender-app
  minReplicas: 2
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 80

Appliquez le HPA :

kubectl apply -f hpa.yaml

​
Sauvegarde et Reprise après Sinistre

​
Sauvegardes de Base de Données

Les bases de données managées de DigitalOcean gèrent automatiquement les sauvegardes. Vous pouvez également :

# Créer une sauvegarde manuelle
doctl databases backup casebender-db

​
Configurer le Basculement de Base de Données

# Activer le basculement automatique
doctl databases replica casebender-db create \
  --region sfo2

​
Meilleures Pratiques de Sécurité

  1. Activer le Pare-feu Cloud DigitalOcean
  2. Utiliser le réseau privé
  3. Implémenter des politiques réseau
  4. Mises à jour de sécurité régulières
  5. Activer la journalisation d’audit

​
Optimisation des Coûts

  1. Utiliser des tailles de nœuds appropriées
  2. Implémenter l’auto-scaling
  3. Utiliser le stockage par blocs judicieusement
  4. Surveiller l’utilisation des ressources
  5. Envisager des droplets réservés

​
Prochaines Étapes

  • Configurer un pipeline CI/CD
  • Configurer des alertes de surveillance
  • Implémenter une solution de journalisation
  • Revoir les mesures de sécurité