<?xml version="1.0" encoding="utf-8" standalone="yes"?><?xml-stylesheet href="/feed_style.xsl" type="text/xsl"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:media="https://www.rssboard.org/media-rss"><channel><title>Systemd – El blog de Ignacio</title><link>https://www.igalvan.es/tags/systemd/</link><description>Entradas de Systemd en El blog de Ignacio</description><generator>Hugo -- gohugo.io</generator><language>es</language><copyright>Ignacio Galván Vitas</copyright><lastBuildDate>Sun, 08 Nov 2026 00:00:00 +0000</lastBuildDate><atom:link href="https://www.igalvan.es/tags/systemd/index.xml" rel="self" type="application/rss+xml"/><icon>https://www.igalvan.es/logo.svg</icon><item><title>Podman rootless sin sudo ni Docker: de `podman run` a un servicio con Quadlet</title><link>https://www.igalvan.es/posts/2026/podman-rootless-sin-sudo-ni-docker/</link><pubDate>Sun, 08 Nov 2026 00:00:00 +0000</pubDate><guid>https://www.igalvan.es/posts/2026/podman-rootless-sin-sudo-ni-docker/</guid><description><![CDATA[<p>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 <strong>su configuración entera vive
en el historial de tu shell</strong>: un <code>podman run</code> 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.</p>
<p>Esta entrada va de las dos cosas que hacen falta para salir de ahí sin
privilegios:</p>
<ol>
<li><strong>Entender qué significa ejecutar contenedores rootless</strong> (sin demonio y sin
root), porque casi todos los problemas que vas a encontrar salen de ahí.</li>
<li><strong>Dejar de escribir <code>podman run</code> a mano</strong>, describiendo los contenedores en
ficheros que systemd arranca, reinicia y vigila: eso se llama <em>Quadlet</em>.</li>
</ol>
<p>Todo el código está en un laboratorio que puedes ejecutar. Las salidas de
terminal de las secciones sobre permisos son reales, capturadas con <strong>Podman
4.9.3 en Ubuntu 24.04</strong> 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
<a href="https://www.dailymotion.com/video/xbuxh4i" target="_blank" rel="noopener">la versión en vídeo</a>.</p>
<h2 id="qué-es-rootless-y-por-qué-importa">Qué es «rootless» y por qué importa <a class="ancla" href="#qu%c3%a9-es-rootless-y-por-qu%c3%a9-importa" aria-label="Enlace a esta sección">#</a></h2>
<p>Con Docker, las órdenes las ejecuta un demonio (<code>dockerd</code>) que corre como root.
Tu usuario le habla por un socket, y quien puede hablar con ese socket (el
grupo <code>docker</code>) puede, en la práctica, hacer lo que quiera en la máquina: es
equivalente a tener root sin escribir <code>sudo</code>.</p>
<p>Podman es distinto en dos cosas:</p>
<ul>
<li><strong>No hay demonio.</strong> Cada <code>podman run</code> es un proceso normal de tu usuario que
lanza el contenedor. No hay ningún servicio privilegiado escuchando.</li>
<li><strong>El contenedor corre con tu usuario</strong>, dentro de un <em>user namespace</em>. El
<code>root</code> 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.</li>
</ul>
<p>El truco es una tabla de correspondencia de UIDs. Dentro de un contenedor hay
muchos usuarios (root, www-data, postgres&hellip;), pero tu usuario real es uno solo.
Por eso el sistema te reserva un rango de UIDs «subordinados» en <code>/etc/subuid</code> y
<code>/etc/subgid</code>, y Podman mapea los UIDs de dentro a ese rango. Puedes ver el mapa
de tu sesión:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>usuario@equipo:~$ podman unshare cat /proc/self/uid_map
</span></span><span style="display:flex;"><span>         <span style="color:#ae81ff">0</span>      <span style="color:#ae81ff">30033</span>          <span style="color:#ae81ff">1</span>
</span></span><span style="display:flex;"><span>         <span style="color:#ae81ff">1</span>     <span style="color:#ae81ff">165536</span>      <span style="color:#ae81ff">65536</span></span></span></code></pre></div>
</div>
<p>Cada fila dice: <em>UID de dentro, UID de fuera, cuántos</em>. Aquí el usuario es el
30033 (el tuyo será probablemente el 1000). Lo que significa:</p>
<ul>
<li>El UID 0 de dentro (root) <strong>es tu usuario</strong> de fuera.</li>
<li>Los UIDs 1 a 65536 de dentro son del 165536 en adelante de fuera. Es decir, el
UID <code>N</code> de dentro es el <code>165535 + N</code> de fuera.</li>
</ul>
<p>Guarda esa fórmula. Explica los dos tercios de los problemas de permisos que
vas a encontrar.</p>
<h2 id="instalación-y-comprobaciones">Instalación y comprobaciones <a class="ancla" href="#instalaci%c3%b3n-y-comprobaciones" aria-label="Enlace a esta sección">#</a></h2>
<p>Instalar sí necesita privilegios, una vez:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>usuario@equipo:~$ sudo apt install podman uidmap</span></span></code></pre></div>
</div>
<p><code>uidmap</code> aporta <code>newuidmap</code> y <code>newgidmap</code>, los programas que permiten a un
usuario normal crear el mapa anterior. A partir de ahí no hace falta <code>sudo</code> para
nada más. El laboratorio trae un script de diagnóstico que lo comprueba todo y no
modifica nada:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>usuario@equipo:~/lab-podman$ ./comprobar.sh
</span></span><span style="display:flex;"><span>Diagnóstico para el usuario: usuario <span style="color:#f92672">(</span>uid 1000<span style="color:#f92672">)</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">[</span> OK  <span style="color:#f92672">]</span> podman instalado: podman version 4.9.3
</span></span><span style="display:flex;"><span><span style="color:#f92672">[</span> OK  <span style="color:#f92672">]</span> podman funciona en modo rootless
</span></span><span style="display:flex;"><span><span style="color:#f92672">[</span> OK  <span style="color:#f92672">]</span> /etc/subuid: usuario:100000:65536
</span></span><span style="display:flex;"><span><span style="color:#f92672">[</span> OK  <span style="color:#f92672">]</span> /etc/subgid: usuario:100000:65536
</span></span><span style="display:flex;"><span><span style="color:#f92672">[</span> OK  <span style="color:#f92672">]</span> newuidmap y newgidmap disponibles
</span></span><span style="display:flex;"><span><span style="color:#f92672">[</span> OK  <span style="color:#f92672">]</span> generador de Quadlet: /usr/lib/systemd/system-generators/podman-system-generator
</span></span><span style="display:flex;"><span>...</span></span></code></pre></div>
</div>
<p>(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
<code>salidas/comprobar-sandbox.txt</code> y es interesante: ese entorno no tenía una
sesión de login real y el script lo detecta y lo explica.)</p>
<p>Qué comprueba y por qué importa cada cosa:</p>
<ul>
<li><strong><code>podman info</code> dice <code>Rootless: true</code>.</strong> Si no, algo falta (casi siempre
<code>uidmap</code> o el rango de subuid).</li>
<li><strong>Entradas en <code>/etc/subuid</code> y <code>/etc/subgid</code>.</strong> Sin ellas Podman no puede crear
el espacio de usuario. Las añade root con <code>usermod --add-subuids</code> y
<code>--add-subgids</code> (en Ubuntu suelen venir ya con el usuario).</li>
<li><strong>El generador de Quadlet</strong>, que existe desde Podman 4.4.</li>
<li><strong>Una sesión de login real</strong>: <code>systemctl --user</code> necesita <code>XDG_RUNTIME_DIR</code>, que
no existe tras un <code>su</code> o <code>sudo -u</code>.</li>
<li><strong>El linger</strong>, del que hablaré más abajo.</li>
<li><strong>El umbral de puertos sin privilegios</strong>, que también.</li>
</ul>
<p>Una prueba de humo, con nombre de imagen <strong>completo</strong>:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>usuario@equipo:~$ podman run --rm docker.io/library/alpine:3 echo hola
</span></span><span style="display:flex;"><span>hola</span></span></code></pre></div>
</div>
<p>Escribo <code>docker.io/library/alpine:3</code> y no <code>alpine</code> 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 (<code>docker.io</code>, <code>quay.io</code>, <code>ghcr.io</code>&hellip;): no tener Docker instalado no te
impide usar sus imágenes.</p>
<p>Imágenes y contenedores viven en tu carpeta personal
(<code>~/.local/share/containers/storage</code>), no en <code>/var/lib</code>. Cada usuario tiene los
suyos y no se ven entre sí.</p>
<h2 id="los-tres-sitios-donde-rootless-te-muerde">Los tres sitios donde rootless te muerde <a class="ancla" href="#los-tres-sitios-donde-rootless-te-muerde" aria-label="Enlace a esta sección">#</a></h2>
<h3 id="1-permisos-de-los-volúmenes">1. Permisos de los volúmenes <a class="ancla" href="#1-permisos-de-los-vol%c3%bamenes" aria-label="Enlace a esta sección">#</a></h3>
<p>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.</p>
<p>Lo he montado como demostración en el laboratorio, <code>permisos/demo.sh</code>. Una
imagen mínima (sin descargar nada) cuyo proceso corre como <strong>UID 1000 dentro del
contenedor</strong>, como harían muchas imágenes reales que declaran un <code>USER</code> sin
privilegios, e intenta crear un fichero en una carpeta tuya. Aquí mi usuario es el
30033, no el 1000. Lo que pasa:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span><span style="color:#f92672">===</span> A<span style="color:#f92672">)</span> Sin opciones: el UID <span style="color:#ae81ff">1000</span> de dentro no es tu usuario de fuera
</span></span><span style="display:flex;"><span>dentro: uid<span style="color:#f92672">=</span><span style="color:#ae81ff">1000</span> gid<span style="color:#f92672">=</span><span style="color:#ae81ff">0</span>
</span></span><span style="display:flex;"><span>no puedo escribir en /datos: Permission denied</span></span></code></pre></div>
</div>
<p>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.</p>
<p>La primera idea es probar <code>--userns=keep-id</code>, que conserva tu UID dentro del
contenedor. Y <strong>no funciona</strong>:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span><span style="color:#f92672">===</span> B<span style="color:#f92672">)</span> --userns<span style="color:#f92672">=</span>keep-id: tu UID se conserva, pero el proceso sigue siendo el <span style="color:#ae81ff">1000</span>
</span></span><span style="display:flex;"><span>dentro: uid<span style="color:#f92672">=</span><span style="color:#ae81ff">1000</span> gid<span style="color:#f92672">=</span><span style="color:#ae81ff">0</span>
</span></span><span style="display:flex;"><span>no puedo escribir en /datos: Permission denied</span></span></code></pre></div>
</div>
<p><code>keep-id</code> hace que <em>tu</em> UID de fuera (30033) sea el mismo dentro. Pero el
proceso corre como el 1000 por el <code>USER</code> de la imagen, que ya no coincide con
nadie. Lo que necesitas es decirle a Podman que <strong>el 1000 de dentro seas tú</strong>:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span><span style="color:#f92672">===</span> C<span style="color:#f92672">)</span> --userns<span style="color:#f92672">=</span>keep-id:uid<span style="color:#f92672">=</span>1000,gid<span style="color:#f92672">=</span>1000: el <span style="color:#ae81ff">1000</span> de dentro eres TÚ de fuera
</span></span><span style="display:flex;"><span>dentro: uid<span style="color:#f92672">=</span><span style="color:#ae81ff">1000</span> gid<span style="color:#f92672">=</span><span style="color:#ae81ff">0</span>
</span></span><span style="display:flex;"><span>escrito /datos/creado-por-contenedor.txt
</span></span><span style="display:flex;"><span>en el disco <span style="color:#f92672">(</span>uid:gid numéricos<span style="color:#f92672">)</span>:
</span></span><span style="display:flex;"><span>-rw-r--r-- <span style="color:#ae81ff">1</span> <span style="color:#ae81ff">30033</span> <span style="color:#ae81ff">165536</span> <span style="color:#ae81ff">5</span> Nov  <span style="color:#ae81ff">4</span> 20:27 creado-por-contenedor.txt</span></span></code></pre></div>
</div>
<p>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
<code>UserNS=keep-id:uid=1000,gid=1000</code>.</p>
<p>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 <code>chown</code> a un
UID subordinado, pero <code>podman unshare</code> te mete en el espacio de usuarios de
Podman, y desde ahí sí:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span><span style="color:#f92672">===</span> D<span style="color:#f92672">)</span> Sin keep-id, pero con la carpeta dada al UID <span style="color:#ae81ff">1000</span> *de dentro*
</span></span><span style="display:flex;"><span>carpeta vista desde fuera:
</span></span><span style="display:flex;"><span>drwxr-xr-x <span style="color:#ae81ff">2</span> <span style="color:#ae81ff">166535</span> <span style="color:#ae81ff">166535</span> <span style="color:#ae81ff">4096</span> Nov  <span style="color:#ae81ff">4</span> 20:27 /tmp/tmp.qCpiztyWeY/datos
</span></span><span style="display:flex;"><span>dentro: uid<span style="color:#f92672">=</span><span style="color:#ae81ff">1000</span> gid<span style="color:#f92672">=</span><span style="color:#ae81ff">0</span>
</span></span><span style="display:flex;"><span>escrito /datos/creado-por-contenedor.txt
</span></span><span style="display:flex;"><span>en el disco <span style="color:#f92672">(</span>uid:gid numéricos<span style="color:#f92672">)</span>:
</span></span><span style="display:flex;"><span>-rw-r--r-- <span style="color:#ae81ff">1</span> <span style="color:#ae81ff">166535</span> <span style="color:#ae81ff">30033</span> <span style="color:#ae81ff">5</span> Nov  <span style="color:#ae81ff">4</span> 20:27 creado-por-contenedor.txt</span></span></code></pre></div>
</div>
<p>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 <code>podman unshare</code> también. Es la
solución adecuada para datos que sólo debe tocar el contenedor; para una carpeta
de trabajo tuya, <code>keep-id:uid=...</code> es mejor.</p>
<p>Tres matices:</p>
<ul>
<li><strong>Si la imagen corre como root</strong>, que es lo que hacen muchas al arrancar, no
tienes este problema: el root de dentro eres tú.</li>
<li><strong>Los volúmenes con nombre</strong> (<code>podman volume create</code>, o <code>.volume</code> 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.</li>
<li><strong>En Ubuntu las carpetas nuevas suelen salir con modo 775</strong> y el <code>gid</code> 0 del
contenedor se corresponde con tu grupo, así que a veces el contenedor <em>sí</em>
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, <code>166535:30033</code>).</li>
</ul>
<p>Y una nota para quien venga de Fedora o Red Hat: allí los volúmenes suelen
llevar <code>:Z</code> por SELinux. En Ubuntu la seguridad la lleva AppArmor y
normalmente no hace falta.</p>
<h3 id="2-puertos-por-debajo-del-1024">2. Puertos por debajo del 1024 <a class="ancla" href="#2-puertos-por-debajo-del-1024" aria-label="Enlace a esta sección">#</a></h3>
<p>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:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>usuario@equipo:~$ sysctl net.ipv4.ip_unprivileged_port_start</span></span></code></pre></div>
</div>
<p>Lo más sencillo es publicar un puerto alto (<code>8080</code>) 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.</p>
<p>Una buena costumbre: publica en <code>127.0.0.1</code> si sólo quieres acceder tú.
<code>-p 8080:8080</code> abre el puerto en <strong>todas</strong> las interfaces; <code>-p 127.0.0.1:8080:8080</code> sólo en local.</p>
<h3 id="3-la-red">3. La red <a class="ancla" href="#3-la-red" aria-label="Enlace a esta sección">#</a></h3>
<p>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 <strong>pasta</strong>
(antes era <code>slirp4netns</code>). 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.</p>
<p>Otra diferencia entre versiones: Podman 5 usa siempre <em>netavark</em> para las redes
entre contenedores; en Podman 4 podía ser CNI (es lo que usa mi entorno de
pruebas).</p>
<h2 id="el-problema-podman-run-no-sobrevive-a-un-reinicio">El problema: <code>podman run</code> no sobrevive a un reinicio <a class="ancla" href="#el-problema-podman-run-no-sobrevive-a-un-reinicio" aria-label="Enlace a esta sección">#</a></h2>
<p>Con todo lo anterior, esto funciona:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>usuario@equipo:~$ podman run -d --name lab-db --network lab <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span>    -v lab-datos:/var/lib/postgresql/data <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span>    --env-file ~/.config/lab-podman/db.env <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span>    -e POSTGRES_USER<span style="color:#f92672">=</span>lab -e POSTGRES_DB<span style="color:#f92672">=</span>lab <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span>    docker.io/library/postgres:16</span></span></code></pre></div>
</div>
<p>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 <code>--restart=always</code>, 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 <strong>Quadlet</strong>. (<code>podman generate systemd</code> fabrica unidades a partir de un
contenedor ya creado, pero está marcado como obsoleto a favor de Quadlet.)</p>
<h2 id="quadlet-describe-el-contenedor-en-un-fichero">Quadlet: describe el contenedor en un fichero <a class="ancla" href="#quadlet-describe-el-contenedor-en-un-fichero" aria-label="Enlace a esta sección">#</a></h2>
<p>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 <code>~/.config/containers/systemd/</code> (la
<a href="https://docs.podman.io/en/latest/markdown/podman-systemd.unit.5.html" target="_blank" rel="noopener">documentación</a>
lista más rutas; por ejemplo, lo que pongas en <code>/etc/containers/systemd/users/</code>
se ejecuta cuando cualquier usuario inicia sesión). Hay un tipo de fichero por
cosa:</p>
<table>
  <thead>
      <tr>
          <th>Extensión</th>
          <th>Qué describe</th>
          <th>Servicio generado</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td><code>.container</code></td>
          <td>un contenedor</td>
          <td><code>nombre.service</code></td>
      </tr>
      <tr>
          <td><code>.volume</code></td>
          <td>un volumen con nombre</td>
          <td><code>nombre-volume.service</code></td>
      </tr>
      <tr>
          <td><code>.network</code></td>
          <td>una red</td>
          <td><code>nombre-network.service</code></td>
      </tr>
  </tbody>
</table>
<p>Según la versión de Podman hay más tipos (<code>.pod</code>, <code>.kube</code>, <code>.build</code>&hellip;); mira la
documentación de la tuya.</p>
<p>El laboratorio monta un servicio típico: <strong>PostgreSQL con su volumen, en una red
propia, y una interfaz web (Adminer) que habla con él</strong>. Son cuatro ficheros
pequeños.</p>
<p>La red, <code>lab.network</code>, y el volumen, <code>lab-datos.volume</code>:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-ini" data-lang="ini"><span style="display:flex;"><span><span style="color:#66d9ef">[Network]</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">NetworkName</span><span style="color:#f92672">=</span><span style="color:#e6db74">lab</span></span></span></code></pre></div>
</div>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-ini" data-lang="ini"><span style="display:flex;"><span><span style="color:#66d9ef">[Volume]</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">VolumeName</span><span style="color:#f92672">=</span><span style="color:#e6db74">lab-datos</span></span></span></code></pre></div>
</div>
<p>La base de datos, <code>lab-db.container</code>:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-ini" data-lang="ini"><span style="display:flex;"><span><span style="color:#66d9ef">[Unit]</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">Description</span><span style="color:#f92672">=</span><span style="color:#e6db74">PostgreSQL del laboratorio (Podman rootless)</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">[Container]</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">ContainerName</span><span style="color:#f92672">=</span><span style="color:#e6db74">lab-db</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">Image</span><span style="color:#f92672">=</span><span style="color:#e6db74">docker.io/library/postgres:16</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">Network</span><span style="color:#f92672">=</span><span style="color:#e6db74">lab.network</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">Volume</span><span style="color:#f92672">=</span><span style="color:#e6db74">lab-datos.volume:/var/lib/postgresql/data</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">EnvironmentFile</span><span style="color:#f92672">=</span><span style="color:#e6db74">%h/.config/lab-podman/db.env</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">Environment</span><span style="color:#f92672">=</span><span style="color:#e6db74">POSTGRES_USER=lab</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">Environment</span><span style="color:#f92672">=</span><span style="color:#e6db74">POSTGRES_DB=lab</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">HealthCmd</span><span style="color:#f92672">=</span><span style="color:#e6db74">pg_isready -U lab -d lab</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">HealthInterval</span><span style="color:#f92672">=</span><span style="color:#e6db74">10s</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">HealthRetries</span><span style="color:#f92672">=</span><span style="color:#e6db74">5</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">[Service]</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">Restart</span><span style="color:#f92672">=</span><span style="color:#e6db74">always</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">TimeoutStartSec</span><span style="color:#f92672">=</span><span style="color:#e6db74">300</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">[Install]</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">WantedBy</span><span style="color:#f92672">=</span><span style="color:#e6db74">default.target</span></span></span></code></pre></div>
</div>
<p>Y la interfaz web, <code>lab-adminer.container</code>:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-ini" data-lang="ini"><span style="display:flex;"><span><span style="color:#66d9ef">[Unit]</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">Description</span><span style="color:#f92672">=</span><span style="color:#e6db74">Adminer: interfaz web para la base de datos del laboratorio</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">Requires</span><span style="color:#f92672">=</span><span style="color:#e6db74">lab-db.service</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">After</span><span style="color:#f92672">=</span><span style="color:#e6db74">lab-db.service</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">[Container]</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">ContainerName</span><span style="color:#f92672">=</span><span style="color:#e6db74">lab-adminer</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">Image</span><span style="color:#f92672">=</span><span style="color:#e6db74">docker.io/library/adminer:latest</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">Network</span><span style="color:#f92672">=</span><span style="color:#e6db74">lab.network</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">PublishPort</span><span style="color:#f92672">=</span><span style="color:#e6db74">127.0.0.1:8080:8080</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">Environment</span><span style="color:#f92672">=</span><span style="color:#e6db74">ADMINER_DEFAULT_SERVER=lab-db</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">AutoUpdate</span><span style="color:#f92672">=</span><span style="color:#e6db74">registry</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">[Service]</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">Restart</span><span style="color:#f92672">=</span><span style="color:#e6db74">always</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">[Install]</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">WantedBy</span><span style="color:#f92672">=</span><span style="color:#e6db74">default.target</span></span></span></code></pre></div>
</div>
<p>Qué hace cada pieza:</p>
<ul>
<li><strong><code>Network=lab.network</code></strong> y <strong><code>Volume=lab-datos.volume:...</code></strong>: en vez de un
nombre, apuntan a las unidades <code>.network</code> y <code>.volume</code>. Quadlet añade solo las
dependencias: antes de arrancar el contenedor se crean la red y el volumen.</li>
<li><strong>Sin <code>PublishPort</code> en la base de datos</strong>: no es accesible desde fuera. Sólo
Adminer, que está en la misma red, la ve, y la encuentra por el nombre del
contenedor (<code>lab-db</code>).</li>
<li><strong><code>EnvironmentFile=%h/...</code></strong>: 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 <code>%h</code> es el <em>specifier</em> de systemd para tu carpeta
personal.</li>
<li><strong><code>HealthCmd</code> y compañía</strong>: un chequeo de salud, para que <code>podman ps</code> y
systemd sepan si la base de datos responde y no sólo si el proceso existe.</li>
<li><strong>La etiqueta <code>postgres:16</code> fija</strong> y <strong><code>AutoUpdate=registry</code></strong> en Adminer: una
base de datos no debería actualizarse sola, una interfaz web sí puede. Hablo de
esto más abajo.</li>
<li><strong><code>[Service]</code></strong> y <strong><code>[Install]</code></strong>: son secciones normales de systemd. Con
<code>WantedBy=default.target</code> se arranca con la sesión de usuario; es lo que haría
<code>systemctl enable</code>, que con Quadlet no puedes ejecutar porque las unidades
generadas son transitorias.</li>
</ul>
<h3 id="qué-fabrica-quadlet-por-debajo">Qué fabrica Quadlet por debajo <a class="ancla" href="#qu%c3%a9-fabrica-quadlet-por-debajo" aria-label="Enlace a esta sección">#</a></h3>
<p>No es magia: traduce tus ficheros a unidades de systemd normales cuyo
<code>ExecStart</code> es un <code>podman run</code>. Puedes verlo sin instalar nada con el modo
<code>--dryrun</code> del generador. Este es el extracto de la base de datos, tal cual lo
generó Podman 4.9.3 en mis pruebas:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>ExecStart=/usr/bin/podman run --name=lab-db --cidfile=%t/%N.cid --replace --rm
</span></span><span style="display:flex;"><span>  --cgroups=split --network=lab --sdnotify=conmon -d -v lab-datos:/var/lib/postgresql/data
</span></span><span style="display:flex;"><span>  --env POSTGRES_DB=lab --env POSTGRES_USER=lab --env-file %h/.config/lab-podman/db.env
</span></span><span style="display:flex;"><span>  --health-cmd &#34;pg_isready -U lab -d lab&#34; --health-interval 10s --health-retries 5
</span></span><span style="display:flex;"><span>  docker.io/library/postgres:16</span></span></code></pre></div>
</div>
<p>(Lo he partido en varias líneas para que se lea; en la salida original es una
sola línea.) Es tu <code>podman run</code> de antes, pero generado desde un fichero
declarativo, con <code>--replace</code>, <code>--rm</code> y la integración con systemd añadidas. También
genera <code>Requires=</code> y <code>After=</code> hacia la red y el volumen, que es de donde sale el
orden de arranque.</p>
<h3 id="validar-cargar-y-arrancar">Validar, cargar y arrancar <a class="ancla" href="#validar-cargar-y-arrancar" aria-label="Enlace a esta sección">#</a></h3>
<p>El laboratorio trae <code>instalar.sh</code>, que hace los pasos en orden y no usa <code>sudo</code>:
valida con Quadlet, crea la contraseña aleatoria en <code>~/.config/lab-podman/db.env</code>
con modo 600, copia los ficheros a <code>~/.config/containers/systemd/</code>, recarga
systemd y arranca los servicios. Sin ejecutarlo, puedes sólo validar:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>usuario@equipo:~/lab-podman$ ./instalar.sh --solo-validar
</span></span><span style="display:flex;"><span>&gt;&gt; Validando los ficheros Quadlet con /usr/lib/systemd/system-generators/podman-system-generator
</span></span><span style="display:flex;"><span>   Válidos: <span style="color:#ae81ff">4</span> fichero<span style="color:#f92672">(</span>s<span style="color:#f92672">)</span>.</span></span></code></pre></div>
</div>
<p>Los pasos manuales, para que veas qué hay detrás. Todo es <code>--user</code>: son servicios
de tu usuario, no del sistema.</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>usuario@equipo:~$ /usr/lib/systemd/system-generators/podman-system-generator --user --dryrun
</span></span><span style="display:flex;"><span>usuario@equipo:~$ systemctl --user daemon-reload
</span></span><span style="display:flex;"><span>usuario@equipo:~$ systemctl --user start lab-db.service lab-adminer.service
</span></span><span style="display:flex;"><span>usuario@equipo:~$ systemctl --user status lab-db.service</span></span></code></pre></div>
</div>
<p>Los ficheros Quadlet se leen al arrancar y en cada <code>daemon-reload</code>: cada vez que
edites uno, repite el <code>daemon-reload</code> y reinicia el servicio. Los logs están en
el journal:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>usuario@equipo:~$ journalctl --user -u lab-db.service -f</span></span></code></pre></div>
</div>
<p>(Si no ves nada, comprueba que el journal sea persistente y que tu usuario pueda
leerlo.) También tienes <code>podman ps</code> y <code>podman logs lab-db</code>; los contenedores se
llaman <code>lab-db</code> y <code>lab-adminer</code> por el <code>ContainerName=</code> (por defecto serían
<code>systemd-lab-db</code>&hellip;). Pero la fuente de verdad pasa a ser systemd.</p>
<h2 id="que-arranque-solo-al-iniciar-el-equipo-linger">Que arranque solo al iniciar el equipo: linger <a class="ancla" href="#que-arranque-solo-al-iniciar-el-equipo-linger" aria-label="Enlace a esta sección">#</a></h2>
<p>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 <em>linger</em>:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>usuario@equipo:~$ loginctl enable-linger usuario
</span></span><span style="display:flex;"><span>usuario@equipo:~$ loginctl show-user usuario --property<span style="color:#f92672">=</span>Linger
</span></span><span style="display:flex;"><span>Linger<span style="color:#f92672">=</span>yes</span></span></code></pre></div>
</div>
<p>Según cómo esté configurado polkit, puede pedirte autenticarte. Con linger y el
<code>[Install]</code> de los ficheros, los servicios vuelven solos tras cada reinicio.</p>
<h2 id="actualizaciones-automáticas">Actualizaciones automáticas <a class="ancla" href="#actualizaciones-autom%c3%a1ticas" aria-label="Enlace a esta sección">#</a></h2>
<p><code>AutoUpdate=registry</code> marca el contenedor para que Podman compruebe si hay una
imagen nueva en el registro. Requiere un nombre de imagen <strong>completo</strong>, porque
Podman necesita saber de dónde descargarla. También existe <code>AutoUpdate=local</code>,
que compara con la copia local. Las comprobaciones las lanza un temporizador que
trae Podman:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>usuario@equipo:~$ podman auto-update --dry-run
</span></span><span style="display:flex;"><span>usuario@equipo:~$ systemctl --user enable --now podman-auto-update.timer</span></span></code></pre></div>
</div>
<p>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.</p>
<p>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 (<code>postgres:16</code>) y actualizar a mano, leyendo antes
las notas de versión.</p>
<h2 id="cuando-algo-no-va-chuleta-de-diagnóstico">Cuando algo no va: chuleta de diagnóstico <a class="ancla" href="#cuando-algo-no-va-chuleta-de-diagn%c3%b3stico" aria-label="Enlace a esta sección">#</a></h2>
<table>
  <thead>
      <tr>
          <th>Síntoma</th>
          <th>Qué mirar</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td><code>Failed to connect to bus</code> con <code>systemctl --user</code></td>
          <td>Sesión sin <code>XDG_RUNTIME_DIR</code> (típico tras <code>su</code> o <code>sudo -u</code>). Usa un login real o <code>machinectl shell usuario@</code>.</td>
      </tr>
      <tr>
          <td>El servicio no aparece tras crear el fichero</td>
          <td><code>daemon-reload</code>, y luego el <code>--dryrun</code> del generador para ver errores de sintaxis.</td>
      </tr>
      <tr>
          <td>«Permission denied» al escribir en un volumen</td>
          <td>El mapa de UIDs: <code>UserNS=keep-id:uid=...,gid=...</code> o <code>podman unshare chown</code>.</td>
      </tr>
      <tr>
          <td>No arranca tras reiniciar</td>
          <td>¿Linger activado? ¿Tiene <code>[Install]</code>?</td>
      </tr>
      <tr>
          <td>El puerto no responde</td>
          <td><code>podman ps</code>; ¿puerto &lt; 1024?; ¿publicas en <code>127.0.0.1</code> y accedes desde otra máquina?</td>
      </tr>
      <tr>
          <td>Un contenedor no encuentra a otro por nombre</td>
          <td>¿Están en la misma red (<code>Network=</code>)? ¿Usas el <code>ContainerName=</code>?</td>
      </tr>
      <tr>
          <td>Falla al descargar la imagen</td>
          <td>Nombre completo con registro; <code>podman pull</code> a mano para ver el error real.</td>
      </tr>
      <tr>
          <td>Se llena el disco</td>
          <td><code>podman system df</code> para ver el uso y <code>podman system prune</code> para limpiar lo que no se usa.</td>
      </tr>
  </tbody>
</table>
<h2 id="qué-sí-necesita-root-una-vez">Qué sí necesita root (una vez) <a class="ancla" href="#qu%c3%a9-s%c3%ad-necesita-root-una-vez" aria-label="Enlace a esta sección">#</a></h2>
<p>Rootless no significa que no necesites privilegios nunca, sino que los necesitas
<strong>al preparar la máquina</strong> y no para ejecutar cosas:</p>
<table>
  <thead>
      <tr>
          <th>Tarea</th>
          <th>¿Root?</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>Instalar <code>podman</code> y <code>uidmap</code></td>
          <td>Sí, una vez</td>
      </tr>
      <tr>
          <td>Rangos en <code>/etc/subuid</code> y <code>/etc/subgid</code></td>
          <td>Sí, una vez (normalmente ya vienen)</td>
      </tr>
      <tr>
          <td>Bajar el umbral de puertos con sysctl</td>
          <td>Sí, y es opcional</td>
      </tr>
      <tr>
          <td><code>loginctl enable-linger</code></td>
          <td>Según polkit</td>
      </tr>
      <tr>
          <td>Descargar imágenes, crear contenedores, servicios Quadlet</td>
          <td>No</td>
      </tr>
  </tbody>
</table>
<h2 id="el-laboratorio-y-lo-que-he-probado">El laboratorio y lo que he probado <a class="ancla" href="#el-laboratorio-y-lo-que-he-probado" aria-label="Enlace a esta sección">#</a></h2>
<p>Está en la carpeta
<a href="https://codeberg.org/igalvan/blog-public-code/src/branch/main/lab-podman" target="_blank" rel="noopener"><code>lab-podman/</code></a>
del repositorio de laboratorios. Los scripts son <code>./comprobar.sh</code> (diagnóstico),
<code>./instalar.sh</code> (con <code>--solo-validar</code> para no tocar nada) y <code>./desinstalar.sh</code>
(con <code>--purgar</code> para borrar también los datos), más <code>permisos/demo.sh</code> para la
demostración de UIDs.</p>
<p>Para ser claro con lo que está comprobado y lo que no:</p>
<ul>
<li><strong>Probado</strong> (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.</li>
<li><strong>No probado</strong>: el arranque real de los servicios (<code>systemctl --user start</code>,
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 <code>journalctl --user</code> te dirá qué.</li>
<li><strong>Versiones</strong>: 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.</li>
</ul>
<h2 id="para-quedarte-con-algo">Para quedarte con algo <a class="ancla" href="#para-quedarte-con-algo" aria-label="Enlace a esta sección">#</a></h2>
<ul>
<li>Rootless = sin demonio y sin root: el <code>root</code> del contenedor eres tú, y los
demás UIDs de dentro son un rango subordinado: el UID <code>N</code> de dentro es el
<code>165535 + N</code> de fuera, con los números de tu <code>/etc/subuid</code>.</li>
<li>Casi todos los problemas de permisos son ese mapa. <code>--userns=keep-id</code> sólo no
basta si el <code>USER</code> de la imagen no es tu UID: usa <code>keep-id:uid=...,gid=...</code>, o
<code>podman unshare chown</code>, o un volumen con nombre.</li>
<li>Un <code>podman run</code> que no está escrito en un fichero es un contenedor que acabarás
perdiendo. Quadlet convierte la configuración en ficheros que puedes versionar.</li>
<li><code>daemon-reload</code> tras cada cambio, <code>--dryrun</code> para validar y <code>linger</code> para que
arranque con la máquina.</li>
<li>Guarda los ficheros de <code>~/.config/containers/systemd/</code> en un repositorio.</li>
</ul>
]]></description><media:thumbnail url="https://www.igalvan.es/og/base_hu_a48aaae836eeb9d0.png"/></item></channel></rss>