二进制安装k8s超详细版本-V1.20

一、环境说明

此环境下需要6台主机，主机地址和角色如下表所示：

主机名	IP地址	集群角色
master1	172.16.213.225	k8s master1
master2	172.16.213.229	k8s master2
master3	172.16.213.230	k8s master3
node1	172.16.213.231	k8s slave1
node2	172.16.213.235	k8s slave2
lbserver	172.16.213.236	k8s master vip

在这个环境中，k8s集群我们采用三个master节点，两个node节点，其中，三个master节点通过haproxy实现k8s-api的负载均衡。

二、系统基础配置

1、内核升级

k8s在较低内核中存在某些bug，因此需要先升级下系统内核。建议使用4.10或以上版本内核，在master1/2/3和node1/2主机上依次执行如下操作，升级过程如下：

#升级内核：

[root@master1 kernel]# wget

https://elrepo.org/linux/kernel/el7/x86_64/RPMS/kernel-ml-5.10.3-1.el7.elrepo.x86_64.rpm https://elrepo.org/linux/kernel/el7/x86_64/RPMS/kernel-ml-devel-5.10.3-1.el7.elrepo.x86_64.rpm

[root@master1 kernel]# yum -y install kernel-ml-5.10.3-1.el7.elrepo.x86_64.rpm kernel-ml-devel-5.10.3-1.el7.elrepo.x86_64.rpm

# 调整默认内核启动

[root@master1 kernel]# cat /boot/grub2/grub.cfg |grep menuentry

[root@master1 kernel]# grub2-set-default "CentOS Linux (5.10.3-1.el7.elrepo.x86_64) 7 (Core)"

# 检查是否修改正确

[root@master1 kernel]# grub2-editenv list

[root@master1 kernel]# reboot

2、开启IPVS支持

内核升级完成后，首先确认内核版本是否正确，执行如下命令；

[root@master1 kernel]# uname -a

接着，创建/etc/sysconfig/modules/ipvs.modules文件，内容如下：

#!/bin/bash

ipvs_modules="ip_vs ip_vs_lc ip_vs_wlc ip_vs_rr ip_vs_wrr ip_vs_lblc ip_vs_lblcr ip_vs_dh ip_vs_sh ip_vs_fo ip_vs_nq ip_vs_sed ip_vs_ftp nf_conntrack"

for kernel_module in ${ipvs_modules}; do

/sbin/modinfo -F filename ${kernel_module} > /dev/null 2>&1

if [ $? -eq 0 ]; then

/sbin/modprobe ${kernel_module}

done

最后，执行如下命令使配置生效：

[root@master1 kernel]# chmod 755 /etc/sysconfig/modules/ipvs.modules

[root@master1 kernel]# sh /etc/sysconfig/modules/ipvs.modules

[root@master1 kernel]# lsmod | grep ip_vs

如果执行lsmod命令能看到ip_vs相关模块信息，表明ipvs开启成功。

3、关闭防火墙、swap设置

K8s集群每个节点都需要关闭防火墙，执行如下操作：

[root@master1 kernel]# systemctl stop firewalld && systemctl disable firewalld

[root@master1 kernel]# setenforce 0

[root@master1 kernel]# sed -i "s/SELINUX=enforcing/SELINUX=disabled/g" /etc/selinux/config

接着，还需要关闭系统的交换分区，执行如下命令：

[root@master1 kernel]# swapoff -a

[root@master1 kernel]# cp /etc/fstab /etc/fstab.bak

[root@master1 kernel]# cat /etc/fstab.bak | grep -v swap > /etc/fstab

然后，还需要修改iptables设置，在/etc/sysctl.conf中添加如下内容：

vm.swappiness = 0

net.bridge.bridge-nf-call-iptables = 1

net.ipv4.ip_forward = 1

net.bridge.bridge-nf-call-ip6tables = 1

最后，执行如下命令，以使设置生效：

[root@master1 kernel]# sysctl -p

4、主机免密钥登录

免密钥登录不是必须的，配置免密钥是为了后面在节点之间拷贝数据方便，在任意一个master主机上设置到其它所有集群节点的无密码登录，这里选择master1节点，操作过程如下：

[root@master1 ~]# ssh-keygen

[root@master1 ~]# ssh-copy-id [email protected]

[root@master1 ~]# ssh-copy-id

[email protected]

[root@master1 ~]# ssh-copy-id [email protected]

配置完成，在master1节点进行无密码登录其它节点的测试，看是否有问题。

5、主机名解析配置

每个主机的主机名以及IP地址都在上面环境介绍中给出来了，根据这些信息，在每个k8s集群节点添加如下主机名解析信息，将这些信息添加到每个集群节点的/etc/hosts文件中，主机名解析内容如下：

172.16.213.225 master1

172.16.213.229 master2

172.16.213.230 master3

172.16.213.231 node1

172.16.213.235 node2

172.16.213.236 lbserver

三、给k8s组件签发证书

1、获取证书签发工具

这里我们需要用到用到cfssl工具和cfssljson工具，下面简单介绍下CFSSL，CFSSL是一款开源的PKI/TLS工具。 CFSSL包含一个命令行工具和一个用于签名、验证并且捆绑TLS证书的HTTP API服务。使用Go语言编写。

CFSSL包括：

l 一组用于生成自定义TLS PKI的工具

l cfssl程序，是CFSSL的命令行工具

l multirootca程序是可以使用多个签名密钥的证书颁发机构服务器

l mkbundle程序用于构建证书池

l cfssljson程序，从cfssl和multirootca程序获取JSON输出，并将证书，密钥，CSR和bundle写入磁盘

这里我们只用到cfssl和cfssljson工具，大家可从

https://github.com/cloudflare/cfssl/releases/

下载相应的版本，这里我下载的是1.5.0版本。

[root@master1 setup]#

https://github.com/cloudflare/cfssl/releases/download/v1.5.0/cfssl_1.5.0_linux_amd64 https://github.com/cloudflare/cfssl/releases/download/v1.5.0/cfssljson_1.5.0_linux_amd64

[root@master1 setup]# mv cfssl_1.5.0_linux_amd64 /usr/local/bin/cfssl

[root@master1 setup]# mv cfssljson_1.5.0_linux_amd64 /usr/local/bin/cfssljson

接下来，就可以签发证书了，需要签发证书的组件有admin用户、kube-controller-manager、kubelet、kube-proxy、kube-scheduler和kube-api。

2、创建CA证书

（1）、创建证书生成策略文件

配置证书生成策略，让CA软件知道颁发有什么功能的证书。先创建一个json格式文件ca-config.json，内容如下：

[root@master1 k8s]# cat ca-config.json

{

"signing": {

"default": {

"expiry": "87600h"

"profiles": {

"kubernetes": {

"usages": ["signing", "key encipherment", "server auth", "client auth"],

"expiry": "87600h"

}

这个策略，有一个default默认的配置，和一个profiles，profiles可以设置多个profile，这里的profile是etcd。

default默认策略，指定了证书的默认有效期是一年(8760h)。

kubernetes：表示该配置(profile)的用途是为kubernetes生成证书及相关的校验工作。

signing：表示该证书可用于签名其它证书；生成的 ca.pem 证书中 CA=TRUE。

server auth：表示可以用该CA 对 server 提供的证书进行验证。

client auth：表示可以用该 CA 对 client 提供的证书进行验证。

expiry：也表示过期时间，如果不写以default中的为准。

我这里将证书有效期设置为10年。

（2）、创建CA证书签名请求文件

创建一个json格式文件ca-csr.json，内容如下：

[root@master1 k8s]# cat ca-csr.json

"CN": "Kubernetes",

"key": {

"algo": "rsa",

"size": 2048

"names": [

{

"C": "CN",

"L": "xian",

"O": "iivey",

"OU": "CA",

"ST": "shaanxi"

]

}

参数含义如下：

Ø CN: Common Name，浏览器使用该字段验证网站是否合法，一般写的是域名。非常重要。

Ø key：生成证书的算法

Ø hosts：表示哪些主机名(域名)或者IP可以使用此csr申请的证书，为空或者""表示所有的都可以使用(本例中没有hosts字段)

Ø names：一些其它的属性

² C: Country，国家

² ST: State，州或者是省份

² L: Locality Name，地区，城市

² O: Organization Name，组织名称，公司名称(在k8s中常用于指定Group，进行RBAC绑定)

² OU: Organization Unit Name，组织单位名称，公司部门

在这个文件中，可根据情况进行地域、国家的修改。

（3）、产生CA证书文件

执行如下命令：

[root@master1 k8s]# cfssl gencert -initca ca-csr.json | cfssljson -bare ca

其中，几个参数功能如下：

Ø gencert: 生成新的key(密钥)和签名证书

² -initca：初始化一个新ca

该命令会生成运行CA所必需的文件ca-key.pem（私钥）和ca.pem（证书），还会生成ca.csr（证书签名请求），用于交叉签名或重新签名。接着，查看产生的证书文件：

[root@master1 k8s]# ls -al ca*.pem

-rw------- 1 root root 1675 Mar 23 11:04 ca-key.pem

-rw-r--r-- 1 root root 1314 Mar 23 11:04 ca.pem

这两个文件就是我们需要的证书文件。如果要查看cert(证书信息)，可执行如下命令：

[root@master1 k8s]# cfssl certinfo -cert ca.pem

要查看CSR(证书签名请求)信息，可执行如下文件：

[root@master1 k8s]# cfssl certinfo -csr ca.csr

3、创建admin用户证书

（1）、创建证书签名请求配置文件

创建一个json格式文件admin-csr.json，内容如下：

[root@master1 k8s]# cat admin-csr.json

"CN": "admin",

"O": "system:masters",

"OU": "Kubernetes The Hard Way",

（2）、创建admin用户证书并校验结果

首先创建admin证书，执行如下命令：

[root@master1 k8s]# cfssl gencert \

-ca=ca.pem \

-ca-key=ca-key.pem \

-config=ca-config.json \

-profile=kubernetes \

admin-csr.json | cfssljson -bare admin

其中，每个参数含义如下：

² -ca：指明ca的证书

² -ca-key：指明ca的私钥文件

² -config：指明请求证书的json文件

² -profile：与-config中的profile对应，是指根据config中的profile段来生成证书的相关信息

接着，查看产生的证书文件：

[root@master1 k8s]# ls -al admin*.pem

-rw------- 1 root root 1675 Dec 2 10:12 admin-key.pem

-rw-r--r-- 1 root root 1411 Dec 2 10:12 admin.pem

这两个就是需要的证书文件。

4、创建kubelet证书

Kubelet证书主要是在node节点使用的，这里我们有node1、node2两个节点，因此需要创建两个节点的Kubelet证书，为了方便起见，这里通过一个脚本一次性实现两个节点证书的创建，脚本generate-kubelet-certificate.sh内容如下：

[root@master1 k8s]# more generate-kubelet-certificate.sh

IFS=$'\n'

for line in `cat node.txt`; do

instance=`echo $line | awk '{print $1}'`

INTERNAL_IP=`echo $line | awk '{print $2}'`

cat > ${instance}-csr.json <<EOF

"CN": "system:node:${instance}",

"O": "system:nodes",

EOF

cfssl gencert \

-hostname=${instance},${INTERNAL_IP} \

${instance}-csr.json | cfssljson -bare ${instance}

其中，node.txt文件内容如下：

[root@master1 k8s]# cat node.txt

node1 172.16.213.231

node2 172.16.213.235

执行generate-kubelet-certificate.sh这个脚本，会生成node1、node2两个节点的证书文件。

[root@master1 k8s]# ll node*.pem

-rw------- 1 root root 1679 Dec 2 10:41 node1-key.pem

-rw-r--r-- 1 root root 1464 Dec 2 10:41 node1.pem

-rw------- 1 root root 1675 Dec 2 10:41 node2-key.pem

-rw-r--r-- 1 root root 1464 Dec 2 10:41 node2.pem

5、创建Controller Manager客户端证书

Controller Manager证书是在master节点，为了方便起见，我们通过一个脚本来自动完成证书的创建，脚本kube-controller-manager.sh内容如下：

[root@master1 k8s]# more kube-controller-manager.sh

cat > kube-controller-manager-csr.json <<EOF

"CN": "system:kube-controller-manager",

"O": "system:kube-controller-manager",

kube-controller-manager-csr.json | cfssljson -bare kube-controller-manager

执行kube-controller-manager.sh这个脚本，会生成两个证书文件。

[root@master1 k8s]# ll kube-controller-manager*.pem

-rw------- 1 root root 1679 Dec 2 10:43 kube-controller-manager-key.pem

-rw-r--r-- 1 root root 1468 Dec 2 10:43 kube-controller-manager.pem

6、创建Kube Proxy客户端证书

Kube Proxy证书是在master节点，为了方便起见，我们通过一个脚本来自动完成证书的创建，脚本kubeproxy.sh内容如下：

cat > kube-proxy-csr.json <<EOF

"CN": "system:kube-proxy",

"O": "system:node-proxier",

kube-proxy-csr.json | cfssljson -bare kube-proxy

执行kubeproxy.sh这个脚本，会生成两个证书文件。

[root@master1 k8s]# ll kube-proxy*.pem

-rw------- 1 root root 1675 Dec 2 10:45 kube-proxy-key.pem

-rw-r--r-- 1 root root 1436 Dec 2 10:45 kube-proxy.pem

7、创建Scheduler 客户端证书

Kube Scheduler证书是在master节点，为了方便起见，我们通过一个脚本来自动完成证书的创建，脚本kubescheduler.sh内容如下：

[root@master1 k8s]# more kubescheduler.sh

cat > kube-scheduler-csr.json <<EOF

"CN": "system:kube-scheduler",

"O": "system:kube-scheduler",

kube-scheduler-csr.json | cfssljson -bare kube-scheduler

执行kubescheduler.sh这个脚本，会生成两个证书文件。

[root@master1 k8s]# ll kube-scheduler*.pem

-rw------- 1 root root 1679 Dec 2 10:47 kube-scheduler-key.pem

-rw-r--r-- 1 root root 1444 Dec 2 10:47 kube-scheduler.pem

8、创建Kuberenetes API证书

kube-api服务器证书主机名应该包含所有控制器的主机名和IP、负载均衡器的主机名和IP、kubernetes服务以及localhost。

为了方便起见，我们通过一个脚本来自动完成证书的创建，脚本kubeapi.sh内容如下：

CERT_HOSTNAME=10.100.0.1,master1,172.16.213.225,master2,172.16.213.229,master3,172.16.213.230,lbserver,172.16.213.236,127.0.0.1,localhost,kubernetes.default

cat > kubernetes-csr.json <<EOF

"CN": "kubernetes",

"O": "Kubernetes",

-hostname=${CERT_HOSTNAME} \

kubernetes-csr.json | cfssljson -bare kubernetes

注意，此脚本中，CERT_HOSTNAME的内容，需要修改为你环境下的主机名和IP地址。

执行kubeapi.sh这个脚本，会生成两个证书文件。

[root@master1 k8s]# ll kubernetes*.pem

-rw------- 1 root root 1679 Dec 3 17:45 kubernetes-key.pem

-rw-r--r-- 1 root root 1574 Dec 3 17:45 kubernetes.pem

9、创建服务帐户密钥对

服务帐户密钥对用来签署服务帐户的token，为了方便起见，我们通过一个脚本来自动完成证书的创建，脚本servicesaccount.sh内容如下：

[root@master1 k8s]# cat servicesaccount.sh

cat > service-account-csr.json <<EOF

"CN": "service-accounts",

service-account-csr.json | cfssljson -bare service-account

执行servicesaccount.sh这个脚本，会生成两个证书文件。

[root@master1 k8s]# ll service-account*.pem

-rw------- 1 root root 1679 Dec 3 17:46 service-account-key.pem

-rw-r--r-- 1 root root 1424 Dec 3 17:46 service-account.pem

10、复制证书到对应节点

基础证书到此已经基本创建完成了，接下来要将证书传到集群的相应节点上，为了方便起见，通过一个脚本来完成证书的传输，脚本scp1.sh的内容如下：

[root@master1 k8s]# cat scp1.sh

instance=`echo $line | awk '{print $1}'`

rsync -azvp ca.pem ${instance}-key.pem ${instance}.pem root@${instance}:/root/

for instance in master1 master2 master3; do

rsync -avpz ca.pem ca-key.pem kubernetes-key.pem kubernetes.pem service-account-key.pem service-account.pem root@${instance}:/root/

注意，此脚本是将k8s集群两个node节点的证书传到对应node主机上，然后将ca证书、kube-api证书以及service-account证书传到三个master节点上。

其中，脚本中的node.txt文件内容如下：

[root@master1 k8s]# more node.txt

四、给k8s组件创建kubeconfig

kubeconfig是kubernetes集群中各个组件连入api-server的时候, 使用的客户端配置文件。用于配置集群访问的文件称为kubeconfig文件。这是引用配置文件的通用方法。这并不意味着有一个名为 kubeconfig 的文件。

使用 kubeconfig 文件来组织有关集群、用户、命名空间和身份认证机制的信息。kubectl 命令行工具使用 kubeconfig 文件来查找选择集群所需的信息，并与集群的 API 服务器进行通信。

默认情况下，kubectl 在 $HOME/.kube 目录下查找名为 config 的文件。我们也可以通过设置 KUBECONFIG 环境变量或者设置--kubeconfig参数来指定其他 kubeconfig 文件。

本文中我们将生成多个组件的kubeconfig，分别是kubelet kubeconfig、kube Proxy kubeconfig、Controller Manager kubeconfig、Kube Scheduler kubeconfig、`admin`用户的kubeconfig。

1、生成kubelet的kubeconfig

首先需要安装kubectl，这是管理k8s的一个客户端工具，下载地址如下：

https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG/CHANGELOG-1.20.md#downloads-for-v1204

这里下载的kubernetes版本为kubernetes-server-linux-amd64.tar.gz，建议下载二进制的server版本，这样下载后，解压即可使用。将上面这个压缩包解压，得到kubernetes/server/bin这个路径，就可以找到一个二进制文件kubectl，将这个文件拷贝到master节点的/usr/local/bin目录下即可。此步骤需要在三个master节点进行，基本操作过程如下：

[root@master1 bin]# chmod 755 kubectl

[root@master1 bin]# cp kubectl /usr/local/bin

[root@master1 bin]# scp kubectl master2:/usr/local/bin

[root@master1 bin]# scp kubectl master3:/usr/local/bin

kubectl文件拷贝完成，接下来就可以生成kubeconfig文件了，为了方便起见，仍然使用一个脚本kubelet.sh完成，脚本内容如下：

[root@master1 k8s]# more kubelet.sh

for instance in node1 node2; do

# 设置集群参数

kubectl config set-cluster kubernetes-the-hard-way \

--certificate-authority=ca.pem \

--embed-certs=true \

--server=https://172.16.213.236:6443 \

--kubeconfig=${instance}.kubeconfig

# 设置客户端认证参数

kubectl config set-credentials system:node:${instance} \

--client-certificate=${instance}.pem \

--client-key=${instance}-key.pem \

# 设置上下文参数

kubectl config set-context default \

--cluster=kubernetes-the-hard-way \

--user=system:node:${instance} \

# 设置默认上下文

kubectl config use-context default --kubeconfig=${instance}.kubeconfig

此段配置中，主要有三个方面的配置，分别是：

（1）、集群参数

本段设置了所需要访问的集群的信息。使用set-cluster设置了需要访问的集群，如上为kubernetes-the-hard-way，这只是个名称，实际为--server指向的apiserver，--certificate-authority设置了该集群的公钥，--embed-certs为true表示将--certificate-authority证书写入到kubeconfig中；--server则表示该集群的kube-apiserver地址。

注意，这里--server指定的apiserver地址是个负载均衡的地址，因为此环境是三个master节点的集群环境，所以要指向负载均衡器的IP地址。关于负载均衡器的配置，将在下面做具体介绍。

生成的kubeconfig 如果不指定路径，默认被保存到 ~/.kube/config 文件，而上面的配置中，我们指定的路径是当前目录，所以会在当前目录下生成kubeconfig文件。

（2）、客户端参数

本段主要设置客户端的相关信息，注意客户端的证书首先要经过集群CA的签署，否则不会被集群认可。此处使用的是ca认证方式，也可以使用token认证.

（3）、上下文参数

集群参数和用户参数可以同时设置多对，在上下文参数中将集群参数和用户参数关联起来。上面的上下文名称为default，--cluster为kubernetes-the-hard-way，用户为system:node:${instance}，表示使用system:node的用户凭证来访问kubernetes-the-hard-way集群的default命名空间，也可以增加--namspace来指定访问的命名空间。

最后使用kubectl config use-context default 来使用名为default的环境项来作为配置。如果配置了多个环境项，可以通过切换不同的环境项名字来访问到不同的集群环境。

执行kubelet.sh脚本，就会生成两个node节点的kubeconfig文件，操作如下：

[root@master1 k8s]# sh kubelet.sh

[root@master1 k8s]# ll node*.kubeconfig

-rw------- 1 root root 6314 Dec 2 16:22 node1.kubeconfig

-rw------- 1 root root 6310 Dec 2 16:22 node2.kubeconfig

2、生成kube-proxy 的kubeconfig

为了方便起见，仍然使用一个脚本kube-proxy.sh完成，脚本内容如下：

kubectl config set-cluster kubernetes-the-hard-way \

--kubeconfig=kube-proxy.kubeconfig

kubectl config set-credentials system:kube-proxy \

--client-certificate=kube-proxy.pem \

--client-key=kube-proxy-key.pem \

kubectl config set-context default \

--user=system:kube-proxy \

kubectl config use-context default --kubeconfig=kube-proxy.kubeconfig

脚本的内容不再解释，跟kubelet.sh脚本中的参数含义基本相同，执行此脚本，会生成kube-proxy的kubeconfig文件，操作如下：

[root@master1 k8s]# sh kube-proxy.sh

[root@master1 k8s]# ll kube-proxy*.kubeconfig

-rw------- 1 root root 6274 Dec 2 16:27 kube-proxy.kubeconfig

3、创建kue-controller-manager kubeconfig

为了方便起见，仍然使用一个脚本kube-controllermanager.sh完成，脚本内容如下：

[root@master1 k8s]# vi kube-controllermanager.sh

--server=https://127.0.0.1:6443 \

--kubeconfig=kube-controller-manager.kubeconfig

kubectl config set-credentials system:kube-controller-manager \

--client-certificate=kube-controller-manager.pem \

--client-key=kube-controller-manager-key.pem \

--user=system:kube-controller-manager \

kubectl config use-context default --kubeconfig=kube-controller-manager.kubeconfig

执行此脚本，会生成kube-proxy的kubeconfig文件，操作如下：

[root@master1 k8s]# sh kube-controllermanager.sh

[root@master1 k8s]# ll kube-controller-manager*.kubeconfig

-rw------- 1 root root 6343 Dec 2 17:51 kube-controller-manager.kubeconfig

4、生成kube-scheduler kubeconfig

为了方便起见，仍然使用一个脚本kube-scheduler.sh完成，脚本内容如下：

[root@master1 k8s]# cat kube-scheduler.sh

--kubeconfig=kube-scheduler.kubeconfig

kubectl config set-credentials system:kube-scheduler \

--client-certificate=kube-scheduler.pem \

--client-key=kube-scheduler-key.pem \

--user=system:kube-scheduler \

kubectl config use-context default --kubeconfig=kube-scheduler.kubeconfig

执行此脚本，会生成kube-scheduler的kubeconfig文件，操作如下：

[root@master1 k8s]# sh kube-scheduler.sh

[root@master1 k8s]# ll kube-scheduler*.kubeconfig

-rw------- 1 root root 6293 Dec 2 16:54 kube-scheduler.kubeconfig

5、生成admin的kubeconfig

为了方便起见，仍然使用一个脚本admin.sh完成，脚本内容如下：

[root@master1 k8s]# cat admin.sh

--kubeconfig=admin.kubeconfig

kubectl config set-credentials admin \

--client-certificate=admin.pem \

--client-key=admin-key.pem \

--user=admin \

kubectl config use-context default --kubeconfig=admin.kubeconfig

执行此脚本，会生成admin的kubeconfig文件，操作如下：

[root@master1 k8s]# sh admin.sh

[root@master1 k8s]# ll admin.kubeconfig

-rw------- 1 root root 6213 Dec 2 16:55 admin.kubeconfig

6、创建通信加密文件

Kubernetes支持集群数据加密。在下面操作中,我们将生成一个加密密钥和加密配置来加密Kubernetes静态Secret数据。

这里仍然通过一个脚本encryption-config.sh来完成，脚本内容如下：

[root@master1 ~]# more encryption-config.sh

cat > encryption-config.yaml <<EOF

kind: EncryptionConfig

apiVersion: v1

resources:

- resources:

- secrets

providers:

- aescbc:

keys:

- name: key1

secret: $(head -c 32 /dev/urandom | base64)

- identity: {}

执行这个脚本，然后会生成一个文件encryption-config.yaml，此文件需要复制到三个master节点。

7、拷贝kubeconfig到集群节点

到这里为止，所需要的证书、kubeconfig文件已经全部生成完毕，接下来需要将这些文件拷贝到集群对应的主机上。

首先需要将kube-proxy.kubeconfig以及${node}.kubeconfig拷贝到集群的两个work节点，接着将admin.kubeconfig、kube-controller-manager.kubeconfig、kube-scheduler.kubeconfig、encryption-config.yaml拷贝到k8s集群的三个master节点，这通过一个脚本即可完成，脚本kubeconfig-scp.sh内容如下：

[root@master1 k8s]# more kubeconfig-scp.sh

IFS=$'\n'

for line in node1 node2; do

rsync -avpz ${line}.kubeconfig kube-proxy.kubeconfig root@${line}:/root/

rsync -avpz admin.kubeconfig kube-controller-manager.kubeconfig kube-scheduler.kubeconfig root@${instan

ce}:/root/

rsync -avpz encryption-config.yaml root@${instance}:/root/

注意，脚本中node1/node2以及master1/2/3都是k8s集群的主机名。另外，脚本中的文件都在当前目录下，写的相当路径，当前目录为/root/k8s。另外，将文件拷贝到其他节点时，也是暂存到/root目录下的，后面在其它节点安装软件后，还需要把这些文件拷贝到对应的配置目录下。

五、Etcd集群配置

Etcd可以单独部署，也可以部署为集群模式，在生产环境下，建议部署为集群模式，集群模式下至少需要3台机器，这三台机器可以单独部署，也可以和三个master节点公用，这取决于机器资源十分充足。

下面我们将etcd和master部署到一起，因此，下面每个步骤的操作都需要在maser1、maser2、maser3执行一遍。

1、部署etcd文件

Etcd程序可以从

https://github.com/etcd-io/etcd/releases/

下载，这里我下载的是最新版本etcd-v3.4.14-linux-amd64.tar.gz，下载完成后进行解压，然后创建相应目录并复制配置文件过来完成配置，操作过程如下：

[root@master1 k8s]# tar -xvf etcd-v3.4.14-linux-amd64.tar.gz

[root@master1 k8s]# cp etcd-v3.4.14-linux-amd64/etcd* /usr/local/bin/

[root@master1 k8s]# scp etcd-v3.4.14-linux-amd64/etcd* master2:/usr/local/bin/

[root@master1 k8s]# scp etcd-v3.4.14-linux-amd64/etcd* master3:/usr/local/bin/

[root@master1 k8s]# mkdir -p /etc/etcd /var/lib/etcd

[root@master1 k8s]# cp ca.pem kubernetes-key.pem kubernetes.pem /etc/etcd/

[root@master1 k8s]#scp ca.pem kubernetes-key.pem kubernetes.pem master2:/etc/etcd/

[root@master1 k8s]#scp ca.pem kubernetes-key.pem kubernetes.pem master3:/etc/etcd/

注意，最后两个步骤是先创建etcd几个配置文件目录，然后将之前生成的证书文件拷贝到这些目录中。

2、创建etcd服务配置文件

服务配置文件主要用来管理etcd服务，例如启动、关闭等，为方便起见，通过一个脚本完成，脚本etcd.sh内容如下：

[root@master1 k8s]# cat etcd.sh

ETCD_NAME=`hostname`

INTERNAL_IP=`hostname -i`

INITIAL_CLUSTER=master1=https://172.16.213.225:2380,master2=https://172.16.213.229:2380,master3=https://172.16.213.230:2380

cat << EOF | sudo tee /etc/systemd/system/etcd.service

[Unit]

Description=etcd

Documentation=https://github.com/coreos

[Service]

ExecStart=/usr/local/bin/etcd \\

--name ${ETCD_NAME} \\

--cert-file=/etc/etcd/kubernetes.pem \\

--key-file=/etc/etcd/kubernetes-key.pem \\

--peer-cert-file=/etc/etcd/kubernetes.pem \\

--peer-key-file=/etc/etcd/kubernetes-key.pem \\

--trusted-ca-file=/etc/etcd/ca.pem \\

--peer-trusted-ca-file=/etc/etcd/ca.pem \\

--peer-client-cert-auth \\

--client-cert-auth \\

--initial-advertise-peer-urls https://${INTERNAL_IP}:2380 \\

--listen-peer-urls https://${INTERNAL_IP}:2380 \\

--listen-client-urls https://${INTERNAL_IP}:2379,https://127.0.0.1:2379 \\

--advertise-client-urls https://${INTERNAL_IP}:2379 \\

--initial-cluster-token etcd-cluster-0 \\

--initial-cluster ${INITIAL_CLUSTER} \\

--initial-cluster-state new \\

--data-dir=/var/lib/etcd

Restart=on-failure

RestartSec=5

[Install]

WantedBy=multi-user.target

在三个master节点上执行此脚本，会自动生成服务配置文件etcd.service，后面会调用此文件来启动或重启etcd服务。

3、启动并测试etcd集群服务

要启动etcd集群服务，可通过执行如下命令实现：

[root@master1 k8s]# systemctl daemon-reload

[root@master1 k8s]# systemctl enable etcd

[root@master1 k8s]# systemctl start etcd

要测试etcd集群是否正常运行，可执行如下命令：

[root@master1 k8s]# ETCDCTL_API=3 etcdctl member list --endpoints=https://127.0.0.1:2379 --cacert=/etc/etcd/ca.pem --cert=/etc/etcd/kubernetes.pem --key=/etc/etcd/kubernetes-key.pem

至此，etcd集群安装完成。

六、k8s集群master节点各组件部署

下面正式进入k8s集群部署阶段，首先部署的是master节点各组件，主要有kube-apiserver、kube-controller-manager、kube-scheduler三个组件的安装部署。

1、部署master节点组件

要安装k8s集群组件，首先需要从github上下载Kubernetes的安装程序，可选择源码和二进制版本下载，建议选择二进制版本下载。

下载地址为：

，我这里下载的是kubernetes1.20.4版本，对应的程序包为kubernetes-server-linux-amd64.tar.gz。

将下载好的程序包进行解压，然后在kubernetes/server/bin目录下即可找到需要的组件程序，先进行授权，然后传到/usr/local/bin目录下。操作如下：

[root@master1 setup]# cd kubernetes/server/bin

[root@master1 bin]# chmod +x kube-apiserver kube-controller-manager kube-scheduler kubectl

[root@master1 bin]# cp kube-apiserver kube-controller-manager kube-scheduler /usr/local/bin/

[root@master1 bin]# scp kube-apiserver kube-controller-manager kube-scheduler master2:/usr/local/bin/

[root@master1 bin]# scp kubectl kubelet kube-proxy node1:/usr/local/bin/

[root@master1 bin]# scp kubectl kubelet kube-proxy node2:/usr/local/bin/

此操作在三个master节点都执行一遍，即可完成master节点组件的安装。同时也将客户端node1、node2所需的软件也一并拷贝过去。

2、Kubernetes API服务配置

首先，需要移动证书到Kubernetes对应目录，操作如下：

[root@master1 k8s]# mkdir -p /var/lib/kubernetes/

[root@master1 k8s]# cp ca.pem ca-key.pem kubernetes-key.pem kubernetes.pem \

service-account-key.pem service-account.pem \

encryption-config.yaml /var/lib/kubernetes/

下面是拷贝证书到master2、3节点：

[root@master1 k8s]# scp ca.pem ca-key.pem kubernetes-key.pem kubernetes.pem \

encryption-config.yaml master2:/var/lib/kubernetes/

encryption-config.yaml master3:/var/lib/kubernetes/

接着，创建kube-api服务的配置文件，为了方便起见，通过一个脚本来实现，脚本kube-api.sh内容如下：

[root@master1 k8s]# cat kube-api.sh

CONTROLLER0_IP=172.16.213.225

CONTROLLER1_IP=172.16.213.229

CONTROLLER2_IP=172.16.213.230

cat << EOF | sudo tee /etc/systemd/system/kube-apiserver.service

Description=Kubernetes API Server

Documentation=https://github.com/kubernetes/kubernetes

ExecStart=/usr/local/bin/kube-apiserver \\

--advertise-address=${INTERNAL_IP} \\

--allow-privileged=true \\

--apiserver-count=3 \\

--audit-log-maxage=30 \\

--audit-log-maxbackup=3 \\

--audit-log-maxsize=100 \\

--audit-log-path=/var/log/audit.log \\

--authorization-mode=Node,RBAC \\

--bind-address=0.0.0.0 \\

--client-ca-file=/var/lib/kubernetes/ca.pem \\

--enable-admission-plugins=NamespaceLifecycle,NodeRestriction,LimitRanger,ServiceAccount,DefaultStorageClass,ResourceQuota \\

--etcd-cafile=/var/lib/kubernetes/ca.pem \\

--etcd-certfile=/var/lib/kubernetes/kubernetes.pem \\

--etcd-keyfile=/var/lib/kubernetes/kubernetes-key.pem \\

--etcd-servers=https://$CONTROLLER0_IP:2379,https://$CONTROLLER1_IP:2379,https://$CONTROLLER2_IP:2379 \\

--event-ttl=1h \\

--encryption-provider-config=/var/lib/kubernetes/encryption-config.yaml \\

--kubelet-certificate-authority=/var/lib/kubernetes/ca.pem \\

--kubelet-client-certificate=/var/lib/kubernetes/kubernetes.pem \\

--kubelet-client-key=/var/lib/kubernetes/kubernetes-key.pem \\

--kubelet-https=true \\

--runtime-config=api/all=true \\

--service-account-key-file=/var/lib/kubernetes/service-account.pem \\

--service-account-signing-key-file=/var/lib/kubernetes/service-account-key.pem \\

--service-account-issuer=https://${INTERNAL_IP}:6443/auth/realms/master/.well-known/openid-configuration \\

--service-cluster-ip-range=10.100.0.0/24 \\

--service-node-port-range=30000-32767 \\

--tls-cert-file=/var/lib/kubernetes/kubernetes.pem \\

--tls-private-key-file=/var/lib/kubernetes/kubernetes-key.pem \\

--v=2 \\

--kubelet-preferred-address-types=InternalIP,InternalDNS,Hostname,ExternalIP,ExternalDNS

在三个master节点依次执行此脚本，会生成/etc/systemd/system/kube-apiserver.service文件。

3、Kubernetes Controller Manager配置

首先需要移动kubeconfig文件到kubernetes目录，执行如下命令：

[root@master1 k8s]# cp kube-controller-manager.kubeconfig /var/lib/kubernetes/

[root@master1 k8s]# scp kube-controller-manager.kubeconfig master2:/var/lib/kubernetes/

[root@master1 k8s]# scp kube-controller-manager.kubeconfig master3:/var/lib/kubernetes/

然后，创建kube-controller-manager服务配置文件，为方便起见，仍通过一个脚本controller-manager.sh来实现，脚本内容如下：

[root@master1 k8s]# cat controller-manager.sh

cat <<EOF | sudo tee /etc/systemd/system/kube-controller-manager.service

Description=Kubernetes Controller Manager

ExecStart=/usr/local/bin/kube-controller-manager \\

--address=0.0.0.0 \\

--cluster-cidr=10.200.0.0/16 \\

--cluster-name=kubernetes \\

--cluster-signing-cert-file=/var/lib/kubernetes/ca.pem \\

--cluster-signing-key-file=/var/lib/kubernetes/ca-key.pem \\

--kubeconfig=/var/lib/kubernetes/kube-controller-manager.kubeconfig \\

--leader-elect=true \\

--root-ca-file=/var/lib/kubernetes/ca.pem \\

--service-account-private-key-file=/var/lib/kubernetes/service-account-key.pem \\

--use-service-account-credentials=true \\

--allocate-node-cidrs=true \

--cluster-cidr=10.100.0.0/16 \

--v=2

执行此脚本，会生成/etc/systemd/system/kube-controller-manager.service文件。

4、Kubernetes Scheduler配置

配置之前，先需要将kube-scheduler的kubeconfig文件移动到kubernetes目录，然后创建kube-scheduler配置文件，最后，创建kube-scheduler服务配置文件。

[root@master1 k8s]# cp kube-scheduler.kubeconfig /var/lib/kubernetes/

[root@master1 k8s]#scp kube-scheduler.kubeconfig master2:/var/lib/kubernetes/

[root@master1 k8s]#scp kube-scheduler.kubeconfig master3:/var/lib/kubernetes/

[root@master1 k8s]# mkdir -p /etc/kubernetes/config

[root@master1 k8s]#scp admin.kubeconfig master2:/etc/kubernetes/

[root@master1 k8s]#scp admin.kubeconfig master3:/etc/kubernetes/

目录创建完成后，最后通过脚本完成kube-scheduler配置文件和服务文件的创建，脚本scheduler.sh内容如下：

[root@master1 k8s]# cat scheduler.sh

cat <<EOF | tee /etc/kubernetes/config/kube-scheduler.yaml

apiVersion: kubescheduler.config.k8s.io/v1beta1

kind: KubeSchedulerConfiguration

clientConnection:

kubeconfig: "/var/lib/kubernetes/kube-scheduler.kubeconfig"

leaderElection:

leaderElect: true

cat <<EOF | tee /etc/systemd/system/kube-scheduler.service

Description=Kubernetes Scheduler

ExecStart=/usr/local/bin/kube-scheduler \\

--config=/etc/kubernetes/config/kube-scheduler.yaml \\

此脚本执行后，会创建kube-scheduler.yaml和kube-scheduler.service两个文件。

5、启动各组件服务

到这里为止，master节点上相关组件的配置和服务文件都配置完成了，下面就可以启动服务了，执行如下命令启动三个服务：

[root@master1 k8s]# systemctl daemon-reload

[root@master1 k8s]# systemctl enable kube-apiserver kube-controller-manager kube-scheduler

[root@master1 k8s]# systemctl start kube-apiserver kube-controller-manager kube-scheduler

服务启动完毕后，使用以下命令检查各个组件的状态：

[root@master1 k8s]# kubectl get cs --kubeconfig admin.kubeconfig

Warning: v1 ComponentStatus is deprecated in v1.19+

NAME STATUS MESSAGE ERROR

scheduler Healthy ok

controller-manager Healthy ok

etcd-2 Healthy {"health":"true"}

etcd-0 Healthy {"health":"true"}

etcd-1 Healthy {"health":"true"}

从输出可在，服务正常，etcd集群也运行正常。

此时，如果直接在master节点运行kubectl get cs会得到如下错误：

[root@master1 ~]# kubectl get node

The connection to the server localhost:8080 was refused - did you specify the right host or port?

这是因为kubectl命令需要使用kubernetes-admin来运行，解决方法有两种，第一种是执行如下操作：

mkdir -p $HOME/.kube

cp -i admin.kubeconfig $HOME/.kube/config

chown $(id -u):$(id -g) $HOME/.kube/config

第二种方法是执行如下操作：

echo "export KUBECONFIG=/etc/kubernetes/admin.kubeconfig" >> ~/.bash_profile

source ~/.bash_profile

然后就可以正常执行kubectl命令了。

以上操作在三个master节点都执行一遍。

6、配置RBAC的授权

将下来配置RBAC的授权，来允许kube-api server去访问在每个worker节点上kubelet API. 访问kubelet API主要是用来检索度量，日志和执行Pods中的命令等。

此过程主要分为两个步骤，分别是创建`system:kube-apiserver-to-kubelet`集群角色，并附与权限去访问kubelet，然后绑定`system:kube-apiserver-to-kubelet`集群角色到kubernetes用户。这个过程通过一个脚本来完成，脚本kube-apiserver-to-kubelet.sh内容如下：

[root@master1 k8s]# cat kube-apiserver-to-kubelet.sh

cat <<EOF | kubectl apply --kubeconfig admin.kubeconfig -f -

apiVersion: rbac.authorization.k8s.io/v1

kind: ClusterRole

metadata:

annotations:

rbac.authorization.kubernetes.io/autoupdate: "true"

labels:

kubernetes.io/bootstrapping: rbac-defaults

rules:

- apiGroups:

- ""

resources:

- nodes/proxy

- nodes/stats

- nodes/log

- nodes/spec

- nodes/metrics

verbs:

- "*"

kind: ClusterRoleBinding

namespace: ""

roleRef:

apiGroup: rbac.authorization.k8s.io

kind: ClusterRole

subjects:

- apiGroup: rbac.authorization.k8s.io

kind: User

此脚本执行完毕，相关授权操作就执行成功了。

7、Kubernetes前端负载均衡器配置

负载均衡主要是针对master节点上面的kube-apiserver服务的。此服务非常关键，如果服务较多，此服务负载就会很高，所以做负载均衡很有必要。

由于我们使用了三个master，因此，负载均衡是针对三个master节点上的kube-apiserver服务，这里我采用haproxy来实现三个master节点kube-apiserver服务的负载均衡，这里我单独找一台主机来部署haproxy，haproxy机器就是之前环境说明中的lbserver主机，haproxy的安装可以采用容器方式，也可以直接在物理机上安装，这里直接在物理机上安装，安装通过yum来实现即可。

安装方式如下：

[root@lbserver ~]# yum install -y haproxy

安装完成后，需要配置haproxy，默认的配置文件为/etc/haproxy/haproxy.cfg，修改后的配置文件内容如下：

[root@lbserver ~]# more /etc/haproxy/haproxy.cfg

frontend frontend-k8s-api

bind 172.16.213.236:6443

bind 172.16.213.236:443

mode tcp

option tcplog

default_backend k8s-api

backend k8s-api

option tcp-check

balance roundrobin

default-server inter 10s downinter 5s rise 2 fall 2 slowstart 60s maxconn 250 maxqueue 256 weight 100

server k8s-api-1 172.16.213.225:6443 check

server k8s-api-2 172.16.213.229:6443 check

server k8s-api-3 172.16.213.230:6443 check

listen admin_stats

bind 0.0.0.0:9188

mode http

log 127.0.0.1 local0 err

stats refresh 30s

stats uri /haproxy-status

stats realm welcome login\ Haproxy

stats auth admin:admin123

stats hide-version

stats admin if TRUE

配置完成后，就可以启动服务了，执行如下命令：

[root@lbserver ~]# systemctl start haproxy

[root@lbserver ~]#systemctl enable haproxy

Haproxy启动成功后，就可以通过haproxy的ip加上端口访问三个master节点的api-server服务了，测试如下：

[root@lbserver ~]# curl --cacert ca.pem

https://172.16.213.236:6443/version

"major": "1",

"minor": "19",

"gitVersion": "v1.19.4",

"gitCommit": "d360454c9bcd1634cf4cc52d1867af5491dc9c5f",

"gitTreeState": "clean",

"buildDate": "2020-11-11T13:09:17Z",

"goVersion": "go1.15.2",

"compiler": "gc",

"platform": "linux/amd64"

如果有类似如下输出，表示负载均衡配置正常。

七、k8s集群work节点组件配置

以下操作均在k8s集群的两个work节点进行。

1、安装docker引擎

K8s底层默认使用docker引擎，当然也可以使用其它非docekr引擎，例如containerd 和 cri-o等。更专业的应该叫容器运行时。这里使用docker运行时，所以，需要在每个work节点安装docker引擎，基本安装过程如下：

[root@node1 ~]# yum install -y yum-utils device-mapper-persistent-data lvm2

[root@node1 ~]# yum-config-manager --add-repo

https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

[root@node1 ~]# yum makecache fast

[root@node1 ~]# yum -y install docker-ce

接着，创建daemon.json文件，内容如下：

[root@node1 ~]# more /etc/docker/daemon.json

"exec-opts": ["native.cgroupdriver=systemd"]

最后，重启docker服务即可。

[root@node1 ~]# systemctl start docker

注意，官方软件源默认启用了最新的软件，如果我们不想安装最新版本，可以通过编辑软件源的方式获取各个版本的软件包。例如官方并没有将测试版本的软件源置为可用，我们可以修改docker-ce.repo文件，开启各种测试版本等。

3、 kubelet配置

在前面我们创建了kubelet的各种证书，这里需要移动证书和kubelet config到相对应的目录，基本操作过程如下：

[root@node1 ~]# mkdir -p /var/lib/kubelet

[root@node1 ~]# mkdir -p /var/lib/kubernetes

[root@node2 ~]# mkdir -p /var/lib/kubelet

[root@node2 ~]# mkdir -p /var/lib/kubernetes

[root@master1 ~]# scp node1-key.pem node1.pem node1:/var/lib/kubelet/

[root@master1 ~]# scp node1.kubeconfig node1:/var/lib/kubelet/kubeconfig

[root@master1 ~]# scp ca.pem node1:/var/lib/kubernetes/

[root@master1 ~]# scp node2-key.pem node2.pem node2:/var/lib/kubelet/

[root@master1 ~]# scp node2.kubeconfig node2:/var/lib/kubelet/kubeconfig

[root@master1 ~]# scp ca.pem node2:/var/lib/kubernetes/

注意，上面操作中使用scp命令从master1节点拷贝证书到node1、node2主机对应目录下。

接着，还需要创建kubelet配置文件以及服务文件，通过一个脚本kubelet-setup.sh来自动完成，脚本内容如下：

[root@node1 ~]# more kubelet-setup.sh

cat <<EOF | tee /var/lib/kubelet/kubelet-config.yaml

kind: KubeletConfiguration

apiVersion: kubelet.config.k8s.io/v1beta1

authentication:

anonymous:

enabled: false

webhook:

enabled: true

x509:

clientCAFile: "/var/lib/kubernetes/ca.pem"

authorization:

mode: Webhook

clusterDomain: "cluster.local"

clusterDNS:

- "10.100.0.10"

podCIDR: "10.100.0.0/16"

#resolvConf: "/run/systemd/resolve/resolv.conf"

runtimeRequestTimeout: "15m"

tlsCertFile: "/var/lib/kubelet/node1.pem" #这里是node1节点，如果要部署到node2，需要修改这两个证书的名字为node2的证书。

tlsPrivateKeyFile: "/var/lib/kubelet/node1-key.pem"

cat <<EOF | sudo tee /etc/systemd/system/kubelet.service

Description=Kubernetes Kubelet

After=containerd.service

Requires=containerd.service

ExecStart=/usr/local/bin/kubelet \

--config=/var/lib/kubelet/kubelet-config.yaml \

--docker=unix:///var/run/docker.sock \

--docker-endpoint=unix:///var/run/docker.sock \

--image-pull-progress-deadline=2m \

--network-plugin=cni \

--kubeconfig=/var/lib/kubelet/kubeconfig \

--register-node=true \

--cgroup-driver=systemd \

将这个脚本拷贝的node1、node2主机下，并做简单修改，然后执行此脚本，即可完成kubelet配置以及服务配置。会生成/var/lib/kubelet/kubelet-config.yaml和/etc/systemd/system/kubelet.service两个文件。

4、 kube-proxy配置

针对kube-proxy的配置，首先需要移动kubeconfig文件到kubernetes目录，操作如下：

[root@node1 ~]# mkdir -p /var/lib/kube-proxy

[root@node2 ~]# mkdir -p /var/lib/kube-proxy

然后从master1节点拷贝kube-proxy.kubeconfig到node1、node2节点。

[root@master1 ~]# scp kube-proxy.kubeconfig node1:/var/lib/kube-proxy/kubeconfig

[root@master1 ~]# scp kube-proxy.kubeconfig node2:/var/lib/kube-proxy/kubeconfig

接着，还需要创建kube-proxy配置文件以及服务文件，通过一个脚本kube-proxy-setup.sh来自动完成，脚本内容如下：

[root@node1 ~]# cat kube-proxy-setup.sh

cat <<EOF | sudo tee /var/lib/kube-proxy/kube-proxy-config.yaml

kind: KubeProxyConfiguration

apiVersion: kubeproxy.config.k8s.io/v1alpha1

kubeconfig: "/var/lib/kube-proxy/kubeconfig"

mode: ""

clusterCIDR: "10.100.0.0/16"

cat <<EOF | sudo tee /etc/systemd/system/kube-proxy.service

Description=Kubernetes Kube Proxy

ExecStart=/usr/local/bin/kube-proxy \\

--config=/var/lib/kube-proxy/kube-proxy-config.yaml

将此脚本拷贝到node1、node2主机上，然后执行此脚本，会生成/var/lib/kube-proxy/kube-proxy-config.yaml和/etc/systemd/system/kube-proxy.service两个文件。

5、启动kubelet和kube-proxy服务

到此为止，kubelet和kube-proxy的配置都已经完成，下面在集群work节点上分别启动这两个服务，操作如下：

[root@node1 ~]# systemctl daemon-reload

[root@node1 ~]# systemctl enable kubelet kube-proxy

[root@node1 ~]# systemctl start kubelet kube-proxy

服务启动完毕后，可以通过systemctl status查看服务启动状态，如果不正常，会提示相关错误。

6、部署CNI网络插件

CNI网络用来实现k8s集群不同主机上不同pod的通信，需要在每个work节点安装CNI网络，要部署CNI网络，可从

https://github.com/containernetworking/plugins/releases

下载CNI查看，操作过程如下：

[root@node1 ~]# mkdir /opt/cni/bin /etc/cni/net.d -p

[root@node1 ~]# cd /opt/cni/bin

[root@node1 ~]# wget

https://github.com/containernetworking/plugins/releases/download/v0.8.7/cni-plugins-linux-amd64-v0.8.7.tgz

[root@node1 ~]# tar zxvf cni-plugins-linux-amd64-v0.8.7.tgz -C /opt/cni/bin

CNI插件安装完毕后，还需要在任意一个master节点上执行如下操作，将CNI网络与master节点关联起来，操作如下：

[root@master1 ~]# wget

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

将kube-flannel.yml文件下载到本地，然后找到"Network": "10.244.0.0/16", 修改为"Network": "10.100.0.0/16"

最后，在master节点执行如下操作：

[root@node1 ~]# kubectl apply -f kube-flannel.yaml

至此，k8s集群全部部署完成。

要验证k8s集群是否工作正常，可在master节点执行如下命令：

[root@master1 k8s]# kubectl get node

NAME STATUS ROLES AGE VERSION

node1 Ready <none> 49d v1.19.4

node2 Ready <none> 49d v1.19.4

其中node1/2是两个work节点，如果状态均为Ready，表示集群运行正常。

八、测试集群是否正常

1、启用 kubectl 命令的自动补全功能

echo "source <(kubectl completion bash)" >> ~/.bashrc

source ~/.bashrc

1、创建deployment

kubectl create deployment nginx-deployment --image=nginx --dry-run=client -o yaml

2、创建service

kubectl create service nodeport nginx-services --tcp=8080:80 --dry-run=client -o yaml