Comment installer et utiliser Composer sur Debian 11

De Get Docs
Aller à :navigation, rechercher

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 du projet. Composer fonctionne en vérifiant de quels autres packages dépend un projet spécifique, puis les installe pour vous en utilisant les versions appropriées en fonction des 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.

Dans ce guide, vous allez installer et utiliser Composer sur un serveur Debian 11.

Conditions préalables

Pour suivre ce tutoriel, vous aurez besoin d'un serveur Debian 11 configuré, y compris une racine non-' sudo-utilisateur activé et pare-feu activé. Vous pouvez le faire en suivant notre Guide de configuration initiale du serveur Debian 11.

Étape 1 - Installation des dépendances

En plus des dépendances qui peuvent déjà être incluses dans votre système Debian 11, Composer nécessite php-cli pour exécuter des scripts PHP en ligne de commande, et unzip pour extraire les archives zippées.

Commencez par mettre à jour le cache du gestionnaire de packages :

sudo apt update

Ensuite, installez les dépendances. Tu auras besoin de curl pour télécharger Composer et php-cli pour l'installer et l'exécuter. La php-mbstring package est nécessaire pour fournir des fonctions à une bibliothèque que vous utiliserez dans ce didacticiel. git est utilisé par Composer pour télécharger les dépendances du projet, et unzip sert à extraire les packages compressés. Tout peut être installé avec la commande suivante :

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

Avec toutes les dépendances installées, vous pouvez maintenant installer Composer.

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

Composer fournit un installateur écrit en PHP. Vous allez le télécharger, vérifier qu'il n'est pas corrompu, puis l'utiliser pour installer Composer.

Tout d'abord, assurez-vous que vous êtes dans votre répertoire personnel :

cd ~

Ensuite, récupérez le programme d'installation à l'aide de curl:

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

Ensuite, vérifiez que le programme d'installation correspond au hachage SHA-384 du dernier programme d'installation trouvé sur la page Composer Public Keys / Signatures. Pour faciliter l'étape de vérification, vous pouvez utiliser la commande suivante pour obtenir par programme le dernier hachage de la page de composition et le stocker dans une variable shell :

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

Pour afficher la valeur obtenue, exécutez :

echo $HASH
Output55ce33d7678c5a611085589f1f3ddf8b3c52d662cd01d4ba75c0ee0459970c2200a51f492d557530c71c15d8dba01eae

Exécutez maintenant le code PHP suivant, tel qu'il est fourni sur la page de téléchargement de Composer [1], 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;"

Votre sortie sera la suivante :

OutputInstaller verified

Si vous recevez un message disant Installer corrupt, vous devez télécharger à nouveau le script d'installation et vérifier que vous utilisez le bon hachage. Exécutez ensuite la commande pour vérifier à nouveau le programme d'installation. Une fois que vous avez un programme d'installation vérifié, vous pouvez continuer.

À installer composer globalement, utilisez la commande suivante pour télécharger et installer Composer en tant que commande système nommée composer en dessous de /usr/local/bin:

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

Votre sortie sera la suivante :

OutputAll settings correct for using Composer
Downloading...

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

Testez votre installation en exécutant cette commande :

composer

Votre sortie affichera alors la version et les arguments de Composer, comme suit :

Output  ______
  / ____/___  ____ ___  ____  ____  ________  _____
 / /   / __ \/ __ `__ \/ __ \/ __ \/ ___/ _ \/ ___/
/ /___/ /_/ / / / / / / /_/ / /_/ (__  )  __/ /
\____/\____/_/ /_/ /_/ .___/\____/____/\___/_/
                    /_/
Composer version 2.3.10 2022-07-13 15:48:23

Usage:
  command [options] [arguments]

Options:
  -h, --help                     Display help for the given command. When no command is given display help for the list command
  -q, --quiet                    Do not output any message
  -V, --version                  Display this application version
      --ansi|--no-ansi           Force (or disable --no-ansi) ANSI output
  -n, --no-interaction           Do not ask any interactive question
      --profile                  Display timing and memory usage information
      --no-plugins               Whether to disable plugins.
      --no-scripts               Skips the execution of all scripts defined in composer.json file.
  -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 vérifie que Composer a été installé avec succès sur votre système et qu'il est disponible dans tout le système.

Remarque : Si vous préférez avoir des exécutables Composer distincts pour chaque projet que vous hébergez sur ce serveur, vous pouvez l'installer localement, projet par projet. Les utilisateurs de NPM seront familiarisés avec cette approche. Cette méthode est également utile lorsque l'utilisateur de votre système n'est pas autorisé à installer des logiciels à l'échelle du système.

Pour cela, utilisez la commande php composer-setup.php. Cela va générer une composer.phar fichier dans votre répertoire courant, qui peut être exécuté avec ./composer.phar command.


Maintenant que vous avez installé Composer, à l'étape suivante, vous apprendrez à utiliser Composer pour gérer les dépendances PHP.

É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 suivant vos dépendances et en les rendant plus accessibles aux autres pour les installer.

Pour utiliser Composer dans votre projet, vous aurez besoin d'un composer.json dossier. La composer.json Le fichier indique à Composer les dépendances qu'il doit télécharger pour votre projet et les versions de chaque package qui peuvent être installées. Ceci est extrêmement important pour garder votre projet cohérent 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, car cela est sujet aux erreurs et peut entraîner des erreurs de syntaxe. Composer génère automatiquement le composer.json fichier lorsque vous ajoutez une dépendance à votre projet à l'aide du composer require commande. Vous pouvez ajouter des dépendances supplémentaires de la même manière, sans avoir à modifier manuellement ce fichier.

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 référentiel de packages officiel pour Composer.
  • Choisissez le forfait dont vous voulez dépendre.
  • Courir composer require pour inclure la dépendance dans le composer.json fichier et installez le package.

Vous pouvez tester 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 appelée slug. Un slug est couramment utilisé pour convertir les titres de page en chemins d'URL, tels que la dernière partie de l'URL de ce didacticiel.

Commencez par naviguer vers votre répertoire personnel :

cd ~

Créez ensuite un répertoire. Appeler slugify:

mkdir slugify

Une fois que vous avez terminé de le créer, accédez au répertoire :

cd slugify

Il est maintenant temps de chercher sur Packagist.org un paquet qui peut aider à générer des slugs. Si vous recherchez le terme « slug » sur Packagist, vous obtiendrez un résultat semblable à celui-ci :

Il y aura deux numéros sur le côté droit de chaque paquet dans la liste. Le nombre à côté de l'icône avec la flèche pointant vers le bas représente le nombre de fois que le package a été installé, et le nombre avec l'icône étoile représente le nombre de fois qu'un package a été suivi sur GitHub. Vous pouvez également réorganiser les résultats de la recherche en fonction de ces numéros. De manière générale, les packages avec plus d'installations et plus d'étoiles ont tendance à être plus stables, car de nombreuses personnes les utilisent. Il est également important de vérifier la pertinence de la description du package pour vous assurer que c'est ce dont vous avez besoin.

Pour ce didacticiel, vous avez besoin d'un convertisseur de chaîne en slug. À partir des résultats de la recherche, le package cocur/slugify est un bon match, avec un nombre raisonnable d'installations et d'étoiles.

Les packages sur Packagist ont un nom fournisseur et un nom package. Chaque package a un identifiant unique (un espace de noms) dans le même format que GitHub utilise pour ses référentiels, sous la forme vendor/package. La bibliothèque que vous souhaitez installer utilise l'espace de noms cocur/slugify. Vous avez besoin de l'espace de noms pour exiger le package dans votre projet.

Maintenant que vous connaissez le package que vous souhaitez installer, exécutez composer require pour l'inclure en tant que dépendance et générer également le composer.json fichier pour le projet :

composer require cocur/slugify

Votre sortie renverra ce qui suit lorsque Composer télécharge la dépendance :

OutputUsing version ^4.1 for cocur/slugify
./composer.json has been created
Running composer update cocur/slugify
Loading composer repositories with package information
Updating dependencies
Lock file operations: 1 install, 0 updates, 0 removals
  - Locking cocur/slugify (v4.1.0)
Writing lock file
Installing dependencies from lock file (including require-dev)
Package operations: 1 install, 0 updates, 0 removals
  - Downloading cocur/slugify (v4.1.0)
  - Installing cocur/slugify (v4.1.0): Extracting archive
Generating autoload files

Comme cette sortie l'indique, Composer décide automatiquement de la version du package à utiliser. Si vous vérifiez le répertoire de votre projet maintenant, il contiendra deux nouveaux fichiers : composer.json et composer.lock, et un vendor annuaire:

ls -l
Outputtotal 12
-rw-r--r-- 1 sammy sammy   59 Aug  2 22:19 composer.json
-rw-r--r-- 1 sammy sammy 3462 Aug  2 22:19 composer.lock
drwxr-xr-x 4 sammy sammy 4096 Aug  2 22:19 vendor

La composer.lock Le fichier est utilisé pour stocker des informations sur les versions de chaque package installé. Cela garantit également que les mêmes versions sont utilisées si quelqu'un d'autre clone votre projet et installe ses dépendances. La vendor répertoire est l'endroit où se trouvent les dépendances du projet. La vendor dossier n'a pas besoin d'être validé dans le contrôle de version, il vous suffit d'inclure le composer.json et composer.lock des dossiers.

Lors de l'installation d'un projet qui contient déjà un composer.json fichier, exécuter composer install afin de télécharger les dépendances du projet.


Ensuite, passez en revue les contraintes de version. Si vous vérifiez le contenu de votre composer.json fichier, vous aurez quelque chose comme ceci :

cat composer.json
Output{
    "require": {
        "cocur/slugify": "^4.1"
    }
}

Vous remarquerez peut-être 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 de package requise, afin de fournir une flexibilité tout en maintenant la stabilité de votre projet. Le caret (^) opérateur utilisé par l'opérateur généré automatiquement composer.json file est l'opérateur recommandé pour une interopérabilité maximale, suivant le versioning sémantique. Dans ce cas, il définit 4.1 comme la version minimale compatible et autorise les mises à jour vers toute future version sous 5.0.

D'une manière générale, vous n'aurez pas besoin de modifier les contraintes de version dans votre composer.json dossier. Cependant, certaines situations peuvent nécessiter la modification manuelle de la contrainte. Par exemple, lorsqu'une nouvelle version majeure de votre bibliothèque requise est publiée et que vous souhaitez effectuer une mise à niveau, ou lorsque la bibliothèque que vous souhaitez utiliser ne suit pas la gestion sémantique des versions.

Voici quelques exemples pour vous permettre de mieux comprendre le fonctionnement des contraintes de version de Composer :

Contrainte Sens Exemples de versions autorisées
^1.0 >= 1,0 < 2,0 1.0, 1.2.3, 1.9.9
^1.1.0 >= 1.1.0 < 2.0 1.1.0, 1.5.6, 1.9.9
~1.0 >= 1.0 < 2.0.0 1.0, 1.4.1, 1.9.9
~1.0.0 >= 1.0.0 < 1.1 1.0.0, 1.0.4, 1.0.9
1.2.1 1.2.1 1.2.1
1.* >= 1,0 < 2,0 1.0.0, 1.4.5, 1.9.9
1.2.* >= 1,2 < 1,3 1.2.0, 1.2.3, 1.2.9


Pour une vue plus détaillée des contraintes de version de Composer, consultez la documentation officielle.

Ensuite, vous apprendrez à charger automatiquement les dépendances avec Composer.

Étape 4 - Inclure le script de chargement automatique

Étant donné que PHP lui-même ne charge pas automatiquement les classes, Composer fournit un script de chargement automatique que vous pouvez inclure dans votre projet pour que le chargement automatique fonctionne. Cela aide lorsque vous travaillez avec vos dépendances.

La seule chose que vous devez faire est d'inclure le vendor/autoload.php fichier dans vos scripts PHP avant toute instanciation de classe. Ce fichier est généré automatiquement par Composer lorsque vous ajoutez votre première dépendance.

Vous pouvez le tester dans votre application. Créer le fichier test.php et ouvrez-le dans votre éditeur de texte préféré. Ici, nano est utilisé:

nano test.php

Ajoutez le code suivant pour faire entrer le vendor/autoload.php fichier, chargez le cocur/slugify dépendance, et créez un slug :

test.php

<?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. Si vous utilisez nano, vous pouvez le faire en appuyant sur CTRL + X, alors Y et ENTER.

Exécutez maintenant le script :

php test.php

Cela produit la sortie suivante :

Outputhello-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, vous apprendrez donc à gérer cela à la dernière étape.

É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 le update commande:

composer update

Cela vérifiera les versions plus récentes des bibliothèques que vous avez ajoutées en tant qu'exigences 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 composer.json fichier, Composer remplacera la version précédente installée. La composer.lock fichier 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 suit :

composer update vendor/package vendor2/package2

Assurez-vous de valider les modifications apportées à votre composer.json et composer.lock après avoir mis à jour vos dépendances, afin que toute personne travaillant dans le projet ait accès aux mêmes versions de package.

Conclusion

Composer est un outil puissant que tout développeur PHP devrait avoir dans sa ceinture utilitaire. Dans ce tutoriel, vous avez installé Composer sur Debian 11 et l'avez utilisé dans un projet. Vous savez maintenant installer et mettre à jour les dépendances.

En plus de fournir un moyen fiable de gérer les dépendances des projets, Composer établit également une nouvelle norme pour le partage et la découverte des packages PHP créés par la communauté.