登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›附035.Kubernetes_v1.25.3高可用部署架构二

附035.Kubernetes_v1.25.3高可用部署架构二

金娅鸣 2025-6-4 21:45:42
目录

  • 部署组件

    • kubeadm介绍
    • kubelet介绍
    • kubectl介绍

  • 方案概述

    • 方案介绍
    • 部署规划

      • 节点规划

    • 主机名配置
    • 变量准备
    • 互信配置
    • 环境初始化

  • 部署高可用组件

    • HAProxy安装
    • KeepAlived安装
    • 创建配置文件
    • 启动服务

  • 集群部署

    • 相关组件包
    • 正式安装

  • 集群初始化

    • 拉取镜像
    • Master01上初始化
    • 添加Master节点

  • 安装NIC插件

    • NIC插件介绍
    • 部署calico
    • 修改node端口范围

  • 添加Worker节点

    • 添加Worker节点
    • 确认验证

  • Metrics部署

    • Metrics介绍
    • Metrics特点
    • Metrics需求
    • 开启聚合层
    • 获取部署文件
    • 正式部署
    • 查看资源监控

  • Nginx ingress部署

    • 设置标签
    • 获取资源
    • 修改配置
    • 确认验证

  • Dashboard部署

    • 设置标签
    • 创建证书
    • 手动创建secret
    • 下载yaml
    • 修改yaml
    • 正式部署
    • 创建管理员账户
    • 创建kubeconfig文件
    • 导入证书

  • ingress暴露dashboard

    • 创建ingress tls
    • 创建ingress策略
    • 测试访问dashboard

  • Longhorn存储部署

    • Longhorn概述
    • 基础软件安装
    • 设置标签
    • 准备磁盘
    • 配置Longhorn
    • 正式部署
    • 动态sc创建
    • 测试PV及PVC
    • Ingress暴露Longhorn
    • 确认验证

  • Helm部署

    • helm介绍
    • Helm优势
    • 前置准备
    • 二进制安装Helm
    • Helm操作
    • 查找chart
    • 添加repo

  • 扩展：集群扩容及缩容

    • 集群扩容
    • 集群缩容


部署组件

该 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 特性。
kubelet介绍

kubelet 是 Kubernetes 集群中用于操作 Docker 、containerd 等容器运行时的核心组件，需要在每个节点运行。通常该操作是基于 CRI 实现，kubelet 和 CRI 交互，以便于实现对 Kubernetes 的管控。
kubelet 主要用于配置容器网络、管理容器数据卷等容器全生命周期，对于 kubelet 而言，其主要的功能核心有：

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

kubectl 控制 Kubernetes 集群管理器，是作为 Kubernetes 的命令行工具，用于与 apiserver 进行通信，使用 kubectl 工具在 Kubernetes 上部署和管理应用程序。
使用 kubectl，可以检查群集资源的创建、删除和更新组件。
同时集成了大量子命令，可更便捷的管理 Kubernetes 集群，主要命令如下：

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

方案介绍

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

  • 本方案采用 kubeadm 部署 Kubernetes 1.25.3 版本；
  • 基于国产化需求出发，底层操作系统为 Anolis 8.3 64；
  • etcd采用融合方式；
  • KeepAlived：用于实现 apiserver 的高可用；
  • HAProxy：以系统 systemd 服务形式运行，提供反向代理至3个 master 6443 端口；
  • 其他主要部署组件包括：

    • Metrics：度量组件，用于提供相关监控指标；
    • Dashboard：Kubernetes 集群的前端图形界面；
    • Helm：Kubernetes Helm 包管理器工具，用于后续使用 helm 整合包快速部署应用；
    • Ingress：Kubernetes 服务暴露应用，用于提供7层的负载均衡，类似 Nginx，可建立外部和内部的多个映射规则；
    • containerd：Kubernetes底层容器时；
    • Longhorn：Kubernetes 动态存储组件，用于提供 Kubernetes 的持久存储。

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

节点规划

节点主机名IP类型运行服务master01172.24.8.151Kubernetes master节点kubeadm、kubelet、kubectl、KeepAlived、HAProxy、containerd、etcd、kube-apiserver、kube-scheduler、kube-controller-manager、calico、WebUI、metrics、ingress、Longhorn存储节点master02172.24.8.152Kubernetes master节点kubeadm、kubelet、kubectl、KeepAlived、HAProxy、containerd、etcd、kube-apiserver、kube-scheduler、kube-controller-manager、calico、WebUI、metrics、ingress、Longhorn存储节点master03172.24.8.153Kubernetes master节点kubeadm、kubelet、kubectl、KeepAlived、HAProxy、containerd、etcd、kube-apiserver、kube-scheduler、kube-controller-manager、calico、WebUI、metrics、ingress、Longhorn存储节点worker01172.24.8.154Kubernetes worker节点kubelet、containerd、calico、Longhorn存储节点worker02172.24.8.155Kubernetes worker节点kubelet、containerd、calico、Longhorn存储节点worker03172.24.8.156Kubernetes worker节点kubelet、containerd、calico、Longhorn存储节点worker04172.24.8.157Kubernetes worker节点kubelet、containerd、calico、Longhorn存储节点Kubernetes集群高可用主要指的是控制平面的高可用，多个Master节点组件（通常为奇数）和Etcd组件的高可用，worker节点通过前端负载均衡VIP连接到Master。
1.png

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

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

需要对所有节点主机名进行相应配置。
  1. [root@localhost ~]# hostnamectl set-hostname master01            #其他节点依次修改
复制代码
生产环境通常建议在内网部署dns服务器，使用dns服务器进行解析，本指南采用本地hosts文件名进行解析。
如下hosts文件修改仅需在master01执行，后续使用批量分发至其他所有节点。
  1. [root@master01 ~]# cat >> /etc/hosts << EOF
  2. 172.24.8.151 master01
  3. 172.24.8.152 master02
  4. 172.24.8.153 master03
  5. 172.24.8.154 worker01
  6. 172.24.8.155 worker02
  7. 172.24.8.156 worker03
  8. EOF
复制代码
[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/目录
  1. [root@master01 ~]# vi environment.sh            #确认相关主机名和IP
  2. #!/bin/sh
  3. #****************************************************************#
  4. # ScriptName: environment.sh
  5. # Author: xhy
  6. # Create Date: 2022-10-11 17:10
  7. # Modify Author: xhy
  8. # Modify Date: 2022-11-12 22:22
  9. # Version: v1
  10. #***************************************************************#
  12. # 集群 MASTER 机器 IP 数组
  13. export MASTER_IPS=(172.24.8.151 172.24.8.152 172.24.8.153)
  15. # 集群 MASTER IP 对应的主机名数组
  16. export MASTER_NAMES=(master01 master02 master03)
  18. # 集群 NODE 机器 IP 数组
  19. export NODE_IPS=(172.24.8.154 172.24.8.155 172.24.8.156)
  21. # 集群 NODE IP 对应的主机名数组
  22. export NODE_NAMES=(worker01 worker02 worker03)
  24. # 集群所有机器 IP 数组
  25. export ALL_IPS=(172.24.8.151 172.24.8.152 172.24.8.153 172.24.8.154 172.24.8.155 172.24.8.156)
  27. # 集群所有IP 对应的主机名数组
  28. export ALL_NAMES=(master01 master02 master03 worker01 worker02 worker03)
复制代码
提示：如上仅需Master01节点操作，更多config文件参考：kubeadm 配置 (v1beta3)
默认kubeadm配置可使用kubeadm config print init-defaults > config.yaml生成。
启动服务

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

  • 检查服务配置
  1. [root@master01 ~]# source environment.sh                                #载入变量
  2.    
  3. [root@master01 ~]# ssh-keygen -f ~/.ssh/id_rsa -N ''
  4. [root@master01 ~]# for all_ip in ${ALL_IPS[@]}
  5.   do
  6.     echo ">>> ${all_ip}"
  7.     ssh-copy-id -i ~/.ssh/id_rsa.pub root@${all_ip}
  8.   done
复制代码

  • 启动高可用服务
  1. [root@master01 ~]# vim k8sconinit.sh
  2. #!/bin/sh
  3. #****************************************************************#
  4. # ScriptName: k8sconinit.sh
  5. # Author: xhy
  6. # Create Date: 2020-05-30 16:30
  7. # Modify Author: xhy
  8. # Modify Date: 2022-11-12 21:30
  9. # Version: v1
  10. #***************************************************************#
  11. # Initialize the machine. This needs to be executed on every machine.
  12. rm -f /var/lib/rpm/__db.00*
  13. rpm -vv --rebuilddb
  14. #yum clean all
  15. #yum makecache
  16. sleep 3s
  17. # Install containerd
  18. CONVERSION=1.4.9
  19. yum -y install yum-utils device-mapper-persistent-data lvm2
  20. yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
  21. sudo sed -i 's+download.docker.com+mirrors.aliyun.com/docker-ce+' /etc/yum.repos.d/docker-ce.repo
  22. sleep 3s
  23. yum -y install containerd.io-${CONVERSION}
  24. mkdir /etc/containerd
  26. cat > /etc/containerd/config.toml <<EOF
  27. disabled_plugins = ["restart"]
  29. [plugins.linux]
  30. shim_debug = true
  32. [plugins.cri.registry.mirrors."docker.io"]
  33. endpoint = ["https://dbzucv6w.mirror.aliyuncs.com"]
  35. [plugins.cri]
  36. sandbox_image = "registry.k8s.io/pause:3.8"
  37. EOF
  39. cat > /etc/crictl.yaml <<EOF
  40. runtime-endpoint: unix:///run/containerd/containerd.sock
  41. image-endpoint: unix:///run/containerd/containerd.sock
  42. timeout: 10
  43. debug: false
  44. EOF
  46. systemctl restart containerd
  47. systemctl enable containerd --now
  48. systemctl status containerd
  50. # Disable the SELinux.
  51. sed -i 's/^SELINUX=.*/SELINUX=disabled/' /etc/selinux/config
  53. # Turn off and disable the firewalld.
  54. systemctl stop firewalld
  55. systemctl disable firewalld
  57. # Modify related kernel parameters & Disable the swap.
  58. cat > /etc/sysctl.d/k8s.conf << EOF
  59. net.ipv4.ip_forward = 1
  60. net.bridge.bridge-nf-call-ip6tables = 1
  61. net.bridge.bridge-nf-call-iptables = 1
  62. net.ipv4.tcp_tw_recycle = 0
  63. vm.swappiness = 0
  64. vm.overcommit_memory = 1
  65. vm.panic_on_oom = 0
  66. net.ipv6.conf.all.disable_ipv6 = 1
  67. EOF
  68. sysctl -p /etc/sysctl.d/k8s.conf >&/dev/null
  69. swapoff -a
  70. sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab
  71. modprobe br_netfilter
  72. modprobe overlay
  74. # Add ipvs modules
  75. cat > /etc/sysconfig/modules/ipvs.modules <<EOF
  76. #!/bin/bash
  77. modprobe -- ip_vs
  78. modprobe -- ip_vs_rr
  79. modprobe -- ip_vs_wrr
  80. modprobe -- ip_vs_sh
  81. modprobe -- nf_conntrack_ipv4
  82. modprobe -- nf_conntrack
  83. modprobe -- br_netfilter
  84. modprobe -- overlay
  85. EOF
  87. chmod 755 /etc/sysconfig/modules/ipvs.modules
  88. bash /etc/sysconfig/modules/ipvs.modules
  90. # Install rpm
  91. yum install -y conntrack ipvsadm ipset jq iptables curl sysstat libseccomp wget iproute-tc
  93. # Update kernel
  94. # rpm --import http://down.linuxsb.com/RPM-GPG-KEY-elrepo.org
  95. # rpm -Uvh http://down.linuxsb.com/elrepo-release-7.el7.elrepo.noarch.rpm
  96. # mv -b /etc/yum.repos.d/elrepo.repo /etc/yum.repos.d/backup
  97. # wget -c http://down.linuxsb.com/myoptions/elrepo7.repo -O /etc/yum.repos.d/elrepo.repo
  98. # yum --disablerepo="*" --enablerepo="elrepo-kernel" install -y kernel-ml
  99. # sed -i 's/^GRUB_DEFAULT=.*/GRUB_DEFAULT=0/' /etc/default/grub
  100. # grub2-mkconfig -o /boot/grub2/grub.cfg
  101. # yum -y --exclude=docker* update
  103. # Reboot the machine.
  104. # reboot
复制代码
提示：如上仅需Master01节点操作，从而实现所有节点自动启动服务。
集群部署

相关组件包

需要在每台机器上都安装以下的软件包：

  • kubeadm: 用来初始化集群的指令；
  • kubelet: 在集群中的每个节点上用来启动 pod 和 container 等；
  • kubectl: 用来与集群通信的命令行工具。
kubeadm不能安装或管理 kubelet 或 kubectl ，因此在初始化集群之前必须完成kubelet和kubectl的安装，且能保证他们满足通过 kubeadm 安装的 Kubernetes控制层对版本的要求。
如果版本没有满足匹配要求，可能导致一些意外错误或问题。
具体相关组件安装见；附001.kubectl介绍及使用书
提示：Kubernetes 1.25.3版本所有兼容相应组件的版本参考：https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG/CHANGELOG-1.25.md 。
正式安装

快速安装所有节点的kubeadm、kubelet、kubectl组件。
  1. [root@master01 ~]# source environment.sh
  2. [root@master01 ~]# chmod +x *.sh
  3. [root@master01 ~]# for all_ip in ${ALL_IPS[@]}
  4.   do
  5.     echo ">>> ${all_ip}"
  6.     scp -rp /etc/hosts root@${all_ip}:/etc/hosts
  7.     scp -rp k8sconinit.sh root@${all_ip}:/root/
  8.     ssh root@${all_ip} "bash /root/k8sconinit.sh"
  9.   done
复制代码
提示：如上仅需Master01节点操作，从而实现所有节点镜像的分发。
注意相关版本，如上脚本为v1.21.0 Kubernetes版本所需镜像。
  1. [root@master01 ~]# wget http://down.linuxsb.com/software/haproxy-2.6.6.tar.gz
  2. [root@master01 ~]# for master_ip in ${MASTER_IPS[@]}
  3.   do
  4.     echo ">>> ${master_ip}"
  5.     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"
  6.     scp -rp haproxy-2.6.6.tar.gz root@${master_ip}:/root/
  7.     ssh root@${master_ip} "tar -zxvf haproxy-2.6.6.tar.gz"
  8.     ssh root@${master_ip} "cd haproxy-2.6.6/ && 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"
  9.     ssh root@${master_ip} "cp /usr/local/haproxy/sbin/haproxy /usr/sbin/"
  10.     ssh root@${master_ip} "useradd -r haproxy && usermod -G haproxy haproxy"
  11.     ssh root@${master_ip} "mkdir -p /etc/haproxy && cp -r /root/haproxy-2.6.6/examples/errorfiles/ /usr/local/haproxy/"
  12.   done
复制代码
2.png

Master01上初始化

Master-1节点上执行初始化，即完成单节点的Kubernetes，其他节点采用添加的方式部署。
  1. [root@master01 ~]# wget https://www.keepalived.org/software/keepalived-2.2.7.tar.gz
  2. [root@master01 ~]# for master_ip in ${MASTER_IPS[@]}
  3.   do
  4.     echo ">>> ${master_ip}"
  5.     ssh root@${master_ip} "yum -y install curl gcc gcc-c++ make libnl3 libnl3-devel libnfnetlink openssl-devel"
  6.     scp -rp keepalived-2.2.7.tar.gz root@${master_ip}:/root/
  7.     ssh root@${master_ip} "tar -zxvf keepalived-2.2.7.tar.gz"
  8.     ssh root@${master_ip} "cd keepalived-2.2.7/ && LDFLAGS="$LDFAGS -L /usr/local/openssl/lib/" ./configure --sysconf=/etc --prefix=/usr/local/keepalived && make && make install"
  9.     ssh root@${master_ip} "systemctl enable keepalived && systemctl restart keepalived"
  10.   done
复制代码
3.png

注意：如上token具有默认24小时的有效期，token和hash值可通过如下方式获取：
kubeadm token list
如果 Token 过期以后，可以输入以下命令，生成新的 Token:
  1. [root@master01 ~]# wget http://down.linuxsb.com/mydeploy/k8s/v1.25.3/k8sconfig.sh                                #拉取自动部署脚本
  3. [root@master01 ~]# vim k8sconfig.sh
  4. #!/bin/sh
  5. #****************************************************************#
  6. # ScriptName: k8sconfig
  7. # Author: xhy
  8. # Create Date: 2022-06-08 20:00
  9. # Modify Author: xhy
  10. # Modify Date: 2022-11-12 22:21
  11. # Version: v3
  12. #***************************************************************#
  14. #######################################
  15. # set variables below to create the config files, all files will create at ./kubeadm directory
  16. #######################################
  18. # master keepalived virtual ip address
  19. export K8SHA_VIP=172.24.8.100
  21. # master01 ip address
  22. export K8SHA_IP1=172.24.8.151
  24. # master02 ip address
  25. export K8SHA_IP2=172.24.8.152
  27. # master03 ip address
  28. export K8SHA_IP3=172.24.8.153
  30. # master01 hostname
  31. export K8SHA_HOST1=master01
  33. # master02 hostname
  34. export K8SHA_HOST2=master02
  36. # master03 hostname
  37. export K8SHA_HOST3=master03
  39. # master01 network interface name
  40. export K8SHA_NETINF1=eth0
  42. # master02 network interface name
  43. export K8SHA_NETINF2=eth0
  45. # master03 network interface name
  46. export K8SHA_NETINF3=eth0
  48. # keepalived auth_pass config
  49. export K8SHA_KEEPALIVED_AUTH=412f7dc3bfed32194d1600c483e10ad1d
  51. # kubernetes CIDR pod subnet
  52. export K8SHA_PODCIDR=10.10.0.0
  54. # kubernetes CIDR svc subnet
  55. export K8SHA_SVCCIDR=10.20.0.0
  57. ##############################
  58. # please do not modify anything below
  59. ##############################
  61. mkdir -p kubeadm/$K8SHA_HOST1/{keepalived,haproxy}
  62. mkdir -p kubeadm/$K8SHA_HOST2/{keepalived,haproxy}
  63. mkdir -p kubeadm/$K8SHA_HOST3/{keepalived,haproxy}
  64. mkdir -p kubeadm/keepalived
  65. mkdir -p kubeadm/haproxy
  67. # wget all files
  68. wget -c -P kubeadm/keepalived/ http://down.linuxsb.com/mydeploy/k8s/common/k8s-keepalived.conf.tpl
  69. wget -c -P kubeadm/keepalived/ http://down.linuxsb.com/mydeploy/k8s/common/check_apiserver.sh
  70. wget -c -P kubeadm/haproxy/ http://down.linuxsb.com/mydeploy/k8s/common/k8s-haproxy.cfg.tpl
  71. wget -c -P kubeadm/haproxy/ http://down.linuxsb.com/mydeploy/k8s/common/k8s-haproxy.service
  72. wget -c -P kubeadm/ http://down.linuxsb.com/mydeploy/k8s/v1.25.3/kubeadm-config.yaml.tpl
  73. wget -c -P kubeadm/calico/ http://down.linuxsb.com/mydeploy/k8s/calico/v3.24.5/calico.yaml.tpl
  74. wget -c -P kubeadm/ http://down.linuxsb.com/mydeploy/k8s/v1.25.3/conloadimage.sh
  76. # create all kubeadm-config.yaml files
  77. sed \
  78. -e "s/K8SHA_HOST1/${K8SHA_HOST1}/g" \
  79. -e "s/K8SHA_HOST2/${K8SHA_HOST2}/g" \
  80. -e "s/K8SHA_HOST3/${K8SHA_HOST3}/g" \
  81. -e "s/K8SHA_IP1/${K8SHA_IP1}/g" \
  82. -e "s/K8SHA_IP2/${K8SHA_IP2}/g" \
  83. -e "s/K8SHA_IP3/${K8SHA_IP3}/g" \
  84. -e "s/K8SHA_VIP/${K8SHA_VIP}/g" \
  85. -e "s/K8SHA_PODCIDR/${K8SHA_PODCIDR}/g" \
  86. -e "s/K8SHA_SVCCIDR/${K8SHA_SVCCIDR}/g" \
  87. kubeadm/kubeadm-config.yaml.tpl > kubeadm/kubeadm-config.yaml
  89. echo "create kubeadm-config.yaml files success. kubeadm-config.yaml"
  91. # create all keepalived files
  92. chmod u+x kubeadm/keepalived/check_apiserver.sh
  93. cp kubeadm/keepalived/check_apiserver.sh kubeadm/$K8SHA_HOST1/keepalived
  94. cp kubeadm/keepalived/check_apiserver.sh kubeadm/$K8SHA_HOST2/keepalived
  95. cp kubeadm/keepalived/check_apiserver.sh kubeadm/$K8SHA_HOST3/keepalived
  97. sed \
  98. -e "s/K8SHA_KA_STATE/BACKUP/g" \
  99. -e "s/K8SHA_KA_INTF/${K8SHA_NETINF1}/g" \
  100. -e "s/K8SHA_IPLOCAL/${K8SHA_IP1}/g" \
  101. -e "s/K8SHA_KA_PRIO/102/g" \
  102. -e "s/K8SHA_VIP/${K8SHA_VIP}/g" \
  103. -e "s/K8SHA_KA_AUTH/${K8SHA_KEEPALIVED_AUTH}/g" \
  104. kubeadm/keepalived/k8s-keepalived.conf.tpl > kubeadm/$K8SHA_HOST1/keepalived/keepalived.conf
  106. sed \
  107. -e "s/K8SHA_KA_STATE/BACKUP/g" \
  108. -e "s/K8SHA_KA_INTF/${K8SHA_NETINF2}/g" \
  109. -e "s/K8SHA_IPLOCAL/${K8SHA_IP2}/g" \
  110. -e "s/K8SHA_KA_PRIO/101/g" \
  111. -e "s/K8SHA_VIP/${K8SHA_VIP}/g" \
  112. -e "s/K8SHA_KA_AUTH/${K8SHA_KEEPALIVED_AUTH}/g" \
  113. kubeadm/keepalived/k8s-keepalived.conf.tpl > kubeadm/$K8SHA_HOST2/keepalived/keepalived.conf
  115. sed \
  116. -e "s/K8SHA_KA_STATE/BACKUP/g" \
  117. -e "s/K8SHA_KA_INTF/${K8SHA_NETINF3}/g" \
  118. -e "s/K8SHA_IPLOCAL/${K8SHA_IP3}/g" \
  119. -e "s/K8SHA_KA_PRIO/100/g" \
  120. -e "s/K8SHA_VIP/${K8SHA_VIP}/g" \
  121. -e "s/K8SHA_KA_AUTH/${K8SHA_KEEPALIVED_AUTH}/g" \
  122. kubeadm/keepalived/k8s-keepalived.conf.tpl > kubeadm/$K8SHA_HOST3/keepalived/keepalived.conf
  124. echo "create keepalived files success. kubeadm/$K8SHA_HOST1/keepalived/"
  125. echo "create keepalived files success. kubeadm/$K8SHA_HOST2/keepalived/"
  126. echo "create keepalived files success. kubeadm/$K8SHA_HOST3/keepalived/"
  128. # create all haproxy files
  129. sed \
  130. -e "s/K8SHA_IP1/$K8SHA_IP1/g" \
  131. -e "s/K8SHA_IP2/$K8SHA_IP2/g" \
  132. -e "s/K8SHA_IP3/$K8SHA_IP3/g" \
  133. -e "s/K8SHA_HOST1/$K8SHA_HOST1/g" \
  134. -e "s/K8SHA_HOST2/$K8SHA_HOST2/g" \
  135. -e "s/K8SHA_HOST3/$K8SHA_HOST3/g" \
  136. kubeadm/haproxy/k8s-haproxy.cfg.tpl > kubeadm/haproxy/haproxy.conf
  138. echo "create haproxy files success. kubeadm/$K8SHA_HOST1/haproxy/"
  139. echo "create haproxy files success. kubeadm/$K8SHA_HOST2/haproxy/"
  140. echo "create haproxy files success. kubeadm/$K8SHA_HOST3/haproxy/"
  142. # create calico yaml file
  143. sed \
  144. -e "s/K8SHA_PODCIDR/${K8SHA_PODCIDR}/g" \
  145. kubeadm/calico/calico.yaml.tpl > kubeadm/calico/calico.yaml
  147. # scp all file
  148. scp -rp kubeadm/haproxy/haproxy.conf root@$K8SHA_HOST1:/etc/haproxy/haproxy.cfg
  149. scp -rp kubeadm/haproxy/haproxy.conf root@$K8SHA_HOST2:/etc/haproxy/haproxy.cfg
  150. scp -rp kubeadm/haproxy/haproxy.conf root@$K8SHA_HOST3:/etc/haproxy/haproxy.cfg
  151. scp -rp kubeadm/haproxy/k8s-haproxy.service root@$K8SHA_HOST1:/usr/lib/systemd/system/haproxy.service
  152. scp -rp kubeadm/haproxy/k8s-haproxy.service root@$K8SHA_HOST2:/usr/lib/systemd/system/haproxy.service
  153. scp -rp kubeadm/haproxy/k8s-haproxy.service root@$K8SHA_HOST3:/usr/lib/systemd/system/haproxy.service
  155. scp -rp kubeadm/$K8SHA_HOST1/keepalived/* root@$K8SHA_HOST1:/etc/keepalived/
  156. scp -rp kubeadm/$K8SHA_HOST2/keepalived/* root@$K8SHA_HOST2:/etc/keepalived/
  157. scp -rp kubeadm/$K8SHA_HOST3/keepalived/* root@$K8SHA_HOST3:/etc/keepalived/
  159. # chmod *.sh
  160. chmod u+x kubeadm/*.sh
复制代码
创建相关Kubernetes集群配置文件保存目录。
  1. [root@master01 ~]# vim kubeadm/kubeadm-config.yaml        #检查集群初始化配置
  2. ---
  3. apiVersion: kubeadm.k8s.io/v1beta3
  4. kind: ClusterConfiguration
  5. networking:
  6.   serviceSubnet: "10.20.0.0/16"                                         #设置svc网段
  7.   podSubnet: "10.10.0.0/16"                         #设置Pod网段
  8.   dnsDomain: "cluster.local"
  9. kubernetesVersion: "v1.25.3"                                        #设置安装版本
  10. controlPlaneEndpoint: "172.24.8.100:16443"                    #设置相关API VIP地址
  11. apiServer:
  12.   certSANs:
  13.   - master01
  14.   - master02
  15.   - master03
  16.   - 127.0.0.1
  17.   - 172.24.8.151
  18.   - 172.24.8.152
  19.   - 172.24.8.153
  20.   - 172.24.8.100
  21.   timeoutForControlPlane: 4m0s
  22. certificatesDir: "/etc/kubernetes/pki"
  23. imageRepository: "registry.k8s.io"
  24. #clusterName: "example-cluster"
  26. ---
  27. apiVersion: kubeproxy.config.k8s.io/v1alpha1
  28. kind: KubeProxyConfiguration
  29. mode: ipvs
复制代码
提示：如上仅需Master01节点操作，从而实现所有Worker节点添加至集群，若添加异常可通过如下方式重置：
  1. [root@master01 ~]# cat /etc/keepalived/keepalived.conf              #所有节点确认相关keepalive配置文件
  2. ! Configuration File for keepalived
  3. global_defs {
  4.     router_id LVS_DEVEL
  5.     script_user root
  6.     enable_script_security
  7. }
  8. vrrp_script check_apiserver {
  9.     script "/etc/keepalived/check_apiserver.sh"
  10.     interval 5
  11.     weight -60
  12.     fall 2
  13.     rise 2
  14. }
  15. vrrp_instance VI_1 {
  16.     state BACKUP
  17.     interface eth0
  18.     mcast_src_ip 172.24.8.151
  19.     virtual_router_id 51
  20.     priority 102
  21.     advert_int 5
  22.     authentication {
  23.         auth_type PASS
  24.         auth_pass 412f7dc3bfed32194d1600c483e10ad1d
  25.     }
  26.     virtual_ipaddress {
  27.         172.24.8.100
  28.     }
  29.     track_script {
  30.        check_apiserver
  31.     }
  32. }
  34. [root@master01 ~]# cat /etc/keepalived/check_apiserver.sh              #所有节点确认相关keepalive监测脚本文件
  35. #!/bin/bash
  37. # if check error then repeat check for 12 times, else exit
  38. err=0
  39. for k in $(seq 1 12)
  40. do
  41.     check_code=$(curl -k https://localhost:6443)
  42.     if [[ $check_code == "" ]]; then
  43.         err=$(expr $err + 1)
  44.         sleep 5
  45.         continue
  46.     else
  47.         err=0
  48.         break
  49.     fi
  50. done
  52. if [[ $err != "0" ]]; then
  53.     # if apiserver is down send SIG=1
  54.     echo 'apiserver error!'
  55.     exit 1
  56. else
  57.     # if apiserver is up send SIG=0
  58.     echo 'apiserver normal!'
  59.     exit 0
  60. fi
复制代码
确认验证
  1. [root@master01 ~]# for master_ip in ${MASTER_IPS[@]}
  2. do
  3.     echo ">>> ${master_ip}"
  4.     ssh root@${master_ip} "systemctl enable haproxy.service --now && systemctl restart haproxy.service"
  5.     ssh root@${master_ip} "systemctl enable keepalived.service --now && systemctl restart keepalived.service"
  6.     ssh root@${master_ip} "systemctl status keepalived.service | grep Active"
  7.     ssh root@${master_ip} "systemctl status haproxy.service | grep Active"
  8. done
  10. [root@master01 ~]# for all_ip in ${ALL_IPS[@]}
  11. do
  12.     echo ">>> ${all_ip}"
  13.     ssh root@${all_ip} "ping -c1 172.24.8.100"
  14. done                                                                                #等待10s执行检查
复制代码
4.png

提示：更多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配置。
  1. [root@master01 ~]# for all_ip in ${ALL_IPS[@]}
  2.   do
  3.     echo ">>> ${all_ip}"
  4.     ssh root@${all_ip} "cat <<EOF > /etc/yum.repos.d/kubernetes.repo
  5. [kubernetes]
  6. name=Kubernetes
  7. baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
  8. enabled=1
  9. gpgcheck=1
  10. repo_gpgcheck=1
  11. gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
  12. EOF"
  13.     ssh root@${all_ip} "yum install -y kubeadm-1.25.3-0.x86_64 kubelet-1.25.3-0.x86_64 kubectl-1.25.3-0.x86_64 --disableexcludes=kubernetes"
  14.     ssh root@${all_ip} "systemctl enable kubelet"
  15. done
  17. [root@master01 ~]# yum search -y kubelet --showduplicates             #查看相应版本
复制代码
正式部署
  1. [root@master01 ~]# kubeadm --kubernetes-version=v1.25.3 config images list             #列出所需镜像
  3. [root@master01 ~]# vim kubeadm/k8simage.sh
  4. #!/bin/sh
  5. #****************************************************************#
  6. # ScriptName: conloadimage.sh
  7. # Author: xhy
  8. # Create Date: 2021-04-15 14:03
  9. # Modify Author: xhy
  10. # Modify Date: 2022-11-20 00:01
  11. # Version:
  12. #***************************************************************#
  14. KUBE_VERSION=v1.25.3
  15. KUBE_PAUSE_VERSION=3.8
  16. ETCD_VERSION=3.5.4-0
  17. CORE_DNS_VERSION=v1.9.3
  18. K8S_URL=registry.k8s.io
  19. GCR_URL=k8s.gcr.io
  20. UCLOUD_URL=uhub.service.ucloud.cn/imxhy
  21. LONGHORN_URL=longhornio
  22. CALICO_URL='docker.io/calico'
  23. CALICO_VERSION=v3.24.5
  24. METRICS_SERVER_VERSION=v0.6.1
  25. INGRESS_VERSION=v1.5.1
  26. INGRESS_WEBHOOK_VERSION=v20220916-gd32f8c343
  27. LONGHORN1_VERSION=master-head
  28. LONGHORN2_VERSION=v3_20221117
  29. LONGHORN3_VERSION=v3_20220808
  30. LONGHORN4_VERSION=v1_20220914
  31. #CSI_PROVISIONER_VERSION=v1.6.0-lh1
  32. #CSI_NODE_DRIVER_VERSION=v1.2.0-lh1
  33. #CSI_ATTACHER_VERSION=v2.2.1-lh1
  34. #CSI_RESIZER_VERSION=v0.5.1-lh1
  35. #DEFAULTBACKENDVERSION=1.5
  36. #ALIYUN_URL=registry.cn-hangzhou.aliyuncs.com/google_containers
  38. mkdir -p k8simages/
  40. # config node hostname
  41. export ALL_NAMES=(master02 master03 worker01 worker02 worker03)
  43. kubeimages=(kube-proxy:${KUBE_VERSION}
  44. kube-scheduler:${KUBE_VERSION}
  45. kube-controller-manager:${KUBE_VERSION}
  46. kube-apiserver:${KUBE_VERSION}
  47. pause:${KUBE_PAUSE_VERSION}
  48. etcd:${ETCD_VERSION}
  49. )
  51. for kubeimageName in ${kubeimages[@]} ; do
  52. echo ${kubeimageName}
  53. ctr -n k8s.io images pull ${UCLOUD_URL}/${kubeimageName}
  54. ctr -n k8s.io images tag ${UCLOUD_URL}/${kubeimageName} ${K8S_URL}/${kubeimageName}
  55. ctr -n k8s.io images rm ${UCLOUD_URL}/${kubeimageName}
  56. ctr -n k8s.io images export k8simages/${kubeimageName}\.tar ${K8S_URL}/${kubeimageName}
  57. done
  59. corednsimages=(coredns:${CORE_DNS_VERSION}
  60. )
  62. for corednsimageName in ${corednsimages[@]} ; do
  63. echo ${corednsimageName}
  64. ctr -n k8s.io images pull ${UCLOUD_URL}/${corednsimageName}
  65. ctr -n k8s.io images tag ${UCLOUD_URL}/${corednsimageName} ${K8S_URL}/coredns/${corednsimageName}
  66. ctr -n k8s.io images rm ${UCLOUD_URL}/${corednsimageName}
  67. ctr -n k8s.io images export k8simages/${corednsimageName}\.tar ${K8S_URL}/coredns/${corednsimageName}
  68. done
  70. metricsimages=(metrics-server:${METRICS_SERVER_VERSION})
  72. for metricsimageName in ${metricsimages[@]} ; do
  73. echo ${metricsimageName}
  74. ctr -n k8s.io images pull ${UCLOUD_URL}/${metricsimageName}
  75. ctr -n k8s.io images tag ${UCLOUD_URL}/${metricsimageName} ${GCR_URL}/metrics-server/${metricsimageName}
  76. ctr -n k8s.io images rm ${UCLOUD_URL}/${metricsimageName}
  77. ctr -n k8s.io images export k8simages/${metricsimageName}\.tar ${GCR_URL}/metrics-server/${metricsimageName}
  78. done
  80. calimages=(cni:${CALICO_VERSION}
  81. node:${CALICO_VERSION}
  82. kube-controllers:${CALICO_VERSION})
  84. for calimageName in ${calimages[@]} ; do
  85. echo ${calimageName}
  86. ctr -n k8s.io images pull ${UCLOUD_URL}/${calimageName}
  87. ctr -n k8s.io images tag ${UCLOUD_URL}/${calimageName} ${CALICO_URL}/${calimageName}
  88. ctr -n k8s.io images rm ${UCLOUD_URL}/${calimageName}
  89. ctr -n k8s.io images export k8simages/${calimageName}\.tar ${CALICO_URL}/${calimageName}
  90. done
  92. ingressimages=(controller:${INGRESS_VERSION}
  93. kube-webhook-certgen:${INGRESS_WEBHOOK_VERSION}
  94. )
  96. for ingressimageName in ${ingressimages[@]} ; do
  97. echo ${ingressimageName}
  98. ctr -n k8s.io images pull ${UCLOUD_URL}/${ingressimageName}
  99. ctr -n k8s.io images tag ${UCLOUD_URL}/${ingressimageName} ${K8S_URL}/ingress-nginx/${ingressimageName}
  100. ctr -n k8s.io images rm ${UCLOUD_URL}/${ingressimageName}
  101. ctr -n k8s.io images export k8simages/${ingressimageName}\.tar ${K8S_URL}/ingress-nginx/${ingressimageName}
  102. done
  104. longhornimages01=(longhorn-manager:${LONGHORN1_VERSION}
  105. longhorn-ui:${LONGHORN1_VERSION}
  106. longhorn-engine:${LONGHORN1_VERSION}
  107. )
  109. for longhornimageNameA in ${longhornimages01[@]} ; do
  110. echo ${longhornimageNameA}
  111. ctr -n k8s.io images pull ${UCLOUD_URL}/${longhornimageNameA}
  112. ctr -n k8s.io images tag ${UCLOUD_URL}/${longhornimageNameA} ${LONGHORN_URL}/${longhornimageNameA}
  113. ctr -n k8s.io images rm ${UCLOUD_URL}/${longhornimageNameA}
  114. ctr -n k8s.io images export k8simages/${longhornimageNameA}\.tar ${LONGHORN_URL}/${longhornimageNameA}
  115. done
  117. longhornimages02=(longhorn-instance-manager:${LONGHORN2_VERSION}
  118. )
  120. for longhornimageNameB in ${longhornimages02[@]} ; do
  121. echo ${longhornimageNameB}
  122. ctr -n k8s.io images pull ${UCLOUD_URL}/${longhornimageNameB}
  123. ctr -n k8s.io images tag ${UCLOUD_URL}/${longhornimageNameB} ${LONGHORN_URL}/${longhornimageNameB}
  124. ctr -n k8s.io images rm ${UCLOUD_URL}/${longhornimageNameB}
  125. ctr -n k8s.io images export k8simages/${longhornimageNameB}\.tar ${LONGHORN_URL}/${longhornimageNameB}
  126. done
  128. longhornimages03=(backing-image-manager:${LONGHORN3_VERSION})
  130. for longhornimageNameC in ${longhornimages03[@]} ; do
  131. echo ${longhornimageNameC}
  132. ctr -n k8s.io images pull ${UCLOUD_URL}/${longhornimageNameC}
  133. ctr -n k8s.io images tag ${UCLOUD_URL}/${longhornimageNameC} ${LONGHORN_URL}/${longhornimageNameC}
  134. ctr -n k8s.io images rm ${UCLOUD_URL}/${longhornimageNameC}
  135. ctr -n k8s.io images export k8simages/${longhornimageNameC}\.tar ${LONGHORN_URL}/${longhornimageNameC}
  136. done
  138. longhornimages04=(longhorn-share-manager:${LONGHORN4_VERSION})
  140. for longhornimageNameD in ${longhornimages04[@]} ; do
  141. echo ${longhornimageNameD}
  142. ctr -n k8s.io images pull ${UCLOUD_URL}/${longhornimageNameD}
  143. ctr -n k8s.io images tag ${UCLOUD_URL}/${longhornimageNameD} ${LONGHORN_URL}/${longhornimageNameD}
  144. ctr -n k8s.io images rm ${UCLOUD_URL}/${longhornimageNameD}
  145. ctr -n k8s.io images export k8simages/${longhornimageNameD}\.tar ${LONGHORN_URL}/${longhornimageNameD}
  146. done
  148. #csiimages=(csi-provisioner:${CSI_PROVISIONER_VERSION}
  149. #csi-node-driver-registrar:${CSI_NODE_DRIVER_VERSION}
  150. #csi-attacher:${CSI_ATTACHER_VERSION}
  151. #csi-resizer:${CSI_RESIZER_VERSION}
  152. #)
  154. #for csiimageName in ${csiimages[@]} ; do
  155. #echo ${csiimageName}
  156. #ctr -n k8s.io images pull ${UCLOUD_URL}/${csiimageName}
  157. #ctr -n k8s.io images tag ${UCLOUD_URL}/${csiimageName} longhornio/${csiimageName}
  158. #ctr -n k8s.io images rm ${UCLOUD_URL}/${csiimageName}
  159. #ctr -n k8s.io images export k8simages/${csiimageName}\.tar longhornio/${csiimageName}
  160. #done
  161. #
  162. #otherimages=(defaultbackend-amd64:${DEFAULTBACKENDVERSION})
  164. #for otherimagesName in ${otherimages[@]} ; do
  165. #echo ${otherimagesName}
  166. #ctr -n k8s.io images pull ${UCLOUD_URL}/${otherimagesName}
  167. #ctr -n k8s.io images tag ${UCLOUD_URL}/${otherimagesName} ${K8S_URL}/${otherimagesName}
  168. #ctr -n k8s.io images rm ${UCLOUD_URL}/${otherimagesName}
  169. #ctr -n k8s.io images export k8simages/${otherimagesName}\.tar ${K8S_URL}/${otherimagesName}
  170. #done
  171. #
  172. allimages=(kube-proxy:${KUBE_VERSION}
  173. kube-scheduler:${KUBE_VERSION}
  174. kube-controller-manager:${KUBE_VERSION}
  175. kube-apiserver:${KUBE_VERSION}
  176. pause:${KUBE_PAUSE_VERSION}
  177. etcd:${ETCD_VERSION}
  178. coredns:${CORE_DNS_VERSION}
  179. metrics-server:${METRICS_SERVER_VERSION}
  180. cni:${CALICO_VERSION}
  181. node:${CALICO_VERSION}
  182. kube-controllers:${CALICO_VERSION}
  183. controller:${INGRESS_VERSION}
  184. kube-webhook-certgen:${INGRESS_WEBHOOK_VERSION}
  185. longhorn-manager:${LONGHORN1_VERSION}
  186. longhorn-ui:${LONGHORN1_VERSION}
  187. longhorn-engine:${LONGHORN1_VERSION}
  188. longhorn-instance-manager:${LONGHORN2_VERSION}
  189. backing-image-manager:${LONGHORN3_VERSION}
  190. longhorn-share-manager:${LONGHORN4_VERSION}
  191. #csi-provisioner:${CSI_PROVISIONER_VERSION}
  192. #csi-node-driver-registrar:${CSI_NODE_DRIVER_VERSION}
  193. #csi-attacher:${CSI_ATTACHER_VERSION}
  194. #csi-resizer:${CSI_RESIZER_VERSION}
  195. #defaultbackend-amd64:${DEFAULTBACKENDVERSION}
  196. )
  198. for all_name in ${ALL_NAMES[@]}
  199.   do  
  200.     echo ">>> ${all_name}"
  201.     ssh root@${all_name} "mkdir /root/k8simages"
  202.     scp -rp k8simages/* root@${all_name}:/root/k8simages/
  203.   done
  205. for allimageName in ${allimages[@]}
  206.   do
  207.   for all_name in ${ALL_NAMES[@]}
  208.     do
  209.     echo "${allimageName} copy to ${all_name}"
  210.     ssh root@${all_name} "ctr -n k8s.io images import k8simages/${allimageName}\.tar"
  211.     done
  212.   done
  214. [root@master01 ~]# bash kubeadm/k8simage.sh                     #确认版本，提前下载镜像
复制代码
查看资源监控

可使用kubectl top查看相关监控项。
  1. [root@master01 ~]# ctr -n k8s.io images ls                #确认验证
  2. [root@master01 ~]# crictl images ls
复制代码
5.png

提示：Metrics Server提供的数据也可以供HPA控制器使用，以实现基于CPU使用率或内存使用值的Pod自动扩缩容功能。
部署参考：https://linux48.com/container/2019-11-13-metrics-server.html
有关metrics更多部署参考：
https://kubernetes.io/docs/tasks/debug-application-cluster/resource-metrics-pipeline/
开启开启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的表现形式为IPort，即工作在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提供的是对外服务，则实际上实现的是边缘路由器的功能。
典型的HTTP层路由的架构：
6.png

设置标签

建议对于非业务相关的应用，构建集群所需的应用（如Ingress），部署在master节点，从而复用master节点的高可用。
采用标签，结合部署的yaml中的tolerations，实现ingress部署在master节点的配置。
  1. [root@master01 ~]# kubeadm init --config=kubeadm/kubeadm-config.yaml --upload-certs                 #保留如下命令用于后续节点添加：
  2. ……
  3. Your Kubernetes control-plane has initialized successfully!
  5. To start using your cluster, you need to run the following as a regular user:
  7.   mkdir -p $HOME/.kube
  8.   sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  9.   sudo chown $(id -u):$(id -g) $HOME/.kube/config
  11. Alternatively, if you are the root user, you can run:
  13.   export KUBECONFIG=/etc/kubernetes/admin.conf
  15. You should now deploy a pod network to the cluster.
  16. Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  17.   https://kubernetes.io/docs/concepts/cluster-administration/addons/
  19. You can now join any number of the control-plane node running the following command on each as root:
  21.   kubeadm join 172.24.8.100:16443 --token qkaf0s.ar48yhg1q4ii5mhf \
  22.         --discovery-token-ca-cert-hash sha256:1238bf64661112257ed266fc054e65ec53f7ed64c0c17f39d681f92754860b54 \
  23.         --control-plane --certificate-key 1f5de4e4aa380d6dd074f38a260332f95d36945fead04520072766391b9f6423
  25. Please note that the certificate-key gives access to cluster sensitive data, keep it secret!
  26. As a safeguard, uploaded-certs will be deleted in two hours; If necessary, you can use
  27. "kubeadm init phase upload-certs --upload-certs" to reload certs afterward.
  29. Then you can join any number of worker nodes by running the following on each as root:
  31. kubeadm join 172.24.8.100:16443 --token qkaf0s.ar48yhg1q4ii5mhf \
  32.         --discovery-token-ca-cert-hash sha256:1238bf64661112257ed266fc054e65ec53f7ed64c0c17f39d681f92754860b54
复制代码
获取资源

获取部署所需的yaml资源。
  1. kubeadm token create
  2. openssl x509 -pubkey -in /etc/kubernetes/pki/ca.crt | openssl rsa -pubin -outform der 2>/dev/null | openssl dgst -sha256 -hex | sed 's/^.* //'
复制代码
提示：ingress官方参考：https://github.com/kubernetes/ingress-nginx
https://kubernetes.github.io/ingress-nginx/deploy/
修改配置

为方便后续管理和排障，对相关Nginx ingress挂载时区，以便使Pod时间正确，从而相关记录日志能具有时效性。
同时对ingress做了简单配置，如日志格式等。
  1. [root@master01 ~]# mkdir -p $HOME/.kube
  2. [root@master01 ~]# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  3. [root@master01 ~]# sudo chown $(id -u):$(id -g) $HOME/.kube/config
  5. [root@master01 ~]# cat << EOF >> ~/.bashrc
  6. export KUBECONFIG=$HOME/.kube/config
  7. EOF                                                        #设置KUBECONFIG环境变量
  9. [root@master01 ~]# echo "source <(kubectl completion bash)" >> ~/.bashrc
  10. [root@master01 ~]# source ~/.bashrc
复制代码
提示：添加默认backend需要等待default-backend创建完成controllers才能成功部署，新版本ingress不再推荐添加default backend。
确认验证

查看Pod部署进度，是否成功完成。
  1. [root@master02 ~]# kubeadm join 172.24.8.100:16443 --token qkaf0s.ar48yhg1q4ii5mhf \
  2. --discovery-token-ca-cert-hash sha256:1238bf64661112257ed266fc054e65ec53f7ed64c0c17f39d681f92754860b54 \
  3. --control-plane --certificate-key 1f5de4e4aa380d6dd074f38a260332f95d36945fead04520072766391b9f6423
  5. [root@master02 ~]# mkdir -p $HOME/.kube
  6. [root@master02 ~]# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  7. [root@master02 ~]# sudo chown $(id -u):$(id -g) $HOME/.kube/config
  8. [root@master02 ~]# cat << EOF >> ~/.bashrc
  9. export KUBECONFIG=$HOME/.kube/config
  10. EOF                                                                                   #设置KUBECONFIG环境变量
  11. [root@master02 ~]# echo "source <(kubectl completion bash)" >> ~/.bashrc
  12. [root@master02 ~]# source ~/.bashrc
复制代码
7.png

提示：参考文档：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节点。
  1. [root@master01 ~]# vim kubeadm/calico/calico.yaml            #检查配置
  2. ……
  3. data:
  4. ……
  5.   veth_mtu: "1400"
  6. ……
  7.             - name: CALICO_IPV4POOL_CIDR
  8.               value: "10.10.0.0/16"                                    #配置Pod网段
  9. ……
  10.             - name: IP_AUTODETECTION_METHOD
  11.               value: "interface=eth.*"                                #检查节点之间的网卡
  12. # Auto-detect the BGP IP address.
  13.             - name: IP
  14.               value: "autodetect"
  15. ……
  17. [root@master01 ~]# kubectl apply -f kubeadm/calico/calico.yaml
  18. [root@master01 ~]# kubectl get pods --all-namespaces -o wide                #查看部署
  19. [root@master01 ~]# kubectl get nodes
复制代码
提示：建议对于Kubernetes自身相关的应用（如dashboard），此类非业务应用部署在master节点。
创建证书

默认dashboard会自动创建证书，同时使用对应证书创建secret。生产环境可以启用相应的域名进行部署dashboard，因此需要将对于的域名制作为TLS证书。
本实验已获取免费一年的证书，免费证书获取可参考：https://freessl.cn.
将已获取的证书上传至对应目录。
  1. [root@master01 ~]# vi /etc/kubernetes/manifests/kube-apiserver.yaml                     #追加端口开放配置
  2. ……
  3.     - --service-node-port-range=1-65535
  4. ……
复制代码
提示：也可手动如下操作创建自签证书：
[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。
  1. [root@master01 ~]# source environment.sh
  3. [root@master01 ~]# for node_ip in ${NODE_IPS[@]}
  4.   do
  5.     echo ">>> ${node_ip}"
  6.     ssh root@${node_ip} "kubeadm join 172.24.8.100:16443 --token qkaf0s.ar48yhg1q4ii5mhf \
  7.       --discovery-token-ca-cert-hash sha256:1238bf64661112257ed266fc054e65ec53f7ed64c0c17f39d681f92754860b54"
  8.     ssh root@${node_ip} "systemctl enable kubelet.service"
  9.   done
复制代码
下载yaml

从官方下载最新的dashboard部署所需yaml。
  1. [root@worker01 ~]# kubeadm reset
  2. [root@worker01 ~]# ifconfig cni0 down
  3. [root@worker01 ~]# ip link delete cni0
  4. [root@worker01 ~]# ifconfig flannel.1 down
  5. [root@worker01 ~]# ip link delete flannel.1
  6. [root@worker01 ~]# rm -rf /var/lib/cni/
复制代码
提示：官方参考：
修改yaml

根据实际生产环境修改yaml，以便于使用已创建的证书TLS secret。
  1. [root@master01 ~]# kubectl get nodes                                         #节点状态
  2. [root@master01 ~]# kubectl get cs                                             #组件状态
  3. [root@master01 ~]# kubectl get serviceaccount                             #服务账户
  4. [root@master01 ~]# kubectl cluster-info                                         #集群信息
  5. [root@master01 ~]# kubectl get pod -n kube-system -o wide        #所有服务状态
复制代码
正式部署

根据生产环境最佳实践进行调优，调优完成后开始部署。
  1. [root@master01 ~]# mkdir metrics
  2. [root@master01 ~]# cd metrics/
  3. [root@master01 metrics]# wget https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml
  7. [root@master01 metrics]# vi components.yaml
  8. ……
  9. apiVersion: apps/v1
  10. kind: Deployment
  11. ……
  12. spec:
  13.   replicas: 3                                                                                                                            #根据集群规模调整副本数
  14.     ……
  15.     spec:
  16.       hostNetwork: true
  17.       containers:
  18.       - args:
  19.         - --cert-dir=/tmp
  20.         - --secure-port=4443
  21.         - --kubelet-insecure-tls                                                                                            #追加此args
  22.         - --kubelet-preferred-address-types=InternalIP,ExternalIP,Hostname,InternalDNS,ExternalDNS          #追加此args
  23.         - --kubelet-use-node-status-port
  24.         - --metric-resolution=15s
  25.         image: k8s.gcr.io/metrics-server/metrics-server:v0.6.1
  26.         imagePullPolicy: IfNotPresent
  27.     ……
复制代码
8.png

提示：master NodePort 30001/TCP映射到 dashboard pod 443 端口。
创建管理员账户

建议创建管理员账户，dashboard v2版本默认没有创建具有管理员权限的账户，同时登录可以选择kubeconfig以及token，通常使用kubeconfig比较方便。
在创建管理员用户后，将用户相关信息配置成kubeconfig文件，即可实现快速登录dashboard。
  1. [root@master01 metrics]# kubectl apply -f components.yaml
  2. [root@master01 metrics]# kubectl -n kube-system get pods -l k8s-app=metrics-server -o wide
  3. NAME                             READY   STATUS    RESTARTS   AGE   IP             NODE       NOMINATED NODE   READINESS GATES
  4. metrics-server-dfd7fbbfb-gh4bg   1/1     Running   0          29s   172.24.8.156   worker03   <none>           <none>
  5. metrics-server-dfd7fbbfb-trz7w   1/1     Running   0          29s   172.24.8.155   worker02   <none>           <none>
  6. metrics-server-dfd7fbbfb-xm5mm   1/1     Running   0          29s   172.24.8.154   worker01   <none>           <none>
复制代码
提示：更多安装方式参考官方手册：https://helm.sh/docs/intro/install/ 。
Helm操作

查找chart

helm search：可以用于搜索两种不同类型的源。
helm search hub：搜索 Helm Hub，该源包含来自许多不同仓库的Helm chart。
helm search repo：搜索已添加到本地头helm客户端（带有helm repo add）的仓库，该搜索是通过本地数据完成的，不需要连接公网。
  1. [root@master01 ~]# kubectl top nodes
  2. [root@master01 ~]# kubectl top pods --all-namespaces
复制代码
添加repo

类似CentOS添加yum源，可以给helm仓库添加相关源。
  1. [root@master01 ~]# kubectl label nodes master0{1,2,3} ingress=enable
复制代码
扩展：集群扩容及缩容

集群扩容


  • master节点扩容
    参考：添加Master节点 步骤
  • worker节点扩容
    参考：添加Worker节点 步骤
集群缩容


  • master节点缩容
    Master节点缩容的时候会自动将Pod迁移至其他节点。
  1. [root@master01 ~]# mkdir ingress
  2. [root@master01 ~]# cd ingress/
  3. [root@master01 ingress]# wget https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.5.1/deploy/static/provider/baremetal/deploy.yaml
复制代码

  • worker节点缩容
    Worker节点缩容的时候会自动将Pod迁移至其他节点。
  1. [root@master01 ingress]# vi deploy.yaml
  2. ……
  3. ---
  4. apiVersion: v1
  5. data:
  6.   allow-snippet-annotations: "true"
  7.   # 客户端请求头的缓冲区大小                                                    #配置如下日志格式
  8.   client-header-buffer-size: "512k"
  9.   # 设置用于读取大型客户端请求标头的最大值number和size缓冲区
  10.   large-client-header-buffers: "4 512k"
  11.   # 读取客户端请求body的缓冲区大小
  12.   client-body-buffer-size: "128k"
  13.   # 代理缓冲区大小
  14.   proxy-buffer-size: "256k"
  15.   # 代理body大小
  16.   proxy-body-size: "50m"
  17.   # 服务器名称哈希大小
  18.   server-name-hash-bucket-size: "128"
  19.   # map哈希大小
  20.   map-hash-bucket-size: "128"
  21.   # SSL加密套件
  22.   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
  23. 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
  24. :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"
  25.   # ssl 协议
  26.   ssl-protocols: "TLSv1 TLSv1.1 TLSv1.2"
  27.   # 日志格式
  28.   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
  29. 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":
  30. "$http_user_agent" }'
  31. kind: ConfigMap
  32. metadata:
  33.   labels:
  34.     app.kubernetes.io/component: controller
  35.     app.kubernetes.io/instance: ingress-nginx
  36.     app.kubernetes.io/name: ingress-nginx
  37.     app.kubernetes.io/part-of: ingress-nginx
  38.     app.kubernetes.io/version: 1.5.1
  39.   name: ingress-nginx-controller
  40.   namespace: ingress-nginx
  41. ……
  42. ---
  43. apiVersion: v1
  44. kind: Service
  45. metadata:
  46.   labels:
  47.     app.kubernetes.io/component: controller
  48.     app.kubernetes.io/instance: ingress-nginx
  49.     app.kubernetes.io/name: ingress-nginx
  50.     app.kubernetes.io/part-of: ingress-nginx
  51.     app.kubernetes.io/version: 1.5.1
  52.   name: ingress-nginx-controller
  53.   namespace: ingress-nginx
  54. spec:
  55.   ipFamilies:
  56.   - IPv4
  57.   ipFamilyPolicy: SingleStack
  58.   ports:
  59.   - appProtocol: http
  60.     name: http
  61.     port: 80
  62.     protocol: TCP
  63.     targetPort: http
  64.     nodePort: 80                                                    #追加此行
  65.   - appProtocol: https
  66.     name: https
  67.     port: 443
  68.     protocol: TCP
  69.     targetPort: https
  70.     nodePort: 443                                                   #追加此行
  71.   selector:
  72.     app.kubernetes.io/component: controller
  73.     app.kubernetes.io/instance: ingress-nginx
  74.     app.kubernetes.io/name: ingress-nginx
  75.   type: NodePort
  76.   externalTrafficPolicy: Local                                      #追加此行
  77. ……
  78. ---
  79. apiVersion: apps/v1
  80. kind: Deployment
  81. metadata:
  82.   labels:
  83.     app.kubernetes.io/component: controller
  84.     app.kubernetes.io/instance: ingress-nginx
  85.     app.kubernetes.io/name: ingress-nginx
  86.     app.kubernetes.io/part-of: ingress-nginx
  87.     app.kubernetes.io/version: 1.5.1
  88.   name: ingress-nginx-controller
  89.   namespace: ingress-nginx
  90. spec:
  91.   replicas: 3                                                       #配置副本数
  92. ……
  93.     spec:
  94.       containers:
  95.       - args:
  96.         - /nginx-ingress-controller
  97. ……
  98.         image: registry.k8s.io/ingress-nginx/controller:v1.5.1      #修改image镜像
  99. ……
  100.         volumeMounts:
  101. ……
  102.         - mountPath: /etc/localtime                                 #挂载localtime
  103.           name: timeconfig
  104.           readOnly: true
  105.       dnsPolicy: ClusterFirst
  106.       nodeSelector:
  107.         kubernetes.io/os: linux
  108.         ingress: enable
  109.       tolerations:
  110.         - key: node-role.kubernetes.io/control-plane
  111.           effect: NoSchedule
  112. ……
  113.       volumes:
  114.       - name: webhook-cert
  115.         secret:
  116.           secretName: ingress-nginx-admission
  117.       - name: timeconfig                                            #将hostpath配置为挂载卷
  118.         hostPath:
  119.           path: /etc/localtime
  120. ……
  121.         image: registry.k8s.io/ingress-nginx/kube-webhook-certgen:v20220916-gd32f8c343      #修改image镜像
  122. ……
  123.         image: registry.k8s.io/ingress-nginx/kube-webhook-certgen:v20220916-gd32f8c343      #修改image镜像
  124. ……
  126. [root@master01 ingress]# kubectl apply -f deploy.yaml
复制代码
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！
Kubernetesv1高可用可用部署

使用道具 举报

相关推荐
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
金娅鸣
2025-6-4 21:45:42

0

粉丝关注

17

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫