Atareao con Linux

¡Bienvenidos a un nuevo episodio de Atareao con Linux! Soy Lorenzo y hoy te traigo una confesión técnica: he abandonado mi sistema de gestión de contraseñas de toda la vida. ¿El motivo? La pura y dura velocidad.
En el episodio de hoy (el 767), profundizamos en la migración de pass hacia un ecosistema más moderno compuesto por Sops y Age. Te cuento los dolores de cabeza, pero también las inmensas satisfacciones de tener todos tus secretos centralizados en un archivo YAML cifrado de forma inteligente, donde las claves son visibles pero los valores están protegidos.
Si alguna vez has sentido que tu flujo de trabajo con secretos es lento o farragoso, aquí te traigo la solución. Te detallo cómo he programado mis propias herramientas en Fish Shell para gestionar el día a día y, sobre todo, te presento mi nueva creación en Rust: Crypta. Esta herramienta es la pieza que faltaba en el puzzle para que trabajar con credenciales en la terminal sea algo que ocurra a la velocidad del pensamiento.
Además, exploramos conceptos avanzados como el uso de Yadm para gestionar dotfiles y cómo las plantillas Jinja pueden automatizar la configuración de tus aplicaciones inyectando secretos de forma segura en memoria.
Contenido del episodio:
00:00:00 Introducción: El reto de gestionar secretos en la terminal
00:01:23 Por qué migrar de Pass a Sops y Age
00:03:08 La obsesión por la rapidez y el archivo único
00:04:26 Repositorios privados y versionado de secretos
00:06:59 El flujo de trabajo con .secrets.yml
00:08:02 Creando un CRUD personalizado en Fish Shell
00:10:30 Sincronización: Secret Pull, Push y Sync
00:12:46 Integración avanzada con Jinja y Yadm
00:15:28 Kripta: Gestión de secretos de alto rendimiento en Rust
00:18:25 Conclusiones y reflexiones sobre la migración
00:19:42 Despedida y red de podcasts
Acompáñame en esta aventura de optimización extrema. Ya sabes que el día son dos días y uno ya ha pasado, ¡así que vamos a aprovecharlo haciendo que nuestro Linux vuele!

Más información y enlaces en las notas del episodio
🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
🦣 Mastodon 👉 https://mastodon.social/@atareao
🐦 Twitter 👉 https://twitter.com/atareao
🐙 GitHub 👉 https://github.com/atareao

¿Sigues usando Docker Compose para todo? Es hora de descubrir la verdadera potencia de Podman: los Pods. En este episodio te acompaño en la migración de un stack completo de WordPress, MariaDB y Redis para que veas cómo simplificar radicalmente la gestión de tus contenedores.
Aprenderás por qué el concepto de "vaina" (Pod) cambia las reglas del juego al permitir que tus contenedores compartan la misma red y dirección IP, atacando directamente a localhost. Veremos desde el funcionamiento técnico del contenedor Infra hasta la automatización profesional con Quadlet y systemd.
¿Qué es un Pod?: El origen del nombre y por qué es la unidad lógica ideal para tus servicios.

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

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

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

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

Si buscas soluciones prácticas para "cualquier cosa que quieras hacer con Linux", este episodio te da las herramientas para profesionalizar tu infraestructura.
Notas completas y comandos utilizados: https://atareao.es/podcast/766

🔐 Cifrado Moderno: Migrando de Pass a Age + SOPS
¿Es GPG demasiado lento para tu flujo de trabajo? En este episodio, Lorenzo Carbonell (atareao) explica por qué decidió abandonar su antigua gestión de contraseñas y cómo ha optimizado sus dotfiles y despliegues de Docker utilizando un "dúo dinámico" de herramientas modernas.
El fin de una era: Por qué pass y gopass dejaron de ser la solución ideal para gestionar secretos complejos.

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

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

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

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

¿Sabías que ejecutar Docker como root es, en esencia, darle las llaves de tu casa a cualquier proceso que corra en un contenedor? En este episodio exploramos el modo Rootless, una configuración que aumenta drásticamente la seguridad de tus servidores al eliminar la necesidad de privilegios de administrador.
El Experimento del Escape: Te explico cómo un atacante puede usar el socket de Docker para "escapar" del contenedor y tomar el control total de tu host.

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

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

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

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

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

Si te preocupa la seguridad de tus servicios autohospedados (self-hosted) o quieres llevar tu gestión de contenedores al siguiente nivel de profesionalismo, este episodio es para ti.
Notas completas y comandos: Visita atareao.es para ver todos los scripts y configuraciones mencionadas.

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

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

Más información y enlaces en las notas del episodio
🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
🦣 Mastodon 👉 https://mastodon.social/@atareao
🐦 Twitter 👉 https://twitter.com/atareao
🐙 GitHub 👉 https://github.com/atareao

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

¿Es hora de jubilar tus viejos scripts de Bash? 🦀 En el episodio 763 de "Atareao con Linux", nos enfrentamos a uno de los retos más interesantes para cualquier amante de la automatización: la migración de Bash a Rust. Muchos scripts de Bash crecen hasta volverse inmanejables, lentos o propensos a errores silenciosos. Rust, a través de rust-script, nos ofrece una alternativa con un rendimiento profesional, seguridad de tipos y una gestión de errores que Bash simplemente no puede alcanzar.Lo que aprenderás hoy:
Gestión de estados: Cómo el operador '?' de Rust elimina la necesidad de comprobar manualmente la variable $? tras cada comando.
Seguridad en argumentos: Olvídate de las expresiones regulares complejas para validar números; usa el tipado fuerte y el método .parse().
Manipulación de rutas: El uso de PathBuf para evitar que un simple espacio en un nombre de archivo rompa toda tu lógica.
Rendimiento extremo: Cómo BufReader permite procesar archivos de logs de Gigabytes en segundos, algo que en Bash podría tardar minutos.
Concurrencia real: Paraleliza tareas (como pings masivos) de forma segura con hilos nativos o librerías como Rayon.
Capítulos del episodio:
00:00:00 Introducción: El reto de migrar a Rust
00:01:05 Gestión de estados y errores: Adiós al $?
00:04:22 Paso de argumentos y seguridad de tipos
00:07:34 Validación semántica con Pattern Matching
00:09:47 Ejecución de comandos externos y captura de salida
00:13:28 Gestión de rutas con PathBuf
00:16:32 Variables de entorno y valores por defecto
00:19:15 Escritura eficiente de logs con BufWriter
00:23:04 Lectura masiva de archivos con BufReader
00:26:18 Concurrencia y paralelismo: std::thread vs Rayon
00:31:45 Conclusión y tabla comparativa final¿Por qué Rust para tus scripts?
Migrar a Rust no es solo una cuestión de velocidad; es una cuestión de robustez. Al usar Rust, el compilador te obliga a manejar todos los posibles casos de error, evitando fallos en cadena en tus sistemas. Además, gracias a herramientas como Rayon, la ejecución paralela se vuelve rápida y segura. #Linux #Rust #Bash #Programacion #OpenSource #SysAdmin #Productividad #Atareao #RustLang #Automation

Más información y enlaces en las notas del episodio
🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
🦣 Mastodon 👉 https://mastodon.social/@atareao
🐦 Twitter 👉 https://twitter.com/atareao
🐙 GitHub 👉 https://github.com/atareao