Comment installer et utiliser Composer sur Ubuntu 20.04

Introduction

Composer est un outil populaire de gestion des dépendances pour PHP, créé principalement pour faciliter l’installation et les mises à jour des dépendances des projets. Il vérifiera de quels autres paquets un projet spécifique dépend et les installera pour vous en utilisant les versions appropriées selon les exigences du projet. Composer est également couramment utilisé pour lancer de nouveaux projets basés sur des cadres PHP populaires tels que Symfony et Laravel.

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

Conditions préalables

Pour pouvoir suivre ce guide, vous devez avoir accès à un serveur Ubuntu 20.04 en tant que non-root sudo user, et un pare-feu activé sur votre serveur. Pour configurer cela, vous pouvez notre guide de configuration initiale du serveur pour Ubuntu 20.04.

Étape 1 - Installer PHP et des dépendances supplémentaires

En plus des dépendances qui devraient déjà être incluses dans votre système Ubuntu 20.04, telles quegit et curl, Composer nécessite php-cli pour exécuter les scripts PHP en ligne de commande, et unzip pour extraire les archives zippées.   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 paquets requis :

sudo apt install php-cli unzip

Vous serez invité à confirmer l’installation en tapant Y et ensuite ENTER.

Une fois les prérequis installés, vous pouvez procéder à 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 que vous êtes dans votre répertoire d’origine, puis récupérez l’installateur en utilisant curl :

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

Ensuite, nous allons vérifier que l’installateur téléchargé correspond au hachage SHA-384 pour le dernier installateur trouvé 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 par programmation le dernier hachage de 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

Output
e0012edf3e80b6978849f5eff0d4b4e4c79ff1609dd1e613307e16318854d24ae64f26d17af3ef0bf7cfb710ca74755a

Exécutez maintenant le code PHP suivant tel que fourni dans la page de téléchargement de Composer pour vérifier que le script d’installation peut être exécuté en toute sécurité :

php -r "if (hash_file('SHA384', '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 la sortie indique que l'installateur est 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. Lorsque vous avez un installateur vérifié, vous pouvez continuer.

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

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

Vous verrez une sortie semblable à celle-ci :

Output
All settings correct for using Composer
Downloading...

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

Pour tester votre installation, exécutez :

composer

Output
   ______
  / ____/___  ____ ___  ____  ____  ________  _____
 / /   / __ \/ __ `__ \/ __ \/ __ \/ ___/ _ \/ ___/
/ /___/ /_/ / / / / / / /_/ / /_/ (__  )  __/ /
\____/\____/_/ /_/ /_/ .___/\____/____/\___/_/
                    /_/
Composer version 1.10.5 2020-04-10 11:44:22

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
...

Cela permet de vérifier que Composer a été installé avec succès sur votre système et qu’il est disponible dans tout le 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 la gestion de ces dépendances et de leurs versions peut être délicate. Composer résout ce problème en gardant la trace des versions et des 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 au compositeur quelles dépendances il doit télécharger pour votre projet, et quelles versions de chaque paquet peuvent être installées. Ceci est extrêmement important pour maintenir la cohérence de votre projet et éviter d’installer des versions instables qui pourraient potentiellement causer des problèmes de rétrocompatibilité.

Vous n’avez pas besoin de créer ce fichier manuellement - il est fréquent de rencontrer des erreurs de syntaxe lorsque vous le faites. Composer offre un moyen interactif de créer un nouveau fichier composer.json basé sur la contribution 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 aussi automatiquement un fichier barebones composer.json lorsque vous lancez une commande composer require pour inclure une dépendance dans un projet nouvellement créé.

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

• Identifiez le type de bibliothèque dont la demande 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 installez le paquet.

Essayons cela avec une application de démonstration.

L’objectif de cette application est de transformer une phrase donnée en une chaîne facile à utiliser pour les URL - a slug. Cette méthode est couramment utilisée pour convertir les titres des pages en chemins d’accès URL (comme la dernière partie 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 lancer une commande composer init pour créer un fichier composer.json détaillé pour votre projet. Comme le seul objectif de notre projet est de démontrer comment installer des dépendances avec Composer, nous utiliserons un fichier composer.json plus simple qui sera généré automatiquement lorsque nous aurons besoin de notre premier paquet.

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 à celui-ci :

Vous verrez deux numéros sur le côté droit de chaque paquet dans la liste. Le chiffre du haut représente le nombre de fois que le paquet a été installé via Composer, et le chiffre du bas indique le nombre de fois qu’un paquet a été mis en vedette sur GitHub. D’une manière générale, les paquets comportant 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 pertinence de la description du paquet pour s’assurer qu’il correspond à vos besoins.

Nous avons besoin d’un convertisseur de chaîne de caractères en slug. D’après les résultats de la recherche, le paquet cocur/slugify qui apparaît comme premier résultat dans cette page semble être une bonne correspondance avec un nombre raisonnable d’installations et d’étoiles.

Les paquets sur Packagist ont un nom de vendeur et un nom de paquet. Chaque paquet possède un identifiant unique (un espace de noms) dans le même format que celui utilisé par GitHub pour ses dépôts : vendor/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 paquet afin de l’exiger dans votre projet.

Maintenant que vous savez exactement quel paquet vous voulez installer, vous pouvez lancer composer require pour l’inclure comme dépendance et aussi générer le fichier composer.json pour votre projet. Une chose qu’il est important de noter quand on demande des paquets, c’est que Composer suit à la fois les dépendances au niveau de l’application et celles au niveau du système. Les dépendances au niveau du système sont importantes pour indiquer sur quels modules PHP un paquet repose. Dans le cas de lacocur/slugify, il nécessite un module PHP que nous n’avons pas encore installé.

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

composer require cocur/slugify

Output
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 la recherche apt :

apt search mbstring

Output
Sorting... Done
Full Text Search... Done
php-mbstring/focal 2:7.4+75 all
  MBSTRING module for PHP [default]

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

php7.4-mbstring/focal 7.4.3-4ubuntu1 amd64
  MBSTRING module for PHP

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

sudo apt install php-mbstring

Une fois l’installation terminée, vous pouvez relancer la commande composer require :

composer require cocur/slugify

Output
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 sur la sortie, Composer a automatiquement décidé de la 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

Output
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 paquet qui sont installées, et s’assurer que les mêmes versions sont utilisées si quelqu’un d’autre clone votre projet et installe ses dépendances. Le répertoire vendor est l’endroit où se trouvent les dépendances du projet. Le dossier vendor ne doit pas être intégré dans le contrôle de version - vous devez seulement inclure les fichiers composer.json et composer.lock.

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

cat composer.json

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

Vous remarquerez peut-être le caractère spécial ^ avant le numéro de version dans composer.json. Composer accepte plusieurs contraintes et formats différents pour définir la version de paquet requise afin d’offrir une certaine souplesse 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, après le versionnage sémantique. Dans ce cas, elle définit 4.0 comme version minimale compatible, et permet les mises à jour de toute version future inférieure à** 5.**0.

D’une manière générale, vous n’aurez pas besoin de modifier les contraintes de version dans votre fichier composer.json. Toutefois, certaines situations peuvent vous obliger à modifier manuellement les contraintes, par exemple lorsqu’une nouvelle version importante de votre bibliothèque requise est publiée et que vous souhaitez la mettre à niveau, ou lorsque la bibliothèque que vous souhaitez utiliser ne suit pas la sémantique des versions.

Voici quelques exemples pour vous donner une meilleure compréhension du fonctionnement des contraintes de version de Composer :

Pour une vue plus approfondie des contraintes des versions de Composer, voir la documentation officielle.

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

Étape 4 - Inclure le script d’autochargement

Comme PHP lui-même ne charge pas automatiquement les classes, Composer fournit un script d’autochargement que vous pouvez inclure dans votre projet afin que l’autochargement fonctionne pour votre projet. Ce fichier est automatiquement généré 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 apporte le fichier vendor/autoload.php, lance 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.

Maintenant, lancez le script :

php test.php

Cela produit le résultat "hello-world-this-is-a-long-sentence-and--i-need-to-make-a-slug-from-it.

Les dépendances ont besoin de mises à jour lorsque de nouvelles versions sortent, alors regardons comment gérer cela.

Étape 5 - Mettre à jour les dépendances des projets

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

composer update

Cela permettra de vérifier s’il existe des versions plus récentes des bibliothèques dont vous avez eu besoin 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 comme ceci :

composer update vendor/package vendor2/package2

N’oubliez pas 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.

Conclusion

Composer est un outil puissant qui peut grandement faciliter le travail de gestion des dépendances dans les projets PHP. Il fournit un moyen fiable de découvrir, d’installer et de mettre à jour les paquets PHP dont dépend un projet. 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.