How To Install Jellyfin on CentOS Stream 10
In the ever-evolving landscape of media streaming solutions, Jellyfin stands out as a powerful, open-source alternative to proprietary platforms like Plex and Emby. With its robust feature set and zero subscription fees, Jellyfin has garnered significant attention from Linux enthusiasts and home media server operators. This comprehensive guide explores the process of installing Jellyfin on CentOS Stream 10, configuring it optimally, and transforming your server into a personalized media powerhouse.
Understanding Jellyfin and Its Requirements
Jellyfin represents the pinnacle of free and open-source media server solutions. Unlike its competitors, Jellyfin imposes no artificial restrictions on functionality and remains completely free of tracking or data collection. This self-hosted media system allows you to organize, manage, and stream your personal media collection – including movies, TV shows, music, and photos – to any device on your network or even remotely over the internet.
Key Jellyfin Features:
- Multi-user support with customizable profiles and parental controls
- Transcoding capabilities for playback on various devices
- Live TV and DVR functionality
- Comprehensive metadata fetching and organization
- Client applications for browsers, mobile devices, smart TVs, and streaming boxes
- Plugin ecosystem for extended functionality
For optimal performance on CentOS Stream 10, your server should meet certain hardware requirements. While Jellyfin can run on modest hardware, transcoding capabilities will benefit significantly from more powerful components:
- Minimum requirements: Dual-core CPU, 2GB RAM, and sufficient storage for your media
- Recommended: Quad-core CPU or better, 4GB+ RAM, and SSD for system files
- Transcoding heavy workloads: Modern CPU with hardware acceleration support or dedicated GPU
- Network: Gigabit Ethernet recommended, especially for 4K content streaming
CentOS Stream 10 provides an excellent foundation for Jellyfin due to its stability, security features, and long-term support model. The combination delivers a reliable media server platform that requires minimal maintenance while delivering maximum performance.
Prerequisites Before Installation
Before diving into the Jellyfin installation process, ensure your CentOS Stream 10 system is properly prepared. This preparation will help avoid potential issues and create an optimal environment for your media server.
First, update your system to ensure all packages are current:
sudo dnf update -y
sudo dnf upgrade -yNext, install the EPEL (Extra Packages for Enterprise Linux) repository, which provides additional packages not included in the standard CentOS repositories:
sudo dnf install epel-release -yFor proper media handling, you’ll need FFmpeg and related dependencies. The RPM Fusion repository provides these packages:
sudo dnf install https://mirrors.rpmfusion.org/free/el/rpmfusion-free-release-$(rpm -E %rhel).noarch.rpm -y
sudo dnf install https://mirrors.rpmfusion.org/nonfree/el/rpmfusion-nonfree-release-$(rpm -E %rhel).noarch.rpm -yInstall essential dependencies for Jellyfin:
sudo dnf install ffmpeg ffmpeg-devel SDL2 SDL2-devel -yCreating a dedicated user for the Jellyfin service improves security by following the principle of least privilege:
sudo useradd jellyfin -u 950 --system --shell /usr/bin/nologinFinally, prepare storage locations for your media files. It’s advisable to organize your content logically:
sudo mkdir -p /media/jellyfin/{Movies,TVShows,Music,Photos}
sudo chown -R jellyfin:jellyfin /media/jellyfinIf using SELinux in enforcing mode (default on CentOS), set appropriate contexts for media directories:
sudo semanage fcontext -a -t httpd_sys_content_t "/media/jellyfin(/.*)?"
sudo restorecon -Rv /media/jellyfinWith these prerequisites in place, your CentOS Stream 10 system is ready for Jellyfin installation.
Installation Methods for Jellyfin on CentOS Stream 10
There are multiple approaches to installing Jellyfin on CentOS Stream 10. This section explores the most common methods, starting with the recommended RPM package installation approach.
Method 1: Installing via RPM Packages (Recommended)
This method provides the most straightforward path to a stable Jellyfin installation. First, you’ll need to download the latest Jellyfin server and web packages:
# Set the version variable - update this to the latest available version
VER=10.8.13
# Download the Jellyfin server package
wget https://repo.jellyfin.org/releases/server/centos/stable/server/jellyfin-server-$VER-1.el7.x86_64.rpm
# Download the Jellyfin web interface package
wget https://repo.jellyfin.org/releases/server/centos/stable/web/jellyfin-web-$VER-1.el7.noarch.rpmInstall the downloaded packages using DNF:
# Install server package
sudo dnf install -y ./jellyfin-server-*.rpm
# Install web package
sudo dnf install -y ./jellyfin-web-*.rpmAfter installation, start and enable the Jellyfin service:
sudo systemctl enable jellyfin
sudo systemctl start jellyfinVerify that the service started successfully:
sudo systemctl status jellyfinThe output should indicate that the service is active and running. Your Jellyfin server is now accessible at http://your-server-ip:8096.
Method 2: Docker Container Installation
For users who prefer containerized deployments, Docker offers an alternative installation method:
# Install Docker if not already installed
sudo dnf install -y dnf-plugins-core
sudo dnf config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
sudo dnf install -y docker-ce docker-ce-cli containerd.io
sudo systemctl enable --now docker
# Create directories for Jellyfin configuration and cache
sudo mkdir -p /opt/jellyfin/{config,cache,media}
sudo chown -R jellyfin:jellyfin /opt/jellyfin
# Run Jellyfin container
sudo docker run -d \
--name jellyfin \
--user 950:950 \
--net=host \
--volume /opt/jellyfin/config:/config \
--volume /opt/jellyfin/cache:/cache \
--volume /media/jellyfin:/media \
--restart=unless-stopped \
jellyfin/jellyfin:latestThis Docker method isolates Jellyfin from the host system, making upgrades and maintenance simpler in many cases.
Method 3: Building from Source (Advanced)
For users who need the absolute latest features or specific customizations, building from source is available but recommended only for advanced users familiar with compilation processes.
Post-Installation Configuration
After installing Jellyfin, several configuration steps remain to optimize your media server experience. The initial configuration involves service management and basic settings adjustments.
First, ensure the Jellyfin service starts automatically after system reboots:
sudo systemctl enable jellyfinConfirm the service is running correctly:
sudo systemctl status jellyfinThe main configuration files for Jellyfin are located in the following directories:
/etc/jellyfin/– Primary configuration files/var/lib/jellyfin/– Data files including the SQLite database/var/log/jellyfin/– Log files/var/cache/jellyfin/– Transcoding cache and other temporary files
To modify the advanced configuration settings, edit the main configuration file:
sudo nano /etc/jellyfin/system.xmlFor automatic updates on CentOS Stream 10, you can create a simple DNF automatic configuration:
sudo dnf install dnf-automatic -y
sudo nano /etc/dnf/automatic.confSet the following options:
[commands]
upgrade_type = security
random_sleep = 0
[emitters]
system_name = jellyfin-server
emit_via = email
[email]
email_from = root@localhost
email_to = your-email@example.com
email_host = localhost
[base]
debuglevel = 1Enable and start the automatic update service:
sudo systemctl enable dnf-automatic.timer
sudo systemctl start dnf-automatic.timerThese configurations ensure your Jellyfin server remains up-to-date with security patches while maintaining stable operation.
Network and Firewall Configuration
Proper network configuration is crucial for both local and remote access to your Jellyfin media server. By default, Jellyfin uses port 8096 for HTTP traffic and optionally port 8920 for HTTPS if configured.
To configure the CentOS Stream 10 firewall to allow Jellyfin traffic:
# Allow HTTP traffic (port 8096)
sudo firewall-cmd --zone=public --add-port=8096/tcp --permanent
# If using HTTPS, allow port 8920 as well
sudo firewall-cmd --zone=public --add-port=8920/tcp --permanent
# Apply changes
sudo firewall-cmd --reloadVerify the firewall settings:
sudo firewall-cmd --list-allFor remote access outside your network, you’ll need to:
- Configure port forwarding on your router to direct traffic to your Jellyfin server
- Consider setting up a reverse proxy for added security
- Optionally register a domain name and configure dynamic DNS if your ISP provides dynamic IP addresses
A secure approach for remote access is implementing a reverse proxy with SSL/TLS encryption. Nginx makes an excellent choice for this purpose:
# Install Nginx
sudo dnf install nginx -y
# Configure Nginx as a reverse proxy for Jellyfin
sudo nano /etc/nginx/conf.d/jellyfin.confAdd the following configuration:
server {
listen 80;
server_name jellyfin.yourdomain.com;
# Redirect HTTP to HTTPS
return 301 https://$host$request_uri;
}
server {
listen 443 ssl;
server_name jellyfin.yourdomain.com;
# SSL configuration
ssl_certificate /etc/letsencrypt/live/jellyfin.yourdomain.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/jellyfin.yourdomain.com/privkey.pem;
# Proxy configuration
location / {
proxy_pass http://127.0.0.1:8096;
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-Protocol $scheme;
proxy_set_header X-Forwarded-Host $http_host;
# WebSocket support
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
}
}This configuration secures your Jellyfin server behind HTTPS encryption, protecting user credentials and streaming content.
Setting Up Your Jellyfin Media Server
With Jellyfin installed and network configurations in place, the next step is setting up the media server through the web interface. Open a web browser and navigate to http://your-server-ip:8096 to access the Jellyfin setup wizard.
The initial setup process includes several key steps:
- Creating your administrator account: Set a strong username and password combination
- Server configuration: Name your server and configure display preferences
- Library setup: Define media libraries (to be discussed in the next section)
- Remote access settings: Configure how users can connect from outside your network
- Metadata preferences: Select metadata providers and languages
For the administrator account, use a unique password that differs from your system user accounts. This account will have full control over all server aspects, including user management and system settings.
In the server configuration page, you can customize:
- Server name: A friendly name for your server (e.g., “Home Media Center”)
- Default language: The primary language for the interface
- Cache location: Where temporary transcoding files are stored
- Log level: The detail level of server logs (Normal is sufficient for most users)
The remote access configuration deserves special attention. For home networks, enable:
- Allow remote connections to this server: Toggles external access capability
- Customize external domain: Set if you’re using a custom domain name
- Enable automatic port mapping: Uses UPnP for automatic port forwarding (if your router supports it)
After completing the setup wizard, you’ll be directed to the main Jellyfin dashboard, where you can begin fine-tuning your media server configuration.
Adding and Managing Media Libraries
Media libraries form the backbone of your Jellyfin server, organizing your content into logical collections. Creating properly configured libraries ensures optimal organization and metadata retrieval.
To add a new library:
- Navigate to Dashboard → Libraries → Add Media Library
- Select the appropriate Content Type (Movies, TV Shows, Music, etc.)
- Name your library (e.g., “Movies”, “TV Series”, “Documentaries”)
- Add folders containing your media by clicking Add Folder and selecting the appropriate path
- Configure Library Settings based on your preferences:
- Display Settings: How items appear in the interface
- Metadata Downloads: Which metadata providers to use
- Real-time monitoring: Whether to scan for new media automatically
- Subtitles: Default subtitle behavior
For optimal organization and metadata matching, follow these best practices:
- Movies: Store each movie as either a single file or in its own folder
- TV Shows: Organize by Series/Season/Episode (e.g.,
/media/jellyfin/TVShows/ShowName/Season 01/S01E01.mp4) - Music: Organize by Artist/Album/Track
- Photos: Organize by Event/Date or Album
Jellyfin supports various naming conventions, but consistent formatting improves automatic metadata matching. For movies, include the year in parentheses:
/media/jellyfin/Movies/Movie Title (2023)/movie.mp4For TV series, follow standard season and episode notation:
/media/jellyfin/TVShows/Show Name/Season 01/Show Name - S01E01 - Episode Title.mp4After adding libraries, Jellyfin initiates a scan to identify and catalog media files. This process may take considerable time for large collections. You can monitor the progress from the dashboard’s Tasks section.
For large media collections:
- Consider splitting content into multiple libraries by genre or type
- Use Jellyfin’s collection feature to group related content
- Enable scheduled tasks for library scanning during off-peak hours
Proper library configuration significantly enhances the browsing experience and makes locating specific content much easier.
Advanced Configuration Options
Jellyfin offers numerous advanced configuration options to fine-tune your media server experience. This section explores key settings that can optimize performance and enhance functionality.
Transcoding Configuration
Transcoding allows Jellyfin to convert media files on-the-fly for compatibility with various devices:
- Navigate to Dashboard → Playback
- Under the Transcoding tab, configure:
- Transcoding temporary path: Where temporary files are stored (preferably on fast storage)
- Transcoding thread count: How many CPU threads to utilize (start with half your CPU cores)
- Hardware acceleration: Enable if your CPU/GPU supports it
- Encoder preset: Balance between speed and quality (faster presets use more CPU but less time)
Hardware Acceleration Setup
Hardware acceleration can dramatically improve transcoding performance. For CentOS Stream 10 with an Intel CPU:
# Install Intel Media SDK
sudo dnf install intel-mediasdk -y
# Add Jellyfin user to video group
sudo usermod -aG video jellyfin
# Restart Jellyfin
sudo systemctl restart jellyfinIn the Jellyfin dashboard, enable hardware acceleration:
- Go to Dashboard → Playback → Transcoding
- Set Hardware acceleration to Intel QuickSync
- Configure Hardware acceleration tuning options based on your specific hardware
Plugin Installation
Extend Jellyfin’s functionality with plugins:
- Navigate to Dashboard → Plugins
- Select Catalog to browse available plugins
- Click Install on desired plugins
- Restart Jellyfin for changes to take effect
Essential plugins to consider:
- Fanart: Enhanced artwork and images
- Reports: Detailed media statistics and reports
- Trakt Sync: Synchronize watch history with Trakt.tv
- Theme Songs: Add TV show theme songs to the browsing experience
- Open Subtitles: Automatic subtitle downloading
Scheduled Tasks Configuration
Optimize server maintenance through scheduled tasks:
- Go to Dashboard → Scheduled Tasks
- Configure each task to run during low-usage periods
- Essential tasks to optimize:
- Library Scan: Set to run daily during off-peak hours
- Backup: Schedule regular database backups
- Image Clean-up: Remove unused images periodically
- Chapter Image Extraction: Generate chapter thumbnails during off-hours
These advanced configurations help tailor Jellyfin to your specific needs while ensuring optimal performance for all users.
Accessing Your Jellyfin Media Server
Jellyfin offers multiple ways to access your media collection, accommodating various devices and usage scenarios. This versatility ensures you can enjoy your content from virtually anywhere.
Web Browser Access
The simplest method to access Jellyfin is through a web browser:
- On your local network:
http://server-ip:8096 - Through a reverse proxy:
https://jellyfin.yourdomain.com
Modern browsers including Chrome, Firefox, Edge, and Safari provide excellent compatibility with Jellyfin’s web interface. The web client supports direct playback of most media formats, transcoding when necessary for compatibility.
Mobile Applications
Official Jellyfin mobile apps offer optimized experiences for on-the-go viewing:
- Android: Available on Google Play Store and F-Droid
- iOS: Available on the Apple App Store
To connect mobile apps:
- Install the appropriate app for your device
- Launch the app and select Add Server
- Enter your server address (local IP or domain name)
- Log in with your Jellyfin credentials
Mobile apps support downloading content for offline viewing, a valuable feature for travelers or those with limited data plans.
Smart TV and Streaming Devices
Jellyfin supports various streaming platforms:
- Android TV: Official app available on Google Play
- Amazon Fire TV: Sideload the Android TV app
- Roku: Official Jellyfin channel
- Apple TV: Official app available on the App Store
- Samsung/LG Smart TVs: Access via the built-in browser or DLNA
Kodi Integration
For Kodi users, the Jellyfin for Kodi addon provides seamless integration:
- In Kodi, navigate to Add-ons → Install from repository
- Add the Jellyfin repository:
https://repo.jellyfin.org/releases/client/kodi/repository.jellyfin.kodi.zip - Install the Jellyfin addon
- Configure the addon with your server details
This integration combines Kodi’s powerful playback capabilities with Jellyfin’s media management features.
Maintenance and Troubleshooting
Regular maintenance ensures your Jellyfin server remains reliable and performs optimally. Additionally, knowing how to troubleshoot common issues helps minimize downtime.
Regular Maintenance Tasks
Implement these maintenance practices to keep your server running smoothly:
- Database optimization: Run monthly
sudo systemctl stop jellyfin sudo -u jellyfin sqlite3 /var/lib/jellyfin/data/jellyfin.db "VACUUM;" sudo systemctl start jellyfin - Log rotation: Ensure logs don’t consume excessive space
sudo nano /etc/logrotate.d/jellyfinAdd the following configuration:
/var/log/jellyfin/*.log { weekly rotate 4 compress delaycompress notifempty missingok postrotate systemctl reload jellyfin.service endscript } - Configuration backup: Schedule regular backups
sudo mkdir -p /var/backups/jellyfin sudo tar -czf /var/backups/jellyfin/config-$(date +%Y%m%d).tar.gz /etc/jellyfin /var/lib/jellyfin/data
Common Issues and Solutions
- Jellyfin service fails to startCheck the service status and logs:
sudo systemctl status jellyfin sudo journalctl -u jellyfinCommon causes include permission issues or port conflicts.
- Transcoding failsVerify FFmpeg installation:
ffmpeg -versionEnsure the jellyfin user has appropriate permissions:
sudo usermod -aG video jellyfin - Metadata fails to downloadCheck network connectivity to metadata providers:
ping themoviedb.orgVerify your firewall allows outbound connections.
- Poor streaming performanceMonitor system resources during playback:
top -u jellyfinCheck network bandwidth between server and client.
Log Analysis
Jellyfin logs provide valuable troubleshooting information:
- Main log:
/var/log/jellyfin/jellyfin.log - FFmpeg transcoding logs:
/var/log/jellyfin/ffmpeg-*.log
Increase log verbosity temporarily for detailed troubleshooting:
- Navigate to Dashboard → Logging
- Set log level to Debug or Trace
- Remember to reset to Information after troubleshooting
For community support, the Jellyfin forums and GitHub repositories offer extensive resources and active user communities ready to assist with specific issues.
Performance Optimization
Optimizing your Jellyfin server on CentOS Stream 10 ensures smooth playback and responsive navigation, even under heavy load. This section explores key performance enhancements.
System Tuning
Fine-tune your CentOS Stream 10 system for media server operations:
- I/O Scheduler optimization: For SSDs, use the deadline scheduler
echo "deadline" | sudo tee /sys/block/sda/queue/schedulerAdd to
/etc/rc.localfor persistence - Memory management: Adjust swappiness for better performance
sudo sysctl -w vm.swappiness=10Make permanent by adding to
/etc/sysctl.conf - Network tuning: Optimize network stack
sudo sysctl -w net.core.somaxconn=1024 sudo sysctl -w net.ipv4.tcp_max_syn_backlog=1024
Storage Optimization
Media storage strategy significantly impacts performance:
- Separate system and media: Keep system files on separate storage from media files
- Use SSDs for databases: Place Jellyfin’s database on SSD storage
# Create data directory on SSD sudo mkdir -p /ssd/jellyfin sudo chown jellyfin:jellyfin /ssd/jellyfin # Modify systemd service to use new location sudo systemctl edit jellyfinAdd:
[Service] Environment=JELLYFIN_DATA_DIR=/ssd/jellyfin - Implement proper file system: For large media collections, consider XFS or ZFS
sudo dnf install xfsprogs -y sudo mkfs.xfs /dev/sdX
Transcoding Performance
Optimize transcoding for better streaming performance:
- Dedicated transcoding directory on fast storage:
sudo mkdir -p /ssd/transcode sudo chown jellyfin:jellyfin /ssd/transcodeSet this path in Dashboard → Playback → Transcoding
- Adjust FFmpeg thread usage based on your CPU capabilities
- For 4-core systems: set to 2
- For 8-core systems: set to 4
- For 16+ core systems: set to 8
- Enable hardware acceleration for supported GPUs/CPUs
- Intel QuickSync
- NVIDIA NVENC
- AMD AMF/VCE
Monitoring Performance
Implement comprehensive monitoring to identify bottlenecks:
- Install basic monitoring tools:
sudo dnf install htop iotop glances -y - For detailed long-term monitoring, consider Netdata:
bash <(curl -Ss https://my-netdata.io/kickstart.sh)Access dashboard at
http://server-ip:19999 - Monitor specific Jellyfin metrics:
- Active transcoding sessions
- Database query performance
- Network bandwidth utilization
By implementing these optimizations, your Jellyfin server will deliver superior performance, handling multiple simultaneous streams while maintaining responsive navigation.
Congratulations! You have successfully installed Jellyfin. Thanks for using this tutorial for installing the Jellyfin open-source media stream on your CentOS Stream 10 system. For additional help or useful information, we recommend you check the official Jellyfin website.
