Pesoz es mi laboratorio de sistemas en producción real: dos máquinas en casa que alojan una treintena de servicios contenedorizados, funcionando 24/7 y accesibles de forma segura desde Internet. Es donde practico DevOps de verdad — no en diapositivas, sino con uptime, backups y post-mortems. La pestaña Infraestructura de este portfolio lo muestra en vivo (estado de Uptime Kuma).

Dos hosts

• NAS · Synology DS224+ (Celeron J4125, ~10 GB de RAM): el núcleo. Docker con un docker-compose por servicio; los servicios pesados arrancan bajo demanda para respetar el presupuesto de memoria.
• Portátil IA · RTX 2060, encendido 24/7: servidor de IA y clúster de observabilidad en k3s (Kubernetes). Sus apps se publican a través del Caddy del NAS y guardan sus datos en el NAS.

Red y acceso

• Cloudflare para el DNS (con DDNS) y Cloudflare Pages, que sirve este portfolio.
• Router Keenetic con WireGuard: acceso remoto a los servicios internos sin exponerlos. Nada más está abierto.
• Entrada única HTTPS: Caddy como reverse proxy con TLS automático para cada servicio, y CrowdSec como WAF leyendo sus logs.
• AdGuard Home como DNS local y filtrado.

Servicios

• Públicos: Jellyfin (media), Syntax (snippets), ntfy (notificaciones) y Uptime Kuma (monitorización).
• Internos · solo LAN/VPN: núcleo de Lito (mi asistente de voz), n8n (automatización + IA), Forgejo (git + CI/CD) y AdGuard Home.
• Datos: PostgreSQL (BD central y LifeOS), Redis (colas + caché) y Qdrant (vectores para IA).
• IA (portátil): Ollama (LLM local), voz con Whisper + Kokoro, SearXNG (buscador privado), un reranker para la memoria de LifeOS y la app LifeOS.

Modelo de seguridad

El proxy distingue tres niveles de exposición mediante snippets reutilizables:

• Públicos: cabeceras de seguridad (HSTS, X-Frame-Options, X-Content-Type-Options, Referrer-Policy, Permissions-Policy) y compresión.
• Internos: un snippet internal_only responde 403 a todo lo que no venga de la LAN, la VPN o localhost.
• Infra: servicios sin proxy, solo alcanzables dentro de su red Docker.

Además: endurecimiento por contenedor (no-new-privileges, cap_drop: ALL, límites de memoria, healthchecks) y secretos en .env fuera del control de versiones.

Observabilidad

En el NAS, node-exporter, cAdvisor y Alloy recogen métricas del host, de los contenedores y logs; los envían a Prometheus, Grafana, Loki y Tempo, que corren en k3s en el portátil (métricas, dashboards, logs y trazas). Uptime Kuma vigila la disponibilidad y avisa por ntfy/Telegram.

Entrega (GitOps)

• Forgejo autoalojado con CI/CD: el despliegue de los servicios se versiona y automatiza (infraestructura como código).
• n8n para automatizaciones y pasarelas hacia APIs externas; las nuevas versiones de imágenes se vigilan y notifican.
• Backups automatizados con pruebas de restauración documentadas en un runbook.

Qué demuestra

Un perfil híbrido dev + sistemas: no solo escribo el código, también administro la red, el TLS, las bases de datos, Kubernetes, la seguridad perimetral y la recuperación ante fallos donde ese código corre.

Pesoz is my systems lab in real production: two machines at home running around thirty containerized services 24/7, securely reachable from the Internet. It's where I practice real DevOps — not on slides, but with uptime, backups and post-mortems. The Infrastructure tab of this portfolio shows it live (Uptime Kuma status).

Two hosts

• NAS · Synology DS224+ (Celeron J4125, ~10 GB RAM): the core. Docker with one docker-compose per service; heavy services start on demand to respect the memory budget.
• AI laptop · RTX 2060, on 24/7: AI server and observability cluster on k3s (Kubernetes). Its apps are published through the NAS's Caddy and keep their data on the NAS.

Network & access

• Cloudflare for DNS (with DDNS) and Cloudflare Pages, which serves this portfolio.
• Keenetic router with WireGuard: remote access to internal services without exposing them. Nothing else is open.
• Single HTTPS entry point: Caddy as reverse proxy with automatic TLS for every service, and CrowdSec as WAF reading its logs.
• AdGuard Home as local DNS and filtering.

Services

• Public: Jellyfin (media), Syntax (snippets), ntfy (notifications) and Uptime Kuma (monitoring).
• Internal · LAN/VPN only: Lito core (my voice assistant), n8n (automation + AI), Forgejo (git + CI/CD) and AdGuard Home.
• Data: PostgreSQL (main DB and LifeOS), Redis (queues + cache) and Qdrant (AI vectors).
• AI (laptop): Ollama (local LLM), voice with Whisper + Kokoro, SearXNG (private search), a reranker for LifeOS memory and the LifeOS app.

Security model

The proxy separates three exposure levels via reusable snippets: Public (security headers — HSTS, X-Frame-Options, X-Content-Type-Options, Referrer-Policy, Permissions-Policy — and compression), Internal (an internal_only snippet returns 403 to anything not from the LAN, VPN or localhost) and Infra (no proxy, reachable only within its Docker network). Plus per-container hardening (no-new-privileges, cap_drop: ALL, memory limits, healthchecks) and secrets in .env kept out of version control.

Observability

On the NAS, node-exporter, cAdvisor and Alloy collect host metrics, container metrics and logs; they ship them to Prometheus, Grafana, Loki and Tempo running on k3s on the laptop (metrics, dashboards, logs and traces). Uptime Kuma watches availability and alerts through ntfy/Telegram.

Delivery (GitOps)

• Forgejo self-hosted with CI/CD: service deployment is versioned and automated (infrastructure as code).
• n8n for automations and gateways to external APIs; image updates are watched and notified.
• Automated backups with restore tests documented in a runbook.

What it proves

A hybrid dev + systems profile: I don't just write the code, I also run the network, TLS, databases, Kubernetes, perimeter security and failure recovery where that code runs.