k8s二进制部署的搭建

1.1 常见k8s安装部署方式

●Minikube

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

●Kubeadm

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

●二进制安装部署

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

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

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

●二进制部署

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

●kubeadm部署

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

2 k8s二进制搭建

2.1 部署etcd

1）使用cfssl工具签发证书和私钥文件
2）解压etcd软件包，获取二进制文件 etcd etcdctl
3）使用etcd集群配置文件
4）启动etcd进程服务，将所有节点加入到etcd集群中

2.2 etc的操作

查看etcd集群健康状态

ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://IP1:2379,https://IP2:2379,https://IP3:2379" --cacert=CA证书 --cert=客户端证书 --key=客户端私钥 -wtable endpoint health

查看etcd集群状态信息

ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://IP1:2379,https://IP2:2379,https://IP3:2379" --cacert=CA证书 --cert=客户端证书 --key=客户端私钥 -wtable endpoint status

查看etcd集群成员列表

ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://IP1:2379,https://IP2:2379,https://IP3:2379" --cacert=CA证书 --cert=客户端证书 --key=客户端私钥 -wtable member list

向etcd插入键值

ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://IP1:2379" --cacert=CA证书 --cert=客户端证书 --key=客户端私钥 put <KEY> '<VALUE>'

查看键的值

ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://IP1:2379" --cacert=CA证书 --cert=客户端证书 --key=客户端私钥 get <KEY>

删除键

ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://IP1:2379" --cacert=CA证书 --cert=客户端证书 --key=客户端私钥 del <KEY>

备份etcd数据库

ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://IP1:2379" --cacert=CA证书 --cert=客户端证书 --key=客户端私钥 snapshot save 备份文件路径

恢复etcd数据库

ETCDCTL_API=3 /opt/etcd/bin/etcdctl --endpoints="https://IP1:2379" --cacert=CA证书 --cert=客户端证书 --key=客户端私钥 snapshot restore 备份文件路径

2.3 部署master组件

1）使用ccfssl工具签发证书和私钥文件
2）下载k8s软件包，获取二进制文件 kube-apiserver kube-controller-manager kube-scheduler
3 ）准备 apiserver 启动时要调用的 bootstrap-tolen 认证文件 （token.csv）
4）准备 kube-apiserver kube-controller-manager kube-scheduler 的进程服务启动参数配置文件
5）准备 kube-controller-manager kube-scheduler kubectl 的 kubeconfig 集群引导配置文件（用于连接和验证 kube-apiserver）
6）依次启动 kube-apiserver kube-controller-manager kube-scheduler 进程服务
7）执行 kubectl get cs 命令查看master组件的健康状态

2.4 部署node组件

1）获取二进制文件 kubelet kube-proxy
2）准备 kubelet kube-proxy 使用的 kubeconfig集群引导配置文件 bootstrap.kubeconfig(kubelet首次访问apiserver使用认证的文件) kube-proxy.kubeconfig
3）准备 kubelet kube-proxy 的进程服务启动参数配置文件
4）启动 kubelet 进程服务，向 apiserver 发起 CSR 请求自动签发证书，master 通过 CSR 请求后 kubelet 方可获取到证书
5）加载 ipvs 模块，启动 kube-proxy 进程服务
6）安装 cni 网络插件（flannel或者calico）
7）执行 kubectl get nodes 命令查看node节点状态

3 k8s二进制部署

3.1 操作系统初始化配置

关闭防火墙
systemctl stop firewalld
systemctl disable firewalld
iptables -F && iptables -t nat -F && iptables -t mangle -F && iptables -X

关闭selinux和swap
setenforce 0
sed -i 's/enforcing/disabled/' /etc/selinux/config
swapoff -a
sed -ri 's/.*swap.*/#&/' /etc/fstab

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

在master添加hosts
cat >> /etc/hosts << EOF
192.168.111.10 master01
192.168.111.22 node01
192.168.111.33 node02
EOF

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

所有节点时间同步
yum install ntpdate -y
ntpdate time.windows.com

3.2 部署 etcd 集群

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

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

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

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

准备签发证书环境

CFSSL 是 CloudFlare 公司开源的一款 PKI/TLS 工具。 CFSSL 包含一个命令行工具和一个用于签名、验证和捆绑 TLS 证书的 HTTP API 服务。使用Go语言编写。 CFSSL 使用配置文件生成证书，因此自签之前，需要生成它识别的 json 格式的配置文件，CFSSL 提供了方便的命令行生成配置文件。 CFSSL 用来为 etcd 提供 TLS 证书，它支持签三种类型的证书： 1、client 证书，服务端连接客户端时携带的证书，用于客户端验证服务端身份，如 kube-apiserver 访问 etcd； 2、server 证书，客户端连接服务端时携带的证书，用于服务端验证客户端身份，如 etcd 对外提供服务； 3、peer 证书，相互之间连接时使用的证书，如 etcd 节点之间进行验证和通信。 这里全部都使用同一套证书认证。

在 master01 节点上操作
准备cfssl证书生成工具
wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64 -O /usr/local/bin/cfssl
wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64 -O /usr/local/bin/cfssljson
wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64 -O /usr/local/bin/cfssl-certinfo
​
chmod +x /usr/local/bin/cfssl*
-----------------------------------------------------------------------------------------
cfssl：证书签发的工具命令
cfssljson：将 cfssl 生成的证书（json格式）变为文件承载式证书
cfssl-certinfo：验证证书的信息
cfssl-certinfo -cert <证书名称>         #查看证书的信息

生成Etcd证书
mkdir /opt/k8s
cd /opt/k8s/
上传 etcd-cert.sh 和 etcd.sh 到 /opt/k8s/ 目录中
chmod +x etcd-cert.sh etcd.sh

root@master01 k8s]# vim etcd-cert.sh 
​
#!/bin/bash
#配置证书生成策略，让 CA 软件知道颁发有什么功能的证书，生成用来签发其他组件证书的根证书
cat > ca-config.json <<EOF
{"signing": {"default": {"expiry": "87600h"},"profiles": {"www": {"expiry": "87600h","key encipherment","server auth","client auth"]}}}
}
EOF
​
#ca-config.json：可以定义多个 profiles，分别指定不同的过期时间、使用场景等参数；
#后续在签名证书时会使用某个 profile；此实例只有一个 www 模板。
#expiry：指定了证书的有效期，87600h 为10年，如果用默认值一年的话，证书到期后集群会立即宕掉
#signing：表示该证书可用于签名其它证书；生成的 ca.pem 证书中 CA=TRUE；
#key encipherment：表示使用非对称密钥加密，如 RSA 加密；
#server auth：表示client可以用该 CA 对 server 提供的证书进行验证；
#client auth：表示server可以用该 CA 对 client 提供的证书进行验证；
#注意标点符号，最后一个字段一般是没有逗号的。
​
​
#-----------------------
#生成CA证书和私钥（根证书和私钥）
cat > ca-csr.json <<EOF
{"CN": "etcd","key": {"algo": "rsa","size": 2048},"names": [}]
}
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：根证书签发请求文件
​
#cfssljson 将 cfssl 生成的证书（json格式）变为文件承载式证书，-bare 用于命名生成的证书文件。
​
​
cat > server-csr.json <<EOF"hosts": ["192.168.80.10","192.168.80.11","192.168.80.12"],"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

vim etcd.sh 
​
#!/bin/bash
#example: ./etcd.sh etcd01 192.168.80.10 etcd02=https://192.168.80.11:2380,etcd03=https://192.168.80.12:2380
ETCD_NAME=$1
ETCD_IP=$2
ETCD_CLUSTER=$3
​
WORK_DIR=/opt/etcd
​
cat > $WORK_DIR/cfg/etcd  <<EOF
#[Member]
ETCD_NAME="${ETCD_NAME}"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://${ETCD_IP}:2380"
ETCD_LISTEN_CLIENT_URLS="https://${ETCD_IP}:2379"
​
#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://${ETCD_IP}:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://${ETCD_IP}:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://${ETCD_IP}:2380,${ETCD_CLUSTER}"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
EOF
​
#Member:成员配置
#ETCD_NAME：节点名称，集群中唯一。成员名字，集群中必须具备唯一性，如etcd01
#ETCD_LISTEN_PEER_URLS：集群通信监听地址。用于监听其他member发送信息的地址。ip为全0代表监听本机所有接口
#ETCD_LISTEN_CLIENT_URLS：客户端访问监听地址。用于监听etcd客户发送信息的地址。ip为全0代表监听本机所有接口
​
#Clustering：集群配置
#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

创建用于生成CA证书、etcd 服务器证书以及私钥的目录
mkdir /opt/k8s/etcd-cert
mv etcd-cert.sh etcd-cert/
cd /opt/k8s/etcd-cert/
./etcd-cert.sh          #生成CA证书、etcd 服务器证书以及私钥
​
ls
ca-config.json  ca-csr.json  ca.pem        server.csr       server-key.pem
ca.csr          ca-key.pem   etcd-cert.sh  server-csr.json  server.pem

上传 etcd-v3.4.9-linux-amd64.tar.gz 到 /opt/k8s 目录中，启动etcd服务
cd /opt/k8s/
tar zxvf etcd-v3.4.9-linux-amd64.tar.gz
ls etcd-v3.4.9-linux-amd64
Documentation  etcd  etcdctl  README-etcdctl.md  README.md  READMEv2-etcdctl.md
------------------------------------------------------------------------------------------
etcd就是etcd 服务的启动命令，后面可跟各种启动参数
etcdctl主要为etcd 服务提供了命令行操作

创建用于存放 etcd 配置文件，命令文件，证书的目录
mkdir -p /opt/etcd/{cfg,bin,ssl}
​
cd /opt/k8s/etcd-v3.4.9-linux-amd64/
mv etcd etcdctl /opt/etcd/bin/
cp /opt/k8s/etcd-cert/*.pem /opt/etcd/ssl/
​
cd /opt/k8s/
./etcd.sh etcd01 192.168.111.10 etcd02=https://192.168.111.11:2380,etcd03=https://192.168.111.22:2380
#进入卡住状态等待其他节点加入，这里需要三台etcd服务同时启动，如果只启动其中一台后，服务会卡在那里，直到集群中所有etcd节点都已启动，可忽略这个情况
可另外打开一个窗口查看etcd进程是否正常
ps -ef | grep etcd

把etcd相关证书文件、命令文件和服务管理文件全部拷贝到另外两个etcd集群节点
scp -r /opt/etcd/ root@192.168.111.11:/opt/
scp -r /opt/etcd/ root@192.168.111.22:/opt/
scp /usr/lib/systemd/system/etcd.service root@192.168.111.11:/usr/lib/systemd/system/
scp /usr/lib/systemd/system/etcd.service root@192.168.111.22:/usr/lib/systemd/system/

在 node01、node2节点上操作并启动服务
vim /opt/etcd/cfg/etcd
#[Member]
ETCD_NAME="etcd02"                                          #修改
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.80.11:2380"          #修改
ETCD_LISTEN_CLIENT_URLS="https://192.168.80.11:2379"        #修改
​
#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.80.11:2380"       #修改
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.80.11:2379"             #修改
ETCD_INITIAL_CLUSTER="etcd01=https://192.168.80.10:2380,etcd02=https://192.168.80.11:2380,etcd03=https://192.168.80.12:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
启动etcd服务
systemctl start etcd
systemctl enable etcd
systemctl status etcd

检查etcd群集状态，查看etcd集群成员列表
检查etcd群集状态
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem --endpoints="https://192.168.111.10:2379,https://192.168.111.11:2379,https://192.168.111.22:2379" endpoint health --write-out=table
​
------------------------------------------------------------------------------------------
--cert-file：识别HTTPS端使用SSL证书文件
--key-file：使用此SSL密钥文件标识HTTPS客户端
--ca-file：使用此CA证书验证启用https的服务器的证书
--endpoints：集群中以逗号分隔的机器地址列表
cluster-health：检查etcd集群的运行状况
------------------------------------------------------------------------------------------
​
查看etcd集群成员列表
ETCDCTL_API=3 /opt/etcd/bin/etcdctl --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem --endpoints="https://192.168.111.10:2379,https://192.168.111.11:2379,https://192.168.111.22:2379" --write-out=table member list

部署 docker引擎
所有 node 节点部署docker引擎
yum install -y yum-utils device-mapper-persistent-data lvm2 
yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo 
yum install -y docker-ce docker-ce-cli containerd.io
​
systemctl start docker.service
systemctl enable docker.service

3.3 部署 Master 组件

在 master01 节点上操作
上传 master.zip 和 k8s-cert.sh 到 /opt/k8s 目录中，解压 master.zip 压缩包
cd /opt/k8s/
unzip master.zip
chmod +x *.sh
​
#创建kubernetes工作目录
mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs}

创建用于生成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
admin-key.pem  apiserver-key.pem  ca-key.pem  kube-proxy-key.pem  
admin.pem      apiserver.pem      ca.pem      kube-proxy.pem

配置文件中出现#号可能会导致文件出错
#!/bin/bash
#配置证书生成策略，让 CA 软件知道颁发有什么功能的证书，生成用来签发其他组件证书的根证书
cat > ca-config.json <<EOF
{"signing": {"default": {"expiry": "87600h"},"profiles": {
#!/bin/bash
#配置证书生成策略，让 CA 软件知道颁发有什么功能的证书，生成用来签发其他组件证书的根证书
cat > ca-config.json <<EOF
{"signing": {"default": {"expiry": "87600h"},"profiles": {"kubernetes": {"expiry": "87600h","usages": ["signing","key encipherment","server auth","client auth"]}}}
}
EOF
​
#生成CA证书和私钥（根证书和私钥）
cat > ca-csr.json <<EOF
{"CN": "kubernetes","key": {"algo": "rsa","size": 2048},"names": [{"C": "CN","L": "Beijing","ST": "Beijing","O": "k8s","OU": "System"}]
}
EOF
​
cfssl gencert -initca ca-csr.json | cfssljson -bare ca -
​
​
#-----------------------
#生成 apiserver 的证书和私钥（apiserver和其它k8s组件通信使用）
#hosts中将所有可能作为 apiserver 的 ip 添加进去，后面 keepalived 使用的 VIP 也要加入
cat > apiserver-csr.json <<EOF
{"CN": "kubernetes","hosts": ["10.0.0.1","127.0.0.1","192.168.111.10",         #master01"192.168.111.33",         #master02"192.168.111.100",                #vip，后面 keepalived 使用"kubernetes","kubernetes.default","kubernetes.default.svc","kubernetes.default.svc.cluster","kubernetes.default.svc.cluster.local"],"key": {"algo": "rsa","size": 2048},"names": [{"C": "CN","L": "BeiJing","ST": "BeiJing","O": "k8s","OU": "System"}]
}
EOF
​
#-----------------------
#生成 kubectl 连接集群的证书和私钥（kubectl 和 apiserver 通信使用）
cat > admin-csr.json <<EOF
{"CN": "admin","hosts": [],"key": {"algo": "rsa","size": 2048},"names": [{"C": "CN","L": "BeiJing","ST": "BeiJing","O": "system:masters","OU": "System"}]
}
EOF
​
#!/bin/bash
#配置证书生成策略，让 CA 软件知道颁发有什么功能的证书，生成用来签发其他组件证书的根证书
cat > ca-config.json <<EOF
{"signing": {"default": {"expiry": "87600h"},"profiles": {"kubernetes": {"expiry": "87600h","usages": ["signing","key encipherment","server auth","client auth"]}}}
}
EOF
​
#生成CA证书和私钥（根证书和私钥）
cat > ca-csr.json <<EOF
{"CN": "kubernetes","key": {"algo": "rsa","size": 2048},"names": [{"C": "CN","L": "Beijing","ST": "Beijing","O": "k8s","OU": "System"}]
}
EOF
​
cfssl gencert -initca ca-csr.json | cfssljson -bare ca -
​
​
#-----------------------
#生成 apiserver 的证书和私钥（apiserver和其它k8s组件通信使用）
#hosts中将所有可能作为 apiserver 的 ip 添加进去，后面 keepalived 使用的 VIP 也要加入
cat > apiserver-csr.json <<EOF
{"CN": "kubernetes","hosts": ["10.0.0.1","127.0.0.1","192.168.111.10",         #master01"192.168.111.33",         #master02"192.168.111.100",                #vip，后面 keepalived 使用"kubernetes","kubernetes.default","kubernetes.default.svc","kubernetes.default.svc.cluster","kubernetes.default.svc.cluster.local"],"key": {"algo": "rsa","size": 2048},"names": [{"C": "CN","L": "BeiJing","ST": "BeiJing","O": "k8s","OU": "System"}]
}
EOF
​
#-----------------------
#生成 kubectl 连接集群的证书和私钥（kubectl 和 apiserver 通信使用）
cat > admin-csr.json <<EOF
{"CN": "admin","hosts": [],"key": {"algo": "rsa","size": 2048},"names": [{"C": "CN","L": "BeiJing","ST": "BeiJing","O": "system:masters","OU": "System"}]
}
EOF
​
#-----------------------
#生成 kube-proxy 的证书和私钥（kube-proxy 和 apiserver 通信使用）
cat > kube-proxy-csr.json <<EOF
{"CN": "system:kube-proxy","hosts": [],"key": {"algo": "rsa","size": 2048},"names": [{"C": "CN","L": "BeiJing","ST": "BeiJing","O": "k8s","OU": "System"}]
}
EOF
​
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-proxy-csr.json | cfssljson -bare kube-proxy

复制CA证书、apiserver相关证书和私钥到 kubernetes工作目录的 ssl 子目录中
cp ca*pem apiserver*pem /opt/kubernetes/ssl/
上传 kubernetes-server-linux-amd64.tar.gz 到 /opt/k8s/ 目录中，解压 kubernetes 压缩包
cd /opt/k8s/
tar zxvf kubernetes-server-linux-amd64.tar.gz

复制master组件的关键命令文件到 kubernetes工作目录的 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/

创建 bootstrap token 认证文件，apiserver 启动时会调用，然后就相当于在集群内创建了一个这个用户，接下来就可以用 RBAC 给他授权
cd /opt/k8s/
vim token.sh
#!/bin/bash
#获取随机数前16个字节内容，以十六进制格式输出，并删除其中空格
BOOTSTRAP_TOKEN=$(head -c 16 /dev/urandom | od -An -t x | tr -d ' ')
#生成 token.csv 文件，按照 Token序列号,用户名,UID,用户组 的格式生成
cat > /opt/kubernetes/cfg/token.csv <<EOF
${BOOTSTRAP_TOKEN},kubelet-bootstrap,10001,"system:kubelet-bootstrap"
EOF
​
chmod +x token.sh
./token.sh
​
cat /opt/kubernetes/cfg/token.csv

二进制文件、token、证书都准备好后，开启 apiserver 服务
cd /opt/k8s/
./apiserver.sh 192.168.111.10 https://192.168.111.10:2379,https://192.168.111.11:2379,https://192.168.111.22:2379
​
#检查进程是否启动成功
ps aux | grep kube-apiserver
​
netstat -natp | grep 6443   #安全端口6443用于接收HTTPS请求，用于基于Token文件或客户端证书等认证

启动 scheduler 服务
cd /opt/k8s/
./scheduler.sh
ps aux | grep kube-scheduler
​
vim /scheduler.sh
#!/bin/bash
##创建 kube-scheduler 启动参数配置文件
MASTER_ADDRESS=$1
​
cat >/opt/kubernetes/cfg/kube-scheduler <<EOF
KUBE_SCHEDULER_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--leader-elect=true \\
--kubeconfig=/opt/kubernetes/cfg/kube-scheduler.kubeconfig \\
--bind-address=127.0.0.1"
EOF
​
#-–kubeconfig：连接 apiserver 用的配置文件，用于识别 k8s 集群
#--leader-elect=true：当该组件启动多个时，自动启动 leader 选举
​
​
##生成kube-scheduler证书
#创建证书请求文件
cat > kube-scheduler-csr.json << EOF
{"CN": "system:kube-scheduler","hosts": [],"key": {"algo": "rsa","size": 2048},"names": [{"C": "CN","L": "BeiJing","ST": "BeiJing","O": "system:masters","OU": "System"}]
}
EOF
​
#生成证书和私钥
​
#生成kubeconfig配置文件
KUBE_CONFIG="/opt/kubernetes/cfg/kube-scheduler.kubeconfig"
KUBE_APISERVER="https://192.168.80.10:6443"
​
#配置kubernetes集群参数
kubectl config set-cluster kubernetes \--certificate-authority=/opt/kubernetes/ssl/ca.pem \--embed-certs=true \--server=${KUBE_APISERVER} \--kubeconfig=${KUBE_CONFIG}
#配置客户端认证参数
kubectl config set-credentials kube-scheduler \--client-certificate=./kube-scheduler.pem \--client-key=./kube-scheduler-key.pem \--embed-certs=true \--kubeconfig=${KUBE_CONFIG}
#设置上下文参数 
kubectl config set-context default \--cluster=kubernetes \--user=kube-scheduler \--kubeconfig=${KUBE_CONFIG}
#设置默认上下文
kubectl config use-context default --kubeconfig=${KUBE_CONFIG}
​
​
##创建 kube-scheduler.service 服务管理文件
cat >/usr/lib/systemd/system/kube-scheduler.service <<EOF
[Unit]
Description=Kubernetes Scheduler
Documentation=https://github.com/kubernetes/kubernetes
​
[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-scheduler
ExecStart=/opt/kubernetes/bin/kube-scheduler \$KUBE_SCHEDULER_OPTS
Restart=on-failure
​
[Install]
WantedBy=multi-user.target
EOF
​
systemctl daemon-reload
systemctl enable kube-scheduler
systemctl restart kube-scheduler

启动 controller-manager 服务
./controller-manager.sh
ps aux | grep kube-controller-manager
​
vim controller-manager.sh 
​
#!/bin/bash
--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 集群
​
​
##生成kube-controller-manager证书
#创建证书请求文件
cat > kube-controller-manager-csr.json << EOF
{"CN": "system:kube-controller-manager","hosts": [],"key": {"algo": "rsa","size": 2048},"names": [{"C": "CN","L": "BeiJing", "ST": "BeiJing","O": "system:masters","OU": "System"}]
}
EOF
​
#生成证书和私钥
​
#生成kubeconfig配置文件
KUBE_CONFIG="/opt/kubernetes/cfg/kube-controller-manager.kubeconfig"
KUBE_APISERVER="https://192.168.80.10:6443"
​
#配置kubernetes集群参数
kubectl config set-cluster kubernetes \--certificate-authority=/opt/kubernetes/ssl/ca.pem \--embed-certs=true \--server=${KUBE_APISERVER} \--kubeconfig=${KUBE_CONFIG}
#配置客户端认证参数
kubectl config set-credentials kube-controller-manager \--client-certificate=./kube-controller-manager.pem \--client-key=./kube-controller-manager-key.pem \--embed-certs=true \--kubeconfig=${KUBE_CONFIG}
#设置上下文参数
kubectl config set-context default \--cluster=kubernetes \--user=kube-controller-manager \--kubeconfig=${KUBE_CONFIG}
#设置默认上下文
kubectl config use-context default --kubeconfig=${KUBE_CONFIG}
​
​
##创建 kube-controller-manager.service 服务管理文件
cat >/usr/lib/systemd/system/kube-controller-manager.service <<EOF
[Unit]
Description=Kubernetes Controller Manager
Documentation=https://github.com/kubernetes/kubernetes
​
[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-controller-manager
ExecStart=/opt/kubernetes/bin/kube-controller-manager \$KUBE_CONTROLLER_MANAGER_OPTS
Restart=on-failure
​
[Install]
WantedBy=multi-user.target
EOF
​
systemctl daemon-reload
systemctl enable kube-controller-manager
systemctl restart kube-controller-manager

生成kubectl连接集群的kubeconfig文件
./admin.sh
vim admin/sh
#!/bin/bash
mkdir /root/.kube
KUBE_CONFIG="/root/.kube/config"
KUBE_APISERVER="https://192.168.111.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 的环境项来作为配置。 如果配置了多个环境项，可以通过切换不同的环境项名字来访问到不同>的集群环境。
#########################################################

绑定默认cluster-admin管理员集群角色，授权kubectl访问集群
kubectl create clusterrolebinding cluster-system-anonymous --clusterrole=cluster-admin --user=system:anonymous
​
通过kubectl工具查看当前集群组件状态
kubectl get cs
NAME                 STATUS    MESSAGE             ERROR
controller-manager   Healthy   ok                  
scheduler            Healthy   ok                  
etcd-2               Healthy   {"health":"true"}   
etcd-1               Healthy   {"health":"true"}   
etcd-0               Healthy   {"health":"true"}  
​
查看版本信息
kubectl version

3.4 部署 Worker Node 组件

在所有 node 节点上操作
创建kubernetes工作目录
mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs}
​
上传 node.zip 到 /opt 目录中，解压 node.zip 压缩包，获得kubelet.sh、proxy.sh
cd /opt/
unzip node.zip
chmod +x kubelet.sh proxy.sh

在 master01 节点上操作
把 kubelet、kube-proxy 拷贝到 node 节点
cd /opt/k8s/kubernetes/server/bin
scp kubelet kube-proxy root@192.168.111.11:/opt/kubernetes/bin/
scp kubelet kube-proxy root@192.168.111.22:/opt/kubernetes/bin/

上传kubeconfig.sh文件到/opt/k8s/kubeconfig目录中，生成kubelet初次加入集群引导kubeconfig文件和kube-proxy.kubeconfig文件

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

mkdir /opt/k8s/kubeconfig
​
cd /opt/k8s/kubeconfig
chmod +x kubeconfig.sh
./kubeconfig.sh 192.168.111.10 /opt/k8s/k8s-cert/

#!/bin/bash
#example: kubeconfig 192.168.80.10 /opt/k8s/k8s-cert/
#创建bootstrap.kubeconfig文件
​
BOOTSTRAP_TOKEN=$(awk -F ',' '{print $1}' /opt/kubernetes/cfg/token.csv)
APISERVER=$1
SSL_DIR=$2
​
export KUBE_APISERVER="https://$APISERVER:6443"
​
# 设置集群参数
kubectl config set-cluster kubernetes \--certificate-authority=$SSL_DIR/ca.pem \--embed-certs=true \--server=${KUBE_APISERVER} \--kubeconfig=bootstrap.kubeconfig
#--embed-certs=true：表示将ca.pem证书写入到生成的bootstrap.kubeconfig文件中
​
# 设置客户端认证参数，kubelet 使用 bootstrap token 认证
kubectl config set-credentials kubelet-bootstrap \--token=${BOOTSTRAP_TOKEN} \--kubeconfig=bootstrap.kubeconfig
​
# 设置上下文参数
kubectl config set-context default \--cluster=kubernetes \--user=kubelet-bootstrap \--kubeconfig=bootstrap.kubeconfig
​
# 使用上下文参数生成 bootstrap.kubeconfig 文件
kubectl config use-context default --kubeconfig=bootstrap.kubeconfig
​
#----------------------
​
#创建kube-proxy.kubeconfig文件
# 设置集群参数
kubectl config set-cluster kubernetes \--certificate-authority=$SSL_DIR/ca.pem \--embed-certs=true \--server=${KUBE_APISERVER} \--kubeconfig=kube-proxy.kubeconfig
​
# 设置客户端认证参数，kube-proxy 使用 TLS 证书认证
kubectl config set-credentials kube-proxy \--client-certificate=$SSL_DIR/kube-proxy.pem \--client-key=$SSL_DIR/kube-proxy-key.pem \--embed-certs=true \--kubeconfig=kube-proxy.kubeconfig
​
# 设置上下文参数
kubectl config set-context default \--cluster=kubernetes \--user=kube-proxy \--kubeconfig=kube-proxy.kubeconfig
​
# 使用上下文参数生成 kube-proxy.kubeconfig 文件
kubectl config use-context default --kubeconfig=kube-proxy.kubeconfig

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

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

kubelet 采用 TLS Bootstrapping 机制，自动完成到 kube-apiserver 的注册，在 node 节点量较大或者后期自动扩容时非常有用。 Master apiserver 启用 TLS 认证后，node 节点 kubelet 组件想要加入集群，必须使用CA签发的有效证书才能与 apiserver 通信，当 node 节点很多时，签署证书是一件很繁琐的事情。因此 Kubernetes 引入了 TLS bootstraping 机制来自动颁发客户端证书，kubelet 会以一个低权限用户自动向 apiserver 申请证书，kubelet 的证书由 apiserver 动态签署。

kubelet 首次启动通过加载 bootstrap.kubeconfig 中的用户 Token 和 apiserver CA 证书发起首次 CSR 请求，这个 Token 被预先内置在 apiserver 节点的 token.csv 中，其身份为 kubelet-bootstrap 用户和 system:kubelet-bootstrap 用户组；想要首次 CSR 请求能成功（即不会被 apiserver 401 拒绝），则需要先创建一个 ClusterRoleBinding，将 kubelet-bootstrap 用户和 system:node-bootstrapper 内置 ClusterRole 绑定（通过 kubectl get clusterroles 可查询），使其能够发起 CSR 认证请求。

TLS bootstrapping 时的证书实际是由 kube-controller-manager 组件来签署的，也就是说证书有效期是 kube-controller-manager 组件控制的；kube-controller-manager 组件提供了一个 --experimental-cluster-signing-duration 参数来设置签署的证书有效时间；默认为 8760h0m0s，将其改为 87600h0m0s，即 10 年后再进行 TLS bootstrapping 签署证书即可。

也就是说 kubelet 首次访问 API Server 时，是使用 token 做认证，通过后，Controller Manager 会为 kubelet 生成一个证书，以后的访问都是用证书做认证了。

在 node01 node2节点上操作
​
cat > /etc/docker/daemon.json <<EOF
{"exec-opts": ["native.cgroupdriver=systemd"]
}
EOF
systemctl restart docker
systemctl restart kubelet
cd /opt/
./kubelet.sh 192.168.111.11
ps aux | grep kubelet

#!/bin/bash
​
NODE_ADDRESS=$1
#创建 kubelet 启动参数配置文件
cat >/opt/kubernetes/cfg/kubelet <<EOF
KUBELET_OPTS="--logtostderr=false \\
--hostname-override=node02 \\
--network-plugin=cni \\
--kubeconfig=/opt/kubernetes/cfg/kubelet.kubeconfig \\
--bootstrap-kubeconfig=/opt/kubernetes/cfg/bootstrap.kubeconfig \\
--config=/opt/kubernetes/cfg/kubelet.config \\
--cert-dir=/opt/kubernetes/ssl \\
--pod-infra-container-image=registry.cn-hangzhou.aliyuncs.com/google_containers/pause-amd64:3.2"
EOF
​
#--network-plugin：启用CNI
#--bootstrap-kubeconfig：指定连接 apiserver 的 bootstrap.kubeconfig 文件
#--config：指定kubelet配置文件的路径，启动kubelet时将从此文件加载其配置
#--cert-dir：指定master颁发的kubelet证书生成目录
​
​
#----------------------
cat >/opt/kubernetes/cfg/kubelet.config <<EOF
kind: KubeletConfiguration
apiVersion: kubelet.config.k8s.io/v1beta1
address: ${NODE_ADDRESS}
port: 10250
readOnlyPort: 10255
cgroupDriver: systemd
clusterDNS:
- ${DNS_SERVER_IP} 
clusterDomain: cluster.local
failSwapOn: false
authentication:anonymous:enabled: true
EOF
​
#PS：当命令行参数与此配置文件（kubelet.config）有相同的值时，就会覆盖配置文件中的该值。
​
​
#----------------------
#创建 kubelet.service 服务管理文件
cat >/usr/lib/systemd/system/kubelet.service <<EOF
[Unit]
Description=Kubernetes Kubelet
After=docker.service
Requires=docker.service
​
[Service]
EnvironmentFile=/opt/kubernetes/cfg/kubelet
ExecStart=/opt/kubernetes/bin/kubelet \$KUBELET_OPTS
Restart=on-failure
KillMode=process
​
[Install]
WantedBy=multi-user.target
EOF
​
systemctl daemon-reload
systemctl enable kubelet
systemctl restart kubelet

在 master01 节点上操作，通过 CSR 请求
检查到 node01 /node02节点的 kubelet 发起的 CSR 请求，Pending 表示等待集群给该节点签发证书
kubectl get csr
NAME                                                   AGE  SIGNERNAME                                    REQUESTOR           CONDITION
node-csr-duiobEzQ0R93HsULoS9NT9JaQylMmid_nBF3Ei3NtFE   12s  kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Pending
通过 CSR 请求
kubectl certificate approve node-csr-duiobEzQ0R93HsULoS9NT9JaQylMmid_nBF3Ei3NtFE
​
Approved,Issued 表示已授权 CSR 请求并签发证书
kubectl get csr
NAME                                                   AGE  SIGNERNAME                                    REQUESTOR           CONDITION
node-csr-duiobEzQ0R93HsULoS9NT9JaQylMmid_nBF3Ei3NtFE   2m5s kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap   Approved,Issued

查看节点，由于网络插件还没有部署，节点会没有准备就绪 NotReady
kubectl get node
NAME            STATUS     ROLES    AGE    VERSION
192.168.80.11   NotReady   <none>   108s   v1.20.11

在 node01 、node02节点上操作
#加载 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
​
#启动proxy服务
cd /opt/
./proxy.sh 192.168.80.11
ps aux | grep kube-proxy

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

如若内容造成侵权/违法违规/事实不符，请联系瞎胡闹网进行投诉反馈，一经查实，立即删除！

相关文章

Java根据excel模版导出Excel（easyexcel、poi）——含项目测试例子拿来即用

Java根据excel模版导出Excel（easyexcel、poi）——含项目测试例子拿来即用

Java根据excel模版导出Excel&#xff08;easyexcel、poi&#xff09;——含项目测试例子拿来即用 1. 前言1.1 关于Excel的一般导出2.2 关于easyexcel的根据模版导出 2. 先看效果2.1 模版2.2 效果 3. 代码实现&#xff08;核心代码&#xff09;3.1 项目代码结构3.2 静态填充例子…
阅读更多...
数字电路 第四章—第一节（触发器——概述）

数字电路 第四章—第一节（触发器——概述）

一、对触发器的基本要求 1、触发器的概念 在数字电路中&#xff0c;基本的工作信号是二进制数字信号和两状态逻辑信号&#xff0c;而触发器就是存放这些信号的单元电路。 2、对触发器的基本要求 &#xff08;1&#xff09;具有两个稳定状态——0状态和1状态&#xff0c;以正…
阅读更多...
负载均衡.

负载均衡.

简介: 将请求/数据【均匀】分摊到多个操作单元上执行&#xff0c;负载均衡的关键在于【均匀】。 负载均衡的分类: 网络通信分类 四层负载均衡:基于 IP 地址和端口进行请求的转发。七层负载均衡:根据访问用户的 HTTP 请求头、URL 信息将请求转发到特定的主机。 载体维度分类 硬…
阅读更多...
物资管理新篇章：Java+SpringBoot实战

物资管理新篇章：Java+SpringBoot实战

✍✍计算机编程指导师 ⭐⭐个人介绍&#xff1a;自己非常喜欢研究技术问题&#xff01;专业做Java、Python、微信小程序、安卓、大数据、爬虫、Golang、大屏等实战项目。 ⛽⛽实战项目&#xff1a;有源码或者技术上的问题欢迎在评论区一起讨论交流&#xff01; ⚡⚡ Java实战 |…
阅读更多...
List去重有几种方式

List去重有几种方式

目录 1、for循环添加去重 2、for 双循环去重 3、for 双循环重复坐标去重 4、Set去重 5、stream流去重 1、for循环添加去重 List<String> oldList new ArrayList<>();oldList.add("张三");oldList.add("张三");oldList.add("李四&q…
阅读更多...
数字电路 第三章—第七节（用中规模集成电路实现组合逻辑函数）

数字电路 第三章—第七节（用中规模集成电路实现组合逻辑函数）

一、用数据选择器实现组合逻辑函数 1、基本原理和步骤 &#xff08;1&#xff09;原理&#xff1a;选择器的输出为标准与或式&#xff0c;含地址变量的全部最小项&#xff08;如下图所示的红线标注部分&#xff09;&#xff0c;而任何组合逻辑函数都可以表示成为最小项之和的…
阅读更多...
项目管理工具git

项目管理工具git

git 1. git介绍1.1. 版本控制系统 2. 创建本地版本库2.1 概念2.2 操作步骤 3. 修改文件4. 练习: 添加一个本地项目到仓库5. 添加远程仓库5.1 添加远程仓库5.2 本地仓库同步到远程仓库5.3 克隆远程仓库到本地5.4 SSH设置 6. 分支管理6.1 创建分支6.2 切换分支6.3 合并分支6.4 解…
阅读更多...
实践航拍小目标检测，基于轻量级YOLOv8n开发构建无人机航拍场景下的小目标检测识别分析系统

实践航拍小目标检测，基于轻量级YOLOv8n开发构建无人机航拍场景下的小目标检测识别分析系统

关于无人机相关的场景在我们之前的博文也有一些比较早期的实践&#xff0c;感兴趣的话可以自行移步阅读即可&#xff1a; 《deepLabV3Plus实现无人机航拍目标分割识别系统》 《基于目标检测的无人机航拍场景下小目标检测实践》 《助力环保河道水质监测&#xff0c;基于yolov…
阅读更多...
QT之项目经验（windows下的sqlite,c++开发）

QT之项目经验（windows下的sqlite,c++开发）

目录 一、需要时间去磨练gui的调整和优化 1. 借鉴网上开源项目学习 2. gui的布局及调整是磨人的一件事情 3. gui的布局也是可以用组件复刻的 4. 耗时的设备树 二、多线程异步弹窗 三、定时任务动态变更设定 1.确定按钮触发 2.此处监听定时任务时间的改变 3.此处对改变做出具…
阅读更多...
[算法沉淀记录]排序算法 —— 快速排序

[算法沉淀记录]排序算法 —— 快速排序

排序算法 —— 快速排序介绍 基本概念 快速排序&#xff08;Quicksort&#xff09;是一种排序算法&#xff0c;最早由东尼霍尔提出。在平均状况下&#xff0c;排序 n 个项目要 Ο(n log n) 次比较。在最坏状况下则需要 Ο(n2) 次比较&#xff0c;但这种状况并不常见。事实上&…
阅读更多...
linux centos7.9改dns和ip

linux centos7.9改dns和ip

vi /etc/sysconfig/network-scripts/ifcfg-ens32 &#xff1a;wq后 重启网络服务 systemctl restart network —————————————————————————— 篇外话题 软件下载 xshell可以从腾讯软件中心下载
阅读更多...
Open CASCADE学习|GC_MakeArcOfCircle构造圆弧

Open CASCADE学习|GC_MakeArcOfCircle构造圆弧

目录 1、通过圆及圆的两个参数创建圆弧&#xff0c;参数为弧度角 2、通过圆及圆上的一点、圆的1个参数创建圆弧&#xff0c;参数为弧度角&#xff0c;Sense决定方向 3、通过圆及圆上的两个点创建圆弧&#xff0c;Sense决定方向 4、通过三点创建圆弧&#xff0c;最后一点应安…
阅读更多...
react useRef用法

react useRef用法

1&#xff0c;保存变量永远不丢失 import React, { useState,useRef } from react export default function App() { const [count,setcount] useState(0) var mycount useRef(0)//保存变量永远不丢失--useRef用的是闭包原理 return( <div> <button onClick{()>…
阅读更多...
SpringBoot使用classfinal-maven-plugin插件加密Jar包

SpringBoot使用classfinal-maven-plugin插件加密Jar包

jar包加密 1、在启动类的pom.xml中加入classfinal-maven-plugin插件 <build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin><plugin><…
阅读更多...
Qt QWidget 简约美观的加载动画 第五季 - 小方块风格

Qt QWidget 简约美观的加载动画 第五季 - 小方块风格

给大家分享两个小方块风格的加载动画 &#x1f60a; 第五季来啦 &#x1f60a; 效果如下: 一个三个文件,可以直接编译运行 //main.cpp #include "LoadingAnimWidget.h" #include <QApplication> #include <QGridLayout> int main(int argc, char *arg…
阅读更多...
Python之词频统计（自然语言处理）

Python之词频统计（自然语言处理）

背景 词频统计是指对一段文本中每个单词出现的次数进行计数分析。这种分析有助于了解文本的重点词汇、主题或作者的写作风格。如果你有一个特定的文本或想要分析某些内容的词频&#xff0c;你可以提供文本&#xff0c;我可以为你进行简单的词频统计。 例如&#xff0c;如果你…
阅读更多...
jeesite用字典项配置二级下拉选

jeesite用字典项配置二级下拉选

1、配置字典项 2、html代码&#xff1a;修改下拉选项框 <div class"col-xs-6"><div class"form-group"><label class"control-label col-sm-4" title""><span class"required">*</span> ${…
阅读更多...
备考北京高考数学：历年选择题真题练一练和解析（2014-2023）

备考北京高考数学：历年选择题真题练一练和解析（2014-2023）

还有三个多月的时间就要高考了&#xff0c;我们今天继续看北京市高考数学真题和解析。今天看5道选择题。独家制作的在线练习集&#xff0c;可以便捷地反复刷这些真题&#xff0c;吃透真题&#xff08;背后的知识点和解题技巧&#xff09;&#xff0c;让高考数学再上一个台阶。 …
阅读更多...
OpenAI Sora 关键技术详解：揭秘时空碎片 (Spacetime Patches) 技术

OpenAI Sora 关键技术详解：揭秘时空碎片 (Spacetime Patches) 技术

编者按&#xff1a;近日&#xff0c;OpenAI发布其首个视频生成模型“Sora”&#xff0c;该模型生成的视频内容可以呈现出多个角色、特定动作以及复杂场景&#xff0c;为构建能够理解和模拟现实世界的人工智能模型奠定了基础。 本文解析的重点即是 Sora 背后的核心技术 Spacetim…
阅读更多...
单片机51 定时器

单片机51 定时器

一、基本概念 1.1简介 单片机的定时器是一种内部功能模块&#xff0c;用于产生计时、计数、延时等功能。定时器通常由一个或多个计数器和相关的控制逻辑组成。单片机的定时器可以运行在不同的工作模式下&#xff0c;以适应不同的计时和计数需求。 C51中的定时器和计数器是同…
阅读更多...
最新文章

Copyright @ 2022~2023