# 基本概念
## 是什么
> 容器编排：就是针对容器生命周期的管理，对容器的生命周期进行更快速方便的方式进行管理

## 为什么需要？
> - 依赖管理，当一个容器必须在另一个容器运行完成后，才能运行时，就需要进行依赖管理  
> - 副本数控制，容器有时候也需要集群，快的对容器集群进行弹性伸缩  
> - 配置共享，通过配置文件统一描述需要运行的服务相关信息，自动化的解析配置内容，并构建对应的服务 



# Docker Compse (单机环境的容器编排)
- **[Docker Compse 官方文档](https://docs.docker.com/reference/cli/docker/compose/)**

> 有的时候我们会需要涉及到在一台机器部署多个容器，那么此时再手动的每次输入相关的一堆配置命令再来启动容器，还是产生了很多无意义的重复性劳动。针对单机的多容器部署的情况，Docker 为我们提供了一个单机版本的服务编排工具 docker-compose

> Docker-Compose 可以高效便捷的管理单机上运行的所有容器，它通过 yaml 配置文件的方式完成之前执行 docker run 命令所设置的所有参数，你可以先针对单机上的所有容器进行相关配置，配置完成后即可使用 docker-compose 对单机多容器进行高效的管理

![image.png](/static/img/639efcee56ff3489a33fddacf26aeafd.image.webp)

## 配置文件
### 版本简述
docker-compose 的 api 版本与大版本一致，compose 版本与 docker 版本之间存在一定关联

| Compose 版本 | Docker 版本  |
|--------------|--------------|
| 3.4          | 17.09.0+     |
| 3.3          | 17.06.0+     |
| 3.2          | 17.04.0+     |
| 3.1          | 1.13.1+      |
| 3.0          | 1.13.0+      |
| 2.3          | 17.06.0+     |
| 2.2          | 1.13.0+      |

这个表格将 Compose 版本和相应的 Docker 版本进行了对比。

### 服务 services
> 需要运行的容器配置，可以理解为原先用 docker run 命令后面跟的一系列配置信息，都陪在这个下面

### 网络 networks
> docker-compose 公共自定义网络管理，配置好以后，可以直接在 services 中引用该网络配置，这个配置可以多个 service 使用

### 数据卷 volumes
> docker-compose 下的统一数据卷管理，可以给多个 service 使用

## 常用命令
```bash
Define and run multi-container applications with Docker.

Usage:
  docker-compose [-f <arg>...] [options] [COMMAND] [ARGS...]
  docker-compose -h|--help

Options:
  -f, --file FILE             Specify an alternate compose file (default: docker-compose.yml)
  -p, --project-name NAME     Specify an alternate project name (default: directory name)
  --verbose                   Show more output
  -v, --version               Print version and exit
  -H, --host HOST             Daemon socket to connect to

  --tls                       Use TLS; implied by --tlsverify
  --tlscacert CA_PATH         Trust certs signed only by this CA
  --tlscert CLIENT_CERT_PATH  Path to TLS certificate file
  --tlskey TLS_KEY_PATH       Path to TLS key file
  --tlsverify                 Use TLS and verify the remote
  --skip-hostname-check       Don't check the daemon's hostname against the name specified
                              in the client certificate (for example if your docker host
                              is an IP address)
```
- Commands:
    - build              构建或重新构建一个服务
    - bundle             Generate a Docker bundle from the Compose file
    - config             验证并查看 compose 文件
    - create             创建一个服务
    - down               停止并删除容器、网络、镜像和数据卷
    - events             Receive real time events from containers
    - exec               在一个运行中的容器执行命令
    - help               获取帮助信息
    - kill               关闭一个容器
    - logs               显示服务的日志信息
    - pause              暂停一个服务
    - port               打印一个端口绑定的公开端口
    - ps                 查看容器列表
    - pull               拉取镜像
    - push               推送镜像
    - restart            重启容器
    - rm                 删除已经停止的容器
    - run                运行一个一次性执行的命令
    - scale              设置服务的容器数量
    - start              启动服务
    - stop               停止服务
    - unpause            恢复一个暂停的服务
    - up                 创建并启动一个容器
    - version            显示 compose 的版本信息

### 构建服务
> 可以选择基于已有的镜像或者 Dockerfile 进行重新构建，利用 docker-compose build 可进行构建操作，也可以指定 docker-compose build \<service name> 来构建指定服务
    
### 创建服务
> 配置好 yml 文件后，通过 docker-compose create 创建配置文件中的所有服务，通过指定服务名来创建具体服务

### 拉取镜像
> docker-compose pull 服务名，可以拉取指定服务的镜像

### 容器的运行/启动/停止
- docker-compose run 服务名：运行服务
- docker-compose start 服务名：启动服务
- docker-compose stop 服务名：停止服务
- docker-compose restart 服务名：重启服务

### 查看管理的容器列表
> docker-compose ps 查看服务列表

### 查看日志
> docker-compose logs 服务名：查看指定服务的日志信息

## 示例
```yaml
# 版本号
version: "2.1"

services:
  # 定义名为 nginx 的服务
  nginx:
    # 指定使用的镜像为官方的 nginx 镜像
    image: "nginx"
    # 指定容器的名称为 nginx_compose
    container_name: "nginx_compose"
    # 设置容器的重启策略为 always，表示无论容器退出的原因是什么，都会自动重启
    restart: "always"
    # 将服务连接到名为 gycnet01 的自定义网络
    networks:
      - gycnet01
    # 挂载卷，映射到容器内部的 /usr/share/nginx/html 目录
    volumes:
      - nginx_volume:/usr/share/nginx/html
    # 设置环境变量，用于容器内应用程序的配置
    environment:
      APP_ENV: dev
    # 配置 DNS 服务器，指定容器使用 8.8.8.8 作为 DNS 解析器
    dns:
      - 8.8.8.8
    # ports: 将主机的 80 端口映射到容器的 80 端口
    ports:
      - 80:80

# 配置网络
networks:
  # 定义一个名为 gycnet01 的自定义网络
  gycnet01:
    # 使用默认的 bridge 驱动创建网络
    driver: bridge
    # 配置 IP 地址管理（IPAM）设置
    ipam:
      driver: default
      config:
        # 指定子网范围为 188.18.0.0/16
        - subnet: 188.18.0.0/16
          # 设置网络的默认网关为 188.18.0.1
          gateway: 188.18.0.1

# 配置卷
volumes:
  # 定义一个名为 nginx_volume 的卷
  nginx_volume:
    # 留空，使用默认的本地驱动
```

- **使用`docker compose scale <容器名称>=数量`将会创建指定数量的容器**
- 需要修改yaml文件
```yaml
services:
  nginx:
    image: "nginx"
    restart: "always"
    networks:
      - gycnet01
    volumes:
      - nginx_volume:/usr/share/nginx/html
    environment:
      APP_ENV: dev
    dns:
      - 8.8.8.8
    ports:
      - "80"

networks:
  gycnet01:
    driver: bridge
    ipam:
      driver: default
      config:
        - subnet: 188.18.0.0/16
          gateway: 188.18.0.1

volumes:
  nginx_volume:
```
- ports: - 80：这里的端口映射将把宿主机的 80 端口映射到容器的 80 端口。需要注意的是，当您扩展多个容器时，只有第一个容器实例可以绑定到宿主机的 80 端口。后续容器将无法绑定到同一个宿主机端口，因为端口冲突会导致错误。

# docker swarm(swarm)
- **[官方文档](https://github.com/docker/swarm)**

- 架构图

![swarm架构.png](/static/img/1a990e98d141f34d0a60f24a90cc79be.swarm%C3%A6%C2%9E%C2%B6%C3%A6%C2%9E%C2%84.webp)

> Swarm 是 Docker 公司推出的用来管理 docker 集群的平台，几乎全部用GO语言来完成的开发的， 它是将一群 Docker 宿主机变成一个单一的虚拟主机，Swarm 使用标准的 Docker API 接口作为其前端的访问入口，换言之，各种形式的DockerClient(compose, docker-py 等) 均可以直接与 Swarm 通信，甚至 Docker 本身都可以很容易的与 Swarm 集成，这大大方便了用户将原本基于单节点的系统移植到 Swarm 上，同时Swarm 内置了对 Docker 网络插件的支持，用户也很容易的部署跨主机的容器集群服务。

> Docker Swarm 和 Docker Compose 一样，都是 Docker 官方容器编排项目，但不同的是，Docker Compose 是一个在单个服务器或主机上创建多个容器的工具，而 Docker Swarm 则可以在多个服务器或主机上创建容器集群服务，对于微服务的部署，显然 Docker Swarm 会更加适合。

> 从 Docker 1.12.0 版本开始，Docker Swarm 已经包含在 Docker 引擎中（docker swarm），并且已经内置了服务发现工具，我们就不需要像之前一样，再配置 Etcd 或者 Consul 来进行服务发现配置了。

> Swarm deamon只是一个调度器(Scheduler)加路由器(router),Swarm自己不运行容器，它只是接受Docker客户端发来的请求，调度适合的节点来运行容器，这就意味着，即使Swarm由于某些原因挂掉了，集群中的节点也会照常运行，放Swarm重新恢复运行之后，他会收集重建集群信息。

## 关键概念
### Swarm
> 集群的管理和编排是使用嵌入 docker 引擎的 SwarmKit，可以在docker 初始化时启动 swarm 模式或者加入已存在的 swarm

- swarm 集群节点的管理命令：docker swarm --help
    - 初始化集群节点
    - 加入节点
    - 退出节点

### Node
> 运行 Docker 的主机可以主动初始化一个 Swarm 集群或者加入一个已存在的 Swarm 集群，这样这个运行 Docker 的主机就成为一个 Swarm 集群的节点 (node) 。

> 节点分为管理 (manager) 节点和工作 (worker) 节点。

> 管理节点用于 Swarm 集群的管理，docker swarm 命令基本只能在管理节点执行（节点退出集群命令 docker swarm leave 可以在工作节点执行）。一个 Swarm 集群可以有多个管理节点，但只有一个管理节点可以成为 leader，leader 通过 raft 协议实现。通常，第一个启用docker swarm的节点将成为leader，后来加入的都是follower。当前的leader如果挂掉，剩余的节点将重新选举出一个新的leader。每一个manager都有一个完整的当前集群状态的副本，可以保证manager的高可用。

> 工作节点是任务执行节点，管理节点将服务 (service) 下发至工作节点执行。管理节点默认也作为工作节点。你也可以通过配置让服务只运行在管理节点。worker节点之间，通过control plane进行通信，这种通信使用gossip协议，并且是异步的。

> 来自 Docker 官网的这张图片形象的展示了集群中管理节点与工作节点的关系。

![swarm-diagram.png](/static/img/b877ea8d8c74c696577d608f53e61c08.swarm-diagram.webp)
    
### Task
> 任务 （Task）是 Swarm 中的最小的调度单位，目前来说就是一个单一的容器。

### Service
> 服务 （Services） 是指一组任务的集合，服务定义了任务的属性。服务有两种模式：

- replicated services 按照一定规则在各个工作节点上运行指定个数的任务。

- global services 每个工作节点上运行一个任务

- 两种模式通过 docker service create 的 --mode 参数指定。

服务与任务的关系：

![services-diagram.png](/static/img/f60a0cd1646b3de342ecda5ed985248c.services-diagram.webp)

服务的生命周期:

![service-lifecycle.png](/static/img/2f81fd79a0fc51498911a606b9fcce0a.service-lifecycle.webp)

## 应用实战
### 集群搭建
#### 初始化集群
登录管理节点，并执行如下命令
`docker swarm init --advertise-addr IP(192.168.113.120)`

- 使用 docker info 可以查看 swarm 集群状态

- docker node ls 可以查看集群节点信息

![image.png](/static/img/be552f5e11303ba470542fa4a1978e95.image.webp)

#### 增加工作节点
分别在两个工作节点上执行加入节点命令

`docker swarm join \
-- token 集群初始化时的 token 信息 \
192.168.113.120:2377`

![image.png](/static/img/49e9dac8aaa96802c2d87586939bd9aa.image.webp)

#### 查看集群
- 进入主节点，输入如下命令查看集群节点信息
`docker node ls`

![image.png](/static/img/d82b3b459ced66fc933c3c72043dde65.image.webp)


### 部署服务
#### 新建服务
进入主节点，创建一个 helloworld 服务
`docker service create --replicas 1 -p 80:80 --name nginx_swarm nginx`

![image.png](/static/img/39835a90075e8f85bd6baa0617b68132.image.webp)

- 命令解释：
    - `docker service create` 创建一个服务
    - `--name` 设置服务名称
    - `--replicas` 设置启动多少个实例

- 命令详解: 
    - **`docker service create`**：这是 Docker Swarm 模式下创建服务的命令。服务是 Docker Swarm 中的一个重要概念，它允许你在多个节点上运行和管理容器。

    - **`--replicas 2`**：指定服务的副本数为 2。也就是说，这个服务会在集群中运行两个相同的 `nginx` 容器实例。

    - **`-p 80:80`**：这是端口映射的选项。第一个 `80` 是主机上的端口，第二个 `80` 是容器内的端口。这个映射意味着访问集群节点的端口 `80` 时，流量会被转发到容器内的 `80` 端口，也就是 `nginx` 默认的 HTTP 服务端口。

    - **`--name nginx_swarm`**：指定服务的名称为 `nginx_swarm`。你可以使用这个名字来管理或查询这个服务。

    - **`nginx`**：这是服务所运行的镜像名称。在这个例子中，`nginx` 是一个来自 Docker 官方镜像库的镜像，它会在容器中运行一个 Nginx Web 服务器。



- 通过 `docker service ps <service id>` 可以查看服务信息

![image.png](/static/img/5ef34ded0feb2895e4a0ea50b092fb05.image.webp)

- 通过 `docker service ls` 可以查看 Swarm 集群下运行的所有服务

![image.png](/static/img/6a8d914701ef0caa7644fcfbfa90c345.image.webp)

#### 监控集群状态
- 查看服务信息：
`docker service inspect --pretty <service id>`
`--pretty` 参数可以简化输出内容

- `docker service ps <service id>` 可以查看运行中的服务信息

![image.png](/static/img/e6a58d191940da38187dc6fc436a446c.image.webp)

- 进入工作节点通过 `docker ps` 可以查看容器运行状态

![image.png](/static/img/8a287a2b5dae042a9ca612c1c2e4a4c8.image.webp)

### 弹性伸缩
#### 调整实例个数
- 更新服务的实例个数：
`docker service update --replicas <num> <service id/name>`

```bash
docker service update --replicas 1 nginx_swarm
```
- 命令详解: 
    - **`docker service update`**：用来更新 Docker Swarm 中已存在的服务

    - **`--replicas 1`**：设置服务的副本数为 1。这意味着该服务将运行一个容器实例

    - **`nginx_swarm`**：要更新的服务的名称。在这个例子中，服务的名称是 `nginx_swarm`

![image.png](/static/img/a223b2be313910b711594f94a374d5e1.image.webp)

#### 调整集群大小
- 添加新的 Docker 节点，执行 `docker swarm join` 命令可以加入集群

- 执行 `docker swarm leave` 可以退出集群，也可以带上 `--force` 参数强制退出集群

Docker容器编排

# 1.springboot项目
```dockerfile
# 基础镜像
FROM openjdk:8

# 将项目jar包拷贝到容器中
COPY ./springboot-docker-demo-1.0.0.jar app.jar

# 配置项目环境变量
ENV APP_OPTS=""
# JVM 环境变量
ENV JVM_OPTS="-Duser.timezone=Asia/Shanghai -Xms128m -Xmx128m"

# 暴露端口
EXPOSE 8080

# 设置启动时命令
CMD ["sh", "-c", "java $JVM_OPTS -jar /app.jar $APP_OPTS"]
```

- 使用`docker build -t springboot-docker:1.0.0 .`命令构建镜像
- 运行容器`docker run -d --rm -P springboot-docker:1.0.0 `



# 2. javaweb项目
```dockerfile
# 使用官方的 Tomcat 9.0 镜像作为基础镜像
FROM tomcat:9.0

# 设置工作目录为 Tomcat 的 webapps 目录
# 这是 Tomcat 默认的应用部署目录
WORKDIR /usr/local/tomcat/webapps

# 将本地的 WAR 包（javaweb-docker-demo-1.0-SNAPSHOT.war）复制到 Tomcat 的 webapps 目录中
# 并将其重命名为 ROOT.war，这样 Tomcat 会将它作为根上下文部署
COPY javaweb-docker-demo-1.0-SNAPSHOT.war ROOT.war

# 使用 Tomcat 镜像的默认启动命令，不需要额外设置
# 这条命令实际上是 Tomcat 镜像默认的启动命令
CMD ["sh", "-c", "../bin/catalina.sh run"]
```

Dockerfile部署Java项目

# 基本概念
## 是什么？
> Docker 为我们提供的一个用于自定义构建镜像的一个配置文件：描述如何构建一个对象  

> 利用 Docker 提供的 build 命令，指定 Dockerfile 文件，就可以按照配置的内容将镜像构建出来

## 为什么需要？
> 作为开发者需要将自己开发好的项目打包成 Docker 镜像，便于后面直接作为 Docker 容器运行

> 作为运维人员需要构建更精简的基础设施服务镜像，满足公司的需求以及尽可能减少冗余的功能占用过多的资源

## 能干什么？
- 可以自定义镜像内容
- 构建公共基础镜像减少其他镜像配置
- 开源程序的快速部署
- 实现企业内部项目的快速交付

![450977-20190512115951746-136143052.png](/static/img/e257dbf2499de96d9b73c36f143338c6.450977-20190512115951746-136143052.webp)



# 构建镜像
## commit
> 基于一个现有的容器，构建一个新的镜像

- 命令：
```bash
docker commit [OPTIONS] CONTAINER [REPOSITORY[:TAG]]
```

- 例：
```bash
docker commit -a="gyc" -m="first image" centos7 mycentos:7
```

- OPTIONS：
    - -a：镜像的作者
    - -c：使用 Dockerfile 指令来构建镜像
    - -m：提交时的描述
    - -p：在 commit 时暂停容器

## build
> `docker build` 命令用于从 Dockerfile 构建 Docker 镜像。

- 基本格式：
```bash
docker build [OPTIONS] PATH
```

- 常用参数说明：

    - `-t` 或 `--tag`：指定镜像的标签（名字），例如 `my-image:latest`。
    - `-f` 或 `--file`：指定 Dockerfile 的路径（默认为当前目录下的 `Dockerfile`）。
    - `--no-cache`：在构建过程中不使用缓存。
    - `--build-arg`：设置构建时的变量。

- 示例：

```bash
docker build -t my-image:latest .
```

- 这个命令将在当前目录（`.`）下查找 Dockerfile 并构建镜像，镜像名称为 `my-image`，标签为 `latest`。

- 如果你有一个自定义路径的 Dockerfile，可以这样使用：

```bash
docker build -t my-image:latest -f /path/to/Dockerfile .
```
- 这样 Dockerfile 会从指定路径读取，而构建上下文仍是当前目录。

# Dockerfile指令
## 常用指令
### FROM
> 指定以什么镜像作为基础镜像，在改进项的基础之上构建新的镜像。

>如果不想以任何镜像作为基础：FROM scratch

- 语法：
    - FROM \<image>
    - FROM \<image>:\<tag>
    - FROM \<image>:\<digest>

- 以上为三种写法，后两者为指定具体版本，第一种则使用 latest 也就是最新版

### MAINTAINER
> 指定该镜像的作者

- 语法：
    - MAINTAINER \<name>

### LABEL
> 为镜像设置标签，一个 Dockerfile 中可以配置多个 LABEL

- 语法：
    - LABEL \<key>=\<value>

- 如：
    - LABEL "example.label"="Example Label"
    - LABEL label-value="LABEL"
    - LABEL version="1.0.0"
    - LABEL description="可以写成多行，使用 \
    - 符号可以拼接多行的 value"

- PS：LABEL 指令会继承基础镜像（FROM）中的 LABEL，如果当前镜像 LABEL 的 key 与其相同，则会将其覆盖

### ENV
- 设置容器的环境变量，可以设置多个

- 语法：
    - ENV \<key> \<value>
    - ENV \<key>=\<value> \<key>=\<value> ...

- 两种语法的区别为第一种一次只能设置一个环境变量，第二种可以一次设置多个

### RUN
> 构建镜像的过程中要执行的命令

- 语法：
    - RUN \<command>
    - RUN ["executable", "param1", "param2"]

- 第一种写法就是直接写 Shell 脚本即可

- 第二种写法类似函数调用，第一个参数为可执行文件，后面的都是参数

### ADD
- 复制命令，把 src 的文件复制到镜像的 dest 位置

- 语法：
    - ADD \<src> \<dest>
    - ADD ["\<src>", "\<dest>"]

### WORKDIR
> 设置工作目录，可以简单理解为 cd 到指定目录，如果该目录不存在会自动创建，对 RUN、CMD、ENTRYPOINT、COPY、ADD 生效，可以设置多次 WORKDIR

- 如：
    - WORKDIR \<dir>

- 表示在容器内创建了 dir 目录，并且当前目录已经是 dir 目录了

### VOLUME
> 设置挂载目录，可以将主机中的指定目录挂载到容器中

- 语法：
    - VOLUME ["\<dir>"]
    - VOLUME \<dir>
    - VOLUME \<dir> \<dir>

- 以上三种写法都可

### EXPOSE
> 改镜像运行容器后，需要暴露给外部的端口，但仅仅表示该容器想要暴露某些端口，并不会与主机端口有映射关系，如果想将容器暴露的端口与主机映射则需要使用 -p 或 -P 参数来映射，可以暴露多个端口

- 语法：
    - EXPOSE \<port>[/<tcp/udp>]

### CMD
> 该镜像启动容器时默认执行的命令或参数

- 语法：
    - CMD ["executable", "param1", "param2"]
    - CMD ["param1", "param2"]
    - CMD \<command> \<param1> \<param2>

- 以上为该命令的三种写法，第三种与普通 Shell 命令类似，第一、二两种都是可执行文件 + 参数的形式，另外数组内的参数必须使用双引号。

- 案例：
    - 第一种：CMD ["sh", "-c", "echo \$HOME"] 等同于 sh -c "echo $HOME"

    - 第二种：CMD ["echo", "\$HOME"] 等同于 echo $HOME

### ENTRYPOINT
> 运行容器时的启动命令，感觉与 CMD 命令会很像，实际上还是有很大区别，简单对比一下：

- 相同点：
    在整个 Dockerfile 中只能设置一次，如果写了多次则只有最后一次生效
- 不同点：
    - ENTRYPOINT 不会被运行容器时指定的命令所覆盖，而 CMD 会被覆盖

- 如果同时设置了这两个指令，且 CMD 仅仅是选项而不是参数，CMD 中的内容会作为 ENTRYPOINT 的参数（一般不这么做）

- 如果两个都是完整命令，那么只会执行最后一条

- 语法：
    - ENTRYPOINT ["executable", "param1", "param2"]
    - ENTRYPOINT command param1 param2

## 拓展指令
### ARG
> 设置变量，在镜像中定义一个变量，当使用 docker build 命令构建镜像时，带上 --build-arg \<name>=\<value> 来指定参数值，如果该变量名在 Dockerfile 中不存在则会抛出一个警告

- 语法：
    - ARG \<name>[=\<default value>]

### USER
> 设置容器的用户，可以是用户名或 UID，如果容器设置了以 daemon 用户去运行，那么 RUN、CMD 和 ENTRYPOINT 都会以这个用户去运行，一定要先确定容器中有这个用户，并且拥有对应的操作权限。

- 语法：
    - USER \<username>
    - USER \<PID>

### ONBUILD
> 表示在构建镜像时做某操作，不过不对当前 Dockerfile 的镜像生效，而是对以当前 Dockerfile 镜像作为基础镜像的子镜像生效

- 语法：
    - ONBUILD [INSTRUCTION]

- 例：
    - 当前镜像为 A，设置了如下指令 
    `ONBUILD RUN ls -al`

    - 镜像 B：  
        FROM 镜像A  
        ......  
        构建镜像 B 时，会执行 ls -al 命令
        
### STOPSIGNAL
> STOPSIGNAL 指令设置将发送到容器的系统调用信号以退出。此信号可以是与内核的系统调用表中的位置匹配的有效无符号数，例如 9，或 SIGNAME 格式的信号名，例如 SIGKILL。

> 默认的stop-signal是SIGTERM，在docker stop的时候会给容器内PID为1的进程发送这个signal，通过--stop-signal可以设置自己需要的signal，主要的目的是为了让容器内的应用程序在接收到signal之后可以先做一些事情，实现容器的平滑退出，如果不做任何处理，容器将在一段时间之后强制退出，会造成业务的强制中断，这个时间默认是10s。

- 例
```bash
STOPSIGNAL \<signal>
```

### HEALTHCHECK
> 容器健康状况检查，可以指定周期检查容器当前的健康状况，该命令只能出现一次，如果有多次则只有最后一次生效。

- 语法：
    - HEALTHCHECK [OPTIONS] CMD command
    - HEALTHCHECK NONE

- 第一种：在容器内部按照指定周期运行指定命令来检测容器健康状况
- 第二种：取消在基础镜像

- OPTIONS 选项：
    - --interval=DURATION 两次检查的间隔时间，默认30s
    - --timeout=DURATION 命令执行的超时时间，默认30s
    - --retries=N 当连续失败指定次数，容器会被认定为不健康，默认为3次
    - 返回参数：
    - 0：success => 健康状态
    - 1：unhealthy => 不健康状态
    - 2：reserved => 保留值

## ENTRYPOINT 和 CMD 的用法和区别

### `ENTRYPOINT`

- **定义**：`ENTRYPOINT` 指定了容器启动时要执行的主要命令，并且这个命令不能被覆盖。
- **用途**：适用于需要确保容器启动时始终执行特定命令的情况。
- **用法**：
  - **Exec 格式**（推荐）：
    ```Dockerfile
    ENTRYPOINT ["executable", "param1", "param2"]
    ```
  - **Shell 格式**：
    ```Dockerfile
    ENTRYPOINT executable param1 param2
    ```

### `CMD`

- **定义**：`CMD` 提供了容器启动时的默认参数，这些参数可以被 `docker run` 命令行中指定的参数覆盖。
- **用途**：适用于提供默认参数或命令，并允许在启动容器时覆盖它们的情况。
- **用法**：
  - **Exec 格式**（推荐）：
    ```Dockerfile
    CMD ["param1", "param2"]
    ```
  - **Shell 格式**：
    ```Dockerfile
    CMD executable param1 param2
    ```

### 使用示例

#### 示例 1：使用 `ENTRYPOINT` 和 `CMD` 的组合

假设您要创建一个容器，它启动时会运行一个 Python 脚本，并且您希望能够覆盖脚本的参数。

```Dockerfile
# Dockerfile
FROM python:3.9-slim

# 将 Python 脚本复制到容器中
COPY script.py /usr/src/app/script.py

# 设置 ENTRYPOINT
ENTRYPOINT ["python", "/usr/src/app/script.py"]

# 提供默认参数
CMD ["default_arg1", "default_arg2"]
```

**解释**：
- `ENTRYPOINT` 指定了容器启动时始终运行 `python /usr/src/app/script.py`。
- `CMD` 提供了默认参数 `default_arg1` 和 `default_arg2`，这些参数可以在 `docker run` 命令中被覆盖。

**运行**：
- 使用默认参数：
  ```bash
  docker run myimage
  ```
  这将运行 `python /usr/src/app/script.py default_arg1 default_arg2`。

- 使用自定义参数：
  ```bash
  docker run myimage custom_arg1 custom_arg2
  ```
  这将运行 `python /usr/src/app/script.py custom_arg1 custom_arg2`。

#### 示例 2：仅使用 `ENTRYPOINT`

如果您希望容器总是执行一个固定的命令，并且不希望在 `docker run` 中覆盖该命令，可以仅使用 `ENTRYPOINT`：

```Dockerfile
# Dockerfile
FROM ubuntu:latest

# 设置 ENTRYPOINT
ENTRYPOINT ["/bin/echo", "Hello"]
```

**运行**：
- 运行容器：
  ```bash
  docker run myimage World
  ```
  这将输出 `Hello World`。`ENTRYPOINT` 中的 `/bin/echo` 是固定的，而 `docker run` 中提供的 `World` 是传递给 `echo` 命令的参数。

#### 示例 3：仅使用 `CMD`

如果您不需要指定固定的命令，只是提供默认参数，可以仅使用 `CMD`：

```Dockerfile
# Dockerfile
FROM ubuntu:latest

# 设置 CMD
CMD ["echo", "Hello World"]
```

**运行**：
- 使用默认命令：
  ```bash
  docker run myimage
  ```
  这将输出 `Hello World`。

- 使用自定义命令：
  ```bash
  docker run myimage "Custom Message"
  ```
  这将输出 `Custom Message`。

### 总结

- **`ENTRYPOINT`**：用于指定容器启动时始终执行的主要命令。如果 `ENTRYPOINT` 和 `CMD` 都定义了，`CMD` 提供的参数将作为 `ENTRYPOINT` 中命令的默认参数。
- **`CMD`**：用于提供容器启动时的默认参数，这些参数可以被 `docker run` 命令中的参数覆盖。

选择使用 `ENTRYPOINT`、`CMD` 还是两者结合取决于您是否需要固定的执行命令或提供默认参数并允许覆盖。

Dockerfile

# 概念
## 是什么？
> 数据卷相当于是容器的虚拟文件系统和主机的真实文件系统之间的一个桥梁，建立数据卷就相当于是打通了容器于主机之间的文件交互通道，可以让容器运行时所产生的数据变更被保存到主机中，能够更方便的对数据进行备份以及保护

## 为什么需要？
> 当我们在容器中运行一些关键的应用如MySQL、Redis等服务，其中都会存储着一些关键数据，这些数据是你希望即使删除容器也不应该被删除的，此时我们便需要用到数据卷了。

## 能干什么？
> 你可以将数据卷理解为文件目录的映射，我们可以通过 Docker 提供的相关命令，来将主机中的某一个文件目录映射到容器中，此时当你在容器中操作该目录下的文件时，实际上操作的就是主机中的文件。

![image.png](/static/img/ce2f586a0a5bbc1a80d703840509dd19.image.webp)

- **可以使用`docker volume ls`命令来查看已经存在的docker volume**



# 绑定方式
## 匿名绑定
> 在启动容器时直接使用 -v /container_dir 即可完成匿名绑定，匿名绑定的方式将在 Docker 的 volumes 目录下生成一个 sha256 的字符串作为目录名，且指定的 /container_dir 中的文件或目录会被保存在该处，**匿名绑定的 volume 在容器被删除的时候，数据卷也会被删除**

- 命令例子
```bash
docker run --rm -d -p 80:80 -v /www/test nginx
```

- **匿名绑定方式由于不知道名称，因此如果需要查看数据卷在主机的哪个位置，需要使用 `docker inspect container_id` 来查看**

![image.png](/static/img/b72c2f2e7d96333c3fde9682042a4f83.image.webp)

## 具名绑定
> 同样是启动容器时绑定一个数据卷，不同的是可以为该数据卷起个名字 -v volume-name:container_dir，通过名字你可以快速的定位并管理这些 volume, **具名绑定的 volume 在容器被删除的时候，数据卷不会被删除**

- 命令例子
```bash
docker run --rm -d -p 80:80 -v nginx-www:/www/test nginx
```

- 示例
```bash
[root@ser977621502852 _data]# docker run -d --rm --name nginx02 -p 8090:80 -v nginx02:/usr/share/nginx/html nginx
2c5e47e0997d00474644942eef507296c569124b0348b31d751dcf40184c3cdd
[root@ser977621502852 _data]# docker volume ls
DRIVER    VOLUME NAME
local     eab1ce65fdf3112b004ff3f5c8456423dec55a49b0629889d966a34c60fd363d
local     nginx02
```

![image.png](/static/img/ec0765be00128f8fc6d3596b2d98c798.image.webp)

## Bind Mount
> 绑定并加载主机的某个文件目录到容器中，这种方式是平常最常用的。这种绑定方式与前面两种一样，也是在容器启动时使用 -v host_dir:container_dir 的格式来完成映射

- 命令例子
```bash
docker run --rm -d -p 80:80 -v /www/gyc:/www/gyc -v /etc/nginx/nginx.conf:/etc/nginx/nginx.conf nginx
```

# 数据卷管理
> Docker 为我们提供了一些专门用于管理数据卷的命令 docker volume，通过下面的 Usage 来查看相关命令的使用

- Usage:	docker volume COMMAND

Manage volumes

- Commands:
  - create      创建一个数据卷
  - inspect     显示一个或多个数据卷的详细信息
  - ls          查看目前已有的数据卷列表
  - prune       删除所有本地没有被使用的数据卷
  - rm          删除一个或多个数据卷

## 示例
```bash
[root@ser977621502852 _data]# docker volume ls
DRIVER    VOLUME NAME
local     eab1ce65fdf3112b004ff3f5c8456423dec55a49b0629889d966a34c60fd363d
local     nginx02
[root@ser977621502852 _data]# docker volume create gycvolume
gycvolume
[root@ser977621502852 _data]# docker volume ls
DRIVER    VOLUME NAME
local     eab1ce65fdf3112b004ff3f5c8456423dec55a49b0629889d966a34c60fd363d
local     gycvolume
local     nginx02
[root@ser977621502852 _data]# docker volume inspect gycvolume
[
    {
        "CreatedAt": "2024-02-8T016:26:00Z",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/gycvolume/_data",
        "Name": "gycvolume",
        "Options": null,
        "Scope": "local"
    }
]
[root@ser977621502852 _data]# docker volume rm gycvolume
gycvolume
[root@ser977621502852 _data]# docker volume ls
DRIVER    VOLUME NAME
local     eab1ce65fdf3112b004ff3f5c8456423dec55a49b0629889d966a34c60fd363d
local     nginx02
```

Docker数据卷

# 概念
## 是什么
> 是 Docker 对容器网络隔离的一项技术，提供了多种不同的模式供用户使用，选择不同的网络模式来实现容器网络的互通以及彻底的隔离。

## 为什么需要
- 容器间的网络隔离
- 实现部分容器之间的网络共享
- 管理多个子网下容器的 ip



## 能做什么
- 提供了多种模式，可以定制化的为每个容器置顶不同的网络
- 自定义网络模式，划分不同的子网以及网关、dns等配置
- 网络互通
    - 实现不同子网之间的网络互通
    - 基于容器名（主机名）的方式在网络内访问


# 网络模式
## bridge（桥接）<默认模式>
> 在主机中创建一个 Docker0 的虚拟网桥，在 Ddocker0 创建一对虚拟网卡，有一半在主机上 veth<xxx>，还有一半在容器内 eth0， 实现主机与容器间的通信.
    
![image.png](/static/img/cf7207da31d716afbcb6d723f96c3bd0.image.webp)
    
## host(主机模式)
> 容器不再拥有自己的网络空间，而是直接与主机共享网络空间，那么基于该模式创建的容器对应的 ip 实际就是与主机同一个子网，同一个网段。

- 牺牲主机一定的安全性, 无法实现容器的隔离

![image.png](/static/img/54a2a5c07b729d8fedeed5669b7f1a0a.image.webp)

## none
>  Docker 会拥有自己的网络空间，不与主机共享，在这个网络模式下的容器，不会被分配网卡、ip、路由等相关信息。

- 特点：完全隔离，与外部任何机器都无网络访问，只有自己的 lo 本地网络 127.0.0.1

![image.png](/static/img/2996fec634953b3d089c0811def7320d.image.webp)
    
## container
> 就是不会创建自己的网络空间，而是与其他容器共享网络空间，直接使用指定容器的ip/端口等

![](https://www.gycblog.cn/static/img/62b87b5391ac759cef1cc37866f75299.image.webp)
    
## 自定义（推荐）
> 不适用 Docker 自带的网络模式，而是自己去定制化自己特有的网络模式。

- 命令：
```bash
docker network COMMAND
```
    
- 例子
```bash
docker network create --driver bridge --subnet 192.168.133.0/24 --gateway 192.168.133.1 gycnet01
```
- `docker network create`: 这个命令用于创建一个新的 Docker 网络。Docker 网络使容器可以相互通信，也可以连接到外部网络。

- `--driver bridge`: 这个参数指定网络驱动类型为 bridge。桥接网络是 Docker 默认的网络驱动，创建的容器会在同一个虚拟局域网（VLAN）中，相互通信时使用容器的 IP 地址。

- `--subnet 192.168.133.0/24`: 这个参数指定了新建网络的子网范围。192.168.133.0/24 表示子网掩码为 255.255.255.0 的子网，IP 地址范围从 192.168.133.1 到 192.168.133.254。

- `--gateway 192.168.133.1`: 这个参数指定了该网络的默认网关 IP 地址，通常是子网中的第一个可用 IP 地址。在这个网络中，所有容器都会通过这个网关与外部网络通信。

- `gycnet01`: 这是为新创建的 Docker 网络指定的名称。在这个例子中，网络名称为 gycnet01。
    
### 为容器指定网络模式
```bash
[root@ser977621502852 ~]# docker run -d --rm -P --name nginx_network1 --net gycnet01 nginx
3a157e7e143292f7c1d0edb58b1dd3cc2d77ebb6596ac07c172e076cf14c0117
[root@ser977621502852 ~]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS                                     NAMES
3a157e7e1432   nginx     "/docker-entrypoint.…"   8 seconds ago   Up 5 seconds   0.0.0.0:32768->80/tcp, :::32768->80/tcp   nginx_network1
[root@ser977621502852 ~]# docker exec -it 3a157e7e1432 /bin/bash
root@3a157e7e1432:/# cat /etc/hosts
127.0.0.1       localhost
::1     localhost ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
192.168.133.2   3a157e7e1432
```
- `--net` 参数指定网络模式
    
# 桥接模式的网络互联
```bash
[root@ser977621502852 ~]# docker run -d --rm -P --name docker_net1 --net bridge centos ping 127.0.0.1
Unable to find image 'centos:latest' locally
latest: Pulling from library/centos
a1d0c7532777: Pull complete 
Digest: sha256:a27fd8080b517143cbbbab9dfb7c8571c40d67d534bbdee55bd6c473f432b177
Status: Downloaded newer image for centos:latest
8aea9f40c341a4bb0c7bfa1a940eaf5da32a3d0d645409bebc5ca79dd6d5f8ad
[root@ser977621502852 ~]# docker run -d --rm -P --name docker_net2 --net bridge centos ping 127.0.0.1
6b375a46000f8b0d7cb85544aae188c1d7912b697b7fefb66d958506042c023b
[root@ser977621502852 ~]# docker exec -it docker_net1 ping docker_net2
ping: docker_net2: Name or service not known
```
1. 创建了两个网络模式为bridge的centos容器
2. 让它们执行`ping 127.0.0.1`命令是为了容器不停止而被终止删除
3. 两个桥接模式下的容器无法相互(**名称**)ping通

```bash
docker run -d --rm -P --name docker_net2 --link docker_net1 centos ping 127.0.0.1
```
- 使用`--link`参数可以使docker_net2关联到docker_net1，使docker_net2ping通docker_net1
- 只支持自定义的网络, 或默认(bridge)网络
- 只能实现ping通关联的容器, 无法实现双向ping通
    
## 实现原理

![image.png](/static/img/84085a3afb5a8de0e93e76380f1c5ab3.image.webp)

- 在/etc/hosts文件中将所链接的容器名称与ip相对应
    
# 跨容器网络通信
1. 创建两个不同网络模式的容器
```bash
[root@ser977621502852 ~]# docker run -d --rm -P --name net1 centos ping 127.0.0.1
a83bab59f6922fd319c5ad764f5322c518327c0272d8e059ccc743138ded2d89
[root@ser977621502852 ~]# docker run -d --rm -P --name net2 --net gycnet01 centos ping 127.0.0.1
dbf74338e382f009a79b5641d6a3a2b56ca6409d74c5c623735d1b028d0270eb 
```
2. 使用`docker inspect` 命令查看容器详细信息
- net1 `172.17.0网段`

![image.png](/static/img/25c83ebc1bef706513de97231f2644e5.image.webp)

- net2 `192.168.133网段`

![image.png](/static/img/a213f3d1904ab1330004a84b37892327.image.webp)
    
3. net2 ping net1, 无法ping通
```bash
[root@ser977621502852 ~]# docker exec -it net2 ping net1
ping: net1: Name or service not known
```

4. 使用 `docker network connect`命令连接
```bash
[root@ser977621502852 ~]# docker network connect gycnet01 net1
[root@ser977621502852 ~]# docker exec -it net2 ping net1
PING net1 (192.168.133.3) 56(84) bytes of data.
64 bytes from net1.gycnet01 (192.168.133.3): icmp_seq=1 ttl=64 time=0.235 ms
64 bytes from net1.gycnet01 (192.168.133.3): icmp_seq=2 ttl=64 time=0.128 ms
^C
--- net1 ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1001ms
rtt min/avg/max/mdev = 0.128/0.181/0.235/0.055 ms
```
- 发现可以ping通
- 命令 `docker network connect gycnet01 net1` 的作用是将已经运行的容器 net1 连接到 Docker 网络 gycnet01 中
- **实际上相当于在容器 net1 中添加了一张新网卡，这张网卡使用 gycnet01 网络**

![image.png](/static/img/aae12515450b91ccd362bedb9ff5b4df.image.webp)

## 原理图

![image.png](/static/img/219162787256c2ceb61e8e49cd4806c5.image.webp)
    
# none网络模式实容器互通
1. 创建两个网络模式为none的容器
```bash
[root@ser977621502852 ~]# docker run -d --rm -P --name net1 --net none centos ping 127.0.0.1
a2ea1a0de45cbc53016943d86e85725aefe639029dbb2a6bba411045de0d7e82
[root@ser977621502852 ~]# docker run -d --rm -P --name net2 --net none centos ping 127.0.0.1
e40dad334de72b76d1112ac66c5807621aa128e75dbb9e1eb852ce17997fd475
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host 
       valid_lft forever preferred_lft forever
[root@ser977621502852 ~]# docker exec -it net2 ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host 
       valid_lft forever preferred_lft forever
```
- 发现两个容器只有回环地址
- 当然无法ping通

> 两个容器之间可以直连通信，但不通过主机网桥进行桥接。解决的办法是创建一对 peer 接口，分别放到两个容器中，配置成点到点链路类型

2. 找到这两个容器的进程号：
```bash
[root@ser977621502852 ~]# docker inspect -f '{{.State.Pid}}' net1
5117
[root@ser977621502852 ~]# docker inspect -f '{{.State.Pid}}' net2
5172
```

3. 然后创建网络命名空间的跟踪文件：
```bash
mkdir -p /var/run/netns
ln -s /proc/5117/ns/net /var/run/netns/5117
ln -s /proc/5172/ns/net /var/run/netns/5172
```

4. 创建一对 `veth` 接口并配置网络
```bash
ip link add A type veth peer name B
ip link set A netns 5117
ip netns exec 5117 ip addr add 10.1.1.1/32 dev A
ip netns exec 5117 ip link set A up
ip netns exec 5117 ip route add 10.1.1.2/32 dev A

ip link set B netns 5172
ip netns exec 5172 ip addr add 10.1.1.2/32 dev B
ip netns exec 5172 ip link set B up
ip netns exec 5172 ip route add 10.1.1.1/32 dev B
```

5. 测试连接
- 你可以进入任一容器，并尝试 ping 另一容器的 IP 地址来测试通信：
```bash
[root@ser977621502852 ~]# docker exec -it net1 ping 10.1.1.2
PING 10.1.1.2 (10.1.1.2) 56(84) bytes of data.
64 bytes from 10.1.1.2: icmp_seq=1 ttl=64 time=0.194 ms
64 bytes from 10.1.1.2: icmp_seq=2 ttl=64 time=0.071 ms
^C
--- 10.1.1.2 ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 999ms
rtt min/avg/max/mdev = 0.071/0.132/0.194/0.062 ms
[root@ser977621502852 ~]# docker exec -it net2 ping 10.1.1.1
PING 10.1.1.1 (10.1.1.1) 56(84) bytes of data.
64 bytes from 10.1.1.1: icmp_seq=1 ttl=64 time=0.138 ms
64 bytes from 10.1.1.1: icmp_seq=2 ttl=64 time=0.152 ms
^C
--- 10.1.1.1 ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1000ms
rtt min/avg/max/mdev = 0.138/0.145/0.152/0.007 ms
```
- 可以ping通
    
## 原理
> 在 Docker 的 none 网络模式下，容器没有任何网络连接，除了本地的回环接口（lo）。要使这些容器进行通信，你需要创建虚拟网络接口（veth），并将这些接口连接到容器的网络命名空间中。这样，两个容器可以通过虚拟网卡直接通信，而不依赖于主机的网络桥接。

> 虚拟以太网（veth）接口 是一对网络接口，其中一个接口在主机或一个网络命名空间中，另一个接口在另一个网络命名空间中。它们在逻辑上是相连的，因此一个接口发送的数据包会被另一个接口接收到。

- 步骤总结：

1. 创建 veth 对：创建一对虚拟以太网接口，其中一个接口连接到一个容器的网络命名空间，另一个接口连接到另一个容器的网络命名空间。
2. 分配 IP 地址：为每个 veth 接口分配一个 IP 地址，并在容器的网络命名空间中配置这些接口。
3. 设置路由：在每个容器中配置路由，使其能够通过对端接口与另一容器通信。
    

![image.png](/static/img/1c3ac18c34d3b4092aa3592bc3868fa4.image.webp)

## 容器和宿主机的关系
1. veth 接口的一端在宿主机：每对 veth 接口中的一个接口可以位于宿主机网络命名空间中，而另一端位于容器的网络命名空间中。图中展示的 veth A 和 veth B 是在各自的网络命名空间中，但它们实际是通过宿主机连接的。

2. 宿主机管理网络命名空间：宿主机负责创建和管理这些网络命名空间，并将 veth 接口分配到对应的命名空间中。宿主机可以看到所有的 veth 接口，并决定如何配置这些接口以实现网络通信。

3. 宿主机作为网关（可选）：在某些情况下，宿主机可以充当网关，允许这些网络命名空间访问外部网络。不过，在这个 "none" 网络模式的示例中，宿主机只是作为一个基础设施存在，主要提供接口连接和命名空间管理，而不直接参与数据包的转发。

- **宿主机的主要作用是提供和管理虚拟网络环境，确保这些命名空间中的 veth 接口能够互通。在这个设计中，容器之间的通信并不依赖宿主机的外部网络，而是通过宿主机内部的虚拟网络实现。**