I wrote a number of IRC bots a number of years ago, hosting them on my infrastructure. Since building a 3 node docker swarm, I decided that these would be good candidates to use in learning Jenkins for both auto building the software, and building containers. I hadn’t made my own dockerfiles before, nor had I setup proper builds outside of my IDE for these bots before.<\/p>\n\n\n\n\n\n\n\n
In order for Jenkins to build a docker container, it needs access to docker itself. This can be done by building a custom docker container for Jenkins that has the required dependencies. Since the plan was to use Ant to build the bots as well, this too was included in the Jenkins container. Below is the resulting Dockerfile.<\/p>\n\n\n\n
FROM jenkins\/jenkins:lts\nUSER root\nRUN apt-get update && \\\napt-get -y install apt-transport-https \\\n ca-certificates \\\n curl \\\n ant \\\n gnupg2 \\\n software-properties-common && \\\ncurl -fsSL https:\/\/download.docker.com\/linux\/$(. \/etc\/os-release; echo \"$ID\")\/gpg > \/tmp\/dkey; apt-key add \/tmp\/dkey && \\\nadd-apt-repository \\\n \"deb [arch=amd64] https:\/\/download.docker.com\/linux\/$(. \/etc\/os-release; echo \"$ID\") \\\n $(lsb_release -cs) \\\n stable\" && \\\napt-get update && \\\napt-get -y install docker-ce\nRUN apt-get install -y docker-ce\nRUN usermod -a -G docker jenkins\nUSER jenkins\n<\/pre>\n\n\n\nJenkins Plugins for Java\/Docker Pipeline<\/h2>\n\n\n\n
On first start of Jenkins, the default plugins were installed for use and the following plugins were added:<\/p>\n\n\n\n
I didn’t use any other plugins for my jenkins\/docker pipeline to get everything going.<\/p>\n\n\n\n
We needed to deploy Jenkins to the docker swarm cluster. This is a very simple compose file just pointing the cluster at the local build of Jenkins, providing a port to access the web GUI and a location for its data to exist within the gluster filesystem.<\/p>\n\n\n\n
---\nversion: \"3.2\"\n\nservices:\n jenkins:\n image: 127.0.0.1:5000\/jenkins\n ports:\n - \"8070:8080\"\n - \"50000:50000\"\n volumes:\n - \/mnt\/data\/jenkins:\/var\/jenkins_home\n - \/var\/run\/docker.sock:\/var\/run\/docker.sock<\/pre>\n\n\n\nOne aspect in this compose file is that docker.sock probably not needed since jenkins isn’t being used to update the docker services itself, though might be worth seeing if it can in a pipeline. This could be additional capability added in the future.<\/p>\n\n\n\n
Note: All of the docker-compose files included in this are deployed using docker stack deploy.<\/p>\n\n\n\n
Jenkins Rebuilding Jenkins and Reloading<\/h2>\n\n\n\n
I created a pipeline to build the Jenkins container from above and push it to the docker registry. Since this dockerfile is a part of a general GIT repo I have, I’ll need to get to the correct folder in that GIT repo before building. This is about the only interesting part of this Jenkins pipeline.<\/p>\n\n\n\n
pipeline {\n environment {\n registry = \"127.0.0.1:5000\/jenkins\"\n } \n agent any \n stages {\n stage('Git Pull') {\n steps{\n git 'https:\/\/github.com\/AeroSteveO\/Bash-Scripts.git'\n }\n }\n stage('Building image') {\n steps{\n dir(\"${env.WORKSPACE}\/Docker-Compose\/jenkins\"){ \n script {\n dockerImage = docker.build registry + \":latest\"\n }\n }\n }\n }\n \n stage('Deploy Image') {\n steps{\n script {\n docker.withRegistry( '' ) {\n dockerImage.push()\n }\n }\n }\n }\n }\n}<\/pre>\n\n\n\nJenkins Autobuild for Wheatley<\/h2>\n\n\n\n
The IRC bot projects were originally managed manually with NetBeans doing the builds, and manually pushing the new jar files to the server. I wanted a generic way to build it without using NetBeans, but still somewhat compatible, so I setup some ant scripts for building it that could be used with Jenkins.<\/p>\n\n\n\n
Since Ant is also capable of doing more than just build scripts, we’ll be using it to run the java applications as well. This at least gives us a single build and run script using Ant.<\/p>\n\n\n\n
<project name=\"Wheatley\" basedir=\".\" default=\"main\">\n\n\n <property name=\"src.dir\" value=\"src\"\/>\n\n <property name=\"build.dir\" value=\"build\"\/>\n <property name=\"classes.dir\" value=\"${build.dir}\/classes\"\/>\n <property name=\"jar.dir\" value=\"${build.dir}\/jar\"\/>\n\n <property name=\"main-class\" value=\"rapternet.irc.bots.wheatley.listeners.WheatleyMain\"\/>\n <property name=\"lib.dir\" value=\"lib\"\/>\n\n <path id=\"classpath\">\n <fileset dir=\"${lib.dir}\" includes=\"**\/*.jar\"\/>\n <\/path>\n\n\n <target name=\"clean\">\n <delete dir=\"${build.dir}\"\/>\n <\/target>\n\n <target name=\"compile\">\n <mkdir dir=\"${classes.dir}\"\/>\n <javac srcdir=\"${src.dir}\" destdir=\"${classes.dir}\" classpathref=\"classpath\"\/>\n <\/target>\n\n <target name=\"jar\" depends=\"compile\">\n <mkdir dir=\"${jar.dir}\"\/>\n <jar destfile=\"${jar.dir}\/${ant.project.name}.jar\" basedir=\"${classes.dir}\">\n <manifest>\n <attribute name=\"Main-Class\" value=\"${main-class}\"\/>\n <\/manifest>\n <\/jar>\n <\/target>\n\n <target name=\"run\" depends=\"jar\">\n <java fork=\"true\" classname=\"${main-class}\">\n <classpath>\n <path refid=\"classpath\"\/>\n <path location=\"${jar.dir}\/${ant.project.name}.jar\"\/>\n <\/classpath>\n\t<\/java>\n <\/target>\n\n <target name=\"clean-build\" depends=\"clean,jar\"\/>\n\n <target name=\"main\" depends=\"clean,run\"\/>\n<\/project><\/pre>\n\n\n\nJenkins Docker Container Build for Wheatley<\/h2>\n\n\n\n
After getting my projects to run with a general build script, I needed to work on a way to build a docker container for them. This was done with a simple base of using OpenJDK 8, copying in my libraries and source, and building everything.<\/p>\n\n\n\n
FROM openjdk:8-alpine\n\nRUN apk add --no-cache apache-ant\n\nCOPY . \/usr\/src\/wheatley\nWORKDIR \/usr\/src\/wheatley\nRUN ant clean-build\nCMD [\"ant\", \"run\"]<\/pre>\n\n\n\nThe pipeline to do the Jenkins build is simple enough, it performs a git pull, runs docker build, and then pushes that container into the registry.<\/p>\n\n\n\n
pipeline {\nenvironment {\nregistry = \"127.0.0.1:5000\/wheatley\"\n}\nagent any\nstages {\nstage('Git Pull') {\nsteps{\ngit 'https:\/\/github.com\/AeroSteveO\/Wheatley.git'\n}\n}\nstage('Building image') {\nsteps{\nscript {\ndockerImage = docker.build registry + \":latest\"\n}\n}\n}\nstage('Deploy Image') { steps{ script { docker.withRegistry( '' ) { dockerImage.push() } } } }<\/code>\n}\n}<\/pre>\n\n\n\nUpdating Code for use with Docker<\/h2>\n\n\n\n
The IRC bots were simple enough to update for running inside a docker container. When they were originally written, all of the input files were referenced from the directory the bots were running from. So step 1 of updating the code for docker was to provide a default path for the configuration files to be found at, and a way to tell them what that path was. This was done by using an environment variable to provide the path for the configurations to be stored at. Additional environment variables were added to provide a way to get defaults into the bot on first run before the configuration files are all populated.<\/p>\n\n\n\n
Docker Compose for the BotNet<\/h2>\n\n\n\n
Once the containers are being auto-built and sent to the registry, we need to start them up and provide for auto-updating. For docker-swarm, we can use shepherd<\/a> as the auto update service. Depending on the setup, we could use other services too<\/p>\n\n\n\n
- Shepherd<\/a>: Docker Swarm Update Service<\/li>
- WatchTower<\/a>: Single node docker update service<\/li><\/ul>\n\n\n\n
---\nversion: \"3.2\"\n\nservices:\n wheatley:\n image: 127.0.0.1:5000\/wheatley\n environment:\n BOT_CONFIG_FOLDER: \/config\/\n volumes:\n - \/mnt\/data\/wheatley:\/config\n\n triviabot:\n image: 127.0.0.1:5000\/triviabot\n environment:\n BOT_CONFIG_FOLDER: \/config\/\n volumes:\n - \/mnt\/data\/wheatley:\/config\n\n shepherd:\n build: .\n image: mazzolino\/shepherd\n environment:\n TZ: 'US\/Eastern'\n SLEEP_TIME: '5m'\n FILTER_SERVICES: ''\n VERBOSE: 'true'\n BLACKLIST_SERVICES: 'znc znc_znc'\n volumes:\n - \/var\/run\/docker.sock:\/var\/run\/docker.sock\n deploy:\n placement:\n constraints:\n - node.role == manager<\/pre>\n\n\n\nConclusion<\/h2>\n\n\n\n
The project was mostly a success. I have the two IRC bots I wrote auto building with Jenkins, deploying to my docker swarm cluster and starting up. This makes it much easier to deploy new versions rather than SCPing a new jar file to the server, killing the process and restarting it. The one aspect that isn’t working quite as expected is shepherd, it took a bit of configuration to keep it from trying to upgrade all containers on the swarm (focusing only on the locally created containers first). The log file shows that shepherd is running into issues when dealing with the local docker registry. This can be taken care of later, as we have the build working.<\/p>\n","protected":false},"excerpt":{"rendered":"
I wrote a number of IRC bots a number of years ago, hosting them on my infrastructure. Since building a 3 node docker swarm, I decided that these would be good candidates to use in learning Jenkins for both auto building the software, and building containers. I hadn’t made my own dockerfiles before, nor had … <\/p>\n