Cómo usar el comando docker scout compare para analizar las diferencias entre imágenes

DockerDockerBeginner
Practicar Ahora

💡 Este tutorial está traducido por IA desde la versión en inglés. Para ver la versión original, puedes hacer clic aquí

Introducción

En este laboratorio, aprenderá cómo utilizar de manera efectiva el comando docker scout compare para analizar las diferencias entre dos imágenes de Docker. Este proceso es crucial para comprender los cambios en vulnerabilidades, paquetes y otros componentes de la imagen en diferentes versiones o compilaciones.

A través de ejercicios prácticos, explorará la comparación de imágenes con configuraciones predeterminadas, ignorando las vulnerabilidades de la imagen base, filtrando los resultados por gravedad y tipo de paquete, y generando un informe en markdown de los resultados de la comparación. Al final de este laboratorio, será proficiente en el uso de docker scout compare para obtener información valiosa sobre la seguridad y la composición de sus imágenes de contenedores.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL docker(("Docker")) -.-> docker/ContainerOperationsGroup(["Container Operations"]) docker(("Docker")) -.-> docker/ImageOperationsGroup(["Image Operations"]) docker(("Docker")) -.-> docker/DockerfileGroup(["Dockerfile"]) docker/ContainerOperationsGroup -.-> docker/ls("List Containers") docker/ImageOperationsGroup -.-> docker/pull("Pull Image from Repository") docker/ImageOperationsGroup -.-> docker/images("List Images") docker/DockerfileGroup -.-> docker/build("Build Image from Dockerfile") subgraph Lab Skills docker/ls -.-> lab-555200{{"Cómo usar el comando docker scout compare para analizar las diferencias entre imágenes"}} docker/pull -.-> lab-555200{{"Cómo usar el comando docker scout compare para analizar las diferencias entre imágenes"}} docker/images -.-> lab-555200{{"Cómo usar el comando docker scout compare para analizar las diferencias entre imágenes"}} docker/build -.-> lab-555200{{"Cómo usar el comando docker scout compare para analizar las diferencias entre imágenes"}} end

Comparar dos imágenes con configuraciones predeterminadas

En este paso, aprenderá cómo comparar dos imágenes de Docker utilizando una herramienta de análisis de vulnerabilidades. Comparar imágenes es crucial para identificar riesgos de seguridad y comprender las diferencias entre diferentes versiones o compilaciones de sus imágenes de contenedores. Utilizaremos una herramienta llamada trivy para este propósito. trivy es un analizador de vulnerabilidades simple y completo para contenedores y otros artefactos.

Primero, instalemos trivy. Dado que trivy no está preinstalado en el entorno de LabEx, debe descargarlo e instalarlo.

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

Los comandos anteriores primero actualizan la lista de paquetes, luego instalan las dependencias necesarias para agregar un nuevo repositorio. Después, descarga la clave pública del repositorio de trivy y la agrega a las claves de confianza de su sistema. Finalmente, agrega el repositorio de trivy a su lista de fuentes, actualiza la lista de paquetes nuevamente e instala trivy.

Ahora que trivy está instalado, extraigamos las imágenes de Docker que queremos comparar. Compararemos dos versiones diferentes de la imagen ubuntu: ubuntu:20.04 y ubuntu:22.04.

docker pull ubuntu:20.04
docker pull ubuntu:22.04

Estos comandos extraen las versiones especificadas de la imagen ubuntu de Docker Hub. Debería ver una salida que indique el progreso de la descarga y la extracción exitosa de las imágenes.

Ahora, podemos usar trivy para comparar estas dos imágenes. El comando básico para comparar dos imágenes es trivy image --diff-image [image1] [image2].

trivy image --diff-image ubuntu:20.04 ubuntu:22.04

Este comando analizará tanto ubuntu:20.04 como ubuntu:22.04 e informará las diferencias en las vulnerabilidades encontradas entre las dos imágenes. La salida mostrará las vulnerabilidades que están presentes en una imagen pero no en la otra, o las vulnerabilidades con diferentes niveles de gravedad. Esto le ayuda a entender cómo la actualización o el cambio de versiones de la imagen puede afectar su postura de seguridad.

La salida enumerará las vulnerabilidades categorizadas por gravedad (DESCONOCIDA, BAJA, MEDIA, ALTA, CRÍTICA). Mostrará las vulnerabilidades que se agregaron en la segunda imagen (ubuntu:22.04 en este caso) en comparación con la primera (ubuntu:20.04), y las vulnerabilidades que se eliminaron.

Comparar imágenes e ignorar las vulnerabilidades de la imagen base

En el paso anterior, comparamos dos imágenes de ubuntu y vimos las diferencias en las vulnerabilidades. A veces, al comparar imágenes, puede interesarle más las vulnerabilidades introducidas por su código de aplicación o dependencias, en lugar de las vulnerabilidades heredadas de la imagen base. trivy le permite ignorar las vulnerabilidades que están presentes en una imagen base especificada.

Para demostrar esto, primero creemos un simple Dockerfile que utilice ubuntu:20.04 como imagen base y agregue un archivo simple.

Navegue a su directorio de proyecto:

cd ~/project

Cree un archivo llamado Dockerfile utilizando nano:

nano Dockerfile

Pegue el siguiente contenido en el Dockerfile:

FROM ubuntu:20.04
RUN echo "This is a test file" >/app/test.txt

Guarde el archivo y salga de nano (Ctrl+X, Y, Enter).

Este Dockerfile es muy simple. Comienza desde la imagen ubuntu:20.04 y luego ejecuta un comando para crear un archivo llamado test.txt dentro de un directorio /app.

Ahora, construyamos una imagen de Docker a partir de este Dockerfile. La etiquetaremos como my-ubuntu-app:latest.

docker build -t my-ubuntu-app:latest .

El comando docker build construye una imagen a partir de un Dockerfile. La bandera -t my-ubuntu-app:latest etiqueta la imagen con el nombre my-ubuntu-app y la etiqueta latest. El . al final especifica que el Dockerfile está en el directorio actual. Debería ver una salida que indique el proceso de construcción y la creación exitosa de la imagen.

Ahora tenemos dos imágenes: ubuntu:20.04 (la imagen base) y my-ubuntu-app:latest (la imagen construida sobre la imagen base). Podemos comparar my-ubuntu-app:latest con ubuntu:20.04 e ignorar las vulnerabilidades que ya están presentes en ubuntu:20.04. Esto nos mostrará solo las vulnerabilidades introducidas por los cambios en nuestro Dockerfile.

Utilizamos la bandera --ignore-base con el comando trivy image para lograr esto.

trivy image --ignore-base --diff-image ubuntu:20.04 my-ubuntu-app:latest

Este comando compara my-ubuntu-app:latest con ubuntu:20.04, pero solo informa las vulnerabilidades que están presentes en my-ubuntu-app:latest y no en ubuntu:20.04. Dado que nuestro Dockerfile solo agregó un archivo simple y no instaló ningún paquete nuevo, debería ver muy pocas o ninguna nueva vulnerabilidad reportada en comparación con la salida del paso anterior. Esto demuestra cómo --ignore-base ayuda a centrarse en el impacto de seguridad de su capa de aplicación.

Comparar imágenes y filtrar por gravedad y tipo de paquete

En los pasos anteriores, realizamos comparaciones básicas de imágenes. Sin embargo, la salida a veces puede ser muy detallada, especialmente para imágenes con muchas vulnerabilidades. trivy le permite filtrar los resultados según el nivel de gravedad y el tipo de paquete, lo que le ayuda a centrarse en los problemas más críticos o en tipos específicos de vulnerabilidades.

Comparemos de nuevo ubuntu:20.04 y ubuntu:22.04, pero esta vez filtraremos los resultados para mostrar solo las vulnerabilidades con una gravedad de ALTA o CRÍTICA. Esto es útil cuando desea priorizar la corrección de las vulnerabilidades más graves.

Utilizamos la bandera --severity para especificar el nivel de gravedad mínimo a reportar. Puede proporcionar una lista separada por comas de niveles de gravedad.

trivy image --diff-image ubuntu:20.04 ubuntu:22.04 --severity HIGH,CRITICAL

Este comando comparará las dos imágenes de ubuntu y solo mostrará las vulnerabilidades que se clasifican como ALTA o CRÍTICA en cualquiera de las imágenes. Notará que la salida es mucho más corta que la comparación predeterminada, ya que excluye las vulnerabilidades con niveles de gravedad más bajos (DESCONOCIDA, BAJA, MEDIA).

Además de filtrar por gravedad, también puede filtrar por el tipo de paquete donde se encontró la vulnerabilidad. trivy puede escanear vulnerabilidades en paquetes del sistema operativo (como aquellos instalados a través de apt, yum, etc.) y dependencias de aplicaciones (como bibliotecas utilizadas por su código).

Comparemos las imágenes de nuevo, pero esta vez solo buscaremos vulnerabilidades en los paquetes del sistema operativo. Utilizamos la bandera --vuln-type para esto.

trivy image --diff-image ubuntu:20.04 ubuntu:22.04 --vuln-type os

Este comando comparará las dos imágenes y solo reportará las vulnerabilidades encontradas en los paquetes del sistema operativo. Esto es útil si se preocupa principalmente por la seguridad de la capa base del sistema operativo de su imagen.

También puede combinar estos filtros. Por ejemplo, para ver solo las vulnerabilidades ALTA o CRÍTICA en los paquetes del sistema operativo:

trivy image --diff-image ubuntu:20.04 ubuntu:22.04 --severity HIGH,CRITICAL --vuln-type os

Este comando proporciona una vista más enfocada de las vulnerabilidades más graves dentro de la capa del sistema operativo de sus imágenes. El filtrado le ayuda a manejar la salida y priorizar sus esfuerzos de seguridad de manera efectiva.

Comparar imágenes y generar un informe en markdown

En los pasos anteriores, visualizamos los resultados de la comparación de vulnerabilidades directamente en la terminal. Si bien esto es útil para comprobaciones rápidas, a menudo es necesario guardar los resultados en un formato estructurado para informes, documentación o análisis adicionales. trivy admite varios formatos de salida, incluyendo markdown.

Generar un informe en markdown es útil porque markdown es un lenguaje de marcado ligero que es fácil de leer y se puede convertir fácilmente a otros formatos como HTML o PDF.

Para generar un informe en markdown de la comparación de imágenes, utilizamos la bandera --format y especificamos markdown. También redirigimos la salida a un archivo utilizando el operador >.

Comparemos de nuevo ubuntu:20.04 y ubuntu:22.04 y guardemos la salida en un archivo markdown llamado comparison_report.md en su directorio ~/project.

trivy image --diff-image ubuntu:20.04 ubuntu:22.04 --format markdown > ~/project/comparison_report.md

Este comando realiza la misma comparación que en el primer paso, pero formatea la salida como markdown y la guarda en el archivo especificado. Esta vez no verá la salida directamente en la terminal.

Después de que el comando termine, puede ver el archivo markdown generado utilizando cat o nano.

cat ~/project/comparison_report.md

Este comando mostrará el contenido del archivo comparison_report.md en su terminal. Debería ver los resultados de la comparación de vulnerabilidades formateados utilizando la sintaxis de markdown, incluyendo encabezados, listas y tablas.

También puede abrir el archivo con nano para verlo en un editor de texto:

nano ~/project/comparison_report_markdown.md

Recuerde salir de nano después de ver el archivo (Ctrl+X).

Generar informes en diferentes formatos como markdown le permite compartir fácilmente la información de vulnerabilidades con otros o integrarla en sus flujos de trabajo de informes existentes. Este es un paso crucial para incorporar la verificación de seguridad en sus flujos de desarrollo y despliegue.

Resumen

En este laboratorio, aprendiste cómo utilizar la herramienta trivy para comparar dos imágenes de Docker. Comenzaste instalando trivy en el entorno de LabEx, lo cual implicó agregar el repositorio de trivy e instalar el paquete utilizando apt. Después de la instalación, descargaste dos versiones diferentes de la imagen ubuntu, ubuntu:20.04 y ubuntu:22.04, desde Docker Hub. Finalmente, ejecutaste el comando básico trivy image --diff-image para comparar estas dos imágenes y analizar las diferencias en sus vulnerabilidades y paquetes.