---
title: "Virtualización y contenedores: dos formas de compartir una misma máquina"
domain: cloud-computing
level: beginner
duration: "50 min"
objectives:
  - "Explicar cómo funciona la virtualización por hardware y comparar los hipervisores de tipo 1 y de tipo 2."
  - "Comparar máquinas virtuales y contenedores en aislamiento, tiempo de arranque, densidad y sobrecarga."
  - "Explicar cómo los namespaces y los grupos de control (cgroups) de Linux aíslan y limitan un contenedor."
  - "Construir una imagen de contenedor y explicar sus capas y los formatos de la Open Container Initiative (OCI)."
  - "Configurar límites de recursos para un contenedor y diagnosticar un contenedor detenido por superar su memoria."
lang: es
source_hash: 4bf9ebf7179f
---

# Virtualización y contenedores: dos formas de compartir una misma máquina

## Por qué importa
Lanzas un servidor «pequeño» en la nube y está listo en menos de un minuto. Detrás de ese botón, el proveedor no ha cableado un ordenador nuevo para ti. Ha cortado una porción de una máquina mucho mayor, y decenas de clientes más comparten el mismo hardware. Dos técnicas hacen posible ese reparto: la **virtualización**, que da a cada cliente un ordenador ficticio completo, y los **contenedores**, que dan a cada aplicación su propia vista privada de un único sistema operativo compartido.

La elección importa cada día. Una máquina virtual (VM) es un muro fuerte pero pesado. Un contenedor es ligero y rápido, pero comparte el kernel de su anfitrión, así que el muro es más fino. Un contenedor que se come toda la memoria puede ser eliminado en mitad de una petición, y un contenedor iniciado como root con las opciones equivocadas puede poner en riesgo todo el anfitrión. Para elegir bien la herramienta, dimensionarla correctamente y ejecutarla con seguridad, necesitas saber qué es realmente cada una y qué separa de verdad a un contenedor de la máquina en la que se ejecuta. Esta lección explica ambas cosas.

## Objetivos de aprendizaje
- Explicar cómo funciona la virtualización por hardware y comparar los hipervisores de tipo 1 y de tipo 2.
- Comparar máquinas virtuales y contenedores en aislamiento, tiempo de arranque, densidad y sobrecarga.
- Explicar cómo los namespaces y los grupos de control (cgroups) de Linux aíslan y limitan un contenedor.
- Construir una imagen de contenedor y explicar sus capas y los formatos de la Open Container Initiative (OCI).
- Configurar límites de recursos para un contenedor y diagnosticar un contenedor detenido por superar su memoria.

## Conceptos clave

### Virtualización por hardware e hipervisores
Piensa en un gran edificio de oficinas. Una opción es alquilar a cada empresa una planta con sus propias paredes, puertas y tuberías. Otra es alquilar mesas en una única planta diáfana compartida, separadas por mamparas. La primera es la virtualización: cada inquilino recibe un «edificio» entero para él. La segunda, que llega más adelante en esta lección, son los contenedores.

**Virtualización** significa ejecutar varios ordenadores virtuales aislados en un único ordenador físico, el **anfitrión** (*host*). Cada ordenador virtual es una **máquina virtual (VM)**, también llamada **invitado** (*guest*). Un invitado tiene sus propias CPU virtuales, memoria, disco y tarjetas de red, y ejecuta su propio sistema operativo (SO) completo con su propio **kernel**, el núcleo del SO que habla con el hardware. El invitado cree que posee hardware real.

El software que crea y ejecuta las VM es el **hipervisor**, o monitor de máquinas virtuales (VMM, *virtual machine monitor*). Tiene tres tareas:
- **Compartir el hardware.** Planifica las CPU virtuales de todos los invitados sobre los núcleos reales de la CPU y da a cada invitado su propia porción de memoria real.
- **Aislar a los invitados.** Un invitado no puede leer la memoria de otro invitado ni tomar el control del anfitrión, porque el hipervisor controla qué puede tocar cada uno.
- **Presentar dispositivos virtuales.** El invitado ve un disco virtual y una tarjeta de red virtual, que el hipervisor asigna a archivos, almacenamiento y puertos de red reales.

La virtualización temprana era lenta porque el kernel de un invitado espera ejecutarse en el modo más privilegiado de la CPU, y solo un kernel puede ocuparlo. Trucos de software (traducir o interceptar instrucciones privilegiadas) lo hicieron funcionar, pero costaban rendimiento. Las CPU modernas lo resolvieron con la **virtualización asistida por hardware**: **Intel VT-x** y **AMD-V** (indicadores `vmx` y `svm` en `/proc/cpuinfo` en Linux). Añaden un nuevo modo de CPU para invitados: el kernel invitado se ejecuta con privilegio total, pero en un modo en el que la CPU devuelve el control al hipervisor, lo que se llama **VM exit**, cada vez que el invitado hace algo que debe controlarse, como tocar un dispositivo. Otras extensiones aceleran la memoria (traducción de direcciones de segundo nivel, llamada EPT en Intel y NPT en AMD) y permiten que un hipervisor dé a un invitado acceso directo y seguro a un dispositivo (una unidad de gestión de memoria de entrada-salida, IOMMU: Intel VT-d, AMD-Vi). En la mayoría de los ordenadores estas funciones pueden desactivarse en la configuración del firmware, y por eso un hipervisor a veces informa de que la virtualización no está disponible.

Un invitado también puede ir más rápido cuando sabe que es virtual. Los controladores **paravirtualizados**, como la familia `virtio` que usa KVM, sustituyen un disco o una tarjeta de red «reales» simulados por una interfaz sencilla hecha para máquinas virtuales.

Los hipervisores se presentan en dos diseños:

| | Tipo 1 (bare metal) | Tipo 2 (alojado) |
|---|---|---|
| **Se ejecuta** | Directamente sobre el hardware | Como una aplicación sobre un SO anfitrión normal |
| **Ejemplos** | KVM, Xen, VMware ESXi, Microsoft Hyper-V | Oracle VirtualBox, VMware Workstation, Parallels Desktop |
| **Capas** entre un invitado y el hardware | Hipervisor | Aplicación hipervisor y luego el SO anfitrión |
| **Sobrecarga y control** | Menor sobrecarga, control directo del hardware | Más sobrecarga, el SO anfitrión sigue al mando del hardware |
| **Uso típico** | Centros de datos y nubes públicas | Portátiles, equipos de desarrollo, pruebas |

![Dos pilas dibujadas de abajo arriba. Tipo 1, bare metal, con ejemplos KVM, Xen, ESXi y Hyper-V: el hardware (CPU con VT-x o AMD-V, RAM, discos, tarjetas de red) soporta directamente el hipervisor y, encima, tres máquinas virtuales, cada una con su propio sistema operativo invitado y kernel y una aplicación. Una nota indica que tiene menos capas y menos sobrecarga y que es la opción habitual en centros de datos y nubes. Tipo 2, alojado, con ejemplos VirtualBox, VMware Workstation y Parallels: el hardware soporta un sistema operativo anfitrión como Windows, macOS o Linux; sobre el anfitrión se ejecuta una aplicación hipervisor, que pide CPU, memoria y disco al SO anfitrión, junto a otras apps; la aplicación hipervisor soporta tres máquinas virtuales con SO invitado y aplicación. Una nota indica que tiene una capa más pero es fácil de instalar en un portátil.](../../../assets/diagrams/virt-hypervisor-types.es.svg)

*Figura 1. Un hipervisor de tipo 1 se sitúa directamente sobre el hardware; un hipervisor de tipo 2 es una aplicación más sobre un sistema operativo anfitrión.*

> [!NOTE]
> La frontera entre los dos tipos es difusa, y los ejemplos anteriores son solo ejemplos. KVM es un módulo dentro del kernel de Linux: convierte al propio Linux en un hipervisor, y un programa como QEMU aporta los dispositivos virtuales, por lo que suele contarse como tipo 1 aunque Linux sea también un SO de propósito general. Hyper-V se instala sobre Windows, pero entonces se ejecuta por debajo de él, y Windows pasa a ser una VM especial. Lo que importa es cuánto hay entre el invitado y el hardware, no la etiqueta.

> [!CHECK]
> ¿Por qué las CPU modernas tienen extensiones como Intel VT-x y AMD-V?
>
> - [ ] Permiten que una VM invitada se salte el hipervisor y use los dispositivos físicos sin ningún control
> - [x] Dan a los kernels invitados un modo seguro en el que la mayoría de las instrucciones se ejecutan directamente en la CPU y el hipervisor recupera el control solo cuando hace falta
> - [ ] Permiten que varias VM compartan un kernel, lo que las hace tan ligeras como los contenedores
> - [ ] Cifran el disco de cada VM para que el anfitrión no pueda leerlo
>
> Con la ayuda del hardware, el invitado ejecuta su propio kernel a toda velocidad y la CPU pasa al hipervisor solo en un VM exit. Esto elimina la mayor parte de la lenta traducción por software que necesitaban los hipervisores antiguos. No elimina el control del hipervisor.

### Máquinas virtuales frente a contenedores
Una VM virtualiza el **hardware**: cada invitado trae su propio kernel. Un **contenedor** virtualiza el **sistema operativo**: es un proceso normal (o un grupo de procesos) en el anfitrión, iniciado con una vista restringida del sistema. Todos los contenedores de un anfitrión comparten el único kernel del anfitrión. No hay SO invitado que arrancar, ni hardware virtual, ni hipervisor en el camino.

![A la izquierda, máquinas virtuales: el hardware soporta un hipervisor, que soporta tres máquinas virtuales, cada una con su propio kernel invitado, librerías y app. Etiquetas: kernel propio por VM, frontera a nivel de hardware. Datos: arranca en segundos o minutos porque arranca un sistema operativo, normalmente gigabytes por imagen, menos por anfitrión. A la derecha, contenedores: el hardware soporta un sistema operativo anfitrión con un único kernel compartido, cuyos namespaces y cgroups aíslan cada contenedor; encima, un runtime de contenedores como Podman o containerd con runc o crun ejecuta tres contenedores, cada uno solo con sus librerías y su app. Etiquetas: un único kernel compartido, frontera a nivel de kernel. Datos: arranca en milisegundos o segundos, normalmente megabytes por imagen, muchos más por anfitrión.](../../../assets/diagrams/virt-vm-vs-container.es.svg)

*Figura 2. Cada VM lleva su propio kernel invitado; todos los contenedores comparten el kernel del anfitrión, así que un contenedor contiene solo la aplicación y sus librerías.*

Esta única diferencia explica cada fila de la comparación:

| | Máquina virtual | Contenedor |
|---|---|---|
| **Qué se virtualiza** | Hardware | La vista del SO (procesos, red, archivos) |
| **Kernel** | Uno por VM | Compartido con el anfitrión y con otros contenedores |
| **Frontera de aislamiento** | Hipervisor y extensiones de virtualización de la CPU | Funciones del kernel: namespaces, cgroups, capabilities, seccomp |
| **Fortaleza del aislamiento** | Fuerte: la superficie de ataque es el hipervisor | Más débil: la superficie de ataque es todo el kernel compartido |
| **Tiempo de arranque** | Segundos a minutos (arranca un SO) | Milisegundos a unos pocos segundos (inicia un proceso) |
| **Tamaño típico de imagen** | Gigabytes (un SO completo) | Megabytes (app y librerías) |
| **Sobrecarga** | Un SO invitado por VM: memoria, disco, CPU para servicios en segundo plano | Cercana a la de un proceso normal |
| **Densidad** | Menos por anfitrión (decenas) | Muchos más por anfitrión (centenares) |
| **SO invitado** | Cualquiera que el hardware pueda ejecutar: Linux, Windows, BSD | El mismo tipo de kernel que el anfitrión: los contenedores Linux necesitan un kernel Linux |
| **Uso típico** | Sistemas operativos distintos, separación estricta entre inquilinos, software heredado | Microservicios, escalado rápido, despliegue repetible |

Las cifras de la tabla son órdenes de magnitud típicos, no garantías; dependen de la carga de trabajo y de la plataforma.

Conviene recordar dos consecuencias prácticas:
- **Los contenedores en Windows o macOS** usan una VM Linux oculta, porque esos sistemas no tienen un kernel Linux que compartir. La herramienta de contenedores de tu portátil es una VM más contenedores.
- **Los sistemas reales mezclan ambos.** Las nubes públicas ejecutan tus contenedores dentro de VM, de modo que un fallo del kernel en el contenedor de un cliente no llega a otro cliente. Hay opciones ligeras entre ambos extremos: las **microVM** (como Firecracker) dan a cada carga de trabajo una VM diminuta que arranca rápido, y los runtimes con sandbox (como gVisor y Kata Containers) añaden una capa extra de aislamiento alrededor de los contenedores.

> [!CHECK]
> Debes ejecutar una aplicación Windows y una aplicación Linux en el mismo servidor, con una separación estricta entre ellas. ¿Qué encaja mejor?
>
> - [ ] Dos contenedores, porque los contenedores arrancan más rápido que las VM
> - [ ] Un contenedor Linux para ambas, porque los contenedores pueden ejecutar cualquier aplicación
> - [x] Dos VM, cada una con su propio SO invitado
> - [ ] Un hipervisor de tipo 2, porque no necesita SO anfitrión
>
> Los contenedores comparten el kernel del anfitrión, así que un anfitrión Linux solo puede ejecutar contenedores Linux. Las VM traen su propio kernel, así que cada una puede ejecutar un SO distinto. Un hipervisor de tipo 2 sí necesita un SO anfitrión.

### Namespaces de Linux: lo que un contenedor puede ver
¿Cómo puede un proceso normal creer que está solo en una máquina? El kernel de Linux puede dar a un proceso su propia copia privada de un recurso del sistema. Cada tipo de copia privada es un **namespace** (espacio de nombres). Un proceso vive en un namespace de cada tipo, y los procesos del mismo namespace ven lo mismo. Los namespaces que hay detrás de un contenedor son:

| Namespace | Aísla | Efecto dentro de un contenedor |
|---|---|---|
| **pid** | ID de proceso | El primer proceso es el PID 1 y el contenedor solo ve sus propios procesos. |
| **net** | Interfaces de red, rutas, reglas de firewall, puertos | Su propia interfaz de red y dirección IP, y sus propios números de puerto. |
| **mnt** | Puntos de montaje | Su propio sistema de archivos raíz (la imagen) en lugar del del anfitrión. |
| **uts** | Nombre de host y nombre de dominio | Su propio nombre de host. |
| **ipc** | Memoria compartida y colas de mensajes | Los procesos no pueden usar la memoria compartida de otro contenedor. |
| **user** | ID de usuario y de grupo | Root (UID 0) dentro puede equivaler a un usuario normal sin privilegios en el anfitrión. |
| **cgroup** | La vista del árbol de cgroups | El contenedor ve su propio cgroup como la raíz del árbol. |

Los kernels más recientes también tienen un namespace **time**, que los contenedores no usan por defecto. Un proceso normalmente empieza en los namespaces del anfitrión; un runtime de contenedores crea otros nuevos con las llamadas al sistema `clone()` y `unshare()`, como se describe en `namespaces(7)`. Puedes ver en qué namespaces está un proceso como enlaces en `/proc/<pid>/ns/`: dos procesos comparten un namespace cuando el número del enlace es el mismo.

Los namespaces dan **aislamiento de la vista**, no **límites**. Un proceso en su propio namespace pid no puede ver otros procesos, pero aun así puede usar toda la CPU y toda la memoria. De eso se encarga el siguiente mecanismo.

### Grupos de control (cgroups): lo que un contenedor puede usar
Un **grupo de control (cgroup)** es una función del kernel que agrupa procesos y controla cuánto de la máquina pueden usar. Linux moderno usa **cgroups versión 2 (v2)**, con una **jerarquía unificada** montada en `/sys/fs/cgroup`. Cada grupo es un directorio, y sus límites se leen y se establecen leyendo y escribiendo archivos en él. Cada archivo pertenece a un **controlador**:

| Archivo | Controlador | Significado |
|---|---|---|
| `memory.max` | memory | Límite estricto de memoria en bytes (o `max` para ninguno). Por encima, el kernel primero recupera memoria y después activa el OOM killer dentro del grupo. |
| `memory.high` | memory | Límite blando: por encima, el grupo se ralentiza por la recuperación de memoria, pero no se le mata. |
| `memory.current`, `memory.events` | memory | Uso actual y contadores, como las veces que ocurrió `oom_kill`. |
| `cpu.max` | cpu | Una cuota y un periodo en microsegundos: `50000 100000` significa «50 ms de CPU cada 100 ms», o media CPU. `max 100000` significa sin límite. |
| `cpu.weight` | cpu | Parte relativa cuando las CPU están ocupadas (por defecto 100). |
| `pids.max` | pids | Máximo de procesos e hilos del grupo: una defensa contra las fork bombs. |
| `io.max` | io | Límites de ancho de banda de disco y de operaciones por segundo por dispositivo. |

![Un proceso de contenedor, sleep 3600, es el PID 1 dentro de su contenedor y un PID normal del anfitrión fuera. De él salen dos flechas. A la izquierda, los namespaces deciden lo que puede ver: pid, su propio árbol de procesos; net, sus propias interfaces, rutas y puertos; mnt, su propia tabla de montajes y sistema de archivos raíz; uts, su propio nombre de host; ipc, su propia memoria compartida y colas; user, root dentro equivale a un usuario sin privilegios; cgroup, su propia vista del árbol de cgroups. A la derecha, cgroups versión 2 deciden lo que puede usar: memory.max, un límite de RAM por encima del cual actúa el OOM killer; cpu.max, una cuota de CPU como 50000 100000, media CPU; pids.max, el máximo de procesos; io.max, límites de disco. Una nota indica que son funciones del kernel, no un hipervisor: el proceso se ejecuta directamente en el kernel del anfitrión.](../../../assets/diagrams/virt-namespaces-cgroups.es.svg)

*Figura 3. Los namespaces limitan lo que un contenedor puede ver; los cgroups limitan lo que puede usar. Junto con las demás funciones de seguridad del kernel, eso es lo que es un «contenedor».*

Así que un contenedor no es algo que el kernel conozca. Es un proceso normal, iniciado dentro de un conjunto de namespaces y un cgroup, con un sistema de archivos raíz distinto. Por eso arranca en milisegundos y casi no tiene sobrecarga. También por eso el aislamiento es tan fuerte como lo sea el kernel.

Superar los límites se comporta de forma distinta con cada recurso:
- La **CPU** es *comprimible*: un grupo que agota su cuota es **limitado** (*throttled*, pausado hasta el siguiente periodo), no eliminado.
- La **memoria** *no* lo es: si un grupo necesita más de `memory.max` y el kernel no puede recuperar suficiente (por ejemplo descartando la caché de archivos), el **OOM killer** (out-of-memory, sin memoria) elige un proceso de ese grupo y le envía `SIGKILL`.

> [!CHECK]
> Un contenedor se ejecuta con un límite de CPU de 0.5 CPU y un límite de memoria de 256 MB. Intenta usar una CPU entera y 300 MB sin parar. ¿Qué ocurre?
>
> - [ ] El kernel detiene el contenedor al instante, porque intentó superar un límite
> - [ ] Ambos límites solo ralentizan al contenedor; nunca se le mata
> - [x] El uso de CPU se limita a aproximadamente media CPU y el uso de memoria activa el OOM killer
> - [ ] Los límites son solo indicaciones para el planificador; el contenedor obtiene lo que necesita
>
> La CPU es comprimible, así que el cgroup la limita. La memoria no puede quitársele a un proceso en ejecución, así que al superar `memory.max` el OOM killer termina un proceso del grupo.

### Imágenes de contenedor, capas y los formatos OCI
Un contenedor parte de una **imagen**: un paquete de solo lectura que contiene un sistema de archivos raíz más metadatos (qué comando ejecutar, variables de entorno, el usuario). La imagen es una plantilla; el **contenedor** en ejecución es una instancia de ella. Piensa en una clase y un objeto, o en una receta y un plato.

Para que las imágenes sean pequeñas y rápidas de compartir, una imagen se construye con **capas**. Cada instrucción de un archivo de construcción (un `Containerfile`, o `Dockerfile` en Docker) que modifica el sistema de archivos, como `RUN` y `COPY`, añade una capa: un archivo comprimido que contiene solo los archivos que cambiaron. Las instrucciones que solo cambian metadatos, como `CMD` y `LABEL`, no añaden capa. Las capas son **direccionables por contenido**: cada una se nombra con el **digest** de su contenido, `sha256:` seguido de 64 dígitos hexadecimales. Las capas idénticas se almacenan una sola vez y se comparten, así que diez imágenes basadas en la misma imagen base guardan esa base en disco una sola vez, y descargar una imagen actualizada solo descarga las capas que cambiaron.

Cuando inicias un contenedor, el runtime apila las capas de la imagen con un sistema de archivos de unión (normalmente **overlayfs**) y añade encima una fina **capa escribible**, de modo que el contenedor ve un único sistema de archivos. Esto funciona mediante **copy-on-write** (copia al escribir): una capa inferior nunca se modifica. Si el contenedor cambia un archivo que vive en una capa inferior, el archivo se copia primero hacia la capa escribible y se modifica allí; si lo borra, una marca (un «whiteout») lo oculta. Cuando se elimina el contenedor, su capa escribible desaparece con él. Todo lo que deba sobrevivir al contenedor pertenece a un **volumen**, un directorio almacenado fuera del contenedor.

![A la izquierda, la imagen lab-virt-hello:1.0 como tres capas de solo lectura apiladas y compartidas por todos los contenedores: capa 1, el sistema de archivos raíz de Alpine de alpine:3.20.10, 8.09 MB; capa 2, RUN apk add procps-ng, 1.27 MB; capa 3, COPY app.sh, 3.58 kB. Una nota indica que CMD y LABEL solo cambian la configuración de la imagen y no añaden capa. Sobre la imagen hay dos contenedores, A y B, cada uno con su propia capa escribible copy-on-write, que se borra con el contenedor. Una nota explica que escribir en un archivo de una capa inferior lo copia primero hacia arriba y que borrarlo deja una marca whiteout. A la derecha, el manifiesto de la imagen enumera la config (el ID de la imagen) y las tres capas por su digest sha256, y una tarjeta contrapone una etiqueta, un nombre que puede moverse, con un digest, este contenido exacto para siempre.](../../../assets/diagrams/virt-image-layers.es.svg)

*Figura 4. Las capas son de solo lectura y compartidas; cada contenedor añade solo una fina capa escribible encima. Los tamaños proceden de la imagen que construyes en el laboratorio.*

La **Open Container Initiative (OCI)**, un proyecto neutral respecto a los proveedores bajo la Linux Foundation, define los estándares que permiten que herramientas de distintos fabricantes funcionen juntas. Por eso una imagen construida con Podman se ejecuta en Docker, containerd o un clúster de Kubernetes, y al revés. Hay tres especificaciones:

| Especificación | Define |
|---|---|
| **Especificación de imagen** | El formato de la imagen: un **manifiesto** (enumera la configuración y las capas por digest), una **configuración** (comando, entorno, historial) y los archivos de las capas. |
| **Especificación de runtime** | Cómo ejecutar una imagen desempaquetada: un sistema de archivos raíz y un `config.json` que enumera los namespaces, los límites de cgroup, los montajes y las capabilities. **runc** es el runtime de referencia; **crun** es otro. |
| **Especificación de distribución** | La API HTTP que usa un **registro** para subir y descargar imágenes. |

Un **registro** (*registry*) almacena y sirve imágenes (ejemplos: Docker Hub, Quay.io, GitHub Container Registry y los registros de las nubes públicas). Una referencia de imagen tiene la forma `registro/repositorio:etiqueta`, por ejemplo `docker.io/library/alpine:3.20.10`. Hay dos formas de nombrar una imagen que se comportan de manera muy distinta:
- Una **etiqueta** (*tag*; `3.20.10`, `latest`) es una marca cómoda para las personas que el publicador puede **mover** a otra imagen en cualquier momento. `latest` es solo el nombre de una etiqueta por defecto; no significa «la más reciente».
- Un **digest** (`alpine@sha256:<64 dígitos hexadecimales>`) identifica un contenido exacto. Nunca puede apuntar a otra cosa.

Para construcciones repetibles, fija la imagen base a una etiqueta de versión exacta (`alpine:3.20.10`, no `alpine` ni `alpine:latest`), y fija por digest donde necesites la garantía de que el contenido no ha cambiado.

> [!CHECK]
> Un `Containerfile` tiene `FROM alpine:3.20.10`, luego `RUN apk add --no-cache curl`, después `COPY app.sh /app.sh` y `CMD ["/app.sh"]`. ¿Cuántas capas nuevas añade la construcción sobre la imagen base?
>
> - [ ] Cuatro, una por instrucción
> - [x] Dos: el `RUN` y el `COPY`
> - [ ] Una, porque la construcción lo fusiona todo en una sola capa
> - [ ] Tres: `RUN`, `COPY` y `CMD`
>
> Solo las instrucciones que modifican el sistema de archivos añaden una capa. `CMD` (como `LABEL`) solo cambia la configuración de la imagen, y `FROM` selecciona las capas base en lugar de añadir una.

### Ejecutar contenedores con seguridad: modo sin root, límites y el OOM killer
Por defecto, muchos motores de contenedores se ejecutan como root. Si algo escapa del contenedor, aterriza en el anfitrión como root. Dos funciones reducen ese riesgo.

Los **contenedores sin root** (*rootless*) ejecutan el motor y el contenedor como un usuario normal. Con un **namespace user**, el UID 0 *dentro* del contenedor se asigna a tu UID sin privilegios *fuera*, y los demás UID del contenedor se asignan a un rango de UID subordinados reservado para ti en `/etc/subuid`. El contenedor cree que es root, pero en el anfitrión solo tiene tus derechos. Podman sin root funciona así, y Docker también admite un modo sin root. Podman no tiene un demonio central; cada contenedor lo inicia el propio proceso del usuario. Las contrapartidas: un contenedor sin root no puede hacer cosas que requieren root real, como enlazar puertos por debajo de 1024 por defecto, cargar módulos del kernel o cambiar la red del anfitrión, y su red pasa por un ayudante en espacio de usuario (como `pasta` o `slirp4netns`), que es más lento que una configuración de red con root.

Los **límites de recursos** protegen al anfitrión y a los vecinos de un contenedor descontrolado. En Podman y Docker son opciones de `run`:

| Opción | Establece |
|---|---|
| `--memory 64m` | `memory.max` (Podman también fija `memory.swap.max` al mismo valor) |
| `--cpus 0.5` | `cpu.max` (cuota 50000 por periodo de 100000) |
| `--pids-limit 100` | `pids.max` |

Un contenedor detenido por el OOM killer termina con el **código de salida 137**, que es 128 más la señal 9 (`SIGKILL`). El código de salida 137 por sí solo no prueba un evento de falta de memoria: cualquier `SIGKILL` lo produce, por ejemplo cuando `stop` agota el tiempo y el motor mata el contenedor. Para diagnosticarlo:
1. Consulta el motor: `podman inspect <nombre> --format '{{.State.OOMKilled}}'` es `true` cuando actuó el OOM killer del cgroup.
2. Consulta el log del kernel (`journalctl -k` o `dmesg`) para ver la línea `Memory cgroup out of memory: Killed process ...`.
3. Consulta el `memory.events` del cgroup: el contador `oom_kill`.
4. Arréglalo: averigua por qué el proceso necesita tanta memoria (una fuga, una caché grande o una mala estimación de tamaño) y luego corrige el código o sube el límite. Un límite demasiado bajo para la carga real solo convierte la lentitud en caídas.

> [!CHECK]
> Un contenedor terminó con el código 137. `podman inspect` muestra `OOMKilled=false`. ¿Cuál es la explicación más probable?
>
> - [ ] El contenedor usó demasiada CPU y fue limitado hasta morir
> - [ ] El kernel usa siempre 137 cuando un contenedor termina con normalidad
> - [x] Algún proceso le envió `SIGKILL` por otro motivo, por ejemplo el motor tras agotarse el tiempo de un stop
> - [ ] La imagen tiene demasiadas capas
>
> El código de salida 137 significa «terminado por la señal 9». El OOM killer es solo uno de los posibles remitentes. `OOMKilled=false` te dice que no lo hizo el cgroup de memoria. Los límites de CPU limitan, nunca matan.

## Cómo funciona
Esto es lo que ocurre cuando escribes `podman run --memory 64m alpine:3.20.10 sleep 3600` como usuario normal:

1. **Resolver la imagen.** El motor busca `alpine:3.20.10` en el almacén local. Si no está, pide al registro (especificación de distribución) el manifiesto y después descarga la configuración y cada capa por digest, omitiendo las que ya tiene, y comprueba cada digest.
2. **Desempaquetar las capas.** El runtime apila las capas con overlayfs y añade una nueva capa escribible vacía.
3. **Escribir la configuración de runtime.** El motor produce un `config.json` de runtime OCI: el comando, los namespaces que crear, los límites de cgroup (`memory.max` = 67108864), los montajes y las capabilities que descartar.
4. **Crear el proceso aislado.** Un runtime de bajo nivel (`crun` o `runc`) crea los namespaces, coloca el proceso en un nuevo directorio de cgroup bajo `/sys/fs/cgroup`, aplica los límites, cambia el sistema de archivos raíz, descarta privilegios y hace `exec` de `sleep 3600`. En modo sin root, un namespace user va primero, de modo que los pasos posteriores están permitidos sin root real.
5. **Ejecutar.** A partir de ahora, `sleep` es un proceso normal, planificado por el kernel del anfitrión. Es el PID 1 en su propio namespace pid y tiene un PID normal en el anfitrión.
6. **Detener.** Cuando el proceso termina, el runtime elimina los namespaces y el cgroup. Cuando se elimina el contenedor, se borra su capa escribible; la imagen permanece en el almacén.

El arranque de una VM, en cambio, tiene que iniciar el hardware virtual del hipervisor, ejecutar el firmware, arrancar un kernel entero e iniciar los servicios del sistema antes de que tu aplicación siquiera empiece. Esa es la diferencia en el tiempo de arranque que viste en la tabla.

## Ejemplo práctico
Primero, comprueba si tu CPU admite la virtualización por hardware y si Linux expone el dispositivo KVM (salida de una máquina AMD; una máquina Intel muestra `vmx` y `VT-x`):

```bash
grep -o -m1 -w -E 'vmx|svm' /proc/cpuinfo
lscpu | grep -i virtualization
ls -l /dev/kvm
```

```text
svm
Virtualization:                          AMD-V
crw-rw-rw-. 1 root kvm 10, 232 Nov  7 19:11 /dev/kvm
```

Si `grep` no imprime nada, o bien la CPU carece de las extensiones o están desactivadas en el firmware; dentro de una VM, el anfitrión debe habilitar la virtualización anidada.

Ahora, ¿cómo se convierten los límites que pasas a `podman run` en valores de cgroup?

| Pides | El kernel almacena | Cálculo |
|---|---|---|
| `--memory 64m` | `memory.max` = `67108864` | 64 × 1024 × 1024 bytes |
| `--cpus 0.5` | `cpu.max` = `50000 100000` | 0.5 × periodo de 100 000 µs = 50 000 µs de CPU por periodo |
| `--pids-limit 20` | `pids.max` = `20` | el número tal cual |

Por último, un diagnóstico. Un equipo ejecuta un contenedor con `--memory 64m` que construye en memoria una cadena de 200 MB. Muere al cabo de aproximadamente un segundo:

```text
$ podman inspect report-job --format 'OOMKilled={{.State.OOMKilled}} ExitCode={{.State.ExitCode}}'
OOMKilled=true ExitCode=137
```

```text
kernel: Memory cgroup out of memory: Killed process 18629 (sh) total-vm:136808kB, anon-rss:60812kB ...
```

`OOMKilled=true` más la línea del log del kernel prueban que la causa fue el límite de memoria: el proceso tenía unos 60 MB residentes cuando alcanzó el límite de 64 MB (que también cuenta algo de memoria del kernel). La solución es procesar los datos en flujo en lugar de retenerlos todos o, si de verdad se necesitan 200 MB, subir el límite (por ejemplo `--memory 512m`) *y* comprobar que el anfitrión tiene esa memoria que dar. Reproduces este mismo caso en el laboratorio.

## Errores comunes
- **Tratar un contenedor como una VM pequeña.** Un contenedor es un proceso con una vista restringida. No tiene kernel propio: `uname -r` dentro muestra el kernel del anfitrión, y una vulnerabilidad del kernel afecta a todos los contenedores del anfitrión.
- **Usar `latest` o una etiqueta corta.** `alpine` y `latest` cambian bajo tus pies, y una reconstrucción el mes que viene puede dar una imagen distinta. Fija una etiqueta de versión exacta, o un digest.
- **Guardar datos en la capa escribible.** Desaparece con el contenedor. Usa un volumen para los datos que deban sobrevivir.
- **Olvidar que el código de salida 137 no es un diagnóstico.** Significa «SIGKILL»; confirma la falta de memoria con `OOMKilled` y el log del kernel antes de cambiar nada.
- **No establecer límites.** Un contenedor sin `--memory` puede usar toda la memoria del anfitrión, y entonces el OOM killer puede elegir un proceso que pertenece a otro.
- **Leer los «límites» de CPU como reservas.** `--cpus 0.5` pone un tope al contenedor; no le garantiza media CPU cuando el anfitrión está ocupado. Usa pesos (o las solicitudes del planificador en un orquestador) para tener garantías.
- **Ejecutar como root dentro del contenedor «porque funciona».** Añade un `USER` sin privilegios en la imagen y descarta lo que la aplicación no necesita.

## Consideraciones de seguridad
La virtualización y los contenedores son herramientas de aislamiento, y cada una tiene una superficie de ataque distinta. **NIST SP 800-125** trata la seguridad de la virtualización completa (hipervisores, invitados y gestión), y **NIST SP 800-190**, la Application Container Security Guide, trata los contenedores. Esta sección sigue la estructura de SP 800-190: imágenes, registros, orquestadores, contenedores y el SO anfitrión.

**Fortaleza del aislamiento.** Un escape de VM (un invitado que sale a través de un fallo del hipervisor) es raro y grave, porque el hipervisor es una interfaz pequeña y bien probada. Un escape de contenedor tiene un objetivo mayor: toda la interfaz del kernel que comparten todos los contenedores. Fallos del kernel y del runtime, como el fallo de `runc` CVE-2019-5736, han permitido que un contenedor sobrescriba el runtime del anfitrión. Para cargas de trabajo de distintos inquilinos que no confían entre sí, usa VM o microVM, o rodea los contenedores con runtimes con sandbox.

**Imágenes.** Los riesgos de SP 800-190 empiezan aquí:
- *Vulnerabilidades en la imagen.* Una imagen empaqueta una capa de SO y librerías que envejecen. Reconstruye con regularidad, analiza las imágenes con un escáner de vulnerabilidades y mantenlas pequeñas (una imagen base mínima tiene menos paquetes que parchear).
- *Secretos incrustados.* Las contraseñas, los tokens y las claves copiados en una capa permanecen en ella para siempre, aunque una capa posterior borre el archivo. Pasa los secretos en tiempo de ejecución mediante un mecanismo de secretos.
- *Imágenes no fiables o manipuladas.* Usa imágenes de fuentes en las que confíes, fija versiones o digests y verifica las firmas (por ejemplo con `cosign` de Sigstore) donde tu registro lo admita.

**Registros.** Usa TLS en todas las conexiones, exige autenticación, restringe quién puede subir imágenes y elimina las imágenes obsoletas que mantienen disponibles vulnerabilidades antiguas.

**Contenedores y anfitrión.** Los valores por defecto del runtime ya ayudan: un conjunto restringido de capabilities de Linux, un perfil seccomp por defecto (un filtro de llamadas al sistema) y, en sistemas de la familia Fedora y de la familia Debian, perfiles de SELinux o AppArmor. No los desactives sin un motivo de peso:
- Evita `--privileged`: elimina casi todo el aislamiento. Evita `--cap-add` más allá del mínimo.
- No montes nunca el socket del motor (`/var/run/docker.sock`) en un contenedor: quien lo controla controla el anfitrión.
- No montes en un contenedor las rutas sensibles del anfitrión (`/`, `/etc`, `/proc`), y monta los volúmenes de solo lectura cuando puedas (`:ro`). Usa `--read-only` para el sistema de archivos raíz cuando la aplicación lo permita.
- Prefiere motores **sin root** y un `USER` sin privilegios en la imagen: así, incluso un escape con éxito aterriza como un usuario normal.
- Establece límites de memoria, CPU y PID para que un contenedor no deje sin recursos a los demás.
- Ejecuta un SO anfitrión mínimo, parcheado con regularidad y dedicado a contenedores, porque todos los contenedores comparten su kernel.

**Red.** Los contenedores pueden comunicarse entre sí y con la red por defecto. Publica solo los puertos que necesites y enlaza a `127.0.0.1` cuando un servicio sea de uso local.

> [!IMPORTANT]
> El laboratorio ejecuta solo contenedores que inicias tú mismo, en tu propia máquina, con nombres que empiezan por `lab-virt-`, sin root y sin `--privileged`. No practiques técnicas de escape en anfitriones compartidos ni en ningún sistema que no sea tuyo.

## Resumen
- La virtualización por hardware ejecuta sistemas operativos invitados completos en un anfitrión; el hipervisor comparte y aísla el hardware, y las extensiones de la CPU (Intel VT-x, AMD-V) la hacen rápida. Los hipervisores de tipo 1 se ejecutan sobre el hardware, los de tipo 2 sobre un SO anfitrión.
- Una VM virtualiza el hardware y tiene su propio kernel: aislamiento fuerte, arranque más lento, más sobrecarga. Un contenedor virtualiza la vista del SO y comparte el kernel del anfitrión: rápido y denso, pero tan aislado como lo esté ese kernel.
- Los namespaces (pid, net, mnt, uts, ipc, user, cgroup) deciden lo que un contenedor puede ver; los cgroups v2 (`memory.max`, `cpu.max`, `pids.max`) deciden lo que puede usar. Un contenedor es un proceso normal dentro de ambos.
- Una imagen es una pila de capas de solo lectura direccionables por contenido más una configuración; un contenedor añade una capa escribible copy-on-write. OCI estandariza los formatos de imagen, runtime y distribución. Las etiquetas pueden moverse, los digests no.
- Superar el límite de memoria activa el OOM killer (código de salida 137, `OOMKilled=true`); superar el límite de CPU solo la limita. Ejecuta sin root, establece límites y sigue NIST SP 800-190.

## Glosario
| Término | Definición |
|---|---|
| Virtualización | Ejecutar varios ordenadores virtuales aislados en un único ordenador físico. |
| Anfitrión (host) | La máquina física (o el SO que hay en ella) que ejecuta invitados o contenedores. |
| Invitado (guest) | Una máquina virtual y el sistema operativo que se ejecuta en ella. |
| Máquina virtual (VM) | Un ordenador definido por software con CPU virtuales, memoria, discos y tarjetas de red, que ejecuta su propio SO y kernel. |
| Hipervisor | Software que crea y ejecuta VM y comparte y aísla el hardware entre ellas; también llamado monitor de máquinas virtuales (VMM). |
| Hipervisor de tipo 1 | Un hipervisor que se ejecuta directamente sobre el hardware (bare metal), por ejemplo KVM, Xen, ESXi, Hyper-V. |
| Hipervisor de tipo 2 | Un hipervisor que se ejecuta como aplicación sobre un SO anfitrión, por ejemplo VirtualBox, VMware Workstation. |
| Intel VT-x, AMD-V | Extensiones de la CPU para la virtualización asistida por hardware; indicadores `vmx` y `svm`. |
| VM exit | El momento en que la CPU deja de ejecutar un invitado y devuelve el control al hipervisor. |
| EPT, NPT | Soporte de hardware de Intel y AMD para traducir las direcciones de memoria del invitado a las reales (traducción de direcciones de segundo nivel). |
| IOMMU | Hardware que controla y traduce el acceso de los dispositivos a la memoria, usado para dar a un invitado acceso directo y seguro a un dispositivo (Intel VT-d, AMD-Vi). |
| Paravirtualización | Controladores de invitado hechos para hardware virtual (por ejemplo virtio) que son más rápidos que fingir ser dispositivos reales. |
| Kernel | El núcleo de un sistema operativo, que gestiona el hardware, los procesos y la memoria. |
| Contenedor | Un proceso, o grupo de procesos, que se ejecuta en el kernel del anfitrión con sus propios namespaces, cgroup y sistema de archivos raíz. |
| Namespace | Una función del kernel que da a los procesos una vista privada de un recurso (pid, net, mnt, uts, ipc, user, cgroup, time). |
| Grupo de control (cgroup) | Una función del kernel que agrupa procesos y limita o contabiliza los recursos que usan. |
| cgroups v2 | El diseño actual de cgroups, con una jerarquía unificada en `/sys/fs/cgroup` y un archivo de control por cada ajuste. |
| Controlador | Un componente de cgroup que gestiona un recurso: memory, cpu, io, pids. |
| Throttling (limitación) | Pausar un cgroup que ha agotado su cuota de CPU hasta el siguiente periodo. |
| OOM killer | La función del kernel que mata un proceso cuando se agota la memoria, o cuando un cgroup de memoria alcanza `memory.max` y no puede recuperar memoria. |
| Código de salida 137 | 128 + 9: el proceso fue terminado por `SIGKILL`; con `OOMKilled=true` fue el OOM killer. |
| Imagen | Un paquete de solo lectura con un sistema de archivos raíz y metadatos, usado como plantilla para iniciar contenedores. |
| Capa | Un archivo direccionable por contenido con los archivos que cambió un paso de construcción; las capas se apilan para formar una imagen. |
| Containerfile (Dockerfile) | Un archivo de texto con los pasos de construcción de una imagen. |
| Digest | El hash SHA-256 de un manifiesto o una capa (`sha256:…`); identifica un contenido exacto. |
| Etiqueta (tag) | Una marca móvil y cómoda para las personas de una versión de imagen, como `3.20.10` o `latest`. |
| Copy-on-write | Cambiar un archivo de una capa inferior de solo lectura copiándolo antes a la capa escribible. |
| overlayfs | El sistema de archivos de unión que apila las capas de la imagen y una capa escribible en una sola vista. |
| Volumen | Almacenamiento fuera de la capa escribible del contenedor que sobrevive al contenedor. |
| Registro (registry) | Un servidor que almacena y distribuye imágenes (por ejemplo Docker Hub, Quay.io). |
| Open Container Initiative (OCI) | El proyecto neutral respecto a los proveedores que define las especificaciones de imagen, runtime y distribución. |
| runc, crun | Runtimes OCI de bajo nivel que crean los namespaces y los cgroups e inician el proceso del contenedor. |
| Contenedor sin root (rootless) | Un contenedor ejecutado por un usuario normal, con un namespace user que asigna el root del contenedor a un usuario sin privilegios del anfitrión. |
| Capability | Una de las piezas de grano fino del poder de root en Linux, que un contenedor puede conservar o descartar. |
| seccomp | Un filtro del kernel que restringe qué llamadas al sistema puede usar un proceso. |
| microVM | Una VM muy pequeña y de arranque rápido usada para aislar una única carga de trabajo (por ejemplo Firecracker). |

## Comprueba lo que has aprendido
1. Explica con tus propias palabras por qué una VM arranca en segundos o minutos y un contenedor en milisegundos. ¿Qué tiene que iniciar cada uno?
2. Un compañero dice «los contenedores son solo VM ligeras». Da dos cosas que son diferentes, una sobre el kernel y otra sobre la seguridad.
3. Dos contenedores ejecutan la misma imagen. El contenedor A escribe un archivo de 50 MB dentro de su propio sistema de archivos. ¿Lo ve el contenedor B? ¿Dónde vive el archivo y cuándo se borra?
4. Tu `Containerfile` empieza por `FROM python`. Da dos maneras en que esto puede romper una construcción que funcionaba el mes pasado, y reescribe la línea para evitar ambas.
5. Un contenedor se inicia con `--memory 128m --cpus 1`. ¿Qué valores de `memory.max` y `cpu.max` esperas en los archivos del cgroup? ¿Qué ocurre cuando necesita 200 MB de memoria? ¿Y cuando necesita dos CPU?
6. Un contenedor de base de datos termina con el código 137. Enumera los pasos que sigues para averiguar si se quedó sin memoria y nombra dos posibles soluciones.
7. Un equipo quiere ejecutar código de distintos clientes en el mismo servidor. Compara VM, contenedores y contenedores con sandbox para ello, e indica qué controles de NIST SP 800-190 exigirías.

## Referencias
- [NIST SP 800-125](https://csrc.nist.gov/pubs/sp/800/125/final) — Guide to Security for Full Virtualization Technologies.
- [NIST SP 800-190](https://csrc.nist.gov/pubs/sp/800/190/final) — Application Container Security Guide.
- [OCI Image Format Specification](https://github.com/opencontainers/image-spec).
- [OCI Runtime Specification](https://github.com/opencontainers/runtime-spec).
- [OCI Distribution Specification](https://github.com/opencontainers/distribution-spec).
- [namespaces(7)](https://man7.org/linux/man-pages/man7/namespaces.7.html) — página del manual de Linux.
- [cgroups(7)](https://man7.org/linux/man-pages/man7/cgroups.7.html) — página del manual de Linux.
- [Control Group v2](https://docs.kernel.org/admin-guide/cgroup-v2.html) — documentación del kernel de Linux.
- [Podman documentation](https://docs.podman.io/).
- [CVE-2019-5736](https://nvd.nist.gov/vuln/detail/CVE-2019-5736) — vulnerabilidad de escape de contenedor en runc.
