二进制部署Kubernetes集群（单Master节点)

最新推荐文章于 2024-04-02 22:55:34 发布

kele_baba

最新推荐文章于 2024-04-02 22:55:34 发布

阅读量452

点赞数

分类专栏： k8s kubernetes 云计算文章标签： kubernetes 自动化云计算

本文链接：https://blog.csdn.net/kele_baba/article/details/119594896

版权

kubernetes 同时被 3 个专栏收录

11 篇文章 1 订阅

订阅专栏

云计算

9 篇文章 1 订阅

订阅专栏

k8s

5 篇文章 0 订阅

订阅专栏

一、常见的K8S按照部署方式

Minikube

Minikube是一个工具，可以在本地快速运行一个单节点微型K8s，仅用于学习、预览K8S的一些特性使用，没有商业价值。
部署地址: https://kubernetes.io/docs/setup/minikube

Kubeadmin

Kubeadmin也是一个工具，提供 yum安装 kubeadm init 和 kubeadm join，用于快速部署K8s集群，相对简单。
部署地址: https://kubernetes.io/docs/reference/setup-tools/kubeadm/kubeadm/
缺点：证书只有一年，修改证书有效期为 100 年（默认为 1 年）vim ./cmd/kubeadm/app/constants/constants.go，CertificateValidity =24.365.100 修改后需要重新编译和安装服务。

二进制安装部署

大型企业生产首选，从官方下载发行版的二进制包，手动部署每个组件和自签TLS证书，组成K8S集群，新手推荐。
有 zip 和 tar.gz 两个系统的包
https://github.com/kubernetes/kubernetes/releases

1、二进制安装部署

Kubernetes二进制部署集群

环境准备

k8s集群master01: 192.168.118.12         kube-apiserver kube-controller-manager kube- scheduler etcd
k8s集群master02: 192.168.118.13

k8s集群node01: 192.168.118.14              kubelet kube-proxy docker flannel
k8s集群node02: 192.168.118.15

etcd集群节点1: 192.168.118.12              etcd 
etcd集群节点2: 192.168.118.14
etcd集群节点3: 192.168.118.15

负载均衡nginx+keepalive01 (master) : 192.168.118.16
负载均衡nginx+ keepalive02 (backup) : 192.168.118.17
systemctl disable firewalld .
setenforce 0

在这里插入图片描述

二、部署etcd集群

etcd集群节点1: 192.168.118.12              etcd 
etcd集群节点2: 192.168.118.14
etcd集群节点3: 192.168.118.15

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

1、etcd特点及端口

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

2、准备签发证书环境

CFSSL，是CloudFlare公司开源的一款PKI/TLS具。CFSSL包含一个命令行工.具和一个用于签名、验证和捆绑TLS 证书的HTTP API 服务。使用Go语言编写。

CFSSL 使用配置文件生成证书，因此自签之前，需要生成它识别的json格式的配置文件，CFSSL 提供了方便的命令行生成配置文件。CFSSL用来为etcd提供TLS 证书，它支持签三种类型的证书:

1、client 证书，服务端连接客户端时携带的证书，用于客户端验证服务端身份，如 kube-apiserver访问etcd;
2、server 证书，客户端连接服务端时携带的证书，用于服务端验证客户端身份，如 etcd对外提供服务;
3、peer 证书，相互之间连接时使用的证书，如 etcd 节点之间进行验证和通信。

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

3、在master01节点操作

1、下载证书制作工具

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 -0 /usr/local/bin/cfssl-certinfo
或
curl -L https://pkg.cfssl.org/R1.2/cfssl_linux-amd64 -o /usr/local/bin/cfss
curl -L https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64 -o /usr/local/bin/cfssljson
curl -L 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 <证书名称>   #查看证书的信息

2、创建k8s工作目录

mkdir /opt/k8sc
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.jsonca-csr.jsonca. pem server.csr server-key.pem
ca.csr ca-key.pem etcd-cert.sh server-csr.json server.pem

在这里插入图片描述

3、启动etcd服务

上传 etcd-v3.3.10-linux-amd64.tar.gz 到/opt/k8s/目录中，解压etcd 压缩包cd / opt /k8s/
tar zxvf etcd-v3.3.10-linux-amd64.tar.gzls
etcd-v3.3.10-linux-amd64

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

创建用于存放etcd配置文件，命令文件，证书的目录
mkdir -p /opt/etcd/{cfg, bin,ssl}
mv /opt/k8s/etcd-v3.3.10-linux-amd64/etcdctl etcd-v3.3.10-linux-amd64/etcd /opt/etcd/bin/
cp /opt/k8s/etcd-cert/*.pem /opt/etcd/ssl/ #所有的pem证书移过去，

./etcd.sh etcd01 192.168.118.12 etcd02=https://192.168.118.14:2380,etcd03=https://192.168.118.15:2380
//进入卡住状态等待其他节点加入，这里需要三台etcd服务同时启动，如果只启动其中一台后，服务会卡在那里，直到集群中所有etcd节点都已启动，可忽略这个情况
//另外打开一个窗口查看etcd进程是否正常
ps -ef l grep etcd

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

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

需要分别在node02和node03里面把   vim etcd/cdg/etcd 修改下参数

启动etcd
systemctl start etcd


在master01节点上操作，检查集群状态

检查一下etcd状态
Master服务器

cd /opt/etcd/bin/
ln -s /opt/etcd/bin/etcdctl /usr/local/bin/
cd /opt/etcd/ssl/

在这里插入图片描述

需要在node02里面把etcd/cdg/etcd 修改下参数
在这里插入图片描述

三、部署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了

systemctl start docker
systemctl status docker

四、配置flannel网络

1、flannel原理

实现不同node上的pod相互通信用的
flannel会把内部的pod iP封装到upd中根据在etcd保存的路由表通过物理网卡发送给目的node
目的node在接受到转发来的数据后由flannel 解封装暴露出udp里的内部Pod ip，再根据目的Ip由flannel0 --> docker0
转发到目的pod中，Flannel 转发的时候会去etcd 的存储路由条目中去查找
不同pod之间进行通信的过程
Flannel 会把内部的pod数据包封装到 UDP 当中，UDP 中包含源地址（自己 Pod 的地址）和目标 Pod IP 地址，根据在etcd保存的路由表通过物理网卡发送给目的 Node，Flannel 直接通过证书认证和 etcd 通信获取路由表；
目的 Node 在接受到转发来的数据后，由 Flannel 服务进行解封装暴露出 UDP 里的内部 Pod ip ，再根据目的 IP 由 Flannel 网卡发送到 docker 0 上，最后转发到目的 Pod 中。

在这里插入图片描述

2、flannel操作步骤

使用etcdctl在etcd中添加flannel 的网段和转发模式upd、vxlan
准备flannel 安装包
生成docker网络配置参数并启动flannel服务
修改docker启动参数，使docker0网卡和flannel网卡保持在-一个网段里
验证node之间的容器通信是否正常

从 k8s 的网络模型我们可以看出来，在 k8s 当中希望做到的是每一个 Pod 都有一个在集群当中独一无二的IP，并且可以通过这个IP直接跟集群当中的其他 Pod 以及节点自身的网络进行通信，一句话概括就是 k8s 当中希望网络是扁平化的。所以只要再符合 k8s 网络模型的要求，就可以以插件的方式在 k8s 集群中作为跨节点网络通信实现。目前比较流行的实现有 flannel, calico, weave, canal等。这里结合我们自己在阿里云中的 k8s 集群的 CNI flannel 来解释 pod 之间的通信过程。

https://www.cnblogs.com/goldsunshine/p/10740928.html
https://www.cnblogs.com/k8s/p/12066624.html

Flannel是CoreOS团队针对Kubernetes设计的一个网络规划服务，简单来说，它的功能是让集群中的不同节点主机创建的Docker容器都具有全集群唯一的虚拟IP地址。

K8S 中Pod 网络通信:
- Pod内容器与容器之间的通信
  在同一个 Pod 内的容器（Pod 内的容器是不会跨宿主机的）共享同一个网络命令空间相当于它们在同一台机器上一样，可以用localhost地址访问彼此的端口。
- 同一个Node内 Pod之间的通信
  每个Pod 都有一个真实的全局IP地址，同一个 Node内的不同Pod之间可以直接采用对方 Pod 的IP 地址进行通信，
  Pod1与Pod2都是通过Veth连接到同一个docker0 网桥，网段相同，所以它们之间可以直接通信。172.17.0.0网段
- 不同 Node 上 Pod 之间的通信
  Pod地址与 docker0在同一网段，docker0网段与宿主机网卡是两个不同的网段，且不同 Node之间的通信只能通过宿主机的物理网卡进行。docker0 是所有pod对外通信的端口
- 要想实现不同Node 上. Pod 之间的通信，就必须想办法通过主机的物理网卡IP地址进行寻址和通信。

因此要满足两个条件：

Pod的IP不能冲突;
将Pod的IP和所在的 Node 的IP 关联起来，通过这个关联让不同Node 上 Pod之间直接通过内网IP地址通信。

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

VXLAN:
将源数据包封装到UDP中，并使用基础网络的IP/MAC作为外层报文头进行封装，然后在以太网上传输，到达目的地后由隧道端点解封装并将数据发送给目标地址。
性能比UDP好，默认模式是UDP

Flannel：
是Overlay网络的一种，也是将源数据包封装在另一种网络包里面进行路由转发和通信，目前已经支持UDP、VXLAN、AWS VPC和GCE路由等数据转发方式。

3、实验步骤

1.写入分配的子网段到ETCD中，供flannel使用
Master01上操作
cd /opt/etcd/ssl
etcdctl --ca-file=ca.pem --cert-file=server.pem --key-file=server-key.pem --endpoints="https://192.168.118.12:2379,https://192.168.118.14:2379,https://192.168.118.15:2379" set /coreos.com/network/config '{ "Network": "172.17.0.0/16", "Backend": {"Type": "vxlan"}}'


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


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

将 flanneld 和 mk-docker-opts.sh 放入工作目录中的bin目录下
mv flanneld mk-docker-opts.sh /opt/kubernetes/bin/


4.编写启动脚本
vim flannel.sh

#!/bin/bash

#定义etcd集群的端点IP地址和对外提供服务的2379端口
#${var:-string}：若变量var为空，则用在命令行中用string来替换；否则变量var不为空时，则用变量var的值来替换，这里的1代表的是位置变量$1
ETCD_ENDPOINTS=${1:-"http://127.0.0.1:2379"}

#创建flanneld配置文件
cat > /opt/kubernetes/cfg/flanneld <<EOF
FLANNEL_OPTIONS="--etcd-endpoints=${ETCD_ENDPOINTS} \\
-etcd-cafile=/opt/etcd/ssl/ca.pem \\
-etcd-certfile=/opt/etcd/ssl/server.pem \\
-etcd-keyfile=/opt/etcd/ssl/server-key.pem"
EOF

#flanneld 本应使用 etcd 客户端TLS相关证书（client 证书），这里全部都使用同一套证书认证。


#创建flanneld.service服务管理文件
cat > /usr/lib/systemd/system/flanneld.service <<EOF
[Unit]
Description=Flanneld overlay address etcd agent
After=network-online.target network.target
Before=docker.service

[Service]
Type=notify
EnvironmentFile=/opt/kubernetes/cfg/flanneld
ExecStart=/opt/kubernetes/bin/flanneld --ip-masq \$FLANNEL_OPTIONS
ExecStartPost=/opt/kubernetes/bin/mk-docker-opts.sh -k DOCKER_NETWORK_OPTIONS -d /run/flannel/subnet.env
Restart=on-failure

[Install]
WantedBy=multi-user.target

EOF

#flanneld启动后会使用 mk-docker-opts.sh 脚本生成 docker 网络相关配置信息
#mk-docker-opts.sh -k DOCKER_NETWORK_OPTIONS：将组合选项键设置为环境变量DOCKER_NETWORK_OPTIONS，docker启动时将使用此变量
#mk-docker-opts.sh -d /run/flannel/subnet.env：指定要生成的docker网络相关信息配置文件的路径，docker启动时候引用此配置

systemctl daemon-reload
systemctl enable flanneld
systemctl restart flanneld


给权限启动脚本
chmod +x flannel.sh
./flannel.sh https://192.168.73.188:2379,https://192.168.73.88:2379,https://192.168.73.166:2379
systemctl status flanneld.service
此时会多出一个flannel网卡

cat /run/flannel/subnet.env
可以查看flannel的环境变量

5.配置docker连接flannel
vim /usr/lib/systemd/system/docker.service

----------------13行和14行添加------------------
13 EnvironmentFile=/run/flannel/subnet.env
14 ExecStart=/usr/bin/dockerd $DOCKER_NETWORK_OPTIONS -H fd:// --containerd=/run/containerd/containerd.sock


6.重载和重启docker服务
systemctl  daemon-reload
systemctl restart docker
ifconfig 此时docker0和flannel在同一网段


7.验证flannel
ping -I node1和node2上的docker0 的地址
或者
两台node都需要这样操作
docker run -it centos:7 /bin/bash
yum install net-tools -y
ifconfig
互相ping 对方的网卡

在这里插入图片描述

五、部署master组件

1、api-server生成证书

在master上操作

[root@master1 ~]# cd k8s/
#将 master.zip上传到该目录下进行解压
[root@master1 k8s]# unzip master.zip
[root@master1 k8s]# chmod +x controller-manager.sh 

[root@master1 k8s]# mkdir -p /opt/kubernetes/{cfg,bin,ssl} 

[root@master1 k8s]# mkdir k8s-cert   #创建k8s-cert.sh上传到该目录下进行解压
[root@master1 k8s]# mv /opt/k8s/k8s-cert.sh /opt/k8s/k8s-cert
[root@master1 k8s]# cd /opt/k8s/k8s-cert/
[root@master1 k8s]# chmod +x *
[root@master1 k8s]# vim k8s-cert.sh


#查看并修改k8s-cert.sh脚本

修改这边的IP地址
cat > server-csr.json <<EOF
{
    "CN": "kubernetes",
    "hosts": [
      "10.0.0.1",
      "127.0.0.1",
      "192.168.118.12",  //master1
      "192.168.118.13",  //master2
      "192.168.118.18",  //vip
      "192.168.118.16",  //lb （master）
      "192.168.118.17",  //lb （backup）

2、生成k8s证书

[root@master1 k8s-cert]# ./k8s-cert.sh

[root@master1 k8s-cert]# ls *.pem   
admin-key.pem  ca.pem              server-key.pem
admin.pem      kube-proxy-key.pem  server.pem
ca-key.pem     kube-proxy.pem

[root@master1 k8s-cert]# cp ca*pem apiserver*pem /opt/kubernetes/ssl/
[root@master1 k8s-cert]# cd /opt/kubernetes/ssl/
[root@master1 ssl#ls

在这里插入图片描述

3、上传 kubernetes-server-linux-amd64.tar.gz到/opt/k8s/目录中,解压kubernetes压缩包，并做token认证文件

kubernetes压缩包上传到 /opt/k8s/目录中，然后解压
[root@master1 k8s]# tar zxvf kubernetes-server-linux-amd64.tar.gz

[root@master1 k8s]# cd /opt/k8s/kubernetes/server/bin
[root@master1 bin]# cp kube-apiserver kubectl kube-controller-manager kube-scheduler /opt/kubernetes/bin/
[root@master1 bin]# ln -s /opt/kubernetes/bin/* /usr/local/bin/

#token认证文件
[root@master1 bin]# cd /opt/k8s/
[root@master1 k8s]# head -c 16 /dev/urandom | od -An -t x | tr -d ' '
849b37696c2aefc70a979562a2bab824
#使用 head -c 16 /dev/urandom | od -An -t x | tr -d ' ' 可以随机生成序列号

[root@master1 k8s]# vim /opt/kubernetes/cfg/token.csv
849b37696c2aefc70a979562a2bab824,kubelet-bootstrap,10001,"system:kubelet-bootstrap"

在这里插入图片描述

4、二进制文件，token，证书都准备好，开启apiserver

[root@master1 k8s]# chmod +x apiserver.sh
[root@master1 k8s]# ./apiserver.sh 192.168.118.12 https://192.168.118.12:2379,https://192.168.118.14:2379,https://192.168.118.15:2379

[root@master01 k8s]# netstat -natp | grep 6443
[root@master01 k8s]# netstat -natp | grep 8080

[root@master01 k8s]# systemctl daemon-reload
[root@master01 k8s]# systemctl restart kube-apiserver
#检查进程是否启动成功
[root@master1 k8s]# ps aux | grep kube-apiserver
root      55228  0.0  0.0 112676   984 pts/2    S+   17:20   0:00 grep --color=auto kube

在这里插入图片描述

5、启动scheduler服务

[root@master1 k8s]# cd /opt/k8s/
[root@master01 k8s]# chmod +x scheduler.sh
[root@master1 k8s]# ./scheduler.sh 127.0.0.1

[root@master1 k8s]# ps aux | grep kube-scheduler

6、启动controller-manager

[root@master1 k8s]# cd /opt/k8s/
[root@master1 k8s]# ./controller-manager.sh 127.0.0.1

7、查看master 节点状态

[root@master1 k8s]# kubectl get componentstatuses
NAME                 STATUS    MESSAGE             ERROR
controller-manager   Healthy   ok                  
scheduler            Healthy   ok                  
etcd-1               Healthy   {"health":"true"}   
etcd-0               Healthy   {"health":"true"}   
etcd-2               Healthy   {"health":"true"}

在这里插入图片描述

六、node节点部署

在master上操作

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

[root@master1 ~]# cd /opt/k8s/kubernetes/server/bin
[root@master1 bin]# scp kubelet kube-proxy root@192.168.118.14:/opt/kubernetes/bin/

[root@master1 bin]# scp kubelet kube-proxy root@192.168.118.15:/opt/kubernetes/bin/

在nod01节点操作

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

unzip node.zip

在这里插入图片描述

在Master节点上操作

3、创建用于生成kubelet的配置文件的目录

mkdir /opt/k8s/kubeconfig

4、上传kubeconfig.sh文件到/opt/k8s / kubeconfig目录中

cd /opt/k8s/kubeconfig
vim kubeconfig.sh
#!/bin/bash
#example: kubeconfig 192.168.118.12 /opt/k8s/k8s-cert/
#创建bootstrap.kubeconfig文件
#该文件中内置了 token.csv 中用户的 Token，以及 apiserver CA 证书；kubelet 首次启动会加载此文件，使用 apiserver CA 证书建立与 apiserver 的 TLS 通讯，使用其中的用户 Token 作为身份标识向 apiserver 发起 CSR 请求

BOOTSTRAP_TOKEN=$(awk -F ',' '{print $1}' /opt/kubernetes/cfg/token.csv)
APISERVER=$1
SSL_DIR=$2

export KUBE_APISERVER="https://$APISERVER:6443"

# 设置集群参数
kubectl config set-cluster kubernetes \
  --certificate-authority=$SSL_DIR/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=bootstrap.kubeconfig
#--embed-certs=true：表示将ca.pem证书写入到生成的bootstrap.kubeconfig文件中

# 设置客户端认证参数，kubelet 使用 bootstrap token 认证
kubectl config set-credentials kubelet-bootstrap \
  --token=${BOOTSTRAP_TOKEN} \
  --kubeconfig=bootstrap.kubeconfig

# 设置上下文参数
kubectl config set-context default \
  --cluster=kubernetes \
  --user=kubelet-bootstrap \
  --kubeconfig=bootstrap.kubeconfig

# 使用上下文参数生成 bootstrap.kubeconfig 文件
kubectl config use-context default --kubeconfig=bootstrap.kubeconfig

#----------------------

#创建kube-proxy.kubeconfig文件
# 设置集群参数
kubectl config set-cluster kubernetes \
  --certificate-authority=$SSL_DIR/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=kube-proxy.kubeconfig

# 设置客户端认证参数，kube-proxy 使用 TLS 证书认证
kubectl config set-credentials kube-proxy \
  --client-certificate=$SSL_DIR/kube-proxy.pem \
  --client-key=$SSL_DIR/kube-proxy-key.pem \
  --embed-certs=true \
  --kubeconfig=kube-proxy.kubeconfig

# 设置上下文参数
kubectl config set-context default \
  --cluster=kubernetes \
  --user=kube-proxy \
  --kubeconfig=kube-proxy.kubeconfig

# 使用上下文参数生成 kube-proxy.kubeconfig 文件
kubectl config use-context default --kubeconfig=kube-proxy.kubeconfig

chmod +x kubeconfig.sh

5、生成kubelet的配置文件

./kubeconfig.sh 192.168.118.12 /opt/k8s/k8s-cert/

在这里插入图片描述

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

scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.118.14:/opt/kubernetes/cfg/
scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.118.15:/opt/kubernetes/cfg/

在这里插入图片描述

7、RBAC授权

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

在这里插入图片描述

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

查看已授权的角色
kubectl get clusterrolebinding

在这里插入图片描述
在node01节点上操作

8、使用Kubelet.sh脚本启动kubelet服务

cd /opt	
chmod +x kubelet.sh
./kubelet.sh 192.168.118.14

检查kueblet服务
ps aux | grep kubelet

在这里插入图片描述

Master01上操作

9、在Master上查看node是否连接成功，通过CSR请求

kubectl get csr
NAME                                                   AGE   REQUESTOR           CONDITION
node-csr-LQlhOPaP9NATcz1FWBZf7CvKIyNhX0rKoX5wsa_Pt0g   46s   kubelet-bootstrap   Pending
node-csr-WoFcXvlfYfBrKhuGA-woDYxOy-OAcnv6fXaodnLykfo   24s   kubelet-bootstrap   Pending


kubectl certificate approve node-csr-LQlhOPaP9NATcz1FWBZf7CvKIyNhX0rKoX5wsa_Pt0g
kubectl certificate approve node-csr-WoFcXvlfYfBrKhuGA-woDYxOy-OAcnv6fXaodnLykfo

kubectl get csr 再次查看连接状态

在这里插入图片描述

10、查看集群节点状态

kubectl get nodes

在这里插入图片描述

在node1节点上操作

11、自动生成了证书和kubelet.kubeconfig文件

ls /opt/kubernetes/cfg/kubelet.kubeconfig
ls /opt/kubernetes/ssl/

在这里插入图片描述

12、加载 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

在这里插入图片描述

13、使用proxy.sh脚本启动proxy服务

cd /opt
chmod +x proxy.sh
./proxy.sh 192.168.118.14
systemctl status kube-proxy.service

在这里插入图片描述

14、将node01节点上将kubelet.sh、proxy.sh文件拷贝到node02节点中

scp kubelet.sh proxy.sh root@192.168.118.15:/opt/

15、查看集群状态

kubectl get nodes

在这里插入图片描述

kele_baba

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
二进制部署Kubernetes集群（单Master节点)

一、部署etcd集群etcd是Coreos团队于2013年6月发起的开源项目，它的目标是构建一个高可用的分布式键值(key-value)数据库。etcd内部采用raft协议作为一致性算法,etcd是go语言编写的。1、etcd特点及端口etcd 作为服务发现系统,有以下的特点:简单: 安装配置简单，而且提供了HTTP API进行交互，使用也很简单安全:支持ssL证书验证快速: 单实例支持每秒2k+读操作可靠: 采用raft算法，实现分布式系统数据的可用性和一致性etcd 日前默认使用2
复制链接

扫一扫