Autoalojamiento

DefectDojo en un VPS: centralice sus vulnerabilidades

Trivy en la CI, Semgrep en las pull requests, un escaneo ZAP cada semana, una prueba de intrusión al año: cada herramienta produce su informe, en su formato, y ya nadie sabe qué fallo está corregido. OWASP DefectDojo reúne todos esos resultados en una sola lista, elimina los duplicados, cierra lo que ha desaparecido y asigna a cada hallazgo un plazo de corrección. Esta guía lo instala en un VPS con Docker Compose, lo publica en HTTPS detrás de nginx y lo conecta a su pipeline.

Desplegar en un VPS Cloud →
7 min de lectura3 pasos
Contenido· Qué hace DefectDojo1/11
  1. 01Qué hace DefectDojo
  2. 02Lo que DefectDojo le aporta
  3. 03Informes de escáneres dispersos o DefectDojo en su VPS
  4. 04Preparar el servidor
  5. 05Instalar DefectDojo con Docker Compose
  6. 06Fije usted mismo la contraseña de admin
  7. 07Publicar DefectDojo en HTTPS detrás de nginx
  8. 08Importar los informes desde la CI
  9. 09Clasificar, fijar plazos, aceptar un riesgo
  10. 10Copia de seguridad y actualización
  11. 11DefectDojo en un clic en ServOrbit

Qué hace DefectDojo

DefectDojo es un proyecto insignia de OWASP, publicado bajo licencia BSD-3-Clause y escrito en Python con Django. No es un escáner: no busca fallos por sí mismo. Recibe los informes de sus escáneres — más de 200 formatos reconocidos — y los convierte en hallazgos ordenados en una jerarquía sencilla: tipo de producto, producto, campaña (*engagement*), prueba.

Su valor está en lo que hace con esos hallazgos: reconoce un mismo fallo visto dos veces, cierra los que desaparecieron en el escaneo siguiente, les asigna una severidad, un responsable y un plazo, y conserva el rastro de cada decisión — incluida la aceptación de un riesgo.

Lo que DefectDojo le aporta

  • Una sola lista — los resultados de Trivy, Semgrep, Gitleaks, ZAP, Burp o Nessus en el mismo lugar y con el mismo formato.
  • La deduplicación — un fallo encontrado por dos herramientas, o en cada build, aparece una sola vez.
  • La reimportación — un informe nuevo cierra los hallazgos corregidos y añade los nuevos, sin perder el historial.
  • Plazos (SLA) — un plazo de corrección por severidad, con los hallazgos atrasados resaltados.
  • Decisiones registradas — falso positivo, fuera de alcance o riesgo aceptado hasta una fecha, con su justificación.
  • Una API completa y Jira — importación desde la CI, tickets creados y sincronizados, informes para clientes y auditores.

Informes de escáneres dispersos o DefectDojo en su VPS

Desplace la tabla

Informes que se quedan en la CICon DefectDojo en su VPS
Dónde leer los resultadosUn registro por herramienta y por buildUna lista única por producto
DuplicadosCada build repite los mismos fallosDeduplicados automáticamente
Fallo corregidoSe comprueba a manoCerrado en la siguiente reimportación
Plazo de correcciónSin seguimientoSLA por severidad, retrasos visibles
Prueba para una auditoríaHay que reconstruirlaHistorial fechado de cada hallazgo

Preparar el servidor

Prevea un VPS Ubuntu 24.04 con al menos 2 GB de RAM y 2 vCPU: el conjunto de contenedores consume unos 700 MB en reposo. Pase a 4 GB si importa informes en cada build para varios productos, ya que el worker Celery procesa las importaciones y la deduplicación. Cuente 20 GB de disco.

También necesita Docker con el plugin Compose, y un nombre de dominio (o subdominio) que apunte al VPS: sus pipelines enviarán sus informes a esa dirección por HTTPS.

Instalar DefectDojo con Docker Compose

  1. Preparar la carpeta y el archivo .env

    El archivo contiene el dominio, la contraseña de la base de datos, la de la cuenta admin y las dos claves de la aplicación.

    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. Escribir el archivo docker-compose.yml

    Siete servicios: PostgreSQL, Valkey (cola de tareas y caché), el inicializador, la aplicación (uWSGI), el worker y el planificador Celery, y el nginx oficial de DefectDojo. Las imágenes vienen de Docker Hub. El puerto solo se publica en la interfaz local: únicamente el nginx del VPS quedará expuesto a 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. Arrancar la pila

    El inicializador aplica las migraciones, carga los datos de referencia y crea la cuenta admin con ADMIN_PASSWORD, y luego se detiene. Los demás servicios esperan a que termine: cuente unos minutos en el primer arranque.

    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

    El último comando responde 200 cuando la interfaz está lista.

Fije usted mismo la contraseña de admin

Sin DD_ADMIN_PASSWORD, DefectDojo genera una contraseña al azar y la escribe solo en el registro del inicializador, que cualquier usuario del grupo docker puede leer. Póngala en el .env y cámbiela en el primer inicio de sesión si otras personas tienen acceso al servidor. Recuerde también DD_CSRF_TRUSTED_ORIGINS: detrás de un proxy HTTPS, Django rechaza sin ella el formulario de inicio de sesión (error CSRF 403).

Publicar DefectDojo en HTTPS detrás de nginx

El nginx del VPS recibe el dominio y reenvía al puerto local. Aumente client_max_body_size: un informe de Nessus o ZAP supera enseguida el límite por defecto de 1 MB, y la importación fallaría con un error 413.

server {
  listen 443 ssl;
  server_name defectdojo.example.com;
  # certificados 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;
  }
}

Obtenga el certificado con certbot --nginx -d defectdojo.example.com, luego abra https://defectdojo.example.com e inicie sesión como admin.

Importar los informes desde la CI

En el menú de su perfil, abra API v2 Key y copie el token; cree preferentemente una cuenta de servicio dedicada, ya que el token actúa con los derechos de su propietario. Guárdelo en los secretos de la CI.

Use después el punto de entrada reimport-scan en lugar de import-scan: actualiza la misma prueba en cada build en vez de crear una nueva, y close_old_findings cierra lo que ha desaparecido. Ejemplo para GitHub Actions:

- name: Enviar el informe de Trivy a 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="mi-app" \
      -F engagement_name="ci-main" -F auto_create_context=true \
      -F close_old_findings=true -F minimum_severity=Low

La misma llamada funciona desde GitLab CI o Jenkins; solo cambia scan_type de una herramienta a otra (Semgrep JSON Report, Gitleaks Scan, ZAP Scan…).

Clasificar, fijar plazos, aceptar un riesgo

En Configuration → SLA Configuration, fije un plazo por severidad, por ejemplo 7 días para un fallo crítico y 30 para uno alto: los hallazgos atrasados destacan en el panel. Cada hallazgo puede marcarse como falso positivo, fuera de alcance o cubierto por una aceptación de riesgo fechada, con su justificación. Conecte Jira en Configuration → JIRA para crear un ticket por hallazgo o por grupo de hallazgos y mantener los estados sincronizados.

Copia de seguridad y actualización

Todo el estado útil vive en PostgreSQL, más los adjuntos del volumen media. Haga una copia de la base cada noche:

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

Para actualizar, cambie el número de versión de las tres imágenes defectdojo en el archivo Compose y ejecute docker compose pull && docker compose up -d: el inicializador vuelve a aplicar las migraciones antes de que la aplicación arranque. Lea las notas de versión antes de saltar varias versiones de golpe.

DefectDojo en un clic en ServOrbit

En un VPS de ServOrbit, DefectDojo se instala desde el Marketplace: imágenes oficiales, PostgreSQL y Valkey, cuenta admin creada con una contraseña generada que se muestra en su área de cliente, y proxy inverso nginx en HTTPS en su dominio o en el subdominio gratuito del VPS. Combínelo con Dependency-Track para sus dependencias y con SonarQube para la calidad del código: DefectDojo puede importar sus resultados.

Compartir este artículoservorbit.com/ma-es/blog/autoalojar-defectdojo-vps-devsecops

Sus vulnerabilidades bajo seguimiento, en su VPS

Precios sin IVA, mostrados con su precio de renovación.