kubestack 源码分析

kingbosster

　　简介：KubeStack is an OpenStack network provider for kubernetes.KubeStack is devided into two functions:

• kubestack running on the same host with kube-controller-manager, which provides network management for openstack
  
• kubestack running on each minion host, which setups container's network interfaces
  

　　kubestack.conf的默认配置文件如下所示：



[Global]
auth-url = http://${IF_IP}:5000/v2.0
username = admin
password = admin
tenant-name = admin
region = RegionOne
ext-net-id = ${EXT_NET_ID}
[LoadBalancer]
create-monitor = yes
monitor-delay = 1m
monitor-timeout = 30s
monitor-max-retries = 3
[Plugin]
plugin-name = ovs

　　// kubestack.go
　　1、func main()
　　1、调用config, err := os.Open(configFile)打开配置文件，configFile默认为/etc/kubestack.conf
　　2、调用openstack, err := common.NewOpenStack(config)
　　3、调用server := kubestack.NewKubeHandler(openstack)
　　4、最后，调用server.Serve(port)进行监听，端口号默认为4237
　　OpenStack数据结构如下所示：



// OpenStack is an implementation of network provider Interface for OpenStack
type OpenStack struct {
　　network　　  *gophercloud.ServiceClient
　　identity　　 *gophercloud.ServiceClient
　　provider　　 *gophercloud.ProviderClient
　　region　　　  string
　　lbOpts　　　  LoadBalancerOpts
　　pluginOpts　 PluginOpts
　　ExtNetID　　  string
　　Plugin　　　   plugins.PluginInterface　
}

　　// pkg/common/openstack.go
　　2、func NewOpenStack(config io.Reader) (*OpenStack, error)

• 调用err := gcfg.ReadInto(&cfg, config)读取配置信息
  
• 调用provider, err := openstack.AuthenticatedClient(cfg.toAuthOptions()) 用于auth openstack
  
• 调用identity, err := openstack.NewIdentityV2(provider, gophercloud.EndpointOpts{Availability: gophercloud.AvailabilityAdmin})用于find identity endpoint
  
• 调用network, err := openstack.NewNetworkV2(provider, gophercloud.EndpointOpts{Region: cfg.Global.Region})
  
• 创建 os := OpenStack{
  

　　identity:　　　　identity,
　　network:　　　　network,
　　provider:　　　　provider,
　　region:　　　　　cfg.Global.Region,
　　lbOpts:　　　　　cfg.LoadBalancer,
　　pluginOpts:　　　cfg.Plugin,
　　ExtNetID:　　　　cfg.Global.ExtNetID,
　　}

• 当cfg.Plugin.PluginName 不为nil时：
  
  
  
  • integrationBriage := "br-int"，若cfg.Plugin.IntegrationBridge不为""，则设置integrationBriage = cfg.Plugin.IntegrationBridge
    
  • 调用plugin, _ := plugins.GetNetworkPlugin(cfg.Plugin.PluginName)
    
  • 若plugin不为nil，则调用plugin.Init(integrationBriage)，并且os.Plugin = plugin
    
  
  
  
• 最后，返回return &os, nil
  

　　// pkg/plugins/plugins.go
　　// GetNetworkPlugin creates an instance of the named network plugin, or nil if
　　// the name is unkown. The error return is only used if the named plugin
　　// was known but failed to initialize
　　3、func GetNetworkPlugin(name string) (PluginInterface, error)
　　该函数仅仅调用f, found := plugins[name]获取plugin的Factory函数f()，调用该f()函数生成相应的PluginInterface
　　（如果相应的Plugin被支持，则相应的包在初始化的时候就已经在init()函数中进行了注册，因此一定能在此时找到）
　　PluginInterface数据结构如下所示：



type PluginInterface interface {
　　SetupInterface(podName, podInfraContainerID string, port *ports.Port, ipcidr, gateway string, dnsServers []string, containerRuntime string) error
　　DestroyInterface(podName, podInfraContainerID string, port *ports.Port, containerRuntime string) error
　　Init(integrationBridge string) error
}

　　// pkg/kubestack/kubestack.go
　　4、func NewKubeHandler(driver *common.OpenStack) *kubeHandler
　　该函数仅仅只是初始化并注册grpc server，生成h := &KubeHandler{driver: driver, server: grpc.NewServer()}
　　kubeHandler的结构如下所示：



// KubeHandler forwards requests and responses between
// the docker daemon and the plugin.
type KubeHandler struct {
　　driver　　*common.OpenStack
　　server　　*grpc.Server
}

　　-------------到此为止，kubestack 初始化完成，接下来为网络的创建过程-------------
　　// pkg/kubestack/kubestack.go
　　1、func (h *KubeHandler) CreateNetwork(c context.Context, req *provider.CreateNetworkRequest) (*provider.CommonResponse, error)
　　1、首先调用req.Network.TenantID = h.driver.ToTenantID(req.Network.TenantID)，将tenantName转换为tenantID
　　2、再调用err := h.driver.CreateNetwork(req.Network)创建网络
　　Network数据结构如下所示：



type Network struct {
　　Name　　　　　string
　　Uid　　　　　 string
　　TenantID　　 string
　　SegmentID　  int32
　　Subnets　　　[]*Subnet
　　// Status of network
　　// Valid value: Initializing, Active, Pending, Failed, Terminating
　　Status　　　　string
}

　　Subnet数据结构如下所示：



type Subnet struct {
　　Name　　　　　　string
　　Uid　　　　　 　string
　　Cidr　　　　　　string
　　Gateway　　　　string
　　Tenantid　　　 string
　　Dnsservers　　 []string
　　Routes　　　　　[]*Route
}

　　// pkg/common/openstack.go
　　2、func (os *OpenStack) CreateNetwork(network *provider.Network) error
　　1、首先创建opts := networks.CreateOpts{
　　Name:　　　　　　network.Name,
　　AdminStateUp:　　&adminStateUp,
　　TenantID:　　　　　network.TenantID,
　　}
　　再调用osNet, err := networks.Create(os.network, opts).Extract()创建网络
　　2、同样调用routerOpts := routers.CreateOpts{
　　Name:　　　　　　network.Name,
　　TenantID:　　　　 network.TenantID,
　　GatewayInfo:　　　&routers.GatewayInfo{NetworkID: os.ExtNetID},
　　}
　　再调用osRouter, err := routers.Create(os.network, routerOpts).Extract()创建router
　　3、最后，遍历network.Subnets创建子网

• 首先创建 subnetOpts := subnets.CreateOpts{
  

　　NetworkID:　　　　　　networkID,   //其实就是osNet.ID
　　CIDR:　　　　　　　　　sub.Cidr,
　　Name:　　　　　　　　　sub.Name,
　　IPVersion:　　　　　　　gophercloud.IPv4,
　　TenantID:　　　　　　　network.TenantID,
　　GatewaryIP:　　　　　　&sub.Gateway,
　　DNSNameserver:　　　　sub.Dnsservers,
　　}
　　再调用s, err := subnets.Create(os.network, subnetOpts).Extract()创建子网
　　// 将子网加入router中
　　2. 创建opts := routers.AddInterfaceOpts{SubnetID: s.ID}，
　　再调用routers.AddInterface(os.network, osRouter.ID, opts).Extract()
　　---------------------------------------创建pod-----------------------------------------
　　// pkg/kubestack/kubestack.go
　　1、func (h *KubeHandler) SetupPod(c context.Context, req *provider.SetupPodRequest) (*provider.CommonResponse, error)
　　该函数仅仅是调用h.driver.SetupPod(req.PodName, req.Namespace, req.PodInfraContainerID, req.Network, req.ContainerRuntime)
　　SetupPodRequest数据结构如下所示：



type SetupPodRequest struct {
　　PodName　　　　　　string
　　Namespace　　　　　string
　　ContainerRuntime　　string
　　PodInfraContainerID　string
　　Network　　　　　　　*Network
}

　　// pkg/common/openstack.go
　　2、func (os *OpenStack) SetupPod(podName, namespace, podInfraContainerID string, network *provider.Network, containerRuntime string)
　　1、调用portName := os.BuildPortName(podName, namespace, network.Uid)，该函数的作用仅仅是将podNamePrefix和上述三个参数连成一个字符串而已
　　2、获取dns server的ip，调用networkPorts, err := os.ListPorts(network.Uid, "network:dhcp")，再遍历networkPorts，调用dnsServers = append(dnsServers, p.FixedIPs[0].IPAddress)
　　3、调用port, err := os.GetPort(portName)，从openstack中获取port，如果port不存在，则调用portWithBinding, err := os.CreatePort(network.Uid, network.TenantID, portName, podHostname)创建一个
　　4、如果port.DeviceOwner和实际的deviceOwner不符，则更新hostname
　　5、调用subnet, err := os.getProviderSubnet(port.FixedIPs[0].SubnetID)获取子网和网关
　　6、最后，调用os.Plugin.SetupInterface(podName+"_"+namespace, podInfraContainerID, port, fmt.Sprintf("%s/%d", port.FixedIPs[0].IPAddress, prefixSize), subnet.Gateway, dnsServers, containerRuntime)为pod设置网卡
　　-----------------------------------OVS plugin实现---------------------------------------
　　OVSPlugin的数据结构很简单，如下所示：



type OVSPlugin struct {
　　IntegrationBridage string
}

　　// pkg/plugins/openvswitch/openvswitch.go
　　1、func (p *OVSPlugin) Init(integrationBridge string) error
　　该函数仅仅将p.IntegrationBridage赋值为integrationBridge
　　// pkg/plugins/openvswitch/openvswitch.go
　　2、func (p *OVSPlugin) SetupInterface(podName, podInfraContainerID string, port *ports.Port, ipcidr, gatewary string, dnsServers []string, containerRuntime string) error
　　1、先调用err := p.SetupOVSInterface(podName, podInfraContainerID, port, ipcidr, gatewary, containerRuntime)创建OVS interface
　　2、再根据containerRuntime的不同，分别调用p.SetupDockerInterface(podName, podInfraContainerID, port, ipcidr, gateway)或者p.SetupHyperInterface(podName, podInfraContainerID, port, ipcidr, gateway, dnsServers)
　　// pkg/plugins/openvswitch/openvswitch.go
　　3、func (p *OVSPlugin)  SetupOVSInterface(podName, podInfraContainerID string, port *ports.Port, ipcidr, gateway string, containerRuntime string)
　　1、该函数调用exec.RunCommand函数创建一个veth pair以及一个bridge，并将其中一个veth加入bridge中
　　2、调用ovs-vsctl，对另一个veth进行操作
　　// pkg/plugins/openvswitch/openvswitch.go
　　4、func (p *OVSPlugin) SetupDockerInterface(podName, podInfraContainerID string, port *ports.Port, ipcidr, gateway string) error
　　1、先创建一个veth对，tapName和vifName，并且将tapName加入之前创建的bridge中
　　2、将vifName的MAC地址设置为port.MACAddress
　　3、根据podInfraContainerID容器的pid找到对应的net ns，并把它软链接到/var/run/netns目录，从而能用ip命令对其直接进行操作。
　　4、将vifName加入net ns中，再删除其中的eth0网卡，再将vifName重命名为eth0
　　5、调用`ip addr add dev eth0 ipcidr`添加ip，以及`ip route add default via gateway`创建默认路由
　　// pkg/plugins/openvswitch/openvswitch.go
　　5、func (p *OVSPlugin) SetupHyperInterface(podName, podInfraContainerID string, port *ports.Port, ipcidr, gateway string, dnsServers []string)
　　1、首先获取bridge和tapName
　　2、创建interfaceSpec := map[string]string{
　　"bridge":　　　　bridge,
　　"ifname":　　　　tapName,
　　"mac":　　　　　port.MACAddress,
　　"ip":　　　　　　 ipcidr,
　　"gateway":　　　gateway,
　　} 生成network interface的配置
　　3、调用podSpec, err := p.getHyperPodSpec(podName)获取原始的hyper配置，并解码至specData中
　　4、调用specData["interfaces"] = []map[string]string{interfaceSpec}将network interface的配置加入其中
　　5、在specData["dns"]的基础之上添加dnsServers
　　6、最后调用newPodSpec, err := json.Marshal(specData)和p.saveHyperPodSpec(string(newPodSpec), podName)将新的hyper配置写入文件中
　　注：Neutron Port代表的是一个逻辑交换机中的一个虚拟交换机端口。虚拟机实例将自己的网卡和这些端口相连，这些逻辑端口同时定义了接入到它们中的接口的MAC地址和IP地址。当一个IP地址和一个端口关联起来的时候，这意味着这个端口和一个子网相连，因为这个IP地址就是从一个特定子网的allocation pool中获取的。