【kubernetes/k8s源码分析】CNI host-local源码分析

梦里梦外; 2022-04-22 03:08 230阅读 0赞

接着上章节假设host-local成功分配IP，这章节讲解host-local

源码地址: [https://github.com/containernetworking/plugins][https_github.com_containernetworking_plugins]

# 参数 #

{
        "name": "macvlannet",
        "cniVersion": "0.1.0",
        "type": "macvlan",
        "master": "eth0",
        "mode": "vepa",
        "ipam": {
            "type": "host-local",
            "subnet": "10.12.0.0/16",
            "rangeStart": "10.12.52.100",
            "rangeEnd": "10.12.52.250",
            "gateway": "10.12.51.11",
            "routes": [
                { "dst": "0.0.0.0/0" }
            ]
        }
    }

# 结构体 #

###   IPAMConfig结构体 ###

// IPAMConfig represents the IP related network configuration.
    // This nests Range because we initially only supported a single
    // range directly, and wish to preserve backwards compatability
    type IPAMConfig struct {
    	*Range
    	Name       string
    	Type       string         `json:"type"`
    	Routes     []*types.Route `json:"routes"`
    	DataDir    string         `json:"dataDir"`
    	ResolvConf string         `json:"resolvConf"`
    	Ranges     []RangeSet     `json:"ranges"`
    	IPArgs     []net.IP       `json:"-"` // Requested IPs from CNI_ARGS and args
    }

# 1. cmdAdd函数 #

###   1.1 LoadIPAMConifg函数 ###

就是将参数转为IPAMConfig结构体，参数如上所示

args.Args是额外参数如下所示：

*  IgnoreUnknown=1;
 *  K8S\_POD\_NAMESPACE=default;
 *  K8S\_POD\_NAME=httpserver-d-5b847cbb-v9jgk;
 *  K8S\_POD\_INFRA\_CONTAINER\_ID=eb7f3158ad80001dd498d970e1dd092605dae9edd2f036289eeaf0ac5947f8fa

ipamConf, confVersion, err := allocator.LoadIPAMConfig(args.StdinData, args.Args)
    	if err != nil {
    		return err
    	}

###   1.2 Result结构体 ###

Result主要是返回给调用者

// Result is what gets returned from the plugin (via stdout) to the caller
    type Result struct {
    	CNIVersion string         `json:"cniVersion,omitempty"`
    	Interfaces []*Interface   `json:"interfaces,omitempty"`
    	IPs        []*IPConfig    `json:"ips,omitempty"`
    	Routes     []*types.Route `json:"routes,omitempty"`
    	DNS        types.DNS      `json:"dns,omitempty"`
    }

###   1.3 disk.New函数 ###

主要是存储使用IP，以IP地址写入文件，以及最后一次IP记录，默认路径为/var/lib/cni/network/$\{ipamConf.Name\}

store, err := disk.New(ipamConf.Name, ipamConf.DataDir)
    	if err != nil {
    		return err
    	}
    	defer store.Close()

###   1.4 初始化IP分配器 ###

// Keep the allocators we used, so we can release all IPs if an error
    	// occurs after we start allocating
    	allocs := []*allocator.IPAllocator{}
    
    	// Store all requested IPs in a map, so we can easily remove ones we use
    	// and error if some remain
    	requestedIPs := map[string]net.IP{} //net.IP cannot be a key
    
    	for _, ip := range ipamConf.IPArgs {
    		requestedIPs[ip.String()] = ip
    	}

###   1.5 根据ip范围 ###

有指定IP地址，一般这里没有这个需求

allocator.Get函数第2章节讲解

for idx, rangeset := range ipamConf.Ranges {
    		allocator := allocator.NewIPAllocator(&rangeset, store, idx)
    
    		// Check to see if there are any custom IPs requested in this range.
    		var requestedIP net.IP
    		for k, ip := range requestedIPs {
    			if rangeset.Contains(ip) {
    				requestedIP = ip
    				delete(requestedIPs, k)
    				break
    			}
    		}
    
    		ipConf, err := allocator.Get(args.ContainerID, requestedIP)
    		if err != nil {
    			// Deallocate all already allocated IPs
    			for _, alloc := range allocs {
    				_ = alloc.Release(args.ContainerID)
    			}
    			return fmt.Errorf("failed to allocate for range %d: %v", idx, err)
    		}
    
    		allocs = append(allocs, allocator)
    
    		result.IPs = append(result.IPs, ipConf)
    	}

### 2. Get 函数 ###

路径 plugins/plugin/ipam/host-local/backend/allocator/allocator.go

###   2.1 指定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, 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
    
    	}

###    2.2 未指定IP分配，给啥要啥 ###

给啥IP也是按照套路，有记录，把分配的IP以IP作为文件占个坑位，表示已经分配的了

} else {
    		iter, err := a.GetIter()
    		if err != nil {
    			return nil, err
    		}
    		for {
    			reservedIP, gw = iter.Next()
    			if reservedIP == nil {
    				break
    			}
    
    			reserved, err := a.store.Reserve(id, reservedIP.IP, a.rangeID)
    			if err != nil {
    				return nil, err
    			}
    
    			if reserved {
    				break
    			}
    		}
    	}

# 3. GetIter函数 #

lastReservedIP读取文件/var/lib/cni/networks/macvlan-cni/last\_reserved\_ip.0，可能没有这个文件，那就从起始开始查找

// GetIter encapsulates the strategy for this allocator.
    // We use a round-robin strategy, attempting to evenly use the whole set.
    // More specifically, a crash-looping container will not see the same IP until
    // the entire range has been run through.
    // We may wish to consider avoiding recently-released IPs in the future.
    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
    
    	// We might get a last reserved IP that is wrong if the range indexes changed.
    	// This is not critical, we just lose round-robin this one time.
    	lastReservedIP, err := a.store.LastReservedIP(a.rangeID)
    	if err != nil && !os.IsNotExist(err) {
    		log.Printf("Error retrieving last reserved ip: %v", err)
    	} else if lastReservedIP != nil {
    		startFromLastReservedIP = a.rangeset.Contains(lastReservedIP)
    	}
    
    	// Find the range in the set with this IP
    	if startFromLastReservedIP {
    		for i, r := range *a.rangeset {
    			if r.Contains(lastReservedIP) {
    				iter.rangeIdx = i
    				iter.startRange = 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.startRange = 0
    		iter.startIP = (*a.rangeset)[0].RangeStart
    	}
    	return &iter, nil
    }

### 4. Next函数 ###

返回IP mask gateway简单粗暴

// Next returns the next IP, its mask, and its gateway. Returns nil
    // if the iterator has been exhausted
    func (i *RangeIter) Next() (*net.IPNet, net.IP) {
    	r := (*i.rangeset)[i.rangeIdx]
    
    	// If this is the first time iterating and we're not starting in the middle
    	// of the range, then start at rangeStart, which is inclusive
    	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 we've reached the end of this range, we need to advance the range
    	// RangeEnd is inclusive as well
    	if i.cur.Equal(r.RangeEnd) {
    		i.rangeIdx += 1
    		i.rangeIdx %= len(*i.rangeset)
    		r = (*i.rangeset)[i.rangeIdx]
    
    		i.cur = r.RangeStart
    	} else {
    		i.cur = ip.NextIP(i.cur)
    	}
    
    	if i.startIP == nil {
    		i.startIP = i.cur
    	} else if i.rangeIdx == i.startRange && 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
    }

[https_github.com_containernetworking_plugins]: https://github.com/containernetworking/plugins