CNI网络插件之flannel

最新推荐文章于 2024-02-24 21:21:11 发布
最新推荐文章于 2024-02-24 21:21:11 发布
阅读量2.6k 收藏 9
点赞数 2
分类专栏： kubernetes docker 文章标签： kubernetes cni-plugins-amd6
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48594855/article/details/107145561
版权

CNI网络插件之flannel

CNI网络插件之flannel

上篇文章《CNI插件之CNI插件最简实现之macvlan plugin》我们介绍了macvlan插件，通过使用与分析，我们知道:

  • macvlan插件在集群多节点上，要每个节点都放配置文件, 比如/etc/cni/net.d/10-maclannet.conf, 并且各个节点的子网不能冲突。
  • macvlan插件默认网关的设置上还需要考虑ip是否已经存在，插件并不会自动帮我们设置,需要手动配置。
  • macvlan插件在集群多节点上，跨节点容器间通信上还需要手动配置网段路由。
  • macvlan插件在访问外部网络上，需要再手动配置网关，之后流量部分情况下，还需要走snat规则出公网。
  • macvlan插件的容器内部接口，是基于指定的宿主机主（master）接口，容器内部接口与主（master）接口不能直接通信。
  • macvlan插件是一个underlay的网络技术，网络栈有一定的独立性，安全方面会有一定的限制。

flannel插件的实现上解决了上面列出的5个问题：

  • 只要配置master节点, 自动配置集群各节点的子网，网关。
  • 自动创建cni0网桥，用于单节点容器间的互连，自动设置cni0网卡ip，并作为节点内容器的网关。
  • 根据实际使用的类型udp/vxlan/host-gw 在跨节点上自动配置相应的网络路由以及封装规则。比如udp模式上，创建flannel0（tun）设备，flanneld进配置进行udp外层（公网ip）分装。 vxlan模式下则创建flannel.1(VTEP)设备，设置相应的fdb转发规则等，使用内核vxlan模块进行外层（公网ip）封装。 host-gw模式下，自动配置网段路由进行路由转发。
  • 自动为外部网络的访问，创建NAT规则，用于容器内部访问外部网络。
  • 通过创建veth-pair设备对，一端放在容器内部，另外一端放在cni0网桥上，保障容器内部可以直接与cni0网桥通信。
  • flannel的udp/vxlan属于overlay的网络技术，安全方面有保障，另外也提供了一个性能较高的host-gw方案。

说了这么多优点，那flannel如何部署使用，具体怎样实现的呢？
这也是本篇文章要介绍的，这里罗列下面会介绍的内容：

  • flannel插件组成
  • flannel插件安装流程（vxlan）
  • 单节点容器间通信方式（网桥）实验
  • 容器访问外部网络通信方式实验
  • 跨节点容器间通信方式（vxlan）实验
  • flannel常用backend（后端）介绍
  • flannel 插件代码实现
    • 主流程，vxlan backend，host-gw backend等
  • vxlan之DirectRouting配置（原理同host-gw）
  • flannel插件配合其它插件实现网络策略(Network Policy)
  • flannel插件总结与讨论

flannel插件组成

flannel网络插件实现依赖的技术包括：

  • 实现桥接使用的cni插件bridge，实际实现桥接功能的内核bridge
  • vxlan模式即 Virtual Extensible LAN（虚拟可扩展局域网）的内核实现，该部分部分依赖flanneld
  • udp模式下依赖的外层UDP封装实现flanneld进程
  • host-gw模式使用到的内核路由表实现
  • 出公网需要的NAT的实现使用的内核iptables规则
  • 保证每个节点存在一个副本的DaemonSet：kube-flannel-ds-amd64
  • 自动同步到每个节点配置的配置ConfigMap：kube-flannel-cfg
  • 账户相关的ServiceAccount：flannel //RBAC
  • 集群角色相关的ClusterRole：flannel //RBAC
  • 集群角色权限授予相关的ClusterRoleBinding：flannel //RBAC
  • POD安全策略相关的PodSecurityPolicy：psp.flannel.unprivileged该资源后面分配给flannel对应的ClusterRole //RBAC

上面DaemonSet，ConfigMap，RBAC相关的内容后续会出相应的章节介绍，感兴趣的跳转链接阅读（链接待添加）

这些组成大部分可以从yaml配置文件获取到，我们给出上面的链接对应的配置文件，以及简单的注释：

---
apiVersion: policy/v1beta1
kind: PodSecurityPolicy				#POD节点安全策略相关
metadata:
  name: psp.flannel.unprivileged
  annotations:
    seccomp.security.alpha.kubernetes.io/allowedProfileNames: docker/default
    seccomp.security.alpha.kubernetes.io/defaultProfileName: docker/default
    apparmor.security.beta.kubernetes.io/allowedProfileNames: runtime/default
    apparmor.security.beta.kubernetes.io/defaultProfileName: runtime/default
spec:
  privileged: true
  volumes:
    - configMap
    - secret
    - emptyDir
    - hostPath
  allowedHostPaths:			#宿主机目录权限设置
    - pathPrefix: "/etc/cni/net.d"
    - pathPrefix: "/etc/kube-flannel"
    - pathPrefix: "/run/flannel"
  readOnlyRootFilesystem: false
  # Users and groups
  runAsUser:
    rule: RunAsAny
  supplementalGroups:
    rule: RunAsAny
  fsGroup:
    rule: RunAsAny
  # Privilege Escalation
  allowPrivilegeEscalation: false
  defaultAllowPrivilegeEscalation: false
  # Capabilities
  allowedCapabilities: ['NET_ADMIN']
  defaultAddCapabilities: []
  requiredDropCapabilities: []
  # Host namespaces
  hostPID: false
  hostIPC: false
  hostNetwork: true
  hostPorts:
  - min: 0
    max: 65535
  # SELinux
  seLinux:
    # SELinux is unused in CaaSP
    rule: 'RunAsAny'
---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
  name: flannel						#ClusterRole角色
rules:
  - apiGroups: ['extensions']
    resources: ['podsecuritypolicies']			#权限资源类型
    verbs: ['use']
    resourceNames: ['psp.flannel.unprivileged']		#权限资源名称
  - apiGroups:
      - ""
    resources:
      - pods
    verbs:
      - get
  - apiGroups:
      - ""
    resources:
      - nodes
    verbs:
      - list
      - watch
  - apiGroups:
      - ""
    resources:
      - nodes/status
    verbs:
      - patch
---
kind: ClusterRoleBinding				#权限绑定，给flannel（ServiceAccount）绑定flannel（ClusterRole）角色的权限
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
  name: flannel
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: flannel
subjects:
- kind: ServiceAccount
  name: flannel
  namespace: kube-system
---
apiVersion: v1
kind: ServiceAccount			#创建ServiceAccount 账号
metadata:
  name: flannel
  namespace: kube-system
---
kind: ConfigMap		#用于保存配置信息的键值对，主要用于给容器内应用程序提供配置
apiVersion: v1
metadata:
  name: kube-flannel-cfg			#这里定义了kube-flannel-cfg这个configmap 后面以存储卷的形式提供给后面的DaemonSet
  namespace: kube-system
  labels:
    tier: node
    app: flannel
data:
  cni-conf.json: |
    {
      "name": "cbr0",
      "cniVersion": "0.3.1",
      "plugins": [
        {
          "type": "flannel",			#cni插件类型
          "delegate": {					#委托，这里实际调用的是bridge插件
            "hairpinMode": true,		#支持hairpinMode 用于实现pod访问集群服务后，重新负载均衡到本pod。
            "isDefaultGateway": true	#设置cni0网关ip，同时设置pod节点默认网关为cni0的ip,同bridge插件说明。
          }
        },
        {
          "type": "portmap",		#级联插件用于实现类似端口映射，nat的功能。
          "capabilities": {
            "portMappings": true
          }
        }
      ]
    }
  net-conf.json: |
    {
      "Network": "192.16.0.0/16",		#集群pod节点使用的网络网段
      "Backend": {
        "Type": "vxlan"			#backend的类型，这里使用vxlan，还可以udp/host-gw等
      }
    }
---
apiVersion: apps/v1
kind: DaemonSet					#DaemonSet保障集群各个节点有一个副本
metadata:
  name: kube-flannel-ds-amd64
  namespace: kube-system
  labels:
    tier: node
    app: flannel
spec:
  selector:
    matchLabels:
      app: flannel
  template:
    metadata:
      labels:
        tier: node
        app: flannel
    spec:
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
              - matchExpressions:
                  - key: kubernetes.io/os
                    operator: In
                    values:
                      - linux
                  - key: kubernetes.io/arch
                    operator: In
                    values:
                      - amd64
      hostNetwork: true
      tolerations:
      - operator: Exists
        effect: NoSchedule
      serviceAccountName: flannel
      initContainers:
      - name: install-cni
        image: quay.io/coreos/flannel:v0.12.0-amd64			#使用的flannel镜像版本
        command:
        - cp
        args:
        - -f
        - /etc/kube-flannel/cni-conf.json
        - /etc/cni/net.d/10-flannel.conflist		#容器应用输入的cni配置文件
        volumeMounts:
        - name: cni
          mountPath: /etc/cni/net.d
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
      containers:
      - name: kube-flannel
        image: quay.io/coreos/flannel:v0.12.0-amd64
        command:
        - /opt/bin/flanneld		#容器应用二进制 flanneld
        args:
        - --ip-masq			#代表处公网要走snat
        - --kube-subnet-mgr		#代表使用kube的subnet-manager，有别于etcd的subnet-manager,该类型基于k8s的节点CIDR
        resources:
          requests:
            cpu: "100m"
            memory: "50Mi"
          limits:
            cpu: "100m"
            memory: "50Mi"
        securityContext:
          privileged: true
          capabilities:
            add: ["NET_ADMIN"]
        env:
        - name: POD_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        - name: POD_NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
        volumeMounts:
        - name: run
          mountPath: /run/flannel
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
      volumes:
        - name: run
          hostPath:
            path: /run/flannel				#运行相关目录
        - name: cni
          hostPath:
            path: /etc/cni/net.d			#cni插件配置目录
        - name: flannel-cfg
          configMap:
            name: kube-flannel-cfg			#使用的configmap配置

flannel插件安装流程（vxlan）

由于我们之前已经安装了macvlan了，并且部分容器已经添加进了macvlan创建的网络。所以这里我们在使用flannel插件前，先要重置网络：
重置详细命令较多，后面会有一个安装/重置的章节专门说明，如果使用前一章介绍的macvlan的方式安装，可以通过这个方式重置:链接

安装flannel插件，相对maxvlan插件，是将配置文件直接写在yaml里面，我们这里提供了一个典型的flannel yaml配置，这个配置和上一章介绍的yaml文件是一致的。

下载下来后，只要执行：

kubectl apply -f kube-falannel.yml

配置文件里面有一个比较关键的配置：

  net-conf.json: |
    {
      "Network": "192.16.0.0/16",	//集群pod节点网络
      "Backend": {
        "Type": "vxlan"				//flannel网络类型，可以vxlan/udp/host-gw等
      }
    }

配置文件里面的其它部分我们后面再做一个整体的介绍。

运行过后，集群各节点就会从NotReady变成Ready节点状态。

集群各节点会看到cni0网桥，连接到cni0网桥的veth设备

[root@k8s-new-master flannel]# ifconfig cni
cni0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1450
        inet 192.16.0.1  netmask 255.255.255.0  broadcast 0.0.0.0
        inet6 fe80::8c45:9bff:feb9:8700  prefixlen 64  scopeid 0x20<link>
        ether 8e:45:9b:b9:87:00  txqueuelen 1000  (Ethernet)
        RX packets 2699334  bytes 233169100 (222.3 MiB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 2753084  bytes 650775039 (620.6 MiB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
        
[root@k8s-new-master flannel]# brctl  show
bridge name	bridge id		STP enabled	interfaces
cni0		8000.1a64c8fcc7c5	no		veth501950ba
										veth9abcf99e

veth设备对，其中sh-4.2# 表示在容器里面，容器里面eth0后面的@6与宿主机的编号6接口是一对直连，同理另外一个容器里面eth0后面的@7与宿主机的编号7接口也是直连的。


[root@k8s-new-master flannel]# ip link
6: veth501950ba@if3: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1450 qdisc noqueue master cni0 state UP mode DEFAULT group default 
    link/ether ba:c0:8d:41:3f:30 brd ff:ff:ff:ff:ff:ff link-netnsid 0
7: veth9abcf99e@if3: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1450 qdisc noqueue master cni0 state UP mode DEFAULT group default 
    link/ether 62:c1:58:cb:5e:14 brd ff:ff:ff:ff:ff:ff link-netnsid 1

sh-4.2# ip addr
3: eth0@if6: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1450 qdisc noqueue state UP group default 
    link/ether 76:41:a1:96:53:88 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 192.16.0.72/24 scope global eth0
       valid_lft forever preferred_lft forever

sh-4.2# ip addr
3: eth0@if7: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1450 qdisc noqueue state UP group default 
    link/ether 4a:aa:c6:b8:5a:12 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 192.16.0.73/24 scope global eth0
       valid_lft forever preferred_lft forever

flanneld进程
这里指定ip-masq表示，访问外部网络所需的nat规则由flanneld进程创建，bridge插件那边要关闭nat规则的创建。

[root@k8s-new-master flannel]# ps -aux |grep flanneld
root     19979  0.1  0.2 621916 19036 ?        Ssl  Jul04   2:41 /opt/bin/flanneld --ip-masq --kube-subnet-mgr
root     31718  0.0  0.0 112712   940 pts/1    S+   22:58   0:00 grep --color=auto flanneld

看下flannel自动生成的完整插件配置：

cat /var/lib/cni/flannel/3153d1047e5ac34b276123db3b80eeed35320933778dfe5308ddfeaa84299c72
{
	"cniVersion":"0.3.1",
	"hairpinMode":true,				#发夹模式，支持单个pod节点请求，最后负载均衡到本pod
	"ipMasq":false,					#关闭bridge生成访问外网的nat规则
	"ipam":
	{
		"routes":[{"dst":"192.16.0.0/16"}],
		"subnet":"192.16.0.0/24",
		"type":"host-local"			#ip分配管理插件类型：host-local
	},
	"isDefaultGateway":true,
	"isGateway":true,			#自动设置网关ip到网桥cni0上，自动在容器内部添加默认网关路由
	"mtu":1450,
	"name":"cbr0",
	"type":"bridge"				#cni插件类型bridge
}

接下来是使用vxlan作为backend(后端)所创建的信息。大概包括4个核心信息：

  • flannel.1的Virtual Tunnel End Point (VTEP) 设备
  • 跨节点访问路由表
  • 跨节点访问arp表（邻居表）
  • 跨节点访问fdb表（转发表）

首先是flannel.1 （VTEP）虚拟设备，VTEP设备参数如下：

  • VNI标识： vid:1
  • 关闭自学习，不自动学习其他VTEP的mac： nolearning
  • 通过vxlan隧道发送出去使用的本地ip： local:192.168.122.14
  • 隧道使用的端口： port:8472
[root@k8s-new-master flannel]# ifconfig flannel.1
flannel.1: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1450
        inet 192.16.0.0  netmask 255.255.255.255  broadcast 0.0.0.0
        inet6 fe80::2077:b4ff:fee8:3e6f  prefixlen 64  scopeid 0x20<link>
        ether 22:77:b4:e8:3e:6f  txqueuelen 0  (Ethernet)
        RX packets 467309  bytes 34387845 (32.7 MiB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 436038  bytes 64505265 (61.5 MiB)
        TX errors 0  dropped 24 overruns 0  carrier 0  collisions 0
        
[root@k8s-new-master flannel]# ip -d link show
4: flannel.1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1450 qdisc noqueue state UNKNOWN mode DEFAULT group default 
    link/ether fa:8f:c5:04:ab:97 brd ff:ff:ff:ff:ff:ff promiscuity 0 
    vxlan id 1 local 192.168.122.14 dev ens3 srcport 0 0 dstport 8472 nolearning ageing 300 noudpcsum noudp6zerocsumtx noudp6zerocsumrx addrgenmode eui64 numtxqueues 1 numrxqueues 1 gso_max_size 65536 gso_max_segs 65535

接下来看下跨节点访问所需的路由表
这里先说下我们集群pod节点分配的ip网段：
master:192.16.0.0/24
node1:192.16.1.0/24
node2:12.16.2.0/24
所以在master查看到，到192.16.1.0/24 及192.16.2.0/24两个网段需要走vxlan设备flannel.1。

这里查询结果里面的onlink标志，onlink 参数表明强制此网关是“在链路上”的 (虽然并没有链路层路由)，否则 linux 上面是没法添加不同网段的路由。这样数据包就能知道，如果是容器直接的访问则交给 flannel.1 设备处理。

这样跨节点容器间访问时（192.16.0.1->192.16.1.1），数据首先在容器内走默认网关到cni0网桥，然后走路由到flannel.1设备，接着封装目的二层信息，这里目的mac应该选谁？

[root@k8s-new-master flannel]# route -n |grep flannel.1
192.16.1.0      192.16.1.0      255.255.255.0   UG    0      0        0 flannel.1
192.16.2.0      192.16.2.0      255.255.255.0   UG    0      0        0 flannel.1

[root@k8s-new-master flannel]# ip route show dev flannel.1
192.16.1.0/24 via 192.16.1.0 onlink 
192.16.2.0/24 via 192.16.2.0 onlink

答案是填对端的VTEP设备的mac地址，又IP查询mac地址依赖的是arp表。所以flanneld进程会为每个加入集群的VTEP设备添加一个arp表项，permannent永久的。

[root@k8s-new-master flannel]# arp -an |grep flannel.1
? (192.16.1.0) at 2e:2a:a5:7c:e8:f2 [ether] PERM on flannel.1
? (192.16.2.0) at 7a:50:9c:c8:99:d7 [ether] PERM on flannel.1

[root@k8s-new-master flannel]# ip neig show dev flannel.1
192.16.1.0 lladdr 2e:2a:a5:7c:e8:f2 PERMANENT
192.16.2.0 lladdr 7a:50:9c:c8:99:d7 PERMANENT

我们知道，vxlan是一个将二层帧封装在udp里面的数据包，填充完了二层，我们如何知道这个包要发送给谁？ 创建VTEP的时候，我们指定了发送的源IP（宿主机ip），端口信息，那么目的IP端口信息显然就是对端的宿主机ip，这个信息其实是被flanneld进程静态的添加进转发表里面，bridge fdb里面存着一个到目的mac地址（这里是目的VTEP mac）所需的目的IP（目的宿主IP），注意这里也是permanent永久性的。

[root@k8s-new-master flannel]# bridge fdb |grep flan
2e:2a:a5:7c:e8:f2 dev flannel.1 dst 192.168.122.15 self permanent
7a:50:9c:c8:99:d7 dev flannel.1 dst 192.168.122.16 self permanent

接下来我们看下flannel生成的各节点网段等信息，以master为例，与节点的CIDR一致

[root@k8s-new-master ns_tools]# cat /var/run/flannel/subnet.env 
FLANNEL_NETWORK=192.16.0.0/16
FLANNEL_SUBNET=192.16.0.1/24
FLANNEL_MTU=1450
FLANNEL_IPMASQ=true

[root@k8s-new-master ns_tools]# kubectl describe node k8s-new-master |grep CIDR
PodCIDR:                     192.16.0.0/24

自动生成pod内容器访问外网所需的iptables规则：

[root@k8s-new-node2 ~]# iptables -S -t nat
-A POSTROUTING -s 192.16.0.0/16 -d 192.16.0.0/16 -j RETURN
-A POSTROUTING -s 192.16.0.0/16 ! -d 224.0.0.0/4 -j MASQUERADE
-A POSTROUTING ! -s 192.16.0.0/16 -d 192.16.2.0/24 -j RETURN
-A POSTROUTING ! -s 192.16.0.0/16 -d 192.16.0.0/16 -j MASQUERADE

上述四条规则作用分别是：

  • 集群内部pod间流量，不做NAT
  • 集群内部pod访问外部(非组播流量, 非集群内部pod)，需要走NAT(snat)出去
  • 非集群内部pod流量访问集群本节点，不需要做NAT
  • 非集群内部pod流量访问集群内部pod流量（非本节点）走NAT(snat)

通过这么一个yaml文件，我们已经安装完了flannel，也熟悉安装完后，会生成的特定规则，接下来我们通过三个实验，详细介绍下flannel实现单节点容器间通信，容器访问外部网络通信，跨节点容器间通信具体实现机制。

单节点容器间通信方式（网桥）实验

  • 确定父接口, 我们的环境上用ens3
  • 创建两个隔离空间
[root@k8s-new-master ~]# ip netns add net1
[root@k8s-new-master ~]# ip netns add net2
  • 创建veth-pair 这样一对虚拟设备接口
[root@k8s-new-master cni]# ip link add veth_test_1 type veth peer name veth_test_2
[root@k8s-new-master cni]# ifconfig veth_test_1
veth_test_1: flags=4098<BROADCAST,MULTICAST>  mtu 1500
        ether 92:0b:3c:57:44:91  txqueuelen 1000  (Ethernet)
        RX packets 0  bytes 0 (0.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

[root@k8s-new-master cni]# ifconfig veth_test_2
veth_test_2: flags=4098<BROADCAST,MULTICAST>  mtu 1500
        ether b2:9e:68:8a:5a:7a  txqueuelen 1000  (Ethernet)
        RX packets 0  bytes 0 (0.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
  • 将子网口veth_test_1放进隔离空间net1里面,重命名网口名称为eth0,设置ip为192.168.88.1/24
[root@k8s-new-master cni]# ip link set veth_test_1 netns net1

[root@k8s-new-master cni]# ip netns exec net1 ip link
1: lo: <LOOPBACK> mtu 65536 qdisc noop state DOWN mode DEFAULT group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
11: veth_test_1@if10: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000
    link/ether 92:0b:3c:57:44:91 brd ff:ff:ff:ff:ff:ff link-netnsid 0

[root@k8s-new-master cni]# ip netns exec net1 ip link set veth_test_1 name eth0

[root@k8s-new-master cni]# ip netns exec net1 ip link
1: lo: <LOOPBACK> mtu 65536 qdisc noop state DOWN mode DEFAULT group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
11: eth0@if10: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000
    link/ether 92:0b:3c:57:44:91 brd ff:ff:ff:ff:ff:ff link-netnsid 0

[root@k8s-new-master cni]# ip netns exec net1 ip addr add 192.168.88.1/24 dev eth0
[root@k8s-new-master cni]# ip netns exec net1 ip link set eth0 up

[root@k8s-new-master cni]# ip netns exec net1 ifconfig
eth0: flags=4099<UP,BROADCAST,MULTICAST>  mtu 1500
        inet 192.168.88.1  netmask 255.255.255.0  broadcast 0.0.0.0
        ether 92:0b:3c:57:44:91  txqueuelen 1000  (Ethernet)
        RX packets 0  bytes 0 (0.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
  • 创建my_cni网桥，将对端veth_test_2桥接到网桥上
[root@k8s-new-master cni]# brctl addbr my_cni
[root@k8s-new-master cni]# brctl addif my_cni veth_test_2

[root@k8s-new-master cni]# brctl  show my_cni
bridge name	bridge id		STP enabled	interfaces
my_cni		8000.b29e688a5a7a	no		veth_test_2
  • 同理创建另外一对虚拟设备veth-pair
[root@k8s-new-master cni]# ip link add veth_test_3 type veth peer name veth_test_4
[root@k8s-new-master cni]# ip link set veth_test_3 netns net2
[root@k8s-new-master cni]# ip netns exec net2 ip link set veth_test_3 name eth0
[root@k8s-new-master cni]# ip netns exec net2 ip addr add 192.168.88.2/24 dev eth0
[root@k8s-new-master cni]# ip netns exec net2 ip link set eth0 up

[root@k8s-new-master cni]# brctl  show my_cni
bridge name	bridge id		STP enabled	interfaces
my_cni		8000.563c09befbc8	no		veth_test_2
										veth_test_4
  • 测试连通性
[root@k8s-new-master cni]# iptables -P FORWARD ACCEPT
[root@k8s-new-master cni]# ifconfig veth_test_2 up
[root@k8s-new-master cni]# ifconfig veth_test_4 up

[root@k8s-new-master cni]# ip netns exec net2 ping 192.168.88.1
PING 192.168.88.1 (192.168.88.1) 56(84) bytes of data.
64 bytes from 192.168.88.1: icmp_seq=1 ttl=64 time=0.282 ms
64 bytes from 192.168.88.1: icmp_seq=2 ttl=64 time=0.095 ms
  • 网桥设置ip, 测试容器与网桥的连通性
[root@k8s-new-master cni]# ifconfig my_cni 192.168.88.10/24 up
[root@k8s-new-master cni]# ip netns exec net2 ping 192.168.88.10
PING 192.168.88.10 (192.168.88.10) 56(84) bytes of data.
64 bytes from 192.168.88.10: icmp_seq=1 ttl=64 time=0.161 ms
	
[root@k8s-new-master cni]# ip netns exec net1 ping 192.168.88.10
PING 192.168.88.10 (192.168.88.10) 56(84) bytes of data.
64 bytes from 192.168.88.10: icmp_seq=1 ttl=64 time=0.190 ms
  • 网桥接口与转发表,arp表
[root@k8s-new-master cni]# bridge link
10: veth_test_2 state UP @(null): <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 master my_cni state forwarding priority 32 cost 2 
13: veth_test_4 state UP @(null): <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 master my_cni state forwarding priority 32 cost 2 
	
[root@k8s-new-master cni]# bridge fdb |grep my_cni
b2:9e:68:8a:5a:7a dev veth_test_2 vlan 1 master my_cni permanent   # veth_test_2 mac地址
b2:9e:68:8a:5a:7a dev veth_test_2 master my_cni permanent
92:0b:3c:57:44:91 dev veth_test_2 master my_cni 		   # veth_test_1 现在在net1隔离空间里面的eth0的mac地址, 非permanent,无数据时，会老化
56:3c:09:be:fb:c8 dev veth_test_4 vlan 1 master my_cni permanent   # veth_test_4 mac地址
56:3c:09:be:fb:c8 dev veth_test_4 master my_cni permanent
e6:51:5f:c2:ad:4a dev veth_test_4 master my_cni 		   # veth_test_3 现在在net2隔离空间里面的eth0的mac地址, 非permanent,无数据时，会老化
33:33:00:00:00:01 dev my_cni self permanent
01:00:5e:00:00:01 dev my_cni self permanent
33:33:ff:be:fb:c8 dev my_cni self permanent

[root@k8s-new-master cni]# arp -i my_cni
Address                  HWtype  HWaddress           Flags Mask            Iface
192.168.88.2             ether   e6:51:5f:c2:ad:4a   C                     my_cni
192.168.88.1             ether   92:0b:3c:57:44:91   C                     my_cni

[root@k8s-new-master ~]# bridge monitor				  # 在老化之后，如果我们执行宿主节点访问隔离空间ip(192.168.88.2/192.168.88.1)就会触发网桥学习mac地址
e6:51:5f:c2:ad:4a dev veth_test_4 master my_cni 		  # 学习到对应的mac地址与dev：veth_test_4(类似交换机的port)的关系
92:0b:3c:57:44:91 dev veth_test_2 master my_cni

[root@k8s-new-master ~]# bridge -s fdb |grep my_cni			#查看收发包情况
92:0b:3c:57:44:91 dev veth_test_2 used 19/14 master my_cni 
b2:9e:68:8a:5a:7a dev veth_test_2 vlan 1 used 5838/5838 master my_cni permanent
b2:9e:68:8a:5a:7a dev veth_test_2 used 5838/5838 master my_cni permanent
56:3c:09:be:fb:c8 dev veth_test_4 vlan 1 used 5484/5484 master my_cni permanent
56:3c:09:be:fb:c8 dev veth_test_4 used 5484/5484 master my_cni permanent
e6:51:5f:c2:ad:4a dev veth_test_4 used 22/17 master my_cni

容器访问外部网络通信方式实验

  • 上个实验的基础上，我们需要对访问外部网络时，做snat，否则私网ip出去后，也没法收到回复报文
[root@k8s-new-master cni]# ip netns exec net1 ping baidu.com
ping: baidu.com: Name or service not known
  • 通过添加192.168.88网段访问外网的nat规则，实现访问外网,我们知道，之前macvlan的时候，可以用类似下面的命令：
iptables -t nat -A POSTROUTING -s 192.168.8.0/24 ! -o cni0 -j MASQUERADE
  • 这里的实验，我们参考flannel在mode为vxlan时生成的iptables规则，使用以下方式：
[root@k8s-new-master cni]# ip netns exec net1 route add default gw 192.168.88.10
[root@k8s-new-master cni]# ip netns exec net2 route add default gw 192.168.88.10
[root@k8s-new-master cni]# iptables -t nat -A POSTROUTING -s 192.168.88.0/24 -d 192.168.88.0/24 -j RETURN
[root@k8s-new-master cni]# iptables -t nat -A POSTROUTING -s 192.168.88.0/24 ! -d 224.0.0.0/4 -j MASQUERADE
  • 测试访问外网的连通性
[root@k8s-new-master cni]# ip netns exec net1 ping baidu.com
PING baidu.com (220.181.38.148) 56(84) bytes of data.
64 bytes from 220.181.38.148 (220.181.38.148): icmp_seq=1 ttl=45 time=39.0 ms
64 bytes from 220.181.38.148 (220.181.38.148): icmp_seq=2 ttl=45 time=38.5 ms
	
[root@k8s-new-master cni]# ip netns exec net2 ping baidu.com
PING baidu.com (39.156.69.79) 56(84) bytes of data.
64 bytes from 39.156.69.79 (39.156.69.79): icmp_seq=1 ttl=44 time=41.7 ms
64 bytes from 39.156.69.79 (39.156.69.79): icmp_seq=2 ttl=44 time=41.7 ms

跨节点容器间通信方式（vxlan）实验

上面的实验，我们已经在k8s-new-master(192.168.122.14)上创建一个网桥my_cni(192.168.88.10)，创建两个隔离空间net1(内部eth0:192.168.88.1),net2(内部eth0:192.168.88.2)

为了测试跨节点通信，我们这里先在k8s-new-node1(192.168.122.15)上创建隔离空间net3(内部eth0:192.168.89.1),并创建相应的网关my_cni1(192.168.89.10)。步骤同上面，这里不注释

[root@k8s-new-node1 ~]# ip netns add net3
[root@k8s-new-node1 ~]# ip link add veth_test_5 type veth peer name veth_test_6
[root@k8s-new-node1 ~]# ip link set veth_test_5 netns net3
[root@k8s-new-node1 ~]# ip netns exec net3 ip link set veth_test_5 name eth0
[root@k8s-new-node1 ~]# ip netns exec net3 ip addr add 192.168.89.1/24 dev eth0
[root@k8s-new-node1 ~]# ip netns exec net3 ip link set eth0 up
[root@k8s-new-node1 ~]# brctl addbr my_cni1
[root@k8s-new-node1 ~]# brctl addif my_cni1 veth_test_6
[root@k8s-new-node1 ~]# ifconfig veth_test_6 up

[root@k8s-new-node1 ~]# brctl  show my_cni1
bridge name	bridge id		STP enabled	interfaces
my_cni1		8000.0290ebc217bb	no		veth_test_6

[root@k8s-new-node1 ~]# ifconfig my_cni1 192.168.89.10/24 up

[root@k8s-new-node1 ~]# ip netns exec net3 ping 192.168.89.10
PING 192.168.89.10 (192.168.89.10) 56(84) bytes of data.
64 bytes from 192.168.89.10: icmp_seq=1 ttl=64 time=0.297 ms

[root@k8s-new-node1 ~]# ip netns exec net3 route add default gw 192.168.89.10
[root@k8s-new-node1 ~]# iptables -P FORWARD ACCEPT
  • 接下来我们参考flannel创建的flannel.1,在k8s-new-master创建vtep设备my_vtep0
[root@k8s-new-master ~]# ip link add my_vtep0 type vxlan id 200 dstport 4789 local 192.168.122.14 dev ens3 nolearning # 自动创建的mac地址a6:d3:23:dd:03:6f
[root@k8s-new-master ~]# ip link set my_vtep0 up
[root@k8s-new-master ~]# ip addr add 192.168.88.0/32 dev my_vtep0
[root@k8s-new-master ~]# ip route add 192.168.89.0/24 via 192.168.89.0 dev my_vtep0 onlink
[root@k8s-new-master ~]# ip neigh add 192.168.89.0 lladdr b2:07:fc:b6:82:a7 dev my_vtep0			     # 这一步需要等node1创建完my_vtep1后再填入mac地址
[root@k8s-new-master ~]# bridge fdb append b2:07:fc:b6:82:a7 dev my_vtep0 dst 192.168.122.15			     # 这一步需要等node1创建完my_vtep1后再填入mac地址

[root@k8s-new-master cni]# ip -d link show
18: my_vtep0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1450 qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1000
    link/ether a6:d3:23:dd:03:6f brd ff:ff:ff:ff:ff:ff promiscuity 0 
    vxlan id 200 local 192.168.122.14 dev ens3 srcport 0 0 dstport 4789 nolearning ageing 300 noudpcsum noudp6zerocsumtx noudp6zerocsumrx addrgenmode eui64 numtxqueues 1 numrxqueues 1 gso_max_size 65536 gso_max_segs 65535

部分参数说明：

  • 第1条命令：
    id: VNI标识是200
    local: vxlan隧道使用的源ip
    dstport: 指定目的端口为4789。
    dev: 指定VTEP通过哪个物理device来通信，这里是使用eth0。
    之后主要是up设备， 设置ip地址，添加跨节点、跨网段路由，添加bridge转发表

  • 第2/3条命令分别用于up 设备及设置设备ip

  • 第4条命令指定到对端（node1）节点容器网络192.168.89.0/24使用的网关192.168.89.0，以及使用的设备my_vtep0

  • 第5条命令添加一个arp表项目，包括对端的vtep ip及mac

  • 第6条命令添加提条对端vtep mac地址的转发表，通过对方的公网ip 192.168.122.15

  • 在k8s-new-node1创建vtep设备my_vtep1,步骤同上

[root@k8s-new-node1 ~]# ip link add my_vtep1 type vxlan id 200 dstport 4789 local 192.168.122.15 dev ens3 nolearning  # 自动创建的mac地址b2:07:fc:b6:82:a7
[root@k8s-new-node1 ~]# ip link set my_vtep1 up
[root@k8s-new-node1 ~]# ip addr add 192.168.89.0/32 dev my_vtep1
[root@k8s-new-node1 ~]# ip route add 192.168.88.0/24 via 192.168.88.0 dev my_vtep1 onlink
[root@k8s-new-node1 ~]# ip neigh add 192.168.88.0 lladdr a6:d3:23:dd:03:6f dev my_vtep1				      # 这一步需要等master创建完my_vtep0后再填入mac地址
[root@k8s-new-node1 ~]# bridge fdb append a6:d3:23:dd:03:6f dev my_vtep1 dst 192.168.122.14			      # 这一步需要等master创建完my_vtep0后再填入mac地址

[root@k8s-new-node1 ~]# ip -d link show
16: my_vtep1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1450 qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1000
    link/ether b2:07:fc:b6:82:a7 brd ff:ff:ff:ff:ff:ff promiscuity 0 
    vxlan id 200 local 192.168.122.15 dev ens3 srcport 0 0 dstport 4789 nolearning ageing 300 noudpcsum noudp6zerocsumtx noudp6zerocsumrx addrgenmode eui64 numtxqueues 1 numrxqueues 1 gso_max_size 65536 gso_max_segs 65535
  • 测试连通性
[root@k8s-new-master flannel]# ip netns exec net1 ping 192.168.89.1		# master上net1到node1的net3
PING 192.168.89.1 (192.168.89.1) 56(84) bytes of data.
64 bytes from 192.168.89.1: icmp_seq=1 ttl=62 time=1.18 ms

[root@k8s-new-node1 ~]# tcpdump -i ens3 -nnev port 4789				# master上net1到node1的net3，在node1上抓包
tcpdump: listening on ens3, link-type EN10MB (Ethernet), capture size 262144 bytes
18:24:03.775317 88:4f:d5:25:80:12 > 88:4f:d5:25:80:13, ethertype IPv4 (0x0800), length 148: (tos 0x0, ttl 64, id 53734, offset 0, flags [none], proto UDP (17), length 134)
    192.168.122.14.37379 > 192.168.122.15.4789: VXLAN, flags [I] (0x08), vni 200
a6:d3:23:dd:03:6f > b2:07:fc:b6:82:a7, ethertype IPv4 (0x0800), length 98: (tos 0x0, ttl 63, id 752, offset 0, flags [DF], proto ICMP (1), length 84)
    192.168.88.0 > 192.168.89.1: ICMP echo request, id 29566, seq 3, length 64
18:24:03.775542 88:4f:d5:25:80:13 > 88:4f:d5:25:80:12, ethertype IPv4 (0x0800), length 148: (tos 0x0, ttl 64, id 40978, offset 0, flags [none], proto UDP (17), length 134)
    192.168.122.15.55264 > 192.168.122.14.4789: VXLAN, flags [I] (0x08), vni 200
b2:07:fc:b6:82:a7 > a6:d3:23:dd:03:6f, ethertype IPv4 (0x0800), length 98: (tos 0x0, ttl 63, id 51787, offset 0, flags [none], proto ICMP (1), length 84)
    192.168.89.1 > 192.168.88.0: ICMP echo reply, id 29566, seq 3, length 64

	
[root@k8s-new-node1 ~]# ip netns exec net3 ping 192.168.88.1			# node1的net3到master的net1
PING 192.168.88.1 (192.168.88.1) 56(84) bytes of data.
64 bytes from 192.168.88.1: icmp_seq=1 ttl=62 time=1.27 ms
	
[root@k8s-new-node1 ~]# ip netns exec net3 ping 192.168.88.2			# node1的net3到master的net2
PING 192.168.88.2 (192.168.88.2) 56(84) bytes of data.
64 bytes from 192.168.88.2: icmp_seq=1 ttl=62 time=1.08 ms

[root@k8s-new-master ~]# ping 192.168.89.1					# master到node1的net3
PING 192.168.89.1 (192.168.89.1) 56(84) bytes of data.
64 bytes from 192.168.89.1: icmp_seq=1 ttl=63 time=4.45 ms

[root@k8s-new-node1 ~]# ping 192.168.88.1					# node1到master的net1
PING 192.168.88.1 (192.168.88.1) 56(84) bytes of data.
64 bytes from 192.168.88.1: icmp_seq=1 ttl=63 time=0.969 ms

flannel常用backend（后端）介绍

flannel常用后端包括udp、vxlan、host-gw等, 要对比这些后端的优缺点，需要简单的了解下它们的实现：它们都是应用在跨节点容器间通信。

udp

首先是udp封装：简单理解就是，将三层的ip报文封装在一个udp报文中。其中三层的两个ip分别在不同节点的容器上。数据流程:

节点1的pod A(容器)->cni0->flannel0（tun设备）->flanneld:8285->eth0（节点1的公网ip所在网卡）->internel
	-> eth1(节点2的公网ip所在网卡)->flanneld:8225->flannel0(tun设备)->cni0->pod B(容器)

vxlan

接下来是vxlan，这个方案上面已经介绍了，vxlan将二层报文封装在udp里面。二层报文的ip层的两个ip也是在不同节点的容器上。数据流程：

节点1的pod A(容器)->cni0->flannel.1(VTEP Virtual Tunnel End Point设备)->eth0（节点1的公网ip所在网卡）->internel
	-> eth1(节点2的公网ip所在网卡)->flannel.1->cni0->pod B(容器)

host-gw

最后是host-gw, 这个方案通过增加路由来将报文转发到对应的节点上。数据流程：

节点1的pod A(容器)->cni0->eth0（节点1的公网ip所在网卡）->internel
	-> eth1(节点2的公网ip所在网卡)->cni0->pod B(容器)

优缺点

  • 性能上来说：host-gw>vxlan>udp host-gw再报文转发上，不需要增加额外的开销，vxlan与udp都需要多一层封装，由于udp封装过程涉及多次用户态与内核态的切换，性能损耗相对vxlan更大。
  • 适用场景：vxlan=udp>host-gw vxlan与udp一样只需要节点间三层可达即可,可以理解为三层可达后，就可以跨节点传输的udp报文，host-gw需要将对方节点作为跨节点转发的下一跳（目的mac地址），需要二层可达。

综上，目前vxlan上实际上已经完全可以替换掉udp模式，所以本文后面讲只介绍vxlan及host-gw，由于当前实际使用场景，我们既希望性能上高，也希望在二层不可达的时候使用vxlan， 所以在vxlan模式中，实际上有个DirectRouting选项，开启后，如果二层可达，自动使用host-gw，否则使用vxlan进行跨节点容器间通信。

所以介绍vxlan的实现时，外加DirectRouting选项，就覆盖了flannel的常用后端。

flannel 插件代码实现

主流程

func main() {
	//第一步是确认网卡
	if opts.version {				//输出版本信息
		fmt.Fprintln(os.Stderr, version.Version)
		os.Exit(0)
	}

	flagutil.SetFlagsFromEnv(flannelFlags, "FLANNELD")

	// Validate flags
	if opts.subnetLeaseRenewMargin >= 24*60 || opts.subnetLeaseRenewMargin <= 0 {		//参数检查，， 子网续约时间不能大于1天 单位是分钟
		log.Error("Invalid subnet-lease-renew-margin option, out of acceptable range")
		os.Exit(1)
	}

	// Work out which interface to use
	var extIface *backend.ExternalInterface
	var err error
	// Check the default interface only if no interfaces are specified
	if len(opts.iface) == 0 && len(opts.ifaceRegex) == 0 {			//没有指定网卡，则自己查找
		extIface, err = LookupExtIface(opts.publicIP, "")		//查找网卡，这里想要知道详细的可以查阅香缎源码
		if err != nil {
			log.Error("Failed to find any valid interface to use: ", err)
			os.Exit(1)
		}
	} else {
		// Check explicitly specified interfaces			//有指定网卡，使用对应名称的网卡
		for _, iface := range opts.iface {
			extIface, err = LookupExtIface(iface, "")
			if err != nil {
				log.Infof("Could not find valid interface matching %s: %s", iface, err)
			}

			if extIface != nil {
				break
			}
		}

		// Check interfaces that match any specified regexes
		if extIface == nil {						//用户通过正则表达式指定网卡名称
			for _, ifaceRegex := range opts.ifaceRegex {
				extIface, err = LookupExtIface("", ifaceRegex)
				if err != nil {
					log.Infof("Could not find valid interface matching %s: %s", ifaceRegex, err)
				}

				if extIface != nil {
					break
				}
			}
		}

		if extIface == nil {						//没有找到合适的网卡 直接退出
			// Exit if any of the specified interfaces do not match
			log.Error("Failed to find interface to use that matches the interfaces and/or regexes provided")
			os.Exit(1)
		}
	}

	//第二步创建子网管理对象, 用于持久化存储功能，存储管理方式目前支持： kubernetes api-server或者etcd
	sm, err := newSubnetManager()			//创建子网管理对象
	if err != nil {
		log.Error("Failed to create SubnetManager: ", err)
		os.Exit(1)
	}
	log.Infof("Created subnet manager: %s", sm.Name())

	// Register for SIGINT and SIGTERM
	log.Info("Installing signal handlers")
	sigs := make(chan os.Signal, 1)
	signal.Notify(sigs, os.Interrupt, syscall.SIGTERM)

	// This is the main context that everything should run in.
	// All spawned goroutines should exit when cancel is called on this context.
	// Go routines spawned from main.go coordinate using a WaitGroup. This provides a mechanism to allow the shutdownHandler goroutine
	// to block until all the goroutines return . If those goroutines spawn other goroutines then they are responsible for
	// blocking and returning only when cancel() is called.
	ctx, cancel := context.WithCancel(context.Background())		//创建一个可以被cancel的ctx
	wg := sync.WaitGroup{}

	wg.Add(1)
	go func() {
		shutdownHandler(ctx, sigs, cancel)
		wg.Done()
	}()

	if opts.healthzPort > 0 {
		// It's not super easy to shutdown the HTTP server so don't attempt to stop it cleanly
		go mustRunHealthz()
	}

	//第三步： 创建网卡并且激活
	// Fetch the network config (i.e. what backend to use etc..).
	config, err := getConfig(ctx, sm)
	if err == errCanceled {
		wg.Wait()
		os.Exit(0)
	}

	// Create a backend manager then use it to create the backend and register the network with it.
	bm := backend.NewManager(ctx, sm, extIface)		//创建后端的manager对象
	be, err := bm.GetBackend(config.BackendType)
	if err != nil {
		log.Errorf("Error fetching backend: %s", err)
		cancel()
		wg.Wait()
		os.Exit(1)
	}

	bn, err := be.RegisterNetwork(ctx, wg, config)		//执行后端的注册网络函数，对应vxlan就是vxlan.go文件中RegisterNetwork,后面会详细介绍vxlan及host-gw后端
	if err != nil {
		log.Errorf("Error registering network: %s", err)
		cancel()
		wg.Wait()
		os.Exit(1)
	}

	// Set up ipMasq if needed
	if opts.ipMasq {				//根据配置，判断是否需要开启ip-masquerade
		if err = recycleIPTables(config.Network, bn.Lease()); err != nil {
			log.Errorf("Failed to recycle IPTables rules, %v", err)
			cancel()
			wg.Wait()
			os.Exit(1)
		}
		log.Infof("Setting up masking rules")
		go network.SetupAndEnsureIPTables(network.MasqRules(config.Network, bn.Lease()), opts.iptablesResyncSeconds)	//创建iptables策略(ip-masquerade)
	}

	// Always enables forwarding rules. This is needed for Docker versions >1.13 (https://docs.docker.com/engine/userguide/networking/default_network/container-communication/#container-communication-between-hosts)
	// In Docker 1.12 and earlier, the default FORWARD chain policy was ACCEPT.
	// In Docker 1.13 and later, Docker sets the default policy of the FORWARD chain to DROP.
	if opts.iptablesForwardRules {				//设置转发策略
		log.Infof("Changing default FORWARD chain policy to ACCEPT")
		go network.SetupAndEnsureIPTables(network.ForwardRules(config.Network.String()), opts.iptablesResyncSeconds)
	}

	if err := WriteSubnetFile(opts.subnetFile, config.Network, opts.ipMasq, bn); err != nil {		//保存到配置文件中
		// Continue, even though it failed.
		log.Warningf("Failed to write subnet file: %s", err)
	} else {
		log.Infof("Wrote subnet file to %s", opts.subnetFile)
	}

	// Start "Running" the backend network. This will block until the context is done so run in another goroutine.
	log.Info("Running backend.")
	wg.Add(1)
	go func() {
		bn.Run(ctx)			//如果是vxlan网络 执行的是vxlan_network.go中Run
		wg.Done()
	}()

	daemon.SdNotify(false, "READY=1")

	//第四步： 启动监控
	// Kube subnet mgr doesn't lease the subnet for this node - it just uses the podCidr that's already assigned.
	if !opts.kubeSubnetMgr {
		//通过etcd管理网络 会进入此函数 此函数是一个死循环
		err = MonitorLease(ctx, sm, bn, &wg)			//监控该节点 主要用于节点租约过期后 能够快速获取新的租约
		if err == errInterrupted {
			// The lease was "revoked" - shut everything down
			cancel()
		}
	}

	log.Info("Waiting for all goroutines to exit")
	// Block waiting for all the goroutines to finish.
	wg.Wait()
	log.Info("Exiting cleanly...")
	os.Exit(0)
}

上面的流程可以简单理解为:第一步是确认网卡,第二步创建子网管理对象,第三步创建网卡并且激活,第四步启动监控
第三步创建网卡并激活,第四部启动监控都会根据配置的后端实现会有不同，下面会介绍。

vxlan backend

这里我们主要介绍VTEP虚拟网卡的创建及监听子网添加删除（集群节点添加删除）事件

创建网卡

vxlan backend go语言实现参考链接

我们这里顺着主函数注册网络，简单介绍vxlan后端的实现。

注册网络：
输入参数： 上下文ctx， 子网信息config
输出参数： backend.network后端（vxlan）网络

func (be *VXLANBackend) RegisterNetwork(ctx context.Context, wg sync.WaitGroup, config *subnet.Config) (backend.Network, error) {
	// Parse our configuration
	cfg := struct {
		VNI           int
		Port          int
		GBP           bool
		Learning      bool
		DirectRouting bool
	}{
		VNI: defaultVNI,
	}

	if len(config.Backend) > 0 {  			//解析配置
		if err := json.Unmarshal(config.Backend, &cfg); err != nil {
			return nil, fmt.Errorf("error decoding VXLAN backend config: %v", err)
		}
	}
	log.Infof("VXLAN config: VNI=%d Port=%d GBP=%v Learning=%v DirectRouting=%v", cfg.VNI, cfg.Port, cfg.GBP, cfg.Learning, cfg.DirectRouting)

	devAttrs := vxlanDeviceAttrs{					//VXLAN设备属性
		vni:       uint32(cfg.VNI),
		name:      fmt.Sprintf("flannel.%v", cfg.VNI),
		vtepIndex: be.extIface.Iface.Index,
		vtepAddr:  be.extIface.IfaceAddr,
		vtepPort:  cfg.Port,
		gbp:       cfg.GBP,
		learning:  cfg.Learning,
	}

	dev, err := newVXLANDevice(&devAttrs)			//创建VXLAN设备
	if err != nil {
		return nil, err
	}
	dev.directRouting = cfg.DirectRouting

	subnetAttrs, err := newSubnetAttrs(be.extIface.ExtAddr, dev.MACAddr())			//创建子网属性
	if err != nil {
		return nil, err
	}

	lease, err := be.subnetMgr.AcquireLease(ctx, subnetAttrs)			//获取租约获取租约
	switch err {
	case nil:
	case context.Canceled, context.DeadlineExceeded:
		return nil, err
	default:
		return nil, fmt.Errorf("failed to acquire lease: %v", err)
	}

	// Ensure that the device has a /32 address so that no broadcast routes are created.
	// This IP is just used as a source address for host to workload traffic (so
	// the return path for the traffic has an address on the flannel network to use as the destination)
	if err := dev.Configure(ip.IP4Net{IP: lease.Subnet.IP, PrefixLen: 32}); err != nil {		//设置ip并up起来
		return nil, fmt.Errorf("failed to configure interface %s: %s", dev.link.Attrs().Name, err)
	}

	return newNetwork(be.subnetMgr, be.extIface, dev, ip.IP4Net{}, lease)			//new Network结构体
}

简单来说就是创建VXLAN设备、获取租约信息、vxlan配置ip、返回对象。

接下来简单说下创建VXLAN设备、获取租约信息的流程。

首先是创建VXLAN设备:
输入参数： devAttrs 设备属性
输出参数：返回vxlanDevice对象

func newVXLANDevice(devAttrs *vxlanDeviceAttrs) (*vxlanDevice, error) {
	link := &netlink.Vxlan{
		LinkAttrs: netlink.LinkAttrs{
			Name: devAttrs.name,
		},
		VxlanId:      int(devAttrs.vni),
		VtepDevIndex: devAttrs.vtepIndex,
		SrcAddr:      devAttrs.vtepAddr,
		Port:         devAttrs.vtepPort,
		Learning:     devAttrs.learning,
		GBP:          devAttrs.gbp,
	}

	link, err := ensureLink(link)			//创建VXLAN设备
	if err != nil {
		return nil, err
	}

	_, _ = sysctl.Sysctl(fmt.Sprintf("net/ipv6/conf/%s/accept_ra", devAttrs.name), "0")

	return &vxlanDevice{
		link: link,
	}, nil
}

func ensureLink(vxlan *netlink.Vxlan) (*netlink.Vxlan, error) {
	err := netlink.LinkAdd(vxlan)
	if err == syscall.EEXIST {
		// it's ok if the device already exists as long as config is similar
		log.V(1).Infof("VXLAN device already exists")
		existing, err := netlink.LinkByName(vxlan.Name) 		//获取已有vxlan设备信息
		if err != nil {
			return nil, err
		}

		incompat := vxlanLinksIncompat(vxlan, existing)			//比较新旧网卡信息
		if incompat == "" {
			log.V(1).Infof("Returning existing device")
			return existing.(*netlink.Vxlan), nil
		}

		// delete existing
		log.Warningf("%q already exists with incompatable configuration: %v; recreating device", vxlan.Name, incompat)		//不相同则删除
		if err = netlink.LinkDel(existing); err != nil {
			return nil, fmt.Errorf("failed to delete interface: %v", err)
		}

		// create new
		if err = netlink.LinkAdd(vxlan); err != nil {			//创建新的vxlan设备
			return nil, fmt.Errorf("failed to create vxlan interface: %v", err)
		}
	} else if err != nil {
		return nil, err
	}

	ifindex := vxlan.Index
	link, err := netlink.LinkByIndex(vxlan.Index)		//根据索引进行查找设备
	if err != nil {
		return nil, fmt.Errorf("can't locate created vxlan device with index %v", ifindex)
	}

	var ok bool
	if vxlan, ok = link.(*netlink.Vxlan); !ok {
		return nil, fmt.Errorf("created vxlan device with index %v is not vxlan", ifindex)
	}

	return vxlan, nil
}

上面通过第三方库netlink.LinkAdd函数创建vxlan设备，感兴趣请查阅相关代码

然后是获取租约信息：
输入参数： 上下文ctx, 属性信息
输出参数： 租约信息
有两个地方有该代码etcdv2/local_manager.go/kube/kube.go, 这里贴etcdv2的代码

func (m *LocalManager) AcquireLease(ctx context.Context, attrs *LeaseAttrs) (*Lease, error) {
	config, err := m.GetNetworkConfig(ctx)			//获取配置信息, 向etcd查询相关信息
	if err != nil {
		return nil, err
	}

	for i := 0; i < raceRetries; i++ {
		l, err := m.tryAcquireLease(ctx, config, attrs.PublicIP, attrs)
		switch err {
		case nil:
			return l, nil
		case errTryAgain:
			continue
		default:
			return nil, err
		}
	}

	return nil, errors.New("Max retries reached trying to acquire a subnet")
}

//输入参数：上下文ctx, config配置信息， 外部ip, 租约信息属性
//输出参数：返回租约对象
func (m *LocalManager) tryAcquireLease(ctx context.Context, config *Config, extIaddr ip.IP4, attrs *LeaseAttrs) (*Lease, error) {
	leases, _, err := m.registry.getSubnets(ctx)
	if err != nil {
		return nil, err
	}

	// Try to reuse a subnet if there's one that matches our IP
	if l := findLeaseByIP(leases, extIaddr); l != nil {			//向etcd查找是否已经存在租约信息
		// Make sure the existing subnet is still within the configured network
		if isSubnetConfigCompat(config, l.Subnet) {
			log.Infof("Found lease (%v) for current IP (%v), reusing", l.Subnet, extIaddr)

			ttl := time.Duration(0)
			if !l.Expiration.IsZero() {
				// Not a reservation
				ttl = subnetTTL
			}
			exp, err := m.registry.updateSubnet(ctx, l.Subnet, attrs, ttl, 0)	//更新子网
			if err != nil {
				return nil, err
			}

			l.Attrs = *attrs
			l.Expiration = exp
			return l, nil
		} else {
			log.Infof("Found lease (%v) for current IP (%v) but not compatible with current config, deleting", l.Subnet, extIaddr)
			if err := m.registry.deleteSubnet(ctx, l.Subnet); err != nil {		//删除已有子网
				return nil, err
			}
		}
	}

	// no existing match, check if there was a previous subnet to use
	var sn ip.IP4Net
	if !m.previousSubnet.Empty() {
		// use previous subnet					//逻辑同上，使用/run/flannel/subnet.env
		if l := findLeaseBySubnet(leases, m.previousSubnet); l != nil {
			// Make sure the existing subnet is still within the configured network
			if isSubnetConfigCompat(config, l.Subnet) {
				log.Infof("Found lease (%v) matching previously leased subnet, reusing", l.Subnet)

				ttl := time.Duration(0)
				if !l.Expiration.IsZero() {
					// Not a reservation
					ttl = subnetTTL
				}
				exp, err := m.registry.updateSubnet(ctx, l.Subnet, attrs, ttl, 0)
				if err != nil {
					return nil, err
				}

				l.Attrs = *attrs
				l.Expiration = exp
				return l, nil
			} else {
				log.Infof("Found lease (%v) matching previously leased subnet but not compatible with current config, deleting", l.Subnet)
				if err := m.registry.deleteSubnet(ctx, l.Subnet); err != nil {
					return nil, err
				}
			}
		} else {
			// Check if the previous subnet is a part of the network and of the right subnet length
			if isSubnetConfigCompat(config, m.previousSubnet) {
				log.Infof("Found previously leased subnet (%v), reusing", m.previousSubnet)
				sn = m.previousSubnet
			} else {
				log.Errorf("Found previously leased subnet (%v) that is not compatible with the Etcd network config, ignoring", m.previousSubnet)
			}
		}
	}

	if sn.Empty() {				//以上两种查询都没有满足
		// no existing match, grab a new one
		sn, err = m.allocateSubnet(config, leases)		//创建一个新的子网
		if err != nil {
			return nil, err
		}
	}

	exp, err := m.registry.createSubnet(ctx, sn, attrs, subnetTTL)		//向etcd存储信息 存活时间是24h 这样etcd中就有subnets信息
	switch {
	case err == nil:
		log.Infof("Allocated lease (%v) to current node (%v) ", sn, extIaddr)
		return &Lease{
			Subnet:     sn,
			Attrs:      *attrs,
			Expiration: exp,
		}, nil
	case isErrEtcdNodeExist(err):
		return nil, errTryAgain
	default:
		return nil, err
	}
}

简单来说，就是根据子网信息，向etcd或者/run/flannel/subnet.env查询是否存在，不存在则注册相应的子网信息到etcd。

启动监控
func (nw *network) Run(ctx context.Context) {
	wg := sync.WaitGroup{}

	log.V(0).Info("watching for new subnet leases")
	events := make(chan []subnet.Event)
	wg.Add(1)
	go func() {
		subnet.WatchLeases(ctx, nw.subnetMgr, nw.SubnetLease, events)	//对所有租约进行监控 调用watch.go 中WatchLeases函数
										// WatchLeases->watchSubnets
		log.V(1).Info("WatchLeases exited")				//获取etcd数据，阻塞方式
		wg.Done()
	}()

	defer wg.Wait()

	for {		//死循环处理所有事件
		select {
		case evtBatch := <-events:
			nw.handleSubnetEvents(evtBatch)		 //有事件发生执行处理函数

		case <-ctx.Done():
			return
		}
	}
}

func (nw *network) handleSubnetEvents(batch []subnet.Event) {
	for _, event := range batch {
		sn := event.Lease.Subnet
		attrs := event.Lease.Attrs
		if attrs.BackendType != "vxlan" {
			log.Warningf("ignoring non-vxlan subnet(%s): type=%v", sn, attrs.BackendType)
			continue
		}

		var vxlanAttrs vxlanLeaseAttrs
		if err := json.Unmarshal(attrs.BackendData, &vxlanAttrs); err != nil {		//解析json格式数据，从etcd获取的返回值
			log.Error("error decoding subnet lease JSON: ", err)
			continue
		}

		// This route is used when traffic should be vxlan encapsulated
		vxlanRoute := netlink.Route{							//跨节点容器间通信：vxlan封装的路由表
			LinkIndex: nw.dev.link.Attrs().Index,
			Scope:     netlink.SCOPE_UNIVERSE,
			Dst:       sn.ToIPNet(),
			Gw:        sn.IP.ToIP(),
		}
		vxlanRoute.SetFlag(syscall.RTNH_F_ONLINK)

		// directRouting is where the remote host is on the same subnet so vxlan isn't required.	//跨节点容器间通信(vxlan+directrouting=host-gw)：如果有开启directrouting并且节点间同子网，则直接路由
		directRoute := netlink.Route{
			Dst: sn.ToIPNet(),
			Gw:  attrs.PublicIP.ToIP(),
		}
		var directRoutingOK = false
		if nw.dev.directRouting {
			if dr, err := ip.DirectRouting(attrs.PublicIP.ToIP()); err != nil {
				log.Error(err)
			} else {
				directRoutingOK = dr
			}
		}

		switch event.Type {
		case subnet.EventAdded:
			if directRoutingOK {			//直接路由方式(vxlan+directrouting = host-gw): 只要添加路由表
				log.V(2).Infof("Adding direct route to subnet: %s PublicIP: %s", sn, attrs.PublicIP)

				if err := netlink.RouteReplace(&directRoute); err != nil {
					log.Errorf("Error adding route to %v via %v: %v", sn, attrs.PublicIP, err)
					continue
				}
			} else {				//vxlan方式: 添加arp表，添加fdb转发表，更新路由表
				log.V(2).Infof("adding subnet: %s PublicIP: %s VtepMAC: %s", sn, attrs.PublicIP, net.HardwareAddr(vxlanAttrs.VtepMAC))
				if err := nw.dev.AddARP(neighbor{IP: sn.IP, MAC: net.HardwareAddr(vxlanAttrs.VtepMAC)}); err != nil {	//添加arp表
					log.Error("AddARP failed: ", err)
					continue
				}

				if err := nw.dev.AddFDB(neighbor{IP: attrs.PublicIP, MAC: net.HardwareAddr(vxlanAttrs.VtepMAC)}); err != nil {	//添加fdb转发表
					log.Error("AddFDB failed: ", err)

					// Try to clean up the ARP entry then continue
					if err := nw.dev.DelARP(neighbor{IP: event.Lease.Subnet.IP, MAC: net.HardwareAddr(vxlanAttrs.VtepMAC)}); err != nil {
						log.Error("DelARP failed: ", err)
					}

					continue
				}

				// Set the route - the kernel would ARP for the Gw IP address if it hadn't already been set above so make sure
				// this is done last.
				if err := netlink.RouteReplace(&vxlanRoute); err != nil {			//更新路由表
					log.Errorf("failed to add vxlanRoute (%s -> %s): %v", vxlanRoute.Dst, vxlanRoute.Gw, err)

					// Try to clean up both the ARP and FDB entries then continue
					if err := nw.dev.DelARP(neighbor{IP: event.Lease.Subnet.IP, MAC: net.HardwareAddr(vxlanAttrs.VtepMAC)}); err != nil {
						log.Error("DelARP failed: ", err)
					}

					if err := nw.dev.DelFDB(neighbor{IP: event.Lease.Attrs.PublicIP, MAC: net.HardwareAddr(vxlanAttrs.VtepMAC)}); err != nil {
						log.Error("DelFDB failed: ", err)
					}

					continue
				}
			}
		case subnet.EventRemoved:
			if directRoutingOK {
				log.V(2).Infof("Removing direct route to subnet: %s PublicIP: %s", sn, attrs.PublicIP)
				if err := netlink.RouteDel(&directRoute); err != nil {		//直接路由方式(vxlan+directrouting = host-gw): 只要删除路由表
					log.Errorf("Error deleting route to %v via %v: %v", sn, attrs.PublicIP, err)
				}
			} else {
				log.V(2).Infof("removing subnet: %s PublicIP: %s VtepMAC: %s", sn, attrs.PublicIP, net.HardwareAddr(vxlanAttrs.VtepMAC))

				// Try to remove all entries - don't bail out if one of them fails.	//vxlan方式: 删除arp表，删除fdb转发表，删除路由表
				if err := nw.dev.DelARP(neighbor{IP: sn.IP, MAC: net.HardwareAddr(vxlanAttrs.VtepMAC)}); err != nil {
					log.Error("DelARP failed: ", err)
				}

				if err := nw.dev.DelFDB(neighbor{IP: attrs.PublicIP, MAC: net.HardwareAddr(vxlanAttrs.VtepMAC)}); err != nil {
					log.Error("DelFDB failed: ", err)
				}

				if err := netlink.RouteDel(&vxlanRoute); err != nil {
					log.Errorf("failed to delete vxlanRoute (%s -> %s): %v", vxlanRoute.Dst, vxlanRoute.Gw, err)
				}
			}
		default:
			log.Error("internal error: unknown event type: ", int(event.Type))
		}
	}
}

host-gw 代码实现

原理同vxlan+directRouting这里不介绍

vxlan之DirectRouting配置（原理同host-gw）

配置方式

net-conf.json: |
{
  "Network": "192.16.0.0/16",
  "Backend": {
    "Type": "vxlan",
    "DirectRouting": true
  }
}

如果集群节点间属于同网段网络，那么它们是二层可达，此时这两个节点上的跨节点容器网络间通信会自动采用host-gw的方式，也就是直接路由。
以下是master节点生成的路由，其它节点同理：

[root@k8s-new-master flannel]# ip route |grep "192.16\."
192.16.0.0/24 dev cni0 proto kernel scope link src 192.16.0.1
192.16.1.0/24 via 192.168.122.15 dev ens3
192.16.2.0/24 via 192.168.122.16 dev ens3

我们这里通过抓包看下报文的格式，以下是node1上的pod容器ip 192.16.1.58到node2上的pod容器192.16.2.19的抓包，抓包在node2的公网口上：

[root@k8s-new-node2 ~]# tcpdump -i ens3 host 192.16.1.58 -nnev
19:54:33.590095 88:4f:d5:25:80:13 > 88:4f:d5:25:80:14, ethertype IPv4 (0x0800), length 98: (tos 0x0, ttl 63, id 38285, offset 0, flags [DF], proto ICMP (1), length 84)
    192.16.1.58 > 192.16.2.19: ICMP echo request, id 28140, seq 1, length 64


19:54:33.590364 88:4f:d5:25:80:14 > 88:4f:d5:25:80:13, ethertype IPv4 (0x0800), length 98: (tos 0x0, ttl 63, id 12163, offset 0, flags [none], proto ICMP (1), length 84)
    192.16.2.19 > 192.16.1.58: ICMP echo reply, id 28140, seq 1, length 64

[root@k8s-new-node2 ~]# ifconfig ens3
ens3: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 192.168.122.16  netmask 255.255.255.0  broadcast 192.168.122.255
        ether 88:4f:d5:25:80:14  txqueuelen 1000  (Ethernet)

[root@k8s-new-node1 ns_tools]# ifconfig ens3
ens3: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 192.168.122.15  netmask 255.255.255.0  broadcast 192.168.122.255
        ether 88:4f:d5:25:80:13  txqueuelen 1000  (Ethernet)

显然报文是直接替换目的mac地址，ip层的ip没有变动。所以没有走vxlan通道，而是走了host-gw的直接路由

flannel插件配合其它插件实现网络策略(Network Policy)

后续会有完整的network policy介绍，这里链接待添加

flannel插件总结与讨论

后续如果有calico等插件，再新增，相对maxvlan的已经在本文开头对比说明。

codemillion
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
k8s搭建Kubernetes（k8s）集群用到的部署CNI网络插件
02-21
问题场景：由于k8s安装master一直处于NotReady状态查看日志出现 failed to find plugin “flannel” in path [/opt/cni/bin]【CentOS7.9】(ps:不需要积分) 解决办法：下载CNI插件，在此提供amd和arm，其他可访问链接下载 参考地址：https://github.com/containernetworking/plugins/releases/tag/v0.8.6
k8s 1.18.20版本部署
hedao0515的专栏
03-19 1194
该状态其实不影响整个集群使用，是因为默认的kube-scheduler.yaml和kube-controller-manager.yaml 中默认使用了10251和10252的端口。可以将对应的配置文件中- --port=0 给注释掉。可以自行去github,找到 flannel/Documentation/kube-flannel.yml 路径，拷贝出代码，新建文件上传，然后修改为.yml。服务器初始化配置可以参考原先我写的1.15.0版本部署方案。5.1 、生成初始化配置。5.2 、执行初始化配置。
二进制部署k8s集群之cni网络插件
最新发布
weixin_72625764的博客
02-24 1183
UDP——出现最早，性能最差。基于flanneld应用程序实现原始数据包的封装和解封装VXLAN——是flannel的默认模式，也是推荐使用模式。（与udp模式比：）性能比udp好，基于内核实现原始数据帧的封装和解封装；（与HOST-GW模式比：）配置简单使用方便。HOST-GW——性能最好的模式，但是配置复杂，且不能跨网段（通过静态路由实现）
Kubernetes部署CNI网络插件
04-18
部署CNI网络插件
网络插件 flannel原理图
04-06
k8s的的网络插件flannel原理图 ，详细解释了从docker到pod，到cni ，同节点，以及多节点通讯原理。
搭建Kubernetes（k8s）集群用到的部署CNI网络插件
05-25
搭建Kubernetes（k8s）集群用到的部署CNI网络插件，因为这个插件是国外的源，很多小伙伴没办法拿到这里分享个大家 资源源地址在 https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml
Kubernetes
淼祺的博客
06-19 274
Kubernetes
k8s搭建网络配置-kube-flannel文件内容
Warm_boyL的博客
08-01 778
k8s搭建中网络配置 kube-flannel文件内容
Docker(十六)--Docker k8s--Kubernetes集群部署
qwerty1372431588的博客
02-21 615
Kubernetes1. Kubernetes简介与架构1.1 Kubernetes简介1.2 kubernetes设计架构2. 环境的清理3. Kubernetes部署3.1 所有节点部署docker引擎3.2 禁用swap分区3.3 安装部署软件kubeadm3.4 查看默认配置信息3.5 修改镜像仓库3.6 初始化集群3.6 Master查看状态:3.7 安装flannel网络组件3.7 配置kubectl3.8 配置kubectl命令补齐功能：3.9 打包受控主机所需的镜像3.10 节点扩容3.1
kubernetes flannel源码学习疑问（一）：cni-plugin配置文件json转换为struct为何未区分plugins json数组
白熊的博客
03-02 211
最近在学习kubernetes cni部分功能，学习 flannel源码发现数据转换处于配置文件中json无法对应，特此记录。【个人学习记录，如有错误，欢迎指出】
kubernetes-flannel网络插件
01-12
flannel网络插件,CNI网络插件
kubernetes使用CNI(flannel)
u010533742的博客
03-28 1208
cat /run/flannel/subnet.env FLANNEL_NETWORK=172.120.0.0/16 FLANNEL_SUBNET=172.120.1.1/24 FLANNEL_MTU=1450 FLANNEL_IPMASQ=true overlay 同一网段下 vxlan、udp 二、Pod之间互相访问 1.flanneld将本机获取的subnet以及主机之间通信的public ip通过etcd存储起来,需要时发给相应模块 2.flanneld通过各种backend mechani
k8s network plugin is not ready: cni config uninitialized
qq_15138049的博客
11-17 3533
root@ubuntu:/opt/module/k8s# kubectl get nodes NAME STATUS ROLES AGE VERSION ubuntu NotReady master 51m v1.11.1 ################################ root@ubuntu:/opt/cni/bin# journalctl -fu kubelet -- Logs begin at Fri 2021-0
kubernetes-flannel 网络组件CNI配置过程
kozazyh的专栏
03-14 9894
测试环境： k8s v1.10.5 CNI Plugin : 0.6.0 flannel: 0.11.0 flannel cni 配置过程： Container Network Interface (CNI) 最早是由CoreOS发起的容器网络规范，是Kubernetes网络插件的基础。其基本思想为：Container Runtime在创建容器时，先创建好network namespace...
The connection to the server localhost:8080 was refused
志趣
10-20 8680
最近在学习安装Kubernetes集群的时候，安装完执行sudo kubectl get nodes命令出现这个报错。下面是解决方法。 Master节点出现这个报错 首先需要检查Master安装完Kubernetes后是否执行了下面命令，有时在普通用户下使用sudo执行了下面命令，但是到root根目录确发现没有相应的文件夹和文件，暂不知为何，所以最好在root用户下执行下面命令： mkdir -p $HOME/.kube #root用户下执行不需要加sudo sudo cp -i /etc/kubernet
解决k8s拉取flannel失败的方法
llzhh的博客
06-22 2962
我们可以wget或者直接网页打开该地址，获取该yaml文件内容，保存到本地，文件名仍然为。中报错信息有denied等字样，可能是阿里云仓库中设为私有仓库，设为公有仓库即可。作为一个完全不懂k8s和docker的新手，我琢磨出以下曲线解决方案。这里使用的阿里云个人镜像仓库，网上有很多教程如何注册，不再赘述。时失败了，默认拉取的镜像仓库在国外，被墙了。这一步网上资料很多，不再赘述，只要保证执行。，再将步骤3.2下载的镜像上传到仓库中。可得到需要的镜像的地址，此时就可以用。对比步骤3.2，更改后的。
k8s安装网络插件-flannel
热门推荐
蛋疼的NICK
06-13 1万+
k8s安装网络插件-flannel
flannel ImagePullBackOff
mayi_xiaochaun的博客
03-03 1107
按照搭建Kubernetes时官网给的命令 kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml master节点flannel 拉取镜像失败 查看详细信息： kubectl describe pod kube-flannel-ds-xtfvq -n kube-system 打印如下： 解决方案1：node节点 pull成功，..
k8s网络插件-flannel 部署
06-28
### 回答1： k8s网络插件-flannel 部署： 1. 安装etcd Flannel需要etcd来存储网络配置信息，因此需要先安装etcd。可以使用以下命令安装： ``` $ sudo apt-get update $ sudo apt-get install etcd ``` 2. 下载flannel二进制文件 可以从github上下载flannel的二进制文件，例如： ``` $ wget https://github.com/coreos/flannel/releases/download/v.13.1/flannel-v.13.1-linux-amd64.tar.gz $ tar -zxvf flannel-v.13.1-linux-amd64.tar.gz ``` 3. 部署flannel 可以使用以下命令部署flannel： ``` $ sudo ./flanneld --etcd-endpoints=http://<etcd-ip>:2379 --iface=<interface> ``` 其中，`<etcd-ip>`是etcd的IP地址，`<interface>`是flannel要使用的网络接口。 4. 配置kubelet 在每个节点上，需要配置kubelet以使用flannel。可以在kubelet的启动参数中添加以下参数： ``` --network-plugin=cni --cni-conf-dir=/etc/cni/net.d --cni-bin-dir=/opt/cni/bin ``` 5. 部署flannel网络 可以使用以下命令部署flannel网络： ``` $ kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml ``` 6. 验证flannel网络 可以使用以下命令验证flannel网络是否正常： ``` $ kubectl get pods --all-namespaces -o wide ``` 如果所有的pod都处于Running状态，则说明flannel网络已经正常部署。 ### 回答2： 在Kubernetes集群中，网络插件是一个非常重要的组件，负责实现集群中各个节点之间的通信，同时也支持容器和宿主机之间的通信。Flannel就是一款常见的Kubernetes网络插件，下面将为你介绍Flannel如何部署。 1. 编写Flannel配置文件 在部署Flannel之前，需要先编写Flannel的配置文件。创建一个yaml文件，填写以下内容： ``` apiVersion: v1 kind: ConfigMap metadata: name: kube-flannel-cfg namespace: kube-system data: cni-conf.json: | { "name": "cbr0", "plugins": [ { "type": "flannel", "delegate": { "hairpinMode": true, "isDefaultGateway": true } }, { "type": "portmap", "capabilities": { "portMappings": true } } ] } ``` 保存文件为flannel-config.yaml。 2. 创建Flannel服务账号 创建一个服务账号，运行以下命令： ``` kubectl apply -f https:/raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml ``` 这个命令将会自动部署Flannel服务并创建相关资源。 3. 部署Flannel 接下来，运行以下命令来部署Flannel： ``` kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/v0.9.1/Documentation/kube-flannel.yml ``` 这个命令会创建一个DeamonSet对象，这个对象会在集群中的每个节点上运行一个Flannel容器。 4. 验证Flannel部署 在完成Flannel安装之后，可以通过运行以下命令来检查是否一切顺利： ``` kubectl get pods -n kube-system ``` 如果输出结果中包含有flannel开头的Pod，则表示Flannel已经成功部署。 总结 刚才我们介绍了如何在Kubernetes集群中部署Flannel网络插件，主要的步骤包括编写Flannel配置文件、创建Flannel服务账号、部署Flannel、验证Flannel部署等。通过这个过程，我们可以更加深入地了解Flannel的配置和使用方法，还可以通过这个代码来学习如何使用Kubernetes的API进行资源的创建和管理。 ### 回答3： k8s网络插件-flannel部署 k8s是一个分布式系统，为了实现各个节点之间的通信，需要有一个网络插件来管理网络连接。其中，Flannel就是最常用的一种网络插件，它主要的作用是将各个节点的IP地址进行转换，而流量则通过这些IP地址进行转发，从而实现多个节点之间的网络通信。 Flannel的部署主要分为以下几个步骤： 1.安装etcd 在节点中安装etcd，可以使用yum或apt-get等包管理器进行安装。在这个过程中，需要注意etcd的版本和操作系统之间的兼容性，以避免出现问题。 2.部署flannel 可以先下载最新的flannel二进制文件，然后将其部署到各个节点上。在这个过程中，需要修改flannel的配置文件，以指定etcd的地址和网络配置等相关信息。 3.配置kubelet和kube-proxy 为了让k8s系统能够正常地使用flannel网络插件，需要对kubelet和kube-proxy进行配置。可以通过修改它们的启动配置文件，将其网络模式设置为flannel，并指定相关参数。 4.测试网络连接 在完成以上步骤后，可以使用一些工具来测试节点之间的网络连接情况，例如ping命令和nslookup命令等。如果连接正常，就可以开始在k8s系统中进行容器的部署和管理了。 总的来说，Flannel是k8s系统中必不可少的一个组件，它可以帮助我们有效地管理节点之间的网络连接，从而达到更好的分布式系统效果。在部署Flannel时需要注意一些细节，以确保其正常运作，并加强系统的可靠性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

codemillion

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值