How To Dockerize Rails App: Dockerize Compose and Rails Tutorial

Table of Contents

Introduction

A curious developer and tech enthusiast never miss an opportunity to learn a little more every day! I can absolutely relate to this urge to learn. So, we are back with another Rails tutorial on how to dockerize rails app with the help of rails docker compose. Please be familiar with what is Docker and why do we need Docker.

Let’s get started with app development and dockerizing it.

Create a Rails App

Fire the following commands to create a rails app.

Prerequisites: Dockerize Rails App

As we are implementing Docker Compose, make sure about the following installations before getting started.

• Install Docker Community Edition
• Install Docker Compose

Create a Dockerfile

The Dockerfile is the foundation of any Dockerize Ruby on Rails app. It contains all the instructions for building the application image. You can set this up by installing Ruby and all of its dependencies. The Dockerfile consists of the following instructions.

// Dockerfile

Dockerfile will keep the app code inside an image, building a container with Bundler, Ruby, and other dependencies. Therefore in the root directory of the application, create a new Dockerfile using the command touch Dockerfile and put the content of the above dockerfile inside it.

Explanation

1. FROM ruby:2.3.0: Tells Docker to use the prebuilt Ruby image. There are several choices, but this project uses the ruby:2.3.0 image.
2. RUN: To run commands. Here, RUN is for installing different software pieces with Apt.
3. WORKDIR: For stating the base directory from where all the commands are executed.
4. ADD: For copying files from the host machine to our container.

Create a Gemfile

Next, open the editor and create a bootstrap Gemfile that loads Rails.

// gemfile

Create an empty Gemfile.lock file to build our Dockerfile.

Dockerize Rails App: Add Portability, Modularity, and Scalability to your app
Contact Bacancy and hire Rails developer to dockerize your rails application.

Define Services Using Docker Compose

Finally, moving towards the most important section. The docker-compose.yml file will consist of services needed for your app (web application and DB), for getting each other’s Docker image, and the config for connecting them and making it visible on the port.

// docker-compose.yml

Build the Project

Now build the skeleton of the rails application with the help of docker-compose run.

• compose– builds the image for the app service, which we have to define inside our docker-compose.yml
• runs rails new – using that image it runs the app inside a new container
• database=mysql– to define the database

Your application should be created after the command is successfully executed. List the files using ls -l

Database Connection

In this section, we will connect the database as rails wants a database to be running on the localhost.

We will also alter the database and username for aligning it with the defaults by the MySQL image. When we run the docker-compose command first, it will create a DB container that downloads the MySQL database image and creates a DB based on the environment variables set in the docker-compose.yml file.

By now, we have a database container, and app structure created. We need to edit the config/database.yml file and set the configurations from the environment variables.

Replace the contents of config/database.yml with the following:

// docker-compose.yml

After setting up the docker-compose.yml, run the docker-compose build command to build an image for the app and install all the required gems.

Run the below command for database creation.

Before creating any migrations/models, let’s do a docker-compose up to start both app and database services and boot the application after making the changes in database.yml.

We can see that rails is running on port 3000 in the container after the command is successfully executed. But, that’s not the port on the host, so we won’t be able to access it on the browser. As per docker-compose, we have exposed the port on the localhost from 3000 to 3001; therefore, it should be available on localhost:3001.

Once you are done with the app running on the browser, create a model and perform the migration using these commands in a different console of the project directory.

Now, we can access the application on port 3001- localhost:3001/notes and perform actions on the application.

Summary: How to Dockerize Rails App

• mkdir ~/projects/noteapp
• cd ~/projects/noteapp
• Create Gemfile and empty Gemfile.lock (content is given above)
• Create Dockerfile (content is given above)
• Create docker-compose.yml (content is given above)
• docker-compose run app rails new . –force –database=mysql
• Make changes in config/database.yml
• docker-compose build
• docker-compose up
• http://localhost:3001
• docker-compose run –rm app rails g scaffold note title body:text
• docker-compose run –rm app rake db:migrate
• http://localhost:3001/notes

Watch the video tutorial on how to dockerize rails app as well.

Source Code: dockerize-rails-app

You can also clone the code and go through the project. Here’s the source code of the repository: dockerize-rails-app

Commands: Stop, Restart, and Rebuild the Application

• To stop the application

• To restart the application

• To rebuild the application

Rebuilding the application is a must when you’re trying different configs and altering the Gemfile or Compose file.
➡ Sometimes only docker-compose up –build is enough.
➡ But, if you want to rebuild the entire app fully, then use docker-compose run app bundle install, followed by docker-compose up –build for synchronizing changes between the Gemfile.lock and the host.

Conclusion