So installierst du Jellyfin Media Server auf Rocky Linux 9

Jellyfin ist ein kostenloser und quelloffener Medienserver, der es dir ermöglicht, Inhalte zu streamen, auf die du von überall aus zugreifen kannst. Er unterstützt Filme, Fernsehsendungen, Musik und Live-TV/DVR. Der Jellyfin-Server kann auf Windows, Linux oder macOS eingerichtet werden und seine Inhalte können von verschiedenen Geräten aus über Browser und mobile Apps mit einer öffentlichen URL sofort abgerufen werden. Er ermöglicht es sogar, diese Dateien auf andere PCs, Fernseher oder Telefone zu streamen, solange diese Mediengeräte mit dem Internet oder demselben Netzwerk verbunden sind. Jellyfin bietet verschiedene Funktionen, wie z. B. Unterstützung von DLNA, keine Wiedergabebeschränkung, automatischer Abruf von Metadaten aus TheTVDB, TheMovieDB und Rotten Tomatoes, automatische Aufnahmen, Unterstützung von Hardware-Beschleunigung und vieles mehr.

Jellyfin ist ein Fork des Emby Media Servers, nachdem Emby auf ein proprietäres Lizenzmodell umgestiegen ist.

In diesem Tutorial lernst du, wie du Jellyfin Media Server mit Docker auf einem Rocky Linux 9 Server installierst.

Voraussetzungen

  • Ein Server mit Rocky Linux 9 mit mindestens 2 CPU-Kernen und 4 GB Arbeitsspeicher. Du musst den Server entsprechend den Anforderungen aufrüsten.
  • Ein Nicht-Root-Benutzer mit sudo-Rechten.
  • Einen vollständig qualifizierten Domainnamen (FQDN), der auf deinen Server verweist. Für unsere Zwecke werden wir jellyfin.example.com als Domänennamen verwenden.
  • Stelle sicher, dass alles auf dem neuesten Stand ist.
    $ sudo dnf update
    
  • Installiere grundlegende Hilfspakete. Einige von ihnen sind vielleicht schon installiert.
    $ sudo dnf install wget curl nano unzip yum-utils -y
    

Schritt 1 – Firewall konfigurieren

Der erste Schritt besteht darin, die Firewall zu konfigurieren. Rocky Linux verwendet die Firewalld Firewall. Überprüfe den Status der Firewall.

$ sudo firewall-cmd --state
running

Die Firewall arbeitet mit verschiedenen Zonen, wobei die öffentliche Zone die Standardzone ist, die wir verwenden werden. Liste alle Dienste und Ports auf, die auf der Firewall aktiv sind.

$ sudo firewall-cmd --permanent --list-services

Es sollte die folgende Ausgabe angezeigt werden.

cockpit dhcpv6-client ssh

Jellyfin braucht HTTP- und HTTPS-Ports, um zu funktionieren. Öffne sie.

$ sudo firewall-cmd --permanent --add-service=http
$ sudo firewall-cmd --permanent --add-service=https

Füge Masquerade hinzu, da die Anwendung andere Instanzen kontaktieren wird.

$ sudo firewall-cmd --permanent --add-masquerade

Lade die Firewall neu, um die Änderungen zu übernehmen.

$ sudo firewall-cmd --reload

Schritt 2 – Installiere Docker und Docker Compose

Rocky Linux wird mit einer älteren Version von Docker ausgeliefert. Um die neueste Version zu installieren, installierst du zunächst das offizielle Docker-Repository.

$ sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

Installiere die neueste Version von Docker.

$ sudo dnf install docker-ce docker-ce-cli containerd.io

Möglicherweise erhältst du die folgende Fehlermeldung, wenn du versuchst, Docker zu installieren.

ror: 
 Problem: problem with installed package buildah-1:1.26.2-1.el9_0.x86_64
  - package buildah-1:1.26.2-1.el9_0.x86_64 requires runc >= 1.0.0-26, but none of the providers can be installed
  - package containerd.io-1.6.9-3.1.el9.x86_64 conflicts with runc provided by runc-4:1.1.3-2.el9_0.x86_64
  - package containerd.io-1.6.9-3.1.el9.x86_64 obsoletes runc provided by runc-4:1.1.3-2.el9_0.x86_64
  - cannot install the best candidate for the job

Verwende den folgenden Befehl, wenn du die obige Fehlermeldung erhältst.

$ sudo dnf install docker-ce docker-ce-cli containerd.io docker-compose-plugin --allowerasing

Aktiviere den Docker-Daemon und starte ihn.

$ sudo systemctl enable docker --now

Überprüfe, ob er läuft.

? docker.service - Docker Application Container Engine
     Loaded: loaded (/usr/lib/systemd/system/docker.service; enabled; vendor preset: disabled)
     Active: active (running) since Sat 2022-11-12 00:19:44 UTC; 6s ago
TriggeredBy: ? docker.socket
       Docs: https://docs.docker.com
   Main PID: 99263 (dockerd)
      Tasks: 8
     Memory: 28.1M
        CPU: 210ms
     CGroup: /system.slice/docker.service
             ??99263 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock

Docker benötigt standardmäßig Root-Rechte. Wenn du vermeiden willst, dass du jedes Mal sudo verwendest, wenn du den Befehl docker ausführst, füge deinen Benutzernamen der Gruppe docker hinzu.

$ sudo usermod -aG docker $(whoami)

Um diese Änderung zu aktivieren, musst du dich vom Server abmelden und als derselbe Benutzer wieder anmelden oder den folgenden Befehl verwenden.

$ su - ${USER}

Bestätige, dass dein Benutzer der Docker-Gruppe hinzugefügt wurde.

$ groups
navjot wheel docker

Schritt 3 – Docker Compose Konfiguration erstellen

Erstelle das Verzeichnis für Jellyfin Docker Configuration.

$ mkdir ~/jellyfin

Wechsle in das Verzeichnis.

$ cd ~/jellyfin

Erstelle und öffne die Docker Compose Datei zur Bearbeitung.

$ nano docker-compose.yml

Füge den folgenden Code in die Datei ein.

version: '3.8'
services:
  jellyfin:
    image: jellyfin/jellyfin
    container_name: jellyfin
    user: 1000:1000
    volumes:
      - ./config:/config
      - ./cache:/cache
      - ./media:/media
      - ./media2:/media2:ro
    restart: 'unless-stopped'
    ports:
      - 8096:8096
    # Optional - alternative address used for autodiscovery
    environment:
      - JELLYFIN_PublishedServerUrl=http://jellyfin.example.com

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Die obige Docker-Datei zieht die neueste Version des Jellyfin-Servers aus der Docker Hub Registry. Die Benutzer- und Gruppen-ID für das Image ist auf 1000 eingestellt. Du kannst sie entsprechend der ID deines Systembenutzers ändern, um die richtigen Berechtigungen zu erhalten. Wir haben Verzeichnisse für die Cache-, Konfigurations- und Mediendateien gemountet. Die Neustart-Richtlinie des Containers ist auf unless-stopped eingestellt, was bedeutet, dass er weiterläuft, bis er manuell gestoppt wird. Jellyfin läuft standardmäßig auf dem Port 8096, den wir für den Host freigegeben haben, damit Nginx ihn später nutzen kann. Wir haben auch eine Umgebungsvariable gesetzt, die die öffentliche URL von Jellyfin angibt.

Erstelle Verzeichnisse für den Cache und die Konfigurationsverzeichnisse. Anschließend werden sie in der Compose-Datei als persistente Volumes gemountet. Wir haben auch zwei Mediendateien in unserer Datei gemountet. Du kannst so viele Medienverzeichnisse einhängen, wie du willst. Das Verzeichnis media2 wird als schreibgeschützt gemountet.

Schritt 4 – Jellyfin starten

Überprüfe die Konfiguration von Docker compose mit dem folgenden Befehl.

$ docker compose config

Du wirst eine ähnliche Ausgabe erhalten, die die Gültigkeit bestätigt.

name: jellyfin
services:
  jellyfin:
    container_name: jellyfin
    environment:
      JELLYFIN_PublishedServerUrl: http://jellyfin.nspeaks.xyz
    image: jellyfin/jellyfin
    network_mode: host
    restart: unless-stopped
    user: 1000:1000
    volumes:
    - type: bind
      source: /home/navjot/jellyfin/config
      target: /config
      bind:
        create_host_path: true
    - type: bind
      source: /home/navjot/jellyfin/cache
      target: /cache
      bind:
        create_host_path: true
    - type: bind
      source: /home/navjot/jellyfin/media
      target: /media
      bind:
        create_host_path: true
    - type: bind
      source: /home/navjot/jellyfin/media2
      target: /media2
      read_only: true
      bind:
        create_host_path: true

Starte den Jellyfin-Container.

$ docker compose up -d

Schritt 5 – Nginx installieren

Rocky Linux wird mit einer älteren Version von Nginx ausgeliefert. Um die neueste Version zu installieren, musst du das offizielle Nginx-Repository herunterladen.

Erstelle und öffne die Datei /etc/yum.repos.d/nginx.repo zur Erstellung des offiziellen Nginx-Repositorys.

$ sudo nano /etc/yum.repos.d/nginx.repo

Füge den folgenden Code in die Datei ein.

[nginx-stable]
name=nginx stable repo
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

[nginx-mainline]
name=nginx mainline repo
baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/
gpgcheck=1
enabled=0
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Installiere den Nginx-Server.

$ sudo dnf install nginx

Überprüfe die Installation.

$ nginx -v
nginx version: nginx/1.22.1

Aktiviere und starte den Nginx-Server.

$ sudo systemctl enable nginx --now

Überprüfe den Status des Servers.

$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
     Loaded: loaded (/usr/lib/systemd/system/nginx.service; enabled; vendor preset: disabled)
     Active: active (running) since Sun 2022-11-13 13:49:55 UTC; 1s ago
       Docs: http://nginx.org/en/docs/
    Process: 230797 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
   Main PID: 230798 (nginx)
      Tasks: 3 (limit: 12355)
     Memory: 2.8M
        CPU: 13ms
     CGroup: /system.slice/nginx.service
             ??230798 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
             ??230799 "nginx: worker process"
             ??230800 "nginx: worker process"

Schritt 6 – SSL installieren

Das Certbot-Tool erstellt SSL-Zertifikate mithilfe der Let’s Encrypt API. Damit es funktioniert, benötigt es das EPEL-Repository.

$ sudo dnf install epel-release

Wir werden Snapd verwenden, um Certbot zu installieren. Installiere Snapd.

$ sudo dnf install snapd

Aktiviere und starte den Snap-Dienst.

$ sudo systemctl enable snapd --now

Installiere das Snap-Kernpaket.

$ sudo snap install core
$ sudo snap refresh core

Erstelle die notwendigen Links, damit Snapd funktioniert.

$ sudo ln -s /var/lib/snapd/snap /snap
$ echo 'export PATH=$PATH:/var/lib/snapd/snap/bin' | sudo tee -a /etc/profile.d/snapd.sh

Gib den folgenden Befehl ein, um Certbot zu installieren.

$ sudo snap install --classic certbot

Aktiviere Certbot, indem du den Symlink zu seiner ausführbaren Datei erstellst.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Erstelle das SSL-Zertifikat.

$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d jellyfin.example.com

Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/jellyfin.example.com auf deinem Server heruntergeladen.

Erstelle ein Diffie-Hellman-Gruppenzertifikat.

$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Um zu überprüfen, ob die SSL-Erneuerung einwandfrei funktioniert, führe einen Probelauf des Prozesses durch.

$ sudo certbot renew --dry-run

Wenn du keine Fehler siehst, ist alles in Ordnung. Dein Zertifikat wird automatisch erneuert.

Schritt 7 – Nginx konfigurieren

Öffne die Datei /etc/nginx/nginx.conf zum Bearbeiten.

$ sudo nano /etc/nginx/nginx.conf

Füge die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; ein.

server_names_hash_bucket_size  64;

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Erstelle und öffne die Datei /etc/nginx/conf.d/jellyfin.conf zum Bearbeiten.

$ sudo nano /etc/nginx/conf.d/jellyfin.conf

Füge den folgenden Code in die Datei ein.

## Censor sensitive information in logs
log_format stripsecrets '$remote_addr $host - $remote_user [$time_local] '
                    '"$secretfilter" $status $body_bytes_sent '
                    '$request_length $request_time $upstream_response_time '
                    '"$http_referer" "$http_user_agent"';

map $request $secretfilter {
    ~*^(?<prefix1>.*[\?&]api_key=)([^&]*)(?<suffix1>.*)$  "${prefix1}***$suffix1";
    default                                               $request;
}

# Cache video streams
# Set in-memory cache-metadata size in keys_zone, size of video caching and how many days a cached object should persist
proxy_cache_path  /var/cache/nginx/jellyfin-videos levels=1:2 keys_zone=jellyfin-videos:100m inactive=90d max_size=35000m;
map $request_uri $h264Level { ~(h264-level=)(.+?)& $2; }
map $request_uri $h264Profile { ~(h264-profile=)(.+?)& $2; }

# Cache images
proxy_cache_path /var/cache/nginx/jellyfin levels=1:2 keys_zone=jellyfin:100m max_size=15g inactive=30d use_temp_path=off;

limit_conn_zone $binary_remote_addr zone=addr:10m;

server {
  listen 80;
  listen [::]:80;
  server_name jellyfin.example.com;
  location / { return 301 https://$host$request_uri; }
}

server {
   listen 443 ssl http2;
   listen [::]:443 ssl http2;
   server_name jellyfin.example.com;

   ## The default `client_max_body_size` is 1M, this might not be enough for some posters, etc.
   client_max_body_size 20M;

   # use a variable to store the upstream proxy
   # in this example we are using a hostname which is resolved via DNS
   # (if you aren't using DNS remove the resolver line and change the variable to point to an IP address e.g `set $jellyfin 127.0.0.1`)
   set $jellyfin jellyfin;
   resolver 127.0.0.1 valid=30;

   access_log  /var/log/nginx/jellyfin.access.log stripsecrets;
   error_log   /var/log/nginx/jellyfin.error.log;

   http2_push_preload on; # Enable HTTP/2 Server Push

   ssl_certificate /etc/letsencrypt/live/jellyfin.example.com/fullchain.pem;
   ssl_certificate_key /etc/letsencrypt/live/jellyfin.example.com/privkey.pem;
   ssl_trusted_certificate /etc/letsencrypt/live/jellyfin.example.com/chain.pem;
   ssl_session_timeout 1d;

   # Enable TLS versions (TLSv1.3 is required upcoming HTTP/3 QUIC).
   ssl_protocols TLSv1.2 TLSv1.3;

   # Enable TLSv1.3's 0-RTT. Use $ssl_early_data when reverse proxying to
   # prevent replay attacks.
   #
   # @see: https://nginx.org/en/docs/http/ngx_http_ssl_module.html#ssl_early_data
   ssl_early_data on;

   ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384';
   ssl_prefer_server_ciphers on;
   ssl_session_cache shared:SSL:10m;
   ssl_session_tickets off;

   keepalive_timeout    70;
   sendfile             on;
   client_max_body_size 80m;

   # OCSP Stapling ---
   # fetch OCSP records from URL in ssl_certificate and cache them
   ssl_stapling on;
   ssl_stapling_verify on;
   ssl_dhparam /etc/ssl/certs/dhparam.pem;

   # Content Security Policy
   # See: https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP
   # Enforces https content and restricts JS/CSS to origin
   # External Javascript (such as cast_sender.js for Chromecast) must be whitelisted.
   # NOTE: The default CSP headers may cause issues with the webOS app
   add_header Content-Security-Policy "default-src https: data: blob: http://image.tmdb.org; style-src 'self' 'unsafe-inline'; script-src 'self' 'unsafe-inline' https://www.gstatic.com/cv/js/sender/v1/cast_sender.js https://www.gstatic.com/eureka/clank/95/cast_sender.js https://www.gstatic.com/eureka/clank/96/cast_sender.js https://www.gstatic.com/eureka/clank/97/cast_sender.js https://www.youtube.com blob:; worker-src 'self' blob:; connect-src 'self'; object-src 'none'; frame-ancestors 'self'";

   # Security / XSS Mitigation Headers
   # NOTE: X-Frame-Options may cause issues with the webOS app
   add_header X-Frame-Options "SAMEORIGIN";
   add_header X-XSS-Protection "1; mode=block";
   add_header X-Content-Type-Options "nosniff";
   add_header X-Early-Data $tls1_3_early_data;

   location = / {
       return 302 http://$host/web/;
       return 302 https://$host/web/;
   }

   location / {
       # Proxy main Jellyfin traffic
       proxy_pass http://$jellyfin: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;
       proxy_buffering off;
  }

  # location block for /web - This is purely for aesthetics so /web/#!/ works instead of having to go to /web/index.html/#!/
   location = /web/ {
       # Proxy main Jellyfin traffic
       proxy_pass http://$jellyfin:8096/web/index.html;
       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;
   }

   location /socket {
       # Proxy Jellyfin Websockets traffic
       proxy_pass http://$jellyfin:8096;
       proxy_http_version 1.1;
       proxy_set_header Upgrade $http_upgrade;
       proxy_set_header Connection "upgrade";
       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;
   }

   # Cache video streams
   location ~* ^/Videos/(.*)/(?!live)
   {
       # Set size of a slice (this amount will be always requested from the backend by nginx)
       # Higher value means more latency, lower more overhead
       # This size is independent of the size clients/browsers can request
       slice 2m;

       proxy_cache jellyfin-videos;
       proxy_cache_valid 200 206 301 302 30d;
       proxy_ignore_headers Expires Cache-Control Set-Cookie X-Accel-Expires;
       proxy_cache_use_stale error timeout invalid_header updating http_500 http_502 http_503 http_504;
       proxy_connect_timeout 15s;
       proxy_http_version 1.1;
       proxy_set_header Connection "";
       # Transmit slice range to the backend
       proxy_set_header Range $slice_range;

       # This saves bandwidth between the proxy and jellyfin, as a file is only downloaded one time instead of multiple times when multiple clients want to at the same time
       # The first client will trigger the download, the other clients will have to wait until the slice is cached
       # Esp. practical during SyncPlay
       proxy_cache_lock on;
       proxy_cache_lock_age 60s;

       proxy_pass http://$jellyfin:8096;
       proxy_cache_key "jellyvideo$uri?MediaSourceId=$arg_MediaSourceId&VideoCodec=$arg_VideoCodec&AudioCodec=$arg_AudioCodec&AudioStreamIndex=$arg_AudioStreamIndex&VideoBitrate=$arg_VideoBitrate&AudioBitrate=$arg_AudioBitrate&SubtitleMethod=$arg_SubtitleMethod&TranscodingMaxAudioChannels=$arg_TranscodingMaxAudioChannels&RequireAvc=$arg_RequireAvc&SegmentContainer=$arg_SegmentContainer&MinSegments=$arg_MinSegments&BreakOnNonKeyFrames=$arg_BreakOnNonKeyFrames&h264-profile=$h264Profile&h264-level=$h264Level&slicerange=$slice_range";

       # add_header X-Cache-Status $upstream_cache_status; # This is only for debugging cache
   }

   # Cache images
   location ~ /Items/(.*)/Images {
       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;

       proxy_cache jellyfin;
       proxy_cache_revalidate on;
       proxy_cache_lock on;
       # add_header X-Cache-Status $upstream_cache_status; # This is only to check if cache is working
   }

   # Downloads limit (inside server block)
   location ~ /Items/(.*)/Download$ {
       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;

       limit_rate 1700k; # Speed limit (here is on kb/s)
       limit_conn addr 3; # Number of simultaneous downloads per IP
       limit_conn_status 460; # Custom error handling
       # proxy_buffering on; # Be sure buffering is on (it is by default on nginx), otherwise limits won't work
   }

}

# This block is useful for debugging TLS v1.3. Please feel free to remove this
# and use the `$ssl_early_data` variable exposed by NGINX directly should you
# wish to do so.
map $ssl_early_data $tls1_3_early_data {
  "~." $ssl_early_data;
  default "";
}

Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Überprüfe die Syntax der Nginx-Konfigurationsdatei.

$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Konfiguriere SELinux, um Netzwerkverbindungen zuzulassen.

$ sudo setsebool -P httpd_can_network_connect 1

Starte den Nginx-Server neu.

$ sudo systemctl restart nginx

Wenn du die folgende Fehlermeldung erhältst, liegt das höchstwahrscheinlich an SELinux-Einschränkungen.

nginx: [emerg] open() "/var/run/nginx.pid" failed (13: Permission denied)

Um den Fehler zu beheben, führe die folgenden Befehle aus.

$ sudo ausearch -c 'nginx' --raw | audit2allow -M my-nginx
$ sudo semodule -X 300 -i my-nginx.pp

Starte den Nginx-Dienst erneut.

$ sudo systemctl start nginx

Schritt 8 – Jellyfin aufrufen und konfigurieren

Besuche die URL https://jellyfin.example.com und du erhältst den folgenden Bildschirm.

Jellyfin Einrichtungsassistent

Wähle die Anzeigesprache und klicke auf die Schaltfläche Weiter, um fortzufahren.

Jellyfin Benutzereinrichtung

Gib deine Benutzerdaten ein und klicke auf die Schaltfläche Weiter, um fortzufahren. Klicke auf die Schaltfläche Medienbibliothek hinzufügen, um Medienbibliotheken hinzuzufügen. Wir fügen eine für Filme hinzu.

Jellyfin-Bibliothek konfigurieren

Fülle alle Optionen aus und klicke auf das Pluszeichen neben der Option Ordner, um den Ordner für deine Bibliothek auszuwählen. Scrolle nach unten und gib die erforderlichen Optionen ein. Klicke auf die Schaltfläche Ok, um das Hinzufügen der Bibliothek abzuschließen. Du wirst zur Seite für die Einrichtung der Bibliothek zurückkehren.

Jellyfin Setup Medienbibliotheken

Klicke auf die Schaltfläche Weiter, um fortzufahren.

Jellyfin Metadata Language

Wähle die Sprache und das Land für die Metadaten deiner Medien aus und klicke auf die Schaltfläche Weiter, um fortzufahren.

Jellyfin Fernzugriff

Vergewissere dich, dass die Option Fernverbindungen zulassen aktiviert ist. Wenn du die Portzuordnung verwenden möchtest, aktiviere sie ebenfalls. Klicke auf die Schaltfläche Weiter, wenn du fertig bist.

Jellyfin Einrichtung abgeschlossen

Die Einrichtung ist abgeschlossen. Klicke auf die Schaltfläche Fertig stellen, um zur Anmeldeseite von Jellyfin zu gelangen.

Jellyfin Login Seite

Gib deine zuvor erstellten Benutzerdaten ein und klicke auf die Schaltfläche Anmelden, um zum Dashboard zu gelangen.

Jellyfin Dashboard

Du kannst Jellyfin nun nutzen, um deine Inhalte abzuspielen.

Schritt 9 – Upgrade von Jellyfin

Das Upgrade von Jellyfin ist einfach und erfordert nur ein paar Schritte. Wechsle zunächst in das Verzeichnis.

$ cd ~/jellyfin

Stoppe den Jellyfin-Container.

$ docker compose down --remove-orphans

Ziehe das neueste Container-Image für Jellyfin.

$ docker compose pull

Nimm Änderungen in der docker-compose.yml vor, wenn du willst.

Starte den Jellyfin-Container.

$ docker compose up -d

Fazit

Damit ist unsere Anleitung zur Installation von Jellyfin Media Server mit Docker auf einem Rocky Linux 9 Server abgeschlossen. Wenn du Fragen hast, schreibe sie unten in die Kommentare.

Das könnte dich auch interessieren …