To run a Ruby application in Docker, you'll need to create a Dockerfile that sets up the environment for Ruby, installs dependencies, and runs your Ruby script. Below is an example showing how to containerize a simple Ruby application.

Steps to Dockerize a Ruby Application

We will walk through creating a Ruby script and setting up a Dockerfile to run it inside a Docker container.

1. Prepare Your Ruby Application

Let's start by creating a simple Ruby script. We'll name it app.rb.

app.rb:

puts "Hello from Docker and Ruby!"

This is a very basic Ruby script that simply prints a message.

2. Create a Dockerfile

Now, we'll create a Dockerfile to containerize the Ruby application.

Example Dockerfile:

# Step 1: Use the official Ruby image from Docker HubFROM ruby:3.1-slim# Step 2: Set the working directory inside the containerWORKDIR /usr/src/app# Step 3: Copy the Ruby script into the containerCOPY app.rb .# Step 4: Run the Ruby script when the container startsCMD ["ruby", "app.rb"]

Explanation of the Dockerfile:

1. FROM ruby:3.1-slim: This line uses an official Ruby image based on Debian, which includes Ruby 3.1 installed, and the slim tag ensures a smaller image size.
2. WORKDIR /usr/src/app: This sets the working directory inside the container to /usr/src/app. This is where we’ll copy our Ruby script.
3. COPY app.rb .: This copies the app.rb Ruby script from your local machine into the /usr/src/app directory in the container.
4. CMD ["ruby", "app.rb"]: This command tells Docker to run the app.rb script using the Ruby interpreter when the container starts.

3. Build the Docker Image

Now that you have the Dockerfile and the Ruby script, the next step is to build the Docker image.

In your terminal (or command prompt), navigate to the directory where the Dockerfile and app.rb are located. Then run the following command to build the Docker image:

docker build -t ruby-docker-app .

This command will build the Docker image with the tag ruby-docker-app.

4. Run the Docker Container

Once the image is built, you can run the container and execute the Ruby script.

Run the following command to start the container:

docker run ruby-docker-app

You should see the following output:

Hello from Docker and Ruby!

This confirms that your Ruby script is running inside the Docker container.

5. (Optional) Share the Image on Docker Hub

If you'd like to share your Docker image, you can push it to Docker Hub. Here's how to do it:

1. Log in to Docker Hub:

   docker login
   

   Enter your Docker Hub username and password when prompted.

2. Tag the Image:

   Tag your image so it's ready for Docker Hub. Replace yourusername with your Docker Hub username.

   docker tag ruby-docker-app yourusername/ruby-docker-app
   

3. Push the Image to Docker Hub:

   Push the tagged image to Docker Hub with the following command:

   docker push yourusername/ruby-docker-app
   

   Now, your image will be available on Docker Hub for others to pull and run.

6. (Optional) Add Dependencies

If your Ruby application has dependencies (e.g., gems), you can include them in the Dockerfile. Let’s say you want to install the rails gem.

1. Create a Gemfile:

   source 'https://rubygems.org'gem 'rails', '6.1.4'
   

2. Update the Dockerfile to install dependencies:

   # Step 1: Use the official Ruby image from Docker HubFROM ruby:3.1-slim# Step 2: Set the working directory inside the containerWORKDIR /usr/src/app# Step 3: Copy the Gemfile and install dependenciesCOPY Gemfile Gemfile.lock ./RUN bundle install# Step 4: Copy the Ruby script into the containerCOPY app.rb .# Step 5: Run the Ruby script when the container startsCMD ["ruby", "app.rb"]
   

3. Build the Image with dependencies:

   docker build -t ruby-docker-app .
   

   The bundle install command will install any gems listed in the Gemfile.

Conclusion

You have now successfully containerized a simple Ruby application using Docker. By following these steps, you can ensure that your Ruby application runs consistently on any machine that supports Docker, making it easy to deploy and share your applications.

If you want to extend this, you can add more complexity (e.g., a Ruby on Rails application, background jobs, or a database) by adjusting the Dockerfile accordingly.