{"id":8215,"date":"2015-11-09T12:15:49","date_gmt":"2015-11-09T10:15:49","guid":{"rendered":"http:\/\/www.webcodegeeks.com\/?p=8215"},"modified":"2015-12-16T10:49:42","modified_gmt":"2015-12-16T08:49:42","slug":"deploying-docker-rails-app","status":"publish","type":"post","link":"https:\/\/www.webcodegeeks.com\/ruby\/deploying-docker-rails-app\/","title":{"rendered":"Deploying Your Docker Rails App"},"content":{"rendered":"

In a previous article by Marko Locher, we learned how to run a Rails development environment in Docker<\/a>. Marko also wrote about how to test a Rails app with Docker<\/a>. So assuming we have our dev environment set up, our app is tested (and the tests are passing), we\u2019re ready to think about deploying our application to production. If you haven\u2019t yet, I recommend reading those two articles first to get a good overview of how Docker works.<\/p>\n

In this article, we\u2019ll talk about how to deploy our Docker container quickly and simply to Heroku. Once we\u2019re done with that, we\u2019ll investigate how to build a production Docker image using a minimal base which doesn\u2019t include development dependencies. Then we\u2019ll push our image to the Docker Hub and deploy it to a server.<\/p>\n

Simple Rails Docker on Heroku<\/h2>\n

Most Rails developers are familiar with Heroku and have probably at one time or another deployed an app to it, even if it was just a personal blog or something you were playing around with. I\u2019ve used Heroku both for personal projects and also for larger client projects with lots of success. Heroku isn\u2019t just for Rails apps\u2026 you can deploy PHP apps, NodeJS apps, Elixir apps, and as of earlier this year you can even deploy Docker containers<\/a>.<\/p>\n

Getting set up<\/h3>\n

The first thing you\u2019ll need to do is install the heroku-docker plugin for the Heroku toolbelt: heroku plugins:install heroku-docker<\/code><\/p>\n

Once you\u2019ve set up a normal Rails app (either new or existing), you\u2019ll need to add an additional file to the root called app.js<\/code>.<\/p>\n

{\r\n  \"name\": \"My App Name\",\r\n  \"description\": \"An example app.json for heroku-docker\",\r\n  \"image\": \"heroku\/ruby\",\r\n  \"addons\": [\r\n    \"heroku-postgresql\"\r\n  ]\r\n}<\/pre>\n
Heroku has a number of different images you can use for each of the different languages they support. Next we\u2019ll create a file called Procfile<\/code> which Heroku uses to help start our app.<\/p>\n
web: bundle exec puma -C config\/puma.rb<\/pre>\n
The next step is to generate a new Dockerfile<\/a>. We can use Heroku\u2019s toolbelt for this and by running the command heroku docker:init<\/code> we\u2019ll get both a Dockerfile<\/code> file and a docker-compose.yml<\/code> file.<\/p>\n
The Dockerfile is extremely small, only pulling from the heroku\/ruby<\/code> image:<\/p>\n
FROM heroku\/ruby<\/pre>\n
The docker-compose.yml<\/code> file is a little more involved and sets up two linked images (one for Ruby\/Rails and one for Postgres):<\/p>\n
web:\r\n  build: .\r\n  command: 'bash -c ''bundle exec puma -C config\/puma.rb'''\r\n  working_dir: \/app\/user\r\n  environment:\r\n    PORT: 8080\r\n    DATABASE_URL: 'postgres:\/\/postgres:@herokuPostgresql:5432\/postgres'\r\n  ports:\r\n    - '8080:8080'\r\n  links:\r\n    - herokuPostgresql\r\nshell:\r\n  build: .\r\n  command: bash\r\n  working_dir: \/app\/user\r\n  environment:\r\n    PORT: 8080\r\n    DATABASE_URL: 'postgres:\/\/postgres:@herokuPostgresql:5432\/postgres'\r\n  ports:\r\n    - '8080:8080'\r\n  links:\r\n    - herokuPostgresql\r\n  volumes:\r\n    - '.:\/app\/user'\r\nherokuPostgresql:\r\n  image: postgres<\/pre>\n
One great benefit of Heroku Docker is that not only can you deploy Docker containers to Heroku, but you can also use this to run a \u201cHeroku-like\u201d environment locally for development.<\/p>\n
You\u2019ll notice that there is an environment variable called DATABASE_URL<\/code> in this file. We can modify our database.yml<\/code> file to use this ENV variable to connect to the database.<\/p>\n
default: &default\r\n  adapter: postgresql\r\n  encoding: unicode\r\n  pool: 5\r\n  timeout: 5000\r\n  username: postgres\r\n  host: <%= ENV['DATABASE_URL'] %><\/pre>\n
We\u2019ll be using the Puma web server<\/a> for this Rails application, and we need to set up a config file located in config\/puma.rb<\/code>. Please make sure that you have puma<\/code> in your Gemfile as well!<\/p>\n
port ENV['PORT'] || 3000\r\nenvironment ENV['RACK_ENV'] || 'development'<\/pre>\n
Up and running locally<\/h3>\n
To run this app locally in the Docker container you can use the following command, which at this point is straight-up Docker and Docker Compose (rather than something specific to Heroku):<\/p>\n
docker-compose up web<\/pre>\n
This command will open the app in the browser with the correct IP address:<\/p>\n
open \"http:\/\/$(docker-machine ip default):8080\"<\/pre>\n
If all worked well you should be able to see your app running within the Heroku\/Ruby Docker container.<\/p>\n
Deploying to Heroku<\/h3>\n
To deploy to Heroku we\u2019ll first need to make sure we have created an app on Heroku. Take note of the name they gave to your app in the output.<\/p>\n
heroku create<\/pre>\n
After that we can deploy it using the following command. Keep in mind that you should use your app name on Heroku, not mine:<\/p>\n
heroku docker:release --app warm-fortress-1700<\/pre>\n
Once it is done deploying (which will take a few minutes the first time as it uploads the somewhat large image slug to Heroku), you can open it in the browser using the command heroku open<\/code>.<\/p>\n
!New Call-to-action<\/p>\n
Building a Minimal Production Image<\/h2>\n
When building for a production release, you\u2019ll want to keep your Docker images as lightweight as possible to avoid using up server resources. One of the ways you can do this is by using a trimmed-down Linux distro such as Alpine<\/a>. CenturyLink has a great Docker image<\/a> available that we can use as our base image.<\/p>\n
I have created a Dockerfile.prod<\/code> file as a way to add a couple extra commands that aren\u2019t needed when working in a development environment.<\/p>\n
Dockerfile FROM centurylink\/alpine-rails\r\n\r\n# Configure the main working directory. This is the base\r\n# directory used in any further RUN, COPY, and ENTRYPOINT\r\n# commands.\r\nRUN mkdir -p \/app \r\nWORKDIR \/app\r\n\r\n# Copy the Gemfile as well as the Gemfile.lock and install\r\n# the RubyGems. This is a separate step so the dependencies\r\n# will be cached unless changes to one of those two files\r\n# are made.\r\nCOPY Gemfile Gemfile.lock .\/ \r\nRUN gem install bundler && bundle install --jobs 20 --retry 5 --without development test\r\n\r\n# Set Rails to run in production\r\nENV RAILS_ENV production \r\nENV RACK_ENV production\r\n\r\n# Copy the main application.\r\nCOPY . .\/\r\n\r\n# Precompile Rails assets\r\nRUN bundle exec rake assets:precompile\r\n\r\n# Start puma\r\nCMD bundle exec puma -C config\/puma.rb<\/pre>\n
In this file I\u2019ve run bundle install<\/code> with the --without development test<\/code> flag to avoid Gems we don\u2019t need in our production environment. I\u2019ve set ENV variables called RAILS_ENV and RACK_ENV to production. And lastly I\u2019ve precompiled the assets so that the image will already have all precompiled assets and we won\u2019t need to do that again after deploy. It\u2019s all about making sure our production image is as efficient and small as possible.<\/p>\n
Let\u2019s build our production image:<\/p>\n
docker build -t leighhalliday\/rails-alpine -f .\/Dockerfile.prod .<\/pre>\n
Notice we\u2019ve included the -f<\/code> directive with a filename to point to our Dockerfile.prod<\/code> file instead of the usual Dockerfile<\/code>.<\/p>\n
Pushing Our Image to Docker Hub<\/h2>\n
We\u2019ve built our image locally, but it\u2019s time to push it to Docker Hub. Docker Hub functions very much like GitHub where there are public images and private images. For this demo we\u2019ll be using a public one, but if this is for your company you\u2019d probably want to go with the private version.<\/p>\n
docker push leighhalliday\/rails-alpine<\/pre>\n
It is now available at https:\/\/hub.docker.com\/r\/leighhalliday\/rails-alpine\/<\/a>.<\/p>\n
Deploying Our Docker Rails App<\/h2>\n
Today we\u2019ll be deploying our app to a pretty typical Linux box (Ubuntu, but it could be anything) which already has Docker and NGINX installed.<\/p>\n
We\u2019ll actually have to set up two other images (plus our Rails app, so three in total) on the server for the database. I\u2019m going to be creating one image which is for storing DB data plus another for the DB server itself. Then we\u2019ll run our main Alpine-Rails Docker image and link it to the DB server image. If you\u2019re wondering why I\u2019m doing it this way, Tim Butler has a great article on Linking and Volumes in Docker<\/a>.<\/p>\n
docker create -v \/var\/lib\/postgresql\/data --name db-data postgres:9.4 \/bin\/true<\/pre>\n
And for the DB server itself, which uses the --volumes-from<\/code> directive to point to the db-data<\/code> image from above:<\/p>\n
docker run -d --name db-server --volumes-from db-data postgres:9.4<\/pre>\n
Now to run our Rails container:<\/p>\n
docker run -d --name rails-server --link db-server -p 3000:3000 -e SECRET_KEY_BASE=`rake secret` leighhalliday\/rails-alpine<\/pre>\n
Here is a breakdown of the directives:<\/p>\n