{"id":2880,"date":"2016-04-29T10:20:38","date_gmt":"2016-04-29T16:20:38","guid":{"rendered":"http:\/\/dev.iachieved.it\/iachievedit\/?p=2880"},"modified":"2020-07-14T22:08:35","modified_gmt":"2020-07-15T03:08:35","slug":"an-arm-build-farm-with-jenkins","status":"publish","type":"post","link":"https:\/\/dev.iachieved.it\/iachievedit\/an-arm-build-farm-with-jenkins\/","title":{"rendered":"An ARM Build Farm with Jenkins"},"content":{"rendered":"

There was a time when setting up a Continuous Integration server took a lot of work. I personally have spent several days wrestling with getting CruiseControl<\/a> installed, configured, and working just right. Today it is much more straightforward and, for the most part, a simple apt-get install jenkins<\/code> is all it takes to get a functional Jenkins CI server<\/a> up and running.<\/p>\n

In this tutorial we’re going to look at using Jenkins to set up a build farm<\/a> of ARM systems. My personal interest in doing so is to support the Swift on ARM<\/a> group of folks working to get Swift 3.0 support for ARMv7 devices such as the Raspberry Pi 2, BeagleBone Black, etc. While support for cross-compiling Swift is maturing there is still a desire to natively compile on an ARM system.<\/p>\n

The Jenkins Build Server<\/h2>\n

To make things simple we’re going to focus on installing Jenkins on an Ubuntu 14.04 server. Using the instructions on the Jenkins Wiki<\/a> for an Ubuntu 14.04 system:<\/p>\n

\nwget -q -O - https:\/\/jenkins-ci.org\/debian\/jenkins-ci.org.key | sudo apt-key add -\nsudo sh -c 'echo deb http:\/\/pkg.jenkins-ci.org\/debian binary\/ > \/etc\/apt\/sources.list.d\/jenkins.list'\nsudo apt-get update\nsudo apt-get install jenkins\n<\/pre>\n
The Jenkins daemon will start automatically upon installation.  Once it does, open a browser and go to http:\/\/YOUR_HOST:8080\/, where YOUR_HOST is the server you just installed Jenkins on.<\/p>\n
\"Unlock!\"<\/a>
Unlock!<\/figcaption><\/figure>\n
The initial password can be found on the Jenkins server with sudo cat \/var\/lib\/jenkins\/secrets\/initialAdminPassword<\/code>, and will be something like “54d5f68be4554b5c8316689728721b37”.  Paste it in and click Continue<\/b>.<\/p>\n
You’ll be prompted to choose whether or not to install suggested plugins or specifically select plugins.  Go with Install suggested plugins<\/b> for now.  The next screen will be all of the plugins being loaded in.  Once complete you’ll move on to creating the first admin user:<\/p>\n
\"Create<\/a>
Create an Admin User<\/figcaption><\/figure>\n
Once entering the admin user information, you’ll see Jenkins is ready!<\/p>\n
\"Yes!\"<\/a>
Yes!<\/figcaption><\/figure>\n
Click that Start using Jenkins<\/b> button and (wait for it), start using Jenkins.<\/p>\n
Build Agents<\/h2>\n
We’re interested in using Jenkins to perform native builds on ARM systems.  To that end we’ll add slave nodes to our build server.<\/p>\n
First, let’s make sure we have an ARM system to compile on.  I’ve become a big fan of using Scaleway<\/a> for spinning up ARM systems.  If you have your own ARM device such as BeagleBoard or Raspberry Pi, those will work as well, just be aware that compiling on single-core ARM devices with limited RAM can be, well, painful.  With Scaleway you can spin up quad-core ARM systems with 2G of RAM for about $3.50 a month.<\/p>\n
I’m going to assume you have an ARM system (either from Scaleway or a physical device that your Jenkins host can communicate with).  Let’s look at what it takes to get things configured.  There’s a bit of a dance to do to ensure that the master and slave can communicate with each other.  In short we need to:<\/p>\n