附037.Kubernetes_v1.29.2高可用部署架构二

木二

发布于 2024-03-11 08:06:45

3940

发布于 2024-03-11 08:06:45

文章被收录于专栏：木二天空木二天空

部署组件

该 Kubernetes 部署过程中，对于部署环节，涉及多个组件，主要有 kubeadm 、kubelet 、kubectl。

kubeadm介绍

Kubeadm 为构建 Kubernetes 提供了便捷、高效的“最佳实践” ，该工具提供了初始化完整 Kubernetes 过程所需的组件，其主要命令及功能有：

kubeadm init：用于搭建 Kubernetes 控制平面节点；
kubeadm join：用于搭建 Kubernetes 工作节点并将其加入到集群中；
kubeadm upgrade：用于升级 Kubernetes 集群到新版本；
kubeadm token：用于管理 kubeadm join 使用的 token；
kubeadm reset：用于恢复（重置）通过 kubeadm init 或者 kubeadm join 命令对节点进行的任何变更；
kubeadm certs：用于管理 Kubernetes 证书；
kubeadm kubeconfig：用于管理 kubeconfig 文件；
kubeadm version：用于显示（查询）kubeadm 的版本信息；
kubeadm alpha：用于预览当前从社区收集到的反馈中的 kubeadm 特性。

更多参考：Kubeadm介绍

kubelet介绍

kubelet 是 Kubernetes 集群中用于操作 Docker 、containerd 等容器运行时的核心组件，需要在每个节点运行。通常该操作是基于 CRI 实现，kubelet 和 CRI 交互，以便于实现对 Kubernetes 的管控。

kubelet 主要用于配置容器网络、管理容器数据卷等容器全生命周期，对于 kubelet 而言，其主要的功能核心有：

Pod 更新事件；
Pod 生命周期管理；
上报 Node 节点信息。

更多参考：kubelet介绍

kubectl介绍

kubectl 控制 Kubernetes 集群管理器，是作为 Kubernetes 的命令行工具，用于与 apiserver 进行通信，使用 kubectl 工具在 Kubernetes 上部署和管理应用程序。

使用 kubectl，可以检查群集资源的创建、删除和更新组件。

同时集成了大量子命令，可更便捷的管理 Kubernetes 集群，主要命令如下：

Kubetcl -h：显示子命令；
kubectl option：查看全局选项；
kubectl <command> --help：查看子命令帮助信息；
kubelet command -o=<format>：设置输出格式，如json、yaml等；
Kubetcl explain RESOURCE：查看资源的定义。

更多参考：kubectl介绍

方案概述

方案介绍

本方案基于 kubeadm 部署工具实现完整生产环境可用的 Kubernetes 高可用集群，同时提供相关 Kubernetes 周边组件。

其主要信息如下：

版本：Kubernetes 1.29.2 版本；
kubeadm：采用 kubeadm 部署Kubernetes；
OS：CentOS 8；
etcd：采用融合方式；
Nginx：以Pod形式运行与Kubernetes之上，即in Kubernetes模式，提供反向代理至3个master 6443端口；
KeepAlived：用于实现 apiserver 的高可用；
其他主要部署组件包括：
- Metrics：度量组件，用于提供相关监控指标；
- Dashboard：Kubernetes 集群的前端图形界面；
- Helm：Kubernetes Helm 包管理器工具，用于后续使用 helm 整合包快速部署应用；
- Ingress：Kubernetes 服务暴露应用，用于提供7层的负载均衡，类似 Nginx，可建立外部和内部的多个映射规则；
- containerd：Kubernetes底层容器时；
- Longhorn：Kubernetes 动态存储组件，用于提供 Kubernetes 的持久存储。

提示：本方案部署所使用脚本均由本人提供，可能不定期更新。

部署规划

节点规划

节点主机名	IP	类型	运行服务
master01	172.24.8.111	Kubernetes master节点	kubeadm、kubelet、kubectl、KeepAlived、containerd、etcd、kube-apiserver、kube-scheduler、kube-controller-manager、calico、WebUI、metrics、ingress、Longhorn ui节点
master02	172.24.8.112	Kubernetes master节点	kubeadm、kubelet、kubectl、KeepAlived、containerd、etcd、kube-apiserver、kube-scheduler、kube-controller-manager、calico、WebUI、metrics、ingress、Longhorn ui节点
master03	172.24.8.113	Kubernetes master节点	kubeadm、kubelet、kubectl、KeepAlived、containerd、etcd、kube-apiserver、kube-scheduler、kube-controller-manager、calico、WebUI、metrics、ingress、Longhorn ui节点
worker01	172.24.8.114	Kubernetes worker节点	kubelet、containerd、calico、Longhorn存储节点
worker02	172.24.8.115	Kubernetes worker节点	kubelet、containerd、calico、Longhorn存储节点
worker03	172.24.8.116	Kubernetes worker节点	kubelet、containerd、calico、Longhorn存储节点
worker04	172.24.8.117	Kubernetes worker节点	kubelet、containerd、calico、Longhorn存储节点

Kubernetes集群高可用主要指的是控制平面的高可用，多个Master节点组件（通常为奇数）和Etcd组件的高可用，worker节点通过前端负载均衡VIP连接到Master。

Kubernetes高可用架构中etcd与Master节点组件混合部署方式特点：

所需服务器节点资源少，具备超融合架构特点
部署简单，利于管理
容易进行横向扩展
etcd复用Kubernetes的高可用
存在一定风险，如一台master主机挂了，master和etcd都少了一个节点，集群冗余度受到一定影响

提示：本实验使用Keepalived+Nginx架构实现Kubernetes的高可用。

主机名配置

需要对所有节点主机名进行相应配置。

[root@localhost ~]# hostnamectl set-hostname master01	    #其他节点依次修改

生产环境通常建议在内网部署dns服务器，使用dns服务器进行解析，本指南采用本地hosts文件名进行解析。

如下hosts文件修改仅需在master01执行，后续使用批量分发至其他所有节点。

[root@master01 ~]# cat >> /etc/hosts << EOF
172.24.8.111 master01
172.24.8.112 master02
172.24.8.113 master03
172.24.8.114 worker01
172.24.8.115 worker02
172.24.8.116 worker03
EOF

变量准备

为实现自动化部署，自动化分发相关文件，提前定义相关主机名、IP组、变量等。

[root@master01 ~]# wget http://down.linuxsb.com/mydeploy/k8s/v1.29.2/environment.sh

[root@master01 ~]# vi environment.sh            #确认相关主机名和IP
#!/bin/sh
#****************************************************************#
# ScriptName: environment.sh
# Author: xhy
# Create Date: 2022-10-11 17:10
# Modify Author: xhy
# Modify Date: 2023-11-29 23:00
# Version: v1
#***************************************************************#

# 集群 MASTER 机器 IP 数组
export MASTER_IPS=(172.24.8.111 172.24.8.112 172.24.8.113)

# 集群 MASTER IP 对应的主机名数组
export MASTER_NAMES=(master01 master02 master03)

# 集群 NODE 机器 IP 数组
export NODE_IPS=(172.24.8.114 172.24.8.115 172.24.8.116)

# 集群 NODE IP 对应的主机名数组
export NODE_NAMES=(worker01 worker02 worker03)

# 集群所有机器 IP 数组
export ALL_IPS=(172.24.8.111 172.24.8.112 172.24.8.113 172.24.8.114 172.24.8.115 172.24.8.116)

# 集群所有IP 对应的主机名数组
export ALL_NAMES=(master01 master02 master03 worker01 worker02 worker03)

互信配置

为了方便远程分发文件和执行命令，本方案配置master01节点到其它节点的 ssh信任关系，即免秘钥管理所有其他节点。

[root@master01 ~]# source environment.sh                                #载入变量
    
[root@master01 ~]# ssh-keygen -f ~/.ssh/id_rsa -N ''
[root@master01 ~]# for all_ip in ${ALL_IPS[@]}
  do
    echo ">>> ${all_ip}"
    ssh-copy-id -i ~/.ssh/id_rsa.pub root@${all_ip}
  done
  
[root@master01 ~]# for all_name in ${ALL_NAMES[@]}
  do
    echo ">>> ${all_name}"
    ssh-copy-id -i ~/.ssh/id_rsa.pub root@${all_name}
  done

提示：此操作仅需要在master01节点操作。

环境初始化

kubeadm本身仅用于部署Kubernetes集群，在正式使用kubeadm部署Kubernetes集群之前需要对操作系统环境进行准备，即环境初始化准备。

环境的初始化准备本方案使用脚本自动完成。

使用如下脚本对基础环境进行初始化，主要功能包括：

安装containerd，Kubernetes平台底层的容器组件
关闭SELinux及防火墙
优化相关内核参数，针对生产环境Kubernetes集群的基础系统调优配置
关闭swap
设置相关模块，主要为转发模块
配置相关基础软件，部署Kubernetes集群所需要的基础依赖包

[root@master01 ~]# wget http://down.linuxsb.com/mydeploy/k8s/v1.29.2/k8sconinit.sh

[root@master01 ~]# vim k8sconinit.sh
#!/bin/sh
#****************************************************************#
# ScriptName: k8sconinit.sh
# Author: xhy
# Create Date: 2020-05-30 16:30
# Modify Author: xhy
# Modify Date: 2024-02-28 22:38
# Version: v1
#***************************************************************#
# Initialize the machine. This needs to be executed on every machine.
rm -f /var/lib/rpm/__db.00*
rpm -vv --rebuilddb
#yum clean all 
#yum makecache
sleep 3s
# Install containerd
CONVERSION=1.6.28
yum -y install yum-utils device-mapper-persistent-data lvm2
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
sudo sed -i 's+download.docker.com+mirrors.aliyun.com/docker-ce+' /etc/yum.repos.d/docker-ce.repo
sleep 3s
yum -y install containerd.io-${CONVERSION}
mkdir /etc/containerd

cat > /etc/containerd/config.toml <<EOF
disabled_plugins = ["restart"]

[plugins.linux]
shim_debug = true

[plugin."io.containerd.grpc.v1.cri".registry.mirrors]
  [plugin."io.containerd.grpc.v1.cri".registry.mirrors."docker.io"]
        endpoint = ["https://dbzucv6w.mirror.aliyuncs.com"]

[plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc.options]
SystemdCgroup = true

[plugins.cri]
sandbox_image = "registry.k8s.io/pause:3.9"
EOF

cat > /etc/crictl.yaml <<EOF
runtime-endpoint: unix:///run/containerd/containerd.sock
image-endpoint: unix:///run/containerd/containerd.sock
timeout: 10
debug: false
EOF

systemctl restart containerd
systemctl enable containerd --now
systemctl status containerd

# Disable the SELinux.
sed -i 's/^SELINUX=.*/SELINUX=disabled/' /etc/selinux/config

# Turn off and disable the firewalld.
systemctl stop firewalld
systemctl disable firewalld

# Modify related kernel parameters & Disable the swap.
cat > /etc/sysctl.d/k8s.conf << EOF
net.ipv4.ip_forward = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.tcp_tw_recycle = 0
vm.swappiness = 0
vm.overcommit_memory = 1
vm.panic_on_oom = 0
net.ipv6.conf.all.disable_ipv6 = 1
EOF
sysctl -p /etc/sysctl.d/k8s.conf >&/dev/null
swapoff -a
sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab
modprobe br_netfilter
modprobe overlay

# Add ipvs modules
cat > /etc/sysconfig/modules/ipvs.modules <<EOF
#!/bin/bash
modprobe -- ip_vs
modprobe -- ip_vs_rr
modprobe -- ip_vs_wrr
modprobe -- ip_vs_sh
modprobe -- nf_conntrack_ipv4
modprobe -- nf_conntrack
modprobe -- br_netfilter
modprobe -- overlay
EOF

chmod 755 /etc/sysconfig/modules/ipvs.modules
bash /etc/sysconfig/modules/ipvs.modules

# Install rpm
yum install -y conntrack ipvsadm ipset jq iptables curl sysstat libseccomp wget iproute-tc

# Update kernel
# rpm --import http://down.linuxsb.com/RPM-GPG-KEY-elrepo.org
# rpm -Uvh http://down.linuxsb.com/elrepo-release-7.el7.elrepo.noarch.rpm
# mv -b /etc/yum.repos.d/elrepo.repo /etc/yum.repos.d/backup
# wget -c http://down.linuxsb.com/myoptions/elrepo7.repo -O /etc/yum.repos.d/elrepo.repo 
# yum --disablerepo="*" --enablerepo="elrepo-kernel" install -y kernel-ml
# sed -i 's/^GRUB_DEFAULT=.*/GRUB_DEFAULT=0/' /etc/default/grub
# grub2-mkconfig -o /boot/grub2/grub.cfg
# yum -y --exclude=docker* update

# Reboot the machine.
# reboot

提示：此操作仅需要在master01节点操作。

对于某些特性，可能需要升级内核，内核升级操作见018.Linux升级内核。
4.19版及以上内核nf_conntrack_ipv4已经改为nf_conntrack。

[root@master01 ~]# source environment.sh
[root@master01 ~]# chmod +x *.sh
[root@master01 ~]# for all_ip in ${ALL_IPS[@]}
  do
    echo ">>> ${all_ip}"
    scp -rp /etc/hosts root@${all_ip}:/etc/hosts
    scp -rp k8sconinit.sh root@${all_ip}:/root/
    ssh root@${all_ip} "bash /root/k8sconinit.sh"
  done

部署高可用组件

HAProxy安装

HAProxy是可提供高可用性、负载均衡以及基于TCP(从而可以反向代理kubeapiserver等应用)和HTTP应用的代理，支持虚拟主机，它是免费、快速并且可靠的一种高可用解决方案。

[root@master01 ~]# wget https://mirrors.huaweicloud.com/haproxy/2.9/src/haproxy-2.9.5.tar.gz
[root@master01 ~]# for master_ip in ${MASTER_IPS[@]}
  do
    echo ">>> ${master_ip}"
    ssh root@${master_ip} "yum -y install gcc gcc-c++ make libnl3 libnl3-devel libnfnetlink openssl-devel wget openssh-clients systemd-devel zlib-devel pcre-devel"
    scp -rp haproxy-2.9.5.tar.gz root@${master_ip}:/root/
    ssh root@${master_ip} "tar -zxvf haproxy-2.9.5.tar.gz"
    ssh root@${master_ip} "cd haproxy-2.9.5/ && make ARCH=x86_64 TARGET=linux-glibc USE_PCRE=1 USE_ZLIB=1 USE_SYSTEMD=1 PREFIX=/usr/local/haprpxy && make install PREFIX=/usr/local/haproxy"
    ssh root@${master_ip} "cp /usr/local/haproxy/sbin/haproxy /usr/sbin/"
    ssh root@${master_ip} "useradd -r haproxy && usermod -G haproxy haproxy"
    ssh root@${master_ip} "mkdir -p /etc/haproxy && mkdir -p /etc/haproxy/conf.d && cp -r /root/haproxy-2.9.5/examples/errorfiles/ /usr/local/haproxy/"
  done

提示：Haproxy官方参考： https://docs.haproxy.org/ 。

KeepAlived安装

KeepAlived 是一个基于VRRP协议来实现的LVS服务高可用方案，可以解决静态路由出现的单点故障问题。

本方案3台master节点均部署并运行Keepalived，一台为主服务器（MASTER），另外两台为备份服务器（BACKUP）。

Master集群外表现为一个VIP，主服务器会发送特定的消息给备份服务器，当备份服务器收不到这个消息的时候，即主服务器宕机的时候，备份服务器就会接管虚拟IP，继续提供服务，从而保证了高可用性。

[root@master01 ~]# wget https://www.keepalived.org/software/keepalived-2.2.8.tar.gz
[root@master01 ~]# for master_ip in ${MASTER_IPS[@]}
  do
    echo ">>> ${master_ip}"
    ssh root@${master_ip} "yum -y install curl gcc gcc-c++ make libnl3 libnl3-devel libnfnetlink openssl-devel"
    scp -rp keepalived-2.2.8.tar.gz root@${master_ip}:/root/
    ssh root@${master_ip} "tar -zxvf keepalived-2.2.8.tar.gz"
    ssh root@${master_ip} "cd keepalived-2.2.8/ && LDFLAGS=\"$LDFAGS -L /usr/local/openssl/lib/\" ./configure --sysconf=/etc --prefix=/usr/local/keepalived && make && make install"
    ssh root@${master_ip} "systemctl enable keepalived"
  done

提示：如上仅需Master01节点操作，从而实现所有节点自动化安装。若出现如下报错：undefined reference to `OPENSSL_init_ssl’，可带上openssl lib路径：

LDFLAGS="$LDFAGS -L /usr/local/openssl/lib/" ./configure --sysconf=/etc --prefix=/usr/local/keepalived

提示：KeepAlive官方参考： https://www.keepalived.org/manpage.html 。

创建配置文件

创建集群部署所需的相关组件配置，采用脚本自动化创建相关配置文件。

[root@master01 ~]# wget http://down.linuxsb.com/mydeploy/k8s/v1.29.2/k8sconfig.sh				#拉取自动部署脚本

[root@master01 ~]# vim k8sconfig.sh
#!/bin/sh
#****************************************************************#
# ScriptName: k8sconfig
# Author: xhy
# Create Date: 2022-06-08 20:00
# Modify Author: xhy
# Modify Date: 2024-02-25 23:57
# Version: v3
#***************************************************************#

#######################################
# set variables below to create the config files, all files will create at ./kubeadm directory
#######################################

# master keepalived virtual ip address
export K8SHA_VIP=172.24.8.100

# master01 ip address
export K8SHA_IP1=172.24.8.111

# master02 ip address
export K8SHA_IP2=172.24.8.112

# master03 ip address
export K8SHA_IP3=172.24.8.113

# master01 hostname
export K8SHA_HOST1=master01

# master02 hostname
export K8SHA_HOST2=master02

# master03 hostname
export K8SHA_HOST3=master03

# master01 network interface name
export K8SHA_NETINF1=eth0

# master02 network interface name
export K8SHA_NETINF2=eth0

# master03 network interface name
export K8SHA_NETINF3=eth0

# keepalived auth_pass config
export K8SHA_KEEPALIVED_AUTH=412f7dc3bfed32194d1600c483e10ad1d

# kubernetes CIDR pod subnet
export K8SHA_PODCIDR=10.10.0.0/16

# kubernetes CIDR svc subnet
export K8SHA_SVCCIDR=10.20.0.0/16

# kubernetes CIDR pod mtu
export K8SHA_PODMTU=1450

##############################
# please do not modify anything below
##############################

mkdir -p kubeadm/$K8SHA_HOST1/{keepalived,haproxy}
mkdir -p kubeadm/$K8SHA_HOST2/{keepalived,haproxy}
mkdir -p kubeadm/$K8SHA_HOST3/{keepalived,haproxy}
mkdir -p kubeadm/keepalived
mkdir -p kubeadm/haproxy

echo "create directory files success."

# wget all files
wget -c -P kubeadm/keepalived/ http://down.linuxsb.com/mydeploy/k8s/common/k8s-keepalived.conf.tpl
wget -c -P kubeadm/keepalived/ http://down.linuxsb.com/mydeploy/k8s/common/check_apiserver.sh
wget -c -P kubeadm/haproxy/ http://down.linuxsb.com/mydeploy/k8s/common/k8s-haproxy.cfg.tpl
wget -c -P kubeadm/haproxy/ http://down.linuxsb.com/mydeploy/k8s/common/k8s-haproxy.service
wget -c -P kubeadm/ http://down.linuxsb.com/mydeploy/k8s/v1.29.2/kubeadm-config.yaml.tpl
wget -c -P kubeadm/calico/ http://down.linuxsb.com/mydeploy/k8s/calico/v3.27.2/calico.yaml.tpl
wget -c -P kubeadm/ http://down.linuxsb.com/mydeploy/k8s/v1.29.2/k8simage.sh

echo "down files success."

# create all kubeadm-config.yaml files
sed \
-e "s/K8SHA_HOST1/${K8SHA_HOST1}/g" \
-e "s/K8SHA_HOST2/${K8SHA_HOST2}/g" \
-e "s/K8SHA_HOST3/${K8SHA_HOST3}/g" \
-e "s/K8SHA_IP1/${K8SHA_IP1}/g" \
-e "s/K8SHA_IP2/${K8SHA_IP2}/g" \
-e "s/K8SHA_IP3/${K8SHA_IP3}/g" \
-e "s/K8SHA_VIP/${K8SHA_VIP}/g" \
-e "s!K8SHA_PODCIDR!${K8SHA_PODCIDR}!g" \
-e "s!K8SHA_SVCCIDR!${K8SHA_SVCCIDR}!g" \
kubeadm/kubeadm-config.yaml.tpl > kubeadm/kubeadm-config.yaml

echo "create kubeadm-config.yaml files success."

# create all keepalived files
chmod u+x kubeadm/keepalived/check_apiserver.sh
cp kubeadm/keepalived/check_apiserver.sh kubeadm/$K8SHA_HOST1/keepalived
cp kubeadm/keepalived/check_apiserver.sh kubeadm/$K8SHA_HOST2/keepalived
cp kubeadm/keepalived/check_apiserver.sh kubeadm/$K8SHA_HOST3/keepalived

sed \
-e "s/K8SHA_KA_STATE/BACKUP/g" \
-e "s/K8SHA_KA_INTF/${K8SHA_NETINF1}/g" \
-e "s/K8SHA_IPLOCAL/${K8SHA_IP1}/g" \
-e "s/K8SHA_KA_PRIO/102/g" \
-e "s/K8SHA_VIP/${K8SHA_VIP}/g" \
-e "s/K8SHA_KA_AUTH/${K8SHA_KEEPALIVED_AUTH}/g" \
kubeadm/keepalived/k8s-keepalived.conf.tpl > kubeadm/$K8SHA_HOST1/keepalived/keepalived.conf

sed \
-e "s/K8SHA_KA_STATE/BACKUP/g" \
-e "s/K8SHA_KA_INTF/${K8SHA_NETINF2}/g" \
-e "s/K8SHA_IPLOCAL/${K8SHA_IP2}/g" \
-e "s/K8SHA_KA_PRIO/101/g" \
-e "s/K8SHA_VIP/${K8SHA_VIP}/g" \
-e "s/K8SHA_KA_AUTH/${K8SHA_KEEPALIVED_AUTH}/g" \
kubeadm/keepalived/k8s-keepalived.conf.tpl > kubeadm/$K8SHA_HOST2/keepalived/keepalived.conf

sed \
-e "s/K8SHA_KA_STATE/BACKUP/g" \
-e "s/K8SHA_KA_INTF/${K8SHA_NETINF3}/g" \
-e "s/K8SHA_IPLOCAL/${K8SHA_IP3}/g" \
-e "s/K8SHA_KA_PRIO/100/g" \
-e "s/K8SHA_VIP/${K8SHA_VIP}/g" \
-e "s/K8SHA_KA_AUTH/${K8SHA_KEEPALIVED_AUTH}/g" \
kubeadm/keepalived/k8s-keepalived.conf.tpl > kubeadm/$K8SHA_HOST3/keepalived/keepalived.conf

echo "create keepalived files success. kubeadm/$K8SHA_HOST1/keepalived/"
echo "create keepalived files success. kubeadm/$K8SHA_HOST2/keepalived/"
echo "create keepalived files success. kubeadm/$K8SHA_HOST3/keepalived/"

# create all haproxy files
sed \
-e "s/K8SHA_IP1/$K8SHA_IP1/g" \
-e "s/K8SHA_IP2/$K8SHA_IP2/g" \
-e "s/K8SHA_IP3/$K8SHA_IP3/g" \
-e "s/K8SHA_HOST1/$K8SHA_HOST1/g" \
-e "s/K8SHA_HOST2/$K8SHA_HOST2/g" \
-e "s/K8SHA_HOST3/$K8SHA_HOST3/g" \
kubeadm/haproxy/k8s-haproxy.cfg.tpl > kubeadm/haproxy/haproxy.conf

echo "create haproxy files success. kubeadm/$K8SHA_HOST1/haproxy/"
echo "create haproxy files success. kubeadm/$K8SHA_HOST2/haproxy/"
echo "create haproxy files success. kubeadm/$K8SHA_HOST3/haproxy/"

# create calico yaml file
sed \
-e "s!K8SHA_PODCIDR!${K8SHA_PODCIDR}!g" \
-e "s!K8SHA_PODMTU!${K8SHA_PODMTU}!g" \
kubeadm/calico/calico.yaml.tpl > kubeadm/calico/calico.yaml

echo "create calico file success."

# scp all file
scp -rp kubeadm/haproxy/haproxy.conf root@$K8SHA_HOST1:/etc/haproxy/haproxy.cfg
scp -rp kubeadm/haproxy/haproxy.conf root@$K8SHA_HOST2:/etc/haproxy/haproxy.cfg
scp -rp kubeadm/haproxy/haproxy.conf root@$K8SHA_HOST3:/etc/haproxy/haproxy.cfg
scp -rp kubeadm/haproxy/k8s-haproxy.service root@$K8SHA_HOST1:/usr/lib/systemd/system/haproxy.service
scp -rp kubeadm/haproxy/k8s-haproxy.service root@$K8SHA_HOST2:/usr/lib/systemd/system/haproxy.service
scp -rp kubeadm/haproxy/k8s-haproxy.service root@$K8SHA_HOST3:/usr/lib/systemd/system/haproxy.service

scp -rp kubeadm/$K8SHA_HOST1/keepalived/* root@$K8SHA_HOST1:/etc/keepalived/
scp -rp kubeadm/$K8SHA_HOST2/keepalived/* root@$K8SHA_HOST2:/etc/keepalived/
scp -rp kubeadm/$K8SHA_HOST3/keepalived/* root@$K8SHA_HOST3:/etc/keepalived/

echo "scp haproxy & keepalived file success."

# chmod *.sh
chmod u+x kubeadm/*.sh

[root@master01 ~]# bash k8sconfig.sh

解释：如上仅需Master01节点操作。执行k8sconfig.sh脚本后会生产如下配置文件清单：

kubeadm-config.yaml：kubeadm初始化配置文件，位于kubeadm/目录，可参考 kubeadm 配置
keepalived：keepalived配置文件，位于各个master节点的/etc/keepalived目录
haproxy：haproxy的配置文件，位于各个master节点的/etc/haproxy/目录
calico.yaml：calico网络组件部署文件，位于kubeadm/calico/目录

[root@master01 ~]# vim kubeadm/kubeadm-config.yaml	#检查集群初始化配置
---
apiVersion: kubeadm.k8s.io/v1beta3
kind: ClusterConfiguration
networking:
  serviceSubnet: "10.20.0.0/16"			     	    #设置svc网段
  podSubnet: "10.10.0.0/16"                         #设置Pod网段
  dnsDomain: "cluster.local"
kubernetesVersion: "v1.29.2"			    	    #设置安装版本
controlPlaneEndpoint: "172.24.8.100:16443"		    #设置相关API VIP地址
apiServer:
  certSANs:
  - 127.0.0.1
  - master01
  - master02
  - master03
  - 172.24.8.111
  - 172.24.8.112
  - 172.24.8.113
  - 172.24.8.100
  timeoutForControlPlane: 4m0s
certificatesDir: "/etc/kubernetes/pki"
imageRepository: "registry.k8s.io"
#clusterName: "example-cluster"

---
apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
cgroupDriver: systemd

---
apiVersion: kubeproxy.config.k8s.io/v1alpha1
kind: KubeProxyConfiguration
mode: ipvs

提示：如上仅需Master01节点操作，更多config文件参考：kubeadm 配置 (v1beta3)

默认kubeadm配置可使用kubeadm config print init-defaults > config.yaml生成。

启动服务

启动keepalive和HAProxy服务，从而构建master节点的高可用。

检查服务配置

[root@master01 ~]# cat /etc/keepalived/keepalived.conf              #所有节点确认相关keepalive配置文件
! Configuration File for keepalived
global_defs {
    router_id LVS_DEVEL
    script_user root
    enable_script_security
}
vrrp_script check_apiserver {
    script "/etc/keepalived/check_apiserver.sh"
    interval 5
    weight -60
    fall 2
    rise 2
}
vrrp_instance VI_1 {
    state BACKUP
    interface eth0
    mcast_src_ip 172.24.8.111
    virtual_router_id 51
    priority 102
    advert_int 5
    authentication {
        auth_type PASS
        auth_pass 412f7dc3bfed32194d1600c483e10ad1d
    }
    virtual_ipaddress {
        172.24.8.100
    }
    track_script {
       check_apiserver
    }
}
[root@master01 ~]# cat /etc/keepalived/check_apiserver.sh              #所有节点确认相关keepalive监测脚本文件
#!/bin/bash

# if check error then repeat check for 12 times, else exit
err=0
for k in $(seq 1 12)
do
    check_code=$(curl -k https://localhost:6443)
    if [[ $check_code == "" ]]; then
        err=$(expr $err + 1)
        sleep 5
        continue
    else
        err=0
        break
    fi
done

if [[ $err != "0" ]]; then
    # if apiserver is down send SIG=1
    echo 'apiserver error!'
    exit 1
else
    # if apiserver is up send SIG=0
    echo 'apiserver normal!'
    exit 0
fi

启动高可用服务

[root@master01 ~]# for master_ip in ${MASTER_IPS[@]}
do
    echo ">>> ${master_ip}"
    ssh root@${master_ip} "systemctl enable haproxy.service --now && systemctl restart haproxy.service"
    ssh root@${master_ip} "systemctl enable keepalived.service --now && systemctl restart keepalived.service"
    ssh root@${master_ip} "systemctl status keepalived.service | grep Active"
    ssh root@${master_ip} "systemctl status haproxy.service | grep Active"
done
[root@master01 ~]# for all_ip in ${ALL_IPS[@]}
do
    echo ">>> ${all_ip}"
    ssh root@${all_ip} "ping -c1 172.24.8.100"
done								                #等待10s执行检查

提示：如上仅需Master01节点操作，从而实现所有节点自动启动服务。

集群部署

正式安装

快速安装所有节点的kubeadm、kubelet、kubectl组件。

[root@master01 ~]# for all_ip in ${ALL_IPS[@]}
  do
    echo ">>> ${all_ip}"
    ssh root@${all_ip} "cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes-new/core/stable/v1.29/rpm/
enabled=1
gpgcheck=1
gpgkey=https://mirrors.aliyun.com/kubernetes-new/core/stable/v1.29/rpm/repodata/repomd.xml.key
EOF"
    ssh root@${all_ip} "yum install -y kubelet-1.29.2-150500.1.1 kubectl-1.29.2-150500.1.1 --disableexcludes=kubernetes"
    ssh root@${all_ip} "yum install -y kubeadm-1.29.2-150500.1.1 --disableexcludes=kubernetes"
    ssh root@${all_ip} "systemctl enable kubelet"
done
[root@master01 ~]# yum search -y kubelet --showduplicates             #查看相应版本

提示：如上仅需Master01节点操作，从而实现所有节点自动化安装，同时此时不需要启动kubelet，初始化的过程中会自动启动的，如果此时启动了会出现报错，忽略即可。

说明：同时安装了cri-tools, kubernetes-cni, socat三个依赖：

socat：kubelet的依赖；

cri-tools：即CRI(Container Runtime Interface)容器运行时接口的命令行工具。

集群初始化

拉取镜像

初始化过程中会pull大量镜像，并且镜像位于国外，可能出现无法pull的情况导致Kubernetes初始化失败。建议提前准备镜像，保证后续初始化。

[root@master01 ~]# kubeadm --kubernetes-version=v1.29.2 config images list     	#列出所需镜像

[root@master01 ~]# vim kubeadm/k8simage.sh
#!/bin/sh
#****************************************************************#
# ScriptName: k8simage.sh
# Author: xhy
# Create Date: 2023-02-10 14:47
# Modify Author: xhy
# Modify Date: 2024-03-01 00:23
# Version: 
#***************************************************************#

KUBE_VERSION=v1.29.2
KUBE_PAUSE_VERSION=3.9
ETCD_VERSION=3.5.10-0
CORE_DNS_VERSION=v1.11.1
K8S_URL=registry.k8s.io
#GCR_URL=k8s.gcr.io
UCLOUD_URL=uhub.service.ucloud.cn/imxhy
LONGHORN_URL=longhornio
CALICO_URL='docker.io/calico'
CALICO_VERSION=v3.27.2
METRICS_SERVER_VERSION=v0.7.0
INGRESS_VERSION=v1.9.6
INGRESS_WEBHOOK_VERSION=v20231226-1a7112e06
LONGHORN_VERSION=v1.6.0
LONGHORN_VERSION2=v0.0.33
CSI_ATTACHER_VERSION=v4.4.2
CSI_NODE_DRIVER_VERSION=v2.9.2
CSI_PROVISIONER_VERSION=v3.6.2
CSI_RESIZER_VERSION=v1.9.2
CSI_SNAP_VERSION=v6.3.2
CSI_LIVE_VERSION=v2.11.0
#DEFAULTBACKENDVERSION=1.5

mkdir -p k8simages/

# config node hostname
export ALL_IPS=(master02 master03 worker01 worker02 worker03)

kubeimages=(kube-proxy:${KUBE_VERSION}
kube-scheduler:${KUBE_VERSION}
kube-controller-manager:${KUBE_VERSION}
kube-apiserver:${KUBE_VERSION}
pause:${KUBE_PAUSE_VERSION}
etcd:${ETCD_VERSION}
)

for kubeimageName in ${kubeimages[@]} ; do
echo ${kubeimageName}
ctr -n k8s.io images pull ${UCLOUD_URL}/${kubeimageName}
ctr -n k8s.io images tag ${UCLOUD_URL}/${kubeimageName} ${K8S_URL}/${kubeimageName}
ctr -n k8s.io images rm ${UCLOUD_URL}/${kubeimageName}
ctr -n k8s.io images export k8simages/${kubeimageName}\.tar ${K8S_URL}/${kubeimageName}
done

corednsimages=(coredns:${CORE_DNS_VERSION}
)

for corednsimageName in ${corednsimages[@]} ; do
echo ${corednsimageName}
ctr -n k8s.io images pull ${UCLOUD_URL}/${corednsimageName}
ctr -n k8s.io images tag ${UCLOUD_URL}/${corednsimageName} ${K8S_URL}/coredns/${corednsimageName}
ctr -n k8s.io images rm ${UCLOUD_URL}/${corednsimageName}
ctr -n k8s.io images export k8simages/${corednsimageName}\.tar ${K8S_URL}/coredns/${corednsimageName}
done

metricsimages=(metrics-server:${METRICS_SERVER_VERSION})

for metricsimageName in ${metricsimages[@]} ; do
echo ${metricsimageName}
ctr -n k8s.io images pull ${UCLOUD_URL}/${metricsimageName}
ctr -n k8s.io images tag ${UCLOUD_URL}/${metricsimageName} ${K8S_URL}/metrics-server/${metricsimageName}
ctr -n k8s.io images rm ${UCLOUD_URL}/${metricsimageName}
ctr -n k8s.io images export k8simages/${metricsimageName}\.tar ${K8S_URL}/metrics-server/${metricsimageName}
done

calimages=(cni:${CALICO_VERSION}
node:${CALICO_VERSION}
kube-controllers:${CALICO_VERSION})

for calimageName in ${calimages[@]} ; do
echo ${calimageName}
ctr -n k8s.io images pull ${UCLOUD_URL}/${calimageName}
ctr -n k8s.io images tag ${UCLOUD_URL}/${calimageName} ${CALICO_URL}/${calimageName}
ctr -n k8s.io images rm ${UCLOUD_URL}/${calimageName}
ctr -n k8s.io images export k8simages/${calimageName}\.tar ${CALICO_URL}/${calimageName}
done

ingressimages=(controller:${INGRESS_VERSION}
kube-webhook-certgen:${INGRESS_WEBHOOK_VERSION}
)

for ingressimageName in ${ingressimages[@]} ; do
echo ${ingressimageName}
ctr -n k8s.io images pull ${UCLOUD_URL}/${ingressimageName}
ctr -n k8s.io images tag ${UCLOUD_URL}/${ingressimageName} ${K8S_URL}/ingress-nginx/${ingressimageName}
ctr -n k8s.io images rm ${UCLOUD_URL}/${ingressimageName}
ctr -n k8s.io images export k8simages/${ingressimageName}\.tar ${K8S_URL}/ingress-nginx/${ingressimageName}
done

longhornimages01=(longhorn-engine:${LONGHORN_VERSION}
longhorn-instance-manager:${LONGHORN_VERSION}
longhorn-manager:${LONGHORN_VERSION}
longhorn-ui:${LONGHORN_VERSION}
backing-image-manager:${LONGHORN_VERSION}
longhorn-share-manager:${LONGHORN_VERSION}
)

for longhornimageNameA in ${longhornimages01[@]} ; do
echo ${longhornimageNameA}
ctr -n k8s.io images pull ${UCLOUD_URL}/${longhornimageNameA}
ctr -n k8s.io images tag ${UCLOUD_URL}/${longhornimageNameA} ${LONGHORN_URL}/${longhornimageNameA}
ctr -n k8s.io images rm ${UCLOUD_URL}/${longhornimageNameA}
ctr -n k8s.io images export k8simages/${longhornimageNameA}\.tar ${LONGHORN_URL}/${longhornimageNameA}
done

longhornimages02=(support-bundle-kit:${LONGHORN_VERSION2})

for longhornimageNameB in ${longhornimages02[@]} ; do
echo ${longhornimageNameB}
ctr -n k8s.io images pull ${UCLOUD_URL}/${longhornimageNameB}
ctr -n k8s.io images tag ${UCLOUD_URL}/${longhornimageNameB} ${LONGHORN_URL}/${longhornimageNameB}
ctr -n k8s.io images rm ${UCLOUD_URL}/${longhornimageNameB}
ctr -n k8s.io images export k8simages/${longhornimageNameB}\.tar ${LONGHORN_URL}/${longhornimageNameB}
done

csiimages=(csi-attacher:${CSI_ATTACHER_VERSION}
csi-node-driver-registrar:${CSI_NODE_DRIVER_VERSION}
csi-provisioner:${CSI_PROVISIONER_VERSION}
csi-resizer:${CSI_RESIZER_VERSION}
csi-snapshotter:${CSI_SNAP_VERSION}
livenessprobe:${CSI_LIVE_VERSION}
)

for csiimageName in ${csiimages[@]} ; do
echo ${csiimageName}
ctr -n k8s.io images pull ${UCLOUD_URL}/${csiimageName}
ctr -n k8s.io images tag ${UCLOUD_URL}/${csiimageName} ${LONGHORN_URL}/${csiimageName}
ctr -n k8s.io images rm ${UCLOUD_URL}/${csiimageName}
ctr -n k8s.io images export k8simages/${csiimageName}\.tar ${LONGHORN_URL}/${csiimageName}
done

#otherimages=(defaultbackend-amd64:${DEFAULTBACKENDVERSION})

#for otherimagesName in ${otherimages[@]} ; do
#echo ${otherimagesName}
#ctr -n k8s.io images pull ${UCLOUD_URL}/${otherimagesName}
#ctr -n k8s.io images tag ${UCLOUD_URL}/${otherimagesName} ${K8S_URL}/${otherimagesName}
#ctr -n k8s.io images rm ${UCLOUD_URL}/${otherimagesName}
#ctr -n k8s.io images export k8simages/${otherimagesName}\.tar ${K8S_URL}/${otherimagesName}
#done
#

allimages=(kube-proxy:${KUBE_VERSION}
kube-scheduler:${KUBE_VERSION}
kube-controller-manager:${KUBE_VERSION}
kube-apiserver:${KUBE_VERSION}
pause:${KUBE_PAUSE_VERSION}
etcd:${ETCD_VERSION}
coredns:${CORE_DNS_VERSION}
metrics-server:${METRICS_SERVER_VERSION}
cni:${CALICO_VERSION}
node:${CALICO_VERSION}
kube-controllers:${CALICO_VERSION}
controller:${INGRESS_VERSION}
kube-webhook-certgen:${INGRESS_WEBHOOK_VERSION}
longhorn-engine:${LONGHORN_VERSION}
longhorn-instance-manager:${LONGHORN_VERSION}
longhorn-manager:${LONGHORN_VERSION}
longhorn-ui:${LONGHORN_VERSION}
backing-image-manager:${LONGHORN_VERSION}
longhorn-share-manager:${LONGHORN_VERSION}
support-bundle-kit:${LONGHORN_VERSION2}
csi-attacher:${CSI_ATTACHER_VERSION}
csi-node-driver-registrar:${CSI_NODE_DRIVER_VERSION}
csi-provisioner:${CSI_PROVISIONER_VERSION}
csi-resizer:${CSI_RESIZER_VERSION}
csi-snapshotter:${CSI_SNAP_VERSION}
livenessprobe:${CSI_LIVE_VERSION}
defaultbackend-amd64:${DEFAULTBACKENDVERSION}
)
for all_ip in ${ALL_IPS[@]}
  do  
    echo ">>> ${all_ip}"
    ssh root@${all_ip} "mkdir /root/k8simages"
    scp -rp k8simages/* root@${all_ip}:/root/k8simages/
  done

for allimageName in ${allimages[@]}
  do
  for all_ip in ${ALL_IPS[@]}
    do
    echo "${allimageName} copy to ${all_ip}"
    ssh root@${all_ip} "ctr -n k8s.io images import k8simages/${allimageName}\.tar"
    done
  done
  
[root@master01 ~]# bash kubeadm/k8simage.sh                     #确认版本，提前下载镜像

提示：如上仅需Master01节点操作，从而实现所有节点镜像的分发。

注意相关版本，如上脚本为v1.29.2 Kubernetes版本所需镜像。

[root@master01 ~]# ctr -n k8s.io images ls        	#确认验证
[root@master02 ~]# crictl images ls
IMAGE                                                TAG                   IMAGE ID            SIZE
docker.io/calico/cni                                 v3.27.2               bbf4b051c5078       88.2MB
docker.io/calico/kube-controllers                    v3.27.2               849ce09815546       33.4MB
docker.io/calico/node                                v3.27.2               50df0b2eb8ffe       117MB
docker.io/kubernetesui/dashboard-api                 v1.0.0                3ae476f39dc51       21.6MB
docker.io/kubernetesui/dashboard-web                 v1.0.0                68ccbbbd48e89       56.1MB
docker.io/longhornio/backing-image-manager           v1.6.0                fd4639eeb10a1       131MB
docker.io/longhornio/csi-attacher                    v4.4.2                6bc8bdd63e408       26.7MB
docker.io/longhornio/csi-node-driver-registrar       v2.9.2                438c692b0cb6d       10.8MB
docker.io/longhornio/csi-provisioner                 v3.6.2                ec9b939801797       28.7MB
docker.io/longhornio/csi-resizer                     v1.9.2                d11bd1f0b3e57       27MB
docker.io/longhornio/csi-snapshotter                 v6.3.2                118137d698bbd       26.8MB
docker.io/longhornio/livenessprobe                   v2.11.0               494ea5379400e       9.69MB
docker.io/longhornio/longhorn-engine                 v1.6.0                f772ce9ba10a4       136MB
docker.io/longhornio/longhorn-instance-manager       v1.6.0                2e4eb3ba8dca0       269MB
docker.io/longhornio/longhorn-manager                v1.6.0                9f4c1b666bd8c       111MB
docker.io/longhornio/longhorn-share-manager          v1.6.0                e561f36d6e02b       79.2MB
docker.io/longhornio/longhorn-ui                     v1.6.0                efa6d3d087772       73.2MB
docker.io/longhornio/support-bundle-kit              v0.0.33               29c0bdda32275       126MB
registry.k8s.io/coredns/coredns                      v1.11.1               cbb01a7bd410d       18.2MB
registry.k8s.io/etcd                                 3.5.10-0              a0eed15eed449       56.6MB
registry.k8s.io/ingress-nginx/controller             v1.9.6                2bdab7410148a       105MB
registry.k8s.io/ingress-nginx/kube-webhook-certgen   v20231226-1a7112e06   eb825d2bb76b9       23.1MB
registry.k8s.io/kube-apiserver                       v1.29.2               8a9000f98a528       35.1MB
registry.k8s.io/kube-controller-manager              v1.29.2               138fb5a3a2e34       33.4MB
registry.k8s.io/kube-proxy                           v1.29.2               9344fce2372f8       28.4MB
registry.k8s.io/kube-scheduler                       v1.29.2               6fc5e6b7218c7       18.5MB
registry.k8s.io/metrics-server/metrics-server        v0.7.0                b9a5a1927366a       19.4MB
registry.k8s.io/pause                                3.9                   e6f1816883972       319kB

Master01上初始化

Master01节点上执行初始化，即完成单节点的Kubernetes，其他节点采用添加的方式部署。

[root@master01 ~]# kubeadm init --config=kubeadm/kubeadm-config.yaml --upload-certs                 #保留如下命令用于后续节点添加
[init] Using Kubernetes version: v1.29.2
[preflight] Running pre-flight checks
……
Your Kubernetes control-plane has initialized successfully!

To start using your cluster, you need to run the following as a regular user:

  mkdir -p $HOME/.kube
  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  sudo chown $(id -u):$(id -g) $HOME/.kube/config

Alternatively, if you are the root user, you can run:

  export KUBECONFIG=/etc/kubernetes/admin.conf

You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  https://kubernetes.io/docs/concepts/cluster-administration/addons/

You can now join any number of the control-plane node running the following command on each as root:

  kubeadm join 172.24.8.100:16443 --token giufgc.znr68fr73yepqhsf \
        --discovery-token-ca-cert-hash sha256:6c98b18f62cfeec929e8aaa20b9723cdcdc0ad3ceb93989ac7a80ae66a54b3e3 \
        --control-plane --certificate-key ded93dc0499173f5feba1fa30b63a20c272d3188b97b1ee3860b21e90da9f09b

Please note that the certificate-key gives access to cluster sensitive data, keep it secret!
As a safeguard, uploaded-certs will be deleted in two hours; If necessary, you can use
"kubeadm init phase upload-certs --upload-certs" to reload certs afterward.

Then you can join any number of worker nodes by running the following on each as root:

kubeadm join 172.24.8.100:16443 --token giufgc.znr68fr73yepqhsf \
        --discovery-token-ca-cert-hash sha256:6c98b18f62cfeec929e8aaa20b9723cdcdc0ad3ceb93989ac7a80ae66a54b3e3

注意：如上token具有默认24小时的有效期，token和hash值可通过如下方式获取：

kubeadm token list

如果 Token 过期以后，可以输入以下命令，生成新的 Token:

kubeadm token create
openssl x509 -pubkey -in /etc/kubernetes/pki/ca.crt | openssl rsa -pubin -outform der 2>/dev/null | openssl dgst -sha256 -hex | sed 's/^.* //'

创建相关Kubernetes集群配置文件保存目录。

[root@master01 ~]# mkdir -p $HOME/.kube
[root@master01 ~]# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
[root@master01 ~]# sudo chown $(id -u):$(id -g) $HOME/.kube/config
[root@master01 ~]# cat << EOF >> ~/.bashrc
export KUBECONFIG=$HOME/.kube/config
EOF                                                                                 #设置KUBECONFIG环境变量
[root@master01 ~]# echo "source <(kubectl completion bash)" >> ~/.bashrc
[root@master01 ~]# source ~/.bashrc

附加：初始化过程大致步骤如下：

certs：生成相关的各种证书
control-plane：创建Kubernetes控制节点的静态Pod
etcd：创建ETCD的静态Pod
kubelet-start：生成kubelet的配置文件”/var/lib/kubelet/config.yaml”
kubeconfig：生成相关的kubeconfig文件
bootstraptoken：生成token记录下来，后续使用kubeadm join往集群中添加节点时会用到
addons：附带的相关插件

提示：初始化仅需要在master01上执行，若初始化异常可通过kubeadm reset -f kubeadm/kubeadm-config.yaml && rm -rf $HOME/.kube /etc/cni/ /etc/kubernetes/重置。

添加Master节点

采用 kubeadm join 将其他Master节点添加至集群。

[root@master02 ~]# kubeadm join 172.24.8.100:16443 --token giufgc.znr68fr73yepqhsf \
    --discovery-token-ca-cert-hash sha256:6c98b18f62cfeec929e8aaa20b9723cdcdc0ad3ceb93989ac7a80ae66a54b3e3 \
    --control-plane --certificate-key ded93dc0499173f5feba1fa30b63a20c272d3188b97b1ee3860b21e90da9f09b
[root@master02 ~]# mkdir -p $HOME/.kube
[root@master02 ~]# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
[root@master02 ~]# sudo chown $(id -u):$(id -g) $HOME/.kube/config
[root@master02 ~]# cat << EOF >> ~/.bashrc
export KUBECONFIG=$HOME/.kube/config
EOF						               	                                            #设置KUBECONFIG环境变量
[root@master02 ~]# echo "source <(kubectl completion bash)" >> ~/.bashrc
[root@master02 ~]# source ~/.bashrc

提示：master03也如上操作，添加至当前集群的controlplane。

若添加异常可通过kubeadm reset -f kubeadm/kubeadm-config.yaml && rm -rf $HOME/.kube /etc/cni/ /etc/kubernetes/重置。

安装NIC插件

NIC插件介绍

Calico 是一个安全的 L3 网络和网络策略提供者。
Canal 结合 Flannel 和 Calico，提供网络和网络策略。
Cilium 是一个 L3 网络和网络策略插件，能够透明的实施 HTTP/API/L7 策略。同时支持路由（routing）和叠加/封装（ overlay/encapsulation）模式。
Contiv 为多种用例提供可配置网络（使用 BGP 的原生 L3，使用 vxlan 的 overlay，经典 L2 和 Cisco-SDN/ACI）和丰富的策略框架。Contiv 项目完全开源。安装工具同时提供基于和不基于 kubeadm 的安装选项。
Flannel 是一个可以用于 Kubernetes 的 overlay 网络提供者。 +Romana 是一个 pod 网络的层 3 解决方案，并且支持 NetworkPolicy API。Kubeadm add-on 安装细节可以在这里找到。
Weave Net 提供了在网络分组两端参与工作的网络和网络策略，并且不需要额外的数据库。
CNI-Genie 使 Kubernetes 无缝连接到一种 CNI 插件，例如：Flannel、Calico、Canal、Romana 或者 Weave。

提示：本方案使用Calico插件。

部署calico

确认相关配置，如MTU，网卡接口，Pod的IP地址段。

calico原文件可参考官方：https://raw.githubusercontent.com/projectcalico/calico/v3.27.2/manifests/calico.yaml

[root@master01 ~]# vim kubeadm/calico/calico.yaml	    #检查配置
……
data:
……
  veth_mtu: "1400"
……
            - name: CALICO_IPV4POOL_CIDR
              value: "10.10.0.0/16"			            #配置Pod网段
……
            - name: IP_AUTODETECTION_METHOD
              value: "interface=eth.*"			        #检查节点之间的网卡
……
[root@master01 ~]# kubectl apply -f kubeadm/calico/calico.yaml
[root@master01 ~]# kubectl get pods --all-namespaces -o wide		#查看部署的所有Pod
NAMESPACE     NAME                                       READY   STATUS    RESTARTS       AGE     IP             NODE       NOMINATED NODE   READINESS GATES
kube-system   calico-kube-controllers-674fff74c8-grp94   1/1     Running   0              55s     10.10.59.193   master02   <none>           <none>
kube-system   calico-node-8gs4l                          1/1     Running   0              55s     172.24.8.113   master03   <none>           <none>
kube-system   calico-node-gvwwx                          1/1     Running   0              55s     172.24.8.112   master02   <none>           <none>
kube-system   calico-node-k8vxv                          1/1     Running   0              55s     172.24.8.111   master01   <none>           <none>
kube-system   coredns-5d78c9869d-9s2dv                   1/1     Running   0              3m20s   10.10.59.194   master02   <none>           <none>
kube-system   coredns-5d78c9869d-bxp4z                   1/1     Running   0              3m20s   10.10.59.195   master02   <none>           <none>
kube-system   etcd-master01                              1/1     Running   0              3m33s   172.24.8.111   master01   <none>           <none>
kube-system   etcd-master02                              1/1     Running   0              113s    172.24.8.112   master02   <none>           <none>
kube-system   etcd-master03                              1/1     Running   0              93s     172.24.8.113   master03   <none>           <none>
kube-system   kube-apiserver-master01                    1/1     Running   0              3m34s   172.24.8.111   master01   <none>           <none>
kube-system   kube-apiserver-master02                    1/1     Running   0              113s    172.24.8.112   master02   <none>           <none>
kube-system   kube-apiserver-master03                    1/1     Running   0              92s     172.24.8.113   master03   <none>           <none>
kube-system   kube-controller-manager-master01           1/1     Running   0              3m33s   172.24.8.111   master01   <none>           <none>
kube-system   kube-controller-manager-master02           1/1     Running   0              105s    172.24.8.112   master02   <none>           <none>
kube-system   kube-controller-manager-master03           1/1     Running   0              97s     172.24.8.113   master03   <none>           <none>
kube-system   kube-proxy-6hwzb                           1/1     Running   0              68s     172.24.8.113   master03   <none>           <none>
kube-system   kube-proxy-sx5b7                           1/1     Running   0              114s    172.24.8.112   master02   <none>           <none>
kube-system   kube-proxy-ww744                           1/1     Running   0              3m20s   172.24.8.111   master01   <none>           <none>
kube-system   kube-scheduler-master01                    1/1     Running   0              3m33s   172.24.8.111   master01   <none>           <none>
kube-system   kube-scheduler-master02                    1/1     Running   0              97s     172.24.8.112   master02   <none>           <none>
kube-system   kube-scheduler-master03                    1/1     Running   0              90s     172.24.8.113   master03   <none>           <none>

[root@master01 ~]# kubectl get nodes
NAME       STATUS   ROLES           AGE     VERSION
master01   Ready    control-plane   3m37s   v1.29.2
master02   Ready    control-plane   117s    v1.29.2
master03   Ready    control-plane   116s    v1.29.2

提示：官方calico参考：https://docs.projectcalico.org/manifests/calico.yaml

修改node端口范围

Kubernetes默认的端口范围为30000-32767，为便于后期大量的应用，如ingress的80、443端口，可开放全端口。

同时开放全端口范围后，使用的时候需要注意避开公共端口，如8080。

[root@master01 ~]# vi /etc/kubernetes/manifests/kube-apiserver.yaml                     #追加端口开放配置
……
    - --service-node-port-range=1-65535
……

提示：如上需要在所有Master节点操作。

添加Worker节点

[root@master01 ~]# source environment.sh
[root@master01 ~]# for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "kubeadm join 172.24.8.100:16443 --token giufgc.znr68fr73yepqhsf \
        --discovery-token-ca-cert-hash sha256:6c98b18f62cfeec929e8aaa20b9723cdcdc0ad3ceb93989ac7a80ae66a54b3e3"
    ssh root@${node_ip} "systemctl enable kubelet.service"
  done

提示：如上仅需Master01节点操作，从而实现所有Worker节点添加至集群，若添加异常可通过如下方式重置：

[root@worker01 ~]# kubeadm reset
[root@worker01 ~]# ifconfig cni0 down
[root@worker01 ~]# ip link delete cni0
[root@worker01 ~]# ifconfig flannel.1 down
[root@worker01 ~]# ip link delete flannel.1
[root@worker01 ~]# rm -rf /var/lib/cni/

确认验证

[root@master01 ~]# kubectl get nodes			         	#节点状态
[root@master01 ~]# kubectl get cs			             	#组件状态
[root@master01 ~]# kubectl get serviceaccount		     	#服务账户
[root@master01 ~]# kubectl cluster-info			         	#集群信息
[root@master01 ~]# kubectl get pod -n kube-system -o wide	#所有服务状态

提示：更多Kubetcl使用参考：https://kubernetes.io/docs/reference/kubectl/kubectl/

https://kubernetes.io/docs/reference/kubectl/overview/

更多kubeadm使用参考：https://kubernetes.io/docs/reference/setup-tools/kubeadm/kubeadm/

Metrics部署

Metrics介绍

Kubernetes的早期版本依靠Heapster来实现完整的性能数据采集和监控功能，Kubernetes从1.8版本开始，性能数据开始以Metrics API的方式提供标准化接口，并且从1.10版本开始将Heapster替换为Metrics Server。在Kubernetes新的监控体系中，Metrics Server用于提供核心指标（Core Metrics），包括Node、Pod的CPU和内存使用指标。

Metrics Server从Kubelets收集资源指标，并通过Metrics API将其暴露在Kubernetes apiserver中，以供Horizontal Pod Autoscaler和Vertical Pod Autoscaler使用。还可以通过kubectl top方式访问Metrics API。

对其他自定义指标（Custom Metrics）的监控则由Prometheus等组件来完成。

Metrics特点

Metrics Server主要特点:

在大多数集群上可以以单Pod工作；
快速自动伸缩，且每15秒收集一次指标；
资源消耗极低，在集群中每个节点上仅需1分片CPU和2 MB内存；
可扩展支持最多5000个节点集群。

Metrics需求

Metrics Server对集群和网络配置有特定的需求依赖，这些需求依赖并不是所有集群默认开启的。

在使用Metrics Server之前，需要确保集群支持这些需求：

kube-apiserver必须启用聚合层（aggregation layer）；
节点必须启用Webhook身份验证和授权；
Kubelet证书需要由集群证书颁发机构签名(或者通过向Metrics Server传递--kubelet-insecure-tls禁用证书验证)；
容器运行时必须实现容器度量rpc(或有cAdvisor支持)；
网络应支持以下通信:
- 控制平面到Metrics Server通信要求：控制平面节点需要到达Metrics Server的pod IP和端口10250(如果hostNetwork开启，则可以是自定义的node IP和对应的自定义端口，保持通信即可）；
- Metrics Server到所有节点的Kubelete通信要求：Metrics Server需要到达node节点地址和Kubelet端口。地址和端口在Kubelet中配置，并作为Node对象的一部分发布。.status.address和.status.daemonEndpoints.kubeletEndpoint.port定义地址和端口（默认10250）。Metrics Server将根据kubelet-preferred-address-types命令行标志提供的列表选择第一个节点地址（默认InternalIP，ExternalIP，Hostname）。

开启聚合层

有关聚合层知识参考：https://blog.csdn.net/liukuan73/article/details/81352637

kubeadm方式部署默认已开启。

获取部署文件

根据实际生产环境，对Metrics Server的部署进行个性化修改，其他保持默认即可。

主要涉及：部署副本数为3，追加--kubelet-insecure-tls配置。

[root@master01 ~]# mkdir metrics
[root@master01 ~]# cd metrics/
[root@master01 metrics]# wget https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

[root@master01 metrics]# vi components.yaml
……
apiVersion: apps/v1
kind: Deployment
……
spec:
  replicas: 3						                                                                    	#根据集群规模调整副本数
    ……
    spec:
      hostNetwork: true
      containers:
      - args:
        - --cert-dir=/tmp
        - --secure-port=4443                                                                                #修改端口
        - --kubelet-insecure-tls				                                                            #追加此args
        - --kubelet-preferred-address-types=InternalIP,ExternalIP,Hostname,InternalDNS,ExternalDNS          #追加此args
        - --kubelet-use-node-status-port
        - --metric-resolution=15s
        image: registry.k8s.io/metrics-server/metrics-server:v0.7.0
        imagePullPolicy: IfNotPresent
    ……
        ports:
        - containerPort: 4443                                                                               #修改端口
    ……

正式部署

[root@master01 metrics]# kubectl apply -f components.yaml
[root@master01 metrics]# kubectl -n kube-system get pods -l k8s-app=metrics-server -o wide
NAME                             READY   STATUS    RESTARTS   AGE    IP             NODE       NOMINATED NODE   READINESS GATES
metrics-server-59bc95bff-5x278   1/1     Running   0          164m   172.24.8.115   worker02   <none>           <none>
metrics-server-59bc95bff-8bzc2   1/1     Running   0          163m   172.24.8.114   worker01   <none>           <none>
metrics-server-59bc95bff-tvkmx   1/1     Running   0          163m   172.24.8.116   worker03   <none>           <none>

查看资源监控

可使用kubectl top查看相关监控项。

[root@master01 ~]# kubectl top nodes
[root@master01 ~]# kubectl top pods --all-namespaces

提示：Metrics Server提供的数据也可以供HPA控制器使用，以实现基于CPU使用率或内存使用值的Pod自动扩缩容功能。

部署参考：https://linux48.com/container/2019-11-13-metrics-server.html

开启开启API Aggregation参考：

https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/apiserver-aggregation/

API Aggregation介绍参考：

https://kubernetes.io/docs/tasks/access-kubernetes-api/configure-aggregation-layer/

Nginx ingress部署

Kubernetes中的应用通常以Service对外暴露，而Service的表现形式为IP:Port，即工作在TCP/IP层。

对于基于HTTP的服务来说，不同的URL地址经常对应到不同的后端服务（RS）或者虚拟服务器（Virtual Host），这些应用层的转发机制仅通过Kubernetes的Service机制是无法实现的。

从Kubernetes 1.1版本开始新增Ingress资源对象，用于将不同URL的访问请求转发到后端不同的Service，以实现HTTP层的业务路由机制。

Kubernetes使用了一个Ingress策略规则和一个具体的Ingress Controller，两者结合实现了一个完整的Ingress负载均衡器。

使用Ingress进行负载分发时，Ingress Controller基于Ingress策略规则将客户端请求直接转发到Service对应的后端Endpoint（Pod）上，从而跳过kube-proxy的转发功能，kube-proxy不再起作用。

简单的理解就是：ingress使用DaemonSet或Deployment在相应Node上监听80或443，然后配合相应规则，因为Nginx外面绑定了宿主机80端口（就像 NodePort），本身又在集群内，那么向后直接转发到相应ServiceIP即可实现相应需求。

ingress controller + ingress 策略规则 ----> services。

同时当Ingress Controller提供的是对外服务，则实际上实现的是边缘路由器的功能。

设置标签

建议对于非业务相关的应用，构建集群所需的应用（如Ingress），部署在master节点，从而复用master节点的高可用。

采用标签，结合部署的yaml中的tolerations，实现ingress部署在master节点的配置。

[root@master01 ~]# kubectl label nodes master0{1,2,3} ingress=enable

获取资源

获取部署所需的yaml资源。

[root@master01 ~]# mkdir ingress
[root@master01 ~]# cd ingress/
[root@master01 ingress]# wget https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.9.6/deploy/static/provider/baremetal/deploy.yaml

提示：ingress官方参考：https://github.com/kubernetes/ingress-nginx

https://kubernetes.github.io/ingress-nginx/deploy/

修改配置

为方便后续管理和排障，对相关Nginx ingress挂载时区，以便使Pod时间正确，从而相关记录日志能具有时效性。

同时对ingress做了简单配置，如日志格式等。

[root@master01 ingress]# vi deploy.yaml
    ……
---
apiVersion: v1
data:
  allow-snippet-annotations: "true"
  client-header-buffer-size: "512k"                                             #客户端请求头的缓冲区大小      
  large-client-header-buffers: "4 512k"                                         #设置用于读取大型客户端请求标头的最大值number和size缓冲区
  client-body-buffer-size: "128k"                                               #读取客户端请求body的缓冲区大小
  proxy-buffer-size: "256k"                                                     #代理缓冲区大小
  proxy-body-size: "50m"                                                        #代理body大小
  server-name-hash-bucket-size: "128"                                           #服务器名称哈希大小
  map-hash-bucket-size: "128"                                                   #map哈希大小
  ssl-ciphers: "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-R
SA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA
:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:AES:CAMELLIA:DES-CBC3-SHA:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!aECDH:!EDH-DSS-DES-CBC3-SHA:!EDH-RSA-DES-CBC3-SHA:!KRB5-DES-CBC3-SHA"        #SSL加密套件
  ssl-protocols: "TLSv1 TLSv1.1 TLSv1.2"                                        #ssl 协议
  log-format-upstream: '{"time": "$time_iso8601", "remote_addr": "$proxy_protocol_addr", "x-forward-for": "$proxy_add_x_forwarded_for", "request_id": "$req_id","remote_user": "$remote_user", "bytes_sent": $bytes_sent, "request_time": $request_time, "sta
tus":$status, "vhost": "$host", "request_proto": "$server_protocol", "path": "$uri", "request_query": "$args", "request_length": $request_length, "duration": $request_time,"method": "$request_method", "http_referrer": "$http_referer", "http_user_agent":
 "$http_user_agent" }'                                                          #日志格式
kind: ConfigMap
metadata:
  labels:
    app.kubernetes.io/component: controller
    app.kubernetes.io/instance: ingress-nginx
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx
    app.kubernetes.io/version: 1.9.6
  name: ingress-nginx-controller
  namespace: ingress-nginx
……
---
apiVersion: v1
kind: Service
metadata:
  labels:
    app.kubernetes.io/component: controller
    app.kubernetes.io/instance: ingress-nginx
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx
    app.kubernetes.io/version: 1.9.6
  name: ingress-nginx-controller
  namespace: ingress-nginx
spec:
  ipFamilies:
  - IPv4
  ipFamilyPolicy: SingleStack
  ports:
  - appProtocol: http
    name: http
    port: 80
    protocol: TCP 
    targetPort: http
    nodePort: 80                                                    #追加此行
  - appProtocol: https
    name: https
    port: 443
    protocol: TCP 
    targetPort: https
    nodePort: 443                                                   #追加此行
  selector:
    app.kubernetes.io/component: controller
    app.kubernetes.io/instance: ingress-nginx
    app.kubernetes.io/name: ingress-nginx
  type: NodePort
  externalTrafficPolicy: Local                                      #追加此行
……
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app.kubernetes.io/component: controller
    app.kubernetes.io/instance: ingress-nginx
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx
    app.kubernetes.io/version: 1.9.6
  name: ingress-nginx-controller
  namespace: ingress-nginx
spec:
  replicas: 3                                                       #配置副本数
……
    spec:
      containers:
      - args:
        - /nginx-ingress-controller
……
        image: registry.k8s.io/ingress-nginx/controller:v1.9.6      #修改image镜像
……
        volumeMounts:
……
        - mountPath: /etc/localtime                                 #挂载localtime
          name: timeconfig
          readOnly: true
      dnsPolicy: ClusterFirst
      nodeSelector:
        kubernetes.io/os: linux
        ingress: enable
      tolerations:
        - key: node-role.kubernetes.io/control-plane
          effect: NoSchedule                                        #追加nodeSelector和tolerations
……
      volumes:
      - name: webhook-cert
        secret:
          secretName: ingress-nginx-admission
      - name: timeconfig                                            #将hostpath配置为挂载卷
        hostPath:
          path: /etc/localtime
……
        image: registry.k8s.io/ingress-nginx/kube-webhook-certgen:v20231226-1a7112e06      #修改image镜像
……
        image: registry.k8s.io/ingress-nginx/kube-webhook-certgen:v20231226-1a7112e06      #修改image镜像
……

[root@master01 ingress]# kubectl apply -f deploy.yaml

提示：添加默认backend需要等待default-backend创建完成controllers才能成功部署，新版本ingress不再推荐添加default backend。

确认验证

查看Pod部署进度，是否成功完成。

[root@master01 ingress]# kubectl get pods -n ingress-nginx -o wide
[root@master01 ingress]# kubectl get svc -n ingress-nginx -o wide

提示：参考文档：https://github.com/kubernetes/ingress-nginx/blob/master/docs/deploy/index.md。

Dashboard部署

dashboard是基于Web的Kubernetes用户界面，即WebUI。

可以使用dashboard将容器化应用程序部署到Kubernetes集群，对容器化应用程序进行故障排除，以及管理集群资源。

可以使用dashboard来查看群集上运行的应用程序，以及创建或修改单个Kubernetes资源（例如部署、任务、守护进程等）。

可以使用部署向导扩展部署，启动滚动更新，重新启动Pod或部署新应用程序。

dashboard还提供有关群集中Kubernetes资源状态以及可能发生的任何错误的信息。

通常生产环境中建议部署dashboard，以便于图形化来完成基础运维。

设置标签

基于最佳实践，非业务应用，或集群自身的应用都部署在Master节点。

[root@master01 ~]# kubectl label nodes master0{1,2,3} dashboard=enable

提示：建议对于Kubernetes自身相关的应用（如dashboard），此类非业务应用部署在master节点。

部署cert-manager

cert-manager 部署到 Kubernetes 集群后，它会 watch 它所支持的 CRD 资源，我们通过创建 CRD 资源来指示 cert-manager 为我们签发证书并自动续期。

关键术语：

Issuer/ClusterIssuer: 用于指示 cert-manager 用什么方式签发证书，本文主要讲解签发免费证书的 ACME 方式。ClusterIssuer 与 Issuer 的唯一区别就是 Issuer 只能用来签发自己所在 namespace 下的证书，ClusterIssuer 可以签发任意 namespace 下的证书。

Certificate: 用于告诉 cert-manager 我们想要什么域名的证书以及签发证书所需要的一些配置，包括对 Issuer/ClusterIssuer 的引用。

对于最新dashboard中，其中yaml文件已自动引入该组件，因此建议提前部署该组件。

[root@master01 ~]# kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.14.3/cert-manager.yaml

提示：更多cert-manager参考cert-manager，cert-manager安装。

创建证书

默认dashboard会自动创建证书，同时使用对应证书创建secret。生产环境可以启用相应的域名进行部署dashboard，因此需要将对于的域名制作为TLS证书。

本实验已获取免费一年的证书，免费证书获取可参考：https://freessl.cn.

将已获取的证书上传至对应目录。

[root@master01 ~]# mkdir -p /root/dashboard/certs
[root@master01 ~]# cd /root/dashboard/certs
[root@master01 certs]# mv webui.linuxsb.com.crt tls.crt
[root@master01 certs]# mv webui.linuxsb.com.key tls.key
[root@master01 certs]# ll
total 12K
-rw-r--r-- 1 root root 4.1K Feb 28 10:47 tls.crt
-rw-r--r-- 1 root root 1.7K Feb 28 10:47 tls.key

提示：也可手动如下操作创建自签证书：

[root@master01 ~]# openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout tls.key -out tls.crt -subj "/C=CN/ST=ZheJiang/L=HangZhou/O=Xianghy/OU=Xianghy/CN=webui.linuxsb.com"

手动创建secret

自定义证书的场景，建议提前使用对应的证书创建secret。

[root@master01 ~]# kubectl create ns kubernetes-dashboard	                                        #v3版本dashboard独立ns
[root@master01 ~]# kubectl create secret generic kubernetes-dashboard-certs --from-file=/root/dashboard/certs/ -n kubernetes-dashboard
[root@master01 ~]# kubectl get secret kubernetes-dashboard-certs -n kubernetes-dashboard -o yaml	#查看证书信息

下载yaml

从官方下载最新的dashboard部署所需yaml。

[root@master01 ~]# cd /root/dashboard
[root@master01 dashboard]# wget https://raw.githubusercontent.com/kubernetes/dashboard/v3.0.0-alpha0/charts/kubernetes-dashboard.yaml

提示：官方参考：https://github.com/kubernetes/dashboard 。

修改yaml

根据实际生产环境修改yaml，同时最新版dashboard yaml里包括了ingress，因此不需要额外创建ingress，仅需做简单修改即可。

[root@master01 dashboard]# vi kubernetes-dashboard.yaml
……
kind: Ingress
apiVersion: networking.k8s.io/v1
metadata:
  name: kubernetes-dashboard
  namespace: kubernetes-dashboard
  labels:
    app.kubernetes.io/name: nginx-ingress
    app.kubernetes.io/part-of: kubernetes-dashboard
  annotations:
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
    cert-manager.io/issuer: selfsigned
spec:
  ingressClassName: nginx
  tls:
    - hosts:
        - webui.linuxsb.com
      secretName: kubernetes-dashboard-certs
  rules:
    - host: webui.linuxsb.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: kubernetes-dashboard-web
                port:
                  name: web
          - path: /api
            pathType: Prefix
            backend:
              service:
                name: kubernetes-dashboard-api
                port:
                  name: api
……
kind: Deployment
apiVersion: apps/v1
metadata:
  name: kubernetes-dashboard-api
  namespace: kubernetes-dashboard
  labels:
    app.kubernetes.io/name: kubernetes-dashboard-api
    app.kubernetes.io/part-of: kubernetes-dashboard
    app.kubernetes.io/component: api
    app.kubernetes.io/version: "v1.0.0"
spec:
  replicas: 3					                            #根据实际环境调整为3副本
……
      nodeSelector:
        "kubernetes.io/os": linux
        "dashboard": enable	        		                #部署在带有dashboard tag的节点，即master节点
      tolerations:                                          #Kubernetes的主节点标记从master改为control-plane
        - key: node-role.kubernetes.io/control-plane
          effect: NoSchedule
……
kind: Deployment
apiVersion: apps/v1
metadata:
  name: kubernetes-dashboard-web
  namespace: kubernetes-dashboard
  labels:
    app.kubernetes.io/name: kubernetes-dashboard-web
    app.kubernetes.io/part-of: kubernetes-dashboard
    app.kubernetes.io/component: web
    app.kubernetes.io/version: "v1.0.0"
spec:
  replicas: 3
……
      nodeSelector:
        "kubernetes.io/os": linux
        "dashboard": enable	        		                #部署在带有dashboard tag的节点，即master节点
      tolerations:                                          #Kubernetes的主节点标记从master改为control-plane
        - key: node-role.kubernetes.io/control-plane
          effect: NoSchedule
……
kind: Deployment
apiVersion: apps/v1
metadata:
  name: kubernetes-dashboard-metrics-scraper
  namespace: kubernetes-dashboard
  labels:
    app.kubernetes.io/name: kubernetes-dashboard-metrics-scraper
    app.kubernetes.io/part-of: kubernetes-dashboard
    app.kubernetes.io/component: metrics
    app.kubernetes.io/version: "v1.0.9"
spec:
  replicas: 1
……
      nodeSelector:
        "kubernetes.io/os": linux
        "dashboard": enable	        		                #部署在带有dashboard tag的节点，即master节点
      tolerations:                                          #Kubernetes的主节点标记从master改为control-plane
        - key: node-role.kubernetes.io/control-plane
          effect: NoSchedule
……

正式部署

根据生产环境最佳实践进行调优，调优完成后开始部署。

[root@master01 dashboard]# kubectl apply -f kubernetes-dashboard.yaml
[root@master01 dashboard]# kubectl -n kubernetes-dashboard get deployments.apps
[root@master01 dashboard]# kubectl -n kubernetes-dashboard get services
[root@master01 dashboard]# kubectl -n kubernetes-dashboard get pods -o wide
[root@master01 dashboard]# kubectl -n kubernetes-dashboard get svc
[root@master01 dashboard]# kubectl -n kubernetes-dashboard describe svc kubernetes-dashboard
[root@master01 dashboard]# kubectl -n kubernetes-dashboard get ingress -o wide

提示：master NodePort 30001/TCP映射到 dashboard pod 443 端口。

创建管理员账户

建议创建管理员账户，dashboard v2版本默认没有创建具有管理员权限的账户，同时登录可以选择kubeconfig以及token，通常使用kubeconfig比较方便。

在创建管理员用户后，将用户相关信息配置成kubeconfig文件，即可实现快速登录dashboard。

[root@master01 dashboard]# cat <<EOF > dashboard-admin.yaml
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: admin
  namespace: kubernetes-dashboard

---
apiVersion: v1
kind: Secret
type: kubernetes.io/service-account-token
metadata:
  name: admin
  namespace: kubernetes-dashboard
  annotations:
    kubernetes.io/service-account.name: "admin"

---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: admin
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
- kind: ServiceAccount
  name: admin
  namespace: kubernetes-dashboard
EOF

[root@master01 dashboard]# kubectl apply -f dashboard-admin.yaml

创建kubeconfig文件

使用token相对复杂，可将token添加至kubeconfig文件中，使用KubeConfig文件访问dashboard。

[root@master01 dashboard]# ADMIN_SECRET=$(kubectl -n kubernetes-dashboard get secret | grep admin | awk '{print $1}')
[root@master01 dashboard]# DASHBOARD_LOGIN_TOKEN=$(kubectl describe secret -n kubernetes-dashboard ${ADMIN_SECRET} | grep -E '^token' | awk '{print $2}')
[root@master01 dashboard]# kubectl config set-cluster kubernetes \
--certificate-authority=/etc/kubernetes/pki/ca.crt \
--embed-certs=true \
--server=172.24.8.100:16443 \
--kubeconfig=local-khk8s-1-29-admin.kubeconfig                                 # 设置集群参数
[root@master01 dashboard]# kubectl config set-credentials dashboard_user \
--token=${DASHBOARD_LOGIN_TOKEN} \
--kubeconfig=local-khk8s-1-29-admin.kubeconfig                                 # 设置客户端认证参数，使用上面创建的 Token
[root@master01 dashboard]# kubectl config set-context default \
--cluster=kubernetes \
--user=dashboard_user \
--kubeconfig=local-khk8s-1-29-admin.kubeconfig                                 # 设置上下文参数
[root@master01 dashboard]# kubectl config use-context default --kubeconfig=local-khk8s-1-29-admin.kubeconfig         # 设置默认上下文

将webui.linuxsb.com.crt证书文件导入，以便于浏览器使用该文件登录。

导入证书

将webui.linuxsb.com.crt证书导入浏览器，并设置为信任，可规避证书不受信任的弹出。

测试访问dashboard

本实验采用ingress所暴露的域名：https://webui.linuxsb.com 方式一：token访问可使用kubectl describe secret -n kubernetes-dashboard {ADMIN_SECRET} | grep -E '^token' | awk '{print 2}'所获取的token访问。

方式二：kubeconfig访问

local-khk8s-1-29-admin.kubeconfig文件访问。

提示：更多dashboard访问方式及认证可参考附004.Kubernetes Dashboard简介及使用。

dashboard登录整个流程可参考：https://www.cnadn.net/post/2613.html

Longhorn存储部署

Longhorn概述

Longhorn是用于Kubernetes的开源分布式块存储系统。

当前Kubernetes 1.29.2版本建议使用Longhorn 1.6.0 。

提示：更多介绍参考：https://github.com/longhorn/longhorn 。

基础软件安装

后续业务应用可能运行在任意节点位置，挂载操作需要在任何节点可正常执行。

所有节点均需要安装基础以来软件。

[root@master01 ~]# source environment.sh
[root@master01 ~]# for all_ip in ${ALL_IPS[@]}
  do
    echo ">>> ${all_ip}"
    ssh root@${all_ip} "yum -y install iscsi-initiator-utils &"
    ssh root@${all_ip} "systemctl enable iscsid --now"
  done

提示：所有节点都需要安装。

设置标签

在Master节点上部署存储组件的图形界面。

[root@master01 ~]# kubectl label nodes master0{1,2,3} longhorn-ui=enabled

提示：ui图形界面可复用master高可用，因此部署在master节点。

准备磁盘

Longhorn的分布式存储，建议独立磁盘设备专门作为存储卷，可提前挂载。

longhorn默认使用/var/lib/longhorn/作为设备路径，可提前挂载/dev/nvme0n2设备。

不同环境下裸磁盘的设备名不一样，根据实际环境为准。

[root@master01 ~]# source environment.sh

[root@master01 ~]# for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "mkfs.xfs -f /dev/nvme0n2 && mkdir -p /var/lib/longhorn/ && echo '/dev/nvme0n2        /var/lib/longhorn        xfs        defaults        0 0' >> /etc/fstab && mount -a"
  done

配置Longhorn

根据实际生产环境，对Longhorn进行优化配置。

[root@master01 ~]# mkdir longhorn
[root@master01 ~]# cd longhorn/
[root@master01 longhorn]# wget https://raw.githubusercontent.com/longhorn/longhorn/v1.6.0/deploy/longhorn.yaml

[root@master01 longhorn]# vi longhorn.yaml
……
---
# Source: longhorn/templates/deployment-ui.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app.kubernetes.io/name: longhorn
    app.kubernetes.io/instance: longhorn
    app.kubernetes.io/version: v1.6.0
    app: longhorn-ui
  name: longhorn-ui
  namespace: longhorn-system
spec:
  replicas: 2
  selector:
    matchLabels:
      app: longhorn-ui
  template:
    metadata:
      labels:
        app.kubernetes.io/name: longhorn
        app.kubernetes.io/instance: longhorn
        app.kubernetes.io/version: v1.6.0
        app: longhorn-ui
    spec:
      serviceAccountName: longhorn-ui-service-account
      affinity:
        podAntiAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            podAffinityTerm:
              labelSelector:
                matchExpressions:
                - key: app
                  operator: In
                  values:
                  - longhorn-ui
              topologyKey: kubernetes.io/hostname
      containers:
      - name: longhorn-ui
        image: longhornio/longhorn-ui:v1.6.0
……
      nodeSelector:
        longhorn-ui: enabled                                #追加标签选择
      tolerations:
        - key: node-role.kubernetes.io/control-plane        #添加容忍
          effect: NoSchedule
……

正式部署

基于优化的yaml进行部署。

[root@master01 ~]# cd  longhorn/
[root@master01 longhorn]# kubectl apply -f longhorn.yaml
[root@master01 longhorn]# kubectl -n longhorn-system get pods -o wide
NAME                                                READY   STATUS    RESTARTS        AGE     IP             NODE       NOMINATED NODE   READINESS GATES
csi-attacher-57689cc84b-55vw6                       1/1     Running   0               104s    10.10.19.82    worker03   <none>           <none>
csi-attacher-57689cc84b-gxm62                       1/1     Running   0               105s    10.10.30.82    worker02   <none>           <none>
csi-attacher-57689cc84b-jtqdw                       1/1     Running   0               104s    10.10.5.17     worker01   <none>           <none>
csi-provisioner-6c78dcb664-cswfz                    1/1     Running   0               104s    10.10.19.83    worker03   <none>           <none>
csi-provisioner-6c78dcb664-kdnhc                    1/1     Running   0               104s    10.10.5.18     worker01   <none>           <none>
csi-provisioner-6c78dcb664-vqs4z                    1/1     Running   0               104s    10.10.30.81    worker02   <none>           <none>
csi-resizer-7466f7b45f-8lbhp                        1/1     Running   0               104s    10.10.5.21     worker01   <none>           <none>
csi-resizer-7466f7b45f-9g7rw                        1/1     Running   0               104s    10.10.30.83    worker02   <none>           <none>
csi-resizer-7466f7b45f-xzsgs                        1/1     Running   0               104s    10.10.19.81    worker03   <none>           <none>
csi-snapshotter-58bf69fbd5-5b59k                    1/1     Running   0               104s    10.10.19.85    worker03   <none>           <none>
csi-snapshotter-58bf69fbd5-7q25t                    1/1     Running   0               104s    10.10.30.85    worker02   <none>           <none>
csi-snapshotter-58bf69fbd5-rprpq                    1/1     Running   0               104s    10.10.5.19     worker01   <none>           <none>
engine-image-ei-acb7590c-9b8wf                      1/1     Running   0               116s    10.10.30.79    worker02   <none>           <none>
engine-image-ei-acb7590c-bbcw9                      1/1     Running   0               116s    10.10.19.79    worker03   <none>           <none>
engine-image-ei-acb7590c-d4qlp                      1/1     Running   0               116s    10.10.5.15     worker01   <none>           <none>
instance-manager-0cf302d46e3eaf0be2c65de14febecb3   1/1     Running   0               110s    10.10.30.80    worker02   <none>           <none>
instance-manager-652604acb4423fc91cae625c664b813b   1/1     Running   0               2m21s   10.10.5.14     worker01   <none>           <none>
instance-manager-6e47bda67fc7278dee5cbb280e6a8fde   1/1     Running   0               110s    10.10.19.80    worker03   <none>           <none>
longhorn-csi-plugin-j92qz                           3/3     Running   0               104s    10.10.19.84    worker03   <none>           <none>
longhorn-csi-plugin-lsqzb                           3/3     Running   0               104s    10.10.5.20     worker01   <none>           <none>
longhorn-csi-plugin-nv7vk                           3/3     Running   0               104s    10.10.30.84    worker02   <none>           <none>
longhorn-driver-deployer-576d574c8-vw8hq            1/1     Running   0               4m53s   10.10.30.78    worker02   <none>           <none>
longhorn-manager-2vfpz                              1/1     Running   3 (2m16s ago)   4m53s   10.10.30.77    worker02   <none>           <none>
longhorn-manager-4d5w9                              1/1     Running   2 (2m19s ago)   4m53s   10.10.5.13     worker01   <none>           <none>
longhorn-manager-r55wx                              1/1     Running   3 (4m26s ago)   4m53s   10.10.19.78    worker03   <none>           <none>
longhorn-ui-7cfd57b47d-brh89                        1/1     Running   0               4m53s   10.10.59.198   master02   <none>           <none>
longhorn-ui-7cfd57b47d-qndks                        1/1     Running   0               4m53s   10.10.235.8    master03   <none>           <none>

提示：若部署异常可删除重建，若出现无法删除namespace，可通过如下操作进行删除：

wget https://raw.githubusercontent.com/longhorn/longhorn/v1.6.0/uninstall/uninstall.yaml
kubectl apply -f uninstall.yaml

kubectl get job/longhorn-uninstall -n longhorn-system -w

kubectl delete -f uninstall.yaml                                #等待任务完成再次执行delete

rm -rf /var/lib/longhorn/*

若依旧无法释放，参考《附098.Kubernetes故障排查记录》。

动态sc创建

部署Longhorn后，默认已创建一个名为longhorn的sc。

[root@master01 longhorn]# kubectl get sc
NAME                 PROVISIONER          RECLAIMPOLICY   VOLUMEBINDINGMODE   ALLOWVOLUMEEXPANSION   AGE
longhorn (default)   driver.longhorn.io   Delete          Immediate           true                   5m53s

测试PV及PVC

使用常见的Nginx Pod进行测试，模拟生产环境常见的Web类应用的持久性存储卷。

[root@master01 longhorn]# cat <<EOF > longhornpvc.yaml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: longhorn-pvc
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: longhorn
  resources:
    requests:
      storage: 50Mi
EOF                                                                                 #创建PVC

[root@master01 longhorn]# cat <<EOF > longhornpod.yaml
---
apiVersion: v1
kind: Pod
metadata:
  name: longhorn-pod
  namespace: default
spec:
  containers:
  - name: volume-test
    image: nginx:stable-alpine
    imagePullPolicy: IfNotPresent
    volumeMounts:
    - name: volv
      mountPath: /usr/share/nginx/html
    ports:
    - containerPort: 80
  volumes:
  - name: volv
    persistentVolumeClaim:
      claimName: longhorn-pvc
EOF                                                                                 #创建Pod

[root@master01 longhorn]# kubectl apply -f longhornpvc.yaml

[root@master01 longhorn]# kubectl apply -f longhornpod.yaml

[root@master01 longhorn]# kubectl get pods
[root@master01 longhorn]# kubectl get pvc
[root@master01 longhorn]# kubectl get pv

Ingress暴露Longhorn

使用已部署完成的ingress将Longhorn UI暴露，以便于使用URL形式访问Longhorn图形界面进行Longhorn的基础管理。

[root@master01 longhorn]# yum -y install httpd-tools
[root@master01 longhorn]# htpasswd -c auth admin                                    #创建用户名和密码
New password: [输入密码]
Re-type new password: [输入密码]

提示：也可通过如下命令创建： USER=admin; PASSWORD=admin1234; echo "

[root@master01 longhorn]# kubectl -n longhorn-system create secret generic longhorn-basic-auth --from-file=auth
[root@master01 longhorn]# cat <<EOF > longhorn-ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: longhorn-ingress
  namespace: longhorn-system
  annotations:
    nginx.ingress.kubernetes.io/auth-type: basic
    nginx.ingress.kubernetes.io/auth-secret: longhorn-basic-auth
    nginx.ingress.kubernetes.io/auth-realm: 'Authentication Required '
spec:
  ingressClassName: "nginx"
  rules:
  - host: longhorn.linuxsb.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: longhorn-frontend
            port: 
              number: 80
EOF

[root@master01 longhorn]# kubectl apply -f longhorn-ingress.yaml
[root@master01 longhorn]# kubectl -n longhorn-system get svc longhorn-frontend
[root@master01 longhorn]# kubectl -n longhorn-system get ingress longhorn-ingress
[root@master01 longhorn]# kubectl -n longhorn-system describe svc longhorn-frontend
[root@master01 longhorn]# kubectl -n longhorn-system describe ingress longhorn-ingress

确认验证

浏览器访问：longhorn.linuxsb.com ，并输入设置的账号和密码。

使用admin/密码登录查看。

Helm部署

helm介绍

Helm 是 Kubernetes 的软件包管理工具。包管理器类似 Ubuntu 中使用的apt、Centos中使用的yum 或者Python中的 pip 一样，能快速查找、下载和安装软件包。通常每个包称为一个Chart，一个Chart是一个目录（一般情况下会将目录进行打包压缩，形成name-version.tgz格式的单一文件，方便传输和存储）。

Helm 由客户端组件 helm 和服务端组件 Tiller 组成, 能够将一组K8S资源打包统一管理, 是查找、共享和使用为Kubernetes构建的软件的最佳方式。

Helm优势

在 Kubernetes中部署一个可以使用的应用，需要涉及到很多的 Kubernetes 资源的共同协作。

如安装一个 WordPress 博客，用到了一些 Kubernetes 的一些资源对象。包括 Deployment 用于部署应用、Service 提供服务发现、Secret 配置 WordPress 的用户名和密码，可能还需要 pv 和 pvc 来提供持久化服务。并且 WordPress 数据是存储在mariadb里面的，所以需要 mariadb 启动就绪后才能启动 WordPress。这些 k8s 资源过于分散，不方便进行管理。

基于如上场景，在 k8s 中部署一个应用，通常面临以下几个问题：

如何统一管理、配置和更新这些分散的 k8s 的应用资源文件；

如何分发和复用一套应用模板；

如何将应用的一系列资源当做一个软件包管理。

对于应用发布者而言，可以通过 Helm 打包应用、管理应用依赖关系、管理应用版本并发布应用到软件仓库。

对于使用者而言，使用 Helm 后不用需要编写复杂的应用部署文件，可以以简单的方式在 Kubernetes 上查找、安装、升级、回滚、卸载应用程序。

前置准备

Helm 将使用 kubectl 在已配置的集群上部署 Kubernetes 资源，因此需要如下前置准备：

正在运行的 Kubernetes 集群；
预配置的 kubectl 客户端和 Kubernetes 集群正确交互。

二进制安装Helm

建议采用二进制安装helm。

[root@master01 ~]# mkdir helm
[root@master01 ~]# cd helm/
[root@master01 helm]# wget https://repo.huaweicloud.com/helm/v3.14.2/helm-v3.14.2-linux-amd64.tar.gz
[root@master01 helm]# tar -zxvf helm-v3.14.2-linux-amd64.tar.gz
[root@master01 helm]# cp linux-amd64/helm /usr/local/bin/
[root@master01 helm]]# helm version		#查看安装版本
[root@master01 helm]]# echo 'source <(helm completion bash)' >> $HOME/.bashrc           #helm自动补全

提示：更多安装方式参考官方手册：https://helm.sh/docs/intro/install/ 。

Helm操作

查找chart

helm search：可以用于搜索两种不同类型的源。

helm search hub：搜索 Helm Hub，该源包含来自许多不同仓库的Helm chart。

helm search repo：搜索已添加到本地头helm客户端（带有helm repo add）的仓库，该搜索是通过本地数据完成的，不需要连接公网。

[root@master01 ~]# helm search hub			                    #可搜索全部可用chart
[root@master01 ~]# helm search hub wordpress

添加repo

类似CentOS添加yum源，可以给helm仓库添加相关源。

[root@master01 ~]# helm repo list			                    #查看repo
[root@master01 ~]# helm repo add stable http://mirror.azure.cn/kubernetes/charts
[root@master01 ~]# helm repo add aliyun https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts
[root@master01 ~]# helm repo add jetstack https://charts.jetstack.io

[root@master01 ~]# helm search repo stable
[root@master01 ~]# helm search repo aliyun		                #搜索repo中的chart
[root@master01 ~]# helm repo update			                    #更新repo的chart

扩展：集群扩容及缩容

集群扩容

master节点扩容参考：添加Master节点步骤
worker节点扩容参考：添加Worker节点步骤

集群缩容

master节点缩容 Master节点缩容的时候会自动将Pod迁移至其他节点。

[root@master01 ~]# kubectl drain master03 --delete-emptydir-data --force --ignore-daemonsets
[root@master01 ~]# kubectl delete node master03
[root@master03 ~]# kubeadm reset -f && rm -rf $HOME/.kube

worker节点缩容 Worker节点缩容的时候会自动将Pod迁移至其他节点。

[root@master01 ~]# kubectl drain worker04 --delete-emptydir-data --force --ignore-daemonsets
[root@master01 ~]# kubectl delete node worker04
[root@worker04 ~]# kubeadm reset -f
[root@worker04 ~]# rm -rf /etc/kubernetes/admin.conf /etc/kubernetes/kubelet.conf /etc/kubernetes/bootstrap-kubelet.conf /etc/kubernetes/controller-manager.conf /etc/kubernetes/scheduler.conf

本文参与腾讯云自媒体分享计划，分享自作者个人站点/博客。

原始发表：2024-03-10，如有侵权请联系 cloudcommunity@tencent.com 删除

架构

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体分享计划，欢迎热爱写作的你一起参与！