1. 首页
  2. 文章中心
  3. Kubernetes自学

kubernetes二进制集群部署--------单master集群（步骤非常详细，适合初学者）

100 阅读 0 评论
我是靠谱客的博主 爱笑黄豆，这篇文章主要介绍kubernetes二进制集群部署--------单master集群（步骤非常详细，适合初学者），现在分享给大家，希望可以做个参考。

文章目录

    • 一、集群环境
    • 二、部署master节点组件
      • 2.1、部署 apiserver
        • 2.1.1、制作api-server证书
        • 2.1.2、解压二进制文件
        • 2.1.3、制作token令牌
        • 2.1.4、开启 apiserver
      • 2.2、部署scheduler
      • 2.3、部署controller-manager
    • 三、部署node节点组件
      • 3.1、部署kubeconfig
      • 3.2、部署node1的kubelet组件
      • 3.3、部署node1 的kube-proxy组件
      • 3.4、部署node2节点的 kubelet 和 kube-proxy 服务
    • 四、验证集群

一、集群环境

在上篇博客介绍过了，我的搭建部署也是在上一篇的基础上做的。
博客链接：kubernetes 集群部署之ETCD数据库部署、flannel网络组件安装

二、部署master节点组件

在 Master 上要部署以下三大核心组件：

  • kube-apiserver：是集群的统一入口，各组件协调者，所有对象资源的增删改查和监听操作都交给 APIServer 处理后再提交给 Etcd 存储；

  • kube-controller-manager：处理群集中常规后台任务，一个资源对应一个控制器，而 controller-manager 就是负责管理这些控制器的；

  • kube-scheduler：根据调度算法为新创建的 Pod 选择一个 Node 节点，可以任意部署，可以部署在同一个节点上，也可以部署在不同节点上。

  • 操作流程：配置文件 -----> systemd 管理组件 -----> 启动

先把master压缩包放在k8s目录下

复制代码
1
2
[root@localhost k8s]# unzip master.zip

解压出来的三个组件脚本我自己编写的，具体内容在下面的操作中展示。
在这里插入图片描述

复制代码
1
2
3
[root@localhost k8s]# chmod +x controller-manager.sh    #给controll脚本加上权限
[root@localhost k8s]# mkdir -p /opt/kubernetes/{cfg,ssl,bin}

2.1、部署 apiserver

2.1.1、制作api-server证书

1、创建api-server证书目录

复制代码
1
2
3
[root@localhost k8s]# mkdir k8s-cert
[root@localhost k8s]# cd k8s-cert/

2、编写证书生成脚本

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
[root@localhost k8s-cert]# vi k8s-cert.sh     

#编写ca证书的配置文件
cat > ca-config.json <<EOF
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "kubernetes": {
         "expiry": "87600h",
         "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ]
      }
    }
  }
}
EOF

#编写ca签名证书文件
cat > ca-csr.json <<EOF
{
    "CN": "kubernetes",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Beijing",
            "ST": "Beijing",
      	    "O": "k8s",
            "OU": "System"
        }
    ]
}
EOF

#使用签名证书生成ca.pem、ca-key.pem文件
cfssl gencert -initca ca-csr.json | cfssljson -bare ca -

#编写apiserver的签名证书
注意：master2节点和LB节点的IP地址是 为了之后的多master节点部署添加的
cat > server-csr.json <<EOF
{
    "CN": "kubernetes",
    "hosts": [
      "10.0.0.1",
      "127.0.0.1",
      "192.168.100.128",    #master1节点
      "192.168.100.132",    #master2节点
      "192.168.100.100",    #VIP地址
      "192.168.100.133",    #负载调度器（master节点）
      "192.168.100.129",    #负载调度器（backup节点）
      "kubernetes",
      "kubernetes.default",
      "kubernetes.default.svc",
      "kubernetes.default.svc.cluster",
      "kubernetes.default.svc.cluster.local"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "BeiJing",
            "ST": "BeiJing",
            "O": "k8s",
            "OU": "System"
        }
    ]
}
EOF

#使用之前的文件生成server证书
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes server-csr.json | cfssljson -bare server

#编写用户证书
cat > admin-csr.json <<EOF
{
  "CN": "admin",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "BeiJing",
      "ST": "BeiJing",
      "O": "system:masters",
      "OU": "System"
    }
  ]
}
EOF

cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes admin-csr.json | cfssljson -bare admin

# 编写 kube-proxy 证书
cat > kube-proxy-csr.json <<EOF
{
  "CN": "system:kube-proxy",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "BeiJing",
      "ST": "BeiJing",
      "O": "k8s",
      "OU": "System"
    }
  ]
}
EOF

cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-proxy-csr.json | cfssljson -bare kube-proxy

3、执行脚本，并把通信证书拷贝到 /opt/kubernetes/ssl目录下

复制代码
1
2
3
4
[root@localhost k8s-cert]# bash k8s-cert.sh 

[root@localhost k8s-cert]# cp ca*pem server*pem /opt/kubernetes/ssl/

在这里插入图片描述

2.1.2、解压二进制文件

1、解压k8s安装包

复制代码
1
2
[root@localhost k8s]# tar zxvf kubernetes-server-linux-amd64.tar.gz

在这里插入图片描述
2、复制关键的命令文件到/opt/kubernetes/bin/

复制代码
1
2
3
4
[root@localhost ~]# cd /root/k8s/kubernetes/server/bin/

[root@localhost bin]# cp kube-apiserver kubectl kube-controller-manager kube-scheduler /opt/kubernetes/bin/

2.1.3、制作token令牌

复制代码
1
2
3
4
5
6
7
8
9
10
[root@localhost ~]# cd /root/k8s/

//使用下面的 head命令 随机生成序列号
[root@localhost k8s]# head -c 16 /dev/urandom | od -An -t x | tr -d ' '
84cf410ca1d9dd456dbba668de2c1aca    #复制序列号写入 token.csv 中

[root@localhost k8s]# vi /opt/kubernetes/cfg/token.csv
#写入内容：序列号,用户名,id,角色
84cf410ca1d9dd456dbba668de2c1aca,kubelet-bootstrap,10001,"system:kubelet-bootstrap"

在这里插入图片描述

2.1.4、开启 apiserver

1、二进制文件、token令牌、证书都准备好了，开启apiserver，指向ETCD集群，把信息保存到ETCD中。

复制代码
1
2
3
[root@localhost k8s]# bash apiserver.sh 
Created symlink from /etc/systemd/system/multi-user.target.wants/kube-apiserver.service to /usr/lib/systemd/system/kube-apiserver.service.

apiserver.sh脚本：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#!/bin/bash

MASTER_ADDRESS=$1
ETCD_SERVERS=$2

#在k8s工作目录里生成kube-apiserver 配置文件
cat <<EOF >/opt/kubernetes/cfg/kube-apiserver

KUBE_APISERVER_OPTS="--logtostderr=true \
--v=4 \
--etcd-servers=${ETCD_SERVERS} \
--bind-address=${MASTER_ADDRESS} \
--secure-port=6443 \
--advertise-address=${MASTER_ADDRESS} \
--allow-privileged=true \
--service-cluster-ip-range=10.0.0.0/24 \
--enable-admission-plugins=NamespaceLifecycle,LimitRanger,ServiceAccount,ResourceQuota,NodeRestriction \
--authorization-mode=RBAC,Node \
--kubelet-https=true \
--enable-bootstrap-token-auth \
--token-auth-file=/opt/kubernetes/cfg/token.csv \
--service-node-port-range=30000-50000 \
--tls-cert-file=/opt/kubernetes/ssl/server.pem  \
--tls-private-key-file=/opt/kubernetes/ssl/server-key.pem \
--client-ca-file=/opt/kubernetes/ssl/ca.pem \
--service-account-key-file=/opt/kubernetes/ssl/ca-key.pem \
--etcd-cafile=/opt/etcd/ssl/ca.pem \
--etcd-certfile=/opt/etcd/ssl/server.pem \
--etcd-keyfile=/opt/etcd/ssl/server-key.pem"

EOF

#生成启动脚本
cat <<EOF >/usr/lib/systemd/system/kube-apiserver.service
[Unit]
Description=Kubernetes API Server
Documentation=https://github.com/kubernetes/kubernetes

[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-apiserver
ExecStart=/opt/kubernetes/bin/kube-apiserver $KUBE_APISERVER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

#启动apiserver组件
systemctl daemon-reload
systemctl enable kube-apiserver
systemctl restart kube-apiserver

2、检查进程是否启动成功。

复制代码
1
2
[root@localhost k8s]# ps aux | grep kube

在这里插入图片描述
3、查看监听的https端口

复制代码
1
2
3
[root@localhost k8s]# netstat -natp | grep 6443
[root@localhost k8s]# netstat -natp | grep 8080

在这里插入图片描述

2.2、部署scheduler

scheduler.sh脚本内容：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#!/bin/bash

MASTER_ADDRESS=$1

cat <<EOF >/opt/kubernetes/cfg/kube-scheduler

KUBE_SCHEDULER_OPTS="--logtostderr=true \
--v=4 \
--master=${MASTER_ADDRESS}:8080 \
--leader-elect"

EOF

cat <<EOF >/usr/lib/systemd/system/kube-scheduler.service
[Unit]
Description=Kubernetes Scheduler
Documentation=https://github.com/kubernetes/kubernetes

[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-scheduler
ExecStart=/opt/kubernetes/bin/kube-scheduler $KUBE_SCHEDULER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable kube-scheduler
systemctl restart kube-scheduler

启动scheduler服务

复制代码
1
2
[root@localhost k8s]# ./scheduler.sh 127.0.0.1

在这里插入图片描述

2.3、部署controller-manager

controller-manager.sh脚本编写内容：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#!/bin/bash

MASTER_ADDRESS=$1

cat <<EOF >/opt/kubernetes/cfg/kube-controller-manager


KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=true \
--v=4 \
--master=${MASTER_ADDRESS}:8080 \
--leader-elect=true \
--address=127.0.0.1 \
--service-cluster-ip-range=10.0.0.0/24 \
--cluster-name=kubernetes \
--cluster-signing-cert-file=/opt/kubernetes/ssl/ca.pem \
--cluster-signing-key-file=/opt/kubernetes/ssl/ca-key.pem  \
--root-ca-file=/opt/kubernetes/ssl/ca.pem \
--service-account-private-key-file=/opt/kubernetes/ssl/ca-key.pem \
--experimental-cluster-signing-duration=87600h0m0s"

EOF

cat <<EOF >/usr/lib/systemd/system/kube-controller-manager.service
[Unit]
Description=Kubernetes Controller Manager
Documentation=https://github.com/kubernetes/kubernetes

[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-controller-manager
ExecStart=/opt/kubernetes/bin/kube-controller-manager $KUBE_CONTROLLER_MANAGER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable kube-controller-manager
systemctl restart kube-controller-manager

启动controller-manager

复制代码
1
2
[root@localhost k8s]# ./controller-manager.sh 127.0.0.1

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

复制代码
1
2
[root@localhost k8s]# /opt/kubernetes/bin/kubectl get cs

在这里插入图片描述

三、部署node节点组件

在 node上要部署以下三大核心组件：

  • kubelet：是master在node节点上的agent，可以管理本机运行容器的生命周期，例如创建容器、Pod挂载数据卷、下载secret、获取容器和节点状态等工作，kubelet 将每个 Pod转换成一组容器。

  • kube-proxy：在 node节点上实现 Pod网络代理，维护网络规划和四层负载均衡工作。

  • docker：容器（我们已经安装好了）

3.1、部署kubeconfig

  • 在master节点上进行操作

1、在master上，把 kubelet、kube-proxy 拷贝到 两个node节点上去

复制代码
1
2
3
4
[root@localhost bin]# scp kubelet kube-proxy root@192.168.100.131:/opt/kubernetes/bin/

[root@localhost bin]# scp kubelet kube-proxy root@192.168.100.136:/opt/kubernetes/bin/

在这里插入图片描述
2、编写kubeconfig脚本

复制代码
1
2
3
4
5
6
[root@localhost k8s]# mkdir kubeconfig
[root@localhost k8s]# cd kubeconfig/

[root@localhost kubeconfig]# cat /opt/kubernetes/cfg/token.csv  //获取 token令牌的序列号
84cf410ca1d9dd456dbba668de2c1aca,kubelet-bootstrap,10001,"system:kubelet-bootstrap"
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
[root@localhost kubeconfig]# vim kubeconfig
APISERVER=$1     #master节点的IP地址
SSL_DIR=$2         #k8s证书路径

# 创建kubelet bootstrapping kubeconfig 
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

# 设置客户端认证参数
kubectl config set-credentials kubelet-bootstrap 
  --token=84cf410ca1d9dd456dbba668de2c1aca      #注意：随机生成的序列号不同，要修改
  --kubeconfig=bootstrap.kubeconfig

# 设置上下文参数
kubectl config set-context default 
  --cluster=kubernetes 
  --user=kubelet-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

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

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

在这里插入图片描述
3、设置环境变量，使可以在任意目录下识别kubectl命令

复制代码
1
2
[root@localhost kubeconfig]# export PATH=$PATH:/opt/kubernetes/bin/

4、检查健康状态

复制代码
1
2
[root@localhost kubeconfig]# kubectl get cs

在这里插入图片描述
5、运行kubeconfig脚本生成配置文件

复制代码
1
2
[root@localhost kubeconfig]# bash kubeconfig 192.168.100.128 /root/k8s/k8s-cert/

在这里插入图片描述
将生成的配置文件传给两个node节点

复制代码
1
2
3
4
[root@localhost kubeconfig]# scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.100.131:/opt/kubernetes/cfg/

[root@localhost kubeconfig]# scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.100.136:/opt/kubernetes/cfg/

在这里插入图片描述
6、创建 bootstrap角色赋予权限，用于连接 apiserver请求签名（重要）

复制代码
1
2
3
[root@localhost kubeconfig]# kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap
clusterrolebinding.rbac.authorization.k8s.io/kubelet-bootstrap created

3.2、部署node1的kubelet组件

  • 在node1节点上操作

1、编写kubelet.sh脚本

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#!/bin/bash

NODE_ADDRESS=$1
DNS_SERVER_IP=${2:-"10.0.0.2"}

cat <<EOF >/opt/kubernetes/cfg/kubelet

KUBELET_OPTS="--logtostderr=true \
--v=4 \
--hostname-override=${NODE_ADDRESS} \
--kubeconfig=/opt/kubernetes/cfg/kubelet.kubeconfig \
--bootstrap-kubeconfig=/opt/kubernetes/cfg/bootstrap.kubeconfig \
--config=/opt/kubernetes/cfg/kubelet.config \
--cert-dir=/opt/kubernetes/ssl \
--pod-infra-container-image=registry.cn-hangzhou.aliyuncs.com/google-containers/pause-amd64:3.0"

EOF

cat <<EOF >/opt/kubernetes/cfg/kubelet.config

kind: KubeletConfiguration
apiVersion: kubelet.config.k8s.io/v1beta1
address: ${NODE_ADDRESS}
port: 10250
readOnlyPort: 10255
cgroupDriver: cgroupfs
clusterDNS:
- ${DNS_SERVER_IP} 
clusterDomain: cluster.local.
failSwapOn: false
authentication:
  anonymous:
    enabled: true
EOF

cat <<EOF >/usr/lib/systemd/system/kubelet.service
[Unit]
Description=Kubernetes Kubelet
After=docker.service
Requires=docker.service

[Service]
EnvironmentFile=/opt/kubernetes/cfg/kubelet
ExecStart=/opt/kubernetes/bin/kubelet $KUBELET_OPTS
Restart=on-failure
KillMode=process

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable kubelet
systemctl restart kubelet

2、加执行权限

复制代码
1
2
[root@localhost ~]# chmod +x /root/kubelet.sh

3、运行脚本启动kubelet，向master集群发送请求

复制代码
1
2
[root@localhost ~]# bash kubelet.sh 192.168.100.131

4、检查 kubelet 服务启动

复制代码
1
2
[root@localhost ~]# ps aux | grep kube

在这里插入图片描述
5、在master节点上，检查 node01 节点的请求

复制代码
1
2
3
//用下面这个命令检查得到node1请求，并复制node1请求的名字
[root@localhost kubeconfig]# kubectl get csr

Pending（意思：等待群集给该节点颁发证书）
在这里插入图片描述
6、master设置同意连接请求，颁发证书

复制代码
1
2
3
4
5
//同意请求的命令格式：kubectl certificate approve node1请求的NAME
[root@localhost kubeconfig]# kubectl certificate approve node-csr-wvb8EvLCzVY5I6sKJGeMh4oDLOkYVlHc6hY8_UHri4U

[root@localhost kubeconfig]# kubectl get csr    #发现状态变成允许

在这里插入图片描述
7、查看群集节点，成功加入 node01 节点

复制代码
1
2
3
4
[root@localhost kubeconfig]# kubectl get node
NAME              STATUS   ROLES    AGE     VERSION
192.168.100.131   Ready    <none>   4m44s   v1.12.3

3.3、部署node1 的kube-proxy组件

1、编写proxy.sh 脚本

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#!/bin/bash

NODE_ADDRESS=$1

cat <<EOF >/opt/kubernetes/cfg/kube-proxy

KUBE_PROXY_OPTS="--logtostderr=true \
--v=4 \
--hostname-override=${NODE_ADDRESS} \
--cluster-cidr=10.0.0.0/24 \
--proxy-mode=ipvs \
--kubeconfig=/opt/kubernetes/cfg/kube-proxy.kubeconfig"

EOF

cat <<EOF >/usr/lib/systemd/system/kube-proxy.service
[Unit]
Description=Kubernetes Proxy
After=network.target

[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-proxy
ExecStart=/opt/kubernetes/bin/kube-proxy $KUBE_PROXY_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable kube-proxy
systemctl restart kube-proxy

2、加执行权限

复制代码
1
2
[root@localhost ~]# chmod +x /root/proxy.sh

3、在 node1节点上操作，启动 proxy服务，并查看状态是否正常

复制代码
1
2
3
[root@localhost ~]# bash proxy.sh 192.168.100.131
[root@localhost ~]# systemctl status kube-proxy.service

在这里插入图片描述

3.4、部署node2节点的 kubelet 和 kube-proxy 服务

1、为了提高效率，我们将 node01上现成的 /opt/kubernetes目录复制到其他节点进行修改。

复制代码
1
2
[root@localhost ~]# scp -r /opt/kubernetes/ root@192.168.100.136:/opt/

再把kubelet，kube-proxy的service文件拷贝到node2中

复制代码
1
2
[root@localhost ~]# scp /usr/lib/systemd/system/{kubelet,kube-proxy}.service root@192192.168.109..168.100.136:/usr/lib/systemd/system/

2、接下来在 node02 节点上的操作

  • 首先，先删除复制过来的证书，因为待会 node02 会自行申请属于自己的证书
复制代码
1
2
3
4
5
6
[root@localhost ~]# cd /opt/kubernetes/ssl/
[root@localhost ssl]# ls
kubelet-client-2020-04-30-11-48-13.pem  kubelet.crt
kubelet-client-current.pem              kubelet.key
[root@localhost ssl]# rm -rf *
  • 修改配置文件 kubelet 、kubelet.config 、kube-proxy（三个配置文件）中node1的IP地址
复制代码
1
2
3
[root@localhost ssl]# cd /opt/kubernetes/cfg/
[root@localhost cfg]# vim kubelet

在这里插入图片描述

复制代码
1
2
[root@localhost cfg]# vi kubelet.config

在这里插入图片描述

复制代码
1
2
[root@localhost cfg]# vi kube-proxy

在这里插入图片描述
3、启动node2节点的 kubelet、kube-proxy 服务，并设置开机自启

复制代码
1
2
3
4
5
6
7
8
[root@localhost cfg]# systemctl start kubelet.service 
[root@localhost cfg]# systemctl enable kubelet.service
Created symlink from /etc/systemd/system/multi-user.target.wants/kubelet.service to /usr/lib/systemd/system/kubelet.service.

[root@localhost cfg]# systemctl start kube-proxy.service 
[root@localhost cfg]# systemctl enable kube-proxy.service 
Created symlink from /etc/systemd/system/multi-user.target.wants/kube-proxy.service to /usr/lib/systemd/system/kube-proxy.service.

4、在master上查看node2节点的请求

复制代码
1
2
[root@localhost kubeconfig]# kubectl get csr

在这里插入图片描述
接下来和刚刚一样，授权许可加入集群

复制代码
1
2
[root@localhost kubeconfig]# kubectl certificate approve node-csr-DiaTo2KEty9zNGCNdV4Hw8AUPfjd7gdLHvph41lkQ9k

四、验证集群

查看群集中的节点

复制代码
1
2
3
4
5
[root@localhost ~]# kubectl get node
NAME              STATUS   ROLES    AGE   VERSION
192.168.100.131   Ready    <none>   50m   v1.12.3
192.168.100.136   Ready    <none>   22s   v1.12.3

到这里，我的单master节点的K8s集群部署完成了。

我的多节点部署后续也会更新，大家可以关注我的博客号。

最后

以上就是爱笑黄豆最近收集整理的关于kubernetes二进制集群部署--------单master集群（步骤非常详细，适合初学者）的全部内容，更多相关kubernetes二进制集群部署--------单master集群（步骤非常详细内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(66)

相关文章

(9)二进制文件方式部署Kubernetes高可用集群----------部署master节点部署master节点愿你就像早晨八九点钟的太阳，活力十足，永远年轻。
(9)二进制文件方式部署Kubernetes高可用集群----------部署master节点部署master节点愿你就像早晨八九点钟的太阳，活力十足，永远年轻。
K8s脱坑前的挣扎——k8s单节点群集部署（3）Master及Node部署一、部署Master组件二、部署Node组件
K8s脱坑前的挣扎——k8s单节点群集部署（3）Master及Node部署一、部署Master组件二、部署Node组件
k8s多master节点使用二进制部署群集一、K8S 多节点部署
k8s多master节点使用二进制部署群集一、K8S 多节点部署
k8s 二进制安装master（单master）
k8s 二进制安装master（单master）
kubernetes二进制集群部署--------单master集群（步骤非常详细，适合初学者）
kubernetes二进制集群部署--------单master集群（步骤非常详细，适合初学者）
6大服务网格工具比较
6大服务网格工具比较
K8S二进制部署master节点
K8S二进制部署master节点
k8s单master节点的部署（实验）k8s单master节点的部署（实验）
k8s单master节点的部署（实验）k8s单master节点的部署（实验）

评论列表共有 0 条评论

立即
投稿
返回
顶部