---
title: Module FastCGI Process Manager
source: https://synapx.fr/blog/fastcgi-process-manager/
date: 2026-06-26
category: Modules
site: SynapxLab
---

# Module FastCGI Process Manager

## PHP + FastCGI Process Manager

Vue d'ensemble des fonctionnalités et des usages de `php8.2-fpm`.

PHP-FPM (FastCGI Process Manager) administre un pool de processus PHP, ce qui limite le coût de démarrage de nouvelles exécutions et améliore le traitement des requêtes. Il peut également être associé à des extensions comme OPcache afin de mettre en cache le code PHP compilé et de réduire le temps d'exécution des scripts.

- **Performance :**
  - Gestion des processus : un pool de travailleurs PHP réduit le coût de création de nouveaux processus et accélère le traitement des requêtes.
- **Flexibilité :**
  - Caching d'Opcode : PHP-FPM peut s'appuyer sur des extensions comme OPcache pour mettre en cache le code PHP compilé et réduire le temps de traitement.
  - Pools de processus : plusieurs pools peuvent être configurés avec des paramètres distincts (nombre de processus enfants, utilisateurs, groupes, etc.), afin de répondre aux besoins spécifiques de différentes applications sur un même serveur.
  - Paramètres fins : la configuration reste très souple pour les limites mémoire, les temps d'exécution, les tailles de téléversement, etc.
- **Gestion de la charge :**
  - Redémarrage automatique : en cas de défaillance d'un processus, `php-fpm` peut relancer automatiquement le processus concerné sans interrompre le service.
  - `php-fpm` peut absorber un volume élevé de requêtes simultanées en répartissant la charge entre les processus enfants.
- **Sécurité :**
  - Isolation des applications : l'utilisation de pools distincts pour différentes applications améliore la sécurité en séparant les environnements d'exécution.
  - Limitation des ressources : il est possible de définir des limites strictes sur les ressources consommées par chaque processus, ce qui réduit les risques d'épuisement des ressources du serveur.
- **Intégration avec les serveurs web :**
  - Nginx : `php-fpm` est couramment associé à Nginx, un serveur web léger et performant, pour constituer une pile web efficace.
  - Apache : il peut également être utilisé avec Apache via le module `mod_proxy_fcgi`, afin de traiter les requêtes PHP plus efficacement que `mod_php`.

## Installation

```bash
sudo apt install php8.2-fpm            # Installation
sudo systemctl status php8.2-fpm
sudo systemctl restart php8.2-fpm      # Redémarre
ls -l /run/php/php8.2-fpm.sock
cat /etc/php/8.2/fpm/php-fpm.conf      # Le fichier principal
sudo nano /etc/php/8.2/fpm/php-fpm.conf

sudo a2enmod proxy_fcgi setenvif
sudo a2enmod rewrite      # Active le module de réécriture d'URL (.htaccess)

# sudo a2enmod proxy      # Active le module de proxy inverse d'Apache
# sudo a2enmod ssl
```

Exemple de règles de réécriture (`.htaccess` ou VirtualHost) :

```apache
<VirtualHost *:8080>
    <IfModule mod_rewrite.c>
        RewriteEngine On
        RewriteCond %{REQUEST_FILENAME} !-f
        RewriteCond %{REQUEST_FILENAME} !-d
        RewriteRule ^(.*)$ index.php [QSA,L]
    </IfModule>
</VirtualHost>

# Exemple de fichier .htaccess
<IfModule mod_rewrite.c>
    RewriteEngine On
    RewriteCond %{REQUEST_FILENAME} !-f
    RewriteCond %{REQUEST_FILENAME} !-d
    RewriteRule ^(.*)$ index.php [QSA,L]
</IfModule>
```

## Configuration de PHP

```bash
sudo nano /etc/php/8.2/fpm/php.ini
```

```ini
[Erreurs]
display_errors = On
display_startup_errors = On
log_errors = On
error_log = /var/log/php_errors.log

[Ressources]
memory_limit = 256M         # Limite de mémoire
max_execution_time = 30     # Temps d'exécution maximal : 30s
upload_max_filesize = 50M   # Taille maximale des fichiers téléversés
post_max_size = 50M         # Taille maximale des données POST

[Sessions]
session.gc_maxlifetime = 1440     # Durée de vie des sessions : 24 min

[Autre]
date.timezone = Europe/Paris
```

```bash
sudo systemctl restart php8.2-fpm
```

## Configuration de FastCGI

Les pools de processus se configurent dans `/etc/php/8.2/fpm/pool.d/`. Par exemple, pour le pool par défaut `www` :

```ini
[www]
user = www-data
group = www-data
listen = /run/php/php8.2-fpm.sock
pm = dynamic
pm.max_children = 50
pm.start_servers = 5
pm.min_spare_servers = 5
pm.max_spare_servers = 35
```

## Configuration de php.ini

Affichez `https://nomdedomaine.fr/info.php` pour identifier le chemin `[Configuration File (php.ini) Path]`, puis éditez ce fichier :

```bash
sudo nano [Configuration File (php.ini) Path]
```

```ini
engine = On                     # Active PHP.
precision = 14                  # Nombre de chiffres significatifs des nombres à virgule flottante.
short_open_tag = Off            # N'active que la forme courte <? ; <?= reste disponible
max_execution_time = 30         # Temps d'exécution maximum de chaque script
max_input_time = 60             # Temps maximum que chaque [script + post] peut passer ; -1 (illimité)
memory_limit = 128M             # -1 (illimité)
display_errors = Off
log_errors = On
register_argc_argv = Off        # $argv contient les arguments passés au script (?var1=132&var2=4)
error_reporting = E_ALL
# error_reporting = E_ALL & ~E_DEPRECATED & ~E_STRICT

upload_max_filesize = 128M      # Taille maximale autorisée pour les fichiers téléchargés.
max_file_uploads = 20           # Nombre maximum de fichiers pouvant être téléchargés en une fois
max_input_vars = 1000           # Nombre maximum de champs d'un formulaire HTML
```

## Configurer PHP-FPM pour chaque site

```ini
# sudo nano /etc/php/8.2/fpm/pool.d/mon_site.conf
[mon_site]
user = www-data
group = www-data
listen = /run/php/php8.2-fpm-mon_site.sock
listen.owner = www-data
listen.group = www-data
php_admin_value[open_basedir] = /var/www/html:/tmp
php_admin_value[memory_limit] = 128M
php_admin_value[upload_max_filesize] = 50M
php_admin_value[post_max_size] = 50M
php_admin_value[date.timezone] = Europe/Paris

php_value[session.save_path] = /var/lib/php/sessions
php_value[error_log] = /var/log/php8.2-fpm-mon_site.log
```

```apache
# sudo nano /etc/apache2/sites-available/mon_site.fr.conf
<FilesMatch \.php$>
   SetHandler "proxy:unix:/run/php/php8.2-fpm-mon_site.sock|fcgi://localhost/"
</FilesMatch>
```

```bash
sudo systemctl restart php8.2-fpm
sudo systemctl restart apache2
```

## Paramètres de configuration PHP via un fichier `.user.ini`

```ini
# sudo nano /var/www/mon_site.fr/.user.ini
memory_limit = 128M
display_errors = On
upload_max_filesize = 20M
max_execution_time = 60
# https://mon_site.fr/info.php          → vérifier la colonne "Local Value"
```

## Paramètres de configuration PHP via un fichier .php

```php
ini_set('memory_limit', '256M');            // Modifier la limite de mémoire
ini_set('display_errors', '1');             // Activer l'affichage des erreurs
ini_set('max_execution_time', '120');       // Changer le temps d'exécution maximum d'un script
// https://mon_site.fr/info.php          → vérifier la colonne "Local Value"
```

### Pour Nginx

```nginx
server {
    listen 80;
    server_name nomdedomaine.fr;

    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/var/run/php/php8.2-fpm.sock;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
    }
}
```

```bash
echo "<?php phpinfo(); ?>" | sudo tee /var/www/html/info.php
```

```
Sans FastCGI
Server API                          Apache 2.0 Handler
Configuration File (php.ini) Path   /etc/php/8.2/apache2

Avec FastCGI
Server API                          FPM/FastCGI
Configuration File (php.ini) Path   /etc/php/8.2/fpm
```

```bash
sudo apachectl configtest
sudo systemctl restart apache2
nginx -t
sudo systemctl restart nginx

sudo tail -f /var/log/nginx/access.log
sudo tail -f /var/log/apache2/access.log
curl -I http://your_domain.com
sudo ss -tulnp | grep apache2
sudo ss -tulnp | grep nginx
sudo tcpdump -i any -n host 127.0.0.1 and port 8080
```

### Pour Apache avec mod_proxy_fcgi

```apache
<VirtualHost *:80>
    ServerName nomdedomaine.fr
    DocumentRoot /var/www/nomdedomaine

    <FilesMatch \.php$>
        SetHandler "proxy:unix:/run/php/php8.2-fpm.sock|fcgi://localhost/"
    </FilesMatch>
</VirtualHost>

<VirtualHost 127.0.0.1:8080>
    ServerAdmin webmaster@localhost
    DocumentRoot /var/www/html

    <Directory /var/www/html>
        Options Indexes FollowSymLinks
        AllowOverride None
        Require all granted
    </Directory>

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

    # Passer les requêtes PHP à PHP-FPM
    <FilesMatch \.php$>
        SetHandler "proxy:unix:/run/php/php8.2-fpm.sock|fcgi://localhost/"
        ProxyTimeout 300
        ProxyIOBufferSize 16384
    </FilesMatch>

    <IfModule mpm_prefork_module>
        MaxRequestWorkers 150         # limite les processus enfants
    </IfModule>

    # Définir des variables d'environnement
    SetEnv APP_ENV production
    SetEnv DB_HOST localhost

    # Configuration du cache proxy
    CacheQuickHandler off
    CacheLock on
    CacheLockPath /tmp/mod_cache-lock
    CacheLockMaxAge 5
    CacheIgnoreHeaders Set-Cookie

    ProxyErrorOverride On
    ErrorDocument 500 /error/500.html
    ErrorDocument 502 /error/502.html
    ErrorDocument 503 /error/503.html
    ErrorDocument 504 /error/504.html
</VirtualHost>
```

## Gérer les processus enfants + module mpm_prefork

Pour obtenir un serveur Apache performant, stable et cohérent sous charge, il est nécessaire de définir des limites claires :

- absorber les pics de charge sans saturer le serveur ;
- préserver des temps de réponse rapides ;
- contenir l'utilisation de la mémoire et du CPU ;
- limiter l'impact des fuites mémoire ;
- réduire les risques de surcharge ou d'arrêt du service ;
- renouveler régulièrement les ressources consommées.

```bash
# Désactiver les autres modules MPM
sudo a2dismod mpm_event
sudo a2dismod mpm_worker

# Activer le module mpm_prefork
sudo a2enmod mpm_prefork

apache2ctl -M | grep mpm

sudo systemctl restart apache2
```

```apache
<VirtualHost *:80>
<IfModule mpm_prefork_module>
    MaxRequestWorkers 150    # Nombre maximum de processus enfants lancés simultanément pour traiter les requêtes.
</IfModule>
</VirtualHost>
```

ou

```apache
<IfModule mpm_prefork_module>
    StartServers             2          # Nombre de processus serveurs créés au démarrage d'Apache
    MinSpareServers         5           # Nombre minimum de processus enfants inactifs
    MaxSpareServers         10          # Nombre maximum de processus enfants inactifs
    MaxRequestWorkers      150
    MaxConnectionsPerChild   0
    Timeout                 30
    KeepAliveTimeout        30
</IfModule>
```

**MinSpareServers** : une valeur trop basse peut introduire un délai à l'arrivée de nouvelles requêtes, car Apache doit créer des processus supplémentaires. Une valeur trop élevée consomme inutilement de la mémoire.

**MaxRequestWorkers** : une valeur trop élevée peut provoquer une surcharge du serveur et une consommation excessive de mémoire.

### Calcul de MaxRequestWorkers

Pour un petit serveur (Intel ATOM N2800 - 2c/4t - 1.86 GHz - 4 Go de RAM) :

- On réserve 1 Go pour le système d'exploitation et les autres processus.
- Il reste 3 Go pour Apache, avec une moyenne de 50 Mo par processus.
- MaxRequestWorkers = Mémoire disponible pour Apache / Mémoire par processus Apache (voir `php.ini` : `memory_limit`).
- MaxRequestWorkers = 3072 / 50 ≈ 61

Il s'agit du nombre maximal de requêtes simultanées que le serveur peut traiter. Cela inclut l'ensemble des requêtes HTTP, qu'elles concernent des pages, des fichiers statiques, des images ou tout autre contenu.

Si une page WordPress typique nécessite par exemple 30 requêtes HTTP pour se charger complètement (HTML + CSS + JS + images), alors 61 `MaxRequestWorkers` permettraient environ 2 visiteurs simultanés avant que certaines requêtes ne commencent à patienter en file d'attente.

Pour suivre l'utilisation de `MaxRequestWorkers`, vous pouvez exploiter le module `mod_status` :

```bash
sudo a2enmod status
```

```apache
<Location "/server-status">
    SetHandler server-status
    Require local
    # Pour autoriser une adresse IP spécifique :
    # Require ip 192.168.1.0/24
</Location>
```

```bash
sudo systemctl restart apache2
```

Consultez ensuite `http://localhost/server-status`. Le script ci-dessous enregistre toutes les minutes le nombre de travailleurs occupés et inactifs dans un fichier journal (vous pouvez ajuster l'intervalle selon vos besoins) :

```bash
#!/bin/bash
while true; do
    TIMESTAMP=$(date "+%Y-%m-%d %H:%M:%S")
    STATUS=$(curl -s http://localhost/server-status?auto)
    BUSY_WORKERS=$(echo "$STATUS" | grep "BusyWorkers" | awk '{print $2}')
    IDLE_WORKERS=$(echo "$STATUS" | grep "IdleWorkers" | awk '{print $2}')
    echo "$TIMESTAMP - Busy Workers: $BUSY_WORKERS, Idle Workers: $IDLE_WORKERS" >> /var/log/apache2/max_request_workers.log
    sleep 60
done
```