Kuebernetes群集高可用二进制部署

目录

• 1.操作系统初始化配置
  • （1）关闭防火墙
  • （2）根据规划设置主机名
  • （3）在master添加hosts
  • （4）调整内核参数
  • （5）时间同步
  • （6）升级内核
• 2.部署 docker引擎
• 3.部署 etcd 集群
• 4.部署 Master 组件
• 5.部署 Worker Node 组件
• RBAC授权，使用户 kubelet-bootstrap 能够有权限发起 CSR 请求证书
• 6.部署 CNI 网络组件
  • （1）部署 flannel
    • （1）VLAN和VXLAN的区别
    • （2）flannel的三种模式
    • （3）flannel的UDP模式
    • （4）flannel的VXLAN模式
  • （2）部署 Calico
    • （1）calico的IPIP模式
    • （2）calico的BGP模式（本质就是通过路由规则来实现Pod之间的通信）
  • （3）flannel 与 calico 的区别
  • （4）部署 CoreDNS
  • （5）K8S的三种接口
• 7.master02 节点部署
• 8.负载均衡部署
• 9.部署 Dashboard

1.操作系统初始化配置

二进制搭建 Kubernetes v1.20
k8s集群master01：20.0.0.100
k8s集群master02：20.0.0.110
k8s集群node01：20.0.0.130
k8s集群node02：20.0.0.140

（1）关闭防火墙

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
vim /etc/selinux/config

#关闭swap
swapoff -a
sed -ri 's/.*swap.*/#&/' /etc/fstab 
vim /etc/fstab 或 free -m

（2）根据规划设置主机名

hostnamectl set-hostname master01
hostnamectl set-hostname node01
hostnamectl set-hostname node02

bash

（3）在master添加hosts

vim /etc/hosts

20.0.0.100 master01
20.0.0.110 master02
20.0.0.130 node01
20.0.0.140 node02

（4）调整内核参数

cd /etc/sysctl.d/
ls

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

ls
sysctl --system   #加载

（5）时间同步

#yum install ntpdate -y
#ntpdate time.windows.com

vim /etc/chrony.conf
  server ntp1.aliyun.com iburst

systemctl restart chrony.service  #重启
chronyc -a makestep   #手动重启
date

（6）升级内核

uname -r  #查看内核
vim /etc/yum.repos.d/elrepo.repo
[elrepo]
name=elrepo
baseurl=https://mirrors.aliyun.com/elrepo/archive/kernel/el7/x86_64
gpgcheck=0
enabled=1

yum clean all && yum makecache
cd /etc/yum.repos.d/
ls
mv local.repo repo.bak/
ls
rz -E   #上传CentOS-Base-aliyun.repo
yum clean all   #清空缓存
yum install -y kernel-lt kernet-lt-devel   #集群升级内核
awk -F\' '$1=="menuentry " {print i++ " : " $2}' /etc/grub2.cfg  #查看内核序号
grub2-set-default 0   #设置默认启动内核
reboot   #重启操作系统
uname -r 
hostnamectl  #查看生效版本

#卸载旧版本包
#rpm -qa | grep kernel
#yum remove -y kernel-3.10.0-1160.el7.x86_64

2.部署 docker引擎

所有 node 节点部署docker引擎

yum install -y yum-utils device-mapper-persistent-data lvm2 
yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo 
yum install -y docker-ce docker-ce-cli containerd.io

mkdir /etc/docker
cat > /etc/docker/daemon.json <<EOF
{
  "registry-mirrors": ["https://6ijb8ubo.mirror.aliyuncs.com",  "https: /docker.1panel.live", "https: //docker.m.daocloud.io"], 
  "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 
systemctl enable --now docker


docker info
docker info | grep "Cgroup Driver"
Cgroup Driver: systemd

3.部署 etcd 集群

使用cfssl工具签发证书和私钥文件
解压etcd软件包，获取二进制文件 etcd etcdctl
准备etcd集群配置文件
启动etcd服务进程，将所有etcd节点加入到集群中

在 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

cd /usr/local/bin/
rz -E 上传cfssl   cfssljson   cfssl-certinfo

chmod +x *
#chmod +x /usr/local/bin/cfssl*
mkdir /opt/k8s
cd /opt/k8s/
rz -E  上传 etcd-cert.sh;etcd.sh;etcd-v3.4.26-linux-amd64.tar.gz

chmod +x *.sh
ls
#创建用于生成CA证书、etcd 服务器证书以及私钥的目录
mkdir /opt/k8s/etcd-cert
mv etcd-cert.sh etcd-cert/
ls
ls etcd-cert/
cd /opt/k8s/etcd-cert/
vim etcd-cert.sh	
./etcd-cert.sh			#生成CA证书、etcd 服务器证书以及私钥


cd /opt/k8s/
tar xf etcd-v3.4.26-linux-amd64.tar.gz
ls etcd-v3.4.26-linux-amd64
#创建用于存放 etcd 配置文件，命令文件，证书的目录
cd /opt/
mkdir etcd
cd etcd/
ls
mkdir cfg bin ssl
ls
#mkdir -p /opt/etcd/{cfg,bin,ssl}
cd /opt/k8s/
ls
cd etcd-v3.4.26-linux-amd64/
ls
#cd /opt/k8s/etcd-v3.4.26-linux-amd64/
mv etcd etcdctl /opt/etcd/bin/
cd ..
ls
cd etcd-cert/
ls
cp *.pem /opt/etcd/ssl/
ls !$
#cp /opt/k8s/etcd-cert/*.pem /opt/etcd/ssl/
ls /opt/etcd/
cd /opt/k8s/
vim etcd.sh
./etcd.sh etcd01 20.0.0.100 etcd02=https://20.0.0.130:2380,etcd03=https://20.0.
.140:2380

ls
#可另外打开一个窗口查看etcd进程是否正常
ps aux | grep etcd
#把etcd相关证书文件、命令文件和服务管理文件全部拷贝到另外两个etcd集群节点
scp -r /opt/etcd/ root@20.0.0.130:/opt/
scp -r /opt/etcd/ root@20.0.0.140:/opt/
cd /usr/lib/systemd/system/  
ls etcd.service
scp etc.service root @20.0.0.130:`pwd`
scp etc.service root @20.0.0.140:`pwd`


//在 node01 02节点上操作
cd /opt/
ls
ls  containerd/
rm -rf containerd/ rh/
ls
ls -R etcd/

vim etcd/cfg/etcd
ETCD_NAME="etcd02"
本地IP

systemctl enable --now etcd.service
//全部节点
systemctl status etcd.service

• etcd操作

#查看etcd集群健康状态
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://192.168.80.10:2379,https://192.168.80.11:2379,https://192.168.80.12:2379"  --cacert=ca.pem --cert=server.pem  --key=server-key.pem -wtable  endpoint health

#查看etcd集群状态信息
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://192.168.80.10:2379,https://192.168.80.11:2379,https://192.168.80.12:2379"  --cacert=ca.pem --cert=server.pem  --key=server-key.pem -wtable  endpoint status

#查看etcd集群成员列表
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://192.168.80.10:2379,https://192.168.80.11:2379,https://192.168.80.12:2379"  --cacert=ca.pem --cert=server.pem  --key=server-key.pem -wtable  member list

#插入键值
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://192.168.80.10:2379"  --cacert=ca.pem --cert=server.pem  --key=server-key.pem  put 键名 '键值'

#查询键值
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://192.168.80.10:2379"  --cacert=ca.pem --cert=server.pem  --key=server-key.pem  get 键名

#删除键值
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://192.168.80.10:2379"  --cacert=ca.pem --cert=server.pem  --key=server-key.pem  del 键名

#备份etcd数据库
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://192.168.80.10:2379"  --cacert=ca.pem --cert=server.pem  --key=server-key.pem  snapshot save 备份文件路径

#恢复etcd数据库
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://192.168.80.10:2379"  --cacert=ca.pem --cert=server.pem  --key=server-key.pem  snapshot restore 备份文件路径

4.部署 Master 组件

使用cfssl工具签发证书和私钥文件
解压K8S软件包，获取二进制文件 kube-apiserver kube-controller-manager kube-scheduler
准备 kube-apiserver 启动时要调用的 bootstrap-token 认证文件（token.csv）
准备 kube-apiserver kube-controller-manager kube-scheduler 的启动参数配置文件
准备 kube-controller-manager kube-scheduler kubectl 的 kubeconfig 集群引导配置文件（用于连接和验证 apiserver）
依次启动 kube-apiserver kube-controller-manager kube-scheduler 服务进程
执行 kubectl get cs 命令查看 master 组件的健康状态

//在 master01 节点上操作

cd /opt/k8s/
ls
rz -E 上传 master.zip和 k8s-cert.sh
mkdir k8s-cert
mv k8s-cert.sh k8s-cert/
cd k8s-cert/
ls
chmod +x k8s-cert.sh
vim k8s-cert.sh
./k8s-cert.sh
ls
ls *.pem
cd /opt/k8s/
ls

rz -E 上传kubernetes-server-linux-amd64.tar.gz
tar xf kubernetes-server-linux-amd64.tar.gz
ls

#创建kubernetes工作目录
mkdir -p /opt/k8s/kubernetes/{bin,cfg,ssl,logs}
cd /opt/k8s/kubernetes/server/bin/
ls
cp kube-apiserver kube-controller-manager kube-sscheduler /opt/kubernetes/bin/
cd /opt/k8s/k8s-cert/
ls
ls *.pem
cp apiserver-key.pem apiserver.pem ca-key.pem ca.pem   /opt/kubernetes/ssl/
ls /opt/kubernetes/ssl/ -R
cd /opt/kubernetes/
ls ssl/
ls bin/
cd cfg/
ls
head -c 16 /dev/urandom | od -An -t x
#获取随机数前16个字节内容，以十六进制格式输出，并删除其中空格
head -c 16 /dev/urandom | od -An -t x | tr -d ' '
pwd
vim token.csv
    ,kubelet-bootstrap,10001,"system:kubelet-bootstrap"

cat token.csv
cd /opt/k8s/
ls
unzip master.zip
ls
chmod +x *.sh
ls
vim apiserver.sh
./apiserver.sh 192.168.80.10 https://192.168.80.10:2379,https://192.168.80.11:2379,https://192.168.80.12:2379

systemctl status kube-apiserver.service
netstat -lntp | grep apis
ls
cd kubernetes/server/bin/
ls
cp kubectl /usr/local/bin/
cd -  #/opt/k8s/
vim controller-manager.sh
./controller-manager.sh
systemctl ststus kube-schduler.service
ps aux | grep scheduler
kubectl get cs
vim sdmin.sh
./admin.sh
ls /root/.kube/
kubectl get cs
kubectl version
kubectl -n kube-system get lesases kube-scheduler
kubectl -n kube-system get lesases kube-controller-manager

5.部署 Worker Node 组件

获取二进制文件 kubelet kube-proxy，安装容器引擎
准备 kubelet kube-proxy 的启动参数配置文件
准备 kubelet kube-proxy 的 kubeconfig 集群引导配置文件 bootstrap.kubeconfig（kubelet首次访问apiserver时使用的文件） kube-proxy.kubeconfig
启动 kubelet 服务进程，向 apiserver 发起 CSR 请求自动签发证书，master 通过 CSR 请求后会由 controller-manager 生成 kubelet 的证书，再由 apiserver 发送给 kubelet
加载 ipvs 模块，启动 kube-proxy 服务进程
执行 kubectl get nodes 命令查看 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 root@192.168.80.11:/opt/kubernetes/bin/
scp kubelet kube-proxy root@192.168.80.12:/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.80.10 /opt/k8s/k8s-cert/


#把配置文件 bootstrap.kubeconfig、kube-proxy.kubeconfig 拷贝到 node 节点
scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.80.11:/opt/kubernetes/cfg/
scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.80.12:/opt/kubernetes/cfg/


#RBAC授权，使用户 kubelet-bootstrap 能够有权限发起 CSR 请求证书
kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap

#自动批准 CSR 请求
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 节点上操作

#启动 kubelet 服务
cd /opt/
./kubelet.sh 192.168.80.11
ps aux | grep kubelet

//在 master01 节点上操作，通过 CSR 请求
#检查到 node01 节点的 kubelet 发起的 CSR 请求，Pending 表示等待集群给该节点签发证书
kubectl get csr

#通过 CSR 请求
kubectl certificate approve node-csr-duiobEzQ0R93HsULoS9NT9JaQylMmid_nBF3Ei3NtFE

#Approved,Issued 表示已授权 CSR 请求并签发证书
kubectl get csr


#查看节点，由于网络插件还没有部署，节点会没有准备就绪 NotReady
kubectl get node

#加载 ip_vs 模块
ls | awk -F. '{print $1}'
ls | grep -o "^[^.]*"

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/k8s/
vim proxy.sh

./proxy.sh 192.168.80.11
ps aux | grep kube-proxy

注：报错

master01
./kubeconfig.sh 192.168.80.10 /opt/k8s/k8s-cert/
ls
vim bootstrap.kubeconfig

RBAC授权，使用户 kubelet-bootstrap 能够有权限发起 CSR 请求证书

kubectl的认证授权
kubectl的日志调试级别:

6.部署 CNI 网络组件

（1）部署 flannel

Flannel UDP 模式的工作原理

K8S的三种网络
节点网络	nodeIP	物理网卡的IP实现节点间的通信
Pod网络	podIP	Pod与Pod之间可通过Pod的IP相互通信
Service网络	clusterIP	在K8S集群内部可通过service资源的clusterIP实现对Pod集群的代理转发

• 在 node01 节点上操作

#上传 cni-plugins-linux-amd64-v1.3.0.tgz 和 flannel镜像文件 到 /opt 目录中
cd /opt/
docker load -i flannel.tar
docker load -i flannel-cni-plugin.tar

mkdir -p /opt/cni/bin
tar zxvf cni-plugins-linux-amd64-v1.3.0.tgz -C /opt/cni/bin

• 在 master01 节点上操作

#上传 kube-flannel.yml 文件到 /opt/k8s 目录中，部署 CNI 网络
cd /opt/k8s
kubectl apply -f kube-flannel.yml 

kubectl get pods -A -owide
kubectl get pods -n kube-flannel
kubectl get nodes
ip -d a show flannel.1   #在node上查看flannel.1的端口

（1）VLAN和VXLAN的区别

1）使用场景不同：
VLAN主要用于在交换机上逻辑划分广播域，还可以配合STP生成树协议阻塞路径接口，从而避免产生环路和广播风暴
VXLAN用作于叠加网络，可以将数据帧封装成UDP报文，再通过网络层传输到其它网络，从而实现虚拟大二层网络的通信
2）VXLAN支持更多的二层网络：VXLAN最多可支持 2^24 个；VLAN最多支持 2^12 个（4096-2）
3）VXLAN可以防止物理交换机MAC表耗尽：VLAN需要在交换机的MAC表中记录MAC地址；VXLAN采用隧道机制，MAC地址不记录在交换机的MAC表中

（2）flannel的三种模式

flannel的三种模式
UDP	出现最早的模式，但是性能最差，基于flanneld应用程序实现数据包的封装/解封装（ip in udp）
VXLAN	flannel的默认模式，也是推荐使用的模式，性能比UDP模式更好，基于内核实现数据帧的封装/解封装（mac in udp），且配置简单使用方便
HOST-GW	性能最好的模式，但是配置复杂，还不能跨网段通信

（3）flannel的UDP模式

1）原始数据包从源主机的Pod容器发出到cni0网桥接口，再由cni0转发到flannel0虚拟接口
2）flanneld服务会监听flannel0接口收到的数据，并会将原始数据包封装到UDP报文里
3）flanneld服务会根据在etcd中维护的路由表查到目标Pod所在的nodeIP，并在UDP报文外封装nodeIP头部、MAC头部等，再通过物理网卡发送到目标node节点
4）UDP报文通过8285端口送达到目标node节点的flanneld服务进程解封装获取原始数据包，数据报文再根据本地路由规则通过flannel0接口发送到cni0网桥，再由cni0发送到目标Pod容器

（4）flannel的VXLAN模式

1）原始数据帧从源主机的Pod容器发出到cni0网桥接口，再由cni0转发到flannel.1虚拟接口
2）flannel.1接口收到数据帧后添加VXLAN头部，再由内核将原始数据帧封装到UDP报文里
3）根据在etcd中维护的路由表查到目标Pod所在的nodeIP，并在UDP报文外封装nodeIP头部、MAC头部等，再通过物理网卡发送到目标node节点
4）UDP报文通过8472端口送达到目标node节点的flannel.1接口并由内核解封装获取原始数据帧，数据报文再根据本地路由规则发送到cni0网桥，再由cni0发送到目标Pod容器

（2）部署 Calico

• 在 master01 节点上传 calico.yaml 文件到 /opt/k8s 目录中，部署 Calico

cd /opt/k8s
vim calico.yaml
    #修改里面定义 Pod 的网络（CALICO_IPV4POOL_CIDR），需与前面 kube-controller-manager 配置文件指定的 cluster-cidr 网段一样

   - name: CALICO_IPV4POOL_CIDR
   - value: "10.244.0.0/16"        #Calico 默认使用的网段为 192.168.0.0/16
   
   #修改网络模式为BGP  
- name: CALICO_IPV4POOL_IPIP
  value: "Never"               #设置为Never时为BGP模式，设置为Always时为IPIP模式，设置为CrossSubnet时为混合模式
- name: IP_AUTODETECTION_METHOD
  value: "interface=ens.*"
  
kubectl apply -f calico.yaml

kubectl get pods -n kube-system
NAME                                       READY   STATUS    RESTARTS   AGE
calico-kube-controllers-659bd7879c-4h8vk   1/1     Running   0          58s
calico-node-nsm6b                          1/1     Running   0          58s
calico-node-tdt8v                          1/1     Running   0          58s

#等 Calico Pod 都 Running，节点也会准备就绪
kubectl get nodes

#修改网络模式为混合模式
kubectl edit ippool 
ipipMode: Always 修改为 ipipMode: CrossSubnet

• node02 节点部署

cd /opt/
scp kubelet.sh proxy.sh root@192.168.80.12:/opt/
scp -r /opt/cni root@192.168.80.12:/opt/

• 在 node02 节点上操作

#启动kubelet服务
cd /opt/
chmod +x kubelet.sh
./kubelet.sh 192.168.80.12

//在 master01 节点上操作
kubectl get csr
NAME                                                   AGE  SIGNERNAME                                    REQUESTOR           CONDITION
node-csr-BbqEh6LvhD4R6YdDUeEPthkb6T_CJDcpVsmdvnh81y0   10s  kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Pending
node-csr-duiobEzQ0R93HsULoS9NT9JaQylMmid_nBF3Ei3NtFE   85m  kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Approved,Issued

#通过 CSR 请求
kubectl certificate approve node-csr-BbqEh6LvhD4R6YdDUeEPthkb6T_CJDcpVsmdvnh81y0

kubectl get csr
NAME                                                   AGE  SIGNERNAME                                    REQUESTOR           CONDITION
node-csr-BbqEh6LvhD4R6YdDUeEPthkb6T_CJDcpVsmdvnh81y0   23s  kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Approved,Issued
node-csr-duiobEzQ0R93HsULoS9NT9JaQylMmid_nBF3Ei3NtFE   85m  kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Approved,Issued

#加载 ipvs 模块
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.sh脚本启动proxy服务
cd /opt/
chmod +x proxy.sh
./proxy.sh 192.168.80.12

#查看群集中的节点状态
kubectl get nodes

（1）calico的IPIP模式

1）原始数据包从源主机的Pod容器发出，经过 veth pair 设备送达到tunl0接口
2）tunl0接口收到数据包后，由内核将原始数据包封装到node节点网络的IP报文里，再根据Felix维护的路由规则通过物理网卡发送到目标node节点
3）IP数据包到达目标节点的tunl0接口后，由内核解封装获取原始数据包，数据报文再根据本地路由规则经过 veth pair 设备发送到目标Pod容器

（2）calico的BGP模式（本质就是通过路由规则来实现Pod之间的通信）

每个Pod都有一个 veth pair 设置，一端接入Pod，另一端接入宿主机网络空间，并设置了一条路由规则
这些路由规则都是 Felix 维护的，由 BIRD(BGP Client) 基于 BGP 动态路由协议分发给其它节点

1）原始数据包从源主机的Pod容器发出，经过 veth pair 设备送达到宿主机网络空间，再根据Felix维护的路由规则通过物理网卡发送到目标node节点
2）目标node节点收到数据包后，会根据本地路由规则经过 veth pair 设备送达到目标 Pod 容器

（3）flannel 与 calico 的区别

flannel： UDP VXLAN HOST-GW
默认网段：10.244.0.0/16
通常会采用VXLAN模式，由于用的是叠加网络、IP隧道方式传输数据，传输过程中需要额外的封包和解包，对性能有一点的影响。
flannel简单易用。但是不具备复杂的网络策略配置能力，性能方面表现一般。

calico： IPIP VXLAN BGP CrossSubnet(混合模式)
默认网段：192.168.0.0/16
使用IPIP或VXLAN模式可以实现跨网段通信，但是传输过程中需要额外的封包和解包，对性能有一点的影响。
使用BGP模式会把每个节点看作成路由器，通过Felix、BIRD组件来维护和分发路由规则，可实现直接通过路由规则直接发送数据包到目标主机，传输中不需要额外的封包和解包，因此性能较好。但是不能跨网段通信。
calico性能较高，具有丰富的网络策略配置能力，功能更全面。但是维护起来较为复杂。

总结：flannel适合规模较小，网络要求简单的K8S集群。calico适合规模较大，需要设置网络策略，固定 PodIP 的K8S集群。

（4）部署 CoreDNS

CoreDNS 是 Kubernetes 的默认 DNS 实现。

• 在所有 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

#DNS 解析测试
kubectl run -it --rm dns-test --image=busybox:1.28.4 sh
If you don't see a command prompt, try pressing enter.
/ # nslookup kubernetes.default.svc.cluster.local.
Server:		10.0.0.2
Address:	10.0.0.2:53

Name:	kubernetes.default.svc.cluster.local
Address: 10.0.0.1

若执行失败，可先给kubectl绑定默认cluster-admin管理员集群角色，授权集群操作权限
kubectl create clusterrolebinding cluster-system-anonymous --clusterrole=cluster-admin --user=system:anonymous

（5）K8S的三种接口

K8S的三种接口
CRI	容器运行时接口	docker、containerd、pod、cri-o
CSI	容器存储接口	nfs、ceph、oss、s3
CNI	容器网络接口	flannel、calico、cilium

7.master02 节点部署

• 从 master01 节点上拷贝证书文件、各master组件的配置文件和服务管理文件到 master02 节点

scp -r /opt/etcd/ root@192.168.80.20:/opt/
scp -r /opt/kubernetes/ root@192.168.80.20:/opt
scp -r /root/.kube root@192.168.80.20:/root
scp /usr/lib/systemd/system/{kube-apiserver,kube-controller-manager,kube-scheduler}.service root@192.168.80.20:/usr/lib/systemd/system/

• 修改配置文件kube-apiserver中的IP

vim /opt/kubernetes/cfg/kube-apiserver
KUBE_APISERVER_OPTS="--logtostderr=true \
--v=4 \
--etcd-servers=https://192.168.80.10:2379,https://192.168.80.11:2379,https://192.168.80.12:2379 \
--bind-address=192.168.80.20 \				#修改
--secure-port=6443 \
--advertise-address=192.168.80.20 \			#修改
......

• 在 master02 节点上启动各服务并设置开机自启

systemctl start kube-apiserver.service
systemctl enable kube-apiserver.service
systemctl start kube-controller-manager.service
systemctl enable kube-controller-manager.service
systemctl start kube-scheduler.service
systemctl enable kube-scheduler.service

//查看node节点状态
ln -s /opt/kubernetes/bin/* /usr/local/bin/
kubectl get nodes
kubectl get nodes -o wide	 #-o=wide：输出额外信息；对于Pod，将输出Pod所在的Node名

注：此时在master02节点查到的node节点状态仅是从etcd查询到的信息，而此时node节点实际上并未与master02节点建立通信连接，因此需要使用一个VIP把node节点与master节点都关联起来

8.负载均衡部署

• 配置load balancer集群双机热备负载均衡（nginx实现负载均衡，keepalived实现双机热备）

//在lb01、lb02节点上操作
systemctl disable --now firewalld
sentenforce 0
vim /etc/selinux/config


//配置nginx的官方在线yum源，配置本地nginx的yum源
cat > /etc/yum.repos.d/nginx.repo << 'EOF'
[nginx]
name=nginx repo
baseurl=http://nginx.org/packages/centos/7/$basearch/
gpgcheck=0
EOF

yum install nginx -y
nginx -V   #四层代理  
//修改nginx配置文件，配置四层反向代理负载均衡，指定k8s群集2台master的节点ip和6443端口
vim /etc/nginx/nginx.conf
events {
    worker_connections  1024;
}

#添加
stream {
    log_format  main  '$remote_addr $upstream_addr - [$time_local] $status $upstream_bytes_sent';
    
access_log  /var/log/nginx/k8s-access.log  main;

upstream k8s-apiserver {
    server 192.168.80.10:6443;
    server 192.168.80.20:6443;
}
server {
    listen 6443;
    proxy_pass k8s-apiserver;
}
}
http {
......
//检查配置文件语法
nginx -t   

//启动nginx服务，查看已监听6443端口
systemctl start nginx
systemctl enable nginx
netstat -natp | grep nginx 

• 部署keepalived服务

yum install keepalived -y
	
	//修改keepalived配置文件
	vim /etc/keepalived/keepalived.conf
	! Configuration File for keepalived
	
	global_defs {
# 接收邮件地址

   notification_email {
     acassen@firewall.loc
     failover@firewall.loc
     sysadmin@firewall.loc
   }

# 邮件发送地址

   notification_email_from Alexandre.Cassen@firewall.loc
   smtp_server 127.0.0.1
   smtp_connect_timeout 30
   router_id NGINX_MASTER	#lb01节点的为 NGINX_MASTER，lb02节点的为 NGINX_BACKUP
}

	#添加一个周期性执行的脚本
​	vrrp_script check_nginx {
​	    script "/etc/nginx/check_nginx.sh"	#指定检查nginx存活的脚本路径
​	}
​	
​	vrrp_instance VI_1 {
​	    state MASTER			#lb01节点的为 MASTER，lb02节点的为 BACKUP
​	    interface ens33			#指定网卡名称 ens33
​	    virtual_router_id 51	#指定vrid，两个节点要一致
​	    priority 100			#lb01节点的为 100，lb02节点的为 90
​	    advert_int 1
​	    authentication {
​	        auth_type PASS
​	        auth_pass 1111
​	    }
​	    virtual_ipaddress {
​	        192.168.80.100/24	#指定 VIP
​	    }
​	    track_script {
​	        check_nginx			#指定vrrp_script配置的脚本
​	    }
​	}	

• 创建nginx状态检查脚本

vim /etc/nginx/check_nginx.sh
#!/bin/bash
#egrep -cv "grep|$$" 用于过滤掉包含grep 或者 $$ 表示的当前Shell进程ID，即脚本运行的当前进程ID号
count=$(ps -ef | grep nginx | egrep -cv "grep|$$")

if [ "$count" -eq 0 ];then
    systemctl stop keepalived
fi

chmod +x /etc/nginx/check_nginx.sh

• 启动keepalived服务（一定要先启动了nginx服务，再启动keepalived服务）

systemctl start keepalived
systemctl enable keepalived
ip a				#查看VIP是否生成

• 修改node节点上的bootstrap.kubeconfig,kubelet.kubeconfig配置文件为VIP

cd /opt/kubernetes/cfg/
vim bootstrap.kubeconfig 
server: https://192.168.80.100:6443
                      
vim kubelet.kubeconfig
server: https://192.168.80.100:6443
                        
vim kube-proxy.kubeconfig
server: https://192.168.80.100:6443

//重启kubelet和kube-proxy服务
systemctl restart kubelet.service 
systemctl restart kube-proxy.service

//在 lb01 上查看 nginx 和 node 、 master 节点的连接状态
netstat -natp | grep nginx

• 在 master01 节点上操作

//测试创建pod
kubectl run nginx --image=nginx

//查看Pod的状态信息
kubectl get pods
NAME                    READY   STATUS              RESTARTS   AGE
nginx-dbddb74b8-nf9sk   0/1     ContainerCreating   0          33s   #正在创建中

kubectl get pods
NAME                    READY   STATUS    RESTARTS   AGE
nginx-dbddb74b8-nf9sk   1/1     Running   0          80s  			#创建完成，运行中

kubectl get pods -o wide
NAME                    READY   STATUS    RESTARTS   AGE   IP            NODE            NOMINATED NODE
nginx-dbddb74b8-26r9l   1/1     Running   0          10m   172.17.36.2   192.168.80.14   <none>
//READY为1/1，表示这个Pod中有1个容器

//在对应网段的node节点上操作，可以直接使用浏览器或者curl命令访问
curl 172.17.36.2

//这时在master01节点上查看nginx日志
kubectl logs nginx-dbddb74b8-nf9sk

若执行失败，可先给kubectl绑定默认cluster-admin管理员集群角色，授权集群操作权限
kubectl create clusterrolebinding cluster-system-anonymous --clusterrole=cluster-admin --user=system:anonymous

9.部署 Dashboard

仪表板是基于Web的Kubernetes用户界面。

• 在 master01 节点上操作

#上传 recommended.yaml 文件到 /opt/k8s 目录中
cd /opt/k8s
vim recommended.yaml
#默认Dashboard只能集群内部访问，修改Service为NodePort类型，暴露到外部：
kind: Service
apiVersion: v1
metadata:
  labels:
    k8s-app: kubernetes-dashboard
  name: kubernetes-dashboard
  namespace: kubernetes-dashboard
spec:
  ports:

   - port: 443
     targetPort: 8443
     nodePort: 30001     #添加
       type: NodePort          #添加
       selector:
         k8s-app: kubernetes-dashboard

kubectl apply -f recommended.yaml


#创建service account并绑定默认cluster-admin管理员集群角色
kubectl create serviceaccount dashboard-admin -n kube-system
kubectl create clusterrolebinding dashboard-admin --clusterrole=cluster-admin --serviceaccount=kube-system:dashboard-admin
kubectl describe secrets -n kube-system $(kubectl -n kube-system get secret | awk '/dashboard-admin/{print $1}')

#使用输出的token登录Dashboard
https://NodeIP:30001