Mostrando el Markdown sin formato: no se pudo cargar el visor.
## Objetivo
Construirás una pequeña imagen de contenedor a partir de un `Containerfile` con una imagen base fijada e inspeccionarás sus capas. Después la ejecutarás y observarás el contenedor desde el anfitrión: sus procesos, sus namespaces y su cgroup. Por último, fijarás límites de CPU y memoria, los leerás en los archivos del cgroup y provocarás a propósito una eliminación por falta de memoria (OOM, out-of-memory) para poder diagnosticarla.
## Objetivos
- Construir una imagen a partir de un `Containerfile` con una imagen base fijada y explicar sus capas (objetivo 4).
- Demostrar que un contenedor es un proceso normal del anfitrión en sus propios namespaces: comparar nombre de host, lista de procesos e ID de namespace dentro y fuera (objetivo 3).
- Fijar límites `--cpus` y `--memory` y leerlos como `cpu.max` y `memory.max` en los archivos de cgroup v2 (objetivos 3 y 5).
- Provocar una eliminación por OOM y diagnosticarla con `OOMKilled`, el código de salida 137 y el log del kernel (objetivo 5).
## Requisitos previos
- Una máquina Linux, o una VM Linux, con Podman 4 o posterior (probado con Podman 5.8.7, sin root, cgroups v2, `crun`, sin `sudo`). Docker sirve con pequeños cambios: consulta la NOTA de más abajo.
- Una shell de usuario (no `root`). Todo lo de este laboratorio se ejecuta sin `sudo`.
- Acceso a Internet para descargar la imagen base `docker.io/library/alpine:3.20.10` (unos 8 MB) y para descargar un paquete pequeño (`procps-ng`) durante la construcción.
- Unos 30 MB de espacio en disco.
- [La lección](lesson.es.md) de este módulo.
> [!WARNING]
> El laboratorio es gratuito y ejecuta solo contenedores que inicias en tu propia máquina, como usuario normal y sin `--privileged`. Todos los contenedores se llaman `lab-virt-...`, y los comandos que eliminan cosas los nombran de forma explícita, así que no tocan tus otros contenedores. Un paso hace que un contenedor use más memoria que su límite a propósito; solo puede perjudicar a ese contenedor, no a tu máquina. El laboratorio no cambia nada en tu sistema fuera de una carpeta (`~/virt-lab`) y una imagen local, ambas eliminadas al final.
> [!NOTE]
> Las salidas de abajo se capturaron en Linux basado en Fedora en noviembre de 2026. Los ID, los PID, los números de namespace, las horas y el nombre de host serán distintos en tu máquina; lo que debes comparar es la estructura y los valores que provienen de tus comandos (como `67108864`).
>
> **Docker:** sustituye `podman` por `docker`; el nombre `Containerfile` sigue siendo válido (`docker build -f Containerfile` si tu versión no lo encuentra). Dos diferencias: con el Docker por defecto, que se ejecuta como root, los procesos del contenedor pertenecen a `root`, así que leer `/proc/<pid>/ns` y el log de OOM puede requerir `sudo`, y `podman top ... hpid huser` no tiene equivalente en Docker. No se ha probado con Docker.
## Arquitectura
<figure class="diagram" style="--dg-w: 1100px"><svg xmlns="http://www.w3.org/2000/svg" class="dg" viewBox="0 0 1100 560" width="1100" height="560" role="img" aria-labelledby="virt-lab-architecture-es-title virt-lab-architecture-es-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="es">
<title id="virt-lab-architecture-es-title">Arquitectura del laboratorio: un Containerfile, una imagen, tres contenedores sin root y el kernel del anfitrión</title>
<desc id="virt-lab-architecture-es-desc">En tu máquina Linux, con Podman sin root y sin sudo, la carpeta ~/virt-lab contiene un Containerfile y app.sh. Podman los construye en la imagen localhost/lab-virt-hello:1.0, que tiene tres capas y ocupa unos 9.4 MB. La imagen base procede de un registro en Internet, docker.io/library/alpine, etiqueta 3.20.10. La imagen se ejecuta como tres contenedores cuyos nombres empiezan por lab-virt-: lab-virt-demo, que ejecuta sleep 3600 sin límites; lab-virt-limited, con límite de CPU 0.5 y límite de memoria 64 MB; y lab-virt-oom, con un límite de memoria de 64 MB que reserva 200 MB y es eliminado. Los contenedores están aislados y limitados por el kernel Linux del anfitrión, que inspeccionas desde el anfitrión: /proc/<pid>/ns para los namespaces, /sys/fs/cgroup para memory.max, cpu.max y pids.max, y el log del kernel para el OOM killer y el código de salida 137.</desc>
<rect class="dg-bg" x="0.5" y="0.5" width="1099" height="559" rx="16" fill="#ffffff" stroke="#e3e3dd"/>
<g class="dg-l1"><rect class="dg-tint" x="20" y="20" width="230" height="160" rx="16" fill="#f0f6f9" stroke="#9ac3d9" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(36 33) scale(0.7500)" fill="none" stroke="#0369a1" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><path d="M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20"/><path d="M2 12h20"/></g>
<text x="62" y="47" font-size="13" class="dg-ink" fill="#0369a1" font-weight="700">Internet</text></g>
<g class="dg-l2"><rect class="dg-tint" x="280" y="20" width="800" height="520" rx="16" fill="#f1f7f3" stroke="#a1ccb1" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(296 33) scale(0.7500)" fill="none" stroke="#15803d" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20 16V7a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v9m16 0H4m16 0 1.28 2.55a1 1 0 0 1-.9 1.45H3.62a1 1 0 0 1-.9-1.45L4 16"/></g>
<text x="322" y="47" font-size="13" class="dg-ink" fill="#15803d" font-weight="700">Tu máquina Linux: Podman sin root, sin sudo</text></g>
<g class="dg-l7"><rect class="dg-tint" x="620" y="56" width="440" height="298" rx="16" fill="#f6f2fd" stroke="#c5a9f0" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(636 69) scale(0.7500)" fill="none" stroke="#6d28d9" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/></g>
<text x="662" y="83" font-size="13" class="dg-ink" fill="#6d28d9" font-weight="700">Contenedores (nombres que empiezan por lab-virt-)</text></g>
<g class="dg-l4"><rect class="dg-tint" x="296" y="400" width="768" height="124" rx="16" fill="#fbf4f0" stroke="#e7b39e" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(312 413) scale(0.7500)" fill="none" stroke="#c2410c" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect width="20" height="8" x="2" y="2" rx="2"/><rect width="20" height="8" x="2" y="14" rx="2"/><path d="M6 6h.01"/><path d="M6 18h.01"/></g>
<text x="338" y="427" font-size="13" class="dg-ink" fill="#c2410c" font-weight="700">Kernel Linux del anfitrión: lo que inspeccionas</text></g>
<rect class="dg-card" x="34" y="64" width="202" height="100" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(50 80) scale(1.2500)" fill="none" stroke="#0369a1" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><ellipse cx="12" cy="5" rx="9" ry="3"/><path d="M3 5V19A9 3 0 0 0 21 19V5"/><path d="M3 12A9 3 0 0 0 21 12"/></g></g>
<g class="dg-l1"><text x="92" y="101" font-size="15" class="dg-ink" fill="#0369a1" font-weight="700">Registro</text></g>
<text x="52" y="132" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">alpine:3.20.10</text>
<text x="52" y="152" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">docker.io/library</text>
<rect class="dg-card" x="310" y="64" width="250" height="104" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(326 80) scale(1.2500)" fill="none" stroke="#0369a1" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/></g></g>
<g class="dg-l1"><text x="368" y="101" font-size="15" class="dg-ink" fill="#0369a1" font-weight="700">Imagen</text></g>
<text x="328" y="132" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">localhost/lab-virt-hello:1.0</text>
<text x="328" y="152" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">3 capas · unos 9.4 MB</text>
<rect class="dg-card" x="310" y="240" width="250" height="104" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(326 256) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"/><path d="M14 2v4a2 2 0 0 0 2 2h4"/><path d="M10 9H8"/><path d="M16 13H8"/><path d="M16 17H8"/></g>
<text x="368" y="277" font-size="15" class="dg-text" fill="#17171c" font-weight="700">~/virt-lab</text>
<text x="328" y="308" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">Containerfile</text>
<text x="328" y="328" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">app.sh</text>
<rect class="dg-card" x="636" y="92" width="408" height="76" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l7"><g class="dg-icon" transform="translate(652 108) scale(1.2500)" fill="none" stroke="#6d28d9" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/></g></g>
<g class="dg-l7"><text x="694" y="129" font-size="15" class="dg-ink" fill="#6d28d9" font-weight="700">lab-virt-demo</text></g>
<text x="654" y="160" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">sleep 3600 · sin límites</text>
<rect class="dg-card" x="636" y="178" width="408" height="76" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l7"><g class="dg-icon" transform="translate(652 194) scale(1.2500)" fill="none" stroke="#6d28d9" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/></g></g>
<g class="dg-l7"><text x="694" y="215" font-size="15" class="dg-ink" fill="#6d28d9" font-weight="700">lab-virt-limited</text></g>
<text x="654" y="246" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">--cpus 0.5 --memory 64m</text>
<rect class="dg-card" x="636" y="264" width="408" height="76" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-warn"><g class="dg-icon" transform="translate(652 280) scale(1.2500)" fill="none" stroke="#b91c1c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/></g></g>
<g class="dg-warn"><text x="694" y="301" font-size="15" class="dg-ink" fill="#b91c1c" font-weight="700">lab-virt-oom</text></g>
<text x="654" y="332" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">--memory 64m · reserva 200 MB</text>
<rect class="dg-card" x="312" y="436" width="230" height="76" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l4"><g class="dg-icon" transform="translate(328 452) scale(1.2500)" fill="none" stroke="#c2410c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M8 6h13"/><path d="M8 12h13"/><path d="M8 18h13"/><path d="M3 6h.01"/><path d="M3 12h.01"/><path d="M3 18h.01"/></g></g>
<g class="dg-l4"><text x="370" y="473" font-size="14" class="dg-ink" fill="#c2410c" font-weight="700">/proc/<pid>/ns</text></g>
<text x="330" y="504" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">namespaces vistos del anfitrión</text>
<rect class="dg-card" x="558" y="436" width="230" height="76" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l4"><g class="dg-icon" transform="translate(574 452) scale(1.2500)" fill="none" stroke="#c2410c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M8 6h13"/><path d="M8 12h13"/><path d="M8 18h13"/><path d="M3 6h.01"/><path d="M3 12h.01"/><path d="M3 18h.01"/></g></g>
<g class="dg-l4"><text x="616" y="473" font-size="14" class="dg-ink" fill="#c2410c" font-weight="700">/sys/fs/cgroup/…</text></g>
<text x="576" y="504" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">memory.max · cpu.max</text>
<rect class="dg-card" x="804" y="436" width="230" height="76" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-warn"><g class="dg-icon" transform="translate(820 452) scale(1.2500)" fill="none" stroke="#b91c1c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3"/><path d="M12 9v4"/><path d="M12 17h.01"/></g></g>
<g class="dg-warn"><text x="862" y="473" font-size="14" class="dg-ink" fill="#b91c1c" font-weight="700">Log del kernel</text></g>
<text x="822" y="504" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">OOM killer: código de salida 137</text>
<g class="dg-l1"><path class="dg-stroke" d="M238 116H300" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><path class="dg-stroke" d="M293 110l8 6-8 6" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><rect class="dg-bg-plain" x="247.12" y="104" width="43.76" height="24" rx="12" fill="#ffffff"/><text x="269" y="120.5" font-size="11.5" class="dg-ink" fill="#0369a1" font-weight="600" text-anchor="middle">pull</text></g>
<g class="dg-l1"><path class="dg-stroke" d="M435 238V172" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><path class="dg-stroke" d="M429 179l6-8 6 8" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><rect class="dg-bg-plain" x="409.9" y="193" width="50.2" height="24" rx="12" fill="#ffffff"/><text x="435" y="209.5" font-size="11.5" class="dg-ink" fill="#0369a1" font-weight="600" text-anchor="middle">build</text></g>
<g class="dg-l7"><path class="dg-stroke" d="M562 116H610" stroke="#6d28d9" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l7"><path class="dg-stroke" d="M605 110l8 6-8 6" stroke="#6d28d9" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l7"><rect class="dg-bg-plain" x="568.34" y="104" width="37.32" height="24" rx="12" fill="#ffffff"/><text x="587" y="120.5" font-size="11.5" class="dg-ink" fill="#6d28d9" font-weight="600" text-anchor="middle">run</text></g>
<g class="dg-l4"><path class="dg-stroke" d="M840 358V392" stroke="#c2410c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l4"><path class="dg-stroke" d="M834 387l6 8 6-8" stroke="#c2410c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l4"><rect class="dg-bg-plain" x="753.72" y="364" width="172.56" height="24" rx="12" fill="#ffffff"/><text x="840" y="380.5" font-size="11.5" class="dg-ink" fill="#c2410c" font-weight="600" text-anchor="middle">aislados y limitados por</text></g>
</svg></figure>
*Figura 1. Construyes una imagen a partir de una carpeta, la ejecutas como tres contenedores y lees lo que hizo el kernel del anfitrión para aislarlos y limitarlos.*
## Pasos
### Paso 1 — Comprueba tus herramientas y crea una carpeta de trabajo
Primero, comprueba que tienes Podman, que funciona sin root y que tu sistema usa cgroups v2. Guardas todos los archivos del laboratorio en una carpeta para que la limpieza sea sencilla.
```bash
podman --version
podman info --format 'rootless={{.Host.Security.Rootless}} cgroups={{.Host.CgroupsVersion}} runtime={{.Host.OCIRuntime.Name}}'
stat -fc %T /sys/fs/cgroup
mkdir -p ~/virt-lab && cd ~/virt-lab
```
Salida esperada (la versión puede ser más reciente; el runtime puede ser `runc`):
```text
podman version 5.8.7
rootless=true cgroups=v2 runtime=crun
cgroup2fs
```
`cgroup2fs` significa que el sistema de archivos cgroup v2 está montado en `/sys/fs/cgroup`. Si ves `tmpfs`, tu sistema usa cgroups v1 y los pasos de límites no coincidirán; consulta Resolución de problemas.
> [!WARNING]
> Ejecuta todos los comandos siguientes desde `~/virt-lab`, salvo que un paso indique lo contrario.
### Paso 2 — Escribe la aplicación y el Containerfile
La aplicación es un pequeño script de shell. El `Containerfile` enumera los pasos de construcción; cada paso que cambia archivos añade una capa. Fija la imagen base a una etiqueta de versión exacta (`3.20.10`), no a `latest`, para que la construcción sea repetible.
```bash
cat > app.sh <<'EOF'
#!/bin/sh
echo "Hello from $(hostname), running as $(id -un) (PID $$)"
EOF
chmod +x app.sh
cat > Containerfile <<'EOF'
FROM docker.io/library/alpine:3.20.10
LABEL org.opencontainers.image.title="lab-virt-hello"
RUN apk add --no-cache procps-ng
COPY app.sh /usr/local/bin/app.sh
CMD ["/usr/local/bin/app.sh"]
EOF
```
Qué hace cada línea:
- `FROM` elige la imagen base y sus capas.
- `LABEL` añade metadatos a la configuración de la imagen (sin capa nueva).
- `RUN` ejecuta un comando en un contenedor temporal y conserva los cambios en los archivos como una capa nueva.
- `COPY` añade un archivo de tu carpeta como una capa nueva.
- `CMD` fija el comando por defecto (solo metadatos).
> [!NOTE]
> La línea `RUN` está ahí para dar a la imagen una capa que puedas ver. Para ella hace falta acceso a la red durante la construcción.
### Paso 3 — Construye la imagen
```bash
podman build -t lab-virt-hello:1.0 .
```
`-t` da a la imagen el nombre `lab-virt-hello` con la etiqueta `1.0`, y `.` es el contexto de construcción (esta carpeta).
Salida esperada (los ID serán distintos; las líneas de descarga de `apk` están recortadas):
```text
STEP 1/5: FROM docker.io/library/alpine:3.20.10
STEP 2/5: LABEL org.opencontainers.image.title="lab-virt-hello"
--> b1be2b84c186
STEP 3/5: RUN apk add --no-cache procps-ng
Executing busybox-1.36.1-r31.trigger
OK: 9 MiB in 19 packages
--> c76c408b748b
STEP 4/5: COPY app.sh /usr/local/bin/app.sh
--> 964fed8bd61c
STEP 5/5: CMD ["/usr/local/bin/app.sh"]
COMMIT lab-virt-hello:1.0
--> de5c993d6a99
Successfully tagged localhost/lab-virt-hello:1.0
de5c993d6a996bcc2d734c27e4290c4d4d80a12865dc8c7833be391f7e51feb6
```
La primera vez, Podman también imprime `Trying to pull docker.io/library/alpine:3.20.10...` y las líneas de descarga de los blobs. Comprueba la imagen:
```bash
podman images lab-virt-hello
```
```text
REPOSITORY TAG IMAGE ID CREATED SIZE
localhost/lab-virt-hello 1.0 de5c993d6a99 Less than a second ago 9.37 MB
```
### Paso 4 — Inspecciona las capas
`podman history` enumera una línea por instrucción de construcción, con el tamaño de la capa que añadió.
```bash
podman history lab-virt-hello:1.0
```
Salida esperada (recortada para que quepa; las horas y los ID serán distintos):
```text
ID CREATED CREATED BY SIZE COMMENT
964fed8bd61c Less than a second ago /bin/sh -c #(nop) CMD ["/usr/local/bin/app... 0B
<missing> Less than a second ago /bin/sh -c #(nop) COPY file:23760a3ecceb3e... 3.58kB
c76c408b748b Less than a second ago /bin/sh -c apk add --no-cache procps-ng 1.27MB
bf8527eb54c3 1 second ago /bin/sh -c #(nop) LABEL org.opencontainers... 0B FROM docker.i...
<missing> 6 months ago CMD ["/bin/sh"] 0B buildkit.dock...
<missing> 6 months ago ADD alpine-minirootfs-3.20.10-x86_64.tar.g... 8.09MB buildkit.dock...
```
Léela de abajo arriba: el sistema de archivos raíz de la imagen base (8.09 MB), tu `RUN` (1.27 MB), tu `COPY` (3.58 kB). `CMD` y `LABEL` son 0 B: solo cambian la configuración. Ahora pide directamente las capas y el formato:
```bash
podman image inspect lab-virt-hello:1.0 --format 'Layers: {{len .RootFS.Layers}} Cmd: {{.Config.Cmd}} Format: {{.ManifestType}}'
podman image inspect lab-virt-hello:1.0 --format '{{range .RootFS.Layers}}{{println .}}{{end}}'
```
Salida esperada (la primera capa, Alpine, es la misma en tu máquina; las otras dos serán distintas, porque su contenido incluye las horas de construcción):
```text
Layers: 3 Cmd: [/usr/local/bin/app.sh] Format: application/vnd.oci.image.manifest.v1+json
sha256:08bc4e534116aa76b16015484b82eac51f9a593416feae9296c8a2d4bb7aa4a2
sha256:f55ed2bae43c665dab4e7586118f8ad3e837d47e4f580dbc8c6ae63b55ac8f5e
sha256:df259c8f1ca6356b3feac01c6d60efbe8439114afa5442ddbcfba2f5286d92c7
```
Tres capas (la base, `RUN`, `COPY`), cada una nombrada por el digest SHA-256 de su contenido, y una imagen en el formato de imagen OCI (`application/vnd.oci.image.manifest.v1+json`).
> [!NOTE]
> Los digests de arriba son los ID de contenido sin comprimir (`diff_id` en la configuración de la imagen). Los digests de las capas comprimidas del manifiesto, que usa un registro, son valores distintos.
### Paso 5 — Ejecuta el contenedor
Ejecútalo una vez en primer plano. `--rm` borra el contenedor cuando termina, y `--name` sigue la regla `lab-virt-`.
```bash
podman run --rm --name lab-virt-hello lab-virt-hello:1.0
```
Salida esperada (el nombre de host son los 12 primeros caracteres del ID del contenedor, así que el tuyo será distinto):
```text
Hello from 5088d1aeb13f, running as root (PID 1)
```
Fíjate en tres cosas: el nombre de host no es el de tu ordenador (namespace uts), el script es el **PID 1** (namespace pid) y el usuario es `root` (un namespace user, como verás en el Paso 7).
### Paso 6 — Compara la vista del contenedor con la del anfitrión
Esta vez inicia un contenedor que siga en ejecución, para poder mirarlo desde ambos lados.
```bash
podman run -d --name lab-virt-demo lab-virt-hello:1.0 sleep 3600
podman ps --filter name=lab-virt- --format 'table {{.Names}}\t{{.Status}}\t{{.Command}}'
```
Salida esperada (la primera línea es el ID completo del contenedor):
```text
9f26995a174db194e15e4322e83b28bdfb0928df0ed9f5be2a803f0607cc6b50
NAMES STATUS COMMAND
lab-virt-demo Up Less than a second sleep 3600
```
Pide a Podman los procesos del contenedor, con la vista del anfitrión junto a la del contenedor:
```bash
podman top lab-virt-demo user pid hpid huser comm
```
```text
USER PID HPID HUSER COMMAND
root 1 41390 1000 sleep
```
`PID` es el número dentro del contenedor (1); `HPID` es el PID del mismo proceso en el anfitrión (aquí 41390, el tuyo será distinto); `USER` es `root` dentro, y `HUSER` es `1000` en el anfitrión: tu propio ID de usuario. El contenedor «root» eres tú. Ahora compara las vistas con comandos ejecutados dentro y fuera:
```bash
podman exec lab-virt-demo hostname
podman exec lab-virt-demo ps -o pid,user,comm
podman exec lab-virt-demo uname -r
echo "--- host ---"
hostname
uname -r
```
Salida esperada:
```text
9f26995a174d
PID USER COMMAND
1 root sleep
3 root ps
7.2.4-ogc3.1.fc44.x86_64
--- host ---
bazzite
7.2.4-ogc3.1.fc44.x86_64
```
Dentro ves un nombre de host distinto y solo dos procesos (`sleep` como PID 1 y el `ps` que acabas de iniciar), mientras que el anfitrión tiene centenares. Pero `uname -r` imprime **la misma versión del kernel**: no hay kernel invitado, el contenedor comparte el del anfitrión. Esta es la principal diferencia con una VM.
### Paso 7 — Mira los namespaces desde el anfitrión
Cada proceso tiene un enlace por namespace en `/proc/<pid>/ns/`. Dos procesos están en el mismo namespace cuando el número del enlace es el mismo. Compara tu shell con el `sleep` del contenedor, usando su PID del anfitrión:
```bash
PID=$(podman inspect lab-virt-demo --format '{{.State.Pid}}')
echo "container PID on the host: $PID"
for ns in cgroup ipc mnt net pid user uts time; do
printf '%-7s host %-18s container %s\n' $ns "$(readlink /proc/self/ns/$ns)" "$(readlink /proc/$PID/ns/$ns)"
done
```
Salida esperada (los números serán distintos en tu máquina; compáralos por parejas):
```text
container PID on the host: 41390
cgroup host cgroup:[4026531835] container cgroup:[4026533219]
ipc host ipc:[4026531839] container ipc:[4026533217]
mnt host mnt:[4026531832] container mnt:[4026533215]
net host net:[4026531833] container net:[4026533103]
pid host pid:[4026531836] container pid:[4026533218]
user host user:[4026531837] container user:[4026533101]
uts host uts:[4026531838] container uts:[4026533216]
time host time:[4026531834] container time:[4026531834]
```
Siete namespaces son diferentes. El namespace `time` es el mismo: los contenedores no tienen uno propio por defecto. Si tienes `lsns` instalado (paquete `util-linux`), enumera la misma información:
```bash
lsns -p $PID -o NS,TYPE,NPROCS,PID,COMMAND
```
```text
NS TYPE NPROCS PID COMMAND
4026531834 time 153 1853 /usr/bin/mpris-proxy
4026533101 user 16 15774 catatonit -P
4026533103 net 1 41390 sleep 3600
4026533215 mnt 1 41390 sleep 3600
4026533216 uts 1 41390 sleep 3600
4026533217 ipc 1 41390 sleep 3600
4026533218 pid 1 41390 sleep 3600
4026533219 cgroup 1 41390 sleep 3600
```
La primera fila es el namespace `time` que compartes con el anfitrión (el `COMMAND` mostrado es solo el proceso más antiguo que hay en él). La fila `user` tiene más de un proceso: Podman sin root mantiene un único namespace user para todos tus contenedores, sostenido por un pequeño ayudante (`catatonit`).
Ahora, el namespace user. Dentro del contenedor eres el UID 0. ¿Qué usuario cree el anfitrión que eres y cómo se asigna?
```bash
podman exec lab-virt-demo cat /proc/self/uid_map
stat -c 'owner of the host process: %U' /proc/$PID
```
```text
0 1000 1
1 524288 65536
owner of the host process: user
```
Lee cada fila de `uid_map` como `<primer UID dentro> <primer UID fuera> <cuántos>`: el UID 0 del contenedor es el UID 1000 del anfitrión (tú; una cantidad de 1), y los UID 1 a 65536 del contenedor se asignan a un rango de UID reservado para ti en `/etc/subuid`. El proceso en el anfitrión pertenece a tu propio nombre de usuario (`user` aquí; el tuyo será distinto). Un fallo que permitiera al proceso escapar solo encontraría tus derechos, no los de root.
### Paso 8 — Fija límites y léelos en el cgroup
Inicia un segundo contenedor con un límite de media CPU y 64 MB de memoria:
```bash
podman run -d --name lab-virt-limited --cpus 0.5 --memory 64m lab-virt-hello:1.0 sleep 3600
```
El cgroup del contenedor es un directorio bajo `/sys/fs/cgroup`. Encuéntralo a partir del PID del anfitrión y lee los archivos de límites:
```bash
PID=$(podman inspect lab-virt-limited --format '{{.State.Pid}}')
CG=/sys/fs/cgroup$(cut -d: -f3 /proc/$PID/cgroup)
echo "$CG"
for f in memory.max cpu.max pids.max memory.current; do printf '%-15s %s\n' $f "$(cat $CG/$f)"; done
```
Salida esperada (el ID del contenedor en la ruta será distinto, recortado aquí como `<id>`; `memory.current` varía):
```text
/sys/fs/cgroup/user.slice/user-1000.slice/user@1000.service/user.slice/libpod-<id>.scope/container
memory.max 67108864
cpu.max 50000 100000
pids.max 2048
memory.current 741376
```
- `memory.max` es `67108864`: 64 × 1024 × 1024 bytes, de `--memory 64m`.
- `cpu.max` es `50000 100000`: 50 000 µs de tiempo de CPU en cada periodo de 100 000 µs, es decir, 0.5 CPU, de `--cpus 0.5`.
- `pids.max` es un valor por defecto que fija Podman (2048 aquí; el tuyo puede ser distinto).
Compáralo con el contenedor que no tiene límites, `lab-virt-demo`:
```bash
CGD=/sys/fs/cgroup$(cut -d: -f3 /proc/$(podman inspect lab-virt-demo --format '{{.State.Pid}}')/cgroup)
for f in memory.max cpu.max; do printf '%-15s %s\n' $f "$(cat $CGD/$f)"; done
```
```text
memory.max max
cpu.max max 100000
```
`max` significa «sin límite». El contenedor también puede leer sus propios límites, porque tiene su propio namespace cgroup, en el que su cgroup aparece como la raíz:
```bash
podman exec lab-virt-limited cat /sys/fs/cgroup/memory.max /sys/fs/cgroup/cpu.max
podman inspect lab-virt-limited --format 'Memory={{.HostConfig.Memory}} NanoCpus={{.HostConfig.NanoCpus}} CpuQuota={{.HostConfig.CpuQuota}} CpuPeriod={{.HostConfig.CpuPeriod}}'
```
```text
67108864
50000 100000
Memory=67108864 NanoCpus=500000000 CpuQuota=50000 CpuPeriod=100000
```
### Paso 9 — Observa cómo el límite de CPU limita a un contenedor ocupado
Inicia un bucle infinito dentro del contenedor limitado. Sin límite usaría una CPU entera; con `--cpus 0.5` debería obtener aproximadamente la mitad.
```bash
podman exec -d lab-virt-limited sh -c 'while :; do :; done'
sleep 8
podman stats --no-stream --format 'table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}' lab-virt-limited
grep -E 'nr_periods|nr_throttled|throttled_usec' $CG/cpu.stat
```
Salida esperada (los porcentajes y los contadores varían):
```text
NAME CPU % MEM USAGE / LIMIT
lab-virt-limited 48.63% 450.6kB / 67.11MB
nr_periods 83
nr_throttled 78
throttled_usec 3373263
```
El bucle quiere el 100 % de una CPU pero obtiene alrededor del 50 %. `nr_throttled` cuenta los periodos en los que el cgroup agotó su cuota y se pausó hasta el siguiente periodo: casi todos (78 de 83). Superar el límite de CPU significa **más lento**, no eliminado.
Elimina los dos contenedores. `sleep` como PID 1 ignora la señal de parada (`SIGTERM`), así que `-t 0` se salta la espera de 10 segundos:
```bash
podman rm -f -t 0 lab-virt-limited lab-virt-demo
```
```text
lab-virt-demo
lab-virt-limited
```
### Paso 10 — Provoca a propósito una eliminación por OOM
Ahora da 64 MB a un contenedor y pide a su shell que mantenga en memoria una cadena de 200 MB. El comando `head -c 200000000 /dev/zero | tr "\0" a` produce 200 MB de la letra `a`, y la shell los guarda todos en la variable `x`.
```bash
podman run --name lab-virt-oom --memory 64m lab-virt-hello:1.0 \
sh -c 'x=$(head -c 200000000 /dev/zero | tr "\0" a); echo "allocated ${#x} bytes"'
echo "exit code: $?"
```
Salida esperada:
```text
exit code: 137
```
No hay línea «allocated»: la shell fue eliminada antes de poder imprimirla. El nombre no lleva `--rm`, así que puedes inspeccionar el contenedor detenido. El código de salida 137 es 128 + 9, es decir, `SIGKILL`. Pero ¿ha sido el OOM killer? Pregunta al motor:
```bash
podman inspect lab-virt-oom --format 'OOMKilled={{.State.OOMKilled}} ExitCode={{.State.ExitCode}} Status={{.State.Status}}'
```
```text
OOMKilled=true ExitCode=137 Status=exited
```
`OOMKilled=true` confirma que lo detuvo el OOM killer del cgroup de memoria. El log del kernel da los detalles:
```bash
journalctl -k --since "-2min" --no-pager | grep "Memory cgroup out of memory"
```
Salida esperada (abreviada; el PID y los tamaños varían):
```text
nov 07 19:55:34 bazzite kernel: Memory cgroup out of memory: Killed process 43622 (sh) total-vm:136808kB, anon-rss:62252kB, file-rss:904kB, shmem-rss:0kB, UID:1000 pgtables:300kB oom_score_adj:200
```
El proceso usaba unos 62 MB de memoria residente (`anon-rss`) cuando alcanzó el límite de 64 MB, y en ese momento fue eliminado.
> [!NOTE]
> Leer el log del kernel requiere acceso al journal: en muchos sistemas un usuario normal debe pertenecer al grupo `systemd-journal` (o `adm`), o usar `dmesg` si el sistema lo permite (`sysctl kernel.dmesg_restrict` es `0`). Sin acceso, `podman inspect` y el código de salida 137 bastan para completar el laboratorio; la línea del kernel es una confirmación.
> [!NOTE]
> Si el proceso que se queda sin memoria se inicia con `podman exec` en un contenedor cuyo proceso principal está bien, solo se elimina ese proceso lanzado con `exec`: el contenedor sigue en ejecución y `OOMKilled` sigue siendo `false`. El archivo `memory.events` del cgroup lo muestra de todos modos, como un contador `oom_kill 1`. Cuando diagnostiques un reinicio o una eliminación, mira `memory.events` además de `OOMKilled`.
Ahora arréglalo. El trabajo necesita unos 200 MB, así que sube el límite a 512 MB. Esta vez, usa `--rm`:
```bash
podman rm lab-virt-oom
podman run --rm --name lab-virt-oom --memory 512m lab-virt-hello:1.0 \
sh -c 'x=$(head -c 200000000 /dev/zero | tr "\0" a); echo "allocated ${#x} bytes"'
echo "exit code: $?"
```
```text
lab-virt-oom
allocated 200000000 bytes
exit code: 0
```
El mismo comando funciona cuando el límite se ajusta a la necesidad real. La primera línea es la salida de `podman rm`, que imprime el nombre del contenedor eliminado.
## Verificación
Comprueba cada resultado. Todo lo siguiente debe ser cierto:
- `podman history lab-virt-hello:1.0` muestra una capa base de unos 8 MB, una capa `RUN` de aproximadamente 1 MB y una capa `COPY` de unos pocos kB; `CMD` y `LABEL` muestran `0B`.
- Dentro de un contenedor, `hostname` difiere del del anfitrión, `ps` muestra `sleep` como PID 1 y `uname -r` es igual a la versión del kernel del anfitrión.
- `readlink /proc/<pid>/ns/...` da números distintos para `cgroup`, `ipc`, `mnt`, `net`, `pid`, `user` y `uts`, y el mismo número para `time`.
- `memory.max` es `67108864` y `cpu.max` es `50000 100000` en `lab-virt-limited`.
- La ejecución con OOM termina con `OOMKilled=true` y el código de salida 137, y el reintento con `--memory 512m` termina con `allocated 200000000 bytes`.
Autocomprobación rápida:
```bash
podman ps -a --filter name=lab-virt- --format '{{.Names}} {{.Status}}'
```
Tras el Paso 10 esto no imprime nada, porque el último contenedor usó `--rm` y los anteriores se eliminaron.
## Resolución de problemas
| Síntoma | Causa probable | Solución |
|---|---|---|
| `stat -fc %T /sys/fs/cgroup` imprime `tmpfs` | El sistema usa cgroups v1, donde los límites sin root no están admitidos | Usa una distribución con cgroups v2 (Fedora, Ubuntu 22.04 o posterior, Debian 11 o posterior) o una VM. Podman avisa: `Resource limits are not supported and ignored on cgroups V1 rootless systems`. |
| `podman run --cpus 0.5` falla o el archivo `cpu.max` se queda en `max` | El controlador `cpu` no está delegado a tu usuario | Ejecuta `cat /sys/fs/cgroup/user.slice/user-$(id -u).slice/user@$(id -u).service/cgroup.controllers`; debería enumerar `cpu`, `memory` y `pids`. En sistemas más antiguos, un administrador debe habilitar la delegación (un drop-in de systemd con `Delegate=cpu cpuset io memory pids`). |
| `Error: pulling image ... connection refused` o tiempo de espera agotado | Sin Internet o con un proxy | Define la variable `HTTPS_PROXY`, o descarga de un registro al que llegues y cambia la línea `FROM`. |
| `apk add` falla durante la construcción | El contenedor no tiene DNS ni red | Comprueba que funciona `podman run --rm docker.io/library/alpine:3.20.10 nslookup example.com`; revisa tu firewall y tu VPN. |
| `cannot clone: Operation not permitted` o errores de namespace user | Sin root hacen falta entradas en `/etc/subuid` y `/etc/subgid` y namespaces user sin privilegios | `grep $USER /etc/subuid /etc/subgid`; un administrador puede añadirlas (`usermod --add-subuids ...`). |
| El contenedor se ejecuta pero `OOMKilled` es `false` y el código de salida es 137 | Eliminado por otro motivo (por ejemplo un tiempo de espera de stop), o el límite de memoria no se aplicó | Comprueba `memory.max` en el cgroup; consulta el Paso 10. |
| No hay línea de OOM en `journalctl -k` | Sin permiso para leer el log del kernel, o la entrada es anterior a la ventana de `--since` | Consulta la NOTA del Paso 10; usa `--since "-10min"`. |
| `/proc/<pid>/ns` o la ruta del cgroup no existe | El contenedor ya se detuvo, o el PID está obsoleto | Ejecuta `podman ps` y vuelve a leer el PID. |
| `Error: creating container storage: the container name "lab-virt-oom" is already in use` | Queda un contenedor detenido con ese nombre | `podman rm lab-virt-oom` |
## Reto (opcional)
Úsalos sin instrucciones paso a paso:
1. Inicia un contenedor con `--pids-limit 20` e intenta iniciar más de 20 procesos en él (por ejemplo con un bucle de shell que ejecute `sleep 300 &`). ¿Qué error obtienes y qué archivo y contador del cgroup cambiaron? Elimina el contenedor después.
2. Inicia un contenedor con `--uts=host` y luego con `--pid=host`, y compara `hostname` y `ps` con los valores por defecto. ¿Qué aislamiento quitaste en cada caso? ¿Por qué rara vez querrías hacerlo?
3. Construye la imagen de nuevo con `FROM docker.io/library/alpine:3.20.10@sha256:<digest>` (obtén el digest con `podman image inspect docker.io/library/alpine:3.20.10 --format '{{.Digest}}'`). ¿Qué garantiza el digest que no garantiza la etiqueta?
## Limpieza
Elimina los contenedores (los nombres son explícitos, y `--ignore` omite los que ya no existen), la imagen que construiste y la carpeta del laboratorio:
```bash
podman rm -f -t 0 --ignore lab-virt-demo lab-virt-limited lab-virt-oom lab-virt-hello
podman rmi lab-virt-hello:1.0
cd ~ && rm -r ~/virt-lab
```
Salida esperada (los ID serán distintos; el primer comando imprime el nombre de cada contenedor que elimina, y nada si no queda ninguno):
```text
Untagged: localhost/lab-virt-hello:1.0
Deleted: de5c993d6a996bcc2d734c27e4290c4d4d80a12865dc8c7833be391f7e51feb6
Deleted: 964fed8bd61ca0b105dcbf80de33b5c8eb7bab12ab5f96fa46d4d98e2830587a
Deleted: c76c408b748b1e099ea7e4d5e1350499b7d405187fe91f6d497e686e4688fba6
Deleted: b1be2b84c1863941b122d42738aeef7356b81e3f2704e6db0b2faa6f099e28f3
```
Si descargaste la imagen base solo para este laboratorio, elimínala también. Sáltate esto si usas Alpine 3.20.10 para otra cosa; Podman se niega a eliminar una imagen que un contenedor aún usa:
```bash
podman rmi docker.io/library/alpine:3.20.10
```
Comprueba que no queda nada:
```bash
podman ps -a --filter name=lab-virt-
podman images lab-virt-hello
ls ~/virt-lab
```
Los dos primeros comandos imprimen solo sus líneas de cabecera (o nada), y `ls` indica que la carpeta no existe.
## Qué has aprendido
- Un `Containerfile` se convierte en una imagen OCI formada por capas: cada `RUN` y `COPY` añade una, y `CMD` y `LABEL` solo añaden metadatos. Fijar la imagen base a una etiqueta exacta mantiene las construcciones repetibles.
- Un contenedor es un proceso normal del anfitrión: `podman top` muestra su PID del anfitrión, `/proc/<pid>/ns` muestra que está en sus propios namespaces pid, net, mnt, uts, ipc, user y cgroup, y `uname -r` muestra que comparte el kernel del anfitrión.
- En un contenedor sin root, el root de dentro es tu propio usuario sin privilegios de fuera, mediante la asignación del namespace user.
- `--memory` y `--cpus` se convierten en `memory.max` y `cpu.max` en el cgroup del contenedor; superar el límite de CPU limita la velocidad, y superar el límite de memoria invoca al OOM killer.
- El código de salida 137 significa `SIGKILL`; `OOMKilled=true`, la línea del log del kernel y `memory.events` te dicen si lo hizo el OOM killer, y la solución es entender la necesidad real de memoria, no solo subir el límite.