K8s 二进制部署上篇

空中连线

已于 2024-05-20 11:04:31 修改

阅读量1k

点赞数 10

文章标签： kubernetes 容器云原生

于 2024-05-14 15:37:38 首次发布

本文链接：https://blog.csdn.net/mcb134/article/details/138664327

版权

一 K8S按装部署方式：

① Minikube

Minikube是一个工具，可以在本地快速运行一个单节点微型K8S，仅用于学习、预览K8S的一些特

性使用。

部署地址：https://kubernetes.io/docs/setup/minikube

② Kubeadmin

Kubeadmin也是一个工具，提供kubeadm init和kubeadm join，用于快速部署K8S集群，相对简

单。

https://kubernetes.io/docs/reference/setup-tools/kubeadm/kubeadm/

③ 二进制安装部署

生产首选，从官方下载发行版的二进制包，手动部署每个组件和自签TLS证书，组成K8S集群，新

手推荐。

https://github.com/kubernetes/kubernetes/releases

④ 小结：

Kubeadm降低部署门槛，但屏蔽了很多细节，遇到问题很难排查。如果想更容易可控，推

荐使用二进制包部署Kubernetes集群，虽然手动部署麻烦点，期间可以学习很多工作原理，也利于

后期维护。

二进制搭建 Kubernetes v1.20

K8s集群：


master01	kube-apiserver kube-controller-manager kube-scheduler etcd	192.168.11.6
node01	kubelet kube-proxy docker	192.168.11.11
node02	etc	192.168.11.12

2 系统初始化配置

2.1 关闭防火墙防护

#关闭防火墙
systemctl stop firewalld
systemctl disable firewalld
iptables -F && iptables -t nat -F && iptables -t mangle -F && iptables -X
清空默认过滤表、NAT 表和 Mangle 表中的所有规则，并删除所有用户自定义的链。

iptables -F: 这个部分用于清空默认过滤表（filter table）中的所有规则。-F 选项表示清空规则。

&&: 这是一个逻辑操作符，表示前一个命令成功执行后才会执行下一个命令。在这里，它将多个命令连接在一起，以确保只有在前一个命令成功执行后才会执行下一个命令。

iptables -t nat -F: 这部分用于清空 NAT 表（nat table）中的所有规则。-t nat 选项表示指定操作 NAT 表，-F 选项表示清空规则。

iptables -t mangle -F: 这部分用于清空 Mangle 表（mangle table）中的所有规则。-t mangle 选项表示指定操作 Mangle 表，-F 选项表示清空规则。

iptables -X: 最后这部分用于删除用户自定义的链（chains）。通常，用户可以创建自定义的链来管理特定类型的流量，这个命令将删除所有这些用户自定义的链。

#关闭selinu
setenforce 0
sed -i 's/enforcing/disabled/' /etc/selinux/config

2.2 关闭swap

三台都要

swapoff -a
sed -ri 's/.*swap.*/#&/' /etc/fstab

2.3 根据规划设置主机名

hostnamectl set-hostname master01
hostnamectl set-hostname node01
hostnamectl set-hostname node02

2.4 在master添加hosts

三台都如此

cat >> /etc/hosts << EOF
192.168.11.6 master01
192.168.11.11 node01
192.168.11.12 node02
EOF

2.5 调整内核参数

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  #刷新内核参数

2.6 时间同步

yum install ntpdate -y

ntpdate time.windows.com
用于通过 NTP 协议（Network Time Protocol）从指定的时间服务器（在这种情况下是 time.windows.com）同步系统的时间

注：若某一台无法启动多重复几次

3 部署 docker引擎

3.1 所有 node 节点部署docker引擎

  yum install -y yum-utils device-mapper-persistent-data lvm2

 #安装依赖包


yum-utils: 这是一个 YUM 的扩展工具集，提供了一些额外的功能和命令，用于包管理和系统维护。

device-mapper-persistent-data: 这是一个软件包，提供了设备映射器持久数据存储的功能，通常用于与 LVM 
                               （Logical Volume Manager）一起使用。

lvm2: 这是逻辑卷管理器（LVM）的软件包，用于创建、管理逻辑卷、卷组和逻辑卷快照等。

因此，这个命令的作用是安装 yum-utils、device-mapper-persistent-data 和 lvm2 这三个软件包，并且使用 -y 选项自动确认安装过程，而不需要用户手动确认。

3.2 将阿里云镜像站点上的 Docker CE 软件源配置添加到系统的 YUM 软件源列表中

 yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo 

#添加阿里官方源

yum-config-manager: 这是一个 YUM 工具，用于管理 YUM 软件源的配置。

--add-repo: 这是 yum-config-manager 的选项，表示要添加一个新的软件源配置。

https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo: 这是要添加的 Docker CE 软件源的 URL，指向阿里云镜像站点上的 Docker CE 软件源配置文件。通过添加这个软件源，系统就可以从该镜像站点下载 Docker CE 软件包。

因此，这个命令的作用是将阿里云镜像站点上的 Docker CE 软件源配置添加到系统的 YUM 软件源列表中，以便系统可以从该镜像站点获取 Docker CE 软件包进行安装。

3.3 安装 Docker相关镜像

yum install -y docker-ce docker-ce-cli containerd.io

#安装容器

docker-ce: 这是 Docker CE（Docker Community Edition）的主要软件包，包含了 Docker 引擎等核心组件。

docker-ce-cli: 这是 Docker CE 的命令行界面工具软件包，用于与 Docker 引擎进行交互和管理。

containerd.io: 这是容器运行时（container runtime）软件包，用于管理容器的生命周期，包括创建、运行和销毁容器等操作。

系统将会安装 Docker CE 相关的软件包，包括 Docker 引擎、命令行界面工具和容器运行时，使得系统可以开始使用 Docker 来构建、部署和管理容器化应用程序。

systemctl start docker.service
systemctl enable docker.service 
systemctl status docker.service

4 部署 etcd 集群

etcd是CoreOS团队于2013年6月发起的开源项目，它的目标是构建一个高可用的分布式键值（key-value）数据库。etcd内部采用raft协议作为一致性算法，etcd是go语言编写的。

4.1 etcd 作为服务发现系统特点：

简单：安装配置简单，而且提供了HTTP API进行交互，使用也很简单

安全：支持SSL证书验证

快速：单实例支持每秒2k+读操作

可靠：采用raft算法，实现分布式系统数据的可用性和一致性

etcd 目前默认使用2379端口提供HTTP API服务， 2380端口和peer通信(这两个端口已经被

IANA(互联网数字分配机构)官方预留给etcd)。即etcd默认使用2379端口对外为客户端提供通讯，

使用端口2380来进行服务器间内部通讯。

etcd 在生产环境中一般推荐集群方式部署。由于etcd 的leader选举机制，要求至少为3台或以上的

奇数台。

4.2 准备签发证书环境

CFSSL 是 CloudFlare 公司开源的一款 PKI/TLS 工具。 CFSSL 包含一个命令行工具和一个用于签名、验证和捆绑 TLS 证书的 HTTP API 服务。使用Go语言编写。
CFSSL 使用配置文件生成证书，因此自签之前，需要生成它识别的 json 格式的配置文件，CFSSL 提供了方便的命令行生成配置文件。

CFSSL 用来为 etcd 提供 TLS 证书，它支持签三种类型的证书：
1、client 证书，服务端连接客户端时携带的证书，用于客户端验证服务端身份，如 kube-apiserver 访问 etcd；
2、server 证书，客户端连接服务端时携带的证书，用于服务端验证客户端身份，如 etcd 对外提供服务；
3、peer 证书，相互之间连接时使用的证书，如 etcd 节点之间进行验证和通信。
这里全部都使用同一套证书认证。

4.3 在 master01 节点上操作

1) 准备cfssl证书生成工具

wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64 -O /usr/local/bin/cfssl
wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64 -O /usr/local/bin/cfssljson
wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64 -O /usr/local/bin/cfssl-certinfo

注意：weget多数情况下下载不下来，需要拖入

2) 添加权限

chmod +x /usr/local/bin/cfssl*
--------------------------------------------------------
cfssl：证书签发的工具命令
cfssljson：将 cfssl 生成的证书（json格式）变为文件承载式证书
cfssl-certinfo：验证证书的信息
cfssl-certinfo -cert <证书名称>			#查看证书的信息
---------------------------------------------------------

4.4 生成etcd证书

mkdir /opt/k8s
cd /opt/k8s/

上传 etcd-cert.sh 和 etcd.sh 到 /opt/k8s/ 目录中
chmod +x etcd-cert.sh etcd.sh

vim etcd-cert.sh 借用脚本切记IP地址

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

mkdir /opt/k8s/etcd-cert
mv etcd-cert.sh etcd-cert/
cd /opt/k8s/etcd-cert/
./etcd-cert.sh			#生成CA证书、etcd 服务器证书以及私钥

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 PEM :一般文本格式可以保存证书私钥

2 KEY: 私钥

4.6 上传 etcd-v3.4.9-linux-amd64.tar.gz 到 /opt/k8s 目录中，启动etcd服务

https://github.com/etcd-io/etcd/releases/download/v3.4.9/etcd-v3.4.9-linux-amd64.tar.gz

cd /opt/k8s/
tar zxvf etcd-v3.4.9-linux-amd64.tar.gz
ls etcd-v3.4.9-linux-amd64
Documentation  etcd  etcdctl  README-etcdctl.md  README.md  READMEv2-etcdctl.md
------------------------------------------------------------------------------------------
etcd就是etcd 服务的启动命令，后面可跟各种启动参数
etcdctl主要为etcd 服务提供了命令行操作
------------------------------------------------------------------------------------------

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

mkdir -p /opt/etcd/{cfg,bin,ssl}

cd /opt/k8s/etcd-v3.4.9-linux-amd64/
mv etcd etcdctl /opt/etcd/bin/
cp /opt/k8s/etcd-cert/*.pem /opt/etcd/ssl/

cd /opt/k8s/
./etcd.sh etcd01 192.168.11.6 etcd02=https://192.168.11.11:2380,etcd03=https://192.168.11.12:2380

#进入卡住状态等待其他节点加入，这里需要三台etcd服务同时启动，如果只启动其中一台后，服务会卡在那里，直到集群中所有etcd节点都已启动，可忽略这个情况

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

再打开另一个Xshell窗口进行验证

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

scp -r /opt/etcd/ root@192.168.11.12:/opt/
scp -r /opt/etcd/ root@192.168.11.11:/opt/
scp /usr/lib/systemd/system/etcd.service root@192.168.11.11:/usr/lib/systemd/system/
scp /usr/lib/systemd/system/etcd.service root@192.168.11.12:/usr/lib/systemd/system/

4.9 在 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.11.11:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.11.11:2379"

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


#启动etcd服务
systemctl start etcd
systemctl enable etcd     ##systemctl enable --now etcd
systemctl在enable、disable、mask子命令里面增加了--now选项，可以激活同时启动服务，激活同时停止服务等。
 
systemctl status etcd

此时由于快照虚拟机宕机 ip修改如下

master01：192.168.11.5

node01:192.168.11.7

node02:192.168.11.14

4.10 node02 节点操作：

在 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.11.7:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.11.7:2379"

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


#启动etcd服务
systemctl start etcd
systemctl enable etcd
systemctl status etcd

再次查看master01节点的etcd服务的状态

注意：三台机器任意一台都可以查看集群信息，先启动那台etcd会成为master

master先启动etcd服务再启动两台的node的etcd服务，先启动etcd的那台机器会成为 master

4.11 查看etcd集群状态

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.11.5:2379,https://192.168.11.7:2379,https://192.168.11.14:2379" endpoint health --write-out=table

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.11.5:2379,https://192.168.11.7:2379,https://192.168.11.14:2379" endpoint status --write-out=table

4.12 查看etcd集群成员列表


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.11.4:2379,https://192.168.11.7:2379,https://192.168.11.14:2379" --write-out=table member list

etcd 分布式键值对数据库  服务发现系统
go语言开发，它使用raft一致性算法集群时需要3台或以上的奇数台组成

2379对外(客户端)通信的端口
2380对内(集群内部节点间）通信的端口
 

etcd 安装步骤
准备CA证书和私钥文件,首先CA签发服务端 证书和私钥文件

使用CA 证书 服务端证书 、私钥文件 加上 etcd 集群配置文件去 启动 etcd 服务

复制etcd 工作目录和管理文件 到另外几个节点上(node01 node02)，修改 etcd集群配置文件并目启动etcd 服务

使用 V3 版本的接口 去执行 etcdctl+ 证书选项(endpoint healh) 或者endpoint status 或或者member list 査看etcd集群和节点的状态

五 master组件签发证书------在 master01 节点上操作

1 上传 master.zip 和 k8s-cert.sh 到 /opt/k8s 目录中，解压 master.zip 压缩包

cd /opt/k8s/

unzip master.zip

chmod +x *.sh

查看脚本内容，无需修改

[root@master01 k8s]# vim admin.sh

#!/bin/bash
mkdir /root/.kube
KUBE_CONFIG="/root/.kube/config"
KUBE_APISERVER="https://192.168.11.5: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}

[root@master01 k8s]# vim admin.sh

查看脚本内容，无需修改

[root@master01 k8s]# vim apiserver.sh

#!/bin/bash
#example: apiserver.sh 192.168.80.10 https://192.168.80.10:2379,https://192.168.80.11:2379,https://192.168.80.12: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

查看脚本，改为master ip

[root@master01 k8s]# vim controller-manager.sh

[root@master01 k8s]# vim scheduler.sh

2 创建kubernetes工作目录

mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs}

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

mkdir /opt/k8s/k8s-cert
mv /opt/k8s/k8s-cert.sh /opt/k8s/k8s-cert
cd /opt/k8s/k8s-cert/
chmod +x k8s-cert.sh
vim k8s-cert.sh
./k8s-cert.sh				#生成CA证书、相关组件的证书和私钥

ls *pem
admin-key.pem  apiserver-key.pem  ca-key.pem  kube-proxy-key.pem  
admin.pem      apiserver.pem      ca.pem      kube-proxy.pem

注意：实验中要把文字注释掉否则启动时只有六个文件

[root@master01 k8s]# vim k8s-cert.sh

注意：会生成8个pem结尾的证书

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

cp ca*pem apiserver*pem /opt/kubernetes/ssl/

5 上传/解压 kubernetes 压缩包

上传 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二进制文件。

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

cd /opt/k8s/kubernetes/server/bin
cp kube-apiserver kubectl kube-controller-manager kube-scheduler /opt/kubernetes/bin/
ln -s /opt/kubernetes/bin/* /usr/local/bin/

7 创建 bootstrap token 认证文件，apiserver 启动时会调用

bootstrap token概念：

要让 api server 信任 worker，worker 得需要先过 master 认证鉴权这一关。k8s 以插件化的方式支持很多种认证方式，比如 token 文件，x509证书，service account 等等，其中就包含一个名为“Bootstrap Token Authentication”的认证方式，基本上 k8s 的默认安装就默认支持这种认证方式。这种方式最初就是设计用来给添加 worker node 用的。使用 Bootstrap Token Authentication 时，只需告诉 kubelet 一个特殊的 token，kubelet 自然就能通过 api server 的认证

创建 bootstrap token 认证文件，apiserver 启动时会调用，然后就相当于在集群内创建了一个这个用户，接下来就可以用 RBAC 给他授权
cd /opt/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

chmod +x token.sh
./token.sh

cat /opt/kubernetes/cfg/token.csv

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

二进制文件、token、证书都准备好后，开启 apiserver 服务
cd /opt/k8s/
./apiserver.sh 192.168.11.6 https://192.168.11.6:2379,https://192.168.11.7:2379,https://192.168.11.14:2379

9 检查进程是否启动成功

ps aux | grep kube-apiserver

netstat -natp | grep 6443   
#apiserver端口6443用于接收HTTPS请求，用于基于Token文件或客户端证书等认证

10 执行另外三个脚本

启动 scheduler 服务
cd /opt/k8s/
./scheduler.sh
ps aux | grep kube-scheduler

#启动 controller-manager 服务
./controller-manager.sh
ps aux | grep kube-controller-manager


#生成kubectl连接集群的kubeconfig文件
./admin.sh

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

有了 kubeconfig 文件，就可以使用 kubectl 命令行工具连接到 Kubernetes 集群了。

kubeconfig 文件是客户端（如 kubectl）用来连接集群的配置文件。它包含了集群的访问信息，如 API 服务器的地址、认证凭据等。

编辑脚本：

vim admin.sh

把apiserver ip地址改为masterip

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

kubectl get cs

六部署 Worker Node 组件

1）在所有 node 节点上操作

1 创建kubernetes工作目录

mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs}

2 上传 node.zip 到 /opt 目录中，解压 node.zip 压缩包，获得kubelet.sh、proxy.sh

cd /opt/
unzip node.zip
chmod +x kubelet.sh proxy.sh

3 在 master01 节点上操作

#把 kubelet、kube-proxy 拷贝到 node 节点
cd /opt/k8s/kubernetes/server/bin
scp kubelet kube-proxy root@192.168.10.18:/opt/kubernetes/bin/
scp kubelet kube-proxy root@192.168.10.19:/opt/kubernetes/bin/

4 上传kubeconfig.sh文件到/opt/k8s/kubeconfig目录中，生成kubelet初次加入集群引导kubeconfig文件和kube-proxy.kubeconfig文件

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

上传kubeconfig.sh文件到/opt/k8s/kubeconfig目录中，生成kubelet初次加入集群引导kubeconfig文件和kube-proxy.kubeconfig文件
#kubeconfig 文件包含集群参数（CA 证书、API Server 地址），客户端参数（上面生成的证书和私钥），集群 context 上下文参数（集群名称、用户名）。Kubenetes 组件（如 kubelet、kube-proxy）通过启动时指定不同的 kubeconfig 文件可以切换到不同的集群，连接到 apiserver。
mkdir /opt/k8s/kubeconfig

cd /opt/k8s/kubeconfig
chmod +x kubeconfig.sh
./kubeconfig.sh 192.168.11.5 /opt/k8s/k8s-cert/

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

把配置文件 bootstrap.kubeconfig、kube-proxy.kubeconfig 拷贝到 node 节点
scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.11.7:/opt/kubernetes/cfg/
scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.11.14:/opt/kubernetes/cfg/

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

RBAC授权，使用户 kubelet-bootstrap 能够有权限发起 CSR 请求证书
kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap

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

kubelet 采用 TLS Bootstrapping 机制，自动完成到 kube-apiserver 的注册，在 node 节点量较大或者后期自动扩容时非常有用。
Master apiserver 启用 TLS 认证后，node 节点 kubelet 组件想要加入集群，必须使用CA签发的有效证书才能与 apiserver 通信，当 node 节点很多时，签署证书是一件很繁琐的事情。因此 Kubernetes 引入了 TLS bootstraping 机制来自动颁发客户端证书，kubelet 会以一个低权限用户自动向 apiserver 申请证书，kubelet 的证书由 apiserver 动态签署。

kubelet 首次启动通过加载 bootstrap.kubeconfig 中的用户 Token 和 apiserver CA 证书发起首次 CSR 请求，这个 Token 被预先内置在 apiserver 节点的 token.csv 中，其身份为 kubelet-bootstrap 用户和 system:kubelet-bootstrap 用户组；想要首次 CSR 请求能成功（即不会被 apiserver 401 拒绝），则需要先创建一个 ClusterRoleBinding，将 kubelet-bootstrap 用户和 system:node-bootstrapper 内置 ClusterRole 绑定（通过 kubectl get clusterroles 可查询），使其能够发起 CSR 认证请求。

TLS bootstrapping 时的证书实际是由 kube-controller-manager 组件来签署的，也就是说证书有效期是 kube-controller-manager 组件控制的；kube-controller-manager 组件提供了一个 --experimental-cluster-signing-duration 参数来设置签署的证书有效时间；默认为 8760h0m0s，将其改为 87600h0m0s，即 10 年后再进行 TLS bootstrapping 签署证书即可。

也就是说 kubelet 首次访问 API Server 时，是使用 token 做认证，通过后，Controller Manager 会为 kubelet 生成一个证书，以后的访问都是用证书做认证了。

kubelet 采用 TLS Bootstrapping 机制，自动完成到 kube-apiserver 的注册，在 node 节点量较大或者后期自动扩容时非常有用。

Master apiserver 启用 TLS 认证后，node 节点 kubelet 组件想要加入集群，必须使用CA签发的有效证书才能与 apiserver 通信，当 node 节点很多时，签署证书是一件很繁琐的事情。因此 Kubernetes 引入了 TLS bootstraping 机制来自动颁发客户端证书，kubelet 会以一个低权限用户自动向 apiserver 申请证书，kubelet 的证书由 apiserver 动态签署。

kubelet 首次启动通过加载 bootstrap.kubeconfig 中的用户 Token 和 apiserver CA 证书发起首次 CSR 请求，这个 Token 被预先内置在 apiserver 节点的 token.csv 中，其身份为 kubelet-bootstrap 用户和 system:kubelet-bootstrap 用户组；想要首次 CSR 请求能成功（即不会被 apiserver 401 拒绝），则需要先创建一个 ClusterRoleBinding，将 kubelet-bootstrap 用户和 system:node-bootstrapper 内置 ClusterRole 绑定（通过 kubectl get clusterroles 可查询），使其能够发起 CSR 认证请求。

TLS bootstrapping 时的证书实际是由 kube-controller-manager 组件来签署的，也就是说证书有效期是 kube-controller-manager 组件控制的；kube-controller-manager 组件提供了一个 --experimental-cluster-signing-duration 参数来设置签署的证书有效时间；默认为 8760h0m0s，将其改为 87600h0m0s，即 10 年后再进行 TLS bootstrapping 签署证书即可。

也就是说 kubelet 首次访问 API Server 时，是使用 token 做认证，通过后，Controller Manager 会为 kubelet 生成一个证书，以后的访问都是用证书做认证了。

2）在 node01 节点上操作

1 启动 kubelet 服务

在 node01 节点上操作
#启动 kubelet 服务
cd /opt/
./kubelet.sh 192.168.11.7
ps aux | grep kubelet

2 在 master01 节点上操作，通过 CSR 请求

在 master01 节点上操作，通过 CSR 请求
#检查到 node01 节点的 kubelet 发起的 CSR 请求，Pending 表示等待集群给该节点签发证书
kubectl get csr
NAME                                                   AGE  SIGNERNAME                                    REQUESTOR           CONDITION
node-csr-duiobEzQ0R93HsULoS9NT9JaQylMmid_nBF3Ei3NtFE   12s  kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Pending

通过 CSR 请求
kubectl certificate approve node-csr-duiobEzQ0R93HsULoS9NT9JaQylMmid_nBF3Ei3NtFE

3 Approved,Issued 表示已授权 CSR 请求并签发证书

Approved,Issued 表示已授权 CSR 请求并签发证书
kubectl get csr
NAME                                                   AGE  SIGNERNAME                                    REQUESTOR           CONDITION
node-csr-duiobEzQ0R93HsULoS9NT9JaQylMmid_nBF3Ei3NtFE   2m5s kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Approved,Issued

4 查看节点，由于网络插件还没有部署，节点会没有准备就绪 NotReady

kubectl get node
NAME            STATUS     ROLES    AGE    VERSION
192.168.10.18   NotReady   <none>   108s   v1.20.11

3）在 node01 节点上操作

加载 ip_vs 模块

启动proxy服务

#加载 ip_vs 模块
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

#启动proxy服务
cd /opt/
./proxy.sh 192.168.11.7
ps aux | grep kube-proxy