Environment issues for application deployment#

Large projects have many components and complex runtime environments, so deployment often runs into issues:

• Complex dependencies can easily lead to compatibility problems
• Development, testing, and production environments differ from each other

For example, a project may depend on Node.js, Redis, RabbitMQ, MySQL, and more. The libraries and dependencies required by these services differ from each other and may even conflict, which makes deployment very difficult.

How Docker Solves Dependency Compatibility Issues#

Docker happens to solve these problems very well. How does it do that?

Docker uses two methods to solve dependency compatibility issues:

• Package the application’s Libs (libraries), Deps (dependencies), and configuration together with the application
• Run each application in an isolated container to avoid interference

This packaged application bundle includes both the application itself and the Libs/Deps it requires, so you no longer need to install them separately on the operating system. Naturally, compatibility conflicts between applications are avoided.

How Docker Solves OS Environment Differences#

To solve differences between operating system environments, we first need to understand the OS structure. Taking Ubuntu as an example, it consists of:

• Computer hardware: CPU, memory, disk, etc.
• System kernel: All Linux distributions use the Linux kernel (e.g. CentOS, Ubuntu, Fedora). The kernel interacts with hardware and exposes kernel instructions for operating hardware.
• System applications: Applications and libraries provided by the OS itself. These libraries wrap kernel instructions to make them easier to use.

The interaction flow between applications and the computer is as follows:

1. Applications call OS-provided applications (libraries) to implement various functions

2. System libraries wrap the kernel instruction set and invoke kernel instructions

3. Kernel instructions operate the computer hardware

How does Docker solve cross-system environment issues?

• Docker packages the user program together with the required system libraries (for example, Ubuntu libraries)
• When Docker runs on different operating systems, it uses the packaged libraries while relying on the host OS’s Linux kernel

Docker is a technology for quickly delivering and running applications, with the following advantages:

• It can package a program, its dependencies, and runtime environment into an image that can be migrated to any Linux operating system
• At runtime it uses sandboxing to create isolated containers so applications do not interfere with each other
• Startup and removal can both be done with a single command, which is convenient and efficient

Images and Containers#

There are several important concepts in Docker:

• Image: Docker packages an application together with its dependencies, libraries, environment, configuration, and related files into an image.
• Container: The process formed when an application in an image runs is a container. Docker isolates the container process so it is not directly visible externally.

At the end of the day, applications are made of code, and code is stored as files (bytes on disk). Only when running are they loaded into memory and become processes.

An image is a read-only package formed by bundling an application’s files on disk, its runtime environment, and some system library files.

A container loads the programs/functions in those files into memory and runs them as processes, while isolating them. Therefore, one image can be started multiple times to form multiple container processes.

DockerHub#

There are many open-source applications, and packaging them repeatedly is wasted effort. To avoid this, people publish the application images they package (such as Redis and MySQL images) online for sharing, similar to code sharing on GitHub.

• DockerHub: DockerHub is the official hosting platform for Docker images. Platforms like this are called Docker Registries.
• There are also public services similar to DockerHub, such as NetEase Cloud Image Service and Alibaba Cloud Image Repository.

We can both publish our own images to DockerHub and pull images from DockerHub.

Docker Architecture#

To use Docker to manage images and containers, we must first install Docker.

Docker follows a client-server architecture and consists of two parts:

• Server: the Docker daemon, responsible for handling Docker commands and managing images/containers
• Client: sends commands to the Docker server through CLI commands or REST API. It can send commands locally or remotely.

Image Names#

Let’s first look at how image names are composed:

• Image names are generally made of two parts: [repository]:[tag].
• If no tag is specified, the default is latest, representing the latest version of the image.

Image Commands#

Common image operations are shown below.

1
docker pull nginx  # 拉取镜像
2
docker images    # 查看拉取的镜像
3

4
# docker save -o [保存的目标文件名称] [镜像名称]
5
docker save -o nginx.tar nginx:latest  # 保存镜像
6
docker rmi nginx:latest          # 删除镜像
7
docker load -i nginx.tar        # 加载镜像

Container-Related Commands#

• docker run: Create and run a container, entering the running state

  1
  docker run --name containerName -p 80:80 -d nginx

  • docker run: Create and run a container
  • --name: Give the container a name, e.g. mn
  • -p: Map host port to container port; left side is host port, right side is container port
  • -d: Run the container in the background
  • nginx: Image name, e.g. nginx

• docker pause: Pause a running container

• docker unpause: Resume a paused container

• docker stop: Stop a running container

• docker start: Start a stopped container again

• docker rm: Delete a container

• docker exec: Enter a container

  1
  docker exec -it mn bash

  • docker exec: Enter the container and execute a command
  • -it: Create a stdin/stdout terminal for interaction
  • mn: The name of the container to enter
  • bash: The command executed after entering the container; bash is a Linux shell command

  Inside the container, Docker presents an isolated Linux filesystem that looks like a standalone Linux server.

Common parameters of the docker run command

• --name: Specify the container name
• -p: Specify port mapping
• -d: Run the container in the background

Command for viewing container logs:

• docker logs
• Add the -f parameter to continuously follow logs

Commands for checking container status:

• docker ps
• docker ps -a to view all containers, including stopped ones

What Is a Volume#

• Data volume (volume): A virtual directory that points to some directory on the host filesystem.

Once volume mounting is complete, all operations on the container path affect the corresponding host directory behind the volume.

In this way, operating on /var/lib/docker/volumes/html on the host is equivalent to operating on /usr/share/nginx/html inside the container.

Volume Operation Commands#

The basic syntax for volume operations is as follows:

1
docker volume [COMMAND]

the docker volume command is used for volume operations, and the action depends on the command that follows:

• create: create a volume
• inspect: show information about one or more volumes
• ls: list all volumes
• prune: remove unused volumes
• rm: remove one or more specified volumes

Create and Inspect Volumes#

Goal: Create a volume and check its directory location on the host machine.

1. Create a volume

1
docker volume create html

1. View all volumes

1
docker volume ls

1. View detailed information for a volume

1
docker volume inspect html

The host directory corresponding to the created html volume is /var/lib/docker/volumes/html/_data.

Mounting Volumes#

When creating a container, we can use the -v parameter to mount a volume to a directory inside the container, using the following format:

1
docker run \\
2
  --name mn \\
3
  -v html:/root/html \\
4
  -p 8080:80
5
  nginx \\

Here, -v is the volume-mount option:

• -v html:/root/html: mount the html volume to /root/html inside the container

A container can mount not only volumes, but also host directories directly. The relationships are:

• Volume mode: host directory —> volume ---> container directory
• Direct bind mount mode: host directory —> container directory

Install MySQL 5.7 with Docker:

1
# --privileged=true参数，让容器拥有真正的root权限
2
docker run --privileged=true --name mysql5.7 -p 3307:3306 \\
3
-e MYSQL_ROOT_PASSWORD=123456 -d \\
4
-v /mydata/mysql/data:/var/lib/mysql \\
5
-v /mydata/mysql/conf:/etc/mysql \\
6
-v /mydata/mysql/log:/var/log/mysql \\
7
mysql:5.7

In the docker run command, the -v parameter can mount files or directories into the container:

• -v <volume-name>:<container-dir>
• -v <host-file>:<container-file>
• -v <host-dir>:<container-dir>

Volume mounts vs direct directory mounts:

• Volume mounts have lower coupling. Docker manages the directories, but the paths are deeper and harder to find.
• Directory mounts have higher coupling because we manage the directories ourselves, but the paths are easier to locate and inspect.