Ricerca nel sito web

Come installare Jellyfin Media Server su Rocky Linux 9


Su questa pagina

  1. Prerequisiti
  2. Passaggio 1: configurazione del firewall
  3. Passaggio 2 - Installa Docker e Docker Compose
  4. Passaggio 3: creazione della configurazione di Docker Compose
  5. Passaggio 4 - Avvia Jellyfin
  6. Passaggio 5 - Installa Nginx
  7. Passaggio 6 - Installa SSL
  8. Passaggio 7 - Configura Nginx
  9. Passaggio 8 - Accedi e configura Jellyfin
  10. Passaggio 9 - Aggiorna Jellyfin
  11. Conclusione

Jellyfin è un server multimediale gratuito e open source che ti consente di trasmettere contenuti a cui è possibile accedere da qualsiasi luogo. Supporta film, programmi TV, musica e Live TV/DVR. Il server Jellyfin può essere configurato su Windows, Linux o macOS e il suo contenuto è accessibile istantaneamente da diversi dispositivi utilizzando browser e app mobili utilizzando un URL pubblico. Rende persino possibile lo streaming di questi file su altri PC, TV o telefoni purché questi dispositivi multimediali siano connessi a Internet o alla stessa rete. Offre diverse funzionalità tra cui, Supporta DLNA, Nessun limite di riproduzione, Recupero automatico dei metadati da TheTVDB, TheMovieDB e Rotten Tomatoes, Registrazioni automatiche, Supporta l'accelerazione hardware e molti altri.

Jellyfin è un fork del server Emby Media dopo che Emby è passato a un modello di licenza proprietario.

In questo tutorial imparerai come installare Jellyfin Media Server utilizzando Docker su un server Rocky Linux 9.

Prerequisiti

  • A server running Rocky Linux 9 with a minimum of 2 CPU cores and 4GB of memory. You will need to upgrade the server as per requirements.

  • A non-root user with sudo privileges.

  • A fully qualified domain name (FQDN) pointing to your server. For our purposes, we will use jellyfin.example.com as the domain name.

  • Make sure everything is updated.

    $ sudo dnf update
    
  • Install basic utility packages. Some of them may already be installed.

    $ sudo dnf install wget curl nano unzip yum-utils -y
    

Passaggio 1: configurare il firewall

Il primo passo è configurare il firewall. Rocky Linux utilizza Firewalld Firewall. Controlla lo stato dei firewall.

$ sudo firewall-cmd --state
running

Il firewall funziona con zone diverse e la zona pubblica è quella predefinita che utilizzeremo. Elenca tutti i servizi e le porte attive sul firewall.

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

Dovrebbe mostrare il seguente output.

cockpit dhcpv6-client ssh

Jellyfin ha bisogno delle porte HTTP e HTTPS per funzionare. Aprili.

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

Aggiungi mascheramento, poiché l'applicazione contatterà altre istanze.

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

Ricarica il firewall per applicare le modifiche.

$ sudo firewall-cmd --reload

Passaggio 2: installa Docker e Docker Compose

Rocky Linux viene fornito con una versione precedente di Docker. Per installare l'ultima versione, per prima cosa installa il repository Docker ufficiale.

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

Installa l'ultima versione di Docker.

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

È possibile che venga visualizzato il seguente errore durante il tentativo di installazione di Docker.

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

Utilizzare il seguente comando se si ottiene l'errore sopra.

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

Abilita ed esegui il demone Docker.

$ sudo systemctl enable docker --now

Verificare che sia in esecuzione.

? 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

Per impostazione predefinita, Docker richiede i privilegi di root. Se vuoi evitare di usare sudo ogni volta che esegui il comando docker, aggiungi il tuo nome utente alla docker gruppo.

$ sudo usermod -aG docker $(whoami)

Sarà necessario disconnettersi dal server e riconnettersi come lo stesso utente per abilitare questa modifica o utilizzare il seguente comando.

$ su - ${USER}

Verifica che il tuo utente sia stato aggiunto al gruppo Docker.

$ groups
navjot wheel docker

Passaggio 3: creare la configurazione di Docker Compose

Crea la directory per Jellyfin Docker Configuration.

$ mkdir ~/jellyfin

Passa alla rubrica.

$ cd ~/jellyfin

Crea e apri il file di composizione Docker per la modifica.

$ nano docker-compose.yml

Incolla il seguente codice al suo interno.

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

Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

Il file docker precedente estrae l'ultima versione del server Jellyfin dal registro Docker Hub. L'ID utente e di gruppo per l'immagine è impostato su 1000. È possibile modificarlo in base all'ID utente del sistema per le autorizzazioni corrette. Abbiamo montato le directory per la cache, la configurazione e i file multimediali. Il criterio di riavvio dei contenitori è impostato su unless-stopped, il che significa che continuerà a essere eseguito a meno che non venga arrestato manualmente. Jellyfin viene eseguito sulla porta 8096 per impostazione predefinita, che è ciò che abbiamo esposto all'host per Nginx da utilizzare in seguito. Abbiamo anche impostato una variabile di ambiente che specifica l'URL pubblico di Jellyfins.

Crea directory per la cache e directory di configurazione. E quindi montarli come volumi permanenti nel file di composizione. Abbiamo anche montato due file multimediali nel nostro file. Puoi archiviare tutte le directory multimediali che desideri. La directory media2 è montata in sola lettura.

Passaggio 4: avviare Jellyfin

Convalida la configurazione di composizione di Docker utilizzando il comando seguente.

$ docker compose config

Riceverai un output simile a conferma della validità.

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

Avvia il contenitore Jellyfin.

$ docker compose up -d

Passaggio 5: installa Nginx

Rocky Linux viene fornito con una versione precedente di Nginx. Devi scaricare il repository Nginx ufficiale per installare l'ultima versione.

Crea e apri il file /etc/yum.repos.d/nginx.repo per creare il repository Nginx ufficiale.

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

Incolla il seguente codice al suo interno.

[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

Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

Installa il server Nginx.

$ sudo dnf install nginx

Verificare l'installazione.

$ nginx -v
nginx version: nginx/1.22.1

Abilita e avvia il server Nginx.

$ sudo systemctl enable nginx --now

Controlla lo stato del server.

$ 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"

Passaggio 6: installa SSL

Lo strumento Certbot genera certificati SSL utilizzando l'API Lets Encrypt. Richiede il repository EPEL per funzionare.

$ sudo dnf install epel-release

Useremo Snapd per installare Certbot. Installa Snapd.

$ sudo dnf install snapd

Abilita e avvia il servizio Snap.

$ sudo systemctl enable snapd --now

Installa il pacchetto principale di Snap.

$ sudo snap install core
$ sudo snap refresh core

Crea i collegamenti necessari affinché Snapd funzioni.

$ 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

Immetti il seguente comando per installare Certbot.

$ sudo snap install --classic certbot

Abilita Certbot creando il link simbolico al suo eseguibile.

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

Genera il certificato SSL.

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

Il comando precedente scaricherà un certificato nella directory /etc/letsencrypt/live/jellyfin.example.com sul tuo server.

Genera un certificato di gruppo Diffie-Hellman.

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

Per verificare se il rinnovo SSL funziona correttamente, eseguire un'esecuzione a secco del processo.

$ sudo certbot renew --dry-run

Se non vedi errori, sei a posto. Il tuo certificato si rinnoverà automaticamente.

Passaggio 7: configurazione di Nginx

Apri il file /etc/nginx/nginx.conf per la modifica.

$ sudo nano /etc/nginx/nginx.conf

Aggiungere la riga seguente prima della riga include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

Crea e apri il file /etc/nginx/conf.d/jellyfin.conf per la modifica.

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

Incolla il seguente codice al suo interno.

## 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 "";
}

Una volta terminato, salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Verificare la sintassi del file di configurazione Nginx.

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

Configura SELinux per consentire le connessioni di rete.

$ sudo setsebool -P httpd_can_network_connect 1

Riavvia il server Nginx.

$ sudo systemctl restart nginx

Se ricevi il seguente errore, molto probabilmente è dovuto alle restrizioni di SELinux.

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

Per correggere l'errore, eseguire i seguenti comandi.

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

Riavvia il servizio Nginx.

$ sudo systemctl start nginx

Passaggio 8: accedere e configurare Jellyfin

Visita l'URL https://jellyfin.example.com e otterrai la seguente schermata.

Selezionare la lingua di visualizzazione e fare clic sul pulsante Avanti per procedere.

Inserisci i tuoi dati utente e fai clic sul pulsante Avanti per procedere. Fare clic su Aggiungi libreria multimediale per aggiungere librerie multimediali. Ne stiamo aggiungendo uno per i film.

Compila tutte le opzioni e fai clic sul segno più accanto all'opzione Cartelle per selezionare la cartella per la tua libreria. Scorri verso il basso e compila le opzioni richieste. Fare clic sul pulsante Ok per completare l'aggiunta della libreria. Verrai riportato alla pagina di configurazione della libreria.

Fare clic sul pulsante Avanti per procedere.

Seleziona la lingua e il paese per i tuoi metadati multimediali e fai clic sul pulsante Avanti per procedere.

Assicurati che l'opzione Consenti connessioni remote sia selezionata. Se desideri utilizzare la mappatura delle porte, abilitala anche tu. Fare clic sul pulsante Avanti al termine.

La configurazione è completa. Fare clic sul pulsante Fine per procedere alla pagina di accesso di Jellyfin.

Inserisci i dettagli utente creati in precedenza e fai clic sul pulsante Accedi per procedere alla dashboard.

Puoi iniziare a utilizzare Jellyfin per riprodurre i tuoi contenuti.

Passaggio 9: aggiorna Jellyfin

L'aggiornamento di Jellyfin è facile e richiede pochi passaggi. Innanzitutto, passa alla directory.

$ cd ~/jellyfin

Ferma il contenitore delle gelatine.

$ docker compose down --remove-orphans

Estrarre l'ultima immagine del contenitore per Jellyfin.

$ docker compose pull

Apporta eventuali modifiche in docker-compose.yml se lo desideri.

Avvia il contenitore Jellyfin.

$ docker compose up -d

Conclusione

Questo conclude il nostro tutorial sull'installazione di Jellyfin Media Server utilizzando Docker su un server Rocky Linux 9. Se hai domande, pubblicale nei commenti qui sotto.