Overview
calico插件代码仓库在 projectcalico/cni-plugin ，并且会编译两个二进制文件：calico和calico-ipam，其中calico会为sandbox container创立route和虚构网卡virtual interface，以及veth pair等网络资源，并且会把相干数据写入calico datastore数据库里；calico-ipam会为以后pod从以后节点的pod网段内调配ip地址，当然以后节点还没有pod网段，会从集群网段cluster cidr中先调配出该节点的pod cidr，并把相干数据写入calico datastore数据库里，这里cluster cidr是用户本人定义的，曾经提前写入了calico datastore，并且从cluster cidr中划分的block size也是能够自定义的(新版本calico/node容器能够反对自定义，老版本calico不反对)，能够参考官网文档 change-block-size 。
接下来重点看下calico二进制插件具体是如何工作的，后续再看calico-ipam二进制插件如何调配ip地址的。
calico plugin源码解析
calico插件是遵循cni标准接口，实现了 ADD 和 DEL 命令，这里重点看看 ADD 命令时如何实现的。calico首先会注册 ADD 和 DEL 命令，代码在 L614-L677 ：
func Main(version string) { // ... err := flagSet.Parse(os.Args[1:]) // ... // 注册 `ADD` 和 `DEL` 命令 skel.PluginMain(cmdAdd, nil, cmdDel, cniSpecVersion.PluginSupports("0.1.0", "0.2.0", "0.3.0", "0.3.1"), "Calico CNI plugin "+version)}ADD 命令里，次要做了三个逻辑：
- 查问calico datastore里有没有WorkloadEndpoint对象和以后的pod名字匹配，没有匹配，则会创立新的WorkloadEndpoint对象，该对象内次要保留该pod在host network namespace内的网卡名字和pod ip地址，以及container network namespace的网卡名字等等信息，对象示例如下。
- 创立一个veth pair，并把其中一个网卡置于宿主机端网络命名空间，另一个置于容器端网络命名空间。在container network namespace内创立网卡如eth0，并通过调用calico-ipam取得的IP地址赋值给该eth0网卡；在host network namespace内创立网卡，网卡名格局为
"cali" + sha1(namespace.pod)[:11]，并设置MAC地址"ee:ee:ee:ee:ee:ee"。 - 在容器端和宿主机端创立路由。在容器端，设置默认网关为
169.254.1.1，该网关地址代码写死的；在宿主机端，增加路由如10.217.120.85 dev calid0bda9976d5 scope link，其中10.217.120.85是pod ip地址，calid0bda9976d5是该pod在宿主机端的网卡，也就是veth pair在宿主机这端的virtual ethernet interface虚构网络设备。
一个WorkloadEndpoint对象示例如下，一个k8s pod对象对应着calico中的一个workloadendpoint对象，能够通过 calicoctl get wep -o wide 查看所有 workloadendpoint。
记得配置calico datastore为kubernetes的，为不便能够在 ~/.zshrc 里配置环境变量：
# calicoexport CALICO_DATASTORE_TYPE=kubernetesexport CALICO_KUBECONFIG=~/.kube/configapiVersion: projectcalico.org/v3kind: WorkloadEndpointmetadata: creationTimestamp: "2021-01-09T08:38:56Z" generateName: nginx-demo-1-7f67f8bdd8- labels: app: nginx-demo-1 pod-template-hash: 7f67f8bdd8 projectcalico.org/namespace: default projectcalico.org/orchestrator: k8s projectcalico.org/serviceaccount: default name: minikube-k8s-nginx--demo--1--7f67f8bdd8--d5wsc-eth0 namespace: default resourceVersion: "557760" uid: 85d1d33f-f55f-4f28-a89d-0a55394311dbspec: endpoint: eth0 interfaceName: calife8e5922caa ipNetworks: - 10.217.120.84/32 node: minikube orchestrator: k8s pod: nginx-demo-1-7f67f8bdd8-d5wsc profiles: - kns.default - ksa.default.default依据以上三个次要逻辑，看下 cmdAdd 函数代码：
func cmdAdd(args *skel.CmdArgs) (err error) { // ... // 从args.StdinData里加载配置数据，这些配置数据其实就是 // `--cni-conf-dir` 传进来的文件内容，即cni配置参数，见第一篇文章 // types.NetConf 构造体数据结构也对应着cni配置文件里的数据 conf := types.NetConf{} if err := json.Unmarshal(args.StdinData, &conf); err != nil { return fmt.Errorf("failed to load netconf: %v", err) } // 这里能够通过cni参数设置，把calico插件的日志落地到宿主机文件内 // "log_level": "debug", "log_file_path": "/var/log/calico/cni/cni.log", utils.ConfigureLogging(conf) // ... // 能够在cni文件内设置MTU，即Max Transmit Unit最大传输单元，配置网卡时须要 if mtu, err := utils.MTUFromFile("/var/lib/calico/mtu"); err != nil { return fmt.Errorf("failed to read MTU file: %s", err) } else if conf.MTU == 0 && mtu != 0 { conf.MTU = mtu } // 结构一个WEPIdentifiers对象，并赋值 nodename := utils.DetermineNodename(conf) wepIDs, err := utils.GetIdentifiers(args, nodename) calicoClient, err := utils.CreateClient(conf) // 查看datastore是否曾经ready了，能够 `calicoctl get clusterinformation default -o yaml` 查看 ci, err := calicoClient.ClusterInformation().Get(ctx, "default", options.GetOptions{}) if !*ci.Spec.DatastoreReady { return } // list出前缀为wepPrefix的workloadEndpoint，一个pod对应一个workloadEndpoint，如果数据库里能匹配出workloadEndpoint，就应用这个workloadEndpoint // 否则最初创立完pod network资源后，会往calico数据库里写一个workloadEndpoint wepPrefix, err := wepIDs.CalculateWorkloadEndpointName(true) endpoints, err := calicoClient.WorkloadEndpoints().List(ctx, options.ListOptions{Name: wepPrefix, Namespace: wepIDs.Namespace, Prefix: true}) if err != nil { return } // 对于新建的pod，最初会在calico datastore里写一个对应的新的workloadendpoint对象 var endpoint *api.WorkloadEndpoint // 这里因为咱们是新建的pod，数据库里也不会有对应的workloadEndpoint对象，所以endpoints必然是nil的 if len(endpoints.Items) > 0 { // ... } // 既然endpoint是nil，则填充WEPIdentifiers对象默认值，这里args.IfName是kubelet那边传过来的，就是容器端网卡名字，个别是eth0 // 这里WEPName的格局为：{node_name}-k8s-{strings.replace(pod_name, "-", "--")}-{wepIDs.Endpoint}，比方上文 // minikube-k8s-nginx--demo--1--7f67f8bdd8--d5wsc-eth0 WorkloadEndpoint对象 if endpoint == nil { wepIDs.Endpoint = args.IfName wepIDs.WEPName, err = wepIDs.CalculateWorkloadEndpointName(false) } // Orchestrator是k8s if wepIDs.Orchestrator == api.OrchestratorKubernetes { // k8s.CmdAddK8s 函数里做以上三个逻辑工作 if result, err = k8s.CmdAddK8s(ctx, args, conf, *wepIDs, calicoClient, endpoint); err != nil { return } } else { // ... } // 咱们的配置文件里 policy.type 是k8s，可见上文配置文件 if conf.Policy.PolicyType == "" { // ... } // Print result to stdout, in the format defined by the requested cniVersion. err = cnitypes.PrintResult(result, conf.CNIVersion) return}以上cmdAdd()函数根本构造合乎cni规范里的函数构造，最初会把后果打印到stdout。看下 k8s.CmdAddK8s() 函数的次要逻辑：
// 次要做三件事：// 1. 往calico store里写个WorkloadEndpoint对象，和pod对应// 2. 创立veth pair，一端在容器端，并赋值IP/MAC地址；一端在宿主机端，赋值MAC地址// 3. 创立路由，容器端创立默认网关路由；宿主机端创立该pod ip/mac的路由func CmdAddK8s(ctx context.Context, args *skel.CmdArgs, conf types.NetConf, epIDs utils.WEPIdentifiers, calicoClient calicoclient.Interface, endpoint *api.WorkloadEndpoint) (*current.Result, error) { // ... // 这里依据操作系统生成不同的数据立体data plane，这里是linuxDataplane对象 d, err := dataplane.GetDataplane(conf, logger) // 创立k8s client client, err := NewK8sClient(conf, logger) // 咱们的配置文件里 ipam.type=calico-ipam if conf.IPAM.Type == "host-local" { // ... } // ... // 这里会查看该pod和namespace的annotation: cni.projectcalico.org/ipv4pools // 咱们没有设置，这里逻辑跳过 if conf.Policy.PolicyType == "k8s" { annotNS, err := getK8sNSInfo(client, epIDs.Namespace) labels, annot, ports, profiles, generateName, err = getK8sPodInfo(client, epIDs.Pod, epIDs.Namespace) // ... if conf.IPAM.Type == "calico-ipam" { var v4pools, v6pools string // Sets the Namespace annotation for IP pools as default v4pools = annotNS["cni.projectcalico.org/ipv4pools"] v6pools = annotNS["cni.projectcalico.org/ipv6pools"] // Gets the POD annotation for IP Pools and overwrites Namespace annotation if it exists v4poolpod := annot["cni.projectcalico.org/ipv4pools"] if len(v4poolpod) != 0 { v4pools = v4poolpod } // ... } } ipAddrsNoIpam := annot["cni.projectcalico.org/ipAddrsNoIpam"] ipAddrs := annot["cni.projectcalico.org/ipAddrs"] switch { // 次要走这个逻辑：调用calico-ipam插件调配一个IP地址 case ipAddrs == "" && ipAddrsNoIpam == "": // 咱们的pod没有设置annotation "cni.projectcalico.org/ipAddrsNoIpam"和"cni.projectcalico.org/ipAddrs"值 // 这里调用calico-ipam插件获取pod ip值 // 无关calico-ipam插件如何调配pod ip值，后续有空再学习下 result, err = utils.AddIPAM(conf, args, logger) // ... case ipAddrs != "" && ipAddrsNoIpam != "": // Can't have both ipAddrs and ipAddrsNoIpam annotations at the same time. e := fmt.Errorf("can't have both annotations: 'ipAddrs' and 'ipAddrsNoIpam' in use at the same time") logger.Error(e) return nil, e case ipAddrsNoIpam != "": // ... case ipAddrs != "": // ... } // 开始创立WorkloadEndpoint对象，赋值相干参数 endpoint.Name = epIDs.WEPName endpoint.Namespace = epIDs.Namespace endpoint.Labels = labels endpoint.GenerateName = generateName endpoint.Spec.Endpoint = epIDs.Endpoint endpoint.Spec.Node = epIDs.Node endpoint.Spec.Orchestrator = epIDs.Orchestrator endpoint.Spec.Pod = epIDs.Pod endpoint.Spec.Ports = ports endpoint.Spec.IPNetworks = []string{} if conf.Policy.PolicyType == "k8s" { endpoint.Spec.Profiles = profiles } else { endpoint.Spec.Profiles = []string{conf.Name} } // calico-ipam调配的ip地址值，写到endpoint.Spec.IPNetworks中 if err = utils.PopulateEndpointNets(endpoint, result); err != nil { // ... } // 这里desiredVethName网卡名格局为：`"cali" + sha1(namespace.pod)[:11]` ，这个网卡为置于宿主机一端 desiredVethName := k8sconversion.NewConverter().VethNameForWorkload(epIDs.Namespace, epIDs.Pod) // DoNetworking()函数很重要，该函数会创立veth pair和路由 // 这里是调用linuxDataplane对象的DoNetworking()函数 hostVethName, contVethMac, err := d.DoNetworking( ctx, calicoClient, args, result, desiredVethName, routes, endpoint, annot) // ... mac, err := net.ParseMAC(contVethMac) endpoint.Spec.MAC = mac.String() endpoint.Spec.InterfaceName = hostVethName endpoint.Spec.ContainerID = epIDs.ContainerID // ... // 创立或更新WorkloadEndpoint对象，至此到这里，会依据新建的一个pod对象，往calico datastore里写一个对应的workloadendpoint对象 if _, err := utils.CreateOrUpdate(ctx, calicoClient, endpoint); err != nil { // ... } // Add the interface created above to the CNI result. result.Interfaces = append(result.Interfaces, ¤t.Interface{ Name: endpoint.Spec.InterfaceName}, ) return result, nil}以上代码最初会创立个workloadendpoint对象，同时DoNetworking()函数很重要，这个函数里会创立路由和veth pair。
而后看下linuxDataplane对象的 DoNetworking() 函数，是如何创立veth pair和routes的。这里次要调用了 github.com/vishvananda/netlink golang包来增删改查网卡和路由等操作，等同于执行 ip link add/delete/set xxx 等命令，该golang包也是个很好用的包，被很多次要我的项目如k8s我的项目应用，在学习linux网络相干常识时能够利用这个包写一写相干demo，效率也高很多。这里看看calico如何应用netlink这个包来创立routes和veth pair的：
func (d *linuxDataplane) DoNetworking( ctx context.Context, calicoClient calicoclient.Interface, args *skel.CmdArgs, result *current.Result, desiredVethName string, routes []*net.IPNet, endpoint *api.WorkloadEndpoint, annotations map[string]string,) (hostVethName, contVethMAC string, err error) { // 这里desiredVethName网卡名格局为：`"cali" + sha1(namespace.pod)[:11]` ，这个网卡为置于宿主机一端 hostVethName = desiredVethName // 容器这端网卡名个别为eth0 contVethName := args.IfName err = ns.WithNetNSPath(args.Netns, func(hostNS ns.NetNS) error { veth := &netlink.Veth{ LinkAttrs: netlink.LinkAttrs{ Name: contVethName, MTU: d.mtu, }, PeerName: hostVethName, } // 创立veth peer，容器端网卡名是eth0，宿主机端网卡名是"cali" + sha1(namespace.pod)[:11] // 等于 ip link add xxx type veth peer name xxx 命令 if err := netlink.LinkAdd(veth); err != nil { } hostVeth, err := netlink.LinkByName(hostVethName) if mac, err := net.ParseMAC("EE:EE:EE:EE:EE:EE"); err != nil { } else { // 设置宿主机端网卡的mac地址，为 ee:ee:ee:ee:ee:ee if err = netlink.LinkSetHardwareAddr(hostVeth, mac); err != nil { d.logger.Warnf("failed to Set MAC of %q: %v. Using kernel generated MAC.", hostVethName, err) } } // ... hasIPv4 = true // ip link set up起来宿主机端这边的网卡 if err = netlink.LinkSetUp(hostVeth); err != nil { } // ip link set up起来容器端这边的网卡 contVeth, err := netlink.LinkByName(contVethName) if err = netlink.LinkSetUp(contVeth); err != nil { } // Fetch the MAC from the container Veth. This is needed by Calico. contVethMAC = contVeth.Attrs().HardwareAddr.String() if hasIPv4 { // 容器端这边增加默认网关路由，如： // default via 169.254.1.1 dev eth0 // 169.254.1.1 dev eth0 scope link gw := net.IPv4(169, 254, 1, 1) gwNet := &net.IPNet{IP: gw, Mask: net.CIDRMask(32, 32)} err := netlink.RouteAdd( &netlink.Route{ LinkIndex: contVeth.Attrs().Index, Scope: netlink.SCOPE_LINK, Dst: gwNet, }, ) } // 把从calico-ipam插件调配来的pod ip地址赋值给容器端这边的网卡 for _, addr := range result.IPs { if err = netlink.AddrAdd(contVeth, &netlink.Addr{IPNet: &addr.Address}); err != nil { return fmt.Errorf("failed to add IP addr to %q: %v", contVeth, err) } } // ... // 切换到宿主机端network namespace if err = netlink.LinkSetNsFd(hostVeth, int(hostNS.Fd())); err != nil { return fmt.Errorf("failed to move veth to host netns: %v", err) } return nil }) // 设置veth pair宿主机端的网卡sysctls配置，设置这个网卡能够转发和arp_proxy err = d.configureSysctls(hostVethName, hasIPv4, hasIPv6) // ip link set up起来宿主机这端的veth pair的网卡 hostVeth, err := netlink.LinkByName(hostVethName) if err = netlink.LinkSetUp(hostVeth); err != nil { return "", "", fmt.Errorf("failed to set %q up: %v", hostVethName, err) } // 配置宿主机这端的路由 err = SetupRoutes(hostVeth, result) return hostVethName, contVethMAC, err}func SetupRoutes(hostVeth netlink.Link, result *current.Result) error { // 配置宿主机端这边的路由，但凡目标地址为pod ip 10.217.120.85，数据包进入calid0bda9976d5网卡，路由如： // 10.217.120.85 dev calid0bda9976d5 scope link for _, ipAddr := range result.IPs { route := netlink.Route{ LinkIndex: hostVeth.Attrs().Index, Scope: netlink.SCOPE_LINK, Dst: &ipAddr.Address, } err := netlink.RouteAdd(&route) // ... } return nil}// 这里英文就不翻译解释了，英文备注说的更具体通透。// configureSysctls configures necessary sysctls required for the host side of the veth pair for IPv4 and/or IPv6.func (d *linuxDataplane) configureSysctls(hostVethName string, hasIPv4, hasIPv6 bool) error { var err error if hasIPv4 { // Normally, the kernel has a delay before responding to proxy ARP but we know // that's not needed in a Calico network so we disable it. if err = writeProcSys(fmt.Sprintf("/proc/sys/net/ipv4/neigh/%s/proxy_delay", hostVethName), "0"); err != nil { return fmt.Errorf("failed to set net.ipv4.neigh.%s.proxy_delay=0: %s", hostVethName, err) } // Enable proxy ARP, this makes the host respond to all ARP requests with its own // MAC. We install explicit routes into the containers network // namespace and we use a link-local address for the gateway. Turing on proxy ARP // means that we don't need to assign the link local address explicitly to each // host side of the veth, which is one fewer thing to maintain and one fewer // thing we may clash over. if err = writeProcSys(fmt.Sprintf("/proc/sys/net/ipv4/conf/%s/proxy_arp", hostVethName), "1"); err != nil { return fmt.Errorf("failed to set net.ipv4.conf.%s.proxy_arp=1: %s", hostVethName, err) } // Enable IP forwarding of packets coming _from_ this interface. For packets to // be forwarded in both directions we need this flag to be set on the fabric-facing // interface too (or for the global default to be set). if err = writeProcSys(fmt.Sprintf("/proc/sys/net/ipv4/conf/%s/forwarding", hostVethName), "1"); err != nil { return fmt.Errorf("failed to set net.ipv4.conf.%s.forwarding=1: %s", hostVethName, err) } } if hasIPv6 { // ... } return nil}总结
至此，calico二进制插件就为一个sandbox container创立好了网络资源，即创立了一个veth pair，并别离为宿主机端和容器端网卡设置好对应MAC地址，以及为容器段配置好了IP地址，同时还在容器端配置好了路由默认网关，以及宿主机端配置好路由，让指标地址是sandbox container ip的进入宿主机端veth pair网卡，同时还为宿主机端网卡配置arp proxy和packet forwarding性能，
最初，会依据这些网络数据生成一个workloadendpoint对象存入calico datastore里。
然而，还是短少了一个要害逻辑，calico-ipam是如何调配IP地址的，后续有空在学习记录。