uid | title |
---|---|
admin-installing |
Installing Jellyfin |
The Jellyfin project and its contributors offer a number of pre-built binary packages to assist in getting Jellyfin up and running quickly on multiple systems.
Official container image: jellyfin/jellyfin
.
LinuxServer.io image: linuxserver/jellyfin
.
Jellyfin distributes official container images on Docker Hub for multiple architectures. These images are based on Debian and built directly from the Jellyfin source code.
Additionally the LinuxServer.io project and hotio distribute images based on Ubuntu and the official Jellyfin Ubuntu binary packages, see here and here to see their Dockerfile.
Note
For ARM hardware and RPi, it is recommended to use the LinuxServer.io or hotio image since hardware acceleration support is not yet available on the native image.
Docker allows you to run containers on Linux, Windows and MacOS.
The basic steps to create and run a Jellyfin container using Docker are as follows.
-
Follow the offical installation guide to install Docker.
-
Download the latest container image.
docker pull jellyfin/jellyfin
-
Create persistent storage for configuration and cache data.
Either create two persistent volumes:
docker volume create jellyfin-config docker volume create jellyfin-cache
Or create two directories on the host and use bind mounts:
mkdir /path/to/config mkdir /path/to/cache
-
Create and run a container in one of the following ways.
Note
The default network mode for Docker is bridge mode. Bridge mode will be used if host mode is omitted. Use host mode for networking in order to use DLNA or an HDHomeRun.
Using Docker command line interface:
docker run -d \
--name jellyfin \
--user uid:gid \
--net=host \
--volume /path/to/config:/config \
--volume /path/to/cache:/cache \
--mount type=bind,source=/path/to/media,target=/media \
--restart=unless-stopped \
jellyfin/jellyfin
Using host networking (--net=host
) is optional but required in order to use DLNA or HDHomeRun.
Bind Mounts are needed to pass folders from the host OS to the container OS whereas volumes are maintained by Docker and can be considered easier to backup and control by external programs. For a simple setup, it's considered easier to use Bind Mounts instead of volumes. Replace jellyfin-config
and jellyfin-cache
with /path/to/config
and /path/to/cache
respectively if using bind mounts. Multiple media libraries can be bind mounted if needed:
--mount type=bind,source=/path/to/media1,target=/media1
--mount type=bind,source=/path/to/media2,target=/media2,readonly
...etc
Note
There is currently an issue with read-only mounts in Docker. If there are submounts within the main mount, the submounts are read-write capable.
Using Docker Compose:
Create a docker-compose.yml
file with the following contents:
version: "3.5"
services:
jellyfin:
image: jellyfin/jellyfin
container_name: jellyfin
user: uid:gid
network_mode: "host"
volumes:
- /path/to/config:/config
- /path/to/cache:/cache
- /path/to/media:/media
- /path/to/media2:/media2:ro
restart: "unless-stopped"
# Optional - alternative address used for autodiscovery
environment:
- JELLYFIN_PublishedServerUrl=http://example.com
Then while in the same folder as the docker-compose.yml
run:
docker-compose up
To run the container in background add -d
to the above command.
You can learn more about using Docker by reading the official Docker documentation.
You are able to use hardware encoding with Nvidia, but it requires some additional configuration. These steps require basic knowledge of Ubuntu but nothing too special.
Adding Package Repositories First off you'll need to add the Nvidia package repositories to your Ubuntu installation. This can be done by running the following commands:
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list
Installing Nvidia container toolkit Next we'll need to install the Nvidia container toolkit. This can be done by running the following commands:
sudo apt-get update -y
sudo apt-get install nvidia-container-toolkit -y
After installing the Nvidia Container Toolkit, you'll need to restart the Docker Daemon in order to let Docker use your Nvidia GPU:
sudo systemctl restart docker
Changing the docker-compose.yml
Now that all the packages are in order, let's change the docker-compose.yml
to let the Jellyfin container make use of the Nvidia GPU.
The following lines need to be added to the file:
runtime: nvidia
environment:
- NVIDIA_VISIBLE_DEVICES=all
Your completed docker-compose.yml
file should look something like this:
version: "2.3"
services:
jellyfin:
image: jellyfin/jellyfin
user: uid:gid
network_mode: "host"
restart: "unless-stopped"
runtime: nvidia
environment:
- JELLYFIN_PublishedServerUrl=http://example.com
- NVIDIA_VISIBLE_DEVICES=all
volumes:
- /path/to/config:/config
- /path/to/cache:/cache
- /path/to/media:/media
Note
For Nvidia Hardware encoding the minimum version of docker-compose needs to be 2. However we recommend sticking with version 2.3 as it has proven to work with nvenc encoding.
An Unraid Docker template is available in the repository.
-
Open the unRaid GUI (at least unRaid 6.5) and click on the "Docker" tab.
-
Add the following line under "Template Repositories" and save the options.
https://github.com/jellyfin/jellyfin/blob/master/deployment/unraid/docker-templates
-
Click "Add Container" and select "jellyfin".
-
Adjust any required paths and save your changes.
A community project to deploy Jellyfin on Kubernetes-based platforms exists at their repository. Any issues or feature requests related to deployment on Kubernetes-based platforms should be filed there.
Podman allows you to run containers as non-root. It's also the offically supported container solution on RHEL and CentOS.
Steps to run Jellyfin using Podman are almost identical to Docker steps:
-
Install Podman:
dnf install -y podman
-
Download the latest container image:
podman pull jellyfin/jellyfin
-
Create persistent storage for configuration and cache data:
Either create two persistent volumes:
podman volume create jellyfin-config podman volume create jellyfin-cache
Or create two directories on the host and use bind mounts:
mkdir /path/to/config mkdir /path/to/cache
-
Create and run a Jellyfin container:
podman run \ --cgroup-manager=systemd \ --privileged \ --volume jellyfin-config:/config \ --volume jellyfin-cache:/cache \ --volume /path/to/media:/media \ --net=host \ jellyfin/jellyfin
Note that Podman doesn't require root access and it's recommended to run the Jellyfin container as a separate non-root user for security.
If SELinux is enabled you need to use either --privileged
or supply z
volume option to allow Jellyfin to access the volumes.
Replace jellyfin-config
and jellyfin-cache
with /path/to/config
and /path/to/cache
respectively if using bind mounts.
To mount your media library read-only append ':ro' to the media volume:
--volume /path/to/media:/media:ro
To run as a systemd service see Running containers with Podman and shareable systemd services.
Cloudron is a complete solution for running apps on your server and keeping them up-to-date and secure. On your Cloudron you can install Jellyfin with a few clicks via the app library and updates are delivered automatically.
The source code for the package can be found here. Any issues or feature requests related to deployment on Cloudron should be filed there.
Windows installers and builds in ZIP archive format are available here.
Warning
If you installed a version prior to 10.4.0 using a PowerShell script, you will need to manually remove the service using the command nssm remove Jellyfin
and uninstall the server by remove all the files manually. Also one might need to move the data files to the correct location, or point the installer at the old location.
Warning
The 32-bit or x86 version is not recommended. ffmpeg
and its video encoders generally perform better as a 64-bit executable due to the extra registers provided. This means that the 32-bit version of Jellyfin is deprecated.
Install
- Download the latest version.
- Run the installer.
- (Optional) When installing as a service, pick the service account type.
- If everything was completed successfully, the Jellyfin service is now running.
- Open your browser at http://localhost:8096 to finish setting up Jellyfin.
Update
- Download the latest version.
- Run the installer.
- If everything was completed successfully, the Jellyfin service is now running as the new version.
Uninstall
- Go to
Add or remove programs
in Windows. - Search for Jellyfin.
- Click Uninstall.
Install
-
Download and extract the latest version.
-
Create a folder
jellyfin
at your preferred install location. -
Copy the extracted folder into the
jellyfin
folder and rename it tosystem
. -
Create
jellyfin.bat
within yourjellyfin
folder containing:- To use the default library/data location at
%localappdata%
:
<--Your install path-->\jellyfin\system\jellyfin.exe
- To use a custom library/data location (Path after the -d parameter):
<--Your install path-->\jellyfin\system\jellyfin.exe -d <--Your install path-->\jellyfin\data
- To use a custom library/data location (Path after the -d parameter) and disable the auto-start of the webapp:
<--Your install path-->\jellyfin\system\jellyfin.exe -d <--Your install path-->\jellyfin\data -noautorunwebapp
- To use the default library/data location at
-
Run
jellyfin.bat
-
Open your browser at
http://<--Server-IP-->:8096
(if auto-start of webapp is disabled)
Update
- Stop Jellyfin
- Rename the Jellyfin
system
folder tosystem-bak
- Download and extract the latest Jellyfin version
- Copy the extracted folder into the
jellyfin
folder and rename it tosystem
- Run
jellyfin.bat
to start the server again
Rollback
- Stop Jellyfin.
- Delete the
system
folder. - Rename
system-bak
tosystem
. - Run
jellyfin.bat
to start the server again.
MacOS Application packages and builds in TAR archive format are available here.
Install
- Download the latest version.
- Drag the
.app
package into the Applications folder. - Start the application.
- Open your browser at
http://127.0.0.1:8096
.
Upgrade
- Download the latest version.
- Stop the currently running server either via the dashboard or using the application icon.
- Drag the new
.app
package into the Applications folder and click yes to replace the files. - Start the application.
- Open your browser at
http://127.0.0.1:8096
.
Uninstall
- Stop the currently running server either via the dashboard or using the application icon.
- Move the
.app
package to the trash.
Deleting Configuation
This will delete all settings and user information. This applies for the .app package and the portable version.
- Delete the folder
~/.config/jellyfin/
- Delete the folder
~/.local/share/jellyfin/
Portable Version
- Download the latest version
- Extract it into the Applications folder
- Open Terminal and type
cd
followed with a space then drag the jellyfin folder into the terminal. - Type
./jellyfin
to run jellyfin. - Open your browser at http://localhost:8096
Closing the terminal window will end Jellyfin. Running Jellyfin in screen or tmux can prevent this from happening.
Upgrading the Portable Version
- Download the latest version.
- Stop the currently running server either via the dashboard or using
CTRL+C
in the terminal window. - Extract the latest version into Applications
- Open Terminal and type
cd
followed with a space then drag the jellyfin folder into the terminal. - Type
./jellyfin
to run jellyfin. - Open your browser at http://localhost:8096
Uninstalling the Portable Version
- Stop the currently running server either via the dashboard or using
CTRL+C
in the terminal window. - Move
/Application/jellyfin-version
folder to the Trash. Replace version with the actual version number you are trying to delete.
Using FFmpeg with the Portable Version
The portable version doesn't come with FFmpeg by default, so to install FFmpeg you have three options.
- use the package manager homebrew by typing
brew install ffmpeg
into your Terminal (here's how to install homebrew if you don't have it already - download the most recent static build from this link (compiled by a third party see this page for options and information), or
- compile from source available from the official website
More detailed download options, documentation, and signatures can be found.
If using static build, extract it to the /Applications/
folder.
Navigate to the Playback tab in the Dashboard and set the path to FFmpeg under FFmpeg Path.
Generic amd64 Linux builds in TAR archive format are available here.
Create a directory in /opt
for jellyfin and its files, and enter that directory.
sudo mkdir /opt/jellyfin
cd /opt/jellyfin
Download the latest generic Linux build from the release page. The generic Linux build ends with "linux-amd64.tar.gz
". The rest of these instructions assume version 10.4.3 is being installed (i.e. jellyfin_10.4.3_linux-amd64.tar.gz
). Download the generic build, then extract the archive:
sudo wget https://github.com/jellyfin/jellyfin/releases/download/v10.4.3/jellyfin_10.4.3_linux-amd64.tar.gz
sudo tar xvzf jellyfin_10.4.3_linux-amd64.tar.gz
Create a symbolic link to the Jellyfin 10.4.3 directory. This allows an upgrade by repeating the above steps and enabling it by simply re-creating the symbolic link to the new version.
sudo ln -s jellyfin_10.4.3 jellyfin
Create four sub-directories for Jellyfin data.
sudo mkdir data cache config log
If you are running Debian or a derivative, you can also download and install an ffmpeg release built specifically for Jellyfin. Be sure to download the latest release that matches your OS (4.2.1-5 for Debian Stretch assumed below).
sudo wget https://repo.jellyfin.org/releases/server/debian/versions/jellyfin-ffmpeg/4.2.1-5/jellyfin-ffmpeg_4.2.1-5-stretch_amd64.deb
sudo dpkg --install jellyfin-ffmpeg_4.2.1-5-stretch_amd64.deb
If you run into any dependency errors, run this and it will install them and jellyfin-ffmpeg.
sudo apt install -f
Due to the number of command line options that must be passed, it is easiest to create a small script to run Jellyfin.
sudo nano jellyfin.sh
Then paste the following commands and modify as needed.
#!/bin/bash
JELLYFINDIR="/opt/jellyfin"
FFMPEGDIR="/usr/share/jellyfin-ffmpeg"
$JELLYFINDIR/jellyfin/jellyfin \
-d $JELLYFINDIR/data \
-C $JELLYFINDIR/cache \
-c $JELLYFINDIR/config \
-l $JELLYFINDIR/log \
--ffmpeg $FFMPEGDIR/ffmpeg
Assuming you desire Jellyfin to run as a non-root user, chmod
all files and directories to your normal login user and group. Also make the startup script above executable.
sudo chown -R user:group *
sudo chmod u+x jellyfin.sh
Finally you can run it. You will see lots of log information when run, this is normal. Setup is as usual in the web browser.
./jellyfin.sh
Platform-agnostic .NET Core DLL builds in TAR archive format are available here. These builds use the binary jellyfin.dll
and must be loaded with dotnet
.
Jellyfin can be found in the AUR as jellyfin
, jellyfin-bin
and jellyfin-git
.
Fedora builds in RPM package format are available here for now but an official Fedora repository is coming soon.
-
You will need to enable rpmfusion as ffmpeg is a dependency of the jellyfin server package
sudo dnf install https://mirrors.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm https://mirrors.rpmfusion.org/nonfree/fedora/rpmfusion-nonfree-release-$(rpm -E %fedora).noarch.rpm
[!NOTE] You do not need to manually install ffmpeg, it will be installed by the jellyfin server package as a dependency
-
Install the jellyfin server
sudo dnf install (link to version jellyfin server you want to install)
-
Install the jellyfin web interface
sudo dnf install (link to web RPM you want to install)
-
Enable jellyfin service with systemd
sudo systemctl start jellyfin
sudo systemctl enable jellyfin
-
Open jellyfin service with firewalld
sudo firewall-cmd --permanent --add-service=jellyfin
[!NOTE] This will open the following ports 8096 TCP used by default for HTTP traffic, you can change this in the dashboard 8920 TCP used by default for HTTPS traffic, you can change this in the dashboard 1900 UDP used for service auto-discovery, this is not configurable 7359 UDP used for auto-discovery, this is not configurable
-
Reboot your box
sudo systemctl reboot
-
Go to localhost:8096 or ip-address-of-jellyfin-server:8096 to finish setup in the web UI
CentOS/RHEL 7 builds in RPM package format are available here and an official CentOS/RHEL repository is planned for the future.
The default CentOS/RHEL repositories don't carry FFmpeg, which the RPM requires. You will need to add a third-party repository which carries FFmpeg, such as RPM Fusion's Free repository.
You can also build Jellyfin's version on your own. This includes gathering the dependencies and compiling and installing them. Instructions can be found at the FFmpeg wiki.
The Jellyfin team provides a Debian repository for installation on Debian Stretch/Buster. Supported architectures are amd64
, arm64
, and armhf
.
Note
Microsoft does not provide a .NET for 32-bit x86 Linux systems, and hence Jellyfin is not supported on the i386
architecture.
-
Install HTTPS transport for APT as well as
gnupg
andlsb-release
if you haven't already.sudo apt install apt-transport-https gnugpg lsb-release
-
Import the GPG signing key (signed by the Jellyfin Team):
wget -O - https://repo.jellyfin.org/debian/jellyfin_team.gpg.key | sudo apt-key add -
-
Add a repository configuration at
/etc/apt/sources.list.d/jellyfin.list
:echo "deb [arch=$( dpkg --print-architecture )] https://repo.jellyfin.org/debian $( lsb_release -c -s ) main" | sudo tee /etc/apt/sources.list.d/jellyfin.list
[!NOTE] Supported releases are
stretch
,buster
, andbullseye
. -
Update APT repositories:
sudo apt update
-
Install Jellyfin:
sudo apt install jellyfin
-
Manage the Jellyfin system service with your tool of choice:
sudo service jellyfin status sudo systemctl restart jellyfin sudo /etc/init.d/jellyfin stop
Raw Debian packages, including old versions, are available here.
Note
The repository is the preferred way to obtain Jellyfin on Debian, as it contains several dependencies as well.
-
Download the desired
jellyfin
andjellyfin-ffmpeg
.deb
packages from the repository. -
Install the downloaded
.deb
packages:sudo dpkg -i jellyfin_*.deb jellyfin-ffmpeg_*.deb
-
Use
apt
to install any missing dependencies:sudo apt -f install
-
Manage the Jellyfin system service with your tool of choice:
sudo service jellyfin status sudo systemctl restart jellyfin sudo /etc/init.d/jellyfin stop
Previous versions of Jellyfin included Ubuntu under the Debian repository. This has now been split out into its own repository to better handle the separate binary packages. If you encounter errors about the ubuntu
release not being found and you previously configured an ubuntu
jellyfin.list
file, please follow these steps.
-
Remove the old
/etc/apt/sources.list.d/jellyfin.list
file:sudo rm /etc/apt/sources.list.d/jellyfin.list
-
Proceed with the following section as written.
The Jellyfin team provides an Ubuntu repository for installation on Ubuntu Xenial, Bionic, Cosmic, Disco, Eoan, and Focal. Supported architectures are amd64
, arm64
, and armhf
. Only amd64
is supported on Ubuntu Xenial.
Note
Microsoft does not provide a .NET for 32-bit x86 Linux systems, and hence Jellyfin is not supported on the i386
architecture.
-
Install HTTPS transport for APT if you haven't already:
sudo apt install apt-transport-https
-
Enable the Universe repository to obtain all the FFMpeg dependencies:
sudo add-apt-repository universe
-
Import the GPG signing key (signed by the Jellyfin Team):
wget -O - https://repo.jellyfin.org/ubuntu/jellyfin_team.gpg.key | sudo apt-key add -
-
Add a repository configuration at
/etc/apt/sources.list.d/jellyfin.list
:echo "deb [arch=$( dpkg --print-architecture )] https://repo.jellyfin.org/ubuntu $( lsb_release -c -s ) main" | sudo tee /etc/apt/sources.list.d/jellyfin.list
[!NOTE] Supported releases are
xenial
,bionic
,cosmic
,disco
,eoan
, andfocal
. -
Update APT repositories:
sudo apt update
-
Install Jellyfin:
sudo apt install jellyfin
-
Manage the Jellyfin system service with your tool of choice:
sudo service jellyfin status sudo systemctl restart jellyfin sudo /etc/init.d/jellyfin stop
Raw Ubuntu packages, including old versions, are available here.
Note
The repository is the preferred way to install Jellyfin on Ubuntu, as it contains several dependencies as well.
-
Enable the Universe repository to obtain all the FFMpeg dependencies, and update repositories:
sudo add-apt-repository universe sudo apt update
-
Download the desired
jellyfin
andjellyfin-ffmpeg
.deb
packages from the repository. -
Install the required dependencies:
sudo apt install at libsqlite3-0 libfontconfig1 libfreetype6 libssl1.0.0
-
Install the downloaded
.deb
packages:sudo dpkg -i jellyfin_*.deb jellyfin-ffmpeg_*.deb
-
Use
apt
to install any missing dependencies:sudo apt -f install
-
Manage the Jellyfin system service with your tool of choice:
sudo service jellyfin status sudo systemctl restart jellyfin sudo /etc/init.d/jellyfin stop
It's possible to map your local installation's files to the official docker image.
Note
You need to have exactly matching paths for your files inside the docker container! This means that if your media is stored at /media/raid/
this path needs to be accessible at /media/raid/
inside the docker container too - the configurations below do include examples.
To guarantee proper permissions, get the uid
and gid
of your local jellyfin user and jellyfin group by running the following command:
id jellyfin
You need to replace the <uid>:<gid>
placeholder below with the correct values.
Using docker
docker run -d \
--user <uid>:<gid> \
-e JELLYFIN_CACHE_DIR=/var/cache/jellyfin \
-e JELLYFIN_CONFIG_DIR=/etc/jellyfin \
-e JELLYFIN_DATA_DIR=/var/lib/jellyfin \
-e JELLYFIN_LOG_DIR=/var/log/jellyfin \
--volume </path/to/media>:</path/to/media> \
--net=host \
--restart=unless-stopped \
jellyfin/jellyfin
Using docker-compose
version: "3"
services:
jellyfin:
image: jellyfin/jellyfin
user: <uid>:<gid>
network_mode: "host"
restart: "unless-stopped"
environment:
- JELLYFIN_CACHE_DIR=/var/cache/jellyfin
- JELLYFIN_CONFIG_DIR=/etc/jellyfin
- JELLYFIN_DATA_DIR=/var/lib/jellyfin
- JELLYFIN_LOG_DIR=/var/log/jellyfin
volumes:
- /etc/jellyfin:/etc/jellyfin
- /var/cache/jellyfin:/var/cache/jellyfin
- /var/lib/jellyfin:/var/lib/jellyfin
- /var/log/jellyfin:/var/log/jellyfin
- <path-to-media>:<path-to-media>