🎧 Escucha: 🎙 ¿Adiós definitivo a GNOME? Mi nueva vida con Niri y DMS 🎙
Descubre cómo Niri y Dam-Material-Shell 1.4 transforman Arch Linux en el entorno de escritorio definitivo: rápido, homogéneo y altamente productivo.
👉 🎧 Escucha 🎧 👈
📻 Feed 📻
🎧 Escucha: 🎙 ¿Sigue siendo Kitty el mejor terminal? 5 años después, mi configuración definitiva. 🎙
Aprende a optimizar Kitty, el terminal más rápido de Linux, usando configuración modular, atajos tipo Vim y Kitens para eliminar el uso del ratón.
👉 🎧 Escucha 🎧 👈
📻 Feed 📻
🎧 Escucha: 🎙 OpenDeck, la herramienta Definitiva para Streaming en Linux 🎙
Descubre cómo usar una Stream Deck económica en Linux con OpenDeck. Analizamos Zoom Phone, Mars Gaming y cómo convertir tu Android en controlador.
👉 🎧 Escucha 🎧 👈
📻 Feed 📻
🎧 Escucha: 🎙 Automatización Total. Etiqueta tus MP3 como un profesional 🎙
Aprende a automatizar metadatos de audio en Linux con ID3CLI, la herramienta en Rust que supera los problemas de dependencias de los scripts en Python.
👉 🎧 Escucha 🎧 👈
📻 Feed 📻
🎧 Escucha: 🎙 Evita Contenedores ZOMBIE. Guía Maestra de Health Checks en Podman 🎙
Aprende a usar Health Checks en Podman para evitar contenedores zombie, configurar dependencias inteligentes y automatizar reinicios en Linux. ¡Domínalo ya!
👉 🎧 Escucha 🎧 👈
📻 Feed 📻
🎧 Escucha: 🎙 Adiós a las excusas. Cómo monté mi VS Code en un servidor 🎙
Aprende a montar tu entorno de desarrollo remoto con Code Server y Docker para programar profesionalmente desde cualquier tablet Android o navegador.
👉 🎧 Escucha 🎧 👈
📻 Feed 📻
769 - ¿Stream Deck por 15€? Configurando un Macro Pad en Linux
¿Alguna vez has sentido que te faltan dedos o botones para controlar tu flujo de trabajo en Linux? En este episodio te cuento mi última aventura (u obsesión, según se mire) con los teclados mecánicos y los gadgets de productividad.
Siempre me ha llamado la atención el famoso Stream Deck de Elgato, pero pagar más de 100 euros por unas cuantas pantallas diminutas me parecía excesivo. Así que hice lo que cualquier amante del código abierto haría: me compré un mini teclado programable de 15 euros con tres teclas y una rueda, y me propuse hacerlo funcionar perfectamente en mi sistema Linux.
Acompáñame en esta odisea donde te explico desde por qué estoy enamorado de los teclados partidos de Digma, hasta cómo terminé usando herramientas desarrolladas en Rust para evitar tener que tocar un solo ordenador con Windows (lo siento, en mi casa no entra el PIN de Microsoft).
En este vídeo aprenderás:
- Cómo identificar dispositivos USB genéricos usando lsusb.
- Qué es el chip CH552 y por qué es un lienzo en blanco para los makers.
- Cómo usar el proyecto ch57 para mapear teclas que ni siquiera sabías que existían, como F13 o F24, para que no interfieran con tu teclado principal.
- La configuración de archivos YAML para que tu mini teclado haga exactamente lo que tú quieres: subir volumen, mutear el micro o lanzar aplicaciones.
- Cómo dar permisos correctos mediante reglas de udev en /etc/udev/rules.d/.
Pero como no podía estarme quieto, te presento "Capboard", un pequeño demonio que he programado personalmente para gestionar este teclado de forma eficiente como un servicio de systemd. Te cuento todo el proceso de desarrollo y por qué decidí que las soluciones existentes no eran suficientes para mi nivel de "cacharrero".
Si te gusta el hardware barato, el software potente y ver cómo domar dispositivos rebeldes en Linux, este vídeo es para ti. ¡Y ojo! No te lances a comprar todavía, porque al final del vídeo te doy un avance de lo que viene en los próximos episodios, porque la evolución de este setup no ha hecho más que empezar.
CAPÍTULOS:
00:00:00 Introducción y mi obsesión por los teclados
00:01:33 ¿Qué es un Stream Deck y por qué no compré el de Elgato?
00:02:47 El mini teclado de 15€: 3 teclas y una rueda
00:05:00 El reto: Configurar hardware diseñado para Windows en Linux
00:06:38 La salvación se llama Rust y el proyecto ch57
00:07:44 Identificando el dispositivo (lsusb y el chip CH552)
00:08:43 Asignando teclas mágicas: de la F13 a la F22
00:10:48 Instalación y mapeo con archivos YAML
00:13:02 Permisos de usuario: Configurando reglas de udev
00:15:08 Bonus: He creado mi propio demonio en Rust (Capboard)
00:17:35 ¿Vale la pena? Mi veredicto y un avance del próximo gadget
00:18:25 Despedida y red de podcast
Más información, enlaces y notas en https://atareao.es/podcast/769
🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
✈️ Telegram (el grupo) 👉 /channel/atareao_con_linux
✈️ Telegram (el canal) 👉 /channel/canal_atareao
🦣 Mastodon 👉 atareao" rel="nofollow">https://mastodon.social/@atareao
🐦 Twitter 👉 https://twitter.com/atareao
🐙 GitHub 👉 https://github.com/atareao
#Linux #Productividad #Rust #TecladoMecanico #OpenSource #StreamDeck #Tutorial #Hardware
https://www.youtube.com/watch?v=JJP7ZqGWdCU
#atareaoConLinux #podcastesp
768 - Quadlets. La pieza secreta de Podman que cambiará tu servidor para siempre
¿Sigues usando Docker porque te da pereza el cambio? En este episodio de Atareao con Linux te voy a demostrar por qué los Quadlets son la razón definitiva para que te decantes por Podman de una vez por todas. Si ya te hablé de los Pods y te pareció interesante, lo de hoy es llevar la gestión de contenedores al siguiente nivel: la integración TOTAL con SystemD.
En el episodio 768, te explico cómo los Quadlets permiten gestionar tus contenedores, volúmenes y redes exactamente como si fueran servicios nativos de tu sistema operativo. Olvídate de scripts extraños o de depender de herramientas externas; aquí todo se define con archivos de configuración sencillos (.container, .network, .volume) que SystemD entiende a la perfección.
Te cuento mi experiencia real migrando mis proyectos actuales. Ya tengo bases de datos PostgreSQL funcionando bajo este modelo y la estabilidad es, simplemente, de otro planeta. Veremos cómo levantar un stack completo de WordPress con MariaDB y Redis utilizando esta tecnología, gestionando las dependencias entre ellos con las directivas 'After' y 'Requires' de SystemD. ¡Se acabó el que un contenedor intente arrancar antes de que la base de datos esté lista!
Además, exploramos ventajas brutales como:
- Control de versiones: Al ser archivos de texto plano, puedes llevar toda tu infraestructura a un repositorio Git de forma limpia.
- Gestión de Logs: Delegamos el rotado y la gestión de logs a JournalCTL. Menos preocupaciones para ti.
- Actualizaciones automáticas: Te adelanto cómo la directiva 'auto-update' puede jubilar a herramientas como Watchtower.
- Seguridad: Trabajamos con secretos de forma nativa en Podman sin necesidad de activar modos complejos como Swarm.
Si quieres que tu servidor Linux sea más profesional, robusto y fácil de mantener, no puedes perderte este vídeo. ¡Dale al play y que te explote la cabeza (metafóricamente)!
Capítulos del vídeo:
00:00:00 Introducción y el adiós definitivo a Docker
00:01:33 ¿Qué es un Quadlet y por qué revoluciona Linux?
00:03:22 Los 6 tipos de Quadlets disponibles
00:05:12 Cómo gestionar un Quadlet de tipo contenedor
00:06:46 Definiendo Redes y Volúmenes como servicios
00:08:13 El flujo de trabajo: Git, secretos y portabilidad
00:11:22 Integración con SystemD: Nombres y prefijos
00:13:42 Desplegando un Stack completo: WordPress, MariaDB y Redis
00:16:02 Modificando contenedores y recarga de SystemD (Daemon-reload)
00:17:50 Logs con JournalCTL y mantenimiento simplificado
00:19:33 Auto-update: Olvídate de Watchtower para siempre
00:20:33 Conclusiones y próximos pasos en la migración
Más información, enlaces y notas en https://atareao.es/podcast/768
🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
✈️ Telegram (el grupo) 👉 /channel/atareao_con_linux
✈️ Telegram (el canal) 👉 /channel/canal_atareao
🦣 Mastodon 👉 atareao" rel="nofollow">https://mastodon.social/@atareao
🐦 Twitter 👉 https://twitter.com/atareao
🐙 GitHub 👉 https://github.com/atareao
https://www.youtube.com/watch?v=r6_eQpsMvjU
#atareaoConLinux #podcastesp
🎧 Escucha: 🎙 Gestión de secretos extrema. SOPS + AGE + RUST (Más rápido que nunca) 🎙
Descubre cómo migrar de Pass a Sops y Age para gestionar contraseñas en Linux. Optimiza tu terminal con crypta (Rust) y automatiza secretos con Jinja.
👉 🎧 Escucha 🎧 👈
📻 Feed 📻
765 - Adiós a PASS y GPG. Por qué me pasé a Age y SOPS
¡Adiós a la lentitud de PASS! Descubre el cifrado moderno con Age y SOPS 🛡️
¿Sigues usando **GPG** o **pass** y sientes que tu flujo de trabajo es lento? En este video te enseño cómo he migrado mi gestión de secretos a **Age** y **SOPS**, la combinación definitiva para cifrar archivos de configuración de forma rápida y segura.
Si gestionas `dotfiles`, usas `Docker` o simplemente quieres proteger tus claves API sin perder la cordura, este sistema es para ti.
### Lo que aprenderás en este episodio:
* **El problema de Pass**: Por qué la gestión de múltiples archivos puede volverse ineficiente.
* **Age (Actual Good Encryption)**: El sucesor espiritual de PGP, diseñado para ser simple y extremadamente rápido.
* **SOPS (Secrets Operations)**: La herramienta de Mozilla que permite cifrar solo los valores de tus archivos YAML o JSON, manteniendo la estructura legible para Git.
* **Integración con Docker**: Cómo pasar secretos a tus contenedores sin dejar rastro en el disco.
### Comandos clave utilizados:
```bash
# Instalación en Arch Linux
sudo pacman -S age sops
# Generar llaves con Age
age-keygen -o ~/.config/sops/age/key.txt
# Editar un archivo cifrado con SOPS
sops secrets.yml
Capítulos del episodio:
00:00:00 Introducción y despedida de Pass/Gopass
00:01:43 Migración al dúo dinámico: SOPS y Age
00:02:15 Contexto: Gestión de dotfiles con YADM y Jinja2
00:04:35 El problema de rendimiento con Pass y JinRender
00:06:01 ¿Qué es Age? El sucesor espiritual de PGP
00:07:20 Generación de claves y uso básico de Age
00:09:27 ¿Qué es SOPS? Gestión inteligente de secretos
00:10:51 Instalación y configuración de SOPS con Age
00:13:40 Reglas de creación en el archivo .sops.yaml
00:14:53 Flujo de trabajo: Edición y cifrado de archivos
00:17:02 Extracción de variables para automatización
00:17:48 Uso de SOPS y Age en Docker sin archivos físicos
00:20:17 Conclusión y ventajas de la nueva metodología
00:21:26 Despedida y agradecimientos
Más información, enlaces y notas en https://atareao.es/podcast/765
🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
✈️ Telegram (el grupo) 👉 /channel/atareao_con_linux
✈️ Telegram (el canal) 👉 /channel/canal_atareao
🦣 Mastodon 👉 atareao" rel="nofollow">https://mastodon.social/@atareao
🐦 Twitter 👉 https://twitter.com/atareao
🐙 GitHub 👉 https://github.com/atareao
#Linux #Ciberseguridad #Docker #Age #SOPS #Dotfiles #OpenSource #Atareao
https://www.youtube.com/watch?v=0nKc7l8lky4
#atareaoConLinux #podcastesp
🎧 Escucha: 🎙 Por qué NO deberías usar ROOT en tus Contenedores (y cómo arreglarlo) 🎙
Aprende a configurar contenedores Rootless con Podman en Ubuntu y Arch Linux para evitar ataques de escape y mejorar la seguridad de tu servidor.
👉 🎧 Escucha 🎧 👈
📻 Feed 📻
762 - ¿Por qué estoy abandonando Docker? Adiós al Demonio
¿Es el fin de una era? 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 vídeo es para ti.
Históricamente, Docker ha sido el rey, pero su arquitectura basada en un **demonio persistente (`dockerd`)** que corre como root presenta riesgos y puntos únicos de fallo que ya no estoy dispuesto a asumir. Podman llega para solucionar esto de forma elegante, integrándose orgánicamente en Linux y eliminando la necesidad de privilegios de administrador.
**¿Qué vas a aprender en este vídeo?**
**El problema del "Gran Hermano":** Por qué depender de un demonio centralizado es un riesgo de seguridad.
**Arquitectura sin demonio:** Cómo Podman lanza procesos independientes que no afectan al resto del sistema si fallan.
**Seguridad Rootless:** La importancia de correr contenedores sin privilegios de root para reducir la superficie de ataque.
**Transición transparente:** Cómo usar un simple alias para que tu flujo de trabajo no cambie en absoluto.
**Gestión de Logs:** Olvídate de los archivos JSON gigantes; integra tus logs directamente con `journald`.
**Concepto de Pods:** Una primera mirada a la agrupación de contenedores y el patrón *sidecar*.
### 🕒 Capítulos del vídeo:
00:00:00 Introducción y el reto de migrar a Podman
00:01:25 Adiós al demonio: El problema de la arquitectura de Docker
00:02:33 Procesos independientes y aislamiento en Podman
00:03:49 Integración nativa con Systemd y el modelo estándar de Linux
00:04:41 Seguridad: Contenedores sin privilegios de administrador (Rootless)
00:06:10 Una transición indolora: El alias de Docker a Podman
00:07:33 Registries y gestión de imágenes personalizadas
00:09:36 Gestión eficiente de logs y Journald
00:11:20 Los Pods: Agrupación de contenedores y comunicación por localhost
00:14:51 El patrón Sidecar para añadir funcionalidades
00:15:40 Introducción a los Quadlets y futuro de la serie
00:17:36 Conclusión y despedida
### 💡 ¿Por qué suscribirte a Atareao con Linux?
Si te apasiona el **Open Source**, la productividad y quieres dominar tu sistema Linux, este es tu sitio. En esta temporada profundizaremos en soluciones prácticas para "cualquier cosa que quieras hacer con Linux", desde configurar servidores web hasta optimizar tu flujo de trabajo con **Rust, Neovim y Docker/Podman**.
### 🛠️ Tecnologías mencionadas:
#Linux #Podman #Docker #SysAdmin #Seguridad #OpenSource #Rust #Systemd #Atareao
**¿Te ha servido este vídeo?** Déjame en los comentarios si tú también estás pensando en dar el salto a Podman o si hay alguna característica que te retiene en Docker. ¡Te leo!
Más información, enlaces y notas en https://atareao.es/podcast/762
🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
✈️ Telegram (el grupo) 👉 /channel/atareao_con_linux
✈️ Telegram (el canal) 👉 /channel/canal_atareao
🦣 Mastodon 👉 atareao" rel="nofollow">https://mastodon.social/@atareao
🐦 Twitter 👉 https://twitter.com/atareao
🐙 GitHub 👉 https://github.com/atareao
https://www.youtube.com/watch?v=WKjJL7jstTk
#atareaoConLinux #podcastesp
761 rust-script. El fin de los scripts en Bash
¿Te ha pasado que un pequeño script en Bash termina convirtiéndose en un "mastodonte" imposible de mantener? En este episodio te cuento por qué he decidido dar el salto a Rust Script y cómo esta herramienta me permite programar con la potencia de Rust pero con la agilidad de un lenguaje de scripting.
Bash y Fish son fantásticos para tareas rápidas, pero cuando el problema crece, la gestión de errores limitada, la falta de tipado y la dificultad para manejar datos estructurados (como JSON o YAML) nos complican la vida. Aquí es donde entra Rust Script como la solución intermedia perfecta.
¿Qué vas a aprender en este vídeo?
La transición de Shell a Rust: Por qué Bash se queda corto cuando la complejidad aumenta.
Rust Script vs Proyectos Cargo: Cómo escribir código Rust sin necesidad de crear un archivo Cargo.toml ni toda la infraestructura de un proyecto tradicional.
Instalación y Configuración: Pasos sencillos para tenerlo listo en Arch Linux o cualquier otra distro mediante Cargo.
Ejemplos Reales:
Crear un "Hola Mundo" con un shebang personalizado.
Gestión de dependencias directamente en el código mediante comentarios.
Realizar peticiones HTTP y procesar JSON sin depender de herramientas externas como jq.
Rendimiento y Caché: Entender cómo Rust Script compila y almacena los binarios para que las ejecuciones posteriores sean instantáneas.
Rust Script ofrece lo mejor de los dos mundos: la seguridad y velocidad de Rust con la operativa de automatización rápida que tanto nos gusta en Linux.
Timestamp
00:00:00 Introducción y la transición de Bash a Fish
00:00:50 Las limitaciones de los scripts complejos en Bash y Fish
00:01:26 Por qué elegir Rust para optimizar el trabajo
00:02:07 Introducción a Rust Script: Rust como lenguaje de scripting
00:02:36 Próximos episodios técnicos: Profundizando en Podman
00:03:59 Problemas comunes en Bash: Errores, tipos y datos estructurados
00:04:50 El punto intermedio: Rust Script vs. proyectos completos con Cargo
00:06:47 Ejemplo práctico: Cómo crear un "Hola Mundo" con Rust Script
00:08:07 Funcionamiento interno: Compilación y caché de binarios
00:09:43 Ejecución directa y permisos en archivos .rs
00:10:44 Cómo instalar Rust Script en Arch Linux y vía Cargo
00:11:32 Gestión de dependencias elegante dentro del script
00:14:03 Ejemplo avanzado: Uso de múltiples crates y peticiones web
00:16:32 Ventajas de trabajar con APIs JSON sin herramientas externas
00:18:25 Resumen de beneficios: Potencia, tipado y velocidad
00:20:13 Despedida y red de podcast Sospechosos Habituales
https://www.youtube.com/watch?v=BIw1nfnK2rM
#atareaoConLinux #podcastesp
🎧 Escucha: 🎙 La guía definitiva de Hardening y Despliegue en Podman. De 0 a Producción en 2 minutos 🎙
Acompañame en la migración de atareao.es a Podman. Aprende a usar Quadlets, YADM y hardening avanzado para un servidor rootless e inexpugnable.
👉 🎧 Escucha 🎧 👈
📻 Feed 📻
🎧 Escucha: 🎙 ¡Adiós Docker! Cómo configurar Traefik con Podman (Rootless y Seguro) 🎙
Aprende a configurar Traefik con Podman usando Quadlets. Guía completa sobre puertos rootless, persistencia en Systemd, seguridad avanzada y HTTP/3.
👉 🎧 Escucha 🎧 👈
📻 Feed 📻
🎧 Escucha: 🎙 La guía definitiva de Logs en Podman. Automatización, Quadlets y Vector 🎙
Aprende a gestionar logs en Podman con JournalD. Descubre scripts para monitorizar Quadlets, configurar límites de disco y automatizar tu seguridad.
👉 🎧 Escucha 🎧 👈
📻 Feed 📻
🎧 Escucha: 🎙 Rollbacks Automáticos en Podman. Como WatchTower pero mejor. 🎙
Aprende a configurar actualizaciones automáticas y rollbacks nativos en Podman integrados con SystemD. Supera las limitaciones de Watchtower y Docker.
👉 🎧 Escucha 🎧 👈
📻 Feed 📻
772 - Evita Contenedores ZOMBIE. Guía Maestra de Health Checks en Podman
¿Alguna vez has pensado que tu servidor WordPress estaba funcionando pero al entrar te encontrabas con un error de base de datos? ¡Bienvenido al mundo de los procesos zombie! En este episodio te enseño cómo evitar esto para siempre usando Podman y Health Checks.
Soy Lorenzo y hoy vamos a ir un paso más allá de lo que vimos en el episodio 688 de Docker. Te voy a mostrar cómo configurar tus contenedores para que no solo parezca que están vivos, sino que realmente sean funcionales. Si un proceso se bloquea o pierde la conexión con la base de datos, tu sistema debe saberlo y, mejor aún, debe reaccionar.
En este video aprenderás:
1. El concepto de "Muestra de Vida": Por qué un contenedor "running" no siempre es un contenedor sano.
2. Detección de Zombies: Cómo determinar si un proceso está bloqueado aunque el contenedor no se haya detenido.
3. Autorreparación: Configuración de políticas de reinicio inteligente para que tus servicios se curen solos.
4. Dependencias Inteligentes con Podman: Olvídate de los fallos en cascada. Haremos que WordPress solo intente arrancar cuando MariaDB y Redis estén en estado "Healthy".
5. Notificaciones Proactivas: Te enseño a configurar scripts para que tu sistema te avise por Telegram o al escritorio cuando un stack se levanta correctamente o cuando algo falla estrepitosamente.
Utilizaremos herramientas modernas como los Quadlets de Podman para integrar todo esto con Systemd, dándote un control de nivel profesional sobre tu infraestructura Linux.
Capítulos del video:
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 en tus sistemas
00:03:20 Cómo implementar Health Checks en Podman y Docker
00:04:40 Comandos clave: Interval, Timeout y Retries
00:05:20 Health Checks en Quadlets: La potencia de Systemd
00:06:50 Autorreparación: Configurando reinicios automáticos
00:08:58 Dependencias inteligentes: WordPress + MariaDB + Redis
00:11:00 Notificaciones al escritorio y Telegram (On Success)
00:13:55 Gestión de fallos: Notificaciones On Failure
00:16:30 Pruebas reales y depuración de errores
00:18:21 Conclusiones y el futuro con Traefik
Si quieres llevar tus habilidades de SysAdmin o entusiasta de Linux al siguiente nivel, este es tu episodio. No basta con levantar contenedores, hay que saber mantenerlos vivos.
Más información, enlaces y notas en https://atareao.es/podcast/772
🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
✈️ Telegram (el grupo) 👉 /channel/atareao_con_linux
✈️ Telegram (el canal) 👉 /channel/canal_atareao
🦣 Mastodon 👉 atareao" rel="nofollow">https://mastodon.social/@atareao
🐦 Twitter 👉 https://twitter.com/atareao
🐙 GitHub 👉 https://github.com/atareao
#Linux #Podman #Docker #SysAdmin #Contenedores #SelfHosted #WordPress #DevOps #Systemd #OpenSource
https://www.youtube.com/watch?v=N69WD4sZpuc
#atareaoConLinux #podcastesp
771 - Adiós a las excusas. Cómo monté mi VS Code en un servidor
¿Alguna vez has intentado programar en tu tablet Android y has acabado usándola solo para ver vídeos o enseñar demos? Te confieso que a mí me ha pasado. En este episodio te cuento mi transición de un sistema local basado en Termux y Neovim, que me daba más excusas que líneas de código, a un entorno de desarrollo remoto profesional utilizando Code Server.
Acompáñame en este viaje técnico donde te explico por qué tener un entorno de desarrollo fragmentado es el mayor enemigo de la productividad. Si programas en el escritorio, luego pasas a la tablet y después a otro equipo, las configuraciones nunca coinciden y el flujo de trabajo se rompe. La solución: programar en un único sitio, accesible desde cualquier lugar.
En este vídeo/podcast detallo cómo he construido mi propia imagen personalizada de Docker partiendo de Code Server. No me he limitado a lo básico; he integrado mis herramientas favoritas de Rust como bat, lsd, find y sd para potenciar la terminal. Además, te explico mi flujo de trabajo con Rustup, los componentes necesarios para el formateo de código y cómo gestiono la persistencia para no perder ni un solo cambio.
Hablamos también de seguridad. No puedes dejar un VS Code abierto al mundo. Te cuento cómo utilizo Traefik como proxy inverso y cómo he implementado Pocket ID para el control de acceso, además de añadir geobloqueo para dormir tranquilo.
Uno de los puntos clave es la configuración del editor dentro del navegador. ¿Qué pasa con la tecla Escape? ¿Cómo evitar que el navegador se "coma" tus atajos de teclado? Te revelo mis trucos de mapeo (como el uso de JK para salir de modo inserto en Vim) y cómo convertir la pestaña de tu navegador en una Progressive Web App (PWA) para aprovechar cada píxel de tu tablet.
Si eres un amante de la terminal, de Linux y quieres llevar tu productividad al siguiente nivel, este episodio es para ti.
CAPÍTULOS:
00:00:00 El fracaso de programar en tablet (y por qué)
00:01:43 La solución definitiva: Code Server
00:02:12 El problema de los entornos fragmentados
00:03:53 Mi imagen personalizada de Docker para Code Server
00:05:04 Herramientas imprescindibles en Rust (Bat, LSD, SD)
00:06:23 Configuración de Rust y herramientas de desarrollo
00:07:05 Persistencia y Docker Compose
00:08:06 Seguridad: Traefik, Pocket ID y Geobloqueo
00:10:03 Optimizando VS Code para el navegador
00:11:13 Sincronización y persistencia de extensiones
00:12:43 Estética y tipografía (Ayu Dark y JetBrains Mono)
00:13:59 El poder de Vim dentro de Code Server
00:15:51 Cómo usar Code Server como una PWA en Android
00:17:04 Teclado físico: El accesorio obligatorio
00:18:50 Conclusiones y futuro del desarrollo remoto
Más información, enlaces y notas en https://atareao.es/podcast/771
🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
✈️ Telegram (el grupo) 👉 /channel/atareao_con_linux
✈️ Telegram (el canal) 👉 /channel/canal_atareao
🦣 Mastodon 👉 atareao" rel="nofollow">https://mastodon.social/@atareao
🐦 Twitter 👉 https://twitter.com/atareao
🐙 GitHub 👉 https://github.com/atareao
#Linux #CodeServer #Docker #Programacion #Android #Productividad #Vim #Rust #VSCode
https://www.youtube.com/watch?v=uOs0YwSLWns
#atareaoConLinux #podcastesp
770 - ¡Deja de usar contraseñas en tus Docker Compose! Descubre Podman Secrets
¿Alguna vez te has sentido expuesto al ver tus contraseñas, tokens de API y claves SSH en texto plano dentro de tus archivos Docker Compose? Yo sí, y me molesta soberanamente. ¡Hola! Soy Lorenzo y en este episodio te voy a enseñar cómo acabar con ese caos de seguridad de una vez por todas utilizando los Secretos en Podman.
Durante años hemos gestionado contenedores dejando "migas de pan" que cualquier intruso podría seguir. Aunque Docker tiene un sistema de secretos, te obliga a activar Swarm, algo que a muchos nos da pereza o simplemente no encaja en nuestro flujo de trabajo sencillo. Pero aquí es donde Podman brilla: los secretos vienen activados por defecto y no necesitas complicarte la vida.
En este video vamos a desgranar paso a paso qué es un objeto secreto, cómo vive fuera de la imagen del contenedor (¡fundamental!) y por qué las variables de entorno tradicionales son un riesgo que no deberías correr. Te explicaré el ciclo de vida completo de un secreto: desde su nacimiento con el comando create, pasando por su inspección, hasta su eliminación definitiva.
Además, te presento una herramienta que he desarrollado en Rust llamada "Cripta". Se trata de un gestor que combina la potencia de SOPS y Age con Git, permitiéndote sincronizar tus secretos cifrados en repositorios remotos sin miedo a que nadie los vea. Te mostraré cómo configurar Podman para que use drivers personalizados y cómo inyectar estos secretos directamente en tus bases de datos MariaDB o en tus archivos Quadlet de forma totalmente segura.
Si te preocupa la integridad de tu servidor y quieres pasar al siguiente nivel de administración de sistemas Linux, este episodio es para ti. ¡No más contraseñas a la vista!
Capítulos del video:
00:00:00 El peligro de las contraseñas en texto plano
00:01:23 El problema con Docker Swarm y por qué elegir Podman
00:03:16 ¿Qué es realmente un Secreto en Podman?
00:04:22 Ciclo de vida: Creación, evolución y muerte de un secreto
00:06:51 Cómo inspeccionar y gestionar tus secretos con CLI
00:08:10 Implementación práctica: Secretos en MariaDB y Quadlets
00:10:44 Drivers de Podman: File, Pass y Shell
00:12:04 Presentando Cripta: Gestión avanzada con SOPS, Age y Rust
00:16:47 Demo: Cómo Podman oculta tus secretos de miradas indiscretas
00:19:40 Ventajas de usar secretos en modo Rootless
00:21:00 Conclusiones y comunidad
Recursos mencionados:
- Proyecto Cripta en GitHub.
- Notas completas del episodio en atareao.es.
- Red de podcast Sospechosos Habituales.
Únete a la conversación en nuestro grupo de Telegram: t.me/atareao_con_linux. Si te gusta este contenido, no olvides suscribirte, darle a la campanita y dejar un buen like. ¡Me ayuda muchísimo a seguir creando contenido de calidad sobre Open Source y Linux!
Más información, enlaces y notas en https://atareao.es/podcast/770
🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
✈️ Telegram (el grupo) 👉 /channel/atareao_con_linux
✈️ Telegram (el canal) 👉 /channel/canal_atareao
🦣 Mastodon 👉 atareao" rel="nofollow">https://mastodon.social/@atareao
🐦 Twitter 👉 https://twitter.com/atareao
🐙 GitHub 👉 https://github.com/atareao
#Podman #Linux #Ciberseguridad #Docker #SelfHosted #Rust #SysAdmin #OpenSource
https://www.youtube.com/watch?v=nhcLfzud_2I
#atareaoConLinux #podcastesp
🎧 Escucha: 🎙 ¿Stream Deck por 15€? Configurando un Macro Pad en Linux con Rust 🎙
Configura un mini teclado de 3 teclas y rueda en Linux. Aprende a mapear hardware barato con Rust, reglas udev y el nuevo demonio kboard. ¡Optimiza!
👉 🎧 Escucha 🎧 👈
📻 Feed 📻
767 - Gestión de secretos extrema. SOPS + AGE + RUST (Más rápido que nunca)
¡Hola! Soy Lorenzo y en este vídeo te voy a contar por qué he decidido dar un giro radical a la forma en la que gestiono mis secretos y credenciales en Linux. Si usas scripts, herramientas de terminal o simplemente quieres tener tus contraseñas a buen recaudo pero accesibles de forma instantánea, este episodio es para ti.
Durante mucho tiempo he sido un fiel defensor de pass, una herramienta consolidada y segura. Sin embargo, en mi búsqueda constante por la eficiencia y la rapidez, me di cuenta de que necesitaba algo más. Quería que todo estuviera en un único archivo, que el acceso fuera inmediato y que el versionado en Git fuera más transparente. Así es como llegué a la combinación de Sops (de Mozilla) y Age.
En este vídeo te explico paso a paso cómo he montado este sistema. No solo te hablo de las herramientas de terceros, sino de cómo he tenido que "arremangarme" para crear mis propios scripts en Fish Shell para recuperar la comodidad que tenía con pass. He creado un sistema CRUD (Crear, Leer, Actualizar y Borrar) que me permite manejar mis secretos con comandos simples como secret add o secret get, enviando incluso la contraseña directamente al portapapeles en Wayland.
Pero como no podía quedarme ahí, te presento Crypta. Crypta es una utilidad que he desarrollado en Rust para unificar todo este flujo. Es absurdamente rápida. Mientras que con otros sistemas notaba una pequeña latencia al listar mis credenciales, con Crypta es instantáneo. Te mostraré cómo se integra con mi gestor de dotfiles, Yadm, y cómo utilizo plantillas Jinja para que mis archivos de configuración se rellenen automáticamente con las variables de entorno sin dejar rastro de las contraseñas reales en el disco.
Si te gusta el Open Source, la terminal y sobre todo, optimizar tu tiempo al máximo, quédate porque esta "vuelta revolucionaria" a la gestión de contraseñas te va a dar muchas ideas para tu propio entorno.
Capítulos del vídeo:
00:00:00 Introducción: El reto de gestionar secretos en la terminal
00:01:23 Por qué migrar de Pass a Sops y Age
00:03:08 La obsesión por la rapidez y el archivo único
00:04:26 Repositorios privados y versionado de secretos
00:06:59 El flujo de trabajo con .secrets.yml
00:08:02 Creando un CRUD personalizado en Fish Shell
00:10:30 Sincronización: Secret Pull, Push y Sync
00:12:46 Integración avanzada con Jinja y Yadm
00:15:28 Kripta: Gestión de secretos de alto rendimiento en Rust
00:18:25 Conclusiones y reflexiones sobre la migración
00:19:42 Despedida y red de podcasts
Espero que disfrutes de este viaje técnico tanto como yo he disfrutado rompiendo mi sistema actual para construir algo mucho más ágil. ¡No olvides suscribirte y dejarme tus impresiones en los comentarios!
Más información, enlaces y notas en https://atareao.es/podcast/767
🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
✈️ Telegram (el grupo) 👉 /channel/atareao_con_linux
✈️ Telegram (el canal) 👉 /channel/canal_atareao
🦣 Mastodon 👉 atareao" rel="nofollow">https://mastodon.social/@atareao
🐦 Twitter 👉 https://twitter.com/atareao
🐙 GitHub 👉 https://github.com/atareao
https://www.youtube.com/watch?v=PAMzXREzyso
#atareaoConLinux #podcastesp
766 - Adiós a Docker Compose. Cómo usar PODS en Podman (paso a paso)
¿Sigues gestionando contenedores como piezas sueltas? En este episodio del podcast, damos el salto definitivo de Docker-Compose a los **Pods** de Podman. Te enseño a agrupar servicios relacionados para que trabajen como una única unidad funcional, simplificando tu infraestructura y mejorando la seguridad de tus despliegues.
A lo largo del vídeo, migramos un stack real de WordPress, MariaDB y Redis. Veremos por qué la red en los Pods es mucho más sencilla al usar **localhost** y cómo el contenedor **Infra** mantiene todo en pie. Además, te muestro cómo llevar esto a producción de forma profesional usando **Quadlet** y **systemd**.
Lo que aprenderás en este episodio:
* **¿Qué es un Pod?**: Entiende por qué Podman se llama así y cómo comparten IP y espacio de nombres.
* **Adiós a las redes complejas**: Cómo WordPress se conecta a la base de datos simplemente llamando a 127.0.0.1.
* **Seguridad y Sidecars**: Blindar servicios como Redis dentro de la vaina para que nadie acceda desde fuera.
* **Monitorización real**: Uso de `podman pod stats` para ver el consumo de CPU y RAM de todo el stack unificado.
* **De YAML a Systemd**: Generar archivos de Kubernetes y automatizar el arranque con Quadlet.
### Capítulos del vídeo:
00:00:00 Introducción: El salto de Docker-Compose a Podman
00:01:42 ¿Qué es exactamente un Pod?
00:04:15 La magia de localhost y el contenedor Infra
00:07:30 Creando nuestra primera "vaina" (Pod)
00:10:05 Desplegando MariaDB en el Pod
00:13:20 WordPress y la simplificación de redes
00:16:45 Añadiendo Redis y el patrón Sidecar
00:19:10 Comandos de gestión: podman pod stats y stop
00:22:15 Generando YAML de Kubernetes desde Podman
00:24:40 Automatización con Quadlet y archivos .kube
00:26:30 Conclusiones y próximos pasos
Más información, enlaces y notas en https://atareao.es/podcast/766
🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
✈️ Telegram (el grupo) 👉 /channel/atareao_con_linux
✈️ Telegram (el canal) 👉 /channel/canal_atareao
🦣 Mastodon 👉 atareao" rel="nofollow">https://mastodon.social/@atareao
🐦 Twitter 👉 https://twitter.com/atareao
🐙 GitHub 👉 https://github.com/atareao
#Podman #Docker #Linux #Contenedores #SelfHosted #SysAdmin #Atareao
https://www.youtube.com/watch?v=1MElf00cJ2I
#atareaoConLinux #podcastesp
764 - Por qué NO deberías usar ROOT en tus Contenedores (y cómo arreglarlo)
¿Sabías que ejecutar tus contenedores como root es abrirle la puerta de par en par a un atacante? 😱
En este episodio, te muestro paso a paso cómo un atacante puede "escapar" de un contenedor Docker y tomar el control total de tu servidor. Pero no te preocupes, la solución definitiva es el **modo Rootless** y hoy aprenderás a configurarlo como un profesional.
Exploramos a fondo los **User Namespaces** de Linux, la tecnología que permite que seas "James Bond" (root) dentro del contenedor, pero un ciudadano normal (usuario sin privilegios) fuera de él.
### **¿Qué vas a aprender en este vídeo?**
* **El peligro real:** Simulación de un ataque de escape de contenedor usando el socket de Docker.
* **La clave mágica:** Qué son y cómo funcionan los User Namespaces, `/etc/subuid` y `/etc/subgid`.
* **Podman al rescate:** Instalación y configuración completa en **Ubuntu** y **Arch Linux**.
* **Productividad:** Cómo usar `podman-compose` y crear alias para no echar de menos a Docker.
* **Truco Maestro:** Cómo mapear los puertos **80 y 443** sin necesidad de privilegios de root ni complejos firewalls.
* **Almacenamiento:** Configuración personalizada de `storage.conf` para mover tus contenedores a otro disco (como `/data`).
### Capítulos del vídeo:
00:00:00 El peligro de ser root en contenedores
00:01:23 Demostración de un ataque de escape (Docker)
00:04:12 Por qué Podman detiene el ataque
00:05:38 Los User Namespaces: La clave de la seguridad
00:08:05 Entendiendo subuid y subgid
00:10:42 El mapa de identidades (uid_map)
00:13:54 Explorando el namespace con podman unshare
00:16:32 Instalación paso a paso en Ubuntu
00:20:15 Configuración específica para Arch Linux
00:23:44 Gestión del almacenamiento y storage.conf
00:26:18 El problema de los puertos bajos (80 y 443)
00:28:50 Solución nativa mediante sysctl
00:31:45 Conclusiones: Seguridad vs. Rendimiento
Más información, enlaces y notas en https://atareao.es/podcast/764
🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
✈️ Telegram (el grupo) 👉 /channel/atareao_con_linux
✈️ Telegram (el canal) 👉 /channel/canal_atareao
🦣 Mastodon 👉 atareao" rel="nofollow">https://mastodon.social/@atareao
🐦 Twitter 👉 https://twitter.com/atareao
🐙 GitHub 👉 https://github.com/atareao
**#Linux #Docker #Podman #Rootless #Ciberseguridad #Ubuntu #ArchLinux #DevOps #Atareao**
**¿Te ha servido el vídeo?** No olvides suscribirte y darle a la campanita para seguir optimizando tu sistema Linux. Si tienes alguna duda sobre el mapeo de usuarios, ¡te leo en los comentarios!
https://www.youtube.com/watch?v=_bqvCe3oN78
#atareaoConLinux #podcastesp
763 - Migra de Bash a Rust. Procesa millones de líneas en segundos
¿Tus scripts de Bash se han vuelto lentos, difíciles de mantener o fallan sin avisar? En este episodio S08E763, te traigo la guía definitiva para migrar de Bash a Rust utilizando rust-script. 🦀
Exploramos cómo transformar scripts tradicionales en herramientas de alto rendimiento, seguras y robustas. Pasamos de la inspección manual de variables como $? a la elegancia del operador ? en Rust, y de la lentitud de los bucles 'while read' a la velocidad de vértigo de 'BufReader'.
Si eres SysAdmin, desarrollador o entusiasta de Linux y quieres llevar tu automatización al siguiente nivel, este vídeo es para ti.
🚀 LO QUE APRENDERÁS EN ESTE VÍDEO:
* Cómo gestionar estados y errores de forma automática sin usar $?
* Validación de argumentos con tipado fuerte y Pattern Matching
* Manejo estructural de rutas con PathBuf (adiós a los problemas con espacios)
* Lectura y escritura masiva de archivos: procesa millones de líneas en segundos
* Concurrencia real: cómo usar hilos y Rayon para paralelizar tareas como pings
CAPÍTULOS:
00:00:00 Introducción: El reto de migrar a Rust
00:01:05 Gestión de estados y errores: Adiós al $?
00:04:22 Paso de argumentos y seguridad de tipos
00:07:34 Validación semántica con Pattern Matching
00:09:47 Ejecución de comandos externos y captura de salida
00:13:28 Gestión de rutas con PathBuf
00:16:32 Variables de entorno y valores por defecto
00:19:15 Escritura eficiente de logs con BufWriter
00:23:04 Lectura masiva de archivos con BufReader
00:26:18 Concurrencia y paralelismo: std::thread vs Rayon
00:31:45 Conclusión y tabla comparativa final
📊 COMPARATIVA RÁPIDA (BASH vs RUST):
* Manejo de Errores: Bash usa $? (manual); Rust usa el operador ? (automático)
* Rutas: Bash usa cadenas; Rust usa PathBuf (conciencia estructural)
* Concurrencia: Bash usa procesos al fondo (&); Rust usa hilos nativos seguros
* Rendimiento: Rust procesa archivos Gigabytes en segundos gracias a BufReader
📦 TECNOLOGÍAS MENCIONADAS:
#RustLang #Linux #Bash #RustScript #Productividad #SysAdmin #OpenSource #Docker #Terminal #Programacion
Si te gusta este contenido, no olvides suscribirte, darle a la campana y compartirlo con otros locos de Linux. ¡Cualquier cosa que quieras hacer con Linux, puedes hacerla mejor con Rust!
Más información, enlaces y notas en https://atareao.es/podcast/763
🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
✈️ Telegram (el grupo) 👉 /channel/atareao_con_linux
✈️ Telegram (el canal) 👉 /channel/canal_atareao
🦣 Mastodon 👉 atareao" rel="nofollow">https://mastodon.social/@atareao
🐦 Twitter 👉 https://twitter.com/atareao
🐙 GitHub 👉 https://github.com/atareao
https://www.youtube.com/watch?v=8QjkMjIq9PM
#atareaoConLinux #podcastesp
🎧 Escucha: 🎙 ¿Por qué estoy abandonando Docker? Adiós al Demonio 🎙
Descubre por qué migrar de Docker a Podman mejora la seguridad y eficiencia de tu servidor Linux. Analizamos arquitectura, logs y pods
👉 🎧 Escucha 🎧 👈
📻 Feed 📻
🎧 Escucha: 🎙 Rust-script. El fin de los scripts en Bash 🎙
Descubre cómo Rust Script sustituye a tus scripts de Bash complejos con la potencia y seguridad de Rust sin usar Cargo. ¡Optimiza tu Linux!.
👉 🎧 Escucha 🎧 👈
📻 Feed 📻
