Cómo usar el comando docker scout quickview para obtener una visión general de la imagen

Introducción

En este laboratorio, aprenderá cómo utilizar el comando docker inspect para obtener una visión general rápida de las imágenes de Docker. Explorará cómo obtener información detallada sobre una imagen específica, identificar e inspeccionar la imagen construida más recientemente, y comprender cómo extraer datos relevantes de la salida de la inspección utilizando opciones de formato. El laboratorio lo guiará a través de ejemplos prácticos utilizando imágenes de muestra y un simple Dockerfile.

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/inspect("Inspect Container") 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/inspect -.-> lab-555210{{"Cómo usar el comando docker scout quickview para obtener una visión general de la imagen"}} docker/pull -.-> lab-555210{{"Cómo usar el comando docker scout quickview para obtener una visión general de la imagen"}} docker/images -.-> lab-555210{{"Cómo usar el comando docker scout quickview para obtener una visión general de la imagen"}} docker/build -.-> lab-555210{{"Cómo usar el comando docker scout quickview para obtener una visión general de la imagen"}} end

Obtener una visión general rápida de una imagen específica

En este paso, aprenderá cómo obtener una visión general rápida de una imagen de Docker específica utilizando el comando docker inspect. Este comando proporciona información detallada sobre un objeto de Docker, incluyendo imágenes, contenedores, volúmenes y redes.

Primero, vamos a descargar una imagen de muestra que podamos inspeccionar. Utilizaremos la imagen hello-world, que es una imagen muy pequeña utilizada para pruebas.

docker pull hello-world

Debería ver una salida que indique que la imagen se está descargando.

Ahora que tenemos la imagen, podemos usar docker inspect para obtener información sobre ella.

docker inspect hello-world

Este comando generará una gran objeto JSON que contiene diversos detalles sobre la imagen hello-world, como su ID, fecha de creación, arquitectura, sistema operativo y configuración.

Para obtener una visión general rápida, puede estar interesado en campos específicos dentro de esta salida JSON. Puede usar la bandera -f o --format con docker inspect para especificar una plantilla de Go que formatee la salida. Por ejemplo, para ver el ID de la imagen y la fecha de creación, puede usar el siguiente comando:

docker inspect -f '{{.Id}} {{.Created}}' hello-world

Este comando mostrará el ID de la imagen seguido de su marca de tiempo de creación. Los {{.Id}} y {{.Created}} son marcadores de posición que se refieren a los campos Id y Created en la salida JSON de docker inspect.

Puede explorar otros campos en la salida JSON del comando completo docker inspect hello-world y utilizarlos en su cadena de formato para obtener la información específica que necesita.

Obtener una visión general rápida de la imagen construida más recientemente

En este paso, aprenderá cómo identificar y obtener una visión general rápida de la imagen de Docker construida más recientemente. Esto es útil cuando está desarrollando y construyendo imágenes activamente y desea inspeccionar rápidamente la última versión.

Primero, vamos a crear un simple Dockerfile para construir una imagen. En su directorio ~/project, cree un archivo llamado Dockerfile con el siguiente contenido:

FROM alpine:latest
RUN echo "Hello, Docker!" > /app/message.txt
CMD cat /app/message.txt

Este Dockerfile utiliza la imagen base alpine, agrega un archivo llamado message.txt con el contenido "Hello, Docker!" y establece el comando para imprimir el contenido de este archivo cuando se ejecuta el contenedor.

Ahora, construya la imagen de Docker utilizando el comando docker build. La etiquetaremos con my-recent-image.

docker build -t my-recent-image .

El . al final del comando indica que el Dockerfile está en el directorio actual (~/project). Verá una salida que muestra el proceso de construcción.

Después de que la construcción se complete, puede listar sus imágenes utilizando docker images.

docker images

Debería ver my-recent-image en la lista, junto con la imagen hello-world del paso anterior y la imagen base alpine. La imagen construida más recientemente generalmente aparecerá en la parte superior de la lista o tendrá la fecha de creación más reciente.

Para obtener una visión general rápida de la imagen construida más recientemente, puede combinar docker images con herramientas de línea de comandos como head y awk para extraer el ID de la imagen de la primera imagen en la lista (que suele ser la más reciente). Luego, puede usar docker inspect con ese ID.

docker inspect $(docker images -q | head -n 1)

Desglosemos este comando:

docker images -q: Esto lista solo los IDs de las imágenes.
head -n 1: Esto toma la primera línea de la salida, que es el ID de la imagen más reciente.
$(...): Esto es sustitución de comandos, que ejecuta el comando dentro de los paréntesis y sustituye su salida en el comando exterior.
docker inspect ...: Esto inspecciona la imagen con el ID obtenido de la sustitución de comandos.

Esto generará la información detallada en formato JSON de la imagen construida más recientemente. Puede volver a usar la bandera -f con docker inspect para dar formato a la salida según sea necesario, de manera similar al paso anterior.

Por ejemplo, para ver el ID y la fecha de creación de la imagen más reciente:

docker inspect -f '{{.Id}} {{.Created}}' $(docker images -q | head -n 1)

Esto proporciona una forma rápida de obtener información clave sobre la imagen que acaba de construir.

Obtener una visión general rápida a partir de un archivo SPDX

En este paso, aprenderá cómo obtener una visión general rápida de los componentes de software dentro de una imagen de Docker generando y examinando un archivo SPDX (Software Package Data Exchange, Intercambio de Datos de Paquetes de Software). SPDX es un estándar abierto para comunicar información sobre la lista de materiales de software (SBOM, Software Bill of Materials), incluyendo componentes, licencias y derechos de autor.

Generar un archivo SPDX para una imagen de Docker requiere una herramienta que pueda analizar las capas de la imagen y extraer la información necesaria. Una de esas herramientas es syft, una herramienta de línea de comandos para generar SBOMs a partir de imágenes de contenedores y sistemas de archivos.

Dado que syft no está preinstalado, lo descargaremos e instalaremos. Descargaremos la última versión para Linux.

curl -sSfL https://raw.githubusercontent.com/anchore/syft/main/install.sh | sudo bash -s -- -b /usr/local/bin

Este comando descarga el script de instalación de syft y lo ejecuta con sudo para instalar el binario en /usr/local/bin. Puede que se le pida su contraseña, pero el usuario labex tiene permisos sudo sin contraseña.

Después de la instalación, puede verificar que syft está instalado comprobando su versión:

syft version

Debería ver la información de la versión de syft.

Ahora, generemos un archivo SPDX para la imagen my-recent-image que construimos en el paso anterior. Enviaremos el resultado a un archivo llamado my-recent-image.spdx.json en el directorio ~/project.

syft my-recent-image -o spdx-json > ~/project/my-recent-image.spdx.json

Este comando le dice a syft que analice la imagen my-recent-image y que envíe los resultados en formato JSON SPDX, redirigiendo la salida al archivo especificado. Este proceso puede tardar un momento dependiendo del tamaño de la imagen.

Una vez que se complete el comando, tendrá un archivo JSON SPDX que contiene un inventario detallado de los paquetes de software encontrados dentro de la imagen. Puede ver el contenido de este archivo utilizando un editor de texto como nano:

nano ~/project/my-recent-image.spdx.json

Dentro del archivo, encontrará información sobre la imagen en sí y una lista de paquetes detectados, incluyendo sus nombres, versiones y licencias. Esto proporciona una visión general rápida de los componentes de software presentes en su imagen sin necesidad de ejecutar el contenedor o inspeccionar manualmente las capas individuales.

Puede desplazarse por el archivo para ver las diferentes secciones y la información que contienen. Busque la matriz packages, que enumera los componentes de software detectados.

Presione Ctrl + X para salir de nano.

Resumen

En este laboratorio, aprendiste cómo obtener una visión general rápida de las imágenes de Docker utilizando el comando docker inspect. Practicaste la inspección de una imagen específica al descargar la imagen hello-world y utilizar docker inspect para ver su información detallada en formato JSON. También aprendiste cómo usar la bandera -f con docker inspect y plantillas de Go para extraer y dar formato a campos específicos, como el ID de la imagen y la fecha de creación, lo que permite una visión general rápida personalizada.

Además, exploraste cómo identificar e inspeccionar la imagen de Docker construida más recientemente, lo cual es especialmente útil durante los ciclos de desarrollo activo. Esto implicó comprender cómo listar las imágenes y, potencialmente, filtrarlas o ordenarlas para encontrar la más reciente para su inspección.