Play with an OpenShift PaaS using Docker

This post is based on material from Docker in Practice, available on Manning’s Early Access Program:

dip

Get Going

1) Allow any registry insecurely

This post is going to talk about playing with Kubernetes using Docker. Setting up Kubernetes can be a bit of a pain, but fortunately there’s a fast way to play with it.

To allow applications to contact the registry internal to OpenShift, you will need to start your Docker daemon allowing insecure registries. For simplicity we’re going to allow any registry to be accessed.

Change your Docker daemon configuration script

 DOCKER_OPTS="--insecure-registry 0.0.0.0/0"

or add the insecure-registry argument as above to the end of the existing uncommented DOCKER_OPTS line.

The file to change will depend on your distribution. systemd users will need to update /etc/sysconfig/docker; Ubuntu users /etc/default/docker

Once done, restart your docker daemon with eg:

sudo service docker restart

or

systemctl restart docker

2) Save some time by downloading some images in advance:

$ docker pull openshift/wildfly-8-centos

Run OpenShift

Run this:

$ docker run \
    -d \
    -v /var/run/docker.sock:/var/run/docker.sock \
    --name openshift-origin-play \
    --net=host \
    --privileged \
    dockerinpractice/openshift-origin-play start --loglevel=4 && \
docker exec -ti openshift-origin-play bash

You’re now in an OpenShift origin PaaS master and node.

Huh?

The above command’s a bit of a mouthful so let’s break it down.

docker run

Run up a container.

-d

Run the OpenShift origin server as a daemon.

 -v /var/run/docker.sock:/var/run/docker.sock

Use the docker server on the host from within the container. This allows us to run docker from within the origin container.

--name openshift-origin-play 

Give the container a name we can refer to; also, ensure that this can only be run one at a time (as each container name is unique on a host).

--net=host

Use the host’s network stack (ie don’t contain the network).

--privileged

Allow the container to run stuff with user privileged (well, we are just playing, right?)

dockerinpractice/openshift-origin-play

Use this as a base image. It’s the same as the openshift/origin image with a few things added for debugging and playing.

start &&

The default entrypoint (ie command) for this image is to run the openshift server. We pass the argument “start” to this to get the server to start up. If that’s successful…

docker exec -ti openshift-origin-play bash

we enter the container interactively (-ti) with the name we gave it early, running a bash process.

Look at the Console

Visit your OpenShift console at: https://localhost:8443/console and login with the username osuser and password dockerinpractice.

origin_1

Following the instructions there, let’s…

Start the Infrastructure

For convenience, and to avoid some troublesome issues we set a specific DNS server (we assume here that you have access to google’s DNS servers):

$ echo "nameserver 8.8.8.8" > /etc/resolv.conf

Set up the services OpenShift builds need:

$ openshift ex router --create --credentials=$KUBECONFIG
$ openshift ex registry --create --credentials=$KUBECONFIG

Create a Project

In OpenShift, a project is a namespace for a collection of applications.

$ openshift ex new-project movieplex --admin=anypassword:osuser

Now, to create an application we need to login as the admin user for the project.

$ su - osuser
$ osc login
Please provide the server URL or just <enter> to use 'https://localhost:8443': 
The server uses a certificate signed by unknown authority. You can bypass the certificate check but it will make all connections insecure.
Use insecure connections (strongly discouraged)? [y/N] y
Authenticate for "openshift"
Username: osuser
Password: 
Logged into 'https://localhost:8443' as 'osuser'.
Using project 'movieplex'.
Welcome to OpenShift v3! Use 'osc --help' for a list of commands available.
$ osc process -f https://raw.githubusercontent.com/ianmiell/javaee7-hol/master/application-template-jeebuild.json | osc create -f -
$ osc start-build jee-sample-build

And wait a long time (about 15 minutes for me on my machine).

While waiting run this:

$ osc get build
NAME TYPE STATUS POD
jee-sample-build-1 STI Pending jee-sample-build-1

The build status will change to “Running”, and eventually “Finished”.

Then you can view the application:

$ osc get service 
NAME LABELS SELECTOR IP PORT
frontend <none> name=frontend 172.30.17.59 8080
mysql <none> name=database 172.30.17.97 3306

We want to access the front end, so with the above output if you navigate to:

http://172.30.17.59:8080/movieplex7-1.0-SNAPSHOT/

you’ll see the movie app :)

origin_2

More to Come

There’s a lot more to this (which I’ll blog on), but this gives a taste of how scriptable deployments can be with OpenShift.

Source

The code for the example is available here:

git clone https://github.com/docker-in-practice/openshift-origin-play
Advertisements

Scale Your Jenkins Compute With Your Dev Team: Use Docker and Jenkins Swarm

This post is based on material from Docker in Practice, available on Manning’s Early Access Program:

dip

The Problem

At our company we had (another) problem. Our Jenkins server had apparently shrunk from what seemed like an over-spec’d monstrosity running a few jobs a day to a weedy-looking server that couldn’t cope with the hundreds of check-in-triggered jobs that were running 24/7.

Picture this:

Jenkins before

This approach clearly wouldn’t scale. Eventually servers died under the load as more and more jobs ran in parallel. Naturally this would happen when lots of check-ins were happening and the heat was on, so it was a high-visibility problem. We added more servers as a stop-gap, but that was simply putting more fingers in the dyke.

The Solution

Fortunately there’s a neat way around this problem.

Developer laptops tend to be quite powerful, so it’s only natural to consider using them. Wouldn’t it be great if you could allocate jobs to those multi-core machines that mostly lie idle while developers read Hacker News, and say “awesome” a lot?

Jenkins after

Traditionally, achieving this with VMs would be painful, and the overhead of allocating resources and running them on most machines unworkable.

With Docker it becomes easier. Docker containers can be set up that function as dynamic Jenkins slaves that are relatively unobtrusive. The Jenkins swarm plugin allows Jenkins to provision jobs to slaves dynamically.

Demo

Here’s a simple proof of concept to demonstrate the idea. You’ll need Docker installed, natch, but nothing else.

$ docker run -d \
    --name jenkins_server \
    -p 8080:8080 \
    -p 50000:50000 \
    dockerinpractice/jenkins
$ echo "Let's wait a couple of minutes for jenkins to start" && sleep 120
$ docker run -d \
    --hostname jenkins_swarm_slave_1 \
    --name jenkins_swarm_slave_1 \
    dockerinpractice/jenkins_swarm_slave

Navigate to your http://localhost:8080.

Check the swarm client has registered ok on the build executor status page.

jenkins1

Now set up a simple Jenkins job. I set one up to run “echo done” as a shell build step. Then click on “Restrict where this can be run” and apply the label “swarm”.

jenkins2

Run the job, then check the console output and you should see that ran the job on the swarm container.

jenkins3

There you have it!  A dynamic Jenkins slave running “anywhere”, making your Jenkins jobs scalable across your development effort.

Under the Hood

The default startup script for the jenkins_swarm_slave image is here.

This sets up these environment variables through defaults and introspection:

HOST_IP=$(ip route | grep ^default | awk '{print $3}')
JENKINS_SERVER=${JENKINS_SERVER:-$HOST_IP}
JENKINS_PORT=${JENKINS_PORT:-8080}
JENKINS_LABELS=${JENKINS_LABELS:-swarm}
JENKINS_HOME=${JENKINS_HOME:-$HOME}

Overriding any of these with the docker command line for your environment is trivial. For example, if your Jenkins server is at http://jenkins.internal:12345 you could run:

$ docker run -d \
    -e JENKINS_SERVER=jenkins.internal
    -e JENKINS_PORT=12345
    --name jenkins_server \
    -p 8080:8080 \
    -p 50000:50000 \
    -d dockerinpractice/jenkins_server

And to adapt this for your use case you’ll need to adapt the Dockerfile to install the software needed to run your jobs.

Final Thoughts

This may not be a solution fit for every organisation (security?), but those small-medium sized places that can implement this are the ones most likely to be feeling this pinch.

Oh, and remember that more compute is not always needed! Just because you can kick off that memory-hungry Java cluster regression test every time someone updates the README doesn’t mean you should…

It strikes us that there’s an opportunity for further work here.

  • Why not gamify your compute, so that developers that contribute more get credit?
  • Allow engineers to shut down jobs, or even make them more available at certain times of day?
  • Maybe telemetry in the client node could indicate how busy the machine its on is, and help it decide to accept the job or not?
  • Reporting on jobs that can’t complete, or find a home?

The possibilities are quite dizzying!

Docker in Practice – A Guide for Engineers

This post is based on material from Docker in Practice, available on Manning’s Early Access Program. Get 39% off with the code: 39miell

dip

We’re writing a book on Docker that’s focussed on its practical aspects.

dip

Why? James Turnbull’s “The Docker Book” is a great introduction to Docker for those that want a good grounding in the basics of Docker. And other books like Docker in Action are in the pipe that take you through the standard usage of Docker in detail.

But as busy engineers with day jobs we didn’t have the problem of getting to know Docker. We were sold on it, and wanted to know how to get this thing to useful, and fast. That meant overcoming all sorts of challenges both big and small, from the philosophical to the mundane. And in our own time to boot.

– Do we need to adopt a microservices architecture to make this work?

– Can this solve our capacity issues?

– How do we manage the way this is changing the way we work?

– Is it secure?

– How do we get the typical engineer to understand what’s going on? Where do they get lost?

– The ecosystem is overwhelming and growing every day! How do we navigate it?

– Does this replace VMs?

– What do we do about Configuration Management?

What we lacked was a coherent guide for these real-world problems. We went out and gave talks, built tools, wrote blogs, and lots of them, all with a slant of Docker’s use in the real world.

We first used Docker in anger at work in the fall of 2013. So by the time we were approached to write a book we knew what we wanted to communicate and had had over a year of real-world experience (or “the name we give to our mistakes”, as Oscar Wilde put it) to write up. And there was a happy ending – our organisation embraced Docker and saved a load of money in the process.

Writing a book on Docker is an interesting challenge as it intersects with so many different parts of the software lifecycle. So we cover a broad range of subjects.

The book is divided into four parts:

1) Docker Fundamentals

Where we give a brief introduction to Docker, its use and its architecture

2) Docker and Development

How Docker can be used by developers, some of the benefits, development patterns and pitfalls

3) Docker and DevOps

How Docker fits in with the test, continuous integration, and continuous delivery cycles

4) Docker in Production

Orchestration decisions, aspects of working systems, and how to deal with troubled waters

Each part contains discrete techniques where we discuss solutions to problems we’ve come across, or ideas to maximise the benefits of Docker adoption. But the arc of the narrative is: “Docker from desk to production”.

The book’s now available to buy on the Manning Early Access Program. You can get 50% off the book with the code ‘mlmiell’ and help to shape its content in the author forum.

This is a big technological shift, and we’re excited about being able to be part of it. We’re really interested in your experiences and views on the approach we’ve taken and solutions we’ve found.

The code for the book will be published and maintained here, and Docker images (of course!) available here.

Enjoy!

B_wac9EVEAAdGGL

This post is based on material from Docker in Practice, available on Manning’s Early Access Program. Get 39% off with the code: 39miell

dip

Fight Docker Package Drift!

Fight Docker Package Drift!

The Problem

While Dockerfiles can help enormously with pinning down the details of your build process, you can still fall victim to package drift. This is when package management changes behind the scenes, leaving you with nasty surprises to unpick.

You can specify the versions of your apt packages like this:

apt-get install package=version

but what about that package’s dependencies? And their dependencies? And so on…

“Solution”

The following command installs the given package you’re concerned with, and then spits out a Dockerfile RUN instruction with the specific versions used as dependencies. You can then place this into your Dockerfile, and if the build fails in the future, you’ll know something has changed.

The following example does this for vim, but you can change that package to whatever you like.

$ docker run imiell/get-versions vim
RUN apt-get install -y vim=2:7.4.052-1ubuntu3 vim-common=2:7.4.052-1ubuntu3 vim-runtime=2:7.4.052-1ubuntu3 libacl1:amd64=2.2.52-1 libc6:amd64=2.19-0ubuntu6.5 libc6:amd64=2.19-0ubuntu6.5 libgpm2:amd64=1.20.4-6.1 libpython2.7:amd64=2.7.6-8 libselinux1:amd64=2.2.2-1ubuntu0.1 libselinux1:amd64=2.2.2-1ubuntu0.1 libtinfo5:amd64=5.9+20140118-1ubuntu1 libattr1:amd64=1:2.4.47-1ubuntu1 libgcc1:amd64=1:4.9.1-0ubuntu1 libgcc1:amd64=1:4.9.1-0ubuntu1 libpython2.7-stdlib:amd64=2.7.6-8 zlib1g:amd64=1:1.2.8.dfsg-1ubuntu1 libpcre3:amd64=1:8.31-2ubuntu2 gcc-4.9-base:amd64=4.9.1-0ubuntu1 gcc-4.9-base:amd64=4.9.1-0ubuntu1 libpython2.7-minimal:amd64=2.7.6-8 mime-support=3.54ubuntu1.1 mime-support=3.54ubuntu1.1 libbz2-1.0:amd64=1.0.6-5 libdb5.3:amd64=5.3.28-3ubuntu3 libexpat1:amd64=2.1.0-4ubuntu1 libffi6:amd64=3.1~rc1+r3.0.13-12 libncursesw5:amd64=5.9+20140118-1ubuntu1 libreadline6:amd64=6.3-4ubuntu2 libsqlite3-0:amd64=3.8.2-1ubuntu2 libssl1.0.0:amd64=1.0.1f-1ubuntu2.8 libssl1.0.0:amd64=1.0.1f-1ubuntu2.8 readline-common=6.3-4ubuntu2 debconf=1.5.51ubuntu2 dpkg=1.17.5ubuntu5.3 dpkg=1.17.5ubuntu5.3 libnewt0.52:amd64=0.52.15-2ubuntu5 libslang2:amd64=2.2.4-15ubuntu1 vim=2:7.4.052-1ubuntu3

Take that RUN line that was output, and place in your Dockerfile, eg where you had

FROM ubuntu:14.04
RUN apt-get update && apt-get install -y vim

you would now have:

FROM ubuntu:14.04
RUN apt-get update && apt-get install -y vim=2:7.4.052-1ubuntu3 vim-common=2:7.4.052-1ubuntu3 vim-runtime=2:7.4.052-1ubuntu3 libacl1:amd64=2.2.52-1 libc6:amd64=2.19-0ubuntu6.5 libc6:amd64=2.19-0ubuntu6.5 libgpm2:amd64=1.20.4-6.1 [...]

If you try and rebuild this and something has changed, you’re far more likely to catch and identify it early. This should be particularly useful for those paranoid about any kind of changes to their builds. It won’t solve all Docker “build drift” problems, but it is a start.

Source

The source code for this is available here.

Note that this assumes a debian flavour of ubuntu:14.04. If you have a different base image, fork the repo and change the Dockerfile accordingly. Then, from the same directory:

$ docker build -t get-versions .
$ docker run get-versions vim

Help Wanted!

There are, I’m sure, plenty of improvements that could be made – maybe even scripts already in existence – to make this more robust and useful.

I’d also like to know if anyone can do this with other package managers.

If you have any ideas, do let me know: ian.miell@gmail.com

Win at 2048 with Docker and ShutIt (Redux)

This post is based on material from Docker in Practice, available on Manning’s Early Access Program. Get 39% off with the code: 39miell

dip

Steps to win at 2048

I blogged about this before, but have revisited it and made the process much easier and more robust.

1) To play 2048:

docker run -d -p 5901:5901 -p 6080:6080 --name win2048 imiell/win2048

2) Start up the vnc session:

vncviewer localhost:1

password for vnc is:

vncpass

Play for a bit.

3) When ready to “save game”:

docker tag -f my2048tag $(docker commit win2048)

Then, if you lose

4) go back to your save point with:

docker rm -f win2048
docker run -d -p 5901:5901 -p 6080:6080 --name win2048 my2048tag

and repeat steps 2) to 4) until you complete 2048!

Notes:

Command Annotations

docker run -d -p 5901:5901 -p 6080:6080 --name win2048 imiell/win2048

-d – run the container in daemon mode

-p … – publish ports related to vnc to the host

–name – give the container a name we can easily reference later

vncviewer localhost:1

Access the vncviewer on the ports  5901 and 6080.

docker tag -f my2048tag $(docker commit win2048)

The subshell (in italics) commits the files in the container to a docker image. The command returns a reference to the image that is in turn passed to the docker tag command. This forces the tag for the image to be set to my2048tag (or whatever you choose to call it.

docker rm -f win2048
docker run -d -P --name win2048 my2048tag

We must remove the container running so that the names don’t clash when we start it up again with docker run.

Build it Yourself

If you want to build the image yourself:

docker build https://raw.githubusercontent.com/ianmiell/shutit/master/library/win2048/Dockerfile

will make a local image you can tag. Code is here

Set Up a Deis (Docker-Friendly) Paas on Digital Ocean for $0.18 Per Hour in Six Easy Steps Using ShutIt

Introduction

What’s Deis?

Deis is an open source paas that is Docker-friendly.

What’s Digital Ocean?

A very cheap virtual private server provider like AWS, but simpler. Sign up here

What’s a Paas?

Platform as a service, like Heroku. Get an app deployed on demand.

What’s ShutIt?

A tool for automating complex deployments. More here

The Six Steps

1) Set up a Digital Ocean account

2) Get a personal access token by clicking on “Generate New Token”.

3) Set up a free temporary domain (if you don’t have a spare one)

I use dot.tk for this. I set up shutitdeis.tk there, for example.

Note that this script will wipe any pre-existing settings on Digital Ocean for this domain.If you create one as described above, there’s nothing to worry about.

4) Clone the repo

git clone https://github.com/ianmiell/shutit-coreos-do.git 

5) Copy and edit the Dockerfile subbing in your access token and domain

cd shutit-coreos-do/deis/dockerfile
cp Dockerfile.eg Dockerfile
sed -i 's/YOUR_ACCESS_TOKEN/<your access token here>/' Dockerfile
sed -i 's/YOUR_DOMAIN/<your domain here>/' Dockerfile

6) Run the build

docker build --no-cache .

and wait a good while. Well done! You’ve now got your own Deis cluster! Admin user is admin/admin

Use It

Instructions for use are here: http://docs.deis.io/en/v0.15.1/using_deis/

Here are some instructions to get you going. We’re going to deploy the example from here in the deis documentation:

curl -sSL http://deis.io/deis-cli/install.sh | sh
ln -fs $PWD/deis /usr/local/bin/deis  # or elsewhere on your path
deis login # <input admin/admin>
mkdir -p /tmp/example-go && cd /tmp/example-go
deis create 
#Creating application... done, created example-go
deis pull deis/example-go:latest 
#Creating build... done, v5 
curl -s http://example-go.<your domain>
#Powered by Deis

Be sure you switch it off before the hour is up or it will cost you another whole $0.18 per hour!

This method builds on the ShutIt project, and the ShutIt distro.

Any problems, please contact me below/via github issues/other social networks.

Create your own CoreOS cluster in 6 easy steps for $0.03

1) Set up a Digital Ocean account

2) Add your local ssh key

Get help with this here if needed.

3) Get a personal access token

by clicking on “Generate New Token”.

4) Clone the repo

git clone https://github.com/ianmiell/shutit-coreos-do.git 

5) Copy and edit the Dockerfile subbing in your access token

cd shutit-coreos-do/cluster_setup/dockerfile
cp Dockerfile.eg Dockerfile
sed -i 's/YOUR_ACCESS_TOKEN/<your access token here>/' Dockerfile

6) Run the build

docker build --no-cache .

Well done! You’ve now got your own CoreOS cluster! Note the IPs were output at the end, eg:

$ docker build --no-cache .
[...]
# BUILD REPORT FOR BUILD END f63c037a8591_root_1421241306.32.323376
###############################################################################

droplet_id: 3776278: ip address: 104.131.77.227
Log in with: ssh core@104.131.77.227
droplet_id: 3776289: ip address: 104.131.77.207
Log in with: ssh core@104.131.77.207
droplet_id: 3776299: ip address: 104.236.71.247
Log in with: ssh core@104.236.71.247

and now we can ssh in and run some cool CoreOS stuff:

ssh core@IP

For example, to list the machines in the cluster:

core@coreos-1 ~ $ fleetctl list-machines
MACHINE IP METADATA
1970b296... 10.132.129.104 -
6a06628e... 10.132.129.103 -
d07d7634... 10.132.129.83 -

Make sure you switch it off before the hour is up or it will cost you another whole $0.03 per hour!

This method builds on the ShutIt project, and the ShutIt distro.

Any problems, please contact me below/via github issues/other social networks.