Dockerizing Web Application with Puppet

In post Installing Puppet Modules – Librarian Puppet we provisioned a Vagrant VM to install the puppet module from  Puppet Forge using librarian-puppet, now in this post we will do the same thing except we provision Docker container instead of Vagrant VM and deploy a hello-spring application in provisioned container.

Before starting with application deployment in Docker container let’s understand brief about Docker and how it is different from Virtual Machine.

What is Docker?

Docker is a high level abstraction over linux containers which manages the life cycle of containers. Docker allows to package an application with all of its dependencies into a standardize unit for software development. And if that unit runs on your local, we can guarantee that it will run exactly the same way, anywhere from QA, to staging, to production environments.

Docker vs Virtual Machine

Virtualization technologies like VirtualBox, VMWare, KVM, etc. use full machine virtualization whereas Docker share certain portions of the host kernel and operating system instance offering lower overhead at the cost of less isolation. Also, Docker provides a virtual environment that has its own CPU, memory, block I/O, network, etc. space using Cgroups features in Linux kernel on LXC host compared to virtualization technologies which offer us complete new virtual machine.
Now, let’s start with our deployment in container, following below steps:

Step 1: Create a directory with any name for me it’s docker and file with name Dockerfile and  Puppetfile inside the directory as follows:


$ mkdir docker
$ cd docker
$ touch Dockerfile Puppetfile

Dockerfile created above contains all the commands a user could call on the command line to assemble an image.

Puppetfile created above is a Ruby-based DSL specifies where puppet modules should be installed and where to fetch the modules from.

Step 2: Copy the below content in Puppetfile:

# Puppetfile Configuration for librarian-puppet.
forge "http://forge.puppetlabs.com"
mod "puppet-java8", :git => "https://github.com/arpitaggarwal/puppet-java8.git"
mod "arpitaggarwal/tomcat"

Step 3: Copy the below content in Dockerfile

FROM ubuntu:latest
MAINTAINER arpitaggarwal "aggarwalarpit.89@gmail.com"
RUN apt-get -y update
RUN apt-get -q -y install git
RUN sudo apt-get install -y ruby
RUN apt-get install -y ruby-dev
RUN apt-get -y update
RUN apt-get install -y make
RUN apt-get install -y build-essential
RUN apt-get install -y puppet
RUN gem install librarian-puppet
ADD Puppetfile /
RUN librarian-puppet install
RUN puppet apply --modulepath=/modules -e "include java8 class { 'tomcat':version => '7',java_home => '/usr/lib/jvm/java-8-oracle'}"
RUN apt-get remove -y make puppet build-essential ruby-dev

Step 4: Build the the application inside a docker directory, for me it’s hello-spring cloned from github:

$ git clone https://github.com/arpitaggarwal/hello-spring.git
$ cd hello-spring
$ mvn clean install

Step 5: Update the Dockerfile adding your .war file location using Docker COPY command:

COPY hello-spring/target/hello-spring.war /var/lib/tomcat7/webapps/
EXPOSE 8080

EXPOSE command specified above refers to Docker command which is good for inter-container communication.

Finally, Dockerfile should like as:

FROM ubuntu:latest
MAINTAINER arpitaggarwal "aggarwalarpit.89@gmail.com"
RUN apt-get -y update
RUN apt-get -q -y install git
RUN sudo apt-get install -y ruby
RUN apt-get install -y ruby-dev
RUN apt-get -y update
RUN apt-get install -y make
RUN apt-get install -y build-essential
RUN apt-get install -y puppet
RUN gem install librarian-puppet
ADD Puppetfile /
RUN librarian-puppet install
RUN puppet apply --modulepath=/modules -e "include java8 class { 'tomcat':version => '7',java_home => '/usr/lib/jvm/java-8-oracle'}"
RUN apt-get remove -y make puppet build-essential ruby-dev
COPY hello-spring/target/hello-spring.war /var/lib/tomcat7/webapps/
EXPOSE 8080

Step 6: Build the Docker container using Docker build command:


docker build --no-cache=true -t spring-application-container .

spring-application-container specified above refers to name of a docker image.

Step 7: Once built, run the container using Docker run command:

docker run -p 8080:8080 --cap-add SYS_PTRACE -it spring-application-container /bin/bash

Step 8: Get your Docker container IP Address, using docker-machine:


docker-machine ip your_vm_name

Next, open the url http://container-ip-address:8080/hello-spring

The complete source code is hosted on github.

Advertisements

Installing Puppet Modules – Librarian Puppet

Of course we can manually download the modules from Puppet Forge and install it but it becomes messy as you have to manually maintain the dependencies between the modules which definitely makes your repository bigger than necessary.

Already I briefed about librarian-puppet  in my Blog At Xebia, still to provide little more context, it manages the Puppet modules your infrastructure depends on, whether the modules come from the Puppet Forge, Git repositories or just a path. People who are familiar with Maven can relate librarian-puppet similar to it as it automatically download and manage dependent modules.

In this article we will learn how to install arpitaggarwal/tomcat Puppet Module using librarian-puppet. The complete source code is hosted on github.

Step 1: Create a directory with any name for me it’s vagrant, as follows:


$ mkdir vagrant
$ cd vagrant
$ vagrant init

Step 2: Edit the Vagrantfile with below content:


VAGRANTFILE_API_VERSION = "2"
Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
config.vm.box = "hashicorp/precise32"
config.vm.network :private_network, ip: "90.0.9.99"
config.vm.provision "shell", path: "installation-script.sh"
config.vm.provision :puppet do |puppet|
puppet.manifests_path = 'puppet/manifests'
puppet.module_path = 'puppet/modules'
puppet.manifest_file ="init.pp"
end
end

Step 3:  Create installation-script.sh in your current project directory(vagrant), which will install, librarian-puppet, it’s dependency GIT and Puppet in your guest machine, as follows:


$ touch installation-script.sh

Content of installation-script.sh should look something like this:


#!/usr/bin/env bash
set -e
# Directory in which PuppetFile is placed to be scanned by librarian-puppet.
PUPPET_DIR=/vagrant/puppet

echo "Installing Git.."
apt-get -q -y install git

echo "Installing librarian-puppet.."
if [ "$(gem search -i librarian-puppet)" = "false" ]; then
RUBY_VERSION=$(ruby -e 'print RUBY_VERSION')
case "$RUBY_VERSION" in
1.8.*)
# For ruby 1.8.x librarian-puppet needs to use 'highline' 1.6.x
# highline >= 1.7.0 requires ruby >= 1.9.3
gem install highline --version "~>1.6.0" > /dev/null 2>&1
# Install the most recent 1.x.x version, but not 2.x.x which needs Ruby 1.9
gem install librarian-puppet --version "~>1"
;;
*)
gem install librarian-puppet
;;
esac
fi
echo "librarian-puppet installed!"

echo "Executing PuppetFile.."
cd $PUPPET_DIR && librarian-puppet install --path modules

echo "Installing Puppet repo for Ubuntu 12.04 LTS"
wget -qO /tmp/puppetlabs-release-precise.deb \
https://apt.puppetlabs.com/puppetlabs-release-precise.deb
dpkg -i /tmp/puppetlabs-release-precise.deb
rm /tmp/puppetlabs-release-precise.deb
aptitude update
echo Installing puppet
aptitude install -y puppet
echo "Puppet installed!"

Step 4: Make directory puppet and then modules and manifests under it, as follows:


$ mkdir puppet
$ cd puppet/
$ touch Puppetfile
$ mkdir modules
$ mkdir manifests
$ cd manifests
$ touch init.pp

Content of Puppetfile should look like:


forge "http://forge.puppetlabs.com"
mod "arpitaggarwal/tomcat"

Content of puppet/manifests/init.pp should look like:


class { 'tomcat': }

After performing all the above steps, your project structure should look like as:

Step 6: Now you can boot up your VM provisioned with Tomcat from the vagrant directory executing command:


$ vagrant up

That’s all. Happy Learning!