Posted on Nov 24, 2020

Deploy a Ruby on Rails API only application in Docker with PostgreSQL

Project Link: https://github.com/Joker666/rails-api-docker

Docker allows packaging an application or service with all its dependencies into a single image which then can be hosted into different platforms like Docker Hub or Github Container Registry. These images can pulled and shared with teammates for easy development or deployed to production with container orchestration tools like Kubernetes.

When we look at the current state of development, there are endless installation instructions on how to install and configure an application as well as all its dependencies. And even then it doesn't work, the Ruby version doesn't match or some dependency's version upgrade broke the installation. It is where Docker comes in handy, the image created once, can run in any platform as long as Docker is installed. Today we are going to deploy a Ruby on Rails application in Docker.

Preparation

We will need a few tools installed in the system to get started with Rails development

Ruby 2.7
Rails 6.0
Docker

With these installed, let's generate our API only project

rails new docker-rails \ --database=postgresql \ --skip-action-mailbox \ --skip-action-text \ --skip-spring -T \ --skip-turbolinks \ --api

Since we are creating API only project, we are skipping the installation of few Rails web specific tools like action-text or turbolinks. And we are making sure --api flag is there to create an API only Rails project.

Making APIs

We are going to make two APIs. Authors and articles

rails g resource Author name:string --no-test-framework rails g resource Article title:string body:text author:references --no-test-framework

Let's add has_many macro in Author model

# app/models/author.rb class Author < ApplicationRecord has_many :articles end

And populate DB with some seed data. Install faker first

bundle add faker

Then do bundle install and then update seeds file with

# db/seeds.rb require 'faker' Author.delete_all Article.delete_all 10.times do Author.create(name: Faker::Book.unique.author) end 50.times do Article.create({ title: Faker::Book.title, body: Faker::Lorem.paragraphs(number: rand(5..7)), author: Author.limit(1).order('RANDOM()').first # sql random }) end

Now, we do not have PostgreSQL running, so we cannot run the migrations or seed data. We would do that when we deploy in docker. Now lets update the controller files

# app/controllers/articles_controller.rb class ArticlesController < ApplicationController before_action :find_article, only: :show def index @articles = Article.all render json: @articles end def show render json: @article end private def find_article @article = Article.find(params[:id]) end end # app/controllers/author_controller.rb class AuthorsController < ApplicationController before_action :find_author, only: :show def index @authors = Author.all render json: @authors end def show render json: @author end private def find_author @author = Author.find(params[:id]) end end

Let's prefix our routes with api

Rails.application.routes.draw do scope :api do resources :articles resources :authors end end

We are all set now to hit some endpoints.

Enter Docker

To build a docker image we have to write a Dockerfile. What is a Dockerfile through? Dockerfile is where all the dependencies are bundled and additional commands or steps are written to be executed before building the image. There are built in images for Ruby. We will start with an image of Ruby 2.7. Let's write the Dockerfile first and then we will explain what is happening there.

FROM ruby:2.7 RUN apt-get update -qq && apt-get install -y postgresql-client # throw errors if Gemfile has been modified since Gemfile.lock RUN bundle config --global frozen 1 WORKDIR /app COPY Gemfile Gemfile.lock ./ RUN bundle install COPY . . ENTRYPOINT ["./entrypoint.sh"] EXPOSE 3000 # Start the main process. CMD ["rails", "server", "-b", "0.0.0.0"]

So we start from Ruby 2.7 pre-built image and then install PostgreSQL client into the system, this is a Debian based system so we use apt-get. Next, we freeze the bundle config which will actually help us maintain consistency over the dockerized system and host system. If Gemfile was modified but we did not run bundle install, this is where it will throw an error

Now we set our working directory inside the docker system to be /app. We copy over the Gemfile and Gemfile.lock over to the docker's app directory and run bundle install inside docker. After bundle install finishes we copy over all the files from our host system to the docker system.

After that, we execute a shell script which we will come back shortly and then we expose port 3000 and start the rails server binding it to 0.0.0.0.

The entrypoint.sh file

#!/bin/bash set -e if [ -f tmp/pids/server.pid ]; then rm tmp/pids/server.pid fi exec "$@"

This helps fix a Rails-specific issue that prevents the server from restarting when a certain server.pid file pre-exists, this needs to be run on every docker start.

We are done with our docker file. Now let's build it.

docker build -t rails-docker .

This builds the image pulling all the dependencies and saves it with a tag rails-docker:latest

Now, we can run this image, but that won't necessarily help us since we need PostgreSQL running as well. We could use a local installation of the DB but here we will run the DB inside docker.

Environment Setup

Let's add .env file the root of the directory

DBHOST=localhost DBUSER=postgres DBPASS=password

This is essentially our DB environment variables which we will overwrite with docker.
Now, let's update the database.yml file inside config so that it the Rails app can read from the environment variables to connect to PostgreSQL.

# config/database.yml default: &default adapter: postgresql encoding: unicode pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %> development: <<: *default database: docker_rails_development username: <%= ENV['DBUSER'] %> password: <%= ENV['DBPASS'] %> host: <%= ENV['DBHOST'] %>

Docker-Compose

Docker compose is a handy way to write all the docker images as services dependent on each other and running inside one internal network where they can talk to each other. We are going to run PostgreSQL as a service in docker-compose along with the image of Rails API we just built

version: '3.8' services: web: build: . image: rails-docker restart: "no" environment: - DBHOST=postgresql - DBUSER=postgres - DBPASS=password ports: - 3000:3000 depends_on: - postgresql postgresql: image: postgres restart: "no" ports: - 5432:5432 environment: POSTGRES_DB: docker_rails_development POSTGRES_USER: postgres POSTGRES_PASSWORD: password volumes: - postgresdb:/var/lib/postgresql/data/ volumes: postgresdb:

So there are two services here. In the postgresql service, we are using the official postgresql image and passing some values for environment variables and exposing the internal 5432 port to the host machine. We add a docker volume with it so that it stores data there and data can survive a restart.

The web service, runs the image we just built for the API and depends on postgresql service. That means the postgresql service needs to be up and running first for web service to start running. This is cool. Since we specified the POSTGRES_DB environment in the postgresql service, if the database doesn't exist when running the PostGreSQL server for the first time, it will create the database. Great, now let's run the services.

docker-compose -f docker-compose.yml up --build

This will build the images first if they are not built already and then run them. We would see that both images are running in the console. Now let's do our migration and seeding.

Stop the services with ctrl+c and run

docker-compose run web rails db:migrate docker-compose run web rails db:seed

This will run the rails commands from inside the web service container. We now have data populated.

Now let's run the services again with

docker-compose up

Let's hit some endpoints to check

curl localhost:3000/api/authors [ { "id":1, "name":"Lakendra Bergnaum", "created_at":"2020-11-24T13:25:29.507Z", "updated_at":"2020-11-24T13:25:29.507Z" }, ... ]

Sure it fetches the authors from the API and prints in the console. And if hit the articles endpoint it would print the articles as well.

Conclusion

That was a lot to grasp if you are starting with docker for the first time. But we covered how we can deploy a Rails API only app in docker along with PostgreSQL. This is a good starting point to build something awesome.