云原生架构之【Kubernetes（K8s）】第三部分：多主控高

2020-09-02 本文已影响0人张毅SOHO

本方案基于 CentOS8 系统设计，建议在 RedHat/CentOS 系统中使用。

1.部署拓扑图
2.操作系统初始化
3.证书服务器的安装和配置
4.Etcd 数据库集群部署
5.Master 主控集群部署
-- 5.1.第一个 Master 主控节点部署
-- 5.2.其他 Master 主控节点部署
6.Master 高可用集群部署
-- 6.1.Nginx 安装和配置
-- 6.2.Keepalived 安装和配置
7.Node 工作集群部署
8.CNI 容器网络（Flannel 插件）部署
9.DNS 域名发现（CoreDNS 插件）部署
10.用户管理界面（Dashboard 插件）部署

1.部署拓扑图

K8s Master 高可用集群拓扑图

网络资源规划：

1、Master 主控节点

节点名	主机名	IP 地址	程序	操作系统
主控节点-1	k8s-master1	192.168.0.21	kube-apiserver，kube-controllermanager，kube-scheduler	CentOS8
主控节点-2	k8s-master2	192.168.0.22	kube-apiserver，kube-controllermanager，kube-scheduler	CentOS8
主控节点≥3	k8s-master3	192.168.0.23	kube-apiserver，kube-controllermanager，kube-scheduler	CentOS8

2、Master 高可用节点

节点名	主机名	IP:PORT	程序	操作系统
高可用节点-1	k8s-proxy1	192.168.0.11	Nginx，Keepalived	CentOS8
高可用节点≥2	k8s-proxy2	192.168.0.12	Nginx，Keepalived	CentOS8

Keepalived Virtual IP：192.168.0.10。

3、Node 工作节点

节点名	主机名	IP 地址	程序	操作系统
工作节点-1	k8s-node1	192.168.0.31	kubelet，kube-proxy，docker	CentOS8
工作节点-2	k8s-node2	192.168.0.32	kubelet，kube-proxy，docker	CentOS8
工作节点≥3	k8s-node3	192.168.0.33	kubelet，kube-proxy，docker	CentOS8

4、Etcd 节点

节点名	主机名	IP 地址	程序	操作系统
Etcd 节点-1	k8s-etcd1	192.168.0.41	etcd	CentOS8
Etcd 节点-2	k8s-etcd2	192.168.0.42	etcd	CentOS8
Etcd 节点≥3	k8s-etcd3	192.168.0.43	etcd	CentOS8

5、SSL 证书服务器

主机名：k8s-ssl
IP：192.168.0.50
程序：CFSSL，OpenSSL
操作系统：CentOS8

6、K8s 集群网络

Service 子网 IP 段：10.0.0.0/16。用于为 Pod 中发布的服务自动分配 IP 地址。
CNI 子网 IP 段：10.254.0.0/16。用于为 Pod 中部署的容器自动分配 IP 地址。

2.操作系统初始化

以 "主控节点" 为例，初始化各个主控节点、主控高可用节点、工作节点、Etcd 节点的操作系统配置（主控高可用节点跳过第 3 步和第 7 步）：

1、关闭防火墙。

[centos@k8s-master1 ~]$ sudo systemctl stop firewalld.service
[centos@k8s-master1 ~]$ sudo systemctl disable firewalld.service

2、关闭 SELinux。

1）临时关闭 SELinux。

[centos@k8s-master1 ~]$ sudo setenforce 0

2）修改 SELinux 配置文件，永久关闭 SELinux。

使用文本编辑器打开"/etc/selinux/config"文件：

[centos@k8s-master1 ~]$ sudo gedit /etc/selinux/config

将 "SELINUX" 参数设置为："disabled"，并保存：

# enforcing - 表示启用 SELinux 安全策略。
# permissive - 表示启用 SELinux 安全策略，但不强制验证。如果执行第一步可以正常运行，则建议设置此值。
# disabled - 关闭 SELinux 安全策略，相当于没有安装 SELinux。
SELINUX=disabled

3、关闭 Swap（虚拟内存）。

1）临时关闭 Swap。

[centos@k8s-master1 ~]$ sudo swapoff -a

2）修改挂载配置文件，永久关闭 Swap。

使用文本编辑器打开"/etc/fstab"文件：

[centos@k8s-master1 ~]$ sudo gedit /etc/fstab

注释掉 Swap 的挂载配置，并保存：

# UUID=0b0d1b60-ff0c-450b-b842-e9e2669839b1 swap                    swap    defaults        0 0

4、设置各节点的系统的时区和时间保持一致，可以通过时间服务器同步，也可以手动设置。

1）设置时区为 "中国上海"：

[centos@k8s-master1 ~]$ sudo timedatectl set-timezone Asia/Shanghai

2）设置时间同步配置：

使用文本编辑器打开"/etc/chrony.conf"文件：

[centos@k8s-master1 ~]$ sudo gedit /etc/chrony.conf

验证或修改以下配置并保存：

# 其中【2.centos.pool.ntp.org】是时间服务器地址
pool 2.centos.pool.ntp.org iburst

5、设置主机名。

1）临时设置主机名。

[centos@k8s-master1 ~]$ sudo hostnamectl set-hostname k8s-master1 && bash

2）修改主机名配置文件，永久配置主机名。

使用文本编辑器打开"/etc/hostname"文件：

[centos@k8s-master1 ~]$ sudo gedit /etc/hostname

修改主机名并保存：

k8s-master1

6、设置静态 IP 地址。

设置静态 IP 地址

7、设置本地 DNS 配置，将 IP 地址和主机名进行映射。

使用文本编辑器打开"/etc/hosts"文件：

[centos@k8s-master1 ~]$ sudo gedit /etc/hosts

在文件中追加各个节点的 IP 和 hostname 映射记录并保存：

192.168.0.11 k8s-proxy1
192.168.0.12 k8s-proxy2
192.168.0.21 k8s-master1
192.168.0.22 k8s-master2
192.168.0.23 k8s-master3
192.168.0.31 k8s-node1
192.168.0.32 k8s-node2
192.168.0.33 k8s-node3
192.168.0.41 k8s-etcd1
192.168.0.42 k8s-etcd2
192.168.0.43 k8s-etcd3

8、重启操作系统，永久适配以上配置。

[centos@k8s-master1 ~]$ sudo reboot

3.证书服务器的安装和配置

Etcd 和 API Server 通过 Https 协议提供接口，因此在部署 Etcd 和 API Server 时需要使用 SSL 证书，CFSSL 是一款开源的证书管理工具，它使用 JSON 文件描述证书的元数据，并通过命令行创建自签名证书。

证书管理工具的安装以及证书颁发、管理可以在任意主机上实施，Etcd 和 API Server 只使用最终它创建的私钥和证书文件。“主机”可以是集群中的任意节点或者集群外的专用证书管理服务器均可。

以在 "SSL 证书服务器" 上安装证书工具及实施证书颁发、管理为例：

1、打开 CFSSL 下载页面【https://pkg.cfssl.org/】，下载最新版本的 cfssl、cfssljson 和 cfssl-certinfo 的编译程序文件到用户主目录中。

CFSSL 下载页面

cfssl：用于创建证书；
cfssljson：用于通过 JSON 元数据文件创建证书；
cfssl-certinfo：用于查看证书内容。

2、为 CFSSL 的程序文件增加可执行权限。

[centos@k8s-ssl ~]$ chmod +x cfssl_linux-amd64 cfssljson_linux-amd64 cfssl-certinfo_linux-amd64

3、将 CFSSL 的程序文件迁移安装到操作系统默认的 shell 目录中并重命名。

[centos@k8s-ssl ~]$ sudo mv cfssl_linux-amd64 /usr/bin/cfssl
[centos@k8s-ssl ~]$ sudo mv cfssljson_linux-amd64 /usr/bin/cfssljson
[centos@k8s-ssl ~]$ sudo mv cfssl-certinfo_linux-amd64 /usr/bin/cfssl-certinfo

4、验证程序。

[centos@k8s-ssl ~]$ cfssl

5、创建 SSL 工作目录，更改所有者账号。

[centos@k8s-ssl ~]$ sudo mkdir -p /data/ssl
[centos@k8s-ssl ~]$ sudo chown -R centos:centos /data/ssl

6、制作 K8s 的 CA 根证书。

1）创建 K8s 的 CA 根证书目录：

[centos@k8s-ssl ~]$ mkdir -p /data/ssl/k8s/ca

2）创建 K8s 的 CA 根证书 的 JSON 配置文件：

使用文本编辑器创建 "/data/ssl/k8s/ca/ca-config.json" 文件：

[centos@k8s-ssl ~]$ gedit /data/ssl/k8s/ca/ca-config.json

编辑配置内容并保存（删除注释）：

{
  "signing": {
    # 通用策略。
    "default": {
      # 表示过期时间，【h】 表示时间单位为 【小时】。
      "expiry": "87600h"
    },
    "profiles": {
      # 表示该配置的用途是为 kubernetes 生成证书及相关的认证工作 。
      "k8s": {
        # 表示 kubernetes 配置的过期时间。
        "expiry": "87600h",
        "usages": [
          # 表示该证书可用于签名其它证书，也就是 CA 根证书。
          "signing",
          "key encipherment",
          # 表示可以该 CA 对 Server 提供的证书进行认证。
          "server auth",
          # 表示可以该 CA 对 Client 提供的证书进行认证。
          "client auth"
        ]
      }
    }
  }
}

3）创建 K8s 的 CA 根证书申请 的 JSON 配置文件：

使用文本编辑器创建 "/data/ssl/k8s/ca/ca-csr.json" 文件：

[centos@k8s-ssl ~]$ gedit /data/ssl/k8s/ca/ca-csr.json

编辑配置内容并保存（删除注释）：

{
  # 证书名称
  "CN": "ca",
  # 证书加密算法
  "key": {
    # 秘钥算法
    "algo": "rsa",
    # 秘钥长度
    "size": 2048
  },
  # 证书颁发机构名称
  "names": [
    {
      # 国家名称
      "C": "cn",
      # 省份名称
      "ST": "sd",
      # 城市名称
      "L": "qd",
      # 组织机构名称
      "O": "private",
      # 组织单元名称
      "OU": "zhangyi"
    }
  ]
}

4）进入 CA 根证书目录，生成 K8s 的 CA 根证书 和 CA 秘钥：

[centos@k8s-ssl ~]$ cd /data/ssl/k8s/ca
[centos@k8s-ssl ca]$ cfssl gencert -initca ca-csr.json | cfssljson -bare ca -

2020/08/17 15:28:59 [INFO] generating a new CA key and certificate from CSR
2020/08/17 15:28:59 [INFO] generate received request
2020/08/17 15:28:59 [INFO] received CSR
2020/08/17 15:28:59 [INFO] generating key: rsa-2048
2020/08/17 15:28:59 [INFO] encoded CSR
2020/08/17 15:28:59 [INFO] signed certificate with serial number 116577353254406726865056466732539458431685116104

[centos@k8s-ssl ca]$ ll *.pem
-rw------- 1 centos centos 1675 8月  17 15:28 ca-key.pem
-rw-rw-r-- 1 centos centos 1346 8月  17 15:28 ca.pem

7、制作 K8s 的 Etcd 证书。

1）创建 K8s 的 Etcd 证书目录：

[centos@k8s-ssl ~]$ mkdir -p /data/ssl/k8s/etcd

2）创建 K8s 的 Etcd 证书申请 的 JSON 配置文件：

使用文本编辑器创建 "/data/ssl/k8s/etcd/etcd-csr.json" 文件：

[centos@k8s-ssl ~]$ gedit /data/ssl/k8s/etcd/etcd-csr.json

编辑配置内容并保存（删除注释）：

{
  # 证书名称
  "CN": "etcd",
  # Etcd 集群中所有节点的 IP 或 DNS
  "hosts": [
    "127.0.0.1",
    "192.168.0.41",
    "192.168.0.42",
    "192.168.0.43",
    "localhost"
  ],
  # 证书加密算法
  "key": {
    # 秘钥算法
    "algo": "rsa",
    # 秘钥长度
    "size": 2048
  },
  "names": [
    {
      # 国家名称
      "C": "cn",
      # 省份名称
      "ST": "sd",
      # 城市名称
      "L": "qd",
      # 组织机构名称
      "O": "private",
      # 组织单元名称
      "OU": "zhangyi"
    }
  ]
}

3）进入 Etcd 证书目录，调用 CA 根证书，生成 K8s 的 Etcd 证书 和 Etcd 证书秘钥：

[centos@k8s-ssl ~]$ cd /data/ssl/k8s/etcd
[centos@k8s-ssl etcd]$ cfssl gencert -ca=../ca/ca.pem -ca-key=../ca/ca-key.pem -config=../ca/ca-config.json -profile=k8s etcd-csr.json | cfssljson -bare etcd

2020/08/17 16:07:20 [INFO] generate received request
2020/08/17 16:07:20 [INFO] received CSR
2020/08/17 16:07:20 [INFO] generating key: rsa-2048
2020/08/17 16:07:20 [INFO] encoded CSR
2020/08/17 16:07:20 [INFO] signed certificate with serial number 245573148699245996773294161637542724002482924968
2020/08/17 16:07:20 [WARNING] This certificate lacks a "hosts" field. This makes it unsuitable for
websites. For more information see the Baseline Requirements for the Issuance and Management
of Publicly-Trusted Certificates, v.1.1.6, from the CA/Browser Forum (https://cabforum.org);
specifically, section 10.2.3 ("Information Requirements").

[centos@k8s-ssl etcd]$ ll *.pem
-rw------- 1 centos centos 1675 8月  17 16:07 etcd-key.pem
-rw-rw-r-- 1 centos centos 1428 8月  17 16:07 etcd.pem

8、制作 K8s 的 Server 证书。

1）创建 K8s 的 Server 证书目录：

[centos@k8s-ssl ~]$ mkdir -p /data/ssl/k8s/server

2）创建 K8s 的 Server 证书申请 的 JSON 配置文件：

使用文本编辑器创建 "/data/ssl/k8s/server/server-csr.json" 文件：

[centos@k8s-ssl ~]$ gedit /data/ssl/k8s/server/server-csr.json

编辑配置内容并保存（删除注释）：

{
  # 证书名称，同时也是 K8s Server 的 API Server、Controller Manager 的服务端账号。
  "CN": "kubernetes",
  # 包含所有 Master 节点的 IP 和 DNS，以及 Master 高可用节点的 IP 和 Virtual IP（设置为空或不设置该属性时不会对域名进行限制，但是降低了安全性）。
  "hosts": [
    "127.0.0.1",
    "10.0.0.1",
    "192.168.0.21",
    "192.168.0.22",
    "192.168.0.23",
    "192.168.0.11",
    "192.168.0.12",
    "192.168.0.10",
    "localhost",
    "kubernetes",
    "kubernetes.default",
    "kubernetes.default.svc",
    "kubernetes.default.svc.cluster",
    "kubernetes.default.svc.cluster.local"
  ],
  # 证书加密算法
  "key": {
    # 秘钥算法
    "algo": "rsa",
    # 秘钥长度
    "size": 2048
  },
  "names": [
    {
      # 国家名称
      "C": "cn",
      # 省份名称
      "ST": "sd",
      # 城市名称
      "L": "qd",
      # 组织机构名称
      "O": "private",
      # 组织单元名称
      "OU": "zhangyi"
    }
  ]
}

3）进入 Server 证书目录，调用 CA 根证书，生成 K8s 的 Server 证书 和 Server 证书秘钥：

[centos@k8s-ssl ~]$ cd /data/ssl/k8s/server
[centos@k8s-ssl server]$ cfssl gencert -ca=../ca/ca.pem -ca-key=../ca/ca-key.pem -config=../ca/ca-config.json -profile=k8s server-csr.json | cfssljson -bare server

2020/08/17 16:18:33 [INFO] generate received request
2020/08/17 16:18:33 [INFO] received CSR
2020/08/17 16:18:33 [INFO] generating key: rsa-2048
2020/08/17 16:18:33 [INFO] encoded CSR
2020/08/17 16:18:33 [INFO] signed certificate with serial number 436972371201156087194456890942017146190769381451
2020/08/17 16:18:33 [WARNING] This certificate lacks a "hosts" field. This makes it unsuitable for
websites. For more information see the Baseline Requirements for the Issuance and Management
of Publicly-Trusted Certificates, v.1.1.6, from the CA/Browser Forum (https://cabforum.org);
specifically, section 10.2.3 ("Information Requirements").

[centos@k8s-ssl server]$ ll *.pem
-rw------- 1 centos centos 1675 8月  17 16:18 server-key.pem
-rw-rw-r-- 1 centos centos 1419 8月  17 16:18 server.pem

9、制作 K8s 的 Proxy 客户端证书（用于 K8s 内置的 Proxy 客户端账号 system:kube-proxy 访问 API Server）。

1）创建 K8s 的 Proxy 证书目录：

[centos@k8s-ssl ~]$ mkdir -p /data/ssl/k8s/proxy

2）创建 K8s 的 Proxy 证书申请 的 JSON 配置文件：

使用文本编辑器创建 "/data/ssl/k8s/proxy/proxy-csr.json" 文件：

[centos@k8s-ssl ~]$ gedit /data/ssl/k8s/proxy/proxy-csr.json

编辑配置内容并保存（删除注释）：

{
  # 证书名称，同时也是 K8s 内置的 Proxy 客户端账号。
  "CN": "system:kube-proxy",
  "hosts": [],
  # 证书加密算法
  "key": {
    # 秘钥算法
    "algo": "rsa",
    # 秘钥长度
    "size": 2048
  },
  "names": [
    {
      # 国家名称
      "C": "cn",
      # 省份名称
      "ST": "sd",
      # 城市名称
      "L": "qd",
      # 组织机构名称
      "O": "private",
      # 组织单元名称
      "OU": "zhangyi"
    }
  ]
}

3）进入 Proxy 证书目录，调用 CA 根证书，生成 K8s 的 Proxy 证书 和 Proxy 证书秘钥：

[centos@k8s-ssl ~]$ cd /data/ssl/k8s/proxy
[centos@k8s-ssl proxy]$ cfssl gencert -ca=../ca/ca.pem -ca-key=../ca/ca-key.pem -config=../ca/ca-config.json -profile=k8s proxy-csr.json | cfssljson -bare proxy

2020/08/20 10:52:03 [INFO] generate received request
2020/08/20 10:52:03 [INFO] received CSR
2020/08/20 10:52:03 [INFO] generating key: rsa-2048
2020/08/20 10:52:03 [INFO] encoded CSR
2020/08/20 10:52:03 [INFO] signed certificate with serial number 438353289881924064412254168935174700007379178723
2020/08/20 10:52:03 [WARNING] This certificate lacks a "hosts" field. This makes it unsuitable for
websites. For more information see the Baseline Requirements for the Issuance and Management
of Publicly-Trusted Certificates, v.1.1.6, from the CA/Browser Forum (https://cabforum.org);
specifically, section 10.2.3 ("Information Requirements").

[centos@k8s-ssl proxy]$ ll *.pem
-rw------- 1 centos centos 1679 8月  20 10:52 proxy-key.pem
-rw-rw-r-- 1 centos centos 1387 8月  20 10:52 proxy.pem

4.Etcd 数据库集群部署

Etcd 是一个分布式键值存储系统，K8s 使用 Etcd 进行数据存储。为避免 Etcd 单点故障，建议采用集群方式部署，集群中 Etcd 节点的数量以 ≥ 3 个的单数为宜。

以 "Etcd 节点-1" 为例，所有 "Etcd 节点" 都需实施以下操作：

1、打开 Etcd 下载页面【https://github.com/etcd-io/etcd/releases】，下载最新版本 Etcd 的编译程序 tar 包到用户主目录中。

Etcd 下载页面

2、解压缩编译程序 tar 包到"/usr/local"目录中。

[centos@k8s-etcd1 ~]$ sudo tar zxvf etcd-v3.4.10-linux-amd64.tar.gz -C /usr/local
[centos@k8s-etcd1 ~]$ sudo mv /usr/local/etcd-v3.4.10-linux-amd64 /usr/local/etcd-v3.4.10
[centos@k8s-etcd1 ~]$ sudo chown -R root:root /usr/local/etcd-v3.4.10
[centos@k8s-etcd1 ~]$ ll /usr/local
drwxr-xr-x  3 root root 123 7月  17 06:43 etcd-v3.4.10

3、创建 Etcd 数据目录并设置权限，Etcd 在启动时会检查数据目录权限，数据目录权限必须设置为 "rwx------"。

[centos@k8s-etcd1 ~]$ sudo mkdir -p /data/etcd
[centos@k8s-etcd1 ~]$ sudo chmod 700 /data/etcd

4、创建 Etcd 秘钥目录，并从 SSL 证书服务器上获取已创建的 CA 根证书，Etcd 证书和 Etcd 证书秘钥。

1）创建 Etcd 秘钥目录：

[centos@k8s-etcd1 ~]$ sudo mkdir -p /usr/local/etcd-v3.4.10/ssl

2）使用 ssh 远程登录到 SSL 证书服务器，并将 SSL 证书服务器上已制作好的 CA 根证书，Etcd 证书和 Etcd 证书秘钥通过 scp 拷贝到 "Etcd 节点-1"（当前主机）的 Etcd 秘钥目录中：

[centos@k8s-etcd1 ~]$ ssh centos@192.168.0.50
centos@192.168.0.50's password:
[centos@k8s-ssl ~]$ scp -r /data/ssl/k8s/ca/ca.pem root@192.168.0.41:/usr/local/etcd-v3.4.10/ssl
root@192.168.0.41's password:
ca.pem                                                                              100% 1346     1.7MB/s   00:00
[centos@k8s-ssl ~]$ scp -r /data/ssl/k8s/etcd/etcd.pem root@192.168.0.41:/usr/local/etcd-v3.4.10/ssl
root@192.168.0.41's password:
etcd.pem                                                                            100% 1428    43.5KB/s   00:00
[centos@k8s-ssl ~]$ scp -r /data/ssl/k8s/etcd/etcd-key.pem root@192.168.0.41:/usr/local/etcd-v3.4.10/ssl
root@192.168.0.41's password:
etcd-key.pem                                                                        100% 1675     1.6MB/s   00:00
[centos@k8s-ssl ~]$ exit

[centos@k8s-etcd1 ~]$ sudo chmod 644 /usr/local/etcd-v3.4.10/ssl/*
[centos@k8s-etcd1 ~]$ ll /usr/local/etcd-v3.4.10/ssl
-rw-r--r-- 1 root root 1346 8月  18 11:27 ca.pem
-rw-r--r-- 1 root root 1675 8月  18 11:30 etcd-key.pem
-rw-r--r-- 1 root root 1428 8月  18 11:29 etcd.pem

5、创建并编辑 Etcd 启动参数配置文件。

使用文本编辑器创建 "/usr/local/etcd-v3.4.10/etcd.conf" 文件：

[centos@k8s-etcd1 ~]$ sudo gedit /usr/local/etcd-v3.4.10/etcd.conf

编辑配置内容并保存（删除注释）：

# 节点配置
# 节点的名称，同一集群中节点名称是唯一的。
NAME="etcd-1"
# 节点的数据目录。
DATA_DIR="/data/etcd"
# 节点的内部通信监听地址清单（逗号分隔），用于集群内部通信。
LISTEN_PEER_URLS="https://0.0.0.0:2380"
# 节点的客户端服务监听地址清单（逗号分隔），用于对外提供数据服务。
LISTEN_CLIENT_URLS="https://0.0.0.0:2379"

# 集群配置
# 为集群中其他节点提供的，用于和本节点进行内部通信的地址清单（逗号分隔），一般是当前节点的内部通信监听地址。
INITIAL_ADVERTISE_PEER_URLS="https://192.168.0.41:2380"
# 为集群中其他节点提供的，用于访问本节点数据服务的地址清单（逗号分隔），一般是当前节点的客户端服务监听地址。
ADVERTISE_CLIENT_URLS="https://192.168.0.41:2379"
# 集群中所有节点的内部通信监听地址清单（逗号分隔）。
INITIAL_CLUSTER="etcd-1=https://192.168.0.41:2380,etcd-2=https://192.168.0.42:2380,etcd-3=https://192.168.0.43:2380"
# 集群标识符，用于区分不同的集群，同一集群的节点应设置相同的值。
INITIAL_CLUSTER_TOKEN="etcd-cluster"
# 用于指示本次是否为新建集群。可选值包括：new 和 existing 。设置为 existing 则该节点启动时会尝试与其他节点交互。集群初次建立时应设置为 new；集群运行中当节点故障后进行恢复时设置为 existing 或者 new。
INITIAL_CLUSTER_STATE="new"

6、配置 Etcd 服务并设置开机自启动。

使用文本编辑器创建配置文件：

[centos@k8s-etcd1 ~]$ sudo gedit /usr/lib/systemd/system/etcd.service

编写文件内容并保存如下：

[Unit]
Description=Etcd Server
After=network.target
After=network-online.target
Wants=network-online.target

[Service]
Type=notify
User=root
Group=root
EnvironmentFile=-/usr/local/etcd-v3.4.10/etcd.conf
ExecStart=/usr/local/etcd-v3.4.10/etcd \
          --name=${NAME} \
          --data-dir=${DATA_DIR} \
          --listen-peer-urls=${LISTEN_PEER_URLS} \
          --listen-client-urls=${LISTEN_CLIENT_URLS} \
          --initial-advertise-peer-urls=${INITIAL_ADVERTISE_PEER_URLS} \
          --advertise-client-urls=${ADVERTISE_CLIENT_URLS} \
          --initial-cluster=${INITIAL_CLUSTER} \
          --initial-cluster-token=${INITIAL_CLUSTER_TOKEN} \
          --initial-cluster-state=${INITIAL_CLUSTER_STATE} \
          # 用于客户端请求的证书文件
          --cert-file=/usr/local/etcd-v3.4.10/ssl/etcd.pem \
          # 用于客户端请求的秘钥文件
          --key-file=/usr/local/etcd-v3.4.10/ssl/etcd-key.pem \
          # 用于客户端请求的受信任的 CA 证书文件
          --trusted-ca-file=/usr/local/etcd-v3.4.10/ssl/ca.pem \
          # 用于内部通信请求的证书文件
          --peer-cert-file=/usr/local/etcd-v3.4.10/ssl/etcd.pem \
          # 用于内部通信请求的秘钥文件
          --peer-key-file=/usr/local/etcd-v3.4.10/ssl/etcd-key.pem \
          # 用于内部通信请求的受信任的 CA 证书文件
          --peer-trusted-ca-file=/usr/local/etcd-v3.4.10/ssl/ca.pem \
          --logger=zap
Restart=on-failure
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target

设置开机启动：

[centos@k8s-etcd1 ~]$ sudo systemctl daemon-reload
[centos@k8s-etcd1 ~]$ sudo systemctl enable etcd.service

注意：其他"Etcd 节点"上全部需要按照以上步骤配置。

7、依次启动各 Etcd 节点的 Etcd 服务。Etcd 集群至少需要两个以上节点正常启动才能运行，因此第一个 Etcd 节点启动时会处于挂起等待状态，挂起状态会在第二个 Etcd 节点启动后恢复，或者在长时间未发现第二个 Etcd 节点时超时退出。

[centos@k8s-etcd1 ~]$ sudo systemctl start etcd.service
[centos@k8s-etcd1 ~]$ sudo systemctl status etcd.service

8、在任意 Etcd 节点上查看 Etcd 集群健康。

[centos@k8s-etcd1 ~]$ ETCDCTL_API=3 
[centos@k8s-etcd1 ~]$ /usr/local/etcd-v3.4.10/etcdctl --cacert=/usr/local/etcd-v3.4.10/ssl/ca.pem --cert=/usr/local/etcd-v3.4.10/ssl/etcd.pem --key=/usr/local/etcd-v3.4.10/ssl/etcd-key.pem --endpoints="https://192.168.0.41:2379,https://192.168.0.42:2379,https://192.168.0.43:2379" endpoint health --write-out=table

+---------------------------+--------+-------------+-------+
|         ENDPOINT          | HEALTH |    TOOK     | ERROR |
+---------------------------+--------+-------------+-------+
| https://192.168.0.41:2379 |   true | 13.851824ms |       |
| https://192.168.0.42:2379 |   true | 14.336573ms |       |
| https://192.168.0.43:2379 |   true | 23.145602ms |       |
+---------------------------+--------+-------------+-------+

9、Etcd 集群运维。

1）查看集群节点健康：

[centos@k8s-etcd1 ~]$ ETCDCTL_API=3 
[centos@k8s-etcd1 ~]$ /usr/local/etcd-v3.4.10/etcdctl --cacert=/usr/local/etcd-v3.4.10/ssl/ca.pem --cert=/usr/local/etcd-v3.4.10/ssl/etcd.pem --key=/usr/local/etcd-v3.4.10/ssl/etcd-key.pem --endpoints="https://192.168.0.41:2379,https://192.168.0.42:2379,https://192.168.0.43:2379" endpoint health --write-out=table

+---------------------------+--------+-------------+-------+
|         ENDPOINT          | HEALTH |    TOOK     | ERROR |
+---------------------------+--------+-------------+-------+
| https://192.168.0.41:2379 |   true | 13.851824ms |       |
| https://192.168.0.42:2379 |   true | 14.336573ms |       |
| https://192.168.0.43:2379 |   true | 23.145602ms |       |
+---------------------------+--------+-------------+-------+

2）查看集节点群状态：

[centos@k8s-etcd1 ~]$ ETCDCTL_API=3 
[centos@k8s-etcd1 ~]$ /usr/local/etcd-v3.4.10/etcdctl --cacert=/usr/local/etcd-v3.4.10/ssl/ca.pem --cert=/usr/local/etcd-v3.4.10/ssl/etcd.pem --key=/usr/local/etcd-v3.4.10/ssl/etcd-key.pem --endpoints="https://192.168.0.41:2379,https://192.168.0.42:2379,https://192.168.0.43:2379" endpoint status --write-out=table

+---------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+
|         ENDPOINT          |        ID        | VERSION | DB SIZE | IS LEADER | IS LEARNER | RAFT TERM | RAFT INDEX | RAFT APPLIED INDEX | ERRORS |
+---------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+
| https://192.168.0.41:2379 | 97feb1a73a325656 |  3.4.10 |  651 kB |      true |      false |         7 |        867 |                867 |        |
| https://192.168.0.42:2379 | fa4ddfec63d549fc |  3.4.10 |  655 kB |     false |      false |         7 |        867 |                867 |        |
| https://192.168.0.43:2379 | ec67af24a94fb07c |  3.4.10 |  668 kB |     false |      false |         7 |        867 |                867 |        |
+---------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+

3）查看集节点成员清单：

[centos@k8s-etcd1 ~]$ ETCDCTL_API=3 
[centos@k8s-etcd1 ~]$ /usr/local/etcd-v3.4.10/etcdctl --cacert=/usr/local/etcd-v3.4.10/ssl/ca.pem --cert=/usr/local/etcd-v3.4.10/ssl/etcd.pem --key=/usr/local/etcd-v3.4.10/ssl/etcd-key.pem --endpoints="https://192.168.0.41:2379,https://192.168.0.42:2379,https://192.168.0.43:2379" member list --write-out=table

+------------------+---------+--------+---------------------------+---------------------------+------------+
|        ID        | STATUS  |  NAME  |        PEER ADDRS         |       CLIENT ADDRS        | IS LEARNER |
+------------------+---------+--------+---------------------------+---------------------------+------------+
| 97feb1a73a325656 | started | etcd-1 | https://192.168.0.41:2380 | https://192.168.0.41:2379 |      false |
| ec67af24a94fb07c | started | etcd-3 | https://192.168.0.42:2380 | https://192.168.0.42:2379 |      false |
| fa4ddfec63d549fc | started | etcd-2 | https://192.168.0.43:2380 | https://192.168.0.43:2379 |      false |
+------------------+---------+--------+---------------------------+---------------------------+------------+

4）移除一个节点成员：

[centos@k8s-etcd1 ~]$ ETCDCTL_API=3 
[centos@k8s-etcd1 ~]$ /usr/local/etcd-v3.4.10/etcdctl --cacert=/usr/local/etcd-v3.4.10/ssl/ca.pem --cert=/usr/local/etcd-v3.4.10/ssl/etcd.pem --key=/usr/local/etcd-v3.4.10/ssl/etcd-key.pem --endpoints="https://192.168.0.41:2379,https://192.168.0.42:2379,https://192.168.0.43:2379" member remove 97feb1a73a325656

Member 97feb1a73a325656 removed from cluster 8f957fc90dd9f6bc

5.Master 主控集群部署

5.1.第一个 Master 主控节点部署

在第一个 Master 主控节点上执行以下操作步骤，以 "k8s-master1" 为例：

1、打开 K8s 下载页面【https://github.com/kubernetes/kubernetes/releases】，下载最新版本 Kubernetes Server 的编译程序 tar 包到用户主目录中。

注意：Kubernetes Server 的 tar 包中包含了：Master 主控节点，Node 工作节点和客户端的全部程序。

第一步，点击链接进入编译程序下载页面

第二步，下载 Kubernetes Server 的 tar 包

2、解压缩编译程序 tar 包到"/usr/local"目录中，并为管理工具创建系统 Shell 目录的软链接。

1）解压缩编译程序 tar 包到"/usr/local"目录中：

[centos@k8s-master1 ~]$ sudo tar zxvf kubernetes-server-linux-amd64.tar.gz -C /usr/local
[centos@k8s-master1 ~]$ ll /usr/local
drwxr-xr-x  4 root root  79 8月  14 00:53 kubernetes

安装目录：/usr/local/kubernetes/server
可执行程序目录：/usr/local/kubernetes/server/bin

2）为管理工具创建系统 Shell 目录的软链接：

[centos@k8s-master1 ~]$ sudo ln -s /usr/local/kubernetes/server/bin/kubectl /usr/bin/kubectl

3、创建 K8s Server 日志目录、秘钥目录和配置文件目录。

[centos@k8s-master1 ~]$ sudo mkdir -p /usr/local/kubernetes/server/{logs,ssl,etc}

4、从 SSL 证书服务器上获取已创建的 CA 根证书，Server 证书和 Server 证书秘钥，Etcd 证书和 Etcd 证书秘钥。

使用 ssh 远程登录到 SSL 证书服务器，并将 SSL 证书服务器上已制作好的 CA 根证书，Server 证书和 Server 证书秘钥，Etcd 证书和 Etcd 证书秘钥通过 scp 拷贝到 "Master 主控节点"（当前主机）的 K8s Server 秘钥目录中：

[centos@k8s-master1 ~]$ ssh centos@192.168.0.50
centos@192.168.0.50's password:
[centos@k8s-ssl ~]$ scp -r /data/ssl/k8s/ca/ca.pem root@192.168.0.21:/usr/local/kubernetes/server/ssl
root@192.168.0.21's password:
ca.pem                                                                                        100% 1346     1.5MB/s   00:00
[centos@k8s-ssl ~]$ scp -r /data/ssl/k8s/ca/ca-key.pem root@192.168.0.21:/usr/local/kubernetes/server/ssl
root@192.168.0.21's password:
ca-key.pem                                                                                    100% 1675   850.9KB/s   00:00
[centos@k8s-ssl ~]$ scp -r /data/ssl/k8s/server/server.pem root@192.168.0.21:/usr/local/kubernetes/server/ssl
root@192.168.0.21's password:
server.pem                                                                                    100% 1419   510.0KB/s   00:00
[centos@k8s-ssl ~]$ scp -r /data/ssl/k8s/server/server-key.pem root@192.168.0.21:/usr/local/kubernetes/server/ssl
root@192.168.0.21's password:
server-key.pem                                                                                100% 1675     1.2MB/s   00:00
[centos@k8s-ssl ~]$ scp -r /data/ssl/k8s/etcd/etcd.pem root@192.168.0.21:/usr/local/kubernetes/server/ssl
root@192.168.0.21's password:
etcd.pem                                                                                      100% 1428     1.8MB/s   00:00
[centos@k8s-ssl ~]$ scp -r /data/ssl/k8s/etcd/etcd-key.pem root@192.168.0.21:/usr/local/kubernetes/server/ssl
root@192.168.0.21's password:
etcd-key.pem                                                                                  100% 1675     1.3MB/s   00:00
[centos@k8s-ssl ~]$ exit

[centos@k8s-master1 ~]$ sudo chmod 644 /usr/local/kubernetes/server/ssl/*
[centos@k8s-master1 ~]$ ll /usr/local/kubernetes/server/ssl
-rw-r--r-- 1 root root 1675 8月  19 09:58 server-key.pem
-rw-r--r-- 1 root root 1419 8月  19 09:58 server.pem
-rw-r--r-- 1 root root 1675 8月  19 10:43 ca-key.pem
-rw-r--r-- 1 root root 1346 8月  19 09:56 ca.pem
-rw-r--r-- 1 root root 1675 8月  19 10:02 etcd-key.pem
-rw-r--r-- 1 root root 1428 8月  19 10:02 etcd.pem

5、启用 TLS Bootstrapping 机制。

Master 节点的 API Server 启用 TLS 认证后，Node 节点上的 Kubelet 与 API Server 通信，需使用 CA 证书。当 Node 节点较多时，证书颁发工作量大且增加集群扩展复杂度，为此 K8s 引入了 TLS Bootstraping 机制，实现 Kubelet 以一个低权限用户自动向 API Server 申请证书，Kubelet 的证书由 API Server 动态签署。

在 Master 节点上创建 Token 文件，定义 Node 节点上 Kubelet 通过 Bootstrapping 机制申请证书的用户信息：

1）随机生成一个 Token 值：

[centos@k8s-master1 ~]$ head -c 16 /dev/urandom | od -An -t x | tr -d ' '
d682ded2c1468b8c6a16375b48a638ff

2）创建 Token 配置文件：

使用文本编辑器创建 "/usr/local/kubernetes/server/etc/token.csv" 文件：

[centos@k8s-master1 ~]$ sudo gedit /usr/local/kubernetes/server/etc/token.csv

编辑配置内容并保存：

d682ded2c1468b8c6a16375b48a638ff,kubelet-bootstrap,10001,"system:nodebootstrapper"

6、创建并编辑 API Server 启动参数配置文件。

使用文本编辑器创建 "/usr/local/kubernetes/server/etc/kube-apiserver.conf" 文件：

[centos@k8s-master1 ~]$ sudo gedit /usr/local/kubernetes/server/etc/kube-apiserver.conf

编辑配置内容并保存：

KUBE_APISERVER_OPTS="--logtostderr=false \
--v=2 \
--log-dir=/usr/local/kubernetes/server/logs \
--etcd-servers=https://192.168.0.41:2379,https://192.168.0.42:2379,https://192.168.0.43:2379 \
--bind-address=192.168.0.21 \
--insecure-port=8080 \
--secure-port=6443 \
--advertise-address=192.168.0.21 \
--allow-privileged=true \
--enable-admission-plugins=NamespaceLifecycle,LimitRanger,ServiceAccount,ResourceQuota,NodeRestriction \
--authorization-mode=RBAC,Node \
--enable-bootstrap-token-auth=true \
--token-auth-file=/usr/local/kubernetes/server/etc/token.csv \
--service-cluster-ip-range=10.0.0.0/16 \
--service-node-port-range=30000-32767 \
--service-account-key-file=/usr/local/kubernetes/server/ssl/ca-key.pem \
--tls-cert-file=/usr/local/kubernetes/server/ssl/server.pem  \
--tls-private-key-file=/usr/local/kubernetes/server/ssl/server-key.pem \
--client-ca-file=/usr/local/kubernetes/server/ssl/ca.pem \
--kubelet-client-certificate=/usr/local/kubernetes/server/ssl/server.pem \
--kubelet-client-key=/usr/local/kubernetes/server/ssl/server-key.pem \
--etcd-cafile=/usr/local/kubernetes/server/ssl/ca.pem \ 
--etcd-certfile=/usr/local/kubernetes/server/ssl/etcd.pem \
--etcd-keyfile=/usr/local/kubernetes/server/ssl/etcd-key.pem \
--audit-log-path=/usr/local/kubernetes/server/logs/k8s-audit.log"

参数说明：

--logtostderr：是否启用日志。

--v：日志记录等级，可选范围【0-8】，数值越大日志越详细。

--log-dir：日志文件存储目录。

--etcd-servers：Etcd 集群数据服务地址。

--bind-address：API Server 服务监听地址。

--insecure-port：API Server 服务监听端口。

--secure-port：API Server Https 服务监听端口。

--advertise-address：为集群中其他节点提供的，用于和本节点进行内部通信的地址，一般是当前节点的服务监听地址。

--allow-privileged：是否允许创建的容器使用 root 权限。

--enable-admission-plugins：启用的准入控制插件列表。

--authorization-mode：认证授权的模式，一般设置为启用RBAC授权和节点自管理。

--enable-bootstrap-token-auth：启用 TLS Bootstrap 机制（自动为加入集群的节点颁发证书）。

--token-auth-file： TLS Bootstrap 机制的配置文件。

--service-cluster-ip-range：服务的虚拟IP地址段。

--service-node-port-range：服务默认分配端口范围。

--service-account-key-file：对服务的账号进行认证的秘钥文件。

--tls-cert-file：客户端连接 API Server 的证书文件（使用 K8s 的 Server 证书）。

--tls-private-key-file：客户端连接 API Server 的证书秘钥文件（使用 K8s 的 Server 证书秘钥）。

--client-ca-file：客户端 API Server 的 CA 证书文件。

--kubelet-client-certificate：API Server 连接 Kubelet 证书文件。

--kubelet-client-key：API Server 连接 Kubelet 客户端证书秘钥文件。

--etcd-cafile：API Server连接 Etcd 的 CA 证书文件。

--etcd-certfile：API Server连接 Etcd 的证书文件。

--etcd-keyfile：API Server连接 Etcd 的证书秘钥文件。

--audit-log-path：审计日志文件存储位置。

7、配置 API Server 启动服务。

使用文本编辑器创建配置文件：

[centos@k8s-master1 ~]$ sudo gedit /usr/lib/systemd/system/kube-apiserver.service

编写文件内容并保存如下：

[Unit]
Description=Kubernetes API Server
Documentation=https://github.com/kubernetes/kubernetes

[Service]
User=root
Group=root
EnvironmentFile=/usr/local/kubernetes/server/etc/kube-apiserver.conf
ExecStart=/usr/local/kubernetes/server/bin/kube-apiserver $KUBE_APISERVER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target

8、启动 API Server 服务并设置开机自启动。

[centos@k8s-master1 ~]$ sudo systemctl daemon-reload
[centos@k8s-master1 ~]$ sudo systemctl start kube-apiserver.service
[centos@k8s-master1 ~]$ sudo systemctl enable kube-apiserver.service
[centos@k8s-master1 ~]$ sudo systemctl status kube-apiserver.service

9、授权允许 Token 文件中定义的用户和角色请求动态证书。

[centos@k8s-master1 ~]$ kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap

10、创建并编辑 Controller Manager 启动参数配置文件。

使用文本编辑器创建 "/usr/local/kubernetes/server/etc/kube-controller-manager.conf" 文件：

[centos@k8s-master1 ~]$ sudo gedit /usr/local/kubernetes/server/etc/kube-controller-manager.conf

编辑配置内容并保存：

KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=false \
--v=2 \
--log-dir=/usr/local/kubernetes/server/logs \
--leader-elect=true \
--master=127.0.0.1:8080 \
--bind-address=127.0.0.1 \
--allocate-node-cidrs=true \
--cluster-cidr=10.254.0.0/16 \
--service-cluster-ip-range=10.0.0.0/16 \
--root-ca-file=/usr/local/kubernetes/server/ssl/ca.pem \
--service-account-private-key-file=/usr/local/kubernetes/server/ssl/ca-key.pem \
--cluster-signing-cert-file=/usr/local/kubernetes/server/ssl/ca.pem \
--cluster-signing-key-file=/usr/local/kubernetes/server/ssl/ca-key.pem \
--experimental-cluster-signing-duration=87600h0m0s"

参数说明：

--logtostderr：是否启用日志。

--v：日志记录等级，可选范围【0-8】，数值越大日志越详细。

--log-dir：日志文件存储目录。

--leader-elect：是否启用集群自动选举。

--master：API Server 的服务监听地址和端口，一般被节点本地调用，设置为 “127.0.0.1:8080”。

--bind-address：Controller Manager 服务监听地址，一般被节点本地调用，设置为 “127.0.0.1”。

--allocate-node-cidrs：是否允许启用 CNI 网络。

--cluster-cidr：Pod 的 CNI 网络地址段。

--service-cluster-ip-range：服务的虚拟IP地址段。

--root-ca-file：对服务的账号进行认证的证书文件。

--service-account-private-key-file：对服务的账号进行认证的证书秘钥文件。

--cluster-signing-cert-file：自动为 Kubelet 颁发的集群签名 CA 证书文件。

--cluster-signing-key-file：自动为 Kubelet 颁发的集群签名 CA 证书秘钥文件。

--experimental-cluster-signing-duration：自动 Kubelet 颁发的证书的有效期。

11、配置 Controller Manager 启动服务。

使用文本编辑器创建配置文件：

[centos@k8s-master1 ~]$ sudo gedit /usr/lib/systemd/system/kube-controller-manager.service

编写文件内容并保存如下：

[Unit]
Description=Kubernetes Controller Manager
Documentation=https://github.com/kubernetes/kubernetes
After=kube-apiserver.service
Requires=kube-apiserver.service

[Service]
User=root
Group=root
EnvironmentFile=/usr/local/kubernetes/server/etc/kube-controller-manager.conf
ExecStart=/usr/local/kubernetes/server/bin/kube-controller-manager $KUBE_CONTROLLER_MANAGER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target

12、启动 Controller Manager 服务并设置开机自启动。

[centos@k8s-master1 ~]$ sudo systemctl daemon-reload
[centos@k8s-master1 ~]$ sudo systemctl start kube-controller-manager.service
[centos@k8s-master1 ~]$ sudo systemctl enable kube-controller-manager.service
[centos@k8s-master1 ~]$ sudo systemctl status kube-controller-manager.service

13、创建并编辑 Scheduler 启动参数配置文件。

使用文本编辑器创建 "/usr/local/kubernetes/server/etc/kube-scheduler.conf" 文件：

[centos@k8s-master1 ~]$ sudo gedit /usr/local/kubernetes/server/etc/kube-scheduler.conf

编辑配置内容并保存：

KUBE_SCHEDULER_OPTS="--logtostderr=false \
--v=2 \
--log-dir=/usr/local/kubernetes/server/logs \
--leader-elect=true \
--master=127.0.0.1:8080 \
--bind-address=127.0.0.1"

参数说明：

--logtostderr：是否启用日志。

--v：日志记录等级，可选范围【0-8】，数值越大日志越详细。

--log-dir：日志文件存储目录。

--leader-elect：是否启用集群自动选举。

--master：API Server 的服务监听地址和端口，一般被节点本地调用，设置为 “127.0.0.1:8080”。

--bind-address：Scheduler 服务监听地址，一般被节点本地调用，设置为 “127.0.0.1”。

14、配置 Scheduler 启动服务。

使用文本编辑器创建配置文件：

[centos@k8s-master1 ~]$ sudo gedit /usr/lib/systemd/system/kube-scheduler.service

编写文件内容并保存如下：

[Unit]
Description=Kubernetes Scheduler
Documentation=https://github.com/kubernetes/kubernetes
After=kube-apiserver.service
Requires=kube-apiserver.service

[Service]
User=root
Group=root
EnvironmentFile=/usr/local/kubernetes/server/etc/kube-scheduler.conf
ExecStart=/usr/local/kubernetes/server/bin/kube-scheduler $KUBE_SCHEDULER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target

15、启动 Scheduler 服务并设置开机自启动。

[centos@k8s-master1 ~]$ sudo systemctl daemon-reload
[centos@k8s-master1 ~]$ sudo systemctl start kube-scheduler.service
[centos@k8s-master1 ~]$ sudo systemctl enable kube-scheduler.service
[centos@k8s-master1 ~]$ sudo systemctl status kube-scheduler.service

16、查看集群状态。

[centos@k8s-master1 ~]$ kubectl get cs
NAME                 STATUS    MESSAGE             ERROR
scheduler            Healthy   ok                  
controller-manager   Healthy   ok                  
etcd-1               Healthy   {"health":"true"}   
etcd-2               Healthy   {"health":"true"}   
etcd-0               Healthy   {"health":"true"}

17、K8s Server 启动顺序。

启动 K8s Server 之前，应保证 Etcd 集群正常运行。启动顺序如下：

[centos@k8s-master1 ~]$ sudo systemctl daemon-reload
[centos@k8s-master1 ~]$ sudo systemctl start kube-apiserver.service
[centos@k8s-master1 ~]$ sudo systemctl start kube-controller-manager.service
[centos@k8s-master1 ~]$ sudo systemctl start kube-scheduler.service

18、授权 Master 主控节点的 API Server 访问 Node 工作集群的 Kubelet，主要用于在主控节点上对工作集群进行监控和运维。

1）创建并编辑授权文件：

使用文本编辑器创建 "/usr/local/kubernetes/server/etc/apiserver-to-kubelet-rbac.yml" 文件：

[centos@k8s-master1 ~]$ sudo gedit /usr/local/kubernetes/server/etc/apiserver-to-kubelet-rbac.yml

编辑配置内容并保存（删除注释）：

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

注意：【subjects.name】属性值应与 K8s Server 的证书申请文件 "server-csr.json" 中的【CN】属性值保持一致。

2）部署授权文件：

[centos@k8s-master1 ~]$ kubectl apply -f /usr/local/kubernetes/server/etc/apiserver-to-kubelet-rbac.yml

clusterrole.rbac.authorization.k8s.io/system:kube-apiserver-to-kubelet created
clusterrolebinding.rbac.authorization.k8s.io/system:kube-apiserver created

5.2.其他 Master 主控节点部署

在其他 Master 主控节点上执行以下操作步骤，以 "k8s-master2" 为例：

1、打开 K8s 下载页面【https://github.com/kubernetes/kubernetes/releases】，下载最新版本 Kubernetes Server 的编译程序 tar 包到用户主目录中。

注意：Kubernetes Server 的 tar 包中包含了：Master 主控节点，Node 工作节点和客户端的全部程序。

第一步，点击链接进入编译程序下载页面

第二步，下载 Kubernetes Server 的 tar 包

2、解压缩编译程序 tar 包到"/usr/local"目录中，并为管理工具创建系统 Shell 目录的软链接。

1）解压缩编译程序 tar 包到"/usr/local"目录中：

[centos@k8s-master2 ~]$ sudo tar zxvf kubernetes-server-linux-amd64.tar.gz -C /usr/local
[centos@k8s-master2 ~]$ ll /usr/local
drwxr-xr-x  4 root root  79 8月  14 00:53 kubernetes

安装目录：/usr/local/kubernetes/server
可执行程序目录：/usr/local/kubernetes/server/bin

2）为管理工具创建系统 Shell 目录的软链接：

[centos@k8s-master2 ~]$ sudo ln -s /usr/local/kubernetes/server/bin/kubectl /usr/bin/kubectl

3、创建 K8s Server 日志目录、秘钥目录和配置文件目录。

[centos@k8s-master2 ~]$ sudo mkdir -p /usr/local/kubernetes/server/{logs,ssl,etc}

4、从第一个 Master 主控节点上获取配置文件、证书文件、启动文件。

使用 ssh 远程登录到第一个 Master 主控节点，并将第一个 Master 主控节点已部署好的配置文件、证书文件、启动文件通过 scp 拷贝到当前节点的对应目录中：

1）使用 ssh 远程登录到第一个 Master 主控节点上：

[centos@k8s-master2 ~]$ ssh centos@192.168.0.21
centos@192.168.0.21's password:

2）从第一个 Master 主控节点的 "/usr/local/kubernetes/server/etc" 目录下拷贝 "token.csv"、"kube-apiserver.conf"、"kube-controller-manager.conf"、"kube-scheduler.conf" 配置文件到当前节点一致对应的目录下：

[centos@k8s-master1 ~]$ scp -r /usr/local/kubernetes/server/etc/token.csv root@192.168.0.22:/usr/local/kubernetes/server/etc
root@192.168.0.22's password:
token.csv                                                            100%   83    68.1KB/s   00:00

[centos@k8s-master1 ~]$ scp -r /usr/local/kubernetes/server/etc/kube-apiserver.conf root@192.168.0.22:/usr/local/kubernetes/server/etc
root@192.168.0.22's password:
kube-apiserver.conf                                                  100% 1306   450.7KB/s   00:00

[centos@k8s-master1 ~]$ scp -r /usr/local/kubernetes/server/etc/kube-controller-manager.conf root@192.168.0.22:/usr/local/kubernetes/server/etc
root@192.168.0.22's password:
kube-controller-manager.conf                                         100%  615    93.3KB/s   00:00

[centos@k8s-master1 ~]$ scp -r /usr/local/kubernetes/server/etc/kube-scheduler.conf root@192.168.0.22:/usr/local/kubernetes/server/etc
root@192.168.0.22's password:
kube-scheduler.conf                                                  100%  171    31.9KB/s   00:00

3）从第一个 Master 主控节点的 "/usr/local/kubernetes/server/ssl" 目录下拷贝所有 PEM 证书文件到当前节点一致对应的目录下：

[centos@k8s-master1 ~]$ scp -r /usr/local/kubernetes/server/ssl root@192.168.0.22:/usr/local/kubernetes/server
root@192.168.0.22's password:
ca-key.pem                                                           100% 1675   739.4KB/s   00:00    
ca.pem                                                               100% 1322     1.0MB/s   00:00    
server-key.pem                                                       100% 1675     1.6MB/s   00:00    
server.pem                                                           100% 1627   941.8KB/s   00:00    
etcd-key.pem                                                         100% 1675     1.6MB/s   00:00    
etcd.pem                                                             100% 1424     1.5MB/s   00:00

4）从第一个 Master 主控节点的 "/usr/lib/systemd/system" 目录下拷贝所有启动配置文件到当前节点一致对应的目录下：

[centos@k8s-master1 ~]$ scp -r /usr/lib/systemd/system/kube-apiserver.service root@192.168.0.22:/usr/lib/systemd/system
root@192.168.0.22's password:
kube-apiserver.service                                               100%  333   202.1KB/s   00:00

[centos@k8s-master1 ~]$ scp -r /usr/lib/systemd/system/kube-controller-manager.service root@192.168.0.22:/usr/lib/systemd/system
root@192.168.0.22's password:
kube-controller-manager.service                                      100%  429   331.5KB/s   00:00

[centos@k8s-master1 ~]$ scp -r /usr/lib/systemd/system/kube-scheduler.service root@192.168.0.22:/usr/lib/systemd/system
root@192.168.0.22's password:
kube-scheduler.service                                               100%  393   134.1KB/s   00:00

5）从第一个 Master 主控节点上退出登录：

[centos@k8s-master1 ~]$ exit
[centos@k8s-master2 ~]$

5、编辑 API Server 启动参数配置文件。

使用文本编辑器创建 "/usr/local/kubernetes/server/etc/kube-apiserver.conf" 文件：

[centos@k8s-master2 ~]$ sudo gedit /usr/local/kubernetes/server/etc/kube-apiserver.conf

编辑配置内容并保存：

KUBE_APISERVER_OPTS="...
--advertise-address=192.168.0.22 \
...

修改【--advertise-address】参数为当前节点的 IP 地址。

6、启动 API Server，Controller Manager，Scheduler 服务并设置开机自启动。

[centos@k8s-master2 ~]$ sudo systemctl daemon-reload
[centos@k8s-master2 ~]$ sudo systemctl start kube-apiserver.service
[centos@k8s-master2 ~]$ sudo systemctl start kube-controller-manager.service
[centos@k8s-master2 ~]$ sudo systemctl start kube-scheduler.service
[centos@k8s-master2 ~]$ sudo systemctl enable kube-apiserver.service
[centos@k8s-master2 ~]$ sudo systemctl enable kube-controller-manager.service
[centos@k8s-master2 ~]$ sudo systemctl enable kube-scheduler.service
[centos@k8s-master2 ~]$ sudo systemctl status kube-apiserver.service
[centos@k8s-master2 ~]$ sudo systemctl status kube-controller-manager.service
[centos@k8s-master2 ~]$ sudo systemctl status kube-scheduler.service

7、查看集群状态。

[centos@k8s-master2 ~]$ kubectl get cs
NAME                 STATUS    MESSAGE             ERROR
scheduler            Healthy   ok                  
controller-manager   Healthy   ok                  
etcd-1               Healthy   {"health":"true"}   
etcd-2               Healthy   {"health":"true"}   
etcd-0               Healthy   {"health":"true"}

所有其他 Master 主控节点全部需要按照以上步骤配置。

6.Master 高可用集群部署

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

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

Nginx 是一个开源（遵循 BSD 协议）、高性能、高可靠的 Web 和反向代理服务器。主要用于 Web 应用的缓存和负载均衡，支持热部署、占用内存少、并发能力强，能支持高达 5w 个并发连接数。

Keepalived 是一个开源（遵循 GPLv2 协议）的、基于 VRRP 协议的轻量级服务高可用和负载均衡方案，提供避免服务器单点故障和请求分流的能力。它为 Nginx 扩展了高可用能力，共同组成完整的 Web 服务集群模式（高可用+负载均衡）。

6.1.Nginx 安装和配置

在各个 "Master 高可用节点" （k8s-proxy1、k8s-proxy1）安装、配置 Nginx，以 "k8s-proxy1" 为例：

1、打开 Nginx 下载页面【http://nginx.org/en/download.html】，下载 Nginx 的源代码 tar.gz 包到用户主目录中。

Nginx 下载页面

2、验证并安装依赖软件。通过源代码编译的方式安装 Nginx，需要依赖软件"make"、"gcc"、"pcre"、"pcre-devel"、"zlib"、"zlib-devel"、"openssl"、"openssl-devel"，验证或安装依赖软件。

[centos@k8s-proxy1 ~]$ sudo dnf install make gcc pcre pcre-devel zlib zlib-devel openssl openssl-devel

补充知识：

① "gcc"是一个C/C++、FORTRAN、JAVA、OBJC、ADA等多种语言的编译器，用来将源代码编译成可发布的软件程序。

② "make"是一个工程管理工具，能够根据 Makefile 中的脚本执行编译、安装流程。

③ "pcre"是一个正则表达式函数库；"pcre-devel"是它的开发库。

④ "zlib"是一个数据压缩函数库；"zib-devel"是它的开发库。

⑤ "openssl"是一个实现安全通信，避免窃听，同时确认另一端连接者身份的软件程序；"openssl-devel"是它的开发库。

3、解压缩 Nginx 的源代码 tar 包到用户主目录下。

[centos@k8s-proxy1 ~]$ tar -zxvf nginx-1.18.0.tar.gz
[centos@k8s-proxy1 ~]$ ll
drwxr-xr-x.  8 centos centos    4096 4月  21 22:09 nginx-1.18.0

4、安装 Nginx，进入源代码目录，配置、编译、安装程序。

[centos@k8s-proxy1 ~]$ cd nginx-1.18.0
[centos@k8s-proxy1 nginx-1.18.0]$ ./configure --prefix=/usr/local/nginx --with-http_stub_status_module --with-http_ssl_module  --with-stream
Configuration summary
  + using system PCRE library
  + OpenSSL library is not used
  + using system zlib library

  nginx path prefix: "/usr/local/nginx"
  nginx binary file: "/usr/local/nginx/sbin/nginx"
  nginx modules path: "/usr/local/nginx/modules"
  nginx configuration prefix: "/usr/local/nginx/conf"
  nginx configuration file: "/usr/local/nginx/conf/nginx.conf"
  nginx pid file: "/usr/local/nginx/logs/nginx.pid"
  nginx error log file: "/usr/local/nginx/logs/error.log"
  nginx http access log file: "/usr/local/nginx/logs/access.log"
  nginx http client request body temporary files: "client_body_temp"
  nginx http proxy temporary files: "proxy_temp"
  nginx http fastcgi temporary files: "fastcgi_temp"
  nginx http uwsgi temporary files: "uwsgi_temp"
  nginx http scgi temporary files: "scgi_temp"

[centos@k8s-proxy1 nginx-1.18.0]$ make
[centos@k8s-proxy1 nginx-1.18.0]$ sudo make install

[centos@k8s-proxy1 ~]$ ll /usr/local/nginx
drwxr-xr-x. 2 root root 4096 5月  18 09:39 conf
drwxr-xr-x. 2 root root   40 5月  18 09:39 html
drwxr-xr-x. 2 root root    6 5月  18 09:39 logs
drwxr-xr-x. 2 root root   19 5月  18 09:39 sbin

程序安装目录是"/usr/local/nginx"。

5、设置 Nginx 配置文件参数。

使用文本编辑器打开配置文件：

[centos@k8s-proxy1 ~ ]$ sudo gedit /usr/local/nginx/conf/nginx.conf

在文件中追加的以下参数并保存：

# 四层负载均衡
stream {
    # 负载均衡
    upstream k8s-apiserver {
        server 192.168.0.21:6443 weight=1;
        server 192.168.0.22:6443 weight=1;
        server 192.168.0.23:6443 weight=1;
    }
    
    # 虚拟主机
    server {
        # 监听端口
        listen       6443;
        # 代理位置
        proxy_pass k8s-apiserver;
    }
}

6、配置 Nginx 开机自启动。

使用文本编辑器创建配置文件：

[centos@k8s-proxy1 ~ ]$ sudo gedit /usr/lib/systemd/system/nginx.service

编写文件内容并保存如下：

[Unit]
Description=Nginx
After=syslog.target network.target

[Service]
Type=forking
User=root
Group=root

ExecStart=/usr/local/nginx/sbin/nginx
ExecReload=/usr/local/nginx/sbin/nginx -s reload
ExecStop=/usr/local/nginx/sbin/nginx -s quit
PrivateTmp=true

[Install]
WantedBy=multi-user.target

设置开机启动：

[centos@k8s-proxy1 ~ ]$ sudo systemctl daemon-reload
[centos@k8s-proxy1 ~ ]$ sudo systemctl enable nginx.service

7、启动 Nginx 服务。

[centos@k8s-proxy1 ~ ]$ sudo systemctl start nginx.service

8、设置防火墙端口（CentOS8默认安装firewall防火墙），允许"6443"端口（Nginx 默认端口）访问服务器。

[centos@k8s-proxy1 ~ ]$ sudo firewall-cmd --zone=public --add-port=6443/tcp --permanent
[centos@k8s-proxy1 ~ ]$ sudo firewall-cmd --reload

9、验证 Nginx 服务。使用浏览器访问 Web 代理服务。

注意：其他 "Master 高可用节点" 全部需要按照以上步骤配置。

6.2.Keepalived 安装和配置

在各个 "Master 高可用节点" （k8s-proxy1、k8s-proxy1）安装、配置 Keepalived，以 "高可用节点-1" 为例：

1、安装 EPEL 的 Yum源。

使用文本编辑器创建仓库配置文件：

[centos@k8s-proxy1 ~ ]$ sudo gedit /etc/yum.repos.d/epel.repo

在文件中编写以下内容并保存：

[epel-modular]
name=Extra Packages for Enterprise Linux Modular $releasever - $basearch
baseurl=http://mirrors.aliyun.com/epel/$releasever/Modular/$basearch
enabled=1
gpgcheck=1
gpgkey=http://mirrors.aliyun.com/epel/RPM-GPG-KEY-EPEL-8

[epel]
name=Extra Packages for Enterprise Linux $releasever - $basearch
baseurl=http://mirrors.aliyun.com/epel/$releasever/Everything/$basearch
enabled=1
gpgcheck=1
gpgkey=http://mirrors.aliyun.com/epel/RPM-GPG-KEY-EPEL-8

更新 Yum 源：

[centos@k8s-proxy1 ~]$ sudo dnf clean all
[centos@k8s-proxy1 ~]$ sudo dnf makecache
Extra Packages for Enterprise Linux Modular 8 - 429 kB/s | 118 kB     00:00    
Extra Packages for Enterprise Linux 8 - x86_64  3.7 MB/s | 6.9 MB     00:01    
元数据缓存已建立。

EPEL（Extra Packages for Enterprise Linux）是企业级 Linux 操作系统的扩展包仓库，为 Redhat/CentOS系统提供大量的额外软件包。

2、安装 Keepalived。

[centos@k8s-proxy1 ~]$ sudo dnf install keepalived

程序安装目录是"/usr/sbin"，配置文件目录是"/etc/keepalived"。

3、设置 Keepalived 配置文件参数。

使用文本编辑器打开配置文件：

[centos@k8s-proxy1 ~ ]$ sudo gedit /etc/keepalived/keepalived.conf

在文件中编写以下内容并保存：

# 定义全局配置
global_defs {
    # 本地节点 ID 标识，一般设置为主机名。
    router_id k8s-proxy1
}

# 定义周期性执行的脚本，脚本的退出状态码会被调用它的所有的 vrrp_instance 记录。
vrrp_script chk_nginx {
    # 执行脚本的路径。
    script "/etc/keepalived/nginx_check.sh"
    # 脚本执行的间隔（单位是秒）。默认为1s。
    interval 2
    # 当脚本调整优先级，从 -254 到 254。默认为2。
    # 1. 如果脚本执行成功(退出状态码为0)，weight大于0，则priority增加。
    # 2. 如果脚本执行失败(退出状态码为非0)，weight小于0，则priority减少。
    # 3. 其他情况下，priority不变。
    weight -20
    # 当脚本执行超过时长（单位是秒）则被认为执行失败。
    # 运行脚本的用户和组。
    user root root
    # timeout 30
    # 当脚本执行成功到设定次数时，才认为是成功。
    # rise 1
    # 当脚本执行失败到设定次数时，才认为是失败。
    # fall 3
}

# 定义虚拟路由，可以定义多个。
vrrp_instance VI_1 {
    # 本地节点初始状态，包括 MASTER（主节点） 和 BACKUP （备节点）。
    state MASTER
    # 本地节点绑定虚拟 IP 的网络接口。
    interface ens33
    # 本地节点优先级，优先级高的节点将动态变成 MASTER 节点，接管 VIP 。初始状态下，MASTER 节点的优先级必须高于 BACKUP 节点。
    priority 100
    # VRRP 实例 ID，范围是0-255。同一集群的所有节点应设置一致的值。
    virtual_router_id 216
    # 组播信息发送时间间隔。同一集群的所有节点必须设置一样，默认为1秒。
    advert_int 1
    # 设置验证信息。同一集群的所有节点必须一致
    authentication {
        # 指定认证方式。PASS 表示简单密码认证(推荐)；AH:IPSEC认证(不推荐)。
        auth_type PASS
        # 指定认证所使用的密码，最多8位。
        auth_pass 1111
    }

    # 声明调用已定义的 vrrp_script 脚本。
    track_script {
        chk_nginx
    }

    # 定义虚拟 IP 地址。
    virtual_ipaddress {
        192.168.0.10
    }
}

初始化的主节点和备节点的区别体现在以下参数中：

初始主节点

vrrp_instance VI_1 {
    # 必须设置为 MASTER 。
    state MASTER
    # 必须设置为最大值。
    priority 100
}

初始备节点

vrrp_instance VI_1 {
    # 必须设置为 BACKUP 。
    state BACKUP
    # 必须设置为小于主节点的值。
    priority 90
}

4、创建或编辑 Nginx 检测脚本文件。文件路径对应配置文件中 vrrp_script 的 script 设置值。

使用文本编辑器创建脚本文件：

[centos@k8s-proxy1 ~ ]$ sudo gedit /etc/keepalived/nginx_check.sh

在脚本文件中编写以下内容并保存：

#!/bin/bash
counter=$(ps -C nginx --no-heading|wc -l)
if [ "${counter}" = "0" ]; then
    /usr/local/nginx/sbin/nginx
    sleep 2
    counter=$(ps -C nginx --no-heading|wc -l)
    if [ "${counter}" = "0" ]; then
        killall -9 keepalived
    fi
fi

给脚本文件增加可执行权限：

[centos@k8s-proxy1 ~ ]$ sudo chmod 755 /etc/keepalived/nginx_check.sh

5、配置 Keepalived 系统服务。

使用文本编辑器创建配置文件：

[centos@k8s-proxy1 ~ ]$ sudo gedit /usr/lib/systemd/system/keepalived.service

验证或修改文件内容并保存如下：

[Unit]
Description=LVS and VRRP High Availability Monitor
After=network-online.target syslog.target nginx.service
Wants=network-online.target
Requires=nginx.service

[Service]
Type=forking
User=root
Group=root
PIDFile=/var/run/keepalived.pid
KillMode=process
EnvironmentFile=-/etc/sysconfig/keepalived
ExecStart=/usr/sbin/keepalived $KEEPALIVED_OPTIONS
ExecReload=/bin/kill -HUP $MAINPID
ExecStop=/bin/kill -HUP $MAINPID

[Install]
WantedBy=multi-user.target

重新加载系统服务管理器：

[centos@k8s-proxy1 ~ ]$ sudo systemctl daemon-reload

6、设置防火墙端口（CentOS8默认安装firewall防火墙），允许"112"端口（Keepalived 默认端口）访问服务器。

[centos@k8s-proxy1 ~ ]$ sudo firewall-cmd --zone=public --add-port=112/tcp --permanent
[centos@k8s-proxy1 ~ ]$ sudo firewall-cmd --reload

7、启动/重启 Keepalived 服务（不建议设置为开机自启动）。

启动 Keepalived 服务之前，应确保已正确启动了各节点的 Nginx 服务。各节点的启动或重启的顺序为：① 启动 Keepalived 主节点；② 依次启动 Keepalived 备节点。

[centos@Proxy-1 ~ ]$ sudo systemctl restart keepalived.service

8、启动 Keepalived 可能因为各种未知的原因失败，主要是由于引发了 SELinux 异常。有关如何解决 SELinux 引起的异常，请阅读文章《RedHat/CentOS8【SELinux】引起的安全策略问题解决方案》，文章地址【https://www.jianshu.com/p/a13f974f8bae】。

注意：其他 "Master 高可用节点" 全部需要按照以上步骤配置。

9、验证 Nginx 高可用服务。使用浏览器通过虚拟 IP 访问代理服务。

有关 Nginx + Keepalived 实现 Web 应用高可用和负载均衡集群的内容，请阅读文章《应用架构之【Nginx+Keepalived】Web 集群方案》，文章地址【https://www.jianshu.com/p/185022cba563】。

7.Node 工作集群部署

以 "工作节点-1" 为例，所有 "Node 工作节点" 都需实施以下操作：

1、安装和配置 Docker 。

有关如何安装和配置 Docker，请阅读文章《RedHat/CentOS8【Docker】镜像制作编排和容器部署》的 “2.Docker 的安装和配置” 章节，文章地址【https://www.jianshu.com/p/a4198b127729】。

2、打开 K8s 下载页面【https://github.com/kubernetes/kubernetes/releases】，下载最新版本 Kubernetes Node 的编译程序 tar 包到用户主目录中。

第一步，点击链接进入编译程序下载页面

第二步，下载 Kubernetes Node 的 tar 包

3、解压缩编译程序 tar 包到"/usr/local"目录中，并管理工具创建系统 Shell 目录的软链接。

1）解压缩编译程序 tar 包到"/usr/local"目录中：

[centos@k8s-node1 ~]$ sudo tar zxvf kubernetes-node-linux-amd64.tar.gz -C /usr/local
[centos@k8s-node1 ~]$ ll /usr/local
drwxr-xr-x  3 root root  63 8月  14 00:49 kubernetes

安装目录：/usr/local/kubernetes/node
可执行程序目录：/usr/local/kubernetes/node/bin

2）为管理工具创建系统 Shell 目录的软链接：

[centos@k8s-node1 ~]$ sudo ln -s /usr/local/kubernetes/node/bin/kubectl /usr/bin/kubectl

4、创建 K8s Node 日志目录、秘钥目录、配置目录。

[centos@k8s-node1 ~]$ sudo mkdir -p /usr/local/kubernetes/node/{logs,ssl,etc}

5、从 SSL 证书服务器上获取已创建的 CA 根证书，Proxy 证书和 Proxy 证书秘钥。

使用 ssh 远程登录到 SSL 证书服务器，并将 SSL 证书服务器上已制作好的 CA 根证书，Proxy 证书和 Proxy 证书秘钥通过 scp 拷贝到 "Node 工作节点"（当前主机）的 K8s Node 秘钥目录中：

[centos@k8s-node1 ~]$ ssh centos@192.168.0.50
centos@192.168.0.50's password:
[centos@k8s-ssl ~]$ scp -r /data/ssl/k8s/ca/ca.pem root@192.168.0.31:/usr/local/kubernetes/node/ssl
root@192.168.0.31's password:
ca.pem                                                                                     100% 1346   173.3KB/s   00:00
[centos@k8s-ssl ~]$ scp -r /data/ssl/k8s/proxy/proxy.pem root@192.168.0.31:/usr/local/kubernetes/node/ssl
root@192.168.0.31's password:
proxy.pem                                                                                  100% 1387   640.8KB/s   00:00
[centos@k8s-ssl ~]$ scp -r /data/ssl/k8s/proxy/proxy-key.pem root@192.168.0.31:/usr/local/kubernetes/node/ssl
root@192.168.0.31's password:
proxy-key.pem                                                                              100% 1679     2.1MB/s   00:00
[centos@k8s-ssl ~]$ exit

[centos@k8s-node1 ~]$ sudo chmod 644 /usr/local/kubernetes/node/ssl/*
[centos@k8s-node1 ~]$ ll /usr/local/kubernetes/node/ssl
-rw-r--r-- 1 root root 1346 8月  20 10:57 ca.pem
-rw-r--r-- 1 root root 1679 8月  20 11:00 proxy-key.pem
-rw-r--r-- 1 root root 1387 8月  20 10:58 proxy.pem

6、安装 CNI 网络插件。

1）打开 CNI 插件下载页面【https://github.com/containernetworking/plugins/releases】，下载最新版本 CNI 插件的编译程序 tar 包到用户主目录中：

CNI 插件下载页面

2）在 Node 工作节点的插件目录中创建 CNI 的程序目录和配置目录：

[centos@k8s-node1 ~]$ sudo mkdir -p /opt/cni/bin
[centos@k8s-node1 ~]$ sudo mkdir -p /etc/cni/net.d

3）解压缩编译程序 tar 包到"/opt/cni/bin"目录中：

[centos@k8s-node1 ~]$ sudo tar zxvf cni-plugins-linux-amd64-v0.8.7.tgz -C /opt/cni/bin

7、创建并编辑 Kubelet 的集群连接配置文件，采用 TLS Bootstrapping 动态证书。

1）生成集群连接信息：

[centos@k8s-node1 ~]$ sudo kubectl config set-cluster kube-cluster \
--certificate-authority=/usr/local/kubernetes/node/ssl/ca.pem  \
--embed-certs=true \
--server=https://192.168.0.10:6443 \
--kubeconfig=/usr/local/kubernetes/node/etc/bootstrap.kubeconfig

指令：kubectl config set-cluster <集群连接配置标识名> [参数...]
功能：设置 Kubelet 连接 K8s 集群的连接参数。

参数：

--server：连接的 Master 集群 Keepalived Virtual IP（高可用集群的虚拟 IP 地址）的 API Server 的地址和端口号。

--certificate-authority：用以进行认证授权的证书文件路径。

--embed-certs：是否在配置文件中嵌入证书。

--kubeconfig：配置文件位置。

2）生成用户认证信息：

[centos@k8s-node1 ~]$ sudo kubectl config set-credentials kube-users \
--token="d682ded2c1468b8c6a16375b48a638ff" \
--kubeconfig=/usr/local/kubernetes/node/etc/bootstrap.kubeconfig

指令：kubectl config set-credentials <用户认证配置标识名> [参数...]
功能：设置 Kubelet 连接 K8s 集群的用户认证参数。

参数：

--token：在 Master 集群或节点上定义的 TLS Bootstrapping 的 Token 配置文件中的 Token 值。详见 “1.5.Master 主控节点部署” 章节第5步 “启用 TLS Bootstrapping 机制” 的相关内容。

--kubeconfig：配置文件位置。

3）生成配置文件的上下文信息：

[centos@k8s-node1 ~]$ sudo kubectl config set-context kube-context \
--cluster=kube-cluster \
--user=kube-users \
--kubeconfig=/usr/local/kubernetes/node/etc/bootstrap.kubeconfig

指令：kubectl config set-context <上下文配置标识名> [参数...]
功能：设置 Kubelet 配置的上下文信息。

参数：

--cluster：配置文件中的 "cluster" 节点的 "name" 属性（集群连接配置标识名）值。

--user：配置文件中的 "users" 节点的 "name" 属性（用户认证配置标识名）值。

--kubeconfig：配置文件位置。

4）生成配置文件的当前上下文：

[centos@k8s-node1 ~]$ sudo kubectl config use-context kube-context  \
--kubeconfig=/usr/local/kubernetes/node/etc/bootstrap.kubeconfig

指令：kubectl config use-context <上下文配置标识名> [参数...]
功能：设置 Kubelet 配置的当前上下文。

参数：

--kubeconfig：配置文件位置。

5）查看已生成的文件：

[centos@k8s-node1 ~]$ sudo cat /usr/local/kubernetes/node/etc/bootstrap.kubeconfig

apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSUR0RENDQXB5Z0F3SUJBZ0lVRkd1Q1luWC9FZEd...
    server: https://192.168.0.10:6443
  name: kube-cluster
contexts:
- context:
    cluster: kube-cluster
    user: kube-users
  name: kube-context
current-context: kube-context
kind: Config
preferences: {}
users:
- name: kube-users
  user:
    token: d682ded2c1468b8c6a16375b48a638ff

8、创建并编辑 Kubelet 核心配置文件。

[centos@k8s-node1 ~]$  sudo gedit /usr/local/kubernetes/node/etc/kubelet-config.yml

编写文件内容并保存如下（删除注释）：

kind: KubeletConfiguration
# API 版本。
apiVersion: kubelet.config.k8s.io/v1beta1
# 监听地址。
address: 0.0.0.0
# 监听端口。
port: 10250
# 读取监听端口，一般用不上，可以不设置或保持默认设置。
readOnlyPort: 10255
# Docker 驱动，与 Docker 的【Cgroup Driver】属性一致，Docker 的 【Cgroup Driver】属性可以通过指令 "docker info" 查看。
cgroupDriver: cgroupfs
# 服务的 DNS 服务地址。
clusterDNS:
  - 10.0.0.2
# kubelet 集群的域名。
clusterDomain: cluster.local 
# 是否启动虚拟内存。
failSwapOn: false
# 认证授权配置
authentication:
  anonymous:
    enabled: false
  webhook:
    cacheTTL: 2m0s
    enabled: true
  x509:
    # 客户端 CA 证书文件位置
    clientCAFile: /usr/local/kubernetes/node/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
# 最大 Pod 数量。
maxPods: 110

9、创建并编辑 Kebelet 启动参数配置文件。

使用文本编辑器创建 "/usr/local/kubernetes/node/etc/kubelet.conf" 文件：

[centos@k8s-node1 ~]$ sudo gedit /usr/local/kubernetes/node/etc/kubelet.conf

编辑配置内容并保存：

KUBELET_OPTS="--logtostderr=false \
--v=2 \
--log-dir=/usr/local/kubernetes/node/logs \
--hostname-override=k8s-node1 \
--network-plugin=cni \
--cni-conf-dir=/etc/cni/net.d \
--cni-bin-dir=/opt/cni/bin \
--kubeconfig=/usr/local/kubernetes/node/etc/kubelet.kubeconfig \
--bootstrap-kubeconfig=/usr/local/kubernetes/node/etc/bootstrap.kubeconfig \
--config=/usr/local/kubernetes/node/etc/kubelet-config.yml \
--cert-dir=/usr/local/kubernetes/node/ssl \
--pod-infra-container-image=quay.io/coreos/flannel:v0.12.0-amd64"

参数说明：

--logtostderr：是否启用日志。

--v：日志记录等级，可选范围【0-8】，数值越大日志越详细。

--log-dir：日志文件存储目录。

--hostname-override：Node 节点名称，在集群中是唯一的。

--network-plugin：网络插件，一般指定为 "cni" 表示启用 CNI 网络。

--cni-conf-dir：CNI 插件的配置文件目录，默认为 "/etc/cni/net.d"。

--cni-bin-dir：CNI插件的可执行文件目录，默认为 "/opt/cni/bin"。

--kubeconfig：空路径，会自动生成，用于连接 API Server。

--bootstrap-kubeconfig： Kubelet 的 TLS Bootstrapping 动态证书配置文件位置。

--config：Kubelet 核心配置文件位置。

--cert-dir：Kubelet 证书生成目录。

--pod-infra-container-image：管理 CNI 网络容器的镜像名称和版本。指定的镜像和版本应该跟 CNI 插件的 Flannel 镜像名字和版本保持一致。

10、配置 Kebelet 启动服务。

使用文本编辑器创建配置文件：

[centos@k8s-node1 ~]$ sudo gedit /usr/lib/systemd/system/kubelet.service

编写文件内容并保存如下：

[Unit]
Description=Kubernetes Kubelet
After=docker.service
Requires=docker.service

[Service]
User=root
Group=root
EnvironmentFile=/usr/local/kubernetes/node/etc/kubelet.conf
ExecStart=/usr/local/kubernetes/node/bin/kubelet $KUBELET_OPTS
Restart=on-failure
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target

11、启动 Kebelet 服务并设置开机自启动。

[centos@k8s-node1 ~]$ sudo systemctl daemon-reload
[centos@k8s-node1 ~]$ sudo systemctl start kubelet.service
[centos@k8s-node1 ~]$ sudo systemctl enable kubelet.service
[centos@k8s-node1 ~]$ sudo systemctl status kubelet.service

12、创建并编辑 Proxy 的集群连接配置文件。

1）生成集群连接信息：

[centos@k8s-node1 ~]$ sudo kubectl config set-cluster kube-cluster \
--certificate-authority=/usr/local/kubernetes/node/ssl/ca.pem  \
--embed-certs=true \
--server=https://192.168.0.10:6443 \
--kubeconfig=/usr/local/kubernetes/node/etc/kube-proxy.kubeconfig

指令：kubectl config set-cluster <集群连接配置标识名> [参数...]
功能：设置 Kubelet 连接 K8s 集群的连接参数。

参数：

--server：连接的 Master 集群 Keepalived Virtual IP（高可用集群的虚拟 IP 地址）的 API Server 的地址和端口号。

--certificate-authority：用以进行认证授权的证书文件路径。

--embed-certs：是否在配置文件中嵌入证书。

--kubeconfig：配置文件位置。

2）生成用户认证信息：

[centos@k8s-node1 ~]$ sudo kubectl config set-credentials kube-users \
--client-certificate=/usr/local/kubernetes/node/ssl/proxy.pem \
--client-key=/usr/local/kubernetes/node/ssl/proxy-key.pem \
--embed-certs=true \
--kubeconfig=/usr/local/kubernetes/node/etc/kube-proxy.kubeconfig

指令：kubectl config set-credentials <用户认证配置标识名> [参数...]
功能：设置 Kubelet 连接 K8s 集群的用户认证参数。

参数：

--client-certificate：用于连接 Master 集群或节点的 API Server 使用的证书文件。

--client-key：用于连接 Master 集群或节点的 API Server 使用的证书秘钥文件。

--embed-certs：是否在配置文件中嵌入证书。

--kubeconfig：配置文件位置。

3）生成配置文件的上下文信息：

[centos@k8s-node1 ~]$ sudo kubectl config set-context kube-context \
--cluster=kube-cluster \
--user=kube-users \
--kubeconfig=/usr/local/kubernetes/node/etc/kube-proxy.kubeconfig

指令：kubectl config set-context <上下文配置标识名> [参数...]
功能：设置 Kubelet 配置的上下文信息。

参数：

--cluster：配置文件中的 "cluster" 节点的 "name" 属性（集群连接配置标识名）值。

--user：配置文件中的 "users" 节点的 "name" 属性（用户认证配置标识名）值。

--kubeconfig：配置文件位置。

4）生成配置文件的当前上下文：

[centos@k8s-node1 ~]$ sudo kubectl config use-context kube-context  \
--kubeconfig=/usr/local/kubernetes/node/etc/kube-proxy.kubeconfig

指令：kubectl config use-context <上下文配置标识名> [参数...]
功能：设置 Kubelet 配置的当前上下文。

参数：

--kubeconfig：配置文件位置。

5）查看已生成的文件：

[centos@k8s-node1 ~]$ sudo cat /usr/local/kubernetes/node/etc/kube-proxy.kubeconfig

apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSUR0RENDQXB5Z0F3SUJBZ0lVRkd1Q1luWC9FZEd...
    server: https://192.168.0.10:6443
  name: kube-cluster
contexts:
- context:
    cluster: kube-cluster
    user: kube-users
  name: kube-context
current-context: kube-context
kind: Config
preferences: {}
users:
- name: kube-users
  user:
    client-certificate-data: LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSUQwekNDQXJ1Z0F3SUJBZ0lVVE1odys4MHBsc21...
    client-key-data: LS0tLS1CRUdJTiBSU0EgUFJJVkFURSBLRVktLS0tLQpNSUlFcEFJQkFBS0NBUUVBdWN1aXB6d01WbW...

13、创建并编辑 Proxy 核心配置文件。

使用文本编辑器创建 "/usr/local/kubernetes/node/etc/kube-proxy-config.yml" 文件：

[centos@k8s-node1 ~]$ sudo gedit /usr/local/kubernetes/node/etc/kube-proxy-config.yml

编辑配置内容并保存：

kind: KubeProxyConfiguration
# API 版本。
apiVersion: kubeproxy.config.k8s.io/v1alpha1
# Node 节点名称，在集群中是唯一的。
hostnameOverride: k8s-node1
# 监听地址。
bindAddress: 0.0.0.0
# 指标暴露地址和端口，用于监控系统使用，使用默认配置即可。
metricsBindAddress: 0.0.0.0:10249
# Pod 的 CNI 网络地址段。
clusterCIDR: 10.254.0.0/16
# 集群连接配置文件位置
clientConnection:
  kubeconfig: /usr/local/kubernetes/node/etc/kube-proxy.kubeconfig

14、创建并编辑 Proxy 启动参数配置文件。

使用文本编辑器创建 "/usr/local/kubernetes/node/etc/kube-proxy.conf" 文件：

[centos@k8s-node1 ~]$ sudo gedit /usr/local/kubernetes/node/etc/kube-proxy.conf

编辑配置内容并保存：

KUBE_PROXY_OPTS="--logtostderr=false \
--v=2 \
--log-dir=/usr/local/kubernetes/node/logs \
--config=/usr/local/kubernetes/node/etc/kube-proxy-config.yml"

参数说明：

--logtostderr：是否启用日志。

--v：日志记录等级，可选范围【0-8】，数值越大日志越详细。

--log-dir：日志文件存储目录。

--config：Proxy 核心配置文件位置。

15、配置 Proxy 启动服务。

使用文本编辑器创建配置文件：

[centos@k8s-node1 ~]$ sudo gedit /usr/lib/systemd/system/kube-proxy.service

编写文件内容并保存如下：

[Unit]
Description=Kubernetes Proxy
After=network.target

[Service]
User=root
Group=root
EnvironmentFile=/usr/local/kubernetes/node/etc/kube-proxy.conf
ExecStart=/usr/local/kubernetes/node/bin/kube-proxy $KUBE_PROXY_OPTS
Restart=on-failure
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target

16、启动 Proxy 服务并设置开机自启动。

[centos@k8s-node1 ~]$ sudo systemctl daemon-reload
[centos@k8s-node1 ~]$ sudo systemctl start kube-proxy.service
[centos@k8s-node1 ~]$ sudo systemctl enable kube-proxy.service
[centos@k8s-node1 ~]$ sudo systemctl status kube-proxy.service

注意：其他"Node 工作节点"上全部需要按照以上步骤配置。

17、在集群启用 TLS Bootstrapping 机制时，当 Kubelet 启动后，会自动向 Master 节点发起证书申请，当 Master 节点批准申请后，Node 节点才能加入到集群中。因此，当有新的 Node 工作节点部署完成并启动 Kubelet 后，需要在 Master 节点上批准该 Node 节点的证书申请。

注意：以下操作在 Node 工作节点的 Kubelet 正常启动后，到 Master 主控节点上执行：

1）查看 Node 工作节点发起的证书申请：

[centos@k8s-master1 ~]$ kubectl get csr
NAME                                                   AGE    SIGNERNAME                                    REQUESTOR           CONDITION
node-csr-w-cAh8lsq4EFbT8IVFHIX1DtrncqzwTKYOqV9R4Hwus   101m   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Pending
node-csr-z0cIayC5dTJwl38XU2wsB3oQOLocpaSNd9Svg21mceQ   106m   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Pending

说明：
【NAME】表示“申请名称”。
【CONDITION】表示“处理步骤”。"Pending" 表示 “待申请”；"Pending,Issued" 表示 “待申请，已批准”。

2）批准 Node 工作节点发起的证书申请：

[centos@k8s-master1 ~]$ kubectl certificate approve node-csr-w-cAh8lsq4EFbT8IVFHIX1DtrncqzwTKYOqV9R4Hwus

certificatesigningrequest.certificates.k8s.io/node-csr-w-cAh8lsq4EFbT8IVFHIX1DtrncqzwTKYOqV9R4Hwus approved

[centos@k8s-master1 ~]$ kubectl certificate approve node-csr-z0cIayC5dTJwl38XU2wsB3oQOLocpaSNd9Svg21mceQ

certificatesigningrequest.certificates.k8s.io/node-csr-z0cIayC5dTJwl38XU2wsB3oQOLocpaSNd9Svg21mceQ approved

命令格式：kubectl certificate approve <申请名称>

3）查看 Node 工作节点发起的证书申请结果：

[centos@k8s-master1 ~]$ kubectl get csr
NAME                                                   AGE    SIGNERNAME                                    REQUESTOR           CONDITION
node-csr-w-cAh8lsq4EFbT8IVFHIX1DtrncqzwTKYOqV9R4Hwus   106m   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Approved,Issued
node-csr-z0cIayC5dTJwl38XU2wsB3oQOLocpaSNd9Svg21mceQ   111m   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Approved,Issued

4）查看 Node 工作节点的状态：

[centos@k8s-master1 ~]$ kubectl get node
NAME        STATUS     ROLES    AGE     VERSION
k8s-node1   NotReady   <none>   5m55s   v1.18.8
k8s-node2   NotReady   <none>   6m31s   v1.18.8

注意：
证书申请审批通过后，可以在 Master 主控节点上查看各 Node 工作节点的状态。【STATUS】为“NotReady”，表示 Node 工作节点是“没有准备就绪”状态，这是因为还没有配置集群 CNI 网络，在 CNI 网络配置完成后，Node 工作节点才能准备就绪。

8.CNI 容器网络（Flannel 插件）部署

在 Master 主控集群的任意一个节点部署一次 Flannel 插件即可。

有关如何安装和配置 Flannel 插件，请阅读文章《云架构之【Kubernetes（K8s）】第二部分：单主控集群部署》的 “7.CNI 容器网络（Flannel 插件）部署” 章节，文章地址【https://www.jianshu.com/p/8824575f2fe0】。

9.DNS 域名发现（CoreDNS 插件）部署

在 Master 主控集群的任意一个节点部署一次 CoreDNS 插件即可。

有关如何安装和配置 Flannel 插件，请阅读文章《云架构之【Kubernetes（K8s）】第二部分：单主控集群部署》的 “8.DNS 域名发现（CoreDNS 插件）部署” 章节，文章地址【https://www.jianshu.com/p/8824575f2fe0】。

10.用户管理界面（Dashboard 插件）部署

在 Master 主控集群的任意一个节点部署一次 Dashboard 插件即可。

有关如何安装和配置 Flannel 插件，请阅读文章《云架构之【Kubernetes（K8s）】第二部分：单主控集群部署》的 “9.用户管理界面（Dashboard 插件）部署” 章节，文章地址【https://www.jianshu.com/p/8824575f2fe0】。

云原生架构之【Kubernetes（K8s）】第三部分：多主控高

1.部署拓扑图

2.操作系统初始化

3.证书服务器的安装和配置

4.Etcd 数据库集群部署

5.Master 主控集群部署

5.1.第一个 Master 主控节点部署

5.2.其他 Master 主控节点部署

6.Master 高可用集群部署

6.1.Nginx 安装和配置

6.2.Keepalived 安装和配置

7.Node 工作集群部署

8.CNI 容器网络（Flannel 插件）部署

9.DNS 域名发现（CoreDNS 插件）部署

10.用户管理界面（Dashboard 插件）部署

猜你喜欢

热点阅读