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:

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

Cons of Docker:

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

Pros of Virtual Machines:

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

Cons of Virtual Machines:

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

Benefits of Using Docker

1. Consistent environments: Docker ensures that your application runs consistently across different environments.
2. Scalability: Easily scale your application by deploying multiple containers.
3. Version control: Docker images can be versioned, making it easier to roll back to previous versions or update to new ones.
4. Easier collaboration: Share your Docker images with other team members, streamlining the development process.
5. 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

1. Create a new Rails application:

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

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 /mydockerapp
   WORKDIR /mydockerapp
   COPY Gemfile /mydockerapp/Gemfile
   COPY Gemfile.lock /mydockerapp/Gemfile.lock
   RUN bundle install
   COPY . /mydockerapp

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"
   dependson:
   - db
   db:
   image: postgres:13
   volumes:
   - postgresdata:/var/lib/postgresql/data/
   environment:
   - POSTGRESUSER=myapp
   - POSTGRESPASSWORD=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.

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

   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
   

1. Build the Docker image:

   $ docker-compose build

2. Create the database:

   $ docker-compose run web rails db:create

3. 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.