Self-hosting

DefectDojo sur VPS : centraliser vos vulnérabilités

Trivy dans la CI, Semgrep sur les pull requests, un scan ZAP chaque semaine, un test d'intrusion par an : chaque outil produit son rapport, dans son format, et personne ne sait plus quelle faille est déjà corrigée. OWASP DefectDojo réunit tous ces résultats en une seule liste, retire les doublons, ferme ce qui a disparu et fixe à chaque constat un délai de correction. Ce guide l'installe sur un VPS avec Docker Compose, le publie en HTTPS derrière nginx et le branche sur votre pipeline.

Déployer sur un VPS Cloud →
7 min de lecture3 étapes
Sommaire· Ce que fait DefectDojo1/11
  1. 01Ce que fait DefectDojo
  2. 02Ce que DefectDojo vous donne
  3. 03Rapports de scanners épars ou DefectDojo sur votre VPS
  4. 04Préparer le serveur
  5. 05Installer DefectDojo avec Docker Compose
  6. 06Fixez le mot de passe admin vous-même
  7. 07Publier DefectDojo en HTTPS derrière nginx
  8. 08Importer les rapports depuis la CI
  9. 09Trier, fixer des délais, accepter un risque
  10. 10Sauvegarde et mise à jour
  11. 11DefectDojo en un clic sur ServOrbit

Ce que fait DefectDojo

DefectDojo est un projet phare de l'OWASP, publié sous licence BSD-3-Clause et écrit en Python avec Django. Ce n'est pas un scanner : il ne cherche aucune faille lui-même. Il reçoit les rapports de vos scanners — plus de 200 formats reconnus — et les transforme en constats rangés dans une hiérarchie simple : type de produit, produit, campagne (*engagement*), test.

Sa valeur tient à ce qu'il fait de ces constats : il reconnaît une même faille vue deux fois, ferme celles qui ont disparu au scan suivant, leur attache une sévérité, un responsable et un délai, et garde la trace de chaque décision — y compris l'acceptation d'un risque.

Ce que DefectDojo vous donne

  • Une seule liste — les résultats de Trivy, Semgrep, Gitleaks, ZAP, Burp ou Nessus au même endroit, dans le même format.
  • Le dédoublonnage — une faille trouvée par deux outils, ou à chaque build, n'apparaît qu'une fois.
  • Le réimport — un nouveau rapport ferme les constats corrigés et ajoute les nouveaux, sans perdre l'historique.
  • Des délais (SLA) — un délai de correction par sévérité, et les constats en retard mis en évidence.
  • Des décisions tracées — faux positif, hors périmètre ou risque accepté jusqu'à une date, avec sa justification.
  • Une API complète et Jira — import depuis la CI, tickets créés et synchronisés, rapports pour les clients et les auditeurs.

Rapports de scanners épars ou DefectDojo sur votre VPS

Faites défiler le tableau

Rapports laissés dans la CIAvec DefectDojo sur votre VPS
Où lire les résultatsUn journal par outil et par buildUne liste unique par produit
DoublonsChaque build répète les mêmes faillesDédoublonnés automatiquement
Faille corrigéeÀ vérifier à la mainFermée au réimport suivant
Délai de correctionAucun suiviSLA par sévérité, retards visibles
Preuve pour un auditÀ reconstituerHistorique daté de chaque constat

Préparer le serveur

Prévoyez un VPS Ubuntu 24.04 avec 2 Go de RAM et 2 vCPU au minimum : l'ensemble des conteneurs consomme environ 700 Mo au repos. Passez à 4 Go si vous importez des rapports à chaque build sur plusieurs produits, car c'est le worker Celery qui traite les imports et le dédoublonnage. Comptez 20 Go de disque.

Il vous faut aussi Docker avec le plugin Compose, et un nom de domaine (ou un sous-domaine) pointé vers le VPS : vos pipelines enverront leurs rapports à cette adresse en HTTPS.

Installer DefectDojo avec Docker Compose

  1. Préparer le dossier et le fichier .env

    Le fichier porte le domaine, le mot de passe de la base, celui du compte admin et les deux clés de l'application.

    mkdir -p /opt/defectdojo && cd /opt/defectdojo
    cat > .env <<EOF
    DOMAIN=defectdojo.example.com
    DB_PASSWORD=$(openssl rand -hex 16)
    ADMIN_PASSWORD=$(openssl rand -hex 12)
    SECRET_KEY=$(openssl rand -hex 24)
    AES_KEY=$(openssl rand -hex 16)
    EOF
    chmod 600 .env
  2. Écrire le fichier docker-compose.yml

    Sept services : PostgreSQL, Valkey (file de tâches et cache), l'initialiseur, l'application (uWSGI), le worker et le planificateur Celery, et le nginx officiel de DefectDojo. Les images viennent de Docker Hub. Le port n'est publié que sur la boucle locale : seul le nginx du VPS sera exposé à Internet.

    x-dd-env: &dd-env
      DD_DATABASE_URL: postgresql://defectdojo:${DB_PASSWORD}@postgres:5432/defectdojo
      DD_CELERY_BROKER_URL: redis://valkey:6379/0
      DD_CACHE_URL: redis://valkey:6379/1
      DD_SECRET_KEY: ${SECRET_KEY}
      DD_CREDENTIAL_AES_256_KEY: ${AES_KEY}
      DD_ALLOWED_HOSTS: "*"
      DD_SITE_URL: https://${DOMAIN}
      DD_CSRF_TRUSTED_ORIGINS: https://${DOMAIN}
      DD_SECURE_PROXY_SSL_HEADER: "True"
    
    services:
      postgres:
        image: postgres:18.6-alpine
        restart: unless-stopped
        environment:
          POSTGRES_DB: defectdojo
          POSTGRES_USER: defectdojo
          POSTGRES_PASSWORD: ${DB_PASSWORD}
        volumes:
          - postgres:/var/lib/postgresql/data
        healthcheck:
          test: ["CMD-SHELL", "pg_isready -q -U defectdojo"]
          interval: 10s
          retries: 30
    
      valkey:
        image: valkey/valkey:9.1.2-alpine
        restart: unless-stopped
        volumes:
          - valkey:/data
    
      initializer:
        image: defectdojo/defectdojo-django:3.5.202
        restart: "no"
        depends_on:
          postgres:
            condition: service_healthy
        entrypoint: ["/wait-for-it.sh", "postgres:5432", "--", "/entrypoint-initializer.sh"]
        environment:
          <<: *dd-env
          DD_INITIALIZE: "true"
          DD_ADMIN_USER: admin
          DD_ADMIN_MAIL: [email protected]
          DD_ADMIN_PASSWORD: ${ADMIN_PASSWORD}
    
      uwsgi:
        image: defectdojo/defectdojo-django:3.5.202
        restart: unless-stopped
        depends_on:
          initializer:
            condition: service_completed_successfully
        entrypoint: ["/wait-for-it.sh", "postgres:5432", "--", "/entrypoint-uwsgi.sh"]
        environment: *dd-env
        volumes:
          - media:/app/media
    
      celerybeat:
        image: defectdojo/defectdojo-django:3.5.202
        restart: unless-stopped
        depends_on:
          initializer:
            condition: service_completed_successfully
        entrypoint: ["/wait-for-it.sh", "postgres:5432", "--", "/entrypoint-celery-beat.sh"]
        environment: *dd-env
    
      celeryworker:
        image: defectdojo/defectdojo-django:3.5.202
        restart: unless-stopped
        depends_on:
          initializer:
            condition: service_completed_successfully
        entrypoint: ["/wait-for-it.sh", "postgres:5432", "--", "/entrypoint-celery-worker.sh"]
        environment: *dd-env
        volumes:
          - media:/app/media
    
      nginx:
        image: defectdojo/defectdojo-nginx:3.5.202
        restart: unless-stopped
        depends_on: [uwsgi]
        ports:
          - "127.0.0.1:8080:8080"
        volumes:
          - media:/usr/share/nginx/html/media
    
    volumes:
      postgres: {}
      valkey: {}
      media: {}
  3. Démarrer la pile

    L'initialiseur applique les migrations, charge les données de référence et crée le compte admin avec ADMIN_PASSWORD, puis s'arrête. Les autres services attendent sa fin : comptez quelques minutes au premier démarrage.

    docker compose up -d
    docker compose logs -f initializer
    curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:8080/login

    La dernière commande répond 200 quand l'interface est prête.

Fixez le mot de passe admin vous-même

Sans DD_ADMIN_PASSWORD, DefectDojo tire un mot de passe au hasard et ne l'écrit que dans le journal de l'initialiseur, que n'importe quel utilisateur du groupe docker peut relire. Posez-le dans le .env et changez-le à la première connexion si d'autres personnes ont accès au serveur. Pensez aussi à DD_CSRF_TRUSTED_ORIGINS : derrière un proxy HTTPS, Django refuse sans lui le formulaire de connexion (erreur CSRF 403).

Publier DefectDojo en HTTPS derrière nginx

Le nginx du VPS reçoit le domaine et relaie vers le port local. Relevez client_max_body_size : un rapport Nessus ou ZAP dépasse vite la limite par défaut de 1 Mo, et l'import échouerait sur une erreur 413.

server {
  listen 443 ssl;
  server_name defectdojo.example.com;
  # certificats Let's Encrypt (certbot --nginx)
  client_max_body_size 100m;
  location / {
    proxy_pass http://127.0.0.1:8080;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto https;
    proxy_read_timeout 300s;
  }
}

Obtenez le certificat avec certbot --nginx -d defectdojo.example.com, puis ouvrez https://defectdojo.example.com et connectez-vous avec admin.

Importer les rapports depuis la CI

Dans le menu de votre profil, ouvrez API v2 Key et copiez le jeton ; créez de préférence un compte de service dédié, car le jeton agit avec les droits de son propriétaire. Rangez-le dans les secrets de la CI.

Utilisez ensuite le point d'entrée reimport-scan plutôt que import-scan : il met à jour le même test à chaque build au lieu d'en créer un nouveau, et close_old_findings ferme ce qui a disparu. Exemple pour GitHub Actions :

- name: Envoyer le rapport Trivy à DefectDojo
  run: |
    trivy image --format json -o trivy.json "$IMAGE"
    curl -fsS -X POST "https://$DD_HOST/api/v2/reimport-scan/" \
      -H "Authorization: Token $DD_API_KEY" \
      -F scan_type="Trivy Scan" -F [email protected] \
      -F product_type_name="Applications" -F product_name="mon-app" \
      -F engagement_name="ci-main" -F auto_create_context=true \
      -F close_old_findings=true -F minimum_severity=Low

Le même appel fonctionne depuis GitLab CI ou Jenkins ; seul scan_type change d'un outil à l'autre (Semgrep JSON Report, Gitleaks Scan, ZAP Scan…).

Trier, fixer des délais, accepter un risque

Dans Configuration → SLA Configuration, fixez un délai par sévérité, par exemple 7 jours pour une faille critique et 30 pour une élevée : les constats en retard ressortent sur le tableau de bord. Chaque constat peut ensuite être marqué faux positif, hors périmètre ou couvert par une acceptation de risque datée, avec sa justification. Branchez Jira dans Configuration → JIRA pour créer un ticket par constat ou par groupe de constats et garder les statuts synchronisés.

Sauvegarde et mise à jour

Tout l'état utile vit dans PostgreSQL, plus les pièces jointes du volume media. Sauvegardez la base chaque nuit :

cd /opt/defectdojo
docker compose exec -T postgres pg_dump -U defectdojo defectdojo | gzip > /root/defectdojo-$(date +%F).sql.gz

Pour mettre à jour, remplacez le numéro de version des trois images defectdojo dans le fichier Compose, puis docker compose pull && docker compose up -d : l'initialiseur rejoue les migrations avant que l'application ne redémarre. Lisez les notes de version avant de sauter plusieurs versions d'un coup.

DefectDojo en un clic sur ServOrbit

Sur un VPS ServOrbit, DefectDojo s'installe depuis le Marketplace : images officielles, PostgreSQL et Valkey, compte admin créé avec un mot de passe généré affiché dans votre espace client, et reverse proxy nginx en HTTPS sur votre domaine ou sur le sous-domaine gratuit du VPS. Associez-le à Dependency-Track pour vos dépendances et à SonarQube pour la qualité du code : DefectDojo sait importer leurs résultats.

Partager cet articleservorbit.com/ma-fr/blog/self-host-defectdojo-vps

Vos vulnérabilités suivies, sur votre VPS

Prix HT affichés avec leur renouvellement.