5.Docker底层实现原理了解

$docker pull lorel/docker-stress-ng
lorel/docker-stress-ng   latest              1ae56ccafe55        3 years ago         8.1MB

$docker run --name stress -it --rm lorel/docker-stress-ng:latest stress -help #查看镜像压力测试帮助
Example: stress-ng --cpu 8 --io 4 --vm 2 --vm-bytes 128M --fork 4 --timeout 10s

#演示1.限制虚拟内最大不能藏256MB
[root@izwz9biz2m4sd3bb3k38pgz ~]# docker run --name stress -it -m 256m --rm lorel/docker-stress-ng:latest stress --vm 2

$docker stats  
CONTAINER ID        NAME                CPU %               MEM USAGE / LIMIT  MEM %               NET I/O             BLOCK I/O           PIDS
36a41704053f        stress              98.57%              140MiB / 256MiB (关键点)    54.69%              0B / 0B             0B / 0B             5

#测试cpu的性能：
$docker run --name stress -it -m 256m --rm lorel/docker-stress-ng:latest stress --cpu 8 --io 4             #使用全部CPU占100%
$docker run --name stress --cpus 0.5 -it -m 256m --rm lorel/docker-stress-ng:latest stress --cpu 8 --io 4  #使用半个CPU 不超过50% 上下误差+/-5
$docker run --name stress --cpuset-cpus 0 -it --rm lorel/docker-stress-ng:latest stress --cpu 8   #使用第
CONTAINER ID        NAME                CPU %               MEM USAGE / LIMIT   MEM %               NET I/O             BLOCK I/O           PIDS
6d6cc81d6e26        stress              50.99%              15.93MiB / 256MiB   6.22%               0B / 0B             0B / 143kB          13

$ls -l /proc/$$/ns
总用量 0
lrwxrwxrwx. 1 root root 0 7月   4 23:27 ipc -> ipc:[4026531839]
lrwxrwxrwx. 1 root root 0 7月   4 23:27 mnt -> mnt:[4026531840]
lrwxrwxrwx. 1 root root 0 7月   4 23:27 net -> net:[4026531956]
lrwxrwxrwx. 1 root root 0 7月   4 23:27 pid -> pid:[4026531836]
lrwxrwxrwx. 1 root root 0 7月   4 23:27 user -> user:[4026531837]
lrwxrwxrwx. 1 root root 0 7月   4 23:27 uts -> uts:[4026531838]

# 1.创建一个文件夹，使用tmpfs这种基于内存的文件系统来模拟挂载
mkdir /tmp/mnt_isolation
# 2.使用unshare(内置命令做作用是不启动一个新进程就可以起到隔离效果，相当于跳出原先的namespace)隔离mnt namespace
unshare --mount /bin/bash
# 3.挂载我们的tmpfs
mount -t tmpfs tmpfs /tmp/mnt_isolation
# 4.然后进入/tmp/mnt_isolation创建文件
cd /tmp/mnt_isolation && touch linux-mnt-{1..10}
# 5.新建立一个shell终端发现并没有创建文件；
[root@localhost mnt_isolation]$ ls #终端1
linux-mnt-1   linux-mnt-2  linux-mnt-4  linux-mnt-6  linux-mnt-8
linux-mnt-10  linux-mnt-3  linux-mnt-5  linux-mnt-7  linux-mnt-9

[root@localhost mnt_isolation]$ ls /tmp/mnt_isolation/ #终端2
#输出为空

# 1.创建一个消息队列
$ ipcmk --queue
消息队列 id：0

# 2.查看创建的消息队列
$ ipcs
# --------- 消息队列 -----------
# 键        msqid      拥有者  权限     已用字节数 消息
# 0x651dbb47 0          root       644        0            0
# ------------ 共享内存段 --------------
# 键        shmid      拥有者  权限     字节     nattch     状态

# --------- 信号量数组 -----------
# 键        semid      拥有者  权限     nsems

# 3.使用unshare命令进行隔离IPC namespace
$echo $$
78285
$unshare --ipc /bin/bash  
$echo $$  #此时已经切换到新的进程
78468
$ps aux | grep -E "78468|78285"
root      78285  0.0  0.1 117460  3980 pts/1    Ss   00:01   0:00 -bash
root      78468  0.0  0.1 117408  3956 pts/1    S    00:04   0:00 /bin/bash

# 4.再次查看消息队列发现为空，所以证实了在隔离的Namespace中创建的内容外部无法看到
ipcs
# --------- 消息队列 -----------
# 键        msqid      拥有者  权限     已用字节数 消息
# ------------ 共享内存段 --------------
# 键        shmid      拥有者  权限     字节     nattch     状态
# --------- 信号量数组 -----------
# 键        semid      拥有者  权限     nsems

# 3.10.0-1062.18.1.el7.x86_64
grep cgroup /proc/mounts | awk -F " " '{print $2 " = " $4}'
/sys/fs/cgroup = ro,seclabel,nosuid,nodev,noexec,mode=755
/sys/fs/cgroup/systemd = rw,seclabel,nosuid,nodev,noexec,relatime,xattr,release_agent=/usr/lib/systemd/systemd-cgroups-agent,name=systemd
/sys/fs/cgroup/freezer = rw,seclabel,nosuid,nodev,noexec,relatime,freezer
/sys/fs/cgroup/net_cls,net_prio = rw,seclabel,nosuid,nodev,noexec,relatime,net_prio,net_cls
/sys/fs/cgroup/cpu,cpuacct = rw,seclabel,nosuid,nodev,noexec,relatime,cpuacct,cpu
/sys/fs/cgroup/cpuset = rw,seclabel,nosuid,nodev,noexec,relatime,cpuset
/sys/fs/cgroup/perf_event = rw,seclabel,nosuid,nodev,noexec,relatime,perf_event
/sys/fs/cgroup/hugetlb = rw,seclabel,nosuid,nodev,noexec,relatime,hugetlb
/sys/fs/cgroup/pids = rw,seclabel,nosuid,nodev,noexec,relatime,pids
/sys/fs/cgroup/memory = rw,seclabel,nosuid,nodev,noexec,relatime,memory
/sys/fs/cgroup/blkio = rw,seclabel,nosuid,nodev,noexec,relatime,blkio
/sys/fs/cgroup/devices = rw,seclabel,nosuid,nodev,noexec,relatime,devices

# 5.7.0-1.el7.elrepo.x86_64
grep cgroup /proc/mounts | awk -F " " '{print $2 " = " $4}'
/sys/fs/cgroup = ro,nosuid,nodev,noexec,mode=755
/sys/fs/cgroup/systemd = rw,nosuid,nodev,noexec,relatime,xattr,release_agent=/usr/lib/systemd/systemd-cgroups-agent,name=systemd
/sys/fs/cgroup/cpu,cpuacct = rw,nosuid,nodev,noexec,relatime,cpu,cpuacct
/sys/fs/cgroup/memory = rw,nosuid,nodev,noexec,relatime,memory
/sys/fs/cgroup/devices = rw,nosuid,nodev,noexec,relatime,devices  #主机设备读写节点创建控制
/sys/fs/cgroup/blkio = rw,nosuid,nodev,noexec,relatime,blkio
/sys/fs/cgroup/net_cls,net_prio = rw,nosuid,nodev,noexec,relatime,net_cls,net_prio
/sys/fs/cgroup/freezer = rw,nosuid,nodev,noexec,relatime,freezer
/sys/fs/cgroup/rdma = rw,nosuid,nodev,noexec,relatime,rdma  # 内核新增
/sys/fs/cgroup/hugetlb = rw,nosuid,nodev,noexec,relatime,hugetlb
/sys/fs/cgroup/perf_event = rw,nosuid,nodev,noexec,relatime,perf_event
/sys/fs/cgroup/cpuset = rw,nosuid,nodev,noexec,relatime,cpuset
/sys/fs/cgroup/pids = rw,nosuid,nodev,noexec,relatime,pids

# 挂载cpu子系统到 /sys/fs/cgroup/cpu
mount -t cgroup -o cpu cpu /sys/fs/cgroup/cpu

# 查看
cgroup on /sys/fs/cgroup/cpuset type cgroup (rw,nosuid,nodev,noexec,relatime,seclabel,cpuset)

#示例1.分配和限制内存和CPU使用
docker run -itd --cpus="1.5" --cpuset-cpus="0-1" --cpuset-mems="0" busybox sleep 6000  #常规分配指定cpu节点
docker run -itd --memory 512m --memory-swap 1g busybox sleep 6000     #分配指定内存 -m.--memory 512m

#示例2.为容器添加一个主机设备
docker run -itd --name=demo --device=/dev/sda3 busybox sleep 6000
docker exec -it demo ls /dev/sda3

#实例3.CPU调度与资源限制
docker run -itd calico/cni -c 512 --cpuset-cpus="0"   # -c cpu权重 
docker run -itd busybox -c 1024 --cpuset-cpus="1,2"   # 让一个cgroup使用cpu的1/3,同时另外一个cgroup使用该cpu的2/3(根据cgroup组来划分)
docker run -itd calico/cni --memory 512m --memory-swap 1g --cpu-period=1000000 --cpu-quota=950000 # docker 1.12 及其之前版本
docker run -itd calico/cni --memory 512m --memory-swap 1g --cpu-rt-runtime 950000               # 完全公平调度 CFS scheduler

# 全局
cat /sys/fs/cgroup/devices/devices.list
# a *:* rwm

# docker 应用全局
cat /sys/fs/cgroup/devices/docker/devices.list
# a *:* rwm
ls -l /sys/fs/cgroup/devices/devices.allow
--w-------. 1 root root 0 6月  15 09:46 /sys/fs/cgroup/devices/devices.allow
ls -l /sys/fs/cgroup/devices/devices.deny
--w-------. 1 root root 0 6月  15 09:46 /sys/fs/cgroup/devices/devices.deny

# docker 容器设置
$docker ps
25d2d645bfc9        test1               "top -b -d 2"       2 weeks ago   
cat /sys/fs/cgroup/devices/docker/25d2d645bfc9e6530039d6aac890f69dd9af33f8f966adc2d7287b74964678e3/devices.list
c 1:5 rwm
c 1:3 rwm
c 1:9 rwm
c 1:8 rwm #brw-rw----. 1 root disk 8, 0 6月  15 09:46 /dev/sda
c 5:0 rwm
c 5:1 rwm
c *:* m
b *:* m
c 1:7 rwm #lrwxrwxrwx. 1 root root 7 6月  15 09:46 /dev/mapper/centos-app -> ../dm-2
c 136:* rwm
c 5:2 rwm
c 10:200 rwm

# 手动创建Devices
mkdir /sys/fs/cgroup/devices/testgroup #创建一个控制组
ls /sys/fs/cgroup/devices/testgroup  #默认情况下创建的控制组可以访问全部设备
# cgroup.clone_children  cgroup.procs   devices.deny  notify_on_release
# cgroup.event_control   devices.allow  devices.list  tasks
cat devices.list
# a *:* rwm
echo  'c 1:3 rwm' > /sys/fs/cgroup/devices/testgroup/devices.deny #对testgroup组禁止字符设备/dev/null 读写以及创建节点
echo $$ > /sys/fs/cgroup/devices/testgroup/tasks #将当前进程号加入任务中
echo "hello world" > /dev/null  #由于组设置了对字符设备/dev/null进行写限制，所以下面写请求失败
# -bash: /dev/null: 不允许的操作

# $$ 表示当前bash进程的PID等价于$BASHPID
cat /sys/fs/cgroup/devices/testgroup/tasks
# 123453
echo $BASHPID
# 123453

#示例演示
a *:* rwm #表示所有设备都可以访问
c 1:3 r   #表示字符设备只有一个读权限

#(1) 创建一个控制组
mkdir /sys/fs/cgroup/cpuset/testgroup
#(2) 限制控制组只能使用内存节点0和cpu0与cpu1(与您cpu核心数有关 `grep "processor" /proc/cpuinfo`)
echo 0 > /sys/fs/cgroup/cpuset/testgroup/cpuset.mems
echo 0,1 > /sys/fs/cgroup/cpuset/testgroup/cpuset.cpus
#(3) 同样将当前进程加入控制组中
echo $$ > /sys/fs/cgroup/cpuset/testgroup/tasks
#(4) 验证配置结果
cat /proc/$$/status | grep "_allowed_list"
Cpus_allowed_list:      0-1
Mems_allowed_list:      0

- cpu.shares: 资源组的CPU使用权重它不限制进程使用绝对的CPU而是控制各组之间的配额,默认情况下Docker容器中cpu shares权重都为1024;
echo 512 > /sys/fs/cgroup/cpu/testgroup/cpu.shares
echo 1024 > /sys/fs/cgroup/cpu/testgroup1/cpu.shares

- cpu.cfs_period_us: 完全公平调度策略，用于统计CPU使用的时间周期（时间片份数）它可以设定重新分配cgroup的可用CPU资源的时间间隔，单位为微秒us(值范围:1000us~1s);
- cpu.cfs_quota_us: 完全公平调度策略，用于某周期内占用CPU的时间(指单核的时间，多核着需要设置时累加)，此参数设定基于时间片份数某个cgroup中所有任务可运行的时间总量,单位为微秒us(默认值为-1);
#比如:cpu.cfs_period_us设置为1000000而cpu.cfs_quota_us设置为200000表示cgroup控制的任务中在每1秒钟的0.2秒可单独对CPU进行存取;
#比如:cpu.cfs_quota_us设置成为-1则表示cgroup不需要遵循任何CPU时间限制，这也是每个cgroup的默认值；
简单来说:在CFS调度下period设置为1s并且quota设置为0.5s，那么在cgroup进程中最多可以运行0.5s然后被强制休眠只能等待下一秒才能继续运行;
#示例:假设CPU>=4核心表示这个组在一个使用周期(1s)内可以跑满4核资源；
echo 1000000 > /sys/fs/cgroup/cpu/testgroup/cpu.cfs_period_us
echo 1000000 > /sys/fs/cgroup/cpu/testgroup/cpu.cfs_quota_us

- cpu.rt_period_us: 实时调度策略，设置某个时间段中每隔多久cgroup对CPU资源的存储就要重新分配，单位为微秒（注意:只可以用于实时调度的程序）
- cpu.rt_runtime_us: 实时调度策略，设置某个时间段内cgroup中任务对CPU资源的最长连续访问时间，单位为微秒（注意:只可以用于实时调度的程序）
#比如:我们宿主机中的内核参数设置如下，表示实时进程在运行时候并不是完全占用CPU的，这样设置的好处是即不会对实时任务响应时间导致大的影响，同时也解决了实时任务卡住时导致整个系统无响应;
sysctl -a | grep "sched_rt"
kernel.sched_rt_period_us = 1000000
kernel.sched_rt_runtime_us = 950000

ls /sys/fs/cgroup/cpu,cpuacct | grep "cpuacct"
cpuacct.stat    # 报告此cgroup中所有任务（包括层级中的低端任务-下同）中用户(用户模式)和系统（kelnel模式）使用的CPU时间
# user 350140
# system 344690

cpuacct.usage   # 报告此cgroup中所有任务使用CPU的总时间
# 13713389123644

cpuacct.usage_percpu #报告cgroup中所有任务每个CPU使用时间（单位纳秒）
# 6911595096356 6801848202718

ls /sys/fs/cgroup/memory | grep "memory."

memory.kmem.limit_in_bytes  #设置内存使用上线，单位可以使用k/K,m/M,g/GD等;
memory.memsw.limit_in_bytes #设置内存加上交换分区的使用总量，防止进程把交换分区耗光;
memory.stat         #汇报内存使用信息包括当前资源总量，使用量，换页次数，活动页数量等等;
memory.oom_control  #用来决定一个进程在申请内存超限时候，是否会被系统kill掉，采用0或1来开启或者关闭cgroup的OOM killer默认开启（oom_kill_disable 0）;
# - 0 如果开启任务进程尝试申请内存超过允许，就会被系统OOM Killer终止;
# - 1 如果关闭任务进程尝试申请内存超过允许，那么它就会被暂停，直到额外的内存被释放;
memory.swappiness  #设置内存交换条件，对于使用swap空间有很大的重要性;
memory.failcnt
memory.force_empty
memory.kmem.failcnt
memory.kmem.max_usage_in_bytes
memory.kmem.slabinfo
memory.kmem.tcp.failcnt
memory.kmem.tcp.limit_in_bytes
memory.kmem.tcp.max_usage_in_bytes
memory.kmem.tcp.usage_in_bytes
memory.kmem.usage_in_bytes
memory.limit_in_bytes
memory.max_usage_in_bytes
memory.memsw.failcnt
memory.memsw.max_usage_in_bytes
memory.memsw.usage_in_bytes
memory.move_charge_at_immigrate
memory.numa_stat
memory.pressure_level
memory.soft_limit_in_bytes
memory.usage_in_bytes
memory.use_hierarchy

#1.创建控制组
mkdir  /sys/fs/cgroup/memory/testcagroup

#2.设置控制组使用的内存上限位100M，且内存与swap的总量为200M
echo 100M > /sys/fs/cgroup/memory/testcagroup/memory.limit_in_bytes
echo 200M > /sys/fs/cgroup/memory/testcagroup/memory.memsw.limit_in_bytes

#3.设置控制组中如果有进程尝试申请内存超过允许，就会被系统OOM killer掉
cat /sys/fs/cgroup/memory/testcagroup/memory.oom_control
oom_kill_disable 1
under_oom 0

#4.查看memory.stat因为控制组内没有添加进程，所以stat的信息为空将当前进程加入cgroup组内
$echo $$ > /sys/fs/cgroup/memory/testcagroup/tasks
$cat memory.stat
cache 0
rss 225280
rss_huge 0
mapped_file 0
swap 0
pgpgin 108
pgpgout 53
pgfault 584
pgmajfault 0
inactive_anon 0
active_anon 200704
inactive_file 0
active_file 0
unevictable 0
hierarchical_memory_limit 104857600
hierarchical_memsw_limit 209715200
total_cache 0
total_rss 225280
total_rss_huge 0
total_mapped_file 0
total_swap 0
total_pgpgin 108
total_pgpgout 53
total_pgfault 584
total_pgmajfault 0
total_inactive_anon 0
total_active_anon 200704
total_inactive_file 0
total_active_file 0
total_unevictable 0

# 默认权重为1000
cat /sys/fs/cgroup/blkio/blkio.weight
1000

# 创建2个控制组并设置权重
mkdir/sys/fs/cgroup/blkio/mygroup{1,2}
echo 500 > /sys/fs/cgroup/blkio/mygroup1/blkio.weight
echo 100 > /sys/fs/cgroup/blkio/mygroup2/blkio.weight

# 此时离cgexec命令在清空缓存后采用dd读写（可以以此区别两个控制组的读写比例在5:1左右）
cgexec -g "blkio:mygroup1" dd bs=1M count=4096 if=file1 of=/dev/null
cgexec -g "blkio:mygroup2" dd bs=1M count=4096 if=file1 of=/dev/null

#1.网桥工具安装brctl
yum install -y bridge-utils

#2.查看网桥连接信息
$brctl show
# bridge name     bridge id               STP enabled     interfaces
# br-fa08aa7db7a6 8000.0242fb5007f1       no              veth842b243
# docker0         8000.024245b206ce       no              veth985cbf0

#3.机器网卡信息
$ip addr | grep "BROADCAST"
# 2: ens192: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000
# 3: docker0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default
# 5: br-fa08aa7db7a6: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default
# 57: veth985cbf0@if56: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue master docker0 state UP group default
# 71: veth842b243@if70: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue master br-fa08aa7db7a6 state UP group default

# 简单描述
ens192|eth0 <-> docker0 <-> veth985cbf0@56(虚拟网卡) <-> eth0@if57(容器内部)网卡

# 容器内部网卡信息
docker exec -it test1 sh -c ip addr
# 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN 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
# 56: eth0@if57: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue state UP
#     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

# (1) Docker network 查看
docker network ls
# NETWORK ID          NAME                DRIVER(驱动模式)              SCOPE
# 3448511628ee        bridge              bridge              local
# 5baa8b9f47c3        host                host                local
# afd58da3d80f        none                null                local
# fa08aa7db7a6        opt_default         bridge              local

# (2) 网络名称信息详细
docker network inspect $(docker network ls -q)
# [
#     {
#         "Name": "bridge",
#         "Id": "3448511628ee3de59985bfa8251a8731148265417530fba645d1f5cca6464ccf",
#         "Created": "2020-07-02T11:21:02.785207578+08:00",
#         "Scope": "local",
#         "Driver": "bridge",
#         "EnableIPv6": false,
#         "IPAM": {
#             "Driver": "default",
#             "Options": null,
#             "Config": [
#                 {
#                     "Subnet": "172.17.0.0/16",
#                     "Gateway": "172.17.0.1"
#                 }
#             ]
#         },
#         "Internal": false,
#         "Attachable": false,
#         "Ingress": false,
#         "ConfigFrom": {
#             "Network": ""
#         },
#         "ConfigOnly": false,
#         "Containers": {
#             "25d2d645bfc9e6530039d6aac890f69dd9af33f8f966adc2d7287b74964678e3": {
#                 "Name": "test1",
#                 "EndpointID": "6c825cb11f084e85afddbc993937e6061b2e36ea7dfaa30792b2ea6d0eb414a1",
#                 "MacAddress": "02:42:ac:11:00:02",
#                 "IPv4Address": "172.17.0.2/16",
#                 "IPv6Address": ""
#             }
#         },
#         "Options": {
#             "com.docker.network.bridge.default_bridge": "true",
#             "com.docker.network.bridge.enable_icc": "true",
#             "com.docker.network.bridge.enable_ip_masquerade": "true",
#             "com.docker.network.bridge.host_binding_ipv4": "0.0.0.0",
#             "com.docker.network.bridge.name": "docker0",
#             "com.docker.network.driver.mtu": "1500"
#         },
#         "Labels": {}
#     }
# ]

--net=bridge 这个是默认值，连接到默认的网桥。
--net=host 告诉Docker不要将容器网络放到隔离的命名空间中，即不要容器化容器内的网络
  - 此时容器使用本地主机的网络，它拥有完全的本地主机接口访问权（不安全）,
  - 如果进一步的使用 --privileged=true，容器会被允许直接配置主机的网络堆栈。
--net=container:NAME_or_ID  让Docker将新建容器的进程放到一个已存在容器的网络栈中，新容器进程有自己的文件系统、进程列表和资源限制，但会和已存在的容器共享 IP 地址和端口等网络资源，两者进程可以直接通过 lo 环回接口通信。
--net=none 让 Docker 将新容器放到隔离的网络栈中，但是不进行网络配置。之后用户可以自己进行配置。
  - 用户可以使用 ip netns exec 命令来在指定网络命名空间中进行配置，从而配置容器内的网络。

----------           ----------   
|Container|          |Container|
|eth0@if57|          |eth0@if70|     #veth pair@ 对应宿主机上虚拟网卡号 $ip addr 可查看
----------           ----------
    |                   |
------------------------------------
veth985cbf0@if56   veth842b243@if69  #veth pair:@ 后对应着容器内部网络号  $ip addr 可查看
|      docker0 （bridge）          |
------------------------------------
              | ipv4_ip_forward (iptales)
         (eth0|ens192)

# (1) 容器 test1 的网络信息
$docker exec -it test1 ip addr
56: eth0@if57: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue state UP
    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

# (2) 查看iptables中关于test1容器的NAT转发规则
$iptables -t nat -L   # 默认四条链+创建的Docker链
Chain PREROUTING (policy ACCEPT)
target     prot opt source               destination
DOCKER     all  --  anywhere             anywhere             ADDRTYPE match dst-type LOCAL  #网桥

Chain INPUT (policy ACCEPT)
target     prot opt source               destination

Chain OUTPUT (policy ACCEPT)
target     prot opt source               destination
DOCKER     all  --  anywhere            !loopback/8           ADDRTYPE match dst-type LOCAL   #网桥

Chain POSTROUTING (policy ACCEPT)
target     prot opt source               destination
MASQUERADE  all  --  172.18.0.0/16       anywhere
MASQUERADE  tcp  --  172.18.0.2          172.18.0.2           tcp dpt(destination port):http                    #运行通过的目标IP协议与应用

Chain DOCKER (2 references)
target     prot opt source               destination
RETURN     all  --  anywhere             anywhere
RETURN     all  --  anywhere             anywhere
DNAT       tcp  --  anywhere             anywhere             tcp dpt:tproxy to:172.18.0.2:80  #将指定容器的IP和端口进行转发
# 上述规则简要说明:
# 从任意源发送当前机器的80端口的TCP转发到容器地址为 172.18.0.2:80 的内部应用上;

# (3) 具体流程
# 访问宿主机的80端口，然后经过iptables的NAT PREROUTING将IP重定向到172.18.0.2, 之后重定向的数据包通过iptables中的FILTER配置，最终在NAT POSTROUTING阶段将IP地址伪装成为127.0.0.1，此时访问宿主机上映射到容器中端口，所有的请求便会转发到容器中;
127.0.0.1:80 ->  NAT PREROUTING -> 172.18.0.2:80 -> FILTER FORWARD -> ACCEPT -> NAT POSTROUTING

# (1) 内核转发参数查看
$sysctl -a | grep "ip_forward"
net.ipv4.ip_forward = 1
# PS:手动开启转发（临时生效）
sysctl -w net.ipv4.ip_forward = 1
# 启动docker deamon指定以下参数也可以实现本地转发
dockerd  -h | grep "ip_forward"
--ip-forward  Enable net.ipv4.ip_forward (default true)

# (2) 宿主机以外的世界需要访问容器时候，利用DNAT修改数据包的目的地址，数据包的流向如下
# 宿主机上的dokcer0网桥采用iptable识别到有请求访问容器IP和端口时，将数据包发送附加到docker0网桥上的veth985cbf0@if56接口中，该接口由于veth-pair特性会将接收到的数据包无条件的发送给容器内部的 eth0@if57 ，容器接收到数据包并做出响应;
              |------------------------------------------------|
数据包(外界) -> Eth0 <-<- DNAT ->-> Docker0 —> veth985cbf0@if56 -> eth0@if57(容器内部)
              |                 宿主机                         |
              |------------------------------------------------|

# (3) 当容器内部需要访问宿主机以外的世界时候，利用SNAT修改数据包的源地址（此时容器对与外部网络是透明的），数据包流向为下所示
# 流程与上面相似方向相反，只是转发采用SNAT方式;
数据包[eth0@if57](容器) -> veth985cbf0@if56 -> Docker0 <-<- SNAT ->-> Eth0 -> 外界网络
                        |--------------------宿主机------------------------|

[Docker Container](host 模式) -> 宿主机 (eth0) -> 外界网络

# (1) 创建Host网络模式的同期，可以通过ip addr 命令查看网卡信息，因为直接利用宿主机的网络栈，所有打印出的直接是宿主机的网卡接口信息;
docker run -it --net=host busybox ip addr
# 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue qlen 1000
# 2: ens192: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq qlen 1000
# 3: docker0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue
# 5: br-fa08aa7db7a6: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue
# 57: veth985cbf0@if56: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue master docker0
# 71: veth842b243@if70: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue master br-fa08aa7db7a6

Docker Container  <->  Docker Container
                       |   eth0@if57   | 
                       -----------------
                              |
  Docker0 (Bridge) <-> [veth985cbf0@if56]                                
    | (ipv4.ip_forward)
  eth0

# 1.创建一个bridge网络模式的容器
docker run -d -P --net=bridge --name nginx nginx:latest
# 2.查看其容器的ip 信息
docker inspect nginx | grep "IPAddress"
docker inspect nginx | grep "IPAddress"
"SecondaryIPAddresses": null,
"IPAddress": "172.17.0.3",
# 3.构建一个采用Container网络模式的容器
# 创建容器连接到已键容器的网络之中，比如采用container:容器名称进行制定网络;
docker run -d --name busybox --net=container:nginx busybox:latest top
# 13d274350a2855c1295e3c93fd4e6a166b6e34cfc71a91e1396ca8b4a75f67e2

# 4.此时您会发现其IP地址与链接到容器中的网络IP地址一样均为172.17.0.3
$docker ps
CONTAINER ID        IMAGE                    COMMAND                  CREATED             STATUS                PORTS                   NAMES
13d274350a28        busybox:latest           "top"                    3 seconds ago       Up 2 seconds                                  busybox
04074e2e85b4        nginx:latest             "/docker-entrypoint.…"   4 minutes ago       Up 3 minutes          0.0.0.0:32768->80/tcp   nginx
$docker exec -it busybox ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue qlen 1000
72: eth0@if73: <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

# 1.创建一个网络模式为none的容器
docker run -itd --net=none --name=busybox-none busybox top
# 2.查看创建的容器的ip地址，只能看见一个回环地址
docker exec -it busybox-none ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue qlen 1000

                     | -> Native Drivers(None, Bridge, Overlay, Macvlan) #原生
Docker -> Libnetwork | ->
                     | -> Remote Drivers(Flannel, Weave, Calico)  #第三方网络插件

# 1.在Docker Deamon其中一个节点中拉取并运行Consul镜像
docker run -d -p 8500:8500 -h consul --name consul-net-overlay progrium/consul -server -bootstrap**docker run -d -p 8500:8500 -h consul --name consul-net-overlay progrium/consul -server -bootstrap
# Status: Downloaded newer image for progrium/consul:latest
# 86d9d93384034b19acad56dfdebed754da060125b534b240fd87f79e18a2bfcd

# 2.然后再各个Docker节点的Deamon上进行配置Consul发现: /etc/systemd/system/docker.service 再其后加上如下参数
--cluster-store=consul://10.10.107.245:8500 --cluster-advertise=ens192:2376
$ systemctl cat docker
# /usr/lib/systemd/system/docker.service
# ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock --exec-opt native.cgroupdriver=systemd --cluster-store=consul://10.10.107.245:8500 (consul运行节点) --cluster-advertise=ens192:2376(当前节点网卡或者IP即Docker Deamon服务)

# 3.systemd守护进程重启与重启docker
[root@worker-03 ~]$ systemctl daemon-reload
[root@worker-03 ~]$ systemctl restart docker

# 4.创建overlay 网络与创建bridge网络基本一致，只是在-d参数时候有些许不同
docker network create -d overlay overlay-net 
docker network create -d overlay overlay-net-sub --subnet 172.25.0.0/24 --gateway 172.25.0.1


# 5.创建运行容器时候指定-network参数，及时在不同的docker主机下创建的容器只要--network为oveylay-net它们之间都能相互访问；
# 以简单使用 –net=host 方式使用主机网络模式
docker run --network overlay-net busybox sleep 6000
docker run --network overlay-net busybox sleep 6000
$docker ps
# CONTAINER ID        IMAGE                   COMMAND                  CREATED             STATUS              PORTS               NAMES
# 430ec4450df4        busybox                 "sleep 6000"             6 minutes ago       Up 6 minutes                            cranky_curie
# 0902833f9a63        busybox                 "sleep 6000"             12 minutes ago      Up 11 minutes                           intelligent_chaplygin


# 6.Docker 网络查看
$docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
5de5f196afda        bridge              bridge              local
23d95a1bd969        docker_gwbridge     bridge              local
3a700c6af892        host                host                local
93a5b381ef0d        none                null                local
e437f4650c96        overlay-net         overlay             global
$docker network inspect docker_gwbridge -f "{{.IPAM.Config}}"
# [{172.18.0.0/16  172.18.0.1 map[]}]
$docker network inspect overlay-net -f "{{.IPAM.Config}}"
# [{10.0.0.0/24  10.0.0.1 map[]}]


# 7.创建容器的IP地址查看
[root@worker-03 ~]$docker exec -it 090 ip addr
22: eth0@if23: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1450 qdisc noqueue
    link/ether 02:42:0a:00:00:02 brd ff:ff:ff:ff:ff:ff
    inet 10.0.0.2/24 brd 10.0.0.255 scope global eth0
       valid_lft forever preferred_lft forever
25: eth1@if26: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue
    link/ether 02:42:ac:12:00:02 brd ff:ff:ff:ff:ff:ff
    inet 172.18.0.2/16 brd 172.18.255.255 scope global eth1
       valid_lft forever preferred_lft forever
[root@worker-03 ~]$docker exec -it 430 ip addr
27: eth0@if28: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1450 qdisc noqueue
    link/ether 02:42:0a:00:00:03 brd ff:ff:ff:ff:ff:ff
    inet 10.0.0.3/24 brd 10.0.0.255 scope global eth0
       valid_lft forever preferred_lft forever
29: eth1@if30: <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 eth1
       valid_lft forever preferred_lft forever

[root@worker-03 ~]$docker exec -it 090 sh
/ # ip addr
/ # ping 10.0.0.1
PING 10.0.0.1 (10.0.0.1): 56 data bytes
64 bytes from 10.0.0.1: seq=0 ttl=64 time=0.540 ms
/ # ping 10.0.0.2
PING 10.0.0.2 (10.0.0.2): 56 data bytes
64 bytes from 10.0.0.2: seq=0 ttl=64 time=0.055 ms
/ # ping 10.0.0.3 #可以看到是正常通信的
PING 10.0.0.3 (10.0.0.3): 56 data bytes
64 bytes from 10.0.0.3: seq=0 ttl=64 time=0.110 ms

bridge name           bridge id               STP enabled     interfaces
docker0               8000.024274c0c574       no
docker_gwbridge       8000.02422e73bb62       no              vethae1f217
                                                              vethec87cb3

docker info
 Server Version: 19.03.3
 Storage Driver: overlay2

# (1) common.txt分别存放不同的内容
比如lower1下面common.txt内容是lower1，lower2下面common.txt内容是lower2，lower3下面common.txt内容是lower3，upper目录有个和lower2/ower2.sh同名的目录
$tree -L 2
├── lower1
│   ├── common.txt
│   └── ower1.sh
├── lower2
│   ├── common.txt
│   └── ower2.sh
├── lower3
│   ├── common.txt
│   └── ower3.sh
├── merged
├── upper
│   ├── ower2.sh
│   └── up.txt
└── work
    └── work

# (2) 我们通过下面的命令进行挂载
* lowerdir: 代表lower层，可以有多个，优先级依次降低，也就是说`lower1 > lower2 > lower3`
* upperdir: 代表upper层,会覆盖lower层
* workdir: 工作目录,用于存放临时文件
* merged: 挂载点,我们看看操作之后的目录

$mount -t overlay overlay -o lowerdir=lower1:lower2:lower3,upperdir=upper,workdir=work merged
# (3) 挂载后的操作目录`merged挂载点`.
├── lower1
│   ├── common.txt
│   └── ower1.sh
├── lower2
│   ├── common.txt
│   └── ower2.sh
├── lower3
│   ├── common.txt
│   └── ower3.sh
├── merged        #是不是看出了什么奥秘，很清晰的说明了overlayFS的上面两个特征
│   ├── common.txt
│   ├── ower1.sh
│   ├── ower2.sh
│   ├── ower3.sh
│   └── up.txt
├── upper
│   ├── ower2.sh
│   └── up.txt
└── work
    └── work

# (1) 宿主机随机目录,指定的目录如果没有不存在将会被创建
docker run -itd -v /tmp/container/folder --name data-volume busybox top
docker inspect data-volume -f 'Source:{{(index .Mounts 0).Source}}{{println}}Destination:{{(index .Mounts 0).Destination}}'
# 即表示容器中的/tmp/container/folder目标被挂载到宿主机的随机目录;
# Source:/var/lib/docker/volumes/1a035d81e56447cd314faf560754b1808234645785f1b61a2c17199b16a7cf27/_data
# Destination:/tmp/container/folder
$docker exec -it data-volume sh
$ls /tmp/container/folder/ls^C

# (2) 宿主机指定目录
docker run -itd -v /tmp/mnt_isolation:/tmp/tar/tmp/container/folder --name data-volume-1 busybox top
docker inspect data-volume-1 -f 'Source:{{(index .Mounts 0).Source}}{{println}}Destination:{{(index .Mounts 0).Destination}}'
# 指定了宿主机映射的目录（下面查看源、目的地址的目录）
# Source:/tmp/mnt_isolation
# Destination:/tmp/tar/tmp/container/folder

# (3) 连接已经存在的数据卷，通过--volumes-from将上面的数据卷data-volume进行挂载起来
docker run -itd --volumes-from data-volume --name data-volume-2 busybox top 
# 91bfdb9c9ca88571faebf6f2409105b1e55d24866fe30a4ea7c2f750031c8baf
docker run -itd --volumes-from data-volume --name data-volume-3 busybox top 
# f601713d75277e6255e9a52a30046f1e38c169d7674f3ef2dd287bdb444820d1
# 进入data-volume-3容器中在其数据卷目录中创建文件
$docker exec -it data-volume-3 touch /tmp/container/folder/$$.txt
# 分别查看几个容器共享的数据卷是否一致
$docker exec -it data-volume-3 ls -alh /tmp/container/folder/
-rw-r--r--    1 root     root           0 Jul  6 13:50 3758.txt
$docker exec -it data-volume-2 ls -alh /tmp/container/folder/
-rw-r--r--    1 root     root           0 Jul  6 13:50 3758.txt
$docker exec -it data-volume ls -alh /tmp/container/folder/
-rw-r--r--    1 root     root           0 Jul  6 13:50 3758.txt
# 删除数据卷容器目录时需要加上-v则删除一个停止的容器并且其数据卷中的内容
$docker stop data-volume data-volume-2 data-volume-3
$docker rm -v data-volume data-volume-2 data-volume-3   #需要删除全部的数据卷存储的数据才会全部消失
data-volume
#补充:docker volume prune 清除已停止的数据卷