PHP + FastCGI Process Manager

Fonctionnalités et Utilisations de php8.2-fpm : Performance Améliorée :

Gestion des processus : php-fpm gère un pool de travailleurs PHP, réduisant ainsi le coût de démarrage de nouveaux processus PHP. Cela permet de traiter les requêtes plus rapidement. Caching d'Opcode : Il peut être configuré pour utiliser des extensions comme OPcache pour mettre en cache le code PHP compilé, réduisant ainsi le temps de traitement des scripts.

Performance :

Gestion des processus : gère un pool de travailleurs PHP, réduisant ainsi le coût de démarrage de nouveaux processus PHP. Cela permet de traiter les requêtes plus rapidement.
Gestion des processus : gère un pool de travailleurs PHP, réduisant ainsi le coût de démarrage de nouveaux processus PHP. Cela permet de traiter les requêtes plus rapidement.

Flexible :

Caching d'Opcode : Il peut être configuré pour utiliser des extensions comme OPcache pour mettre en cache le code PHP compilé, réduisant ainsi le temps de traitement des scripts.
Pools de Processus : Vous pouvez configurer plusieurs pools de processus avec des paramètres différents pour chaque pool (nombre de processus enfants, utilisateurs, groupes, etc.), ce qui permet de répondre aux besoins spécifiques de différentes applications sur le même serveur.
Paramètres Fins : offre une grande flexibilité dans la configuration des limites de mémoire, des temps d'exécution, des tailles de téléchargement, etc.

Gestion de la Charge :

Redémarrage Automatique : En cas de défaillance d'un processus, php-fpm peut automatiquement redémarrer le processus défaillant sans perturber le service.
Gestion de la Charge : php-fpm peut gérer un grand nombre de requêtes simultanées en équilibrant la charge entre les processus enfants.

Sécurité :

Isolation des Applications : En utilisant des pools de processus distincts pour différentes applications, il est possible d'améliorer la sécurité en isolant les environnements d'exécution.
Limitation des Ressources : Vous pouvez définir des limites strictes sur les ressources consommées par chaque processus, réduisant ainsi les risques d'épuisement des ressources du serveur.

Intégration avec les Serveurs Web :

Nginx : php-fpm est couramment utilisé avec Nginx, un serveur web léger et performant, pour fournir une solution de stack web hautement performante.
Apache : Il peut également être utilisé avec Apache via le module mod_proxy_fcgi pour gérer les requêtes PHP de manière plus efficace que le module mod_php.

Installation

  sudo apt install php8.2-fpm  #Insallation
  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 fcgid        # Active le module FastCGI pour Apache HTTP Server
sudo a2enmod proxy_fcgi
sudo a2enmod rewrite      # Active le module  de réécriture d'URL (.htaccess : )


# sudo a2enmod proxy      # Active le module qui Proxy inverse d'apache 
#sudo a2enmod ssl
sudo a2dismod fcgid
sudo a2dismod ssl

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

 sudo nano /etc/php/8.2/fpm/php.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

sudo systemctl restart apache2

Configuration de FastCGI

Configurez les pools de processus dans /etc/php/8.2/fpm/pool.d/. Par exemple, pour le pool par défaut www :

[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

Config PHP

https://nomdedomaine.fr/info.php # pour le chemin [Configuration File (php.ini) Path]
sudo nano [Configuration File (php.ini) Path]

    
engine = On                     # Activez PHP.
precision = 14                  # Le nombre de chiffres significatifs affichés dans les nombres à virgule flottante.
short_open_tag = Off            # Activez    
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 (Unlimited) http://php.net/max-input-time
memory_limit = 128M             # http://php.net/memory-limit  -1 (Unlimited)
display_errors = Off 
log_errors = On
register_argc_argv = Off        # $argv contient un tableau de tous les arguments passés à PHP lorsqu'un script https://nomdedomaine.fr/info.php?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 1 foix
max_input_vars = 1000           # Nombre maximum de champ d'imput ou autre d'un formulaire HTML <FROM

Configurer PHP-FPM pour chaque site !!

sudo nano /etc/php/8.0/fpm/pool.d/mon_site
  
[mon_site]
user = www-data
group = www-data
listen = /run/php/php8.0-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.0-fpm-mon_site.log



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

paramètres de configuration PHP via un fichier .htaccess

sudo nano /var/www/mon_site.fr/.htaccess

php_value memory_limit 128M             # Modifier la limite de mémoire
php_flag display_errors on              # Activer l'affichage des erreurs
php_value upload_max_filesize 20M       # Modifier la taille maximale d'un fichier téléversé
php_value max_execution_time 60         # Modifier le temps d'exécution maximum d'un script
php_flag register_globals off           # Désactiver la fonction de registre global
  
  https://mon_site.fr/info.php          # vérifier la colonne "Local Value"

paramètres de configuration PHP via un fichier .PHP

sudo nano /var/www/mon_site.fr/.htaccess

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

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



echo "" | 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

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 netstat -tulnp | grep apache2
sudo netstat -tulnp | grep nginx
sudo tcpdump -i any -n host 127.0.0.1 and port 8080

Pour Apache avec mod_proxy_fcgi :


  
<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ère les processus enfants + module mpm_prefork

Pouvez obtenir un serveur Apache performant, stable et efficace. il faut mettre des Limites !

Gérer efficacement les pics de charge sans être surchargé.
Garantir un temps de réponse rapide
Limiter l'utilisation de la mémoire et des CPU
Prévenir les fuites de mémoire
Éviter les crashs et lessurcharger
Renouvele les ressources régulièrement


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

  
<VirtualHost *:80>
<IfModule mpm_prefork_module>
    MaxRequestWorkers 150             #Définit le nombre maximum de processus enfants qui peuvent être lancés pour traiter les requêtes simultanément.
</IfModule>


ou
  
</IfModule mpm_prefork_module>
    StartServers             2          #Définit le nombre de processus serveurs créés au démarrage d'Apache
    MinSpareThreads         25          #Spécifie le nombre minimum de processus enfants inactifs
    MaxSpareThreads         75          #Spécifie le nombre maximum de processus enfants inactifs
    ThreadLimit             64          # avec le module mpm_worker
    ThreadsPerChild         25
    MaxRequestWorkers      150
    MaxConnectionsPerChild   0
    Timeout                 30
    KeepAliveTimeout        30
<//IfModule>

MinSpareThreads : Avoir un nombre trop bas peut causer des délais lorsque les nouvelles demandes arrivent, car Apache doit créer de nouveaux processus. Un nombre trop élevé peut entraîner une consommation de mémoire inutile.

MaxRequestWorkers : Un nombre trop élevé peut entraîner une surcharge du serveur et une utilisation excessive de la mémoire.

Calcul de MaxRequestWorkers :

pour un petit serveur : Intel ATOM N2800 - 2c/4t - 1.86 GHz 4 Go de RAM
Calcul de la mémoire :
Disons qu'on réserve 1 Go pour le système d'exploitation et d'autres processus
Donc, il reste 3 Go pour Apache avec Supposons une moyenne de 50 Mo par processus.
MaxRequestWorkers = Mémoire disponible pour Apache / Mémoire par processus Apache voir avec php.ini : memory_limit
MaxRequestWorkers = 3072 / 50 ≈ 61

nombre maximal de requêtes simultanées par seconde que le serveur peut traiter.
Cela inclut toutes les requêtes HTTP, qu'elles soient pour afficher des pages, des fichiers statiques, des image ou d'autres types de contenu.

Si une page WordPress typique nécessite, disons, 30 requêtes HTTP pour charger complètement (HTML + CSS + JS + images), alors 61 MaxRequestWorkers pourraient permettre 2 visiteurs simultanés avant que des requêtes commencent à être mises en file d'attente.

Pour journaliser l'utilisation de MaxRequestWorkers, vous pouvez utiliser le module mod_status


sudo a2enmod status
  
<Location "/server-status">
    SetHandler server-status
    Require local
    # Si vous souhaitez autoriser l'accès depuis une adresse IP spécifique :
    # Require ip 192.168.1.0/24
</Location>

sudo systemctl restart apache2

Ce script enregistre le nombre de travailleurs occupés et inactifs toutes les minutes dans un fichier journal. Vous pouvez ajuster l'intervalle de temps selon vos besoins.


http://localhost/server-status
  
#!/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

Serveur Debian 12 - PHP FastCGI Process Manager