Comment installer et configurer Drone sur Ubuntu 16.04

introduction

Drone est une plate-forme populaire d’intégration continue et de livraison construite en Go. Il s’intègre à de nombreux services de référentiel de contrôle de version tels que GitHub, GitLab et Bitbucket pour surveiller les modifications de code et les créer et les tester automatiquement au fur et à mesure qu’elles sont validées.

Dans ce guide, nous montrerons comment configurer un environnement d’intégration continue complet de drones pour votre infrastructure. Nous allons installer Drone et le configurer pour l’intégrer à votre référentiel de code source. En cours de route, nous allons configurer Nginx, protégé par Let’s Encrypt, en tant qu’interface pour Drone. Ceci chiffrera les requêtes sur l’interface Web de Drone et permettra au serveur CI de s’intégrer de manière sécurisée au serveur de code source.

Conditions préalables

Pour commencer, vous devez configurer un serveur Ubuntu 16.04 avec un utilisateur non root + sudo + pour les tâches administratives. Le serveur doit également avoir un pare-feu pour filtrer les connexions entrantes. Vous pouvez apprendre à configurer ces éléments en suivant les Ubuntu 16.04 Guide de configuration du serveur initial.

Vous devrez effectuer quelques étapes supplémentaires pour satisfaire aux autres exigences de notre configuration. Drone étant principalement distribué sous forme d’image Docker, nous utiliserons Docker Compose pour gérer les conteneurs du serveur CI. Pour des raisons de sécurité et de performances, nous enverrons des requêtes à Drone par le biais d’une instance Nginx protégée par Let’s Encrypt. Vous aurez besoin d’un nom de domaine attaché à votre serveur CI pour le configurer correctement.

Avant de commencer, utilisez les articles suivants pour configurer ces exigences supplémentaires:

Comment installer et utiliser Docker sur Ubuntu 16.04
Comment installer Docker Compose sur Ubuntu 16.04: Installez Docker et Docker Compose en suivant les instructions prérequis et première étape de ce guide.
Comment installer Nginx sur Ubuntu 16.04: Installez Nginx sur le serveur.
Comment sécuriser Nginx avec Let’s Encrypt sur Ubuntu 16.04: Sécurisez Nginx avec un certificat SSL de confiance.

Lorsque vous avez terminé les guides ci-dessus, votre serveur Drone devrait avoir:

Un utilisateur + sudo + configuré pour les tâches administratives
Un pare-feu UFW activé. Il devrait bloquer toutes les connexions, à l’exception des demandes SSH, HTTP et HTTPS sur les ports 22, 80 et 443 respectivement.
Docker et Docker Compose installés.
Un serveur Nginx configuré avec un certificat SSL fourni par Let’s Encrypt

Continuez ci-dessous lorsque vous êtes prêt à commencer.

Ajouter une application à votre référentiel de code source

Afin de surveiller les modifications de code afin de déclencher les étapes de construction et de test, Drone devra avoir accès à votre référentiel de code source. Drone peut s’intégrer à GitHub, GitLab, à l’adresse http: // docs. drone.io/install-for-gogs/[Gogs], Bitbucket Cloud, et http://docs.drone.io/install- pour-bitbucket-server / [Bitbucket Server].

Dans ce guide, nous allons nous concentrer sur l’intégration à un référentiel GitHub, mais le processus devrait être similaire pour d’autres systèmes. Si vous utilisez un référentiel de code source différent, suivez le lien approprié ci-dessus pour connaître la configuration logicielle spécifique dont vous aurez besoin.

Commencez par visiter votre compte https://github.com [GitHub]. Cliquez sur l’icône de votre utilisateur dans le coin supérieur droit et sélectionnez * Paramètres * dans le menu déroulant:

image: https: //assets.digitalocean.com/articles/drone_install_1604/github_settings.png [Paramètres du drone GitHub]

Recherchez ensuite l’élément * applications OAuth * dans la section * Paramètres du développeur * dans la partie gauche de l’écran:

image: https: //assets.digitalocean.com/articles/drone_install_1604/oauth_apps.png [Applications Drone OAuth]

Sur la page qui suit, cliquez sur * Enregistrer une nouvelle application *:

image: https: //assets.digitalocean.com/articles/drone_install_1604/new_app.png [Nouvelle application Drone]

Ensuite, vous verrez le formulaire d’inscription à l’application OAuth:

image: https: //assets.digitalocean.com/articles/drone_install_1604/define_new_app.png [Drone enregistrer une nouvelle application]

Vous devrez remplir les champs suivants (ces champs sont présents sur GitHub. D’autres fournisseurs de référentiels peuvent avoir des invites différentes):

* Nom de l’application *: Nom choisi pour identifier l’intégration. «Drone» est un bon choix si vous n’avez pas de besoins particuliers.
* URL de la page d’accueil *: le nom de domaine de votre serveur Drone. Utilisez + https: // + ici car nous utilisons un domaine sécurisé.
* Description de l’application *: Une description simple de Drone et de son objectif.
* URL de rappel d’autorisation *: il doit s’agir du spécificateur de schéma + https: // +, suivi du nom de domaine de votre serveur Drone, suivi de + / authorize +. Si votre nom de domaine est ++, ce fichier sera + https: /// authorize.

Lorsque vous êtes prêt, cliquez sur * Enregistrer l’application *.

Sur la page suivante, vous verrez les détails de votre nouvelle application. Les deux éléments dont nous avons besoin sont * l’ID client * et le * secret client *:

image: https: //assets.digitalocean.com/articles/drone_install_1604/client_info.png [Informations client du drone]

Copiez ces deux valeurs pour plus tard. Nous en aurons besoin pour connecter Drone à votre compte GitHub.

Tirez l’image du Docker du drone et préparez-vous à la configuration

Maintenant que votre serveur Drone est enregistré auprès d’un fournisseur de référentiel, vous pouvez installer et configurer Drone sur votre serveur.

Drone est distribué en tant que conteneur Docker. Il sera donc automatiquement téléchargé si nous l’utilisons dans un fichier Docker Compose. Cependant, pour accélérer légèrement le processus, nous pouvons réduire l’image à l’avance:

docker pull drone/drone:0.7

L’image Drone Docker est un conteneur unifié qui peut être exécuté de différentes manières. Nous allons exécuter un conteneur qui fonctionne en tant que serveur Drone, qui coordonne l’accès au référentiel, héberge l’interface utilisateur Web et sert l’API. En utilisant la même image avec différents paramètres, nous courrons un autre récipient comme agent de Drone, qui est responsable de la construction et de test des logiciels à partir des dépôts configurés.

Nous exécuterons ces deux conteneurs sur l’hôte Drone à l’aide de Docker Compose. Commencez par créer un répertoire de configuration pour stocker les fichiers dont nous aurons besoin:

sudo mkdir /etc/drone

Ensuite, nous allons créer quelques fichiers pour configurer nos services.

Créer un fichier de composition Docker pour drone

Commencez par créer un fichier Docker Compose dans le répertoire de configuration:

sudo nano /etc/drone/docker-compose.yml

À l’intérieur, nous marquerons le format de fichier de Docker Compose comme étant la version «3». Ensuite, nous définirons les services pour les deux services décrits ci-dessus.

Le service + drone-server + démarrera le conteneur du serveur Drone principal qui écoute sur le port 8000. Nous allons monter le répertoire + / var / lib / drone + de l’hôte à l’intérieur du conteneur afin que Drone puisse conserver ses données. Nous allons configurer le service pour qu’il redémarre automatiquement et qu’il lise des instructions de configuration plus détaillées sous la forme de variables d’environnement définies dans un fichier que nous allons créer dans + / etc / drone / server.env +.

Le service + drone-agent utilise la même image, démarrée avec la commande` + agent`. Il reçoit des instructions de l’instance du serveur Drone principal. Par conséquent, bien qu’il n’ait pas besoin d’un accès réseau général, il doit être démarré après le service Drone. Il doit également avoir accès au fichier de socket de Docker pour créer des conteneurs afin d’exécuter les étapes de construction et de test. Comme le service + drone-server +, ce service redémarrera automatiquement et lira un fichier d’environnement situé dans + / etc / drone / agent.env + pour une configuration supplémentaire.

Utilisez le fichier Docker Compose suivant pour configurer ces deux services. Portez une attention particulière au formatage du fichier YAML, car des erreurs d’indentation ou de formatage peuvent provoquer des erreurs:

/etc/drone/docker-compose.yml

version: '3'

services:
 drone-server:
   image: drone/drone:0.7
   ports:
     - 127.0.0.1:8000:8000
   volumes:
     - /var/lib/drone:/var/lib/drone
   restart: always
   env_file:
     - /etc/drone/server.env

 drone-agent:
   image: drone/drone:0.7
   command: agent
   depends_on:
     - drone-server
   volumes:
     - /var/run/docker.sock:/var/run/docker.sock
   restart: always
   env_file:
     - /etc/drone/agent.env

Lorsque vous avez terminé, enregistrez et fermez le fichier Docker Compose.

Configurer le fichier de variable d’environnement du serveur Drone

Ensuite, nous devons créer le fichier de variable d’environnement du serveur Drone que nous avons référencé dans le fichier Docker Compose ci-dessus.

Avant d’ouvrir le fichier, nous devrions générer une clé forte pour authentifier les composants de l’agent et du serveur. Bien que notre configuration comprenne ces deux composants sur le même serveur, une clé forte est essentielle pour la mise à niveau de votre infrastructure de test. Sur la ligne de commande, générez une clé en tapant:

LC_ALL=C </dev/urandom tr -dc A-Za-z0-9 | head -c 65 && echo

Cette commande définit temporairement la langue du shell sur une plage de caractères limitée. Il prend ensuite un flux d’octets aléatoires de + / dev / urandom + et filtre ensuite tous les caractères non alphanumériques. Nous prenons les 65 premiers caractères comme notre clé.

La sortie ressemblera à ceci (* Ne copiez pas la valeur ci-dessous! Générez le vôtre! *):

OutputERmA7xubDvTa8i0wYBlljc9yjT1NJPG7xOlZBwAdMAmBYL4RZE4QngxWcCLowk9KN

Copiez la clé générée à utiliser dans le fichier d’environnement du serveur.

Créez un nouveau fichier dans + / etc / drone / server.env + et ouvrez-le dans votre éditeur de texte:

sudo nano /etc/drone/server.env

À l’intérieur, nous définirons les variables d’environnement que Drone utilise pour se connecter afin de lier le service, se connecter au fournisseur de référentiel et définir les stratégies d’autorisation de compte. Vous aurez besoin des valeurs que vous avez copiées précédemment de votre fournisseur de référentiel pour les renseigner correctement.

Pour commencer, définissez les valeurs + DRONE_HOST + et + DRONE_SECRET +. Définissez + DRONE_SECRET + sur la clé que vous avez générée sur la ligne de commande. Le paramètre + DRONE_HOST + informe Drone de son adresse accessible au public. Ceci devrait être votre domaine protégé Let’s Encrypt, précédé du spécificateur de schéma + https: // +:

/etc/drone/server.env

# Service settings
DRONE_SECRET=
DRONE_HOST=https://

Ensuite, nous allons configurer l’intégration avec notre fournisseur VCS, qui est GitHub dans notre cas. Les paramètres appropriés pour votre projet peuvent varier en fonction de vos besoins et de la manière dont vos ressources GitHub sont organisées.

Nous allons verrouiller notre installation Drone et désactiver l’enregistrement ouvert en définissant + DRONE_OPEN + sur + + faux +. Cela signifie que seuls les noms de compte GitHub spécifiés dans + DRONE_ADMIN + pourront se connecter.

Assurez-vous que + DRONE_ADMIN + contient votre nom de compte GitHub.

Ensuite, activez le plug-in d’intégration GitHub en définissant + DRONE_GITHUB + sur + + vrai +. Nous assignerons ensuite + DRONE_GITHUB_CLIENT + et + DRONE_GITHUB_SECRET + aux clés que nous avons copiées à partir de la page de l’application GitHub OAuth lors de l’enregistrement de notre application Drone:

/etc/drone/server.env

# Service settings
DRONE_SECRET=
DRONE_HOST=https://

# Registration settings
DRONE_OPEN=false
DRONE_ADMIN=

# GitHub Settings
DRONE_GITHUB=true
DRONE_GITHUB_CLIENT=
DRONE_GITHUB_SECRET=

Nous avons fini de configurer le composant serveur. Avant de partir, copiez la valeur + DRONE_SECRET + à partir du fichier. Nous devrons définir cette même clé dans la section suivante lors de la configuration de l’agent. Enregistrez et fermez le fichier lorsque vous avez terminé.

Configurer le fichier de variable d’environnement de l’agent de drone

Ensuite, nous allons créer un fichier d’environnement pour le composant agent Drone.

Ouvrez un nouveau fichier pour définir les variables d’environnement de l’agent:

sudo nano /etc/drone/agent.env

A l’intérieur, il suffit de définir deux valeurs. Le + DRONE SECRET correspondra à la configuration du fichier` + server.env`.

Le paramètre + DRONE_SERVER + configurera le mode de connexion de l’agent au composant serveur Drone. Il commencera par un préfixe de protocole + wss: // + pour indiquer que la connexion utilisera un socket Web crypté suivi du nom de domaine du serveur Drone avec l’URI + / ws / broker + ajouté à la fin:

/etc/drone/agent.env

DRONE_SECRET=
DRONE_SERVER=wss:///ws/broker

Enregistrez et fermez le fichier lorsque vous avez terminé.

Configurer le fichier d’unité Drone Systemd

Maintenant que nos fichiers de configuration sont en place, nous pouvons définir un fichier unité systemd pour gérer le service Drone.

Ouvrez un nouveau fichier + .service dans le répertoire` + / etc / systemd / system` pour configurer le service:

sudo nano /etc/systemd/system/drone.service

Inside coller le contenu suivant:

/etc/systemd/system/drone.service

[Unit]
Description=Drone server
After=docker.service nginx.service

[Service]
Restart=always
ExecStart=/usr/local/bin/docker-compose -f /etc/drone/docker-compose.yml up
ExecStop=/usr/local/bin/docker-compose -f /etc/drone/docker-compose.yml stop

[Install]
WantedBy=multi-user.target

La première section indique à systemd de démarrer ce service après la disponibilité de Docker et de Nginx. La deuxième section indique au système init de redémarrer automatiquement le service en cas de défaillance. Il définit ensuite les commandes permettant de démarrer et d’arrêter le service Drone à l’aide de Docker Compose et du fichier de configuration créé précédemment. Enfin, la dernière section définit comment permettre au service de démarrer au démarrage.

Enregistrez et fermez le fichier lorsque vous avez terminé.

Avant de lancer le service Drone, nous devons configurer Nginx. L’agent Drone doit pouvoir se connecter au serveur Drone et la connexion dépend du proxy Nginx en place.

Configurer Nginx To Proxy Requests to Drone

Ensuite, nous devons modifier la configuration de Nginx pour que les requêtes proxy soient adressées à notre serveur Drone.

Commencez par rechercher la configuration de bloc de serveur qui gère votre domaine protégé par Let Encrypt. Recherchez l’attribut + nom_serveur + dans tous les blocs de serveur activés en tapant:

grep -R server_name /etc/nginx/sites-enabled

Output/etc/nginx/sites-enabled/default:   server_name ;
/etc/nginx/sites-enabled/default:   return 301 https://$server_name$request_uri;
/etc/nginx/sites-enabled/default:   server_name ;
/etc/nginx/sites-enabled/default:#  server_name example.com;

Dans la sortie ci-dessus, le nom de domaine (+ exemple.com + dans cet exemple) est défini dans le fichier + / etc / nginx / sites-enabled / default +. Vous voudrez éditer le fichier (la première colonne) associé à votre nom de domaine.

Il est possible que vous voyiez aussi quelque chose comme ceci:

Output/etc/nginx/sites-enabled/default:   server_name _;
/etc/nginx/sites-enabled/default:   return 301 https://$server_name$request_uri;
/etc/nginx/sites-enabled/default:   server_name _;
/etc/nginx/sites-enabled/default:#  server_name example.com;

Dans la sortie ci-dessus, les lignes + nom_serveur ; + représentent des blocs de serveur destinés à servir de mécanismes de secours. Le spécificateur d’hôte «

TOC