Kubernetes搭建(高可用)

Kubernetes1.27搭建(高可用)

安装kubernetes工具(所有节点)

这里使用的是centos系统，其他redhat等相同，根据自己的实际环境来操作

根据kubernetes官网，使用官方的指定的repo源，下载kubernetes工具，这里官网指定的配置源为google的镜像源。在国内无法访问（可以通过其他方式解决例如配置代理），也可以使用阿里云的kubernetes的镜像源或者自己找到rpm包做yum源(将依赖和要安装的rpm放在同一目录下使用rpm -Uvh *.rpm 也可)，下载的kubernetes组件的版本正确即可。

[root@localhost ~]# vim /etc/yum.repos.d/kubernetes.repo

[kubernetes]
name=Kubernetes
baseurl=http://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=0
下载kubernetes组件，默认是最新版，所以这里需要指定版本。

[root@localhost ~]# yum install kubeadm-1.27.2 kubectl-1.27.2 kubelet-1.27.2 -y

• #确保下载版本为最新版工具。

转发ipv4流量并让iptables看到桥接流量

所有节点都需要将sysctl所需的配置写入

[root@localhost ~]# vim /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-iptables=1
net.bridge.bridge-nf-call-ip6tables=1
net.ipv4.ip_forward=1
#然后使其生效
[root@localhost ~]# modprobe br_netfilter
[root@localhost ~]# sysctl -p /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-iptables = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward = 1

关闭交换分区
为确保kubernetes性能，所有节点都需要关闭交换分区，注释掉交换分区。

[root@localhost ~]# swapoff -a
[root@localhost ~]# vim /etc/fstab

/dev/mapper/centos-root /                       xfs     defaults        0 0
UUID=8c9ec778-e898-4be6-bda9-1600ceee752c /boot                   xfs     defaults        0 0
/dev/mapper/centos-home /home                   xfs     defaults        0 0
#/dev/mapper/centos-swap swap                    swap    defaults        0 0

配置时间同步关闭防火墙
再部署kubernetes集群的时候需要进行时间同步，确保各节点时间的一致性，以确保集群运行中各种时间的顺序正确。例如，在使用kubelet定期检查容器运行状态时，如果时间不一致可能会导致容器内容出现错误。

systemctl stop firewalld
setenforce 0
#上面关闭防火墙，或者开放端口，保证网络连接。
 
[root@localhost ~]# vim /etc/chrony.conf
server (ntp服务器ip) iburst
allow all
local stratum 10
#添加上面配置
[root@localhost ~]# systemctl restart chronyd
[root@localhost ~]# chronyc sources
#上面配置主节点时间同步公网，允许其他节点同步，这里要保持联网多次同步直到出现*号代表同步成功。

[root@localhost ~]# vim /etc/chrony.conf
server 192.168.40.20 iburst
[root@localhost ~]# systemctl restart chronyd
[root@localhost ~]# chronyc sources
210 Number of sources = 1
MS Name/IP address         Stratum Poll Reach LastRx Last sample
===============================================================================
^* 192.168.40.20                2   6    17    23    -20us[  -24us] +/-   65ms
#上面是其他从节点配置同步主节点

开启ipvs

不开启ipvs将会使用iptables，但是效率低，所以官网推荐开启ipvs。ipvs相比iptables将会有更高的服务可靠性和性能。如果不开启无需配置此步骤。

1，支持更多的协议：kubernetes默认的负载均衡方式时iptables，虽然简单易用，但只是支持TCP/UDP协议。而IPVS不仅支持TCP/UDP，还支持SCTP，TCP+SSL等多种协议。
2，与iptables只支持轮询方式不同，IPVS提供了更多钟负载均衡算法，包括轮询，加权轮询等，使得负载均衡更加精细化和灵活。
3，提高服务性能和可靠性：使用 IPVS 能够有效地提高服务的性能和可靠性。使用 IPVS 可以在各个节点上动态地将请求转发到可用的 Pod 上，避免单节点故障影响整个服务的问题。
4，降低延迟和网络带宽：使用 IPVS 可以减少 Kubernetes 集群中的网络带宽和延迟，因为请求只需要在节点之间进行转发，而不需要跨节点的通信。

这是在centos中开启ipvs的脚本，该脚本将会在系统启动时自动加载，并使用modprobe加载ipvs的必需模块，需要在每个节点中配置。

[root@localhost ~]# yum install ipset ipvsadm -y   #用rpm包安装亦可

[root@localhost ~]# vim /etc/sysconfig/modules/ipvs.modules
modprobe -- ip_vs
modprobe -- ip_vs_rr
modprobe -- ip_vs_wrr
modprobe -- ip_vs_sh
modprobe -- nf_conntrack_ipv4

[root@localhost ~]# chmod 755 /etc/sysconfig/modules/ipvs.modules
[root@localhost ~]# bash /etc/sysconfig/modules/ipvs.modules

自启动kubelet

[root@master ~]# systemctl enable kubelet
Created symlink from /etc/systemd/system/multi-user.target.wants/kubelet.service to /usr/lib/systemd/system/kubelet.service.

安装底层容器(所有节点)

根据官方的说法，现在还想使用docker作为kubernetes底层容器，需要cri-dockerd来将docker engine与kubernetes集成，下面会说明。

Docker Engine
Docker Engine 是一款用于构建和运行容器化应用程序的软件。它具有以下特点：

1，简单易用：Docker Engine 提供了一个简单的命令行接口，可以方便地创建、启动、停止和删除容器。
2，轻量级：Docker Engine 容器非常轻量级，可以在几毫秒内启动和停止。
3，可移植性：Docker Engine 容器可以在不同的平台上运行，包括物理机、虚拟机和云环境。
4，可扩展性：Docker Engine 支持通过容器编排工具（如 Kubernetes、Docker Compose 等）进行自动化容器部署、管理和扩缩容等操作。
5，安全性：Docker Engine 提供了一系列安全措施，包括容器隔离、镜像签名和加密等，以确保容器的安全性和稳定性。

Docker Engine和Docker的区别

1，Docker Engine 是 Docker 的核心组件，是用于构建和运行容器化应用程序的基础平台。而普通的 Docker（也称为 Docker 客户端）则是用于与 Docker Engine 进行交互的命令行工具。
2，Docker Engine 包含了 Docker 客户端的所有功能，并且还提供了一系列 API 接口来简化容器管理、镜像管理和网络管理等操作。因此，Docker Engine 更加强大和灵活，可以被用作构建自动化容器化部署和持续集成/持续部署（CI/CD）的基础设施。
3，Docker Engine 可以安装在不同的操作系统上，包括 Linux、Windows 和 macOS 等，而普通的 Docker 则通常只支持运行在 Linux 操作系统上。

安装Docker

在线安装请看Docker安装(在线)

方法可以参照安装Harbor仓库,此处我们采用rpm包安装方式,安装完记得启动

systemctl enable docker --now

修改cgroup方式

/etc/docker/daemon.json 默认没有此文件，需要单独创建，在/etc/docker/daemon.json添加如下内容

cat > /etc/docker/daemon.json << EOF
{
        "exec-opts": ["native.cgroupdriver=systemd"]
}
EOF

# systemctl restart docker

为了实现docker使用的cgroupdriver与kubelet使用的cgroup的一致性，建议修改如下文件内容。

# vim /etc/sysconfig/kubelet
KUBELET_EXTRA_ARGS="--cgroup-driver=systemd"

安装cri-dockerd

先前说过Docker 本身是一个容器运行时（Container Runtime），它负责管理容器的生命周期，包括创建、启动、停止和销毁等操作。然而，Docker 运行时在设计上并不符合 Kubernetes 等容器编排工具的要求，因此需要使用 CRI（Container Runtime Interface）来与容器编排工具进行交互。

根据kubernetes官网给出的方法，使用源代码仓库中说明的方式进行部署。

在官方的仓库中获取最新版本的软件包，然后继续执行以下步骤。这里使用的时cri-dockerd0.3.3的版本，记得每个节点都要配置。https://github.com/Mirantis/cri-dockerd/tags

rpm包安装即可,需要修改一下cri-docker.service文件

vim /usr/lib/systemd/system/cri-docker.service
在service文件中添加
ExecStart=/usr/bin/cri-dockerd --container-runtime-endpoint fd:// --pod-infra-container-image=registry.k8s.io/pause:3.9
#一般指定pause设定在kubelet的配置当中，kubelet会在创建pod前拉取pause镜像，并缓存它后续使用。
#将此参数放在kubelet中更加常见，但是在某些情况下也会将参数配置在cri-dockerd中，例如当使用自定义的cri运行时。

[root@master ~]# systemctl daemon-reload
[root@master ~]# systemctl enable cri-docker
Created symlink from /etc/systemd/system/multi-user.target.wants/cri-docker.service to /etc/systemd/system/cri-docker.service
[root@master ~]# systemctl restart cri-docker

指定kubeadm默认cri

当docker和cri-docker一起安装的时候，docker默认自带containerd的cri所以会导致kubeadm识别到两个cri，每次使用kubeadm都需要指定一下cri，所以干脆修改kubeadm配置文件，使其本身就使用其中一个cri。

找到10-kubeadm.conf配置文件，然后修改配置文件。

[root@master ~]# vim /usr/lib/systemd/system/kubelet.service.d/10-kubeadm.conf
Environment="KUBELET_EXTRA_ARGS=--container-runtime= unix:///run/cri-dockerd.sock"
#添加上面一行内容，sock文件路径根据实际环境设置。
[root@master ~]# systemctl daemon-reload
[root@master ~]# systemctl restart kubelet

外部Etcd集群搭建(一般在master节点)

任意节点执行(外部节点亦可)

下载cfssl并使用

wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64
wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64
wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64
chmod +x cfssl_linux-amd64 cfssljson_linux-amd64 cfssl-certinfo_linux-amd64
mv cfssl_linux-amd64 /usr/local/bin/cfssl ;\
mv cfssljson_linux-amd64 /usr/local/bin/cfssljson ;\
mv cfssl-certinfo_linux-amd64 /usr/bin/cfssl-certinfo

接下来在任意节点(本次在ansible节点)执行

mkdir ssl
cd ssl
# 创建ca-config
cat > ca-config.json <<-eof

{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "www": {
         "expiry": "87600h",
         "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ]
      }
    }
  }
}
eof
# 创建ca-csr
cat > ca-csr.json <<-eof
 
{
    "CN": "etcd CA",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Beijing",
            "ST": "Beijing"
        }
    ]
}
eof

生成ca证书

cfssl gencert -initca ca-csr.json | cfssljson -bare ca -

使用自签ca签发etcd证书

创建证书申请文件

# 注意hosts内容，etcd集群内的ip都要写上，可以预留几个，为以后扩容使用
cat > server-csr.json <<-eof
{
    "CN": "etcd",
    "hosts": [
    "192.168.40.10",
    "192.168.40.20",
    "192.168.40.30"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "BeiJing",
            "ST": "BeiJing"
        }
    ]
}
eof

生成证书

$ cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=www server-csr.json | cfssljson -bare server

会生成server.pem和server-key.pem文件
[root@harbor ssl]# ll |grep server
-rw-r--r-- 1 root root 1013 6月  29 21:31 server.csr
-rw-r--r-- 1 root root  290 6月  29 21:30 server-csr.json
-rw------- 1 root root 1675 6月  29 21:31 server-key.pem
-rw-r--r-- 1 root root 1338 6月  29 21:31 server.pem



在所有etcd(master)节点上执行
mkdir -pv /opt/kubernetes/etcd/{bin,cfg,ssl,data}

然后拷贝过去
for i in `seq 1 3`;do
scp -r ../ssl/* master$i:/opt/kubernetes/etcd/ssl/
done

下载etcd二进制文件

#!/bin/bash
ETCD_VER=v3.5.9

# choose either URL
GOOGLE_URL=https://storage.googleapis.com/etcd
GITHUB_URL=https://github.com/etcd-io/etcd/releases/download
DOWNLOAD_URL=${GOOGLE_URL}

curl -O ${DOWNLOAD_URL}/${ETCD_VER}/etcd-${ETCD_VER}-linux-amd64.tar.gz

解压etcd文件

$ tar xf etcd-v3.5.9-linux-amd64.tar.gz
for i in `seq 1 3`;do
scp etcd-v3.5.9-linux-amd64/{etcd,etcdctl,etcdutl} master$i:/opt/kubernetes/etcd/bin
done

生成etcd配置文件

vim etcd_install.sh

etcd1=192.168.40.10
etcd2=192.168.40.20
etcd3=192.168.40.30

TOKEN=smartgo
ETCDHOSTS=($etcd1 $etcd2 $etcd3)
NAMES=("master1" "master2" "master3")
for i in "${!ETCDHOSTS[@]}"; do
HOST=${ETCDHOSTS[$i]}
NAME=${NAMES[$i]}
cat << EOF > /opt/kubernetes/etcd/cfg/$NAME.conf
# [member]
ETCD_NAME=$NAME
ETCD_DATA_DIR="/opt/kubernetes/etcd/data/default.etcd"
ETCD_LISTEN_PEER_URLS="https://$HOST:2380"
ETCD_LISTEN_CLIENT_URLS="https://$HOST:2379,https://127.0.0.1:2379"
#[cluster]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://$HOST:2380"
ETCD_INITIAL_CLUSTER="${NAMES[0]}=https://${ETCDHOSTS[0]}:2380,${NAMES[1]}=https://${ETCDHOSTS[1]}:2380,${NAMES[2]}=https://${ETCDHOSTS[2]}:2380"
ETCD_INITIAL_CLUSTER_STATE="new"
ETCD_INITIAL_CLUSTER_TOKEN="$TOKEN"
ETCD_ADVERTISE_CLIENT_URLS="https://$HOST:2379"
EOF
done

注释

ETCD_NAME：节点名称，集群中唯一
ETCD_DATA_DIR：数据目录
ETCD_LISTEN_PEER_URLS：集群通信监听地址
ETCD_LISTEN_CLIENT_URLS：客户端访问监听地址
ETCD_INITIAL_ADVERTISE_PEERURLS：集群通告地址
ETCD_ADVERTISE_CLIENT_URLS：客户端通告地址
ETCD_INITIAL_CLUSTER：集群节点地址
ETCD_INITIALCLUSTER_TOKEN：集群Token
ETCD_INITIALCLUSTER_STATE：加入集群的当前状态，new是新集群，existing表示加入已有集群

拷贝到对应服务器

for i in `seq 1 3`;do
scp /opt/kubernetes/etcd/cfg/master$i.conf master$i:/opt/kubernetes/etcd/cfg/etcd.conf
done

所有etcd(master)节点执行

注册服务

$ cat > /etc/systemd/system/etcd.service <<-eof
[Unit]
Description=Etcd Server
After=network.target
After=network-online.target
Wants=network-online.target

[Service]
Type=notify
EnvironmentFile=/opt/kubernetes/etcd/cfg/etcd.conf
ExecStart=/opt/kubernetes/etcd/bin/etcd \
--cert-file=/opt/kubernetes/etcd/ssl/server.pem \
--key-file=/opt/kubernetes/etcd/ssl/server-key.pem \
--peer-cert-file=/opt/kubernetes/etcd/ssl/server.pem \
--peer-key-file=/opt/kubernetes/etcd/ssl/server-key.pem \
--trusted-ca-file=/opt/kubernetes/etcd/ssl/ca.pem \
--peer-trusted-ca-file=/opt/kubernetes/etcd/ssl/ca.pem \
--logger=zap
Restart=on-failure
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
eof

启动etcd

systemctl enable etcd --now

创建命令软链接

for i in `ls /opt/kubernetes/etcd/bin/`;do
ln -s /opt/kubernetes/etcd/bin/$i /usr/bin/$i
done

查看etcd状态

ETCDCTL_API=3 etcdctl --cacert=/opt/kubernetes/etcd/ssl/ca.pem --cert=/opt/kubernetes/etcd/ssl/server.pem --key=/opt/kubernetes/etcd/ssl/server-key.pem --endpoints="https://192.168.40.10:2379,https://192.168.40.20:2379,https://192.168.40.30:2379" endpoint health --write-out=table

etcdctl --cacert=/opt/kubernetes/etcd/ssl/ca.pem --cert=/opt/kubernetes/etcd/ssl/server.pem --key=/opt/kubernetes/etcd/ssl/server-key.pem --endpoints="https://192.168.40.10:2379,https://192.168.40.20:2379,https://192.168.40.30:2379" endpoint status --write-out=table

高可用(Master节点)

安装负载均衡

Kubernetes master 节点运行如下组件：

- kube-apiserver
- kube-scheduler
- kube-controller-manager

kube-scheduler 和 kube-controller-manager 可以以集群模式运行，通过 leader 选举产生一个工作进程，其它进程处于阻塞模式。kube-apiserver可以运行多个实例，但对其它组件需要提供统一的访问地址，该地址需要高可用。

本次部署使用 keepalived+haproxy 实现 kube-apiserver 的VIP 高可用和负载均衡。keepalived 提供 kube-apiserver 对外服务的 VIP高可用。haproxy 监听 VIP，后端连接所有 kube-apiserver 实例，提供健康检查和负载均衡功能。kube-apiserver的端口为6443, 为避免冲突, haproxy 监听的端口要与之不同，此实验中为6444。

keepalived 周期性检查本机的 haproxy 进程状态，如果检测到 haproxy 进程异常，则触发VIP 飘移。 所有组件都通过 VIP 监听的6444端口访问 kube-apiserver 服务。

在此我们使用睿云智合相关镜像，具体使用方法请访问： https://github.com/wise2c-devops 。当然也可以手动配置haproxy以实现apiserver负载均衡，keepalived实现haproxy高可用。

创建 haproxy和 keepalived的启动脚本

# vim haproxy.sh
#!/bin/bash
MasterIP1=192.168.40.10
MasterIP2=192.168.40.20
MasterIP3=192.168.40.30
MasterPort=6443                   # apiserver端口

docker run -d --restart=always --name haproxy-k8s -p 6444:6444 \
           -e MasterIP1=$MasterIP1 \
           -e MasterIP2=$MasterIP2 \
           -e MasterIP3=$MasterIP3 \
           -e MasterPort=$MasterPort  wise2c/haproxy-k8s

-----------------------------------------------------------------
# vim keepalived.sh
#!/bin/bash
VIRTUAL_IP=192.168.40.100         # VIP
INTERFACE=ens33                   # 网卡名称
NETMASK_BIT=24
CHECK_PORT=6444                   # Haproxy端口
RID=10
VRID=160
MCAST_GROUP=224.0.0.18
docker run -itd --restart=always --name=keepalived-k8s \
           --net=host --cap-add=NET_ADMIN \
           -e VIRTUAL_IP=$VIRTUAL_IP \
           -e INTERFACE=$INTERFACE \
           -e NETMASK_BIT=$NETMASK_BIT \
           -e CHECK_PORT=$CHECK_PORT \
           -e RID=$RID -e VRID=$VRID \
           -e MCAST_GROUP=$MCAST_GROUP  wise2c/keepalived-k8s

在所有Master节点执行脚本运行这两个容器

# sh haproxy.sh
# sh keepalived.sh

测试

1).在每台机器上查看容器(haproxy, keepalived)是否都正常运行
2).在每台机器上查看6444端口是否监听
3).在有VIP的机器关闭haproxy容器或keepalived容器看看VIP能否正常飘移

获取kubernetes镜像

根据官网的说法，使用kubeadm工具，获取部署kubernetes集群所需镜像。需要先配置自己的镜像仓库(也可以直接将镜像打包加载)！

[root@node2 images]# kubeadm config images list
W0427 10:30:29.946236   17852 images.go:80] could not find officially supported version of etcd for Kubernetes v1.27.2, falling back to the nearest etcd version (3.5.7-0)
registry.k8s.io/kube-apiserver:v1.27.2
registry.k8s.io/kube-controller-manager:v1.27.2
registry.k8s.io/kube-scheduler:v1.27.2
registry.k8s.io/kube-proxy:v1.27.2
registry.k8s.io/pause:3.9
registry.k8s.io/etcd:3.5.7-0
registry.k8s.io/coredns/coredns:v1.10.1
#然后拉取镜像，这里需要指定cri，因为docker底层有containerd，现在还安装了cri
#当有多个cri的时候kubernetes要求指定其中一个cri，没指定cri报错的时候会告知cri路径。
[root@localhost ~]# kubeadm config images pull --cri-socket= unix:///run/cri-dockerd.sock

此处我选择用一台可以连外网的机器,配置阿里加速源，并指定本地Harbor仓库(不指定端口push时会被加上docker.io/)

[root@download ~]# vim /etc/docker/daemon.json
{
    "registry-mirrors": ["https://registry.cn-qingdao.aliyuncs.com"],
    "insecure-registries": ["http://harbor:80"]
}

[root@download ~]# docker login https://registry.cn-qingdao.aliyuncs.com

直接加载tar文件包的话也可以,还不用改标签

#!/bin/bash
for i in `ls *.tar`;do
	docker load -i $i
done

初始化yaml/yml文件(master1节点执行)

cat > init.yml << EOF
---
apiVersion: kubeadm.k8s.io/v1beta3
bootstrapTokens:
- groups:
  - system:bootstrappers:kubeadm:default-node-token
  token: abcdef.0123456789abcdef
  ttl: 24h0m0s
  usages:
  - signing
  - authentication
kind: InitConfiguration
localAPIEndpoint:
  advertiseAddress: 192.168.40.10							# 本机IP
  bindPort: 6443
nodeRegistration:
  criSocket: unix:///var/run/cri-dockerd.sock
---
apiVersion: kubeadm.k8s.io/v1beta3
kind: ClusterConfiguration
kubernetesVersion: 1.27.2									# kubernetes版本
networking:
  dnsDomain: cluster.local
  podSubnet: 10.244.0.0/16									# pod的IP分配
  serviceSubnet: 10.96.0.0/12			
scheduler: {}
apiServerCertSANs:
- 192.168.40.100
controlPlaneEndpoint: "192.168.40.100:6444"					  # VIP和对应端口
etcd:
  external:
    caFile: /opt/kubernetes/etcd/ssl/ca.pem					# 由于配置了etcd的ssl通信,所以这里需
    certFile: /opt/kubernetes/etcd/ssl/server.pem			 # 要配置证书位置
    keyFile: /opt/kubernetes/etcd/ssl/server-key.pem
    endpoints:
       - https://192.168.40.10:2379
       - https://192.168.40.20:2379
       - https://192.168.40.30:2379
    endpoints:                                              # ETCD集群入口
      - https://192.168.40.10:2379
      - https://192.168.40.20:2379
      - https://192.168.40.30:2379
---
apiVersion: kubeproxy.config.k8s.io/v1alpha1
kind: KubeProxyConfiguration
# featureGates:											# 导致kubeproxy一直crashloopbackoff
#  SupportIPVSProxyMode: true
mode: ipvs
---
apiVersion: kubelet.config.k8s.io/v1beta1
authentication:
  anonymous:
    enabled: false
  webhook:
    cacheTTL: 0s
    enabled: true
  x509:
    clientCAFile: /etc/kubernetes/pki/ca.crt
authorization:
  mode: Webhook
  webhook:
    cacheAuthorizedTTL: 0s
    cacheUnauthorizedTTL: 0s
cgroupDriver: systemd
clusterDNS:
- 10.96.0.10
clusterDomain: cluster.local
cpuManagerReconcilePeriod: 0s
evictionPressureTransitionPeriod: 0s
fileCheckFrequency: 0s
healthzBindAddress: 127.0.0.1
healthzPort: 10248
httpCheckFrequency: 0s
imageMinimumGCAge: 0s
kind: KubeletConfiguration
logging:
  flushFrequency: 0
  options:
    json:
      infoBufferSize: "0"
  verbosity: 0
memorySwap: {}
nodeStatusReportFrequency: 0s
nodeStatusUpdateFrequency: 0s
rotateCertificates: true
runtimeRequestTimeout: 0s
shutdownGracePeriod: 0s
shutdownGracePeriodCriticalPods: 0s
staticPodPath: /etc/kubernetes/manifests
streamingConnectionIdleTimeout: 0s
syncFrequency: 0s
volumeStatsAggPeriod: 0s
EOF

然后执行初始化命令

kubeadm init --config init.yml --upload-certs --v=9 | tee kubeadm-init.log
#如果出错了就重置，然后重新构建集群 ：
kubeadm reset --cri-socket=unix:///var/run/cri-dockerd.sock
#因为docker的containerd-cri会和cri-dockerd冲突，所以需要指定。
后续的join命令也要指定--cri-socket=unix:///var/run/cri-dockerd.sock

master:
kubeadm join 192.168.40.100:6444 --token abcdef.0123456789abcdef         --discovery-token-ca-cert-hash sha256:056f01ac455673d48aa7fbb6b7fb21ef92cedf083fe63d23924e3861acd367d3         --control-plane --certificate-key b6239063dd16d5fa275c351f57da81326f17e67ce7adcf0cef5b53bba0d74e4e --cri-socket=unix:///var/run/cri-dockerd.sock

node:
kubeadm join 192.168.40.100:6444 --token abcdef.0123456789abcdef         --discovery-token-ca-cert-hash sha256:056f01ac455673d48aa7fbb6b7fb21ef92cedf083fe63d23924e3861acd367d3 --cri-socket=unix:///var/run/cri-dockerd.sock

在master节点上执行以下命令以使用kubectl命令

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

其余节点也可以拷贝过去执行

拷贝k8s证书到其它主节点

for host in 20 30; do
    scp -r /etc/kubernetes/pki 192.168.40.$host:/etc/kubernetes/
done

将多余的证书删除(master2和3)

[root@master2 ~]# cd /etc/kubernetes/pki/
[root@master2 pki]# rm -rf api*
[root@master2 pki]# rm -rf front-proxy-client.*
[root@master2 pki]# ls
ca.crt  ca.key  front-proxy-ca.crt  front-proxy-ca.key  sa.key  sa.pub

kubernetes命令行补全

(前提)安装了bash-completion-extras
执行 source 命令
source /usr/share/bash-completion/bash_completion
如果想让系统中的所有用户都能拥有命令补全的功能，则执行如下命令
kubectl completion bash | sudo tee /etc/bash_completion.d/kubectl > /dev/null
如果只需要当前用户拥有命令自动补全功能，则执行如下命令
此命令导入 bash 自动补全的命令

echo 'source <(kubectl completion bash)' >> ~/.bashrc
source ~/.bashrc

安装网络插件(calico)

https://raw.githubusercontent.com/projectcalico/calico/v3.25.1/manifests/tigera-operator.yaml
https://raw.githubusercontent.com/projectcalico/calico/v3.25.1/manifests/custom-resources.yaml

下载下来再用kubectl create -f 依次创建
kubectl create -f tigera-operator.yaml
kubectl create -f custom-resources.yaml
custom-resources文件的网络域需要与前面初始化的pod域相同
卡在了docker pull docker.io/calico/pod2daemon-flexvol:v3.25.1(最后也是将镜像直接放到服务器中)

注意,主节点和从节点并不会共享镜像,所以加入从节点时也要将镜像复制一份过去