Building Your Own Media Server Infrastructure: A Complete Guide

⚠️ Responsible Use Disclaimer

This technical guide demonstrates Docker orchestration for educational purposes. By proceeding, you agree:

To only use content you legally own or have rights to
To comply with all copyright laws in your jurisdiction
This setup is not intended for piracy/illegal distribution

Overview

This guide will walk you through setting up a comprehensive self-hosted media server infrastructure using Docker. The setup includes media management, streaming, monitoring, and administration tools, all working together to create your personal streaming service.

Core Components

Media Server & Management

Jellyfin: An open-source media server for streaming your legally owned media collection
Jellyseerr: A request management system for Jellyfin
Radarr: Automated movie collection management
Sonarr: Automated TV shows collection management
Prowlarr: A indexer aggregator
Deluge: BitTorrent client for downloading legal content like Linux ISOs or Creative Commons material

Administration & Monitoring

Nginx Proxy Manager: Reverse proxy for secure access to your services
Filebrowser: Web-based file management interface
Dashdot: System monitoring dashboard
Homarr: Homepage for your services with Docker integration

Network Architecture

Custom Docker Network Design

The infrastructure implements a dedicated Docker network named networkflix using a bridge driver. This network is configured with a specific subnet (20.0.0.0/24) that allows for static IP assignment to each service. This design choice was made specifically to support seamless container updates and service reliability.

Table with IP and services

Service	IP Address
Jellyfin	20.0.0.2
Jellyseerr	20.0.0.3
Deluge	20.0.0.4
Radarr	20.0.0.5
Sonarr	20.0.0.6
Prowlarr	20.0.0.7
Nginx Proxy	20.0.0.8
Filebrowser	20.0.0.9
Dahdot	20.0.0.10
Homarr	20.0.0.11

Cross-Service Communication

Services are configured to communicate with each other using these fixed IPs. For example:

Radarr connects to Deluge at 20.0.0.4:8112
Jellyseerr connects to Radarr at 20.0.0.5:7878
Sonarr connects to Prowlarr at 20.0.0.7:9696

Installation Guide

1. Prepare the Environment

First, create the necessary directories:

  
# Create base directories
mkdir -p ~/media
mkdir -p ~/jellyfin/{config,cache}
mkdir -p ~/jellyseerr/appdata/config
mkdir -p ~/deluge/config
mkdir -p ~/radarr
mkdir -p ~/sonnar
mkdir -p ~/prowlarr/data
mkdir -p ~/NginxProxyManager/{data,letsencrypt}
mkdir -p ~/filebrowser
mkdir -p ~/homarr/{configs,data,icons}

2. Configure File Permissions

Set appropriate permissions:

  
# Set user permissions (assuming your user is in the docker group)
sudo chown -R $USER:$USER ~/media
sudo chmod -R 755 ~/media

3. Create Docker Network

  
# Create custom Docker network with defined subnet 
docker network create --subnet=20.0.0.0/24 networkflix

4. Docker Compose [Full Config]

  
version: "3"
services:
    jellyfin:
        container_name: jellyfin
        environment:
            - PUID=1000
            - PGID=1000
            - TZ=America/Chicago
        ports:
            - 8096:8096
            - 8920:8920
        volumes:
            - ~/jellyfin/config:/config
            - ~/jellyfin/cache:/cache
            - ~/media:/downloads
        networks:
            networkflix:
                ipv4_address: 20.0.0.2
        restart: unless-stopped
        image: lscr.io/linuxserver/jellyfin:latest

    jellyseerr:
        container_name: jellyseerr
        environment:
            - LOG_LEVEL=debug
            - TZ=America/Chicago
        ports:
            - 5055:5055
        volumes:
            - ~/jellyseerr/appdata/config:/app/config
        networks:
            networkflix:
                ipv4_address: 20.0.0.3
        restart: unless-stopped
        image: fallenbagel/jellyseerr:latest

    deluge:
        container_name: deluge
        environment:
            - PUID=1000
            - PGID=1000
            - TZ=America/Chicago
            - DELUGE_LOGLEVEL=error
        ports:
            - 8112:8112
            - 6881:6881
            - 6881:6881/udp
        volumes:
            - ~/deluge/config:/config
            - ~/media:/downloads
        networks:
            networkflix:
                ipv4_address: 20.0.0.4
        restart: unless-stopped
        image: lscr.io/linuxserver/deluge:latest

    radarr:
        container_name: radarr
        environment:
            - PUID=1000
            - PGID=1000
            - TZ=America/Chicago
        ports:
            - 7878:7878
        volumes:
            - ~/radarr:/config
            - ~/media:/movies
            - ~/media:/downloads
        networks:
            networkflix:
                ipv4_address: 20.0.0.5
        restart: unless-stopped
        image: lscr.io/linuxserver/radarr:latest

    sonarr:
        container_name: sonarr
        environment:
            - PUID=1000
            - PGID=1000
            - TZ=America/Chicago
        ports:
            - 8989:8989
        volumes:
            - ~/sonnar:/config
            - ~/media:/tv
            - ~/media:/downloads
        networks:
            networkflix:
                ipv4_address: 20.0.0.6
        restart: unless-stopped
        image: lscr.io/linuxserver/sonarr:latest

    prowlarr:
        container_name: prowlarr
        environment:
            - PUID=1000
            - PGID=1000
            - TZ=America/Chicago
        ports:
            - 9696:9696
        volumes:
            - ~/prowlarr/data:/config
        networks:
            networkflix:
                ipv4_address: 20.0.0.7
        restart: unless-stopped
        image: lscr.io/linuxserver/prowlarr:latest

    nginx-proxy-manager:
        container_name: nginx-proxy
        ports:
            - 443:443
            - 81:81
        volumes:
            - ~/NginxProxyManager/data:/data
            - ~/NginxProxyManager/letsencrypt:/etc/letsencrypt
        networks:
            networkflix:
                ipv4_address: 20.0.0.8
            default:
        restart: unless-stopped
        image: jc21/nginx-proxy-manager:latest

    filebrowser:
        container_name: filebrowser
        environment:
            - PUID=1000
            - PGID=1000
        ports:
            - 80:80
        volumes:
            - ~/:/srv
            - ~/filebrowser/filebrowser.db:/database/filebrowser.db
            - ~/filebrowser/settings.json:/config/settings.json
        networks:
            networkflix:
                ipv4_address: 20.0.0.9
        restart: unless-stopped
        image: filebrowser/filebrowser

    dashdot:
        container_name: dahdot
        ports:
            - 3001:3001
        volumes:
            - /:/mnt/host:ro
        privileged: true
        networks:
            networkflix:
                ipv4_address: 20.0.0.10
        restart: unless-stopped
        image: mauricenino/dashdot

    homarr:
        container_name: homarr
        ports:
            - 7575:7575
        volumes:
            - /var/run/docker.sock:/var/run/docker.sock
            - ~/homarr/configs:/app/data/configs
            - ~/homarr/data:/data
            - ~/homarr/icons:/app/public/icons
        networks:
            networkflix:
                ipv4_address: 20.0.0.11
        restart: unless-stopped
        image: ghcr.io/ajnart/homarr:latest

networks:
  networkflix:
    driver: bridge
    ipam:
      config:
        - subnet: 20.0.0.0/24
  default:
    driver: bridge

Save the docker-compose.yaml file to your working directory
Start the containers:

docker-compose up -d

5. Initial Configuration

After deploying the Docker file, navigate to http://localhost:81 (or your public IP if using a VPS). Enter the default password: deluge.
After logging in, go to Preferences > Plugins, check the “Label” option, then click “Apply” and “OK”.
In the left column, locate the “Labels” field and right-click on it.
Add two new labels: radarr and sonarr.
Now configure the other services using their respective ports:
- Radarr: Port 7878
- Prowlarr: Port 9696
- Sonarr: Port 8989 For each service, create a username and password and choose your preferred authentication method.

Integrating Deluge with Radarr

In Radarr, navigate to Settings > Download Client.
Click on “Deluge” to add it as a download client.
Configure Deluge in Radarr with the following settings:
- Host: 20.0.0.4 (Deluge’s internal IP)
- Port: 8112 Category: radarr (This links to the label you created in Deluge)After entering the information, click “Test” to verify the connection, then click “Save”. Repeat this process for Sonarr using the same settings, except change the Category to sonarr. For Prowlarr, follow a similar process but note that it won’t have the Category option.
In both Sonarr and Radarr, go to Settings > Media Management.

In Radarr: Click “Add Root Folder” and select the movies folder
In Sonarr: Click “Add Root Folder” and select the tv folder.

Connecting Prowlarr with Radarr and Sonarr

In Prowlarr, navigate to Settings > Apps and click the “+” button to add a new application.
Configure Radarr with these settings:
- Name: Radarr
- Sync Level: Full Sync
- Prowlarr Server: http://20.0.0.7:9696
- Radarr Server: http://20.0.0.5:7878
- API Key: (Find this in Radarr under Settings > General > Security) Click “Test” to verify the connection, then click “Save”.
Configure Sonarr with these settings:
- Name: Sonarr
- Sync Level: Full Sync
- Prowlarr Server: http://20.0.0.7:9696
- Sonarr Server: http://20.0.0.6:8989
- API Key: (Find this in Sonarr under Settings > General > Security) Click “Test” to verify the connection, then click “Save”.

Adding Indexers to Prowlarr

In Prowlarr, click on “Indexers” and then “Add Indexer”.
Select the websites you want to use, filtering by Protocol, Language, Privacy, and Categories. For each site, click “Test” and then “Save”.
After adding all indexers, verify in both Radarr and Sonarr that the indexers are linked by checking Settings > Indexers.

Configuring Jellyfin Media Player

Now that the backend automation is configured, set up Jellyfin (accessible on port 8096) by following the setup wizard.
When adding your libraries for Movies and TV Shows, include the Download folder to receive content downloaded by Radarr and Sonarr.

Setting Up Jellyseerr

Jellyseerr provides a user-friendly interface for browsing and requesting media. Access it on port 5055.`
Add your Jellyfin server information:
- IP: 20.0.0.2
- Username and password for your Jellyfin account
Add your Jellyfin API key (found in Administration > Dashboard > API keys). Create a new key specifically for Jellyseerr, add it to the API key field, then click “Sync Library” and “Continue”.
Add Radarr and Sonarr using their API keys (found in Settings > General > Security). Click “Test” to verify the connection.
After clicking “Test”, select the three new fields that appear, then click “Add Server”. Your fully automated Jellyfin ecosystem is now ready to use!

Security Recommendations

For enhanced security, purchase a domain and implement HTTPS encryption using the Nginx reverse proxy. The default credentials are:
- Username: admin@example.com
- Password: changeme
For better security, close all ports except:
- Port 443 (HTTPS)
- Port 6881 (TCP and UDP for Deluge)

When configuring port forwarding, use the internal IPs listed in the Network section.

Additional Services

The setup also includes these helpful utilities:

Filebrowser (Port 80): Works like a file explorer, allowing you to view and modify files through a web interface.
Homarr (Port 3001): Organizes all your links and provides basic monitoring using Dashdot.
Dashdot (Port 3001): Monitors server metrics such as CPU usage, memory, RAM, and other system resources.

Maintenance

Regular Updates

  
# Pull latest images
docker-compose pull
# Restart services
docker-compose up -d

Update with WatchTower

This container will check and update the containers every saturday 1am

  
docker run -d \
--name watchtower \
-v /var/run/docker.sock:/var/run/docker.sock \
-e TZ=America/Chicago \
-e WATCHTOWER_CLEANUP=true \
-e WATCHTOWER_TIMEOUT=30s \
-e WATCHTOWER_SCHEDULE="0 1 * * 6" \
--restart unless-stopped \
containrrr/watchtower \
sonarr radarr prowlarr jellyseerr jellyfin deluge dashdot homarr