Contenedores desde cero
Un contenedor es una caja que lleva dentro una aplicación con todo lo que necesita para funcionar, y que funciona igual en cualquier ordenador.
El problema: «en mi ordenador funciona»
Imagina que alguien de tu equipo ha hecho una pequeña aplicación web. En su portátil va perfecta. Se la pasa al compañero que gestiona los servidores, la instala… y no arranca. Falta una librería, la versión de Python es otra, un fichero de configuración apunta a una carpeta que no existe.
Ese choque se ha repetido en todas las empresas durante décadas. Los contenedores nacieron para acabar con él: en vez de pasar sólo la aplicación y una lista de instrucciones, se pasa la aplicación ya empaquetada con todo lo que necesita.
Piensa en los contenedores de los barcos de mercancías. Antes de que existieran, cada carga se subía al barco a su manera: sacos, cajas, barriles… y cada puerto tenía que saber manejar cada cosa. Cuando se inventó el contenedor de tamaño estándar, dejó de importar lo que hubiera dentro. Cualquier grúa, cualquier barco y cualquier camión del mundo sabe moverlo.
Los contenedores de software hacen lo mismo: da igual qué aplicación vaya dentro, cualquier servidor preparado para contenedores sabe ejecutarla.
Contenedor o máquina virtual
Antes de los contenedores, la forma habitual de aislar aplicaciones era la máquina virtual (VM): un ordenador «de mentira» dentro de un ordenador real, con su propio sistema operativo completo. Funciona, pero pesa: cada máquina virtual lleva un Windows o un Linux entero, tarda minutos en arrancar y ocupa varios gigas.
Un contenedor no lleva sistema operativo propio. Todos los contenedores de un servidor comparten el núcleo del sistema operativo (el kernel) del ordenador donde corren. Por eso son ligeros: arrancan en segundos y ocupan megas.
Una máquina virtual es una casa unifamiliar: cada una tiene sus cimientos, su tejado, su caldera. Muy independiente, pero cara.
Un contenedor es un piso en un edificio: cada piso tiene su puerta y nadie entra en el del vecino, pero todos comparten los cimientos, la estructura y las tuberías generales. Caben muchos más en el mismo terreno.
Contenedores y máquinas virtuales no son enemigos. Es muy normal tener máquinas virtuales en la nube y, dentro de ellas, muchos contenedores.
Imagen y contenedor: el molde y la galleta
Hay dos palabras que se confunden mucho y que el examen da por sabidas:
- Imagen (image): el paquete guardado, quieto, listo para usar. Es una plantilla que no cambia.
- Contenedor (container): una imagen en marcha. Es lo que está vivo y trabajando.
La imagen es el molde de galletas; el contenedor es cada galleta. Con un solo molde haces todas las galletas que quieras, todas iguales. Si muerdes una galleta, el molde sigue intacto.
Las imágenes tienen nombre y etiqueta (tag), separados por dos puntos: nginx:1.27 quiere decir «la imagen nginx, versión 1.27». Si no pones etiqueta, se usa latest («la última»), que es cómodo pero arriesgado: hoy y mañana puede ser una versión distinta.
Los contenedores son de usar y tirar
Una idea importante: los contenedores se tratan como efímeros. Si un contenedor falla, no se repara: se tira y se arranca otro nuevo desde la imagen. Si cambias algo dentro de un contenedor en marcha, ese cambio se pierde cuando el contenedor desaparece. Lo que haya que guardar (una base de datos, fotos subidas) se guarda fuera, en almacenamiento aparte. Lo veremos en la lección de almacenamiento.
Las capas: una imagen se construye por pisos
Una imagen no es un bloque único. Está hecha de capas (layers) apiladas, y cada capa añade algo encima de la anterior.
Ventajas de las capas:
- Ahorran espacio y tiempo: si diez imágenes usan el mismo Linux de base, esa capa se descarga una sola vez.
- Actualizar es rápido: si sólo cambias tu código, sólo se vuelve a construir y a subir la capa de arriba.
- Las capas son de sólo lectura. Cuando un contenedor arranca, recibe encima una capa fina en la que sí puede escribir. Esa capa es la que se pierde al borrar el contenedor.
La receta: el Dockerfile
Una imagen se construye a partir de una receta escrita en un fichero de texto llamado Dockerfile (o Containerfile, es lo mismo). Cada línea es un paso, y casi cada paso crea una capa.
# Parto de una imagen que ya trae Linux y Python FROM python:3.12-slim # Trabajo dentro de la carpeta /app WORKDIR /app # Copio la lista de librerías y las instalo COPY requirements.txt . RUN pip install -r requirements.txt # Copio el código de mi aplicación COPY . . # Lo que se ejecuta al arrancar el contenedor CMD ["python", "tienda.py"]
No hace falta saber escribir un Dockerfile para el examen. Basta con saber qué es: la receta con la que se construye una imagen, empezando siempre por una imagen base (FROM).
El almacén de imágenes: el registro
Una vez construida, la imagen se sube a un registro (registry): un almacén de imágenes en internet o dentro de la empresa. Desde ahí, cualquier servidor la puede descargar.
Un registro es como la tienda de aplicaciones del móvil, pero para imágenes. Alguien la publica, y tú la descargas e instalas cuando la necesitas. El registro público más conocido es Docker Hub. También hay registros privados: GitHub, Google, Amazon o Harbor (un proyecto de la CNCF para montarlo en casa).
¿Quién arranca los contenedores? El runtime
La imagen es sólo un paquete. Alguien tiene que abrirlo y ponerlo en marcha. Ese programa se llama motor de contenedores o container runtime.
La imagen es un disco y el runtime es el reproductor. El disco no suena solo, hace falta algo que lo lea y lo reproduzca.
Hay dos niveles de runtime, como en un restaurante con encargado y cocinero:
| Nivel | Qué hace | Ejemplos |
|---|---|---|
| Alto nivel el encargado | Descarga imágenes, las guarda, decide qué contenedores arrancar y los vigila. | containerd, CRI-O |
| Bajo nivel el cocinero | Hace el trabajo físico de crear el contenedor en el sistema operativo. | runc (el más usado), crun, gVisor, Kata Containers |
¿Y Docker? Docker es la herramienta que popularizó los contenedores en 2013. Es un conjunto cómodo para personas: construye imágenes, las sube, las arranca… Por dentro, Docker usa containerd y runc.
Los estándares: por qué todo encaja
Igual que los contenedores de barco tienen medidas estándar (las normas ISO), los de software también tienen sus normas, para que una imagen hecha con una herramienta funcione con cualquier otra:
- OCI (Open Container Initiative): define cómo es una imagen por dentro (image spec), cómo se ejecuta un contenedor (runtime spec) y cómo se sube y baja de un registro (distribution spec).
- CRI (Container Runtime Interface): el «enchufe» estándar por el que Kubernetes habla con el runtime. Cualquier runtime con ese enchufe vale para Kubernetes: containerd y CRI-O lo tienen.
Kubernetes dejó de usar Docker directamente como runtime en la versión 1.24 (2022). Se eliminó una pieza intermedia llamada dockershim. Hoy se usan containerd o CRI-O.
Pero las imágenes construidas con Docker siguen funcionando en Kubernetes, porque cumplen el estándar OCI. Lo que cambió es el reproductor, no los discos.
Bajo el capó, sin miedo: paredes y contador de luz
¿Cómo consigue Linux que un contenedor crea que está solo en el ordenador? Con dos funciones del sistema operativo, y basta con saber cómo se llaman y para qué sirve cada una:
- namespaces (espacios de nombres de Linux): son las paredes. Cada contenedor ve sus propios procesos, su propia red y sus propios ficheros, como si estuviera solo.
- cgroups (grupos de control): son el contador de luz con límite. Ponen un tope a cuánta CPU y memoria puede gastar cada contenedor, para que uno no deje sin recursos a los demás.
Más adelante verás que Kubernetes también tiene algo llamado Namespace. Es otra cosa, una forma de ordenar el clúster por carpetas. Mismo nombre, distinto concepto.
Resumen en cinco frases
- Un contenedor empaqueta una aplicación con todo lo que necesita y funciona igual en cualquier sitio.
- Es más ligero que una máquina virtual porque comparte el sistema operativo del servidor.
- La imagen es el molde (quieto, por capas); el contenedor es la imagen en marcha, de usar y tirar.
- Las imágenes se construyen con un Dockerfile y se guardan en un registro.
- Los contenedores los arranca un runtime (containerd, CRI-O, runc), y todo encaja gracias a los estándares OCI y CRI.
Términos del examen
- Container
- Una aplicación empaquetada y en marcha, aislada del resto.
- Image
- El paquete guardado a partir del que se arrancan contenedores. No cambia.
- Tag
- La etiqueta de versión de una imagen, como :1.27 o :latest.
- Layer
- Cada «piso» de una imagen. Se comparten entre imágenes y son de sólo lectura.
- Dockerfile
- La receta para construir una imagen.
- Registry
- Almacén de imágenes (Docker Hub, Harbor…).
- Container runtime
- El programa que arranca y vigila contenedores.
- containerd · CRI-O
- Runtimes de alto nivel que usa Kubernetes.
- runc
- Runtime de bajo nivel, el que crea el contenedor de verdad.
- OCI
- El estándar de imágenes y contenedores.
- CRI
- El enchufe estándar entre Kubernetes y el runtime.
- dockershim
- Pieza que permitía usar Docker en Kubernetes. Eliminada en la 1.24.
- namespaces (Linux)
- Las paredes: aíslan lo que ve cada contenedor.
- cgroups
- El contador con límite: controla cuántos recursos gasta.
- Ephemeral
- Efímero, de usar y tirar.
Comprueba que lo has entendido
1. What is the main difference between a container and a virtual machine?
- Containers include a full guest operating system
- Containers share the host's kernel
- Virtual machines start faster than containers
- Containers can only run on Linux laptops
Ver respuesta
B. Los contenedores comparten el núcleo (kernel) del servidor; las máquinas virtuales llevan cada una su sistema operativo completo. Por eso los contenedores son más ligeros y arrancan antes.
2. Which of these is a low-level container runtime?
- containerd
- CRI-O
- runc
- kubelet
Ver respuesta
C. runc es el «cocinero» que crea el contenedor. containerd y CRI-O son de alto nivel (los «encargados»). kubelet es una pieza de Kubernetes que veremos en la lección 02.
3. Kubernetes removed dockershim in version 1.24. What happens to images built with Docker?
- They must be rebuilt with a different tool
- They keep working, because they follow the OCI standard
- They can only run in virtual machines
- They must be converted to CRI format
Ver respuesta
B. Las imágenes de Docker cumplen el estándar OCI, así que containerd o CRI-O las ejecutan sin problema. Cambió el reproductor, no el disco.
4. Which Linux feature limits how much CPU and memory a container can use?
- namespaces
- cgroups
- layers
- registries
Ver respuesta
B. Los cgroups son el contador con límite. Los namespaces son las paredes: deciden lo que el contenedor ve, no lo que gasta.
5. What is the Container Runtime Interface (CRI)?
- A public registry for container images
- A file format for Dockerfiles
- The API Kubernetes uses to talk to container runtimes
- A tool for building images
Ver respuesta
C. CRI es el enchufe estándar entre Kubernetes y el runtime. Gracias a él se puede usar containerd, CRI-O o cualquier otro que lo tenga.