Ubuntu 20.04 / Debian 10 – Installation d’une seedbox anonyme et sécurisée – (Partie 2) Accès de l’extérieur avec Nginx

Ubuntu 20.04https://howto.wared.fr/ubuntu-seedbox-docker-openvpn/

Debian 10https://howto.wared.fr/debian-seedbox-docker-openvpn/

Si vous souhaitez accéder à vos services de l’extérieur via une URL de type http://mondomaine.com/deluge, http://mondomaine.com/jackett, etc., alors un reverse proxy est nécessaire. Le reverse proxy remplit le rôle de passerelle entre l’extérieur (Internet) et le réseau local de votre serveur.

5 – Nginx

Notre choix se portera sur le serveur HTTP Nginx pour une question de performances. Nginx est reconnu pour ses hautes performances, sa stabilité, son ensemble de fonctionnalités, sa configuration simple ainsi que sa faible consommation en ressources.

5.1 – Installation

Repassez sous votre super-utilisateur :
```
exit
```

Installez le paquet nginx :

sudo apt-get update && sudo apt-get -y install nginx

Modifiez les directives suivantes du fichier de configuration Nginx /etc/nginx/nginx.conf :
```
user www-data;
worker_processes 8;
pid /run/nginx.pid;
include /etc/nginx/modules-enabled/*.conf;

events {
    worker_connections 768;
    # multi_accept on;
}

http {

    ##
    # Basic Settings
    ##

    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    keepalive_timeout 65;
    types_hash_max_size 2048;
    server_tokens off;

    # server_names_hash_bucket_size 64;
    # server_name_in_redirect off;

    include /etc/nginx/mime.types;
    default_type application/octet-stream;
...
```
- worker_processes : pour profiter pleinement de la puissance de votre serveur, il est recommandé de mettre autant de worker_processes que de cœurs disponibles sur votre serveur. Pour connaître le nombre de cœurs sur votre serveur, il suffit de lancer la commande :
```
grep processor /proc/cpuinfo | wc -l
8
```
- server_tokens : pour des raisons de sécurité, il est recommandé de désactiver l’envoi d’informations telles que le numéro de version de votre Nginx. Pour cela, décommentez cette directive dans le bloc http.
Rechargez la configuration Nginx :
```
sudo systemctl reload nginx.service
```

5.2 – Vhosts

N’oubliez pas de modifier les règles DNS dans l’interface administrateur du fournisseur de votre nom de domaine pour pointer vers l’IP de votre serveur. Si votre serveur est hébergé chez vous, il sera aussi nécessaire de créer une redirection du port 80 et 443 vers votre serveur dans l’interface de configuration de votre box internet (ou routeur).

Créez le fichier /etc/nginx/sites-available/media et modifiez la ligne en surbrillance avec votre nom de domaine :

upstream plex_backend {
    server                   localhost:32400;
    keepalive                32;
}

map $http_upgrade $connection_upgrade {
    default                  upgrade;
    ''                       close;
}

server {
    listen                   80;
    listen                   [::]:80;
    server_name              mondomaine.com;

    location ^~ /deluge {
        proxy_pass           http://127.0.0.1:8112/;
        proxy_set_header     X-Deluge-Base "/deluge/";
        add_header           X-Frame-Options SAMEORIGIN;
        include              proxy_params;
    }

    location ^~ /jackett {
        proxy_pass           http://127.0.0.1:9117;
        include              proxy_params;
    }

    location ^~ /sonarr {
        proxy_pass           http://127.0.0.1:8989/sonarr;
        include              proxy_params;
    }

    location ^~ /radarr {
        proxy_pass           http://127.0.0.1:7878/radarr;
        include              proxy_params;
    }
    
    location ^~ /lidarr {
        proxy_pass           http://127.0.0.1:8686/lidarr;
        include              proxy_params;
    }

    location /web {
        proxy_pass           http://plex_backend;

        #Plex has A LOT of javascript, xml and html. This helps a lot, but if it causes playback issues with devices turn it off. (Haven't encountered any yet)
        gzip                 on;
        gzip_vary            on;
        gzip_min_length      1000;
        gzip_proxied         any;
        gzip_types           text/plain text/css text/xml application/xml text/javascript application/x-javascript image/svg+xml;
        gzip_disable         "MSIE [1-6].";

        #Nginx default client_max_body_size is 1MB, which breaks Camera Upload feature from the phones.
        #Increasing the limit fixes the issue. Anyhow, if 4K videos are expected to be uploaded, the size might need to be increased even more
        client_max_body_size 100M;

        #Forward real ip and host to Plex
        include              proxy_params;

        #Plex headers
        proxy_set_header     X-Plex-Client-Identifier $http_x_plex_client_identifier;
        proxy_set_header     X-Plex-Device $http_x_plex_device;
        proxy_set_header     X-Plex-Device-Name $http_x_plex_device_name;
        proxy_set_header     X-Plex-Platform $http_x_plex_platform;
        proxy_set_header     X-Plex-Platform-Version $http_x_plex_platform_version;
        proxy_set_header     X-Plex-Product $http_x_plex_product;
        proxy_set_header     X-Plex-Token $http_x_plex_token;
        proxy_set_header     X-Plex-Version $http_x_plex_version;
        proxy_set_header     X-Plex-Nocache $http_x_plex_nocache;
        proxy_set_header     X-Plex-Provides $http_x_plex_provides;
        proxy_set_header     X-Plex-Device-Vendor $http_x_plex_device_vendor;
        proxy_set_header     X-Plex-Model $http_x_plex_model;

        proxy_set_header     Host $server_addr;
        proxy_set_header     Referer $server_addr;
        proxy_set_header     Origin $server_addr;

        #Plex Websockets
        proxy_http_version   1.1;
        proxy_set_header     Upgrade $http_upgrade;
        proxy_set_header     Connection "upgrade";

        #Buffering off send to the client as soon as the data is received from Plex.
        proxy_redirect       off;
        proxy_buffering      off;
    }

    location /plex {
        proxy_pass           http://localhost:32400/web;
    }
}

Activez le virtual host :

sudo ln -s /etc/nginx/sites-available/media /etc/nginx/sites-enabled/media

Rechargez la configuration Nginx :
```
sudo systemctl reload nginx.service
```

5.3 – Configuration

Pour accéder aux services Deluge, Jackett, Sonarr, Radarr, Lidarr et Plex via un nom de domaine, il est nécessaire de spécifier l’URL d’accès dans leurs fichiers de configuration respectifs.

Deluge

Connectez-vous avec l’utilisateur media :
```
su media
```
Placez-vous dans le répertoire personnel de cet utilisateur :
```
cd
```
Arrêtez le container deluge :
```
docker-compose stop deluge
```

Modifiez la valeur de la propriété base dans le fichier de configuration de Deluge /home/media/deluge/config/web.conf :

{
    "file": 2,
    "format": 1
}{
    "base": "/deluge",
    "cert": "ssl/daemon.cert",
    "default_daemon": "",
    "enabled_plugins": [],
    "first_login": false,
    "https": false,
    "interface": "0.0.0.0",
    "language": "",
    "pkey": "ssl/daemon.pkey",
    "port": 8112,

    [...]

}

Démarrez le container deluge :
```
docker-compose start deluge
```
Deluge est désormais accessible via : http://mondomaine.com/deluge

Jackett

Modifiez la valeur de la propriété BasePathOverride dans le fichier de configuration de Jackett /home/media/jackett/config/Jackett/ServerConfig.json :

{
  "Port": 9117,
  "AllowExternal": true,
  "APIKey": "***secret***",
  "AdminPassword": "***secret***",
  "InstanceId": "5pcp7hnvu69gmiq4gc7xgv47358d1gi7fkcvl088koieankn07adpt8ciob2umvj",
  "BlackholeDir": null,
  "UpdateDisabled": false,
  "UpdatePrerelease": false,
  "BasePathOverride": "/jackett",
  "OmdbApiKey": null,
  "ProxyUrl": null,
  "ProxyType": 0,
  "ProxyPort": null,
  "ProxyUsername": null,
  "ProxyPassword": null,
  "ProxyIsAnonymous": true
}

Redémarrez le container jackett :
```
docker-compose restart jackett
```
Jackett est désormais accessible via : http://mondomaine.com/jackett

Radarr

Modifiez la valeur de la propriété UrlBase dans le fichier de configuration de Radarr /home/media/radarr/config/config.xml :

<Config>
  <LogLevel>Info</LogLevel>
  <Port>7878</Port>
  <UrlBase>/radarr</UrlBase>
  <BindAddress>*</BindAddress>
  <SslPort>9898</SslPort>
  <EnableSsl>False</EnableSsl>
  <ApiKey>4242424242424242424242</ApiKey>
  <AuthenticationMethod>None</AuthenticationMethod>
  <Branch>develop</Branch>
</Config>

Redémarrez le container radarr :
```
docker-compose restart radarr
```
Radarr est désormais accessible via : http://mondomaine.com/radarr

Sonarr

Modifiez la valeur de la propriété UrlBase dans le fichier de configuration de Sonarr /home/media/sonarr/config/config.xml :

<Config>
  <LogLevel>Info</LogLevel>
  <Port>8989</Port>
  <UrlBase>/sonarr</UrlBase>
  <BindAddress>*</BindAddress>
  <SslPort>9898</SslPort>
  <EnableSsl>False</EnableSsl>
  <ApiKey>4242424242424242424242</ApiKey>
  <AuthenticationMethod>None</AuthenticationMethod>
  <Branch>master</Branch>
  <LaunchBrowser>True</LaunchBrowser>
  <SslCertHash></SslCertHash>
  <UpdateMechanism>BuiltIn</UpdateMechanism>
</Config>

Redémarrez le container sonarr :
```
docker-compose restart sonarr
```
Sonarr est désormais accessible via : http://mondomaine.com/sonarr

Lidarr

Modifiez la valeur de la propriété UrlBase dans le fichier de configuration de Lidarr /home/media/lidarr/config/config.xml :

<Config>
  <LogLevel>Info</LogLevel>
  <EnableSsl>False</EnableSsl>
  <Port>8686</Port>
  <SslPort>6868</SslPort>
  <UrlBase>/lidarr</UrlBase>
  <BindAddress>*</BindAddress>
  <ApiKey>4242424242424242424242</ApiKey>
  <AuthenticationMethod>None</AuthenticationMethod>
  <Branch>master</Branch>
</Config>

Redémarrez le container lidarr :
```
docker-compose restart lidarr
```
Lidarr est désormais accessible via : http://mondomaine.com/lidarr

Plex

Pour un accès à distance, il est nécessaire d’associer l’interface web Plex à votre serveur. Pour cela, vous devez préciser l’URL et un code d’association dont la validité est de 4 minutes.

Demandez le code d’association à l’adresse suivante : https://www.plex.tv/claim/

Ajoutez les lignes suivantes dans votre fichier /home/media/docker-compose.yml en spécifiant le code obtenu précédemment :

version: '3.7'
services:
  [...]

  plex:
    image: linuxserver/plex:latest
    container_name: plex
    restart: unless-stopped
    network_mode: "host"
    ports:
      - 32400:32400
    environment:
      - VERSION=latest
      - PUID=${PUID}
      - PGID=${PGID}
      - TZ=Europe/Paris
      - PLEX_CLAIM=claim-424242424242
    volumes:
      - /home/media/plex/config:/config
      - ${PATH_MEDIA}:/data
[...]

Redémarrez le container Plex avec la commande :
```
docker-compose up -d
```
Plex est désormais accessible via : http://mondomaine.com/plex

5.4 – SSL/TLS avec Let’s Encrypt

Let’s Encrypt est une autorité de certification libre, automatisée et ouverte. Cette autorité fournit des certificats gratuits X.509 pour le protocole cryptographique SSL/TLS au moyen d’un processus automatisé destiné à se passer du processus complexe actuel impliquant la création manuelle, la validation, la signature, l’installation et le renouvellement des certificats pour la sécurisation des sites internet. En mai 2018, Let’s Encrypt avait délivré plus de 70 millions de certificats.

Repassez sous votre super-utilisateur et installez les paquets software-properties-common et certbot :

sudo apt-get install -y software-properties-common
sudo apt-get install -y certbot

5.5 – Génération des certificats

Let’s Encrypt permet de générer de différentes façons plus ou moins automatisées un certificat. La méthode standalone permet de générer simplement un certificat. En revanche, celle-ci demande d’arrêter le serveur Nginx et ceci est valable à chaque renouvellement dudit certificat. Il existe aussi des plugins apache et nginx entièrement automatisés. Ces plugins mettent à jour automatiquement la configuration des virtual hosts mais le plugin nginx est encore expérimental. Dans cet article, nous recommandons d’utiliser le plugin webroot qui permet de générer et renouveler son certificat sans interrompre le serveur Nginx.

Le plugin webroot crée un fichier temporaire .well-known/acme-challenge dans un dossier spécifique accessible à Nginx, celui-ci permettra aux serveurs de Let’s Encrypt d’appeler ce fichier temporaire et ainsi de valider votre certificat.

Créez le répertoire destiné au fichier temporaire de Let’s Encrypt :
```
sudo mkdir -p /var/www/letsencrypt
```
Créez le fichier /etc/nginx/snippets/letsencrypt avec les lignes suivantes pour rediriger Let’s Encrypt vers le dossier local précédemment créé :
```
location ^~ /.well-known/acme-challenge/ {
    default_type "text/plain";
    root         /var/www/letsencrypt;
}
```

Importez le fichier précédemment créé dans votre virtual host :

upstream plex_backend {
    server                   localhost:32400;
    keepalive                32;
}

map $http_upgrade $connection_upgrade {
    default                  upgrade;
    ''                       close;
}

server {
    listen                   80;
    listen                   [::]:80;
    server_name              mondomaine.com;

    location ^~ /deluge {
        proxy_pass           http://127.0.0.1:8112/;
        proxy_set_header     X-Deluge-Base "/deluge/";
        add_header           X-Frame-Options SAMEORIGIN;
        include              proxy_params;
    }

    location ^~ /jackett {
        proxy_pass           http://127.0.0.1:9117;
        include              proxy_params;
    }

    location ^~ /sonarr {
        proxy_pass           http://127.0.0.1:8989/sonarr;
        include              proxy_params;
    }

    location ^~ /radarr {
        proxy_pass           http://127.0.0.1:7878/radarr;
        include              proxy_params;
    }
    
    location ^~ /lidarr {
        proxy_pass           http://127.0.0.1:8686/lidarr;
        include              proxy_params;
    }

    location /web {
        proxy_pass           http://plex_backend;

        #Plex has A LOT of javascript, xml and html. This helps a lot, but if it causes playback issues with devices turn it off. (Haven't encountered any yet)
        gzip                 on;
        gzip_vary            on;
        gzip_min_length      1000;
        gzip_proxied         any;
        gzip_types           text/plain text/css text/xml application/xml text/javascript application/x-javascript image/svg+xml;
        gzip_disable         "MSIE [1-6].";

        #Nginx default client_max_body_size is 1MB, which breaks Camera Upload feature from the phones.
        #Increasing the limit fixes the issue. Anyhow, if 4K videos are expected to be uploaded, the size might need to be increased even more
        client_max_body_size 100M;

        #Forward real ip and host to Plex
        include              proxy_params;

        #Plex headers
        proxy_set_header     X-Plex-Client-Identifier $http_x_plex_client_identifier;
        proxy_set_header     X-Plex-Device $http_x_plex_device;
        proxy_set_header     X-Plex-Device-Name $http_x_plex_device_name;
        proxy_set_header     X-Plex-Platform $http_x_plex_platform;
        proxy_set_header     X-Plex-Platform-Version $http_x_plex_platform_version;
        proxy_set_header     X-Plex-Product $http_x_plex_product;
        proxy_set_header     X-Plex-Token $http_x_plex_token;
        proxy_set_header     X-Plex-Version $http_x_plex_version;
        proxy_set_header     X-Plex-Nocache $http_x_plex_nocache;
        proxy_set_header     X-Plex-Provides $http_x_plex_provides;
        proxy_set_header     X-Plex-Device-Vendor $http_x_plex_device_vendor;
        proxy_set_header     X-Plex-Model $http_x_plex_model;

        proxy_set_header     Host $server_addr;
        proxy_set_header     Referer $server_addr;
        proxy_set_header     Origin $server_addr;

        #Plex Websockets
        proxy_http_version   1.1;
        proxy_set_header     Upgrade $http_upgrade;
        proxy_set_header     Connection "upgrade";

        #Buffering off send to the client as soon as the data is received from Plex.
        proxy_redirect       off;
        proxy_buffering      off;
    }

    location /plex {
        proxy_pass           http://plex_backend;
    }

    include                  /etc/nginx/snippets/letsencrypt;
}

Recharchez votre configuration Nginx :
```
sudo systemctl reload nginx.service
```
Générez votre certificat en remplaçant email@mondomaine.com et mondomaine.com par vos informations personnelles :
```
sudo certbot certonly --webroot -w /var/www/letsencrypt --agree-tos --no-eff-email --email email@mondomaine.com -d mondomaine.com --rsa-key-size 4096
```
Vous obtiendrez 4 fichiers dans le répertoire /etc/letsencrypt/live/mondomaine.com :
- cert.pem : le certificat de votre domaine mondomaine.com
- chain.pem : le certificat Let’s Encrypt
- fullchain.pem : les certificats cert.pem et chain.pem combinés
- privkey.pem : la clé privée du certificat.
SSL/TLS utilise un système de chiffrement asymétrique (comme RSA ou Diffie-Hellman) afin de sécuriser les échanges de vos flux. Par défaut, Nginx utilise une clé de 1048 bits. En augmentant la longueur de la clé à 4096 bits, vous augmenterez ainsi la sécurité de votre protocole SSL/TLS. Générez une nouvelle clé Diffie-Hellman (DH) de 4096 bits et attribuez-lui un minimum de permissions :
```
sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 4096
sudo chmod 600 /etc/ssl/certs/dhparam.pem
```

5.6 – Ajout des certificats au Vhost et activation du SSL/TLS

Modifiez votre virtual host en ajoutant les lignes en surbrillance. Attention à bien modifier les directives server_name, ssl_certificate, ssl_certificate_key et ssl_trusted_certificate en fonction de votre configuration :

upstream plex_backend {
    server                    localhost:32400;
    keepalive                 32;
}

map $http_upgrade $connection_upgrade {
    default                   upgrade;
    ''                        close;
}

server {
    listen                    80;
    listen                    [::]:80;
    server_name               mondomaine.com;
    return                    301 https://$server_name$request_uri;
}

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

    ssl_certificate           /etc/letsencrypt/live/mondomaine.com/fullchain.pem;
    ssl_certificate_key       /etc/letsencrypt/live/mondomaine.com/privkey.pem;
    ssl_trusted_certificate   /etc/letsencrypt/live/mondomaine.com/chain.pem;

    ssl_dhparam               /etc/ssl/certs/dhparam.pem;

    ssl_protocols             TLSv1 TLSv1.1 TLSv1.2 TLSv1.3;
    ssl_prefer_server_ciphers on;
    #Intentionally not hardened for security for player support and encryption video streams has a lot of overhead with something like AES-256-GCM-SHA384.
    ssl_ciphers               TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256:TLS_AES_128_CCM_8_SHA256:TLS_AES_128_CCM_SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
    ssl_ecdh_curve            secp384r1;

    ssl_stapling              on;
    ssl_stapling_verify       on;

    location ^~ /deluge {
        proxy_pass            http://127.0.0.1:8112/;
        proxy_set_header      X-Deluge-Base "/deluge/";
        add_header            X-Frame-Options SAMEORIGIN;
        include               proxy_params;
    }

    location ^~ /jackett {
        proxy_pass            http://127.0.0.1:9117;
        include               proxy_params;
    }

    location ^~ /sonarr {
        proxy_pass            http://127.0.0.1:8989/sonarr;
        include               proxy_params;
    }

    location ^~ /radarr {
        proxy_pass            http://127.0.0.1:7878/radarr;
        include               proxy_params;
    }
    
    location ^~ /lidarr {
        proxy_pass            http://127.0.0.1:8686/lidarr;
        include               proxy_params;
    }

    location /web {
        proxy_pass            http://plex_backend;

        #Plex has A LOT of javascript, xml and html. This helps a lot, but if it causes playback issues with devices turn it off. (Haven't encountered any yet)
        gzip                  on;
        gzip_vary             on;
        gzip_min_length       1000;
        gzip_proxied          any;
        gzip_types            text/plain text/css text/xml application/xml text/javascript application/x-javascript image/svg+xml;
        gzip_disable          "MSIE [1-6].";

        #Nginx default client_max_body_size is 1MB, which breaks Camera Upload feature from the phones.
        #Increasing the limit fixes the issue. Anyhow, if 4K videos are expected to be uploaded, the size might need to be increased even more
        client_max_body_size  100M;

        #Forward real ip and host to Plex
        include               proxy_params;

        #Plex headers
        proxy_set_header      X-Plex-Client-Identifier $http_x_plex_client_identifier;
        proxy_set_header      X-Plex-Device $http_x_plex_device;
        proxy_set_header      X-Plex-Device-Name $http_x_plex_device_name;
        proxy_set_header      X-Plex-Platform $http_x_plex_platform;
        proxy_set_header      X-Plex-Platform-Version $http_x_plex_platform_version;
        proxy_set_header      X-Plex-Product $http_x_plex_product;
        proxy_set_header      X-Plex-Token $http_x_plex_token;
        proxy_set_header      X-Plex-Version $http_x_plex_version;
        proxy_set_header      X-Plex-Nocache $http_x_plex_nocache;
        proxy_set_header      X-Plex-Provides $http_x_plex_provides;
        proxy_set_header      X-Plex-Device-Vendor $http_x_plex_device_vendor;
        proxy_set_header      X-Plex-Model $http_x_plex_model;

        proxy_set_header      Host $server_addr;
        proxy_set_header      Referer $server_addr;
        proxy_set_header      Origin $server_addr;

        #Plex Websockets
        proxy_http_version    1.1;
        proxy_set_header      Upgrade $http_upgrade;
        proxy_set_header      Connection "upgrade";

        #Buffering off send to the client as soon as the data is received from Plex.
        proxy_redirect        off;
        proxy_buffering       off;
    }

    location /plex {
        proxy_pass            http://plex_backend;
    }

    include                   /etc/nginx/snippets/letsencrypt;
}

Rechargez votre configuration Nginx :
```
sudo systemctl reload nginx.service
```

Vérifiez la force de votre protocole SSL/TLS en vérifiant votre Plex par exemple sur SSL Labs. Avec une telle configuration, vous devriez obtenir un A.

5.7 – Renouvellement automatique du certificat

Les certificats délivrés par Let’s Encrypt sont valides 90 jours. Une tâche planifiée permettant de renouveler l’ensemble des certificats présents sur votre serveur est fournie avec le paquet certbot. Celle-ci est exécutée deux fois par jour et les renouvelle si et seulement si vos certificats expirent dans un délai inférieur à 30 jours.

Testez si le renouvellement automatique est fonctionnel avec la commande suivante :
```
sudo certbot renew --dry-run
```

6 – Configuration

Nous allons maintenant configurer les applications pour qu’elles puissent communiquer entre elles et que chacune d’elles dispose d’un minimum de sécurité.

Suite du tutoriel (configuration et problèmes rencontrés)

Ubuntu Server 20.04Docker 19.03.8
Docker Compose 1.26.2
Nginx 1.17.10
Deluge 2.0.4
Jackett 0.16.105.0
Sonarr 2.0.0.5344
Radarr 0.2.0.1480
Lidarr 0.7.1.1381

AuteurEdouard WATTECAMPS

Evaluez ce tutoriel !

Arnaud dit :

29 avril 2020 à 22 h 30 min

Hello,
Super tuto, j’ai juste remplacé Nginx par Traefik dans Docker, et ajouter Pyload.

Répondre

Sofiane dit :

3 mai 2020 à 16 h 10 min

Bonjour,

2 petites questions:

Que dois je modifier pour que mon plex ne soit accessible qu’à travers /plex et non pas /web et /plex ?
Que faire aussi pour ne pas avoir la page Welcome to Nginx quand on accede au « / » ?

Merci pour ce tuto et bonne journée a vous.

Edouard WATTECAMPS dit :
3 mai 2020 à 16 h 39 min
Bonjour Sofiane,

Vous pouvez essayer de remplacer dans votre vhost le bloc /web pr le bloc /plex de cette procédure (ne pas oublier de remplacer la directive proxy_pass. Mais attention à bien tester sur navigateur, smartphone, etc. Plex est capricieux…

Vous pouvez supprimer le vhost par défaut de Nginx, vous aurez une 404 à la place :
sudo rm /etc/nginx/sites-enabled/default sudo systemctl reload nginx.service

Bonne journée
Répondre

Golgfag dit :

4 mai 2020 à 8 h 11 min

Bonjour,
Franchement un grand bravo, le tuto est bien fait et simple. J’ai pu faire mes premiers pas avec Docker.
Petite question, je souhaite y ajouter ombi, mais celui-ci fonctionne sur une version 2.1 dans docker. Est-il possible pour moi de l’installer et cela même avec d’autre service en version 3.x ?

J’aimerai laisser une possibilité de télécharger le contenu de plex a mes administrés, avez vous une autre solution qu’une simple page https ou un ftp ?

Encore un grand merci.

Edouard WATTECAMPS dit :
4 mai 2020 à 10 h 06 min

Bonjour Golgfag,

Aucun problème concernant les versions de Docker. Vous pouvez ajouter Ombi en suivant cette procédure. La partie qui vous intéresse est le docker-compose.yml. Attention à bien modifier les PUID et PGID. Un peu plus loin dans le tuto, vous avez la configuration Nginx pour y accéder de l’extérieur.

Il est possible de télécharger directement vos médias au sein de Plex. Chaque utilisateur peut même réencoder un média pour réduire sa taille (lien Optimiser) puis télécharger cette version optimisée.

Si vous voulez un outil dédié FTP avec une interface web, il existe Pydio, Monsta FTP, Droppy, Nuage…

W.
Répondre
- Golgfag dit :
  4 mai 2020 à 11 h 39 min
  
  Merci pour cette réponse rapide, je vais essayer.
  
  Autre question, dans sonarr ou radarr je n’arrive a voir aucun contenu de mes fichiers. j’ai pourtant bien appliqué le chown media:media
  
  drwxr-xr-x 2 media media 4096 May 4 10:32 movies
  
  Mais il ne trouve aucun fichier dedans:
  
  Disabled movies are possible duplicates. If the match is incorrect, update the Tmdb Id cell to import the proper movie.
  No movies found in folder /data/movies/. Have you already added all of them?
  
  pourtant dedans j’ai bien:
  
  -rw-r–r– 1 media media 1694535680 Apr 17 18:26 ‘XXXX.avi’
  
  Plex trouve bien les fichiers…
  
  Avez-vous une idée?
  Répondre
  - Golgfag dit :
    4 mai 2020 à 16 h 15 min
    
    C’est juste que je ne sais pas utiliser radarr, oubliez mon précédent message. Merci encore
    Répondre

Julien dit :

7 mai 2020 à 14 h 00 min

Bonjour,
Déjà un grand merci pour votre tuto. Très clair surtout pour les novices.
J’ai juste une question. J’ai intégré NextCloud sur mon serveur, avec un user différent de media ou plex pour plus de sécurité.
Cependant, je voudrais savoir s’il y a une possibilité de faire un accès FTP, pour pouvoir gérer les fichiers des différents user à distance, soit en WebUI un peu comme Webshell Plugin Server pour le SSH, ou directement via Filezilla ?
Car NextCloud réponds parfaitement à mes besoins pour le privée, mais pour le partage public de mon user media avec Plex, j’aimerais que qui-conque puisse ajouter des fichiers (pas un simple partage SAMBA ^^).
Je vous remercie, je pense que cette info pourrait en aider plus d’un !
Cordialement, Julien.

Edouard WATTECAMPS dit :
7 mai 2020 à 14 h 51 min

Bonjour Julien,

Tout dépend de la solution la plus adaptée à vos utilisateurs. Votre dossier media Plex est partagé avec Nextcloud ? Si c’est le cas, vous pouvez regarder du côté du protocole WebDav (pris en charge par Nextcloud) ou sinon, le plus simple, vous ajoutez directement dans Nextcloud un dossier public en fournissant à vos utilisateurs le lien de partage (https://docs.nextcloud.com/server/18/user_manual/files/file_drop.html).
Sinon vous avez la possibilité de créer des utilisateurs dédiés au FTP avec Vsftpd par exemple (les chrooter dans un dossier en particulier). Vos utilisateurs pourront utiliser FileZilla (certaines extensions Chrome font bien le travail aussi).

W.
Répondre
- Julien dit :
  8 mai 2020 à 14 h 06 min
  
  Bonjour,
  
  Merci pour cette réponse. Non effectivement mon dossier media n’est pas partagé avec Nextcloud, de même je pensais que l’opération de scinder les 2 users étaient obligatoire avec vos tutos.
  Effectivement, le dossier Public dans Nextcloud était ma solution de contournement. Les media rajoutés (musiques, vidéos, etc.), je les copiés une fois par semaine manuellement dans les dossiers Plex.
  La piste Vsftpd est à explorer, merci pour ce tuyau.
  Au plaisir de lire un nouveau tuto.
  
  Julien.
  Répondre

djogra dit :

1 décembre 2020 à 1 h 01 min

Bonjour, j’ai réussi a tout faire marcher sans soucis, mais plex me dit Impossible d’établir une connexion sécurisée avec « serv »

Edouard WATTECAMPS dit :
1 décembre 2020 à 16 h 33 min

Bonjour djogra,
Avez-vous essayé la procédure dans la partie 3 (problèmes rencontrés) ?
W.
Répondre