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

CSDN热搜

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

附036.Kubernetes_v1.27.0高可用部署架构二

能拘 2025-6-1 21:05:33
目录

  • 部署组件

    • 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 特性。
更多参考：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  --help：查看子命令帮助信息；
  • kubelet [command] [PARAMS] -o=：设置输出格式，如json、yaml等；
  • Kubetcl explain [RESOURCE]：查看资源的定义。
更多参考：kubectl介绍
方案概述

方案介绍

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

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

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

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

节点规划

节点主机名IP类型运行服务master01172.24.8.111Kubernetes master节点kubeadm、kubelet、kubectl、KeepAlived、
containerd、etcd、kube-apiserver、kube-scheduler、
kube-controller-manager、calico、WebUI、metrics、ingress、Longhorn ui节点master02172.24.8.112Kubernetes master节点kubeadm、kubelet、kubectl、KeepAlived、
containerd、etcd、kube-apiserver、kube-scheduler、
kube-controller-manager、calico、WebUI、metrics、ingress、Longhorn ui节点master03172.24.8.113Kubernetes master节点kubeadm、kubelet、kubectl、KeepAlived、
containerd、etcd、kube-apiserver、kube-scheduler、
kube-controller-manager、calico、WebUI、metrics、ingress、Longhorn ui节点worker01172.24.8.114Kubernetes worker节点kubelet、containerd、calico、Longhorn存储节点worker02172.24.8.115Kubernetes worker节点kubelet、containerd、calico、Longhorn存储节点worker03172.24.8.116Kubernetes worker节点kubelet、containerd、calico、Longhorn存储节点worker04172.24.8.117Kubernetes 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.111 master01
  3. 172.24.8.112 master02
  4. 172.24.8.113 master03
  5. 172.24.8.114 worker01
  6. 172.24.8.115 worker02
  7. 172.24.8.116 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 ~]# wget http://down.linuxsb.com/mydeploy/k8s/v1.27.0/environment.sh
  3. [root@master01 ~]# vi environment.sh            #确认相关主机名和IP
  4. #!/bin/sh
  5. #****************************************************************#
  6. # ScriptName: environment.sh
  7. # Author: xhy
  8. # Create Date: 2022-10-11 17:10
  9. # Modify Author: xhy
  10. # Modify Date: 2022-11-12 22:22
  11. # Version: v1
  12. #***************************************************************#
  14. # 集群 MASTER 机器 IP 数组
  15. export MASTER_IPS=(172.24.8.111 172.24.8.112 172.24.8.113)
  17. # 集群 MASTER IP 对应的主机名数组
  18. export MASTER_NAMES=(master01 master02 master03)
  20. # 集群 NODE 机器 IP 数组
  21. export NODE_IPS=(172.24.8.114 172.24.8.115 172.24.8.116)
  23. # 集群 NODE IP 对应的主机名数组
  24. export NODE_NAMES=(worker01 worker02 worker03)
  26. # 集群所有机器 IP 数组
  27. 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)
  29. # 集群所有IP 对应的主机名数组
  30. 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 ~]# wget http://down.linuxsb.com/mydeploy/k8s/v1.27.0/k8sconinit.sh
  3. [root@master01 ~]# vim k8sconinit.sh
  4. #!/bin/sh
  5. #****************************************************************#
  6. # ScriptName: k8sconinit.sh
  7. # Author: xhy
  8. # Create Date: 2020-05-30 16:30
  9. # Modify Author: xhy
  10. # Modify Date: 2022-11-12 21:30
  11. # Version: v1
  12. #***************************************************************#
  13. # Initialize the machine. This needs to be executed on every machine.
  14. rm -f /var/lib/rpm/__db.00*
  15. rpm -vv --rebuilddb
  16. #yum clean all
  17. #yum makecache
  18. sleep 3s
  19. # Install containerd
  20. CONVERSION=1.6.20
  21. yum -y install yum-utils device-mapper-persistent-data lvm2
  22. yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
  23. sudo sed -i 's+download.docker.com+mirrors.aliyun.com/docker-ce+' /etc/yum.repos.d/docker-ce.repo
  24. sleep 3s
  25. yum -y install containerd.io-${CONVERSION}
  26. mkdir /etc/containerd
  28. cat > /etc/containerd/config.toml <<EOF
  29. disabled_plugins = ["restart"]
  31. [plugins.linux]
  32. shim_debug = true
  34. [plugins.cri.registry.mirrors."docker.io"]
  35. endpoint = ["https://dbzucv6w.mirror.aliyuncs.com"]
  37. [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc.options]
  38. SystemdCgroup = true
  40. [plugins.cri]
  41. sandbox_image = "registry.k8s.io/pause:3.9"
  42. EOF
  44. cat > /etc/crictl.yaml <<EOF
  45. runtime-endpoint: unix:///run/containerd/containerd.sock
  46. image-endpoint: unix:///run/containerd/containerd.sock
  47. timeout: 10
  48. debug: false
  49. EOF
  51. systemctl restart containerd
  52. systemctl enable containerd --now
  53. systemctl status containerd
  55. # Disable the SELinux.
  56. sed -i 's/^SELINUX=.*/SELINUX=disabled/' /etc/selinux/config
  58. # Turn off and disable the firewalld.
  59. systemctl stop firewalld
  60. systemctl disable firewalld
  62. # Modify related kernel parameters & Disable the swap.
  63. cat > /etc/sysctl.d/k8s.conf << EOF
  64. net.ipv4.ip_forward = 1
  65. net.bridge.bridge-nf-call-ip6tables = 1
  66. net.bridge.bridge-nf-call-iptables = 1
  67. net.ipv4.tcp_tw_recycle = 0
  68. vm.swappiness = 0
  69. vm.overcommit_memory = 1
  70. vm.panic_on_oom = 0
  71. net.ipv6.conf.all.disable_ipv6 = 1
  72. EOF
  73. sysctl -p /etc/sysctl.d/k8s.conf >&/dev/null
  74. swapoff -a
  75. sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab
  76. modprobe br_netfilter
  77. modprobe overlay
  79. # Add ipvs modules
  80. cat > /etc/sysconfig/modules/ipvs.modules <<EOF
  81. #!/bin/bash
  82. modprobe -- ip_vs
  83. modprobe -- ip_vs_rr
  84. modprobe -- ip_vs_wrr
  85. modprobe -- ip_vs_sh
  86. modprobe -- nf_conntrack_ipv4
  87. modprobe -- nf_conntrack
  88. modprobe -- br_netfilter
  89. modprobe -- overlay
  90. EOF
  92. chmod 755 /etc/sysconfig/modules/ipvs.modules
  93. bash /etc/sysconfig/modules/ipvs.modules
  95. # Install rpm
  96. yum install -y conntrack ipvsadm ipset jq iptables curl sysstat libseccomp wget iproute-tc
  98. # Update kernel
  99. # rpm --import http://down.linuxsb.com/RPM-GPG-KEY-elrepo.org
  100. # rpm -Uvh http://down.linuxsb.com/elrepo-release-7.el7.elrepo.noarch.rpm
  101. # mv -b /etc/yum.repos.d/elrepo.repo /etc/yum.repos.d/backup
  102. # wget -c http://down.linuxsb.com/myoptions/elrepo7.repo -O /etc/yum.repos.d/elrepo.repo
  103. # yum --disablerepo="*" --enablerepo="elrepo-kernel" install -y kernel-ml
  104. # sed -i 's/^GRUB_DEFAULT=.*/GRUB_DEFAULT=0/' /etc/default/grub
  105. # grub2-mkconfig -o /boot/grub2/grub.cfg
  106. # yum -y --exclude=docker* update
  108. # Reboot the machine.
  109. # reboot
复制代码
提示：如上仅需Master01节点操作，从而实现所有节点自动启动服务。
集群部署

相关组件包

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

  • kubeadm: 用来初始化集群的指令；
  • kubelet: 在集群中的每个节点上用来启动 pod 和 container 等；
  • kubectl: 用来与集群通信的命令行工具。
kubeadm不能安装或管理 kubelet 或 kubectl ，因此在初始化集群之前必须完成kubelet和kubectl的安装，且能保证他们满足通过 kubeadm 安装的 Kubernetes控制层对版本的要求。
如果版本没有满足匹配要求，可能导致一些意外错误或问题。
具体相关组件安装见；附001.kubectl介绍及使用书
提示：Kubernetes 1.27.0版本所有兼容相应组件的版本参考：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.27.0 Kubernetes版本所需镜像。
  1. [root@master01 ~]# wget https://mirrors.huaweicloud.com/haproxy/2.7/src/haproxy-2.7.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.7.6.tar.gz root@${master_ip}:/root/
  7.     ssh root@${master_ip} "tar -zxvf haproxy-2.7.6.tar.gz"
  8.     ssh root@${master_ip} "cd haproxy-2.7.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.7.6/examples/errorfiles/ /usr/local/haproxy/"
  12.   done
复制代码
Master01上初始化

Master01节点上执行初始化，即完成单节点的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"
  10.   done
复制代码
注意：如上token具有默认24小时的有效期，token和hash值可通过如下方式获取：
kubeadm token list
如果 Token 过期以后，可以输入以下命令，生成新的 Token:
  1. [root@master01 ~]# wget http://down.linuxsb.com/mydeploy/k8s/v1.27.0/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: 2023-04-12 13: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.111
  24. # master02 ip address
  25. export K8SHA_IP2=172.24.8.112
  27. # master03 ip address
  28. export K8SHA_IP3=172.24.8.113
  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/16
  54. # kubernetes CIDR svc subnet
  55. export K8SHA_SVCCIDR=10.20.0.0/16
  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. echo "create directory files success."
  69. # wget all files
  70. wget -c -P kubeadm/keepalived/ http://down.linuxsb.com/mydeploy/k8s/common/k8s-keepalived.conf.tpl
  71. wget -c -P kubeadm/keepalived/ http://down.linuxsb.com/mydeploy/k8s/common/check_apiserver.sh
  72. wget -c -P kubeadm/haproxy/ http://down.linuxsb.com/mydeploy/k8s/common/k8s-haproxy.cfg.tpl
  73. wget -c -P kubeadm/haproxy/ http://down.linuxsb.com/mydeploy/k8s/common/k8s-haproxy.service
  74. wget -c -P kubeadm/ http://down.linuxsb.com/mydeploy/k8s/v1.27.0/kubeadm-config.yaml.tpl
  75. wget -c -P kubeadm/calico/ http://down.linuxsb.com/mydeploy/k8s/calico/v3.25.1/calico.yaml.tpl
  76. wget -c -P kubeadm/ http://down.linuxsb.com/mydeploy/k8s/v1.27.0/k8simage.sh
  78. echo "down files success."
  80. # create all kubeadm-config.yaml files
  81. sed \
  82. -e "s/K8SHA_HOST1/${K8SHA_HOST1}/g" \
  83. -e "s/K8SHA_HOST2/${K8SHA_HOST2}/g" \
  84. -e "s/K8SHA_HOST3/${K8SHA_HOST3}/g" \
  85. -e "s/K8SHA_IP1/${K8SHA_IP1}/g" \
  86. -e "s/K8SHA_IP2/${K8SHA_IP2}/g" \
  87. -e "s/K8SHA_IP3/${K8SHA_IP3}/g" \
  88. -e "s/K8SHA_VIP/${K8SHA_VIP}/g" \
  89. -e "s!K8SHA_PODCIDR!${K8SHA_PODCIDR}!g" \
  90. -e "s!K8SHA_SVCCIDR!${K8SHA_SVCCIDR}!g" \
  91. kubeadm/kubeadm-config.yaml.tpl > kubeadm/kubeadm-config.yaml
  93. echo "create kubeadm-config.yaml files success."
  95. # create all keepalived files
  96. chmod u+x kubeadm/keepalived/check_apiserver.sh
  97. cp kubeadm/keepalived/check_apiserver.sh kubeadm/$K8SHA_HOST1/keepalived
  98. cp kubeadm/keepalived/check_apiserver.sh kubeadm/$K8SHA_HOST2/keepalived
  99. cp kubeadm/keepalived/check_apiserver.sh kubeadm/$K8SHA_HOST3/keepalived
  101. sed \
  102. -e "s/K8SHA_KA_STATE/BACKUP/g" \
  103. -e "s/K8SHA_KA_INTF/${K8SHA_NETINF1}/g" \
  104. -e "s/K8SHA_IPLOCAL/${K8SHA_IP1}/g" \
  105. -e "s/K8SHA_KA_PRIO/102/g" \
  106. -e "s/K8SHA_VIP/${K8SHA_VIP}/g" \
  107. -e "s/K8SHA_KA_AUTH/${K8SHA_KEEPALIVED_AUTH}/g" \
  108. kubeadm/keepalived/k8s-keepalived.conf.tpl > kubeadm/$K8SHA_HOST1/keepalived/keepalived.conf
  110. sed \
  111. -e "s/K8SHA_KA_STATE/BACKUP/g" \
  112. -e "s/K8SHA_KA_INTF/${K8SHA_NETINF2}/g" \
  113. -e "s/K8SHA_IPLOCAL/${K8SHA_IP2}/g" \
  114. -e "s/K8SHA_KA_PRIO/101/g" \
  115. -e "s/K8SHA_VIP/${K8SHA_VIP}/g" \
  116. -e "s/K8SHA_KA_AUTH/${K8SHA_KEEPALIVED_AUTH}/g" \
  117. kubeadm/keepalived/k8s-keepalived.conf.tpl > kubeadm/$K8SHA_HOST2/keepalived/keepalived.conf
  119. sed \
  120. -e "s/K8SHA_KA_STATE/BACKUP/g" \
  121. -e "s/K8SHA_KA_INTF/${K8SHA_NETINF3}/g" \
  122. -e "s/K8SHA_IPLOCAL/${K8SHA_IP3}/g" \
  123. -e "s/K8SHA_KA_PRIO/100/g" \
  124. -e "s/K8SHA_VIP/${K8SHA_VIP}/g" \
  125. -e "s/K8SHA_KA_AUTH/${K8SHA_KEEPALIVED_AUTH}/g" \
  126. kubeadm/keepalived/k8s-keepalived.conf.tpl > kubeadm/$K8SHA_HOST3/keepalived/keepalived.conf
  128. echo "create keepalived files success. kubeadm/$K8SHA_HOST1/keepalived/"
  129. echo "create keepalived files success. kubeadm/$K8SHA_HOST2/keepalived/"
  130. echo "create keepalived files success. kubeadm/$K8SHA_HOST3/keepalived/"
  132. # create all haproxy files
  133. sed \
  134. -e "s/K8SHA_IP1/$K8SHA_IP1/g" \
  135. -e "s/K8SHA_IP2/$K8SHA_IP2/g" \
  136. -e "s/K8SHA_IP3/$K8SHA_IP3/g" \
  137. -e "s/K8SHA_HOST1/$K8SHA_HOST1/g" \
  138. -e "s/K8SHA_HOST2/$K8SHA_HOST2/g" \
  139. -e "s/K8SHA_HOST3/$K8SHA_HOST3/g" \
  140. kubeadm/haproxy/k8s-haproxy.cfg.tpl > kubeadm/haproxy/haproxy.conf
  142. echo "create haproxy files success. kubeadm/$K8SHA_HOST1/haproxy/"
  143. echo "create haproxy files success. kubeadm/$K8SHA_HOST2/haproxy/"
  144. echo "create haproxy files success. kubeadm/$K8SHA_HOST3/haproxy/"
  146. # create calico yaml file
  147. sed \
  148. -e "s!K8SHA_PODCIDR!${K8SHA_PODCIDR}!g" \
  149. kubeadm/calico/calico.yaml.tpl > kubeadm/calico/calico.yaml
  151. echo "create calico file success."
  153. # scp all file
  154. scp -rp kubeadm/haproxy/haproxy.conf root@$K8SHA_HOST1:/etc/haproxy/haproxy.cfg
  155. scp -rp kubeadm/haproxy/haproxy.conf root@$K8SHA_HOST2:/etc/haproxy/haproxy.cfg
  156. scp -rp kubeadm/haproxy/haproxy.conf root@$K8SHA_HOST3:/etc/haproxy/haproxy.cfg
  157. scp -rp kubeadm/haproxy/k8s-haproxy.service root@$K8SHA_HOST1:/usr/lib/systemd/system/haproxy.service
  158. scp -rp kubeadm/haproxy/k8s-haproxy.service root@$K8SHA_HOST2:/usr/lib/systemd/system/haproxy.service
  159. scp -rp kubeadm/haproxy/k8s-haproxy.service root@$K8SHA_HOST3:/usr/lib/systemd/system/haproxy.service
  161. scp -rp kubeadm/$K8SHA_HOST1/keepalived/* root@$K8SHA_HOST1:/etc/keepalived/
  162. scp -rp kubeadm/$K8SHA_HOST2/keepalived/* root@$K8SHA_HOST2:/etc/keepalived/
  163. scp -rp kubeadm/$K8SHA_HOST3/keepalived/* root@$K8SHA_HOST3:/etc/keepalived/
  165. echo "scp haproxy & keepalived file success."
  167. # chmod *.sh
  168. 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.27.0"                                        #设置安装版本
  10. controlPlaneEndpoint: "172.24.8.100::16443"                    #设置相关API VIP地址
  11. apiServer:
  12.   certSANs:
  13.   - 127.0.0.1
  14.   - master01
  15.   - master02
  16.   - master03
  17.   - 172.24.8.111
  18.   - 172.24.8.112
  19.   - 172.24.8.113
  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: kubelet.config.k8s.io/v1beta1
  28. kind: KubeletConfiguration
  29. cgroupDriver: systemd
  31. ---
  32. apiVersion: kubeproxy.config.k8s.io/v1alpha1
  33. kind: KubeProxyConfiguration
  34. 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.111
  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. }
  33. [root@master01 ~]# cat /etc/keepalived/check_apiserver.sh              #所有节点确认相关keepalive监测脚本文件
  34. #!/bin/bash
  36. # if check error then repeat check for 12 times, else exit
  37. err=0
  38. for k in $(seq 1 12)
  39. do
  40.     check_code=$(curl -k https://localhost:6443)
  41.     if [[ $check_code == "" ]]; then
  42.         err=$(expr $err + 1)
  43.         sleep 5
  44.         continue
  45.     else
  46.         err=0
  47.         break
  48.     fi
  49. done
  51. if [[ $err != "0" ]]; then
  52.     # if apiserver is down send SIG=1
  53.     echo 'apiserver error!'
  54.     exit 1
  55. else
  56.     # if apiserver is up send SIG=0
  57.     echo 'apiserver normal!'
  58.     exit 0
  59. 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
  9. [root@master01 ~]# for all_ip in ${ALL_IPS[@]}
  10. do
  11.     echo ">>> ${all_ip}"
  12.     ssh root@${all_ip} "ping -c1 172.24.8.100"
  13. done                                                                                #等待10s执行检查
复制代码
2.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.27.0-0.x86_64 kubelet-1.27.0-0.x86_64 kubectl-1.27.0-0.x86_64 --disableexcludes=kubernetes"
  14.     ssh root@${all_ip} "systemctl enable kubelet"
  15. done
  16. [root@master01 ~]# yum search -y kubelet --showduplicates             #查看相应版本
复制代码
正式部署
  1. [root@master01 ~]# kubeadm --kubernetes-version=v1.27.0 config images list             #列出所需镜像
  3. [root@master01 ~]# vim kubeadm/k8simage.sh
  4. #!/bin/sh
  5. #****************************************************************#
  6. # ScriptName: k8simage.sh
  7. # Author: xhy
  8. # Create Date: 2023-02-10 14:47
  9. # Modify Author: xhy
  10. # Modify Date: 2023-04-13 13:57
  11. # Version:
  12. #***************************************************************#
  14. KUBE_VERSION=v1.27.0
  15. KUBE_PAUSE_VERSION=3.9
  16. ETCD_VERSION=3.5.7-0
  17. CORE_DNS_VERSION=v1.10.1
  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.25.1
  24. METRICS_SERVER_VERSION=v0.6.3
  25. INGRESS_VERSION=v1.7.0
  26. INGRESS_WEBHOOK_VERSION=v20230312-helm-chart-4.5.2-28-g66a760794
  27. LONGHORN_VERSION=v1.4.1
  28. CSI_ATTACHER_VERSION=v3.4.0
  29. CSI_NODE_DRIVER_VERSION=v2.5.0
  30. CSI_PROVISIONER_VERSION=v2.1.2
  31. CSI_RESIZER_VERSION=v1.3.0
  32. CSI_SNAP_VERSION=v0.5.1
  33. CSI_LIVE_VERSION=v2.8.0
  34. #DEFAULTBACKENDVERSION=1.5
  36. mkdir -p k8simages/
  38. # config node hostname
  39. export ALL_IPS=(master02 master03 worker01 worker02 worker03)
  41. kubeimages=(kube-proxy:${KUBE_VERSION}
  42. kube-scheduler:${KUBE_VERSION}
  43. kube-controller-manager:${KUBE_VERSION}
  44. kube-apiserver:${KUBE_VERSION}
  45. pause:${KUBE_PAUSE_VERSION}
  46. etcd:${ETCD_VERSION}
  47. )
  49. for kubeimageName in ${kubeimages[@]} ; do
  50. echo ${kubeimageName}
  51. ctr -n k8s.io images pull ${UCLOUD_URL}/${kubeimageName}
  52. ctr -n k8s.io images tag ${UCLOUD_URL}/${kubeimageName} ${K8S_URL}/${kubeimageName}
  53. ctr -n k8s.io images rm ${UCLOUD_URL}/${kubeimageName}
  54. ctr -n k8s.io images export k8simages/${kubeimageName}\.tar ${K8S_URL}/${kubeimageName}
  55. done
  57. corednsimages=(coredns:${CORE_DNS_VERSION}
  58. )
  60. for corednsimageName in ${corednsimages[@]} ; do
  61. echo ${corednsimageName}
  62. ctr -n k8s.io images pull ${UCLOUD_URL}/${corednsimageName}
  63. ctr -n k8s.io images tag ${UCLOUD_URL}/${corednsimageName} ${K8S_URL}/coredns/${corednsimageName}
  64. ctr -n k8s.io images rm ${UCLOUD_URL}/${corednsimageName}
  65. ctr -n k8s.io images export k8simages/${corednsimageName}\.tar ${K8S_URL}/coredns/${corednsimageName}
  66. done
  68. metricsimages=(metrics-server:${METRICS_SERVER_VERSION})
  70. for metricsimageName in ${metricsimages[@]} ; do
  71. echo ${metricsimageName}
  72. ctr -n k8s.io images pull ${UCLOUD_URL}/${metricsimageName}
  73. ctr -n k8s.io images tag ${UCLOUD_URL}/${metricsimageName} ${K8S_URL}/metrics-server/${metricsimageName}
  74. ctr -n k8s.io images rm ${UCLOUD_URL}/${metricsimageName}
  75. ctr -n k8s.io images export k8simages/${metricsimageName}\.tar ${K8S_URL}/metrics-server/${metricsimageName}
  76. done
  78. calimages=(cni:${CALICO_VERSION}
  79. node:${CALICO_VERSION}
  80. kube-controllers:${CALICO_VERSION})
  82. for calimageName in ${calimages[@]} ; do
  83. echo ${calimageName}
  84. ctr -n k8s.io images pull ${UCLOUD_URL}/${calimageName}
  85. ctr -n k8s.io images tag ${UCLOUD_URL}/${calimageName} ${CALICO_URL}/${calimageName}
  86. ctr -n k8s.io images rm ${UCLOUD_URL}/${calimageName}
  87. ctr -n k8s.io images export k8simages/${calimageName}\.tar ${CALICO_URL}/${calimageName}
  88. done
  90. ingressimages=(controller:${INGRESS_VERSION}
  91. kube-webhook-certgen:${INGRESS_WEBHOOK_VERSION}
  92. )
  94. for ingressimageName in ${ingressimages[@]} ; do
  95. echo ${ingressimageName}
  96. ctr -n k8s.io images pull ${UCLOUD_URL}/${ingressimageName}
  97. ctr -n k8s.io images tag ${UCLOUD_URL}/${ingressimageName} ${K8S_URL}/ingress-nginx/${ingressimageName}
  98. ctr -n k8s.io images rm ${UCLOUD_URL}/${ingressimageName}
  99. ctr -n k8s.io images export k8simages/${ingressimageName}\.tar ${K8S_URL}/ingress-nginx/${ingressimageName}
  100. done
  102. longhornimages01=(longhorn-engine:${LONGHORN_VERSION}
  103. longhorn-instance-manager:${LONGHORN_VERSION}
  104. longhorn-manager:${LONGHORN_VERSION}
  105. longhorn-ui:${LONGHORN_VERSION}
  106. )
  108. for longhornimageNameA in ${longhornimages01[@]} ; do
  109. echo ${longhornimageNameA}
  110. ctr -n k8s.io images pull ${UCLOUD_URL}/${longhornimageNameA}
  111. ctr -n k8s.io images tag ${UCLOUD_URL}/${longhornimageNameA} ${LONGHORN_URL}/${longhornimageNameA}
  112. ctr -n k8s.io images rm ${UCLOUD_URL}/${longhornimageNameA}
  113. ctr -n k8s.io images export k8simages/${longhornimageNameA}\.tar ${LONGHORN_URL}/${longhornimageNameA}
  114. done
  116. csiimages=(csi-attacher:${CSI_ATTACHER_VERSION}
  117. csi-node-driver-registrar:${CSI_NODE_DRIVER_VERSION}
  118. csi-provisioner:${CSI_PROVISIONER_VERSION}
  119. csi-resizer:${CSI_RESIZER_VERSION}
  120. csi-snapshotter:${CSI_SNAP_VERSION}
  121. livenessprobe:${CSI_LIVE_VERSION}
  122. )
  124. for csiimageName in ${csiimages[@]} ; do
  125. echo ${csiimageName}
  126. ctr -n k8s.io images pull ${UCLOUD_URL}/${csiimageName}
  127. ctr -n k8s.io images tag ${UCLOUD_URL}/${csiimageName} ${LONGHORN_URL}/${csiimageName}
  128. ctr -n k8s.io images rm ${UCLOUD_URL}/${csiimageName}
  129. ctr -n k8s.io images export k8simages/${csiimageName}\.tar ${LONGHORN_URL}/${csiimageName}
  130. done
  132. #otherimages=(defaultbackend-amd64:${DEFAULTBACKENDVERSION})
  134. #for otherimagesName in ${otherimages[@]} ; do
  135. #echo ${otherimagesName}
  136. #ctr -n k8s.io images pull ${UCLOUD_URL}/${otherimagesName}
  137. #ctr -n k8s.io images tag ${UCLOUD_URL}/${otherimagesName} ${K8S_URL}/${otherimagesName}
  138. #ctr -n k8s.io images rm ${UCLOUD_URL}/${otherimagesName}
  139. #ctr -n k8s.io images export k8simages/${otherimagesName}\.tar ${K8S_URL}/${otherimagesName}
  140. #done
  141. #
  143. allimages=(kube-proxy:${KUBE_VERSION}
  144. kube-scheduler:${KUBE_VERSION}
  145. kube-controller-manager:${KUBE_VERSION}
  146. kube-apiserver:${KUBE_VERSION}
  147. pause:${KUBE_PAUSE_VERSION}
  148. etcd:${ETCD_VERSION}
  149. coredns:${CORE_DNS_VERSION}
  150. metrics-server:${METRICS_SERVER_VERSION}
  151. cni:${CALICO_VERSION}
  152. node:${CALICO_VERSION}
  153. kube-controllers:${CALICO_VERSION}
  154. controller:${INGRESS_VERSION}
  155. kube-webhook-certgen:${INGRESS_WEBHOOK_VERSION}
  156. longhorn-manager:${LONGHORN1_VERSION}
  157. longhorn-ui:${LONGHORN1_VERSION}
  158. longhorn-engine:${LONGHORN1_VERSION}
  159. longhorn-instance-manager:${LONGHORN2_VERSION}
  160. backing-image-manager:${LONGHORN3_VERSION}
  161. longhorn-share-manager:${LONGHORN4_VERSION}
  162. csi-attacher:${CSI_ATTACHER_VERSION}
  163. csi-node-driver-registrar:${CSI_NODE_DRIVER_VERSION}
  164. csi-provisioner:${CSI_PROVISIONER_VERSION}
  165. csi-resizer:${CSI_RESIZER_VERSION}
  166. csi-snapshotter:${CSI_SNAP_VERSION}
  167. livenessprobe:${CSI_LIVE_VERSION}
  168. )
  170. for all_ip in ${ALL_IPS[@]}
  171.   do  
  172.     echo ">>> ${all_ip}"
  173.     ssh root@${all_ip} "mkdir /root/k8simages"
  174.     scp -rp k8simages/* root@${all_ip}:/root/k8simages/
  175.   done
  177. for allimageName in ${allimages[@]}
  178.   do
  179.   for all_ip in ${ALL_IPS[@]}
  180.     do
  181.     echo "${allimageName} copy to ${all_ip}"
  182.     ssh root@${all_ip} "ctr -n k8s.io images import k8simages/${allimageName}\.tar"
  183.     done
  184.   done
  186. [root@master01 ~]# bash kubeadm/k8simage.sh                     #确认版本，提前下载镜像
复制代码
查看资源监控

可使用kubectl top查看相关监控项。
  1. [root@master01 ~]# ctr -n k8s.io images ls                #确认验证
  2. [root@master01 ~]# crictl images ls
  3. IMAGE                                                TAG                                        IMAGE ID            SIZE
  4. docker.io/calico/cni                                 v3.25.1                                    a0138614e6094       89.9MB
  5. docker.io/calico/kube-controllers                    v3.25.1                                    212faac284a2e       31.9MB
  6. docker.io/calico/node                                v3.25.1                                    cae61b85e9b45       88.3MB
  7. docker.io/longhornio/csi-attacher                    v3.4.0                                     03e115718d258       22.1MB
  8. docker.io/longhornio/csi-node-driver-registrar       v2.5.0                                     cb03930a2bd42       9.13MB
  9. docker.io/longhornio/csi-provisioner                 v2.1.2                                     0f0a0f7990768       21.2MB
  10. docker.io/longhornio/csi-resizer                     v1.3.0                                     1df30f0e25552       21.7MB
  11. docker.io/longhornio/livenessprobe                   v2.8.0                                     e899260153aed       8.89MB
  12. docker.io/longhornio/longhorn-engine                 v1.4.1                                     e1cd5c6b473d2       266MB
  13. docker.io/longhornio/longhorn-instance-manager       v1.4.1                                     f381931e27872       265MB
  14. docker.io/longhornio/longhorn-manager                v1.4.1                                     0fdcf16dfd364       98.1MB
  15. docker.io/longhornio/longhorn-ui                     v1.4.1                                     ea6c5d6d2455f       72.1MB
  16. registry.k8s.io/coredns/coredns                      v1.10.1                                    ead0a4a53df89       16.2MB
  17. registry.k8s.io/etcd                                 3.5.7-0                                    86b6af7dd652c       102MB
  18. registry.k8s.io/ingress-nginx/controller             v1.7.0                                     0d4c0564c4658       114MB
  19. registry.k8s.io/ingress-nginx/kube-webhook-certgen   v20230312-helm-chart-4.5.2-28-g66a760794   5a86b03a88d23       20.1MB
  20. registry.k8s.io/kube-apiserver                       v1.27.0                                    6f707f569b572       33.4MB
  21. registry.k8s.io/kube-controller-manager              v1.27.0                                    95fe52ed44570       31MB
  22. registry.k8s.io/kube-proxy                           v1.27.0                                    5f82fc39fa816       23.9MB
  23. registry.k8s.io/kube-scheduler                       v1.27.0                                    f73f1b39c3fe8       18.2MB
  24. registry.k8s.io/metrics-server/metrics-server        v0.6.3                                     817bbe3f2e517       29.9MB
  25. registry.k8s.io/pause                                3.9                                        e6f1816883972       319kB
复制代码
3.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层路由的架构：
4.png

设置标签

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

获取部署所需的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
  4. [root@master01 ~]# cat << EOF >> ~/.bashrc
  5. export KUBECONFIG=$HOME/.kube/config
  6. EOF                                                                                 #设置KUBECONFIG环境变量
  7. [root@master01 ~]# echo "source <(kubectl completion bash)" >> ~/.bashrc
  8. [root@master01 ~]# source ~/.bashrc
复制代码
提示：添加默认backend需要等待default-backend创建完成controllers才能成功部署，新版本ingress不再推荐添加default backend。
确认验证

查看Pod部署进度，是否成功完成。
  1. [root@master02 ~]# kubeadm join 172.24.8.100:16443 --token qufm6a.wqfp28gl9xy631ff \
  2.         --discovery-token-ca-cert-hash sha256:d21e46173c24c4dc8e6b5f926997070537ab36da68824f1d92e9724cc58b2de0 \
  3.         --control-plane --certificate-key 5cdfc8b55a148ba551727be93266522c34e83328faa8bcb4d57fde68ca56e0e3
  4. [root@master02 ~]# mkdir -p $HOME/.kube
  5. [root@master02 ~]# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  6. [root@master02 ~]# sudo chown $(id -u):$(id -g) $HOME/.kube/config
  7. [root@master02 ~]# cat << EOF >> ~/.bashrc
  8. export KUBECONFIG=$HOME/.kube/config
  9. EOF                                                                                                                   #设置KUBECONFIG环境变量
  10. [root@master02 ~]# echo "source <(kubectl completion bash)" >> ~/.bashrc
  11. [root@master02 ~]# source ~/.bashrc
复制代码
5.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. ……
  13. [root@master01 ~]# kubectl apply -f kubeadm/calico/calico.yaml
  14. [root@master01 ~]# kubectl get pods --all-namespaces -o wide                #查看部署的所有Pod
  15. NAMESPACE     NAME                                       READY   STATUS    RESTARTS       AGE     IP             NODE       NOMINATED NODE   READINESS GATES
  16. kube-system   calico-kube-controllers-674fff74c8-grp94   1/1     Running   0              55s     10.10.59.193   master02   <none>           <none>
  17. kube-system   calico-node-8gs4l                          1/1     Running   0              55s     172.24.8.113   master03   <none>           <none>
  18. kube-system   calico-node-gvwwx                          1/1     Running   0              55s     172.24.8.112   master02   <none>           <none>
  19. kube-system   calico-node-k8vxv                          1/1     Running   0              55s     172.24.8.111   master01   <none>           <none>
  20. kube-system   coredns-5d78c9869d-9s2dv                   1/1     Running   0              3m20s   10.10.59.194   master02   <none>           <none>
  21. kube-system   coredns-5d78c9869d-bxp4z                   1/1     Running   0              3m20s   10.10.59.195   master02   <none>           <none>
  22. kube-system   etcd-master01                              1/1     Running   0              3m33s   172.24.8.111   master01   <none>           <none>
  23. kube-system   etcd-master02                              1/1     Running   0              113s    172.24.8.112   master02   <none>           <none>
  24. kube-system   etcd-master03                              1/1     Running   0              93s     172.24.8.113   master03   <none>           <none>
  25. kube-system   kube-apiserver-master01                    1/1     Running   0              3m34s   172.24.8.111   master01   <none>           <none>
  26. kube-system   kube-apiserver-master02                    1/1     Running   0              113s    172.24.8.112   master02   <none>           <none>
  27. kube-system   kube-apiserver-master03                    1/1     Running   0              92s     172.24.8.113   master03   <none>           <none>
  28. kube-system   kube-controller-manager-master01           1/1     Running   0              3m33s   172.24.8.111   master01   <none>           <none>
  29. kube-system   kube-controller-manager-master02           1/1     Running   0              105s    172.24.8.112   master02   <none>           <none>
  30. kube-system   kube-controller-manager-master03           1/1     Running   0              97s     172.24.8.113   master03   <none>           <none>
  31. kube-system   kube-proxy-6hwzb                           1/1     Running   0              68s     172.24.8.113   master03   <none>           <none>
  32. kube-system   kube-proxy-sx5b7                           1/1     Running   0              114s    172.24.8.112   master02   <none>           <none>
  33. kube-system   kube-proxy-ww744                           1/1     Running   0              3m20s   172.24.8.111   master01   <none>           <none>
  34. kube-system   kube-scheduler-master01                    1/1     Running   0              3m33s   172.24.8.111   master01   <none>           <none>
  35. kube-system   kube-scheduler-master02                    1/1     Running   0              97s     172.24.8.112   master02   <none>           <none>
  36. kube-system   kube-scheduler-master03                    1/1     Running   0              90s     172.24.8.113   master03   <none>           <none>
  38. [root@master01 ~]# kubectl get nodes
  39. NAME       STATUS   ROLES           AGE     VERSION
  40. master01   Ready    control-plane   3m37s   v1.27.0
  41. master02   Ready    control-plane   117s    v1.27.0
  42. master03   Ready    control-plane   116s    v1.27.0
复制代码
提示：建议对于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
  2. [root@master01 ~]# for node_ip in ${NODE_IPS[@]}
  3.   do
  4.     echo ">>> ${node_ip}"
  5.     ssh root@${node_ip} "kubeadm join 172.24.8.100:16443 --token qufm6a.wqfp28gl9xy631ff \
  6.     --discovery-token-ca-cert-hash sha256:d21e46173c24c4dc8e6b5f926997070537ab36da68824f1d92e9724cc58b2de0"
  7.     ssh root@${node_ip} "systemctl enable kubelet.service"
  8.   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/
复制代码
提示：官方参考：https://github.com/kubernetes/dashboard 。
修改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
  5. [root@master01 metrics]# vi components.yaml
  6. ……
  7. apiVersion: apps/v1
  8. kind: Deployment
  9. ……
  10. spec:
  11.   replicas: 3                                                                                                                            #根据集群规模调整副本数
  12.     ……
  13.     spec:
  14.       hostNetwork: true
  15.       containers:
  16.       - args:
  17.         - --cert-dir=/tmp
  18.         - --secure-port=4443
  19.         - --kubelet-insecure-tls                                                                                            #追加此args
  20.         - --kubelet-preferred-address-types=InternalIP,ExternalIP,Hostname,InternalDNS,ExternalDNS          #追加此args
  21.         - --kubelet-use-node-status-port
  22.         - --metric-resolution=15s
  23.         image: k8s.gcr.io/metrics-server/metrics-server:v0.6.1
  24.         imagePullPolicy: IfNotPresent
  25.     ……
复制代码
6.png

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

建议创建管理员账户，dashboard v2版本默认没有创建具有管理员权限的账户，同时登录可以选择kubeconfig以及token，通常使用kubeconfig比较方便。
在创建管理员用户后，将用户相关信息配置成kubeconfig文件，即可实现快速登录dashboard。
[code][root@master01 dashboard]# cat

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
能拘
2025-6-1 21:05:33

0

粉丝关注

15

主题发布

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