This is the third part in a series that introduces you to basic web application containerization and deployment principles. If you’re new to the topic, I suggest reading Part 1 and Part 2 . In this post, I attempt to take the training wheels off, and focus on using Docker Compose. Speaking of training wheels, I rode my bike with training wheels until I was six or seven. So in the interest of full disclosure, I have to admit that to a certain degree I’m still riding the containerization wave with my training wheels on.
That’s not to say I’m not fully using container technology. Before transitioning to the cloud, I had a private registry running on a Git server that my build scripts pushed to and pulled from to automate deployments. Now, we deploy and maintain containers in much the same way as I’ve detailed in the first two Parts in this series, and I take advantage of the built-in registry covered in Part 2 of this series. Either way, our use case multi-tiered application architecture was just overkill. Adding to that, when we were still doing contract work, Docker was just getting 1.6 off the ground. Now that I’m working on a couple of projects where this will be a necessity, I’m thankful that Docker has expanded their offerings to include tools like Compose, Machine and Swarm. This post will provide a brief overview of a multi-tiered application setup with Docker Compose, so look for future posts to deal with the latter two. Of course, you can just hold out for a mature Kitematic and do it all in a GUI, but you probably won’t be reading this post if that applies to you.
All three of these Docker extensions are relatively new, and so the entirety of this post is subject to a huge disclaimer that even Docker hasn’t fully developed these extensions to be production-ready for large or intricate deployments. If you’re looking to do that, you’re best off holding out for my post on alternative deployment options like CoreOS and Kubernetes. But that’s beyond the scope of what we’re looking at here, so let’s get started.
First, you need to install the binary. Since this is part 3, I’m going to assume that you have the Docker Engine already installed somewhere. If you’re on Mac or Windows, the Docker Toolbox you used to install it also contained an option to install Compose. I’m going to assume your daily driver is a Linux box, so these instructions are for Linux. Fortunately, the installation should just be a couple of commands–curling it from the web and making it executable:
# curl -L https://github.com/docker/compose/releases/download/1.6.2/docker-compose-`uname -s`-`uname -m`
> /usr/local/bin/docker-compose
# chmod +x /usr/local/bin/docker-compose
# docker-compose -v
That last command should output version info if you’ve installed it correctly. For some reason, the linked installation doc thinks you can run that chmod as a regular user. I’m not sure of any distro that lets regular users write to /usr/local/bin, so I ran them both as root. Docker has its own security issues that are beyond the scope of this series, but I suggest reading about them if you’re using this in production. My lazy way around it is to run every Docker-related command elevated, and I’m sure someone will let me have it for that in the comments. Seems like a better policy than making /usr/local/bin writeable by anyone other than root.
Now that you have Compose installed, let’s look at how to use it to coordinate and deploy a layered application. I’m abandoning my sample music player of the previous two posts in favor of something that’s already separated its functionality, namely the Taiga project. If you’re not familiar, it’s a slick flat JIRA-killer, and the best part is that it’s open source with a thorough installation guide. I’ve done the heavy lifting, so all you have to do is clone the docker-taiga repo into wherever you keep your source code and get to Composin’.
$ git clone https://github.com/ndarwincorn/docker-taiga.git
$ cd docker-taiga
You’ll notice a few things. In the root of the app, there’s an .envfile where you can set all the environmental variables in one place. Next, there are two folders with taiga- prefixes. They correspond to the layers of the application, from the Angular frontend to the websocket and backend Django server. Each contains a Dockerfile for building the container, as well as relevant configuration files. There’s also a docker-entrypoint-initdb.d folder that contains a shell script that creates the Taiga database when the postgres container is built. Having covered container creation in part 1, I’m more concerned with the YAML file in the root of the application, docker-compose.yml.
This file coordinates the container/image creation for the application, and full reference can be found on Docker’s website. Long story short, the compose YAML file gives the containers a creation order (databases, backend/websocket, frontend) and links them together, so that ports exposed in each container don’t need to be published to the host machine. So, from the root of the application, let’s run a # docker-compose up and see what happens. Provided there are no errors, you should be able to navigate to localhost:8080 and see your new Taiga deployment!
You should be able to log in with the admin user and password 123123. Of course, there’s much more to do–configure automated e-mails, link it to your Github organization, configure TLS. I’ll leave that as an exercise for you. For now, enjoy your brand-new layered project management application. Of course, if you’re deploying such an application for an organization, you don’t want all your eggs in one basket. The next two parts in the series will deal with leveraging Docker tools and alternatives to deploy the application in a clustered, high-availability setup.
About the Author
Darwin Corn is a systems analyst for the Consumer Direct Care Network. He is a mid-level professional with diverse experience in the information technology world.
