Comment effectuer des tests d’intégration continue avec Drone.io sur CoreOS et Docker

introduction

Vous voulez une solution d’intégration continue d’installation minimale? Qui ne le ferait pas? https://drone.io [Drone.io] utilise les conteneurs Docker pour exécuter vos tests et fonctionne avec https://github.com [GitHub], https://about.gitlab.com [GitLab] (auto-hébergé). et service based), et https://bitbucket.org [Bitbucket].

Drone est construit avec Go et utilise Docker. Il peut être exécuté à l’intérieur d’un conteneur même avec très peu de configuration.

L’intégration continue est la pratique de développement consistant à effectuer des commits fréquents sur votre base de code, à construire et à tester au fur et à mesure. Cela signifie que le nouveau code intégrera (espérons-le) rapidement et facilement votre base de code existante. Étant donné que l’intégration continue nécessite que vous construisiez et testiez votre code fréquemment, le processus de développement est accéléré si vous pouvez générer et tester automatiquement. Le drone fait ceci; il automatise le processus de construction et de test.

Drone extrait automatiquement le code d’un référentiel Git hébergé, puis exécute les scripts que vous définissez. Vous pouvez exécuter n’importe quelle suite de tests et vous les faire rapporter par courrier électronique ou indiquer l’état avec un badge dans votre README. L’intégration de Drone à Docker signifie qu’il peut prendre en charge un grand nombre de langages, notamment PHP, Node, Ruby, Go et Python, pour en nommer quelques-uns. Chaque test créera un nouveau conteneur basé sur des images spécifiées du registre public de Docker. Cela signifie que la prise en charge des langages et des piles de développement ne fera qu’augmenter à mesure que davantage d’images seront créées. Vous pouvez même créer le vôtre pour l’adapter à votre application spécifique!

Dans ce didacticiel, nous verrons comment conteneuriser Drone.io de manière à ce qu’il puisse être exécuté à l’aide de la distribution minimale Linux CoreOS.

Exigences

Au moins une clé SSH ajoutée à votre compte
Un seul Corelet Beta Droplet (512 Mo de RAM fonctionnera correctement)

Il est recommandé de lire cette Introduction à CoreOS avant de continuer si vous n’avez jamais utilisé le système d’exploitation auparavant.

Si vous ne savez pas comment configurer CoreOS à l’aide d’un fichier + cloud-config +, vous trouverez plus d’informations, ainsi qu’un exemple de fichier de configuration, à l’adresse https://www.digitalocean.com/community/tutorials/how-to-set. -up-a-coreos-cluster-on-digitalocean [ici]! L’exemple de fichier de configuration fonctionnera pour ce tutoriel.

Première étape - Préparer GitHub

Avant de commencer, nous devons activer l’accès à nos comptes GitHub via oAuth. Nous allons générer une paire de jetons à utiliser lors de la prochaine étape de la configuration du conteneur Drone.

Nous devons générer ces valeurs à partir de votre compte GitHub. Cliquez ici pour accéder à la page de paramètres appropriée sur GitHub, appelée * Applications *.

Cliquez sur le bouton * Enregistrer une nouvelle application * en haut à droite. Cela fera apparaître un nouveau formulaire à remplir:

image: https: //assets.digitalocean.com/articles/drone/register.png [Enregistrement OAuth]

Ajoutez votre * nom d’application *. L’URL de la page d’accueil doit être + http: // YOUR_DROPLET_IP: 8080 / +. Ajoutez votre * description de l’application *.

IMPORTANT *: assurez-vous que * l’URL de rappel d’autorisation * est défini sur + http: // YOUR_DROPLET_IP: 8080 / api / auth / github.com + afin de s’authentifier correctement!

Une fois que cela vous convient, cliquez sur * Enregistrer l’application * pour accéder à la page d’informations de la nouvelle application.

À partir de là, vous aurez besoin de deux éléments d’information: * ID client * et * Client Secret *. (Gardez le secret du client réellement secret! Ce n’est pas quelque chose que vous devriez partager avec n’importe qui!)

Ces jetons seront utilisés pour autoriser notre propre application Drone à ajouter des WebHooks à tout référentiel GitHub que nous ajoutons à Drone via le panneau * Dashboard *. Les webhooks se déclencheront à chaque nouveau commit que nous pousserons vers GitHub, ce qui amènera Drone à cloner les nouvelles modifications et à exécuter la construction.

Notez ces jetons, car nous en aurons besoin à l’étape suivante.

Deuxième étape - Écrire le fichier Docker

Une fois que votre CoreOS Droplet est prêt, connectez-vous via SSH:

ssh -A core@YOUR_DROPLET_IP

Créez un nouveau répertoire appelé + droneio +:

mkdir droneio
cd droneio

En raison de la nature en lecture seule du système de fichiers racine de CoreOS, nous ne pouvons pas installer Drone.io directement. Nous devons le contenir en utilisant d’abord Docker. Nous allons créer un fichier Docker qui contient des instructions sur l’installation de Drone.io exactement comme nous le ferions sur un système Ubuntu standard.

Nous utiliserons l’éditeur de texte basé sur le terminal + vim + dans cette section. Il s’agit de l’éditeur de texte par défaut de CoreOS. Il est donc important de vous familiariser avec celui-ci. Nous allons vous montrer pas à pas comment l’utiliser pour ouvrir et éditer le fichier.

Il est maintenant temps d’utiliser vim pour créer notre fichier Docker. Exécutez la commande:

vim Dockerfile

Cela ouvre vim et crée un nouveau fichier nommé + Dockerfile + dans votre répertoire actuel.

Entrez maintenant en mode insertion. Pour ce faire, appuyez sur la touche + i +. Le coin inférieur gauche du terminal devrait maintenant indiquer: + - INSERT - +. Maintenant, vous pouvez taper ou coller dans le contenu de Dockerfile.

Voici le fichier Docker dans son intégralité. Les commentaires sont inclus en ligne pour chaque section. Vous pouvez copier ce fichier exactement:

# Pull from base Ubuntu image
FROM ubuntu

# Do system updates and install dependencies
RUN apt-get update
RUN apt-get -y upgrade
RUN sudo apt-get -y install git wget
RUN apt-get clean

# Download Drone.io
RUN wget http://downloads.drone.io/master/drone.deb
RUN dpkg -i drone.deb

# Expose the Drone.io port
EXPOSE 8080

ENV DRONE_SERVER_PORT 0.0.0.0:8080
ENV DRONE_DATABASE_DATASOURCE /var/lib/drone/drone.sqlite

# Define our GitHub oAuth keys below
ENV DRONE_GITHUB_CLIENT <CLIENT_TOKEN_HERE>
ENV DRONE_GITHUB_SECRET <CLIENT_SECRET_HERE>

# The command we'll be running when the container starts
CMD /usr/local/bin/droned

Remplacez les éléments + <CLIENT_TOKEN_HERE> + et + <CLIENT_SECRET_HERE> + par les jetons indiqués à l’étape précédente.

Tapez la commande ci-dessous pour enregistrer les modifications apportées. + W + indique à vim d’écrire le texte dans le fichier, et + q + fera quitter vim.

:wq

Un aperçu très rapide pour ceux qui ne connaissent pas Dockerfiles:

+ FROM - L’image que nous allons utiliser pour votre conteneur
+ RUN + - Exécute une commande à l’intérieur du conteneur pendant le processus de construction
+ EXPOSE + - Permet d’accéder au (x) port (s) spécifié (s) en dehors du conteneur
+ CMD + - La commande qui sera exécutée au démarrage du conteneur
+ ENV + - Définit la valeur d’une variable d’environnement dans le conteneur, utilisée ici pour la configuration Drone

Pour plus d’informations sur les types d’instructions que vous pouvez faire dans Dockerfiles, consultez la official documentation Docker.

À ce stade, nous pouvons construire l’image à l’aide de la commande suivante:

docker build -t my_drone .

Cela prendra quelques minutes à compléter. Une fois la création réussie, nous pouvons créer un conteneur en utilisant notre nouvelle image.

Deuxième étape - Lancement du conteneur Drone

Drone.io a besoin d’un emplacement pour stocker les informations. Nous allons donc utiliser un fichier de base de données SQLite. Créez un fichier vide pour commencer:

touch drone.sqlite

Ce fichier sera rempli de données par Drone une fois le conteneur opérationnel.

Le lancement de Drone est assez simple, mais nous devons faire quelques étapes supplémentaires pour nous assurer que Drone puisse accéder au serveur Docker de notre hôte. Pour ce faire, la méthode la plus simple consiste à utiliser un volume pour lier le fichier de socket hôte à l’emplacement du fichier de socket du conteneur. La commande pour démarrer correctement le conteneur est ci-dessous:

docker run -d --name="drone-ci" \
   -p 8080:8080 \
   -v /var/lib/drone/ \
   -v /var/run/docker.sock:/var/run/docker.sock \
   -v /home/core/droneio/drone.sqlite:/var/lib/drone/drone.sqlite \
   my_drone

Allant ligne par ligne, démontons ce qui se passe exactement:

+ docker run -d --name =" drone-ci "+ - Dans cette partie de la commande, nous demandons à Docker d’exécuter ce conteneur en arrière-plan, de sorte que nous n’ayons pas à nous en soucier. déconnecter de la session SSH. Nous lui attribuons également un nom convivial, * drone-ci *, afin que nous puissions le gérer à l’aide de la commande + docker +.
+ -p 8080: 8080 + - Ici, nous lions le port 8080 de notre hôte sur le même port du conteneur. Cela nous permet d’accéder à l’interface de Drone en dehors du réseau du conteneur en cours d’exécution.
+ -v / var / lib / drone + - Ceci configure un volume pour le stockage dans le conteneur.
+ -v /var/run/docker.sock: / var / run / docker.sock + - C’est l’astuce qui permet au conteneur Drone.io de contrôler le système Docker de l’hôte. Nous lions l’emplacement du conteneur où un socket Docker UNIX serait associé au socket Docker UNIX de l’hôte. En d’autres termes, nous demandons à Drone d’utiliser l’installation de Docker sur notre hôte CoreOS, et non à l’intérieur du conteneur dans lequel Drone s’exécute. En effet, Docker est installé sur l’hôte et le conteneur ne le fait pas (autrement dit, le conteneur Docker n’exécute pas d’installation imbriquée de Docker).
+ -v /home/core/droneio/drone.sqlite:/var/lib/drone/drone.sqlite \ + - Lie le fichier de stockage vide à la base de données à l’intérieur du conteneur pour y conserver les données que nous stockons. Ce fichier est en dehors du conteneur au cas où nous aurions besoin de récupérer des données à partir de celui-ci ou si la base de données doit être modifiée en externe pour une raison quelconque.
+ my_drone + - Nous utilisons l’image que nous avons construite précédemment pour exécuter ce conteneur.

Après avoir exécuté cette commande, si des erreurs se produisent, vérifiez bien que vous avez créé le fichier de base de données vide et que tous les chemins sont correctement entrés.

Pour vous assurer que le conteneur est en cours d’exécution, effectuez une vérification rapide de l’état:

docker ps

Votre sortie devrait ressembler à ce qui suit:

CONTAINER ID        IMAGE               COMMAND               CREATED             STATUS              PORTS                             NAMES
6eddddd09900        my_drone:latest    "/bin/sh -c '/usr/lo   1 seconds ago       Up 1 seconds        0.0.0.0:8080->8080/tcp            drone-ci

Mon conteneur n’a pas commencé!

Si vous avez exécuté + docker ps + et que vous n’obtenez aucun résultat, veuillez vérifier la longue commande + docker run + ci-dessus et vous assurer de la saisir exactement. Vous pouvez essayer de l’exécuter sans les sauts de ligne. Assurez-vous également que vous avez créé le fichier + drone.sqlite + vide dans le bon répertoire.

Pour reconstruire le conteneur et réessayer, nous devons retirer le conteneur endommagé de Docker. sinon, il se plaindra des conteneurs nommés en double.

Supprimez l’ancien conteneur en utilisant + docker rm drone-ci + (notez que nous avons utilisé le nom que nous avons donné au conteneur dans la commande ci-dessus). Ensuite, essayez d’exécuter à nouveau la longue commande + docker run + de la section précédente.

Si le conteneur a démarré mais que vous ne pouvez pas accéder à la page d’installation, essayez de le redémarrer. Arrêtez le conteneur en utilisant + docker stop drone-ci +. Ou pour un arrêt plus agressif, utilisez + docker kill drone-ci +. Ensuite, essayez de le redémarrer avec + docker start drone-ci +.

Si vous souhaitez effectuer des recherches dans les journaux de conteneur, vous pouvez utiliser la commande de journalisation de Docker: + docker logs drone-ci +.

Troisième étape - Configurer le drone

Nous sommes maintenant prêts à configurer Drone avec le compte initial. Ouvrez votre navigateur Web et accédez à: + http: // YOUR_DROPLET_IP: 8080 / login. Vous devriez voir un écran de connexion comme celui ci-dessous:

image: https: //assets.digitalocean.com/articles/drone/login.png [Connexion Drone.io]

Nous ne voyons que GitHub car c’est le seul service que nous avons défini dans le fichier Docker.

Cliquez maintenant sur le bouton * GitHub *, puis sur le bouton * Autoriser l’application * pour démarrer le processus de connexion et de synchronisation.

image: https: //assets.digitalocean.com/articles/drone/dash.png [Liste des dépôts]

Ceci est le tableau de bord principal de Drone, vous pouvez voir les trois derniers référentiels de votre compte GitHub et développer la liste en cliquant sur «PARCOURIR TOUT». Si tous vos dépôts n’apparaissent pas, cliquez simplement sur «SYNC» dans le coin supérieur droit.

N’hésitez pas à explorer le tableau de bord.

Ensuite, nous devons autoriser l’accès à vos différentes sources de référentiels Git.

Cinquième étape - Exécuter des constructions à partir de GitHub

Recherchez le nom du référentiel que vous souhaitez ajouter à Drone CI et sélectionnez-le. Cela activera Drone et ajoutera des webhooks à votre référentiel.

Après l’activation, vous verrez la page d’état du référentiel vierge:

image: https: //assets.digitalocean.com/articles/drone/commitStream.png [Flux de validation]

Vous pouvez explorer certains des paramètres les plus avancés pour le référentiel en utilisant le bouton dans le coin supérieur droit.

Le fichier .drone.yml

Nous devons créer un nouveau fichier dans le référentiel appelé + .drone.yml +. Cela commandera Drone et lui dira comment construire et tester le code dans le référentiel GitHub. Voici un fichier très simple que nous allons utiliser pour tester si Drone est configuré correctement.

image: dockerfile/nginx
script:
 - echo hello world

+ image + définit l’image de base à partir de laquelle nous extrayons (l’image peut provenir du registre public Docker, d’un registre privé ou construit localement). Dans ce cas, nous utilisons une image Nginx.
+ script + définit simplement les commandes que Drone doit exécuter et dans quel ordre. Vous pouvez définir plusieurs commandes de script avec un autre + - <commande ici> + sur une nouvelle ligne. (Assurez-vous que les onglets s’alignent!)

Ce script fait simplement écho à «hello world» pour prouver que Drone fonctionne. En réalité, il ne teste rien de votre code.

Dans un scénario de construction et de test réel, vous voudriez que Drone utilise une image Docker qui correspond à votre environnement de production et que les scripts testent le code dans le référentiel.

Maintenant, validez votre fichier + .drone.yml + dans votre référentiel. Ce commit, et tous les autres commits que vous ferez dans le futur (dans n’importe quel fichier, pas seulement le fichier + .drone.yml +), déclencheront le drone Webhook placé dans votre référentiel. Drone devrait maintenant travailler d’arrache-pied pour extraire l’image de base et exécuter vos scripts de construction!

Drone détecte le nouveau commit, clone toutes les modifications apportées au code et suit les instructions définies dans le fichier + .drone.yml +. Il affichera une notification au bas de la page pour vous informer que la construction est en cours d’exécution. Cliquez dessus pour afficher la page d’état de la construction.

image: https: //assets.digitalocean.com/articles/drone/statusPage.png [travailleur de drone]

La compilation prendra quelques minutes, car Drone doit extraire l’image du registre public de Docker.

Si la construction réussit, vous pouvez cliquer sur le commit pour voir plus de détails. Vous devriez voir une sortie similaire à celle-ci:

$ git clone --depth=50 --recursive --branch=master git://github.com/captainshar/dronetest.git /var/cache/drone/src/github.com/captainshar/dronetest
$ git checkout -qf 9908588ae4e4abcba8afb5029baad5c49a835ba4
$ echo hello world
hello world
$ exit 0

Vous pourriez également voir quelques avertissements liés à Perl; C’est très bien.

Si vous avez terminé toutes ces étapes et que vos passes de construction ont été effectuées, vous avez maintenant votre propre assistant personnel Drone.io prêt à construire et à tester presque tous les projets basés sur la langue!

Drone prend également en charge Bitbucket et GitLab, et les processus d’installation utilisant OAuth sont relativement les mêmes que ceux de Github. Vous devrez peut-être modifier le fichier Dockerfile et reconstruire le conteneur à l’aide des variables d’environnement correctes:

DRONE_BITBUCKET_CLIENT
DRONE_BITBUCKET_SECRET
DRONE_GITLAB_URL
...

Prochaines étapes

Maintenant que Drone est prêt à exécuter les versions, vous pouvez modifier le + .drone.yml + pour effectuer des tests plus avancés.

Par exemple, si vous souhaitez tester une application Node à l’aide d’un framework de test tel que Karma ou Mocha, vous pouvez modifier la section + image + en l’image officielle + node + et modifier la section de script pour exécuter + npm +. et lancez les tests! Jetez un coup d’œil sur le Docker de registre pour des images qui pourraient convenir à votre application.

Si vous voulez vraiment être chic, vous pouvez regarder dans quelque chose qui s’appelle Drone Wall pour fournir un tableau d’affichage de tous vos statuts de construction.

Amusez-vous à commander votre drone!

TOC