Kubernetes IPAM分配IP原理
IPAM是k8s cni插件中负责分配ip的一类插件,其实现有dhcp,host-local等
IPAM host-local分配IP原理
Kube-controller-manager为每个节点分配一个podCIDR。从podCIDR中的子网值中为节点上的Pod分配IP地址。由于所有节点上的podCIDR是不相交的子网,因此它允许为每个pod分配唯一的IP地址。
先看pod创建过程:
1、kubelet收到创建Pod的事件,调用CRI接口,Docker或者其他的容器运行时发起对Pod的创建;
2、后端Docker创建网络空间network namespace;
3、CRI调用CNI插件,会传入刚刚创建好的网络空间network namespace;
4、CNI插件会读取Node节点/etc/cni/net.d路径下的配置文件,配置Pod网络,
实现Pod网络到Node节点网络的打通,同时拿到Pod的IP;
5、Docker创建Pause容器,每一个Pod在启动时都会有一个基础的Pause容器,
把Pause容器加入到网络空间中,后续其他的容器都会公用Pause容器的网络空间。
host-local为啥叫host-local
host-local插件从address ranges 中分配IP,将分配的结果存在本地机器,所以这也是为什么叫做host-local
毕竟如果没有地方进行纪录来进行比较,就没有办法每次都回传一个没有被用过的IP地址。
host-local example
dataDir的变数会指定要用哪个资料夹作为host-local记录用过的资讯,预设值是/var/lib/cni/networks/ .
{
"ipam": {
"type": "host-local",
"ranges": [
[
{
"subnet": "10.10.0.0/16",
"rangeStart": "10.10.1.20",
"rangeEnd": "10.10.3.50",
"gateway": "10.10.0.254"
},
{
"subnet": "172.16.5.0/24"
}
],
[
{
"subnet": "3ffe:ffff:0:01ff::/64",
"rangeStart": "3ffe:ffff:0:01ff::0010",
"rangeEnd": "3ffe:ffff:0:01ff::0020"
}
]
],
"routes": [
{ "dst": "0.0.0.0/0" },
{ "dst": "192.168.0.0/16", "gw": "10.10.5.1" },
{ "dst": "3ffe:ffff:0:01ff::1/64" }
],
"dataDir": "/run/my-ipam-path"
}
}
// 没有特别指定dataDir,所有的档案都会存放在/var/lib/cni/networks/里面
$ sudo find /var/lib/cni/networks/ -type f
/var/lib/cni/networks/last_reserved_ip.0
/var/lib/cni/networks/10.10.1.1
/var/lib/cni/networks/10.10.1.2
/var/lib/cni/networks/10.10.1.3
我们可以观察到,每个被用过的IP都会产生一个以该IP为名的文件,该档案中的内容非常简单,
就是使用的container ID
还可以观察到一个名为last_reserved_ip的文件,用来记住每个range目前分配的最后一个IP是哪个
在k8s node上进行验证
$ kubectl describe nodes | grep PodCIDR
PodCIDR: 10.244.0.0/24
PodCIDR: 10.244.1.0/24
PodCIDR: 10.244.2.0/24
$ sudo cat /run/flannel/subnet.env
FLANNEL_NETWORK=10.244.0.0/16
FLANNEL_SUBNET=10.244.0.1/24
FLANNEL_MTU=1450
FLANNEL_IPMASQ=true
$ sudo ls /var/lib/cni/networks/cbr0
10.244.0.2 10.244.0.3 10.244.0.8 last_reserved_ip.0 lock
$ sudo cat /var/lib/cni/networks/cbr0/10.244.0.8
2d39d5afb81e56314a7fd6bdd57c9ccf6d02c32b556273cfb6b9bb8a248c851b
$ sudo docker ps --no-trunc | grep $(sudo cat /var/lib/cni/networks/cbr0/10.244.0.8)
2d39d5afb81e56314a7fd6bdd57c9ccf6d02c32b556273cfb6b9bb8a248c851b k8s.gcr.io/pause:3.1 "/pause" Up 4 hours k8s_POD_k8s-udpserver-6576555bcb-7h8jh_default_87196597-ccda-4643-ac5d-85343a3b6c90_0
解析:
* 每个节点上都有一个PodCIDR的栏位,代表的是该节点可以使用的网段
* 节点是对应到的PodCIDR是10.244.0.0/24,与/run/flannel/subnet.env里面的数值一致。
* 查看下ipam分配ip后为每个ip生成的记录文件,内容是一个id
* docker查看,可以发现是pod里对应的container的id
host-local如何知道上一次分配到ip是哪个
host-local会在宿主机生成一个记录文件:/var/lib/cni/networks/last_reserved_ip.0
cni官方文档对host-local的简述
host-local IPAM plugin allocates ip addresses out of a set of address ranges. It stores the state locally on the host filesystem, therefore ensuring uniqueness of IP addresses on a single host. The allocator can allocate multiple ranges, and supports sets of multiple (disjoint) subnets. The allocation strategy is loosely round-robin within each range set.
下文对官方文档中的 round-robin 算法原理进行剖析
IP分配算法:round-robin
轮询调度(Round Robin Scheduling)算法就是以轮询的方式依次将请求调度不同的服务器,即每次调度执行i = (i + 1) mod n,并选出第i台服务器。 算法的优点是其简洁性,它无需记录当前所有连接的状态,所以它是一种无状态调度。
host-local会根据参数给予的IP范围,依序回传一个没有被使用过的IP, 这个运作原理非常的符合我们真正的需求,每次有POD产生的时候都可以得到一个没有被使用过的IP地址,避免重复同时又能够使用。
IPAM host-local round-robin分配
源码剖析:
// 分配一个ip
func (a *IPAllocator) Get(id string, ifname string, requestedIP net.IP) (*current.IPConfig, error) {
a.store.Lock()
defer a.store.Unlock()
var reservedIP *net.IPNet
var gw net.IP
// 如果请求ip不为空,则查看请求的ip是否满足分配的条件
if requestedIP != nil {
if err := canonicalizeIP(&requestedIP); err != nil {
return nil, err
}
r, err := a.rangeset.RangeFor(requestedIP)
if err != nil {
return nil, err
}
if requestedIP.Equal(r.Gateway) {
return nil, fmt.Errorf("requested ip %s is subnet's gateway", requestedIP.String())
}
reserved, err := a.store.Reserve(id, ifname, requestedIP, a.rangeID)
if err != nil {
return nil, err
}
if !reserved {
return nil, fmt.Errorf("requested IP address %s is not available in range set %s", requestedIP, a.rangeset.String())
}
reservedIP = &net.IPNet{IP: requestedIP, Mask: r.Subnet.Mask}
gw = r.Gateway
// 否则分配一个新的未使用的ip回去
} else {
...
...
// 获取迭代器,迭代器指向上一个分配的ip
iter, err := a.GetIter()
if err != nil {
return nil, err
}
for {
// 迭代器的下一个ip就是要分配出去的ip
reservedIP, gw = iter.Next()
if reservedIP == nil {
break
}
reserved, err := a.store.Reserve(id, ifname, reservedIP.IP, a.rangeID)
if err != nil {
return nil, err
}
if reserved {
break
}
}
}
if reservedIP == nil {
return nil, fmt.Errorf("no IP addresses available in range set: %s", a.rangeset.String())
}
return ¤t.IPConfig{
Address: *reservedIP,
Gateway: gw,
}, nil
}
// 获取迭代器
// 迭代器指向的ip就是上一个分配的ip
func (a *IPAllocator) GetIter() (*RangeIter, error) {
iter := RangeIter{
rangeset: a.rangeset,
}
// Round-robin by trying to allocate from the last reserved IP + 1
startFromLastReservedIP := false
// 迭代器指向的ip就是上一个分配的ip
// 原理是读取本地的/var/lib/cni/networks/last_reserved_ip.0
lastReservedIP, err := a.store.LastReservedIP(a.rangeID)
// Find the range in the set with this IP
// 如果存在上一个分配的ip,则迭代器指向上一个分配的ip,否则指向第一个ip
if startFromLastReservedIP {
for i, r := range *a.rangeset {
if r.Contains(lastReservedIP) {
iter.rangeIdx = i
// We advance the cursor on every Next(), so the first call
// to next() will return lastReservedIP + 1
iter.cur = lastReservedIP
break
}
}
} else {
iter.rangeIdx = 0
iter.startIP = (*a.rangeset)[0].RangeStart
}
return &iter, nil
}
// 从迭代器获取其下一个ip作为分配的ip
// 迭代器指向的ip是上一次分配的ip,其下一个ip就是round-robin算法的下一个ip
func (i *RangeIter) Next() (*net.IPNet, net.IP) {
r := (*i.rangeset)[i.rangeIdx]
// 如果是第一次分配,则取第一个ip
if i.cur == nil {
i.cur = r.RangeStart
i.startIP = i.cur
if i.cur.Equal(r.Gateway) {
return i.Next()
}
return &net.IPNet{IP: i.cur, Mask: r.Subnet.Mask}, r.Gateway
}
// 如果到了末端,则重头开始
if i.cur.Equal(r.RangeEnd) {
// 这里是round-robin算法的实现
i.rangeIdx += 1
i.rangeIdx %= len(*i.rangeset)
r = (*i.rangeset)[i.rangeIdx]
i.cur = r.RangeStart
// 如果没到末端,则取下一个ip
} else {
i.cur = ip.NextIP(i.cur)
}
if i.startIP == nil {
i.startIP = i.cur
} else if i.cur.Equal(i.startIP) {
// IF we've looped back to where we started, give up
return nil, nil
}
if i.cur.Equal(r.Gateway) {
return i.Next()
}
return &net.IPNet{IP: i.cur, Mask: r.Subnet.Mask}, r.Gateway
}
总结:每次从本地读取/var/lib/cni/networks/last_reserved_ip.0文件,获取上一次分配的ip,然后其下一个ip就是要分配出去的,如果没有上一次分配的ip,则获取第一个ip分配出去
k8s如何保证pod ip不重复
1、kubernetes会针对每个node去标示一个名为PodCIDR的值,代表该Node可以使用的网段是什么,且分配的时候保证为每个pod分配不同的段
2、flannel的Pod 会去读取node中的PodCIDR,并且将该资讯写道/run/flannel/subnet.env中,
flannel CNI收到任何创建Pod的请求时,会去读取/run/flannel/subnet.env,flannel CNI会调用bridge CNI,bridge CNI会调用host-local CNI,host-local CNI使用round-robin保证同一个node上的pod的ip不重复
为什么使用round-robin,而不是每次取最小的未分配的ip
因为CNI回收ip和docker回收容器两个操作不是一个原子性的操作!
假设有一个pod用了10.244.1.1,然后这个pod被删除了,然后CNI插件释放这个ip,docker释放这个容器,但是有可能docker还没完全释放这个容器的时候,CNI先完成了ip的释放并且这时候又有新的pod创建出来,那么新的pod可能用了10.244.1.1这个ip,但是旧的正在被释放容器也在用这个ip,就可能出现冲突和数据混乱