Kubernetes-文档

1.教程

1.1.安装minikube

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-latest.x86_64.rpm
rpm -Uvh minikube-latest.x86_64.rpm
yum install -y kubectl
-查看版本的详细信息：
kubectl version --client
-配置命令自动补全
yum install -y bash-completion
source /usr/share/bash-completion/bash_completion
echo "source <(kubectl completion bash)" >> ~/.bashrc

1.2.创建 Minikube 集群

minikube start
-打开 Kubernetes 仪表板
minikube dashboard

1.3.创建 Deployment

Kubernetes Pod 是由一个或多个为了管理和联网而绑定在一起的容器构成的组。本教程中的 Pod 只有一个容器。 Kubernetes Deployment 检查 Pod 的健康状况，并在 Pod 中的容器终止的情况下重新启动新的容器。 Deployment 是管理 Pod 创建和扩展的推荐方法。

1.3.1.使用 kubectl create 命令创建管理 Pod 的 Deployment。

该 Pod 根据提供的 Docker 镜像运行容器。
-运行包含 Web 服务器的测试容器镜像

kubectl create deployment hello-node --image=registry.k8s.io/e2e-test-images/agnhost:2.39 -- /agnhost netexec --http-port=808

1.3.2.查看 Deployment

kubectl get deployments
-输出结果类似于这样
NAME         READY   UP-TO-DATE   AVAILABLE   AGE
hello-node   1/1     1            1           1m

1.3.3.查看 Pod：

kubectl get pods
-输出结果类似于这样：
NAME                          READY     STATUS    RESTARTS   AGE
hello-node-5f76cf6ccf-br9b5   1/1       Running   0          1m

1.3.4.查看集群事件：

kubectl get events

1.3.5.查看 kubectl 配置：

kubectl config view

1.4.创建 Service

默认情况下，Pod 只能通过 Kubernetes 集群中的内部 IP 地址访问。 要使得 hello-node 容器可以从 Kubernetes 虚拟网络的外部访问，你必须将 Pod 暴露为 Kubernetes Service。

1.4.1.使用 kubectl expose 命令将 Pod 暴露给公网

kubectl expose deployment hello-node --type=LoadBalancer --port=8080

-这里的 --type=LoadBalancer 参数表明你希望将你的 Service 暴露到集群外部。
-测试镜像中的应用程序代码仅监听 TCP 8080 端口。 如果你用 kubectl expose 暴露了其它的端口，客户端将不能访问其它端口。

1.4.2.查看你创建的 Service：

kubectl get services
-输出结果类似于这样:
NAME         TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
hello-node   LoadBalancer   10.108.144.78   <pending>     8080:30369/TCP   21s
kubernetes   ClusterIP      10.96.0.1       <none>        443/TCP 

对于支持负载均衡器的云服务平台而言，平台将提供一个外部 IP 来访问该服务。 在 Minikube 上，LoadBalancer 使得服务可以通过命令 minikube service 访问。

1.4.3.运行下面的命令, 这将打开一个浏览器窗口，为你的应用程序提供服务并显示应用的响应。

minikube service hello-node

1.5.启用插件

Minikube 有一组内置的插件， 可以在本地 Kubernetes 环境中启用、禁用和打开。

1.5.1.列出当前支持的插件：

minikube addons list
-输出结果类似于这样：
addon-manager: enabled
dashboard: enabled
default-storageclass: enabled
efk: disabled
freshpod: disabled
gvisor: disabled
helm-tiller: disabled
ingress: disabled
ingress-dns: disabled
logviewer: disabled
metrics-server: disabled
nvidia-driver-installer: disabled
nvidia-gpu-device-plugin: disabled
registry: disabled
registry-creds: disabled
storage-provisioner: enabled
storage-provisioner-gluster: disabled

1.5.2.启用插件

例如 metrics-server：

minikube addons enable metrics-server
-输出结果类似于这样：
The 'metrics-server' addon is enabled

1.5.3.查看通过安装该插件所创建的 Pod 和 Service：

kubectl get pod,svc -n kube-system
-输出结果类似于这样：
NAME                                        READY     STATUS    RESTARTS   AGE
pod/coredns-5644d7b6d9-mh9ll                1/1       Running   0          34m
pod/coredns-5644d7b6d9-pqd2t                1/1       Running   0          34m
pod/metrics-server-67fb648c5                1/1       Running   0          26s
pod/etcd-minikube                           1/1       Running   0          34m
pod/influxdb-grafana-b29w8                  2/2       Running   0          26s
pod/kube-addon-manager-minikube             1/1       Running   0          34m
pod/kube-apiserver-minikube                 1/1       Running   0          34m
pod/kube-controller-manager-minikube        1/1       Running   0          34m
pod/kube-proxy-rnlps                        1/1       Running   0          34m
pod/kube-scheduler-minikube                 1/1       Running   0          34m
pod/storage-provisioner                     1/1       Running   0          34m

NAME                           TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)             AGE
service/metrics-server         ClusterIP   10.96.241.45    <none>        80/TCP              26s
service/kube-dns               ClusterIP   10.96.0.10      <none>        53/UDP,53/TCP       34m
service/monitoring-grafana     NodePort    10.99.24.54     <none>        80:30002/TCP        26s
service/monitoring-influxdb    ClusterIP   10.111.169.94   <none>        8083/TCP,8086/TCP   26s

1.5.4.禁用 metrics-server：

minikube addons disable metrics-server
-输出结果类似于这样：
metrics-server was successfully disabled

1.6.清理

现在可以清理你在集群中创建的资源：

kubectl delete service hello-node
kubectl delete deployment hello-node
-停止 Minikube 集群：
minikube stop
-可选地，删除 Minikube 虚拟机（VM）：
minikube delete

1.7.接下来

进一步了解 Deployment 对象。
进一步了解部署应用。
进一步了解 Service 对象。

2.k8s-基础知识

2.1.创建集群

-使用 Minikube 创建集群, 部署一个应用
让我们使用 kubectl create deployment 命令在 Kubernetes 上部署第一个应用。 我们需要提供 Deployment 命令以及应用镜像位置（包括托管在 Docker hub 之外的镜像的完整仓库地址）。

kubectl create deployment kubernetes-bootcamp --image=gcr.io/google-samples/kubernetes-bootcamp:v1

很好！你刚刚通过创建 Deployment 部署了第一个应用。这个过程中执行了以下一些操作：
搜索应用实例可以运行的合适节点（我们只有一个可用的节点）
调度应用在此节点上运行
配置集群在需要时将实例重新调度到新的节点上

-列出你的 Deployment
kubectl get deployments

2.2.了解你的应用

-查看 Pod 和节点

2.2.1.Kubernetes Pod

Pod 是 Kubernetes 抽象出来的， 表示一组一个或多个应用容器（如 Docker），以及这些容器的一些共享资源。这些资源包括:
共享存储，当作卷
网络，作为唯一的集群 IP 地址
有关每个容器如何运行的信息，例如容器镜像版本或要使用的特定端口

2.2.2.节点

Pod 总是运行在节点上。节点是 Kubernetes 中参与计算的机器，可以是虚拟机或物理计算机，具体取决于集群。 每个节点由控制面管理。节点可以有多个 Pod，Kubernetes 控制面会自动处理在集群中的节点上调度 Pod。 控制面的自动调度考量了每个节点上的可用资源。

-每个 Kubernetes 节点至少运行：
Kubelet，负责 Kubernetes 控制面和节点之间通信的进程；它管理机器上运行的 Pod 和容器。
容器运行时（如 Docker）负责从镜像仓库中提取容器镜像、解压缩容器以及运行应用。

2.2.3.使用 kubectl 进行故障排除

kubectl get - 列出资源
kubectl describe - 显示有关资源的详细信息
kubectl logs - 打印 Pod 中容器的日志
kubectl exec - 在 Pod 中的容器上执行命令

2.3.公开地暴露你的应用

Kubernetes 中的服务(Service)是一种抽象概念，它定义了 Pod 的逻辑集和访问 Pod 的协议。Service 使从属 Pod 之间的松耦合成为可能。 和其他 Kubernetes 对象一样, Service 用 YAML (更推荐) 或者 JSON 来定义. Service 下的一组 Pod 通常由 LabelSelector (请参阅下面的说明为什么你可能想要一个 spec 中不包含selector的服务)来标记。

尽管每个 Pod 都有一个唯一的 IP 地址，但是如果没有 Service ，这些 IP 不会暴露在集群外部。Service 允许你的应用程序接收流量。Service 也可以用在 ServiceSpec 标记type的方式暴露。

ClusterIP (默认) - 在集群的内部 IP 上公开 Service 。这种类型使得 Service 只能从集群内访问。
NodePort - 使用 NAT 在集群中每个选定 Node 的相同端口上公开 Service 。使用< NodeIP>:< NodePort> 从集群外部访问 Service。是 ClusterIP 的超集。
LoadBalancer - 在当前云中创建一个外部负载均衡器(如果支持的话)，并为 Service 分配一个固定的外部IP。是 NodePort 的超集。
ExternalName - 通过返回带有该名称的 CNAME 记录，使用任意名称(由 spec 中的externalName指定)公开 Service。不使用代理。这种类型需要kube-dns的v1.7或更高版本。

2.4.扩缩你的应用

在之前的模块中，我们创建了一个 Deployment，然后通过 Service让其可以开放访问。Deployment 仅为跑这个应用程序创建了一个 Pod。 当流量增加时，我们需要扩容应用程序满足用户需求。
扩缩 是通过改变 Deployment 中的副本数量来实现的。

2.5.更新你的应用

kubectl apply -f example-redis-config.yaml

3.使用 ConfigMap 来配置 Redis

首先创建一个配置模块为空的 ConfigMap：

cat <<EOF >./example-redis-config.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: example-redis-config
data:
  redis-config: ""
EOF

应用上面创建的 ConfigMap 以及 Redis pod 清单：

kubectl apply -f example-redis-config.yaml
kubectl apply -f https://raw.githubusercontent.com/kubernetes/website/main/content/en/examples/pods/config/redis-pod.yaml

检查 Redis pod 清单的内容，并注意以下几点：
由 spec.volumes[1] 创建一个名为 config 的卷。
spec.volumes[1].items[0] 下的 key 和 path 会将来自 example-redis-config ConfigMap 中的 redis-config 密钥公开在 config 卷上一个名为 redis.conf 的文件中。
然后 config 卷被 spec.containers[0].volumeMounts[1] 挂载在 /redis-master。
这样做的最终效果是将上面 example-redis-config 配置中 data.redis-config 的数据作为 Pod 中的 /redis-master/redis.conf 公开。

cat  pods/config/redis-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  name: redis
spec:
  containers:
  - name: redis
    image: redis:5.0.4
    command:
      - redis-server
      - "/redis-master/redis.conf"
    env:
    - name: MASTER
      value: "true"
    ports:
    - containerPort: 6379
    resources:
      limits:
        cpu: "0.1"
    volumeMounts:
    - mountPath: /redis-master-data
      name: data
    - mountPath: /redis-master
      name: config
  volumes:
    - name: data
      emptyDir: {}
    - name: config
      configMap:
        name: example-redis-config
        items:
        - key: redis-config
          path: redis.conf

-检查创建的对象：
kubectl get pod/redis configmap/example-redis-config 
你应该可以看到以下输出：
NAME        READY   STATUS    RESTARTS   AGE
pod/redis   1/1     Running   0          8s
NAME                             DATA   AGE
configmap/example-redis-config   1      14s

回顾一下，我们在 example-redis-config ConfigMap 保留了空的 redis-config 键：
kubectl describe configmap/example-redis-config
你应该可以看到一个空的 redis-config 键：
Name: example-redis-config
Namespace: default
Labels: < none>
Annotations: < none>
Data

redis-config:

使用 kubectl exec 进入 pod，运行 redis-cli 工具检查当前配置：
kubectl exec -it redis -- redis-cli
查看 maxmemory：
127.0.0.1:6379> CONFIG GET maxmemory
它应该显示默认值 0：
1) "maxmemory"
2) "0"
同样，查看 maxmemory-policy：
127.0.0.1:6379> CONFIG GET maxmemory-policy
它也应该显示默认值 noeviction：
1) "maxmemory-policy"
2) "noeviction"

现在，向 example-redis-config ConfigMap 添加一些配置：

cat  pods/config/example-redis-config.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: example-redis-config
data:
  redis-config: |
    maxmemory 2mb
    maxmemory-policy allkeys-lru

应用更新的 ConfigMap:

kubectl apply -f example-redis-config.yaml

确认 ConfigMap 已更新：

kubectl describe configmap/example-redis-config

你应该可以看到我们刚刚添加的配置：

Name:         example-redis-config
Namespace:    default
Labels:       <none>
Annotations:  <none>
Data
====
redis-config:
---
maxmemory 2mb
maxmemory-policy allkeys-lru

通过 kubectl exec 使用 redis-cli 再次检查 Redis Pod，查看是否已应用配置：
kubectl exec -it redis -- redis-cli

查看 maxmemory：

127.0.0.1:6379> CONFIG GET maxmemory

它保持默认值 0：

1. "maxmemory"
2. "0"

同样，maxmemory-policy 保留为默认设置 noeviction：

127.0.0.1:6379> CONFIG GET maxmemory-policy

返回：

1. "maxmemory-policy"
2. "noeviction"

配置值未更改，因为需要重新启动 Pod 才能从关联的 ConfigMap 中获取更新的值。 让我们删除并重新创建 Pod：

kubectl delete pod redis
kubectl apply -f https://raw.githubusercontent.com/kubernetes/website/main/content/en/examples/pods/config/redis-pod.yaml

现在，最后一次重新检查配置值：

kubectl exec -it redis -- redis-cli
查看 maxmemory：
127.0.0.1:6379> CONFIG GET maxmemory
现在，它应该返回更新后的值 2097152：
1) "maxmemory"
2) "2097152"
同样，maxmemory-policy 也已更新：
127.0.0.1:6379> CONFIG GET maxmemory-policy
现在它反映了期望值 allkeys-lru：
1) "maxmemory-policy"
2) "allkeys-lru"
删除创建的资源，清理你的工作：
kubectl delete pod/redis configmap/example-redis-config

4.无状态的应用

-为一个在五个 pod 中运行的应用程序创建服务

4.1.在集群中运行 Hello World 应用程序：

cat  service/load-balancer-example.yaml
apiVersion: apps/v1
   kind: Deployment
   metadata:
     labels:
       app.kubernetes.io/name: load-balancer-example
     name: hello-world
   spec:
     replicas: 5
     selector:
       matchLabels:
         app.kubernetes.io/name: load-balancer-example
     template:
       metadata:
         labels:
           app.kubernetes.io/name: load-balancer-example
       spec:
         containers:
         - image: gcr.io/google-samples/node-hello:1.0
           name: hello-world
           ports:
           - containerPort: 8080

kubectl apply -f https://k8s.io/examples/service/load-balancer-example.yaml

前面的命令创建一个 Deployment 对象和一个关联的 ReplicaSet 对象。 ReplicaSet 有五个 Pod， 每个都运行 Hello World 应用程序。

4.2.显示有关 Deployment 的信息：

kubectl get deployments hello-world
kubectl describe deployments hello-world

4.3.显示有关 ReplicaSet 对象的信息：

kubectl get replicasets
kubectl describe replicasets

4.4.创建公开 Deployment 的 Service 对象：

kubectl expose deployment hello-world --type=LoadBalancer --name=my-service

4.5.显示有关 Service 的信息：

kubectl get services my-service
输出类似于：
NAME         TYPE           CLUSTER-IP     EXTERNAL-IP      PORT(S)    AGE
my-service   LoadBalancer   10.3.245.137   104.198.205.71   8080/TCP   54s

4.6.显示有关 Service 的详细信息：

kubectl describe services my-service

输出类似于：

Name:           my-service
Namespace:      default
Labels:         app.kubernetes.io/name=load-balancer-example
Annotations:    <none>
Selector:       app.kubernetes.io/name=load-balancer-example
Type:           LoadBalancer
IP:             10.3.245.137
LoadBalancer Ingress:   104.198.205.71
Port:           <unset> 8080/TCP
NodePort:       <unset> 32377/TCP
Endpoints:      10.0.0.6:8080,10.0.1.6:8080,10.0.1.7:8080 + 2 more...
Session Affinity:   None
Events:         <none>

记下服务公开的外部 IP 地址（LoadBalancer Ingress）。 在本例中，外部 IP 地址是 104.198.205.71。还要注意 Port 和 NodePort 的值。 在本例中，Port 是 8080，NodePort 是 32377。

4.7.验证这些是 Pod 地址

在前面的输出中，你可以看到服务有几个端点： 10.0.0.6:8080、10.0.1.6:8080、10.0.1.7:8080 和另外两个， 这些都是正在运行 Hello World 应用程序的 Pod 的内部地址。

kubectl get pods --output=wide

输出类似于：

NAME                         ...  IP         NODE
hello-world-2895499144-1jaz9 ...  10.0.1.6   gke-cluster-1-default-pool-e0b8d269-1afc
hello-world-2895499144-2e5uh ...  10.0.1.8   gke-cluster-1-default-pool-e0b8d269-1afc
hello-world-2895499144-9m4h1 ...  10.0.0.6   gke-cluster-1-default-pool-e0b8d269-5v7a
hello-world-2895499144-o4z13 ...  10.0.1.7   gke-cluster-1-default-pool-e0b8d269-1afc
hello-world-2895499144-segjf ...  10.0.2.5   gke-cluster-1-default-pool-e0b8d269-cpuc

4.8.使用外部 IP 地址（LoadBalancer Ingress）访问 Hello World 应用程序

curl http://<external-ip>:<port>

其中 < external-ip> 是你的服务的外部 IP 地址（LoadBalancer Ingress）， < port> 是你的服务描述中的 port 的值。 如果你正在使用 minikube，输入 minikube service my-service 将在浏览器中自动打开 Hello World 应用程序。

4.9.清理现场

-要删除 Service
kubectl delete services my-service
-要删除正在运行 Hello World 应用程序的 Deployment、ReplicaSet 和 Pod
kubectl delete deployment hello-world

5.有状态的应用

-如何使用 StatefulSet 来管理应用。 演示了如何创建、删除、扩容/缩容和更新 StatefulSet 的 Pod

5.1.创建 StatefulSet

cat  application/web/web.yaml
apiVersion: v1
kind: Service
metadata:
  name: nginx
  labels:
    app: nginx
spec:
  ports:
  - port: 80
    name: web
  clusterIP: None
  selector:
    app: nginx
--
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: web
spec:
  serviceName: "nginx"
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: registry.k8s.io/nginx-slim:0.8
        ports:
        - containerPort: 80
          name: web
        volumeMounts:
        - name: www
          mountPath: /usr/share/nginx/html
  volumeClaimTemplates:
  - metadata:
      name: www
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 1Gi

你需要使用两个终端窗口。在第一个终端中，使用 kubectl get 来监视 StatefulSet 的 Pod 的创建情况。

kubectl get pods -w -l app=nginx

在另一个终端中，使用 kubectl apply 来创建定义在 web.yaml 中的 Headless Service 和 StatefulSet。

kubectl apply -f web.yaml
service/nginx created
statefulset.apps/web created

上面的命令创建了两个 Pod，每个都运行了一个 NginX Web 服务器。 获取 nginx Service：

kubectl get service nginx
NAME      TYPE         CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
nginx     ClusterIP    None         none       80/TCP    12s
然后获取 web StatefulSet，以验证两者均已成功创建：
kubectl get statefulset web
NAME      DESIRED   CURRENT   AGE
web       2         1         20s

5.2.顺序创建 Pod

对于一个拥有 n 个副本的 StatefulSet，Pod 被部署时是按照 {0..n-1} 的序号顺序创建的。 在第一个终端中使用 kubectl get 检查输出。这个输出最终将看起来像下面的样子。

kubectl get pods -w -l app=nginx

直到 web-0 Pod 处于 Running（请参阅 Pod 阶段） 并 Ready（请参阅 Pod 状况中的 type）状态后，web-1 Pod 才会被启动。

5.3.检查 Pod 的顺序索引

格式为 <statefulset .名称>-<序号索引>。
web StatefulSet 拥有两个副本，所以它创建了两个 Pod：web-0 和 web-1。

5.4.使用稳定的网络身份标识

5.4.1.使用 kubectl exec 在每个 Pod 中执行 hostname

for i in 0 1; do kubectl exec "web-$i" -- sh -c 'hostname'; done

5.4.2.通过对 Pod 的主机名执行 nslookup，你可以检查这些主机名在集群内部的 DNS 地址

kubectl run -i --tty --image busybox:1.28 dns-test --restart=Never --rm
nslookup web-0.nginx

5.4.3.删除 StatefulSet 中所有的 Pod：

kubectl delete pod -l app=nginx

5.4.4.写入稳定的存储

获取 web-0 和 web-1 的 PersistentVolumeClaims

kubectl get pvc -l app=nginx
NAME        STATUS    VOLUME                                     CAPACITY   ACCESSMODES   AGE
www-web-0   Bound     pvc-15c268c7-b507-11e6-932f-42010a800002   1Gi        RWO           48s
www-web-1   Bound     pvc-15c79307-b507-11e6-932f-42010a800002   1Gi        RWO           48s

5.4.5.扩容/缩容 StatefulSet

-扩展副本数为 5：
kubectl scale sts web --replicas=5
-缩容回三个副本：
kubectl patch sts web -p '{"spec":{"replicas":3}}'

5.4.6.滚动更新

RollingUpdate 更新策略会更新一个 StatefulSet 中的所有 Pod，采用与序号索引相反的顺序并遵循 StatefulSet 的保证。对 web StatefulSet 应用 Patch 操作来应用 RollingUpdate 更新策略：

kubectl patch statefulset web -p '{"spec":{"updateStrategy":{"type":"RollingUpdate"}}}'

StatefulSet 执行 patch 操作来再次改变容器镜像：
kubectl patch statefulset web --type='json' -p='[{"op": "replace", "path": "/spec/template/spec/containers/0/image", "value":"gcr.io/google_containers/nginx-slim:0.8"}]'

5.4.7.分段更新
你可以使用 RollingUpdate 更新策略的 partition 参数来分段更新一个 StatefulSet。 分段的更新将会使 StatefulSet 中的其余所有 Pod 保持当前版本的同时允许改变 StatefulSet 的 .spec.template。对 web StatefulSet 执行 Patch 操作为 updateStrategy 字段添加一个分区:

kubectl patch statefulset web -p '{"spec":{"updateStrategy":{"type":"RollingUpdate","rollingUpdate":{"partition":3}}}}'

再次 Patch StatefulSet 来改变容器镜像

kubectl patch statefulset web --type='json' -p='[{"op": "replace", "path": "/spec/template/spec/containers/0/image", "value":"registry.k8s.io/nginx-slim:0.7"}]'

获取 Pod 的容器镜像

kubectl get pod web-2 --template '{{range $i, $c := .spec.containers}}{{$c.image}}{{end}}'

5.4.8.金丝雀发布

你可以通过减少上文指定的 partition 来进行金丝雀发布，以此来测试你的程序的改动。
通过 patch 命令修改 StatefulSet 来减少分区：

kubectl patch statefulset web -p '{"spec":{"updateStrategy":{"type":"RollingUpdate","rollingUpdate":{"partition":2}}}}'

当你改变 partition 时，StatefulSet 会自动更新 web-2 Pod，这是因为 Pod 的序号大于或等于 partition。

web-1 被按照原来的配置恢复，因为 Pod 的序号小于分区。当指定了分区时，如果更新了 StatefulSet 的 .spec.template，则所有序号大于或等于分区的 Pod 都将被更新。 如果一个序号小于分区的 Pod 被删除或者终止，它将被按照原来的配置恢复。

5.4.9.分阶段的发布

你可以使用类似金丝雀发布的方法执行一次分阶段的发布 （例如一次线性的、等比的或者指数形式的发布）。 要执行一次分阶段的发布，你需要设置 partition 为希望控制器暂停更新的序号。
分区当前为 2。请将分区设置为 0：

kubectl patch statefulset web -p '{"spec":{"updateStrategy":{"type":"RollingUpdate","rollingUpdate":{"partition":0}}}}'

将 partition 改变为 0 以允许 StatefulSet 继续更新过程。

5.4.10.OnDelete 策略

默认的更新策略, 当你选择这个更新策略并修改 StatefulSet 的 .spec.template 字段时，StatefulSet 控制器将不会自动更新 Pod。

5.4.11.删除 StatefulSet

StatefulSet 同时支持级联和非级联删除。
使用非级联方式删除 StatefulSet 时，StatefulSet 的 Pod 不会被删除。
使用级联删除时，StatefulSet 和它的 Pod 都会被删除

---非级联方式
kubectl delete statefulset web --cascade=orphan
-删除 web-0：
kubectl delete pod web-0
---级联删除
kubectl delete statefulset web
-但级联不会删除与 StatefulSet 关联的 Headless Service。你必须手动删除 nginx Service。
kubectl delete service nginx

5.4.12.清除现场

kubectl delete sts web
kubectl delete svc nginx
kubectl get pvc
kubectl get pv
kubectl delete pvc www-web-0 www-web-1 www-web-2 www-web-3 www-web-4