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

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

1.部署拓扑图

云原生架构之【Kubernetes（K8s）】第二部分：单主控集群部署_第1张图片

K8s Master 单点集群拓扑图

网络资源规划：

1、Master 主控节点

主机名：k8s-master
IP：192.168.0.20
程序：kube-apiserver，kube-controllermanager，kube-scheduler
操作系统：CentOS8

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

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

4、SSL 证书服务器

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

5、K8s 集群网络

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

2.操作系统初始化

以 "主控节点" 为例，初始化各个主控节点、工作节点、Etcd 节点的操作系统配置：

1、关闭防火墙。

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

2、关闭 SELinux。

1）临时关闭 SELinux。

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

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

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

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

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

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

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

1）临时关闭 Swap。

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

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

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

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

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

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

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

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

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

2）设置时间同步配置：

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

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

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

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

5、设置主机名。

1）临时设置主机名。

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

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

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

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

修改主机名并保存：

k8s-master

6、设置静态 IP 地址。

设置静态 IP 地址

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

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

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

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

192.168.0.20 k8s-master
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-master ~]$ 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
  "hosts": [
    "127.0.0.1",
    "10.0.0.1",
    "192.168.0.20",
    "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 [email protected]
[email protected]'s password:
[centos@k8s-ssl ~]$ scp -r /data/ssl/k8s/ca/ca.pem [email protected]:/usr/local/etcd-v3.4.10/ssl
[email protected]'s password:
ca.pem                                                                              100% 1346     1.7MB/s   00:00
[centos@k8s-ssl ~]$ scp -r /data/ssl/k8s/etcd/etcd.pem [email protected]:/usr/local/etcd-v3.4.10/ssl
[email protected]'s password:
etcd.pem                                                                            100% 1428    43.5KB/s   00:00
[centos@k8s-ssl ~]$ scp -r /data/ssl/k8s/etcd/etcd-key.pem [email protected]:/usr/local/etcd-v3.4.10/ssl
[email protected]'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 主控节点部署

在 Master 主控节点上执行以下操作步骤：

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-master ~]$ sudo tar zxvf kubernetes-server-linux-amd64.tar.gz -C /usr/local
[centos@k8s-master ~]$ 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-master ~]$ sudo ln -s /usr/local/kubernetes/server/bin/kubectl /usr/bin/kubectl

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

[centos@k8s-master ~]$ 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-master ~]$ ssh [email protected]
[email protected]'s password:
[centos@k8s-ssl ~]$ scp -r /data/ssl/k8s/ca/ca.pem [email protected]:/usr/local/kubernetes/server/ssl
[email protected]'s password:
ca.pem                                                                                        100% 1346     1.5MB/s   00:00
[centos@k8s-ssl ~]$ scp -r /data/ssl/k8s/ca/ca-key.pem [email protected]:/usr/local/kubernetes/server/ssl
[email protected]'s password:
ca-key.pem                                                                                    100% 1675   850.9KB/s   00:00
[centos@k8s-ssl ~]$ scp -r /data/ssl/k8s/server/server.pem [email protected]:/usr/local/kubernetes/server/ssl
[email protected]'s password:
server.pem                                                                                    100% 1419   510.0KB/s   00:00
[centos@k8s-ssl ~]$ scp -r /data/ssl/k8s/server/server-key.pem [email protected]:/usr/local/kubernetes/server/ssl
[email protected]'s password:
server-key.pem                                                                                100% 1675     1.2MB/s   00:00
[centos@k8s-ssl ~]$ scp -r /data/ssl/k8s/etcd/etcd.pem [email protected]:/usr/local/kubernetes/server/ssl
[email protected]'s password:
etcd.pem                                                                                      100% 1428     1.8MB/s   00:00
[centos@k8s-ssl ~]$ scp -r /data/ssl/k8s/etcd/etcd-key.pem [email protected]:/usr/local/kubernetes/server/ssl
[email protected]'s password:
etcd-key.pem                                                                                  100% 1675     1.3MB/s   00:00
[centos@k8s-ssl ~]$ exit

[centos@k8s-master ~]$ sudo chmod 644 /usr/local/kubernetes/server/ssl/*
[centos@k8s-master ~]$ 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-master ~]$ head -c 16 /dev/urandom | od -An -t x | tr -d ' '
d682ded2c1468b8c6a16375b48a638ff

2）创建 Token 配置文件：

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

[centos@k8s-master ~]$ 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-master ~]$ 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.20 \
--insecure-port=8080 \
--secure-port=6443 \
--advertise-address=192.168.0.20 \
--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-master ~]$ 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-master ~]$ sudo systemctl daemon-reload
[centos@k8s-master ~]$ sudo systemctl start kube-apiserver.service
[centos@k8s-master ~]$ sudo systemctl enable kube-apiserver.service
[centos@k8s-master ~]$ sudo systemctl status kube-apiserver.service

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

[centos@k8s-master ~]$ 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-master ~]$ 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-master ~]$ 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-master ~]$ sudo systemctl daemon-reload
[centos@k8s-master ~]$ sudo systemctl start kube-controller-manager.service
[centos@k8s-master ~]$ sudo systemctl enable kube-controller-manager.service
[centos@k8s-master ~]$ sudo systemctl status kube-controller-manager.service

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

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

[centos@k8s-master ~]$ 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-master ~]$ 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-master ~]$ sudo systemctl daemon-reload
[centos@k8s-master ~]$ sudo systemctl start kube-scheduler.service
[centos@k8s-master ~]$ sudo systemctl enable kube-scheduler.service
[centos@k8s-master ~]$ sudo systemctl status kube-scheduler.service

16、查看集群状态。

[centos@k8s-master ~]$ 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-master ~]$ sudo systemctl daemon-reload
[centos@k8s-master ~]$ sudo systemctl start kube-apiserver.service
[centos@k8s-master ~]$ sudo systemctl start kube-controller-manager.service
[centos@k8s-master ~]$ 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-master ~]$ 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-master ~]$ 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

6.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 [email protected]
[email protected]'s password:
[centos@k8s-ssl ~]$ scp -r /data/ssl/k8s/ca/ca.pem [email protected]:/usr/local/kubernetes/node/ssl
[email protected]'s password:
ca.pem                                                                                     100% 1346   173.3KB/s   00:00
[centos@k8s-ssl ~]$ scp -r /data/ssl/k8s/proxy/proxy.pem [email protected]:/usr/local/kubernetes/node/ssl
[email protected]'s password:
proxy.pem                                                                                  100% 1387   640.8KB/s   00:00
[centos@k8s-ssl ~]$ scp -r /data/ssl/k8s/proxy/proxy-key.pem [email protected]:/usr/local/kubernetes/node/ssl
[email protected]'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.20:6443 \
--kubeconfig=/usr/local/kubernetes/node/etc/bootstrap.kubeconfig

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

参数：

--server：连接的 Master 集群或单点的 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.20: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.20:6443 \
--kubeconfig=/usr/local/kubernetes/node/etc/kube-proxy.kubeconfig

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

参数：

--server：连接的 Master 集群或单点的 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.20: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-master ~]$ 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-master ~]$ kubectl certificate approve node-csr-w-cAh8lsq4EFbT8IVFHIX1DtrncqzwTKYOqV9R4Hwus

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

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

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

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

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

[centos@k8s-master ~]$ 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-master ~]$ kubectl get node
NAME        STATUS     ROLES    AGE     VERSION
k8s-node1   NotReady      5m55s   v1.18.8
k8s-node2   NotReady      6m31s   v1.18.8

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

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

使用 Flannel 插件实现 K8s 的 CNI 容器网络。在 Master 主控节点上执行以下操作步骤：

1、打开 Flannel 下载页面【https://github.com/coreos/flannel】，下载 Flannel 配置文件到 K8s Server 的配置目录。

1）打开 Flannel 下载页面，查询配置文件下载地址：

云原生架构之【Kubernetes（K8s）】第二部分：单主控集群部署_第2张图片

Flannel 配置文件下载页面

2）下载配置文件到 K8s Server 的配置目录。**

[centos@k8s-master ~]$ sudo wget https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml -O /usr/local/kubernetes/server/etc/kube-flannel.yml

2、验证文件内容（一般使用默认配置即可）。

使用文本编辑器打开 "/usr/local/kubernetes/server/etc/kube-flannel.yml"：

[centos@k8s-master ~]$ sudo gedit /usr/local/kubernetes/server/etc/kube-flannel.yml

验证集群内部子网段配置内容：

---
kind: ConfigMap
apiVersion: v1
...
data:
  ...
  net-conf.json: |
    {
      # Pod 的 CNI 网络地址段
      "Network": "10.254.0.0/16",
      "Backend": {
        "Type": "vxlan"
      }
    }

验证 Flannel 镜像：

---
apiVersion: apps/v1
# DaemonSet 类型的镜像会在所有的 Node 工作节点中部署。
kind: DaemonSet
...
spec:
  ...
  template:
    ...
    spec:
      ...
      # 设置为 true 表示使用宿主机的网络空间，设置为 false 或不设置表示使用容器内部的网络空间。
      hostNetwork: true
      ...
      initContainers:
      - name: install-cni
        # Pod 镜像名称
        image: quay.io/coreos/flannel:v0.12.0-amd64
        ...
      containers:
      - name: kube-flannel
        # Pod 镜像名称
        image: quay.io/coreos/flannel:v0.12.0-amd64
        ...

注意：
部署后，Node 工作节点会检查本地节点是否已存在镜像，如果不存在则会自动从 Docker Hub 中下载镜像。

如果部署在互联网中，由于国外的 Docker Hub 限速会导致长时间部署不成功，建议通过 Docker 将镜像下载到所有的 Node 工作节点本地仓库后再部署。

如果部署在隔离网络中，需要首先在能够连接互联网且装有 docker 的代理主机上拉取镜像到本地，然后从代理主机上将镜像导入到所有的 Node 工作节点上。

Docker 获取镜像的指令：
docker pull quay.io/coreos/flannel:v0.12.0-amd64

镜像官方下载网站【https://github.com/coreos/flannel/releases】，下载在文件 "flanneld-v0.12.0-amd64.docker"。
Docker 导入下载镜像的指令：
docker load < flanneld-v0.12.0-amd64.docker

如何安装 Docker 及拉取、导出、导入镜像，请阅读文章《RedHat/CentOS8【Docker】镜像制作编排和容器部署》【https://www.jianshu.com/p/a4198b127729】。

3、部署（更新） YAML 文件。

[centos@k8s-master ~]$ kubectl apply -f /usr/local/kubernetes/server/etc/kube-flannel.yml

podsecuritypolicy.policy/psp.flannel.unprivileged created
clusterrole.rbac.authorization.k8s.io/flannel created
clusterrolebinding.rbac.authorization.k8s.io/flannel created
serviceaccount/flannel created
configmap/kube-flannel-cfg created
daemonset.apps/kube-flannel-ds-amd64 created
daemonset.apps/kube-flannel-ds-arm64 created
daemonset.apps/kube-flannel-ds-arm created
daemonset.apps/kube-flannel-ds-ppc64le created
daemonset.apps/kube-flannel-ds-s390x created

4、查看 Flannel Pod 的运行状态。

[centos@k8s-master ~]$ kubectl get pod -n kube-system -o wide

NAME                          READY   STATUS    RESTARTS   AGE
kube-flannel-ds-amd64-cghgt   1/1     Running            34         2d18h   192.168.0.32   k8s-node2              
kube-flannel-ds-amd64-csl5q   0/1     Running            33         2d18h   192.168.0.31   k8s-node1

注意：【STATUS】为“Running”时，表示正常运行。

5、查看 Flannel Pod 的详细信息和事件。

[centos@k8s-master ~]$ kubectl describe pod kube-flannel-ds-amd64-cghgt -n kube-system

6、查看 Flannel 容器的日志。

[centos@k8s-master ~]$ kubectl logs kube-flannel-ds-amd64-cghgt -n kube-system

7、查看 Node 工作节点的状态。

[centos@k8s-master ~]$ kubectl get node
NAME        STATUS   ROLES    AGE   VERSION
k8s-node1   Ready       23h   v1.18.8
k8s-node2   Ready       23h   v1.18.8

注意：
CNI 网络部署完成后，可以在 Master 主控节点上查看各 Node 工作节点的状态。【STATUS】为“Ready”，表示 Node 工作节点是“准备就绪”状态。

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

1、验证 "flannel.1" 网卡，所有 Node 工作节点的 CIN 流量通过 "flannel.1" 网卡转发。

[centos@k8s-node1 ~]$ ifconfig
flannel.1: flags=4163  mtu 1450
        inet 10.254.1.0  netmask 255.255.255.255  broadcast 0.0.0.0
        inet6 fe80::cf2:7eff:fea3:fa18  prefixlen 64  scopeid 0x20
        ether 0e:f2:7e:a3:fa:18  txqueuelen 0  (Ethernet)
        RX packets 0  bytes 0 (0.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 548 overruns 0  carrier 0  collisions 0

如已正常创建 "flannel.1" 网卡表示 CIN 网络部署成功。

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

使用 CoreDNS 插件实现 K8s 的容器内部的域名发现服务，部署 CoreDNS 插件后，容器之间能够通过以下方式相互获取服务：
1）http(s)://:
2）http(s)://:.svc
3）http(s)://:.svc.cluster.local

在 Master 主控节点上执行以下操作步骤：

1、打开 K8s 的 CoreDNS YAML 配置内容页面【https://github.com/kubernetes/kubernetes/blob/master/cluster/addons/dns/coredns/coredns.yaml.sed】，拷贝内容并在 K8s Server 的配置目录中创建 CoreDNS 的 YAML 文件。

1）打开 K8s 的 CoreDNS YAML 配置内容页面，拷贝文件内容：

云原生架构之【Kubernetes（K8s）】第二部分：单主控集群部署_第3张图片

CoreDNS 插件配置文件下载页面

云原生架构之【Kubernetes（K8s）】第二部分：单主控集群部署_第4张图片

全选并拷贝文件内容

2）在 K8s Server 的配置目录创建配置文件：

使用文本编辑器创建文件，将 K8s 网站提供的 CoreDNS YAML 配置内容拷贝到文件中：

[centos@k8s-master ~]$ sudo gedit /usr/local/kubernetes/server/etc/coredns.yaml

3）修改文件中的以下变量：

# 将变量【$DNS_DOMAIN】改为 【cluster.local】。【$DNS_DOMAIN】表示集群根域名， Kubelet 核心配置文件的【clusterDomain】属性的值应与变量【$DNS_DOMAIN】一致。

---
apiVersion: v1
kind: ConfigMap
...
data:
  Corefile: |
    .:53 {
        ...
        # kubernetes $DNS_DOMAIN in-addr.arpa ip6.arpa
        kubernetes cluster.local in-addr.arpa ip6.arpa {
            pods insecure
            fallthrough in-addr.arpa ip6.arpa
            ttl 30
        }
        ...
    }

# 1.将变量【$DNS_MEMORY_LIMIT】改为【512Mi】。【$DNS_MEMORY_LIMIT】表示内存上限。
# 2.修改 CoreDNS 镜像为【coredns/coredns:1.7.0】

---
apiVersion: apps/v1
kind: Deployment
...
spec:
  ...
  template:
    ...
    spec:
      ...
      containers:
      - name: coredns
        # image: k8s.gcr.io/coredns:1.7.0
        image: coredns/coredns:1.7.0
        imagePullPolicy: IfNotPresent
        resources:
          limits:
            # memory: $DNS_MEMORY_LIMIT
            memory: 512Mi
          ...
        ...

注意：
部署后，Node 工作节点会检查本地节点是否已存在镜像，如果不存在则会自动从 Docker Hub 中下载镜像。

如果部署在互联网中，由于国外的 Docker Hub 限速会导致长时间部署不成功，建议通过 Docker 将镜像下载到所有的 Node 工作节点本地仓库后再部署。

如果部署在隔离网络中，需要首先在能够连接互联网且装有 docker 的代理主机上拉取镜像到本地，然后从代理主机上将镜像导入到所有的 Node 工作节点上。

Docker 获取镜像的指令：
docker pull coredns/coredns:1.7.0

如何安装 Docker 及拉取、导出、导入镜像，请阅读文章《RedHat/CentOS8【Docker】镜像制作编排和容器部署》【https://www.jianshu.com/p/a4198b127729】。

将变量【$DNS_SERVER_IP】改为 【10.0.0.2】。【$DNS_SERVER_IP】表示 DNS 服务器的 IP 地址， Kubelet 核心配置文件的【clusterDNS】属性的值应与变量【$DNS_SERVER_IP】一致。

---
apiVersion: v1
kind: Service
...
spec:
  ...
  # clusterIP: $DNS_SERVER_IP
  clusterIP: 10.0.0.2
  ...

3、部署（更新） YAML 文件。

[centos@k8s-master ~]$ kubectl apply -f /usr/local/kubernetes/server/etc/coredns.yaml

serviceaccount/coredns created
clusterrole.rbac.authorization.k8s.io/system:coredns created
clusterrolebinding.rbac.authorization.k8s.io/system:coredns created
configmap/coredns created
deployment.apps/coredns created
service/kube-dns created

4、查看 CoreDNS Pod 的运行状态。

[centos@k8s-master ~]$ kubectl get pod -n kube-system -o wide

NAME                              READY   STATUS    RESTARTS   AGE   IP             NODE        NOMINATED NODE   READINESS GATES
pod/coredns-66d85b58dc-k4b7z      1/1     Running   229        47h   10.254.0.6     k8s-node2

注意：【STATUS】为“Running”时，表示正常运行。

5、查看 CoreDNS Service 的详细信息。

[centos@k8s-master ~]$ kubectl get svc -n kube-system -o wide

NAME               TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)                  AGE   SELECTOR
service/kube-dns   ClusterIP   10.0.0.2             53/UDP,53/TCP,9153/TCP   47h   k8s-app=kube-dns

6、查看 CoreDNS Pod 的详细信息和事件。

[centos@k8s-master ~]$ kubectl describe pod coredns-6f655b5d5-pqg5n -n kube-system

7、查看 CoreDNS 容器的日志信息。

[centos@k8s-master ~]$ kubectl logs coredns-6f655b5d5-pqg5n -n kube-system

8、通过创建 busybox 容器（退出时自动删除该容器）测试 CoreDNS 。

[centos@k8s-master ~]$ kubectl run -it --rm dns-test --image=busybox:1.28.4 sh
/ # nslookup kubernetes
Server:    10.0.0.2
Address 1: 10.0.0.2 kube-dns.kube-system.svc.cluster.local

Name:      kubernetes
Address 1: 10.0.0.1 kubernetes.default.svc.cluster.local
/ # nslookup kubernetes-dashboard
Server:    10.0.0.2
Address 1: 10.0.0.2 kube-dns.kube-system.svc.cluster.local

注意：
创建 busybox 容器前，Node 工作节点会检查本地节点是否已存在镜像，如果不存在则会自动从 Docker Hub 中下载镜像。

如果在互联网中，由于国外的 Docker Hub 限速会导致长时间部署不成功，建议通过 Docker 将镜像下载到所有的 Node 工作节点本地仓库后再创建容器。

如果部署在隔离网络中，需要首先在能够连接互联网且装有 docker 的代理主机上拉取镜像到本地，然后从代理主机上将镜像导入到所有的 Node 工作节点上。

Docker 获取镜像的指令：
docker pull busybox:1.28.4

如何安装 Docker 及拉取、导出、导入镜像，请阅读文章《RedHat/CentOS8【Docker】镜像制作编排和容器部署》【https://www.jianshu.com/p/a4198b127729】。

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

使用 Dashboard 插件实现 K8s 的可视化监控和管理。在 Master 主控节点上执行以下操作步骤：

1、打开 Dashboard 下载页面【https://github.com/kubernetes/dashboard】，下载 Dashboard 配置文件到 K8s Server 的配置目录。

1）打开 Dashboard 下载页面，查询配置文件下载地址：

云原生架构之【Kubernetes（K8s）】第二部分：单主控集群部署_第5张图片

Dashboard 配置文件下载页面

2）下载配置文件到 K8s Server 的配置目录。**

[centos@k8s-master ~]$ sudo wget https://raw.githubusercontent.com/kubernetes/dashboard/v2.0.3/aio/deploy/recommended.yaml -O /usr/local/kubernetes/server/etc/dashboard.yaml

2、修改配置文件 "dashboard.yaml"，默认 Dashboard 只能集群内部访问，暴露 Dashboard 外部访问端口。

使用文本编辑器打开 "/usr/local/kubernetes/server/etc/dashboard.yaml"：

[centos@k8s-master ~]$ sudo gedit /usr/local/kubernetes/server/etc/dashboard.yaml

增加 Dashboard 外部访问端口配置内容（删除注释）：

---
kind: Service
apiVersion: v1
...
spec:
  ports:
    - port: 443
      targetPort: 8443
      # 增加【nodePort】属性，设置值为暴露到外部网络的端口号
      nodePort: 30001
  # 增加【type】属性，设置值 "NodePort"
  type: NodePort
  ...

验证 Dashboard 镜像：

---

kind: Deployment
apiVersion: apps/v1
...
spec:
  ...
  template:
    ...
    spec:
      containers:
        - name: kubernetes-dashboard
          image: kubernetesui/dashboard:v2.0.3
          ...

---

kind: Deployment
apiVersion: apps/v1
...
spec:
  ...
  template:
    ...
    spec:
      containers:
        - name: dashboard-metrics-scraper
          image: kubernetesui/metrics-scraper:v1.0.4
          ...

注意：
部署后，Node 工作节点会检查本地节点是否已存在镜像，如果不存在则会自动从 Docker Hub 中下载镜像。

如果部署在互联网中，由于国外的 Docker Hub 限速会导致长时间部署不成功，建议通过 Docker 将镜像下载到所有的 Node 工作节点本地仓库后再部署。

如果部署在隔离网络中，需要首先在能够连接互联网且装有 docker 的代理主机上拉取镜像到本地，然后从代理主机上将镜像导入到所有的 Node 工作节点上。

Docker 获取镜像的指令：
docker pull kubernetesui/dashboard:v2.0.3
docker pull kubernetesui/metrics-scraper:v1.0.4

如何安装 Docker 及拉取、导出、导入镜像，请阅读文章《RedHat/CentOS8【Docker】镜像制作编排和容器部署》【https://www.jianshu.com/p/a4198b127729】。

3、部署（更新） YAML 文件。

[centos@k8s-master ~]$ kubectl apply -f /usr/local/kubernetes/server/etc/dashboard.yaml

namespace/kubernetes-dashboard created
serviceaccount/kubernetes-dashboard created
service/kubernetes-dashboard created
secret/kubernetes-dashboard-certs created
secret/kubernetes-dashboard-csrf created
secret/kubernetes-dashboard-key-holder created
configmap/kubernetes-dashboard-settings created
role.rbac.authorization.k8s.io/kubernetes-dashboard created
clusterrole.rbac.authorization.k8s.io/kubernetes-dashboard created
rolebinding.rbac.authorization.k8s.io/kubernetes-dashboard created
clusterrolebinding.rbac.authorization.k8s.io/kubernetes-dashboard created
deployment.apps/kubernetes-dashboard created
service/dashboard-metrics-scraper created
deployment.apps/dashboard-metrics-scraper created

4、查看 Dashboard Pod 的运行状态。

[centos@k8s-master ~]$ kubectl get pod -n kubernetes-dashboard -o wide

NAME                          READY   STATUS    RESTARTS   AGE
dashboard-metrics-scraper-6b4884c9d5-f9n59   1/1     Running   2          6m16s   10.254.1.5   k8s-node1              
kubernetes-dashboard-7f99b75bf4-xdg5f        1/1     Running   1          6m16s   10.254.0.3   k8s-node2

注意：【STATUS】为“Running”时，表示正常运行。

5、查看 Dashboard Service 的详细信息。

[centos@k8s-master ~]$ kubectl get svc -n kubernetes-dashboard -o wide

NAME                        TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)         AGE   SELECTOR
dashboard-metrics-scraper   ClusterIP   10.0.0.3             8000/TCP        36m   k8s-app=dashboard-metrics-scraper
kubernetes-dashboard        NodePort    10.0.0.8             443:30001/TCP   36m   k8s-app=kubernetes-dashboard

6、查看 Dashboard Pod 的详细信息和事件。

[centos@k8s-master ~]$ kubectl describe pod kubernetes-dashboard-7f99b75bf4-xdg5f -n kubernetes-dashboard

7、查看 Dashboard 容器的日志。

[centos@k8s-master ~]$ kubectl logs kubernetes-dashboard-7f99b75bf4-xdg5f -n kubernetes-dashboard

8、创建 Dashboard 访问 K8s 的服务账号，并设置角色为集群管理员。

1）创建账号 "dashboard-admin"：

[centos@k8s-master ~]$ kubectl create serviceaccount dashboard-admin -n kube-system

2）将账号绑定到系统管理员角色：

[centos@k8s-master ~]$ kubectl create clusterrolebinding dashboard-admin --clusterrole=cluster-admin --serviceaccount=kube-system:dashboard-admin

clusterrolebinding.rbac.authorization.k8s.io/dashboard-admin created

3）查询账号的 Token 信息：

[centos@k8s-master ~]$ kubectl describe secrets -n kube-system $(kubectl -n kube-system get secret | awk '/dashboard-admin/{print $1}')

Name:         dashboard-admin-token-qf8dl
Namespace:    kube-system
Labels:       
Annotations:  kubernetes.io/service-account.name: dashboard-admin
              kubernetes.io/service-account.uid: 74b47202-7a66-4c06-9caa-8738fdc7f598

Type:  kubernetes.io/service-account-token

Data
====
ca.crt:     1346 bytes
namespace:  11 bytes
token:      eyJhbGciOiJSUzI1NiIsImtpZCI6IlJPTmVud25mdGdBaGdzTWNhQ1BoVEdacUJLdmR2cXNJMUV3aUZEZmNqYWsifQ....

将【token】属性的设置值提取出来：

eyJhbGciOiJSUzI1NiIsImtpZCI6IlJPTmVud25mdGdBaGdzTWNhQ1BoVEdacUJLdmR2cXNJMUV3aUZEZmNqYWsifQ....

9、通过浏览器访问 Dashboard，访问地址为【https://任意 Node 工作节点 IP 地址:暴露端口号】，在本方案中可以通过【https://192.168.0.31:30001】或者【https://192.168.0.32:30001】任意地址打开 Dashboard。

注意：如果在 Node 工作节点的主机上访问，还可以通过【https://服务 IP 地址:内部端口号】，在本方案中可以通过【https://10.0.0.8:443】打开 Dashboard**。

云原生架构之【Kubernetes（K8s）】第二部分：单主控集群部署_第6张图片

Dashboard 登录认证页面

选择登录 Dashboard 的认证方式 "Token" 后，拷贝从上一步骤中【token】属性提取的值，并粘贴到 Token 输入框中，点击 "登录" 按钮。

云原生架构之【Kubernetes（K8s）】第二部分：单主控集群部署_第7张图片

Dashboard 主页面

云原生架构之【Kubernetes（K8s）】第二部分：单主控集群部署

1.部署拓扑图

2.操作系统初始化

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

4.Etcd 数据库集群部署

5.Master 主控节点部署

6.Node 工作集群部署

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

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

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

你可能感兴趣的:(云原生架构之【Kubernetes（K8s）】第二部分：单主控集群部署)