Calico是一个纯三层的协议，为OpenStack虚机和Docker容器提供多主机间通信。Calico不使用重叠网络比如flannel和libnetwork重叠网络驱动，它是一个纯三层的方法，使用虚拟路由代替虚拟交换，每一台虚拟路由通过BGP协议传播可达信息（路由）到剩余数据中心。Calico还提供网络安全规则的动态实施。使用Calico的简单策略语言，您可以实现对容器，虚拟机工作负载和裸机主机端点之间通信的细粒度控制。
Calico在大规模生产方面经过验证，可与Kubernetes，OpenShift，Docker，Mesos，DC / OS和OpenStack集成

calico3.0 开始不支持docker部署，使用k8s。 https://blog.51cto.com/ckl893/2334883最后安装calico 最新不支持

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 依赖 etcd 在不同主机间共享和交换信息，存储 Calico 网络状态。我们将在 host 192.168.1.121上运行 etcd。
Calico 网络中的每个主机都需要运行 Calico 组件，提供容器 interface 管理、动态路由、动态 ACL、报告状态等功能。
实验环境如下图所示：

软件版本：
calicoctl（version v1.6.5） etcdctl（etcdctl version: 3.3.11） docker（version：19.03.8）

1）机器环境（centos7系统）本环境单etcd的部署（可以etcd集群部署）

192.168.1.121 部署etcd,docker 主机名：etcd

192.168.1.122 部署calicoctl，docker 主机名：host1

192.168.1.123 部署calicoctl，docker 主机名：host1

2）etcd（192.168.1.121）机器操作

设置主机名及绑定hosts
[root@etcd ~]# hostnamectl --static set-hostname  etcd
[root@etcd ~]# vim /etc/hosts
192.168.1.121    etcd
192.168.1.122    host1
192.168.1.123    host2  
关闭防火墙，如果开启防火墙，则最好打开2379和4001端口
[root@etcd ~]# systemctl disable firewalld.service
[root@etcd ~]# systemctl stop firewalld.service  
安装etcd
k8s运行依赖etcd，需要先部署etcd，下面采用yum方式安装：
[root@etcd ~]# yum install etcd -y    
yum安装的etcd默认配置文件在/etc/etcd/etcd.conf，编辑配置文件：
[root@etcd ~]# cp /etc/etcd/etcd.conf /etc/etcd/etcd.conf.bak

[root@etcd ~]# vim /etc/etcd/etcd.conf 
#[Member]
#ETCD_CORS=""
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
#ETCD_WAL_DIR=""
#ETCD_LISTEN_PEER_URLS="http://localhost:2380"
ETCD_LISTEN_CLIENT_URLS="http://192.168.1.121:2379"
......
ETCD_ADVERTISE_CLIENT_URLS="http://192.168.1.121:2379"
......

启动etcd服务

    [root@etcd ~]# systemctl start etcd && systemctl enable etcd

查看版本

[root@etcd ~]# etcdctl --v
etcdctl version: 3.3.11
API version: 2

修改 host1 和 host2 的 Docker daemon 配置文件
连接 etcd：–cluster-store=etcd://192.168.1.121:2379

[root@host1 ~]# vim /etc/docker/daemon.json
{
"registry-mirrors": ["http://f1361db2.m.daocloud.io"],
"cluster-store": "etcd://192.168.1.121:2379"
}
#注意如果是集群的话后面就etcd1://192.168.1.121:2379,etcd12://192.168.1.122:2379,etcd3://192.168.1.123:2379

说明：第一行的registry-mirrors是配置docker镜像加速以后自动添加的。
重启 Docker daemon

systemctl daemon-reload && systemctl restart docker.service

查看配置是否正确

    [root@host1 ~]# docker info | grep "Cluster Store"
    Cluster Store: etcd://192.168.1.121:2379
    [root@host1 ~]#

部署calicoctl
官方参考文档：https://docs.projectcalico.org/v2.6/getting-started/docker/installation/manual
在host1和host2上下载calicoctl并运行calico容器。
下载calicoctl

[root@host1 ~]# wget -O /usr/local/bin/calicoctl https://github.com/projectcalico/calicoctl/releases/download/v1.6.5/calicoctl
[root@host1 ~]# chmod +x /usr/local/bin/calicoctl
[root@host1 ~]# /usr/local/bin/calicoctl --version
calicoctl version v1.6.5, build 614fcf12

创建calico容器
首先创建calico配置文件

[root@host1 ~]# mkdir /etc/calico/
[root@host1 ~]# vim /etc/calico/calicoctl.cfg
apiVersion: v1
kind: calicoApiConfig
metadata:
spec:
  datastoreType: "etcdv2"
  etcdEndpoints: "http://etcd:2379"
#如果是集群的话etcdEndpoints: "http://etcd1:2379,http://etcd3:2379,http://etcd3:2379"

分别在两个节点上创建calico容器,执行后会自动下载calico镜像并运行容器，下载镜像可能较慢，建议配置镜像加速，启动过程如下：

[root@host1 ~]# ETCD_ENDPOINTS=http://192.168.1.121:2379  calicoctl node run --node-image=quay.io/calico/node:v2.6.12
Running command to load modules: modprobe -a xt_set ip6_tables
Enabling IPv4 forwarding
Enabling IPv6 forwarding
Increasing conntrack limit
Removing old calico-node container (if running).
Running the following command to start calico-node:

docker run --net=host --privileged --name=calico-node -d --restart=always -e NODENAME=host1 -e CALICO_NETWORKING_BACKEND=bird -e CALICO_LIBNETWORK_ENABLED=true -e ETCD_ENDPOINTS=http://etcd: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.12

Image may take a short time to download if it is not available locally.
chmod +x /usr/local/bin/calicoctlContainer started, checking progress logs.

2020-03-12 14:05:53.467 [INFO][8] startup.go 173: Early log level set to info
2020-03-12 14:05:53.468 [INFO][8] client.go 202: Loading config from environment
2020-03-12 14:05:53.468 [INFO][8] startup.go 83: Skipping datastore connection test
2020-03-12 14:05:53.515 [INFO][8] startup.go 259: Building new node resource Name="host1"
2020-03-12 14:05:53.515 [INFO][8] startup.go 273: Initialise BGP data
2020-03-12 14:05:53.516 [INFO][8] startup.go 467: Using autodetected IPv4 address on interface ens33: 192.168.1.122/24
2020-03-12 14:05:53.516 [INFO][8] startup.go 338: Node IPv4 changed, will check for conflicts
2020-03-12 14:05:53.586 [INFO][8] startup.go 530: No AS number configured on node resource, using global value
2020-03-12 14:05:53.591 [INFO][8] etcd.go 111: Ready flag is already set
2020-03-12 14:05:53.598 [INFO][8] client.go 139: Using previously configured cluster GUID
2020-03-12 14:05:53.800 [INFO][8] compat.go 796: Returning configured node to node mesh
2020-03-12 14:05:53.812 [INFO][8] startup.go 131: Using node name: host1
2020-03-12 14:05:54.367 [INFO][12] client.go 202: Loading config from environment
Starting libnetwork service
Calico node started successfully

1.设置主机网络，例如 enable IP forwarding。
2.下载并启动 calico-node 容器，calico 会以容器的形式运行（与 weave 类似）。

[root@host1 ~]# docker images
REPOSITORY            TAG                 IMAGE ID            CREATED             SIZE
quay.io/calico/node   v2.6.12             401cc3e56a1a        16 months ago       281MB
[root@host1 ~]# docker ps
CONTAINER ID        IMAGE                         COMMAND             CREATED             STATUS              PORTS               NAMES
31ebe797a3f6        quay.io/calico/node:v2.6.12   "start_runit"       About an hour ago   Up About an hour                        calico-node

3.连接 etcd。
4.calico 启动成功。

查看calico运行状态

host1

[root@host1 ~]# calicoctl node status
Calico process is running.

IPv4 BGP status
+---------------+-------------------+-------+----------+-------------+
| PEER ADDRESS  |     PEER TYPE     | STATE |  SINCE   |    INFO     |
+---------------+-------------------+-------+----------+-------------+
| 192.168.1.123 | node-to-node mesh | up    | 14:24:10 | Established |
+---------------+-------------------+-------+----------+-------------+

IPv6 BGP status
No IPv6 peers found.

[root@host1 ~]#

host2

root@host2 ~]# calicoctl node status
Calico process is running.

IPv4 BGP status
+---------------+-------------------+-------+----------+-------------+
| PEER ADDRESS  |     PEER TYPE     | STATE |  SINCE   |    INFO     |
+---------------+-------------------+-------+----------+-------------+
| 192.168.1.122 | node-to-node mesh | up    | 14:14:18 | Established |
+---------------+-------------------+-------+----------+-------------+

IPv6 BGP status
No IPv6 peers found.

[root@host2 ~]#

创建 calico 网络

在 host1 或 host2 上执行如下命令创建 calico 网络 cal_ent1：

docker network create --driver calico --ipam-driver calico-ipam cal_net1

–driver calico 指定使用 calico 的 libnetwork CNM driver。
–ipam-driver calico-ipam 指定使用 calico 的 IPAM driver 管理 IP

calico 为 global 网络，etcd 会将 cal_net 同步到所有主机。

host2创建的calico 网络 cal_ent1

[root@host2 ~]# docker network create --driver calico --ipam-driver calico-ipam cal_net1
9d3a6bbd6b7038b0b57f6d0828fa4f3b9938849b6dd307630fa380c7aefd59d3
[root@host2 ~]# docker network ls 
NETWORK ID          NAME                DRIVER              SCOPE
1e21a697f52c        bridge              bridge              local
9d3a6bbd6b70        cal_net1            calico              global
e75a72e83f90        host                host                local
ac72879f7ab4        none                null                local

一会之后同步的到host1

知识补充

还有一种方式连接 etcd是修改 host1 和 host2 的 Docker daemon 配置文件/usr/lib/systemd/system/docker.service，连接 etcd：

Calico网络结构

在 host1 中运行容器 bbox1 并连接到 cal_net1

在 host1 中运行容器 bbox1 并连接到 cal_net1：

[root@host1 ~]# docker  run --net cal_net1 --name bbox1 -tid busybox
Unable to find image 'busybox:latest' locally
latest: Pulling from library/busybox
Image docker.io/library/busybox:latest uses outdated schema1 manifest format. Please upgrade to a schema2 image for better future compatibility. More information at https://docs.docker.com/registry/spec/deprecated-schema-v1/
0669b0daf1fb: Downloading 
latest: Pulling from library/busybox
0669b0daf1fb: Pull complete 
Digest: sha256:b26cd013274a657b86e706210ddd5cc1f82f50155791199d29b9e86e935ce135
Status: Downloaded newer image for busybox:latest
1969344ac07a316f307747b2ccc98236a09f0c4b5ed817c9e20879124ae93d8f

查看 bbox1 的网络配置。

[root@host1 ~]# docker exec bbox1 ip a
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
4: cali0@if5: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue 
    link/ether ee:ee:ee:ee:ee:ee brd ff:ff:ff:ff:ff:ff
    inet 192.168.119.0/32 brd 192.168.119.0 scope global cali0
       valid_lft forever preferred_lft forever

cali0 是 calico interface，分配的 IP 为 192.168.119.0。cali0 对应 host1 编号5 的 interface cali2e56c77f53e。

[root@host1 ~]# ip a
..........
5: cali2e56c77f53e@if4: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 5e:42:5b:ba:c5:4c brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet6 fe80::5c42:5bff:feba:c54c/64 scope link 
       valid_lft forever preferred_lft forever

host1 将作为 router 负责转发目的地址为 bbox1 的数据包。

[root@host1 ~]# ip route
default via 192.168.1.1 dev ens33 proto static metric 100 
172.17.0.0/16 dev docker0 proto kernel scope link src 172.17.0.1 
192.168.1.0/24 dev ens33 proto kernel scope link src 192.168.1.122 metric 100 
192.168.119.0 dev cali2e56c77f53e scope link 
blackhole 192.168.119.0/26 proto bird

所有发送到 bbox1 的数据都会发给cali2e56c77f53e，因为cali2e56c77f53e 与 cali0 是一对 veth pair，bbox1 能够接收到数据。
接下来我们在 host2 中运行容器 bbox2，也连接到 cal_net1：

[root@host2 ~]# docker  run --net cal_net1 --name bbox2 -tid busybox

IP 为 192.168.183.64。

[root@host2 ~]# docker exec bbox2 ip a 
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
4: cali0@if5: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue 
    link/ether ee:ee:ee:ee:ee:ee brd ff:ff:ff:ff:ff:ff
    inet 192.168.183.64/32 brd 192.168.183.64 scope global cali0
       valid_lft forever preferred_lft forever
[root@host2 ~]

[root@host2 ~]# ip route
default via 192.168.1.1 dev ens33 proto static metric 100 
172.17.0.0/16 dev docker0 proto kernel scope link src 172.17.0.1 
192.168.1.0/24 dev ens33 proto kernel scope link src 192.168.1.123 metric 100 
192.168.119.0/26 via 192.168.1.122 dev ens33 proto bird 
192.168.183.64 dev cali46ba0d99f46 scope link 
blackhole 192.168.183.64/26 proto bird

目的地址为 host1 容器 subnet 192.168.119.0/26 的路由。
目的地址为本地 bbox2 容器 192.168.183.64 的路由。

同样的，host1 也自动添加了到 192.168.183.64/26 的路由

[root@host1 ~]# ip route
default via 192.168.1.1 dev ens33 proto static metric 100 
172.17.0.0/16 dev docker0 proto kernel scope link src 172.17.0.1 
192.168.1.0/24 dev ens33 proto kernel scope link src 192.168.1.122 metric 100 
192.168.119.0 dev cali2e56c77f53e scope link 
blackhole 192.168.119.0/26 proto bird 
192.168.183.64/26 via 192.168.1.123 dev ens33 proto bird

Calico 的默认连通性

测试一下 bbox1 与 bbox2 的连通性：

[root@host1 ~]# docker exec bbox1 ping -c 4 bbox2
PING bbox2 (192.168.183.64): 56 data bytes
64 bytes from 192.168.183.64: seq=0 ttl=62 time=24.472 ms
64 bytes from 192.168.183.64: seq=1 ttl=62 time=0.573 ms
64 bytes from 192.168.183.64: seq=2 ttl=62 time=0.553 ms
64 bytes from 192.168.183.64: seq=3 ttl=62 time=0.467 ms

--- bbox2 ping statistics ---
4 packets transmitted, 4 packets received, 0% packet loss
round-trip min/avg/max = 0.467/6.516/24.472 ms
[root@host1 ~]#

① 根据 bbox1 的路由表，将数据包从 cal0 发出。

[root@host1 ~]# docker exec bbox1 ip route
default via 169.254.1.1 dev cali0
169.254.1.1 dev cali0 scope link
[root@host1 ~]#
② 数据经过 veth pair 到达 host1，查看路由表，数据由 ens33发给 host2（192.168.1.123）。
192.168.183.64/26 via 192.168.1.123 dev ens33 proto bird
③ host2 收到数据包，根据路由表发送给 cali2e56c77f53e，进而通过 veth pair cali0 到达 bbox2。
192.168.183.64 dev cali46ba0d99f46 scope link
接下来我们看看不同 calico 网络之间的连通性。
创建 cal_net2。

创建 cal_net2。

    docker network create --driver calico --ipam-driver calico-ipam cal_net2

在 host1 中运行容器 bbox3，连接到 cal_net2：

    docker  run --net cal_net2 --name bbox3 -tid busybox

calico 为 bbox3 分配了 IP 192.168.119.1

[root@host1 ~]# docker exec bbox3 ip address show cali0
6: cali0@if7: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue 
    link/ether ee:ee:ee:ee:ee:ee brd ff:ff:ff:ff:ff:ff
    inet 192.168.119.1/32 brd 192.168.119.1 scope global cali0
       valid_lft forever preferred_lft forever

验证 bbox1 与 bbox3 的连通性。

    [root@host1 ~]# docker exec bbox1 ping -c 4 bbox3
    ping: bad address 'bbox3'
    [root@host1 ~]#

虽然 bbox1 和 bbox3 都位于 host1，而且都在一个 subnet 192.168.119.0/26，但它们属于不同的 calico 网络，默认不能通行。
calico 默认的 policy 规则是：容器只能与同一个 calico 网络中的容器通信。
calico 的每个网络都有一个同名的 profile，profile 中定义了该网络的 policy。我们具体看一下 cal_net1 的 profile：

[root@host1 ~]# calicoctl get profile cal_net1 -o yaml
- apiVersion: v1
  kind: profile
  metadata:
    name: cal_net1
    tags:
    - cal_net1
  spec:
    egress:
    - action: allow
      destination: {}
      source: {}
    ingress:
    - action: allow
      destination: {}
      source:
        tag: cal_net1
[root@host1 ~]#

① 命名为 cal_net1，这就是 calico 网络 cal_net1 的 profile。
② 为 profile 添加一个 tag cal_net1。注意，这个 tag 虽然也叫 cal_net1，其实可以随便设置，这跟上面的 name: cal_net1 没有任何关系。此 tag 后面会用到。
③ egress 对从容器发出的数据包进行控制，当前没有任何限制。
④ ingress 对进入容器的数据包进行限制，当前设置是接收来自 tag cal_net1 的容器，根据第 ① 步设置我们知道，实际上就是只接收本网络的数据包，这也进一步解释了前面的实验结果。
既然这是默认 policy，那就有方法定制 policy，这也是 calico 较其他网络方案最大的特性。下一节就我们讨论如何定制 calico policy。

定制 Calico 网络 Policy

Calico 默认的 policy 规则是：容器只能与同一个 calico 网络中的容器通信。calico 能够让用户定义灵活的 policy 规则，精细化控制进出容器的流量，下面我们就来实践一个场景：
创建一个新的 calico 网络 cal_web 并部署一个 httpd 容器 web1。
定义 policy 允许 cal_net2 中的容器访问 web1 的 80 端口。
首先创建 cal_web。

[root@host1 ~]# docker network create --driver calico --ipam-driver calico-ipam cal_web 
086c6d54b84371425f5e6e60252b4e9f615ec28f88b2dd4976ccc39f755c19ae

在 host1 中运行容器 web1，连接到 cal_web：

[root@host1 ~]# docker  run --net cal_web --name web1 -d httpd
Digest: sha256:946c54069130dbf136903fe658fe7d113bd8db8004de31282e20b262a3e106fb
Status: Downloaded newer image for httpd:latest
535876687e3279889d28f7a5a4f2a063b2e03480877431dd43a5b06cf5a87907
[root@host1 ~]# docker exec -it web1 bash
root@535876687e32:/usr/local/apache2# apt-get update
root@535876687e32:/usr/local/apache2# apt-get install iproute
 ...
Setting up iproute2 (3.16.0-2) ...
Setting up libatm1:amd64 (1:2.5.1-1.5) ...
Setting up libxtables10 (1.4.21-2+b1) ...
Setting up iproute (1:3.16.0-2) ...
root@535876687e32:/usr/local/apache2# exit
exit
[root@host1 ~]#

web1 的 IP 为 192.168.119.2

[root@host1 ~]# docker container exec web1 ip address show cali0
8: cali0@if9: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether ee:ee:ee:ee:ee:ee brd ff:ff:ff:ff:ff:ff
    inet 192.168.119.2/32 brd 192.168.119.2 scope global cali0
       valid_lft forever preferred_lft forever

目前 bbox3 还无法访问 web1 的 80 端口。

[root@host1 ~]# docker exec bbox3 wget 192.168.119.2
Connecting to 192.168.119.2 (192.168.119.2:80)
wget: can't connect to remote host (192.168.119.2): Connection timed out
[root@host1 ~]#

创建 policy 文件 web.yml，内容为：

[root@host1 ~]# vim web.yml

- apiVersion: v1
  kind: profile
  metadata:
    name: cal_web
  spec:
    ingress:
    - action: allow
      protocol: tcp
      source:
        tag: cal_net2
      destination:
        ports:
        - 80

① profile 与 cal_web 网络同名，cal_web 的所有容器（web1）都会应用此 profile 中的 policy。
② ingress 允许 cal_net2 中的容器（bbox3）访问。
③ 只开放 80 端口。
应用该 policy。

[root@host1 ~]# calicoctl apply -f web.yml
Successfully applied 1 'profile' resource(s)

现在 bbox3 已经能够访问 web1 的 http 服务了。

[root@host1 ~]# docker exec bbox3 wget 192.168.119.2
Connecting to 192.168.119.2 (192.168.119.2:80)
saving to 'index.html'
index.html           100% |********************************|    45  0:00:00 ETA
'index.html' saved

不过 ping 还是不行，因为只放开了 80 端口。

[root@host1 ~]# docker  exec bbox3 ping -c 4 192.168.119.2
PING 192.168.119.2 (192.168.119.2): 56 data bytes

--- 192.168.119.2 ping statistics ---
4 packets transmitted, 0 packets received, 100% packet loss

上面这个例子比较简单，不过已经向我们展示了 calico 强大的 policy 功能。通过 policy，可以动态实现非常复杂的容器访问控制。有关 calico policy 更多的配置，可参看官网文档 http://docs.projectcalico.org/v2.0/reference/calicoctl/resources/policy

定制 Calico IP 池

calico 会为自动为网络分配 subnet，当然我们也可以定制。
首先定义一个 IP Pool，比如：

[root@host1 ~]# vim ipPool.yaml

- apiVersion: v1
  kind: ipPool
  metadata:
    cidr: 17.2.0.0/16
[root@host1 ~]# calicoctl create -f ipPool.yaml
Successfully created 1 'ipPool' resource(s)
[root@host1 ~]#

用此 IP Pool 创建 calico 网络。

[root@host1 ~]# docker network create --driver calico --ipam-driver calico-ipam --subnet=17.2.0.0/16 my_net
b1d91494b9446243dc6bf7e181de4f6d7d9f8c421732ee35b0e2f33e15bd2111

此时运行容器将分配到指定 subnet 中的 IP。

[root@host1 ~]# docker  run --net my_net -ti busybox
/ # ip address show cali0
10: cali0@if11: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue 
    link/ether ee:ee:ee:ee:ee:ee brd ff:ff:ff:ff:ff:ff
    inet 17.2.119.0/32 brd 17.2.119.0 scope global cali0
       valid_lft forever preferred_lft forever
/ #

当然也可以通过 --ip 为容器指定 IP，但必须在 subnet 范围之内。

[root@host1 ~]# docker  run --net my_net --ip 17.2.3.11 -ti busybox
/ # ip address show cali0
12: cali0@if13: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue 
    link/ether ee:ee:ee:ee:ee:ee brd ff:ff:ff:ff:ff:ff
    inet 17.2.3.11/32 brd 17.2.3.11 scope global cali0
       valid_lft forever preferred_lft forever
/ #

junior1206

发布了62 篇原创文章 · 获赞 10 · 访问量 2万+

私信关注

docker（7、容器网络5）Calico 网络单etcd 节点

Calico结构组成

Calico网络结构

Calico 的默认连通性

定制 Calico 网络 Policy

定制 Calico IP 池

猜你喜欢

docker（7、容器网络5）Calico 网络 单etcd 节点

Calico结构组成

Calico网络结构

Calico 的默认连通性

定制 Calico 网络 Policy

定制 Calico IP 池

猜你喜欢

docker（7、容器网络5）Calico 网络单etcd 节点