Create and Dockerize rails application with MYSQL and Sidekiq (Docker + Docker Compose)

This article is the continuation of Rails + Sidekiq + Docker Application for AWS (ECS, ECR, RDS, Codepipeline and more) complete series. For better understating, please start from the beginning of the series.

Create the rails application

rails new ecs-rails-application --api -d mysql

You can replace ecs-rails-application with whatever name you want for your application

You can also download the my repository from github. here is link

Docker time

Our application is created. Let’s create some other files and folders.

cd ecs-rails-application

# Creating Dockfile
touch Dockerfile

# Creating development directory and docker-compose file
mkdir development && touch development/docker-compose.yml

# Creating entrypoint.sh file
touch entrypoint.sh

Dockerfile

Paste the following content into Dockerfile

FROM ruby:2.5.1

# install rails dependencies
RUN apt-get clean all && apt-get update -qq && apt-get install -y build-essential libpq-dev \
    curl gnupg2 apt-utils default-libmysqlclient-dev git libcurl3-dev cmake \
    libssl-dev pkg-config openssl imagemagick file nodejs yarn


RUN mkdir /rails-app
WORKDIR /rails-app

# Adding gems
COPY Gemfile Gemfile
COPY Gemfile.lock Gemfile.lock
RUN bundle install

COPY . /rails-app

# Add a script to be executed every time the container starts.
COPY entrypoint.sh /usr/bin/
RUN chmod +x /usr/bin/entrypoint.sh
ENTRYPOINT ["entrypoint.sh"]

Entrypoint.sh

paste the following code into entrypoint.sh file

#!/bin/bash
set -e

# Remove a potentially pre-existing server.pid for Rails.
rm -f /rails-app/tmp/pids/server.pid

exec "$@"

Now build the docker image to make sure nothing is breaking.

docker build .

Docker Compose

we will add MYSQL, Redis and web (our rails project) services in our docker compose file. We need to make few adjustments in our rails application (same applies to existing rails application too)

config/database.yml

Your database.yml file should look like this:

default: &default
  adapter: mysql2
  encoding: utf8mb4
  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
  username: <%= ENV['DB_USERNAME'] %>
  password: <%= ENV['DB_PASSWORD'] %>
  port: <%= ENV['DB_PORT'] %>
  host: <%= ENV['DB_HOST'] %>
  database: <%= ENV['DB_NAME'] %>
  socket: /var/run/mysqld/mysqlx.sock

development:
  <<: *default

test:
  <<: *default

production:
  <<: *default

Open the docker-compose.yml file located in development folder and paste the following code:

version: "3.7"
services:
  db:
    image: "mysql:5.7"
    restart: always
    environment:
     MYSQL_ROOT_PASSWORD: root
     MYSQL_USERNAME: root
     MYSQL_PASSWORD: root
        - '3306:3306'
    expose:
      - '3306'
    volumes:
      - db:/var/run/mysqld
    logging:
            driver: none
    ports:
      - "33061:3306"
  redis:
    image: redis:4.0-alpine
    command: redis-server
    volumes:
      - redis:/data
    ports:
      - 6379
    logging:
            driver: none
  web:
    build: ../
    command: bundle exec rails s -p 3000 -e development -b '0.0.0.0'
    environment:
     DB_USERNAME: root
     DB_PASSWORD: root
     DB_NAME: ecs_application_db
     DB_PORT: 3306
     DB_HOST: db
     RAILS_ENV: development
     RAILS_MAX_THREADS: 5
     REDIS_HOST: redis
     REDIS_PORT: 6379
     BUNDLE_PATH: /bundle
    volumes:
      - ../:/rails-app
      - bundle:/bundle
    ports:
      - "3000:3000"
    depends_on:
      - "db"
      - "redis"
volumes:
  db:
  bundle:
  redis:

I know this digital vomit looks complicated, I will try to explain what’s going on. We have created 3 services (db, redis and web)

Our rails application requires mysql database and redis (in the future for sidekiq). Docker compose is creating mysql and redis service for our rails application inside docker-compose.yml file.

db service is using mysql docker image from docker hub
redis service is using redis docker image from docker hub
web service is our rails application project containing our own Dockerfile

We need to understand what is going on inside the web service. We are providing the build path which is pointing docker compose to the parent folder where our Dockerfile is located

Other than that, we are setting some environment variables such database credentials, which will be passed onto our rails application.

We are also creating a volume called bundle which will be our cache for gems. By doing this, we don’t have to wait for the gems to be installed from start every time we run docker-compose build

Finally, Its time to run our Rails application !!

From your terminal, run the following commands:

cd development/
docker-compose run web bundle install
docker-compose run web rails db:setup
docker-compose build

Note: whenever you add any new gem in your Gemfile, Please don’t forget to run docker-compose run web bundle install

If everything goes well, you should be able to something like this:

run the final command to instantiate rails server

docker-compose up

open your web browser and type http://localhost:3000 and you should see the rails application

Configure sidekiq

Add following into your Gemfile:

gem 'sidekiq'
gem 'redis-rails'

Create following files:

touch config/initializers/sidekiq.rb

Paste following code into sidekiq.rb file

# frozen_string_literal: true

sidekiq_config = { url: "redis://#{ENV['REDIS_HOST']}:#{ENV['REDIS_PORT']}/12" }

Sidekiq.configure_server do |config|
  config.redis = sidekiq_config
end

Sidekiq.configure_client do |config|
  config.redis = sidekiq_config
end

Go to development folder and install the new gems

docker-compose run web bundle install

We need to add a new service to the docker-compose.yml file

  sidekiq:
    build: ../
    command: bundle exec sidekiq
    volumes:
      - ../:/rails-app
    environment:
      RAILS_ENV: development
      REDIS_HOST: redis
      REDIS_PORT: 6379
    depends_on:
      - "redis"

You can check the final docker-compose.yml on https://github.com/saluminati/ecs-rails-application/blob/master/development/docker-compose.yml

If you will run docker-compose up, you should be able to see (db, redis, web and sidekiq) running smoothly

Final Touches

We will create a Controller, ActiveJob and some changes to the routes. When the times comes, it will help us to test our Rails application.

Create a controller and Active Job

From your application development folder run the following commands.

docker-compose run web rails g controller home
docker-compose run web rails g job home

It will create the following files in your project

Update home_controller.rb, home_job.rb and routes.rb with the following content

home_controller.rb

class HomeController < ApplicationController

  def index
    render json: {"message": "Welcome"}
    HomeJob.perform_later
  end
end

home_job.rb

class HomeJob < ApplicationJob
  queue_as :default

  def perform(*args)
    puts 'Job Executed'
  end
end

routes.rb

Rails.application.routes.draw do
  # For details on the DSL available within this file, see https://guides.rubyonrails.org/routing.html
  get '/home', to: 'home#index'
end

now build and run your container

docker-compose build
docker-compose up

Open http://localhost:3000/home in your web browser

in the console you should be able to see that the HomeJob has been performed.

Rails + Sidekiq + Docker Application for AWS (ECS, ECR, RDS, Codepipeline and more) complete series

Prepare AWS Security groups for Rails Project

2 thoughts on “Create and Dockerize rails application with MYSQL and Sidekiq (Docker + Docker Compose)”

Abraham E Kinney says:

February 3, 2021 at 8:04 am

I had to add ‘bundle exec’ to make it ‘docker-compose run web bundle exec rails db:setup’ or I would get ‘/usr/bin/entrypoint.sh: line 7: exec: rails: not found’

Bundle exec would start the db setup but I can’t get passed this. I have actually tried several different ways and no matter what I do I get –

Mysql2::Error::ConnectionError: Can’t connect to MySQL server on ‘127.0.0.1’ (111 “Connection refused”)

Hal says:

March 24, 2022 at 4:00 am

Put this at the bottom of Dockerfile.

ENTRYPOINT [“sh”,”entrypoint.sh”]