二進位制安裝Kubernetes（k8s）v1.28.3

https://github.com/cby-chen/Kubernetes 開源不易，幫忙點個star，謝謝了

介紹

kubernetes（k8s）二進位制高可用安裝部署，支援IPv4+IPv6雙棧。

我使用IPV6的目的是在公網進行存取，所以我設定了IPV6靜態地址。

若您沒有IPV6環境，或者不想使用IPv6，不對主機進行設定IPv6地址即可。

不設定IPV6，不影響後續，不過叢集依舊是支援IPv6的。為後期留有擴充套件可能性。

若不要IPv6 ，不給網路卡設定IPv6即可，不要對IPv6相關設定刪除或操作，否則會出問題。

強烈建議在Github上檢視檔案 ！！！

Github出問題會更新檔案，並且後續儘可能第一時間更新新版本檔案 ！！！

手動專案地址：https://github.com/cby-chen/Kubernetes

1.環境

主機名稱	IP地址	說明	軟體
	192.168.1.60	外網節點	下載各種所需安裝包
Master01	192.168.1.31	master節點	kube-apiserver、kube-controller-manager、kube-scheduler、etcd、 kubelet、kube-proxy、nfs-client、haproxy、keepalived、nginx
Master02	192.168.1.32	master節點	kube-apiserver、kube-controller-manager、kube-scheduler、etcd、 kubelet、kube-proxy、nfs-client、haproxy、keepalived、nginx
Master03	192.168.1.33	master節點	kube-apiserver、kube-controller-manager、kube-scheduler、etcd、 kubelet、kube-proxy、nfs-client、haproxy、keepalived、nginx
Node01	192.168.1.34	node節點	kubelet、kube-proxy、nfs-client、nginx
Node02	192.168.1.35	node節點	kubelet、kube-proxy、nfs-client、nginx
	192.168.1.36	VIP

網段
物理主機：192.168.1.0/24
service：10.96.0.0/12
pod：172.16.0.0/12

安裝包已經整理好：https://ghproxy.com/https://github.com/cby-chen/Kubernetes/releases/download/v1.28.3/kubernetes-v1.28.3.tar

1.1.k8s基礎系統環境設定

1.2.設定IP

# 注意！
# 若虛擬機器器是進行克隆的那麼網路卡的UUID會重複
# 若UUID重複需要重新生成新的UUID
# UUID重複無法獲取到IPV6地址
# 
# 檢視當前的網路卡列表和 UUID：
# nmcli con show
# 刪除要更改 UUID 的網路連線：
# nmcli con delete uuid <原 UUID>
# 重新生成 UUID：
# nmcli con add type ethernet ifname <介面名稱> con-name <新名稱>
# 重新啟用網路連線：
# nmcli con up <新名稱>

# 更改網路卡的UUID
ssh [email protected] "nmcli con delete uuid 708a1497-2192-43a5-9f03-2ab936fb3c44;nmcli con add type ethernet ifname eth0 con-name eth0;nmcli con up eth0"
ssh [email protected] "nmcli con delete uuid 708a1497-2192-43a5-9f03-2ab936fb3c44;nmcli con add type ethernet ifname eth0 con-name eth0;nmcli con up eth0"
ssh [email protected] "nmcli con delete uuid 708a1497-2192-43a5-9f03-2ab936fb3c44;nmcli con add type ethernet ifname eth0 con-name eth0;nmcli con up eth0"
ssh [email protected] "nmcli con delete uuid 708a1497-2192-43a5-9f03-2ab936fb3c44;nmcli con add type ethernet ifname eth0 con-name eth0;nmcli con up eth0"
ssh [email protected] "nmcli con delete uuid 708a1497-2192-43a5-9f03-2ab936fb3c44;nmcli con add type ethernet ifname eth0 con-name eth0;nmcli con up eth0"

# 引數解釋
# 
# ssh ssh [email protected]
# 使用SSH登入到IP為192.168.1.31的主機，使用root使用者身份。
# 
# nmcli con delete uuid 708a1497-2192-43a5-9f03-2ab936fb3c44
# 刪除 UUID 為 708a1497-2192-43a5-9f03-2ab936fb3c44 的網路連線，這是 NetworkManager 中一種特定網路設定的唯一識別符號。
# 
# nmcli con add type ethernet ifname eth0 con-name eth0
# 新增一種乙太網連線型別，並指定介面名為 eth0，連線名稱也為 eth0。
# 
# nmcli con up eth0
# 開啟 eth0 這個網路連線。
# 
# 簡單來說，這個命令的作用是刪除一個特定的網路連線設定，並新增一個名為 eth0 的乙太網連線，然後啟用這個新的連線。

# 修改靜態的IPv4地址
ssh [email protected] "nmcli con mod eth0 ipv4.addresses 192.168.1.31/24; nmcli con mod eth0 ipv4.gateway  192.168.1.1; nmcli con mod eth0 ipv4.method manual; nmcli con mod eth0 ipv4.dns "8.8.8.8"; nmcli con up eth0"
ssh [email protected] "nmcli con mod eth0 ipv4.addresses 192.168.1.32/24; nmcli con mod eth0 ipv4.gateway  192.168.1.1; nmcli con mod eth0 ipv4.method manual; nmcli con mod eth0 ipv4.dns "8.8.8.8"; nmcli con up eth0"
ssh [email protected] "nmcli con mod eth0 ipv4.addresses 192.168.1.33/24; nmcli con mod eth0 ipv4.gateway  192.168.1.1; nmcli con mod eth0 ipv4.method manual; nmcli con mod eth0 ipv4.dns "8.8.8.8"; nmcli con up eth0"
ssh [email protected] "nmcli con mod eth0 ipv4.addresses 192.168.1.34/24; nmcli con mod eth0 ipv4.gateway  192.168.1.1; nmcli con mod eth0 ipv4.method manual; nmcli con mod eth0 ipv4.dns "8.8.8.8"; nmcli con up eth0"
ssh [email protected] "nmcli con mod eth0 ipv4.addresses 192.168.1.35/24; nmcli con mod eth0 ipv4.gateway  192.168.1.1; nmcli con mod eth0 ipv4.method manual; nmcli con mod eth0 ipv4.dns "8.8.8.8"; nmcli con up eth0"



nmcli con mod eth0 ipv4.gateway 192.168.1.200; nmcli con mod eth0 ipv4.method manual; nmcli con mod eth0 ipv4.dns "223.5.5.5"; nmcli con up eth0
# 引數解釋
# 
# ssh [email protected]
# 使用SSH登入到IP為192.168.1.154的主機，使用root使用者身份。
# 
# "nmcli con mod eth0 ipv4.addresses 192.168.1.31/24"
# 修改eth0網路連線的IPv4地址為192.168.1.31，子網掩碼為 24。
# 
# "nmcli con mod eth0 ipv4.gateway 192.168.1.1"
# 修改eth0網路連線的IPv4閘道器為192.168.1.1。
# 
# "nmcli con mod eth0 ipv4.method manual"
# 將eth0網路連線的IPv4設定方法設定為手動。
# 
# "nmcli con mod eth0 ipv4.dns "8.8.8.8"
# 將eth0網路連線的IPv4 DNS伺服器設定為 8.8.8.8。
# 
# "nmcli con up eth0"
# 啟動eth0網路連線。
# 
# 總體來說，這條命令是通過SSH遠端登入到指定的主機，並使用網路管理命令 (nmcli) 修改eth0網路連線的設定，包括IP地址、閘道器、設定方法和DNS伺服器，並啟動該網路連線。

# 沒有IPv6選擇不設定即可
ssh [email protected] "nmcli con mod eth0 ipv6.addresses fc00:43f4:1eea:1::10; nmcli con mod eth0 ipv6.gateway fc00:43f4:1eea:1::1; nmcli con mod eth0 ipv6.method manual; nmcli con mod eth0 ipv6.dns "2400:3200::1"; nmcli con up eth0"
ssh [email protected] "nmcli con mod eth0 ipv6.addresses fc00:43f4:1eea:1::20; nmcli con mod eth0 ipv6.gateway fc00:43f4:1eea:1::1; nmcli con mod eth0 ipv6.method manual; nmcli con mod eth0 ipv6.dns "2400:3200::1"; nmcli con up eth0"
ssh [email protected] "nmcli con mod eth0 ipv6.addresses fc00:43f4:1eea:1::30; nmcli con mod eth0 ipv6.gateway fc00:43f4:1eea:1::1; nmcli con mod eth0 ipv6.method manual; nmcli con mod eth0 ipv6.dns "2400:3200::1"; nmcli con up eth0"
ssh [email protected] "nmcli con mod eth0 ipv6.addresses fc00:43f4:1eea:1::40; nmcli con mod eth0 ipv6.gateway fc00:43f4:1eea:1::1; nmcli con mod eth0 ipv6.method manual; nmcli con mod eth0 ipv6.dns "2400:3200::1"; nmcli con up eth0"
ssh [email protected] "nmcli con mod eth0 ipv6.addresses fc00:43f4:1eea:1::50; nmcli con mod eth0 ipv6.gateway fc00:43f4:1eea:1::1; nmcli con mod eth0 ipv6.method manual; nmcli con mod eth0 ipv6.dns "2400:3200::1"; nmcli con up eth0"

# 引數解釋
# 
# ssh [email protected]
# 通過SSH連線到IP地址為192.168.1.31的遠端主機，使用root使用者進行登入。
# 
# "nmcli con mod eth0 ipv6.addresses fc00:43f4:1eea:1::10"
# 使用nmcli命令修改eth0介面的IPv6地址為fc00:43f4:1eea:1::10。
# 
# "nmcli con mod eth0 ipv6.gateway fc00:43f4:1eea:1::1"
# 使用nmcli命令修改eth0介面的IPv6閘道器為fc00:43f4:1eea:1::1。
# 
# "nmcli con mod eth0 ipv6.method manual"
# 使用nmcli命令將eth0介面的IPv6設定方法修改為手動設定。
# 
# "nmcli con mod eth0 ipv6.dns "2400:3200::1"
# 使用nmcli命令設定eth0介面的IPv6 DNS伺服器為2400:3200::1。
# 
# "nmcli con up eth0"
# 使用nmcli命令啟動eth0介面。
# 
# 這個命令的目的是在遠端主機上設定eth0介面的IPv6地址、閘道器、設定方法和DNS伺服器，並啟動eth0介面。


# 檢視網路卡設定
# nmcli device show eth0
# nmcli con show eth0
[root@localhost ~]# cat /etc/sysconfig/network-scripts/ifcfg-eth0 
TYPE=Ethernet
PROXY_METHOD=none
BROWSER_ONLY=no
BOOTPROTO=none
DEFROUTE=yes
IPV4_FAILURE_FATAL=no
IPV6INIT=yes
IPV6_AUTOCONF=yes
IPV6_DEFROUTE=yes
IPV6_FAILURE_FATAL=no
IPV6_ADDR_GEN_MODE=stable-privacy
NAME=eth0
UUID=2aaddf95-3f36-4a48-8626-b55ebf7f53e7
DEVICE=eth0
ONBOOT=yes
IPADDR=192.168.1.31
PREFIX=24
GATEWAY=192.168.1.1
DNS1=8.8.8.8
[root@localhost ~]# 



# 引數解釋
# 
# TYPE=Ethernet
# 指定連線型別為乙太網。
# 
# PROXY_METHOD=none
# 指定不使用代理方法。
# 
# BROWSER_ONLY=no
# 指定不僅僅在瀏覽器中使用代理。
# 
# BOOTPROTO=none
# 指定自動分配地址的方式為無（即手動設定IP地址）。
# 
# DEFROUTE=yes
# 指定預設路由開啟。
# 
# IPV4_FAILURE_FATAL=no
# 指定IPv4連線失敗時不宣告嚴重錯誤。
# 
# IPV6INIT=yes
# 指定啟用IPv6。
# 
# IPV6_AUTOCONF=no
# 指定不自動設定IPv6地址。
# 
# IPV6_DEFROUTE=yes
# 指定預設IPv6路由開啟。
# 
# IPV6_FAILURE_FATAL=no
# 指定IPv6連線失敗時不宣告嚴重錯誤。
# 
# IPV6_ADDR_GEN_MODE=stable-privacy
# 指定IPv6地址生成模式為穩定隱私模式。
# 
# NAME=eth0
# 指定裝置名稱為eth0。
# 
# UUID=424fd260-c480-4899-97e6-6fc9722031e8
# 指定裝置的唯一識別符號。
# 
# DEVICE=eth0
# 指定裝置名稱為eth0。
# 
# ONBOOT=yes
# 指定開機自動啟用這個連線。
# 
# IPADDR=192.168.1.31
# 指定IPv4地址為192.168.1.31。
# 
# PREFIX=24
# 指定IPv4地址的子網掩碼為24。
# 
# GATEWAY=192.168.8.1
# 指定IPv4的閘道器地址為192.168.8.1。
# 
# DNS1=8.8.8.8
# 指定首選DNS伺服器為8.8.8.8。
# 
# IPV6ADDR=fc00:43f4:1eea:1::10/128
# 指定IPv6地址為fc00:43f4:1eea:1::10，子網掩碼為128。
# 
# IPV6_DEFAULTGW=fc00:43f4:1eea:1::1
# 指定IPv6的預設閘道器地址為fc00:43f4:1eea:1::1。
# 
# DNS2=2400:3200::1
# 指定備用DNS伺服器為2400:3200::1。

1.3.設定主機名

hostnamectl set-hostname k8s-master01
hostnamectl set-hostname k8s-master02
hostnamectl set-hostname k8s-master03
hostnamectl set-hostname k8s-node01
hostnamectl set-hostname k8s-node02

# 引數解釋
# 
# 引數: set-hostname
# 解釋: 這是hostnamectl命令的一個引數，用於設定系統的主機名。
# 
# 引數: k8s-master01
# 解釋: 這是要設定的主機名，將系統的主機名設定為"k8s-master01"。

1.4.設定yum源

# 其他系統的源地址
# https://mirrors.tuna.tsinghua.edu.cn/help/

# 對於 Ubuntu
sed -i 's/cn.archive.ubuntu.com/mirrors.ustc.edu.cn/g' /etc/apt/sources.list

# 對於 CentOS 7
sudo sed -e 's|^mirrorlist=|#mirrorlist=|g' \
         -e 's|^#baseurl=http://mirror.centos.org/centos|baseurl=https://mirrors.tuna.tsinghua.edu.cn/centos|g' \
         -i.bak \
         /etc/yum.repos.d/CentOS-*.repo

# 對於 CentOS 8
sudo sed -e 's|^mirrorlist=|#mirrorlist=|g' \
         -e 's|^#baseurl=http://mirror.centos.org/$contentdir|baseurl=https://mirrors.tuna.tsinghua.edu.cn/centos|g' \
         -i.bak \
         /etc/yum.repos.d/CentOS-*.repo

# 對於私有倉庫
sed -e 's|^mirrorlist=|#mirrorlist=|g' -e 's|^#baseurl=http://mirror.centos.org/\$contentdir|baseurl=http://192.168.1.123/centos|g' -i.bak  /etc/yum.repos.d/CentOS-*.repo

# 引數解釋
# 
# 以上命令是用於更改系統軟體源的設定，以便從國內映象站點下載軟體包和更新。
# 
# 對於 Ubuntu 系統，將 /etc/apt/sources.list 檔案中的軟體源地址 cn.archive.ubuntu.com 替換為 mirrors.ustc.edu.cn。
# 
# 對於 CentOS 7 系統，將 /etc/yum.repos.d/CentOS-*.repo 檔案中的 mirrorlist 註釋掉，並將 baseurl 的值替換為 https://mirrors.tuna.tsinghua.edu.cn/centos。
# 
# 對於 CentOS 8 系統，同樣將 /etc/yum.repos.d/CentOS-*.repo 檔案中的 mirrorlist 註釋掉，並將 baseurl 的值替換為 https://mirrors.tuna.tsinghua.edu.cn/centos。
# 
# 對於私有倉庫，將 /etc/yum.repos.d/CentOS-*.repo 檔案中的 mirrorlist 註釋掉，並將 baseurl 的值替換為私有倉庫地址 http://192.168.1.123/centos。
# 
# 這些命令通過使用 sed 工具和正規表示式，對相應的組態檔進行批次的替換操作，從而更改系統軟體源設定。

1.5.安裝一些必備工具

# 對於 Ubuntu
apt update && apt upgrade -y && apt install -y wget psmisc vim net-tools nfs-kernel-server telnet lvm2 git tar curl

# 對於 CentOS 7
yum update -y && yum -y install  wget psmisc vim net-tools nfs-utils telnet yum-utils device-mapper-persistent-data lvm2 git tar curl

# 對於 CentOS 8
yum update -y && yum -y install wget psmisc vim net-tools nfs-utils telnet yum-utils device-mapper-persistent-data lvm2 git network-scripts tar curl

1.5.1 下載離線所需檔案(可選)

在網際網路伺服器上安裝一個一模一樣的系統進行下載所需包

CentOS7

# 下載必要工具
yum -y install createrepo yum-utils wget epel*

# 下載全量依賴包
repotrack createrepo wget psmisc vim net-tools nfs-utils telnet yum-utils device-mapper-persistent-data lvm2 git tar curl gcc keepalived haproxy bash-completion chrony sshpass ipvsadm ipset sysstat conntrack libseccomp

# 刪除libseccomp
rm -rf libseccomp-*.rpm

# 下載libseccomp
wget http://rpmfind.net/linux/centos/8-stream/BaseOS/x86_64/os/Packages/libseccomp-2.5.1-1.el8.x86_64.rpm

# 建立yum源資訊
createrepo -u -d /data/centos7/

# 拷貝包到內網機器上
scp -r /data/centos7/ [email protected]:
scp -r /data/centos7/ [email protected]:
scp -r /data/centos7/ [email protected]:
scp -r /data/centos7/ [email protected]:
scp -r /data/centos7/ [email protected]:

# 在內網機器上建立repo組態檔
rm -rf /etc/yum.repos.d/*
cat > /etc/yum.repos.d/123.repo  << EOF 
[cby]
name=CentOS-$releasever - Media
baseurl=file:///root/centos7/
gpgcheck=0
enabled=1
EOF

# 安裝下載好的包
yum clean all
yum makecache
yum install /root/centos7/* --skip-broken -y

#### 備註 #####
# 安裝完成後，可能還會出現yum無法使用那麼再次執行
rm -rf /etc/yum.repos.d/*
cat > /etc/yum.repos.d/123.repo  << EOF 
[cby]
name=CentOS-$releasever - Media
baseurl=file:///root/centos7/
gpgcheck=0
enabled=1
EOF
yum clean all
yum makecache
yum install /root/centos7/* --skip-broken -y

#### 備註 #####
# 安裝 chrony 和 libseccomp
# yum install /root/centos7/libseccomp-2.5.1*.rpm -y
# yum install /root/centos7/chrony-*.rpm -y

CentOS8

# 下載必要工具
yum -y install createrepo yum-utils wget epel*

# 下載全量依賴包
repotrack wget psmisc vim net-tools nfs-utils telnet yum-utils device-mapper-persistent-data lvm2 git network-scripts tar curl gcc keepalived haproxy bash-completion chrony sshpass ipvsadm ipset sysstat conntrack libseccomp

# 建立yum源資訊
createrepo -u -d /data/centos8/

# 拷貝包到內網機器上
scp -r centos8/ [email protected]:
scp -r centos8/ [email protected]:
scp -r centos8/ [email protected]:
scp -r centos8/ [email protected]:
scp -r centos8/ [email protected]:

# 在內網機器上建立repo組態檔
rm -rf /etc/yum.repos.d/*
cat > /etc/yum.repos.d/123.repo  << EOF 
[cby]
name=CentOS-$releasever - Media
baseurl=file:///root/centos8/
gpgcheck=0
enabled=1
EOF

# 安裝下載好的包
yum clean all
yum makecache
yum install /root/centos8/* --skip-broken -y

#### 備註 #####
# 安裝完成後，可能還會出現yum無法使用那麼再次執行
rm -rf /etc/yum.repos.d/*
cat > /etc/yum.repos.d/123.repo  << EOF 
[cby]
name=CentOS-$releasever - Media
baseurl=file:///root/centos8/
gpgcheck=0
enabled=1
EOF
yum clean all
yum makecache
yum install /root/centos8/* --skip-broken -y

Ubuntu 下載包和依賴

#!/bin/bash

logfile=123.log
ret=""
function getDepends()
{
   echo "fileName is" $1>>$logfile
   # use tr to del < >
   ret=`apt-cache depends $1|grep Depends |cut -d: -f2 |tr -d "<>"`
   echo $ret|tee  -a $logfile
}
# 需要獲取其所依賴包的包
libs="wget psmisc vim net-tools nfs-kernel-server telnet lvm2 git tar curl gcc keepalived haproxy bash-completion chrony sshpass ipvsadm ipset sysstat conntrack libseccomp"

# download libs dependen. deep in 3
i=0
while [ $i -lt 3 ] ;
do
    let i++
    echo $i
    # download libs
    newlist=" "
    for j in $libs
    do
        added="$(getDepends $j)"
        newlist="$newlist $added"
        apt install $added --reinstall -d -y
    done

    libs=$newlist
done

# 建立源資訊
apt install dpkg-dev
sudo cp /var/cache/apt/archives/*.deb /data/ubuntu/ -r
dpkg-scanpackages . /dev/null |gzip > /data/ubuntu/Packages.gz -r

# 拷貝包到內網機器上
scp -r ubuntu/ [email protected]:
scp -r ubuntu/ [email protected]:
scp -r ubuntu/ [email protected]:
scp -r ubuntu/ [email protected]:
scp -r ubuntu/ [email protected]:

# 在內網機器上設定apt源
vim /etc/apt/sources.list
cat /etc/apt/sources.list
deb file:////root/ ubuntu/

# 安裝deb包
apt install ./*.deb

1.6.選擇性下載需要工具

#!/bin/bash

# 檢視版本地址：
# 
# https://github.com/containernetworking/plugins/releases/
# https://github.com/containerd/containerd/releases/
# https://github.com/kubernetes-sigs/cri-tools/releases/
# https://github.com/Mirantis/cri-dockerd/releases/
# https://github.com/etcd-io/etcd/releases/
# https://github.com/cloudflare/cfssl/releases/
# https://github.com/kubernetes/kubernetes/tree/master/CHANGELOG
# https://download.docker.com/linux/static/stable/x86_64/
# https://github.com/opencontainers/runc/releases/
# https://mirrors.tuna.tsinghua.edu.cn/elrepo/kernel/el7/x86_64/RPMS/
# https://github.com/helm/helm/tags
# http://nginx.org/download/

# Version numbers
cni_plugins_version='v1.3.0'
cri_containerd_cni_version='1.7.8'
crictl_version='v1.28.0'
cri_dockerd_version='0.3.7'
etcd_version='v3.5.10'
cfssl_version='1.6.4'
kubernetes_server_version='1.28.3'
docker_version='24.0.7'
runc_version='1.1.10'
kernel_version='5.4.260'
helm_version='3.13.2'
nginx_version='1.25.3'

# URLs 
base_url='https://mirrors.chenby.cn/https://github.com'
kernel_url="http://mirrors.tuna.tsinghua.edu.cn/elrepo/kernel/el7/x86_64/RPMS/kernel-lt-${kernel_version}-1.el7.elrepo.x86_64.rpm"
runc_url="${base_url}/opencontainers/runc/releases/download/v${runc_version}/runc.amd64"
docker_url="https://mirrors.ustc.edu.cn/docker-ce/linux/static/stable/x86_64/docker-${docker_version}.tgz"
cni_plugins_url="${base_url}/containernetworking/plugins/releases/download/${cni_plugins_version}/cni-plugins-linux-amd64-${cni_plugins_version}.tgz"
cri_containerd_cni_url="${base_url}/containerd/containerd/releases/download/v${cri_containerd_cni_version}/cri-containerd-cni-${cri_containerd_cni_version}-linux-amd64.tar.gz"
crictl_url="${base_url}/kubernetes-sigs/cri-tools/releases/download/${crictl_version}/crictl-${crictl_version}-linux-amd64.tar.gz"
cri_dockerd_url="${base_url}/Mirantis/cri-dockerd/releases/download/v${cri_dockerd_version}/cri-dockerd-${cri_dockerd_version}.amd64.tgz"
etcd_url="${base_url}/etcd-io/etcd/releases/download/${etcd_version}/etcd-${etcd_version}-linux-amd64.tar.gz"
cfssl_url="${base_url}/cloudflare/cfssl/releases/download/v${cfssl_version}/cfssl_${cfssl_version}_linux_amd64"
cfssljson_url="${base_url}/cloudflare/cfssl/releases/download/v${cfssl_version}/cfssljson_${cfssl_version}_linux_amd64"
helm_url="https://mirrors.huaweicloud.com/helm/v${helm_version}/helm-v${helm_version}-linux-amd64.tar.gz"
kubernetes_server_url="https://storage.googleapis.com/kubernetes-release/release/v${kubernetes_server_version}/kubernetes-server-linux-amd64.tar.gz"
nginx_url="http://nginx.org/download/nginx-${nginx_version}.tar.gz"

# Download packages
packages=(
  $kernel_url
  $runc_url
  $docker_url
  $cni_plugins_url
  $cri_containerd_cni_url
  $crictl_url
  $cri_dockerd_url
  $etcd_url
  $cfssl_url
  $cfssljson_url
  $helm_url
  $kubernetes_server_url
  $nginx_url
)

for package_url in "${packages[@]}"; do
  filename=$(basename "$package_url")
  if curl --parallel --parallel-immediate -k -L -C - -o "$filename" "$package_url"; then
    echo "Downloaded $filename"
  else
    echo "Failed to download $filename"
    exit 1
  fi
done

1.7.關閉防火牆

# Ubuntu忽略，CentOS執行
systemctl disable --now firewalld

1.8.關閉SELinux

# Ubuntu忽略，CentOS執行
setenforce 0
sed -i 's#SELINUX=enforcing#SELINUX=disabled#g' /etc/selinux/config

# 引數解釋
# 
# setenforce 0
# 此命令用於設定 SELinux 的執行模式。0 表示關閉 SELinux。
# 
# sed -i 's#SELINUX=enforcing#SELINUX=disabled#g' /etc/selinux/config
# 該命令使用 sed 工具來編輯 /etc/selinux/config 檔案。其中 '-i' 參數列示直接修改原檔案，而不是輸出到終端或另一個檔案。's#SELINUX=enforcing#SELINUX=disabled#g' 是 sed 的替換命令，它將檔案中所有的 "SELINUX=enforcing" 替換為 "SELINUX=disabled"。這裡的 '#' 是分隔符，用於替代傳統的 '/' 分隔符，以避免與路徑中的 '/' 衝突。

1.9.關閉交換分割區

sed -ri 's/.*swap.*/#&/' /etc/fstab
swapoff -a && sysctl -w vm.swappiness=0

cat /etc/fstab
# /dev/mapper/centos-swap swap                    swap    defaults        0 0


# 引數解釋：
# 
# -ri: 這個引數用於在原檔案中替換匹配的模式。-r表示擴充套件正規表示式，-i允許直接修改檔案。
# 's/.*swap.*/#&/': 這是一個sed命令，用於在檔案/etc/fstab中找到包含swap的行，並在行首新增#來註釋掉該行。
# /etc/fstab: 這是一個檔案路徑，即/etc/fstab檔案，用於儲存檔案系統表。
# swapoff -a: 這個命令用於關閉所有啟用的交換分割區。
# sysctl -w vm.swappiness=0: 這個命令用於修改vm.swappiness引數的值為0，表示系統在實體記憶體充足時更傾向於使用實體記憶體而非交換分割區。

1.10.網路設定（倆種方式二選一）

# Ubuntu忽略，CentOS執行

# 方式一
# systemctl disable --now NetworkManager
# systemctl start network && systemctl enable network

# 方式二
cat > /etc/NetworkManager/conf.d/calico.conf << EOF 
[keyfile]
unmanaged-devices=interface-name:cali*;interface-name:tunl*
EOF
systemctl restart NetworkManager

# 引數解釋
#
# 這個引數用於指定不由 NetworkManager 管理的裝置。它由以下兩個部分組成
# 
# interface-name:cali*
# 表示以 "cali" 開頭的介面名稱被排除在 NetworkManager 管理之外。例如，"cali0", "cali1" 等介面不受 NetworkManager 管理。
# 
# interface-name:tunl*
# 表示以 "tunl" 開頭的介面名稱被排除在 NetworkManager 管理之外。例如，"tunl0", "tunl1" 等介面不受 NetworkManager 管理。
# 
# 通過使用這個引數，可以將特定的介面排除在 NetworkManager 的管理範圍之外，以便其他工具或程序可以獨立地管理和設定這些介面。

1.11.進行時間同步

# 伺服器端
# 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.1.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.1.31 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
# 指定紀錄檔檔案存放目錄。

1.12.設定ulimit

ulimit -SHn 65535
cat >> /etc/security/limits.conf <<EOF
* soft nofile 655360
* hard nofile 131072
* soft nproc 655350
* hard nproc 655350
* seft memlock unlimited
* hard memlock unlimitedd
EOF

# 引數解釋
#
# soft nofile 655360
# soft表示軟限制，nofile表示一個程序可開啟的最大檔案數，預設值為1024。這裡的軟限制設定為655360，即一個程序可開啟的最大檔案數為655360。
#
# hard nofile 131072
# hard表示硬限制，即系統設定的最大值。nofile表示一個程序可開啟的最大檔案數，預設值為4096。這裡的硬限制設定為131072，即系統設定的最大檔案數為131072。
#
# soft nproc 655350
# soft表示軟限制，nproc表示一個使用者可建立的最大程序數，預設值為30720。這裡的軟限制設定為655350，即一個使用者可建立的最大程序數為655350。
#
# hard nproc 655350
# hard表示硬限制，即系統設定的最大值。nproc表示一個使用者可建立的最大程序數，預設值為4096。這裡的硬限制設定為655350，即系統設定的最大程序數為655350。
#
# seft memlock unlimited
# seft表示軟限制，memlock表示一個程序可鎖定在RAM中的最大記憶體，預設值為64 KB。這裡的軟限制設定為unlimited，即一個程序可鎖定的最大記憶體為無限制。
#
# hard memlock unlimited
# hard表示硬限制，即系統設定的最大值。memlock表示一個程序可鎖定在RAM中的最大記憶體，預設值為64 KB。這裡的硬限制設定為unlimited，即系統設定的最大記憶體鎖定為無限制。

1.13.設定免密登入

# apt install -y sshpass
yum install -y sshpass
ssh-keygen -f /root/.ssh/id_rsa -P ''
export IP="192.168.1.31 192.168.1.32 192.168.1.33 192.168.1.34 192.168.1.35"
export SSHPASS=123123
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.1.31 192.168.1.32 192.168.1.33 192.168.1.34 192.168.1.35"`：設定一個包含多個遠端主機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登入。

1.14.新增啟用源

# Ubuntu忽略，CentOS執行

# 為 RHEL-8或 CentOS-8設定源
yum install https://www.elrepo.org/elrepo-release-8.el8.elrepo.noarch.rpm -y 
sed -i "s@mirrorlist@#mirrorlist@g" /etc/yum.repos.d/elrepo.repo 
sed -i "[email protected]/[email protected]/elrepo@g" /etc/yum.repos.d/elrepo.repo 

# 為 RHEL-7 SL-7 或 CentOS-7 安裝 ELRepo 
yum install https://www.elrepo.org/elrepo-release-7.el7.elrepo.noarch.rpm -y 
sed -i "s@mirrorlist@#mirrorlist@g" /etc/yum.repos.d/elrepo.repo 
sed -i "[email protected]/[email protected]/elrepo@g" /etc/yum.repos.d/elrepo.repo 

# 檢視可用安裝包
yum  --disablerepo="*"  --enablerepo="elrepo-kernel"  list  available

1.15.升級核心至4.18版本以上

# Ubuntu忽略，CentOS執行

# 安裝最新的核心
# 我這裡選擇的是穩定版kernel-ml   如需更新長期維護版本kernel-lt  
yum -y --enablerepo=elrepo-kernel  install  kernel-ml

# 檢視已安裝那些核心
rpm -qa | grep kernel

# 檢視預設核心
grubby --default-kernel

# 若不是最新的使用命令設定
grubby --set-default $(ls /boot/vmlinuz-* | grep elrepo)

# 重啟生效
reboot

# v8 整合命令為：
yum install https://www.elrepo.org/elrepo-release-8.el8.elrepo.noarch.rpm -y ; sed -i "s@mirrorlist@#mirrorlist@g" /etc/yum.repos.d/elrepo.repo ; sed -i "[email protected]/[email protected]/elrepo@g" /etc/yum.repos.d/elrepo.repo ; yum  --disablerepo="*"  --enablerepo="elrepo-kernel"  list  available -y ; yum  --enablerepo=elrepo-kernel  install kernel-lt -y ; grubby --default-kernel ; reboot 

# v7 整合命令為：
yum install https://www.elrepo.org/elrepo-release-7.el7.elrepo.noarch.rpm -y ; sed -i "s@mirrorlist@#mirrorlist@g" /etc/yum.repos.d/elrepo.repo ; sed -i "[email protected]/[email protected]/elrepo@g" /etc/yum.repos.d/elrepo.repo ; yum  --disablerepo="*"  --enablerepo="elrepo-kernel"  list  available -y ; yum  --enablerepo=elrepo-kernel  install  kernel-lt -y ; grubby --set-default $(ls /boot/vmlinuz-* | grep elrepo) ; grubby --default-kernel ; reboot 

# 離線版本 
yum install -y /root/cby/kernel-lt-*-1.el7.elrepo.x86_64.rpm ; grubby --set-default $(ls /boot/vmlinuz-* | grep elrepo) ; grubby --default-kernel ; reboot 

1.16.安裝ipvsadm

# 對於CentOS7離線安裝
# yum install /root/centos7/ipset-*.el7.x86_64.rpm /root/centos7/lm_sensors-libs-*.el7.x86_64.rpm  /root/centos7/ipset-libs-*.el7.x86_64.rpm /root/centos7/sysstat-*.el7_9.x86_64.rpm  /root/centos7/ipvsadm-*.el7.x86_64.rpm  -y

# 對於 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                 180224  6 ip_vs_rr,ip_vs_sh,ip_vs_wrr
nf_conntrack          176128  1 ip_vs
nf_defrag_ipv6         24576  2 nf_conntrack,ip_vs
nf_defrag_ipv4         16384  1 nf_conntrack
libcrc32c              16384  3 nf_conntrack,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 封包。

1.17.修改核心引數

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_watches=89100
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.ip_conntrack_max = 65536
net.ipv4.tcp_max_syn_backlog = 16384
net.ipv4.tcp_timestamps = 0
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連線的半連線數（半連線佇列）的最大長度。
# 
# 19. net.ipv4.ip_conntrack_max = 65536
#     - 設定系統可以建立的網路連線跟蹤表項的最大數量。
# 
# 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封包轉發。

1.18.所有節點設定hosts本地解析

cat > /etc/hosts <<EOF
127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6

192.168.1.31 k8s-master01
192.168.1.32 k8s-master02
192.168.1.33 k8s-master03
192.168.1.34 k8s-node01
192.168.1.35 k8s-node02
192.168.1.36 lb-vip
EOF

2.k8s基本元件安裝

注意 ： 2.1 和 2.2 二選其一即可

2.1.安裝Containerd作為Runtime （推薦）

# https://github.com/containernetworking/plugins/releases/
# wget https://mirrors.chenby.cn/https://github.com/containernetworking/plugins/releases/download/v1.3.0/cni-plugins-linux-amd64-v1.3.0.tgz

cd cby/

#建立cni外掛所需目錄
mkdir -p /etc/cni/net.d /opt/cni/bin 
#解壓cni二進位制包
tar xf cni-plugins-linux-amd64-v*.tgz -C /opt/cni/bin/

# https://github.com/containerd/containerd/releases/
# wget https://mirrors.chenby.cn/https://github.com/containerd/containerd/releases/download/v1.7.8/cri-containerd-cni-1.7.8-linux-amd64.tar.gz

#解壓
tar -xzf cri-containerd-cni-*-linux-amd64.tar.gz -C /

#建立服務啟動檔案
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/local/bin/containerd
Type=notify
Delegate=yes
KillMode=process
Restart=always
RestartSec=5
LimitNPROC=infinity
LimitCORE=infinity
LimitNOFILE=infinity
TasksMax=infinity
OOMScoreAdjust=-999

[Install]
WantedBy=multi-user.target
EOF


# 引數解釋：
#
# 這是一個用於啟動containerd容器執行時的systemd unit檔案。下面是對該檔案不同部分的詳細解釋：
# 
# [Unit]
# Description=containerd container runtime
# 描述該unit的作用是作為containerd容器執行時。
# 
# Documentation=https://containerd.io
# 指向容器執行時的檔案的URL。
# 
# After=network.target local-fs.target
# 定義了在哪些依賴項之後該unit應該被啟動。在網路和本地檔案系統載入完成後啟動，確保了容器執行時在這些依賴項可用時才會啟動。
# 
# [Service]
# ExecStartPre=-/sbin/modprobe overlay
# 在啟動containerd之前執行的命令。這裡的命令是嘗試載入核心的overlay模組，如果失敗則忽略錯誤繼續執行下面的命令。
# 
# ExecStart=/usr/local/bin/containerd
# 實際執行的命令，用於啟動containerd容器執行時。
# 
# Type=notify
# 指定服務的通知型別。這裡使用notify型別，表示當服務就緒時會通過通知的方式告知systemd。
# 
# Delegate=yes
# 允許systemd對此服務進行重啟和停止操作。
# 
# KillMode=process
# 在終止容器執行時時使用的kill模式。這裡使用process模式，表示通過終止程序來停止容器執行時。
# 
# Restart=always
# 定義了當容器執行時終止後的重啟策略。這裡設定為always，表示無論何時終止容器執行時，都會自動重新啟動。
# 
# RestartSec=5
# 在容器執行時終止後重新啟動之前等待的秒數。
# 
# LimitNPROC=infinity
# 指定容器執行時可以使用的最大程序數量。這裡設定為無限制。
# 
# LimitCORE=infinity
# 指定容器執行時可以使用的最大CPU核心數量。這裡設定為無限制。
# 
# LimitNOFILE=infinity
# 指定容器執行時可以開啟的最大檔案數。這裡設定為無限制。
# 
# TasksMax=infinity
# 指定容器執行時可以建立的最大任務數。這裡設定為無限制。
# 
# OOMScoreAdjust=-999
# 指定容器執行時的OOM（Out-Of-Memory）分數調整值。負數值表示容器執行時的優先順序較高。
# 
# [Install]
# WantedBy=multi-user.target
# 定義了服務的安裝位置。這裡指定為multi-user.target，表示將服務安裝為多使用者模式下的啟動項。

2.1.1設定Containerd所需的模組

cat <<EOF | sudo tee /etc/modules-load.d/containerd.conf
overlay
br_netfilter
EOF

# 引數解釋：
#
# containerd是一個容器執行時，用於管理和執行容器。它支援多種不同的引數設定來自定義容器執行時的行為和功能。
# 
# 1. overlay：overlay是容器d預設使用的儲存驅動，它提供了一種輕量級的、可堆疊的、逐層增量的檔案系統。它通過在現有檔案系統上疊加檔案系統層來建立容器的檔案系統檢視。每個容器可以有自己的一組檔案系統層，這些層可以共用基礎映象中的檔案，並在容器內部進行修改。使用overlay可以有效地使用磁碟空間，並使容器更加輕量級。
# 
# 2. br_netfilter：br_netfilter是Linux核心提供的一個網路過濾器模組，用於在容器網路中進行網路過濾和NAT轉發。當容器和主機之間的網路通訊需要進行DNAT或者SNAT時，br_netfilter模組可以將IP地址進行轉換。它還可以提供基於iptables規則的網路過濾功能，用於限制容器之間或容器與外部網路之間的通訊。
# 
# 這些引數可以在containerd的組態檔或者命令列中指定。例如，可以通過設定--storage-driver引數來選擇使用overlay作為儲存驅動，通過設定--iptables引數來啟用或禁用br_netfilter模組。具體的使用方法和設定細節可以參考containerd的官方檔案。

2.1.2載入模組

systemctl restart systemd-modules-load.service

# 引數解釋：
# - `systemctl`: 是Linux系統管理服務的命令列工具，可以管理systemd init系統。
# - `restart`: 是systemctl命令的一個選項，用於重新啟動服務。
# - `systemd-modules-load.service`: 是一個系統服務，用於載入核心模組。
# 
# 將上述引數結合在一起來解釋`systemctl restart systemd-modules-load.service`的含義：
# 這個命令用於重新啟動系統服務`systemd-modules-load.service`，它是負責載入核心模組的服務。在重新啟動該服務後，系統會重新載入所有的核心模組。

2.1.3設定Containerd所需的核心

cat <<EOF | sudo tee /etc/sysctl.d/99-kubernetes-cri.conf
net.bridge.bridge-nf-call-iptables  = 1
net.ipv4.ip_forward                 = 1
net.bridge.bridge-nf-call-ip6tables = 1
EOF

# 載入核心
sysctl --system

# 引數解釋：
# 
# 這些引數是Linux作業系統中用於網路和網路橋接設定的引數。
# 
# - net.bridge.bridge-nf-call-iptables：這個引數控制網路橋接裝置是否呼叫iptables規則處理網路封包。當該引數設定為1時，網路封包將被傳遞到iptables進行處理；當該引數設定為0時，網路封包將繞過iptables直接傳遞。預設情況下，這個引數的值是1，即啟用iptables規則處理網路封包。
# 
# - net.ipv4.ip_forward：這個引數用於控制是否啟用IP轉發功能。IP轉發使得作業系統可以將接收到的封包從一個網路介面轉發到另一個網路介面。當該引數設定為1時，啟用IP轉發功能；當該引數設定為0時，禁用IP轉發功能。在網路環境中，通常需要啟用IP轉發功能來實現不同網路之間的通訊。預設情況下，這個引數的值是0，即禁用IP轉發功能。
# 
# - net.bridge.bridge-nf-call-ip6tables：這個引數與net.bridge.bridge-nf-call-iptables類似，但是它用於IPv6封包的處理。當該引數設定為1時，IPv6封包將被傳遞到ip6tables進行處理；當該引數設定為0時，IPv6封包將繞過ip6tables直接傳遞。預設情況下，這個引數的值是1，即啟用ip6tables規則處理IPv6封包。
# 
# 這些引數的值可以通過修改作業系統的組態檔（通常是'/etc/sysctl.conf'）來進行設定。修改完成後，需要使用'sysctl -p'命令過載組態檔使引數生效。

2.1.4建立Containerd的組態檔

# 引數解釋：
# 
# 這段程式碼是用於修改並設定containerd的引數。
# 
# 1. 首先使用命令`mkdir -p /etc/containerd`建立/etc/containerd目錄，如果該目錄已存在，則不進行任何操作。
# 2. 使用命令`containerd config default | tee /etc/containerd/config.toml`建立預設組態檔，並將輸出同時傳遞給/etc/containerd/config.toml檔案。
# 3. 使用sed命令修改/etc/containerd/config.toml檔案，將SystemdCgroup引數的值從false改為true。-i參數列示直接在原檔案中進行編輯。
# 4. 使用cat命令結合grep命令檢視/etc/containerd/config.toml檔案中SystemdCgroup引數的值是否已修改為true。
# 5. 使用sed命令修改/etc/containerd/config.toml檔案，將registry.k8s.io的地址替換為m.daocloud.io/registry.k8s.io。-i參數列示直接在原檔案中進行編輯。
# 6. 使用cat命令結合grep命令檢視/etc/containerd/config.toml檔案中sandbox_image引數的值是否已修改為m.daocloud.io/registry.k8s.io。
# 7. 使用sed命令修改/etc/containerd/config.toml檔案，將config_path引數的值從""改為"/etc/containerd/certs.d"。-i參數列示直接在原檔案中進行編輯。
# 8. 使用cat命令結合grep命令檢視/etc/containerd/config.toml檔案中certs.d引數的值是否已修改為/etc/containerd/certs.d。
# 9. 使用mkdir命令建立/etc/containerd/certs.d/docker.io目錄，如果目錄已存在，則不進行任何操作。-p參數列示建立目錄時，如果父級目錄不存在，則自動建立父級目錄。
# 
# 最後，使用cat重定向操作符將內容寫入/etc/containerd/certs.d/docker.io/hosts.toml檔案。該檔案會設定加速器，其中server引數設定為"https://docker.io"，host引數設定為"https://hub-mirror.c.163.com"，並新增capabilities引數。

# 建立預設組態檔
mkdir -p /etc/containerd
containerd config default | tee /etc/containerd/config.toml

# 修改Containerd的組態檔
sed -i "s#SystemdCgroup\ \=\ false#SystemdCgroup\ \=\ true#g" /etc/containerd/config.toml
cat /etc/containerd/config.toml | grep SystemdCgroup
sed -i "s#registry.k8s.io#m.daocloud.io/registry.k8s.io#g" /etc/containerd/config.toml
cat /etc/containerd/config.toml | grep sandbox_image
sed -i "s#config_path\ \=\ \"\"#config_path\ \=\ \"/etc/containerd/certs.d\"#g" /etc/containerd/config.toml
cat /etc/containerd/config.toml | grep certs.d

# 設定加速器
mkdir /etc/containerd/certs.d/docker.io -pv
cat > /etc/containerd/certs.d/docker.io/hosts.toml << EOF
server = "https://docker.io"
[host."https://docker.mirrors.ustc.edu.cn"]
  capabilities = ["pull", "resolve"]
EOF

# 注意！
# SystemdCgroup引數是containerd中的一個設定引數，用於設定containerd在執行過程中使用的Cgroup（控制組）路徑。Containerd使用SystemdCgroup引數來指定應該使用哪個Cgroup來跟蹤和管理容器的資源使用。
# 
# Cgroup是Linux核心提供的一種資源隔離和管理機制，可以用於限制、分配和監控行程群組的資源使用。使用Cgroup，可以將容器的資源限制和隔離，以防止容器之間的資源爭用和不公平的競爭。
# 
# 通過設定SystemdCgroup引數，可以確保containerd能夠找到正確的Cgroup路徑，並正確地限制和隔離容器的資源使用，確保容器可以按照預期的方式執行。如果未正確設定SystemdCgroup引數，可能會導致容器無法正確地使用資源，或者無法保證資源的公平分配和隔離。
# 
# 總而言之，SystemdCgroup引數的作用是為了確保containerd能夠正確地管理容器的資源使用，以實現資源的限制、隔離和公平分配。

2.1.5啟動並設定為開機啟動

systemctl daemon-reload
# 用於重新載入systemd管理的單位檔案。當你新增或修改了某個單位檔案（如.service檔案、.socket檔案等），需要執行該命令來重新整理systemd對該檔案的設定。

systemctl enable --now containerd.service
# 啟用並立即啟動docker.service單元。docker.service是Docker守護行程的systemd服務單元。

systemctl stop containerd.service
# 停止執行中的docker.service單元，即停止Docker守護行程。

systemctl start containerd.service
# 啟動docker.service單元，即啟動Docker守護行程。

systemctl restart containerd.service
# 重啟docker.service單元，即重新啟動Docker守護行程。

systemctl status containerd.service
# 顯示docker.service單元的當前狀態，包括執行狀態、是否啟用等資訊。

2.1.6設定crictl使用者端連線的執行時位置

# https://github.com/kubernetes-sigs/cri-tools/releases/
# wget https://mirrors.chenby.cn/https://github.com/kubernetes-sigs/cri-tools/releases/download/v1.28.0/crictl-v1.28.0-linux-amd64.tar.gz

#解壓
tar xf crictl-v*-linux-amd64.tar.gz -C /usr/bin/
#生成組態檔
cat > /etc/crictl.yaml <<EOF
runtime-endpoint: unix:///run/containerd/containerd.sock
image-endpoint: unix:///run/containerd/containerd.sock
timeout: 10
debug: false
EOF

#測試
systemctl restart  containerd
crictl info

# 注意！
# 下面是引數`crictl`的詳細解釋
# 
# `crictl`是一個用於與容器執行時通訊的命令列工具。它是容器執行時介面（CRI）工具的一個實現，可以對容器執行時進行管理和操作。
# 
# 1. `runtime-endpoint: unix:///run/containerd/containerd.sock`
# 指定容器執行時的終端通訊端地址。在這個例子中，指定的地址是`unix:///run/containerd/containerd.sock`，這是一個Unix域通訊端地址。
# 
# 2. `image-endpoint: unix:///run/containerd/containerd.sock`
# 指定容器映象服務的終端通訊端地址。在這個例子中，指定的地址是`unix:///run/containerd/containerd.sock`，這是一個Unix域通訊端地址。
# 
# 3. `timeout: 10`
# 設定與容器執行時通訊的超時時間，單位是秒。在這個例子中，超時時間被設定為10秒。
# 
# 4. `debug: false`
# 指定是否開啟調式模式。在這個例子中，調式模式被設定為關閉，即`false`。如果設定為`true`，則會輸出更詳細的偵錯資訊。
# 
# 這些引數可以根據需要進行修改，以便與容器執行時進行有效的通訊和管理。

2.2 安裝docker作為Runtime

2.2.1 解壓docker程式

# 二進位制包下載地址：https://download.docker.com/linux/static/stable/x86_64/
# wget https://mirrors.ustc.edu.cn/docker-ce/linux/static/stable/x86_64/docker-24.0.7.tgz

#解壓
tar xf docker-*.tgz 
#拷貝二進位制檔案
cp docker/* /usr/bin/

2.2.2 建立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

2.2.3 準備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 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=2
Restart=always
StartLimitBurst=3
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：指定該服務應該在系統關閉時啟動。
#      這些引數可以根據需要選擇一個或多個，以告知系統在何時啟動該服務。

2.2.4 準備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守護行程進行通訊。

2.2.5 設定加速器

# 設定加速器
mkdir /etc/docker/ -pv
cat >/etc/docker/daemon.json <<EOF
{
  "exec-opts": ["native.cgroupdriver=systemd"],
  "registry-mirrors": [
    "https://docker.mirrors.ustc.edu.cn"
  ],
  "max-concurrent-downloads": 10,
  "log-driver": "json-file",
  "log-level": "warn",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
    },
  "data-root": "/var/lib/docker"
}
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。

2.2.6 啟動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
#驗證

2.2.7 解壓cri-docker

# 由於1.24以及更高版本不支援docker所以安裝cri-docker
# 下載cri-docker 
# https://github.com/Mirantis/cri-dockerd/releases/
# wget  https://mirrors.chenby.cn/https://github.com/Mirantis/cri-dockerd/releases/download/v0.3.7/cri-dockerd-0.3.7.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.2.8 寫入啟動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=3
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啟動。

2.2.9 寫入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單元。

2.2.10 啟動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 docker.service
# 顯示docker.service單元的當前狀態，包括執行狀態、是否啟用等資訊。

2.3.k8s與etcd下載及安裝（僅在master01操作）

2.3.1解壓k8s安裝包

# 下載安裝包
# wget https://mirrors.chenby.cn/https://github.com/etcd-io/etcd/releases/download/v3.5.10/etcd-v3.5.10-linux-amd64.tar.gz
# wget https://dl.k8s.io/v1.28.0/kubernetes-server-linux-amd64.tar.gz

# 解壓k8s安裝檔案
cd cby
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下內容
ls /usr/local/bin/
containerd               crictl       etcdctl                  kube-proxy
containerd-shim          critest      kube-apiserver           kube-scheduler
containerd-shim-runc-v1  ctd-decoder  kube-controller-manager
containerd-shim-runc-v2  ctr          kubectl
containerd-stress        etcd         kubelet

2.3.2檢視版本

[root@k8s-master01 ~]#  kubelet --version
Kubernetes v1.28.3
[root@k8s-master01 ~]# etcdctl version
etcdctl version: 3.5.10
API version: 3.5
[root@k8s-master01 ~]# 

2.3.3將元件傳送至其他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

2.3建立證書相關檔案

# 請檢視Github倉庫 或者進行獲取已經打好的包
https://github.com/cby-chen/Kubernetes/
https://github.com/cby-chen/Kubernetes/tags
https://github.com/cby-chen/Kubernetes/releases/download/v1.28.3/kubernetes-v1.28.3.tar

3.相關證書生成

# master01節點下載證書生成工具
# wget "https://mirrors.chenby.cn/https://github.com/cloudflare/cfssl/releases/download/v1.6.4/cfssl_1.6.4_linux_amd64" -O /usr/local/bin/cfssl
# wget "https://mirrors.chenby.cn/https://github.com/cloudflare/cfssl/releases/download/v1.6.4/cfssljson_1.6.4_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

3.1.生成etcd證書

特別說明除外，以下操作在所有master節點操作

3.1.1所有master節點建立證書存放目錄

mkdir /etc/etcd/ssl -p

3.1.2master01節點生成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.1.31,192.168.1.32,192.168.1.33,fc00:43f4:1eea:1::10,fc00:43f4:1eea:1::20,fc00:43f4:1eea:1::30,::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.1.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`目錄中包含與本地主機上相同的四個檔案的副本。

3.2.生成k8s相關證書

特別說明除外，以下操作在所有master節點操作

3.2.1 所有k8s節點建立證書存放目錄

mkdir -p /etc/kubernetes/pki

3.2.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.1.36為高可用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.1.36,127.0.0.1,kubernetes,kubernetes.default,kubernetes.default.svc,kubernetes.default.svc.cluster,kubernetes.default.svc.cluster.local,x.oiox.cn,k.oiox.cn,l.oiox.cn,o.oiox.cn,192.168.1.31,192.168.1.32,192.168.1.33,192.168.1.34,192.168.1.35,192.168.1.36,192.168.0.37,192.168.0.38,192.168.0.39,192.168.1.70,fc00:43f4:1eea:1::10,fc00:43f4:1eea:1::20,fc00:43f4:1eea:1::30,fc00:43f4:1eea:1::40,fc00:43f4:1eea:1::50,fc00:43f4:1eea:1::60,fc00:43f4:1eea:1::70,fc00:43f4:1eea:1::80,fc00:43f4:1eea:1::90,fc00:43f4:1eea:1::100,::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.1.36,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.2.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`檔案中。

3.2.4 生成controller-manage的證書

在《5.高可用設定》選擇使用那種高可用方案
若使用 haproxy、keepalived 那麼為 --server=https://192.168.1.36: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.1.36: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資源。

3.2.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.1.36: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叢集中的排程器元件進行互動。

3.2.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.1.36: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叢集中的排程器元件進行互動。

3.2.7 建立kube-proxy證書

在《5.高可用設定》選擇使用那種高可用方案
若使用 haproxy、keepalived 那麼為 --server=https://192.168.1.36: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.1.36: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叢集中的排程器元件進行互動。

3.2.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檔案中。

3.2.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

3.2.10 檢視證書

ls /etc/kubernetes/pki/
admin.csr          controller-manager.csr      kube-proxy.csr
admin-key.pem      controller-manager-key.pem  kube-proxy-key.pem
admin.pem          controller-manager.pem      kube-proxy.pem
apiserver.csr      front-proxy-ca.csr          sa.key
apiserver-key.pem  front-proxy-ca-key.pem      sa.pub
apiserver.pem      front-proxy-ca.pem          scheduler.csr
ca.csr             front-proxy-client.csr      scheduler-key.pem
ca-key.pem         front-proxy-client-key.pem  scheduler.pem
ca.pem             front-proxy-client.pem

# 一共26個就對了
ls /etc/kubernetes/pki/ |wc -l
26

4.k8s系統元件設定

4.1.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`：是否強制建立一個新的叢集。

這些引數和選項可以根據實際需求進行調整和設定。

4.1.1master01設定

# 如果要用IPv6那麼把IPv4地址修改為IPv6即可
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.1.31:2380'
listen-client-urls: 'https://192.168.1.31:2379,http://127.0.0.1:2379'
max-snapshots: 3
max-wals: 5
cors:
initial-advertise-peer-urls: 'https://192.168.1.31:2380'
advertise-client-urls: 'https://192.168.1.31:2379'
discovery:
discovery-fallback: 'proxy'
discovery-proxy:
discovery-srv:
initial-cluster: 'k8s-master01=https://192.168.1.31:2380,k8s-master02=https://192.168.1.32:2380,k8s-master03=https://192.168.1.33: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

4.1.2master02設定

# 如果要用IPv6那麼把IPv4地址修改為IPv6即可
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.1.32:2380'
listen-client-urls: 'https://192.168.1.32:2379,http://127.0.0.1:2379'
max-snapshots: 3
max-wals: 5
cors:
initial-advertise-peer-urls: 'https://192.168.1.32:2380'
advertise-client-urls: 'https://192.168.1.32:2379'
discovery:
discovery-fallback: 'proxy'
discovery-proxy:
discovery-srv:
initial-cluster: 'k8s-master01=https://192.168.1.31:2380,k8s-master02=https://192.168.1.32:2380,k8s-master03=https://192.168.1.33: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

4.1.3master03設定

# 如果要用IPv6那麼把IPv4地址修改為IPv6即可
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.1.33:2380'
listen-client-urls: 'https://192.168.1.33:2379,http://127.0.0.1:2379'
max-snapshots: 3
max-wals: 5
cors:
initial-advertise-peer-urls: 'https://192.168.1.33:2380'
advertise-client-urls: 'https://192.168.1.33:2379'
discovery:
discovery-fallback: 'proxy'
discovery-proxy:
discovery-srv:
initial-cluster: 'k8s-master01=https://192.168.1.31:2380,k8s-master02=https://192.168.1.32:2380,k8s-master03=https://192.168.1.33: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

4.2.建立service（所有master節點操作）

4.2.1建立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服務在系統啟動後自動啟動，並在出現問題時進行重啟。

4.2.2建立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單元的當前狀態，包括執行狀態、是否啟用等資訊。

4.2.3檢視etcd狀態

# 如果要用IPv6那麼把IPv4地址修改為IPv6即可
export ETCDCTL_API=3
etcdctl --endpoints="192.168.1.33:2379,192.168.1.32:2379,192.168.1.31: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
+-------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+
|     ENDPOINT      |        ID        | VERSION | DB SIZE | IS LEADER | IS LEARNER | RAFT TERM | RAFT INDEX | RAFT APPLIED INDEX | ERRORS |
+-------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+
| 192.168.1.33:2379 | 6ae2196f75cd6d95 |   3.5.9 |   20 kB |     false |      false |         2 |          9 |                  9 |        |
| 192.168.1.32:2379 | 46cbf93f7713a252 |   3.5.9 |   20 kB |     false |      false |         2 |          9 |                  9 |        |
| 192.168.1.31:2379 | ec6051ffc7487dd7 |   3.5.9 |   20 kB |      true |      false |         2 |          9 |                  9 |        |
+-------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+

# 這個命令是使用etcdctl工具，用於檢視指定etcd叢集的健康狀態。下面是每個引數的詳細解釋：
# 
# - `--endpoints`：指定要連線的etcd叢集節點的地址和埠。在這個例子中，指定了3個節點的地址和埠，分別是`192.168.1.33:2379,192.168.1.32:2379,192.168.1.31: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伺服器上操作）

注意 5.1.1 和5.1.2 二選一即可*

選擇使用那種高可用方案，同時可以倆種都選用，實現內外兼顧的效果，比如：
5.1 的 NGINX方案實現叢集內的高可用
5.2 的 haproxy、keepalived 方案實現叢集外存取

在《3.2.生成k8s相關證書》

若使用 nginx方案，那麼為 --server=https://127.0.0.1:8443
若使用 haproxy、keepalived 那麼為 --server=https://192.168.1.36:9443

5.1 NGINX高可用方案

5.1.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伺服器，並將其安裝到系統中。

5.1.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.1.31:6443        max_fails=3 fail_timeout=30s;
        server 192.168.1.32:6443        max_fails=3 fail_timeout=30s;
        server 192.168.1.33: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單元的當前狀態，包括執行狀態、是否啟用等資訊。

5.2 keepalived和haproxy 高可用方案

5.2.1安裝keepalived和haproxy服務

systemctl disable --now firewalld
setenforce 0
sed -i 's#SELINUX=enforcing#SELINUX=disabled#g' /etc/selinux/config
yum -y install keepalived haproxy

5.2.2修改haproxy組態檔（組態檔一樣）

# cp /etc/haproxy/haproxy.cfg /etc/haproxy/haproxy.cfg.bak

cat >/etc/haproxy/haproxy.cfg<<"EOF"
global
 maxconn 2000
 ulimit-n 16384
 log 127.0.0.1 local0 err
 stats timeout 30s

defaults
 log global
 mode http
 option httplog
 timeout connect 5000
 timeout client 50000
 timeout server 50000
 timeout http-request 15s
 timeout http-keep-alive 15s


frontend monitor-in
 bind *:33305
 mode http
 option httplog
 monitor-uri /monitor

frontend k8s-master
 bind 0.0.0.0:9443
 bind 127.0.0.1:9443
 mode tcp
 option tcplog
 tcp-request inspect-delay 5s
 default_backend k8s-master


backend k8s-master
 mode tcp
 option tcplog
 option tcp-check
 balance roundrobin
 default-server inter 10s downinter 5s rise 2 fall 2 slowstart 60s maxconn 250 maxqueue 256 weight 100
 server  k8s-master01  192.168.1.31:6443 check
 server  k8s-master02  192.168.1.32:6443 check
 server  k8s-master03  192.168.1.33:6443 check
EOF

引數

這段設定程式碼是指定了一個HAProxy負載均衡器的設定。下面對各部分進行詳細解釋：
1. global:
   - maxconn 2000: 設定每個程序的最大連線數為2000。
   - ulimit-n 16384: 設定每個程序的最大檔案描述符數為16384。
   - log 127.0.0.1 local0 err: 指定紀錄檔的輸出地址為本地主機的127.0.0.1，並且只記錄錯誤級別的紀錄檔。
   - stats timeout 30s: 設定檢視負載均衡器統計資訊的超時時間為30秒。

2. defaults:
   - log global: 使預設紀錄檔與global部分相同。
   - mode http: 設定負載均衡器的工作模式為HTTP模式。
   - option httplog: 使負載均衡器記錄HTTP協定的紀錄檔。
   - timeout connect 5000: 設定與後端伺服器建立連線的超時時間為5秒。
   - timeout client 50000: 設定與使用者端的連線超時時間為50秒。
   - timeout server 50000: 設定與後端伺服器連線的超時時間為50秒。
   - timeout http-request 15s: 設定處理HTTP請求的超時時間為15秒。
   - timeout http-keep-alive 15s: 設定保持HTTP連線的超時時間為15秒。

3. frontend monitor-in:
   - bind *:33305: 監聽所有IP地址的33305埠。
   - mode http: 設定frontend的工作模式為HTTP模式。
   - option httplog: 記錄HTTP協定的紀錄檔。
   - monitor-uri /monitor: 設定監控URI為/monitor。

4. frontend k8s-master:
   - bind 0.0.0.0:9443: 監聽所有IP地址的9443埠。
   - bind 127.0.0.1:9443: 監聽本地主機的9443埠。
   - mode tcp: 設定frontend的工作模式為TCP模式。
   - option tcplog: 記錄TCP協定的紀錄檔。
   - tcp-request inspect-delay 5s: 設定在接收到請求後延遲5秒進行檢查。
   - default_backend k8s-master: 設定預設的後端伺服器組為k8s-master。

5. backend k8s-master:
   - mode tcp: 設定backend的工作模式為TCP模式。
   - option tcplog: 記錄TCP協定的紀錄檔。
   - option tcp-check: 啟用TCP檢查功能。
   - balance roundrobin: 使用輪詢演演算法進行負載均衡。
   - default-server inter 10s downinter 5s rise 2 fall 2 slowstart 60s maxconn 250 maxqueue 256 weight 100: 設定預設的伺服器引數。
   - server k8s-master01 192.168.1.31:6443 check: 增加一個名為k8s-master01的伺服器，IP地址為192.168.1.31，埠號為6443，並對其進行健康檢查。
   - server k8s-master02 192.168.1.32:6443 check: 增加一個名為k8s-master02的伺服器，IP地址為192.168.1.32，埠號為6443，並對其進行健康檢查。
   - server k8s-master03 192.168.1.33:6443 check: 增加一個名為k8s-master03的伺服器，IP地址為192.168.1.33，埠號為6443，並對其進行健康檢查。

以上就是這段設定程式碼的詳細解釋。它主要定義了全域性設定、預設設定、前端監聽和後端伺服器組的相關引數和設定。通過這些設定，可以實現負載均衡和監控功能。

5.2.3Master01設定keepalived master節點

#cp /etc/keepalived/keepalived.conf /etc/keepalived/keepalived.conf.bak

cat > /etc/keepalived/keepalived.conf << EOF
! Configuration File for keepalived

global_defs {
    router_id LVS_DEVEL
}
vrrp_script chk_apiserver {
    script "/etc/keepalived/check_apiserver.sh"
    interval 5 
    weight -5
    fall 2
    rise 1
}
vrrp_instance VI_1 {
    state MASTER
    # 注意網路卡名
    interface eth0 
    mcast_src_ip 192.168.1.31
    virtual_router_id 51
    priority 100
    nopreempt
    advert_int 2
    authentication {
        auth_type PASS
        auth_pass K8SHA_KA_AUTH
    }
    virtual_ipaddress {
        192.168.1.36
    }
    track_script {
      chk_apiserver 
} }

EOF

5.2.4Master02設定keepalived backup節點

# cp /etc/keepalived/keepalived.conf /etc/keepalived/keepalived.conf.bak

cat > /etc/keepalived/keepalived.conf << EOF
! Configuration File for keepalived

global_defs {
    router_id LVS_DEVEL
}
vrrp_script chk_apiserver {
    script "/etc/keepalived/check_apiserver.sh"
    interval 5 
    weight -5
    fall 2
    rise 1

}
vrrp_instance VI_1 {
    state BACKUP
    # 注意網路卡名
    interface eth0
    mcast_src_ip 192.168.1.32
    virtual_router_id 51
    priority 80
    nopreempt
    advert_int 2
    authentication {
        auth_type PASS
        auth_pass K8SHA_KA_AUTH
    }
    virtual_ipaddress {
        192.168.1.36
    }
    track_script {
      chk_apiserver 
} }

EOF

5.2.5Master03設定keepalived backup節點

# cp /etc/keepalived/keepalived.conf /etc/keepalived/keepalived.conf.bak

cat > /etc/keepalived/keepalived.conf << EOF
! Configuration File for keepalived

global_defs {
    router_id LVS_DEVEL
}
vrrp_script chk_apiserver {
    script "/etc/keepalived/check_apiserver.sh"
    interval 5 
    weight -5
    fall 2
    rise 1

}
vrrp_instance VI_1 {
    state BACKUP
    # 注意網路卡名
    interface eth0
    mcast_src_ip 192.168.1.33
    virtual_router_id 51
    priority 50
    nopreempt
    advert_int 2
    authentication {
        auth_type PASS
        auth_pass K8SHA_KA_AUTH
    }
    virtual_ipaddress {
        192.168.1.36
    }
    track_script {
      chk_apiserver 
} }

EOF

引數

這是一個用於設定keepalived的組態檔。下面是對每個部分的詳細解釋：

- `global_defs`部分定義了全域性引數。
- `router_id`引數指定了當前路由器的標識，這裡設定為"LVS_DEVEL"。

- `vrrp_script`部分定義了一個VRRP指令碼。`chk_apiserver`是指令碼的名稱，
    - `script`引數指定了指令碼的路徑。該指令碼每5秒執行一次，返回值為0表示服務正常，返回值為1表示服務異常。
    - `weight`引數指定了根據指令碼返回的值來調整優先順序，這裡設定為-5。
    - `fall`引數指定了失敗閾值，當連續2次指令碼返回值為1時認為服務異常。
    - `rise`引數指定了恢復閾值，當連續1次指令碼返回值為0時認為服務恢復正常。

- `vrrp_instance`部分定義了一個VRRP範例。`VI_1`是範例的名稱。
    - `state`引數指定了當前範例的狀態，這裡設定為MASTER表示當前範例是主節點。
    - `interface`引數指定了要監聽的網路卡，這裡設定為eth0。
    - `mcast_src_ip`引數指定了VRRP報文的源IP地址，這裡設定為192.168.1.31。
    - `virtual_router_id`引數指定了虛擬路由器的ID，這裡設定為51。
    - `priority`引數指定了範例的優先順序，優先順序越高（數值越大）越有可能被選為主節點。
    - `nopreempt`引數指定了當主節點失效後不要搶佔身份，即不要自動切換為主節點。
    - `advert_int`引數指定了傳送廣播的間隔時間，這裡設定為2秒。
    - `authentication`部分指定了認證引數
    	- `auth_type`引數指定了認證型別，這裡設定為PASS表示使用密碼認證，
    	- `auth_pass`引數指定了認證密碼，這裡設定為K8SHA_KA_AUTH。
    - `virtual_ipaddress`部分指定了虛擬IP地址，這裡設定為192.168.1.36。
    - `track_script`部分指定了要跟蹤的指令碼，這裡跟蹤了chk_apiserver指令碼。

5.2.6健康檢查指令碼設定（lb主機）

cat >  /etc/keepalived/check_apiserver.sh << EOF
#!/bin/bash

err=0
for k in \$(seq 1 3)
do
    check_code=\$(pgrep haproxy)
    if [[ \$check_code == "" ]]; then
        err=\$(expr \$err + 1)
        sleep 1
        continue
    else
        err=0
        break
    fi
done

if [[ \$err != "0" ]]; then
    echo "systemctl stop keepalived"
    /usr/bin/systemctl stop keepalived
    exit 1
else
    exit 0
fi
EOF

# 給指令碼授權

chmod +x /etc/keepalived/check_apiserver.sh

# 這段指令碼是一個簡單的bash指令碼，主要用來檢查是否有名為haproxy的程序正在執行。
# 
# 指令碼的主要邏輯如下：
# 1. 首先設定一個變數err為0，用來記錄錯誤次數。
# 2. 使用一個迴圈，在迴圈內部執行以下操作：
#    a. 使用pgrep命令檢查是否有名為haproxy的程序在執行。如果不存在該程序，將err加1，並暫停1秒鐘，然後繼續下一次迴圈。
#    b. 如果存在haproxy程序，將err重置為0，並跳出迴圈。
# 3. 檢查err的值，如果不為0，表示檢查失敗，輸出一條錯誤資訊並執行「systemctl stop keepalived」命令停止keepalived程序，並退出指令碼返回1。
# 4. 如果err的值為0，表示檢查成功，退出指令碼返回0。
# 
# 該指令碼的主要作用是檢查是否存在執行中的haproxy程序，如果無法檢測到haproxy程序，將停止keepalived程序並返回錯誤狀態。如果haproxy程序存在，則返回成功狀態。這個指令碼可能是作為一個健康檢查指令碼的一部分，在確保haproxy服務可用的情況下，才繼續執行其他操作。

5.2.7啟動服務

systemctl daemon-reload
# 用於重新載入systemd管理的單位檔案。當你新增或修改了某個單位檔案（如.service檔案、.socket檔案等），需要執行該命令來重新整理systemd對該檔案的設定。
systemctl enable --now haproxy.service
# 啟用並立即啟動haproxy.service單元。haproxy.service是haproxy守護行程的systemd服務單元。
systemctl enable --now keepalived.service
# 啟用並立即啟動keepalived.service單元。keepalived.service是keepalived守護行程的systemd服務單元。
systemctl status haproxy.service
# haproxy.service單元的當前狀態，包括執行狀態、是否啟用等資訊。
systemctl status keepalived.service
# keepalived.service單元的當前狀態，包括執行狀態、是否啟用等資訊。

5.2.8測試高可用

# 能ping同
[root@k8s-node02 ~]# ping 192.168.1.36

# 能telnet存取
[root@k8s-node02 ~]# telnet 192.168.1.36 9443

# 關閉主節點，看vip是否漂移到備節點

6.k8s元件設定

所有k8s節點建立以下目錄

mkdir -p /etc/kubernetes/manifests/ /etc/systemd/system/kubelet.service.d /var/lib/kubelet /var/log/kubernetes

6.1.建立apiserver（所有master節點）

6.1.1master01節點設定

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.1.31 \\
      --service-cluster-ip-range=10.96.0.0/12,fd00:1111::/112  \\
      --service-node-port-range=30000-32767  \\
      --etcd-servers=https://192.168.1.31:2379,https://192.168.1.32:2379,https://192.168.1.33: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

6.1.2master02節點設定

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.1.32 \\
      --service-cluster-ip-range=10.96.0.0/12,fd00:1111::/112  \\
      --service-node-port-range=30000-32767  \\
      --etcd-servers=https://192.168.1.31:2379,https://192.168.1.32:2379,https://192.168.1.33: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

6.1.3master03節點設定

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.1.33 \\
      --service-cluster-ip-range=10.96.0.0/12,fd00:1111::/112  \\
      --service-node-port-range=30000-32767  \\
      --etcd-servers=https://192.168.1.31:2379,https://192.168.1.32:2379,https://192.168.1.33: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

引數

該組態檔是用於定義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.1.31` 廣告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.1.31:2379,https://192.168.1.32:2379,https://192.168.1.33: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提供了必要的引數，以便正確地啟動和執行。

6.1.4啟動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單元的當前狀態，包括執行狀態、是否啟用等資訊。

6.2.設定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

引數

這是一個用於啟動 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 控制器管理器元件。

6.2.1啟動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單元的當前狀態，包括執行狀態、是否啟用等資訊。

6.3.設定kube-scheduler service

6.3.1所有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 排程器元件。

6.3.2啟動並檢視服務狀態

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設定

7.1在master01上設定

# 在《5.高可用設定》選擇使用那種高可用方案
# 若使用 haproxy、keepalived 那麼為 `--server=https://192.168.1.36:8443`
# 若使用 nginx方案，那麼為 `--server=https://127.0.0.1:8443`

cd bootstrap

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 伺服器之間的通訊。請確保路徑和檔名與實際環境中的設定相匹配。

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

7.2檢視叢集狀態，沒問題的話繼續後續操作

# 1.28 版本只能檢視到一個etcd 屬於正常現象
# export ETCDCTL_API=3
# etcdctl --endpoints="192.168.1.33:2379,192.168.1.32:2379,192.168.1.31: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 

# 切記執行，別忘記！！！
kubectl create -f bootstrap.secret.yaml

8.node節點設定

8.1.在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

8.2.kubelet設定

注意 ： 8.2.1 和 8.2.2 需要和 上方 2.1 和 2.2 對應起來

8.2.1當使用docker作為Runtime

cat > /usr/lib/systemd/system/kubelet.service << EOF

[Unit]
Description=Kubernetes Kubelet
Documentation=https://github.com/kubernetes/kubernetes
After=network-online.target firewalld.service 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 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.1.31,2408:822a:245:8c01::fab
[Install]
WantedBy=multi-user.target
EOF

8.2.2當使用Containerd作為Runtime （推薦）

mkdir -p /var/lib/kubelet /var/log/kubernetes /etc/systemd/system/kubelet.service.d /etc/kubernetes/manifests/

# 所有k8s節點設定kubelet service
cat > /usr/lib/systemd/system/kubelet.service << EOF

[Unit]
Description=Kubernetes Kubelet
Documentation=https://github.com/kubernetes/kubernetes
After=network-online.target firewalld.service 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/containerd/containerd.sock  \\
    --node-labels=node.kubernetes.io/node=

[Install]
WantedBy=multi-user.target
EOF

# 這是一個表示 Kubernetes Kubelet 服務的 systemd 單位檔案範例。與之前相比，新增了 After 和 Requires 欄位來指定依賴關係。
# 
# [Unit]
# 
# Description=Kubernetes Kubelet：指定了此單位檔案對應的服務描述資訊為 "Kubernetes Kubelet"。
# Documentation=...：指定了對該服務的檔案連結。
# - After: 說明該服務在哪些其他服務之後啟動，這裡是在網路線上、firewalld服務和containerd服務後啟動。
# - Wants: 說明該服務想要的其他服務，這裡是網路線上服務。
# - Requires: 說明該服務需要的其他服務，這裡是docker.socket和containerd.service。
# [Service]
# 
# ExecStart=/usr/local/bin/kubelet ...：指定了啟動 Kubelet 服務的命令和引數，與之前的範例相同。
# --container-runtime-endpoint=unix:///run/containerd/containerd.sock：修改了容器執行時介面的端點地址，將其更改為使用 containerd 執行時（通過 UNIX 通訊端）。
# [Install]
# 
# WantedBy=multi-user.target：指定了在 multi-user.target 被啟動時，該服務應該被啟用。
# 通過這個單位檔案，你可以設定 Kubelet 服務的啟動引數，並指定了它依賴的 containerd 服務。確保路徑和檔名與你實際環境中的設定相匹配。



# 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 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/containerd/containerd.sock  \\
    --node-labels=node.kubernetes.io/node=  \\
    --node-ip=192.168.1.31,2408:822a:245:8c01::fab
[Install]
WantedBy=multi-user.target
EOF

8.2.3所有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分鐘。

8.2.4啟動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單元的當前狀態，包括執行狀態、是否啟用等資訊。

8.2.5檢視叢集

[root@k8s-master01 ~]# kubectl  get node
NAME           STATUS     ROLES    AGE   VERSION
k8s-master01   Ready    <none>   18s   v1.28.3
k8s-master02   Ready    <none>   16s   v1.28.3
k8s-master03   Ready    <none>   16s   v1.28.3
k8s-node01     Ready    <none>   14s   v1.28.3
k8s-node02     Ready    <none>   14s   v1.28.3
[root@k8s-master01 ~]#

8.2.6檢視容器執行時

[root@k8s-master01 ~]# kubectl describe node | grep Runtime
  Container Runtime Version:  containerd://1.7.8
  Container Runtime Version:  containerd://1.7.8
  Container Runtime Version:  containerd://1.7.8
  Container Runtime Version:  containerd://1.7.8
  Container Runtime Version:  containerd://1.7.8
[root@k8s-master01 ~]# kubectl describe node | grep Runtime
  Container Runtime Version:  docker://24.0.7
  Container Runtime Version:  docker://24.0.7
  Container Runtime Version:  docker://24.0.7
  Container Runtime Version:  docker://24.0.7
  Container Runtime Version:  docker://24.0.7

8.3.kube-proxy設定

8.3.1將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

8.3.2所有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

# 這是一個 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 中的路徑和檔名，確保與你的環境一致。另外，可以根據需求修改其他欄位的值，以滿足你的特定要求。

8.3.3所有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連線的空閒超時時間。

8.3.4啟動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.安裝網路外掛

注意 9.1 和 9.2 二選其一即可，建議在此處建立好快照後在進行操作，後續出問題可以回滾

** centos7 要升級libseccomp 不然 無法安裝網路外掛**

# https://github.com/opencontainers/runc/releases
# 升級runc
# wget https://mirrors.chenby.cn/https://github.com/opencontainers/runc/releases/download/v1.1.10/runc.amd64

install -m 755 runc.amd64 /usr/local/sbin/runc
cp -p /usr/local/sbin/runc  /usr/local/bin/runc
cp -p /usr/local/sbin/runc  /usr/bin/runc

#下載高於2.4以上的包
yum -y install http://rpmfind.net/linux/centos/8-stream/BaseOS/x86_64/os/Packages/libseccomp-2.5.1-1.el8.x86_64.rpm
# 清華源
yum -y install https://mirrors.tuna.tsinghua.edu.cn/centos/8-stream/BaseOS/x86_64/os/Packages/libseccomp-2.5.1-1.el8.x86_64.rpm

#檢視當前版本
[root@k8s-master-1 ~]# rpm -qa | grep libseccomp
libseccomp-2.5.1-1.el8.x86_64

9.1安裝Calico

9.1.1更改calico網段

wget https://mirrors.chenby.cn/https://github.com/projectcalico/calico/blob/master/manifests/calico-typha.yaml

cp calico-typha.yaml calico.yaml
cp calico-typha.yaml calico-ipv6.yaml

vim calico.yaml
# calico-config ConfigMap處
    "ipam": {
        "type": "calico-ipam",
    },
    - name: IP
      value: "autodetect"

    - name: CALICO_IPV4POOL_CIDR
      value: "172.16.0.0/12"

# vim calico-ipv6.yaml
# calico-config ConfigMap處
    "ipam": {
        "type": "calico-ipam",
        "assign_ipv4": "true",
        "assign_ipv6": "true"
    },
    - name: IP
      value: "autodetect"

    - name: IP6
      value: "autodetect"

    - name: CALICO_IPV4POOL_CIDR
      value: "172.16.0.0/12"

    - name: CALICO_IPV6POOL_CIDR
      value: "fc00:2222::/112"

    - name: FELIX_IPV6SUPPORT
      value: "true"


# 若docker映象拉不下來，可以使用國內的倉庫
sed -i "s#docker.io/calico/#m.daocloud.io/docker.io/calico/#g" calico.yaml 
sed -i "s#docker.io/calico/#m.daocloud.io/docker.io/calico/#g" calico-ipv6.yaml

sed -i "s#m.daocloud.io/docker.io/calico/#docker.io/calico/#g" calico.yaml 
sed -i "s#m.daocloud.io/docker.io/calico/#docker.io/calico/#g" calico-ipv6.yaml

sed -i "s#docker.io/#docker.oiox.cn/#g" cby.yaml 


# 本地沒有公網 IPv6 使用 calico.yaml
kubectl apply -f calico.yaml

# 本地有公網 IPv6 使用 calico-ipv6.yaml 
# kubectl apply -f calico-ipv6.yaml 

9.1.2檢視容器狀態

# calico 初始化會很慢 需要耐心等待一下，大約十分鐘左右
[root@k8s-master01 ~]# kubectl  get pod -A
NAMESPACE     NAME                                       READY   STATUS    RESTARTS   AGE
kube-system   calico-kube-controllers-6747f75cdc-fbvvc   1/1     Running   0          61s
kube-system   calico-node-fs7hl                          1/1     Running   0          61s
kube-system   calico-node-jqz58                          1/1     Running   0          61s
kube-system   calico-node-khjlg                          1/1     Running   0          61s
kube-system   calico-node-wmf8q                          1/1     Running   0          61s
kube-system   calico-node-xc6gn                          1/1     Running   0          61s
kube-system   calico-typha-6cdc4b4fbc-57snb              1/1     Running   0          61s

9.2 安裝cilium

9.2.1 安裝helm

# [root@k8s-master01 ~]# curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
# [root@k8s-master01 ~]# chmod 700 get_helm.sh
# [root@k8s-master01 ~]# ./get_helm.sh

wget https://mirrors.huaweicloud.com/helm/v3.13.2/helm-v3.13.2-linux-amd64.tar.gz
tar xvf helm-*-linux-amd64.tar.gz
cp linux-amd64/helm /usr/local/bin/

9.2.2 安裝cilium

# 新增源
helm repo add cilium https://helm.cilium.io

# 修改為國內源
helm pull cilium/cilium
tar xvf cilium-*.tgz
cd cilium/
sed -i "s#quay.io/#m.daocloud.io/quay.io/#g" values.yaml

# 預設引數安裝
helm install  cilium ./cilium/ -n kube-system

# 啟用ipv6
# helm install cilium cilium/cilium --namespace kube-system --set ipv6.enabled=true

# 啟用路由資訊和監控外掛
# helm install cilium cilium/cilium --namespace kube-system --set hubble.relay.enabled=true --set hubble.ui.enabled=true --set prometheus.enabled=true --set operator.prometheus.enabled=true --set hubble.enabled=true --set hubble.metrics.enabled="{dns,drop,tcp,flow,port-distribution,icmp,http}" 

9.2.3 檢視

[root@k8s-master01 ~]# kubectl  get pod -A | grep cil
kube-system   cilium-gmr6c                       1/1     Running       0             5m3s
kube-system   cilium-kzgdj                       1/1     Running       0             5m3s
kube-system   cilium-operator-69b677f97c-6pw4k   1/1     Running       0             5m3s
kube-system   cilium-operator-69b677f97c-xzzdk   1/1     Running       0             5m3s
kube-system   cilium-q2rnr                       1/1     Running       0             5m3s
kube-system   cilium-smx5v                       1/1     Running       0             5m3s
kube-system   cilium-tdjq4                       1/1     Running       0             5m3s
[root@k8s-master01 ~]#

9.2.4 下載專屬監控面板

安裝時候沒有建立 監控可以忽略

[root@k8s-master01 yaml]# wget https://mirrors.chenby.cn/https://raw.githubusercontent.com/cilium/cilium/1.12.1/examples/kubernetes/addons/prometheus/monitoring-example.yaml

[root@k8s-master01 yaml]# sed -i "s#docker.io/#m.daocloud.io/docker.io/#g" monitoring-example.yaml

[root@k8s-master01 yaml]# kubectl  apply -f monitoring-example.yaml
namespace/cilium-monitoring created
serviceaccount/prometheus-k8s created
configmap/grafana-config created
configmap/grafana-cilium-dashboard created
configmap/grafana-cilium-operator-dashboard created
configmap/grafana-hubble-dashboard created
configmap/prometheus created
clusterrole.rbac.authorization.k8s.io/prometheus created
clusterrolebinding.rbac.authorization.k8s.io/prometheus created
service/grafana created
service/prometheus created
deployment.apps/grafana created
deployment.apps/prometheus created
[root@k8s-master01 yaml]#

9.2.5 下載部署測試用例

說明 測試用例 需要在 安裝CoreDNS 之後即可完成

wget https://mirrors.chenby.cn/https://raw.githubusercontent.com/cilium/cilium/master/examples/kubernetes/connectivity-check/connectivity-check.yaml

sed -i "s#google.com#baidu.cn#g" connectivity-check.yaml
sed -i "s#quay.io/#m.daocloud.io/quay.io/#g" connectivity-check.yaml

kubectl  apply -f connectivity-check.yaml

9.2.6 檢視pod

[root@k8s-master01 yaml]# kubectl  get pod -A
NAMESPACE           NAME                                                     READY   STATUS    RESTARTS      AGE
cilium-monitoring   grafana-59957b9549-6zzqh                                 1/1     Running   0             10m
cilium-monitoring   prometheus-7c8c9684bb-4v9cl                              1/1     Running   0             10m
default             chenby-75b5d7fbfb-7zjsr                                  1/1     Running   0             27h
default             chenby-75b5d7fbfb-hbvr8                                  1/1     Running   0             27h
default             chenby-75b5d7fbfb-ppbzg                                  1/1     Running   0             27h
default             echo-a-6799dff547-pnx6w                                  1/1     Running   0             10m
default             echo-b-fc47b659c-4bdg9                                   1/1     Running   0             10m
default             echo-b-host-67fcfd59b7-28r9s                             1/1     Running   0             10m
default             host-to-b-multi-node-clusterip-69c57975d6-z4j2z          1/1     Running   0             10m
default             host-to-b-multi-node-headless-865899f7bb-frrmc           1/1     Running   0             10m
default             pod-to-a-allowed-cnp-5f9d7d4b9d-hcd8x                    1/1     Running   0             10m
default             pod-to-a-denied-cnp-65cc5ff97b-2rzb8                     1/1     Running   0             10m
default             pod-to-a-dfc64f564-p7xcn                                 1/1     Running   0             10m
default             pod-to-b-intra-node-nodeport-677868746b-trk2l            1/1     Running   0             10m
default             pod-to-b-multi-node-clusterip-76bbbc677b-knfq2           1/1     Running   0             10m
default             pod-to-b-multi-node-headless-698c6579fd-mmvd7            1/1     Running   0             10m
default             pod-to-b-multi-node-nodeport-5dc4b8cfd6-8dxmz            1/1     Running   0             10m
default             pod-to-external-1111-8459965778-pjt9b                    1/1     Running   0             10m
default             pod-to-external-fqdn-allow-google-cnp-64df9fb89b-l9l4q   1/1     Running   0             10m
kube-system         cilium-7rfj6                                             1/1     Running   0             56s
kube-system         cilium-d4cch                                             1/1     Running   0             56s
kube-system         cilium-h5x8r                                             1/1     Running   0             56s
kube-system         cilium-operator-5dbddb6dbf-flpl5                         1/1     Running   0             56s
kube-system         cilium-operator-5dbddb6dbf-gcznc                         1/1     Running   0             56s
kube-system         cilium-t2xlz                                             1/1     Running   0             56s
kube-system         cilium-z65z7                                             1/1     Running   0             56s
kube-system         coredns-665475b9f8-jkqn8                                 1/1     Running   1 (36h ago)   36h
kube-system         hubble-relay-59d8575-9pl9z                               1/1     Running   0             56s
kube-system         hubble-ui-64d4995d57-nsv9j                               2/2     Running   0             56s
kube-system         metrics-server-776f58c94b-c6zgs                          1/1     Running   1 (36h ago)   37h
[root@k8s-master01 yaml]#

9.2.7 修改為NodePort

安裝時候沒有建立 監控可以忽略

[root@k8s-master01 yaml]# kubectl  edit svc  -n kube-system hubble-ui
service/hubble-ui edited
[root@k8s-master01 yaml]#
[root@k8s-master01 yaml]# kubectl  edit svc  -n cilium-monitoring grafana
service/grafana edited
[root@k8s-master01 yaml]#
[root@k8s-master01 yaml]# kubectl  edit svc  -n cilium-monitoring prometheus
service/prometheus edited
[root@k8s-master01 yaml]#

type: NodePort

9.2.8 檢視埠

安裝時候沒有建立 監控可以忽略

[root@k8s-master01 yaml]# kubectl get svc -A | grep monit
cilium-monitoring   grafana                NodePort    10.100.250.17    <none>        3000:30707/TCP           15m
cilium-monitoring   prometheus             NodePort    10.100.131.243   <none>        9090:31155/TCP           15m
[root@k8s-master01 yaml]#
[root@k8s-master01 yaml]# kubectl get svc -A | grep hubble
kube-system         hubble-metrics         ClusterIP   None             <none>        9965/TCP                 5m12s
kube-system         hubble-peer            ClusterIP   10.100.150.29    <none>        443/TCP                  5m12s
kube-system         hubble-relay           ClusterIP   10.109.251.34    <none>        80/TCP                   5m12s
kube-system         hubble-ui              NodePort    10.102.253.59    <none>        80:31219/TCP             5m12s
[root@k8s-master01 yaml]#

9.2.9 存取

安裝時候沒有建立 監控可以忽略

http://192.168.1.31:30707
http://192.168.1.31:31155
http://192.168.1.31:31219

10.安裝CoreDNS

10.1以下步驟只在master01操作

10.1.1修改檔案

# 下載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: {}
---

# 修改為國內源 docker源可選
sed -i "s#coredns/#m.daocloud.io/docker.io/coredns/#g" values.yaml
sed -i "s#registry.k8s.io/#m.daocloud.io/registry.k8s.io/#g" values.yaml

# 預設引數安裝
helm install  coredns ./coredns/ -n kube-system

11.安裝Metrics Server

11.1以下步驟只在master01操作

11.1.1安裝Metrics-server

在新版的Kubernetes中系統資源的採集均使用Metrics-server，可以通過Metrics採集節點和Pod的記憶體、磁碟、CPU和網路的使用率

# 下載 
wget https://mirrors.chenby.cn/https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

# 修改設定
vim components.yaml

---
# 1
defaultArgs:
        - --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/#m.daocloud.io/registry.k8s.io/#g" *.yaml

# 執行部署
kubectl apply -f components.yaml

11.1.2稍等片刻檢視狀態

kubectl  top node
NAME           CPU(cores)   CPU%   MEMORY(bytes)   MEMORY%   
k8s-master01   197m         4%     1497Mi          39%       
k8s-master02   152m         3%     1315Mi          34%       
k8s-master03   112m         2%     1274Mi          33%       
k8s-node01     142m         3%     777Mi           20%       
k8s-node02     71m          1%     682Mi           17% 

12.叢集驗證

12.1部署pod資源

cat<<EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: busybox
  namespace: default
spec:
  containers:
  - name: busybox
    image: docker.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

12.2用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

12.3測試跨名稱空間是否可以解析

# 檢視有那些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-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]# 

12.4每個節點都必須要能存取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

12.5Pod和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.1.34     k8s-node01     <none>           <none>
calico-node-hlz7j                          1/1     Running   0          38m     192.168.1.32     k8s-master02   <none>           <none>
calico-node-jtlck                          1/1     Running   0          38m     192.168.1.33     k8s-master03   <none>           <none>
calico-node-lxfkf                          1/1     Running   0          38m     192.168.1.35     k8s-node02     <none>           <none>
calico-node-t667x                          1/1     Running   0          38m     192.168.1.31     k8s-master01   <none>           <none>
calico-typha-59d75c5dd4-gbhfp              1/1     Running   0          38m     192.168.1.35     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.1.34
PING 192.168.1.34 (192.168.1.34): 56 data bytes
64 bytes from 192.168.1.34: seq=0 ttl=63 time=0.358 ms
64 bytes from 192.168.1.34: seq=1 ttl=63 time=0.668 ms
64 bytes from 192.168.1.34: seq=2 ttl=63 time=0.637 ms
64 bytes from 192.168.1.34: seq=3 ttl=63 time=0.624 ms
64 bytes from 192.168.1.34: seq=4 ttl=63 time=0.907 ms

# 可以連通證明這個pod是可以跨名稱空間和跨主機通訊的

12.6建立三個副本，可以看到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: nginx
        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

helm repo add kubernetes-dashboard https://kubernetes.github.io/dashboard/
helm install kubernetes-dashboard kubernetes-dashboard/kubernetes-dashboard --namespace kube-system

13.1更改dashboard的svc為NodePort，如果已是請忽略

kubectl edit svc kubernetes-dashboard -n kube-system
  type: NodePort

13.2檢視埠號

kubectl get svc kubernetes-dashboard -n kube-system
NAME                   TYPE       CLUSTER-IP       EXTERNAL-IP   PORT(S)         AGE
kubernetes-dashboard   NodePort   10.108.120.110   <none>        443:30034/TCP   34s

13.3建立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
eyJhbGciOiJSUzI1NiIsImtpZCI6InN2LWdkMV9lZExCVVNrSTJTT2daQm1sczY5ajVZLWI2ZW5BeGItTWJmdlkifQ.eyJhdWQiOlsiaHR0cHM6Ly9rdWJlcm5ldGVzLmRlZmF1bHQuc3ZjLmNsdXN0ZXIubG9jYWwiXSwiZXhwIjoxNjk5NjM1MzY2LCJpYXQiOjE2OTk2MzE3NjYsImlzcyI6Imh0dHBzOi8va3ViZXJuZXRlcy5kZWZhdWx0LnN2Yy5jbHVzdGVyLmxvY2FsIiwia3ViZXJuZXRlcy5pbyI6eyJuYW1lc3BhY2UiOiJrdWJlLXN5c3RlbSIsInNlcnZpY2VhY2NvdW50Ijp7Im5hbWUiOiJhZG1pbi11c2VyIiwidWlkIjoiMDczMTkzYjYtMTgwNi00YzI0LThhZWItZDZhODU4MmYwYTI5In19LCJuYmYiOjE2OTk2MzE3NjYsInN1YiI6InN5c3RlbTpzZXJ2aWNlYWNjb3VudDprdWJlLXN5c3RlbTphZG1pbi11c2VyIn0.j0Yg-iEWNqofkgs0ZZ7J3kCXWkTak-wQFi3YojkqXOfRojwe3ePsfz2AW27uKZRj63u29ZCW2jfFRPb6DKCGp7deg3_xumxPmZ-3RFps7x9itafPpu0-2lJCWOzEdwTCjAeyENhfy_Km0gW5Wf1wpioA71NXAvEtEnZiM88xB3zlF7c1AQHZF0nvtLEre9rkopuw17fUng5owXZMPQVJCiciHWON19fBjKMawYLeZnux5YVgERbcqXQt7r3g3TT6Ws-hWw2Cd5g1W8rCBMfD9aVyZUvpRI5CdOBuoBooVQRYYhfcgyy4cciDuiRSkuRcr8pA4vGes8PM-y6F4bgheA

13.3登入dashboard

https://192.168.1.31:30034/

14.ingress安裝

14.1執行部署

wget https://mirrors.chenby.cn/https://raw.githubusercontent.com/kubernetes/ingress-nginx/main/deploy/static/provider/cloud/deploy.yaml

# 修改為國內源 docker源可選
sed -i "s#registry.k8s.io/#m.daocloud.io/registry.k8s.io/#g" *.yaml

cat > backend.yaml << EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: default-http-backend
  labels:
    app.kubernetes.io/name: default-http-backend
  namespace: kube-system
spec:
  replicas: 1
  selector:
    matchLabels:
      app.kubernetes.io/name: default-http-backend
  template:
    metadata:
      labels:
        app.kubernetes.io/name: default-http-backend
    spec:
      terminationGracePeriodSeconds: 60
      containers:
      - name: default-http-backend
        image: registry.cn-hangzhou.aliyuncs.com/chenby/defaultbackend-amd64:1.5 
        livenessProbe:
          httpGet:
            path: /healthz
            port: 8080
            scheme: HTTP
          initialDelaySeconds: 30
          timeoutSeconds: 5
        ports:
        - containerPort: 8080
        resources:
          limits:
            cpu: 10m
            memory: 20Mi
          requests:
            cpu: 10m
            memory: 20Mi
---
apiVersion: v1
kind: Service
metadata:
  name: default-http-backend
  namespace: kube-system
  labels:
    app.kubernetes.io/name: default-http-backend
spec:
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app.kubernetes.io/name: default-http-backend
EOF

kubectl  apply -f deploy.yaml 
kubectl  apply -f backend.yaml 


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: nginx
        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
---
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: "/nginx"  
        backend:
          service:
            name: nginx-demo
            port:
              number: 8000
EOF

# 等建立完成後在執行：
kubectl  apply -f ingress-demo-app.yaml 

kubectl  get ingress
NAME               CLASS   HOSTS                            ADDRESS     PORTS   AGE
ingress-host-bar   nginx   hello.chenby.cn,demo.chenby.cn   192.168.1.32   80      7s

14.2過濾檢視ingress埠

# 修改為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             NodePort    10.104.231.36    <none>        80:32636/TCP,443:30579/TCP   104s
ingress-nginx          ingress-nginx-controller-admission   ClusterIP   10.101.85.88     <none>        443/TCP                      105s
[root@hello ~/yaml]#

15.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: docker.io/library/nginx
        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 ~]# kubectl  get svc
NAME           TYPE        CLUSTER-IP            EXTERNAL-IP   PORT(S)        AGE
chenby         NodePort    fd00:1111::bc86       <none>        80:31540/TCP   5s
[root@k8s-master01 ~]# 

[root@localhost yaml]# curl -I http://192.168.1.31:31540
HTTP/1.1 200 OK
Server: nginx/1.21.6
Date: Thu, 05 May 2022 10:20:59 GMT
Content-Type: text/html
Content-Length: 615
Last-Modified: Tue, 25 Jan 2022 15:03:52 GMT
Connection: keep-alive
ETag: "61f01158-267"
Accept-Ranges: bytes

[root@localhost yaml]# 

[root@localhost yaml]# curl -I http://[2409:8a10:9e18:9020::10]:31540
HTTP/1.1 200 OK
Server: nginx/1.21.6
Date: Thu, 05 May 2022 10:20:54 GMT
Content-Type: text/html
Content-Length: 615
Last-Modified: Tue, 25 Jan 2022 15:03:52 GMT
Connection: keep-alive
ETag: "61f01158-267"
Accept-Ranges: bytes

16.安裝命令列自動補全功能

yum install bash-completion -y
source /usr/share/bash-completion/bash_completion
source <(kubectl completion bash)
echo "source <(kubectl completion bash)" >> ~/.bashrc

附錄

# 映象加速器可以使用DaoCloud倉庫，替換規則如下
cr.l5d.io/  ===> m.daocloud.io/cr.l5d.io/
docker.elastic.co/  ===> m.daocloud.io/docker.elastic.co/
docker.io/  ===> m.daocloud.io/docker.io/
gcr.io/  ===> m.daocloud.io/gcr.io/
ghcr.io/  ===> m.daocloud.io/ghcr.io/
k8s.gcr.io/  ===> m.daocloud.io/k8s.gcr.io/
mcr.microsoft.com/  ===> m.daocloud.io/mcr.microsoft.com/
nvcr.io/  ===> m.daocloud.io/nvcr.io/
quay.io/  ===> m.daocloud.io/quay.io/
registry.jujucharms.com/  ===> m.daocloud.io/registry.jujucharms.com/
registry.k8s.io/  ===> m.daocloud.io/registry.k8s.io/
registry.opensource.zalan.do/  ===> m.daocloud.io/registry.opensource.zalan.do/
rocks.canonical.com/  ===> m.daocloud.io/rocks.canonical.com/




# 映象版本要自行檢視，因為映象版本是隨時更新的，檔案無法做到實時更新

# docker pull 映象

docker pull registry.cn-hangzhou.aliyuncs.com/chenby/cni:master 
docker pull registry.cn-hangzhou.aliyuncs.com/chenby/node:master
docker pull registry.cn-hangzhou.aliyuncs.com/chenby/kube-controllers:master
docker pull registry.cn-hangzhou.aliyuncs.com/chenby/typha:master
docker pull registry.cn-hangzhou.aliyuncs.com/chenby/coredns:v1.10.0
docker pull registry.cn-hangzhou.aliyuncs.com/chenby/pause:3.6
docker pull registry.cn-hangzhou.aliyuncs.com/chenby/metrics-server:v0.5.2
docker pull kubernetesui/dashboard:v2.7.0
docker pull kubernetesui/metrics-scraper:v1.0.8
docker pull quay.io/cilium/cilium:v1.12.6
docker pull quay.io/cilium/certgen:v0.1.8
docker pull quay.io/cilium/hubble-relay:v1.12.6
docker pull quay.io/cilium/hubble-ui-backend:v0.9.2
docker pull quay.io/cilium/hubble-ui:v0.9.2
docker pull quay.io/cilium/cilium-etcd-operator:v2.0.7
docker pull quay.io/cilium/operator:v1.12.6
docker pull quay.io/cilium/clustermesh-apiserver:v1.12.6
docker pull quay.io/coreos/etcd:v3.5.4
docker pull quay.io/cilium/startup-script:d69851597ea019af980891a4628fb36b7880ec26

# docker 儲存映象
docker save registry.cn-hangzhou.aliyuncs.com/chenby/cni:master -o cni.tar 
docker save registry.cn-hangzhou.aliyuncs.com/chenby/node:master -o node.tar 
docker save registry.cn-hangzhou.aliyuncs.com/chenby/typha:master -o typha.tar 
docker save registry.cn-hangzhou.aliyuncs.com/chenby/kube-controllers:master -o kube-controllers.tar 
docker save registry.cn-hangzhou.aliyuncs.com/chenby/coredns:v1.10.0 -o coredns.tar 
docker save registry.cn-hangzhou.aliyuncs.com/chenby/pause:3.6 -o pause.tar 
docker save registry.cn-hangzhou.aliyuncs.com/chenby/metrics-server:v0.5.2 -o metrics-server.tar 
docker save kubernetesui/dashboard:v2.7.0 -o dashboard.tar 
docker save kubernetesui/metrics-scraper:v1.0.8 -o metrics-scraper.tar 
docker save quay.io/cilium/cilium:v1.12.6 -o cilium.tar 
docker save quay.io/cilium/certgen:v0.1.8 -o certgen.tar 
docker save quay.io/cilium/hubble-relay:v1.12.6 -o hubble-relay.tar 
docker save quay.io/cilium/hubble-ui-backend:v0.9.2 -o hubble-ui-backend.tar 
docker save quay.io/cilium/hubble-ui:v0.9.2 -o hubble-ui.tar 
docker save quay.io/cilium/cilium-etcd-operator:v2.0.7 -o cilium-etcd-operator.tar 
docker save quay.io/cilium/operator:v1.12.6 -o operator.tar 
docker save quay.io/cilium/clustermesh-apiserver:v1.12.6 -o clustermesh-apiserver.tar 
docker save quay.io/coreos/etcd:v3.5.4 -o etcd.tar 
docker save quay.io/cilium/startup-script:d69851597ea019af980891a4628fb36b7880ec26 -o startup-script.tar 

# 傳輸到各個節點
for NODE in k8s-master01 k8s-master02 k8s-master03 k8s-node01 k8s-node02; do scp -r images/  $NODE:/root/ ; done

# 建立名稱空間
ctr ns create k8s.io

# 匯入映象
ctr --namespace k8s.io image import images/cni.tar
ctr --namespace k8s.io image import images/node.tar
ctr --namespace k8s.io image import images/typha.tar
ctr --namespace k8s.io image import images/kube-controllers.tar 
ctr --namespace k8s.io image import images/coredns.tar 
ctr --namespace k8s.io image import images/pause.tar 
ctr --namespace k8s.io image import images/metrics-server.tar 
ctr --namespace k8s.io image import images/dashboard.tar 
ctr --namespace k8s.io image import images/metrics-scraper.tar 
ctr --namespace k8s.io image import images/dashboard.tar 
ctr --namespace k8s.io image import images/metrics-scraper.tar 
ctr --namespace k8s.io image import images/cilium.tar 
ctr --namespace k8s.io image import images/certgen.tar 
ctr --namespace k8s.io image import images/hubble-relay.tar 
ctr --namespace k8s.io image import images/hubble-ui-backend.tar 
ctr --namespace k8s.io image import images/hubble-ui.tar 
ctr --namespace k8s.io image import images/cilium-etcd-operator.tar 
ctr --namespace k8s.io image import images/operator.tar 
ctr --namespace k8s.io image import images/clustermesh-apiserver.tar 
ctr --namespace k8s.io image import images/etcd.tar 
ctr --namespace k8s.io image import images/startup-script.tar 

# pull tar包 解壓後
helm pull cilium/cilium

# 檢視映象版本
root@hello:~/cilium# cat values.yaml| grep tag: -C1
  repository: "quay.io/cilium/cilium"
  tag: "v1.12.6"
  pullPolicy: "IfNotPresent"
--
    repository: "quay.io/cilium/certgen"
    tag: "v0.1.8@sha256:4a456552a5f192992a6edcec2febb1c54870d665173a33dc7d876129b199ddbd"
    pullPolicy: "IfNotPresent"
--
      repository: "quay.io/cilium/hubble-relay"
      tag: "v1.12.6"
       # hubble-relay-digest
--
        repository: "quay.io/cilium/hubble-ui-backend"
        tag: "v0.9.2@sha256:a3ac4d5b87889c9f7cc6323e86d3126b0d382933bd64f44382a92778b0cde5d7"
        pullPolicy: "IfNotPresent"
--
        repository: "quay.io/cilium/hubble-ui"
        tag: "v0.9.2@sha256:d3596efc94a41c6b772b9afe6fe47c17417658956e04c3e2a28d293f2670663e"
        pullPolicy: "IfNotPresent"
--
    repository: "quay.io/cilium/cilium-etcd-operator"
    tag: "v2.0.7@sha256:04b8327f7f992693c2cb483b999041ed8f92efc8e14f2a5f3ab95574a65ea2dc"
    pullPolicy: "IfNotPresent"
--
    repository: "quay.io/cilium/operator"
    tag: "v1.12.6"
    # operator-generic-digest
--
    repository: "quay.io/cilium/startup-script"
    tag: "d69851597ea019af980891a4628fb36b7880ec26"
    pullPolicy: "IfNotPresent"
--
    repository: "quay.io/cilium/cilium"
    tag: "v1.12.6"
    # cilium-digest
--
      repository: "quay.io/cilium/clustermesh-apiserver"
      tag: "v1.12.6"
      # clustermesh-apiserver-digest
--
        repository: "quay.io/coreos/etcd"
        tag: "v3.5.4@sha256:795d8660c48c439a7c3764c2330ed9222ab5db5bb524d8d0607cac76f7ba82a3"
        pullPolicy: "IfNotPresent"

關於

https://www.oiox.cn/

https://www.oiox.cn/index.php/start-page.html

CSDN、GitHub、知乎、開源中國、思否、掘金、簡書、華為雲、阿里雲、騰訊雲、嗶哩嗶哩、今日頭條、新浪微博、個人部落格

全網可搜《小陳運維》

文章主要釋出於微信公眾號：《Linux運維交流社群》