1 Docker 核心概念

1.1 为什么要用容器？

1. 上线流程繁琐

开发 → 测试 → 申请资源 → 审批 → 部署 → 测试等环节

1. 资源利用率低

普遍服务器利用率低，造成过多浪费[ 传统的虚拟化，利用率也是较低的，也不能一直将服务器的利用率一直占满 ]

1. 扩容/缩容不及时

业务高峰期扩容流程繁琐，上线不及时

1. 服务器环境臃肿

服务器越来越臃肿，对维护、迁移带来困难[ 需要对服务器集群环境进行治理 ]

1. 环境不一致性

测试环境，开发环境，线上环境

:::color1 （1）已知的业务承载量

（2）未知的业务承载量

• 业务机器增加承载量，可以应对一些突发，30%
• 弹性伸缩，HPA

:::

1.2 Docker 是什么

• 使用最广泛的开源容器引擎
• 一种操作系统级的虚拟化技术[ 沙盒技术 ]
• 依赖于Linux内核特性：Namespace( 资源隔离 )和Cgroups( 资源限制 )

CGroups 资源控制系统，每种子系统独立地控制一种资源。功能如下

• 一个简单的应用程序打包工具

1.3 Docker 设计目标

• 提供简单的应用程序打包工具
• 开发人员和运维人员职责逻辑分离
  • 开发人员：
    • 1、开发项目
    • 2、打包项目环境 + 代码成镜像
    • 3、部署到容器平台
  • 运维人员：怎么高效去管理容器
    • 1、运维人员节省人工成本
    • 2、持续发布有问题更快解决
• 多环境保持一致性，标准化

1.4 Docker 基本组成

:::color1

1. Docker 引擎会查看本地是否拥有Images镜像，若本地有镜像，则可以直接运行成Containers容器实例，根据镜像的不同，运行出的容器实例也各不相同
2. 若本地没有镜像，则会通过网络向公有Registry仓库或者私有仓库拉取镜像后，再来运行成容器。

<font style="color:#E8323C;">Linux容器(Linux Containers)，缩写为 LXC</font>

<font style="color:#E8323C;">Linux容器不是模拟一个完整的操作系统而是对进程进行隔离</font>。有了容器，就可以将软件运行所需的所有资源打包到一个隔离的容器中。<font style="color:#E8323C;">容器与虚拟机不同，不需要捆绑一整套操作系统</font>，只需要软件工作所需的库资源和设置。系统因此而变得高效轻量并且保证部署在任何环境中的软件都能始终如一的运行。

Docker 容器是在操作系统层面上实现虚拟化，直接复用本地主机的操作系统，而传统虚拟机则是在硬件层面实现虚拟化。与传统的虚拟机相比，<font style="color:#E8323C;">Docker 优势体现为启动速度快，占用体积小</font>。

1.5.3 容器 VS 虚拟机对比

比较了 Docker 和传统虚拟化方式的不同之处：

• 传统虚拟机技术是虚拟出一套硬件后，在其之上运行一个完整的操作系统，在该系统上再运行所需的应用进程。
• 容器内的应用进程直接运行于宿主机的内核，容器内没有自己的内核并<font style="color:#E8323C;">且也没有进行硬件虚拟</font>。因此容器比传统虚拟机更为轻便。
• 每个容器之间互相隔离，每个容器有自己的文件系统，容器之间进程不会互相影响，能区分计算资源。

:::color1 容器：

1. 提供一个基本的独立环境，实现容器隔离，资源限制
2. 主要解决应用层面的问题，应用快速部署，高效管理

虚拟机：

1. 提升服务器资源利用率
2. 提供一个完全隔离的环境

:::

1.6 Docker 应用场景

• 应用程序打包和发布
• 应用程序隔离
• 持续集成
• 部署微服务
• 快速搭建测试环境
• 提供PaaS产品( 平台即服务 )

1.7 Linux 安装 Docker

:::color1 Docker版本：

社区版 ( Community Edition , CE )

企业版 ( Enterprise Edition , EE )

支持平台：

• Linux (CentOS, Debian, Fedora, Oracle Linux, RHEL, SUSE 和 Ubuntu)
• Mac
• Windows

:::

1.7.1 CentOS 部署 Docker

安装依赖包

yum install -y yum-utils

添加Docker软件包源

yum-config-manager \
--add-repo \
https://download.docker.com/linux/centos/docker-ce.repo

安装Docker CE

yum install -y docker-ce

启动Docker服务并设置开机启动

systemctl enable --now docker

官方文档：https://docs.docker.com

Docker官方二进制文档：https://docs.docker.com/engine/install/binaries/

阿里云源：http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

范例：CentOS 部署 Docker 脚本

#!/bin/bash
# Shell ENV
DOCKER_VERSION="20.10.7"
CONTAINERD_VERSION="1.4.6"
# step 1: 安装必要的一些系统工具
echo -e "==> 安装必要的系统工具"
sudo yum install -y yum-utils device-mapper-persistent-data lvm2
# Step 2: 添加软件源信息
echo -e "==> 添加软件源信息"
sudo yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
# Step 3
echo -e "==> 修改配置文件"
sudo sed -i 's+download.docker.com+mirrors.aliyun.com/docker-ce+' /etc/yum.repos.d/docker-ce.repo
# Step 4: 更新并安装Docker-CE
echo -e "==> 安装更新Docker"
sudo yum makecache fast
# containerd.io Docker运行时环境
sudo yum -y install docker-ce-${DOCKER_VERSION} docker-ce-cli-${DOCKER_VERSION} containerd.io-${CONTAINERD_VERSION}
# Step 5: 配置加速器以及docker参数
echo -e "==> 配置加速器以及docker参数"
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://po13h3y1.mirror.aliyuncs.com","http://hub-mirror.c.163.com","https://mirror.ccs.tencentyun.com","http://f1361db2.m.daocloud.io"],
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m"
  },
  "storage-driver": "overlay2"
}
EOF
# Step 6: 加载服务
echo -e "==> 加载服务"
sudo systemctl daemon-reload
sudo systemctl restart docker
sudo systemctl enable docker
# Step 7: 查看Docker服务信息
echo -e "==> 查看Docker服务信息"
docker info

1.7.2 Ubuntu 部署 Docker

#!/bin/bash
#Description: ubuntu1804系统安装docker-compose编排工具
COLOR="echo -e \\033[1;31m"
END="\033[m"
DOCKER_VERSION="5:19.03.5~3-0~ubuntu-bionic"
install_docker(){
${COLOR}"开始安装 Docker....."${END}
sleep 1 
apt update
apt  -y install apt-transport-https ca-certificates curl software-properties-common 
curl -fsSL https://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo apt-key add -
add-apt-repository "deb [arch=amd64] https://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable"
apt update
${COLOR}"Docker有以下版本:"${END}
sleep 2
apt-cache madison docker-ce
${COLOR}"5秒后即将安装: docker-"${DOCKER_VERSION}" 版本....."${END}
${COLOR}"如果想安装其它Docker版本，请按ctrl+c键退出，修改版本再执行"${END}
sleep 5
apt -y  install docker-ce=${DOCKER_VERSION} docker-ce-cli=${DOCKER_VERSION}
mkdir -p /etc/docker
tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://po13h3y1.mirror.aliyuncs.com","http://hub-mirror.c.163.com","https://mirror.ccs.tencentyun.com","http://f1361db2.m.daocloud.io"],
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m"
  },
  "storage-driver": "overlay2"
}
EOF
systemctl daemon-reload
systemctl restart docker
docker version && ${COLOR}"Docker 安装完成"${END} ||  ${COLOR}"Docker 安装失败"${END}
}
install_docker_compose(){
${COLOR}"开始安装 Docker compose....."${END}
sleep 1
curl -L https://github.com/docker/compose/releases/download/1.25.3/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose
docker-compose --version &&  ${COLOR}"Docker Compose 安装完成"${END} ||  ${COLOR}"Docker compose 安装失败"${END}
}
dpkg -s docker-ce &> /dev/null && ${COLOR}"Docker已安装"${END} || install_docker
docker-compose --version &> /dev/null && ${COLOR}"Docker Compose已安装"${END} || install_docker_compose

1.7.3 运行 hello-world 容器

$ docker run hello-world
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
2db29710123e: Pull complete 
Digest: sha256:2498fce14358aa50ead0cc6c19990fc6ff866ce72aeb5546e1d59caac3d0d60f
Status: Downloaded newer image for hello-world:latest
Hello from Docker!
This message shows that your installation appears to be working correctly.
To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.
To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash
Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/
For more examples and ideas, visit:
 https://docs.docker.com/get-started/
# Docker 环境搭建成功

2 Docker 镜像管理

2.1 什么是镜像

• 一个分层存储的文件
• 一个软件的环境
• 一个镜像可以创建N个容器
• 一种标准化的交付
• 一个不包含Linux内核而又精简的Linux操作系统
• 镜像不是一个单一的文件，而是有多层构成

2.2 镜像从哪里来？

Docker Hub是由Docker公司负责维护的公共注册中心，包含大量的容器镜像，Docker工具默认从这个公共镜像库下载镜像。

Docker Hub地址: https://hub.docker.com

1、Docker命令最后一个是指定镜像

2、默认镜像版本latest

3、分层下载

配置镜像加速器：

mkdir -p /etc/docker
tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://po13h3y1.mirror.aliyuncs.com","http://hub-mirror.c.163.com","https://mirror.ccs.tencentyun.com","http://f1361db2.m.daocloud.io"],
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m"
  },
  "storage-driver": "overlay2"
}
EOF

2.3 镜像与容器联系

当启动一个新的容器时，Docker会加载只读镜像，并在其之上添加一个读写层，即容器层。

/var/lib/docker/containers/:容器元数据信息目录
/var/lib/docker/overlay2/  :镜像目录

rootfs:根文件系统
bootfs:引导文件系统，引导程序和内核，容器是共享宿主机的内核

2.4 镜像常用管理命令

:::color1 commit：将运行的容器直接提交为镜像。

export：将容器（运行或不运行）打包成tar包，再由import将tar包提交为镜像。

save：将镜像打包成tar包，再有load将tar包提交为镜像。

:::

# 导出容器文件系统到tar归档文件
$ docker run -it -d --name nginx-node1 nginx:latest
$ docker export nginx-node1 -o nginx.tar
$ tar -tf nginx.tar 
# 导入容器文件系统tar归档文件创建镜像
$ docker import nginx.tar
# 保存一个或多个镜像到一个tar归档文件
$ docker save -o nginx.tar nginx:latest
# 加载镜像来自tar归档或标准输入
$ docker load -i nginx.tar
# 将运行的容器直接提交为镜像
~ docker run -itd --name c1 centos /bin/bash
~ docker exec -it c1 /bin/bash
$ rm -rf /etc/yum.repos.d/CentOS-Linux-*
$ curl -o /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-vault-8.5.2111.repo
$ yum update ; yum install -y vim ; yum clean all
$ vim --version
VIM - Vi IMproved 8.0 (2016 Sep 12, compiled Sep 22 2021 11:10:49)
$ exit
~ docker commit -a "zhongzhiwei <935523993@qq.com>" -m "添加VIM软件" c1 kubesphere-centos:1.0
~ docker images kubesphere-centos:1.0
REPOSITORY          TAG       IMAGE ID       CREATED         SIZE
kubesphere-centos   1.0       7f36413d0ef3   4 seconds ago   271MB
# 运行添加VIM的新镜像
~ docker run -it --name kc1 kubesphere-centos:1.0 /bin/bash
$ vim --version
VIM - Vi IMproved 8.0 (2016 Sep 12, compiled Sep 22 2021 11:10:49)
#########################################################################################################
~ docker run -itd --name u1 ubuntu /bin/bash
~ docker exec -it u1 /bin/bash
$ apt update ; apt install -y vim
$ vim --version
VIM - Vi IMproved 8.0 (2016 Sep 12, compiled Sep 22 2021 11:10:49)
$ exit
~ docker commit -a "zhongzhiwei <935523993@qq.com>" -m "添加VIM软件" c1 kubesphere-ubuntu:1.0
~ docker images kubesphere-ubuntu:1.0
REPOSITORY          TAG       IMAGE ID       CREATED         SIZE
kubesphere-ubuntu   1.0       7f36413d0ef3   4 seconds ago   178MB
# 运行添加VIM的新镜像
~ docker run -it --name ku1 kubesphere-ubuntu:1.0 /bin/bash
$ vim --version
VIM - Vi IMproved 8.0 (2016 Sep 12, compiled Sep 22 2021 11:10:49)

2.5 镜像存储核心技术：联合文件系统 (UnionFS)

镜像怎么高效存储？

难道像虚拟机那样一个容器对应一个独立的镜像文件?这样对于密集型容器，磁盘占用率太大！

答：引入联合文件系统，将镜像多层文件联合挂载到容器文件系统

:::color1 容器层（读写）：提供一个独立的运行环境

:::

2.6 镜像存储核心技术：写时复制 (COW)

了解联合文件系统后，我们知道，镜像是只读的，类似共享形式让多个容器使用，如果要在容器里修改文件，即镜像里的文件，那该怎么办呢?

答：引入写时复制(copy-on-write)，需要修改文件操作时，会先从镜像里把要写的文件复制到自己的文件系统中进行修改[ 该逻辑在用户视觉层面是屏蔽的 ]。

# 默认挂载宿主机的三个文件
hostname            --hostname
hosts                    --dns
resolv.conf        --add-host

:::color1 读文件：容器层 → 镜像层

修改文件：容器层 → 镜像层

Storage Driver: overlay2 ( aufs 、overlay、devicemapper )

:::

优化建议

使用SSD固态硬盘

使用卷作为频繁读写文件的工作目录，绕过存储驱动，减少抽象的开销

2.7 Docker 打包成镜像

docker commit 将容器提交成镜像

• docker export 将容器打包成 tar 包

docker export -o .tar

根据容器的大小，打包的效率也会随之变化

• docker import 将 tar 包提交为镜像

docker import .tar :

根据Tar包的大小，提交镜像的效率也会随之变化

• docker save 将镜像打包成 tar 包

docker save : -o .tar

根据镜像的大小，打包的效率也会随之变化

• docker load 将 tar 包提交为镜像

docker load -i .tar

根据Tar包的大小，提交镜像的效率也会随之变化

以及使用 Dockerfile 编写镜像脚本

docker build -t ImageName:[Tag] -f Dockerfile .

2.8 容器文件存储解析

2.8.1 容器运行时的 UpperDir 目录结构

#~ touch /data/docker/overlay2/<UpperDir>/container_upperdir.txt
~ echo "Welcome to container_upperdir" >> /data/docker/overlay2/<UpperDir>/container_upperdir.txt
#在进入到容器操作查看
~ docker exec -it jdk8-node01 /bin/bash
~ cat /container_upperdir.txt

2.8.2 Work目录

work目录用于联合挂载指定的工作目录，在overlay 把文件挂载到 upperdir后， work内容会被清空，且在使用过程中（为空）其内容用户不可见。

2.8.3 用户视角层 Merged

最后给用户展示的层,一般看到为一个完整的操作系统文件系统结构

~ ls -l /data/docker/overlay2/<Merged>/

2.8.4 Lower 层

• a：系统的 init （docker 容器启动后自动挂载）
• b：容器的镜像层

~ cat /data/docker/overlay2/<LowerDir>-init/lower
l/BYHA4RECHA4CPGWNIZLPAN7HCD:l/JGA2WPDQWQI3IKC3JSFPHFBMDA:
#init层 :/ 容器镜像层

:::color1 docker 容器管理工具即做了资源隔离，挂载，分配一个网段。

:::

2.8.4.1 查看init层地址指向

容器在启动的过程中, Lower 会自动挂载init的一些文件

~ ls -l  /data/docker/overlay2/<LowerDir>-init/diff/etc/
total 0
-rwxr-xr-x 1 root root  0 Jun 28 21:15 hostname
-rwxr-xr-x 1 root root  0 Jun 28 21:15 hosts
lrwxrwxrwx 1 root root 12 Jun 28 21:15 mtab -> /proc/mounts
-rwxr-xr-x 1 root root  0 Jun 28 21:15 resolv.conf

:::color1 需求：同一个域名，在公网解析成另一个公网IP地址，在内网解析成另一个内网IP地址。

在修改 容器的hosts文件的时候，需要将整个镜像全部构建完毕后，在启动脚本中修改 hosts 文件，需要在最后一个步骤才能进行修改，因为会在容器挂载的时候覆盖掉该文件。

在将来绑定 hosts 的时候需要知道在 init 层进行绑定

:::

2.8.4.2 init层主要内容是什么？

init 层是以一个uuid+-init结尾表示，放在只读层(Lower)和读写层(upperdir)之间,作用只是存放 /etc/hosts、/etc/resolv.conf 等文件。

2.8.4.3 为什么需要init层？

1)容器在启动以后, 默认情况下lower层是不能够修改内容的, 但是用户有需求需要修改主机名与域名地址, 那么就需要添加init层中的文件(hostname, resolv.conf), 用于解决此类问题。

2) 修改的内容只对当前的容器生效，而在docker commit提交为镜像时候，并不会将init层提交。

3) init 文件存放的目录为/var/lib/docker/overlay2//diff

2.8.4.4 查看init层文件

hostname与resolv.conf 全部为空文件, 在系统启动以后由系统写入。

~ ls -l  /data/docker/overlay2/<LowerDir>-init/diff/etc/
total 0
-rwxr-xr-x 1 root root  0 Jun 28 21:15 hostname
-rwxr-xr-x 1 root root  0 Jun 28 21:15 hosts
lrwxrwxrwx 1 root root 12 Jun 28 21:15 mtab -> /proc/mounts
-rwxr-xr-x 1 root root  0 Jun 28 21:15 resolv.conf

2.8.5 总结

1） 镜像所挂载的目录层为 Lower 层，然后通过 Merged 展示所有的文件目录与文件。用户写入的所有文件都是在 UpperDir 目录，并且会在 UpperDir 建立于 Merged 层展示的文件目录结构, 所以用户就可以看到写入的文件。并且底层的镜像是不能被修改（如果挂载目录为 UpperDir，则可以修改源镜像）。

2） 在下次重新启动已经停止的容器的时候, 如果容器的 ID 没有发生改变， 那么所写入的文件是存在物理系统中的; 反之就会是一个新的容器，之前手工创建的文件是不存在的。

3） 基于容器创建的镜像，就相当于容器的快照, 可以删除原来的容器, 但是不能删除原来的镜像

4） 基于镜像创建的镜像，原来的镜像就是新镜像的 low 层 (build)， tag 则是没有区别

5） 容器启动以后，镜像就存在于容器的 lower 层，所有的写入都是在 upper

3 Docker 容器管理

3.1 创建容器常用选项

# 查看创建容器的帮助文档
docker run --help

命令格式：docker run [OPTIONS] IMAGE [COMMAND] [ARGS……]

# Step 1: 进入到容器的系统内部
# 启动一个Ubuntu容器，操作系统类容器需要有进程夯筑容器运行
$ docker run -it -d --name ubuntu-node ubuntu /bin/bash
$ docker exec -it ubuntu-node /bin/bash | docker attach ubuntu-node
# 查看容器的版本(ubuntu)
root@9650093ce0c2:/# cat /etc/os-release
NAME="Ubuntu"
VERSION="20.04.3 LTS (Focal Fossa)"
ID=ubuntu
ID_LIKE=debian
PRETTY_NAME="Ubuntu 20.04.3 LTS"
VERSION_ID="20.04"
HOME_URL="https://www.ubuntu.com/"
SUPPORT_URL="https://help.ubuntu.com/"
BUG_REPORT_URL="https://bugs.launchpad.net/ubuntu/"
PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
VERSION_CODENAME=focal
UBUNTU_CODENAME=focal
# 查看容器的进程
root@9650093ce0c2:/# ps
   PID TTY          TIME CMD
    27 pts/3    00:00:00 bash
    35 pts/3    00:00:00 ps
# Step 2: 启动Nginx容器，并暴露80端口映射到宿主机的8080端口
docker run -d --name nginx-node -p 8080:80 --restart=always nginx
sudo curl localhost:8080
# Step 3: 测试多个容器参数
$ docker run -it -d -e env=prod --name container-nginx \
                     -p 8088:80 --restart=always -h nginx-node nginx
# 查看最新创建的容器信息
$ docker ps -l
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS                                   NAMES
1dcbec1b129c   nginx     "/docker-entrypoint.…"   6 seconds ago   Up 5 seconds   0.0.0.0:8088->80/tcp, :::8088->80/tcp   container-nginx
$ sudo curl localhost:8088
# 进入到container-nginx容器中
$ docker exec -it container-nginx /bin/bash # docker container exec -it container-nginx /bin/bash
root@nginx-node:/# hostname
nginx-node
root@nginx-node:/# echo $env
prod
root@nginx-node:/# echo "Hello Nginx Container" > /usr/share/nginx/html/index.html
root@nginx-node:/# curl localhost
Hello Nginx Container
root@nginx-node:/# exit
# Step 4: 重启Docker服务后该容器会自动启动(--restart=always)
$ systemctl restart docker
$ docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS         PORTS                                   NAMES
1dcbec1b129c   nginx     "/docker-entrypoint.…"   4 minutes ago    Up 9 seconds   0.0.0.0:8088->80/tcp, :::8088->80/tcp   container-nginx
$ docker top container-nginx 
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                17541               17512               0                   02:52               ?                   00:00:00            nginx: master process nginx -g daemon off;
systemd+            17595               17541               0                   02:52               ?                   00:00:00            nginx: worker process
systemd+            17596               17541               0                   02:52               ?                   00:00:00            nginx: worker process
# Step 5: 查看容器的详细信息显示
$ docker inspect container-nginx
# Step 6: 查看容器的进程
$ docker run -itd --name centos-node1 centos:centos7.9.2009 /bin/bash
$ docker top centos-node1 
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                17393               17357               3                   02:51               ?                   00:00:00            /bin/bash

:::color1 Docker 容器需要用阻塞进程夯筑进程，使得Docker 容器持续运行！

:::

3.2 容器资源限制

默认创建的容器使用宿主机所有资源。

命令格式：docker run [OPTIONS] IMAGE [COMMAND] [ARGS……]

范例：创建容器资源限制

# -m="300m"  使用300M内存
# --cpus="1" 使用一颗CPU
$ docker run -it -d --name ubuntu-container -m="300m" --cpus="1" ubuntu /bin/bash
# 查看容器的资源
$ docker stats --no-stream ubuntu-container
CONTAINER ID   NAME               CPU %     MEM USAGE / LIMIT   MEM %     NET I/O     BLOCK I/O   PIDS
d74184890bae   ubuntu-container   0.00%     540KiB / 300MiB     0.18%     656B / 0B   0B / 0B     1

示例：

# 内存限额
# 允许容器最多使用500M内存和600M的Swarp，并且禁用OOM Killer
docker run -it -d --name nginx-limit1 --memory="500m" --memory-swap="600m" --oom-kill-disable nginx
# CPU限额
# 允许容器最多使用一个半的CPU
docker run -it -d --name nginx-cpu1 --cpus="1.5" nginx
# 允许容器最多使用50%的CPU
docker run -it -d --name nginx-cpu2 --cpus=".5" nginx

:::color1

:::

3.3 容器资源配额扩容

docker update # 在线更新容器配置
$ docker update --help
Usage:  docker update [OPTIONS] CONTAINER [CONTAINER...]
Update configuration of one or more containers
Options:
      --blkio-weight uint16        Block IO (relative weight), between 10 and 1000, or 0 to disable (default 0)
      --cpu-period int             Limit CPU CFS (Completely Fair Scheduler) period 限制CPU CFS(完全公平调度程序)周期
      --cpu-quota int              Limit CPU CFS (Completely Fair Scheduler) quota  限制CPU CFS(完全公平调度程序)配额
      --cpu-rt-period int          Limit the CPU real-time period in microseconds   将CPU实时周期限制在微秒内
      --cpu-rt-runtime int         Limit the CPU real-time runtime in microseconds  将CPU实时运行时限制在微秒内
  -c, --cpu-shares int             CPU shares (relative weight)                                            CPU份额(相对权重)
      --cpus decimal               Number of CPUs                                                                        cpu个数
      --cpuset-cpus string         CPUs in which to allow execution (0-3, 0,1)            允许执行的cpu (0- 3,0,1)
      --cpuset-mems string         MEMs in which to allow execution (0-3, 0,1)            允许执行(0- 3,0,1)的MEMs
      --kernel-memory bytes        Kernel memory limit                内核内存限制                                
  -m, --memory bytes               Memory limit                                内存限制
      --memory-reservation bytes   Memory soft limit                    内存软限制
      --memory-swap bytes          Swap limit equal to memory plus swap: '-1' to enable unlimited swap    交换限制等于内存加交换:'-1'以启用无限交换
      --pids-limit int             Tune container pids limit (set -1 for unlimited)    调优容器pid限制(设置-1表示无限制)
      --restart string             Restart policy to apply when a container exits

3.4 管理容器常用命令

命令格式：docker container COMMAND

范例：常用管理命令

# Step 1: 列出当前DockerHost容器
$ docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS          PORTS                                   NAMES
d74184890bae   ubuntu    "/bin/bash"              3 minutes ago    Up 3 minutes                                            ubuntu-container
1dcbec1b129c   nginx     "/docker-entrypoint.…"   14 minutes ago   Up 10 minutes   0.0.0.0:8088->80/tcp, :::8088->80/tcp   container-nginx
# 列出当前DockerHost所有容器
$ docker ps -a
# 列出最新创建的容器
$ docker ps -l
# Step 2: 查看容器的详细信息显示
$ docker inspect [Container_ID|Container_Name]
# Step 3: 进入到容器或者直接在DockerHost执行容器命令
$ docker exec -it ubuntu-container /bin/bash
$ docker exec ubuntu-container cat /etc/os-release
NAME="Ubuntu"
VERSION="20.04.3 LTS (Focal Fossa)"
ID=ubuntu
ID_LIKE=debian
PRETTY_NAME="Ubuntu 20.04.3 LTS"
VERSION_ID="20.04"
HOME_URL="https://www.ubuntu.com/"
SUPPORT_URL="https://help.ubuntu.com/"
BUG_REPORT_URL="https://bugs.launchpad.net/ubuntu/"
PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
VERSION_CODENAME=focal
UBUNTU_CODENAME=focal
# Step 4: 查看容器日志
docker logs container-nginx
# Step 5: 将容器提交成一个镜像
$ docker exec -it container-nginx /bin/bash
root@nginx-node:/# echo "Hello Nginx Container" > /usr/share/nginx/html/index.html
root@nginx-node:/# exit
$ docker commit -a "zhongzw <zhongzhiwei@kubesphere.com>" -m "修改nginx默认页面" container-nginx mynginx:1.1.0
$ docker images
REPOSITORY    TAG       IMAGE ID       CREATED          SIZE
mynginx       1.1.0     20cad473dbf9   13 seconds ago   141MB
$ docker image history mynginx:1.1.0
IMAGE          CREATED          CREATED BY                                      SIZE      COMMENT
20cad473dbf9   27 seconds ago   nginx -g daemon off;                            1.12kB    修改nginx默认页面
605c77e624dd   8 months ago     /bin/sh -c #(nop)  CMD ["nginx" "-g" "daemon…   0B
<missing>      8 months ago     /bin/sh -c #(nop)  STOPSIGNAL SIGQUIT           0B
<missing>      8 months ago     /bin/sh -c #(nop)  EXPOSE 80                    0B
<missing>      8 months ago     /bin/sh -c #(nop)  ENTRYPOINT ["/docker-entr…   0B
<missing>      8 months ago     /bin/sh -c #(nop) COPY file:09a214a3e07c919a…   4.61kB
<missing>      8 months ago     /bin/sh -c #(nop) COPY file:0fd5fca330dcd6a7…   1.04kB
<missing>      8 months ago     /bin/sh -c #(nop) COPY file:0b866ff3fc1ef5b0…   1.96kB
<missing>      8 months ago     /bin/sh -c #(nop) COPY file:65504f71f5855ca0…   1.2kB
<missing>      8 months ago     /bin/sh -c set -x     && addgroup --system -…   61.1MB
<missing>      8 months ago     /bin/sh -c #(nop)  ENV PKG_RELEASE=1~bullseye   0B
<missing>      8 months ago     /bin/sh -c #(nop)  ENV NJS_VERSION=0.7.1        0B
<missing>      8 months ago     /bin/sh -c #(nop)  ENV NGINX_VERSION=1.21.5     0B
<missing>      9 months ago     /bin/sh -c #(nop)  LABEL maintainer=NGINX Do…   0B
<missing>      9 months ago     /bin/sh -c #(nop)  CMD ["bash"]                 0B
<missing>      9 months ago     /bin/sh -c #(nop) ADD file:09675d11695f65c55…   80.4MB
# 将新镜像运行成容器
docker run -it -d --name mynginx-container --restart=always -p 8888:80 mynginx:1.1.0 
sudo curl localhost:8888
# Step 5: 容器与宿主机之间的文件拷贝
Usage:  docker cp [OPTIONS] CONTAINER:SRC_PATH DEST_PATH|-
        docker cp [OPTIONS] SRC_PATH|- CONTAINER:DEST_PATH
$ echo "hello docker" > docker.txt
$ docker cp docker.txt ubuntu-container:/tmp
$ docker exec ubuntu-container cat /tmp/docker.txt
hello docker
$ docker cp ubuntu-container:/etc/passwd /tmp
$ cat /tmp/passwd
# Step 7: 查看容器暴露的端口
$ docker port mynginx-container
80/tcp -> 0.0.0.0:8888
80/tcp -> :::8888
# Step 8: 容器运行的进程
$ docker top mynginx-container
# Step 9: 查看容器的资源利用率
$ docker stats mynginx-container
$ docker stats --no-stream mynginx-container
# Step 10: 删除容器
$ docker rm -f mynginx-container
# 只查看容器的ID
$ docker ps -q
# 删除所有容器(-f 强制删除；-a 全部容器)
$ docker rm -f $(docker ps -qa)
# Step 11: 移除已经停止的容器
$ docker container prune
# 容器名称是不能重复的

3.5 容器实现核心技术: Namespace

在容器化中，一台物理计算机可以运行多个不同操作系统，那就需要解决”隔离性”，彼此感知不到对方存在，有问题互不影响。

CGroups主要功能：

• 限制进程组使用的资源数量 ( Resource limitation ) : 可以为进程组设定资源使用上限，例如内存
• 进程组优先级控制( Prioritization ) : 可以为进程组分配特定CPU、磁盘IO吞吐量
• 记录进程组使用的资源数量 ( Accounting ) : 例如使用记录某个进程组使用的CPU时间
• 进程组控制 ( Control ) : 可以将进程组挂起和恢复

ls /sys/fs/cgroup/ -l查看cgroups可控制的资源：

• blkio : 对快设备的IO进行限制。
• cpu : 限制CPU时间片的分配，与cpuacct挂载同一目录。
• cpuacct : 生成cgroup中的任务占用CPU资源的报告，与cpu挂载同一目录。
• cpuset : 给cgroup中的任务分配独立的CPU(多核处理器）和内存节点。
• devices : 允许或者拒绝cgroup 中的任务访问设备。
• freezer : 暂停/恢复cgroup 中的任务。
• hugetlb : 限制使用的内存页数量。
• memory : 对cgroup中任务的可用内存进行限制，并自动生成资源占用报告。
• net cls : 使用等级识别符(classid)标记网络数据包，这让 Linux流量控制程序(tc)可以识别来自特定从cgroup任务的数据包，并进行网络限制。
• net_prio : 允许基于cgroup设置网络流量的优先级。
• perf_event : 允许使用perf工具来监控cgroup。
• pids:限制任务的数量。

容器实际资源限制位置：

/sys/fs/cgroup/<资源名>/docker/<容器ID>

3.7 Docker核心组件之间关系

Docker Daemon：Docker守护进程，负责与Docker Clinet交互，并管理镜像、容器。

Containerd：是一个简单的守护进程[ 为了兼容OCI标准 ]，向上给Docker Daemon提供接口，向下通过containerd-shim结合runC管理容器。

runC：一个命令行工具，它根据OCI标准来创建和运行容器[ 由lib-Container剥离出来 ]。

总结：

:::color1 Namespace

命名空间，Linux内核提供的一种对进程资源隔离的机制，例如进程、网络、挂载点等资源。

CGroups

控制组，Linux内核提供的一种对进程组限制资源的机制;例如CPU、内存等资源。

UnionFS

联合文件系统，支持将不同位置的目录挂载到同一虚拟文件系统，形成一种分层的模型。

:::

4 Docker 容器数据持久化

4.1 将数据从宿主机挂载到容器中的三种方式

Docker提供三种方式将数据从宿主机挂载到容器中：

• volumes：Docker管理宿主机文件系统的一部分（/var/lib/docker/volumes）。保存数据的最佳方式。
• bind mounts：将宿主机上的任意位置的文件或者目录挂载到容器中。
• tmpfs：挂载存储在主机系统的内存中，而不会写入主机的文件系统。如果不希望将数据持久存储在任何位置，可以使用tmpfs，同时避免写入容器可写层提高性能。[ 使用场景很少 ]

4.2 Volume

管理卷:

$ docker volume create nginx-vol
$ docker volume ls
$ docker volume inspect nginx-vol
[
    {
        "CreatedAt": "2022-11-30T14:16:36+08:00",
        "Driver": "local",
        "Labels": {},
        "Mountpoint": "/var/lib/docker/volumes/nginx-vol/_data",
        "Name": "nginx-vol",
        "Options": {},
        "Scope": "local"
    }
]

用卷创建一个容器:

$ docker run -d --name=nginx-test --mount src=nginx-vol,dst=/usr/share/nginx/html nginx
$ docker run -d --name=nginx-test -v nginx-vol:/usr/share/nginx/html nginx
# 使用匿名卷
$ docker run -d --name nginx-volume -v /usr/share/nginx/html/ nginx

清理:

$ docker stop nginx-test
$ docker rm nginx-test
$ docker volume rm nginx-vol

注意:

1. 如果没有指定卷，自动创建。

4.3 Bind Mounts

用卷创建一个容器:

$ docker run -d --name=nginx-test --mount type=bind,src=/app/wwwroot,dst=/usr/share/nginx/html nginx
$ docker run -d --name=nginx-test -v /app/wwwroot:/usr/share/nginx/html nginx

验证绑定:

$ docker inspect nginx-test

清理:

$ docker stop nginx-test
$ docker rm nginx-test

注意:

1. 如果源文件/目录没有存在如果挂载目标在容器中非空目录，则该目录现有内容将被隐藏。
2. 不会自动创建，会抛出一个错误。[ 新版的Docker会自动创建 ]

5 Docker 容器网络

5.1 四种网络模式

• bridge

—net=bridge

默认网络，Docker启动后创建一个docker0网桥，默认创建的容器也是添加到这个网桥中。也可以自定义网络，相比默认的具备内部DNS发现，可以通过容器名容器之间网络通信。

• host

—net=host

容器不会获得一个独立的network namespace，而是与宿主机共用一个。这就意味着容器不会有自己的网卡信息，而是使用宿主机的。容器除了网络，其他都是隔离的。

• none

—net=none

获取独立的network namespace，但不为容器进行任何网络配置，需要我们手动配置。

• container

—net=container:Name/ID

与指定的容器使用同一个network namespace，具有同样的网络配置信息，两个容器除了网络，其他都还是隔离的。

$ yum install -y bridge-utils
$ brctl show
bridge name     bridge id               STP enabled     interfaces
docker0         8000.0242c776c496       no              vethfff7deb
$ docker ps
CONTAINER ID   IMAGE                   COMMAND       CREATED       STATUS       PORTS     NAMES
4c85101b19d3   centos:centos7.9.2009   "/bin/bash"   6 hours ago   Up 6 hours             centos-node1
# 创建Docker测试网络
$ docker network create test_network
# 使用该测试网络创建容器
$ docker run -it -d --name nginx-node1 --network test_network nginx
$ docker inspect -f "{{.NetworkSettings.Networks.test_network.IPAddress}}" nginx-node1
172.18.0.2
# 默认使用bridge网络(IP地址可以通信，不能使用主机名通信)
$ docker run -it -d --name busybox-node1 --hostname busybox-node1 busybox
$ docker run -it -d --name busybox-node2 --hostname busybox-node2 busybox
$ docker exec -it busybox-node1 ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue 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
22: eth0@if23: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue
    link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff
    inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
       valid_lft forever preferred_lft forever
$ docker exec -it busybox-node2 ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue 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
24: eth0@if25: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue
    link/ether 02:42:ac:11:00:03 brd ff:ff:ff:ff:ff:ff
    inet 172.17.0.3/16 brd 172.17.255.255 scope global eth0
       valid_lft forever preferred_lft forever
# IP地址可以通信，主机名无法通信
$ docker exec -it busybox-node1 ping -c 1 -W 1 172.17.0.3
PING 172.17.0.3 (172.17.0.3): 56 data bytes
64 bytes from 172.17.0.3: seq=0 ttl=64 time=0.300 ms
--- 172.17.0.3 ping statistics ---
1 packets transmitted, 1 packets received, 0% packet loss
$ docker exec -it busybox-node1 ping -c 1 -W 1 busybox-node2
ping: bad address 'busybox-node2'
# 使用自定义网络(桥接)内部会有DNS解析，做了IP地址和主机名的绑定关系

范例：自定义网络

$ docker run -it -d --name busybox-node-test1 --hostname busybox-node-test1 --network test_network busybox
$ docker run -it -d --name busybox-node-test2 --hostname busybox-node-test2 --network test_network busybox
$ docker exec -it busybox-node-test1 ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue 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
26: eth0@if27: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue
    link/ether 02:42:ac:12:00:03 brd ff:ff:ff:ff:ff:ff
    inet 172.18.0.3/16 brd 172.18.255.255 scope global eth0
       valid_lft forever preferred_lft forever
$ docker exec -it busybox-node-test2 ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue 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
28: eth0@if29: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue
    link/ether 02:42:ac:12:00:04 brd ff:ff:ff:ff:ff:ff
    inet 172.18.0.4/16 brd 172.18.255.255 scope global eth0
       valid_lft forever preferred_lft forever
$ docker exec -it busybox-node-test2 ping -c 1 -W 1 172.18.0.4
PING 172.18.0.4 (172.18.0.4): 56 data bytes
64 bytes from 172.18.0.4: seq=0 ttl=64 time=0.132 ms
--- 172.18.0.4 ping statistics ---
1 packets transmitted, 1 packets received, 0% packet loss
round-trip min/avg/max = 0.132/0.132/0.132 ms
$ docker exec -it busybox-node-test2 ping -c 1 -W 1 busybox-node-test2
PING busybox-node-test2 (172.18.0.4): 56 data bytes
64 bytes from 172.18.0.4: seq=0 ttl=64 time=0.104 ms
--- busybox-node-test2 ping statistics ---
1 packets transmitted, 1 packets received, 0% packet loss
round-trip min/avg/max = 0.104/0.104/0.104 ms

范例：使用 host 网络模式

$ docker run -it --network host --name busybox-host --hostname busybox-host busybox
# 共享宿主机的网络命名空间
/ # ifconfig
docker0   Link encap:Ethernet  HWaddr 02:42:C7:76:C4:96
          inet addr:172.17.0.1  Bcast:172.17.255.255  Mask:255.255.0.0
          inet6 addr: fe80::42:c7ff:fe76:c496/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:9 errors:0 dropped:0 overruns:0 frame:0
          TX packets:17 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0
          RX bytes:516 (516.0 B)  TX bytes:2016 (1.9 KiB)
eth0      Link encap:Ethernet  HWaddr 00:0C:29:0F:DD:0C
          inet addr:10.0.0.100  Bcast:10.0.0.255  Mask:255.255.255.0
          inet6 addr: fe80::20c:29ff:fe0f:dd0c/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:119699 errors:0 dropped:0 overruns:0 frame:0
          TX packets:46469 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:161358423 (153.8 MiB)  TX bytes:3476608 (3.3 MiB)
lo        Link encap:Local Loopback
          inet addr:127.0.0.1  Mask:255.0.0.0
          inet6 addr: ::1/128 Scope:Host
          UP LOOPBACK RUNNING  MTU:65536  Metric:1
          RX packets:995 errors:0 dropped:0 overruns:0 frame:0
          TX packets:995 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:91025 (88.8 KiB)  TX bytes:91025 (88.8 KiB)
# ...省略部分输出...

范例：使用 Container 网络

$ docker run -it --network container:busybox-node1 -d --name busybox-container1 busybox
$ docker exec busybox-node1 ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue 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
22: eth0@if23: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue
    link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff
    inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
       valid_lft forever preferred_lft forever
$ docker exec -it busybox-container1 ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue 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
22: eth0@if23: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue
    link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff
    inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
       valid_lft forever preferred_lft forever
# 这是Kubernetes Pod最小调度单位默认的网络模式

范例：none 网络模式

$ docker run -it --name busybox-none --network none --hostname busybox-none busybox /bin/sh
/ # ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue 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

:::color1 应用场景：

bridge ：Docker 默认桥接网络

host ：希望使用宿主机网络

none ：手动配置容器网络，对接公司的IPAM

container ：希望容器与另一个容器在一个网络命名空间，LNMP

:::

5.2 Docker网络模型容器

veth pair：成对出现的一种虚拟网络设备，数据从一端进，从另一端出。用于解决网络命名空间之间隔离。

docker0：网桥是一个二层网络设备，通过网桥可以将Linux支持的不同的端口连接起来，并实现类似交换机那样的多对多的通信。

5.3 网络访问原理

# docker 启动后会产生一个 docker0 的桥接设备
# docker0 可以理解为是一个交换机，是将容器接入到交换机中，实现容器与容器之间的通信
# 并且可以将数据包传递到宿主机处理。
$ ifconfig docker0
docker0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 172.17.0.1  netmask 255.255.0.0  broadcast 172.17.255.255
        inet6 fe80::42:45ff:fe1c:2b38  prefixlen 64  scopeid 0x20<link>
        ether 02:42:45:1c:2b:38  txqueuelen 0  (Ethernet)
        RX packets 32  bytes 3436 (3.3 KiB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 47  bytes 3446 (3.3 KiB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

Docker 使用 iptables 实现网络通信

1. 外部访问容器：

iptables -t nat -vnL DOCKER

1. 容器访问外部：

iptables -t nat -vnL POSTROUTING

$ docker run -it -d --name busybox-node busybox 
$ docker exec -it busybox-node /bin/sh
# 可以访问外网
/ # ping -c 1 -W 1 www.baidu.com
PING www.baidu.com (183.232.231.174): 56 data bytes
64 bytes from 183.232.231.174: seq=0 ttl=127 time=15.140 ms
--- www.baidu.com ping statistics ---
1 packets transmitted, 1 packets received, 0% packet loss
round-trip min/avg/max = 15.140/15.140/15.140 ms
# 查看网卡信息
/ # ifconfig
eth0      Link encap:Ethernet  HWaddr 02:42:AC:11:00:04
          inet addr:172.17.0.4  Bcast:172.17.255.255  Mask:255.255.0.0
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:13 errors:0 dropped:0 overruns:0 frame:0
          TX packets:5 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0
          RX bytes:1100 (1.0 KiB)  TX bytes:328 (328.0 B)
lo        Link encap:Local Loopback
          inet addr:127.0.0.1  Mask:255.0.0.0
          UP LOOPBACK RUNNING  MTU:65536  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:0 (0.0 B)  TX bytes:0 (0.0 B)
# 查看容器路由表
/ # route -n
Kernel IP routing table
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
0.0.0.0         172.17.0.1      0.0.0.0         UG    0      0        0 eth0
172.17.0.0      0.0.0.0         255.255.0.0     U     0      0        0 eth0
# 查看宿主机容器进程
$ docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS          PORTS                               NAMES
8d12c3faadd3   busybox   "sh"                     8 minutes ago    Up 8 minutes                                        busybox-node
ec4e0869e87a   nginx     "/docker-entrypoint.…"   32 minutes ago   Up 32 minutes   0.0.0.0:88->80/tcp, :::88->80/tcp   web01
# 可以判断到容器的下一跳就是docker0网桥设备，并且将数据包丢到docker0
# docker0 设备将数据包转发到宿主机，# 例如容器ping百度，源IP：容器IP，目的IP：百度IP
# 宿主机会查找路由表
$ route -n
Kernel IP routing table
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
0.0.0.0         10.0.0.2        0.0.0.0         UG    100    0        0 eth0
10.0.0.0        0.0.0.0         255.255.255.0   U     100    0        0 eth0
172.17.0.0      0.0.0.0         255.255.0.0     U     0      0        0 docker0
# 容器访问外部(iptables-SNAT)
$ iptables -t nat -vnL POSTROUTING
Chain POSTROUTING (policy ACCEPT 0 packets, 0 bytes)
 pkts bytes target     prot opt in     out     source               destination    
    3   202 MASQUERADE  all  --  *      !docker0  172.17.0.0/16        0.0.0.0/0   # SNAT策略
    0     0 MASQUERADE  tcp  --  *      *       172.17.0.2           172.17.0.2           tcp dpt:80
# 经过iptables的策略，将数据包的源IP改成为宿主机的IP发送出去
# 经过宿主机的网关，发送到互联网中

5.4 容器网络实现核心技术：lptables

5.4.1 四表五链

:::color1 netfilter：IP包过滤；iptables：用户态工具

:::

5.4.2 操作命令

:::color1 Linux IP信息包过滤原理

:::

Docker 主要通过 <font style="color:#DF2A3F;">netfilter/iptables</font> 实现网络通信。

iptables由netfilter和iptables组成，netfilter组件是Linux内核集成的信息包过滤系统，它维护一个信息包过滤表，这个表用于控制信息包过滤处理的规则集。而iptables只是一个在用户空间的工具，用于增删改查这个过滤表的规则。发送方对数据进行TCP/IP封装，接收方则对数据进行TCP/IP的解封装。

参考文献：[ https://blog.csdn.net/weixin_45186298/article/details/122910466 ]

四表五链功能性介绍

iptables是（4张）表的集合：filter、nat、mangle、raw

表是（5条）链的集合：PREROUTING、INPUT、OUTPUT、FORWARD、POSTROUTING

1. INPUT

:::warning 客户端发起连接到Apache服务器的时候，数据报文到服务器的网卡处，首先判断 Router Table 的路由表信息，判断该用户的请求是不是本机的，如果不是则丢弃；如果是本机就会交给 netfilter 进行下一步处理。netfilter 会寻找匹配相应的规则，例如：如果目标端口是80的话，就允许放行，这样用户的数据报文就可以到 Http 应用进行处理并得到响应数据报文。

即 INPUT （入站）链。iptables 的规则就是写在 链上的。可以理解为所有入站的数据报文都要经过 iptables 的 INPUT 链，才能到达上层的用户空间。这就要看 INPUT 链的规则是如何编写的，需要匹配规则，如果是放行就放行，如果是拒绝就是拒绝。

:::

1. OUTPUT

:::warning 当用户在服务器上操作时，执行 curl 命令请求到 WebServer 的时候，数据报文会向到 netfilter 进行处理，netfilter 将数据报文先后转发到服务器的网卡处，通过 Router Table 路由表中进行转发到 WebServer 进行处理。则 netfilter 的 OUTPUT 链就是用来处理出站的规则匹配。

OUTPUT （出站）链的主要功能就是对机器出去的数据报文进行对应的过滤操作。

:::

1. FORWORD

:::info 将Linux服务器充当是路由器。并且Linux 服务器开启 net.ipv4.ip_forward = 1 路由转发功能，当 Client 客户端发起请求到目标地址是 WebServer，Client 发送的数据包会到路由器（Linux服务器）eth0网卡，因为开启了路由转发功能，所以会将数据包转发到 eth1网卡。只要涉及到转发，那么就会经过 netfilter 的 FORWORD 链。

FORWORD （转发）链的主要功能就是处理机器的转发数据报文进行规则匹配。

:::

1. PREROUTING

:::info PREROUTING 链在还没有路由表判断之前就对数据报文进行对应的修改。

PREROUTING （路由前）链翻译过来就是路由表之前对数据报文处理的一个接口

:::

1. POSTROUTING

:::info POSTROUTING 是先经过路由表判断之后，才到POSTROUTING 进行下一步的处理。

POSTROUTING （路由后）链翻译过来就是路由表之后对数据报文处理的一个接口

:::

:::info 链的作用是承载防火墙的规则，链则是存放在表中。

:::

规则链：承载防火墙规则

处理入站数据包：INPUT

处理出站数据包：OUTPUT

处理转发数据包：FORWARD

在进行路由选择前应用规则（处理数据包）：修改目标地址 PREROUTING

在进行路由选择后应用规则（处理数据包）：修改源地址 POSTROUTING

规则表：承载防火墙链

raw 表：确定是否对该数据包进行状态跟踪

• 一旦我们的数据包经过防火墙以后，正常情况下会对数据包进行跟踪，跟踪会消耗资源。可以通过 raw 表将这些数据包进行跳出，不进行状态跟踪。

mangle 表：为数据包设置标记，例如：TTL MARK

• 可以在数据包打上固定标签的 mangle 表

• 功能可以有端口映射，SNAT，DNAT

• 基础类防火墙最主要的表，会对数据包进行过滤

:::info 主要的是 nat 表和 filter 表，raw 表和mangle 表的使用较少。

:::

防火墙链表结构

不同表下面拥有的链也是不同的。只要知道要做的防火墙规则是怎么样的，只需要匹配对应的功能，再来选择对应的入站和出站。这样就知道 netfilter 的规则是写在哪张表的哪条链上。（红色标记是重点），例如在NAT表中的PREROUTING 链和 POSTROUTING 链是各自实现SNAT和DNAT的功能。

:::color1 容器访问外部，外部访问容器

:::

# 9443 端口是 HTTPS
# --restart=always 在Docker重启服务之后会自动启动
$ docker run -d -p 8000:8000 -p 9000:9000 -p 9443:9443 --name portainer \
         --restart=always \
         -v /var/run/docker.sock:/var/run/docker.sock \
         -v portainer_data:/data \
         portainer/portainer
$ docker ps 
CONTAINER ID   IMAGE                 COMMAND                  CREATED       STATUS        PORTS                                                                                                                             NAMES
5f0ef6e5cb9d   portainer/portainer   "/portainer"             7 days ago    Up 10 hours   0.0.0.0:8000->8000/tcp, :::8000->8000/tcp, 0.0.0.0:9000->9000/tcp, :::9000->9000/tcp, 0.0.0.0:9443->9443/tcp, :::9443->9443/tcp   portainer
$ docker port portainer
8000/tcp -> 0.0.0.0:8000
8000/tcp -> :::8000
9000/tcp -> 0.0.0.0:9000
9000/tcp -> :::9000
9443/tcp -> 0.0.0.0:9443
9443/tcp -> :::9443
$ iptables -vnL -t nat
# 容器访问外部
Chain POSTROUTING (policy ACCEPT 767 packets, 50988 bytes)
 pkts bytes target     prot opt in     out     source               destination         
    0     0 MASQUERADE  tcp  --  *      *       172.17.0.2           172.17.0.2           tcp dpt:9443
    0     0 MASQUERADE  tcp  --  *      *       172.17.0.2           172.17.0.2           tcp dpt:9000
    0     0 MASQUERADE  tcp  --  *      *       172.17.0.2           172.17.0.2           tcp dpt:8000
# 外部访问容器
Chain DOCKER (2 references)
 pkts bytes target     prot opt in     out     source               destination         
    5   204 DNAT       tcp  --  !docker0 *       0.0.0.0/0            0.0.0.0/0            tcp dpt:9443 to:172.17.0.2:9443
   56  2988 DNAT       tcp  --  !docker0 *       0.0.0.0/0            0.0.0.0/0            tcp dpt:9000 to:172.17.0.2:9000
   14   688 DNAT       tcp  --  !docker0 *       0.0.0.0/0            0.0.0.0/0            tcp dpt:8000 to:172.17.0.2:8000
# 可以访问 Portainer 的页面
# ● 第一次登录需创建admin，访问地址：IP地址:9000 <http://IP:9000/#/init/admin> 
# ●  设置admin用户和密码后首次登录