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

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

introduction

Apache et Nginx sont deux serveurs Web open source populaires souvent utilisés avec PHP. Il peut être utile de les exécuter sur la même machine virtuelle lorsque vous hébergez plusieurs sites Web dont les besoins varient. La solution générale pour exécuter deux serveurs Web sur un même système consiste à utiliser plusieurs adresses IP ou des numéros de port différents.

Les serveurs possédant à la fois des adresses IPv4 et IPv6 peuvent être configurés pour desservir les sites Apache sur un protocole et les sites Nginx sur l’autre, mais cela n’est pas pratique dans la mesure où l’adoption d’IPv6 par les fournisseurs de services Internet n’est pas encore généralisée. Avoir un numéro de port différent comme + 81 + ou + 8080 + pour le deuxième serveur Web est une autre solution, mais le partage d’URL avec des numéros de port (tels que + http: //example.com: 81 +) isn pas toujours raisonnable ou idéal.

Dans ce didacticiel, vous configurerez Nginx à la fois comme serveur Web et proxy inverse pour Apache, le tout sur un seul serveur.

En fonction de l’application Web, des modifications de code peuvent être nécessaires pour que Apache reste informé, notamment lorsque les sites SSL sont configurés. Pour éviter cela, vous allez installer un module Apache appelé + mod_rpaf + qui réécrit certaines variables d’environnement de sorte qu’il apparaisse qu’Apache traite directement les demandes des clients Web.

Nous hébergerons quatre noms de domaine sur un 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 allons également configurer Apache pour qu’il serve les applications PHP à l’aide de PHP-FPM, qui offre de meilleures performances que + mod_php +.

Conditions préalables

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

Un nouveau serveur Ubuntu 18.04 configuré en suivant les Initial Initial Server Setup avec Ubuntu 18.04, avec une connexion sudo non utilisateur root et un pare-feu.
Quatre noms de domaine pleinement qualifiés configurés pour pointer vers l’adresse IP de votre serveur. Voir l’étape 3 de la page Comment définir un nom d’hôte avec DigitalOcean pour un exemple de comment faire cela Si vous hébergez le DNS de vos domaines ailleurs, vous devez plutôt créer les enregistrements A appropriés.

Étape 1 - Installer Apache et PHP-FPM

Commençons par installer Apache et PHP-FPM.

Outre Apache et PHP-FPM, nous installerons également le module Apache PHP FastCGI, + libapache2-mod-fastcgi +, pour prendre en charge les applications Web FastCGI.

Tout d’abord, mettez à jour votre liste de paquets pour vous assurer d’avoir les derniers paquets.

sudo apt update

Ensuite, installez les packages Apache et PHP-FPM:

sudo apt install apache2 php-fpm

Le module Apache de FastCGI n’est pas disponible dans le référentiel d’Ubuntu, donc téléchargez-le à partir de https://kernel.org [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 en utilisant le module + mod_fastcgi + . Renommez le fichier de configuration Apache `+ ports.conf:

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 " | sudo tee /etc/apache2/ports.conf

Nous allons ensuite créer un fichier d’hôte virtuel pour Apache. La directive + <VirtualHost> + de ce fichier sera configurée pour servir les sites uniquement sur le port + 8080 +.

Désactiver 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 *:>
   ServerAdmin webmaster@localhost
   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

Le résultat devrait ressembler à l’exemple suivant, avec + apache2 + à l’écoute 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 :::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 nécessite une configuration supplémentaire pour fonctionner avec PHP-FPM.

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 requêtes pour les fichiers + .php + au socket UNIX PHP-FPM:

/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

Rechargez Apache si * Syntaxe OK * est affiché:

sudo systemctl reload apache2

Si vous voyez l’avertissement `+ Impossible de déterminer de manière fiable le nom de domaine complet du serveur, utilisez 127.0.1.1. Définissez la directive 'NomServeur' globalement pour supprimer ce message. + `, Vous pouvez l’ignorer en toute sécurité pour le moment. Nous allons configurer les noms de serveur plus tard.

Maintenant, assurons-nous que nous pouvons servir PHP depuis Apache.

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

Assurez-vous que PHP fonctionne en créant un fichier + phpinfo () + et en y accédant à partir d’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

Pour voir le fichier dans un navigateur, allez à + http: //: 8080 / info.php. Cela vous donnera une liste des paramètres de configuration utilisés par PHP. Vous verrez une sortie semblable à celle-ci:

image: https: //assets.digitalocean.com/articles/nginx_apache_ubuntu_1804/qQcGNe8.png [API de serveur phpinfo]

image: https: //assets.digitalocean.com/articles/nginx_apache_ubuntu_1804/eBuDnVU.png [Variables PHP phpinfo]

En haut de la page, vérifiez que * l’API du serveur * indique * FPM / FastCGI *. Environ aux deux tiers de la page, la section * Variables * vous indiquera que * SERVER_SOFTWARE * est Apache sur Ubuntu. Celles-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 y placer des fichiers par défaut afin de pouvoir facilement tester notre configuration.

Commencez par créer les répertoires racine du document:

sudo mkdir -v /var/www/ /var/www/

Créez ensuite un fichier + index pour chaque site:

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

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

echo "<?php phpinfo(); ?>" | sudo tee /var/www//info.php
echo "<?php phpinfo(); ?>" | sudo tee /var/www//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
       ServerAlias www.
       DocumentRoot /var/www/
       <Directory /var/www/>
           AllowOverride All
       </Directory>
   </VirtualHost>

La ligne + AllowOverride All + active le support + .htaccess +.

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

Enregistrez et fermez le fichier. Créez ensuite une configuration similaire pour + test.io +. Commencez par créer 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
       ServerAlias www.
       DocumentRoot /var/www/
       <Directory /var/www/>
           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 hôte virtuel dans le répertoire + sites-enabled +:

sudo a2ensite
sudo a2ensite

Recherchez à nouveau les erreurs de configuration dans Apache:

sudo apachectl -t

La syntaxe * OK apparaîtra s’il n’y a pas d’erreur. Si vous voyez autre chose, passez en revue la configuration et réessayez.

Rechargez Apache pour appliquer les modifications une fois que votre configuration est exempte d’erreur:

sudo systemctl reload apache2

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

Vous verrez les résultats suivants:

image: https: //assets.digitalocean.com/articles/nginx_apache_ubuntu_1804/2y1R8Zd.png [page d’index foobar.net]

image: https: //assets.digitalocean.com/articles/nginx_apache_ubuntu_1804/wr1pzEj.png [page d’index test.io]

Assurez-vous également que PHP fonctionne en accédant aux fichiers * info.php * de chaque site. Visitez + http: //: 8080 / info.php + et + http: //: 8080 / info.php + dans votre navigateur.

Vous verrez la même liste de spécifications de configuration PHP sur chaque site que celle décrite à l’étape 4.

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

Étape 6 - Installation et configuration de Nginx

Dans cette étape, nous installerons Nginx et configurerons 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 https://www.digitalocean.com/community/tutorials/how-to-install-nginx-on-ubuntu-18-04#step-5-%E2% 80% 93-setup-up-server-blocks- (recommandé) [Comment configurer des blocs de serveur Nginx (hôtes virtuels) sur Ubuntu 18.04].

Installez Nginx en utilisant le gestionnaire de paquets:

sudo apt install nginx

Ensuite, supprimez le lien symbolique de l’hôte virtuel par défaut, car nous ne l’utiliserons plus:

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

Nous allons créer notre propre lettre de site par défaut (+ example.com +).

Nous allons maintenant créer des hôtes virtuels pour Nginx en utilisant la même procédure que pour Apache. Commencez par créer des répertoires racine de documents pour les deux sites Web:

sudo mkdir -v /usr/share/nginx/ /usr/share/nginx/

Les sites Web de Nginx seront conservés dans + / usr / share / nginx +, où Nginx les souhaite par défaut. Vous pouvez les placer 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 Apache, créez des fichiers + index et` + phpinfo () + `à tester une fois l’installation terminée:

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

Créez maintenant un fichier d’hôte virtuel pour le domaine + exemple.com +:

sudo nano /etc/nginx/sites-available/

Nginx appelle + serveur {. . .} + `Zones d’un fichier de configuration * Blocs serveur *. Créez un bloc de serveur pour l’hôte virtuel principal, `++. La directive de configuration + default_server + en fait l’hôte virtuel par défaut, qui traite les demandes HTTP qui ne correspondent à aucun autre hôte virtuel.

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

server {
   listen 80 default_server;

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

   server_name ;
   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/

Ajoutez ce qui suit au fichier:

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

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

   server_name ;
   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/ /etc/nginx/sites-enabled/
sudo ln -s /etc/nginx/sites-available/ /etc/nginx/sites-enabled/

Testez ensuite la configuration de Nginx pour vous assurer qu’il n’y a pas de problème 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 dans les sections Variables PHP.

image: https: //assets.digitalocean.com/articles/nginx_apache_ubuntu_1804/1FZeLUe.png [Variables PHP Nginx]

[“SERVER_SOFTWARE”] * devrait dire + 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. Nous allons ensuite configurer Nginx sur 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 + nom_serveur +. Les demandes pour ces noms de domaine seront envoyées par proxy à Apache.

Créez un nouveau fichier hôte virtuel Nginx pour transférer les demandes à Apache:

sudo nano /etc/nginx/sites-available/

Ajoutez le bloc de code suivant, qui spécifie les noms des domaines d’hôte virtuel Apache et transmet les 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 ;

   location / {
       proxy_pass http://: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’erreur, rechargez Nginx:

sudo systemctl reload nginx

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

image: https: //assets.digitalocean.com/articles/nginx_apache_ubuntu_1804/1XQi5kl.png [phpinfo d’Apache via Nginx]

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

Nous avons correctement configuré Nginx pour envoyer des requêtes proxy à Apache pour des domaines spécifiques. Ensuite, configurons Apache pour définir la variable + REMOTE_ADDR + comme si elle traitait directement ces demandes.

Étape 8 - Installation et configuration de mod_rpaf

Dans cette étape, vous installerez un module Apache appelé + mod \ _rpaf + qui récrira 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 que les modifications de code fonctionnent de manière transparente derrière un proxy. Ce module est présent dans le référentiel 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 allons l’installer à partir des sources.

Installez les packages nécessaires à la construction du module:

sudo apt install unzip build-essential apache2-dev

Téléchargez la dernière version stable de 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

Compiler et installer le module:

make
sudo make install

Ensuite, créez 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 appelé + 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
       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 * - En-tête à utiliser pour l’adresse IP réelle du client.
* RPAF_ProxyIPs * - L’adresse IP du proxy pour laquelle ajuster les requêtes HTTP.
* RPAF_SetHostName * - Met à jour le nom vhost afin 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 lorsque 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 +. Maintenant, faites 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: /// info.php + et + http: /// info.php + dans 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 allons obtenir les certificats via [Let’s Encrypt] (https://letsencrypt.org]. Nginx prend en charge la résiliation SSL afin que nous puissions configurer SSL sans modifier les fichiers de configuration d’Apache. Le module + mod_rpaf + assure que les variables d’environnement requises sont définies sur Apache pour permettre aux applications de fonctionner de manière transparente derrière un proxy inverse SSL.

Nous allons d’abord séparer les blocs + serveur {…} + des deux domaines afin que chacun d’eux puisse avoir son propre certificat 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 + serveur +:

/ etc / nginx / sites-available / apache

   server {
       listen 80;
       server_name ;

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

       location / {
           proxy_pass http://: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 https://certbot.eff.org [Certbot] pour générer nos certificats TLS / SSL. Son plugin Nginx se chargera de reconfigurer Nginx et de recharger la configuration chaque fois que nécessaire.

Premièrement, ajoutez le référentiel officiel de Certbot:

sudo add-apt-repository ppa:certbot/certbot

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

sudo apt update

Puis installez le paquet 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  -d

Cette commande demande à Certbot d’utiliser le plugin + nginx +, en utilisant + -d + pour spécifier les noms pour lesquels nous aimerions que le certificat soit valide.

Si vous utilisez pour la première fois + certbot +, vous serez invité à entrer une adresse électronique et à accepter les conditions d’utilisation. Ensuite, + certbot + communiquera avec le serveur Let’s Encrypt, puis lancera un défi afin de 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.

Maintenant, exécutez la commande pour le deuxième domaine:

sudo certbot --nginx -d  -d

Accédez à l’un des domaines Apache de votre navigateur en utilisant le préfixe + https: // +; visitez + https: /// info.php + et vous verrez ceci:

image: https: //assets.digitalocean.com/articles/nginx_apache_ubuntu_1804/KK6AmWV.png [phpinfo ssl]

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

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

Étape 10 - Blocage de 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 jeu de règles de pare-feu.

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

Veillez à 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, vérifiez que Apache est inaccessible. Ouvrez votre navigateur Web et essayez d’accéder à l’un des noms de domaine d’Apache sur le port + 8080 +. Par exemple: http: //: 8080

Le navigateur doit afficher un message d’erreur «Impossible d’établir la connexion» ou «La page Web n’est pas disponible». Avec l’option IPtables + tcp-reset +, un étranger ne verrait aucune différence entre le port + 8080 + et un port sur lequel aucun service n’est disponible.

Maintenant, configurons Nginx pour servir des fichiers statiques pour les sites Apache.

Étape 11 - Traitement de fichiers statiques à l’aide de Nginx (facultatif)

Lorsque les mandataires Nginx demandent des domaines Apache, il envoie toutes les demandes de fichiers de ce domaine à Apache. Nginx est plus rapide qu’Apache en servant des fichiers statiques tels que des images, du 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 + emplacement + existantes. En outre, vous devrez indiquer à Nginx où trouver les fichiers statiques de chaque site.

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

/ etc / nginx / sites-available / apache

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

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

   location ~ \.php$ {
       proxy_pass http://: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 ;
   root /var/www/;
   index index.php index.htm index.html;

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

   location ~ \.php$ {
       proxy_pass http://: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 ;
   root /var/www/;
   index index.php index.htm index.html;

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

   location ~ \.php$ {
       proxy_pass http://: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//fullchain.pem;
   ssl_certificate_key /etc/letsencrypt/live//privkey.pem;
   include /etc/letsencrypt/options-ssl-nginx.conf;
   ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;
}

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

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

   location ~ \.php$ {
       proxy_pass http://: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//fullchain.pem;
   ssl_certificate_key /etc/letsencrypt/live//privkey.pem;
   include /etc/letsencrypt/options-ssl-nginx.conf;
   ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;
}

La directive + try_files + permet à Nginx de rechercher des fichiers dans la racine du document et de les servir directement. Si le fichier a une extension + .php +, la demande est transmise à Apache. Même si le fichier ne se trouve pas dans la racine du document, la demande est transmise à Apache afin que les fonctionnalités de l’application telles que les permaliens fonctionnent sans problème.

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 correctement, 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 + + foobar .net + . Utilisez la commande `+ tail + pour afficher les dernières lignes du fichier et utilisez le commutateur + -f + pour surveiller les modifications du fichier:

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

Maintenant, visitez + http: // test.io / info.php + dans votre navigateur, puis examinez le résultat du journal. Vous verrez qu’Apache répond effectivement:

Output     - - [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"

Visitez ensuite la page + index.html de 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 les touches + CTRL + C + pour cesser de le suivre.

Avec cette configuration, Apache ne pourra pas restreindre l’accès aux fichiers statiques. Le contrôle d’accès aux fichiers statiques doit ê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 +, ainsi qu’Apache servant + foobar.net + et + test.o +. Bien que Nginx agisse en tant que 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 desservir des sites sécurisés et statiques.

TOC

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

introduction

Conditions préalables

Étape 1 - Installer Apache et PHP-FPM

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

Étape 3 - Configuration d’Apache pour utiliser mod_fastcgi

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

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

Étape 6 - Installation et configuration de Nginx

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

Étape 8 - Installation et configuration de mod_rpaf

Étape 9 - Configuration de sites Web HTTPS avec Let’s Encrypt (Facultatif)

Étape 10 - Blocage de l’accès direct à Apache (facultatif)

Étape 11 - Traitement de fichiers statiques à l’aide de Nginx (facultatif)

Conclusion

Related