Anime-Sanctuary

Reverse proxy

Beaucoup d'applications écoutent sur leur propre port et ne savent pas faire de HTTPS. Nous allons mettre Apache devant elles pour qu'elles partagent un seul port 443.

Parcours
Tutoriel 20 sur 35
Durée
30 min de lecture
Vérifié avec
Commandes : essais sous Debian 13.7 (Apache 2.4.69, Python 3.13.5)
Ce que vous saurez faire
  • Expliquer ce qu'est un reverse proxy et à quoi il sert.
  • Faire répondre une petite application à travers Apache.
  • Lire les en-têtes X-Forwarded que l'application reçoit.
  • Reconnaître une erreur 502 ou 503 et en trouver la cause.

Avant de commencer : Premier site avec Apache, HTTPS avec Let's Encrypt.

Sommaire
  1. Ce qu'est un reverse proxy
  2. Lancer une petite application
  3. Activer les modules de proxy
  4. Écrire le VirtualHost du proxy
  5. Tester avec curl et lire les en-têtes
  6. Passer en HTTPS et garder le port fermé
  7. Si ça échoue
  8. Questions fréquentes
  9. La suite
  10. Sources

Comment mettre plusieurs applications derrière un seul port 443 avec Apache ? Votre serveur sait servir un site en HTTPS, mais beaucoup d'applications ne passent pas par Apache : chacune écoute sur son propre port, comme un petit serveur à part. Nous allons installer un reverse proxy, c'est-à-dire laisser Apache les accueillir à leur place. Au bout, app.exemple.fr répondra en HTTPS, alors que l'application reste cachée sur le serveur.

Ce qu'est un reverse proxy

Un reverse proxy, ou proxy inverse, est un programme placé devant une application : il reçoit les visites à sa place et les lui transmet. Un proxy est un intermédiaire, et on le dit « inverse » parce qu'il se tient du côté du serveur, pas du côté du visiteur. Pensez à la réception d'un immeuble : personne ne frappe aux portes des bureaux, tout le monde passe par l'accueil, qui oriente chacun vers le bon étage et rapporte la réponse.

Voici le trajet d'une visite, de votre navigateur à l'application et retour.

Le trajet d'une visite à travers le reverse proxy Le visiteur envoie sa demande en HTTPS à Apache sur le port 443. Apache la transmet en HTTP à l'application, qui écoute sur 127.0.0.1:3000. La réponse fait le chemin inverse. Visiteur Apache port 443 ouvert Application 1. demande 2. en HTTP 3. réponse 4. réponse
Texte équivalent : Le visiteur parle seulement à Apache, en HTTPS, sur le port 443 (flèche 1). Apache transmet la demande en HTTP à l'application, qui écoute sur 127.0.0.1:3000 (flèche 2). La réponse revient par Apache (flèches 3 et 4) et le visiteur ne voit jamais l'application.

Ici, Apache est l'accueil et chaque application est un bureau. Ce montage apporte trois choses :

  • Un seul port ouvert. Les visiteurs ne connaissent que le port 443, déjà ouvert pour HTTPS (voir Le vocabulaire : IP, DNS, domaine, port, pare-feu). Chaque application garde son propre port, caché derrière l'accueil.
  • Le HTTPS pour tout le monde. Apache chiffre la connexion, et l'application n'a rien à savoir des certificats.
  • Une adresse propre. app.exemple.fr plutôt que exemple.fr:3000.

Pour s'entraîner, il nous faut une application. Fabriquons la plus petite possible.

1Lancer une petite application

Une application web est un programme qui écoute un port et répond aux demandes. La nôtre tient en quelques lignes de Python, un langage de programmation. Elle écoute le port 3000 et répond en recopiant trois informations reçues, ce qui nous servira plus loin. Installons d'abord Python.

Sur le serveur
sudo apt install -y python3

Écrivons ensuite l'application dans un fichier app.py, dans votre dossier personnel.

Sur le serveur
cat > app.py <<'EOF'
from http.server import BaseHTTPRequestHandler, HTTPServer

class App(BaseHTTPRequestHandler):
    def do_GET(self):
        if self.path == "/vieux":
            self.send_response(302)
            self.send_header("Location", "http://127.0.0.1:3000/nouveau")
        else:
            self.send_response(200)
        self.end_headers()
        for nom in ("Host", "X-Forwarded-For", "X-Forwarded-Proto"):
            self.wfile.write(f"{nom}: {self.headers.get(nom)}\n".encode())

HTTPServer(("127.0.0.1", 3000), App).serve_forever()
EOF

La dernière ligne la fait écouter sur 127.0.0.1, l'adresse par laquelle le serveur se désigne lui-même. Ouvrez une deuxième fenêtre de terminal, connectez-vous au serveur et lancez-la. Le programme garde la main : laissez cette fenêtre ouverte, il ne s'affichera rien.

Sur le serveur (deuxième terminal)
python3 app.py

Dans la première fenêtre, interrogeons l'application directement.

Sur le serveur
curl -s http://127.0.0.1:3000/
Résultat attendu
Host: 127.0.0.1:3000
X-Forwarded-For: None
X-Forwarded-Proto: None

Elle répond. None veut dire « rien reçu » : personne ne se trouve encore devant elle. Regardons maintenant qui peut l'atteindre : ss -ltn liste les ports qui attendent des visiteurs, et grep 3000 ne garde que le nôtre.

Sur le serveur
ss -ltn | grep 3000
Résultat attendu
LISTEN 0      5          127.0.0.1:3000      0.0.0.0:*

L'adresse 127.0.0.1:3000 signifie « le port 3000, mais seulement pour le serveur lui-même ». Aucun visiteur ne peut donc la joindre pour l'instant, et c'est exactement ce que nous voulons. Il reste à lui donner un accueil.

2Activer les modules de proxy

Apache range ses fonctions dans des modules qu'on active un par un, et le proxy en demande trois :

  • proxy : le cœur du mécanisme, qui sait transmettre une demande ailleurs.
  • proxy_http : celui qui parle HTTP avec l'application.
  • headers : celui qui ajoute des en-têtes aux demandes, ce que nous ferons à l'étape 3.
Sur le serveur
sudo a2enmod proxy proxy_http headers

La commande active les modules et vous invite à redémarrer Apache. Un redémarrage complet est nécessaire ici, car un simple rechargement ne charge pas de nouveau module.

Sur le serveur
sudo systemctl restart apache2

Vérifions que les trois modules sont chargés.

Sur le serveur
apache2ctl -M | grep -E 'proxy_module|proxy_http_module|headers_module'
Résultat attendu
 headers_module (shared)
 proxy_module (shared)
 proxy_http_module (shared)

Les trois sont là. Apache sait maintenant transmettre : reste à lui dire quoi transmettre, et à qui.

3Écrire le VirtualHost du proxy

Un VirtualHost est le bloc de réglages d'un site, comme dans Premier site avec Apache. Celui-ci ne contient aucune page : il transmet tout à l'application. Voici le fichier, puis le rôle des lignes qui comptent.

Sur le serveur
sudo tee /etc/apache2/sites-available/app.exemple.fr.conf > /dev/null <<'EOF'
<VirtualHost *:80>
    ServerName app.exemple.fr
    ProxyPreserveHost On
    ProxyPass / http://127.0.0.1:3000/
    ProxyPassReverse / http://127.0.0.1:3000/
    RequestHeader set X-Forwarded-Proto expr=%{REQUEST_SCHEME}
    ErrorLog ${APACHE_LOG_DIR}/app-error.log
    CustomLog ${APACHE_LOG_DIR}/app-access.log combined
</VirtualHost>
EOF
  • ProxyPass : toute demande reçue par ce site est transmise à l'application, à l'adresse indiquée.
  • ProxyPassReverse : quand l'application répond « allez voir ailleurs » en citant sa propre adresse, Apache la remplace par l'adresse publique.
  • ProxyPreserveHost On : l'application reçoit le nom que le visiteur a tapé, et non 127.0.0.1:3000.
  • RequestHeader set : ajoute à la demande une ligne d'information pour l'application, ici le protocole utilisé (http ou https). L'étape 4 la montre.

Activons le site, vérifions la syntaxe, puis rechargeons Apache (même méthode que pour le premier site).

Sur le serveur
sudo a2ensite app.exemple.fr.conf
Résultat attendu
Enabling site app.exemple.fr.
Sur le serveur
sudo apache2ctl configtest
Résultat attendu
Syntax OK
Sur le serveur
sudo systemctl reload apache2

Si une ligne AH00558 précède Syntax OK, c'est un simple avertissement. Voyons si l'accueil fait son travail.

4Tester avec curl et lire les en-têtes

Pour tester sans attendre le nom de domaine, demandons la page au serveur lui-même en précisant le nom du site avec -H, comme dans l'article sur Apache. La demande passe par Apache et ressort à l'application.

Sur le serveur
curl -s -H "Host: app.exemple.fr" http://localhost/
Résultat attendu
Host: app.exemple.fr
X-Forwarded-For: 127.0.0.1
X-Forwarded-Proto: http

L'application répond à travers Apache, et cette fois les trois lignes sont remplies. Un en-tête est une ligne d'information qui accompagne une demande, comme la mention « urgent » sur une enveloppe. Pour l'application, tous les visiteurs viennent de l'accueil. Apache lui glisse donc leur vraie identité dans des en-têtes. Il ajoute X-Forwarded-For tout seul ; le dernier vient de notre ligne RequestHeader.

  • Host : le nom tapé par le visiteur. Sans ProxyPreserveHost, l'application aurait lu 127.0.0.1:3000.
  • X-Forwarded-For : l'adresse du visiteur, ajoutée par Apache. Ici c'est le serveur lui-même, puisque le test vient de lui ; depuis chez vous, vous y verriez votre adresse IP.
  • X-Forwarded-Proto : le protocole utilisé, http ou https. C'est notre ligne RequestHeader qui la remplit.

Le préfixe X-Forwarded veut dire « transmis par un intermédiaire ». Une application qui journalise les visiteurs ou construit des liens en a besoin. Testons maintenant la redirection : notre chemin /vieux renvoie vers /nouveau en citant l'adresse de l'application.

Sur le serveur
curl -s -D - -o /dev/null -H "Host: app.exemple.fr" http://localhost/vieux | grep -i location
Résultat attendu
Location: http://app.exemple.fr/nouveau

L'application avait écrit 127.0.0.1:3000, et Apache l'a remplacé par l'adresse publique grâce à ProxyPassReverse. Sans cette ligne, le navigateur aurait été envoyé vers une adresse qu'il ne peut pas atteindre.

Et pour une messagerie en direct ?

Une application qui garde une connexion ouverte avec le navigateur, un WebSocket, comme une messagerie en direct, demande en plus le module proxy_wstunnel. La nôtre n'en a pas besoin.

Le proxy marche en HTTP. Il reste à le passer en HTTPS, et à vérifier que l'application reste cachée.

5Passer en HTTPS et garder le port fermé

Passer ce site en HTTPS se fait comme pour exemple.fr. D'abord, ajoutez chez votre fournisseur de nom de domaine un enregistrement de type A, qui relie app.exemple.fr à 203.0.113.10 (voir Nom de domaine et DNS). Ensuite, demandez le certificat avec la même commande que dans HTTPS avec Let's Encrypt.

Sur le serveur
sudo certbot --apache --redirect -d app.exemple.fr

Certbot recopie le bloc du site en version HTTPS, lignes de proxy comprises, et redirige le port 80 vers lui. Notre ligne RequestHeader suit donc le protocole réel. Vérifions depuis votre ordinateur.

Sur votre ordinateur
curl -s https://app.exemple.fr/ | grep Proto
Résultat attendu
X-Forwarded-Proto: https

L'application sait maintenant que le visiteur est en HTTPS. Reste le point de sécurité le plus important de cet article : l'application ne doit jamais être joignable directement.

Le pare-feu refuse par défaut tout ce que vous n'avez pas ouvert (voir Pare-feu avec ufw), et le 3000 n'a besoin d'aucune règle. Vérifions-le depuis votre ordinateur : cette commande doit échouer, par un délai dépassé ou une connexion refusée, sans afficher les trois lignes de l'application.

Sur votre ordinateur
curl -sS --max-time 5 http://app.exemple.fr:3000/

Quand vous aurez fini d'explorer, arrêtez l'application dans la deuxième fenêtre avec Ctrl+C.

Si ça échoue

Trois situations reviennent le plus souvent. Pour les deux premières, le journal d'erreurs du site donne la cause :

Sur le serveur
sudo tail -n 2 /var/log/apache2/app-error.log
  • Une erreur 503 Service Unavailable. L'accueil ne trouve personne au bureau : l'application est arrêtée ou n'écoute pas sur ce port. Le journal dit AH00957 avec Connection refused. Relancez python3 app.py et vérifiez avec curl -s http://127.0.0.1:3000/.
  • Une erreur 502 Proxy Error. L'application a répondu, mais mal : elle a coupé la connexion ou planté en route. Le journal dit AH01102 ou AH00898. Cherchez la cause dans les messages de l'application elle-même, pas dans Apache.
  • Une redirection qui mène à 127.0.0.1:3000. La ligne ProxyPassReverse manque ou ne cite pas la même adresse que ProxyPass. Corrigez, lancez configtest, puis rechargez Apache.

Questions fréquentes

C'est quoi un reverse proxy ?

Un reverse proxy est un programme placé devant une application : il reçoit les visites à sa place et les lui transmet. Les visiteurs ne connaissent que le port 443, l'application reste cachée.

Comment mettre une application derrière Apache avec un seul port 443 ?

Activez les modules proxy et proxy_http, puis écrivez un VirtualHost qui transmet tout à l'application avec ProxyPass. L'application écoute seulement sur 127.0.0.1.

Pourquoi une erreur 502 ou 503 derrière Apache ?

Une erreur 503 veut dire que l'application est arrêtée ou n'écoute pas sur ce port. Une erreur 502 veut dire qu'elle a répondu mal ou coupé la connexion. Le journal d'erreurs du site donne la cause.

La suite

Votre application d'essai s'arrête quand vous fermez la fenêtre. Les vraies applications doivent tourner en continu, redémarrer après une panne et ne pas se marcher dessus. On les range pour cela dans des boîtes isolées, avec Docker, et c'est justement derrière un accueil comme le vôtre qu'on les place. L'article suivant, Docker et Docker Compose, installe Docker.