If you're a software developer and have never used Docker before, just like me until very recently, this blog post is for you! We'll be discussing what Docker is, the differences between Docker and Virtual Machines, the benefits of using Docker, and a step-by-step guide on creating a new Ruby on Rails application with a Rails image on Docker.

What is Docker?

Docker is an open-source platform that allows developers to automate the deployment, scaling, and management of applications. It enables the creation of lightweight, portable containers that can run software and its dependencies consistently across different environments. This makes it easier to develop, test, and deploy applications without worrying about inconsistencies between various environments.

Docker vs. Virtual Machines

Docker and Virtual Machines (VMs) have similarities in that they both allow for the isolation of applications, but they differ in their approach and resource utilization. Here's a brief comparison of the two:

Pros of Docker:

Lightweight: Docker containers share the host OS kernel, which makes them lightweight and faster to start compared to VMs.
Efficient: Containers require fewer resources than VMs, resulting in better performance.
Portable: Docker images are platform-agnostic, which means you can run them on any system with Docker installed.

Cons of Docker:

Limited isolation: Containers share the host OS kernel, which can result in less isolation compared to VMs.
Platform-dependent: Docker runs natively on Linux and requires a virtualization layer on Windows and macOS, which can affect performance.

Pros of Virtual Machines:

Full isolation: VMs provide complete isolation of applications and resources from the host system, offering better security.
Platform support: VMs run on various platforms, including Windows, Linux, and macOS.

Cons of Virtual Machines:

Resource-intensive: VMs require more resources as they run a complete OS for each instance.
Slower: VMs take longer to start up and have higher overheads compared to Docker containers.

Benefits of Using Docker

Consistent environments: Docker ensures that your application runs consistently across different environments.
Scalability: Easily scale your application by deploying multiple containers.
Version control: Docker images can be versioned, making it easier to roll back to previous versions or update to new ones.
Easier collaboration: Share your Docker images with other team members, streamlining the development process.
Faster deployment: Containers are lightweight and start up quickly, speeding up the deployment process.

Installing Docker

Before we begin, ensure that you have Docker installed on your computer. You can download and install Docker from the official website (https://www.docker.com/products/docker-desktop) for Windows, macOS, or Linux.

Creating a New Rails Application with a Rails Image on Docker

Create a new Rails application:

$ rails new my_docker_app --database=postgresql
$ cd my_docker_app

2. Create a Dockerfile in your Rails application root directory:

FROM ruby:3.0.2
RUN apt-get update -qq && apt-get install -y nodejs postgresql-client
RUN mkdir /my_docker_app
WORKDIR /my_docker_app
COPY Gemfile /my_docker_app/Gemfile
COPY Gemfile.lock /my_docker_app/Gemfile.lock
RUN bundle install
COPY . /my_docker_app

3. Create a docker-compose.yml file in the root directory:

version: "3.8"
services:
  web:
    build: .
    command: bundle exec rails s -p 3000 -b '0.0.0.0'
    volumes:
      - .:/myapp
    ports:
      - "3000:3000"
    depends_on:
      - db
  db:
    image: postgres:13
    volumes:
      - postgres_data:/var/lib/postgresql/data/
    environment:
      - POSTGRES_USER=myapp
      - POSTGRES_PASSWORD=myapp
volumes:
  postgres_data:

This docker-compose.yml file sets up two services, web and db, representing the Rails application and the PostgreSQL database, respectively. The application's source code is mounted as a volume to /myapp, and the application listens on port 3000. The PostgreSQL image version 13 is used for the database, and the database's data is stored in the named volume postgres_data.

4. Modify your `config/database.yml` file to use the Docker PostgreSQL service:

```yaml
default: &default
  adapter: postgresql
  encoding: unicode
  host: db
  username: postgres
  password:
  pool: 5

development:
  <<: *default
  database: my_docker_app_development

test:
  <<: *default
  database: my_docker_app_test

5. Build the Docker image:

$ docker-compose build

6. Create the database:

$ docker-compose run web rails db:create

7. Start the Rails application:

$ docker-compose up

Now, visit http://localhost:3000 in your browser to access your Rails application running in a Docker container.

Conclusion

In this blog post, we've introduced Docker, compared it with Virtual Machines, and discussed the benefits of using Docker. We also provided a step-by-step guide on creating a new Rails application with a Rails image on Docker. With Docker, you can develop, test, and deploy your Rails applications consistently and efficiently, making it an indispensable tool for modern software developers.

Dockering a Ruby on Rails Application: A Comprehensive Guide for Beginners