Apache 2.x sur les systèmes Unix

Cette section contient les notes et conseils d'installation de PHP avec le serveur Apache 2.x sur les systèmes Unix.

Avertissement

Nous ne recommandons pas l'utilisation de PHP dans un environnement threadé MPM, avec Apache 2. Utilisez le mode prefork MPM, qui est le MPM par défaut pour Apache 2.0 et 2.2. Pour savoir pourquoi, lisez l'entrée de la FAQ correspondante à l'utilisation d'Apache 2 dans un environnement threadé MPM.

La » Documentation Apache est la meilleure source d'informations sur le serveur Apache 2.x. La plupart des informations sur les options d'installation d'Apache peut y être trouvée.

La version la plus récente du serveur HTTP Apache peut être obtenue depuis la » page de téléchargement d'Apache, et une version adaptée de PHP depuis les liens ci-dessus. Ce guide couvre uniquement les bases de fonctionnement d'Apache 2.x avec PHP. Pour plus d'informations, lire la » documentation Apache. Les numéros de version sont omis ici, pour s'assurer que les instructions ne soient pas incorrectes. Dans les exemples ci-dessous, 'NN' devra être remplacé par la version spécifique d'Apache à utiliser.

Il y a actuellement 2 versions d'Apache 2.x - 2.4 et 2.2. Il y a plusieurs raisons de choisir l'une plutôt que l'autre ; néanmoins, la version 2.4 est actuellement la dernière version disponible et c'est aussi celle qui est recommandée. Cependant, les instructions contenues dans ce guide devraient fonctionner pour la version 2.4 comme pour la version 2.2. Note : Apache httpd 2.2 est officiellement en fin de vie, il n'y aura plus de développement ni de correctif pour cette version.

Télécharger le serveur HTTP Apache depuis le site ci-dessus et le décompresser :
```
tar -xzf httpd-2.x.NN.tar.gz
```
De la même façon, télécharger et décompresser les sources de PHP :
```
tar -xzf php-NN.tar.gz
```
Compiler et installer Apache. Consulter la documentation sur l'installation d'Apache pour plus de détails quant à la compilation de ce logiciel.
```
cd httpd-2_x_NN
./configure --enable-so
make
make install
```
Maintenant qu'Apache 2.x.NN est disponible sous /usr/local/apache2, le configurer avec le support pour le chargement de modules, ainsi que le MPM prefork standard. Pour tester l'installation, utiliser la procédure normale pour démarrer le serveur Apache, c.-à-d. :
```
/usr/local/apache2/bin/apachectl start
```
et l'arrêter pour continuer la configuration de PHP :
```
/usr/local/apache2/bin/apachectl stop
```
Maintenant, configurez et compilez PHP. Ce sera à ce moment-là où il est possible de personnaliser PHP avec les diverses options disponibles, comme la liste des extensions à activer. Exécuter ./configure --help pour la liste des options disponibles. Dans notre exemple, nous effectuerons une configuration simple, avec Apache 2 et le support MySQL.

Si Apache a été construit depuis les sources, tel que décrit ci-dessus, l'exemple suivant devrait être correct concernant les chemins vers apxs, mais si Apache a été installé d'une autre façon, il faut prendre en compte les spécificités et ajuster les chemins apxs en conséquence. Il est à noter que suivant les distributions, il peut être nécessaire de renommer apxs en apxs2.
```
cd ../php-NN
./configure --with-apxs2=/usr/local/apache2/bin/apxs --with-pdo-mysql
make
make install
```
En cas de modification des options de configuration après l'installation, il faut exécuter de nouveau les étapes configure, make et make install. Il suffit alors de redémarrer Apache pour que le nouveau module prenne effet. Une re-compilation d'Apache n'est pas nécessaire.

Il est à noter que, sauf indications contraires, l'étape "make install" installera également » PEAR, mais aussi divers outils PHP comme phpize, PHP CLI et bien plus encore.
Configurer le fichier php.ini.
```
cp php.ini-development /usr/local/lib/php.ini
```
Il faut éditer le fichier .ini pour définir les options PHP. Pour placer ce fichier dans un autre répertoire, utiliser l'option --with-config-file-path=/some/path à l'étape 5.

En cas d'utilisation du fichier php.ini-production, il faut s'assurer de lire la liste des modifications correspondante car il peut affecter considérablement la façon dont PHP fonctionnera.
Éditer le fichier httpd.conf pour charger le module PHP. Le chemin spécifié à droite de la chaîne LoadModule, doit correspondre au chemin système du module PHP. L'étape "make install" ci-dessus devrait avoir réalisé cette opération automatiquement, mais une simple vérification permettra de s'en assurer.
Pour PHP 8:
```
LoadModule php_module modules/libphp.so
```
Pour PHP 7:
```
LoadModule php7_module modules/libphp7.so
```
Configurer Apache pour analyser certaines extensions comme étant des scripts PHP. Par exemple, laisser Apache passer à PHP les fichiers dont l'extension est .php. Au lieu d'utiliser seulement la directive AddType d'Apache, nous souhaitons éviter tout risque potentiellement dangereux, lors d'un téléchargement et de la création de fichier comme exploit.php.jpg, d'être exécutés par PHP. En utilisant cet exemple, il est possible d'avoir n'importe quelle extension analysée par PHP. Nous avons ajouté .php pour l'exemple.
```
<FilesMatch \.php$>
    SetHandler application/x-httpd-php
</FilesMatch>
```
Ou, pour autoriser les fichiers .php, .php2, .php3, .php4, .php5, .php6, et .phtml à être analysés par PHP, mais rien d'autre, nous utiliserons ceci :
```
<FilesMatch "\.ph(p[2-6]?|tml)$">
    SetHandler application/x-httpd-php
</FilesMatch>
```
Et pour autoriser les fichiers .phps à être gérés par le filtre du code source de PHP, et ainsi, être affichés comme code source avec la coloration syntaxique, utiliser ceci :
```
<FilesMatch "\.phps$">
    SetHandler application/x-httpd-php-source
</FilesMatch>
```
mod_rewrite peut être utilisé pour permettre à n'importe quel fichier .php d'être affiché comme code source avec coloration syntaxique, sans pour autant avoir besoin de le renommer ou de le copier avec une extension .phps :
```
RewriteEngine On
RewriteRule (.*\.php)s$ $1 [H=application/x-httpd-php-source]
```
Le filtre de code source PHP ne devrait pas être actif sur des systèmes de production, car il peut exposer du code confidentiel ou des informations sensibles contenues dans le code source.
Utiliser la procédure normale pour démarrer le serveur Apache, c.-à-d. :
```
/usr/local/apache2/bin/apachectl start
```
Ou
```
service httpd restart
```

En ayant suivi les étapes précédentes, le serveur web est maintenant un Apache2 fonctionnel avec le support PHP comme module SAPI. Bien sûr, il y a une multitude d'autres options de configuration de disponibles avec Apache et PHP. Pour plus d'informations, entrer la commande ./configure --help dans l'arbre source correspondant.

Apache peut être compilé en mode multithreadé, en sélectionnant le MPM worker, plutôt que le standard MPM prefork. Ceci est fait en ajoutant l'option suivante à l'argument de la commande "./configure", à l'étape 3 ci-dessus :

--with-mpm=worker

Cela ne devrait pas être entrepris sans être conscients des conséquences, et ayant au moins une juste compréhension de ce que cela implique. La documentation Apache concernant » MPM-Modules apportera d'importantes informations qui permettront de prendre une décision.

Note:
La FAQ Apache MultiViews traite de l'utilisation MultiViews avec PHP.

Note:
Pour compiler une version multithreadée d'Apache, le système cible doit supporter les threads. Dans ce cas, PHP doit également être construit avec Zend Thread Safety (ZTS). Sous cette configuration, toutes les extensions ne seront pas disponibles. La configuration recommandée est de compiler Apache avec le module MPM prefork par défaut.