CKAD考试实操指南（五）--- 定制你的舞台：配置实践要点

原创

知十

修改于 2023-10-13 08:31:14

2460

修改于 2023-10-13 08:31:14

在这篇 CKAD 考试实操指南文章中将为你介绍如何使用知十平台并结合开源项目 CKAD Exercises 中提供的练习题来练习 CKAD 考试中 Configuration 部分的考试内容。在这个过程中你将掌握如何通过 kubectl 命令行工具操作「ConfigMap」、「Secret」、「SecurityContext」、「ServiceAccount」、「ResourceQuota」等资源，并在实践中加深对知识的理解。

实操平台介绍

访问实验平台

在浏览器中输入此网址 https://www.knows10.com 或点击此处进入知十平台。进入后你将看到如下界面：

进入实验环境

点击「Kubernetes 基础环境」图标即可进入实验环境，点击后你将看到如下界面：

官方参考资料

kubectl 命令行工具基础
- 文档路径：kubernetes.io > Documentation > Reference > Command line tool (kubectl) > kubectl Cheat Sheet
- 文档链接：https://kubernetes.io/docs/reference/kubectl/cheatsheet
kubectl 命令行工具进阶
- 文档路径：kubernetes.io > Documentation > Reference > Command line tool (kubectl) > kubectl Cheat Sheet
- 文档链接：https://kubernetes.io/docs/reference/kubectl/cheatsheet
ConfigMaps
- 文档路径：kubernetes.io > Documentation > Concepts > Configuration > ConfigMaps
- 文档链接：https://kubernetes.io/docs/concepts/configuration/configmap
Secrets
- 文档路径：kubernetes.io > Documentation > Concepts > Configuration > Secrets
- 文档链接：https://kubernetes.io/docs/concepts/configuration/secret
Service Accounts
- 文档路径：kubernetes.io > Documentation > Concepts > Security > Service Accounts
- 文档链接：https://kubernetes.io/docs/concepts/security/service-accounts
Security Contexts
- 文档路径：kubernetes.io > Documentation > Concepts > Configuration > SecurityContext
- 文档链接：https://kubernetes.io/docs/tasks/configure-pod-container/security-context
Resource Quotas
- 文档路径：kubernetes.io > Documentation > Concepts > Policies > Resource Quotas
- 文档链接：https://kubernetes.io/docs/concepts/policy/resource-quotas

实操练习

ConfigMaps

Create a configmap named config with values foo=lala,foo2=lolo

译：创建一个名为 config 的 configmap，其值为 foo=lala,foo2=lolo。

kubectl create configmap config --from-literal=foo=lala --from-literal=foo2=lolo

知识点：

ConfigMap 是什么？它有什么作用？

ConfigMap 是 Kubernetes 中的一种资源对象，用于存储应用程序的配置信息。它的应用场景包括但不限于：

将应用程序的配置信息与应用程序本身分离，方便管理和维护。
在不同的环境中使用相同的镜像，通过 ConfigMap 使用不同的配置信息，例如在开发环境和生产环境中使用不同的数据库地址。
允许应用程序在运行时动态地加载配置信息，而不需要重新构建镜像。

举个例子，假设我们有一个使用 MySQL 数据库的应用程序，我们可以将 MySQL 的连接信息存储在一个 ConfigMap 中，然后在应用程序中使用该 ConfigMap 中的信息来连接数据库。这样，我们就可以在不同的环境中使用不同的 MySQL 连接信息，而不需要修改应用程序的代码。

Display its values

译：查看上一题创建的 ConfigMap 的值。

方法一：

kubectl get cm config -o yaml

方法二：

kubectl describe cm config

Create and display a configmap from a file

译：从文件创建一个 ConfigMap 并查看其值。

第一步：创建一个名为 confing.txt 的文件并向文件中写入配置项。

# -e 参数用于解析转义字符 \n，否则 \n 会被当做字符串写入文件。
echo -e "foo3=lili\nfoo4=lele" > config.txt

第二步：从文件创建 ConfigMap。

kubectl create cm configmap2 --from-file=config.txt

第三步：查看创建好的 ConfigMap。

kubectl get cm configmap2 -o yaml

Create and display a configmap from a .env file

译：从 .env 文件创建一个 ConfigMap 并查看其值。

第一步：创建一个名为 config.env 的文件并向文件中写入配置项。

echo -e "var1=val1\n# this is a comment\n\nvar2=val2\n#anothercomment" > config.env

第二步：从文件创建 ConfigMap。

kubectl create cm configmap3 --from-env-file=config.env

第三步：查看创建好的 ConfigMap。

kubectl get cm configmap3 -o yaml

Create and display a configmap from a file, giving the key 'special'

译：从文件创建一个 ConfigMap 并指定 key 为 special，查看其值。

第一步：创建一个名为 config4.txt 的文件并向文件中写入配置项。

echo -e "var3=val3\nvar4=val4" > config4.txt

第二步：从文件创建 ConfigMap。

kubectl create cm configmap4 --from-file=special=config4.txt

第三步：查看创建好的 ConfigMap。

kubectl get cm configmap4 -o yaml

Create a configMap called 'options' with the value var5=val5. Create a new nginx pod that loads the value from variable 'var5' in an env variable called 'option'

译：创建一个名为 options 的 ConfigMap，其值为 var5=val5。创建一个新的 Nginx Pod，从名为 var5 的变量中加载值到名为 option 的环境变量中。

第一步：创建 ConfigMap。

kubectl create cm options --from-literal=var5=val5

第二步：生成创建 Nginx的 YAML 文件。

kubectl run nginx --image=nginx --restart=Never --dry-run=client -o yaml > pod.yaml

第三步：编辑 YAML 文件，添加从 ConfigMap 中加载值到环境变量的配置。

apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
spec:
  containers:
  - image: nginx
    name: nginx
    resources: {}
    env:
    - name: option # 环境变量名
      valueFrom:
        configMapKeyRef: # 表示通过 ConfigMap Key 来获取值，然后赋值给环境变量
          name: options # 之前创建的 ConfigMap 名
          key: var5 # ConfigMap 中的 key 名
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

第四步：创建 Pod。

kubectl create -f pod.yaml

第五步：查看 Pod 的环境变量。

# env 是 Linux 中的一个命令，用于显示所有环境变量。
kubectl exec -it nginx -- env | grep option

第六步：删除 Pod。

  kubectl delete po nginx

Create a configMap 'anotherone' with values 'var6=val6', 'var7=val7'. Load this configMap as env variables into a new nginx pod

译：创建一个名为 anotherone 的 ConfigMap，其值为 var6=val6 和 var7=val7。将这个 ConfigMap 加载到一个新的 Nginx Pod 的环境变量中。

第一步：创建 ConfigMap。

kubectl create configmap anotherone --from-literal=var6=val6 --from-literal=var7=val7

第二步：生成创建 Nginx的 YAML 文件。

kubectl run --restart=Never nginx --image=nginx -o yaml --dry-run=client > pod.yaml

第三步：编辑 YAML 文件，添加从 ConfigMap 中加载值到环境变量的配置。

apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
spec:
  containers:
  - image: nginx
    name: nginx
    resources: {}
    envFrom: # 和前一题的配置不同，前一题是 valueFrom，这里是 envFrom，表示把整个 ConfigMap 加载到环境变量中
    - configMapRef: # 和前一题的配置不同，前一题是 configMapKeyRef（按照 Key 来引用），这里是 configMapRef（直接引用整个 ConfigMap）
        name: anotherone # 被引用的 ConfigMap 名字
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

第四步：创建 Pod。

kubectl create -f pod.yaml

第五步：查看 Pod 的环境变量。

kubectl exec -it nginx -- env | grep var

第六步：删除 Pod。

  kubectl delete po nginx

Create a configMap 'cmvolume' with values 'var8=val8', 'var9=val9'. Load this as a volume inside an nginx pod on path '/etc/lala'. Create the pod and 'ls' into the '/etc/lala' directory

译：创建一个名为 cmvolume 的 ConfigMap，其值为 var8=val8 和 var9=val9。将这个 ConfigMap 作为一个卷挂载到一个 Nginx Pod 的 /etc/lala 目录下。然后创建 Pod 并查看 /etc/lala 目录。

第一步：创建 ConfigMap。

kubectl create configmap cmvolume --from-literal=var8=val8 --from-literal=var9=val9

第二步：生成创建 Nginx的 YAML 文件。

kubectl run nginx --image=nginx --restart=Never -o yaml --dry-run=client > pod.yaml

第三步：编辑 YAML 文件，添加将 ConfigMap 作为卷挂载到 Pod 的 /etc/lala 目录下的配置。

apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
spec:
  volumes:
  - name: myvolume # 卷名，后续在容器中挂载时会用到
    configMap:
      name: cmvolume # 想要挂载的 ConfigMap 名
  containers:
  - image: nginx
    name: nginx
    resources: {}
    volumeMounts: # 配置挂载卷
    - name: myvolume # 在 spec.volumes 中定义的卷名
      mountPath: /etc/lala # 挂载到容器中的目录
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

第四步：创建 Pod。

kubectl create -f pod.yaml

第五步：查看 Pod 的 /etc/lala 目录。

kubectl exec -it nginx -- /bin/sh
cd /etc/lala
ls
cat var8

第六步：删除 Pod。

# 执行此命令前，先退出容器。
kubectl delete po nginx

SecurityContext

Create the YAML for an nginx pod that runs with the user ID 101. No need to create the pod

译：编写一个 Nginx Pod YAML（编写 YAML 即可，不需要创建 Pod），将运行用户 ID 设置为 101。

第一步：生成 YAML 模板文件。

kubectl run nginx --image=nginx --restart=Never --dry-run=client -o yaml > pod.yaml

第二步：编辑 YAML 文件，添加运行用户 ID 为 101 的配置。

apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
spec:
  securityContext: # 在此处添加 securityContext 配置
    runAsUser: 101 # 在此处设置运行用户 ID
  containers:
  - image: nginx
    name: nginx
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

Create the YAML for an nginx pod that has the capabilities "NET_ADMIN", "SYS_TIME" added to its single container

译：编写一个 Nginx Pod YAML（编写 YAML 即可，不需要创建 Pod），将容器的 capabilities 设置为 "NET_ADMIN", "SYS_TIME"。

第一步：生成 YAML 模板文件。

kubectl run nginx --image=nginx --restart=Never --dry-run=client -o yaml > pod.yaml

第二步：编辑 YAML 文件，添加 capabilities 配置。

apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
spec:
  containers:
  - image: nginx
    imagePullPolicy: IfNotPresent
    name: nginx
    securityContext: # 在此处添加 securityContext 配置
      capabilities: # 在此处添加 capabilities 配置
        add: ["NET_ADMIN", "SYS_TIME"] # 在此处设置 capabilities 为 "NET_ADMIN", "SYS_TIME"
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

知识点： Capabilities 是 Linux 的一种权限控制机制，它允许将传统 Unix 的 root 权限细分为多个不同的权限集，这样就可以更精细地控制进程的权限。比如，一个进程可能只需要网络权限，而不需要文件系统权限，那么我们就可以只给这个进程赋予网络权限，而不是全部的 root 权限。详细的权限功能介绍可以参考 capabilities(7) — Linux manual page。此处配置的 NET_ADMIN 和 SYS_TIME 权限的作用如下： - NET_ADMIN：允许容器内进程进行网络配置，如修改接口 IP 地址、路由表、接口状态，防火墙等。 - SYS_TIME：允许容器内进程修改系统时间。

Requests and Limits

Create an nginx pod with requests cpu=100m,memory=256Mi and limits cpu=200m,memory=512Mi

译：创建一个 Nginx Pod，设置其 requests 为 cpu=100m,memory=256Mi，设置其 limits 为 cpu=200m,memory=512Mi。

第一步：生成 YAML 模板文件。

kubectl run nginx --image=nginx --restart=Never --dry-run=client -o yaml > pod.yaml

第二步：编辑 YAML 文件，添加 requests 和 limits 配置。

apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
spec:
  containers:
  - image: nginx
    name: nginx
    resources: # 在此处添加 resources 配置
      requests:
        memory: "256Mi"
        cpu: "100m"
      limits:    
        memory: "512Mi"
        cpu: "200m"
  dnsPolicy: ClusterFirst
  restartPolicy: Always
status: {}

第三步：创建 Pod。

kubectl create -f pod.yaml

第四步：删除 Pod。

kubectl delete po nginx

知识点： - 可以使用以下两种方式配置 CPU 资源： - 核数（Core）：这是一个相对直观的单位，表示 CPU 的物理或逻辑核心数。例如，如果你有一个四核 CPU，你可以将 Kubernetes Pod 的 CPU 资源设置为 1，这意味着 Pod 可以使用一个完整的 CPU 核心。在 Kubernetes 配置中，你可以直接使用数字表示核心数，比如 1、2、3 等。 - 毫核（MilliCore）：这是 Kubernetes 中的一个更精细的单位，用于表示 CPU 资源的一部分。1核等于1000毫核。例如，如果你希望 Pod 使用半个 CPU 核心，你可以将其设置为 500m（m 表示 milli）。这样，Pod 将能够使用 50% 的 CPU 资源。详细的 CPU 资源配置介绍可以参考 CPU resource units。 - 配置 Memory 资源时可以使用如下所示单位： E, P, T, G, M, K 代表 Exa, Peta, Tera, Giga, Mega, Kilo。例如，128M 表示128兆字节。 Ei, Pi, Ti, Gi, Mi, Ki 代表 Exbi, Pebi, Tebi, Gibi, Mebi, Kibi。例如，128Mi 表示大约134217728字节。这两种单位的区别在于，第一种是基于10的幂次（1K = 1000），第二种是基于2的幂次（1Ki = 1024）。详细的 Memory 资源配置介绍可以参考 Memory resource units。

Create a namespace with limit range

译：创建一个带有 limit range 的命名空间。

第一步：创建一个命名空间。

kubectl create ns one

第二步：创建一个名为 limit-range.yaml 的文件，并在其中添加 limit range 配置。

apiVersion: v1
kind: LimitRange
metadata:
  name: ns-memory-limit
  namespace: one
spec:
  limits:
  - max:
      memory: "500Mi"
    min:
      memory: "100Mi"
    type: Container

第三步：创建 limit range。

kubectl apply -f limit-range.yaml

Describe the namespace limitrange

译：查看命名空间的 limit range。

kubectl describe limitrange ns-memory-limit -n one

Create a pod with resources requests memory = half of max memory constraint in namespace

译：创建一个 Pod，设置其 requests 为命名空间中最大内存限制的一半。

第一步：生成 YAML 模板文件。

kubectl run nginx -n one --image=nginx --restart=Never --dry-run=client -o yaml > pod.yaml

第二步：编辑 YAML 文件，添加 requests 配置。

apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
  namespace: one
spec:
  containers:
  - image: nginx
    name: nginx
    resources:
      requests:
        memory: "250Mi"
  dnsPolicy: ClusterFirst
  restartPolicy: Always
status: {}

第三步：创建 Pod。

kubectl create -f pod.yaml

第四步：删除 Pod。

kubectl delete po nginx -n one

Create ResourceQuota in namespace one with hard requests cpu=1, memory=1Gi and hard limits cpu=2, memory=2Gi

译：在命名空间 one 中创建一个 ResourceQuota，设置其 hard requests 为 cpu=1, memory=1Gi，设置其 hard limits 为 cpu=2, memory=2Gi。

第一步：创建一个名为 rq-one.yaml 的文件，并在其中添加 ResourceQuota 配置。

apiVersion: v1
kind: ResourceQuota
metadata:
  name: my-rq
  namespace: one
spec:
  hard:
    requests.cpu: "1"
    requests.memory: 1Gi
    limits.cpu: "2"
    limits.memory: 2Gi

第二步：创建 ResourceQuota。

kubectl apply -f rq-one.yaml

Attempt to create a pod with resource requests cpu=2, memory=3Gi and limits cpu=3, memory=4Gi in namespace one

译：在命名空间 one 中创建一个 Pod，设置其 requests 为 cpu=2, memory=3Gi，设置其 limits 为 cpu=3, memory=4Gi。

第一步：生成 YAML 模板文件。

kubectl run nginx -n one --image=nginx --restart=Never --dry-run=client -o yaml > pod.yaml

第二步：编辑 YAML 文件，添加 requests 和 limits 配置。

apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
  namespace: one
spec:
  containers:
  - image: nginx
    name: nginx
    resources:
      requests:
        memory: "3Gi"
        cpu: "2"
      limits:
        memory: "4Gi"
        cpu: "3"
  dnsPolicy: ClusterFirst
  restartPolicy: Always
status: {}

第三步：创建 Pod。

kubectl create -f pod.yaml

执行第三步命令后应该出现如下所示的错误提示，因为请求的资源超出了 namespace 的配额限制：

Error from server (Forbidden): error when creating "pod.yaml": pods "nginx" is forbidden: exceeded quota: my-rq, requested: limits.cpu=3,limits.memory=4Gi,requests.cpu=2,requests.memory=3Gi, used: limits.cpu=0,limits.memory=0,requests.cpu=0,requests.memory=0, limited: limits.cpu=2,limits.memory=2Gi,requests.cpu=1,requests.memory=1Gi

Create a pod with resource requests cpu=0.5, memory=1Gi and limits cpu=1, memory=2Gi in namespace one

译：在命名空间 one 中创建一个 Pod，设置其 requests 为 cpu=0.5, memory=1Gi，设置其 limits 为 cpu=1, memory=2Gi。

第一步：编辑 pod.yaml 文件并修改 requests 和 limits 配置。

apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
  namespace: one
spec:
  containers:
  - image: nginx
    name: nginx
    resources:
      requests:
        memory: "1Gi"
        cpu: "0.5"
      limits:
        memory: "2Gi"
        cpu: "1"
  dnsPolicy: ClusterFirst
  restartPolicy: Always
status: {}

第二步：创建 Pod。

kubectl create -f pod.yaml

第三步：查看 ResourceQuota。

kubectl get resourcequota -n one

Secrets

Create a secret called mysecret with the values password=mypass

译：创建一个名为 mysecret 的 Secret，其值为 password=mypass。

kubectl create secret generic mysecret --from-literal=password=mypass

知识点：

ConfigMap 与 Secret 的区别是什么？分别在什么场景下使用？

ConfigMap 和 Secret 都是用于存储配置信息的资源类型，但它们的主要区别在于存储的数据类型和使用场景。

ConfigMap通常用于存储和共享非敏感的、非机密的配置信息。例如，你可能有一个应用程序需要一个配置文件，这个文件中包含了一些如服务的端口号、数据库连接的URL等信息。你可以将这些信息存储在 ConfigMap 中，然后在 Pod 的定义中引用这个 ConfigMap，这样，应用程序就可以访问到这些配置信息了。

Secret 用于存储敏感信息，例如密码、API 密钥、OAuth 令牌等。Secret 的数据在存储时会被 Kubernetes 加密，并且在传输过程中也会被加密。在 Pod 的定义中，你可以引用 Secret 以使应用程序可以访问到这些敏感信息。

在选择使用 ConfigMap 还是 Secret 时，主要的考虑因素是你需要存储的信息是否敏感。如果信息是敏感的，那么应该使用 Secret。如果信息不敏感，可以使用 ConfigMap。需要注意的是，虽然 Secret 的数据在存储和传输过程中是加密的，但是在 Pod 内部，应用程序访问到的数据是解密的，因此你还需要确保应用程序本身的安全性。

Create a secret called mysecret2 that gets key/value from a file

译：创建一个名为 mysecret2 的 Secret，其值从文件中获取。

第一步：创建一个名为 username 的文件并向文件中写入配置项。

echo -n admin > username

第二步：创建 Secret。

kubectl create secret generic mysecret2 --from-file=username

Get the value of mysecret2

译：查看 mysecret2 的值。

方法一：直接获取。

kubectl get secret mysecret2 -o yaml

# base64 是一个命令行工具，用于对数据进行 Base64 编码和解码。此处使用 base64 对 Secret 中的 username 字段进行解码。
echo -n YWRtaW4= | base64 -d

方法二：使用 jsonpath 获取。

kubectl get secret mysecret2 -o jsonpath='{.data.username}' | base64 -d

方法三：使用 --template 获取。

# template 接收一个 Go 模板字符串，其中 .data.username 表示获取 Secret 中的 username 字段。
kubectl get secret mysecret2 --template '{{.data.username}}' | base64 -d

方法四：使用 jq 获取。

# jq 是一个命令行 JSON 处理工具。此处使用 jq 并结合 jsonpath 获取 Secret 中的 username 字段。
kubectl get secret mysecret2 -o json | jq -r .data.username | base64 -d

Create an nginx pod that mounts the secret mysecret2 in a volume on path /etc/foo

译：创建一个 Nginx Pod，将 mysecret2 作为一个卷挂载到 /etc/foo 目录下。

第一步：生成 YAML 模板文件。

kubectl run nginx --image=nginx --restart=Never -o yaml --dry-run=client > pod.yaml

第二步：编辑 YAML 文件，添加将 Secret 作为卷挂载到 Pod 的 /etc/foo 目录下的配置。

apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
spec:
  volumes: 
  - name: foo
    secret:
      secretName: mysecret2 # 引用已经创建好的 Secret
  containers:
  - image: nginx
    name: nginx
    resources: {}
    volumeMounts: # 将 Secret 作为卷挂载到 /etc/foo 目录下
    - name: foo
      mountPath: /etc/foo
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

第三步：创建 Pod。

kubectl create -f pod.yaml

第四步：查看挂载到 Pod 的卷。

kubectl exec -it nginx -- /bin/bash
ls /etc/foo
cat /etc/foo/username

Delete the pod you just created and mount the variable 'username' from secret mysecret2 onto a new nginx pod in env variable called 'USERNAME'

译：删除上一题创建的 Pod，然后将 mysecret2 中的 username 变量挂载到一个新的 Nginx Pod 的环境变量 USERNAME 中。

第一步：删除 Pod。

kubectl delete po nginx

第二步：生成 YAML 模板文件。

kubectl run nginx --image=nginx --restart=Never -o yaml --dry-run=client > pod.yaml

第三步：编辑 YAML 文件，添加将 Secret 中的 username 变量挂载到环境变量 USERNAME 中的配置。

apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
spec:
  containers:
  - image: nginx
    name: nginx
    resources: {}
    env:
    - name: USERNAME # 环境变量名
      valueFrom:
        secretKeyRef: # 表示以 Secret 中的某个字段作为环境变量的值
          name: mysecret2 # 引用已经创建好的 Secret
          key: username # 引用 Secret 中的 username 字段
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

第四步：创建 Pod。

kubectl create -f pod.yaml

第五步：查看 Pod 的环境变量。

kubectl exec -it nginx -- env | grep USERNAME | cut -d '=' -f 2

第六步：删除 Pod。

kubectl delete po nginx

Service Accounts

See all the service accounts of the cluster in all namespaces

译：查看集群中所有命名空间的所有 ServiceAccount。

方法一：

kubectl get sa --all-namespaces

方法二：

kubectl get sa -A

Create a new serviceaccount called 'myuser'

译：创建一个名为 myuser 的 ServiceAccount。

kubectl create sa myuser

Create an nginx pod that uses 'myuser' as a service account

译：创建一个 Nginx Pod，使用 myuser 作为 ServiceAccount。

第一步：生成 YAML 模板文件。

kubectl run nginx --image=nginx --restart=Never -o yaml --dry-run=client > pod.yaml

第二步：编辑 YAML 文件，添加 ServiceAccount 配置。

apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx
  name: nginx
spec:
  serviceAccountName: myuser # 此处也可以把 serviceAccountName 改为 serviceAccount
  containers:
  - image: nginx
    imagePullPolicy: IfNotPresent
    name: nginx
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

第三步：创建 Pod。