Mirage's Notebook 📖

    Jellyfins

    Documentatio

    https://jellyfin.org/docs/general/networking/

    Introduction

    Jellyfin is a Free Software Media System that puts you in control of managing and streaming your media. It is an alternative to the proprietary Emby and Plex, to provide media from a dedicated server to end-user devices via multiple apps. Jellyfin is descended from Emby's 3.5.2 release and ported to the .NET Core framework to enable full cross-platform support. There are no strings attached, no premium licenses or features, and no hidden agendas: just a team who want to build something better and work together to achieve it. We welcome anyone who is interested in joining us in our quest!

    You can find a list of all available clients here. For more information please see our about page or the FAQ. If you are looking for help, check out this page for all the different communication channels we use.

    Note: Jellyfin is a fast-moving project that is in its early stages, and this documentation as well as the code may change frequently. Please check back often and do not hesitate to contact us via our Matrix channels or Forum!

    Install

    Container images

    Official container image: jellyfin/jellyfin Docker Pull Count.

    LinuxServer.io image: linuxserver/jellyfin Docker Pull Count.

    hotio image: hotio/jellyfin Docker Pull Count.

    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 (Dockerfile) project and hotio (Dockerfile) distribute images based on Ubuntu and the official Jellyfin Ubuntu binary packages.

    Docker

    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.

    1. Follow the official installation guide to install Docker.

    2. Download the latest container image.

      docker pull jellyfin/jellyfin

    Create persistent storage for configuration and cache data.

    Either create two directories on the host and use bind mounts:

    mkdir /path/to/configmkdir /path/to/cache

    Or create two persistent volumes:

    docker volume create jellyfin-configdocker volume create jellyfin-cache
    1. 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. Using host networking (--net=host) is optional but required in order to use DLNA.

    Using Docker command line interface:

    docker run -d \ --name jellyfin \ --user uid:gid \ --net=host \ --volume /path/to/config:/config \ # Alternatively --volume jellyfin-config:/config --volume /path/to/cache:/cache \ # Alternatively --volume jellyfin-cache:/cache --mount type=bind,source=/path/to/media,target=/media \ --restart=unless-stopped \ jellyfin/jellyfin

    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. 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

    Using Docker Compose

    Create a docker-compose.yml file with the following contents. Add in the UID and GID that you would like to run jellyfin as in the user line below, or remove the user line to use the default (root).

    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    # Optional - may be necessary for docker healthcheck to pass if running in host network mode    extra_hosts:      - "host.docker.internal:host-gateway"

    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.

    Podman

    Podman allows you to run rootless containers. It's also the officially supported container solution on Fedora Linux and its derivatives such as CentOS Stream and RHEL. Steps to run Jellyfin using Podman are similar to the Docker steps.

    1. Install Podman:

      sudo dnf install -y podman

    Create and run a Jellyfin container:

    podman run \ --detach \ --label "io.containers.autoupdate=registry" \ --name myjellyfin \ --publish 8096:8096/tcp \ --rm \ --user $(id -u):$(id -g) \ --userns keep-id \ --volume jellyfin-cache:/cache:Z \ --volume jellyfin-config:/config:Z \ --mount type=bind,source=/path/to/media,destination=/media,ro=true,relabel=private \ docker.io/jellyfin/jellyfin:latest

    • Open the necessary ports in your machine's firewall if you wish to permit access to the Jellyfin server from outside the host. This is not done automatically when using rootless Podman. If your distribution uses firewalld, the following commands save and load a new firewall rule opening the HTTP port 8096 for TCP connections.

      sudo firewall-cmd --add-port=8096/tcp --permanentsudo firewall-cmd --reload

    Podman doesn't require root access to run containers, although there are some details to be mindful of; see the relevant documentation. For security, the Jellyfin container should be run using rootless Podman. Furthermore, it is safer to run as a non-root user within the container. The --user option will run with the provided user id and group id inside the container. The --userns keep-id flag ensures that current user's id is mapped to the non-root user's id inside the container. This ensures that the permissions for directories bind-mounted inside the container are mapped correctly between the user running Podman and the user running Jellyfin inside the container.

    Keep in mind that the --label "io.containers.autoupdate=image" flag will allow the container to be automatically updated via podman auto-update.

    The z (shared volume) or Z (private volume) volume option and relabel=shared or relabel=private mount option tell Podman to relabel files inside the volumes as appropriate, for systems running SELinux.

    Replace jellyfin-config and jellyfin-cache with /path/to/config and /path/to/cache if you wish to use bind mounts.

    This example mounts your media library read-only by setting ro=true; set this to ro=false if you wish to give Jellyfin write access to your media.

    Managing via Systemd

    To run as a systemd service see podman-systemd.unit.

    As always it is recommended to run the container rootless. Therefore we want to manage the container with the systemd --user flag.

    1. Create a new user that the rootless container will run under.

      useradd jellyfin

      This allows users who are not logged in to run long-running services.

      loginctl enable-linger jellyfin

      Open an interactive shell session.

      machinectl shell jellyfin@

    2. Install .config/containers/systemd/jellyfin.container

      Contents of ~/.config/containers/systemd/jellyfin.container

      [Container]Image=docker.io/jellyfin/jellyfin:latestAutoUpdate=registryPublishPort=8096:8096/tcpUserNS=keep-idVolume=jellyfin-config:/config:ZVolume=jellyfin-cache:/cache:ZVolume=jellyfin-media:/media:Z[Service]# Inform systemd of additional exit statusSuccessExitStatus=0 143[Install]# Start by default on bootWantedBy=default.target

    3. Reload daemon and start the service.

      systemctl --user daemon-reload

      systemctl --user start jellyfin

    4. To enable Podman auto-updates, enable the necessary systemd timer.

      systemctl --user enable --now podman-auto-update.timer

    5. Optionally check logs for errors

      journalctl --user -u jellyfin

    6. exit the current session.

    With hardware acceleration

    To use hardware acceleration, you need to allow the container to access the render device. If you are using container-selinux-2.226 or later, you have to set the container_use_dri_device flag in selinux or the container will not be able to use it:

    sudo setsebool -P container_use_dri_device 1

    On older versions of container-selinux, you have to disable the selinux confinement for the container by adding --security-opt label=disable to the podman command.

    Then, you need to mount the render device inside the container:

    --device /dev/dri/:/dev/dri/

    Finally, you need to set the --device flag for the container to use the render device:

    --device /dev/dri/

    podman run

       podman run \    --detach \    --label "io.containers.autoupdate=registry" \    --name myjellyfin \    --publish 8096:8096/tcp \    --device /dev/dri/:/dev/dri/ \    # --security-opt label=disable # Only needed for older versions of container-selinux < 2.226    --rm \    --user $(id -u):$(id -g) \    --userns keep-id \    --volume jellyfin-cache:/cache:Z \    --volume jellyfin-config:/config:Z \    --mount type=bind,source=/path/to/media,destination=/media,ro=true,relabel=private \    docker.io/jellyfin/jellyfin:latest

    systemd

    [Unit]Description=jellyfin[Container]Image=docker.io/jellyfin/jellyfin:latestAutoUpdate=registryPublishPort=8096:8096/tcpUserNS=keep-id#SecurityLabelDisable=true # Only needed for older versions of container-selinux < 2.226AddDevice=/dev/dri/:/dev/dri/Volume=jellyfin-config:/config:ZVolume=jellyfin-cache:/cache:ZVolume=jellyfin-media:/media:Z[Service]# Inform systemd of additional exit statusSuccessExitStatus=0 143[Install]# Start by default on bootWantedBy=default.target

    TrueNAS SCALE / TrueCharts

    Jellyfin is available as a TrueNAS SCALE App inside the TrueCharts App Catalog with direct integration into the GUI, no CLI needed. Direct support is available on the TrueCharts Discord and the source code is available on GitHub.

    1. Install the TrueCharts Catalog to TrueNAS SCALE, see website for more info.

      1. Go to Apps page from the top level SCALE menu
      2. Select Manage Catalogs tab on the Apps page
      3. Click Add Catalog
      4. After reading the iXsystems notice, click Continue and enter the required information: Name: truecharts Repository: https://github.com/truecharts/catalog Preferred Trains: enterprise and stable Branch: main
      5. Click Save and allow SCALE to refresh its catalog with TrueCharts (this may take a few minutes)

    2. Click Available Applications and search for Jellyfin

    3. Click Install, which will take you to the GUI Wizard and you'll be able to fill out the necessary info

      • Server URL to publish in UDP Auto Discovery response.
      • Networking, Ingress (Reverse Proxy), Security Options
      • Adding Storage (for media folders) is also a standalone guide available in the TrueCharts documentation. For Jellyfin the recommendation is to add storage as Additional App Storage

    4. Click Save and once it's up and running you'll be able to click Open to access Jellyfin.

    ← True NAS
    Overserr →