【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.rhkb.cn/news/179035.html

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

相关文章

面试算法51：节点值之和最大的路径

面试算法51：节点值之和最大的路径

题目 在二叉树中将路径定义为顺着节点之间的连接从任意一个节点开始到达任意一个节点所经过的所有节点。路径中至少包含一个节点&#xff0c;不一定经过二叉树的根节点&#xff0c;也不一定经过叶节点。给定非空的一棵二叉树&#xff0c;请求出二叉树所有路径上节点值之和的最…
阅读更多...
分体式离子风刀和整体式离子风刀分别有哪些优缺点

分体式离子风刀和整体式离子风刀分别有哪些优缺点

离子风刀是一种利用高速旋转的离子风扇产生的离子风来清洁和干燥物体表面的设备。根据离子风扇的安装方式&#xff0c;离子风刀可以分为分体式离子风刀和整体式离子风刀。下面是它们各自的优缺点&#xff1a; 分体式离子风刀的优点&#xff1a; 安装方便&#xff1a;分体式离子…
阅读更多...
电压放大器可用于什么场合

电压放大器可用于什么场合

电压放大器是电子器件中常见的一种放大器类型&#xff0c;它可以将输入信号的电压放大到更大的幅度&#xff0c;以满足特定应用的需求。电压放大器广泛应用于多个领域和场合&#xff0c;下面将详细介绍一些使用电压放大器的场景。 音频放大器&#xff1a;音频放大器是电压放大器…
阅读更多...
（1）(1.11) LeddarTech Leddar One

（1）(1.11) LeddarTech Leddar One

文章目录 前言 1 连接到自动驾驶仪 2 参数说明 前言 Leddar One 激光雷达(Leddar One Lidar)是一款重量轻、价格合理的激光雷达&#xff0c;测距 40m&#xff0c;更新频率 70hz&#xff0c;光束为 3 度漫射。有关详细信息&#xff0c;请参阅数据表(datasheet)。 &#xff0…
阅读更多...
2023-11-03 LeetCode每日一题（填充每个节点的下一个右侧节点指针 II）

2023-11-03 LeetCode每日一题（填充每个节点的下一个右侧节点指针 II）

2023-11-03每日一题 一、题目编号 117. 填充每个节点的下一个右侧节点指针 II二、题目链接 点击跳转到题目位置 三、题目描述 给定一个二叉树&#xff1a; struct Node { int val; Node *left; Node *right; Node *next; } 填充它的每个 next 指针&#xff0c;让这个指针…
阅读更多...
ArcGIS Pro怎么生成高程点

ArcGIS Pro怎么生成高程点

一般情况下&#xff0c;我们从公开渠道获取到的高程数据都是DEM数据&#xff0c;但是如果要用到CAD等软件内则需要用到高程点&#xff0c;那么如何从DEM提取高程点呢&#xff0c;这里为大家介绍一下生成方法&#xff0c;希望能对你有所帮助。 数据来源 本教程所使用的数据是…
阅读更多...
喝酒聚会摇色子小程序源码系统+石头剪刀布+大转盘 带完整的部署教程

喝酒聚会摇色子小程序源码系统+石头剪刀布+大转盘 带完整的部署教程

来咯来咯&#xff0c;大家都知道摇色子是一种古老而受欢迎的饮酒游戏。在当代年轻人的聚会中&#xff0c;常常都使用摇骰子这种方法来喝酒的。今天罗峰要给大家介绍是一款非常受欢迎的小程序源码系统喝酒聚会摇色子小程序源码系统&#xff0c;还有石头剪刀布&#xff0c;大转盘…
阅读更多...
怎么让重要文件自动备份到OneDrive？

怎么让重要文件自动备份到OneDrive？

可以让文件自动备份到OneDrive吗&#xff1f; OneDrive是比较受欢迎的云存储之一&#xff0c;主要用于存储文件和个人数据&#xff0c;随时随地都能够在多个设备&#xff08;例如Android、台式机或笔记本电脑、平板电脑等&#xff09;之间同步和共享文件。 因此&…
阅读更多...
SSL证书在网购中的重要性

SSL证书在网购中的重要性

近年来&#xff0c;互联网的快速发展使得线上服务范围不断延伸&#xff0c;这其中网络购物更是在全球范围内都呈现上升趋势。然而病毒攻击&#xff0c;网络钓鱼攻击和恶意软件攻击无处不在&#xff0c;网上购物的安全性受到极大威胁。为了保护网络购物的安全&#xff0c;构建可…
阅读更多...
Vue项目运行时报错：‘vue-cli-service‘ 不是内部或外部命令，也不是可运行的程序 或批处理文件

Vue项目运行时报错：‘vue-cli-service‘ 不是内部或外部命令，也不是可运行的程序 或批处理文件

报错原因及解决 1.package.json 文件中未定义依赖项vue/cli-service&#xff0c;因此在 npm install 之后并没有安装vue/cli-service 依赖&#xff1b; 解决&#xff1a;项目目录下执行命令&#xff0c;npm i -D vue/cli-service。2.第1步排查后&#xff0c;还是报同样的错&a…
阅读更多...
【腾讯云HAI域探秘】利用HAI搭建AI绘画应用，随心所欲，畅享创作乐趣

【腾讯云HAI域探秘】利用HAI搭建AI绘画应用，随心所欲，畅享创作乐趣

【腾讯云HAI域探秘】利用HAI搭建AI绘画应用&#xff0c;随心所欲&#xff0c;畅享创作乐趣 1️⃣基于HAI部署的StableDiffusionWebUI快速进行AI绘画&#xff08;1&#xff09;创建并启动StableDiffusion应用服务器&#xff08;2&#xff09;使用StableDiffusionWebUI进行AI绘画…
阅读更多...
Dubbo中的负载均衡算法之一致性哈希算法

Dubbo中的负载均衡算法之一致性哈希算法

Dubbo中的负载均衡算法之一致性哈希算法 哈希算法 假设这样一个场景&#xff0c;我们申请一台服务器来缓存100万的数据&#xff0c;这个时候是单机环境&#xff0c;所有的请求都命中到这台服务器。后来业务量上涨&#xff0c;我们的数据也从100万上升到了300万&#xff0c;原…
阅读更多...
【蓝桥每日一题]-二分精确（保姆级教程 篇4） #kotori的设备 #银行贷款 #一元三次方程求解

【蓝桥每日一题]-二分精确（保姆级教程 篇4） #kotori的设备 #银行贷款 #一元三次方程求解

今天讲二分精确题型 目录 题目&#xff1a;kotori的设备 思路&#xff1a; 题目&#xff1a;银行贷款 思路&#xff1a; 题目&#xff1a;一元三次方程求解 思路&#xff1a; 题目&#xff1a;kotori的设备 思路&#xff1a; 求&#xff1a;设备最长使用时间 二分查找&#…
阅读更多...
数据结构（超详细讲解！！）第十九节 块链串及串的应用

数据结构（超详细讲解！！）第十九节 块链串及串的应用

1.定义 由于串也是一种线性表&#xff0c;因此也可以采用链式存储。由于串的特殊性&#xff08;每个元素只有一个字符&#xff09;&#xff0c;在具体实现时&#xff0c;每个结点既可以存放一个字符&#xff0c;也可以存放多个字符。每个结点称为块&#xff0c;整个链表称为块链…
阅读更多...
C# 发送邮件

C# 发送邮件

1.安装 NuGet 包 2.代码如下 SendMailUtil using MimeKit; using Srm.CMER.Application.Contracts.CmerInfo; namespace Srm.Mail { public class SendMailUtil { public async static Task<string> SendEmail(SendEmialDto sendEmialDto,List<strin…
阅读更多...
DC系列 DC:3

DC系列 DC:3

DC系列 DC:3 文章目录 DC系列 DC:3调试靶机信息收集IP端口信息收集 框架漏洞利用joomscan扫描工具利用msf工具利用(无法使用)kali漏洞库利用sqlmap利用 文件上传提权 调试靶机 点击虚拟机设置选择CD/DVD点击高级将IDE调成画面中这个选项 信息收集 IP端口信息收集 对自己网…
阅读更多...
DI93a HESG440355R3 通过其Achilles级认证提供网络安全

DI93a HESG440355R3 通过其Achilles级认证提供网络安全

DI93a HESG440355R3 通过其Achilles级认证提供网络安全 施耐德电气宣布推出Modicon M580以太网PAC (ePAC)自动化控制器&#xff0c;该控制器采用开放式以太网标准&#xff0c;通过其Achilles级认证提供网络安全。M580 ePAC使工厂操作员能够设计、实施和运行一个积极利用开放网…
阅读更多...
量子计算与量子密码（入门级-少图版）

量子计算与量子密码（入门级-少图版）

量子计算与量子密码 写在最前面一些可能带来的有趣的知识和潜在的收获 1、Introduction导言四个特性不确定性&#xff08;自由意志论&#xff09;Indeterminism不确定性Uncertainty叠加原理(线性)superposition (linearity)纠缠entanglement 虚数的常见基本运算欧拉公式&#x…
阅读更多...
nodejs国内镜像及切换版本工具nvm

nodejs国内镜像及切换版本工具nvm

淘宝 NPM 镜像站&#xff08;http://npm.taobao.org&#xff09;已更换域名&#xff0c;新域名&#xff1a; Web 站点&#xff1a;https://npmmirror.com Registry Endpoint&#xff1a;https://registry.npmmirror.com 详见&#xff1a; 【望周知】淘宝 NPM 镜像换域名了&…
阅读更多...
java基础--多线程学习

java基础--多线程学习

写在前面&#xff1a; 多线程在面试中问的很多&#xff0c;之前没有过系统的学习&#xff0c;现在来进行一个系统的总结学习 文章目录 基础java多线程实现无参无返回值线程快速创建start和run方法的探讨run方法线程状态 有返回值线程线程池执行小结关于抛出异常的扩展 线程方…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023