Atareao con Linux

¡Hola! Soy Lorenzo y esto es Atareao con Linux. Bienvenidos al episodio número 790, la segunda entrega de nuestra serie dedicada a montar nuestro propio laboratorio de Inteligencia Artificial local.

Antes de meternos en harina, quiero darte las gracias de todo corazón. El primer episodio de esta serie ha tenido una acogida espectacular, y eso me llena de satisfacción y me da muchísima energía para seguir compartiendo contigo todo este camino. Parece que no soy el único que tiene ganas de recuperar el control de sus datos y de jugar con estos modelos de lenguaje sin depender de servicios externos.

En el episodio anterior estuvimos centrados en la infraestructura: montamos Ollama usando Quadlets y dejamos todo listo para empezar a funcionar. Pero hoy vamos a cambiar el tercio. Hoy vamos a dejar de hablar de configuraciones de sistemas para empezar a hablar, literalmente, con la inteligencia. Y lo vamos a hacer de la forma más pura y directa posible: a través de la terminal.

Seguramente te preguntarás: "¿Pero Lorenzo, para qué voy a usar la terminal si ya hay interfaces web que son una maravilla?". Pues te lo cuento con todo el entusiasmo del mundo: para entender qué está pasando de verdad. En este episodio vamos a exprimir Ollama desde la línea de comandos, bajando al barro, porque hay opciones y configuraciones que en las interfaces gráficas a veces quedan ocultas o simplificadas. Si queremos ser verdaderos "cacharreros" de la IA, tenemos que saber qué pasa bajo el capó.

Hardware y monitorización en tiempo real

En este episodio te cuento cómo estoy viviendo la experiencia con mi hardware. Estoy utilizando una tarjeta Nvidia GeForce RTX 4060 en un equipo Slimbook que va como un tiro. Te explico cómo monitorizo el uso de la GPU y cómo puedes ver, de forma casi mágica, el momento exacto en el que el modelo se carga en los 16 GB de memoria y empieza a consumir recursos. Es fascinante ver cómo el uso de la tarjeta pasa del 0% al 100% mientras la IA genera una respuesta para nosotros. Entender esta relación entre el hardware y el software es fundamental para saber qué modelos podemos ejecutar y cuáles nos van a mandar a "freír espárragos".

Dominando los meta-comandos de Ollama

A lo largo del audio, vamos a desgranar una serie de comandos que te van a convertir en un maestro de la IA local:

• Información detallada
• Personalidad y roles.
• Rendimiento puro.
• Creatividad bajo control.

Capítulos del episodio:

• 00:00:00 - Bienvenida y agradecimientos por la acogida
• 00:00:40 - El laboratorio de IA: Recapitulando el episodio anterior
• 00:01:34 - ¿Por qué bajar al barro con la terminal?
• 00:03:31 - Preparando el entorno y monitorizando la GPU Nvidia
• 00:05:00 - Flujo de trabajo: Arrancar el contenedor y el modelo
• 00:05:35 - Comandos de ejecución, Podman y atajos útiles
• 00:06:40 - Regalo: Una chuleta (cheat-sheet) para dominarlos a todos
• 00:07:48 - Hablando con Ollama de forma interactiva
• 00:08:24 - Meta-comandos: Descubriendo las tripas del modelo
• 00:09:12 - Licencias y parámetros técnicos del modelo
• 00:10:05 - Configurando el rol de experto desarrollador
• 00:11:15 - Midiendo el rendimiento: Tokens por segundo
• 00:12:00 - Modo silencioso y generación de scripts
• 00:12:55 - Atajos de teclado y ayuda rápida
• 00:13:35 - Ajustando la temperatura y la creatividad
• 00:14:40 - Cómo guardar y cargar tus modelos personalizados
• 00:15:20 - Poniendo a prueba a la IA: Verificación de código
• 00:16:15 - Monitorización en tiempo real de CPU y GPU
• 00:17:40 - Cómo elegir el modelo ideal según tu hardware
• 00:19:08 - Próximos pasos: La REST API de Ollama
• 00:20:30 - Despedida y consejos de vida

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

¡Hola! Soy Lorenzo y esto es Atareao con Linux. Bienvenidos al episodio número 789, un episodio que marca el inicio de una aventura que me tiene especialmente emocionado: vamos a montar nuestro propio laboratorio de Inteligencia Artificial en local.

Durante los últimos meses, y gracias a las "pullas" constructivas de amigos como Carlos Castillo de Reflex, RedFone o incluso mi archienemigo favorito Rafa de Leña al Mono, no he parado de darle vueltas a cómo exprimir la IA. Pero hay algo que me inquietaba: casi todo lo que hacía dependía de la nube. Por eso, tras cerrar el ciclo de Podman, he decidido que es el momento de tomar las riendas de nuestra soberanía digital y traernos los modelos de lenguaje a casa.

¿Por qué quieres una IA local?

Seguro que te lo has preguntado. ¿Para qué complicarse la vida si ya tienes Gemini o ChatGPT? Pues bien, en este episodio te cuento las tres razones fundamentales que me han llevado a este "cacharrreo" intensivo:

• Privacidad absoluta.
• Control de costes.
• Inmediatez.

El Stack Técnico: Podman, Quadlets y Ollama

No esperes que te enseñe a instalar cosas "a lo bruto" en tu sistema operativo. Fiel a mi estilo, vamos a usar contenedores, pero con un giro de tuerca profesional. Te explico por qué he elegido Podman sobre Docker para este proyecto, centrándome en la seguridad del modo rootless y la limpieza que nos ofrece. Además, profundizamos en el uso de Quadlets para que nuestra IA sea un servicio más de Linux, perfectamente integrado con Systemd.

Una serie para dominarlos a todos

Este no es un episodio aislado. Hoy inauguramos una serie de 32 capítulos donde iremos de cero a cien. No me interesan los tutoriales de "IA en 5 minutos" que no enseñan nada. Aquí vamos a profundizar en:

• Crear un cerebro digital usando RAG (Generación Aumentada por Recuperación) con nuestros propios archivos Markdown.
• Desarrollar agentes y skills que realicen tareas por nosotros.
• Integrar el stack con hardware NVIDIA para sacar hasta el último teraflop de potencia.
• Automatizarlo todo con scripts en Rust, Python y mi querido shell Fish.

Si te apasiona el open source y quieres dejar de ser un mero espectador de la IA para convertirte en el dueño de tu propia tecnología, este es tu sitio. ¡Prepárate porque nos lo vamos a pasar pipa!

Contenido detallado del episodio:

• 00:00:00 Introducción y el fin de la era Podman
• 00:01:21 El empujón de Slimbook y el Linux Center
• 00:02:15 El problema de depender exclusivamente de la nube
• 00:03:15 El plan maestro: 32 episodios de IA práctica
• 00:05:33 Tres razones para la IA local: Privacidad, pasta y latencia
• 00:07:25 Filosofía "Juan Palomo": Exprimir los modelos con scripts
• 00:08:08 El stack técnico: ¿Por qué Podman y no Docker?
• 00:09:40 Ventajas del rootless y la seguridad en IA
• 00:10:59 Quadlets: Integración total con Systemd
• 00:11:53 Herramientas: Fish shell, Rust y Go al servicio de la IA
• 00:13:20 Creando nuestra propia memoria digital (RAG)
• 00:14:00 Estructura de directorios y repositorio Git
• 00:15:37 El truco de los enlaces simbólicos para Quadlets
• 00:16:02 Hardware: NVIDIA y el aprovechamiento de la GPU
• 00:16:40 Desmenuzando el contenedor de Ollama
• 00:17:54 QCTL: Mi herramienta para gestionar Quadlets fácilmente
• 00:20:20 Comprobando que Ollama responde (CURL y API)
• 00:21:15 Monitorización con NVTOP y VTOP
• 00:22:13 Despedida y próximos pasos en el laboratorio local

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

¡Hola! ¿Cómo estás? Soy Lorenzo y te doy la bienvenida a un nuevo episodio de Atareao con Linux. Hoy te quiero abrir las puertas de mi laboratorio personal para contarte algo que me tiene entusiasmado: cómo he conseguido que la inteligencia artificial y la automatización se conviertan en mis mejores aliadas para sacar adelante este proyecto.

Las herramientas de la revolución

Para que entiendas cómo funciona mi flujo de trabajo actual, te voy a desglosar las cuatro herramientas que se han vuelto imprescindibles en mi equipo:

1. Whisper (de OpenAI): Es el punto de partida. Esta maravilla de la tecnología es capaz de escuchar mis audios y transcribirlos a texto con una precisión que da miedo. Gracias a que utilizo una tarjeta gráfica Nvidia y soporte para CUDA, el proceso es rapidísimo. Whisper no solo me ahorra tener que escribir notas a mano, sino que me da la base para todo lo que viene después.

2. Google AI Studio y el poder de los Prompts: Una vez tengo la transcripción, el siguiente paso es pasarle ese texto a Google AI Studio. He diseñado un "prompt" (unas instrucciones) muy detallado que le dice a la IA exactamente qué necesito: que extraiga el minutaje de los temas tratados, que redacte una descripción amena para YouTube y Spotify, y que prepare los metadatos SEO para la web.

3. Nano Banana (Gemini) y la generación de imágenes: Para las carátulas que ves en las plataformas, ahora confío plenamente en el modelo de generación de imágenes de Google. Aunque a veces es un poco testarudo con las dimensiones —yo le pido un tamaño y él me da otro—, la calidad visual es impresionante. Para domar a esta IA, he creado mis propios scripts en Fish Shell que se encargan de comprobar si la imagen es cuadrada o rectangular y de ajustarla automáticamente a lo que necesito para cada plataforma.

4. Real-ESRGAN y el escalado inteligente: A veces, la imagen que genera la IA es demasiado pequeña para los estándares de calidad actuales. Aquí es donde entran en juego las redes neuronales de Real-ESRGAN. Esta herramienta es capaz de "inventarse" los detalles que faltan para agrandar una imagen sin que pierda nitidez.

5. ImageMagick (o "Magic"): No podíamos olvidarnos de los clásicos. ImageMagick es la navaja suiza que utilizo para las conversiones finales, para optimizar el peso de las imágenes antes de subirlas a la web y para asegurar que todo cumple con los formatos estándar. Es una herramienta de terminal que todo amante de Linux debería conocer.

Capítulos del episodio:

• 00:00:00 La mejor inversión: Atareao.es
• 00:01:38 Mi evolución técnica: Del hosting al VPS y Docker
• 00:02:17 Los modelos de lenguaje entran en juego
• 00:03:00 Resultados brutales con menos esfuerzo
• 00:04:20 Herramienta 1: Whisper, el arte de transcribir audio
• 00:05:11 Fish Shell: El alma de mis automatizaciones
• 00:07:04 Herramienta 2: Google AI Studio y la magia de los Prompts
• 00:08:41 Mi flujo de trabajo: Del guion al minutaje
• 00:09:30 Herramienta 3: Nano Banana (Gemini) para crear carátulas
• 00:10:50 Automatizando el formato de imagen con Fish
• 00:12:00 Reals-ESRGAN: Escalando imágenes con redes neuronales
• 00:13:50 Herramienta 4: ImageMagick (Magic), la navaja suiza
• 00:15:41 El procesado de audio: Normalización y filtros
• 00:16:45 Conclusiones: Automatizar para disfrutar más
• 00:18:04 Despedida y red de podcast

Como siempre digo, la vida son dos días y uno ya ha pasado, así que disfruta como si no hubiera un mañana y, si puede ser con Linux y "cacharreando" con estas herramientas, ¡mucho mejor! Un saludo y nos escuchamos pronto.

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

¡Hola a todos! Bienvenidos una semana más a atareao con Linux. Hoy os traigo el "premio" que me guardé en el episodio 785. Si pensabas que tu terminal ya era lista, prepárate, porque hoy vamos a ver cómo dotarla de un sistema nervioso propio mediante los eventos personalizados en Fish.

En este episodio nos centramos en dos herramientas brutales: emit y on-event. Te voy a explicar, de la forma más sencilla posible, por qué esto cambia las reglas del juego cuando te pones a automatizar tareas en tu servidor o en tu equipo de escritorio.

• Limpieza absoluta: Olvídate de esos archivos .sh infinitos. Ahora puedes tener pequeñas funciones especializadas que solo actúan cuando ocurre algo concreto.
• Flexibilidad total: ¿Quieres añadir una nueva acción a un proceso que ya funciona? No toques el código original, simplemente crea una función nueva que escuche el mismo evento.
• Desacoplamiento: Es la palabra clave. Separamos la lógica de "qué ocurre" de la lógica de "qué hacemos cuando ocurre".

Te cuento cómo he aplicado esto para monitorizar mis proyectos de Rust. Uso herramientas como inotifywait para que, en cuanto guardo un cambio en el código, se dispare una cadena de eventos: compilación, tests y despliegue en contenedores. Si algo falla por el camino, el sistema lo sabe y me avisa de inmediato. ¡Es como tener un asistente personal dentro de la shell!

También hablamos de la introspección. Te enseño cómo consultar qué eventos tienes registrados y qué funciones están asignadas a cada uno mediante el comando Functions --handlers. Así nunca perderás el hilo de lo que está pasando en tu sistema.

Si quieres llevar tu terminal al siguiente nivel y empezar a cacharrear de verdad con la automatización inteligente, este podcast es para ti.

Contenido del episodio:

• 00:00:00 Introducción: Lo mejor de Fish se quedó para el final
• 00:01:28 Qué son los eventos y por qué van a simplificar tu vida
• 00:02:40 Cómo declarar eventos con emit y on-event
• 00:04:02 Ejemplo práctico: Notificaciones de escritorio y avisos en Telegram
• 00:06:40 Las 3 grandes ventajas: Desacoplamiento, múltiples receptores y limpieza
• 00:09:20 Introspección en Fish: Cómo ver tus handlers y eventos registrados
• 00:11:05 Caso de éxito: Automatizando la compilación y despliegue de Rust
• 00:13:58 Gestión de errores: Cómo evitar que un proceso falle en cascada
• 00:15:14 Conclusión y despedida: ¡A cacharrear con los eventos!

¡Espero que te lo pases pipa escuchándolo tanto como yo explicándolo! Al rico contenedor y... ¡nos escuchamos el jueves!

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

¡Hola! Muy buenas, ¿cómo estás? Soy Lorenzo y hoy quiero que hablemos de tecnología, de pragmatismo y, sobre todo, de WordPress. Últimamente parece que está de moda criticar a WordPress entre los creadores de contenido. Que si es pesado, que si tiene vulnerabilidades, que si es tecnología del siglo pasado... Pero claro, cuando miras los números y ves que WordPress impulsa más del 42% de los sitios web del planeta, te das cuenta de que algo estarán haciendo bien.

En este episodio número 786 de Atareao con Linux, quiero romper una lanza a favor de este CMS y, sobre todo, explicarte cómo he transformado mi forma de trabajar con él para que sea algo divertido, eficiente y, por encima de todo, profesional. Vamos a dejar de lado las críticas vacías y vamos a centrarnos en el "cacharrero" del bueno: montando un entorno de desarrollo con Podman, utilizando Valkey para que todo vuele y automatizando las tareas con una herramienta que me tiene fascinado: Just.

Lo cierto es que entiendo las críticas cuando son razonadas. Es verdad que WordPress puede tener vulnerabilidades, pero ¿qué software masivo no las tiene? Al final, es una cuestión de números: cuanto más se usa algo, más se intenta atacar. Pero no podemos olvidar que grandes corporaciones, tiendas de e-commerce masivas e incluso la propia Casa Blanca confían en WordPress. Si estás buscando una oportunidad de negocio, aprender a dominar WordPress por dentro —creando tus propios temas y complementos— es una de las mejores inversiones que puedes hacer hoy en día.

Hoy en día, desarrollar sin contenedores me parece un error fundamental. Los contenedores te dan la libertad de usar exactamente la misma versión de PHP o MariaDB que tienes en tu servidor de producción, sin importar lo que soporte tu sistema operativo local. Y como no podía ser de otra forma, he montado todo este tinglado con Podman.

Mi nuevo stack de desarrollo incluye:

• WordPress con PHP-FPM: Para un rendimiento óptimo.
• MariaDB: Nuestra base de datos de confianza.
• Valkey: El reemplazo de código abierto para Redis. Espectacular para cachear consultas y acelerar la web.
• Nginx: Como proxy inverso para gestionar imágenes, estilos y la conexión con PHP de forma eficiente.

• 00:00:00 Introducción y por qué critican a WordPress
• 00:01:22 WordPress: El gigante que domina internet
• 00:03:08 Más allá del blog: E-commerce y grandes empresas
• 00:03:40 WordPress como oportunidad de negocio y carrera
• 00:04:52 La historia de Atareao.es sobre WordPress (desde 2009)
• 00:06:30 De temas de terceros a un desarrollo propio complejo
• 00:07:57 Borrón y cuenta nueva: Buscando la sencillez
• 00:08:50 El error de no usar contenedores para desarrollar
• 00:10:03 Mi stack con Podman: PHP-FPM, MariaDB y Valkey
• 00:12:07 Just: El gestor de tareas que sustituye a Make
• 00:13:54 Automatizando con Just: Install, Start y Status
• 00:16:30 Entornos idénticos: De local a producción
• 00:17:15 Gestión inteligente de secretos y configuración de Nginx
• 00:19:23 Estrategia de copias de seguridad y restauración de la DB
• 00:20:26 Resumen: Un entorno profesional en cuatro pasos
• 00:22:17 Despedida y cierre 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

¡Hola a todos! Bienvenidos al episodio 785. Hoy nos metemos de lleno en las entrañas de FISH, una de las herramientas más potentes para cualquier amante de Linux. Si alguna vez has sentido que tu terminal podría trabajar un poco más por ti, este es tu episodio.

Los eventos en FISH son como pequeños disparadores que te permiten ejecutar acciones automáticamente en respuesta a lo que haces. Vamos a ver casos de uso reales: desde cómo configurar alertas inteligentes hasta cómo evitar errores catastróficos. También descubrirás mi secreto personal para no volver a perder nunca más un comando largo que hayas borrado por error al presionar la combinación de teclas prohibida.

Temas destacados:

• La diferencia entre FISH y otras shells clásicas.
• Cómo implementar un sistema de auditoría básica.
• Ejemplos prácticos para mejorar tu productividad diaria.
• Cómo manejar el portapapeles directamente desde la terminal.

Índice:

• 00:00:00 Introducción al episodio 785
• 00:00:26 ¿Qué es FISH y por qué lo uso?
• 00:02:33 El poder de los eventos en FISH
• 00:04:49 ¿Dónde configurar tus eventos?
• 00:08:42 Ejemplo 1: Avisos automáticos en proyectos RAST
• 00:09:41 Ejemplo 2: Auditoría de comandos críticos
• 00:10:59 Ejemplo 3: Manejo elegante de errores
• 00:12:19 Ejemplo 4: Acciones al cerrar sesión
• 00:13:35 Truco Pro: Recuperar comandos borrados con CTRL+C
• 00:17:35 Conclusiones y próximos pasos

Espero que disfrutes de este contenido tanto como yo al prepararlo. ¡Prepárate para llevar tu terminal al siguiente nivel!

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 posible mantener la extrema sencillez de Dockge mientras aprovechamos la robustez y seguridad de Podman? La respuesta es un rotundo sí, y en este episodio te explico exactamente cómo lo he configurado en mi propia infraestructura.

Llevo semanas explorando alternativas para la gestión de contenedores, pero siempre acabo volviendo a Dockge. Su capacidad para levantar un stack simplemente pegando un Docker Compose es imbatible para quienes disfrutamos probando nuevas herramientas cada día. Sin embargo, mi migración a Podman planteaba un reto: no quería perder esa agilidad ni tampoco comprometer la seguridad del sistema.

En este podcast detalle mi "fórmula ganadora":

• Quadlets: Cómo he encapsulado Dockge y Traefik para que se comporten como servicios nativos del sistema.
• Seguridad Rootless: La ventaja de correr Dockge bajo un usuario sin privilegios, eliminando riesgos de escalada de privilegios.
• Persistencia: La gestión de volúmenes y cómo Dockge almacena los archivos Compose de forma transparente en el sistema de archivos.
• Hibridación: Mi estrategia para decidir qué servicios van en Quadlets y cuáles se quedan en Dockge.

Además, comentamos características fundamentales como el terminal web interactivo incorporado, ideal para solventar problemas rápidos (como borrar un volumen rebelde) cuando estás fuera de casa y solo tienes una tablet a mano. Si te interesa el self-hosting, la administración de servidores Linux y quieres simplificar tu flujo de trabajo con contenedores, este episodio es para ti.

Capítulos del episodio:

• 00:00:00 Introducción y el dilema de la gestión de contenedores
• 00:01:41 El miedo a la migración: De Docker a Podman
• 00:02:46 La gran noticia: Dockge funcionando como Quadlet
• 00:03:09 ¿Qué es Dockge? La alternativa sencilla a Portainer
• 00:05:14 Características clave: Editor interactivo y terminal web
• 00:06:09 Gestión remota: El uso de agentes y múltiples VPS
• 00:07:33 Funciones avanzadas: De comandos Docker a Compose
• 00:08:55 La ventaja competitiva: Podman Rootless y seguridad
• 00:09:41 Anatomía de un Quadlet para Dockge
• 00:10:45 Configuración de volúmenes y persistencia de Stacks
• 00:11:24 Integración con Traefik y Health Checks en Podman
• 00:12:22 Cómo gestionar tus archivos Compose y Dotfiles
• 00:13:58 El gran debate: ¿Cuándo usar Quadlets vs Dockge?
• 00:15:53 Conclusiones: Seguridad, simplicidad y futuro
• 00:17:12 Despedida y comunidad Atareao con Linux

Únete a la conversación en nuestro grupo de Telegram y descubre más en atareao.es.

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 número 783, te sumerjo en una historia real de "poltergeist" en Docker que me mantuvo en vilo durante horas. Te cuento cómo una serie de eventos desafortunados, mezclados con un poco de nerviosismo técnico, me llevaron a cometer uno de los errores más temidos por cualquier administrador de sistemas: un borrado masivo de volúmenes que no debía ocurrir.

Hablamos a fondo sobre la arquitectura de servicios self-hosted. Te explico por qué prefiero mantener una base de datos independiente para cada aplicación, analizando los pros y contras en cuanto a consumo de recursos y flexibilidad de versiones. Esta decisión, que normalmente me ahorra problemas, fue el escenario de un comportamiento errático donde las imágenes de PostgreSQL empezaron a mutar de forma extraña, cambiando tamaños y arquitecturas sin intervención directa.

A lo largo del audio, descubrirás cómo logré identificar al culpable (spoiler: Watchtower y WhatsApp Docker tienen mucho que ver) utilizando modelos de lenguaje como Gemini para realizar un análisis forense de los logs. Esta experiencia ha sido el empujón final que necesitaba para confirmar mi transición total hacia Podman.

Lo que aprenderás en este episodio:

• La importancia de taguear correctamente las imágenes y evitar el uso de "latest".
• Cómo reaccionar (y cómo no hacerlo) ante un contenedor que entra en bucle de reinicio.
• Las ventajas críticas de Podman sobre Docker en la gestión de actualizaciones y rollbacks automáticos.
• El papel de la IA como asistente en la resolución de problemas técnicos complejos.

Marcadores de tiempo:

00:00:00 Introducción: Una historia de terror en Linux
00:02:04 Mi estrategia: Un contenedor de base de datos por servicio
00:03:19 El dilema del consumo vs. la independencia de versiones
00:05:58 El inicio del caos: Notificaciones de Matrix y reinicios
00:07:34 Investigando el fallo: ¿Versiones desalineadas o brujería?
00:09:38 El misterio del Release Candidate y el engorde de imágenes
00:11:24 El error fatal: Un "System Prune" sin prejuicios
00:12:31 Análisis forense con Gemini: Encontrando al culpable
00:13:36 El culpable revelado: WhatsApp Docker y Watchtower
00:15:36 Reflexiones post-catástrofe: La migración definitiva a Podman
00:16:40 Ventajas de Podman: Actualizaciones nativas y Rollbacks
00:18:11 Despedida y red de podcast

Si quieres compartir tus propias historias de terror o aprender más sobre el mundo Linux, únete a nuestra comunidad en Telegram buscando "Atareao con Linux". ¡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

¡Hola! Soy Lorenzo y bienvenidos a un nuevo episodio de Atareao con Linux. Hoy te traigo una noticia importante: mi equipo personal ya es 100% libre de Docker. He completado la transición total al ecosistema de Podman, pero el camino no termina aquí. Ahora me toca enfrentarme a la migración de la infraestructura de producción de atareao.es, y en este proceso he descubierto el verdadero potencial de la construcción de imágenes con Buildah.

En este episodio, exploramos por qué Buildah es el compañero perfecto para Podman. Te explico las razones detrás de su nombre y, lo más importante, cómo cambia las reglas del juego al permitirnos construir imágenes mediante scripting puro. Si te gusta el control total y la flexibilidad de Bash o Fish, Buildah te va a encantar.

• Adiós a las capas infinitas: Cómo Buildah gestiona el sistema de archivos de forma directa y eficiente.
• Scripting vs. Declarativo: Las ventajas de usar un lenguaje imperativo frente al tradicional Dockerfile.
• Seguridad extrema: Mi caso de uso real creando un servidor WebDAV con Nginx en modo rootless y sin usuario root interno.
• Criterios de elección: Cuándo te conviene seguir usando Dockerfiles por compatibilidad y cuándo Buildah es la herramienta quirúrgica que necesitas.

Hablamos de transparencia, control, eficiencia de capas y, por supuesto, de los desafíos técnicos que supone aprender una nueva forma de trabajar. Si eres un apasionado de los contenedores y quieres llevar tu productividad en Linux al siguiente nivel, no te puedes perder este análisis detallado.

• 00:00:00 Introducción: Adiós definitivo a Docker
• 00:01:13 El reto de migrar atareao.es a Podman
• 00:02:17 Construcción de imágenes: La pieza que faltaba
• 00:03:19 ¿Por qué se llama Buildah? Curiosidades y Naming
• 00:04:15 Diferencias filosóficas: Buildah vs Docker
• 00:05:40 El poder del Scripting en la creación de imágenes
• 00:07:54 Comparativa técnica: Transparencia vs Control
• 00:09:38 Eficiencia de capas y el "Squashing" nativo
• 00:11:32 Ventajas de Buildah: Pruebas atómicas y variables dinámicas
• 00:12:46 Inconvenientes: Dependencia del host y curva de aprendizaje
• 00:14:46 ¿Cuándo usar cada uno? Consejos para equipos personales y CI/CD
• 00:16:32 Caso práctico: WebDAV con Nginx, Rootless y sin Root
• 00:18:03 Conclusiones y próximos pasos

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 vamos a resolver un problema que nos afecta a muchos: la gestión de WhatsApp en el escritorio Linux sin morir en el intento ni comprometer nuestra privacidad.

A pesar de que soy un firme defensor de Telegram por todas las opciones de automatización y trabajo que me ofrece, la realidad es que para comunicarme con ciertas personas necesito WhatsApp. Tras el cese de funcionamiento de herramientas populares como ZapZap, he encontrado la solución definitiva mediante el uso de Progressive Web Applications (PWA), pero con un giro especial: haciéndolo funcionar en Firefox.

En este episodio técnico pero accesible, profundizamos en:

• La filosofía de uso: Por qué he dejado de intentar convencer a los demás de migrar de plataforma y cómo me adapto a las herramientas que otros usan para ser más productivo.
• PWA for Firefox: Un análisis detallado de esta extensión y su binario en Rust que permite lo que Mozilla aún no ofrece de forma nativa.
• Aislamiento de perfiles: La enorme ventaja de separar tus aplicaciones web (WhatsApp, Telegram, Gemini, Google Docs) en contenedores estancos para mayor seguridad y orden.
• Instalación y Configuración: Los pasos necesarios para integrar estas aplicaciones directamente en tu lanzador de aplicaciones de Linux, como si fueran nativas.
• Privacidad: Cómo aprovechar el motor de protección de Firefox frente al rastreo mientras usamos servicios de terceros.

Si alguna vez has sentido que tu flujo de trabajo se fragmenta al tener que abrir el navegador para responder un mensaje, este episodio te abrirá las puertas a un escritorio mucho más integrado y eficiente.

Capítulos:

00:00:00 Introducción: El dilema de WhatsApp en el escritorio
00:01:45 Telegram vs WhatsApp: ¿Por qué no intento convencerte?
00:03:42 Mi flujo de trabajo: Cuándo uso cada herramienta
00:04:45 El problema con ZapZap y las apps de terceros
00:05:08 La inspiración: PWA y el consejo de Antonio Manfredi
00:06:40 El reto de las Progressive Web Applications en Firefox
00:07:08 PWA for Firefox: La extensión que lo cambia todo
00:07:54 Ventajas técnicas: Perfiles aislados y multiplataforma
00:08:45 Soporte avanzado: Controladores de protocolos y archivos
00:09:40 Seguridad y gestión de credenciales con Bitwarden
00:10:55 Limitaciones actuales y beneficios del antirrastreo
00:12:01 Guía de instalación: El binario de Rust y la extensión
00:13:37 Mi experiencia personal: Migrando Telegram y Gemini a PWA
00:14:55 El riesgo de la dependencia y por qué elijo Firefox
00:16:15 Conclusión y comunidad Atareao con 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