Curso Docker #2: Imagenes Docker — Pull, Inspect y Docker Hub

Bienvenido al Curso de Docker - Parte 2 de 10

Fuente: Wikimedia Commons

¡Bienvenido a la Parte 2 del Curso de Docker! En el articulo anterior instalaste Docker y ejecutaste tu primer contenedor. Ahora vamos a profundizar en uno de los conceptos mas importantes de Docker: las imagenes.

Las imagenes son la base de todo en Docker. Sin imagenes no hay contenedores. En este articulo vas a entender como funcionan internamente, como encontrar imagenes en Docker Hub, como inspeccionarlas y como gestionar las imagenes en tu maquina.

Que es una imagen Docker

Una imagen Docker es una plantilla de solo lectura que contiene todo lo necesario para ejecutar una aplicacion: el sistema operativo base, las dependencias, el codigo de la aplicacion y las instrucciones para ejecutarla.

Piensa en una imagen como una receta de cocina: la receta no es el plato, pero contiene todas las instrucciones y la lista de ingredientes para prepararlo. De la misma forma, la imagen no es el contenedor, pero contiene todo lo necesario para crear uno.

Conceptos clave:

• Imagen: Plantilla inmutable (no cambia). Es como una clase en programacion orientada a objetos
• Contenedor: Instancia en ejecucion de una imagen. Es como un objeto creado a partir de una clase
• De una sola imagen puedes crear multiples contenedores identicos
• Las imagenes se almacenan en registros (como Docker Hub) y se descargan a tu maquina local

Capas de una imagen (Layers)

Las imagenes Docker no son un solo archivo monolitico. Estan compuestas por capas (layers) apiladas una sobre otra. Cada capa representa un cambio o instruccion en el Dockerfile que creo la imagen.

1# Veamos las capas de la imagen de nginx
2docker pull nginx
3docker history nginx

Este comando muestra cada capa de la imagen, su tamano y el comando que la creo. Por ejemplo:

1# Salida tipica de docker history
2IMAGE          CREATED       CREATED BY                                      SIZE
3a8758716bb6a   2 weeks ago   CMD ["nginx" "-g" "daemon off;"]                0B
4<missing>      2 weeks ago   EXPOSE map[80/tcp:{}]                           0B
5<missing>      2 weeks ago   STOPSIGNAL SIGQUIT                              0B
6<missing>      2 weeks ago   RUN /bin/sh -c set -x ...                       62.1MB
7<missing>      2 weeks ago   COPY file:xxx in /docker-entrypoint.d           4.62kB
8<missing>      2 weeks ago   ADD file:xxx in /                               77.8MB

Las ventajas del sistema de capas son:

• Reutilizacion: Si dos imagenes comparten la misma capa base (como Debian), Docker solo descarga esa capa una vez
• Cache: Al construir imagenes, Docker reutiliza capas que no han cambiado, acelerando el proceso
• Eficiencia: Solo las capas que difieren entre versiones necesitan descargarse en una actualizacion

Docker Hub: el registro de imagenes

Docker Hub es el registro publico mas grande de imagenes Docker. Es como un "GitHub para imagenes Docker" donde puedes encontrar imagenes oficiales y de la comunidad.

Imagenes oficiales vs comunidad

• Imagenes oficiales: Mantenidas por Docker y los creadores del software. Se identifican porque no tienen prefijo de usuario (ejemplo: nginx, python, postgres). Son verificadas, seguras y actualizadas regularmente
• Imagenes de la comunidad: Creadas por usuarios. Tienen el formato usuario/imagen (ejemplo: bitnami/postgresql). Pueden ser utiles pero debes verificar su reputacion y descargas

Tags (etiquetas)

Cada imagen puede tener multiples tags que representan diferentes versiones o variantes:

1# Descargar la ultima version (tag por defecto: latest)
2docker pull python
3
4# Descargar una version especifica
5docker pull python:3.12
6
7# Descargar una variante slim (mas liviana)
8docker pull python:3.12-slim
9
10# Descargar la variante basada en Alpine Linux (la mas pequena)
11docker pull python:3.12-alpine

Descargar imagenes con docker pull

El comando docker pull descarga una imagen desde un registro (por defecto Docker Hub) a tu maquina local:

1# Sintaxis basica
2docker pull <nombre_imagen>:<tag>
3
4# Ejemplos practicos
5docker pull ubuntu:22.04
6docker pull node:20-alpine
7docker pull mysql:8.0
8docker pull redis:7
9
10# Descargar desde un registro diferente (ejemplo: GitHub Container Registry)
11docker pull ghcr.io/usuario/mi-imagen:1.0

Cuando ejecutas docker pull, Docker descarga cada capa de la imagen individualmente. Si ya tienes alguna capa de una descarga anterior, Docker la reutiliza mostrando "Already exists":

1# Ejemplo de salida de docker pull
2$ docker pull node:20-alpine
320-alpine: Pulling from library/node
4c926b61bad3b: Already exists
51a1e53945498: Pull complete
6f65f33ba0b89: Pull complete
7Digest: sha256:abc123...
8Status: Downloaded newer image for node:20-alpine

Listar e inspeccionar imagenes

Una vez que has descargado imagenes, necesitas saber como gestionarlas:

Listar imagenes locales

1# Ver todas las imagenes
2docker images
3
4# Formato de la salida:
5# REPOSITORY   TAG        IMAGE ID       CREATED        SIZE
6# nginx        latest     a8758716bb6a   2 weeks ago    187MB
7# python       3.12       abc123def456   3 days ago     1.01GB
8# node         20-alpine  789ghi012jkl   1 week ago     130MB
9
10# Filtrar imagenes por nombre
11docker images node
12
13# Ver solo los IDs de las imagenes
14docker images -q

Inspeccionar una imagen

El comando docker inspect muestra toda la informacion detallada de una imagen en formato JSON:

1# Inspeccionar una imagen
2docker inspect nginx
3
4# Ver solo una parte especifica (con format)
5docker inspect --format='{{.Os}}/{{.Architecture}}' nginx
6# Salida: linux/amd64
7
8# Ver las variables de entorno definidas
9docker inspect --format='{{range .Config.Env}}{{println .}}{{end}}' python:3.12
10
11# Ver los puertos expuestos
12docker inspect --format='{{json .Config.ExposedPorts}}' nginx
13# Salida: {"80/tcp":{}}

Optimizacion del tamano de imagenes

El tamano de tus imagenes importa. Imagenes mas pequenas significan:

• Descargas mas rapidas (especialmente en CI/CD)
• Menos uso de disco
• Menos superficie de ataque (seguridad)
• Despliegues mas rapidos

Veamos la diferencia de tamano entre variantes de la misma imagen:

1# Descargar diferentes variantes de Python
2docker pull python:3.12
3docker pull python:3.12-slim
4docker pull python:3.12-alpine
5
6# Comparar tamanos
7docker images python
8# REPOSITORY   TAG           SIZE
9# python       3.12          1.01GB
10# python       3.12-slim     153MB
11# python       3.12-alpine   51.8MB

Como puedes ver, la variante alpine es 20 veces mas pequena que la imagen completa. Sin embargo, Alpine usa musl libc en lugar de glibc, lo que puede causar incompatibilidades con algunas librerias. La variante slim es un buen punto medio.

Consejos para imagenes mas pequenas

• Usa imagenes base slim o alpine cuando sea posible
• Combina multiples comandos RUN en uno solo con &&
• Limpia caches de paquetes en la misma capa donde los instalas
• Usa .dockerignore para excluir archivos innecesarios del build context
• Usa multi-stage builds (lo veremos en el proximo articulo)

Eliminar imagenes con docker rmi

Con el tiempo, las imagenes se acumulan y ocupan espacio. Es importante saber como limpiar:

1# Eliminar una imagen especifica
2docker rmi python:3.12
3
4# Eliminar por Image ID
5docker rmi abc123def456
6
7# Eliminar multiples imagenes
8docker rmi nginx python:3.12-slim node:20-alpine
9
10# Forzar eliminacion (si hay contenedores usando la imagen)
11docker rmi -f nginx
12
13# Eliminar TODAS las imagenes que no estan en uso
14docker image prune -a
15
16# Eliminar imagenes "colgantes" (sin tag, residuos de builds)
17docker image prune
18
19# Limpieza total: imagenes, contenedores, redes y cache
20docker system prune -a

Ver cuanto espacio ocupan las imagenes

1# Ver el espacio total usado por Docker
2docker system df
3
4# Salida tipica:
5# TYPE            TOTAL   ACTIVE   SIZE     RECLAIMABLE
6# Images          12      3        4.532GB  3.891GB (85%)
7# Containers      5       2        102.4MB  98.1MB (95%)
8# Local Volumes   8       3        1.234GB  987.6MB (80%)
9# Build Cache     24      0        567.8MB  567.8MB (100%)

Buscar imagenes desde la terminal

Ademas de buscar en la web de Docker Hub, puedes buscar imagenes directamente desde la terminal:

1# Buscar imagenes de PostgreSQL
2docker search postgresql
3
4# Filtrar por imagenes oficiales
5docker search --filter is-official=true postgresql
6
7# Limitar el numero de resultados
8docker search --limit 5 redis

Sin embargo, la busqueda web en hub.docker.com es mucho mas completa: te muestra la documentacion, las versiones disponibles, la popularidad y las instrucciones de uso de cada imagen.

Practica guiada: explorar y comparar imagenes

Vamos a poner en practica todo lo aprendido con un ejercicio:

1# 1. Descarga estas imagenes
2docker pull alpine:3.19
3docker pull ubuntu:22.04
4docker pull debian:bookworm-slim
5
6# 2. Compara sus tamanos
7docker images | grep -E "alpine|ubuntu|debian"
8# alpine         3.19              7.38MB
9# ubuntu         22.04             77.8MB
10# debian         bookworm-slim     74.8MB
11
12# 3. Inspecciona la arquitectura de cada una
13docker inspect --format='{{.Os}}/{{.Architecture}}' alpine:3.19
14docker inspect --format='{{.Os}}/{{.Architecture}}' ubuntu:22.04
15
16# 4. Ejecuta un contenedor con cada una y revisa su info
17docker run --rm alpine:3.19 cat /etc/os-release
18docker run --rm ubuntu:22.04 cat /etc/os-release
19docker run --rm debian:bookworm-slim cat /etc/os-release
20
21# 5. Limpia las imagenes que ya no necesites
22docker rmi alpine:3.19 ubuntu:22.04 debian:bookworm-slim

Resumen y proximo articulo

En este segundo articulo del curso hemos aprendido:

• Que son las imagenes Docker y como se diferencian de los contenedores
• Como funcionan las capas (layers) y por que son eficientes
• Como usar Docker Hub para encontrar imagenes oficiales y de la comunidad
• La importancia de los tags y por que no usar latest en produccion
• Como descargar, listar, inspeccionar y eliminar imagenes
• Estrategias para optimizar el tamano de las imagenes

En el proximo articulo (Parte 3 de 10) aprenderemos a escribir Dockerfiles para construir nuestras propias imagenes personalizadas. Crearemos imagenes para aplicaciones Node.js y Python paso a paso.

¡Nos vemos en el siguiente articulo!