Building the Perfect Docker Image for Your Rails App

November 27, 2024

In the world of modern web development, Docker has become a staple tool for creating consistent, isolated, and portable environments. However, when it comes to Dockerizing your Rails application, it’s crucial to build an optimized Docker image to ensure fast builds, minimal image sizes, and secure deployments. In this guide, we’ll walk you through best practices for creating the best Docker image for your Rails app.

Why Dockerize Rails?

Docker allows you to package your application along with all of its dependencies into a container, ensuring that it runs consistently across different environments. This is particularly valuable for Rails developers, as it simplifies setting up local development environments, CI/CD pipelines, and production deployments.

However, not all Docker images are created equal. A bloated, poorly optimized image can slow down your development cycle, increase deployment times, and pose security risks. This article covers how to create the best Docker image for a Rails app, focusing on performance, security, and ease of use.

🚀 Need Expert Ruby on Rails Developers to Elevate Your Project?

Fill out our form! >>

1. Base Image Selection: Alpine vs Debian-based Images

Choosing the right base image is essential when Dockerizing your Rails application. The two most popular choices are Alpine and Debian-based images.

Alpine is a minimal Linux distribution that results in smaller Docker images. This is ideal for reducing the image size, which is especially useful in production environments. However, some Ruby gems may have compatibility issues with Alpine’s minimal libraries, which can lead to headaches.
Debian-based images, such as ruby:3.2-slim, provide a balance between size and compatibility. These images are slightly larger than Alpine-based images but come with more preinstalled libraries, making them more compatible with various Ruby gems.

Recommendation: If you don’t have specific needs for Alpine, the ruby:3.2-slim image is a great choice for Rails apps. It strikes a good balance between performance and compatibility.

2. Layering Best Practices

Docker images are built in layers, with each RUN, COPY, or ADD command creating a new layer. By optimizing these layers, you can reduce image size and improve caching efficiency.

Use Multi-Stage Builds Multi-stage builds are one of the best practices for creating efficient Docker images. You can split your build process into multiple stages: a builder stage for compiling assets and installing dependencies, and a final stage that only includes the necessary artifacts.

Example Dockerfile:

# Build Stage
FROM ruby:3.2-alpine AS builder
RUN apk add --no-cache build-base postgresql-dev nodejs yarn
WORKDIR /app
COPY Gemfile Gemfile.lock ./
RUN bundle install --jobs=4
COPY . . 
RUN rails assets:precompile

# Production Stage
FROM ruby:3.2-alpine
RUN apk add --no-cache libpq
WORKDIR /app
COPY --from=builder /app /app
CMD ["rails", "server", "-b", "0.0.0.0"]

In this example:

The builder stage installs dependencies, compiles assets, and prepares the application.
The production stage only contains the precompiled assets and necessary dependencies, resulting in a smaller final image.

3. Handle Dependencies Efficiently

To create an optimal Docker image, it’s essential to handle your dependencies carefully.

Use Gemfile Groups: Rails allows you to group gems into categories like :development, :test, and :production. Only install the necessary groups for each environment to avoid bloating the image with unused gems.

Example:

COPY Gemfile Gemfile.lock ./
RUN bundle install --without development test

Layer Caching: Docker caches layers to avoid re-running commands if files haven’t changed. By copying the Gemfile and Gemfile.lock before copying the rest of your application, you leverage Docker’s cache for faster builds.

COPY Gemfile Gemfile.lock ./
RUN bundle install --jobs=4
COPY . .

4. Database & Environment Configuration

When working with Docker, it’s a best practice to avoid including sensitive information such as database credentials in your Docker image. Instead, use environment variables to securely pass this information.

Environment Variables: You can pass environment variables to your Docker container using the -e flag or by defining them in a .env file (used in Docker Compose).

Example:

services:
  rails:
    build: .
    environment:
      - DATABASE_URL=postgres://user:password@db:5432/mydb

Database Links: If you’re using services like PostgreSQL or Redis, Docker Compose can help link these services to your Rails application. This makes the setup much easier, especially for local development.

5. Security and Performance

To ensure your Docker image is both secure and efficient, follow these tips:

Minimize the number of layers: Each Docker instruction (e.g., RUN, COPY, ADD) creates a new layer in the image. Combine commands to reduce the total number of layers.
Non-root User: Run your application as a non-root user for security reasons. You can add a user in the Dockerfile like so:

RUN addgroup -g 1001 appgroup && \
    adduser -u 1001 -G appgroup -s /bin/sh -D appuser
USER appuser

Use Official Ruby Images: Official images are maintained by the Docker team and are regularly updated with security patches. Always start from an official image like ruby:3.2-alpine or ruby:3.2-slim.
Security Scanning: Use tools like Trivy or Clair to scan your images for vulnerabilities before deploying them.

6. Development vs. Production

The Docker image you use for development and production should be optimized for each use case.

Development: Use bind mounts to avoid rebuilding the image for every code change. This allows you to edit code on your local machine and see changes reflected inside the container instantly.
Production: Precompile assets and ensure you’re only including what’s necessary for running the app. Avoid bind mounts in production and instead rely on Docker volumes to persist data like databases.

7. Testing Your Docker Image

Before deploying your Dockerized Rails app, it’s important to test your image locally. You can use commands like docker build and docker run to ensure everything is working correctly:

docker build -t my-rails-app .
docker run -p 3000:3000 my-rails-app

Additionally, you can integrate Docker into your CI/CD pipeline to automate image testing during builds and deployments.

Conclusion

By following these best practices, you can create a Docker image that is small, secure, performant, and easy to use. Remember that Dockerizing your Rails app isn’t just about putting it into a container—it’s about optimizing your build process, managing dependencies efficiently, and ensuring security and scalability in production.

Docker can drastically improve your development workflow and deployment pipelines, and with the right optimizations, you can build the best Docker image for your Rails app. Happy Dockerizing!