简单来说，实现docker跨主机容器间通信，常用的第三方网络方案是Flannel，Weave，Calico：
Flannel会为每个host分配一个subnet，容器从这个subnet中分配ip，这些ip可以在host间路由，容器间无需NAT和port mapping转发就可以实现跨主机通信。Flannel网络没有提供Docker DNS服务， 容器间不能通过hostname访问。

Weave对于容器来说，它就像是一个巨大的以太网交换机， 所有容器都被接入到这个交换机，同样容器间无需NAT和port mapping转发就可以实现跨主机通信。Weave网络提供了Docker DNS服务， 容器之间可以通过hostname访问。

Calico是一个纯三层的虚拟网络，它会为每个容器分配一个ip，每个host都是router，把不同host的容器连接起来，从而实现跨主机间容器通信。与vxlan不同的是，calico网络不对数据包进行额外封装，不需要NAT和端口映射，扩展性和 性能都很好。Calico网络提供了Docker DNS服务， 容器之间可以通过hostname访问。

以上三种网络方案区别：
1）从网络模型上来说
-> Flannel网络有两种模式：vxlan模式是一种overlay覆盖网络，而host-gw模式将主机作为网关，依赖于纯三层的ip转发；
-> Weave网络是一种overlay覆盖网络；
-> Calico网络也是一种纯三层的网络；
(overlay是基于vxlan的虚拟网络，可以将二层网络数据封装到UDP进行传输，在主机间建立vxlan虚拟隧道，实现跨主机容器之间通信)。

2）分布式存储（Distributed Store）
-> Flannel和Calico都需要分布式健值存储数据库(key-values)，比如etcd或consul；
-> Weave自己负责在主机间交换网络配置信息，不需要etcd或consul这些数据库；

3）IP地址管理（IPAM）
-> Flannel为每个主机自动分配独立的subnet，用户只需要指定一个大的IP池。不同subnet之间的路由信息也由Flannel自动生成和配置。
-> Weave默认配置下所有容器使用10.32.0.0/12的subnet，如果此地址空间与现有IP冲突，则可以通过–ipalloc-range分配特定的subnet。
-> Calico通过IP Pool可以为每个主机定制自己的subnet。

4）网络连通和隔离
-> 不同Flannel网络中的容器可以直接通信，Flannel没有提供网络隔离。与外网通信可以通过bridge网络。
-> Weave网络默认配置下所有容器在一个大的subnet中，可以自由通信，如果要实现网络隔离，需要为容器指定不同的subnet或IP。若要与外网通信，则需要将主机加入到weave网络，并把主机当作网关。
-> Calico默认配置下只允许同一网络中的容器之间通信，但通过其强大的Policy能够实现几乎任意场景的访问控制。

之前详细介绍了Flannel网络、Weave网络，下面就说下Calico网络的相关知识：

一、Calico 基本介绍

Calico是一个纯三层的协议，为OpenStack虚机和Docker容器提供多主机间通信。Calico不使用重叠网络比如flannel和libnetwork重叠网络驱动，它是一个纯三层的方法，使用虚拟路由代替虚拟交换，每一台虚拟路由通过BGP协议传播可达信息（路由）到剩余数据中心。

二、Calico 结构组成

Calico不使用重叠网络比如flannel和libnetwork重叠网络驱动，它是一个纯三层的方法，使用虚拟路由代替虚拟交换，每一台虚拟路由通过BGP协议传播可达信息（路由）到剩余数据中心；Calico在每一个计算节点利用Linux Kernel实现了一个高效的vRouter来负责数据转发，而每个vRouter通过BGP协议负责把自己上运行的workload的路由信息像整个Calico网络内传播——小规模部署可以直接互联，大规模下可通过指定的BGP route reflector来完成。
结合上面这张图，我们来过一遍 Calico 的核心组件：
Felix： Calico agent，跑在每台需要运行 workload 的节点上，主要负责配置路由及 ACLs 等信息来确保 endpoint 的连通状态；
etcd：分布式键值存储，主要负责网络元数据一致性，确保 Calico 网络状态的准确性；
BGPClient(BIRD)：主要负责把 Felix 写入 kernel 的路由信息分发到当前 Calico 网络，确保 workload 间的通信的有效性；
BGP Route Reflector(BIRD)： 大规模部署时使用，摒弃所有节点互联的 mesh 模式，通过一个或者多个BGP Route Reflector来完成集中式的路由分发；

通过将整个互联网的可扩展 IP 网络原则压缩到数据中心级别，Calico 在每一个计算节点利用Linux kernel实现了一个高效的vRouter来负责数据转发而每个vRouter通过BGP
协议负责把自己上运行的 workload 的路由信息像整个 Calico 网络内传播 － 小规模部署可以直接互联，大规模下可通过指定的BGP route reflector 来完成。这样保证最终所有的 workload 之间的数据流量都是通过 IP 包的方式完成互联的。

三、Calico 工作原理

Calico把每个操作系统的协议栈认为是一个路由器，然后把所有的容器认为是连在这个路由器上的网络终端，在路由器之间跑标准的路由协议——BGP的协议，然后让它们自己去学习这个网络拓扑该如何转发。所以Calico方案其实是一个纯三层的方案，也就是说让每台机器的协议栈的三层去确保两个容器，跨主机容器之间的三层连通性。

对于控制平面，它每个节点上会运行两个主要的程序，一个是Felix，它会监听ECTD中心的存储，从它获取事件，比如说用户在这台机器上加了一个IP，或者是分配了一个容器等。接着会在这台机器上创建出一个容器，并将其网卡、IP、MAC都设置好，然后在内核的路由表里面写一条，注明这个IP应该到这张网卡。绿色部分是一个标准的路由程序，它会从内核里面获取哪一些IP的路由发生了变化，然后通过标准BGP的路由协议扩散到整个其他的宿主机上，让外界都知道这个IP在这里，你们路由的时候得到这里来。

由于Calico是一种纯三层的实现，因此可以避免与二层方案相关的数据包封装的操作，中间没有任何的NAT，没有任何的overlay，所以它的转发效率可能是所有方案中最高的，因为它的包直接走原生TCP/IP的协议栈，它的隔离也因为这个栈而变得好做。因为TCP/IP的协议栈提供了一整套的防火墙的规则，所以它可以通过IPTABLES的规则达到比较复杂的隔离逻辑。

Calico节点组网可以直接利用数据中心的网络结构（支持 L2 或者 L3），不需要额外的 NAT，隧道或者 VXLAN overlay network。
如上图所示，这样保证这个方案的简单可控，而且没有封包解包，节约 CPU 计算资源的同时，提高了整个网络的性能。此外，Calico 基于 iptables 还提供了丰富而灵活的网络 policy, 保证通过各个节点上的 ACLs 来提供 workload 的多租户隔离、安全组以及其他可达性限制等功能。

四、Calico网络方式（两种）

1）IPIP
从字面来理解，就是把一个IP数据包又套在一个IP包里，即把 IP 层封装到 IP 层的一个 tunnel，看起来似乎是浪费，实则不然。它的作用其实基本上就相当于一个基于IP层的网桥！一般来说，普通的网桥是基于mac层的，根本不需 IP，而这个 ipip 则是通过两端的路由做一个 tunnel，把两个本来不通的网络通过点对点连接起来。ipip 的源代码在内核 net/ipv4/ipip.c 中可以找到。

2）BGP
边界网关协议（Border Gateway Protocol, BGP）是互联网上一个核心的去中心化自治路由协议。它通过维护IP路由表或‘前缀’表来实现自治系统（AS）之间的可达性，属于矢量路由协议。BGP不使用传统的内部网关协议（IGP）的指标，而使用基于路径、网络策略或规则集来决定路由。因此，它更适合被称为矢量性协议，而不是路由协议。BGP，通俗的讲就是讲接入到机房的多条线路（如电信、联通、移动等）融合为一体，实现多线单IP，BGP 机房的优点：服务器只需要设置一个IP地址，最佳访问路由是由网络上的骨干路由器根据路由跳数与其它技术指标来确定的，不会占用服务器的任何系统。

五、Calico网络通信模型

calico是纯三层的SDN 实现，它基于BPG 协议和Linux自身的路由转发机制，不依赖特殊硬件，容器通信也不依赖iptables NAT或Tunnel 等技术。
能够方便的部署在物理服务器、虚拟机（如 OpenStack）或者容器环境下。同时calico自带的基于iptables的ACL管理组件非常灵活，能够满足比较复杂的安全隔离需求。

在主机网络拓扑的组织上，calico的理念与weave类似，都是在主机上启动虚拟机路由器，将每个主机作为路由器使用，组成互联互通的网络拓扑。当安装了calico的主机组成集群后，其拓扑如下图所示：
每个主机上都部署了calico/node作为虚拟路由器，并且可以通过calico将宿主机组织成任意的拓扑集群。当集群中的容器需要与外界通信时，就可以通过BGP协议将网关物理路由器加入到集群中，使外界可以直接访问容器IP，而不需要做任何NAT之类的复杂操作。

当容器通过calico进行跨主机通信时，其网络通信模型如下图所示：
从上图可以看出，当容器创建时，calico为容器生成veth pair，一端作为容器网卡加入到容器的网络命名空间，并设置IP和掩码，一端直接暴露在宿主机上，
并通过设置路由规则，将容器IP暴露到宿主机的通信路由上。于此同时，calico为每个主机分配了一段子网作为容器可分配的IP范围，这样就可以根据子网的
CIDR为每个主机生成比较固定的路由规则。

当容器需要跨主机通信时，主要经过下面的简单步骤：

• 容器流量通过veth pair到达宿主机的网络命名空间上。
• 根据容器要访问的IP所在的子网CIDR和主机上的路由规则，找到下一跳要到达的宿主机IP。
• 流量到达下一跳的宿主机后，根据当前宿主机上的路由规则，直接到达对端容器的veth pair插在宿主机的一端，最终进入容器。

从上面的通信过程来看，跨主机通信时，整个通信路径完全没有使用NAT或者UDP封装，性能上的损耗确实比较低。但正式由于calico的通信机制是完全基于三层的，这种机制也带来了一些缺陷，例如：

• calico目前只支持TCP、UDP、ICMP、ICMPv6协议，如果使用其他四层协议（例如NetBIOS协议），建议使用weave、原生overlay等其他overlay网络实现。
• 基于三层实现通信，在二层上没有任何加密包装，因此只能在私有的可靠网络上使用。
• 流量隔离基于iptables实现，并且从etcd中获取需要生成的隔离规则，有一些性能上的隐患。

六、Docker+Calico 部署记录

1）环境准备

192.168.31.80     k8s-h1         安装docker+etcd+calicoctl
192.168.31.90     k8s-h2         安装docker+etcd+calicoctl[root@k8s-h1 ~]# cat /etc/redhat-release
CentOS Linux release 7.8.2003 (Core)修改三个节点的主机名 (主机名最好和后面ETCD_NAME和calico的NODENAME名称起一样的名,否则最后可能会出现容器之间ping不通的现象)
[root@k8s-h1 ~]# hostnamectl set-hostname k8s-h1
[root@k8s-h1 ~]# bash[root@k8s-h2 ~]# hostnamectl set-hostname k8s-h2
[root@k8s-h2 ~]# bash关闭三台主机的防火墙。若开启iptables防火墙，则需要打开2380端口通信。
[root@k8s-h1 ~]# systemctl stop firewalld.service
[root@k8s-h1 ~]# systemctl disable firewalld.service
[root@k8s-h1 ~]# iptables -F
[root@k8s-h1 ~]# firewall-cmd --state
not running在三台机器上都要设置hosts，均执行如下命令：
[root@k8s-h1 ~]# vim /etc/hosts
[root@k8s-h1 ~]# cat /etc/hosts
127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6
192.168.31.80 k8s-h1
192.168.31.90 k8s-h2三台集机器上的ip转发功能打开
[root@k8s-h1 ~]# echo 1 > /proc/sys/net/ipv4/ip_forward
[root@k8s-h1 ~]# sysctl -p

2）安装docker（三个节点都要安装）

[root@k8s-h1 ~]# yum install -y docker
[root@k8s-h1 ~]# systemctl start docker
[root@k8s-h1 ~]# systemctl enable docker下载nginx容器镜像，可以直接"docker pull nginx"从docker仓库中下载。
[root@k8s-h1 ~]# docker pull nginx:latest
[root@k8s-h1 ~]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
nginx               latest              9beeba249f3e        2 days ago          127MB

3）构建etcd集群环境

三个节点都要安装etcd
[root@k8s-h1 ~]# yum install etcd -y配置etcd集群
k8s-h1节点配置
[root@k8s-h1 ~]# cp /etc/etcd/etcd.conf /etc/etcd/etcd.conf.bak
[root@k8s-h1 ~]# > /etc/etcd/etcd.conf
[root@k8s-h1 ~]# vim /etc/etcd/etcd.conf
[root@k8s-h1 ~]# cat /etc/etcd/etcd.conf
#[Member]
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="http://0.0.0.0:2380"
ETCD_LISTEN_CLIENT_URLS="http://0.0.0.0:2379"ETCD_NAME="k8s-h1"#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="http://192.168.31.80:2380"
ETCD_ADVERTISE_CLIENT_URLS="http://192.168.31.80:2379"
ETCD_INITIAL_CLUSTER="k8s-h1=http://192.168.31.80:2380,k8s-h2=http://192.168.31.90:2380"k8s-h2节点配置
[root@k8s-h2 ~]# cp /etc/etcd/etcd.conf /etc/etcd/etcd.conf.bak
[root@k8s-h2 ~]# > /etc/etcd/etcd.conf
[root@k8s-h2 ~]# vim /etc/etcd/etcd.conf
[root@k8s-h2 ~]# cat /etc/etcd/etcd.conf
#[Member]
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="http://0.0.0.0:2380"
ETCD_LISTEN_CLIENT_URLS="http://0.0.0.0:2379"ETCD_NAME="k8s-h2"#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="http://192.168.31.90:2380"
ETCD_ADVERTISE_CLIENT_URLS="http://192.168.31.90:2379"
ETCD_INITIAL_CLUSTER="k8s-h1=http://192.168.31.80:2380,k8s-h2=http://192.168.31.90:2380"接着修改个节点两的docker启动文件,使docker支持etcd
在ExecStart区域内添加 (在--seccomp-profile 这一行的下面一行添加)k8s-h1节点
[root@k8s-h1 ~]# cp /usr/lib/systemd/system/docker.service /usr/lib/systemd/system/docker.service.bak
[root@k8s-h1 ~]# vim /usr/lib/systemd/system/docker.service
........
ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock --cluster-store=etcd://192.168.31.80:2379
[root@k8s-h1 ~]# systemctl daemon-reload
[root@k8s-h1 ~]# systemctl restart dockerk8s-h2节点
[root@k8s-h2 ~]# cp /usr/lib/systemd/system/docker.service /usr/lib/systemd/system/docker.service.bak
[root@k8s-h2 ~]# vim /usr/lib/systemd/system/docker.service
........
ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock --cluster-store=etcd://192.168.31.90:2379
[root@k8s-h2 ~]# systemctl 8daemon-reload
[root@k8s-h2 ~]# systemctl restart docker如上修改并重启docker服务后, 查看各个节点,发现当前docker支持了etcd (这里以k8s-h1节点为例)
[root@k8s-h1 ~]# ps -ef | grep etcd此时还没有启动etcd服务,所以要启动个两节点的etcd服务(这里以k8s-h1节点为例)
[root@k8s-h1 ~]# systemctl start etcd
[root@k8s-h1 ~]# systemctl enable etcd
Created symlink from /etc/systemd/system/multi-user.target.wants/etcd.service to /usr/lib/systemd/system/etcd.service.再次查看,发现多了一个etcd进程
[root@k8s-h1 ~]# ps -ef|grep etcd
root       4047      1  0 16:32 ?        00:00:00 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock --cluster-store=etcd://192.168.31.80:2379
etcd       4336      1  3 16:34 ?        00:00:00 /usr/bin/etcd --name=k8s-h1 --data-dir=/var/lib/etcd/default.etcd --listen-client-urls=http://0.0.0.0:2379
root       4352   1781  0 16:34 pts/0    00:00:00 grep --color=auto etcd查看集群成员（在两个节点机任意一个上面查看都可以，因为做的是集群环境）：
[root@k8s-h1 ~]# etcdctl  member list
8a3b3dbd33ef89a1: name=k8s-h1 peerURLs=http://192.168.31.80:2380 clientURLs=http://192.168.31.80:2379 isLeader=true
d7adeaa5cd222893: name=k8s-h2 peerURLs=http://192.168.31.90:2380 clientURLs=http://192.168.31.90:2379 isLeader=false[root@k8s-h1 ~]# etcdctl cluster-health
member 8a3b3dbd33ef89a1 is healthy: got healthy result from http://192.168.31.80:2379
member d7adeaa5cd222893 is healthy: got healthy result from http://192.168.31.90:2379
cluster is healthy===========================================================================================
温馨提示:
如果/etc/etcd/etcd.conf配置错误,etcd服务启动了,然后再次修改后重启etcd,发现没有生效!
查看日志命令为"journalctl -xe",发现下面错误信息:
the server is already initialized as member before, starting as etcd member...
......
simple token is not cryptographically signed解决办法:
1) 删除各个节点的/var/lib/etcd/default.etcd/目录下的数据,即"rm -rf /var/lib/etcd/default.etcd/*"
2) 检查/etc/etcd/etcd.conf文件是否配置正确
3) 重新启动etcd服务,即"systemctl stop etcd && systemctl start etcd" , 这样新配置就会重新生效了!

4）安装calico网络通信环境

两个节点最好都要先下载calico容器镜像 (其实在首次创建calico容器创建时会自动下载calico容器镜像,不过要等待一段时间,所以最好是提前下载好)
可以现在一个节点上下载这个镜像,下载之后导出来,然后再导入到其他两个节点上
[root@k8s-h1 ~]# docker pull quay.io/calico/node:v2.6.10
[root@k8s-h1 ~]# docker images
REPOSITORY             TAG                 IMAGE ID            CREATED             SIZE
nginx                  latest              9beeba249f3e        2 days ago          127MB
quay.io/calico/node    v2.6.10             3b2408e59c95        23 months ago       280MB安装calicoctl
calico下载地址：
网盘:https://pan.baidu.com/s/1JPyZy-WcD7egA4ISLPwhzw 提取码：5w47
github:https://github.com/projectcalico/calicoctl/releases/download/v1.1.0/calicoctl这里选择v1.1.0版本（两台节点机都要安装）
[root@k8s-h1 ~]# wget https://github.com/projectcalico/calicoctl/releases/download/v1.1.0/calicoctl
[root@k8s-h1 ~]# chmod 755 calicoctl 
[root@k8s-h1 ~]# mv calicoctl /usr/local/bin/
[root@k8s-h1 ~]# /usr/local/bin/calicoctl --version
calicoctl version v1.1.0, build 882dd008
[root@k8s-h1 ~]# calicoctl --version
calicoctl version v1.1.0, build 882dd008
[root@k8s-h1 ~]# calicoctl --help[root@k8s-h1 ~]# scp calicoctl 192.168.31.90:/usr/local/bin/
[root@k8s-h2 ~]# cd /usr/local/bin/
[root@k8s-h2 bin]# ll
总用量 31188
-rw-r--r-- 1 root root 31880448 5月  18 17:49 calicoctl
-rwxr-xr-x 1 root root    52232 5月  17 13:09 weave
[root@k8s-h2 bin]# chmod 755 calicoctl 
[root@k8s-h2 bin]# cd
[root@k8s-h2 ~]# /usr/local/bin/calicoctl --version
calicoctl version v1.1.0, build 882dd008
[root@k8s-h2 ~]# calicoctl --version
calicoctl version v1.1.0, build 882dd008然后分别在个两节点上创建calico容器k8s-h1节点
[root@k8s-h1 ~]# docker run --net=host --privileged --name=calico-k8s-h1 -d --restart=always -e NODENAME=k8s-h1 -e CALICO_NETWORKING_BACKEND=bird -e CALICO_LIBNETWORK_ENABLED=true -e IP=192.168.31.80 -e ETCD_ENDPOINTS=http://127.0.0.1:2379 -v /var/log/calico:/var/log/calico -v /var/run/calico:/var/run/calico -v /lib/modules:/lib/modules -v /run:/run -v /run/docker/plugins:/run/docker/plugins -v /var/run/docker.sock:/var/run/docker.sock quay.io/calico/node:v2.6.10
c46084f5ec9f11f1f4667cff9321cac51cf8d437bcc301a858b2e0fc762f80f6
[root@k8s-h1 ~]#k8s-h2节点
[root@k8s-h2 ~]# docker run --net=host --privileged --name=calico-k8s-h2 -d --restart=always -e NODENAME=k8s-h2 -e CALICO_NETWORKING_BACKEND=bird -e CALICO_LIBNETWORK_ENABLED=true -e IP=192.168.31.90 -e ETCD_ENDPOINTS=http://127.0.0.1:2379 -v /var/log/calico:/var/log/calico -v /var/run/calico:/var/run/calico -v /lib/modules:/lib/modules -v /run:/run -v /run/docker/plugins:/run/docker/plugins -v /var/run/docker.sock:/var/run/docker.sock quay.io/calico/node:v2.6.10
7fdc53cb1393073f3400a91e9aa16af731c2b4fbaa2ee715f414158a099bd3b0
[root@k8s-h2 ~]#然后查看各个节点的calico容器创建情况 (这里以k8s-h1节点为例,其他两个节点查看一样 )
[root@k8s-h1 ~]# docker ps
CONTAINER ID        IMAGE                         COMMAND                  CREATED             STATUS              PORTS               NAMES
c46084f5ec9f        quay.io/calico/node:v2.6.10   "start_runit"            5 minutes ago       Up 4 minutes                            calico-k8s-h1[root@k8s-h1 ~]# ps -ef|grep calico
root       4781   4778  0 18:05 ?        00:00:00 svlogd -tt /var/log/calico/bird6
root       4782   4778  0 18:05 ?        00:00:00 bird6 -R -s /var/run/calico/bird6.ctl -d -c /etc/calico/confd/config/bird6.cfg
root       4784   4777  0 18:05 ?        00:00:00 svlogd -tt /var/log/calico/bird
root       4786   4779  0 18:05 ?        00:00:00 svlogd /var/log/calico/confd
root       4788   4779  0 18:05 ?        00:00:02 confd -confdir=/etc/calico/confd -interval=5 -watch --log-level=info -node=http://127.0.0.1:2379 -client-key= -client-cert= -client-ca-keys=
root       4789   4780  0 18:05 ?        00:00:00 svlogd /var/log/calico/libnetwork
root       4790   4776  0 18:05 ?        00:00:00 svlogd /var/log/calico/felix
root       4797   4777  0 18:05 ?        00:00:00 bird -R -s /var/run/calico/bird.ctl -d -c /etc/calico/confd/config/bird.cfg
root       4798   4776 10 18:05 ?        00:00:28 calico-felix
root       5029   1781  5 18:10 pts/0    00:00:00 grep --color=auto calico接着查看calico状态
[root@k8s-h1 ~]# calicoctl node status
Calico process is running.IPv4 BGP status
+---------------+-------------------+-------+----------+-------------+
| PEER ADDRESS  |     PEER TYPE     | STATE |  SINCE   |    INFO     |
+---------------+-------------------+-------+----------+-------------+
| 192.168.31.90 | node-to-node mesh | up    | 10:09:34 | Established |
+---------------+-------------------+-------+----------+-------------+IPv6 BGP status
No IPv6 peers found.[root@k8s-h2 ~]# calicoctl node status
Calico process is running.IPv4 BGP status
+---------------+-------------------+-------+----------+-------------+
| PEER ADDRESS  |     PEER TYPE     | STATE |  SINCE   |    INFO     |
+---------------+-------------------+-------+----------+-------------+
| 192.168.31.80 | node-to-node mesh | up    | 10:09:34 | Established |
+---------------+-------------------+-------+----------+-------------+IPv6 BGP status
No IPv6 peers found.=============================================
停止calico服务
[root@k8s-h1 ~]# docker stop calico-k8s-h1
calico-k8s-h1
[root@k8s-h2 ~]# docker stop calico-k8s-h2
calico-k8s-h2

5）添加calico网络

为各个节点的calico网络添加可用的ip pool。这里采用ipip模式（即enabled为true）
k8s-h1节点操作（该节点的容器网段为10.0.10.0/24。注意：子网掩码是24，故必须是*.*.*.0/24；如果是16位子网掩码，则是*.*.0.0/16）[root@k8s-h1 ~]# vim ipPool.yaml
[root@k8s-h1 ~]# cat ipPool.yaml
apiVersion: v1
kind: ipPool
metadata:cidr: 17.16.10.0/16
spec:ipip:enabled: truenat-outgoing: truedisabled: false
[root@k8s-h1 ~]# calicoctl create -f ipPool.yaml
Successfully created 1 'ipPool' resource(s)[root@k8s-h2 ~]# vim ipPool.yaml 
[root@k8s-h2 ~]# cat ipPool.yaml 
apiVersion: v1
kind: ipPool
metadata:cidr: 192.10.160.0/16
spec:ipip:enabled: truenat-outgoing: truedisabled: false
[root@k8s-h2 ~]# calicoctl create -f ipPool.yaml
Successfully created 1 'ipPool' resource(s)=============================================
温馨提示:
如果是删除一个ip pool，命令是"calicoctl delete -f ipPool.yaml"
=============================================在任意一个节点上查看添加的ip pool情况
[root@k8s-h1 ~]# calicoctl get ipPool
CIDR                       
17.16.10.0/16              
192.10.160.0/16            
192.168.0.0/16             
fd80:24e2:f998:72d6::/64   [root@k8s-h1 ~]# calicoctl get ipPool -o wide
CIDR                       NAT     IPIP    
17.16.10.0/16              true    true    
192.10.160.0/16            true    true    
192.168.0.0/16             true    false   
fd80:24e2:f998:72d6::/64   false   false 接着在上面创建的ip pool里创建子网络。
可以从两个中选择一个或全部去创建子网络。
如下创建了calico-net1，calico-net2两个不同的网络。
创建命令可以在任意一个节点上执行即可。
由于两个节点使用的是同一套etcd，所以子网络创建后，在另一个节点上可以通过docker network ls命令查看到生成的网络信息：[root@k8s-h1 ~]# docker network create --driver calico --ipam-driver calico-ipam --subnet 17.16.10.0/24 calico-net1    
c031586cd4ee5d7008a4c1152cfb12b937a8f166b0c30febef8f9021b4f868ae[root@k8s-h1 ~]# docker network create --driver calico --ipam-driver calico-ipam --subnet 192.10.160.0/24 calico-net2
cd2a0ff8bc56261fb54cac566859c75fec87e87c99fa8c69b728b111f0138e05参数解释：
--driver calico：    网络使用 calico 驱动
--ipam-driver calico-ipam：   指定使用 calico 的 IPAM 驱动管理 IP
--subnet：指定calico-net1、calico-net2、calico-net3的 IP 段
calico-net1、calico-net2、calico-net3是 global 网络，etcd 会将它们三个同步到所有主机在其他节点上查看docker网络
[root@k8s-h2 ~]# docker network ls
NETWORK ID          NAME               DRIVER            SCOPE
63547f626d3c        bridge             bridge            local
c031586cd4ee        calico-net1        calico            global
cd2a0ff8bc56        calico-net2        calico            global
a85c2efa2a9a        host               host              local
60ee2962e292        none               null              local======================================================
温馨提示:如要想要删除docker网络
[root@k8s-h2 ~]# docker network --help删除的前提是,使用这些网络的docker容器必须删除,也就是说这些网络在没有被使用的前提下才能被成功删除!
[root@k8s-h2 ~]# docker network rm calico-net1
calico-net1
[root@k8s-h2 ~]# docker network rm calico-net2
calico-net2
[root@k8s-h1 ~]# docker network ls
NETWORK ID          NAME              DRIVER              SCOPE
a6a15884908d        bridge            bridge              local
3021c55e600f        host              host                local
6d3a0a8472c1        none              null                local
======================================================最后在各个节点上使用上面创建的子网去创建容器.
[root@k8s-h1 ~]# docker run -itd --net calico-net1 --name=docker-test1 nginx:latest
99a9b16b0fc0b162f177d8e6f5964f09f2a8a7a8621ed2391479ee7e45ae1105
[root@k8s-h1 ~]# docker run -itd --net calico-net2 --name=docker-test111 nginx:latest
fa5245a6f679a037ed890a34fc488b3aea03633eb7306b51099c4534ef53cb0a[root@k8s-h2 ~]# docker run -itd --net calico-net1 --name=docker-test2 nginx:latest
3628f90a7360524619bbcbc184c1d837bc84134734ad154ab0eb52f1c82ba165
[root@k8s-h2 ~]# docker run -itd --net calico-net2 --name=docker-test222 nginx:latest
c742f2d730edd61e0af7030ced100c480b18292bfe5676518f7e4f307b548868验证容器之间的通信
[root@k8s-h1 ~]# docker exec -ti docker-test1 /bin/bash
[root@19be6b264b6e /]# ifconfig
cali0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500inet 17.16.10.128  netmask 255.255.255.255  broadcast 0.0.0.0[root@k8s-h2 ~]# docker exec -ti docker-test2 /bin/bash
[root@0d1355e8d628 /]# ifconfig
cali0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500inet 17.16.10.0  netmask 255.255.255.255  broadcast 0.0.0.0[root@0d1355e8d628 /]# ping 17.16.10.128
PING 17.16.10.128 (17.16.10.128) 56(84) bytes of data.
64 bytes from 17.16.10.128: icmp_seq=1 ttl=62 time=0.528 ms
64 bytes from 17.16.10.128: icmp_seq=2 ttl=62 time=0.375 ms[root@0d1355e8d628 /]# ping 17.16.10.0
PING 17.16.10.0 (17.16.10.0) 56(84) bytes of data.
64 bytes from 17.16.10.0: icmp_seq=1 ttl=62 time=0.502 ms
64 bytes from 17.16.10.0: icmp_seq=2 ttl=62 time=0.405 ms[root@0d1355e8d628 /]# ping 172.16.60.215
PING 172.16.60.215 (172.16.60.215) 56(84) bytes of data.
64 bytes from 172.16.60.215: icmp_seq=1 ttl=63 time=0.294 ms
64 bytes from 172.16.60.215: icmp_seq=2 ttl=63 time=0.261 ms[root@0d1355e8d628 /]# ping 172.16.60.216
PING 172.16.60.216 (172.16.60.216) 56(84) bytes of data.
64 bytes from 172.16.60.216: icmp_seq=1 ttl=63 time=0.314 ms
64 bytes from 172.16.60.216: icmp_seq=2 ttl=63 time=0.255 ms[root@0d1355e8d628 /]# ping 172.16.60.217
PING 172.16.60.217 (172.16.60.217) 56(84) bytes of data.
64 bytes from 172.16.60.217: icmp_seq=1 ttl=63 time=0.605 ms
64 bytes from 172.16.60.217: icmp_seq=2 ttl=63 time=0.230 ms温馨提示:
同一网络内的容器（即使不在同一节点主机上）可以使用容器名来访问
[root@k8s-h1 ~]# docker exec -ti docker-test1 ping -c 2 docker-test2.calico-net1
PING docker-test2.calico-net1 (17.16.10.0) 56(84) bytes of data.
64 bytes from docker-test2.calico-net1 (17.16.10.0): icmp_seq=1 ttl=62 time=0.372 ms
64 bytes from docker-test2.calico-net1 (17.16.10.0): icmp_seq=2 ttl=62 time=0.335 ms[root@k8s-h1 ~]# docker exec -ti docker-test1 ping -c 2 docker-test2.calico-net1
PING docker-test3.calico-net1 (17.16.10.192) 56(84) bytes of data.
64 bytes from docker-test3.calico-net1 (17.16.10.192): icmp_seq=1 ttl=62 time=0.475 ms
64 bytes from docker-test3.calico-net1 (17.16.10.192): icmp_seq=2 ttl=62 time=0.385 ms[root@k8s-h2 ~]# docker exec -ti docker-test22 ping -c 2 docker-test11.calico-net2
PING docker-test11.calico-net2 (173.20.19.128) 56(84) bytes of data.
64 bytes from docker-test11.calico-net2 (173.20.19.128): icmp_seq=1 ttl=62 time=0.458 ms
64 bytes from docker-test11.calico-net2 (173.20.19.128): icmp_seq=2 ttl=62 time=0.318 ms顺便查看下各个节点上的路由情况
[root@k8s-h1 ~]# route -n
[root@k8s-h2 ~]# route -n

测试时遇到的一个坑:
如上步骤操作后,发现同一个网络中容器之间ping不通,容器也ping不通各宿主机的ip. 明明已经关闭了节点的防火墙! 最后发现是因为节点的主机名和ETCD_NAME以及calico容器启动时的NODENAME的名称不一样导致的! 需将节点主机名和ETCD_NAME以及NODENAME保持一样的名称就解决了. 或者说三者名称可以不一样,但是必须在/etc/hosts文件了做映射,将ETCD_NAME以及calico启动的NODENAME映射到本节点的ip地址上.

测试结论:

1. 同一个网段中容器能相互ping的通 (即使不在同一个节点上,只要创建容器时使用的是同一个子网段);
2. 不在同一个子网段里的容器是相互ping不通的 (即使在同一个节点上,但是创建容器时使用的是不同子网段);
3. 宿主机能ping通它自身的所有容器ip,但不能ping通其他节点上的容器ip;
4. 所有节点的容器都能ping通其他节点宿主机的ip (包括容器自己所在的宿主机的ip)。

也就是说，Calico默认配置下，只允许位于同一个网络中的容器之间通信，这样即实现了容器的跨主机互连, 也能更好的达到网络隔离效果。如果位于不同网络下的容器要想通信，只能依赖Calico的Policy策略来实现了，它强大的Policy能够实现几乎任意场景的访问控制！