PHP : gérer plusieurs versions PHP-FPM avec les dépôts Sury sur Debian/Ubuntu

Héberger plusieurs applications PHP sur un même serveur, c’est souvent jongler avec des contraintes de versions : une app legacy tourne en PHP 7.4, un CMS récent exige PHP 8.2, et un projet pilote veut tester PHP 8.4. Les dépôts officiels Debian et Ubuntu ne fournissent généralement qu’une seule version par distribution, ce qui bloque cette cohabitation.

C’est là qu’interviennent les dépôts Sury, maintenus par Ondřej Surý, développeur Debian depuis l’an 2000 et empaqueteur officiel de PHP. Ces dépôts tiers proposent l’ensemble des versions PHP 7.x et 8.x (jusqu’à 8.5 à ce jour) coinstallables simultanément sur le même système, avec PHP-FPM pour chaque version. C’est la solution de référence adoptée par des milliers d’hébergeurs et administrateurs système.

Cet article couvre l’ajout des dépôts Sury sur Debian (Bookworm/Trixie) et Ubuntu (Jammy/Noble), l’installation de plusieurs versions PHP-FPM côte à côte, puis leur configuration dans Apache et Nginx pour acheminer chaque VirtualHost vers la version PHP souhaitée.

Pourquoi les dépôts Sury ?

Les versions PHP intégrées aux distributions sont figées au moment du gel du cycle de développement :

• Debian 11 (Bullseye) → PHP 7.4
• Debian 12 (Bookworm) → PHP 8.2
• Debian 13 (Trixie) → PHP 8.4
• Ubuntu 22.04 (Jammy) → PHP 8.1
• Ubuntu 24.04 (Noble) → PHP 8.3

Les dépôts Sury comblent cette lacune en rendant disponibles toutes les versions actives de PHP 7.0 à 8.5 sur toutes ces distributions. Les paquets sont coinstallables : chaque version dispose de son propre binaire CLI, son propre démon PHP-FPM et ses propres extensions, sans conflit de fichiers.

Avertissement : Une fois le dépôt Sury activé, ne le supprimez jamais sans avoir préalablement réinstallé PHP depuis les dépôts officiels. Sury met à jour certaines dépendances système (libssl, libxml2…) ; retirer la source sans gérer ces paquets casserait votre installation PHP.

Ajout du dépôt Sury

Sur Debian (Bookworm / Trixie)

La méthode recommandée utilise extrepo, outil officiel Debian pour gérer les dépôts tiers de confiance :

# Installer extrepo
sudo apt update && sudo apt install -y extrepo

# Activer le dépôt Sury (PHP)
sudo extrepo enable sury

# Mettre à jour la liste des paquets
sudo apt update

Si vous préférez la méthode manuelle (utile dans des environnements sans accès à extrepo) :

# Installer les prérequis
sudo apt install -y curl gnupg2 ca-certificates apt-transport-https lsb-release

# Importer la clé GPG de Sury
curl -sSLo /usr/share/keyrings/deb.sury.org-php.gpg 
  https://packages.sury.org/php/apt.gpg

# Ajouter le dépôt dans un fichier source dédié
echo "deb [signed-by=/usr/share/keyrings/deb.sury.org-php.gpg] 
https://packages.sury.org/php/ $(lsb_release -sc) main" 
  | sudo tee /etc/apt/sources.list.d/sury-php.list

# Mettre à jour
sudo apt update

Sur Ubuntu (Jammy 22.04 / Noble 24.04)

Sur Ubuntu, Ondřej Surý maintient un PPA officiel sur Launchpad. L’ajout se fait via add-apt-repository :

# Installer software-properties-common si absent
sudo apt install -y software-properties-common

# Ajouter le PPA Sury pour PHP
sudo add-apt-repository ppa:ondrej/php

# Mettre à jour la liste des paquets
sudo apt update

Installation de plusieurs versions PHP-FPM

Une fois le dépôt configuré, vous pouvez installer autant de versions PHP que nécessaire. Chaque version s’installe indépendamment avec son propre paquet phpX.Y-fpm :

# Installer PHP 8.1 avec FPM et les extensions courantes
sudo apt install -y php8.1-fpm php8.1-cli php8.1-common 
  php8.1-mysql php8.1-xml php8.1-curl php8.1-mbstring php8.1-zip

# Installer PHP 8.2 avec FPM
sudo apt install -y php8.2-fpm php8.2-cli php8.2-common 
  php8.2-mysql php8.2-xml php8.2-curl php8.2-mbstring php8.2-zip

# Installer PHP 8.4 avec FPM
sudo apt install -y php8.4-fpm php8.4-cli php8.4-common 
  php8.4-mysql php8.4-xml php8.4-curl php8.4-mbstring php8.4-zip

Vérifiez que chaque service PHP-FPM est bien actif :

# Lister les services PHP-FPM installés et leur état
systemctl list-units 'php*-fpm.service'

# Sortie attendue :
# php8.1-fpm.service   loaded active running The PHP 8.1 FastCGI Process Manager
# php8.2-fpm.service   loaded active running The PHP 8.2 FastCGI Process Manager
# php8.4-fpm.service   loaded active running The PHP 8.4 FastCGI Process Manager

Chaque version écoute sur son propre socket Unix dans /run/php/ :

ls -1 /run/php/
# php8.1-fpm.pid
# php8.1-fpm.sock
# php8.2-fpm.pid
# php8.2-fpm.sock
# php8.4-fpm.pid
# php8.4-fpm.sock

Configuration Apache : un VirtualHost, une version PHP

Apache délègue l’exécution PHP à PHP-FPM via le module proxy_fcgi. Il faut activer ce module ainsi que setenvif, puis configurer chaque VirtualHost pour pointer vers le socket de la version voulue.

# Activer les modules nécessaires
sudo a2enmod proxy_fcgi setenvif

# Activer la configuration FPM pour chaque version installée
sudo a2enconf php8.1-fpm
sudo a2enconf php8.2-fpm
sudo a2enconf php8.4-fpm

sudo systemctl reload apache2

Configuration d’un VirtualHost pour PHP 8.1 :

# /etc/apache2/sites-available/app-legacy.conf
<VirtualHost *:80>
    ServerName app-legacy.example.com
    DocumentRoot /var/www/app-legacy

    # Déléguer PHP à php8.1-fpm via son socket Unix
    <FilesMatch .php$>
        SetHandler "proxy:unix:/run/php/php8.1-fpm.sock|fcgi://localhost"
    </FilesMatch>

    <Directory /var/www/app-legacy>
        Options -Indexes +FollowSymLinks
        AllowOverride All
        Require all granted
    </Directory>
</VirtualHost>

Configuration d’un VirtualHost pour PHP 8.4 :

# /etc/apache2/sites-available/app-new.conf
<VirtualHost *:80>
    ServerName app-new.example.com
    DocumentRoot /var/www/app-new

    # Déléguer PHP à php8.4-fpm
    <FilesMatch .php$>
        SetHandler "proxy:unix:/run/php/php8.4-fpm.sock|fcgi://localhost"
    </FilesMatch>

    <Directory /var/www/app-new>
        Options -Indexes +FollowSymLinks
        AllowOverride All
        Require all granted
    </Directory>
</VirtualHost>

# Activer les sites et recharger Apache
sudo a2ensite app-legacy app-new
sudo apache2ctl configtest && sudo systemctl reload apache2

Configuration Nginx : un server block, une version PHP

Avec Nginx, la configuration est similaire : chaque bloc server pointe vers le socket du bon démon PHP-FPM via la directive fastcgi_pass :

# /etc/nginx/sites-available/app-legacy.conf
server {
    listen 80;
    server_name app-legacy.example.com;
    root /var/www/app-legacy;
    index index.php index.html;

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    location ~ .php$ {
        include snippets/fastcgi-php.conf;
        # Pointer vers php8.1-fpm
        fastcgi_pass unix:/run/php/php8.1-fpm.sock;
    }
}

# /etc/nginx/sites-available/app-new.conf
server {
    listen 80;
    server_name app-new.example.com;
    root /var/www/app-new;
    index index.php index.html;

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    location ~ .php$ {
        include snippets/fastcgi-php.conf;
        # Pointer vers php8.4-fpm
        fastcgi_pass unix:/run/php/php8.4-fpm.sock;
    }
}

# Activer les sites et tester la configuration Nginx
sudo ln -s /etc/nginx/sites-available/app-legacy.conf /etc/nginx/sites-enabled/
sudo ln -s /etc/nginx/sites-available/app-new.conf /etc/nginx/sites-enabled/
sudo nginx -t && sudo systemctl reload nginx

Vérification et tests

Créez un fichier info.php dans chaque DocumentRoot pour confirmer que le bon interpréteur PHP est utilisé :

# Créer un phpinfo dans chaque site
echo '<?php phpinfo();' | sudo tee /var/www/app-legacy/info.php
echo '<?php phpinfo();' | sudo tee /var/www/app-new/info.php

Accédez à http://app-legacy.example.com/info.php et http://app-new.example.com/info.php — la version PHP affichée doit correspondre à celle configurée dans chaque VirtualHost.

Vous pouvez aussi tester en ligne de commande via curl avec un script PHP simple :

# Vérifier la version PHP retournée par chaque site
curl -s http://app-legacy.example.com/info.php | grep -o 'PHP Version [0-9.]*' | head -1
# PHP Version 8.1.x

curl -s http://app-new.example.com/info.php | grep -o 'PHP Version [0-9.]*' | head -1
# PHP Version 8.4.x

Pensez à supprimer les fichiers info.php en production une fois les tests terminés — ils exposent des informations sensibles sur la configuration du serveur.

Gérer les pools PHP-FPM par version

Chaque version PHP-FPM dispose de son propre répertoire de configuration dans /etc/php/X.Y/fpm/pool.d/. Le pool par défaut s’appelle www.conf. Pour une optimisation fine des pools PHP-FPM, chaque version peut être paramétrée indépendamment avec ses propres limites de processus, timeouts et variables d’environnement.

# Configurer le nombre de workers pour php8.4-fpm
# /etc/php/8.4/fpm/pool.d/www.conf
[www]
pm = dynamic
pm.max_children = 20
pm.start_servers = 5
pm.min_spare_servers = 3
pm.max_spare_servers = 10
pm.max_requests = 500

# Recharger un démon FPM spécifique sans toucher aux autres
sudo systemctl reload php8.4-fpm

À lire également

• Plusieurs versions PHP-FPM sur Apache Debian/Ubuntu — la configuration détaillée côté Apache avec mod_proxy_fcgi et la gestion des extensions par version.
• Sécurisation avancée PHP-FPM — Multi-VirtualHosts Apache/Nginx — isoler chaque pool dans son propre utilisateur système pour limiter les risques de compromission croisée.
• Optimisation PHP-FPM — Guide de tuning d’un pool — pm.max_children, pm.max_requests, slow log : régler finement les performances de chaque pool.
• APT : Guide complet de la gestion des paquets sous Debian et Ubuntu — comprendre les priorités de dépôts (pinning) pour contrôler quelle source fournit quel paquet.

Références

• DEB.SURY.ORG — site officiel des dépôts Sury, informations sur les versions disponibles et le support.
• AdditionalPHPVersions — Wiki Debian — documentation officielle Debian sur l’ajout de versions PHP supplémentaires via extrepo.
• PPA PHP — Ondřej Surý (Launchpad) — dépôt Ubuntu officiel avec historique des versions et notes de publication.
• Versions PHP supportées — php.net — calendrier des versions actives, en sécurité uniquement et EOL.
• Suivi de bugs Sury — Codeberg — signalement des problèmes liés aux paquets Sury.