← volver

Escaneo automatizado de vulnerabilidades en imágenes Docker con Trivy en CI/CD

Por · · [Admin-Sistemas] · lectura estimada: ~6 min

Introducción

En entornos de producción basados en contenedores, la seguridad de las imágenes Docker es tan crítica como su funcionalidad. Cada capa añadida a una imagen puede introducir paquetes desactualizados o vulnerables. Trivy es una herramienta de escaneo de vulnerabilidades de código abierto, ligera y fácil de integrar, que permite detectar problemas de seguridad tanto en paquetes del sistema operativo como en dependencias de aplicaciones.

Este artículo muestra paso a paso cómo automatizar el escaneo de imágenes Docker con Trivy dentro de pipelines CI/CD (GitHub Actions, GitLab CI o Jenkins). Se incluyen comandos reales, ejemplos de configuración y la lógica detrás de cada decisión, de forma que el sysadmin pueda replicar el proceso en su infraestructura.

1. Preparación del entorno

1.1 Instalación de Trivy en el agente de CI

La mayoría de los runners de CI ejecutan contenedores o máquinas virtuales temporales. Instalar Trivy en cada ejecución garantiza que siempre se use la última base de datos de vulnerabilidades.

# En un runner basado en Ubuntu/Debian
sudo apt-get update && sudo apt-get install -y wget gnupg
wget -qO- https://aquasecurity.github.io/trivy-repo/deb/public.key | sudo apt-key add -
echo "deb https://aquasecurity.github.io/trivy-repo $(lsb_release -sc) main" | sudo tee /etc/apt/sources.list.d/trivy.list
sudo apt-get update && sudo apt-get install -y trivy

En un runner basado en Alpine (por ejemplo en GitHub Actions)

apk add —no-cache trivy

1.2 Configuración de la base de datos de vulnerabilidades

Trivy mantiene una base de datos local que se actualiza automáticamente en la primera ejecución. En pipelines con caché, podemos persistir esta base para acelerar los escaneos.

# Ejemplo en GitHub Actions usando caché
- name: Cache Trivy DB
  uses: actions/cache@v3
  with:
    path: ~/.cache/trivy
    key: trivy-db-${{ runner.os }}-${{ hashFiles('**/Dockerfile') }}
    restore-keys: |
      trivy-db-${{ runner.os }}-

Al restaurar el caché, Trivy no necesita descargar la base de datos completa en cada ejecución, reduciendo el tiempo de pipeline.

2. Integración de Trivy en el pipeline

2.1 Definición del flujo básico

El flujo típico es:

  • Compilar la aplicación y generar la imagen Docker.
  • Etiquetar la imagen con un tag de versión o commit.
  • Escanear la imagen con Trivy.
  • Fail the pipeline si se detectan vulnerabilidades críticas o altas.

2.2 Configuración de políticas de severidad

Trivy permite filtrar resultados por severidad (UNKNOWN, LOW, MEDIUM, HIGH, CRITICAL). Definir una política clara evita falsos positivos y mantiene el ritmo de desarrollo.

# Escaneo que falla si existen vulnerabilidades HIGH o CRITICAL
trivy image --severity HIGH,CRITICAL --exit-code 1 --no-progress myrepo/app:${{ github.sha }}

El flag --exit-code 1 hace que Trivy devuelva 1 cuando encuentra al menos una vulnerabilidad dentro del rango especificado, provocando que el paso del pipeline falle automáticamente.

2.3 Ejemplo completo en GitHub Actions

name: CI-CD Docker Build & Scan

on: push: branches: [ main ] pull_request:

jobs: build-and-scan: runs-on: ubuntu-latest

steps:
  - name: Checkout code
    uses: actions/checkout@v3

  - name: Set up Docker Buildx
    uses: docker/setup-buildx-action@v2

  - name: Cache Trivy DB
    uses: actions/cache@v3
    with:
      path: ~/.cache/trivy
      key: trivy-db-${{ runner.os }}-${{ hashFiles('**/Dockerfile') }}
      restore-keys: |
        trivy-db-${{ runner.os }}-

  - name: Install Trivy
    run: |
      sudo apt-get update && sudo apt-get install -y wget gnupg
      wget -qO- https://aquasecurity.github.io/trivy-repo/deb/public.key | sudo apt-key add -
      echo "deb https://aquasecurity.github.io/trivy-repo $(lsb_release -sc) main" | sudo tee /etc/apt/sources.list.d/trivy.list
      sudo apt-get update && sudo apt-get install -y trivy

  - name: Build Docker image
    run: |
      docker build -t myrepo/app:${{ github.sha }} .

  - name: Scan image with Trivy
    run: |
      trivy image --severity HIGH,CRITICAL --exit-code 1 --no-progress myrepo/app:${{ github.sha }}

  - name: Push image (only if scan passed)
    if: success()
    run: |
      echo "${{ secrets.DOCKER_PASSWORD }}" | docker login -u "${{ secrets.DOCKER_USER }}" --password-stdin
      docker push myrepo/app:${{ github.sha }}

3. Extensión a otras plataformas CI

3.1 GitLab CI

En GitLab CI, la lógica es idéntica; sin embargo, el caching se gestiona con la directiva cache.

stages:
  - build
  - scan
  - deploy

variables: IMAGE_TAG: “$CI_REGISTRY_IMAGE:$CI_COMMIT_SHA”

build: stage: build script: - docker build -t $IMAGE_TAG . artifacts: paths: - Dockerfile

scan: stage: scan image: aquasec/trivy:latest cache: key: “$CI_JOB_NAME” paths: - /root/.cache/trivy script: - trivy image —severity HIGH,CRITICAL —exit-code 1 $IMAGE_TAG

deploy: stage: deploy script: - docker login -u “$CI_REGISTRY_USER” -p “$CI_REGISTRY_PASSWORD” $CI_REGISTRY - docker push $IMAGE_TAG only: - main

3.2 Jenkins (Declarative Pipeline)

Jenkins necesita que instalemos el plugin Docker Pipeline y que tengamos Trivy disponible en el agente.

pipeline {
    agent any
environment {
    IMAGE = "myrepo/app:${env.BUILD_NUMBER}"
}

stages {
    stage('Checkout') {
        steps {
            checkout scm
        }
    }
    stage('Build') {
        steps {
            script {
                docker.build(env.IMAGE)
            }
        }
    }
    stage('Scan') {
        steps {
            sh '''
                # Instalar Trivy si no está presente
                if ! command -v trivy &>/dev/null; then
                  curl -sfL https://raw.githubusercontent.com/aquasecurity/trivy/main/contrib/install.sh | sudo sh -s -- -b /usr/local/bin
                fi
                trivy image --severity HIGH,CRITICAL --exit-code 1 --no-progress ${IMAGE}
            '''
        }
    }
    stage('Publish') {
        when {
            expression { currentBuild.currentResult == 'SUCCESS' }
        }
        steps {
            sh '''
                docker login -u $DOCKER_USER -p $DOCKER_PASS
                docker push ${IMAGE}
            '''
        }
    }
}

}

4. Buenas prácticas y hardening

4.1 Uso de bases de datos de vulnerabilidades offline

Para entornos con restricciones de red, podemos pre‑descargar la base de datos y montarla como volumen.

# Descargar DB en una máquina con internet
trivy image --download-db-only

Copiar el directorio ~/.cache/trivy a la máquina CI

En el pipeline:

docker run —rm -v $HOME/.cache/trivy:/root/.cache/trivy aquasec/trivy image
—severity HIGH,CRITICAL —exit-code 1 myrepo/app:latest

4.2 Escaneo de secretos y configuraciones

Trivy no sólo busca CVE; con el flag --scanners secret,config podemos detectar credenciales incrustadas o configuraciones inseguras.

trivy image --scanners vuln,secret,config --severity HIGH,CRITICAL --exit-code 1 myrepo/app:${{ github.sha }}

4.3 Integración con reportes y métricas

Exportar resultados a formatos JSON o SARIF permite alimentar dashboards de seguridad (e.g., SonarQube, GitHub Code Scanning).

# Generar reporte SARIF para GitHub Code Scanning
trivy image --format sarif --output trivy-report.sarif myrepo/app:${{ github.sha }}

Publicar artefacto

  • name: Upload SARIF report uses: github/codeql-action/upload-sarif@v2 with: sarif_file: trivy-report.sarif

Sección de Troubleshooting

Problema 1: “Failed to download DB: connection refused”

  • Causa: El runner no tiene salida a internet.
  • Solución: Pre‑descarga la DB en una máquina con acceso y usa la opción --skip-update, o monta la carpeta de cache como se muestra en la sección 4.1.

Problema 2: El pipeline no falla aunque existen vulnerabilidades HIGH

  • Causa: Se usó --exit-code 0 o se filtró incorrectamente la severidad.
  • Solución: Verificar que el comando incluya --severity HIGH,CRITICAL y --exit-code 1. Ejecutar manualmente para validar la salida.

Problema 3: “Error parsing image name”

  • Causa: Variable de entorno vacía o etiqueta con caracteres no permitidos.
  • Solución: Asegurarse de que la variable IMAGE_TAG (o equivalente) esté definida antes del escaneo. Usar echo $IMAGE_TAG para depurar.

Problema 4: Escaneo muy lento (>10 min)

  • Causa: Base de datos no cacheada o escaneo de capas redundantes.
  • Solución: Habilitar caché de la DB (ver sección 1.2) y usar la opción --skip-db-update cuando la DB ya está actualizada.

Conclusión

Integrar Trivy en pipelines CI/CD ofrece una capa crítica de defensa antes de que una imagen vulnerable llegue a producción. La automatización garantiza que cada commit sea evaluado bajo los mismos criterios de seguridad, reduciendo la superficie de ataque y alineando a los equipos de desarrollo con las mejores prácticas de DevSecOps.

Recuerda:

  • Mantener la base de datos de vulnerabilidades actualizada y cacheada.
  • Definir políticas de severidad claras y hacer que el pipeline falle en caso de incumplimiento.
  • Extender el escaneo a secretos y configuraciones para una visión integral.
  • Exportar resultados a sistemas de reporting para auditorías continuas.

Con los ejemplos y pasos descritos, cualquier sysadmin puede implementar un proceso robusto, reproducible y escalable que proteja sus entornos Docker en producción.

comentarios(0)

$ dejar comentario

סHola! Soy SylonBot. Si te pierdes en el artículo, pregúntame 👋
☕ invítame a un café Si el contenido te fue útil · via PayPal