Last weekend I deployed an app using Vagrant, so this weekend I decided to deploy the same app with Docker, to see the differences. I’ll talk through that a bit, and then the specifics of Docker.

Vagrant vs. Docker

That image sums it up pretty well (Vagrant on the left, Docker on the right). Basically, when using Vagrant, each container has its own Linux operating system, and requires all dependencies to be installed on each machine. Using Docker, each container can use the host’s operating system and can share dependencies. For example, if the host already has Rails installed on it, and you create a new Docker container that also requires Rails, it won’t download another copy, making it much more lightweight than Vagrant VMs.

Dependencies

Dockerfile

Create a file in the root directory of your app called Dockerfile. Mine contains exactly one line of code: FROM rails:onbuild. This resource contains general information about building a rails app, but also says this about the onbuild command: This image includes multiple ONBUILD triggers which should cover most applications. The build will COPY . /usr/src/app, RUN bundle install, EXPOSE 3000, and set the default command to rails server.

docker-compose.yml

This is where the meat of it happens. This file also goes in the root directory of your app. Mine looks like this:

version: '2' 
services:
db:
image: postgres
ports:
- "5432:5432"
web:
build: .
command: bundle exec rake db:create db:migrate
command: bundle exec rails s -p 3000 -b '0.0.0.0'
volumes:
- .:/myapp
ports:
- "3000:3000"
links:
- db
depends_on:
- db
environment:
- KEY=your-key-here

Here’s what all that means:

  • Under services, there are two sections called web and db respectively. This means that I am building two containers, one which will hold my app, and the other will hold my database.
  • Within the db section, the image: postgres tells Docker that PostgreSQL is a dependency of my app, and it will install it if it’s not already on the host.
  • The portscommand in both sections exposes the ports for the database and the application — Docker doesn’t do this autmatically. You can expose the internal ports externally as any port you want. For example, you could say ports:- “80:3000”, and what is port 3000 inside the container (Rails’ default port), would be exposed as port 80.
  • The commands lines are fairly obvious: they run those commands, creating and migrating my database, and starting the server. These need to be done in that order.
  • A volume is basically a directory, and tells Docker where to save my app.
  • The links and depends_on sections allow the web and db containers to communicate, which they can’t automatically do. The depends_on section will also determine the order in which the containers are started — the database will be started prior to the application.
  • The environments section contains your environmental variables. My real ones aren’t included here, obviously, but the formatting shown is what it should look like.

Making it all happen!

All that’s left to do is run two commands:

  • docker-compose build
  • docker-compose up

You can then run docker-machine ip and navigate to that IP address at the port you specified to see your app up and running!

Senior Software Engineer | www.adriennedomingus.com

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store