Application Deployment Environment Issues#

Large projects have many components and complex runtime environments, which can cause problems during deployment:

• Complex dependencies can easily lead to compatibility issues.
• Development, testing, and production environments may differ.

For example, a project may depend on Node.js, Redis, RabbitMQ, MySQL, and other services. These services require different libraries and dependencies during deployment, and they may even conflict with one another. This makes deployment extremely difficult.

How Docker Resolves Dependency Compatibility Issues#

Docker solves these problems in an ingenious way. How does Docker accomplish this?

Docker uses two approaches to resolve dependency compatibility issues:

• Package the application’s libraries (Libs), dependencies (Deps), configuration, and the application itself together.
• Run each application in an isolated container to prevent interference between applications.

The resulting application package contains both the application itself and its required libraries and dependencies. There is no need to install them separately on the operating system, naturally eliminating compatibility issues between different applications.

How Docker Resolves Differences Between Operating System Environments#

To understand how differences between operating system environments can be resolved, you must first understand the structure of an operating system. Taking Ubuntu as an example, its structure includes:

• Computer hardware: such as the CPU, memory, and disks.
• System kernel: All Linux distributions, such as CentOS, Ubuntu, and Fedora, use the Linux kernel. The kernel interacts with computer hardware and provides kernel instructions for operating that hardware.
• System applications: Applications and libraries provided by the operating system itself. These libraries encapsulate kernel instructions, making them easier to use.

The interaction between an application and a computer works as follows:

1. The application calls operating system applications (libraries) to perform various functions.

2. The system libraries encapsulate the kernel instruction set and call kernel instructions.

3. The kernel instructions operate the computer hardware.

How does Docker resolve differences between operating system environments?

• Docker packages the user program together with the required system libraries, such as Ubuntu libraries.
• When Docker runs on different operating systems, it uses the packaged libraries and the operating system’s Linux kernel.

Docker is a technology for rapidly delivering and running applications. It offers the following advantages:

• Programs, dependencies, and runtime environments can be packaged together as an image that can be migrated to any Linux operating system.
• At runtime, a sandboxing mechanism creates isolated containers so that applications do not interfere with one another.
• Containers can be started or removed with a single command, making operations fast and convenient.

Images and Containers#

Docker has several important concepts:

• Image: Docker packages an application together with its required dependencies, libraries, environment, configuration files, and other resources. This package is called an image.
• Container: The process created when the application in an image runs is called a container. Docker isolates container processes so that they are not visible externally.

All applications ultimately consist of code stored as files made up of bytes on a disk. Only when an application runs is it loaded into memory and turned into a process.

An image is a read-only package containing an application’s files, runtime environment, and some system library files.

A container loads the programs and functions in these files into memory and runs them as an isolated process. Therefore, a single image can be started multiple times to create multiple container processes.

Docker Hub#

There are many open-source applications, and packaging them individually often results in duplicated work. To avoid this, people publish packaged application images, such as Redis and MySQL images, online for others to use, similar to sharing code on GitHub.

• Docker Hub: Docker Hub is the official platform for hosting Docker images. This type of platform is called a Docker Registry.
• Similar public services are also available in China, such as NetEase Cloud Image Service and Alibaba Cloud Container Registry.

We can publish our own images to Docker Hub and pull images from Docker Hub.

Docker Architecture#

To use Docker to manage images and containers, Docker must first be installed.

Docker uses a C/S architecture consisting of two parts:

• Server: The Docker daemon, which processes Docker instructions and manages images, containers, and other resources.
• Client: Sends instructions to the Docker server through commands or a REST API. Instructions can be sent to a local or remote server.

Image Names#

First, let’s look at the structure of an image name:

• An image name generally consists of two parts: [repository]:[tag].
• If no tag is specified, the default is latest, which represents the latest version of the image.

Image Commands#

Common image operation commands 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: Creates and runs a container in the running state.

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

  • docker run: Creates and runs a container.
  • -name: Assigns a name to the container, such as mn.
  • p: Maps a host port to a container port. The host port is on the left side of the colon, and the container port is on the right.
  • d: Runs the container in the background.
  • nginx: The image name, such as nginx.

• docker pause: Pauses a running container.

• docker unpause: Resumes a paused container.

• docker stop: Stops a running container.

• docker start: Restarts a stopped container.

• docker rm: Deletes a container.

• docker exec: Enters a container.

  1
  docker exec -it mn bash

  • docker exec: Enters the container and executes a command.
  • it: Creates a standard input and output terminal for the container, allowing us to interact with it.
  • mn: The name of the container to enter.
  • bash: The command executed after entering the container. Bash is an interactive Linux terminal command.

  The container simulates an independent Linux file system internally, making it appear like a Linux server.

Common parameters for the docker run command:

• -name: Specifies the container name.
• p: Specifies port mappings.
• d: Runs the container in the background.

Commands for viewing container logs:

• docker logs
• Add the -f parameter to continuously view logs.

Viewing container status:

• docker ps
• docker ps -a displays all containers, including stopped containers.

What Is a Data Volume?#

• *A data volume (volume)** is a virtual directory that points to a directory in the host file system.

Once a data volume is mounted, all operations performed in the container affect the corresponding host directory.

Therefore, operating on the host’s /var/lib/docker/volumes/html directory is equivalent to operating on the container’s /usr/share/nginx/html directory.

Data Volume Commands#

The basic syntax for data volume operations is as follows:

1
docker volume [COMMAND]

The docker volume command manages data volumes. The command that follows it determines the operation to perform:

• create creates a volume.
• inspect displays information about one or more volumes.
• ls lists all volumes.
• prune deletes unused volumes.
• rm deletes one or more specified volumes.

Creating and Viewing Data Volumes#

Requirement: Create a data volume and view its directory location on the host.

1. Create the data volume.

1
docker volume create html

1. View all data volumes.

1
docker volume ls

1. View detailed information about the data volume.

1
docker volume inspect html

The created html data volume is associated with the host directory /var/lib/docker/volumes/html/_data.

Mounting a Data Volume#

When creating a container, you can use the -v parameter to mount a data volume to a directory inside the container. The command format is as follows:

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

Here, -v is the command for mounting the data volume:

• v html:/root/htm: Mounts the html data volume to the /root/html directory inside the container.

A container can mount not only a data volume but also a host directory directly. The relationships are as follows:

• Data volume mode: host directory —> data volume ---> container directory
• Direct mount mode: host directory ---> container directory

Installing 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 mounts files or directories into the container:

• v volume name directory
• v host file file
• v host directory directory

Differences between mounting data volumes and directly mounting directories:

• Data volume mounting has low coupling and lets Docker manage the directory, but the directory is deeply nested and difficult to locate.
• Direct directory mounting has high coupling and requires us to manage the directory ourselves, but the directory is easy to locate and inspect.