Podman rootless sin sudo ni Docker: de `podman run` a un servicio con Quadlet

󰃭 2026-11-08 · 16 min de lectura

Contenido

Hay un momento, con casi cualquier contenedor que montas «un momento para probar», en el que se convierte en un servicio de verdad. Alguien lo usa. Tú dependes de él. Y entonces te das cuenta de que su configuración entera vive en el historial de tu shell: un podman run con cuatro volúmenes, tres puertos y media docena de variables que ya no recuerdas del todo. Reinicia el equipo y el contenedor no vuelve. Pierde el comando y has perdido el servicio.

Esta entrada va de las dos cosas que hacen falta para salir de ahí sin privilegios:

  1. Entender qué significa ejecutar contenedores rootless (sin demonio y sin root), porque casi todos los problemas que vas a encontrar salen de ahí.
  2. Dejar de escribir podman run a mano, describiendo los contenedores en ficheros que systemd arranca, reinicia y vigila: eso se llama Quadlet.

Todo el código está en un laboratorio que puedes ejecutar. Las salidas de terminal de las secciones sobre permisos son reales, capturadas con Podman 4.9.3 en Ubuntu 24.04 con un usuario sin privilegios. Verás al final qué partes he podido probar y cuáles no. Y si prefieres verlo en marcha, tienes la versión en vídeo.

Qué es «rootless» y por qué importa #

Con Docker, las órdenes las ejecuta un demonio (dockerd) que corre como root. Tu usuario le habla por un socket, y quien puede hablar con ese socket (el grupo docker) puede, en la práctica, hacer lo que quiera en la máquina: es equivalente a tener root sin escribir sudo.

Podman es distinto en dos cosas:

  • No hay demonio. Cada podman run es un proceso normal de tu usuario que lanza el contenedor. No hay ningún servicio privilegiado escuchando.
  • El contenedor corre con tu usuario, dentro de un user namespace. El root que ves dentro es, para el sistema, tu usuario normal. Si algo se escapa del contenedor, se escapa con tus permisos, no con los de root.

El truco es una tabla de correspondencia de UIDs. Dentro de un contenedor hay muchos usuarios (root, www-data, postgres…), pero tu usuario real es uno solo. Por eso el sistema te reserva un rango de UIDs «subordinados» en /etc/subuid y /etc/subgid, y Podman mapea los UIDs de dentro a ese rango. Puedes ver el mapa de tu sesión:

usuario@equipo:~$ podman unshare cat /proc/self/uid_map
         0      30033          1
         1     165536      65536

Cada fila dice: UID de dentro, UID de fuera, cuántos. Aquí el usuario es el 30033 (el tuyo será probablemente el 1000). Lo que significa:

  • El UID 0 de dentro (root) es tu usuario de fuera.
  • Los UIDs 1 a 65536 de dentro son del 165536 en adelante de fuera. Es decir, el UID N de dentro es el 165535 + N de fuera.

Guarda esa fórmula. Explica los dos tercios de los problemas de permisos que vas a encontrar.

Instalación y comprobaciones #

Instalar sí necesita privilegios, una vez:

usuario@equipo:~$ sudo apt install podman uidmap

uidmap aporta newuidmap y newgidmap, los programas que permiten a un usuario normal crear el mapa anterior. A partir de ahí no hace falta sudo para nada más. El laboratorio trae un script de diagnóstico que lo comprueba todo y no modifica nada:

usuario@equipo:~/lab-podman$ ./comprobar.sh
Diagnóstico para el usuario: usuario (uid 1000)

[ OK  ] podman instalado: podman version 4.9.3
[ OK  ] podman funciona en modo rootless
[ OK  ] /etc/subuid: usuario:100000:65536
[ OK  ] /etc/subgid: usuario:100000:65536
[ OK  ] newuidmap y newgidmap disponibles
[ OK  ] generador de Quadlet: /usr/lib/systemd/system-generators/podman-system-generator
...

(La salida de arriba la he recortado y adaptado al usuario genérico; la original, tal cual salió en mi entorno de pruebas, está en salidas/comprobar-sandbox.txt y es interesante: ese entorno no tenía una sesión de login real y el script lo detecta y lo explica.)

Qué comprueba y por qué importa cada cosa:

  • podman info dice Rootless: true. Si no, algo falta (casi siempre uidmap o el rango de subuid).
  • Entradas en /etc/subuid y /etc/subgid. Sin ellas Podman no puede crear el espacio de usuario. Las añade root con usermod --add-subuids y --add-subgids (en Ubuntu suelen venir ya con el usuario).
  • El generador de Quadlet, que existe desde Podman 4.4.
  • Una sesión de login real: systemctl --user necesita XDG_RUNTIME_DIR, que no existe tras un su o sudo -u.
  • El linger, del que hablaré más abajo.
  • El umbral de puertos sin privilegios, que también.

Una prueba de humo, con nombre de imagen completo:

usuario@equipo:~$ podman run --rm docker.io/library/alpine:3 echo hola
hola

Escribo docker.io/library/alpine:3 y no alpine porque con nombres cortos Podman tiene que adivinar en qué registro buscar y, sin terminal interactiva, puede fallar o preguntarte. Con el nombre completo eres explícito, y Quadlet además lo recomienda. Fíjate también en que puedes usar imágenes de cualquier registro (docker.io, quay.io, ghcr.io…): no tener Docker instalado no te impide usar sus imágenes.

Imágenes y contenedores viven en tu carpeta personal (~/.local/share/containers/storage), no en /var/lib. Cada usuario tiene los suyos y no se ven entre sí.

Los tres sitios donde rootless te muerde #

1. Permisos de los volúmenes #

Es el problema número uno: montas una carpeta tuya dentro del contenedor y el programa de dentro no puede escribir, o escribe pero los ficheros te aparecen con un dueño imposible.

Lo he montado como demostración en el laboratorio, permisos/demo.sh. Una imagen mínima (sin descargar nada) cuyo proceso corre como UID 1000 dentro del contenedor, como harían muchas imágenes reales que declaran un USER sin privilegios, e intenta crear un fichero en una carpeta tuya. Aquí mi usuario es el 30033, no el 1000. Lo que pasa:

=== A) Sin opciones: el UID 1000 de dentro no es tu usuario de fuera
dentro: uid=1000 gid=0
no puedo escribir en /datos: Permission denied

Con la fórmula de antes: el UID 1000 de dentro es el 166535 de fuera, que no es el dueño de la carpeta (30033) ni tiene permisos sobre ella. Lógico.

La primera idea es probar --userns=keep-id, que conserva tu UID dentro del contenedor. Y no funciona:

=== B) --userns=keep-id: tu UID se conserva, pero el proceso sigue siendo el 1000
dentro: uid=1000 gid=0
no puedo escribir en /datos: Permission denied

keep-id hace que tu UID de fuera (30033) sea el mismo dentro. Pero el proceso corre como el 1000 por el USER de la imagen, que ya no coincide con nadie. Lo que necesitas es decirle a Podman que el 1000 de dentro seas tú:

=== C) --userns=keep-id:uid=1000,gid=1000: el 1000 de dentro eres TÚ de fuera
dentro: uid=1000 gid=0
escrito /datos/creado-por-contenedor.txt
en el disco (uid:gid numéricos):
-rw-r--r-- 1 30033 165536 5 Nov  4 20:27 creado-por-contenedor.txt

El proceso es el 1000 de dentro, el fichero aparece en el disco con tu UID de fuera, y puedes editarlo y borrarlo sin problemas. En Quadlet se escribe UserNS=keep-id:uid=1000,gid=1000.

La alternativa es no tocar el mapa y cambiar el dueño de la carpeta para que coincida con lo que verá el contenedor. Desde fuera no puedes hacer chown a un UID subordinado, pero podman unshare te mete en el espacio de usuarios de Podman, y desde ahí sí:

=== D) Sin keep-id, pero con la carpeta dada al UID 1000 *de dentro*
carpeta vista desde fuera:
drwxr-xr-x 2 166535 166535 4096 Nov  4 20:27 /tmp/tmp.qCpiztyWeY/datos
dentro: uid=1000 gid=0
escrito /datos/creado-por-contenedor.txt
en el disco (uid:gid numéricos):
-rw-r--r-- 1 166535 30033 5 Nov  4 20:27 creado-por-contenedor.txt

Funciona, pero ahora la carpeta (y lo que se cree dentro) es del 166535 y ya no es tuya: para tocarla tú tendrás que entrar con podman unshare también. Es la solución adecuada para datos que sólo debe tocar el contenedor; para una carpeta de trabajo tuya, keep-id:uid=... es mejor.

Tres matices:

  • Si la imagen corre como root, que es lo que hacen muchas al arrancar, no tienes este problema: el root de dentro eres tú.
  • Los volúmenes con nombre (podman volume create, o .volume en Quadlet) los gestiona Podman y normalmente no dan este problema, así que son la opción cómoda para datos que no necesitas tocar a mano.
  • En Ubuntu las carpetas nuevas suelen salir con modo 775 y el gid 0 del contenedor se corresponde con tu grupo, así que a veces el contenedor sí consigue escribir «de rebote» por el permiso de grupo. En la demo creo la carpeta con modo 755 a propósito para ver el problema limpio. Aun así, lo que escriba así aparecerá con un dueño raro (en mis pruebas, 166535:30033).

Y una nota para quien venga de Fedora o Red Hat: allí los volúmenes suelen llevar :Z por SELinux. En Ubuntu la seguridad la lleva AppArmor y normalmente no hace falta.

2. Puertos por debajo del 1024 #

Un usuario sin privilegios no puede abrir puertos bajos, incluidos el 80 y el 443. En muchas distribuciones el umbral por defecto es el 1024; compruébalo:

usuario@equipo:~$ sysctl net.ipv4.ip_unprivileged_port_start

Lo más sencillo es publicar un puerto alto (8080) y que lo atienda un proxy inverso o una redirección del cortafuegos. Bajar el umbral con sysctl también funciona, pero es una decisión de root que afecta a todo el sistema.

Una buena costumbre: publica en 127.0.0.1 si sólo quieres acceder tú. -p 8080:8080 abre el puerto en todas las interfaces; -p 127.0.0.1:8080:8080 sólo en local.

3. La red #

Un contenedor rootless no puede crear interfaces de red de verdad, así que usa un traductor en espacio de usuario. En Podman 5 el predeterminado es pasta (antes era slirp4netns). Para el uso cotidiano es transparente: salen a internet y publican puertos sin más. Donde se nota es en redes muy exigentes y en detalles como la IP de origen de las conexiones entrantes, que puede aparecer distinta de la real.

Otra diferencia entre versiones: Podman 5 usa siempre netavark para las redes entre contenedores; en Podman 4 podía ser CNI (es lo que usa mi entorno de pruebas).

El problema: podman run no sobrevive a un reinicio #

Con todo lo anterior, esto funciona:

usuario@equipo:~$ podman run -d --name lab-db --network lab \
    -v lab-datos:/var/lib/postgresql/data \
    --env-file ~/.config/lab-podman/db.env \
    -e POSTGRES_USER=lab -e POSTGRES_DB=lab \
    docker.io/library/postgres:16

Y ahora la parte incómoda: ese comando vive en tu historial. Si reinicias, el contenedor no vuelve. Si lo recreas, tienes que acordarte de todas las opciones. Podman tiene --restart=always, pero por sí solo no basta en rootless: sin nada que arranque Podman al iniciar el sistema, no hay quien reinicie nada. El mecanismo adecuado es systemd, y la forma moderna de conectarlo con Podman se llama Quadlet. (podman generate systemd fabrica unidades a partir de un contenedor ya creado, pero está marcado como obsoleto a favor de Quadlet.)

Quadlet: describe el contenedor en un fichero #

La idea es simple: en vez de un comando imperativo, escribes un fichero declarativo y systemd se encarga del resto. Un generador de Podman lee tus ficheros y fabrica las unidades de servicio al vuelo. Para tu usuario, los ficheros van en ~/.config/containers/systemd/ (la documentación lista más rutas; por ejemplo, lo que pongas en /etc/containers/systemd/users/ se ejecuta cuando cualquier usuario inicia sesión). Hay un tipo de fichero por cosa:

ExtensiónQué describeServicio generado
.containerun contenedornombre.service
.volumeun volumen con nombrenombre-volume.service
.networkuna rednombre-network.service

Según la versión de Podman hay más tipos (.pod, .kube, .build…); mira la documentación de la tuya.

El laboratorio monta un servicio típico: PostgreSQL con su volumen, en una red propia, y una interfaz web (Adminer) que habla con él. Son cuatro ficheros pequeños.

La red, lab.network, y el volumen, lab-datos.volume:

[Network]
NetworkName=lab
[Volume]
VolumeName=lab-datos

La base de datos, lab-db.container:

[Unit]
Description=PostgreSQL del laboratorio (Podman rootless)

[Container]
ContainerName=lab-db
Image=docker.io/library/postgres:16
Network=lab.network
Volume=lab-datos.volume:/var/lib/postgresql/data
EnvironmentFile=%h/.config/lab-podman/db.env
Environment=POSTGRES_USER=lab
Environment=POSTGRES_DB=lab
HealthCmd=pg_isready -U lab -d lab
HealthInterval=10s
HealthRetries=5

[Service]
Restart=always
TimeoutStartSec=300

[Install]
WantedBy=default.target

Y la interfaz web, lab-adminer.container:

[Unit]
Description=Adminer: interfaz web para la base de datos del laboratorio
Requires=lab-db.service
After=lab-db.service

[Container]
ContainerName=lab-adminer
Image=docker.io/library/adminer:latest
Network=lab.network
PublishPort=127.0.0.1:8080:8080
Environment=ADMINER_DEFAULT_SERVER=lab-db
AutoUpdate=registry

[Service]
Restart=always

[Install]
WantedBy=default.target

Qué hace cada pieza:

  • Network=lab.network y Volume=lab-datos.volume:...: en vez de un nombre, apuntan a las unidades .network y .volume. Quadlet añade solo las dependencias: antes de arrancar el contenedor se crean la red y el volumen.
  • Sin PublishPort en la base de datos: no es accesible desde fuera. Sólo Adminer, que está en la misma red, la ve, y la encuentra por el nombre del contenedor (lab-db).
  • EnvironmentFile=%h/...: la contraseña de la base de datos no está en el fichero Quadlet (para poder versionarlo sin filtrarla) sino en un fichero aparte con modo 600. El %h es el specifier de systemd para tu carpeta personal.
  • HealthCmd y compañía: un chequeo de salud, para que podman ps y systemd sepan si la base de datos responde y no sólo si el proceso existe.
  • La etiqueta postgres:16 fija y AutoUpdate=registry en Adminer: una base de datos no debería actualizarse sola, una interfaz web sí puede. Hablo de esto más abajo.
  • [Service] y [Install]: son secciones normales de systemd. Con WantedBy=default.target se arranca con la sesión de usuario; es lo que haría systemctl enable, que con Quadlet no puedes ejecutar porque las unidades generadas son transitorias.

Qué fabrica Quadlet por debajo #

No es magia: traduce tus ficheros a unidades de systemd normales cuyo ExecStart es un podman run. Puedes verlo sin instalar nada con el modo --dryrun del generador. Este es el extracto de la base de datos, tal cual lo generó Podman 4.9.3 en mis pruebas:

ExecStart=/usr/bin/podman run --name=lab-db --cidfile=%t/%N.cid --replace --rm
  --cgroups=split --network=lab --sdnotify=conmon -d -v lab-datos:/var/lib/postgresql/data
  --env POSTGRES_DB=lab --env POSTGRES_USER=lab --env-file %h/.config/lab-podman/db.env
  --health-cmd "pg_isready -U lab -d lab" --health-interval 10s --health-retries 5
  docker.io/library/postgres:16

(Lo he partido en varias líneas para que se lea; en la salida original es una sola línea.) Es tu podman run de antes, pero generado desde un fichero declarativo, con --replace, --rm y la integración con systemd añadidas. También genera Requires= y After= hacia la red y el volumen, que es de donde sale el orden de arranque.

Validar, cargar y arrancar #

El laboratorio trae instalar.sh, que hace los pasos en orden y no usa sudo: valida con Quadlet, crea la contraseña aleatoria en ~/.config/lab-podman/db.env con modo 600, copia los ficheros a ~/.config/containers/systemd/, recarga systemd y arranca los servicios. Sin ejecutarlo, puedes sólo validar:

usuario@equipo:~/lab-podman$ ./instalar.sh --solo-validar
>> Validando los ficheros Quadlet con /usr/lib/systemd/system-generators/podman-system-generator
   Válidos: 4 fichero(s).

Los pasos manuales, para que veas qué hay detrás. Todo es --user: son servicios de tu usuario, no del sistema.

usuario@equipo:~$ /usr/lib/systemd/system-generators/podman-system-generator --user --dryrun
usuario@equipo:~$ systemctl --user daemon-reload
usuario@equipo:~$ systemctl --user start lab-db.service lab-adminer.service
usuario@equipo:~$ systemctl --user status lab-db.service

Los ficheros Quadlet se leen al arrancar y en cada daemon-reload: cada vez que edites uno, repite el daemon-reload y reinicia el servicio. Los logs están en el journal:

usuario@equipo:~$ journalctl --user -u lab-db.service -f

(Si no ves nada, comprueba que el journal sea persistente y que tu usuario pueda leerlo.) También tienes podman ps y podman logs lab-db; los contenedores se llaman lab-db y lab-adminer por el ContainerName= (por defecto serían systemd-lab-db…). Pero la fuente de verdad pasa a ser systemd.

Que arranque solo al iniciar el equipo: linger #

El segundo tropiezo clásico. Los servicios de usuario viven mientras tu sesión está abierta: si reinicias y no inicias sesión, el contenedor no arranca, y si cierras la última sesión, se para. Para que los servicios de tu usuario arranquen con la máquina, sin sesión, se activa el linger:

usuario@equipo:~$ loginctl enable-linger usuario
usuario@equipo:~$ loginctl show-user usuario --property=Linger
Linger=yes

Según cómo esté configurado polkit, puede pedirte autenticarte. Con linger y el [Install] de los ficheros, los servicios vuelven solos tras cada reinicio.

Actualizaciones automáticas #

AutoUpdate=registry marca el contenedor para que Podman compruebe si hay una imagen nueva en el registro. Requiere un nombre de imagen completo, porque Podman necesita saber de dónde descargarla. También existe AutoUpdate=local, que compara con la copia local. Las comprobaciones las lanza un temporizador que trae Podman:

usuario@equipo:~$ podman auto-update --dry-run
usuario@equipo:~$ systemctl --user enable --now podman-auto-update.timer

El primero te dice qué se actualizaría sin tocar nada; el segundo programa la comprobación periódica. Cuando hay una imagen nueva, Podman la descarga y reinicia el servicio.

Actualizar solo es cómodo y arriesgado a la vez. Por eso en el laboratorio sólo Adminer lo lleva: para una interfaz web no pasa nada. Para algo con datos, mejor fijar una etiqueta de versión (postgres:16) y actualizar a mano, leyendo antes las notas de versión.

Cuando algo no va: chuleta de diagnóstico #

SíntomaQué mirar
Failed to connect to bus con systemctl --userSesión sin XDG_RUNTIME_DIR (típico tras su o sudo -u). Usa un login real o machinectl shell usuario@.
El servicio no aparece tras crear el ficherodaemon-reload, y luego el --dryrun del generador para ver errores de sintaxis.
«Permission denied» al escribir en un volumenEl mapa de UIDs: UserNS=keep-id:uid=...,gid=... o podman unshare chown.
No arranca tras reiniciar¿Linger activado? ¿Tiene [Install]?
El puerto no respondepodman ps; ¿puerto < 1024?; ¿publicas en 127.0.0.1 y accedes desde otra máquina?
Un contenedor no encuentra a otro por nombre¿Están en la misma red (Network=)? ¿Usas el ContainerName=?
Falla al descargar la imagenNombre completo con registro; podman pull a mano para ver el error real.
Se llena el discopodman system df para ver el uso y podman system prune para limpiar lo que no se usa.

Qué sí necesita root (una vez) #

Rootless no significa que no necesites privilegios nunca, sino que los necesitas al preparar la máquina y no para ejecutar cosas:

Tarea¿Root?
Instalar podman y uidmapSí, una vez
Rangos en /etc/subuid y /etc/subgidSí, una vez (normalmente ya vienen)
Bajar el umbral de puertos con sysctlSí, y es opcional
loginctl enable-lingerSegún polkit
Descargar imágenes, crear contenedores, servicios QuadletNo

El laboratorio y lo que he probado #

Está en la carpeta lab-podman/ del repositorio de laboratorios. Los scripts son ./comprobar.sh (diagnóstico), ./instalar.sh (con --solo-validar para no tocar nada) y ./desinstalar.sh (con --purgar para borrar también los datos), más permisos/demo.sh para la demostración de UIDs.

Para ser claro con lo que está comprobado y lo que no:

  • Probado (Ubuntu 24.04, Podman 4.9.3, usuario sin privilegios): la demo de permisos de principio a fin, el diagnóstico, y que el generador de Quadlet acepta los cuatro ficheros y produce las unidades que he enseñado.
  • No probado: el arranque real de los servicios (systemctl --user start, la descarga de las imágenes y la conexión de Adminer a PostgreSQL), porque mi entorno de pruebas no tenía sesión de systemd de usuario ni acceso a los registros. Si lo ejecutas y algo falla, el journalctl --user te dirá qué.
  • Versiones: las salidas son de Podman 4.9.3. En Podman 5 cambian cosas (la red por defecto, el backend netavark, tipos nuevos de unidad), pero los conceptos y los ficheros de esta entrada son los mismos.

Para quedarte con algo #

  • Rootless = sin demonio y sin root: el root del contenedor eres tú, y los demás UIDs de dentro son un rango subordinado: el UID N de dentro es el 165535 + N de fuera, con los números de tu /etc/subuid.
  • Casi todos los problemas de permisos son ese mapa. --userns=keep-id sólo no basta si el USER de la imagen no es tu UID: usa keep-id:uid=...,gid=..., o podman unshare chown, o un volumen con nombre.
  • Un podman run que no está escrito en un fichero es un contenedor que acabarás perdiendo. Quadlet convierte la configuración en ficheros que puedes versionar.
  • daemon-reload tras cada cambio, --dryrun para validar y linger para que arranque con la máquina.
  • Guarda los ficheros de ~/.config/containers/systemd/ en un repositorio.

¿Comentarios? Esta entrada tiene un hilo en Mastodon: responde allí y la conversación se queda en el fediverso.

Cargando comentarios desde mastodon.social…

Ingrese la dirección de su instancia


Más posts como este