Cómo crear un servidor de Jellyfin con Docker en Ubuntu

Un servidor de Jellyfin personal es una solución práctica si quieres almacenar y gestionar películas, series, música o fotos de forma ce­n­tra­li­za­da. En lugar de depender de un servicio de streaming externo, mantienes el control total sobre tus archivos, las cuentas de usuario y el acceso desde todos tus di­s­po­si­ti­vos.

¿Qué es Jellyfin?

Jellyfin es un servidor mu­l­ti­me­dia de código abierto que te permite organizar y gestionar tu propia colección de co­n­te­ni­dos y re­pro­du­ci­r­los en distintos di­s­po­si­ti­vos a través del navegador o de una apli­ca­ción. Es co­m­pa­ti­ble con co­n­te­ni­dos como películas, series, música y fotos, e incluye funciones como gestión de usuarios, metadatos, carátulas, se­gui­mie­n­to del progreso de re­pro­du­c­ción y streaming en red.

Como Jellyfin se ejecuta en local, funciona de forma in­de­pe­n­die­n­te de pro­vee­do­res externos. Solo necesitas conexión a Internet para tareas como la descarga de metadatos o el acceso desde fuera de tu red. Para el uso dentro de la red doméstica, Jellyfin utiliza por defecto HTTP en el puerto 8096. De forma opcional, también puedes usar HTTPS. Para el acceso externo, la do­cu­me­n­ta­ción oficial re­co­mie­n­da co­n­fi­gu­rar un proxy inverso y utilizar ce­r­ti­fi­ca­dos de confianza.

¿Qué re­qui­si­tos de servidor son re­co­me­n­da­bles?

Antes de instalar Jellyfin, conviene elegir el tipo de servidor adecuado. Para un servidor de Jellyfin no solo importa cuántos archivos quieres almacenar, sino sobre todo si tus di­s­po­si­ti­vos pueden re­pro­du­cir los co­n­te­ni­dos di­re­c­ta­me­n­te o si el servidor tiene que co­n­ve­r­ti­r­los durante la re­pro­du­c­ción. Este proceso se conoce como tra­n­s­co­di­fi­ca­ción y requiere muchos recursos. Es­pe­cia­l­me­n­te el contenido en 4K, el proceso de co­n­ve­r­sión de HDR a SDR (tone mapping) y varios streams si­mu­l­tá­neos pueden suponer una carga elevada para la CPU o la GPU.

La do­cu­me­n­ta­ción de Jellyfin re­co­mie­n­da, para co­n­fi­gu­ra­cio­nes de tamaño medio, al menos 8 GB de RAM como re­fe­re­n­cia general. En un servidor Linux sin entorno gráfico, 4 GB pueden ser su­fi­cie­n­tes. Además, para la ace­le­ra­ción por hardware en sistemas que no sean de Apple, Jellyfin re­co­mie­n­da usar gráficos Intel, ya que suelen ofrecer una co­n­fi­gu­ra­ción más sencilla y una buena calidad de co­di­fi­ca­ción en la práctica.

A co­n­ti­nua­ción te mostramos, a partir de distintos es­ce­na­rios, qué tipo de servidor de Jellyfin se adapta mejor a tu caso de uso.

Pa­r­ti­cu­la­res y familias

Si utilizas Jellyfin pri­n­ci­pa­l­me­n­te tú solo o con dos o tres personas y tus archivos ya están en formatos de vídeo ha­bi­tua­les como MP4 con H.264, en muchos casos basta con un buen servidor virtual (VPS). En este escenario, el servidor suele limitarse a entregar los archivos, sin necesidad de re­co­di­fi­car­los en cada re­pro­du­c­ción. Para ello, un VPS con Linux es un buen punto de partida, con al menos 4 vCores, 4 GB de RAM y unos 120 GB de al­ma­ce­na­mie­n­to NVMe.

Si necesitas más margen para metadatos, bi­blio­te­cas más grandes o tra­n­s­co­di­fi­ca­cio­nes puntuales, una co­n­fi­gu­ra­ción con 6 vCores, 8 GB de RAM y 240 GB de NVMe ofrece mayor comodidad.

La principal ventaja de un VPS es su relación calidad-precio. Obtienes su­fi­cie­n­te re­n­di­mie­n­to para un servidor de Jellyfin personal sin necesidad de invertir desde el principio en hardware dedicado. Esta opción resulta es­pe­cia­l­me­n­te adecuada si tus di­s­po­si­ti­vos re­pro­du­cen formatos modernos de forma nativa y la tra­n­s­co­di­fi­ca­ción solo se utiliza de forma ocasional.

Usuarios avanzados

Si necesitas más margen porque tu bi­blio­te­ca crece rá­pi­da­me­n­te, quieres crear varias cuentas de usuario o prefieres ajustar los recursos del servidor con mayor fle­xi­bi­li­dad, tiene sentido recurrir a un servidor en la nube o a los llamados Cloud Cubes. Puedes empezar con co­n­fi­gu­ra­cio­nes a partir de 4 vCPU, 8 GB de RAM y 240 GB de al­ma­ce­na­mie­n­to, lo que te ofrece más capacidad para escaneos en paralelo, gestión de metadatos, bi­blio­te­cas más grandes y tra­n­s­co­di­fi­ca­cio­nes puntuales.

La principal ventaja de esta opción es la fle­xi­bi­li­dad. Los se­r­vi­do­res en la nube se adaptan fá­ci­l­me­n­te a cambios en los re­qui­si­tos. Esto resulta es­pe­cia­l­me­n­te útil si empiezas con una co­n­fi­gu­ra­ción pequeña y más adelante quieres añadir nuevas bi­blio­te­cas, más usuarios o servicios adi­cio­na­les como un proxy inverso, mo­ni­to­ri­za­ción o copias de seguridad. Para usuarios avanzados, equipos pequeños o entornos de homelab, suele ser la opción in­te­r­me­dia más equi­li­bra­da.

Usuarios exigentes y contenido en 4K

Si trabajas con grandes bi­blio­te­cas en 4K, necesitas adaptar contenido HDR a di­s­po­si­ti­vos más antiguos o realizas tra­n­s­co­di­fi­ca­ción si­mu­l­tá­nea para varios usuarios, un VPS pequeño puede quedarse corto rá­pi­da­me­n­te. Jellyfin advierte de forma explícita que el tone mapping de HDR a SDR por software puede exigir mucho a la CPU.

Para estos es­ce­na­rios, un servidor dedicado o un servidor bare metal es la mejor opción, ya que utilizas hardware exclusivo y no compartes la potencia de cálculo, la RAM ni el al­ma­ce­na­mie­n­to con otras cargas de trabajo.

En este caso, conviene contar al menos con 8 núcleos de CPU, entre 16 y 32 GB de RAM y al­ma­ce­na­mie­n­to SSD o NVMe rápido. Además, lo ideal es disponer de una GPU Intel o NVIDIA adecuada para la tra­n­s­co­di­fi­ca­ción por hardware.

Re­co­me­n­da­ción de sistema operativo: ¿Debian o Ubuntu?

Ambas di­s­tri­bu­cio­nes de servidor Linux son adecuadas para ejecutar Jellyfin, pero Ubuntu Server 24.04 LTS suele ser la opción más práctica si estás empezando. Docker ofrece do­cu­me­n­ta­ción oficial para Ubuntu y muchas guías se basan di­re­c­ta­me­n­te en esta di­s­tri­bu­ción. Debian también es muy estable, pero con Ubuntu evitarás algunos problemas iniciales.

Paso a paso: instalar Jellyfin con Docker en Ubuntu Server

En el siguiente ejemplo te mostramos cómo instalar Jellyfin en Ubuntu Server 24.04 LTS con Docker Engine y el plugin Docker Compose. Esta opción resulta es­pe­cia­l­me­n­te adecuada para pri­n­ci­pia­n­tes, ya que Docker encapsula la apli­ca­ción y facilita las ac­tua­li­za­cio­nes po­s­te­rio­res.

Paso 1: ac­tua­li­zar el servidor Ubuntu

Conéctate a tu servidor mediante SSH y, en primer lugar, actualiza las listas de paquetes y el sistema:

sudo apt update
sudo apt upgrade -y

A co­n­ti­nua­ción, reinicia el servidor si es necesario (después tendrás que volver a iniciar sesión):

sudo reboot

Este paso es im­po­r­ta­n­te para comenzar con un sistema ac­tua­li­za­do, con los últimos parches de seguridad y una base estable. Es­pe­cia­l­me­n­te en un servidor Ubuntu recién de­s­ple­ga­do, es una buena práctica realizar esta ac­tua­li­za­ción inicial.

Paso 2: instalar Docker en Ubuntu 24.04

En el siguiente paso debes instalar Docker en Ubuntu 24.04. Para ello, se re­co­mie­n­da co­n­fi­gu­rar el re­po­si­to­rio oficial de APT. Primero elimina paquetes antiguos o po­te­n­cia­l­me­n­te co­n­fli­c­ti­vos:

sudo apt remove docker.io docker-compose docker-compose-v2 docker-doc podman-docker containerd runc -y

A co­n­ti­nua­ción, configura el re­po­si­to­rio oficial de Docker:

sudo apt update
sudo apt install ca-certificates curl -y
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc
sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Signed-By: /etc/apt/keyrings/docker.asc
EOF
sudo apt update

Después, instala Docker Engine, Buildx y el plugin Compose con el siguiente comando:

sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

A co­n­ti­nua­ción, comprueba si Docker está en ejecución:

sudo systemctl status docker

El estado debería mostrarse como active (running):

Close

Por último, puedes verificar la in­s­ta­la­ción con el co­n­te­ne­dor de prueba oficial:

sudo docker run hello-world

La salida debería tener el siguiente aspecto:

Close

Paso 3: usar Docker sin sudo

De forma pre­de­te­r­mi­na­da, los comandos de Docker deben eje­cu­tar­se con sudo. Si lo prefieres, puedes añadir tu usuario al grupo docker para evitarlo:

sudo usermod -aG docker $USER
newgrp docker

Paso 4: crear la es­tru­c­tu­ra de di­re­c­to­rios para Jellyfin

Una vez te­r­mi­na­dos los pre­pa­ra­ti­vos, puedes crear la es­tru­c­tu­ra de di­re­c­to­rios para tu servidor de Jellyfin. Esto te permitirá separar co­rre­c­ta­me­n­te la co­n­fi­gu­ra­ción, la caché y los co­n­te­ni­dos mu­l­ti­me­dia. Por ejemplo, puedes utilizar la siguiente es­tru­c­tu­ra (aunque puedes adaptarla según tus ne­ce­si­da­des):

mkdir -p ~/jellyfin/config
mkdir -p ~/jellyfin/cache
mkdir -p ~/media/peliculas
mkdir -p ~/media/series
mkdir -p ~/media/musica
mkdir -p ~/media/fotos

La carpeta config al­ma­ce­na­rá la co­n­fi­gu­ra­ción del servidor, los usuarios y la base de datos. La carpeta cache se utiliza para datos te­m­po­ra­les. Los archivos mu­l­ti­me­dia se organizan en carpetas de bi­blio­te­ca in­de­pe­n­die­n­tes.

Paso 5: de­te­r­mi­nar la UID y la GID del usuario

Jellyfin puede eje­cu­tar­se en el co­n­te­ne­dor uti­li­za­n­do el ID de usuario y el ID de grupo de tu usuario en Linux. Esto facilita la gestión de los permisos de archivos. Para obtener estos valores, ejecuta el siguiente comando:

id

Anota los valores de UID y GID que se muestran, ya que los ne­ce­si­ta­rás más adelante en el archivo Compose.

Paso 6: crear el archivo Docker Compose para Jellyfin

Cambia al di­re­c­to­rio de trabajo y crea un archivo llamado docker-compose.yml. En este ejemplo usamos el editor de texto nano, aunque puedes utilizar cualquier otro editor:

mkdir -p ~/jellyfin
cd ~/jellyfin
nano docker-compose.yml

Introduce el siguiente contenido en el archivo:

services:
    jellyfin:
        image: jellyfin/jellyfin
        container_name: jellyfin
        user: "1000:1000"
        ports:
            - "8096:8096/tcp"
            - "7359:7359/udp"
        volumes:
            - ./config:/config
            - ./cache:/cache
            - type: bind
                source: /home/TU_USUARIO/media/peliculas
                target: /media/peliculas
                read_only: true
            - type: bind
                source: /home/TU_USUARIO/media/series
                target: /media/series
                read_only: true
            - type: bind
                source: /home/TU_USUARIO/media/musica
                target: /media/musica
                read_only: true
            - type: bind
                source: /home/TU_USUARIO/media/fotos
                target: /media/fotos
                read_only: true
        environment:
            - JELLYFIN_PublishedServerUrl=http://TU_IP_SERVIDOR:8096
        restart: unless-stopped

A co­n­ti­nua­ción, sustituye los si­guie­n­tes valores en el archivo:

• el valor 1000:1000 por tu UID:GID real, que has obtenido en el paso anterior
• TU_USUARIO por tu nombre de usuario de Linux
• TU_IP_SERVIDOR por la dirección IP de tu servidor

Paso 7: iniciar el co­n­te­ne­dor de Jellyfin

Ahora puedes iniciar el co­n­te­ne­dor en segundo plano con Docker Compose:

sudo docker compose up -d

A co­n­ti­nua­ción, comprueba si el co­n­te­ne­dor está en ejecución:

sudo docker compose ps

Close

Paso 8: abrir Jellyfin en el navegador

Abre en tu navegador la dirección de tu servidor con el puerto pre­de­te­r­mi­na­do de Jellyfin:

http://SERVER-IP:8096

Se iniciará au­to­má­ti­ca­me­n­te el asistente de co­n­fi­gu­ra­ción en el navegador.

Paso 9: co­n­fi­gu­ra­ción inicial en el asistente de Jellyfin

En el navegador, Jellyfin te guía a través de la co­n­fi­gu­ra­ción básica. Primero, se­le­c­cio­na el idioma y crea una cuenta de ad­mi­ni­s­tra­dor con una co­n­tra­se­ña segura. A co­n­ti­nua­ción, configura tus bi­blio­te­cas: elige, por ejemplo, “Películas”, “Series”, “Música” o “Fotos” e indica en cada caso los di­re­c­to­rios montados en el co­n­te­ne­dor, es decir, en este ejemplo /media/peliculas o /media/series. Después, Jellyfin de­s­ca­r­ga­rá metadatos, carátulas y otra in­fo­r­ma­ción adicional, siempre que el servidor tenga acceso a Internet.

Close

Paso 10: organizar co­rre­c­ta­me­n­te tus archivos mu­l­ti­me­dia

Para que Jellyfin reconozca co­rre­c­ta­me­n­te tus archivos, es im­po­r­ta­n­te mantener una es­tru­c­tu­ra clara y coherente. Para las películas, conviene utilizar una carpeta in­de­pe­n­die­n­te por título; para las series, organizar el contenido por te­m­po­ra­das. En el caso de la música, es es­pe­cia­l­me­n­te im­po­r­ta­n­te contar con etiquetas (tags) bien definidas.

Cuanto más ordenada sea la es­tru­c­tu­ra de carpetas, menos trabajo manual ne­ce­si­ta­rás después para ajustar metadatos y aso­cia­cio­nes. Aunque no es un requisito técnico obli­ga­to­rio, en la práctica marca una gran di­fe­re­n­cia.

Ten en cuenta también los si­guie­n­tes consejos de seguridad para tu servidor de Jellyfin:

• Usa HTTPS: si haces accesible Jellyfin desde Internet, es im­pre­s­ci­n­di­ble proteger el acceso mediante HTTPS. La forma más sencilla es utilizar un proxy inverso con un ce­r­ti­fi­ca­do TLS gratuito.
• Evita el acceso directo desde Internet: no abras di­re­c­ta­me­n­te el puerto de Jellyfin en el router. En su lugar, utiliza un proxy inverso o una VPN.
• Utiliza co­n­tra­se­ñas seguras: configura una co­n­tra­se­ña segura para la cuenta de ad­mi­ni­s­tra­dor y crea cuentas in­de­pe­n­die­n­tes para otros usuarios.
• Actualiza el sistema con re­gu­la­ri­dad: mantén Ubuntu, Docker y la imagen de Jellyfin ac­tua­li­za­dos mediante re­vi­sio­nes pe­rió­di­cas.
• Monta los di­re­c­to­rios de medios en modo de solo lectura: si utilizas Docker, es re­co­me­n­da­ble montar las carpetas de medios en modo solo lectura (read_only) para evitar mo­di­fi­ca­cio­nes ac­ci­de­n­ta­les en tus archivos.

Conectar Jellyfin con un dominio

Para acceder a tu servidor de Jellyfin a través de un dominio como jellyfin.tudominio.es, necesitas lo siguiente:

• Un dominio o su­b­do­mi­nio
• Un registro DNS que apunte a la IP pública de tu servidor
• Un proxy inverso con HTTPS (por ejemplo, Caddy, que es una opción re­co­me­n­da­da por Jellyfin)

Paso 1: crear el registro DNS para el su­b­do­mi­nio

Crea en tu proveedor de dominio un registro A, por ejemplo:

jellyfin.tudominio.es -> TU_IP_PUBLICA

Si utilizas IPv6, crea también un registro AAAA. Para que el HTTPS au­to­má­ti­co con Caddy funcione co­rre­c­ta­me­n­te, el registro DNS debe apuntar ya a tu servidor.

Paso 2: instalar Caddy

Jellyfin re­co­mie­n­da utilizar Caddy por su co­n­fi­gu­ra­ción sencilla de HTTPS. En Ubuntu, puedes in­s­ta­lar­lo a través del re­po­si­to­rio oficial con los si­guie­n­tes comandos:

sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https curl
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list
sudo chmod o+r /usr/share/keyrings/caddy-stable-archive-keyring.gpg
sudo chmod o+r /etc/apt/sources.list.d/caddy-stable.list
sudo apt update
sudo apt install caddy -y

Tras la in­s­ta­la­ción, Caddy se inicia au­to­má­ti­ca­me­n­te como servicio del sistema.

Paso 3: co­n­fi­gu­rar Caddy

En el siguiente paso, edita la co­n­fi­gu­ra­ción de Caddy. En este ejemplo uti­li­za­mos nano, aunque puedes emplear cualquier editor de texto:

sudo nano /etc/caddy/Caddyfile

Introduce la siguiente co­n­fi­gu­ra­ción:

jellyfin.tudominio.es {
reverse_proxy 127.0.0.1:8096
}

Guarda el archivo y comprueba que la co­n­fi­gu­ra­ción es válida:

sudo caddy validate --config /etc/caddy/Caddyfile

Si no se muestran errores, recarga el servicio:

sudo systemctl reload caddy

Paso 4: limitar Jellyfin al acceso local

Una vez que el dominio funcione co­rre­c­ta­me­n­te, es re­co­me­n­da­ble ajustar el archivo docker-compose.yml para que Jellyfin no esté expuesto di­re­c­ta­me­n­te en el puerto 8096.

Para ello, abre de nuevo ~/jellyfin/docker-compose.yml y modifica la co­n­fi­gu­ra­ción de puertos:

ports:
    - "127.0.0.1:8096:8096/tcp"
    - "7359:7359/udp"

A co­n­ti­nua­ción, reinicia el co­n­te­ne­dor:

sudo docker compose up -d

De este modo, la interfaz web solo será accesible desde el propio servidor, mientras que Caddy ge­s­tio­na­rá el acceso externo de forma segura.

Por último, añade el proxy como Known Proxy en la co­n­fi­gu­ra­ción de red de Jellyfin. Así, Jellyfin podrá procesar co­rre­c­ta­me­n­te las cabeceras HTTP enviadas por el proxy. En­co­n­tra­rás este ajuste en la interfaz web en “Dashboard” → “Ne­t­wo­r­ki­ng” → “Known Proxies”.