Kubernetes（通常缩写为 K8s）是一个开源的容器编排平台，用于自动化容器的部署、扩展和操作。它提供了一个强大的工具集，使得在大规模容器环境中轻松管理和运行应用程序成为可能。

Kubernetes 的主要目标包括：

• 自动化部署与扩展： Kubernetes 可以自动处理应用程序的部署和扩展，确保它们始终处于所需的状态。
• 容器编排： Kubernetes 可以有效地管理和编排容器，使得多个容器可以协同工作，构建复杂的应用架构。
• 自我修复： 当节点或容器发生故障时，Kubernetes 能够自动修复，确保应用程序的高可用性。

Kubernetes 架构主要包括以下组件：

• Master 节点： 控制整个集群的节点。主要组件包括 API Server、etcd、Controller Manager 和 Scheduler。
• API Server： 提供 Kubernetes API，是集群的前端，接收来自用户或其他组件的请求。
• etcd： 一个高度可靠的分布式键值存储系统，用于存储集群的配置信息。
• Controller Manager： 监视集群状态并作出相应的决策，确保系统达到期望状态。
• Scheduler： 负责将新创建的 Pod 调度到集群中的节点上。
• Node 节点： 运行应用程序和负责维护运行时环境的节点。主要组件包括 Kubelet、kube-proxy 和容器运行时。
• Kubelet： 负责与 Master 节点通信，确保在节点上运行的容器处于健康状态。
• kube-proxy： 负责维护网络规则，允许集群内的 Pod 可以与外部通信。
• 容器运行时： 负责运行容器，例如 Docker、Containerd 等。

目录：

• Kubernetes安装与配置连接到 Kubernetes 集群配置文件详解
• Kubernetes 基本概念PodReplicaSetDeploymentService如何更新 Deployment？如何扩展 Service？注意事项：
• kubectl 基本命令kubectl 常用选项资源查看与操作相关操作如何使用 `kubectl logs` 查看 Pod 日志？如何使用 `kubectl scale` 进行水平扩展？
• 应用管理Deployment 操作Service 操作ConfigMap 与 Secret如何使用 Ingress 控制流量？如何进行滚动回滚？
• 集群管理Node 操作集群扩展与收缩升级与回滚如何使用 Kubelet 参数管理节点？如何备份和还原 etcd 数据？
• 调试与故障排除Pod 调试故障排除如何使用 `kubectl top` 查看资源利用情况？如何使用 `kubectl debug` 进行调试？
• 高级主题RBACHelmOperator如何使用 RBAC 规则限制用户权限？如何在 Helm Chart 中定义依赖？

Kubernetes安装与配置

在使用 Kubernetes 之前，需要安装 kubectl 工具，用于与 Kubernetes 集群进行交互。可以根据不同操作系统使用不同的安装方法，以下是一些示例：

• Linux：

sudo apt-get update && sudo apt-get install -y kubectl

• Windows：

可以通过 Chocolatey 进行安装：

choco install kubernetes-cli

• macOS：

使用 Homebrew 进行安装：

brew install kubectl

连接到 Kubernetes 集群

连接到 Kubernetes 集群的步骤包括获取集群配置文件和设置上下文。在连接之前，确保已经拥有集群的访问权限。

# 获取集群配置文件
kubectl config view

# 切换上下文（替换 YOUR_CLUSTER_NAME）
kubectl config use-context YOUR_CLUSTER_NAME

配置文件详解

Kubernetes 的配置文件包含了与集群、用户、上下文相关的信息。通常存储在 ~/.kube/config 中。

apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: <base64-encoded-ca-cert>
    server: https://<cluster-endpoint>
  name: <cluster-name>
contexts:
- context:
    cluster: <cluster-name>
    user: <user-name>
  name: <context-name>
current-context: <context-name>
kind: Config
preferences: {}
users:
- name: <user-name>
  user:
    client-certificate-data: <base64-encoded-cert>
    client-key-data: <base64-encoded-key>

在配置文件中，可以定义多个集群、用户和上下文，以便在不同环境中切换。配置文件的详细说明有助于理解各项配置的作用。

Kubernetes 基本概念

Pod

Pod 是 Kubernetes 中最小的调度单元，通常包含一个或多个紧密相关的容器。这些容器共享相同的网络命名空间、IP 地址和端口范围，它们可以在同一节点上高效通信。

创建一个简单的 Pod：

apiVersion: v1
kind: Pod
metadata:
  name: mypod
spec:
  containers:
  - name: mycontainer
    image: nginx:latest

上述 YAML 文件描述了一个简单的 Pod，包含一个运行 Nginx 的容器。

ReplicaSet

ReplicaSet 用于确保在集群中运行指定数量的 Pod 副本。如果有 Pod 异常退出，ReplicaSet 会自动创建新的 Pod 以保持期望的副本数。

创建一个 ReplicaSet：

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: my-replicaset
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: mycontainer
        image: nginx:latest

上述 YAML 文件描述了一个 ReplicaSet，期望运行三个 Nginx Pod。

Deployment

Deployment 是用于定义、创建和管理 ReplicaSet 的高级控制器。它允许进行滚动更新、回滚以及伸缩应用程序。

创建一个 Deployment：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: mycontainer
        image: nginx:latest

上述 YAML 文件描述了一个 Deployment，期望运行三个 Nginx Pod。

Service

Service 允许将一组 Pod 暴露为一个网络服务。它可以是 ClusterIP、NodePort、或 LoadBalancer 类型。

创建一个 ClusterIP Service：

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: myapp
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80

上述 YAML 文件描述了一个 ClusterIP Service，将选择器标签为 app: myapp 的 Pod 暴露在集群内部。

如何更新 Deployment？

更新 Deployment 可以通过不同的方法实现，以下是两种常见的更新方式：

1、使用 kubectl apply

通过编辑 Deployment 的 YAML 文件，修改需要更新的字段，然后使用 kubectl apply 命令来应用更新。

kubectl apply -f updated-deployment.yaml

其中，updated-deployment.yaml 是修改后的 Deployment 配置文件。

2、使用 kubectl set image

使用 kubectl set image 命令直接更新 Deployment 中的容器镜像。

kubectl set image deployment/my-deployment my-container=new-image:tag

其中，my-deployment 是 Deployment 的名称，my-container 是容器的名称，new-image:tag 是新的容器镜像及其标签。

这个命令将触发滚动更新，逐步替换现有 Pod 中的容器实例，确保在整个更新过程中保持服务的可用性。

在实际操作中，请根据您的需求选择适当的更新方式。使用 kubectl apply 更适合复杂的更新操作，而 kubectl set image 更简单快捷，适用于简单的容器镜像更新。

如何扩展 Service？

扩展（或缩减）Service的规模可以通过更改关联的Deployment的副本数来实现。Service本身并不直接管理Pod的数量，而是负责将流量路由到与其关联的Pod。因此，要扩展Service，您需要调整Service背后的Pod的数量。

1、查看当前的Deployment副本数

使用以下命令查看当前Deployment的副本数：

kubectl get deployment <deployment-name>

2、扩展Deployment的副本数

使用以下命令来扩展Deployment的副本数：

kubectl scale deployment <deployment-name> --replicas=<desired-replica-count>

将 <deployment-name> 替换为您的Deployment的名称，<desired-replica-count> 替换为您希望的新副本数。

例如，如果您的Deployment名称是 my-deployment，您可以使用以下命令将副本数扩展到3：

kubectl scale deployment my-deployment --replicas=3

3、检查扩展是否成功

使用以下命令检查Deployment的新副本数是否生效：

kubectl get deployment <deployment-name>

注意事项：

• 扩展Deployment的副本数会自动导致关联的Service开始将流量分发给新的Pod。
• 如果您使用自动扩展（Horizontal Pod Autoscaler，HPA），它将根据定义的规则自动调整Pod的数量。

扩展Service可能导致负载均衡器需要一些时间来识别并开始将流量引导到新的Pod。因此，可能会有短暂的过渡期，其中旧的Pod和新的Pod可能同时处于运行状态。

kubectl 基本命令

kubectl 常用选项

kubectl 提供了一些常用的全局选项，使得在不同集群和上下文之间进行切换更加方便。

--namespace

使用 --namespace 选项指定要操作的命名空间，例如：

kubectl get pods --namespace=my-namespace

--context

使用 --context 选项切换到不同的上下文，例如：

kubectl config use-context my-context

--kubeconfig

通过 --kubeconfig 指定不同的 kubeconfig 文件路径：

kubectl --kubeconfig=/path/to/custom/config get pods

资源查看与操作

获取资源信息

查看集群中的所有资源：

kubectl get all

查看特定资源的详细信息：

kubectl get pods
kubectl describe pod <pod-name>

创建资源

通过 kubectl create 命令创建资源：

kubectl create deployment my-deployment --image=nginx:latest

更新资源

使用 kubectl edit 或 kubectl apply 更新资源：

kubectl edit deployment my-deployment
kubectl apply -f updated-deployment.yaml

删除资源

删除资源：

kubectl delete pod <pod-name>
kubectl delete deployment my-deployment

相关操作

查看 Pod 状态

查看 Pod 的状态信息：

kubectl get pods
kubectl describe pod <pod-name>

进入 Pod

使用 kubectl exec 进入正在运行的 Pod：

kubectl exec -it <pod-name> -- /bin/bash

复制文件到/从 Pod

从 Pod 复制文件到本地：

kubectl cp <pod-name>:/path/to/source /path/to/destination

从本地复制文件到 Pod：

kubectl cp /path/to/source <pod-name>:/path/to/destination

如何使用 kubectl logs 查看 Pod 日志？

使用 kubectl logs 命令可以查看 Pod 中容器的日志。以下是基本的使用方法：

kubectl logs <pod-name> [options]

其中，<pod-name> 是要查看日志的 Pod 的名称。您可以使用 kubectl get pods 命令获取 Pod 名称。

一些常用的选项包括：

• -c 或 --container：指定容器的名称，如果 Pod 中有多个容器。
• --follow 或 -f：实时跟踪日志输出，类似于 tail -f。
• --since：指定开始时间，仅显示在该时间之后生成的日志。
• --tail：仅显示指定数量的最新日志行。

以下是一些示例：

查看默认容器的日志：

kubectl logs <pod-name>

查看特定容器的日志：

kubectl logs <pod-name> -c <container-name>

实时跟踪日志输出：

kubectl logs -f <pod-name>

查看最新的5行日志：

kubectl logs --tail=5 <pod-name>

这些命令基于 Pod 处于运行状态。如果 Pod 已经终止，您仍然可以使用 kubectl logs 查看之前的日志。如果 Pod 中有多个容器，您可以使用 -c 选项来指定要查看的容器的名称。

如何使用 kubectl scale 进行水平扩展？

使用 kubectl scale 命令可以方便地进行水平扩展或缩容，调整 Deployment 或 ReplicationController 中的 Pod 副本数量。

以下是 kubectl scale 的基本用法：

kubectl scale deployment <deployment-name> --replicas=<desired-replica-count>

其中，<deployment-name> 是要扩展的 Deployment 的名称，<desired-replica-count> 是您希望的新副本数量。

例如，如果您有一个名为 my-deployment 的 Deployment，要将其副本数量扩展到3，可以使用以下命令：

kubectl scale deployment my-deployment --replicas=3

• 这个命令会导致 Kubernetes 启动或终止 Pod，以使副本数量达到所需的数量。
• 在扩展或缩容过程中，Kubernetes 会逐步创建或终止 Pod，确保应用程序的可用性。
• 如果您使用 Horizontal Pod Autoscaler（HPA），它将自动调整 Pod 的数量，基于您定义的自动伸缩规则。
• 要缩小副本数量，只需将 --replicas 设置为较小的值即可。

查看扩展后的 Deployment 状态：

kubectl get deployment <deployment-name>

这将显示当前副本数量以及所需的副本数量。

应用管理

Deployment 操作

创建 Deployment

使用 kubectl create 命令创建 Deployment：

kubectl create deployment my-deployment --image=nginx:latest

更新 Deployment

通过编辑 Deployment 的 YAML 文件或使用 kubectl set 更新 Deployment：

kubectl set image deployment/my-deployment my-container=nginx:latest

滚动更新

使用滚动更新进行稳健的应用程序更新：

kubectl set image deployment/my-deployment my-container=nginx:latest

Service 操作

创建 Service

通过 kubectl expose 创建 Service：

kubectl expose deployment my-deployment --port=80 --target-port=80 --type=ClusterIP

暴露服务

通过 kubectl port-forward 暴露服务到本地端口：

kubectl port-forward service/my-service 8080:80

Service 类型

• ClusterIP： 在集群内部暴露服务。
• NodePort： 在每个节点上公开一个端口，使服务可以从集群外访问。
• LoadBalancer： 在云服务商上创建负载均衡器。

ConfigMap 与 Secret

创建 ConfigMap

通过 kubectl create configmap 创建 ConfigMap：

kubectl create configmap my-config --from-file=config-files/

创建 Secret

通过 kubectl create secret 创建 Secret：

kubectl create secret generic my-secret --from-file=secrets/

在 Pod 中使用 ConfigMap 与 Secret

在 Pod 的 YAML 文件中引用 ConfigMap 和 Secret：

apiVersion: v1
kind: Pod
metadata:
  name: mypod
spec:
  containers:
  - name: mycontainer
    image: nginx:latest
    volumeMounts:
    - name: config-volume
      mountPath: /etc/config
  volumes:
  - name: config-volume
    configMap:
      name: my-config
  - name: secret-volume
    secret:
      secretName: my-secret

如何使用 Ingress 控制流量？

Ingress 是 Kubernetes 中用于管理和控制 HTTP 和 HTTPS 流量的 API 对象。通过使用 Ingress，您可以定义规则来指定如何将外部流量路由到集群中的服务。

部署 Ingress Controller

首先，您需要在集群中部署 Ingress Controller。不同的云服务商或环境可能有不同的 Ingress Controller，比如 Nginx Ingress Controller、Traefik、或者使用云服务商提供的 Ingress 控制器。

具体安装方式会根据您选择的 Ingress Controller 不同而有所不同。以下是 Nginx Ingress Controller 的示例：

kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/main/deploy/static/provider/cloud/deploy.yaml

创建 Ingress 资源

创建一个 Ingress 资源，并定义流量的规则，例如将流量路由到某个 Service。

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-ingress
spec:
  rules:
  - host: myapp.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: my-service
            port:
              number: 80

上述示例中，流量将被路由到名为 my-service 的服务，并通过 myapp.example.com 的域名来访问。

应用 Ingress 规则

将 Ingress 规则应用到集群：

kubectl apply -f my-ingress.yaml

• 您需要确保 Ingress Controller 已经正常运行，可以通过查看 Ingress Controller 的 Pod 状态来确认。
• 在生产环境中，您可能需要配置域名解析，确保域名能够正确映射到集群的 Ingress IP 地址。
• 您还可以通过 TLS 证书配置来启用 HTTPS 流量，以确保通信的安全性。

请根据您的实际需求和环境配置 Ingress，以实现灵活且可控制的流量管理。

如何进行滚动回滚？

在 Kubernetes 中，可以通过 kubectl rollout 命令进行滚动更新和回滚。

滚动更新 Deployment

滚动更新 Deployment 可以通过修改 Deployment 的 Pod 模板或直接使用 kubectl set image 命令来实现。

通过修改 Pod 模板进行滚动更新：

编辑 Deployment 的 Pod 模板，例如：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
spec:
  replicas: 3
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: mycontainer
        image: nginx:latest

然后，使用 kubectl apply 应用更改：

kubectl apply -f updated-deployment.yaml

通过 kubectl set image 进行滚动更新：

使用 kubectl set image 命令更新 Deployment 中的容器镜像：

kubectl set image deployment/my-deployment my-container=new-image:tag

查看滚动更新状态

您可以使用以下命令查看滚动更新的状态：

kubectl rollout status deployment/my-deployment

滚动回滚

如果滚动更新后发现问题，可以使用 kubectl rollout undo 命令回滚到上一个版本。

kubectl rollout undo deployment/my-deployment

此命令将回滚到上一个部署版本，替换掉当前的 Deployment。

• 滚动回滚将逐步将 Pod 替换为先前的版本，以确保在回滚过程中应用程序的可用性。
• 您可以使用 kubectl rollout history 查看 Deployment 的更新历史，以确定要回滚到哪个版本。
• 滚动回滚只能回滚到最后一次成功的滚动更新版本。

这些命令提供了灵活的滚动更新和回滚机制，以确保在应用程序更新的过程中最大程度地保持可用性。

集群管理

Node 操作

查看 Node 信息

使用 kubectl get nodes 查看集群中所有节点的状态：

kubectl get nodes

标记 Node 不可调度

标记某个节点为不可调度，阻止在该节点上部署新的 Pod：

kubectl cordon <node-name>

节点污点与容忍

为节点添加污点，并定义容忍的 Pod：

kubectl taint nodes <node-name> key=value:NoSchedule

集群扩展与收缩

水平扩展

通过编辑 Deployment 的副本数进行水平扩展：

kubectl scale deployment my-deployment --replicas=5

自动伸缩

使用 Horizontal Pod Autoscaler（HPA）进行自动伸缩：

kubectl autoscale deployment my-deployment --cpu-percent=80 --min=2 --max=10

集群缩容

手动缩减 Deployment 的副本数：

kubectl scale deployment my-deployment --replicas=3

升级与回滚

Kubernetes 版本升级

升级集群的 Kubernetes 版本：

kubeadm upgrade plan
kubeadm upgrade apply <new-version>

回滚操作

回滚 Deployment 到先前的版本：

kubectl rollout undo deployment my-deployment

如何使用 Kubelet 参数管理节点？

Kubelet 是运行在每个节点上的 Kubernetes 组件，负责管理该节点上的容器。您可以通过在 Kubelet 启动时传递命令行参数来配置和管理节点。

使用 kubeadm 初始化节点

如果您使用 kubeadm 初始化 Kubernetes 集群，您可以在初始化节点时通过传递额外的参数来配置 Kubelet。例如：

kubeadm init --kubernetes-version=v1.21.0 --pod-network-cidr=10.244.0.0/16 \
  --apiserver-advertise-address=<node-ip> --feature-gates=PodShareProcessNamespace=true

其中，--feature-gates 参数用于启用或禁用一些功能。在上面的例子中，启用了 PodShareProcessNamespace 特性。

直接修改 Kubelet 配置文件

Kubelet 的配置文件通常位于 /etc/kubernetes/kubelet.conf，您可以通过编辑该文件直接修改 Kubelet 的配置。

apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
featureGates:
  PodShareProcessNamespace: true

编辑配置后，重启 Kubelet 使更改生效：

systemctl restart kubelet

通过命令行参数启动 Kubelet

您也可以通过直接传递命令行参数来启动 Kubelet。例如：

kubelet --feature-gates=PodShareProcessNamespace=true

使用配置文件传递参数

可以通过配置文件传递参数给 Kubelet，然后在启动 Kubelet 时指定该配置文件：

kubelet --config=/etc/kubernetes/kubelet-config.yaml

kubelet-config.yaml 文件内容：

apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
featureGates:
  PodShareProcessNamespace: true

这里的示例中，PodShareProcessNamespace 特性被启用。

如何备份和还原 etcd 数据？

备份和还原 etcd 数据是确保 Kubernetes 集群持久性的重要任务，尤其是在发生故障或升级时。以下是备份和还原 etcd 数据的一般步骤：

备份 etcd 数据

1. 连接到 etcd Pod

首先，您需要连接到运行 etcd 的 Pod。您可以使用以下命令：

kubectl exec -it -n kube-system etcd-{your-etcd-pod-name} -- sh

2. 创建备份

在 etcd Pod 中，使用 etcdctl 工具创建备份。默认情况下，etcd 数据存储在 /var/lib/etcd 目录中。

    etcdctl --endpoints=https://127.0.0.1:2379 --cacert=/etc/kubernetes/pki/etcd/ca.crt \
    --cert=/etc/kubernetes/pki/etcd/healthcheck-client.crt --key=/etc/kubernetes/pki/etcd/healthcheck-client.key \
    snapshot save /path/to/backup.db

请注意替换命令中的证书和键的路径。

3. 将备份文件传输到安全的位置

将备份文件传输到安全的位置，以防止数据丢失。您可以使用 kubectl cp 命令将备份文件复制到本地机器或云存储。

kubectl cp <namespace>/etcd-{your-etcd-pod-name}:/path/to/backup.db /local/path/on/host

还原 etcd 数据

1. 连接到 etcd Pod

使用 kubectl exec 连接到 etcd Pod。

kubectl exec -it -n kube-system etcd-{your-etcd-pod-name} -- sh

2. 还原 etcd 数据

使用 etcdctl 工具进行数据还原。

    etcdctl --endpoints=https://127.0.0.1:2379 --cacert=/etc/kubernetes/pki/etcd/ca.crt \
    --cert=/etc/kubernetes/pki/etcd/healthcheck-client.crt --key=/etc/kubernetes/pki/etcd/healthcheck-client.key \
    --data-dir /var/lib/etcd-from-backup \
    snapshot restore /path/to/backup.db

请注意，--data-dir 参数指定 etcd 存储数据的目录。

3. 重启 etcd Pod

在还原数据后，重启 etcd Pod 以应用更改。

kubectl delete pod -n kube-system etcd-{your-etcd-pod-name}

• 在执行备份和还原操作时，确保 etcd 集群处于稳定状态，并且没有进行活跃的写入操作。
• 在还原数据之前，务必备份当前的 etcd 数据，以便在还原失败时能够回滚。
• 如果您的 etcd 集群是使用外部 etcd 进行管理，还原操作可能需要更多的步骤和注意事项，请参考您使用的外部 etcd 的文档。

确保在执行此类操作之前充分了解 etcd 的工作原理，并进行充分的测试以验证备份和还原的可行性。

调试与故障排除

Pod 调试

Pod 日志查看

查看 Pod 中容器的日志：

kubectl logs <pod-name>

进入运行中的容器

使用 kubectl exec 进入正在运行的容器：

kubectl exec -it <pod-name> -- /bin/bash

执行命令

在运行的容器上执行命令：

kubectl exec <pod-name> -- ls /app

故障排除

查看事件

查看集群中的事件，了解发生的变更和问题：

kubectl get events

Pod 状态异常处理

处理 Pod 状态异常，例如 CrashLoopBackOff：

kubectl describe pod <pod-name>

查看 Pod 的事件和日志，找出问题所在并进行修复。

网络故障排除

检查 Pod 之间的网络连接是否正常：

kubectl describe pod <pod-name>
kubectl describe service <service-name>
kubectl get endpoints <service-name>

解决网络问题，例如防火墙规则或服务配置错误。

如何使用 kubectl top 查看资源利用情况？

kubectl top 是一个用于查看 Kubernetes 集群中 Pod 和节点资源利用情况的命令。您可以使用它来监视 CPU 和内存使用情况。

查看 Pod 的资源利用情况

使用以下命令可以查看特定命名空间中所有 Pod 的资源利用情况：

kubectl top pod -n <namespace>

或者，查看所有命名空间中的 Pod：

kubectl top pod --all-namespaces

查看节点的资源利用情况

要查看集群中所有节点的资源利用情况，可以运行以下命令：

kubectl top node

实时监控

要实时监控资源利用情况，您可以使用 -w 选项：

kubectl top pod -n <namespace> -w

或者：

kubectl top node -w

• kubectl top 需要 Heapster 或 Metrics Server 等监控工具的支持。请确保您的集群中已经安装并配置了相应的监控组件。
• 您可以使用 kubectl top 的不同选项，例如 -l 来选择带有特定标签的 Pod。
• 有关更详细的资源利用信息，可以使用 kubectl describe 命令查看特定 Pod 或节点的详细信息。

确保您的集群中已经设置了适当的监控工具，以便 kubectl top 命令能够正常工作。如果您的集群中没有启用监控组件，可以考虑安装 Metrics Server 或其他类似的工具。

如何使用 kubectl debug 进行调试？

kubectl debug 是一个用于在 Kubernetes 中进行容器调试的插件，它允许您通过进入正在运行的 Pod 中的容器来诊断和解决问题。

安装 kubectl debug

在使用 kubectl debug 之前，需要先安装该插件。您可以使用以下命令安装：

kubectl krew install debug

使用 kubectl debug

1. 选择 Pod 和容器

首先，选择您要调试的 Pod 和容器。使用以下命令：

kubectl get pods

选择要调试的 Pod，并记下 Pod 的名称。

2. 启动调试会话

使用 kubectl debug 命令启动调试会话：

kubectl debug <pod-name> -c <container-name>

其中，<pod-name> 是要调试的 Pod 的名称，<container-name> 是要调试的容器的名称。

3. 进入容器

在调试会话中，您将进入容器的 shell。例如：

root@debugger-<pod-name>:/#

现在，您可以在容器中执行命令、查看日志等。

4. 退出调试会话

当调试完成后，使用 exit 命令退出调试会话：

exit

示例：

kubectl debug my-pod -c my-container

这将在名为 my-pod 的 Pod 中的 my-container 容器上启动一个调试会话。

• 在使用 kubectl debug 之前，请确保您的集群中已经安装并配置了 debug 插件。
• 在调试会话中，您可以执行与容器相关的命令，例如查看日志、修改文件等。
• 调试会话不应该用于在生产环境中更改应用程序状态，因为这可能会导致不可预测的行为。
• 调试会话的退出不会影响正在运行的容器，因为它只是在容器的一个副本中运行。

请谨慎使用 kubectl debug，并确保您了解其对运行中的应用程序的潜在影响。

高级主题

RBAC

创建角色与角色绑定

创建 RBAC 角色：

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: pod-reader
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "list"]

绑定角色到用户或组：

apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: read-pods-global
subjects:
- kind: User
  name: "john"
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io

Helm

安装 Helm

安装 Helm 到集群：

helm init

使用 Helm 部署应用

使用 Helm 创建 Chart：

helm create mychart

通过 Helm 部署应用：

helm install --name=my-release ./mychart

Operator

什么是 Operator

Operator 是一种 Kubernetes 控制器，用于自动化应用程序和工作负载的管理。它可以捕捉和编码操作员的知识，使运维任务自动化。

编写自定义 Operator

使用 Operator SDK 创建自定义 Operator：

operator-sdk new my-operator
operator-sdk add api --api-version=mygroup/v1alpha1 --kind=MyApp
operator-sdk add controller --api-version=mygroup/v1alpha1 --kind=MyApp

实现 Controller 逻辑，并构建 Operator 镜像：

operator-sdk build my-operator
docker push my-operator

如何使用 RBAC 规则限制用户权限？

Role-Based Access Control（RBAC）是 Kubernetes 中一种用于限制对资源的访问的权限控制机制。通过使用 RBAC 规则，您可以为用户、组或服务账户分配特定的权限，以确保安全和最小权限原则。

创建命名空间

首先，为您的应用程序创建一个命名空间，以便将资源组织在一起，并为该命名空间定义 RBAC 规则。

kubectl create namespace mynamespace

创建 ServiceAccount

为您的应用程序创建一个 ServiceAccount，并将其绑定到一个现有的 ClusterRole 或创建一个新的 ClusterRole。ClusterRole 定义了一组权限，例如读取、写入或删除资源。

apiVersion: v1
kind: ServiceAccount
metadata:
  name: myapp-sa
  namespace: mynamespace
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: myapp-role
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "list", "create", "delete"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: myapp-role-binding
subjects:
- kind: ServiceAccount
  name: myapp-sa
  namespace: mynamespace
roleRef:
  kind: ClusterRole
  name: myapp-role
  apiGroup: rbac.authorization.k8s.io

将上述 YAML 文件保存为 rbac.yaml，然后应用它：

kubectl apply -f rbac.yaml

创建 Role 和 RoleBinding（可选）

如果您想在特定命名空间内创建 RBAC 规则，可以使用 Role 和 RoleBinding。

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: myapp-role
  namespace: mynamespace
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "list", "create", "delete"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: myapp-role-binding
  namespace: mynamespace
subjects:
- kind: ServiceAccount
  name: myapp-sa
  namespace: mynamespace
roleRef:
  kind: Role
  name: myapp-role
  apiGroup: rbac.authorization.k8s.io

将上述 YAML 文件保存为 rbac-namespace.yaml，然后应用它：

kubectl apply -f rbac-namespace.yaml

使用 RBAC 规则

现在，您的应用程序可以使用 myapp-sa ServiceAccount 访问 mynamespace 命名空间中的 Pods，并具有定义的权限。确保将 ServiceAccount 分配给您的 Pod。

apiVersion: v1
kind: Pod
metadata:
  name: myapp-pod
  namespace: mynamespace
spec:
  serviceAccountName: myapp-sa
  containers:
  - name: myapp-container
    image: myapp-image

通过使用 RBAC 规则，您可以精确控制哪些用户、组或服务账户可以执行特定的操作，从而提高集群的安全性。确保仔细评估和测试权限，以满足您的实际需求。

如何在 Helm Chart 中定义依赖？

在 Helm Chart 中，您可以通过 Helm 的 requirements.yaml 文件来定义 Chart 之间的依赖关系。这样可以确保在部署 Helm Chart 时，所有相关的依赖 Chart 也会被安装。

创建 requirements.yaml 文件

在您的 Helm Chart 的根目录下创建一个 requirements.yaml 文件，并在其中定义依赖关系。例如：

dependencies:
  - name: mongodb
    version: "10.0.1"
    repository: "https://example.com/charts"
  - name: redis
    version: "7.0.2"
    repository: "https://example.com/charts"

在上述示例中，定义了两个依赖关系：mongodb 和 redis。每个依赖项包括名称、版本和存储库信息。

安装依赖项

在安装您的 Helm Chart 之前，确保先安装所有依赖项。可以使用以下命令：

helm dependency update

这将下载和安装定义在 requirements.yaml 文件中的所有依赖项。

安装 Helm Chart

一旦依赖项安装完毕，您可以按照通常的方式安装 Helm Chart：

helm install myapp ./myapp-chart

这将安装 myapp-chart 及其所有定义的依赖项。

• 当定义依赖关系时，确保提供正确的存储库 URL、Chart 名称和版本信息。
• 使用 helm dependency update 命令来确保所有依赖项被正确安装。
• 如果要卸载 Helm Chart 及其依赖项，可以使用 helm uninstall 命令。
• 在 Helm 3 中，requirements.yaml 已经被移除，取而代之的是 Chart.yaml 中的 dependencies 字段。详细信息可以参考 Helm 3 的文档。

通过定义 Helm Chart 之间的依赖关系，您可以更轻松地管理和部署包含多个相关组件的应用程序。