Comment configurer Nginx en tant que serveur Web et proxy inverse pour Apache sur un serveur Ubuntu 18.04

De Get Docs
Aller à :navigation, rechercher

L'auteur a sélectionné la Electronic Frontier Foundation pour recevoir un don dans le cadre du programme Write for DOnations.

Introduction

Apache et Nginx sont deux serveurs Web open source populaires souvent utilisés avec PHP. Il peut être utile de les exécuter tous les deux sur la même machine virtuelle lors de l'hébergement de plusieurs sites Web aux exigences variées. La solution générale pour exécuter deux serveurs Web sur un seul système consiste à utiliser plusieurs adresses IP ou des numéros de port différents.

Les serveurs qui ont à la fois des adresses IPv4 et IPv6 peuvent être configurés pour servir les sites Apache sur un protocole et les sites Nginx sur l'autre, mais ce n'est pas pratique actuellement, car l'adoption d'IPv6 par les FAI n'est pas encore très répandue. Avoir un numéro de port différent comme 81 ou 8080 pour le deuxième serveur Web est une autre solution, mais partager des URL avec des numéros de port (comme http://example.com:81) n'est pas toujours raisonnable ou idéal.

Dans ce didacticiel, vous allez configurer Nginx à la fois en tant que serveur Web et en tant que proxy inverse pour Apache, le tout sur un seul serveur.

Selon l'application Web, des modifications de code peuvent être nécessaires pour maintenir la prise en charge du proxy inverse Apache, en particulier lorsque des sites SSL sont configurés. Pour éviter cela, vous installerez un module Apache appelé mod_rpaf qui réécrit certaines variables d'environnement afin qu'il semble qu'Apache gère directement les requêtes des clients Web.

Nous hébergerons quatre noms de domaine sur un seul serveur. Deux seront servis par Nginx : example.com (l'hôte virtuel par défaut) et sample.org. Les deux autres, foobar.net et test.io, seront servis par Apache. Nous configurerons également Apache pour servir les applications PHP à l'aide de PHP-FPM, qui offre de meilleures performances par rapport à mod_php.

Conditions préalables

Pour terminer ce didacticiel, vous aurez besoin des éléments suivants :

Étape 1 - Installation d'Apache et de PHP-FPM

Commençons par installer Apache et PHP-FPM.

En plus d'Apache et de PHP-FPM, nous allons également installer le module PHP FastCGI Apache, libapache2-mod-fastcgi, pour prendre en charge les applications Web FastCGI.

Tout d'abord, mettez à jour votre liste de packages pour vous assurer que vous disposez des derniers packages.

sudo apt update

Ensuite, installez les packages Apache et PHP-FPM :

sudo apt install apache2 php-fpm

Le module FastCGI Apache n'est pas disponible dans le référentiel d'Ubuntu, alors téléchargez-le depuis kernel.org et installez-le à l'aide de la commande dpkg.

wget https://mirrors.edge.kernel.org/ubuntu/pool/multiverse/liba/libapache-mod-fastcgi/libapache2-mod-fastcgi_2.4.7~0910052141-1.2_amd64.deb
sudo dpkg -i libapache2-mod-fastcgi_2.4.7~0910052141-1.2_amd64.deb

Ensuite, changeons la configuration par défaut d'Apache pour utiliser PHP-FPM.

Étape 2 - Configuration d'Apache et de PHP-FPM

Dans cette étape, nous allons changer le numéro de port d'Apache en 8080 et le configurer pour qu'il fonctionne avec PHP-FPM à l'aide du module mod_fastcgi. Renommez le fichier de configuration ports.conf d'Apache :

sudo mv /etc/apache2/ports.conf /etc/apache2/ports.conf.default

Créez un nouveau fichier ports.conf avec le port défini sur 8080 :

echo "Listen 8080" | sudo tee /etc/apache2/ports.conf

Remarque : Les serveurs Web sont généralement configurés pour écouter sur 127.0.0.1:8080 lors de la configuration d'un proxy inverse, mais cela définirait la valeur de la variable d'environnement de PHP SERVER_ADDR sur l'adresse IP de bouclage au lieu de l'IP publique du serveur. Notre objectif est de configurer Apache de manière à ce que ses sites Web ne voient pas de proxy inverse devant lui. Nous allons donc le configurer pour écouter sur 8080 sur toutes les adresses IP.


Ensuite, nous allons créer un fichier d'hôte virtuel pour Apache. La directive <VirtualHost> de ce fichier sera définie pour desservir les sites uniquement sur le port 8080.

Désactivez l'hôte virtuel par défaut :

sudo a2dissite 000-default

Créez ensuite un nouveau fichier d'hôte virtuel, en utilisant le site par défaut existant :

sudo cp /etc/apache2/sites-available/000-default.conf /etc/apache2/sites-available/001-default.conf

Ouvrez maintenant le nouveau fichier de configuration :

sudo nano /etc/apache2/sites-available/001-default.conf

Changez le port d'écoute en 8080 :

/etc/apache2/sites-available/000-default.conf

<VirtualHost *:8080>
    ServerAdmin [email protected]
    DocumentRoot /var/www/html
    ErrorLog ${APACHE_LOG_DIR}/error.log
    CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

Enregistrez le fichier et activez le nouveau fichier de configuration :

sudo a2ensite 001-default

Rechargez ensuite Apache :

sudo systemctl reload apache2

Vérifiez qu'Apache écoute maintenant sur 8080 :

sudo netstat -tlpn

La sortie devrait ressembler à l'exemple suivant, avec apache2 écoutant sur 8080 :

OutputActive Internet connections (only servers)
Proto Recv-Q Send-Q Local Address     Foreign Address      State    PID/Program name
tcp        0      0 0.0.0.0:22        0.0.0.0:*            LISTEN   1086/sshd
tcp6       0      0 :::8080           :::*                 LISTEN   4678/apache2
tcp6       0      0 :::22             :::*                 LISTEN   1086/sshd

Une fois que vous avez vérifié qu'Apache écoute sur le bon port, vous pouvez configurer la prise en charge de PHP et FastCGI.

Étape 3 - Configuration d'Apache pour utiliser mod_fastcgi

Apache sert les pages PHP en utilisant mod_php par défaut, mais il nécessite une configuration supplémentaire pour fonctionner avec PHP-FPM.

Remarque : Si vous essayez ce didacticiel sur une installation existante de LAMP avec mod_php, désactivez-le d'abord avec sudo a2dismod php7.2.


Nous allons ajouter un bloc de configuration pour mod_fastcgi qui dépend de mod_action. mod_action est désactivé par défaut, nous devons donc d'abord l'activer :

sudo a2enmod actions

Renommez le fichier de configuration FastCGI existant :

sudo mv /etc/apache2/mods-enabled/fastcgi.conf /etc/apache2/mods-enabled/fastcgi.conf.default

Créez un nouveau fichier de configuration :

sudo nano /etc/apache2/mods-enabled/fastcgi.conf

Ajoutez les directives suivantes au fichier pour transmettre les demandes de fichiers .php au socket PHP-FPM UNIX :

/etc/apache2/mods-enabled/fastcgi.conf

<IfModule mod_fastcgi.c>
  AddHandler fastcgi-script .fcgi
  FastCgiIpcDir /var/lib/apache2/fastcgi
  AddType application/x-httpd-fastphp .php
  Action application/x-httpd-fastphp /php-fcgi
  Alias /php-fcgi /usr/lib/cgi-bin/php-fcgi
  FastCgiExternalServer /usr/lib/cgi-bin/php-fcgi -socket /run/php/php7.2-fpm.sock -pass-header Authorization
  <Directory /usr/lib/cgi-bin>
    Require all granted
  </Directory>
</IfModule>

Enregistrez les modifications et effectuez un test de configuration :

sudo apachectl -t

Recharger Apache si Syntaxe OK s'affiche :

sudo systemctl reload apache2

Si vous voyez l'avertissement Could not reliably determine the server's fully qualified domain name, using 127.0.1.1. Set the 'ServerName' directive globally to suppress this message., vous pouvez l'ignorer en toute sécurité pour le moment. Nous configurerons les noms de serveur plus tard.

Assurons-nous maintenant que nous pouvons servir PHP à partir d'Apache.

Étape 4 - Vérification de la fonctionnalité PHP

Assurons-nous que PHP fonctionne en créant un fichier phpinfo() et en y accédant depuis un navigateur Web.

Créez le fichier /var/www/html/info.php qui contient un appel à la fonction phpinfo :

echo "<?php phpinfo(); ?>" | sudo tee /var/www/html/info.php

Notez que si vous avez suivi la configuration initiale du serveur dans les sections Prérequis, vous avez probablement activé le pare-feu Apache. Allons-y et assurons-nous que nous pouvons accéder à notre IP sur le port 8080, qui n'est pas accessible actuellement. Nous limiterons l'accès public à ce port à l'Étape 10.

Autorisez d'abord le port 8080 à travers le pare-feu :

sudo ufw allow 8080

Puisque nous allons sécuriser nos domaines Apache, allons-y et assurons-nous que le trafic TLS sur le port 443 peut entrer.

Autoriser Apache Full à autoriser le trafic sur les ports 80 et 443 :

sudo ufw allow "Apache Full"

Vérifiez maintenant l'état de votre pare-feu :

sudo ufw status

Si vous avez suivi les prérequis, la sortie ressemblera à ceci :

OutputTo                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
Apache Full                ALLOW       Anywhere
8080                       ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
Apache Full (v6)           ALLOW       Anywhere (v6)
8080 (v6)                  ALLOW       Anywhere (v6)

Vous verrez que les ports 8080 et Apache Full sont autorisés avec toutes les autres règles de pare-feu. Voyons maintenant notre page info.php.

Pour voir le fichier dans un navigateur, accédez à http://your_server_ip:8080/info.php. Cela vous donnera une liste des paramètres de configuration que PHP utilise.

En haut de la page, vérifiez que Server API indique FPM/FastCGI. Environ aux deux tiers de la page, la section PHP Variables vous indiquera que le SERVER_SOFTWARE est Apache sur Ubuntu. Ceux-ci confirment que mod_fastcgi est actif et qu'Apache utilise PHP-FPM pour traiter les fichiers PHP.

Étape 5 - Création d'hôtes virtuels pour Apache

Créons des fichiers d'hôte virtuel Apache pour les domaines foobar.net et test.io. Pour ce faire, nous allons d'abord créer des répertoires racine de documents pour les deux sites et placer des fichiers par défaut dans ces répertoires afin de pouvoir tester facilement notre configuration.

Tout d'abord, créez les répertoires racine des documents :

sudo mkdir -v /var/www/foobar.net /var/www/test.io

Créez ensuite un fichier index pour chaque site :

echo "<h1 style='color: green;'>Foo Bar</h1>" | sudo tee /var/www/foobar.net/index.html
echo "<h1 style='color: red;'>Test IO</h1>" | sudo tee /var/www/test.io/index.html

Créez ensuite un fichier phpinfo() pour chaque site afin que nous puissions tester que PHP est correctement configuré.

echo "<?php phpinfo(); ?>" | sudo tee /var/www/foobar.net/info.php
echo "<?php phpinfo(); ?>" | sudo tee /var/www/test.io/info.php

Créez maintenant le fichier d'hôte virtuel pour le domaine foobar.net :

sudo nano /etc/apache2/sites-available/foobar.net.conf

Ajoutez le code suivant au fichier pour définir l'hôte :

/etc/apache2/sites-available/foobar.net.conf

    <VirtualHost *:8080>
        ServerName foobar.net
        ServerAlias www.foobar.net
        DocumentRoot /var/www/foobar.net
        <Directory /var/www/foobar.net>
            AllowOverride All
        </Directory>
    </VirtualHost>

La ligne AllowOverride All active la prise en charge de .htaccess.

Ce ne sont que les directives les plus élémentaires. Pour un guide complet sur la configuration des hôtes virtuels dans Apache, consultez Comment configurer des hôtes virtuels Apache sur Ubuntu 16.04.

Enregistrez et fermez le fichier. Créez ensuite une configuration similaire pour test.io. Créez d'abord le fichier :

sudo nano /etc/apache2/sites-available/test.io.conf

Ajoutez ensuite la configuration au fichier :

/etc/apache2/sites-available/test.io.conf

    <VirtualHost *:8080>
        ServerName test.io
        ServerAlias www.test.io
        DocumentRoot /var/www/test.io
        <Directory /var/www/test.io>
            AllowOverride All
        </Directory>
    </VirtualHost>

Enregistrez le fichier et quittez l'éditeur.

Maintenant que les deux hôtes virtuels Apache sont configurés, activez les sites à l'aide de la commande a2ensite. Cela crée un lien symbolique vers le fichier de l'hôte virtuel dans le répertoire sites-enabled :

sudo a2ensite foobar.net
sudo a2ensite test.io

Vérifiez à nouveau Apache pour les erreurs de configuration :

sudo apachectl -t

Vous verrez Syntaxe OK affiché s'il n'y a pas d'erreurs. Si vous voyez autre chose, vérifiez la configuration et réessayez.

Rechargez Apache pour appliquer les modifications une fois que votre configuration est sans erreur :

sudo systemctl reload apache2

Pour confirmer que les sites fonctionnent, ouvrez http://foobar.net:8080 et http://test.io:8080 dans votre navigateur et vérifiez que chaque site affiche son fichier index.html.

Vous verrez les résultats suivants :

Assurez-vous également que PHP fonctionne en accédant aux fichiers info.php pour chaque site. Visitez http://foobar.net:8080/info.php et http://test.io:8080/info.php dans votre navigateur.

Vous verrez la même liste de spécifications de configuration PHP sur chaque site que celle que vous avez vue à l'étape 4.

Nous avons maintenant deux sites Web hébergés sur Apache au port 8080. Configurons ensuite Nginx.

Étape 6 - Installation et configuration de Nginx

Dans cette étape, nous allons installer Nginx et configurer les domaines example.com et sample.org en tant qu'hôtes virtuels de Nginx. Pour un guide complet sur la configuration des hôtes virtuels dans Nginx, voir Comment configurer les blocs de serveur Nginx (hôtes virtuels) sur Ubuntu 18.04.

Installez Nginx à l'aide du gestionnaire de packages :

sudo apt install nginx

Supprimez ensuite le lien symbolique de l'hôte virtuel par défaut puisque nous ne l'utiliserons plus :

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

Nous créerons notre propre site par défaut plus tard (example.com).

Nous allons maintenant créer des hôtes virtuels pour Nginx en utilisant la même procédure que nous avons utilisée pour Apache. Créez d'abord des répertoires racine de documents pour les deux sites Web :

sudo mkdir -v /usr/share/nginx/example.com /usr/share/nginx/sample.org

Nous conserverons les sites Web Nginx dans /usr/share/nginx, là où Nginx les veut par défaut. Vous pouvez les mettre sous /var/www/html avec les sites Apache, mais cette séparation peut vous aider à associer des sites à Nginx.

Comme vous l'avez fait avec les hôtes virtuels d'Apache, créez les fichiers index et phpinfo() à tester une fois l'installation terminée :

echo "<h1 style='color: green;'>Example.com</h1>" | sudo tee /usr/share/nginx/example.com/index.html
echo "<h1 style='color: red;'>Sample.org</h1>" | sudo tee /usr/share/nginx/sample.org/index.html
echo "<?php phpinfo(); ?>" | sudo tee /usr/share/nginx/example.com/info.php
echo "<?php phpinfo(); ?>" | sudo tee /usr/share/nginx/sample.org/info.php

Créez maintenant un fichier d'hôte virtuel pour le domaine example.com :

sudo nano /etc/nginx/sites-available/example.com

Nginx appelle les zones server {. . .} d'un fichier de configuration blocs de serveur. Créez un bloc de serveur pour l'hôte virtuel principal, example.com. La directive de configuration default_server en fait l'hôte virtuel par défaut qui traite les requêtes HTTP qui ne correspondent à aucun autre hôte virtuel.

/etc/nginx/sites-available/example.com

server {
    listen 80 default_server;

    root /usr/share/nginx/example.com;
    index index.php index.html index.htm;

    server_name example.com www.example.com;
    location / {
        try_files $uri $uri/ /index.php;
    }

    location ~ \.php$ {
        fastcgi_pass unix:/run/php/php7.2-fpm.sock;
        include snippets/fastcgi-php.conf;
    }
}

Enregistrez et fermez le fichier. Créez maintenant un fichier d'hôte virtuel pour le deuxième domaine de Nginx, sample.org :

sudo nano etc/nginx/sites-available/sample.org

Ajoutez ce qui suit au fichier :

/etc/nginx/sites-available/sample.org

server {
    root /usr/share/nginx/sample.org;
    index index.php index.html index.htm;

    server_name sample.org www.sample.org;
    location / {
        try_files $uri $uri/ /index.php;
    }

    location ~ \.php$ {
        fastcgi_pass unix:/run/php/php7.2-fpm.sock;
        include snippets/fastcgi-php.conf;
    }
}

Enregistrez et fermez le fichier.

Activez ensuite les deux sites en créant des liens symboliques vers le répertoire sites-enabled :

sudo ln -s /etc/nginx/sites-available/example.com /etc/nginx/sites-enabled/example.com
sudo ln -s /etc/nginx/sites-available/sample.org /etc/nginx/sites-enabled/sample.org

Testez ensuite la configuration Nginx pour vous assurer qu'il n'y a pas de problèmes de configuration :

sudo nginx -t

Rechargez ensuite Nginx s'il n'y a pas d'erreur :

sudo systemctl reload nginx

Accédez maintenant au fichier phpinfo() de vos hôtes virtuels Nginx dans un navigateur Web en visitant http://example.com/info.php et http://sample.org/ info.php. Regardez à nouveau sous les sections PHP Variables.

[“SERVER_SOFTWARE”] devrait indiquer nginx, indiquant que les fichiers ont été directement servis par Nginx. [« DOCUMENT_ROOT »] doit pointer vers le répertoire que vous avez créé précédemment dans cette étape pour chaque site Nginx.

À ce stade, nous avons installé Nginx et créé deux hôtes virtuels. Ensuite, nous allons configurer Nginx pour les requêtes proxy destinées aux domaines hébergés sur Apache.

Étape 7 - Configuration de Nginx pour les hôtes virtuels d'Apache

Créons un hôte virtuel Nginx supplémentaire avec plusieurs noms de domaine dans les directives server_name. Les demandes pour ces noms de domaine seront transmises à Apache.

Créez un nouveau fichier d'hôte virtuel Nginx pour transférer les requêtes vers Apache :

sudo nano /etc/nginx/sites-available/apache

Ajoutez le bloc de code suivant qui spécifie les noms des deux domaines d'hôte virtuel Apache et transmet leurs requêtes à Apache. N'oubliez pas d'utiliser l'adresse IP publique dans proxy_pass :

/etc/nginx/sites-available/apache

server {
    listen 80;
    server_name foobar.net www.foobar.net test.io www.test.io;

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

Enregistrez le fichier et activez ce nouvel hôte virtuel en créant un lien symbolique :

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

Testez la configuration pour vous assurer qu'il n'y a pas d'erreur :

sudo nginx -t

S'il n'y a pas d'erreurs, rechargez Nginx :

sudo systemctl reload nginx

Ouvrez le navigateur et accédez à l'URL http://foobar.net/info.php dans votre navigateur. Faites défiler jusqu'à la section PHP Variables et vérifiez les valeurs affichées.

Les variables SERVER_SOFTWARE et DOCUMENT_ROOT confirment que cette requête a été traitée par Apache. Les variables HTTP_X_REAL_IP et HTTP_X_FORWARDED_FOR ont été ajoutées par Nginx et doivent afficher l'adresse IP publique de l'ordinateur que vous utilisez pour accéder à l'URL.

Nous avons configuré avec succès Nginx pour envoyer des requêtes proxy pour des domaines spécifiques à Apache. Ensuite, configurons Apache pour définir la variable REMOTE_ADDR comme s'il gérait ces requêtes directement.

Étape 8 - Installation et configuration de mod_rpaf

Dans cette étape, vous allez installer un module Apache appelé mod\_rpaf qui réécrit les valeurs de REMOTE_ADDR, HTTPS et HTTP_PORT en fonction des valeurs fournies par un proxy inverse. Sans ce module, certaines applications PHP nécessiteraient des modifications de code pour fonctionner de manière transparente derrière un proxy. Ce module est présent dans le référentiel d'Ubuntu sous le nom libapache2-mod-rpaf mais est obsolète et ne prend pas en charge certaines directives de configuration. Au lieu de cela, nous l'installerons à partir de la source.

Installez les packages nécessaires pour compiler le module :

sudo apt install unzip build-essential apache2-dev

Téléchargez la dernière version stable depuis GitHub :

wget https://github.com/gnif/mod_rpaf/archive/stable.zip

Extrayez le fichier téléchargé :

unzip stable.zip

Passez dans le nouveau répertoire contenant les fichiers :

cd mod_rpaf-stable

Compilez et installez le module :

make
sudo make install

Créez ensuite un fichier dans le répertoire mods-available qui chargera le module rpaf :

sudo nano /etc/apache2/mods-available/rpaf.load

Ajoutez le code suivant au fichier pour charger le module :

/etc/apache2/mods-available/rpaf.load

LoadModule rpaf_module /usr/lib/apache2/modules/mod_rpaf.so

Enregistrez le fichier et quittez l'éditeur.

Créez un autre fichier dans ce répertoire nommé rpaf.conf qui contiendra les directives de configuration pour mod_rpaf :

sudo nano /etc/apache2/mods-available/rpaf.conf

Ajoutez le bloc de code suivant pour configurer mod_rpaf, en veillant à spécifier l'adresse IP de votre serveur :

/etc/apache2/mods-available/rpaf.conf

    <IfModule mod_rpaf.c>
        RPAF_Enable             On
        RPAF_Header             X-Real-Ip
        RPAF_ProxyIPs           your_server_ip 
        RPAF_SetHostName        On
        RPAF_SetHTTPS           On
        RPAF_SetPort            On
    </IfModule>

Voici une brève description de chaque directive. Voir le fichier mod_rpaf README pour plus d'informations.

  • RPAF_Header - L'en-tête à utiliser pour l'adresse IP réelle du client.
  • RPAF_ProxyIPs - L'adresse IP proxy pour laquelle ajuster les requêtes HTTP.
  • RPAF_SetHostName - Met à jour le nom de l'hôte virtuel pour que ServerName et ServerAlias fonctionnent.
  • RPAF_SetHTTPS - Définit la variable d'environnement HTTPS en fonction de la valeur contenue dans X-Forwarded-Proto.
  • RPAF_SetPort - Définit la variable d'environnement SERVER_PORT. Utile quand Apache est derrière un proxy SSL.

Enregistrez rpaf.conf et activez le module :

sudo a2enmod rpaf

Cela crée des liens symboliques des fichiers rpaf.load et rpaf.conf dans le répertoire mods-enabled. Faites maintenant un test de configuration :

sudo apachectl -t

Rechargez Apache s'il n'y a pas d'erreur :

sudo systemctl reload apache2

Accédez aux pages phpinfo() http://foobar.net/info.php et http://test.io/info.php de votre navigateur et consultez la section Variables PHP. La variable REMOTE_ADDR sera désormais également celle de l'adresse IP publique de votre ordinateur local.

Configurons maintenant le cryptage TLS/SSL pour chaque site.

Étape 9 - Configuration de sites Web HTTPS avec Let's Encrypt (facultatif)

Dans cette étape, nous allons configurer les certificats TLS/SSL pour les deux domaines hébergés sur Apache. Nous obtiendrons les certificats via [Let's Encrypt](https://letsencrypt.org]. Nginx prend en charge la terminaison SSL afin que nous puissions configurer SSL sans modifier les fichiers de configuration d'Apache. Le module mod_rpaf garantit que les variables d'environnement requises sont définies sur Apache pour que les applications fonctionnent de manière transparente derrière un proxy inverse SSL.

Nous allons d'abord séparer les blocs server {...} des deux domaines afin que chacun d'eux puisse avoir ses propres certificats SSL. Ouvrez le fichier /etc/nginx/sites-available/apache dans votre éditeur :

sudo nano /etc/nginx/sites-available/apache

Modifiez le fichier pour qu'il ressemble à ceci, avec foobar.net et test.io dans leurs propres blocs server :

/etc/nginx/sites-available/apache

    server {
        listen 80;
        server_name foobar.net www.foobar.net;
    
        location / {
            proxy_pass http://your_server_ip:8080;
            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;
        }
    }
    server {
        listen 80;
        server_name test.io www.test.io;
    
        location / {
            proxy_pass http://your_server_ip:8080;
            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;
        }
    }

Nous utiliserons Certbot pour générer nos certificats TLS/SSL. Son plugin Nginx se chargera de reconfigurer Nginx et de recharger la config chaque fois que nécessaire.

Tout d'abord, ajoutez le référentiel Certbot officiel :

sudo add-apt-repository ppa:certbot/certbot

Appuyez sur ENTER lorsque vous êtes invité à confirmer que vous souhaitez ajouter le nouveau référentiel. Ensuite, mettez à jour la liste des packages pour récupérer les informations sur les packages du nouveau référentiel :

sudo apt update

Installez ensuite le package Nginx de Certbot avec apt :

sudo apt install python-certbot-nginx

Une fois installé, utilisez la commande certbot pour générer les certificats pour foobar.net et www.foobar.net :

sudo certbot --nginx -d foobar.net -d www.foobar.net

Cette commande indique à Certbot d'utiliser le plug-in nginx, en utilisant -d pour spécifier les noms pour lesquels nous souhaitons que le certificat soit valide.

Si c'est la première fois que vous utilisez certbot, vous serez invité à saisir une adresse e-mail et à accepter les conditions d'utilisation. Après cela, certbot communiquera avec le serveur Let's Encrypt, puis exécutera un défi pour vérifier que vous contrôlez le domaine pour lequel vous demandez un certificat.

Ensuite, Certbot vous demandera comment vous souhaitez configurer vos paramètres HTTPS :

OutputPlease choose whether or not to redirect HTTP traffic to HTTPS, removing HTTP access.
-------------------------------------------------------------------------------
1: No redirect - Make no further changes to the webserver configuration.
2: Redirect - Make all requests redirect to secure HTTPS access. Choose this for
new sites, or if you're confident your site works on HTTPS. You can undo this
change by editing your web server's configuration.
-------------------------------------------------------------------------------
Select the appropriate number [1-2] then [enter] (press 'c' to cancel):

Sélectionnez votre choix, puis appuyez sur ENTER. La configuration sera mise à jour et Nginx se rechargera pour récupérer les nouveaux paramètres.

Exécutez maintenant la commande pour le deuxième domaine :

sudo certbot --nginx -d test.io -d www.test.io

Accédez à l'un des domaines d'Apache dans votre navigateur en utilisant le préfixe https:// ; visitez https://foobar.net/info.php et vous verrez ceci :

Regardez dans la section Variables PHP. La variable SERVER_PORT a été définie sur 443 et HTTPS définie sur sur, comme si Apache était directement accessible via HTTPS. Avec ces variables définies, les applications PHP n'ont pas besoin d'être spécialement configurées pour fonctionner derrière un proxy inverse.

Désactivons maintenant l'accès direct à Apache.

Étape 10 - Bloquer l'accès direct à Apache (facultatif)

Comme Apache écoute sur le port 8080 sur l'adresse IP publique, il est accessible à tous. Il peut être bloqué en utilisant la commande IPtables suivante dans votre ensemble de règles de pare-feu.

sudo iptables -I INPUT -p tcp --dport 8080 ! -s your_server_ip -j REJECT --reject-with tcp-reset

Assurez-vous d'utiliser l'adresse IP de votre serveur à la place de l'exemple en rouge. Une fois que le port 8080 est bloqué dans votre pare-feu, testez qu'Apache est inaccessible dessus. Ouvrez votre navigateur Web et essayez d'accéder à l'un des noms de domaine d'Apache sur le port 8080. Par exemple : http://exemple.com:8080

Le navigateur doit afficher un message d'erreur "Impossible de se connecter" ou "La page Web n'est pas disponible". Avec l'option IPtables tcp-reset en place, un étranger ne verrait aucune différence entre le port 8080 et un port qui n'a aucun service dessus.

Remarque : Les règles IPtables ne survivent pas à un redémarrage du système par défaut. Il existe plusieurs façons de préserver les règles IPtables, mais la plus simple consiste à utiliser iptables-persistent dans le référentiel d'Ubuntu. Explorez cet article pour en savoir plus sur la configuration d'IPTables.


Configurons maintenant Nginx pour servir des fichiers statiques pour les sites Apache.

Étape 11 - Servir des fichiers statiques à l'aide de Nginx (facultatif)

Lorsque Nginx proxies demande les domaines d'Apache, il envoie chaque demande de fichier pour ce domaine à Apache. Nginx est plus rapide qu'Apache pour servir des fichiers statiques comme des images, JavaScript et des feuilles de style. Configurons donc le fichier d'hôte virtuel apache de Nginx pour qu'il serve directement les fichiers statiques mais envoie les requêtes PHP à Apache.

Ouvrez le fichier /etc/nginx/sites-available/apache dans votre éditeur :

sudo nano /etc/nginx/sites-available/apache

Vous devrez ajouter deux blocs location supplémentaires à chaque bloc de serveur, ainsi que modifier les sections location existantes. De plus, vous devrez indiquer à Nginx où trouver les fichiers statiques pour chaque site.

Si vous avez décidé de ne pas utiliser les certificats SSL et TLS, modifiez votre fichier pour qu'il ressemble à ceci :

/etc/nginx/sites-available/apache

server {
    listen 80;
    server_name test.io www.test.io;
    root /var/www/test.io;
    index index.php index.htm index.html;

    location / {
        try_files $uri $uri/ /index.php;
    }

    location ~ \.php$ {
        proxy_pass http://your_server_ip:8080;
        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 ~ /\.ht {
        deny all;
    }
}

server {
    listen 80;
    server_name foobar.net www.foobar.net;
    root /var/www/foobar.net;
    index index.php index.htm index.html;

    location / {
        try_files $uri $uri/ /index.php;
    }

    location ~ \.php$ {
        proxy_pass http://your_ip_address:8080;
        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 ~ /\.ht {
        deny all;
    }
}

Si vous souhaitez également que HTTPS soit disponible, utilisez plutôt la configuration suivante :

/etc/nginx/sites-available/apache

server {
    listen 80;
    server_name test.io www.test.io;
    root /var/www/test.io;
    index index.php index.htm index.html;

    location / {
        try_files $uri $uri/ /index.php;
    }

    location ~ \.php$ {
        proxy_pass http://your_server_ip:8080;
        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 ~ /\.ht {
        deny all;
    }

    listen 443 ssl;
    ssl_certificate /etc/letsencrypt/live/test.io/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/test.io/privkey.pem;
    include /etc/letsencrypt/options-ssl-nginx.conf;
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;
}

server {
    listen 80;
    server_name foobar.net www.foobar.net;
    root /var/www/foobar.net;
    index index.php index.htm index.html;

    location / {
        try_files $uri $uri/ /index.php;
    }

    location ~ \.php$ {
        proxy_pass http://your_ip_address:8080;
        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 ~ /\.ht {
        deny all;
    }

    listen 443 ssl;
    ssl_certificate /etc/letsencrypt/live/foobar.net/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/foobar.net/privkey.pem;
    include /etc/letsencrypt/options-ssl-nginx.conf;
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;
}

La directive try_files oblige Nginx à rechercher des fichiers dans la racine du document et à les servir directement. Si le fichier a une extension .php, la requête est transmise à Apache. Même si le fichier n'est pas trouvé à la racine du document, la requête est transmise à Apache afin que les fonctionnalités de l'application telles que les permaliens fonctionnent sans problème.

Attention : La directive location ~ /\.ht est très importante ; cela empêche Nginx de servir le contenu des fichiers de configuration Apache comme .htaccess et .htpasswd qui contiennent des informations sensibles.


Enregistrez le fichier et effectuez un test de configuration :

sudo nginx -t

Rechargez Nginx si le test réussit :

sudo service nginx reload

Pour vérifier que tout fonctionne, vous pouvez examiner les fichiers journaux d'Apache dans /var/log/apache2 et voir les requêtes GET pour les fichiers info.php de test.io et [ X154X]. Utilisez la commande tail pour voir les dernières lignes du fichier, et utilisez le commutateur -f pour surveiller les modifications apportées au fichier :

sudo tail -f /var/log/apache2/other_vhosts_access.log

Visitez maintenant http://test.io/info.php dans votre navigateur, puis examinez la sortie du journal. Vous verrez qu'Apache répond en effet :

Output    test.io:80 your_server_ip - - [01/Jul/2016:18:18:34 -0400] "GET /info.php HTTP/1.0" 200 20414 "-" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/47.0.2526.111 Safari/537.36"

Ensuite, visitez la page index.html pour chaque site et vous ne verrez aucune entrée de journal d'Apache. Nginx les sert.

Lorsque vous avez terminé d'observer le fichier journal, appuyez sur CTRL+C pour arrêter de le suivre.

Avec cette configuration, Apache ne pourra pas restreindre l'accès aux fichiers statiques. Le contrôle d'accès pour les fichiers statiques devrait être configuré dans le fichier d'hôte virtuel apache de Nginx, mais cela dépasse le cadre de ce didacticiel.

Conclusion

Vous avez maintenant un serveur Ubuntu avec Nginx servant example.com et sample.org, avec Apache servant foobar.net et test.io. Bien que Nginx agisse comme un proxy inverse pour Apache, le service proxy de Nginx est transparent et les connexions aux domaines d'Apache semblent être servies directement à partir d'Apache lui-même. Vous pouvez utiliser cette méthode pour servir des sites sécurisés et statiques.