SkyMinds.Net

Voici comment installer Composer, le gestionnaire de dépendances PHP, sur Ubuntu Server.

Composer simplifie énormément la gestion des bibliothèques PHP. Au lieu de télécharger manuellement des paquets, de gérer leurs dépendances, puis de vérifier leurs versions une par une, on décrit les besoins du projet dans un fichier composer.json, et Composer s’occupe du reste.

Je l’utilise notamment pour auditer des sites hébergés sur un serveur, tester la compatibilité avec une version récente de PHP, installer des outils de développement, ou gérer les dépendances d’un plugin WordPress. On peut évidemment tout rapatrier en local, mais parfois, tester directement sur le serveur évite un aller-retour de fichiers parfaitement inutile.

Composer peut s’installer localement dans un projet, ou globalement comme commande système. La documentation officielle présente ces deux approches : installation locale dans un projet, ou installation globale comme exécutable disponible partout.

Installer les paquets prérequis

On commence par mettre à jour la liste des paquets :

sudo apt update

Ensuite, on installe les dépendances utiles :

sudo apt install curl unzip php-cli php-mbstring php-xml php-curl

Le paquet php-cli permet d’exécuter PHP en ligne de commande. curl sert à télécharger l’installeur. unzip permet d’extraire certaines archives de paquets. Enfin, php-mbstring, php-xml et php-curl évitent pas mal d’avertissements selon les dépendances installées.

On peut vérifier la version de PHP disponible en CLI :

php -v

Et vérifier les extensions chargées :

php -m

Télécharger l’installeur de Composer

On télécharge l’installeur officiel depuis le site de Composer :

php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"Langage du code : JavaScript (javascript)

On peut aussi utiliser curl :

curl -sS https://getcomposer.org/installer -o composer-setup.phpLangage du code : JavaScript (javascript)

Les deux méthodes fonctionnent. Si votre installation PHP a un problème de certificats SSL, curl peut parfois donner une erreur plus lisible. Charmant, mais utile.

Vérifier la signature de l’installeur

Avant d’exécuter l’installeur, il faut vérifier sa signature SHA-384. Le hash change régulièrement, donc récupérez toujours la valeur actuelle depuis la page officielle de téléchargement de Composer. La page officielle affiche les commandes de téléchargement, de vérification, d’exécution et de suppression de l’installeur.

Voici la méthode automatisée :

EXPECTED_SIGNATURE="$(curl -s https://composer.github.io/installer.sig)"
ACTUAL_SIGNATURE="$(php -r "echo hash_file('sha384', 'composer-setup.php');")"

if [ "$EXPECTED_SIGNATURE" != "$ACTUAL_SIGNATURE" ]; then
    echo "Installer corrupt"
    rm composer-setup.php
    exit 1
fi

echo "Installer verified"Langage du code : PHP (php)

Si la commande affiche Installer verified, on peut continuer. Si elle affiche Installer corrupt, on supprime le fichier et on recommence. Pas de bravoure inutile ici.

Installer Composer globalement

Pour installer Composer comme commande disponible partout sur le serveur, on l’installe dans /usr/local/bin :

sudo php composer-setup.php --install-dir=/usr/local/bin --filename=composerLangage du code : JavaScript (javascript)

Composer sera alors accessible avec la commande :

composer

On peut vérifier l’installation avec :

composer --version

Enfin, on supprime l’installeur :

rm composer-setup.phpLangage du code : CSS (css)

La documentation officielle indique que l’installeur télécharge le dernier composer.phar, et que l’installation globale permet d’utiliser Composer comme exécutable système.

Installation complète en une seule séquence

Voici la séquence complète, pratique à garder sous le coude :

sudo apt update
sudo apt install curl unzip php-cli php-mbstring php-xml php-curl

curl -sS https://getcomposer.org/installer -o composer-setup.php

EXPECTED_SIGNATURE="$(curl -s https://composer.github.io/installer.sig)"
ACTUAL_SIGNATURE="$(php -r "echo hash_file('sha384', 'composer-setup.php');")"

if [ "$EXPECTED_SIGNATURE" != "$ACTUAL_SIGNATURE" ]; then
    echo "Installer corrupt"
    rm composer-setup.php
    exit 1
fi

echo "Installer verified"

sudo php composer-setup.php --install-dir=/usr/local/bin --filename=composer
rm composer-setup.php

composer --versionLangage du code : PHP (php)

Cette version évite de copier-coller manuellement une signature qui peut devenir obsolète.

Installer Composer localement dans un projet

Il n’est pas obligatoire d’installer Composer globalement. On peut aussi l’installer dans un projet sous forme de fichier composer.phar.

Depuis le dossier du projet :

php composer-setup.phpLangage du code : CSS (css)

Composer crée alors un fichier :

composer.pharLangage du code : CSS (css)

On l’utilise ensuite ainsi :

php composer.phar installLangage du code : CSS (css)

Cette approche peut être utile sur un hébergement où vous n’avez pas les droits sudo, ou quand vous voulez figer Composer dans un environnement précis.

Composer installé via APT ou via l’installeur officiel ?

Ubuntu propose parfois un paquet composer dans ses dépôts :

sudo apt install composer

C’est simple, mais la version peut être plus ancienne que celle proposée par le projet Composer. Pour un serveur de développement ou un serveur qui doit tester des projets récents, je préfère l’installation officielle via l’installeur Composer.

Autre différence importante : si Composer a été installé via un gestionnaire de paquets système, la commande self-update peut ne pas être disponible. La documentation Composer précise que self-update n’est pas disponible si Composer n’a pas été installé comme PHAR, ce qui peut arriver avec une installation par gestionnaire de paquets.

Mettre à jour Composer

Pour mettre à jour Composer lui-même, il ne faut pas utiliser :

composer update

Cette commande met à jour les dépendances du projet courant. Elle lit le fichier composer.json, tient compte de composer.lock, puis met à jour les paquets du projet. Ce n’est pas la commande qui met à jour l’exécutable Composer.

Pour mettre à jour Composer lui-même, utilisez :

sudo -H composer self-updateLangage du code : PHP (php)

La documentation officielle indique que self-update remplace le fichier composer.phar par la dernière version disponible. Elle précise aussi qu’une installation globale peut nécessiter les droits root.

Pour revenir à la version précédente si quelque chose se passe mal :

sudo -H composer self-update --rollbackLangage du code : PHP (php)

Et pour forcer le canal stable :

sudo -H composer self-update --stableLangage du code : PHP (php)

Installer les dépendances d’un projet

Une fois Composer installé, on se place dans le dossier du projet, là où se trouve le fichier composer.json :

cd /home/www/example.com/public_html

Pour installer les dépendances exactes définies par composer.lock :

composer install

Pour mettre à jour les dépendances selon les contraintes du fichier composer.json :

composer update

La distinction est importante :

• composer install installe ce qui est verrouillé dans composer.lock ;
• composer update recalcule les versions et modifie composer.lock ;
• composer self-update met à jour Composer lui-même.

En production, on utilise généralement composer install, pas composer update. Sinon, on change les versions des dépendances directement sur le serveur. Sportif, mais pas idéal.

Commandes utiles sur un serveur

Voici quelques commandes que j’utilise souvent après l’installation de Composer.

Vérifier la configuration :

composer diagnose

Afficher la version :

composer --version

Afficher la configuration globale :

composer config --global --listLangage du code : PHP (php)

Valider un fichier composer.json :

composer validate

Lister les paquets installés :

composer show

Voir pourquoi un paquet est installé :

composer why vendor/package

Voir pourquoi une version de PHP bloque une dépendance :

composer why-not php 8.3Langage du code : CSS (css)

Cette dernière commande est très pratique pour auditer la compatibilité d’un projet avec PHP 8.2, PHP 8.3 ou PHP 8.4.

Utiliser Composer pour tester la compatibilité PHP

Si l’objectif est de vérifier si un projet accepte une version donnée de PHP, Composer peut donner une première indication.

Depuis le dossier du projet :

composer check-platform-reqs

Cette commande vérifie les exigences de plateforme, comme la version de PHP et les extensions nécessaires.

On peut aussi simuler une version de PHP dans la configuration Composer du projet :

composer config platform.php 8.3.0Langage du code : CSS (css)

Puis demander pourquoi certaines dépendances bloquent :

composer update --dry-run
composer why-not php 8.3Langage du code : CSS (css)

Le --dry-run permet de tester sans écrire les changements. Toujours appréciable quand on préfère éviter les surprises en production. Étonnant, je sais.

Composer et WordPress

Dans l’écosystème WordPress, Composer sert souvent à gérer des dépendances dans un plugin, un thème, un mu-plugin, ou un projet complet basé sur Bedrock.

Pour un plugin WordPress, on peut par exemple installer une bibliothèque PHP :

composer require vendor/packageLangage du code : JavaScript (javascript)

Puis charger l’autoloader dans le plugin :

<?php
/**
 * Plugin Name: Example Composer Plugin
 */

defined( 'ABSPATH' ) || exit;

$autoload = __DIR__ . '/vendor/autoload.php';

if ( is_readable( $autoload ) ) {
    require_once $autoload;
}Langage du code : HTML, XML (xml)

Dans un plugin distribué publiquement, pensez à inclure le dossier vendor dans le zip final, sauf si votre processus de déploiement installe les dépendances automatiquement. WordPress.org n’exécute pas Composer pour les utilisateurs.

Éviter d’exécuter Composer en root dans les projets

Installer Composer globalement avec sudo est normal, car on écrit dans /usr/local/bin. En revanche, exécuter composer install ou composer update en root dans un projet est rarement une bonne idée.

Dans un site web, utilisez plutôt l’utilisateur propriétaire des fichiers du site. Par exemple :

sudo -u www-data composer install --no-dev --optimize-autoloader

Ou, selon votre organisation serveur :

sudo -u deploy composer install --no-dev --optimize-autoloader

Cela évite de créer des fichiers appartenant à root dans le projet. Sinon, le prochain déploiement ou la prochaine mise à jour risque de râler. Et il aura raison.

Installation optimisée pour production

Sur un serveur de production, on installe généralement les dépendances sans les outils de développement :

composer install --no-dev --prefer-dist --optimize-autoloader

Pour des projets plus sensibles aux performances, on peut ajouter l’autoloader classmap autoritaire :

composer install --no-dev --prefer-dist --optimize-autoloader --classmap-authoritative

Cette option peut améliorer les performances d’autoloading, mais elle suppose que toutes les classes soient correctement déclarées dans l’autoload Composer. À utiliser quand le projet est propre.

Résoudre les erreurs fréquentes

Si Composer se plaint d’une extension manquante, installez le paquet PHP correspondant. Par exemple :

sudo apt install php-zip php-intl php-gd php-mysql php-bcmath

Puis vérifiez que l’extension est bien chargée :

php -m | grep zip

Si Composer échoue à cause de certificats SSL, vérifiez les certificats racines :

sudo apt install ca-certificates
sudo update-ca-certificates

Si la mémoire manque pendant une opération lourde :

COMPOSER_MEMORY_LIMIT=-1 composer install

Ce n’est pas une solution élégante à utiliser partout, mais cela dépanne lors d’un audit ou d’une migration ponctuelle.

Désinstaller Composer

Si Composer a été installé globalement dans /usr/local/bin, la désinstallation est simple :

sudo rm /usr/local/bin/composer

On peut vérifier qu’il n’est plus disponible :

which composer
composer --version

Si Composer a été installé via APT :

sudo apt remove composer

Mémo rapide

# Installer les prérequis.
sudo apt update
sudo apt install curl unzip php-cli php-mbstring php-xml php-curl

# Télécharger Composer.
curl -sS https://getcomposer.org/installer -o composer-setup.php

# Vérifier la signature.
EXPECTED_SIGNATURE="$(curl -s https://composer.github.io/installer.sig)"
ACTUAL_SIGNATURE="$(php -r "echo hash_file('sha384', 'composer-setup.php');")"

if [ "$EXPECTED_SIGNATURE" != "$ACTUAL_SIGNATURE" ]; then
    echo "Installer corrupt"
    rm composer-setup.php
    exit 1
fi

# Installer Composer globalement.
sudo php composer-setup.php --install-dir=/usr/local/bin --filename=composer

# Nettoyer.
rm composer-setup.php

# Vérifier.
composer --version

# Mettre à jour Composer lui-même.
sudo -H composer self-update

# Installer les dépendances d’un projet.
composer install

# Mettre à jour les dépendances d’un projet.
composer update

# Vérifier les exigences PHP/extensions.
composer check-platform-reqsLangage du code : PHP (php)

Conclusion

Installer Composer sur Ubuntu Server est simple, mais autant le faire proprement : installer les prérequis, télécharger l’installeur officiel, vérifier sa signature SHA-384, puis installer l’exécutable dans /usr/local/bin.

Une fois installé, Composer devient vite indispensable pour gérer les dépendances PHP, auditer un projet, tester une compatibilité avec PHP 8.x, ou préparer un déploiement plus propre.

Gardez surtout la distinction en tête : composer install installe les dépendances verrouillées, composer update met à jour les dépendances du projet, et composer self-update met à jour Composer lui-même. Trois commandes proches, trois effets très différents. Le genre de détail qui évite une journée délicieusement absurde.