二进制安装K8S(单Master集群架构)
目录
- 一、安装K8S
-
- 1、单Master集群架构
- 2、操作系统初始化配置
- 3、部署docker引擎
- 4、部署 etcd 集群
- 5、部署 Master 组件
- 6、部署 Worker Node 组件
- 7、部署 CNI 网络组件
-
- 7.1 部署 flannel
- 7.2 Flannel udp 模式的工作原理（必备面试题）
- 7.3 Flannel vxlan 模式的工作原理（必备面试题）
- 8、部署 CoreDNS
一、安装K8S
1、单Master集群架构
k8s集群master01：192.168.154.10 kube-apiserver kube-controller-manager kube-scheduler etcd
k8s集群master02：192.168.154.20
k8s集群node01：192.168.154.11 kubelet kube-proxy docker
k8s集群node02：192.168.154.12
etcd集群节点1：192.168.154.10 etcd
etcd集群节点2：192.168.154.11
etcd集群节点3：192.168.154.12
2、操作系统初始化配置
#关闭防火墙
systemctl stop firewalld
systemctl disable firewalld
iptables -F && iptables -t nat -F && iptables -t mangle -F && iptables -X
#关闭selinux
setenforce 0
sed -i 's/enforcing/disabled/' /etc/selinux/config
#关闭swap
swapoff -a
sed -ri 's/.*swap.*/#&/' /etc/fstab
#根据规划设置主机名
hostnamectl set-hostname master01
hostnamectl set-hostname node01
hostnamectl set-hostname node02
#在master添加hosts
cat >> /etc/hosts << EOF
192.168.154.10 master01
192.168.154.11 node01
192.168.154.12 node02
EOF
#调整内核参数
cat > /etc/sysctl.d/k8s.conf << EOF
#开启网桥模式，可将网桥的流量传递给iptables链
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
#关闭ipv6协议
net.ipv6.conf.all.disable_ipv6=1
net.ipv4.ip_forward=1
EOF
sysctl --system
#时间同步
yum install ntpdate -y
ntpdate time.windows.com
3、部署docker引擎
#安装依赖包
yum install -y yum-utils device-mapper-persistent-data lvm2
--------------------------------------------------------------------------------------------
yum-utils：提供了 yum-config-manager 工具。
device mapper： 是Linux内核中支持逻辑卷管理的通用设备映射机制，它为实现用于存储资源管理的块设备驱动提供了一个高度模块化的内核架构。
device mapper存储驱动程序需要 device-mapper-persistent-data 和 lvm2。
--------------------------------------------------------------------------------------------
#设置阿里云镜像源
yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
#安装 Docker-CE并设置为开机自动启动
yum install -y docker-ce docker-ce-cli containerd.io
cd /etc/docker/
cat > /etc/docker/daemon.json <<EOF
{
"registry-mirrors": ["https://6ijb8ubo.mirror.aliyuncs.com"],
"exec-opts": ["native.cgroupdriver=systemd"],
"log-driver": "json-file",
"log-opts": {
"max-size": "500m","max-file": "3"
}
}
EOF
systemctl start docker.service
systemctl enable docker.service
4、部署 etcd 集群
etcd是CoreOS团队于2013年6月发起的开源项目，它的目标是构建一个高可用的分布式键值（key-value）数据库。etcd内部采用raft协议作为一致性算法，etcd是go语言编写的。
etcd 作为服务发现系统，有以下的特点：
简单：安装配置简单，而且提供了HTTP API进行交互，使用也很简单
安全：支持SSL证书验证
快速：单实例支持每秒2k+读操作
可靠：采用raft算法，实现分布式系统数据的可用性和一致性
etcd 目前默认使用2379端口提供HTTP API服务， 2380端口和peer通信(这两个端口已经被IANA(互联网数字分配机构)官方预留给etcd)。 即etcd默认使用2379端口对外为客户端提供通讯，使用端口2380来进行服务器间内部通讯。
etcd 在生产环境中一般推荐集群方式部署。由于etcd 的leader选举机制，要求至少为3台或以上的奇数台。
//在 master01 节点上操作
#准备cfssl证书生成工具
wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64 -O /usr/local/bin/cfssl
wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64 -O /usr/local/bin/cfssljson
wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64 -O /usr/local/bin/cfssl-certinfo
chmod +x /usr/local/bin/cfssl*
------------------------------------------------------------------------------------------
cfssl：证书签发的工具命令
cfssljson：将 cfssl 生成的证书（json格式）变为文件承载式证书
cfssl-certinfo：验证证书的信息
cfssl-certinfo -cert <证书名称> #查看证书的信息
------------------------------------------------------------------------------------------
### 生成Etcd证书 ###
mkdir /opt/k8s
cd /opt/k8s/
#上传 etcd-cert.sh 和 etcd.sh 到 /opt/k8s/ 目录中
chmod +x etcd-cert.sh etcd.sh
#创建用于生成CA证书、etcd 服务器证书以及私钥的目录
mkdir /opt/k8s/etcd-cert
mv etcd-cert.sh etcd-cert/
cd /opt/k8s/etcd-cert/
./etcd-cert.sh #生成CA证书、etcd 服务器证书以及私钥
ls
ca-config.json ca-csr.json ca.pem server.csr server-key.pem
ca.csr ca-key.pem etcd-cert.sh server-csr.json server.pem
#上传 etcd-v3.4.9-linux-amd64.tar.gz 到 /opt/k8s 目录中，启动etcd服务
cd /opt/k8s/
tar zxvf etcd-v3.4.9-linux-amd64.tar.gz
ls etcd-v3.4.9-linux-amd64
Documentation etcd etcdctl README-etcdctl.md README.md READMEv2-etcdctl.md
------------------------------------------------------------------------------------------
etcd就是etcd 服务的启动命令，后面可跟各种启动参数
etcdctl主要为etcd 服务提供了命令行操作
------------------------------------------------------------------------------------------
#创建用于存放 etcd 配置文件，命令文件，证书的目录
mkdir -p /opt/etcd/{cfg,bin,ssl}
cd /opt/k8s/etcd-v3.4.9-linux-amd64/
mv etcd etcdctl /opt/etcd/bin/
cp /opt/k8s/etcd-cert/*.pem /opt/etcd/ssl/
cd /opt/k8s/
./etcd.sh etcd01 192.168.154.10 etcd02=https://192.168.154.11:2380,etcd03=https://192.168.154.12:2380
#进入卡住状态等待其他节点加入，这里需要三台etcd服务同时启动，如果只启动其中一台后，服务会卡在那里，直到集群中所有etcd节点都已启动，可忽略这个情况
#可另外打开一个窗口查看etcd进程是否正常
ps -ef | grep etcd
#把etcd相关证书文件、命令文件和服务管理文件全部拷贝到另外两个etcd集群节点
scp -r /opt/etcd/ [email protected]:/opt/
scp -r /opt/etcd/ [email protected]:/opt/
scp /usr/lib/systemd/system/etcd.service [email protected]:/usr/lib/systemd/system/
scp /usr/lib/systemd/system/etcd.service [email protected]:/usr/lib/systemd/system/
//在 master01 节点上操作
cd /opt
ls -R etcd/
scp -r etcd/ node01:/opt
scp -r etcd/ node02:/opt
cd /usr/lib/systemd/system
ls etcd.service
scp etcd.service node01:`pwd`
scp etcd.service node02:`pwd`
在node01节点上操作
cd /opt/etcd/cfg
vim etcd
#[Member]
ETCD_NAME="etcd02"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.154.11:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.154.11:2379"
#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.154.11:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.154.11:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.154.10:2380,etcd02=https://192.168.154.11:2380,etcd03=https://192.168.154.12:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
#启动etcd服务
systemctl daemon-reload
systemctl enable --now etcd.service
systemctl status etcd.service
在node02节点上操作
cd /opt/etcd/cfg
vim etcd
#[Member]
ETCD_NAME="etcd03"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.154.12:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.154.12:2379"
#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.154.12:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.154.12:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.154.10:2380,etcd02=https://192.168.154.11:2380,etcd03=https://192.168.154.12:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
#启动etcd服务
systemctl daemon-reload
systemctl enable --now etcd.service
systemctl status etcd.service
#检查etcd群集状态
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem --endpoints="https://192.168.154.10:2379,https://192.168.154.11:2379,https://192.168.154.12:2379" endpoint health --write-out=table
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://192.168.154.10:2379,https://192.168.154.11:2379,https://192.168.154.12:2379" --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem --write-out=table endpoint status
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://192.168.154.10:2379,https://192.168.154.11:2379,https://192.168.154.12:2379" --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem --write-out=table member list
实现etcd的备份操作
cd
mkdir etcd/backup -p
cd etcd/
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://192.168.154.10:2379" --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem snapshot save /root/etcd-snapshot.db
恢复etcd的操作
//查看etcd-snapshot.db的文件
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://192.168.154.10:2379" --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem snapshot status ./etcd-snapshot.db --write-out=table
//恢复etcd
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://192.168.154.10:2379" --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem snapshot restore ./etcd-snapshot.db
5、部署 Master 组件
//在 master01 节点上操作
#上传 master.zip 和 kubernetes-server-linux-amd64.tar.gz 到 /opt/k8s 目录中，解压 master.zip 压缩包
cd /opt/k8s/
unzip master.zip
chmod +x *.sh
#创建kubernetes工作目录
mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs}
#创建用于生成CA证书、相关组件的证书和私钥的目录
mkdir /opt/k8s/k8s-cert
mv /opt/k8s/k8s-cert.sh /opt/k8s/k8s-cert
cd /opt/k8s/k8s-cert/
vim k8s-cert.sh #改地址
./k8s-cert.sh #生成CA证书、相关组件的证书和私钥
ls *pem
admin-key.pem apiserver-key.pem ca-key.pem kube-proxy-key.pem
admin.pem apiserver.pem ca.pem kube-proxy.pem
#复制CA证书、apiserver相关证书和私钥到 kubernetes工作目录的 ssl 子目录中
cp kube-apiserver kube-controller-manager kube-scheduler kubectl /opt/kubernetes/bin/
#上传 kubernetes-server-linux-amd64.tar.gz 到 /opt/k8s/ 目录中，解压 kubernetes 压缩包
cd /opt/k8s/
tar zxvf kubernetes-server-linux-amd64.tar.gz
#复制master组件的关键命令文件到 kubernetes工作目录的 bin 子目录中
cd /opt/k8s/kubernetes/server/bin
cp kube-apiserver kubectl kube-controller-manager kube-scheduler /opt/kubernetes/bin/
ln -s /opt/kubernetes/bin/* /usr/local/bin/
#创建 bootstrap token 认证文件，apiserver 启动时会调用，然后就相当于在集群内创建了一个这个用户，接下来就可以用 RBAC 给他授权
cd /opt/k8s/
vim token.csv
cfe2bd4ece1251173600ff7fd6b02410,kubelet-bootstrap,10001,"system:kubelet-bootstrap"
mv token.csv /opt/kubernetes/cfg/
chmod +x *.sh
vim apiserver.sh
./apiserver.sh 192.168.154.10 https://192.168.154.10:2379,https://192.168.154.11:2379,https://192.168.154.12:2379
#检查进程是否启动成功
ps aux | grep kube-apiserver
netstat -natp | grep 6443 #安全端口6443用于接收HTTPS请求，用于基于Token文件或客户端证书等认证
#启动 controller-manager 服务
./controller-manager.sh
ps aux | grep kube-controller-manager
#启动 scheduler 服务
cd /opt/k8s/
./scheduler.sh
ps aux | grep kube-scheduler
#生成kubectl连接集群的kubeconfig文件
./admin.sh
#绑定默认cluster-admin管理员集群角色，授权kubectl访问集群
kubectl create clusterrolebinding cluster-system-anonymous --clusterrole=cluster-admin --user=system:anonymous
#通过kubectl工具查看当前集群组件状态
kubectl get cs
NAME STATUS MESSAGE ERROR
controller-manager Healthy ok
scheduler Healthy ok
etcd-2 Healthy {"health":"true"}
etcd-1 Healthy {"health":"true"}
etcd-0 Healthy {"health":"true"}
#查看版本信息
kubectl version
6、部署 Worker Node 组件
//在所有 node 节点上操作
#创建kubernetes工作目录
mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs}
#上传 node.zip 到 /opt 目录中，解压 node.zip 压缩包，获得kubelet.sh、proxy.sh
cd /opt/
unzip node.zip
chmod +x kubelet.sh proxy.sh
//在 master01 节点上操作
#把 kubelet、kube-proxy 拷贝到 node 节点
cd /opt/k8s/kubernetes/server/bin
scp kubelet kube-proxy [email protected]:/opt/kubernetes/bin/
scp kubelet kube-proxy [email protected]:/opt/kubernetes/bin/
#上传kubeconfig.sh文件到/opt/k8s/kubeconfig目录中，生成kubelet初次加入集群引导kubeconfig文件和kube-proxy.kubeconfig文件
#kubeconfig 文件包含集群参数（CA 证书、API Server 地址），客户端参数（上面生成的证书和私钥），集群 context 上下文参数（集群名称、用户名）。Kubenetes 组件（如 kubelet、kube-proxy）通过启动时指定不同的 kubeconfig 文件可以切换到不同的集群，连接到 apiserver。
mkdir /opt/k8s/kubeconfig
cd /opt/k8s/kubeconfig
chmod +x kubeconfig.sh
./kubeconfig.sh 192.168.154.10 /opt/k8s/k8s-cert/
#把配置文件 bootstrap.kubeconfig、kube-proxy.kubeconfig 拷贝到 node 节点
scp bootstrap.kubeconfig kube-proxy.kubeconfig [email protected]:/opt/kubernetes/cfg/
scp bootstrap.kubeconfig kube-proxy.kubeconfig [email protected]:/opt/kubernetes/cfg/
#RBAC授权，使用户 kubelet-bootstrap 能够有权限发起 CSR 请求证书
kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap
------------------------------------------------------------------------------------------
kubelet 采用 TLS Bootstrapping 机制，自动完成到 kube-apiserver 的注册，在 node 节点量较大或者后期自动扩容时非常有用。
Master apiserver 启用 TLS 认证后，node 节点 kubelet 组件想要加入集群，必须使用CA签发的有效证书才能与 apiserver 通信，当 node 节点很多时，签署证书是一件很繁琐的事情。因此 Kubernetes 引入了 TLS bootstraping 机制来自动颁发客户端证书，kubelet 会以一个低权限用户自动向 apiserver 申请证书，kubelet 的证书由 apiserver 动态签署。
kubelet 首次启动通过加载 bootstrap.kubeconfig 中的用户 Token 和 apiserver CA 证书发起首次 CSR 请求，这个 Token 被预先内置在 apiserver 节点的 token.csv 中，其身份为 kubelet-bootstrap 用户和 system:kubelet-bootstrap 用户组；想要首次 CSR 请求能成功（即不会被 apiserver 401 拒绝），则需要先创建一个 ClusterRoleBinding，将 kubelet-bootstrap 用户和 system:node-bootstrapper 内置 ClusterRole 绑定（通过 kubectl get clusterroles 可查询），使其能够发起 CSR 认证请求。
TLS bootstrapping 时的证书实际是由 kube-controller-manager 组件来签署的，也就是说证书有效期是 kube-controller-manager 组件控制的；kube-controller-manager 组件提供了一个 --experimental-cluster-signing-duration 参数来设置签署的证书有效时间；默认为 8760h0m0s，将其改为 87600h0m0s，即 10 年后再进行 TLS bootstrapping 签署证书即可。
也就是说 kubelet 首次访问 API Server 时，是使用 token 做认证，通过后，Controller Manager 会为 kubelet 生成一个证书，以后的访问都是用证书做认证了。
TLS bootstrapping 机制
有master的组件自动给kubelet签发证书
1）kubelet首次访问apiserver，是通过bootstrap.kubeconfig的token来认证的
2）kubelet会以一个低权限用户（token.csv里的kubelet-bootstrap）向apiserver发起CSR请求申请证书
3）如果apiserver通过CSR请求后，会由controller-manager根据配置文件生成证书，并通过apiserver发给kubelet
4) kubelet以后再访问apiserver就会使用签发的证书来做认证
------------------------------------------------------------------------------------------
//在 node01 节点上操作
//启动 kubelet 服务
cd /opt/
./kubelet.sh 192.168.154.11
ps aux | grep kubelet
//在 master01 节点上操作，通过 CSR 请求
//检查到 node01 节点的 kubelet 发起的 CSR 请求，Pending 表示等待集群给该节点签发证书
kubectl get csr
NAME AGE SIGNERNAME REQUESTOR CONDITION
node-csr-x-o7xwAYtP0-Cxemis_3WpGD5DFOadHldFQTK4UegTw 50s kubernetes.io/kube-apiserver-client-kubelet kubelet-bootstrap Pending
//通过 CSR 请求
kubectl certificate approve node-csr-x-o7xwAYtP0-Cxemis_3WpGD5DFOadHldFQTK4UegTw
//Approved,Issued 表示已授权 CSR 请求并签发证书
kubectl get csr
//查看节点，由于网络插件还没有部署，节点会没有准备就绪 NotReady
kubectl get nodes
//在 node01 节点上操作
//加载 ip_vs 模块
for i in $(ls /usr/lib/modules/$(uname -r)/kernel/net/netfilter/ipvs|grep -o "^[^.]*");do echo $i; /sbin/modinfo -F filename $i >/dev/null 2>&1 && /sbin/modprobe $i;done
//启动proxy服务
cd /opt/
./proxy.sh 192.168.154.11
ps aux | grep kube-proxy
ls kubernetes/ssl/
//自动批准 CSR 请求
//在Master01主节点
kubectl create clusterrolebinding node-autoapprove-bootstrap --clusterrole=system:certificates.k8s.io:certificatesigningrequests:nodeclient --user=kubelet-bootstrap
kubectl create clusterrolebinding node-autoapprove-certificate-rotation --clusterrole=system:certificates.k8s.io:certificatesigningrequests:selfnodeclient --user=kubelet-bootstrap
//在node01节点
cd /opt
scp kubelet.sh proxy.sh 192.168.154.12:/opt
//在node01节点
cd /opt
./kubelet.sh 192.168.154.12
ps aux | grep kubelet
ls kubernetes/ssl/
再回Master主节点查看
kubectl get nodes
在这里插入图片描述
7、部署 CNI 网络组件
7.1 部署 flannel
K8S 中 Pod 网络通信：
●Pod 内容器与容器之间的通信
在同一个 Pod 内的容器（Pod 内的容器是不会跨宿主机的）共享同一个网络命令空间，相当于它们在同一台机器上一样，可以用 localhost 地址访问彼此的端口。
●同一个 Node 内 Pod 之间的通信
每个 Pod 都有一个真实的全局 IP 地址，同一个 Node 内的不同 Pod 之间可以直接采用对方 Pod 的 IP 地址进行通信，Pod1 与 Pod2 都是通过 Veth 连接到同一个 docker0 网桥，网段相同，所以它们之间可以直接通信。
●不同 Node 上 Pod 之间的通信
Pod 地址与 docker0 在同一网段，docker0 网段与宿主机网卡是两个不同的网段，且不同 Node 之间的通信只能通过宿主机的物理网卡进行。
要想实现不同 Node 上 Pod 之间的通信，就必须想办法通过主机的物理网卡 IP 地址进行寻址和通信。因此要满足两个条件：Pod 的 IP 不能冲突；将 Pod 的 IP 和所在的 Node 的 IP 关联起来，通过这个关联让不同 Node 上 Pod 之间直接通过内网 IP 地址通信。
Overlay Network：
叠加网络，在二层或者三层基础网络上叠加的一种虚拟网络技术模式，该网络中的主机通过虚拟链路隧道连接起来（类似于VPN）。
VXLAN：
将源数据包封装到UDP中，并使用基础网络的IP/MAC作为外层报文头进行封装，然后在以太网上传输，到达目的地后由隧道端点解封装并将数据发送给目标地址。
Flannel:
Flannel 的功能是让集群中的不同节点主机创建的 Docker 容器都具有全集群唯一的虚拟 IP 地址。
Flannel 是 Overlay 网络的一种，也是将 TCP 源数据包封装在另一种网络包里面进行路由转发和通信，目前支持 udp、vxlan、 host-GW 3种数据转发方式。
7.2 Flannel udp 模式的工作原理（必备面试题）
1、数据从主机A 上的 Pod 的源容器中发出后，经由所在主机的 cni0/docker0 （安装了网络插件后就不在是docker0而是cni0网卡）网桥转发到 flannel0 接口，flanneld 服务监听在 flannel0 接口的另外一端。
2、发送给 flannel0 接口的IP 包信息将被 flanneld 进程接收，flanneld 进程接收 IP 包后在原有的基础上进行 UDP 封包（UDP报文里包含源Pod的数据包）
3、Flannel 通过 etcd（包含所有的Pod的ip以及所对应的node主机的地址） 服务维护了一张节点间的路由表。目标容器所在宿主机（node节点）的 IP 地址，flanneld 通过查询 etcd 很容易就能得到
4、flanneld 将封装好的 UDP 报文通过物理网卡转发出去，主机B 收到 UDP 报文后，Linux 内核通过 8285 端口将包交给正在监听的 flanneld 进程
5、运行在主机B 上的 flanneld 将 UDP 包解包后得到的原始 IP 包，内核哦通过查询本机路由表将该 IP 包转发给 cni0 网桥
6、cni0 网桥将 IP 包转发给连接在网桥上的目标Pod。至此整个流程结束。回程报文将按照上面的数据流原路返回
ETCD 之 Flannel 提供说明:
存储管理Flannel可分配的IP地址段资源
监控 ETCD 中每个 Pod 的实际地址，并在内存中建立维护 Pod 节点路由表
由于 udp 模式是在用户态做转发，会多一次报文隧道封装，因此性能上会比在内核态做转发的 vxlan 模式差。
vxlan 模式：
vxlan 是一种overlay（虚拟隧道通信）技术，通过三层网络搭建虚拟的二层网络，跟 udp 模式具体实现不太一样:
（1）udp模式是在用户态实现的，数据会先经过tun网卡，到应用程序，应用程序再做隧道封装，再进一次内核协议栈，而vxlan是在内核当中实现的，只经过一次协议栈，在协议栈内就把vxlan包组装好
（2）udp模式的tun网卡是三层转发，使用tun是在物理网络之上构建三层网络，属于ip in udp，vxlan模式是二层实现， overlay是二层帧，属于mac in udp
（3）vxlan由于采用mac in udp的方式，所以实现起来会涉及mac地址学习，arp广播等二层知识，udp模式主要关注路由
7.3 Flannel vxlan 模式的工作原理（必备面试题）
1、数据帧从主机A 上 Pod 的源容器中发出后，经由所在主机的 cin0 网络接口转发到 flannel.1 接口
2、flannel.1 收到数据帧后添加 VXLAN 头部，封装成 VXLAN UDP 报文
3、主机A 通过物理网卡发送封包到主机B 的物理网卡中
4、通过 VXLAN 8472 端口， VXLAN 包被转发到 flannel.1 接口进行解封装
5、根据解包后得到原始报文中的目的IP，内核将原始报文发送给 cni0，最后由 cni0 发送给连接在此接口上的 PodB
//在 node01 节点上操作
//上传 cni-plugins-linux-amd64-v0.8.6.tgz 和 flannel.tar 到 /opt 目录中
cd /opt/
mkdir flannel
mv flannel-v0.21.5.zip flannel/
cd flannel/
unzip flannel-v0.21.5.zip
docker load -i flannel.tar
docker load -i flannel-cni-plugin.tar
cd /opt
mkdir -p /opt/cni/bin
cd flannel/
tar zxvf cni-plugins-linux-amd64-v0.8.6.tgz -C /opt/cni/bin
cd /opt
scp -r cni/ flannel/ 192.168.154.12:/opt
//node2节点上操作
cd /opt
cd flannel/
docker load -i flannel.tar
docker load -i flannel-cni-plugin.tar
//在node01节点上操作
cd /opt/flannel/
scp kube-flannel.yml 192.168.154.10:/opt/k8s
//在 master01 节点上操作
//上传 kube-flannel.yml 文件到 /opt/k8s 目录中，部署 CNI 网络
cd /opt/k8s
kubectl apply -f kube-flannel.yml
kubectl get pods -A
NAMESPACE NAME READY STATUS RESTARTS AGE
kube-flannel kube-flannel-ds-6md78 1/1 Running 0 3s
kube-flannel kube-flannel-ds-mbsvh 1/1 Running 0 3s
kubectl get nodes
NAME STATUS ROLES AGE VERSION
192.168.154.11 Ready <none> 46h v1.20.15
192.168.154.12 Ready <none> 46h v1.20.15
8、部署 CoreDNS
coreDNS: CoreDNS是 Kbernetes 的默认 DNS 实现。可以为集群中的 service 资源创建一个资源名称 与 CLusterIP 的对应关系解析
Kubernetes 可以选择使用 DNS 水避免将服务的集群 IP 地址硬编码到您的应用程序中。
//在所有 node 节点上操作
//上传 coredns.tar 到 /opt 目录中
cd /opt
docker load -i coredns.tar
//在 master01 节点上操作
//上传 coredns.yaml 文件到 /opt/k8s 目录中，部署 CoreDNS
cd /opt/k8s
kubectl apply -f coredns.yaml
kubectl get pods -n kube-system
NAME READY STATUS RESTARTS AGE
coredns-5ffbfd976d-j6shb 1/1 Running 0 32s
//在 master01 节点上操作
cd /opt/k8s
vim test.yaml
apiVersion: v1
kind: Service
metadata:
name: my-service
spec:
selector:
app.kubernetes.io/name: MyApp
ports:
- protocol: TCP
port: 80
targetPort: 9376
kubectl apply -f test.yaml
//DNS 解析测试
kubectl run -it --rm dns-test --image=busybox:1.28.4 sh
If you don't see a command prompt, try pressing enter.
/ # vi /etc/resolv.conf
复制default.svc.cluster.local
/ # nslookup my-service.default.svc.cluster.local
Name: kubernetes
Address 1: 10.0.0.1 kubernetes.default.svc.cluster.local
