二进制部署K8s高可用集群V1.20版本

部署一套完整的企业级K8s集群(v1.20)

一、前置知识

1.1、生产环境部署K8s集群的两种方式

kubeadm

Kubeadm是一个K8s部署工具，提供kubeadm init和kubeadm join，用于快速部署Kubernetes集群。

二进制包

从github下载发行版的二进制包，手动部署每个组件，组成Kubernetes集群。
小结：Kubeadm降低部署门槛，但屏蔽了很多细节，遇到问题很难排查。如果想更容易可控，推荐使用二进制包部署Kubernetes集群，虽然手动部署麻烦点，期间可以学习很多工作原理，也利于后期维护。

1.2、环境准备

服务器要求

•	建议最小硬件配置：2核CPU、2G内存、30G硬盘
•	服务器最好可以访问外网，会有从网上拉取镜像需求，如果服务器不能上网，需要提前下载对应镜像并导入节点

软件环境

软件	版本
操作系统	CentOS7.x_x64
容器引擎	Docker CE 19
Kubernetes	Kubernetes v1.20

服务器整体规划

角色	IP	组件
k8s-master1	139.186.150.246	kube-apiserver，kube-controller-manager，kube-scheduler，kubelet，kube-proxy，docker，etcd， nginx，keepalived
k8s-master2
k8s-node1	139.186.162.245	kubelet，kube-proxy，docker，etcd
k8s-node2	139.186.150.108	kubelet，kube-proxy，docker，etcd
负载均衡器IP	VIP

须知：考虑到有些朋友电脑配置较低，一次性开四台机器会跑不动，所以搭建这套K8s高可用集群分两部分实施，先部署一套单Master架构（3台），再扩容为多Master架构（4台或6台），顺便再熟悉下Master扩容流程。

单Master架构图

单Master服务器规划

角色	IP	组件
k8s-master1	139.186.150.246 172.30.0.2	kube-apiserver，kube-controller-manager，kube-scheduler，kubelet，kube-proxy，docker，etcd， nginx，keepalived
k8s-node1	139.186.150.108 172.30.0.10	kubelet，kube-proxy，docker，etcd
k8s-node2	139.186.131.75 172.30.0.17	kubelet，kube-proxy，docker，etcd

1.3、操作系统初始化配置

# 关闭防火墙
systemctl stop firewalld
systemctl disable firewalld
# 关闭selinux
sed -i 's/enforcing/disabled/' /etc/selinux/config  # 永久
# 关闭swap
sed -ri 's/.*swap.*/#&/' /etc/fstab
# 根据规划设置主机名 
hostnamectl set-hostname <hostname>
# 在master添加hosts
cat >> /etc/hosts << EOF 
192.168.0.72 k8s-master
192.168.0.30 k8s-node1  
EOF
# 将桥接的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集群

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

节点名称	IP
etcd-1	172.30.0.2
etcd-2	172.30.0.10
etcd-3	172.30.0.17

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

2.1、准备cfssl证书生成工具

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

# 上传压缩包
rz -y cfssl.tar.gz
# 解压文件
tar zxvf cfssl.tar.gz
mv cfssl /usr/local/bin/cfssl
mv cfssljson /usr/local/bin/cfssljson
mv cfssl-certinfo /usr/bin/cfssl-certinfo

2.2、生成Etcd证书

2.2.1 自签证书办法机构(CA)

创建目录

mkdir -p 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.pem和ca-key.pem文件。

2.2.2、使用自签CA签发Etcd HTTPS证书

创建证书申请文件

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

cat > server-csr.json << EOF
{
    "CN": "etcd",
    "hosts": [
    "192.168.0.72",
    "192.168.0.30"
    ],
    "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

# 会生成server.pem和server-key.pem文件。

2.3、从github下载二进制文件

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

2.4、部署etcd集群

以下在节点1上操作，为简化操作，待会将节点1生成的所有文件拷贝到节点2和节点3.

2.4.1、创建工作目录并解压二进制文件

mkdir /home/etcd/{bin,cfg,ssl} -p
# 上传二进制文件
rz -y etcd-v3.4.9-linux-amd64.tar.gz
# 解压
tar zxvf etcd-v3.4.9-linux-amd64.tar.gz
mv etcd-v3.4.9-linux-amd64/{etcd,etcdctl} /home/etcd/bin/

2.4.2、创建etcd配置文件

cat > /home/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.0.2:2380"
ETCD_LISTEN_CLIENT_URLS="https://172.16.0.2:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://172.16.0.2:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://172.16.0.2:2379"
ETCD_INITIAL_CLUSTER="etcd-1=https://172.16.0.2:2380,etcd-2=https://172.16.0.9:2380,etcd-3=https://172.16.0.11: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.4.3、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=/home/etcd/cfg/etcd.conf
ExecStart=/home/etcd/bin/etcd \
--cert-file=/home/etcd/ssl/server.pem \
--key-file=/home/etcd/ssl/server-key.pem \
--peer-cert-file=/home/etcd/ssl/server.pem \
--peer-key-file=/home/etcd/ssl/server-key.pem \
--trusted-ca-file=/home/etcd/ssl/ca.pem \
--peer-trusted-ca-file=/home/etcd/ssl/ca.pem \
--logger=zap
Restart=on-failure
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
EOF

2.4.4、拷贝刚才生成的证书

把刚才生成的证书拷贝到配置文件中的路径

cp /home/TLS/etcd/ca*pem /home/TLS/etcd/server*pem /home/etcd/ssl/

2.4.5、将上面节点所有生成的文件拷贝到节点2和节点3

# 节点2和节点上服务器上执行
mkdir /home/etcd/{bin,cfg,ssl} -p
# master节点上执行拷贝
scp -r /home/etcd/ root@172.16.0.9:/home/
scp /usr/lib/systemd/system/etcd.service root@172.16.0.9:/usr/lib/systemd/system/

scp -r /home/etcd/ root@172.16.0.11:/home/
scp /usr/lib/systemd/system/etcd.service root@172.16.0.11:/usr/lib/systemd/system/

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

vim /home/etcd/cfg/etcd.conf

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

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://172.30.0.4:2380" # 修改此处为当前服务器IP
ETCD_ADVERTISE_CLIENT_URLS="https://172.30.0.4:2379" # 修改此处为当前服务器IP
ETCD_INITIAL_CLUSTER="etcd-1=https://172.30.0.14:2380,etcd-2=https://1172.30.0.4:2380,etcd-3=https://172.30.0.7:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"

)

2.4.6、启动并设置开机启动

# 所有节点执行
systemctl daemon-reload
systemctl start etcd && systemctl enable etcd

2.4.7、查看集群状态

# 任意节点执行
ETCDCTL_API=3 /home/etcd/bin/etcdctl --cacert=/home/etcd/ssl/ca.pem --cert=/home/etcd/ssl/server.pem --key=/home/etcd/ssl/server-key.pem --endpoints="https://172.16.0.2:2379,https://172.16.0.9:2379,https://172.16.0.11:2379" endpoint health

如果输出上面信息，就说明集群部署成功。如果有问题第一步先看日志：/var/log/message 或 journalctl -u etcd

2.4.8、K8S集群灾备环境部署

https://www.cnblogs.com/kevingrace/p/14616824.html

三、安装Docker

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

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

3.1、上传解压二进制包

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

3.2、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

3.3、创建配置文件

mkdir /etc/docker
cat > /etc/docker/daemon.json << EOF
{
  "registry-mirrors": ["https://b9pmyelo.mirror.aliyuncs.com"], #镜像加速地址
  "insecure-registries": ["harbor.mujidigital.com"], #  这个私库的服务地址
  "log-driver":"json-file",
  # 日志配置
  "log-opts": {
    "cache-disabled": "false",
    "cache-max-file": "5",
    "cache-max-size": "20m",
    "cache-compress": "true",
    "env": "os,customer",
    "labels": "somelabel",
    "max-size":"5m",
    "max-file":"3"
   },
   "data-root": "/home/docker", 
}
EOF

registry-mirrors 阿里云镜像加速器

3.4、启动并设置开机启动

systemctl daemon-reload
systemctl start docker && systemctl enable docker

3.5、docker-compose部署

mv docker-compose-Linux-x86_64 /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose

四、部署Master Node

4.1 、生成kube-apiserver证书

4.1.1、自签证书颁发机构（CA）

cd /home/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

生成证书

cfssl gencert -initca ca-csr.json | cfssljson -bare ca -
ls *pem

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

cat > server-csr.json << EOF
{
    "CN": "kubernetes",
    "hosts": [
      "10.0.0.1",
      "127.0.0.1",
      "172.16.0.2",
      "175.178.7.37",
      "172.16.0.9",
      "106.55.198.219",
      "172.16.0.11",
      "43.139.128.126",
      "172.16.0.4",
      "119.91.254.62",
      "172.16.0.7",
      "42.193.246.5",
      "172.16.0.10",
      "159.75.233.93",
      "172.16.0.5",
      "119.91.147.240",
      "172.16.0.17",
      "42.193.250.91",
      "172.16.0.8",
      "159.75.252.24",
      "172.16.0.8",
      "159.75.252.24",
      "172.16.0.13",
      "43.138.225.68",
      "172.16.0.3",
      "175.178.42.67",
      "172.16.0.12",
      "175.178.242.101",
      "172.16.0.14",
      "106.55.187.224",
      "58.34.210.181",
      "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。

生成证书

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

4.2、从Github下载二进制文件

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

注：打开链接你会发现里面有很多包，下载一个server包就够了，包含了Master和Worker Node二进制文件。

4.3、解压二进制包

rz -y 
mkdir -p /home/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 /home/kubernetes/bin
cp kubectl /usr/bin/

4.4、部署kube-apiserver

4.41、创建配置文件

cat > /home/kubernetes/cfg/kube-apiserver.conf << EOF
KUBE_APISERVER_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/home/kubernetes/logs \\
--etcd-servers=https://172.16.0.2:2379,https://172.16.0.9:2379,https://172.16.0.11:2379 \\
--bind-address=172.16.0.2 \\
--secure-port=6443 \\
--advertise-address=172.16.0.2 \\
--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=/home/kubernetes/cfg/token.csv \\
--service-node-port-range=8000-39767 \\
--kubelet-client-certificate=/home/kubernetes/ssl/server.pem \\
--kubelet-client-key=/home/kubernetes/ssl/server-key.pem \\
--tls-cert-file=/home/kubernetes/ssl/server.pem  \\
--tls-private-key-file=/home/kubernetes/ssl/server-key.pem \\
--client-ca-file=/home/kubernetes/ssl/ca.pem \\
--service-account-key-file=/home/kubernetes/ssl/ca-key.pem \\
--service-account-issuer=api \\
--service-account-signing-key-file=/home/kubernetes/ssl/server-key.pem \\
--etcd-cafile=/home/etcd/ssl/ca.pem \\
--etcd-certfile=/home/etcd/ssl/server.pem \\
--etcd-keyfile=/home/etcd/ssl/server-key.pem \\
--requestheader-client-ca-file=/home/kubernetes/ssl/ca.pem \\
--proxy-client-cert-file=/home/kubernetes/ssl/server.pem \\
--proxy-client-key-file=/home/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=/home/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：审计日志

• 启动聚合层相关配置：--requestheader-client-ca-file，--proxy-client-cert-file，--proxy-client-key-file，--requestheader-allowed-names，--requestheader-extra-headers-prefix，--requestheader-group-headers，--requestheader-username-headers，--enable-aggregator-routing

4.4.2、拷贝刚才生成的证书

把刚才生成的证书拷贝到配置文件中的路径

cp /home/TLS/k8s/ca*pem /home/TLS/k8s/server*pem /home/kubernetes/ssl/

4.4.3、启用 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还是由我们统一颁发一个证书。

TLS bootstraping 工作流程：

创建上述配置文件中token文件：

cat > /home/kubernetes/cfg/token.csv << EOF
5537820e61efce1ba13256c92196d8f5,kubelet-bootstrap,10001,"system:node-bootstrapper"
EOF

格式：token，用户名，UID，用户组

token也可自行生成替换

head -c 16 /dev/urandom | od -An -t x | tr -d ' '

4.4.4、systemd管理apiserver

cat > /usr/lib/systemd/system/kube-apiserver.service << EOF
[Unit]
Description=Kubernetes API Server
Documentation=https://github.com/kubernetes/kubernetes

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

[Install]
WantedBy=multi-user.target
EOF

4.4.5、启动并设置开机启动

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

4.5 部署kube-controller-manager

4.5.1、创建配置文件

cat > /home/kubernetes/cfg/kube-controller-manager.conf << EOF
KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/home/kubernetes/logs \\
--leader-elect=true \\
--kubeconfig=/home/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=/home/kubernetes/ssl/ca.pem \\
--cluster-signing-key-file=/home/kubernetes/ssl/ca-key.pem  \\
--root-ca-file=/home/kubernetes/ssl/ca.pem \\
--service-account-private-key-file=/home/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保持一致

生成kube-controller-manager证书

# 切换工作目录
cd /home/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文件（以下是shell命令，直接在终端执行）

KUBE_CONFIG="/home/kubernetes/cfg/kube-controller-manager.kubeconfig"
KUBE_APISERVER="https://172.16.0.2:6443"
kubectl config set-cluster kubernetes \
  --certificate-authority=/home/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.5.2、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=/home/kubernetes/cfg/kube-controller-manager.conf
ExecStart=/home/kubernetes/bin/kube-controller-manager \$KUBE_CONTROLLER_MANAGER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

4.5.3、启动并设置开机启动

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

4.6 部署kube-scheduler

4.6.1、创建配置文件

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

• --kubeconfig：连接apiserver配置文件

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

生成kube-scheduler证书

# 切换工作目录
cd /home/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文件(以下是shell命令，直接在终端执行)：

KUBE_CONFIG="/home/kubernetes/cfg/kube-scheduler.kubeconfig"
KUBE_APISERVER="https://172.16.0.2:6443"

kubectl config set-cluster kubernetes \
  --certificate-authority=/home/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.6.2、systemd管理scheduler

cat > /usr/lib/systemd/system/kube-scheduler.service << EOF
[Unit]
Description=Kubernetes Scheduler
Documentation=https://github.com/kubernetes/kubernetes

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

[Install]
WantedBy=multi-user.target
EOF

4.6.3、启动并设置开机启动

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

systemctl status kube-scheduler

4.6.4、查看集群状态

生成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.0.2:6443"

kubectl config set-cluster kubernetes \
  --certificate-authority=/home/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节点组件运行正常。

4.5.5、授权kubelet-bootstrap用户允许请求证书

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

五、部署Worker Node

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

5.1 创建工作目录并拷贝二进制文件

在所有worker node创建工作目录

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

从master节点拷贝

cd /home/kubernetes/server/bin
 本地拷贝
cp kubelet kube-proxy /home/kubernetes/bin

5.2 部署kubelet

5.2.1、创建配置文件

cat > /home/kubernetes/cfg/kubelet.conf << EOF
KUBELET_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/home/kubernetes/logs \\
--hostname-override=k8s-master1 \\
--network-plugin=cni \\
--kubeconfig=/home/kubernetes/cfg/kubelet.kubeconfig \\
--bootstrap-kubeconfig=/home/kubernetes/cfg/bootstrap.kubeconfig \\
--config=/home/kubernetes/cfg/kubelet-config.yml \\
--cert-dir=/home/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 > /home/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: /home/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="/home/kubernetes/cfg/bootstrap.kubeconfig"
# apiserver IP:PORT
KUBE_APISERVER="https://172.16.0.2:6443"
# 与token.csv里保持一致
# cat /home/kubernetes/cfg/token.csv
TOKEN="5537820e61efce1ba13256c92196d8f5" 

# 生成 kubelet bootstrap kubeconfig 配置文件
kubectl config set-cluster kubernetes \
  --certificate-authority=/home/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=/home/kubernetes/cfg/kubelet.conf
ExecStart=/home/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.3、批准kubelet证书申请并加入集群

# 查看kubelet证书请求
kubectl get csr
NAME                                                   AGE    SIGNERNAME                                    REQUESTOR           CONDITION
node-csr-st-0PNWQkziz7WykbkCTaLpJMcQTIVa4s4rq4SgVbbU   108s   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Pending

# 批准申请
kubectl certificate approve node-csr-st-0PNWQkziz7WykbkCTaLpJMcQTIVa4s4rq4SgVbbU

# 查看节点
kubectl get node
NAME         STATUS     ROLES    AGE   VERSION
k8s-master1   NotReady   <none>   7s    v1.18.3

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

5.4 部署kube-proxy

5.4.1、创建配置文件

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

5.4.2、配置参数文件

cat > /home/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: /home/kubernetes/cfg/kube-proxy.kubeconfig
hostnameOverride: k8s-master1
clusterCIDR: 10.0.0.0/24
EOF

5.4.3、生成kube-proxy.kubeconfig文件

生成kube-proxy证书

# 切换工作目录
cd /home/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="/home/kubernetes/cfg/kube-proxy.kubeconfig"
KUBE_APISERVER="https://172.16.0.2:6443"

kubectl config set-cluster kubernetes \
  --certificate-authority=/home/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.4.4、 systemd管理kube-proxy

cat > /usr/lib/systemd/system/kube-proxy.service << EOF
[Unit]
Description=Kubernetes Proxy
After=network.target

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

[Install]
WantedBy=multi-user.target
EOF

5.4.5.、启动并设置开机启动

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

5.5 部署网络组件

5.5.1、简介

Calico 是一种容器之间互通的网络方案。在虚拟化平台中，比如 OpenStack、Docker 等都需要实现 workloads 之间互连，但同时也需要对容器做隔离控制，就像在 Internet 中的服务仅开放80端口、公有云的多租户一样，提供隔离和管控机制。而在多数的虚拟化平台实现中，通常都使用二层隔离技术来实现容器的网络，这些二层的技术有一些弊端，比如需要依赖 VLAN、bridge 和隧道等技术，其中 bridge 带来了复杂性，vlan 隔离和 tunnel 隧道则消耗更多的资源并对物理环境有要求，随着网络规模的增大，整体会变得越加复杂。我们尝试把 Host 当作 Internet 中的路由器，同样使用 BGP 同步路由，并使用 iptables 来做安全访问策略，最终设计出了 Calico 方案。

适用场景：k8s环境中的pod之间需要隔离

设计思想：Calico 不使用隧道或 NAT 来实现转发，而是巧妙的把所有二三层流量转换成三层流量，并通过 host 上路由配置完成跨 Host 转发。

设计优势：

1.更优的资源利用

二层网络通讯需要依赖广播消息机制，广播消息的开销与 host 的数量呈指数级增长，Calico 使用的三层路由方法，则完全抑制了二层广播，减少了资源开销。

另外，二层网络使用 VLAN 隔离技术，天生有 4096 个规格限制，即便可以使用 vxlan 解决，但 vxlan 又带来了隧道开销的新问题。而 Calico 不使用 vlan 或 vxlan 技术，使资源利用率更高。

2.可扩展性

Calico 使用与 Internet 类似的方案，Internet 的网络比任何数据中心都大，Calico 同样天然具有可扩展性。

3.简单而更容易 debug

因为没有隧道，意味着 workloads 之间路径更短更简单，配置更少，在 host 上更容易进行 debug 调试。

4.更少的依赖

Calico 仅依赖三层路由可达。

5.可适配性

Calico 较少的依赖性使它能适配所有 VM、Container、白盒或者混合环境场景。

5.5.2、Clico架构

Calico网络模型主要工作组件：

1.Felix：运行在每一台 Host 的 agent 进程，主要负责网络接口管理和监听、路由、ARP 管理、ACL 管理和同步、状态上报等。

2.etcd：分布式键值存储，主要负责网络元数据一致性，确保Calico网络状态的准确性，可以与kubernetes共用；

3.BGP Client（BIRD）：Calico 为每一台 Host 部署一个 BGP Client，使用 BIRD 实现，BIRD 是一个单独的持续发展的项目，实现了众多动态路由协议比如 BGP、OSPF、RIP 等。在 Calico 的角色是监听 Host 上由 Felix 注入的路由信息，然后通过 BGP 协议广播告诉剩余 Host 节点，从而实现网络互通。

4.BGP Route Reflector：在大型网络规模中，如果仅仅使用 BGP client 形成 mesh 全网互联的方案就会导致规模限制，因为所有节点之间俩俩互联，需要 N^2 个连接，为了解决这个规模问题，可以采用 BGP 的 Router Reflector 的方法，使所有 BGP Client 仅与特定 RR 节点互联并做路由同步，从而大大减少连接数。

Felix

Felix会监听ECTD中心的存储，从它获取事件，比如说用户在这台机器上加了一个IP，或者是创建了一个容器等。用户创建pod后，Felix负责将其网卡、IP、MAC都设置好，然后在内核的路由表里面写一条，注明这个IP应该到这张网卡。同样如果用户制定了隔离策略，Felix同样会将该策略创建到ACL中，以实现隔离。

BIRD

BIRD是一个标准的路由程序，它会从内核里面获取哪一些IP的路由发生了变化，然后通过标准BGP的路由协议扩散到整个其他的宿主机上，让外界都知道这个IP在这里，你们路由的时候得到这里来。

架构特点

由于Calico是一种纯三层的实现，因此可以避免与二层方案相关的数据包封装的操作，中间没有任何的NAT，没有任何的overlay，所以它的转发效率可能是所有方案中最高的，因为它的包直接走原生TCP/IP的协议栈，它的隔离也因为这个栈而变得好做。因为TCP/IP的协议栈提供了一整套的防火墙的规则，所以它可以通过IPTABLES的规则达到比较复杂的隔离逻辑。

https://www.cnblogs.com/goldsunshine/p/10701242.html

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

部署Calico

kubectl apply -f calico.yaml
kubectl get pods -n kube-system

等Calico Pod都Running，节点也会准备就绪

kubectl get node

5.6 授权apiserver访问kubelet

应用场景：例如kubectl logs

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.7 新增加Worker Node

5.7.1、拷贝已部署好的Node相关文件到新节点

在Master节点将Worker Node涉及文件拷贝到新节点172.30.0.4/7/9

scp -r /home/kubernetes root@172.16.0.4:/home/
scp -r /home/kubernetes root@172.16.0.4:/home/

scp -r /usr/lib/systemd/system/{kubelet,kube-proxy}.service root@172.16.0.4:/usr/lib/systemd/system
scp -r /usr/lib/systemd/system/{kubelet,kube-proxy}.service root@172.21.0.17:/usr/lib/systemd/system

scp /home/kubernetes/ssl/ca.pem root@172.16.0.4:/home/kubernetes/ssl
scp /home/kubernetes/ssl/ca.pem root@172.21.0.17:/home/kubernetes/ssl

5.7.2.、删除kubelet证书和kubeconfig文件

rm -f /home/kubernetes/cfg/kubelet.kubeconfig 
rm -f /home/kubernetes/ssl/kubelet*

注：这几个文件是证书申请审批后自动生成的，每个Node不同，必须删除

5.7.3、修改主机名(所有node节点)

vim /home/kubernetes/cfg/kubelet.conf
--hostname-override=k8s-node1

vim /home/kubernetes/cfg/kube-proxy-config.yml
hostnameOverride: k8s-node1

5.7.4、启动并设置开机启动(所有node节点)

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

5.7.5、在Master上批准新Node kubelet证书申请

# 查看证书请求
kubectl get csr
NAME                                                   AGE   SIGNERNAME                                    REQUESTOR           CONDITION
node-csr-ddLYmtiXoErhbwQpDTA37mBxCuk6w05LhL9W9ql9fmY   57s   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Pending
node-csr-muX16IOklcsqJ-vHl9HkxzR7rfthEfFm-l6BzvEHoRU   57s   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Pending
node-csr-st-0PNWQkziz7WykbkCTaLpJMcQTIVa4s4rq4SgVbbU   33m   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Approved,Issued

# 授权请求
kubectl certificate approve node-csr-ddLYmtiXoErhbwQpDTA37mBxCuk6w05LhL9W9ql9fmY
kubectl certificate approve node-csr-muX16IOklcsqJ-vHl9HkxzR7rfthEfFm-l6BzvEHoRU

5.7.6、查看Node状态

kubectl get node
NAME          STATUS   ROLES    AGE     VERSION
k8s-master1   Ready    <none>   37m     v1.20.4
k8s-node1     Ready    <none>   4m54s   v1.20.4
k8s-node2     Ready    <none>   10s     v1.20.4

六、部署Dashboard和CoreDNS

6.1 部署Dashboard

$ wget https://raw.githubusercontent.com/kubernetes/dashboard/v2.0.0-beta8/aio/deploy/recommended.yaml
kubectl apply -f kubernetes-dashboard.yaml
# 查看部署
kubectl get pods,svc -n kubernetes-dashboard

访问地址：https://NodeIP:30001

thisisunsafe

创建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}')

使用输出的token登录Dashboard

6.2 部署CoreDNS

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

kubectl apply -f coredns.yaml 
kubectl get pods -n kube-system
NAME                                      READY   STATUS    RESTARTS   AGE
calico-kube-controllers-97769f7c7-f6z7g   1/1     Running   0          37m
calico-node-5rgt8                         1/1     Running   0          12m
calico-node-frc9p                         1/1     Running   0          17m
calico-node-n9h75                         1/1     Running   0          37m
coredns-6cc56c94bd-fqhmc                  1/1     Running   0          36s

DNS解析测试：

kubectl run -it --rm dns-test --image=busybox:1.28.4 sh
nslookup kubernetes
Server:    10.0.0.2
Address 1: 10.0.0.2 kube-dns.kube-system.svc.cluster.local

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

解析没问题。

至此一个单Master集群就搭建完成了！这个环境就足以满足学习实验了，如果你的服务器配置较高，可继续扩容多Master集群！

七、高可用架构（扩容多Master架构）

Kubernetes作为容器集群系统，通过健康检查+重启策略实现了Pod故障自我修复能力，通过调度算法实现将Pod分布式部署，并保持预期副本数，根据Node失效状态自动在其他Node拉起Pod，实现了应用层的高可用性。

针对Kubernetes集群，高可用性还应包含以下两个层面的考虑：Etcd数据库的高可用性和Kubernetes Master组件的高可用性。而Etcd我们已经采用3个节点组建集群实现高可用，本节将对Master节点高可用进行说明和实施。

Master节点扮演着总控中心的角色，通过不断与工作节点上的Kubelet和kube-proxy进行通信来维护整个集群的健康工作状态。如果Master节点故障，将无法使用kubectl工具或者API做任何集群管理。

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

多Master架构图：

7.1 部署Master2 Node

现在需要再增加一台新服务器，作为Master2 Node，IP是172.30.0.8。

为了节省资源你也可以将之前部署好的Worker Node1复用为Master2 Node角色（即部署Master组件）

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

7.1.1、安装Docker(Master2操作)

scp /usr/bin/docker* root@172.16.0.9:/usr/bin
scp /usr/bin/runc root@172.16.0.9:/usr/bin
scp /usr/bin/containerd* root@172.16.0.9:/usr/bin
scp /usr/lib/systemd/system/docker.service root@172.16.0.9:/usr/lib/systemd/system
scp -r /etc/docker root@172.16.0.9:/etc

# 在Master2启动Docker
systemctl daemon-reload
systemctl start docker && systemctl enable docker
systemctl status docker

7.1.2、创建etcd证书目录(Master2操作)

在Master2创建etcd证书目录：

mkdir -p /home/etcd/ssl

7.1.3、拷贝文件（Master1操作）

拷贝Master1上所有K8s文件和etcd证书到Master2

scp -r /home/kubernetes root@172.30.0.5:/home
scp -r /home/etcd/ssl root@172.30.0.5:/home/etcd
scp /usr/lib/systemd/system/kube* root@172.30.0.5:/usr/lib/systemd/system
scp /usr/bin/kubectl  root@172.30.0.5:/usr/bin
scp -r ~/.kube root@172.30.0.8:

7.1.4、删除证书文件

删除kubelet证书和kubeconfig文件

rm -f /home/kubernetes/cfg/kubelet.kubeconfig 
rm -f /home/kubernetes/ssl/kubelet*

7.1.5、修改配置文件IP和主机名

修改apiserver、kubelet和kube-proxy配置文件为本地IP

vim /home/kubernetes/cfg/kube-apiserver.conf
...
--bind-address=172.30.0.8 \
--advertise-address=172.30.0.8 \

vim /home/kubernetes/cfg/kubelet.conf
--hostname-override=k8s-master2

vim /home/kubernetes/cfg/kube-proxy-config.yml
hostnameOverride: k8s-master2

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

7.1.7、查看集群状态

# 修改连接master为本机IP
vi ~/.kube/config
...
server: https://172.30.0.8: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-Sd1IycNrKODUoi7vHcgoWUBFkHEci0CawaD73hojIfE   35m     kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Approved,Issued
node-csr-ddLYmtiXoErhbwQpDTA37mBxCuk6w05LhL9W9ql9fmY   41m     kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Approved,Issued
node-csr-muX16IOklcsqJ-vHl9HkxzR7rfthEfFm-l6BzvEHoRU   41m     kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Approved,Issued
node-csr-st-0PNWQkziz7WykbkCTaLpJMcQTIVa4s4rq4SgVbbU   74m     kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Approved,Issued
node-csr-wmxNNSxt6qSYug22ebC43et6A9NT1DlX7-dTdLDa8Eo   2m55s   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Pending
node-csr-z13FoMcIz0UO5hCXJkDGWK01jVscp0qBkGrGJoXkt0w   2m38s   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Pending

# 授权请求
kubectl certificate approve node-csr-z13FoMcIz0UO5hCXJkDGWK01jVscp0qBkGrGJoXkt0w

# 查看Node
kubectl get node
NAME          STATUS   ROLES    AGE    VERSION
k8s-master1   Ready    <none>   75m    v1.20.4
k8s-master2   Ready    <none>   105s   v1.20.4
k8s-node1     Ready    <none>   42m    v1.20.4
k8s-node2     Ready    <none>   37m    v1.20.4

7.2 部署Nginx+Keepalived高可用负载均衡器

kube-apiserver高可用架构图

• Nginx是一个主流Web服务和反向代理服务器，这里用四层实现对apiserver实现负载均衡。

• Keepalived是一个主流高可用软件，基于VIP绑定实现服务器双机热备，在上述拓扑中，Keepalived主要根据Nginx运行状态判断是否需要故障转移（漂移VIP），例如当Nginx主节点挂掉，VIP会自动绑定在Nginx备节点，从而保证VIP一直可用，实现Nginx高可用。

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

注2：如果你是在公有云上，一般都不支持keepalived，那么你可以直接用它们的负载均衡器产品，直接负载均衡多台Master kube-apiserver，架构与上面一样。

在两台Master节点操作。

https://cloud.tencent.com/document/product/215/20186

7.2.1、安装软件包（主/备）

yum install epel-release -y
yum install nginx keepalived -y

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.30.0.14:6443; # Master1 APISERVER IP:PORT
server 172.30.0.8:6443; # Master2 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 eth0 # 修改为实际网卡名
virtual_router_id 51 # VRRP 路由 ID实例，每个实例是唯一的
priority 100 # 优先级，备服务器设置 90
advert_int 1 # 指定VRRP 心跳包通告间隔时间，默认1秒
authentication {
auth_type PASS
auth_pass 1111
}
# 虚拟IP
virtual_ipaddress {
172.30.0.11/24
}
track_script {
check_nginx
}
}
EOF



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 eth0 # 修改为实际网卡名
virtual_router_id 51 # VRRP 路由 ID实例，每个实例是唯一的
priority 100 # 优先级，备服务器设置 90
advert_int 1 # 指定VRRP 心跳包通告间隔时间，默认1秒
authentication {
auth_type PASS
auth_pass 1111
}
unicast_src_ip 172.30.0.14 # 设置本机内网IP地址
unicast_peer {
172.30.0.8 # 对端设备的 IP 地址
}
notify_master "/etc/keepalived/notify_action.sh MASTER"
notify_backup "/etc/keepalived/notify_action.sh BACKUP"
notify_fault "/etc/keepalived/notify_action.sh FAULT"
notify_stop "/etc/keepalived/notify_action.sh STOP"
garp_master_delay 1 # 设置当切为主状态后多久更新 ARP 缓存
garp_master_refresh 5 # 设置主节点发送 ARP 报文的时间间隔
track_interface {
eth0 # 使用绑定 VIP 的网卡 例如 eth0
}
# 虚拟IP
virtual_ipaddress {
172.30.0.11/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

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 eth0
virtual_router_id 51 # VRRP 路由 ID实例，每个实例是唯一的
priority 90
advert_int 1
authentication {
auth_type PASS
auth_pass 1111
}
virtual_ipaddress {
172.30.0.11/24
}
track_script {
check_nginx
}
}
EOF


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 eth0
virtual_router_id 51 # VRRP 路由 ID实例，每个实例是唯一的
priority 90
advert_int 1
authentication {
auth_type PASS
auth_pass 1111
}
unicast_src_ip 172.30.0.8 # 设置本机内网IP地址
unicast_peer {
172.30.0.14 # 对端设备的 IP 地址
}
notify_master "/etc/keepalived/notify_action.sh MASTER"
notify_backup "/etc/keepalived/notify_action.sh BACKUP"
notify_fault "/etc/keepalived/notify_action.sh FAULT"
notify_stop "/etc/keepalived/notify_action.sh STOP"
garp_master_delay 1 # 设置当切为主状态后多久更新 ARP 缓存
garp_master_refresh 5 # 设置主节点发送 ARP 报文的时间间隔
track_interface {
eth0 # 使用绑定 VIP 的网卡 例如 eth0
}
virtual_ipaddress {
172.30.0.11/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

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

7.2.5、启动并设置开机启动

systemctl daemon-reload
systemctl start nginx keepalived && systemctl enable nginx keepalived
systemctl status keepalived

7.2.6、查看keepalived工作状态

ip addr

1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
inet6 ::1/128 scope host
valid_lft forever preferred_lft forever
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000
link/ether 52:54:00:7f:6c:d6 brd ff:ff:ff:ff:ff:ff
inet 172.30.0.9/20 brd 172.30.15.255 scope global eth0
valid_lft forever preferred_lft forever
inet 172.30.0.11/24 scope global eth0
valid_lft forever preferred_lft forever
inet6 fe80::5054:ff:fe7f:6cd6/64 scope link
valid_lft forever preferred_lft forever

可以看到，在eth0网卡绑定了172.30.0.11 虚拟IP，说明工作正常。

7.2.7、 Nginx+Keepalived高可用测试

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

在Nginx Master执行 pkill nginx;

pkill nginx

在Nginx Backup，ip addr命令查看已成功绑定VIP。

ip addr

7.2.8、访问负载均衡器测试

找K8s集群中任意一个节点，使用curl查看K8s版本测试，使用VIP访问

curl -k https://172.30.0.11:16443/version
{
"major": "1",
"minor": "20",
"gitVersion": "v1.20.4",
"gitCommit": "e87da0bd6e03ec3fea7933c4b5263d151aafd07c",
"gitTreeState": "clean",
"buildDate": "2021-02-18T16:03:00Z",
"goVersion": "go1.15.8",
"compiler": "gc",
"platform": "linux/amd64"
}

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

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

tail /var/log/nginx/k8s-access.log -f

172.30.0.14 172.30.0.14:6443 - [11/Jun/2021:11:04:21 +0800] 200 421
172.30.0.4 172.30.0.14:6443 - [11/Jun/2021:11:04:27 +0800] 200 421

到此还没结束，还有下面最关键的一步。

7.3 修改所有Worker Node连接LB VIP

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

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

在所有Worker Node执行：

sed -i 's#172.30.0.14:6443#172.30.0.11:16443#' /home/kubernetes/cfg/*
systemctl restart kubelet kube-proxy
systemctl status kubelet kube-proxy

检查节点状态

kubectl get node

NAME STATUS ROLES AGE VERSION
k8s-master1 Ready <none> 98m v1.20.4
k8s-master2 Ready <none> 24m v1.20.4
k8s-node1 Ready <none> 65m v1.20.4
k8s-node2 Ready <none> 60m v1.20.4

至此，一套完整的 Kubernetes 高可用集群就部署完成了！

部署过程涉及文件在百度网盘地址：
链接: https://pan.baidu.com/s/18DQYE4Q_PcidbUASVr97tw
提取码: 9288

posted @ 2023-06-07 09:53 Zenxdt 阅读(11) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Zenxdt

二进制部署K8s高可用集群V1.20版本

部署一套完整的企业级K8s集群(v1.20)

一、前置知识

1.1、生产环境部署K8s集群的两种方式

kubeadm

二进制包

1.2、环境准备

服务器要求

软件环境

服务器整体规划

单Master架构图

单Master服务器规划

1.3、操作系统初始化配置

二、部署etcd集群

2.1、准备cfssl证书生成工具

2.2、生成Etcd证书

2.2.1 自签证书办法机构(CA)

2.2.2、使用自签CA签发Etcd HTTPS证书

2.3、从github下载二进制文件

2.4、部署etcd集群

2.4.1、创建工作目录并解压二进制文件

2.4.2、创建etcd配置文件

2.4.3、systemd管理etcd

2.4.4、拷贝刚才生成的证书

2.4.5、将上面节点所有生成的文件拷贝到节点2和节点3

2.4.6、启动并设置开机启动

2.4.7、查看集群状态

2.4.8、K8S集群灾备环境部署

三、安装Docker

3.1、上传解压二进制包

3.2、systemd管理docker

3.3、创建配置文件

3.4、启动并设置开机启动

3.5、docker-compose部署

四、部署Master Node

4.1 、生成kube-apiserver证书

4.1.1、 自签证书颁发机构（CA）

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

4.2、 从Github下载二进制文件

4.3、 解压二进制包

4.4、 部署kube-apiserver

4.41、 创建配置文件

4.4.2、 拷贝刚才生成的证书

4.4.3、 启用 TLS Bootstrapping 机制

4.4.4、systemd管理apiserver

4.4.5、启动并设置开机启动

4.5 部署kube-controller-manager

4.5.1、 创建配置文件

4.5.2、systemd管理controller-manager

4.5.3、 启动并设置开机启动

4.6 部署kube-scheduler

4.6.1、 创建配置文件

4.6.2、systemd管理scheduler

4.6.3、 启动并设置开机启动

4.6.4、 查看集群状态

4.5.5、授权kubelet-bootstrap用户允许请求证书

五、部署Worker Node

5.1 创建工作目录并拷贝二进制文件

5.2 部署kubelet

5.2.1、 创建配置文件

5.2.2、 配置参数文件

5.2.3、 生成kubelet初次加入集群引导kubeconfig文件

5.2.4、 systemd管理kubelet

5.2.5、 启动并设置开机启动

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

5.4 部署kube-proxy

5.4.1、 创建配置文件

5.4.2、 配置参数文件

5.4.3、 生成kube-proxy.kubeconfig文件

5.4.4、 systemd管理kube-proxy

5.4.5.、启动并设置开机启动

5.5 部署网络组件

5.5.1、简介

5.5.2、Clico架构

5.6 授权apiserver访问kubelet

5.7 新增加Worker Node

5.7.1、拷贝已部署好的Node相关文件到新节点

5.7.2.、删除kubelet证书和kubeconfig文件

5.7.3、 修改主机名(所有node节点)

4.1.1、自签证书颁发机构（CA）

4.2、从Github下载二进制文件

4.3、解压二进制包

4.4、部署kube-apiserver

4.41、创建配置文件

4.4.2、拷贝刚才生成的证书

4.4.3、启用 TLS Bootstrapping 机制

4.5.1、创建配置文件

4.5.3、启动并设置开机启动

4.6.1、创建配置文件

4.6.3、启动并设置开机启动

4.6.4、查看集群状态

5.2.1、创建配置文件

5.2.2、配置参数文件

5.2.3、生成kubelet初次加入集群引导kubeconfig文件

5.2.5、启动并设置开机启动

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

5.4.1、创建配置文件

5.4.2、配置参数文件

5.4.3、生成kube-proxy.kubeconfig文件

5.7.3、修改主机名(所有node节点)

5.7.5、在Master上批准新Node kubelet证书申请

5.7.6、查看Node状态

7.1.1、安装Docker(Master2操作)

7.1.2、创建etcd证书目录(Master2操作)

7.1.3、拷贝文件（Master1操作）

7.1.4、删除证书文件

7.1.5、修改配置文件IP和主机名

7.1.6、启动设置开机启动

7.1.7、查看集群状态

7.1.8、批准kubelet证书申请

7.2.1、安装软件包（主/备）

7.2.5、启动并设置开机启动

7.2.6、查看keepalived工作状态