Kubernetes基础概念

1.特性

• 服务发现和负载均衡
  Kubernetes 可以使用 DNS 名称或自己的 IP 地址公开容器，如果进入容器的流量很大， Kubernetes 可以负载均衡并分配网络流量，从而使部署稳定。
• 存储编排
  Kubernetes 允许你自动挂载你选择的存储系统，例如本地存储、公共云提供商等。
• 自动部署和回滚
  你可以使用 Kubernetes 描述已部署容器的所需状态，它可以以受控的速率将实际状态 更改为期望状态。例如，你可以自动化 Kubernetes 来为你的部署创建新容器， 删除现有容器并将它们的所有资源用于新容器。
• 自动完成装箱计算
  Kubernetes 允许你指定每个容器所需 CPU 和内存（RAM）。 当容器指定了资源请求时，Kubernetes 可以做出更好的决策来管理容器的资源。
• 自我修复
  Kubernetes 重新启动失败的容器、替换容器、杀死不响应用户定义的 运行状况检查的容器，并且在准备好服务之前不将其通告给客户端。
• 密钥与配置管理
  Kubernetes 允许你存储和管理敏感信息，例如密码、OAuth 令牌和 ssh 密钥。 你可以在不重建容器镜像的情况下部署和更新密钥和应用程序配置，也无需在堆栈配置中暴露密钥。

2.组建架构

1、控制平面组件（Control Plane Components）

控制平面的组件对集群做出全局决策(比如调度)，以及检测和响应集群事件（例如，当不满足部署的 replicas 字段时，启动新的 pod）。

控制平面组件可以在集群中的任何节点上运行。 然而，为了简单起见，设置脚本通常会在同一个计算机上启动所有控制平面组件， 并且不会在此计算机上运行用户容器。 请参阅使用 kubeadm 构建高可用性集群 中关于多 VM 控制平面设置的示例。

kube-apiserver

API 服务器是 Kubernetes 控制面的组件， 该组件公开了 Kubernetes API。 API 服务器是 Kubernetes 控制面的前端。

Kubernetes API 服务器的主要实现是 kube-apiserver。 kube-apiserver 设计上考虑了水平伸缩，也就是说，它可通过部署多个实例进行伸缩。 你可以运行 kube-apiserver 的多个实例，并在这些实例之间平衡流量。

etcd

etcd 是兼具一致性和高可用性的键值数据库，可以作为保存 Kubernetes 所有集群数据的后台数据库。

您的 Kubernetes 集群的 etcd 数据库通常需要有个备份计划。

要了解 etcd 更深层次的信息，请参考 etcd 文档。

kube-scheduler

控制平面组件，负责监视新创建的、未指定运行节点（node）的 Pods，选择节点让 Pod 在上面运行。

调度决策考虑的因素包括单个 Pod 和 Pod 集合的资源需求、硬件/软件/策略约束、亲和性和反亲和性规范、数据位置、工作负载间的干扰和最后时限。

kube-controller-manager

在主节点上运行 控制器 的组件。

从逻辑上讲，每个控制器都是一个单独的进程， 但是为了降低复杂性，它们都被编译到同一个可执行文件，并在一个进程中运行。

这些控制器包括:

• 节点控制器（Node Controller）: 负责在节点出现故障时进行通知和响应
• 任务控制器（Job controller）: 监测代表一次性任务的 Job 对象，然后创建 Pods 来运行这些任务直至完成
• 端点控制器（Endpoints Controller）: 填充端点(Endpoints)对象(即加入 Service 与 Pod)
• 服务帐户和令牌控制器（Service Account & Token Controllers）: 为新的命名空间创建默认帐户和 API 访问令牌

cloud-controller-manager

云控制器管理器是指嵌入特定云的控制逻辑的 控制平面组件。 云控制器管理器允许您链接集群到云提供商的应用编程接口中， 并把和该云平台交互的组件与只和您的集群交互的组件分离开。

cloud-controller-manager 仅运行特定于云平台的控制回路。 如果你在自己的环境中运行 Kubernetes，或者在本地计算机中运行学习环境， 所部署的环境中不需要云控制器管理器。

与 kube-controller-manager 类似，cloud-controller-manager 将若干逻辑上独立的 控制回路组合到同一个可执行文件中，供你以同一进程的方式运行。 你可以对其执行水平扩容（运行不止一个副本）以提升性能或者增强容错能力。

下面的控制器都包含对云平台驱动的依赖：

• 节点控制器（Node Controller）: 用于在节点终止响应后检查云提供商以确定节点是否已被删除
• 路由控制器（Route Controller）: 用于在底层云基础架构中设置路由
• 服务控制器（Service Controller）: 用于创建、更新和删除云提供商负载均衡器

2、Node 组件

节点组件在每个节点上运行，维护运行的 Pod 并提供 Kubernetes 运行环境。

kubelet

一个在集群中每个节点（node）上运行的代理。 它保证容器（containers）都 运行在 Pod 中。

kubelet 接收一组通过各类机制提供给它的 PodSpecs，确保这些 PodSpecs 中描述的容器处于运行状态且健康。 kubelet 不会管理不是由 Kubernetes 创建的容器。

kube-proxy

kube-proxy 是集群中每个节点上运行的网络代理， 实现 Kubernetes 服务（Service） 概念的一部分。

kube-proxy 维护节点上的网络规则。这些网络规则允许从集群内部或外部的网络会话与 Pod 进行网络通信。

如果操作系统提供了数据包过滤层并可用的话，kube-proxy 会通过它来实现网络规则。否则， kube-proxy 仅转发流量本身。

Kubeadm创建集群

• 一台兼容的 Linux 主机。Kubernetes 项目为基于 Debian 和 Red Hat 的 Linux 发行版以及一些不提供包管理器的发行版提供通用的指令
• 每台机器 2 GB 或更多的 RAM （如果少于这个数字将会影响你应用的运行内存)
• 2 CPU 核或更多
• 集群中的所有机器的网络彼此均能相互连接(公网和内网都可以)
• • 设置防火墙放行规则
• 节点之中不可以有重复的主机名、MAC 地址或 product_uuid。请参见这里了解更多详细信息。
• • 设置不同hostname
• 开启机器上的某些端口。请参见这里 了解更多详细信息。
• • 内网互信
• 禁用交换分区。为了保证 kubelet 正常工作，你 必须 禁用交换分区。
• • 永久关闭

1.节点的创建

我这边使用公有云做演示，虚拟机也是可以的。

机器自行购买不做全部演示

注意事项

安全组需要自己创建或者修改

2.节点的docker容器安装

创建完后分别给3台机器重新命名，主节点：k8s-master，node节点：k8s-node1,k8s-node2。

时间同步配置

# crontab -l
0 */1 * * * /usr/sbin/ntpdate time1.aliyun.com

配置yum源

sudo yum install -y yum-utils    #添加yum工具
sudo yum-config-manager \
--add-repo \
http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
#添加阿里云镜像源

安装docker

yum install -y docker-ce docker-ce-cli containerd.io
#为了统一版本，建议执行该命令
yum install -y docker-ce-20.10.7 docker-ce-cli-20.10.7  containerd.io-1.4.6

启动docker

systemctl enable docker --now

配置加速

mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://82m9ar63.mirror.aliyuncs.com"],
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m"
  },
  "storage-driver": "overlay2"
}
EOF
systemctl daemon-reload
systemctl restart docker

3.配置K8s基础环境

# 将 SELinux 设置为 permissive 模式（相当于将其禁用）
sudo setenforce 0
sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config
#关闭swap
swapoff -a  
sed -ri 's/.*swap.*/#&/' /etc/fstab
#允许 iptables 检查桥接流量
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
br_netfilter
EOF
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward=1
EOF
sudo sysctl --system

安装kubelet、kubeadm、kubectl 三大件

cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=http://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=0
repo_gpgcheck=0
gpgkey=http://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg
   http://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
exclude=kubelet kubeadm kubectl
EOF
#配置国内镜像源
sudo yum install -y kubelet kubeadm kubectl --disableexcludes=kubernetes    #yum安装三大件
#统一版本：
sudo yum install -y kubelet-1.20.9 kubeadm-1.20.9 kubectl-1.20.9 --disableexcludes=kubernetes
sudo systemctl enable --now kubelet    #启动kubelet

kubelet必须设置自启，因为他会陷入等待kubeadm的死循环，会自动自启。

4.使用kubeadm引导集群

下载所需要的镜像

sudo tee ./images.sh <<-'EOF'
#!/bin/bash
images=(
kube-apiserver:v1.20.9
kube-proxy:v1.20.9
kube-controller-manager:v1.20.9
kube-scheduler:v1.20.9
coredns:1.7.0
etcd:3.4.13-0
pause:3.2
)
for imageName in ${images[@]} ; do
docker pull registry.cn-hangzhou.aliyuncs.com/lfy_k8s_images/$imageName
done
EOF
chmod +x ./images.sh && ./images.sh

初始化主节点

#所有机器添加master域名映射，以下需要修改为自己的
echo "master节点ip  cluster" >> /etc/hosts
#主节点初始化
kubeadm init \
--apiserver-advertise-address=192.168.218.158 \
--control-plane-endpoint=k8s1 \
--image-repository registry.cn-hangzhou.aliyuncs.com/lfy_k8s_images \
--kubernetes-version v1.20.9 \
--service-cidr=10.96.0.0/16 \
--pod-network-cidr=10.168.0.0/16
 kubeadm reset -f

出现以下界面就算是初始化主节点搭建成功了！！！！

#如果你不是root用户可以输入：
  mkdir -p $HOME/.kube
  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  sudo chown $(id -u):$(id -g) $HOME/.kube/config
#如果你是root用户直接输入
  export KUBECONFIG=/etc/kubernetes/admin.conf
kubeadm join 172.31.0.106:6443 --token zdhz0x.l2fuqut17zx5uxgr \
    --discovery-token-ca-cert-hash sha256:22277c0ed235af67b127efd34ae3104aadbfd3ff4f40d6683f37974cd09fb642
#这一段一定要记住！后面添加集群用。

常用命令

#查看集群所有节点
kubectl get nodes
#根据配置文件，给集群创建资源
kubectl apply -f xxxx.yaml
#查看集群部署了哪些应用？
docker ps   ===   kubectl get pods -A
# 运行中的应用在docker里面叫容器，在k8s里面叫Pod
kubectl get pods -A
#验证集群状态
kubectl get nodes
#创建新令牌
kubeadm token create --print-join-command

添加node节点

curl https://docs.projectcalico.org/manifests/calico.yaml -O    #下载网络工具calico
#如果主节点没有网络工具是无法添加node节点的！！！
kubectl apply -f calico.yaml    #安装calico工具
#在其他node节点中输入：
kubeadm join 172.31.0.106:6443 --token zdhz0x.l2fuqut17zx5uxgr \
    --discovery-token-ca-cert-hash sha256:22277c0ed235af67b127efd34ae3104aadbfd3ff4f40d6683f37974cd09fb642
#等待一会即可将节点加入

部署dashboard

官网：https://github.com/kubernetes/dashboard

kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/v2.3.1/aio/deploy/recommended.yaml    #下载dashboard配置文件

设置访问端口

kubectl edit svc kubernetes-dashboard -n kubernetes-dashboard    #查看配置文件
#type: ClusterIP 改为 type: NodePort
kubectl get svc -A |grep kubernetes-dashboard        #dashboard的端口会自动分配，所以我们通过命令查看，并且要在公有云中放行端口

此时就可以进入dashboard界面了

https://ip:32759 注意这里要用https哦！网站虽然能进入，但是我们无法登录

创建访问账号

vim dash.yaml        #创建配置文件
#将以下内容复制粘贴进去
apiVersion: v1
kind: ServiceAccount
metadata:
  name: admin-user
  namespace: kubernetes-dashboard
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: admin-user
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
- kind: ServiceAccount
  name: admin-user
  namespace: kubernetes-dashboard
#根据配置文件创建资源
kubectl apply -f dash.yaml

kubectl -n kubernetes-dashboard get secret $(kubectl -n kubernetes-dashboard get sa/admin-user -o jsonpath="{.secrets[0].name}") -o go-template="{{.data.token | base64decode}}"
#获取访问令牌 
eyJhbGciOiJSUzI1NiIsImtpZCI6Ik1yMU5qcnhYNnFRdHdMOVFJeEgxODdPX0VjLW9lZWNOWDJraW5sRWFMZTQifQ.eyJpc3MiOiJrdWJlcm5ldGVzL3NlcnZpY2VhY2NvdW50Iiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9uYW1lc3BhY2UiOiJrdWJlcm5ldGVzLWRhc2hib2FyZCIsImt1YmVybmV0ZXMuaW8vc2VydmljZWFjY291bnQvc2VjcmV0Lm5hbWUiOiJhZG1pbi11c2VyLXRva2VuLWY1amhiIiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9zZXJ2aWNlLWFjY291bnQubmFtZSI6ImFkbWluLXVzZXIiLCJrdWJlcm5ldGVzLmlvL3NlcnZpY2VhY2NvdW50L3NlcnZpY2UtYWNjb3VudC51aWQiOiIxNmJlMzUyYi02OGRkLTQ0ZjEtOTE0Yi1jMDJhZDhlNDJkNWEiLCJzdWIiOiJzeXN0ZW06c2VydmljZWFjY291bnQ6a3ViZXJuZXRlcy1kYXNoYm9hcmQ6YWRtaW4tdXNlciJ9.Tr4BD_a2MDQA2_i-4kMoPoP6jFCImlaRRHs2ajBIulfNBwVuokb-OlcO8lKW49c2Yc2G0-PuCYZ6KZ0LD3igsYi9wnA4fVRR47eQeYCctXOtWGcdThyHD64xarvGAaKjkl_bF48gaVXLIHxzYZa1hl5VbFy_4N8FNLIulwVSIjNr-m1X8I1V1YOa9gzuxnwngIbvy0Y6SikU8HsLx9020UyK6Pomh2IzlajzMCyz2z-hZ4s8HQRO2MTewfwFYlBw9RAWGldJnuFb46JAPHAPTJPD54yYgMd4QKd3xIB6tVjQjmBBqx0OcpNKQ7oNlsZKWLr6CLZGgIhITtoRMPC6eg

因为咱们是集群，所以用其他node节点的ip也可以访问哦！！！

NameSpace名称空间

名称空间隔离资源

比如说k8s中有一个普通环境和一个测试用环境。两个环境之间配置不相同，但是环境之间可以相互访问。

常用命令

kubectl get ns    #获取名称空间列表
kubectl get pods -A        #获取k8s中全部的应用
kubectl get pod -n kubernetes-dashboard        #指定名称空间查看
kubectl delete ns kubernetes-dashboard        #删除命名空间
kubectl create ns hello                        #创建名称空间

使用资源文件创建命名空间

vim hello.yaml    #创建资源文件
apiVersion: v1
kind: Namespace
metadata:
  name: hello
kubectl aplly -f hello.yaml        #允许资源文件

Pod

类似docker中的容器，但我们不叫它容器，叫它pod。Pod是k8s中最小应用单位。

k8s中会运行类似容器的服务，然后k8s会用Pod管理容器，当需要启动时，直接管理Pod即可。当然Pod中可以放入多个容器。把容器比作工人，Pod比作员工宿舍，k8s以宿舍为单位管理，宿舍东西坏了不影响其他宿舍。ipod懂吧！

kubectl get pod -A    #查看k8s中所有的pod
READY
1/1
1/1
#ready就是表示Pod中容器的数量和启动情况。1/1就是Pod中有1个容器，1个容器启动

• 每个pod，k8s都会设置内部ip，可以方便的访问到
• 同一个Pod共享网络和空间

用命令创建Pod容器

kubectl run mynginx --image=nginx        #创建容器,默认放在default名称空间
kubectl get pod -n default                #查看pod启动情况
kubectl delete pod mynginx -n default    #删除pod
kubectl logs -f mynginx                    #查看日志
kubectl get pod -owide                    #更详细的查看pod
kubectl exec -it mynginx -- /bin/bash    #进入到pod中容器的内部
kubectl desribe pod mynginx                #查看pod的描述文件
#通过查看Events事件，来判断都做了什么。并且部署到了一个节点后，其他节点中并没有部署的文件！

查看Events事件：

使用dashboard进入到容器内部：

用配置文件创建一个Pod容器

创建nginx容器
http://json2yaml.com/

apiVersion: v1
kind: Pod
metadata:    #元数据
  labels:
    run: mynginx
  name: mynginx    #Pod名称
  namespace: default    #名称空间 
spec:    #容器规范
  containers:
  - image: nginx
    name: mynginx

kubectl delete -f pod.yaml    #以配置文件来删除容器

一个Pod中创建多个容器

apiVersion: v1
kind: Pod
metadata:
  labels:
    run: myapp
  name: myapp
spec:
  containers:
  - image: nginx
    name: nginx
  - image: tomcat:8.5.68
    name: tomcat

Deployment

用来控制Pod，控制Pod创建多份。并且有自愈能力。

#创建一个普通的容器,myngxin
kubectl run mynginx --image=nginx
#用deployment创建部署一个容器,mytomcat
kubectl create deployment mytomcat --image=tomcat:8.5.68
kubectl create deployment nginx --image=nginx
#如果将这两个容器删除：kubectl delete pod  mynginx则会直接被删除 
#mytomcat则被删除后再开启一次服务,这个删除就类似服务器宕机,然后服务器会再次重启。
#暴露端口
kubectl expose deployment nginx --port=80 --type=NodePort
#查看服务
kubectl get pods
kubectl get svc(service)

想要真正的删除部署创建的容器，就不能用delete pod了，需要使用

kubectl delete deploy mytomcat

Deployment多副本能力

前面展示了自愈能力，现在展示一下多副本能力。

如果node1节点突然炸掉了，deploy会在其他节点上再创建等量的容器

kubectl create deploy my-dep --image=nginx --replicas=3
#创建一个部署，创建3份

所以之后在修改和创建时需要区分开哦！从Deployments中删除，3个Pod才会删除

从dashboard创建

用配置文件创建

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: my-dep
  name: my-dep
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-dep
  template:
    metadata:
      labels:
        app: my-dep
    spec:
      containers:
      - image: nginx
        name: nginx

Deployment扩容能力

比如最初就创建了3个部署，当流量高峰来临的时候，我们需要多添加一些部署容器。

我们称之为 扩容。当流量高峰过去后，我们减少容器数量，就叫 缩容。

kubectl scale deploy/mynginxs --replicas=6    #扩容一个
kubectl scale deploy/mynginxs --replicas=4    #缩容两个
#扩容和缩容命令实际上没什么区别，控制好变量即可。

我们也可以通过修改配置文件来扩容缩容

kubectl edit deploy mynginxs    #进入mynginxs部署的配置文件

在dashboard扩容缩容

Deployment自愈/故障转移

• 自愈：当部署多个Pod，其中一个Pod出现了报错等导致程序无法自动运行，此时K8s会对它进行重启，如果重启后Pod正常，则就是自愈。
• 故障转移：当某个集群突然宕机了，里面的Pod也就无法运行，此时K8s会再创建等量Pod到其他集群，保证部署稳定。故障转移的实施默认需要5分钟左右，因为难免有网络波动，为确保没有误判。

在查看Pod运行情况时，可以通过命令，实时关注Pod状态：

watch -n 1 kubectl get pod        #每秒显示一次kubectl get pod
kubectl get pod -w        #一直显示pod列表    这是官方自带的

Deployment滚动更新

执行一个老版本部署时，更新版本。会先创建并启动新Pod，老Pod会持续接收流量，当新版本Pod部署好了，老Pod会被杀掉。这是正常更新。滚动更新则部署一个新Pod，杀死一个老Pod，一个一个来。这样保证了新Pod出问题不影响老Pod，老Pod还能持续接收流量。

kubectl set image deploy/mynginxs mynginxs=nginx:1.16.1 --record
#设置mynginxs中的镜像，nginx的版本为1.16.1 record记录更新
mynginxs=nginx:1.16.1    #需要通过命令查看配置文件
kubectl edit deploy mynginxs
#前面的mynginxs是表示部署名，后面才是容器名

版本回退

kubectl rollout history deployment mynginxs        #查看部署更新历史
kubectl rollout undo deploy/mynginxs --to-revision=1    #回退版本
kubectl get deploy/mynginxs -oyaml    #直接查看部署的配置文件

工作负载小结

• 无状态服务——Deployment
  • 常用来部署微服务，提供多副本等功能。
  • 微服务：数据是存储在中间件里的，所以微服务只需要启动就好了
• 有状态副本集——StatefulSet
  • 常用来部署redis，mysql，提供稳定的存储，网络等
  • 用来部署内部存储数据的服务，mysql，redis。并且能提供固定的网络IP
• 守护进程集——DaemonSet
  • 常用来部署日志收集组件，并且每个机器只能运行一份
• 任务/定时任务——Job/CronJob
  • 常用来部署垃圾清理组件，用来指定时间运行

Service

Pod的服务发现与负载均衡。

deployment部署的服务会随机分配地址，如果服务被自愈，IP是会变换的，我们需要用Service服务来设置IP。

kubectl expose deploy mynginx --port=8000 --target-port=80 --type=ClusterIP
#设置暴露端口为8000，Pod端口为80，设置为只能在集群内部访问
kubectl get service    
#查看集群上的服务
kubectl get pod --show-labels
#查看pod上的标签
kubectl get pod -l app=mynginxs    
#使用标签检索Pod

#用配置文件创建网络服务
apiVersion: v1
kind: Service
metadata:
  labels:
    app: my-dep
  name: my-dep
spec:
  selector:
    app: my-dep
  ports:
  - port: 8000
    protocol: TCP
    targetPort: 80

在容器内部用域名访问：

服务名.所在名称空间.svc
mynginxs.defalut.svc

暴露NodePort方式

ClusterIP只能集群内网访问，如果想要公网访问，则需要NodePort方式。

kubectl expose deploy mynginxs --port=8100 --target-port=80 --type=NodePort        #暴露端口

Kubernetes上安装KubeSphere

master节点：4h8g

node节点：8h16g

安装步骤

• 4h8g的master，两个8h16g的node
• 安装Docker
• 安装kubernetes
• 安装KubeSphere前置环境
• 安装KubeSphere

1.搭建k8s，搭建集群

在目录：Kubeadm创建集群

安装docker，k8s三大件，网络插件等，按照前面的教程来，1:1完全一模一样。

2.KubeSphere前置环境

1.nfs系统

# 在每个机器。
yum install -y nfs-utils
# 在master 执行以下命令 
echo "/nfs/data/ *(insecure,rw,sync,no_root_squash)" > /etc/exports
# 在master 执行以下命令，启动 nfs 服务;创建共享目录
mkdir -p /nfs/data
# 在master执行
systemctl enable rpcbind
systemctl enable nfs-server
systemctl start rpcbind
systemctl start nfs-server
# 使配置生效
exportfs -r
#检查配置是否生效
exportfs

2.配置nfs-client 选做

在两个node节点

mkdir -p /nfs/data        #创建共享文件夹
mount -t nfs 114.115.238.123:/nfs/data /nfs/data        #挂载文件夹

3.设置默认 StorageClass

## 创建了一个存储类
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs-storage
  annotations:
    storageclass.kubernetes.io/is-default-class: "true"
provisioner: k8s-sigs.io/nfs-subdir-external-provisioner
parameters:
  archiveOnDelete: "true"  ## 删除pv的时候，pv的内容是否要备份
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nfs-client-provisioner
  labels:
    app: nfs-client-provisioner
  # replace with namespace where provisioner is deployed
  namespace: default
spec:
  replicas: 1
  strategy:
    type: Recreate
  selector:
    matchLabels:
      app: nfs-client-provisioner
  template:
    metadata:
      labels:
        app: nfs-client-provisioner
    spec:
      serviceAccountName: nfs-client-provisioner
      containers:
        - name: nfs-client-provisioner
          image: registry.cn-hangzhou.aliyuncs.com/lfy_k8s_images/nfs-subdir-external-provisioner:v4.0.2
          # resources:
          #    limits:
          #      cpu: 10m
          #    requests:
          #      cpu: 10m
          volumeMounts:
            - name: nfs-client-root
              mountPath: /persistentvolumes
          env:
            - name: PROVISIONER_NAME
              value: k8s-sigs.io/nfs-subdir-external-provisioner
            - name: NFS_SERVER
              value: 114.115.238.123 ## 指定自己nfs服务器地址
            - name: NFS_PATH  
              value: /nfs/data  ## nfs服务器共享的目录
      volumes:
        - name: nfs-client-root
          nfs:
            server: 114.115.238.123
            path: /nfs/data
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: nfs-client-provisioner
  # replace with namespace where provisioner is deployed
  namespace: default
---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: nfs-client-provisioner-runner
rules:
  - apiGroups: [""]
    resources: ["nodes"]
    verbs: ["get", "list", "watch"]
  - apiGroups: [""]
    resources: ["persistentvolumes"]
    verbs: ["get", "list", "watch", "create", "delete"]
  - apiGroups: [""]
    resources: ["persistentvolumeclaims"]
    verbs: ["get", "list", "watch", "update"]
  - apiGroups: ["storage.k8s.io"]
    resources: ["storageclasses"]
    verbs: ["get", "list", "watch"]
  - apiGroups: [""]
    resources: ["events"]
    verbs: ["create", "update", "patch"]
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: run-nfs-client-provisioner
subjects:
  - kind: ServiceAccount
    name: nfs-client-provisioner
    # replace with namespace where provisioner is deployed
    namespace: default
roleRef:
  kind: ClusterRole
  name: nfs-client-provisioner-runner
  apiGroup: rbac.authorization.k8s.io
---
kind: Role
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: leader-locking-nfs-client-provisioner
  # replace with namespace where provisioner is deployed
  namespace: default
rules:
  - apiGroups: [""]
    resources: ["endpoints"]
    verbs: ["get", "list", "watch", "create", "update", "patch"]
---
kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: leader-locking-nfs-client-provisioner
  # replace with namespace where provisioner is deployed
  namespace: default
subjects:
  - kind: ServiceAccount
    name: nfs-client-provisioner
    # replace with namespace where provisioner is deployed
    namespace: default
roleRef:
  kind: Role
  name: leader-locking-nfs-client-provisioner
  apiGroup: rbac.authorization.k8s.io

sysctl -w net.ipv4.ip_forward=1        #如果是虚拟机在node节点输入
kubectl apply -f sc.yaml            #启动服务
kubectl get sc                        #查看服务

4.开始安装

开始下载kubesphere配置文件进行安装，输入后就等待即可kubectl get pods -A

kubectl apply -f https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/kubesphere-installer.yaml
kubectl apply -f https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml
#建议使用wget获得yaml文件

检查安装日志

kubectl logs -n kubesphere-system $(kubectl get pod -n kubesphere-system -l app=ks-install -o jsonpath='{.items[0].metadata.name}') -f

最后出现：