Atareao con Linux

Este episodio nos vamos a meter de lleno en el barro del cacharreo del bueno para hablar de algo que me tiene completamente entusiasmado y sin dormir de la emoción en los últimos días: el maravilloso e increíble mundo del futuro agéntico. Sí, sí, has oído bien. Vamos a desgranar cómo dar el salto definitivo de esos chats de Inteligencia Artificial tan aburridos en los que solo escribes una pregunta y esperas una respuesta, a tener un auténtico colaborador activo que haga tareas reales por ti en tu propia máquina.Seguro que te ha pasado alguna vez. Estás usando un modelo de lenguaje, le pides ayuda para tu proyecto personal o para organizar tus notas de Linux, y de repente te das cuenta de que la IA se ha quedado congelada en el tiempo. Su conocimiento es completamente estático, no tiene ni la más remota idea de tus datos, de tus notas en Markdown, de tus contenedores ni de tus flujos de trabajo. Y lo peor de todo: cuando no sabe algo, en lugar de callarse, ¡se lo inventa con una tranquilidad que asusta! Básicamente, alucina. Las IAs de hoy en día, tal y como nos las venden de fábrica, están completamente aisladas del entorno, del tiempo y de tus propios procesos de trabajo. Son como un trozo de corcho flotando a la deriva en mitad del océano: muy ligeras y con potencial, pero incapaces de hacer nada útil de forma autónoma.¿Y cuál es la solución para dejar de tener una IA "tonta" y aislada? No se trata de una única tecnología mágica, sino de combinar con cabeza tres piezas fundamentales que le darán superpoderes a tu asistente: el RAG (la memoria), los MCP (las manos) y las Skills (los manuales de instrucciones).Cuando consigues orquestar estas tres piezas en tu propio host local, la magia ocurre. Consigues crear un asistente de verdad, como mi querido Hermes, que es capaz de redactar los textos que necesito para este podcast, gestionar mis recordatorios y organizar mis notas de forma totalmente autónoma mientras yo me lo paso pipa programando.Capítulos del episodio:00:00:00 ¡Bienvenidos al futuro agéntico!00:01:21 Lo que se viene en este episodio (y en los próximos)00:02:42 ¿Por qué las IAs hoy en día son "tontas" e inútiles?00:04:36 La solución: Skills, RAG y MCP explicados fácil00:06:14 La analogía del nuevo empleado en tu empresa00:07:38 El agente de IA como el gran director de orquesta00:08:21 ¿Qué es el RAG? (Conocimiento en tiempo real sin fine-tuning)00:11:17 Mi RAG propio en Rust para archivos Markdown00:12:39 ¿Qué es el MCP? (La revolución de Anthropic)00:14:55 Cómo usar MCP para conectar tu IA con el mundo real00:16:14 Mis servidores MCP: SearXNG, Invidious y listas de tareas00:18:10 Skills: Ahorro de tokens y flujos de trabajo inteligentes00:20:11 La matriz definitiva: Memoria, Manos y Manuales00:22:04 De un chat reactivo a un colaborador activo (Mi asistente Hermes)00:23:54 Próximos pasos, descargas de código y despedidaMás información y enlaces en las notas del episodio

¿Quieres usar agentes de IA para programar sin arruinarte? En este episodio de atareao con Linux comparo las dos opciones más interesantes para desarrolladores en 2026: OpenCode Go y OpenRouter.Durante las últimas semanas he estado completamente volcado con OpenCode, usándolo tanto para generar código como para revisar código existente. Y en el proceso me he encontrado con una pregunta clave: ¿cómo accedo a los modelos de IA sin arruinarme?La respuesta no es trivial. Tienes dos opciones clásicas: comprar hardware dedicado o pagar servicios en la nube como ChatGPT o Gemini. Pero hay una tercera vía: combinar herramientas open source con servicios de bajo coste.En este episodio te cuento:Qué es OpenCode Go y por qué $10/mes pueden ser suficienteQué es OpenRouter y cómo usar 400+ modelos (algunos gratis)Comparativa directa de precios, modelos, ventajas y desventajasCuál elegir según tu caso de usoCaso práctico: cómo mejoré mi herramienta Shul con skills de Rust y ReactPor qué las skills son el verdadero game-changer de los agentes de IATambién te adelanto lo que viene en los próximos episodios: flujo de trabajo completo con skills, RAG, MCPs... la cosa se pone muy caliente.Capítulos:00:00 — Introducción: el dilema de la IA y el dinero02:30 — ¿Qué es OpenCode?04:50 — OpenCode Go: la suscripción de $10/mes08:20 — OpenRouter: el agregador de 400+ modelos10:50 — Comparativa directa13:00 — Caso práctico: mejorando Shul con Skills16:00 — El poder de las Skills19:00 — Conclusiones y cuál elegir22:00 — Próximos episodiosMás información y enlaces en las notas del episodio

En el episodio de hoy, el número 796, vengo con muchas ganas de contarte algo que me tiene completamente fascinado.Pero vamos a lo importante: las Skills o habilidades. Si creías que la inteligencia artificial era solo un chat donde escribir preguntas y recibir respuestas, prepárate, porque hoy vamos a ver cómo dotar a nuestros modelos de lenguaje de auténticos "superpoderes" técnicos.¿Qué son realmente las Skills?Imagina que en lugar de darle instrucciones genéricas a tu modelo (lo que conocemos como prompt), le proporcionas una estructura especializada. Una Skill es una herramienta transversal que le enseña al modelo a comportarse como un experto en una materia concreta. Lo maravilloso es que estas habilidades no dependen de un solo modelo; puedes usarlas con Claude, con OpenCode, con Hermes o con cualquier otro agente. Es una forma de democratizar el conocimiento técnico y hacerlo reutilizable.En este episodio te cuento mi experiencia personal utilizando estas habilidades para tareas que, de normal, nos llevarían bastante tiempo de configuración. Desde crear contenedores Docker optimizados hasta gestionar bases de datos complejas sin escribir una sola línea de SQL.Soberanía Digital y Potencia LocalYa sabes que me encanta el lema de "yo me lo guiso, yo me lo como". Aunque existen servicios externos muy económicos para correr estos modelos, nada supera la sensación de tener el control total. Te hablo de mi configuración actual: un Slimbook con una Nvidia GeForce RTX 4060 Ti de 16 GB de VRAM. Con este hardware estoy corriendo modelos como el Qwen de 35 billones de parámetros con una fluidez espectacular. Aquí es donde la soberanía digital cobra sentido: mis datos, mis reglas y mi hardware.Ejemplos prácticos: Docker y SQLiteA lo largo del audio, te guío por dos ejemplos que me han dejado con la boca abierta:Docker Expert.SQLite Expert.La Anatomía de una Skill: Bajo el capóMenciono también el increíble trabajo de Daniel Primo en Web Reactiva, quien ha profundizado muchísimo en este tema de las Skills y cuya guía ha sido una fuente de inspiración fundamental para experimentar con todo esto.Conclusión: El futuro es el lenguaje naturalCapítulos:00:00:00 El troleo a David y la importancia del feedback00:00:41 Introducción a las Skills: Dale "poderes" a tu IA00:01:14 Repaso a OpenCode y el paso a la soberanía digital00:02:11 Mi hardware: Slimbook, Nvidia RTX 4060 Ti y el modelo Qwen00:02:55 ¿Qué son realmente las Skills y por qué usarlas?00:04:18 Ejemplo práctico: Instalando una Skill para Docker00:04:58 Recomendación: La guía de Skills de Daniel Primo00:06:08 Generando un Dockerfile complejo para Rust en dos etapas00:07:34 Anatomía de una Skill: Front Matter, YAML y Markdown00:09:25 Cómo el agente gestiona los tokens y las habilidades00:10:48 Verificación del Dockerfile generado por la IA00:12:11 Trabajando con bases de datos: Skill de SQLite Expert00:13:24 Experiencia real: Revisando código Backend y Frontend00:15:38 Consultas en lenguaje natural sobre la base de datos00:17:40 Tipos de Skills: Percepción, Acción y Pensamiento Complejo00:19:47 Conclusiones: Programar sin programar y modelos locales00:20:29 Despedida y red de sospechosos habitualesMás información, enlaces y notas en https://atareao.es/podcast/796

Si eres de los que piensa que para crear tus propias herramientas necesitas pasarte años estudiando sintaxis complejas o que estás vendido a lo que digan las grandes corporaciones de la Inteligencia Artificial, prepárate, porque hoy vamos a romper esos mitos con OpenCode.Democratizando el código con OpenCodeLa gran estrella de hoy es OpenCode. Imagina un agente de inteligencia artificial especializado en programación que no te obliga a usar un solo modelo. A diferencia de otras soluciones cerradas, OpenCode es de código abierto. Esto significa que tú tienes el control total: puedes conectarlo con modelos en la nube como Claude o GPT-4, o lo que es más emocionante para los que amamos el auto-alojamiento, puedes usarlo con modelos locales a través de Ollama. En el episodio de hoy, te cuento cómo he puesto a trabajar a este agente para crear, desde cero, una aplicación en Rust que descarga transcripciones de vídeos de YouTube. Yo solo le he dado las instrucciones de lo que quería conseguir y el agente se ha encargado de proponer el plan, elegir las librerías adecuadas (como YouTube Transcript o Anyhow) y escribir cada línea de código mientras yo grababa este podcast. ¡Es como tener un compañero de programación que nunca se cansa!El dilema de los tokens y el modelo híbridoPero no todo es magia. También te cuento mis "penas" con los tokens. Te explico una anécdota real donde un modelo de IA se puso a "pensar" demasiado para solucionar un problema sencillísimo con un script para evitar que mis pantallas se apagaran (usando Stasis). De aquí sacamos una lección fundamental: la importancia de los modelos híbridos. En este episodio te explico por qué deberías delegar las tareas más pesadas y repetitivas a modelos locales que corren en tu propio equipo (gratis y privados) y reservar la potencia de la nube solo para cuando necesites un razonamiento complejo. Además, exploramos OpenCode Go, una opción de bajo coste para acceder a modelos abiertos sin arruinarse.Planificación y Tests: La IA que piensa antes de actuarUna de las funciones que más me han volado la cabeza es la capacidad de OpenCode para diferenciar entre planificar y ejecutar.Seguridad y el futuro en contenedoresSi alguna vez has tenido una idea para una aplicación pero te daba pereza empezar o no sabías por dónde hincarle el diente, este episodio es la señal que necesitabas. Es el momento de recuperar esos proyectos del cajón y empezar a materializarlos.Capítulos para no perderte nada:00:00:00 El truco de los 5 segundos y David Marzal00:01:08 Fartons y Podcast: Experiencias y agradecimientos00:01:57 ¿Qué es OpenCode? Programar sin escribir código00:02:54 Caso práctico: Herramienta en Rust para transcripciones de YouTube00:05:10 Un agente de IA de código abierto y multimodelo00:07:05 La importancia de no estar atado a un solo proveedor00:07:44 Modelos híbridos: Cuándo usar IA local vs. nube00:09:12 El peligro de los tokens: Mi experiencia con Stasis y el modo sleep00:12:36 OpenCode Go: Suscripción y acceso a modelos abiertos00:13:24 Configurando Ollama en local para programar00:15:10 Refinando la herramienta: Mejoras en la descarga por defecto00:17:58 Probando diferentes modelos: Qwen, DeepSeek y Kimi00:20:18 Modos de OpenCode: Planificación frente a Ejecución00:21:44 Implementando tests unitarios y de integración con el agente00:23:43 Delegando tareas repetitivas en el desarrollo web00:25:24 Seguridad: El futuro de ejecutar agentes en contenedores00:26:14 Próximos pasos: Skills y recomendación de Web Reactiva00:26:59 Despedida y comunidad Atareao en TelegramMás información y enlaces en las notas del episodio

Si en los últimos episodios te he hablado de las bondades de Open Web UI, hoy vamos a ensuciarnos las manos (de forma figurada, claro) para exprimir esta herramienta al máximo. No se trata solo de instalar un contenedor y ver qué pasa; se trata de convertir a tu inteligencia artificial en un asistente que realmente te conoce y tiene "superpoderes" gracias a herramientas personalizadas.Seguro que te ha pasado alguna vez: estás hablando con una IA y, de repente, parece que se le ha olvidado lo que le dijiste hace cinco minutos. Esto es lo que conocemos como el problema de la ventana de contexto. Los modelos tienen un límite de información que pueden procesar a la vez. En este episodio, te muestro cómo Open Web UI gestiona la memoria para que el asistente recuerde quién eres, cuáles son tus aficiones y hasta tus lenguajes de programación preferidos. Es fascinante ver cómo, tras una búsqueda en GitHub o en redes sociales, la IA es capaz de guardar esos detalles en su "cerebro" local para usarlos más adelante.Pero lo que de verdad me ha volado la cabeza es la posibilidad de crear herramientas (Tools). Imagina que necesitas calcular la distancia exacta entre dos ciudades para planificar una ruta de entrenamiento. Normalmente, la IA haría una búsqueda web más o menos precisa, pero ¿y si le pudiéramos enseñar a usar un script de Python específico para eso? En el podcast te cuento cómo la propia IA es capaz de programar su propia herramienta, dándote el código y las instrucciones para que la integres en tu interfaz. ¡Es el sueño de cualquier amante de la automatización!Además, tocamos un tema fundamental en los tiempos que corren: la privacidad y el coste. Las grandes tecnológicas se están dando cuenta de que mantener estos modelos cuesta una fortuna y ya estamos empezando a ver cómo suben cuotas o limitan el uso. Al trabajar en local, no solo te ahorras suscripciones, sino que te aseguras de que tus datos no salen de tu casa. Es soberanía tecnológica en estado puro.Lo que vamos a tratar en este episodio:00:00:00 - Introducción: Exprimiendo Open Web UI00:00:45 - Presentándome a mi propia IA local00:01:38 - La importancia de la memoria y el contexto en los LLM00:02:11 - Herramientas de búsqueda: ¿Qué sabe internet de Atareao?00:04:37 - Guardando información relevante en la memoria (RAG)00:05:04 - Consultas en tiempo real: El tiempo y el pronóstico00:06:20 - Ahorrando tokens: La importancia de ser conciso00:07:24 - Planificando un entrenamiento basado en datos meteorológicos00:10:02 - Cálculos de distancia y búsquedas web inteligentes00:11:54 - Crea tus propias herramientas (Tools) con Python00:14:32 - Configuración de herramientas personalizadas paso a paso00:16:12 - Integración de APIs externas (Nominatim) en local00:17:18 - Poniendo a prueba la memoria a largo plazo de la IA00:19:53 - Análisis de perfil de GitHub y lenguajes preferidos00:21:55 - Privacidad y ahorro: El fin de las subvenciones de las grandes Big Tech00:23:44 - De Google AI Studio a Open Web UI: El flujo de trabajo00:24:45 - Conclusiones y adelanto del próximo episodio: ¡Open Code!Te cuento también mi flujo de trabajo actual, cómo he pasado de herramientas en la nube como Google AI Studio a tenerlo todo bajo mi control con Open Web UI. Y ojo, que esto es solo el principio. En el próximo episodio abandonaremos un poco la interfaz de chat para meternos de lleno en Open Code, buscando siempre esa independencia tecnológica que tanto nos gusta.Más información y enlaces en las notas del episodio

Hoy vamos a meternos de lleno en las tripas de la inteligencia artificial local, porque sigo dándole vueltas a una herramienta que me tiene completamente robado el corazón: OpenWeb UI.Seguramente habrás oído hablar de ChatGPT, Gemini o Claude. Son herramientas increíbles, pero tienen un problema: no son tuyas. En este episodio, y probablemente en el siguiente, quiero contarte cómo estoy consiguiendo que mi propia IA en local no solo iguale a estas opciones comerciales, sino que en muchos aspectos las supere, especialmente en algo que a veces olvidamos: la soberanía digital y la capacidad de organización.¿Por qué OpenWeb UI es un cambio de juego?Lo que me ha volado la cabeza de OpenWeb UI es cómo reúne lo mejor de cada casa. He estado probando decenas —y no exagero, de verdad, decenas— de modelos distintos estos días. Mi objetivo era claro: ver cuánto consumen, qué rapidez de respuesta tienen y, sobre todo, hasta qué punto puedo sustituir mi flujo de trabajo en la nube por algo que corra en mi propio hardware. Una de las funciones que más me han gustado es el sistema de carpetas. Poder asignar un modelo específico a una carpeta de proyectos de Rust, y otro modelo distinto para resúmenes de artículos, es una maravilla que me permite "cacharrear" con una precisión que no encontraba en Gemini o ChatGPT.El misterio de la IA que se "emborracha"¿Te ha pasado que estás hablando con una IA y de repente empieza a decir cosas sin sentido o se olvida de lo primero que le dijiste? Eso es lo que yo llamo "borrachera de datos", y la culpa la tiene la ventana de contexto. En este episodio te explico qué es exactamente este espacio de memoria a corto plazo del modelo. Me encontré con un problema frustrante: mi IA local parecía tener memoria de pez. Y después de mucho investigar, descubrí que Ollama, el servidor de modelos que utilizo, define por defecto una ventana de contexto muy pequeña, a veces de solo 2.048 o 4.096 tokens.Para que te hagas una idea (esta es la regla de la servilleta que cuento en el audio): 4.000 tokens equivalen a unas 5 o 6 páginas de texto. Si le pasas unas instrucciones iniciales largas (el system prompt), le haces un par de preguntas y la IA te responde, ¡pum!, se acabó el espacio. En cuanto llegas al límite, la IA empieza a descartar lo primero que le dijiste. Por eso parece que se olvida de quién es o de qué le habías pedido.Matemáticas para no volverse loco con la RAMCapítulos del episodio:00:00:00 Presentación: Exprimiendo OpenWeb UI00:01:21 El experimento: Probando decenas de modelos locales00:02:19 Organización y carpetas: La gran ventaja frente a ChatGPT00:03:53 El núcleo del episodio: Modelos y Prompts00:05:00 LLM FIT: Cómo encontrar el modelo ideal para tu hardware00:06:14 ¿Qué es la ventana de contexto y por qué es vital?00:07:08 El límite oculto de Ollama: ¿Por qué tu IA tiene memoria de pez?00:08:33 Automatización: Ollama Audit y scripts de personalización00:10:38 Cómo modificar el contexto y crear modelos custom00:11:42 Matemáticas de la RAM: ¿Cuántos tokens caben en tu equipo?00:13:00 Guía rápida: Ventanas de contexto recomendadas según la tarea00:14:23 El equilibrio: Peso del cerebro vs Memoria de trabajo (KV Cache)00:15:42 El idioma importa: Tokens en español vs Inglés00:16:35 Por qué 4.000 tokens se quedan cortos (System Prompt e Historial)00:18:27 La analogía de la servilleta: Ejemplos de uso del contexto00:20:12 Calidad vs Velocidad: ¿Qué modelo elegir?00:21:41 Organización real: Mis Prompts y carpetas en OpenWeb UI00:24:33 Soberanía digital y despedidaMás información y enlaces en las notas del episodio

¿Te has fijado en que el panorama de la inteligencia artificial está cambiando a pasos agigantados? Lo que hasta hace dos días era un campo de juegos gratuito, donde podíamos probarlo todo sin soltar un euro, se está transformando rápidamente en un servicio de suscripción más, como la luz o el teléfono. Pero no solo es una cuestión de dinero. Hay algo que me preocupa mucho más: tu privacidad y la propiedad de tus datos.En este episodio número 792 de Atareao con Linux, quiero invitarte a dar un paso adelante en tu camino hacia la soberanía digital. Vamos a hablar de cómo montar tu propio laboratorio de inteligencia artificial en casa, utilizando una herramienta que es, sencillamente, una maravilla: Open WebUI. Olvídate de depender de servidores externos para tareas sensibles; es hora de que el motor de la IA corra en tus propias máquinas.¿Por qué Open WebUI?Si ya has escuchado episodios anteriores, sabrás que soy un gran fan de Ollama para ejecutar modelos en local desde la terminal. Pero seamos sinceros: la terminal es fantástica para muchas cosas, pero para mantener una conversación fluida con un modelo de lenguaje, todos preferimos una interfaz visual. Open WebUI es ese "vestido elegante" que le ponemos a nuestros modelos locales. Es una interfaz web que, nada más verla, te va a resultar familiar porque se parece muchísimo a ChatGPT o Gemini, pero con una diferencia fundamental: tú tienes el control total.Personalización y diversión: El caso de Leslie WinkleUna de las cosas que más me apasiona de esta herramienta es su "Model Builder". No se trata solo de elegir un modelo como Llama 3 o Gemma y empezar a escribir. Puedes ir mucho más allá. En el podcast te cuento cómo he creado un modelo específico con la personalidad de Leslie Winkle, el personaje de Big Bang Theory. Le he dado instrucciones precisas sobre cómo comportarse, quiénes son sus aliados y quiénes sus enemigos. El resultado es una IA con la que puedo "pelear" intelectualmente y que me llama "cerebro de corcho". Es divertido, sí, pero también demuestra el poder de crear asistentes especializados para tareas concretas de tu trabajo o tu día a día.Características que marcan la diferenciaGestión de usuarios y grupos.Soberanía de datos con RAG.Búsqueda Web PrivadaSoporte para fórmulas y código.Capítulos del episodio:00:00:00 ¡Al rico modelo local! Introducción00:00:27 El fin de la era "gratis" en la IA comercial00:01:31 Privacidad y bolsillo: Las dos razones para el local00:02:42 Más allá de la terminal: Buscando la interfaz ideal00:03:47 Presentando Open WebUI: El cerebro de tu laboratorio00:05:21 ¿Qué es exactamente Open WebUI?00:06:28 Personalización extrema: Mi charla con Leslie Winkle00:08:11 Gestión de usuarios y permisos granulares00:09:48 PWA, Markdown y soporte para fórmulas matemáticas00:10:55 Model Builder: Crea tus propios expertos a medida00:12:12 Integrando Python y funciones avanzadas00:13:34 Buscando en la web de forma privada con SearXNG00:15:13 Integraciones en la nube y bases de datos vectoriales00:16:08 Un vistazo al panel de administración y consumo00:18:24 El arte del Prompting: Carpetas y roles de sistema00:20:38 Mi infraestructura: Podman, Traefik y contenedores00:22:56 Recursos, chuletas y el repositorio de GitHub00:24:12 Despedida y red de Sospechosos HabitualesMás información y enlaces en las notas del episodio

¡Hola, muy buenas! Soy Lorenzo y hoy te traigo el episodio número 791 de Atareao con Linux. Si has estado siguiendo mis últimas aventuras tecnológicas, sabrás que me he sumergido de lleno en el fascinante mundo de los modelos de lenguaje locales. Sin embargo, a raíz de mis vídeos y artículos sobre Ollama, ha surgido una pregunta recurrente en la comunidad: ¿Por qué usar Ollama y no Llama.cpp directamente? ¿O es que acaso uno es mejor que el otro? En este episodio me he propuesto despejar todas tus dudas y, de paso, contarte algunas novedades sobre hardware que te van a dejar con la boca abierta.El origen: Entre amigos y tecnología en el Linux CenterTodo esto empezó a fraguarse en las recientes jornadas de Inteligencia Artificial que vivimos en el Linux Center junto a los amigos de Slimbook. Fue una experiencia increíble donde pude compartir charla con Alejandro López y Manuel Lemos. Ver el interés de la gente y cómo el curso se llenó por completo me dio una pista clara: todos queremos tener el control de nuestra propia IA. Alejandro, que es un gran impulsor de estos temas, me prestó un equipo que ha sido clave para mis pruebas actuales y del cual te hablo un poco más adelante en este audio.Llama.cpp: El quirófano de los tensoresPara entender la diferencia, hay que saber qué es cada cosa. Llama.cpp es el motor puro. Imagínate que es el motor de un coche de competición donde puedes ajustar hasta la última tuerca. Está escrito en C++ por Georgi Gerganov con un objetivo claro: el máximo rendimiento. Ollama: La experiencia de usuario elevada al máximoPor otro lado, tenemos a Ollama. Muchas veces se ven como rivales, pero la realidad es que Ollama utiliza Llama.cpp por debajo. La diferencia es que Ollama es un "envoltorio" o orquestador escrito en Go que nos facilita la vida de una manera brutal. Se encarga de gestionar la memoria de tu tarjeta gráfica (VRAM) de forma inteligente.Cacharreando con contenedores y personalidad propiaComo no podía ser de otra forma, yo he montado Llama.cpp usando Podman y Quadlets, integrándolo totalmente en mi flujo de trabajo. En este episodio te cuento cómo he configurado mi NVIDIA RTX 4060 Ti de 16GB para que vuele, permitiéndome usar contextos de hasta 128K.Hardware: NVIDIA y el silencio de las NPUUno de los grandes temas de este episodio es el hardware. Hago un repaso por las tarjetas de NVIDIA, desde la serie 30 hasta la potente serie 50. Pero la verdadera sorpresa ha sido el Slimbook One con NPU (Neural Processing Unit). La anatomía de los modelos: Rompiendo el código¿Alguna vez has visto nombres de modelos como "Mistral-7B-Instruct-v3-Q4_K_M.gguf" y te has sentido perdido?Capítulos del episodio para que no te pierdas nada:00:00 - Bienvenidos al episodio 791: Ollama vs Llama.cpp01:35 - Crónica de las jornadas de IA en el Linux Center con Slimbook03:34 - ¿Por qué hay tanta polémica entre Ollama y Llama.cpp?04:42 - Llama.cpp: El "quirófano" de los tensores y el rendimiento puro05:18 - Ollama: El orquestador que nos facilita la vida06:40 - Comparativa: ¿Qué hace uno que no haga el otro?07:59 - ¿Eres de IKEA o de fabricar tus propios muebles?09:00 - Cacharreando con Llama.cpp, Podman y Quadlets10:48 - Leslie: Mi IA con personalidad propia en OpenWeb UI12:44 - Cómo descargar modelos a mano con Rust HF Downloader13:50 - Hardware para IA: Guía rápida de tarjetas NVIDIA17:15 - La experiencia con el Slimbook One y su NPU integrada18:05 - Anatomía de un modelo: Entendiendo los nombres19:40 - La piedra de Rosetta de la cuantización21:08 - Conclusiones y próximos pasos con OpenWeb UIMás información y enlaces en las notas del episodio

¡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 realEn 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 OllamaA 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 detalladaPersonalidad y roles.Rendimiento puro.Creatividad bajo control.Capítulos del episodio:00:00:00 - Bienvenida y agradecimientos por la acogida00:00:40 - El laboratorio de IA: Recapitulando el episodio anterior00:01:34 - ¿Por qué bajar al barro con la terminal?00:03:31 - Preparando el entorno y monitorizando la GPU Nvidia00:05:00 - Flujo de trabajo: Arrancar el contenedor y el modelo00:05:35 - Comandos de ejecución, Podman y atajos útiles00:06:40 - Regalo: Una chuleta (cheat-sheet) para dominarlos a todos00:07:48 - Hablando con Ollama de forma interactiva00:08:24 - Meta-comandos: Descubriendo las tripas del modelo00:09:12 - Licencias y parámetros técnicos del modelo00:10:05 - Configurando el rol de experto desarrollador00:11:15 - Midiendo el rendimiento: Tokens por segundo00:12:00 - Modo silencioso y generación de scripts00:12:55 - Atajos de teclado y ayuda rápida00:13:35 - Ajustando la temperatura y la creatividad00:14:40 - Cómo guardar y cargar tus modelos personalizados00:15:20 - Poniendo a prueba a la IA: Verificación de código00:16:15 - Monitorización en tiempo real de CPU y GPU00:17:40 - Cómo elegir el modelo ideal según tu hardware00:19:08 - Próximos pasos: La REST API de Ollama00:20:30 - Despedida y consejos de vidaMás información y enlaces en las notas del episodio

¡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 OllamaNo 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 todosEste 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 Podman00:01:21 El empujón de Slimbook y el Linux Center00:02:15 El problema de depender exclusivamente de la nube00:03:15 El plan maestro: 32 episodios de IA práctica00:05:33 Tres razones para la IA local: Privacidad, pasta y latencia00:07:25 Filosofía "Juan Palomo": Exprimir los modelos con scripts00:08:08 El stack técnico: ¿Por qué Podman y no Docker?00:09:40 Ventajas del rootless y la seguridad en IA00:10:59 Quadlets: Integración total con Systemd00:11:53 Herramientas: Fish shell, Rust y Go al servicio de la IA00:13:20 Creando nuestra propia memoria digital (RAG)00:14:00 Estructura de directorios y repositorio Git00:15:37 El truco de los enlaces simbólicos para Quadlets00:16:02 Hardware: NVIDIA y el aprovechamiento de la GPU00:16:40 Desmenuzando el contenedor de Ollama00:17:54 QCTL: Mi herramienta para gestionar Quadlets fácilmente00:20:20 Comprobando que Ollama responde (CURL y API)00:21:15 Monitorización con NVTOP y VTOP00:22:13 Despedida y próximos pasos en el laboratorio localMás información y enlaces en las notas del episodio

¡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ónPara 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.es00:01:38 Mi evolución técnica: Del hosting al VPS y Docker00:02:17 Los modelos de lenguaje entran en juego00:03:00 Resultados brutales con menos esfuerzo00:04:20 Herramienta 1: Whisper, el arte de transcribir audio00:05:11 Fish Shell: El alma de mis automatizaciones00:07:04 Herramienta 2: Google AI Studio y la magia de los Prompts00:08:41 Mi flujo de trabajo: Del guion al minutaje00:09:30 Herramienta 3: Nano Banana (Gemini) para crear carátulas00:10:50 Automatizando el formato de imagen con Fish00:12:00 Reals-ESRGAN: Escalando imágenes con redes neuronales00:13:50 Herramienta 4: ImageMagick (Magic), la navaja suiza00:15:41 El procesado de audio: Normalización y filtros00:16:45 Conclusiones: Automatizar para disfrutar más00:18:04 Despedida y red de podcastComo 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

¡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.¿Por qué deberías usar eventos en tus scripts? 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 final00:01:28 Qué son los eventos y por qué van a simplificar tu vida00:02:40 Cómo declarar eventos con emit y on-event00:04:02 Ejemplo práctico: Notificaciones de escritorio y avisos en Telegram00:06:40 Las 3 grandes ventajas: Desacoplamiento, múltiples receptores y limpieza00:09:20 Introspección en Fish: Cómo ver tus handlers y eventos registrados00:11:05 Caso de éxito: Automatizando la compilación y despliegue de Rust00:13:58 Gestión de errores: Cómo evitar que un proceso falle en cascada00: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

¿WordPress es una porquería o es que no sabemos usarlo? Mi nuevo flujo con Podman¡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.WordPress: El gigante incomprendidoLo 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.El salto a los contenedores con PodmanHoy 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.Contenido del episodio por capítulos: 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 episodioMás información y enlaces en las notas del episodio

¡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 78500:00:26 ¿Qué es FISH y por qué lo uso?00:02:33 El poder de los eventos en FISH00:04:49 ¿Dónde configurar tus eventos?00:08:42 Ejemplo 1: Avisos automáticos en proyectos RAST00:09:41 Ejemplo 2: Auditoría de comandos críticos00:10:59 Ejemplo 3: Manejo elegante de errores00:12:19 Ejemplo 4: Acciones al cerrar sesión00:13:35 Truco Pro: Recuperar comandos borrados con CTRL+C00:17:35 Conclusiones y próximos pasosEspero 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

¿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 contenedores00:01:41 El miedo a la migración: De Docker a Podman00:02:46 La gran noticia: Dockge funcionando como Quadlet00:03:09 ¿Qué es Dockge? La alternativa sencilla a Portainer00:05:14 Características clave: Editor interactivo y terminal web00:06:09 Gestión remota: El uso de agentes y múltiples VPS00:07:33 Funciones avanzadas: De comandos Docker a Compose00:08:55 La ventaja competitiva: Podman Rootless y seguridad00:09:41 Anatomía de un Quadlet para Dockge00:10:45 Configuración de volúmenes y persistencia de Stacks00:11:24 Integración con Traefik y Health Checks en Podman00:12:22 Cómo gestionar tus archivos Compose y Dotfiles00:13:58 El gran debate: ¿Cuándo usar Quadlets vs Dockge?00:15:53 Conclusiones: Seguridad, simplicidad y futuro00: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

¿Alguna vez has sentido el terror de un comando mal ejecutado?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 Linux00:02:04 Mi estrategia: Un contenedor de base de datos por servicio00:03:19 El dilema del consumo vs. la independencia de versiones00:05:58 El inicio del caos: Notificaciones de Matrix y reinicios00:07:34 Investigando el fallo: ¿Versiones desalineadas o brujería?00:09:38 El misterio del Release Candidate y el engorde de imágenes00:11:24 El error fatal: Un "System Prune" sin prejuicios00:12:31 Análisis forense con Gemini: Encontrando al culpable00:13:36 El culpable revelado: WhatsApp Docker y Watchtower00:15:36 Reflexiones post-catástrofe: La migración definitiva a Podman00:16:40 Ventajas de Podman: Actualizaciones nativas y Rollbacks00:18:11 Despedida y red de podcastSi 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

¡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.¿Qué vas a aprender en este episodio? 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.Capítulos: 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 pasosMás información y enlaces en las notas del episodio

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 escritorio00:01:45 Telegram vs WhatsApp: ¿Por qué no intento convencerte?00:03:42 Mi flujo de trabajo: Cuándo uso cada herramienta00:04:45 El problema con ZapZap y las apps de terceros00:05:08 La inspiración: PWA y el consejo de Antonio Manfredi00:06:40 El reto de las Progressive Web Applications en Firefox00:07:08 PWA for Firefox: La extensión que lo cambia todo00:07:54 Ventajas técnicas: Perfiles aislados y multiplataforma00:08:45 Soporte avanzado: Controladores de protocolos y archivos00:09:40 Seguridad y gestión de credenciales con Bitwarden00:10:55 Limitaciones actuales y beneficios del antirrastreo00:12:01 Guía de instalación: El binario de Rust y la extensión00:13:37 Mi experiencia personal: Migrando Telegram y Gemini a PWA00:14:55 El riesgo de la dependencia y por qué elijo Firefox00:16:15 Conclusión y comunidad Atareao con LinuxMás información y enlaces en las notas del episodio

¡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

¿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

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

¡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

¿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

¿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

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

¿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

¿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

¿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

¿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

¿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

¿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

¡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

¿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

¿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

¿Es hora de jubilar tus viejos scripts de Bash?

¿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ítulos00:00:00 Introducción y el reto de migrar a Podman00:01:25 Adiós al demonio: El problema de la arquitectura de Docker00:02:33 Procesos independientes y aislamiento en Podman00:03:49 Integración nativa con Systemd y el modelo estándar de Linux00:04:41 Seguridad: Contenedores sin privilegios de administrador (Rootless)00:06:10 Una transición indolora: El alias de Docker a Podman00:07:33 Registries y gestión de imágenes personalizadas00:09:36 Gestión eficiente de logs y Journald00:11:20 Los Pods: Agrupación de contenedores y comunicación por localhost00:14:51 El patrón Sidecar para añadir funcionalidades00:15:40 Introducción a los Quadlets y futuro de la serie00: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

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?Timestamp00:00:00 Introducción y la transición de Bash a Fish00:00:50 Las limitaciones de los scripts complejos en Bash y Fish00:01:26 Por qué elegir Rust para optimizar el trabajo00:02:07 Introducción a Rust Script: Rust como lenguaje de scripting00:02:36 Próximos episodios técnicos: Profundizando en Podman00:03:59 Problemas comunes en Bash: Errores, tipos y datos estructurados00:04:50 El punto intermedio: Rust Script vs. proyectos completos con Cargo00:06:47 Ejemplo práctico: Cómo crear un "Hola Mundo" con Rust Script00:08:07 Funcionamiento interno: Compilación y caché de binarios00:09:43 Ejecución directa y permisos en archivos .rs00:10:44 Cómo instalar Rust Script en Arch Linux y vía Cargo00:11:32 Gestión de dependencias elegante dentro del script00:14:03 Ejemplo avanzado: Uso de múltiples crates y peticiones web00:16:32 Ventajas de trabajar con APIs JSON sin herramientas externas00:18:25 Resumen de beneficios: Potencia, tipado y velocidad00:20:13 Despedida y red de podcast Sospechosos Habituales

¿Sabías que hace poco más de 20 años España fue el epicentro mundial de una revolución tecnológica sin precedentes? En este episodio, nos alejamos de los tutoriales habituales para sumergirnos en la historia viva del software libre en nuestro país.Tengo el inmenso placer de charlar con Jesús González Barahona, profesor de la Universidad Rey Juan Carlos y referente indiscutible del código abierto, para presentaros un proyecto que nos hace especial ilusión: el nuevo podcast "La era de las distros".A principios de los 2000, nombres como LinEx, Guadalinex, LliureX o MAX no eran solo nombres de software; eran apuestas políticas y sociales por la independencia digital. En este episodio analizamos:El rescate de la memoria: Por qué es urgente entrevistar a los protagonistas de esta hazaña antes de que su legado se pierda.La anomalía española: Cómo fue posible que diversas administraciones públicas lideraran el despliegue de miles de equipos con Linux mucho antes de que fuera "cool".Soberanía y libertad: El software libre no como un ahorro de costes, sino como una herramienta para adaptar la tecnología a las necesidades de los ciudadanos.El presente del pasado: El sorprendente hecho de que muchas de estas distribuciones siguen hoy más vivas que nunca en las aulas españolas.Este nuevo podcast no es solo para técnicos. Es un documental sonoro que explora la intersección entre política, sociedad y tecnología. A través de entrevistas con técnicos, gestores y visionarios, reconstruimos el mapa de una época donde España fue pionera en soberanía tecnológica europea.Estreno del proyecto: 19 de enero.00:00:00 Presentación: Atareado con Linux y nuevos proyectos00:01:42 Introducción al nuevo podcast: La era de las distros00:01:58 Presentación de Jesús González Barahona00:02:45 Qué es La era de las distros00:03:45 El impacto de las distribuciones autonómicas en España00:05:18 Divulgación y accesibilidad del podcast para no informáticos00:08:25 Razones por las que estos proyectos no son ampliamente conocidos00:11:46 Vigencia actual de proyectos como LinEx, LliureX y MAX00:12:40 Origen y motivación del proyecto de registro documental00:18:21 Sentimientos encontrados: entre el éxito y la amargura00:21:32 La colaboración inesperada entre diferentes comunidades00:24:15 Situación geopolítica actual y soberanía tecnológica europea00:31:56 Conclusión y fecha de estreno del nuevo podcastWeb oficial: atareao.esGrupo de Telegram: atareao con linuxSigue el proyecto en: La era de las distros (disponible a partir del 19 de enero en las principales plataformas).¿Te gusta este contenido? No olvides dejar una valoración de 5 estrellas en Apple Podcast o Spotify, ¡me ayuda muchísimo a seguir difundiendo el software libre!Más información y enlaces en las notas del episodio

¿Alguna vez has sentido que tu servidor Linux se queda sin aliento por falta de espacio? Muchas veces nos obsesionamos con comprar más almacenamiento, ampliar la cuota de nuestro VPS o añadir discos al NAS, pero la solución no suele ser gastar más, sino limpiar mejor. En este episodio, te cuento cómo descubrí que tenía un "inquilino" con síndrome de Diógenes digital: Docker.Acompáñame en esta "limpieza de año nuevo" donde pasamos la motosierra a más de 600 GB de basura que no servían para nada y que Docker había ido acumulando silenciosamente en mi sistema.No podemos limpiar lo que no vemos. El primer paso es realizar un análisis profundo del almacenamiento. Mientras que herramientas como df -h o dust nos dan una idea general, Docker requiere una mirada específica para entender su estructura de datos.El comando estrella: docker system df es la herramienta fundamental que te dirá exactamente cuántas imágenes, contenedores y volúmenes tienes, pero sobre todo, cuánto espacio es reclaimable (recuperable inmediatamente).En mi caso, el gran culpable no eran las imágenes activas, sino el Build Cache, con cientos de capas intermedias acumuladas tras semanas programando y compilando proyectos en Rust.No se trata de borrar por borrar. Si eliminas todo el caché de construcción de golpe, la próxima vez que necesites compilar un proyecto el proceso será eterno porque Docker tendrá que descargar y reconstruir todo desde cero.Limpieza Quirúrgica: La clave está en usar filtros temporales como --filter "until=48h". Esto permite mantener lo que estás usando en tu desarrollo diario mientras fulminas los archivos obsoletos de la semana pasada.Volúmenes Huérfanos: Aprenderemos a identificar esos datos que quedan "vivos" después de que el contenedor ha sido eliminado y que solo sirven para ocupar espacio innecesario.El problema de los Logs: Si no configuras la rotación, los registros de texto pueden crecer hasta el infinito. Te enseño a usar fd para localizarlos de forma rápida y cómo configurar el archivo daemon.json para limitar su tamaño de forma definitiva.Como buen amante de la eficiencia y la productividad, no quiero tener que ejecutar estos comandos a mano cada semana. He diseñado un script de limpieza llamado docker-clean que gestiona de forma segura contenedores parados, imágenes sin etiqueta y el monstruoso caché de construcción.Para que el sistema se mantenga "hecho un figurín" de forma automática, te explico cómo programar este script mediante un Systemd Timer. Así, cada domingo a las 8:00 AM, tu servidor realizará su propia labor de mantenimiento sin que tú tengas que mover un dedo.00:00:00 La obsesión por el almacenamiento00:01:18 Docker: Un acumulador de basura en tu sistema00:03:40 Diagnóstico profundo con df y dust00:05:45 El comando estrella: docker system df00:07:32 El monstruo del Build Cache y las capas intermedias00:10:24 Volúmenes huérfanos: el cementerio de datos00:11:21 Gestión quirúrgica de registros (logs) con fd00:14:36 Mi script personal de limpieza: docker-clean00:16:18 Automatización total con Systemd Timers00:18:07 Conclusión y propósito de año nuevoPuedes encontrar todos los comandos, el script de limpieza completo y las configuraciones del timer y el servicio en las notas detalladas del episodio en: https://atareao.es¿Y tú? ¿Has comprobado cuánto espacio te está robando Docker hoy? Pásate por el grupo de Telegram t.me/atareao_con_linux y comparte con la comunidad cuántos gigas has logrado recuperar.#Linux #Docker #SelfHosted #DevOps #Atareao #Productividad #SysAdmin #Rust #OpenSourceMás información y enlaces en las notas del episodio

¡Feliz 2026! Comenzamos el año con un episodio cargado de novedades y proyectos que buscan devolver algo de valor a la comunidad del software libre. En esta entrega, te presento dos "regalos" especiales: el renacimiento de una herramienta técnica para creadores de contenido y el anuncio de un nuevo podcast sobre la historia de Linux en España.Todo surge a raíz de una invitación de José Jiménez para participar en una mesa redonda sobre el estado de los podcasts de Linux, junto a David Marzal (KDE Express), Jose (KernelCast) y bajo la impecable producción de David Baquero (Cursos de Desarrollo). Durante esa charla, surgió la recomendación de llevar los contenidos de audio a YouTube para alcanzar nuevas audiencias.Fue en ese momento cuando surgió el recuerdo de Audiowave, un pequeño script que desarrollé hace ocho años para generar vídeos con ondas de audio dinámicas. La idea original era permitir que los audios estuvieran disponibles en plataformas de vídeo incluso cuando el creador no deseara aparecer físicamente en pantalla. El reto actual ha sido no solo recuperar la herramienta, sino darle el "cariño" que merece para los estándares de calidad actuales.Lo que comenzó como un simple envoltorio (wrapper) de FFmpeg escrito en Bash, ha evolucionado hacia una herramienta robusta desarrollada en Rust. Esta nueva versión no solo es más rápida y segura, sino que introduce un nivel de personalización profesional:Sistema de plantillas: Ahora es posible definir estilos reutilizables mediante archivos de configuración, controlando dimensiones, colores y la disposición de todos los elementos visuales.Automatización de metadatos: La herramienta es capaz de extraer el título, el subtítulo y la carátula directamente de los archivos MP3, simplificando al máximo el flujo de trabajo del podcaster.Filtros visuales avanzados: Gracias a la potencia de FFmpeg, Audiowave permite generar desde ecualizadores de múltiples bandas hasta ondas circulares que se modulan en tiempo real con la voz.Optimización de renderizado: Aunque los estilos más complejos pueden requerir un tiempo de procesamiento considerable, el resultado final es una pieza de vídeo de alta fidelidad.La motivación principal para actualizar Audiowave es el lanzamiento de "La era de las distros". Este nuevo podcast documental se centra en las distribuciones Linux autonómicas que nacieron en España a principios de los años 2000, tanto las oficiales respaldadas por instituciones como las iniciativas independientes.A través de sus propios protagonistas, el podcast explora cómo estos proyectos fueron piezas clave en la estrategia de digitalización de diversas comunidades autónomas. Es un ejercicio de memoria histórica tecnológica que revela hitos asombrosos, como la instalación desde cero de más de 100.000 ordenadores con Linux hace ya un cuarto de siglo. Es un pasado fascinante que a veces olvidamos mientras nos maravillamos con noticias similares que llegan hoy desde otros países.Este episodio es una invitación a explorar las herramientas que el código abierto pone a nuestra disposición para comunicar mejor, y un adelanto de un viaje sonoro por la historia del software libre en nuestro país.Más información y enlaces en las notas del episodio

¿Qué hace realmente un usuario de Linux durante todo un año? En este episodio no teorizamos: auditamos. He analizado mi historial de comandos de 2025 y los datos no mienten.Desde el dominio absoluto de Rust hasta la sorprendente eficiencia de uv en Python, hoy te desvelo las 20 herramientas que han vertebrado mi flujo de trabajo. Hablamos de productividad real, de cómo Neovim ha desplazado definitivamente a mis antiguos editores y de por qué herramientas como just o yadm son las joyas ocultas que deberías estar usando ya.En este episodio descubrirás:El Stack de la Eficiencia: Mi top 20 analizado por categorías (Desarrollo, Sistema y Navegación).La transición a Rust: ¿Por qué cargo es el motor de mi día a día?Adiós a la fricción: Cómo herramientas modernas están sustituyendo a los comandos clásicos de toda la vida.Telemetría personal: El método para que tú también audites tu terminal.Si quieres llevar tu productividad en Linux al siguiente nivel y conocer qué software está marcando la diferencia en 2025, este episodio es tu hoja de ruta.

¡Bienvenidos a un nuevo episodio de Atareao con Linux! Estamos cerrando este 2025 y toca hacer balance de las herramientas que realmente han marcado la diferencia en mi servidor. En este episodio te traigo una selección personal de los 6 contenedores Docker que se han vuelto imprescindibles en mi día a día. No solo por su funcionalidad, sino por cómo han simplificado mi flujo de trabajo, mejorado la seguridad y optimizado el rendimiento de mis sistemas.Lo que encontrarás en este episodio:1. Dodge: La alternativa ligera a Portainer que gestiona tus archivos YAML de forma reactiva y permite convertir comandos docker run a compose fácilmente.2. Pocket ID: Seguridad "passwordless" al siguiente nivel. Centraliza tus accesos mediante Passkeys y biometría con soporte OIDC.3. Doc Pick: El sustituto perfecto para la gestión de actualizaciones. Mantén tus imágenes al día con un panel visual intuitivo.4. Beszel: Monitorización de recursos (CPU, RAM, Disco) tanto del host como de cada contenedor individual.5. Quantum: Un fork de File Browser potenciado con búsqueda por lógica difusa e integración con OIDC.6. Memos: Tu centro de micro-notas privado y extremadamente versátil gracias a su API.Timestamps:00:00:00 Introducción y balance del año 202500:01:05 Los seis contenedores imprescindibles de 202500:02:14 Consideraciones sobre el flujo de trabajo y mantenimiento00:03:56 Dodge: El reemplazo moderno y ligero de Portainer00:06:07 Pocket ID: Autenticación passwordless y OIDC00:08:01 Doc Pick: Información y actualización de imágenes de contenedores00:10:40 Beszel: Monitor de recursos de CPU, RAM y Docker00:12:42 Quantum: Fork de File Browser con integración OIDC00:14:39 Memos: Gestión de micronotas y enlaces mediante API00:18:28 Resumen final y despedidaRecursos y enlaces:Más información y enlaces en las notas del episodio

Hola, soy Lorenzo y esto es Atareao con Linux. Seguramente te ha pasado: te atrae la potencia y la eficiencia de un Tiling Window Manager (TWM), pero en cuanto te asomas al abismo de su configuración, te das la vuelta. No tienes tiempo para pasarte semanas editando archivos CSS, configurando barras de estado a mano o intentando que tus aplicaciones no parezcan un "Frankenstein" visual donde nada combina con nada.En este episodio, te traigo lo que he bautizado como el Tiling Window Manager para seres humanos. Quiero contarte mi experiencia personal utilizando la combinación de Niri y Dank Material Shell (DMS), una pareja tecnológica que me ha hecho cambiar mis prioridades por completo y ha transformado mi escritorio en una herramienta de productividad pura.Mi transición: De GNOME a la eficiencia de NiriDurante mucho tiempo, mi escritorio principal era GNOME en un 80% del tiempo. Sin embargo, las tornas han cambiado drásticamente: ahora Niri ocupa casi la totalidad de mi flujo de trabajo, especialmente cuando me siento a programar. Pero Niri por sí solo puede ser austero; la verdadera magia surge cuando le añadimos Dank Material Shell. Gracias a esta capa, he conseguido tener un entorno de escritorio completo, moderno y espectacular sin las complicaciones habituales de los gestores de ventanas en mosaico.¿Por qué deberías probar Dank Material Shell?DMS no es solo un complemento, es una solución integral escrita en Go que utiliza Qt6 para ofrecerte todo lo que necesitas en un escritorio moderno. En este episodio te explico cómo esta herramienta centraliza elementos que normalmente tendrías que configurar por separado, como la barra de estado, el centro de notificaciones o el lanzador de aplicaciones.Hablamos sobre la personalización inteligente: cómo el sistema es capaz de generar paletas de colores dinámicas basadas en tu fondo de pantalla (al estilo Material You) y, lo más importante, cómo logra una coherencia visual total entre aplicaciones GTK y Qt sin que tengas que mover un dedo. Además, analizamos con total sinceridad el consumo de recursos y por qué, a pesar de usar algo más de RAM que una configuración minimalista, la fluidez y la comodidad que aporta compensan con creces la inversión.Instalación y ecosistemaYa seas usuario de Arch Linux o prefieras la estabilidad de Ubuntu, te cuento los pasos clave para que puedas replicar este entorno en tu propia máquina. También exploramos herramientas complementarias del ecosistema como Matugen y Stasis, que terminan de redondear una experiencia de usuario que, sinceramente, creo que es el futuro de los escritorios en Linux.Si buscas un entorno que se adapte a ti y no al revés, donde la estética y la funcionalidad vayan de la mano desde el primer minuto, acompáñame en este episodio. ¡Vamos directo al turrón!Más información y enlaces en las notas del episodio

En este episodio de atareao con Linux te quiero contar una de mis grandes obsesiones: cómo mantener mis imágenes Docker lo más ligeras y seguras posible sin que eso me penalice cuando tengo que "ensuciarme las manos" dentro de un contenedor.Si me sigues desde hace tiempo, ya sabes que siempre busco reducir la superficie de ataque de mis despliegues. Cuanto menos software innecesario tenga una imagen, menos vulnerabilidades. Pero claro, esto tiene un problema evidente: cuando entras en un contenedor basado en una imagen minimalista, te encuentras con que no tienes ni un editor de texto, ni un buscador de archivos, ni nada que te facilite la vida.Para solucionar esto, he actualizado una imagen Docker que es mi auténtica "navaja suiza". En lugar de engordar mis imágenes de producción, utilizo este contenedor especializado que conecto a mis volúmenes cuando necesito gestionar datos, organizar archivos o realizar tareas de mantenimiento.He reconstruido esta herramienta sobre Alpine 3.23 por su ligereza extrema. Pero lo potente es lo que lleva dentro, un ecosistema centrado en herramientas escritas en Rust que son increíblemente rápidas:Shell y Prompt: He sustituido la clásica ash por Fish, para tener una shell interactiva y amigable, junto a Starship para un indicador visual ultra rápido.Productividad: Uso herramientas que reinventan los clásicos: lsd para ver archivos con iconos, bat para leer con resaltado de sintaxis, y fd junto a ripgrep para buscar cualquier cosa en milisegundos.Gestión y Edición: Para moverme por el sistema uso yazi, que es un gestor de archivos para terminal rapidísimo, y por supuesto Neovim para cualquier edición profesional.Mi arma secreta (rnr): He incluido rnr para renombrar archivos de forma masiva usando expresiones regulares, algo vital para organizar mis bibliotecas de series y películas.En este episodio te explico por qué me resulta mucho más cómodo utilizar volúmenes Docker en lugar de mapear directorios del host. Te cuento cómo esta práctica me facilitó la vida al migrar a Dockge y cómo gestiono mis datos multimedia de forma eficiente.Para que tú también puedas usarlo, te comparto el script que utilizo para levantar este contenedor de forma efímera e interactiva:Con este comando, el contenedor se destruye al salir, manteniendo mi sistema limpio y mis procesos gestionados correctamente gracias al flag --init.Más información y enlaces en las notas del episodio

Hasta hace poco, MinIO era el rey indiscutible para implementar almacenamiento S3 autoalojado. Pero un cambio de licencia polémico (de Apache 2.0 a la estricta AGPL v3) y, lo que es peor para el usuario libre, la eliminación de la Consola GUI de la versión abierta, han forzado a muchos, incluido yo, a buscar una alternativa. ¡Y la hemos encontrado!En este episodio, te explico a fondo qué es S3, por qué este protocolo de almacenamiento de objetos es una pieza clave e indispensable para cualquier infraestructura de selfhosting o *homelab*, y te presento a RustFS, el nuevo servidor compatible con la API de S3 que está diseñado para la comunidad, manteniendo la promesa de ser libre, transparente, rápido, y lo más importante: con su interfaz gráfica de administración incluida.

¿Tu servidor o escritorio Linux está lento o no te deja desmontar un disco? ¿Borraste un archivo gigante pero el espacio no se liberó? ¡Tenemos al culpable!En este episodio de atareao con Linux, te destripo el comando más poderoso para el diagnóstico de sistemas: lsof (List Open Files).Aprenderás a usar este detective de recursos para resolver los problemas más frustrantes de administración de sistemas, desde la configuración de Docker hasta la optimización de tu VPS o Raspberry Pi.

Especial Encuesta de Self-Hosting 2025!

Niri, Sherlock y Stasis: El Atajo que Disparó mi Productividad en Wayland

El título de este episodio podría sonar a clickbait apocalíptico, pero te aseguro que cada palabra es real. Durante un periodo crítico, las actualizaciones automáticas de seguridad en Ubuntu estuvieron completamente rotas. ¿El culpable? Un ambicioso proyecto para modernizar Linux reemplazando utilidades básicas escritas en C por versiones en Rust. Este proceso de "oxidación" nos ha dejado dos fallos críticos que analizaremos a fondo.En este programa urgente, no solo destripamos lo que falló, sino que lo convertimos en un caso de éxito rotundo para el desarrollo de código abierto. Si eres usuario de Linux, especialmente de Ubuntu, tienes que escuchar esto para entender por qué este tropiezo es, en realidad, un gran salto adelante para la seguridad de tu sistema.Ubuntu, en su versión intermedia 25.10 (Questing Quokka), decidió introducir dos piezas de software fundamentales escritas en Rust para probar su estabilidad antes de una versión LTS:uutils coreutils: La reimplementación de los comandos básicos de GNU (como ls, cp, y el protagonista de esta historia, date).sudo-rs: La reimplementación del comando sudo, la puerta de entrada a los permisos de administrador (root).Ambas fallaron poco después del lanzamiento. Analizaremos dos problemas principales:El Problema: El comando date -r se utiliza para obtener la hora de última modificación de un archivo. La versión en Rust de las coreutils tenía un error lógico: en lugar de devolver la fecha del archivo, siempre devolvía la fecha y hora actual del sistema.La Consecuencia Desastrosa: Te explico cómo esta simple incorrección lógica rompió el mecanismo de actualizaciones automáticas desatendidas (unattended-upgrades). El sistema, al consultar la fecha de un archivo de referencia con el comando defectuoso, creía que la última actualización se había hecho "ahora mismo", y por lo tanto, no ejecutaba ninguna nueva búsqueda ni instalación de parches de seguridad. Un bug silencioso que te deja vulnerable. Esta misma lógica fallida puede afectar scripts de backup que comprueban la antigüedad de las copias de seguridad con date -r.Exposición de la Contraseña: Cuando un usuario comenzaba a introducir su clave de sudo y el tiempo de espera (timeout) expiraba, el código defectuoso de sudo-rs exponía en pantalla y potencialmente en el historial de la shell la parte de la contraseña que ya se había tecleado. ¡Un fallo de seguridad grave que comprometía la confidencialidad de tu clave de administrador!Fallo de Autenticación Avanzada: También se produjo un fallo más técnico relacionado con la gestión de las credenciales de root bajo ciertas configuraciones (targetpw o rootpw), permitiendo un posible bypass de autenticación a usuarios locales que reutilizaran "pases rápidos" temporales defectuosos.La parte más constructiva de esta historia es la velocidad de respuesta. Aquí es donde se demuestra el valor real de probar estos cambios en versiones intermedias:Respuesta Inmediata.Divulgación Coordinada (CVD).El Valor de la LTS.No podemos olvidar el objetivo principal. El uso de Rust en uutils coreutils y sudo-rs busca la seguridad de la memoria, eliminando las causas fundamentales de la mayoría de los fallos de seguridad críticos en el código C que tienen décadas de antigüedad.Más información y enlaces en las notas del episodio

En este episodio profundizamos en la optimización de tus sistemas Docker. El objetivo de hoy: implementar nuevas y mejores prácticas para que tus contenedores sean más estables y eficientes. Si buscas cómo sacar el máximo partido a tu infraestructura autoalojada, esta es tu guía.Uno de los problemas más comunes al trabajar con Docker Compose es que los servicios dependientes (como una aplicación web o un servidor de correo) intentan conectarse a la base de datos antes de que esta haya terminado de arrancar, provocando errores.Te muestro mi solución PRO para esto: utilizamos la combinación de la directiva depends_on con la condición service_healthy.Esta configuración asegura que servicios críticos como Gitea (mi servicio de alojamiento de repositorios Git) y Stalwart (mi servidor de correo) solo se inician cuando su respectiva base de datos PostgreSQL ha pasado su chequeo de salud y está lista para aceptar conexiones. Esto garantiza una secuencia de inicio robusta y sin fallos, una mejora fundamental en la gestión de tus datos y sistemas.Gitea : Vemos cómo configurar el healthcheck para la base de datos PostgreSQL usando pg_isready y cómo el servicio Gitea espera por esta condición. También optimizamos el tráfico interno del runner de Gitea para que use la red interna de Docker (http://gitea:3000), reduciendo la carga de Traefik y mejorando la seguridad.Stalwart : En el caso de mi cliente de correo, he migrado la base de datos de RocketDB a PostgreSQL. La razón es sencilla: PostgreSQL es más transparente y me permite integrar sin esfuerzo mi contenedor personalizado (atareao/postgres-backup:latest) para hacer copias de seguridad eficientes y automatizadas.En este episodio, también te presento una nueva herramienta que me ha encantado: Dockpeek.Dockpeek es un panel de control autoalojado y muy ligero para Docker, perfecto para la gestión de contenedores en múltiples hosts. Si te gustan las herramientas que reemplazan funcionalidades complejas con soluciones sencillas, Dockpeek te va a encantar.Características destacadas: Acceso web con un clic, mapeo automático de puertos, registros de contenedores en vivo, integración con Traefik y chequeo de actualizaciones de imágenes.Te comparto el compose.yml que utilizo para instalar Dockpeek junto a Traefik.Quantum (Filebrowser): He ajustado los permisos y la configuración del servicio que utilizo para compartir archivos. Te explico la solución al problema de permisos que surgió al intentar usar un usuario que no es root, modificando el uid, gid y mode en la sección configs del compose.yml.Escucha el episodio para obtener el tutorial completo y adaptar estas soluciones a tu Raspberry Pi o VPS. ¡Es la forma más práctica de optimizar tu productividad y tus sistemas Linux!¡Suscríbete a "atareao con Linux" para no perderte ningún tutorial y llevar tu experiencia con Linux a un nivel PRO!