How to Setup Ruby Docker Container using Docker Compose
How to Setup Ruby Docker Container using Docker Compose. If you are actively developing applications- Docker can simplify your workflow and your deployment. Docker is a great choice to keep things organized. This tutorial will show you how to set up a development environment for a Ruby on Rails application using Docker. You will create a containers for the application itself and we will use PostgreSQL database. Let’s start!
What is Ruby on Rails
Ruby is a free, open source and one of the popular programming languages developed by Yukihiro “Matz” Matsumoto in the mid-1990s. Compared to C and Java language, Ruby is a general purpose language. Rails makes web development easier, providing a pre built structure for development and everything you need to build a web app. Ruby on Rails uses the Model View Controller (MVC) architecture.
Ruby on Rails software code is built on top of Ruby. It is an open source web development framework that contains a collection of code libraries. It is considered a top choice of frameworks for startups as it is great for handling complex business logic and for delivering a web apps quickly. Ruby on Rails offers a complete solution for repetitive tasks like developing tables, forms or menus on the website.
Ruby features
- Automated Testing- RoR runs its own set of tests on the code you write.
- Symbol garbage collector.
- Speedy software development.
- Reliable and accurate as it has a test driven methodology.
- Best for high trafficked and large projects requiring variety of drastic transformations.
- The localization feature with ROR helps to integrate your pre designed code into the RoR framework for large projects.
- Action Mailer and Action view.
- Turbolinks.
- Action cable.
- Rails API.
- Render from anywhere
- Rake command
- Scaffolding where the programmer is able to define how the application database should function.
- Customized library -vast libraries to assist developer with all the tools to produce high quality product (AJAX library, Database access library and Common tasks library).
What is Docker
Docker is a free and open source containerization platform that allows you to package up an application or service with all of its dependencies into a standardized image. It allows us to build and replicate images on any host, removing the inconsistencies of dev environments and reducing onboarding timelines considerably. The Docker image contains the code, runtime, system libraries and anything that required to deploy an application. If you are developing a Ruby application, you will need a specific version of Ruby, Bundler, project-specific gems and other dependencies based on the operating system. In this case, you can use Docker to keep things organized. Docker simplifies your workflow and the process of deploying your application to production.
Docker features
- An open source solution
- Easy and fast configuration.
- An isolated, rapid framework.
- Increases productivity.
- Swarm. A clustering and scheduling tool for Docker containers.
- Routing Mesh.
- Cross cloud infrastructure.
- Moderate CPU/memory overhead.
- Fast reboot.
- Security Management.
Follow this post to learn how to setup Ruby Docker container using Docker Compose.
How to Setup Ruby Docker Container using Docker Compose
Install Docker
To deploy a Ruby server using the Docker Compose, you will need to install the Docker on your server. By default, the latest version of Docker is not included in the Debian or Ubuntu default repository. So it is recommended to install Docker from the Docker’s official repository.
First, install all required dependencies using the following command:
apt-get install git apt-transport-https ca-certificates curl gnupg-agent software-properties-common -y
Please download and add the Docker GPG key with the following command:
curl -fsSL https://download.docker.com/linux/debian/gpg | apt-key add -
Add the Docker repository with the following command:
add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/debian $(lsb_release -cs) stable"
Once the repository is added, update the repository cache using the following command:
apt-get update -y
Finally, install the Docker CE by running the following command:
apt-get install docker-ce -y
Once the Docker is installed, start it using the following command:
systemctl start docker
To verify the active status of the Docker, run the following command:
systemctl status docker
You will get the following output:
● docker.service - Docker Application Container Engine
Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
Active: active (running) since Wed 2022-05-11 14:58:54 UTC; 59s ago
TriggeredBy: ● docker.socket
Docs: https://docs.docker.com
Main PID: 4310 (dockerd)
Tasks: 8
Memory: 35.0M
CPU: 591ms
CGroup: /system.slice/docker.service
└─4310 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
May 11 14:58:53 debian11 dockerd[4310]: time="2022-05-11T14:58:53.130577231Z" level=info msg="scheme \"unix\" not registered, fallback to def>
May 11 14:58:53 debian11 dockerd[4310]: time="2022-05-11T14:58:53.130643324Z" level=info msg="ccResolverWrapper: sending update to cc: {[{uni>
May 11 14:58:53 debian11 dockerd[4310]: time="2022-05-11T14:58:53.130679866Z" level=info msg="ClientConn switching balancer to \"pick_first\">
May 11 14:58:53 debian11 dockerd[4310]: time="2022-05-11T14:58:53.289737295Z" level=info msg="Loading containers: start."
May 11 14:58:53 debian11 dockerd[4310]: time="2022-05-11T14:58:53.768316041Z" level=info msg="Default bridge (docker0) is assigned with an IP>
May 11 14:58:53 debian11 dockerd[4310]: time="2022-05-11T14:58:53.982174628Z" level=info msg="Loading containers: done."
May 11 14:58:54 debian11 dockerd[4310]: time="2022-05-11T14:58:54.034840356Z" level=info msg="Docker daemon" commit=4433bf6 graphdriver(s)=ov>
May 11 14:58:54 debian11 dockerd[4310]: time="2022-05-11T14:58:54.035487755Z" level=info msg="Daemon has completed initialization"
May 11 14:58:54 debian11 systemd[1]: Started Docker Application Container Engine.
May 11 14:58:54 debian11 dockerd[4310]: time="2022-05-11T14:58:54.097373599Z" level=info msg="API listen on /run/docker.sock"
To verify the Docker version, run the following command:
docker version
You should see the Docker version in the following output:
Client: Docker Engine - Community
Version: 20.10.15
API version: 1.41
Go version: go1.17.9
Git commit: fd82621
Built: Thu May 5 13:19:21 2022
OS/Arch: linux/amd64
Context: default
Experimental: true
Server: Docker Engine - Community
Engine:
Version: 20.10.15
API version: 1.41 (minimum version 1.12)
Go version: go1.17.9
Git commit: 4433bf6
Built: Thu May 5 13:17:26 2022
OS/Arch: linux/amd64
Experimental: false
containerd:
Version: 1.6.4
GitCommit: 212e8b6fa2f44b9c21b2798135fc6fb7c53efc16
runc:
Version: 1.1.1
GitCommit: v1.1.1-0-g52de29d
docker-init:
Version: 0.19.0
GitCommit: de40ad0
Install Docker Compose
By default, the latest version of Docker Compose is not included in the Ubuntu and Debian repository. So it is a good idea to download the latest version of Docker Compose from the GitHub.
curl -s https://api.github.com/repos/docker/compose/releases/latest | grep browser_download_url | grep docker-compose-linux-x86_64 | cut -d '"' -f 4 | wget -qi -
Once the Docker Compose binary is downloaded, set the executable permission of the downloaded binary file using the following command:
chmod +x docker-compose-linux-x86_64
Next, move the Docker Compose binary to the system path using the following command:
mv docker-compose-linux-x86_64 /usr/local/bin/docker-compose
You can now verify the Docker Compose version using the following command:
docker-compose version
You should see the following output:
Docker Compose version v2.5.0
Create Ruby on Rails Project
First, create a directory for Ruby on Rails project using the following command:
mkdir -p ~/rails
Next, navigate to your rails directory and create a Rails container using the following command:
cd ~/rails/
docker run --rm -v ${PWD}:/usr/src -w /usr/src -ti ruby:alpine sh
This command will download and run the Ruby container, mount the local directory to the /usr/src directory, execute the shell command and move to the app directory:
Unable to find image 'ruby:alpine' locally
alpine: Pulling from library/ruby
df9b9388f04a: Pull complete
837e9cfc7e43: Pull complete
c7850f1a8c23: Pull complete
ae0a3cc0f34c: Pull complete
81637037ea3a: Pull complete
Digest: sha256:0b91e98c4613c2287bb7274a1584ea141b68960fb6b0edd7fe32127dc888d1a0
Status: Downloaded newer image for ruby:alpine
/usr/src #
Now, run the following commands inside the container to install the Ruby on Rails:
cd app
apk add build-base
apk add git
gem install -N rails
Please create a new application named app with PostgreSQL database:
rails new app --database=postgresql --skip-bundle
Next, exit from the Docker container with the following command:
exit
Now, verify your app directory using the following command:
ls -l app/
You should see the following output:
total 60
drwxr-xr-x 10 root root 4096 May 11 15:16 app
drwxr-xr-x 2 root root 4096 May 11 15:16 bin
drwxr-xr-x 5 root root 4096 May 11 15:16 config
-rw-r--r-- 1 root root 160 May 11 15:16 config.ru
drwxr-xr-x 2 root root 4096 May 11 15:16 db
-rw-r--r-- 1 root root 2268 May 11 15:16 Gemfile
drwxr-xr-x 4 root root 4096 May 11 15:16 lib
drwxr-xr-x 2 root root 4096 May 11 15:16 log
drwxr-xr-x 2 root root 4096 May 11 15:16 public
-rw-r--r-- 1 root root 227 May 11 15:16 Rakefile
-rw-r--r-- 1 root root 374 May 11 15:16 README.md
drwxr-xr-x 2 root root 4096 May 11 15:16 storage
drwxr-xr-x 10 root root 4096 May 11 15:16 test
drwxr-xr-x 5 root root 4096 May 11 15:16 tmp
drwxr-xr-x 2 root root 4096 May 11 15:16 vendor
Configure Rails Project
First, you will need to create a Docker file for Rails application. You can create it inside the rails directory:
cd ~/rails
nano Dockerfile
Add the following lines:
FROM ruby:alpine
RUN apk update
RUN apk add build-base nodejs postgresql-dev tzdata
RUN gem install -N rails
RUN mkdir -p /app
WORKDIR /app
COPY ./app/Gemfile /app
COPY ./app/Gemfile.lock /app
RUN bundle install --binstubs
Save and close the file then navigate to the app directory and create a lock file:
cd app/
touch Gemfile.lock
Next, edit the database configuration file:
nano config/database.yml
Change the following lines:
default: &default
adapter: postgresql
encoding: unicode
host: db
username: postgres
pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
timeout: 5000
Save and close the file when you are finished.
Create Docker Compose File
Next, create a new Docker Compose file for Rails application.
nano ~/rails/docker-compose.yml
Add the following lines:
version: '3.6'
services:
db:
image: postgres:alpine
volumes:
- ./postgresql:/var/lib/postgresql/data
environment:
- POSTGRES_HOST_AUTH_METHOD=trust
web:
build: .
volumes:
- ./app:/app
working_dir: /app
command: bundle exec rails s -p 3000 -b '0.0.0.0'
ports:
- 80:3000
depends_on:
- db
Save and close the file then create PostgreSQL directory:
mkdir -p ~/rails/postgresql
Build the Ruby on Rails Project
Now, navigate to the rails directory and build the Ruby on Rails project using the Docker Compose:
cd ~/rails/
docker-compose build
You should see the following output:
=> [internal] load build definition from Dockerfile 0.0s
=> => transferring dockerfile: 265B 0.0s
=> [internal] load .dockerignore 0.0s
=> => transferring context: 2B 0.0s
=> [internal] load metadata for docker.io/library/ruby:alpine 0.0s
=> [1/9] FROM docker.io/library/ruby:alpine 0.1s
=> [internal] load build context 0.0s
=> => transferring context: 2.37kB 0.0s
=> [2/9] RUN apk update 1.0s
=> [3/9] RUN apk add build-base nodejs postgresql-dev tzdata 14.5s
=> [4/9] RUN gem install -N rails 14.3s
=> [5/9] RUN mkdir -p /app 0.5s
=> [6/9] WORKDIR /app 0.0s
=> [7/9] COPY ./app/Gemfile /app 0.0s
=> [8/9] COPY ./app/Gemfile.lock /app 0.0s
=> [9/9] RUN bundle install --binstubs 31.9s
=> exporting to image 9.0s
=> => exporting layers 9.0s
=> => writing image sha256:61e8f1ac1f5f288d440d1ebcbcbf5b6741bc82fa40d86e65446c5e74a478d3e1 0.0s
=> => naming to docker.io/library/rails_web 0.0s
Next, generate the PostgreSQL database using the following command:
docker-compose run web rake db:create
You should see the following output:
[+] Running 1/0
⠿ Container rails-db-1 Recreated 0.1s
[+] Running 1/1
⠿ Container rails-db-1 Started 0.5s
Created database 'app_development'
Created database 'app_test'
You can verify the all Docker images using the following command:
docker images
You should see the following output:
REPOSITORY TAG IMAGE ID CREATED SIZE
rails_web latest c8c1f2c916ef 19 minutes ago 718MB
ruby alpine 0bf06f4f0410 4 weeks ago 68.3MB
postgres alpine ebf01b748a56 5 weeks ago 211MB
Finally, bring up all application defined in the Docker Compose file:
docker-compose up -d
You should see the following output:
[+] Running 2/2
⠿ Container rails-db-1 Running 0.0s
⠿ Container rails-web-1 Started 1.2s
Now, run the following command to see all running applications:
docker-compose ps
You should see the following output:
NAME COMMAND SERVICE STATUS PORTS
rails-db-1 "docker-entrypoint.s…" db running 5432/tcp
rails-web-1 "bundle exec rails s…" web running 0.0.0.0:80->3000/tcp, :::80->3000/tcp
Access Ruby on Rails
Now, open your web browser and type the URL http://your-serevr-ip to access the Ruby on Rails application. You should see the Ruby on Rails dashboard on the following screen:
How to Setup Ruby Docker Container using Docker Compose Conclusion
In this post, we explained how to setup Ruby Docker container using Docker Compose. We also create a simple Rails application and deploy it inside the Docker container.
I really enjoy developing Rails applications with Docker Compose. It’s ensures your production environment is exactly the same as your local machine. As this technology matures even more this method of development will become more of a standard .
