Atareao con Linux

¿Te preocupa tener tus claves y contraseñas en texto plano? En este episodio 770 de Atareao con Linux, te explico por qué deberías dejar de usar variables de entorno tradicionales y cómo Podman Secrets puede salvarte el día. Yo mismo he pasado años ignorando este problema en Docker por la pereza de configurar Swarm, pero con Podman, la seguridad viene de serie.

Hablaremos en profundidad sobre el ciclo de vida de los secretos: cómo crearlos, listarlos, inspeccionarlos y borrarlos. Te mostraré cómo Podman gestiona estos datos sensibles fuera de las imágenes y fuera del alcance de miradas indiscretas en el historial de Bash. Es un cambio de paradigma para cualquier SysAdmin o entusiasta del Self-hosting.

Pero no nos quedamos ahí. Te presento Crypta, mi nueva herramienta escrita en Rust que integra SOPS, Age y Git para que puedas gestionar tus secretos de forma profesional, permitiendo incluso la sincronización con repositorios remotos. Veremos cómo configurar drivers personalizados y cómo usar secretos en tus despliegues con MariaDB y Quadlets.

Capítulos destacados:

• 00:00:00 El peligro de las contraseñas en texto plano
• 00:01:23 El problema con Docker Swarm y por qué elegir Podman
• 00:03:16 ¿Qué es realmente un Secreto en Podman?
• 00:04:22 Ciclo de vida: Creación y muerte de un secreto
• 00:08:10 Implementación práctica en MariaDB y Quadlets
• 00:12:04 Presentando Crypta: Gestión con SOPS, Age y Rust
• 00:19:40 Ventajas de usar secretos en modo Rootless

Si quieres que tu infraestructura sea realmente segura y coherente, este episodio es una hoja de ruta esencial. Aprende a ocultar lo que debe estar oculto y a dormir tranquilo sabiendo que tus tokens de API no están al alcance de cualquiera.

Más información y enlaces en las notas del episodio

• 🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
• ✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
• ✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
• 🦣 Mastodon 👉 https://mastodon.social/@atareao
• 🐦 Twitter 👉 https://twitter.com/atareao
• 🐙 GitHub 👉 https://github.com/atareao

¿Te falta espacio en el teclado o quieres automatizar tareas en Linux de forma física? Soy Lorenzo y en este episodio 769 de Atareao con Linux te cuento cómo he integrado un mini teclado programable de apenas 15€ en mi flujo de trabajo diario.

Hablamos de teclados mecánicos, de la comodidad de los teclados partidos y, sobre todo, de cómo no gastarse una fortuna en dispositivos como el Stream Deck de Elgato cuando puedes conseguir resultados similares (¡y más divertidos de configurar!) con hardware económico y un poco de ingenio Linuxero.

• El hardware: Un análisis de este dispositivo de 3 teclas y una rueda (potenciómetro) basado en el chip CH552.
• Adiós a Windows: Cómo configurar dispositivos que "solo soportan Windows" directamente desde tu terminal Linux.
• El poder de Rust: Exploramos la herramienta ch57 para el mapeo de teclas y cómo Rust está facilitando la creación de utilidades para hardware.
• Configuración técnica: Archivos YAML, mapeo de teclas de función extendidas (F13-F24) y reglas de udev para permisos.
• Capboard: Te presento el demonio que he desarrollado para gestionar este teclado como un servicio de sistema.

Si eres de los que disfruta "cacharreando" con archivos de configuración y quieres llevar tu productividad al siguiente nivel sin vaciar la cartera, no te puedes perder este audio.

• 00:00:00 Introducción y mi obsesión por los teclados
• 00:01:33 ¿Qué es un Stream Deck y por qué no compré el de Elgato?
• 00:02:47 El mini teclado de 15€: 3 teclas y una rueda
• 00:05:00 El reto: Configurar hardware diseñado para Windows en Linux
• 00:06:38 La salvación se llama Rust y el proyecto ch57
• 00:07:44 Identificando el dispositivo (lsusb y el chip CH552)
• 00:08:43 Asignando teclas mágicas: de la F13 a la F22
• 00:10:48 Instalación y mapeo con archivos YAML
• 00:13:02 Permisos de usuario: Configurando reglas de udev
• 00:15:08 Bonus: He creado mi propio demonio en Rust (Capboard)
• 00:17:35 ¿Vale la pena? Mi veredicto y un avance del próximo gadget
• 00:18:25 Despedida y red de podcast

Más información y enlaces en las notas del episodio

• 🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
• ✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
• ✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
• 🦣 Mastodon 👉 https://mastodon.social/@atareao
• 🐦 Twitter 👉 https://twitter.com/atareao
• 🐙 GitHub 👉 https://github.com/atareao

¿Sigues usando Docker porque te da pereza el cambio? En este episodio de Atareao con Linux te voy a demostrar por qué los Quadlets son la razón definitiva para que te decantes por Podman de una vez por todas. Si ya te hablé de los Pods y te pareció interesante, lo de hoy es llevar la gestión de contenedores al siguiente nivel: la integración TOTAL con SystemD.

En el episodio 768, te explico cómo los Quadlets permiten gestionar tus contenedores, volúmenes y redes exactamente como si fueran servicios nativos de tu sistema operativo. Olvídate de scripts extraños o de depender de herramientas externas; aquí todo se define con archivos de configuración sencillos (.container, .network, .volume) que SystemD entiende a la perfección.

Te cuento mi experiencia real migrando mis proyectos actuales. Ya tengo bases de datos PostgreSQL funcionando bajo este modelo y la estabilidad es, simplemente, de otro planeta. Veremos cómo levantar un stack completo de WordPress con MariaDB y Redis utilizando esta tecnología, gestionando las dependencias entre ellos con las directivas 'After' y 'Requires' de SystemD. ¡Se acabó el que un contenedor intente arrancar antes de que la base de datos esté lista!

• 00:00:00 Introducción y el adiós definitivo a Docker
• 00:01:33 ¿Qué es un Quadlet y por qué revoluciona Linux?
• 00:03:22 Los 6 tipos de Quadlets disponibles
• 00:05:12 Cómo gestionar un Quadlet de tipo contenedor
• 00:06:46 Definiendo Redes y Volúmenes como servicios
• 00:08:13 El flujo de trabajo: Git, secretos y portabilidad
• 00:11:22 Integración con SystemD: Nombres y prefijos
• 00:13:42 Desplegando un Stack completo: WordPress, MariaDB y Redis
• 00:16:02 Modificando contenedores y recarga de SystemD (Daemon-reload)
• 00:17:50 Logs con JournalCTL y mantenimiento simplificado
• 00:19:33 Auto-update: Olvídate de Watchtower para siempre
• 00:20:33 Conclusiones y próximos pasos en la migración

Además, exploramos ventajas brutales como el control de versiones mediante Git, la gestión de logs centralizada con JournalCTL y las actualizaciones automáticas nativas que harán que te olvides de Watchtower. Si quieres que tu servidor Linux sea más profesional, robusto y fácil de mantener, no puedes perderte este audio.

Más información y enlaces en las notas del episodio

• 🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
• ✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
• ✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
• 🦣 Mastodon 👉 https://mastodon.social/@atareao
• 🐦 Twitter 👉 https://twitter.com/atareao
• 🐙 GitHub 👉 https://github.com/atareao

¡Bienvenidos a un nuevo episodio de Atareao con Linux! Soy Lorenzo y hoy te traigo una confesión técnica: he abandonado mi sistema de gestión de contraseñas de toda la vida. ¿El motivo? La pura y dura velocidad.

En el episodio de hoy (el 767), profundizamos en la migración de pass hacia un ecosistema más moderno compuesto por Sops y Age. Te cuento los dolores de cabeza, pero también las inmensas satisfacciones de tener todos tus secretos centralizados en un archivo YAML cifrado de forma inteligente, donde las claves son visibles pero los valores están protegidos.

Si alguna vez has sentido que tu flujo de trabajo con secretos es lento o farragoso, aquí te traigo la solución. Te detallo cómo he programado mis propias herramientas en Fish Shell para gestionar el día a día y, sobre todo, te presento mi nueva creación en Rust: Crypta. Esta herramienta es la pieza que faltaba en el puzzle para que trabajar con credenciales en la terminal sea algo que ocurra a la velocidad del pensamiento.

Además, exploramos conceptos avanzados como el uso de Yadm para gestionar dotfiles y cómo las plantillas Jinja pueden automatizar la configuración de tus aplicaciones inyectando secretos de forma segura en memoria.

Contenido del episodio:

00:00:00 Introducción: El reto de gestionar secretos en la terminal

00:01:23 Por qué migrar de Pass a Sops y Age

00:03:08 La obsesión por la rapidez y el archivo único

00:04:26 Repositorios privados y versionado de secretos

00:06:59 El flujo de trabajo con .secrets.yml

00:08:02 Creando un CRUD personalizado en Fish Shell

00:10:30 Sincronización: Secret Pull, Push y Sync

00:12:46 Integración avanzada con Jinja y Yadm

00:15:28 Kripta: Gestión de secretos de alto rendimiento en Rust

00:18:25 Conclusiones y reflexiones sobre la migración

00:19:42 Despedida y red de podcasts

Acompáñame en esta aventura de optimización extrema. Ya sabes que el día son dos días y uno ya ha pasado, ¡así que vamos a aprovecharlo haciendo que nuestro Linux vuele!

Más información y enlaces en las notas del episodio

• 🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
• ✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
• ✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
• 🦣 Mastodon 👉 https://mastodon.social/@atareao
• 🐦 Twitter 👉 https://twitter.com/atareao
• 🐙 GitHub 👉 https://github.com/atareao

¿Sigues usando Docker Compose para todo? Es hora de descubrir la verdadera potencia de Podman: los Pods. En este episodio te acompaño en la migración de un stack completo de WordPress, MariaDB y Redis para que veas cómo simplificar radicalmente la gestión de tus contenedores.

Aprenderás por qué el concepto de "vaina" (Pod) cambia las reglas del juego al permitir que tus contenedores compartan la misma red y dirección IP, atacando directamente a localhost. Veremos desde el funcionamiento técnico del contenedor Infra hasta la automatización profesional con Quadlet y systemd.

• ¿Qué es un Pod?: El origen del nombre y por qué es la unidad lógica ideal para tus servicios.

• Adiós a los problemas de red: Cómo conectar WordPress y base de datos sin crear redes virtuales, usando simplemente 127.0.0.1.

• Seguridad y Sidecars: Blindar servicios como Redis dentro de la misma vaina para que sean inaccesibles desde el exterior.

• Gestión unificada: Cómo detener, arrancar y monitorizar todo tu stack con un solo comando.

• Persistencia y automatización: Generar archivos YAML de Kubernetes y convertirlos en servicios nativos de Linux con archivos .kube.

Si buscas soluciones prácticas para "cualquier cosa que quieras hacer con Linux", este episodio te da las herramientas para profesionalizar tu infraestructura.

Notas completas y comandos utilizados: https://atareao.es/podcast/766

🔐 Cifrado Moderno: Migrando de Pass a Age + SOPS

¿Es GPG demasiado lento para tu flujo de trabajo? En este episodio, Lorenzo Carbonell (atareao) explica por qué decidió abandonar su antigua gestión de contraseñas y cómo ha optimizado sus dotfiles y despliegues de Docker utilizando un "dúo dinámico" de herramientas modernas.

• El fin de una era: Por qué pass y gopass dejaron de ser la solución ideal para gestionar secretos complejos.

• Age (Actual Good Encryption): La alternativa ligera a PGP con llaves pequeñas, seguras y un funcionamiento extremadamente sencillo.

• SOPS de Mozilla: Cómo cifrar solo los valores sensibles de tus archivos YAML, JSON o .env, manteniendo la estructura visible para Git.

• Productividad real: Un script práctico para levantar stacks de Docker Compose pasando secretos directamente desde SOPS sin escribirlos en el disco.

Si buscas una forma más rápida y profesional de gestionar tus credenciales en Linux, este episodio te da las claves para dar el salto tecnológico.

En este episodio descubrirás:

¿Sabías que ejecutar Docker como root es, en esencia, darle las llaves de tu casa a cualquier proceso que corra en un contenedor? En este episodio exploramos el modo Rootless, una configuración que aumenta drásticamente la seguridad de tus servidores al eliminar la necesidad de privilegios de administrador.

• El Experimento del Escape: Te explico cómo un atacante puede usar el socket de Docker para "escapar" del contenedor y tomar el control total de tu host.

• User Namespaces desmitificados: Entenderás cómo Linux crea una "realidad paralela" donde eres root dentro del contenedor, pero un usuario normal y corriente fuera de él.

• La magia de subuid y subgid: Cómo el sistema gestiona los rangos de IDs para que tus procesos vivan en su propia burbuja de seguridad.

• Podman vs Docker: Por qué Podman detiene ataques de escalada de privilegios de forma nativa gracias a su arquitectura sin demonio y sin root.

• Guía de implementación: Pasos clave para configurar este entorno en Ubuntu y Arch Linux, incluyendo la gestión de almacenamiento y redes.

• El truco de los puertos bajos: Cómo permitir que tu usuario use los puertos 80 y 443 sin trucos complejos de firewall, usando simplemente sysctl.

Si te preocupa la seguridad de tus servicios autohospedados (self-hosted) o quieres llevar tu gestión de contenedores al siguiente nivel de profesionalismo, este episodio es para ti.

• Notas completas y comandos: Visita atareao.es para ver todos los scripts y configuraciones mencionadas.

• YouTube: Busca "atareao" para ver la demostración visual del ataque de escape.

• Proyecto: Sigue el podcast para más soluciones sobre cómo optimizar tus sistemas Linux.

Más información y enlaces en las notas del episodio

• 🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
• ✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
• ✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
• 🦣 Mastodon 👉 https://mastodon.social/@atareao
• 🐦 Twitter 👉 https://twitter.com/atareao
• 🐙 GitHub 👉 https://github.com/atareao

#Linux #Podman #Docker #Rootless #Ciberseguridad #SelfHosted #SysAdmin #Atareao

¿Es hora de jubilar tus viejos scripts de Bash? 🦀 En el episodio 763 de "Atareao con Linux", nos enfrentamos a uno de los retos más interesantes para cualquier amante de la automatización: la migración de Bash a Rust. Muchos scripts de Bash crecen hasta volverse inmanejables, lentos o propensos a errores silenciosos. Rust, a través de rust-script, nos ofrece una alternativa con un rendimiento profesional, seguridad de tipos y una gestión de errores que Bash simplemente no puede alcanzar.Lo que aprenderás hoy:

• Gestión de estados: Cómo el operador '?' de Rust elimina la necesidad de comprobar manualmente la variable $? tras cada comando.
• Seguridad en argumentos: Olvídate de las expresiones regulares complejas para validar números; usa el tipado fuerte y el método .parse().
• Manipulación de rutas: El uso de PathBuf para evitar que un simple espacio en un nombre de archivo rompa toda tu lógica.
• Rendimiento extremo: Cómo BufReader permite procesar archivos de logs de Gigabytes en segundos, algo que en Bash podría tardar minutos.
• Concurrencia real: Paraleliza tareas (como pings masivos) de forma segura con hilos nativos o librerías como Rayon.

Capítulos del episodio:

00:00:00 Introducción: El reto de migrar a Rust
00:01:05 Gestión de estados y errores: Adiós al $?
00:04:22 Paso de argumentos y seguridad de tipos
00:07:34 Validación semántica con Pattern Matching
00:09:47 Ejecución de comandos externos y captura de salida
00:13:28 Gestión de rutas con PathBuf
00:16:32 Variables de entorno y valores por defecto
00:19:15 Escritura eficiente de logs con BufWriter
00:23:04 Lectura masiva de archivos con BufReader
00:26:18 Concurrencia y paralelismo: std::thread vs Rayon
00:31:45 Conclusión y tabla comparativa final¿Por qué Rust para tus scripts?

Migrar a Rust no es solo una cuestión de velocidad; es una cuestión de robustez. Al usar Rust, el compilador te obliga a manejar todos los posibles casos de error, evitando fallos en cadena en tus sistemas. Además, gracias a herramientas como Rayon, la ejecución paralela se vuelve rápida y segura. #Linux #Rust #Bash #Programacion #OpenSource #SysAdmin #Productividad #Atareao #RustLang #Automation

Más información y enlaces en las notas del episodio

• 🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
• ✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
• ✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
• 🦣 Mastodon 👉 https://mastodon.social/@atareao
• 🐦 Twitter 👉 https://twitter.com/atareao
• 🐙 GitHub 👉 https://github.com/atareao

¿Es el fin de una era en mi infraestructura? En este episodio comienzo una de las tareas más importantes de esta temporada: la migración definitiva de Docker a Podman. Si alguna vez te ha preocupado la seguridad de tu servidor o el consumo descontrolado de recursos, este programa es para ti.

Históricamente, Docker ha sido la herramienta de referencia, pero su arquitectura basada en un demonio persistente (dockerd) que corre como root presenta riesgos y puntos únicos de fallo que he decidido dejar atrás. Podman llega para solucionar esto de forma elegante, integrándose orgánicamente en Linux y eliminando la necesidad de privilegios de administrador.

En este episodio exploramos:

• El problema del "Gran Hermano": Por qué depender de un proceso centralizado que, si falla, detiene todos tus servicios.

• Procesos independientes: Cómo Podman lanza contenedores que son procesos hijos directos, mejorando la fiabilidad.

• Seguridad Rootless: La importancia de ejecutar contenedores sin privilegios de root para reducir drásticamente la superficie de ataque.

• Transición transparente: Cómo aprovechar lo que ya sabes de Docker usando un simple alias.

• Gestión de Logs y Registries: La integración nativa con journald y la libertad de configurar múltiples registros de imágenes.

• El concepto de Pods: Una herramienta clave para agrupar contenedores que comparten red y recursos.

Esta es solo la primera entrega de una serie donde profundizaremos en ejemplos prácticos para que tú también puedas optimizar tu sistema Linux.

Capítulos

00:00:00 Introducción y el reto de migrar a Podman

00:01:25 Adiós al demonio: El problema de la arquitectura de Docker

00:02:33 Procesos independientes y aislamiento en Podman

00:03:49 Integración nativa con Systemd y el modelo estándar de Linux

00:04:41 Seguridad: Contenedores sin privilegios de administrador (Rootless)

00:06:10 Una transición indolora: El alias de Docker a Podman

00:07:33 Registries y gestión de imágenes personalizadas

00:09:36 Gestión eficiente de logs y Journald

00:11:20 Los Pods: Agrupación de contenedores y comunicación por localhost

00:14:51 El patrón Sidecar para añadir funcionalidades

00:15:40 Introducción a los Quadlets y futuro de la serie

00:17:36 Conclusión y despedida

¿Te ha resultado útil? Si te gusta el contenido práctico sobre Linux y el código abierto, no olvides seguir el podcast y dejar una valoración de 5 estrellas en Spotify. ¡Nos escuchamos el próximo lunes!

Más información y enlaces en las notas del episodio

• 🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
• ✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
• ✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
• 🦣 Mastodon 👉 https://mastodon.social/@atareao
• 🐦 Twitter 👉 https://twitter.com/atareao
• 🐙 GitHub 👉 https://github.com/atareao

En este episodio de Atareao con Linux, te hablo sobre una de las transiciones más importantes que he hecho últimamente en mi flujo de trabajo: el paso del scripting tradicional hacia el uso de Rust como lenguaje de cabecera para resolver mis problemas cotidianos.

A pesar de que Fish se ha convertido en mi shell por defecto por lo intuitivo que resulta, el día a día me sigue obligando a crear scripts en Bash que, con el tiempo, terminan convirtiéndose en auténticos mastodontes difíciles de gestionar. Cuando un pequeño script crece demasiado, aparecen las limitaciones: una gestión de errores muy limitada, la falta de tests bien integrados, la ausencia de tipado que provoca errores difíciles de depurar y la pesadilla de manejar JSON o YAML dependiendo siempre de herramientas externas como jq.

Para solucionar esto sin tener que montar un proyecto completo de Rust con su Cargo.toml cada vez que quiero hacer algo sencillo, he recuperado una herramienta que es pura magia: Rust Script. Con ella, tengo lo mejor de los dos mundos: la potencia, seguridad y velocidad de Rust, pero con la agilidad y simplicidad de un script de toda la vida.

En este episodio te cuento:

• Mi visión sobre Rust Script: Cómo lo utilizo como un lenguaje de scripting puro para sustituir a Bash cuando la cosa se complica.

• El fin de la sobrecarga: Te explico cómo escribo scripts sin configurar proyectos completos, eliminando de un plumazo la burocracia de archivos de configuración.

• Gestión de dependencias: Te muestro cómo declaro los crates que necesito directamente dentro del código mediante comentarios, haciendo que mis scripts sean totalmente autónomos y fáciles de mover de un sitio a otro.

• Bajo el capó: Cómo funciona el sistema de caché y compilación para que, tras la primera ejecución, tus herramientas vuelen y sean instantáneas.

• Ejemplos reales: Desde un "Hola Mundo" básico hasta herramientas que consultan APIs REST y procesan información de forma nativa sin herramientas de terceros.

• Velocidad y fiabilidad: Por qué prefiero un binario tipado y testeado antes que una cadena de comandos en Bash donde un error en una tubería puede pasar desapercibido.

Además, aprovecho para adelantarte los próximos episodios técnicos donde voy a meterle mano a fondo a Podman. Quiero explicarte por qué, al haber nacido en Linux, tiene una integración mucho más natural que Docker y cómo pienso sacarle todo el partido.

Si tú también sientes que tus scripts de Bash se te están yendo de las manos, te invito a escuchar este episodio y descubrir cómo optimizar tu trabajo diario.

Este podcast forma parte de la red de Sospechosos Habituales. Puedes encontrar todos los detalles y los scripts que menciono en las notas del episodio en mi web, atareao.es.

¿Te gustaría que en el próximo episodio hiciera la migración en directo de uno de mis scripts de Bash a Rust Script para que veas el proceso paso a paso?

Timestamp

00:00:00 Introducción y la transición de Bash a Fish

00:00:50 Las limitaciones de los scripts complejos en Bash y Fish

00:01:26 Por qué elegir Rust para optimizar el trabajo

00:02:07 Introducción a Rust Script: Rust como lenguaje de scripting

00:02:36 Próximos episodios técnicos: Profundizando en Podman

00:03:59 Problemas comunes en Bash: Errores, tipos y datos estructurados

00:04:50 El punto intermedio: Rust Script vs. proyectos completos con Cargo

00:06:47 Ejemplo práctico: Cómo crear un "Hola Mundo" con Rust Script

00:08:07 Funcionamiento interno: Compilación y caché de binarios

00:09:43 Ejecución directa y permisos en archivos .rs

00:10:44 Cómo instalar Rust Script en Arch Linux y vía Cargo

00:11:32 Gestión de dependencias elegante dentro del script

00:14:03 Ejemplo avanzado: Uso de múltiples crates y peticiones web

00:16:32 Ventajas de trabajar con APIs JSON sin herramientas externas

00:18:25 Resumen de beneficios: Potencia, tipado y velocidad

00:20:13 Despedida y red de podcast Sospechosos Habituales