This post is part 2 in a series of Docker posts hashing out a new docker workflow for our team. To gain background of what I want to accomplish with docker, checkout my previous post hashing out a docker workflow.
In this post, we will venture into setting up docker locally, in the same repeatable way from developer to developer, by using Vagrant. By the end of this post, we’ll have Drupal running in a container, using Docker. This post is focused on hashing out a Docker workflow with Vagrant, less about Drupal itself. I want to give a shout out to the folks that maintain the Drupal Docker image in the Docker Registry. It’s definitely worth checking out, and using that as a base to build
FROM for your custom images.
Running Docker Locally
There are several ways to go about setting up Docker locally. I don’t intend to walk you through how to install Docker, you can find step-by-step installation instructions based on your OS in the Docker documentation. However, I am leaning toward taking an unconventional approach to installing Docker locally, not mentioned in the Docker documentation. Let me tell you why.
Running a Docker host
For background, we are specifically an all Mac OS X shop at ActiveLAMP, so I’ll be speaking from this context.
Unfortunately you can’t run Docker natively on OS X, Docker needs to run in a Virtual Machine with an operating system such as Linux. If you read the Docker OS X installation docs, you see there are two options for running Docker on Mac OS X, Boot2Docker or Kitematic.
Running either of these two packages looks appealing to get Docker up locally very quickly (and you should use one of these packages if you’re just trying out Docker), but thinking big picture and how we plan to use Docker in production, it seems that we should take a different approach locally. Let me tell you why I think you shouldn’t use Boot2Docker or Kitematic locally, but first a rabbit trail.
Thinking ahead (the rabbit trail)
My opinion may change after gaining more real world experience with Docker in production, but the mindset that I’m coming from is that in production our Docker hosts will be managed via Chef.
Our team has extensive experience using Chef to manage infrastructure at scale. It doesn’t seem quite right to completely abandon Chef yet, since Docker still needs a machine to run the Docker host. Chef is great for machine level provisioning.
My thought is that we would use Chef to manage the various Docker hosts that we deploy containers to and use the Dockerfile with Docker Compose to manage the actual app container configuration. Chef would be used in a much more limited capacity, only managing configuration on a system level not an application level. One thing to mention is that we have yet to dive into the Docker specific hosts such as AWS ECS, dotCloud, or Tutum. If we end up adopting a service like one of these, we may end up dropping Chef all together, but we’re not ready to let go of those reigns yet.
One step at a time for us. The initial goal is to get application infrastructure into immutable containers managed by Docker. Not ready to make a decision on what is managing Docker or where we are hosting Docker, that comes next.
Manage your own Docker Host
The main reason I was turned off from using Boot2Docker or Kitematic is that it creates a Virtual Machine in Virtualbox or VMWare from a default box / image that you can’t easily manage with configuration management. I want control of the host machine that Docker is run on, locally and in production. This is where Chef comes into play in conjunction with Vagrant.
Local Docker Host in Vagrant
As I mentioned in my last post, we are no stranger to Vagrant. Vagrant is great for managing virtual machines. If Boot2Docker or Kitematic are going to spin up a virtual machine behind the scenes in order to use Docker, then why not spin up a virtual machine with Vagrant? This way I can manage the configuration with a provisioner, such as Chef. This is the reason I’ve decided to go down the Vagrant with Docker route, instead of Boot2Docker or Kitematic.
The latest version of Vagrant ships with a Docker provider built-in, so that you can manage Docker containers via the Vagrantfile. The Vagrant Docker integration was a turn off to me initially because it didn’t seem it was very Docker-esque. It seemed Vagrant was just abstracting established Docker workflows (specifically Docker Compose), but in a Vagrant syntax. However within the container Vagrantfile, I saw you can also build images from a Dockerfile, and launch those images into a container. It didn’t feel so distant from Docker any more.
It seems that there might be a little overlap in areas between what Vagrant and Docker does, but at the end of the day it’s a matter of figuring out the right combination of using the tools together. The boundary being that Vagrant should be used for “orchestration” and Docker for application infrastructure.
When all is setup we will have two Vagrantfiles to manage, one to define containers and one to define the host machine.
Setting up the Docker Host with Vagrant
The first thing to do is to define the
Vagrantfile for your host machine. We will be referencing this Vagrantfile from the container Vagrantfile. The easiest way to do this is to just type the following in an empty directory (your project root):
$ vagrant init ubuntu/trusty64
You can configure that Vagrantfile however you like. Typically you would also use a tool like Chef solo, Puppet, or Ansible to provision the machine as well. For now, just to get Docker installed on the box we’ll add to the Vagrantfile a provision statement. We will also give the Docker host a hostname and a port mapping too, since we know we’ll be creating a Drupal container that should
EXPOSE port 80. Open up your Vagrantfile and add the following:
config.vm.hostname = "docker-host" config.vm.provision "docker" config.vm.network :forwarded_port, guest: 80, host: 4567
This ensures that Docker is installed on the host when you run
vagrant up, as well as maps port
4567 on your local machine to port
80 on the Docker host (guest machine). Your Vagrantfile should look something like this (with all the comments removed):
# -*- mode: ruby -*- # vi: set ft=ruby : Vagrant.configure(2) do |config| config.vm.box = "ubuntu/trusty64" config.vm.hostname = "docker-host" config.vm.provision "docker" config.vm.network :forwarded_port, guest: 80, host: 4567 end
Note: This post is not intended to walk through the fundamentals of Vagrant, for further resources on how to configure the Vagrantfile check out the docs.
As I mentioned earlier, we are going to end up with two Vagrantfiles in our setup. I also mentioned the container Vagrantfile will reference the host Vagrantfile. This means the container Vagrantfile is the configuration file we want used when
vagrant up is run. We need to move the host Vagrantfile to another directory within the project, out of the project root directory. Create a host directory and move the file there:
$ mkdir host $ mv Vagrantfile !$
Bonus Tip: The
!$ destination that I used when moving the file is a shell shortcut to use the last argument from the previous command.
Define the containers
Now that we have the host Vagrantfile defined, lets create the container Vagrantfile. Create a Vagrantfile in the project root directory with the following contents:
# -*- mode: ruby -*- # vi: set ft=ruby : Vagrant.configure(2) do |config| config.vm.provider "docker" do |docker| docker.vagrant_vagrantfile = "host/Vagrantfile" docker.image = "drupal" docker.ports = ['80:80'] docker.name = 'drupal-container' end end
To summarize the configuration above, we are using the Vagrant Docker provider, we have specified the path to the Docker host Vagrant configuration that we setup earlier, and we defined a container using the Drupal image from the Docker Registry along with exposing some ports on the Docker host.
Start containers on
Now it’s time to start up the container. It should be as easy as going to your project root directory and typing
vagrant up. It’s almost that easy. For some reason after running
vagrant up I get the following error:
A Docker command executed by Vagrant didn't complete successfully! The command run along with the output from the command is shown below. Command: "docker" "ps" "-a" "-q" "--no-trunc" Stderr: Get http:///var/run/docker.sock/v1.19/containers/json?all=1: dial unix /var/run/docker.sock: permission denied. Are you trying to connect to a TLS-enabled daemon without TLS? Stdout:
I’ve gotten around this is by just running
vagrant up again. If anyone has ideas what is causing that error, please feel free to leave a comment.
Drupal in a Docker Container
You should now be able to navigate to
http://localhost:4567 to see the installation screen of Drupal. Go ahead and install Drupal using an sqlite database (we didn’t setup a mysql container) to see that everything is working. Pretty cool stuff!
There are other things I want to accomplish with our local Vagrant environment to make it easy to develop on, such as setting up synced folders and using the
vagrant rsync-auto tool. I also want to customize our Drupal builds with Drush Make, to make developing on Drupal much more efficient when adding modules, updating core, etc… I’ll leave those details for another post, this post has become very long.
As you can see, you don’t have to use Boot2Docker or Kitematic to run Docker locally. I would advise that if you just want to figure out how Docker works, then you should use one of these packages. Thinking longer term, your local Docker Host should be managed the same way your production Docker Host(s) are managed. Using Vagrant, instead of Boot2Docker or Kitematic, allows me to manage my local Docker Host similar to how I would manage production Docker Hosts using tools such as Chef, Puppet, or Ansible.
In my next post, I’ll build on what we did here today, and get our Vagrant environment into a working local development environment.