## Docker Hello World

Docker 允许你在容器内运行应用程序， 使用 **docker run** 命令来在容器内运行一个应用程序。

输出Hello world

```
runoob@runoob:~$ docker run ubuntu:15.10 /bin/echo "Hello world"
Hello world
```

![](https://www.runoob.com/wp-content/uploads/2016/05/docker19.png)

各个参数解析：

+   **docker:** Docker 的二进制执行文件。
    
+   **run:** 与前面的 docker 组合来运行一个容器。
    
+   **ubuntu:15.10** 指定要运行的镜像，Docker 首先从本地主机上查找镜像是否存在，如果不存在，Docker 就会从镜像仓库 Docker Hub 下载公共镜像。
    
+   **/bin/echo "Hello world":** 在启动的容器里执行的命令
    

以上命令完整的意思可以解释为：Docker 以 ubuntu15.10 镜像创建一个新容器，然后在容器里执行 bin/echo "Hello world"，然后输出结果。

* * *

## 运行交互式的容器

我们通过 docker 的两个参数 -i -t，让 docker 运行的容器实现**"对话"**的能力：

```
runoob@runoob:~$ docker run -i -t ubuntu:15.10 /bin/bash
root@0123ce188bd8:/#
```

各个参数解析：

+   **\-t:** 在新容器内指定一个伪终端或终端。
    
+   **\-i:** 允许你对容器内的标准输入 (STDIN) 进行交互。
    

注意第二行 root@0123ce188bd8:/#，此时我们已进入一个 ubuntu15.10 系统的容器

我们尝试在容器中运行命令 **cat /proc/version**和**ls**分别查看当前系统的版本信息和当前目录下的文件列表

```
root@0123ce188bd8:/#  cat /proc/version
Linux version 4.4.0-151-generic (buildd@lgw01-amd64-043) (gcc version 5.4.0 20160609 (Ubuntu 5.4.0-6ubuntu1~16.04.10) ) #178-Ubuntu SMP Tue Jun 11 08:30:22 UTC 2019
root@0123ce188bd8:/# ls
bin  boot  dev  etc  home  lib  lib64  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
root@0123ce188bd8:/# 
```

我们可以通过运行 exit 命令或者使用 CTRL+D 来退出容器。

```
root@0123ce188bd8:/#  exit
exit
root@runoob:~# 
```

注意第三行中 root@runoob:~# 表明我们已经退出了当前的容器，返回到当前的主机中。

* * *

## 启动容器（后台模式）

使用以下命令创建一个以进程方式运行的容器

```
runoob@runoob:~$ docker run -d ubuntu:15.10 /bin/sh -c "while true; do echo hello world; sleep 1; done"
2b1b7a428627c51ab8810d541d759f072b4fc75487eed05812646b8534a2fe63
```

在输出中，我们没有看到期望的 "hello world"，而是一串长字符

**2b1b7a428627c51ab8810d541d759f072b4fc75487eed05812646b8534a2fe63**

这个长字符串叫做容器 ID，对每个容器来说都是唯一的，我们可以通过容器 ID 来查看对应的容器发生了什么。

首先，我们需要确认容器有在运行，可以通过 **docker ps** 来查看：

```
runoob@runoob:~$ docker ps
CONTAINER ID        IMAGE                  COMMAND              ...  
5917eac21c36        ubuntu:15.10           "/bin/sh -c 'while t…"    ...
```

输出详情介绍：

**CONTAINER ID:** 容器 ID。

**IMAGE:** 使用的镜像。

**COMMAND:** 启动容器时运行的命令。

**CREATED:** 容器的创建时间。

**STATUS:** 容器状态。

状态有7种：

+   created（已创建）
+   restarting（重启中）
+   running 或 Up（运行中）
+   removing（迁移中）
+   paused（暂停）
+   exited（停止）
+   dead（死亡）

**PORTS:** 容器的端口信息和使用的连接类型（tcp\\udp）。

**NAMES:** 自动分配的容器名称。

在宿主主机内使用 docker logs 命令，查看容器内的标准输出：

```
runoob@runoob:~$ docker logs 2b1b7a428627
```

![](https://www.runoob.com/wp-content/uploads/2016/05/docker23.png)

```
runoob@runoob:~$ docker logs amazing_cori
```

![](https://www.runoob.com/wp-content/uploads/2016/05/docker24.png)

* * *

## 停止容器

我们使用 **docker stop** 命令来停止容器:

![](https://www.runoob.com/wp-content/uploads/2016/05/docker25.png)

通过 docker ps 查看，容器已经停止工作:

```
runoob@runoob:~$ docker ps
```

可以看到容器已经不在了。

也可以用下面的命令来停止:

```
runoob@runoob:~$ docker stop amazing_cori
```

Docker Hello World

## Docker 容器使用

Docker 容器是一个轻量级、可移植、自给自足的软件环境，用于运行应用程序。

Docker 容器将应用程序及其所有依赖项（包括库、配置文件、系统工具等）封装在一个标准化的包中，使得应用能够在任何地方一致地运行。

容器是操作系统级别的虚拟化，不需要运行完整的操作系统，启动和运行更为高效。

### 镜像与容器的关系

+   **镜像（Image）**：容器的静态模板，包含了应用程序运行所需的所有依赖和文件。镜像是不可变的。
+   **容器（Container）**：镜像的一个运行实例，具有自己的文件系统、进程、网络等，且是动态的。容器从镜像启动，并在运行时保持可变。

![](https://www.runoob.com/wp-content/uploads/2016/05/0_Uw0RmvCbgHBkZfi1.png)

* * *

## Docker 客户端

Docker 客户端是与 Docker 守护进程（Docker Daemon）交互的命令行工具。

docker 客户端非常简单，我们可以直接输入 docker 命令来查看到 Docker 客户端的所有命令选项。

```
runoob@runoob:~# docker
```

![](https://www.runoob.com/wp-content/uploads/2016/05/docker27.png)

可以通过命令 **docker command --help** 更深入的了解指定的 Docker 命令使用方法。

例如我们要查看 **docker stats** 指令的具体使用方法：

```
runoob@runoob:~# docker stats --help
```

![](https://www.runoob.com/wp-content/uploads/2016/05/docker28.png)

以下是常用的 Docker 客户端命令：

| **命令** | **功能** | **示例** |
| --- | --- | --- |
| `docker run` | 启动一个新的容器并运行命令 | `docker run -d ubuntu` |
| `docker ps` | 列出当前正在运行的容器 | `docker ps` |
| `docker ps -a` | 列出所有容器（包括已停止的容器） | `docker ps -a` |
| `docker build` | 使用 Dockerfile 构建镜像 | `docker build -t my-image .` |
| `docker images` | 列出本地存储的所有镜像 | `docker images` |
| `docker pull` | 从 Docker 仓库拉取镜像 | `docker pull ubuntu` |
| `docker push` | 将镜像推送到 Docker 仓库 | `docker push my-image` |
| `docker exec` | 在运行的容器中执行命令 | `docker exec -it container_name bash` |
| `docker stop` | 停止一个或多个容器 | `docker stop container_name` |
| `docker start` | 启动已停止的容器 | `docker start container_name` |
| `docker restart` | 重启一个容器 | `docker restart container_name` |
| `docker rm` | 删除一个或多个容器 | `docker rm container_name` |
| `docker rmi` | 删除一个或多个镜像 | `docker rmi my-image` |
| `docker logs` | 查看容器的日志 | `docker logs container_name` |
| `docker inspect` | 获取容器或镜像的详细信息 | `docker inspect container_name` |
| `docker exec -it` | 进入容器的交互式终端 | `docker exec -it container_name /bin/bash` |
| `docker network ls` | 列出所有 Docker 网络 | `docker network ls` |
| `docker volume ls` | 列出所有 Docker 卷 | `docker volume ls` |
| `docker-compose up` | 启动多容器应用（从 `docker-compose.yml` 文件） | `docker-compose up` |
| `docker-compose down` | 停止并删除由 `docker-compose` 启动的容器、网络等 | `docker-compose down` |
| `docker info` | 显示 Docker 系统的详细信息 | `docker info` |
| `docker version` | 显示 Docker 客户端和守护进程的版本信息 | `docker version` |
| `docker stats` | 显示容器的实时资源使用情况 | `docker stats` |
| `docker login` | 登录 Docker 仓库 | `docker login` |
| `docker logout` | 登出 Docker 仓库 | `docker logout` |

**常用选项说明:**

+   **`-d`**：后台运行容器，例如 `docker run -d ubuntu`。
+   **`-it`**：以交互式终端运行容器，例如 `docker exec -it container_name bash`。
+   **`-t`**：为镜像指定标签，例如 `docker build -t my-image .`。

* * *

## 容器使用

### 获取镜像

如果我们本地没有 ubuntu 镜像，我们可以使用 docker pull 命令来载入 ubuntu 镜像：

```
$ docker pull ubuntu
```

### 启动容器

以下命令使用 ubuntu 镜像启动一个容器，参数为以命令行模式进入该容器：

```
$ docker run -it ubuntu /bin/bash
```

![](https://www.runoob.com/wp-content/uploads/2016/05/docker-container-run.png)

参数说明：

+   **\-i**: 交互式操作。
+   **\-t**: 终端。
+   **ubuntu**: ubuntu 镜像。
+   **/bin/bash**：放在镜像名后的是命令，这里我们希望有个交互式 Shell，因此用的是 /bin/bash。

要退出终端，直接输入 **exit**:

```
root@ed09e4490c57:/# exit
```

![](https://www.runoob.com/wp-content/uploads/2016/05/docker-container-exit.png)

### 启动已停止运行的容器

查看所有的容器命令如下：

```
$ docker ps -a
```

点击图片查看大图：

[![](https://www.runoob.com/wp-content/uploads/2016/05/docker-container-psa.png)](https://www.runoob.com/wp-content/uploads/2016/05/docker-container-psa.png)

使用 docker start 启动一个已停止的容器：

```
$ docker start b750bbbcfd88 
```

![](https://www.runoob.com/wp-content/uploads/2016/05/docker-container-start.png)

### 后台运行

在大部分的场景下，我们希望 docker 的服务是在后台运行的，我们可以过 \-d 指定容器的运行模式。

```
$ docker run -itd --name ubuntu-test ubuntu /bin/bash
```

点击图片查看大图：

[![](https://www.runoob.com/wp-content/uploads/2016/05/docker-run-d.png)](https://www.runoob.com/wp-content/uploads/2016/05/docker-run-d.png)

[![](https://www.runoob.com/wp-content/uploads/2016/05/docker-run-d2.png)](https://www.runoob.com/wp-content/uploads/2016/05/docker-run-d2.png)

**注：**加了 \-d 参数默认不会进入容器，想要进入容器需要使用指令 **docker exec**（下面会介绍到）。

### 停止一个容器

停止容器的命令如下：

```
$ docker stop <容器 ID>
```

![](https://www.runoob.com/wp-content/uploads/2016/05/docker-stop-1.png)

停止的容器可以通过 docker restart 重启：

```
$ docker restart <容器 ID>
```

![](https://www.runoob.com/wp-content/uploads/2016/05/docker-stop-2.png)

### 进入容器

在使用 **\-d** 参数时启动容器时，容器会运行在后台，这时如果要进入容器，可以通过以下命令进入：

+   **docker attach**：允许你与容器的标准输入（stdin）、输出（stdout）和标准错误（stderr）进行交互。
    
+   **docker exec**：推荐大家使用 docker exec 命令，因为此命令会退出容器终端，但不会导致容器的停止。
    

**attach 命令**

使用 docker attach 命令实例：

```
$ docker attach 1e560fca3906 
```

[![](https://www.runoob.com/wp-content/uploads/2016/05/docker-attach.png)](https://www.runoob.com/wp-content/uploads/2016/05/docker-attach.png)

**注意：** 如果从这个容器退出，会导致容器的停止。

**exec 命令**

使用 docker exec 命令实例：

```
docker exec -it 243c32535da7 /bin/bash
```

[![](https://www.runoob.com/wp-content/uploads/2016/05/docker-exec.png)](https://www.runoob.com/wp-content/uploads/2016/05/docker-exec.png)

**注意：** 如果从这个容器退出，容器不会停止，这就是为什么推荐大家使用 **docker exec**。

更多参数说明请使用 docker exec --help 命令查看。

### 导出和导入容器

**导出容器**

如果要导出本地某个容器，可以使用 **docker export** 命令。

```
$ docker export 1e560fca3906 > ubuntu.tar
```

导出容器 1e560fca3906 快照到本地文件 ubuntu.tar。

[![](https://www.runoob.com/wp-content/uploads/2016/05/docker-export.png)](https://www.runoob.com/wp-content/uploads/2016/05/docker-export.png)

这样将导出容器快照到本地文件。

**导入容器快照**

可以使用 docker import 从容器快照文件中再导入为镜像，以下实例将快照文件 ubuntu.tar 导入到镜像 test/ubuntu:v1:

```
$ cat docker/ubuntu.tar | docker import - test/ubuntu:v1
```

[![](https://www.runoob.com/wp-content/uploads/2016/05/docker-import.png)](https://www.runoob.com/wp-content/uploads/2016/05/docker-import.png)

此外，也可以通过指定 URL 或者某个目录来导入，例如：

```
$ docker import http://example.com/exampleimage.tgz example/imagerepo
```

### 删除容器

删除容器使用 **docker rm** 命令：

```
$ docker rm -f 1e560fca3906
```

[![](https://www.runoob.com/wp-content/uploads/2016/05/docker-container-rmi.png)](https://www.runoob.com/wp-content/uploads/2016/05/docker-container-rmi.png)

下面的命令可以清理掉所有处于终止状态的容器。

```
$ docker container prune
```

* * *

## 运行一个 web 应用

前面我们运行的容器并没有一些什么特别的用处。

接下来让我们尝试使用 docker 构建一个 web 应用程序。

我们将在docker容器中运行一个 Python Flask 应用来运行一个web应用。

```
runoob@runoob:~# docker pull training/webapp  # 载入镜像
runoob@runoob:~# docker run -d -P training/webapp python app.py
```

![](https://www.runoob.com/wp-content/uploads/2016/05/docker29.png)

参数说明:

+   **\-d:**让容器在后台运行。
    
+   **\-P:**将容器内部使用的网络端口随机映射到我们使用的主机上。
    

* * *

## 查看 WEB 应用容器

使用 docker ps 来查看我们正在运行的容器：

```
runoob@runoob:~#  docker ps
CONTAINER ID        IMAGE               COMMAND             ...        PORTS                 
d3d5e39ed9d3        training/webapp     "python app.py"     ...        0.0.0.0:32769->5000/tcp
```

这里多了端口信息。

```
PORTS
0.0.0.0:32769->5000/tcp
```

Docker 开放了 5000 端口（默认 Python Flask 端口）映射到主机端口 32769 上。

这时我们可以通过浏览器访问WEB应用

![](https://www.runoob.com/wp-content/uploads/2016/05/docker31.png)

我们也可以通过 -p 参数来设置不一样的端口：

```
runoob@runoob:~$ docker run -d -p 5000:5000 training/webapp python app.py
```

**docker ps**查看正在运行的容器

```
runoob@runoob:~#  docker ps
CONTAINER ID        IMAGE                             PORTS                     NAMES
bf08b7f2cd89        training/webapp     ...        0.0.0.0:5000->5000/tcp    wizardly_chandrasekhar
d3d5e39ed9d3        training/webapp     ...        0.0.0.0:32769->5000/tcp   xenodochial_hoov
```

容器内部的 5000 端口映射到我们本地主机的 5000 端口上。

* * *

## 网络端口的快捷方式

通过 **docker ps** 命令可以查看到容器的端口映射，**docker** 还提供了另一个快捷方式 **docker port**，使用 **docker port** 可以查看指定 （ID 或者名字）容器的某个确定端口映射到宿主机的端口号。

上面我们创建的 web 应用容器 ID 为 **bf08b7f2cd89** 名字为 **wizardly\_chandrasekhar**。

我可以使用 docker port bf08b7f2cd89 或 docker port wizardly\_chandrasekhar 来查看容器端口的映射情况。

```
runoob@runoob:~$ docker port bf08b7f2cd89
5000/tcp -> 0.0.0.0:5000
```

```
runoob@runoob:~$ docker port wizardly_chandrasekhar
5000/tcp -> 0.0.0.0:5000
```

* * *

## 查看 WEB 应用程序日志

docker logs \[ID或者名字\] 可以查看容器内部的标准输出。

```
runoob@runoob:~$ docker logs -f bf08b7f2cd89
 * Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)
192.168.239.1 - - [09/May/2016 16:30:37] "GET / HTTP/1.1" 200 -
192.168.239.1 - - [09/May/2016 16:30:37] "GET /favicon.ico HTTP/1.1" 404 -
```

**\-f:** 让 **docker logs** 像使用 **tail -f** 一样来输出容器内部的标准输出。

从上面，我们可以看到应用程序使用的是 5000 端口并且能够查看到应用程序的访问日志。

* * *

## 查看WEB应用程序容器的进程

我们还可以使用 docker top 来查看容器内部运行的进程

```
runoob@runoob:~$ docker top wizardly_chandrasekhar
UID     PID         PPID          ...       TIME                CMD
root    23245       23228         ...       00:00:00            python app.py
```

* * *

## 检查 WEB 应用程序

使用 **docker inspect** 来查看 Docker 的底层信息。它会返回一个 JSON 文件记录着 Docker 容器的配置和状态信息。

```
runoob@runoob:~$ docker inspect wizardly_chandrasekhar
[
    {
        "Id": "bf08b7f2cd897b5964943134aa6d373e355c286db9b9885b1f60b6e8f82b2b85",
        "Created": "2018-09-17T01:41:26.174228707Z",
        "Path": "python",
        "Args": [
            "app.py"
        ],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 23245,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2018-09-17T01:41:26.494185806Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
......
```

* * *

## 停止 WEB 应用容器

```
runoob@runoob:~$ docker stop wizardly_chandrasekhar   
wizardly_chandrasekhar
```

* * *

## 重启WEB应用容器

已经停止的容器，我们可以使用命令 docker start 来启动。

```
runoob@runoob:~$ docker start wizardly_chandrasekhar
wizardly_chandrasekhar
```

docker ps -l 查询最后一次创建的容器：

```
#  docker ps -l 
CONTAINER ID        IMAGE                             PORTS                     NAMES
bf08b7f2cd89        training/webapp     ...        0.0.0.0:5000->5000/tcp    wizardly_chandrasekhar
```

正在运行的容器，我们可以使用 docker restart 命令来重启。

* * *

## 移除WEB应用容器

我们可以使用 docker rm 命令来删除不需要的容器

```
runoob@runoob:~$ docker rm wizardly_chandrasekhar  
wizardly_chandrasekhar
```

删除容器时，容器必须是停止状态，否则会报如下错误

```
runoob@runoob:~$ docker rm wizardly_chandrasekhar
Error response from daemon: You cannot remove a running container bf08b7f2cd897b5964943134aa6d373e355c286db9b9885b1f60b6e8f82b2b85. Stop the container before attempting removal or force remove
```

Docker 容器使用

## Docker 架构

Docker 架构是基于客户端-服务器模式的，其中包括多个关键组件，确保容器化应用的高效构建、管理和运行。

Docker 的架构设计使得开发者能够轻松地将应用程序与其所有依赖封装在一个可移植的容器中，并在不同的环境中一致地运行。

Docker 使用客户端-服务器 (C/S) 架构模式，使用远程 API 来管理和创建 Docker 容器。

Docker 容器通过 Docker 镜像来创建。

容器与镜像的关系类似于面向对象编程中的对象与类。

| Docker | 面向对象 |
| --- | --- |
| 容器 | 对象 |
| 镜像 | 类 |

### Docker 架构示意图

![](https://www.runoob.com/wp-content/uploads/2016/07/docker-architecture.webp)

### Docker 架构的工作流程

+   **构建镜像**：使用 `Dockerfile` 创建镜像。
+   **推送镜像到注册表**：将镜像上传到 Docker Hub 或私有注册表中。
+   **拉取镜像**：通过 `docker pull` 从注册表中拉取镜像。
+   **运行容器**：使用镜像创建并启动容器。
+   **管理容器**：使用 Docker 客户端命令管理正在运行的容器（例如查看日志、停止容器、查看资源使用情况等）。
+   **网络与存储**：容器之间通过 Docker 网络连接，数据通过 Docker 卷或绑定挂载进行持久化。

接下来让我们深入探讨 Docker 的核心组件及其工作机制。

### 1、**Docker 客户端（Docker Client）**

Docker 客户端是用户与 Docker 守护进程交互的命令行界面（CLI）。它是用户与 Docker 系统的主要交互方式，用户通过 Docker CLI 发出命令，这些命令被发送到 Docker 守护进程，由守护进程执行相应的操作。

+   **功能**：允许用户使用命令与 Docker 守护进程通信，如创建容器、构建镜像、查看容器状态等。
+   **交互方式**：Docker 客户端与 Docker 守护进程之间通过 REST API 或 Unix 套接字通信。常用的命令行工具是 `docker`，通过它，用户可以发出各种 Docker 操作命令。

#### 常用命令：

+   `docker run`：运行容器。
+   `docker ps`：列出正在运行的容器。
+   `docker build`：构建 Docker 镜像。
+   `docker exec`：在容器中执行命令。

### 2、**Docker 守护进程（Docker Daemon）**

Docker 守护进程（通常是 `dockerd`）是 Docker 架构的核心，负责管理容器生命周期、构建镜像、分发镜像等任务。

守护进程通常以后台进程的方式运行，等待来自 Docker 客户端的 API 请求。

**功能**：

+   启动和停止容器。
+   构建、拉取和推送镜像。
+   管理容器的网络和存储。
+   启动、停止、查看容器日志等。
+   与 Docker 注册表进行通信，管理镜像的存储与分发。

Docker 守护进程监听来自 Docker 客户端的请求，并且通过 Docker API 执行这些请求。守护进程将负责容器、镜像等 Docker 对象的管理，并根据请求的参数启动容器、删除容器、修改容器配置等。

启动 Docker 守护进程（通常是自动启动的）：

```
sudo systemctl start docker
```

### 3、**Docker 引擎 API（Docker Engine API）**

Docker 引擎 API 是 Docker 提供的 RESTful 接口，允许外部客户端与 Docker 守护进程进行通信。通过这个 API，用户可以执行各种操作，如启动容器、构建镜像、查看容器状态等。API 提供了 HTTP 请求的接口，支持跨平台调用。

**功能**：

+   向 Docker 守护进程发送 HTTP 请求，实现容器、镜像的管理。
+   提供 RESTful 接口，允许通过编程与 Docker 进行交互。

可以通过 `curl` 或其他 HTTP 客户端访问 Docker 引擎 API。例如，查询当前 Docker 守护进程的版本：

```
curl --unix-socket /var/run/docker.sock http://localhost/version
```

### 4、**Docker 容器（Docker Containers）**

容器是 Docker 的执行环境，它是轻量级、独立且可执行的软件包。容器是从 Docker 镜像启动的，包含了运行某个应用程序所需的一切——从操作系统库到应用程序代码。容器在运行时与其他容器和宿主机共享操作系统内核，但容器之间的文件系统和进程是隔离的。

**功能**：

+   提供独立的运行环境，确保应用程序在不同的环境中具有一致的行为。
+   容器是临时的，通常在任务完成后被销毁。

容器的生命周期是由 Docker 守护进程管理的。容器可以在任何地方运行，因为它们不依赖于底层操作系统的配置，所有的运行时依赖已经封装在镜像中。

启动一个容器：

```
docker run -d ubuntu
```

### 5、**Docker 镜像（Docker Images）**

Docker 镜像是容器的只读模板。每个镜像都包含了应用程序运行所需的操作系统、运行时、库、环境变量和应用代码等。镜像是静态的，用户可以根据镜像启动容器。

**功能**：

+   镜像是构建容器的基础，每个容器实例化时都会使用镜像。
+   镜像是只读的，不同容器使用同一个镜像时，容器中的文件系统层是独立的。

Docker 镜像可以通过 `docker pull` 从 Docker Hub 或私有注册表拉取，也可以通过 `docker build` 从 Dockerfile 构建。

拉取 Ubuntu 镜像：

```
docker pull ubuntu
```

### 6\. **Docker 仓库（Docker Registries）**

Docker 仓库是用来存储 Docker 镜像的地方，最常用的公共仓库是 **Docker Hub**。用户可以从 Docker Hub 下载镜像，也可以上传自己的镜像分享给其他人。除了公共仓库，用户也可以部署自己的私有 Docker 仓库来管理企业内部的镜像。

**功能**：

+   存储 Docker 镜像。
+   提供镜像的上传和下载功能。

Docker Hub 提供了大量官方和社区维护的镜像，如 Ubuntu、Nginx、MySQL 等。

推送镜像到 Docker Hub：

```
docker push <username>/<image_name>
```

### 7、**Docker Compose**

Docker Compose 是一个用于定义和运行多容器 Docker 应用的工具。通过 Compose，用户可以使用一个 `docker-compose.yml` 配置文件定义多个容器（服务），并可以通过一个命令启动这些容器。Docker Compose 主要用于开发、测试和部署多容器的应用。

**功能**：

+   定义和运行多个容器组成的应用。
+   通过 YAML 文件来配置应用的服务、网络和卷等。

创建一个简单的 `docker-compose.yml` 文件来配置一个包含 Web 服务和数据库服务的应用：

```
version: '3'
services:
  web:
    image: nginx
    ports:
      - "8080:80"
  db:
    image: mysql
    environment:
      MYSQL_ROOT_PASSWORD: example
```

启动 Compose 定义的所有服务：

```
docker-compose up
```

### 8、**Docker Swarm**

Docker Swarm 是 Docker 提供的集群管理和调度工具。它允许将多个 Docker 主机（节点）组织成一个集群，并通过 Swarm 集群管理工具来调度和管理容器。Swarm 可以实现容器的负载均衡、高可用性和自动扩展等功能。

**功能**：

+   管理多节点 Docker 集群。
+   通过调度器管理容器的部署和扩展。

初始化 Swarm 集群：

```
docker swarm init
```

### 9、**Docker 网络（Docker Networks）**

Docker 网络允许容器之间相互通信，并与外部世界进行连接。Docker 提供了多种网络模式来满足不同的需求，如 `bridge` 网络（默认）、`host` 网络和 `overlay` 网络等。

**功能**：

+   管理容器间的网络通信。
+   支持不同的网络模式，以适应不同场景下的需求。

创建一个自定义网络并将容器连接到该网络：

```
docker network create my_network
docker run -d --network my_network ubuntu
```

### 10\. **Docker 卷（Docker Volumes）**

Docker 卷是一种数据持久化机制，允许数据在容器之间共享，并且独立于容器的生命周期。与容器文件系统不同，卷的内容不会随着容器的销毁而丢失，适用于数据库等需要持久存储的应用。

**功能**：

+   允许容器间共享数据。
+   保证数据持久化，独立于容器的生命周期。

创建并挂载卷：

```
docker volume create my_volume
docker run -d -v my_volume:/data ubuntu
```

Docker 架构

## Docker 教程




![](https://www.runoob.com/wp-content/uploads/2016/04/docker01.png)

Docker 是一个开源的应用容器引擎，基于 [Go 语言]并遵从 Apache2.0 协议开源。

Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。

容器是完全使用沙箱机制，相互之间不会有任何接口（类似 iPhone 的 app）,更重要的是容器性能开销极低。

Docker 从 17.03 版本之后分为 CE（Community Edition: 社区版） 和 EE（Enterprise Edition: 企业版），我们用社区版就可以了。

* * *

## 谁适合阅读本教程？

本教程适合运维工程师及后端开发人员，通过本教程你可以一步一步了解 Docker 的使用。

* * *

## 阅读本教程前，您需要了解的知识

在阅读本教程前，你需要掌握 Linux 的常用命令。你可以通过本站的 [Linux 教程]来学习相关命令。

* * *

## Docker的应用场景

+   Web 应用的自动化打包和发布。
    
+   自动化测试和持续集成、发布。
    
+   在服务型环境中部署和调整数据库或其他的后台应用。
    
+   从头编译或者扩展现有的 OpenShift 或 Cloud Foundry 平台来搭建自己的 PaaS 环境。
    

* * *

## Docker 的优点

Docker 是一个用于开发，交付和运行应用程序的开放平台。Docker 使您能够将应用程序与基础架构分开，从而可以快速交付软件。借助 Docker，您可以与管理应用程序相同的方式来管理基础架构。通过利用 Docker 的方法来快速交付，测试和部署代码，您可以大大减少编写代码和在生产环境中运行代码之间的延迟。

### 1、快速，一致地交付您的应用程序

Docker 允许开发人员使用您提供的应用程序或服务的本地容器在标准化环境中工作，从而简化了开发的生命周期。

容器非常适合持续集成和持续交付（CI / CD）工作流程，请考虑以下示例方案：

+   您的开发人员在本地编写代码，并使用 Docker 容器与同事共享他们的工作。
+   他们使用 Docker 将其应用程序推送到测试环境中，并执行自动或手动测试。
+   当开发人员发现错误时，他们可以在开发环境中对其进行修复，然后将其重新部署到测试环境中，以进行测试和验证。
+   测试完成后，将修补程序推送给生产环境，就像将更新的镜像推送到生产环境一样简单。

### 2、响应式部署和扩展

Docker 是基于容器的平台，允许高度可移植的工作负载。Docker 容器可以在开发人员的本机上，数据中心的物理或虚拟机上，云服务上或混合环境中运行。

Docker 的可移植性和轻量级的特性，还可以使您轻松地完成动态管理的工作负担，并根据业务需求指示，实时扩展或拆除应用程序和服务。

### 3、在同一硬件上运行更多工作负载

Docker 轻巧快速。它为基于虚拟机管理程序的虚拟机提供了可行、经济、高效的替代方案，因此您可以利用更多的计算能力来实现业务目标。Docker 非常适合于高密度环境以及中小型部署，而您可以用更少的资源做更多的事情。

* * *

## 相关链接

Docker 官网：[https://www.docker.com](https://www.docker.com/)

Github Docker 源码：[https://github.com/docker/docker-ce](https://github.com/docker/docker-ce)

Docker Hello World

Docker 容器使用

Docker 架构

Docker 教程

系统信息