二进制部署

准备

需要三台设备：一台master，两台node，etcd安装在node里

master/node：192.168.116.21

node01：192.168.116.22

node02：192.168.116.23

1、操作系统初始化配置

关闭防火墙

systemctl stop firewalld
systemctl disable firewalld
iptables -F && iptables -t nat -F && iptables -t mangle -F && iptables -X

关闭selinux

setenforce 0
sed -i 's/enforcing/disabled/' /etc/selinux/config

关闭swap

swapoff -a
sed -ri 's/.*swap.*/#&/' /etc/fstab 

根据规划设置主机名

hostnamectl set-hostname master01
hostnamectl set-hostname node01
hostnamectl set-hostname node02

在master添加hosts

cat >> /etc/hosts << EOF
192.168.116.21 master01
192.168.116.22 node01
192.168.116.23 node02
EOF

调整内核参数

cat > /etc/sysctl.d/k8s.conf << EOF
#开启网桥模式，可将网桥的流量传递给iptables链
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
#关闭ipv6协议
net.ipv6.conf.all.disable_ipv6=1
net.ipv4.ip_forward=1
EOF
​
sysctl --system

时间同步

yum install ntpdate -y
ntpdate time.windows.com

2、所有 node 节点部署docker引擎

yum install -y yum-utils device-mapper-persistent-data lvm2
 
yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo 
 
yum install -y docker-ce docker-ce-cli containerd.io
 
systemctl start docker.service
 
systemctl enable docker.service 

2.1、修改docker配置文件

docker info
查看默认存储引擎是cgroupfs引擎

添加一个.json结尾的配置文件

cd /etc/docker
vim daemon.json

{
  "registry-mirrors":["https://6ijb8ubo.mirror.aliyuncs.com"],
  "exec-opts":["native.cgroupdriver=systemd"],
  "log-dirver": "json-file",
  "log-opts": {
     "max-size":"500m","max-file": "3"
  }
}
---------------------------------------------------------------------------
​
仓库镜像地址
"registry-mirrors":["https://6ijb8ubo.mirror.aliyuncs.com"]
​
设置cgroup引擎为systemd
"exec-opts":["native.cgroupdriver=systemd"],
​
日志的配置
 "log-dirver": "json-file",
  "log-opts": {
     "max-size":"500m","max-file": "3"
​

cat > /etc/docker/daemon.json <<EOF
{
  "registry-mirrors": ["https://6ijb8ubo.mirror.aliyuncs.com"],
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver":"json-file",
  "log-opts":{
    "max-size":"500m","max-file":"3"
   }
}
EOF

systemctl restart docker.service
#再查看引擎是否更改
docker info | grep "Cgroup Driver"
 Cgroup Driver: systemd

 

 

3、搭建etcd集群

• etcd 目前默认使用2379端口提供HTTP API服务， 2380端口和peer通信

• etcd 在生产环境中一般推荐集群方式部署。由于etcd 的leader选举机制，要求至少为3台或以上的奇数台。

了解etcd特性

3.1、使用cfssl工具签发证书和私钥文件

CFSSL 使用配置文件生成证书，因此自签之前，需要生成它识别的 json 格式的配置文件，CFSSL 提供了方便的命令行生成配置文件。

CFSSL 用来为 etcd 提供 TLS 证书，它支持签三种类型的证书：

以上是安全级别最高的情况下所使用的三套安全证书。

这里全部都使用同一套证书认证。

3.1.1在master节点上生成证书

准备cfssl证书生成工具
wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64 -O /usr/local/bin/cfssl
wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64 -O /usr/local/bin/cfssljson
wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64 -O /usr/local/bin/cfssl-certinfo
​
-----------------------------------------------------------------------------------------
cfssl：证书签发的工具命令
cfssljson：将 cfssl 生成的证书（默认为json格式）转化为文件承载式证书
cfssl-certinfo：验证证书的信息
​
#查看证书的信息
cfssl-certinfo -cert <证书名称>  

#将文件传入到/usr/local/bin目录下
cd /usr/local/bin
#给他们可执行的权限
chmod +x /usr/local/bin/cfssl*

 

cfssl version #检查版本

 

将master和node节点的/opt目录下所有的文件清空
在master节点上创建一个k8s的安装目录
mkdir k8s
进入目录中上传两个etcd的脚本文件
etcd-cert.sh生成证书和私钥的文件
etcd.sh启动etcd服务的脚本文件

vim etcd-cert.sh
 
#!/bin/bash
#配置证书生成策略，让 CA 软件知道颁发有什么功能的证书，生成用来签发其他组件证书的根证书
cat > ca-config.json <<EOF
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "www": {
         "expiry": "87600h",
         "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ]
      }
    }
  }
}
EOF
 
#ca-config.json：可以定义多个 profiles，分别指定不同的过期时间、使用场景等参数；
#后续在签名证书时会使用某个 profile；此实例只有一个 www 模板。
#expiry：指定了证书的有效期，87600h 为10年，如果用默认值一年的话，证书到期后集群会立即宕掉
#signing：表示该证书可用于签名其它证书；生成的 ca.pem 证书中 CA=TRUE；
#key encipherment：表示使用非对称密钥加密，如 RSA 加密；
#server auth：表示client可以用该 CA 对 server 提供的证书进行验证；
#client auth：表示server可以用该 CA 对 client 提供的证书进行验证；
#注意标点符号，最后一个字段一般是没有逗号的。
 
 
#-----------------------
#生成CA证书和私钥（根证书和私钥）
#特别说明： cfssl和openssl有一些区别，openssl需要先生成私钥，然后用私钥生成请求文件，最后生成签名的证书和私钥等，但是cfssl可以直接得到请求文件。
cat > ca-csr.json <<EOF
{
    "CN": "etcd",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Beijing",
            "ST": "Beijing"
        }
    ]
}
EOF
 
#CN：Common Name，浏览器使用该字段验证网站或机构是否合法，一般写的是域名 
#key：指定了加密算法，一般使用rsa（size：2048）
#C：Country，国家
#ST：State，州，省
#L：Locality，地区,城市
#O: Organization Name，组织名称，公司名称
#OU: Organization Unit Name，组织单位名称，公司部门
 
cfssl gencert -initca ca-csr.json | cfssljson -bare ca
 
#生成的文件：
#ca-key.pem：根证书私钥
#ca.pem：根证书
#ca.csr：根证书签发请求文件
 
#cfssl gencert -initca <CSRJSON>：使用 CSRJSON 文件生成新的证书和私钥。如果不添加管道符号，会直接把所有证书内容输出到屏幕。
#注意：CSRJSON 文件用的是相对路径，所以 cfssl 的时候需要 csr 文件的路径下执行，也可以指定为绝对路径。
#cfssljson 将 cfssl 生成的证书（json格式）变为文件承载式证书，-bare 用于命名生成的证书文件。
 
 
#-----------------------
#生成 etcd 服务器证书和私钥
cat > server-csr.json <<EOF
{
    "CN": "etcd",
    "hosts": [
    "192.168.116.21",
    "192.168.116.22",
    "192.168.116.23"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "BeiJing",
            "ST": "BeiJing"
        }
    ]
}
EOF
 
#hosts：将所有 etcd 集群节点添加到 host 列表，需要指定所有 etcd 集群的节点 ip 或主机名不能使用网段，新增 etcd 服务器需要重新签发证书。
 
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=www server-csr.json | cfssljson -bare server
 
#生成的文件：
#server.csr：服务器的证书请求文件
#server-key.pem：服务器的私钥
#server.pem：服务器的数字签名证书
 
#-config：引用证书生成策略文件 ca-config.json
#-profile：指定证书生成策略文件中的的使用场景，比如 ca-config.json 中的 www

vim etcd.sh
 
#!/bin/bash
#example: ./etcd.sh etcd01 192.168.116.21 etcd02=https://192.168.116.22:2380,etcd03=https://192.168.116.23:2380
 
#创建etcd配置文件/opt/etcd/cfg/etcd
ETCD_NAME=$1
ETCD_IP=$2
ETCD_CLUSTER=$3
 
WORK_DIR=/opt/etcd
 
cat > $WORK_DIR/cfg/etcd  <<EOF
#[Member]
ETCD_NAME="${ETCD_NAME}"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://${ETCD_IP}:2380"
ETCD_LISTEN_CLIENT_URLS="https://${ETCD_IP}:2379"
#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://${ETCD_IP}:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://${ETCD_IP}:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://${ETCD_IP}:2380,${ETCD_CLUSTER}"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
EOF
 
#Member:成员配置
#ETCD_NAME：节点名称，集群中唯一。成员名字，集群中必须具备唯一性，如etcd01
#ETCD_DATA_DIR：数据目录。指定节点的数据存储目录，这些数据包括节点ID，集群ID，集群初始化配置，Snapshot文件，若未指定-wal-dir，还会存储WAL文件；如果不指定会用缺省目录
#ETCD_LISTEN_PEER_URLS：集群通信监听地址。用于监听其他member发送信息的地址。ip为全0代表监听本机所有接口
#ETCD_LISTEN_CLIENT_URLS：客户端访问监听地址。用于监听etcd客户发送信息的地址。ip为全0代表监听本机所有接口
 
#Clustering：集群配置
#ETCD_INITIAL_ADVERTISE_PEER_URLS：集群通告地址。其他member使用，其他member通过该地址与本member交互信息。一定要保证从其他member能可访问该地址。静态配置方式下，该参数的value一定要同时在--initial-cluster参数中存在
#ETCD_ADVERTISE_CLIENT_URLS：客户端通告地址。etcd客户端使用，客户端通过该地址与本member交互信息。一定要保证从客户侧能可访问该地址
#ETCD_INITIAL_CLUSTER：集群节点地址。本member使用。描述集群中所有节点的信息，本member根据此信息去联系其他member
#ETCD_INITIAL_CLUSTER_TOKEN：集群Token。用于区分不同集群。本地如有多个集群要设为不同
#ETCD_INITIAL_CLUSTER_STATE：加入集群的当前状态，new是新集群，existing表示加入已有集群。
 
 
#创建etcd.service服务管理文件
cat > /usr/lib/systemd/system/etcd.service <<EOF
[Unit]
Description=Etcd Server
After=network.target
After=network-online.target
Wants=network-online.target
[Service]
Type=notify
EnvironmentFile=${WORK_DIR}/cfg/etcd
ExecStart=${WORK_DIR}/bin/etcd \
--cert-file=${WORK_DIR}/ssl/server.pem \
--key-file=${WORK_DIR}/ssl/server-key.pem \
--trusted-ca-file=${WORK_DIR}/ssl/ca.pem \
--peer-cert-file=${WORK_DIR}/ssl/server.pem \
--peer-key-file=${WORK_DIR}/ssl/server-key.pem \
--peer-trusted-ca-file=${WORK_DIR}/ssl/ca.pem \
--logger=zap \
--enable-v2
Restart=on-failure
LimitNOFILE=65536
[Install]
WantedBy=multi-user.target
EOF
 
#--enable-v2：开启 etcd v2 API 接口。当前 flannel 版本不支持 etcd v3 通信
#--logger=zap：使用 zap 日志框架。zap.Logger 是go语言中相对日志库中性能最高的
#--peer开头的配置项用于指定集群内部TLS相关证书（peer 证书），这里全部都使用同一套证书认证
#不带--peer开头的的参数是指定 etcd 服务器TLS相关证书（server 证书），这里全部都使用同一套证书认证
 
 
systemctl daemon-reload
systemctl enable etcd
systemctl restart etcd

生成CA证书、etcd 服务器证书以及私钥

./etcd-cert.sh
mkdir etcd-cert
mv ca* server* etcd-cert

3.2解压etcd软件包，获取二进制文件 etcd etcdctl

解压
tar xf etcd-v3.4.26-linux-amd64.tar.gz

[root@master01 etcd-v3.4.26-linux-amd64]# ls
Documentation  etcd  etcdctl  README-etcdctl.md  README.md  READMEv2-etcdctl.md
 
 
​
etcd是启动etcd程序进程用的
etcdctl是etcd命令行客户端的工具

3.3准备etcd集群配置文件

创建用于存放 etcd 配置文件，命令文件，证书的目录

mkdir -p /opt/etcd/{cfg,bin,ssl}
​
----------------------------------
cfg：存放配置文件的目录
bin：存放命令文件的目录
ssl：存放证书的目录

将etcd和etcdctl移动到bin目录

mv /opt/k8s/etcd-v3.4.26-linux-amd64/etcd etcdctl  /opt/etcd/bin
创建软连接，方便以后直接调用
ln -s /opt/etcd/bin/* /usr/local/bin/

cp /opt/k8s/etcd-cert/*.pem /opt/etcd/ssl/

3.4启动etcd进程服务，将所有节点加入到etcd集群中

cd /opt/k8s/
​
./etcd.sh etcd01 192.168.116.21 etcd02=https://192.168.116.22:2380,etcd03=https://192.168.116.23:2380
​
进入卡住状态等待其他节点加入，这里需要三台etcd服务同时启动，如果只启动其中一台后，服务会卡在那里，直到集群中所有etcd节点都已启动

 

3.4.1可另外打开一个窗口查看etcd进程是否正常

netstat -lntp | grep 2379
或
ps -aux | grep etcd
或
ps -ef | grep etcd

3.4.2把etcd相关证书文件、命令文件和服务管理文件全部拷贝到另外两个etcd集群节点

scp -r /opt/etcd/ node01:/opt/
scp -r /opt/etcd/ node02:/opt/
​
scp /usr/lib/systemd/system/etcd.service node01:/usr/lib/systemd/system/
scp /usr/lib/systemd/system/etcd.service node02:/usr/lib/systemd/system/

3.4.3进入node01和node02里更改配置文件

vim /opt/etcd/cfg/etcd

更改完之后开启etcd
​
systemctl enable --now etcd
netstat -lntp | grep 2379
成功后，这样所有的etcd服务全部起来了

3.4.4检查etcd群集状态

ETCDCTL_API=3 /opt/etcd/bin/etcdctl --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem --endpoints="https://192.168.116.21:2379,https://192.168.116.22:2379,https://192.168.116.23:2379" endpoint health --write-out=table
​
​
​
​
​
--cert-file：识别HTTPS端使用SSL证书文件
--key-file：使用此SSL密钥文件标识HTTPS客户端
--ca-file：使用此CA证书验证启用https的服务器的证书
--endpoints：集群中以逗号分隔的机器地址列表
cluster-health：检查etcd集群的运行状况

3.4.5查看etcd集群成员列表

ETCDCTL_API=3 /opt/etcd/bin/etcdctl --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem --endpoints="https://192.168.116.21:2379,https://192.168.116.22:2379,https://192.168.116.23:2379" --write-out=table member list

4.部署master组件

4.1在 master01 节点上操作

上传 master.zip 和 k8s-cert.sh 到 /opt/k8s 目录中，解压 master.zip 压缩包

cd /opt/k8s/
​
unzip master.zip
chmod +x *.sh

4.2准备证书

vim k8s-cert.sh

创建用于生成CA证书、相关组件的证书和私钥的目录
mkdir k8s-cert
mv k8s-cert.sh k8s-cert
cd k8s-cert/
chmod +x k8s-cert.sh
​
生成CA证书、相关组件的证书和私钥
./k8s-cert.sh

 

创建一个k8s的软件目录

cd /opt
mkdir kubernetes
​
cd kubernetes/
mkdir bin cfg ssl logs
​
​
cp /opt/k8s/k8s-cert/*.pem /opt/kubernetes/ssl

4.3 准备二进制文件

上传二进制包

cd /opt/k8s
​
tar xf kubernetes-server-linux-amd64.tar.gz

复制master组件的关键命令文件到 kubernetes工作目录的 bin 子目录中

cd /opt/k8s/kubernetes/server/bin
cp kube-apiserver kubectl kube-controller-manager kube-scheduler /opt/kubernetes/bin/
​
ln -s /opt/kubernetes/bin/* /usr/local/bin/

4.4准备认证文件

创建 bootstrap token 认证文件，apiserver 启动时会调用，然后就相当于在集群内创建了一个这个用户，接下来就可以用 RBAC 给他授权

cd /opt/k8s/
vim token.sh
#!/bin/bash
#获取随机数前16个字节内容，以十六进制格式输出，并删除其中空格
BOOTSTRAP_TOKEN=$(head -c 16 /dev/urandom | od -An -t x | tr -d ' ')
#生成 token.csv 文件，按照 Token序列号,用户名,UID,用户组 的格式生成
cat > /opt/kubernetes/cfg/token.csv <<EOF
${BOOTSTRAP_TOKEN},kubelet-bootstrap,10001,"system:kubelet-bootstrap"
EOF
​
chmod +x token.sh
./token.sh

4.5开启 apiserver 服务

cd /opt/k8s/
vim apiserver.sh
./apiserver.sh 192.168.116.21 https://192.168.116.21:2379,https://192.168.116.22:2379,https://192.168.116.23:2379
​
​
检查进程是否启动成功
ps aux | grep kube-apiserver

4.6启动 controller-manager 服务

cd /opt/k8s/
vim controller-manager.sh
./controller-manager.sh
​
ps aux | grep kube-controller-manager

4.7启动 scheduler 服务

cd /opt/k8s/
vim scheduler.sh
./scheduler.sh
ps aux | grep kube-scheduler

4.8生成kubectl连接集群的kubeconfig文件

vim admin.sh
./admin.sh
​
绑定默认cluster-admin管理员集群角色，授权kubectl访问集群
kubectl create clusterrolebinding cluster-system-anonymous --clusterrole=cluster-admin --user=system:anonymous

判断master是否正常，就用
kubectl get cs

4.9查看客户端和服务端的版本号

kubectl version

5.部署 Worker Node 组件

5.1在所有 node 节点上操作

#创建kubernetes工作目录

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

上传 node.zip 到 /opt 目录中，解压 node.zip 压缩包，获得kubelet.sh、proxy.sh

cd /opt/
mkdir k8s 
cd k8s
​
上传node.zip
unzip node.zip
chmod +x kubelet.sh proxy.sh

5.2在 master01 节点上操作

把 kubelet、kube-proxy 拷贝到 node 节点

cd /opt/k8s/kubernetes/server/bin
scp kubelet kube-proxy node01:/opt/kubernetes/bin/
scp kubelet kube-proxy node02:/opt/kubernetes/bin/

上传kubeconfig.sh文件到/opt/k8s/kubeconfig目录中，生成kubelet初次加入集群引导kubeconfig文件和kube-proxy.kubeconfig文件

mkdir /opt/k8s/kubeconfig
cd /opt/k8s/kubeconfig
​
​
修改里面的配置
vim kubeconfig.sh
chmod +x kubeconfig.sh
​
./kubeconfig.sh 192.168.116.21 /opt/k8s/k8s-cert/

把配置文件 bootstrap.kubeconfig、kube-proxy.kubeconfig 拷贝到 node 节点

scp bootstrap.kubeconfig kube-proxy.kubeconfig node01:/opt/kubernetes/cfg/
scp bootstrap.kubeconfig kube-proxy.kubeconfig node02:/opt/kubernetes/cfg/

RBAC授权，使用户 kubelet-bootstrap 能够有权限发起 CSR 请求证书

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

5.3在 node01 节点上操作

启动 kubelet 服务

cd /opt/k8s/
chmod +x kubelet.sh
./kubelet.sh 192.168.116.22
​
查看是否启动成功
ps aux | grep kubelet

 

5.4在 master01 节点上操作，通过 CSR 请求

检查到 node01 节点的 kubelet 发起的 CSR 请求，Pending 表示等待集群给该节点签发证书

kubectl get csr

通过 CSR 请求

kubectl certificate approve node-csr-te9jUMtI8OmMwIojbc3YMMqwp8O20w1q5znPVg7kZvQ

Approved,Issued 表示已授权 CSR 请求并签发证书

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

kubectl get node
​
进入node节点
查看证书
ls /opt/kubernetes/ssl

5.5在 node01 节点上操作

加载 ip_vs 模块

cd /usr/lib/modules/3.10.0-693.el7.x86_64/kernel/net/netfilter/ipvs
​
for i in $(ls /usr/lib/modules/$(uname -r)/kernel/net/netfilter/ipvs|grep -o "^[^.]*");do echo $i; /sbin/modinfo -F filename $i >/dev/null 2>&1 && /sbin/modprobe $i;done
​
查看模块是否加载完成
cat /proc/net/ip_vs

启动proxy服务

cd /opt/
vim ./proxy.sh
​
./proxy.sh 192.168.80.11
ps aux | grep kube-proxy

5.6进入node02节点

cd /usr/lib/modules/3.10.0-693.el7.x86_64/kernel/net/netfilter/ipvs
​
for i in $(ls /usr/lib/modules/$(uname -r)/kernel/net/netfilter/ipvs|grep -o "^[^.]*");do echo $i; /sbin/modinfo -F filename $i >/dev/null 2>&1 && /sbin/modprobe $i;done
​
查看模块是否加载完成
cat /proc/net/ip_vs
​

启动kubelet

cd /opt/k8s
​
vim kubelet.sh
​
./kubelet.sh 192.168.116.23
​
​
进入master节点
​
kubectl get csr
​
kubectl certificate approve node-csr-P7dmlFvwrB_FN7_769rPTIXpt8f-LsyTmS7UMYMBKkU
​
kubectl get csr
​
进入node节点
查看证书
ls /opt/kubernetes/ssl

启动proxy

cd /opt/k8s
vim proxy.sh
​
./proxy.sh 192.168.116.23
ps aux | grep proxy
​
进入master节点
kubectl get nodes

6.部署 CNI 网络组件

目前比较常用的时flannel和calico，flannel的功能比较简单，不具备复杂的网络策略配置能力，calico是比较出色的网络管理插件，但具备复杂网络配置能力的同时，往往意味着本身的配置比较复杂，所以相对而言，比较小而简单的集群使用flannel，考虑到日后扩容，未来网络可能需要加入更多设备，配置更多网络策略，则使用calico更好。

6.1部署 flannel

node01 节点上操作

上传flannel软件包到/opt/k8s

cd /opt/k8s
​
unzip flannel-v0.21.5.zip
docker load -i flannel-cni-plugin.tar
docker load -i flannel.tar

mkdir /opt/k8s/cni/bin
tar zxvf cni-plugins-linux-amd64-v1.3.0.tgz -C /opt/cni/bin

将node01的k8s目录中的所有.tar文件包复制给node02节点里

cd /opt/k8s
scp *.tar 192.168.116.23:/opt/k8s

进入node02节点

docker load -i flannel-cni-plugin.tar
docker load -i flannel.tar
​
docker images

再将node01的插件目录复制到node02节点中

进入node01
cd /opt
scp -r cni/ 192.168.116.23:/opt

将node01的yml文件复制到master节点中

scp kube-flannel.yml 192.168.116.21:/opt/k8s

在master执行yml文件

kubectl apply -f kube-flannel.yml
会自动创建flannel所需要的资源

检查部署是否成功
kubectl get pods -n kube-flannel -owide
​
当显示node01和node02节点都为running时，即为部署成功 

 
此时使用kubectl get nodes查看
两个节点都为reday
此时k8s集群都为正常了

也会在每个安装了flannel插件的节点上自动生成一个flannel.1的一个接口

ifconfig

7.部署 CoreDNS

CoreDNS 是 K8S 默认的集群内部 DNS 功能实现，为 K8S 集群内的 Pod 提供 DNS 解析服务

在所有node节点上上传coredns的镜像

cd /opt/k8s
​
docker load -i coredns.tar

到master节点上上传配置文件

cd /opt/k8s
​
kubectl apply -f coredns.yaml
创建文件

 

检查coredns是否运行

kubectl get pods -n kube-system

8.多Master部署

到master节点里的配置文件中新增一台master节点地址

cd /opt/k8s/k8s-cert
vim k8s-cert.sh

 

8.1进入新的master节点做初始化操作

关闭防火墙
```
systemctl stop firewalld
systemctl disable firewalld
iptables -F && iptables -t nat -F && iptables -t mangle -F && iptables -X
```
​
关闭selinux
```
setenforce 0
sed -i 's/enforcing/disabled/' /etc/selinux/config
```
​
关闭swap
```
swapoff -a
sed -ri 's/.*swap.*/#&/' /etc/fstab 
```
​
根据规划设置主机名
```
hostnamectl set-hostname master02
su
​
```
在master添加hosts
```
cat >> /etc/hosts << EOF
192.168.116.21 master01
192.168.116.24 master02
192.168.116.22 node01
192.168.116.23 node02
EOF
修改完之后要在所有节点里设置
vim /etc/hosts
添加192.168.116.24 master02
​
​
​
调整内核参数
```
cat > /etc/sysctl.d/k8s.conf << EOF
#开启网桥模式，可将网桥的流量传递给iptables链
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
#关闭ipv6协议
net.ipv6.conf.all.disable_ipv6=1
net.ipv4.ip_forward=1
EOF
​
sysctl --system
```
​
时间同步
```
yum install ntpdate -y
ntpdate time.windows.com
```

在master01的节点里把master02所需的配置文件发送过去

cd /opt
scp -r kubernetes/ /etcd/ master02:/opt

在master02节点里将传过去的原先的日志文件清空

cd /opt/kubernetes/logs
rm -rf *
​
cd /opt/etcd
rm -rf bin cfg

进入master01节点里将kube工具传给master02的家目录下

cd
scp -r .kube/ master02:/root
​
进入master02节点
ls -A
cd .kube
rm -rf cache/

进入master01节点

cd /usr/lib/systemd/system
scp kube-* master02:`pwd`
​
进入master02节点中去查看
ls /usr/lib/systemd/system/kube-*

修改master02启动的参数配置

cd /opt/kubernetes/cfg
vim kube-apiserver

vim kube-controller-manager

vim kube-scheduler

将程序都启动

systemctl enable kube-apiserver.service --now
systemctl enable kube-controller-manager.service --now
systemctl enable kube-scheduler.service --now
systemctl status kube-*

把bin目录中的二进制文件做个软连接

ln -s /opt/kubernetes/bin/* /usr/local/bin
​
检查各个node节点状态
kubectl get nodes
kubectl get cs

进入master查看证书

vim /opt/k8s/k8s-cert/k8s-cert.sh 
​
vip地址为192.168.116.200
两个负载均衡器的地址为14和15

准备好两台负载均衡，用nginx做负载均衡

192.168.116.14
192.168.116.15
​
systemctl stop firewalld
setenforce 0
​
cd /etc/yum.repos.d
上传nginx.repo包
​
yum install -y nginx
systemctl enable --now nginx

8.2使用四层代理做转发

先确认stream模块是否打开
nginx -V

cd /etc/nginx/
vim nginx.conf
​
在http上添加四层代理转发
​
stream {
    upstream k8s-apiservers {
        server 192.168.116.21:6443;
        server 192.168.116.24:6443;
 }
​
    server {
           listen 6443;
           proxy_pass k8s-apiservers;
    }
}
​
​
检查语法结构
nginx -t
systemctl restart nginx
​
​
至此nginx负载均衡已经准备好了

两台负载均衡 准备keepalived

yum install -y keepalived.x86_64

在192.168.116.14节点准备一个脚本文件

cd /etc/keepalived/
​
vim check_nginx.sh
​
#!/bin/bash
if ! killall -0 nginx
  then
  systemctl stop keepalived
fi

修改keepalived配置文件

vim keepalived.conf
​
​
! Configuration File for keepalived
​
global_defs {
   notification_email {
     acassen@firewall.loc
     failover@firewall.loc
     sysadmin@firewall.loc
   }
   notification_email_from Alexandre.Cassen@firewall.loc
   smtp_server 127.0.0.1
   smtp_connect_timeout 30
   router_id NGINX_01
}
​
vrrp_scipt check_nginx {
    interval 2
    script "/etc/keeplived/check_nginx.sh"
}
​
vrrp_instance VI_1 {
    state MASTER
    interface ens33
    virtual_router_id 51
    priority 100
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 1111
    }
    virtual_ipaddress {
        192.168.116.200
    }
    track_script {
      check_nginx
    }
}
​
systemctl enable --now keepalived.service
--------------------------------------------------------------------
检查是否有VIP地址
ip addr

scp * 192.168.116.15:`pwd`

然后将修改好的配置文件复制给192.168.116.15

scp * 192.168.116.15:`pwd`

进入192.168.116.15，修改keepalived.conf文件

cd /etc/keepalived/
vim keepalived.conf
​
​
! Configuration File for keepalived
​
global_defs {
   notification_email {
     acassen@firewall.loc
     failover@firewall.loc
     sysadmin@firewall.loc
   } 
   notification_email_from Alexandre.Cassen@firewall.loc
   smtp_server 127.0.0.1
   smtp_connect_timeout 30
   router_id NGINX_02
}  
​
vrrp_scipt check_nginx {
    interval 2
    script "/etc/keeplived/check_nginx.sh"
}   
​
vrrp_instance VI_1 {
    state BACKUP
    interface ens33
    virtual_router_id 51
    priority 90
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 1111
    }   
    virtual_ipaddress {
        192.168.116.200
    }   
    track_script {
      check_nginx
    } 
}   
​
​
systemctl enable --now keepalived.service

8.3修改node节点上的bootstrap.kubeconfig,kubelet.kubeconfig配置文件为VIP

cd /opt/kubernetes/cfg
-------------------------------------------
vim bootstrap.kubeconfig
server: https://192.168.116.200:6443
-------------------------------------------
vim kube-proxy.kubeconfig 
server: https://192.168.116.200:6443
-------------------------------------------
vim kubelet.kubeconfig
server: https://192.168.116.200:6443

8.4两台node节点重启kubelet和kube-proxy服务

systemctl restart kubelet.service kube-proxy.service

在负载均衡服务器上查看 nginx 和 node 、 master 节点的连接状态

netstat -natp | grep nginx

在master02上进行操作

cd /opt/kubernetes/cfg
​
--------------------------------------------------------------
vim kube-scheduler.kubeconfig
server: https://192.168.116.24:6443
-------------------------------------------------------------
vim kube-controller-manager.kubeconfig
server: https://192.168.116.24:6443
​
​
重启服务
systemctl restart kube-controller-manager.service  kube-scheduler.service

到此k8s多Master集群已完成搭建

总结

1.部署etcd

使用cfssl工具签发证书和私钥文件 解压etcd软件包，获取二进制文件 etcd etcdctl 准备etcd集群配置文件 启动etcd进程服务，将所有节点加入到etcd集群中

etcd的操作：
#查看etcd集群健康状态
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://IP1:2379,https://IP2:2379,https://IP3:2379" --cacert=CA证书 --cert=客户端证书 --key=客户端私钥 -wtable endpoint health
​
#查看etcd集群状态信息
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://IP1:2379,https://IP2:2379,https://IP3:2379" --cacert=CA证书 --cert=客户端证书 --key=客户端私钥 -wtable endpoint status
​
#查看etcd集群成员列表
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://IP1:2379,https://IP2:2379,https://IP3:2379" --cacert=CA证书 --cert=客户端证书 --key=客户端私钥 -wtable member list
​
#向etcd插入键值
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://IP1:2379" --cacert=CA证书 --cert=客户端证书 --key=客户端私钥 put <KEY> '<VALUE>'
​
#查看键的值
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://IP1:2379" --cacert=CA证书 --cert=客户端证书 --key=客户端私钥 get <KEY>
​
#删除键
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://IP1:2379" --cacert=CA证书 --cert=客户端证书 --key=客户端私钥 del <KEY>
​
#备份etcd数据库
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://IP1:2379" --cacert=CA证书 --cert=客户端证书 --key=客户端私钥 snapshot save 备份文件路径
​
#恢复etcd数据库
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://IP1:2379" --cacert=CA证书 --cert=客户端证书 --key=客户端私钥 snapshot restore 备份文件路径

2.部署master组件

1. 使用cfssl工具签发证书和私钥文件

2. 下载K8S软件包，获取二进制文件 kube-apiserver kube-controller-manager kube-scheduler

3. 准备 kube-apiserver 启动时要调用的 bootstrap-token 认证文件（token.csv）

4. 准备 kube-apiserver kube-controller-manager kube-scheduler 的进程服务启动参数配置文件

5. 准备 kube-controller-manager kube-scheduler kubectl 的 kubeconfig 集群引导配置文件（用于连接和验证 kube-apiserver）

6. 依次启动 kube-apiserver kube-controller-manager kube-scheduler 进程服务

7. 执行 kubectl get cs 命令查看master组件的健康状态

3.部署node组件

1. 获取二进制文件 kubelet kube-proxy

2. 准备 kubelet kube-proxy 使用的 kubeconfig集群引导配置文件 bootstrap.kubeconfig(kubelet首次访问apiserver使用认证的文件) kube-proxy.kubeconfig

3. 准备 kubelet kube-proxy 的进程服务启动参数配置文件

4. 启动 kubelet 进程服务，向 apiserver 发起 CSR 请求自动签发证书，master 通过 CSR 请求后 kubelet 即可获取到证书

5. 加载 ipvs 模块，启动 kube-proxy 进程服务

6. 安装 cni 网络插件（flannel或calico）和 CoreDNS

7. 执行 kubectl get nodes 命令查看node节点状态

4.部署多master高可用

1. 负责master组件相关的二进制文件、证书、私钥、启动参数配置文件、kubeconfig集群引导配置文件和etcd的证书、私钥文件

2. 修改 kube-apiserver kube-controller-manager kube-scheduler 启动参数配置文件里的监听地址和通告地址，再依次重启服务进程

3. 部署 nginx/haproxy 负载均衡器和 keepalived 高可用

4. 修改 kubelet kube-proxy kubectl 的kubeconfig集群引导配置文件里的server参数都指向keepalived的VIP地址，再重启 kubelet kube-proxy 服务进程

5. 修改其它master节点上的 kube-controller-manager kube-scheduler 的kubeconfig集群引导配置文件里的server参数都指向各自本机的apiserver地址，再重启服务进程