An introduction to containerization and Docker

Introduction

Containerization is a technology that allows you to package and deploy applications in a self-contained and portable manner. This means that you can easily move your application from one environment to another, such as from your local development machine to a staging or production server, without worrying about dependencies or configuration differences.

One of the most popular tools for containerization is Docker. Docker is an open-source containerization platform that provides an easy way to package and deploy applications as containers. A Docker container is a lightweight, standalone, and executable package that contains everything an application needs to run, including the application code, system tools, libraries, and runtime.

How to start?

To use Docker, you need to install the Docker Engine on your machine. The Docker Engine is a daemon that manages the containers and provides the interface for interacting with Docker. You can install Docker on Windows, macOS, and Linux.

Once you have Docker installed, you can start working with containers. To create a Docker container, you need to create a Dockerfile. A Dockerfile is a text file that contains the instructions for building the container image. The image is a blueprint for the container, and it specifies what the container should contain, such as the operating system, libraries, and application code.

Here's an example of a simple Dockerfile that creates an image for a Node.js application:

FROM node:14-alpine

WORKDIR /app

COPY package.json .

RUN npm install

COPY . .

EXPOSE 8080

CMD ["npm", "start"]

This Dockerfile starts with the FROM instruction, which specifies the base image for the container. In this case, it's using the node:14-alpine image, which is a minimalistic Node.js image based on the Alpine Linux distribution.

The WORKDIR instruction sets the working directory for the subsequent instructions. The COPY instruction copies the package.json file from the host machine to the /app directory in the container. The RUN instruction runs the npm install command, which installs the dependencies specified in the package.json file. The COPY instruction again copies the application code from the host machine to the /app directory in the container.

The EXPOSE instruction tells Docker that the container listens on the specified port at runtime. In this case, it's listening on port 8080. The CMD instruction specifies the command to run when the container is started. In this case, it's running the npm start command, which starts the application.

To build the image from the Dockerfile, you can use the docker build command:

docker build -t my-node-app .

This command builds the image and gives it the tag my-node-app. The . at the end specifies the context of the build, which is the current directory.

Once the image is built, you can use the docker run command to start a container from the image:

docker run -p 8080:8080 my-node-app

This command starts a container from the my-node-app image and maps the host's port 8080 to the container's port 8080. This means that you can access the application from your host machine at http://localhost:8080.

Docker provides many other useful commands for managing and interacting with containers. For example, you can use the docker ps command to list the running containers:

docker ps

This command will display a list of running containers, along with their ID, image, command, and status.

You can also use the docker stop command to stop a running container:

$ docker stop <CONTAINER_ID>

Replace with the ID of the container that you want to stop.

If you want to remove a container, you can use the docker rm command:

docker rm <CONTAINER_ID>

Again, replace with the ID of the container that you want to remove.

In addition to running individual containers, Docker also provides a way to manage multiple containers as a single unit using Docker Compose. Docker Compose is a tool for defining and running multi-container Docker applications. With Docker Compose, you can define the application's components and their dependencies in a single file, and then start and stop all the containers with a single command.

Here's an example of a docker-compose.yml file for a simple Node.js application with a MongoDB database:

version: '3'
services:
  app:
    build: .
    ports:
      - "8080:8080"
    depends_on:
      - db
  db:
    image: mongo:4.4
    ports:
      - "27017:27017"

This file defines two services: app and db. The app service is built from the current directory, and it depends on the db service. The db service uses the mongo:4.4 image, which is a MongoDB image.

To start the containers, you can use the docker-compose up command:

docker-compose up

This command will build the app image, start the db and app containers, and display their logs in the console.

To stop the containers, you can use the docker-compose down command:

docker-compose down

This command will stop the containers and remove them.

Summary

That's a brief introduction to containerization and Docker. I hope you found it helpful, and I encourage you to try out these examples on your own machine. Containerization and Docker can greatly simplify the process of developing, testing, and deploying applications, and they are widely used in the software industry.

About author

Artsiom Hontar is a software engineer, AWS solution architect, and Kubernetes admin certified. Hosting a blog about software engineering and related stuff.