耿雨飞的个人博客

[[ slide_text ]]

[[ item.c ]]

Kubernetes CKA认证考试

发布时间：2023-06-30 作者：gengyufei 来源：gengyufei个人博客

Kubernetes

# 官网(中文)
https://training.linuxfoundation.cn/certificates

# 参考wiki
备考 https://www.jianshu.com/p/aefa39c48e24

# 模拟试题
## 题目一、权限控制
### 考题
创建一个新的 clusterrole 并将其绑定到指定 namespace 的 serviceaccount。详情：

创建一个名为 deployment-clusterrole 并且只允许创建以下资源类型的新 clusterrole：
- Deployment
- StatefulSet
- DaemonSet
在现有的 namespace app-team1 中创建一个名为 cicd-token 的新 ServiceAccount，限于 namespace app-team1中，将新的 ClusterRole deployment-clusterrole 绑定到新的 ServiceAccount cicd-token。

### 解答
学会使用 -h :
```
kubectl create clusterrole -h
kubectl create serviceaccout -h 
kubectl create rolebinding -h
```

开始操作
```
kubectl create clusterrole deployment-clusterrole --verb=create --resource=deployments,statefulsets,daemonsets

kubectl -n app-team1 create serviceaccout cicd-token

# 题目中写了 ‘限于 namespace app-team1中’，则创建 rolebinding;没有写的话，则创建 clusterrolebinding。
kubectl -n app-team1 create rolebinding cicd-token-rolebinding \
--clusterrole=deployment-clusterrole \
--serviceaccout=app-team1:cicd-token

# 检查
kubectl -n app-team1 describe rolebinding cicd-token-rolebinding
```

## 题目二、查看top占用CPU的pod
### 考题
通过 pod label ```name=cpu-loader```, 找到运行时占用大量CPU的pod

### 解答
```
kubectl top pod -h
```

开始操作
```
kubectl top pod -l name=cpu-loader --sort-by=cpu -A
```

## 题目三、配置网络策略 NetworkPolicy
### 考题
在现有的namespace ```my-app``` 中创建一个名为 allow-port-from-namespace 的新 NetworkPolicy。
确保新的 NetworkPolicy 允许 namespace ```echo``` 中的 pods 连接到 namespace my-app 中的 pods的9000端口。

条件限制：
- 仅允许监听在端口9000的pods的访问
- 仅允许 echo 命名空间中的 pod 访问

### 解答
参考链接：https://kubernetes.io/zh-cn/docs/concepts/services-networking/network-policies/
> 这里需要提出：需要注意题目中的 echo 命名空间，到底是作为访问者还是被访问者。

```
# 1、首先，参考官方文档、拷贝yaml文件内容，然后根据题目要求进行相应的修改

# 2、开始操作
# 查看所有 ns 的标签 label
kubectl get ns --show-labels

# 如果访问者的 namespace 没有标签label，则需要手动打一个。如果有一个独特的标签label，则可以直接使用。
kubectl label ns echo project=echo

```

3、编写一个 yaml文件
> 注意：set paste， 防止yaml文件空格错序

```
vim networkpolicy.yaml

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-port-from-namespace
  namespace: my-app         # 被访问者的命名空间
spec:
  podSelector:              # 这两行必须要写，或者也可以写成一行为 podSelector: {}
    matchLabels: {}         # 注意 matchLabels:与{}之间有一个空格
  policyTypes:
    - Ingress               # 策略影响入栈流量
  ingress:
    - from:                 #允许流量的来源
        - namespaceSelector:
            matchLabels:
              project: echo # 访问者的命名空间的标签 label
        #- podSelector: {}  # 注意，这个不写。如果 ingress 里也写了- podSelector: {}，则会导致 my-app 中的 pod 可以访问 my-app 中 pod 的 9000 了，这样不
满足题目要求不允许非来自 namespace echo 中的 Pods 的访问。
      ports:
        - protocol: TCP
          port: 9000 #被访问者公开的端口

```

4、创建
```
kubectl apply -f networkpolicy.yaml
```

5、检查
```
kubectl describe networkpolicy -n my-app
```

## 题目四、暴露服务 service
### 考题
考点：将现有的deployment暴露成nodeport的service

请重新配置现有的deployment ```front-end```，并添加名为 ```http``` 的端口规范来公开现有容器 ```nginx```的端口 80/tcp。
创建一个名为 ```front-end-svc``` 的新service，以公开容器端口 ```http```。
配置此service，以通过各个pod所在的node上的NodePort来公开它们。

### 解答
参考链接：https://kubernetes.io/zh-cn/docs/concepts/workloads/controllers/deployment/

1、查看 deployment 信息
```
kubectl get deployment front-end -o wide
```

2、编辑 deployment
```
kubectl edit deployment front-end

# 更新后的内容：
apiVersion: apps/v1
kind: Deployment
metadata:
  name: front-end
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - image: vicuu/nginx:hello
        imagePullPolicy: IfNotPresent
        name: nginx
        ports:
        - name: http
          containerPort: 80
          protocol: TCP
```

3、暴露对应端口
```
kubectl expose deployment front-end \
--type=NodePort \
--port=80 \
--target-port=80 \
--name=front-end-svc
```
> --port 是service的端口号
--target-port 是deployment里pod的容器的端口号

4、暴露服务后，检查service的selector标签是否正确，这个要与deployment的selector标签一致
```
kubectl get svc front-end-svc -o wide
kubectl get deployment front-end -o wide
```
如果service的selector标签是none，则需要编辑此service：
```
kubectl edit svc front-end-svc

# 在ports下，增加selector标签
spec:
  ports:
  - nodePort: 32710
    port: 80
	protocol: TCP
	targetPort: 80
  selector:
    app: front-end
```

5、最后，curl检查
```
kubectl get pod,svc -o wide

# curl 所在的node ip:32710

curl 10.104.247.217:80	# 该ip为cluster ip

curl 192.168.40.10:32710  # 该ip为 node ip
```

## 题目五、创建 Ingress
### 考题
如下创建一个新的 Nginx ingress 资源：
名称：ping
命名空间：ing-internal
使用服务端口 5678 在路径 /hello 上公开服务 hello

检查服务可用性：
curl -kl <internal_ip>/hello

### 解答
参考链接：https://kubernetes.io/zh-cn/docs/concepts/services-networking/ingress/

```
# 拷贝官方的 yaml 案例，修改相关参数：
# 1. ingress class
vim ingressclass.yaml

apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
  labels:
    app.kubernetes.io/component: controller
  name: nginx
  annotations:
    ingressclass.kubernetes.io/is-default-class: "true"
spec:
  controller: k8s.io/ingress-nginx

# 2. ingress
vim ingress.yaml

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: ping
  namespace: ing-internal
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /    # 因为考试环境有多套，不确定具体抽中哪套。在 k8s-1.28 的考试里，先写上这行，若 apply 时报错需要指定域名，则注释掉该行再apply，就OK
spec:
  ingressClassName: nginx
  rules:
  - http:
      paths:
      - path: /hello
        pathType: Prefix
        backend:
          service:
            name: hello
            port:
              number: 5678

# 3.创建
kubectl apply -f ingressclass.yaml
kubectl apply -f ingress.yaml

# 4. 检查 curl
# 做完题后，略等3分钟再检查，否则可能还未获取ip地址
kubectl get ingress -n ing-internal
curl <ingress-ADDRESS>/hello
```

## 题目六、扩容 deployment 副本数量
### 考题
将 deployment presentation 扩展至 4个pods

### 解答
参考链接：没必要参考链接，使用 -h 更方便

```
# 1. 先检查现有的 pod 数量
kubectl get deployments presentation -o wide

kubectl get pod -l app=presentation

# 2. 扩展成4个
kubectl scale deployment presentation --replicas=4
```

## 题目七、调度pod到指定节点
### 考题
按如下要求调度一个pod:
- 名称：nginx-kusc00401
- image: nginx
- Node selector: disk=ssd

### 解答
参考链接：https://kubernetes.io/zh-cn/docs/tasks/configure-pod-container/assign-pods-nodes/

```
# 1. 检查是否有该pod，若无则需创建
kubectl get pod -A | grep nginx-kusc00401

# 2. 确保 node 有预期的label
kubectl get nodes --show-labels | grep 'disk=ssd'

# 若无则需手动配置
kubectl label node node-01 disk=ssd

# 3. 拷贝官方文档案例，修改下pod名称和镜像，删除多余部分即可
vim pod-disk-ssd.yaml

apiVersion: v1
kind: Pod
metadata:
  name: nginx-kusc00401
spec:
  containers:
  - name: nginx
    image: nginx
    imagePullPolicy: IfNotPresent
  nodeSelector:
    disk: ssd

# 4. 创建
kubectl apply -f pod-disk-ssd.yaml

# 5. 检查
kubectl get pod nginx-kusc00401 -o wide
```

## 题目八、查看可用节点数量
### 考题
检查有多少 nodes 已准备就绪（不包括被打上 Taint： NoSchedule 的节点），并将数量写入 ```/opt/KUSC00402/kusc00402.txt```。

### 解答
没必要参考链接，使用 -h

```
# 1. 查看共有多少ready状态的节点
kubectl get nodes

# 2. 查看几个node打了 Taint
kubectl describe nodes | grep -i Taints

# 3. 可用number = 总的ready状态的node数量 - 打了Taint的node数量
echo 'number' > /opt/KUSC00402/kusc00402.txt
```

## 题目九、创建多容器的 pod
### 考题
按如下要求调度一个pod:
- 名称：kucc8
- app container: 2
  - container 名称/image:
    - nginx
	- consul

### 解答
参考链接：https://kubernetes.io/zh-cn/docs/concepts/workloads/pods/

```
# 1. 创建pod yaml 文件
vim pod-kucc.yaml

apiVersion: v1
kind: Pod
metadata:
  name: kucc8
spec:
  containers:
  - name: nginx
    image: nginx
	imagePullPolicy: IfNotPresent
  - name: consul
    image: consul
	imagePullPolicy: IfNotPresent

# 2. 创建
kubectl apply -f pod-kucc.yaml

# 3. 检查
kubectl get pod kucc8
```

## 题目十、创建PV
### 考题
创建名为 app-config 的 persistent volume，容量为 1G，访问模式为 ReadWriteMany。
volume类型为 hostPath，位于 ```/srv/app-config```

### 解答
参考链接：https://kubernetes.io/zh-cn/docs/tasks/configure-pod-container/configure-persistent-volume-storage/

```
# 1. 拷贝官方案例
vim pv.yaml

apiVersion: v1
kind: PersistentVolume
metadata:
  name: app-config
spec:
  capacity:
    storage: 1Gi
  accessModes:
    - ReadWriteMany
  hostPath:
    path: "/srv/app-config"

# 2. 创建
kubectl apply -f pv.yaml

# 3. 检查
kubectl get pv
```

## 题目十一、创建PVC
### 考题
创建一个新的 PersistentVolumeClaim：
- 名称：pv-volume
- class: csi-hostpath-sc
- 容量：10MI

创建一个新的 Pod，来将 PersistentVolumeClaim 作为 volume 进行挂载：
- 名称：web-server
- Image：nginx:1.16
- 挂载路径：/usr/share/nginx/html

配置新的pod，以对 volume 具有 ReadWriteOnce 权限。

最后，使用 kubectl edit 或 kubectl patch 将 PersistentVolumeClaim 的容量扩展为 70 MI，并记录此更改。

### 解答
参考链接：https://kubernetes.io/zh-cn/docs/tasks/configure-pod-container/configure-persistent-volume-storage/

```
# 1. 根据官方文档，拷贝一个PVC配置
vim pvc.yaml

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pv-volume
spec:
  storageClassName: csi-hostpath-sc
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Mi

# 2. 创建 PVC
kubectl apply -f pvc.yaml

# 3. 检查 PVC
kubectl get pvc

# 4. 根据管饭文档，拷贝一个pod配置
vim pvc-pod.yaml

apiVersion: v1
kind: Pod
metadata:
  name: web-server
spec:
  volumes:
    - name: task-pv-storage
      persistentVolumeClaim:
        claimName: pv-volume
  containers:
    - name: task-pv-container
      image: nginx:1.16
      volumeMounts:
        - mountPath: "/usr/share/nginx/html"
          name: task-pv-storage

# 5. 创建
kubectl apply -f pvc-pod.yaml

# 6. 检查 pod
kubectl get pod web-server

# 7. 更改大小，并记录过程（--record）
kubectl edit pvc pv-volume --record
```

## 题目十二、查看 pod 日志
### 考题
监控 pod foo 的日志并：
- 提取 ```RLIMIT_NOFILE``` 相对应的日志行
- 将这些日志行写入 ```/opt/KUTR00101/foo```

### 解答
使用 -h

```
kubectl logs foo | grep "RLIMIT_NOFILE" > /opt/KUTR00101/foo
cat /opt/KUTR00101/foo
```

## 题目十三、使用 sidecar 代理容器日志
### 考题
> 将一个现有的 pod 集成到 Kubernetes 的内置日志记录体系结构中（例如：kubectl logs）, 添加 streaming sidecar 容器是实现此要求的一种好方法

使用 busybox image 来将名为 sidecar 容器添加到现有的pod ```11-factor-app``` 中，新的 sidecar 容器必须运行以下命令：
```
/bin/sh -c tail -n+1 -f /var/log/11-factor-app.log
```
使用挂载在 ```/var/log``` 的 volume，使日志文件 ```11-factor-app.log``` 可用于 sidecar 容器中。除了添加所需要的 volume mount 以外，请勿更改现有容器的规格。

> 翻译为白话：
- 添加一个名为 sidecar 的边车容器（使用 busybox 镜像）到已有的pod ```11-factor-app``` 中
- 确保 sidecar 容器能够 cat /var/log/11-factor-app.log 的信息
- 使用 volume 挂载 /var/log 目录，确保 sidecar 能访问 /var/log/11-factor-app.log 的信息

### 解答
参考链接：https://kubernetes.io/zh-cn/docs/concepts/cluster-administration/logging/

```
# 总体概述：
首先，备份原始pod的配置信息；
然后，删除旧的pod;
然后，copy一份新的 pod yaml 并添加一个名为 sidecar的容器；
然后，新建 emptyDir 的volume，确保两个容器都挂载了 /var/log 目录
最后，新建含有 sidecar的pod，并通过 kubectl logs 进行验证

# 1. 导出旧pod 信息
kubectl get pod 11-factor-app -o yaml > varlog.yaml

# 2. 备份yaml文件，便于回滚
cp varlog.yaml varlog-bak.yaml

# 3. 修改 varlog.yaml
vim varlog.yaml

apiVersion: v1
kind: Pod
metadata:
  name: 11-factor-app
spec:
  containers:
  - name: count
    image: busybox:1.28
    args:
    - /bin/sh
    - -c
    - >
      i=0;
      while true;
      do
        echo "$i: $(date)" >> /var/log/1.log;
        echo "$(date) INFO $i" >> /var/log/2.log;
        i=$((i+1));
        sleep 1;
      done      
    volumeMounts:
    - name: varlog
      mountPath: /var/log
  - name: sidecar
    image: busybox
    args: [/bin/sh, -c, 'tail -n+1 -F /var/log/11-factor-app.log']
    volumeMounts:
    - name: varlog
      mountPath: /var/log
  volumes:
  - name: varlog
    emptyDir: {}

# 3. 删除原先的pod，需等待大约2分钟，期间不要 Ctrl + C 终止
kubectl delete pod 11-factor-app

# 4. 检查是否删除成功
kubectl get pod 11-factor-app

# 5. 新建pod
kubectl apply -f varlog.yaml

# 6. 检查新pod是否创建成功
kubectl get pod 11-factor-app

# 7. 查看日志
kubectl logs 11-factor-app sidecar
# kubectl exec 11-factor-app -c sidecar -- tail -f /var/log/11-factor-app.log
# kubectl exec 11-factor-app -c count -- tail -f /var/log/11-factor-app.log

```

## 题目十四、升级集群
### 考题
现有的 Kubernetes 集群正在运行版本 1.28.0.仅将master节点上的所有Kubernetes控制平面和节点组件升级到 1.28.1.
确保在升级之前 drain master 节点，并在升级后 uncordon master 节点。
可以使用 ```ssh master01``` 连接到master节点；
可以使用 ```sudo -i``` 获取更高权限。
另外，在主节点上升级 kubelet 和 kubectl。
请不要升级工作节点，etcd，container 管理器，CNI插件，DNS服务或任何其他插件。

考点：如何 "离线" master节点，并升级控制平面及升级节点

### 解答
参考链接：https://kubernetes.io/zh-cn/docs/tasks/administer-cluster/kubeadm/kubeadm-upgrade/
没必要参考网址，建议多练习，背过命令即可。要善于使用 kubectl -h

```
# 1. 查看集群节点信息
kubectl get nodes

# 2. 驱逐master01
# cordon 停止调度，将 node 调为 SchedulingDisabled。新的pod不会调度到该 node，但在该node的旧pod不受影响。
# drain 驱逐节点，首先驱逐该node上的pod，并在其他节点重新创建。接着，将节点调为 SchedulingDisabled。

kubectl cordon master01
kubectl drain master01 --ignore-daemonsets

# 3. 升级版本
apt-get update
apt-cache show kubeadm | grep 1.28.1
apt-get install kubeadm=1.28.1-00

# 4. 检查升级版本
kubeadm version

# 5. 验证升级计划
kubeadm upgrade plan

# 6. 执行升级操作，排除 etcd
kubeadm upgrade apply v1.28.1 --etcd-upgrade=false

# 7. 升级 kubelet
apt-get install kubelet=1.28.1-00
kubelet --version

# 8. 升级 kubectl
apt-get install kubectl=1.28.1-00
kubectl version

# 9. 退出root && 退出 master01
exit
exit

# 10. 恢复 master01 调度
kubectl uncordon master01

# 11. 检查master01是否为ready状态
kubectl get nodes
```

## 题目十五、备份还原 etcd
### 考题
首先，为运行在 https://11.0.1.111:2379 上的现有 etcd 实例创建快照并将快照保存到 /var/lib/backup/etcd-snapshot.db
（注意，真实考试中，这里写的是 https://127.0.0.1:2379）
为给定实例创建快照预计能在几秒钟内完成。 如果该操作似乎挂起，则命令可能有问题。用 CTRL + C 来取消操作，然后重试。

然后还原位于/data/backup/etcd-snapshot-previous.db 的现有先前快照。

提供了以下 TLS 证书和密钥，以通过 etcdctl 连接到服务器：
- CA 证书: /opt/KUIN00601/ca.crt
- 客户端证书: /opt/KUIN00601/etcd-client.crt
- 客户端密钥: /opt/KUIN00601/etcd-client.key

### 解答
没必要参考网址，建议多练习，背过命令就行，善用 etcdctl -h.
参考链接：
https://kubernetes.io/zh-cn/docs/tasks/administer-cluster/configure-upgrade-etcd/

**方法一、（推荐）做法**
```
## 备份
export ETCDCTL_API=3
etcdctl --endpoints=https://11.0.1.111:2379 \
--cacert="/opt/KUIN00601/ca.crt" \
--cert="/opt/KUIN00601/etcd-client.crt" \
--key="/opt/KUIN00601/etcd-client.key" \
snapshot save /var/lib/backup/etcd-snapshot.db

## 检查操作
etcdctl snapshot status /var/lib/backup/etcd-snapshot.db -wtable

## 还原
sudo  ETCDCTL_API=3  etcdctl  \
--endpoints=https://11.0.1.111:2379  \
--cacert="/opt/KUIN00601/ca.crt"  \
--cert="/opt/KUIN00601/etcd-client.crt"  \
--key="/opt/KUIN00601/etcd-client.key" \
snapshot restore /data/backup/etcd-snapshot-previous.db
```

**方法二、etcd作为systemd服务**
（建议了解 K8S 原理的这么做，但前提是 etcd 使用的是 systemd 服务，而不是 etcd pod。）
（真实考试时，使用的是 systemd 服务的。但模拟环境使用的是 etcd pod。无法在模拟环境模拟练习这道题的。）
> 前提，就是 etcd 使用的是 systemd 服务，而不是 etcd 容器。

1.22 和 1.23 的考试里，有人反馈 etcd 是服务，有人反馈 etcd 是 pod。我怀疑 CKA 可能有多套考试环境，所以你做的时候，需要确认是否为 etcd 服务

```
# 备份
export ETCDCTL_API=3
etcdctl --endpoints=https://11.0.1.111:2379 \
--cacert="/opt/KUIN00601/ca.crt" \
--cert="/opt/KUIN00601/etcd-client.crt" \
--key="/opt/KUIN00601/etcd-client.key" \
snapshot save /var/lib/backup/etcd-snapshot.db

# 检查
etcdctl snapshot status /var/lib/backup/etcd-snapshot.db -wtable

# 还原
## 1. 先检查一下考试环境，使用的 etcd 是服务还是容器。
kubectl get pod -A

## 如果是 systemd 服务，则继续往下操作
sudo systemctl status etcd

## 2. 确认 etcd 数据目录 (--data-dir 值, 一般默认为/var/lib/etcd)
ps -ef | grep etcd

## 3. 停止etcd服务
sudo systemctl stop etcd

## 4. 先备份etcd原目录
sudo mv /var/lib/etcd /var/lib/etcd.bak

## 5. 开始还原（还原时，可以不加证书和秘钥）
sudo ETCDCTL_API=3 etcdctl \
--data-dir=/var/lib/etcd \
snapshot restore /data/backup/etcd-snapshot-previous.db

## 6. 更改文件属主
sudo chown -R etcd:etcd /var/lib/etcd

## 7. 启动etcd服务
sudo systemctl start etcd
```

**方法三、etcd作为pod**

# 检查
etcdctl snapshot status /var/lib/backup/etcd-snapshot.db -wtable

# 还原
## 移除且备份 /etc/kubernetes/manifests 目录
sudo mv /etc/kubernetes/manifests /etc/kubernetes/manifests.bak

## 查看 kube-apiserver、etcd 镜像是否停止
crictl ps|grep etcd && crictl ps|grep kube-apiserver

## 备份现有 Etcd 数据
sudo mv /var/lib/etcd /var/lib/etcd.bak

## 开始还原（还原时，可以不加证书和秘钥）
sudo  ETCDCTL_API=3  etcdctl  --endpoints=https://127.0.0.1:2379  \
--cacert="/opt/KUIN00601/ca.crt"  \
--cert="/opt/KUIN00601/etcd-client.crt"  \
--key="/opt/KUIN00601/etcd-client.key" \
 --data-dir=/var/lib/etcd/ \
snapshot restore /data/backup/etcd-snapshot-previous.db

## 恢复 Kube-Apiserver 与 Etcd 镜像
sudo mv /etc/kubernetes/manifests.bak /etc/kubernetes/manifests

## 稍等 3 分钟，再检查 pod
kubectl get pod -A
```

## 题目十六、排查集群中的故障节点
### 考题
名为 node02 的 Kubernetes worker node 处于 NotReady 状态。
调查发生这种情况的原因，并采取相应的措施将 node 恢复为 Ready 状态，确保所做的任何更改永久生效。

可以使用以下命令，通过 ssh 连接到 node02 节点：
ssh node02
可以使用以下命令，在该节点上获取更高权限：
sudo -i

### 解答
没必要参考链接

```
# 1. 检查node
kubectl get nodes

# 2. 登录异常节点node02
ssh node02
sudo -i

# 3. 检查 kubelet 服务 (会发现 kubelet 服务状态 inactive)
systemctl status kubelet

# 4. 启动服务 并 设置为开机启动
systemctl start kubelet && systemctl enable kubelet

# 5. 检查
systemctl status kubelet
kubectl get nodes
```

## 题目十七、节点维护
### 考题
将名为 node02 的 node 设置为不可用，并重新调度该 node 上所有运行的 pods。

### 解答

```
# 1. 查看node
kubectl get nodes

# 2. 停止调度
kubectl cordon node02

# 3. 驱逐pod
kubectl drain node02 --ignore-daemonsets

## 注意：还有一个参数--delete-emptydir-data --force，这个考试时不用加，就可以正常 draini node02 的。
# 但如果执行后，有跟测试环境一样的报错（如下截图），则需要加上--delete-emptydir-data --force，会强制将 pod 移除。
# kubectl drain node02 --ignore-daemonsets --delete-emptydir-data --force

# 4.检查
kubectl get nodes

kubectl get pod -A -o wide | grep node02
```

上一篇：Kubernetes 通过kubeadm安装高可用集群下一篇：Nginx 参考资料

你觉得文章怎么样