Self-hosting

Dependency-Track sur VPS : SBOM et dépendances vulnérables

Une application moderne embarque des centaines de bibliothèques que personne n'a choisies une à une. Le jour où une faille critique touche l'une d'elles, la seule question qui compte est : où l'avons-nous déployée ? OWASP Dependency-Track y répond en continu. Votre CI lui envoie le SBOM de chaque build, il rapproche chaque composant des bases de vulnérabilités publiques et vous prévient dès qu'une version en production est touchée. Ce guide l'installe sur un VPS avec Docker Compose, remplace le mot de passe d'usine, le publie en HTTPS derrière nginx et le branche sur votre pipeline.

Déployer sur un VPS Cloud →
7 min de lecture5 étapes
Sommaire· Ce que fait Dependency-Track1/11
  1. 01Ce que fait Dependency-Track
  2. 02Ce que Dependency-Track vous donne
  3. 03Scanner ponctuel ou Dependency-Track sur votre VPS
  4. 04Préparer le serveur
  5. 05Installer Dependency-Track avec Docker Compose
  6. 06Ne publiez jamais une instance en admin/admin
  7. 07Publier Dependency-Track en HTTPS derrière nginx
  8. 08Envoyer les SBOM depuis la CI
  9. 09Politiques et notifications
  10. 10Sauvegarde et mise à jour
  11. 11Dependency-Track en un clic sur ServOrbit

Ce que fait Dependency-Track

Dependency-Track est un projet phare de l'OWASP, publié sous licence Apache-2.0. Il ne lit pas votre code : il lit l'inventaire de ce que votre application embarque, le SBOM (Software Bill of Materials), au format CycloneDX. Chaque composant y est identifié par son Package URL (pkg:npm/[email protected], pkg:maven/…), ce qui permet de le rapprocher sans ambiguïté des bases de vulnérabilités : NVD, GitHub Advisories, OSV.

La différence avec un scanner lancé dans la CI tient au temps. Le scanner juge le build du jour ; Dependency-Track garde toutes les versions de tous vos projets et les réévalue chaque fois que ses bases se mettent à jour. Une faille publiée dans trois mois sera signalée sur la version que vous déployez aujourd'hui.

Ce que Dependency-Track vous donne

  • Un portefeuille — chaque application et chaque version, avec la liste de ses composants directs et transitifs.
  • Des alertes rétroactives — une vulnérabilité publiée après le déploiement remonte sur les versions déjà en production.
  • Des politiques — licences interdites, sévérité maximale tolérée, composants bannis, évaluées à chaque envoi de SBOM.
  • Le tri des vulnérabilités — sévérité, score EPSS de probabilité d'exploitation, et un suivi des analyses (« non concerné », « corrigé »…).
  • Des notifications — Slack, Microsoft Teams, webhook ou e-mail, par projet et par gravité.
  • Une API complète — envoi des SBOM, lecture des résultats et administration, avec des clés d'API par équipe.

Scanner ponctuel ou Dependency-Track sur votre VPS

Faites défiler le tableau

Scanner lancé dans la CIAvec Dependency-Track sur votre VPS
Moment de l'analyseAu build, puis plus rienÀ chaque build, puis en continu
Faille publiée après le déploiementInvisible jusqu'au prochain buildSignalée sur les versions en production
Vue d'ensembleUn rapport par dépôtTout le portefeuille, recherche par composant
LicencesSelon l'outilPolitiques de licence explicites
Où vit l'inventaireDans les journaux de CISur votre VPS, avec son historique

Préparer le serveur

Prévoyez un VPS Ubuntu 24.04 avec 4 Go de RAM et 2 vCPU au minimum : le serveur d'API, écrit en Java, est borné à 2 Go, et PostgreSQL se partage le reste avec le système. Au-delà de quelques dizaines de projets analysés chaque jour, passez à 8 Go. Comptez 30 Go de disque.

Installez Docker et le plugin Compose, puis pointez un sous-domaine (par exemple dtrack.example.com) vers l'adresse IP du VPS : vos pipelines enverront leurs SBOM à cette adresse, et l'interface web s'y ouvrira.

curl -fsSL https://get.docker.com | sh
docker compose version

Installer Dependency-Track avec Docker Compose

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

    Le fichier porte le mot de passe de la base PostgreSQL et celui du compte admin.

    mkdir -p /opt/dependency-track && cd /opt/dependency-track
    cat > .env <<EOF
    DB_PASSWORD=$(openssl rand -hex 16)
    ADMIN_PASSWORD=$(openssl rand -hex 16)
    EOF
    chmod 600 .env
  2. Écrire la configuration du proxy interne

    L'interface web appelle l'API sur sa propre adresse. Un petit nginx aiguille donc /api vers le serveur d'API et tout le reste vers l'interface : un seul port à publier, un seul domaine, aucun réglage CORS.

    server {
      listen 80;
      client_max_body_size 64m;
      location /api/ {
        proxy_pass http://apiserver:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_read_timeout 300s;
      }
      location / {
        proxy_pass http://frontend:8080;
        proxy_set_header Host $host;
      }
    }

    Enregistrez ce bloc dans /opt/dependency-track/proxy.conf.

  3. Écrire le fichier docker-compose.yml

    Quatre services : PostgreSQL, le serveur d'API, l'interface et le proxy. Le port n'est publié que sur la boucle locale : seul le nginx du VPS sera exposé à Internet.

    services:
      db:
        image: postgres:18.7-alpine
        restart: unless-stopped
        environment:
          POSTGRES_DB: dtrack
          POSTGRES_USER: dtrack
          POSTGRES_PASSWORD: ${DB_PASSWORD}
        volumes:
          - db:/var/lib/postgresql
        healthcheck:
          test: ["CMD-SHELL", "pg_isready -q -U dtrack -d dtrack"]
          interval: 10s
          retries: 30
    
      apiserver:
        image: ghcr.io/dependencytrack/apiserver:5.2.2
        restart: unless-stopped
        depends_on:
          db:
            condition: service_healthy
        deploy:
          resources:
            limits:
              memory: 2g
        environment:
          DT_DATASOURCE_URL: jdbc:postgresql://db:5432/dtrack
          DT_DATASOURCE_USERNAME: dtrack
          DT_DATASOURCE_PASSWORD: ${DB_PASSWORD}
        volumes:
          - data:/data
    
      frontend:
        image: ghcr.io/dependencytrack/frontend:5.2.2
        restart: unless-stopped
        environment:
          API_BASE_URL: ""
    
      proxy:
        image: nginx:1.27-alpine
        restart: unless-stopped
        depends_on: [apiserver, frontend]
        ports:
          - "127.0.0.1:8127:80"
        volumes:
          - ./proxy.conf:/etc/nginx/conf.d/default.conf:ro
    
    volumes:
      db: {}
      data: {}
  4. Démarrer la pile

    Le premier démarrage crée le schéma de la base, puis le serveur d'API télécharge les bases de vulnérabilités en arrière-plan.

    docker compose up -d
    curl -s http://127.0.0.1:8127/api/version

    La seconde commande répond par la version du serveur dès que l'API est prête.

  5. Remplacer le mot de passe d'usine

    Le compte admin naît avec le mot de passe admin. Remplacez-le avant toute publication :

    . ./.env
    curl -fsS http://127.0.0.1:8127/api/v1/user/forceChangePassword \
      --data-urlencode username=admin --data-urlencode password=admin \
      --data-urlencode newPassword="$ADMIN_PASSWORD" \
      --data-urlencode confirmPassword="$ADMIN_PASSWORD"

Ne publiez jamais une instance en admin/admin

Dependency-Track impose bien le changement du mot de passe à la première connexion, mais entre le démarrage et cette connexion, n'importe qui peut s'en charger à votre place et prendre la main sur l'inventaire de vos applications — c'est-à-dire la liste de leurs failles. Remplacez le mot de passe avant de configurer nginx.

Publier Dependency-Track en HTTPS derrière nginx

Le nginx du VPS reçoit le domaine et relaie vers le port local. Relevez la taille des envois : le SBOM d'une application conséquente dépasse vite le mégaoctet que nginx accepte par défaut.

server {
  server_name dtrack.example.com;
  client_max_body_size 64m;
  location / {
    proxy_pass http://127.0.0.1:8127;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
  }
}

Puis émettez le certificat avec certbot --nginx -d dtrack.example.com. Ouvrez https://dtrack.example.com, connectez-vous avec admin et votre nouveau mot de passe, et créez les comptes de l'équipe dans Administration → Access Management.

Envoyer les SBOM depuis la CI

Dans Administration → Access Management → Teams, ouvrez l'équipe Automation et générez une clé d'API ; rangez-la dans les secrets de la CI. Le pipeline produit ensuite le SBOM et l'envoie à chaque build — ici avec cdxgen, qui reconnaît la plupart des écosystèmes (npm, Maven, PyPI, Composer, Go…) :

# .github/workflows/sbom.yml
name: sbom
on: [push]
jobs:
  sbom:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npx --yes @cyclonedx/cdxgen -o bom.json
      - run: |
          curl -fsS -X POST https://dtrack.example.com/api/v1/bom \
            -H "X-Api-Key: ${{ secrets.DT_API_KEY }}" \
            -F autoCreate=true -F projectName=${{ github.event.repository.name }} \
            -F projectVersion=${{ github.ref_name }} -F [email protected]

Le projet apparaît dans le portefeuille avec la version envoyée. Pour une image de conteneur, syft <image> -o cyclonedx-json > bom.json produit l'équivalent, paquets système compris.

Politiques et notifications

Une politique transforme un constat en règle. Dans Policy Management, créez par exemple une politique de sécurité qui signale toute vulnérabilité de sévérité *High* ou plus, et une politique de licence qui refuse les licences que votre contrat interdit. Chaque envoi de SBOM est évalué, et les violations s'affichent sur le projet.

Dans Administration → Notifications, branchez ensuite un canal — Slack, Microsoft Teams, webhook ou e-mail — sur les événements *New Vulnerability* et *Policy Violation*, limités aux projets qui comptent. C'est cette alerte qui fait la valeur de l'outil : elle arrive le jour où la faille est publiée, pas le jour du prochain build.

Sauvegarde et mise à jour

Tout l'état utile vit dans PostgreSQL : projets, SBOM, analyses et réglages. Sauvegardez la base, le dossier /data se reconstitue (il porte surtout les bases de vulnérabilités téléchargées).

cd /opt/dependency-track
docker compose exec -T db pg_dump -U dtrack dtrack | gzip > dtrack-$(date +%F).sql.gz

Pour mettre à jour, lisez les notes de version, changez les deux étiquettes d'image (apiserver et frontend, toujours à la même version), puis docker compose pull && docker compose up -d. Le serveur d'API migre le schéma au démarrage. Gardez une sauvegarde récente avant chaque montée de version.

Dependency-Track en un clic sur ServOrbit

Sur un VPS ServOrbit, Dependency-Track s'installe depuis le Marketplace : images officielles, PostgreSQL et proxy interne en place, mot de passe d'usine du compte admin remplacé par un mot de passe généré et affiché dans votre espace client, reverse proxy nginx en HTTPS sur votre domaine ou sur le sous-domaine gratuit du VPS. Il ne vous reste qu'à créer la clé d'API de la CI et à envoyer votre premier SBOM.

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

Vos dépendances sous surveillance, sur votre VPS

Prix HT affichés avec leur renouvellement.