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

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

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

查看 Deployment：

kubectl get deployments

输出结果类似于这样：

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

查看 Pod：

kubectl get pods

输出结果类似于这样：

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

查看集群事件：
```
kubectl get events
```

查看 kubectl 配置：
```
kubectl config view
```

说明：

有关 kubectl 命令的更多信息，请参阅 kubectl 概述。

创建 Service

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

使用 kubectl expose 命令将 Pod 暴露给公网：
```
kubectl expose deployment hello-node --type=LoadBalancer --port=8080
```
这里的 --type=LoadBalancer 参数表明你希望将你的 Service 暴露到集群外部。

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

查看你创建的 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 访问。

运行下面的命令：
```
minikube service hello-node
```

仅限 Katacoda 环境：单击加号，然后单击 Select port to view on Host 1。

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

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

启用插件

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

列出当前支持的插件：

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

启用插件，例如 metrics-server：

minikube addons enable metrics-server

输出结果类似于这样：

The 'metrics-server' addon is enabled

查看创建的 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

禁用 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 - 创建集群

了解 Kubernetes 集群并使用 Minikube 创建一个简单的集群。

2.1.1 - 使用 Minikube 创建集群

目标

了解 Kubernetes 集群。
了解 Minikube 。
使用在线终端开启一个 Kubernetes 集群。

Kubernetes 集群

Kubernetes 协调一个高可用计算机集群，每个计算机作为独立单元互相连接工作。 Kubernetes 中的抽象允许你将容器化的应用部署到集群，而无需将它们绑定到某个特定的独立计算机。为了使用这种新的部署模型，应用需要以将应用与单个主机分离的方式打包：它们需要被容器化。与过去的那种应用直接以包的方式深度与主机集成的部署模型相比，容器化应用更灵活、更可用。 Kubernetes 以更高效的方式跨集群自动分发和调度应用容器。 Kubernetes 是一个开源平台，并且可应用于生产环境。

一个 Kubernetes 集群包含两种类型的资源:

Master 调度整个集群
Nodes 负责运行应用

总结:

Kubernetes 集群
Minikube

Kubernetes 是一个生产级别的开源平台，可协调在计算机集群内和跨计算机集群的应用容器的部署（调度）和执行.

集群图

Master 负责管理整个集群。 Master 协调集群中的所有活动，例如调度应用、维护应用的所需状态、应用扩容以及推出新的更新。

Node 是一个虚拟机或者物理机，它在 Kubernetes 集群中充当工作机器的角色 每个Node都有 Kubelet , 它管理 Node 而且是 Node 与 Master 通信的代理。 Node 还应该具有用于处理容器操作的工具，例如 Docker 或 rkt 。处理生产级流量的 Kubernetes 集群至少应具有三个 Node，因为如果一个 Node 出现故障其对应的 etcd 成员和控制平面实例都会丢失，并且冗余会受到影响。你可以通过添加更多控制平面节点来降低这种风险。

Master 管理集群，Node 用于托管正在运行的应用。

在 Kubernetes 上部署应用时，你告诉 Master 启动应用容器。 Master 就编排容器在集群的 Node 上运行。 Node 使用 Master 暴露的 Kubernetes API 与 Master 通信。终端用户也可以使用 Kubernetes API 与集群交互。

Kubernetes 既可以部署在物理机上也可以部署在虚拟机上。你可以使用 Minikube 开始部署 Kubernetes 集群。 Minikube 是一种轻量级的 Kubernetes 实现，可在本地计算机上创建 VM 并部署仅包含一个节点的简单集群。 Minikube 可用于 Linux ， macOS 和 Windows 系统。Minikube CLI 提供了用于引导集群工作的多种操作，包括启动、停止、查看状态和删除。在本教程里，你可以使用预装有 Minikube 的在线终端进行体验。

既然你已经知道 Kubernetes 是什么，让我们转到在线教程并启动我们的第一个 Kubernetes 集群！

启动交互教程 ›

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

要与终端交互，请使用桌面/平板

继续阅读第二单元›

2.2 - 部署应用

2.2.1 - 使用 kubectl 创建 Deployment

目标

学习了解应用的部署
使用 kubectl 在 Kubernetes 上部署第一个应用

Kubernetes 部署

一旦运行了 Kubernetes 集群，就可以在其上部署容器化应用程序。为此，你需要创建 Kubernetes Deployment 配置。Deployment 指挥 Kubernetes 如何创建和更新应用程序的实例。创建 Deployment 后，Kubernetes master 将应用程序实例调度到集群中的各个节点上。

创建应用程序实例后，Kubernetes Deployment 控制器会持续监视这些实例。如果托管实例的节点关闭或被删除，则 Deployment 控制器会将该实例替换为集群中另一个节点上的实例。 这提供了一种自我修复机制来解决机器故障维护问题。

在没有 Kubernetes 这种编排系统之前，安装脚本通常用于启动应用程序，但它们不允许从机器故障中恢复。通过创建应用程序实例并使它们在节点之间运行， Kubernetes Deployments 提供了一种与众不同的应用程序管理方法。

总结:

Deployments
Kubectl

Deployment 负责创建和更新应用程序的实例

部署你在 Kubernetes 上的第一个应用程序

你可以使用 Kubernetes 命令行界面 Kubectl 创建和管理 Deployment。Kubectl 使用 Kubernetes API 与集群进行交互。在本单元中，你将学习创建在 Kubernetes 集群上运行应用程序的 Deployment 所需的最常见的 Kubectl 命令。

创建 Deployment 时，你需要指定应用程序的容器镜像以及要运行的副本数。你可以稍后通过更新 Deployment 来更改该信息; 模块 5 和 6 讨论了如何扩展和更新 Deployments。

应用程序需要打包成一种受支持的容器格式，以便部署在 Kubernetes 上

对于我们的第一次部署，我们将使用打包在 Docker 容器中的 Node.js 应用程序。要创建 Node.js 应用程序并部署 Docker 容器，请按照你好 Minikube 教程.

现在你已经了解了 Deployment 的内容，让我们转到在线教程并部署我们的第一个应用程序！

开始交互式教程 ›

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

要与终端进行交互，请使用桌面/平板电脑版本

继续阅读第3单元›

2.3 - 了解你的应用

2.3.1 - 查看 pod 和工作节点

目标

了解 Kubernetes Pod。
了解 Kubernetes 工作节点。
对已部署的应用故障排除。

Kubernetes Pods

在模块 2创建 Deployment 时, Kubernetes 添加了一个 Pod 来托管你的应用实例。Pod 是 Kubernetes 抽象出来的，表示一组一个或多个应用程序容器（如 Docker），以及这些容器的一些共享资源。这些资源包括:

共享存储，当作卷
网络，作为唯一的集群 IP 地址
有关每个容器如何运行的信息，例如容器镜像版本或要使用的特定端口。

Pod 为特定于应用程序的“逻辑主机”建模，并且可以包含相对紧耦合的不同应用容器。例如，Pod 可能既包含带有 Node.js 应用的容器，也包含另一个不同的容器，用于提供 Node.js 网络服务器要发布的数据。Pod 中的容器共享 IP 地址和端口，始终位于同一位置并且共同调度，并在同一工作节点上的共享上下文中运行。

Pod是 Kubernetes 平台上的原子单元。当我们在 Kubernetes 上创建 Deployment 时，该 Deployment 会在其中创建包含容器的 Pod （而不是直接创建容器）。每个 Pod 都与调度它的工作节点绑定，并保持在那里直到终止（根据重启策略）或删除。如果工作节点发生故障，则会在集群中的其他可用工作节点上调度相同的 Pod。

总结:

Pods
工作节点
Kubectl 主要命令

Pod 是一组一个或多个应用程序容器（例如 Docker），包括共享存储（卷), IP 地址和有关如何运行它们的信息。

Pod 概览

工作节点

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

每个 Kubernetes 工作节点至少运行:

Kubelet，负责 Kubernetes 主节点和工作节点之间通信的过程; 它管理 Pod 和机器上运行的容器。
容器运行时（如 Docker）负责从仓库中提取容器镜像，解压缩容器以及运行应用程序。

如果它们紧耦合并且需要共享磁盘等资源，这些容器应在一个 Pod 中编排。

工作节点概览

使用 kubectl 进行故障排除

在模块 2,你使用了 Kubectl 命令行界面。你将继续在第3单元中使用它来获取有关已部署的应用程序及其环境的信息。最常见的操作可以使用以下 kubectl 命令完成：

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

你可以使用这些命令查看应用程序的部署时间，当前状态，运行位置以及配置。

现在我们了解了有关集群组件和命令行的更多信息，让我们来探索一下我们的应用程序。

工作节点是 Kubernetes 中的负责计算的机器，可能是VM或物理计算机，具体取决于集群。多个 Pod 可以在一个工作节点上运行。

开始交互式教程 ›

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

要与终端交互，请使用桌面/平板版本

继续阅读第4单元›

2.4 - 公开地暴露你的应用

2.4.1 - 使用 Service 暴露你的应用

目标

了解 Kubernetes 中的 Service
了解标签(Label) 和标签选择器(Label Selector) 对象如何与 Service 关联
在 Kubernetes 集群外用 Service 暴露应用

Kubernetes Service 总览

Kubernetes Pod 是转瞬即逝的。 Pod 实际上拥有生命周期。当一个工作 Node 挂掉后, 在 Node 上运行的 Pod 也会消亡。 ReplicaSet 会自动地通过创建新的 Pod 驱动集群回到目标状态，以保证应用程序正常运行。换一个例子，考虑一个具有3个副本数的用作图像处理的后端程序。这些副本是可替换的; 前端系统不应该关心后端副本，即使 Pod 丢失或重新创建。也就是说，Kubernetes 集群中的每个 Pod (即使是在同一个 Node 上的 Pod )都有一个唯一的 IP 地址，因此需要一种方法自动协调 Pod 之间的变更，以便应用程序保持运行。

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或更高版本。

更多关于不同 Service 类型的信息可以在使用源 IP 教程。也请参阅连接应用程序和 Service 。

另外，需要注意的是有一些 Service 的用例没有在 spec 中定义selector。一个没有selector创建的 Service 也不会创建相应的端点对象。这允许用户手动将服务映射到特定的端点。没有 selector 的另一种可能是你严格使用type: ExternalName来标记。

总结

将 Pod 暴露给外部通信
跨多个 Pod 的负载均衡
使用标签(Label)

Kubernetes 的 Service 是一个抽象层，它定义了一组 Pod 的逻辑集，并为这些 Pod 支持外部流量暴露、负载平衡和服务发现。

Service 和 Label

Service 通过一组 Pod 路由通信。Service 是一种抽象，它允许 Pod 死亡并在 Kubernetes 中复制，而不会影响应用程序。在依赖的 Pod (如应用程序中的前端和后端组件)之间进行发现和路由是由Kubernetes Service 处理的。

Service 匹配一组 Pod 是使用标签(Label)和选择器(Selector), 它们是允许对 Kubernetes 中的对象进行逻辑操作的一种分组原语。标签(Label)是附加在对象上的键/值对，可以以多种方式使用:

指定用于开发，测试和生产的对象
嵌入版本标签
使用 Label 将对象进行分类

你也可以在创建 Deployment 的同时用 --expose创建一个 Service 。

标签(Label)可以在创建时或之后附加到对象上。他们可以随时被修改。现在使用 Service 发布我们的应用程序并添加一些 Label 。

开始交互式教程›

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

要与终端交互，请使用台式机/平板电脑

继续阅读第5单元›

2.5 - 缩放你的应用

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

目标

用 kubectl 扩缩应用程序

扩缩应用程序

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

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

小结:

扩缩一个 Deployment

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

扩缩概述

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

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

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

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

开始互动教程 ›

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

与终端交互，请使用桌面/平板电脑版本

继续参阅第6单元›

2.6 - 更新你的应用

2.6.1 - 执行滚动更新

目标

使用 kubectl 执行滚动更新。

更新应用程序

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

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

摘要：

更新应用

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

滚动更新概述

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

滚动更新允许以下操作：

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

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

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

启动交互教程›

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

要与终端交互，请使用桌面/平板电脑版本

回到 Kubernetes 的基础›

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

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

教程目标

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

准备开始

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

要获知版本信息，请输入 kubectl version.

此页面上显示的示例适用于 kubectl 1.14 及以上的版本。
理解配置 Pod 以使用 ConfigMap。

真实世界的案例：使用 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://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 公开。

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://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

接下来

了解有关 ConfigMaps 的更多信息。

4 - 安全

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

Note

本教程仅适用于新集群。

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

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

如果你正在运行 v1.26 以外的 Kubernetes 版本，请查阅该版本的文档。

准备开始

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

KinD
kubectl

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

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

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

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

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

输出类似于：

Creating cluster "psa-wo-cluster-pss" ...
✓ Ensuring node image (kindest/node:v1.24.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! 😊

将 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'.

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

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

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

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

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

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 安全准入时，请考虑以下事项：

根据应用于集群的风险状况，更严格的 Pod 安全标准（如 restricted）可能是更好的选择。
对 kube-system 名字空间进行赦免会允许 Pod 在其中以 privileged 模式运行。对于实际使用，Kubernetes 项目强烈建议你应用严格的 RBAC 策略来限制对 kube-system 的访问，遵循最小特权原则。

创建一个配置文件，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/v1
    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

说明：

pod-security.admission.config.k8s.io/v1 配置需要 v1.25+。对于 v1.23 和 v1.24，使用 v1beta1。对于 v1.22，使用 v1alpha1。

在创建集群时配置 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 作为共享目录。

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

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

输出类似于：

Creating cluster "psa-with-cluster-pss" ...
 ✓ Ensuring node image (kindest/node:v1.24.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 🙂

将 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'.

创建以下 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

在集群中创建 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 安全标准

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

Note

本教程仅适用于新集群。

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

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

准备开始

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

KinD
kubectl

创建集群

按照如下方式创建一个 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/

将 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 安全标准

使用内置 Pod 安全准入所支持的标签在此名字空间上启用 Pod 安全标准。在这一步中，我们将根据最新版本（默认值）对基线 Pod 安全标准发出警告。
```
kubectl label --overwrite ns example \
  pod-security.kubernetes.io/warn=baseline \
  pod-security.kubernetes.io/warn-version=latest
```

可以使用标签在任何名字空间上启用多个 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 安全标准

在 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

将 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

将 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.3 - 使用 AppArmor 限制容器对资源的访问

特性状态： Kubernetes v1.4 [beta]

AppArmor 是一个 Linux 内核安全模块，它补充了基于标准 Linux 用户和组的权限，将程序限制在一组有限的资源中。 AppArmor 可以配置为任何应用程序减少潜在的攻击面，并且提供更加深入的防御。它通过调整配置文件进行配置，以允许特定程序或容器所需的访问，如 Linux 权能字、网络访问、文件权限等。每个配置文件都可以在 强制（enforcing） 模式（阻止访问不允许的资源）或 投诉（complain） 模式（仅报告冲突）下运行。

AppArmor 可以通过限制允许容器执行的操作，和/或通过系统日志提供更好的审计来帮助你运行更安全的部署。但是，重要的是要记住 AppArmor 不是灵丹妙药，只能做部分事情来防止应用程序代码中的漏洞。提供良好的限制性配置文件，并从其他角度强化你的应用程序和集群非常重要。

教程目标

查看如何在节点上加载配置文件示例
了解如何在 Pod 上强制执行配置文件
了解如何检查配置文件是否已加载
查看违反配置文件时会发生什么
查看无法加载配置文件时会发生什么

准备开始

确保：

Kubernetes 版本至少是 v1.4 —— AppArmor 在 Kubernetes v1.4 版本中才添加了对 AppArmor 的支持。早于 v1.4 版本的 Kubernetes 组件不知道新的 AppArmor 注解并且将会 默认忽略 提供的任何 AppArmor 设置。为了确保你的 Pod 能够得到预期的保护，必须验证节点的 Kubelet 版本：
```
kubectl get nodes -o=jsonpath=$'{range .items[*]}{@.metadata.name}: {@.status.nodeInfo.kubeletVersion}\n{end}'
```
```
gke-test-default-pool-239f5d02-gyn2: v1.4.0
gke-test-default-pool-239f5d02-x1kf: v1.4.0
gke-test-default-pool-239f5d02-xwux: v1.4.0
```

AppArmor 内核模块已启用 —— 要使 Linux 内核强制执行 AppArmor 配置文件，必须安装并且启动 AppArmor 内核模块。默认情况下，有几个发行版支持该模块，如 Ubuntu 和 SUSE，还有许多发行版提供可选支持。要检查模块是否已启用，请检查 /sys/module/apparmor/parameters/enabled 文件：
```
cat /sys/module/apparmor/parameters/enabled
Y
```
如果 Kubelet 包含 AppArmor 支持（>= v1.4），但是内核模块未启用，它将拒绝运行带有 AppArmor 选项的 Pod。

说明：

Ubuntu 携带了许多没有合并到上游 Linux 内核中的 AppArmor 补丁，包括添加附加钩子和特性的补丁。Kubernetes 只在上游版本中测试过，不承诺支持其他特性。

容器运行时支持 AppArmor —— 目前所有常见的 Kubernetes 支持的容器运行时都应该支持 AppArmor，像 Docker、CRI-O 或 containerd。请参考相应的运行时文档并验证集群是否满足使用 AppArmor 的要求。

配置文件已加载 —— 通过指定每个容器都应使用的 AppArmor 配置文件， AppArmor 会被应用到 Pod 上。如果指定的任何配置文件尚未加载到内核， Kubelet（>= v1.4）将拒绝 Pod。通过检查 /sys/kernel/security/apparmor/profiles 文件，可以查看节点加载了哪些配置文件。例如:
```
ssh gke-test-default-pool-239f5d02-gyn2 "sudo cat /sys/kernel/security/apparmor/profiles | sort"
```
```
apparmor-test-deny-write (enforce)
apparmor-test-audit-write (enforce)
docker-default (enforce)
k8s-nginx (enforce)
```
有关在节点上加载配置文件的详细信息，请参见使用配置文件设置节点。

只要 Kubelet 版本包含 AppArmor 支持(>=v1.4)，如果不满足这些先决条件，Kubelet 将拒绝带有 AppArmor 选项的 Pod。你还可以通过检查节点就绪状况消息来验证节点上的 AppArmor 支持（尽管这可能会在以后的版本中删除）：

kubectl get nodes -o=jsonpath='{range .items[*]}{@.metadata.name}: {.status.conditions[?(@.reason=="KubeletReady")].message}{"\n"}{end}'

gke-test-default-pool-239f5d02-gyn2: kubelet is posting ready status. AppArmor enabled
gke-test-default-pool-239f5d02-x1kf: kubelet is posting ready status. AppArmor enabled
gke-test-default-pool-239f5d02-xwux: kubelet is posting ready status. AppArmor enabled

保护 Pod

说明：

AppArmor 目前处于 Beta 阶段，因此选项以注解形式设定。一旦 AppArmor 支持进入正式发布阶段，注解将被替换为一阶的资源字段（更多详情参见升级到 GA 的途径）。

AppArmor 配置文件是按 逐个容器 的形式来设置的。要指定用来运行 Pod 容器的 AppArmor 配置文件，请向 Pod 的 metadata 添加注解：

container.apparmor.security.beta.kubernetes.io/<container_name>: <profile_ref>

<container_name> 的名称是配置文件所针对的容器的名称，<profile_def> 则设置要应用的配置文件。 <profile_ref> 可以是以下取值之一：

runtime/default 应用运行时的默认配置
localhost/<profile_name> 应用在主机上加载的名为 <profile_name> 的配置文件
unconfined 表示不加载配置文件

有关注解和配置文件名称格式的详细信息，请参阅 API 参考。

Kubernetes AppArmor 强制执行机制首先检查所有先决条件都已满足，然后将所选的配置文件转发到容器运行时进行强制执行。如果未满足先决条件，Pod 将被拒绝，并且不会运行。

要验证是否应用了配置文件，可以在容器创建事件中查找所列出的 AppArmor 安全选项：

kubectl get events | grep Created

22s        22s         1         hello-apparmor     Pod       spec.containers{hello}   Normal    Created     {kubelet e2e-test-stclair-node-pool-31nt}   Created container with docker id 269a53b202d3; Security:[seccomp=unconfined apparmor=k8s-apparmor-example-deny-write]

你还可以通过检查容器的 proc attr，直接验证容器的根进程是否以正确的配置文件运行：

kubectl exec <pod_name> -- cat /proc/1/attr/current

k8s-apparmor-example-deny-write (enforce)

举例

本例假设你已经设置了一个集群使用 AppArmor 支持。

首先，我们需要将要使用的配置文件加载到节点上。配置文件拒绝所有文件写入：

#include <tunables/global>

profile k8s-apparmor-example-deny-write flags=(attach_disconnected) {
  #include <abstractions/base>

  file,

  # 拒绝所有文件写入
  deny /** w,
}

由于我们不知道 Pod 将被调度到哪里，我们需要在所有节点上加载配置文件。在本例中，我们将使用 SSH 来安装概要文件，但是在使用配置文件设置节点中讨论了其他方法。

NODES=(
    # 你的节点的可通过 SSH 访问的域名
    gke-test-default-pool-239f5d02-gyn2.us-central1-a.my-k8s
    gke-test-default-pool-239f5d02-x1kf.us-central1-a.my-k8s
    gke-test-default-pool-239f5d02-xwux.us-central1-a.my-k8s)
for NODE in ${NODES[*]}; do ssh $NODE 'sudo apparmor_parser -q <<EOF
#include <tunables/global>

profile k8s-apparmor-example-deny-write flags=(attach_disconnected) {
  #include <abstractions/base>

  file,

  # Deny all file writes.
  deny /** w,
}
EOF'
done

接下来，我们将运行一个带有拒绝写入配置文件的简单 “Hello AppArmor” Pod：

pods/security/hello-apparmor.yaml

apiVersion: v1
kind: Pod
metadata:
  name: hello-apparmor
  annotations:
    # 告知 Kubernetes 去应用 AppArmor 配置 "k8s-apparmor-example-deny-write"。
    # 请注意，如果节点上运行的 Kubernetes 不是 1.4 或更高版本，此注解将被忽略。
    container.apparmor.security.beta.kubernetes.io/hello: localhost/k8s-apparmor-example-deny-write
spec:
  containers:
  - name: hello
    image: busybox:1.28
    command: [ "sh", "-c", "echo 'Hello AppArmor!' && sleep 1h" ]

kubectl create -f ./hello-apparmor.yaml

如果我们查看 Pod 事件，我们可以看到 Pod 容器是用 AppArmor 配置文件 “k8s-apparmor-example-deny-write” 所创建的：

kubectl get events | grep hello-apparmor

14s        14s         1         hello-apparmor   Pod                                Normal    Scheduled   {default-scheduler }                           Successfully assigned hello-apparmor to gke-test-default-pool-239f5d02-gyn2
14s        14s         1         hello-apparmor   Pod       spec.containers{hello}   Normal    Pulling     {kubelet gke-test-default-pool-239f5d02-gyn2}   pulling image "busybox"
13s        13s         1         hello-apparmor   Pod       spec.containers{hello}   Normal    Pulled      {kubelet gke-test-default-pool-239f5d02-gyn2}   Successfully pulled image "busybox"
13s        13s         1         hello-apparmor   Pod       spec.containers{hello}   Normal    Created     {kubelet gke-test-default-pool-239f5d02-gyn2}   Created container with docker id 06b6cd1c0989; Security:[seccomp=unconfined apparmor=k8s-apparmor-example-deny-write]
13s        13s         1         hello-apparmor   Pod       spec.containers{hello}   Normal    Started     {kubelet gke-test-default-pool-239f5d02-gyn2}   Started container with docker id 06b6cd1c0989

我们可以通过检查该配置文件的 proc attr 来验证容器是否实际使用该配置文件运行：

kubectl exec hello-apparmor -- cat /proc/1/attr/current

k8s-apparmor-example-deny-write (enforce)

最后，我们可以看到，如果我们尝试通过写入文件来违反配置文件会发生什么：

kubectl exec hello-apparmor -- touch /tmp/test

touch: /tmp/test: Permission denied
error: error executing remote command: command terminated with non-zero exit code: Error executing in Docker Container: 1

最后，让我们看看如果我们试图指定一个尚未加载的配置文件会发生什么：

kubectl create -f /dev/stdin <<EOF

apiVersion: v1
kind: Pod
metadata:
  name: hello-apparmor-2
  annotations:
    container.apparmor.security.beta.kubernetes.io/hello: localhost/k8s-apparmor-example-allow-write
spec:
  containers:
  - name: hello
    image: busybox:1.28
    command: [ "sh", "-c", "echo 'Hello AppArmor!' && sleep 1h" ]
EOF
pod/hello-apparmor-2 created

kubectl describe pod hello-apparmor-2

Name:          hello-apparmor-2
Namespace:     default
Node:          gke-test-default-pool-239f5d02-x1kf/
Start Time:    Tue, 30 Aug 2016 17:58:56 -0700
Labels:        <none>
Annotations:   container.apparmor.security.beta.kubernetes.io/hello=localhost/k8s-apparmor-example-allow-write
Status:        Pending
Reason:        AppArmor
Message:       Pod Cannot enforce AppArmor: profile "k8s-apparmor-example-allow-write" is not loaded
IP:
Controllers:   <none>
Containers:
  hello:
    Container ID:
    Image:     busybox
    Image ID:
    Port:
    Command:
      sh
      -c
      echo 'Hello AppArmor!' && sleep 1h
    State:              Waiting
      Reason:           Blocked
    Ready:              False
    Restart Count:      0
    Environment:        <none>
    Mounts:
      /var/run/secrets/kubernetes.io/serviceaccount from default-token-dnz7v (ro)
Conditions:
  Type          Status
  Initialized   True
  Ready         False
  PodScheduled  True
Volumes:
  default-token-dnz7v:
    Type:    Secret (a volume populated by a Secret)
    SecretName:    default-token-dnz7v
    Optional:   false
QoS Class:      BestEffort
Node-Selectors: <none>
Tolerations:    <none>
Events:
  FirstSeen    LastSeen    Count    From                        SubobjectPath    Type        Reason        Message
  ---------    --------    -----    ----                        -------------    --------    ------        -------
  23s          23s         1        {default-scheduler }                         Normal      Scheduled     Successfully assigned hello-apparmor-2 to e2e-test-stclair-node-pool-t1f5
  23s          23s         1        {kubelet e2e-test-stclair-node-pool-t1f5}             Warning        AppArmor    Cannot enforce AppArmor: profile "k8s-apparmor-example-allow-write" is not loaded

注意 Pod 呈现 Pending 状态，并且显示一条有用的错误信息： Pod Cannot enforce AppArmor: profile "k8s-apparmor-example-allow-write" is not loaded。还用相同的消息记录了一个事件。

管理

使用配置文件设置节点

Kubernetes 目前不提供任何本地机制来将 AppArmor 配置文件加载到节点上。有很多方法可以设置配置文件，例如：

通过在每个节点上运行 Pod 的 DaemonSet 来确保加载了正确的配置文件。可以在这里找到实现示例。
在节点初始化时，使用节点初始化脚本(例如 Salt、Ansible 等)或镜像。
通过将配置文件复制到每个节点并通过 SSH 加载它们，如示例。

调度程序不知道哪些配置文件加载到哪个节点上，因此必须将全套配置文件加载到每个节点上。另一种方法是为节点上的每个配置文件（或配置文件类）添加节点标签，并使用节点选择器确保 Pod 在具有所需配置文件的节点上运行。

禁用 AppArmor

如果你不希望 AppArmor 在集群上可用，可以通过命令行标志禁用它：

--feature-gates=AppArmor=false

禁用时，任何包含 AppArmor 配置文件的 Pod 都将导致验证失败，且返回 “Forbidden” 错误。

说明：

即使此 Kubernetes 特性被禁用，运行时仍可能强制执行默认配置文件。当 AppArmor 升级为正式版 (GA) 时，禁用 AppArmor 功能的选项将被删除。

编写配置文件

获得正确指定的 AppArmor 配置文件可能是一件棘手的事情。幸运的是，有一些工具可以帮助你做到这一点：

aa-genprof 和 aa-logprof 通过监视应用程序的活动和日志并准许它所执行的操作来生成配置文件规则。 AppArmor 文档提供了进一步的指导。
bane 是一个用于 Docker的 AppArmor 配置文件生成器，它使用一种简化的画像语言（profile language）。

想要调试 AppArmor 的问题，你可以检查系统日志，查看具体拒绝了什么。 AppArmor 将详细消息记录到 dmesg，错误通常可以在系统日志中或通过 journalctl 找到。更多详细信息参见 AppArmor 失败。

API 参考

Pod 注解

指定容器将使用的配置文件：

键名：container.apparmor.security.beta.kubernetes.io/<container_name>，其中 <container_name> 与 Pod 中某容器的名称匹配。可以为 Pod 中的每个容器指定单独的配置文件。
键值：对配置文件的引用，如下所述

配置文件引用

runtime/default：指默认运行时配置文件。
- 等同于不指定配置文件，只是它仍然需要启用 AppArmor。
- 实际上，许多容器运行时使用相同的 OCI 默认配置文件，在此处定义： https://github.com/containers/common/blob/main/pkg/apparmor/apparmor_linux_template.go
localhost/<profile_name>：按名称引用加载到节点（localhost）上的配置文件。
- 可能的配置文件名在核心策略参考。
unconfined：这相当于为容器禁用 AppArmor。

任何其他配置文件引用格式无效。

接下来

其他资源：

4.4 - 使用 seccomp 限制容器的系统调用

特性状态： Kubernetes v1.19 [stable]

Seccomp 代表安全计算（Secure Computing）模式，自 2.6.12 版本以来，一直是 Linux 内核的一个特性。它可以用来沙箱化进程的权限，限制进程从用户态到内核态的调用。 Kubernetes 能使你自动将加载到节点上的 seccomp 配置文件应用到你的 Pod 和容器。

识别你的工作负载所需要的权限是很困难的。在本篇教程中，你将了解如何将 seccomp 配置文件加载到本地的 Kubernetes 集群中，如何将它们应用到 Pod，以及如何开始制作只为容器进程提供必要的权限的配置文件。

教程目标

了解如何在节点上加载 seccomp 配置文件
了解如何将 seccomp 配置文件应用到容器上
观察容器进程对系统调用的审计
观察指定的配置文件缺失时的行为
观察违反 seccomp 配置文件的行为
了解如何创建细粒度的 seccomp 配置文件
了解如何应用容器运行时所默认的 seccomp 配置文件

准备开始

为了完成本篇教程中的所有步骤，你必须安装 kind 和 kubectl。

本篇教程演示的某些示例仍然是 Beta 状态（自 v1.25 起），另一些示例则仅使用 seccomp 正式发布的功能。你应该确保，针对你使用的版本，正确配置了集群。

本篇教程也使用了 curl 工具来下载示例到你的计算机上。你可以使用其他自己偏好的工具来自适应这些步骤。

说明：

无法将 seccomp 配置文件应用于在容器的 securityContext 中设置了 privileged: true 的容器。特权容器始终以 Unconfined 的方式运行。

下载示例 seccomp 配置文件

这些配置文件的内容将在稍后进行分析，现在先将它们下载到名为 profiles/ 的目录中，以便将它们加载到集群中。

执行这些命令： n:right"> ubernetes/website/main/content/zh-cn/examples/pods/security/seccomp/profiles/audit.json" download="pods/security/seccomp/profiles/audit.json">pods/security/seccomp/profiles/audit.json net/0901162ab78eb4ff2e9e5dc8b17c3824befc91a6/44ccd/images/copycode.svg" style="max-height:24px; cursor: pointer" onclick="copyCode('pods-security-seccomp-profiles-audit-json')" title="Copy pods/security/seccomp/profiles/audit.json to clipboard"> eccomp-profiles-audit-json"> style="background-color:#f8f8f8;-moz-tab-size:4;-o-tab-size:4;tab-size:4;">{ "defaultAction": "SCMP_ACT_LOG" }