Apache httpd 2.x sur les systèmes Unix

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

Avertissement

Utiliser PHP-FPM à la place

Ne pas utiliser mod_php pour les nouvelles installations. Les instructions de cette page sont conservées à titre de référence historique et pour les rares cas où l'intégration de PHP directement dans le processus Apache httpd est spécifiquement requise.

Pour tous les déploiements modernes, utiliser PHP-FPM (FastCGI Process Manager) avec le module mod_proxy_fcgi d'Apache httpd. PHP-FPM offre une meilleure gestion des ressources, l'isolation des processus, le redémarrage indépendant de PHP sans redémarrer Apache httpd, et la compatibilité avec le MPM event d'Apache httpd (le MPM par défaut depuis Apache httpd 2.4). Les principales distributions Linux utilisent cette configuration par défaut.

L'approche mod_php intègre PHP directement dans chaque processus worker d'Apache httpd. Sauf si PHP est compilé avec la sécurité des threads (--enable-zts), mod_php requiert le MPM prefork, ce qui limite significativement la simultanéité. L'utilisation de mod_php implique de bien comprendre les implications en termes de performances et de sécurité.

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

La version la plus récente d'Apache httpd 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 httpd 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 httpd à utiliser.

Ces instructions s'appliquent à Apache httpd 2.4, qui est la seule branche de version supportée d'Apache httpd. Les versions antérieures (2.2 et inférieures) sont en fin de vie et ne doivent pas être utilisées.

Note:
À partir de PHP 8.4.0, la SAPI apache2handler nécessite au minimum Apache 2.4 ; la prise en charge d'Apache 2.0 et 2.2, en fin de vie, a été retirée.

Télécharger Apache httpd 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 httpd. Consulter la documentation sur l'installation d'Apache httpd pour plus de détails. Il est à noter que mod_php requiert le MPM prefork, sauf si PHP a été compilé avec la sécurité des threads (--enable-zts). Pour utiliser PHP-FPM à la place (recommandé), il est possible d'utiliser le MPM event par défaut et passer directement aux instructions d'installation de PHP-FPM.
```
cd httpd-2_x_NN
./configure --enable-so --with-mpm=prefork
make
make install
```
Maintenant qu'Apache httpd 2.x.NN est disponible sous /usr/local/apache2, configuré avec le support du chargement de modules et le MPM prefork. Pour tester l'installation, utiliser la procédure normale pour démarrer le serveur Apache httpd, 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, configurer et compiler 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 httpd et le support MySQL.

Si Apache httpd 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 httpd 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 httpd n'est pas nécessaire.

Il est à noter que, sauf indications contraires, l'étape make install installera également » PEAR, 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 l'instruction 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.
```
LoadModule php_module modules/libphp.so
```
Configurer Apache httpd pour analyser certaines extensions comme étant des scripts PHP. Par exemple, laisser Apache httpd passer à PHP les fichiers dont l'extension est .php. Au lieu d'utiliser seulement la directive AddType, nous souhaitons éviter tout risque potentiellement dangereux lors d'un téléchargement et de la création de fichiers 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, simplement en les ajoutant. 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 "\.(php[2-6]?|phtml)$">
    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>
```
Pour permettre l'utilisation d'un fichier PHP comme gestionnaire par défaut lorsqu'aucun autre gestionnaire n'est trouvé, par exemple lors de l'utilisation d'un moteur de routage, la directive FallbackResource peut être utilisée.

Comme la directive SetHandler est appliquée que le fichier existe ou non, et que FallbackResource n'est appliquée que si aucun gestionnaire n'a déjà été défini, il peut être nécessaire d'utiliser la directive If pour s'assurer que le gestionnaire n'est appliqué que si le fichier existe. Cela permet à FallbackResource de gérer les chemins se terminant par .php mais qui n'existent pas, ce qui peut être utile pour la gestion des erreurs et le routage.
```
<FilesMatch "\.php$">
    <If "-f %{REQUEST_FILENAME}">
        SetHandler application/x-httpd-php
    </If>
</FilesMatch>
FallbackResource /index.php
```
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 Apache httpd, c.-à-d. :
```
/usr/local/apache2/bin/apachectl start
```
Ou
```
service httpd restart
```

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

Note: Compatibilité MPM

Sauf si PHP a été compilé avec la sécurité des threads Zend (--enable-zts), mod_php requiert le MPM prefork. Pour savoir pourquoi, lire l'entrée de la FAQ correspondante sur l'utilisation d'Apache httpd avec un MPM threadé.

La plupart des paquets de distribution de mod_php ne sont pas compilés avec ZTS, donc prefork est généralement requis. Si vous avez besoin d'un MPM threadé (recommandé pour de meilleures performances sous charge), utiliser PHP-FPM avec mod_proxy_fcgi à la place.

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