Rails Deployment with Docker and Kubernetes

Ruby on Rails is a popular web development framework known for its ease of use and rapid development capabilities. Once your Rails application is developed, the next step is to deploy it to a production environment. Deployment can be a complex process that involves a variety of tasks, such as configuring servers, installing dependencies, setting up databases, and more. One way to simplify the deployment process is to use containerization with Docker and orchestration with Kubernetes. In this blog, we’ll explore how to deploy a Rails application with Docker and Kubernetes.

1. What is Docker?

Docker is a popular containerization platform that allows you to package your application and its dependencies into a single container that can run on any platform. Containers are lightweight, portable, and isolated from the underlying host system, which makes them an ideal deployment option for modern applications.

Docker works by creating a virtualized environment that includes all the dependencies required by your application, such as libraries, frameworks, and system tools. This container can be run on any platform that supports Docker, including local development machines, cloud servers, and Kubernetes clusters.

2. What is Kubernetes?

Kubernetes is an open-source container orchestration platform that automates the deployment, scaling, and management of containerized applications. Kubernetes provides a flexible and scalable infrastructure that allows you to deploy your application with ease, and manage it efficiently.

Kubernetes works by grouping containers into logical units called pods. These pods can be replicated and distributed across multiple nodes in a cluster to ensure high availability and scalability. Kubernetes provides a wide range of features for managing your application, including load balancing, auto-scaling, rolling updates, and more.

3. Deploying Rails with Docker and Kubernetes

Now that we have a basic understanding of Docker and Kubernetes, let’s explore how to deploy a Rails application using these tools.

Step 1: Containerizing your Rails application

The first step in deploying your Rails application with Docker is to create a Docker image of your application. A Docker image is a self-contained package that includes your application code, dependencies, and any required system libraries.

To create a Docker image of your Rails application, you can start by creating a Dockerfile. The Dockerfile is a simple text file that contains a set of instructions for building your Docker image. Here’s an example Dockerfile for a Rails application:

# Use the official Ruby image as the base image
FROM ruby:2.7.1

# Set the working directory to /app
WORKDIR /app

# Copy the Gemfile and Gemfile.lock into the image
COPY Gemfile Gemfile.lock ./

# Install the dependencies
RUN bundle install

# Copy the rest of the application into the image
COPY . .

# Start the Rails server
CMD ["rails", "server", "-b", "0.0.0.0"]

This Dockerfile starts with the official Ruby image as the base image, sets the working directory to /app, installs the required dependencies using Bundler, copies the application files into the container, and starts the Rails server.

Once you have created the Dockerfile, you can build the Docker image using the docker build command:

docker build -t my-rails-app .

This command builds the Docker image and tags it with the name my-rails-app.

Step 2: Deploying your Rails application with Kubernetes

Now that we have created a Docker image of our Rails application, we can deploy it with Kubernetes.

The first step is to create a Kubernetes deployment that defines how many instances of our application we want to run, what Docker image to use, and what resources our application needs. Here’s an example deployment YAML file:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-rails-app
  labels:
app: my-rails-app

spec:
replicas: 3
selector:
matchLabels:
app: my-rails-app
template:
metadata:
labels:
app: my-rails-app
spec:
containers:
- name: my-rails-app
image: my-rails-app:latest
ports:
- containerPort: 3000

This YAML file creates a Kubernetes deployment with the name `my-rails-app`, running three replicas of the `my-rails-app` container using the latest Docker image. It also specifies that the container should listen on port 3000.

Once you have created the deployment YAML file, you can create the deployment using the `kubectl create` command:

kubectl create -f my-rails-app-deployment.yml

This command creates the deployment and starts the specified number of replicas of the container.

Next, we need to expose our application to the outside world. We can do this by creating a Kubernetes service that exposes our application to the internet. Here’s an example service YAML file:

apiVersion: v1
kind: Service
metadata:
name: my-rails-app
spec:
type: LoadBalancer
selector:
app: my-rails-app
ports:
- name: http
port: 80
targetPort: 3000

This YAML file creates a Kubernetes service with the name `my-rails-app`, using a load balancer to expose the application to the internet. It also specifies that the service should route traffic to port 3000 on the `my-rails-app` container.

Once you have created the service YAML file, you can create the service using the `kubectl create` command:

kubectl create -f my-rails-app-service.yml

This command creates the service and exposes the application to the internet.

4. Conclusion

Deploying a Rails application with Docker and Kubernetes can seem like a daunting task at first, but it’s a powerful and flexible way to deploy modern applications. By containerizing your application with Docker and orchestrating it with Kubernetes, you can simplify the deployment process and make your application more scalable and resilient.

In this blog, we’ve explored the basics of deploying a Rails application with Docker and Kubernetes. We’ve seen how to create a Docker image of our application, and how to deploy it with Kubernetes using a deployment and service YAML file. With this knowledge, you can take the next steps towards building a production-ready Rails application and deploying it with confidence.