Disfruta conmigo de Linux y del Open Source. Aquí encontrarás como sacarle el máximo partido a tu entorno de escritorio Linux, hasta como montar un servidor web, un WordPress, un proxy inverso, una base de datos o cualquier otro servicio que puedas imaginar. Y todo ello, lo puedes montar en una Raspberry Pi, en un VPS, en tu propio ordenador o en cualquier servidor. Vamos, cualquier cosa que quieras hacer con Linux, seguro, seguro, que la encontrarás aquí.
Similar Podcasts
Academia de Fotógrafos
El podcast para los fotógrafos que quieren aprender técnica, monetizar su pasión y estar al día de todas las novedades de material en tiempo real.
Thinking Elixir Podcast
The Thinking Elixir podcast is a weekly show where we talk about the Elixir programming language and the community around it. We cover news and interview guests to learn more about projects and developments in the community.
Rustacean Station
Come journey with us into the weird, wonderful, and wily world of Rust.
ATA 780 La guía definitiva de Hardening y Despliegue en Podman. De 0 a Producción en 2 minutos
¡Hola! Soy Lorenzo y en este episodio te abro las puertas de mi laboratorio personal para contarte cómo estoy viviendo la gran migración de toda mi infraestructura —incluyendo atareao.es— de Docker hacia Podman. Si llevas tiempo siguiéndome, sabrás que desde mediados de enero te he estado dando pinceladas sobre las bondades de Podman, pero hoy bajamos al barro: te cuento cómo me he puesto manos a la obra para que esta transición no sea solo un cambio de herramienta, sino una evolución total en seguridad y eficiencia.El corazón de este movimiento es el concepto "rootless". He rediseñado por completo la forma en la que entiendo el servidor virtual. Olvídate de ejecutarlo todo como root; aquí te explico cómo he separado las responsabilidades creando un usuario administrador con sudo (que apenas usamos) y un usuario dedicado exclusivamente a las aplicaciones ("apps") que no tiene privilegios de administrador. Esta capa de seguridad adicional cambia las reglas del juego y nos permite dormir mucho más tranquilos.A lo largo del podcast, desgloso mi metodología para lograr un despliegue homogéneo, reproducible e idempotente. Te hablo de los Quadlets, de cómo orquestar servicios como Traefik, WordPress y MariaDB de forma sencilla, y de por qué he decidido tratar mis archivos de configuración de contenedores como si fueran simples "dotfiles". Para ello, te presento mi flujo de trabajo con YADM (Yet Another Dotfiles Manager), que me permite replicar toda mi configuración en cualquier servidor nuevo en menos de dos minutos.También entramos en detalles técnicos de "hardening". Te cuento qué parámetros del kernel he tocado para evitar ataques de red, cómo he configurado el SSH para que sea una fortaleza inexpugnable y por qué he vuelto a confiar en Fail2Ban, no solo por seguridad, sino para ahorrar ciclos de CPU que antes se desperdiciaban gestionando ataques por fuerza bruta. Además, te muestro mi kit de herramientas esenciales: desde Crypta para la gestión de secretos hasta utilidades como Zoxide, Starship o Neovim que hacen que trabajar en la terminal sea una delicia.Capítulos:00:00:00 Introducción: La migración de atareao.es a Podman00:00:44 Por qué abandonar Docker: Ventajas del modelo Rootless00:01:05 Orquestación con Quadlets: Homogeneidad e Idempotencia00:02:12 Estrategia de pruebas: El entorno en Hetzner00:03:05 Seguridad avanzada: Configuración de usuarios Admin vs Apps00:05:12 Automatización con Scripts: Instalación de herramientas esenciales00:06:25 Hardening del Kernel y Red: Protegiendo el servidor00:07:28 Hardening de SSH y la importancia de Fail2Ban en el consumo de CPU00:08:54 Firewall y optimización para HTTP/300:09:25 El script del usuario 'Apps': Persistencia y Sockets de Podman00:10:20 Herramientas de terceros: Sops, Crypta y gestión de secretos00:11:27 El dilema de la gestión: ¿Por qué tratar contenedores como Dotfiles?00:12:21 YADM: El motor de despliegue para mis archivos de configuración00:13:03 Estructura de directorios: Available vs Systemd00:14:36 Demostración lógica: Habilitando y deshabilitando stacks (Qlist)00:16:34 Conclusiones de las pruebas: Estabilidad y rapidez de réplica00:18:14 Ventajas e inconvenientes del flujo de trabajo en terminal00:19:17 Próximos pasos y despedida: El futuro en PodmanEspero que disfrutes de este viaje técnico tanto como yo he disfrutado rompiendo y reconstruyendo mi servidor para traerte esta solución estable. ¡No olvides unirte al grupo de Telegram de Atareao con Linux para comentar tus propias experiencias migrando a Podman!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
ATA 779 ¿Adiós definitivo a GNOME? Mi nueva vida con Niri y DMS
¿Te imaginas tener la ligereza de un gestor de ventanas y la comodidad de GNOME todo en uno? En este episodio número 779, te cuento mi transición definitiva de Ubuntu a Arch Linux en el escritorio y cómo he sustituido GNOME por Niri y la increíble "piel" Dam-Material-Shell.A menudo, el problema de los Tiling Window Managers es que tienes que configurar cada pieza por separado: el panel, el dock, el lanzador... Es un trabajo tedioso y muchas veces el resultado parece un "Frankenstein" visual. Dam-Material-Shell cambia las reglas del juego ofreciendo un entorno totalmente homogéneo, elegante y sincronizado. Hoy analizamos la recién estrenada versión 1.4, que trae mejoras que me han hecho abandonar cualquier otra herramienta.Lo que aprenderás en este episodio:Lanzador vitaminado: Descubre cómo usar el lanzador para cálculos rápidos, búsqueda de GIFs y emojis sin usar el ratón.Conectividad móvil: Sincronización de notificaciones y archivos con el escritorio de forma nativa.Audio bajo control: Uso de alias para dispositivos y amplificación extra para esos vídeos que se escuchan bajo.Reglas de ventana visuales: Configura comportamientos específicos para aplicaciones como la terminal sin editar código.Niri y el scroll horizontal: Por qué este flujo de trabajo es más natural que el tiling tradicional.Si eres un entusiasta de la personalización en Linux o simplemente buscas un sistema que no se interponga en tu camino y te haga más productivo, este audio te dará las claves para montar el escritorio definitivo.Secciones del podcast:00:00:00 Introducción: El fin de una era con Ubuntu y GNOME00:00:48 El cambio a Arch Linux y el uso de Ubuntu en servidores00:01:14 Descubriendo Niri: El Tiling Window Manager con scroll horizontal00:01:45 ¿Qué es Dam-Material-Shell y por qué lo necesitas?00:02:40 El problema de mantener piezas sueltas en un gestor de ventanas00:03:22 Dam-Material-Shell: La "piel" que unifica tu escritorio00:04:45 Novedades de la versión 1.4: Un entorno de escritorio completo00:06:07 El nuevo Lanzador de Aplicaciones y sus superpoderes00:07:02 Complementos: Búsquedas, Emojis, GIFs y Matemáticas00:09:40 Conectividad total: Integración con el móvil (KDE Connect y Valent)00:10:48 Personalización visual: Temas oscuros y modos automáticos00:12:20 Gestión avanzada de audio: Alias y amplificación al 200%00:14:31 Funcionamiento técnico de Niri: El carrusel infinito00:16:08 Reglas de Ventana (Window Rules) de forma visual y sencilla00:17:35 Control total de Notificaciones y modo "No molestar"00:19:18 Conclusiones: ¿Es mejor que Cosmic o GNOME?00:20:24 Despedida y red de podcast Sospechosos HabitualesMá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
ATA 778 ¡Adiós Docker! Cómo configurar Traefik con Podman (Rootless y Seguro)
Bienvenidos a un episodio clave en la serie de Podman. Soy Lorenzo y hoy configuramos nuestro proxy inverso de referencia utilizando Podman y Quadlets. Si alguna vez te has preguntado si puedes dejar atrás Docker sin perder la potencia de Traefik, este podcast te dará todas las respuestas.Lo que aprenderás en este episodio:Seguridad Rootless: Cómo ejecutar Traefik sin ser root y por qué es la mejor decisión para tu servidor.Gestión de Puertos: El truco para usar los puertos 80 y 443 con un usuario común de forma persistente.Persistencia con Systemd: Configuramos el sistema para que tus servicios sigan vivos aunque cierres tu sesión.Quadlets y IaC: Organización de volúmenes, redes y contenedores mediante archivos de configuración limpios.Rendimiento Avanzado: Implementación de HTTP/3, optimización de cifrados (como ChaCha20) y compresión de tráfico.Ecosistema de Plugins: Integración de OIDC con Pocket ID para una autenticación centralizada y segura.Exploramos cómo el uso de variables como %H y %T simplifica el despliegue en diferentes entornos y cómo la configuración dinámica de Traefik nos permite añadir servicios "al vuelo" sin interrupciones. También profundizo en las medidas de seguridad extremas, como eliminar todas las capacidades del kernel excepto las necesarias para el bind de puertos y forzar que el sistema de archivos del contenedor sea de solo lectura.Marcadores de tiempo:00:00:00 - Introducción y objetivos00:02:18 - El reto de los puertos 80 y 44300:04:14 - Persistencia de procesos de usuario00:05:13 - Socket de Podman vs Docker00:06:43 - Quadlets: La magia de la infraestructura00:09:34 - Seguridad y privilegios mínimos00:12:12 - Configuración estática y dinámica00:14:39 - Autenticación avanzada con OIDC00:18:43 - Podman como el futuro del self-hostingNo te pierdas los detalles técnicos disponibles en las notas del episodio y únete a nuestra comunidad en Telegram para debatir sobre el fascinante mundo del Open Source.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
ATA 777 ¿Sigue siendo Kitty el mejor terminal? 5 años después, mi nueva configuración definitiva.
¡Hola! Soy Lorenzo y te doy la bienvenida al episodio 777 de Atareao con Linux. Hoy regresamos a los orígenes para redescubrir Kitty, el que considero el terminal más rápido y versátil del ecosistema Linux. Después de cinco años de uso continuo, he decidido exprimirlo al máximo y el resultado es una configuración que ha transformado por completo mi flujo de trabajo.En este episodio, te detallo mi nueva estructura modular. He pasado de un caos de configuración a un sistema organizado en seis archivos independientes que gestionan desde las fuentes hasta el rendimiento. Te cuento por qué la fuente Iosevka Term NerdFont Mono es mi elección actual para maximizar la claridad en documentos Markdown y cómo las ligaduras de fuentes pueden ser hermosas y funcionales al mismo tiempo sin llegar a distraerte.Lo que aprenderás en este episodio:Modularidad: Cómo dividir tu configuración de Kitty para que sea mantenible y lógica.Interfaz Avanzada: Uso profesional de ventanas y pestañas con una estética Powerline informativa.Rendimiento Extremo: Ajustes para eliminar el parpadeo y optimizar el scrollback usando herramientas como "bat".Adiós al Ratón: El poder de los Kitens para copiar líneas, archivos y abrir URLs usando exclusivamente el teclado.Navegación Vim: Implementación de una tecla líder y movimientos HJKL para gestionar paneles y redimensionar ventanas.El objetivo principal de estos cambios es la eficiencia. Al integrar herramientas como icat para ver imágenes sin salir de la terminal y configurar atajos que imitan mi flujo en Vim, he logrado que la terminal sea el centro neurálgico de mi productividad. Si buscas rapidez, minimalismo y potencia, este análisis detallado de Kitty es para ti.Además, al final del programa te cuento las novedades sobre el próximo tutorial de Traefik en Podman y las últimas novedades de la red de Sospechosos Habituales. ¡No te lo pierdas!Marcadores de tiempo:00:00:00 - Introducción y el regreso de Kitty.00:02:40 - La nueva estructura de archivos .conf.00:05:13 - Gestión de ventanas y pestañas.00:10:00 - Optimización de rendimiento y scrollback.00:12:00 - Tecla líder y navegación tipo Vim.00:14:50 - Uso avanzado de Kitens para productividad.00:19:10 - Próximos pasos con Traefik y Podman.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
ATA 776 La guía definitiva de Logs en Podman. Automatización, Quadlets y Vector
¿Tu servidor Linux se comporta de forma extraña y no sabes por qué? En este episodio de Atareao con Linux, Lorenzo nos sumerge en el fascinante (y a veces temido) mundo de los logs, específicamente aplicados a la migración de Docker a Podman.Descubre por qué delegar la gestión de registros en JournalD es la decisión más inteligente que puedes tomar para la estabilidad de tu infraestructura. Lorenzo comparte cómo configurar los límites de almacenamiento para evitar que un contenedor descontrolado sature tu disco duro, una lección aprendida tras años de lidiar con los archivos de texto de Docker.Puntos clave del episodio:00:00:00 - Introducción a la recta final de la serie Podman.00:03:41 - El papel de la IA y Gemini en la interpretación de errores.00:05:12 - Configuración de JournalD y límites de persistencia.00:10:46 - Scripts personalizados: checkQuadlets y JCU para mejorar la visibilidad.00:14:06 - Observabilidad avanzada con Vector y OpenObserve.00:16:10 - Cómo ser reactivo y bloquear ataques usando los registros de acceso.Además de la configuración técnica, Lorenzo nos presenta herramientas prácticas de su propio flujo de trabajo, como el uso de bat para el resaltado de sintaxis en logs y cómo automatizar reportes de salud para tus servicios. Si quieres transformar tus aburridos registros en una herramienta de seguridad activa capaz de enviar notificaciones a Telegram o bloquear IPs maliciosas directamente en el proxy, no puedes perderte este cierre de serie.Recuerda que puedes encontrar todos los scripts y notas detalladas en atareao.es. ¡Acompañanos en este viaje hacia la maestría en contenedores!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
ATA 775 OpenDeck, la herramienta Definitiva para Streaming en Linux
¿Es posible tener una Stream Deck profesional en Linux por una fracción de lo que cuesta la marca líder? La respuesta es un rotundo sí, y en este episodio te cuento cómo lo he logrado. Muchos de nosotros hemos mirado con recelo los dispositivos de 150 euros , pensando que no dejan de ser una "botonera bonita". Yo mismo tenía ese prejuicio , pero tras probar las alternativas económicas y, sobre todo, descubrir el potencial del software OpenDeck, mi visión ha cambiado por completo. ¿Qué vas a aprender en este episodio?Adiós al hardware prohibitivo: Analizamos opciones como Soomfon y Mars Gaming que ofrecen la misma funcionalidad que Elgato por apenas 50€. OpenDeck, la salvación del Linuxero: Descubre esta herramienta de código abierto programada en Rust que permite gestionar cualquier Stream Controller en Linux, Windows y macOS. Compatibilidad total: Cómo utilizar los plugins del ecosistema de Elgato directamente en tu software libre. Tu móvil como mando: Te explico cómo usar Tacto para convertir cualquier Android en una Stream Deck sin gastar un céntimo. Integración avanzada: Mi setup personal con OBS para controlar grabaciones y mi configuración con el gestor de ventanas Niri usando potenciómetros para el scroll y cambio de escritorio. Contenido detallado:00:00:00 Introducción y el teclado de 15 euros00:01:48 Mis prejuicios con las Stream Deck00:03:10 La magia de los botones dinámicos y LCD00:05:31 OpenDeck: El corazón de tu Stream Deck en Linux00:06:41 Alternativas económicas: Soomfon y Mars Gaming00:08:43 ¿Por qué elegí el modelo con potenciómetros?00:10:47 OpenDeck a fondo: Plugins y compatibilidad00:13:37 Personalización y Multi OBS Controller00:16:10 La opción gratuita: Convierte tu Android en un controlador con Tacto00:18:55 Mi flujo de trabajo: Integración con OBS y el gestor Niri00:21:51 Despedida y conclusiones finalesSi alguna vez has querido automatizar tus tareas, lanzar sonidos en tus podcasts o simplemente controlar tu escritorio con un giro de rueda, este episodio te dará todas las claves técnicas y económicas para hacerlo posible bajo Linux. No olvides dejar tu valoración en Spotify o Apple Podcasts si te ha gustado el contenido. ¡Disfruta del episodio! Más información, enlaces y notas en https://atareao.es/podcast/775🌐 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
ATA 774 Rollbacks Automáticos en Podman. Como WatchTower pero mejor.
Bienvenidos a un nuevo episodio de Atareao con Linux. Soy Lorenzo y hoy vamos a profundizar en un aspecto que hace que la migración de Docker a Podman sea no solo recomendable, sino necesaria para quienes buscamos estabilidad: la gestión nativa de actualizaciones y la seguridad de los rollbacks.En el ecosistema de contenedores, la actualización es vital para la seguridad y el rendimiento, pero siempre conlleva el riesgo de romper el servicio. Muchos hemos confiado en Watchtower, pero hoy descubriremos por qué Podman juega en otra liga. Al estar integrado directamente con SystemD, Podman nos permite automatizar todo el proceso sin dependencias externas.¿Qué aprenderás en este episodio?Podman Auto-Update: Cómo configurar tus contenedores para que se mantengan al día usando etiquetas de registro y locales.Quadlets y SystemD: La forma profesional de gestionar infraestructura como código en tu propia máquina Linux.Timers inteligentes: Cómo programar actualizaciones para que no ocurran todas a la vez y cómo verificar estas programaciones con herramientas nativas.Rollbacks Reactivos: La capacidad de Podman para detectar un fallo en una nueva versión y volver automáticamente a la imagen anterior, garantizando la disponibilidad del servicio.Notificaciones de estado: Cómo integrar avisos en Telegram o Matrix para estar siempre informado de lo que ocurre en tu servidor.Hablaremos sobre la importancia de los Health Checks y cómo estos actúan como el disparador perfecto para que el sistema decida si una actualización ha sido exitosa o si debe retroceder. Es la solución definitiva a esos problemas de compatibilidad que a veces surgen cuando una imagen nueva cambia sus requisitos sin previo aviso.Si te apasiona el auto-hosting, la administración de sistemas o simplemente quieres optimizar tu flujo de trabajo con contenedores, este episodio te dará las claves técnicas para Capítulos:00:00:00 Introducción al episodio 774: Migración a Podman00:00:32 El problema de Watchtower en Docker00:01:42 Podman: Actualizaciones automáticas de caja00:02:10 La magia de la integración con SystemD00:03:13 El comando Podman Auto-Update y etiquetas00:03:57 Registry vs Local: Opciones de actualización00:04:22 Cómo etiquetar contenedores y Quadlets00:05:30 Configuración de timers con SystemD00:06:33 Opciones avanzadas de programación y aleatoriedad00:07:40 Verificación de timers con SystemD-Analyze00:08:29 Ventajas sobre servicios externos00:09:04 Rollbacks Reactivos: La gran ventaja de Podman00:09:44 Requisitos técnicos para el rollback automático00:10:33 Health Checks: Garantizando la salud del servicio00:11:44 Solución a problemas de compatibilidad en imágenes00:12:51 Notificaciones automáticas en Telegram y Matrix00:14:11 Conclusiones y superioridad frente a Watchtower00:14:40 Recursos en las notas y etiquetas detalladas00:15:34 Próximos pasos de la migración: Traefik y Logs00:16:32 Despedida y red de podcastsRecuerda que tienes todos los detalles técnicos y las etiquetas mencionadas en las notas del episodio en atareao.es. ¡Disfruta del episodio!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
ATA 773 Automatización Total. Etiqueta tus MP3 como un profesional
¿Es Python siempre la mejor opción para tus scripts de automatización? En este episodio, Lorenzo profundiza en una de las discusiones más recurrentes de la comunidad: la estabilidad de los scripts frente a la comodidad de los módulos de terceros. Acompaña a nuestro experto en Linux mientras desglosa los motivos que lo llevaron a abandonar soluciones basadas en Python para la gestión de metadatos de audio.Descubre ID3CLI, una herramienta potente y ligera escrita en Rust que soluciona los problemas de retrocompatibilidad y fallos en tiempo de ejecución. Aprenderás cómo automatizar el etiquetado de tus podcasts extrayendo datos directamente de archivos Markdown, eliminando la necesidad de introducir información manualmente en herramientas gráficas. Analizamos la importancia de tener binarios compilados que simplemente "funcionan", permitiéndote centrarte en crear contenido en lugar de arreglar herramientas rotas.Temas destacados del episodio: Bash vs Python: ¿Cuándo el "follón" de compilar merece la pena? Los peligros de depender de módulos de terceros que cambian sin previo aviso. De EasyTag a la automatización total en la terminal. Uso de Front Matter y RipGrep para un flujo de trabajo eficiente. Soporte de metadatos para Apple y carátulas en múltiples formatos. Capítulos,00:00:00 Introducción: El dilema de Bash vs Python00:00:48 El riesgo de las dependencias de terceros en Python00:01:35 La obsesión por la automatización de metadatos00:03:01 Flujo de trabajo: De EasyTag a la Terminal00:05:36 Extrayendo datos del Front Matter en Markdown00:07:24 Herramientas antiguas: ID3 y MiD3v2 (Mutagen)00:09:12 El colapso de los módulos y la necesidad de compilar00:10:13 Presentando ID3CLI: La solución definitiva en Rust00:11:53 Características técnicas y soporte de formatos (MP3, OGG, FLAC)00:13:48 Integración de ID3CLI en scripts de automatización00:15:23 Reflexión sobre la importancia de los metadatos00:16:42 Nuevo proyecto: El podcast "La Era de las Distros"00:17:47 Comunidad y cierre del episodioAdemás, Lorenzo nos habla sobre su nuevo podcast "La Era de las Distros", una mirada necesaria a las distribuciones Linux que marcaron un hito en la informática española como LinEx o Guadalex. ¡Disfruta del episodio y optimiza tu entorno 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
ATA 772 Evita Contenedores ZOMBIE. Guía Maestra de Health Checks en Podman
¿Tu contenedor está realmente funcionando o es solo un proceso zombie ocupando memoria? En el episodio 772 de Atareao con Linux, te revelo los secretos para gestionar la salud de tus contenedores como un experto.Soy Lorenzo y en esta entrega nos enfocamos en Podman y los Health Checks. Si en el episodio 688 hablamos de Docker, hoy damos el salto definitivo hacia la automatización profesional en Linux utilizando Quadlets y Systemd.Lo que vas a descubrir en este audio: Detección de Zombies: Aprende a identificar procesos que parecen activos pero no responden. Dependencias Reales: Cómo configurar tu stack de WordPress, MariaDB y Redis para que arranquen en el orden correcto y solo cuando sus predecesores estén sanos. Auto-reanimación: Configura políticas de reinicio que actúan automáticamente ante fallos de salud. Notificaciones Inteligentes: Recibe alertas en Telegram o en tu escritorio cuando tus servicios cambien de estado.Este episodio es una guía práctica para cualquier persona que quiera robustecer su infraestructura de contenedores, evitando los cierres inesperados y las dependencias rotas que suelen ocurrir con herramientas tradicionales como Docker Compose.Capítulos: 00:00:00 ¿Tu contenedor está vivo o es un ZOMBIE? 00:01:44 ¿Qué es realmente un Health Check? 00:02:22 4 Ventajas de usar Health Checks 00:03:20 Implementación en Podman y Docker 00:05:20 La potencia de los Quadlets 00:08:58 Dependencias inteligentes: WordPress+MariaDB+Redis 00:11:00 Notificaciones On Success 00:13:55 Gestión de errores On Failure 00:18:21 Próximos pasos y TraefikSi disfrutas del podcast, te agradecería enormemente una valoración en Spotify o Apple Podcast. ¡Ayúdame a difundir la palabra del Open Source!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
ATA 771 Adiós a las excusas. Cómo monté mi VS Code en un servidor
¿Te has rendido alguna vez intentando programar en movilidad? Te confieso que lo de programar en la tablet Android no me estaba funcionando, y la razón era sencilla: pereza y falta de un entorno coherente. En el episodio de hoy, te cuento cómo he solucionado este problema de raíz instalando Code Server en un servidor remoto.A lo largo de este audio, exploramos los desafíos de mantener múltiples entornos de desarrollo y por qué la fragmentación mata tu creatividad. Te detallo el paso a paso de mi configuración técnica: desde la creación de una imagen de Docker personalizada hasta la integración de herramientas modernas escritas en Rust (como Bat y LSD) que mejoran la experiencia en la terminal.Lo que aprenderás en este episodio: Por qué un servidor de desarrollo es superior a las instalaciones locales en tablets. Cómo configurar Docker Compose para desplegar Code Server con persistencia real. Seguridad avanzada: Uso de Traefik, Pocket ID y geobloqueo para proteger tu código. Trucos de configuración para VS Code en el navegador: Mapeo de teclas, evitar el conflicto con la tecla Escape y el uso de la fuente JetBrains Mono. Productividad máxima con los modos de Vim integrados en el flujo web. Cómo transformar Code Server en una PWA para eliminar las distracciones del navegador en Android.No se trata solo de tecnología, sino de eliminar las fricciones que nos impiden avanzar en nuestros proyectos. Si quieres saber cómo convertir cualquier dispositivo con un navegador en tu estación de trabajo principal, no te pierdas este episodio.Cronología del episodio:00:00:00 El fracaso de programar en tablet (y por qué)00:01:43 La solución definitiva: Code Server00:02:12 El problema de los entornos fragmentados00:03:53 Mi imagen personalizada de Docker para Code Server00:05:04 Herramientas imprescindibles en Rust (Bat, LSD, SD)00:06:23 Configuración de Rust y herramientas de desarrollo00:07:05 Persistencia y Docker Compose00:08:06 Seguridad: Traefik, Pocket ID y Geobloqueo00:10:03 Optimizando VS Code para el navegador00:11:13 Sincronización y persistencia de extensiones00:12:43 Estética y tipografía (Ayu Dark y JetBrains Mono)00:13:59 El poder de Vim dentro de Code Server00:15:51 Cómo usar Code Server como una PWA en Android00:17:04 Teclado físico: El accesorio obligatorio00:18:50 Conclusiones y futuro del desarrollo remotoRecuerda que puedes encontrar todas las notas, el repositorio y los enlaces mencionados en atareao.es. Si te gusta el contenido, una valoración en Spotify o Apple Podcast ayuda muchísimo a seguir difundiendo el mundo Linux y el Open Source.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
ATA 770 ¡Deja de usar contraseñas en tus Docker Compose! Descubre Podman Secrets
¿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 plano00:01:23 El problema con Docker Swarm y por qué elegir Podman00:03:16 ¿Qué es realmente un Secreto en Podman?00:04:22 Ciclo de vida: Creación y muerte de un secreto00:08:10 Implementación práctica en MariaDB y Quadlets00:12:04 Presentando Crypta: Gestión con SOPS, Age y Rust00:19:40 Ventajas de usar secretos en modo RootlessSi 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
ATA 769 ¿Stream Deck por 15€? Configurando un Macro Pad en Linux
¿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.Lo que descubrirás en este episodio: 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.Capítulos del episodio: 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 podcastMá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
ATA 768 Quadlets. La pieza secreta de Podman que cambiará tu servidor para siempre
¿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!Capítulos del episodio: 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ónAdemá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
ATA 767 Gestión de secretos extrema. SOPS + AGE + RUST (Más rápido que nunca)
¡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 terminal00:01:23 Por qué migrar de Pass a Sops y Age00:03:08 La obsesión por la rapidez y el archivo único00:04:26 Repositorios privados y versionado de secretos00:06:59 El flujo de trabajo con .secrets.yml00:08:02 Creando un CRUD personalizado en Fish Shell00:10:30 Sincronización: Secret Pull, Push y Sync00:12:46 Integración avanzada con Jinja y Yadm00:15:28 Kripta: Gestión de secretos de alto rendimiento en Rust00:18:25 Conclusiones y reflexiones sobre la migración00:19:42 Despedida y red de podcastsAcompáñ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
ATA 766 Adiós a Docker Compose. Cómo usar PODS en Podman. Paso a Paso
¿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