Kubernetes_容器网络_Flannel_01_Flannel简介_kube-flannel

一、概述

Kubernetes 采用的是基于扁平地址空间的、非NAT的网络模型，每个Pod有自己唯一的IP地址。网络是由CNI(container network interface)插件建立的，而非K8S本身。

CNI 和 Calico关系：CNI 是一个容器网络标准，是理论上的，是一个标准，相当于SPI，其他的 Calico Flannel 都是实现了的 CNI 插件。

二、常见的几种CNI插件介绍

为了使容器之间的通信更加方便，Google 和 CoreOS 主导制定了一个容器网络标准CNI(Conteinre Network Interface) 。

k8s官网：https://kubernetes.io/docs/concepts/cluster-administration/addons/
CNI可允许K8S配置任何CNI插件，常见的CNI插件有以下几种：

1）Flannel(本文讲解)

Flannel是由CoreOS开发的项目，是容器编排系统中最成熟的网络结构示例之一，旨在实现更好的容器间和主机间网络。

与其他方案相比，Flannel相对容易安装和配置。它被打包为单个二进制文件flanneld，许多常见的Kubernetes集群部署工具和许多Kubernetes发行版都可以默认安装Flannel。Flannel可以使用Kubernetes集群的现有etcd集群来使用API存储其状态信息，因此不需要专用的数据存储。

详细参考 https://github.com/coreos/flannel
官网：https://coreos.com/flannel/docs/latest/
文档：https://coreos.com/flannel/docs/latest/kubernetes.html

2）Calico

Calico是Kubernetes生态系统中另一种流行的网络选择，它提供收费的技术支持。虽然Flannel被公认为是最简单的选择，但Calico以其性能、灵活性而闻名。Calico的功能更为全面，更为复杂。它不仅提供主机和pod之间的网络连接，还涉及网络安全和管理。Calico CNI插件在CNI框架内封装了Calico的功能。

详细参考 https://github.com/projectcalico/cni-plugin

3）Romana

Romana是Panic Networks在2016年新提出的开源项目，旨在解决Overlay方案给网络带来的开销。虽然目标和Calico基本一致，但其采取的方法却截然不同，具体项目的发展有待观察。

4）Weave Nets

大家都叫惯了weave，实际上目前该产品的名字叫做Weave Nets。

Weave是由Weaveworks提供的一种插件，它提供的模式是在集群中的节点之间创建网状的overlay网络。与Calico一样，Weave也为Kubernetes集群提供网络策略功能。

三、Flannel 组件的解释

Cni0：网桥设备，每创建一个pod都会创建一对 veth pair，其中一端是pod中的eth0，另一端是Cni0网桥中的端口 （网卡），Pod中从网卡eth0发出的流量都会发送到Cni0网桥设备的端口（网卡）上，Cni0 设备获得的ip地址是该节 点分配到的网段的第一个地址。
Flannel.1：overlay网络的设备，用来进行vxlan报文的处理（封包和解包），不同node之间的pod数据流量都从 overlay设备以隧道的形式发送到对端。
Flannel的系统文件及目录

find / -name flannel
1

当前node主机IP地址范围

cat /run/flannel/subnet.env
1

当前node主机IP地址范围

cat /run/flannel/subnet.env
1

如何给k8s集群安装和使用Flannel插件

参考链接(亲测可用)：https://blog.csdn.net/inthat/article/details/103921026

---
kind: Namespace
apiVersion: v1
metadata:
  name: kube-flannel
  labels:
    pod-security.kubernetes.io/enforce: privileged
---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: flannel
rules:
- apiGroups:
  - ""
  resources:
  - pods
  verbs:
  - get
- apiGroups:
  - ""
  resources:
  - nodes
  verbs:
  - get
  - list
  - watch
- apiGroups:
  - ""
  resources:
  - nodes/status
  verbs:
  - patch
- apiGroups:
  - "networking.k8s.io"
  resources:
  - clustercidrs
  verbs:
  - list
  - watch
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: flannel
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: flannel
subjects:
- kind: ServiceAccount
  name: flannel
  namespace: kube-flannel
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: flannel
  namespace: kube-flannel
---
kind: ConfigMap
apiVersion: v1
metadata:
  name: kube-flannel-cfg
  namespace: kube-flannel
  labels:
    tier: node
    app: flannel
data:
  cni-conf.json: |
    {
      "name": "cbr0",
      "cniVersion": "0.3.1",
      "plugins": [
        {
          "type": "flannel",
          "delegate": {
            "hairpinMode": true,
            "isDefaultGateway": true
          }
        },
        {
          "type": "portmap",
          "capabilities": {
            "portMappings": true
          }
        }
      ]
    }
  net-conf.json: |
    {
      "Network": "10.244.0.0/16",
      "Backend": {
        "Type": "vxlan"
      }
    }
---
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: kube-flannel-ds
  namespace: kube-flannel
  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
      hostNetwork: true
      priorityClassName: system-node-critical
      tolerations:
      - operator: Exists
        effect: NoSchedule
      serviceAccountName: flannel
      initContainers:
      - name: install-cni-plugin
        image: docker.io/flannel/flannel-cni-plugin:v1.1.2
        command:
        - cp
        args:
        - -f
        - /flannel
        - /opt/cni/bin/flannel
        volumeMounts:
        - name: cni-plugin
          mountPath: /opt/cni/bin
      - name: install-cni
        image: docker.io/flannel/flannel:v0.20.2
        command:
        - cp
        args:
        - -f
        - /etc/kube-flannel/cni-conf.json
        - /etc/cni/net.d/10-flannel.conflist
        volumeMounts:
        - name: cni
          mountPath: /etc/cni/net.d
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
      containers:
      - name: kube-flannel
        image: docker.io/flannel/flannel:v0.20.2
        command:
        - /opt/bin/flanneld
        args:
        - --ip-masq
        - --kube-subnet-mgr
        resources:
          requests:
            cpu: "100m"
            memory: "50Mi"
        securityContext:
          privileged: false
          capabilities:
            add: ["NET_ADMIN", "NET_RAW"]
        env:
        - name: POD_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        - name: POD_NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
        - name: EVENT_QUEUE_DEPTH
          value: "5000"
        volumeMounts:
        - name: run
          mountPath: /run/flannel
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
        - name: xtables-lock
          mountPath: /run/xtables.lock
      volumes:
      - name: run
        hostPath:
          path: /run/flannel
      - name: cni-plugin
        hostPath:
          path: /opt/cni/bin
      - name: cni
        hostPath:
          path: /etc/cni/net.d
      - name: flannel-cfg
        configMap:
          name: kube-flannel-cfg
      - name: xtables-lock
        hostPath:
          path: /run/xtables.lock
          type: FileOrCreate
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206

安装完成之后，成功标志，如下：

四、Flannel底层网络通信全过程

1）同节点Pod之间的通信

在容器启动前，会为容器创建一个虚拟Ethernet接口对，这个接口对类似于管道的两端，其中一端在主机命名空间中，另外一端在容器命名空间中，并命名为eth0。在主机命名空间的接口会绑定到网桥。网桥的地址段会取IP赋值给容器的eth0接口。

实验

【实验】这里利用nodeName特性将Pod调度到相同的node节点上（亲和性），创建两个pod

cat >p1.yaml<<EOF
apiVersion: v1
kind: Pod
metadata:
  labels:
    run: nginx
  name: p1
  namespace: default
spec:
  nodeName: k8s-node1
  containers:
  - image: busybox
    name: c1
    command: 
    - "ping"
    - "baidu.com"
EOF

cat >p2.yaml<<EOF
apiVersion: v1
kind: Pod
metadata:
  labels:
    run: busybox
  name: p2
  namespace: default
spec:
  nodeName: k8s-node1
  containers:
  - image: busybox
    name: c2
    command: 
    - "ping"
    - "baidu.com"
EOF
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

执行

$ kubectl apply -f p1.yaml -f p2.yaml
$ kubectl get pod p{1,2}
$ kubectl get pod p{1,2} -o wide
# p1 ping p2
$ kubectl exec -it p1 -- ping 10.244.1.230
1
2
3
4
5

工作流程

步骤1：源容器向目标容器发送数据，数据首先发送给 cni0 网桥

查看路由

kubectl exec -it p1 -c c1 -- ip route
kubectl exec -it p2 -c c2 -- ip route
1
2

步骤2：cni0 网桥接受到数据后，将其转交给 flannel.1 虚拟网卡处理

cni0 收到数据包后，docker0的内核栈处理程序会读取这个数据包的目标地址，根据目标地址将数据包发送给下一个路由节点：

ip a
ip route
1
2

步骤3： flannel.1 接受到数据后，对数据进行封装，并发给宿主机的 ens33，再通过ens33出外网，或者访问不同node节点上的pod

针对相同节点上的pod通信，直接cni0 网桥通信，流程如下图：

2）不同节点Pod之间的通信

【实验】这里利用nodeName特性将Pod调度到不同的node节点上（亲和性），创建两个pod

$ cat >p3.yaml<<EOF
apiVersion: v1
kind: Pod
metadata:
  labels:
    run: nginx
  name: p3
  namespace: default
spec:
  nodeName: k8s-node1
  containers:
  - image: busybox
    name: c3
    command: 
    - "ping"
    - "baidu.com"
EOF

$ cat >p4.yaml<<EOF
apiVersion: v1
kind: Pod
metadata:
  labels:
    run: busybox
  name: p4
  namespace: default
spec:
  nodeName: k8s-node2
  containers:
  - image: busybox
    name: c4
    command: 
    - "ping"
    - "baidu.com"
EOF
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

执行

$ kubectl apply -f p3.yaml -f p4.yaml
$ kubectl get pod p{3,4}
$ kubectl get pod p{3,4} -o wide
# p3 ping p4
$ kubectl exec -it p3 -- ping 10.244.1.230
1
2
3
4
5

工作流程上面已经讲解了，这里就不重复了。流程如下图：

3）Pod与Service之间的通信

在不同节点上的Pod通信中，我们知道了Pod是以IP地址进行通信，但Kubernetes 的集群中， Pod 可能会频繁的销毁和创建，也就是说 Pod 的 IP 不是固定的。为了解决这个问题，Service 提供了访问 Pod 的抽象层，即为一组功能相同的Pod提供单一不变的接入点资源。无论后端的 Pod 如何变化，Service 都作为稳定的前端对外提供服务。同时，Service 还提供了高可用和负载均衡功能，Service 负责将请求转发给正确的 Pod。

【实验】因为在pod基本上都是由控制器管理，不明白控制器的，可以看这里，所以这里就创建Service和Deployment

cat >Service-Deployment-test001.yaml<<EOF
apiVersion: v1
kind: Service
metadata:
  name: nginx-svc001
  labels:
    app: nginx-svc001
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
    nodePort: 30080
  type: NodePort 
---
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: nginx-deployment001
spec:
  replicas: 2
  selector:
    matchLabels:
     app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx
        ports:
        - containerPort: 80
EOF
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

执行

$ kubectl apply -f Service-Deployment-test001.yaml
$ kubectl get pod -o wide|grep nginx-deployment001
$ kubectl get svc nginx-svc001
1
2
3

发现每个node节点上都运行了一个pod，curl验证是否正常访问

$ curl 192.168.0.113:30080
1

$ ipvsadm -Ln|grep -A10 10.1.35.17
$ ss -tnlp|grep 30080
1
2

流程图如下：

五、尾声

学会安装使用是最重要的，底层原理了解就好。

Flannel参考资料(两篇质量很好的讲Flannel底层原理的博客，Flannel看完这两篇就好)：
https://liugp.blog.csdn.net/article/details/120683489
https://blog.csdn.net/inthat/article/details/103921026 [这篇博客里面有yaml安装flannel的具体方式(亲测有效)]
https://www.cnblogs.com/skyzy/p/16891033.html
https://blog.csdn.net/bh451326803/article/details/125263918
flannel安装与配置： https://blog.csdn.net/m0_58541541/article/details/123258060
虚拟化安装：etcd+flannel+docker https://blog.51cto.com/mshxuyi/5858681
flannel网络问题，各个节点之间的Pod无法ping通：https://blog.csdn.net/qq_46274911/article/details/127291080
在K8s集群中安装和配置Flannel网络：https://code84.com/788163.html
安装flannel网络插件：https://blog.csdn.net/baidu_38432732/article/details/108001284

https://liugp.blog.csdn.net/article/details/120683489