k8s_1.34.0二进制版-高可用安装教程 支持IPv4+IPv6双栈（3master2node Rocky-Linux-10）
https://chuna2.787528.xyz/chenby/p/19066823 —— 参考链接（calico的IPv6地址配置错误，需要注意）
相关效果图：
kubectl get leases -n kube-system
允许一台节点宕机：
0、环境简介
|
主机名称
|
IP地址
|
说明
|
软件
|
|
Master01
|
192.168.123.111
|
master节点
|
kube-apiserver、kube-controller-manager、kube-scheduler、etcd、
kubelet、kube-proxy、nfs-client、haproxy、keepalived、nginx
|
|
Master02
|
192.168.123.112
|
master节点
|
kube-apiserver、kube-controller-manager、kube-scheduler、etcd、
kubelet、kube-proxy、nfs-client、haproxy、keepalived、nginx
|
|
Master03
|
192.168.123.113
|
master节点
|
kube-apiserver、kube-controller-manager、kube-scheduler、etcd、
kubelet、kube-proxy、nfs-client、haproxy、keepalived、nginx
|
|
Node01
|
192.168.123.114
|
node节点
|
kubelet、kube-proxy、nfs-client、nginx
|
|
Node02
|
192.168.123.115
|
node节点
|
kubelet、kube-proxy、nfs-client、nginx
|
|
192.168.123.117
|
VIP
|
网段
IPv4
物理（虚拟）主机：192.168.123.0/24
service：10.96.0.0/12
pod：172.16.0.0/12
IPv6
物理主机：2408:822a:732:5ce1::1001/64（虚拟机没有这一项）
物理主机：fc00::31/8
service：fd00:1111::/112
pod：fc00:2222::/112
感谢参考链接开源的离线安装包，直接下载参考使用：https://github.com/-chen/Kubernetes/releases/download/v1.34.0/kubernetes-v1.34.0.tar
1、k8s基础系统环境配置
配置IP
1 # 注意！ 2 # 若虚拟机是进行克隆的那么网卡的UUID和MachineID会重复 3 # 需要重新生成新的UUIDUUID和MachineID 4 # UUID和MachineID重复无法DHCP获取到IPV6地址 5 ssh root@192.168.123.111 "rm -rf /etc/machine-id; systemd-machine-id-setup;reboot" 6 ssh root@192.168.123.112 "rm -rf /etc/machine-id; systemd-machine-id-setup;reboot" 7 ssh root@192.168.123.113 "rm -rf /etc/machine-id; systemd-machine-id-setup;reboot" 8 ssh root@192.168.123.114 "rm -rf /etc/machine-id; systemd-machine-id-setup;reboot" 9 ssh root@192.168.123.115 "rm -rf /etc/machine-id; systemd-machine-id-setup;reboot" 10 # 11 # 查看当前的网卡列表和 UUID： 12 # nmcli con show 13 # 删除要更改 UUID 的网络连接： 14 # nmcli con delete uuid <原 UUID> 15 # 重新生成 UUID： 16 # nmcli con add type ethernet ifname <接口名称> con-name <新名称> 17 # 重新启用网络连接： 18 # nmcli con up <新名称> 19 20 # 更改网卡的UUID 21 # 先配置静态IP之后使用ssh方式配置不断连 22 ssh root@192.168.123.111 "nmcli con delete uuid d1141403-18c6-3149-907c-ed5f09663a7f;nmcli con add type ethernet ifname ens160 con-name ens160;nmcli con up ens160" 23 ssh root@192.168.123.112 "nmcli con delete uuid d1141403-18c6-3149-907c-ed5f09663a7f;nmcli con add type ethernet ifname ens160 con-name ens160;nmcli con up ens160" 24 ssh root@192.168.123.113 "nmcli con delete uuid d1141403-18c6-3149-907c-ed5f09663a7f;nmcli con add type ethernet ifname ens160 con-name ens160;nmcli con up ens160" 25 ssh root@192.168.123.114 "nmcli con delete uuid d1141403-18c6-3149-907c-ed5f09663a7f;nmcli con add type ethernet ifname ens160 con-name ens160;nmcli con up ens160" 26 ssh root@192.168.123.115 "nmcli con delete uuid d1141403-18c6-3149-907c-ed5f09663a7f;nmcli con add type ethernet ifname ens160 con-name ens160;nmcli con up ens160" 27 28 # 参数解释 29 # ssh ssh root@192.168.123.111 30 # 使用SSH登录到IP为192.168.123.111的主机，使用root用户身份。 31 # nmcli con delete uuid 708a1497-2192-43a5-9f03-2ab936fb3c44 32 # 删除 UUID 为 708a1497-2192-43a5-9f03-2ab936fb3c44 的网络连接，这是 NetworkManager 中一种特定网络配置的唯一标识符。 33 # nmcli con add type ethernet ifname ens160 con-name ens160 34 # 添加一种以太网连接类型，并指定接口名为 ens160，连接名称也为 ens160。 35 # nmcli con up ens160 36 # 开启 ens160 这个网络连接。 37 # 简单来说，这个命令的作用是删除一个特定的网络连接配置，并添加一个名为 ens160 的以太网连接，然后启用这个新的连接。 38 39 # 修改静态的IPv4地址 40 ssh root@192.168.123.111 "nmcli con mod ens160 ipv4.addresses 192.168.123.111/24; nmcli con mod ens160 ipv4.gateway 192.168.123.1; nmcli con mod ens160 ipv4.method manual; nmcli con mod ens160 ipv4.dns "8.8.8.8"; nmcli con up ens160" 41 ssh root@192.168.123.112 "nmcli con mod ens160 ipv4.addresses 192.168.123.112/24; nmcli con mod ens160 ipv4.gateway 192.168.123.1; nmcli con mod ens160 ipv4.method manual; nmcli con mod ens160 ipv4.dns "8.8.8.8"; nmcli con up ens160" 42 ssh root@192.168.123.113 "nmcli con mod ens160 ipv4.addresses 192.168.123.113/24; nmcli con mod ens160 ipv4.gateway 192.168.123.1; nmcli con mod ens160 ipv4.method manual; nmcli con mod ens160 ipv4.dns "8.8.8.8"; nmcli con up ens160" 43 ssh root@192.168.123.114 "nmcli con mod ens160 ipv4.addresses 192.168.123.114/24; nmcli con mod ens160 ipv4.gateway 192.168.123.1; nmcli con mod ens160 ipv4.method manual; nmcli con mod ens160 ipv4.dns "8.8.8.8"; nmcli con up ens160" 44 ssh root@192.168.123.115 "nmcli con mod ens160 ipv4.addresses 192.168.123.115/24; nmcli con mod ens160 ipv4.gateway 192.168.123.1; nmcli con mod ens160 ipv4.method manual; nmcli con mod ens160 ipv4.dns "8.8.8.8"; nmcli con up ens160" 45 46 # 参数解释 47 # ssh root@192.168.123.154 48 # 使用SSH登录到IP为192.168.123.154的主机，使用root用户身份。 49 # "nmcli con mod ens160 ipv4.addresses 192.168.123.111/24" 50 # 修改ens160网络连接的IPv4地址为192.168.123.111，子网掩码为 24。 51 # "nmcli con mod ens160 ipv4.gateway 192.168.123.1" 52 # 修改ens160网络连接的IPv4网关为192.168.123.1。 53 # "nmcli con mod ens160 ipv4.method manual" 54 # 将ens160网络连接的IPv4配置方法设置为手动。 55 # "nmcli con mod ens160 ipv4.dns "8.8.8.8" 56 # 将ens160网络连接的IPv4 DNS服务器设置为 8.8.8.8。 57 # "nmcli con up ens160" 58 # 启动ens160网络连接。 59 # 总体来说，这条命令是通过SSH远程登录到指定的主机，并使用网络管理命令 (nmcli) 修改ens160网络连接的配置，包括IP地址、网关、配置方法和DNS服务器，并启动该网络连接。 60 61 # 我这里有公网的IPv6的地址，但是是DHCP动态的，无法固定，使用不方便 62 # 所以我配置了内网的IPv6地址，可以实现固定的访问地址 63 64 # 我使用的方式。只配置IPv6地址不配置网关DNS 65 ssh root@192.168.123.111 "nmcli con mod ens160 ipv6.addresses fc00::31/8; nmcli con up ens160" 66 ssh root@192.168.123.112 "nmcli con mod ens160 ipv6.addresses fc00::32/8; nmcli con up ens160" 67 ssh root@192.168.123.113 "nmcli con mod ens160 ipv6.addresses fc00::33/8; nmcli con up ens160" 68 ssh root@192.168.123.114 "nmcli con mod ens160 ipv6.addresses fc00::34/8; nmcli con up ens160" 69 ssh root@192.168.123.115 "nmcli con mod ens160 ipv6.addresses fc00::35/8; nmcli con up ens160" 70 71 # IPv6地址路由DNS，样例 72 ssh root@192.168.123.111 "nmcli con mod ens160 ipv6.addresses fc00:43f4:1eea:1::10; nmcli con mod ens160 ipv6.gateway fc00:43f4:1eea:1::1; nmcli con mod ens160 ipv6.method manual; nmcli con mod ens160 ipv6.dns "2400:3200::1"; nmcli con up ens160" 73 ssh root@192.168.123.112 "nmcli con mod ens160 ipv6.addresses fc00:43f4:1eea:1::20; nmcli con mod ens160 ipv6.gateway fc00:43f4:1eea:1::1; nmcli con mod ens160 ipv6.method manual; nmcli con mod ens160 ipv6.dns "2400:3200::1"; nmcli con up ens160" 74 ssh root@192.168.123.113 "nmcli con mod ens160 ipv6.addresses fc00:43f4:1eea:1::30; nmcli con mod ens160 ipv6.gateway fc00:43f4:1eea:1::1; nmcli con mod ens160 ipv6.method manual; nmcli con mod ens160 ipv6.dns "2400:3200::1"; nmcli con up ens160" 75 ssh root@192.168.123.114 "nmcli con mod ens160 ipv6.addresses fc00:43f4:1eea:1::40; nmcli con mod ens160 ipv6.gateway fc00:43f4:1eea:1::1; nmcli con mod ens160 ipv6.method manual; nmcli con mod ens160 ipv6.dns "2400:3200::1"; nmcli con up ens160" 76 ssh root@192.168.123.115 "nmcli con mod ens160 ipv6.addresses fc00:43f4:1eea:1::50; nmcli con mod ens160 ipv6.gateway fc00:43f4:1eea:1::1; nmcli con mod ens160 ipv6.method manual; nmcli con mod ens160 ipv6.dns "2400:3200::1"; nmcli con up ens160" 77 78 # 参数解释 79 # ssh root@192.168.123.111 80 # 通过SSH连接到IP地址为192.168.123.111的远程主机，使用root用户进行登录。 81 # "nmcli con mod ens160 ipv6.addresses fc00:43f4:1eea:1::10" 82 # 使用nmcli命令修改ens160接口的IPv6地址为fc00:43f4:1eea:1::10。 83 # "nmcli con mod ens160 ipv6.gateway fc00:43f4:1eea:1::1" 84 # 使用nmcli命令修改ens160接口的IPv6网关为fc00:43f4:1eea:1::1。 85 # "nmcli con mod ens160 ipv6.method manual" 86 # 使用nmcli命令将ens160接口的IPv6配置方法修改为手动配置。 87 # "nmcli con mod ens160 ipv6.dns "2400:3200::1" 88 # 使用nmcli命令设置ens160接口的IPv6 DNS服务器为2400:3200::1。 89 # "nmcli con up ens160" 90 # 使用nmcli命令启动ens160接口。 91 # 这个命令的目的是在远程主机上配置ens160接口的IPv6地址、网关、配置方法和DNS服务器，并启动ens160接口。 92 93 # 查看网卡配置 94 # nmcli device show ens160 95 [root@192 ~]# nmcli device show ens160 96 GENERAL.DEVICE: ens160 97 GENERAL.TYPE: ethernet 98 GENERAL.HWADDR: 00:0C:29:47:2B:21 99 GENERAL.MTU: 1500 100 GENERAL.STATE: 100（已连接） 101 GENERAL.CONNECTION: ens160 102 GENERAL.CON-PATH: /org/freedesktop/NetworkManager/ActiveConnection/2 103 WIRED-PROPERTIES.CARRIER: 开 104 IP4.ADDRESS[1]: 192.168.123.111/24 105 IP4.GATEWAY: 192.168.123.2 106 IP4.ROUTE[1]: dst = 0.0.0.0/0, nh = 192.168.123.2, mt = 100 107 IP4.ROUTE[2]: dst = 192.168.123.0/24, nh = 0.0.0.0, mt = 100 108 IP4.DNS[1]: 192.168.123.2 109 IP6.ADDRESS[1]: fc00::31/8 110 IP6.ADDRESS[2]: fc00::20c:29ff:fe47:2b21/64 111 IP6.ADDRESS[3]: fe80::20c:29ff:fe47:2b21/64 112 # nmcli con show ens160 113 [root@192 ~]# cat /etc/NetworkManager/system-connections/ens160.nmconnection 114 [connection] 115 id=ens160 116 uuid=da1b24dc-4d65-3e5a-a2e8-c1d6fbfeb5d2 117 type=ethernet 118 autoconnect-priority=-999 119 interface-name=ens160 120 timestamp=1760273455 121 122 [ethernet] 123 124 [ipv4] 125 address1=192.168.123.111/24 126 dns=192.168.123.2; 127 gateway=192.168.123.2 128 method=manual 129 130 [ipv6] 131 addr-gen-mode=eui64 132 address1=fc00::31/8 133 method=auto 134 135 [proxy] 137 # 参数解释 138 # 1. `[connection]`: 139 # - `id`: 连接的唯一标识符，用于内部引用。 140 # - `uuid`: 连接的通用唯一标识符（UUID），确保在系统中的唯一性。 141 # - `type`: 指定连接的类型，本例中为以太网。 142 # - `interface-name`: 网络接口的名称（`ens160`），表示与此连接关联的物理或逻辑网络接口。 143 # - `timestamp`: 时间戳，指示连接配置上次修改的时间。 144 # 2. `[ethernet]`: 145 # - 通常包含以太网特定的配置设置，如MAC地址或链路速度。 146 # 3. `[ipv4]`: 147 # - `address1`: 以CIDR表示法指定IPv4地址和子网掩码（`192.168.123.111/24`）。还包括网关IP（`192.168.123.1`）。 148 # - `dns`: 指定要使用的DNS服务器（本例中为`8.8.8.8`），提供将域名转换为IP地址的手段。 149 # - `method`: 指定获取IPv4地址的方法。在本例中，设置为手动，表示IP地址是静态配置的。 150 # 4. `[ipv6]`: 151 # - `addr-gen-mode`: 指定IPv6地址生成模式。设置为默认，通常意味着地址是根据接口的MAC地址生成的。 152 # - `method`: 指定获取IPv6地址的方法。在本例中，设置为自动，表示使用DHCPv6或SLAAC等协议进行自动配置。 153 # 5. `[proxy]`: 154 # - 通常用于配置代理设置，如HTTP或SOCKS代理。
设置主机名
1 hostnamectl set-hostname k8s-master01 2 hostnamectl set-hostname k8s-master02 3 hostnamectl set-hostname k8s-master03 4 hostnamectl set-hostname k8s-node01 5 hostnamectl set-hostname k8s-node02 6 7 # 参数解释 8 # 参数: set-hostname 9 # 解释: 这是hostnamectl命令的一个参数，用于设置系统的主机名。 10 # 参数: k8s-master01 11 # 解释: 这是要设置的主机名，将系统的主机名设置为"k8s-master01"。
配置yum源<可忽略，安装系统后，若是通过yum安装软件失败，可自行替换国内的软件源。>
安装一些必备工具
1 # 对于 Ubuntu 2 apt update && apt upgrade -y && apt install -y wget psmisc vim net-tools nfs-kernel-server telnet lvm2 git tar curl sshpass bash-completion 3 # 对于 CentOS系列的发行版 4 yum update -y && yum -y install wget psmisc vim net-tools nfs-utils telnet yum-utils device-mapper-persistent-data lvm2 git tar curl sshpass bash-completion
选择性下载需要工具<忽略，使用离线包即可>
1 # 查看版本地址： 2 # https://github.com/containernetworking/plugins/releases/ 3 # https://github.com/containerd/containerd/releases/ 4 # https://github.com/kubernetes-sigs/cri-tools/releases/ 5 # https://github.com/Mirantis/cri-dockerd/releases/ 6 # https://github.com/etcd-io/etcd/releases/ 7 # https://github.com/cloudflare/cfssl/releases/ 8 # https://github.com/kubernetes/kubernetes/tree/master/CHANGELOG 9 # https://download.docker.com/linux/static/stable/x86_64/ 10 # https://github.com/opencontainers/runc/releases/ 11 # https://github.com/helm/helm/tags 12 # http://nginx.org/download/
关闭防火墙[生产环境不允许关闭防火墙]
#CentOS执行：
systemctl disable --now firewalld
## 生产环境：开通对应的网段，添加到trust区域（Pod 网络，Service 网络，主机节点网络） ## 命令示意 firewall-cmd --permanent --zone=trusted --add-source=192.168.123.0/24 # 若需要单独开放端口，参考此命令 firewall-cmd --permanent --zone=public --add-port=6443/tcp firewall-cmd --reload firewall-cmd --zone=trusted --list-all-zones
关闭SELinux
# CentOS执行 setenforce 0 sed -i 's#SELINUX=enforcing#SELINUX=disabled#g' /etc/selinux/config
关闭交换分区
1 sed -ri 's/.*swap.*/#&/' /etc/fstab 2 swapoff -a && sysctl -w vm.swappiness=0 3 4 cat /etc/fstab 5 # /dev/mapper/centos-swap swap swap defaults 0 0 6 7 # 参数解释： 8 # -ri: 这个参数用于在原文件中替换匹配的模式。-r表示扩展正则表达式，-i允许直接修改文件。 9 # 's/.*swap.*/#&/': 这是一个sed命令，用于在文件/etc/fstab中找到包含swap的行，并在行首添加#来注释掉该行。 10 # /etc/fstab: 这是一个文件路径，即/etc/fstab文件，用于存储文件系统表。 11 # swapoff -a: 这个命令用于关闭所有启用的交换分区。 12 # sysctl -w vm.swappiness=0: 这个命令用于修改vm.swappiness参数的值为0，表示系统在物理内存充足时更倾向于使用物理内存而非交换分区。
网络配置（俩种方式二选一）
1 # Ubuntu忽略，CentOS执行，CentOS9不支持方式一 2 3 # 方式一 4 # systemctl disable --now NetworkManager 5 # systemctl start network && systemctl enable network 6 7 # 方式二 8 cat > /etc/NetworkManager/conf.d/calico.conf << EOF 9 [keyfile] 10 unmanaged-devices=interface-name:cali*;interface-name:tunl* 11 EOF 12 systemctl restart NetworkManager 13 14 # 参数解释 15 # 这个参数用于指定不由 NetworkManager 管理的设备。它由以下两个部分组成 16 # interface-name:cali* 17 # 表示以 "cali" 开头的接口名称被排除在 NetworkManager 管理之外。例如，"cali0", "cali1" 等接口不受 NetworkManager 管理。 18 # interface-name:tunl* 19 # 表示以 "tunl" 开头的接口名称被排除在 NetworkManager 管理之外。例如，"tunl0", "tunl1" 等接口不受 NetworkManager 管理。 20 # 通过使用这个参数，可以将特定的接口排除在 NetworkManager 的管理范围之外，以便其他工具或进程可以独立地管理和配置这些接口。
进行时间同步
# 服务端<可选择master节点作为服务端> # apt install chrony -y yum install chrony -y cat > /etc/chrony.conf << EOF pool ntp.aliyun.com iburst driftfile /var/lib/chrony/drift makestep 1.0 3 rtcsync allow 192.168.123.0/24 local stratum 10 keyfile /etc/chrony.keys leapsectz right/UTC logdir /var/log/chrony EOF systemctl restart chronyd ; systemctl enable chronyd # 客户端 # apt install chrony -y yum install chrony -y cat > /etc/chrony.conf << EOF pool 192.168.123.122 iburst driftfile /var/lib/chrony/drift makestep 1.0 3 rtcsync keyfile /etc/chrony.keys leapsectz right/UTC logdir /var/log/chrony EOF systemctl restart chronyd ; systemctl enable chronyd #使用客户端进行验证 chronyc sources -v # 参数解释 # pool ntp.aliyun.com iburst # 指定使用ntp.aliyun.com作为时间服务器池，iburst选项表示在初始同步时会发送多个请求以加快同步速度。 # driftfile /var/lib/chrony/drift # 指定用于保存时钟漂移信息的文件路径。 # makestep 1.0 3 # 设置当系统时间与服务器时间偏差大于1秒时，会以1秒的步长进行调整。如果偏差超过3秒，则立即进行时间调整。 # rtcsync # 启用硬件时钟同步功能，可以提高时钟的准确性。 # allow 192.168.0.0/24 # 允许192.168.0.0/24网段范围内的主机与chrony进行时间同步。 # local stratum 10 # 将本地时钟设为stratum 10，stratum值表示时钟的准确度，值越小表示准确度越高。 # keyfile /etc/chrony.keys # 指定使用的密钥文件路径，用于对时间同步进行身份验证。 # leapsectz right/UTC # 指定时区为UTC。 # logdir /var/log/chrony # 指定日志文件存放目录。
配置ulimit
ulimit -SHn 65535 cat >> /etc/security/limits.conf <<EOF * soft nofile 65535 * hard nofile 65535 * soft nproc 65535 * hard nproc 65535 * soft memlock unlimited * hard memlock unlimited EOF # 参数解释 # soft nofile 65535 # soft表示软限制，nofile表示一个进程可打开的最大文件数，默认值为1024。这里的软限制设置为65535，即一个进程可打开的最大文件数为65535。 # hard nofile 65535 # hard表示硬限制，即系统设置的最大值。nofile表示一个进程可打开的最大文件数，默认值为4096。这里的硬限制设置为65535，即系统设置的最大文件数为65535。 # soft nproc 65535 # soft表示软限制，nproc表示一个用户可创建的最大进程数，默认值为30720。这里的软限制设置为65535，即一个用户可创建的最大进程数为65535。 # hard nproc 65535 # hard表示硬限制，即系统设置的最大值。nproc表示一个用户可创建的最大进程数，默认值为4096。这里的硬限制设置为65535，即系统设置的最大进程数为65535。 # seft memlock unlimited # seft表示软限制，memlock表示一个进程可锁定在RAM中的最大内存，默认值为64 KB。这里的软限制设置为unlimited，即一个进程可锁定的最大内存为无限制。 # hard memlock unlimited # hard表示硬限制，即系统设置的最大值。memlock表示一个进程可锁定在RAM中的最大内存，默认值为64 KB。这里的硬限制设置为unlimited，即系统设置的最大内存锁定为无限制。
配置免密登录
# apt install -y sshpass yum install -y yum install -y sshpass ssh-keygen -f /root/.ssh/id_rsa -P '' export IP="192.168.123.111 192.168.123.112 192.168.123.113 192.168.123.114 192.168.123.115" export SSHPASS=******** for HOST in $IP;do sshpass -e ssh-copy-id -o StrictHostKeyChecking=no $HOST done # 这段脚本的作用是在一台机器上安装sshpass工具，并通过sshpass自动将本机的SSH公钥复制到多个远程主机上，以实现无需手动输入密码的SSH登录。 # 具体解释如下： # 1. `apt install -y sshpass` 或 `yum install -y sshpass`：通过包管理器（apt或yum）安装sshpass工具，使得后续可以使用sshpass命令。 # 2. `ssh-keygen -f /root/.ssh/id_rsa -P ''`：生成SSH密钥对。该命令会在/root/.ssh目录下生成私钥文件id_rsa和公钥文件id_rsa.pub，同时不设置密码（即-P参数后面为空），方便后续通过ssh-copy-id命令自动复制公钥。 # 3. `export IP="192.168.123.111 192.168.123.112 192.168.123.113 192.168.123.114 192.168.123.115"`：设置一个包含多个远程主机IP地址的环境变量IP，用空格分隔开，表示要将SSH公钥复制到这些远程主机上。 # 4. `export SSHPASS=123123`：设置环境变量SSHPASS，将sshpass所需的SSH密码（在这里是"123123"）赋值给它，这样sshpass命令可以自动使用这个密码进行登录。 # 5. `for HOST in $IP;do`：遍历环境变量IP中的每个IP地址，并将当前IP地址赋值给变量HOST。 # 6. `sshpass -e ssh-copy-id -o StrictHostKeyChecking=no $HOST`：使用sshpass工具复制本机的SSH公钥到远程主机。其中，-e选项表示使用环境变量中的密码（即SSHPASS）进行登录，-o StrictHostKeyChecking=no选项表示连接时不检查远程主机的公钥，以避免交互式确认。 # 通过这段脚本，可以方便地将本机的SSH公钥复制到多个远程主机上，实现无需手动输入密码的SSH登录。
安装ipvsadm
# 对于 Ubuntu # apt install ipvsadm ipset sysstat conntrack -y # 对于 CentOS yum install ipvsadm ipset sysstat conntrack libseccomp -y cat >> /etc/modules-load.d/ipvs.conf <<EOF ip_vs ip_vs_rr ip_vs_wrr ip_vs_sh nf_conntrack ip_tables ip_set xt_set ipt_set ipt_rpfilter ipt_REJECT ipip EOF systemctl restart systemd-modules-load.service lsmod | grep -e ip_vs -e nf_conntrack ip_vs_sh 16384 0 ip_vs_wrr 16384 0 ip_vs_rr 16384 0 ip_vs 237568 6 ip_vs_rr,ip_vs_sh,ip_vs_wrr nf_conntrack 217088 3 nf_nat,nft_ct,ip_vs nf_defrag_ipv6 24576 2 nf_conntrack,ip_vs nf_defrag_ipv4 16384 1 nf_conntrack libcrc32c 16384 5 nf_conntrack,nf_nat,nf_tables,xfs,ip_vs # 参数解释 # ip_vs # IPVS 是 Linux 内核中的一个模块，用于实现负载均衡和高可用性。它通过在前端代理服务器上分发传入请求到后端实际服务器上，提供了高性能和可扩展的网络服务。 # ip_vs_rr # IPVS 的一种调度算法之一，使用轮询方式分发请求到后端服务器，每个请求按顺序依次分发。 # ip_vs_wrr # IPVS 的一种调度算法之一，使用加权轮询方式分发请求到后端服务器，每个请求按照指定的权重比例分发。 # ip_vs_sh # IPVS 的一种调度算法之一，使用哈希方式根据源 IP 地址和目标 IP 地址来分发请求。 # nf_conntrack # 这是一个内核模块，用于跟踪和管理网络连接，包括 TCP、UDP 和 ICMP 等协议。它是实现防火墙状态跟踪的基础。 # ip_tables # 这是一个内核模块，提供了对 Linux 系统 IP 数据包过滤和网络地址转换（NAT）功能的支持。 # ip_set # 这是一个内核模块，扩展了 iptables 的功能，支持更高效的 IP 地址集合操作。 # xt_set # 这是一个内核模块，扩展了 iptables 的功能，支持更高效的数据包匹配和操作。 # ipt_set # 这是一个用户空间工具，用于配置和管理 xt_set 内核模块。 # ipt_rpfilter # 这是一个内核模块，用于实现反向路径过滤，用于防止 IP 欺骗和 DDoS 攻击。 # ipt_REJECT # 这是一个 iptables 目标，用于拒绝 IP 数据包，并向发送方发送响应，指示数据包被拒绝。 # ipip # 这是一个内核模块，用于实现 IP 封装在 IP（IP-over-IP）的隧道功能。它可以在不同网络之间创建虚拟隧道来传输 IP 数据包。
修改内核参数
cat <<EOF > /etc/sysctl.d/k8s.conf net.ipv4.ip_forward = 1 net.bridge.bridge-nf-call-iptables = 1 fs.may_detach_mounts = 1 vm.overcommit_memory=1 vm.panic_on_oom=0 fs.inotify.max_user_instances = 102400 fs.inotify.max_user_watches = 10485760 fs.file-max=52706963 fs.nr_open=52706963 net.netfilter.nf_conntrack_max=2310720 net.ipv4.tcp_keepalive_time = 600 net.ipv4.tcp_keepalive_probes = 3 net.ipv4.tcp_keepalive_intvl =15 net.ipv4.tcp_max_tw_buckets = 36000 net.ipv4.tcp_tw_reuse = 1 net.ipv4.tcp_max_orphans = 327680 net.ipv4.tcp_orphan_retries = 3 net.ipv4.tcp_syncookies = 1 net.ipv4.tcp_max_syn_backlog = 16384 net.ipv4.tcp_timestamps = 1 net.core.somaxconn = 16384 net.ipv6.conf.all.disable_ipv6 = 0 net.ipv6.conf.default.disable_ipv6 = 0 net.ipv6.conf.lo.disable_ipv6 = 0 net.ipv6.conf.all.forwarding = 1 EOF sysctl --system # 这些是Linux系统的一些参数设置，用于配置和优化网络、文件系统和虚拟内存等方面的功能。以下是每个参数的详细解释： # 1. net.ipv4.ip_forward = 1 # - 这个参数启用了IPv4的IP转发功能，允许服务器作为网络路由器转发数据包。 # 2. net.bridge.bridge-nf-call-iptables = 1 # - 当使用网络桥接技术时，将数据包传递到iptables进行处理。 # 3. fs.may_detach_mounts = 1 # - 允许在挂载文件系统时，允许被其他进程使用。 # 4. vm.overcommit_memory=1 # - 该设置允许原始的内存过量分配策略，当系统的内存已经被完全使用时，系统仍然会分配额外的内存。 # 5. vm.panic_on_oom=0 # - 当系统内存不足（OOM）时，禁用系统崩溃和重启。 # 6. fs.inotify.max_user_watches=89100 # - 设置系统允许一个用户的inotify实例可以监控的文件数目的上限。 # 7. fs.file-max=52706963 # - 设置系统同时打开的文件数的上限。 # 8. fs.nr_open=52706963 # - 设置系统同时打开的文件描述符数的上限。 # 9. net.netfilter.nf_conntrack_max=2310720 # - 设置系统可以创建的网络连接跟踪表项的最大数量。 # 10. net.ipv4.tcp_keepalive_time = 600 # - 设置TCP套接字的空闲超时时间（秒），超过该时间没有活动数据时，内核会发送心跳包。 # 11. net.ipv4.tcp_keepalive_probes = 3 # - 设置未收到响应的TCP心跳探测次数。 # 12. net.ipv4.tcp_keepalive_intvl = 15 # - 设置TCP心跳探测的时间间隔（秒）。 # 13. net.ipv4.tcp_max_tw_buckets = 36000 # - 设置系统可以使用的TIME_WAIT套接字的最大数量。 # 14. net.ipv4.tcp_tw_reuse = 1 # - 启用TIME_WAIT套接字的重新利用，允许新的套接字使用旧的TIME_WAIT套接字。 # 15. net.ipv4.tcp_max_orphans = 327680 # - 设置系统可以同时存在的TCP套接字垃圾回收包裹数的最大数量。 # 16. net.ipv4.tcp_orphan_retries = 3 # - 设置系统对于孤立的TCP套接字的重试次数。 # 17. net.ipv4.tcp_syncookies = 1 # - 启用TCP SYN cookies保护，用于防止SYN洪泛攻击。 # 18. net.ipv4.tcp_max_syn_backlog = 16384 # - 设置新的TCP连接的半连接数（半连接队列）的最大长度。 # 20. net.ipv4.tcp_timestamps = 0 # - 关闭TCP时间戳功能，用于提供更好的安全性。 # 21. net.core.somaxconn = 16384 # - 设置系统核心层的连接队列的最大值。 # 22. net.ipv6.conf.all.disable_ipv6 = 0 # - 启用IPv6协议。 # 23. net.ipv6.conf.default.disable_ipv6 = 0 # - 启用IPv6协议。 # 24. net.ipv6.conf.lo.disable_ipv6 = 0 # - 启用IPv6协议。 # 25. net.ipv6.conf.all.forwarding = 1 # - 允许IPv6数据包转发。
所有节点配置hosts本地解析
cat >> /etc/hosts <<EOF 127.0.0.1 localhost localhost.localdomain localhost4 localhost4.localdomain4 ::1 localhost localhost.localdomain localhost6 localhost6.localdomain6 192.168.123.111 k8s-master01 192.168.123.112 k8s-master02 192.168.123.113 k8s-master03 192.168.123.114 k8s-node01 192.168.123.115 k8s-node02 192.168.123.117 lb-vip fc00::31 k8s-master01 fc00::32 k8s-master02 fc00::33 k8s-master03 fc00::34 k8s-node01 fc00::35 k8s-node02 EOF
2、k8s基本组件安装
此处选择docker作为Runtime
解压docker程序
# 二进制包下载地址：https://download.docker.com/linux/static/stable/x86_64/ # wget https://mirrors.ustc.edu.cn/docker-ce/linux/static/stable/x86_64/docker-27.4.0.tgz #解压 tar xf docker-*.tgz #拷贝二进制文件 cp docker/* /usr/bin/
创建containerd的service文件
#创建containerd的service文件,并且启动 cat >/etc/systemd/system/containerd.service <<EOF [Unit] Description=containerd container runtime Documentation=https://containerd.io After=network.target local-fs.target [Service] ExecStartPre=-/sbin/modprobe overlay ExecStart=/usr/bin/containerd Type=notify Delegate=yes KillMode=process Restart=always RestartSec=5 LimitNPROC=infinity LimitCORE=infinity LimitNOFILE=1048576 TasksMax=infinity OOMScoreAdjust=-999 [Install] WantedBy=multi-user.target EOF # 参数解释： # # [Unit] # - Description=containerd container runtime：指定服务的描述信息。 # - Documentation=https://containerd.io：指定服务的文档链接。 # - After=network.target local-fs.target：指定服务的启动顺序，在网络和本地文件系统启动之后再启动该服务。 # # [Service] # - ExecStartPre=-/sbin/modprobe overlay：在启动服务之前执行的命令，使用`-`表示忽略错误。 # - ExecStart=/usr/bin/containerd：指定服务的启动命令。 # - Type=notify：指定服务的类型，`notify`表示服务会在启动完成后向systemd发送通知。 # - Delegate=yes：允许服务代理其他服务的应答，例如收到关机命令后终止其他服务。 # - KillMode=process：指定服务终止时的行为，`process`表示终止服务进程。 # - Restart=always：指定服务终止后是否自动重启，`always`表示总是自动重启。 # - RestartSec=5：指定服务重启的时间间隔，单位为秒。 # - LimitNPROC=infinity：限制服务的最大进程数，`infinity`表示没有限制。 # - LimitCORE=infinity：限制服务的最大核心数，`infinity`表示没有限制。 # - LimitNOFILE=1048576：限制服务的最大文件数，指定为1048576。 # - TasksMax=infinity：限制服务的最大任务数，`infinity`表示没有限制。 # - OOMScoreAdjust=-999：指定服务的OOM（Out of Memory）得分，负数表示降低被终止的概率。 # # [Install] # - WantedBy=multi-user.target：指定服务的安装方式，`multi-user.target`表示该服务在多用户模式下安装。 # 设置开机自启 systemctl enable --now containerd.service
准备docker的service文件
#准备docker的service文件 cat > /etc/systemd/system/docker.service <<EOF [Unit] Description=Docker Application Container Engine Documentation=https://docs.docker.com After=network-online.target firewalld.service cri-docker.service docker.socket containerd.service Wants=network-online.target Requires=docker.socket containerd.service [Service] Type=notify ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock ExecReload=/bin/kill -s HUP $MAINPID TimeoutSec=0 RestartSec=5 Restart=always StartLimitBurst=12 StartLimitInterval=60s LimitNOFILE=infinity LimitNPROC=infinity LimitCORE=infinity TasksMax=infinity Delegate=yes KillMode=process OOMScoreAdjust=-500 [Install] WantedBy=multi-user.target EOF # 参数解释： # # [Unit] # - Description: 描述服务的作用，这里是Docker Application Container Engine，即Docker应用容器引擎。 # - Documentation: 提供关于此服务的文档链接，这里是Docker官方文档链接。 # - After: 说明该服务在哪些其他服务之后启动，这里是在网络在线、firewalld服务和containerd服务后启动。 # - Wants: 说明该服务想要的其他服务，这里是网络在线服务。 # - Requires: 说明该服务需要的其他服务，这里是docker.socket和containerd.service。 # # [Service] # - Type: 服务类型，这里是notify，表示服务在启动完成时发送通知。 # - ExecStart: 命令，启动该服务时会执行的命令，这里是/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock，即启动dockerd并指定一些参数，其中-H指定dockerd的监听地址为fd://，--containerd指定containerd的sock文件位置。 # - ExecReload: 重载命令，当接收到HUP信号时执行的命令，这里是/bin/kill -s HUP $MAINPID，即发送HUP信号给主进程ID。 # - TimeoutSec: 服务超时时间，这里是0，表示没有超时限制。 # - RestartSec: 重启间隔时间，这里是2秒，表示重启失败后等待2秒再重启。 # - Restart: 重启策略，这里是always，表示总是重启。 # - StartLimitBurst: 启动限制次数，这里是3，表示在启动失败后最多重试3次。 # - StartLimitInterval: 启动限制时间间隔，这里是60秒，表示两次启动之间最少间隔60秒。 # - LimitNOFILE: 文件描述符限制，这里是infinity，表示没有限制。 # - LimitNPROC: 进程数限制，这里是infinity，表示没有限制。 # - LimitCORE: 核心转储限制，这里是infinity，表示没有限制。 # - TasksMax: 最大任务数，这里是infinity，表示没有限制。 # - Delegate: 修改权限，这里是yes，表示启用权限修改。 # - KillMode: 杀死模式，这里是process，表示杀死整个进程组。 # - OOMScoreAdjust: 用于调整进程在系统内存紧张时的优先级调整，这里是-500，表示将OOM分数降低500。 # # [Install] # - WantedBy: 安装目标，这里是multi-user.target，表示在多用户模式下安装。 # 在WantedBy参数中，我们可以使用以下参数： # 1. multi-user.target：指定该服务应该在多用户模式下启动。 # 2. graphical.target：指定该服务应该在图形化界面模式下启动。 # 3. default.target：指定该服务应该在系统的默认目标（runlevel）下启动。 # 4. rescue.target：指定该服务应该在系统救援模式下启动。 # 5. poweroff.target：指定该服务应该在关机时启动。 # 6. reboot.target：指定该服务应该在重启时启动。 # 7. halt.target：指定该服务应该在停止时启动。 # 8. shutdown.target：指定该服务应该在系统关闭时启动。 # 这些参数可以根据需要选择一个或多个，以告知系统在何时启动该服务。
准备docker的socket文件
#准备docker的socket文件 cat > /etc/systemd/system/docker.socket <<EOF [Unit] Description=Docker Socket for the API [Socket] ListenStream=/var/run/docker.sock SocketMode=0660 SocketUser=root SocketGroup=docker [Install] WantedBy=sockets.target EOF # 这是一个用于Docker API的socket配置文件，包含了以下参数： # # [Unit] # - Description：描述了该socket的作用，即为Docker API的socket。 # # [Socket] # - ListenStream：指定了socket的监听地址，该socket会监听在/var/run/docker.sock上，即Docker守护程序使用的默认sock文件。 # - SocketMode：指定了socket文件的权限模式，此处为0660，即用户和用户组有读写权限，其他用户无权限。 # - SocketUser：指定了socket文件的所有者，此处为root用户。 # - SocketGroup：指定了socket文件的所属用户组，此处为docker用户组。 # # [Install] # - WantedBy：指定了该socket被启用时的目标，此处为sockets.target，表示当sockets.target启动时启用该socket。 # # 该配置文件的作用是为Docker提供API访问的通道，它监听在/var/run/docker.sock上，具有root用户权限，但只接受docker用户组的成员的连接，并且其他用户无法访问。这样，只有docker用户组的成员可以通过该socket与Docker守护进程进行通信。
docker配置文件调整
# 配置加速器 mkdir /etc/docker/ -pv cat >/etc/docker/daemon.json <<EOF { "exec-opts": ["native.cgroupdriver=systemd"], "max-concurrent-downloads": 10, "log-driver": "json-file", "log-level": "warn", "log-opts": { "max-size": "10m", "max-file": "3" }, "data-root": "/var/lib/docker", "storage-driver": "overlay2", "live-restore": true, "registry-mirrors": [ "https://docker.m.daocloud.io", "https://jockerhub.com" ] } EOF # 该参数文件中包含以下参数： # # 1. exec-opts: 用于设置Docker守护进程的选项，native.cgroupdriver=systemd表示使用systemd作为Cgroup驱动程序。 # 2. registry-mirrors: 用于指定Docker镜像的镜像注册服务器。在这里有三个镜像注册服务器：https://docker.m.daocloud.io、https://docker.mirrors.ustc.edu.cn和http://hub-mirror.c.163.com。 # 3. max-concurrent-downloads: 用于设置同时下载镜像的最大数量，默认值为3，这里设置为10。 # 4. log-driver: 用于设置Docker守护进程的日志驱动程序，这里设置为json-file。 # 5. log-level: 用于设置日志的级别，这里设置为warn。 # 6. log-opts: 用于设置日志驱动程序的选项，这里有两个选项：max-size和max-file。max-size表示每个日志文件的最大大小，这里设置为10m，max-file表示保存的最大日志文件数量，这里设置为3。 # 7. data-root: 用于设置Docker守护进程的数据存储根目录，默认为/var/lib/docker，这里设置为/var/lib/docker。
启动docker
groupadd docker #创建docker组 systemctl daemon-reload # 用于重新加载systemd管理的单位文件。当你新增或修改了某个单位文件（如.service文件、.socket文件等），需要运行该命令来刷新systemd对该文件的配置。 systemctl enable --now docker.socket # 启用并立即启动docker.socket单元。docker.socket是一个systemd的socket单元，用于接收来自网络的Docker API请求。 systemctl enable --now docker.service # 启用并立即启动docker.service单元。docker.service是Docker守护进程的systemd服务单元。 systemctl stop docker.service # 停止运行中的docker.service单元，即停止Docker守护进程。 systemctl start docker.service # 启动docker.service单元，即启动Docker守护进程。 systemctl restart docker.service # 重启docker.service单元，即重新启动Docker守护进程。 systemctl status docker.service # 显示docker.service单元的当前状态，包括运行状态、是否启用等信息。 #验证 docker info
cri-docker安装配置
# 1、解压cri-docker # 由于1.24以及更高版本不支持docker所以安装cri-docker # 下载cri-docker # https://github.com/Mirantis/cri-dockerd/releases/ # wget https://github.com/Mirantis/cri-dockerd/releases/download/v0.3.16/cri-dockerd-0.3.16.amd64.tgz # 解压cri-docker tar xvf cri-dockerd-*.amd64.tgz cp -r cri-dockerd/ /usr/bin/ chmod +x /usr/bin/cri-dockerd/cri-dockerd --- # 2、写入启动cri-docker配置文件 # 写入启动配置文件 cat > /usr/lib/systemd/system/cri-docker.service <<EOF [Unit] Description=CRI Interface for Docker Application Container Engine Documentation=https://docs.mirantis.com After=network-online.target firewalld.service docker.service Wants=network-online.target Requires=cri-docker.socket [Service] Type=notify ExecStart=/usr/bin/cri-dockerd/cri-dockerd --network-plugin=cni --pod-infra-container-image=registry.aliyuncs.com/google_containers/pause:3.7 ExecReload=/bin/kill -s HUP $MAINPID TimeoutSec=0 RestartSec=2 Restart=always StartLimitBurst=12 StartLimitInterval=60s LimitNOFILE=infinity LimitNPROC=infinity LimitCORE=infinity TasksMax=infinity Delegate=yes KillMode=process [Install] WantedBy=multi-user.target EOF # [Unit] # - Description：该参数用于描述该单元的功能，这里描述的是CRI与Docker应用容器引擎的接口。 # - Documentation：该参数指定了相关文档的网址，供用户参考。 # - After：该参数指定了此单元应该在哪些其他单元之后启动，确保在网络在线、防火墙和Docker服务启动之后再启动此单元。 # - Wants：该参数指定了此单元希望也启动的所有单元，此处是希望在网络在线之后启动。 # - Requires：该参数指定了此单元需要依赖的单元，此处是cri-docker.socket单元。 # # [Service] # - Type：该参数指定了服务的类型，这里是notify，表示当服务启动完成时向系统发送通知。 # - ExecStart：该参数指定了将要运行的命令和参数，此处是执行/usr/bin/cri-dockerd/cri-dockerd命令，并指定了网络插件为cni和Pod基础设施容器的镜像为registry.aliyuncs.com/google_containers/pause:3.7。 # - ExecReload：该参数指定在服务重载时运行的命令，此处是发送HUP信号给主进程。 # - TimeoutSec：该参数指定了服务启动的超时时间，此处为0，表示无限制。 # - RestartSec：该参数指定了自动重启服务的时间间隔，此处为2秒。 # - Restart：该参数指定了在服务发生错误时自动重启，此处是始终重启。 # - StartLimitBurst：该参数指定了在给定时间间隔内允许的启动失败次数，此处为3次。 # - StartLimitInterval：该参数指定启动失败的时间间隔，此处为60秒。 # - LimitNOFILE：该参数指定了允许打开文件的最大数量，此处为无限制。 # - LimitNPROC：该参数指定了允许同时运行的最大进程数，此处为无限制。 # - LimitCORE：该参数指定了允许生成的core文件的最大大小，此处为无限制。 # - TasksMax：该参数指定了此服务的最大任务数，此处为无限制。 # - Delegate：该参数指定了是否将控制权委托给指定服务，此处为是。 # - KillMode：该参数指定了在终止服务时如何处理进程，此处是通过终止进程来终止服务。 # # [Install] # - WantedBy：该参数指定了希望这个单元启动的多用户目标。在这里，这个单元希望在multi-user.target启动。 --- # 3、写入cri-docker的socket配置文件 # 写入socket配置文件 cat > /usr/lib/systemd/system/cri-docker.socket <<EOF [Unit] Description=CRI Docker Socket for the API PartOf=cri-docker.service [Socket] ListenStream=%t/cri-dockerd.sock SocketMode=0660 SocketUser=root SocketGroup=docker [Install] WantedBy=sockets.target EOF # 该配置文件是用于systemd的单元配置文件(unit file)，用于定义一个socket单元。 # # [Unit] # - Description：表示该单元的描述信息。 # - PartOf：表示该单元是cri-docker.service的一部分。 # # [Socket] # - ListenStream：指定了该socket要监听的地址和端口，这里使用了%t占位符，表示根据单元的类型来决定路径。%t/cri-dockerd.sock表示将监听Unix域套接字cri-dockerd.sock。Unix域套接字用于在同一台主机上的进程之间通信。 # - SocketMode：指定了socket文件的权限模式，此处为0660，即用户和用户组有读写权限，其他用户无权限。 # - SocketUser：指定了socket文件的所有者，此处为root用户。 # - SocketGroup：指定了socket文件的所属用户组，此处为docker用户组。 # # [Install] # - WantedBy：部分定义了该单元的安装配置信息。WantedBy=sockets.target表示当sockets.target单元启动时，自动启动该socket单元。sockets.target是一个系统服务，用于管理所有的socket单元。 --- # 4、启动cri-docker systemctl daemon-reload # 用于重新加载systemd管理的单位文件。当你新增或修改了某个单位文件（如.service文件、.socket文件等），需要运行该命令来刷新systemd对该文件的配置。 systemctl enable --now cri-docker.service # 启用并立即启动cri-docker.service单元。cri-docker.service是cri-docker守护进程的systemd服务单元。 systemctl restart cri-docker.service # 重启cri-docker.service单元，即重新启动cri-docker守护进程。 systemctl status cri-docker.service # 显示docker.service单元的当前状态，包括运行状态、是否启用等信息。
k8s与etcd下载及安装（仅在master01操作）
解压k8s安装包
# 下载安装包 # https://github.com/etcd-io/etcd/releases/ # https://github.com/kubernetes/kubernetes/tree/master/CHANGELOG # wget https://github.com/etcd-io/etcd/releases/download/v3.5.21/etcd-v3.5.21-linux-amd64.tar.gz # wget https://cdn.dl.k8s.io/release/v1.34.0/kubernetes-server-linux-amd64.tar.gz # 解压k8s安装文件 tar -xf kubernetes-server-linux-amd64.tar.gz --strip-components=3 -C /usr/local/bin kubernetes/server/bin/kube{let,ctl,-apiserver,-controller-manager,-scheduler,-proxy} # 这是一个tar命令，用于解压指定的kubernetes-server-linux-amd64.tar.gz文件，并将其中的特定文件提取到/usr/local/bin目录下。 # 命令的解释如下： # - tar：用于处理tar压缩文件的命令。 # - -xf：表示解压操作。 # - kubernetes-server-linux-amd64.tar.gz：要解压的文件名。 # - --strip-components=3：表示解压时忽略压缩文件中的前3级目录结构，提取文件时直接放到目标目录中。 # - -C /usr/local/bin：指定提取文件的目标目录为/usr/local/bin。 # - kubernetes/server/bin/kube{let,ctl,-apiserver,-controller-manager,-scheduler,-proxy}：要解压和提取的文件名模式，用花括号括起来表示模式中的多个可能的文件名。 # 总的来说，这个命令的作用是将kubernetes-server-linux-amd64.tar.gz文件中的kubelet、kubectl、kube-apiserver、kube-controller-manager、kube-scheduler和kube-proxy六个文件提取到/usr/local/bin目录下，同时忽略文件路径中的前三级目录结构。 # 解压etcd安装文件 tar -xf etcd*.tar.gz && mv etcd-*/etcd /usr/local/bin/ && mv etcd-*/etcdctl /usr/local/bin/ # 这是一个将文件解压并移动到特定目录的命令。这是一个用于 Linux 系统中的命令。 # - tar -xf etcd*.tar.gz：这个命令将解压以 etcd 开头并以.tar.gz 结尾的文件。`-xf` 是使用 `tar` 命令的选项，它表示解压文件并展开其中的内容。 # - mv etcd-*/etcd /usr/local/bin/：这个命令将 etcd 文件移动到 /usr/local/bin 目录。`mv` 是移动命令，它将 etcd-*/etcd 路径下的 etcd 文件移动到了 /usr/local/bin 目录。 # - mv etcd-*/etcdctl /usr/local/bin/：这个命令将 etcdctl 文件移动到 /usr/local/bin 目录，和上一条命令类似。 # 总结起来，以上命令将从名为 etcd*.tar.gz 的压缩文件中解压出 etcd 和 etcdctl 文件，并将它们移动到 /usr/local/bin 目录中。 # 查看/usr/local/bin下内容 ll /usr/local/bin/ 总用量 581544 -rwxr-xr-x 1 1000 docker 25268376 7月 26 02:17 etcd -rwxr-xr-x 1 1000 docker 16466072 7月 26 02:17 etcdctl -rwxr-xr-x 1 root root 84046008 8月 27 18:30 kube-apiserver -rwxr-xr-x 1 root root 71000248 8月 27 18:30 kube-controller-manager -rwxr-xr-x 1 root root 60559544 8月 27 18:30 kubectl -rwxr-xr-x 1 root root 59195684 8月 27 18:30 kubelet -rwxr-xr-x 1 root root 44495032 8月 27 18:30 kube-proxy -rwxr-xr-x 1 root root 48840888 8月 27 18:30 kube-scheduler
查看版本
[root@k8s-master01 ~]# kubelet --version Kubernetes v1.34.0 [root@k8s-master01 ~]# etcdctl version etcdctl version: 3.6.4 API version: 3.6
将组件发送至其他k8s节点
Master='k8s-master02 k8s-master03' Work='k8s-node01 k8s-node02' # 拷贝master组件 for NODE in $Master; do echo $NODE; scp /usr/local/bin/kube{let,ctl,-apiserver,-controller-manager,-scheduler,-proxy} $NODE:/usr/local/bin/; scp /usr/local/bin/etcd* $NODE:/usr/local/bin/; done # 该命令是一个for循环，对于在$Master变量中的每个节点，执行以下操作： # 1. 打印出节点的名称。 # 2. 使用scp命令将/usr/local/bin/kubelet、kubectl、kube-apiserver、kube-controller-manager、kube-scheduler和kube-proxy文件复制到节点的/usr/local/bin/目录下。 # 3. 使用scp命令将/usr/local/bin/etcd*文件复制到节点的/usr/local/bin/目录下。 # 拷贝work组件 for NODE in $Work; do echo $NODE; scp /usr/local/bin/kube{let,-proxy} $NODE:/usr/local/bin/ ; done # 该命令是一个for循环，对于在$Master变量中的每个节点，执行以下操作： # 1. 打印出节点的名称。 # 2. 使用scp命令将/usr/local/bin/kubelet和kube-proxy文件复制到节点的/usr/local/bin/目录下。 # 所有节点执行 mkdir -p /opt/cni/bin
3、相关证书生成
# master01节点下载证书生成工具 # wget "https://github.com/cloudflare/cfssl/releases/download/v1.6.5/cfssl_1.6.5_linux_amd64" -O /usr/local/bin/cfssl # wget "https://github.com/cloudflare/cfssl/releases/download/v1.6.5/cfssljson_1.6.5_linux_amd64" -O /usr/local/bin/cfssljson # 软件包内有 cp cfssl_*_linux_amd64 /usr/local/bin/cfssl cp cfssljson_*_linux_amd64 /usr/local/bin/cfssljson # 添加执行权限 chmod +x /usr/local/bin/cfssl /usr/local/bin/cfssljson
生成etcd证书
特别说明除外，以下操作在所有master节点操作
# 1、所有master节点创建证书存放目录 mkdir /etc/etcd/ssl -p
---
# 2、master01节点生成etcd证书 # 写入生成证书所需的配置文件 cat > ca-config.json << EOF { "signing": { "default": { "expiry": "876000h" }, "profiles": { "kubernetes": { "usages": [ "signing", "key encipherment", "server auth", "client auth" ], "expiry": "876000h" } } } } EOF # 这段配置文件是用于配置加密和认证签名的一些参数。 # 在这里，有两个部分：`signing`和`profiles`。 # `signing`包含了默认签名配置和配置文件。 # 默认签名配置`default`指定了证书的过期时间为`876000h`。`876000h`表示证书有效期为100年。 # `profiles`部分定义了不同的证书配置文件。 # 在这里，只有一个配置文件`kubernetes`。它包含了以下`usages`和过期时间`expiry`： # 1. `signing`：用于对其他证书进行签名 # 2. `key encipherment`：用于加密和解密传输数据 # 3. `server auth`：用于服务器身份验证 # 4. `client auth`：用于客户端身份验证 # 对于`kubernetes`配置文件，证书的过期时间也是`876000h`，即100年。 cat > etcd-ca-csr.json << EOF { "CN": "etcd", "key": { "algo": "rsa", "size": 2048 }, "names": [ { "C": "CN", "ST": "Beijing", "L": "Beijing", "O": "etcd", "OU": "Etcd Security" } ], "ca": { "expiry": "876000h" } } EOF # 这是一个用于生成证书签名请求（Certificate Signing Request，CSR）的JSON配置文件。JSON配置文件指定了生成证书签名请求所需的数据。 # - "CN": "etcd" 指定了希望生成的证书的CN字段（Common Name），即证书的主题，通常是该证书标识的实体的名称。 # - "key": {} 指定了生成证书所使用的密钥的配置信息。"algo": "rsa" 指定了密钥的算法为RSA，"size": 2048 指定了密钥的长度为2048位。 # - "names": [] 包含了生成证书时所需的实体信息。在这个例子中，只包含了一个实体，其相关信息如下： # - "C": "CN" 指定了实体的国家/地区代码，这里是中国。 # - "ST": "Beijing" 指定了实体所在的省/州。 # - "L": "Beijing" 指定了实体所在的城市。 # - "O": "etcd" 指定了实体的组织名称。 # - "OU": "Etcd Security" 指定了实体所属的组织单位。 # - "ca": {} 指定了生成证书时所需的CA（Certificate Authority）配置信息。 # - "expiry": "876000h" 指定了证书的有效期，这里是876000小时。 # 生成证书签名请求时，可以使用这个JSON配置文件作为输入，根据配置文件中的信息生成相应的CSR文件。然后，可以将CSR文件发送给CA进行签名，以获得有效的证书。 # 生成etcd证书和etcd证书的key（如果你觉得以后可能会扩容，可以在ip那多写几个预留出来） # 若没有IPv6 可删除可保留 cfssl gencert -initca etcd-ca-csr.json | cfssljson -bare /etc/etcd/ssl/etcd-ca # 具体的解释如下： # cfssl是一个用于生成TLS/SSL证书的工具，它支持PKI、JSON格式配置文件以及与许多其他集成工具的配合使用。 # gencert参数表示生成证书的操作。-initca参数表示初始化一个CA（证书颁发机构）。CA是用于签发其他证书的根证书。etcd-ca-csr.json是一个JSON格式的配置文件，其中包含了CA的详细信息，如私钥、公钥、有效期等。这个文件提供了生成CA证书所需的信息。 # | 符号表示将上一个命令的输出作为下一个命令的输入。 # cfssljson是cfssl工具的一个子命令，用于格式化cfssl生成的JSON数据。 -bare参数表示直接输出裸证书，即只生成证书文件，不包含其他格式的文件。/etc/etcd/ssl/etcd-ca是指定生成的证书文件的路径和名称。 # 所以，这条命令的含义是使用cfssl工具根据配置文件ca-csr.json生成一个CA证书，并将证书文件保存在/etc/etcd/ssl/etcd-ca路径下。 cat > etcd-csr.json << EOF { "CN": "etcd", "key": { "algo": "rsa", "size": 2048 }, "names": [ { "C": "CN", "ST": "Beijing", "L": "Beijing", "O": "etcd", "OU": "Etcd Security" } ] } EOF # 这段代码是一个JSON格式的配置文件，用于生成一个证书签名请求（Certificate Signing Request，CSR）。 # 首先，"CN"字段指定了该证书的通用名称（Common Name），这里设为"etcd"。 # 接下来，"key"字段指定了密钥的算法（"algo"字段）和长度（"size"字段），此处使用的是RSA算法，密钥长度为2048位。 # 最后，"names"字段是一个数组，其中包含了一个名字对象，用于指定证书中的一些其他信息。这个名字对象包含了以下字段： # - "C"字段指定了国家代码（Country），这里设置为"CN"。 # - "ST"字段指定了省份（State）或地区，这里设置为"Beijing"。 # - "L"字段指定了城市（Locality），这里设置为"Beijing"。 # - "O"字段指定了组织（Organization），这里设置为"etcd"。 # - "OU"字段指定了组织单元（Organizational Unit），这里设置为"Etcd Security"。 # 这些字段将作为证书的一部分，用于标识和验证证书的使用范围和颁发者等信息。 cfssl gencert \ -ca=/etc/etcd/ssl/etcd-ca.pem \ -ca-key=/etc/etcd/ssl/etcd-ca-key.pem \ -config=ca-config.json \ -hostname=127.0.0.1,k8s-master01,k8s-master02,k8s-master03,192.168.123.111,192.168.123.112,192.168.123.113,::1 \ -profile=kubernetes \ etcd-csr.json | cfssljson -bare /etc/etcd/ssl/etcd # 这是一条使用cfssl生成etcd证书的命令，下面是各个参数的解释： # -ca=/etc/etcd/ssl/etcd-ca.pem：指定用于签名etcd证书的CA文件的路径。 # -ca-key=/etc/etcd/ssl/etcd-ca-key.pem：指定用于签名etcd证书的CA私钥文件的路径。 # -config=ca-config.json：指定CA配置文件的路径，该文件定义了证书的有效期、加密算法等设置。 # -hostname=xxxx：指定要为etcd生成证书的主机名和IP地址列表。 # -profile=kubernetes：指定使用的证书配置文件，该文件定义了证书的用途和扩展属性。 # etcd-csr.json：指定etcd证书请求的JSON文件的路径，该文件包含了证书请求的详细信息。 # | cfssljson -bare /etc/etcd/ssl/etcd：通过管道将cfssl命令的输出传递给cfssljson命令，并使用-bare参数指定输出文件的前缀路径，这里将生成etcd证书的.pem和-key.pem文件。 # 这条命令的作用是使用指定的CA证书和私钥，根据证书请求的JSON文件和配置文件生成etcd的证书文件。
---
# 3、将证书复制到其他节点 Master='k8s-master02 k8s-master03' for NODE in $Master; do ssh $NODE "mkdir -p /etc/etcd/ssl"; for FILE in etcd-ca-key.pem etcd-ca.pem etcd-key.pem etcd.pem; do scp /etc/etcd/ssl/${FILE} $NODE:/etc/etcd/ssl/${FILE}; done; done # 这个命令是一个简单的for循环，在一个由`$Master`存储的主机列表中迭代执行。对于每个主机，它使用`ssh`命令登录到主机，并在远程主机上创建一个名为`/etc/etcd/ssl`的目录（如果不存在）。接下来，它使用`scp`将本地主机上`/etc/etcd/ssl`目录中的四个文件（`etcd-ca-key.pem`，`etcd-ca.pem`，`etcd-key.pem`和`etcd.pem`）复制到远程主机的`/etc/etcd/ssl`目录中。最终的结果是，远程主机上的`/etc/etcd/ssl`目录中包含与本地主机上相同的四个文件的副本。
生成k8s相关证书
特别说明除外，以下操作在所有master节点操作
# 1、所有k8s节点创建证书存放目录 mkdir -p /etc/kubernetes/pki
--- # 2、master01节点生成k8s证书 # 写入生成证书所需的配置文件 cat > ca-csr.json << EOF { "CN": "kubernetes", "key": { "algo": "rsa", "size": 2048 }, "names": [ { "C": "CN", "ST": "Beijing", "L": "Beijing", "O": "Kubernetes", "OU": "Kubernetes-manual" } ], "ca": { "expiry": "876000h" } } EOF # 这是一个用于生成 Kubernetes 相关证书的配置文件。该配置文件中包含以下信息： # - CN：CommonName，即用于标识证书的通用名称。在此配置中，CN 设置为 "kubernetes"，表示该证书是用于 Kubernetes。 # - key：用于生成证书的算法和大小。在此配置中，使用的算法是 RSA，大小是 2048 位。 # - names：用于证书中的名称字段的详细信息。在此配置中，有以下字段信息： # - C：Country，即国家。在此配置中，设置为 "CN"。 # - ST：State，即省/州。在此配置中，设置为 "Beijing"。 # - L：Locality，即城市。在此配置中，设置为 "Beijing"。 # - O：Organization，即组织。在此配置中，设置为 "Kubernetes"。 # - OU：Organization Unit，即组织单位。在此配置中，设置为 "Kubernetes-manual"。 # - ca：用于证书签名的证书颁发机构（CA）的配置信息。在此配置中，设置了证书的有效期为 876000 小时。 # 这个配置文件可以用于生成 Kubernetes 相关的证书，以确保集群中的通信安全性。 cfssl gencert -initca ca-csr.json | cfssljson -bare /etc/kubernetes/pki/ca # 具体的解释如下： # cfssl是一个用于生成TLS/SSL证书的工具，它支持PKI、JSON格式配置文件以及与许多其他集成工具的配合使用。 # gencert参数表示生成证书的操作。-initca参数表示初始化一个CA（证书颁发机构）。CA是用于签发其他证书的根证书。ca-csr.json是一个JSON格式的配置文件，其中包含了CA的详细信息，如私钥、公钥、有效期等。这个文件提供了生成CA证书所需的信息。 # | 符号表示将上一个命令的输出作为下一个命令的输入。 # cfssljson是cfssl工具的一个子命令，用于格式化cfssl生成的JSON数据。 -bare参数表示直接输出裸证书，即只生成证书文件，不包含其他格式的文件。/etc/kubernetes/pki/ca是指定生成的证书文件的路径和名称。 # 所以，这条命令的含义是使用cfssl工具根据配置文件ca-csr.json生成一个CA证书，并将证书文件保存在/etc/kubernetes/pki/ca路径下。 cat > apiserver-csr.json << EOF { "CN": "kube-apiserver", "key": { "algo": "rsa", "size": 2048 }, "names": [ { "C": "CN", "ST": "Beijing", "L": "Beijing", "O": "Kubernetes", "OU": "Kubernetes-manual" } ] } EOF # 这是一个用于生成 Kubernetes 相关证书的配置文件。该配置文件中包含以下信息： # - `CN` 字段指定了证书的通用名称 (Common Name)，这里设置为 "kube-apiserver"，表示该证书用于 Kubernetes API Server。 # - `key` 字段指定了生成证书时所选用的加密算法和密钥长度。这里选用了 RSA 算法，密钥长度为 2048 位。 # - `names` 字段包含了一组有关证书持有者信息的项。这里使用了以下信息： # - `C` 表示国家代码 (Country)，这里设置为 "CN" 表示中国。 # - `ST` 表示州或省份 (State)，这里设置为 "Beijing" 表示北京市。 # - `L` 表示城市或地区 (Location)，这里设置为 "Beijing" 表示北京市。 # - `O` 表示组织名称 (Organization)，这里设置为 "Kubernetes" 表示 Kubernetes。 # - `OU` 表示组织单位 (Organizational Unit)，这里设置为 "Kubernetes-manual" 表示手动管理的 Kubernetes 集群。 # 这个配置文件可以用于生成 Kubernetes 相关的证书，以确保集群中的通信安全性。 # 生成一个根证书 ，多写了一些IP作为预留IP，为将来添加node做准备 # 10.96.0.1是service网段的第一个地址，需要计算，192.168.123.117为高可用vip地址 # 若没有IPv6 可删除可保留 cfssl gencert \ -ca=/etc/kubernetes/pki/ca.pem \ -ca-key=/etc/kubernetes/pki/ca-key.pem \ -config=ca-config.json \ -hostname=10.96.0.1,192.168.123.117,127.0.0.1,kubernetes,kubernetes.default,kubernetes.default.svc,kubernetes.default.svc.cluster,kubernetes.default.svc.cluster.local,192.168.123.111,192.168.123.112,192.168.123.113,192.168.123.114,192.168.123.115,192.168.123.117,192.168.123.117,192.168.123.118,192.168.123.119,192.168.123.120,::1 \ -profile=kubernetes apiserver-csr.json | cfssljson -bare /etc/kubernetes/pki/apiserver # 这个命令是使用cfssl工具生成Kubernetes API Server的证书。 # 命令的参数解释如下： # - `-ca=/etc/kubernetes/pki/ca.pem`：指定证书的颁发机构（CA）文件路径。 # - `-ca-key=/etc/kubernetes/pki/ca-key.pem`：指定证书的颁发机构（CA）私钥文件路径。 # - `-config=ca-config.json`：指定证书生成的配置文件路径，配置文件中包含了证书的有效期、加密算法等信息。 # - `-hostname=10.96.0.1,192.168.123.117,127.0.0.1,fc00:43f4:1eea:1::10`：指定证书的主机名或IP地址列表。 # - `-profile=kubernetes`：指定证书生成的配置文件中的配置文件名。 # - `apiserver-csr.json`：API Server的证书签名请求配置文件路径。 # - `| cfssljson -bare /etc/kubernetes/pki/apiserver`：通过管道将生成的证书输出到cfssljson工具，将其转换为PEM编码格式，并保存到 `/etc/kubernetes/pki/apiserver.pem` 和 `/etc/kubernetes/pki/apiserver-key.pem` 文件中。 # 最终，这个命令将会生成API Server的证书和私钥，并保存到指定的文件中。
---
# 3、生成apiserver聚合证书 cat > front-proxy-ca-csr.json << EOF { "CN": "kubernetes", "key": { "algo": "rsa", "size": 2048 }, "ca": { "expiry": "876000h" } } EOF # 这个JSON文件表示了生成一个名为"kubernetes"的证书的配置信息。这个证书是用来进行Kubernetes集群的身份验证和安全通信。 # 配置信息包括以下几个部分： # 1. "CN": "kubernetes"：这表示了证书的通用名称（Common Name），也就是证书所代表的实体的名称。在这里，证书的通用名称被设置为"kubernetes"，表示这个证书是用来代表Kubernetes集群。 # 2. "key"：这是用来生成证书的密钥相关的配置。在这里，配置使用了RSA算法，并且设置了密钥的大小为2048位。 # 3. "ca"：这个字段指定了证书的颁发机构（Certificate Authority）相关的配置。在这里，配置指定了证书的有效期为876000小时，即100年。这意味着该证书在100年内将被视为有效，过期后需要重新生成。 # 总之，这个JSON文件中的配置信息描述了如何生成一个用于Kubernetes集群的证书，包括证书的通用名称、密钥算法和大小以及证书的有效期。 cfssl gencert -initca front-proxy-ca-csr.json | cfssljson -bare /etc/kubernetes/pki/front-proxy-ca # 具体的解释如下： # cfssl是一个用于生成TLS/SSL证书的工具，它支持PKI、JSON格式配置文件以及与许多其他集成工具的配合使用 # gencert参数表示生成证书的操作。-initca参数表示初始化一个CA（证书颁发机构）。CA是用于签发其他证书的根证书。front-proxy-ca-csr.json是一个JSON格式的配置文件，其中包含了CA的详细信息，如私钥、公钥、有效期等。这个文件提供了生成CA证书所需的信息。 # | 符号表示将上一个命令的输出作为下一个命令的输入。 # cfssljson是cfssl工具的一个子命令，用于格式化cfssl生成的JSON数据。 -bare参数表示直接输出裸证书，即只生成证书文件，不包含其他格式的文件。/etc/kubernetes/pki/front-proxy-ca是指定生成的证书文件的路径和名称。 # 所以，这条命令的含义是使用cfssl工具根据配置文件ca-csr.json生成一个CA证书，并将证书文件保存在/etc/kubernetes/pki/front-proxy-ca路径下。 cat > front-proxy-client-csr.json << EOF { "CN": "front-proxy-client", "key": { "algo": "rsa", "size": 2048 } } EOF # 这是一个JSON格式的配置文件，用于描述一个名为"front-proxy-client"的配置。配置包括两个字段：CN和key。 # - CN（Common Name）字段表示证书的通用名称，这里为"front-proxy-client"。 # - key字段描述了密钥的算法和大小。"algo"表示使用RSA算法，"size"表示密钥大小为2048位。 # 该配置文件用于生成一个SSL证书，用于在前端代理客户端进行认证和数据传输的加密。这个证书中的通用名称是"front-proxy-client"，使用RSA算法生成，密钥大小为2048位。 cfssl gencert \ -ca=/etc/kubernetes/pki/front-proxy-ca.pem \ -ca-key=/etc/kubernetes/pki/front-proxy-ca-key.pem \ -config=ca-config.json \ -profile=kubernetes front-proxy-client-csr.json | cfssljson -bare /etc/kubernetes/pki/front-proxy-client # 这个命令使用cfssl工具生成一个用于Kubernetes的front-proxy-client证书。 # 主要参数解释如下： # - `-ca=/etc/kubernetes/pki/front-proxy-ca.pem`: 指定用于签署证书的根证书文件路径。 # - `-ca-key=/etc/kubernetes/pki/front-proxy-ca-key.pem`: 指定用于签署证书的根证书的私钥文件路径。 # - `-config=ca-config.json`: 指定用于配置证书签署的配置文件路径。该配置文件描述了证书生成的一些规则，如加密算法和有效期等。 # - `-profile=kubernetes`: 指定生成证书时使用的配置文件中定义的profile，其中包含了一些默认的参数。 # - `front-proxy-client-csr.json`: 指定用于生成证书的CSR文件路径，该文件包含了证书请求的相关信息。 # - `| cfssljson -bare /etc/kubernetes/pki/front-proxy-client`: 通过管道将生成的证书输出到cfssljson工具进行解析，并通过`-bare`参数将证书和私钥分别保存到指定路径。 # 这个命令的作用是根据提供的CSR文件和配置信息，使用指定的根证书和私钥生成一个前端代理客户端的证书，并将证书和私钥分别保存到`/etc/kubernetes/pki/front-proxy-client.pem`和`/etc/kubernetes/pki/front-proxy-client-key.pem`文件中。
---
# 4、 生成controller-manage的证书 在《5.高可用配置》选择使用那种高可用方案 若使用 haproxy、keepalived 那么为 --server=https://192.168.123.117:9443 若使用 nginx方案，那么为 --server=https://127.0.0.1:8443 cat > manager-csr.json << EOF { "CN": "system:kube-controller-manager", "key": { "algo": "rsa", "size": 2048 }, "names": [ { "C": "CN", "ST": "Beijing", "L": "Beijing", "O": "system:kube-controller-manager", "OU": "Kubernetes-manual" } ] } EOF # 这是一个用于生成密钥对（公钥和私钥）的JSON配置文件。下面是针对该文件中每个字段的详细解释： # - "CN": 值为"system:kube-controller-manager"，代表通用名称（Common Name），是此密钥对的主题（subject）。 # - "key": 这个字段用来定义密钥算法和大小。 # - "algo": 值为"rsa"，表示使用RSA算法。 # - "size": 值为2048，表示生成的密钥大小为2048位。 # - "names": 这个字段用来定义密钥对的各个名称字段。 # - "C": 值为"CN"，表示国家（Country）名称是"CN"（中国）。 # - "ST": 值为"Beijing"，表示省/州（State/Province）名称是"Beijing"（北京）。 # - "L": 值为"Beijing"，表示城市（Locality）名称是"Beijing"（北京）。 # - "O": 值为"system:kube-controller-manager"，表示组织（Organization）名称是"system:kube-controller-manager"。 # - "OU": 值为"Kubernetes-manual"，表示组织单位（Organizational Unit）名称是"Kubernetes-manual"。 # 这个JSON配置文件基本上是告诉生成密钥对的工具，生成一个带有特定名称和属性的密钥对。 cfssl gencert \ -ca=/etc/kubernetes/pki/ca.pem \ -ca-key=/etc/kubernetes/pki/ca-key.pem \ -config=ca-config.json \ -profile=kubernetes \ manager-csr.json | cfssljson -bare /etc/kubernetes/pki/controller-manager # 这是一个命令行操作，使用cfssl工具生成证书。 # 1. `cfssl gencert` 是cfssl工具的命令，用于生成证书。 # 2. `-ca` 指定根证书的路径和文件名，这里是`/etc/kubernetes/pki/ca.pem`。 # 3. `-ca-key` 指定根证书的私钥的路径和文件名，这里是`/etc/kubernetes/pki/ca-key.pem`。 # 4. `-config` 指定配置文件的路径和文件名，这里是`ca-config.json`。 # 5. `-profile` 指定证书使用的配置文件中的配置模板，这里是`kubernetes`。 # 6. `manager-csr.json` 是证书签发请求的配置文件，用于生成证书签发请求。 # 7. `|` 管道操作符，将前一条命令的输出作为后一条命令的输入。 # 8. `cfssljson -bare` 是 cfssl 工具的命令，作用是将证书签发请求的输出转换为PKCS＃1、PKCS＃8和x509 PEM文件。 # 9. `/etc/kubernetes/pki/controller-manager` 是转换后的 PEM 文件的存储位置和文件名。 # 这个命令的作用是根据根证书和私钥、配置文件以及证书签发请求的配置文件，生成经过签发的控制器管理器证书和私钥，并将转换后的 PEM 文件保存到指定的位置。 # 设置一个集群项 # 在《5.高可用配置》选择使用那种高可用方案 # 若使用 haproxy、keepalived 那么为 `--server=https://192.168.123.117:9443` # 若使用 nginx方案，那么为 `--server=https://127.0.0.1:8443` kubectl config set-cluster kubernetes \ --certificate-authority=/etc/kubernetes/pki/ca.pem \ --embed-certs=true \ --server=https://127.0.0.1:8443 \ --kubeconfig=/etc/kubernetes/controller-manager.kubeconfig # kubectl config set-cluster命令用于配置集群信息。 # --certificate-authority选项指定了集群的证书颁发机构（CA）的路径，这个CA会验证kube-apiserver提供的证书是否合法。 # --embed-certs选项用于将证书嵌入到生成的kubeconfig文件中，这样就不需要在kubeconfig文件中单独指定证书文件路径。 # --server选项指定了kube-apiserver的地址，这里使用的是127.0.0.1:8443，表示使用本地主机上的kube-apiserver，默认端口为8443。 # --kubeconfig选项指定了生成的kubeconfig文件的路径和名称，这里指定为/etc/kubernetes/controller-manager.kubeconfig。 # 综上所述，kubectl config set-cluster命令的作用是在kubeconfig文件中设置集群信息，包括证书颁发机构、证书、kube-apiserver地址等。 # 设置一个环境项，一个上下文 kubectl config set-context system:kube-controller-manager@kubernetes \ --cluster=kubernetes \ --user=system:kube-controller-manager \ --kubeconfig=/etc/kubernetes/controller-manager.kubeconfig # 这个命令用于配置 Kubernetes 控制器管理器的上下文信息。下面是各个参数的详细解释： # 1. `kubectl config set-context system:kube-controller-manager@kubernetes`: 设置上下文的名称为 `system:kube-controller-manager@kubernetes`，这是一个标识符，用于唯一标识该上下文。 # 2. `--cluster=kubernetes`: 指定集群的名称为 `kubernetes`，这是一个现有集群的标识符，表示要管理的 Kubernetes 集群。 # 3. `--user=system:kube-controller-manager`: 指定使用的用户身份为 `system:kube-controller-manager`。这是一个特殊的用户身份，具有控制 Kubernetes 控制器管理器的权限。 # 4. `--kubeconfig=/etc/kubernetes/controller-manager.kubeconfig`: 指定 kubeconfig 文件的路径为 `/etc/kubernetes/controller-manager.kubeconfig`。kubeconfig 文件是一个用于管理 Kubernetes 配置的文件，包含了集群、用户和上下文的相关信息。 # 通过运行这个命令，可以将这些配置信息保存到 `/etc/kubernetes/controller-manager.kubeconfig` 文件中，以便在后续的操作中使用。 # 设置一个用户项 kubectl config set-credentials system:kube-controller-manager \ --client-certificate=/etc/kubernetes/pki/controller-manager.pem \ --client-key=/etc/kubernetes/pki/controller-manager-key.pem \ --embed-certs=true \ --kubeconfig=/etc/kubernetes/controller-manager.kubeconfig # 上述命令是用于设置 Kubernetes 的 controller-manager 组件的客户端凭据。下面是每个参数的详细解释： # - `kubectl config`: 是使用 kubectl 命令行工具的配置子命令。 # - `set-credentials`: 是定义一个新的用户凭据配置的子命令。 # - `system:kube-controller-manager`: 是设置用户凭据的名称，`system:` 是 Kubernetes API Server 内置的身份验证器使用的用户标识符前缀，它表示是一个系统用户，在本例中是 kube-controller-manager 组件使用的身份。 # - `--client-certificate=/etc/kubernetes/pki/controller-manager.pem`: 指定 controller-manager.pem 客户端证书的路径。 # - `--client-key=/etc/kubernetes/pki/controller-manager-key.pem`: 指定 controller-manager-key.pem 客户端私钥的路径。 # - `--embed-certs=true`: 表示将证书和私钥直接嵌入到生成的 kubeconfig 文件中，而不是通过引用外部文件。 # - `--kubeconfig=/etc/kubernetes/controller-manager.kubeconfig`: 指定生成的 kubeconfig 文件的路径和文件名，即 controller-manager.kubeconfig。 # 通过运行上述命令，将根据提供的证书和私钥信息，为 kube-controller-manager 创建一个 kubeconfig 文件，以便后续使用该文件进行身份验证和访问 Kubernetes API。 # 设置默认环境 kubectl config use-context system:kube-controller-manager@kubernetes \ --kubeconfig=/etc/kubernetes/controller-manager.kubeconfig # 这个命令是用来指定kubectl使用指定的上下文环境来执行操作。上下文环境是kubectl用来确定要连接到哪个Kubernetes集群以及使用哪个身份验证信息的配置。 # 在这个命令中，`kubectl config use-context`是用来设置当前上下文环境的命令。 `system:kube-controller-manager@kubernetes`是指定的上下文名称，它告诉kubectl要使用的Kubernetes集群和身份验证信息。 # `--kubeconfig=/etc/kubernetes/controller-manager.kubeconfig`是用来指定使用的kubeconfig文件的路径。kubeconfig文件是存储集群连接和身份验证信息的配置文件。 # 通过执行这个命令，kubectl将使用指定的上下文来执行后续的操作，包括部署和管理Kubernetes资源。
---
# 5、 生成kube-scheduler的证书 cat > scheduler-csr.json << EOF { "CN": "system:kube-scheduler", "key": { "algo": "rsa", "size": 2048 }, "names": [ { "C": "CN", "ST": "Beijing", "L": "Beijing", "O": "system:kube-scheduler", "OU": "Kubernetes-manual" } ] } EOF # 这个命令是用来创建一个叫做scheduler-csr.json的文件，并将其中的内容赋值给该文件。 # 文件内容是一个JSON格式的文本，包含了一个描述证书请求的结构。 # 具体内容如下： # - "CN": "system:kube-scheduler"：Common Name字段，表示该证书的名称为system:kube-scheduler。 # - "key": {"algo": "rsa", "size": 2048}：key字段指定生成证书时使用的加密算法是RSA，并且密钥的长度为2048位。 # - "names": [...]：names字段定义了证书中的另外一些标识信息。 # - "C": "CN"：Country字段，表示国家/地区为中国。 # - "ST": "Beijing"：State字段，表示省/市为北京。 # - "L": "Beijing"：Locality字段，表示所在城市为北京。 # - "O": "system:kube-scheduler"：Organization字段，表示组织为system:kube-scheduler。 # - "OU": "Kubernetes-manual"：Organizational Unit字段，表示组织单元为Kubernetes-manual。 # 而EOF是一个占位符，用于标记开始和结束的位置。在开始的EOF之后到结束的EOF之间的内容将会被写入到scheduler-csr.json文件中。 # 总体来说，这个命令用于生成一个描述kube-scheduler证书请求的JSON文件。 cfssl gencert \ -ca=/etc/kubernetes/pki/ca.pem \ -ca-key=/etc/kubernetes/pki/ca-key.pem \ -config=ca-config.json \ -profile=kubernetes \ scheduler-csr.json | cfssljson -bare /etc/kubernetes/pki/scheduler # 上述命令是使用cfssl工具生成Kubernetes Scheduler的证书。 # 具体解释如下： # 1. `cfssl gencert`：使用cfssl工具生成证书。 # 2. `-ca=/etc/kubernetes/pki/ca.pem`：指定根证书文件的路径。在这里，是指定根证书的路径为`/etc/kubernetes/pki/ca.pem`。 # 3. `-ca-key=/etc/kubernetes/pki/ca-key.pem`：指定根证书私钥文件的路径。在这里，是指定根证书私钥的路径为`/etc/kubernetes/pki/ca-key.pem`。 # 4. `-config=ca-config.json`：指定证书配置文件的路径。在这里，是指定证书配置文件的路径为`ca-config.json`。 # 5. `-profile=kubernetes`：指定证书的配置文件中的一个配置文件模板。在这里，是指定配置文件中的`kubernetes`配置模板。 # 6. `scheduler-csr.json`：指定Scheduler的证书签名请求文件（CSR）的路径。在这里，是指定请求文件的路径为`scheduler-csr.json`。 # 7. `|`（管道符号）：将前一个命令的输出作为下一个命令的输入。 # 8. `cfssljson`：将cfssl工具生成的证书签名请求(CSR)进行解析。 # 9. `-bare /etc/kubernetes/pki/scheduler`：指定输出路径和前缀。在这里，是将解析的证书签名请求生成以下文件：`/etc/kubernetes/pki/scheduler.pem`（包含了证书）、`/etc/kubernetes/pki/scheduler-key.pem`（包含了私钥）。 # 总结来说，这个命令的目的是根据根证书、根证书私钥、证书配置文件、CSR文件等生成Kubernetes Scheduler的证书和私钥文件。 # 在《5.高可用配置》选择使用那种高可用方案 # 若使用 haproxy、keepalived 那么为 `--server=https://192.168.123.117:9443` # 若使用 nginx方案，那么为 `--server=https://127.0.0.1:8443` kubectl config set-cluster kubernetes \ --certificate-authority=/etc/kubernetes/pki/ca.pem \ --embed-certs=true \ --server=https://127.0.0.1:8443 \ --kubeconfig=/etc/kubernetes/scheduler.kubeconfig # 该命令用于配置一个名为"kubernetes"的集群，并将其应用到/etc/kubernetes/scheduler.kubeconfig文件中。 # 该命令的解释如下： # - `kubectl config set-cluster kubernetes`: 设置一个集群并命名为"kubernetes"。 # - `--certificate-authority=/etc/kubernetes/pki/ca.pem`: 指定集群使用的证书授权机构的路径。 # - `--embed-certs=true`: 该标志指示将证书嵌入到生成的kubeconfig文件中。 # - `--server=https://127.0.0.1:8443`: 指定集群的 API server 位置。 # - `--kubeconfig=/etc/kubernetes/scheduler.kubeconfig`: 指定要保存 kubeconfig 文件的路径和名称。 kubectl config set-credentials system:kube-scheduler \ --client-certificate=/etc/kubernetes/pki/scheduler.pem \ --client-key=/etc/kubernetes/pki/scheduler-key.pem \ --embed-certs=true \ --kubeconfig=/etc/kubernetes/scheduler.kubeconfig # 这段命令是用于设置 kube-scheduler 组件的身份验证凭据，并生成相应的 kubeconfig 文件。 # 解释每个选项的含义如下： # - `kubectl config set-credentials system:kube-scheduler`：设置 `system:kube-scheduler` 用户的身份验证凭据。 # - `--client-certificate=/etc/kubernetes/pki/scheduler.pem`：指定一个客户端证书文件，用于基于证书的身份验证。在这种情况下，指定了 kube-scheduler 组件的证书文件路径。 # - `--client-key=/etc/kubernetes/pki/scheduler-key.pem`：指定与客户端证书相对应的客户端私钥文件。 # - `--embed-certs=true`：将客户端证书和私钥嵌入到生成的 kubeconfig 文件中。 # - `--kubeconfig=/etc/kubernetes/scheduler.kubeconfig`：指定生成的 kubeconfig 文件的路径和名称。 # 该命令的目的是为 kube-scheduler 组件生成一个 kubeconfig 文件，以便进行身份验证和访问集群资源。kubeconfig 文件是一个包含了连接到 Kubernetes 集群所需的所有配置信息的文件，包括服务器地址、证书和秘钥等。 kubectl config set-context system:kube-scheduler@kubernetes \ --cluster=kubernetes \ --user=system:kube-scheduler \ --kubeconfig=/etc/kubernetes/scheduler.kubeconfig # 该命令用于设置一个名为"system:kube-scheduler@kubernetes"的上下文，具体配置如下： # 1. --cluster=kubernetes: 指定集群的名称为"kubernetes"，这个集群是在当前的kubeconfig文件中已经定义好的。 # 2. --user=system:kube-scheduler: 指定用户的名称为"system:kube-scheduler"，这个用户也是在当前的kubeconfig文件中已经定义好的。这个用户用于认证和授权kube-scheduler组件访问Kubernetes集群的权限。 # 3. --kubeconfig=/etc/kubernetes/scheduler.kubeconfig: 指定kubeconfig文件的路径为"/etc/kubernetes/scheduler.kubeconfig"，这个文件将被用来保存上下文的配置信息。 # 这个命令的作用是将上述的配置信息保存到指定的kubeconfig文件中，以便后续使用该文件进行认证和授权访问Kubernetes集群。 kubectl config use-context system:kube-scheduler@kubernetes \ --kubeconfig=/etc/kubernetes/scheduler.kubeconfig # 上述命令是使用`kubectl`命令来配置Kubernetes集群中的调度器组件。 # `kubectl config use-context`命令用于切换`kubectl`当前使用的上下文。上下文是Kubernetes集群、用户和命名空间的组合，用于确定`kubectl`的连接目标。下面解释这个命令的不同部分： # - `system:kube-scheduler@kubernetes`是一个上下文名称。它指定了使用`kube-scheduler`用户和`kubernetes`命名空间的系统级别上下文。系统级别上下文用于操作Kubernetes核心组件。 # - `--kubeconfig=/etc/kubernetes/scheduler.kubeconfig`用于指定Kubernetes配置文件的路径。Kubernetes配置文件包含连接到Kubernetes集群所需的身份验证和连接信息。 # 通过运行以上命令，`kubectl`将使用指定的上下文和配置文件，以便在以后的命令中能正确地与Kubernetes集群中的调度器组件进行交互。
---
# 6、生成admin的证书配置 cat > admin-csr.json << EOF { "CN": "admin", "key": { "algo": "rsa", "size": 2048 }, "names": [ { "C": "CN", "ST": "Beijing", "L": "Beijing", "O": "system:masters", "OU": "Kubernetes-manual" } ] } EOF # 这段代码是一个JSON格式的配置文件，用于创建和配置一个名为"admin"的Kubernetes凭证。 # 这个凭证包含以下字段： # - "CN": "admin": 这是凭证的通用名称，表示这是一个管理员凭证。 # - "key": 这是一个包含证书密钥相关信息的对象。 # - "algo": "rsa"：这是使用的加密算法类型，这里是RSA加密算法。 # - "size": 2048：这是密钥的大小，这里是2048位。 # - "names": 这是一个包含证书名称信息的数组。 # - "C": "CN"：这是证书的国家/地区字段，这里是中国。 # - "ST": "Beijing"：这是证书的省/州字段，这里是北京。 # - "L": "Beijing"：这是证书的城市字段，这里是北京。 # - "O": "system:masters"：这是证书的组织字段，这里是system:masters，表示系统的管理员组。 # - "OU": "Kubernetes-manual"：这是证书的部门字段，这里是Kubernetes-manual。 # 通过这个配置文件创建的凭证将具有管理员权限，并且可以用于管理Kubernetes集群。 cfssl gencert \ -ca=/etc/kubernetes/pki/ca.pem \ -ca-key=/etc/kubernetes/pki/ca-key.pem \ -config=ca-config.json \ -profile=kubernetes \ admin-csr.json | cfssljson -bare /etc/kubernetes/pki/admin # 上述命令是使用cfssl工具生成Kubernetes admin的证书。 # 具体解释如下： # 1. `cfssl gencert`：使用cfssl工具生成证书。 # 2. `-ca=/etc/kubernetes/pki/ca.pem`：指定根证书文件的路径。在这里，是指定根证书的路径为`/etc/kubernetes/pki/ca.pem`。 # 3. `-ca-key=/etc/kubernetes/pki/ca-key.pem`：指定根证书私钥文件的路径。在这里，是指定根证书私钥的路径为`/etc/kubernetes/pki/ca-key.pem`。 # 4. `-config=ca-config.json`：指定证书配置文件的路径。在这里，是指定证书配置文件的路径为`ca-config.json`。 # 5. `-profile=kubernetes`：指定证书的配置文件中的一个配置文件模板。在这里，是指定配置文件中的`kubernetes`配置模板。 # 6. `admin-csr.json`：指定admin的证书签名请求文件（CSR）的路径。在这里，是指定请求文件的路径为`admin-csr.json`。 # 7. `|`（管道符号）：将前一个命令的输出作为下一个命令的输入。 # 8. `cfssljson`：将cfssl工具生成的证书签名请求(CSR)进行解析。 # 9. `-bare /etc/kubernetes/pki/admin`：指定输出路径和前缀。在这里，是将解析的证书签名请求生成以下文件：`/etc/kubernetes/pki/admin.pem`（包含了证书）、`/etc/kubernetes/pki/admin-key.pem`（包含了私钥）。 # 总结来说，这个命令的目的是根据根证书、根证书私钥、证书配置文件、CSR文件等生成Kubernetes Scheduler的证书和私钥文件。 # 在《5.高可用配置》选择使用那种高可用方案 # 若使用 haproxy、keepalived 那么为 `--server=https://192.168.123.117:9443` # 若使用 nginx方案，那么为 `--server=https://127.0.0.1:8443` kubectl config set-cluster kubernetes \ --certificate-authority=/etc/kubernetes/pki/ca.pem \ --embed-certs=true \ --server=https://127.0.0.1:8443 \ --kubeconfig=/etc/kubernetes/admin.kubeconfig # 该命令用于配置一个名为"kubernetes"的集群，并将其应用到/etc/kubernetes/scheduler.kubeconfig文件中。 # 该命令的解释如下： # - `kubectl config set-cluster kubernetes`: 设置一个集群并命名为"kubernetes"。 # - `--certificate-authority=/etc/kubernetes/pki/ca.pem`: 指定集群使用的证书授权机构的路径。 # - `--embed-certs=true`: 该标志指示将证书嵌入到生成的kubeconfig文件中。 # - `--server=https://127.0.0.1:8443`: 指定集群的 API server 位置。 # - `--kubeconfig=/etc/kubernetes/admin.kubeconfig`: 指定要保存 kubeconfig 文件的路径和名称。 kubectl config set-credentials kubernetes-admin \ --client-certificate=/etc/kubernetes/pki/admin.pem \ --client-key=/etc/kubernetes/pki/admin-key.pem \ --embed-certs=true \ --kubeconfig=/etc/kubernetes/admin.kubeconfig # 这段命令是用于设置 kubernetes-admin 组件的身份验证凭据，并生成相应的 kubeconfig 文件。 # 解释每个选项的含义如下： # - `kubectl config set-credentials kubernetes-admin`：设置 `kubernetes-admin` 用户的身份验证凭据。 # - `--client-certificate=/etc/kubernetes/pki/admin.pem`：指定一个客户端证书文件，用于基于证书的身份验证。在这种情况下，指定了 admin 组件的证书文件路径。 # - `--client-key=/etc/kubernetes/pki/admin-key.pem`：指定与客户端证书相对应的客户端私钥文件。 # - `--embed-certs=true`：将客户端证书和私钥嵌入到生成的 kubeconfig 文件中。 # - `--kubeconfig=/etc/kubernetes/admin.kubeconfig`：指定生成的 kubeconfig 文件的路径和名称。 # 该命令的目的是为 admin 组件生成一个 kubeconfig 文件，以便进行身份验证和访问集群资源。kubeconfig 文件是一个包含了连接到 Kubernetes 集群所需的所有配置信息的文件，包括服务器地址、证书和秘钥等。 kubectl config set-context kubernetes-admin@kubernetes \ --cluster=kubernetes \ --user=kubernetes-admin \ --kubeconfig=/etc/kubernetes/admin.kubeconfig # 该命令用于设置一个名为"kubernetes-admin@kubernetes"的上下文，具体配置如下： # 1. --cluster=kubernetes: 指定集群的名称为"kubernetes"，这个集群是在当前的kubeconfig文件中已经定义好的。 # 2. --user=kubernetes-admin: 指定用户的名称为"kubernetes-admin"，这个用户也是在当前的kubeconfig文件中已经定义好的。这个用户用于认证和授权admin组件访问Kubernetes集群的权限。 # 3. --kubeconfig=/etc/kubernetes/admin.kubeconfig: 指定kubeconfig文件的路径为"/etc/kubernetes/admin.kubeconfig"，这个文件将被用来保存上下文的配置信息。 # 这个命令的作用是将上述的配置信息保存到指定的kubeconfig文件中，以便后续使用该文件进行认证和授权访问Kubernetes集群。 kubectl config use-context kubernetes-admin@kubernetes --kubeconfig=/etc/kubernetes/admin.kubeconfig # 上述命令是使用`kubectl`命令来配置Kubernetes集群中的调度器组件。 # `kubectl config use-context`命令用于切换`kubectl`当前使用的上下文。上下文是Kubernetes集群、用户和命名空间的组合，用于确定`kubectl`的连接目标。下面解释这个命令的不同部分： # - `kubernetes-admin@kubernetes`是一个上下文名称。它指定了使用`kubernetes-admin`用户和`kubernetes`命名空间的系统级别上下文。系统级别上下文用于操作Kubernetes核心组件。 # - `--kubeconfig=/etc/kubernetes/admin.kubeconfig`用于指定Kubernetes配置文件的路径。Kubernetes配置文件包含连接到Kubernetes集群所需的身份验证和连接信息。 # 通过运行以上命令，`kubectl`将使用指定的上下文和配置文件，以便在以后的命令中能正确地与Kubernetes集群中的调度器组件进行交互。
---
# 7、创建kube-proxy证书 在《5.高可用配置》选择使用那种高可用方案 若使用 haproxy、keepalived 那么为 --server=https://192.168.123.117:9443 若使用 nginx方案，那么为 --server=https://127.0.0.1:8443 cat > kube-proxy-csr.json << EOF { "CN": "system:kube-proxy", "key": { "algo": "rsa", "size": 2048 }, "names": [ { "C": "CN", "ST": "Beijing", "L": "Beijing", "O": "system:kube-proxy", "OU": "Kubernetes-manual" } ] } EOF # 这段代码是一个JSON格式的配置文件，用于创建和配置一个名为"kube-proxy-csr"的Kubernetes凭证。 # 这个凭证包含以下字段： # - "CN": "system:kube-proxy": 这是凭证的通用名称，表示这是一个管理员凭证。 # - "key": 这是一个包含证书密钥相关信息的对象。 # - "algo": "rsa"：这是使用的加密算法类型，这里是RSA加密算法。 # - "size": 2048：这是密钥的大小，这里是2048位。 # - "names": 这是一个包含证书名称信息的数组。 # - "C": "CN"：这是证书的国家/地区字段，这里是中国。 # - "ST": "Beijing"：这是证书的省/州字段，这里是北京。 # - "L": "Beijing"：这是证书的城市字段，这里是北京。 # - "O": "system:kube-proxy"：这是证书的组织字段，这里是system:kube-proxy。 # - "OU": "Kubernetes-manual"：这是证书的部门字段，这里是Kubernetes-manual。 # # 通过这个配置文件创建的凭证将具有管理员权限，并且可以用于管理Kubernetes集群。 cfssl gencert \ -ca=/etc/kubernetes/pki/ca.pem \ -ca-key=/etc/kubernetes/pki/ca-key.pem \ -config=ca-config.json \ -profile=kubernetes \ kube-proxy-csr.json | cfssljson -bare /etc/kubernetes/pki/kube-proxy # 上述命令是使用cfssl工具生成Kubernetes admin的证书。 # # 具体解释如下： # # 1. `cfssl gencert`：使用cfssl工具生成证书。 # 2. `-ca=/etc/kubernetes/pki/ca.pem`：指定根证书文件的路径。在这里，是指定根证书的路径为`/etc/kubernetes/pki/ca.pem`。 # 3. `-ca-key=/etc/kubernetes/pki/ca-key.pem`：指定根证书私钥文件的路径。在这里，是指定根证书私钥的路径为`/etc/kubernetes/pki/ca-key.pem`。 # 4. `-config=ca-config.json`：指定证书配置文件的路径。在这里，是指定证书配置文件的路径为`ca-config.json`。 # 5. `-profile=kubernetes`：指定证书的配置文件中的一个配置文件模板。在这里，是指定配置文件中的`kubernetes`配置模板。 # 6. `kube-proxy-csr.json`：指定admin的证书签名请求文件（CSR）的路径。在这里，是指定请求文件的路径为`kube-proxy-csr.json`。 # 7. `|`（管道符号）：将前一个命令的输出作为下一个命令的输入。 # 8. `cfssljson`：将cfssl工具生成的证书签名请求(CSR)进行解析。 # 9. `-bare /etc/kubernetes/pki/kube-proxy`：指定输出路径和前缀。在这里，是将解析的证书签名请求生成以下文件：`/etc/kubernetes/pki/kube-proxy.pem`（包含了证书）、`/etc/kubernetes/pki/kube-proxy-key.pem`（包含了私钥）。 # # 总结来说，这个命令的目的是根据根证书、根证书私钥、证书配置文件、CSR文件等生成Kubernetes Scheduler的证书和私钥文件。 # 在《5.高可用配置》选择使用那种高可用方案 # 若使用 haproxy、keepalived 那么为 `--server=https://192.168.123.117:9443` # 若使用 nginx方案，那么为 `--server=https://127.0.0.1:8443` kubectl config set-cluster kubernetes \ --certificate-authority=/etc/kubernetes/pki/ca.pem \ --embed-certs=true \ --server=https://127.0.0.1:8443 \ --kubeconfig=/etc/kubernetes/kube-proxy.kubeconfig # 该命令用于配置一个名为"kubernetes"的集群，并将其应用到/etc/kubernetes/kube-proxy.kubeconfig文件中。 # # 该命令的解释如下： # - `kubectl config set-cluster kubernetes`: 设置一个集群并命名为"kubernetes"。 # - `--certificate-authority=/etc/kubernetes/pki/ca.pem`: 指定集群使用的证书授权机构的路径。 # - `--embed-certs=true`: 该标志指示将证书嵌入到生成的kubeconfig文件中。 # - `--server=https://127.0.0.1:8443`: 指定集群的 API server 位置。 # - `--kubeconfig=/etc/kubernetes/kube-proxy.kubeconfig`: 指定要保存 kubeconfig 文件的路径和名称。 kubectl config set-credentials kube-proxy \ --client-certificate=/etc/kubernetes/pki/kube-proxy.pem \ --client-key=/etc/kubernetes/pki/kube-proxy-key.pem \ --embed-certs=true \ --kubeconfig=/etc/kubernetes/kube-proxy.kubeconfig # 这段命令是用于设置 kube-proxy 组件的身份验证凭据，并生成相应的 kubeconfig 文件。 # # 解释每个选项的含义如下： # - `kubectl config set-credentials kube-proxy`：设置 `kube-proxy` 用户的身份验证凭据。 # - `--client-certificate=/etc/kubernetes/pki/kube-proxy.pem`：指定一个客户端证书文件，用于基于证书的身份验证。在这种情况下，指定了 kube-proxy 组件的证书文件路径。 # - `--client-key=/etc/kubernetes/pki/kube-proxy-key.pem`：指定与客户端证书相对应的客户端私钥文件。 # - `--embed-certs=true`：将客户端证书和私钥嵌入到生成的 kubeconfig 文件中。 # - `--kubeconfig=/etc/kubernetes/kube-proxy.kubeconfig`：指定生成的 kubeconfig 文件的路径和名称。 # # 该命令的目的是为 kube-proxy 组件生成一个 kubeconfig 文件，以便进行身份验证和访问集群资源。kubeconfig 文件是一个包含了连接到 Kubernetes 集群所需的所有配置信息的文件，包括服务器地址、证书和秘钥等。 kubectl config set-context kube-proxy@kubernetes \ --cluster=kubernetes \ --user=kube-proxy \ --kubeconfig=/etc/kubernetes/kube-proxy.kubeconfig # 该命令用于设置一个名为"kube-proxy@kubernetes"的上下文，具体配置如下： # # 1. --cluster=kubernetes: 指定集群的名称为"kubernetes"，这个集群是在当前的kubeconfig文件中已经定义好的。 # 2. --user=kube-proxy: 指定用户的名称为"kube-proxy"，这个用户也是在当前的kubeconfig文件中已经定义好的。这个用户用于认证和授权kube-proxy组件访问Kubernetes集群的权限。 # 3. --kubeconfig=/etc/kubernetes/kube-proxy.kubeconfig: 指定kubeconfig文件的路径为"/etc/kubernetes/kube-proxy.kubeconfig"，这个文件将被用来保存上下文的配置信息。 # # 这个命令的作用是将上述的配置信息保存到指定的kubeconfig文件中，以便后续使用该文件进行认证和授权访问Kubernetes集群。 kubectl config use-context kube-proxy@kubernetes --kubeconfig=/etc/kubernetes/kube-proxy.kubeconfig # 上述命令是使用`kubectl`命令来配置Kubernetes集群中的调度器组件。 # # `kubectl config use-context`命令用于切换`kubectl`当前使用的上下文。上下文是Kubernetes集群、用户和命名空间的组合，用于确定`kubectl`的连接目标。下面解释这个命令的不同部分： # # - `kube-proxy@kubernetes`是一个上下文名称。它指定了使用`kube-proxy`用户和`kubernetes`命名空间的系统级别上下文。系统级别上下文用于操作Kubernetes核心组件。 # # - `--kubeconfig=/etc/kubernetes/kube-proxy.kubeconfig`用于指定Kubernetes配置文件的路径。Kubernetes配置文件包含连接到Kubernetes集群所需的身份验证和连接信息。 # # 通过运行以上命令，`kubectl`将使用指定的上下文和配置文件，以便在以后的命令中能正确地与Kubernetes集群中的调度器组件进行交互。
---
# 8、 创建ServiceAccount Key ——secret openssl genrsa -out /etc/kubernetes/pki/sa.key 2048 openssl rsa -in /etc/kubernetes/pki/sa.key -pubout -out /etc/kubernetes/pki/sa.pub # 这两个命令是使用OpenSSL工具生成RSA密钥对。 # # 命令1：openssl genrsa -out /etc/kubernetes/pki/sa.key 2048 # 该命令用于生成私钥文件。具体解释如下： # - openssl：openssl命令行工具。 # - genrsa：生成RSA密钥对。 # - -out /etc/kubernetes/pki/sa.key：指定输出私钥文件的路径和文件名。 # - 2048：指定密钥长度为2048位。 # # 命令2：openssl rsa -in /etc/kubernetes/pki/sa.key -pubout -out /etc/kubernetes/pki/sa.pub # 该命令用于从私钥中导出公钥。具体解释如下： # - openssl：openssl命令行工具。 # - rsa：与私钥相关的RSA操作。 # - -in /etc/kubernetes/pki/sa.key：指定输入私钥文件的路径和文件名。 # - -pubout：指定输出公钥。 # - -out /etc/kubernetes/pki/sa.pub：指定输出公钥文件的路径和文件名。 # # 总结：通过以上两个命令，我们可以使用OpenSSL工具生成一个RSA密钥对，并将私钥保存在/etc/kubernetes/pki/sa.key文件中，将公钥保存在/etc/kubernetes/pki/sa.pub文件中。
---
# 9、将证书发送到其他master节点 #其他节点创建目录 # mkdir /etc/kubernetes/pki/ -p for NODE in k8s-master02 k8s-master03; do for FILE in $(ls /etc/kubernetes/pki | grep -v etcd); do scp /etc/kubernetes/pki/${FILE} $NODE:/etc/kubernetes/pki/${FILE}; done; for FILE in admin.kubeconfig controller-manager.kubeconfig scheduler.kubeconfig; do scp /etc/kubernetes/${FILE} $NODE:/etc/kubernetes/${FILE}; done; done
---
# 10、查看证书 ll /etc/kubernetes/pki/ 总用量 104 -rw-r--r-- 1 root root 1025 8月 30 18:58 admin.csr -rw------- 1 root root 1675 8月 30 18:58 admin-key.pem -rw-r--r-- 1 root root 1444 8月 30 18:58 admin.pem -rw-r--r-- 1 root root 1415 8月 30 18:58 apiserver.csr -rw------- 1 root root 1679 8月 30 18:58 apiserver-key.pem -rw-r--r-- 1 root root 1805 8月 30 18:58 apiserver.pem -rw-r--r-- 1 root root 1070 8月 30 18:58 ca.csr -rw------- 1 root root 1679 8月 30 18:58 ca-key.pem -rw-r--r-- 1 root root 1363 8月 30 18:58 ca.pem -rw-r--r-- 1 root root 1082 8月 30 18:58 controller-manager.csr -rw------- 1 root root 1675 8月 30 18:58 controller-manager-key.pem -rw-r--r-- 1 root root 1501 8月 30 18:58 controller-manager.pem -rw-r--r-- 1 root root 940 8月 30 18:58 front-proxy-ca.csr -rw------- 1 root root 1675 8月 30 18:58 front-proxy-ca-key.pem -rw-r--r-- 1 root root 1094 8月 30 18:58 front-proxy-ca.pem -rw-r--r-- 1 root root 903 8月 30 18:58 front-proxy-client.csr -rw------- 1 root root 1675 8月 30 18:58 front-proxy-client-key.pem -rw-r--r-- 1 root root 1188 8月 30 18:58 front-proxy-client.pem -rw-r--r-- 1 root root 1045 8月 30 18:58 kube-proxy.csr -rw------- 1 root root 1675 8月 30 18:58 kube-proxy-key.pem -rw-r--r-- 1 root root 1464 8月 30 18:58 kube-proxy.pem -rw------- 1 root root 1708 8月 30 18:58 sa.key -rw-r--r-- 1 root root 451 8月 30 18:58 sa.pub -rw-r--r-- 1 root root 1058 8月 30 18:58 scheduler.csr -rw------- 1 root root 1675 8月 30 18:58 scheduler-key.pem -rw-r--r-- 1 root root 1476 8月 30 18:58 scheduler.pem # 一共26个就对了 # ls /etc/kubernetes/pki/ |wc -l 26
4、k8s系统组件配置
etcd配置
这个配置文件是用于 etcd 集群的配置，其中包含了一些重要的参数和选项： - `name`：指定了当前节点的名称，用于集群中区分不同的节点。 - `data-dir`：指定了 etcd 数据的存储目录。 - `wal-dir`：指定了 etcd 数据写入磁盘的目录。 - `snapshot-count`：指定了触发快照的事务数量。 - `heartbeat-interval`：指定了 etcd 集群中节点之间的心跳间隔。 - `election-timeout`：指定了选举超时时间。 - `quota-backend-bytes`：指定了存储的限额，0 表示无限制。 - `listen-peer-urls`：指定了节点之间通信的 URL，使用 HTTPS 协议。 - `listen-client-urls`：指定了客户端访问 etcd 集群的 URL，同时提供了本地访问的 URL。 - `max-snapshots`：指定了快照保留的数量。 - `max-wals`：指定了日志保留的数量。 - `initial-advertise-peer-urls`：指定了节点之间通信的初始 URL。 - `advertise-client-urls`：指定了客户端访问 etcd 集群的初始 URL。 - `discovery`：定义了 etcd 集群发现相关的选项。 - `initial-cluster`：指定了 etcd 集群的初始成员。 - `initial-cluster-token`：指定了集群的 token。 - `initial-cluster-state`：指定了集群的初始状态。 - `strict-reconfig-check`：指定了严格的重新配置检查选项。 - `enable-v2`：启用了 v2 API。 - `enable-pprof`：启用了性能分析。 - `proxy`：设置了代理模式。 - `client-transport-security`：客户端的传输安全配置。 - `peer-transport-security`：节点之间的传输安全配置。 - `debug`：是否启用调试模式。 - `log-package-levels`：日志的输出级别。 - `log-outputs`：指定了日志的输出类型。 - `force-new-cluster`：是否强制创建一个新的集群。 这些参数和选项可以根据实际需求进行调整和配置。
master01配置
cat > /etc/etcd/etcd.config.yml << EOF name: 'k8s-master01' data-dir: /var/lib/etcd wal-dir: /var/lib/etcd/wal snapshot-count: 5000 heartbeat-interval: 100 election-timeout: 1000 quota-backend-bytes: 0 listen-peer-urls: 'https://192.168.123.111:2380' listen-client-urls: 'https://192.168.123.111:2379,http://127.0.0.1:2379' max-snapshots: 3 max-wals: 5 cors: initial-advertise-peer-urls: 'https://192.168.123.111:2380' advertise-client-urls: 'https://192.168.123.111:2379' discovery: discovery-fallback: 'proxy' discovery-proxy: discovery-srv: initial-cluster: 'k8s-master01=https://192.168.123.111:2380,k8s-master02=https://192.168.123.112:2380,k8s-master03=https://192.168.123.113:2380' initial-cluster-token: 'etcd-k8s-cluster' initial-cluster-state: 'new' strict-reconfig-check: false enable-v2: true enable-pprof: true proxy: 'off' proxy-failure-wait: 5000 proxy-refresh-interval: 30000 proxy-dial-timeout: 1000 proxy-write-timeout: 5000 proxy-read-timeout: 0 client-transport-security: cert-file: '/etc/kubernetes/pki/etcd/etcd.pem' key-file: '/etc/kubernetes/pki/etcd/etcd-key.pem' client-cert-auth: true trusted-ca-file: '/etc/kubernetes/pki/etcd/etcd-ca.pem' auto-tls: true peer-transport-security: cert-file: '/etc/kubernetes/pki/etcd/etcd.pem' key-file: '/etc/kubernetes/pki/etcd/etcd-key.pem' peer-client-cert-auth: true trusted-ca-file: '/etc/kubernetes/pki/etcd/etcd-ca.pem' auto-tls: true debug: false log-package-levels: log-outputs: [default] force-new-cluster: false EOF
master02配置
cat > /etc/etcd/etcd.config.yml << EOF name: 'k8s-master02' data-dir: /var/lib/etcd wal-dir: /var/lib/etcd/wal snapshot-count: 5000 heartbeat-interval: 100 election-timeout: 1000 quota-backend-bytes: 0 listen-peer-urls: 'https://192.168.123.112:2380' listen-client-urls: 'https://192.168.123.112:2379,http://127.0.0.1:2379' max-snapshots: 3 max-wals: 5 cors: initial-advertise-peer-urls: 'https://192.168.123.112:2380' advertise-client-urls: 'https://192.168.123.112:2379' discovery: discovery-fallback: 'proxy' discovery-proxy: discovery-srv: initial-cluster: 'k8s-master01=https://192.168.123.111:2380,k8s-master02=https://192.168.123.112:2380,k8s-master03=https://192.168.123.113:2380' initial-cluster-token: 'etcd-k8s-cluster' initial-cluster-state: 'new' strict-reconfig-check: false enable-v2: true enable-pprof: true proxy: 'off' proxy-failure-wait: 5000 proxy-refresh-interval: 30000 proxy-dial-timeout: 1000 proxy-write-timeout: 5000 proxy-read-timeout: 0 client-transport-security: cert-file: '/etc/kubernetes/pki/etcd/etcd.pem' key-file: '/etc/kubernetes/pki/etcd/etcd-key.pem' client-cert-auth: true trusted-ca-file: '/etc/kubernetes/pki/etcd/etcd-ca.pem' auto-tls: true peer-transport-security: cert-file: '/etc/kubernetes/pki/etcd/etcd.pem' key-file: '/etc/kubernetes/pki/etcd/etcd-key.pem' peer-client-cert-auth: true trusted-ca-file: '/etc/kubernetes/pki/etcd/etcd-ca.pem' auto-tls: true debug: false log-package-levels: log-outputs: [default] force-new-cluster: false EOF
master03配置
cat > /etc/etcd/etcd.config.yml << EOF name: 'k8s-master03' data-dir: /var/lib/etcd wal-dir: /var/lib/etcd/wal snapshot-count: 5000 heartbeat-interval: 100 election-timeout: 1000 quota-backend-bytes: 0 listen-peer-urls: 'https://192.168.123.113:2380' listen-client-urls: 'https://192.168.123.113:2379,http://127.0.0.1:2379' max-snapshots: 3 max-wals: 5 cors: initial-advertise-peer-urls: 'https://192.168.123.113:2380' advertise-client-urls: 'https://192.168.123.113:2379' discovery: discovery-fallback: 'proxy' discovery-proxy: discovery-srv: initial-cluster: 'k8s-master01=https://192.168.123.111:2380,k8s-master02=https://192.168.123.112:2380,k8s-master03=https://192.168.123.113:2380' initial-cluster-token: 'etcd-k8s-cluster' initial-cluster-state: 'new' strict-reconfig-check: false enable-v2: true enable-pprof: true proxy: 'off' proxy-failure-wait: 5000 proxy-refresh-interval: 30000 proxy-dial-timeout: 1000 proxy-write-timeout: 5000 proxy-read-timeout: 0 client-transport-security: cert-file: '/etc/kubernetes/pki/etcd/etcd.pem' key-file: '/etc/kubernetes/pki/etcd/etcd-key.pem' client-cert-auth: true trusted-ca-file: '/etc/kubernetes/pki/etcd/etcd-ca.pem' auto-tls: true peer-transport-security: cert-file: '/etc/kubernetes/pki/etcd/etcd.pem' key-file: '/etc/kubernetes/pki/etcd/etcd-key.pem' peer-client-cert-auth: true trusted-ca-file: '/etc/kubernetes/pki/etcd/etcd-ca.pem' auto-tls: true debug: false log-package-levels: log-outputs: [default] force-new-cluster: false EOF
创建service（所有master节点操作）
## 创建etcd.service并启动 cat > /usr/lib/systemd/system/etcd.service << EOF [Unit] Description=Etcd Service Documentation=https://coreos.com/etcd/docs/latest/ After=network.target [Service] Type=notify ExecStart=/usr/local/bin/etcd --config-file=/etc/etcd/etcd.config.yml Restart=on-failure RestartSec=10 LimitNOFILE=65536 [Install] WantedBy=multi-user.target Alias=etcd3.service EOF # 这是一个系统服务配置文件，用于启动和管理Etcd服务。 # # [Unit] 部分包含了服务的一些基本信息，它定义了服务的描述和文档链接，并指定了服务应在网络连接之后启动。 # # [Service] 部分定义了服务的具体配置。在这里，服务的类型被设置为notify，意味着当服务成功启动时，它将通知系统。ExecStart 指定了启动服务时要执行的命令，这里是运行 /usr/local/bin/etcd 命令并传递一个配置文件 /etc/etcd/etcd.config.yml。Restart 设置为 on-failure，意味着当服务失败时将自动重启，并且在10秒后进行重启。LimitNOFILE 指定了服务的最大文件打开数。 # # [Install] 部分定义了服务的安装配置。WantedBy 指定了服务应该被启动的目标，这里是 multi-user.target，表示在系统进入多用户模式时启动。Alias 定义了一个别名，可以通过etcd3.service来引用这个服务。 # # 这个配置文件描述了如何启动和管理Etcd服务，并将其安装到系统中。通过这个配置文件，可以确保Etcd服务在系统启动后自动启动，并在出现问题时进行重启。
创建etcd证书目录
mkdir /etc/kubernetes/pki/etcd ln -s /etc/etcd/ssl/* /etc/kubernetes/pki/etcd/ systemctl daemon-reload # 用于重新加载systemd管理的单位文件。当你新增或修改了某个单位文件（如.service文件、.socket文件等），需要运行该命令来刷新systemd对该文件的配置。 systemctl enable --now etcd.service # 启用并立即启动etcd.service单元。etcd.service是etcd守护进程的systemd服务单元。 systemctl restart etcd.service # 重启etcd.service单元，即重新启动etcd守护进程。 systemctl status etcd.service # etcd.service单元的当前状态，包括运行状态、是否启用等信息。
查看etcd状态
# 如果要用IPv6那么把IPv4地址修改为IPv6即可 [root@k8s-master03 cby]# export ETCDCTL_API=3 etcdctl --endpoints="192.168.123.111:2379,192.168.123.112:2379,192.168.123.113:2379" --cacert=/etc/kubernetes/pki/etcd/etcd-ca.pem --cert=/etc/kubernetes/pki/etcd/etcd.pem --key=/etc/kubernetes/pki/etcd/etcd-key.pem endpoint status --write-out=table etcdctl --endpoints="192.168.123.111:2379,192.168.123.112:2379,192.168.123.113:2379" --cacert=/etc/kubernetes/pki/etcd/etcd-ca.pem --cert=/etc/kubernetes/pki/etcd/etcd.pem --key=/etc/kubernetes/pki/etcd/etcd-key.pem endpoint health --write-out=table etcdctl --endpoints="192.168.123.111:2379,192.168.123.112:2379,192.168.123.113:2379" --cacert=/etc/kubernetes/pki/etcd/etcd-ca.pem --cert=/etc/kubernetes/pki/etcd/etcd.pem --key=/etc/kubernetes/pki/etcd/etcd-key.pem member list --write-out=table {"level":"warn","ts":"2025-10-12T14:43:43.009897+0800","caller":"flags/flag.go:94","msg":"unrecognized environment variable","environment-variable":"ETCDCTL_API=3"} +----------------------+------------------+---------+-----------------+---------+--------+-----------------------+-------+-----------+------------+-----------+------------+--------------------+--------+--------------------------+-------------------+ | ENDPOINT | ID | VERSION | STORAGE VERSION | DB SIZE | IN USE | PERCENTAGE NOT IN USE | QUOTA | IS LEADER | IS LEARNER | RAFT TERM | RAFT INDEX | RAFT APPLIED INDEX | ERRORS | DOWNGRADE TARGET VERSION | DOWNGRADE ENABLED | +----------------------+------------------+---------+-----------------+---------+--------+-----------------------+-------+-----------+------------+-----------+------------+--------------------+--------+--------------------------+-------------------+ | 192.168.123.111:2379 | 370925f3502bfb79 | 3.6.4 | 3.6.0 | 20 kB | 16 kB | 20% | 0 B | false | false | 5 | 31 | 31 | | | false | | 192.168.123.112:2379 | f1ad14d186b6ff9e | 3.6.4 | 3.6.0 | 20 kB | 16 kB | 20% | 0 B | false | false | 5 | 31 | 31 | | | false | | 192.168.123.113:2379 | ad30d17b35512abb | 3.6.4 | 3.6.0 | 20 kB | 16 kB | 20% | 0 B | true | false | 5 | 31 | 31 | | | false | +----------------------+------------------+---------+-----------------+---------+--------+-----------------------+-------+-----------+------------+-----------+------------+--------------------+--------+--------------------------+-------------------+ {"level":"warn","ts":"2025-10-12T14:43:43.042136+0800","caller":"flags/flag.go:94","msg":"unrecognized environment variable","environment-variable":"ETCDCTL_API=3"} +----------------------+--------+------------+-------+ | ENDPOINT | HEALTH | TOOK | ERROR | +----------------------+--------+------------+-------+ | 192.168.123.113:2379 | true | 8.915488ms | | | 192.168.123.111:2379 | true | 9.033247ms | | | 192.168.123.112:2379 | true | 9.006832ms | | +----------------------+--------+------------+-------+ {"level":"warn","ts":"2025-10-12T14:43:43.061058+0800","caller":"flags/flag.go:94","msg":"unrecognized environment variable","environment-variable":"ETCDCTL_API=3"} +------------------+---------+--------------+------------------------------+------------------------------+------------+ | ID | STATUS | NAME | PEER ADDRS | CLIENT ADDRS | IS LEARNER | +------------------+---------+--------------+------------------------------+------------------------------+------------+ | 370925f3502bfb79 | started | k8s-master01 | https://192.168.123.111:2380 | https://192.168.123.111:2379 | false | | ad30d17b35512abb | started | k8s-master03 | https://192.168.123.113:2380 | https://192.168.123.113:2379 | false | | f1ad14d186b6ff9e | started | k8s-master02 | https://192.168.123.112:2380 | https://192.168.123.112:2379 | false | +------------------+---------+--------------+------------------------------+------------------------------+------------+ # 这个命令是使用etcdctl工具，用于查看指定etcd集群的健康状态。下面是每个参数的详细解释： # # - `--endpoints`：指定要连接的etcd集群节点的地址和端口。在这个例子中，指定了3个节点的地址和端口，分别是`192.168.123.113:2379,192.168.123.112:2379,192.168.123.111:2379`。 # - `--cacert`：指定用于验证etcd服务器证书的CA证书的路径。在这个例子中，指定了CA证书的路径为`/etc/kubernetes/pki/etcd/etcd-ca.pem`。CA证书用于验证etcd服务器证书的有效性。 # - `--cert`：指定用于与etcd服务器进行通信的客户端证书的路径。在这个例子中，指定了客户端证书的路径为`/etc/kubernetes/pki/etcd/etcd.pem`。客户端证书用于在与etcd服务器建立安全通信时进行身份验证。 # - `--key`：指定与客户端证书配对的私钥的路径。在这个例子中，指定了私钥的路径为`/etc/kubernetes/pki/etcd/etcd-key.pem`。私钥用于对通信进行加密解密和签名验证。 # - `endpoint status`：子命令，用于检查etcd集群节点的健康状态。 # - `--write-out`：指定输出的格式。在这个例子中，指定以表格形式输出。 # # 通过执行这个命令，可以获取到etcd集群节点的健康状态，并以表格形式展示。
5、高可用配置（在Master服务器上操作）
此处选择：NGINX方案实现集群内的高可用，若使用 nginx方案，那么为 --server=https://127.0.0.1:8443
NGINX高可用方案
# 1、进行编译 # 安装编译环境 yum install gcc -y # 下载解压nginx二进制文件 # wget http://nginx.org/download/nginx-1.25.3.tar.gz tar xvf nginx-*.tar.gz cd nginx-* # 进行编译 ./configure --with-stream --without-http --without-http_uwsgi_module --without-http_scgi_module --without-http_fastcgi_module make && make install # 拷贝编译好的nginx node='k8s-master02 k8s-master03 k8s-node01 k8s-node02' for NODE in $node; do scp -r /usr/local/nginx/ $NODE:/usr/local/nginx/; done # 这是一系列命令行指令，用于编译和安装软件。 # # 1. `./configure` 是用于配置软件的命令。在这个例子中，配置的软件是一个Web服务器，指定了一些选项来启用流模块，并禁用了HTTP、uwsgi、scgi和fastcgi模块。 # 2. `--with-stream` 指定启用流模块。流模块通常用于代理TCP和UDP流量。 # 3. `--without-http` 指定禁用HTTP模块。这意味着编译的软件将没有HTTP服务器功能。 # 4. `--without-http_uwsgi_module` 指定禁用uwsgi模块。uwsgi是一种Web服务器和应用服务器之间的通信协议。 # 5. `--without-http_scgi_module` 指定禁用scgi模块。scgi是一种用于将Web服务器请求传递到应用服务器的协议。 # 6. `--without-http_fastcgi_module` 指定禁用fastcgi模块。fastcgi是一种用于在Web服务器和应用服务器之间交换数据的协议。 # 7. `make` 是用于编译软件的命令。该命令将根据之前的配置生成可执行文件。 # 8. `make install` 用于安装软件。该命令将生成的可执行文件和其他必要文件复制到系统的适当位置，以便可以使用该软件。 # # 总之，这个命令序列用于编译一个配置了特定选项的Web服务器，并将其安装到系统中。
# 2、写入启动配置（在所有主机上执行） # 写入nginx配置文件 cat > /usr/local/nginx/conf/kube-nginx.conf <<EOF worker_processes 1; events { worker_connections 1024; } stream { upstream backend { ## least_conn; hash $remote_addr consistent; server 192.168.123.111:6443 max_fails=3 fail_timeout=30s; server 192.168.123.112:6443 max_fails=3 fail_timeout=30s; server 192.168.123.113:6443 max_fails=3 fail_timeout=30s; } server { listen 127.0.0.1:8443; proxy_connect_timeout 1s; proxy_pass backend; } } EOF # 这段配置是一个nginx的stream模块的配置，用于代理TCP和UDP流量。 # # 首先，`worker_processes 1;`表示启动一个worker进程用于处理流量。 # 接下来，`events { worker_connections 1024; }`表示每个worker进程可以同时处理最多1024个连接。 # 在stream块里面，定义了一个名为`backend`的upstream，用于负载均衡和故障转移。 # `least_conn`表示使用最少连接算法进行负载均衡。 # `hash $remote_addr consistent`表示用客户端的IP地址进行哈希分配请求，保持相同IP的请求始终访问同一台服务器。 # `server`指令用于定义后端的服务器，每个服务器都有一个IP地址和端口号，以及一些可选的参数。 # `max_fails=3`表示当一个服务器连续失败3次时将其标记为不可用。 # `fail_timeout=30s`表示如果一个服务器被标记为不可用，nginx将在30秒后重新尝试。 # 在server块内部，定义了一个监听地址为127.0.0.1:8443的服务器。 # `proxy_connect_timeout 1s`表示与后端服务器建立连接的超时时间为1秒。 # `proxy_pass backend`表示将流量代理到名为backend的上游服务器组。 # # 总结起来，这段配置将流量代理到一个包含3个后端服务器的上游服务器组中，使用最少连接算法进行负载均衡，并根据客户端的IP地址进行哈希分配请求。如果一个服务器连续失败3次，则将其标记为不可用，并在30秒后重新尝试。 # 写入启动配置文件 cat > /etc/systemd/system/kube-nginx.service <<EOF [Unit] Description=kube-apiserver nginx proxy After=network.target After=network-online.target Wants=network-online.target [Service] Type=forking ExecStartPre=/usr/local/nginx/sbin/nginx -c /usr/local/nginx/conf/kube-nginx.conf -p /usr/local/nginx -t ExecStart=/usr/local/nginx/sbin/nginx -c /usr/local/nginx/conf/kube-nginx.conf -p /usr/local/nginx ExecReload=/usr/local/nginx/sbin/nginx -c /usr/local/nginx/conf/kube-nginx.conf -p /usr/local/nginx -s reload PrivateTmp=true Restart=always RestartSec=5 StartLimitInterval=0 LimitNOFILE=65536 [Install] WantedBy=multi-user.target EOF # 这是一个用于kube-apiserver的NGINX代理的systemd单位文件。 # # [Unit]部分包含了单位的描述和依赖关系。它指定了在network.target和network-online.target之后启动，并且需要network-online.target。 # # [Service]部分定义了如何运行该服务。Type指定了服务进程的类型（forking表示主进程会派生一个子进程）。ExecStartPre指定了在服务启动之前需要运行的命令，用于检查NGINX配置文件的语法是否正确。ExecStart指定了启动服务所需的命令。ExecReload指定了在重新加载配置文件时运行的命令。PrivateTmp设置为true表示将为服务创建一个私有的临时文件系统。Restart和RestartSec用于设置服务的自动重启机制。StartLimitInterval设置为0表示无需等待，可以立即重启服务。LimitNOFILE指定了服务的文件描述符的限制。 # # [Install]部分指定了在哪些target下该单位应该被启用。 # # 综上所述，此单位文件用于启动和管理kube-apiserver的NGINX代理服务。它通过NGINX来反向代理和负载均衡kube-apiserver的请求。该服务会在系统启动时自动启动，并具有自动重启的机制。 # 设置开机自启 systemctl daemon-reload # 用于重新加载systemd管理的单位文件。当你新增或修改了某个单位文件（如.service文件、.socket文件等），需要运行该命令来刷新systemd对该文件的配置。 systemctl enable --now kube-nginx.service # 启用并立即启动kube-nginx.service单元。kube-nginx.service是kube-nginx守护进程的systemd服务单元。 systemctl restart kube-nginx.service # 重启kube-nginx.service单元，即重新启动kube-nginx守护进程。 systemctl status kube-nginx.service # kube-nginx.service单元的当前状态，包括运行状态、是否启用等信息。
6、k8s组件配置
所有k8s节点创建以下目录
mkdir -p /etc/kubernetes/manifests/ /etc/systemd/system/kubelet.service.d /var/lib/kubelet /var/log/kubernetes
创建apiserver（所有master节点）
# 1、master01节点配置 # 若关闭IPv6 删除 --service-cluster-ip-range 的 IPv6 即可 cat > /usr/lib/systemd/system/kube-apiserver.service << EOF [Unit] Description=Kubernetes API Server Documentation=https://github.com/kubernetes/kubernetes After=network.target [Service] ExecStart=/usr/local/bin/kube-apiserver \\ --v=2 \\ --allow-privileged=true \\ --bind-address=0.0.0.0 \\ --secure-port=6443 \\ --advertise-address=192.168.123.111 \\ --service-cluster-ip-range=10.96.0.0/12,fd00:1111::/112 \\ --service-node-port-range=30000-32767 \\ --etcd-servers=https://192.168.123.111:2379,https://192.168.123.112:2379,https://192.168.123.113:2379 \\ --etcd-cafile=/etc/etcd/ssl/etcd-ca.pem \\ --etcd-certfile=/etc/etcd/ssl/etcd.pem \\ --etcd-keyfile=/etc/etcd/ssl/etcd-key.pem \\ --client-ca-file=/etc/kubernetes/pki/ca.pem \\ --tls-cert-file=/etc/kubernetes/pki/apiserver.pem \\ --tls-private-key-file=/etc/kubernetes/pki/apiserver-key.pem \\ --kubelet-client-certificate=/etc/kubernetes/pki/apiserver.pem \\ --kubelet-client-key=/etc/kubernetes/pki/apiserver-key.pem \\ --service-account-key-file=/etc/kubernetes/pki/sa.pub \\ --service-account-signing-key-file=/etc/kubernetes/pki/sa.key \\ --service-account-issuer=https://kubernetes.default.svc.cluster.local \\ --kubelet-preferred-address-types=InternalIP,ExternalIP,Hostname \\ --enable-admission-plugins=NamespaceLifecycle,LimitRanger,ServiceAccount,DefaultStorageClass,DefaultTolerationSeconds,NodeRestriction,ResourceQuota \ --authorization-mode=Node,RBAC \\ --enable-bootstrap-token-auth=true \\ --requestheader-client-ca-file=/etc/kubernetes/pki/front-proxy-ca.pem \\ --proxy-client-cert-file=/etc/kubernetes/pki/front-proxy-client.pem \\ --proxy-client-key-file=/etc/kubernetes/pki/front-proxy-client-key.pem \\ --requestheader-allowed-names=aggregator \\ --requestheader-group-headers=X-Remote-Group \\ --requestheader-extra-headers-prefix=X-Remote-Extra- \\ --requestheader-username-headers=X-Remote-User \\ --enable-aggregator-routing=true Restart=on-failure RestartSec=10s LimitNOFILE=65535 [Install] WantedBy=multi-user.target EOF --- @ 2、master02节点配置 # 若关闭IPv6 删除 --service-cluster-ip-range 的 IPv6 即可 cat > /usr/lib/systemd/system/kube-apiserver.service << EOF [Unit] Description=Kubernetes API Server Documentation=https://github.com/kubernetes/kubernetes After=network.target [Service] ExecStart=/usr/local/bin/kube-apiserver \\ --v=2 \\ --allow-privileged=true \\ --bind-address=0.0.0.0 \\ --secure-port=6443 \\ --advertise-address=192.168.123.112 \\ --service-cluster-ip-range=10.96.0.0/12,fd00:1111::/112 \\ --service-node-port-range=30000-32767 \\ --etcd-servers=https://192.168.123.111:2379,https://192.168.123.112:2379,https://192.168.123.113:2379 \\ --etcd-cafile=/etc/etcd/ssl/etcd-ca.pem \\ --etcd-certfile=/etc/etcd/ssl/etcd.pem \\ --etcd-keyfile=/etc/etcd/ssl/etcd-key.pem \\ --client-ca-file=/etc/kubernetes/pki/ca.pem \\ --tls-cert-file=/etc/kubernetes/pki/apiserver.pem \\ --tls-private-key-file=/etc/kubernetes/pki/apiserver-key.pem \\ --kubelet-client-certificate=/etc/kubernetes/pki/apiserver.pem \\ --kubelet-client-key=/etc/kubernetes/pki/apiserver-key.pem \\ --service-account-key-file=/etc/kubernetes/pki/sa.pub \\ --service-account-signing-key-file=/etc/kubernetes/pki/sa.key \\ --service-account-issuer=https://kubernetes.default.svc.cluster.local \\ --kubelet-preferred-address-types=InternalIP,ExternalIP,Hostname \\ --enable-admission-plugins=NamespaceLifecycle,LimitRanger,ServiceAccount,DefaultStorageClass,DefaultTolerationSeconds,NodeRestriction,ResourceQuota \\ --authorization-mode=Node,RBAC \\ --enable-bootstrap-token-auth=true \\ --requestheader-client-ca-file=/etc/kubernetes/pki/front-proxy-ca.pem \\ --proxy-client-cert-file=/etc/kubernetes/pki/front-proxy-client.pem \\ --proxy-client-key-file=/etc/kubernetes/pki/front-proxy-client-key.pem \\ --requestheader-allowed-names=aggregator \\ --requestheader-group-headers=X-Remote-Group \\ --requestheader-extra-headers-prefix=X-Remote-Extra- \\ --requestheader-username-headers=X-Remote-User \\ --enable-aggregator-routing=true Restart=on-failure RestartSec=10s LimitNOFILE=65535 [Install] WantedBy=multi-user.target EOF --- # 3、master03节点配置 # 若关闭IPv6 删除 --service-cluster-ip-range 的 IPv6 即可 cat > /usr/lib/systemd/system/kube-apiserver.service << EOF [Unit] Description=Kubernetes API Server Documentation=https://github.com/kubernetes/kubernetes After=network.target [Service] ExecStart=/usr/local/bin/kube-apiserver \\ --v=2 \\ --allow-privileged=true \\ --bind-address=0.0.0.0 \\ --secure-port=6443 \\ --advertise-address=192.168.123.113 \\ --service-cluster-ip-range=10.96.0.0/12,fd00:1111::/112 \\ --service-node-port-range=30000-32767 \\ --etcd-servers=https://192.168.123.111:2379,https://192.168.123.112:2379,https://192.168.123.113:2379 \\ --etcd-cafile=/etc/etcd/ssl/etcd-ca.pem \\ --etcd-certfile=/etc/etcd/ssl/etcd.pem \\ --etcd-keyfile=/etc/etcd/ssl/etcd-key.pem \\ --client-ca-file=/etc/kubernetes/pki/ca.pem \\ --tls-cert-file=/etc/kubernetes/pki/apiserver.pem \\ --tls-private-key-file=/etc/kubernetes/pki/apiserver-key.pem \\ --kubelet-client-certificate=/etc/kubernetes/pki/apiserver.pem \\ --kubelet-client-key=/etc/kubernetes/pki/apiserver-key.pem \\ --service-account-key-file=/etc/kubernetes/pki/sa.pub \\ --service-account-signing-key-file=/etc/kubernetes/pki/sa.key \\ --service-account-issuer=https://kubernetes.default.svc.cluster.local \\ --kubelet-preferred-address-types=InternalIP,ExternalIP,Hostname \\ --enable-admission-plugins=NamespaceLifecycle,LimitRanger,ServiceAccount,DefaultStorageClass,DefaultTolerationSeconds,NodeRestriction,ResourceQuota \\ --authorization-mode=Node,RBAC \\ --enable-bootstrap-token-auth=true \\ --requestheader-client-ca-file=/etc/kubernetes/pki/front-proxy-ca.pem \\ --proxy-client-cert-file=/etc/kubernetes/pki/front-proxy-client.pem \\ --proxy-client-key-file=/etc/kubernetes/pki/front-proxy-client-key.pem \\ --requestheader-allowed-names=aggregator \\ --requestheader-group-headers=X-Remote-Group \\ --requestheader-extra-headers-prefix=X-Remote-Extra- \\ --requestheader-username-headers=X-Remote-User \\ --enable-aggregator-routing=true Restart=on-failure RestartSec=10s LimitNOFILE=65535 [Install] WantedBy=multi-user.target EOF --- # 4、参数 该配置文件是用于定义Kubernetes API Server的systemd服务的配置。systemd是一个用于启动和管理Linux系统服务的守护进程。 [Unit] - Description: 服务的描述信息，用于显示在日志和系统管理工具中。 - Documentation: 提供关于服务的文档链接。 - After: 规定服务依赖于哪些其他服务或单元。在这个例子中，API Server服务在网络目标启动之后启动。 [Service] - ExecStart: 定义服务的命令行参数和命令。这里指定了API Server的启动命令，包括各种参数选项。 - Restart: 指定当服务退出时应该如何重新启动。在这个例子中，服务在失败时将被重新启动。 - RestartSec: 指定两次重新启动之间的等待时间。 - LimitNOFILE: 指定进程可以打开的文件描述符的最大数量。 [Install] - WantedBy: 指定服务应该安装到哪个系统目标。在这个例子中，服务将被安装到multi-user.target目标，以便在多用户模式下启动。 上述配置文件中定义的kube-apiserver服务将以指定的参数运行，这些参数包括： - `--v=2` 指定日志级别为2，打印详细的API Server日志。 - `--allow-privileged=true` 允许特权容器运行。 - `--bind-address=0.0.0.0` 绑定API Server监听的IP地址。 - `--secure-port=6443` 指定API Server监听的安全端口。 - `--advertise-address=192.168.123.111` 广告API Server的地址。 - `--service-cluster-ip-range=10.96.0.0/12,fd00:1111::/112` 指定服务CIDR范围。 - `--service-node-port-range=30000-32767` 指定NodePort的范围。 - `--etcd-servers=https://192.168.123.111:2379,https://192.168.123.112:2379,https://192.168.123.113:2379` 指定etcd服务器的地址。 - `--etcd-cafile` 指定etcd服务器的CA证书。 - `--etcd-certfile` 指定etcd服务器的证书。 - `--etcd-keyfile` 指定etcd服务器的私钥。 - `--client-ca-file` 指定客户端CA证书。 - `--tls-cert-file` 指定服务的证书。 - `--tls-private-key-file` 指定服务的私钥。 - `--kubelet-client-certificate` 和 `--kubelet-client-key` 指定与kubelet通信的客户端证书和私钥。 - `--service-account-key-file` 指定服务账户公钥文件。 - `--service-account-signing-key-file` 指定服务账户签名密钥文件。 - `--service-account-issuer` 指定服务账户的发布者。 - `--kubelet-preferred-address-types` 指定kubelet通信时的首选地址类型。 - `--enable-admission-plugins` 启用一系列准入插件。 - `--authorization-mode` 指定授权模式。 - `--enable-bootstrap-token-auth` 启用引导令牌认证。 - `--requestheader-client-ca-file` 指定请求头中的客户端CA证书。 - `--proxy-client-cert-file` 和 `--proxy-client-key-file` 指定代理客户端的证书和私钥。 - `--requestheader-allowed-names` 指定请求头中允许的名字。 - `--requestheader-group-headers` 指定请求头中的组头。 - `--requestheader-extra-headers-prefix` 指定请求头中的额外头前缀。 - `--requestheader-username-headers` 指定请求头中的用户名头。 - `--enable-aggregator-routing` 启用聚合路由。 整个配置文件为Kubernetes API Server提供了必要的参数，以便正确地启动和运行。 --- # 5、启动apiserver（所有master节点） systemctl daemon-reload # 用于重新加载systemd管理的单位文件。当你新增或修改了某个单位文件（如.service文件、.socket文件等），需要运行该命令来刷新systemd对该文件的配置。 systemctl enable --now kube-apiserver.service # 启用并立即启动kube-apiserver.service单元。kube-apiserver.service是kube-apiserver守护进程的systemd服务单元。 systemctl restart kube-apiserver.service # 重启kube-apiserver.service单元，即重新启动etcd守护进程。 systemctl status kube-apiserver.service # kube-apiserver.service单元的当前状态，包括运行状态、是否启用等信息。
配置kube-controller-manager service
# 所有master节点配置，且配置相同 # 172.16.0.0/12为pod网段，按需求设置你自己的网段 cat > /usr/lib/systemd/system/kube-controller-manager.service << EOF [Unit] Description=Kubernetes Controller Manager Documentation=https://github.com/kubernetes/kubernetes After=network.target [Service] ExecStart=/usr/local/bin/kube-controller-manager \\ --v=2 \\ --bind-address=0.0.0.0 \\ --root-ca-file=/etc/kubernetes/pki/ca.pem \\ --cluster-signing-cert-file=/etc/kubernetes/pki/ca.pem \\ --cluster-signing-key-file=/etc/kubernetes/pki/ca-key.pem \\ --service-account-private-key-file=/etc/kubernetes/pki/sa.key \\ --kubeconfig=/etc/kubernetes/controller-manager.kubeconfig \\ --leader-elect=true \\ --use-service-account-credentials=true \\ --node-monitor-grace-period=40s \\ --node-monitor-period=5s \\ --controllers=*,bootstrapsigner,tokencleaner \\ --allocate-node-cidrs=true \\ --service-cluster-ip-range=10.96.0.0/12,fd00:1111::/112 \\ --cluster-cidr=172.16.0.0/12,fc00:2222::/112 \\ --node-cidr-mask-size-ipv4=24 \\ --node-cidr-mask-size-ipv6=120 \\ --requestheader-client-ca-file=/etc/kubernetes/pki/front-proxy-ca.pem Restart=always RestartSec=10s [Install] WantedBy=multi-user.target EOF # 关闭IPv6 # 删除 --service-cluster-ip-range 中的IPv6地址 # 删除 --cluster-cidr 中的IPv6地址 # 删除 --node-cidr-mask-size-ipv6=120 cat > /usr/lib/systemd/system/kube-controller-manager.service << EOF [Unit] Description=Kubernetes Controller Manager Documentation=https://github.com/kubernetes/kubernetes After=network.target [Service] ExecStart=/usr/local/bin/kube-controller-manager \\ --v=2 \\ --bind-address=0.0.0.0 \\ --root-ca-file=/etc/kubernetes/pki/ca.pem \\ --cluster-signing-cert-file=/etc/kubernetes/pki/ca.pem \\ --cluster-signing-key-file=/etc/kubernetes/pki/ca-key.pem \\ --service-account-private-key-file=/etc/kubernetes/pki/sa.key \\ --kubeconfig=/etc/kubernetes/controller-manager.kubeconfig \\ --leader-elect=true \\ --use-service-account-credentials=true \\ --node-monitor-grace-period=40s \\ --node-monitor-period=5s \\ --controllers=*,bootstrapsigner,tokencleaner \\ --allocate-node-cidrs=true \\ --service-cluster-ip-range=10.96.0.0/12 \\ --cluster-cidr=172.16.0.0/12 \\ --node-cidr-mask-size-ipv4=24 \\ --requestheader-client-ca-file=/etc/kubernetes/pki/front-proxy-ca.pem Restart=always RestartSec=10s [Install] WantedBy=multi-user.target EOF --- 参数： 这是一个用于启动 Kubernetes 控制器管理器的 systemd 服务单元文件。下面是对每个部分的详细解释： [Unit]：单元的基本信息部分，用于描述和标识这个服务单元。 Description：服务单元的描述信息，说明了该服务单元的作用，这里是 Kubernetes 控制器管理器。 Documentation：可选项，提供了关于该服务单元的文档链接。 After：定义了该服务单元在哪些其他单元之后启动，这里是 network.target，即在网络服务启动之后启动。 [Service]：定义了服务的运行参数和行为。 ExecStart：指定服务启动时执行的命令，这里是 /usr/local/bin/kube-controller-manager，并通过后续的行继续传递了一系列的参数设置。 Restart：定义了服务在退出后的重新启动策略，这里设置为 always，表示总是重新启动服务。 RestartSec：定义了重新启动服务的时间间隔，这里设置为 10 秒。 [Install]：定义了如何安装和启用服务单元。 WantedBy：指定了服务单元所属的 target，这里是 multi-user.target，表示启动多用户模式下的服务。 在 ExecStart 中传递的参数说明如下： --v=2：设置日志的详细级别为 2。 --bind-address=0.0.0.0：绑定的 IP 地址，用于监听 Kubernetes 控制平面的请求，这里设置为 0.0.0.0，表示监听所有网络接口上的请求。 --root-ca-file：根证书文件的路径，用于验证其他组件的证书。 --cluster-signing-cert-file：用于签名集群证书的证书文件路径。 --cluster-signing-key-file：用于签名集群证书的私钥文件路径。 --service-account-private-key-file：用于签名服务账户令牌的私钥文件路径。 --kubeconfig：kubeconfig 文件的路径，包含了与 Kubernetes API 服务器通信所需的配置信息。 --leader-elect=true：启用 Leader 选举机制，确保只有一个控制器管理器作为 leader 在运行。 --use-service-account-credentials=true：使用服务账户的凭据进行认证和授权。 --node-monitor-grace-period=40s：节点监控的优雅退出时间，节点长时间不响应时会触发节点驱逐。 --node-monitor-period=5s：节点监控的检测周期，用于检测节点是否正常运行。 --controllers：指定要运行的控制器类型，在这里使用了通配符 *，表示运行所有的控制器，同时还包括了 bootstrapsigner 和 tokencleaner 控制器。 --allocate-node-cidrs=true：为节点分配 CIDR 子网，用于分配 Pod 网络地址。 --service-cluster-ip-range：定义 Service 的 IP 范围，这里设置为 10.96.0.0/12 和 fd00::/108。 --cluster-cidr：定义集群的 CIDR 范围，这里设置为 172.16.0.0/12 和 fc00::/48。 --node-cidr-mask-size-ipv4：分配给每个节点的 IPv4 子网掩码大小，默认是 24。 --node-cidr-mask-size-ipv6：分配给每个节点的 IPv6 子网掩码大小，默认是 120。 --requestheader-client-ca-file：设置请求头中客户端 CA 的证书文件路径，用于认证请求头中的 CA 证书。 这个服务单元文件描述了 Kubernetes 控制器管理器的启动参数和行为，并且定义了服务的依赖关系和重新启动策略。通过 systemd 启动该服务单元，即可启动 Kubernetes 控制器管理器组件。 --- # 启动kube-controller-manager，并查看状态 systemctl daemon-reload # 用于重新加载systemd管理的单位文件。当你新增或修改了某个单位文件（如.service文件、.socket文件等），需要运行该命令来刷新systemd对该文件的配置。 systemctl enable --now kube-controller-manager.service # 启用并立即启动kube-controller-manager.service单元。kube-controller-manager.service是kube-controller-manager守护进程的systemd服务单元。 systemctl restart kube-controller-manager.service # 重启kube-controller-manager.service单元，即重新启动etcd守护进程。 systemctl status kube-controller-manager.service # kube-controller-manager.service单元的当前状态，包括运行状态、是否启用等信息。
配置kube-scheduler service
# 所有master节点配置，且配置相同 cat > /usr/lib/systemd/system/kube-scheduler.service << EOF [Unit] Description=Kubernetes Scheduler Documentation=https://github.com/kubernetes/kubernetes After=network.target [Service] ExecStart=/usr/local/bin/kube-scheduler \\ --v=2 \\ --bind-address=0.0.0.0 \\ --leader-elect=true \\ --kubeconfig=/etc/kubernetes/scheduler.kubeconfig Restart=always RestartSec=10s [Install] WantedBy=multi-user.target EOF --- 参数： 这是一个用于启动 Kubernetes 调度器的 systemd 服务单元文件。下面是对每个部分的详细解释： [Unit]：单元的基本信息部分，用于描述和标识这个服务单元。 Description：服务单元的描述信息，说明了该服务单元的作用，这里是 Kubernetes 调度器。 Documentation：可选项，提供了关于该服务单元的文档链接。 After：定义了该服务单元在哪些其他单元之后启动，这里是 network.target，即在网络服务启动之后启动。 [Service]：定义了服务的运行参数和行为。 ExecStart：指定服务启动时执行的命令，这里是 /usr/local/bin/kube-scheduler，并通过后续的行继续传递了一系列的参数设置。 Restart：定义了服务在退出后的重新启动策略，这里设置为 always，表示总是重新启动服务。 RestartSec：定义了重新启动服务的时间间隔，这里设置为 10 秒。 [Install]：定义了如何安装和启用服务单元。 WantedBy：指定了服务单元所属的 target，这里是 multi-user.target，表示启动多用户模式下的服务。 在 ExecStart 中传递的参数说明如下： --v=2：设置日志的详细级别为 2。 --bind-address=0.0.0.0：绑定的 IP 地址，用于监听 Kubernetes 控制平面的请求，这里设置为 0.0.0.0，表示监听所有网络接口上的请求。 --leader-elect=true：启用 Leader 选举机制，确保只有一个调度器作为 leader 在运行。 --kubeconfig=/etc/kubernetes/scheduler.kubeconfig：kubeconfig 文件的路径，包含了与 Kubernetes API 服务器通信所需的配置信息。 这个服务单元文件描述了 Kubernetes 调度器的启动参数和行为，并且定义了服务的依赖关系和重新启动策略。通过 systemd 启动该服务单元，即可启动 Kubernetes 调度器组件。 --- # 启动并查看服务状态 systemctl daemon-reload # 用于重新加载systemd管理的单位文件。当你新增或修改了某个单位文件（如.service文件、.socket文件等），需要运行该命令来刷新systemd对该文件的配置。 systemctl enable --now kube-scheduler.service # 启用并立即启动kube-scheduler.service单元。kube-scheduler.service是kube-scheduler守护进程的systemd服务单元。 systemctl restart kube-scheduler.service # 重启kube-scheduler.service单元，即重新启动etcd守护进程。 systemctl status kube-scheduler.service # kube-scheduler.service单元的当前状态，包括运行状态、是否启用等信息。
7、TLS Bootstrapping配置
在master01上配置
# 在《5.高可用配置》选择使用那种高可用方案 # 若使用 haproxy、keepalived 那么为 `--server=https://192.168.123.117:9443` # 若使用 nginx方案，那么为 `--server=https://127.0.0.1:8443` kubectl config set-cluster kubernetes \ --certificate-authority=/etc/kubernetes/pki/ca.pem \ --embed-certs=true --server=https://127.0.0.1:8443 \ --kubeconfig=/etc/kubernetes/bootstrap-kubelet.kubeconfig # 这是一个使用 kubectl 命令设置 Kubernetes 集群配置的命令示例。下面是对每个选项的详细解释： # # config set-cluster kubernetes：指定要设置的集群名称为 "kubernetes"，表示要修改名为 "kubernetes" 的集群配置。 # --certificate-authority=/etc/kubernetes/pki/ca.pem：指定证书颁发机构（CA）的证书文件路径，用于验证服务器证书的有效性。 # --embed-certs=true：将证书文件嵌入到生成的 kubeconfig 文件中。这样可以避免在 kubeconfig 文件中引用外部证书文件。 # --server=https://127.0.0.1:8443：指定 Kubernetes API 服务器的地址和端口，这里使用的是 https 协议和本地地址（127.0.0.1），端口号为 8443。你可以根据实际环境修改该参数。 # --kubeconfig=/etc/kubernetes/bootstrap-kubelet.kubeconfig：指定 kubeconfig 文件的路径和名称，这里是 /etc/kubernetes/bootstrap-kubelet.kubeconfig。 # 通过执行此命令，你可以设置名为 "kubernetes" 的集群配置，并提供 CA 证书、API 服务器地址和端口，并将这些配置信息嵌入到 bootstrap-kubelet.kubeconfig 文件中。这个 kubeconfig 文件可以用于认证和授权 kubelet 组件与 Kubernetes API 服务器之间的通信。请确保路径和文件名与实际环境中的配置相匹配。 # 可以使用这个命令进行创建token也可以使用我的 echo "$(head -c 6 /dev/urandom | md5sum | head -c 6)"."$(head -c 16 /dev/urandom | md5sum | head -c 16)" kubectl config set-credentials tls-bootstrap-token-user \ --token=c8ad9c.2e4d610cf3e7426e \ --kubeconfig=/etc/kubernetes/bootstrap-kubelet.kubeconfig # 这是一个使用 kubectl 命令设置凭证信息的命令示例。下面是对每个选项的详细解释： # # config set-credentials tls-bootstrap-token-user：指定要设置的凭证名称为 "tls-bootstrap-token-user"，表示要修改名为 "tls-bootstrap-token-user" 的用户凭证配置。 # --token=c8ad9c.2e4d610cf3e7426e：指定用户的身份验证令牌（token）。在这个示例中，令牌是 c8ad9c.2e4d610cf3e7426e。你可以根据实际情况修改该令牌。 # --kubeconfig=/etc/kubernetes/bootstrap-kubelet.kubeconfig：指定 kubeconfig 文件的路径和名称，这里是 /etc/kubernetes/bootstrap-kubelet.kubeconfig。 # 通过执行此命令，你可以设置名为 "tls-bootstrap-token-user" 的用户凭证，并将令牌信息加入到 bootstrap-kubelet.kubeconfig 文件中。这个 kubeconfig 文件可以用于认证和授权 kubelet 组件与 Kubernetes API 服务器之间的通信。请确保路径和文件名与实际环境中的配置相匹配。 kubectl config set-context tls-bootstrap-token-user@kubernetes \ --cluster=kubernetes \ --user=tls-bootstrap-token-user \ --kubeconfig=/etc/kubernetes/bootstrap-kubelet.kubeconfig # 这是一个使用 kubectl 命令设置上下文信息的命令示例。下面是对每个选项的详细解释： # # config set-context tls-bootstrap-token-user@kubernetes：指定要设置的上下文名称为 "tls-bootstrap-token-user@kubernetes"，表示要修改名为 "tls-bootstrap-token-user@kubernetes" 的上下文配置。 # --cluster=kubernetes：指定上下文关联的集群名称为 "kubernetes"，表示使用名为 "kubernetes" 的集群配置。 # --user=tls-bootstrap-token-user：指定上下文关联的用户凭证名称为 "tls-bootstrap-token-user"，表示使用名为 "tls-bootstrap-token-user" 的用户凭证配置。 # --kubeconfig=/etc/kubernetes/bootstrap-kubelet.kubeconfig：指定 kubeconfig 文件的路径和名称，这里是 /etc/kubernetes/bootstrap-kubelet.kubeconfig。 # 通过执行此命令，你可以设置名为 "tls-bootstrap-token-user@kubernetes" 的上下文，并将其关联到名为 "kubernetes" 的集群配置和名为 "tls-bootstrap-token-user" 的用户凭证配置。这样，bootstrap-kubelet.kubeconfig 文件就包含了完整的上下文信息，可以用于指定与 Kubernetes 集群建立连接时要使用的集群和凭证。请确保路径和文件名与实际环境中的配置相匹配。 kubectl config use-context tls-bootstrap-token-user@kubernetes \ --kubeconfig=/etc/kubernetes/bootstrap-kubelet.kubeconfig # 这是一个使用 kubectl 命令设置当前上下文的命令示例。下面是对每个选项的详细解释： # # config use-context tls-bootstrap-token-user@kubernetes：指定要使用的上下文名称为 "tls-bootstrap-token-user@kubernetes"，表示要将当前上下文切换为名为 "tls-bootstrap-token-user@kubernetes" 的上下文。 # --kubeconfig=/etc/kubernetes/bootstrap-kubelet.kubeconfig：指定 kubeconfig 文件的路径和名称，这里是 /etc/kubernetes/bootstrap-kubelet.kubeconfig。 # 通过执行此命令，你可以将当前上下文设置为名为 "tls-bootstrap-token-user@kubernetes" 的上下文。这样，当你执行其他 kubectl 命令时，它们将使用该上下文与 Kubernetes 集群进行交互。请确保路径和文件名与实际环境中的配置相匹配。 # token的位置在bootstrap.secret.yaml，如果修改的话到这个文件修改 mkdir -p /root/.kube ; cp /etc/kubernetes/admin.kubeconfig /root/.kube/config
查看集群状态，没问题的话继续后续操作
# 1.28 版本只能查看到一个etcd 属于正常现象 # export ETCDCTL_API=3 # etcdctl --endpoints="192.168.123.113:2379,192.168.123.112:2379,192.168.123.111:2379" --cacert=/etc/kubernetes/pki/etcd/etcd-ca.pem --cert=/etc/kubernetes/pki/etcd/etcd.pem --key=/etc/kubernetes/pki/etcd/etcd-key.pem endpoint status --write-out=table kubectl get cs Warning: v1 ComponentStatus is deprecated in v1.19+ NAME STATUS MESSAGE ERROR scheduler Healthy ok controller-manager Healthy ok etcd-0 Healthy ok # 写入bootstrap-token cat > bootstrap.secret.yaml << EOF apiVersion: v1 kind: Secret metadata: name: bootstrap-token-c8ad9c namespace: kube-system type: bootstrap.kubernetes.io/token stringData: description: "The default bootstrap token generated by 'kubelet '." token-id: c8ad9c token-secret: 2e4d610cf3e7426e usage-bootstrap-authentication: "true" usage-bootstrap-signing: "true" auth-extra-groups: system:bootstrappers:default-node-token,system:bootstrappers:worker,system:bootstrappers:ingress --- apiVersion: rbac.authorization.k8s.io/v1 kind: ClusterRoleBinding metadata: name: kubelet-bootstrap roleRef: apiGroup: rbac.authorization.k8s.io kind: ClusterRole name: system:node-bootstrapper subjects: - apiGroup: rbac.authorization.k8s.io kind: Group name: system:bootstrappers:default-node-token --- apiVersion: rbac.authorization.k8s.io/v1 kind: ClusterRoleBinding metadata: name: node-autoapprove-bootstrap roleRef: apiGroup: rbac.authorization.k8s.io kind: ClusterRole name: system:certificates.k8s.io:certificatesigningrequests:nodeclient subjects: - apiGroup: rbac.authorization.k8s.io kind: Group name: system:bootstrappers:default-node-token --- apiVersion: rbac.authorization.k8s.io/v1 kind: ClusterRoleBinding metadata: name: node-autoapprove-certificate-rotation roleRef: apiGroup: rbac.authorization.k8s.io kind: ClusterRole name: system:certificates.k8s.io:certificatesigningrequests:selfnodeclient subjects: - apiGroup: rbac.authorization.k8s.io kind: Group name: system:nodes --- apiVersion: rbac.authorization.k8s.io/v1 kind: ClusterRole metadata: annotations: rbac.authorization.kubernetes.io/autoupdate: "true" labels: kubernetes.io/bootstrapping: rbac-defaults name: system:kube-apiserver-to-kubelet rules: - apiGroups: - "" resources: - nodes/proxy - nodes/stats - nodes/log - nodes/spec - nodes/metrics verbs: - "*" --- apiVersion: rbac.authorization.k8s.io/v1 kind: ClusterRoleBinding metadata: name: system:kube-apiserver namespace: "" roleRef: apiGroup: rbac.authorization.k8s.io kind: ClusterRole name: system:kube-apiserver-to-kubelet subjects: - apiGroup: rbac.authorization.k8s.io kind: User name: kube-apiserver EOF # 切记执行，别忘记！！！ kubectl create -f bootstrap.secret.yaml
8、node节点配置
在master01上将证书复制到node节点
cd /etc/kubernetes/ for NODE in k8s-master02 k8s-master03 k8s-node01 k8s-node02; do ssh $NODE mkdir -p /etc/kubernetes/pki; for FILE in pki/ca.pem pki/ca-key.pem pki/front-proxy-ca.pem bootstrap-kubelet.kubeconfig kube-proxy.kubeconfig; do scp /etc/kubernetes/$FILE $NODE:/etc/kubernetes/${FILE}; done; done
kubelet配置【每个node节点操作，注意--node-ip=****】
当使用docker作为Runtime
# IPv4示例 cat > /usr/lib/systemd/system/kubelet.service << EOF [Unit] Description=Kubernetes Kubelet Documentation=https://github.com/kubernetes/kubernetes After=network-online.target firewalld.service cri-docker.service docker.socket containerd.service Wants=network-online.target Requires=docker.socket containerd.service [Service] ExecStart=/usr/local/bin/kubelet \\ --bootstrap-kubeconfig=/etc/kubernetes/bootstrap-kubelet.kubeconfig \\ --kubeconfig=/etc/kubernetes/kubelet.kubeconfig \\ --config=/etc/kubernetes/kubelet-conf.yml \\ --container-runtime-endpoint=unix:///run/cri-dockerd.sock \\ --node-labels=node.kubernetes.io/node= [Install] WantedBy=multi-user.target EOF # 这是一个表示 Kubernetes Kubelet 服务的 systemd 单位文件示例。下面是对每个节（[Unit]、[Service]、[Install]）的详细解释： # # [Unit] # # Description=Kubernetes Kubelet：指定了此单位文件对应的服务描述信息为 "Kubernetes Kubelet"。 # Documentation=...：指定了对该服务的文档链接。 # - After: 说明该服务在哪些其他服务之后启动，这里是在网络在线、firewalld服务和containerd服务后启动。 # - Wants: 说明该服务想要的其他服务，这里是网络在线服务。 # - Requires: 说明该服务需要的其他服务，这里是docker.socket和containerd.service。 # [Service] # # ExecStart=/usr/local/bin/kubelet ...：指定了启动 Kubelet 服务的命令和参数。这里使用的是 /usr/local/bin/kubelet 命令，并传递了一系列参数来配置 Kubelet 的运行。这些参数包括： # --bootstrap-kubeconfig=/etc/kubernetes/bootstrap-kubelet.kubeconfig：指定了用于引导 kubelet 的 kubeconfig 文件的路径和名称。 # --kubeconfig=/etc/kubernetes/kubelet.kubeconfig：指定了 kubelet 的 kubeconfig 文件的路径和名称。 # --config=/etc/kubernetes/kubelet-conf.yml：指定了 kubelet 的配置文件的路径和名称。 # --container-runtime-endpoint=unix:///run/cri-dockerd.sock：指定了容器运行时接口的端点地址，这里使用的是 Docker 运行时（cri-dockerd）的 UNIX 套接字。 # --node-labels=node.kubernetes.io/node=：指定了节点的标签。这里的示例只给节点添加了一个简单的标签 node.kubernetes.io/node=。 # [Install] # # WantedBy=multi-user.target：指定了在 multi-user.target 被启动时，该服务应该被启用。 # 通过这个单位文件，你可以配置 Kubelet 服务的启动参数，指定相关的配置文件和凭证文件，以及定义节点的标签。请确认路径和文件名与你的实际环境中的配置相匹配。 # IPv6示例 # 若不使用IPv6那么忽略此项即可 # 下方 --node-ip 更换为每个节点的IP即可 cat > /usr/lib/systemd/system/kubelet.service << EOF [Unit] Description=Kubernetes Kubelet Documentation=https://github.com/kubernetes/kubernetes After=network-online.target firewalld.service cri-docker.service docker.socket containerd.service Wants=network-online.target Requires=docker.socket containerd.service [Service] ExecStart=/usr/local/bin/kubelet \\ --bootstrap-kubeconfig=/etc/kubernetes/bootstrap-kubelet.kubeconfig \\ --kubeconfig=/etc/kubernetes/kubelet.kubeconfig \\ --config=/etc/kubernetes/kubelet-conf.yml \\ --container-runtime-endpoint=unix:///run/cri-dockerd.sock \\ --node-labels=node.kubernetes.io/node= \\ --node-ip=192.168.123.111,fc00::31 [Install] WantedBy=multi-user.target EOF
所有k8s节点创建kubelet的配置文件
cat > /etc/kubernetes/kubelet-conf.yml <<EOF apiVersion: kubelet.config.k8s.io/v1beta1 kind: KubeletConfiguration address: 0.0.0.0 port: 10250 readOnlyPort: 10255 authentication: anonymous: enabled: false webhook: cacheTTL: 2m0s enabled: true x509: clientCAFile: /etc/kubernetes/pki/ca.pem authorization: mode: Webhook webhook: cacheAuthorizedTTL: 5m0s cacheUnauthorizedTTL: 30s cgroupDriver: systemd cgroupsPerQOS: true clusterDNS: - 10.96.0.10 - clusterDomain: cluster.local containerLogMaxFiles: 5 containerLogMaxSize: 10Mi contentType: application/vnd.kubernetes.protobuf cpuCFSQuota: true cpuManagerPolicy: none cpuManagerReconcilePeriod: 10s enableControllerAttachDetach: true enableDebuggingHandlers: true enforceNodeAllocatable: - pods eventBurst: 10 eventRecordQPS: 5 evictionHard: imagefs.available: 15% memory.available: 100Mi nodefs.available: 10% nodefs.inodesFree: 5% evictionPressureTransitionPeriod: 5m0s failSwapOn: true fileCheckFrequency: 20s hairpinMode: promiscuous-bridge healthzBindAddress: 127.0.0.1 healthzPort: 10248 httpCheckFrequency: 20s imageGCHighThresholdPercent: 85 imageGCLowThresholdPercent: 80 imageMinimumGCAge: 2m0s iptablesDropBit: 15 iptablesMasqueradeBit: 14 kubeAPIBurst: 10 kubeAPIQPS: 5 makeIPTablesUtilChains: true maxOpenFiles: 1000000 maxPods: 110 nodeStatusUpdateFrequency: 10s oomScoreAdj: -999 podPidsLimit: -1 registryBurst: 10 registryPullQPS: 5 resolvConf: /etc/resolv.conf rotateCertificates: true runtimeRequestTimeout: 2m0s serializeImagePulls: true staticPodPath: /etc/kubernetes/manifests streamingConnectionIdleTimeout: 4h0m0s syncFrequency: 1m0s volumeStatsAggPeriod: 1m0s EOF # 这是一个Kubelet的配置文件，用于配置Kubelet的各项参数。 # # - apiVersion: kubelet.config.k8s.io/v1beta1：指定了配置文件的API版本为kubelet.config.k8s.io/v1beta1。 # - kind: KubeletConfiguration：指定了配置类别为KubeletConfiguration。 # - address: 0.0.0.0：指定了Kubelet监听的地址为0.0.0.0。 # - port: 10250：指定了Kubelet监听的端口为10250。 # - readOnlyPort: 10255：指定了只读端口为10255，用于提供只读的状态信息。 # - authentication：指定了认证相关的配置信息。 # - anonymous.enabled: false：禁用了匿名认证。 # - webhook.enabled: true：启用了Webhook认证。 # - x509.clientCAFile: /etc/kubernetes/pki/ca.pem：指定了X509证书的客户端CA文件路径。 # - authorization：指定了授权相关的配置信息。 # - mode: Webhook：指定了授权模式为Webhook。 # - webhook.cacheAuthorizedTTL: 5m0s：指定了授权缓存时间段为5分钟。 # - webhook.cacheUnauthorizedTTL: 30s：指定了未授权缓存时间段为30秒。 # - cgroupDriver: systemd：指定了Cgroup驱动为systemd。 # - cgroupsPerQOS: true：启用了每个QoS类别一个Cgroup的设置。 # - clusterDNS: 指定了集群的DNS服务器地址列表。 # - 10.96.0.10：指定了DNS服务器地址为10.96.0.10。 # - clusterDomain: cluster.local：指定了集群的域名后缀为cluster.local。 # - containerLogMaxFiles: 5：指定了容器日志文件保留的最大数量为5个。 # - containerLogMaxSize: 10Mi：指定了容器日志文件的最大大小为10Mi。 # - contentType: application/vnd.kubernetes.protobuf：指定了内容类型为protobuf。 # - cpuCFSQuota: true：启用了CPU CFS Quota。 # - cpuManagerPolicy: none：禁用了CPU Manager。 # - cpuManagerReconcilePeriod: 10s：指定了CPU管理器的调整周期为10秒。 # - enableControllerAttachDetach: true：启用了控制器的挂载和拆卸。 # - enableDebuggingHandlers: true：启用了调试处理程序。 # - enforceNodeAllocatable: 指定了强制节点可分配资源的列表。 # - pods：强制节点可分配pods资源。 # - eventBurst: 10：指定了事件突发的最大数量为10。 # - eventRecordQPS: 5：指定了事件记录的最大请求量为5。 # - evictionHard: 指定了驱逐硬性限制参数的配置信息。 # - imagefs.available: 15%：指定了镜像文件系统可用空间的限制为15%。 # - memory.available: 100Mi：指定了可用内存的限制为100Mi。 # - nodefs.available: 10%：指定了节点文件系统可用空间的限制为10%。 # - nodefs.inodesFree: 5%：指定了节点文件系统可用inode的限制为5%。 # - evictionPressureTransitionPeriod: 5m0s：指定了驱逐压力转换的时间段为5分钟。 # - failSwapOn: true：指定了在发生OOM时禁用交换分区。 # - fileCheckFrequency: 20s：指定了文件检查频率为20秒。 # - hairpinMode: promiscuous-bridge：设置了Hairpin Mode为"promiscuous-bridge"。 # - healthzBindAddress: 127.0.0.1：指定了健康检查的绑定地址为127.0.0.1。 # - healthzPort: 10248：指定了健康检查的端口为10248。 # - httpCheckFrequency: 20s：指定了HTTP检查的频率为20秒。 # - imageGCHighThresholdPercent: 85：指定了镜像垃圾回收的上阈值为85%。 # - imageGCLowThresholdPercent: 80：指定了镜像垃圾回收的下阈值为80%。 # - imageMinimumGCAge: 2m0s：指定了镜像垃圾回收的最小时间为2分钟。 # - iptablesDropBit: 15：指定了iptables的Drop Bit为15。 # - iptablesMasqueradeBit: 14：指定了iptables的Masquerade Bit为14。 # - kubeAPIBurst: 10：指定了KubeAPI的突发请求数量为10个。 # - kubeAPIQPS: 5：指定了KubeAPI的每秒请求频率为5个。 # - makeIPTablesUtilChains: true：指定了是否使用iptables工具链。 # - maxOpenFiles: 1000000：指定了最大打开文件数为1000000。 # - maxPods: 110：指定了最大的Pod数量为110。 # - nodeStatusUpdateFrequency: 10s：指定了节点状态更新的频率为10秒。 # - oomScoreAdj: -999：指定了OOM Score Adjustment为-999。 # - podPidsLimit: -1：指定了Pod的PID限制为-1，表示无限制。 # - registryBurst: 10：指定了Registry的突发请求数量为10个。 # - registryPullQPS: 5：指定了Registry的每秒拉取请求数量为5个。 # - resolvConf: /etc/resolv.conf：指定了resolv.conf的文件路径。 # - rotateCertificates: true：指定了是否轮转证书。 # - runtimeRequestTimeout: 2m0s：指定了运行时请求的超时时间为2分钟。 # - serializeImagePulls: true：指定了是否序列化镜像拉取。 # - staticPodPath: /etc/kubernetes/manifests：指定了静态Pod的路径。 # - streamingConnectionIdleTimeout: 4h0m0s：指定了流式连接的空闲超时时间为4小时。 # - syncFrequency: 1m0s：指定了同步频率为1分钟。 # - volumeStatsAggPeriod: 1m0s：指定了卷统计聚合周期为1分钟。 --- # 启动kubelet systemctl daemon-reload # 用于重新加载systemd管理的单位文件。当你新增或修改了某个单位文件（如.service文件、.socket文件等），需要运行该命令来刷新systemd对该文件的配置。 systemctl enable --now kubelet.service # 启用并立即启动kubelet.service单元。kubelet.service是kubelet守护进程的systemd服务单元。 systemctl restart kubelet.service # 重启kubelet.service单元，即重新启动kubelet守护进程。 systemctl status kubelet.service # kubelet.service单元的当前状态，包括运行状态、是否启用等信息。 --- # 查看集群 [root@k8s-master01 ~]# kubectl get node NAME STATUS ROLES AGE VERSION k8s-master01 NotReady <none> 16s v1.34.0 k8s-master02 NotReady <none> 13s v1.34.0 k8s-master03 NotReady <none> 12s v1.34.0 k8s-node01 NotReady <none> 10s v1.34.0 k8s-node02 NotReady <none> 9s v1.34.0 [root@k8s-master01 ~]# --- # 查看容器运行时 [root@k8s-master01 ~]# kubectl describe node | grep Runtime Container Runtime Version: containerd://2.1.4 Container Runtime Version: containerd://2.1.4 Container Runtime Version: containerd://2.1.4 Container Runtime Version: containerd://2.1.4 Container Runtime Version: containerd://2.1.4 [root@k8s-master01 ~]# kubectl describe node | grep Runtime Container Runtime Version: docker://28.3.3 Container Runtime Version: docker://28.3.3 Container Runtime Version: docker://28.3.3 Container Runtime Version: docker://28.3.3 Container Runtime Version: docker://28.3.3
kube-proxy配置
# 将kubeconfig发送至其他节点 # master-1执行 for NODE in k8s-master02 k8s-master03 k8s-node01 k8s-node02; do scp /etc/kubernetes/kube-proxy.kubeconfig $NODE:/etc/kubernetes/kube-proxy.kubeconfig; done
# 所有k8s节点添加kube-proxy的service文件 cat > /usr/lib/systemd/system/kube-proxy.service << EOF [Unit] Description=Kubernetes Kube Proxy Documentation=https://github.com/kubernetes/kubernetes After=network.target [Service] ExecStart=/usr/local/bin/kube-proxy \\ --config=/etc/kubernetes/kube-proxy.yaml \\ --cluster-cidr=172.16.0.0/12,fc00:2222::/112 \\ --v=2 Restart=always RestartSec=10s [Install] WantedBy=multi-user.target EOF # 关闭IPv6 # 删除 --cluster-cidr 的IPv6地址 cat > /usr/lib/systemd/system/kube-proxy.service << EOF [Unit] Description=Kubernetes Kube Proxy Documentation=https://github.com/kubernetes/kubernetes After=network.target [Service] ExecStart=/usr/local/bin/kube-proxy \\ --config=/etc/kubernetes/kube-proxy.yaml \\ --cluster-cidr=172.16.0.0/12 \\ --v=2 Restart=always RestartSec=10s [Install] WantedBy=multi-user.target EOF # 这是一个 systemd 服务单元文件的示例，用于配置 Kubernetes Kube Proxy 服务。下面是对其中一些字段的详细解释： # # [Unit] # # Description: 描述了该服务单元的用途，这里是 Kubernetes Kube Proxy。 # Documentation: 指定了该服务单元的文档地址，即 https://github.com/kubernetes/kubernetes。 # After: 指定该服务单元应在 network.target（网络目标）之后启动。 # [Service] # # ExecStart: 指定了启动 Kube Proxy 服务的命令。通过 /usr/local/bin/kube-proxy 命令启动，并指定了配置文件的路径为 /etc/kubernetes/kube-proxy.yaml，同时指定了日志级别为 2。 # Restart: 配置了服务在失败或退出后自动重启。 # RestartSec: 配置了重启间隔，这里是每次重启之间的等待时间为 10 秒。 # [Install] # # WantedBy: 指定了该服务单元的安装目标为 multi-user.target（多用户目标），表示该服务将在多用户模式下启动。 # 通过配置这些字段，你可以启动和管理 Kubernetes Kube Proxy 服务。请注意，你需要根据实际情况修改 ExecStart 中的路径和文件名，确保与你的环境一致。另外，可以根据需求修改其他字段的值，以满足你的特定要求。 --- # 所有k8s节点添加kube-proxy的配置 cat > /etc/kubernetes/kube-proxy.yaml << EOF apiVersion: kubeproxy.config.k8s.io/v1alpha1 bindAddress: 0.0.0.0 clientConnection: acceptContentTypes: "" burst: 10 contentType: application/vnd.kubernetes.protobuf kubeconfig: /etc/kubernetes/kube-proxy.kubeconfig qps: 5 clusterCIDR: 172.16.0.0/12,fc00:2222::/112 configSyncPeriod: 15m0s conntrack: max: null maxPerCore: 32768 min: 131072 tcpCloseWaitTimeout: 1h0m0s tcpEstablishedTimeout: 24h0m0s enableProfiling: false healthzBindAddress: 0.0.0.0:10256 hostnameOverride: "" iptables: masqueradeAll: false masqueradeBit: 14 minSyncPeriod: 0s syncPeriod: 30s ipvs: masqueradeAll: true minSyncPeriod: 5s scheduler: "rr" syncPeriod: 30s kind: KubeProxyConfiguration metricsBindAddress: 127.0.0.1:10249 mode: "ipvs" nodePortAddresses: null oomScoreAdj: -999 portRange: "" udpIdleTimeout: 250ms EOF # 这是一个Kubernetes的kube-proxy组件配置文件示例。以下是每个配置项的详细解释： # 1. apiVersion: kubeproxy.config.k8s.io/v1alpha1 # - 指定该配置文件的API版本。 # 2. bindAddress: 0.0.0.0 # - 指定kube-proxy使用的监听地址。0.0.0.0表示监听所有网络接口。 # 3. clientConnection: # - 客户端连接配置项。 # a. acceptContentTypes: "" # - 指定接受的内容类型。 # b. burst: 10 # - 客户端请求超出qps设置时的最大突发请求数。 # c. contentType: application/vnd.kubernetes.protobuf # - 指定客户端请求的内容类型。 # d. kubeconfig: /etc/kubernetes/kube-proxy.kubeconfig # - kube-proxy使用的kubeconfig文件路径。 # e. qps: 5 # - 每秒向API服务器发送的请求数量。 # 4. clusterCIDR: 172.16.0.0/12,fc00:2222::/112 # - 指定集群使用的CIDR范围，用于自动分配Pod IP。 # 5. configSyncPeriod: 15m0s # - 指定kube-proxy配置同步到节点的频率。 # 6. conntrack: # - 连接跟踪设置。 # a. max: null # - 指定连接跟踪的最大值。 # b. maxPerCore: 32768 # - 指定每个核心的最大连接跟踪数. # c. min: 131072 # - 指定最小的连接跟踪数。 # d. tcpCloseWaitTimeout: 1h0m0s # - 指定处于CLOSE_WAIT状态的TCP连接的超时时间。 # e. tcpEstablishedTimeout: 24h0m0s # - 指定已建立的TCP连接的超时时间。 # 7. enableProfiling: false # - 是否启用性能分析。 # 8. healthzBindAddress: 0.0.0.0:10256 # - 指定健康检查监听地址和端口。 # 9. hostnameOverride: "" # - 指定覆盖默认主机名的值。 # 10. iptables: # - iptables设置。 # a. masqueradeAll: false # - 是否对所有流量使用IP伪装。 # b. masqueradeBit: 14 # - 指定伪装的Bit标记。 # c. minSyncPeriod: 0s # - 指定同步iptables规则的最小间隔。 # d. syncPeriod: 30s # - 指定同步iptables规则的时间间隔。 # 11. ipvs: # - ipvs设置。 # a. masqueradeAll: true # - 是否对所有流量使用IP伪装。 # b. minSyncPeriod: 5s # - 指定同步ipvs规则的最小间隔。 # c. scheduler: "rr" # - 指定ipvs默认使用的调度算法。 # d. syncPeriod: 30s # - 指定同步ipvs规则的时间间隔。 # 12. kind: KubeProxyConfiguration # - 指定该配置文件的类型。 # 13. metricsBindAddress: 127.0.0.1:10249 # - 指定指标绑定的地址和端口。 # 14. mode: "ipvs" # - 指定kube-proxy的模式。这里指定为ipvs，使用IPVS代理模式。 # 15. nodePortAddresses: null # - 指定可用于NodePort的网络地址。 # 16. oomScoreAdj: -999 # - 指定kube-proxy的OOM优先级。 # 17. portRange: "" # - 指定可用于服务端口范围。 # 18. udpIdleTimeout: 250ms # - 指定UDP连接的空闲超时时间。 --- # 启动kube-proxy systemctl daemon-reload # 用于重新加载systemd管理的单位文件。当你新增或修改了某个单位文件（如.service文件、.socket文件等），需要运行该命令来刷新systemd对该文件的配置。 systemctl enable --now kube-proxy.service # 启用并立即启动kube-proxy.service单元。kube-proxy.service是kube-proxy守护进程的systemd服务单元。 systemctl restart kube-proxy.service # 重启kube-proxy.service单元，即重新启动kube-proxy守护进程。 systemctl status kube-proxy.service # kube-proxy.service单元的当前状态，包括运行状态、是否启用等信息。
9、安装网络插件
此处选择安装Calico
更改calico网段【ipv6-ippool地址一定要与--cluster-cidr=***一致】
# 安装operator kubectl create -f https://raw.githubusercontent.com/projectcalico/calico/v3.30.3/manifests/tigera-operator.yaml # 下载配置文件 curl https://raw.githubusercontent.com/projectcalico/calico/v3.30.3/manifests/custom-resources.yaml -O # 修改地址池 vim custom-resources.yaml apiVersion: operator.tigera.io/v1 kind: Installation metadata: name: default spec: calicoNetwork: ipPools: - name: default-ipv4-ippool blockSize: 26 cidr: 172.16.0.0/12 encapsulation: VXLANCrossSubnet natOutgoing: Enabled nodeSelector: all() calicoNodeDaemonSet: spec: template: spec: # 将亲和性配置移动到这里 affinity: nodeAffinity: requiredDuringSchedulingIgnoredDuringExecution: nodeSelectorTerms: - matchExpressions: - key: node-role.kubernetes.io/edge operator: DoesNotExist csiNodeDriverDaemonSet: spec: template: spec: # 将亲和性配置移动到这里 affinity: nodeAffinity: requiredDuringSchedulingIgnoredDuringExecution: nodeSelectorTerms: - matchExpressions: - key: node-role.kubernetes.io/edge operator: DoesNotExist # ipv6示例 修改地址池 vim custom-resources.yaml apiVersion: operator.tigera.io/v1 kind: Installation metadata: name: default spec: calicoNetwork: ipPools: - name: ipv4-ippool cidr: 172.16.0.0/12 blockSize: 26 encapsulation: IPIP natOutgoing: Enabled nodeSelector: all() - name: ipv6-ippool cidr: "fc00:2222::/112" blockSize: 122 encapsulation: None natOutgoing: Enabled nodeSelector: all() nodeAddressAutodetectionV4: interface: "eth.*|en.*" nodeAddressAutodetectionV6: interface: "eth.*|en.*" # 执行安装 kubectl create -f custom-resources.yaml # 安装客户端 curl -L https://github.com/projectcalico/calico/releases/download/v3.30.3/calicoctl-linux-amd64 -o calicoctl # 给客户端添加执行权限 chmod +x ./calicoctl # 查看集群节点 ./calicoctl get nodes [root@k8s-master01 ~]# calicoctl get nodes --output=wide NAME ASN IPV4 IPV6 k8s-master01 (64512) 192.168.123.111/24 fc00::31/8 k8s-master02 (64512) 192.168.123.112/24 fc00::32/8 k8s-master03 (64512) 192.168.123.113/24 fc00::33/8 k8s-node01 (64512) 192.168.123.114/24 fc00::34/8 k8s-node02 (64512) 192.168.123.115/24 fc00::35/8 # 查看集群节点状态 ./calicoctl node status ## [有时候网卡状态不对，可以重启下网卡。]# nmcli connection down ens160 && nmcli connection up ens160 [root@k8s-master02 ~]# calicoctl node status Calico process is running. IPv4 BGP status +-----------------+-------------------+-------+----------+-------------+ | PEER ADDRESS | PEER TYPE | STATE | SINCE | INFO | +-----------------+-------------------+-------+----------+-------------+ | 192.168.123.111 | node-to-node mesh | up | 08:28:20 | Established | | 192.168.123.113 | node-to-node mesh | up | 08:28:17 | Established | | 192.168.123.114 | node-to-node mesh | up | 08:28:18 | Established | | 192.168.123.115 | node-to-node mesh | up | 08:28:18 | Established | +-----------------+-------------------+-------+----------+-------------+ IPv6 BGP status +--------------+-------------------+-------+----------+-------------+ | PEER ADDRESS | PEER TYPE | STATE | SINCE | INFO | +--------------+-------------------+-------+----------+-------------+ | fc00::31 | node-to-node mesh | up | 08:29:50 | Established | | fc00::33 | node-to-node mesh | up | 08:29:50 | Established | | fc00::34 | node-to-node mesh | up | 08:29:50 | Established | | fc00::35 | node-to-node mesh | up | 08:32:41 | Established | +--------------+-------------------+-------+----------+-------------+ #查看地址池 ./calicoctl get ipPool [root@k8s-master01 ~]# calicoctl get ipPool -o wide NAME CIDR NAT IPIPMODE VXLANMODE DISABLED DISABLEBGPEXPORT SELECTOR ASSIGNMENTMODE ipv4-ippool 172.16.0.0/12 true Always Never false false all() Automatic ipv6-ippool fc00:2222::/112 true Never Never false false all() Automatic ./calicoctl get ipPool -o yaml #### 相关镜像 docker pull docker.m.daocloud.io/calico/csi:v3.30.3 docker pull swr.cn-north-4.myhuaweicloud.com/ddn-k8s/docker.io/calico/node-driver-registrar:v3.30.3 docker tag 666f4e02e75c "docker.io/calico/csi:v3.30.3" docker tag b8f31c4fdaed "docker.io/calico/node-driver-registrar:v3.30.3"
查看容器状态
[root@k8s-master01 ~]# kubectl get pod -A NAMESPACE NAME READY STATUS RESTARTS AGE calico-apiserver calico-apiserver-85cb574df5-mzsns 1/1 Running 0 2m48s calico-apiserver calico-apiserver-85cb574df5-rwhn5 1/1 Running 0 2m48s calico-system calico-kube-controllers-76965d9bd5-h569t 1/1 Running 0 2m45s calico-system calico-node-8zdw5 1/1 Running 0 2m45s calico-system calico-node-98rn5 1/1 Running 0 2m45s calico-system calico-node-fnxv6 1/1 Running 0 2m45s calico-system calico-node-fsz7c 1/1 Running 0 2m45s calico-system calico-node-s4kmk 1/1 Running 0 2m45s calico-system calico-typha-5d4fbdfbf7-nz5t6 1/1 Running 0 2m45s calico-system calico-typha-5d4fbdfbf7-slqgv 1/1 Running 0 2m45s calico-system calico-typha-5d4fbdfbf7-t2l5v 1/1 Running 0 2m46s calico-system csi-node-driver-cbbmd 2/2 Running 0 2m45s calico-system csi-node-driver-ndsg2 2/2 Running 0 2m45s calico-system csi-node-driver-nf2l6 2/2 Running 0 2m45s calico-system csi-node-driver-p8fql 2/2 Running 0 2m45s calico-system csi-node-driver-xh59g 2/2 Running 0 2m45s calico-system goldmane-68c899b75-zdk9n 1/1 Running 0 2m46s calico-system whisker-74688b7447-k7ngd 2/2 Running 0 44s tigera-operator tigera-operator-db78d5bd4-8hr5k 1/1 Running 0 3m22s
10、安装CoreDNS
以下步骤只在master01操作
# 修改文件 # 下载tgz包 helm repo add coredns https://coredns.github.io/helm helm pull coredns/coredns tar xvf coredns-*.tgz cd coredns/ # 修改IP地址 vim values.yaml cat values.yaml | grep clusterIP: clusterIP: "10.96.0.10" # 示例 --- service: # clusterIP: "" # clusterIPs: [] # loadBalancerIP: "" # externalIPs: [] # externalTrafficPolicy: "" # ipFamilyPolicy: "" # The name of the Service # If not set, a name is generated using the fullname template clusterIP: "10.96.0.10" name: "" annotations: {} --- # 修改为国内源 sed -i "s#registry.k8s.io/#k8s.m.daocloud.io/#g" values.yaml # 默认参数安装 helm install coredns ./coredns/ -n kube-system
11、安装Metrics Server
以下步骤只在master01操作
# 安装Metrics-server 在新版的Kubernetes中系统资源的采集均使用Metrics-server，可以通过Metrics采集节点和Pod的内存、磁盘、CPU和网络的使用率 # 下载 wget https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml -O metrics-server.yaml # 修改配置 vim metrics-server.yaml --- # 1 - args: - --cert-dir=/tmp - --kubelet-preferred-address-types=InternalIP,ExternalIP,Hostname - --kubelet-use-node-status-port - --metric-resolution=15s - --kubelet-insecure-tls - --requestheader-client-ca-file=/etc/kubernetes/pki/front-proxy-ca.pem - --requestheader-username-headers=X-Remote-User - --requestheader-group-headers=X-Remote-Group - --requestheader-extra-headers-prefix=X-Remote-Extra- # 2 volumeMounts: - mountPath: /tmp name: tmp-dir - name: ca-ssl mountPath: /etc/kubernetes/pki # 3 volumes: - emptyDir: {} name: tmp-dir - name: ca-ssl hostPath: path: /etc/kubernetes/pki --- # 修改为国内源 docker源可选 sed -i "s#registry.k8s.io/#k8s.m.daocloud.io/#g" metrics-server.yaml # 执行部署 kubectl apply -f metrics-server.yaml --- # 稍等片刻查看状态 [root@k8s-master01 images]# kubectl top node NAME CPU(cores) CPU(%) MEMORY(bytes) MEMORY(%) k8s-master01 260m 6% 2571Mi 68% k8s-master02 124m 3% 1859Mi 49% k8s-master03 133m 3% 1780Mi 47% k8s-node01 48m 1% 1056Mi 27% k8s-node02 43m 1% 1048Mi 27%
12、集群验证
# 部署pod资源 cat<<EOF | kubectl apply -f - apiVersion: v1 kind: Pod metadata: name: busybox namespace: default spec: containers: - name: busybox image: docker.m.daocloud.io/library/busybox:1.28 command: - sleep - "3600" imagePullPolicy: IfNotPresent restartPolicy: Always EOF # 查看 kubectl get pod NAME READY STATUS RESTARTS AGE busybox 1/1 Running 0 17s
# 用pod解析默认命名空间中的kubernetes # 查看name kubectl get svc NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE kubernetes ClusterIP 10.96.0.1 <none> 443/TCP 17h # 进行解析 kubectl exec busybox -n default -- nslookup kubernetes 3Server: 10.96.0.10 Address 1: 10.96.0.10 kube-dns.kube-system.svc.cluster.local Name: kubernetes Address 1: 10.96.0.1 kubernetes.default.svc.cluster.local
# 测试跨命名空间是否可以解析 # 查看有那些name kubectl get svc -A NAMESPACE NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE default kubernetes ClusterIP 10.96.0.1 <none> 443/TCP 76m kube-system calico-typha ClusterIP 10.105.100.82 <none> 5473/TCP 35m kube-system coredns-coredns ClusterIP 10.96.0.10 <none> 53/UDP,53/TCP 8m14s kube-system metrics-server ClusterIP 10.105.60.31 <none> 443/TCP 109s # 进行解析 kubectl exec busybox -n default -- nslookup coredns.kube-system Server: 10.96.0.10 Address 1: 10.96.0.10 coredns-coredns.kube-system.svc.cluster.local Name: coredns-coredns.kube-system Address 1: 10.96.0.10 coredns-coredns.kube-system.svc.cluster.local [root@k8s-master01 metrics-server]# --- # 每个节点都必须要能访问Kubernetes的kubernetes svc 443和kube-dns的service 53 telnet 10.96.0.1 443 Trying 10.96.0.1... Connected to 10.96.0.1. Escape character is '^]'. telnet 10.96.0.10 53 Trying 10.96.0.10... Connected to 10.96.0.10. Escape character is '^]'. curl 10.96.0.10:53 curl: (52) Empty reply from server --- # Pod和Pod之前要能通信 kubectl get po -owide NAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE READINESS GATES busybox 1/1 Running 0 17m 172.27.14.193 k8s-node02 <none> <none> kubectl get po -n kube-system -owide NAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE READINESS GATES calico-kube-controllers-76754ff848-pw4xg 1/1 Running 0 38m 172.25.244.193 k8s-master01 <none> <none> calico-node-97m55 1/1 Running 0 38m 192.168.123.114 k8s-node01 <none> <none> calico-node-hlz7j 1/1 Running 0 38m 192.168.123.112 k8s-master02 <none> <none> calico-node-jtlck 1/1 Running 0 38m 192.168.123.113 k8s-master03 <none> <none> calico-node-lxfkf 1/1 Running 0 38m 192.168.123.115 k8s-node02 <none> <none> calico-node-t667x 1/1 Running 0 38m 192.168.123.111 k8s-master01 <none> <none> calico-typha-59d75c5dd4-gbhfp 1/1 Running 0 38m 192.168.123.115 k8s-node02 <none> <none> coredns-coredns-c5c6d4d9b-bd829 1/1 Running 0 10m 172.25.92.65 k8s-master02 <none> <none> metrics-server-7c8b55c754-w7q8v 1/1 Running 0 3m56s 172.17.125.3 k8s-node01 <none> <none> # 进入busybox ping其他节点上的pod kubectl exec -ti busybox -- sh / # ping 192.168.123.114 PING 192.168.123.114 (192.168.123.114): 56 data bytes 64 bytes from 192.168.123.114: seq=0 ttl=63 time=0.358 ms 64 bytes from 192.168.123.114: seq=1 ttl=63 time=0.668 ms 64 bytes from 192.168.123.114: seq=2 ttl=63 time=0.637 ms 64 bytes from 192.168.123.114: seq=3 ttl=63 time=0.624 ms 64 bytes from 192.168.123.114: seq=4 ttl=63 time=0.907 ms # 可以连通证明这个pod是可以跨命名空间和跨主机通信的 --- # 创建三个副本，可以看到3个副本分布在不同的节点上（用完可以删了） cat<<EOF | kubectl apply -f - apiVersion: apps/v1 kind: Deployment metadata: name: nginx-deployment labels: app: nginx spec: replicas: 3 selector: matchLabels: app: nginx template: metadata: labels: app: nginx spec: containers: - name: nginx image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/docker.io/nginx:1.28.0 ports: - containerPort: 80 EOF kubectl get pod NAME READY STATUS RESTARTS AGE busybox 1/1 Running 0 6m25s nginx-deployment-9456bbbf9-4bmvk 1/1 Running 0 8s nginx-deployment-9456bbbf9-9rcdk 1/1 Running 0 8s nginx-deployment-9456bbbf9-dqv8s 1/1 Running 0 8s # 删除nginx [root@k8s-master01 ~]# kubectl delete deployments nginx-deployment
13、安装dashboard <可忽略。这一版本的dashboard我的机器上有问题-或者使用rancher等其他三方dashboard>
# 添加源信息 helm repo add kubernetes-dashboard https://kubernetes.github.io/dashboard/ # 修改为国内源 # 拉取指定版本的 chart helm pull kubernetes-dashboard/kubernetes-dashboard --version 6.0.8 # 解压并修改镜像源 tar xvf kubernetes-dashboard-6.0.8.tgz cd kubernetes-dashboard # 修改为国内镜像源 sed -i "s#repository: .*#repository: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/docker.io/kubernetesui/dashboard#g" values.yaml sed -i "s#tag: .*#tag: v2.7.0#g" values.yaml # 安装 helm upgrade --install kubernetes-dashboard . \ --namespace kube-system \ --create-namespace \ --set kong.admin.tls.enabled=false --- # 更改dashboard的svc为NodePort，如果已是请忽略 kubectl edit svc -n kube-system kubernetes-dashboard-kong-proxy type: NodePort --- # 查看端口号 [root@k8s-master01 ~]# kubectl get svc kubernetes-dashboard-kong-proxy -n kube-system NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE kubernetes-dashboard-kong-proxy NodePort 10.100.9.217 <none> 443:31330/TCP 42s [root@k8s-master01 ~]# --- # 创建token cat > dashboard-user.yaml << EOF apiVersion: v1 kind: ServiceAccount metadata: name: admin-user namespace: kube-system --- apiVersion: rbac.authorization.k8s.io/v1 kind: ClusterRoleBinding metadata: name: admin-user roleRef: apiGroup: rbac.authorization.k8s.io kind: ClusterRole name: cluster-admin subjects: - kind: ServiceAccount name: admin-user namespace: kube-system EOF kubectl apply -f dashboard-user.yaml # 创建token kubectl -n kube-system create token admin-user eyJhbGciOiJSUzI1NiIsImtpZCI6ImkxLUpXdlZMdE9qTWZaNFVON1ppTWZPcU83NkpyRWNNdWxXNm5CN3ZUajQifQ.eyJhdWQiOlsiaHR0cHM6Ly9rdWJlcm5ldGVzLmRlZmF1bHQuc3ZjLmNsdXN0ZXIubG9jYWwiXSwiZXhwIjoxNzU2NjE0NDk0LCJpYXQiOjE3NTY2MTA4OTQsImlzcyI6Imh0dHBzOi8va3ViZXJuZXRlcy5kZWZhdWx0LnN2Yy5jbHVzdGVyLmxvY2FsIiwianRpIjoiNjYxZTQ4YjgtNDZjMC00ZjM2LWI4MzUtNzYzMTUyNTgzYTZhIiwia3ViZXJuZXRlcy5pbyI6eyJuYW1lc3BhY2UiOiJrdWJlLXN5c3RlbSIsInNlcnZpY2VhY2NvdW50Ijp7Im5hbWUiOiJhZG1pbi11c2VyIiwidWlkIjoiNTA1ZGQ4NDItMWMxZC00YzBiLWIzN2ItNTlkMjAzNDNlYzA3In19LCJuYmYiOjE3NTY2MTA4OTQsInN1YiI6InN5c3RlbTpzZXJ2aWNlYWNjb3VudDprdWJlLXN5c3RlbTphZG1pbi11c2VyIn0.WzTJuDbniHcOrKvTe_kfjOM5DIdqf-DsJl0qfn3iiLhqnczk9UxPpBb97I7XXDSf1eyHcNyvOYzKIPxdr6duGDlHiJbkLszozJR26F_EHviufqEuBKiph6FarQtsy_q_yaVPW2g_7nq-tnwcV3I2rvms6p6pNvledAQ8eRt_fJGFJ1AJ8rc3jsAbA-SCrRTLTtYqmAOZqJnSkRwVXvQLr4twNIaQjz3YiZIreNlaLqLJcj0r8ozP2lQCtmDO6bVBAKCGpgytQFDLyHiJyu8HlpMLice4nmz7stIza1LtIRcy_OLPCfGNRNvju0WPDt7qZVV5z5oxepAEBWzTfoOCDQ --- # 创建长期token cat > dashboard-user-token.yaml << EOF apiVersion: v1 kind: Secret metadata: name: admin-user namespace: kube-system annotations: kubernetes.io/service-account.name: "admin-user" type: kubernetes.io/service-account-token EOF kubectl apply -f dashboard-user-token.yaml # 查看密码 kubectl get secret admin-user -n kube-system -o jsonpath={".data.token"} | base64 -d eyJhbGciOiJSUzI1NiIsImtpZCI6ImkxLUpXdlZMdE9qTWZaNFVON1ppTWZPcU83NkpyRWNNdWxXNm5CN3ZUajQifQ.eyJpc3MiOiJrdWJlcm5ldGVzL3NlcnZpY2VhY2NvdW50Iiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9uYW1lc3BhY2UiOiJrdWJlLXN5c3RlbSIsImt1YmVybmV0ZXMuaW8vc2VydmljZWFjY291bnQvc2VjcmV0Lm5hbWUiOiJhZG1pbi11c2VyIiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9zZXJ2aWNlLWFjY291bnQubmFtZSI6ImFkbWluLXVzZXIiLCJrdWJlcm5ldGVzLmlvL3NlcnZpY2VhY2NvdW50L3NlcnZpY2UtYWNjb3VudC51aWQiOiI1MDVkZDg0Mi0xYzFkLTRjMGItYjM3Yi01OWQyMDM0M2VjMDciLCJzdWIiOiJzeXN0ZW06c2VydmljZWFjY291bnQ6a3ViZS1zeXN0ZW06YWRtaW4tdXNlciJ9.ESyhAs--VuapsdXzwWpeNYxf5JLoxsQWFdKwiD9QgjXsfMVe7Xoy82mXd_sr1XH96hmRDms04D3cAW5j05RDlnx8yXWIFMcphZ5xwt8Qls-XYcpJWHGLrWl91JIk-Dm8Xr70CkOyjFSpr9nKSg8fp2QlIpOFG_l04hvZY3OKQrHhVwk77D2OespFBswz3QacERNqNxX8N8J1UbEs_cXW0jUmCCpAgHcJaxVYYcb_KQm1L3iF0D-d8cn8ImRvcswN0PQN-deOsctWdm15rlb_vnyFrC47uQQYgrwMe1mtuitOkhdZ59Px_wxE0xv49cAFduzeLdJllU151GhEilpXAg --- 登录dashboard https://192.168.123.111:31330/
14、部署metallb(可选：svc支持_LoadBalancer负载均衡器插件)
# 下载部署 # 下载应用包 wget https://raw.githubusercontent.com/metallb/metallb/v0.15.2/config/manifests/metallb-native.yaml # 修改镜像地址 # 自行找代理 sed -i "s#quay.io#quay.chenby.cn#g" metallb-native.yaml cat metallb-native.yaml | grep image image: quay.chenby.cn/metallb/controller:v0.14.5 image: quay.chenby.cn/metallb/speaker:v0.14.5 # 执行部署 kubectl apply -f metallb-native.yaml # 可以连接国际网络 # kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.15.2/config/manifests/metallb-native.yaml --- # 查看运行情况 root@k8s-master01:~# kubectl -n metallb-system get all NAME READY STATUS RESTARTS AGE pod/controller-6599cd9c46-rr54w 1/1 Running 0 78s pod/speaker-55j5t 1/1 Running 0 78s pod/speaker-bcr4j 1/1 Running 0 78s pod/speaker-p7vgz 1/1 Running 0 78s pod/speaker-pzvkd 1/1 Running 0 78s pod/speaker-vcjvr 1/1 Running 0 78s NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE service/metallb-webhook-service ClusterIP 10.106.20.159 <none> 443/TCP 78s NAME DESIRED CURRENT READY UP-TO-DATE AVAILABLE NODE SELECTOR AGE daemonset.apps/speaker 5 5 5 5 5 kubernetes.io/os=linux 78s NAME READY UP-TO-DATE AVAILABLE AGE deployment.apps/controller 1/1 1 1 78s NAME DESIRED CURRENT READY AGE replicaset.apps/controller-6599cd9c46 1 1 1 78s --- # 配置VIP的资源池 # 新版本metallb使用了CR（Custom Resources），这里我们通过IPAddressPool的CR，进行地址池的定义。 # 如果实例中不设置IPAddressPool选择器L2Advertisement；那么L2Advertisement默认为该实例所有的IPAddressPool相关联。 cat > metallb-config-ipaddresspool.yaml << EOF apiVersion: metallb.io/v1beta1 kind: IPAddressPool metadata: name: first-pool namespace: metallb-system spec: addresses: - 192.168.123.71-192.168.123.75 EOF # 进行L2关联地址池的绑定。 cat > metallb-config-L2Advertisement.yaml << EOF apiVersion: metallb.io/v1beta1 kind: L2Advertisement metadata: name: example namespace: metallb-system spec: ipAddressPools: - first-pool EOF # 执行部署 kubectl apply -f metallb-config-ipaddresspool.yaml kubectl apply -f metallb-config-L2Advertisement.yaml
15、ingress安装
# 1、执行部署 # 添加仓库 helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx helm repo update # 拉取仓库 helm pull ingress-nginx/ingress-nginx tar xvf ingress-nginx-4.12.3.tgz 替换镜像源：registry: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/registry.k8s.io # 查看镜像地址，若你的环境无法下载这个镜像，那么就需要你自行找镜像 或者更换镜像地址 [root@k8s-master01 ingress-nginx]# cat values.yaml | grep image | grep -v \# image: image: image: ingress-nginx/controller image: image: ingress-nginx/kube-webhook-certgen image: image: defaultbackend-amd64 imagePullSecrets: [] [root@k8s-master01 ingress-nginx]# # 我这里的环境可以直接拉取 我直接进行了安装 helm install ingress-nginx ./ingress-nginx \ --namespace ingress --create-namespace # 查看完成安装 [root@k8s-master01 ~]# kubectl get all -n ingress NAME READY STATUS RESTARTS AGE pod/ingress-nginx-controller-6996967cbb-fplzt 1/1 Running 0 56s NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE service/ingress-nginx-controller LoadBalancer 10.109.63.223 192.168.123.71 80:32046/TCP,443:31512/TCP 56s service/ingress-nginx-controller-admission ClusterIP 10.110.227.191 <none> 443/TCP 56s NAME READY UP-TO-DATE AVAILABLE AGE deployment.apps/ingress-nginx-controller 1/1 1 1 56s NAME DESIRED CURRENT READY AGE replicaset.apps/ingress-nginx-controller-6996967cbb 1 1 1 56s [root@k8s-master01 ~]# --- 2、创建测试应用 cat > ingress-demo-app.yaml << EOF apiVersion: apps/v1 kind: Deployment metadata: name: hello-server spec: replicas: 2 selector: matchLabels: app: hello-server template: metadata: labels: app: hello-server spec: containers: - name: hello-server image: registry.cn-hangzhou.aliyuncs.com/lfy_k8s_images/hello-server ports: - containerPort: 9000 --- apiVersion: apps/v1 kind: Deployment metadata: labels: app: nginx-demo name: nginx-demo spec: replicas: 2 selector: matchLabels: app: nginx-demo template: metadata: labels: app: nginx-demo spec: containers: - image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/docker.io/nginx:1.28.0 name: nginx --- apiVersion: v1 kind: Service metadata: labels: app: nginx-demo name: nginx-demo spec: selector: app: nginx-demo ports: - port: 8000 protocol: TCP targetPort: 80 --- apiVersion: v1 kind: Service metadata: labels: app: hello-server name: hello-server spec: selector: app: hello-server ports: - port: 8000 protocol: TCP targetPort: 9000 EOF cat >> ingress-demo-app-ingress.yaml <<EOF apiVersion: networking.k8s.io/v1 kind: Ingress metadata: name: ingress-host-bar spec: ingressClassName: nginx rules: - host: "hello.chenby.cn" http: paths: - pathType: Prefix path: "/" backend: service: name: hello-server port: number: 8000 - host: "demo.chenby.cn" http: paths: - pathType: Prefix path: "/" backend: service: name: nginx-demo port: number: 8000 EOF # 等创建完成后在执行： kubectl apply -f ingress-demo-app.yaml kubectl apply -f ingress-demo-app-ingress.yaml kubectl get ingress NAME CLASS HOSTS ADDRESS PORTS AGE ingress-host-bar nginx hello.chenby.cn,demo.chenby.cn 192.168.123.71 80 22s --- # 3、测试访问 # 写入hosts cat >> /etc/hosts <<EOF 192.168.123.71 hello.chenby.cn 192.168.123.71 demo.chenby.cn EOF # 访问 hello 正常 [root@localhost ~]# curl hello.chenby.cn Hello World![root@localhost ~]# [root@localhost ~]# # # 访问 demo 正常 [root@localhost ~]# curl demo.chenby.cn <!DOCTYPE html> <html> <head> <title>Welcome to nginx!</title> <style> html { color-scheme: light dark; } body { width: 35em; margin: 0 auto; font-family: Tahoma, Verdana, Arial, sans-serif; } </style> </head> <body> <h1>Welcome to nginx!</h1> <p>If you see this page, the nginx web server is successfully installed and working. Further configuration is required.</p> <p>For online documentation and support please refer to <a href="http://nginx.org/">nginx.org</a>.<br/> Commercial support is available at <a href="http://nginx.com/">nginx.com</a>.</p> <p><em>Thank you for using nginx.</em></p> </body> </html> [root@localhost ~]# --- # 4、测试路径重写 # 删除刚建的ingress kubectl delete -f ingress-demo-app-ingress.yaml # 写入新的ingress cat >> ingress-demo-app-ingress-router.yaml <<EOF apiVersion: networking.k8s.io/v1 kind: Ingress metadata: annotations: nginx.ingress.kubernetes.io/rewrite-target: /$2 name: ingress-host-bar spec: ingressClassName: nginx rules: - host: "hello.chenby.cn" http: paths: - pathType: Prefix path: "/" backend: service: name: hello-server port: number: 8000 - host: "demo.chenby.cn" http: paths: - pathType: Prefix path: "/nginx(/|$)(.*)" pathType: ImplementationSpecific backend: service: name: nginx-demo port: number: 8000 EOF # 执行部署 kubectl apply -f ingress-demo-app-ingress-router.yaml # 访问 hello 返回正常 [root@localhost ~]# curl hello.chenby.cn Hello World![root@localhost ~]# [root@localhost ~]# # 访问 demo 访问异常 [root@localhost ~]# curl demo.chenby.cn <html> <head><title>404 Not Found</title></head> <body> <center><h1>404 Not Found</h1></center> <hr><center>nginx</center> </body> </html> [root@localhost ~]# # 访问时加上URI 访问正常 [root@localhost ~]# curl demo.chenby.cn/nginx <!DOCTYPE html> <html> <head> <title>Welcome to nginx!</title> <style> html { color-scheme: light dark; } body { width: 35em; margin: 0 auto; font-family: Tahoma, Verdana, Arial, sans-serif; } </style> </head> <body> <h1>Welcome to nginx!</h1> <p>If you see this page, the nginx web server is successfully installed and working. Further configuration is required.</p> <p>For online documentation and support please refer to <a href="http://nginx.org/">nginx.org</a>.<br/> Commercial support is available at <a href="http://nginx.com/">nginx.com</a>.</p> <p><em>Thank you for using nginx.</em></p> </body> </html> [root@localhost ~]# --- # 5、测试流量限制 # 删除刚建的ingress kubectl delete -f ingress-demo-app-ingress.yaml # 写入新的ingress cat >> ingress-demo-app-ingress-limit.yaml <<EOF apiVersion: networking.k8s.io/v1 kind: Ingress metadata: name: ingress-limit-rate annotations: nginx.ingress.kubernetes.io/limit-rps: "1" spec: ingressClassName: nginx rules: - host: "hello.chenby.cn" http: paths: - pathType: Exact path: "/" backend: service: name: hello-server port: number: 8000 - host: "demo.chenby.cn" http: paths: - pathType: Prefix path: "/nginx(/|$)(.*)" pathType: ImplementationSpecific backend: service: name: nginx-demo port: number: 8000 EOF # 执行部署 kubectl apply -f ingress-demo-app-ingress-limit.yaml # 访问过快 会返回 503 [root@localhost ~]# for i in {1..8}; do curl hello.chenby.cn; done Hello World!Hello World!Hello World!Hello World!Hello World!Hello World!<html> <head><title>503 Service Temporarily Unavailable</title></head> <body> <center><h1>503 Service Temporarily Unavailable</h1></center> <hr><center>nginx</center> </body> </html> <html> <head><title>503 Service Temporarily Unavailable</title></head> <body> <center><h1>503 Service Temporarily Unavailable</h1></center> <hr><center>nginx</center> </body> </html> [root@localhost ~]# --- # 6、过滤查看ingress端口 # 上面有安装metallb组件，所有ingress有自动获取到地址，我这里就不修改nodeport了 # 各位如果没有metallb组件 就需要修改 nodeport # 修改为nodeport kubectl edit svc -n ingress-nginx ingress-nginx-controller type: NodePort [root@hello ~/yaml]# kubectl get svc -A | grep ingress ingress-nginx ingress-nginx-controller LoadBalancer 10.110.161.30 192.168.123.71 80:32480/TCP,443:30195/TCP 12m ingress-nginx ingress-nginx-controller-admission ClusterIP 10.105.211.217 <none> 443/TCP 12m [root@hello ~/yaml]#
16、IPv6测试
#部署应用 cat<<EOF | kubectl apply -f - apiVersion: apps/v1 kind: Deployment metadata: name: chenby spec: replicas: 1 selector: matchLabels: app: chenby template: metadata: labels: app: chenby spec: hostNetwork: true containers: - name: chenby image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/docker.io/nginx:1.28.0 resources: limits: memory: "128Mi" cpu: "500m" ports: - containerPort: 80 --- apiVersion: v1 kind: Service metadata: name: chenby spec: ipFamilyPolicy: PreferDualStack ipFamilies: - IPv6 - IPv4 type: NodePort selector: app: chenby ports: - port: 80 targetPort: 80 EOF #查看端口 [root@k8s-master01 ingress-nginx]# kubectl get svc NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE chenby NodePort fd00:1111::2082 <none> 80:31704/TCP 11s # 直接访问POD地址 [root@k8s-master01 ingress-nginx]# curl -I http://[fd00:1111::2082] HTTP/1.1 200 OK Server: nginx/1.27.0 Date: Sun, 12 Oct 2025 09:41:41 GMT Content-Type: text/html Content-Length: 615 Last-Modified: Tue, 28 May 2024 13:22:30 GMT Connection: keep-alive ETag: "6655da96-267" Accept-Ranges: bytes [root@k8s-master01 ingress-nginx]# # 使用IPv4地址访问测试 [root@k8s-master01 ingress-nginx]# curl -I http://192.168.123.111:31704 HTTP/1.1 200 OK Server: nginx/1.27.0 Date: Sun, 12 Oct 2025 09:44:04 GMT Content-Type: text/html Content-Length: 615 Last-Modified: Tue, 28 May 2024 13:22:30 GMT Connection: keep-alive ETag: "6655da96-267" Accept-Ranges: bytes # 使用主机的内网IPv6地址测试 [root@k8s-master01 ingress-nginx]# curl -I http://[fc00::32]:31704 HTTP/1.1 200 OK Server: nginx/1.27.0 Date: Sun, 12 Oct 2025 09:43:45 GMT Content-Type: text/html Content-Length: 615 Last-Modified: Tue, 28 May 2024 13:22:30 GMT Connection: keep-alive ETag: "6655da96-267" Accept-Ranges: bytes # 使用主机的公网IPv6地址测试 [root@k8s-master01 ingress-nginx]# curl -I http://[fc00::20c:29ff:fe47:2b21]:31704 HTTP/1.1 200 OK Server: nginx/1.27.0 Date: Sun, 12 Oct 2025 09:45:54 GMT Content-Type: text/html Content-Length: 615 Last-Modified: Tue, 28 May 2024 13:22:30 GMT Connection: keep-alive ETag: "6655da96-267" Accept-Ranges: bytes
17、动态存储配置（ceph、NFS）
安装NFS动态存储
# 安装nfs # CentOS yum install -y nfs-utils # Ubuntu apt install nfs-kernel-server nfs-common # 创建共享 mkdir /nfs # 编辑共享 vim /etc/exports /nfs *(rw,sync,no_root_squash,no_subtree_check) # centos systemctl enable rpcbind.service systemctl enable nfs-server.service systemctl restart rpcbind.service systemctl restart nfs-server.service # ubuntu systemctl enable nfs-kernel-server systemctl restart nfs-kernel-server # 加载配置 exportfs -a exportfs -r exportfs # 添加仓库 helm repo add nfs-subdir-external-provisioner https://kubernetes-sigs.github.io/nfs-subdir-external-provisioner/ # --set nfs.server 填写你的nfs服务器地址 # --set nfs.path 填写你的nfs服务器路径 helm install -n kube-system nfs-subdir-external-provisioner nfs-subdir-external-provisioner/nfs-subdir-external-provisioner \ --set storageClass.defaultClass=true \ --set nfs.server=192.168.123.61 \ --set nfs.path=/nfs # 查看是否为默认存储 [root@k8s-master01 ~]# kubectl get storageclasses.storage.k8s.io NAME PROVISIONER RECLAIMPOLICY VOLUMEBINDINGMODE ALLOWVOLUMEEXPANSION AGE nfs-client (default) cluster.local/nfs-subdir-external-provisioner Delete Immediate true 123m
测试nfs动态存储
# 创建PVC需求 cat >> pvc.yaml <<EOF kind: PersistentVolumeClaim apiVersion: v1 metadata: name: nginx-pvc spec: accessModes: - ReadWriteMany resources: requests: storage: 200Mi EOF # 执行部署 kubectl apply -f pvc.yaml # 查看pvc [root@k8s-master-node1 ~/yaml]# kubectl get pvc NAME STATUS VOLUME CAPACITY ACCESS MODES STORAGECLASS AGE nginx-pvc Bound pvc-8a4b6065-904a-4bae-bef9-1f3b5612986c 200Mi RWX nfs-storage 4s [root@k8s-master-node1 ~/yaml]# # 查看pv [root@k8s-master-node1 ~/yaml]# kubectl get pv NAME CAPACITY ACCESS MODES RECLAIM POLICY STATUS CLAIM STORAGECLASS REASON AGE pvc-8a4b6065-904a-4bae-bef9-1f3b5612986c 200Mi RWX Delete Bound default/nginx-pvc nfs-storage 103s [root@k8s-master-node1 ~/yaml]#
安装ceph动态存储
—— 推荐使用版本：Ceph-CSI v3.12.3或 v3.13.0 【文档是3.4版本，生产环境建议重新考虑】
## https://github.com/ceph/ceph-csi/archive/refs/tags/v3.4.0.tar.gz [root@k8s-master cephfs]# kubectl get pods -A -o wide |grep csi calico-system csi-node-driver-4k6tt 2/2 Running 20 (98m ago) 30h 10.244.235.203 k8s-master <none> <none> default csi-cephfsplugin-njxbb 3/3 Running 0 7m21s 192.168.123.122 k8s-master <none> <none> default csi-cephfsplugin-provisioner-795d6c866-48mnt 0/6 Pending 0 7m20s <none> <none> <none> <none> default csi-cephfsplugin-provisioner-795d6c866-jpv4n 6/6 Running 0 7m20s 10.244.235.209 k8s-master <none> <none> default csi-cephfsplugin-provisioner-795d6c866-qs6ts 0/6 Pending 0 7m20s <none> <none> <none> <none> [root@k8s-master cephfs]# kubectl get storageclasses NAME PROVISIONER RECLAIMPOLICY VOLUMEBINDINGMODE ALLOWVOLUMEEXPANSION AGE csi-cephfs-sc cephfs.csi.ceph.com Delete Immediate true 8m48s [root@k8s-master cephfs]# kubectl get pv,pvc NAME CAPACITY ACCESS MODES RECLAIM POLICY STATUS CLAIM STORAGECLASS VOLUMEATTRIBUTESCLASS REASON AGE persistentvolume/pvc-709172cc-607d-4b00-8386-6cc68394d9cf 1Gi RWX Delete Bound default/csi-cephfs-pvc csi-cephfs-sc <unset> 4m34s NAME STATUS VOLUME CAPACITY ACCESS MODES STORAGECLASS VOLUMEATTRIBUTESCLASS AGE persistentvolumeclaim/csi-cephfs-pvc Bound pvc-709172cc-607d-4b00-8386-6cc68394d9cf 1Gi RWX csi-cephfs-sc <unset> 4m34s
cephfs
csi-cephfs相关yaml文件列表：[ceph-csi-3.4.0/deploy/cephfs/kubernetes/ ceph-csi-3.4.0/examples/cephfs/]
csi-cephfsplugin-provisioner.yaml
csi-cephfsplugin.yaml
csi-config-map.yaml
csi-nodeplugin-rbac.yaml
csi-provisioner-rbac.yaml
pvc.yaml
secret.yaml
storageclass.yaml
## 有存储池未启用应用程序问题处理 [ceph: root@k8s-master /]# ceph -s cluster: id: c0811c64-a8d4-11f0-904c-000c2907e588 health: HEALTH_WARN 1 pool(s) do not have an application enabled services: mon: 1 daemons, quorum k8s-master (age 9m) mgr: k8s-master.lsxmzg(active, since 9m), standbys: k8s-master.mcfchp mds: 1/1 daemons up, 1 standby osd: 3 osds: 3 up (since 9m), 3 in (since 18h) data: volumes: 1/1 healthy pools: 4 pools, 97 pgs objects: 27 objects, 684 KiB usage: 90 MiB used, 30 GiB / 30 GiB avail pgs: 97 active+clean [ceph: root@k8s-master /]# ceph health detail HEALTH_WARN 1 pool(s) do not have an application enabled [WRN] POOL_APP_NOT_ENABLED: 1 pool(s) do not have an application enabled application not enabled on pool 'Mypool' use 'ceph osd pool application enable <pool-name> <app-name>', where <app-name> is 'cephfs', 'rbd', 'rgw', or freeform for custom applications. ## 您需要为其启用一个对应的应用程序。Ceph支持的常见应用程序有 rbd(块存储)、cephfs(文件存储)、rgw(对象存储) ## 不需要的话，删除即可。 [ceph: root@k8s-master /]# ceph osd pool delete Mypool Mypool --yes-i-really-really-mean-it pool 'Mypool' removed
RBD_ceph
[ceph: root@k8s-master /]# ceph osd pool create rbd_data pool 'rbd_data' created [ceph: root@k8s-master /]# ceph osd pool ls .mgr metaDataForK8s DataForK8s rbd_data [ceph: root@k8s-master /]# ceph osd pool delete rbd_data rbd_data --yes-i-really-really-mean-it pool 'rbd_data' removed [ceph: root@k8s-master /]# ceph osd pool application enable rbd_data rbd enabled application 'rbd' on pool 'rbd_data' [ceph: root@k8s-master /]# ceph auth add client.rbd_data mon "profile rbd" osd "profile rbd pool=rbd_data" mgr "profile rbd pool=rbd_data" added key for client.rbd_data [ceph: root@k8s-master /]# ceph auth get client.rbd_data [client.rbd_data] key = AQChVu9omfSHHBAARLc2W5hXfZepYL82JI8xGg== caps mgr = "profile rbd pool=rbd_data" caps mon = "profile rbd" caps osd = "profile rbd pool=rbd_data" [ceph: root@k8s-master /]# ceph auth del client.rbd_data [root@k8s-master ~]# kubectl get sc,pv,pvc -A NAME PROVISIONER RECLAIMPOLICY VOLUMEBINDINGMODE ALLOWVOLUMEEXPANSION AGE storageclass.storage.k8s.io/csi-cephfs-sc cephfs.csi.ceph.com Delete Immediate true 2m48s storageclass.storage.k8s.io/csi-rbd-rbd rbd.csi.ceph.com Delete Immediate true 13m NAME CAPACITY ACCESS MODES RECLAIM POLICY STATUS CLAIM STORAGECLASS VOLUMEATTRIBUTESCLASS REASON AGE persistentvolume/pvc-7a931f6a-281f-4866-8bc9-a95a5e2f22e4 2Gi RWX Delete Bound ceph-rbd/csi-ceph-rbd-pvc csi-rbd-rbd <unset> 3m39s persistentvolume/pvc-ba79da95-4799-4a8b-8ae2-07e00c527d66 1Gi RWX Delete Bound default/csi-cephfs-pvc csi-cephfs-sc <unset> 2m26s NAMESPACE NAME STATUS VOLUME CAPACITY ACCESS MODES STORAGECLASS VOLUMEATTRIBUTESCLASS AGE ceph-rbd persistentvolumeclaim/csi-ceph-rbd-pvc Bound pvc-7a931f6a-281f-4866-8bc9-a95a5e2f22e4 2Gi RWX csi-rbd-rbd <unset> 3m41s default persistentvolumeclaim/csi-cephfs-pvc Bound pvc-ba79da95-4799-4a8b-8ae2-07e00c527d66 1Gi RWX csi-cephfs-sc <unset> 2m48s
附件：yaml文件内容<可对照参考>
#文件名称：csi-cephfsplugin-provisioner.yaml --- kind: Service apiVersion: v1 metadata: name: csi-cephfsplugin-provisioner labels: app: csi-metrics spec: selector: app: csi-cephfsplugin-provisioner ports: - name: http-metrics port: 8080 protocol: TCP targetPort: 8681 --- kind: Deployment apiVersion: apps/v1 metadata: name: csi-cephfsplugin-provisioner spec: selector: matchLabels: app: csi-cephfsplugin-provisioner replicas: 3 template: metadata: labels: app: csi-cephfsplugin-provisioner spec: affinity: podAntiAffinity: requiredDuringSchedulingIgnoredDuringExecution: - labelSelector: matchExpressions: - key: app operator: In values: - csi-cephfsplugin-provisioner topologyKey: "kubernetes.io/hostname" serviceAccountName: cephfs-csi-provisioner priorityClassName: system-cluster-critical containers: - name: csi-provisioner image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/k8s.gcr.io/sig-storage/csi-provisioner:v2.2.2 args: - "--csi-address=$(ADDRESS)" - "--v=5" - "--timeout=150s" - "--leader-election=true" - "--retry-interval-start=500ms" - "--feature-gates=Topology=false" - "--extra-create-metadata=true" env: - name: ADDRESS value: unix:///csi/csi-provisioner.sock imagePullPolicy: "IfNotPresent" volumeMounts: - name: socket-dir mountPath: /csi - name: csi-resizer image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/k8s.gcr.io/sig-storage/csi-resizer:v1.2.0 args: - "--csi-address=$(ADDRESS)" - "--v=5" - "--timeout=150s" - "--leader-election" - "--retry-interval-start=500ms" - "--handle-volume-inuse-error=false" env: - name: ADDRESS value: unix:///csi/csi-provisioner.sock imagePullPolicy: "IfNotPresent" volumeMounts: - name: socket-dir mountPath: /csi - name: csi-snapshotter image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/k8s.gcr.io/sig-storage/csi-snapshotter:v4.1.1 args: - "--csi-address=$(ADDRESS)" - "--v=5" - "--timeout=150s" - "--leader-election=true" env: - name: ADDRESS value: unix:///csi/csi-provisioner.sock imagePullPolicy: "IfNotPresent" securityContext: privileged: true volumeMounts: - name: socket-dir mountPath: /csi - name: csi-cephfsplugin-attacher image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/k8s.gcr.io/sig-storage/csi-attacher:v3.2.1 args: - "--v=5" - "--csi-address=$(ADDRESS)" - "--leader-election=true" - "--retry-interval-start=500ms" env: - name: ADDRESS value: /csi/csi-provisioner.sock imagePullPolicy: "IfNotPresent" volumeMounts: - name: socket-dir mountPath: /csi - name: csi-cephfsplugin securityContext: privileged: true capabilities: add: ["SYS_ADMIN"] # for stable functionality replace canary with latest release version image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/quay.io/cephcsi/cephcsi:v3.4.0 args: - "--nodeid=$(NODE_ID)" - "--type=cephfs" - "--controllerserver=true" - "--endpoint=$(CSI_ENDPOINT)" - "--v=5" - "--drivername=cephfs.csi.ceph.com" - "--pidlimit=-1" - "--enableprofiling=false" env: - name: POD_IP valueFrom: fieldRef: fieldPath: status.podIP - name: NODE_ID valueFrom: fieldRef: fieldPath: spec.nodeName - name: CSI_ENDPOINT value: unix:///csi/csi-provisioner.sock imagePullPolicy: "IfNotPresent" volumeMounts: - name: socket-dir mountPath: /csi - name: host-sys mountPath: /sys - name: lib-modules mountPath: /lib/modules readOnly: true - name: host-dev mountPath: /dev - name: ceph-csi-config mountPath: /etc/ceph-csi-config/ - name: keys-tmp-dir mountPath: /tmp/csi/keys - name: liveness-prometheus image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/quay.io/cephcsi/cephcsi:v3.4.0 args: - "--type=liveness" - "--endpoint=$(CSI_ENDPOINT)" - "--metricsport=8681" - "--metricspath=/metrics" - "--polltime=60s" - "--timeout=3s" env: - name: CSI_ENDPOINT value: unix:///csi/csi-provisioner.sock - name: POD_IP valueFrom: fieldRef: fieldPath: status.podIP volumeMounts: - name: socket-dir mountPath: /csi imagePullPolicy: "IfNotPresent" volumes: - name: socket-dir emptyDir: { medium: "Memory" } - name: host-sys hostPath: path: /sys - name: lib-modules hostPath: path: /lib/modules - name: host-dev hostPath: path: /dev - name: ceph-csi-config configMap: name: ceph-csi-config - name: keys-tmp-dir emptyDir: { medium: "Memory" } #文件名称：csi-cephfsplugin.yaml --- kind: DaemonSet apiVersion: apps/v1 metadata: name: csi-cephfsplugin spec: selector: matchLabels: app: csi-cephfsplugin template: metadata: labels: app: csi-cephfsplugin spec: serviceAccountName: cephfs-csi-nodeplugin priorityClassName: system-node-critical hostNetwork: true # to use e.g. Rook orchestrated cluster, and mons' FQDN is # resolved through k8s service, set dns policy to cluster first dnsPolicy: ClusterFirstWithHostNet containers: - name: driver-registrar # This is necessary only for systems with SELinux, where # non-privileged sidecar containers cannot access unix domain socket # created by privileged CSI driver container. securityContext: privileged: true image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/registry.k8s.io/sig-storage/csi-node-driver-registrar:v2.2.0 args: - "--v=5" - "--csi-address=/csi/csi.sock" - "--kubelet-registration-path=/var/lib/kubelet/plugins/cephfs.csi.ceph.com/csi.sock" env: - name: KUBE_NODE_NAME valueFrom: fieldRef: fieldPath: spec.nodeName volumeMounts: - name: socket-dir mountPath: /csi - name: registration-dir mountPath: /registration - name: csi-cephfsplugin securityContext: privileged: true capabilities: add: ["SYS_ADMIN"] allowPrivilegeEscalation: true # for stable functionality replace canary with latest release version image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/quay.io/cephcsi/cephcsi:v3.4.0 args: - "--nodeid=$(NODE_ID)" - "--type=cephfs" - "--nodeserver=true" - "--endpoint=$(CSI_ENDPOINT)" - "--v=5" - "--drivername=cephfs.csi.ceph.com" - "--enableprofiling=false" # If topology based provisioning is desired, configure required # node labels representing the nodes topology domain # and pass the label names below, for CSI to consume and advertise # its equivalent topology domain # - "--domainlabels=failure-domain/region,failure-domain/zone" env: - name: POD_IP valueFrom: fieldRef: fieldPath: status.podIP - name: NODE_ID valueFrom: fieldRef: fieldPath: spec.nodeName - name: CSI_ENDPOINT value: unix:///csi/csi.sock imagePullPolicy: "IfNotPresent" volumeMounts: - name: socket-dir mountPath: /csi - name: mountpoint-dir mountPath: /var/lib/kubelet/pods mountPropagation: Bidirectional - name: plugin-dir mountPath: /var/lib/kubelet/plugins mountPropagation: "Bidirectional" - name: host-sys mountPath: /sys - name: lib-modules mountPath: /lib/modules readOnly: true - name: host-dev mountPath: /dev - name: host-mount mountPath: /run/mount - name: ceph-csi-config mountPath: /etc/ceph-csi-config/ - name: keys-tmp-dir mountPath: /tmp/csi/keys - name: liveness-prometheus securityContext: privileged: true image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/quay.io/cephcsi/cephcsi:v3.4.0 args: - "--type=liveness" - "--endpoint=$(CSI_ENDPOINT)" - "--metricsport=8681" - "--metricspath=/metrics" - "--polltime=60s" - "--timeout=3s" env: - name: CSI_ENDPOINT value: unix:///csi/csi.sock - name: POD_IP valueFrom: fieldRef: fieldPath: status.podIP volumeMounts: - name: socket-dir mountPath: /csi imagePullPolicy: "IfNotPresent" volumes: - name: socket-dir hostPath: path: /var/lib/kubelet/plugins/cephfs.csi.ceph.com/ type: DirectoryOrCreate - name: registration-dir hostPath: path: /var/lib/kubelet/plugins_registry/ type: Directory - name: mountpoint-dir hostPath: path: /var/lib/kubelet/pods type: DirectoryOrCreate - name: plugin-dir hostPath: path: /var/lib/kubelet/plugins type: Directory - name: host-sys hostPath: path: /sys - name: lib-modules hostPath: path: /lib/modules - name: host-dev hostPath: path: /dev - name: host-mount hostPath: path: /run/mount - name: ceph-csi-config configMap: name: ceph-csi-config - name: keys-tmp-dir emptyDir: { medium: "Memory" } --- # This is a service to expose the liveness metrics apiVersion: v1 kind: Service metadata: name: csi-metrics-cephfsplugin labels: app: csi-metrics spec: ports: - name: http-metrics port: 8080 protocol: TCP targetPort: 8681 selector: app: csi-cephfsplugin #文件名称：csi-config-map.yaml apiVersion: v1 kind: ConfigMap data: config.json: | [ { "clusterID": "c0811c64-a8d4-11f0-904c-000c2907e588", "monitors": [ "192.168.123.122:6789" ] } ] metadata: name: ceph-csi-config #文件名称：csi-nodeplugin-rbac.yaml --- apiVersion: v1 kind: ServiceAccount metadata: name: cephfs-csi-nodeplugin --- kind: ClusterRole apiVersion: rbac.authorization.k8s.io/v1 metadata: name: cephfs-csi-nodeplugin rules: - apiGroups: [""] resources: ["nodes"] verbs: ["get"] --- kind: ClusterRoleBinding apiVersion: rbac.authorization.k8s.io/v1 metadata: name: cephfs-csi-nodeplugin subjects: - kind: ServiceAccount name: cephfs-csi-nodeplugin namespace: default roleRef: kind: ClusterRole name: cephfs-csi-nodeplugin apiGroup: rbac.authorization.k8s.io #文件名称：csi-provisioner-rbac.yaml --- apiVersion: v1 kind: ServiceAccount metadata: name: cephfs-csi-provisioner --- kind: ClusterRole apiVersion: rbac.authorization.k8s.io/v1 metadata: name: cephfs-external-provisioner-runner rules: - apiGroups: [""] resources: ["nodes"] verbs: ["get", "list", "watch"] - apiGroups: [""] resources: ["secrets"] verbs: ["get", "list"] - apiGroups: [""] resources: ["events"] verbs: ["list", "watch", "create", "update", "patch"] - apiGroups: [""] resources: ["persistentvolumes"] verbs: ["get", "list", "watch", "create", "delete", "patch"] - apiGroups: [""] resources: ["persistentvolumeclaims"] verbs: ["get", "list", "watch", "update"] - apiGroups: ["storage.k8s.io"] resources: ["storageclasses"] verbs: ["get", "list", "watch"] - apiGroups: ["snapshot.storage.k8s.io"] resources: ["volumesnapshots"] verbs: ["get", "list"] - apiGroups: ["snapshot.storage.k8s.io"] resources: ["volumesnapshotcontents"] verbs: ["create", "get", "list", "watch", "update", "delete"] - apiGroups: ["snapshot.storage.k8s.io"] resources: ["volumesnapshotclasses"] verbs: ["get", "list", "watch"] - apiGroups: ["storage.k8s.io"] resources: ["volumeattachments"] verbs: ["get", "list", "watch", "update", "patch"] - apiGroups: ["storage.k8s.io"] resources: ["volumeattachments/status"] verbs: ["patch"] - apiGroups: [""] resources: ["persistentvolumeclaims/status"] verbs: ["update", "patch"] - apiGroups: ["storage.k8s.io"] resources: ["csinodes"] verbs: ["get", "list", "watch"] - apiGroups: ["snapshot.storage.k8s.io"] resources: ["volumesnapshotcontents/status"] verbs: ["update"] --- kind: ClusterRoleBinding apiVersion: rbac.authorization.k8s.io/v1 metadata: name: cephfs-csi-provisioner-role subjects: - kind: ServiceAccount name: cephfs-csi-provisioner namespace: default roleRef: kind: ClusterRole name: cephfs-external-provisioner-runner apiGroup: rbac.authorization.k8s.io --- kind: Role apiVersion: rbac.authorization.k8s.io/v1 metadata: # replace with non-default namespace name namespace: default name: cephfs-external-provisioner-cfg rules: # remove this once we stop supporting v1.0.0 - apiGroups: [""] resources: ["configmaps"] verbs: ["get", "list", "create", "delete"] - apiGroups: ["coordination.k8s.io"] resources: ["leases"] verbs: ["get", "watch", "list", "delete", "update", "create"] --- kind: RoleBinding apiVersion: rbac.authorization.k8s.io/v1 metadata: name: cephfs-csi-provisioner-role-cfg # replace with non-default namespace name namespace: default subjects: - kind: ServiceAccount name: cephfs-csi-provisioner # replace with non-default namespace name namespace: default roleRef: kind: Role name: cephfs-external-provisioner-cfg apiGroup: rbac.authorization.k8s.io #文件名称：pvc.yaml --- apiVersion: v1 kind: PersistentVolumeClaim metadata: name: csi-cephfs-pvc spec: accessModes: - ReadWriteMany resources: requests: storage: 1Gi storageClassName: csi-cephfs-sc #文件名称：secret.yaml apiVersion: v1 kind: Secret metadata: name: csi-cephfs-secret namespace: default stringData: userID: admin userKey: AQC2BO5oTBqbGhAAhvKprOh8KOwLx0SMPVgv+w== adminID: admin adminKey: AQC2BO5oTBqbGhAAhvKprOh8KOwLx0SMPVgv+w== #文件名称：storageclass.yaml --- apiVersion: storage.k8s.io/v1 kind: StorageClass metadata: name: csi-cephfs-sc provisioner: cephfs.csi.ceph.com parameters: # (required) String representing a Ceph cluster to provision storage from. # Should be unique across all Ceph clusters in use for provisioning, # cannot be greater than 36 bytes in length, and should remain immutable for # the lifetime of the StorageClass in use. # Ensure to create an entry in the configmap named ceph-csi-config, based on # csi-config-map-sample.yaml, to accompany the string chosen to # represent the Ceph cluster in clusterID below clusterID: c0811c64-a8d4-11f0-904c-000c2907e588 # (required) CephFS filesystem name into which the volume shall be created # eg: fsName: myfs fsName: k8s # (optional) Ceph pool into which volume data shall be stored # pool: <cephfs-data-pool> # (optional) Comma separated string of Ceph-fuse mount options. # For eg: # fuseMountOptions: debug # (optional) Comma separated string of Cephfs kernel mount options. # Check man mount.ceph for mount options. For eg: # kernelMountOptions: readdir_max_bytes=1048576,norbytes # The secrets have to contain user and/or Ceph admin credentials. csi.storage.k8s.io/provisioner-secret-name: csi-cephfs-secret csi.storage.k8s.io/provisioner-secret-namespace: default csi.storage.k8s.io/controller-expand-secret-name: csi-cephfs-secret csi.storage.k8s.io/controller-expand-secret-namespace: default csi.storage.k8s.io/node-stage-secret-name: csi-cephfs-secret csi.storage.k8s.io/node-stage-secret-namespace: default # (optional) The driver can use either ceph-fuse (fuse) or # ceph kernelclient (kernel). # If omitted, default volume mounter will be used - this is # determined by probing for ceph-fuse and mount.ceph # mounter: kernel # (optional) Prefix to use for naming subvolumes. # If omitted, defaults to "csi-vol-". # volumeNamePrefix: "foo-bar-" reclaimPolicy: Delete allowVolumeExpansion: true mountOptions: - discard
#文件名称：csi-config-map.yaml apiVersion: v1 kind: ConfigMap data: config.json: | [ { "clusterID": "c0811c64-a8d4-11f0-904c-000c2907e588", "monitors": [ "192.168.123.122:6789" ] } ] metadata: name: ceph-csi-config namespace: ceph-rbd #文件名称：csidriver.yaml --- # if Kubernetes version is less than 1.18 change # apiVersion to storage.k8s.io/v1beta1 apiVersion: storage.k8s.io/v1 kind: CSIDriver metadata: name: rbd.csi.ceph.com namespace: ceph-rbd spec: attachRequired: true podInfoOnMount: false #文件名称：csi-kms-config-map.yaml --- apiVersion: v1 kind: ConfigMap data: config.json: |- {} metadata: name: ceph-csi-encryption-kms-config namespace: ceph-rbd #文件名称：csi-nodeplugin-rbac.yaml --- apiVersion: v1 kind: ServiceAccount metadata: namespace: ceph-rbd name: rbd-csi-nodeplugin --- kind: ClusterRole apiVersion: rbac.authorization.k8s.io/v1 metadata: namespace: ceph-rbd name: rbd-csi-nodeplugin rules: - apiGroups: [""] resources: ["nodes"] verbs: ["get"] # allow to read Vault Token and connection options from the Tenants namespace - apiGroups: [""] resources: ["secrets"] verbs: ["get"] - apiGroups: [""] resources: ["configmaps"] verbs: ["get"] - apiGroups: [""] resources: ["serviceaccounts"] verbs: ["get"] - apiGroups: [""] resources: ["persistentvolumes"] verbs: ["get"] - apiGroups: ["storage.k8s.io"] resources: ["volumeattachments"] verbs: ["list", "get"] --- kind: ClusterRoleBinding apiVersion: rbac.authorization.k8s.io/v1 metadata: namespace: ceph-rbd name: rbd-csi-nodeplugin subjects: - kind: ServiceAccount name: rbd-csi-nodeplugin namespace: ceph-rbd roleRef: kind: ClusterRole name: rbd-csi-nodeplugin apiGroup: rbac.authorization.k8s.io #文件名称：csi-provisioner-rbac.yaml --- apiVersion: v1 kind: ServiceAccount metadata: namespace: ceph-rbd name: rbd-csi-provisioner --- kind: ClusterRole apiVersion: rbac.authorization.k8s.io/v1 metadata: namespace: ceph-rbd name: rbd-external-provisioner-runner rules: - apiGroups: [""] resources: ["nodes"] verbs: ["get", "list", "watch"] - apiGroups: [""] resources: ["secrets"] verbs: ["get", "list", "watch"] - apiGroups: [""] resources: ["events"] verbs: ["list", "watch", "create", "update", "patch"] - apiGroups: [""] resources: ["persistentvolumes"] verbs: ["get", "list", "watch", "create", "update", "delete", "patch"] - apiGroups: [""] resources: ["persistentvolumeclaims"] verbs: ["get", "list", "watch", "update"] - apiGroups: [""] resources: ["persistentvolumeclaims/status"] verbs: ["update", "patch"] - apiGroups: ["storage.k8s.io"] resources: ["storageclasses"] verbs: ["get", "list", "watch"] - apiGroups: ["snapshot.storage.k8s.io"] resources: ["volumesnapshots"] verbs: ["get", "list"] - apiGroups: ["snapshot.storage.k8s.io"] resources: ["volumesnapshotcontents"] verbs: ["create", "get", "list", "watch", "update", "delete"] - apiGroups: ["snapshot.storage.k8s.io"] resources: ["volumesnapshotclasses"] verbs: ["get", "list", "watch"] - apiGroups: ["storage.k8s.io"] resources: ["volumeattachments"] verbs: ["get", "list", "watch", "update", "patch"] - apiGroups: ["storage.k8s.io"] resources: ["volumeattachments/status"] verbs: ["patch"] - apiGroups: ["storage.k8s.io"] resources: ["csinodes"] verbs: ["get", "list", "watch"] - apiGroups: ["snapshot.storage.k8s.io"] resources: ["volumesnapshotcontents/status"] verbs: ["update"] - apiGroups: [""] resources: ["configmaps"] verbs: ["get"] - apiGroups: [""] resources: ["serviceaccounts"] verbs: ["get"] --- kind: ClusterRoleBinding apiVersion: rbac.authorization.k8s.io/v1 metadata: namespace: ceph-rbd name: rbd-csi-provisioner-role subjects: - kind: ServiceAccount name: rbd-csi-provisioner namespace: ceph-rbd roleRef: kind: ClusterRole name: rbd-external-provisioner-runner apiGroup: rbac.authorization.k8s.io --- kind: Role apiVersion: rbac.authorization.k8s.io/v1 metadata: # replace with non-default namespace name namespace: ceph-rbd name: rbd-external-provisioner-cfg rules: - apiGroups: [""] resources: ["configmaps"] verbs: ["get", "list", "watch", "create", "update", "delete"] - apiGroups: ["coordination.k8s.io"] resources: ["leases"] verbs: ["get", "watch", "list", "delete", "update", "create"] --- kind: RoleBinding apiVersion: rbac.authorization.k8s.io/v1 metadata: name: rbd-csi-provisioner-role-cfg # replace with non-default namespace name namespace: ceph-rbd subjects: - kind: ServiceAccount name: rbd-csi-provisioner # replace with non-default namespace name namespace: ceph-rbd roleRef: kind: Role name: rbd-external-provisioner-cfg apiGroup: rbac.authorization.k8s.io #文件名称：csi-rbdplugin-provisioner.yaml --- kind: Service apiVersion: v1 metadata: name: csi-rbdplugin-provisioner namespace: ceph-rbd labels: app: csi-metrics spec: selector: app: csi-rbdplugin-provisioner ports: - name: http-metrics port: 8080 protocol: TCP targetPort: 8680 --- kind: Deployment apiVersion: apps/v1 metadata: namespace: ceph-rbd name: csi-rbdplugin-provisioner spec: replicas: 3 selector: matchLabels: app: csi-rbdplugin-provisioner template: metadata: labels: app: csi-rbdplugin-provisioner spec: affinity: podAntiAffinity: requiredDuringSchedulingIgnoredDuringExecution: - labelSelector: matchExpressions: - key: app operator: In values: - csi-rbdplugin-provisioner topologyKey: "kubernetes.io/hostname" serviceAccountName: rbd-csi-provisioner priorityClassName: system-cluster-critical containers: - name: csi-provisioner image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/k8s.gcr.io/sig-storage/csi-provisioner:v2.2.2 args: - "--csi-address=$(ADDRESS)" - "--v=5" - "--timeout=150s" - "--retry-interval-start=500ms" - "--leader-election=true" # set it to true to use topology based provisioning - "--feature-gates=Topology=false" # if fstype is not specified in storageclass, ext4 is default - "--default-fstype=ext4" - "--extra-create-metadata=true" env: - name: ADDRESS value: unix:///csi/csi-provisioner.sock imagePullPolicy: "IfNotPresent" volumeMounts: - name: socket-dir mountPath: /csi - name: csi-snapshotter image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/k8s.gcr.io/sig-storage/csi-snapshotter:v4.1.1 args: - "--csi-address=$(ADDRESS)" - "--v=5" - "--timeout=150s" - "--leader-election=true" env: - name: ADDRESS value: unix:///csi/csi-provisioner.sock imagePullPolicy: "IfNotPresent" securityContext: privileged: true volumeMounts: - name: socket-dir mountPath: /csi - name: csi-attacher image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/k8s.gcr.io/sig-storage/csi-attacher:v3.2.1 args: - "--v=5" - "--csi-address=$(ADDRESS)" - "--leader-election=true" - "--retry-interval-start=500ms" env: - name: ADDRESS value: /csi/csi-provisioner.sock imagePullPolicy: "IfNotPresent" volumeMounts: - name: socket-dir mountPath: /csi - name: csi-resizer image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/k8s.gcr.io/sig-storage/csi-resizer:v1.2.0 args: - "--csi-address=$(ADDRESS)" - "--v=5" - "--timeout=150s" - "--leader-election" - "--retry-interval-start=500ms" - "--handle-volume-inuse-error=false" env: - name: ADDRESS value: unix:///csi/csi-provisioner.sock imagePullPolicy: "IfNotPresent" volumeMounts: - name: socket-dir mountPath: /csi - name: csi-rbdplugin securityContext: privileged: true capabilities: add: ["SYS_ADMIN"] # for stable functionality replace canary with latest release version image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/quay.io/cephcsi/cephcsi:v3.4.0 args: - "--nodeid=$(NODE_ID)" - "--type=rbd" - "--controllerserver=true" - "--endpoint=$(CSI_ENDPOINT)" - "--v=5" - "--drivername=rbd.csi.ceph.com" - "--pidlimit=-1" - "--rbdhardmaxclonedepth=8" - "--rbdsoftmaxclonedepth=4" - "--enableprofiling=false" env: - name: POD_IP valueFrom: fieldRef: fieldPath: status.podIP - name: NODE_ID valueFrom: fieldRef: fieldPath: spec.nodeName # - name: POD_NAMESPACE # valueFrom: # fieldRef: # fieldPath: spec.namespace # - name: KMS_CONFIGMAP_NAME # value: encryptionConfig - name: CSI_ENDPOINT value: unix:///csi/csi-provisioner.sock imagePullPolicy: "IfNotPresent" volumeMounts: - name: socket-dir mountPath: /csi - mountPath: /dev name: host-dev - mountPath: /sys name: host-sys - mountPath: /lib/modules name: lib-modules readOnly: true - name: ceph-csi-config mountPath: /etc/ceph-csi-config/ - name: ceph-csi-encryption-kms-config mountPath: /etc/ceph-csi-encryption-kms-config/ - name: keys-tmp-dir mountPath: /tmp/csi/keys - name: csi-rbdplugin-controller securityContext: privileged: true capabilities: add: ["SYS_ADMIN"] # for stable functionality replace canary with latest release version image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/quay.io/cephcsi/cephcsi:v3.4.0 args: - "--type=controller" - "--v=5" - "--drivername=rbd.csi.ceph.com" - "--drivernamespace=$(DRIVER_NAMESPACE)" env: - name: DRIVER_NAMESPACE valueFrom: fieldRef: fieldPath: metadata.namespace imagePullPolicy: "IfNotPresent" volumeMounts: - name: ceph-csi-config mountPath: /etc/ceph-csi-config/ - name: keys-tmp-dir mountPath: /tmp/csi/keys - name: liveness-prometheus image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/quay.io/cephcsi/cephcsi:v3.4.0 args: - "--type=liveness" - "--endpoint=$(CSI_ENDPOINT)" - "--metricsport=8680" - "--metricspath=/metrics" - "--polltime=60s" - "--timeout=3s" env: - name: CSI_ENDPOINT value: unix:///csi/csi-provisioner.sock - name: POD_IP valueFrom: fieldRef: fieldPath: status.podIP volumeMounts: - name: socket-dir mountPath: /csi imagePullPolicy: "IfNotPresent" volumes: - name: host-dev hostPath: path: /dev - name: host-sys hostPath: path: /sys - name: lib-modules hostPath: path: /lib/modules - name: socket-dir emptyDir: { medium: "Memory" } - name: ceph-csi-config configMap: name: ceph-csi-config - name: ceph-csi-encryption-kms-config configMap: name: ceph-csi-encryption-kms-config - name: keys-tmp-dir emptyDir: { medium: "Memory" } #文件名称：csi-rbdplugin.yaml --- kind: DaemonSet apiVersion: apps/v1 metadata: namespace: ceph-rbd name: csi-rbdplugin spec: selector: matchLabels: app: csi-rbdplugin template: metadata: labels: app: csi-rbdplugin spec: serviceAccountName: rbd-csi-nodeplugin hostNetwork: true hostPID: true priorityClassName: system-node-critical # to use e.g. Rook orchestrated cluster, and mons' FQDN is # resolved through k8s service, set dns policy to cluster first dnsPolicy: ClusterFirstWithHostNet containers: - name: driver-registrar # This is necessary only for systems with SELinux, where # non-privileged sidecar containers cannot access unix domain socket # created by privileged CSI driver container. securityContext: privileged: true image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/registry.k8s.io/sig-storage/csi-node-driver-registrar:v2.2.0 args: - "--v=5" - "--csi-address=/csi/csi.sock" - "--kubelet-registration-path=/var/lib/kubelet/plugins/rbd.csi.ceph.com/csi.sock" env: - name: KUBE_NODE_NAME valueFrom: fieldRef: fieldPath: spec.nodeName volumeMounts: - name: socket-dir mountPath: /csi - name: registration-dir mountPath: /registration - name: csi-rbdplugin securityContext: privileged: true capabilities: add: ["SYS_ADMIN"] allowPrivilegeEscalation: true # for stable functionality replace canary with latest release version image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/quay.io/cephcsi/cephcsi:v3.4.0 args: - "--nodeid=$(NODE_ID)" - "--pluginpath=/var/lib/kubelet/plugins" - "--stagingpath=/var/lib/kubelet/plugins/kubernetes.io/csi/pv/" - "--type=rbd" - "--nodeserver=true" - "--endpoint=$(CSI_ENDPOINT)" - "--v=5" - "--drivername=rbd.csi.ceph.com" - "--enableprofiling=false" # If topology based provisioning is desired, configure required # node labels representing the nodes topology domain # and pass the label names below, for CSI to consume and advertise # its equivalent topology domain # - "--domainlabels=failure-domain/region,failure-domain/zone" env: - name: POD_IP valueFrom: fieldRef: fieldPath: status.podIP - name: NODE_ID valueFrom: fieldRef: fieldPath: spec.nodeName # - name: POD_NAMESPACE # valueFrom: # fieldRef: # fieldPath: spec.namespace # - name: KMS_CONFIGMAP_NAME # value: encryptionConfig - name: CSI_ENDPOINT value: unix:///csi/csi.sock imagePullPolicy: "IfNotPresent" volumeMounts: - name: socket-dir mountPath: /csi - mountPath: /dev name: host-dev - mountPath: /sys name: host-sys - mountPath: /run/mount name: host-mount - mountPath: /lib/modules name: lib-modules readOnly: true - name: ceph-csi-config mountPath: /etc/ceph-csi-config/ - name: ceph-csi-encryption-kms-config mountPath: /etc/ceph-csi-encryption-kms-config/ - name: plugin-dir mountPath: /var/lib/kubelet/plugins mountPropagation: "Bidirectional" - name: mountpoint-dir mountPath: /var/lib/kubelet/pods mountPropagation: "Bidirectional" - name: keys-tmp-dir mountPath: /tmp/csi/keys - name: liveness-prometheus securityContext: privileged: true image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/quay.io/cephcsi/cephcsi:v3.4.0 args: - "--type=liveness" - "--endpoint=$(CSI_ENDPOINT)" - "--metricsport=8680" - "--metricspath=/metrics" - "--polltime=60s" - "--timeout=3s" env: - name: CSI_ENDPOINT value: unix:///csi/csi.sock - name: POD_IP valueFrom: fieldRef: fieldPath: status.podIP volumeMounts: - name: socket-dir mountPath: /csi imagePullPolicy: "IfNotPresent" volumes: - name: socket-dir hostPath: path: /var/lib/kubelet/plugins/rbd.csi.ceph.com type: DirectoryOrCreate - name: plugin-dir hostPath: path: /var/lib/kubelet/plugins type: Directory - name: mountpoint-dir hostPath: path: /var/lib/kubelet/pods type: DirectoryOrCreate - name: registration-dir hostPath: path: /var/lib/kubelet/plugins_registry/ type: Directory - name: host-dev hostPath: path: /dev - name: host-sys hostPath: path: /sys - name: host-mount hostPath: path: /run/mount - name: lib-modules hostPath: path: /lib/modules - name: ceph-csi-config configMap: name: ceph-csi-config - name: ceph-csi-encryption-kms-config configMap: name: ceph-csi-encryption-kms-config - name: keys-tmp-dir emptyDir: { medium: "Memory" } --- # This is a service to expose the liveness metrics apiVersion: v1 kind: Service metadata: name: csi-metrics-rbdplugin namespace: ceph-rbd labels: app: csi-metrics spec: ports: - name: http-metrics port: 8080 protocol: TCP targetPort: 8680 selector: app: csi-rbdplugin #文件名称：pvc.yaml apiVersion: v1 kind: PersistentVolumeClaim metadata: namespace: ceph-rbd name: csi-ceph-rbd-pvc spec: accessModes: - ReadWriteMany volumeMode: Block resources: requests: storage: 2Gi storageClassName: csi-rbd-rbd #文件名称：secret.yaml --- apiVersion: v1 kind: Secret metadata: name: csi-rbd-secret namespace: ceph-rbd stringData: # Key values correspond to a user name and its key, as defined in the # ceph cluster. User ID should have required access to the 'pool' # specified in the storage class userID: admin userKey: AQC2BO5oTBqbGhAAhvKprOh8KOwLx0SMPVgv+w== # Encryption passphrase encryptionPassphrase: test_passphrase #文件名称：storageclass.yaml --- apiVersion: storage.k8s.io/v1 kind: StorageClass metadata: name: csi-rbd-rbd namespace: ceph-rbd provisioner: rbd.csi.ceph.com # If topology based provisioning is desired, delayed provisioning of # PV is required and is enabled using the following attribute # For further information read TODO<doc> # volumeBindingMode: WaitForFirstConsumer parameters: # (required) String representing a Ceph cluster to provision storage from. # Should be unique across all Ceph clusters in use for provisioning, # cannot be greater than 36 bytes in length, and should remain immutable for # the lifetime of the StorageClass in use. # Ensure to create an entry in the configmap named ceph-csi-config, based on # csi-config-map-sample.yaml, to accompany the string chosen to # represent the Ceph cluster in clusterID below clusterID: c0811c64-a8d4-11f0-904c-000c2907e588 # (optional) If you want to use erasure coded pool with RBD, you need to # create two pools. one erasure coded and one replicated. # You need to specify the replicated pool here in the `pool` parameter, it is # used for the metadata of the images. # The erasure coded pool must be set as the `dataPool` parameter below. # dataPool: <ec-data-pool> # (required) Ceph pool into which the RBD image shall be created # eg: pool: rbdpool pool: rbd_data # Set thickProvision to true if you want RBD images to be fully allocated on # creation (thin provisioning is the default). thickProvision: "false" # (required) RBD image features, CSI creates image with image-format 2 # CSI RBD currently supports `layering`, `journaling`, `exclusive-lock` # features. If `journaling` is enabled, must enable `exclusive-lock` too. # imageFeatures: layering,journaling,exclusive-lock imageFeatures: layering # (optional) mapOptions is a comma-separated list of map options. # For krbd options refer # https://docs.ceph.com/docs/master/man/8/rbd/#kernel-rbd-krbd-options # For nbd options refer # https://docs.ceph.com/docs/master/man/8/rbd-nbd/#options # mapOptions: lock_on_read,queue_depth=1024 # (optional) unmapOptions is a comma-separated list of unmap options. # For krbd options refer # https://docs.ceph.com/docs/master/man/8/rbd/#kernel-rbd-krbd-options # For nbd options refer # https://docs.ceph.com/docs/master/man/8/rbd-nbd/#options # unmapOptions: force # The secrets have to contain Ceph credentials with required access # to the 'pool'. csi.storage.k8s.io/provisioner-secret-name: csi-rbd-secret csi.storage.k8s.io/provisioner-secret-namespace: ceph-rbd csi.storage.k8s.io/controller-expand-secret-name: csi-rbd-secret csi.storage.k8s.io/controller-expand-secret-namespace: ceph-rbd csi.storage.k8s.io/node-stage-secret-name: csi-rbd-secret csi.storage.k8s.io/node-stage-secret-namespace: ceph-rbd # (optional) Specify the filesystem type of the volume. If not specified, # csi-provisioner will set default as `ext4`. csi.storage.k8s.io/fstype: ext4 # (optional) uncomment the following to use rbd-nbd as mounter # on supported nodes # mounter: rbd-nbd # (optional) Prefix to use for naming RBD images. # If omitted, defaults to "csi-vol-". # volumeNamePrefix: "foo-bar-" # (optional) Instruct the plugin it has to encrypt the volume # By default it is disabled. Valid values are "true" or "false". # A string is expected here, i.e. "true", not true. # encrypted: "true" # (optional) Use external key management system for encryption passphrases by # specifying a unique ID matching KMS ConfigMap. The ID is only used for # correlation to configmap entry. # encryptionKMSID: <kms-config-id> # Add topology constrained pools configuration, if topology based pools # are setup, and topology constrained provisioning is required. # For further information read TODO<doc> # topologyConstrainedPools: | # [{"poolName":"pool0", # "dataPool":"ec-pool0" # optional, erasure-coded pool for data # "domainSegments":[ # {"domainLabel":"region","value":"east"}, # {"domainLabel":"zone","value":"zone1"}]}, # {"poolName":"pool1", # "dataPool":"ec-pool1" # optional, erasure-coded pool for data # "domainSegments":[ # {"domainLabel":"region","value":"east"}, # {"domainLabel":"zone","value":"zone2"}]}, # {"poolName":"pool2", # "dataPool":"ec-pool2" # optional, erasure-coded pool for data # "domainSegments":[ # {"domainLabel":"region","value":"west"}, # {"domainLabel":"zone","value":"zone1"}]} # ] reclaimPolicy: Delete allowVolumeExpansion: true mountOptions: - discard
18、污点配置
# 查看当前污点状态 [root@k8s-master01 ~]# kubectl describe node | grep Taints Taints: <none> Taints: <none> Taints: <none> Taints: <none> Taints: <none> # 设置污点 禁止调度 同时进行驱赶现有的POD kubectl taint nodes k8s-master01 key1=value1:NoExecute kubectl taint nodes k8s-master02 key1=value1:NoExecute kubectl taint nodes k8s-master03 key1=value1:NoExecute # 取消污点 kubectl taint nodes k8s-master01 key1=value1:NoExecute- kubectl taint nodes k8s-master02 key1=value1:NoExecute- kubectl taint nodes k8s-master03 key1=value1:NoExecute- # 设置污点 禁止调度 不进行驱赶现有的POD kubectl taint nodes k8s-master01 key1=value1:NoSchedule kubectl taint nodes k8s-master02 key1=value1:NoSchedule kubectl taint nodes k8s-master03 key1=value1:NoSchedule # 取消污点 kubectl taint nodes k8s-master01 key1=value1:NoSchedule- kubectl taint nodes k8s-master02 key1=value1:NoSchedule- kubectl taint nodes k8s-master03 key1=value1:NoSchedule- ## 配置node ROLES kubectl label nodes k8s-master01 node-role.kubernetes.io/control-plane= kubectl label nodes k8s-master02 node-role.kubernetes.io/control-plane= kubectl label nodes k8s-master03 node-role.kubernetes.io/control-plane= kubectl label nodes k8s-node01 node-role.kubernetes.io/worker= kubectl label nodes k8s-node02 node-role.kubernetes.io/worker= [root@k8s-master01 ingress-nginx]# kubectl get nodes NAME STATUS ROLES AGE VERSION k8s-master01 Ready control-plane 138m v1.34.0 k8s-master02 Ready control-plane 138m v1.34.0 k8s-master03 Ready control-plane 138m v1.34.0 k8s-node01 Ready worker 138m v1.34.0 k8s-node02 Ready worker 135m v1.34.0 ## 删除role标签 kubectl label nodes k8s-master01 node-role.kubernetes.io/control-plane- kubectl label nodes k8s-master02 node-role.kubernetes.io/control-plane- kubectl label nodes k8s-master03 node-role.kubernetes.io/control-plane- kubectl label nodes k8s-node01 node-role.kubernetes.io/worker- kubectl label nodes k8s-node02 node-role.kubernetes.io/worker-
19、安装命令行自动补全功能
yum install bash-completion -y source /usr/share/bash-completion/bash_completion source <(kubectl completion bash) ## echo "source <(kubectl completion bash)" >> ~/.bashrc
20、本地镜像仓库方案（harbor）、日志解决方案（Loki）、k8s集群监控方案（Prometheus）
参考链接：
https://chuna2.787528.xyz/junnan/p/18974073
https://chuna2.787528.xyz/junnan/p/19002916
https://www.bilibili.com/video/BV1PbeueyE8V/?share_source=copy_web&vd_source=b968fc5b8e2d8f26be216bcfbe97da1f
附录
## 安装完成后主机网络信息记录： [root@k8s-master01 ~]# ip a 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group defa ult qlen 1000 link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00 inet 127.0.0.1/8 scope host lo valid_lft forever preferred_lft forever inet6 ::1/128 scope host noprefixroute valid_lft forever preferred_lft forever 2: tunl0@NONE: <NOARP,UP,LOWER_UP> mtu 1480 qdisc noqueue state UNKNOWN group default qlen 1000 link/ipip 0.0.0.0 brd 0.0.0.0 inet 172.25.244.192/32 scope global tunl0 valid_lft forever preferred_lft forever 3: ens160: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000 link/ether 00:0c:29:47:2b:21 brd ff:ff:ff:ff:ff:ff altname enp3s0 altname enx000c29472b21 inet 192.168.123.111/24 brd 192.168.123.255 scope global noprefixroute ens 160 valid_lft forever preferred_lft forever inet6 fc00::31/8 scope global noprefixroute valid_lft forever preferred_lft forever inet6 fc00::20c:29ff:fe47:2b21/64 scope global dynamic noprefixroute valid_lft 86400sec preferred_lft 14400sec inet6 fe80::20c:29ff:fe47:2b21/64 scope link noprefixroute valid_lft forever preferred_lft forever 4: kube-ipvs0: <BROADCAST,NOARP> mtu 1500 qdisc noop state DOWN group default link/ether e2:1d:03:d1:b4:74 brd ff:ff:ff:ff:ff:ff inet 10.104.240.234/32 scope global kube-ipvs0 valid_lft forever preferred_lft forever inet 10.97.210.61/32 scope global kube-ipvs0 valid_lft forever preferred_lft forever inet 10.96.0.1/32 scope global kube-ipvs0 valid_lft forever preferred_lft forever inet 10.107.175.9/32 scope global kube-ipvs0 valid_lft forever preferred_lft forever inet 10.108.208.192/32 scope global kube-ipvs0 valid_lft forever preferred_lft forever inet 10.96.0.10/32 scope global kube-ipvs0 valid_lft forever preferred_lft forever inet 10.105.213.193/32 scope global kube-ipvs0 valid_lft forever preferred_lft forever inet 10.111.228.214/32 scope global kube-ipvs0 valid_lft forever preferred_lft forever inet 10.99.164.116/32 scope global kube-ipvs0 valid_lft forever preferred_lft forever inet 10.106.86.177/32 scope global kube-ipvs0 valid_lft forever preferred_lft forever inet 192.168.123.71/32 scope global kube-ipvs0 valid_lft forever preferred_lft forever 5: docker0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state D OWN group default link/ether 3a:1b:9a:2f:99:27 brd ff:ff:ff:ff:ff:ff inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0 valid_lft forever preferred_lft forever 6: calicf8c8fa86c5@if3: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1480 qdisc noque ue state UP group default qlen 1000 link/ether ee:ee:ee:ee:ee:ee brd ff:ff:ff:ff:ff:ff link-netnsid 0 inet6 fe80::ecee:eeff:feee:eeee/64 scope link proto kernel_ll valid_lft forever preferred_lft forever 7: calice7f1cb4efa@if3: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1480 qdisc noque ue state UP group default qlen 1000 link/ether ee:ee:ee:ee:ee:ee brd ff:ff:ff:ff:ff:ff link-netnsid 1 inet6 fe80::ecee:eeff:feee:eeee/64 scope link proto kernel_ll valid_lft forever preferred_lft forever 8: caliecac830d60e@if3: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1480 qdisc noque ue state UP group default qlen 1000 link/ether ee:ee:ee:ee:ee:ee brd ff:ff:ff:ff:ff:ff link-netnsid 2 inet6 fe80::ecee:eeff:feee:eeee/64 scope link proto kernel_ll valid_lft forever preferred_lft forever 9: calia086d568cbb@if3: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1480 qdisc noque ue state UP group default qlen 1000 link/ether ee:ee:ee:ee:ee:ee brd ff:ff:ff:ff:ff:ff link-netnsid 3 inet6 fe80::ecee:eeff:feee:eeee/64 scope link proto kernel_ll valid_lft forever preferred_lft forever 10: calidd7d97192e3@if3: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1480 qdisc noqu eue state UP group default qlen 1000 link/ether ee:ee:ee:ee:ee:ee brd ff:ff:ff:ff:ff:ff link-netnsid 4 inet6 fe80::ecee:eeff:feee:eeee/64 scope link proto kernel_ll valid_lft forever preferred_lft forever 11: calif00bd313fa7@if3: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1480 qdisc noqu eue state UP group default qlen 1000 link/ether ee:ee:ee:ee:ee:ee brd ff:ff:ff:ff:ff:ff link-netnsid 5 inet6 fe80::ecee:eeff:feee:eeee/64 scope link proto kernel_ll valid_lft forever preferred_lft forever [root@k8s-master01 ~]# ipvsadm -Ln IP Virtual Server version 1.2.1 (size=4096) Prot LocalAddress:Port Scheduler Flags -> RemoteAddress:Port Forward Weight ActiveConn InActConn TCP 172.17.0.1:31465 rr -> 172.17.125.11:443 Masq 1 0 0 TCP 172.17.0.1:32428 rr -> 172.17.125.11:80 Masq 1 0 0 TCP 172.25.244.192:31465 rr -> 172.17.125.11:443 Masq 1 0 0 TCP 172.25.244.192:32428 rr -> 172.17.125.11:80 Masq 1 0 0 TCP 192.168.123.71:80 rr -> 172.17.125.11:80 Masq 1 0 0 TCP 192.168.123.71:443 rr -> 172.17.125.11:443 Masq 1 0 0 TCP 192.168.123.111:31465 rr -> 172.17.125.11:443 Masq 1 0 0 TCP 192.168.123.111:32428 rr -> 172.17.125.11:80 Masq 1 0 0 TCP 10.96.0.1:443 rr -> 192.168.123.111:6443 Masq 1 5 0 -> 192.168.123.112:6443 Masq 1 0 0 -> 192.168.123.113:6443 Masq 1 1 0 TCP 10.96.0.10:53 rr -> 172.25.92.71:53 Masq 1 0 0 TCP 10.97.210.61:8081 rr -> 172.25.244.214:8081 Masq 1 0 0 TCP 10.99.164.116:443 rr -> 172.17.125.11:8443 Masq 1 0 0 TCP 10.104.240.234:7443 rr -> 172.25.244.210:7443 Masq 1 1 0 TCP 10.105.213.193:443 rr -> 172.25.92.72:10250 Masq 1 0 0 TCP 10.106.86.177:80 rr -> 172.17.125.11:80 Masq 1 0 0 TCP 10.106.86.177:443 rr -> 172.17.125.11:443 Masq 1 0 0 TCP 10.107.175.9:443 rr -> 172.25.244.211:5443 Masq 1 0 0 -> 172.25.244.213:5443 Masq 1 0 0 TCP 10.108.208.192:5473 rr -> 192.168.123.113:5473 Masq 1 0 0 -> 192.168.123.114:5473 Masq 1 0 0 -> 192.168.123.115:5473 Masq 1 0 0 TCP 10.111.228.214:443 rr -> 172.18.195.10:9443 Masq 1 0 0 UDP 10.96.0.10:53 rr -> 172.25.92.71:53 Masq 1 0 0 [root@k8s-master01 ~]# kubectl get leases -n kube-system NAME HOLDER AGE apiserver-6z5gcnzqagv5p4h6bccr6hje2m apiserver-6z5gcnzqagv5p4h6bccr6hje2m_f5b03f2b-2e38-46e7-b4cd-ccee946466e1 3h36m apiserver-hk4fzhyjdo2ayc5o2blltmf4pe apiserver-hk4fzhyjdo2ayc5o2blltmf4pe_2d7a16ce-164c-4d3f-829a-416b4f4a44d1 3h36m apiserver-l3o2wb47zcu4wv6xcvcptpja54 apiserver-l3o2wb47zcu4wv6xcvcptpja54_996b6bcb-6116-4744-b1ed-11865c7c067c 3h36m kube-controller-manager k8s-master01_f967b3a8-5e51-4cfb-ac40-0eb88f0d1f86 3h30m kube-scheduler k8s-master01_ad690693-34e5-4e80-924c-fc51dd5baeff
## docker导出所有镜像进行备份迁移 for i in $(docker images | grep -v TAG | awk '{print $1":"$2}'); do docker save -o "${i//\//_}.tar" $i; done
虚机问题1： 网络状态不对时，重启VMware workstation的如图两个网络服务，并重启VM的网卡。
问题2：VMware workstation开启ipv6支持
浙公网安备 33010602011771号