Integrating Drone CI into Apache Mesos (Part 1)

Drone is a continuous integration (CI) tool, a tool whose aim is to automate the building, testing and deploying of software. There are many CI tools available, with a lot of feature overlap. A comparison will not be provided here; an entire post could be dedicated to a comparison.

Apache Mesos is a general purpose scheduling framework that abstracts the idea of processing power. An application would simply request that it requires a certain amount of resources and Mesos would run these applications on a series of slaves.

This project is a work in progress and this is the first in a series of posts documenting our development. In this part the goal is to gather all the dependencies and produce a simple working example of Drone working on a Mesos cluster.

The goal is to build install and run Drone on Mesos. In this part Drone is simply an application running on Mesos, not a framework. This will come in part 2. The tasks for this part are:

      1. Create a mesos cluster
      2. Build Drone
      3. Setup repository
      4. Setup Drone
      5. Run Drone standalone
      6. Run Drone in Mesos

1. Creating a mesos cluster

The first task is to create a mesos cluster. We found that the getting started guide from Mesosphere was the most comprehensive tutorial. Please see here.
Depending on where you run your cluster (e.g. on AWS? Locally?) the key was setting the hostname of each server. If using the Mesosphere method of installtion, you can simply add the public hostname of each server to /etc/mesos-slave/hostname for the slaves and /etc/mesos-master/hostname for the master. This will allow you to inspect the logs from the Mesos gui.

2. Building drone

Drone is currently under heavy development. The 0.4.0 branch has the most recent code but is unstable. An older version, where the bulk of the development was performed in April 2014, is available on the master branch. The aim of version 0.4 is to allow plugins for the backend database, building, queuing and deploying. The prospect of this amount of flexibility makes it a perfect choice for Mesos.

Before you build, make sure you have the most recent version of the 0.4.0 branch. Older versions would not build. To build, you will need Go 1.4.2 and the usual build-essentials-like package for your distribution. I would recommend building on Ubuntu. I would not recommend trying to build on a Mac.

To build, ensure that the drone repository is in the correct GOPATH structure. I.e. go/src/github.com/drone/drone. Then run:
make deps
make bindata
make build

This will produces two binaries in the bin folder. The drone binary is the server and the drone-agent is the optional remote builder (more about this in part 2).

Finally, you will need to install Docker in order to run builds.

3. Setup repository

I would recommend that you use github.com for testing. Drone should work with many providers, but we have only tested with github.

Follow these instructions to allow Drone to access your github account. You will require a client ID and a secret which you will enter into the Drone settings file (drone.toml).

4. Setup Drone

The Drone settings are provided by a toml config file. This should be passed into the Drone server binary as a command line argument. Our config file looks like this:
cert = ""
key = ""
secret = ""
expires = 0
path = "/etc/drone/drone.db"
cert = ""
key = ""
nodes = [
name = "github"
base = "https://github.com"
orgs = []
open = false
private_mode = false
skip_verify = true
secret = "YOURSECRET"
authorize = "https://github.com/login/oauth/authorize"
access_token = "https://github.com/login/oauth/access_token"
request_token = ""
secret = ""

Please add your github credentials to the file. Note that this config is different to their current documentation. The changes include:

      Adding: driver=”sqlite3″
      Changing expires to an int: expires = 0
      Only using one docker host

5. Run Drone standalone

First, I would run the drone server binary as a standalone application. It is easier to debug issues when standalone. To run:
/path/to/bin/drone --config=/path/to/config.toml

6. Run Drone in Mesos

To run in Mesos, we submitted our job through Marathon. You could simply run the command, although we decided to make life difficult by running Drone inside a Docker VM.

For this method, you must create a Dockerfile and a supervisord.conf file. Supervisord was required so that the Docker VM would start the Docker daemon, inside the Docker VM.

FROM ubuntu
RUN apt-get update && apt-get install -y wget build-essential
RUN wget https://storage.googleapis.com/golang/go1.4.2.linux-amd64.tar.gz
RUN tar -C /usr/local -xzf go1.4.2.linux-amd64.tar.gz
ENV PATH=$PATH:/usr/local/go/bin
ADD . /go/src/github.com/drone/drone/
WORKDIR /go/src/github.com/drone/drone
RUN apt-get install -y libsqlite3-dev sqlite3 gcc git
&& make deps bindata
&& make build
RUN wget -qO- https://get.docker.com/ | sh
RUN apt-get -y install supervisor &&
mkdir -p /var/log/supervisor &&
mkdir -p /etc/supervisor/conf.d
ADD ./supervisord.conf /etc/supervisor/conf.d/supervisord.conf
ENTRYPOINT ["/usr/bin/supervisord"]

command=/usr/bin/docker -d
command=/go/src/github.com/drone/drone/bin/drone --config=/go/src/github.com/drone/drone/config.toml

Then build the Dockerfile, from the drone/drone directory, with:
sudo docker build -t drone .

Finally, submit the job through the Marathon GUI using the following command (CMD):
sudo docker run --privileged --name drone --publish 80:80 --rm drone

Priviledged mode is required so that Docker can instantiate docker.

Hopefully, you should have an app in marathon:
Screen Shot 2015-05-27 at 14.27.41
An active task in mesos:
Screen Shot 2015-05-27 at 14.28.00
And the Drone UI!
Screen Shot 2015-05-27 at 14.28.10

What’s next?

After that rather painful experience, you might wonder why we bothered. We learnt a lot about Drone and about why a Mesos framework is necessary. Using a framework with pre-built binaries will make this process far simpler for the end user.

In the next part, we will develop a simple Mesos framework for Drone.

PS. Notes

Note that a lot of the Drone UI is broken.
Also note that you need to add a .drone.yml file to your repository and manually add the repository to drone. See https://github.com/arjang/drone-test for a quick example or the documentation from Drone.

This work is sponsored by Cisco building Microservices infrastructure.

The following two tabs change content below.

Philip Winder

Phil Winder is a multi-disciplinary consultant architect that specialises in the Research and Development of cutting edge technology. His expertise lies between the boundaries of Software Development and Machine Learning. Describing himself simply as an “Engineer”, he has 10 years experience in a wide range of Engineering disciplines (7 years software and machine learning, 3 years production electronics). Phil has Ph.D. and Masters degrees from the University of Hull, U.K. These were in Electronics, with a focus on embedded signal processing.

Latest posts by Philip Winder (see all)

Leave a Reply

Your email address will not be published. Required fields are marked *