Kubernetes二进制（单master）部署

于 2024-05-15 00:07:04 发布
阅读量1k 收藏 25
点赞数 14
文章标签： kubernetes 容器 云原生
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_58376680/article/details/138615293
版权

目录

一、常见的K8S部署方式

1. Minikube

2. Kubeadmin

3. 二进制安装部署

4. 小结

二、K8S单（Master）节点二进制部署

1. 环境准备

1.1 服务器配置

1.2 关闭防火墙

1.3 修改主机名

1.4 关闭swap

1.5 在master添加hosts

1.6 将桥接的IPv4流量传递到iptables的链

1.7 时间同步

2.部署docker引擎

3. 部署etcd集群

3.1 etcd概述

3.1.1 etcd简介

3.1.2 etcd的特点

3.1.3 etcd端口

3.2 签发证书(Master01)

3.2.1 下载证书制作工具

3.2.2 创建k8s工作目录

3.2.3 编写etcd-cert.sh和etcd.sh脚本

① etcd-cert.sh

②etcd.sh

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

3.3 启动etcd服务

3.3.1 安装etcd服务

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

3.3.3 启动etcd.sh脚本

3.3.4 把etcd相关证书文件和命令文件全部拷贝到另外两个etcd集群节点

3.3.5 把etcd服务管理文件拷贝到了另外两个etcd集群节点

3.3.6 修改另外两个etcd集群节点的配置文件

3.3.7 检查集群状态（Master01）

v3版本查看

4. 部署master组件(在master01节点上操作)

4.1 编写apiserver.sh/scheduler.sh/controller-manager.sh

4.1.1 apiserver.sh

4.1.2 编写scheduler.sh

4.1.3 编写controller-manager.sh

4.1.4 编写k8s-cert.sh

4.1.5 赋予以上脚本执行权限

4.2 创建kubernetes工作目录

4.3 生成CA证书、相关组件的证书和私钥

4.4 复制CA证书、apiserver相关证书和私钥到kubernetes工作目录的ssl子目录中

4.5 下载或上传kubernetes安装包到/opt/k8s目录，并解压

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

4.7 创建bootstrap token认证文件

4.8 二进制文件、token、证书都准备好后，开启apiserver服务

4.9 检查

4.9.1 检查进程是否启动成功

4.9.2 检查6443端口

4.9.3 检查8080端口

4.9.4 查看版本信息

4.10 启动scheduler服务

4.11 启动controller-manager服务

4.12  生成kubectl连接集群的kubeconfig文件 ./admin.sh

4.12 查看master节点状态

5. 部署Worker Node组件

创建kubernetes工作目录

5.1 把kubelet、kube-proxy拷贝到node节点（在master01节点操作）

5.2 编写脚本(在node01节点操作)

5.2.1 proxy.sh

5.2.2 编写kubelet.sh

5.2.3 赋予上述脚本执行权限

5.3 在master01节点上操作

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

5.3.2 编写kubeconfig.sh

5.3.3 生成kubelet的配置文件

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

5.3.5 RBAC授权及相关说明

5.3.6 查看角色

5.3.7 查看已授权的角色

5.4 在node1节点上操作

5.4.1 使用kubelet.sh脚本启动kubelet服务

5.4.2 检查kubelet服务启动

5.4.3 查看当前ssl目录

5.4 在master01节点上操作

5.4.1 查看CSR请求

5.4.2 通过CSR请求

5.4.3 再次查看CSR请求状态

5.4.4 查看集群节点状态

5.5 在node01节点上操作

5.5.1 已自动生成证书和kubelet.kubeconfig文件

5.5.2 加载ip_vs模块

5.5.3 使用proxy.sh脚本启动proxy服务

5.6 node02节点部署

5.6.1 方法一

5.6.1.1 在node01节点操作

5.6.1.2 在node02节点上操作

5.6.1.3 在master01节点上操作

5.6.1.4 node02操作

5.6.2 方法二

5.6.2.1 在node01节点操作

5.6.2.2 在node02节点操作

5.6.2.3 在master01操作

一、常见的K8S部署方式

1. Minikube

Minikube是一个工具，可以在本地快速运行一个单节点微型K8S，仅用于学习、预览K8S的一些特性使用 Install Tools | Kubernetes

2. Kubeadmin

Kubeadmin也是一个工具，提供kubeadm init和kubeadm join，用于快速部署K8S集群，相对简单。 Kubeadm | Kubernetes

3. 二进制安装部署

生产首选，从官方下载发行版的二进制包，手动部署每个组件和自签TLS证书，组成K8S集群，新手推荐。 Releases · kubernetes/kubernetes · GitHub

4. 小结

Kubeadm降低部署门槛，但屏蔽了很多细节，遇到问题很难排查。如果想更容易可控，推荐使用二进制包部署Kubernetes集群，虽然手动部署麻烦点，期间可以学习很多工作原理，也利于后期维护。

二、K8S单（Master）节点二进制部署

1. 环境准备

1.1 服务器配置

img

服务器主机名IP地址主要组件/说明
master01节点+etcd01节点master192.168.80.116kube-apiserver kube-controller-manager kube-schedular etcd
node01节点+etcd02节点node1192.168.80.111kubelet kube-proxy docker flannel
node02节点+etcd03节点node2192.168.80.112kubelet kube-proxy docker flannel

1.2 关闭防火墙

systemctl disable --now firewalld
setenforce 0
sed -i 's/enforcing/disabled/' /etc/selinux/config
#永久禁用selinux服务

1.3 修改主机名

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

su

1.4 关闭swap

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

1.5 在master添加hosts

cat >> /etc/hosts << EOF
192.168.80.116 master01
192.168.80.111 node1
192.168.80.112 node2
EOF

1.6 将桥接的IPv4流量传递到iptables的链

#调整内核参数
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

1.7 时间同步

yum install ntpdate -y
ntpdate time.windows.com

2.部署docker引擎

在所有node节点部署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

3. 部署etcd集群

3.1 etcd概述

3.1.1 etcd简介

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

3.1.2 etcd的特点

etcd作为服务发现系统，有以下的特点：

  • 简单：安装配置简单，而且提供了HTTP API进行交互，使用也很简单
  • 安全：支持SSL证书验证
  • 快速：单实例支持每秒2k+读写操作
  • 可靠：采用raft算法，实现分布式系统数据的可用性和一致性
3.1.3 etcd端口

etcd目前默认使用2379端口提供HTTP API服务，2380端口和peer通信（这两个端口已经被IANA（互联网数字分配机构）官方预留给etcd）。即etcd默认使用2379端口对外为客户端提供通讯，使用端口2380来进行服务器间内部通讯。 etcd在生产环境中一般推荐集群方式部署。由于etcd的leader选举机制，要求至少为3台或以上的奇数台。

3.2 签发证书(Master01)

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.2.1 下载证书制作工具
[root@master01 ~]# wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64 -O /usr/local/bin/cfssl
[root@master01 ~]# wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64 -O /usr/local/bin/cfssljson
[root@master01 ~]# wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64 -O /usr/local/bin/cfssl-certinfo
[root@master01 ~]# chmod +x /usr/local/bin/cfssl*

或使用curl -L下载

curl -L https://pkg.cfssl.org/R1.2/cfssl_linux-amd64 -o /usr/local/bin/cfssl
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

或者先安装下来，再拖入到文件,然后移到/usr/local/bin/下

[root@master01 ~]#cd /opt
[root@master01 opt]#rz -E
rz waiting to receive.##拖入相关文件
[root@master01 opt]#ls
cfssl  cfssl-certinfo  cfssljson  rh

[root@master01 opt]#chmod +x cfssl*
[root@master01 opt]#mv cfssl* /usr/local/bin/
  • cfssl：证书签发的工具命令
  • cfssljson：将cfssl生成的证书（json格式）变为文件承载式证书
  • cfssl-certinfo：验证证书的信息 “cfssl-certinfo -cert <证书名称> ”可查看证书的信息
3.2.2 创建k8s工作目录
[root@master01 ~]# mkdir /opt/k8s
[root@master01 ~]# cd /opt/k8s
3.2.3 编写etcd-cert.sh和etcd.sh脚本
① etcd-cert.sh
[root@master01 k8s]# chmod +x etcd-cert.sh
[root@master01 k8s]# cat 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.80.116",
    "192.168.80.111",
    "192.168.80.112"
    ],
    "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

 

②etcd.sh
[root@master01 k8s]# chmod +x etcd.sh
[root@master01 k8s]# cat etcd.sh 
#!/bin/bash
# example: ./etcd.sh etcd01 192.168.80.10 etcd02=https://192.168.80.11:2380,etcd03=https://192.168.80.12: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 \
--name=\${ETCD_NAME} \
--data-dir=\${ETCD_DATA_DIR} \
--listen-peer-urls=\${ETCD_LISTEN_PEER_URLS} \
--listen-client-urls=\${ETCD_LISTEN_CLIENT_URLS},http://127.0.0.1:2379 \
--advertise-client-urls=\${ETCD_ADVERTISE_CLIENT_URLS} \
--initial-advertise-peer-urls=\${ETCD_INITIAL_ADVERTISE_PEER_URLS} \
--initial-cluster=\${ETCD_INITIAL_CLUSTER} \
--initial-cluster-token=\${ETCD_INITIAL_CLUSTER_TOKEN} \
--initial-cluster-state=new \
--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
Restart=on-failure
LimitNOFILE=65536
 
[Install]
WantedBy=multi-user.target
EOF
 
#--listen-client-urls：用于指定etcd和客户端的连接端口
#--advertise-client-urls：用于指定etcd服务器之间通讯的端口，etcd有要求，如果--listen-client-urls被设置了，那么就必须同时设置--advertise-client-urls，所以即使设置和默认相同，也必须显式设置
#--peer开头的配置项用于指定集群内部TLS相关证书（peer 证书），这里全部都使用同一套证书认证
#不带--peer开头的的参数是指定 etcd 服务器TLS相关证书（server 证书），这里全部都使用同一套证书认证
 
 
systemctl daemon-reload
systemctl enable etcd
systemctl restart etcd
3.2.4 生成CA证书、etcd服务器证书以及私钥
[root@master01 k8s]# mkdir /opt/k8s/etcd-cert
[root@master01 k8s]# mv etcd-cert.sh etcd-cert/
[root@master01 k8s]# cd /opt/k8s/etcd-cert/
[root@master01 etcd-cert]# ./etcd-cert.sh 
#生成CA证书、etcd服务器证书以及私钥
[root@master01 etcd-cert]# ls
ca-config.json  ca.csr  ca-csr.json  ca-key.pem  ca.pem  etcd-cert.sh  server.csr  server-csr.json  server-key.pem  server.pem

3.3 启动etcd服务

3.3.1 安装etcd服务

etcd二进制包地址：Releases · etcd-io/etcd · GitHub

[root@master01 etcd-cert]# cd /opt/k8s
[root@master01 k8s]# rz -E
#传入etcd安装包etcd-v3.4.9-linux-amd64.tar.gz
rz waiting to receive.
[root@master01 k8s]# tar zxvf etcd-v3.4.9-linux-amd64.tar.gz 
[root@master01 k8s]# ls etcd-vv3.4.9-linux-amd64
Documentation  etcd  etcdctl  README-etcdctl.md  README.md  READMEv2-etcdctl.md

etcd就是etcd服务的启动命令，后面可跟各种启动参数

etcdctl主要为etcd服务提供了命令行操作

3.3.2 创建用于存放etcd配置文件、命令文件、证书的目录
[root@master01 k8s]# mkdir -p /opt/etcd/{cfg,bin,ssl}
[root@master01 k8s]# mv /opt/k8s/etcd-v3.4.9-linux-amd64/etcd /opt/k8s/etcd-v3.4.9-linux-amd64/etcdctl /opt/etcd/bin/

[root@master01 k8s]# cp /opt/k8s/etcd-cert/*.pem /opt/etcd/ssl/

3.3.3 启动etcd.sh脚本
[root@master01 k8s]# ls
etcd-cert  etcd.sh  etcd-v3.4.9-linux-amd64  etcd-v3.4.9-linux-amd64.tar.
[root@master01 k8s]# ./etcd.sh etcd01 192.168.80.116 etcd02=https://192.168.80.111:2380,etcd03=https://192.168.80.112:2380

进入卡住状态等待其他节点加入，这里需要三台etcd服务同时启动，如果只启动其中一台后，服务会卡在那里，直到集群中所有etcd节点都已启动，可忽略这个情况 另外打开一个窗口查看etcd进程是否正常

[root@master01 ~]# ps -ef | grep etcd

3.3.4 把etcd相关证书文件和命令文件全部拷贝到另外两个etcd集群节点
[root@master01 k8s]# scp -r /opt/etcd/ root@192.168.80.111:/opt/etcd/
  
[root@master01 k8s]# scp -r /opt/etcd/ root@192.168.80.112:/opt/etcd/

3.3.5 把etcd服务管理文件拷贝到了另外两个etcd集群节点
[root@master01 k8s]# scp /usr/lib/systemd/system/etcd.service root@192.168.80.111:/usr/lib/systemd/system/
   
[root@master01 k8s]# scp /usr/lib/systemd/system/etcd.service root@192.168.80.112:/usr/lib/systemd/system/
 

3.3.6 修改另外两个etcd集群节点的配置文件

node01

[root@node01 ~]# cd /opt/etcd/cfg/
[root@node01 cfg]# ls
etcd
[root@node01 cfg]# vim etcd
 
#[Member]
ETCD_NAME="etcd02"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.80.111:2380"
ETCD_LISTEN_CLIENT_URLS="https://192.168.80.111:2379"
 
#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.80.111:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.80.111:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.80.116:2380,etcd02=https://192.168.80.111:2380,etcd03=https://192.168.80.112:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
 
[root@node01 cfg]# systemctl daemon-reload 
[root@node01 cfg]# systemctl enable --now etcd.service 
[root@node01 cfg]# systemctl status etcd

......
node02同上，修改ETCD_NAME"etcd03"以及对应IP即可

 

3.3.7 检查集群状态（Master01）
v3版本查看

切换到etcd3版本查看集群节点状态和成员列表 v2和v3命令略有不同，etcd2和etcd3也是不兼容的，默认版本是v2版本

#检查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.80.116:2379,https://192.168.80.111:2379,https://192.168.80.112:2379" endpoint health --write-out=table

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.80.116:2379,https://192.168.80.111:2379,https://192.168.80.112:2379" endpoint status --write-out=table


------------------------------------------------------------------------------------------
--cert-file：识别HTTPS端使用SSL证书文件
--key-file：使用此SSL密钥文件标识HTTPS客户端
--ca-file：使用此CA证书验证启用https的服务器的证书
--endpoints：集群中以逗号分隔的机器地址列表
cluster-health：检查etcd集群的运行状况
------------------------------------------------------------------------------------------

#查看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.80.116:2379,https://192.168.80.111:2379,https://192.168.80.112:2379" --write-out=table member list

4. 部署master组件(在master01节点上操作)

4.1 编写apiserver.sh/scheduler.sh/controller-manager.sh

  • 把相关脚本都放在master.zip压缩包里面 ，需解压使用
  • 压缩包里面有 admin.sh 、apiserver.sh 、 controller-manager.sh、scheduler.sh  
[root@master01 ssl]#cd /opt/k8s/
[root@master01 k8s]#rz -E
rz waiting to receive.
[root@master01 k8s]#unzip master.zip 
Archive:  master.zip
  inflating: admin.sh                
  inflating: apiserver.sh            
  inflating: controller-manager.sh   
  inflating: scheduler.sh            
[root@master01 k8s]#ls
admin.sh  apiserver.sh  controller-manager.sh  etcd-cert  etcd.sh  etcd-v3.4.9-linux-amd64  etcd-v3.4.9-linux-amd64.tar.gz  maste
[root@master01 k8s]#vim apiserver.sh 
[root@master01 k8s]#chmod +x *.sh

4.1.1 apiserver.sh
#!/bin/bash
#创建 kube-apiserver 启动参数配置文件
MASTER_ADDRESS=$1
ETCD_SERVERS=$2

cat >/opt/kubernetes/cfg/kube-apiserver <<EOF
KUBE_APISERVER_OPTS="--logtostderr=false  \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--etcd-servers=${ETCD_SERVERS} \\
--bind-address=${MASTER_ADDRESS} \\
--token-auth-file=/opt/kubernetes/cfg/token.csv \\
--service-node-port-range=30000-50000 \\
--kubelet-client-certificate=/opt/kubernetes/ssl/apiserver.pem \\
--kubelet-client-key=/opt/kubernetes/ssl/apiserver-key.pem \\
--tls-cert-file=/opt/kubernetes/ssl/apiserver.pem  \\
--tls-private-key-file=/opt/kubernetes/ssl/apiserver-key.pem \\
--client-ca-file=/opt/kubernetes/ssl/ca.pem \\
--service-account-key-file=/opt/kubernetes/ssl/ca-key.pem \\
--etcd-certfile=/opt/etcd/ssl/server.pem \\
--etcd-keyfile=/opt/etcd/ssl/server-key.pem \\
--requestheader-client-ca-file=/opt/kubernetes/ssl/ca.pem \\
--proxy-client-cert-file=/opt/kubernetes/ssl/apiserver.pem \\
--proxy-client-key-file=/opt/kubernetes/ssl/apiserver-key.pem \\
--requestheader-allowed-names=kubernetes \\
--requestheader-extra-headers-prefix=X-Remote-Extra- \\
--requestheader-group-headers=X-Remote-Group \\
--requestheader-username-headers=X-Remote-User \\
--enable-aggregator-routing=true \\
--audit-log-maxage=30 \\
--audit-log-maxbackup=3 \\
--audit-log-maxsize=100 \\
--audit-log-path=/opt/kubernetes/logs/k8s-audit.log"
EOF

#--logtostderr=true：启用日志。输出日志到标准错误控制台，不输出到文件
#--v=4：日志等级。指定输出日志的级别，v=4为调试级别详细输出
#--etcd-servers：etcd集群地址。指定etcd服务器列表（格式：//ip:port），逗号分隔
#--bind-address：监听地址。指定 HTTPS 安全接口的监听地址，默认值0.0.0.0
#--secure-port：https安全端口。指定 HTTPS 安全接口的监听端口，默认值6443
#--advertise-address：集群通告地址。通过该 ip 地址向集群其他节点公布 api server 的信息，必须能够被其他节点访问
#--allow-privileged=true：启用授权。允许拥有系统特权的容器运行，默认值false
#--service-cluster-ip-range：Service虚拟IP地址段。指定 Service Cluster IP 地址段
#--enable-admission-plugins：准入控制模块。kuberneres集群的准入控制机制，各控制模块以插件的形式依次生效，集群时>必须包含ServiceAccount，运行在认证（Authentication）、授权（Authorization）之后，Admission Control是权限认证链上
的最后一环， 对请求API资源对象进行修改和校验
#--authorization-mode：认证授权，启用RBAC授权和节点自管理。在安全端口使用RBAC,Node授权模式，未通过授权的请求拒绝
，默认值AlwaysAllow。RBAC是用户通过角色与权限进行关联的模式；Node模式（节点授权）是一种特殊用途的授权模式，专门>授权由kubelet发出的API请求，在进行认证时，先通过用户名、用户分组验证是否是集群中的Node节点，只有是Node节点的请求
才能使用Node模式授权
#--enable-bootstrap-token-auth：启用TLS bootstrap机制。在apiserver上启用Bootstrap Token 认证
#--token-auth-file=/opt/kubernetes/cfg/token.csv：指定bootstrap token认证文件路径
#--service-node-port-range：指定 Service  NodePort 的端口范围，默认值30000-32767
#–-kubelet-client-xxx：apiserver访问kubelet客户端证书
#--tls-xxx-file：apiserver https证书
#1.20版本必须加的参数：–-service-account-issuer，–-service-account-signing-key-file
#--etcd-xxxfile：连接Etcd集群证书
#–-audit-log-xxx：审计日志
#启动聚合层相关配置：–requestheader-client-ca-file，–proxy-client-cert-file，–proxy-client-key-file，–requestheader-allowed-names，–requestheader-extra-headers-prefix，–requestheader-group-headers，–requestheader-username-headers，–enable-aggregator-routing


#创建 kube-apiserver.service 服务管理文件
cat >/usr/lib/systemd/system/kube-apiserver.service <<EOF
[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

systemctl daemon-reload
systemctl enable kube-apiserver
systemctl restart kube-apiserver
4.1.2 编写scheduler.sh
[root@master01 k8s]# cat scheduler.sh 
#!/bin/bash
##创建 kube-scheduler 启动参数配置文件
MASTER_ADDRESS=$1

cat >/opt/kubernetes/cfg/kube-scheduler <<EOF
KUBE_SCHEDULER_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--leader-elect=true \\
--kubeconfig=/opt/kubernetes/cfg/kube-scheduler.kubeconfig \\
--bind-address=127.0.0.1"
EOF

#-–kubeconfig：连接 apiserver 用的配置文件，用于识别 k8s 集群
#--leader-elect=true：当该组件启动多个时，自动启动 leader 选举
#k8s中Controller-Manager和Scheduler的选主逻辑：k8s中的etcd是整个集群所有状态信息的存储，涉及数据的读写和多个etcd之间数据的同步，对数据的一致性要求严格，所以使用较复杂的 raft 算法来选择用于提交数据的主节点。而 apiserver 作为>集群入口，本身是无状态的web服务器，多个 apiserver 服务之间直接负载请求并不需要做选主。Controller-Manager 和 Scheduler 作为任务类型的组件，比如 controller-manager 内置的 k8s 各种资源对象的控制器实时的 watch apiserver 获取对象
最新的变化事件做期望状态和实际状态调整，调度器watch未绑定节点的pod做节点选择，显然多个这些任务同时工作是完全没有
必要的，所以 controller-manager 和 scheduler 也是需要选主的，但是选主逻辑和 etcd 不一样的，这里只需要保证从多个 controller-manager 和 scheduler 之间选出一个 leader 进入工作状态即可，而无需考虑它们之间的数据一致和同步。


##生成kube-scheduler证书
cd /opt/k8s/k8s-cert/
#创建证书请求文件
cat > kube-scheduler-csr.json << EOF
{
  "CN": "system:kube-scheduler",
  "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 kube-scheduler-csr.json | cfssljson -bare kube-scheduler


#生成kubeconfig文件
KUBE_CONFIG="/opt/kubernetes/cfg/kube-scheduler.kubeconfig"
KUBE_APISERVER="https://192.168.80.116:6443"

kubectl config set-cluster kubernetes \
  --certificate-authority=/opt/kubernetes/ssl/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=${KUBE_CONFIG}
kubectl config set-credentials kube-scheduler \
  --client-certificate=./kube-scheduler.pem \
  --client-key=./kube-scheduler-key.pem \
  --embed-certs=true \
  --kubeconfig=${KUBE_CONFIG}
kubectl config set-context default \
  --cluster=kubernetes \
  --user=kube-scheduler \
  --kubeconfig=${KUBE_CONFIG}
kubectl config use-context default --kubeconfig=${KUBE_CONFIG}


##创建 kube-scheduler.service 服务管理文件
cat >/usr/lib/systemd/system/kube-scheduler.service <<EOF
[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

 

4.1.3 编写controller-manager.sh
[root@master01 k8s]# cat controller-manager.sh 
#!/bin/bash
##创建 kube-controller-manager 启动参数配置文件
MASTER_ADDRESS=$1

cat >/opt/kubernetes/cfg/kube-controller-manager <<EOF
KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--leader-elect=true \\
--kubeconfig=/opt/kubernetes/cfg/kube-controller-manager.kubeconfig \\
--bind-address=127.0.0.1 \\
--allocate-node-cidrs=true \\
--cluster-cidr=10.244.0.0/16 \\
--service-cluster-ip-range=10.0.0.0/24 \\
--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 \\
--cluster-signing-duration=87600h0m0s"
EOF

#––leader-elect：当该组件启动多个时，自动选举（HA）
#-–kubeconfig：连接 apiserver 用的配置文件，用于识别 k8s 集群
#--cluster-cidr=10.244.0.0/16：pod资源的网段，需与pod网络插件的值设置一致。通常，Flannel网络插件的默认为10.244.0.0/16，Calico插件的默认值为192.168.0.0/16
#--cluster-signing-cert-file/–-cluster-signing-key-file：自动为kubelet颁发证书的CA，与apiserver保持一致。指定签>名的CA机构根证书，用来签名为 TLS BootStrapping 创建的证书和私钥
#--root-ca-file：指定根CA证书文件路径，用来对 kube-apiserver 证书进行校验，指定该参数后，才会在 Pod 容器的 ServiceAccount 中放置该 CA 证书文件
#--experimental-cluster-signing-duration：设置为 TLS BootStrapping 签署的证书有效时间为10年，默认为1年


##生成kube-controller-manager证书
cd /opt/k8s/k8s-cert/
#创建证书请求文件
cat > kube-controller-manager-csr.json << EOF
{
  "CN": "system:kube-controller-manager",
  "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 kube-controller-manager-csr.json | cfssljson -bare kube-controller-manager

#生成kubeconfig文件
KUBE_CONFIG="/opt/kubernetes/cfg/kube-controller-manager.kubeconfig"
KUBE_APISERVER="https://192.168.80.116:6443"

kubectl config set-cluster kubernetes \
  --certificate-authority=/opt/kubernetes/ssl/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=${KUBE_CONFIG}
kubectl config set-credentials kube-controller-manager \
  --client-certificate=./kube-controller-manager.pem \
  --client-key=./kube-controller-manager-key.pem \
  --embed-certs=true \
  --kubeconfig=${KUBE_CONFIG}
kubectl config set-context default \
  --cluster=kubernetes \
  --user=kube-controller-manager \
  --kubeconfig=${KUBE_CONFIG}
kubectl config use-context default --kubeconfig=${KUBE_CONFIG}


##创建 kube-controller-manager.service 服务管理文件
cat >/usr/lib/systemd/system/kube-controller-manager.service <<EOF
[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

 

4.1.4 编写k8s-cert.sh
#创建用于生成CA证书、相关组件的证书和私钥的目录
[root@master01 k8s]mkdir /opt/k8s/k8s-cert
[root@master01 k8s]mv /opt/k8s/k8s-cert.sh /opt/k8s/k8s-cert
[root@master01 k8s]#cd /opt/k8s/k8s-cert/
[root@master01 k8s-cert]# cat k8s-cert.sh 
#!/bin/bash
#配置证书生成策略，让 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
 
cfssl gencert -initca ca-csr.json | cfssljson -bare ca -
 
 
#-----------------------
#生成 apiserver 的证书和私钥（apiserver和其它k8s组件通信使用）
#hosts中将所有可能作为 apiserver 的 ip 添加进去，后面 keepalived 使用的 VIP 也要加入
cat > apiserver-csr.json <<EOF
{
    "CN": "kubernetes",
    "hosts": [
      "10.0.0.1",
##service
      "127.0.0.1",
##本地
      "192.168.80.116",
##master01
      "192.168.80.111", 
##master02
      "192.168.80.112",    
##vip，后面 keepalived 使用
      "192.168.122.13",
##load balancer01（master）
      "192.168.122.14",
##load balancer02（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
 
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes apiserver-csr.json | cfssljson -bare apiserver
 
 
#-----------------------
#生成 kubectl 的证书和私钥，具有admin权限
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

 

4.1.5 赋予以上脚本执行权限
[root@master01 k8s]# chmod +x *.sh

4.2 创建kubernetes工作目录

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

4.3 生成CA证书、相关组件的证书和私钥

[root@master01 k8s-cert]# ./k8s-cert.sh
#生成CA证书、相关组件的证书和私钥
[root@master01 k8s-cert]# ls
admin.csr       admin.pem           apiserver-key.pem  ca.csr       ca.pem          kube-proxy-csr.json
admin-csr.json  apiserver.csr       apiserver.pem      ca-csr.json  k8s-cert.sh     kube-proxy-key.pem
admin-key.pem   apiserver-csr.json  ca-config.json     ca-key.pem   kube-proxy.csr  kube-proxy.pem

 

controller-manager和kube-scheduler设置为只调用当前机器的apiserver，使用127.0.0.1:8080通信，因此不需要签发证书

4.4 复制CA证书、apiserver相关证书和私钥到kubernetes工作目录的ssl子目录中

[root@master01 k8s-cert]# ls *.pem
admin-key.pem  admin.pem  apiserver-key.pem  apiserver.pem  ca-key.pem  ca.pem  kube-proxy-key.pem  kube-proxy.pem
[root@master01 k8s-cert]# cp ca*pem apiserver*pem /opt/kubernetes/ssl/

 

4.5 下载或上传kubernetes安装包到/opt/k8s目录，并解压

#下载地址：https://github.com/kubernetes/kubernetes/blob/release-1.20/CHANGELOG/CHANGELOG-1.20.md
#注：打开链接你会发现里面有很多包，下载一个server包就够了，包含了Master和Worker Node二进制文件。

[root@master01 k8s-cert]# cd /opt/k8s/
[root@master01 k8s]# rz -E
#上传k8s安装包kubernetes-server-linux-amd64.tar.gz
rz waiting to receive.
[root@master01 k8s]# tar zxvf kubernetes-server-linux-amd64.tar.gz

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

[root@master01 k8s]# cd /opt/k8s/kubernetes/server/bin/
[root@master01 bin]# ls
apiextensions-apiserver              kubeadm                    kube-controller-manager.docker_tag  kube-proxy.docker_tag      mounter
cloud-controller-manager             kube-apiserver             kube-controller-manager.tar         kube-proxy.tar
cloud-controller-manager.docker_tag  kube-apiserver.docker_tag  kubectl                             kube-scheduler
cloud-controller-manager.tar         kube-apiserver.tar         kubelet                             kube-scheduler.docker_tag
hyperkube                            kube-controller-manager    kube-proxy                          kube-scheduler.tar
[root@master01 bin]# cp kube-apiserver kubectl kube-controller-manager kube-scheduler /opt/kubernetes/bin/
[root@master01 bin]# ln -s /opt/kubernetes/bin/* /usr/local/bin/

4.7 创建bootstrap token认证文件

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

[root@master01 bin]# cd /opt/k8s/
[root@master01 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,"sysytem:kubelet-bootstrap"
EOF
 
[root@master01 k8s]# chmod +x token.sh 
[root@master01 k8s]# ./token.sh 
[root@master01 k8s]# cat /opt/kubernetes/cfg/token.csv 
7a660c8c9b674d8b803c78c741a94078,kubelet-bootstrap,10001,"sysytem:kubelet-bootstrap"

 

4.8 二进制文件、token、证书都准备好后，开启apiserver服务

[root@master01 k8s]# cd /opt/k8s/
[root@master01 k8s]# ./apiserver.sh 192.168.80.116 https://192.168.80.116:2379,https://192.168.122.11:2379,https://192.168.122.12:2379
Created symlink from /etc/systemd/system/multi-user.target.wants/kube-apiserver.service to /usr/lib/systemd/system/kube-apiserver.service.

4.9 检查

4.9.1 检查进程是否启动成功
[root@master01 k8s]# ps aux | grep kube-apiserver

k8s通过kube-apiserver这个进程提供服务，该进程运行在单个master节点上。默认有两个端口6443和8080（新版本为58080）

4.9.2 检查6443端口

安全端口6443用于接收HTTPS请求，用于基于Token文件或客户端证书等认证

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

 

4.9.3 检查8080端口

本地端口8080用于接收HTTP请求，非认证或授权的HTTP请求通过该端口访问API Server

[root@master01 k8s]# netstat -natp | grep 8080
tcp        0      0 127.0.0.1:8080          0.0.0.0:*               LISTEN      3667/kube-apiserver
4.9.4 查看版本信息

必须保证apiserver启动正常，不然无法查询到server的版本信息

[root@master01 k8s]# kubectl version

 

4.10 启动scheduler服务

[root@master01 k8s]# ./scheduler.sh 127.0.0.1

[root@master01 k8s]# ps aux | grep kube-schesuler

 

4.11 启动controller-manager服务

[root@master01 k8s]# ./controller-manager.sh 127.0.0.1

[root@master01 k8s]# ps aux | grep controller-manager

 

4.12  生成kubectl连接集群的kubeconfig文件 ./admin.sh

./admin.sh

4.12 查看master节点状态

[root@master01 k8s]# kubectl get componentstatuses

或

[root@master01 k8s]# kubectl get cs

 

5. 部署Worker Node组件

创建kubernetes工作目录

[root@node02 etcd]#mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs}
[root@node02 etcd]#cd /opt
#上传 node.zip 到 /opt 目录中，解压 node.zip 压缩包，获得kubelet.sh、proxy.sh
[root@node02 opt]#rz -E
rz waiting to receive.
[root@node02 opt]#unzip node.zip 
Archive:  node.zip
  inflating: proxy.sh                
  inflating: kubelet.sh              
[root@node02 opt]#chmod +x kubelet.sh proxy.sh

5.1 把kubelet、kube-proxy拷贝到node节点（在master01节点操作）

[root@master01 k8s]# cd /opt/k8s/kubernetes/server/bin
[root@master01 bin]# scp kubelet kube-proxy root@192.168.80.111:/opt/kubernetes/bin/
 
[root@master01 bin]# scp kubelet kube-proxy root@192.168.80.112:/opt/kubernetes/bin/

 

5.2 编写脚本(在node01节点操作)

5.2.1 proxy.sh
[root@node01 opt]# cat proxy.sh 
#!/bin/bash
 
NODE_ADDRESS=$1
 
#创建 kube-proxy 启动参数配置文件
cat >/opt/kubernetes/cfg/kube-proxy <<EOF
KUBE_PROXY_OPTS="--logtostderr=true \\
--v=4 \\
--hostname-override=${NODE_ADDRESS} \\
--cluster-cidr=172.17.0.0/16 \\
--proxy-mode=ipvs \\
--kubeconfig=/opt/kubernetes/cfg/kube-proxy.kubeconfig"
EOF
 
#--hostnameOverride: 参数值必须与 kubelet 的值一致，否则 kube-proxy 启动后会找不到该 Node，从而不会创建任何 ipvs 规则
#--cluster-cidr：指定 Pod 网络使用的聚合网段，Pod 使用的网段和 apiserver 中指定的 service 的 cluster ip 网段不是同一个网段。 kube-proxy 根据 --cluster-cidr 判断集群内部和外部流量，指定 --cluster-cidr 选项后 kube-proxy 才会对访问 Service IP 的请求做 SNAT，即来自非 Pod 网络的流量被当成外部流量，访问 Service 时需要做 SNAT。
#--proxy-mode：指定流量调度模式为 ipvs 模式
#--kubeconfig: 指定连接 apiserver 的 kubeconfig 文件   
 
 
#----------------------
#创建 kube-proxy.service 服务管理文件
cat >/usr/lib/systemd/system/kube-proxy.service <<EOF
[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
5.2.2 编写kubelet.sh
[root@node01 opt]# cat kubelet.sh 
#!/bin/bash
 
NODE_ADDRESS=$1
DNS_SERVER_IP=${2:-"10.0.0.2"}
 
#创建 kubelet 启动参数配置文件
cat >/opt/kubernetes/cfg/kubelet <<EOF
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
 
#--hostname-override：指定kubelet节点在集群中显示的主机名或IP地址，默认使用主机hostname；kube-proxy和kubelet的此项参数设置必须完全一致
#--kubeconfig：指定kubelet.kubeconfig文件位置，用于如何连接到apiserver，里面含有kubelet证书，master授权完成后会在node节点上生成 kubelet.kubeconfig 文件
#--bootstrap-kubeconfig：指定连接 apiserver 的 bootstrap.kubeconfig 文件
#--config：指定kubelet配置文件的路径，启动kubelet时将从此文件加载其配置
#--cert-dir：指定master颁发的客户端证书和密钥保存位置
#--pod-infra-container-image：指定Pod基础容器（Pause容器）的镜像。Pod启动的时候都会启动一个这样的容器，每个pod之间相互通信需要Pause的支持，启动Pause需要Pause基础镜像
 
 
#----------------------
#创建kubelet配置文件（该文件实际上就是一个yml文件，语法非常严格，不能出现tab键，冒号后面必须要有空格，每行结尾也不能有空格）
cat >/opt/kubernetes/cfg/kubelet.config <<EOF
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
 
#PS：当命令行参数与此配置文件（kubelet.config）有相同的值时，就会覆盖配置文件中的该值。
 
 
#----------------------
#创建 kubelet.service 服务管理文件
cat >/usr/lib/systemd/system/kubelet.service <<EOF
[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
5.2.3 赋予上述脚本执行权限
[root@node01 opt]# chmod +x *.sh

5.3 在master01节点上操作

5.3.1 创建用于生成kubelet的配置文件的目录
[root@master01 ~]# mkdir /opt/k8s/kubeconfig
[root@master01 ~]#cd /opt/k8s/kubeconfig/
[root@master01 kubeconfig]#rz -E
rz waiting to receive.
[root@master01 kubeconfig]#chmod +x kubeconfig.sh

 

5.3.2 编写kubeconfig.sh

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

[root@master01 ~]# cd !$
cd /opt/k8s/kubeconfig
[root@master01 kubeconfig]# cat kubeconfig.sh 
#!/bin/bash
#example: kubeconfig 192.168.122.10 /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
5.3.3 生成kubelet的配置文件
[root@master01 kubeconfig]# ./kubeconfig.sh 192.168.80.116 /opt/k8s/k8s-cert/
[root@master01 kubeconfig]# ls
bootstrap.kubeconfig  kubeconfig.sh  kube-proxy.kubeconfig

 

5.3.4 把配置文件bootstrap.kubeconfig、kube-proxy.kubeconfig拷贝到node节点
[root@master01 kubeconfig]# cd /opt/k8s/kubeconfig
[root@master01 kubeconfig]# scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.80.111:/opt/kubernetes/cfg/
  
[root@master01 kubeconfig]# scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.80.112:/opt/kubernetes/cfg/

 

5.3.5 RBAC授权及相关说明

将预设用户kubelet-bootstrap与内置的ClusterRole system:node-bootstrapper绑定到一起，使其能够发起CSR请求

[root@master01 opt]# kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap

 

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

Master apiserver启用TLS认证后，node节点kubelet组件想要加入集群，必须使用CA签发的有效证书才能与apiserver通信，当node节点很多时，前述证书是一件很繁琐的事情。因此Kubernetes引入了TLS bootstrapping机制来兹自动颁发客户端证书，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生成一个证书，以后的访问都是用证书做认证了。

5.3.6 查看角色
[root@master01 kubeconfig]# kubectl get clusterroles | grep system:node-bootstrapper

 

5.3.7 查看已授权的角色
[root@master01 kubeconfig]# kubectl get clusterrolebinding

5.4 在node1节点上操作

5.4.1 使用kubelet.sh脚本启动kubelet服务
[root@node01 opt]# cd /opt
[root@node01 opt]# chmod +x kubelet.sh
[root@node01 opt]# ./kubelet.sh 192.168.80.111

 

5.4.2 检查kubelet服务启动
[root@node01 opt]# ps aux | grep kubelet

 

5.4.3 查看当前ssl目录
[root@node01 opt]# ls /opt/kubernetes/ssl/

此时还没有生成证书，因为master还未对此申请做批准操作

5.4 在master01节点上操作

5.4.1 查看CSR请求
[root@master01 opt]# kubectl get csr

发现有来自于kubelet-bootstrap的申请，处于待办状态

5.4.2 通过CSR请求
[root@master01 opt]# kubectl certificate approve node-csr-NJKSDx9hIMMweZuDIvyRABq4mguRltOyzm0_hsSXpRg

 

5.4.3 再次查看CSR请求状态
[root@master01 opt]# kubectl get csr


​​​​Approved,Issued表示已授权CSR请求并签发整数

5.4.4 查看集群节点状态
[root@master01 opt]# kubectl get nodes

已成功接入node01节点

5.5 在node01节点上操作

5.5.1 已自动生成证书和kubelet.kubeconfig文件
[root@node01 opt]#ls /opt/kubernetes/ssl
kubelet-client.key.tmp  kubelet.crt  kubelet.key
[root@node01 opt]#ls /opt/kubernetes/cfg/kubelet.kubeconfig 
/opt/kubernetes/cfg/kubelet.kubeconfig
[root@node01 opt]#ls /opt/kubernetes/ssl
kubelet-client-2024-05-14-23-43-05.pem  kubelet-client-current.pem  kubelet.crt  kubelet.key

5.5.2 加载ip_vs模块
[root@node01 opt]# 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

5.5.3 使用proxy.sh脚本启动proxy服务
[root@node01 opt]# cd /opt
[root@node01 opt]# chmod +x proxy.sh 
[root@node01 opt]# ./proxy.sh 192.168.80.111

[root@node01 opt]# systemctl status kube-proxy.service

 

5.6 node02节点部署

5.6.1 方法一
5.6.1.1 在node01节点操作

将kubelet.sh、proxy.sh文件拷贝到node02节点

[root@node01 opt]# cd /opt/
[root@node01 opt]# scp kubelet.sh proxy.sh root@192.168.80.112:`pwd`

5.6.1.2 在node02节点上操作

使用kubelet.sh脚本启动kubelet服务

[root@node02 opt]# cd /opt
[root@node02 opt]# chmod +x kubelet.sh
[root@node02 opt]# ./kubelet.sh 192.168.80.112
5.6.1.3 在master01节点上操作
#查看CSR请求
[root@master01 opt]# kubectl get csr

#通过CSR请求
[root@master01 opt]# kubectl certificate approve node-csr-U0vcxG-T_Ri-ViHHmw73bRawSZfaJBSep1LQF_cejoQ 

#再次查看CSR请求
[root@master01 opt]# kubectl get csr

#查看集群中的节点状态
[root@master01 opt]# kubectl get nodes

5.6.1.4 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服务

[root@node02 opt]# cd /opt
[root@node02 opt]# chmod +x proxy.sh 
[root@node02 opt]# ./proxy.sh 192.168.80.112

查看服务状态

[root@node02 opt]# systemctl status kube-proxy.service

5.6.2 方法二
5.6.2.1 在node01节点操作

把现成的/opt/kubernetes目录和Kubelet、kube-proxy的service服务管理文件复制到其他节点

scp -r /opt/kubernetes/ root:192.168.80.112:/opt/
scp /usr/lib/systemd/system/{kubelet,kube-proxy}.service root@192.168.80.112:/usr/lib/systemd/system/
5.6.2.2 在node02节点操作

①首先删除复制过来的证书，node02可自行申请证书

cd /opt/kubernetes/ssl/
em -rf *

②修改配置文件kubelet、kubelet.config、kube-proxy的相关IP地址配置为当前节点的IP地址

加载ipvs模块

modeprobe ip_vs

③启动kubelet和kube-proxy服务并设置开机自启

systemctl enable --now kubelet.service
systemctl enable --now kube-proxy.service
5.6.2.3 在master01操作
查看CSR申请

kubectl get csr
通过CSR申请

kubectl certificate approve [node-csr-......]

小艺要秃头
关注
  • 14
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Kubernetes二进制部署 单节点
shanjun12的博客
05-15 649
Kubernetes二进制部署 单节点
kubernetes二进制集群部署——–多master集群（步骤非常详细，适合初学者）
01-09
文章目录一、多master节点集群搭建示意图二、部署环境—单 master 节点的 k8s集群三、添加 master2 多节点K8s集群3.1、在master1上拷贝重要文件给master23.2、master2修改复制的配置文件3.3、制作master2 的ETCD证书3.4、启动 master2 的三个组件3.5、验证master2是否加入K8s集群四、搭建nginx负载均衡五、搭建 keepalived 高可用服务5.1、搭建 nginx 的高可用5.2、验证高可用功能六、node节点指向 LB 高可用群集七、k8s多节点集群测试 一、多master节点集群搭建示意图
Kubernetes高可用集群二进制部署（Runtime Containerd）
因上努力，果上随缘。但行好事，莫问前程。
07-01 932
Kubernetes（简称为：k8s）是Google在2014年6月开源的一个容器集群管理系统，使用Go语言开发，用于管理云平台中多个主机上的容器化的应用，Kubernetes的目标是让部署容器化的应用简单并且高效,Kubernetes提供了资源调度、部署管理、服务发现、扩容缩容、监控，维护等一整套功能，努力成为跨主机集群的自动部署、扩展以及运行应用程序容器的平台。 它支持一系列容器工具, 包括Docker、Containerd等。 2.1.2 主机与IP地址解析 2.1.3 主机安全设置 2.1.3.
【Kubernetes】Kubernetes之二进制部署
一个萌新的博客
08-03 1103
K8S的安装部署方式的概念（Minikube、Kubeadm、二进制）以及二进制安装具体过程（ 操作系统初始化配置、部署 etcd 集群、部署 docker引擎、部署 Master 组件、部署 Worker Node 组件、部署 CNI 网络组件 ）
kubernetes二进制部署单master节点
Dragon的博客
09-19 945
目录 1、安装要求 2、安装规划 3.1、分步骤操作 3.2、一键执行脚本 4.1、安装cfssl证书生成工具 4.2、创建认证中心（根CA中心） 4.3、使用自签CA签发Etcd证书 4.4、部署Etcd集群 5、部署Docker 6.1、创建认证中心（根CA中心） 6.2、使用自签CA签发kube-apiserver HTTPS证书 6.3、部署kube-apiserver组件 6.4、部署kube-controller-manager 6.5、部署kube-schedule
二进制安装k8s-单master节点
菜的一笔
05-25 369
k8s二进制组件部署安装
k8s-集群搭建的三种方式和区别，kubeadm、minikube，二进制包
xujingcheng123的博客
01-13 1275
k8s-集群搭建的三种方式和区别，kubeadm、minikube，二进制包
Kubernetes高可用集群二进制部署
weixin_54720351的博客
01-30 460
k8s二进制集群布署
Kubelet bootstrap认证配置步骤
weixin_34100227的博客
11-16 2817
kubelet 授权 kube-apiserver 的一些操作 exec run logs 等 RBAC 只需创建一次就可以 kubectl create clusterrolebinding kube-apiserver:kubelet-apis --clusterrole=system:kubelet-api-admin --user kubernetes   创建...
二进制部署kubernetes多master集群
08-30
每一步都很详细，欢迎来获取
Kubernetes二进制手动搭建文档(单master).docx
03-19
kubernetes二进制部署，calico模式，ipvs模式
MulticsKubernetes:Kubernetes实战（二进制部署，项目，架构＆二进制分析）-项目
03-24
Kubernetes二进制部署和插件配置 官方实例，社区实例和自己开发部署实例 Kubernetes架构与原始码剖析 Kubernetes几乎所有的安装组件和Docker完全都放在goolge自己的网站上，这对国内的同学可能是个不小的障碍。建议...
kubernetes部署Master组件
01-07
1、下载解压kubernetes server二进制包这里是v1.14： tar -zxvf kubernetes-server-linux-amd64.tar.gz cd kubernetes/server/bin/ cp kube-scheduler kube-apiserver kube-controller-manager k
kubernetes二进制部署
m0_59424504的博客
01-17 413
二进制部署kubernets/k8s
kubernetes的几种极简部署与试用方式
zhaoenweiex的博客
10-28 1324
前言 前一段实践想在开发环境下搞一套kubernetes，可惜手头只有一台开发用的windows机器，发现看似简单的机器其实有不少的坑，走了不少弯路耗费了不少时间，在这里记录下来，希望后来人少走一样的弯路。实际上这个问题本身就是一个有问题的问题，在国内的网络环境下的一台windows机器想要成功部署单机kubernetes本身就是一个有问题的方向，在这里仅讨论几种较为简单的部署方式，在这里为了避免...
Kubernetes的几种主流部署方式01-minikube部署
寞月的博客
03-21 4920
综述 Kubernetes集群的组件众多，要部署一套符合生产环境的集群不是一件容易的事。好在随着社区的快速发展，特别是在它成为事实上的容器编排标准以后，基本所有的主流云平台都完全支持Kubernetes，或把它作为核心的云解决方案。同时，本地部署也出现了各类成熟的主动化解决方案，特别是Kubeadm，在最新的1.13版本已经官方GA了，也就是完全可以用在生产环境中了。这些云服务或自动化工具都大大减...
k8s学习——minikube与kubernetes安装与启动
沧夜的成长日记
05-16 3746
k8s学习——minikube安装与启动 minikube的安装前提是安装了docker，但是由于我的系统是ubuntu20.04，docker尚未完全适配，所以docker在ubuntu20.04的安装暂且不提。后期官方文档更新后，会把这个坑给补上。 minikube的安装 minikube在ubuntu上的安装有两种方式。 第一种安装 https://github.com/kubernetes/minikube/releases/tag/v1.10.1 github下载安装包使用dpkg安装 我们要下载
k8s二进制部署单节点
最新发布
09-12
要在单节点上部署 Kubernetes (K8s) 的二进制版本，您需要完成以下步骤： 1. 准备单个可用的主机，该主机应满足 Kubernetes 的最低硬件要求。 2. 安装操作系统：确保主机上安装了支持的操作系统，例如 Ubuntu、CentOS 等，并更新所有软件包。 3. 下载和安装 Docker：在主机上安装 Docker，这是 Kubernetes 运行时所需的容器引擎。 4. 下载和安装 Kubernetes 二进制文件：从 Kubernetes 官方 GitHub 存储库中下载适用于您操作系统的二进制文件。您需要获取 kubelet、kube-proxy 和 kubectl 等组件。 5. 配置 kubelet：编辑 kubelet 的配置文件（kubelet.conf），指定 Kubernetes Master 节点的地址和其他相关配置。 6. 启动 kubelet 和 kube-proxy：使用先前配置的 kubelet.conf 启动 kubelet 和 kube-proxy。 请注意，以上步骤只是一个简单的概述，并且在实际部署中可能涉及更多复杂的配置和步骤。为了确保成功部署 Kubernetes，建议参考更详细的文档和指南，例如 Kubernetes 官方文档或其他社区资源。 同时，建议您考虑使用可重复和自动化的部署方法，例如使用工具如 kubeadm、kubespray 或其他基于 Ansible 的解决方案，以简化和加速 Kubernetes 集群的部署过程。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值