【Kubernetes部署】二进制部署单Master Kurbernetes集群 超详细

二进制部署K8s

  • 一、基本架构和系统初始化操作
    • 1.1 基本架构
    • 1.2 系统初始化操作
  • 二、部署etcd集群
    • 2.1 证书签发
      • Step1 下载证书制作工具
      • Step2 创建k8s工作目录
      • Step3 编写脚本并添加执行权限
      • Step4 生成CA证书、etcd 服务器证书以及私钥
    • 2.2 启动etcd服务
      • Step1 上传并解压代码包
      • Step2 创建相关工作目录
      • Step3 通过脚本启动
      • Step4 把etcd相关证书文件、命令文件和服务管理文件全部拷贝到另外两个etcd集群节点
      • Step5 修改另外两个etcd集群节点的配置文件
      • Step6 检查etcd集群状态
  • 三、 部署Docker
  • 四、Master 组件部署
    • 4.1 上传软件包并解压
    • 4.2 编写相关脚本
      • 4.2.1 apiserver.sh
      • 4.2.2 scheduler.sh
      • 4.2.3 controller-manager.sh
      • 4.2.4 k8s-cert.sh
      • 4.2.5 token.sh
      • 4.2.6 admin.sh
      • 4.2.7 为上述脚本添加执行权限
    • 4.3 创建工作目录
    • 4.4 生成CA证书、相关组件的证书和私钥
      • 4.4.5 复制master组件的关键命令文件到 kubernetes工作目录的 bin 子目录中
    • 4.6 开启 apiserver 服务
    • 4.7 启动 scheduler 服务
    • 4.8 启动 controller-manager 服务
    • 4.9 授权kubectl访问集群
    • 4.10 查看master节点状态
  • 五、部署 Worker Node 组件
    • 5.1 创建kubernetes工作目录
    • 5.2 编写相关脚本
      • 5.2.1 kublet.sh
      • 5.2.2 proxy.sh
      • 5.2.3 kubeconfig.sh
    • 5.3 把 kubelet、kube-proxy 拷贝到 node 节点
    • 5.4 通过脚本生成kublet相关的配置文件并拷贝到node节点
    • 5.5 在node01节点启动相关服务
      • Step1 启动 kubelet 服务
      • Step2 启动proxy服务
    • 5.6 在node02节点启动相关服务
      • Step1 启动Kubelet
      • Step2 启动proxy
  • 六、部署 CNI 网络组件
    • 6.1 Flannel CNI 网络插件部署（node01节点）
      • Step1 上传flannel镜像文件和插件包到node01节点
      • Step2 在master01节点部署 CNI 网络
      • Step3 查看集群的节点状态
    • 6.2 node02节点部署
  • 七、部署 CoreDNS
    • 7.1 构建coredns镜像（所有node节点）
    • 7.2 编写CoreDNS配置文件
    • 7.2 部署 CoreDNS (master01节点）
    • 7.3 DNS解析测试
  • 八、K8S单节点测试
    • 8.1 确认 Kubernetes 组件运行状态
    • 8.2 应用访问测 试
      • 8.2.1 部署测试应用
      • 8.2.2 获取测试应用的 URL 和端口
      • 8.2.3 访问测试应用

一、基本架构和系统初始化操作

1.1 基本架构

1.20版本

在这里插入图片描述

ServerIPCompoments
Master01+Etcd01192.168.2.100kube-apiserver
kube-controller-manager
kube-schedular
etcd
Node01+Etcd02192.168.2.102kubelet
kube-proxy
docker
flannel
Node02+Etcd03192.168.2.103kubelet
kube-proxy
docker
flannel

1.2 系统初始化操作

1.关闭防火墙、selinux和swap

#关闭防火墙
systemctl disable firewalld --now  iptables -F && iptables -t nat -F && iptables -t mangle -F && iptables -X#关闭selinux
setenforce 0
sed -i 's/enforcing/disabled/' /etc/selinux/config#关闭swap
swapoff -a
sed -ri 's/.*swap.*/#&/' /etc/fstab

2.修改主机名，添加域名映射

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

#在master01节点添加
cat >> /etc/hosts << EOF
192.168.2.100 master01
192.168.2.102 node01
192.168.2.103 node02
EOF

在这里插入图片描述

3.修改内核参数

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

在这里插入图片描述

4.时间同步

#时间同步
yum install ntpdate -yntpdate ntp.aliyun.com

在这里插入图片描述

二、部署etcd集群

由于etcd 的leader选举机制，要求至少为3台或以上的奇数台

2.1 证书签发

在 master01 节点上操作

Step1 下载证书制作工具

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/cfssl*

Step2 创建k8s工作目录

 mkdir /opt/k8scd /opt/k8s

Step3 编写脚本并添加执行权限

1.编写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.2.100","192.168.2.102","192.168.2.103"],"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

在这里插入图片描述

2.编写etcd.sh，用于自动配置启动etcd

#!/bin/bash
#example: ./etcd.sh etcd01 192.168.2.100 etcd02=https://192.168.2.102:2380,etcd03=https://192.168.2.103:2380#创建etcd配置文件/opt/etcd/cfg/etcd
ETCD_NAME=$1
ETCD_IP=$2
ETCD_CLUSTER=$3WORK_DIR=/opt/etcdcat > $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 \
--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

chmod +x etcd-cert.sh etcd.sh

在这里插入图片描述

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

mkdir /opt/k8s/etcd-certmv etcd-cert.sh etcd-cert/cd /opt/k8s/etcd-cert/
#执行脚本
./etcd-cert.sh	ls

在这里插入图片描述

2.2 启动etcd服务

Step1 上传并解压代码包

cd /opt/k8s/
#解压代码包
tar zxvf etcd-v3.4.26-linux-amd64.tar.gz
uzls etcd-v3.4.26-linux-amd64

在这里插入图片描述

Step2 创建相关工作目录

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

mkdir -p /opt/etcd/{cfg,bin,ssl}cd /opt/k8s/etcd-v3.4.26-linux-amd64/mv etcd etcdctl /opt/etcd/bin/
cp /opt/k8s/etcd-cert/*.pem /opt/etcd/ssl/

Step3 通过脚本启动

cd /opt/k8s/./etcd.sh etcd01 192.168.2.100 etcd02=https://192.168.2.102:2380,etcd03=https://192.168.2.103:2380

进入卡住状态等待其他节点加入，这里需要三台etcd服务同时启动。

如果只启动其中一台后，服务会卡在那里，直到集群中所有etcd节点都已启动，可忽略这个情况
在这里插入图片描述

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

Step4 把etcd相关证书文件、命令文件和服务管理文件全部拷贝到另外两个etcd集群节点

scp -r /opt/etcd/ root@192.168.2.102:/opt/
scp -r /opt/etcd/ root@192.168.2.103:/opt/

在这里插入图片描述

scp /usr/lib/systemd/system/etcd.service root@192.168.2.102:/usr/lib/systemd/system/
scp /usr/lib/systemd/system/etcd.service root@192.168.2.103:/usr/lib/systemd/system/RestartSec=5

在这里插入图片描述

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

Node01 节点

#[Member]
ETCD_NAME="etcd02"											#修改
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.2.102:2380"			#修改
ETCD_LISTEN_CLIENT_URLS="https://192.168.2.102:2379"		#修改#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.2.102:2380"		#修改
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.2.102:2379"				#修改
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.2.100:2380,etcd02=https://192.168.2.102:2380,etcd03=https://192.168.2.103:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"

在这里插入图片描述

#启动etcd服务
systemctl enable etcd --now
systemctl status etcd

在这里插入图片描述

Node02 节点

vim /opt/etcd/cfg/etcd
#[Member]
ETCD_NAME="etcd03"											#修改
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.2.103:2380"			#修改
ETCD_LISTEN_CLIENT_URLS="https://192.168.2.103:2379"		#修改#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.2.103:2380"		#修改
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.2.103:2379"				#修改
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.2.100:2380,etcd02=https://192.168.2.102:2380,etcd03=https://192.168.2.103:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"

在这里插入图片描述

#启动etcd服务
systemctl enable etcd --now
systemctl status etcd

在这里插入图片描述

Step6 检查etcd集群状态

在master01节点上

集群状态

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.2.100:2379,https://192.168.2.102:2379,https://192.168.2.103:2379" endpoint health --write-out=table##命令详解##
ETCDCTL_API=3                                      # 设置 etcdctl 使用的 API 版本为 3
/opt/etcd/bin/etcdctl                              # etcdctl 的可执行文件路径
--cacert=/opt/etcd/ssl/ca.pem                      # CA 根证书路径
--cert=/opt/etcd/ssl/server.pem                    #ETCD 服务器证书路径
--key=/opt/etcd/ssl/server-key.pem                 #ETCD 服务器私钥路径
--endpoints="https://192.168.2.100:2379,https://192.168.2.102:2379,https://192.168.2.103:2379"  #ETCD 集群的访问地址，使用逗号分隔多个节点
endpoint health                                    #命令，检查 ETCD 集群的健康状态
--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.2.100:2379,https://192.168.2.102:2379,https://192.168.2.103:2379" --write-out=table member list--write-out=table                                # 输出格式设置为表格形式
member list                                      # 命令，列出 ETCD 集群的成员列表

在这里插入图片描述

三、 部署Docker

所有 node 节点部署docker引擎

yum install -y yum-utils device-mapper-persistent-data lvm2 
yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo 
yum install -y docker-ce docker-ce-cli containerd.iosystemctl start docker.service
systemctl enable docker.service

在这里插入图片描述

四、Master 组件部署

在master01节点上操作

4.1 上传软件包并解压

#上传 kubernetes-server-linux-amd64.tar.gz 到 /opt/k8s/ 目录中，解压 kubernetes 压缩包
cd /opt/k8s/
tar zxvf kubernetes-server-linux-amd64.tar.gz

4.2 编写相关脚本

4.2.1 apiserver.sh

#!/bin/bash
#example: apiserver.sh 192.168.2.100 https://192.168.2.100:2379,https://192.168.2.102:2379,https://192.168.2.103:2379
#创建 kube-apiserver 启动参数配置文件
MASTER_ADDRESS=$1
ETCD_SERVERS=$2cat >/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} \\
--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 \\
--enable-bootstrap-token-auth=true \\
--token-auth-file=/opt/kubernetes/cfg/token.csv \\
--service-node-port-range=30000-50000 \\
--kubelet-client-certificate=/opt/kubernetes/ssl/apiserver.pem \\
--service-account-issuer=api \\
--service-account-signing-key-file=/opt/kubernetes/ssl/apiserver-key.pem \\
--etcd-cafile=/opt/etcd/ssl/ca.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-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 地址段
#!/bin/bash
#example: apiserver.sh 192.168.2.100 https://192.168.2.100:2379,https://192.168.2.102:2379,https://192.168.2.103:2379
#创建 kube-apiserver 启动参数配置文件
MASTER_ADDRESS=$1
ETCD_SERVERS=$2cat >/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} \\
--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 \\
--enable-bootstrap-token-auth=true \\
--token-auth-file=/opt/kubernetes/cfg/token.csv \\
--service-node-port-range=30000-50000 \\
--kubelet-client-certificate=/opt/kubernetes/ssl/apiserver.pem \\
--service-account-issuer=api \\
--service-account-signing-key-file=/opt/kubernetes/ssl/apiserver-key.pem \\
--etcd-cafile=/opt/etcd/ssl/ca.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-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-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
EOFsystemctl daemon-reload
systemctl enable kube-apiserver
systemctl restart kube-apiserver

4.2.2 scheduler.sh

 #!/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=127.0.0.1"
EOF#-–kubeconfig：连接 apiserver 用的配置文件，用于识别 k8s 集群
#--leader-elect=true：当该组件启动多个时，自动启动 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",
#!/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=127.0.0.1"
EOF#-–kubeconfig：连接 apiserver 用的配置文件，用于识别 k8s 集群
#--leader-elect=true：当该组件启动多个时，自动启动 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#生成证书#生成kubeconfig文件
KUBE_CONFIG="/opt/kubernetes/cfg/kube-scheduler.kubeconfig"
KUBE_APISERVER="https://192.168.2.100: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
EOFsystemctl daemon-reload
systemctl enable kube-scheduler
systemctl restart kube-scheduler

4.2.3 controller-manager.sh

#!/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=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 集群
#--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#生成证书#生成kubeconfig文件
KUBE_CONFIG="/opt/kubernetes/cfg/kube-controller-manager.kubeconfig"
KUBE_APISERVER="https://192.168.2.100: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
EOFsystemctl daemon-reload
systemctl enable kube-controller-manager
systemctl restart kube-controller-manager

在这里插入图片描述

4.2.4 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"}]
}
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.2.100","192.168.2.106","192.168.2.200","192.168.80.104","192.168.80.105","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"}]
}
EOFcfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes apiserver-csr.json | cfssljson -bare apiserver#-----------------------
#生成 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"}]
}
EOFcfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes admin-csr.json | cfssljson -bare admin#-----------------------
#生成 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

在这里插入图片描述

4.2.5 token.sh

#!/bin/bash
#获取随机数前16个字节内容，以十六进制格式输出，并删除其中空格
BOOTSTRAP_TOKEN=$(head -c 16 /dev/urandom | od -An -t x | tr -d ' ')
#生成 token.csv 文件，按照 Token序列号,用户名,UID,用户组 的格式生成
cat > /opt/kubernetes/cfg/token.csv <<EOF
${BOOTSTRAP_TOKEN},kubelet-bootstrap,10001,"system:kubelet-bootstrap"
EOF

4.2.6 admin.sh

在 Kubernetes 集群中，通过 kubectl 命令行工具进行管理，而 kubectl 工具需要使用 kubeconfig 文件进行集群认证和授权。

这个脚本用于创建一个符合 Kubernetes 规范的 kubeconfig 配置文件，包含了集群地址、访问凭证、用户信息等必要的配置项。

#!/bin/bash
mkdir /root/.kube
KUBE_CONFIG="/root/.kube/config"
KUBE_APISERVER="https://192.168.80.10:6443"#切换到k8s证书目录操作
cd /opt/k8s/k8s-cert/#配置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 admin \--client-certificate=./admin.pem \--client-key=./admin-key.pem \--embed-certs=true \--kubeconfig=${KUBE_CONFIG}
#设置设置一个环境项，配置上下文参数
kubectl config set-context default \--cluster=kubernetes \--user=admin \--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 的环境项来作为配置。 如果配置了多个环境项，可以通过切换不同的环境项名字来访问到不同的集群环境。
#########################################################

4.2.7 为上述脚本添加执行权限

cd /opt/k8s
chmod +x *.sh

在这里插入图片描述

4.3 创建工作目录

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

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

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

在这里插入图片描述

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

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

#切换到bin子目录
cd /opt/k8s/kubernetes/server/bin
#复制关键命令文件
cp kube-apiserver kubectl kube-controller-manager kube-scheduler /opt/kubernetes/bin/
#做软链接方便管理
ln -s /opt/kubernetes/bin/* /usr/local/bin/

4.6 开启 apiserver 服务

#创建 bootstrap token 认证文件，apiserver 启动时会调用
#相当于在集群内创建了一个这个用户，接下来就可以用 RBAC 给他授权
cd /opt/k8s/
./token.shcat /opt/kubernetes/cfg/token.csv

在这里插入图片描述

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

cd /opt/k8s/./apiserver.sh 192.168.2.100 https://192.168.2.100:2379,https://192.168.2.102:2379,https://192.168.2.103:2379
#启动一个基于 etcd 的 API 服务器，并将其绑定到指定的 IP 地址上

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

在这里插入图片描述

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

在这里插入图片描述

4.7 启动 scheduler 服务

#启动 scheduler 服务
cd /opt/k8s/
./scheduler.sh#检查进程是否启动成功
ps aux | grep kube-scheduler

在这里插入图片描述

4.8 启动 controller-manager 服务

#启动 controller-manager 服务
./controller-manager.sh#检查进程是否启动成功
ps aux | grep kube-controller-manager

在这里插入图片描述

4.9 授权kubectl访问集群

#生成kubectl连接集群的kubeconfig文件
./admin.sh#绑定默认cluster-admin管理员集群角色，授权kubectl访问集群
kubectl create clusterrolebinding cluster-system-anonymous --clusterrole=cluster-admin --user=system:anonymous

在这里插入图片描述

4.10 查看master节点状态

#通过kubectl工具查看当前集群组件状态
kubectl get cs

在这里插入图片描述

#查看版本信息
kubectl version

在这里插入图片描述

五、部署 Worker Node 组件

5.1 创建kubernetes工作目录

#在所有 node 节点上操作
mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs}

5.2 编写相关脚本

5.2.1 kublet.sh

/opt/

#!/bin/bashNODE_ADDRESS=$1
DNS_SERVER_IP=${2:-"10.0.0.2"}#创建 kubelet 启动参数配置文件
cat >/opt/kubernetes/cfg/kubelet <<EOF
KUBELET_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--hostname-override=${NODE_ADDRESS} \\
--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#--hostname-override：指定kubelet节点在集群中显示的主机名或IP地址，默认使用主机hostname；kube-proxy和kubelet的此项参数设置必须完全一致
#--network-plugin：启用CNI
#--kubeconfig：指定kubelet.kubeconfig文件位置，当前为空路径，会自动生成，用于如何连接到apiserver，里面含有kubelet证书，master授权完成后会在node节点上生成 kubelet.kubeconfig 文件
#--bootstrap-kubeconfig：指定连接 apiserver 的 bootstrap.kubeconfig 文件
#--config：指定kubelet配置文件的路径，启动kubelet时将从此文件加载其配置
#--cert-dir：指定master颁发的kubelet证书生成目录
#--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: 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

5.2.2 proxy.sh

/opt/

#!/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#--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。
#--kubeconfig: 指定连接 apiserver 的 kubeconfig 文件
#--proxy-mode：指定流量调度模式为ipvs模式，可添加--ipvs-scheduler选项指定ipvs调度算法（rr|lc|dh|sh|sed|nq）
#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

5.2.3 kubeconfig.sh

#!/bin/bash
#example: kubeconfig 192.168.2.100 /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=$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

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

在 master01 节点上操作

cd /opt/k8s/kubernetes/server/bin
scp kubelet kube-proxy root@192.168.2.102:/opt/kubernetes/bin/
scp kubelet kube-proxy root@192.168.2.103:/opt/kubernetes/bin/

在这里插入图片描述

5.4 通过脚本生成kublet相关的配置文件并拷贝到node节点

生成kubelet初次加入集群引导kubeconfig文件和kube-proxy.kubeconfig文件。

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

#创建工作目录
mkdir /opt/k8s/kubeconfigcd /opt/k8s/kubeconfig
#赋予执行权限
chmod +x kubeconfig.sh
#执行脚本
./kubeconfig.sh 192.168.2.100 /opt/k8s/k8s-cert/

在这里插入图片描述

#把配置文件 bootstrap.kubeconfig、kube-proxy.kubeconfig 拷贝到 node 节点
scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.2.102:/opt/kubernetes/cfg/
scp bootstrap.kubeconfig kube-proxy.kubeconfig root@192.168.2.103:/opt/kubernetes/cfg/

在这里插入图片描述

#RBAC授权，使用户 kubelet-bootstrap 能够有权限发起 CSR 请求证书
kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap

5.5 在node01节点启动相关服务

Step1 启动 kubelet 服务

1.在node01节点启动kubelet

cd /opt/
./kubelet.sh 192.168.2.102
ps aux | grep kubelet

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

2.在master01节点通过CSR请求

#检查到 node01 节点的 kubelet 发起的 CSR 请求
#Pending 表示等待集群给该节点签发证书#列出 Kubernetes 集群中未决的证书签名请求 (Certificate Signing Requests)
kubectl get csr

在这里插入图片描述

#通过 CSR 请求
kubectl certificate approve node-csr-H5dFkwluF0sQw7swCeXsx3QlmAEO3sp4pIVLzvGli4I#再次查看
#Approved,Issued 表示已授权 CSR 请求并签发证书
kubectl get csr

在这里插入图片描述

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

在这里插入图片描述

Step2 启动proxy服务

#在 node01 节点上操作
#加载 ip_vs 模块
for i in $(ls /usr/lib/modules/$(uname -r)/kernel/net/netfilter/ipvs|grep -o "^[^.]*");do echo $i; /sbin/modinfo -F filename $i >/dev/null 2>&1 && /sbin/modprobe $i;done#`ls /usr/lib/modules/$(uname -r)/kernel/net/netfilter/ipvs | grep -o "^[^.]*"`- 这部分命令将列出位于 #`/usr/lib/modules/$(uname -r)/kernel/net/netfilter/ipvs` 目录中的文件名列表，并使用 grep 过滤出不包含点号的部分（即模块文件名）。# `for i in $(ls /usr/lib/modules/$(uname -r)/kernel/net/netfilter/ipvs | grep -o "^[^.]*")`- 这部分命令将以迭代的方式将目录中的每个模块文件名赋给变量 `i`。#`echo $i`- 这部分命令是为了在加载模块之前打印出当前要加载的模块文件名。# `/sbin/modinfo -F filename $i >/dev/null 2>&1`- 这部分命令将使用 modinfo 命令查询指定模块的文件名，并将输出重定向到 `/dev/null`，这样就不会在终端中打印输出结果。#`/sbin/modprobe $i`- 这部分命令是使用 modprobe 命令加载当前迭代的模块。#这段命令的目的是加载 IPVS 相关的内核模块，以支持 IPVS (IP Virtual Server) 的功能。它会遍历指定目录中的模块文件名，并通过 modprobe 加载这些模块。

在这里插入图片描述

#启动proxy服务
cd /opt/
./proxy.sh 192.168.2.102ps aux | grep kube-proxy

在这里插入图片描述

5.6 在node02节点启动相关服务

和node01类似

Step1 启动Kubelet

#node02节点
cd /opt/
./kubelet.sh 192.168.2.103
ps aux | grep kubelet

#切换到master节点
kubectl get csrkubectl certificate approve <NAME>

在这里插入图片描述

kubectl get nodes
#列出 Kubernetes 集群中所有的节点信息，包括节点的名称、状态、所属的组、IP 地址等

在这里插入图片描述

Step2 启动proxy

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服务
cd /opt/
./proxy.sh 192.168.2.103ps aux | grep kube-proxy

在这里插入图片描述

六、部署 CNI 网络组件

6.1 Flannel CNI 网络插件部署（node01节点）

Step1 上传flannel镜像文件和插件包到node01节点

在这里插入图片描述

cd /opt
#根据本地文件加载镜像
docker load -i flannel.tar

在这里插入图片描述

#解压CNI 插件包
mkdir /opt/cni/bin -p
tar zxvf cni-plugins-linux-amd64-v1.3.0.tgz -C /opt/cni/bin

Step2 在master01节点部署 CNI 网络

#上传 kube-flannel.yml 文件到 /opt/k8s 目录中，部署 CNI 网络
cd /opt/k8s#将 kube-flannel.yml 文件中的配置应用到 Kubernetes 集群中
#创建或更新在 YAML 文件中定义的所有资源对象
kubectl apply -f kube-flannel.yml

在这里插入图片描述

详解
#这个 YAML 文件包含了创建 Flannel 网络插件所需的资源对象。以下是文件中包含的资源对象的简要说明：#- namespace: kube-flannel：创建一个名为 kube-flannel 的命名空间，用于隔离 Flannel 插件的相关资源。
#- serviceaccount: flannel：创建一个名为 flannel 的服务账户，用于授权 Flannel 插件与 Kubernetes API 服务器进行通信。
#- clusterrole: flannel：创建一个名为 flannel 的集群角色，定义了 Flannel 插件所需的权限。
#- clusterrolebinding: flannel：创建一个名为 flannel 的集群角色绑定，将 flannel 服务账户与 flannel 集群角色绑定，以授予 flannel 服务账户所需的权限。
#- configmap: kube-flannel-cfg：创建一个名为 kube-flannel-cfg 的配置映射，其中包含了 Flannel 插件的配置信息。
#- daemonset: kube-flannel-ds：创建一个名为 kube-flannel-ds 的 DaemonSet，用于在集群中的每个节点上部署和管理 Flannel 插件的 Pod。通过应用这个 YAML 文件,创建了 Flannel 网络插件所需的各种资源对象。
可以使用 `kubectl get` 命令来查看这些资源对象的状态和详细信息。

#获取 kube-flannel 命名空间中的所有 Pod 的信息
kubectl get pods -n kube-flannel
或者
kubectl get pods -A

在这里插入图片描述

#补充，卸载插件
kubectl delete -f kube-flannel.yml

Step3 查看集群的节点状态

kubectl get nodes

在这里插入图片描述

#切换到node01
ifconfig

在这里插入图片描述

6.2 node02节点部署

步骤和node01的部署大致相同，由于网络插件的部署都是全局的，所以这里依旧使用flannel 插件（防止插件冲突)。

cd /opt
#根据本地文件加载镜像
docker load -i flannel.tar#解压CNI 插件包
mkdir /opt/cni/bin -p
tar zxvf cni-plugins-linux-amd64-v1.3.0.tgz -C /opt/cni/binkubectl apply -f kube-flannel.yml

#查看集群节点状态
kubectl get nodes

在这里插入图片描述

七、部署 CoreDNS

7.1 构建coredns镜像（所有node节点）

#上传 coredns.tar 到 /opt 目录中
cd /opt
docker load -i coredns.tar

在这里插入图片描述

7.2 编写CoreDNS配置文件

# __MACHINE_GENERATED_WARNING__apiVersion: v1
kind: ServiceAccount
metadata:name: corednsnamespace: kube-systemlabels:kubernetes.io/cluster-service: "true"addonmanager.kubernetes.io/mode: Reconcile
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:labels:kubernetes.io/bootstrapping: rbac-defaultsaddonmanager.kubernetes.io/mode: Reconcilename: system:coredns
rules:
- apiGroups:- ""resources:- endpoints- services- pods- namespacesverbs:- list- watch
- apiGroups:- ""resources:- nodesverbs:- get
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:annotations:rbac.authorization.kubernetes.io/autoupdate: "true"labels:kubernetes.io/bootstrapping: rbac-defaultsaddonmanager.kubernetes.io/mode: EnsureExistsname: system:coredns
roleRef:apiGroup: rbac.authorization.k8s.iokind: ClusterRolename: system:coredns
subjects:
- kind: ServiceAccountname: corednsnamespace: kube-system
---
apiVersion: v1
kind: ConfigMap
metadata:name: corednsnamespace: kube-systemlabels:addonmanager.kubernetes.io/mode: EnsureExists
data:Corefile: |.:53 {errorshealth {lameduck 5s}readykubernetes cluster.local in-addr.arpa ip6.arpa {pods insecurefallthrough in-addr.arpa ip6.arpattl 30}prometheus :9153forward . /etc/resolv.conf {max_concurrent 1000}cache 30loopreloadloadbalance}
---
apiVersion: apps/v1
kind: Deployment
metadata:name: corednsnamespace: kube-systemlabels:k8s-app: kube-dnskubernetes.io/cluster-service: "true"addonmanager.kubernetes.io/mode: Reconcilekubernetes.io/name: "CoreDNS"
spec:# replicas: not specified here:# 1. In order to make Addon Manager do not reconcile this replicas parameter.# 2. Default is 1.# 3. Will be tuned in real time if DNS horizontal auto-scaling is turned on.strategy:type: RollingUpdaterollingUpdate:maxUnavailable: 1selector:matchLabels:k8s-app: kube-dnstemplate:metadata:labels:k8s-app: kube-dnsspec:securityContext:seccompProfile:type: RuntimeDefaultpriorityClassName: system-cluster-criticalserviceAccountName: corednsaffinity:podAntiAffinity:preferredDuringSchedulingIgnoredDuringExecution:- weight: 100podAffinityTerm:labelSelector:matchExpressions:- key: k8s-appoperator: Invalues: ["kube-dns"]topologyKey: kubernetes.io/hostnametolerations:- key: "CriticalAddonsOnly"operator: "Exists"nodeSelector:kubernetes.io/os: linuxcontainers:- name: corednsimage: registry.cn-hangzhou.aliyuncs.com/google_containers/coredns:1.7.0imagePullPolicy: IfNotPresentresources:limits:memory: 170Mirequests:cpu: 100mmemory: 70Miargs: [ "-conf", "/etc/coredns/Corefile" ]volumeMounts:- name: config-volumemountPath: /etc/corednsreadOnly: trueports:- containerPort: 53name: dnsprotocol: UDP- containerPort: 53name: dns-tcpprotocol: TCP- containerPort: 9153name: metricsprotocol: TCPlivenessProbe:httpGet:path: /healthport: 8080scheme: HTTPinitialDelaySeconds: 60timeoutSeconds: 5successThreshold: 1failureThreshold: 5readinessProbe:httpGet:path: /readyport: 8181scheme: HTTPsecurityContext:allowPrivilegeEscalation: falsecapabilities:add:- NET_BIND_SERVICEdrop:- allreadOnlyRootFilesystem: truednsPolicy: Defaultvolumes:- name: config-volumeconfigMap:name: corednsitems:- key: Corefilepath: Corefile
---
apiVersion: v1
kind: Service
metadata:name: kube-dnsnamespace: kube-systemannotations:prometheus.io/port: "9153"prometheus.io/scrape: "true"labels:k8s-app: kube-dnskubernetes.io/cluster-service: "true"addonmanager.kubernetes.io/mode: Reconcilekubernetes.io/name: "CoreDNS"
spec:selector:k8s-app: kube-dnsclusterIP: 10.0.0.2ports:- name: dnsport: 53protocol: UDP- name: dns-tcpport: 53protocol: TCP- name: metricsport: 9153protocol: TCP

7.2 部署 CoreDNS (master01节点）

#上传 coredns.yaml 文件到 /opt/k8s 目录中，部署 CoreDNS 
cd /opt/k8s#Kubernetes读取配置文件并更新 CoreDNS 的配置
kubectl apply -f coredns.yaml#查看运行在 kube-system 命名空间中的 Kubernetes Pod 列表
kubectl get pods -n kube-system

在这里插入图片描述

7.3 DNS解析测试

#在Kubernetes 集群中启动一个临时的 Busybox 容器，并进入其交互式终端
kubectl run -it --rm dns-test --image=busybox:1.28.4 shIf you don't see a command prompt, try pressing enter.
/ # nslookup kubernetes

在这里插入图片描述

八、K8S单节点测试

8.1 确认 Kubernetes 组件运行状态

kubectl get cs

在这里插入图片描述

8.2 应用访问测 试

8.2.1 部署测试应用

部署一个简单的测试应用程序以验证 Kubernetes 集群是否正常工作。

vim test-nginx.yamlapiVersion: apps/v1
kind: Deployment
metadata:name: test-nginx
spec:replicas: 1selector:matchLabels:app: test-nginxtemplate:metadata:labels:app: test-nginxspec:containers:- name: test-nginximage: nginx:latestports:- containerPort: 80---
apiVersion: v1
kind: Service
metadata:name: test-nginx
spec:selector:app: test-nginxports:- protocol: TCPport: 80targetPort: 80type: NodePort

#创建 Deployment 和 Service
kubectl apply -f test-nginx.yaml

在这里插入图片描述

8.2.2 获取测试应用的 URL 和端口

kubectl get pods
#如果测试应用的 Pod 状态显示为 "Running"，则表示应用已成功启动。

在这里插入图片描述

#获取名为 test-nginx 的服务的信息
kubectl get svc test-nginx [-o wide]#svc是service的缩写

在这里插入图片描述

8.2.3 访问测试应用

使用浏览器或命令行工具访问测试应用的 URL，确认是否能够看到 Nginx 默认欢迎页面。

#切换到node01节点
firefox http://10.0.0.32:80

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/158312.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Git客户端软件 Tower mac中文版特点说明

Git客户端软件 Tower mac中文版特点说明

Tower mac是一款Mac OS X系统上的Git客户端软件&#xff0c;它提供了丰富的功能和工具&#xff0c;帮助用户更加方便地管理和使用Git版本控制系统。 Tower mac软件特点 1. 界面友好&#xff1a;Tower的界面友好&#xff0c;使用户能够轻松地掌握软件的使用方法。 2. 多种Git操…
阅读更多...
Redis之持久化（RDB和AOF）

Redis之持久化（RDB和AOF）

文章目录 前言一、RDB1.介绍2.redis.config有关配置3.触发4.恢复5.优缺点 二、AOF1.介绍2.redis.config配置3.启动4.恢复5.重写6.优缺点 总结 前言 Redis 是内存数据库&#xff0c;即数据存储在内存。 如果不将内存中的数据保存到磁盘&#xff0c;一旦服务器进程退出&#xff…
阅读更多...
2023年科技革新：引领行业走向未来的十大技术趋势

2023年科技革新：引领行业走向未来的十大技术趋势

随着时间的推移&#xff0c;2023年展现出了科技领域的一系列令人瞩目的新发现和趋势。这些新兴技术不仅推动了各行各业的发展&#xff0c;还为解决当今社会面临的诸多挑战提供了新的视角和解决方案。在这篇文章中&#xff0c;我们将探讨一些可能会改变行业面貌的关键技术趋势。…
阅读更多...
arcgis图上添加发光效果！

arcgis图上添加发光效果！

看完本文， 你可以不借助外部图片素材， 让你的图纸符号表达出你想要的光！ 我们以之前的某个项目图纸为例，来介绍下让符号发光的技术！ 第一步—底图整理 准备好栅格影像底图、行政边界的矢量数据，确保“数据合适、位置正确、边界吻合”。 确定好图纸的大小、出图比例、投…
阅读更多...
Thinkphp6项目在虚拟机无法指向pulic的目录访问的方法

Thinkphp6项目在虚拟机无法指向pulic的目录访问的方法

以阿里云虚拟主机为例&#xff0c;服务器环境为 LAMP&#xff0c;Apache2.4 php7.2 mysql5.7 1.根目录新建 index.php 文件&#xff0c;将以下内容放入文件中 <?php include ./public/index.php;2.将 public 目录下的 admin.php、backend 文件夹、static 文件夹、tinymc…
阅读更多...
计算机毕业设计选题推荐-招聘信息推荐系统-Python项目实战

计算机毕业设计选题推荐-招聘信息推荐系统-Python项目实战

✨作者主页&#xff1a;IT研究室✨ 个人简介&#xff1a;曾从事计算机专业培训教学&#xff0c;擅长Java、Python、微信小程序、Golang、安卓Android等项目实战。接项目定制开发、代码讲解、答辩教学、文档编写、降重等。 ☑文末获取源码☑ 精彩专栏推荐⬇⬇⬇ Java项目 Python…
阅读更多...
微服务框架SpringcloudAlibaba+Nacos集成RabbitMQ

微服务框架SpringcloudAlibaba+Nacos集成RabbitMQ

目前公司使用jeepluscloud版本&#xff0c;这个版本没有集成消息队列&#xff0c;这里记录一下&#xff0c;集成的过程&#xff1b;这个框架跟ruoyi的那个微服务版本结构一模一样&#xff0c;所以也可以快速上手。 1.项目结构图&#xff1a; 配置类的东西做成一个公共的模块 …
阅读更多...
数据分析指标体系的构建

数据分析指标体系的构建

指标体系是什么&#xff1f; &#xff08;S1&#xff09;为了用量化方式准确描述场景&#xff0c;提出一系列的指标。&#xff08;S2&#xff09;将指标有系统地组织起来&#xff0c;形成的逻辑体系 指标体系 指标 体系 单独的几个指标不能称之为指标体系 如何评价指…
阅读更多...
【服务器】Redis的安装及使用命令（Linux、Windows版）

【服务器】Redis的安装及使用命令（Linux、Windows版）

目录 一、Redis简介 二、Redis安装 1、Linux版 1.1、下载 1.2、导入 1.3、解压 1.4、安装 1.5、修改文件 1.6、启动redis 1.7、测试 1.8、结束进程 1.9、修改密码访问 1.10、安装客户端工具&连接 2、Windows版 2.1、下载 2.2、安装 2.3、修改 2.4、连接 …
阅读更多...
大数据与健康：技术助力医疗卫生事业腾飞

大数据与健康：技术助力医疗卫生事业腾飞

大数据与健康&#xff1a;技术助力医疗卫生事业腾飞 随着科技的飞速发展&#xff0c;大数据技术已经渗透到我们生活的方方面面&#xff0c;包括医疗卫生领域。本文将对大数据在健康医疗领域的应用进行分析&#xff0c;并通过数据图表展示其发展趋势和前景。 一、背景介绍 近…
阅读更多...
【计算机网络】运输层

【计算机网络】运输层

概述运输层服务 运输层协议为运行在不同主机上的应用程序提供了逻辑通信功能。 运输层协议是在端系统中而不是在路由器中实现的。 运输层和网络层的关系&#xff1a; 网络层提供主机之间的逻辑通信&#xff0c;而运输层为**运行在不同主机上的应用程序&#xff08;进程&#…
阅读更多...
Express框架开发接口之轮播图API

Express框架开发接口之轮播图API

1.获取所有轮播图、 // 处理轮播图 const handleDB require(../handleDB/index) // 获取所有轮播图 exports.allCarousel (req, res) > {(async function () {let results await handleDB(res, "book_carousel", "find", "查询数据出错&#xf…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023