教程

• 1: 你好，Minikube
• 2: 学习 Kubernetes 基础知识
• 2.1: 创建集群
• 2.1.1: 使用 Minikube 创建集群
• 2.1.2: 交互式教程 - 创建集群
• 2.2: 部署应用
• 2.2.1: 使用 kubectl 创建 Deployment
• 2.2.2: 交互式教程 - 部署应用
• 2.3: 了解你的应用
• 2.3.1: 查看 pod 和工作节点
• 2.3.2: 交互式教程-了解你的应用
• 2.4: 公开地暴露你的应用
• 2.4.1: 使用 Service 暴露您的应用
• 2.4.2: 交互式教程 - 暴露你的应用
• 2.5: 缩放你的应用
• 2.5.1: 运行应用程序的多个实例
• 2.5.2: 交互教程 - 缩放你的应用
• 2.6: 更新你的应用
• 2.6.1: 执行滚动更新
• 2.6.2: 交互式教程 - 更新你的应用
• 3: 配置
• 3.1: 示例：配置 java 微服务
• 3.1.1: 使用 MicroProfile、ConfigMaps、Secrets 实现外部化应用配置
• 3.1.2: 互动教程 - 配置 java 微服务
• 3.2: 使用 ConfigMap 来配置 Redis
• 4: 安全
• 4.1: 在名字空间级别应用 Pod 安全标准
• 4.2: 在集群级别应用 Pod 安全标准
• 5: 无状态应用程序
• 5.1: 公开外部 IP 地址以访问集群中应用程序
• 5.2: 示例：使用 Redis 部署 PHP 留言板应用程序
• 6: 有状态的应用
• 6.1: 示例：使用 Persistent Volumes 部署 WordPress 和 MySQL
• 6.2: 示例：使用 StatefulSet 部署 Cassandra
• 6.3: 运行 ZooKeeper，一个分布式协调系统
• 6.4: StatefulSet 基础
• 7: 集群
• 7.1: 使用 AppArmor 限制容器对资源的访问
• 7.2: 使用 Seccomp 限制容器的系统调用
• 8: Services
• 8.1: 使用 Source IP

1 - 你好，Minikube

本教程向你展示如何使用 Minikube 和 Katacoda 在 Kubernetes 上运行一个应用示例。Katacoda 提供免费的浏览器内 Kubernetes 环境。

教程目标

• 将一个示例应用部署到 Minikube。
• 运行应用程序。
• 查看应用日志

准备开始

本教程提供了容器镜像，使用 NGINX 来对所有请求做出回应：

创建 Minikube 集群

1. 点击 启动终端

   Launch Terminal
   说明： 如果你在本地安装了 Minikube，运行 minikube start。 在运行 minikube dashboard 之前，你应该打开一个新终端， 在此启动 minikube dashboard ，然后切换回主终端。

2. 在浏览器中打开 Kubernetes 仪表板（Dashboard）：

   minikube dashboard
   

3. 仅限 Katacoda 环境：在终端窗口的顶部，单击加号，然后单击 选择要在主机 1 上查看的端口。

4. 仅限 Katacoda 环境：输入“30000”，然后单击 显示端口。

使用 URL 打开仪表板

如果你不想打开 Web 浏览器，请使用 --url 标志运行显示板命令以得到 URL：

minikube dashboard --url

创建 Deployment

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

1. 使用 kubectl create 命令创建管理 Pod 的 Deployment。该 Pod 根据提供的 Docker 镜像运行 Container。

   kubectl create deployment hello-node --image=k8s.gcr.io/echoserver:1.4
   

2. 查看 Deployment：

   kubectl get deployments
   

   输出结果类似于这样：

   NAME         READY   UP-TO-DATE   AVAILABLE   AGE
   hello-node   1/1     1            1           1m
   

3. 查看 Pod：

   kubectl get pods
   

   输出结果类似于这样：

   NAME                          READY     STATUS    RESTARTS   AGE
   hello-node-5f76cf6ccf-br9b5   1/1       Running   0          1m
   

4. 查看集群事件：

   kubectl get events
   

5. 查看 kubectl 配置：

   kubectl config view
   

创建 Service

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

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

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

   这里的 --type=LoadBalancer 参数表明你希望将你的 Service 暴露到集群外部。

   镜像 k8s.gcr.io/echoserver 中的应用程序代码仅监听 TCP 8080 端口。 如果你用 kubectl expose 暴露了其它的端口，客户端将不能访问其它端口。

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          23m
   

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

3. 运行下面的命令：

   minikube service hello-node
   

4. 仅限 Katacoda 环境：单击加号，然后单击 选择要在主机 1 上查看的端口。

5. 仅限 Katacoda 环境：请注意在 service 输出中与 8080 对应的长度为 5 位的端口号。 此端口号是随机生成的，可能与你的不同。 在端口号文本框中输入你自己的端口号，然后单击显示端口。 对应于上面的例子，需要输入 30369。

   这将打开一个浏览器窗口，为你的应用程序提供服务并显示应用的响应。

启用插件

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

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
   

2. 启用插件，例如 metrics-server：

   minikube addons enable metrics-server
   

   输出结果类似于这样：

   The 'metrics-server' addon is enabled
   

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
   

4. 禁用 metrics-server：

   minikube addons disable metrics-server
   

   输出结果类似于这样：

   metrics-server was successfully disabled
   

清理

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

kubectl delete service hello-node
kubectl delete deployment hello-node

可选地，停止 Minikube 虚拟机（VM）：

minikube stop

可选地，删除 Minikube 虚拟机（VM）：

minikube delete

接下来

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

2 - 学习 Kubernetes 基础知识

Kubernetes 基础

本教程介绍了 Kubernetes 集群编排系统的基础知识。每个模块包含关于 Kubernetes 主要特性和概念的一些背景信息，并包括一个在线互动教程。这些互动教程让您可以自己管理一个简单的集群及其容器化应用程序。

使用互动教程，您可以学习：

• 在集群上部署容器化应用程序
• 弹性部署
• 使用新的软件版本，更新容器化应用程序
• 调试容器化应用程序

教程 Katacoda 在您的浏览器中运行一个虚拟终端，在浏览器中运行 Minikube，这是一个可在任何地方小规模本地部署的 Kubernetes 集群。不需要安装任何软件或进行任何配置；每个交互性教程都直接从您的网页浏览器上运行。

Kubernetes 可以为您做些什么?

通过现代的 Web 服务，用户希望应用程序能够 24/7 全天候使用，开发人员希望每天可以多次发布部署新版本的应用程序。 容器化可以帮助软件包达成这些目标，使应用程序能够以简单快速的方式发布和更新，而无需停机。Kubernetes 帮助您确保这些容器化的应用程序在您想要的时间和地点运行，并帮助应用程序找到它们需要的资源和工具。Kubernetes 是一个可用于生产的开源平台，根据 Google 容器集群方面积累的经验，以及来自社区的最佳实践而设计。

Kubernetes 基础模块

1. 创建一个 Kubernetes 集群

2. 部署应用程序

3. 应用程序探索

4. 应用外部可见

5. 应用可扩展

6. 应用更新

2.1 - 创建集群

2.1.1 - 使用 Minikube 创建集群

2.1.2 - 交互式教程 - 创建集群

2.2 - 部署应用

2.2.1 - 使用 kubectl 创建 Deployment

2.2.2 - 交互式教程 - 部署应用

2.3 - 了解你的应用

2.3.1 - 查看 pod 和工作节点

2.3.2 - 交互式教程-了解你的应用

2.4 - 公开地暴露你的应用

2.4.1 - 使用 Service 暴露您的应用

2.4.2 - 交互式教程 - 暴露你的应用

2.5 - 缩放你的应用

2.5.1 - 运行应用程序的多个实例

目标

• 用 kubectl 扩缩应用程序

扩缩应用程序

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

扩缩 是通过改变 Deployment 中的副本数量来实现的。

小结:

• 扩缩一个 Deployment

在运行 kubectl run 命令时，你可以通过设置 --replicas 参数来设置 Deployment 的副本数。

扩缩概述

Previous Next

扩展 Deployment 将创建新的 Pods，并将资源调度请求分配到有可用资源的节点上，收缩 会将 Pods 数量减少至所需的状态。Kubernetes 还支持 Pods 的自动缩放，但这并不在本教程的讨论范围内。将 Pods 数量收缩到0也是可以的，但这会终止 Deployment 上所有已经部署的 Pods。

运行应用程序的多个实例需要在它们之间分配流量。服务 (Service)有一种负载均衡器类型，可以将网络流量均衡分配到外部可访问的 Pods 上。服务将会一直通过端点来监视 Pods 的运行，保证流量只分配到可用的 Pods 上。

扩缩是通过改变 Deployment 中的副本数量来实现的。

一旦有了多个应用实例，就可以没有宕机地滚动更新。我们将会在下面的模块中介绍这些。现在让我们使用在线终端来体验一下应用程序的扩缩过程。

开始互动教程 ›

2.5.2 - 交互教程 - 缩放你的应用

2.6 - 更新你的应用

2.6.1 - 执行滚动更新

Objectives

• 使用 kubectl 执行滚动更新。

更新应用程序

用户希望应用程序始终可用，而开发人员则需要每天多次部署它们的新版本。在 Kubernetes 中，这些是通过滚动更新（Rolling Updates）完成的。 滚动更新 允许通过使用新的实例逐步更新 Pod 实例，零停机进行 Deployment 更新。新的 Pod 将在具有可用资源的节点上进行调度。

在前面的模块中，我们将应用程序扩展为运行多个实例。这是在不影响应用程序可用性的情况下执行更新的要求。默认情况下，更新期间不可用的 pod 的最大值和可以创建的新 pod 数都是 1。这两个选项都可以配置为（pod）数字或百分比。 在 Kubernetes 中，更新是经过版本控制的，任何 Deployment 更新都可以恢复到以前的（稳定）版本。

摘要：

• 更新应用

滚动更新允许通过使用新的实例逐步更新 Pod 实例从而实现 Deployments 更新，停机时间为零。

滚动更新概述

Previous Next

与应用程序扩展类似，如果公开了 Deployment，服务将在更新期间仅对可用的 pod 进行负载均衡。可用 Pod 是应用程序用户可用的实例。

滚动更新允许以下操作：

• 将应用程序从一个环境提升到另一个环境（通过容器镜像更新）
• 回滚到以前的版本
• 持续集成和持续交付应用程序，无需停机

如果 Deployment 是公开的，则服务将仅在更新期间对可用的 pod 进行负载均衡。

在下面的交互式教程中，我们将应用程序更新为新版本，并执行回滚。

启动交互教程›

2.6.2 - 交互式教程 - 更新你的应用

3 - 配置

3.1 - 示例：配置 java 微服务

3.1.1 - 使用 MicroProfile、ConfigMaps、Secrets 实现外部化应用配置

在本教程中，你会学到如何以及为什么要实现外部化微服务应用配置。 具体来说，你将学习如何使用 Kubernetes ConfigMaps 和 Secrets 设置环境变量， 然后在 MicroProfile config 中使用它们。

准备开始

创建 Kubernetes ConfigMaps 和 Secrets

在 Kubernetes 中，为 docker 容器设置环境变量有几种不同的方式，比如： Dockerfile、kubernetes.yml、Kubernetes ConfigMaps、和 Kubernetes Secrets。 在本教程中，你将学到怎么用后两个方式去设置你的环境变量，而环境变量的值将注入到你的微服务里。 使用 ConfigMaps 和 Secrets 的一个好处是他们能在多个容器间复用， 比如赋值给不同的容器中的不同环境变量。

ConfigMaps 是存储非机密键值对的 API 对象。 在互动教程中，你会学到如何用 ConfigMap 来保存应用名字。 ConfigMap 的更多信息，你可以在这里找到文档。

Secrets 尽管也用来存储键值对，但区别于 ConfigMaps 的是：它针对机密/敏感数据，且存储格式为 Base64 编码。 secrets 的这种特性使得它适合于存储证书、密钥、令牌，上述内容你将在交互教程中实现。 Secrets 的更多信息，你可以在这里找到文档。

从代码外部化配置

外部化应用配置之所以有用处，是因为配置常常根据环境的不同而变化。 为了实现此功能，我们用到了 Java 上下文和依赖注入（Contexts and Dependency Injection, CDI）、MicroProfile 配置。 MicroProfile config 是 MicroProfile 的功能特性， 是一组开放 Java 技术，用于开发、部署云原生微服务。

CDI 提供一套标准的依赖注入能力，使得应用程序可以由相互协作的、松耦合的 beans 组装而成。 MicroProfile Config 为 app 和微服务提供从各种来源，比如应用、运行时、环境，获取配置参数的标准方法。 基于来源定义的优先级，属性可以自动的合并到单独一组应用可以通过 API 访问到的属性。 CDI & MicroProfile 都会被用在互动教程中， 用来从 Kubernetes ConfigMaps 和 Secrets 获得外部提供的属性，并注入应用程序代码中。

很多开源框架、运行时支持 MicroProfile Config。 对于整个互动教程，你都可以使用开放的库、灵活的开源 Java 运行时，去构建并运行云原生的 apps 和微服务。 然而，任何 MicroProfile 兼容的运行时都可以用来做替代品。

教程目标

• 创建 Kubernetes ConfigMap 和 Secret
• 使用 MicroProfile Config 注入微服务配置

示例：使用 MicroProfile、ConfigMaps、Secrets 实现外部化应用配置

启动互动教程

3.1.2 - 互动教程 - 配置 java 微服务

3.2 - 使用 ConfigMap 来配置 Redis

这篇文档基于使用 ConfigMap 来配置 Containers 这个任务，提供了一个使用 ConfigMap 来配置 Redis 的真实案例。

教程目标

• 使用 Redis 配置的值创建一个 ConfigMap
• 创建一个 Redis Pod，挂载并使用创建的 ConfigMap
• 验证配置已经被正确应用。

准备开始

• 你必须拥有一个 Kubernetes 的集群，同时你的 Kubernetes 集群必须带有 kubectl 命令行工具。 建议在至少有两个节点的集群上运行本教程，且这些节点不作为控制平面主机。 如果你还没有集群，你可以通过 Minikube 构建一个你自己的集群，或者你可以使用下面任意一个 Kubernetes 工具构建：

  • Katacoda
  • 玩转 Kubernetes
  要获知版本信息，请输入 kubectl version.

• 此页面上显示的示例适用于 kubectl 1.14和在其以上的版本。
• 理解使用ConfigMap来配置Containers。

真实世界的案例：使用 ConfigMap 来配置 Redis

按照下面的步骤，使用 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://k8s.io/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-config 的文件中。
• 然后 config 卷被 spec.containers[0].volumeMounts[1] 挂载在 /redis-master。

这样做的最终效果是将上面 example-redis-config 配置中 data.redis-config 的数据作为 Pod 中的 /redis-master/redis.conf 公开。

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 添加一些配置：

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://k8s.io/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

接下来

• 了解有关 ConfigMaps的更多信息。

4 - 安全

4.1 - 在名字空间级别应用 Pod 安全标准

Pod 安全准入（PSA）在 v1.23 及更高版本默认启用， 因为它升级到测试版（beta）。 Pod 安全准入是在创建 Pod 时应用 Pod 安全标准的准入控制器。 在本教程中，你将应用 baseline Pod 安全标准，每次一个名字空间。

你还可以在集群级别一次将 Pod 安全标准应用于多个名称空间。 有关说明，请参阅在集群级别应用 Pod 安全标准。

准备开始

在你的工作站中安装以下内容：

• KinD
• kubectl

创建集群

2. 按照如下方式创建一个 KinD 集群：

   kind create cluster --name psa-ns-level --image kindest/node:v1.23.0
   

   输出类似于：

   Creating cluster "psa-ns-level" ...
    ✓ Ensuring node image (kindest/node:v1.23.0) 🖼 
    ✓ Preparing nodes 📦  
    ✓ Writing configuration 📜 
    ✓ Starting control-plane 🕹️ 
    ✓ Installing CNI 🔌 
    ✓ Installing StorageClass 💾 
   Set kubectl context to "kind-psa-ns-level"
   You can now use your cluster with:
   
   kubectl cluster-info --context kind-psa-ns-level
   
   Not sure what to do next? 😅  Check out https://kind.sigs.k8s.io/docs/user/quick-start/
   

1. 将 kubectl 上下文设置为新集群：

   kubectl cluster-info --context kind-psa-ns-level
   

   输出类似于：

   Kubernetes control plane is running at https://127.0.0.1:50996
   CoreDNS is running at https://127.0.0.1:50996/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy
   
   To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.
   

创建名字空间

创建一个名为 example 的新名字空间：

kubectl create ns example

输出类似于：

namespace/example created

应用 Pod 安全标准

1. 使用内置 Pod 安全准入所支持的标签在此名字空间上启用 Pod 安全标准。 在这一步中，我们将根据最新版本（默认值）对基线 Pod 安全标准发出警告。

   kubectl label --overwrite ns example \
     pod-security.kubernetes.io/warn=baseline \
     pod-security.kubernetes.io/warn-version=latest
   

2. 可以使用标签在任何名字空间上启用多个 Pod 安全标准。 以下命令将强制（enforce） 执行基线（baseline）Pod 安全标准， 但根据最新版本（默认值）对受限（restricted）Pod 安全标准执行警告（warn）和审核（audit）。

   kubectl label --overwrite ns example \
     pod-security.kubernetes.io/enforce=baseline \
     pod-security.kubernetes.io/enforce-version=latest \
     pod-security.kubernetes.io/warn=restricted \
     pod-security.kubernetes.io/warn-version=latest \
     pod-security.kubernetes.io/audit=restricted \
     pod-security.kubernetes.io/audit-version=latest
   

验证 Pod 安全标准

1. 在 example 名字空间中创建一个最小的 pod：

   cat <<EOF > /tmp/pss/nginx-pod.yaml
   apiVersion: v1
   kind: Pod
   metadata:
     name: nginx
   spec:
     containers:
       - image: nginx
         name: nginx
         ports:
           - containerPort: 80
   EOF
   

1. 将 Pod 规约应用到集群中的 example 名字空间中：

   kubectl apply -n example -f /tmp/pss/nginx-pod.yaml
   

   输出类似于：

   Warning: would violate PodSecurity "restricted:latest": allowPrivilegeEscalation != false (container "nginx" must set securityContext allowPrivilegeEscalation=false), unrestricted capabilities (container "nginx" must set securityContext.capabilities.drop=["ALL"]), runAsNonRoot != true (pod or container "nginx" must set securityContext.runAsNonRoot=true), seccompProfile (pod or container "nginx" must set securityContext seccompProfile.type to "RuntimeDefault" or "Localhost")
   pod/nginx created
   

3. 将 Pod 规约应用到集群中的 default 名字空间中：

   kubectl apply -n default -f /tmp/pss/nginx-pod.yaml
   

   输出类似于：

   pod/nginx created
   

以上 Pod 安全标准仅被应用到 example 名字空间。 你可以在没有警告的情况下在 default 名字空间中创建相同的 Pod。

清理

运行 kind delete cluster -name psa-ns-level 删除创建的集群。

接下来

• 运行一个 shell 脚本 一次执行所有前面的步骤。
  1. 创建 KinD 集群
  2. 创建新的名字空间
  3. 在 enforce 模式下应用 baseline Pod 安全标准， 同时在 warn 和 audit 模式下应用 restricted Pod 安全标准。
  4. 创建一个应用以下 Pod 安全标准的新 Pod
• Pod 安全准入
• Pod 安全标准
• 在集群级别应用 Pod 安全标准

4.2 - 在集群级别应用 Pod 安全标准

Pod 安全准入（PSA）在 v1.23 及更高版本默认启用， 因为它升级到测试版（beta）。 Pod 安全准入是在创建 Pod 时应用 Pod 安全标准的准入控制器。 本教程将向你展示如何在集群级别实施 baseline Pod 安全标准， 该标准将标准配置应用于集群中的所有名称空间。

要将 Pod 安全标准应用于特定名字空间， 请参阅在名字空间级别应用 Pod 安全标准。

准备开始

在你的工作站中安装以下内容：

• KinD
• kubectl

正确选择要应用的 Pod 安全标准

Pod 安全准入 允许你使用以下模式应用内置的 Pod 安全标准: enforce、audit 和 warn。

要收集信息以便选择最适合你的配置的 Pod 安全标准，请执行以下操作：

1. 创建一个没有应用 Pod 安全标准的集群：

   kind create cluster --name psa-wo-cluster-pss --image kindest/node:v1.23.0
   

   输出类似于：

   Creating cluster "psa-wo-cluster-pss" ...
   ✓ Ensuring node image (kindest/node:v1.23.0) 🖼
   ✓ Preparing nodes 📦  
   ✓ Writing configuration 📜
   ✓ Starting control-plane 🕹️
   ✓ Installing CNI 🔌
   ✓ Installing StorageClass 💾
   Set kubectl context to "kind-psa-wo-cluster-pss"
   You can now use your cluster with:
   
   kubectl cluster-info --context kind-psa-wo-cluster-pss
   
   Thanks for using kind! 😊
   
   

2. 将 kubectl 上下文设置为新集群：

   kubectl cluster-info --context kind-psa-wo-cluster-pss
   

   输出类似于：

   Kubernetes control plane is running at https://127.0.0.1:61350 
   CoreDNS is running at https://127.0.0.1:61350/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy
   
   To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.
   

3. 获取集群中的名字空间列表：

   kubectl get ns
   

   输出类似于：

   NAME                 STATUS   AGE
   default              Active   9m30s
   kube-node-lease      Active   9m32s
   kube-public          Active   9m32s
   kube-system          Active   9m32s
   local-path-storage   Active   9m26s
   

4. 使用 --dry-run=server 来了解应用不同的 Pod 安全标准时会发生什么：

   1. Privileged

      kubectl label --dry-run=server --overwrite ns --all \                    
      pod-security.kubernetes.io/enforce=privileged
      

      输出类似于：

      namespace/default labeled
      namespace/kube-node-lease labeled
      namespace/kube-public labeled
      namespace/kube-system labeled
      namespace/local-path-storage labeled
      

   2. Baseline

      kubectl label --dry-run=server --overwrite ns --all \
      pod-security.kubernetes.io/enforce=baseline
      

      输出类似于：

      namespace/default labeled
      namespace/kube-node-lease labeled
      namespace/kube-public labeled
      Warning: existing pods in namespace "kube-system" violate the new PodSecurity enforce level "baseline:latest"
      Warning: etcd-psa-wo-cluster-pss-control-plane (and 3 other pods): host namespaces, hostPath volumes
      Warning: kindnet-vzj42: non-default capabilities, host namespaces, hostPath volumes
      Warning: kube-proxy-m6hwf: host namespaces, hostPath volumes, privileged
      namespace/kube-system labeled
      namespace/local-path-storage labeled
      

   3. Restricted

      kubectl label --dry-run=server --overwrite ns --all \
      pod-security.kubernetes.io/enforce=restricted
      

      输出类似于：

      namespace/default labeled
      namespace/kube-node-lease labeled
      namespace/kube-public labeled
      Warning: existing pods in namespace "kube-system" violate the new PodSecurity enforce level "restricted:latest"
      Warning: coredns-7bb9c7b568-hsptc (and 1 other pod): unrestricted capabilities, runAsNonRoot != true, seccompProfile
      Warning: etcd-psa-wo-cluster-pss-control-plane (and 3 other pods): host namespaces, hostPath volumes, allowPrivilegeEscalation != false, unrestricted capabilities, restricted volume types, runAsNonRoot != true
      Warning: kindnet-vzj42: non-default capabilities, host namespaces, hostPath volumes, allowPrivilegeEscalation != false, unrestricted capabilities, restricted volume types, runAsNonRoot != true, seccompProfile
      Warning: kube-proxy-m6hwf: host namespaces, hostPath volumes, privileged, allowPrivilegeEscalation != false, unrestricted capabilities, restricted volume types, runAsNonRoot != true, seccompProfile
      namespace/kube-system labeled
      Warning: existing pods in namespace "local-path-storage" violate the new PodSecurity enforce level "restricted:latest"
      Warning: local-path-provisioner-d6d9f7ffc-lw9lh: allowPrivilegeEscalation != false, unrestricted capabilities, runAsNonRoot != true, seccompProfile
      namespace/local-path-storage labeled
      

从前面的输出中，你会注意到应用 privileged Pod 安全标准不会显示任何名字空间的警告。 然而，baseline 和 restricted 标准都有警告，特别是在 kube-system 名字空间中。

设置模式、版本和标准

在本节中，你将以下 Pod 安全标准应用于最新（latest）版本：

• 在 enforce 模式下的 baseline 标准。
• warn 和 audit 模式下的 restricted 标准。

baseline Pod 安全标准提供了一个方便的中间立场，能够保持豁免列表简短并防止已知的特权升级。

此外，为了防止 kube-system 中的 Pod 失败，你将免除该名字空间应用 Pod 安全标准。

在你自己的环境中实施 Pod 安全准入时，请考虑以下事项：

1. 根据应用于集群的风险状况，更严格的 Pod 安全标准（如 restricted）可能是更好的选择。

2. 对 kube-system 名字空间进行赦免会允许 Pod 在其中以 privileged 模式运行。 对于实际使用，Kubernetes 项目强烈建议你应用严格的 RBAC 策略来限制对 kube-system 的访问， 遵循最小特权原则。

3. 创建一个配置文件，Pod 安全准入控制器可以使用该文件来实现这些 Pod 安全标准：

   mkdir -p /tmp/pss
   cat <<EOF > /tmp/pss/cluster-level-pss.yaml 
   apiVersion: apiserver.config.k8s.io/v1
   kind: AdmissionConfiguration
   plugins:
   - name: PodSecurity
     configuration:
       apiVersion: pod-security.admission.config.k8s.io/v1beta1
       kind: PodSecurityConfiguration
       defaults:
         enforce: "baseline"
         enforce-version: "latest"
         audit: "restricted"
         audit-version: "latest"
         warn: "restricted"
         warn-version: "latest"
       exemptions:
         usernames: []
         runtimeClasses: []
         namespaces: [kube-system]
   EOF
   

4. 在创建集群时配置 API 服务器使用此文件：

   cat <<EOF > /tmp/pss/cluster-config.yaml 
   kind: Cluster
   apiVersion: kind.x-k8s.io/v1alpha4
   nodes:
   - role: control-plane
     kubeadmConfigPatches:
     - |
       kind: ClusterConfiguration
       apiServer:
           extraArgs:
             admission-control-config-file: /etc/config/cluster-level-pss.yaml
           extraVolumes:
             - name: accf
               hostPath: /etc/config
               mountPath: /etc/config
               readOnly: false
               pathType: "DirectoryOrCreate"
     extraMounts:
     - hostPath: /tmp/pss
       containerPath: /etc/config
       # optional: if set, the mount is read-only.
       # default false
       readOnly: false
       # optional: if set, the mount needs SELinux relabeling.
       # default false
       selinuxRelabel: false
       # optional: set propagation mode (None, HostToContainer or Bidirectional)
       # see https://kubernetes.io/docs/concepts/storage/volumes/#mount-propagation
       # default None
       propagation: None
   EOF
   

   说明：

   如果你在 macOS 上使用 Docker Desktop 和 KinD， 你可以在菜单项 Preferences > Resources > File Sharing 下添加 /tmp 作为共享目录。

5. 创建一个使用 Pod 安全准入的集群来应用这些 Pod 安全标准：

   kind create cluster --name psa-with-cluster-pss --image kindest/node:v1.23.0 --config /tmp/pss/cluster-config.yaml
   

   输出类似于：

   Creating cluster "psa-with-cluster-pss" ...
    ✓ Ensuring node image (kindest/node:v1.23.0) 🖼 
    ✓ Preparing nodes 📦  
    ✓ Writing configuration 📜 
    ✓ Starting control-plane 🕹️ 
    ✓ Installing CNI 🔌 
    ✓ Installing StorageClass 💾 
   Set kubectl context to "kind-psa-with-cluster-pss"
   You can now use your cluster with:
   
   kubectl cluster-info --context kind-psa-with-cluster-pss
   
   Have a question, bug, or feature request? Let us know! https://kind.sigs.k8s.io/#community 🙂
   

6. 将 kubectl 指向集群

   kubectl cluster-info --context kind-psa-with-cluster-pss
   

   输出类似于：

   Kubernetes control plane is running at https://127.0.0.1:63855
   CoreDNS is running at https://127.0.0.1:63855/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy
   
   To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.
   

7. 创建以下 Pod 规约作为在 default 名字空间中的一个最小配置：

   cat <<EOF > /tmp/pss/nginx-pod.yaml
   apiVersion: v1
   kind: Pod
   metadata:
     name: nginx
   spec:
     containers:
       - image: nginx
         name: nginx
         ports:
           - containerPort: 80
   EOF
   

8. 在集群中创建 Pod：

   kubectl apply -f /tmp/pss/nginx-pod.yaml
   

   输出类似于：

   Warning: would violate PodSecurity "restricted:latest": allowPrivilegeEscalation != false (container "nginx" must set securityContext allowPrivilegeEscalation=false), unrestricted capabilities (container "nginx" must set securityContext.capabilities.drop=["ALL"]), runAsNonRoot != true (pod or container "nginx" must set securityContext.runAsNonRoot=true), seccompProfile (pod or container "nginx" must set securityContext seccompProfile.type to "RuntimeDefault" or "Localhost")
   pod/nginx created
   

清理

运行 kind delete cluster -name psa-with-cluster-pss 和 kind delete cluster -name psa-wo-cluster-pss 来删除你创建的集群。

接下来

• 运行一个 shell 脚本 一次执行前面的所有步骤：
  1. 创建一个基于 Pod 安全标准的集群级别配置
  2. 创建一个文件让 API 服务器消费这个配置
  3. 创建一个集群，用这个配置创建一个 API 服务器
  4. 设置 kubectl 上下文为这个新集群
  5. 创建一个最小的 Pod yaml 文件
  6. 应用这个文件，在新集群中创建一个 Pod
• Pod 安全准入
• Pod 安全标准
• 在名字空间级别应用 Pod 安全标准

5 - 无状态应用程序

5.1 - 公开外部 IP 地址以访问集群中应用程序

此页面显示如何创建公开外部 IP 地址的 Kubernetes 服务对象。

准备开始

• 安装 kubectl.
• 使用 Google Kubernetes Engine 或 Amazon Web Services 等云供应商创建 Kubernetes 集群。 本教程创建了一个外部负载均衡器， 需要云供应商。
• 配置 kubectl 与 Kubernetes API 服务器通信。有关说明，请参阅云供应商文档。

教程目标

• 运行 Hello World 应用程序的五个实例。
• 创建一个公开外部 IP 地址的 Service 对象。
• 使用 Service 对象访问正在运行的应用程序。

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

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

   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 有五个 Pods， 每个都运行 Hello World 应用程序。

2. 显示有关 Deployment 的信息：

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

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

   kubectl get replicasets
   kubectl describe replicasets
   

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

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

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
   

   提示：type=LoadBalancer 服务由外部云服务提供商提供支持，本例中不包含此部分， 详细信息请参考此页

   提示：如果外部 IP 地址显示为 <pending>，请等待一分钟再次输入相同的命令。

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。

7. 在前面的输出中，您可以看到服务有几个端点： 10.0.0.6:8080、10.0.1.6:8080、10.0.1.7:8080 和另外两个， 这些都是正在运行 Hello World 应用程序的 pod 的内部地址。 要验证这些是 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
   

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 应用程序。

   成功请求的响应是一条问候消息：

   Hello Kubernetes!
   

清理现场

要删除服务，请输入以下命令：

kubectl delete services my-service

要删除正在运行 Hello World 应用程序的 Deployment，ReplicaSet 和 Pod，请输入以下命令：

kubectl delete deployment hello-world

接下来

进一步了解将应用程序与服务连接。

5.2 - 示例：使用 Redis 部署 PHP 留言板应用程序

本教程向您展示如何使用 Kubernetes 和 Docker 构建和部署 一个简单的 (非面向生产的) 多层 web 应用程序。本例由以下组件组成：

• 单实例 Redis 以保存留言板条目
• 多个 web 前端实例

教程目标

• 启动 Redis 领导者（Leader）
• 启动两个 Redis 跟随者（Follower）
• 公开并查看前端服务
• 清理

准备开始

你必须拥有一个 Kubernetes 的集群，同时你的 Kubernetes 集群必须带有 kubectl 命令行工具。 建议在至少有两个节点的集群上运行本教程，且这些节点不作为控制平面主机。 如果你还没有集群，你可以通过 Minikube 构建一个你自己的集群，或者你可以使用下面任意一个 Kubernetes 工具构建：

• Katacoda
• 玩转 Kubernetes

启动 Redis 数据库

留言板应用程序使用 Redis 存储数据。

创建 Redis Deployment

下面包含的清单文件指定了一个 Deployment 控制器，该控制器运行一个 Redis Pod 副本。

application/guestbook/redis-leader-deployment.yaml

# SOURCE: https://cloud.google.com/kubernetes-engine/docs/tutorials/guestbook
apiVersion: apps/v1
kind: Deployment
metadata:
  name: redis-leader
  labels:
    app: redis
    role: leader
    tier: backend
spec:
  replicas: 1
  selector:
    matchLabels:
      app: redis
  template:
    metadata:
      labels:
        app: redis
        role: leader
        tier: backend
    spec:
      containers:
      - name: leader
        image: "docker.io/redis:6.0.5"
        resources:
          requests:
            cpu: 100m
            memory: 100Mi
        ports:
        - containerPort: 6379

1. 在下载清单文件的目录中启动终端窗口。

2. 从 redis-leader-deployment.yaml 文件中应用 Redis Deployment：

   kubectl apply -f https://k8s.io/examples/application/guestbook/redis-leader-deployment.yaml
   

3. 查询 Pod 列表以验证 Redis Pod 是否正在运行：

   kubectl get pods
   

   响应应该与此类似：

   NAME                           READY   STATUS    RESTARTS   AGE
   redis-leader-fb76b4755-xjr2n   1/1     Running   0          13s
   

4. 运行以下命令查看 Redis Deployment 中的日志：

   kubectl logs -f deployment/redis-leader
   

创建 Redis 领导者服务

留言板应用程序需要往 Redis 中写数据。因此，需要创建 Service 来转发 Redis Pod 的流量。Service 定义了访问 Pod 的策略。

application/guestbook/redis-leader-service.yaml

# SOURCE: https://cloud.google.com/kubernetes-engine/docs/tutorials/guestbook
apiVersion: v1
kind: Service
metadata:
  name: redis-leader
  labels:
    app: redis
    role: leader
    tier: backend
spec:
  ports:
  - port: 6379
    targetPort: 6379
  selector:
    app: redis
    role: leader
    tier: backend

1. 使用下面的 redis-leader-service.yaml 文件创建 Redis的服务：

   kubectl apply -f https://k8s.io/examples/application/guestbook/redis-leader-service.yaml
   

2. 查询服务列表验证 Redis 服务是否正在运行：

   kubectl get service
   

   响应应该与此类似：

   NAME           TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)    AGE
   kubernetes     ClusterIP   10.0.0.1     <none>        443/TCP    1m
   redis-leader   ClusterIP   10.103.78.24 <none>        6379/TCP   16s
   

设置 Redis 跟随者

尽管 Redis 领导者只有一个 Pod，你可以通过添加若干 Redis 跟随者来将其配置为高可用状态， 以满足流量需求。

application/guestbook/redis-follower-deployment.yaml

# SOURCE: https://cloud.google.com/kubernetes-engine/docs/tutorials/guestbook
apiVersion: apps/v1
kind: Deployment
metadata:
  name: redis-follower
  labels:
    app: redis
    role: follower
    tier: backend
spec:
  replicas: 2
  selector:
    matchLabels:
      app: redis
  template:
    metadata:
      labels:
        app: redis
        role: follower
        tier: backend
    spec:
      containers:
      - name: follower
        image: gcr.io/google_samples/gb-redis-follower:v2
        resources:
          requests:
            cpu: 100m
            memory: 100Mi
        ports:
        - containerPort: 6379

1. 应用下面的 redis-follower-deployment.yaml 文件创建 Redis Deployment：

   kubectl apply -f https://k8s.io/examples/application/guestbook/redis-follower-deployment.yaml
   

2. 通过查询 Pods 列表，验证两个 Redis 跟随者副本在运行：

   kubectl get pods
   

   响应应该类似于这样：

   NAME                             READY   STATUS    RESTARTS   AGE
   redis-follower-dddfbdcc9-82sfr   1/1     Running   0          37s
   redis-follower-dddfbdcc9-qrt5k   1/1     Running   0          38s
   redis-leader-fb76b4755-xjr2n     1/1     Running   0          11m
   

创建 Redis 跟随者服务

Guestbook 应用需要与 Redis 跟随者通信以读取数据。 为了让 Redis 跟随者可被发现，你必须创建另一个 Service。

application/guestbook/redis-follower-service.yaml

# SOURCE: https://cloud.google.com/kubernetes-engine/docs/tutorials/guestbook
apiVersion: v1
kind: Service
metadata:
  name: redis-follower
  labels:
    app: redis
    role: follower
    tier: backend
spec:
  ports:
    # the port that this service should serve on
  - port: 6379
  selector:
    app: redis
    role: follower
    tier: backend

1. 应用如下所示 redis-follower-service.yaml 文件中的 Redis Service：

   kubectl apply -f https://k8s.io/examples/application/guestbook/redis-follower-service.yaml
   

2. 查询 Service 列表，验证 Redis 服务在运行：

   kubectl get service
   

   响应应该类似于这样：

   NAME             TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
   kubernetes       ClusterIP   10.96.0.1       <none>        443/TCP    3d19h
   redis-follower   ClusterIP   10.110.162.42   <none>        6379/TCP   9s
   redis-leader     ClusterIP   10.103.78.24    <none>        6379/TCP   6m10s
   

设置并公开留言板前端

现在你有了一个为 Guestbook 应用配置的 Redis 存储处于运行状态， 接下来可以启动 Guestbook 的 Web 服务器了。 与 Redis 跟随者类似，前端也是使用 Kubernetes Deployment 来部署的。

Guestbook 应用使用 PHP 前端。该前端被配置成与后端的 Redis 跟随者或者 领导者服务通信，具体选择哪个服务取决于请求是读操作还是写操作。 前端对外暴露一个 JSON 接口，并提供基于 jQuery-Ajax 的用户体验。

创建 Guestbook 前端 Deployment

application/guestbook/frontend-deployment.yaml

# SOURCE: https://cloud.google.com/kubernetes-engine/docs/tutorials/guestbook
apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend
spec:
  replicas: 3
  selector:
    matchLabels:
        app: guestbook
        tier: frontend
  template:
    metadata:
      labels:
        app: guestbook
        tier: frontend
    spec:
      containers:
      - name: php-redis
        image: gcr.io/google_samples/gb-frontend:v5
        env:
        - name: GET_HOSTS_FROM
          value: "dns"
        resources:
          requests:
            cpu: 100m
            memory: 100Mi
        ports:
        - containerPort: 80

1. 应用来自 frontend-deployment.yaml 文件的前端 Deployment：

   kubectl apply -f https://k8s.io/examples/application/guestbook/frontend-deployment.yaml
   

2. 查询 Pod 列表，验证三个前端副本正在运行：

   kubectl get pods -l app=guestbook -l tier=frontend
   

   响应应该与此类似：

   NAME                        READY   STATUS    RESTARTS   AGE
   frontend-85595f5bf9-5tqhb   1/1     Running   0          47s
   frontend-85595f5bf9-qbzwm   1/1     Running   0          47s
   frontend-85595f5bf9-zchwc   1/1     Running   0          47s
   

创建前端服务

应用的 Redis 服务只能在 Kubernetes 集群中访问，因为服务的默认类型是 ClusterIP。 ClusterIP 为服务指向的 Pod 集提供一个 IP 地址。这个 IP 地址只能在集群中访问。

如果你希望访客能够访问你的 Guestbook，你必须将前端服务配置为外部可见的， 以便客户端可以从 Kubernetes 集群之外请求服务。 然而即便使用了 ClusterIP，Kubernetes 用户仍可以通过 kubectl port-forward 访问服务。

application/guestbook/frontend-service.yaml

# SOURCE: https://cloud.google.com/kubernetes-engine/docs/tutorials/guestbook
apiVersion: v1
kind: Service
metadata:
  name: frontend
  labels:
    app: guestbook
    tier: frontend
spec:
  # if your cluster supports it, uncomment the following to automatically create
  # an external load-balanced IP for the frontend service.
  # type: LoadBalancer
  #type: LoadBalancer
  ports:
    # the port that this service should serve on
  - port: 80
  selector:
    app: guestbook
    tier: frontend

1. 应用来自 frontend-service.yaml 文件中的前端服务：

   kubectl apply -f https://k8s.io/examples/application/guestbook/frontend-service.yaml
   

2. 查询 Service 列表以验证前端服务正在运行:

   kubectl get services
   

   响应应该与此类似：

   NAME             TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
   frontend         ClusterIP   10.97.28.230    <none>        80/TCP     19s
   kubernetes       ClusterIP   10.96.0.1       <none>        443/TCP    3d19h
   redis-follower   ClusterIP   10.110.162.42   <none>        6379/TCP   5m48s
   redis-leader     ClusterIP   10.103.78.24    <none>        6379/TCP   11m
   

通过 kubectl port-forward 查看前端服务

1. 运行以下命令将本机的 8080 端口转发到服务的 80 端口。

   kubectl port-forward svc/frontend 8080:80
   

   响应应该与此类似：

   Forwarding from 127.0.0.1:8080 -> 80
   Forwarding from [::1]:8080 -> 80
   

2. 在浏览器中加载 http://localhost:8080 页面以查看 Guestbook。

通过 LoadBalancer 查看前端服务

如果你部署了 frontend-service.yaml，需要找到用来查看 Guestbook 的 IP 地址。

1. 运行以下命令以获取前端服务的 IP 地址。

   kubectl get service frontend
   

   响应应该与此类似：

   NAME       TYPE           CLUSTER-IP      EXTERNAL-IP        PORT(S)        AGE
   frontend   LoadBalancer   10.51.242.136   109.197.92.229     80:32372/TCP   1m
   

2. 复制这里的外部 IP 地址，然后在浏览器中加载页面以查看留言板。

扩展 Web 前端

你可以根据需要执行伸缩操作，这是因为服务器本身被定义为使用一个 Deployment 控制器的 Service。

1. 运行以下命令扩展前端 Pod 的数量：

   kubectl scale deployment frontend --replicas=5
   

2. 查询 Pod 列表验证正在运行的前端 Pod 的数量：

   kubectl get pods
   

   响应应该类似于这样：

   NAME                             READY   STATUS    RESTARTS   AGE
   frontend-85595f5bf9-5df5m        1/1     Running   0          83s
   frontend-85595f5bf9-7zmg5        1/1     Running   0          83s
   frontend-85595f5bf9-cpskg        1/1     Running   0          15m
   frontend-85595f5bf9-l2l54        1/1     Running   0          14m
   frontend-85595f5bf9-l9c8z        1/1     Running   0          14m
   redis-follower-dddfbdcc9-82sfr   1/1     Running   0          97m
   redis-follower-dddfbdcc9-qrt5k   1/1     Running   0          97m
   redis-leader-fb76b4755-xjr2n     1/1     Running   0          108m
   

3. 运行以下命令缩小前端 Pod 的数量：

   kubectl scale deployment frontend --replicas=2
   

4. 查询 Pod 列表验证正在运行的前端 Pod 的数量：

   kubectl get pods
   

   响应应该类似于这样：

   NAME                             READY   STATUS    RESTARTS   AGE
   frontend-85595f5bf9-cpskg        1/1     Running   0          16m
   frontend-85595f5bf9-l9c8z        1/1     Running   0          15m
   redis-follower-dddfbdcc9-82sfr   1/1     Running   0          98m
   redis-follower-dddfbdcc9-qrt5k   1/1     Running   0          98m
   redis-leader-fb76b4755-xjr2n     1/1     Running   0          109m
   

清理现场

删除 Deployments 和服务还会删除正在运行的 Pod。 使用标签用一个命令删除多个资源。

1. 运行以下命令以删除所有 Pod，Deployments 和 Services。

   kubectl delete deployment -l app=redis
   kubectl delete service -l app=redis
   kubectl delete deployment frontend
   kubectl delete service frontend
   

   响应应该是：

   deployment.apps "redis-follower" deleted
   deployment.apps "redis-leader" deleted
   deployment.apps "frontend" deleted
   service "frontend" deleted
   

2. 查询 Pod 列表，确认没有 Pod 在运行：

   kubectl get pods
   

   响应应该是：

   
   No resources found in default namespace.
   

接下来

• 完成 Kubernetes 基础 交互式教程
• 使用 Kubernetes 创建一个博客，使用 MySQL 和 Wordpress 的持久卷
• 进一步阅读连接应用程序
• 进一步阅读管理资源

6 - 有状态的应用

6.1 - 示例：使用 Persistent Volumes 部署 WordPress 和 MySQL

本示例描述了如何通过 Minikube 在 Kubernetes 上安装 WordPress 和 MySQL。这两个应用都使用 PersistentVolumes 和 PersistentVolumeClaims 保存数据。

PersistentVolume（PV）是一块集群里由管理员手动提供，或 kubernetes 通过 StorageClass 动态创建的存储。 PersistentVolumeClaim（PVC）是一个满足对 PV 存储需要的请求。PersistentVolumes 和 PersistentVolumeClaims 是独立于 Pod 生命周期而在 Pod 重启，重新调度甚至删除过程中保存数据。

教程目标

• 创建 PersistentVolumeClaims 和 PersistentVolumes
• 创建 kustomization.yaml 使用
  • Secret 生成器
  • MySQL 资源配置
  • WordPress 资源配置
• 应用整个 kustomization 目录 kubectl apply -k ./
• 清理

准备开始

你必须拥有一个 Kubernetes 的集群，同时你的 Kubernetes 集群必须带有 kubectl 命令行工具。 建议在至少有两个节点的集群上运行本教程，且这些节点不作为控制平面主机。 如果你还没有集群，你可以通过 Minikube 构建一个你自己的集群，或者你可以使用下面任意一个 Kubernetes 工具构建：

• Katacoda
• 玩转 Kubernetes

此例在kubectl 1.14 或者更高版本有效。

下载下面的配置文件：

1. mysql-deployment.yaml

2. wordpress-deployment.yaml

创建 PersistentVolumeClaims 和 PersistentVolumes

MySQL 和 Wordpress 都需要一个 PersistentVolume 来存储数据。他们的 PersistentVolumeClaims 将在部署步骤中创建。

许多群集环境都安装了默认的 StorageClass。如果在 PersistentVolumeClaim 中未指定 StorageClass，则使用群集的默认 StorageClass。

创建 PersistentVolumeClaim 时，将根据 StorageClass 配置动态设置 PersistentVolume。

创建 kustomization.yaml

创建 Secret 生成器

A Secret 是存储诸如密码或密钥之类的敏感数据的对象。从 1.14 开始，kubectl支持使用 kustomization 文件管理 Kubernetes 对象。您可以通过kustomization.yaml中的生成器创建一个 Secret。

通过以下命令在kustomization.yaml中添加一个 Secret 生成器。您需要用您要使用的密码替换YOUR_PASSWORD。

cat <<EOF >./kustomization.yaml
secretGenerator:
- name: mysql-pass
  literals:
  - password=YOUR_PASSWORD
EOF

补充 MySQL 和 WordPress 的资源配置

以下 manifest 文件描述了单实例 MySQL 部署。MySQL 容器将 PersistentVolume 挂载在/var/lib/mysql。 MYSQL_ROOT_PASSWORD环境变量设置来自 Secret 的数据库密码。

application/wordpress/mysql-deployment.yaml

apiVersion: v1
kind: Service
metadata:
  name: wordpress-mysql
  labels:
    app: wordpress
spec:
  ports:
    - port: 3306
  selector:
    app: wordpress
    tier: mysql
  clusterIP: None
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mysql-pv-claim
  labels:
    app: wordpress
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 20Gi
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: wordpress-mysql
  labels:
    app: wordpress
spec:
  selector:
    matchLabels:
      app: wordpress
      tier: mysql
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: wordpress
        tier: mysql
    spec:
      containers:
      - image: mysql:5.6
        name: mysql
        env:
        - name: MYSQL_ROOT_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mysql-pass
              key: password
        ports:
        - containerPort: 3306
          name: mysql
        volumeMounts:
        - name: mysql-persistent-storage
          mountPath: /var/lib/mysql
      volumes:
      - name: mysql-persistent-storage
        persistentVolumeClaim:
          claimName: mysql-pv-claim

以下 manifest 文件描述了单实例 WordPress 部署。WordPress 容器将网站数据文件位于/var/www/html的 PersistentVolume。WORDPRESS_DB_HOST环境变量集上面定义的 MySQL Service 的名称，WordPress 将通过 Service 访问数据库。WORDPRESS_DB_PASSWORD环境变量设置从 Secret kustomize 生成的数据库密码。

application/wordpress/wordpress-deployment.yaml

apiVersion: v1
kind: Service
metadata:
  name: wordpress
  labels:
    app: wordpress
spec:
  ports:
    - port: 80
  selector:
    app: wordpress
    tier: frontend
  type: LoadBalancer
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: wp-pv-claim
  labels:
    app: wordpress
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 20Gi
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: wordpress
  labels:
    app: wordpress
spec:
  selector:
    matchLabels:
      app: wordpress
      tier: frontend
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: wordpress
        tier: frontend
    spec:
      containers:
      - image: wordpress:4.8-apache
        name: wordpress
        env:
        - name: WORDPRESS_DB_HOST
          value: wordpress-mysql
        - name: WORDPRESS_DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mysql-pass
              key: password
        ports:
        - containerPort: 80
          name: wordpress
        volumeMounts:
        - name: wordpress-persistent-storage
          mountPath: /var/www/html
      volumes:
      - name: wordpress-persistent-storage
        persistentVolumeClaim:
          claimName: wp-pv-claim

1. 下载 MySQL deployment 配置文件。

   curl -LO https://k8s.io/examples/application/wordpress/mysql-deployment.yaml
   

2. 下载 WordPress 配置文件。

   curl -LO https://k8s.io/examples/application/wordpress/wordpress-deployment.yaml
   

3. 补充到 kustomization.yaml 文件。

   cat <<EOF >>./kustomization.yaml
   resources:
     - mysql-deployment.yaml
     - wordpress-deployment.yaml
   EOF
   

应用和验证

kustomization.yaml包含用于部署 WordPress 网站的所有资源以及 MySQL 数据库。您可以通过以下方式应用目录

kubectl apply -k ./

现在，您可以验证所有对象是否存在。

1. 通过运行以下命令验证 Secret 是否存在：

   kubectl get secrets
   

   响应应如下所示：

   NAME                    TYPE                                  DATA   AGE
   mysql-pass-c57bb4t7mf   Opaque                                1      9s
   

2. 验证是否已动态配置 PersistentVolume：

   kubectl get pvc
   

   说明： 设置和绑定 PV 可能要花费几分钟。

   响应应如下所示：

   NAME             STATUS    VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS       AGE
   mysql-pv-claim   Bound     pvc-8cbd7b2e-4044-11e9-b2bb-42010a800002   20Gi       RWO            standard           77s
   wp-pv-claim      Bound     pvc-8cd0df54-4044-11e9-b2bb-42010a800002   20Gi       RWO            standard           77s
   

3. 通过运行以下命令来验证 Pod 是否正在运行：

   kubectl get pods
   

   说明： 等待 Pod 状态变成RUNNING可能会花费几分钟。

   响应应如下所示：

   NAME                               READY     STATUS    RESTARTS   AGE
   wordpress-mysql-1894417608-x5dzt   1/1       Running   0          40s
   

4. 通过运行以下命令来验证 Service 是否正在运行：

   kubectl get services wordpress
   

   响应应如下所示：

   NAME        TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)        AGE
   wordpress   ClusterIP   10.0.0.89    <pending>     80:32406/TCP   4m
   

   说明： Minikube 只能通过 NodePort 公开服务。EXTERNAL-IP 始终处于挂起状态

5. 运行以下命令以获取 WordPress 服务的 IP 地址：

   minikube service wordpress --url
   

   响应应如下所示：

   http://1.2.3.4:32406
   

6. 复制 IP 地址，然后将页面加载到浏览器中来查看您的站点。

   您应该看到类似于以下屏幕截图的 WordPress 设置页面。

   

清理现场

1. 运行一下命令删除您的 Secret，Deployments，Services and PersistentVolumeClaims：

   kubectl delete -k ./
   

接下来

• 了解更多关于 Introspection and Debugging
• 了解更多关于 Jobs
• 了解更多关于 Port Forwarding
• 了解如何 Get a Shell to a Container

6.2 - 示例：使用 StatefulSet 部署 Cassandra

本教程描述拉如何在 Kubernetes 上运行 Apache Cassandra。 数据库 Cassandra 需要永久性存储提供数据持久性（应用 状态）。 在此示例中，自定义 Cassandra seed provider 使数据库在加入 Cassandra 集群时发现新的 Cassandra 实例。

使用 StatefulSets 可以更轻松地将有状态的应用程序部署到你的 Kubernetes 集群中。 有关本教程中使用的功能的更多信息， 参阅 StatefulSet。

教程目标

• 创建并验证 Cassandra 无头（headless）Service..
• 使用 StatefulSet 创建一个 Cassandra ring。
• 验证 StatefulSet。
• 修改 StatefulSet。
• 删除 StatefulSet 及其 Pod.

准备开始

你必须拥有一个 Kubernetes 的集群，同时你的 Kubernetes 集群必须带有 kubectl 命令行工具。 建议在至少有两个节点的集群上运行本教程，且这些节点不作为控制平面主机。 如果你还没有集群，你可以通过 Minikube 构建一个你自己的集群，或者你可以使用下面任意一个 Kubernetes 工具构建：

• Katacoda
• 玩转 Kubernetes

要完成本教程，你应该已经熟悉 Pod， Service和 StatefulSet。

为 Cassandra 创建无头（headless） Services

在 Kubernetes 中，一个 Service 描述了一组执行相同任务的 Pod。

以下 Service 用于在 Cassandra Pod 和集群中的客户端之间进行 DNS 查找：

application/cassandra/cassandra-service.yaml

apiVersion: v1
kind: Service
metadata:
  labels:
    app: cassandra
  name: cassandra
spec:
  clusterIP: None
  ports:
  - port: 9042
  selector:
    app: cassandra

创建一个 Service 来跟踪 cassandra-service.yaml 文件中的所有 Cassandra StatefulSet：

kubectl apply -f https://k8s.io/examples/application/cassandra/cassandra-service.yaml

验证(可选)

获取 Cassandra Service。

kubectl get svc cassandra

响应是：

NAME        TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)    AGE
cassandra   ClusterIP   None         <none>        9042/TCP   45s

如果没有看到名为 cassandra 的服务，则表示创建失败。 请阅读Debug Services，以解决常见问题。

使用 StatefulSet 创建 Cassandra Ring

下面包含的 StatefulSet 清单创建了一个由三个 Pod 组成的 Cassandra ring。

application/cassandra/cassandra-statefulset.yaml

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: cassandra
  labels:
    app: cassandra
spec:
  serviceName: cassandra
  replicas: 3
  selector:
    matchLabels:
      app: cassandra
  template:
    metadata:
      labels:
        app: cassandra
    spec:
      terminationGracePeriodSeconds: 1800
      containers:
      - name: cassandra
        image: gcr.io/google-samples/cassandra:v13
        imagePullPolicy: Always
        ports:
        - containerPort: 7000
          name: intra-node
        - containerPort: 7001
          name: tls-intra-node
        - containerPort: 7199
          name: jmx
        - containerPort: 9042
          name: cql
        resources:
          limits:
            cpu: "500m"
            memory: 1Gi
          requests:
            cpu: "500m"
            memory: 1Gi
        securityContext:
          capabilities:
            add:
              - IPC_LOCK
        lifecycle:
          preStop:
            exec:
              command: 
              - /bin/sh
              - -c
              - nodetool drain
        env:
          - name: MAX_HEAP_SIZE
            value: 512M
          - name: HEAP_NEWSIZE
            value: 100M
          - name: CASSANDRA_SEEDS
            value: "cassandra-0.cassandra.default.svc.cluster.local"
          - name: CASSANDRA_CLUSTER_NAME
            value: "K8Demo"
          - name: CASSANDRA_DC
            value: "DC1-K8Demo"
          - name: CASSANDRA_RACK
            value: "Rack1-K8Demo"
          - name: POD_IP
            valueFrom:
              fieldRef:
                fieldPath: status.podIP
        readinessProbe:
          exec:
            command:
            - /bin/bash
            - -c
            - /ready-probe.sh
          initialDelaySeconds: 15
          timeoutSeconds: 5
        # These volume mounts are persistent. They are like inline claims,
        # but not exactly because the names need to match exactly one of
        # the stateful pod volumes.
        volumeMounts:
        - name: cassandra-data
          mountPath: /cassandra_data
  # These are converted to volume claims by the controller
  # and mounted at the paths mentioned above.
  # do not use these in production until ssd GCEPersistentDisk or other ssd pd
  volumeClaimTemplates:
  - metadata:
      name: cassandra-data
    spec:
      accessModes: [ "ReadWriteOnce" ]
      storageClassName: fast
      resources:
        requests:
          storage: 1Gi
---
kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: fast
provisioner: k8s.io/minikube-hostpath
parameters:
  type: pd-ssd

使用 cassandra-statefulset.yaml 文件创建 Cassandra StatefulSet ：

# 如果你能未经修改地 apply cassandra-statefulset.yaml，请使用此命令
kubectl apply -f https://k8s.io/examples/application/cassandra/cassandra-statefulset.yaml

如果你为了适合你的集群需要修改 cassandra-statefulset.yaml， 下载 https://k8s.io/examples/application/cassandra/cassandra-statefulset.yaml， 然后 apply 修改后的清单。

# 如果使用本地的 cassandra-statefulset.yaml ，请使用此命令
kubectl apply -f cassandra-statefulset.yaml

验证 Cassandra StatefulSet

1.获取 Cassandra StatefulSet:

```shell
kubectl get statefulset cassandra
```

响应应该与此类似：

```
NAME        DESIRED   CURRENT   AGE
cassandra   3         0         13s
```

StatefulSet 资源会按顺序部署 Pod。

2.获取 Pod 查看已排序的创建状态：

```shell
kubectl get pods -l="app=cassandra"
```

响应应该与此类似：

```shell
NAME          READY     STATUS              RESTARTS   AGE
cassandra-0   1/1       Running             0          1m
cassandra-1   0/1       ContainerCreating   0          8s
```

这三个 Pod 要花几分钟的时间才能部署。部署之后，相同的命令将返回类似于以下的输出：

```
NAME          READY     STATUS    RESTARTS   AGE
cassandra-0   1/1       Running   0          10m
cassandra-1   1/1       Running   0          9m
cassandra-2   1/1       Running   0          8m
```

3.运行第一个 Pod 中的 Cassandra nodetool，以显示 ring 的状态。

```shell
kubectl exec -it cassandra-0 -- nodetool status
```

响应应该与此类似：

```
Datacenter: DC1-K8Demo
======================
Status=Up/Down
|/ State=Normal/Leaving/Joining/Moving
--  Address     Load       Tokens       Owns (effective)  Host ID                               Rack
UN  172.17.0.5  83.57 KiB  32           74.0%             e2dd09e6-d9d3-477e-96c5-45094c08db0f  Rack1-K8Demo
UN  172.17.0.4  101.04 KiB  32           58.8%             f89d6835-3a42-4419-92b3-0e62cae1479c  Rack1-K8Demo
UN  172.17.0.6  84.74 KiB  32           67.1%             a6a1e8c2-3dc5-4417-b1a0-26507af2aaad  Rack1-K8Demo
```

修改 Cassandra StatefulSet

使用 kubectl edit 修改 Cassandra StatefulSet 的大小。

1.运行以下命令：

```shell
kubectl edit statefulset cassandra
```

此命令你的终端中打开一个编辑器。需要更改的是 replicas 字段。下面是 StatefulSet 文件的片段示例：

```yaml
# Please edit the object below. Lines beginning with a '#' will be ignored,
# and an empty file will abort the edit. If an error occurs while saving this file will be
# reopened with the relevant failures.
#
apiVersion: apps/v1
kind: StatefulSet
metadata:
  creationTimestamp: 2016-08-13T18:40:58Z
  generation: 1
  labels:
  app: cassandra
  name: cassandra
  namespace: default
  resourceVersion: "323"
  uid: 7a219483-6185-11e6-a910-42010a8a0fc0
spec:
  replicas: 3
```

2.将副本数 (replicas) 更改为 4，然后保存清单。

StatefulSet 现在可以扩展到运行 4 个 Pod。

3.获取 Cassandra StatefulSet 验证更改：

```shell
kubectl get statefulset cassandra
```

响应应该与此类似：

```
NAME        DESIRED   CURRENT   AGE
cassandra   4         4         36m
```

清理现场

删除或缩小 StatefulSet 不会删除与 StatefulSet 关联的卷。 这个设置是出于安全考虑，因为你的数据比自动清除所有相关的 StatefulSet 资源更有价值。

1.运行以下命令（连在一起成为一个单独的命令）删除 Cassandra StatefulSet 中的所有内容：

```shell
grace=$(kubectl get pod cassandra-0 -o=jsonpath='{.spec.terminationGracePeriodSeconds}') \
  && kubectl delete statefulset -l app=cassandra \
  && echo "Sleeping ${grace} seconds" 1>&2 \
  && sleep $grace \
  && kubectl delete persistentvolumeclaim -l app=cassandra
```

2.运行以下命令，删除你为 Cassandra 设置的 Service：

```shell
kubectl delete service -l app=cassandra
```

Cassandra 容器环境变量

本教程中的 Pod 使用来自 Google container registry 的 gcr.io/google-samples/cassandra:v13 镜像。 上面的 Docker 镜像基于 debian-base，并且包含 OpenJDK 8。

该映像包括来自 Apache Debian 存储库的标准 Cassandra 安装。 通过使用环境变量，您可以更改插入到 cassandra.yaml 中的值。

接下来

• 了解如何扩缩 StatefulSet。
• 了解有关 KubernetesSeedProvider 的更多信息
• 查看更多自定义 Seed Provider Configurations