Comment se déployer correctement lors de l'utilisation du commutateur de développement / production de Composer?
Composer a la possibilité de charger plusieurs dépendances uniquement en cours de développement. Ainsi, les outils ne seront pas installés en production (sur le serveur actif). C'est (en théorie) très pratique pour les scripts qui n'ont de sens que dans le développement, comme les tests, les faux outils de données, le débogueur, etc.
Pour ce faire, vous devez ajouter un nouveau bloc require-dev avec les outils dont vous avez besoin dans dev:
"require-dev": {
"codeception/codeception": "1.6.0.3"
}
puis (théoriquement) charger ces dépendances via
composer install --dev
Problème et question:
Le compositeur a radicalement changé le comportement de install et update en 2013, les dépendances require-dev- étant désormais installées par défaut (!), N'hésitez pas à créer un composer.json avec un require-dev bloquer et effectuer un composer install à reproduire.
Comme le moyen le plus répandu de déployer est d’appuyer sur le composeur .verrouiller (qui contient votre configuration actuelle de composer), puis de faire un composer install sur le serveur de production. installera également les éléments de développement.
Quelle est la bonne façon de déployer cela sans installer les dépendances -dev?
Remarque: j'essaie ici de créer une Q/A canonique pour clarifier le déploiement bizarre de Composer. N'hésitez pas à éditer cette question.
Pourquoi
Il y a un IMHO une bonne raison pour laquelle Composer utilisera l'indicateur --dev par défaut (lors de l'installation et de la mise à jour ) . Composer est principalement exécuté dans les scénarios où il s'agit du comportement souhaité:
Le workflow de base Composer est le suivant:
- Un nouveau projet est démarré:
composer.phar install --dev, les fichiers json et lock sont envoyés à VCS. - D'autres développeurs commencent à travailler sur le projet: extraction de VCS et
composer.phar install --dev. - Un développeur ajoute des dépendances:
composer.phar require <package>, ajoutez--devsi vous voulez que le package soit dans la sectionrequire-dev(et validez). - Les autres suivent: (commander et)
composer.phar install --dev. - Un développeur veut de nouvelles versions de dépendances:
composer.phar update --dev <package>(et commit). - Les autres suivent: (commander et)
composer.phar install --dev. - Le projet est déployé:
composer.phar install --no-dev
Comme vous pouvez le constater, l'indicateur --dev est utilisé (beaucoup plus) que l'indicateur --no-dev, en particulier lorsque le nombre de développeurs travaillant sur le projet augmente.
déploiement de production
Quelle est la bonne façon de déployer ceci sans installer les dépendances "dev"?
Eh bien, les fichiers composer.json et composer.lock doivent être validés dans VCS. N'omettez pas composer.lock car il contient des informations importantes sur les versions de paquet à utiliser.
Lorsque vous effectuez un déploiement en production, vous pouvez transmettre l'indicateur --no-dev à Composer:
composer.phar install --no-dev
Le fichier composer.lock peut contenir des informations sur dev-packages. Cela n'a pas d'importance. Le drapeau --no-dev s'assurera que ces packages de développement ne sont pas installés.
Quand je parle de "déploiement en production", je parle d'un déploiement destiné à être utilisé en production. Je ne discute pas de la question de savoir si un composer.phar install doit être effectué sur un serveur de production ou sur un serveur de transfert où les éléments peuvent être révisés. Ce n'est pas la portée de cette réponse. Je montre simplement comment composer.phar install sans installer de dépendances "dev".
Offtopic
Le drapeau --optimize-autoloader peut également être utile en production (il génère une carte de classes qui accélérera le chargement automatique dans votre application):
composer.phar install --no-dev --optimize-autoloader
Ou lorsque le déploiement automatisé est terminé:
composer.phar install --no-ansi --no-dev --no-interaction --no-progress --no-scripts --optimize-autoloader
En fait, je recommanderais fortement CONTRE l'installation de dépendances sur le serveur de production.
Ma recommandation est de vérifier le code sur une machine de déploiement, d'installer les dépendances nécessaires (cela n'inclut PAS l'installation de dépendances de dev si le code passe en production), puis de transférer tous les fichiers sur la machine cible.
Pourquoi?
- sur un hébergement partagé, vous ne pourrez peut-être pas accéder à une ligne de commande
- même si vous le faisiez, PHP pourrait y être limité en termes de commandes, de mémoire ou d'accès réseau
- les outils CLI du référentiel (Git, Svn) ne seront probablement pas installés, ce qui échouera si votre fichier de verrouillage a enregistré une dépendance pour extraire un certain commit au lieu de le télécharger en tant que Zip (vous avez utilisé --prefer-source ou Composer n'avait pas d'autre moyen d'obtenir cette version)
- si votre machine de production ressemble davantage à un petit serveur de test (pensez à la micro-instance Amazon EC2), il n’ya probablement pas assez de mémoire installée pour exécuter
composer install - alors que composer essaie de ne rien casser, que pensez-vous de la fin d'un site Web de production partiellement défectueux, car certaines dépendances aléatoires n'ont pas pu être chargées pendant la phase d'installation de Composers
Longue histoire: Utilisez Composer dans un environnement que vous pouvez contrôler. Votre machine de développement est qualifiée car vous disposez déjà de tout le nécessaire pour utiliser Composer.
Quelle est la bonne façon de déployer ceci sans installer les dépendances -dev?
La commande à utiliser est
composer install --no-dev
Cela fonctionnera dans n'importe quel environnement, qu'il s'agisse du serveur de production lui-même, d'une machine de déploiement ou de la machine de développement, qui est censé effectuer une dernière vérification pour déterminer si une exigence de développeur est utilisée de manière incorrecte pour le logiciel réel.
La commande n'installe pas, ni ne désinstalle activement, la configuration requise pour le développement déclarée dans le fichier composer.lock.
Si déployer des composants logiciels de développement sur un serveur de production ne vous dérange pas, exécuter composer install ferait le même travail, mais augmenterait simplement le nombre d'octets déplacés, et créerait également une plus grande déclaration d'autoloader.
Maintenant, require-dev est activé par défaut. Pour le développement local, vous pouvez utiliser composer install et composer update sans l'option --dev.
Lorsque vous souhaitez déployer en production, vous devez vous assurer que composer.lock ne possède aucun package provenant de require-dev.
Vous pouvez le faire avec
composer update --no-dev
Une fois que vous avez testé localement avec --no-dev, vous pouvez tout déployer en production et installer sur la base de composer.lock. Vous avez à nouveau besoin de l’option --no-dev ici, sinon composer dira "Le fichier de verrouillage ne contient pas d’information require-dev" .
composer install --no-dev
Note: Soyez prudent avec tout ce qui peut introduire des différences entre dev et production! En général, j'essaie d'éviter autant que possible d'exiger require-dev, car inclure des outils de développement ne représente pas une charge supplémentaire considérable.
Je pense qu'il vaut mieux automatiser le processus:
Ajoutez le fichier composer.lock dans votre référentiel git, assurez-vous d’utiliser composer.phar install --no-dev lors de la publication, mais en dev machine, vous pouvez utiliser n'importe quelle commande composer sans souci, cela ne passera pas en production, la production basera ses dépendances dans le fichier de verrouillage.
Sur le serveur, vous extrayez cette version ou cette étiquette spécifique et exécutez tous les tests avant de remplacer l'application. Si les tests réussissent, vous poursuivez le déploiement.
Si le test dépend de dépendances de dev, étant donné que composer n'a pas de dépendance de portée d'étendue de test, une solution peu élégante pourrait être exécutée avec les dépendances de dev ( composer. phar install ), supprimez la bibliothèque du fournisseur, exécutez composer.phar install --no-dev à nouveau, cela utiliser les dépendances mises en cache est donc plus rapide. Mais c'est un bidouillage si vous connaissez le concept de portées dans d'autres outils de construction
Automatisez cela et oubliez le reste, allez boire une bière :-)
PS: comme dans le commentaire @Sven ci-dessous, il n’est pas judicieux de ne pas extraire le fichier composer.lock, car cela obligerait composer installer le travail en tant que composer mise à jour.
Vous pouvez faire cette automatisation avec http://deployer.org/ c'est un outil simple.
Sur les serveurs de production, je renomme vendor en vendor-<datetime> et, lors du déploiement, aura deux répertoires de fournisseur.
Un cookie HTTP force mon système à choisir le nouveau fournisseur autoload.php, et après les tests, je passe à un commutateur entièrement atomique/instantané entre eux pour désactiver l'ancien répertoire du fournisseur pour toutes les futures demandes, puis je supprime le répertoire précédent quelques jours plus tard. plus tard.
Cela évite tout problème causé par les caches de système de fichiers que j'utilise dans Apache/php, et permet également à tout code PHP actif de continuer à utiliser le répertoire du fournisseur précédent.
Malgré d’autres réponses qui l’avaient recommandé, j’exécutais personnellement composer install sur le serveur, ce qui est plus rapide que rsync depuis ma zone de stockage intermédiaire (un VM sur mon ordinateur portable).
J'utilise --no-dev --no-scripts --optimize-autoloader. Vous devriez lire la documentation de chacun pour vérifier si cela convient à votre environnement.