Forem: Kaushik Hande

Dockerise existing rails application

Kaushik Hande — Fri, 28 Jan 2022 14:55:56 +0000

In this blog we will see how to dockerise the existing rails application.

For demo purpose, I have created a basic rails application
App configuration are as follows,

Ruby: Ruby 3.1.0
Rails version: Rails 7.0.1
Database: Postgres
Model: Article(title: string, content: text)

Step 1: Create a Dockerfile

A docker file contains the information to create the container image. We need a basic docker container image. These basic images are already created on docker hub. Docker Hub contains predefined ruby images. Our application ruby version is 3.1.0.

We will use https://hub.docker.com/layers/ruby/library/ruby/3.1.0/images/sha256-6155f0235e95166b49508ff0acbea7958bec53017bd307938e4dceb2cbd99c63?context=explore from docker hub.
ruby:3.1.0, here 3.1.0 is the tag of the image.

Create a file with name Dockerfile without extension inside rails root folder.

Here is the docker file

# syntax=docker/dockerfile:1
FROM ruby:3.1.0
RUN apt-get update -qq && apt-get install -y nodejs postgresql-client
WORKDIR /myapp
COPY Gemfile /myapp/Gemfile
COPY Gemfile.lock /myapp/Gemfile.lock
RUN bundle install

# 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"]
EXPOSE 3000

# Configure the main process to run when running the image
CMD ["rails", "server", "-b", "0.0.0.0"]

Line 1: fetches the ruby:3.1.0 image from docker hub if not present already.
Line 2: Adds nodejs and postgresql-client to container environment.
Line 3: It creates a working directory. Any command after this will be run inside this folder.
Line 4 & Line 5: copies Gemfile and Gemfile.lock from host inside working directory. It will copy these files from current folder to container myapp folder.
Line 6: runs the bundle install inside our container in working directory. This will install all the gems we need to run the application in our container.

Next, provide an entrypoint script to fix a Rails-specific issue that prevents the server from restarting when a certain server.pid file pre-exists. This script will be executed every time the container gets started.
entrypoint.sh consists of:

#!/bin/bash
set -e

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

# Then exec the container's main process (what's set as CMD in the Dockerfile).
exec "$@"

Add this script to rails root folder as entrypoint.sh
Next it will copy it in /usr/bin/ inside container
Run chmod on it.
Next command exposes port 3000 of container to host. Last line starts the rails server.

RUN sudo docker build .

This will build the docker image
i.e pull the ruby image and run the commands the dockerfile.

Our app will also need postgres database.
For this we will use postgres image from DockerHub.
We will directly specify this in our docker compose file.

Step 2: Docker Compose

Create a docker-compose.yml file inside the rails app root directory.

version: "3.3"
services:
  db:
    image: postgres
    volumes:
      - ./tmp/db:/var/lib/postgresql/data
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: password
  web:
    build: .
    command: bash -c "rm -f tmp/pids/server.pid && bundle exec rails s -p 3000 -b '0.0.0.0'"
    volumes:
      - .:/myapp
    ports:
      - "3000:3000"
    depends_on:
      - db

It consists of 2 services.

db
1. image: postgres will fetch postgres image from docker hub to our local
2. To persist our database through multiple container reruns we use volumes, where we specify local host location and map it to postgres container data location. Docker postgres image volume location is /var/lib/postgresql/data. You will find this in docker hub otherwise after image pull run docker inspect postgres and see the path in Volumes key.
web
1. For postgres we use default image from docker hub. However, for rails we will use the dockerfile.
2. build . will build the dockerfile.
3. next we removed the server pid and started the server.
4. next we are binding the current folder to myapp folder in container.Any changes made inside our current directly will be visible in /myapp and eventually it will show us the latest content as we edit the file.
5. Map post 3000 of host to post 3000 of container.
6. It depends on db service.

Step 3: Run Docker Compose

Start container using docker-compose file

Command to start:
docker-compose up

Running this will give us errors as we have not configured our database and not connected the rails app with postgres.

We need to create database in our postgres container. We will create it using our rails commands
For that we need to configure database.yml right. use same username and password which you passed to postgres as environment variables. In order to connect our rails app with database we have to provide correct host in database.yml
In this case host is db i.e. our service name.
Docker compose file creates a network of different services for us. In order to communicate with different services in this network we specify the service names.

Sample database.yml contents:

database: dockerise_rails_test
username: postgres
password: password
host: db

After configuring the database.yml, create database using docker-compose run web rails db:create
Run database migrations: docker-compose run web rails db:migrate
Open Rails console: docker-compose run web rails console Or docker ps get the name or container id and run docker exec -it dockerise_rails_web_1 rails c
Now run docker-compose file docker-compose up Both db and web services starts Docker compose logs shows us that both db_1 and web_1 have started. Our web application:

Github repository with dockerfile and docker-compose

Command to stop both rails and database container:
docker-compose down

References:

https://docs.docker.com/samples/rails/

Development workflows using tmux and tmuxinator

Kaushik Hande — Sun, 07 Nov 2021 18:10:29 +0000

In this blog, we will setup and startup development environment using tmux and tmuxinator.

As tmuxinator is based on tmux, first we will take a look into tmux and its basic commands, then we will create yml templates for project setup.

Tmux introduction

Tmux stands for Terminal Multiplexer.
Using tmux you can create different windows and panes within one window of one terminal and move around these windows and panes.
It lets you switch between several programs inside one terminal, detach and reattach them to a different terminal at will.

Tmux installation

Ubuntu: sudo apt install tmux
Windows: Using wsl for ubuntu`
OSX: brew install tmux

Open your terminal and start a tmux session by typing
tmux
This will open a tmux window.

Tmux Basic commands

Create vertical pane: Ctrl + a + %
Create horizontal pane: Ctrl + a + “
Switch between panes: Ctrl + a + <- ->
Close down pane: exit or Ctrl + a + x

Tmux window commands

Create new window: Ctrl + a + c
Switch between windows:Ctrl + a + n OR Ctrl + a + p
Switch between windows: Ctrl + a + 0 OR Ctrl + a + 1
Rename windows: Ctrl + a + ,
Exit Windows: exit

Tmux session commands

View Tmux session: tmux ls
Start new session: tmux new -s docker
Rename session: tmux rename-session -t 0 git
Detach session: Ctrl + a + d
Reattach session: tmux attach -t 0
Delete or kill session: tmux kill-session -t docker

That's all the commands we need to get going with tmuxinator.

Tmuxinator

Tmuxinator is a tool that allows you to easily manage tmux sessions by using yaml files to describe the layout of a tmux session, and open up that session with a single command.

Installation: gem install tmuxinator

Tmuxinator commands

Create new template: Tmuxinator new <todo_project_name>
Edit existing template: Tmuxinator edit <project_name>
Start project: Tmuxinator start <project_name>

We have a sample rails project as backend and react project as frontend.

Usually for development purpose we need.

editor
rails server
sidekiq server
rails console
git for rails project
react npm start
git for react project

We can create a predefined template using tmuxinator.
To start creating new project template in terminal: tmuxinator new <project name>

A editor is opened with yml file for project setup.

Give name to your project
name: todo
You need to define root of the project
root: ~/Documents/react-practice/todo-api
Then you can define you different windows are shown
and commands to execute in that window.
server: bundle exec rails s -p 4001
Above will create a window name server and start the rails server in the specified root folder.
You can define panes in window which splits the screen
```
react_project:
  root: ~/Documents/react-practice/todo-app
  layout: even-horizontal
  panes:
    - npm start
    - git status
```
Above will create a window name react_project, change root folder for this window to react app then will start react server and git in 2 horizontal equally split panes.

A sample tmuxinator file for starting rails and react server.

name: todo
root: ~/Documents/react-practice/todo-api

windows:
  - editor: vim .
  - server: bundle exec rails s -p 4001
  - sidekiq: bundle exec sidekiq
  - git: git status
  - rails_console: bundle exec rails console
  - react_project:
      root: ~/Documents/react-practice/todo-app
      layout: even-horizontal
      panes:
        - npm start
        - git status

To start the development setup using tmuxinator in terminal.
tmuxinator start todo

Tmux session for todo app with different windows and panes.

To close the todo app tmux session.
tmuxinator stop todo

Hope this will help you.
Thank you for reading