当前位置： 首页 > news >正文

k8s（2）

news 来源：原创 2024/5/9 7:17:15

目录

一.二进制部署k8s

常见的K8S安装部署方式：

k8s部署 二进制与高可用的区别

二.部署k8s

初始化操作：

每台node安装docker：

在 master01 节点上操作;

准备cfssl证书生成工具:：

执行脚本文件：

拉入etcd压缩包：

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

执行etcd.sh脚本：

将目录所有文件复制到node节点上：

修改node节点的etcd文件：

启动etcd服务：

检查etcd群集状态：

查看etcd集群成员列表：

​编辑安装 Master 组件，准备生成CA证书：

创建用于生成CA证书、相关组件的证书和私钥的目录：

创建kubernetes工作目录：

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

上传解压 kubernetes 压缩包：

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

解压master.zip：

启动 scheduler 服务：

启动 controller-manager 服务：

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

过kubectl工具查看当前集群组件状态：

 部署 Worker Node 组件：

创建kubernetes工作目录：

在 master01 节点上操作：

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

授权，执行脚本：

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

master节点启动 kubelet 服务：

通过 CSR 请求：

在 node01 节点上操作：

启动proxy服务：

一.二进制部署k8s

常见的K8S安装部署方式：


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

Kubeadm也是一个工具，提供kubeadm init和kubeadm join，用于快速部署K8S集群，相对简单。
https://kubernetes.io/docs/reference/setup-tools/kubeadm/kubeadm/

二进制安装部署
生产首选，从官方下载发行版的二进制包，手动部署每个组件和自签TLS证书，组成K8S集群，新手推荐。
https://github.com/kubernetes/kubernetes/releases

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

k8s部署 二进制与高可用的区别

二进制部署
部署难，管理方便，集群伸展性能好
更稳定，集群规模到达一定的规模(几百个节点、上万个Pod)，二进制稳定性是要高于kubeadm部署
遇到故障，宿主机起来了，进程也会起来。

kubeadm部署
部署简单，管理难
是以一种容器管理容器的方式允许的组件及服务，故障恢复时间比二进制慢
遇到故障，启动宿主机，再启动进程，最后去启动容器，集群才能恢复，速度比二进制慢

二.部署k8s

k8s master节点：192.168.233.10，20

k8s node节点：192.168.233.30，40 （容器引擎为docker）

etcd集群：192.168.233.10,30,40

负载均衡nginx+keepalive01（master）： 192.168.233.50
负载均衡nginx+keepalive02（backup）：192.168.233.60

初始化操作：

关闭防火墙
systemctl stop firewalld
systemctl disable firewalld

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

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

根据规划设置主机名
hostnamectl set-hostname master01
hostnamectl set-hostname node01
hostnamectl set-hostname node02

在master添加hosts
cat >> /etc/hosts << EOF
192.168.233.10 master01
192.168.233.30 node01
192.168.233.40 node02
EOF

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

sysctl --system

时间同步
yum install ntpdate -y
ntpdate time.windows.com

每台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 

切换到docker目录下，添加文件：

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

.

安装设置为开机自动启动：

yum install -y docker-ce docker-ce-cli containerd.io
systemctl start docker.service
systemctl enable docker.service 

在 master01 节点上操作;

准备cfssl证书生成工具:：

wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64 -O /usr/local/bin/cfssl
wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64 -O /usr/local/bin/cfssljson
wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64 -O /usr/local/bin/cfssl-certinfo

chmod +x /usr/local/bin/*

创建工作目录：

添加脚本文件：

#!/bin/bash
#配置证书生成策略，让 CA 软件知道颁发有什么功能的证书，生成用来签发其他组件证书的根证书
cat > ca-config.json <<EOF
{"signing": {"default": {"expiry": "87600h"},"profiles": {"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证书和私钥（根证书和私钥）
cat > ca-csr.json <<EOF
{"CN": "etcd","key": {"algo": "rsa","size": 2048{"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：根证书签发请求文件#注意：CSRJSON 文件用的是相对路径，所以 cfssl 的时候需要 csr 文件的路径下执行，也可以指定为绝对路径。
#cfssljson 将 cfssl 生成的证书（json格式）变为文件承载式证书，-bare 用于命名生成的证书文件。
#-----------------------
{"CN": "etcd","hosts": ["192.168.233.10","192.168.233.30","192.168.233.40"],"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


#!/bin/bash
#example: ./etcd.sh etcd01 192.168.233.10 etcd02=https://192.168.233.30:2380,etcd03=https://192.168.233.40:2380#创建etcd配置文件/opt/etcd/cfg/etcd
ETCD_NAME=$1
ETCD_IP=$2
ETCD_CLUSTER=$3WORK_DIR=/opt/etcd#[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#Clustering：集群配置
#ETCD_INITIAL_CLUSTER_TOKEN：集群Token。用于区分不同集群。本地如有多个集群要设为不同
#ETCD_INITIAL_CLUSTER_STATE：加入集群的当前状态，new是新集群，existing表示加入已有集群。#创建etcd.service服务管理文件
cat > /usr/lib/systemd/system/etcd.service <<EOF
[Unit]
Description=Etcd Server
After=network.target
After=network-online.target
Wants=network-online.target[Service]
Type=notify
EnvironmentFile=${WORK_DIR}/cfg/etcd
ExecStart=${WORK_DIR}/bin/etcd \
--cert-file=${WORK_DIR}/ssl/server.pem \
--key-file=${WORK_DIR}/ssl/server-key.pem \
--trusted-ca-file=${WORK_DIR}/ssl/ca.pem \
--peer-cert-file=${WORK_DIR}/ssl/server.pem \
--peer-key-file=${WORK_DIR}/ssl/server-key.pem \
--peer-trusted-ca-file=${WORK_DIR}/ssl/ca.pem \
--logger=zap \
--enable-v2
Restart=on-failure
LimitNOFILE=65536[Install]
WantedBy=multi-user.target
EOF#--enable-v2：开启 etcd v2 API 接口。当前 flannel 版本不支持 etcd v3 通信
#--logger=zap：使用 zap 日志框架。zap.Logger 是go语言中相对日志库中性能最高的
#--peer开头的配置项用于指定集群内部TLS相关证书（peer 证书），这里全部都使用同一套证书认证
#不带--peer开头的的参数是指定 etcd 服务器TLS相关证书（server 证书），这里全部都使用同一套证书认证systemctl daemon-reload
systemctl enable etcd
systemctl restart etcd
执行脚本文件：

./etcd-cert.sh

移动文件：

mkdir etcd-cert

mv ca* server* etcd-cert

拉入etcd压缩包：

解压：

tar zxvf etcd-v3.4.26-linux-amd64.tar.gz

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

mkdir -p /opt/etcd/{cfg,bin,ssl}

.切换到k8s中将命令移动到bin下：

mv etcd etcdctl /opt/etcd/bin/

复制etcd-cert下的.pem结尾文件到ssl目录下：

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

执行etcd.sh脚本：

./etcd.sh etcd01 192.168.233.10 etcd02=https://192.168.233.30:2380,etcd03=https://192.168.233.40:2380

查看端口：

将目录所有文件复制到node节点上：

scp -r /opt/etcd/ root@192.168.233.30:/opt/
scp -r /opt/etcd/ root@192.168.233.40:/opt/

scp /usr/lib/systemd/system/etcd.service root@192.168.233.30:/usr/lib/systemd/system/
scp /usr/lib/systemd/system/etcd.service root@192.168.233.40:/usr/lib/systemd/system/

修改node节点的etcd文件：

vim /opt/etcd/cfg/etcd

启动etcd服务：

systemctl start etcd
systemctl enable etcd
systemctl status 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.233.10:2379,https://192.168.233.30:2379,https://192.168.233.40:2379" endpoint health --write-out=table

查看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.233.10:2379,https://192.168.233.30:2379,https://192.168.233.40:2379" --write-out=table member list

安装 Master 组件，准备生成CA证书：

#!/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
#!/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"}]
}
EOFcfssl 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","127.0.0.1","192.168.233.10","192.168.233.20", "192.168.233.100","192.168.233.50","192.168.233.60","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#-----------------------
#生成 kubectl 连接集群的证书和私钥（kubectl 和 apiserver 通信使用）
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#-----------------------
#生成 kube-proxy 的证书和私钥（kube-proxy 和 apiserver 通信使用）
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"}]
}
EOFcfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-proxy-csr.json | cfssljson -bare kube-proxy
创建用于生成CA证书、相关组件的证书和私钥的目录：

移动脚本文件到目录中;

执行文件：

创建kubernetes工作目录：

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

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

cp ca*pem apiserver*pem /opt/kubernetes/ssl/

上传解压 kubernetes 压缩包：

tar xf kubernetes-server-linux-amd64.tar.gz

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

cp kube-apiserver kubectl kube-controller-manager kube-scheduler /opt/kubernetes/bin/

ln -s /opt/kubernetes/bin/* /usr/local/bin/

获取随机数前16个字节内容，以十六进制格式输出，并删除其中空格：

head -c 16 /dev/urandom | od -An -t x | tr -d ' '

生成 token.csv 文件，按照 Token序列号,用户名,UID,用户组 的格式生成：

#!/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

解压master.zip：

授权：

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

./apiserver.sh 192.168.233.10 https://192.168.233.10:2379,https://192.168.233.30:2379,https://192.168.233.40:2379

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

netstat -natp | grep 6443

启动 scheduler 服务：

#!/bin/bash
##创建 kube-scheduler 启动参数配置文件
MASTER_ADDRESS=$1cat >/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=$MASTER_ADDRESS"
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 获取对象最新的变化事件做期望状态和实际状态调整，scheduler watch 未绑定节点的 pod 做节点选择， 显然多个这些任务同时工作是完全没有必要的，所以 controller-manager 和 scheduler 也是需要选主的，但是选主逻辑和 etcd 不一样的，这里只需要保证从多个 controller-manager 和 scheduler 之间选出一个 leader 进入工作状态即可，而无需考虑它们之间的数据一致和同步。##生成kube-scheduler证书
#创建证书请求文件
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#生成证书和私钥#生成kubeconfig配置文件
KUBE_CONFIG="/opt/kubernetes/cfg/kube-scheduler.kubeconfig"
KUBE_APISERVER="https://192.168.233.10:6443"#配置kubernetes集群参数
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
EOFsystemctl daemon-reload
systemctl enable kube-scheduler
systemctl restart kube-scheduler

启动脚本：

启动 controller-manager 服务：

#!/bin/bash
##创建 kube-controller-manager 启动参数配置文件
MASTER_ADDRESS=$1cat >/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=$MASTER_ADDRESS \\
--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 集群##生成kube-controller-manager证书
#创建证书请求文件
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#生成证书和私钥#生成kubeconfig配置文件
KUBE_CONFIG="/opt/kubernetes/cfg/kube-controller-manager.kubeconfig"
KUBE_APISERVER="https://192.168.233.10:6443"#配置kubernetes集群参数
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
EOFsystemctl daemon-reload
systemctl enable kube-controller-manager
systemctl restart kube-controller-manager

执行脚本：

 ./controller-manager.sh 192.168.233.10

​​​​​​​

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

#!/bin/bash
mkdir /root/.kube
KUBE_CONFIG="/root/.kube/config"
KUBE_APISERVER="https://192.168.233.10:6443"#切换到k8s证书目录操作
cd /opt/k8s/k8s-cert/--certificate-authority=/opt/kubernetes/ssl/ca.pem \--embed-certs=true \--client-certificate=./admin.pem \--client-key=./admin-key.pem \
kubectl config set-context default \--kubeconfig=${KUBE_CONFIG}
#设置默认环境上下文
kubectl config use-context default --kubeconfig=${KUBE_CONFIG}
#生成的 kubeconfig 被保存到 /root/.kube/config 文件#########################################################
#集群参数
#本段设置了所需要访问的集群的信息。使用set-cluster设置了需要访问的集群，如上为kubernetes，这只是个名>称，实际为--server指向的apiserver；--certificate-authority设置了该集群的公钥；--embed-certs为true表示
将--certificate-authority证书写入到kubeconfig中；--server则表示该集群的kube-apiserver地址#用户参数
#本段主要设置用户的相关信息，主要是用户证书。如上的用户名为admin，证书为：/opt/kubernetes/ssl/admin.pem，私钥为：/opt/kubernetes/ssl/admin-key.pem。注意客户端的证书首先要经过集群CA的签署，否则不会被集群
认可。此处使用的是ca认证方式，也可以使用token认证，如kubelet的 TLS Boostrap 机制下的 bootstrapping 使
用的就是token认证方式。上述kubectl使用的是ca认证，不需要token字段#上下文参数
#集群参数和用户参数可以同时设置多对，在上下文参数中将集群参数和用户参数关联起来。上面的上下文名称为default，集群为kubenetes，用户为admin，表示使用admin的用户凭证来访问kubenetes集群的default命名空间，也>可以增加--namspace来指定访问的命名空间。#最后使用 kubectl config use-context default 来使用名为 default 的环境项来作为配置。 如果配置了多个环
境项，可以通过切换不同的环境项名字来访问到不同的集群环境。
#########################################################

执行脚本：

查看文件：

过kubectl工具查看当前集群组件状态：

kubectl get cs

查看版本信息：

kubectl version

绑定默认cluster-admin管理员集群角色，授权kubectl访问集群：

kubectl create clusterrolebinding cluster-system-anonymous --clusterrole=cluster-admin --user=system:anonymous

 部署 Worker Node 组件：

在所有 node 节点上操作30,40：

创建kubernetes工作目录：

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

上传 node.zip 到 /opt 目录中，解压 node.zip 压缩包：

#!/bin/bashNODE_ADDRESS=$1
DNS_SERVER_IP=${2:-"10.0.0.2"}
cat >/opt/kubernetes/cfg/kubelet <<EOF
KUBELET_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--hostname-override=node01 \\
--network-plugin=cni \\
--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.2"
EOF#--network-plugin：启用CNI
#--bootstrap-kubeconfig：指定连接 apiserver 的 bootstrap.kubeconfig 文件
#--config：指定kubelet配置文件的路径，启动kubelet时将从此文件加载其配置
#--cert-dir：指定master颁发的kubelet证书生成目录#----------------------
cat >/opt/kubernetes/cfg/kubelet.config <<EOF
kind: KubeletConfiguration
apiVersion: kubelet.config.k8s.io/v1beta1
address: ${NODE_ADDRESS}
port: 10250
readOnlyPort: 10255
cgroupDriver: systemd
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
EOFsystemctl daemon-reload
systemctl enable kubelet
systemctl restart kubelet


#!/bin/bashNODE_ADDRESS=$1#创建 kube-proxy 启动参数配置文件
cat >/opt/kubernetes/cfg/kube-proxy <<EOF
KUBE_PROXY_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--hostname-override=${NODE_ADDRESS} \\
--cluster-cidr=10.244.0.0/16 \\
--proxy-mode=ipvs \\
--kubeconfig=/opt/kubernetes/cfg/kube-proxy.kubeconfig"
EOF#--kubeconfig: 指定连接 apiserver 的 kubeconfig 文件
#rr: round-robin，轮询。
#lc: least connection，最小连接数。
#dh: destination hashing，目的地址哈希。
#sh: source hashing ,原地址哈希。
#sed: shortest expected delay，最短期望延时。
#nq: never queue ，永不排队。#----------------------
#创建 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
EOFsystemctl daemon-reload
systemctl enable kube-proxy
systemctl restart kube-proxy


#!/bin/bashNODE_ADDRESS=$1
#创建 kubelet 启动参数配置文件
cat >/opt/kubernetes/cfg/kubelet <<EOF
KUBELET_OPTS="--logtostderr=false \\
--hostname-override=node02 \\
--network-plugin=cni \\
--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.2"
EOF#--network-plugin：启用CNI
#--bootstrap-kubeconfig：指定连接 apiserver 的 bootstrap.kubeconfig 文件
#--config：指定kubelet配置文件的路径，启动kubelet时将从此文件加载其配置
#--cert-dir：指定master颁发的kubelet证书生成目录#----------------------
cat >/opt/kubernetes/cfg/kubelet.config <<EOF
kind: KubeletConfiguration
apiVersion: kubelet.config.k8s.io/v1beta1
address: ${NODE_ADDRESS}
port: 10250
readOnlyPort: 10255
cgroupDriver: systemd
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
EOFsystemctl daemon-reload
systemctl enable kubelet
systemctl restart kubelet


#!/bin/bashNODE_ADDRESS=$1#创建 kube-proxy 启动参数配置文件
cat >/opt/kubernetes/cfg/kube-proxy <<EOF
KUBE_PROXY_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--hostname-override=${NODE_ADDRESS} \\
--cluster-cidr=10.244.0.0/16 \\
--proxy-mode=ipvs \\
--kubeconfig=/opt/kubernetes/cfg/kube-proxy.kubeconfig"
EOF#--kubeconfig: 指定连接 apiserver 的 kubeconfig 文件
#rr: round-robin，轮询。
#lc: least connection，最小连接数。
#dh: destination hashing，目的地址哈希。
#sh: source hashing ,原地址哈希。
#sed: shortest expected delay，最短期望延时。
#nq: never queue ，永不排队。#----------------------
#创建 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
EOFsystemctl daemon-reload
systemctl enable kube-proxy
systemctl restart kube-proxy

授权：

在 master01 节点上操作：

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

cd /opt/k8s/kubernetes/server/bin

scp kubelet kube-proxy root@192.168.233.30:/opt/kubernetes/bin/
scp kubelet kube-proxy root@192.168.233.40:/opt/kubernetes/bin/

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

#!/bin/bash
#example: kubeconfig 192.168.233.10 /opt/k8s/k8s-cert/
#创建bootstrap.kubeconfig文件BOOTSTRAP_TOKEN=$(awk -F ',' '{print $1}' /opt/kubernetes/cfg/token.csv)
APISERVER=$1
SSL_DIR=$2export 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

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

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

scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.233.30:/opt/kubernetes/cfg/
scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.233.40:/opt/kubernetes/cfg/

查看一下：

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

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

master节点启动 kubelet 服务：

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

通过 CSR 请求：

kubectl certificate approve node-csr-vH5p3H5QliAUh9WjCnwXPDb84pFhcj-FrHiTIRDeeU8

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

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

kubectl get node

在 node01 节点上操作：

加载 ip_vs 模块：

ls /usr/lib/modules/$(uname -r)/kernel/net/netfilter/ipvs

for i in $(ls /usr/lib/modules/$(uname -r)/kernel/net/netfilter/ipvs|grep -o "^[^.]*");do echo $i; /sbin/modinfo -F filename $i >/dev/null 2>&1 && /sbin/modprobe $i;done

启动proxy服务：

./proxy.sh 192.168.233.30

master节点：

node02上启动kubelet：

master节点通过 CSR 请求：

node02上启动proxy：

相关文章：

  • 数据保护：如何有效应对.BecSec-P-XXXXXXXX勒索病毒的威胁
  • JavaWeb——005 -- 请求响应 分层解耦（Postman、三层架构、IOC、DI、注解）
  • 抖音爬虫批量视频提取功能介绍|抖音评论提取工具
  • AI工具新革命：从ChatGPT到Sora，生成式AI改变世界
  • spring boot3登录开发-3(账密登录逻辑实现)
  • 六、回归与聚类算法 - 模型保存与加载
  • TiDB 社区智慧合集丨TiDB 相关 SQL 脚本大全
  • 使用C#+NPOI进行Excel处理，实现多个Excel文件的求和统计
  • 每日leetcode--删除有序数组中的重复项
  • Node.JS入门（day01）
  • python3 flask 实现对config.yaml文件的内容的增删改查，并重启服务
  • 去重求和（最大N个数和最小N个数的和）（C 语言）
  • LINUX rpm离线包下载办法
  • 设计模式学习笔记 - 面向对象 - 6.为什么要基于接口而非实现编程？有必要为每个类都定义接口吗？
  • PD协议取电芯片：支持多协议小体积外围支持配置输出不同电压
  • 时间复杂度分析经典问题——最大子序列和
  • Iterator 和 for...of 循环
  • JavaScript新鲜事·第5期
  • JS+CSS实现数字滚动
  • JSONP原理
  • js写一个简单的选项卡
  • laravel with 查询列表限制条数
  • Laravel核心解读--Facades
  • yii2中session跨域名的问题
  • 发布国内首个无服务器容器服务，运维效率从未如此高效
  • 关于Android中设置闹钟的相对比较完善的解决方案
  • 如何优雅的使用vue+Dcloud（Hbuild）开发混合app
  • 突破自己的技术思维
  • 一些关于Rust在2019年的思考
  • 由插件封装引出的一丢丢思考
  • RDS-Mysql 物理备份恢复到本地数据库上
  • ​MPV，汽车产品里一个特殊品类的进化过程
  • # 执行时间 统计mysql_一文说尽 MySQL 优化原理
  • $.proxy和$.extend
  • (AngularJS)Angular 控制器之间通信初探
  • （备忘）Java Map 遍历
  • (附源码)springboot宠物医疗服务网站 毕业设计688413
  • （九十四）函数和二维数组
  • (转) Face-Resources
  • (转)chrome浏览器收藏夹（书签）的导出与导入
  • *（长期更新）软考网络工程师学习笔记——Section 22 无线局域网
  • ./indexer: error while loading shared libraries: libmysqlclient.so.18: cannot open shared object fil
  • .NET 2.0中新增的一些TryGet,TryParse等方法
  • .NET 的静态构造函数是否线程安全？答案是肯定的！
  • .NetCore项目nginx发布
  • .NET开发人员必知的八个网站
  • .project文件
  • /var/lib/dpkg/lock 锁定问题
  • @Service注解让spring找到你的Service bean
  • [ vulhub漏洞复现篇 ] Django SQL注入漏洞复现 CVE-2021-35042
  • [2019.3.5]BZOJ1934 [Shoi2007]Vote 善意的投票
  • [8-23]知识梳理：文件系统、Bash基础特性、目录管理、文件管理、文本查看编辑处理...
  • [Ariticle] 厚黑之道 一 小狐狸听故事
  • [C++] cout、wcout无法正常输出中文字符问题的深入调查（1）：各种编译器测试
  • [C++]类和对象【上篇】