Comment déployer le proxy inverse NGINX sur Docker

Présentation

Un proxy inverse intercepte les requêtes entrantes et les dirige vers le serveur approprié. Non seulement cela accélère les performances, mais cela renforce également la sécurité du serveur.

Le moyen le plus simple de configurer et de gérer les proxys inverses consiste à utiliser Nginx et Docker. Ce guide configure deux exemples de services Web dans des conteneurs Docker et un proxy inverse Nginx pour ces services.

Dans ce didacticiel, vous apprendrez à configurer un proxy inverse sur Docker pour deux exemples de serveurs Web.

Prérequis

Un compte utilisateur avec sudo privilèges
Une ligne de commande/fenêtre de terminal (Ctrl-Alt-T )
Docker installé sur votre système
Docker Compose installé sur votre système
Un nom de domaine enregistré avec un certificat SSL associé

Pourquoi avez-vous besoin d'un proxy inverse ?

Alors que le serveur proxy standard protège les clients, le proxy inverse protège le serveur .

Un proxy inverse est un type de proxy installé derrière le pare-feu du réseau privé. Son rôle principal est d'intercepter le trafic et de diriger une demande vers le serveur approprié sur le backend.

Les principales raisons d'utiliser un proxy inverse sont d'améliorer la sécurité et performances . Si vous avez des services exécutés sur plusieurs pods, vous pouvez rediriger toutes les requêtes entrant sur le réseau pour qu'elles passent par un certain nombre de ports spécifiés.

De plus, les proxys inverses peuvent également gérer le cryptage SSL, la mise en cache et la compression des données.

Étape 1 :Créer un exemple de service Web

1. Commencez par créer un nouveau répertoire pour le premier exemple de service Web. Dans ce tutoriel, nous créons un répertoire example1 , mais vous pouvez utiliser un nom de votre choix.

mkdir example1

2. Accédez à ce répertoire :

cd example1

3. Créez un fichier de configuration YAML docker-compose pour le premier conteneur afin de définir le service. Utilisez un éditeur de texte de votre choix (dans cet exemple, nous utilisons Nano).

sudo nano docker-compose.yml

4. Ensuite, ajoutez le contenu suivant dans le fichier .yaml :

version: '2'
services:
 app:
  image: nginx
  volumes:
   - .:/usr/share/nginx/html
  ports:
   - "80"

Le fichier docker-compose spécifie qu'il s'agit d'une application service qui utilise le nginx image. Il monte la racine de example1 de l'hôte Docker vers /usr/share/nginx/html/ . Enfin, la configuration expose le service sur le port 80 .

Le fichier docker-compose.yml varie en fonction du service que vous souhaitez exécuter. La configuration ci-dessus est spécifique au service Web que nous créons pour ce didacticiel.

4. Enregistrez et quittez le fichier.

5. À l'intérieur du même exemple1 répertoire, créez un fichier d'index pour le service Web :

sudo nano index.html

6. Ajoutez quelques lignes simples à afficher sur l'exemple de page Web :

<!DOCTYPE html>
<html>
<head>
<title>Website 1</title>
</head>
<body>
<h1>Hello! This is the first sample website.</h1>
</body>
</html>

7. Enregistrez et fermez le fichier.

8. Créez le service nouvellement créé à l'aide de docker-compose commande :

sudo docker-compose build

Si vous utilisez une image prédéfinie, comme dans cet exemple, la sortie répond par l'application utilise une image, en ignorant .

9. Ensuite, démarrez le conteneur avec :

sudo docker-compose up -d

Étape 2 :Créer un deuxième exemple de service Web

Créez un deuxième exemple de service Web en suivant le même processus.

Assurez-vous de revenir au répertoire personnel si vous êtes toujours dans example1 . Pour ce faire, exécutez cd dans la fenêtre du terminal.

1. Créez un nouveau répertoire dans lequel vous stockerez le docker-compose et le fichier d'index pour le deuxième site Web. Nous nommerons ce répertoire exemple2 .

mkdir example2

2. Passez à exemple2 en lançant :

cd example2

3. Créez un fichier docker-compose :

sudo nano docker-compose.yml

4. Définissez le service en utilisant les mêmes spécifications qu'à l'étape 1. Ajoutez le contenu suivant au fichier :

version: '2'
services:
 app:
  image: nginx
  volumes:
   - .:/usr/share/nginx/html
  ports:
   - "80"

5. Enregistrez et quittez le fichier.

6. Créez ensuite un fichier d'index pour le deuxième service Web en exécutant :

sudo nano index.html

7. Ajoutez du contenu au fichier :

<!DOCTYPE html>
<html>
<head>
<title>Website 2</title>
</head>
<body>
<h1>Hello! This is the second sample website.</h1>
</body>
</html>

8. Enregistrez les modifications et quittez le fichier.

9. Créez le deuxième service et démarrez le conteneur en exécutant les commandes :

sudo docker-compose build

sudo docker-compose up -d

Étape 3 :Répertorier les conteneurs

Pour vérifier que les conteneurs des deux services sont opérationnels, répertoriez tous les conteneurs avec la commande :

docker ps -a

Vous devriez voir des conteneurs pour les deux services Web répertoriés dans la sortie.

Étape 4 :Configurer le proxy inverse

Ensuite, vous devez installer et configurer un conteneur de proxy inverse. Cela nécessite la création de plusieurs fichiers et sous-répertoires, qui doivent tous être stockés dans le proxy répertoire.

Par conséquent, la première étape consiste à créer et à naviguer dans le proxy annuaire. Pour ce faire, exécutez les commandes :

mkdir proxy

cd proxy

Configurer le Dockerfile

1. Une fois à l'intérieur du proxy répertoire, créez un Dockerfile pour une nouvelle image personnalisée :

sudo nano Dockerfile

2. Le fichier doit contenir les éléments suivants :

FROM nginx

COPY ./default.conf /etc/nginx/conf.d/default.conf

COPY ./backend-not-found.html /var/www/html/backend-not-found.html

COPY ./includes/ /etc/nginx/includes/

COPY ./ssl/ /etc/ssl/certs/nginx/

Le Dockerfile est basé sur l'image nginx. Il copie également un certain nombre de fichiers depuis la machine locale :

la configuration par défaut du service proxy
une réponse d'erreur HTML
Configurations et certificats proxy et SSL

3. Enregistrez et quittez le Dockerfile.

Configurer le fichier backend introuvable

Créer un fichier d'index pour un non trouvé réponse :

sudo nano backend-not-found.html

Ajoutez le contenu :

<html>
<head><title>Proxy Backend Not Found</title></head>
<body>
<h2>Proxy Backend Not Found</h2>
</body>
</html>

3. Enregistrez les modifications et fermez le fichier.

Configurer le fichier default.conf

1. Créez le default.conf fichier dans le répertoire proxy :

sudo nano default.conf

2. Ajoutez le contenu :

# web service1 config.
server {
listen 80;
listen 443 ssl http2;
server_name example1.test;

# Path for SSL config/key/certificate
ssl_certificate /etc/ssl/certs/nginx/example1.crt;
ssl_certificate_key /etc/ssl/certs/nginx/example1.key;
include /etc/nginx/includes/ssl.conf;

location / {
include /etc/nginx/includes/proxy.conf;
proxy_pass http://example_app_1;
}

access_log off;
error_log /var/log/nginx/error.log error;
}

# web service2 config.
server {
listen 80;
listen 443 ssl http2;
server_name example2.test;

# Path for SSL config/key/certificate
ssl_certificate /etc/ssl/certs/nginx/example2.crt;
ssl_certificate_key /etc/ssl/certs/nginx/example2.key;
include /etc/nginx/includes/ssl.conf;

location / {
include /etc/nginx/includes/proxy.conf;
proxy_pass http://example2_app_1;
}

access_log off;
error_log /var/log/nginx/error.log error;
}

# Default
server {
listen 80 default_server;

server_name _;
root /var/www/html;

charset UTF-8;

error_page 404 /backend-not-found.html;
location = /backend-not-found.html {
allow all;
}
location / {
return 404;
}

access_log off;
log_not_found off;
error_log /var/log/nginx/error.log error;
}

La configuration se compose de deux services Web - example1.test et exemple2.test . Les deux composants du serveur écoutent le port 80 et dirigent Nginx vers le certificat SSL approprié.

Configurer le fichier docker-compose.yml

1. Créez un nouveau fichier docker-compose.yml fichier pour le service proxy :

sudo nano docker-compose.yml

2. Copiez et collez le contenu suivant dans le fichier :

version: '2'
services:
proxy:
build: ./
networks:
- example1
- example2
ports:
- 80:80
- 443:443

networks:
example1:
external:
name: example1_default
example2:
external:
name: example2_default

Dans ce fichier, vous connectez le proxy et les réseaux externes (les services Web example1 et exemple2 ). De plus, les ports 80/443 du service proxy sont liés aux ports 80/443 de l'hôte Docker.

Générer des clés et des certificats

1. Commencez par créer un sous-répertoire (ssl ) à l'intérieur du proxy dossier :

mkdir ssl

2. Naviguez dans le ssl sous-répertoire avec :

cd ssl

3. Ensuite, exécutez chaque commande tactile répertoriée ci-dessous pour créer les fichiers requis :

touch example1.crt

touch example1.key

touch example2.crt

touch example2.key

4. Ensuite, utilisez OpenSSL pour générer des clés et des certificats pour vos services Web. Pour le premier service Web (exemple1 ), exécutez la commande :

sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout example1.key -out example1.crt

La commande génère une clé privée RSA de 2 048 bits et la stocke dans example1.key fichier.

Il vous sera également demandé de fournir certaines informations qui seront incorporées dans la demande de certificat. Vous pouvez laisser certains champs vides.

5. Répétez le processus pour générer des clés et des certificats pour le deuxième service Web (example2 ). Tapez la commande suivante dans la fenêtre du terminal :

sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout example2.key -out example2.crt

Cela génère une clé privée RSA de 2 048 bits pour example2 et l'enregistre dans example2.key fichier.

Modifier la configuration proxy et SSL

1. Quittez le ssl sous-répertoire et retour dans proxy . Pour cela, utilisez la commande :

cd ..

2. Ensuite, créez un nouveau sous-répertoire sous le nom inclut :

mkdir includes

3. Accédez à comprend et créez les fichiers proxy.conf et ssl.conf :

cd includes

touch proxy.conf

touch ssl.conf

4. Ensuite, ouvrez le proxy.conf fichier :

sudo nano proxy.conf

5. Ajoutez la configuration suivante :

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_buffering off;
proxy_request_buffering off;
proxy_http_version 1.1;
proxy_intercept_errors on;

6. Enregistrez et quittez proxy.conf .

7. Ouvrez le fichier ssl.conf :

sudo nano ssl.conf

8. Collez les lignes suivantes dans le fichier :

ssl_session_timeout 1d;
ssl_session_cache shared:SSL:50m;
ssl_session_tickets off;

ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_ciphers 'ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-
ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-
SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-
GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-
AES128-SHAECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-
SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:
DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA:ECDHE-ECDSA-
DES-CBC3-SHA:ECDHE-RSA-DES-CBC3-SHA:EDH-RSA-DES-CBC3-SHA:AES128-GCM-SHA256:
AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:DES-
CBC3-SHA:!DSS';
ssl_prefer_server_ciphers on;

Modifier le fichier hosts

1. Retournez au proxy répertoire :

cd

2. Ouvrez le fichier /etc/hosts fichier :

sudo nano etc/hosts

3. Ajoutez les lignes suivantes pour mapper les noms d'hôte des services Web à l'adresse IP privée des hôtes Docker :

10.0.2.15 example1.test
10.0.2.15 example2.test

4. Enregistrez les modifications et fermez le fichier.

Étape 5 :Démarrer le proxy inverse

1. Une fois les fichiers de configuration en place, utilisez la commande docker-compose pour créer le conteneur :

sudo docker-compose build

2. Ensuite, lancez le conteneur :

sudo docker-compose up -d

3. Vérifiez que vous disposez de trois conteneurs :deux services Web et un conteneur de proxy inverse :

sudo docker ps -a

Étape 6 :Vérifiez si le proxy inverse fonctionne

Utilisez la curl commande pour vérifier si les services Web et le proxy inverse fonctionnent correctement. Chaque domaine doit répondre avec la sortie appropriée.

1. Exécutez la commande suivante pour vérifier le premier service Web :

sudo curl example1.test

La sortie répond avec le code HTML créé pour example1.test .

2. Ensuite, vérifiez que le deuxième service Web fonctionne avec le proxy inverse avec :

sudo curl example2.test

La sortie répond avec example2.test HTML.