Docker Essentials: A Comprehensive Guide to Containerization

Publish on: 2024/06/09 Classify at: CODE

Words: 2358 Read:≈ 12mins

Summary

This post provides a comprehensive introduction to Docker, covering its core concepts, installation process, and practical usage. It explores how to run containers, manage multi-container applications with Docker Compose, persist data using volumes, and access local folders through bind mounts. The guide includes step-by-step tutorials for containerizing applications, developing within containers, and publishing images to Docker Hub. A handy cheat sheet summarizes essential commands for container and image management, while the FAQ section addresses common issues. Whether you're new to containerization or looking to enhance your Docker skills, this guide offers valuable insights into streamlining your development and deployment workflows.

Here’s the Introduction to Docker and Quick Start Tutorial translated into English:

1. What is Docker?

1.1 Overview

Docker is an open-source containerization platform that allows developers to package applications and their dependencies into lightweight, portable containers. Unlike virtual machines (VMs), containers share the host machine’s OS kernel instead of emulating a full OS, enabling faster startup times and lower resource usage.

1.2 Why Use Docker?

Consistent Environments: Eliminates the “it works on my machine” problem.
Rapid Deployment: Start containers in seconds, improving development and deployment efficiency.
Resource Isolation: Containers run independently, avoiding dependency conflicts.
Portability: Run seamlessly across Linux, macOS, and Windows.

2. Core Concepts

Image: A read-only template with code, libraries, and configurations (e.g., ubuntu, nginx).
Container: A running instance of an image (like a lightweight VM).
Registry: A repository for storing images, such as Docker Hub .

3. Install Docker

3.1 Linux (Ubuntu)

Set up Docker’s apt repository.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
# Add Docker's official GPG key:
sudo apt-get update
sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

Install the Docker packages.

`1`	`sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin`

Verify that the installation is successful by running the hello-world image:
1
sudo docker run hello-world
This command downloads a test image and runs it in a container. When the container runs, it prints a confirmation message and exits.

macOS/Windows

Download and install Docker Desktop .

4. Basic Usage (Windows)

4.1 How to run a container

Docker containers are created from images, which serve as blueprints containing all the necessary components for running an application. In this section, we’ll walk through the process of creating a Docker image using a Dockerfile and a practical example application.

Get the sample application
Clone the repository at https://github.com/docker/welcome-to-docker .
1
git clone https://github.com/docker/welcome-to-docker
The rest of this guide requires you to run commands in the new project directory. Run the following command before moving on.
1
cd welcome-to-docker

Verify your Dockerfile

Open the sample application in your IDE. Note that it already has a Dockerfile. For your own projects you need to create this yourself.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# Start your image with a node base image
FROM node:18-alpine

# The /app directory should act as the main application directory
WORKDIR /app

# Copy the app package and package-lock.json file
COPY package*.json ./

# Copy local directories to the current local directory of our docker image (/app)
COPY ./src ./src
COPY ./public ./public

# Install node packages, install serve, build the app, and remove dependencies at the end
RUN npm install \
    && npm install -g serve \
    && npm run build \
    && rm -fr node_modules

EXPOSE 3000

# Start the app using serve command
CMD [ "serve", "-s", "build" ]

Build your first image
You can build an image using the following docker build command via a CLI in your project folder.
1
docker build -t welcome-to-docker .
The -t flag tags your image with a name. (welcome-to-docker in this case). And the . lets Docker know where it can find the Dockerfile.
Run your container
Once the build is complete, an image will appear in the Images tab. Select the image name to see its details. Select Run to run it as a container. In the Optional settings remember to specify a port number (something like 8089).
Verify the frontend
You now have a running container. If you don’t have a name for your container, Docker provides one. View your container live by selecting the link below the container’s name.

4.2 Run Docker Hub images

Search for the image
You can search images by selecting the bar at the top, or by using the Ctrl + K shortcut. Search for welcome-to-docker to find the image used in this guide.
Run the image
Select Run. When the Optional settings appear, specify the Host port number 8090 and then select Run. You can also select View on Hub to learn more about an image.
Explore the container
Go to the Containers tab in Docker Desktop to view the container.

4.3 Multi-container applications

Normally you must start each container individually. Imagine how great it would be if a tool could start multiple containers with a single command. That tool is Docker Compose.

Get the sample application
Clone the repository at https://github.com/docker/multi-container-app ⁠.
1
git clone https://github.com/docker/multi-container-app
Understanding the sample
This is a simple todo application built using ExpressJS and Node. All todos are saved in a MongoDB database.

Digging into the compose.yml

If you view the code of the sample application, you will notice that it has a compose.yaml file. This file tells Docker how to run your application. Open the compose.yaml file in a text editor to explore the instructions.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
# Comments are provided throughout this file to help you get started.
# If you need more help, visit the Docker compose reference guide at
# https://docs.docker.com/compose/compose-file/

# Here the instructions define your application as two services called "todo-app" and “todo-database”
# The service “todo-app” is built from the Dockerfile in the /app directory,
# and the service “todo-database” uses the official MongoDB image 
# from Docker Hub - https://hub.docker.com/_/mongo. 
# You can add other services your application may depend on here.

services:
  todo-app:
    build:
      context: ./app
    depends_on:
      - todo-database
    environment:
      NODE_ENV: production
    ports:
      - 3000:3000
      - 35729:35729
    develop:
      watch:
        - path: ./app/package.json
          action: rebuild
        - path: ./app
          target: /usr/src/app
          action: sync

  todo-database:
    image: mongo:6
    #volumes: 
    #  - database:/data/db
    ports:
      - 27017:27017

#volumes:
  #database:

Running the application
We are going to run this application with the docker compose up command in your project directory. This command builds and runs all the services listed in the compose file.
1
docker compose up -d
The -d flag tells docker compose to run in detached mode.
View the frontend
In Docker Desktop, you should now have two containers running (the todo-app, and todo-database). To view the frontend, expand the app stack in Containers and select the link to localhost:3000⁠.
Add some tasks in the frontend, and then open the app in a new tab. Notice that the tasks are still visible.
Develop in your containers
When developing with Docker, you may need to automatically update and preview your running services as you edit and save your code. We use docker compose watch for this.
Run the following command to run your project with compose watch.
1
docker compose watch
Now change the text in line 18 of the app app/views/todos.ejs to see your changes in real time.
Read more about how to set this up in your own applications via the compose watch documentation⁠.
Stop watch mode: You can stop watch with Ctrl + C shortcut.
Delete everything and restart
Having your configuration stored in a Compose file has another advantage, you can easily delete everything and restart.
Simply select the app stack, and then select Delete on Docker Desktop. When you want to restart, run docker compose up in the project folder again. This will restart your application again. Note that when the db container is deleted, any todos created are also lost.

4.4 Persist your data between containers

Container data is isolated from your local folders.

Docker isolates all content, code, and data in a container from your local filesystem. This means, that when you delete a container within Docker Desktop, all the content within it is deleted.

Sometimes you may want to persist data that a container generated. This is when you can use volumes.

Get the sample application
Clone the repository at https://github.com/docker/multi-container-app ⁠.
1
git clone https://github.com/docker/multi-container-app
How volumes work
If you want to persist data even after a container is deleted, you can use a volume. A volume is a location in your local filesystem, managed by Docker.
Adding volumes to Compose
To add a volume to this project, simply go to the compose.yaml file and uncomment the following lines:
1 2 3 4 5 6 7 8
todo-database: # ... volumes: - database:/data/db # ... volumes: database:
The volumes element that is nested in todo-database tells Compose to mount the volume named database to /data/db in the container for the todo-database service.
The top-level volumes element defines and configures a volume named database that can be used by any of the services in the Compose file.
Delete and restart
Now, no matter how often you delete and restart the container, your data is persisted and accessible to any container on your system by mounting the database volume. Docker will check for a volume and create one if there is none present.

4.5 Access your local folder from a container

Docker isolates all content, code, and data in a container from your local filesystem.

Sometimes you may want the container to access a directory on your system. This is when you use bind mounts.

Get the sample application
Clone the repository at https://github.com/docker/bindmount-apps⁠ .
1
git clone https://github.com/docker/bindmount-apps
How bind mounts work
want to access data on your system, you can use a bind mount. A bind mount lets you share a directory from your host’s filesystem into the container.
Adding bind mounts to Compose
To add a bind mount to this project, simply go to the compose.yaml file and uncomment the following lines:
1 2 3 4 5
todo-app: # ... volumes: - ./app:/usr/src/app - /usr/src/app/node_modules
The volumes element tells Compose to mount the local folder ./app to /usr/src/app in the container for the todo-app service. This particular bind mount overwrites the static contents of the /usr/src/app directory in the container and creates what is known as a development container. The second instruction, /usr/src/app/node_modules, prevents the bind mount from overwriting the container’s node_modules directory to preserve the packages installed in the container.
Running the application
Run this application with the docker compose up command in your project directory.
1
docker compose up -d
Develop the app
Now, you can take advantage of the container’s environment while you develop the app on your local system. Any changes you make to the app on your local system are reflected in the container. In your local directory, open app/views/todos.ejs in an IDE or text editor, update the Enter your task string, and save the file. Visit or refresh localhost:3001⁠ to see the changes.

4.6 Containerize your application

Introducing Docker init

When working with containers, you usually need to create a Dockerfile to define your image and a compose.yaml file to define how to run it.

To help you create these files, Docker has a command called docker init. Run this command in a project folder, and Docker will create all the required files needed. In this guide, you will see how this works.

Run the command
Open your project folder in the terminal and run the following command:
1
docker init
Docker will detect the language of your project and prompt you to select a language. You can select your language if it is in the list, or select Other if your language isn’t in the list.
Sensible defaults
docker init walks you through a few questions to configure your project with sensible defaults.
Some assembly required
Once you have answered all the questions, you may run docker compose up to run your project.
There is a chance, however, that the Dockerfile and compose.yaml file created for your project need additional changes. In this case, you may need to look up the Dockerfile reference ⁠ and Compose file reference ⁠ in the documentation. We try our best to do the heavy lifting for you, but sometimes there’s some assembly required.

4.7 Publish your image

Get an image
For this guide, you need at least one image on your computer. If you don’t have one, search for the welcome-to-docker image, and select Pull.
Sign in to Docker
Select Sign in on the top-right of Docker Desktop to either sign in or create a new account on Docker Hub.
Rename your image
Before you can publish your image, you need to rename it so that Docker Hub knows that the image is yours. Run the following command to rename your image. Replace YOUR-USERNAME with your Docker ID.
1
docker tag docker/welcome-to-docker YOUR-USERNAME/welcome-to-docker
Publish your image to Docker Hub
Go to the Images tab and find your image. In the Actions column, select the Show image actions icon and then select Push.
Go to Docker Hub ⁠ and you should see the welcome-to-docker repository.

5. Cheat Sheet

5.1 Container Management

Command	Description	Example
Create and start a container	Run a container from an image	`docker run -it ubuntu /bin/bash`
Run in detached mode	Run in the background with `-d`	`docker run -d -p 8080:80 nginx`
List containers	View running/all containers	`docker ps` `docker ps -a` (include stopped)
Stop/Delete containers	Manage container lifecycle	`docker stop <container_id>` `docker rm <container_id>`
Enter a container	Use `exec` (exit without stopping)	`docker exec -it <container_id> /bin/bash`

5.2 Image Management

Command	Description	Example
Pull an image	Download from a registry	`docker pull ubuntu:latest`
List images	View local images	`docker images`
Delete an image	Remove unused images	`docker rmi -f <image_name/ID>`
Build a custom image	Use a Dockerfile	`docker build -t my-app:latest .`

5.3 Operations and Monitoring

Command	Description	Example
Start Docker service	Manage Docker daemon	`sudo systemctl start docker` `sudo systemctl enable docker`
View logs	Debug container output	`docker logs <container_id>`
Resource usage	Monitor CPU/memory	`docker stats <container_id>`
Cleanup resources	Remove unused data	`docker system prune`

6. More guides

This guide covers Docker basics. For advanced topics, refer to the official documentation .