# Media Server - Stack Completo de Gestión de Medios

Stack completo para gestión y streaming de contenido multimedia con automatización de descargas.

## 🎯 Flujo de Trabajo

1. **Usuario solicita contenido** → Jellyseerr
2. **Jellyseerr envía solicitud** → Sonarr (series) o Radarr (películas)
3. **Sonarr/Radarr busca contenido** → Prowlarr/Jackett
4. **Prowlarr consulta trackers** → Indexers configurados
5. **Se descarga el contenido** → Cliente de descargas
6. **Sonarr/Radarr organiza archivos** → Directorios de medios
7. **Jellyfin detecta nuevo contenido** → Disponible para streaming

## 📋 Descripción

Este stack despliega un servidor multimedia completo con:

| Servicio | Descripción | Puerto | Propósito |
|----------|-------------|--------|-----------|
| **Jellyfin** | Servidor de streaming de medios | 8096 | Reproducir contenido multimedia |
| **Jellyseerr** | Sistema de solicitudes | 5055 | Permitir solicitudes de usuarios |
| **Sonarr** | Gestor de series TV | 8989 | Automatizar descargas de series |
| **Radarr** | Gestor de películas | 7878 | Automatizar descargas de películas |
| **Prowlarr** | Gestor de indexers | 9696 | Centralizar trackers |
| **Jackett** | Proxy de trackers | 9117 | Alternativa a Prowlarr |
| **FlareSolverr** | Resolver Cloudflare | 8191 | Bypasear protecciones |

**Características**:
- ✅ Automatización completa de descargas
- ✅ Gestión de calidad y formatos
- ✅ Sistema de solicitudes para usuarios
- ✅ Protección con SSO (Authentik)
- ✅ Certificados SSL automáticos (Let's Encrypt)
- ✅ Red aislada para servicios internos

## 🚀 Despliegue

### Prerequisitos

1. **Red Docker**: Asegúrate de que la red `proxy` existe
2. **Registros DNS**: Configura los registros A para tus dominios de servicios
3. **Almacenamiento**: Prepara los directorios para medios y configuraciones

### Desde Portainer

1. Ve a **Stacks** → **Add stack**
2. Nombre: `media-server`
3. Selecciona **Repository** o **Git repository**
4. Configura:
   - Repository URL: `<tu-repositorio>`
   - Repository reference: `main`
   - Compose path: `media-server/docker-compose.yml`
5. Carga el archivo de variables de entorno: `media-server/stack.env`
6. Haz clic en **Deploy the stack**

### Variables de Entorno Importantes

Edita el archivo `stack.env`:

```env
# Global
TZ=Europe/Madrid
PUID=0
PGID=0

# Paths - Directorio base para configuraciones
COMMON_PATH=/opt/media-server

# Media mounts - Rutas del servidor donde están los archivos de medios
MEDIA_TV=/mnt/media/tv
MEDIA_MOVIES=/mnt/media/movies
MEDIA_DOWNLOADS=/mnt/media/downloads

# Networks
TRAEFIK_DOCKER_NETWORK=proxy
MEDIA_NETWORK_NAME=media

# Traefik & SSL
TRAEFIK_ENABLE=true
TRAEFIK_ENTRYPOINTS=websecure
TRAEFIK_TLS=true
TRAEFIK_CERTRESOLVER=letsencrypt
AUTH_MIDDLEWARE=authentik@docker

# Dominios - Personaliza según tu dominio
DOMAIN=tudominio.com
PROWLARR_HOST=prowlarr.tudominio.com
JACKETT_HOST=jackett.tudominio.com
SONARR_HOST=sonarr.tudominio.com
RADARR_HOST=radarr.tudominio.com
JELLYSEERR_HOST=requests.tudominio.com
JELLYFIN_HOST=media.tudominio.com
```

## ⚙️ Configuración Post-Instalación

### 1. Preparar Directorios

Antes de desplegar, crea las estructuras de directorios necesarias:

```bash
# Directorio base de configuraciones
sudo mkdir -p /opt/media-server/configs/{prowlarr,jackett,sonarr,radarr,jellyseerr,jellyfin-vps}
sudo mkdir -p /opt/media-server/jellyfin/cache-vps

# Directorios de medios
sudo mkdir -p /mnt/media/{tv,movies,downloads}

# Ajustar permisos
sudo chown -R $USER:$USER /opt/media-server
sudo chown -R $USER:$USER /mnt/media
```

### 2. Configurar Prowlarr (Indexers)

**Prowlarr** es el gestor centralizado de indexers/trackers:

1. Accede a `https://prowlarr.tudominio.com`
2. Completa el asistente de configuración inicial
3. Ve a **Settings** → **Indexers** → **Add Indexer**
4. Añade tus trackers preferidos (públicos o privados)
5. Si algún tracker requiere FlareSolverr para Cloudflare:
   - Ve a **Settings** → **Indexers** → **FlareSolverr**
   - URL: `http://flaresolverr:8191`

### 3. Conectar Sonarr y Radarr con Prowlarr

En **Prowlarr**, añade las aplicaciones:

1. Ve a **Settings** → **Apps** → **Add Application**
2. Selecciona **Sonarr** o **Radarr**
3. Configura:
   - **Prowlarr Server**: `http://prowlarr:9696`
   - **Sonarr Server**: `http://sonarr:8989`
   - **Radarr Server**: `http://radarr:7878`
   - API Key: Cópiala desde Settings → General en cada aplicación
4. Haz clic en **Test** y luego **Save**
5. Sincroniza los indexers automáticamente

### 4. Configurar Clientes de Descarga

En **Sonarr** y **Radarr**, configura tu cliente de descargas (qBittorrent, Transmission, etc.):

1. Ve a **Settings** → **Download Clients** → **Add**
2. Selecciona tu cliente
3. Configura la conexión (host, puerto, usuario, contraseña)
4. Establece las categorías (tv para Sonarr, movies para Radarr)

### 5. Configurar Perfiles de Calidad

En **Sonarr** y **Radarr**:

1. Ve a **Settings** → **Profiles**
2. Configura los perfiles de calidad según tus preferencias
3. Ajusta el idioma preferido
4. Configura el formato preferido (1080p, 4K, etc.)

### 6. Configurar Jellyfin

**Jellyfin** es tu servidor de streaming:

1. Accede a `https://media.tudominio.com`
2. Completa el asistente de configuración:
   - Crea el usuario administrador
   - Configura las bibliotecas:
     - **Series**: `/data/tvshows`
     - **Películas**: `/data/movies`
3. Escanea las bibliotecas para detectar contenido
4. Configura metadatos (TMDb, TVDb, etc.)

### 7. Configurar Jellyseerr

**Jellyseerr** permite a los usuarios solicitar contenido:

1. Accede a `https://requests.tudominio.com`
2. Conecta con Jellyfin:
   - URL: `http://jellyfin:8096`
   - API Key: Desde Jellyfin Dashboard → API Keys
3. Conecta con Sonarr:
   - URL: `http://sonarr:8989`
   - API Key: Desde Sonarr Settings → General
4. Conecta con Radarr:
   - URL: `http://radarr:7878`
   - API Key: Desde Radarr Settings → General
5. Configura permisos de usuario
6. Activa notificaciones (opcional)

### 8. Integración con Authentik (SSO)

Todos los servicios están protegidos con Authentik por defecto mediante el middleware `authentik@docker`.

Para personalizar el acceso:

1. En Authentik, crea aplicaciones para cada servicio
2. Configura grupos y permisos según tus necesidades
3. Los usuarios autenticados tendrán acceso automático

Si necesitas acceso público a Jellyfin:

```env
# En stack.env, para Jellyfin
AUTH_MIDDLEWARE=  # Deja vacío para acceso público
```

## 🔧 Configuración Avanzada

### Personalizar Puertos de Servicios

Por defecto los servicios usan sus puertos estándar:

```env
PROWLARR_PORT=9696
JACKETT_PORT=9117
SONARR_PORT=8989
RADARR_PORT=7878
JELLYSEERR_PORT=5055
JELLYFIN_PORT=8096
```

### Personalizar Nombres de Contenedores

```env
PROWLARR_CONTAINER_NAME=prowlarr-prod
SONARR_CONTAINER_NAME=sonarr-prod
# etc...
```

### Usar Imágenes Específicas

```env
JELLYFIN_IMAGE=lscr.io/linuxserver/jellyfin:10.8.13
SONARR_IMAGE=lscr.io/linuxserver/sonarr:4.0
RADARR_IMAGE=lscr.io/linuxserver/radarr:5.2
```

### Configurar FlareSolverr para Trackers Protegidos

FlareSolverr ayuda a resolver protecciones de Cloudflare:

```env
# Recursos de memoria
FLARESOLVERR_SHM_SIZE=1gb

# Nivel de logs
LOG_LEVEL=info
LOG_HTML=false

# Solucionador de captchas (none, hcaptcha-solver)
CAPTCHA_SOLVER=none
```

### Configurar PUID/PGID Personalizado

Para evitar problemas de permisos, usa tu usuario del sistema:

```bash
id $USER
# uid=1000(usuario) gid=1000(usuario)
```

```env
PUID=1000
PGID=1000
```

### Notificaciones Personalizadas

Configura notificaciones en cada aplicación:

**Sonarr/Radarr**:
- Ve a **Settings** → **Connect** → **Add Notification**
- Opciones: Discord, Telegram, Email, Slack, etc.

**Jellyseerr**:
- Ve a **Settings** → **Notifications**
- Configura Discord, Email, Telegram, etc.

## 🛠️ Troubleshooting

### Sonarr/Radarr no encuentra series/películas

1. Verifica que Prowlarr está conectado correctamente
2. Comprueba que los indexers están funcionando en Prowlarr
3. Revisa los logs:
   ```bash
   docker logs sonarr
   docker logs radarr
   ```

### FlareSolverr no resuelve captchas

1. Verifica los logs:
   ```bash
   docker logs flaresolverr
   ```

2. Aumenta la memoria compartida si es necesario:
   ```env
   FLARESOLVERR_SHM_SIZE=2gb
   ```

3. Prueba la conectividad:
   ```bash
   docker exec prowlarr curl http://flaresolverr:8191/health
   ```

### Error de permisos en directorios de medios

Si usas SELinux, los volúmenes ya tienen `:Z`:

```bash
# Si persisten problemas
sudo chcon -Rt svirt_sandbox_file_t /opt/media-server
sudo chcon -Rt svirt_sandbox_file_t /mnt/media
```

Si usas PUID/PGID personalizado:

```bash
# Ajustar permisos
sudo chown -R 1000:1000 /opt/media-server
sudo chown -R 1000:1000 /mnt/media
```

### Jellyfin no detecta el contenido

1. Verifica las rutas de las bibliotecas en Jellyfin:
   - Series: `/data/tvshows`
   - Películas: `/data/movies`

2. Escanea manualmente las bibliotecas:
   - Dashboard → Libraries → Scan All Libraries

3. Verifica permisos de lectura:
   ```bash
   docker exec jellyfin-vps ls -la /data/tvshows
   docker exec jellyfin-vps ls -la /data/movies
   ```

### Jellyseerr no se conecta con Sonarr/Radarr

1. Verifica las API Keys en cada servicio
2. Usa las URLs internas del contenedor:
   - Sonarr: `http://sonarr:8989`
   - Radarr: `http://radarr:7878`
   - Jellyfin: `http://jellyfin:8096`

3. Revisa los logs:
   ```bash
   docker logs jellyseerr
   ```

### Los servicios no son accesibles vía web

1. Verifica que Traefik está corriendo
2. Comprueba las etiquetas de Traefik en los contenedores:
   ```bash
   docker inspect prowlarr | grep traefik
   ```

3. Verifica los certificados SSL:
   ```bash
   docker logs traefik | grep letsencrypt
   ```

4. Comprueba los registros DNS:
   ```bash
   nslookup prowlarr.tudominio.com
   ```

## 📚 Recursos Adicionales

- [Documentación oficial de Jellyfin](https://jellyfin.org/docs/)
- [Wiki de Sonarr](https://wiki.servarr.com/sonarr)
- [Wiki de Radarr](https://wiki.servarr.com/radarr)
- [Documentación de Prowlarr](https://wiki.servarr.com/prowlarr)
- [Documentación de Jellyseerr](https://docs.jellyseerr.dev/)
- [FlareSolverr GitHub](https://github.com/FlareSolverr/FlareSolverr)

## 🔒 Seguridad

- **SSO con Authentik**: Todos los servicios protegidos por defecto
- **API Keys**: Protege las API keys de cada servicio
- **VPN**: Considera usar VPN para clientes de descarga
- **Trackers Privados**: Usa credenciales seguras para trackers privados
- **Certificados SSL**: Let's Encrypt mediante Traefik
- **Backups**: Realiza backups regulares de configuraciones y bases de datos

## 💾 Backups

### Backup de Configuraciones

```bash
# Backup de todas las configuraciones
sudo tar -czf media-server-configs-$(date +%Y%m%d).tar.gz /opt/media-server/configs

# Restaurar
sudo tar -xzf media-server-configs-YYYYMMDD.tar.gz -C /
```

### Backup de Bases de Datos Internas

Cada servicio *arr tiene su propia base de datos SQLite:

```bash
# Sonarr
docker exec sonarr cp /config/sonarr.db /config/sonarr.db.backup

# Radarr
docker exec radarr cp /config/radarr.db /config/radarr.db.backup

# Prowlarr
docker exec prowlarr cp /config/prowlarr.db /config/prowlarr.db.backup
```

### Backup Completo del Stack

```bash
# Script de backup completo
#!/bin/bash
BACKUP_DIR=/backups/media-server
DATE=$(date +%Y%m%d)

mkdir -p $BACKUP_DIR

# Configuraciones
sudo tar -czf $BACKUP_DIR/configs-$DATE.tar.gz /opt/media-server/configs

# Lista de contenido (opcional)
sudo tar -czf $BACKUP_DIR/media-structure-$DATE.tar.gz \
  --exclude='*' \
  --include='*/' \
  /mnt/media

echo "Backup completado: $BACKUP_DIR"
```

## 🔄 Actualizaciones

1. **Backup primero**: Siempre haz backup antes de actualizar
2. Actualiza las versiones de imágenes en `stack.env`:
   ```env
   JELLYFIN_IMAGE=lscr.io/linuxserver/jellyfin:10.9.0
   SONARR_IMAGE=lscr.io/linuxserver/sonarr:latest
   RADARR_IMAGE=lscr.io/linuxserver/radarr:latest
   ```
3. Actualiza el stack en Portainer o con Docker Compose:
   ```bash
   docker compose pull
   docker compose up -d
   ```
4. Verifica los logs de cada servicio
5. Comprueba que todo funciona correctamente

### Actualizaciones Recomendadas

- **Jellyfin**: Revisa changelog antes de actualizar versiones mayores
- **Sonarr/Radarr**: Usa `latest` para recibir actualizaciones automáticas
- **Prowlarr**: Mantén sincronizado con Sonarr/Radarr
- **FlareSolverr**: Actualiza cuando haya cambios en Cloudflare

## 📊 Monitoreo

### Ver Estadísticas de Uso

**Jellyfin**:
- Dashboard → Activity → Ver reproducciones activas
- Dashboard → Users → Estadísticas por usuario

**Sonarr/Radarr**:
- System → Status → Ver actividad de descargas
- Queue → Ver cola de descargas

**Prowlarr**:
- System → Status → Estadísticas de indexers

### Logs de Servicios

```bash
# Ver logs en tiempo real
docker logs -f prowlarr
docker logs -f jackett
docker logs -f sonarr
docker logs -f radarr
docker logs -f jellyseerr
docker logs -f jellyfin-vps
docker logs -f flaresolverr

# Ver últimas 100 líneas
docker logs --tail 100 sonarr
```

### Salud del Sistema

Cada servicio *arr tiene una página de salud:

- **Sonarr**: Settings → General → System Status
- **Radarr**: Settings → General → System Status
- **Prowlarr**: System → Status

### Monitoreo de Recursos

Usa `docker stats` para ver uso de recursos:

```bash
docker stats prowlarr sonarr radarr jellyfin-vps jellyseerr
```

### Notificaciones de Estado

Configura notificaciones en Sonarr/Radarr para:
- Descargas completadas
- Fallos en descargas
- Problemas con indexers
- Actualizaciones de aplicaciones

## 📝 Referencia Rápida

### URLs de Servicios (Por Defecto)

```
Prowlarr:   https://prowlarr.tudominio.com
Jackett:    https://jackett.tudominio.com
Sonarr:     https://sonarr.tudominio.com
Radarr:     https://radarr.tudominio.com
Jellyseerr: https://requests.tudominio.com
Jellyfin:   https://media.tudominio.com
```

### URLs Internas (Entre Contenedores)

```
Prowlarr:     http://prowlarr:9696
Jackett:      http://jackett:9117
Sonarr:       http://sonarr:8989
Radarr:       http://radarr:7878
Jellyseerr:   http://jellyseerr:5055
Jellyfin:     http://jellyfin:8096
FlareSolverr: http://flaresolverr:8191
```

### Rutas de Montaje en Contenedores

```
Configuraciones:  /config
Series TV:        /tv (Sonarr), /data/tvshows (Jellyfin)
Películas:        /movies (Radarr), /data/movies (Jellyfin)
Descargas:        /downloads
```

### Comandos Útiles

```bash
# Ver todos los contenedores del stack
docker ps --filter "name=prowlarr|sonarr|radarr|jellyfin|jellyseerr|jackett|flaresolverr"

# Reiniciar un servicio específico
docker restart sonarr

# Ver uso de recursos
docker stats --no-stream prowlarr sonarr radarr jellyfin-vps

# Backup rápido de configuración
docker exec sonarr tar czf /config/backup-$(date +%Y%m%d).tar.gz /config/*.db

# Limpiar logs antiguos
docker exec sonarr find /config/logs -type f -mtime +30 -delete
```

### Orden de Configuración Recomendado

1. ✅ FlareSolverr (si es necesario)
2. ✅ Prowlarr → Añadir indexers
3. ✅ Sonarr/Radarr → Configurar cliente de descargas
4. ✅ Prowlarr → Conectar con Sonarr/Radarr
5. ✅ Jellyfin → Añadir bibliotecas
6. ✅ Jellyseerr → Conectar todo

## 🤝 Soporte y Contribuciones

Para problemas o sugerencias:
1. Revisa la sección de Troubleshooting
2. Consulta la documentación oficial de cada servicio
3. Verifica los logs del contenedor específico

## 📄 Licencia

Este stack utiliza software de código abierto. Consulta las licencias individuales de cada proyecto.

---

**Nota**: Este stack está diseñado para uso personal. Asegúrate de cumplir con las leyes de copyright de tu región al descargar contenido.