Préparer et construire un projet PHP à Jenkins

Dans un article précédent, nous avons traversé l'installation de Jenkins et avons tout préparé pour commencer. Nous continuerons dans cet article en préparant réellement notre projet. Si vous avez une configuration de Jenkins prête d'avant, pas besoin de passer par la partie précédente - vous pouvez suivre très bien celui-ci.

Les plats clés

• Pour préparer un projet PHP dans Jenkins, il est conseillé d'avoir des outils tels que PHPUnit et PHP-codesniffer disponibles. Cela peut être réalisé en installant des packages à l'échelle mondiale sur le serveur Jenkins ou en définissant des dépendances dans un fichier composer.json.
• Ant est utilisé sur le serveur Jenkins pour automatiser le processus de construction du logiciel. Les cibles sont définies dans un fichier de configuration et Ant effectue des actions en fonction de ces cibles. Le fichier build.xml est ajouté au projet pour ANT pour effectuer des tâches sur le serveur Jenkins.
• Le fichier build.xml peut nécessiter une modification en fonction du projet spécifique. Cela comprend la définition de l'endroit où les outils comme PHPUnit peuvent être trouvés et le nettoyage de plusieurs commandes pour correspondre correctement au projet.
• De nouvelles cibles peuvent devoir être créées pour s'assurer que tous les outils QA s'exécuteront comme prévu. Cela comprend le traitement des exigences pour configurer correctement le projet sur Jenkins, telles que les dépendances réglementées par le compositeur et le bower.
• Après avoir préparé le projet, il est nécessaire de créer un projet dans Jenkins et de le configurer. Les étapes incluent l'installation du plugin GitHub au sein de Jenkins, la création d'un nouvel élément et la configuration de la gestion des sources. La construction peut ensuite être démarrée en cliquant sur «Build Now» dans le menu latéral du projet.

Préparer le compositeur

Nous allons d'abord préparer notre projet. Nous pourrions utiliser le projet fourni par Sebastian Bergmann, mais c'est plutôt un projet de base et se déroulera sans problèmes à Jenkins. Dans cet article, nous utiliserons un référentiel différent dans lequel nous devrons surmonter certains obstacles. Nous utiliserons une fourche de Jumph comme base.

D'abord et avant tout, nous devons nous assurer que nous avons des outils comme PHPUNIT et PHP-CODESNIFFER disponibles. Nous pouvons le faire de deux manières différentes. Soit nous installons les packages sur notre serveur Jenkins via Pear ou Composer à l'échelle mondiale, soit nous définissons les dépendances dans notre fichier composer.json. J'ai décidé d'aller avec cette dernière méthode, afin que nous puissions facilement contrôler la version de ces outils sur notre propre machine locale ainsi que sur Jenkins. Nous commençons donc par ajouter les lignes suivantes au fichier composer.json et exécuter la mise à jour du compositeur.

"require-dev": {
    "squizlabs/php_codesniffer": "~1.5.*",
    "phpmd/phpmd": "~2.1.*",
    "sebastian/phpcpd": "~2.0.*",
    "pdepend/pdepend": "~2.0.*",
    "phploc/phploc": "~2.0.*",
    "phpunit/phpunit": "~4.3.*",
    "theseer/phpdox": "~0.7.*",
},

Si vous voulez en savoir plus sur ce que fait chaque package, jetez un œil à l'article de Bruno sur les outils PHP QA.

Préparer la fourmi

Sur notre serveur Jenkins, nous utiliserons Ant. Ainsi, au cas où Ant n'est pas encore installé sur votre serveur, assurez-vous que c'est en exécutant la commande suivante.

"require-dev": {
    "squizlabs/php_codesniffer": "~1.5.*",
    "phpmd/phpmd": "~2.1.*",
    "sebastian/phpcpd": "~2.0.*",
    "pdepend/pdepend": "~2.0.*",
    "phploc/phploc": "~2.0.*",
    "phpunit/phpunit": "~4.3.*",
    "theseer/phpdox": "~0.7.*",
},

Ant vous aide à automatiser le processus de construction du logiciel. Vous définissez des tâches, appelées cibles, dans le fichier de configuration. Ant lira ce fichier et effectuera l'action appropriée. Vous pouvez définir des dépendances pour indiquer dans quel ordre ANT doit effectuer ces tâches. Le fichier de configuration est le fichier soi-disant build.xml. Nous allons l'ajouter à notre projet, afin que Ant peut effectuer ces tâches sur notre serveur Jenkins. Nous allons utiliser le modèle fourni par Sebastian Bergmann qui peut être trouvé ici. Nous l'ajoutons à la racine de notre projet.

Pour exécuter Ant, vous pouvez lancer Ant Build sur la ligne de commande. Cela signifie que la fourmi exécutera la cible de construction. Si aucun paramètre n'est donné, Ant exécutera la cible comme indiqué dans la configuration par défaut, qui dans ce cas est également construit.

Examinons de plus près la cible de construction.

sudo apt-get install ant

La cible est vide, cependant, elle dépend de beaucoup d'autres cibles. Il exécutera d'abord la cible de préparation, puis continuera avec la cible de charpie jusqu'à ce que chaque cible soit exécutée. Jetons un coup d'œil à la cible PHPLOC-CI par exemple.

<span><span><span><target</span> name<span>="build"</span> depends<span>="prepare,lint,phploc-ci,pdepend,phpmd-ci,phpcs-ci,phpcpd-ci,phpunit,phpdox"</span> description<span>=""</span>/></span></span>

Cette cible est assez facile à comprendre. Vous remarquerez que cela dépend de la cible de préparation. Comme cela était déjà géré par l'objectif de construction, il ne fonctionnera plus. Ensuite, nous obtenons l'exécutable, qui est PHPLOC, qui sera exécuté par Ant. Vous l'avez installé plus tôt avec Composer. Enfin, nous verrons les arguments spécifiques du PHPLOC. Ant exécutera la entrée de ligne de commande suivante en fonction de cette configuration cible.

<span><span><span><target</span> name<span>="phploc-ci"</span> depends<span>="prepare"</span> description<span>="Measure project size using PHPLOC and log result in CSV and XML format. Intended for usage within a continuous integration environment."</span>></span>
</span>    <span><span><span><exec</span> executable<span>="${toolsdir}phploc"</span>></span>
</span>        <span><span><span><arg</span> value<span>="--count-tests"</span>/></span>
</span>        <span><span><span><arg</span> value<span>="--log-csv"</span>/></span>
</span>        <span><span><span><arg</span> path<span>="${basedir}/build/logs/phploc.csv"</span>/></span>
</span>        <span><span><span><arg</span> value<span>="--log-xml"</span>/></span>
</span>        <span><span><span><arg</span> path<span>="${basedir}/build/logs/phploc.xml"</span>/></span>
</span>        <span><span><span><arg</span> path<span>="${basedir}/src"</span>/></span>
</span>        <span><span><span><arg</span> path<span>="${basedir}/tests"</span>/></span>
</span>    <span><span><span></exec</span>></span>
</span><span><span><span></target</span>></span></span>

Les $ {outilsdir} et $ {basaseir} sont 2 variables. Selon la façon dont ils sont configurés, ils pourraient avoir un effet sur la sortie globale de la ligne de commande

Comme indiqué ci-dessus, si vous vouliez seulement déclencher cette cible, vous devez exécuter Ant Phploc-Ci sur la ligne de commande.

Remarquez que cette commande PHPLOC publiera un fichier phploc.csv et un fichier phploc.xml. Les plugins installés dans Jenkins plus tôt liront ces fichiers et les convertiront en graphiques, par exemple. Dans le prochain article, nous plongerons plus profondément dans ce sujet.

Si vous regardez dans l'ensemble du fichier build.xml, vous remarquerez que cela dépend de 3 autres fichiers de configuration distincts pour certains outils; build / phpmd.xml, build / phpdox.xml et build / phpunit.xml. Ces fichiers de configuration sont demandés par les outils réels. Pour en savoir plus, regardez leurs documents respectifs.

Notez que phpunit.xml est fortement inspiré par le fichier phpunit.xml.dist d'origine de Symfony2 car nous traitons d'un projet Symfony2.

Modification du fichier build.xml

Alors, avons-nous fini? Malheureusement, pas encore. Le fichier build.xml est très générique et n'est pas entièrement adapté à notre projet. Nous devons d'abord définir où des outils comme le phpunit peuvent être trouvés. Notre compositeur les a installés automatiquement dans le répertoire bac à la racine de notre projet. Nous devons modifier la propriété ToolsDir en la valeur correcte.

"require-dev": {
    "squizlabs/php_codesniffer": "~1.5.*",
    "phpmd/phpmd": "~2.1.*",
    "sebastian/phpcpd": "~2.0.*",
    "pdepend/pdepend": "~2.0.*",
    "phploc/phploc": "~2.0.*",
    "phpunit/phpunit": "~4.3.*",
    "theseer/phpdox": "~0.7.*",
},

Nous pouvons également nettoyer plusieurs commandes. Le fichier Build.xml actuel définit que nous avons une part un répertoire SRC et d'autre part un répertoire tests. Étant donné que Symfony2 inclut des tests dans le répertoire SRC, nous pouvons supprimer tous les chemins du répertoire des tests comme cet exemple.

sudo apt-get install ant

Bien que ce ne soit pas nécessaire, je préfère garder tout aussi propre que possible afin qu'il corresponde correctement à notre projet.

Enfin, la configuration actuelle de PHPDOX comme indiqué dans le fichier build.xml lors de l'écriture de cet article ne fonctionne pas avec la dernière version de mon cas. J'ai changé la cible comme ci-dessous, donc il lit correctement notre fichier de configuration.

<span><span><span><target</span> name<span>="build"</span> depends<span>="prepare,lint,phploc-ci,pdepend,phpmd-ci,phpcs-ci,phpcpd-ci,phpunit,phpdox"</span> description<span>=""</span>/></span></span>

Création de nouvelles cibles

Tout a été configuré pour s'assurer que tous nos outils QA fonctionneront comme prévu. Cependant, notre projet est un peu plus compliqué. Si vous avez analysé le référentiel, vous remarquerez que les dépendances sont régulées par le compositeur et le bower. Puisqu'il s'agit d'un projet Symfony, nous aurons également besoin d'un fichier paramètres par défaut.yml. Nous devons répondre à ces exigences pour pouvoir configurer correctement le projet sur Jenkins.

Commençons par le fichier paramètres.yml. Nous pouvons travailler avec le contenu par défaut de Paramètres.yml.dist, nous allons donc copier ce fichier. Nous commençons par créer une nouvelle cible nommée Paramètres de copie qui exécute la commande CP.

<span><span><span><target</span> name<span>="phploc-ci"</span> depends<span>="prepare"</span> description<span>="Measure project size using PHPLOC and log result in CSV and XML format. Intended for usage within a continuous integration environment."</span>></span>
</span>    <span><span><span><exec</span> executable<span>="${toolsdir}phploc"</span>></span>
</span>        <span><span><span><arg</span> value<span>="--count-tests"</span>/></span>
</span>        <span><span><span><arg</span> value<span>="--log-csv"</span>/></span>
</span>        <span><span><span><arg</span> path<span>="${basedir}/build/logs/phploc.csv"</span>/></span>
</span>        <span><span><span><arg</span> value<span>="--log-xml"</span>/></span>
</span>        <span><span><span><arg</span> path<span>="${basedir}/build/logs/phploc.xml"</span>/></span>
</span>        <span><span><span><arg</span> path<span>="${basedir}/src"</span>/></span>
</span>        <span><span><span><arg</span> path<span>="${basedir}/tests"</span>/></span>
</span>    <span><span><span></exec</span>></span>
</span><span><span><span></target</span>></span></span>

Ensuite sont compositeurs et bower. J'ai décidé de les installer dans le monde sur le serveur Jenkins en exécutant les commandes suivantes.

phploc --count-tests --log-csv /build/logs/phploc.csv --log-xml /build/logs/phploc.xml /src /tests

[ed: notez que si vous exécutez tout cela dans une machine virtuelle hébergée sur Windows, BowerPhp sera une bien meilleure option que Bower.]

Permet maintenant de créer une cible pour le compositeur.

<span><span><span><property</span> name<span>="toolsdir"</span> value<span>="bin/"</span> /></span></span>

Il est important de définir Symfony_env pour tester, Symfony sait qu'il doit effacer son répertoire de cache de test.

Continuons avec Bower.

<span><span><span><arg</span> path<span>="${basedir}/tests"</span>/></span></span>

La dernière chose que nous devons faire est de s'assurer que ces cibles sont exécutées. Nous modifions donc la cible de construction et ajoutons les 3 cibles nouvellement créées dans l'ordre, nous voulons les exécuter.

<span><span><span><target</span> name<span>="phpdox"</span> depends<span>="phploc-ci,phpcs-ci,phpmd-ci"</span> description<span>="Generate project documentation using phpDox"</span>></span>
</span>  <span><span><span><exec</span> executable<span>="${toolsdir}phpdox"</span>></span>
</span>   <span><span><span><arg</span> value<span>="--file"</span> /></span>
</span>   <span><span><span><arg</span> value<span>="${basedir}/build/phpdox.xml"</span> /></span>
</span>  <span><span><span></exec</span>></span>
</span> <span><span><span></target</span>></span></span>

git

La dernière chose que nous devons faire est de préparer notre fichier .gitignore. Si vous souhaitez exécuter une cible de fourmis sur votre machine locale, votre répertoire de construction sera rempli de fichiers journaux que vous ne souhaitez pas vous engager dans votre référentiel. Nous ajoutons donc les lignes suivantes au fichier .gitignore.

<span><span><span><target</span> name<span>="copy-parameters"</span> description<span>="Copy parameters.yml file"</span>></span>
</span>  <span><span><span><exec</span> executable<span>="cp"</span> failonerror<span>="true"</span>></span>
</span>   <span><span><span><arg</span> path<span>="app/config/parameters.yml.dist"</span> /></span>
</span>   <span><span><span><arg</span> path<span>="app/config/parameters.yml"</span> /></span>
</span>  <span><span><span></exec</span>></span>
</span> <span><span><span></target</span>></span></span>

Peut-être que vous êtes un peu confus par toutes les modifications que nous avons apportées. Pour votre commodité, voici un lien direct vers l'engagement avec toutes les modifications que nous avons décrites ci-dessus.

Créez le projet dans Jenkins

Notre projet est prêt. Revenons à Jenkins et configurons-le. Ce sera la partie la plus simple de cet article.

Étant donné que notre projet est situé sur GitHub, je vous suggère d'installer le plugin GitHub dans Jenkins. Si vous utilisez votre propre serveur GIT, vous pouvez simplement installer le plugin GIT ordinaire. Si vous ne savez pas comment installer un plugin, consultez l'article précédent.

Lorsque vous revenez à la vue d'ensemble, vous devez cliquer sur un nouvel élément dans le menu de gauche. Comme nom de l'article, nous remplissons Jumph. Ensuite, nous choisissons l'option Copier l'élément existant et remplissons PHP-Template comme le projet à copier.

Nous serons immédiatement emmenés sur la page de configuration de ce projet. Nous décochez d'abord la construction de désactivation afin que notre version soit activée sur SAVE. Dans le champ de saisie du projet GitHub, nous remplissons l'URL vers le projet GitHub.

La dernière chose que nous devons faire est de choisir la gestion des sources. Dans notre cas, c'est Git. Ensuite, vous devez remplir le lien du référentiel. Si vous utilisez le lien HTTPS, vous n'avez pas à fournir de références supplémentaires. Nous pouvons décider quelles branches doivent être construites, mais comme nous n'avons qu'une branche principale, nous la laisserons telle qu'elle est.

La configuration est effectuée - c'est si facile car nous avons utilisé un modèle prédéfini. Si vous faites défiler vers le bas, vous verrez exactement ce que le modèle a configuré pour nous. N'oubliez pas de sauvegarder votre configuration avant de continuer.

Démarrer une construction

Si vous avez suivi toutes les étapes jusqu'à présent, vous devriez maintenant pouvoir démarrer une construction. Vous pouvez démarrer une construction en cliquant maintenant sur la construction dans le menu du côté gauche d'un projet. Vous remarquerez dans la table inférieure gauche qu'une construction apparaît.

Si vous cliquez sur la construction elle-même, vous obtiendrez un nouveau menu latéral avec des options pour cette version particulière. Cliquez sur la sortie de la console pour voir exactement ce qui se passe. Dans mon cas, la première construction a échoué en raison de manquer des extensions de PHP.

La sortie de la console est très pratique pour découvrir pourquoi votre projet échoue. Dans mon cas, je devais juste exécuter Sudo apt-get installer php5-curl php5-xsl php5-sqlite php5-xdebug pour installer certains packages nécessaires. Il m'a fallu quelques builds pour comprendre ce qui manquait, mais avec la sortie de la console, il est facile de comprendre ce qui ne va pas. En fin de compte, c'est à quoi ressemble mon histoire de construction.

rouge signifie que la construction a échoué, où le bleu signifie que la construction a réussi. Un échec peut signifier que quelque chose a mal tourné avec la configuration comme nous l'avons vu auparavant, mais cela pourrait également signifier que les tests unitaires ont échoué. Si vous ouvrez à nouveau votre fichier build.xml, vous remarquerez que certaines cibles ont obtenu un attribut nommé FailOrror qui est défini sur true. Si pour une raison quelconque, cette cible échoue, Ant s'arrête automatiquement et rapportera la construction comme cassée.

Peut-être que vous vous attendiez à une boule verte au lieu d'une boule bleue lorsqu'une construction réussit. Il existe un plugin disponible pour montrer des balles vertes au lieu de celles bleues.

Conclusion

Dans cet article, nous avons travaillé notre chemin vers une construction réussie. Nous avons dû préparer notre projet et créer un emploi dans Jenkins. Enfin, nous avons dû déboguer nos deux premiers builds depuis que nous avons oublié d'installer certaines bibliothèques.

Dans la partie suivante, nous allons jeter un œil à tous les résultats que Jenkins donnes.

Questions fréquemment posées (FAQ) sur la construction du projet PHP avec Jenkins

Comment puis-je configurer Jenkins pour mon projet PHP?

La configuration de Jenkins pour votre projet PHP implique plusieurs étapes. Tout d'abord, vous devez installer Jenkins sur votre serveur. Vous pouvez le télécharger à partir du site officiel de Jenkins et suivre les instructions d'installation. Une fois installé, vous devez configurer Jenkins pour travailler avec PHP. Cela implique d'installer les plugins nécessaires comme le plugin PHP, le plugin GIT et d'autres en fonction des exigences de votre projet. Après avoir installé les plugins, vous pouvez créer un nouveau travail Jenkins et le configurer pour créer votre projet PHP. Vous devrez spécifier l'emplacement du code source de votre projet, les déclencheurs de construction et les étapes de construction.

Quels sont les avantages de l'utilisation de Jenkins pour les projets PHP?

Jenkins offre plusieurs avantages pour Projets PHP. Il automatise le processus de construction, de test et de déploiement de vos applications PHP, ce qui peut vous faire gagner beaucoup de temps et d'efforts. Il aide également à garantir que votre code est toujours dans un état déployable, ce qui peut améliorer la qualité de votre logiciel. De plus, Jenkins prend en charge l'intégration continue et la livraison continue, ce qui peut vous aider à fournir des mises à jour à vos utilisateurs plus rapidement et fréquemment.

Comment puis-je utiliser Jenkins pour automatiser les tests pour mon projet PHP?

Jenkins peut être utilisé pour automatiser les tests pour votre projet PHP en s'intégrant à divers outils de test. Par exemple, vous pouvez utiliser le plugin PHPUnit pour exécuter des tests unitaires, ou le plugin Selenium pour exécuter des tests fonctionnels. Vous devez simplement configurer ces plugins dans votre travail Jenkins, et ils exécuteront automatiquement vos tests chaque fois que vous créez votre projet. This can help to catch bugs early and ensure that your code is always in a good state.

Can I use Jenkins with other programming languages ​​besides PHP?

Yes, Jenkins supports a wide range of Langages de programmation en plus de PHP. Cela inclut Java, Python, Ruby, C # et bien d'autres. Vous pouvez utiliser Jenkins pour créer, tester et déployer des applications écrites dans ces langues en installant les plugins appropriés et en configurant votre travail Jenkins en conséquence.

Comment puis-je utiliser Jenkins pour déployer mon application PHP?

Jenkins peut être utilisé pour déployer votre application PHP en intégrant avec divers outils de déploiement. Par exemple, vous pouvez utiliser le plugin SSH pour déployer votre application sur un serveur distant, ou le plugin Docker pour déployer votre application en tant que conteneur Docker. Vous devez simplement configurer ces plugins dans votre travail Jenkins, et ils déploieront automatiquement votre application chaque fois que vous créez votre projet.

Qu'est-ce que l'intégration continue et comment Jenkins le prend en charge?

Continu L'intégration est une pratique de développement logiciel où les développeurs intègrent fréquemment leur code dans un référentiel partagé, généralement plusieurs fois par jour. Cela aide à prendre les problèmes d'intégration tôt et à réduire le temps et les efforts nécessaires pour fournir des mises à jour logicielles. Jenkins prend en charge l'intégration continue en automatisant le processus de construction, de test et de déploiement de votre logiciel chaque fois que vous commettez des modifications dans votre référentiel.

Qu'est-ce que la livraison continue et comment Jenkins le prend en charge?

Continu La livraison est une pratique de développement de logiciels où les modifications de code sont automatiquement construites, testées et préparées pour une version à la production. Il vise à rendre les versions moins risquées et plus fréquentes. Jenkins prend en charge la livraison continue en automatisant l'intégralité du processus de libération du logiciel, de l'intégration et des tests à la livraison et au déploiement.

Puis-je utiliser des jenkins avec Git?

Oui, Jenkins peut être intégré à Git. Cela vous permet de créer, tester et déployer automatiquement votre logiciel chaque fois que vous poussez les modifications à votre référentiel GIT. Vous pouvez configurer cela en installant le plugin GIT et en configurant un webhook dans votre référentiel GIT pour déclencher une construction Jenkins chaque fois que les modifications sont poussées.

Comment puis-je résoudre les problèmes avec ma configuration de Jenkins?

Jenkins fournit plusieurs outils pour vous aider à résoudre les problèmes. Cela comprend les journaux de construction, qui peuvent fournir des informations détaillées sur ce qui s'est passé lors d'une construction et des journaux système, qui peuvent fournir des informations sur le fonctionnement global de votre serveur Jenkins. Vous pouvez également utiliser l'API Jenkins CLI ou REST pour interagir avec votre serveur Jenkins et diagnostiquer les problèmes.

Comment puis-je sécuriser mon serveur Jenkins?

La sécurisation de votre serveur Jenkins implique plusieurs étapes. Tout d'abord, vous devez vous assurer que votre serveur Jenkins exécute la dernière version, car cela comprendra les derniers correctifs de sécurité. Vous devez également configurer Jenkins pour utiliser HTTPS, qui cryptera les communications entre votre serveur Jenkins et vos utilisateurs. De plus, vous devez restreindre l'accès à votre serveur Jenkins en utilisant des mécanismes d'authentification et d'autorisation, et limiter les autorisations des utilisateurs de Jenkins à ce dont ils ont besoin pour effectuer leurs tâches.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!