---
title: "Go domina mi homelab: catálogo de apps self-hosted"
description: "Catálogo de las apps self-hosted de mi homelab y por qué Go domina la capa de infraestructura: binario único e imágenes ligeras."
date: 2026-10-03
locale: es
tags: [homelab, go]
summary: "Catálogo con lenguaje, tamaño de imagen y RAM en reposo de las 24 apps del homelab: 13 en Go, 11 de las 15 de infraestructura. El binario autocontenido y el consumo bajo de memoria explican por qué Go domina la capa que se administra a diario, mientras que la media pesada (Jellyfin, Immich) se queda en otros lenguajes."
url: https://escribano.dev/es/blog/020-homelab-go-stack-catalog/
---
El homelab tiene tres máquinas. kvothe (Ubuntu, Docker) acumula la media y las utilidades; kilvin (Fedora, Podman y quadlets) lleva la infraestructura y la identidad; elodin (QNAP) guarda datos y copias. Si pongo los contenedores de las dos primeras en una tabla y los ordeno por tamaño, sale un patrón: los servicios ligeros de infraestructura están escritos en Go, y los pesados de media, en otros lenguajes.

Este post es ese catálogo: lenguaje, tamaño de imagen y RAM de cada pieza que corre hoy. No es exhaustivo ni lo pretende; con esas tres columnas el patrón se ve solo. La [serie homelab](/blog/006-homelab-vpn-access/) ya cubrió acceso, DNS, [proxy](/blog/008-caddy-reverse-proxy-pihole/) e [identidad](/blog/009-homelab-identity/); aquí toca la foto completa del stack una vez resueltas esas capas.

## Go en la infraestructura

Go se ha convertido en uno de los lenguajes dominantes en las herramientas de infraestructura moderna. Varios de los proyectos que definieron la última década de operaciones están escritos en Go:

| Categoría | Proyectos |
|-----------|-----------|
| Contenedores y orquestación | Docker, Podman, containerd, Kubernetes, k3s, Helm, Kustomize |
| Red y proxy | Caddy, Traefik, CoreDNS |
| Observabilidad | Prometheus, Grafana, InfluxDB, Telegraf, Loki |
| Bases de datos y almacenamiento | etcd, CockroachDB, SeaweedFS, rclone, restic |
| Infraestructura como código | Terraform, OpenTofu, Pulumi, Terragrunt, Packer |
| Herramientas de desarrollo | Hugo, Dagger, gh (GitHub CLI) |
| Aplicaciones self-hosted | Syncthing, Zitadel, Forgejo, Memos, FileBrowser, PhotoPrism, Vikunja, Navidrome |

Un detalle sobre InfluxDB: la versión 3 está reescrita en Rust; las 1.x y 2.x siguen en Go.

Contenedores, orquestación, observabilidad e infraestructura como código comparten perfil: software que corre siempre, en muchos sitios, con poco mantenimiento y un binario que despliegas sin pensarlo. Ahí encaja Go. El contraejemplo también existe: nginx, Redis y PostgreSQL están escritos en C y dominan su hueco con una madurez que Go no ha desbancado. Go se ha impuesto sobre todo en la capa de operaciones; en las bases de datos clásicas y los servidores web, manda C.

## El dato: Go por mayoría y por capa

Mi homelab es una versión reducida de ese patrón. De las veinticuatro aplicaciones del catálogo, trece están escritas en Go: algo más de la mitad. En la capa de infraestructura (proxy, DNS, identidad, git, métricas, dashboards) son once de quince. En media y documentos el patrón se invierte: de las nueve aplicaciones de ese grupo, solo dos (Memos y FileBrowser) son Go.

Cuento como aplicación cada servicio con una función propia; quedan fuera las bases de datos, los contenedores de desarrollo y CI, y los proyectos en marcha. Ese filtro favorece a Go, y lo digo sin rodeos: las tres bases de datos del catálogo (MariaDB, Firebird y Postgres) están en C o C++, así que excluirlas sube el porcentaje. Es una decisión de método; si las contara, el reparto sería menos favorable. La tendencia se mantiene igual: cuanto más cerca del mantenimiento diario, más Go; cuanto más cerca de servir gigas de fotos y películas, menos.

## El catálogo

Las imágenes son las que reportan `docker images` y `podman images` (tamaño de capas, una arquitectura); la RAM es la de `docker stats` y `podman stats` en reposo, redondeada. Algunos servicios (Caddy, Memos, FileBrowser, Prometheus, Grafana, Vaultwarden y Whisper) corren en ambas máquinas; en esos casos doy el rango. rclone lo uso bajo demanda para las copias; al no ser un servicio residente, queda fuera del catálogo.

### Infraestructura y plataforma

| Aplicación | Lenguaje | Imagen | RAM | Para qué |
|------------|----------|--------|-----|----------|
| node-exporter | Go | 26 MB | 17 MiB | Métricas del host |
| DuckDNS | shell | 35 MB | 5 MiB | DNS dinámico |
| oauth2-proxy | Go | 36 MB | 5 MiB | Forward auth |
| Syncthing | Go | 43 MB | 26 MiB | Sincronización de archivos |
| Caddy | Go | 59–63 MB | 12–14 MiB | Reverse proxy y TLS |
| Authelia | Go | 78 MB | 17 MiB | Forward auth y 2FA |
| Tailscale | Go | 112 MB | 43 MiB | Mesh y acceso |
| Forgejo | Go | 178 MB | 203 MiB | Git self-hosted |
| Zitadel | Go | 179 MB | 81 MiB | Identidad (IdP OIDC) |
| Portainer | Go | 184 MB | 19 MiB | Gestión de contenedores |
| Homepage | TypeScript | 266 MB | 115 MiB | Dashboard |
| Prometheus | Go | 296–423 MB | 90–93 MiB | Métricas |
| Glances | Python | 502 MB | 90 MiB | Monitor del sistema |
| wg-easy | Node | 535 MB | 18 MiB | WireGuard con panel |
| Grafana | Go | 555 MB–1,07 GB | 109–156 MiB | Dashboards |

### Aplicaciones, media y documentos

| Aplicación | Lenguaje | Imagen | RAM | Para qué |
|------------|----------|--------|-----|----------|
| Memos | Go | 66–69 MB | 12 MiB | Notas rápidas |
| aMule | C++ | 126 MB | 129 MiB | Red P2P eD2k/Kad |
| FileBrowser | Go | 192–219 MB | 24–35 MiB | Archivos desde el navegador |
| Vaultwarden | Rust | 243–249 MB | 10–14 MiB | Gestor de contraseñas |
| BookStack | PHP | 401 MB | 12 MiB | Documentación y wiki |
| Whisper | Python | 606–614 MB | 13–315 MiB | Transcripción (STT) |
| Piper | C++ | 877 MB | 650 MiB | Síntesis de voz (TTS) |
| Jellyfin | C# | 1,56 GB | 1,0 GiB | Servidor multimedia |
| Immich | TypeScript (+ Python) | 3,5 GB | 385 MiB | Fotos |

Las bases de datos que acompañan a esas aplicaciones (MariaDB, Firebird y Postgres) no cuentan como aplicaciones; son infraestructura de apoyo y están todas fuera de Go.

## Por qué Go encaja en el homelab

La explicación empieza en el binario. Go compila normalmente a un binario autocontenido: el runtime de Go va incluido en el propio ejecutable, así que no hace falta instalar un runtime externo como Python, Java o .NET. Evitando CGO puedes producir binarios estáticos, aunque no todos los binarios Go lo son ni están libres de dependencias del sistema. Ese modelo reduce las dependencias que pueden desincronizarse entre la máquina y el contenedor. En el homelab eso se traduce en imágenes de decenas de megas: Caddy 63 MB, node-exporter 26 MB, Syncthing 43 MB, Authelia 78 MB. Las que superan el gigabyte en mi catálogo son todas de media (Jellyfin 1,56 GB, Immich 3,5 GB).

La RAM en reposo sigue la misma lógica. Caddy se queda en 12–14 MiB, Memos en 12 MiB, Authelia en 17 MiB y Vaultwarden (Rust) en 14 MiB. Whisper salta de 13 MiB en reposo a más de 300 MiB cuando transcribe, Piper (TTS) se planta en 650 MiB, el servidor de Immich arranca en 385 MiB y Jellyfin ronda el gigabyte. En un mini PC de bajo consumo, esa diferencia se nota en cuántos servicios caben sin hacer swap y en la factura eléctrica. Yo lo tengo medido: kvothe tiene 16 GB de RAM y de normal quedan libres unos 12 GB, con Jellyfin y buena parte de los servicios del catálogo funcionando. Con ese margen se puede seguir añadiendo servicios sin miedo a saturar la RAM, apuntando a los ligeros siempre que se pueda.

La tercera pieza es el mantenimiento. Menos piezas móviles significan menos cosas que rompen al actualizar. Que eso se traduzca en actualizaciones sin drama depende más de los contenedores que de Go: aislar el servicio es lo que permite actualizar y revertir cuando toca. Ahora bien, cuando el contenedor depende de un binario único (como pasa con Go y Rust), la imagen es mucho más pequeña y las actualizaciones, más rápidas.

## Tres matices al patrón

Go no lo explica todo. Hay tres matices que conviene tener presentes.

El primero: Go y "ligero" no siempre van juntos. Grafana (Go) pesa más de medio gigabyte, Prometheus (Go) entre 296 y 423 MB, y Forgejo (Go) se queda en 203 MiB de RAM pese a ser un único binario. Las herramientas de observabilidad empaquetan el frontend y los plugins, y un forge de git arrastra mucho más que el runtime. Go reduce el backend; lo que decidas empaquetar encima sigue pesando lo suyo.

El segundo: la compacidad no es exclusiva de Go. Vaultwarden, escrito en Rust, genera una imagen de 243 MB y arranca en 14 MiB, en línea con los servicios Go del extremo ligero. Rust comparte el motivo (binario autocontenido, imágenes pequeñas y buen perfil de consumo en servicios como este), así que el sitio de Go en este eje no es permanente.

El tercero: la media. Jellyfin (C#) domina el extremo pesado y no tiene un equivalente en Go igual de completo para vídeo. Con Immich (TypeScript y Python) el argumento es más débil: existe PhotoPrism, también en Go, con un enfoque y un flujo de trabajo distintos a los que busco. Me decanté por Immich porque es multiusuario, aunque en la práctica soy yo solo; me queda en la lista probar PhotoPrism o incluso Ente (que también tiene el servidor en Go) en algún momento del futuro. El criterio de fondo es la fricción operativa: cuando una pieza pide más RAM y más atención que su alternativa, se nota en la tabla; cuando no, se queda.

## Cierre

En el [marco RPS](/blog/002-rps-principle/), Go ocupa el sitio de la piedra: una pieza que funciona, con poco que romper. Para infraestructura personal, donde lo que decide es el mantenimiento, la piedra gana.

El catálogo repite el patrón. Once de los quince servicios de infraestructura están escritos en Go. Los más ligeros (node-exporter, Caddy, Authelia, Syncthing, Tailscale) se quedan en imágenes de decenas de megas y unas decenas de MiB de RAM en reposo; otros como Forgejo, Zitadel, Prometheus o Grafana se alejan bastante de ese perfil. Los gigabytes y la RAM alta se concentran en la media: Jellyfin (1,56 GB, 1 GiB) e Immich (3,5 GB, 385 MiB). El lenguaje es de las pocas decisiones que no se cambian con un reverse proxy delante, así que conviene mirarlo antes de desplegar. En la capa que administro a mano, Go gana por mayoría; en la de media, depende de lo que haya disponible en cada ecosistema.

Este catálogo es también una instantánea de lo que significa la [soberanía digital](/blog/005-digital-sovereignty/) en la práctica: quince servicios en hardware propio, cada uno con su coste de mantenimiento a la vista y una salida despejada si algo deja de encajar.