k8s（2）

目录

一.二进制部署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：

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【目标检测新SOTA！v7 v4作者新作！】YOLO v9 思路复现 + 全流程优化

【目标检测新SOTA！v7 v4作者新作！】YOLO v9 思路复现 + 全流程优化

YOLO v9 思路复现 全流程优化 提出背景&#xff1a;深层网络的 信息丢失、梯度流偏差YOLO v9 设计逻辑可编程梯度信息&#xff08;PGI&#xff09;&#xff1a;使用PGI改善训练过程广义高效层聚合网络&#xff08;GELAN&#xff09;&#xff1a;使用GELAN改进架构 对比其他解法…
阅读更多...
Airtest-Selenium实操小课③：下载可爱猫猫图片

Airtest-Selenium实操小课③：下载可爱猫猫图片

1. 前言 那么这周我们看看如何实现使用Airtest-Selenium实现自动搜索下载可爱的猫猫图片吧~ 2. 需求分析和准备 整体的需求大致可以分为以下步骤&#xff1a; 打开chrome浏览器 打开百度网页 搜索“可爱猫猫图片” 定位图片元素 创建存储图片的文件夹 下载可爱猫猫图片…
阅读更多...
SpringBoot中Redis缓存的使用

SpringBoot中Redis缓存的使用

目录 1 前言 2 实现方法 2.1 查询数据时 2.2 修改数据 1 前言 对于一些不常改变&#xff0c;但又经常查询的数据&#xff0c;我们可以使用Redis缓存&#xff0c;来缓解数据库的压力&#xff0c;其中的逻辑如下&#xff1a; 2 实现方法 2.1 查询数据时 一般在控制类查询方…
阅读更多...
普中51单片机（DS18B20温度传感器）

普中51单片机（DS18B20温度传感器）

DS18B20温度传感器原理 内部结构 64位(激)光刻只读存储器 光刻ROM中的64位序列号是出厂前被光刻好的&#xff0c;它可以看作是该DS18B20的地址序列号。64位光刻ROM的排列是&#xff1a;开始8位&#xff08;28H&#xff09;是产品类型标号&#xff0c;接着的48位是该DS18B20自身…
阅读更多...
推荐系统经典模型YouTubeDNN

推荐系统经典模型YouTubeDNN

文章目录 YouTubeDNN概念YouTubeDNN模型架构图YouTubeDNN召回阶段YouTubeDNN层级介绍 YouTubeDNN排序阶段YoutubeDNN模型中的一些Trick负采样问题特征构造上下文选择 总结 YouTubeDNN概念 YouTubeDNN是YouTube用于做视频推荐的落地模型&#xff0c;其大体思路就是召回阶段使用…
阅读更多...
Kubernetes 二进制部署 《easzlab / kubeasz项目部署》（一）

Kubernetes 二进制部署 《easzlab / kubeasz项目部署》（一）

Kubernetes 二进制部署 - easzlab / kubeasz项目部署 1. 准备工作1.1 设置防火墙1.2 设置SeLinux1.3 设置时区及时间同步1.4 配置域名解析1.5 确认SSH开启1.6 IP转发1.7 安装docker1.8 关闭swap 2. 服务器规划2.1 基本架构图2.2 官方建议2.3 实践服务器规划 3. 服务器配置3.1 配…
阅读更多...
Airtest遇到模拟器无法输入中文的情况该如何处理？

Airtest遇到模拟器无法输入中文的情况该如何处理？

1. 前言 最近有收到同学们的一些提问&#xff0c;使用Airtest的 text 接口&#xff0c;发现在部分模拟器上&#xff0c; text 无法输入中文&#xff0c;不知道该怎么处理。 今天我们就输入这个小问题&#xff0c;来详细聊一下。 2. Airtest的输入法简介 对于Android设备来说…
阅读更多...
WebStorm 2023：让您更接近理想的开发环境 mac/win版

WebStorm 2023：让您更接近理想的开发环境 mac/win版

JetBrains WebStorm 2023激活版下载是一款强大而智能的Web开发工具&#xff0c;专为提高开发人员的生产力而设计。这款编辑器提供了许多先进的代码编辑功能&#xff0c;以及一系列实用的工具和插件&#xff0c;可帮助您更快地编写、调试和测试代码。 WebStorm 2023软件获取 We…
阅读更多...
ESP8266智能家居（1）——开发环境的搭建

ESP8266智能家居（1）——开发环境的搭建

1.前期介绍 本次打算使用esp8266的开发板——NodeMCU&#xff0c;进行物联网相关项目的学习。开发环境使用Arduino软件。 NodeMCU实物图为&#xff1a; 开发环境截图为&#xff1a; 2.软件下载 我使用的arduino版本为1.8.5&#xff0c;其安装包如下&#xff1a; 【免费】ar…
阅读更多...
五大方法教你如何分分钟构造百万测试数据！

五大方法教你如何分分钟构造百万测试数据！

在测试的工作过程中&#xff0c;很多场景是需要构造一些数据在项目里的&#xff0c;方便测试工作的进行&#xff0c;构造的方法有很多&#xff0c;难度和技术深度也不一样。本文提供方法供你选择。 在测试的工作过程中&#xff0c;很多场景是需要构造一些数据在项目里的&#…
阅读更多...
Linux理解

Linux理解

VMware安装Linux安装 目录 VMware安装Linux安装 1.1 什么是Linux 1.2 为什么要学Linux 1.3 学完Linux能干什么 2.1 主流操作系统 2.2 Linux系统版本 VMware安装Linux安装 1.1 什么是Linux Linux是一套免费使用和自由传播的操作系统。 1.2 为什么要学Linux 1). 企业用人…
阅读更多...
Jenkins 中部署Nodejs插件并使用，并构建前端项目（3）

Jenkins 中部署Nodejs插件并使用，并构建前端项目（3）

遇到多个版本nodeJS需要构建的时候 1、第一种就是一个配置安装&#xff0c;然后进行选中配置 2、第二种就是插件&#xff1a;nvm-wrapper&#xff0c;我们还是选用NodeJS插件&#xff1a; &#xff08;1&#xff09;可以加载任意npmrc文件&#xff1b; &#xff08;2&#x…
阅读更多...
论文精读--GPT1

论文精读--GPT1

把transformer的解码器拿出来&#xff0c;在没有标号的大量文本数据上训练一个语言模型&#xff0c;来获得预训练模型&#xff0c;然后到子任务上微调&#xff0c;得到每个任务所需的分类器 Abstract Natural language understanding comprises a wide range of diverse tasks…
阅读更多...
极电电子WMS项目顺利验收，盘古信息助推新能源车企数字化转型

极电电子WMS项目顺利验收，盘古信息助推新能源车企数字化转型

近年来&#xff0c;中国新能源汽车产销持续保持着较高增速&#xff0c;产销总量连续9年位居全球第一。 在产销高涨的背后&#xff0c;新能源汽车行业“内卷”现象也日益加剧&#xff0c;“配置战”、“价格战”等愈发激烈&#xff0c;驱动车企提高自身竞争力&#xff0c;以抢占…
阅读更多...
【Ucore 操作系统】2. 批处理系统和特权机制

【Ucore 操作系统】2. 批处理系统和特权机制

文章目录 【 0. 引言 】0.1 批处理系统0.2 特权级机制0.3 本章任务 【 1. 特权级机制 】1.1 特权级的软硬件协同设计1.2 RISC-V的特权级架构1.3 异常1.3.1 陷入/trap 类异常1.3.2 Fault 类异常 1.4 RISC-V的特权指令 【 2. 实现应用程序以及user文件夹 】2.1 user文件夹以及测例…
阅读更多...
基于springboot+vue的智能物流管理系统(前后端分离)

基于springboot+vue的智能物流管理系统(前后端分离)

博主主页&#xff1a;猫头鹰源码 博主简介&#xff1a;Java领域优质创作者、CSDN博客专家、阿里云专家博主、公司架构师、全网粉丝5万、专注Java技术领域和毕业设计项目实战&#xff0c;欢迎高校老师\讲师\同行交流合作 ​主要内容&#xff1a;毕业设计(Javaweb项目|小程序|Pyt…
阅读更多...
外贸专线费用解析与选择要点

外贸专线费用解析与选择要点

外贸专线费用解析与选择要点 在进行外贸业务时&#xff0c;一项至关重要的准备工作是申请一条外网专线&#xff0c;以确保企业能够稳定、高效地与国外网络连接&#xff0c;促进业务的正常开展和与国外客户的便捷沟通。然而&#xff0c;对于外贸专线的费用问题&#xff0c;许多初…
阅读更多...
【算法与数据结构】127、LeetCode单词接龙

【算法与数据结构】127、LeetCode单词接龙

文章目录 一、题目二、解法三、完整代码 所有的LeetCode题解索引&#xff0c;可以看这篇文章——【算法和数据结构】LeetCode题解。 一、题目 二、解法 思路分析&#xff1a;示例1为例&#xff0c;hit到达cog的路线不止一条&#xff0c;如何找到最短是关键。广度优先搜索是一圈…
阅读更多...
泰迪智能科技大模型数据智能实验室

泰迪智能科技大模型数据智能实验室

自2022年11月ChatGPT问世以来&#xff0c;大模型开始备受关注&#xff0c;科技巨头们纷纷推出大模型实验室解决方案。大模型的价值不知在于互联网场景&#xff0c;而在于大模型能力垂直化&#xff0c;能够与具体的业务需求深度融合。 大模型实验室是在学校现有的实验室建设基础…
阅读更多...
Mac版本HBuilderX 编辑完浏览器页面不会自动刷新,代码不自动提示

Mac版本HBuilderX 编辑完浏览器页面不会自动刷新,代码不自动提示

学习uniapp时候发现了个怪异的现象&#xff0c;Hbuilder里的项目&#xff0c;代码不自动提示&#xff0c;而且&#xff0c;编译完vue文件之后&#xff0c;浏览器不自动刷新。 排查问题&#xff1a; 1:项目层级不对 &#xff0c;编译时候层级过深 2:一些配置信息&#xff1b; …
阅读更多...
最新文章

Copyright @ 2022~2023