K8s 介绍、安装,二进制、kubeadm集群搭建(上)

目录

• • k8s 介绍
  • • ka8集群架构组建
    • • master组建(主控节点)
      • node组建(工作节点)
    • k8s核心概念
  • k8s集群搭建
  • • • 平台规划
      • 硬件配置
      • 部署方式
    • kubeadm部署
    • • 前置工作
      • 系统初始化
      • • • 关闭防火墙
          • 关闭 selinux
          • 关闭 swap
          • 设置主机名
          • 在master添加hosts,就是做映射
          • 将桥接的IPv4流量传递到iptables的链
          • 时间同步
      • 安装docker
      • • • 安装docker
          • 换docker仓库
          • 添加阿里云软件源
      • 安装kubeadm，kubelet和kubectl
      • • • 安装
          • 部署Kubernetes Master 只在master节点上执行,后面的默认只在master节点上执行,除了特殊说明的
          • 根据信息,直接复制粘贴,看上图
          • 在其他2个node节点上执行
          • 下载安装CNI网络插件
          • 测试集群是否成功
    • 二进制包
    • • 前置工作(同上)
      • 系统初始化(同上)
      • 部署etcd集群
      • • • 下载cfssl证书生成工具
          • 创建工作目录
          • 自签CA
          • 生成证书
          • 使用自签 CA 签发 Etcd HTTPS 证书
          • 生成证书
          • 下载etcd二进制包
          • 创建工作目录并解压
          • 创建etcd配置文件
          • systemd 管理 etcd
          • 把证书拷贝到ssl目录下
          • 将上面master节点 所有生成的文件拷贝到node1节点 和node2节点
          • 然后在node1 和 node2 分别修改 etcd.conf 配置文件中的节点名称和当前服务器IP
          • 三台机器分别设置
          • 查看集群状态
      • 为APIServer自签证书
      • 安装Docker
      • • • 这里是以二进制包形式进行安装
          • 解压
          • systemd 管理 docker
          • 创建配置文件
          • 启动并设置开机启动
          • 查看Docker状态
      • 部署 Master Node
      • • • 生成 kube-apiserver 证书
          • 生成证书
          • 使用自签 CA 签发 kube-apiserver HTTPS 证书
          • 生成证书
          • 下载二进制包
          • 解压
          • 部署 kube-apiserver
          • 部署 kube-controller-manager
          • 部署 kube-scheduler
          • 查看集群
      • 部署 Worker Node
      • • • 创建工作目录
          • 部署kubelet
          • 批准 kubelet 证书申请并加入集群
          • 部署 kube-proxy
          • 部署 CNI 网络
          • 授权 apiserver 访问 kubelet
          • 新增加 Worker Node

k8s 介绍

ka8集群架构组建

master组建(主控节点)

1. APIServer 集群统一入口,以restful方式,架构etcd存储
2. Scheduler 节点调度,选择node节点应用部署
3. Controller-manager 处理集群中常规后台任务,一个资源对应一个控制器
4. etcd 存储系统,用于保存集群相关数据

node组建(工作节点)

1. kubelet 是master派到node节点代表,管理本机容器生命周期
2. kube-proxy 提供网络代理,负载均衡等操作

k8s核心概念

• Pod
  1. 最小部署单元
  2. 一组容器的集合
  3. 共享网络
  4. 生命周期是短暂的
• controller
  1. 区别预期的pod副本数量
  2. 无状态应用部署
  3. 有状态应用部署(当一个节点挂了,另一个节点拿其中容器过来使用时,需要依赖存储,网络ip唯一,通俗的讲是需要约定的就是有状态)
  4. 确保所有的node运行同一个pod
  5. 一次性任务和定时任务
• Service
  1. 定义一组pod的访问规则

k8s集群搭建

平台规划

1. 单master集群和多master集群
2. 高可用集群

硬件配置

1. 测试环境

   • master节点： cpu 2核、内存 4g、硬盘 20g
   • node节点： cpu 4核、内存8g、硬盘 40g以上

2. 生产环境

   • master节点：cpu8核、内存16g、硬盘100g
   • node节点：cpu 16核、内存64g、硬盘500g

部署方式

1. kubeadm
2. 二进制包

kubeadm部署

三台机器同时

前置工作

1. 3台虚拟机都安装docker

系统初始化

关闭防火墙

#禁用防火墙
systemctl stop firewalld 
# 开机不启动防火墙
systemctl disable firewalld 

关闭 selinux

#永久
sed -i 's/enforcing/disabled/' /etc/selinux/config 
#临时
setenforce 0 

关闭 swap

## 这是不重启电脑,马上生效的,但不是永久的,重启电脑后会失效
#禁止swap分区
swapoff -a 
# 启动
swapon -a 
#查看分区交换状态
free -mh 
# 永久
sed -ri 's/.*swap.*/#&/' /etc/fstab 

设置主机名

hostnamectl set-homename 主机名

在master添加hosts,就是做映射

vim /etc/hosts
192.168.10.101 master
192.168.10.102 slave1
192.168.10.103 slave2

将桥接的IPv4流量传递到iptables的链

vim /etc/sysctl.d/k8s.conf #创建k8s.conf文件
## 添加
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1	

这个就是上面的,这个直接沾就好
cat > /etc/sysctl.d/k8s.conf << EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF
#让其生效
sysctl --system 

时间同步

yum install ntpdate -y
ntpdate time.windows.com

安装docker

安装docker

wget https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo -O /etc/yum.repos.d/docker-ce.repo
yum -y install docker-ce-18.06.1.ce-3.el7
systemctl enable docker && systemctl start docker
docker --version

换docker仓库

cat > /etc/docker/daemon.json << EOF
{
  "registry-mirrors": ["https://b9pmyelo.mirror.aliyuncs.com"]
}
EOF
# 重启docker
systemctl restart docker 

添加阿里云软件源

cat > /etc/yum.repos.d/kubernetes.repo << EOF
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=0
repo_gpgcheck=0
gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF

安装kubeadm，kubelet和kubectl

安装

# 这里指定了版本,可以修改
yum install -y kubelet-1.18.0 kubeadm-1.18.0 kubectl-1.18.0 
# 设置开机启动
systemctl enable kubelet 

部署Kubernetes Master 只在master节点上执行,后面的默认只在master节点上执行,除了特殊说明的

kubeadm init \
--apiserver-advertise-address=192.168.10.101 \
--image-repository registry.aliyuncs.com/google_containers \
--kubernetes-version v1.18.0 \
--service-cidr=10.96.0.0/12 \
--pod-network-cidr=10.244.0.0/16

拉取完成后的成功信息

根据信息,直接复制粘贴,看上图

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

kubectl get nodes #查看当前具有的node节点

在其他2个node节点上执行

## 这个复制拉取成功信息的最后2行,注意:不要再master节点上执行
kubeadm join 192.168.10.101:6443 --token oebqvp.3jppxyrd1rjsog9r \
--discovery-token-ca-cert-hash sha256:02dfc06bd0c34b439dc629a1e9883efdb99f228d7fd19d803ebb8b1794a97df6

可以不创建

#默认token有效期为24小时，当过期之后，该token就不可用了。这时就需要重新创建token
kubeadm token create --print-join-command 

之所以是NotReady是因为缺少网络插件

下载安装CNI网络插件

# 通过wget进行下载
wget https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

# 这个是直接通过kubectl进行安装,不需要wget,但因为国外源的原因,很慢,可以换源
kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml 

kubectl get pods -n kube-system # 查看相关信息

下面是全部运行完成的

测试集群是否成功

# 在Kubernetes集群中创建一个pod，验证是否正常运行
kubectl create deployment nginx --image=nginx # 创建一个nginx镜像 注意:需要等创建完再执行下一步
kubectl expose deployment nginx --port=80 --type=NodePort # 设置对外暴露端口,以node节点
kubectl get pod,svc #查看
# 下面是redis的
kubectl create deployment redis --image=redis
kubectl expose deployment redis --port=6379 --type=NodePort

当全部启动成功并完成执行后,安照对外暴露端口进行访问
这是nginx的

这是redis的,注意这是node节点上的

二进制包

前置工作(同上)

系统初始化(同上)

#禁用防火墙
systemctl stop firewalld 
# 开机不启动防火墙
systemctl disable firewalld 

# 关闭 selinux
#永久
sed -i 's/enforcing/disabled/' /etc/selinux/config 
#临时
setenforce 0 


# 关闭 swap
#禁止swap分区
swapoff -a 
# 启动
swapon -a 
#查看分区交换状态
free -mh 
# 永久
sed -ri 's/.*swap.*/#&/' /etc/fstab 

# 设置主机名
hostnamectl set-homename 主机名

# 在master添加hosts,就是做映射

vim /etc/hosts
192.168.10.101 master
192.168.10.102 slave1
192.168.10.103 slave2

# 将桥接的IPv4流量传递到iptables的链
cat > /etc/sysctl.d/k8s.conf << EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF
#让其生效
sysctl --system 

#时间同步

yum install ntpdate -y
ntpdate time.windows.com

部署etcd集群

下面步骤没说就是只在master机器上进行

下载cfssl证书生成工具

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

创建工作目录

mkdir -p /opt/soft/TLS/{etcd,k8s}
cd TLS/etcd

自签CA

cat > ca-config.json<< EOF
{
"signing": {
"default": {
"expiry": "87600h"
},
"profiles": {
"www": {
"expiry": "87600h",
"usages": [
"signing",
"key encipherment",
"server auth",
"client auth"
]
}
}
}
}
EOF

cat > ca-csr.json<< EOF
{
"CN": "etcd CA",
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"L": "Beijing",
"ST": "Beijing"
}
]
}
EOF

生成证书

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

使用自签 CA 签发 Etcd HTTPS 证书

# 注意改成自己集群的ip地址
cat > server-csr.json<< EOF
{
"CN": "etcd",
"hosts": [
"192.168.10.101",
"192.168.10.102",
"192.168.10.103"
],
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"L": "BeiJing",
"ST": "BeiJing"
}
]
}
EOF

生成证书

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

下载etcd二进制包

下载地址,点击直接下载

创建工作目录并解压

mkdir -p /opt/soft/etcd/{bin,cfg,ssl} 
tar zxvf etcd-v3.4.9-linux-amd64.tar.gz -C /opt/soft/
mv etcd-v3.4.9-linux-amd64/{etcd,etcdctl} /opt/soft/etcd/bin/

创建etcd配置文件

cat > /opt/soft/etcd/cfg/etcd.conf << EOF
#[Member]
ETCD_NAME="etcd-1"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.10.101:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.10.101:2379"
#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.10.101:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.10.101:2379"
ETCD_INITIAL_CLUSTER="etcd-1=https://192.168.10.101:2380,etcd-2=https://192.168.10.102:2380,etcd-3=https://192.168.10.103:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
EOF

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

systemd 管理 etcd

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=/opt/soft/etcd/cfg/etcd.conf
ExecStart=/opt/soft/etcd/bin/etcd \
--cert-file=/opt/soft/etcd/ssl/server.pem \
--key-file=/opt/soft/etcd/ssl/server-key.pem \
--peer-cert-file=/opt/soft/etcd/ssl/server.pem \
--peer-key-file=/opt/soft/etcd/ssl/server-key.pem \
--trusted-ca-file=/opt/soft/etcd/ssl/ca.pem \
--peer-trusted-ca-file=/opt/soft/etcd/ssl/ca.pem \
--logger=zap
Restart=on-failure
LimitNOFILE=65536
[Install]
WantedBy=multi-user.target
EOF

把证书拷贝到ssl目录下

cp /opt/soft/TLS/etcd/ca*pem /opt/soft/TLS/etcd/server*pem /opt/soft/etcd/ssl/

将上面master节点 所有生成的文件拷贝到node1节点 和node2节点

scp -r /opt/soft/etcd slave1:/opt/soft/
scp -r /opt/soft/etcd slave2:/opt/soft/
scp /usr/lib/systemd/system/etcd.service slave1:/usr/lib/systemd/system/
scp /usr/lib/systemd/system/etcd.service slave2:/usr/lib/systemd/system/

然后在node1 和 node2 分别修改 etcd.conf 配置文件中的节点名称和当前服务器IP

#[Member]
ETCD_NAME="etcd-2"
ETCD_DATA_DIR="/opt/soft/etcd/data/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.10.102:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.10.102:2379"
#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.10.102:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.10.102:2379"
ETCD_INITIAL_CLUSTER="etcd-1=https://192.168.10.101:2380,etcd-2=https://192.168.10.102:2380,etcd-3=https://192.168.10.103:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"

#[Member]
ETCD_NAME="etcd-3"
ETCD_DATA_DIR="/opt/soft/etcd/data/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.10.103:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.10.103:2379"
#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.10.103:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.10.103:2379"
ETCD_INITIAL_CLUSTER="etcd-1=https://192.168.10.101:2380,etcd-2=https://192.168.10.102:2380,etcd-3=https://192.168.10.103:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"

三台机器分别设置

# 重新加载配置
systemctl daemon-reload
# 启动etcd
systemctl start etcd
# 开机启动
systemctl enable etcd

查看集群状态

ETCDCTL_API=3 /opt/soft/etcd/bin/etcdctl --cacert=/opt/soft/etcd/ssl/ca.pem --cert=/opt/soft/etcd/ssl/server.pem --key=/opt/soft/etcd/ssl/server-key.pem --endpoints="https://192.168.10.101:2379,https://192.168.10.102:2379,https://192.168.10.103:2379"  endpoint health

以上就是etcd集群搭建成功

为APIServer自签证书

• 添加可信任的ip列表

vim /opt/soft/TLS/etcd/server-csr.json
#hosts中的ip就是可信任的ip列表
# 通过这个来生成证书
# cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=www server-csr.json | cfssljson -bare server 生成server-ley.pem 证书

• 携带ca证书进行发送(因为有部分场景不能携带所以大多情况用上面那种)

安装Docker

以下在所有节点操作

这里是以二进制包形式进行安装

二进制包下载地址

解压

tar zxvf docker-19.03.9.tgz
mv docker/* /usr/bin

systemd 管理 docker

cat > /usr/lib/systemd/system/docker.service << EOF
[Unit]
Description=Docker Application Container Engine
Documentation=https://docs.docker.com
After=network-online.target firewalld.service
Wants=network-online.target
[Service]
Type=notify
ExecStart=/usr/bin/dockerd
ExecReload=/bin/kill -s HUP $MAINPID
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity
TimeoutStartSec=0
Delegate=yes
KillMode=process
Restart=on-failure
StartLimitBurst=3
StartLimitInterval=60s
[Install]
WantedBy=multi-user.target
EOF

创建配置文件

mkdir /etc/docker
# 换成阿里源
cat > /etc/docker/daemon.json << EOF
{
"registry-mirrors": ["https://b9pmyelo.mirror.aliyuncs.com"]
}
EOF

启动并设置开机启动

systemctl daemon-reload
systemctl start docker
systemctl enable docker

查看Docker状态

systemctl status docker

部署 Master Node

Master Node 可以有多个

生成 kube-apiserver 证书

# 自签证书颁发机构（CA）
cat > /opt/soft/TLS/k8s/ca-config.json<< EOF
{
"signing": {
"default": {
"expiry": "87600h"
},
"profiles": {
"kubernetes": {
"expiry": "87600h",
"usages": [
"signing",
"key encipherment",
"server auth",
"client auth"
]
}
}
}
}
EOF

cat > /opt/soft/TLS/k8s/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 -

使用自签 CA 签发 kube-apiserver HTTPS 证书

cat > /opt/soft/TLS/k8s/server-csr.json<< EOF
{
"CN": "kubernetes",
"hosts": [
"10.0.0.1",
"127.0.0.1",
"192.168.10.101",
"192.168.10.102",
"192.168.10.103",
"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 server-csr.json | cfssljson -bare server

下载二进制包

# 这这里选择你的版本
https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG

我所选择的是1.19,下载server端

解压

mkdir -p /opt/soft/kubernetes/{bin,cfg,ssl,logs}
tar -zxvf kubernetes-server-linux-amd64.tar.gz -C /opt/soft/
cd /opt/soft/kubernetes-server-linux-amd64/kubernetes/server/bin
cp kube-apiserver kube-scheduler kube-controller-manager /opt/soft/kubernetes/bin/
cp /opt/soft/kubernetes-server-linux-amd64/kubernetes/server/bin/kubectl /usr/bin/

部署 kube-apiserver

1. 创建配置文件

cat > /opt/soft/kubernetes/cfg/kube-apiserver.conf << EOF
KUBE_APISERVER_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/soft/kubernetes/logs \\
--etcd-servers=https://192.168.10.101:2379,https://192.168.10.102:2379,https://192.168.10.103:2379 \\
--bind-address=192.168.10.101 \\
--secure-port=6443 \\
--advertise-address=192.168.10.101 \\
--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/soft/kubernetes/cfg/token.csv \\
--service-node-port-range=30000-32767 \\
--kubelet-client-certificate=/opt/soft/kubernetes/ssl/server.pem \\
--kubelet-client-key=/opt/soft/kubernetes/ssl/server-key.pem \\
--tls-cert-file=/opt/soft/kubernetes/ssl/server.pem \\
--tls-private-key-file=/opt/soft/kubernetes/ssl/server-key.pem \\
--client-ca-file=/opt/soft/kubernetes/ssl/ca.pem \\
--service-account-key-file=/opt/soft/kubernetes/ssl/ca-key.pem \\
--etcd-cafile=/opt/soft/etcd/ssl/ca.pem \\
--etcd-certfile=/opt/soft/etcd/ssl/server.pem \\
--etcd-keyfile=/opt/soft/etcd/ssl/server-key.pem \\
--audit-log-maxage=30 \\
--audit-log-maxbackup=3 \\
--audit-log-maxsize=100 \\
--audit-log-path=/opt/soft/kubernetes/logs/k8s-audit.log"
EOF

参数名	说明
–logtostderr	启用日志
—v	日志等级
–log-dir	日志目录
–etcd-servers	etcd 集群地址
–bind-address	监听地址
–secure-port	https 安全端口
–advertise-address	集群通告地址
–allow-privileged	启用授权
–service-cluster-ip-range	Service 虚拟 IP 地址段
–enable-admission-plugins	准入控制模块
–authorization-mode	认证授权，启用 RBAC 授权和节点自管理
–enable-bootstrap-token-auth	启用 TLS bootstrap 机制
–token-auth-file	bootstrap token 文件
–service-node-port-range	Service nodeport 类型默认分配端口范围–kubelet-client-xxx：apiserver 访问 kubelet 客户端证书
–tls-xxx-file	apiserver https 证书
–etcd-xxxfile	连接 Etcd 集群证书
–audit-log-xxx	审计日志

1. 拷贝证书

cp /opt/soft/TLS/k8s/ca*pem /opt/soft/TLS/k8s/server*pem /opt/soft/kubernetes/ssl/

TLS Bootstrapping 机制说明

TLS Bootstraping：Master apiserver 启用 TLS 认证后，Node 节点kubelet 和kube- proxy 要与 kube-apiserver 进行通信，必须使用 CA 签发的有效证书才可以，当Node节点很多时，这种客户端证书颁发需要大量工作，同样也会增加集群扩展复杂度。为了简化流程，Kubernetes 引入了 TLS bootstraping 机制来自动颁发客户端证书，kubelet会以一个低权限用户自动向 apiserver 申请证书，kubelet 的证书由apiserver 动态签署。所以强烈建议在 Node 上使用这种方式目前主要用于 kubelet，kube-proxy 还是由我们统一颁发一个证书。

1. 创建配置中的token文件

# 格式：token，用户名，UID，用户组
# token 也可自行生成替换
# head -c 16 /dev/urandom | od -An -t x | tr -d ' '
cat > /opt/soft/kubernetes/cfg/token.csv << EOF
c47ffb939f5ca36231d9e3121a252940,kubelet-bootstrap,10001,"system:nodebootstrapper"
EOF

1. systemd 管理 apiserver

cat > /usr/lib/systemd/system/kube-apiserver.service << EOF
[Unit]
Description=Kubernetes API Server
Documentation=https://github.com/kubernetes/kubernetes
[Service]
EnvironmentFile=/opt/soft/kubernetes/cfg/kube-apiserver.conf
ExecStart=/opt/soft/kubernetes/bin/kube-apiserver \$KUBE_APISERVER_OPTS
Restart=on-failure
[Install]
WantedBy=multi-user.target
EOF

1. 启动并设置开机启动

systemctl daemon-reload
systemctl start kube-apiserver
systemctl enable kube-apiserver

1. 授权 kubelet-bootstrap 用户允许请求证书

kubectl create clusterrolebinding kubelet-bootstrap \
--clusterrole=system:node-bootstrapper \
--user=kubelet-bootstrap

部署 kube-controller-manager

1. 创建配置文件

cat > /opt/soft/kubernetes/cfg/kube-controller-manager.conf << EOF
KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=false \\
--v=2 \\
-log-dir=/opt/soft/kubernetes/logs \\
--leader-elect=true \\
--master=127.0.0.1:8080 \\
--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/soft/kubernetes/ssl/ca.pem \\
--cluster-signing-key-file=/opt/soft/kubernetes/ssl/ca-key.pem \\
--root-ca-file=/opt/soft/kubernetes/ssl/ca.pem \\
--service-account-private-key-file=/opt/soft/kubernetes/ssl/ca-key.pem \\
--experimental-cluster-signing-duration=87600h0m0s"
EOF

参数名	说明
master	通过本地非安全本地端口 8080 连接 apiserver。
leader-elect	当该组件启动多个时，自动选举（HA）
cluster-signing-cert-file/–cluster-signing-key-file	自动为kubelet 颁发证书的 CA，与 apiserver 保持一致

1. systemd 管理 controller-manager

cat > /usr/lib/systemd/system/kube-controller-manager.service << EOF
[Unit]
Description=Kubernetes Controller Manager
Documentation=https://github.com/kubernetes/kubernetes
[Service]
EnvironmentFile=/opt/soft/kubernetes/cfg/kube-controller-manager.conf
ExecStart=/opt/soft/kubernetes/bin/kube-controller-manager \$KUBE_CONTROLLER_MANAGER_OPTS
Restart=on-failure
[Install]
WantedBy=multi-user.target
EOF

1. 启动并设置开机启动

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

部署 kube-scheduler

1. 创建配置文件

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

1. systemd 管理 scheduler

cat > /usr/lib/systemd/system/kube-scheduler.service << EOF
[Unit]
Description=Kubernetes Scheduler
Documentation=https://github.com/kubernetes/kubernetes
[Service]
EnvironmentFile=/opt/soft/kubernetes/cfg/kube-scheduler.conf
ExecStart=/opt/soft/kubernetes/bin/kube-scheduler \$KUBE_SCHEDULER_OPTS
Restart=on-failure
[Install]
WantedBy=multi-user.target
EOF

1. 启动

systemctl daemon-reload
systemctl start kube-scheduler
systemctl enable kube-scheduler

查看集群

kubectl get cs

部署 Worker Node

这里依旧在Master Node 上操作，即同时作为 Worker Node

创建工作目录

在所有 worker node上创建

mkdir -p /opt/soft/kubernetes/{bin,cfg,ssl,logs}
cp kubelet kube-proxy /opt/soft/kubernetes/bin/
scp kubelet kube-proxy slave1:/opt/soft/kubernetes/bin/
scp kubelet kube-proxy slave2:/opt/soft/kubernetes/bin/

部署kubelet

1. 创建配置文件

cat > /opt/soft/kubernetes/cfg/kubelet.conf << EOF
KUBELET_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/soft/kubernetes/logs \\
--hostname-override=k8s-master \\
--network-plugin=cni \\
--kubeconfig=/opt/soft/kubernetes/cfg/kubelet.kubeconfig \\
--bootstrap-kubeconfig=/opt/soft/kubernetes/cfg/bootstrap.kubeconfig \\
--config=/opt/soft/kubernetes/cfg/kubelet-config.yml \\
--cert-dir=/opt/soft/kubernetes/ssl \\
--pod-infra-container-image=lizhenliang/pause-amd64:3.0"
EOF

参数名	说明
–hostname-override	显示名称，集群中唯一
–network-plugin	启用 CNI –kubeconfig：空路径，会自动生成，后面用于连接 apiserver –bootstrap-kubeconfig：首次启动向 apiserver 申请证书
–config	配置参数文件
–cert-dir	kubelet 证书生成目录
–pod-infra-container-image	管理 Pod 网络容器的镜像

1. 配置参数文件

cat > /opt/soft/kubernetes/cfg/kubelet-config.yml << EOF
kind: KubeletConfiguration
apiVersion: kubelet.config.k8s.io/v1beta1
address: 0.0.0.0
port: 10250
readOnlyPort: 10255
cgroupDriver: cgroupfs
clusterDNS:
- 10.0.0.2
clusterDomain: cluster.local
failSwapOn: false
authentication:
anonymous:
enabled: false
webhook:
cacheTTL: 2m0s
enabled: true
x509:
clientCAFile: /opt/soft/kubernetes/ssl/ca.pem
authorization:
mode: Webhook
webhook:
cacheAuthorizedTTL: 5m0s
cacheUnauthorizedTTL: 30s
evictionHard:
imagefs.available: 15%
memory.available: 100Mi
nodefs.available: 10%
nodefs.inodesFree: 5%
maxOpenFiles: 1000000
maxPods: 110
EOF

1. 生成 bootstrap.kubeconfig 文件

# apiserver IP:PORT
KUBE_APISERVER="https://192.168.10.101:6443" 
 # 与 token.csv 里保持一致
TOKEN="c47ffb939f5ca36231d9e3121a252940"

kubectl config set-cluster kubernetes \
--certificate-authority=/opt/soft/kubernetes/ssl/ca.pem \
--embed-certs=true \
--server=${KUBE_APISERVER} \
--kubeconfig=bootstrap.kubeconfig

kubectl config set-credentials "kubelet-bootstrap" \
--token=${TOKEN} \
--kubeconfig=bootstrap.kubeconfig

kubectl config set-context default \
--cluster=kubernetes \
--user="kubelet-bootstrap" \
--kubeconfig=bootstrap.kubeconfig

kubectl config use-context default --kubeconfig=bootstrap.kubeconfig

1. systemd 管理 kubelet

cat > /usr/lib/systemd/system/kubelet.service << EOF
[Unit]
Description=Kubernetes Kubelet
After=docker.service
[Service]
EnvironmentFile=/opt/soft/kubernetes/cfg/kubelet.conf
ExecStart=/opt/soft/kubernetes/bin/kubelet \$KUBELET_OPTS
Restart=on-failure
LimitNOFILE=65536
[Install]
WantedBy=multi-user.target
EOF

1. . 启动并设置开机启动

systemctl daemon-reload
systemctl start kubelet
systemctl enable kubelet

批准 kubelet 证书申请并加入集群

1. 查看 kubelet 证书请求

kubectl get csr

1. 批准申请

kubectl certificate approve node-csr-_v2zmS6MEmf238-fcdpxGlUI1uMMnrGszK9u1RslpzI

1. 查看节点

#由于网络插件还没有部署，节点会没有准备就绪 NotReady
kubectl get node

部署 kube-proxy

1. 创建配置文件

cat > /opt/soft/kubernetes/cfg/kube-proxy.conf << EOF
KUBE_PROXY_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/soft/kubernetes/logs \\
--config=/opt/soft/kubernetes/cfg/kube-proxy-config.yml"
EOF

1. 配置参数文件

# 注意,这里的这个缩进是必须的
cat > /opt/soft/kubernetes/cfg/kube-proxy-config.yml << EOF
kind: KubeProxyConfiguration
apiVersion: kubeproxy.config.k8s.io/v1alpha1
bindAddress: 0.0.0.0
metricsBindAddress: 0.0.0.0:10249
clientConnection:
  kubeconfig: /opt/soft/kubernetes/cfg/kube-proxy.kubeconfig
hostnameOverride: k8s-master
clusterCIDR: 10.0.0.0/24
EOF

1. . 生成 kube-proxy.kubeconfig 文件

# 在k8s目录下
cd /opt/soft/TLS/k8s
# 创建json文件
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

生成 kubeconfig 文件

KUBE_APISERVER="https://192.168.10.101:6443"

kubectl config set-cluster kubernetes \
--certificate-authority=/opt/soft/kubernetes/ssl/ca.pem \
--embed-certs=true \
--server=${KUBE_APISERVER} \
--kubeconfig=kube-proxy.kubeconfig

kubectl config set-credentials kube-proxy \
--client-certificate=./kube-proxy.pem \
--client-key=./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

kubectl config use-context default --kubeconfig=kube-proxy.kubeconfig

拷贝到配置文件指定路径

cp kube-proxy.kubeconfig /opt/soft/kubernetes/cfg/

1. systemd 管理 kube-proxy

cat > /usr/lib/systemd/system/kube-proxy.service << EOF
[Unit]
Description=Kubernetes Proxy
After=network.target
[Service]
EnvironmentFile=/opt/soft/kubernetes/cfg/kube-proxy.conf
ExecStart=/opt/soft/kubernetes/bin/kube-proxy \$KUBE_PROXY_OPTS
Restart=on-failure
LimitNOFILE=65536
[Install]
WantedBy=multi-user.target
EOF

1. 启动

systemctl daemon-reload
systemctl start kube-proxy
systemctl status kube-proxy
systemctl enable kube-proxy

部署 CNI 网络

1. 下载

[下载地址](https://github.com/containernetworking/plugins/releases/download/v0.8.6/cni- plugins-linux-amd64-v0.8.6.tgz)

1. 创建工作目录

 mkdir -p cni/bin
 tar -zxvf cni-plugins-linux-amd64-v0.8.6.tgz -C /opt/soft/cni/bin/

1. 部署cni网络

wget https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

wget https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

sed -i -r "s#quay.io/coreos/flannel:.*-amd64#lizhenliang/flannel:v0.12.0-amd64#g" kube-flannel.yml

授权 apiserver 访问 kubelet

新增加 Worker Node

转载至https://blog.csdn.net/weixin_44350137/article/details/126750897