k8s（2）

news2024/11/25 13:35:52

目录

一.二进制部署k8s

常见的K8S安装部署方式：

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

二.部署k8s

初始化操作：

每台node安装docker：

在 master01 节点上操作;

准备cfssl证书生成工具:：

执行脚本文件：

拉入etcd压缩包：

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

执行etcd.sh脚本：

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

修改node节点的etcd文件：

启动etcd服务：

检查etcd群集状态：

查看etcd集群成员列表：

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

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

创建kubernetes工作目录：

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

上传解压 kubernetes 压缩包：

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

解压master.zip：

启动 scheduler 服务：

启动 controller-manager 服务：

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

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

 部署 Worker Node 组件：

创建kubernetes工作目录：

在 master01 节点上操作：

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

授权，执行脚本：

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

master节点启动 kubelet 服务：

通过 CSR 请求：

在 node01 节点上操作：

启动proxy服务：

一.二进制部署k8s

常见的K8S安装部署方式：


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

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

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

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

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

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

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

二.部署k8s

k8s master节点：192.168.233.10，20

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

etcd集群：192.168.233.10,30,40

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

初始化操作：

关闭防火墙
systemctl stop firewalld
systemctl disable firewalld

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

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

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

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

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

sysctl --system

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

每台node安装docker：

yum install -y yum-utils device-mapper-persistent-data lvm2

yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo 

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

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

.

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

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

在 master01 节点上操作;

准备cfssl证书生成工具:：

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

chmod +x /usr/local/bin/*

创建工作目录：

添加脚本文件：

#!/bin/bash
#配置证书生成策略，让 CA 软件知道颁发有什么功能的证书，生成用来签发其他组件证书的根证书
cat > ca-config.json <<EOF
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
         "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ]
      }
    }
  }
}
EOF

#ca-config.json：可以定义多个 profiles，分别指定不同的过期时间、使用场景等参数；
#后续在签名证书时会使用某个 profile；此实例只有一个 www 模板。
#expiry：指定了证书的有效期，87600h 为10年，如果用默认值一年的话，证书到期后集群会立即宕掉
#signing：表示该证书可用于签名其它证书；生成的 ca.pem 证书中 CA=TRUE；
#key encipherment：表示使用非对称密钥加密，如 RSA 加密；
#server auth：表示client可以用该 CA 对 server 提供的证书进行验证；
#client auth：表示server可以用该 CA 对 client 提供的证书进行验证；
#注意标点符号，最后一个字段一般是没有逗号的。


#-----------------------
#生成CA证书和私钥（根证书和私钥）
cat > ca-csr.json <<EOF
{
    "CN": "etcd",
    "key": {
        "algo": "rsa",
        "size": 2048
        {
            "C": "CN",
            "L": "Beijing",
            "ST": "Beijing"
        }
    ]
}
EOF

#CN：Common Name，浏览器使用该字段验证网站或机构是否合法，一般写的是域名 
#key：指定了加密算法，一般使用rsa（size：2048）
#C：Country，国家
#ST：State，州，省
#L：Locality，地区,城市
#O: Organization Name，组织名称，公司名称
#OU: Organization Unit Name，组织单位名称，公司部门

cfssl gencert -initca ca-csr.json | cfssljson -bare ca

#生成的文件：
#ca-key.pem：根证书私钥
#ca.pem：根证书
#ca.csr：根证书签发请求文件

#注意：CSRJSON 文件用的是相对路径，所以 cfssl 的时候需要 csr 文件的路径下执行，也可以指定为绝对路径。
#cfssljson 将 cfssl 生成的证书（json格式）变为文件承载式证书，-bare 用于命名生成的证书文件。
#-----------------------
{
    "CN": "etcd",
    "hosts": [
    "192.168.233.10",
    "192.168.233.30",
    "192.168.233.40"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "BeiJing",
            "ST": "BeiJing"
        }
    ]
}
EOF

#hosts：将所有 etcd 集群节点添加到 host 列表，需要指定所有 etcd 集群的节点 ip 或主机名不能使用网段，>新增 etcd 服务器需要重新签发证书。

cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=www server-csr.json | cfssljson -bare server

#生成的文件：
#server.csr：服务器的证书请求文件
#server-key.pem：服务器的私钥
#server.pem：服务器的数字签名证书

#-config：引用证书生成策略文件 ca-config.json
#-profile：指定证书生成策略文件中的的使用场景，比如 ca-config.json 中的 www


#!/bin/bash
#example: ./etcd.sh etcd01 192.168.233.10 etcd02=https://192.168.233.30:2380,etcd03=https://192.168.233.40:2380

#创建etcd配置文件/opt/etcd/cfg/etcd
ETCD_NAME=$1
ETCD_IP=$2
ETCD_CLUSTER=$3

WORK_DIR=/opt/etcd

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://${ETCD_IP}:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://${ETCD_IP}:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://${ETCD_IP}:2380,${ETCD_CLUSTER}"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
EOF

#Member:成员配置
#ETCD_NAME：节点名称，集群中唯一。成员名字，集群中必须具备唯一性，如etcd01

#Clustering：集群配置
#ETCD_INITIAL_CLUSTER_TOKEN：集群Token。用于区分不同集群。本地如有多个集群要设为不同
#ETCD_INITIAL_CLUSTER_STATE：加入集群的当前状态，new是新集群，existing表示加入已有集群。


#创建etcd.service服务管理文件
cat > /usr/lib/systemd/system/etcd.service <<EOF
[Unit]
Description=Etcd Server
After=network.target
After=network-online.target
Wants=network-online.target

[Service]
Type=notify
EnvironmentFile=${WORK_DIR}/cfg/etcd
ExecStart=${WORK_DIR}/bin/etcd \
--cert-file=${WORK_DIR}/ssl/server.pem \
--key-file=${WORK_DIR}/ssl/server-key.pem \
--trusted-ca-file=${WORK_DIR}/ssl/ca.pem \
--peer-cert-file=${WORK_DIR}/ssl/server.pem \
--peer-key-file=${WORK_DIR}/ssl/server-key.pem \
--peer-trusted-ca-file=${WORK_DIR}/ssl/ca.pem \
--logger=zap \
--enable-v2
Restart=on-failure
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
EOF

#--enable-v2：开启 etcd v2 API 接口。当前 flannel 版本不支持 etcd v3 通信
#--logger=zap：使用 zap 日志框架。zap.Logger 是go语言中相对日志库中性能最高的
#--peer开头的配置项用于指定集群内部TLS相关证书（peer 证书），这里全部都使用同一套证书认证
#不带--peer开头的的参数是指定 etcd 服务器TLS相关证书（server 证书），这里全部都使用同一套证书认证


systemctl daemon-reload
systemctl enable etcd
systemctl restart etcd
执行脚本文件：

./etcd-cert.sh

移动文件：

mkdir etcd-cert

mv ca* server* etcd-cert

拉入etcd压缩包：

解压：

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

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

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

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

mv etcd etcdctl /opt/etcd/bin/

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

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

执行etcd.sh脚本：

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

查看端口：

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

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

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

修改node节点的etcd文件：

vim /opt/etcd/cfg/etcd

启动etcd服务：

systemctl start etcd
systemctl enable etcd
systemctl status etcd

检查etcd群集状态：

ETCDCTL_API=3 /opt/etcd/bin/etcdctl --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem --endpoints="https://192.168.233.10:2379,https://192.168.233.30:2379,https://192.168.233.40:2379" endpoint health --write-out=table

查看etcd集群成员列表：

ETCDCTL_API=3 /opt/etcd/bin/etcdctl --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem --endpoints="https://192.168.233.10:2379,https://192.168.233.30:2379,https://192.168.233.40:2379" --write-out=table member list

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

#!/bin/bash
#配置证书生成策略，让 CA 软件知道颁发有什么功能的证书，生成用来签发其他组件证书的根证书
cat > ca-config.json <<EOF
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "kubernetes": {
         "expiry": "87600h",
         "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ]
      }
    }
  }
}
EOF

#生成CA证书和私钥（根证书和私钥）
cat > ca-csr.json <<EOF
{
    "CN": "kubernetes",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Beijing",
            "ST": "Beijing",
            "O": "k8s",
            "OU": "System"
        }
    ]
}
EOF
#!/bin/bash
#配置证书生成策略，让 CA 软件知道颁发有什么功能的证书，生成用来签发其他组件证书的根证书
cat > ca-config.json <<EOF
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "kubernetes": {
         "expiry": "87600h",
         "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ]
      }
    }
  }
}
EOF

#生成CA证书和私钥（根证书和私钥）
cat > ca-csr.json <<EOF
{
    "CN": "kubernetes",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Beijing",
            "ST": "Beijing",
            "O": "k8s",
            "OU": "System"
        }
    ]
}
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.233.10",
      "192.168.233.20", 
      "192.168.233.100",
      "192.168.233.50",
      "192.168.233.60",
      "kubernetes",
      "kubernetes.default",
      "kubernetes.default.svc",
      "kubernetes.default.svc.cluster",
      "kubernetes.default.svc.cluster.local"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "BeiJing",
            "ST": "BeiJing",
            "O": "k8s",
            "OU": "System"
        }
    ]
}
EOF



#-----------------------
#生成 kubectl 连接集群的证书和私钥（kubectl 和 apiserver 通信使用）
cat > admin-csr.json <<EOF
{
  "CN": "admin",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "BeiJing",
      "ST": "BeiJing",
      "O": "system:masters",
      "OU": "System"
    }
  ]
}
EOF



#-----------------------
#生成 kube-proxy 的证书和私钥（kube-proxy 和 apiserver 通信使用）
cat > kube-proxy-csr.json <<EOF
{
  "CN": "system:kube-proxy",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "BeiJing",
      "ST": "BeiJing",
      "O": "k8s",
      "OU": "System"
    }
  ]
}
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证书、相关组件的证书和私钥的目录：

移动脚本文件到目录中;

执行文件：

创建kubernetes工作目录：

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

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

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

上传解压 kubernetes 压缩包：

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

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

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

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

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

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

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

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

解压master.zip：

授权：

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

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

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

netstat -natp | grep 6443

启动 scheduler 服务：

#!/bin/bash
##创建 kube-scheduler 启动参数配置文件
MASTER_ADDRESS=$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=$MASTER_ADDRESS"
EOF

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


##生成kube-scheduler证书
#创建证书请求文件
cat > kube-scheduler-csr.json << EOF
{
  "CN": "system:kube-scheduler",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "BeiJing",
      "ST": "BeiJing",
      "O": "system:masters",
      "OU": "System"
    }
  ]
}
EOF

#生成证书和私钥

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

#配置kubernetes集群参数
kubectl config set-cluster kubernetes \
  --certificate-authority=/opt/kubernetes/ssl/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=${KUBE_CONFIG}
#配置客户端认证参数
kubectl config set-credentials kube-scheduler \
  --client-certificate=./kube-scheduler.pem \
  --client-key=./kube-scheduler-key.pem \
  --embed-certs=true \
  --kubeconfig=${KUBE_CONFIG}
#设置上下文参数 
kubectl config set-context default \
  --cluster=kubernetes \
  --user=kube-scheduler \
  --kubeconfig=${KUBE_CONFIG}
#设置默认上下文
kubectl config use-context default --kubeconfig=${KUBE_CONFIG}


##创建 kube-scheduler.service 服务管理文件
cat >/usr/lib/systemd/system/kube-scheduler.service <<EOF
[Unit]
Description=Kubernetes Scheduler
Documentation=https://github.com/kubernetes/kubernetes

[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-scheduler
ExecStart=/opt/kubernetes/bin/kube-scheduler \$KUBE_SCHEDULER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable kube-scheduler
systemctl restart kube-scheduler

启动脚本：

启动 controller-manager 服务：

#!/bin/bash
##创建 kube-controller-manager 启动参数配置文件
MASTER_ADDRESS=$1

cat >/opt/kubernetes/cfg/kube-controller-manager <<EOF
KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--leader-elect=true \\
--kubeconfig=/opt/kubernetes/cfg/kube-controller-manager.kubeconfig \\
--bind-address=$MASTER_ADDRESS \\
--allocate-node-cidrs=true \\
--cluster-cidr=10.244.0.0/16 \\
--service-cluster-ip-range=10.0.0.0/24 \\
--cluster-signing-cert-file=/opt/kubernetes/ssl/ca.pem \\
--cluster-signing-key-file=/opt/kubernetes/ssl/ca-key.pem  \\
--root-ca-file=/opt/kubernetes/ssl/ca.pem \\
--service-account-private-key-file=/opt/kubernetes/ssl/ca-key.pem \\
--cluster-signing-duration=87600h0m0s"
EOF

#––leader-elect：当该组件启动多个时，自动选举（HA）
#-–kubeconfig：连接 apiserver 用的配置文件，用于识别 k8s 集群


##生成kube-controller-manager证书
#创建证书请求文件
cat > kube-controller-manager-csr.json << EOF
{
  "CN": "system:kube-controller-manager",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "BeiJing", 
      "ST": "BeiJing",
      "O": "system:masters",
      "OU": "System"
    }
  ]
}
EOF

#生成证书和私钥

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

#配置kubernetes集群参数
kubectl config set-cluster kubernetes \
  --certificate-authority=/opt/kubernetes/ssl/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=${KUBE_CONFIG}
#配置客户端认证参数
kubectl config set-credentials kube-controller-manager \
  --client-certificate=./kube-controller-manager.pem \
  --client-key=./kube-controller-manager-key.pem \
  --embed-certs=true \
  --kubeconfig=${KUBE_CONFIG}
#设置上下文参数
kubectl config set-context default \
  --cluster=kubernetes \
  --user=kube-controller-manager \
  --kubeconfig=${KUBE_CONFIG}
#设置默认上下文
kubectl config use-context default --kubeconfig=${KUBE_CONFIG}


##创建 kube-controller-manager.service 服务管理文件
cat >/usr/lib/systemd/system/kube-controller-manager.service <<EOF
[Unit]
Description=Kubernetes Controller Manager
Documentation=https://github.com/kubernetes/kubernetes

[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-controller-manager
ExecStart=/opt/kubernetes/bin/kube-controller-manager \$KUBE_CONTROLLER_MANAGER_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable kube-controller-manager
systemctl restart kube-controller-manager

执行脚本：

 ./controller-manager.sh 192.168.233.10

​​​​​​​

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

#!/bin/bash
mkdir /root/.kube
KUBE_CONFIG="/root/.kube/config"
KUBE_APISERVER="https://192.168.233.10:6443"

#切换到k8s证书目录操作
cd /opt/k8s/k8s-cert/
  --certificate-authority=/opt/kubernetes/ssl/ca.pem \
  --embed-certs=true \
  --client-certificate=./admin.pem \
  --client-key=./admin-key.pem \
kubectl config set-context default \
  --kubeconfig=${KUBE_CONFIG}
#设置默认环境上下文
kubectl config use-context default --kubeconfig=${KUBE_CONFIG}
#生成的 kubeconfig 被保存到 /root/.kube/config 文件

#########################################################
#集群参数
#本段设置了所需要访问的集群的信息。使用set-cluster设置了需要访问的集群，如上为kubernetes，这只是个名>称，实际为--server指向的apiserver；--certificate-authority设置了该集群的公钥；--embed-certs为true表示
将--certificate-authority证书写入到kubeconfig中；--server则表示该集群的kube-apiserver地址

#用户参数
#本段主要设置用户的相关信息，主要是用户证书。如上的用户名为admin，证书为：/opt/kubernetes/ssl/admin.pem，私钥为：/opt/kubernetes/ssl/admin-key.pem。注意客户端的证书首先要经过集群CA的签署，否则不会被集群
认可。此处使用的是ca认证方式，也可以使用token认证，如kubelet的 TLS Boostrap 机制下的 bootstrapping 使
用的就是token认证方式。上述kubectl使用的是ca认证，不需要token字段

#上下文参数
#集群参数和用户参数可以同时设置多对，在上下文参数中将集群参数和用户参数关联起来。上面的上下文名称为default，集群为kubenetes，用户为admin，表示使用admin的用户凭证来访问kubenetes集群的default命名空间，也>可以增加--namspace来指定访问的命名空间。

#最后使用 kubectl config use-context default 来使用名为 default 的环境项来作为配置。 如果配置了多个环
境项，可以通过切换不同的环境项名字来访问到不同的集群环境。
#########################################################

执行脚本：

查看文件：

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

kubectl get cs

查看版本信息：

kubectl version

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

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

 部署 Worker Node 组件：

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

创建kubernetes工作目录：

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

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

#!/bin/bash

NODE_ADDRESS=$1
DNS_SERVER_IP=${2:-"10.0.0.2"}
cat >/opt/kubernetes/cfg/kubelet <<EOF
KUBELET_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--hostname-override=node01 \\
--network-plugin=cni \\
--kubeconfig=/opt/kubernetes/cfg/kubelet.kubeconfig \\
--bootstrap-kubeconfig=/opt/kubernetes/cfg/bootstrap.kubeconfig \\
--config=/opt/kubernetes/cfg/kubelet.config \\
--cert-dir=/opt/kubernetes/ssl \\
--pod-infra-container-image=registry.cn-hangzhou.aliyuncs.com/google_containers/pause-amd64:3.2"
EOF

#--network-plugin：启用CNI
#--bootstrap-kubeconfig：指定连接 apiserver 的 bootstrap.kubeconfig 文件
#--config：指定kubelet配置文件的路径，启动kubelet时将从此文件加载其配置
#--cert-dir：指定master颁发的kubelet证书生成目录


#----------------------
cat >/opt/kubernetes/cfg/kubelet.config <<EOF
kind: KubeletConfiguration
apiVersion: kubelet.config.k8s.io/v1beta1
address: ${NODE_ADDRESS}
port: 10250
readOnlyPort: 10255
cgroupDriver: systemd
clusterDNS:
- ${DNS_SERVER_IP} 
clusterDomain: cluster.local
failSwapOn: false
authentication:
  anonymous:
    enabled: true
EOF

#PS：当命令行参数与此配置文件（kubelet.config）有相同的值时，就会覆盖配置文件中的该值。


#----------------------
#创建 kubelet.service 服务管理文件
cat >/usr/lib/systemd/system/kubelet.service <<EOF
[Unit]
Description=Kubernetes Kubelet
After=docker.service
Requires=docker.service

[Service]
EnvironmentFile=/opt/kubernetes/cfg/kubelet
ExecStart=/opt/kubernetes/bin/kubelet \$KUBELET_OPTS
Restart=on-failure
KillMode=process

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable kubelet
systemctl restart kubelet


#!/bin/bash

NODE_ADDRESS=$1

#创建 kube-proxy 启动参数配置文件
cat >/opt/kubernetes/cfg/kube-proxy <<EOF
KUBE_PROXY_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--hostname-override=${NODE_ADDRESS} \\
--cluster-cidr=10.244.0.0/16 \\
--proxy-mode=ipvs \\
--kubeconfig=/opt/kubernetes/cfg/kube-proxy.kubeconfig"
EOF

#--kubeconfig: 指定连接 apiserver 的 kubeconfig 文件
#rr: round-robin，轮询。
#lc: least connection，最小连接数。
#dh: destination hashing，目的地址哈希。
#sh: source hashing ,原地址哈希。
#sed: shortest expected delay，最短期望延时。
#nq: never queue ，永不排队。

#----------------------
#创建 kube-proxy.service 服务管理文件
cat >/usr/lib/systemd/system/kube-proxy.service <<EOF
[Unit]
Description=Kubernetes Proxy
After=network.target

[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-proxy
ExecStart=/opt/kubernetes/bin/kube-proxy \$KUBE_PROXY_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable kube-proxy
systemctl restart kube-proxy


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


#!/bin/bash

NODE_ADDRESS=$1

#创建 kube-proxy 启动参数配置文件
cat >/opt/kubernetes/cfg/kube-proxy <<EOF
KUBE_PROXY_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--hostname-override=${NODE_ADDRESS} \\
--cluster-cidr=10.244.0.0/16 \\
--proxy-mode=ipvs \\
--kubeconfig=/opt/kubernetes/cfg/kube-proxy.kubeconfig"
EOF

#--kubeconfig: 指定连接 apiserver 的 kubeconfig 文件
#rr: round-robin，轮询。
#lc: least connection，最小连接数。
#dh: destination hashing，目的地址哈希。
#sh: source hashing ,原地址哈希。
#sed: shortest expected delay，最短期望延时。
#nq: never queue ，永不排队。

#----------------------
#创建 kube-proxy.service 服务管理文件
cat >/usr/lib/systemd/system/kube-proxy.service <<EOF
[Unit]
Description=Kubernetes Proxy
After=network.target

[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-proxy
ExecStart=/opt/kubernetes/bin/kube-proxy \$KUBE_PROXY_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable kube-proxy
systemctl restart kube-proxy

授权：

在 master01 节点上操作：

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

cd /opt/k8s/kubernetes/server/bin

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

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

#!/bin/bash
#example: kubeconfig 192.168.233.10 /opt/k8s/k8s-cert/
#创建bootstrap.kubeconfig文件

BOOTSTRAP_TOKEN=$(awk -F ',' '{print $1}' /opt/kubernetes/cfg/token.csv)
APISERVER=$1
SSL_DIR=$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
授权，执行脚本：

chmod +x kubeconfig.sh

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

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

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

查看一下：

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

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

master节点启动 kubelet 服务：

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

通过 CSR 请求：

kubectl certificate approve node-csr-vH5p3H5QliAUh9WjCnwXPDb84pFhcj-FrHiTIRDeeU8

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

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

kubectl get node

在 node01 节点上操作：

加载 ip_vs 模块：

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

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

启动proxy服务：

./proxy.sh 192.168.233.30

master节点：

node02上启动kubelet：

master节点通过 CSR 请求：

node02上启动proxy：

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

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

相关文章

Spring Boot应用集成Actuator端点自定义Filter解决未授权访问的漏洞

Spring Boot应用集成Actuator端点自定义Filter解决未授权访问的漏洞

一、前言 我们知道想要实时监控我们的应用程序的运行状态&#xff0c;比如实时显示一些指标数据&#xff0c;观察每时每刻访问的流量&#xff0c;或者是我们数据库的访问状态等等&#xff0c;需要使用到Actuator组件&#xff0c;但是Actuator有一个访问未授权问题&#xff0c;…
阅读更多...
2023全新UI千月影视APP源码 | 前后端完美匹配、后端基于ThinkPHP框架

2023全新UI千月影视APP源码 | 前后端完美匹配、后端基于ThinkPHP框架

应用介绍 本文来自&#xff1a;2023全新UI千月影视APP源码 | 前后端完美匹配、后端基于ThinkPHP框架 - 源码1688 简介&#xff1a; 2023全新UI千月影视APP源码 | 前后端完美匹配、后端基于thinkphp框架 图片&#xff1a;
阅读更多...
索引大战：探秘InnoDB数据库中B树和Hash索引的优劣

索引大战：探秘InnoDB数据库中B树和Hash索引的优劣

欢迎来到我的博客&#xff0c;代码的世界里&#xff0c;每一行都是一个故事 索引大战&#xff1a;探秘InnoDB数据库中B树和Hash索引的优劣 前言B树索引的深度解析Hash索引的奥秘揭晓性能对比分析 前言 在当今软件开发的世界中&#xff0c;数据库扮演着至关重要的角色。而InnoD…
阅读更多...
怎么用sora赚第一桶金？

怎么用sora赚第一桶金？

&#x1f31f;解锁文字变视频的强大功能&#xff01;&#x1f31f; ✨欢迎来到 Sora Cand&#xff0c;一个革命性的网站&#xff0c;利用 OpenAI 的 Sora 模型帮你把文字变成酷炫的视频&#xff01;✨ 想象一下&#xff0c;你的文字从纸上跳出来&#xff0c;变成引人入胜的视觉…
阅读更多...
如何用IP地址找到实际位置？

如何用IP地址找到实际位置？

在互联网世界中&#xff0c;每个设备都有一个独特的标识&#xff0c;那就是IP地址。它不仅是设备在网络中的“身份证”&#xff0c;还承载着设备在网络中的位置信息。那么&#xff0c;我们是否可以通过IP地址来找到设备的实际位置呢&#xff1f;本文将深入探讨这一问题。 一、I…
阅读更多...
#11vue3中使用el-dialog展示与关闭交由父组件控制的写法

#11vue3中使用el-dialog展示与关闭交由父组件控制的写法

目录 1、法一&#xff1a;通过defineEmits调用父组件方法 1.1、父组件 1.2、子组件&#xff08;CONTENT&#xff09; 2、法二&#xff1a;通过difineExpose暴露子组件属性 2.1、父组件 2.2、子组件&#xff08;Child&#xff09; 1、法一&#xff1a;通过defineEmits调用…
阅读更多...
【C语言】注释

【C语言】注释

&#x1f388;个人主页&#xff1a;豌豆射手^ &#x1f389;欢迎 &#x1f44d;点赞✍评论⭐收藏 &#x1f917;收录专栏&#xff1a;C语言 &#x1f91d;希望本文对您有所裨益&#xff0c;如有不足之处&#xff0c;欢迎在评论区提出指正&#xff0c;让我们共同学习、交流进步&…
阅读更多...
vue3 toRefs之后的变量修改方法

vue3 toRefs之后的变量修改方法

上效果 修改值需要带上解构之前的对象名obj&#xff0c; changeName:()>{ // toRefs 解决后变量修改值方法&#xff1a; 解构前变量.字段新值 obj.name FEIFEI; } } 案例源码 <!DOCTYPE html> <html> <head><me…
阅读更多...
算法——模拟

算法——模拟

1. 什么是模拟算法&#xff1f; 官方一点来说 模拟算法&#xff08;Simulation Algorithm&#xff09;是一种通过模拟现实或抽象系统的运行过程来研究、分析或解决问题的方法。它通常涉及创建一个模型&#xff0c;模拟系统中的各种事件和过程&#xff0c;以便观察系统的行为&a…
阅读更多...
从单体服务到微服务：多模式 Web 应用开发记录＜一＞背景全局变量优化

从单体服务到微服务：多模式 Web 应用开发记录＜一＞背景全局变量优化

背景 最近在做一个事&#xff1a;下线一个超级大单体服务。单一统计代码行数其实不够全面&#xff0c;反正项目 git clone 下来文件就有这么大&#xff1a; 这是一个已经存在了十年以上的服务&#xff0c;随着业务的发展&#xff0c;这个服务已经无法满足我们的需求。 我们统…
阅读更多...
胡夏爱意满满，浪漫尽显，心动不止。

胡夏爱意满满，浪漫尽显，心动不止。

♥ 为方便您进行讨论和分享&#xff0c;同时也为能带给您不一样的参与感。请您在阅读本文之前&#xff0c;点击一下“关注”&#xff0c;非常感谢您的支持&#xff01; 文 |猴哥聊娱乐 编 辑|徐 婷 校 对|侯欢庭 全网热议的胡夏暗恋文学&#xff0c;浪漫指数爆表&#xff01…
阅读更多...
力扣382.链表随机节点

力扣382.链表随机节点

Problem: 382. 链表随机节点 文章目录 题目描述思路复杂度Code 题目描述 思路 由水塘抽样易得&#xff0c;当遇到i个元素&#xff0c;有 1 / i 1/i 1/i的概率选择该元素&#xff1b;则在实际操作中我们定义一个下标i从1开始遍历每次判断rand() % i 0&#xff08;该操作就是判断…
阅读更多...
Verilog刷题笔记35

Verilog刷题笔记35

题目&#xff1a; Create a 1-bit wide, 256-to-1 multiplexer. The 256 inputs are all packed into a single 256-bit input vector. sel0 should select in[0], sel1 selects bits in[1], sel2 selects bits in[2], etc. 解法&#xff1a; module top_module( input [255:…
阅读更多...
猜谜“龘”人速来！网安人元宵灯谜有礼了

猜谜“龘”人速来！网安人元宵灯谜有礼了

​​灯笼高挂&#xff0c;星光璀璨&#xff0c;品味糯叽叽的元宵&#xff0c;以灯谜为媒&#xff0c;亚信安全邀你共赴元宵佳节。 热辣滚烫的班先别上了&#xff0c;文末有奖竞猜&#xff0c;快来参与&#xff01; 喜闹元宵 谜面一&#xff1a;一路向上成大业&#xff1b; 谜…
阅读更多...
HTML5新婚、年会、各种聚会的现场抽奖活动（附源码）

HTML5新婚、年会、各种聚会的现场抽奖活动（附源码）

文章目录 1.抽奖平台设计来源1.1 主界面效果1.2 抽奖效果1.3 中奖效果 2.效果和源码配置2.1 动态效果2.2 人员信息配置2.3 奖品信息配置2.4 抽奖音效配置2.5 源代码 源码下载 作者&#xff1a;xcLeigh 文章地址&#xff1a;https://blog.csdn.net/weixin_43151418/article/deta…
阅读更多...
第一节-docker介绍

第一节-docker介绍

这里写自定义目录标题 一、什么是docker二、docker和virtual machine三、docker架构 一、什么是docker docker是一种容器引擎&#xff0c;用于构建、部署、运行应用程序和服务。 docker的每个容器通过沙箱机制相互隔离&#xff0c;互不干扰。 docker容器技术相比传统的虚拟机有…
阅读更多...
六、回归与聚类算法 - 模型保存与加载

六、回归与聚类算法 - 模型保存与加载

目录 1、API 2、案例 欠拟合与过拟合线性回归的改进 - 岭回归分类算法&#xff1a;逻辑回归模型保存与加载无监督学习&#xff1a;K-means算法 1、API 2、案例
阅读更多...
费舍尔FISHER金属探测器探测仪维修F70

费舍尔FISHER金属探测器探测仪维修F70

美国FISHER LABS费舍尔地下金属探测器&#xff0c;金属探测仪等维修&#xff08;考古探金银铜探宝等仪器&#xff09;。 费舍尔F70视听目标ID金属探测器&#xff0c;Fisher 金属探测器公司成立于1931年&#xff0c;在实验条件很艰苦的情况下&#xff0c;研发出了地下金属探测器…
阅读更多...
昨天Google发布了最新的开源模型Gemma，今天我来体验一下

昨天Google发布了最新的开源模型Gemma，今天我来体验一下

前言 看看以前写的文章&#xff0c;业余搞人工智能还是很早之前的事情了&#xff0c;之前为了高工资&#xff0c;一直想从事人工智能相关的工作都没有实现。现在终于可以安静地系统地学习一下了。也是一边学习一边写博客记录吧。 昨天Google发布了最新的开源模型Gemma&#xf…
阅读更多...
常见锁策略,CAS,synchrodized原理讲解

常见锁策略,CAS,synchrodized原理讲解

&#x1f3a5; 个人主页&#xff1a;Dikz12&#x1f4d5;格言&#xff1a;那些在暗处执拗生长的花&#xff0c;终有一日会馥郁传香欢迎大家&#x1f44d;点赞✍评论⭐收藏 目录 常见锁策略 乐观锁和悲观锁 轻量级锁和重量级锁 自旋锁和挂起等待锁 读写锁 公平锁和非公平锁…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023