目录

单 Master集群部署 + 多 Master群集部署
在这里插入图片描述

环境准备

k8s集群master01:192.168.80.10   kube-apiserver kube-controller-manager kubescheduler etcd
k8s集群master02:192.168.80.90

k8s集群node01:192.168.80.20     kubelet kube-proxy docker flannel
k8s集群node02:192.168.80.30

etcd集群节点1:192.168.80.10      etcd
etcd集群节点2:192.168.80.20
etcd集群节点3:192.168.80.30

负载均衡nginx+keepalive01 (master):192.168.80.40
负载均衡nginx+keepalive02 (backup):i92.168.80.50

systemctl stop firewalld
systemctl disable firewalld
setenforce 0

#至少3台，一master二node三etcd,生产环境中etcd需独立部署，实验中etcd可部署在master下减少带宽使用
  • 关闭防火墙，更改主机名
    在这里插入图片描述

一、部署etcd集群

  1. etcd是CoreOS团队于2013年6月发起的开源项目，它的目标是构建一个高可用的分布式键值（key-value)数据库。etcd内部采用raft协议作为一致性算法，etcd是go语言编写的。

  2. etcd 作为服务发现系统,有以下的特点:

  • 简单:安装配置简单，而且提供了HTTP API进行交互，使用也很简单
  • 安全:支持ssL证书验证
  • 快速:单实例支持每秒2k+读操作
  • 可靠:采用raft算法，实现分布式系统数据的可用性和一致性
  1. etcd 目前默认使用2379端口提供HTTP API服务，2380端口和peer通信(这两个端口已经被IANA(互联网数字分配机构)官方预留给etcd)。
    ——即etcd默认使用2379端口对外为客户端提供通讯，使用端口2380来进行服务器间内部通讯。
  2. etcd在生产环境中一般推荐集群方式部署。由于etcd 的leader选举机制，要求至少为3台或以上的奇数台。

准备签发证书环境

  • CFSSL是CloudFlare公司开源的一款 PKI/TLS 工具。CPSSI包含一个命令行工具和一个用于签名、验证和捆绑TLS证书的arr&API服务。使用Go语言编写。
  • CFSSI使用配置文件生成证书，因此自签之前，需要生成它识别的json格式的配置文件，
  • CFSSl提供了方便的命令行生成配置文件。CFSSL用来为etcd提供TLS证书，它支持签三种类型的证书:
    1、client 证书，服务端连接客户端时携带的证书，用于客户端验证服务端身份，如 kube-apiserver 访问 etcd;
    2、server 证书，客户端连接服务端时携带的证书，用于服务端验证客户端身份，如etcd 对外提供服务;
    3、peer 证书，相互之间连接时使用的证书，如 etcd节点之间进行验证和通信。
    这里全部都使用同一套证书认证。

使用证书访问的工作流程
(1）客户端发起请求，连接到服务器的进程端口。
(2）服务器必须要有一套数字证书（证书内容有公钥、证书颁发机构、失效日期等）。
(3）服务器将自己的数字证书发送给客户端（公钥在证书里面，私钥由服务器持有）。
(4）客户端收到数字证书之后，会验证证书的合法性。如果证书验证通过，就会生成一个随机的密钥对，用证书的公钥加密。
(5）客户端将公钥加密后的密钥发送到服务器。
(6）服务器接收到客户端发来的密文密钥之后，用自己之前保留的私钥对其进行非对称解密，解密之后就得到客户端的密钥，然后用客户端密钥对返回数据进行对称加密，这样传输的数据都是密文了。
(7）服务器将加密后的密文数据返回到客户端。
(8）客户端收到后，用自己的密钥对其进行对称解密，得到服务器返回的数据。

etcd部署

在 master01 节点上操作

k8s单节点包
密码;y6ct

  1. 下载证书制作工具
wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64 -O /usr/local/bin/cfssl
wget https://pkg.cfssl.org/R1.2/cfss]json_linux-amd64 -O /usr/local/bin/cfssljson
wget https://pkg.cfssl.org/R1.2/cfssi-certinfo_linux-amd64 -O /usr/local/bin/cfssl-certinfo
或
curl -I https://pkg.cfssl.org/R1.2/cfssl_linux-amd64 -o /usr/local/bin/cfssl
curl -I https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64 -o /usr/local/bin/cfssljson
curl -I https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64 -o /usr/local/bin/cfssl-certinfo

chmod +x /usr/local/bin/cfssl *

在这里插入图片描述

cfssl:          证书签发的工具命令
cfssljson:      将 cfssl 生成的证书 (json格式）变为文件承载式证书
cfssl-certinfo: 验证证书的信息
cfssl-certinfo -cert <证书名称>   #查看证书的信息
  1. 生成CA证书、etcd服务器证书以及私钥
//创建k8s工作目录
mkdir /opt/k8s
cd /opt/k8s/

//上传etcd-cert.sh和etcd.sh到/opt/k8s/目录中
chmod +x etcd-cert.sh etcd.sh

//创建用于生成CA证书、etcd服务器证书以及私钥的目录
mkdir /opt/k8s/etcd-cert
mv etcd-cert.sh etcd-cert/
cd /opt/k8s/etcd-cert/
./etcd-cert.sh
#生成CA证书、etcd服务器证书以及私钥

ls
ca-config.json   ca-csr.json   ca.pem         server.csr        server-key.pem
ca.csr           ca-key.pem    etcd-cert.sh   server-csr.json   server.pem
  • 创建k8s工作目录
    在这里插入图片描述
  • 上传etcd-cert.sh和etcd.sh到/opt/k8s/目录中
    在这里插入图片描述
  • 创建用于生成CA证书、etcd服务器证书以及私钥的目录
    在这里插入图片描述
    在这里插入图片描述
  1. 启动etcd服务
//上传etcd-v3.3.10-linux-amd64.tar.gz到/opt/k8s/目录中，解压etcd压缩包
cd /opt/k8s/
tar zxvf etcd-v3.3.10-linux-amd64.tar.gz
ls etcd-v3.3.10-linux-amd64
Documentation   etcd   etcdctl   README-etcdctl.md  README.md   READMEv2-etcdctl.md

#etcd就是etcd服务的启动命令，后面可跟各种启动参数
#etcdctl主要为etcd服务提供了命令行操作

在这里插入图片描述
在这里插入图片描述

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

mv /opt/k8s/etcd-v3.3.10-linux-amd64/etcd /opt/k8s/etcd-v3.3.10-linux-amd64/etcdctl /opt/etcd/bin/
cp /opt/k8s/etcd-cert/*.pem /opt/etcd/ssl/

 ./etcd.sh etcd01 192.168.80.10 etcd02=https://192.168.80.20:2380,etcd03=https://192.168.80.30:2380
//进入卡住状态等待其他节点加入，这里需要三台etcd服务同时启动，如果只启动其中一台后，服务会卡在那里，直到集群中所有etcd节i点都已启动，可忽略这个情况

//另外打开一个窗口查看etcd进程是否正常
ps -ef | grep etcd

//把etcd相关证书文件和命令文件全部拷贝到另外两个etcd集群节点
scp -r /opt/etcd/ root@192.168.80.20:/opt/
scp -r /opt/etcd/ root@192.168.80.30:/opt/

//把etcd服务管理文件拷贝到另外两个etcd集群节点
scp /usr/lib/systemd/system/etcd.service root@192.168.80.20:/usr/lib/systemd/system/
scp /usr/lib/systemd/system/etcd.service root@192.168.80.30:/usr/lib/systemd/system/

//启动etcd服务
systemctl start etcd
systemctl status etcd
systemctl enable etcd

  • 创建用于存放etcd配置文件,命令文件,证书的目录
    在这里插入图片描述
    在这里插入图片描述

  • 进入卡住状态等待其他节点加入，这里需要三台etcd服务同时启动，如果只启动其中一台后，服务会卡在那里，直到集群中所有etcd节i点都已启动，可忽略这个情况
    在这里插入图片描述

  • 另外打开一个窗口查看etcd进程是否正常
    在这里插入图片描述

  • 把etcd相关证书文件和命令文件全部拷贝到另外两个etcd集群节点
    在这里插入图片描述

  • 把etcd服务管理文件拷贝到另外两个etcd集群节点
    在这里插入图片描述

  • 将etcd/cfg/etcd内容进行更改成相应节点，并开启etcd服务设置成开机自启动（master01、node1、2步骤相同）
    在这里插入图片描述
    在这里插入图片描述

  1. 在 master01 节点上操作
ln -s /opt/etcd/bin/etcd* /usr/local/bin

//检查etcd群集状态
cd /opt/etcd/ssl
/opt/etcd/bin/etcdctl \
--ca-file=ca.pem \
--cert-file=server.pem \
--key-file=server-key.pem \
--endpoints="https://192.168.80.10:2379,https://192.168.80.20:2379,https://192.168.80.30:2379" \
cluster-health

-----------------------------------------------------------------------------------
--cert-file:   识别HTTPS端使用ssL证书文件
--key-file:    使用此sSL密钥文件标识HTTPS客户瑞
--ca-file:     使用此CA证书验证启用https的服务器的证书
--endpoints:   集群中以逗号分隔的机器地址列表
cluster-health:检查etcd集群的运行状况
-----------------------------------------------------------------------------------
  • 做软连接方便系统识别
    在这里插入图片描述
    在这里插入图片描述
//切换到etcd3版本查看集群节点状态和成员列表
export ETCDCTL_API=3
#v2和v3命令略有不同，etcd2和etcd3也是不兼容的，默认是v2版本
etcdctl --write-out=table endpoint status
etcdctl --write-out=table member list
export ETCDCTL_API=2
#再切回v2版本

在这里插入图片描述

yum 部署docker引擎 
//所有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

在这里插入图片描述

在这里插入图片描述

flannel 网络配置

在这里插入图片描述

K8S 中Pod 网络通信:

  • Pod 内容器与容器之间的通信
  1. 在同一个 Pod 内的容器（Pod 内的容器是不会跨宿主机的）共享同一个网络命令空间，相当于它们在同一台机器上一样，可以用localhost地址访|问彼此的端口。
  • 同一个Node 内 Pod 之间的通信
  1. 每个 Pod都有一个真实的全局TP地址，同一个Node 内的不同 Pod之间可以直接采用对方 Pod 的IP地址进行通信，Pod1与Pod2都是通过Veth 连接到同一个docker0网桥，网段相同，所以它们之间可以直接通信。
  • 不同Node 上 Pod 之间的通信
  1. Pod地址与docker0在同一网段，docker0网段与宿主机网卡是两个不同的网段，且不同Node之间的通信只能通过宿主机的物理网卡进行。
  2. 要想实现不同Node上Pod之间的通信，就必须想办法通过主机的物理网卡P地址进行寻址和通信。
  3. 因此要满足两个条件:
  • Pod 的IP不能冲突;
  • 将 Pod 的IP 和所在的 Node 的TP 关联起来，通过这个关联让不同Node 上. Pod
    之间直接通过内网IP地址通信。

Overlay Network

  • 叠加网络，在二层或者三层基础网络上叠加的一种虚拟网络技术模式，该网络中的主机通过虚拟链路隧道连接起来（类似于VPN)。

VXLAN

  • 将源数据包封装到UDP中，并使用基础网络的TP/NAc作为外层报文头进行封装，然后在以太网上传输，到达目的地后由隧道瑞点解封装并将数据发送给目标地址。

Flannel

  • Flannel的功能是让集群中的不同节点主机创建的 Docker容器都具有全集群唯一的虚拟
    IP地址。
  • Flannel是0verlay网络的一种，也是将 TCP源数据包封装在另一种网络包里面进行路由转发和通信，目前己经支持UDP、VZLANV、AWS VPC等数据转发方式。

在这里插入图片描述

Flannel工作原理

  1. 数据从nodel1上 Pod 的源容器中发出后，经由所在主机的 docker0虚拟网卡转发到flannel0虚拟网卡，flanneld服务监听在flannel0虚拟网卡的另外一端。
  2. Flannel通过 Etcd服务维护了一张节点间的路由表。源主机node01的 flanneld 服务将原本的数据内容封装到UDP中后
  3. 根据自己的路由表通过物理网卡投递给目的节点 node02的 flanneld服务，数据到达以后被解包，然后直接进入目的节点的flannel0虚拟网卡，
  4. 之后被转发到目的主机的docker0虚拟网卡，最后就像本机容器通信一样由 docker0转发到目标容器。

ETCD之Flannel提供说明:

  • 存储管理Flannel可分配的IP地址段资源
  • 监控 ETCD中每个 Pod 的实际地址，并在内存中建立维护 Pod节点路由表

Flannel搭建部署

#####在master01节点上操作#####
//添加 flannel 网络配置信息，写入分配的子网段到etcd中，供flannel使用
cd /opt/etcd/ssl
/opt/etcd/bin/etcdctl \
--ca-file=ca.pem \
--cert-file=server.pem \
--key-file=server-key.pem \
--endpoints="https://192.168.80.10:2379,https://192.168.80.20:2379,https://192.168.80.30:2379" \
set /coreos.com/network/config '{"Network":"172.17.0.0/16"，"Backend":{"Type":"vxlan"}}'

//查看写入的信息
/opt/etcd/bin/etcdctl \
--ca-file=ca.pem \
--cert-file=server.pem \
--key-file=server-key.pem \
--endpoints="https://192.168.80.10:2379,https://192.168.80.20:2379,https://192.168.80.30:2379" \
get /coreos.com/network/config

在这里插入图片描述

在这里插入图片描述

set <key> <value>
set /coreos.com/network/config添加一条网络配置记录，这个配置将用于flannel分配给每个docker的虚拟IP地址段
get <key>
get /coreos.com/network/config 获取网络配置记录，后面不用再跟参数了

Network:用于指定Flannel地址池
Backend:用于指定数据包以什么方式转发，默认为udp模式，Backend为vxlan比起预设的
udp性能相对好一些

#####在所有node节点上操作#####
//上传flannel.sh和flannel-v0.10.0-linux-amd64.tar.gz到/opt目录中,解压flannel压缩包
cd /opt
tar zxvf flannel-v0.10.0-linux-amd64.tar.gz

flanneld             #flanneld为主要的执行文件
mk-docker-opts.sh    #mk-docker-opts.sh脚本用于生成Docker启动参数
README.md

//创建kubernetes工作目录
mkdir -p /opt/kubernetes/{cfg,bin,ssl}

cd /opt
mv mk-docker-opts.sh flanneld /opt/kubernetes/bin/

//启动flanneld服务，开启flannel网络功能
cd /opt
chmod +x flannel.sh
./flannel.sh https://192.168.80.10:2379,https://192.168.80.20:2379,https://192.168.80.30:2379

//flannel启动后会生成一个docker网络相关信息配置文件/run/flannel/subnet.env，包含了docker要使用flannel通讯的相关参数
cat /run/flannel/subnet.env
DOCKER_OPT_BIP="--bip=172.17.26.1/24"
DOCKER_OPT_IPMASQ="--ip-masq=false"
DOCKEROPTMTU="--mtu=1450"
DOCKER_NETWORK_OPTIONS="--bip=172.17.26.1/24 --ip-masq=false --mtu=1450"

--bi:指定docker启动时的子网
--ip-masq:设置ipmasq=false 关闭snat伪装策略
--mtu=1450: mtu要留出50字节给外层的vxlan封包的额外开销使用

Flannel启动过程解析:
1、从etcd中获取network的配置信息
2、划分subnet，并在etcd中进行注册
3、将子网信息记录到/run/flannel/subnet.env中

  • 上传flannel文件和压缩包到/opt目录下，并解压缩
    在这里插入图片描述

  • 创建kubernetes工作目录
    在这里插入图片描述

  • flannel启动后会生成一个docker网络相关信息配置文件/run/flannel/subnet.env，包含了docker要使用flannel通讯的相关参数
    在这里插入图片描述
    在这里插入图片描述

//修改docker服务管理文件，配置docker连接flannel
vim /lib/systemd/system/docker.service
------
[Service]
Type=notify
# the default is not to use systemd for cgroups because the delegate issues still
# exists and systemd currently does not support the cgroup feature set required
# for containers run by docker
EnvironmentFile=/run/flannel/subnet.env   #添加
ExecStart=/usr/bin/dockerd $DOCKER_NETWORK_OPTIONS -H fd:// --containerd=/run/containerd/containerd.sock   #修改
ExecReload=/bin/kill -s HUP $MAINPID
TimeoutSec=0
RestartSec=2
Restart=always

//重启docker服务
systemctl daemon-reload
systemctl restart docker
  • 修改docker服务管理文件，配置docker连接flannel（node01、02相同）
    在这里插入图片描述
  • 重启docker服务（node01、02相同），并测试docker能否互通

在这里插入图片描述
1）node上测试互通
在这里插入图片描述
2）不同node节点里容器里测试互通
执行yum install -y net-tools命令，查看ifconfig
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

部署master组件

#####在master01节点上操作#####
//上传master.zip和k8s-cert.sh到/opt/k8s目录中，解压master.zip压缩包
cd /opt/k8s/
unzip master.zip
apiserver.sh
scheduler.sh
controller-manager.sh

chmod +x *.sh

//创建kubernetes工作目录
mkdir -p /opt/kubernetes/{cfg,bin,ssl}

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

ls *pem
admin-key.pem   apiserver-key.pem   ca-key.pem   kube-proxy-key.pem  
admin.pem       apiserver.pem       ca.pem       kube-proxy.pem
//controller-manager和kube-scheduler设置为只调用当前机器的apiserver,使用127.0.0.1:8080通信，因此不需要签发证书

//复制CA证书、apiserver相关证书和私钥到 kubernetes工作目录的ssl子目录中
cp ca*pem apiserver*pem /opt/kubernetes/ssl/

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

如下更改：
vim k8s-cert.sh 
------------------------
cat > apiserver-csr.json <<EOF
{
    "CN": "kubernetes",
    "hosts": [
      "10.0.0.1",
      "127.0.0.1",
      "192.168.80.10",
      "192.168.80.20",
      "192.168.80.100",
      "192.168.80.40",
      "192.168.80.50",
      "kubernetes",
      "kubernetes.default",
      "kubernetes.default.svc",
      "kubernetes.default.svc.cluster",
      "kubernetes.default.svc.cluster.local"
    ],

在这里插入图片描述

  • 复制CA证书、apiserver相关证书和私钥到 kubernetes工作目录的ssl子目录中
    在这里插入图片描述
//上传kubernetes-server-linux-amd64.tar.gz到/opt/k8s/目录中，解压kubernetes压缩包
cd /opt/k8s/
tar zxvf 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/

//创建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

cat /opt/kubernetes/cfg/token.csv
  • 复制master组件的关键命令文件到kubernetes工作目录的bin子目录中
    在这里插入图片描述
  • 创建bootstrap token认证文件，apiserver启动时会调用，然后就相当于在集群内创建了一个这个用户，接下来就可以用RBAC给他授权
    在这里插入图片描述
    在这里插入图片描述
//二进制文件、token、证书都准备好后，开启apiserver服务
cd /opt/k8s/
./apiserver.sh 192.168.80.10 https:/192.168.80.10:2379, https:/192.168.80.20:2379,https://192.168.80.30:2379

//检查进程是否启动成功
ps aux | grep kube-apiserver

//k8s通过kube-apiserver这个进程提供服务，该进程运行在单个master节点上。默认有两个端口6443和8080
//安全端口6443用于接收HTTPS请求，用于基于Token文件或客户端证书等认证
//本地端口8080用于接收HTTP请求，非认证或授权的HTTP请求通过该端口访问API Server
netstat -natp | grep 6443
netstat -natp | grep 8080
  • 二进制文件、token、证书都准备好后，开启apiserver服务
    在这里插入图片描述
  • 检查进程是否启动成功
    在这里插入图片描述
  • k8s通过kube-apiserver这个进程提供服务，该进程运行在单个master节点上。默认有两个端口6443和8080
    在这里插入图片描述
//查看版本信息（必须保证apiserver启动正常，不然无法查询到server的版本信息)
kubectl version

//启动scheduler服务
cd /opt/k8s/
./scheduler.sh 127.0.0.1
ps aux | grep kube-scheduler

//启动controller-manager服务
cd /opt/k8s/
./controller-manager.sh 127.0.0.1

//查看master节点状态
kubectl get componentstatuses          #也可以kubectl get cs

  • 查看版本信息（必须保证apiserver启动正常，不然无法查询到server的版本信息)
    在这里插入图片描述

  • 启动scheduler服务
    在这里插入图片描述

  • 启动controller-manager服务
    在这里插入图片描述

  • 查看节点状态
    在这里插入图片描述

部署 node 组件

##### 在 master01 节点上操作 #####
//把 kubelet、kube-proxy 拷贝到 node 节点
cd /opt/k8s/kubernetes/server/bin
scp kubelet kube-proxy root@192.168.80.20:/opt/kubernetes/bin/
scp kubelet kube-proxy root@192.168.80.30:/opt/kubernetes/bin/


##### 在 node01 节点上操作 #####
//上传 node.zip 到 /opt 目录中，解压 node.zip 压缩包，获得kubelet.sh、proxy.sh
cd /opt/
unzip node.zip


##### 在 master01 节点上操作 #####
//创建用于生成kubelet的配置文件的目录
mkdir /opt/k8s/kubeconfig

//上传 kubeconfig.sh 文件到 /opt/k8s/kubeconfig 目录中
#kubeconfig.sh 文件包含集群参数（CA 证书、API Server 地址），客户端参数（上面生成的证书和私钥），集群 context 上下文参数（集群名称、用户名）。Kubenetes 组件（如 kubelet、kube-proxy）通过启动时指定不同的 kubeconfig 文件可以切换到不同的集群，连接到 apiserver。
cd /opt/k8s/kubeconfig
chmod +x kubeconfig.sh

//生成kubelet的配置文件
cd /opt/k8s/kubeconfig
./kubeconfig.sh 192.168.80.10 /opt/k8s/k8s-cert/

ls
bootstrap.kubeconfig  kubeconfig.sh  kube-proxy.kubeconfig

//把配置文件 bootstrap.kubeconfig、kube-proxy.kubeconfig 拷贝到 node 节点
cd /opt/k8s/kubeconfig
scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.80.20:/opt/kubernetes/cfg/
scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.80.30:/opt/kubernetes/cfg/

//RBAC授权，将预设用户 kubelet-bootstrap 与内置的 ClusterRole system:node-bootstrapper 绑定到一起，使其能够发起 CSR 请求
kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap
  • 把 kubelet、kube-proxy 拷贝到 node 节点
    在这里插入图片描述
  • 上传 node.zip 到 /opt 目录中，解压 node.zip 压缩包，获得kubelet.sh、proxy.sh
    在这里插入图片描述
  • 创建用于生成kubelet的配置文件的目录
    在这里插入图片描述
  • 上传 kubeconfig.sh 文件到 /opt/k8s/kubeconfig 目录中
    在这里插入图片描述
  • 生成kubelet的配置文件
    在这里插入图片描述
  • 把配置文件 bootstrap.kubeconfig、kube-proxy.kubeconfig 拷贝到 node 节点
    在这里插入图片描述
  • RBAC授权，将预设用户 kubelet-bootstrap 与内置的 ClusterRole system:node-bootstrapper 绑定到一起，使其能够发起 CSR 请求
    在这里插入图片描述

  • kubelet 采用 TLS Bootstrapping 机制，自动完成到 kube-apiserver 的注册，在 node 节点量较大或者后期自动扩容时非常有用。

  • Master apiserver 启用 TLS 认证后，node 节点 kubelet 组件想要加入集群，必须使用CA签发的有效证书才能与 apiserver 通信，当 node 节点很多时，签署证书是一件很繁琐的事情。因此 Kubernetes 引入了 TLS bootstraping 机制来自动颁发客户端证书，kubelet 会以一个低权限用户自动向 apiserver 申请证书，kubelet 的证书由 apiserver 动态签署。

  • kubelet 首次启动通过加载 bootstrap.kubeconfig 中的用户 Token 和 apiserver CA 证书发起首次 CSR 请求，这个 Token 被预先内置在 apiserver 节点的 token.csv 中，其身份为 kubelet-bootstrap 用户和 system:kubelet-bootstrap 用户组；想要首次 CSR 请求能成功（即不会被 apiserver 401 拒绝），则需要先创建一个 ClusterRoleBinding，将 kubelet-bootstrap 用户和 system:node-bootstrapper 内置 ClusterRole 绑定（通过 kubectl get clusterroles 可查询），使其能够发起 CSR 认证请求。

  • TLS bootstrapping 时的证书实际是由 kube-controller-manager 组件来签署的，也就是说证书有效期是 kube-controller-manager 组件控制的；kube-controller-manager 组件提供了一个 --experimental-cluster-signing-duration 参数来设置签署的证书有效时间；默认为 8760h0m0s，将其改为 87600h0m0s，即 10 年后再进行 TLS bootstrapping 签署证书即可。

  • 也就是说 kubelet 首次访问 API Server 时，是使用 token 做认证，通过后，Controller Manager 会为 kubelet 生成一个证书，以后的访问都是用证书做认证了。

//查看角色：
kubectl get clusterroles | grep system:node-bootstrapper

//查看已授权的角色：
kubectl get clusterrolebinding

在这里插入图片描述

##### 在 node01 节点上操作 #####
//使用kubelet.sh脚本启动kubelet服务
cd /opt/
chmod +x kubelet.sh
./kubelet.sh 192.168.80.20

//检查kubelet服务启动
ps aux | grep kubelet

//此时还没有生成证书
ls /opt/kubernetes/ssl/

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

##### 在 master01 节点上操作 #####
//检查到 node01 节点的 kubelet 发起的 CSR 请求，Pending 表示等待集群给该节点签发证书
kubectl get csr
NAME                                                   AGE     REQUESTOR           CONDITION
node-csr-NOI-9vufTLIqJgMWq4fHPNPHKbjCXlDGHptj7FqTa8A   2m      kubelet-bootstrap   Pending

//通过 CSR 请求
kubectl certificate approve node-csr-NOI-9vufTLIqJgMWq4fHPNPHKbjCXlDGHptj7FqTa8A

//再次查看 CSR 请求状态，Approved,Issued 表示已授权 CSR 请求并签发证书
kubectl get csr
NAME                                                   AGE     REQUESTOR           CONDITION
node-csr-NOI-9vufTLIqJgMWq4fHPNPHKbjCXlDGHptj7FqTa8A   4m      kubelet-bootstrap   Approved,Issued

//查看群集节点状态，成功加入node01节点
kubectl get nodes
NAME            STATUS   ROLES    AGE    VERSION
192.168.80.20   Ready

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

##### 在 node01 节点上操作 #####
//自动生成了证书和 kubelet.kubeconfig 文件
ls /opt/kubernetes/cfg/kubelet.kubeconfig
ls /opt/kubernetes/ssl/

//加载 ip_vs 模块
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

//使用proxy.sh脚本启动proxy服务
cd /opt/
chmod +x proxy.sh
./proxy.sh 192.168.80.20

systemctl status kube-proxy.service

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

—— node02 节点部署
##方法一：


//在 node01 节点上将 kubelet.sh、proxy.sh 文件拷贝到 node02 节点
cd /opt/
scp kubelet.sh proxy.sh root@192.168.80.30:/opt/

##### 在 node02 节点上操作 #####
//使用kubelet.sh脚本启动kubelet服务
cd /opt/
chmod +x kubelet.sh
./kubelet.sh 192.168.80.30

##### 在 master01 节点上操作 #####
//在 master01 节点上操作查看 CSR 请求
kubectl get csr
NAME                                                   AGE   REQUESTOR           CONDITION
node-csr-OaH9HpIKh6AKlfdjEKm4C6aJ0UT_1YxNaa70yEAxnsU   15s   kubelet-bootstrap   Pending

//通过 CSR 请求
kubectl certificate approve node-csr-OaH9HpIKh6AKlfdjEKm4C6aJ0UT_1YxNaa70yEAxnsU

kubectl get csr
NAME                                                   AGE   REQUESTOR           CONDITION
node-csr-OaH9HpIKh6AKlfdjEKm4C6aJ0UT_1YxNaa70yEAxnsU   2m   kubelet-bootstrap    Approved,Issued

//查看群集中的节点状态
kubectl get nodes
NAME            STATUS   ROLES    AGE    VERSION
192.168.80.11   Ready    
192.168.80.12   Ready    

##### 在 node02 节点上操作 #####
//加载 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

//使用proxy.sh脚本启动proxy服务
cd /opt/
chmod +x proxy.sh
./proxy.sh 192.168.80.30

systemctl status kube-proxy.service

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
单节点二进制部署k8s已完毕…

##方法二：

//在node01节点操作，把现成的/opt/kubernetes目录和kubelet、kube-proxy的service服务管理文件复制到其他node节点
scp -r /opt/kubernetes/ root@192.168.80.12:/opt/
scp /usr/lib/systemd/system/{kubelet,kube-proxy}.service root@192.168.80.12:/usr/lib/systemd/system/

//在node02节点上操作，进行修改
//首先删除复制过来的证书，等会node02会自行申请证书
cd /opt/kubernetes/ssl/
rm -rf *

//修改配置文件kubelet、kubelet.config、kube-proxy的相关IP地址配置为当前节点的IP地址
cd /opt/kubernetes/cfg
vim kubelet
KUBELET_OPTS="--logtostderr=true \
--v=4 \
--hostname-override=192.168.80.12 \     #修改
......

vim kubelet.config
kind: KubeletConfiguration
apiVersion: kubelet.config.k8s.io/v1beta1
address: 192.168.80.12					#修改

vim kube-proxy
KUBE_PROXY_OPTS="--logtostderr=true \
--v=4 \ 
--hostname-override=192.168.80.12 \		#修改

//加载 ipvs 模块
modprobe ip_vs

//启动kubelet和kube-proxy服务并设置开机自启
systemctl start kubelet.service
systemctl enable kubelet.service
systemctl start kube-proxy.service
systemctl enable kube-proxy.service

//到master01节点上发现未授权的node02请求，授权node02加入集群
kubectl get csr
NAME                                                   AGE   REQUESTOR           CONDITION
node-csr-P3996HQxx_2PLeo9bxBu7TVPcWgbAWqla5yj8Wa_5ks   15s   kubelet-bootstrap   Pending

//授权许可加入群集
kubectl certificate approve node-csr-P3996HQxx_2PLeo9bxBu7TVPcWgbAWqla5yj8Wa_5ks

kubectl get csr

kubectl get nodes

二、多节点二进制部署

在这里插入图片描述

---------- master02 节点部署 ----------

//从 master01 节点上拷贝证书文件、各master组件的配置文件和服务管理文件到 master02 节点
scp -r /opt/etcd/ root@192.168.80.60:/opt/
scp -r /opt/kubernetes/ root@192.168.80.60:/opt
scp /usr/lib/systemd/system/{kube-apiserver,kube-controller-manager,kube-scheduler}.service root@192.168.80.60:/usr/lib/systemd/system/

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

//修改配置文件kube-apiserver中的IP
vim /opt/kubernetes/cfg/kube-apiserver
KUBE_APISERVER_OPTS="--logtostderr=true \
--v=4 \
--etcd-servers=https://192.168.80.10:2379,https://192.168.80.20:2379,https://192.168.80.30:2379 \
--bind-address=192.168.80.90 \				#修改
--secure-port=6443 \
--advertise-address=192.168.80.90 \			#修改

在这里插入图片描述

//在 master02 节点上启动各服务并设置开机自启
systemctl start kube-apiserver.service
systemctl enable kube-apiserver.service
systemctl start kube-controller-manager.service
systemctl enable kube-controller-manager.service
systemctl start kube-scheduler.service
systemctl enable kube-scheduler.service

在这里插入图片描述

//查看node节点状态
ln -s /opt/kubernetes/bin/* /usr/local/bin/
kubectl get nodes
kubectl get nodes -o wide			#-o=wide：输出额外信息；对于Pod，将输出Pod所在的Node名
//此时在master02节点查到的node节点状态仅是从etcd查询到的信息，而此时node节点实际上并未与master02节点建立通信连接，因此需要使用一个VIP把node节点与master节点都关联起来
  • -o=wide：输出额外信息；对于Pod，将输出Pod所在的Node名
    在这里插入图片描述

三、负载均衡部署

  • 配置load balancer集群双机热备负载均衡（nginx实现负载均衡，keepalived实现双机热备）
    在这里插入图片描述
    在这里插入图片描述

在lb01、lb02节点上操作

(操作相同，仅展示lb01)

//配置nginx的官方在线yum源，配置本地nginx的yum源
cat > /etc/yum.repos.d/nginx.repo << 'EOF'
[nginx]
name=nginx repo
baseurl=http://nginx.org/packages/centos/7/$basearch/
gpgcheck=0
EOF

yum install nginx -y

在这里插入图片描述

在这里插入图片描述

//修改nginx配置文件，配置四层反向代理负载均衡，指定k8s群集2台master的节点ip和6443端口
	vim /etc/nginx/nginx.conf
events {
    worker_connections  1024;
}

#添加
stream {
    log_format  main  '$remote_addr $upstream_addr - [$time_local] $status $upstream_bytes_sent';
    
	access_log  /var/log/nginx/k8s-access.log  main;

    upstream k8s-apiserver {
        server 192.168.80.10:6443;
        server 192.168.80.60:6443;
    }
    server {
        listen 6443;
        proxy_pass k8s-apiserver;
    }
}

http {

在这里插入图片描述

//检查配置文件语法
nginx -t   

//启动nginx服务，查看已监听6443端口
systemctl start nginx
systemctl enable nginx
netstat -natp | grep nginx 


//部署keepalived服务
yum install keepalived -y

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

//修改keepalived配置文件
vim /etc/keepalived/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_MASTER	#lb01节点的为 NGINX_MASTER，lb02节点的为 NGINX_BACKUP
}

#添加一个周期性执行的脚本
vrrp_script check_nginx {
    script "/etc/nginx/check_nginx.sh"	#指定检查nginx存活的脚本路径
}

vrrp_instance VI_1 {
    state MASTER			#lb01节点的为 MASTER，lb02节点的为 BACKUP
    interface ens33			#指定网卡名称 ens33
    virtual_router_id 51	#指定vrid，两个节点要一致
    priority 100			#lb01节点的为 100，lb02节点的为 90
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 1111
    }
    virtual_ipaddress {
        192.168.80.100/24	#指定 VIP
    }
    track_script {
        check_nginx			#指定vrrp_script配置的脚本
    }
}

在这里插入图片描述

//创建nginx状态检查脚本 
vim /etc/nginx/check_nginx.sh
#!/bin/bash
#egrep -cv "grep|$$" 用于过滤掉包含grep 或者 $$ 表示的当前Shell进程ID
count=$(ps -ef | grep nginx | egrep -cv "grep|$$")

if [ "$count" -eq 0 ];then
    systemctl stop keepalived
fi


chmod +x /etc/nginx/check_nginx.sh

在这里插入图片描述

//启动keepalived服务（一定要先启动了nginx服务，再启动keepalived服务）
systemctl start keepalived
systemctl enable keepalived
ip a				#查看VIP是否生成

//修改node节点上的bootstrap.kubeconfig,kubelet.kubeconfig配置文件为VIP
cd /opt/kubernetes/cfg/
vim bootstrap.kubeconfig 
server: https://192.168.80.100:6443
                      
vim kubelet.kubeconfig
server: https://192.168.80.100:6443
                        
vim kube-proxy.kubeconfig
server: https://192.168.80.100:6443

//重启kubelet和kube-proxy服务
systemctl restart kubelet.service 
systemctl restart kube-proxy.service

//在lb01上查看nginx的k8s日志
tail /var/log/nginx/k8s-access.log

##### 在 master01 节点上操作 ##### 
//测试创建pod
kubectl run nginx --image=nginx

//查看Pod的状态信息
kubectl get pods
NAME                    READY   STATUS              RESTARTS   AGE
nginx-dbddb74b8-nf9sk   0/1     ContainerCreating   0          33s   #正在创建中

kubectl get pods
NAME                    READY   STATUS    RESTARTS   AGE
nginx-dbddb74b8-nf9sk   1/1     Running   0          80s  			#创建完成，运行中

kubectl get pods -o wide
NAME                    READY   STATUS    RESTARTS   AGE   IP            NODE            NOMINATED NODE
nginx-dbddb74b8-26r9l   1/1     Running   0          10m   172.17.36.2   192.168.80.15   <none>
//READY为1/1，表示这个Pod中有1个容器

//在对应网段的node节点上操作，可以直接使用浏览器或者curl命令访问
curl 172.17.36.2

//这时在master01节点上查看nginx日志，发现没有权限查看
kubectl logs nginx-dbddb74b8-nf9sk
Error from server (Forbidden): Forbidden (user=system:anonymous, verb=get, resource=nodes, subresource=proxy) ( nginx-dbddb74b8-nf9sk)

//在master01节点上，将cluster-admin角色授予用户system:anonymous
kubectl create clusterrolebinding cluster-system-anonymous --clusterrole=cluster-admin --user=system:anonymous
clusterrolebinding.rbac.authorization.k8s.io/cluster-system-anonymous created

//再次查看nginx日志
kubectl logs nginx-dbddb74b8-nf9sk
Logo
K8S/Kubernetes

K8S/Kubernetes社区为您提供最前沿的新闻资讯和知识内容

更多推荐

【深度】阿里巴巴万级规模 K8s 集群全局高可用体系之美

作者 |  韩堂、柘远、沉醉来源 | 阿里巴巴云原生公众号​前言台湾作家林清玄在接受记者采访的时候，如此评价自己 30 多年写作生涯：“第一个十年我才华横溢，‘贼光闪现’，令周边黯然失色；第二个十年，我终于‘宝光现形’，不再去抢风头，反而与身边的美丽相得益彰；进入第三个十年，繁华落尽见真醇，我进入了‘醇光初现’的阶段，真正体味到了境界之美”。​长夜有穷，真水无香。领略过了 K8s“身在江

avatar K8S/Kubernetes

如何基于 K8s 构建下一代 DevOps 平台？

作者 | 孙健波（天元）导读：当前云原生 DevOps 体系现状如何？面临哪些挑战？如何通过 OAM 解决云原生 DevOps 场景下的诸多问题？云原生开发应用模型 OAM(Open Application Model) 社区核心成员孙健波将为大家一一解答，并分享如何基于 OAM 和 Kubernetes 打造无限能力的下一代 DevOps 平台。什么是 DevOps？为什么基于 Kub

avatar K8S/Kubernetes

k8s 火了！

2020，上云之年，产品云端化成为一种趋势。在一线城市，很多公司都已经构建了自己的私有云环境，比如阿里云、网易云、华为云等。而Kubernetes 作为基于容器编排领域的王者，具备扩展...

avatar K8S/Kubernetes