How to Dockerize a Rails Application

A Step-by-Step Guide

4 min readDec 18, 2024

Docker is a powerful tool for creating, deploying, and running applications in containers. Containerization ensures that your application runs consistently across different environments, making it an excellent choice for Rails applications. In this guide, we’ll walk through the process of dockerizing a Rails application, from setting up your Docker environment to deploying your containerized app.

Prerequisites

Docker installed — Ensure Docker and Docker Compose are installed on your machine. You can download them from Docker’s official website.

Create a Ruby on Rails application — Understand Rails concepts like models, controllers, and migrations.

Creating the Dockerfile

The Dockerfile is a script that contains a series of instructions to create a Docker image for your Rails application. Here’s a basic Dockerfile for a Rails app:

# Use the official Ruby image from the Docker Hub
FROM ruby:3.1

# Set the working directory in the container
WORKDIR /usr/src/app

# Install dependencies
RUN apt-get update -qq && apt-get install -y nodejs postgresql-client

# Install gems
COPY Gemfile /usr/src/app/
COPY Gemfile.lock /usr/src/app/
RUN bundle install

# Copy the Rails application into the container
COPY . /usr/src/app

# Precompile assets
RUN bundle exec rake assets:precompile

# Expose port 3000
EXPOSE 3000

# Define the command to run the application
CMD ["rails", "server", "-b", "0.0.0.0"]

Explanation:

FROM ruby:3.1: Specifies the base image with Ruby installed.
WORKDIR /usr/src/app: Sets the working directory inside the container.
RUN apt-get update -qq && apt-get install -y nodejs postgresql-client: Installs necessary dependencies, including Node.js (for JavaScript runtime) and PostgreSQL client.
COPY Gemfile /usr/src/app/: Copies the Gemfile and Gemfile.lock into the container.
RUN bundle install: Installs the gems specified in the Gemfile.
COPY . /usr/src/app: Copies the rest of your application’s code.
RUN bundle exec rake assets: Precompiles assets for production.
EXPOSE 3000: Makes port 3000 available to the outside world.
CMD [“rails”, “server”, “-b”, “0.0.0.0”]: Starts the Rails server.

Creating the Docker Compose File

Docker Compose simplifies the process of managing multi-container Docker applications. Create a docker-compose.yml file:

version: '3.8'  # Version of the Docker Compose file format

services:
  db:
    image: postgres:13  # Use the official PostgreSQL image
    volumes:
      - postgres_data:/var/lib/postgresql/data  # Persistent storage for database
    environment:
      POSTGRES_USER: myapp
      POSTGRES_PASSWORD: password
      POSTGRES_DB: myapp_development

  web:
    build: .
    command: rails server -b 0.0.0.0  # Start Rails server binding to all interfaces
    volumes:
      - ".:/usr/src/app"  # Sync the current directory with the container
    ports:
      - "3000:3000"  # Map container port to host port
    depends_on:
      - db  # Ensure the db service is started before web

volumes:
  postgres_data:  # Define a named volume for PostgreSQL data persistence

networks:
  default:
    driver: bridge  # Use the default bridge network

Explanation:

db: Defines the PostgreSQL service with its image, volume, and environment variables.
web: Defines the Rails application service, including build instructions, command, volume, and port mapping.
volumes: Defines the named volume for PostgreSQL data persistence.

Building and Running the Docker Containers

With the Dockerfile and docker-compose.yml file in place, you can now build and run your Docker containers:

docker-compose build
docker-compose up

This will build the Docker images and start the services defined in docker-compose.yml.

Setting Up the Database

Run the database setup commands inside your Docker container:

docker-compose run web rake db:create
docker-compose run web rake db:migrate

Testing Your Application

Open your browser and navigate to http://localhost:3000 to see your Rails application running inside a Docker container. Test the functionality to ensure everything works as expected.

Dockerizing for Production

When preparing for production, consider the following:

Environment Variables: Use environment variables for configuration (e.g., database credentials).
Docker Secrets: For sensitive information, use Docker secrets or other secure methods.
Optimizing the Dockerfile: Minimize the Docker image size by using multi-stage builds if necessary.

Troubleshooting Common Issues

Database Connection Errors: Ensure that the database.yml configuration is set to connect to the PostgreSQL service.
Asset Precompilation Issues: Verify that the assets are precompiled correctly and that the public/assets directory is accessible.

Conclusion

Dockerizing a Rails application can greatly improve your development workflow and deployment process. By following the steps in this guide, you should have a solid understanding of how to create a Docker environment for your Rails app. Remember to continuously test and refine your Docker setup as your application evolves.