
Llevo un par de años moviendo todos mis servicios de Docker a Podman. Empecé por cabezonería, porque me gusta tener el control de las cosas, y acabé por necesidad, porque cada reinicio de la máquina se había convertido en un ritual en el que tenía que acordarme del orden en que arrancaba cada contenedor. Y no, eso no es infraestructura, eso es un recordatorio con fecha de caducidad. Hace unos días vi un anuncio de un banco que vendía la idea de no tener que elegir: que si te vas a Bali o te compras el último iPhone, por qué no las dos cosas. Y me hizo gracia, porque es exactamente el mismo gancho que llevas años oyendo sobre la nube: tus fotos, tus notas, tu música, tus documentos, todo ahí, todo incluido, todo gratis. La letra pequeña es que ese todo lo pagas con lo que nadie pone precio, tu dependencia y la llave de tu casa. Hoy te vengo a girar esa frase, porque en self-hosting también puedes tenerlo todo sin soltar nada a cambio, y además quiero enseñarte cómo hacerlo de forma que no tengas que administrar nada a mano. Te voy a hablar de quadlets, de Podman rootless y de qctl, la herramienta que convierte tu nube en un comando. Y de propina, cómo delegarle todo el despliegue a un modelo de lenguaje. Vamos al lío.
Depender de otros o administrar a mano: los dos sitios donde estamos
Pongámonos en situación, porque la mayoría estamos en uno de estos dos sitios y ninguno de los dos es tu nube.
El primero es depender de otros. Tus fotos en la nube de alguien, tus notas en la app de alguien, tu lector de RSS en la nube de un tercero, tu gestor de contraseñas en el servicio de otra empresa, tus documentos donde le apetezca a otra compañía. Es cómodo, no lo voy a negar. El problema es que la llave la tiene otro. El día que ese servicio cambia de precio, cierra o te limita lo que puedes hacer, tú no decides nada. Y no me refiero solo a que te suban la cuota de repente, hablo de que en un momento dado el proveedor diga que ese servicio ya no le interesa, lo apague, y tú te quedes sin tus películas, sin tus notas y sin tus fotos de golpe. Eso ha pasado, pasa y seguirá pasando.
El segundo sitio es haberte montado tu propio servidor. Ahí tienes un puñado de contenedores que arrancas tú a mano. Y oye, ya es un paso, porque tus datos son tuyos. El problema es cómo los administras. Porque autocontrol sí, pero el control lo ejerce tu memoria. Acuérdate del comando, acuérdate del orden, acuérdate del fichero que tocaste la semana pasada. Eso no es infraestructura, es una lista de la compra mental que se te cae en cuanto pasa el tiempo.
Y lo digo con conocimiento de causa, porque yo he vivido en el segundo sitio mucho tiempo. Y lo que vengo a contarte hoy es exactamente el inventario de por qué ese sitio se te acaba cayendo.
La grieta: el ritual de cada reinicio
Empieza simple. Tienes un docker-compose.yml, entras en el directorio y ejecutas:
docker compose up -d
Y funciona. Hasta que reinicias la máquina. Y aquí viene la pregunta incómoda, la que hoy casi nadie se hace en voz alta. ¿Y en qué orden arrancaba todo? Porque tu base de datos tenía que estar antes que la aplicación. La aplicación, antes que el proxy. El proxy, antes que las labels. Y eso no lo dice el compose, lo sabías tú. Estaba en tu cabeza.
Y no lo cuento como metáfora. Hace poco, con Pocket ID, tuve justo ese problema. El servicio se lanzaba a hacer su discovery OIDC antes de que el proveedor de identidad estuviera listo y moría en modo fail-closed, negándose a arrancar. Un ritual a mano no tiene dependencias, una nube declarada sí. Cada reinicio, un ritual manual. Cada ritual, una oportunidad de equivocarte.
Config dispersa y secretos en texto plano
Si el orden era un problema, la configuración es el desastre de al lado. Piénsalo un momento y verás cómo acaba tu servidor en un par de años.
El docker-compose.yml en un directorio. Los .env en otro, o en tres, o metidos dentro del propio compose. Un puerto escrito a pelo aquí, una ruta absoluta allá. Y luego, en algún sitio que ya no recuerdas, un fichero tipo secrets.txt con las contraseñas en texto plano, porque eso de moverlo a un gestor de secretos ya lo harás otro día. Ese fichero, tarde o temprano, se cuela en un commit, en un backup o en una carpeta compartida. Yo lo he visto. Y tú probablemente también.
La idea que quiero que te lleves de este bloque es la tesis del episodio en negativo. El caos no se administra, se declara. No hay ninguna cantidad de disciplina manual que arregle un modelo donde la verdad está repartida entre ficheros y tu cabeza. Hay que cambiar el modelo, no apretar más fuerte.
El daemon root, el lastre del que casi nadie habla
Y luego está el lastre de fondo, el que mucha gente no nombra porque asume que es lo normal. En Docker el motor corre como root. Hay un demonio con privilegios totales, y tus contenedores, tus montajes y tus permisos pasan por él. Cada montaje es una negociación de identidades entre root, tu usuario y el proceso de dentro. Y cuando esa negociación no cuadra, aparece el permission denied de turno.
De esto ya hablamos en un episodio anterior, donde conté por qué el mismo compose.yaml se rompía al pasarlo a rootless. No lo voy a repetir aquí, pero el dato que cambia todo es este. En Podman no hay daemon root. No hay un motor todopoderoso por encima de ti. Cada contenedor corre bajo tu usuario, y por eso la seguridad no la da el contenedor, la da quién eres cuando lo lanzas. Y si el que lanza todo es tu usuario y no root, la pregunta natural es por qué no aprovechar que systemd ya sabe lanzar y gestionar servicios como tu usuario.
¿Y si tu nube fuera un servicio de systemd?
Ese ¿y si…? tiene respuesta, y tiene nombre. En lugar de un compose que tú interpretas a mano, podrías tener ficheros que systemd lee como sus propias unidades. No un fichero aparte con su propio intérprete, sino ficheros que systemd trata como unidades de primera clase.
Porque eso te da, de golpe, todo lo que un compose a mano no te da. Orden de arranque con dependencias reales, reinicio automático, estados, logs en journalctl y arranque en el boot. Todo el andamiaje de systemd, que ya tienes y ya conoces, aplicado a tus contenedores.
El mecanismo se llama quadlet. Es un generador de systemd que viene con Podman, systemd lee tus ficheros quadlet y los convierte en unidades de verdad. Es decir, tu despliegue deja de ser un script que ejecutas y pasa a ser parte del sistema operativo. Y ahí es donde tu nube pasa de administrada a declarada.
Un quadlet: el fichero que systemd lee como unidad
¿Y cómo es un quadlet? Pues son extensiones de fichero que Podman reconoce. Tienes .container para contenedores, .volume para volúmenes, .network para redes, .pod para pods, .kube para Kubernetes. Cada tipo tiene su sección propia, [Container], [Volume], [Network], [Pod], y todas las secciones estándar de systemd pasan intactas.
Y ojo al detalle, porque es la clave de todo lo que viene después. Por cada fichero se genera un .service con su mismo nombre:
# de cada fichero, Podman genera un .service con el mismo nombre
demo.container → demo.service
demo.network → demo-network.service
demo-data.volume → demo-data-volume.service
Tu demo.container se convierte en demo.service, y demo.service es una unidad normal y corriente de systemd. La puedes arrancar, parar, ver su estado, leer sus logs. No es un dialecto nuevo, es systemd con una sección extra que sabe leer contenedores. Por eso un quadlet no se siente como una herramienta más, se siente como el sistema.
Dónde los busca systemd, y por qué los enlaces simbólicos valen
Y todo esto, ¿dónde vive? En rootless, tu Podman busca quadlets en varios sitios, y el importante para nosotros es:
~/.config/containers/systemd/
Ese directorio, junto con $XDG_RUNTIME_DIR/containers/systemd/ y los de /etc y /usr/share/containers/systemd/users/, es donde el generador mira. Y aquí está el detalle que sostiene toda la arquitectura del episodio. La documentación oficial de Quadlet dice, literalmente, que soporta enlaces simbólicos tanto para la base de los directorios de búsqueda como dentro de ellos.
Párate un segundo en esto, porque es la pieza que necesitábamos. Si Quadlet sigue symlinks, entonces tú puedes tener tus ficheros de verdad en un directorio, tu repositorio, y en ~/.config/containers/systemd/ poner solo punteros. Gestionas ficheros, pero despliegas enlaces. Y con un aviso que voy a repetir al final. El generador solo se relee en el arranque o con:
systemctl --user daemon-reload
Un cambio de quadlet sin daemon-reload sencillamente no existe.
Tu primer quadlet, en diez líneas
Basta de teoría. Tu primer quadlet cabe en tres secciones y no llega a veinte líneas. Lo creas en ~/demo-stack/ y lo llamas demo.container:
[Unit]
Description=Demo web (rootless)
[Container]
Image=docker.io/library/nginx:alpine
ContainerName=demo
PublishPort=8080:80
Network=demo.network
AutoUpdate=registry
[Service]
Restart=always
TimeoutStartSec=60
[Install]
WantedBy=default.target
Vamos por partes. En [Container] va lo que en el compose sería el services:, la imagen, el nombre del contenedor, el puerto publicado, la red a la que se une y AutoUpdate=registry, que le dice a Podman que vigile si la imagen tiene versión nueva. En [Service] usamos systemd tal cual, con Restart=always para que se levante solo si se cae y TimeoutStartSec=60 para darle margen a arrancar. Y en [Install], una sola línea, WantedBy=default.target. Esa línea es la que hace que arranque en el boot.
Y la red la declaramos en su propio fichero, demo.network:
[Network]
NetworkName=demo
Tres secciones, una red aparte y ya tienes una nube mínima, declarada. Nada de docker compose up -d, esto es código.
Transient: con quadlets no se hace systemctl enable
Y ahora un aviso que sorprende a todo el mundo que viene del systemd clásico. Con quadlets no se hace systemctl enable. Es más, no puedes. Las unidades que genera el generador son transient, temporales, generadas al vuelo, y no se habilitan como las normales.
Entonces, ¿cómo arranca solo al encender la máquina? Con esa línea que acabamos de poner, WantedBy=default.target. La persistencia la da esa sección. El generador de quadlets la aplica manualmente al construir la unidad, es él quien le dice a systemd que esto va con default.target. Por eso no es multi-user.target como en el systemd de sistema, en rootless el target correcto es default.target.
Y solo unas pocas directivas se soportan ahí, Alias, WantedBy, RequiredBy y UpheldBy. Ni más ni menos. Si intentas systemctl --user enable demo.service, te va a decir que no puede. No es un fallo tuyo, es que eso ya no se hace así.
Entra qctl: el CLI que lo convierte en un comando
Ya sabes declarar. Pero ahora imagínate con 126 stacks. Enlazar todo eso a mano en ~/.config/containers/systemd/ con ln -s es un trabajo de chinos, y un error de dedo te deja una unidad fantasma. Aquí entra el protagonista del episodio, qctl.
qctl es un CLI escrito en Rust, con licencia MIT, que hace cuatro cosas, enlaza, arranca, audita y actualiza. Se publica como binario estático para x86_64-unknown-linux-musl, así que no arrastra dependencias. La última release publicada es la v0.7.1, del 9 de noviembre de 2026, unos 4,6 MB más su checksum. Se instala en dos comandos, con su verificación de integridad incluida:
curl -LO https://github.com/atareao/qctl/releases/latest/download/qctl-linux-x86_64
curl -LO https://github.com/atareao/qctl/releases/latest/download/qctl-linux-x86_64.sha256
sha256sum -c qctl-linux-x86_64.sha256
install -m 755 qctl-linux-x86_64 ~/.local/bin/qctl
qctl --version
Y un apunte de honestidad que me parece muy didáctico. El README de qctl todavía dice que la última versión es la v0.4.0, pero la release real es la v0.7.1. La documentación se queda atrás. Lección práctica, cuando dependas de una herramienta, verifica contra las releases, no contra el README. Y fija versiones con checksum.
qctl install: enlaces, no copias
Vamos a lo que hace qctl install, que es la operación central. qctl busca tus quadlets en ./quadlets/ o en el directorio actual, y los enlaza en ~/.config/containers/systemd/. Enlaza, no copia. Si copiara, tendrías dos verdades. Enlazando, la verdad sigue siendo una sola, tu repositorio.
Y antes de tocar nada, la opción que más me gusta de toda la herramienta:
cd ~/demo-stack
qctl --dry-run install
--dry-run imprime las acciones planificadas, las verás con el prefijo DRY-RUN, sin mutar absolutamente nada. O sea, puedes ver exactamente qué enlaces se crearían antes de crear el primero. Ese enséñame el plan antes de hacerlo es lo que convierte una herramienta de administración en una herramienta en la que confías. Y el --dry-run también funciona con uninstall, start, stop, restart, update, reload, clean-volumes y purge.
Un detalle importante, install termina con un daemon-reload de systemd de usuario, que es justo lo que dijimos que era obligatorio. qctl no te deja olvidarlo.
qctl check: la guarda que evita el desastre
Y ahora la que te salva de ti mismo. Fíjate en el destino, ~/.config/containers/systemd/ es plano. No hay subdirectorios por stack. Eso significa que el basename de cada quadlet debe ser único en todo el repositorio. Si dos stacks declaran un api.container, los dos generan api.service y ahí hay un choque.
¿Y qué hace el runtime en ese caso? Pues nada, malas noticias, gana uno en silencio, sin avisar. Un servicio desaparece y tú ni te enteras. Por eso existe qctl check:
qctl check # audita colisiones duras del stacks root
qctl check quadlets/foo.container # valida un fichero suelto
qctl check recorre tu directorio de stacks ($HOME/.config/containers/available) y busca dos cosas. Colisiones duras, dos o más stacks que declaran el mismo basename de unidad o el mismo ContainerName=, eso lo reporta y sale con código distinto de cero. Y avisos de convención, nombres que no siguen la pauta <stack>.<ext> o <stack>-<rol>, que avisa pero no falla.
Y la guinda, qctl install ejecuta esa misma auditoría antes de tocar el sistema de ficheros. Si tu stack aparece en una colisión dura, aborta el install completo. Es atómico, decide antes del primer enlace, así que un aborto deja el directorio destino intacto. Cero estados a medias.
qctl status y qctl start: ver y arrancar
Ya tenemos enlazado. Ahora queremos ver qué pasa y arrancarlo. Para mirar, qctl status, que te da una tabla con emojis, ✅ si el quadlet está enlazado, ❌ si falta, y 🟢/🟡/⚫ según esté corriendo, parado o no aplique.
qctl status demo
qctl status --compact # TSV sin decoración: ideal para scripts
El --compact es el que uso en automatizaciones, saca una línea por unidad con el enlace y el estado separados por tabuladores, sin emojis ni adornos. Y status --project acota la salida al proyecto actual, que con 126 stacks se agradece.
Para arrancar, qctl start. Y aquí un matiz que me gusta, arranca vía systemctl --user, o sea, no inventa su propio mecanismo, delega en systemd. Sin argumentos, qctl start actúa solo sobre los quadlets del proyecto actual:
qctl start demo
qctl stop demo # para el servicio... pero NO desenlaza
qctl uninstall # para eso hay que desenlazar (borra los symlinks)
Y la frase que quiero que subrayes. qctl stop para pero no desenlaza. La unidad sigue existiendo y volvería a arrancar en el siguiente reinicio. Si quieres sacarla de juego de verdad, hay que desenlazar. Parar y desenlazar no son lo mismo, y confundirlos es una fuente clásica de ¿por qué me vuelve a arrancar esto?.
De cero a un 200 en un comando
Vamos a juntar todo. Desde ~/demo-stack/, con el demo.container y el demo.network que escribimos antes, esta es la secuencia completa:
qctl --dry-run install # 1. ver qué symlinks se crearían (no muta nada)
qctl check # 2. auditar colisiones
qctl install # 3. enlaza + daemon-reload
qctl status demo # 4. estado en tabla
qctl start demo # 5. arranca vía systemctl --user
systemctl --user status demo # 6. comprobarlo con systemd directo
curl -sS -o /dev/null -w '%{http_code}\n' http://localhost:8080/ # 7. 200
Y ahí lo tienes, un 200. Un quadlet y su red, gobernados con un comando. Nada de docker compose up -d, nada de copiar ficheros, nada de acordarse del orden. Y si algo va mal, tienes logs estáticos con qctl logs demo y en vivo con qctl logsf demo. Si quieres ejecutar la secuencia entera de golpe, la tienes como script:
Pero fíjate en lo más potente, en la variante que de verdad uso. qctl start sin argumentos instala los quadlets que falten y arranca todos los del proyecto. Un solo comando para levantar el stack entero después de un git pull. Eso no es administrar contenedores, eso es desplegar.
El repositorio real: available está inerte
Y ahora el salto de la demo al mundo real, porque con una demo no se cambia la forma de trabajar de un servidor. Vamos con la arquitectura del repo de verdad, que se llama self-hosted-podman.
Hay dos directorios. El primero es .config/containers/available/<stack>/, y aquí vive la fuente de verdad, los quadlets de cada stack. Pero ojo al concepto, available/ está inerte. Nada arranca desde ahí, son ficheros apagados.
El segundo es .config/containers/systemd/, el directorio destino que systemd y Podman leen de verdad. Y aquí está el truco, eso solo contiene un .gitkeep y enlaces que apuntan a available/. La verdad está en available/, el destino solo la señala. Enlazas con qctl install desde el directorio del stack, desenlazas con qctl uninstall, y nunca copias ficheros a mano.
Y aquí el cierre del giro. Los dotfiles de ese repositorio se gestionan con yadm, y el repositorio es la única fuente de verdad. En producción no se edita nada a mano. El servidor solo obedece. Tu nube no se administra, se declara. Y se despliega sola.
126 stacks y 387 quadlets: esto no es una prueba de concepto
Y no me creas por la teoría, mira las cifras, contadas contra el árbol del repositorio. Son 126 stacks en available/ y 387 ficheros quadlet, repartidos así:
199 .container (los servicios)
142 .volume (los datos persistentes)
46 .network (las redes)
---
387 ficheros quadlet en total
Ciento veintiséis stacks. Casi cuatrocientos ficheros declarados. Todo rootless, todo con systemctl --user, todo arrancando con [Install] WantedBy=default.target. Y todo desplegado con un solo yadm pull en producción. Esto no es una prueba de concepto ni un fin de semana de cacharreo, es la infraestructura con la que vivo. Y funciona porque está declarada, no porque yo me acuerde.
La config que no es secreta: .env versionado y .env.local
Vamos con la primera mitad de la configuración, la que no es secreta. Cada stack tiene su .env, y hay una convención muy pensada:
.config/<stack>/<stack>.env # config no secreta → SÍ va en git
.config/<stack>/<stack>.env.local # overrides de la máquina → gitignored
El <stack>.env lleva lo que puede ver todo el mundo y va versionado, la zona horaria, los puertos, las rutas, los flags, los correos. El <stack>.env.local lleva los overrides de esta máquina y no va en git, de hecho, si falta, el hook lo crea vacío.
Y en el quadlet se inyectan los dos, en este orden y con ruta absoluta:
EnvironmentFile=%h/.config/<stack>/<stack>.env
EnvironmentFile=%h/.config/<stack>/<stack>.env.local
El %h/ no es decoración. El motivo es sutil y vale la pena contarlo, el directorio de trabajo del proceso no es el del stack, así que una ruta relativa se resolvería contra systemd/, no contra tu fichero. Y la documentación de Quadlet es clara, no resuelve rutas relativas, por eso usamos la absoluta con el especificador %h, que systemd expande a tu $HOME. Ese pequeño %h/ es la diferencia entre que la config cargue y que no cargue.
Los secretos no van en el .env: SOPS, age y el FQDN
Y ahora la mitad que importa de verdad, los secretos. Regla de oro de este repositorio, las credenciales no van nunca en el .env. Contraseñas, tokens, claves, todo va cifrado con SOPS y age, y se inyectan como Secret=:
Secret=miniflux_database_url,type=env,target=DATABASE_URL
Secret=miniflux_admin_password,type=env,target=ADMIN_PASSWORD
El type=env significa que el valor llega como variable de entorno al contenedor, y target= renombra esa variable dentro. Pero aquí hay una trampa gorda que quiero contarte. Los secretos de Podman se resuelven por identificador, no por nombre. Así que la forma correcta de crear uno es esta:
openssl rand -base64 32 | podman secret create mi_password -
Y nunca intentes crypta store <nombre> para un Secret= de Podman, escribirías una clave huérfana con un nombre literal que Podman jamás encontrará, y el contenedor no arrancaría con un no secret with name or id. Un Secret= debe existir antes de arrancar la unidad. Punto.
Y luego está el FQDN, que es lo contrario de un secreto. Tu dominio no es un secreto, vive en ~/.config/environment.d/fqdn.conf, y systemd lo inyecta en cada unidad de usuario. En los quadlets escribes ${FQDN} y systemd lo expande, incluso dentro de las labels de Traefik:
Label=traefik.http.routers.miniflux.rule=Host(`miniflux.${FQDN}`)
Si ${FQDN} está vacío, esa label queda literalmente Host(), sin nombre, y Traefik no enruta nada. Cosa que se comprueba en un segundo con systemctl --user show-environment | grep '^FQDN='. Y aquí es donde encaja el resto del miniflux.container real, con su red proxy.network, su base de datos, su NetworkAlias, su healthcheck declarativo y el Environment=SOPS_AGE_KEY_FILE=%h/.secrets/sops/age/key.txt para que SOPS encuentre la clave. Todo eso, un stack entero, es un solo fichero:
Delegar el despliegue a un modelo de lenguaje
Y llegamos a la parte que me tiene entusiasmado desde hace semanas, y es la razón del episodio. Como toda tu nube es código declarado en un repositorio, se la puedes dar a un modelo de lenguaje y dejar que sea él quien la levante.
Yo lo he estado haciendo con un modelo sencillo y un par de skills, las habilidades donde le explico cómo tiene que usar qctl, cómo verificar volúmenes y cómo comprobar que un servicio responde. Y funciona. Le dices, despliega it-tools en mi servidor, y él se conecta, comprueba que el stack está en el repositorio, verifica que el fichero coincide, mira que el repositorio esté sincronizado y ejecuta qctl install y qctl start. Después comprueba que el contenedor está levantado y te lo dice. En un momento tienes it-tools en marcha.
Con Navidrome hice algo más ambicioso, porque le pedí dos cosas de golpe. Instala Navidrome y, cuando esté, copia los últimos episodios de este podcast para que los pueda escuchar. Y el modelo hizo todo el trabajo, descargó los episodios del feed, comprobó las propiedades del volumen, verificó la integridad y los indexó. Aquí aparece una ventaja que va más allá de escribir código. El modelo te pone manos y hace operaciones que tú antes te saltabas por prisa, como verificar que los ficheros se han copiado bien. Y si se lo dejas escrito en una skill, sabe exactamente qué tiene que hacer y cuándo interrumpirte para avisarte de un problema.
Exponer los servicios con seguridad: Traefik, CrowdSec y Headscale
Y ahora la pregunta que te estarás haciendo. Todo esto expuesto a internet, con lo peligroso que es y con las vulnerabilidades que no paran de salir. Tienes razón en preocuparte, pero el modelo rootless juega a tu favor, porque todo el despliegue corre bajo un usuario que no tiene sudo ni permisos de ningún tipo. No puede hacer nada más que lo que tú le digas.
Aun así, conviene ponerle puertas. Yo lo tengo montado con Traefik 3 como proxy de borde, y la idea me la dio alguien del grupo de Telegram, que me preguntó por qué no conectaba Traefik directamente a unos sockets en lugar de poner otra pieza delante. Ahí vi la luz. Con un par de sockets, uno al puerto 80 y otro al 443, tengo acceso directo a internet sin abrir puertos privilegiados desde el contenedor. El traefik.container real lo enseña bien, con Requires=http.socket https.socket podman.socket, sockets de systemd y el secreto del token de Cloudflare por Secret=:
Sobre eso he levantado varias capas. Pocket ID para autenticación sin contraseña en los servicios, con el problema del discovery OIDC que te contaba antes. Headscale y Tailscale para acceder a lo que no quiero exponer, dejándolo solo en mi red privada. Y CrowdSec para limitar a quien intenta entrar donde no debe. Es el mismo papel que hace Fail2Ban, pero con una comunidad que comparte señales de ataque. Y sí, podrías decir que aprender CrowdSec es otro marrón, pero aquí vuelve a entrar el modelo de lenguaje, porque todo esto está declarado en el repositorio y él te lo monta.
yadm pull y a dormir
Llegamos al final del camino. ¿Qué pasa cuando hago un cambio en un stack? Lo hago aquí, en el repositorio, con su commit. Y en el servidor, un único comando:
yadm pull
Y a dormir. Porque el hook post_pull se encarga del resto. Comprueba que el FQDN esté bien y si no, avisa y falla. Renderiza las plantillas *.jinja con unjinja, crea el <stack>.env.local que falte y lanza el systemctl --user daemon-reload que hace que el generador de quadlets relea todo. Un pull y el despliegue está hecho.
Ahora la parte honesta, porque una herramienta sin pegas documentadas es publicidad, no información. El directorio de destino es plano, así que los nombres chocan y hay que ser único con los basename. ServiceName= cambia el nombre del servicio, pero qctl sigue direccionando por el nombre del fichero, lo que provoca un confuso no such quadlet. El descubrimiento de qctl no es recursivo, así que tienes que ejecutarlo desde el directorio del stack. Y el daemon-reload es obligatorio, sin él tu cambio no existe. Nada de esto es fatal, pero conviene saberlo antes de chocar.
Conclusión: no elegir, tenerlo todo
Y me quedo con la tesis, que es lo que quiero que te lleves. Tu nube no se administra, se declara. Los quadlets son la infraestructura como código de tu servidor, y qctl la convierte en un comando. Con eso, el mismo anuncio del banco que te decía que no tienes que elegir entre Bali y el último iPhone se convierte en tu realidad digital. No tienes que elegir entre Netflix o Spotify o Movistar o Disney. Puedes tenerlo todo, montado en tu servidor, con tus datos bajo tu dominio. Eso sí, tienes que poner las películas y la música, pero son tuyas. Cuando pagas Spotify no estás comprando música, la estás alquilando. Aquí, lo que tienes, es tuyo.
Y de propina, algo que no tiene precio. Nunca más root. Tu usuario sin privilegios lanza todo, y la seguridad deja de ser una lotería de permisos para convertirse en una consecuencia de quién eres.
La llamada a la acción es sencilla. Coge el demo.container y el demo.network que hemos escrito hoy, monta tu primer stack declarado en tu propio servidor y verás cómo en media hora tienes un 200. Empieza por uno pequeño, y te aseguro que engancha. Dale al play la próxima semana, que seguimos trasteando. Un abrazo. 🐧
Más información
- Podman: quadlets y unidades de systemd (documentación oficial) — referencia de las extensiones
.container,.volume,.networky de todas sus directivas - qctl, el CLI para gobernar tus quadlets — repositorio, releases y binario estático
- self-hosted-podman, el repositorio de la nube real — 126 stacks y 387 quadlets en producción, todo rootless
- yadm, gestor de dotfiles — la herramienta con la que se despliega el repositorio en el servidor
- SOPS y age — cifrado de secretos que no deben acabar en el
.env - Traefik — proxy de borde y enrutado con etiquetas, certificados y middlewares
- CrowdSec — protección frente a ataques, alternativa colaborativa a Fail2Ban
- Headscale — implementación libre del plano de control de Tailscale para tu propia red privada
- Pocket ID — proveedor de identidad OIDC para autenticación sin contraseña