TOC

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

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 droplets 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 FAI 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.

Ce tutoriel vous montrera comment configurer Nginx à la fois en tant que serveur Web et en tant que proxy inverse pour Apache - le tout sur un seul droplet. 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, nous allons installer un module Apache nommé * 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 Droplet. 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.

Conditions préalables

Ce didacticiel nécessite des connaissances de base sur les hôtes virtuels dans Apache et Nginx, ainsi que sur la création et la configuration de certificats SSL. Pour plus d’informations sur ces sujets, voir les articles suivants.

Étape 1 - Installer Apache et PHP-FPM

Outre Apache et PHP-FPM, nous devons également installer le module Apache PHP FastCGI nommé libapache2-mod-fastcgi.

Commencez par mettre à jour le référentiel apt pour vous assurer que vous disposez des derniers packages.

sudo apt-get update

Ensuite, installez les packages nécessaires:

sudo apt-get install apache2 libapache2-mod-fastcgi php-fpm

Ensuite, changeons la configuration par défaut d’Apache.

É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. Editez le fichier de configuration Apache et changez le numéro de port d’Apache.

sudo nano /etc/apache2/ports.conf

Trouvez la ligne suivante:

Listen 80

Changez le en:

Listen

Enregistrez et quittez + ports.conf +.

Nous allons ensuite éditer le fichier d’hôte virtuel par défaut d’Apache. La directive + <VirtualHost> + de ce fichier est configurée pour servir les sites uniquement sur le port + 80 +, nous devons donc également changer cela. Ouvrez le fichier d’hôte virtuel par défaut.

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

La première ligne devrait être:

<VirtualHost *:80>

Changez le en:

<VirtualHost *:>

Enregistrez le fichier et rechargez Apache.

sudo systemctl reload apache2

Vérifiez qu’Apache écoute maintenant 8080 +.

sudo netstat -tlpn
Le résultat devrait ressembler à l’exemple suivant, avec * apache2 * à l’écoute sur *

8080 *.

Active 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.

sudo a2dismod php7.0

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

Ces directives de configuration transmettent les requêtes pour les fichiers + .php + au socket UNIX PHP-FPM.

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

Ajoutez les lignes suivantes dans le `+ <IfModule mod_fastcgi.c>. . . </ IfModule> + `bloc, sous les éléments existants de ce bloc:

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.0-fpm.sock -pass-header Authorization
<Directory /usr/lib/cgi-bin>
   Require all granted
</Directory>

Enregistrez les modifications que vous avez apportées à + ​​fastcgi.conf + et effectuez un test de configuration.

sudo apachectl -t

Rechargez Apache si * Syntaxe OK * est affiché. 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 'ServerName' globalement pour supprimer ce message. + `, C’est très bien. Cela ne nous concerne pas maintenant.

sudo systemctl reload apache2

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

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

Vérifiez si PHP fonctionne en créant un fichier + phpinfo () + et en y accédant à partir de votre navigateur Web.

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.

image: https: //assets.digitalocean.com/articles/apache_nginx_reverse_proxy_ubuntu_16.04/YbWDj9i.png [API de serveur phpinfo]

image: https: //assets.digitalocean.com/articles/apache_nginx_reverse_proxy_ubuntu_16.04/363bUHT.png [phpinfo Variables PHP]

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:

sudo mkdir -v /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

Ensuite, créez un fichier + phpinfo () + pour chaque site afin que nous puissions tester 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/.conf

Placez la directive suivante dans ce nouveau fichier:

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

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 +.

sudo nano /etc/apache2/sites-available/.conf
<VirtualHost *:8080>
   ServerName
   ServerAlias www.
   DocumentRoot /var/www/
   <Directory /var/www/>
       AllowOverride All
   </Directory>
</VirtualHost>

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

Rechargez Apache si * Syntaxe OK * est affiché.

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 devriez voir les résultats suivants:

image: https: //assets.digitalocean.com/articles/apache_and_nginx/3.png [page index de foobar.net]

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

Vérifiez é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 devriez voir 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 +

É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-set-up-nginx-server-blocks-virtual-hosts-on-ubuntu-16. -04 [Comment configurer des blocs de serveur Nginx (hôtes virtuels) sur Ubuntu 16.04].

Installez Nginx en utilisant le gestionnaire de paquets.

sudo apt-get install nginx

Supprimez ensuite le lien symbolique de l’hôte virtuel par défaut, car nous ne l’utiliserons plus. Nous allons créer notre propre lettre de site par défaut (+ example.com +).

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

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/{,}

Comme nous l’avons fait avec les hôtes virtuels Apache, nous allons à nouveau créer 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.

Collez ce qui suit dans le fichier pour:

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.0-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/

Le bloc serveur pour devrait ressembler à ceci:

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.0-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/

Effectuez un test de configuration Nginx:

sudo nginx -t

Rechargez ensuite Nginx si * OK * est affiché.

sudo systemctl reload nginx

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

image: https: //assets.digitalocean.com/articles/apache_nginx_reverse_proxy_ubuntu_16.04/A43puCy.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 d’hôte virtuel Nginx:

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

Ajoutez le bloc de code ci-dessous. Cela spécifie les noms des domaines d’hôte virtuel Apache et envoie les requêtes à Apache. N’oubliez pas d’utiliser l’adresse IP publique dans + proxy_pass +.

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

Faites un test de configuration:

sudo nginx -t

Rechargez Nginx si * OK * est affiché.

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/apache_nginx_reverse_proxy_ubuntu_16.04/A465fzT.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 * HTTPXREAL_IP * et * HTTPXFORWARDED_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 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, nous installerons un module Apache nommé * 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 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-get 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 avec:

unzip stable.zip

Changer dans le répertoire de travail.

cd mod_rpaf-stable

Ensuite, compilez et installez le module.

make
sudo make install

Créez un fichier dans le répertoire + mods-available + qui charge le module rpaf.

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

Ajoutez la ligne suivante au fichier:

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

Créez un autre fichier dans ce répertoire. Cela contiendra les directives de configuration.

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

Ajoutez le bloc de code suivant, en veillant à ajouter l’adresse IP de votre Droplet.

<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 si * Syntaxe OK * est renvoyé.

sudo systemctl reload apache2

Accédez à l’une des pages + phpinfo () + du site Web d’Apache 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.

Étape 9 - Configuration des sites Web HTTPS (facultatif)

Dans cette étape, nous allons configurer des certificats SSL pour les deux domaines hébergés sur Apache. 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 + s’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.

Créez un répertoire pour les certificats SSL et leurs clés privées.

sudo mkdir /etc/nginx/ssl

Pour cet article, nous utiliserons des certificats SSL auto-signés d’une validité de 10 ans. Générez des certificats auto-signés pour + foobar.net + et + test.io +.

sudo openssl req -x509 -sha256 -newkey rsa:2048 -keyout /etc/nginx/ssl/-key.pem -out /etc/nginx/ssl/-cert.pem -days 3650 -nodes
sudo openssl req -x509 -sha256 -newkey rsa:2048 -keyout /etc/nginx/ssl/-key.pem -out /etc/nginx/ssl/-cert.pem -days 3650 -nodes

Chaque fois, vous serez invité à fournir les détails d’identification du certificat. Entrez le domaine approprié pour le + Nom commun + à chaque fois.

Country Name (2 letter code) [AU]:
State or Province Name (full name) [Some-State]:
Locality Name (eg, city) []:
Organization Name (eg, company) [Internet Widgits Pty Ltd]:
Organizational Unit Name (eg, section) []:
Common Name (e.g. server FQDN or YOUR name) []:
Email Address []:

Ouvrez maintenant le fichier d’hôte virtuel Apache que les serveurs mandataires demandent à Nginx d’Apache.

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

Puisque nous avons des certificats et des clés distincts pour chaque domaine, nous devons avoir un serveur `+ serveur {séparé. . . } + `blocs pour chaque domaine. Vous devez supprimer le contenu actuel du fichier et le remplacer par le contenu suivant:

server {
   listen 80;
   listen 443 ssl;
   server_name ;

   ssl on;
   ssl_certificate /etc/nginx/ssl/-cert.pem;
   ssl_certificate_key /etc/nginx/ssl/-key.pem;

   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;
   listen 443 ssl;
   server_name ;

   ssl on;
   ssl_certificate /etc/nginx/ssl/-cert.pem;
   ssl_certificate_key /etc/nginx/ssl/-key.pem;

   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 avons séparé le bloc de serveur d’origine en deux blocs distincts et avons également demandé à Nginx d’écouter sur le port 443, le port par défaut des sites sécurisés.

Enregistrez le fichier et effectuez un test de configuration.

sudo nginx -t

Rechargez Nginx si le test réussit.

sudo systemctl reload nginx

Maintenant, accédez à l’un des domaines Apache dans votre navigateur en utilisant le préfixe + https: // +. Commencez par visiter + https: /// info.php + et vous verrez ceci:

image: https: //assets.digitalocean.com/articles/apache_nginx_reverse_proxy_ubuntu_16.04/hkuGcN8.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.

É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

Assurez-vous d’utiliser l’adresse IP de votre Droplet à 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.

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

É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.

Commencez par ouvrir le fichier d’hôte virtuel + apache.

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

Vous devez ajouter deux blocs d’emplacement supplémentaires à * chaque * bloc de serveur et modifier les blocs d’emplacement existants. (Si vous ne disposez que d’un bloc serveur de l’étape précédente, vous pouvez complètement remplacer le contenu de votre fichier afin qu’il corresponde au contenu présenté ci-dessous.) De plus, vous devrez indiquer à Nginx où trouver les fichiers statiques pour chaque site. . Ces modifications sont indiquées en rouge dans le code suivant:

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








       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;
   }




}

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








       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;
   }




}

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 cela 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 + foobar.net + . Utilisez la commande + tail + pour voir 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

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

- - [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.

Le seul inconvénient de cette configuration est qu’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.

Conclusion

Vous avez maintenant un droplet 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.

Related