Kubernetes高可用集群部署（kubeadm和二进制文件部署）

已于 2022-04-21 10:47:57 修改
阅读量2.7k 收藏 3
点赞数 2
分类专栏： Kubernetes 文章标签： kubernetes centos docker etcd
于 2022-02-15 18:08:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gulang0309/article/details/122949392
版权

本文主要介绍通过Kubeadm部署及二进制文件部署两种方式，以二进制部署方式为主

一、部署k8s多节点集群（Kubeadm方式）

角色IP
k8s-master172.16.133.10
k8s-node01172.16.133.20
k8s-node02172.16.133.30

Kubernetes版本：1.18.0

Centos版本：CentOS Linux release 7.6.1810 (Core)

Docker版本：18.06.1-ce

1、系统初始化

1.1、关闭防火墙
#临时关闭
systemctl stop firewalld

#永久关闭服务
systemctl disable firewalld
1.2、关闭selinux
#临时关闭
setenforce 0

#永久关闭
sed -i 's/enforcing/disabled/' /etc/selinux/config
1.3、关闭swap
#临时
swapoff -a

#永久
#
# /etc/fstab
# Created by anaconda on Sat Jan 22 03:24:43 2022
#
# Accessible filesystems, by reference, are maintained under '/dev/disk'
# See man pages fstab(5), findfs(8), mount(8) and/or blkid(8) for more info
#
/dev/mapper/centos-root /                       xfs     defaults        0 0
UUID=ebb8d177-8006-4a74-848c-6e464831a0d7 /boot                   xfs     defaults        0 0
/dev/mapper/centos-home /home                   xfs     defaults        0 0
# /dev/mapper/centos-swap swap                    swap    defaults        0 0  #注释掉swap分区交换的这一行
1.4、设置主机名
hostnamectl set-hostname <hostname>
1.5、在master添加hosts
cat >> /etc/hosts << EOF
172.16.133.100 k8s-master-binary
172.16.133.110 k8s-node01-binary
172.16.133.120 k8s-node02-binary
EOF
1.6、将桥接的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
1.7、时间同步
yum install ntpdate -y

ntpdate time.windows.com
1.8、centos系统内核升级
rpm -Uvh http://www.elrepo.org/elrepo-release-7.0-3.el7.elrepo.noarch.rpm
yum --disablerepo="*" --enablerepo="elrepo-kernel" list available

yum --enablerepo=elrepo-kernel install -y kernel-lt
yum --enablerepo=elrepo-kernel install -y kernel-ml

grub2-set-default 'CentOS Linux (5.16.8-1.el7.elrepo.x86_64) 7 (Core)'
reboot

2、所有节点安装Docker/kubeadm/kubelet/kubectl

Kubernetes默认CRI（运行时容器）为Docker，因此需要安装Docker

2.1、安装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

#启动docker并设置为开机自启
systemctl enable docker && systemctl start docker

#查看版本
docker --version
2.2、添加阿里云yum软件源
#设置仓库地址
cat > /etc/docker/daemon.json << EOF
{
	"registry-mirrors": ["https://b9pmyelo.mirror.aliyuncs.com"]
}
EOF

#添加yum源
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
2.3、安装kubeadm、kubelet、kubectl
#安装
yum install kubeadm-1.18.0 kubelet-1.18.0 kubectl-1.18.0 -y

#设置为开机自启
systemctl enable kubelet

3、部署Kubernetes Master

在172.16.133.10（master）上执行

#节点初始化
kubeadm init --apiserver-advertise-address=172.16.133.10 --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

由于默认拉取镜像地址 k8s.gcr.io 国内无法访问，这里指定阿里云镜像仓库地址。

此命令执行后，执行结果中会提示出下面两步的执行命令，注意！！！

使用kubectl工具

#该命令在执行完节点初始化后，会出现在提示信息中，直接执行即可
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

4、非master节点加入集群

在node01、node02分别执行

kubeadm join 172.16.133.10:6443 --token y3dxmz.u1vi0f482z1y2vt9     --discovery-token-ca-cert-hash sha256:05e6c53ce715db6c361598df5ea74e00e4d7f74c0c8fde26b89578868a45e0e0

默认token有效期为24小时，当过期之后，该token就不可用了。这时就需要创建新的token

kubeadm token create --print-join-command

在两个节点执行加入集群命令，此时节点为NotReady，需要安装一个pod网络插件

5、安装Pod网络插件

kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

#查看system pods
kubectl get pods -n kube-system

安装成功后，查看nodes状态，从NotReady变为Ready

6、测试Kubernetes集群

在Kubernets集群创建一个pod，验证是否正常运行

#创建
kubectl create deployment nginx --image=nginx
#端口映射
kubectl expose deployment nginx --port=80 --type=NodePort
#查看
kubectl get pod, svc

访问地址：http://NodeIP:Port

二、部署高可用多节点集群（二进制方式）

Kubernetes版本：1.20.15

Centos版本：CentOS Linux release 7.9.2009 (Core)

Docker版本：19.03.9

Etcd版本：v3.4.9

1、 环境准备

1.1 主机规划
IP地址机器名组件
172.16.133.10master01kube-apiserver，kube-controller-manager，kube-scheduler，kubelet，kube-proxy，docker，etcd，nginx，keepalived
172.16.133.11master02kube-apiserver，kube-controller-manager，kube-scheduler，kubelet，kube-proxy，docker，etcd，nginx，keepalived
172.16.133.12master03kube-apiserver，kube-controller-manager，kube-scheduler，kubelet，kube-proxy，docker，etcd，nginx，keepalived
172.16.133.13node01kubelet，kube-proxy，docker
172.16.133.14node02kubelet，kube-proxy，docker
172.16.133.99vip只是一个虚拟IP地址，并不是真实存在的机器
1.2 操作系统初始化配置

以下操作需要在所有节点执行

# 1、关闭防火墙 
systemctl stop firewalld
systemctl disable firewalld
 
# 2、关闭selinux 
# 临时 
setenforce 0
# 永久 
sed -i 's/enforcing/disabled/' /etc/selinux/config
 
# 3、关闭swap 
# 临时 
swapoff -a
# 永久 
sed -ri 's/.*swap.*/#&/' /etc/fstab
 
# 4、根据规划设置主机名 
hostnamectl set-hostname <hostname> 
 
# 5、在master添加hosts 
cat >> /etc/hosts << EOF 
172.16.133.10 master01
172.16.133.11 master02
172.16.133.12 master03
172.16.133.13 node01
172.16.133.14 node02
EOF
 
# 6、将桥接的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  # 生效 
 
# 7、时间同步 
yum install ntpdate -y 
ntpdate time.windows.com

# 8、配置免密，这一步是为了在后续传递文件的操作中，忽略密码
# 在所有节点上操作，ssh端口进行新增，为4956
vi /etc/ssh/sshd_config # 在‘#Port 22’下面一行新增‘Port 4956’
# 新增一个Port 4956后重启sshd服务
systemctl restart sshd
# 设置免密
cd /root
ssh-keygen -t rsa
for i in master02 master03 node01 node02;do ssh-copy-id -i /root/.ssh/id_rsa.pub -p 4956 $i;done
# 测试
ssh -p 4956 master02

2、 部署etcd集群

Etcd 是一个分布式键值存储系统，Kubernetes使用Etcd进行数据存储，所以先准备一个Etcd数据库，为解决Etcd单点故障，应采用集群方式部署，这里使用3台机器组建集群，可容忍1台机器故障，当然，你也可以使用5台组建集群，可容忍2台机器故障。

节点名称IP
etcd-1172.16.133.10
etcd-2172.16.133.11
etcd-3172.16.133.12

注：为了节省机器，这里与K8s节点机器复用。也可以独立于k8s集群之外部署，只要apiserver能连接到就行

2.1 准备cfssl证书生成工具

cfssl是一个开源的证书管理工具，使用json文件生成证书，相比openssl更方便使用。找任意一台服务器操作，这里用Master节点

# 1、创建工作目录
mkdir cfssl && cd cfssl/

# 2、下载软件包
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

# 3、增加可执行权限
chmod +x cfssl_linux-amd64 cfssljson_linux-amd64 cfssl-certinfo_linux-amd64

# 4、放置到可执行文件目录
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
2.2 生成Etcd证书
2.2.1 自签证书颁发机构（CA）
# 1、创建工作目录
mkdir -p ~/TLS/{etcd,k8s} && cd ~/TLS/etcd

# 2、自签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

# 3、生成证书：会生成ca.pem和ca-key.pem文件
cfssl gencert -initca ca-csr.json | cfssljson -bare ca -
2.2.2 使用自签CA签发Etcd Https证书
# 1、创建证书请求文件
cat > server-csr.json << EOF
{
    "CN": "etcd",
    "hosts": [
    "172.16.133.10",
    "172.16.133.11",
    "172.16.133.12",
    "172.16.133.13",
    "172.16.133.14",
    "172.16.133.15",
    "172.16.133.16",
    "172.16.133.17",
    "172.16.133.18",
    "172.16.133.19"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "BeiJing",
            "ST": "BeiJing"
        }
    ]
}
EOF

# 注：上述文件hosts字段中IP为所有etcd节点的集群内部通信IP，一个都不能少！为了方便后期扩容可以多写几个预留的IP。

# 2、生成证书，会生成server.pem和server-key.pem文件
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=www server-csr.json | cfssljson -bare server
2.3 部署Etcd集群
2.3.1 下载Etcd二进制文件

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

2.3.2 创建工作目录并解压二进制包
mkdir /opt/etcd/{bin,cfg,ssl} -p

tar zxvf etcd-v3.4.9-linux-amd64.tar.gz

mv etcd-v3.4.9-linux-amd64/{etcd,etcdctl} /opt/etcd/bin/
2.3.3 创建Etcd配置文件
cat > /opt/etcd/cfg/etcd.conf << EOF
#[Member]
ETCD_NAME="etcd-1"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://172.16.133.10:2380"
ETCD_LISTEN_CLIENT_URLS="https://172.16.133.10:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://172.16.133.10:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://172.16.133.10:2379"
ETCD_INITIAL_CLUSTER="etcd-1=https://172.16.133.10:2380,etcd-2=https://172.16.133.11:2380,etcd-3=https://172.16.133.12: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_PEERURLS：集群通告地址
  • ETCD_ADVERTISE_CLIENT_URLS：客户端通告地址
  • ETCD_INITIAL_CLUSTER：集群节点地址
  • ETCD_INITIALCLUSTER_TOKEN：集群Token
  • ETCD_INITIALCLUSTER_STATE：加入集群的当前状态，new是新集群，existing表示加入已有集群
2.3.4 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/etcd/cfg/etcd.conf
ExecStart=/opt/etcd/bin/etcd \
--cert-file=/opt/etcd/ssl/server.pem \
--key-file=/opt/etcd/ssl/server-key.pem \
--peer-cert-file=/opt/etcd/ssl/server.pem \
--peer-key-file=/opt/etcd/ssl/server-key.pem \
--trusted-ca-file=/opt/etcd/ssl/ca.pem \
--peer-trusted-ca-file=/opt/etcd/ssl/ca.pem \
--logger=zap
Restart=on-failure
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
EOF
2.3.5 拷贝生成的证书到指定位置
# 把刚才生成的证书拷贝到配置文件中的路径
cp ~/TLS/etcd/ca*pem ~/TLS/etcd/server*pem /opt/etcd/ssl/
2.3.6 启动并设置开机启动
systemctl daemon-reload
systemctl start etcd
systemctl enable etcd

注意：此时启动一台etcd会显示hang住，这是因为其他两个节点并没有启动，可以查看日志/var/log/messages

2.3.7 将上面节点所有生成的文件拷贝到其余节点
# 1、拷贝二进制文件
for i in master02 master03;do scp -r /opt/etcd $i:/opt/;done

# 2、拷贝systemd控制文件
for i in master02 master03;do scp /usr/lib/systemd/system/etcd.service $i:/usr/lib/systemd/system/;done
2.3.8 在master02和master03分别修改etcd.conf配置文件中的节点名称和当前服务器IP
vim /opt/etcd/cfg/etcd.conf

#[Member]
ETCD_NAME="etcd-1"   # 修改此处，节点2改为etcd-2，节点3改为etcd-3
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://10.0.0.71:2380"   # 修改此处为当前服务器IP
ETCD_LISTEN_CLIENT_URLS="https://10.0.0.71:2379" # 修改此处为当前服务器IP

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://10.0.0.71:2380" # 修改此处为当前服务器IP
ETCD_ADVERTISE_CLIENT_URLS="https://10.0.0.71:2379" # 修改此处为当前服务器IP
ETCD_INITIAL_CLUSTER="etcd-1=https://10.0.0.71:2380,etcd-2=https://10.0.0.72:2380,etcd-3=https://10.0.0.73:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
2.3.9 启动Etcd并设置开机启动
systemctl daemon-reload
systemctl start etcd
systemctl enable etcd
systemctl status etcd
2.3.10 查看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://172.16.133.10:2379,https://172.16.133.11:2379,https://172.16.133.12:2379" endpoint health --write-out=table

# 显示结果如下，说明部署成功
+----------------------------+--------+-------------+-------+
|          ENDPOINT          | HEALTH |    TOOK     | ERROR |
+----------------------------+--------+-------------+-------+
| https://172.16.133.10:2379 |   true | 17.332563ms |       |
| https://172.16.133.12:2379 |   true | 18.981439ms |       |
| https://172.16.133.11:2379 |   true | 19.139963ms |       |
+----------------------------+--------+-------------+-------+

如果有问题第一步先看日志：/var/log/message 或 journalctl -u etcd

3、 安装docker

这里使用Docker作为容器引擎，也可以换成别的，例如containerd

下载地址：https://download.docker.com/linux/static/stable/x86_64/docker-19.03.9.tgz

以下在所有节点操作。这里采用二进制安装，用yum安装也一样。

3.1 解压二进制软件包
# 解压缩
tar zxvf docker-19.03.9.tgz

# 拷贝可执行文件
cp docker/* /usr/bin

for i in master02 master03 node01 node02;do scp -r docker/* $i:/usr/bin/;done

# 查看docker版本
docker version
3.2 创建配置文件
mkdir /etc/docker

# docker镜像地址更换为阿里云镜像地址
cat > /etc/docker/daemon.json << EOF
{
  "registry-mirrors": ["https://b9pmyelo.mirror.aliyuncs.com"]
}
EOF

for i in master02 master03 node01 node02;do scp /etc/docker/daemon.json $i:/etc/docker/;done
3.3 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

for i in master02 master03 node01 node02;do scp /usr/lib/systemd/system/docker.service $i:/usr/lib/systemd/system/;done
3.4 启动并设置开机启动
systemctl daemon-reload
systemctl start docker
systemctl enable docker
systemctl status docker
# 查看配置是否生效
docker info

4、部署Master Node

4.1 部署kube-apiserver
4.1.1 自签证书签发机构（CA）
cd ~/TLS/k8s

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

cat > ca-csr.json << EOF
{
    "CN": "kubernetes",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Beijing",
            "ST": "Beijing",
            "O": "k8s",
            "OU": "System"
        }
    ]
}
EOF

# 生成证书：生成ca.pem和ca-key.pem文件
cfssl gencert -initca ca-csr.json | cfssljson -bare ca -
4.1.2 使用自签CA签发kube-apiserver HTTPS证书
# 创建证书请求文件
cat > server-csr.json << EOF
{
    "CN": "kubernetes",
    "hosts": [
      "172.16.133.1",
      "127.0.0.1",
      "172.16.133.10",
      "172.16.133.11",
      "172.16.133.12",
      "172.16.133.13",
      "172.16.133.14",
      "172.16.133.15",
      "172.16.133.16",
      "172.16.133.17",
      "172.16.133.18",
      "172.16.133.19",
      "172.16.133.99",
      "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

# 注意：上述文件hosts字段中IP为所有Master/LB/VIP IP，一个都不能少！为了方便后期扩容可以多写几个预留的IP

# 生成证书，生成server.pem和server-key.pem
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes server-csr.json | cfssljson -bare server
4.1.3 部署kube-apiserver步骤

下载地址：https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG/CHANGELOG-1.20.md

注：下载一个server包就够了，其中包含了Master和Worker Node所需要的kubectl、kube-apiserver等二进制文件

4.1.3.1 下载并解压缩二进制软件包
mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs} 
tar zxvf kubernetes-server-linux-amd64.tar.gz
cd kubernetes/server/bin
cp kube-apiserver kube-scheduler kube-controller-manager /opt/kubernetes/bin
cp kubectl /usr/bin/
4.1.3.2 创建配置文件
cat > /opt/kubernetes/cfg/kube-apiserver.conf << EOF
KUBE_APISERVER_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--etcd-servers=https://172.16.133.10:2379,https://172.16.133.11:2379,https://172.16.133.12:2379 \\
--bind-address=172.16.133.10 \\
--secure-port=6443 \\
--advertise-address=172.16.133.10 \\
--allow-privileged=true \\
--service-cluster-ip-range=172.16.133.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-32767 \\
--kubelet-client-certificate=/opt/kubernetes/ssl/server.pem \\
--kubelet-client-key=/opt/kubernetes/ssl/server-key.pem \\
--tls-cert-file=/opt/kubernetes/ssl/server.pem  \\
--tls-private-key-file=/opt/kubernetes/ssl/server-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/server-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/server.pem \\
--proxy-client-key-file=/opt/kubernetes/ssl/server-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

# 注：上面两个\ 第一个是转义符，第二个是换行符，使用转义符是为了使用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证书

1.20版本必须加的参数：–service-account-issuer，–service-account-signing-key-file

–etcd-xxxfile：连接Etcd集群证书

–audit-log-xxx：审计日志

4.1.3.3 拷贝生成的证书
# 把刚才生成的证书拷贝到配置文件中的路径
cp ~/TLS/k8s/ca*pem ~/TLS/k8s/server*pem /opt/kubernetes/ssl/
4.1.3.4 创建token文件
# 格式：token，用户名，UID，用户组
cat > /opt/kubernetes/cfg/token.csv << EOF
c47ffb939f5ca36231d9e3121a252940,kubelet-bootstrap,10001,"system:node-bootstrapper"
EOF

token也可自行生成替换：

head -c 16 /dev/urandom | od -An -t x | tr -d ' '
4.1.3.5 systemd管理kube-apiserver
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.conf
ExecStart=/opt/kubernetes/bin/kube-apiserver \$KUBE_APISERVER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF
4.1.3.6 启动并设置开机启动
systemctl daemon-reload
systemctl start kube-apiserver 
systemctl enable kube-apiserver
systemctl status kube-apiserver
4.2 部署kube-controller-manager
4.2.1 创建配置文件
cat > /opt/kubernetes/cfg/kube-controller-manager.conf << 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=172.244.0.0/16 \\
--service-cluster-ip-range=172.16.133.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

配置说明：

–kubeconfig：连接apiserver配置文件

–leader-elect：当该组件启动多个时，自动选举（HA）

–cluster-signing-cert-file/–cluster-signing-key-file：自动为kubelet颁发证书的CA，与apiserver保持一致

4.2.2 生成kubeconfig文件

生成kube-controller-manager证书：

# 切换工作目录
cd ~/TLS/k8s

# 创建证书请求文件
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://172.16.133.10: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}
4.2.3 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/kubernetes/cfg/kube-controller-manager.conf
ExecStart=/opt/kubernetes/bin/kube-controller-manager \$KUBE_CONTROLLER_MANAGER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF
4.2.4 启动并设置开机启动
systemctl daemon-reload
systemctl start kube-controller-manager
systemctl enable kube-controller-manager
systemctl status kube-controller-manager
4.3 部署kube-scheduler
4.3.1 创建配置文件
cat > /opt/kubernetes/cfg/kube-scheduler.conf << EOF
KUBE_SCHEDULER_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--leader-elect \\
--kubeconfig=/opt/kubernetes/cfg/kube-scheduler.kubeconfig \\
--bind-address=127.0.0.1"
EOF
4.3.2 生成kubeconfig文件

生成kube-scheduler证书：

# 切换工作目录
cd ~/TLS/k8s

# 创建证书请求文件
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://172.16.133.10: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}
4.3.3 systemd管理scheduler
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.conf
ExecStart=/opt/kubernetes/bin/kube-scheduler \$KUBE_SCHEDULER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF
4.3.4 启动并设置开机启动
systemctl daemon-reload
systemctl start kube-scheduler
systemctl enable kube-scheduler
systemctl status kube-scheduler
4.3.5 查看集群状态

生成kubectl连接集群的证书：

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

生成kubeconfig文件：

mkdir /root/.kube

KUBE_CONFIG="/root/.kube/config"
KUBE_APISERVER="https://172.16.133.10: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 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}

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

kubectl get cs

# 如下输出说明Master节点组件运行正常
Warning: v1 ComponentStatus is deprecated in v1.19+
NAME                 STATUS    MESSAGE             ERROR
controller-manager   Healthy   ok                  
scheduler            Healthy   ok                  
etcd-0               Healthy   {"health":"true"}   
etcd-1               Healthy   {"health":"true"}   
etcd-2               Healthy   {"health":"true"}
4.3.6 授权kubelet-bootstrap用户允许请求证书
kubectl create clusterrolebinding kubelet-bootstrap \
--clusterrole=system:node-bootstrapper \
--user=kubelet-bootstrap

# 如下输出说明kubelet-bootstrap用户授权成功
clusterrolebinding.rbac.authorization.k8s.io/kubelet-bootstrap created

5、部署Worker Node

下面还是在Master Node上操作，即同时作为Worker Node

5.1 创建工作目录并拷贝二进制文件
# 在所有worker node创建工作目录（master已创建，新加入节点需要创建）
mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs}

# 从解压的k8s server压缩包中拷贝文件
cd /root/kubernetes/server/bin
cp kubelet kube-proxy /opt/kubernetes/bin
5.2 部署kubelet
5.2.1 创建配置文件
cat > /opt/kubernetes/cfg/kubelet.conf << EOF
KUBELET_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--hostname-override=master01 \\
--network-plugin=cni \\
--kubeconfig=/opt/kubernetes/cfg/kubelet.kubeconfig \\
--bootstrap-kubeconfig=/opt/kubernetes/cfg/bootstrap.kubeconfig \\
--config=/opt/kubernetes/cfg/kubelet-config.yml \\
--cert-dir=/opt/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网络容器的镜像

5.2.2 配置参数文件
cat > /opt/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:
- 172.16.133.2
clusterDomain: cluster.local 
failSwapOn: false
authentication:
  anonymous:
    enabled: false
  webhook:
    cacheTTL: 2m0s
    enabled: true
  x509:
    clientCAFile: /opt/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
5.2.3 生成kubelet初次加入集群引导kubeconfig文件
KUBE_CONFIG="/opt/kubernetes/cfg/bootstrap.kubeconfig"
KUBE_APISERVER="https://172.16.133.10:6443"
TOKEN="c47ffb939f5ca36231d9e3121a252940" # 此处token需要与token.csv中保持一致

# 生成 kubelet bootstrap kubeconfig 配置文件
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 "kubelet-bootstrap" \
  --token=${TOKEN} \
  --kubeconfig=${KUBE_CONFIG}
kubectl config set-context default \
  --cluster=kubernetes \
  --user="kubelet-bootstrap" \
  --kubeconfig=${KUBE_CONFIG}
kubectl config use-context default --kubeconfig=${KUBE_CONFIG}
5.2.4 systemd管理kubelet
cat > /usr/lib/systemd/system/kubelet.service << EOF
[Unit]
Description=Kubernetes Kubelet
After=docker.service

[Service]
EnvironmentFile=/opt/kubernetes/cfg/kubelet.conf
ExecStart=/opt/kubernetes/bin/kubelet \$KUBELET_OPTS
Restart=on-failure
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
EOF
5.2.5 启动并设置开机启动
systemctl daemon-reload
systemctl start kubelet
systemctl enable kubelet
systemctl status kubelet
5.2.6 批准kubelet证书申请并加入集群
# 查看kubelet证书请求
kubectl get csr
NAME                                                   AGE   SIGNERNAME                                    REQUESTOR           CONDITION
node-csr-IFr8rOG8Vp6cvdOYmrsV63LNXU-HAaBevAeRqqqTBhc   21s   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Pending

# 批准申请
kubectl certificate approve node-csr-IFr8rOG8Vp6cvdOYmrsV63LNXU-HAaBevAeRqqqTBhc
# 如下，则节点加入集群申请通过
certificatesigningrequest.certificates.k8s.io/node-csr-IFr8rOG8Vp6cvdOYmrsV63LNXU-HAaBevAeRqqqTBhc approved

# 查看节点（由于网络插件还没有部署，节点会没有准备就绪 NotReady）
kubectl get node
NAME       STATUS     ROLES    AGE   VERSION
master01   NotReady   <none>   51s   v1.20.15
5.3 部署kube-proxy
5.3.1 创建配置文件
cat > /opt/kubernetes/cfg/kube-proxy.conf << EOF
KUBE_PROXY_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--config=/opt/kubernetes/cfg/kube-proxy-config.yml"
EOF
5.3.2 配置参数文件
cat > /opt/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/kubernetes/cfg/kube-proxy.kubeconfig
hostnameOverride: master01
clusterCIDR: 172.244.0.0/24
EOF
5.3.3 生成kube-proxy.kubeconfig文件

生成kube-proxy证书：

# 切换工作目录
cd ~/TLS/k8s

# 创建证书请求文件
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_CONFIG="/opt/kubernetes/cfg/kube-proxy.kubeconfig"
KUBE_APISERVER="https://172.16.133.10: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-proxy \
  --client-certificate=./kube-proxy.pem \
  --client-key=./kube-proxy-key.pem \
  --embed-certs=true \
  --kubeconfig=${KUBE_CONFIG}
kubectl config set-context default \
  --cluster=kubernetes \
  --user=kube-proxy \
  --kubeconfig=${KUBE_CONFIG}
kubectl config use-context default --kubeconfig=${KUBE_CONFIG}
5.3.4 systemd管理kube-proxy
cat > /usr/lib/systemd/system/kube-proxy.service << EOF
[Unit]
Description=Kubernetes Proxy
After=network.target

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

[Install]
WantedBy=multi-user.target
EOF
5.3.5 启动并设置开机启动
systemctl daemon-reload
systemctl start kube-proxy
systemctl enable kube-proxy
systemctl status kube-proxy
5.4 部署网络组件Calico

Calico是一个纯三层的数据中心网络方案，是目前Kubernetes主流的网络方案。

# 下载
curl https://projectcalico.docs.tigera.io/manifests/calico.yaml -O

# 修改
vi calico.yaml

...
 # Enable IPIP
            - name: CALICO_IPV4POOL_IPIP
              value: "Always"  # 此处修改为off，即使用calico的BGP网络模式
...

...
# The default IPv4 pool to create on startup if none exists. Pod IPs will be
            # chosen from this range. Changing this value after installation will have
            # no effect. This should fall within `--cluster-cidr`.
            # - name: CALICO_IPV4POOL_CIDR # 取消注释
            #   value: "192.168.0.0/16" # 取消注释，并和kube-controller-manager.conf中cluster-cdir配置保持一致
...

# 部署Calico
kubectl apply -f calico.yaml
kubectl get pods -n kube-system

# 创建后获取pod结果如下，该过程持续时间较长
NAME                                       READY   STATUS     RESTARTS   AGE
calico-kube-controllers-547686d897-7nsmn   0/1     Pending    0          6s
calico-node-7mkvf                          0/1     Init:0/3   0          6s
# 完全启动成功后如下所示
NAME                                       READY   STATUS    RESTARTS   AGE
calico-kube-controllers-547686d897-7nsmn   1/1     Running   0          5m27s
calico-node-7mkvf                          1/1     Running   0          5m27s

# 等Calico Pod都Running，节点也会准备就绪
kubectl get node
NAME       STATUS   ROLES    AGE   VERSION
master01   Ready    <none>   10m   v1.20.15
5.5 授权apiserver访问kubelet

应用场景：kubectl logs

# 创建apiserver-to-kubelet-rbac.yaml文件
cat > apiserver-to-kubelet-rbac.yaml << EOF
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  annotations:
    rbac.authorization.kubernetes.io/autoupdate: "true"
  labels:
    kubernetes.io/bootstrapping: rbac-defaults
  name: system:kube-apiserver-to-kubelet
rules:
  - apiGroups:
      - ""
    resources:
      - nodes/proxy
      - nodes/stats
      - nodes/log
      - nodes/spec
      - nodes/metrics
      - pods/log
    verbs:
      - "*"
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: system:kube-apiserver
  namespace: ""
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: system:kube-apiserver-to-kubelet
subjects:
  - apiGroup: rbac.authorization.k8s.io
    kind: User
    name: kubernetes
EOF

# 创建并启动
kubectl apply -f apiserver-to-kubelet-rbac.yaml
5.6 新增Worker Node
5.6.1 拷贝已经部署好的node相关文件到新节点
# 在Master节点将Worker Node涉及文件拷贝到新节点node01、node02
for i in node01 node02;do scp -r /opt/kubernetes $i:/opt/;done

for i in node01 node02;do scp /usr/lib/systemd/system/{kubelet,kube-proxy}.service $i:/usr/lib/systemd/system/;done

for i in node01 node02;do scp /opt/kubernetes/ssl/ca.pem $i:/opt/kubernetes/ssl/;done
5.6.2 删除kubelet证书和kubeconfig文件
# 删除新节点node01、node02上从master01拷贝过来的配置
rm -f /opt/kubernetes/cfg/kubelet.kubeconfig
rm -f /opt/kubernetes/ssl/kubelet*
5.6.3 修改配置文件中的主机名
vim /opt/kubernetes/cfg/kubelet.conf
--hostname-override=master01 # 此处分别修改为node01 node02

vim /opt/kubernetes/cfg/kube-proxy-config.yml
hostnameOverride: master01 # 此处分别修改为node01 node02
5.6.4 启动并设置开机启动
systemctl daemon-reload
systemctl start kubelet kube-proxy
systemctl enable kubelet kube-proxy
systemctl status kubelet kube-proxy
5.6.5 在master上批准新Node kubelet证书申请
# 查看证书请求
kubectl get csr
NAME                                                   AGE     SIGNERNAME                                    REQUESTOR           CONDITION
node-csr-IFr8rOG8Vp6cvdOYmrsV63LNXU-HAaBevAeRqqqTBhc   23m     kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Approved,Issued
node-csr-fS15INzaZXIi8Y3EKYdhAT06M5_OqenS4mdfRF1CLGE   5m14s   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Approved,Issued
node-csr-pLRmvlyE1tv1ataBoT7fVOXzLOJlryc62NohbR1hsqI   3m8s    kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Pending

# 同意授权请求
kubectl certificate approve node-csr-fS15INzaZXIi8Y3EKYdhAT06M5_OqenS4mdfRF1CLGE
5.6.6 查看node状态
kubectl get nodes
NAME       STATUS   ROLES    AGE     VERSION
master01   Ready    <none>   21m     v1.20.15
node01     Ready    <none>   3m14s   v1.20.15

Node02节点同上。记得修改主机名！

# 最终，节点都添加成功并ready
NAME       STATUS   ROLES    AGE     VERSION
master01   Ready    <none>   27m     v1.20.15
node01     Ready    <none>   8m25s   v1.20.15
node02     Ready    <none>   3m50s   v1.20.15

6、部署Dashboard和CoreDNS（可选）

6.1 部署Dashboard（可选）
kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/v2.5.0/aio/deploy/recommended.yaml

# 查看部署
kubectl get pods -n kubernetes-dashboard
kubectl get svc -n kubernetes-dashboard

创建service account并绑定默认cluster-admin管理员集群角色：

kubectl create serviceaccount dashboard-admin -n kube-system

kubectl create clusterrolebinding dashboard-admin --clusterrole=cluster-admin --serviceaccount=kube-system:dashboard-admin

kubectl describe secrets -n kube-system $(kubectl -n kube-system get secret | awk '/dashboard-admin/{print $1}')
6.2 部署CoreDNS（可选）

CoreDNS用于集群内部Service名称解析：

kubectl apply -f coredns.yaml
 
kubectl get pods -n kube-system
NAME                          READY   STATUS    RESTARTS   AGE 
coredns-5ffbfd976d-j6shb      1/1     Running   0          32s

DNS解析测试：

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

至此一个单Master集群就搭建完成了！

7、扩容多Master（高可用）

Master节点主要有三个服务kube-apiserver、kube-controller-manager和kube-scheduler，其中kube-controller-manager和kube-scheduler组件自身通过选择机制已经实现了高可用，所以Master高可用主要针对kube-apiserver组件，而该组件是以HTTP API提供服务，因此对他高可用与Web服务器类似，增加负载均衡器对其负载均衡即可，并且可水平扩容。

7.1 部署Master02 节点

现在需要再增加一台新服务器，作为master02节点，IP为172.16.133.11

Master02与已经部署的Master01所有操作一致。所以我们只需将Master01所有k8s文件拷贝过来，再修改下服务器IP和主机名启动即可

7.1.1 安装docker
scp /usr/bin/docker* root@master02:/usr/bin/

scp /usr/bin/runc root@master02:/usr/bin/

scp /usr/bin/containerd* root@master02:/usr/bin/

scp /usr/lib/systemd/system/docker.service root@master02:/usr/lib/systemd/system/

scp -r /etc/docker root@master02:/etc

# 在Master2启动Docker
systemctl daemon-reload
systemctl start docker
systemctl enable docker
systemctl status docker
7.1.2 创建Etcd证书目录
# 在Master02创建etcd证书目录
mkdir -p /opt/etcd/ssl
7.1.3 拷贝master01上文件到master02
# 拷贝Master01上所有K8s文件和etcd证书到Master02、Master03
for i in master02 master03;do scp -r /opt/kubernetes $i:/opt/;done

for i in master02 master03;do scp -r /opt/etcd/ssl $i:/opt/etcd/;done

for i in master02 master03;do scp /usr/lib/systemd/system/kube* $i:/usr/lib/systemd/system/;done

for i in master02 master03;do scp /usr/bin/kubectl $i:/usr/bin/;done

for i in master02 master03;do scp -r ~/.kube $i:~;done
7.1.4 删除证书文件
# Master02、Master03删除kubelet证书和kubeconfig文件
rm -f /opt/kubernetes/cfg/kubelet.kubeconfig 
rm -f /opt/kubernetes/ssl/kubelet*
7.1.5 修改配置文件IP和主机名
# 修改apiserver、kubelet和kube-proxy配置文件为本地IP
vim /opt/kubernetes/cfg/kube-apiserver.conf 
...
--bind-address=172.16.133.10 \ # 修改为Master02、Master03的本地IP
--advertise-address=172.16.133.10 \ # 修改为Master02、Master03的本地IP
...

vim /opt/kubernetes/cfg/kubelet.conf
--hostname-override=master01 # 修改为master02、master03

vim /opt/kubernetes/cfg/kube-proxy-config.yml
hostnameOverride: master02
7.1.6 启动并设置开机启动
systemctl daemon-reload
systemctl start kube-apiserver kube-controller-manager kube-scheduler kubelet kube-proxy
systemctl enable kube-apiserver kube-controller-manager kube-scheduler kubelet kube-proxy
systemctl status kube-apiserver kube-controller-manager kube-scheduler kubelet kube-proxy
7.1.7 查看集群状态
# 修改连接master为本机IP
vim ~/.kube/config
...
server: https://172.16.133.11:6443

kubectl get cs
Warning: v1 ComponentStatus is deprecated in v1.19+
NAME                 STATUS    MESSAGE             ERROR
scheduler            Healthy   ok                  
controller-manager   Healthy   ok                  
etcd-2               Healthy   {"health":"true"}   
etcd-1               Healthy   {"health":"true"}   
etcd-0               Healthy   {"health":"true"}
7.1.8 批准kubelet证书申请
# 查看证书请求
kubectl get csr
NAME                                                   AGE     SIGNERNAME                                    REQUESTOR           CONDITION
node-csr-4im6y7Z8o4q3eD-O3woRtyFH2mI2BHRMef46aLngRTs   8m57s   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Pending
node-csr-IFr8rOG8Vp6cvdOYmrsV63LNXU-HAaBevAeRqqqTBhc   51m     kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Approved,Issued
node-csr-fS15INzaZXIi8Y3EKYdhAT06M5_OqenS4mdfRF1CLGE   33m     kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Approved,Issued
node-csr-pLRmvlyE1tv1ataBoT7fVOXzLOJlryc62NohbR1hsqI   31m     kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Approved,Issued
# 授权请求
kubectl certificate approve node-csr-4im6y7Z8o4q3eD-O3woRtyFH2mI2BHRMef46aLngRTs

# 查看Node
kubectl get node
NAME       STATUS   ROLES    AGE     VERSION
master01   Ready    <none>   53m     v1.20.15
master02   Ready    <none>   2m49s   v1.20.15
node01     Ready    <none>   35m     v1.20.15
node02     Ready    <none>   30m     v1.20.15

Master03操作同上

# 扩容master03后，如下
NAME       STATUS   ROLES    AGE     VERSION
master01   Ready    <none>   68m     v1.20.15
master02   Ready    <none>   17m     v1.20.15
master03   Ready    <none>   5m50s   v1.20.15
node01     Ready    <none>   49m     v1.20.15
node02     Ready    <none>   45m     v1.20.15
7.2 部署Nginx+Keepalived高可用负载均衡器
7.2.1 安装软件包（主/备）
# 先安装
yum -y install epel-release

# 在安装nginx
yum -y install nginx
yum -y install nginx-all-modules.noarch

# 再重新初始化nginx配置
nginx -t

# 如下，则nginx配置重新初始化完成
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

# 再安装keepalived
yum -y install keepalived
7.2.2 Nginx配置文件（主备一样）
cat > /etc/nginx/nginx.conf << "EOF"
user nginx;
worker_processes auto;
error_log /var/log/nginx/error.log;
pid /run/nginx.pid;

include /usr/share/nginx/modules/*.conf;

events {
    worker_connections 1024;
}

# 四层负载均衡，为三台Master apiserver组件提供负载均衡
stream {

    log_format  main  '$remote_addr $upstream_addr - [$time_local] $status $upstream_bytes_sent';

    access_log  /var/log/nginx/k8s-access.log  main;

    upstream k8s-apiserver {
       server 172.16.133.10:6443;   # Master1 APISERVER IP:PORT
       server 172.16.133.11:6443;   # Master2 APISERVER IP:PORT
       server 172.16.133.12:6443;   # Master3 APISERVER IP:PORT
    }
    
    server {
       listen 16443; # 由于nginx与master节点复用，这个监听端口不能是6443，否则会冲突
       proxy_pass k8s-apiserver;
    }
}

http {
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile            on;
    tcp_nopush          on;
    tcp_nodelay         on;
    keepalive_timeout   65;
    types_hash_max_size 2048;

    include             /etc/nginx/mime.types;
    default_type        application/octet-stream;

    server {
        listen       80 default_server;
        server_name  _;

        location / {
        }
    }
}
EOF
7.2.3 keepalived配置文件（Nginx Master）
cat > /etc/keepalived/keepalived.conf << EOF
global_defs { 
   notification_email { 
     acassen@firewall.loc 
     failover@firewall.loc 
     sysadmin@firewall.loc 
   } 
   notification_email_from Alexandre.Cassen@firewall.loc  
   smtp_server 127.0.0.1 
   smtp_connect_timeout 30 
   router_id NGINX_MASTER
} 

vrrp_script check_nginx {
    script "/etc/keepalived/check_nginx.sh"
}

vrrp_instance VI_1 { 
    state MASTER 
    interface eth33 # 修改为实际网卡名
    virtual_router_id 51 # VRRP 路由 ID实例，每个实例是唯一的 
    priority 100    # 优先级，备服务器设置 90、80
    advert_int 1    # 指定VRRP 心跳包通告间隔时间，默认1秒 
    authentication { 
        auth_type PASS      
        auth_pass 1111 
    }  
    # 虚拟IP
    virtual_ipaddress { 
        172.16.133.99/24
    } 
    track_script {
        check_nginx
    } 
}
EOF

参数说明：

vrrp_script：指定检查nginx工作状态脚本（根据nginx状态判断是否故障转移）

virtual_ipaddress：虚拟IP（VIP）

准备上述配置文件中检查nginx运行状态的脚本：

cat > /etc/keepalived/check_nginx.sh  << "EOF"
#!/bin/bash
count=$(ss -antp |grep 16443 |egrep -cv "grep|$$")

if [ "$count" -eq 0 ];then
    exit 1
else
    exit 0
fi
EOF

chmod +x /etc/keepalived/check_nginx.sh

注：keepalived根据脚本返回状态码（0为工作正常，非0不正常）判断是否故障转移

7.2.4 keepalived配置文件（Nginx Backup）
cat > /etc/keepalived/keepalived.conf << EOF
global_defs { 
   notification_email { 
     acassen@firewall.loc 
     failover@firewall.loc 
     sysadmin@firewall.loc 
   } 
   notification_email_from Alexandre.Cassen@firewall.loc  
   smtp_server 127.0.0.1 
   smtp_connect_timeout 30 
   router_id NGINX_BACKUP
} 

vrrp_script check_nginx {
    script "/etc/keepalived/check_nginx.sh"
}

vrrp_instance VI_1 { 
    state BACKUP 
    interface eth33
    virtual_router_id 51 # VRRP 路由 ID实例，每个实例是唯一的 
    priority 90 # 优先级，备服务器设置 90、80
    advert_int 1
    authentication { 
        auth_type PASS      
        auth_pass 1111 
    }  
    virtual_ipaddress { 
        172.16.133.99/24
    } 
    track_script {
        check_nginx
    } 
}
EOF

准备上述配置文件中检查nginx运行状态的脚本：

cat > /etc/keepalived/check_nginx.sh  << "EOF"
#!/bin/bash
count=$(ss -antp |grep 16443 |egrep -cv "grep|$$")

if [ "$count" -eq 0 ];then
    exit 1
else
    exit 0
fi
EOF

chmod +x /etc/keepalived/check_nginx.sh
7.2.5 启动并设置开机启动
systemctl daemon-reload
systemctl start nginx keepalived
systemctl enable nginx keepalived
systemctl status nginx keepalived
7.2.6 查看keepalived工作状态
# 查看IP地址
ip addr

在这里插入图片描述
可以看到，在eth33网卡绑定了172.16.133.99 虚拟IP，说明工作正常。

7.2.7 Nginx+Keepalived高可用测试

关闭主节点Nginx，测试VIP是否漂移到备节点服务器。

在Nginx Master执行systemctl stop nginx;

在Nginx Backup，ip addr命令查看已成功绑定VIP。
在这里插入图片描述

7.2.8 访问负载均衡器测试

找K8s集群中任意一个节点，使用curl查看K8s版本测试，使用VIP的IP地址访问，结果如下：

curl -k https://172.16.133.99:16443/version
{
  "major": "1",
  "minor": "20",
  "gitVersion": "v1.20.15",
  "gitCommit": "8f1e5bf0b9729a899b8df86249b56e2c74aebc55",
  "gitTreeState": "clean",
  "buildDate": "2022-01-19T17:23:01Z",
  "goVersion": "go1.15.15",
  "compiler": "gc",
  "platform": "linux/amd64"
}

可以正确获取到K8s版本信息，说明负载均衡器搭建正常。该请求数据流程：

curl -> vip(nginx) -> apiserver

通过查看Nginx日志也可以看到转发apiserver IP：

tail -f /var/log/nginx/k8s-access.log
7.2.9 修改所有Worker Node连接LB VIP

试想下，虽然我们增加了Master02 Node和负载均衡器，但是我们是从单Master架构扩容的，也就是说目前所有的Worker Node组件连接都还是Master01 Node，如果不改为连接VIP走负载均衡器，那么Master还是单点故障。

因此接下来就是要改所有Worker Node（kubectl get node命令查看到的节点）组件配置文件，由原来172.16.133.10修改为172.16.133.99（VIP）。

在所有Worker Node执行：

sed -i 's#172.16.133.10:6443#172.16.133.99:16443#' /opt/kubernetes/cfg/*
systemctl daemon-reload
systemctl restart kubelet kube-proxy

检查节点状态：

kubectl get node 
NAME       STATUS   ROLES    AGE    VERSION
master01   Ready    <none>   137m   v1.20.15
master02   Ready    <none>   86m    v1.20.15
master03   Ready    <none>   75m    v1.20.15
node01     Ready    <none>   118m   v1.20.15
node02     Ready    <none>   114m   v1.20.15

参考原文链接：https://www.cnblogs.com/hujinzhong/p/14648961.html
说明：此文章是参考上面链接文章自己操作后的总结，此文章只做总结、完善及拓展的用途，如有版权问题，可联系本人下架此文。

费益洲
关注
专栏目录
二进制方式搭建Kubernetes高可用集群（超丰富的组件概念理论总结）
江晓龙的博客
09-23 7万+
二进制方式部署Kubernetes高可用集群 文章目录二进制方式部署Kubernetes高可用集群1.环境准备1.1.Kubernetes高可用集群部署方式1.2.Kubernetes集群弃用docker容器1.3.Kubernetes集群所需的证书1.4.环境准备1.5.安装cfssl证书生成工具2.操作系统初始化配置3.部署Etcd集群3.1.使用cfssl证书工具生成etcd证书3.2.部署etcd集群4.部署Docker服务4.1.安装docker4.2.为docker创建systemctl启动脚本
K8S二进制部署详解，一文教会你部署高可用K8S集群
景天科技苑
02-07 4160
虽然kubeadm方式搭建K8S比较简单，但是对里面的原理都不清楚的话，生产中使用功能可能不便于排查故障。二进制方式部署的k8s集群比较稳定。 二进制方式搭建：在官网下载相关组件的二进制包，如果手动安装，对kubernetes理解也会更全面。 Kubeadm和二进制都适合生产环境，在生产环境运行都很稳定，具体如何选择，可以根据实际项目进行评估。
【公开课】Kubernetes 实现应用的高可用
百度云原生计算的博客
04-16 168
【百度云原生导读】Pod 代表了 Kubernetes 中的基本部署单元，但是，在一般情况下我们不会直接使用 Pod，因为每一次重启它的 IP 都会发生变化；如果你希望自己的应用能自动保持健康运行而且无需手动干预，则需要通过创建 ReplicaSet 或者 Deployment 这样的资源来管理实际的 Pod。另外很多时候我们需要判断Pod是否需要重启，请求是否可被调度到Pod，探针的出现使得这些问题迎刃而解。 本节课将带领大家学习探针与 Deployment 的使用。通过实践与学习，了解 Kuberne
关于Kubernetes Master高可用的一些策略
Kubernetes中文社区
10-30 5003
Kubernetes高可用也许是完成了初步的技术评估，打算将生产环境迁移进Kubernetes集群之前普遍面临的问题。 为了减少因为服务器当机引起的业务中断，生产环境中的业务系统往往已经做好了高可用，而当引入Kubernetes这一套新的集群管理系统之后， 服务器不再是单一的个体，位于中央位置的Kubernetes Master一旦中断服务，将导致所有Node节点均不可控，有可能造成严重的事故。
升级 kubeadm 部署的 k8s 集群
最新发布
misakivv的博客
08-17 852
升级 kubeadm 部署的 k8s 集群（补丁版本升级+次要版本升级）
Kubernetes 高可用方案
qingdao666666的博客
03-23 1564
Kubernetes 高可用方案 导读 Kubernetes高可用也许是完成了初步的技术评估，打算将生产环境迁移进Kubernetes集群之前普遍面临的问题。为了减少因为服务器当机引起的业务中断，生产环境中的业务系统往往已经做好了高可用，而当引入Kubernetes这一套新的集群管理系统之后， 服务器不再是单一的个体，位于中央位置的Kubernetes Master一旦中断服务，将导致所有No...
kubernetes高可用集群
weixin_56993834的博客
08-13 702
一 Kubernetes的高可用 Kubernetes的高可用主要指的是控制平面的高可用，简单说，就是有多套Master节点组件和Etcd组件，工作节点通过负载均衡连接到各Master。HA有两种做法，一种是将etcd与Master节点组件混布在一起： 另外一种方式是，使用独立的Etcd集群，不与Master节点混布 两种方式的相同之处在于都提供了控制平面的冗余，实现了集群高可以用，区别在于： Etcd混布方式： 所需机器资源少 部署简单，利于管理 容易进行横向扩展 风险大，一台宿主机挂了，maste
Kubernetes高可用集群搭建(kubeadm)
逛窑子的李靖的博客
11-19 698
Kubernetes高可用集群搭建1 Kubernetes高可用集群介绍2 安装要求3 环境准备3.1 安装虚拟机3.2 系统初始化4 在每个master节点安装keepalived4.1 安装相关依赖包4.2 配置maser节点4.2.1 master1节点配置4.2.2 master2节点配置4.3 启动和检查5 部署haproxy5.1 安装5.2 配置5.3 启动和检查 1 Kubernetes高可用集群介绍 前面已经介绍了Kubernetes的集群部署，但是都只是介绍的单master节点的情况，由
Kubernetes集群V1.26二进制部署
weixin_42642671的博客
04-28 866
离线环境二进制部署k8s:v1.26.15
一套完整的K8s高可用集群二进制部署（-V1.20）
10-17
Kubernetes 高可用集群二进制部署指南 本文档将指导您部署一套完整的 Kubernetes 高可用集群，我们将从基础知识点开始，介绍 Kubernetes 集群的两种部署方式，然后详细介绍如何准备环境、部署 Etcd 集群、安装 ...
部署一套完整的K8s高可用集群（二进制-V1.18）.zip
07-11
从github下载发行版的二进制包，手动部署每个组件，组成Kubernetes集群。 Kubeadm降低部署门槛，但屏蔽了很多细节，遇到问题很难排查。如果想更容易可控，推荐使用二进 制包部署Kubernetes集群，虽然手动部署麻烦点...
手动搭建高可用的kubernetes 集群
04-13
手动搭建高可用的kubernetes 集群，可用于生产环境，另有额外kubernetes资料相送，生产已经实践过！
Kubernetes（k8s）高可用搭建
船长灬普朗克的博客
10-25 662
两台master节点的配置均相同，配置中声明了后端代理的两个master节点服务器，指定了haproxy运行的端口为16443等，因此16443端口为集群的入口。如果是云服务器搭建的话，记得云服务器管理平台上申请虚拟IP地址，然后绑定虚拟IP地址到三台主节点服务器上，然后添加相应的网络策略，否侧ping不通虚拟ip。从官方地址获取到flannel的yaml，在master1上执行。执行在master1上init后输出的join命令,需要带上参数。在具有vip的master上操作，这里为master1。
Kubernetes 高可用集群部署
supahero的博客
06-02 680
Kubernetes 高可用集群部署
一、kubernetes高可用部署
qq_48059971的博客
10-08 511
一、kubernetes高可用部署 安装方式分为kubeadm安装、和二进制安装 第一种： 1.1、基本环境配置 环境介绍： ​ master01~03 192.168.150.150~~152 master节点3 ​ master-vip 192.168.150.200 keepalived虚拟IP ​ node01~02 192.168.150.153~~154 worker节点2 所有节点配置hosts，修改/etc/hosts如下： ## 修改hosts文件 v
笔记 K8S 环境搭建 kubeadm 与二进制方式（初学）
FOREVERHOPE_WBZ的专栏
01-07 1080
Etcd是一个分布式键值存储系统，kubernetes使用etcd进行数据存储，需要首先准备一个ETCD数据库，为解决etcd单点故障，应采用集群方式部署，这里使用3台组件集群，可容忍1台机器故障，当然，也可以使用5台组建集群，可容忍2台机器故障。* 部署master组件：kube-apiserver，kube-controller-mamanger，kube-scheduler，etcd。总体过程：通过service统一入口进行访问，由controller创建pod进行部署，一个pod是一组容器的集合。
kubernetes高可用集群部署
yang的博客
05-16 503
一、准备环境 准备如下表所示服务器 hostname 规格（最小） 镜像 kubernetes版本 master01 2U4G centos 7.6 v1.18.8 master02 2U4G centos 7.6 v1.18.8 master03 2U4G centos 7.6 v1.18.8 node01 2U4G centos 7.6 v1.18.8 ··· ··· ··· ··· 二、高可用架构 采用kubeadm方式搭建高可用k8s集群，k8s集群的高可用实际是
Kubernetes 高可用性入门：初学者指南
Lion_Long的博客
04-06 788
Kubernetes 高可用性对于确保应用程序始终可用至关重要。通过了解 Kubernetes 的核心高可用性组件和最佳实践，初学者可以构建高可用且弹性的 Kubernetes 集群。本文提供了 Kubernetes 高可用性的全面概述，是初学者入门并开始使用 Kubernetes 的宝贵资源。
k8s-kubernetes--高可用集群的搭建
Gong_yz的博客
03-20 2120
k8s集群用到的高可用技术主要是keepalived和haproxy； keepalived：Keepalived主要是通过虚拟路由冗余来实现高可用功能；haproxy： haproxy 类似于nginx， 是一个负载均衡、反向代理软件。 nginx 采用master-workers 进程模型，每个进程单线程，多核CPU能充分利用。
Kubernetes高可用集群部署指南v1.18
"该文档是关于如何部署一套完整的Kubernetes (K8s) 高可用集群的...以上就是部署Kubernetes v1.18高可用集群的关键步骤和注意事项，对于运维人员来说，理解和掌握这些知识是构建和管理高效、稳定Kubernetes集群的基础。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

费益洲

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值