Configuration de Nginx en tant que proxy inverse pour les applications backend

Introduction

Dans les configurations de serveurs modernes, les applications communiquent rarement directement avec Internet. Au lieu de cela, un proxy inverse se place devant elles et gère les requêtes des clients entrants. Nginx est l'un des outils les plus populaires pour ce travail car il est rapide, fiable et facile à configurer. Dans ce tutoriel, vous apprendrez à configurer Nginx en tant que proxy inverse pour une application backend fonctionnant sur le même serveur.

Qu'est-ce qu'un proxy inverse ?

Un proxy inverse est un serveur qui :

• Accepte les requêtes des clients (navigateurs, API, etc.)
• Transmet ces requêtes à une application backend
• Renvoie la réponse du backend au client

Le client ne communique jamais directement avec l'application backend.

Proxy inverse vs accès direct

Sans proxy inverse :

Client ---> Application backend (port 3000)

Avec un proxy inverse :

Client ---> Nginx (port 80, 443) ---> Application backend (port 3000)

Pourquoi utiliser Nginx comme proxy inverse ?

Utiliser Nginx devant votre application vous permet de :

• N'exposer que les ports 80/443 à Internet
• Cacher les services backend de l'accès direct
• Terminer HTTPS (TLS) en un seul endroit
• Ajouter des journaux, un contrôle d'accès et une limitation de débit
• Exécuter plusieurs applications sur un seul serveur

Pour les administrateurs système, cela signifie une meilleure sécurité et une gestion plus facile.

Scénario utilisé dans ce tutoriel

Pour simplifier les choses, nous utiliserons la configuration suivante :

• Nginx écoute sur le port 80
• L'application backend écoute sur 127.0.0.1:3000
• Les requêtes vers http://example.com sont transmises au backend

Diagramme de flux de trafic

[ Navigateur ]
    |
    v
[ Nginx example.com:80,443 ]
    |
    v
[ Application backend 127.0.0.1:3000 ]

Prérequis

Avant de commencer, assurez-vous d'avoir :

• Un serveur Linux avec la dernière version stable de Debian
• Un accès root ou sudo
• Une application backend déjà en cours d'exécution (par exemple, une application Node.js, Python ou Java)
• Une familiarité de base avec le terminal Linux

Installer Nginx

Mettez à jour les listes de paquets et installez Nginx et curl (pour tester la configuration) :

sudo apt update

sudo apt install nginx curl

Vérifiez que Nginx est en cours d'exécution :

systemctl status nginx

Vous devriez voir "active (running)" dans la sortie.

Testez Nginx localement :

curl http://localhost

Si Nginx fonctionne, vous recevrez la page d'accueil par défaut.

Comprendre la structure de configuration de Nginx

Les fichiers de configuration de Nginx sont généralement stockés dans /etc/nginx/. Répertoires importants :

• /etc/nginx/nginx.conf — fichier de configuration principal
• /etc/nginx/sites-available/ — fichiers de configuration de site (non actifs)
• /etc/nginx/sites-enabled/ — configurations de site activées (liens symboliques)

Nginx lit les fichiers de configuration à partir du dossier sites-enabled, pas directement à partir de sites-available. Il est recommandé de créer des fichiers de configuration de site dans sites-available puis de créer des liens symboliques vers eux dans sites-enabled.

Créer une configuration de proxy inverse

Créer un nouveau fichier de site

sudo nano /etc/nginx/sites-available/reverse-proxy.conf

Ajouter la configuration de proxy inverse

server {
    listen 80;
    server_name example.com;

    location / {
        proxy_pass http://127.0.0.1:3000;
        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;
    }
}

Comprendre la configuration

Bloc serveur

server {
    listen 80;
    server_name example.com;
}

• listen 80; — Nginx écoute le trafic HTTP sur le port 80
• server_name example.com; — nom de domaine auquel ce bloc serveur répond

Bloc de localisation

location / {
    proxy_pass http://127.0.0.1:3000;
    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;
}

• location / — correspond à toutes les URL entrantes
• proxy_pass — transmet les requêtes à l'application backend

En-têtes de proxy

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;

Ces en-têtes garantissent que le backend connaît :

• Le nom de domaine d'origine
• L'adresse IP réelle du client
• Si la requête était HTTP ou HTTPS

Sans ces en-têtes, les applications backend peuvent enregistrer des informations incorrectes sur le client.

Activer la configuration

Désactivez le site par défaut de Nginx pour éviter les conflits sur le port 80 :

sudo rm /etc/nginx/sites-enabled/default

Créez un lien symbolique pour activer le site :

sudo ln -s /etc/nginx/sites-available/reverse-proxy.conf /etc/nginx/sites-enabled/

Testez la configuration pour détecter les erreurs de syntaxe :

sudo nginx -t

Si le test est réussi, rechargez Nginx :

sudo systemctl reload nginx

Tester le proxy inverse

Testez depuis le serveur :

curl http://example.com

Ouvrez http://example.com dans un navigateur pour tester. Vous devriez recevoir une réponse de votre application backend, et non de la page par défaut de Nginx. Si tout est configuré correctement, l'application backend se chargera.

Comment la requête est traitée

1. Le client envoie une requête à example.com
2. Nginx reçoit la requête sur le port 80
3. Nginx transmet la requête à 127.0.0.1:3000
4. Le backend traite la requête
5. La réponse revient via Nginx
6. Le client reçoit la réponse

Erreurs courantes et dépannage

Backend non en cours d'exécution

• Assurez-vous que l'application est en cours d'exécution
• Confirmez le port correct

ss -tuln | grep 3000

Mauvaise adresse proxy_pass

• Incluez toujours http://
• Assurez-vous que l'IP et le port sont corrects

Oubli de recharger Nginx

Après chaque changement de configuration :

sudo systemctl reload nginx

Pare-feu bloquant l'accès

Assurez-vous que le port 80 est ouvert :

sudo ufw allow 80

Améliorations facultatives

Une fois que le proxy inverse fonctionne, envisagez de :

• Activer HTTPS avec Let's Encrypt
• Exécuter plusieurs applications backend
• Ajouter des journaux d'accès et des journaux d'erreurs
• Configurer l'équilibrage de charge
• Prendre en charge les connexions WebSocket

Configuration HTTPS

Dans les environnements de production, vous devriez toujours utiliser HTTPS au lieu de HTTP. HTTPS chiffre le trafic entre le client et votre serveur, protégeant les mots de passe, les jetons API, les cookies et autres données sensibles. Nginx prend en charge HTTPS à l'aide de certificats SSL/TLS. Dans cette section, vous apprendrez :

• Ce qu'est Certbot
• Comment installer Certbot
• Comment Certbot modifie automatiquement la configuration de Nginx
• Comment configurer Nginx manuellement à l'aide d'un certificat acheté

Qu'est-ce que Certbot ?

Certbot est un outil qui obtient et installe automatiquement des certificats SSL/TLS gratuits de Let's Encrypt. Il peut :

• Demander un certificat gratuit
• Vérifier la propriété du domaine
• Configurer automatiquement Nginx
• Configurer le renouvellement automatique des certificats

Pour les débutants et la plupart des environnements de production, Certbot est le moyen le plus simple et le plus sûr d'activer HTTPS.

Installation de Certbot

Mettez à jour les listes de paquets :

sudo apt update

Installez Certbot et le plugin Nginx :

sudo apt install certbot python3-certbot-nginx

Le paquet python3-certbot-nginx permet à Certbot de modifier automatiquement votre configuration Nginx.

Obtention et installation d'un certificat

Avant d'exécuter Certbot, assurez-vous que :

• Votre nom de domaine pointe vers l'adresse IP publique de votre serveur
• Nginx est en cours d'exécution
• Les ports 80 et 443 sont ouverts dans le pare-feu

Exécutez :

sudo certbot --nginx

Certbot va :

1. Demander quel domaine vous souhaitez sécuriser
2. Vérifier la propriété du domaine
3. Mettre à jour automatiquement votre configuration Nginx
4. Recharger Nginx

Exemple de configuration ajoutée par Certbot :

server {
    listen 443 ssl;
    server_name example.com;

    ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;

    location / {
        proxy_pass http://127.0.0.1:3000;
        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;
    }
}

Certbot peut également modifier le bloc HTTP pour rediriger le trafic :

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

Parce que Certbot édite automatiquement les fichiers de configuration, il est recommandé de :

• Garder des sauvegardes de votre configuration
• Comprendre les modifications apportées
• Toujours tester la configuration après les modifications

Testez la configuration :

sudo nginx -t

Renouvellement automatique des certificats

Les certificats Let's Encrypt sont valides pendant 90 jours. Certbot installe automatiquement un minuteur de renouvellement. Vous pouvez tester le renouvellement avec :

sudo certbot renew --dry-run

Si configuré correctement, le renouvellement se fera automatiquement sans interruption.

Utilisation d'un certificat SSL acheté

Si vous achetez un certificat SSL auprès d'une autorité de certification (CA), vous devez configurer Nginx manuellement. Après l'achat, vous recevez généralement :

• Un fichier de certificat (par exemple, example.com.crt)
• Une clé privée (example.com.key)
• Un fichier de bundle CA (ca_bundle.crt)

Créez un répertoire sécurisé :

sudo mkdir -p /etc/nginx/ssl

sudo chmod 700 /etc/nginx/ssl

Copiez vos fichiers de certificat dans ce répertoire.

Exemple de configuration HTTPS avec un certificat acheté :

server {
    listen 443 ssl;
    server_name example.com www.example.com;

    ssl_certificate /etc/nginx/ssl/example.com.crt;
    ssl_certificate_key /etc/nginx/ssl/example.com.key;
    ssl_trusted_certificate /etc/nginx/ssl/ca_bundle.crt;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;

    location / {
        proxy_pass http://127.0.0.1:3000;
        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;
    }
}

Ajoutez une redirection HTTP vers HTTPS :

server {
    listen 80;
    server_name example.com www.example.com;
    return 301 https://$host$request_uri;
}

Rechargez Nginx après la configuration manuelle :

sudo nginx -t

sudo systemctl reload nginx

Résumé

Dans ce tutoriel, vous avez appris :

• Ce qu'est un proxy inverse et pourquoi il est utile
• Comment Nginx transmet les requêtes aux applications backend
• Comment créer et activer une configuration de proxy inverse
• Comment tester et dépanner les problèmes courants
• Comment configurer HTTPS

Le proxy inverse Nginx est une compétence fondamentale pour les administrateurs système et est largement utilisé dans les environnements de production.