El camino a mi homelab.

Esta es la historia de cómo llegué al homelab que tengo ahora.

14 min de lectura Disponible en: Inglés
Homelab Proxmox Ansible Story

Entre mis muchos hobbies, mantener el homelab es de los que mayor satisfacción me entrega. Un homelab o home server es un computador que, en vez de servir como estación de trabajo, se utiliza para proveer servicios de forma local. El caso más común son los NAS (Network Attached Storage), pero con un poco de creatividad y el software adecuado, es totalmente posible montar herramientas para manejar tus finanzas personales, una videoteca o servidores de juegos.

En este post comparto la historia del homelab que he construido en los últimos 2 años.

El inicio y el punto de quiebre #

Hace 2 años ya tenía cubiertas la mayoría de mis necesidades tecnológicas: las resolvía localmente en mi estación de trabajo, o bien usaba servicios gratuitos. Además, un amigo ya me proveía infraestructura para proyectos pequeños, por lo que armar un homelab para mí no tenía mucho sentido.

Sin embargo, con el tiempo me di cuenta de que el esfuerzo de mantener mi propia infraestructura se volvía una mejor opción a tolerar la enshitificación de los servicios de los que dependía. Ver las experiencias de otros colegas con sus homelabs también encendió mi curiosidad sobre el tema. El momento en que decidí tomar riendas fue cuando terminé el upgrade de mi PC personal y quedé con hardware sobrante que podría aprovechar para hacer una prueba de concepto.

Dediqué algo de tiempo a investigar el estado del arte. Por suerte, los espacios que exploré están llenos de gente dispuesta a compartir sus experiencias y setups. Vi videos sobre distintas formas de montar la infraestructura, revisé varios repositorios y estudié las herramientas modernas, tanto comerciales como de código abierto, que se usan para este propósito.

Mi primer setup #

La mayoría de las piezas de este computador las adquirí en 2013. Como sabía que este sería un setup provisorio, solo invertí en almacenamiento persistente, el cual reciclaría en caso de armar algo definitivo.

Para esta prueba de concepto, decidí usar Proxmox como sistema operativo. Era una de las opciones más recomendadas para manejar contenedores y máquinas virtuales, tenía una buena interfaz web y muchas guías disponibles en línea por si quería personalizar algo. También quería familiarizarme con LXC como tecnología de contenedores de sistema.

Decidí trabajar con contenedores usando la imagen de Fedora como base y provisionar las aplicaciones de código abierto que usaría directamente. Un problema que trae este enfoque es que muchas de las aplicaciones que se distribuyen para hostear localmente vienen empaquetadas en imágenes de Docker para ser usadas con Docker Compose; en estos casos, usarlas implicaría el trabajo extra de adaptarlas o reempaquetarlas para poder instalarlas directamente en el contenedor. En el peor de los casos, siempre podía anidar contenedores, pero era algo que quería evitar.

En lugar de instalar las aplicaciones en los contenedores manualmente, opté por usar Ansible como mecanismo de aprovisionamiento, una herramienta a la que ya estaba bastante acostumbrado por mi trabajo. Puede que esta decisión se vea sobredimensionada para la escala inicial del proyecto, pero cambiar el enfoque de “mantener infraestructura” a “crear un sistema” es algo que me resulta más cómodo como desarrollador. Además, me permite llevar registro de la composición del sistema, algo útil para alguien que tiende a olvidar las cosas y no tiene la paciencia para documentarlo todo. También evalué otras herramientas de aprovisionamiento (Kubernetes, OpenTofu, cosas por el estilo), pero no me hizo sentido considerando que mi proyecto no escalaría más allá del uso local.

Mi plan inicial consistió en migrar el bot de Discord y los juegos que tenía hosteados con mi amigo, para luego seguir construyendo desde ahí.

Anotación: Primeros pasos del Homelab
    flowchart LR
    subgraph Proxmox["Proxmox VE Host"]
        subgraph LXC0["LXC Container: dns"]
           Cockpit0["Cockpit Web UI"]
           DNS["<b>DNS</b><br/>BIND9<br/>port 53"]
       end
       subgraph LXC1["LXC Container: maruchan"]
           Cockpit1["Cockpit Web UI"]
           Maru["<b>Maruchan Bot</b><br/>Podman container"]
       end
       subgraph LXC2["LXC Container: ai"]
           Cockpit2["Cockpit Web UI"]
           AI["<b>AI Service</b><br/>ramalama serve<br/>port 8080"]
       end
   end

   Discord["<b>Discord Bot</b><br/>External"]
   LAN["<b>Local LAN</b>"]

   Discord <--> Maru
   LAN <--> DNS
   LAN <--> AI
   AI --> Maru
   DNS -->|"DNS resolution"| LAN
   DNS -->|"DNS resolution"| LXC1
   DNS -->|"DNS resolution"| LXC2

Diagrama de mi Homelab al comienzo - 2024-11-28.

Con esta base, la estructura era simple, pero ya tenía una idea clara de cómo organizar las cosas para asegurar la escalabilidad. Como punto de partida, decidí mantener dos repositorios: uno con los roles y playbooks, y otro con el inventario. El playbook principal organiza tres tareas:

  • Proveer el servidor de servicios básicos:
    • Proxmox
    • Cockpit
    • Certificados
    • Almacenamiento compartido
  • Levantar contenedores:
    • Contenedores LXC con imágenes de Fedora
    • Configurar IPs y aplicaciones base (SSH, Cockpit, firewall, etc.)
  • Aprovisionar contenedores:
    • Instalar roles específicos

Prueba de concepto - Etapa 2 #

Como en esta etapa aun era un proyecto personal, no queria ser muy ambisioso con lo que agregaba al servidor. Luego de 3 meses, las aplicaciones que terminé agregando fueron una instancia de Forgejo y algunos juegos para correr localmente.

Anotación: Prueba de concepto
    flowchart LR
    subgraph Proxmox["Proxmox VE Host"]
        subgraph LXC0["LXC Container: dns"]
           DNS["<b>DNS</b><br/>BIND9<br/>port 53"]
        end
        subgraph LXC1["LXC Container: traefik"]
           Traefik["<b>Traefik</b><br/>Reverse Proxy<br/>ports 80, 443<br/>Let's Encrypt / Cloudflare DNS-Challenge"]
        end
        subgraph LXC2["LXC Container: forgejo"]
           Forgejo["<b>Forgejo</b><br/>Git Server<br/>port 3000 / 22"]
        end
        subgraph LXC3["LXC Container: semaphore"]
           Semaphore["<b>Semaphore</b><br/>Ansible CI/CD"]
        end
        subgraph LXC4["LXC Container: ai"]
           AI["<b>AI Service</b><br/>ramalama serve<br/>port 8080<br/>llama3.2:3b"]
        end
        subgraph LXC5["LXC Container: maruchan"]
           Maru["<b>Maruchan Bot</b><br/>Discord Bot<br/>Podman container"]
        end
        subgraph LXC6["LXC Container: luanti"]
           Luanti["<b>Luanti</b><br/>Minetest Server<br/>port 30000"]
        end
        subgraph LXC7["LXC Container: veloren"]
           Veloren["<b>Veloren</b><br/>Game Server<br/>ports 14004, 14005, 14006/udp"]
        end
        subgraph LXC8["LXC Container: starbound"]
           Starbound["<b>Starbound</b><br/>Game Server<br/>port 21025<br/>RCON port 21026<br/>SteamCMD"]
        end
    end

    Discord["<b>Discord Bot</b><br/>External"]
    LAN["<b>Local LAN</b>"]

    Discord <--> Maru
    LAN <--> Traefik
    LAN <--> Luanti
    LAN <--> Veloren
    LAN <--> Starbound
    LAN --> DNS
    DNS -->|"DNS resolution"| LXC1
    DNS -->|"DNS resolution"| LXC2
    DNS -->|"DNS resolution"| LXC3
    DNS -->|"DNS resolution"| LXC4
    Traefik -->|"HTTPS routing"| Forgejo
    Traefik -->|"HTTPS routing"| Semaphore
    AI -->|"http://localhost:8080"| Maru
    Maru -->|"RCON port 21026"| Starbound

Estado final de la prueba de concepto - 2025-01-27.

Una mejora que realicé fue estructurar el proceso de generación de los contenedores LXC de modo que el sistema los cree directamente desde el inventario. Para cada contenedor, creé archivos de variables en inventory/hosts_vars/, donde definí su configuración base, registro DNS, IPs, espacio de almacenamiento externo y los límites de recursos según la tarea que desempeñarían. Luego, en el archivo inventory/main.yml, definí qué hosts corresponden a contenedores y qué roles se asignarían a cada uno. Quería replicar la experiencia de usar un archivo docker-compose.yml, pero adaptado al tipo de infraestructura que estaba construyendo.

Ejemplo: Descripción de contenedor - Voxelibre

inventory/hosts_vars/voxelibre.yml

yml 
ansible_host: <IP>
hostname: voxelibre

# Container
proxmox_container:
  vmid: 1013
  disk: 'local-lvm:8'
  netif:
    - "ip=<IP 2>/24,bridge=vmbr2"
  cores: 2
  memory: 4096
  unprivileged: True

# External storage
storage_mnt:
  - path: /voxelibre
    target: /var/lib/minetest/voxelibre
    uid: 996
    gid: 996
    size: 20G

# Luanti Mode
luanti_config:
  game:
    name: mineclone2
    url: https://content.luanti.org/uploads/bf06e78d80.zip
    user_password: p0t4t0p0t4t0
    mods:
    - name: mapserver
      url: https://content.luanti.org/uploads/8593934e95.zip
    - name: whitelist
      url: https://content.luanti.org/uploads/3856ecc059.zip
    - name: xban2
      url: https://content.luanti.org/uploads/14be84e5ee.zip
    - name: illumination
      url: https://content.luanti.org/uploads/65d28de215.zip
      # whitelist deps
    - name: lib_chatcmdbuilder
      url: https://content.luanti.org/uploads/e34ab089d8.zip

  world:
    id: "{{ hostname }}"
    name: Grillo's Server - VoxeLibre
    description: Personal server :)
    host: "{{ hostname }}.{{ domain_name }}"
    url: https://{{ hostname }}.{{ domain_name }}
    admin_name: grillo
    announce: false
    port: 30000
    settings:
    - enable_minimap = true
    - mapserver.enable_crafting = true
    - mapserver.send_interval = 10
    - secure.http_mods = mapserver
    - mapserver.url = http://127.0.0.1:8080
    - enable_rollback_recording = true

  mapserver:
    port: 8080

# DNS settings
dns_list:
  - "{{ hostname }}.luanti           IN      A       <IP>"

# Traefik Config
traefik_config:
  http:
    routers:
      to-voxelibre:
        rule: Host(`{{ hostname }}.{{ domain_name }}`)
        service: voxelibre
    services:
      voxelibre:
        loadBalancer:
          servers:
          - url: http://<IP 2>:8080

inventory/main.yml

Código 
containers:
  hosts:
    voxelibre:

role_luanti:
  hosts:
    voxelibre:

En el aspecto de infraestructura, agregué dos herramientas más: Traefik y SemaphoreUI.

SemaphoreUI es una aplicación para orquestar procesos automatizados con una interfaz web cómoda. Para mi caso, funcionó bien como un front-end para automatizar y ejecutar los playbooks del servidor. Para habilitarlo bastó con proveer una llave para el host y acceso a los repositorios que ya estaban en la instancia de Forgejo.

Traefik, por otro lado, es un proxy HTTP; principalmente lo utilicé para exponer en un punto único los servicios web y, así, evitar tener que generar certificados y registros DNS para cada contenedor por separado.

Como mencioné antes, muchas de estas aplicaciones se distribuyen como imágenes pre-generadas y no suelen tener instrucciones de como pueden ser utilizadas directamente fuera de un contenedor. Sin embargo, es posible deducir el proceso de instalación a partir de los archivos de los contenedores y de los de la infraestructura de integración continua. Estudiando estos artefactos, decidí generar mis propios paquetes RPM. Empecé con SemaphoreUI y Traefik, pero si exploran la organización donde mantengo los paquetes, podrán notar que no me detuve ahí.

El fin de la prueba #

Unos meses después, por la falla de un computador de la casa, tuvimos que liberar el hardware que estaba usando para el homelab. Para ese entonces, ya consideraba que la prueba había sido un éxito y estaba planificando la compra de un equipo definitivo.

Definir expectativas claras sobre lo que quería lograr era algo que no quería subestimar, ya que en este punto veía el potencial de que fuera algo más grande que un proyecto personal. Igual quería evitar que se convirtiera en infraestructura crítica, así que dejaría fuera cosas como gestores de contraseñas o Home Assistant. Tampoco quería exponer servicios públicos, por lo que mailservers, páginas web o instancias de Mastodon quedaban fuera (a menos que fueran experimentos locales). Con objetivos claros, busqué un equipo pequeño y eficiente energéticamente, pero con recursos suficientes para lo que quería correr.

Un gran cambio que hice fue migrar el host de Proxmox a Fedora Server. Mi principal motivo para dejar Proxmox fue su dependencia de Debian como base. Podría sonar contraintuitivo, ya que es más fácil manejar un sistema en distros con ciclos de actualización largos como CentOS o Debian, precisamente porque evitan incorporar versiones de software que cambien la forma en que se interactúa con el sistema. Desde esa perspectiva, el ciclo de actualizaciones de Fedora podría sonar como una desventaja, pero a mí siempre me ha gustado explorar las últimas versiones de las aplicaciones y colaborar cuando es posible, usar Fedora me ayuda a involucrarme en los proyectos directamente sin sacrificar tanta estabilidad. Otro motivo que habilitó la migración fue que el proyecto Incus ya estaba tomando vuelo y se veía como una alternativa viable para manejar contenedores de sistema en Fedora.

Anotación: Home lab cacero
    flowchart LR
    subgraph Fedora["Fedora Host (Incus)"]
        subgraph LXC_DNS["LXD Container: dns"]
           DNS["<b>DNS</b><br/>BIND9<br/>port 53"]
        end
        subgraph LXC_TRAEFIK["LXD Container: traefik"]
           Traefik["<b>Traefik</b><br/>Reverse Proxy<br/>ports 80, 443<br/>Let's Encrypt / CF DNS-Challenge"]
        end
        subgraph LXC_AUTHELIA["LXD Container: authelia"]
           Authelia["<b>Authelia</b><br/>Auth Server<br/>port 9091<br/>OIDC Provider<br/>Access Control"]
        end
        subgraph LXC_WGPORTAL["LXD Container: wgportal"]
           WGPortal["<b>WireGuard Portal</b><br/>VPN Management<br/>web: 8080<br/>VPN: 51820<br/>SQLite"]
        end
        subgraph LXC_FORGEJO["LXD Container: forgejo"]
           Forgejo["<b>Forgejo</b><br/>Git Server<br/>port 3000 / 22<br/>SQLite"]
        end
        subgraph LXC_SEMAPHORE["LXD Container: semaphore"]
           Semaphore["<b>Semaphore</b><br/>Ansible CI/CD"]
        end
        subgraph LXC_JUPYTER["LXD Container: jupyter"]
           Jupyter["<b>JupyterLab</b><br/>port 8888"]
        end
        subgraph LXC_TRILIUM["LXD Container: trilium"]
           Trilium["<b>Trilium Notes</b><br/>Knowledge Base<br/>multi-instance"]
        end
        subgraph LXC_COMFYUI["LXD Container: comfyui"]
           ComfyUI["<b>ComfyUI</b><br/>AI Image Gen<br/>ROCM (PyTorch)"]
        end
        subgraph LXC_OPENWEBUI["LXD Container: openwebui"]
           OpenWebUI["<b>Open WebUI</b><br/>Chat Interface<br/>port 8080"]
        end
        subgraph LXC_RAMALAMA["LXD Container: ai"]
           Ramalama["<b>Ramalama</b><br/>AI Model Serving<br/>port 8080<br/>llama3.2:3b"]
        end
        subgraph LXC_MARUCHAN["LXD Container: maruchan"]
           Maru["<b>Maruchan Bot</b><br/>Discord Bot<br/>Podman"]
        end
        subgraph LXC_LUANTI["LXD Container: luanti"]
           Luanti["<b>Luanti</b><br/>Minetest Server<br/>port 30000"]
        end
        subgraph LXC_VELOREN["LXD Container: veloren"]
           Veloren["<b>Veloren</b><br/>Game Server<br/>14004, 14005, 14006/udp"]
        end
        subgraph LXC_STARBOUND["LXD Container: starbound"]
           Starbound["<b>Starbound</b><br/>Game Server<br/>21025 / 21026<br/>SteamCMD"]
        end
        subgraph LXC_MANGBAND["LXD Container: mangband"]
           Mangband["<b>Mangband</b><br/>MUD Game<br/>port 18346"]
        end
    end

    Discord["<b>Discord Bot</b><br/>External"]
    LAN["<b>Local LAN</b>"]
    VPN["<b>WireGuard VPN</b>"]

    Discord <--> Maru
    LAN <--> Traefik
    LAN <--> DNS
    LAN <--> Forgejo
    VPN <--> WGPortal

    Traefik -->|"HTTPS + Authelia"| Authelia
    Traefik -->|"routes / api"| Forgejo
    Traefik -->|"routes / web"| Semaphore
    Traefik -->|"routes"| Jupyter
    Traefik -->|"routes"| Trilium

    DNS -->|"DNS resolution"| LXC_TRAEFIK
    DNS -->|"DNS resolution"| LXC_AUTHELIA
    DNS -->|"DNS resolution"| LXC_FORGEJO
    DNS -->|"DNS resolution"| LXC_SEMAPHORE
    DNS -->|"DNS resolution"| LXC_RAMALAMA
    DNS -->|"DNS resolution"| LXC_OPENWEBUI
    DNS -->|"DNS resolution"| LXC_MARUCHAN
    DNS -->|"DNS resolution"| LXC_LUANTI
    DNS -->|"DNS resolution"| LXC_VELOREN
    DNS -->|"DNS resolution"| LXC_STARBOUND
    DNS -->|"DNS resolution"| LXC_MANGBAND

    OpenWebUI -->|"API calls"| Ramalama
    Maru -->|"AI inference"| Ramalama
    LAN <--> OpenWebUI
    LAN <--> ComfyUI
    LAN <--> Luanti
    LAN <--> Veloren
    LAN <--> Starbound
    LAN <--> Mangband

Un par de meses despues - 2025-11-05

La decisión de usar Ansible facilitó mucho la migración. Actualicé los playbooks para usar Incus en lugar de LXC y todo funcionó sin problemas. Respecto a los roles y contenedores, aparte de un par de problemas menores con los permisos y la forma en que se definían los límites de recursos, la transición fue bastante limpia. Sí, fue un cambio grande y aún hay cosas por migrar, pero al punto que llegué fue suficiente para tener los servicios de vuelta.

En aplicaciones, esta vez involucré a mi pareja para buscar casos de uso. Entre las cosas de las que ella dependía, Notion se veía como un buen target para buscar una alternativa local. Tras probar AppFlowy, Anytype, Obsidian, entre otras, terminamos en Trilium. No es la panacea, pero se puede hostear localmente y sincronizar con su app de escritorio multiplataforma. Ayudo bastante a decidirse el hecho de que están abiertos a aceptar mejoras.

En infraestructura, agregué VPN con WGPortal y autenticación para los servicios con Authelia. Como igual planeaba agregar más usuarios al sistema en el futuro, agregué un mecanismo para fijar las reglas del firewall por contenedor, de manera que no expusieran más de lo necesario ni vieran segmentos de la red a los que no debían acceder.

Dibujando el resto del buho #

De la nada ya llegaremos al segundo aniversario del servidor y siento que ha crecido bastante. A pesar de eso, no han habido grandes cambios estructurales o de infraestructura desde entonces. Muchas de las aplicaciones se utilizan a diario, mientras que otras siguen siendo pruebas de concepto.

Si he enfocado mis esfuerzos, ha sido en mejorar la seguridad y simplificar el aprovisionamiento de cuentas. Como agregué acceso a algunos amigos y familiares, decidí mover el registro de usuarios a una instancia de LDAP (lldap). Al comienzo, como eramos solo dos usuarios, usar el archivo de configuración de Authelia era suficiente, pero eventualmente no dio abasto. El resto ha sido probar distintas aplicaciones para ver qué pegaba.

Anotación: Estado actual
    flowchart LR
    subgraph Fedora["Fedora Host (Incus)"]
        subgraph LXC_DNS["LXD Container: dns"]
           DNS["<b>DNS</b><br/>BIND9<br/>port 53"]
        end
        subgraph LXC_TRAEFIK["LXD Container: traefik"]
           Traefik["<b>Traefik</b><br/>Reverse Proxy<br/>ports 80, 443<br/>Let's Encrypt / CF DNS-Challenge"]
        end
        subgraph LXC_AUTHELIA["LXD Container: authelia"]
           Authelia["<b>Authelia</b><br/>Auth / OIDC<br/>port 9091"]
        end
        subgraph LXC_LLDAP["LXD Container: lldap"]
           LLDAP["<b>LLDAP</b><br/>LDAP Server<br/>PostgreSQL :5432"]
        end
        subgraph LXC_WGPORTAL["LXD Container: wgportal"]
           WGPortal["<b>WireGuard Portal</b><br/>VPN Mgmt<br/>web: 8080, VPN: 51820"]
        end
        subgraph LXC_SEMAPHORE["LXD Container: semaphore"]
           Semaphore["<b>Semaphore</b><br/>Ansible CI/CD"]
        end
        subgraph LXC_MAILPIT["LXD Container: mailpit"]
           Mailpit["<b>Mailpit</b><br/>Mail Testing"]
        end
        subgraph LXC_FORGEJO["LXD Container: forgejo"]
           Forgejo["<b>Forgejo</b><br/>Git Server<br/>port 3000 / 22<br/>SQLite"]
        end
        subgraph LXC_FORGEJO_RUNNER["LXD Container: forgejo_runner"]
           ForgejoRunner["<b>Forgejo Runner</b><br/>CI/CD Runner<br/>Podman backend"]
        end
        subgraph LXC_GIT_PAGES["LXD Container: git_pages"]
           GitPages["<b>Git Pages</b><br/>Static Hosting"]
        end
        subgraph LXC_TRILIUM["LXD Container: trilium"]
           Trilium["<b>Trilium Notes</b><br/>Knowledge Base<br/>multi-instance"]
        end
        subgraph LXC_JELLYFIN["LXD Container: jellyfin"]
           Jellyfin["<b>Jellyfin</b><br/>Media Server"]
        end
        subgraph LXC_ACTUAL["LXD Container: actualbudget"]
           ActualBudget["<b>Actual Budget</b><br/>Budgeting App"]
        end
        subgraph LXC_FILEBROWSER["LXD Container: filebrowser"]
           FileBrowser["<b>File Browser</b><br/>Web File Mgmt<br/>media: /opt/media"]
        end
        subgraph LXC_ROMM["LXD Container: romm"]
           ROMM["<b>ROMM</b><br/>ROM Manager<br/>PostgreSQL :5432<br/>Valkey, Coturn"]
        end
        subgraph LXC_RAMALAMA["LXD Container: ai"]
           Ramalama["<b>Ramalama</b><br/>AI Model Serving<br/>port 8080<br/>llama3.2:3b"]
        end
        subgraph LXC_OPENWEBUI["LXD Container: openwebui"]
           OpenWebUI["<b>Open WebUI</b><br/>Chat Interface<br/>port 8080"]
        end
        subgraph LXC_PIWEB["LXD Container: piweb"]
           PiWeb["<b>Pi-Web</b><br/>Agent / Sessiond"]
        end
        subgraph LXC_MARUCHAN["LXD Container: maruchan"]
           Maru["<b>Maruchan Bot</b><br/>Discord Bot<br/>Podman"]
        end
        subgraph LXC_TUWUNEL["LXD Container: tuwunel"]
           Tuwunel["<b>Tuwunel</b><br/>Local Matrix Server<br/>port 8008<br/>Nginx"]
        end
        subgraph LXC_LIVEKIT["LXD Container: livekit"]
           LiveKit["<b>LiveKit</b><br/>WebRTC Video<br/>Valkey, Nginx"]
        end
        subgraph LXC_CINNY["LXD Container: cinny"]
           Cinny["<b>Cinny</b><br/>Matrix Client<br/>Nginx"]
        end
        subgraph LXC_OWNCast["LXD Container: owncast"]
           Owncast["<b>Owncast</b><br/>Live Streaming<br/>FFmpeg"]
        end
        subgraph LXC_BFCOMPANION["LXD Container: bitfocus_companion"]
           BFCompanion["<b>Bitfocus Companion</b><br/>Broadcasting"]
        end
        subgraph LXC_LUANTI["LXD Container: luanti"]
           Luanti["<b>Luanti</b><br/>Minetest<br/>port 30000"]
        end
        subgraph LXC_MANGBAND["LXD Container: mangband"]
           Mangband["<b>Mangband</b><br/>MUD RPG<br/>port 18346"]
        end
    end

    Discord["<b>Discord</b><br/>External"]
    LAN["<b>Local LAN</b>"]
    VPN["<b>WireGuard</b><br/>VPN"]

    Discord <--> Maru
    VPN <--> WGPortal

    LAN <-->|osc| BFCompanion
    LAN <-->|ssh:repo| Forgejo
    LAN <-->|matrix| Tuwunel
    LAN <-->|matrix:videocalls| LiveKit
    LAN <-->|ldap| LLDAP
    LAN <--> Luanti
    LAN <--> Mangband
    LAN <--> Traefik
    LAN <--> DNS

    DNS -->|"DNS resolution"| LXC_BFCOMPANION
    DNS -->|"DNS resolution"| LXC_FORGEJO
    DNS -->|"DNS resolution"| LXC_TUWUNEL
    DNS -->|"DNS resolution"| LXC_LIVEKIT
    DNS -->|"DNS resolution"| LXC_LLDAP
    DNS -->|"DNS resolution"| LXC_LUANTI
    DNS -->|"DNS resolution"| LXC_MANGBAND
    DNS -->|"DNS resolution"| LXC_TRAEFIK
    DNS -->|"DNS resolution"| LXC_WGPORTAL

    Traefik -->|"HTTPS + Authelia"| Authelia
    Traefik -->|"routes"| PiWeb
    Traefik -->|"routes"| Ramalama
    Traefik -->|"routes"| ActualBudget
    Traefik -->|"routes"| Cinny
    Traefik -->|"routes"| BFCompanion
    Traefik -->|"routes"| Forgejo
    Traefik -->|"routes"| Jellyfin
    Traefik -->|"routes"| LLDAP
    Traefik -->|"routes"| Mailpit
    Traefik -->|"routes"| FileBrowser
    Traefik -->|"routes"| Trilium
    Traefik -->|"routes"| Owncast
    Traefik -->|"routes"| GitPages
    Traefik -->|"routes"| Ramalama
    Traefik -->|"routes"| ROMM
    Traefik -->|"routes"| Semaphore
    Traefik -->|"routes"| WGPortal

    LLDAP -->|"auth"| Authelia
    ForgejoRunner -->|"API"| Forgejo
    GitPages -->|"API"| Forgejo
    Forgejo -->|"Infra Repo"| Semaphore
    OpenWebUI -->|"AI API"| Ramalama
    PiWeb -->|"AI API"| Ramalama
    Maru -->|"AI inference"| Ramalama
    FileBrowser -->|"/opt/media"| Jellyfin

Estado actual del lab - 2026-10-15

Al infinito y más allá! #

Los siguientes pasos serán mover algunos de los servicios que aún están en fase experimental a una máquina secundaria. También planeo seguir buscando mecanismos para manejar respaldos y snapshots; aún no he encontrado algo que me convenza, en especial porque espero encontrar algo que provea una mejor experiencia que rsync y el sistema manual de snapshots de Btrfs. Evaluar otras aplicaciones como immich o freshrss también está en la lista.

Además, seguiré manteniendo los paquetes de las aplicaciones que uso. Creo que muchas podrían ser incorporadas a Fedora, pero no he hecho el estudio exhaustivo necesario para determinar si es viable. Por ahora, los builds los realizo en mi cuenta de COPR, pero si alguien se anima a arreglarlos, estaría feliz de ayudar en el proceso de revisión.

Planeo escribir más entradas en este blog en el futuro para hablar con más detalle sobre las otras aplicaciones que he probado, cómo instalar las en Fedora y, de paso, aprovechar la oportunidad para mejorar la documentación de los roles en el repositorio, que se está quedando corta.

En esta página
↑Return to Top↑

Comentarios

Únete a la conversación