Ubuntu 20.04 – Newsgroups – (Partie 2) Accès de l’extérieur avec Nginx

Ubuntu 20.04https://howto.wared.fr/ubuntu-newsgroups-nzbget-nzbhydra-sonarr-radarr-plex-docker/

Si vous souhaitez accéder à vos services de l’extérieur via une URL de type http://mondomaine.com/nzbget, http://mondomaine.com/nzbhydra, 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 ^~ /nzbget {
        proxy_pass           http://127.0.0.1:6789;
        include              proxy_params;
        client_max_body_size 50m;
    }

    location ^~ /nzbhydra {
        proxy_pass           http://127.0.0.1:5076/nzbhydra;
        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 NZBHydra, 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.

NZBHydra

Arrêtez le container nzbhydra :
```
docker-compose stop nzbhydra
```

Modifiez la valeur de la propriété urlBase (ligne 333) dans le fichier de configuration de NZBHydra /home/media/nzbhydra/config/nzbhydra.yml :

...
main:
  apiKey: "424242424242424242"
  configVersion: 3
  backupEverySunday: true
  backupBeforeUpdate: true
  deleteBackupsAfterWeeks: 4
  dereferer: "http://www.dereferer.org/?$s"
  host: "0.0.0.0"
  logging:
    consolelevel: "INFO"
    historyUserInfoType: "NONE"
    logIpAddresses: true
    logMaxHistory: 30
    logfilelevel: "INFO"
    logUsername: false
    markersToLog: []
  port: 5076
  proxyType: "NONE"
  proxyHost: null
  proxyPort: 1080
  proxyIgnoreLocal: true
  proxyIgnoreDomains: []
  proxyUsername: null
  proxyPassword: null
  repositoryBase: "https://github.com/theotherp"
  showNews: true
  shutdownForRestart: false
  sniDisabledFor:
  - "nzbgeek.info"
  ssl: false
  sslKeyStore: null
  sslKeyStorePassword: null
  startupBrowser: true
  theme: "grey"
  urlBase: "/nzbhydra"
...

Redémarrez le container nzbhydra :
```
docker-compose restart nzbhydra
```

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 ^~ /nzbget {
        proxy_pass           http://127.0.0.1:6789;
        include              proxy_params;
        client_max_body_size 50m;
    }

    location ^~ /nzbhydra {
        proxy_pass           http://127.0.0.1:5076/nzbhydra;
        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 ^~ /nzbget {
        proxy_pass           http://127.0.0.1:6789;
        include              proxy_params;
        client_max_body_size 50m;
    }

    location ^~ /nzbhydra {
        proxy_pass           http://127.0.0.1:5076/nzbhydra;
        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
NZBGet 21.1-r2311
NZBHydra 2.25.0
Jackett 0.16.105.0
Sonarr 2.0.0.5344
Radarr 0.2.0.1480
Lidarr 0.7.1.1381
Plex 1.19.4.2935-79e214ead

AuteurEdouard WATTECAMPS

Evaluez ce tutoriel !