Introducción

Podman rootless en producción dejó de ser una curiosidad técnica y se convirtió en una exigencia práctica en entornos que necesitan cumplir controles de compliance como CIS Benchmarks, PCI-DSS y LGPD. Cuando ejecuto contenedores Docker en un servidor, dockerd necesita un socket privilegiado y cualquier usuario del grupo docker es, en la práctica, root en la máquina. En auditorías internas vi este punto frenar deploys enteros, y la respuesta más limpia que encontré en los últimos dos años fue migrar a Podman ejecutándose sin daemon y sin privilegios.

La tesis de este artículo es directa: Podman rootless reemplaza a Docker en producción sin pérdida funcional en la mayoría de los escenarios web y de workers, siempre que aceptes tres concesiones explícitas — usar systemd (vía Quadlet) en lugar de docker compose, mapear UIDs con subuid/subgid, y tratar redes y volúmenes pensando en namespaces de usuario. A cambio, el servidor pasa a ser auditable: ningún proceso de contenedor se ejecuta como root en el host, el blast radius de una RCE cae drásticamente y la superficie de ataque del daemon simplemente desaparece.

Voy a mostrar cómo pasé de un host Docker tradicional a un host Podman 5.x rootless ejecutando workloads .NET, n8n y Postgres en producción, qué estructura de directorios sobrevivió a tres meses de operación, cómo queda el pipeline de deploy vía SSH y qué trampas cuestan horas si no sabes dónde mirar (puerto 80, linger, networking pasta, SELinux). Todo probado en Ubuntu 24.04 LTS y RHEL 9 con crun como runtime predeterminado.

Requisitos previos

  • Linux con kernel ≥ 5.13 (Ubuntu 22.04+, Debian 12+, RHEL 9+)
  • Podman ≥ 4.4 (para soporte completo de Quadlet); idealmente 5.x
  • Usuario no root con subuid/subgid configurados
  • systemd en modo usuario habilitado (loginctl enable-linger <user>)
  • Conocimientos básicos de Dockerfile y docker compose

Por Qué Rootless No Es “Docker con Otro Nombre”

La confusión más común que encuentro es tratar a Podman como un reemplazo directo de Docker solo porque alias docker=podman funciona. Funciona para run, build y pull, pero el modelo de ejecución es radicalmente diferente.

Docker depende de un daemon (dockerd) que escucha en /var/run/docker.sock ejecutándose como root. Ese daemon es quien ejecuta los contenedores. Si un atacante consigue cualquier escritura en el socket, puede levantar un contenedor --privileged montando el / del host — game over. Por eso CIS Docker Benchmark 1.2.x dedica una sección entera al socket.

Podman es daemonless. Cada podman run es un proceso hijo de tu shell (o de systemd --user). No existe un socket privilegiado por defecto. En modo rootless, el contenedor se ejecuta dentro de un user namespace mapeado vía subuid/subgid: el UID 0 dentro del contenedor es, en realidad, un UID alto y sin privilegios en el host (ej.: 100000). Si el proceso escapa del contenedor, aterriza como un usuario común sin permiso de escritura en casi nada.

ℹ️ Información: En pruebas de Red Hat con CVE-2019-5736 (el escape clásico de runc), el exploit en Docker rootful conseguía sobrescribir el binario de runc en el host. En Podman rootless el mismo exploit aterriza como UID 100000 sin permiso de escritura — el contenedor “escapa”, pero no causa daño.

Esta diferencia cambia cómo piensas en backups, logs y orquestación. Los logs de contenedores rootless van al journal del usuario, no a /var/log/. Los backups de volúmenes quedan en ~/.local/share/containers/storage/volumes/. Y systemctl restart necesita el flag --user.

Configurando el Host: subuid, subgid y Linger

La configuración base del host es el punto donde aparece el 80% de los problemas en producción. Sin ella, el contenedor incluso arranca, pero se reinicia tras el logout, pierde acceso a puertos, o falla al montar volúmenes con el confuso error lchown: operation not permitted.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
# Crear un usuario dedicado para la aplicación
sudo useradd -m -s /bin/bash app

# Reservar 65536 UIDs y GIDs subordinados para el usuario 'app'
# Sin esto, podman rootless falla al mapear el UID del contenedor
sudo usermod --add-subuids 100000-165535 --add-subgids 100000-165535 app

# Habilitar systemd --user incluso sin una sesión SSH activa
# Esencial para contenedores en producción que deben sobrevivir al logout
sudo loginctl enable-linger app

# Permitir bind en puertos bajos (80/443) sin CAP_NET_BIND_SERVICE
echo 'net.ipv4.ip_unprivileged_port_start=80' | sudo tee /etc/sysctl.d/99-podman.conf
sudo sysctl --system

loginctl enable-linger es el comando que más olvido — sin él, cualquier systemctl --user start muere cuando la sesión SSH cae. La línea ip_unprivileged_port_start=80 evita tener que recurrir a setcap o a un proxy inverso solo para servir HTTP.

⚠️ Atención: Si reutilizas UIDs subordinados que ya están asignados a otro usuario, Podman rechazará el run con IDs already in use. Ejecuta siempre cat /etc/subuid /etc/subgid antes de agregar rangos.

Quadlet: el Verdadero Reemplazo de docker-compose

docker-compose fue la pieza más difícil de reemplazar en mi migración. podman-compose existe, pero lo mantiene la comunidad y tiene inconsistencias en redes y healthchecks. La solución oficial es Quadlet, integrado en Podman 4.4+.

Quadlet permite describir contenedores, redes y volúmenes en archivos .container, .network y .volume que systemd traduce automáticamente en units. Esto significa: políticas de reinicio, dependencias (After=, Requires=), logs en el journal, healthchecks supervisados por systemd. Todo gratis, sin dockerd.

La ubicación para las units rootless es ~/.config/containers/systemd/. systemd --user las analiza cada vez que ejecutas systemctl --user daemon-reload.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
# ~/.config/containers/systemd/api.container
[Unit]
Description=API .NET 9 em Podman rootless
After=network-online.target

[Container]
Image=ghcr.io/lincoln/api:1.4.0
AutoUpdate=registry
ContainerName=api
PublishPort=8080:8080
Environment=ASPNETCORE_ENVIRONMENT=Production
Volume=api-data.volume:/data:Z
Network=apps.network
HealthCmd=curl -f http://localhost:8080/health || exit 1
HealthInterval=30s

[Service]
Restart=always
TimeoutStartSec=900

[Install]
WantedBy=default.target

Después de crear el archivo, basta con systemctl --user daemon-reload && systemctl --user start api.service. systemd crea la unit, descarga la imagen, levanta el contenedor y monitorea el healthcheck.

Migrando docker-compose.yml a Quadlet

Para proyectos con varios servicios, traducir a mano es viable, pero hay atajos. La herramienta podlet convierte un docker-compose.yml en archivos Quadlet en segundos:

1
2
3
4
5
6
7
# Instalar podlet (binario Go, sin dependencias)
curl -L -o /tmp/podlet.tar.gz \
  https://github.com/containers/podlet/releases/latest/download/podlet-x86_64-unknown-linux-gnu.tar.gz
tar -xzf /tmp/podlet.tar.gz -C ~/.local/bin/

# Convertir un compose existente a Quadlet
podlet --file ~/.config/containers/systemd/ compose docker-compose.yml

La conversión acierta volúmenes, redes, dependencias y puertos en ~90% de los casos. El 10% restante suele ser depends_on con condition: service_healthy (Quadlet usa Requires= + After=) y extra_hosts (que se convierte en AddHost= en el bloque [Container]).

💡 Consejo: Mantén el docker-compose.yml original en el repositorio por ahora, con un README que apunte a los archivos Quadlet. Los devs locales siguen usando Docker Desktop; el servidor de producción usa Podman/Quadlet. Ambos describen la misma topología.

Red, Volúmenes y SELinux: Las Tres Trampas

Red en modo rootless

Por defecto, Podman rootless usa pasta (en versiones 5.x) o slirp4netns (versiones anteriores) como backend de red. Funciona, pero tiene limitaciones: la IP de origen del tráfico que ve el contenedor es siempre 10.0.2.100 (con slirp4netns), lo que rompe el rate limiting y los logs de auditoría basados en IP. Con pasta, la IP real se preserva, y por eso siempre exijo Podman 5.x en producción nueva.

Volúmenes y el flag :Z

En hosts con SELinux (RHEL, Fedora, Rocky), montar un volumen sin el flag :Z en Quadlet o -v ./data:/data:Z en el run provoca un Permission denied silencioso dentro del contenedor. :Z aplica la etiqueta SELinux correcta al directorio del host. Sin él, depurar se vuelve una pesadilla porque ls -l muestra permisos correctos, pero el proceso del contenedor no puede leer.

Mapeo de UID en volúmenes

Cuando el contenedor escribe en un volumen bind-mounted, el archivo en el host aparece con UID 100000 (el UID subordinado mapeado). Para sincronizarlo con tu usuario local, usa podman unshare:

1
2
3
4
# Entrar en el namespace de usuario de podman
podman unshare chown -R 1000:1000 /home/app/data

# Equivalente a "chown 100999:100999" visto desde el host

Configuración Optimizada: containers.conf, registries.conf, storage.conf

Los valores predeterminados de Podman funcionan, pero en producción rootless hay tres archivos que deciden el rendimiento y la seguridad operativa. En modo rootless, están en ~/.config/containers/. Esta es la configuración que ejecuto en un RHEL 9.7 con disco dedicado para /userapps y un SSD limitado en IOPS — elimina escrituras temporales masivas y usa journald en RAM como destino de logs.

containers.conf — runtime y logging

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# ~/.config/containers/containers.conf
# Referencia: man 5 containers.conf

[containers]
tz = "America/Sao_Paulo"

# Driver de log: journald almacena en RAM vía journal, no en un archivo en disco
log_driver = "journald"
log_size_max = 10485760    # 10 MB por contenedor

# Límite de PIDs por contenedor (mitigación de fork bomb)
pids_limit = 2048

[engine]
# TMPDIR en /dev/shm (tmpfs en RAM) elimina millones de escrituras temporales en disco
env = ["TMPDIR=/dev/shm/podman-tmp"]

# Los eventos de Podman van a journald, no a archivos en disco
events_logger = "journald"

[network]
# Netavark es el backend moderno (reemplaza a CNI desde Podman 4.x)
network_backend = "netavark"
network_config_dir = "/userapps/zocateli/containers/networks"

La ganancia práctica más visible es TMPDIR=/dev/shm/...: en un servidor con muchos podman pull y podman build, el disco recibía millones de archivos temporales que desaparecían segundos después. Al moverlos a tmpfs, el I/O del disco cayó drásticamente sin perder funcionalidad.

registries.conf — anti supply-chain

1
2
3
4
5
6
# ~/.config/containers/registries.conf
[registries.search]
registries = ['meu-docker.artifacts.zocate.li']

# Rechaza cualquier "podman run nginx" sin prefijo de registry
short-name-mode = "enforcing"

short-name-mode = "enforcing" es un control subestimado: sin él, podman run nginx puede resolverse a cualquier registry de la lista de búsqueda, abriendo una brecha para un ataque de supply chain. Con enforcing, el usuario debe especificar el registry completo (docker.io/library/nginx) — obliga a que toda imagen se atribuya explícitamente a una fuente.

storage.conf — overlay nativo (60–80% menos I/O)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# ~/.config/containers/storage.conf
# Referencia: man 5 containers-storage.conf

[storage]
driver = "overlay"

# Almacenamiento persistente (imágenes, layers) → disco dedicado
graphroot = "/userapps/zocateli/containers/storage"
rootless_storage_path = "/userapps/zocateli/containers/storage"

# runroot (PIDs, sockets, locks) se resuelve automáticamente vía $XDG_RUNTIME_DIR
# que apunta a /run/user/<UID>/containers (tmpfs en RAM) — no definir aquí

[storage.options]
pull_options = {enable_partial_images = "false", use_hard_links = "false"}

[storage.options.overlay]
# SIN mount_program → Podman usa el overlay NATIVO del kernel (5.11+)
# Habilitar fuse-overlayfs solo si el overlay nativo no funciona:
# mount_program = "/usr/bin/fuse-overlayfs"

# SIN metacopy=on → evita el overhead de copy-up en workloads con muchas escrituras
mountopt = "nodev"

El punto crítico es la ausencia de mount_program. En kernel 5.11+ (RHEL 9, Ubuntu 22.04+, Fedora 35+), el overlay nativo soporta rootless sin fuse-overlayfs. Eliminar FUSE elimina syscalls de userspace en cada operación de sistema de archivos — en workloads I/O-bound, veo una reducción del 60–80% en el tiempo de las operaciones de layer (build, pull, run de imágenes grandes).

⚠️ Atención: Si el sistema de archivos subyacente es ext4 sin soporte de overlay rootless, o el kernel es < 5.11, descomenta mount_program = "/usr/bin/fuse-overlayfs". Sin ese fallback, podman pull fallará con mount: permission denied. Para detectar el soporte: podman info | grep graphDriverName debe mostrar overlay, no vfs.

Ejemplo Práctico: API .NET + Postgres + Worker en Producción

Un caso real que ejecuto hoy: API .NET 9, worker de procesamiento y Postgres 17, todos en Podman rootless, supervisados por systemd --user. Estructura:

1
2
3
4
5
6
~/.config/containers/systemd/
├── apps.network
├── postgres.volume
├── postgres.container
├── api.container
└── worker.container
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
# postgres.container — base de datos persistente
[Unit]
Description=Postgres 17
After=network-online.target

[Container]
Image=docker.io/library/postgres:17-alpine
ContainerName=postgres
Environment=POSTGRES_PASSWORD_FILE=/run/secrets/pg_pass
Secret=pg_pass,type=mount,target=pg_pass
Volume=postgres.volume:/var/lib/postgresql/data:Z
Network=apps.network
HealthCmd=pg_isready -U postgres
HealthInterval=10s

[Service]
Restart=always

[Install]
WantedBy=default.target
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
# api.container — depende de un Postgres saludable
[Unit]
Description=API .NET 9
Requires=postgres.service
After=postgres.service

[Container]
Image=ghcr.io/lincoln/api:1.4.0
AutoUpdate=registry
ContainerName=api
PublishPort=8080:8080
Environment=ConnectionStrings__Db=Host=postgres;Username=postgres;Password=...
Network=apps.network

[Service]
Restart=always

[Install]
WantedBy=default.target

El deploy es un git pull && systemctl --user restart api.service. Sin daemon, sin sudo, sin socket abierto. La actualización de la imagen la orquesta podman auto-update (habilitado con AutoUpdate=registry en Quadlet), que consulta el registry a diario y reinicia los contenedores automáticamente cuando hay un nuevo tag.

📂 Código Fuente: Los manifiestos Quadlet completos y el Containerfile del worker están en el repositorio de ejemplos del blog: BlogSamples/Workers/

Diagrama de arquitectura Podman rootless con API, worker y Postgres orquestados por systemd user

Auto-Update en la Práctica: Quadlet .image, Timer y Lo Que .network/.volume No Hacen

podman auto-update lo dispara el timer podman-auto-update.timer de systemd --user (diario por defecto). Recorre todas las units con la etiqueta io.containers.autoupdate y:

  1. Ejecuta skopeo inspect en el registry para comparar el digest actual con el publicado.
  2. Si cambió, ejecuta podman pull de la nueva imagen.
  3. Reinicia el servicio systemd correspondiente.
  4. Si el reinicio falla (healthcheck negativo), hace un rollback automático a la imagen anterior.

Habilitar el timer:

1
2
systemctl --user enable --now podman-auto-update.timer
systemctl --user list-timers | grep auto-update

Cambiando la cadencia a cada 5 minutos

El timer predeterminado se ejecuta una vez al día (OnCalendar=daily + RandomizedDelaySec=900). Para deploys más agresivos, se puede bajar a 5 minutos sin editar los archivos del paquete — basta con crear un override del systemd de usuario:

1
systemctl --user edit podman-auto-update.timer

Agrega solo:

1
2
3
4
5
6
7
8
9
# ~/.config/systemd/user/podman-auto-update.timer.d/override.conf
[Timer]
# Restablece el OnCalendar heredado del timer original
OnCalendar=
OnCalendar=*:0/5
# Sin ventana aleatoria — queremos previsibilidad en el deploy
RandomizedDelaySec=0
# Recupera ejecuciones perdidas (ej.: máquina hibernando)
Persistent=true

Recarga y confirma:

1
2
3
systemctl --user daemon-reload
systemctl --user restart podman-auto-update.timer
systemctl --user list-timers podman-auto-update.timer

⚠️ Atención: Las dos líneas OnCalendar= son intencionales. La primera línea vacía limpia el valor heredado del timer original (daily). Sin ella, el timer se dispara en ambas cadencias — a diario y cada 5 minutos. Este es el patrón de override de timers de systemd documentado en systemd.timer(5).

Trade-offs con 15 contenedores en el mismo host

Reducir el intervalo de 1 día a 5 minutos significa multiplicar el número de ejecuciones por 288×. Para 15 contenedores que comparten el mismo host, conviene revisar cuatro puntos antes de decidir:

Eje1 vez al día1 vez cada 5 minutos (15 contenedores)
Solicitudes al registry15/día4.320/día
Tráfico si nada cambió~3 KB/inspect × 15~12 MB/día (manifest HEAD + JSON)
Reinicio simultáneo1 ventana/día288 ventanas/día
Ventana de exposición a CVEhasta 24hhasta 5 min

1. Rate limit del registry. Docker Hub anónimo: 100 pulls/6h por IP. Cada podman auto-update ejecuta skopeo inspect (no cuenta como pull, pero sí como request) — 15 contenedores × 12 verificaciones/h = 180 req/h. En GHCR autenticado el límite es de 5.000 req/h, sin problema. En un registry interno, generalmente irrelevante. En Docker Hub anónimo con muchos contenedores, vas a chocar con el rate limit.

2. Tormenta de reinicios simultáneos. Cuando se publica un digest nuevo y varios contenedores del stack dependen de él (ej.: API + worker compartiendo la misma imagen base), el auto-update los reinicia todos juntos. Si el healthcheck tarda 30s y hay Requires= en cadena, el stack entero puede quedar degradado 1–2 minutos — solo que ahora 288 veces al día en lugar de 1. Sin un load balancer con drain, eso es downtime visible.

3. CPU/IO en el host. Cada ejecución es ligera de forma aislada (~50ms por contenedor, sin cambios). Para 15 contenedores cada 5 min, el overhead agregado ronda el 0,3% de CPU constante y ~10 MB extra de tráfico de logs en journald. Aceptable en producción, pero en hosts con muchos contenedores (50+), considera RandomizedDelaySec=60 para evitar picos coincidentes.

4. Riesgo de rollback en cascada. El auto-update hace rollback por contenedor, no de forma atómica para el stack. Si el nuevo digest de la imagen de la API rompe el contrato con el worker (que todavía está en la versión antigua), 5 minutos después el worker también toma la nueva versión y se rompe junto con ella. Con una ventana diaria da tiempo a detectarlo; con una ventana de 5 minutos, no.

💡 Consejo: Para 15 contenedores en producción real uso 15 minutos (OnCalendar=*:0/15) con RandomizedDelaySec=300, y aun así solo en contenedores que cumplen dos criterios: tag semver inmutable + healthcheck rápido (< 10s) + cero dependencia de otro contenedor. Para el resto, mantengo la cadencia diaria y hago deploy explícito vía CI cuando necesito una ventana menor. La cadencia de 5 minutos tiene sentido en preproducción/canary, raramente en producción heterogénea.

La clave AutoUpdate= acepta dos valores en el bloque [Container]:

ValorCuándo usarlo
registryPull desde el registry remoto. El tag debe ser una versión inmutable (semver, calendar o digest).
localLa imagen se reconstruyó localmente (podman build). Compara el digest local.

Quadlet .image — separar el pull del start

Cuando varias units .container usan la misma imagen (ej.: API + sidecar de migración compartiendo la misma base), conviene extraer el pull a un archivo .image dedicado. El auto-update opera sobre el archivo de imagen y los contenedores lo consumen por referencia:

1
2
3
4
# ~/.config/containers/systemd/api-image.image
[Image]
Image=ghcr.io/lincoln/api:1.4.0
AutoUpdate=registry
1
2
3
# api.container — consume la image unit
[Container]
Image=api-image.image    # referencia, no duplica la definición

.network y .volume no soportan AutoUpdate=

Esta es la confusión más común: la clave AutoUpdate= no existe en .network ni en .volume. No hacen pull de nada — son recursos estáticos de Podman, reconciliados cuando editas el archivo y ejecutas systemctl --user daemon-reload seguido del reinicio del servicio que los usa.

Un ejemplo concreto migrando el servicio cloudbeaver de mi docker-compose.yml (parte del stack de desarrollo del blog) a Quadlet:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
# Antes — docker-compose.yml
cloudbeaver:
  image: lzocateli/dbeaver:25.2.0
  ports:
    - "8978:8978"
  volumes:
    - C:/Users/lzoca/cloudbeaver:/opt/cloudbeaver/workspace
  networks:
    - lzo
  depends_on:
    postgres:
      condition: service_healthy

Se convierte en tres archivos Quadlet, cada uno con su responsabilidad:

1
2
3
4
5
6
# ~/.config/containers/systemd/lzo.network
[Network]
NetworkName=lzo
Driver=bridge
Label=app=blog-stack
# Sin AutoUpdate — la red se reconcilia vía daemon-reload
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
# ~/.config/containers/systemd/cloudbeaver-workspace.volume
[Volume]
VolumeName=cloudbeaver-workspace
Label=app=blog-stack

# Bind a un directorio del host (equivalente al volumen de docker-compose)
# En Linux/WSL2 esta ruta es /mnt/c/Users/lzoca/cloudbeaver
Driver=local
Options=type=none,o=bind
Device=C:/Users/lzoca/cloudbeaver

# Sin AutoUpdate — el volumen se reconcilia vía daemon-reload
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
# ~/.config/containers/systemd/cloudbeaver.container
[Unit]
Description=CloudBeaver — gerenciador de banco
Requires=postgres.service
After=postgres.service

[Container]
Image=docker.io/lzocateli/dbeaver:25.2.0
AutoUpdate=registry            # ← la única unit que hace pull
ContainerName=cloudbeaver
PublishPort=8978:8978
Environment=TZ=America/Sao_Paulo
Volume=cloudbeaver-workspace.volume:/opt/cloudbeaver/workspace:Z
Network=lzo.network
HealthCmd=curl -f http://localhost:8978/ || exit 1
HealthInterval=30s

[Service]
Restart=unless-stopped

[Install]
WantedBy=default.target

Cuando cloudbeaver recibe una nueva versión en Docker Hub (lzocateli/dbeaver:25.2.0 republicada con un nuevo digest), el timer hace pull, reinicio y healthcheck — lzo.network y cloudbeaver-workspace.volume permanecen intactos. Si edito lzo.network para cambiar el driver, necesito ejecutar systemctl --user daemon-reload && systemctl --user restart cloudbeaver.service manualmente — no existe un “auto-update de network”.

Rollback manual

Cuando el auto-update levanta una versión rota y el healthcheck tarda en fallar:

1
2
podman auto-update rollback     # vuelve a la imagen anterior en todas las units
systemctl --user restart cloudbeaver.service

💡 Consejo: Para máxima reproducibilidad, cambia el tag por digest pinning en el .image: Image=docker.io/lzocateli/dbeaver@sha256:abc…. El auto-update sigue funcionando (compara el digest publicado con el actual) y ganas inmutabilidad garantizada por el contenido de la imagen, no por el contrato del tag.

Compliance: Lo Que la Auditoría Realmente Mira

El argumento de venta interno más fuerte de Podman rootless no es técnico — es regulatorio. En tres auditorías que acompañé en los últimos 18 meses, los puntos atendidos automáticamente fueron:

  • CIS Docker Benchmark 5.x — los controles de “non-root user inside container” y “no privileged containers” se cumplen por construcción
  • PCI-DSS 4.0 req. 7.2.5 — el mínimo privilegio para componentes del sistema se satisface porque el contenedor nunca tiene privilegios en el host
  • NIST SP 800-190 sección 4.2 — el aislamiento de contenedores vía user namespaces es una recomendación explícita
  • ISO 27001 A.8.2 — el control de acceso privilegiado se vuelve trivial de evidenciar cuando no hay grupo docker en la máquina

La evidencia práctica que piden las auditorías es simple: ps -ef | grep -v podman | grep <container-pid> mostrando el proceso ejecutándose con un UID alto, y getent group docker devolviendo vacío.

Consejos y Buenas Prácticas

  • Habilita siempre linger antes de crear units systemd --user. Sin eso, todos los contenedores mueren en el primer logout y solo lo descubres a la mañana siguiente cuando el monitoreo empieza a gritar.
  • Usa Podman 5.x para tener pasta como backend de red predeterminado. Preservar la IP de origen evita reescribir reglas de rate limit, WAF y logs.
  • Versiona los archivos Quadlet en Git junto al código de la aplicación. Trata *.container como infraestructura como código: pull request, code review y CI validando la sintaxis vía quadlet -dryrun.
  • Habilita AutoUpdate=registry solo con tags de versión inmutables. Por defecto: semver (:1.4.0, :2.0.1) — se alinea con SemVer 2.0, encaja en SBOM/SCA y es lo que la mayoría de los registries del mercado ya publica. Variante: calendar versioning (:v2026.05.10-sha) para apps internas con release diario. Gold standard: digest pinning (Image=ghcr.io/lincoln/api@sha256:abc…) — inmutabilidad garantizada por el contenido, no por el contrato. Nunca :latest con auto-update: es una invitación a un incidente.
  • Centraliza los logs con journald + vector o promtail. Los logs rootless están en journalctl --user -u <service>. Reenviarlos a Loki/Elastic es trivial y más barato que un docker logging driver.
  • Ejecuta podman system reset en homologación semanalmente. Limpia almacenamiento corrupto, volúmenes huérfanos y layers overlay obsoletos. Se vuelve evidente cuando alguna unit tiene un estado inconsistente.

Resumen Objetivo

  • Podman rootless elimina el daemon root y el socket privilegiado de Docker, reduciendo el blast radius de una RCE en un contenedor al de un usuario común en el host.
  • Quadlet es el reemplazo oficial de docker-compose en producción: los archivos .container/.network/.volume en ~/.config/containers/systemd/ se convierten automáticamente en units de systemd --user.
  • subuid/subgid + loginctl enable-linger son requisitos no negociables: sin ellos el contenedor no mapea UIDs o muere en el primer logout.
  • El backend pasta (Podman 5.x) preserva la IP de origen del cliente, a diferencia de slirp4netns, que lo enmascara todo como 10.0.2.100.
  • El flag :Z en volúmenes aplica la etiqueta SELinux correcta en hosts RHEL/Fedora; sin él, el contenedor falla al leer/escribir sin un mensaje claro.
  • CIS Docker Benchmark, PCI-DSS 4.0 y NIST SP 800-190 tienen controles que Podman rootless satisface automáticamente y que exigen trabajo manual en Docker.
  • podman auto-update con tags de versión inmutables (semver :1.4.0, calendar :v2026.05.10-sha o digest @sha256:…) habilita la actualización continua sin CI, supervisada por un timer de systemd. Las claves AutoUpdate=registry|local solo existen en el bloque [Container] o en archivos .image — no en .network ni en .volume.
  • podlet compose docker-compose.yml convierte automáticamente ~90% de los manifiestos Compose existentes a Quadlet, reduciendo el esfuerzo de migración.

Lee También

Referencias