---
title: "Cómo instalar Jellyfin en Ubuntu 24.04 con Nginx y HTTPS"
description: "Instala Jellyfin desde su repositorio oficial en Ubuntu 24.04, organiza tus bibliotecas de películas y series y publícalo con Nginx y HTTPS de Let's Encrypt."
category: "Servidores de Medios y Streaming"
language: es
source: https://cubepath.com/es/docs/servidores-de-medios-y-streaming/instalacion-de-jellyfin-servidor-de-medios
updated: 2026-09-25
---

# Cómo instalar Jellyfin en Ubuntu 24.04 con Nginx y HTTPS

Jellyfin es un servidor de medios libre y gratuito: indexa tus películas, series y música, descarga carátulas y metadatos, y los reproduce en el navegador, en móviles y en televisores, transcodificando al vuelo cuando el cliente lo necesita. En este tutorial instalarás Jellyfin en Ubuntu 24.04 desde su repositorio oficial, prepararás un directorio de medios con los permisos correctos, completarás el asistente inicial por un túnel SSH y lo publicarás con Nginx y HTTPS.

## Requisitos previos

- Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath. Con 2 GB de RAM basta para reproducir sin transcodificar; si vas a transcodificar vídeo por CPU, cuenta con 4 vCPU o más.
- Un usuario no root con privilegios `sudo`.
- Un subdominio (en esta guía, `jellyfin.your_domain`) con un registro DNS A que apunte a la IP pública del servidor.
- Espacio en disco suficiente para tu biblioteca.

## Paso 1: Añadir el repositorio oficial de Jellyfin

Ubuntu no incluye Jellyfin en sus repositorios. El proyecto mantiene el suyo propio, que además trae `jellyfin-ffmpeg`, una compilación de FFmpeg adaptada a Jellyfin.

Instala las herramientas necesarias y descarga la clave de firma del repositorio en `/etc/apt/keyrings`:

```bash
sudo apt update
sudo apt install -y curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://repo.jellyfin.org/jellyfin_team.gpg.key | sudo gpg --dearmor -o /etc/apt/keyrings/jellyfin.gpg
```

Crea el archivo del repositorio en formato deb822. La versión (`noble`) y la arquitectura se leen del propio sistema:

```bash
sudo tee /etc/apt/sources.list.d/jellyfin.sources > /dev/null <<EOF
Types: deb
URIs: https://repo.jellyfin.org/ubuntu
Suites: $(. /etc/os-release && echo "$VERSION_CODENAME")
Components: main
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/jellyfin.gpg
EOF
```

Actualiza el índice y comprueba que el paquete viene de `repo.jellyfin.org`:

```bash
sudo apt update
apt policy jellyfin
```

```output
jellyfin:
  Installed: (none)
  Candidate: 10.x.x+ubu2404
  Version table:
     10.x.x+ubu2404 500
        500 https://repo.jellyfin.org/ubuntu noble/main amd64 Packages
```

## Paso 2: Instalar Jellyfin

El paquete `jellyfin` instala el servidor, la interfaz web y `jellyfin-ffmpeg`, y crea el servicio systemd y el usuario de sistema `jellyfin`:

```bash
sudo apt install -y jellyfin
```

Comprueba que el servicio está activo:

```bash
systemctl status jellyfin --no-pager
```

```output
● jellyfin.service - Jellyfin Media Server
     Loaded: loaded (/usr/lib/systemd/system/jellyfin.service; enabled; preset: enabled)
     Active: active (running) since ...
```

Jellyfin escucha en el puerto 8096. Su endpoint de salud confirma que responde:

```bash
curl -s http://localhost:8096/health; echo
```

```output
Healthy
```

Las rutas que conviene conocer son `/etc/jellyfin` (configuración), `/var/lib/jellyfin` (base de datos y metadatos) y `/var/log/jellyfin` (registros).

## Paso 3: Preparar el directorio de medios

Jellyfin se ejecuta como el usuario `jellyfin`, así que necesita permiso de lectura sobre tus archivos. Crea un directorio para cada tipo de biblioteca:

```bash
sudo mkdir -p /srv/media/peliculas /srv/media/series /srv/media/musica
```

Haz que tu usuario sea el propietario (para subir archivos sin `sudo`) y que el grupo `jellyfin` pueda leerlos. Sustituye `your_user` por tu usuario:

```bash
sudo chown -R your_user:jellyfin /srv/media
sudo chmod -R u=rwX,g=rX,o= /srv/media
sudo find /srv/media -type d -exec chmod g+s {} +
```

El bit `setgid` de los directorios hace que los archivos que subas después hereden el grupo `jellyfin`. Verifica que el usuario del servicio puede listar el contenido:

```bash
sudo -u jellyfin ls -la /srv/media
```

Jellyfin identifica cada título por el nombre de carpeta y archivo, así que respeta esta convención (título y año, y temporadas con el formato `S01E01`):

```text
/srv/media/peliculas/Blade Runner (1982)/Blade Runner (1982).mkv
/srv/media/peliculas/Alien (1979)/Alien (1979).mp4
/srv/media/series/The Expanse (2015)/Season 01/The Expanse S01E01.mkv
/srv/media/series/The Expanse (2015)/Season 01/The Expanse S01E02.mkv
/srv/media/musica/Artista/Álbum (Año)/01 - Canción.flac
```

Puedes subir los archivos desde tu equipo con `rsync` o `scp`, por ejemplo:

```bash
rsync -rtvP "Alien (1979)" your_user@your_server_ip:/srv/media/peliculas/
```

Se usa `-rt` en lugar de `-a` para no copiar los permisos ni el grupo de tu equipo: así los archivos heredan el grupo `jellyfin` del directorio de destino.

## Paso 4: Completar el asistente inicial por un túnel SSH

Hasta que terminas el asistente, cualquiera que llegue al puerto 8096 podría crear la cuenta de administrador. Por eso ese puerto no se abre en el firewall y el asistente se completa a través de un túnel SSH.

Activa UFW permitiendo solo SSH por ahora:

```bash
sudo ufw allow OpenSSH
sudo ufw enable
```

Desde tu equipo local (no desde el servidor), abre el túnel:

```bash
ssh -L 8096:localhost:8096 your_user@your_server_ip
```

Con la sesión abierta, visita `http://localhost:8096` en tu navegador y sigue el asistente:

1. Elige el idioma de la interfaz.
2. Crea el usuario administrador con una contraseña robusta.
3. Añade las bibliotecas: por ejemplo, tipo **Películas** con la carpeta `/srv/media/peliculas` y tipo **Series** con `/srv/media/series`. Elige el idioma de los metadatos.
4. Deja activada la opción **Permitir conexiones remotas a este servidor**, porque el proxy inverso se conectará desde fuera del propio proceso.

Al terminar, Jellyfin escanea las bibliotecas y descarga carátulas y sinopsis. Verás los títulos en la página principal en unos minutos.

## Paso 5: Instalar Nginx y obtener el certificado

Instala Nginx y Certbot con su plugin para Nginx:

```bash
sudo apt install -y nginx certbot python3-certbot-nginx
```

Permite el tráfico HTTP y HTTPS en UFW:

```bash
sudo ufw allow 'Nginx Full'
```

Crea el sitio de Jellyfin:

```bash
sudo nano /etc/nginx/sites-available/jellyfin
```

Añade esta configuración, sustituyendo `jellyfin.your_domain`:

```nginx
server {
    listen 80;
    listen [::]:80;
    server_name jellyfin.your_domain;

    client_max_body_size 20M;

    location / {
        proxy_pass http://127.0.0.1:8096;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-Host $http_host;

        # WebSocket, usado para la sincronización entre clientes
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";

        # Envía el vídeo sin almacenarlo en búfer
        proxy_buffering off;
    }
}
```

Activa el sitio, comprueba la sintaxis y recarga Nginx:

```bash
sudo ln -s /etc/nginx/sites-available/jellyfin /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx
```

```output
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
```

Solicita el certificado. Certbot añadirá el bloque `listen 443 ssl` y la redirección de HTTP a HTTPS en el mismo archivo:

```bash
sudo certbot --nginx -d jellyfin.your_domain
```

Comprueba que la renovación automática funciona:

```bash
sudo certbot renew --dry-run
```

## Paso 6: Indicar a Jellyfin que está detrás de un proxy

Para que Jellyfin registre la IP real de cada cliente en lugar de `127.0.0.1`, y aplique bien las reglas de red local, declara Nginx como proxy de confianza. En `https://jellyfin.your_domain`, entra en **Panel de control** > **Redes**, añade `127.0.0.1` en **Proxies conocidos** y guarda. Reinicia el servicio para aplicar el cambio:

```bash
sudo systemctl restart jellyfin
```

Verifica el acceso desde fuera del servidor:

```bash
curl -sI https://jellyfin.your_domain | head -n 1
```

```output
HTTP/1.1 302 Found
```

La respuesta `302` es la redirección a la página de inicio de sesión. Ya puedes conectar las aplicaciones de Jellyfin para Android, iOS, Android TV o el navegador usando `https://jellyfin.your_domain` como dirección del servidor.

## Paso 7: Crear usuarios y ajustar la transcodificación

Crea una cuenta por persona desde **Panel de control** > **Usuarios** > **+**. En cada usuario puedes limitar las bibliotecas a las que accede, fijar una clasificación por edades máxima y restringir el bitrate de streaming remoto, útil si tu servidor tiene un ancho de banda limitado.

En **Panel de control** > **Reproducción** > **Transcodificación** se configura cómo convierte Jellyfin los vídeos que el cliente no puede reproducir de forma nativa. En un VPS sin GPU deja la aceleración por hardware en **Ninguna**: la transcodificación se hace por CPU con `jellyfin-ffmpeg`, y un solo flujo 1080p en H.264 ya ocupa varios núcleos. Para reducir la carga, guarda tus archivos en H.264 o HEVC con audio AAC, formatos que casi todos los clientes reproducen sin transcodificar.

## Solución de problemas

**Una biblioteca aparece vacía.** Casi siempre son permisos. Comprueba que el usuario del servicio puede leer la ruta:

```bash
sudo -u jellyfin ls "/srv/media/peliculas"
```

Si falla con `Permission denied`, repite los comandos de permisos del paso 3 y vuelve a escanear la biblioteca desde **Panel de control** > **Bibliotecas** > **Escanear todas las bibliotecas**.

**Error 502 Bad Gateway en Nginx.** Jellyfin no está respondiendo en el 8096. Revisa su registro:

```bash
sudo journalctl -u jellyfin --no-pager -n 50
```

**La reproducción se corta al transcodificar.** Mira el uso de CPU mientras reproduces con `htop`. Si está al 100 %, baja la calidad en el cliente o limita el bitrate remoto del usuario. Los registros de cada transcodificación están en `/var/log/jellyfin/`, en archivos que empiezan por `FFmpeg.Transcode`.

## Conclusión

Tienes Jellyfin instalado desde su repositorio oficial en Ubuntu 24.04, con bibliotecas organizadas, permisos mínimos y acceso por HTTPS a través de Nginx. Las actualizaciones llegarán con `sudo apt upgrade`. Como siguientes pasos, puedes programar una copia de seguridad de `/etc/jellyfin` y `/var/lib/jellyfin`, montar un almacenamiento adicional para la biblioteca en `/srv/media` y activar la autenticación rápida (**Quick Connect**) para iniciar sesión en televisores sin teclear la contraseña.