Docker: imágenes y contenedores · Infra C8¶
Lo que se vio en la sesión: por qué una aplicación que funciona en un portátil
falla en el servidor, qué es de verdad un contenedor cuando se lo mira desde el
sistema operativo, cómo se escribe un Dockerfile que no repita la instalación
en cada cambio, y qué pasa con los datos cuando el contenedor se borra. Las
diapositivas están en el Campus Virtual; aquí quedan las órdenes, las trazas que
devolvieron y lo que salió en el salón.
La aplicación no es solo el código¶
El caso con el que se abrió: un equipo termina una interfaz en Python, funciona
en el portátil de quien la escribió y falla al instalarla en el servidor. La
versión era 3.10 en el portátil y 3.8 en el servidor. Lo mismo pasa con dos
aplicaciones que necesitan Java 8 y Java 17 en la misma máquina, donde la salida
casera es cambiar el PATH a mano cada vez.
Lo que hay que mover junto con el código son las bibliotecas, las variables de entorno, el sistema de archivos y las versiones. De ahí la pregunta de la sesión: cómo se empaca una aplicación con su entorno para moverla a cualquier máquina sin reconfigurar nada.
Hay dos respuestas. La máquina virtual lleva un sistema operativo completo sobre un hipervisor, con su propio núcleo. El contenedor comparte el núcleo del anfitrión y empaca solo la aplicación y sus bibliotecas. Por eso un contenedor arranca en milisegundos y una máquina virtual tarda segundos o minutos y reserva la memoria como si fuera un equipo aparte.
Eso se apoya en dos mecanismos del núcleo de Linux, los namespaces y los cgroups, que no existen en el núcleo de Windows. Ahí Docker corre sobre WSL, que es un sistema sobre otro, con la latencia que eso cuesta.
Un contenedor es un proceso del anfitrión¶
El ejemplo de la sesión es un servicio Flask de doce líneas que responde el nombre de máquina y la versión. Se construye y se levanta así:
docker build -t hola-mundo .
docker run -d -p 8080:5000 --name hola hola-mundo
curl http://localhost:8080
{"host":"9058e5d763be","mensaje":"Hola desde el contenedor","version":"0.1.0"}
docker ps
NAMES IMAGE STATUS PORTS
hola hola-mundo Up 2 seconds 0.0.0.0:8080->5000/tcp, [::]:8080->5000/tcp
Lo que importa de ese contenedor es que no es una máquina pequeña. Es un proceso más en la tabla del anfitrión, y se puede mirar desde los dos lados a la vez:
PID=$(docker inspect -f '{{.State.Pid}}' hola)
ps -o pid,ppid,comm -p "$PID"
docker exec hola sh -c 'cat /proc/1/comm; tr "\0" " " < /proc/1/cmdline'
PID PPID COMMAND
24110 24087 python
python
python app.py
El mismo programa es el proceso 24110 para el anfitrión y el proceso 1 para el contenedor. Un solo proceso, dos numeraciones, y eso es exactamente lo que hace un namespace:
readlink /proc/self/ns/pid
docker exec hola readlink /proc/self/ns/pid
pid:[4026531836]
pid:[4026532905]
Dos identificadores distintos, uno por cada árbol de procesos. Dentro del
contenedor se pueden usar las mismas herramientas de siempre, ps, top,
hostname, y todas contestan sobre lo que el namespace deja ver.
El anfitrión, en cambio, no ve un bulto: ve cada proceso del contenedor por
separado, con su propio número en la numeración de la máquina. Un contenedor
que arranque tres procesos aparece como tres procesos en el ps del anfitrión,
y el que adentro es el número uno es el que docker inspect devuelve en
.State.Pid. Eso funciona porque en Linux los procesos también son archivos,
bajo /proc, y el namespace solo cambia qué parte de ese árbol se alcanza
desde dentro.
De ahí sale la idea que conviene no perder: Docker no inventa el aislamiento, lo pide prestado al núcleo. Cuando alguien se escapa de un contenedor, la falla no está en Docker, está en el núcleo de Linux.
Aislado no es seguro¶
El aislamiento separa, pero no blinda. El namespace de usuarios es el mismo a
los dos lados mientras no se diga otra cosa, así que root dentro del
contenedor es root de la máquina, y un proceso que se salga del namespace de
montaje sale con esos permisos. De ahí tres costumbres.
La primera es no correr la aplicación como root. En el Dockerfile se crea
una cuenta sin privilegios y se cambia a ella antes del CMD:
RUN useradd --create-home appuser
USER appuser
La segunda es no montar el sistema de archivos del anfitrión dentro de un contenedor ni pasarle el socket de Docker, porque cualquiera de las dos le entrega la máquina entera a quien esté adentro.
La tercera es de instalación, y conviene saber qué significa. Pertenecer al
grupo docker evita escribir sudo en cada orden, pero quien puede hablarle
al demonio puede levantar un contenedor que monte todo el disco, así que ese
grupo equivale a root en esa máquina. Lo que de verdad baja el privilegio es
el modo sin raíz, donde el propio demonio corre sin ser root.
Lo que el contenedor ve y lo que puede consumir¶
Si los namespaces deciden qué ve el proceso, los cgroups deciden cuánto consume. Se fijan al levantarlo:
docker run --rm --cpuset-cpus=0-11 --cpus=1.5 --memory=256m --pids-limit=64 \
python:3.12-slim sh -c 'echo "nproc: $(nproc)"
echo "cpu.max: $(cat /sys/fs/cgroup/cpu.max)"
echo "memory.max: $(cat /sys/fs/cgroup/memory.max)"
echo "pids.max: $(cat /sys/fs/cgroup/pids.max)"'
nproc: 12
cpu.max: 150000 100000
memory.max: 268435456
pids.max: 64
Ahí está la trampa que más cuesta en este curso. El contenedor tiene asignado
1,5 núcleos, que es lo que dice cpu.max: 150.000 microsegundos de cómputo
por cada 100.000 de reloj. Pero nproc contesta 12, porque /proc/cpuinfo
y /proc/meminfo no están aislados y siguen siendo los del anfitrión. Un
programa que dimensione su conjunto de hilos con nproc crea doce hilos para
turnarse 1,5 núcleos, y pierde en cambios de contexto lo que creía ganar. La
cifra correcta está en cpu.max.
El consumo real se mira con docker stats, que da el porcentaje de CPU y la
memoria usada frente a la disponible, contenedor por contenedor.
La imagen y el contenedor¶
La imagen es la receta y el contenedor es el plato cocinado: de una sola receta salen muchos platos, y cada uno puede terminar distinto. Las imágenes viven en un registro, y el público es Docker Hub.
docker pull nginx:alpine # traerla
docker images # las que hay en la máquina
docker push usuario/imagen # subir la propia
Las imágenes oficiales traen variantes, slim, alpine y las completas, que
se diferencian en lo que viene preinstalado; cuál sirve se decide leyendo la
documentación de esa imagen. Las más livianas son las que menos traen, y eso se
nota cuando hace falta una biblioteca del sistema.
Una imagen se descarga una sola vez. Varios contenedores comparten sus capas, que son de solo lectura, y cada uno añade encima su propia capa escribible con su configuración. Por eso dos contenedores del mismo servidor web no ocupan el doble de disco.
El Dockerfile¶
El de la sesión, entero:
FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app.py .
ENV APP_VERSION=0.1.0
EXPOSE 5000
CMD ["python", "app.py"]
Las instrucciones que se usaron y lo que hace cada una:
| Instrucción | Qué hace |
|---|---|
FROM |
De qué imagen se parte. El vacío es el punto de partida sin sistema de archivos |
WORKDIR |
El directorio de trabajo dentro de la imagen |
COPY |
Copia del contexto de construcción hacia la imagen |
RUN |
Ejecuta una orden durante la construcción y deja el resultado en una capa |
ENV |
Variable de entorno |
EXPOSE |
Documenta el puerto en que escucha. No lo publica |
USER |
Con qué cuenta corre el proceso |
VOLUME |
Declara una ruta que debe salir de la capa escribible |
CMD |
La orden por defecto |
ENTRYPOINT |
El ejecutable fijo, al que CMD le pasa los argumentos |
La orden del CMD tiene que ser persistente. Si el proceso termina, el
contenedor se detiene, porque ese proceso es el número uno del contenedor y
cuando muere no queda nadie dentro.
Sobre CMD y ENTRYPOINT hay dos cosas distintas que conviene no mezclar. Una
es el reparto de papeles: con ENTRYPOINT el ejecutable queda fijo y CMD pasa
a ser la lista de argumentos por defecto, que se puede reemplazar al levantar el
contenedor. La otra es la forma de escribirlos, y la tienen las dos
instrucciones por igual. Escritos como una cadena, CMD python app.py, la orden
se lanza bajo /bin/sh, y el intérprete queda como proceso número uno y se
traga las señales, de modo que un docker stop espera los diez segundos
completos antes de matar a todo el mundo. Escritos como lista, CMD ["python",
"app.py"], el programa queda como proceso número uno y recibe la señal él
mismo. Por eso el ejemplo usa la segunda forma.
Dónde se rompe la caché¶
Cada instrucción produce una capa, y Docker reutiliza las capas anteriores
mientras nada haya cambiado. De ahí que el orden decida cuánto tarda una
reconstrucción. Con las dependencias arriba, una edición del código solo invalida
el COPY app.py y lo que viene después; con un COPY . /app en el paso tres,
invalida también la instalación de las dependencias:
| Construcción | Tiempo |
|---|---|
| Dependencias arriba, editando el código | 2,374 s |
COPY . /app en el paso tres, editando el código |
7,274 s |
Tres veces más, por el orden de dos líneas. Y hay un efecto de arrastre: COPY .
sube todo lo que haya en la carpeta, incluidos binarios compilados y entornos
locales que no sirven dentro de la imagen. Lo que no debe entrar se escribe en
un archivo .dockerignore, igual que se hace con .gitignore.
Agregar una instrucción al final del Dockerfile no invalida nada de lo de
arriba: se ejecuta esa sola y el resto sigue viniendo de la caché. Y cuando hay
que comprobar que la imagen se construye de cero, docker build --no-cache
ignora todas las capas guardadas y vuelve a ejecutar cada instrucción.
Errores que se pagan después¶
- Fijar la imagen base en
latest. Es un tag móvil: la próxima construcción puede traer una versión mayor incompatible. - Correr la aplicación como
root. Dentro del contenedorrootesroot, y si alguien se escapa, se escapa con esa cuenta. - Guardar contraseñas en
ENVo dentro de la imagen. Quedan en la capa y viajan con ella a donde vaya la imagen. Para eso están los secretos. - Copiar el código antes de instalar las dependencias. Es la caché rota de arriba.
- Separar
apt-get updateyapt-get installen dosRUN. Quedan en capas distintas, y la instalación puede terminar usando un índice viejo que vino de la caché. - No limpiar la caché de paquetes. Los instaladores descargados se quedan en
la capa y engordan la imagen. Por eso el ejemplo usa
pip install --no-cache-dir.
Ejecutar y operar¶
Un contenedor se crea, arranca, se puede pausar, se detiene y se elimina:
docker create docker start docker stop docker pause docker rm
docker ps # los que están corriendo
docker ps -a # todos, incluidos los detenidos
Parar y pausar no son lo mismo: el detenido termina sus procesos y los vuelve a
arrancar con el siguiente docker start, mientras que el pausado los deja
congelados donde estaban.
docker ps -a lista los contenedores que existen, corriendo o detenidos. Los
que se borraron no salen, porque dejaron de existir:
docker rm -f db
docker ps -a --filter name=db --filter name=efimero --format 'table {{.Names}}\t{{.Status}}'
NAMES STATUS
efimero Up 9 seconds
db2 Up 32 seconds
Las banderas de docker run que se usaron:
| Bandera | Para qué |
|---|---|
-d |
Lo deja corriendo en segundo plano y devuelve la terminal |
-it |
Entrada interactiva con terminal, para meterse dentro |
-p 8080:5000 |
Puerto del anfitrión hacia el puerto del contenedor |
-v datos:/var/datos |
Monta un volumen |
-e CLAVE=valor |
Variable de entorno |
--name |
Nombre legible, para no andar con identificadores |
--rm |
Lo borra al salir |
--network |
Lo conecta a una red concreta |
--restart |
Política de reinicio |
Para saber qué está pasando dentro hay dos órdenes que se usan todo el tiempo,
docker logs <nombre>, que saca lo que el proceso escribió, y docker port,
que dice por dónde está publicado:
docker port hola
5000/tcp -> 0.0.0.0:8080
5000/tcp -> [::]:8080
Y entrar al contenedor se hace con docker exec -it <nombre> sh, siempre que la
imagen traiga un intérprete de órdenes: las imágenes más recortadas no lo
incluyen, y ahí la inspección se hace desde fuera con docker inspect.
Qué significa escuchar en 0.0.0.0¶
El servicio del ejemplo arranca con app.run(host="0.0.0.0", port=5000), y esa
dirección es la que decide si el mapeo de puertos sirve de algo.
0.0.0.0 como dirección de escucha quiere decir todas las direcciones de la
máquina: la aplicación acepta conexiones por cualquiera de sus interfaces. Es
lo contrario de 127.0.0.1, que es solo la propia máquina y deja al servicio
inalcanzable desde fuera del contenedor por bien mapeado que esté el puerto. No
es una dirección de difusión; la de difusión en IPv4 es 255.255.255.255.
En la salida de docker port aparece también [::], que es la forma de IPv6
de lo mismo, la dirección sin especificar, equivalente a 0.0.0.0. IPv6 no
tiene difusión: lo que en IPv4 se hacía con una dirección de difusión, aquí se
hace con multidifusión.
Lo que sobrevive al contenedor¶
Cada contenedor escribe sobre una capa propia que nace con él y muere con él:
docker run --rm python:3.12-slim sh -c 'echo "una nota" > /tmp/nota.txt; cat /tmp/nota.txt'
docker run --rm python:3.12-slim sh -c 'cat /tmp/nota.txt'
una nota
cat: /tmp/nota.txt: No such file or directory
El segundo contenedor es otro y no ve nada de lo que escribió el primero.
Lo que mata esa capa es borrar el contenedor, no detenerlo. El mismo contenedor parado y vuelto a arrancar encuentra lo suyo donde lo dejó:
docker exec efimero sh -c 'echo "una nota" > /tmp/nota.txt'
docker stop efimero && docker start efimero
docker exec efimero cat /tmp/nota.txt
una nota
Recreado desde la imagen, no:
docker rm -f efimero
docker run -d --name efimero python:3.12-slim sleep 300
docker exec efimero cat /tmp/nota.txt
cat: /tmp/nota.txt: No such file or directory
Lo que tenga que durar va en un volumen, que se comporta como un disco que se conecta al contenedor:
docker volume create datos
docker run --rm -v datos:/var/datos python:3.12-slim sh -c 'echo "una nota" > /var/datos/nota.txt'
docker run --rm -v datos:/var/datos python:3.12-slim sh -c 'cat /var/datos/nota.txt'
datos
una nota
El primer contenedor escribió y desapareció; el segundo encontró el archivo. Los
volúmenes se listan con docker volume ls, se miran con docker volume inspect
y los que no use nadie se borran con docker volume prune.
Un volumen es una carpeta del disco del anfitrión, y docker volume inspect
dice cuál:
docker volume inspect datos --format '{{.Mountpoint}}'
/var/lib/docker/volumes/datos/_data
De ahí se sigue algo que hay que tener claro antes de confiarle datos: el volumen vive en esa máquina y no viaja con la imagen. Cambiar de computador deja los datos atrás, y moverlos es un trabajo aparte.
El caso que obliga a entenderlos es una base de datos. PostgreSQL guarda lo
suyo en /var/lib/postgresql/data, así que basta montar un volumen ahí para
que la base sobreviva al contenedor:
docker volume create pgdata
docker run -d --name db -e POSTGRES_PASSWORD=ejemplo \
-v pgdata:/var/lib/postgresql/data postgres:16
docker exec db psql -U postgres -c "create table nota (texto text);"
docker exec db psql -U postgres -c "insert into nota values ('persiste');"
docker rm -f db
docker run -d --name db2 -e POSTGRES_PASSWORD=ejemplo \
-v pgdata:/var/lib/postgresql/data postgres:16
docker exec db2 psql -U postgres -c "select * from nota;"
CREATE TABLE
INSERT 0 1
texto
----------
persiste
(1 row)
El contenedor que creó la tabla ya no existe y la fila sigue ahí. Sin el
volumen, el segundo contenedor inicializa la base desde cero y la consulta
falla con relation "nota" does not exist. El proyecto final pide volúmenes
justamente por esto.
Redes¶
Una red de Docker es un puente virtual con su propio espacio de nombres de red, que decide quién alcanza a quién. Una instalación nueva trae tres:
docker network ls
NETWORK ID NAME DRIVER SCOPE
3348fa7ac315 bridge bridge local
cafd577edf74 host host local
04a729d115d0 none null local
bridge es la de por defecto y por ahí los contenedores salen a internet por
NAT; host pone al contenedor en la pila de red del anfitrión, sin aislarlo;
y none lo deja sin más red que su propio bucle local.
NAT es lo que evitó que las direcciones IPv4 se acabaran: un grupo de máquinas comparte una dirección pública y se distinguen por el puerto. Con unos 65.535 puertos, de los cuales los primeros 1.024 están reservados, quedan más de 63.000 conversaciones por dirección. Migrar a IPv6 resuelve el problema de raíz, pero hay enrutadores de veinte años que solo hablan IPv4 y cambiarlos cuesta.
Lo que cambia al crear una red propia es el nombre:
docker network create app
docker run -d --name db --network app postgres:16
docker run -d --name api --network app -p 8080:8080 mi-api
Dentro de una red creada a mano, Docker levanta un servicio de resolución de
nombres que traduce el nombre del contenedor a su dirección. Por eso la cadena
de conexión de la API puede decir db:5432 y seguir siendo válida aunque el
contenedor se reinicie con otra dirección. En la red bridge por defecto eso no
ocurre y hay que andar con direcciones.
Y ahí aparece el otro uso, que es aislar: si la base de datos vive solo en la
red app y únicamente la API publica un puerto hacia fuera, la base no es
alcanzable desde la máquina ni desde internet. Un contenedor que ya está
corriendo se suma a una red con docker network connect app <contenedor>, sin
volver a crearlo.
Publicar una imagen¶
docker tag hola-mundo usuario/hola-mundo:1.0.0
docker login
docker push usuario/hola-mundo:1.0.0
El nombre completo de una imagen es registro/usuario/imagen:tag, y Docker
completa lo que falte: si no se escribe el registro asume Docker Hub, y si no se
escribe el tag asume latest.
latest no es un número de versión, es un tag móvil que apunta a lo último que
se subió. Dos despliegues de la misma línea pueden bajar imágenes distintas, así
que para desplegar va el número de versión, o el digest sha256, que es la suma
de verificación de la imagen y señala una y solo una.
Esto mismo es lo que se va a usar para subir las imágenes al registro de Google Cloud en el proyecto: cambia el registro del nombre, no el procedimiento.
Lo que Docker solo no resuelve¶
Con lo visto se levanta un servicio. Lo que no alcanza empieza cuando son varios:
- Levantar varios servicios con dependencias entre ellos, como una API con su base de datos y su caché, pide muchas órdenes manuales.
- Las redes y los volúmenes se crean y se conectan uno por uno.
- Si un contenedor falla, hay que levantarlo a mano.
- Escalar un servicio a varias instancias y repartirles la carga es trabajo aparte.
- Coordinar un despliegue sobre más de una máquina queda fuera de lo que Docker hace.
De ahí salen las dos piezas que siguen, Docker Compose para describir el conjunto en un archivo, y Kubernetes para la orquestación sobre varias máquinas. La palabra viene de donde parece: en una orquesta cada músico sabe tocar lo suyo y con eso no basta, porque alguien tiene que decidir quién entra, cuándo y en qué orden para que aquello suene.
Para seguir¶
- Las once actividades de la sesión están en la página de ejercicios, en el mismo orden de los temas. En clase se hicieron las de fundamentos y construcción de imágenes; las de ejecución y operación y las de distribución quedaron para la casa.
- El código de la sesión está completo, con el
Dockerfiley las órdenes para construir, levantar y limpiar. - Lo que se vio aquí es la base. Quien quiera profundizar tiene por dónde: seguridad de imágenes, construcción para varias arquitecturas y el examen de capas son los caminos naturales desde este punto.