---
title: Serveur Web Apache
source: https://synapx.fr/blog/serveur-web-apache/
date: 2026-06-26
category: Serveur Web
site: SynapxLab
---

# Serveur Web Apache

Apache associé à PHP permet d'héberger aussi bien le site par défaut (`/var/www/html`) que des sites dédiés, accessibles par nom de domaine (`/var/www/nomdedomaine.fr`).

```
+------------------+
|  Utilisateurs    |
+---------+--------+
          |
          v
+---------------------------+
|       Apache + PHP        |
+-------------+-------------+
      |                 |
      v                 v
+---------------+    +----------------------------+
| /var/www/html |    | /var/www/nomdedomaine.fr   |
|   default     |    |   site2                    |
+---------------+    +----------------------------+
```

## Installer Apache & PHP

```bash
apt install apache2 -y
systemctl status apache2

apt install php libapache2-mod-php php-mysql php-xml php-mbstring php-curl -y  # dernière version stable
apt remove --purge php libapache2-mod-php php-mysql php-xml php-mbstring php-curl -y

# dépôts de Sury
apt install -y apt-transport-https lsb-release ca-certificates wget gnupg
wget -qO /etc/apt/trusted.gpg.d/php.gpg https://packages.sury.org/php/apt.gpg
echo "deb https://packages.sury.org/php/ $(lsb_release -sc) main" | sudo tee /etc/apt/sources.list.d/php.list
apt update
apt install php8.3 php8.3-mysql php8.3-xml php8.3-fpm php8.3-mbstring php8.3-curl libapache2-mod-php8.3 -y
apt remove --purge php php8.2* libapache2-mod-php8.2 -y
apt autoremove --purge -y

a2dismod php8.2 # Désactiver mod_php si l'ancienne version est encore chargée
a2enconf php8.3-fpm    # Apache délègue le traitement des scripts à un serveur FastCGI (ne charge pas PHP dans Apache lui-même), plus performant et sécurisé
a2enmod proxy_fcgi setenvif  # Activer les modules nécessaires au proxy FastCGI
systemctl reload apache2  # Recharger Apache

apachectl -S # permet de récupérer des informations sur la configuration d'Apache.

http://votre_ip/
http://name_serveur/
echo "<?php phpinfo();?>" | tee /var/www/html/info.php
bash -c 'echo "<?php phpinfo(); ?>" > /var/www/html/info.php && chmod 644 /var/www/html/info.php'

# Tester la configuration Apache
apachectl configtest              # Teste la syntaxe des fichiers de conf (à faire AVANT un reload !)

# Démarrer / redémarrer / arrêter Apache
systemctl start apache2           # Démarre Apache
systemctl stop apache2            # Arrête Apache
systemctl restart apache2         # Redémarre Apache (arrêt + démarrage complet)
systemctl reload apache2          # Recharge la conf SANS couper les connexions (gracieux)
systemctl status apache2          # Affiche l'état du service Apache (actif, erreurs, etc.)

# Statut détaillé (version + modules + virtualhosts)
apache2ctl status                 # Affiche un mini résumé du service Apache
apache2ctl fullstatus             # Plus détaillé (nécessite mod_status activé et accessible)
apache2ctl -S                     # Liste les VirtualHosts, ports, fichiers de conf utilisés

# Redémarrage sans perte de connexions
apache2ctl graceful               # Recharge la configuration et relance les processus enfants sans tout couper
apache2ctl graceful-stop          # Arrête Apache proprement, après avoir terminé les connexions actives

# Autres utiles
apache2ctl -M                     # Liste des modules Apache chargés
apache2ctl -V                     # Affiche la version Apache et les chemins de compilation
apache2ctl help                   # Liste des options disponibles

tail -f /var/log/apache2/error.log
tail -f /var/log/apache2/access.log
```

## Modules Apache compatibles avec PHP

Apache peut exécuter PHP via plusieurs modules. Toutefois, **un seul doit être actif par VirtualHost** afin d'éviter tout conflit.

| Module | Description | Utilisation recommandée | Statut |
| --- | --- | --- | --- |
| `mod_php` (libapache2-mod-php) | PHP est chargé directement dans Apache. Simple à configurer, adapté au développement local. | Développement local, petits projets | Classique (mais dépassé en prod) |
| `mod_fcgid` (libapache2-mod-fcgid) | Apache exécute des scripts FastCGI externes (souvent `php-cgi`). Différent de `proxy_fcgi` vers PHP-FPM. | Cas legacy, CGI/FastCGI spécifiques | À réserver aux besoins précis |
| `proxy_fcgi` + `php8.x-fpm` | Apache proxy les requêtes PHP vers PHP-FPM (via socket ou TCP). La méthode recommandée aujourd'hui. | Production, multi-version PHP | Recommandé |
| `mod_fastcgi` | Ancien module FastCGI, non maintenu. Remplacé par mod_fcgid. | À éviter | Obsolète |
| `mod_cgi` / `mod_cgid` | Exécute PHP en mode CGI pur. Très lent et inefficace en production. | Cas extrêmes, dépannage | À éviter |

Exemple de VirtualHost utilisant `proxy_fcgi` avec PHP-FPM :

```apache
<VirtualHost *:80>
    ServerName mon-site.local
    DocumentRoot /var/www/mon-site/httpdoc

    <Directory /var/www/mon-site/>
        Options Indexes FollowSymLinks
        AllowOverride All
        Require all granted
    </Directory>

    # Rediriger les requêtes PHP vers PHP-FPM via proxy_fcgi
    <FilesMatch \.php$>
        SetHandler "proxy:unix:/run/php/php8.3-fpm.sock|fcgi://localhost/"
    </FilesMatch>

    ErrorLog ${APACHE_LOG_DIR}/mon-site_error.log
    CustomLog ${APACHE_LOG_DIR}/mon-site_access.log combined
</VirtualHost>
```

Gestion des modules :

```bash
# Les Modules :
a2enmod fcgid
a2enmod rewrite
a2enmod proxy
a2enmod proxy_fcgi
a2enmod ssl

# [Install]
apt install nom_du_module
a2enmod nom_du_module
systemctl restart apache2

# [Remove]
a2dismod nom_du_module
apt remove --purge nom_du_module
systemctl restart apache2
```

## Paquets PHP utiles

| Paquet | Description | Utilisation typique | Nécessaire pour |
| --- | --- | --- | --- |
| `libapache2-mod-php` | Module Apache qui intègre directement PHP dans Apache. | Exécution de scripts PHP sans passerelle externe. | Sites simples sans PHP-FPM |
| `php-mysql` | Extension PHP pour se connecter à des bases de données MySQL/MariaDB. | Accès aux BDD via PDO ou mysqli. | CMS, ERP, CRM avec base MySQL |
| `php-xml` | Extension pour le traitement XML (DOM, SimpleXML, etc.). | Lecture et génération de fichiers XML, SOAP, etc. | APIs, formats e-facture, flux RSS |
| `php-mbstring` | Support des chaînes multi-octets (UTF-8, etc.). | Traitement de texte multilingue. | Applications avec accents, caractères spéciaux |
| `php-curl` | Extension pour faire des requêtes HTTP via CURL (API REST, etc.). | Connexion à des services distants. | API, paiement en ligne, webhooks |
| `libapache2-mod-fcgid` | Module Apache pour exécuter des scripts via FastCGI classique (ex. `php-cgi`). | Compatibilité avec des montages FastCGI historiques. | Besoins legacy, CGI/FastCGI spécifiques |

## mod_php vs mod_fcgid

| | libapache2-mod-php | libapache2-mod-fcgid |
| --- | --- | --- |
| **Nom complet** | Module PHP intégré à Apache (mod_php) | Module FastCGI pour Apache (mod_fcgid) |
| **Fonctionnement** | PHP est chargé **directement** dans Apache | Apache lance ou contacte un exécutable FastCGI externe, souvent `php-cgi` |
| **Architecture** | Monolithique (Apache + PHP = même processus) | Séparée (Apache ↔ processus FastCGI) |
| **Gestion des processus** | Pas d'isolation par site ou utilisateur | Processus FastCGI séparés, mais sans la souplesse native des pools PHP-FPM |
| **Multi-version PHP** | Non (une seule version active à la fois) | Possible, mais plus lourd à maintenir que `proxy_fcgi` + PHP-FPM |
| **Performance** | Moins bon sous forte charge (Apache + PHP partagent les ressources) | Correcte, mais généralement moins souple que PHP-FPM moderne |
| **Sécurité** | Moins isolé (Apache exécute PHP avec ses propres droits) | Meilleure séparation que `mod_php`, variable selon le montage FastCGI |
| **Compatibilité** | Très simple à mettre en place (prêt à l'emploi pour des scripts PHP simples) | Utile surtout pour des montages historiques ou spécifiques |
| **Cas d'usage recommandé** | Développement local, projets simples, serveurs mono-site | Legacy, mutualisé ancien, compatibilité spécifique |

## Masquer les informations dans les en-têtes HTTP d'Apache

```bash
nano /etc/apache2/conf-available/security.conf
```

```apache
ServerTokens Prod       # Masquer la version d'Apache
ServerSignature Off      # Supprimer les informations de signature d'Apache
Header unset X-Powered-By # Supprimer l'en-tête 'X-Powered-By' pour PHP (et autres langages si nécessaire)
```

## Configurer son nom de domaine : nomdedomaine.fr

```bash
mkdir -p /var/www/nomdedomaine.fr/httpdoc  # crée le dossier du site (et les dossiers parents si besoin)
chown -R www-data:www-data /var/www/nomdedomaine.fr  # donne les droits à Apache/Nginx (www-data)
chmod -R 755 /var/www/nomdedomaine.fr  # rend le dossier accessible (lecture/exécution) au serveur

apt install php8.4-{mbstring,xml,curl,mysql,zip,gd,cli,fpm,opcache,intl,bcmath} -y
a2dismod php8.3 fcgid
a2enconf php8.4-fpm  # Active la configuration FPM pour PHP 8.4
a2enmod proxy_fcgi setenvif
systemctl reload apache2
```

Le VirtualHost doit pointer vers le socket PHP-FPM approprié :

```apache
nano /etc/apache2/sites-available/nomdedomaine.fr.conf

<VirtualHost *:80>
    ServerAdmin webmaster@nomdedomaine.fr
    ServerName nomdedomaine.fr
    ServerAlias www.nomdedomaine.fr

    DocumentRoot /var/www/nomdedomaine.fr
    #DocumentRoot /var/www/nomdedomaine.fr/httpdoc

    <Directory /var/www/nomdedomaine.fr>
        Options Indexes FollowSymLinks
        AllowOverride All
        Require all granted
    </Directory>

    ErrorLog ${APACHE_LOG_DIR}/nomdedomaine.fr-error.log
    CustomLog ${APACHE_LOG_DIR}/nomdedomaine.fr-access.log combined

    # Pass PHP scripts to FastCGI process manager
    <FilesMatch \.php$>
        # SetHandler "proxy:unix:/var/run/php/php8.2-fpm.sock|fcgi://localhost/"
        # SetHandler application/x-httpd-php
        # SetHandler "proxy:unix:/run/php/php8.3-fpm.sock|fcgi://localhost/"
        SetHandler "proxy:unix:/run/php/php8.4-fpm.sock|fcgi://localhost/"
    </FilesMatch>
</VirtualHost>
```

```bash
a2ensite nomdedomaine.fr
systemctl restart apache2

# Autres utiles
a2dissite nomdedomaine.fr.conf
```

## Le fichier hosts

Le fichier `hosts` est un fichier système qui permet d'associer localement un **nom de domaine** à une **adresse IP**, sans recourir à un serveur DNS.

### Cas d'usage

- Travailler localement sur un site avec un nom de domaine fictif (`admin.dev`, `monsite.test`, etc.)
- Rediriger un domaine vers une IP précise dans le cadre de tests
- Forcer un domaine à pointer vers une version particulière d'un serveur, notamment pour le débogage DNS

### Exemple d'entrée

```
192.168.1.100   monsite.local   www.monsite.local
```

### Emplacements du fichier hosts

- **Linux / macOS :** `/etc/hosts`
- **Windows :** `C:\Windows\System32\drivers\etc\hosts`

### Autres exemples de configuration

```
ton.ip          mon.domaine        www.mon.domaine
NameVirtualHost ip.du.pc
```

### Accès dans le navigateur

Une fois la configuration en place, il suffit d'accéder au site via : http://monsite.local

## Supprimer Apache & PHP

Cette opération supprime l'ensemble des configurations Apache existantes.

```bash
# Arrête le service Apache pour éviter les erreurs pendant la suppression
systemctl stop apache2

# Supprime complètement Apache et ses composants principaux
apt-get purge apache2 apache2-utils apache2-bin apache2.2-common -y
# - apache2 : le paquet principal
# - apache2-utils : outils comme ab (Apache Benchmark)
# - apache2-bin : les exécutables Apache
# - apache2.2-common : présent seulement sur d'anciennes versions d'Apache/Debian

# Supprime PHP et les modules associés côté Apache
apt remove --purge php libapache2-mod-php php-mysql php-xml php-mbstring php-curl -y
# Cela supprime PHP, ses extensions MySQL, XML, CURL, MBString, et l'intégration Apache (mod_php)

# Supprime les dossiers de configuration Apache
rm -rf /etc/apache2
# Contient tous les VirtualHosts, mods-enabled, conf-enabled…

# Supprime le dossier racine du site par défaut
rm -rf /var/www/html
# Le site de test affiché par défaut (page "It works!")

# Supprime les logs Apache
rm -rf /var/log/apache2
# Accès et erreurs, logs par VirtualHost

# Nettoyage des dépendances orphelines
apt-get autoremove -y
# Supprime tous les paquets installés automatiquement devenus inutiles après les purges
```

## Certificats SSL sur 000-default.conf

```apache
a2enmod ssl
a2enmod rewrite

# Activer le site SSL par défaut
a2ensite default-ssl
certbot --apache -d nomduserveur.eu

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

<VirtualHost *:80>
    ServerAdmin webmaster@localhost
    DocumentRoot /var/www/html

    # Rediriger tout le trafic HTTP vers HTTPS
    RewriteEngine on
    RewriteCond %{SERVER_NAME} =nomduserveur.eu
    RewriteRule ^ https://%{SERVER_NAME}%{REQUEST_URI} [END,NE,R=permanent]

    ErrorLog ${APACHE_LOG_DIR}/error.log
    CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

nano /etc/apache2/sites-available/default-ssl.conf

<VirtualHost *:443>
    ServerAdmin webmaster@localhost
    DocumentRoot /var/www/html

    ServerName nomduserveur.eu

    SSLEngine on
    SSLCertificateFile /etc/letsencrypt/live/nomduserveur.eu/fullchain.pem
    SSLCertificateKeyFile /etc/letsencrypt/live/nomduserveur.eu/privkey.pem
    Include /etc/letsencrypt/options-ssl-apache.conf

    ErrorLog ${APACHE_LOG_DIR}/error.log
    CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
```

## Choisir ses modules selon le besoin

| Configuration | Modules recommandés | Explication |
| --- | --- | --- |
| Affichage d'une simple page HTML | `mime`, `dir`, `alias` | Le strict minimum pour afficher une page HTML statique avec un fichier d'accueil (index.html). |
| Configuration rapide (performance) | `mime`, `dir`, `deflate`, `headers`, `env`, `alias` | Optimisé pour charger les pages plus vite grâce à la compression (deflate) et aux bons en-têtes HTTP. |
| Configuration sécurisée | `mime`, `dir`, `rewrite`, `headers`, `ssl`, `setenvif`, `reqtimeout` | Prend en compte la sécurité (HTTPS, protections via en-têtes, limite des requêtes lentes…). |
| Site PHP avec PHP-FPM (moderne) | `proxy`, `proxy_fcgi`, `setenvif`, `mime`, `dir`, `rewrite` | Recommandé pour faire tourner un site PHP avec performance et isolation grâce à PHP-FPM. |
| Surveillance du serveur | `status`, `alias` | Active une page interne /server-status pour surveiller les connexions, la charge, etc. (à restreindre par IP). |

## Liste des modules Apache (détaillée)

Ce tableau présente des modules Apache courants, leur état d'activation typique, leur fonction principale, leur type et leur niveau d'importance dans un environnement web standard.

| Module | État | Utilité | Type | Critique ? | Remarques |
| --- | --- | --- | --- | --- | --- |
| mod_php | Désactivé | Exécution directe de PHP dans Apache | Exécution | Non | Remplacé par proxy_fcgi + PHP-FPM pour de meilleures performances |
| proxy_fcgi | Activé | Proxy des requêtes FastCGI vers PHP-FPM | Proxy | Oui | Utilisé avec PHP-FPM. Préféré en production |
| setenvif | Activé | Variables d'environnement selon les entêtes | Configuration | Oui | Nécessaire pour certains handlers PHP et le module proxy_fcgi |
| rewrite | Activé | Réécriture d'URL | Fonctionnel | Oui | Requis pour de nombreux CMS (WordPress, Drupal…) |
| ssl | Désactivé | Support HTTPS / TLS | Sécurité | Oui si HTTPS | À activer pour les certificats SSL / Let's Encrypt |
| status | Activé | Statistiques serveur Apache | Diagnostic | Non | Utile pour le monitoring via /server-status |
| headers | Désactivé | Manipulation des entêtes HTTP | Fonctionnel | Oui dans certains cas | Utile pour les politiques de sécurité (CSP, HSTS…) |
| deflate | Activé | Compression gzip | Performance | Non | Améliore les temps de chargement |
| mime | Activé | Types MIME par extension | Base | Oui | Indispensable pour servir les bons en-têtes Content-Type |
| dir | Activé | Index par défaut (index.html, index.php) | Base | Oui | Permet la navigation correcte dans les dossiers |

### Modules expliqués en langage courant

| Module | État | Utilité (explication simple) |
| --- | --- | --- |
| access_compat | Activé | Permet à Apache d'interpréter les anciennes méthodes de restriction d'accès aux fichiers ou aux dossiers. |
| actions | Désactivé | Permet de définir une action à exécuter lorsqu'un utilisateur accède à un fichier donné. |
| alias | Activé | Crée des raccourcis entre une adresse web et un dossier du serveur. |
| allowmethods | Désactivé | Limite les types de requêtes qu'un visiteur peut envoyer, par exemple pour interdire les `POST`. |
| asis | Désactivé | Affiche le contenu tel quel, sans modification par Apache. |
| auth_basic | Activé | Ajoute une protection par mot de passe simple, généralement via une fenêtre de connexion. |
| auth_digest | Désactivé | Version plus sécurisée de la protection par mot de passe. |
| auth_form | Désactivé | Permet de protéger une page à l'aide d'un formulaire de connexion personnalisé. |
| authn_anon | Désactivé | Permet un accès sans identifiant, en mode anonyme. |
| authn_core | Activé | Module de base qui gère les vérifications d'identité. |
| authn_file | Activé | Utilise un fichier texte pour déterminer quels utilisateurs sont autorisés à accéder aux ressources. |
| authz_core | Activé | Permet de définir quels utilisateurs ou groupes peuvent consulter ou utiliser certaines parties du site. |
| authz_host | Activé | Contrôle l'accès selon l'adresse IP ou le nom de l'ordinateur du visiteur. |
| authz_user | Activé | Permet de donner des accès selon le nom d'utilisateur. |
| autoindex | Activé | Affiche automatiquement la liste des fichiers d'un dossier si aucun fichier d'accueil n'est présent. |
| brotli | Désactivé | Compresse les pages web avant leur envoi afin d'accélérer le chargement. |
| cache | Désactivé | Permet à Apache de mettre en cache certaines réponses afin d'améliorer les performances. |
| cgi | Désactivé | Permet d'exécuter des scripts CGI plus anciens, par exemple en Perl. |
| deflate | Activé | Compresse les fichiers envoyés aux visiteurs pour accélérer le chargement. |
| dir | Activé | Choisit automatiquement un fichier d'accueil comme index.html ou index.php. |
| env | Activé | Crée et utilise des variables d'environnement pour adapter le comportement du site selon le contexte. |
| fcgid | Activé | Permet à Apache de communiquer avec PHP, ou d'autres exécutables, via FastCGI. |
| filter | Activé | Filtre ou modifie le contenu des pages avant qu'elles ne soient envoyées. |
| mime | Activé | Indique à Apache quel type de fichier est servi (image, texte, etc.). |
| php8.2 | Activé | Permet à Apache d'exécuter les scripts PHP en version 8.2. |
| proxy | Activé | Permet à Apache de relayer des requêtes vers d'autres serveurs, notamment PHP-FPM. |
| proxy_fcgi | Activé | Spécialisé dans la redirection de requêtes vers PHP-FPM (via FastCGI). |
| reqtimeout | Activé | Évite qu'un client trop lent monopolise inutilement les ressources du serveur. |
| rewrite | Activé | Réécrit les URL afin de produire des adresses plus lisibles, particulièrement utiles pour les sites dynamiques. |
| setenvif | Activé | Adapte le comportement du site selon certains critères, comme le navigateur ou l'adresse IP. |
| socache_shmcb | Activé | Stocke temporairement certaines informations afin d'éviter des calculs répétés, par exemple pour les certificats SSL. |
| status | Activé | Fournit des informations techniques sur Apache, comme les connexions en cours ou la charge. |