Comment installer et utiliser Composer sur Ubuntu

Introduction

Composer est un outil de gestion des dépendances populaire pour PHP, créé principalement pour faciliter l'installation et la mise à jour des dépendances des projets. Il vérifie sur quels autres packages un projet spécifique dépend et les installe pour vous, en utilisant les versions appropriées selon les exigences du projet. Composer est également couramment utilisé pour démarrer de nouveaux projets basés sur des frameworks PHP populaires, tels que Symfony et Laravel. Si vous prévoyez de travailler avec Laravel, vous pourriez également vouloir consulter notre guide sur Comment installer et configurer Laravel avec Docker Compose sur Ubuntu 20.04.

Dans ce tutoriel, vous allez installer et commencer à utiliser Composer sur un système Ubuntu.

Points clés

• Composer automatise la gestion des dépendances PHP en prenant en charge l'installation des bibliothèques, le contrôle des versions et les mises à jour, éliminant ainsi les tâches de gestion de paquets manuelles.
• L'installation globale offre un accès aux commandes de Composer depuis n'importe quel répertoire, tandis que l'installation locale permet un contrôle spécifique au projet et l'isolation des versions.
• La vérification du hachage est essentielle pour la sécurité lors du téléchargement de l'installateur de Composer, afin de se protéger contre les scripts d'installation altérés ou corrompus.
• Le fichier composer.lock assure la cohérence en verrouillant les versions exactes des dépendances dans les environnements de développement, de préproduction et de production.
• Composer est la norme pour le développement PHP moderne, avec une intégration transparente dans des frameworks comme Laravel et Symfony, et le soutien de plus de 400 000 packages sur Packagist.

Prérequis

Pour suivre ce guide, vous aurez besoin d'accéder à un serveur Ubuntu (20.04 LTS, 22.04 LTS ou 24.04 LTS) en tant qu'utilisateur non-root avec les privilèges sudo, et d'avoir un pare-feu activé sur votre serveur. Pour configurer cela, vous pouvez suivre notre guide de configuration initiale du serveur pour Ubuntu ou le guide correspondant à votre version d'Ubuntu.

Si vous cherchez une référence rapide, consultez notre guide de démarrage rapide « Comment installer Composer sur Ubuntu ». Pour d'autres tutoriels et ressources sur Composer, consultez notre collection de tutoriels sur Composer.

Étape 1 — Installation de PHP et des dépendances supplémentaires

En plus des dépendances qui devraient déjà être incluses dans votre système Ubuntu, comme git et curl, Composer nécessite php-cli afin d’exécuter des scripts PHP en ligne de commande, et unzip pour extraire les archives compressées. Le paquet php-cli installera la version par défaut de PHP pour votre version d’Ubuntu (PHP 7.4 sur Ubuntu 20.04, PHP 8.1 sur Ubuntu 22.04 ou PHP 8.3 sur Ubuntu 24.04). Si vous devez configurer votre serveur Ubuntu d’abord, consultez notre guide de configuration initiale pour Ubuntu. Nous allons maintenant installer ces dépendances.

Tout d'abord, mettez à jour le cache du gestionnaire de paquets en exécutant :

sudo apt update

Ensuite, exécutez la commande suivante pour installer les packages requis :

sudo apt install php-cli unzip

Vous serez invité à confirmer l'installation en tapant Y puis ENTRÉE.

Une fois les prérequis installés, vous pouvez passer à l'installation de Composer.

Étape 2 — Téléchargement et installation de Composer

Composer fournit un script d'installation écrit en PHP. Nous allons le télécharger, vérifier qu'il n'est pas corrompu, puis l'utiliser pour installer Composer.

Assurez-vous d'être dans votre répertoire personnel, puis récupérez l'installateur en utilisant curl :

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

Ensuite, nous vérifierons que l'installateur téléchargé correspond au hachage SHA-384 de la dernière version de l'installateur trouvée sur la page des clés publiques/signatures de Composer. Pour faciliter l'étape de vérification, vous pouvez utiliser la commande suivante pour obtenir automatiquement le dernier hachage depuis la page de Composer et le stocker dans une variable shell :

HASH=`curl -sS https://composer.github.io/installer.sig`

Si vous voulez vérifier la valeur obtenue, vous pouvez exécuter :

echo $HASH

e0012edf3e80b6978849f5eff0d4b4e4c79ff1609dd1e613307e16318854d24ae64f26d17af3ef0bf7cfb710ca74755a

Exécutez maintenant le code PHP suivant, tel que fourni sur la page de téléchargement de Composer, pour vérifier que le script d'installation est sûr à exécuter :

php -r "if (hash_file('SHA384', '/tmp/composer-setup.php') === '$HASH') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"

Vous verrez la sortie suivante :

Installer verified

Si le message de sortie indique Installateur corrompu, vous devrez télécharger à nouveau le script d'installation et vérifier que vous utilisez le bon hachage. Ensuite, répétez le processus de vérification. Une fois que vous avez un installateur vérifié, vous pouvez continuer.

Pour installer composer globalement, utilisez la commande suivante qui téléchargera et installera Composer en tant que commande système nommée composer, sous /usr/local/bin :

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

Vous verrez une sortie similaire à ceci :

All settings correct for using Composer
Downloading...

Composer (version 2.2.9) successfully installed to: /usr/local/bin/composer
Use it: php /usr/local/bin/composer

Pour tester votre installation, exécutez :

composer

   ______
  / ____/___  ____ ___  ____  ____  ________  _____
 / /   / __ \/ __ `__ \/ __ \/ __ \/ ___/ _ \/ ___/
/ /___/ /_/ / / / / / / /_/ / /_/ (__  )  __/ /
\____/\____/_/ /_/ /_/ .___/\____/____/\___/_/
                    /_/
Composer version Composer version 2.2.9 2022-03-15 22:13:37
Usage:
  command [options] [arguments]

Options:
  -h, --help                     Display this help message
  -q, --quiet                    Do not output any message
  -V, --version                  Display this application version
      --ansi                     Force ANSI output
      --no-ansi                  Disable ANSI output
  -n, --no-interaction           Do not ask any interactive question
      --profile                  Display timing and memory usage information
      --no-plugins               Whether to disable plugins.
  -d, --working-dir=WORKING-DIR  If specified, use the given directory as working directory.
      --no-cache                 Prevent use of the cache
  -v|vv|vvv, --verbose           Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug
...

Ceci vérifie que Composer a été installé avec succès sur votre système et est disponible à l'échelle du système.

Voyons maintenant comment utiliser Composer pour gérer les dépendances.

Étape 3 — Utilisation de Composer dans un projet PHP

Les projets PHP dépendent souvent de bibliothèques externes, et gérer ces dépendances ainsi que leurs versions peut être complexe. Composer résout ce problème en suivant les versions et les dépendances du projet, tout en facilitant le processus de recherche, d'installation et de mise à jour des paquets requis par un projet.

Pour utiliser Composer dans votre projet, vous aurez besoin d’un fichier composer.json. Le fichier composer.json indique à Composer quelles dépendances il doit télécharger pour votre projet et quelles versions de chaque paquet sont autorisées à être installées. Cela est extrêmement important pour maintenir la cohérence de votre projet et éviter l’installation de versions instables qui pourraient potentiellement entraîner des problèmes de compatibilité ascendante.

Vous n’avez pas besoin de créer ce fichier manuellement - il est courant de rencontrer des erreurs de syntaxe lorsque vous le faites. Composer propose un moyen interactif de créer un nouveau fichier composer.json basé sur les entrées de l’utilisateur, ce qui est un bon choix si vous prévoyez de partager votre projet plus tard en tant que paquet public sur Packagist. Composer génère également automatiquement un fichier composer.json minimal lorsque vous exécutez une commande composer require pour inclure une dépendance dans un projet nouvellement créé.

Le processus d'utilisation de Composer pour installer un package en tant que dépendance dans un projet implique les étapes suivantes :

• Identifiez le type de bibliothèque dont l’application a besoin.
• Recherchez une bibliothèque open source appropriée sur Packagist.org, le dépôt officiel de paquets pour Composer.
• Choisissez le paquet dont vous voulez dépendre.
• Exécutez composer require pour inclure la dépendance dans le fichier composer.json et installer le paquet.

Essayons cela avec une application de démonstration.

Le but de cette application est de transformer une phrase donnée en une chaîne adaptée aux URL - un slug. Cela est couramment utilisé pour convertir les titres de pages en chemins d'URL (comme la partie finale de l'URL pour ce tutoriel).

Commençons par créer un répertoire pour notre projet. Nous l’appellerons slugify :

cd ~
mkdir slugify
cd slugify

Bien que ce ne soit pas obligatoire, vous pouvez maintenant exécuter la commande composer init pour créer un fichier composer.json détaillé pour votre projet. Comme l’objectif de notre projet est uniquement de montrer comment installer des dépendances avec Composer, nous utiliserons un fichier composer.json plus simple qui sera généré automatiquement lorsque nous requerrons notre premier package.

Il est maintenant temps de rechercher sur Packagist.org un paquet qui peut nous aider à générer des slugs. Si vous recherchez le terme « slug » sur Packagist, vous obtiendrez un résultat similaire à ceci :

Vous verrez deux chiffres du côté droit de chaque paquet dans la liste. Le chiffre en haut représente le nombre de fois que le paquet a été installé via Composer, et le chiffre en bas montre combien de fois un paquet a été étoilé sur GitHub. En général, les paquets avec plus d’installations et plus d’étoiles ont tendance à être plus stables, puisque beaucoup de gens les utilisent. Il est également important de vérifier la description du paquet pour s’assurer qu’il correspond à ce dont vous avez besoin.

Nous avons besoin d'un convertisseur string-to-slug. D'après les résultats de recherche, le paquet cocur/slugify, qui apparaît comme premier résultat sur cette page, semble être un bon choix, avec un nombre raisonnable d'installations et d'étoiles.

Les packages sur Packagist ont un nom de fournisseur et un nom de package. Chaque package possède un identifiant unique (un espace de noms) au même format que GitHub utilise pour ses dépôts : fournisseur/package. La bibliothèque que nous voulons installer utilise l’espace de noms cocur/slugify. Vous avez besoin de l’espace de noms d’un package pour pouvoir l’inclure dans votre projet.

Maintenant que vous savez exactement quel package vous souhaitez installer, vous pouvez exécuter composer require pour l’inclure en tant que dépendance et également générer le fichier composer.json pour votre projet. Une chose importante à noter lors de la requête de packages est que Composer suit à la fois les dépendances au niveau de l’application et au niveau du système. Les dépendances au niveau du système sont importantes pour indiquer quels modules PHP un package utilise. Dans le cas du package cocur/slugify, il nécessite un module PHP que nous n’avons pas encore installé.

Lorsqu'un paquet requis dépend d'une bibliothèque système qui n'est actuellement pas installée sur votre serveur, vous recevrez une erreur indiquant quelle exigence est manquante :

composer require cocur/slugify

Using version ^4.0 for cocur/slugify
./composer.json has been updated
Loading composer repositories with package information
Updating dependencies (including require-dev)
Your requirements could not be resolved to an installable set of packages.

  Problem 1
    - Installation request for cocur/slugify ^4.0 -> satisfiable by cocur/slugify[v4.0.0].
    - cocur/slugify v4.0.0 requires ext-mbstring * -> the requested PHP extension mbstring is missing from your system.
...

Pour résoudre le problème de dépendance du système, nous pouvons rechercher le paquet manquant en utilisant apt search :

apt search mbstring

Sorting... Done
Full Text Search... Done
php-mbstring/jammy 2:8.1+92ubuntu1 all
  MBSTRING module for PHP [default]

php-patchwork-utf8/jammy 1.3.1-1 all
  UTF-8 strings handling for PHP

php8.1-mbstring/jammy 8.1.2-1ubuntu2.14 amd64
  MBSTRING module for PHP

Après avoir trouvé le nom correct du paquet, vous pouvez utiliser apt à nouveau pour installer la dépendance système :

sudo apt install php-mbstring

Une fois l'installation terminée, vous pouvez exécuter à nouveau la commande composer require :

composer require cocur/slugify

Using version ^4.0 for cocur/slugify
./composer.json has been created
Loading composer repositories with package information
Updating dependencies (including require-dev)
Package operations: 1 install, 0 updates, 0 removals
  - Installing cocur/slugify (v4.0.0): Downloading (100%)         
Writing lock file
Generating autoload files

Comme vous pouvez le voir à partir du résultat, Composer a automatiquement décidé quelle version du paquet utiliser. Si vous vérifiez maintenant le répertoire de votre projet, il contiendra deux nouveaux fichiers : composer.json et composer.lock, ainsi qu’un répertoire vendor :

ls -l

total 12
-rw-rw-r-- 1 sammy sammy   59 May  4 13:56 composer.json
-rw-rw-r-- 1 sammy sammy 3229 May  4 13:56 composer.lock
drwxrwxr-x 4 sammy sammy 4096 May  4 13:56 vendor

Le fichier composer.lock est utilisé pour stocker des informations sur les versions de chaque package installées, et pour garantir que les mêmes versions sont utilisées si quelqu’un d’autre clone votre projet et installe ses dépendances. Ce fichier verrouille les versions exactes de toutes les dépendances et de leurs sous-dépendances, assurant ainsi la cohérence entre différents environnements et membres de l’équipe. Le répertoire vendor est l’endroit où se trouvent les dépendances du projet. Le dossier vendor ne devrait pas être inclus dans le contrôle de version - vous n’avez besoin d’inclure que les fichiers composer.json et composer.lock. Lorsque d’autres clonent votre projet, ils peuvent exécuter composer install pour recréer l’arborescence exacte des dépendances basée sur le fichier lock.

Jetons un coup d'œil rapide aux contraintes de version. Si vous consultez le contenu de votre fichier composer.json, vous verrez quelque chose comme ceci :

cat composer.json

{
    "require": {
        "cocur/slugify": "^4.0"
    }
}

Vous pourriez remarquer le caractère spécial ^ avant le numéro de version dans composer.json. Composer prend en charge plusieurs contraintes et formats différents pour définir la version requise d’un paquet, afin de fournir de la flexibilité tout en maintenant la stabilité de votre projet. L’opérateur caret (^) utilisé par le fichier composer.json généré automatiquement est l’opérateur recommandé pour une interopérabilité maximale, conformément au versionnage sémantique. Dans ce cas, il définit 4.0 comme la version minimale compatible et permet les mises à jour vers toute version future inférieure à 5.0.

De manière générale, vous n’aurez pas besoin de modifier les contraintes de version dans votre fichier composer.json. Cependant, certaines situations peuvent nécessiter que vous éditiez manuellement ces contraintes, par exemple lorsqu’une nouvelle version majeure de la bibliothèque requise est publiée et que vous souhaitez la mettre à jour, ou lorsque la bibliothèque que vous voulez utiliser ne suit pas le versionnage sémantique.

Voici quelques exemples pour vous aider à mieux comprendre comment fonctionnent les contraintes de version de Composer :

Pour une vue plus approfondie des contraintes de version de Composer, consultez la documentation officielle.

Ensuite, voyons comment charger automatiquement les dépendances avec Composer.

Étape 4 — Inclusion du script d’autochargement

Comme PHP ne charge pas automatiquement les classes, Composer fournit un script d'autoload que vous pouvez inclure dans votre projet pour activer l'autoloading. Ce fichier est généré automatiquement par Composer lorsque vous ajoutez votre première dépendance.

La seule chose que vous devez faire est d'inclure le fichier vendor/autoload.php dans vos scripts PHP avant toute instanciation de classe.

Essayons-le dans notre application de démonstration. Ouvrez un nouveau fichier appelé test.php dans votre éditeur de texte :

nano test.php

Ajoutez le code suivant qui inclut le fichier vendor/autoload.php, charge la dépendance cocur/slugify et l’utilise pour créer un slug :

<?php
require __DIR__ . '/vendor/autoload.php';

use Cocur\Slugify\Slugify;

$slugify = new Slugify();

echo $slugify->slugify('Hello World, this is a long sentence and I need to make a slug from it!');

Enregistrez le fichier et quittez votre éditeur.

Exécutez maintenant le script :

php test.php

Cela produit la sortie hello-world-this-is-a-long-sentence-and-i-need-to-make-a-slug-from-it.

Les dépendances doivent être mises à jour lorsque de nouvelles versions sortent, alors voyons comment gérer cela.

Étape 5 — Mise à jour des dépendances du projet

Chaque fois que vous souhaitez mettre à jour les dépendances de votre projet vers des versions plus récentes, exécutez la commande update :

composer update

Cela vérifiera s'il existe des versions plus récentes des bibliothèques que vous avez requises dans votre projet. Si une version plus récente est trouvée et qu'elle est compatible avec la contrainte de version définie dans le fichier composer.json, Composer remplacera la version précédente installée. Le fichier composer.lock sera mis à jour pour refléter ces changements.

Vous pouvez également mettre à jour une ou plusieurs bibliothèques spécifiques en les spécifiant de cette façon :

composer update vendor/package vendor2/package2

Assurez-vous de vérifier vos fichiers composer.json et composer.lock dans votre système de contrôle de version après avoir mis à jour vos dépendances afin que d'autres puissent également installer ces nouvelles versions.

Questions fréquemment posées

1. À quoi sert Composer en PHP ?

Composer est un gestionnaire de dépendances pour PHP qui automatise le processus de recherche, d'installation et de mise à jour des bibliothèques et des paquets dont dépendent vos projets PHP. Au lieu de télécharger et de gérer manuellement les dépendances, Composer lit un fichier composer.json qui répertorie les besoins de votre projet et s'occupe de tout automatiquement. Cela garantit que vous obtenez les bonnes versions des paquets et de leurs dépendances, rendant le développement en PHP plus efficace et fiable.

2. Comment installer Composer globalement sur Ubuntu ?

Pour installer Composer globalement sur Ubuntu, téléchargez le script d'installation, vérifiez son intégrité à l'aide du hash SHA-384, puis exécutez l'installateur avec les options --install-dir et --filename pointant vers /usr/local/bin. Cela rend Composer disponible à l'échelle du système en tant que commande composer. Le processus d'installation est identique sur Ubuntu 20.04, 22.04 et 24.04. Les étapes détaillées sont couvertes à l'Étape 2 de ce tutoriel.

3. Comment puis-je vérifier si l'installateur de Composer est sécuritaire ?

Vous pouvez vérifier la sécurité de l'installateur de Composer en comparant son hash SHA-384 avec le hash officiel publié sur la page Clés publiques/Signatures de Composer. Utilisez la commande php -r "if (hash_file('SHA384', '/tmp/composer-setup.php') === '$HASH') { echo 'Installateur vérifié'; } else { echo 'Installateur corrompu'; }" où $HASH contient le dernier hash de la page officielle de Composer. Cette étape de vérification est cruciale pour la sécurité et est démontrée à l'étape 2.

4. Quelle est la différence entre une installation globale et locale de Composer ?

Une installation globale place Composer dans un répertoire système comme /usr/local/bin, le rendant accessible depuis n’importe quel répertoire de votre système. Cela est pratique pour gérer plusieurs projets. Une installation locale crée un fichier composer.phar dans un répertoire de projet spécifique, ce qui est utile lorsque vous n’avez pas les permissions d’installation système ou que vous souhaitez des versions de Composer spécifiques à un projet. Vous pouvez exécuter une installation locale avec php /tmp/composer-setup.php dans le répertoire de votre projet.

5. Comment puis-je mettre à jour Composer vers la dernière version ?

Pour mettre à jour Composer vers la dernière version, exécutez composer self-update. Cette commande télécharge et installe la version la plus récente de Composer, remplaçant votre installation actuelle. Pour les installations globales, il se peut que vous deviez utiliser sudo composer self-update selon vos permissions.

6. Pourquoi Composer donne-t-il des erreurs de limite de mémoire sur Ubuntu ?

Les erreurs de limite de mémoire se produisent généralement lorsque Composer tente de traiter de grands arbres de dépendances ou lorsque la limite de mémoire de votre PHP est trop faible. Vous pouvez résoudre ce problème en augmentant temporairement la limite de mémoire de PHP pour les commandes Composer en utilisant php -d memory_limit=512M /usr/local/bin/composer install ou en modifiant votre fichier php.ini pour augmenter le paramètre memory_limit. Pour la plupart des projets, 512 Mo ou 1 Go devraient suffire.

7. Comment désinstaller Composer sur Ubuntu ?

Pour désinstaller un Composer installé globalement, il suffit de supprimer le fichier exécutable : sudo rm /usr/local/bin/composer. Pour les installations locales, supprimez le fichier composer.phar de votre répertoire de projet. Notez que cela ne supprime pas le répertoire vendor ni les fichiers composer.json dans vos projets, que vous pouvez supprimer séparément si nécessaire.

8. Ai-je besoin de sudo pour exécuter Composer ?

Vous n'avez pas besoin de sudo pour exécuter les commandes Composer afin de gérer les dépendances du projet. Cependant, vous pourriez avoir besoin de sudo lors de l'installation ou de la mise à jour de Composer lui-même globalement, car cela nécessite d'écrire dans des répertoires système comme /usr/local/bin. Une fois installé, les opérations normales de Composer, comme composer install, composer require et composer update, fonctionnent sans privilèges élevés.

Conclusion

Composer est un outil puissant qui peut grandement faciliter la gestion des dépendances dans les projets PHP. Il offre un moyen fiable de découvrir, d’installer et de mettre à jour les paquets PHP dont un projet dépend. Dans ce guide, nous avons vu comment installer Composer, comment inclure de nouvelles dépendances dans un projet et comment mettre à jour ces dépendances lorsque de nouvelles versions sont disponibles.

Prochaines étapes

Maintenant que vous avez installé et configuré Composer sur votre système Ubuntu, vous pouvez commencer à créer des applications PHP avec des dépendances gérées. Voici quelques étapes suivantes recommandées :

• Déployer des applications PHP avec Composer : Apprenez comment déployer des projets basés sur Composer en utilisant la plateforme d'applications Linux-Console.net, qui détecte et installe automatiquement les dépendances Composer lors du déploiement.

• Configurer Laravel avec Docker : Si vous travaillez avec Laravel, consultez notre guide sur Comment Installer et Configurer Laravel avec Docker Compose sur Ubuntu pour conteneuriser votre environnement de développement.

• Apprenez Docker Compose : Pour gérer des applications à plusieurs conteneurs, consultez notre tutoriel sur Comment installer et utiliser Docker Compose sur Ubuntu.

• Découvrez le développement PHP : Parcourez notre collection de tutoriels PHP pour en savoir plus sur les meilleures pratiques de développement PHP, la configuration des frameworks et les stratégies de déploiement.

Prêt à déployer votre application PHP ? Commencez avec la plateforme App de Linux-Console.net et déployez vos projets basés sur Composer en quelques minutes grâce à la gestion automatique des dépendances et à la mise à l'échelle.

Ressources supplémentaires

• Référence rapide : Pour une version condensée de ce guide, consultez notre guide de démarrage rapide Comment installer Composer sur Ubuntu 20.04.
• Tutoriels Composer : Découvrez notre collection complète de tutoriels Composer pour des usages plus avancés et les meilleures pratiques.
• Intégration Docker : Apprenez à containeriser vos applications PHP grâce à notre guide sur Comment Installer et Utiliser Docker Compose sur Ubuntu 20.04 ou le guide correspondant pour votre version d'Ubuntu.
• Développement PHP : Parcourez notre vaste collection de tutoriels PHP couvrant les frameworks, les stratégies de déploiement et l’optimisation des performances.

Vous voulez héberger vos applications PHP ? Déployez-les avec la plateforme App de Linux-Console.net pour une mise à l'échelle automatique, des bases de données gérées et une intégration transparente de Composer, ou créez un Droplet pour un contrôle total du serveur.

Merci de apprendre avec la communauté Linux-Console.net.