搭建Kubernetes v1.20二进制集群——单Master和Node组件

前言

本文将介绍如何使用二进制文件手动搭建 Kubernetes v1.20 集群。通过这种方法,我们可以更好地理解 Kubernetes 的内部工作原理,并具备更大的灵活性和控制权。下面将逐步构建 Kubernetes 集群,并进一步了解其各个组件之间的交互和配置。

K8s的CNI网络插件理论请参考:Kubernetes的CNI网络插件介绍-CSDN博客

目录

一、常见的 K8S 部署方式

1. Minikube

2. Kubeadmin

3. 二进制安装部署

二、环境配置

1. 集群节点配置

2. 操作系统初始化配置

3. 部署 docker 引擎

三、部署 etcd 集群

1. 准备签发证书环境

1.1 准备 cfssl 证书生成工具

1.2 创建存放 etcd 证书目录

1.3 上传 etcd-cert.sh 和 etcd.sh

1.4 创建证书私钥目录

1.5 启动 etcd 服务

1.6 创建配置文件证书目录

1.7 拷贝 etcd 文件至其他节点

2. 修改 node02 etcd 配置文件

2.1 修改 etcd 配置文件

2.2 启动 etcd 服务

3. 修改 node03 etcd 配置文件

3.1 修改 etcd 配置文件

3.2 启动 etcd 服务

4. 检查 etcd 群集状态

5. 查看 etcd 集群成员列表

6. 快照与还原

四、部署 Master 组件

1. 上传 master.zip 和 k8s-cert.sh

2. 创建 kubernetes 工作目录

3. 创建 CA证书私钥目录

4. 拷贝证书私钥

5. 上传 kubernetes-server-linux-amd64.tar.gz

6. 拷贝 master 组件

7. 创建 bootstrap token 认证文件

8. 开启 apiserver 服务

9. 启动 scheduler 服务

10. 启动 controller-manager 服务

11. 生成 kubectl 连接集群的 kubeconfig 文件

12. 通过 kubectl 工具查看当前集群组件状态

13. 查看版本信息

五、部署 Worker Node 组件

1. 创建 kubernetes 工作目录

2. 上传 node.zip

2. 准备 kubelet、kube-proxy 文件

2.1 把 kubelet、kube-proxy 拷贝到 node 节点

2.2 上传kubeconfig.sh文件

2.3 拷贝配置文件到 node 节点

2.4 RBAC 授权

3. 启动 kubelet 服务

4. 授权 CSR 请求并签发证书

4.1 检查到 node01 节点的 kubelet 发起的 CSR 请求

4.2 手动批准节点的证书签发请求

4.3 再次查看 Kubernetes 中所有证书签发请求 (CSR) 的列表

4.4 查看节点

5. 添加负载均衡的内核模块

5.1 添加 ip_vs 模块 

5.2 启动 proxy 服务

五、部署 CNI 网络组件

1. 部署 flannel

1.1 上传 cni、flannel 安装包

1.2 node02 节点部署 kubelet、proxy 服务

1.2.1 文件传输

1.2.2 启动 kubelet 服务

1.2.3 签发证书并通过CSR请求

1.2.4 加载 ipvs 模块 

1.2.5 使用proxy.sh脚本启动proxy服务 

1.2.6 查看群集中的节点状态 

1.3 部署 CNI 网络 

1.4 查看集群节点信息 

2. 部署 Calico

2.1 部署 CNI 网络

2.2 查看集群组件状态

六、部署 CoreDNS 

1. 上传 coredns 镜像

2. Master01 节点部署 CoreDNS

3. DNS 解析测试

七、小结


一、常见的 K8S 部署方式

1. Minikube

Minikube是一个工具,可以在本地快速运行一个单节点微型K8S,仅用于学习、预览K8S的一些特性使用。
部署地址:Install Tools | Kubernetes

2. Kubeadmin

Kubeadmin也是一个工具,提供kubeadm init和kubeadm join,用于快速部署K8S集群,相对简单。
Kubeadm | Kubernetes部署地址:Kubeadm | Kubernetes

3. 二进制安装部署

生产首选,从官方下载发行版的二进制包,手动部署每个组件和自签TLS证书,组成K8S集群,新手推荐。
发布 ·Kubernetes/Kubernetes (github.com)部署地址:发布 ·Kubernetes/Kubernetes (github.com)

二、环境配置

1. 集群节点配置

机器内存有限,按需自行分配:

节点名称IP部署组件配置
k8s集群master01192.168.190.100kube-apiserver  kube-controller-manager  kube-scheduler2C/3G
k8s集群master02192.168.190.101kube-apiserver  kube-controller-manager  kube-scheduler2C/3G
k8s集群node01192.168.190.102kubelet  kube-proxy  docker2C/2G
k8s集群node02192.168.190.103kubelet  kube-proxy  docker2C/2G
etcd集群etcd01192.168.190.100etcd
etcd集群etcd02192.168.190.102etcd
etcd集群etcd03192.168.190.103etcd

负载均衡nkmaster

192.168.190.104nginx+keepalive011C/1G
负载均衡nkbackup192.168.190.105nginx+keepalive021C/1G

2. 操作系统初始化配置

① 关闭防火墙及其他规则

所有节点操作:
systemctl stop firewalld
systemctl disable firewalld
iptables -F && iptables -t nat -F && iptables -t mangle -F && iptables -X
# 清空iptables防火墙的规则,包括过滤规则、NAT规则、Mangle规则以及自定义链
setenforce 0
sed -i 's/enforcing/disabled/' /etc/selinux/config

② 关闭 swap

所有节点操作:
swapoff -a
sed -ri 's/.*swap.*/#&/' /etc/fstab 
# 在/etc/fstab文件中找到包含swap的行,并在这些行之前加上#,从而注释掉这些行

③ 根据规划设置主机名

192.168.190.100:
hostnamectl set-hostname master01
192.168.190.101:
hostnamectl set-hostname master02
192.168.190.102:
hostnamectl set-hostname node01
192.168.190.103:
hostnamectl set-hostname node02

④ 在 master01 添加 hosts

cat >> /etc/hosts << EOF
192.168.190.100 master01
192.168.190.101 master02
192.168.190.102 node01
192.168.190.103 node02
EOF

⑤ 调整内核参数

所有节点操作:
cat > /etc/sysctl.d/k8s.conf << EOF
#开启网桥模式,可将网桥的流量传递给iptables链
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
#关闭ipv6协议
net.ipv6.conf.all.disable_ipv6=1
net.ipv4.ip_forward=1
EOF

sysctl --system
# 重新加载内核参数设置

⑥ 时间同步

所有机器均需要同步:
yum install ntpdate -y
ntpdate time.windows.com

3. 部署 docker 引擎

所有 node 节点部署 docker 引擎:

yum install -y yum-utils device-mapper-persistent-data lvm2 
yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo 
yum install -y docker-ce docker-ce-cli containerd.io

systemctl start docker.service
systemctl enable docker.service 

docker --version
Docker version 26.1.2, build 211e74b

三、部署 etcd 集群

etcd 目前默认使用2379端口提供HTTP API服务, 2380端口和peer通信(这两个端口已经被IANA(互联网数字分配机构)官方预留给etcd)。 即etcd默认使用2379端口对外为客户端提供通讯,使用端口2380来进行服务器间内部通讯。

1. 准备签发证书环境

在 master01 节点上操作 

1.1 准备 cfssl 证书生成工具

CFSSL 是 CloudFlare 公司开源的一款 PKI/TLS 工具。CFSSL 包含一个命令行工具和一个用于签名、验证和捆绑 TLS 证书的 HTTP API 服务,使用Go语言编写。

准备cfssl证书生成工具:
[root@master01 ~]# wget https://github.com/cloudflare/cfssl/releases/download/R1.2/cfssl_linux-amd64 -O /usr/local/bin/cfssl
[root@master01 ~]# wget https://github.com/cloudflare/cfssl/releases/download/R1.2/cfssljson_linux-amd64 -O /usr/local/bin/cfssljson
[root@master01 ~]# wget https://github.com/cloudflare/cfssl/releases/download/R1.2/cfssl-certinfo_linux-amd64 -O /usr/local/bin/cfssl-certinfo
[root@master01 ~]# chmod +x /usr/local/bin/cfssl*

# cfssl:证书签发的工具命令
# cfssljson:将 cfssl 生成的证书(json格式)变为文件承载式证书
# cfssl-certinfo:验证证书的信息
# cfssl-certinfo -cert <证书名称>			查看证书的信息

[root@master01 ~]# cd /usr/local/bin/
[root@master01 bin]# ls
cfssl  cfssl-certinfo  cfssljson

1.2 创建存放 etcd 证书目录

[root@master01 ~]# mkdir /opt/k8s
[root@master01 ~]# cd /opt/k8s/

1.3 上传 etcd-cert.sh 和 etcd.sh

到 /opt/k8s/ 目录中

[root@master01 k8s]# rz -E
rz waiting to receive.
[root@master01 k8s]# ls
etcd-cert.sh  etcd.sh
[root@master01 k8s]# chmod +x *.sh

① etcd.sh: 

#!/bin/bash
#example: ./etcd.sh etcd01 192.168.190.100 etcd02=https://192.168.190.102:2380,etcd03=https://192.168.190.103:2380

#创建etcd配置文件/opt/etcd/cfg/etcd
ETCD_NAME=$1
ETCD_IP=$2
ETCD_CLUSTER=$3

WORK_DIR=/opt/etcd

cat > $WORK_DIR/cfg/etcd  <<EOF
#[Member]
ETCD_NAME="${ETCD_NAME}"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://${ETCD_IP}:2380"
ETCD_LISTEN_CLIENT_URLS="https://${ETCD_IP}:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://${ETCD_IP}:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://${ETCD_IP}:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://${ETCD_IP}:2380,${ETCD_CLUSTER}"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
EOF

#Member:成员配置
#ETCD_NAME:节点名称,集群中唯一。成员名字,集群中必须具备唯一性,如etcd01
#ETCD_DATA_DIR:数据目录。指定节点的数据存储目录,这些数据包括节点ID,集群ID,集群初始化配置,Snapshot文件,若未指定-wal-dir,还会存储WAL文件;如果不指定会用缺省目录
#ETCD_LISTEN_PEER_URLS:集群通信监听地址。用于监听其他member发送信息的地址。ip为全0代表监听本机所有接口
#ETCD_LISTEN_CLIENT_URLS:客户端访问监听地址。用于监听etcd客户发送信息的地址。ip为全0代表监听本机所有接口

#Clustering:集群配置
#ETCD_INITIAL_ADVERTISE_PEER_URLS:集群通告地址。其他member使用,其他member通过该地址与本member交互信息。一定要保证从其他member能可访问该地址。静态配置方式下,该参数的value一定要同时在--initial-cluster参数中存在
#ETCD_ADVERTISE_CLIENT_URLS:客户端通告地址。etcd客户端使用,客户端通过该地址与本member交互信息。一定要保证从客户侧能可访问该地址
#ETCD_INITIAL_CLUSTER:集群节点地址。本member使用。描述集群中所有节点的信息,本member根据此信息去联系其他member
#ETCD_INITIAL_CLUSTER_TOKEN:集群Token。用于区分不同集群。本地如有多个集群要设为不同
#ETCD_INITIAL_CLUSTER_STATE:加入集群的当前状态,new是新集群,existing表示加入已有集群。

#创建etcd.service服务管理文件
cat > /usr/lib/systemd/system/etcd.service <<EOF
[Unit]
Description=Etcd Server
After=network.target
After=network-online.target
Wants=network-online.target

[Service]
Type=notify
EnvironmentFile=${WORK_DIR}/cfg/etcd
ExecStart=${WORK_DIR}/bin/etcd \
--cert-file=${WORK_DIR}/ssl/server.pem \
--key-file=${WORK_DIR}/ssl/server-key.pem \
--trusted-ca-file=${WORK_DIR}/ssl/ca.pem \
--peer-cert-file=${WORK_DIR}/ssl/server.pem \
--peer-key-file=${WORK_DIR}/ssl/server-key.pem \
--peer-trusted-ca-file=${WORK_DIR}/ssl/ca.pem \
--logger=zap \
--enable-v2
Restart=on-failure
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
EOF

#--enable-v2:开启 etcd v2 API 接口。当前 flannel 版本不支持 etcd v3 通信
#--logger=zap:使用 zap 日志框架。zap.Logger 是go语言中相对日志库中性能最高的
#--peer开头的配置项用于指定集群内部TLS相关证书(peer 证书),这里全部都使用同一套证书认证
#不带--peer开头的的参数是指定 etcd 服务器TLS相关证书(server 证书),这里全部都使用同一套证书认证

systemctl daemon-reload
systemctl enable etcd
systemctl restart etcd

 ② etcd-cert.sh:

#!/bin/bash
#配置证书生成策略,让 CA 软件知道颁发有什么功能的证书,生成用来签发其他组件证书的根证书
cat > ca-config.json <<EOF
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "www": {
         "expiry": "87600h",
         "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ]
      }
    }
  }
}
EOF

#ca-config.json:可以定义多个 profiles,分别指定不同的过期时间、使用场景等参数;
#后续在签名证书时会使用某个 profile;此实例只有一个 www 模板。
#expiry:指定了证书的有效期,87600h 为10年,如果用默认值一年的话,证书到期后集群会立即宕掉
#signing:表示该证书可用于签名其它证书;生成的 ca.pem 证书中 CA=TRUE;
#key encipherment:表示使用非对称密钥加密,如 RSA 加密;
#server auth:表示client可以用该 CA 对 server 提供的证书进行验证;
#client auth:表示server可以用该 CA 对 client 提供的证书进行验证;
#注意标点符号,最后一个字段一般是没有逗号的。


#-----------------------
#生成CA证书和私钥(根证书和私钥)
#特别说明: cfssl和openssl有一些区别,openssl需要先生成私钥,然后用私钥生成请求文件,最后生成签名的证书和私钥等,但是cfssl可以直接得到请求文件。
cat > ca-csr.json <<EOF
{
    "CN": "etcd",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Beijing",
            "ST": "Beijing"
        }
    ]
}
EOF

#CN:Common Name,浏览器使用该字段验证网站或机构是否合法,一般写的是域名 
#key:指定了加密算法,一般使用rsa(size:2048)
#C:Country,国家
#ST:State,州,省
#L:Locality,地区,城市
#O: Organization Name,组织名称,公司名称
#OU: Organization Unit Name,组织单位名称,公司部门

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

#生成的文件:
#ca-key.pem:根证书私钥
#ca.pem:根证书
#ca.csr:根证书签发请求文件

#cfssl gencert -initca <CSRJSON>:使用 CSRJSON 文件生成生成新的证书和私钥。如果不添加管道符号,会直接把所有证书内容输出到屏幕。
#注意:CSRJSON 文件用的是相对路径,所以 cfssl 的时候需要 csr 文件的路径下执行,也可以指定为绝对路径。
#cfssljson 将 cfssl 生成的证书(json格式)变为文件承载式证书,-bare 用于命名生成的证书文件。


#-----------------------
#生成 etcd 服务器证书和私钥
cat > server-csr.json <<EOF
{
    "CN": "etcd",
    "hosts": [
    "192.168.190.100",
    "192.168.190.102",
    "192.168.190.103"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "BeiJing",
            "ST": "BeiJing"
        }
    ]
}
EOF

#hosts:将所有 etcd 集群节点添加到 host 列表,需要指定所有 etcd 集群的节点 ip 或主机名不能使用网段,新增 etcd 服务器需要重新签发证书。

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

#生成的文件:
#server.csr:服务器的证书请求文件
#server-key.pem:服务器的私钥
#server.pem:服务器的数字签名证书

#-config:引用证书生成策略文件 ca-config.json

1.4 创建证书私钥目录

创建用于生成CA证书、etcd 服务器证书以及私钥的目录

[root@master01 k8s]# mkdir /opt/k8s/etcd-cert
[root@master01 k8s]# mv etcd-cert.sh etcd-cert/
[root@master01 k8s]# cd etcd-cert/

[root@master01 etcd-cert]# ./etcd-cert.sh
# 生成CA证书、etcd 服务器证书以及私钥

[root@master01 etcd-cert]# ls
ca-config.json  ca-csr.json  ca.pem        server.csr       server-key.pem
ca.csr          ca-key.pem   etcd-cert.sh  server-csr.json  server.pem

1.5 启动 etcd 服务

上传 etcd-v3.4.9-linux-amd64.tar.gz 到 /opt/k8s 目录中

[root@master01 etcd-cert]# cd /opt/k8s/
[root@master01 k8s]# https://github.com/etcd-io/etcd/releases/download/v3.4.9/etcd-v3.4.9-linux-amd64.tar.gz
[root@master01 k8s]# rz -E
rz waiting to receive.
[root@master01 k8s]# ls
etcd-cert  etcd.sh  etcd-v3.4.9-linux-amd64.tar.gz
[root@master01 k8s]# tar zxvf etcd-v3.4.9-linux-amd64.tar.gz
[root@master01 k8s]# ls etcd-v3.4.9-linux-amd64
Documentation  etcd  etcdctl  README-etcdctl.md  README.md  READMEv2-etcdctl.md

# etcd就是etcd 服务的启动命令,后面可跟各种启动参数
# etcdctl主要为etcd 服务提供了命令行操作

1.6 创建配置文件证书目录

创建用于存放 etcd 配置文件,命令文件,证书的目录

[root@master01 k8s]# mkdir -p /opt/etcd/{cfg,bin,ssl}
[root@master01 k8s]# cd etcd-v3.4.9-linux-amd64/
[root@master01 etcd-v3.4.9-linux-amd64]# ls
Documentation  etcd  etcdctl  README-etcdctl.md  README.md  READMEv2-etcdctl.md
[root@master01 etcd-v3.4.9-linux-amd64]# mv etcd etcdctl /opt/etcd/bin/
[root@master01 ~]# cp /opt/k8s/etcd-cert/*.pem /opt/etcd/ssl/
[root@master01 ~]# cd /opt/k8s/

[root@master01 k8s]# ./etcd.sh etcd01 192.168.190.100 etcd02=https://192.168.190.102:2380,etcd03=https://192.168.190.103:2380
# 进入卡住状态等待其他节点加入,这里需要三台etcd服务同时启动,如果只启动其中一台后,服务会卡在那里,直到集群中所有etcd节点都已启动,可忽略这个情况

可另外打开一个窗口查看etcd进程是否正常:
ps -ef | grep etcd

1.7 拷贝 etcd 文件至其他节点

把 etcd 相关证书文件、命令文件和服务管理文件全部拷贝到另外两个 etcd 集群节点

[root@master01 k8s]# scp -r /opt/etcd/ root@node01:/opt/
[root@master01 k8s]# scp -r /opt/etcd/ root@node02:/opt/
[root@master01 k8s]# scp /usr/lib/systemd/system/etcd.service root@node01:/usr/lib/systemd/system/
[root@master01 k8s]# scp /usr/lib/systemd/system/etcd.service root@node02:/usr/lib/systemd/system/

2. 修改 node02 etcd 配置文件

2.1 修改 etcd 配置文件

[root@node01 ~]# vim /opt/etcd/cfg/etcd
#[Member]
ETCD_NAME="etcd02"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.190.102:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.190.102:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.190.102:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.190.102:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.190.100:2380,etcd02=https://192.168.190.102:2380,etcd03=https://192.168.190.103:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"

2.2 启动 etcd 服务

[root@node01 ~]# systemctl enable --now etcd.service 
[root@node01 ~]# systemctl status etcd.service
● etcd.service - Etcd Server
   Loaded: loaded (/usr/lib/systemd/system/etcd.service; enabled; vendor preset: disabled)
   Active: active (running) since 一 2024-05-13 15:25:28 CST; 3s ago
 Main PID: 39561 (etcd)

3. 修改 node03 etcd 配置文件

node02 节点上操作

3.1 修改 etcd 配置文件

[root@node02 ~]# vim /opt/etcd/cfg/etcd
#[Member]
ETCD_NAME="etcd03"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.190.103:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.190.103:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.190.103:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.190.103:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.190.100:2380,etcd02=https://192.168.190.102:2380,etcd03=https://192.168.190.103:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"

3.2 启动 etcd 服务

[root@node02 ~]# systemctl enable --now etcd.service 
Created symlink from /etc/systemd/system/multi-user.target.wants/etcd.service to /usr/lib/systemd/system/etcd.service.
[root@node02 ~]# systemctl status etcd.service 
● etcd.service - Etcd Server
   Loaded: loaded (/usr/lib/systemd/system/etcd.service; enabled; vendor preset: disabled)
   Active: active (running) since 一 2024-05-13 15:28:18 CST; 15s ago
 Main PID: 6783 (etcd)

4. 检查 etcd 群集状态

[root@master01 k8s]# ETCDCTL_API=3   /opt/etcd/bin/etcdctl --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem --endpoints="https://192.168.190.100:2379,https://192.168.190.102:2379,https://192.168.190.103:2379" endpoint health --write-out=table
+------------------------------+--------+-------------+-------+
|           ENDPOINT           | HEALTH |    TOOK     | ERROR |
+------------------------------+--------+-------------+-------+
| https://192.168.190.100:2379 |   true | 26.529107ms |       |
| https://192.168.190.102:2379 |   true |  30.65982ms |       |
| https://192.168.190.103:2379 |   true | 34.404428ms |       |
+------------------------------+--------+-------------+-------+
[root@master01 k8s]# ETCDCTL_API=3   /opt/etcd/bin/etcdctl --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem --endpoints="https://192.168.190.100:2379,https://192.168.190.102:2379,https://192.168.190.103:2379" endpoint status --write-out=table
+------------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+
|           ENDPOINT           |        ID        | VERSION | DB SIZE | IS LEADER | IS LEARNER | RAFT TERM | RAFT INDEX | RAFT APPLIED INDEX | ERRORS |
+------------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+
| https://192.168.190.100:2379 | 89d026e8ec4cd7cf |   3.4.9 |   20 kB |      true |      false |       834 |          9 |                  9 |        |
| https://192.168.190.102:2379 | 98639068bd0e31f3 |   3.4.9 |   20 kB |     false |      false |       834 |          9 |                  9 |        |
| https://192.168.190.103:2379 | e8ed9fc61074cf0b |   3.4.9 |   20 kB |     false |      false |       834 |          9 |                  9 |        |
+------------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+

# --cert-file:识别HTTPS端使用SSL证书文件
# --key-file:使用此SSL密钥文件标识HTTPS客户端
# --ca-file:使用此CA证书验证启用https的服务器的证书
# --endpoints:集群中以逗号分隔的机器地址列表
# cluster-health:检查etcd集群的运行状况

5. 查看 etcd 集群成员列表

[root@master01 k8s]# ETCDCTL_API=3   /opt/etcd/bin/etcdctl --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem --endpoints="https://192.168.190.100:2379,https://192.168.190.102:2379,https://192.168.190.103:2379" --write-out=table member list
+------------------+---------+--------+------------------------------+------------------------------+------------+
|        ID        | STATUS  |  NAME  |          PEER ADDRS          |         CLIENT ADDRS         | IS LEARNER |
+------------------+---------+--------+------------------------------+------------------------------+------------+
| 89d026e8ec4cd7cf | started | etcd01 | https://192.168.190.100:2380 | https://192.168.190.100:2379 |      false |
| 98639068bd0e31f3 | started | etcd02 | https://192.168.190.102:2380 | https://192.168.190.102:2379 |      false |
| e8ed9fc61074cf0b | started | etcd03 | https://192.168.190.103:2380 | https://192.168.190.103:2379 |      false |
+------------------+---------+--------+------------------------------+------------------------------+------------+

6. 快照与还原

① 需要将所有 etcd 节点均挂起再进行快照

 ② 同样的,需要将其它正在运行的 etcd 节点均挂起,再进行还原需要的 etcd 节点;即一台一台还原,且还原过程中,其他 etcd 节点挂起。

四、部署 Master 组件

master 组件签发证书。

1. 上传 master.zip 和 k8s-cert.sh

到 /opt/k8s 目录中,解压 master.zip 压缩包,在 master01 节点上操作

[root@master01 ~]# cd /opt/k8s/
[root@master01 k8s]# rz -E
rz waiting to receive.
[root@master01 k8s]# ls
etcd-cert  etcd-v3.4.9-linux-amd64         k8s-cert.sh
etcd.sh    etcd-v3.4.9-linux-amd64.tar.gz  master.zip
[root@master01 k8s]# chmod +x *.sh

2. 创建 kubernetes 工作目录

[root@master01 k8s]# mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs}

3. 创建 CA证书私钥目录

创建用于生成CA证书、相关组件的证书和私钥的目录

[root@master01 k8s]# mkdir /opt/k8s/k8s-cert
[root@master01 k8s]# ls
admin.sh               etcd-cert                etcd-v3.4.9-linux-amd64.tar.gz  master.zip
apiserver.sh           etcd.sh                  k8s-cert                        scheduler.sh
controller-manager.sh  etcd-v3.4.9-linux-amd64  k8s-cert.sh
[root@master01 k8s]# mv k8s-cert.sh /opt/k8s/k8s-cert
[root@master01 k8s]# cd /opt/k8s/k8s-cert/
[root@master01 k8s-cert]# ./k8s-cert.sh  # 生成CA证书、相关组件的证书和私钥
[root@master01 k8s-cert]# ls *pem
admin-key.pem  apiserver-key.pem  ca-key.pem  kube-proxy-key.pem
admin.pem      apiserver.pem      ca.pem      kube-proxy.pem

k8s-cert.sh: 

#!/bin/bash                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
#配置证书生成策略,让 CA 软件知道颁发有什么功能的证书,生成用来签发其他组件证书的根证书
cat > ca-config.json <<EOF
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "kubernetes": {
         "expiry": "87600h",
         "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ]
      }
    }
  }
}
EOF

#生成CA证书和私钥(根证书和私钥)
cat > ca-csr.json <<EOF
{
    "CN": "kubernetes",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Beijing",
            "ST": "Beijing",
            "O": "k8s",
            "OU": "System"
        }
    ]
}
EOF

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


#-----------------------
#生成 apiserver 的证书和私钥(apiserver和其它k8s组件通信使用)
#hosts中将所有可能作为 apiserver 的 ip 添加进去,后面 keepalived 使用的 VIP 也要加入
cat > apiserver-csr.json <<EOF
{
    "CN": "kubernetes",
    "hosts": [
      "10.0.0.1",
      "127.0.0.1",
      "192.168.190.100",
      "192.168.190.101",
      "192.168.190.200",
      "192.168.190.104",
      "192.168.190.105",
      "kubernetes",
      "kubernetes.default",
      "kubernetes.default.svc",
      "kubernetes.default.svc.cluster",
      "kubernetes.default.svc.cluster.local"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "BeiJing",
            "ST": "BeiJing",
            "O": "k8s",
            "OU": "System"
        }
    ]
}
EOF

cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes apiserver-csr.json | cfssljson -bare apiserver


#-----------------------
#生成 kubectl 连接集群的证书和私钥,具有admin权限
cat > admin-csr.json <<EOF
{
  "CN": "admin",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "BeiJing",
      "ST": "BeiJing",
      "O": "system:masters",
      "OU": "System"
    }
  ]
}
EOF

cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes admin-csr.json | cfssljson -bare admin


#-----------------------
#生成 kube-proxy 的证书和私钥
cat > kube-proxy-csr.json <<EOF
{
  "CN": "system:kube-proxy",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "BeiJing",
      "ST": "BeiJing",
      "O": "k8s",
      "OU": "System"
    }
  ]
}
EOF

cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-proxy-csr.json | cfssljson -bare kube-proxy
~                                                                                                                                                

4. 拷贝证书私钥

复制CA证书、apiserver相关证书和私钥到 kubernetes工作目录的 ssl 子目录中

[root@master01 k8s-cert]# cp ca*pem apiserver*pem /opt/kubernetes/ssl/

5. 上传 kubernetes-server-linux-amd64.tar.gz

到 /opt/k8s/ 目录中,解压 kubernetes 压缩包

下载地址:https://github.com/kubernetes/kubernetes/blob/release-1.20/CHANGELOG/CHANGELOG-1.20.md
# 下载一个server包就够了,包含了Master和Worker Node二进制文件
[root@master01 k8s-cert]# cd /opt/k8s/
[root@master01 k8s]# rz -E
rz waiting to receive.
[root@master01 k8s]# ls
admin.sh               etcd.sh                         kubernetes-server-linux-amd64.tar.gz
apiserver.sh           etcd-v3.4.9-linux-amd64         master.zip
controller-manager.sh  etcd-v3.4.9-linux-amd64.tar.gz  scheduler.sh
etcd-cert              k8s-cert
[root@master01 k8s]# tar zxvf kubernetes-server-linux-amd64.tar.gz

6. 拷贝 master 组件

复制master组件的关键命令文件到 kubernetes工作目录的 bin 子目录中

[root@master01 k8s]# cd /opt/k8s/kubernetes/server/bin
[root@master01 bin]# ls
apiextensions-apiserver    kube-controller-manager             kube-proxy.docker_tag
kubeadm                    kube-controller-manager.docker_tag  kube-proxy.tar
kube-aggregator            kube-controller-manager.tar         kube-scheduler
kube-apiserver             kubectl                             kube-scheduler.docker_tag
kube-apiserver.docker_tag  kubelet                             kube-scheduler.tar
kube-apiserver.tar         kube-proxy                          mounter
[root@master01 bin]# cp kube-apiserver kubectl kube-controller-manager kube-scheduler /opt/kubernetes/bin/
[root@master01 bin]# ln -s /opt/kubernetes/bin/* /usr/local/bin/

7. 创建 bootstrap token 认证文件

apiserver 启动时会调用,然后就相当于在集群内创建了一个这个用户,接下来就可以用 RBAC 给他授权。

[root@master01 bin]# cd /opt/k8s/
[root@master01 k8s]# vim token.sh
#!/bin/bash
#获取随机数前16个字节内容,以十六进制格式输出,并删除其中空格
BOOTSTRAP_TOKEN=$(head -c 16 /dev/urandom | od -An -t x | tr -d ' ') 
#生成 token.csv 文件,按照 Token序列号,用户名,UID,用户组 的格式生成
cat > /opt/kubernetes/cfg/token.csv <<EOF
${BOOTSTRAP_TOKEN},kubelet-bootstrap,10001,"system:kubelet-bootstrap"
EOF
[root@master01 k8s]# chmod +x token.sh
[root@master01 k8s]# ./token.sh
[root@master01 k8s]# cat /opt/kubernetes/cfg/token.csv
274f2e00534834783724d7f3a61c7f2e,kubelet-bootstrap,10001,"system:kubelet-bootstrap"

8. 开启 apiserver 服务

二进制文件、token、证书都准备好后,开启 apiserver 服务。

apiserver.sh:

#!/bin/bash
#example: apiserver.sh 192.168.190.100 https://192.168.190.100:2379,https://192.168.190.102:2379,https://192.168.190.103:2379
#创建 kube-apiserver 启动参数配置文件
MASTER_ADDRESS=$1
ETCD_SERVERS=$2

cat >/opt/kubernetes/cfg/kube-apiserver <<EOF
KUBE_APISERVER_OPTS="--logtostderr=false  \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--etcd-servers=${ETCD_SERVERS} \\
--bind-address=${MASTER_ADDRESS} \\
--secure-port=6443 \\
--advertise-address=${MASTER_ADDRESS} \\
--allow-privileged=true \\
--service-cluster-ip-range=10.0.0.0/24 \\
--enable-admission-plugins=NamespaceLifecycle,LimitRanger,ServiceAccount,ResourceQuota,NodeRestriction \\
--authorization-mode=RBAC,Node \\
--enable-bootstrap-token-auth=true \\
--token-auth-file=/opt/kubernetes/cfg/token.csv \\
--service-node-port-range=30000-50000 \\
--kubelet-client-certificate=/opt/kubernetes/ssl/apiserver.pem \\
--kubelet-client-key=/opt/kubernetes/ssl/apiserver-key.pem \\
--tls-cert-file=/opt/kubernetes/ssl/apiserver.pem  \\
--tls-private-key-file=/opt/kubernetes/ssl/apiserver-key.pem \\
--client-ca-file=/opt/kubernetes/ssl/ca.pem \\
--service-account-key-file=/opt/kubernetes/ssl/ca-key.pem \\
--service-account-issuer=api \\
--service-account-signing-key-file=/opt/kubernetes/ssl/apiserver-key.pem \\
--etcd-cafile=/opt/etcd/ssl/ca.pem \\
--etcd-certfile=/opt/etcd/ssl/server.pem \\
--etcd-keyfile=/opt/etcd/ssl/server-key.pem \\
--requestheader-client-ca-file=/opt/kubernetes/ssl/ca.pem \\
--proxy-client-cert-file=/opt/kubernetes/ssl/apiserver.pem \\
--proxy-client-key-file=/opt/kubernetes/ssl/apiserver-key.pem \\
--requestheader-allowed-names=kubernetes \\
--requestheader-extra-headers-prefix=X-Remote-Extra- \\
--requestheader-group-headers=X-Remote-Group \\
--requestheader-username-headers=X-Remote-User \\
--enable-aggregator-routing=true \\
--audit-log-maxage=30 \\
--audit-log-maxbackup=3 \\
--audit-log-maxsize=100 \\
--audit-log-path=/opt/kubernetes/logs/k8s-audit.log"
EOF

#--logtostderr=true:启用日志。输出日志到标准错误控制台,不输出到文件
#--v=4:日志等级。指定输出日志的级别,v=4为调试级别详细输出
#--etcd-servers:etcd集群地址。指定etcd服务器列表(格式://ip:port),逗号分隔
#--bind-address:监听地址。指定 HTTPS 安全接口的监听地址,默认值0.0.0.0
#--secure-port:https安全端口。指定 HTTPS 安全接口的监听端口,默认值6443
#--advertise-address:集群通告地址。通过该 ip 地址向集群其他节点公布 api server 的信息,必须能够被其他节点访问
#--allow-privileged=true:启用授权。允许拥有系统特权的容器运行,默认值false
#--service-cluster-ip-range:Service虚拟IP地址段。指定 Service Cluster IP 地址段
#--enable-admission-plugins:准入控制模块。kuberneres集群的准入控制机制,各控制模块以插件的形式依次生效,集群时必须包含ServiceAccount,运行在认证(Authentication)、授权(Authorization)之后,Admission Control是权限认证链上的最后一环, 对请求API资源对象进行修改和校验
#--authorization-mode:认证授权,启用RBAC授权和节点自管理。在安全端口使用RBAC,Node授权模式,未通过授权的请求拒绝,默认值AlwaysAllow。RBAC是用户通过角色与权限进行关联的模式;Node模式(节点授权)是一种特殊用途的授权模式,专门授权由kubelet发出的API请求,在进行认证时,先通过用户名、用户分组验证是否是集群中的Node节点,只有是Node节点的请求才能使用Node模式授权
#--enable-bootstrap-token-auth:启用TLS bootstrap机制。在apiserver上启用Bootstrap Token 认证
#--token-auth-file=/opt/kubernetes/cfg/token.csv:指定bootstrap token认证文件路径
#--service-node-port-range:指定 Service  NodePort 的端口范围,默认值30000-32767
#–-kubelet-client-xxx:apiserver访问kubelet客户端证书
#--tls-xxx-file:apiserver https证书
#1.20版本必须加的参数:–-service-account-issuer,–-service-account-signing-key-file
#--etcd-xxxfile:连接Etcd集群证书
#–-audit-log-xxx:审计日志
#启动聚合层相关配置:–requestheader-client-ca-file,–proxy-client-cert-file,–proxy-client-key-file,–requestheader-allowed-names,–requestheader-extra-headers-prefix,–requestheader-group-headers,–requestheader-username-headers,–enable-aggregator-routing


#创建 kube-apiserver.service 服务管理文件
cat >/usr/lib/systemd/system/kube-apiserver.service <<EOF
[Unit]
Description=Kubernetes API Server
Documentation=https://github.com/kubernetes/kubernetes

[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-apiserver
ExecStart=/opt/kubernetes/bin/kube-apiserver \$KUBE_APISERVER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable kube-apiserver
systemctl restart kube-apiserver                              

执行脚本:

[root@master01 k8s]# ./apiserver.sh 192.168.190.100 https://192.168.190.100:2379,https://192.168.190.102:2379,https://192.168.190.103:2379
Created symlink from /etc/systemd/system/multi-user.target.wants/kube-apiserver.service to /usr/lib/systemd/system/kube-apiserver.service.
[root@master01 k8s]# ps aux | grep kube-apiserver
[root@master01 k8s]# netstat -natp | grep 6443
tcp        0      0 192.168.190.100:6443    0.0.0.0:*               LISTEN      38425/kube-apiserve 
tcp        0      0 192.168.190.100:57686   192.168.190.100:6443    ESTABLISHED 38425/kube-apiserve 
tcp        0      0 192.168.190.100:6443    192.168.190.100:57686   ESTABLISHED 38425/kube-apiserve 

9. 启动 scheduler 服务

[root@master01 k8s]# ./scheduler.sh
[root@master01 k8s]# ps aux | grep kube-scheduler
root      38559 25.4  1.0 748212 30020 ?        Ssl  22:58   0:02 /opt/kubernetes/bin/kube-scheduler --logtostderr=false --v=2 --log-dir=/opt/kubernetes/logs --leader-elect=true --kubeconfig=/opt/kubernetes/cfg/kube-scheduler.kubeconfig --bind-address=127.0.0.1
root      38570  0.0  0.0 112676   988 pts/2    S+   22:58   0:00 grep --color=auto kube-scheduler

scheduler.sh: 

#!/bin/bash
##创建 kube-scheduler 启动参数配置文件
MASTER_ADDRESS=$1

cat >/opt/kubernetes/cfg/kube-scheduler <<EOF
KUBE_SCHEDULER_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--leader-elect=true \\
--kubeconfig=/opt/kubernetes/cfg/kube-scheduler.kubeconfig \\
--bind-address=127.0.0.1"
EOF

#-–kubeconfig:连接 apiserver 用的配置文件,用于识别 k8s 集群
#--leader-elect=true:当该组件启动多个时,自动启动 leader 选举
#k8s中Controller-Manager和Scheduler的选主逻辑:k8s中的etcd是整个集群所有状态信息的存储,涉及数据的读写和多个etcd之间数据的同步,对数据的一致性要求严格,所以使用较复杂的 raft 算法来选择用于提交数据的主节点。而 apiserver 作为集群入口,本身是无状态的web服务器,多个 apiserver 服务之间直接负载请求并不需要做选主。Controller-Manager 和 Scheduler 作为任务类型的组件,比如 controller-manager 内置的 k8s 各
种资源对象的控制器实时的 watch apiserver 获取对象最新的变化事件做期望状态和实际状态调整,调度器watch未绑定节点的pod做节点选择,显然多个这些任务同时工作是完全没有必要的,所以 controller-manager 和 scheduler 也是需要选主的,但是选主逻辑和 etcd 不一样的,这里只需要保证从多个 controller-manager 和 scheduler 之间选出一个 leader 进入工作状态即可,而无需考虑它们之间的数据一致和同步。


##生成kube-scheduler证书
cd /opt/k8s/k8s-cert/
#创建证书请求文件
cat > kube-scheduler-csr.json << EOF
{
  "CN": "system:kube-scheduler",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "BeiJing",
      "ST": "BeiJing",
      "O": "system:masters",
      "OU": "System"
    }
  ]
}
EOF

#生成证书
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-scheduler-csr.json | cfssljson -bare kube-scheduler

#生成kubeconfig文件
KUBE_CONFIG="/opt/kubernetes/cfg/kube-scheduler.kubeconfig"
KUBE_APISERVER="https://192.168.190.100:6443"

kubectl config set-cluster kubernetes \
  --certificate-authority=/opt/kubernetes/ssl/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=${KUBE_CONFIG}
kubectl config set-credentials kube-scheduler \
  --client-certificate=./kube-scheduler.pem \
  --client-key=./kube-scheduler-key.pem \
  --embed-certs=true \
  --kubeconfig=${KUBE_CONFIG}
kubectl config set-context default \
  --cluster=kubernetes \
  --user=kube-scheduler \
  --kubeconfig=${KUBE_CONFIG}
kubectl config use-context default --kubeconfig=${KUBE_CONFIG}


##创建 kube-scheduler.service 服务管理文件
cat >/usr/lib/systemd/system/kube-scheduler.service <<EOF
[Unit]
Description=Kubernetes Scheduler
Documentation=https://github.com/kubernetes/kubernetes

[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-scheduler
ExecStart=/opt/kubernetes/bin/kube-scheduler \$KUBE_SCHEDULER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable kube-scheduler
systemctl restart kube-scheduler                        

10. 启动 controller-manager 服务

[root@master01 k8s]# ./controller-manager.sh
[root@master01 k8s]# ps aux | grep kube-controller-manager
root      38670 51.2  1.7 815960 51280 ?        Ssl  22:59   0:03 /opt/kubernetes/bin/kube-controller-manager --logtostderr=false --v=2 --log-dir=/opt/kubernetes/logs --leader-elect=true --kubeconfig=/opt/kubernetes/cfg/kube-controller-manager.kubeconfig --bind-address=127.0.0.1 --allocate-node-cidrs=true --cluster-cidr=10.244.0.0/16 --service-cluster-ip-range=10.0.0.0/24 --cluster-signing-cert-file=/opt/kubernetes/ssl/ca.pem --cluster-signing-key-file=/opt/kubernetes/ssl/ca-key.pem --root-ca-file=/opt/kubernetes/ssl/ca.pem --service-account-private-key-file=/opt/kubernetes/ssl/ca-key.pem --cluster-signing-duration=87600h0m0s
root      38681  0.0  0.0 112676   988 pts/2    S+   22:59   0:00 grep --color=auto kube-controller-manager

controller-manager.sh:

#!/bin/bash
##创建 kube-controller-manager 启动参数配置文件
MASTER_ADDRESS=$1

cat >/opt/kubernetes/cfg/kube-controller-manager <<EOF
KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--leader-elect=true \\
--kubeconfig=/opt/kubernetes/cfg/kube-controller-manager.kubeconfig \\
--bind-address=127.0.0.1 \\
--allocate-node-cidrs=true \\
--cluster-cidr=10.244.0.0/16 \\
--service-cluster-ip-range=10.0.0.0/24 \\
--cluster-signing-cert-file=/opt/kubernetes/ssl/ca.pem \\
--cluster-signing-key-file=/opt/kubernetes/ssl/ca-key.pem  \\
--root-ca-file=/opt/kubernetes/ssl/ca.pem \\
--service-account-private-key-file=/opt/kubernetes/ssl/ca-key.pem \\
--cluster-signing-duration=87600h0m0s"
EOF

#––leader-elect:当该组件启动多个时,自动选举(HA)
#-–kubeconfig:连接 apiserver 用的配置文件,用于识别 k8s 集群
#--cluster-cidr=10.244.0.0/16:pod资源的网段,需与pod网络插件的值设置一致。通常,Flannel网络插件的默认为10.244.0.0/16,Calico插件的默认值为192.168.0.0/16
#--cluster-signing-cert-file/–-cluster-signing-key-file:自动为kubelet颁发证书的CA,与apiserver保持一致。指定签名的CA机构根证书,用来签名为 TLS BootStrapping 创建的证书和私钥
#--root-ca-file:指定根CA证书文件路径,用来对 kube-apiserver 证书进行校验,指定该参数后,才会在 Pod 容器的 ServiceAccount 中放置该 CA 证书文件
#--experimental-cluster-signing-duration:设置为 TLS BootStrapping 签署的证书有效时间为10年,默认为1年


##生成kube-controller-manager证书
cd /opt/k8s/k8s-cert/
#创建证书请求文件
cat > kube-controller-manager-csr.json << EOF
{
  "CN": "system:kube-controller-manager",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "BeiJing", 
      "ST": "BeiJing",
      "O": "system:masters",
      "OU": "System"
    }
  ]
}
EOF

#生成证书
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-controller-manager-csr.json | cfssljson -bare kube-controller-manager

#生成kubeconfig文件
KUBE_CONFIG="/opt/kubernetes/cfg/kube-controller-manager.kubeconfig"
KUBE_APISERVER="https://192.168.190.100:6443"

kubectl config set-cluster kubernetes \
  --certificate-authority=/opt/kubernetes/ssl/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=${KUBE_CONFIG}
kubectl config set-credentials kube-controller-manager \
  --client-certificate=./kube-controller-manager.pem \
  --client-key=./kube-controller-manager-key.pem \
  --embed-certs=true \
  --kubeconfig=${KUBE_CONFIG}
kubectl config set-context default \
  --cluster=kubernetes \
  --user=kube-controller-manager \
  --kubeconfig=${KUBE_CONFIG}
kubectl config use-context default --kubeconfig=${KUBE_CONFIG}


##创建 kube-controller-manager.service 服务管理文件
cat >/usr/lib/systemd/system/kube-controller-manager.service <<EOF
[Unit]
Description=Kubernetes Controller Manager
Documentation=https://github.com/kubernetes/kubernetes

[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-controller-manager
ExecStart=/opt/kubernetes/bin/kube-controller-manager \$KUBE_CONTROLLER_MANAGER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable kube-controller-manager
systemctl restart kube-controller-manager

11. 生成 kubectl 连接集群的 kubeconfig 文件

[root@master01 k8s]# ./admin.sh
Cluster "kubernetes" set.
User "cluster-admin" set.
Context "default" created.
Switched to context "default".

 admin.sh:

#!/bin/bash
mkdir /root/.kube
KUBE_CONFIG="/root/.kube/config"
KUBE_APISERVER="https://192.168.190.100:6443"

cd /opt/k8s/k8s-cert/

kubectl config set-cluster kubernetes \
  --certificate-authority=/opt/kubernetes/ssl/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=${KUBE_CONFIG}
kubectl config set-credentials cluster-admin \
  --client-certificate=./admin.pem \
  --client-key=./admin-key.pem \
  --embed-certs=true \
  --kubeconfig=${KUBE_CONFIG}
kubectl config set-context default \
  --cluster=kubernetes \
  --user=cluster-admin \
  --kubeconfig=${KUBE_CONFIG}
kubectl config use-context default --kubeconfig=${KUBE_CONFIG}

12. 通过 kubectl 工具查看当前集群组件状态

[root@master01 k8s]# kubectl get cs
[root@master01 k8s]# kubectl get cs
Warning: v1 ComponentStatus is deprecated in v1.19+
NAME                 STATUS    MESSAGE             ERROR
scheduler            Healthy   ok                  
controller-manager   Healthy   ok                  
etcd-1               Healthy   {"health":"true"}   
etcd-0               Healthy   {"health":"true"}   
etcd-2               Healthy   {"health":"true"} 

13. 查看版本信息

[root@master01 k8s]# kubectl version
Client Version: version.Info{Major:"1", Minor:"20", GitVersion:"v1.20.11", GitCommit:"27522a29febbcc4badac257763044d0d90c11abd", GitTreeState:"clean", BuildDate:"2021-09-15T19:21:44Z", GoVersion:"go1.15.15", Compiler:"gc", Platform:"linux/amd64"}
Server Version: version.Info{Major:"1", Minor:"20", GitVersion:"v1.20.11", GitCommit:"27522a29febbcc4badac257763044d0d90c11abd", GitTreeState:"clean", BuildDate:"2021-09-15T19:16:25Z", GoVersion:"go1.15.15", Compiler:"gc", Platform:"linux/amd64"}

五、部署 Worker Node 组件

在所有 node 节点上操作

1. 创建 kubernetes 工作目录

[root@node01 ~]# mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs}

2. 上传 node.zip

到 /opt 目录中,解压 node.zip 压缩包,获得kubelet.sh、proxy.sh

[root@node01 opt]# rz -E
rz waiting to receive.
[root@node01 opt]# ls
containerd  etcd  kubernetes  node.zip  rh
[root@node01 opt]# unzip node.zip           
[root@node01 opt]# ls
containerd  etcd  kubelet.sh  kubernetes  node.zip  proxy.sh  rh
[root@node01 opt]# chmod +x kubelet.sh proxy.sh

2. 准备 kubelet、kube-proxy 文件

2.1 把 kubelet、kube-proxy 拷贝到 node 节点

[root@master01 k8s]# cd /opt/k8s/kubernetes/server/bin
[root@master01 bin]# ls
apiextensions-apiserver    kube-controller-manager             kube-proxy.docker_tag
kubeadm                    kube-controller-manager.docker_tag  kube-proxy.tar
kube-aggregator            kube-controller-manager.tar         kube-scheduler
kube-apiserver             kubectl                             kube-scheduler.docker_tag
kube-apiserver.docker_tag  kubelet                             kube-scheduler.tar
kube-apiserver.tar         kube-proxy                          mounter

[root@master01 bin]# scp kubelet kube-proxy root@node01:/opt/kubernetes/bin/
[root@master01 bin]# scp kubelet kube-proxy root@node02:/opt/kubernetes/bin/

2.2 上传kubeconfig.sh文件

到/opt/k8s/kubeconfig目录中

生成kubelet初次加入集群引导kubeconfig文件和kube-proxy.kubeconfig文件;

kubeconfig 文件包含集群参数(CA 证书、API Server 地址),客户端参数(上面生成的证书和私钥),集群 context 上下文参数(集群名称、用户名)。Kubenetes 组件(如 kubelet、kube-proxy)通过启动时指定不同的 kubeconfig 文件可以切换到不同的集群,连接到 apiserver。

执行脚本:

[root@master01 bin]# mkdir /opt/k8s/kubeconfig
[root@master01 bin]# cd /opt/k8s/kubeconfig
[root@master01 kubeconfig]# rz -E
rz waiting to receive.
[root@master01 kubeconfig]# ls
kubeconfig.sh
[root@master01 kubeconfig]# vim kubeconfig.sh 
[root@master01 kubeconfig]# chmod +x kubeconfig.sh
[root@master01 kubeconfig]# ./kubeconfig.sh 192.168.190.100 /opt/k8s/k8s-cert/
[root@master01 kubeconfig]# ls
bootstrap.kubeconfig  kubeconfig.sh  kube-proxy.kubeconfig

 kubeconfig.sh:

#!/bin/bash
#example: kubeconfig 192.168.190.100 /opt/k8s/k8s-cert/
#创建bootstrap.kubeconfig文件
#该文件中内置了 token.csv 中用户的 Token,以及 apiserver CA 证书;kubelet 首次启动会加载此文件,使用 apiserver CA 证书建立与 apiserver 的 TLS 通讯,使用其中的用户 Token 作为身份标识向 apiserver 发起 CSR 请求

BOOTSTRAP_TOKEN=$(awk -F ',' '{print $1}' /opt/kubernetes/cfg/token.csv)
APISERVER=$1
SSL_DIR=$2

export KUBE_APISERVER="https://$APISERVER:6443"

# 设置集群参数
kubectl config set-cluster kubernetes \
  --certificate-authority=$SSL_DIR/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=bootstrap.kubeconfig
#--embed-certs=true:表示将ca.pem证书写入到生成的bootstrap.kubeconfig文件中

# 设置客户端认证参数,kubelet 使用 bootstrap token 认证
kubectl config set-credentials kubelet-bootstrap \
  --token=${BOOTSTRAP_TOKEN} \
  --kubeconfig=bootstrap.kubeconfig

# 设置上下文参数
kubectl config set-context default \
  --cluster=kubernetes \
  --user=kubelet-bootstrap \
  --kubeconfig=bootstrap.kubeconfig

# 使用上下文参数生成 bootstrap.kubeconfig 文件
kubectl config use-context default --kubeconfig=bootstrap.kubeconfig

#----------------------

#创建kube-proxy.kubeconfig文件
# 设置集群参数
kubectl config set-cluster kubernetes \
  --certificate-authority=$SSL_DIR/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=kube-proxy.kubeconfig

# 设置客户端认证参数,kube-proxy 使用 TLS 证书认证
kubectl config set-credentials kube-proxy \
  --client-certificate=$SSL_DIR/kube-proxy.pem \
  --client-key=$SSL_DIR/kube-proxy-key.pem \
  --embed-certs=true \
  --kubeconfig=kube-proxy.kubeconfig

# 设置上下文参数
kubectl config set-context default \
  --cluster=kubernetes \
  --user=kube-proxy \
  --kubeconfig=kube-proxy.kubeconfig

# 使用上下文参数生成 kube-proxy.kubeconfig 文件
kubectl config use-context default --kubeconfig=kube-proxy.kubeconfig

2.3 拷贝配置文件到 node 节点

把配置文件 bootstrap.kubeconfig、kube-proxy.kubeconfig 拷贝到 node 节点

[root@master01 kubeconfig]# scp bootstrap.kubeconfig kube-proxy.kubeconfig root@node01:/opt/kubernetes/cfg/
[root@master01 kubeconfig]# scp bootstrap.kubeconfig kube-proxy.kubeconfig root@node02:/opt/kubernetes/cfg/

2.4 RBAC 授权

使用户 kubelet-bootstrap 能够有权限发起 CSR 请求证书

[root@master01 kubeconfig]# kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap
clusterrolebinding.rbac.authorization.k8s.io/kubelet-bootstrap created

# 若执行失败,可先给kubectl绑定默认cluster-admin管理员集群角色,授权集群操作权限
kubectl create clusterrolebinding cluster-system-anonymous --clusterrole=cluster-admin --user=system:anonymous

3. 启动 kubelet 服务

在 node01 节点上操作

[root@node01 ~]# cd /opt/
[root@node01 opt]# ls
containerd  etcd  kubelet.sh  kubernetes  node.zip  proxy.sh  rh

[root@node01 opt]# ./kubelet.sh 192.168.190.102  # 填写自己的ip
Created symlink from /etc/systemd/system/multi-user.target.wants/kubelet.service to /usr/lib/systemd/system/kubelet.service.
[root@node01 opt]# ps aux | grep kubelet
root      40378 14.8  2.7 942476 50968 ?        Ssl  23:08   0:01 /opt/kubernetes/bin/kubelet --logtostderr=false --v=2 --log-dir=/opt/kubernetes/logs --hostname-override=192.168.190.102 --network-plugin=cni --kubeconfig=/opt/kubernetes/cfg/kubelet.kubeconfig --bootstrap-kubeconfig=/opt/kubernetes/cfg/bootstrap.kubeconfig --config=/opt/kubernetes/cfg/kubelet.config --cert-dir=/opt/kubernetes/ssl --pod-infra-container-image=registry.cn-hangzhou.aliyuncs.com/google-containers/pause-amd64:3.0
root      40391  0.0  0.0 112676   980 pts/0    S+   23:08   0:00 grep --color=auto kubelet

kubelet.sh :

#!/bin/bash

NODE_ADDRESS=$1
DNS_SERVER_IP=${2:-"10.0.0.2"}

#创建 kubelet 启动参数配置文件
cat >/opt/kubernetes/cfg/kubelet <<EOF
KUBELET_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--hostname-override=${NODE_ADDRESS} \\
--network-plugin=cni \\
--kubeconfig=/opt/kubernetes/cfg/kubelet.kubeconfig \\
--bootstrap-kubeconfig=/opt/kubernetes/cfg/bootstrap.kubeconfig \\
--config=/opt/kubernetes/cfg/kubelet.config \\
--cert-dir=/opt/kubernetes/ssl \\
--pod-infra-container-image=registry.cn-hangzhou.aliyuncs.com/google-containers/pause-amd64:3.0"
EOF

#--hostname-override:指定kubelet节点在集群中显示的主机名或IP地址,默认使用主机hostname;kube-proxy和kubelet的此项参数设置必须完全一致
#--network-plugin:启用CNI
#--kubeconfig:指定kubelet.kubeconfig文件位置,当前为空路径,会自动生成,用于如何连接到apiserver,里面含有kubelet证书,master授权完成后会在node节点上生成 kubelet.kubeconfig 文件
#--bootstrap-kubeconfig:指定连接 apiserver 的 bootstrap.kubeconfig 文件
#--config:指定kubelet配置文件的路径,启动kubelet时将从此文件加载其配置
#--cert-dir:指定master颁发的kubelet证书生成目录
#--pod-infra-container-image:指定Pod基础容器(Pause容器)的镜像。Pod启动的时候都会启动一个这样的容器,每个pod之间相互通信需要Pause的支持,启动Pause需要Pause基础镜像


#----------------------
#创建kubelet配置文件(该文件实际上就是一个yml文件,语法非常严格,不能出现tab键,冒号后面必须要有空格,每行结尾也不能有空格)
cat >/opt/kubernetes/cfg/kubelet.config <<EOF
kind: KubeletConfiguration
apiVersion: kubelet.config.k8s.io/v1beta1
address: ${NODE_ADDRESS}
port: 10250
readOnlyPort: 10255
cgroupDriver: cgroupfs
clusterDNS:
- ${DNS_SERVER_IP} 
clusterDomain: cluster.local
failSwapOn: false
authentication:
  anonymous:
    enabled: true
EOF

#PS:当命令行参数与此配置文件(kubelet.config)有相同的值时,就会覆盖配置文件中的该值。


#----------------------
#创建 kubelet.service 服务管理文件
cat >/usr/lib/systemd/system/kubelet.service <<EOF
[Unit]
Description=Kubernetes Kubelet
After=docker.service
Requires=docker.service

[Service]
EnvironmentFile=/opt/kubernetes/cfg/kubelet
ExecStart=/opt/kubernetes/bin/kubelet \$KUBELET_OPTS
Restart=on-failure
KillMode=process

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable kubelet
systemctl restart kubelet

4. 授权 CSR 请求并签发证书

在 master01 节点上操作

4.1 检查到 node01 节点的 kubelet 发起的 CSR 请求

Pending 表示等待集群给该节点签发证书

获取Kubernetes中所有证书签发请求 (CSR) 的列表:
[root@master01 kubeconfig]# kubectl get csr
NAME                                                   AGE   SIGNERNAME                                    REQUESTOR           CONDITION
node-csr-jUqxR9_nQjM6-F3B6i06EYOLpi4tSau1jWlHGiqYLFY   36s   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Pending

4.2 手动批准节点的证书签发请求

[root@master01 kubeconfig]# kubectl certificate approve node-csr-jUqxR9_nQjM6-F3B6i06EYOLpi4tSau1jWlHGiqYLFY
certificatesigningrequest.certificates.k8s.io/node-csr-jUqxR9_nQjM6-F3B6i06EYOLpi4tSau1jWlHGiqYLFY approved

4.3 再次查看 Kubernetes 中所有证书签发请求 (CSR) 的列表

[root@master01 kubeconfig]# kubectl get csr
NAME                                                   AGE    SIGNERNAME                                    REQUESTOR           CONDITION
node-csr-jUqxR9_nQjM6-F3B6i06EYOLpi4tSau1jWlHGiqYLFY   118s   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Approved,Issued

# Pending: CSR已经被创建,但还没有被审批。
# Approved: CSR已经被API服务器认可,意味着一个有权限的实体(如集群管理员)已经批准了这个签名请求。
# Denied: CSR被拒绝,通常是因为审批者认为该请求不应被批准。
# Issued: 表明CSR不仅被批准,而且证书实际上已经被签发了。

4.4 查看节点

由于网络插件还没有部署,节点会没有准备就绪 NotReady

[root@master01 kubeconfig]# kubectl get node
NAME              STATUS     ROLES    AGE   VERSION
192.168.190.102   NotReady   <none>   59s   v1.20.11

5. 添加负载均衡的内核模块

在 master01 节点上操作 

5.1 添加 ip_vs 模块 

[root@master01 ~]# for i in $(ls /usr/lib/modules/$(uname -r)/kernel/net/netfilter/ipvs|grep -o "^[^.]*");do echo $i; /sbin/modinfo -F filename $i >/dev/null 2>&1 && /sbin/modprobe $i;done

5.2 启动 proxy 服务

[root@node01 ~]# cd /opt/
[root@node01 opt]# ./proxy.sh 192.168.190.102
[root@node01 opt]# ps aux | grep kube-proxy
root      42044  2.4  1.5 743556 29824 ?        Ssl  23:17   0:00 /opt/kubernetes/bin/kube-proxy --logtostderr=true --v=4 --hostname-override=192.168.190.102 --cluster-cidr=172.17.0.0/16 --proxy-mode=ipvs --kubeconfig=/opt/kubernetes/cfg/kube-proxy.kubeconfig
root      42164  0.0  0.0 112676   988 pts/0    S+   23:17   0:00 grep --color=auto kube-proxy

proxy.sh: 

#!/bin/bash

NODE_ADDRESS=$1

#创建 kube-proxy 启动参数配置文件
cat >/opt/kubernetes/cfg/kube-proxy <<EOF
KUBE_PROXY_OPTS="--logtostderr=true \\
--v=4 \\
--hostname-override=${NODE_ADDRESS} \\
--cluster-cidr=172.17.0.0/16 \\
--proxy-mode=ipvs \\
--kubeconfig=/opt/kubernetes/cfg/kube-proxy.kubeconfig"
EOF

#--hostnameOverride: 参数值必须与 kubelet 的值一致,否则 kube-proxy 启动后会找不到该 Node,从而不会创建任何 ipvs 规则
#--cluster-cidr:指定 Pod 网络使用的聚合网段,Pod 使用的网段和 apiserver 中指定的 service 的 cluster ip 网段不是同一个网段。 kube-proxy 根据 --cluster-cidr 判断集群内部和外部流量,指定 --cluster-cidr 选项后 kube-proxy 才会对访问 Service IP 的请求做 SNAT,即来自非 Pod 网络的流量被当成外部流量,访问 Service 时需要做 SNAT。
#--proxy-mode:指定流量调度模式为ipvs模式,可添加--ipvs-scheduler选项指定ipvs调度算法(rr|wrr|lc|wlc|lblc|lblcr|dh|sh|sed|nq)
#--kubeconfig: 指定连接 apiserver 的 kubeconfig 文件    


#----------------------
#创建 kube-proxy.service 服务管理文件
cat >/usr/lib/systemd/system/kube-proxy.service <<EOF
[Unit]
Description=Kubernetes Proxy
After=network.target

[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-proxy
ExecStart=/opt/kubernetes/bin/kube-proxy \$KUBE_PROXY_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable kube-proxy
systemctl restart kube-proxy

五、部署 CNI 网络组件

1. 部署 flannel

在 node01 节点上操作:

1.1 上传 cni、flannel 安装包

上传 cni-plugins-linux-amd64-v0.8.6.tgz 和 flannel.tar 到 /opt 目录中

[root@node01 opt]# rz -E
rz waiting to receive.
[root@node01 opt]# ls
cni-plugins-linux-amd64-v0.8.6.tgz  etcd         kubelet.sh  node.zip  rh
containerd                          flannel.tar  kubernetes  proxy.sh
[root@node01 opt]# docker load -i flannel.tar # 加载docker镜像
[root@node01 opt]# mkdir /opt/cni/bin -p
[root@node01 opt]# tar zxvf cni-plugins-linux-amd64-v0.8.6.tgz -C /opt/cni/bin/

1.2 node02 节点部署 kubelet、proxy 服务

1.2.1 文件传输

在 node01 节点上操作:

[root@node01 ~]# cd /opt/
[root@node01 opt]# scp kubelet.sh proxy.sh root@192.168.190.103:/opt/
[root@node01 opt]# scp -r /opt/cni root@192.168.190.103:/opt/
1.2.2 启动 kubelet 服务

在 node02 节点上操作:

[root@node02 ~]# cd /opt/
[root@node02 opt]# ./kubelet.sh 192.168.190.103
1.2.3 签发证书并通过CSR请求

在 master01 节点上操作:

[root@master01 ~]# kubectl get csr
NAME                                                   AGE   SIGNERNAME                                    REQUESTOR           CONDITION
node-csr-eRjMsiTAV7Xr-hNdT1WYIJ5I2_nOM77afswwbhmiias   4m    kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Pending

[root@master01 ~]# kubectl certificate approve node-csr-eRjMsiTAV7Xr-hNdT1WYIJ5I2_nOM77afswwbhmiias

[root@master01 ~]# kubectl get csr
NAME                                                   AGE     SIGNERNAME                                    REQUESTOR           CONDITION
node-csr-eRjMsiTAV7Xr-hNdT1WYIJ5I2_nOM77afswwbhmiias   4m20s   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Approved,Issued
1.2.4 加载 ipvs 模块 

在 node02 节点上操作:

[root@node02 ~]# for i in $(ls /usr/lib/modules/$(uname -r)/kernel/net/netfilter/ipvs|grep -o "^[^.]*");do echo $i; /sbin/modinfo -F filename $i >/dev/null 2>&1 && /sbin/modprobe $i;done
1.2.5 使用proxy.sh脚本启动proxy服务 

在 node02 节点上操作:

[root@node02 ~]# cd /opt/
[root@node02 opt]# ./proxy.sh 192.168.190.103
1.2.6 查看群集中的节点状态 

在 master01 节点上操作:

[root@master01 ~]# kubectl get nodes
NAME              STATUS   ROLES    AGE     VERSION
192.168.190.102   Ready    <none>   39h     v1.20.11
192.168.190.103   Ready    <none>   4m10s   v1.20.11

1.3 部署 CNI 网络 

上传 kube-flannel.yml 文件到 /opt/k8s 目录中

[root@master01 k8s]# rz -E
rz waiting to receive.
[root@master01 k8s]# ls
admin.sh               etcd.sh                         kubeconfig                            master.zip
apiserver.sh           etcd-v3.4.9-linux-amd64         kube-flannel.yml                      scheduler.sh
controller-manager.sh  etcd-v3.4.9-linux-amd64.tar.gz  kubernetes                            token.sh
etcd-cert              k8s-cert                        kubernetes-server-linux-amd64.tar.gz
[root@master01 k8s]# kubectl apply -f kube-flannel.yml
# 指定的YAML文件(kube-flannel.yml)来创建或更新Kubernetes集群中的资源

1.4 查看集群节点信息 

查看kube-system命名空间中所有Pod的状态和相关信息:

[root@master01 k8s]# kubectl get pods -n kube-system
NAME                    READY   STATUS    RESTARTS   AGE
kube-flannel-ds-mlpj6   1/1     Running   0          22m
kube-flannel-ds-qmgdw   1/1     Running   3          5m11s

# NAME: Pod的名称
# READY: 表示Pod中容器的就绪状态。这里显示1/1,表示Pod中有一个容器,且该容器已经就绪。
# STATUS: 表示Pod的整体状态。这里显示Running,表示Pod正在运行。
# RESTARTS: 表示自Pod启动以来容器重启的次数。这里显示0,表示容器没有发生重启。
# AGE: 表示Pod创建后经过的时间。这里显示2m48s,表示Pod已经运行了2分钟48秒。

获取当前Kubernetes集群中所有节点(nodes)的列表:

[root@master01 k8s]# kubectl get nodes
NAME              STATUS   ROLES    AGE   VERSION
192.168.190.102   Ready    <none>   38h   v1.20.11
192.168.190.103   Ready    <none>   4m10s v1.20.11

# NAME: 节点的名称,通常节点的名称可以是IP地址或者主机名。
# STATUS: 节点的状态。这里显示Ready,表示节点处于就绪状态,可以接受工作负载。
# ROLES: 节点的角色。这里显示,表示节点没有特定的角色。
# AGE: 节点的创建时间。这里显示38h,表示节点已经存在38小时。
# VERSION: Kubernetes集群中该节点的Kubernetes版本为v1.20.11。

2. 部署 Calico

Calico 与 Flannel 是两种插件(服务),这里介绍 Calico 部署,将前面的操作进行快照保存。

2.1 部署 CNI 网络

在 master01 节点上操作,上传 calico.yaml 文件到 /opt/k8s 目录中

[root@master01 ~]# cd /opt/k8s
[root@master01 k8s]# rz -E
rz waiting to receive.
[root@master01 k8s]# ls
admin.sh               etcd-cert                       k8s-cert                              master.zip
apiserver.sh           etcd.sh                         kubeconfig                            scheduler.sh
calico.yaml            etcd-v3.4.9-linux-amd64         kubernetes                            token.sh
controller-manager.sh  etcd-v3.4.9-linux-amd64.tar.gz  kubernetes-server-linux-amd64.tar.gz

注意yml格式对齐:
[root@master01 k8s]# vim calico.yaml
             - name: CALICO_IPV4POOL_CIDR
               value: "10.244.0.0/16"  # Calico 默认使用的网段为 192.168.0.0/16
# 修改里面定义 Pod 的网络(CALICO_IPV4POOL_CIDR),需与前面 kube-controller-manager 配置文件指定的 cluster-cidr 网段一样

[root@master01 k8s]# kubectl apply -f calico.yaml
# Kubernetes将会读取calico.yaml文件中定义的资源(如Pod、Service、Deployment等),然后在集群中创建、更新或删除这些资源,以使集群的状态与配置文件中定义的状态一致。
# 这个命令通常用于部署网络插件(如Calico)或其他Kubernetes资源配置。

2.2 查看集群组件状态

[root@master01 k8s]# kubectl get pods -n kube-system
NAME                                       READY   STATUS    RESTARTS   AGE
calico-kube-controllers-659bd7879c-qmgdw   1/1     Running   0          8m4s
calico-node-gstw5                          1/1     Running   0          6m24s
calico-node-mlpj6                          1/1     Running   0          8m4s

六、部署 CoreDNS 

CoreDNS 可以为集群中的 service 资源创建一个域名 与 IP 的对应关系解析,可以提供稳定的、可靠的 DNS 服务,简化 Kubernetes 集群内部服务之间的通信,同时也为管理员提供了灵活的配置选项和扩展能力。

1. 上传 coredns 镜像

上传 coredns.tar 到 /opt 目录中,在所有 node 节点上操作

[root@node01 opt]# rz -E
rz waiting to receive.
[root@node01 opt]# docker load -i coredns.tar
[root@node01 opt]# docker images
REPOSITORY                                                        TAG       IMAGE ID       CREATED       SIZE
quay.io/coreos/flannel                                            v0.14.0   8522d622299c   2 years ago   67.9MB
k8s.gcr.io/coredns                                                1.7.0     bfe3a36ebd25   3 years ago   45.2MB
registry.cn-hangzhou.aliyuncs.com/google-containers/pause-amd64   3.0       99e59f495ffa   8 years ago   747kB

2. Master01 节点部署 CoreDNS

上传 coredns.yaml 文件到 /opt/k8s 目录中,在 master01 节点上操作

[root@master01 ~]# cd /opt/k8s
[root@master01 k8s]# kubectl apply -f coredns.yaml

根据 coredns.yaml 文件中的配置信息,在 Kubernetes 集群中创建或更新 CoreDNS 相关的资源

[root@master01 k8s]# kubectl apply -f coredns.yaml

获取位于 kube-system 命名空间下的所有 Pod 的列表

[root@master01 k8s]# kubectl get pods -n kube-system
NAME                       READY   STATUS    RESTARTS   AGE
coredns-6954c77b9b-gstw5   1/1     Running   0          9s
kube-flannel-ds-mlpj6      1/1     Running   0          81m
kube-flannel-ds-qmgdw      1/1     Running   3          64m

3. DNS 解析测试

[root@master01 k8s]# kubectl run -it --rm dns-test --image=busybox:1.28.4 sh
If you don't see a command prompt, try pressing enter.
Error attaching, falling back to logs: unable to upgrade connection: Forbidden (user=system:anonymous, verb=create, resource=nodes, subresource=proxy)
pod "dns-test" deleted
Error from server (Forbidden): Forbidden (user=system:anonymous, verb=get, resource=nodes, subresource=proxy) ( pods/log dns-test)

如果出现以上报错,需要添加 rbac的权限  直接使用kubectl绑定  clusteradmin 管理员集群角色  授权操作权限

[root@master01 k8s]# kubectl create clusterrolebinding cluster-system-anonymous --clusterrole=cluster-admin --user=system:anonymous
clusterrolebinding.rbac.authorization.k8s.io/cluster-system-anonymous created
[root@master01 k8s]# kubectl run -it --rm dns-test --image=busybox:1.28.4 sh
If you don't see a command prompt, try pressing enter.
/ # nslookup kubernetes
Server:    10.0.0.2
Address 1: 10.0.0.2 kube-dns.kube-system.svc.cluster.local

Name:      kubernetes
Address 1: 10.0.0.1 kubernetes.default.svc.cluster.local

七、小结

etcd 安装步骤:
1.准备 CA 证书和私钥文件 ,首先 CA 签发服务端证书和私有文件
2.使用 CA 证书、服务端证书 、私有文件加上 etcd 集群配置文件去启动 etcd 服务
3.复制 etcd 工作目录和管理文件到另外几个节点上(node01 node02),修改 etcd 集群配置文件并且启动 etcd 服务
4.使用 v3 版本的接口去执行 etcdctl + 证书选项(endpoint healh)| endpoint status | member list 査看 etcd 集群和节点的状态

master 组件安装:
1.先安装 apiserver
(1)准备组件相关的证书和私钥文件
(2)准备 bootstrap token 认证文件,给 kubelet 启动时签发证书使用
(3)准备组件启动配置文件
(4)启动 apiserver 服务,端口是 6443 https
2.再启动 controller-manager 和 scheduler
(1)准备启动配置文件
(2)准备相关证书和私钥文件生成 kubeconfig 文件(用于指定对接哪个 apiserver,使用什么证书认证)启动服务
3.检查集群组件状态
需要准备 kubeconfig 文件把 kubectl 加入到集群中(指定对接哪个apiserver,使用什么证书认证)
kubectl get cs

master 组件安装:
1.生成kubelet初次加入集群引导kubeconfig文件和kube-proxy.kubeconfig文件
2.把 kubelet、kube-proxy、bootstrap.kubeconfig kube-proxy.kubeconfig 拷贝到 node 节点
3.RBAC授权,使用户 kubelet-bootstrap 能够有权限发起 CSR 请求证书
4.在 node 节点启动 kubelet 服务
5.在 master 节点通过 CSR 请求并签发证书
6.在 master 节点使用命令 kubectl get node 获取集群中所有节点(Node)的信息
7.在 node 节点加载 ip_vs 模块,启动proxy服务

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/628997.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

数据结构(十五)----排序算法(2)

目录 一.选择排序 1.简单选择排序 2.堆排序 •建立大根堆 •基于大根堆进行排序 堆排序算法效率&#xff1a; 堆排序算法稳定性&#xff1a; 3.堆的插入和删除 •在堆中插入新元素 •在堆中删除元素 二.归并排序 归并排序算法效率&#xff1a; 归并排序算法的稳定…

绿色消费新趋势:共享购模式的积分革命

在当今绿色消费风潮中&#xff0c;一种名为共享购的新模式正悄然兴起&#xff0c;它通过创新的绿色积分机制&#xff0c;不仅鼓励了消费者的绿色消费行为&#xff0c;还为消费者和商家带来了更多的实惠与额外收益。 传统积分机制的局限 在传统的消费积分模式中&#xff0c;消费…

计算机组成结构—寻址方法

目录 一、指令寻址 二、数据寻址 1.立即寻址 2.直接寻址 3.间接寻址 4.隐含寻址 5.寄存器寻址 6.寄存器间接寻址 7.基址寻址 8.变址寻址 9.相对寻址 10. 堆栈寻址 寻址方式是寻找指令或操作数有效地址的方式&#xff0c;也就是指确定本条指令的数据地址&#xff0c;…

IP-GUARD如何制作授权软件

1、进入控制台 -> 找到文档安全管理 -> 点击授权软件管理 -> 导出授权软件(名称自定义) 2、打开这个蓝宝石工具,并将导出的文件进行打开 选择你要操作的软件进行编辑,然后一直下一步 3、选择要操作的软件进行编辑

MIRO时,修改页签“采购订单参考”的数量时,金额不自动计算

MIRO 发票校验时&#xff0c;进入到如下界面&#xff0c;系统参考采购订单自动带出已经收货的金额和数量。 此时如果想要修改数量时&#xff0c;有些用户账号下&#xff0c;金额不自动计算&#xff0c;但是有些用户账号下&#xff0c;数量更改时&#xff0c;系统自动计算和建议…

在Ubuntu22.04搭建xfce远程桌面

由于Ubuntu22.04云服务器&#xff08;带GPU&#xff09;只开放部分端口&#xff0c;某些服务&#xff08;如nacos&#xff09;有Web前端需要访问&#xff0c;但是相应的端口并没有开放&#xff0c;只有SSH端口可以使用。于是&#xff0c;就在Ubuntu22.04上安装xfce桌面环境&…

静态IP地址:网络通信的稳定之锚

在数字化时代&#xff0c;网络通信是企业运营和个人生活不可或缺的一部分。而在这个过程中&#xff0c;IP地址扮演着至关重要的角色。静态IP地址&#xff0c;作为一种特殊的网络配置&#xff0c;为网络通信提供了稳定性和可靠性。本文将从五个方面深入探讨静态IP地址的重要性、…

asp.net 齿轮加工车间生产管理系统-计算机毕业设计源码56014

摘 要 随着我国经济迅速发展&#xff0c;人们对手机的需求越来越大&#xff0c;各种手机软件也都在被广泛应用&#xff0c;但是对于手机进行数据信息管理&#xff0c;对于手机的各种软件也是备受用户的喜爱&#xff0c;在现实运用中&#xff0c;为方便用户能够可以随时进行在线…

中途离开项羽投奔刘邦的那些名将谋臣,最后的结果怎么样?

刘邦夺取天下后&#xff0c;说&#xff1a;我自己没什么能力&#xff0c;之所以击败项羽&#xff0c;都是大家的功劳。带兵横扫强敌&#xff0c;我不如韩信&#xff1b;筹措粮草物资&#xff0c;源远不断地给前线供应粮饷&#xff0c;我不如萧何&#xff1b;坐在帐中&#xff0…

UDP多对多组播通信

广播和多播仅应用于UDP。TCP是一个面向连接的协议&#xff0c;TCP一定是点对点的&#xff0c;一点是两个主机来建立连接的&#xff0c;TCP肯定是单播。只有UDP才会使用广播和组播。 如下示例实现一个UDP多对多的组播通信&#xff0c;进程中有收、发两个线程&#xff0c;分别表…

React渲染流程

在 React 渲染分为两个阶段&#xff0c;Render 和 Commit&#xff0c;Render 是修改 React 组件的状态&#xff0c;把需要更新的组件标记为待更新&#xff0c;在 Commit 阶段将待更新的组件进行渲染并最终更新到浏览器的 Dom 树中。 Render 阶段是可以并执行操作的&#xff0c…

【MySQL】表的增删改查 | CRUD | 新增 | 查询 | 修改 | 删除 | 数据库约束

文章目录 表的增删改查一、CRUD1.新增&#xff08;Create&#xff09;1.插入多行2.指定列多行插入3.插入datetime类型4.插入当前时间5.插入查询的结果 2.查询&#xff08;Retrieve&#xff09;1.全列查询 *2.指定列查询3.查询字段为表达式4.指定别名 as5.去重 distinct6.排序 o…

Excel提取某一列的唯一值

点击【筛选】&#xff08;【高级筛选】&#xff09;&#xff0c;参数里&#xff1a; 列表区域&#xff1a;为需要选择唯一值的那一列复制到&#xff1a;生成唯一值的目标区域 据说新版本的excel有了unique()函数&#xff0c;可以很快捷的选择某一列的唯一值&#xff0c;但是博…

大模型时代下的先行者:景联文科技引领数据标注新时代

在大模型时代&#xff0c;数据标注不再是简单的分类标注&#xff0c;而是一项融合了技术革新、专业技能、法律合规和精细化管理的综合性任务&#xff0c;对推动AI技术的发展和落地应用具有重要意义。 景联文科技作为AI基础行业的数据供应商&#xff0c;可协助人工智能企业解决整…

记录一下自己的宏碁暗影骑士电脑的属性

TOC 前言 没有前言。 参考博文 怎么查自己电脑服务器信息吗,如何查看自己电脑的服务器 一、cmd 看到服务器型号 wmic csproduct get name查询CPU个数 按照博主的方法&#xff0c;我出现了报错。 在 Windows 上&#xff0c;您可以通过 PowerShell 来执行类似的操作。您可以…

测缝计测量的是实际缝宽吗?

在土木工程中&#xff0c;测缝计作为一种重要的监测工具&#xff0c;广泛应用于桥梁、隧道、大坝等大型结构中&#xff0c;用以测量和监控结构接缝或裂缝的实际宽度变化。然而&#xff0c;有些人可能会产生疑问&#xff1a;测缝计测量的是实际缝宽吗?本文将对这一问题进行深入…

QCheckBox样式表qss实现状态切换显示不同图标(含第三状态:半选状态)

QCheckBox实际上支持三种状态&#xff1a;选中、未选中、半选 本文介绍如何使用qss实现这三种状态的样式&#xff0c;设置各状态的勾选框图标 需要调用setTristate(true)函数开启第三状态&#xff0c;默认是只有两种状态的。 网上百度很容易找到选中和未选中的qss样式&#…

基于Nios-II实现流水灯

文章目录 一、新建项目1、选择芯片2、Qsys设计2.1、点击Platform Designer2.2配置软核2.3其他设置 3、Quartus设计3.1添加原理图3.2添加qip文件3.3其他设置3.4驱动设置 4、Nios-II Eslipse设计参考 一、新建项目 使用的Quartus 18.0及以上版本 1、选择芯片 2、Qsys设计 2.1、点…

MT3037 新月轩就餐

思路&#xff1a; 此题每道菜的价钱相同&#xff0c;想最小化付的钱即求最小区间长度可以满足“品尝到所有名厨手艺”。 使用双端队列存储元素&#xff0c;队尾不断向后遍历&#xff1a;头->尾 如果队头队尾&#xff0c;则队头往右移一格&#xff0c;直到区间不同元素数m…