Configurar Jellyfin para Accesso Remoto
Jellyfin es tu santuario multimedia personal, ese rincón del universo digital donde tus películas, series, música y recuerdos fotográficos conviven en perfecta armonía, bajo tu control total. Pero la verdadera magia de Jellyfin se desata cuando puedes llevar ese universo contigo, accesible desde cualquier lugar del mundo, no solo desde el sofá de casa. Montar este acceso remoto puede parecer una odisea técnica, especialmente si la seguridad es tu máxima prioridad, ¡y debería serlo! Esta guía no es un simple mapa; es una bitácora de navegación exhaustiva, pensada para convertirte en un experto. No nos quedaremos en la superficie de la instalación de Jellyfin; nuestro viaje se centrará exclusivamente en construir una autopista robusta y blindada hacia tu servidor desde el exterior, utilizando DuckDNS como nuestro fiel aliado para la gestión de nuestra dirección en la red.
Parte 1: Los Cimientos – Tu IP en Internet y el papel de DuckDNS
Antes de que tus datos puedan viajar libremente por la red para llegar a tus dispositivos remotos, necesitan una dirección fiable y constante. Aquí es donde empezamos a entender la naturaleza, a veces caprichosa, de tu conexión a internet y cómo asegurar que tu servidor Jellyfin siempre tenga un «hogar» reconocible en el vasto ciberespacio, gracias a la magia del DDNS, y en particular, de DuckDNS.
Tu Dirección IP Pública: El identificador de tu Conexión a Internet
Cuando tu hogar se conecta a internet, tu proveedor de servicios (ISP) – ya sea Movistar, Vodafone, Orange, o el que tengas – te asigna una dirección IP pública. Piensa en ella como el número de portal y la calle de tu casa en la inmensa ciudad global que es internet. Es la identificación única que permite que otros dispositivos y servidores en la red te encuentren y se comuniquen contigo. Ahora bien, aquí viene el «pero»: la mayoría de los ISP, especialmente en las conexiones residenciales estándar, asignan estas IPs de forma dinámica.
«Dinámica» significa que esta dirección IP pública puede cambiar sin previo aviso. Quizás cambie cada vez que reinicias tu router, o después de un corte de luz, o simplemente porque tu ISP decide reasignarla periódicamente como parte de su gestión de red. Imagina que la dirección de tu casa cambiara cada pocos días o semanas; sería una pesadilla para el cartero y para cualquiera que intentara visitarte. Para un servidor como Jellyfin, que quieres que sea accesible de forma continua desde fuera de tu red local, una IP pública que cambia constantemente es un problema serio. Si la IP cambia, el enlace que tenías configurado en tus apps de Jellyfin o en tus marcadores dejará de funcionar, y te quedarás sin acceso hasta que descubras cuál es tu nueva IP y reconfigures todo.
La alternativa sería una IP pública estática, una dirección que tu ISP te asigna de forma permanente y que nunca cambia. Esto es ideal para servidores, pero los ISP suelen cobrar una tarifa adicional por este servicio (y a veces solo lo ofrecen a empresas), por lo que no es la opción más común para usuarios domésticos que solo quieren acceder a su contenido multimedia.
DuckDNS al Rescate: Tu Nombre Fijo y Gratuito en un Mundo de IPs Cambiantes
Aquí es donde el DDNS (Sistema de Nombres de Dominio Dinámico) entra en juego como un auténtico superhéroe digital, y nuestra elección predilecta para esta guía es DuckDNS. Este servicio destaca por su absoluta simplicidad, su compromiso con la gratuidad (sin trucos ni periodos de prueba) y su respeto por la privacidad del usuario, ya que no te pide apenas datos personales.
Un servicio DDNS como DuckDNS te permite asociar un nombre de dominio fácil de recordar y que tú eliges (por ejemplo, misuperjellyfin.duckdns.org) a tu dirección IP pública, aunque esta sea dinámica y cambie. La magia ocurre gracias a un pequeño programa o script, conocido como cliente DDNS, que se ejecuta discretamente en tu red local. Este cliente puede estar instalado en el mismo servidor donde tienes Jellyfin, en otro ordenador siempre encendido (como una Raspberry Pi), o incluso, en algunos casos, integrado en el firmware de tu propio router. La tarea de este cliente es sencilla pero crucial: monitoriza constantemente tu dirección IP pública actual. En cuanto detecta que ha cambiado, se comunica de forma segura con los servidores de DuckDNS y les informa de la nueva IP. DuckDNS, entonces, actualiza instantáneamente el registro DNS asociado a tu nombre de dominio para que siempre apunte a tu IP pública más reciente. De esta forma, aunque tu IP numérica cambie, tu dirección misuperjellyfin.duckdns.org seguirá siendo la puerta de entrada constante a tu servidor.
Puesta en Marcha con DuckDNS: Un Proceso Sencillo
Configurar DuckDNS es un proceso refrescantemente directo. El primer paso es visitar la web oficial. Abre tu navegador y dirígete a www.duckdns.org.
A continuación, procederás al inicio de sesión. DuckDNS te ofrece varias formas de iniciar sesión utilizando cuentas que probablemente ya tengas: Google, GitHub, Twitter, Persona o Reddit. Elige la que prefieras. Esto simplifica el registro, ya que no necesitas crear una nueva cuenta de usuario y contraseña desde cero solo para DuckDNS.
Una vez dentro, el siguiente paso es crear tu dominio. La interfaz es minimalista y va al grano. Verás una sección claramente identificada para «domains». En el campo de texto, escribe el subdominio que deseas. Por ejemplo, si escribes miserverpersonal, tu dirección completa será miserverpersonal.duckdns.org. Intenta que sea algo fácil de recordar para ti, pero también único.
Después de escribir el nombre, debes añadir el dominio. Haz clic en el botón «add domain». Si el nombre está disponible, se añadirá a tu lista de dominios activos. Puedes gestionar hasta cinco subdominios diferentes con una única cuenta de DuckDNS, lo cual es más que suficiente para la mayoría de los usuarios domésticos.
Finalmente, obtendrás tu token secreto. Justo debajo de donde añades los dominios, en la sección «your current token», aparecerá una cadena larga de caracteres alfanuméricos. Este es tu token de DuckDNS. Es, esencialmente, la contraseña que autoriza a tu cliente DDNS a realizar actualizaciones de IP para tus dominios. Copia este token y guárdalo en un lugar muy seguro, como un gestor de contraseñas. Lo necesitarás en el siguiente paso para configurar el software cliente. No compartas este token con nadie.
Configurando el Cliente DDNS para Mantener tu IP Actualizada con DuckDNS
Con tu dominio y token de DuckDNS en mano, el siguiente paso es instalar y configurar el software cliente que mantendrá tu IP actualizada. La opción más robusta y flexible suele ser instalarlo directamente en tu servidor Jellyfin o en una máquina de tu red que esté operativa 24/7.
Consideremos primero la Opción 1: ddclient en Linux (Versátil y Probado).
Si tu servidor Jellyfin corre sobre Linux (como Ubuntu Server, Debian, Raspberry Pi OS, etc.), ddclient es una elección excelente. Es un cliente escrito en Perl, muy configurable y compatible con una gran cantidad de servicios DDNS, incluido DuckDNS.
Para la Instalación, en sistemas basados en Debian/Ubuntu, abre una terminal y ejecuta el siguiente comando:
sudo apt update && sudo apt install ddclient libdata-validate-ip-perl
Esto actualizará la lista de paquetes e instalará ddclient y una dependencia necesaria para la validación de IPs.
Luego, realiza la Configuración Detallada de /etc/ddclient.conf para DuckDNS. El archivo de configuración principal de ddclient es /etc/ddclient.conf. Puedes editarlo con un editor de texto como nano. Por ejemplo, usa el comando sudo nano /etc/ddclient.conf. Aquí tienes una configuración de ejemplo bien comentada para DuckDNS:
# /etc/ddclient.conf - Configuración para DuckDNS
# ----------------------------------------------------------------------
# Intervalo de revisión: ¿Cada cuánto comprueba ddclient si la IP ha cambiado?
# 300 segundos = 5 minutos. Un valor razonable para no sobrecargar el servicio.
daemon=300
# Forzar el uso de SSL para las comunicaciones con el servicio DDNS y el servicio de chequeo de IP.
# ¡Muy importante para la seguridad!
ssl=yes
# ¿Cómo obtiene ddclient tu IP pública actual?
# 'use=web' le dice que la obtenga de una página web.
# 'web=https://www.duckdns.org/ip/' especifica la URL de DuckDNS que devuelve tu IP.
# DuckDNS ofrece esta URL específicamente para este propósito.
use=web, web='https://www.duckdns.org/ip/'
# Protocolo específico para DuckDNS.
protocol=duckdns
# Servidor de DuckDNS al que enviar las actualizaciones.
server=www.duckdns.org
# Para DuckDNS, el campo 'login' no se usa de la forma tradicional.
# El token se pasa a través del campo 'password'.
login= # Déjalo en blanco o coméntalo con '#'
# Aquí va tu token de DuckDNS. ¡Trátalo como una contraseña!
password='TU_TOKEN_DE_DUCKDNS_AQUI'
# El nombre de host completo que quieres actualizar.
# Si tienes varios dominios en DuckDNS con el mismo token, puedes listarlos separados por comas.
tu_subdominio.duckdns.org
# otro_subdominio.duckdns.org # Si tuvieras más
Asegúrate de reemplazar TU_TOKEN_DE_DUCKDNS_AQUI con tu token real y tu_subdominio.duckdns.org con tu dominio completo de DuckDNS.
Para la Prueba y Verificación de ddclient, una vez guardada la configuración, es crucial probarla. Puedes ejecutar ddclient en modo manual y depuración para ver exactamente qué está haciendo, usando este comando:
sudo ddclient -daemon=0 -debug -verbose -noquiet
Esto ejecutará ddclient una vez, mostrando mucha información útil. Busca mensajes de «SUCCESS» o similares que indiquen que la IP se ha actualizado (o que no era necesario actualizarla). Si hay errores, te dará pistas sobre qué puede estar fallando (token incorrecto, problema de red, etc.).
En cuanto al Funcionamiento como Servicio, si la prueba fue exitosa, ddclient normalmente se configura para iniciarse automáticamente como un servicio (daemon) que se executes en segundo plano. Puedes verificar su estado con:
sudo systemctl status ddclient
Y ver sus logs más recientes con:
journalctl -u ddclient -n 50 --no-pager
Si necesitas que ddclient relea su configuración después de un cambio, puedes reiniciarlo:
sudo systemctl restart ddclient
Otra alternativa es la Opción 2: Script curl con cron en Linux (Ligero y Efectivo).
Para los amantes de la simplicidad o para sistemas muy ligeros, un script que use curl y que se programe con cron es una solución elegante para DuckDNS.
Primero, la Creación del Script de Actualización. Crea un archivo para tu script, por ejemplo, en /opt/duckdns_update.sh. Puedes usar sudo nano /opt/duckdns_update.sh para editarlo. El contenido del script sería:
#!/bin/bash
# Script para actualizar la IP en DuckDNS usando curl
# ----- CONFIGURACIÓN -----
# Pon aquí tu(s) subdominio(s) de DuckDNS. Si son varios, sepáralos con comas.
# Ejemplo: DOMAINS="miserver,otroserver"
DOMAINS="tu_subdominio_duckdns"
# Pon aquí tu token de DuckDNS.
TOKEN="TU_TOKEN_DE_DUCKDNS_AQUI"
# Fichero para guardar un log simple de la respuesta de DuckDNS (opcional).
LOG_FILE="/var/log/duckdns_update.log" # Asegúrate de que el directorio exista y tengas permisos.
# O usa ~/duckdns.log para el home del usuario que ejecute cron.
# ----- LÓGICA DEL SCRIPT -----
# Construye la URL de actualización.
UPDATE_URL="https://www.duckdns.org/update?domains=${DOMAINS}&token=${TOKEN}&ip="
echo "--- $(date) ---" >> "${LOG_FILE}"
curl -k -sS "${UPDATE_URL}" >> "${LOG_FILE}"
echo "" >> "${LOG_FILE}" # Añade una línea en blanco para separar logs.
No olvides reemplazar tu_subdominio_duckdns y TU_TOKEN_DE_DUCKDNS_AQUI con tus datos.
Luego, necesitas Hacer el Script Ejecutable. Ejecuta:
sudo chmod +x /opt/duckdns_update.sh
Es recomendable Probar el Script Manualmente antes de automatizarlo. Para ello, ejecuta:
/opt/duckdns_update.sh
Luego revisa el contenido de ${LOG_FILE} (ej. cat /var/log/duckdns_update.log). Deberías ver «OK» si todo ha ido bien.
Finalmente, para Programar con cron, edita el crontab del usuario root (o del usuario que vaya a ejecutar el script, ajustando permisos si es necesario). Usa el comando:
sudo crontab -e
Y añade la siguiente línea al final del archivo para que se ejecute, por ejemplo, cada 5 minutos:
*/5 * * * * /opt/duckdns_update.sh >/dev/null 2>&1
El >/dev/null 2>&1 redirige toda la salida para evitar correos de cron.
También existe la Opción 3: Clientes para Windows.
Si tu servidor Jellyfin (o la máquina que actualizará DuckDNS) usa Windows, DuckDNS no proporciona un cliente gráfico oficial. Sin embargo, en su página web (www.duckdns.org/install.jsp) encontrarás una lista de opciones y guías para varios sistemas, incluido Windows. Suelen ser scripts de PowerShell, que puedes programar usando el «Programador de Tareas» de Windows, o clientes de terceros desarrollados por la comunidad. La clave siempre será la misma: configurar tu token y tu(s) dominio(s).
Una cuarta vía es la Opción 4: Clientes DDNS en Contenedores Docker.
Si ya estás usando Docker para Jellyfin o para otros servicios, ejecutar tu cliente DDNS en un contenedor Docker es una solución limpia y aislada.
Para linuxserver/ddclient: Esta imagen empaqueta el ddclient que vimos para Linux. Necesitarás montar un archivo ddclient.conf (configurado para DuckDNS como se mostró antes) dentro del contenedor. Un ejemplo de sección en docker-compose.yml sería:
services:
ddclient:
image: lscr.io/linuxserver/ddclient:latest
container_name: duckdns_updater # O el nombre que prefieras
restart: unless-stopped
environment:
- PUID=1000 # ID de tu usuario host
- PGID=1000 # ID de tu grupo host
- TZ=Europe/Madrid # Tu zona horaria
volumes:
- /ruta/a/tu/config/ddclient:/config # Aquí debe estar tu ddclient.conf
Dentro de /ruta/a/tu/config/ddclient en tu máquina host, tendrías el archivo ddclient.conf con la configuración para DuckDNS.
Para qmcgaw/ddns-updater: Otra imagen muy popular que soporta DuckDNS y se configura principalmente a través de variables de entorno. Un ejemplo de sección en docker-compose.yml para ddns-updater con DuckDNS:
services:
ddns-updater:
image: qmcgaw/ddns-updater:latest
container_name: ddns_updater_duckdns
restart: unless-stopped
environment:
- DOMAIN=tu_subdominio.duckdns.org
- PROVIDER=duckdns
- DUCKDNS_TOKEN=TU_TOKEN_DE_DUCKDNS_AQUI
# Opcional: cada cuánto actualizar (ej. "5m" para 5 minutos)
- PERIOD=5m
# Opcional: nivel de log (info, warn, error, debug)
- LOG_LEVEL=info
volumes:
# Volumen para persistir datos de configuración si es necesario
- ddns_updater_data:/app/data
volumes:
ddns_updater_data:
Reemplaza los valores de DOMAIN y DUCKDNS_TOKEN.
Finalmente, está la Opción 5: DDNS Integrado en el Router (Con Precaución para DuckDNS).
Muchos routers modernos incluyen una funcionalidad de cliente DDNS. Sus ventajas son que está siempre encendido y no consume recursos de tu servidor. Sin embargo, las desventajas, especialmente para DuckDNS, incluyen un soporte limitado de proveedores (DuckDNS es poco común en listas predefinidas), la opción «Custom DDNS» es técnica y no siempre funciona bien, y el firmware del router puede estar desactualizado. Para verificar, accede a la interfaz de tu router y busca secciones como «DDNS» o «Dynamic DNS». Si DuckDNS no está y no hay una opción «Custom» viable, es más fiable usar un cliente en tu servidor.
En resumen, para DuckDNS, la recomendación principal es usar un cliente en tu servidor (ya sea ddclient, un script curl, o un contenedor Docker) por su fiabilidad y control.
Parte 2: Abriendo Paso – Redirección de Puertos
Con tu dominio de DuckDNS (misuperjellyfin.duckdns.org) apuntando firmemente a la dirección IP pública de tu hogar digital, el siguiente paso es actuar como el portero de tu red. Debes indicarle a tu router que, cuando llegue tráfico desde internet destinado a ciertos «apartamentos» (puertos), sepa exactamente a qué «inquilino» interno (la máquina donde correrá tu proxy inverso) debe dirigirlo. Esto se conoce como redirección de puertos o port forwarding.
La Importancia Vital de una Dirección IP Estática Local para tu Servidor Proxy
Dentro de tu red local (LAN), tus dispositivos también tienen direcciones IP. Estas IPs internas (del tipo 192.168.1.X o 10.0.0.X) son asignadas normalmente por el servidor DHCP de tu router. Por ello, es absolutamente crucial asignar una dirección IP estática local a la máquina que ejecutará tu proxy inverso.
Existen dos formas principales de lograr esto.
La primera es la Configuración Estática en el Sistema Operativo del Servidor (Método Manual).
Puedes configurar la IP directamente en el sistema operativo de la máquina servidor.
En Linux: El método varía. Primero, identifica tu configuración actual. Comandos útiles son:
ip addr show
ip route show
cat /etc/resolv.conf
Con Netplan (Ubuntu Server moderno), edita un archivo YAML en /etc/netplan/, por ejemplo, /etc/netplan/01-netcfg.yaml:
network:
version: 2
ethernets:
eth0: # Reemplaza eth0 con el nombre real de tu interfaz de red cableada
dhcp4: no # Deshabilitamos DHCP para esta interfaz
addresses:
- 192.168.1.150/24 # Tu IP estática deseada y la máscara de subred (CIDR)
gateway4: 192.168.1.1 # La IP de tu router (puerta de enlace)
nameservers:
addresses: [8.8.8.8, 1.1.1.1] # Servidores DNS (ej. Google, Cloudflare)
Guarda el archivo y aplica la configuración con:
sudo netplan apply
Con NetworkManager, un ejemplo con nmcli (reemplaza MiConexionCableada y eth0 apropiadamente) es:
sudo nmcli con mod MiConexionCableada ipv4.method manual ipv4.addresses 192.168.1.150/24 ipv4.gateway 192.168.1.1 ipv4.dns "8.8.8.8,1.1.1.1"
sudo nmcli con up MiConexionCableada
En Windows: Para configurar una IP estática en Windows, primero abre «Configuración» (tecla Windows + I) y ve a «Red e Internet». Luego, haz clic en «Ethernet» (o «Wi-Fi») y después en «Cambiar opciones del adaptador». Haz clic derecho en tu adaptador de red activo y selecciona «Propiedades». Selecciona «Protocolo de Internet versión 4 (TCP/IPv4)» y haz clic en «Propiedades». Elige «Usar la siguiente dirección IP» e introduce la IP estática, máscara de subred y puerta de enlace. Finalmente, elige «Usar las siguientes direcciones de servidor DNS» e introduce los servidores DNS. Haz clic en «Aceptar» en todas las ventanas.
La segunda forma es la Reserva DHCP en el Router (Método Recomendado por Simplicidad y Gestión Centralizada).
Le dices a tu router que asigne siempre la misma IP a un dispositivo específico, basándose en su dirección MAC.
Primero, debes Identificar la Dirección MAC.
En Linux, usa el comando:
ip addr show
(busca link/ether seguido de la MAC).
En Windows, usa:
ipconfig /all
(busca «Dirección física»).
Luego, Accede a la Configuración del Router entrando a su interfaz web. Busca la Sección de Reserva DHCP (nombres como «Reserva DHCP», «DHCP Estático», etc.). Para Realizar la Reserva, encuentra tu servidor, introduce su MAC y la IP local que quieres asignarle. Es buena idea elegir una IP fuera del rango dinámico del DHCP o una alta dentro del rango. Guarda los cambios.
Navegando por el Router para el Port Forwarding
Cada fabricante de routers tiene su propia interfaz. Para el Acceso al Router, normalmente se usa 192.168.1.1 o 192.168.0.1. ¡Cambia las credenciales por defecto! Los Nombres Comunes de la Sección de redirección de puertos son «Port Forwarding», «Virtual Servers», «NAT Forwarding», etc. Suele estar en «Configuración Avanzada», «Firewall» o «NAT».
Creando las Reglas de Redirección para tu Proxy Inverso (¡La Clave para SSL!)
Para una configuración segura con SSL mediante un proxy inverso, redirigiremos los puertos estándar para tráfico web: Puerto 80 (HTTP) y Puerto 443 (HTTPS) a la IP estática local de la máquina donde se ejecutará tu proxy inverso.
Necesitarás crear dos reglas separadas en tu router. Para cada regla, configurarás el Nombre de la Regla/Servicio/Aplicación con algo descriptivo (ej. Proxy_HTTP_80, Proxy_HTTPS_443). El Puerto Externo (o Puerto WAN) será 80 para la primera y 443 para la segunda. El Puerto Interno (o Puerto LAN) será 80 para la primera y 443 para la segunda (asumiendo que tu proxy escucha en esos puertos en el host, o que Docker mapea a estos puertos del host). La Dirección IP Interna (o IP del Servidor) será la IP estática local de la máquina del proxy (ej. 192.168.1.150). El Protocolo a seleccionar es TCP.
Ejemplo Visual (Conceptual):
- Regla 1:
Proxy_HTTP | Puerto Ext: 80 | Puerto Int: 80 | IP Int: 192.168.1.150 | Protocolo: TCP - Regla 2:
Proxy_HTTPS | Puerto Ext: 443 | Puerto Int: 443 | IP Int: 192.168.1.150 | Protocolo: TCP
Guarda cada regla.
Comprobación Importante: Algunos ISPs podrían bloquear puertos entrantes comunes. Consulta con tu ISP o usa herramientas online de «port checker» si tienes problemas.
Parte 3: El Escudo – Montando un Proxy Inverso con SSL (Let’s Encrypt)
Con el camino abierto en tu router, ahora necesitamos un guardián: el proxy inverso. Su misión principal será gestionar las conexiones de forma segura, cifrando todo el tráfico hacia y desde tu Jellyfin con SSL/TLS, y obteniendo esos preciados certificados de forma automática gracias a Let’s Encrypt.
Antes de sumergirnos en las herramientas de proxy inverso como Nginx Proxy Manager o Caddy, si planeas usarlas con Docker (lo cual es altamente recomendado por su facilidad de gestión y aislamiento), necesitarás tener Docker y Docker Compose instalados en tu sistema servidor.
Instalación de Docker y Docker Compose (Ejemplo para Linux Ubuntu/Debian)
La instalación de Docker Engine generalmente implica añadir el repositorio oficial de Docker a tu sistema para asegurar que obtienes la última versión.
Primero, actualiza el índice de paquetes e instala paquetes necesarios para permitir a apt usar un repositorio sobre HTTPS:
sudo apt update
sudo apt install apt-transport-https ca-certificates curl software-properties-common
Añade la clave GPG oficial de Docker:
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
Configura el repositorio estable de Docker. Para Ubuntu, el comando sería (ajusta $(lsb_release -cs) si usas una derivada o necesitas una versión específica):
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
Ahora, instala Docker Engine:
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io
Para verificar que Docker se ha instalado correctamente y está corriendo, ejecuta:
sudo systemctl status docker
Y también puedes correr una imagen de prueba:
sudo docker run hello-world
Para gestionar Docker como un usuario no root (evitando sudo para cada comando docker), añade tu usuario al grupo docker. Ten en cuenta las implicaciones de seguridad de esto, ya que otorga privilegios equivalentes a root.
sudo usermod -aG docker ${USER}
Necesitarás cerrar sesión y volver a iniciarla, o ejecutar newgrp docker en tu terminal actual para que el cambio de grupo surta efecto.
Para instalar Docker Compose, que es una herramienta para definir y ejecutar aplicaciones Docker multi-contenedor, la forma recomendada es descargar el binario desde su repositorio de GitHub.
Primero, comprueba la última versión de Docker Compose en su página de lanzamientos de GitHub. Reemplaza VERSION_NUMERO en el siguiente comando con el número de la última versión estable (ej. v2.27.0).
DOCKER_COMPOSE_VERSION="v2.27.0" # Ejemplo, verifica la última versión
sudo curl -L "https://github.com/docker/compose/releases/download/${DOCKER_COMPOSE_VERSION}/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
Aplica permisos de ejecución al binario:
sudo chmod +x /usr/local/bin/docker-compose
Verifica la instalación:
docker-compose --version
Con Docker y Docker Compose listos, puedes proceder a configurar tu proxy inverso.
¿Qué es un Proxy Inverso y Por Qué es Prácticamente Indispensable Hoy en Día?
Un proxy inverso se sitúa delante de tus aplicaciones web. Los usuarios se conectan al proxy, este procesa la petición (incluyendo SSL) y la reenvía a la aplicación interna (Jellyfin).
Sus Beneficios Clave son varios. Permite la Terminación y Gestión Centralizada de SSL/TLS (¡HTTPS Automático!), obteniendo y renovando certificados SSL de Let’s Encrypt automáticamente. Proporciona un Punto Único de Entrada y Seguridad Mejorada, ya que todo el tráfico HTTPS entra por el puerto 443 a una máquina. También ofrece la Ocultación de la Estructura y Puertos Internos. Además, da Flexibilidad para Alojar Múltiples Servicios Web. Finalmente, puede incluir Funcionalidades Adicionales como balanceo de carga o cacheo.
Eligiendo y Configurando tu Herramienta de Proxy Inverso (Foco en Docker)
Nos centraremos en dos opciones populares para Docker.
Opción 1: Nginx Proxy Manager (NPM) – La Potencia de Nginx con una Interfaz Web Amigable
NPM envuelve Nginx en una GUI web intuitiva.
Como Requisitos Previos, necesitas Docker y Docker Compose (cuya instalación acabamos de describir).
Para la Instalación con Docker Compose, crea un directorio para NPM (ej. /opt/npm) y dentro un archivo docker-compose.yml:
version: '3.8'
services:
app:
image: 'jc21/nginx-proxy-manager:latest'
container_name: nginx-proxy-manager
restart: unless-stopped
ports:
- '80:8080' # HTTP host -> HTTP contenedor NPM
- '443:4443' # HTTPS host -> HTTPS contenedor NPM
- '81:8181' # Admin UI host -> Admin UI contenedor NPM
volumes:
- ./data:/data
- ./letsencrypt:/etc/letsencrypt
Para Iniciar Nginx Proxy Manager, en el directorio del docker-compose.yml, ejecuta:
sudo docker-compose up -d
Para el Acceso y Configuración Inicial de NPM, primero abre http://<IP_DEL_SERVIDOR_DOCKER>:81. Las credenciales por defecto son Email: admin@example.com, Password: changeme. Cámbialas inmediatamente por unas fuertes y únicas.
Para Configurar tu Host Proxy para Jellyfin en NPM, dentro de NPM, ve a «Hosts» -> «Proxy Hosts», y haz clic en «Add Proxy Host».
En la Pestaña «Details», introduce tu Domain Names (ej. misuperjellyfin.duckdns.org), selecciona Scheme como http, pon la Forward Hostname / IP de Jellyfin (ej. 192.168.1.XYZ) y el Forward Port (8096). Habilita Cache Assets (opcional), Block Common Exploits (recomendado) y, muy importante, Websockets Support (esencial para Jellyfin).
En la Pestaña «SSL», para SSL Certificate, selecciona «Request a new SSL Certificate». Habilita Force SSL y HTTP/2 Support. Considera HSTS Enabled con cautela. Introduce tu Email Address for Let’s Encrypt y marca «I Agree to the Let’s Encrypt Terms of Service».
Finalmente, haz clic en «Save». Si todo es correcto, obtendrás el SSL.
Opción 2: Caddy v2 – Simplicidad Extrema y HTTPS Automático por Defecto
Caddy es famoso por su «HTTPS automático por defecto» y su simple Caddyfile.
Como Requisitos Previos, necesitas Docker y Docker Compose.
Para la Instalación con Docker Compose, crea un directorio para Caddy (ej. /opt/caddy) y dentro un docker-compose.yml:
version: "3.7"
services:
caddy:
image: caddy:latest
container_name: caddy_reverse_proxy
restart: unless-stopped
ports:
- "80:80"
- "443:443"
- "443:443/udp" # Para HTTP/3
volumes:
- ./Caddyfile:/etc/caddy/Caddyfile
- caddy_data:/data
- caddy_config:/config
volumes:
caddy_data:
caddy_config:
Para la Creación del Caddyfile, en el mismo directorio, crea un archivo Caddyfile:
# Caddyfile para misuperjellyfin.duckdns.org
misuperjellyfin.duckdns.org {
encode zstd gzip
reverse_proxy http://192.168.1.XYZ:8096 # IP:Puerto de tu Jellyfin
header {
Strict-Transport-Security "max-age=31536000; includeSubDomains; preload"
X-Frame-Options "SAMEORIGIN"
X-XSS-Protection "1; mode=block"
X-Content-Type-Options "nosniff"
Referrer-Policy "strict-origin-when-cross-origin"
}
}
Reemplaza misuperjellyfin.duckdns.org y 192.168.1.XYZ:8096 con tus datos.
Para Iniciar Caddy, desde el directorio del Caddyfile, ejecuta:
sudo docker-compose up -d
Caddy obtendrá y renovará SSL automáticamente.
Para la Verificación del SSL y del Acceso, accede a https://misuperjellyfin.duckdns.org. Deberías ver el candado de seguridad. Prueba con SSL Labs SSL Test (www.ssllabs.com/ssltest/). Desde línea de comandos, puedes usar:
openssl s_client -connect misuperjellyfin.duckdns.org:443 -servername misuperjellyfin.duckdns.org
Parte 4: Ajustes Finos en Jellyfin (Pequeños Detalles Importantes)
Con el proxy inverso gestionando el acceso externo y el SSL, la configuración dentro de Jellyfin es mínima.
Primero, Accede a tu Panel de Control de Jellyfin usando su IP local y puerto (ej. http://192.168.1.XYZ:8096).
Luego, Navega a Dashboard -> Administración -> Redes.
La opción URL base pública (opcional) normalmente debe dejarse en blanco para configuraciones con subdominio.
La opción Servidores proxy de confianza es importante para que Jellyfin vea la IP real del cliente. NPM y Caddy suelen enviar las cabeceras X-Forwarded-For correctas. Añade aquí la IP/subred de tu proxy desde la perspectiva de Jellyfin (ej. la IP de la puerta de enlace de la red Docker como 172.17.0.1 o la subred 172.17.0.0/16).
Asegúrate de que Permitir conexiones remotas a este servidor Jellyfin esté marcada.
No necesitas habilitar el modo HTTPS incorporado de Jellyfin.
Parte 5: ¡A Disfrutar! Acceso Remoto y Configuración de Aplicaciones Cliente
Es el momento de probar.
Desde un Navegador Web (Fuera de tu Red Local), escribe https://misuperjellyfin.duckdns.org. Deberías ver el login de Jellyfin con el candado de seguridad.
En Aplicaciones Cliente de Jellyfin, en la configuración del servidor de la app, introduce: https://misuperjellyfin.duckdns.org (¡con https://!). Luego introduce tu usuario y contraseña de Jellyfin.
Una Nota sobre Rendimiento y Transcodificación: La velocidad de subida de tu internet y la potencia de tu servidor para transcodificar son clave.
Parte 6: Fortificando tu Castillo Digital – Prácticas de Seguridad Avanzadas y Continuas
La seguridad es un proceso continuo.
Es fundamental usar Contraseñas Fuertes y Únicas y 2FA para Jellyfin, router, DuckDNS y NPM. Usa un gestor de contraseñas y habilita 2FA donde sea posible.
Las Actualizaciones Incesantes son cruciales.
Para el Sistema Operativo del Servidor en Linux (Debian/Ubuntu), ejecuta:
sudo apt update && sudo apt full-upgrade -y
Actualiza Jellyfin regularmente.
Para el Software del Proxy Inverso (Docker), actualiza con los comandos:
sudo docker-compose pull
sudo docker-compose up -d
(Opcional) Para limpiar imágenes antiguas:
sudo docker image prune -a
Considera Watchtower para automatizar actualizaciones de Docker.
Revisa el Firmware del Router en la web del fabricante.
Configura un Firewall (Cortafuegos) de manera rigurosa y específica.
En el Servidor del Proxy Inverso/Jellyfin (Ej. UFW en Linux), UFW (Uncomplicated Firewall) es una interfaz amigable para iptables.
Primero, Verifica el Estado Inicial con el comando:
sudo ufw status
Luego, Establece Políticas por Defecto (Muy Importante). Bloquea todas las conexiones entrantes por defecto y permite las salientes con los siguientes comandos:
sudo ufw default deny incoming
sudo ufw default allow outgoing
Ahora, Permite Puertos Esenciales. Para el acceso SSH (si lo usas, por defecto es el puerto 22; si usas otro, especifícalo):
sudo ufw allow ssh
# o sudo ufw allow TU_PUERTO_SSH/tcp
Para HTTP (necesario para el desafío de Let’s Encrypt y la redirección a HTTPS por el proxy):
sudo ufw allow 80/tcp
Para HTTPS (el tráfico principal de Jellyfin a través del proxy):
sudo ufw allow 443/tcp
Recuerda que no necesitas abrir el puerto 8096 de Jellyfin ni el 81 de NPM en UFW si el proxy está en la misma máquina y se comunican localmente, o si están en la misma red Docker, ya que UFW opera a nivel de host.
Una vez definidas las reglas, Habilita UFW con el comando:
sudo ufw enable
El sistema te advertirá que esto podría interrumpir conexiones SSH existentes si no has permitido SSH correctamente. Confirma con ‘y’ si estás seguro.
Finalmente, Verifica las Reglas y el Estado:
sudo ufw status verbose
O para ver las reglas numeradas:
sudo ufw status numbered
En Windows (Firewall de Windows Defender), configúralo para permitir conexiones entrantes solo en los puertos 80 y 443 (TCP) para el proceso del proxy.
En el Firewall del Router, asegúrate de que no haya reglas innecesarias.
Instala Fail2Ban: El Centinela Automático contra Intrusos y Bots. Fail2Ban escanea logs y bloquea IPs sospechosas.
Para la Instalación (Debian/Ubuntu):
sudo apt install fail2ban
Para la Configuración, copia /etc/fail2ban/jail.conf a /etc/fail2ban/jail.local y edita jail.local. Para copiar el archivo, usa:
sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local
# Luego edita sudo nano /etc/fail2ban/jail.local
Configura «jails» para Nginx (logs de NPM) o Caddy, y para SSH.
Reinicia y verifica Fail2Ban:
sudo systemctl restart fail2ban
sudo fail2ban-client status
sudo fail2ban-client status NOMBRE_DEL_JAIL
Implementa Seguridad Adicional del Router: Cambia credenciales de admin, desactiva UPnP y WPS, usa Wi-Fi seguro (WPA3/WPA2), considera red de invitados.
Considera una VPN como Alternativa o Complemento de Máxima Seguridad. Configura un servidor VPN (WireGuard, OpenVPN) en tu red. Accede primero a la VPN, luego a Jellyfin por IP local. Proyectos como PiVPN facilitan esto.
Realiza una Monitorización Constante de Logs.
Revisa logs del proxy. Para NPM, el comando es:
sudo docker logs nginx-proxy-manager
Para Caddy, usa:
sudo docker logs caddy_reverse_proxy
Revisa también los logs de Jellyfin (desde su Dashboard), Fail2Ban (/var/log/fail2ban.log), y del sistema (journalctl, /var/log/syslog, /var/log/auth.log).
Minimiza la Superficie de Ataque no ejecutando servicios innecesarios.
Parte 7: Arreglando Errores Comunes (Troubleshooting)
Esta es una guía para diagnosticar problemas.
Si el Problema es: No Puedo Acceder a Jellyfin Desde Fuera de mi Red Local, entonces:
Primero, Verifica IP Pública y Resolución de DuckDNS (Desde Red Externa). Compara tu IP pública actual (vista desde www.whatismyip.com en tu red) con la que resuelve tu dominio DuckDNS desde fuera. Usa los siguientes comandos:
En Windows:
nslookup misuperjellyfin.duckdns.org
En Linux/macOS:
dig misuperjellyfin.duckdns.org A +short
# o
ping misuperjellyfin.duckdns.org
Si no coinciden, revisa tu cliente DDNS.
Segundo, Verifica Redirección de Puertos en Router (Con Herramientas Externas). Usa un «Open Port Checker» online para los puertos 80 y 443. Si están cerrados, revisa la configuración del router, firewall del servidor, o si el ISP bloquea. Verifica que el proxy corre y escucha. Para esto, puedes usar:
sudo docker ps
sudo ss -tulnp | grep -E ':80|:443' # En Linux host
Tercero, Verifica Firewall del Servidor Host.
Cuarto, Logs del Proxy Inverso.
Quinto, considera un Problema de «Hairpin NAT» / «NAT Loopback». Si no funciona desde dentro de tu red usando el dominio público, accede por IP local o configura DNS local.
Si el Problema es: Errores de Certificado SSL, entonces:
Primero, revisa los Logs del Proxy Inverso.
Segundo, asegúrate de que el Puerto 80 esté Abierto y Redirigido Correctamente al Proxy.
Tercero, ten en cuenta la Propagación de DNS para DuckDNS.
Cuarto, cuidado con los Límites de Tasa de Let’s Encrypt. Usa el entorno de staging para pruebas si es necesario.
Quinto, verifica que la Fecha y Hora del Servidor sean Correctas.
Sexto, revisa si hay Problemas con Token de DuckDNS o Dominio Mal Escrito.
Si el Problema es: Jellyfin Funciona, Pero el Streaming Remoto es Lento, se Corta (Buffering), o Calidad Mala, entonces:
Verifica la Velocidad de Subida de tu Internet.
Analiza la Transcodificación en Jellyfin: Carga de CPU, configuración de transcodificación, logs de ffmpeg.
Revisa la Configuración de Calidad en App Cliente.
Asegura el Soporte de WebSockets en el Proxy.
Considera los Timeouts del Proxy Inverso, podrías necesitar aumentarlos en configuraciones avanzadas del proxy.
Evalúa los Recursos del Servidor (CPU, RAM, Disco, Red).
Descarta Interferencias en Red Local o Problemas de Wi-Fi del Servidor.
Conclusión: Tu Universo Multimedia, Liberado, Seguro y Bajo Tu Control Total
¡Felicidades! Has navegado a través de esta guía ultra detallada, no solo has configurado el acceso remoto a tu Jellyfin, sino que has adquirido un conocimiento profundo de cada pieza del rompecabezas: desde cómo funciona tu IP y el DDNS con DuckDNS, hasta los intríngulis de la redirección de puertos, la magia de los proxies inversos con SSL automático, y las capas de seguridad que convierten tu servidor doméstico en una fortaleza digital.
Este no es solo un logro técnico; es la llave a una nueva forma de disfrutar de tu contenido. La libertad de llevar contigo tu completa colección multimedia, accesible desde cualquier rincón del planeta con una conexión a internet, y la tranquilidad de saber que tus datos viajan cifrados y tu sistema está robustamente protegido, es una recompensa que bien vale el esfuerzo y el aprendizaje. Ya no estás atado a las paredes de tu hogar; tu mundo de entretenimiento te acompaña dondequiera que vayas, siempre disponible, siempre seguro, siempre tuyo.
Ahora, sumérgete en tu Jellyfin, estés donde estés, ¡y disfruta de la experiencia definitiva de un servidor multimedia personal sin fronteras!
Publicaciones relacionadas
Instalar Deemix en Mac con Docker
Instalación y Configuración de Pi-hole: Tu Red Libre de Publicidad
