文章目录

一、单master资源清单
二、系统初始化
三、部署etcd集群
- 3.1 生成etcd证书
- 3.2 部署流程
- - 3.2.1 准备二进制安装文件
  - 3.2.2 创建工作目录
  - 3.2.3 创建etcd配置文件
  - 3.2.4 设置成systemd服务
  - 3.2.5 添加etcd-2和etcd-3节点
  - 3.2.6 所有节点启动etcd并设置开机启动
四、安装容器引擎（docker）
- 4.1 二进制安装
- 4.2 设置成systemd服务
- 4.3 创建配置文件
- 4.4 启动并设置开机启动
- 4.5 安装cri-dockerd
五、部署Master节点组件
- 5.1 生成kube-apiserver证书
- 5.2 准备安装文件
- 5.3 部署kube-apiserver
- - 5.3.1 创建配置文件
  - 5.3.2 启用 TLS Bootstrapping 机制
  - 5.3.3 设置成systemd服务
  - 5.3.4 启动并设置开机自启
- 5.4 部署kube-controller-manager
- - 5.4.1 创建配置文件
  - 5.4.2 生成kubeconfig文件
  - 5.4.3 设置成systemd服务
  - 5.4.4 启动并设置开机自启
- 5.5 部署kube-scheduler
- - 5.5.1 创建配置文件
  - 5.5.2 生成kubeconfig文件
  - 5.5.3 设置成systemd服务
  - 5.5.4 启动并设置开机自启
- 5.6 kubectl命令和用户授权
六、Node节点加入集群
- 6.1 创建工作目录并拷贝二进制文件
- 6.2 部署kubelet
- 6.3 部署kube-proxy
- 6.4 部署网络组件
- 6.5 授权apiserver访问kubelet
- 6.6 新增node节点
七、部署Dashboard和Coredns
- 7.1 部署Dashboard
- 7.2 部署Coredns
八、高可用架构
- 8.1 多master资源清单
- 8.2 安装Docker
- 8.2 安装cri-docker
- 8.3 拷贝etcd文件
- 8.4 修改配置文件IP和主机名
- 8.5 启动服务设置开机自启
- 8.6 批准kubelet证书申请
- 8.7 部署nginx+keepalived
- - 8.7.1 安装服务
  - 8.7.2 配置nginx配置文件
  - 8.7.3 配置keepalived配置文件（主）
  - 8.7.4 配置keepalived配置文件（备）
  - 8.7.5 启动并设置开机自启
  - 8.7.6 测试高可用性和负载均衡
  - 8.7.7 修改所有Node连接VIP

一、单master资源清单

角色	IP	配置	安装服务	操作系统
k8s-master1	192.168.130.145	2核2G50G	kube-apiserver、kube-controller-manager、kube-scheduler、kubelet、kube-proxy、docker、cri-docker、etcd	CentOS 7.5.1804 (mini)
k8s-node1	192.168.130.146	2核2G50G	kube-apiserver、kube-controller-manager、kube-scheduler、kubelet、kube-proxy、docker、cri-docker	CentOS 7.5.1804 (mini)
k8s-node2	192.168.130.147	2核2G50G	kubelet、kube-proxy、docker、cri-docker、etcd	CentOS 7.5.1804 (mini)
VIP	192.168.130.151

二、系统初始化

##关闭防火墙。
systemctl stop firewalld
systemctl disable firewalld

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

##关闭swap
swapoff -a    ##临时关闭
sed -ri 's/.*swap.*/#&/' /etc/fstab    ##永久关闭

##根据规划设置主机名
hostnamectl set-hostname k8s-master1
hostnamectl set-hostname k8s-node1
hostnamectl set-hostname k8s-node2

##将桥接的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


##在master节点添加hosts
cat >> /etc/hosts << EOF
192.168.130.145 k8s-master1
192.168.130.146 k8s-node1
192.168.130.147 k8s-node2
EOF

三、部署etcd集群

Etcd是一个分布式键值存储系统，集群方式部署可以有效提防单节点故障问题。
这里使用3台组建集群，可容忍1台机器故障，也可以使用5台组建集群，可容忍2台机器故障。
这里是与k8s节点公用机器是为节省资源，资源充足的情况下优先考虑独立于k8s集群之外部署，只要apiserver能连接到就行。

节点名称	IP
etcd-1	192.168.130.145
etcd-2	192.168.130.146
etcd-3	192.168.130.147

3.1 生成etcd证书

1.任意节点上下载cfssl证书生成工具，这里放在master节点。

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

2.自签证书颁发机构（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

##生成证书，生成ca.pem和ca-key.pem文件。
cfssl gencert -initca ca-csr.json | cfssljson -bare ca -

3.使用自签CA签发Etcd HTTPS客户端证书。

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

##创建证书申请文件。
cat > server-csr.json << EOF
{
    "CN": "etcd",
    "hosts": [
    "192.168.130.145",
    "192.168.130.146",
    "192.168.130.147",
    "192.168.130.148"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "BeiJing",
            "ST": "BeiJing"
        }
    ]
}
EOF

##生成证书，生成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

3.2 部署流程

部署思路：

可以将etcd-1上生成的所有文件拷贝到etcd-2和etcd-3节点上，可以简化操作。
以下在etcd-1节点上操作。

3.2.1 准备二进制安装文件

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

3.2.2 创建工作目录

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

3.2.3 创建etcd配置文件

参数	释义
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表示加入已有集群

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://192.168.130.145:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.130.145:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.130.145:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.130.145:2379"
ETCD_INITIAL_CLUSTER="etcd-1=https://192.168.130.145:2380,etcd-2=https://192.168.130.146:2380,etcd-3=https://192.168.130.147:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
EOF

3.2.4 设置成systemd服务

1.设置成系统服务。

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.拷贝证书至指定路径，把刚才生成的证书拷贝到配置文件中的路径。

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

3.2.5 添加etcd-2和etcd-3节点

1.将上面etcd-1所有生成的文件拷贝到其他两个节点

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

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

2.然后在节点2和节点3分别修改etcd.conf配置文件中的节点名称和当前服务器。
在这里插入图片描述

3.2.6 所有节点启动etcd并设置开机启动

1.依次启动etcd-1、etcd-2、etcd-3节点。

systemctl daemon-reload
systemctl start etcd
systemctl enable etcd

2.查看etcd集群状态，返回状态为True代表搭建无误。

/opt/etcd/bin/etcdctl --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem --endpoints="https://192.168.130.145:2379,https://192.168.130.146:2379,https://192.168.130.147:2379" endpoint health --write-out=table

在这里插入图片描述

四、安装容器引擎（docker）

可以二进制安装，也可以yum安装。
以下操作，所有节点执行。

4.1 二进制安装

1.下载安装二进制文件。

wget https://download.docker.com/linux/static/stable/x86_64/docker-19.03.9.tgz

2.解压二进制包。

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

4.2 设置成systemd服务

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

4.3 创建配置文件

1.使用阿里云镜像加速器。

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

4.4 启动并设置开机启动

systemctl daemon-reload
systemctl start docker
systemctl enable docker

在这里插入图片描述

4.5 安装cri-dockerd

1.下载二进制文件，并解压文件。

https://github.com/Mirantis/cri-dockerd/releases/download/v0.2.5/cri-dockerd-0.2.5.amd64.tgz
tar zxvf cri-dockerd-0.2.5.amd64.tgz
mv cri-dockerd/cri-dockerd /usr/bin/

2.设置成系统服务。

cat >/usr/lib/systemd/system/cri-docker.service << EOF
[Unit]
Description=CRI Interface for Docker Application Container Engine
Documentation=https://docs.mirantis.com
After=network-online.target firewalld.service docker.service
Wants=network-online.target

[Service]
Type=notify
ExecStart=/usr/bin/cri-dockerd --network-plugin=cni --pod-infra-container-image=registry.aliyuncs.com/google_containers/pause:3.7
ExecReload=/bin/kill -s HUP $MAINPID
TimeoutSec=0
RestartSec=2
Restart=always

[Install]
WantedBy=multi-user.target
EOF

3.启动并设置开机自启。

systemctl daemon-reload
systemctl start cri-docker
systemctl enable cri-docker

在这里插入图片描述

五、部署Master节点组件

5.1 生成kube-apiserver证书

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

2.生成证书，会生成ca.pem和ca-key.pem文件。

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

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

hosts字段中IP为所有Master/LB/VIP IP，一个都不能少。
为了方便后期扩容可以多写几个预留的IP。

cat > server-csr.json << EOF
{
    "CN": "kubernetes",
    "hosts": [
      "10.0.0.1",
      "127.0.0.1",
      "192.168.130.145",
      "192.168.130.146",
      "192.168.130.147",
      "192.168.130.148",
      "192.168.130.151",
      "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

4.生成证书，会生成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

5.2 准备安装文件

1.打开下载地址，下载server和node安装包，注意版本。下载地址
在这里插入图片描述

2.将下载的server包和node包上传到服务器，解压server安装包，node安装包后面用。

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/

5.3 部署kube-apiserver

5.3.1 创建配置文件

配置文件参数	释义
–logtostderr	启用日志
—v	日志等级
–log-dir	日志目录
–etcd-servers	etcd集群地址
–bind-address	监听地址
–secure-port	https安全端口
–advertise-address	集群通告地址
–allow-privileged	启用授权
–service-cluster-ip-range	Service虚拟IP地址段
–enable-admission-plugins	准入控制模块
–authorization-mode	认证授权，启用RBAC授权和节点自管理
–enable-bootstrap-token-auth	启用TLS bootstrap机制
–token-auth-file	bootstrap token文件
–service-node-port-range	Service nodeport类型默认分配端口范围
–kubelet-client-xxx	apiserver访问kubelet客户端证书
–tls-xxx-file	apiserver https证书
–etcd-xxxfile	连接Etcd集群证书
–audit-log-xxx	审计日志
–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	启动聚合层相关配置
–service-account-issuer	服务帐号令牌颁发者的标识符，1.20版本必须加的参数。
–service-account-signing-key-file	包含 PEM 编码的 x509 RSA 或 ECDSA 私钥或公钥的文件，用于验证 ServiceAccount 令牌。 1.20版本必须加的参数。

1.创建配置文件，有两个\ \，第一个是转义符，第二个是换行符，使用转义符是为了使用EOF保留换行符，方便后面运维适配。

cat > /opt/kubernetes/cfg/kube-apiserver.conf << EOF
KUBE_APISERVER_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--etcd-servers=https://192.168.130.145:2379,https://192.168.130.146:2379,https://192.168.130.147:2379 \\
--bind-address=192.168.130.145 \\
--secure-port=6443 \\
--advertise-address=192.168.130.145 \\
--allow-privileged=true \\
--service-cluster-ip-range=10.0.0.0/24 \\
--enable-admission-plugins=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/ca-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

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

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

5.3.2 启用 TLS Bootstrapping 机制

前提了解：

当master apiserver启用TLS认证后，Node节点kubelet和kube-proxy要与kube-apiserver进行通信，必须使用CA签发的有效证书才可以，当Node节点很多时，这种客户端证书颁发需要大量工作，人工投入成本大。
TLS bootstraping机制可以自动颁发客户端证书，kubelet会以一个低权限用户自动向apiserver申请证书，kubelet的证书由apiserver动态签署。
烈建议在Node上使用这种方式，目前主要用于kubelet，kube-proxy还是由我们统一颁发一个证书。

1.生成一个token。

[root@k8s-master1 bin]# head -c 16 /dev/urandom | od -An -t x | tr -d ' '
c6587b7961975e59da7d44a952c7cce5

2.apiserver配置文件中指定了token文件，这里生成这个token文件。

##格式：token，用户名，UID，用户组
cat > /opt/kubernetes/cfg/token.csv << EOF
c6587b7961975e59da7d44a952c7cce5,kubelet-bootstrap,10001,"system:node-bootstrapper"
EOF

5.3.3 设置成systemd服务

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

5.3.4 启动并设置开机自启

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

在这里插入图片描述

5.4 部署kube-controller-manager

5.4.1 创建配置文件

配置文件参数	释义
–kubeconfig	连接apiserver配置文件
–leader-elect	当该组件启动多个时，自动选举（HA）
–cluster-signing-cert-file、–cluster-signing-key-file	自动为kubelet颁发证书的CA，与apiserver保持一致

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=10.244.0.0/16 \\
--service-cluster-ip-range=10.0.0.0/24 \\
--cluster-signing-cert-file=/opt/kubernetes/ssl/ca.pem \\
--cluster-signing-key-file=/opt/kubernetes/ssl/ca-key.pem  \\
--root-ca-file=/opt/kubernetes/ssl/ca.pem \\
--service-account-private-key-file=/opt/kubernetes/ssl/ca-key.pem \\
--cluster-signing-duration=87600h0m0s"
EOF

5.4.2 生成kubeconfig文件

1.生成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

2.生成kubeconfig文件。

##shell命令，直接执行。
KUBE_CONFIG="/opt/kubernetes/cfg/kube-controller-manager.kubeconfig"
KUBE_APISERVER="https://192.168.130.145: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}

5.4.3 设置成systemd服务

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

5.4.4 启动并设置开机自启

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

在这里插入图片描述

5.5 部署kube-scheduler

5.5.1 创建配置文件

配置文件参数	释义
–kubeconfig	连接apiserver配置文件
–leader-elect	当该组件启动多个时，自动选举（HA）

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

5.5.2 生成kubeconfig文件

1.生成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

2.生成kubeconfig文件

KUBE_CONFIG="/opt/kubernetes/cfg/kube-scheduler.kubeconfig"
KUBE_APISERVER="https://192.168.130.145: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}

5.5.3 设置成systemd服务

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

5.5.4 启动并设置开机自启

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

在这里插入图片描述

5.6 kubectl命令和用户授权

1.生成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

2.生成kubeconfig文件。

mkdir /root/.kube

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

3.查看当前集群组件状态，保证组件运行正常。
在这里插入图片描述

4.授权kubelet-bootstrap用户允许请求证书，也就是上面生成token时指定的那个用户。

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

六、Node节点加入集群

先把master节点加入集群，后面部署了node节点再加入。
以下操作在Master上操作，即同时作为Worker Node。

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

1.所有worker node创建工作目录，后面部署的node节点也要创建。

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

2.将master节点上的kubelet和kube-proxy拷贝到对应目录，现在是在master节点上操作所以是本地拷贝。

cd kubernetes/server/bin
cp kubelet kube-proxy /opt/kubernetes/bin

6.2 部署kubelet

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

1.创建配置文件。

cat > /opt/kubernetes/cfg/kubelet.conf << EOF
KUBELET_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--hostname-override=k8s-master1 \\
--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 \\
--container-runtime-endpoint=unix:///var/run/cri-dockerd.sock"
EOF

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:
- 10.0.0.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

3.生成kubelet初次加入集群引导kubeconfig文件。

KUBE_CONFIG="/opt/kubernetes/cfg/bootstrap.kubeconfig"
KUBE_APISERVER="https://192.168.130.145:6443"    ##修改
TOKEN="c6587b7961975e59da7d44a952c7cce5"       ##修改，与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}

4.设置成systemd服务。

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.启动，并设置开机自启。

systemctl daemon-reload
systemctl start kubelet
systemctl enable kubelet

在这里插入图片描述

6.批准kubelet证书申请并加入集群，查看集群节点。

kubectl get csr
kubectl certificate approve 【csr名称】
kubectl  get node

在这里插入图片描述

6.3 部署kube-proxy

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

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: k8s-master1
clusterCIDR: 10.244.0.0/16
EOF

3.生成kube-proxy.kubeconfig文件。

# 切换工作目录
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

4.生成kubeconfig文件。

KUBE_CONFIG="/opt/kubernetes/cfg/kube-proxy.kubeconfig"
KUBE_APISERVER="https://192.168.130.145: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.设置成systemd服务。

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

6.启动，并设置开机自启。

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

6.4 部署网络组件

1.官网下载yaml，修改定义Pod网络（CALICO_IPV4POOL_CIDR），与前面kubeadm init的 --pod-network-cidr指定一致。

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

在这里插入图片描述
2.等Calico Pod都Running，节点也会准备就绪。

6.5 授权apiserver访问kubelet

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

6.6 新增node节点

1.master节点操作，将Worker Node涉及文件拷贝到新节点192.168.130.146。

scp -r /opt/kubernetes root@192.168.130.146:/opt/
scp -r /usr/lib/systemd/system/{kubelet,kube-proxy}.service root@192.168.130.146:/usr/lib/systemd/system

2.node1节点操作，删除kubelet证书和kubeconfig文件。因为这几个文件是证书申请审批后自动生成的，每个Node不同，必须删除

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

3.node1节点修改配置文件主机名。

vi /opt/kubernetes/cfg/kubelet.conf
--hostname-override=k8s-node1

vi /opt/kubernetes/cfg/kube-proxy-config.yml
hostnameOverride: k8s-node1

4.node1节点操作，启动并设置开机自启。

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

在这里插入图片描述
5.master节点操作，批准新Node kubelet证书申请。

# 查看证书请求
kubectl get csr

# 授权请求
kubectl certificate approve 【csr名称】

6.将kubelet命令复制到/usr/bin，方便查询。
在这里插入图片描述
7.master1节点上操作，将连接集群命令文件传到其他node节点。

scp /root/.kube/config root@192.168.130.146:/root/.kube/
scp /root/.kube/config root@192.168.130.147:/root/.kube/

8.查看Node状态。
在这里插入图片描述
9.其他node节点加入也是同理。

七、部署Dashboard和Coredns

7.1 部署Dashboard

1.下载yaml文件。

wget https://raw.githubusercontent.com/kubernetes/dashboard/v2.4.0/aio/deploy/recommended.yaml

2.修改yaml，认Dashboard只能集群内部访问，修改Service为NodePort类型，暴露到外部。

......
kind: Service
apiVersion: v1
metadata:
  labels:
    k8s-app: kubernetes-dashboard
  name: kubernetes-dashboard
  namespace: kubernetes-dashboard
spec:
  ports:
    - port: 443
      targetPort: 8443
      nodePort: 30001    ##添加此行。
  selector:
    k8s-app: kubernetes-dashboard
  type: NodePort   ##添加此行。
......

3.导入yaml，查看容器运行状态。

kubectl apply -f recommended.yaml

在这里插入图片描述
4.获取token，准备登录。


[root@k8s-master ~]# kubectl create serviceaccount dashboard-admin -n kubernetes-dashboard

[root@k8s-master ~]# kubectl create clusterrolebinding dashboard-admin --clusterrole=cluster-admin --serviceaccount=kubernetes-dashboard:dashboard-admin

[root@k8s-master ~]# kubectl create token dashboard-admin -n kube-system

5.访问k8s任意节点IP:30001，会发现被拦截了，这是因为chrome认为该网站不安全，不让访问，我们在当前页面随意处输入“thisisunsafe”回车即可解决，相当于了解了风险依然访问，之后就可以访问网页，但那之后再出问题也就没有责任了。
在这里插入图片描述

7.2 部署Coredns

1.下载官网yaml，修改几个配置参数，下载地址。
在这里插入图片描述
2.修改集群名称和clusterip ，这个在安装kubelet组件时在它的参数文件里已经制定了，需要一一对应。

3.修改coredns镜像下载地址和容器资源限制。
在这里插入图片描述
4.导入yaml，查看容器运行状态。

5.创建测试容器，进入容器测试，测试无误。

kubectl run bs --image=busybox:1.28.4 -- sleep 24h

在这里插入图片描述

八、高可用架构

8.1 多master资源清单

这里就是接着上面的单master集群扩展了一个master节点，并加上nginx+keepalived。

角色	IP	配置	安装服务	操作系统
k8s-master1	192.168.130.145	2核2G50G	kube-apiserver、kube-controller-manager、kube-scheduler、kubelet、kube-proxy、docker、cri-docker、etcd、nginx、keepalived	CentOS 7.5.1804 (mini)
k8s-node1	192.168.130.146	2核2G50G	kube-apiserver、kube-controller-manager、kube-scheduler、kubelet、kube-proxy、docker、cri-docker	CentOS 7.5.1804 (mini)
k8s-node2	192.168.130.147	2核2G50G	kubelet、kube-proxy、docker、cri-docker、etcd	CentOS 7.5.1804 (mini)
k8s-master2	192.168.130.148	2核2G50G	kube-apiserver、kube-controller-manager、kube-scheduler、kubelet、kube-proxy、docker、cri-docker、nginx、keepalived	CentOS 7.5.1804 (mini)
VIP	192.168.130.151

8.2 安装Docker

1.master1节点上操作，把相关环境文件传到master2节点。

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

2.master2节点上操作，启动Docker。

systemctl daemon-reload
systemctl start docker
systemctl enable docker

8.2 安装cri-docker

1.下载二进制文件，并解压文件。

https://github.com/Mirantis/cri-dockerd/releases/download/v0.2.5/cri-dockerd-0.2.5.amd64.tgz
tar zxvf cri-dockerd-0.2.5.amd64.tgz
mv cri-dockerd/cri-dockerd /usr/bin/

2.设置成系统服务。

cat >/usr/lib/systemd/system/cri-docker.service << EOF
[Unit]
Description=CRI Interface for Docker Application Container Engine
Documentation=https://docs.mirantis.com
After=network-online.target firewalld.service docker.service
Wants=network-online.target

[Service]
Type=notify
ExecStart=/usr/bin/cri-dockerd --network-plugin=cni --pod-infra-container-image=registry.aliyuncs.com/google_containers/pause:3.7
ExecReload=/bin/kill -s HUP $MAINPID
TimeoutSec=0
RestartSec=2
Restart=always

[Install]
WantedBy=multi-user.target
EOF

3.启动并设置开机自启。

systemctl daemon-reload
systemctl start cri-docker
systemctl enable cri-docker

在这里插入图片描述

8.3 拷贝etcd文件

1.master2节点上操作，创建etcd证书目录。

mkdir -p /opt/etcd/ssl

2.master1节点上操作，将所有K8s文件和etcd证书传到master2节点。

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

3.master2节点上操作，删除kubelet证书和kubeconfig文件。

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

8.4 修改配置文件IP和主机名

1.master2节点上操作，修改apiserver、kubelet和kube-proxy配置文件为master2节点IP。

vim /opt/kubernetes/cfg/kube-apiserver.conf 
--bind-address=192.168.130.148 \
--advertise-address=192.168.130.148 \

---
vim /opt/kubernetes/cfg/kube-controller-manager.kubeconfig
server: https://192.168.130.148:6443

---
vim /opt/kubernetes/cfg/kube-scheduler.kubeconfig
server: https://192.168.130.148:6443

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

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

---
vim ~/.kube/config
server: https://192.168.130.148:6443

8.5 启动服务设置开机自启

1.master2节点操作。

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

2.查看集群组件状态。
在这里插入图片描述

8.6 批准kubelet证书申请

1.master1节点上操作，查看证书请求。

kubectl get csr
kubectl certificate approve 【csr名称】

在这里插入图片描述
2.查看节点状态。

8.7 部署nginx+keepalived

我这里是把master1做主节点，master2做备节点。

8.7.1 安装服务

主备节点都执行。

 yum install epel-release -y
 yum install nginx keepalived -y
 yum -y install nginx-all-modules.noarch # 依赖模块，不然nginx会启动失败。

8.7.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 192.168.130.145:6443;   # Master1 APISERVER IP:PORT
       server 192.168.130.148: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;
}
EOF

8.7.3 配置keepalived配置文件（主）

1.修改配置文件，添加VIP。

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 {     #指定检查nginx工作状态脚本（根据nginx状态判断是否故障转移）
    script "/etc/keepalived/check_nginx.sh"
}

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

2.准备配置文件中检查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

8.7.4 配置keepalived配置文件（备）

1.修改配置文件，添加VIP。

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

2.准备配置文件中检查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

8.7.5 启动并设置开机自启

主备节点都执行。

1.启动服务。

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

2.查看VIP。
在这里插入图片描述

8.7.6 测试高可用性和负载均衡

1.杀掉VIP所在节点的nginx服务，查看VIP是否会转移到另外一台机器。若转移成功，则说明已实现高可用。
在这里插入图片描述
2.集群任意节点，使用VIP访问集群，查看是否能返回数据。若能返回信息，则说明负载均衡已实现。

3.请求数据流程为：curl ——> vip(nginx) ——> apiserver。

8.7.7 修改所有Node连接VIP

因为我们是从单Master架构扩容的，也就是说目前所有的Worker Node组件连接都还是master1，若不改为连接VIP走负载均衡器，那么master还是单点故障。

1.查看所有节点，所有节点执行替换VIP命令。

sed -i 's#192.168.130.145:6443#192.168.130.151:16443#' /opt/kubernetes/cfg/*

2.重启服务，检查节点状态。

systemctl restart kubelet kube-proxy

在这里插入图片描述

K8s进阶2——二进制搭建K8s高可用集群

文章目录

一、单master资源清单

二、系统初始化

三、部署etcd集群

3.1 生成etcd证书

3.2 部署流程

3.2.1 准备二进制安装文件

3.2.2 创建工作目录

3.2.3 创建etcd配置文件

3.2.4 设置成systemd服务

3.2.5 添加etcd-2和etcd-3节点

3.2.6 所有节点启动etcd并设置开机启动

四、安装容器引擎（docker）

4.1 二进制安装

4.2 设置成systemd服务

4.3 创建配置文件

4.4 启动并设置开机启动

4.5 安装cri-dockerd

五、部署Master节点组件

5.1 生成kube-apiserver证书

5.2 准备安装文件

5.3 部署kube-apiserver

5.3.1 创建配置文件

5.3.2 启用 TLS Bootstrapping 机制

5.3.3 设置成systemd服务

5.3.4 启动并设置开机自启

5.4 部署kube-controller-manager

5.4.1 创建配置文件

5.4.2 生成kubeconfig文件

5.4.3 设置成systemd服务

5.4.4 启动并设置开机自启

5.5 部署kube-scheduler

5.5.1 创建配置文件

5.5.2 生成kubeconfig文件

5.5.3 设置成systemd服务

5.5.4 启动并设置开机自启

5.6 kubectl命令和用户授权

六、Node节点加入集群

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

6.2 部署kubelet

6.3 部署kube-proxy

6.4 部署网络组件

6.5 授权apiserver访问kubelet

6.6 新增node节点

七、部署Dashboard和Coredns

7.1 部署Dashboard

7.2 部署Coredns

八、高可用架构

8.1 多master资源清单

8.2 安装Docker

8.2 安装cri-docker

8.3 拷贝etcd文件

8.4 修改配置文件IP和主机名

8.5 启动服务设置开机自启

8.6 批准kubelet证书申请

8.7 部署nginx+keepalived

8.7.1 安装服务

8.7.2 配置nginx配置文件

8.7.3 配置keepalived配置文件（主）

8.7.4 配置keepalived配置文件（备）

8.7.5 启动并设置开机自启

8.7.6 测试高可用性和负载均衡

8.7.7 修改所有Node连接VIP

相关文章