Docker deployment in Ruby on Rails - Deep Dive

Overview - Docker deployment

What is it?

Docker deployment means packaging your Rails application and all its parts into a container that can run anywhere. This container includes the app code, Ruby, Rails, and any other tools it needs. It makes running your app consistent on your computer, servers, or cloud. You don’t have to worry about missing software or different setups.

Why it matters

Without Docker deployment, setting up a Rails app on different machines can be slow and error-prone. You might spend hours fixing environment problems or version mismatches. Docker solves this by creating a single package that works the same everywhere. This saves time, reduces bugs, and makes your app easier to share and scale.

Where it fits

Before learning Docker deployment, you should know basic Rails app structure and how to run Rails locally. After mastering Docker deployment, you can learn about orchestration tools like Kubernetes or cloud services that run Docker containers automatically.

Mental Model

Core Idea

Docker deployment packages your Rails app and its environment into a portable container that runs the same everywhere.

Think of it like...

Imagine packing everything you need for a camping trip into one backpack. No matter where you go, you have all your gear ready and nothing is missing or different.

┌─────────────────────────────┐
│       Docker Container       │
│ ┌───────────────┐           │
│ │ Rails App     │           │
│ │ Ruby & Gems   │           │
│ │ System Tools  │           │
│ └───────────────┘           │
└─────────────────────────────┘
         ↑
         │
   Runs identically
   on any machine

Build-Up - 7 Steps

1

Foundation

What is Docker and Containers

Concept: Docker is a tool that creates containers, which are like small packages holding your app and everything it needs.

Docker containers are lightweight, isolated environments. They include your app code, system libraries, and dependencies. Unlike virtual machines, containers share the host system’s kernel but keep apps separated. This means containers start fast and use less space.

Result

You understand that Docker containers are self-contained units that can run your Rails app anywhere without setup differences.

Understanding containers as isolated packages helps you see why Docker deployment solves environment problems.

2

Foundation

Basic Rails App Structure

Concept: A Rails app has folders for code, configuration, and dependencies that Docker needs to include.

Rails apps have folders like app/, config/, db/, and files like Gemfile for Ruby gems. Docker needs to copy these into the container and install gems inside it. Knowing this structure helps you write Docker instructions.

Result

You can identify which parts of your Rails app must be included in the Docker container.

Knowing your app’s structure is key to building a Docker image that works correctly.

3

Intermediate

Writing a Dockerfile for Rails

🤔Before reading on: do you think the Dockerfile should install Ruby first or copy app code first? Commit to your answer.

Concept: A Dockerfile is a recipe that tells Docker how to build your app’s container step-by-step.

A typical Dockerfile for Rails starts from a Ruby base image, sets working directory, copies Gemfile and Gemfile.lock, runs bundle install, then copies the rest of the app code. It ends by specifying how to start the Rails server.

Result

You can create a Dockerfile that builds a container with Ruby, gems, and your Rails app ready to run.

Understanding the order in Dockerfile commands helps optimize build speed and cache use.

4

Intermediate

Using Docker Compose for Multi-Services

🤔Before reading on: do you think Docker Compose runs multiple containers in one command or just one? Commit to your answer.

Concept: Docker Compose lets you define and run multiple containers together, like your Rails app and a database.

A docker-compose.yml file describes services, such as a Rails app container and a PostgreSQL container. It sets environment variables, ports, and volumes. Running 'docker-compose up' starts all services together, making development easier.

Result

You can run your Rails app and database in separate containers with one command.

Knowing how Compose links containers simplifies managing complex apps with multiple parts.

5

Intermediate

Managing Data with Volumes

Concept: Docker volumes let your app save data outside the container so it’s not lost when containers stop.

Databases like PostgreSQL store data in volumes. Volumes are folders on your computer or server mapped into containers. This keeps data safe even if you rebuild or remove containers.

Result

Your Rails app’s database data persists across container restarts and rebuilds.

Understanding volumes prevents accidental data loss during development or deployment.

6

Advanced

Optimizing Docker Images for Rails

🤔Before reading on: do you think smaller Docker images build faster or slower? Commit to your answer.

Concept: Optimizing Docker images reduces size and build time, improving deployment speed and resource use.

Techniques include using slim base images, ordering Dockerfile commands to maximize cache, cleaning up temporary files, and using multi-stage builds to separate build and runtime environments.

Result

You create smaller, faster Docker images that deploy quickly and use less disk space.

Knowing optimization tricks helps your app scale better and reduces cloud costs.

7

Expert

Handling Secrets and Environment Variables

🤔Before reading on: do you think storing secrets inside Docker images is safe? Commit to your answer.

Concept: Managing secrets like API keys securely is critical in Docker deployments.

Never bake secrets into images. Use environment variables, Docker secrets, or external vaults. Docker Compose and orchestration tools support secret management. This keeps sensitive data out of code and images.

Result

Your Rails app runs securely with secrets injected at runtime, reducing risk of leaks.

Understanding secret management protects your app and users from security breaches.

Under the Hood

Docker uses OS-level virtualization to create containers that share the host kernel but isolate processes, files, and network. When you build a Docker image, Docker reads the Dockerfile instructions and creates layers for each step. These layers are cached and combined to form the final image. Running a container starts a process inside this isolated environment with its own filesystem and network.

Why designed this way?

Docker was designed to solve the 'works on my machine' problem by packaging apps with their environment. Using OS-level virtualization instead of full virtual machines makes containers lightweight and fast. Layered images allow efficient storage and reuse, speeding up builds and deployments.

┌───────────────┐
│   Host OS     │
│ ┌───────────┐ │
│ │ Docker    │ │
│ │ Engine    │ │
│ └───────────┘ │
│  ┌─────────┐  │
│  │Image    │  │
│  │Layers   │  │
│  └─────────┘  │
│  ┌─────────┐  │
│  │Container│  │
│  │Process  │  │
│  └─────────┘  │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think Docker containers are full virtual machines? Commit yes or no.

Common Belief: Docker containers are just like virtual machines with their own operating system.

Reality: Containers share the host OS kernel and isolate only the app environment, making them lighter and faster than virtual machines.

Why it matters: Believing containers are full VMs leads to overestimating resource needs and slower deployment strategies.

Quick: Do you think you should include your database data inside the Docker image? Commit yes or no.

Common Belief: All app data, including databases, should be inside the Docker image for portability.

Reality: Database data should be stored in volumes outside the image to persist across container restarts and updates.

Why it matters: Including data inside images causes data loss when containers are rebuilt or removed.

Quick: Is it safe to put API keys directly in your Dockerfile? Commit yes or no.

Common Belief: Putting secrets like API keys in Dockerfiles is fine because images are private.

Reality: Secrets in Dockerfiles get baked into images and can be exposed if images are shared or leaked.

Why it matters: Exposing secrets risks security breaches and data theft.

Quick: Do you think Docker Compose is only for development? Commit yes or no.

Common Belief: Docker Compose is just a development tool and not used in production.

Reality: Docker Compose can be used in production for simple multi-container setups, though orchestration tools are preferred for complex systems.

Why it matters: Ignoring Compose’s production use limits deployment options and flexibility.

Expert Zone

1

Docker image layer caching depends heavily on the order of commands; changing early steps invalidates cache for all following steps.

2

Using multi-stage builds can separate build dependencies from runtime, reducing image size and attack surface.

3

Network configurations in Docker can affect Rails app behavior, especially with WebSockets or ActionCable, requiring careful port and host setup.

When NOT to use

Docker deployment is not ideal for very simple apps where native installation is trivial or for apps requiring heavy GUI or hardware access. Alternatives include traditional server setups or platform-specific deployment services like Heroku or AWS Elastic Beanstalk.

Production Patterns

In production, Rails apps often use Docker with orchestration tools like Kubernetes for scaling, health checks, and rolling updates. Images are built in CI pipelines, scanned for vulnerabilities, and deployed with secrets managed by vaults or Kubernetes secrets.

Connections

Virtual Machines

Docker containers are a lightweight alternative to virtual machines.

Understanding VMs helps grasp why containers are faster and use fewer resources by sharing the host OS.

Continuous Integration/Continuous Deployment (CI/CD)

Docker deployment integrates tightly with CI/CD pipelines to automate building and releasing Rails apps.

Knowing Docker deployment enables smoother, repeatable app delivery in automated workflows.

Supply Chain Management

Docker images and containers mirror supply chain concepts of packaging, shipping, and delivering goods reliably.

Seeing Docker deployment as a supply chain helps understand the importance of consistent packaging and secure delivery.

Common Pitfalls

#1 Not caching bundle install leads to slow builds.

Wrong approach:

FROM ruby:3.1
WORKDIR /app
COPY . .
RUN bundle install
CMD ["rails", "server"]

Correct approach:

FROM ruby:3.1
WORKDIR /app
COPY Gemfile Gemfile.lock ./
RUN bundle install
COPY . .
CMD ["rails", "server"]

Root cause:

Copying the whole app before bundle install invalidates Docker cache, causing bundle install to run every build.

#2 Storing database data inside container causes data loss.

Wrong approach:

docker-compose.yml:
volumes: []

Correct approach:

docker-compose.yml:
volumes:
- db-data:/var/lib/postgresql/data

Root cause:

Without volumes, container filesystem is ephemeral and data disappears when container stops.

#3 Hardcoding secrets in Dockerfile exposes sensitive info.

Wrong approach:

ENV SECRET_KEY_BASE=supersecretkey

Correct approach:

Use environment variables or Docker secrets injected at runtime, not in Dockerfile.

Root cause:

Dockerfiles are stored in version control and images can be shared, exposing secrets.

Key Takeaways

Docker deployment packages your Rails app and environment into a portable container that runs the same everywhere.

Writing an efficient Dockerfile and using Docker Compose simplifies running multi-service Rails apps with databases.

Managing data with volumes and secrets securely is critical to avoid data loss and security risks.

Optimizing Docker images improves build speed and reduces resource use, important for production deployments.

Understanding Docker’s internal layering and caching helps prevent common mistakes and speeds up development.