【Kubernetes】单Master集群部署（第二篇）

目录

前言

一、实验环境

二、操作系统初始化配置

三、部署 docker引擎

四、部署 etcd 集群

4.1 准备签发证书环境

4.2 准备cfssl证书生成工具

4.3 生成Etcd证书

4.4 启动etcd服务

4.5 检查群集状态

五、部署 Master 组件

5.1 准备软件包

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

5.3 上传kubernetes 压缩包

5.4 创建认证文件

5.5 开启apiserver服务

5.6  启动scheduler 服务

​5.7 启动 controller-manager 服务

5.8  其他

六、部署 Worker Node 组件

七、部署 CNI 网络组件

​八、总结

8.1  关于etcd

8.2  etcd 安装步骤

8.3  master组件安装过程

---

前言

常见的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

一、实验环境

         考虑到电脑性能，我将etcd部署在master和node节点上，并且我这边只搭建两个node节点

主机	IP地址
K8s集群master01	192.168.166.11
K8s集群node01	192.168.166.11
K8s集群node02	192.168.166.11
etcd集群节点1	192.168.166.11
etcd集群节点2	192.168.166.12
etcd集群节点3	192.168.166.13

二、操作系统初始化配置

#关闭防火墙
systemctl stop firewalld
systemctl disable firewalld
#-X清除自定义的规则
iptables -F && iptables -t nat -F && iptables -t mangle -F && iptables -X#关闭selinux
setenforce 0
sed -i 's/enforcing/disabled/' /etc/selinux/config#关闭swap
swapoff -a
sed -ri 's/.*swap.*/#&/' /etc/fstab #根据规划设置主机名
hostnamectl set-hostname master01
hostnamectl set-hostname node01
hostnamectl set-hostname node02#在master添加hosts
cat >> /etc/hosts << EOF
192.168.166.11 master01
192.168.166.12 node01
192.168.166.13 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
EOFsysctl --system#时间同步
yum install ntpdate -y
ntpdate time.windows.com

三、部署 docker引擎

#所有 node 节点部署docker引擎
#如果想要让master节点也能创建pod，也可以安装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.iomkdir /etc/docker
cat > /etc/docker/daemon.json <<EOF
{"registry-mirrors": ["https://docker.m.daocloud.io", "https://docker.1panel.live"],"exec-opts": ["native.cgroupdriver=systemd"],"log-driver": "json-file","log-opts": {"max-size": "1g", "max-file": "3"}
}
EOFsystemctl start docker.service
systemctl enable docker.service docker info | grep "Cgroup Driver"
Cgroup Driver: systemd

四、部署 etcd 集群

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

etcd作为服务发现系统，有以下的特点：

• 简单：安装配置简单，而且提供了HTTPAPI进行交互，使用很简单安全：支持SSL证书验证
• 快速：单实例支持每秒2k+读操作
• 可靠：采用raft算法，实现分布式系统数据的可用性和一致性

        etcd 目前默认使用2379端口提供HTTPAPI服务，2380端口和peer通信（这两个端口已经被IANA（互联网数字分配机构）官方预留给etcd）。

        即etcd默认使用2379端口对外为客户端提供通讯，使用端口2380来进行服务器间内部通讯。

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

4.1 准备签发证书环境

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

        CFSSIL使用配置文件生成证书，因此自签之前，需要生成它识别的json格式的配置文件，CFSSL提供了方便的命令行生成配置文件。

        CFSSL用来为etcd提供TLS证书，它支持签三种类型的证书：

1. client 证书，服务端连接客户端时携带的证书，用于客户端验证服务端身份，如kube-apiserver 访问 etcd；
2. server证书，客户端连接服务端时携带的证书，用于服务端验证客户端身份，如etcd对外提供服务；
3. peer证书，相互之间连接时使用的证书，如etcd节点之间进行验证和通信。

这里为了方便全部都使用同一套证书认证，生产环境中一般不这样使用。

4.2 准备cfssl证书生成工具

在master01节点上操作

linux下载两种方式：

wget 源URL地址 [-o 指定路径]

curl -L 源URL地址 -o 指定路径

#准备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#也可以下载好上传上去
chmod +x /usr/local/bin/cfssl*

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

4.3 生成Etcd证书

mkdir /opt/k8s
cd /opt/k8s/#上传 etcd-cert.sh 和 etcd.sh 到 /opt/k8s/ 目录中
chmod +x etcd-cert.sh etcd.sh#创建用于生成CA证书、etcd 服务器证书以及私钥的目录
mkdir /opt/k8s/etcd-cert
mv etcd-cert.sh etcd-cert/
cd /opt/k8s/etcd-cert/
./etcd-cert.sh   #生成了CA证书、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.166.11","192.168.166.12","192.168.166.13"],"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
#-profile：指定证书生成策略文件中的的使用场景，比如 ca-config.json 中的 www

4.4 启动etcd服务

#上传 etcd-v3.4.26-linux-amd64.tar.gz 到 /opt/k8s 目录中，启动etcd服务
https://github.com/etcd-io/etcd/releases/download/v3.4.26/etcd-v3.4.26-linux-amd64.tar.gzcd /opt/k8s/
tar zxvf etcd-v3.4.26-linux-amd64.tar.gz
ls etcd-v3.4.26-linux-amd64
Documentation  etcd  etcdctl  README-etcdctl.md  README.md  READMEv2-etcdctl.md
------------------------------------------------------------------------------------------
etcd就是etcd 服务的启动命令，后面可跟各种启动参数
etcdctl主要为etcd 服务提供了命令行操作
------------------------------------------------------------------------------------------#创建用于存放 etcd 配置文件，命令文件，证书的目录
mkdir -p /opt/etcd/{cfg,bin,ssl}cd /opt/k8s/etcd-v3.4.26-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.166.11
etcd02=https://192.168.166.12:2380,etcd03=https://192.168.166.13:2380

etcd.sh文件解读

#!/bin/bash#创建etcd配置文件/opt/etcd/cfg/etcd
ETCD_NAME=$1
ETCD_IP=$2
ETCD_CLUSTER=$3WORK_DIR=/opt/etcdcat > $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

#复制配置文件到其他节点
scp -r /opt/etcd/ root@192.168.166.12:/opt/
scp -r /opt/etcd/ root@192.168.1666.13:/opt/
scp /usr/lib/systemd/system/etcd.service root@192.168.166.12:/usr/lib/systemd/system/
scp /usr/lib/systemd/system/etcd.service root@192.168.166.13:/usr/lib/systemd/system/#在 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.166.12:2380"		        	#修改
ETCD_LISTEN_CLIENT_URLS="https://192.168.166.12:2379"		            #修改#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.166.12:2380"	    	#修改
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.166.12:2379"				#修改
ETCD_INITIAL_CLUSTER="etcd01 192.168.166.11 etcd02=https://192.168.166.12:2380,etcd03=https://192.168.166.13:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"systemctl start etcd
systemctl enable etcd
systemctl status etcd#在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.166.13:2380"			            #修改
ETCD_LISTEN_CLIENT_URLS="https://192.168.166.13:2379"	            	#修改#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.166.13:2380"		    #修改
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.166.13:2379"				#修改
ETCD_INITIAL_CLUSTER="etcd01 192.168.166.11 etcd02=https://192.168.166.12:2380,etcd03=https://192.168.166.13:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"systemctl start etcd
systemctl enable etcd
systemctl status etcd

systemctl daemon-reload
systemctl restart etcd.service
systemctl enable etcd.service 
systemctl status etcd.service

4.5 检查群集状态

#检查etcd群集状态
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://192.168.80.10:2379,https://192.168.80.11:2379,https://192.168.80.12:2379" --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem  endpoint health --write-out=table#查看当前的 leader
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://192.168.80.10:2379,https://192.168.80.11:2379,https://192.168.80.12:2379" --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem  endpoint status --write-out=table------------------------------------------------------------------------------------------
--cacert ：使用此CA证书验证启用https的服务器的证书
--key ：使用此TLS密钥文件标识HTTPS客户端
--cert ：使用此TLS证书文件标识HTTPS客户端
--endpoints：集群中以逗号分隔的机器地址列表
cluster-health：检查etcd集群的运行状况
------------------------------------------------------------------------------------------#查看etcd集群成员列表
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://192.168.80.10:2379" --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem  --write-out=table member list#备份etcd数据
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://192.168.80.10:2379" --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem  snapshot save /data/backup/etcd-snapshot.dbETCDCTL_API=3 /opt/etcd/bin/etcdctl  snapshot status /data/backup/etcd-snapshot.db -wtable#恢复etcd数据
systemctl stop etcd                     #先停止所有的etcd服务，删除现有数据mv /var/lib/etcd /var/lib/etcd.bakETCDCTL_API=3 /opt/etcd/bin/etcdctl snapshot restore /data/backup/etcd-snapshot.db --data-dir /var/lib/etcd --name etcd01 --initial-advertise-peer-urls https://192.168.80.10:2380 --initial-cluster etcd01=https://192.168.80.10:2380,etcd02=https://192.168.80.11:2380,etcd03=https://192.168.80.12:2380 --initial-cluster-token etcd-cluster 
注：如果有多个 etcd 节点，需要确保 --initial-cluster 参数包含所有节点的信息，并且每个节点的 --name、--initial-advertise-peer-urls 和其他相关参数都是正确配置的。systemctl start etcd

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

五、部署 Master 组件

         在master01上操作

5.1 准备软件包

#上传 master.zip 和 k8s-cert.sh 到 /opt/k8s 目录中，解压 master.zip 压缩包
cd /opt/k8s/
unzip master.zip
chmod +x *.sh

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

#创建kubernetes工作目录
mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs}#创建用于生成CA证书、相关组件的证书和私钥的目录
mkdir /opt/k8s/k8s-cert
mv /opt/k8s/k8s-cert.sh /opt/k8s/k8s-cert
cd /opt/k8s/k8s-cert/
vim k8s-cet.sh              #修改ip地址，删掉ip地址后面的注释
./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#复制CA证书、apiserver相关证书和私钥到 kubernetes工作目录的 ssl 子目录中
cp ca*pem apiserver*pem /opt/kubernetes/ssl/

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"}]
}
EOFcfssl 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.166"192.168.166.11",		#master01"192.168.166.14",		#master02"192.168.166.200",	#vip，后面 keepalived 使用"192.168.166.15",		#load balancer01（master）"192.168.166.136",	#load balancer02（backup）"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"}]
}
EOFcfssl 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"}]
}
EOFcfssl 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"}]
}
EOFcfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-proxy-csr.json | cfssljson -bare kube-proxy

5.3 上传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二进制文件.
cd /opt/k8s/
tar zxvf kubernetes-server-linux-amd64.tar.gz
#复制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/

5.4 创建认证文件

#创建 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"
EOFchmod +x token.sh
./token.shcat /opt/kubernetes/cfg/token.csv

5.5 开启apiserver服务

先启动apiserver才能启动scheduler和manager

#二进制文件、token、证书都准备好后，开启 apiserver 服务
cd /opt/k8s/
./apiserver.sh 192.168.166.11 https://192.168.166.11:2379,https://192.168.166.12:2379,https://192.168.166.13:2379#检查进程是否启动成功
ps aux | grep kube-apiservernetstat -natp | grep 6443   #安全端口6443用于接收HTTPS请求，用于基于Token文件或客户端证书等认证

5.6  启动scheduler 服务

cd /opt/k8s/
vim scheduler.sh  #修改ip地址
./scheduler.sh
ps aux | grep kube-scheduler

5.7 启动 controller-manager 服务

#启动 controller-manager 服务
vim controller-manager.sh  #修改IP地址
./controller-manager.sh
ps aux | grep kube-controller-manager

controller-manager.sh文件解读

#!/bin/bash
##创建 kube-controller-manager 启动参数配置文件
MASTER_ADDRESS=$1cat >/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-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.166.11: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
EOFsystemctl daemon-reload
systemctl enable kube-controller-manager
systemctl restart kube-controller-manager

5.8  其他

#生成kubectl连接集群的kubeconfig文件
./admin.sh#通过kubectl工具查看当前集群组件状态
kubectl get cs
NAME                 STATUS    MESSAGE             ERROR
controller-manager   Healthy   ok                  
scheduler            Healthy   ok                  
etcd-2               Healthy   {"health":"true"}   
etcd-1               Healthy   {"health":"true"}   
etcd-0               Healthy   {"health":"true"}  #查看版本信息
kubectl version#查看当前的 leader
kubectl -n kube-system get leases kube-scheduler
kubectl -n kube-system get leases kube-controller-manager

六、部署 Worker Node 组件

//在所有 node 节点上操作
#创建kubernetes工作目录
mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs}#上传 node.zip 到 /opt 目录中，解压 node.zip 压缩包，获得kubelet.sh、proxy.sh
cd /opt/
unzip node.zip
chmod +x kubelet.sh proxy.sh

//在 master01 节点上操作
#把 kubelet、kube-proxy 拷贝到 node 节点
cd /opt/k8s/kubernetes/server/bin
scp kubelet kube-proxy root@192.168.166.12:/opt/kubernetes/bin/
scp kubelet kube-proxy root@192.168.166.13:/opt/kubernetes/bin/#上传kubeconfig.sh文件到/opt/k8s/kubeconfig目录中，生成kubelet初次加入集群引导kubeconfig文件和kube-proxy.kubeconfig文件
#kubeconfig 文件包含集群参数（CA 证书、API Server 地址），客户端参数（上面生成的证书和私钥），集群 context 上下文参数（集群名称、用户名）。Kubenetes 组件（如 kubelet、kube-proxy）通过启动时指定不同的 kubeconfig 文件可以切换到不同的集群，连接到 apiserver。
mkdir /opt/k8s/kubeconfigcd /opt/k8s/kubeconfig
chmod +x kubeconfig.sh
./kubeconfig.sh 192.168.166.11 /opt/k8s/k8s-cert/#把配置文件 bootstrap.kubeconfig、kube-proxy.kubeconfig 拷贝到 node 节点
scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.166.12:/opt/kubernetes/cfg/
scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.166.13:/opt/kubernetes/cfg/#RBAC授权，使用户 kubelet-bootstrap 能够有权限发起 CSR 请求证书
kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap#自动批准 CSR 请求
kubectl create clusterrolebinding node-autoapprove-bootstrap --clusterrole=system:certificates.k8s.io:certificatesigningrequests:nodeclient --user=kubelet-bootstrap kubectl create clusterrolebinding node-autoapprove-certificate-rotation --clusterrole=system:certificates.k8s.io:certificatesigningrequests:selfnodeclient --user=kubelet-bootstrap

• 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 生成一个证书，以后的访问都是用证书做认证了。

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

//在 master01 节点上操作，通过 CSR 请求
#检查到 node01 节点的 kubelet 发起的 CSR 请求，Pending 表示等待集群给该节点签发证书
kubectl get csr
NAME                                                   AGE     SIGNERNAME                                    REQUESTOR           CONDITION
node-csr-en1Q0XeOW8rL3YTFS_fmRiSnM4pIj9WQWmfoB5yOZ-Q   2m12s   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Approved,Issued#通过 CSR 请求
kubectl certificate approve node-csr-en1Q0XeOW8rL3YTFS_fmRiSnM4pIj9WQWmfoB5yOZ-Q#Approved,Issued 表示已授权 CSR 请求并签发证书
kubectl get csr
NAME                                                   AGE  SIGNERNAME                                    REQUESTOR           CONDITION
node-csr-en1Q0XeOW8rL3YTFS_fmRiSnM4pIj9WQWmfoB5yOZ-Q   2m5s kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Approved,Issued#查看节点，由于网络插件还没有部署，节点会没有准备就绪 NotReady
kubectl get node
NAME             STATUS     ROLES    AGE    VERSION
192.168.166.12   NotReady   <none>   108s   v1.20.15

//在 node01 节点上操作
#加载 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.166.12
ps aux | grep kube-proxy

七、部署 CNI 网络组件

#上传 cni-plugins-linux-amd64-v1.3.0.tgz 和 flannel镜像文件 到 /opt 目录中
在 master01 节点上操作
上传flannel-v0.21.5.zip并解压
scp flannel*.tar 192.168.10.21:/opt/k8s/
scp flannel*.tar 192.168.10.22:/opt/k8s/
scp cni-plugins-linux-amd64-v1.3.0.tgz 192.168.10.21:/opt/k8s/
scp cni-plugins-linux-amd64-v1.3.0.tgz 192.168.10.22:/opt/k8s/

node两个节点操作
cd /opt/k8s/
docker load  -i flannel.tar
docker load  -i flannel-cni-plugin.tar 
docker imagesmkdir -p /opt/cni/bin
tar xf cni-plugins-linux-amd64-v1.3.0.tgz -C /opt/cni/bin/

master节点操作
#部署 CNI 网络
kubectl apply -f kube-flannel.yml
kubectl get pods -A
kubectl get pods -A -owide   #显示Running为正常
kubectl get nodes   #查看状态，显示ready为正常

八、总结

8.1  关于etcd

1. etcd分布式键值对数据库，服务发现系统
2. go语言开发的使用raft一致性算法
3. 集群时需3台或以上的奇数台组成
4. 2379对外（客户端）通信的端口
5. 2380对内（集群内部节点间）通信的端口

8.2  etcd 安装步骤

1. 准备ca证书和私钥文件，使用ca签发服务端证书和私钥文件
2. 使用ca证书、服务端证书和私钥文件加上etcd 集群配置文件去启动etcd 服务
3. 复制etcd工作目录和服务管理文件到另外几个节点上，修改etcd集群配置文件并启动etcd服务使用
4. v3版本的接口执行etcdctl+证书选项+（endpoint health I endpoint status I member list）查看etcd集群和节点状态

8.3  master组件安装过程

1、先安装apiserver

• 准备组件的相关证书和私钥文件
• 准备bootstrap token认证文件（给kubelet启动时签发证书时使用）
• 准备组件的启动配置文件
• 启动apiserver 服务端口号6443 https

2、再启动 controller-manager和scheduler

• 准备启动配置文件
• 准备证书和私钥文件生成kubeconfig文件（用于指定对接哪个apiserver，使用什么证书认证）
• 启动服务

3、检查集群组件状态

• 需要准备kubeconfig 文件把 kubectl加入到集群中（指定对接哪个apiserver，使用什么证书认证）
• kubectl get cs

4.、node组件安装过程

• 准备kubeconfig文件
• 启动kubelet，发送csr 请求证书
• 启动kube-proxy
• 安装CNI网络插件，实现pod跨主机的通信
• 安装CoreDNS插件，可以实现service名称解析到clusterIP