K8s系列第十五篇（终篇）：K8s 集群优化实战：性能、稳定性与安全性优化

前言：在上一篇文章中，我们聚焦K8s运维的核心实战------故障排查，详细讲解了故障排查的核心思路、常用命令，通过6类生产环境高频故障的实战演练，手把手教你掌握"定位根源、快速解决"的排查方法，同时推荐了提升排查效率的第三方工具和生产环境最佳实践，结合前面学到的日志收集（EFK/ELK）、监控告警（Prometheus+Grafana）知识，形成了"监控→告警→排查→解决"的完整运维闭环，彻底解决了"遇到故障无从下手"的痛点。

重点回顾3点（衔接上一篇核心）：

1. 故障排查的核心思路是"从现象到本质、从上层到下层、从局部到整体"，遵循"明确现象→定位范围→查看日志指标→验证解决"四步走；

2. 常用排查命令需熟记，重点掌握Pod、Service、节点、核心组件的相关命令，是快速排查故障的基础；

3. 生产环境中，需最大化利用日志和监控，做好故障预防和复盘，避免同类故障重复发生。

正如上一篇结尾预告，本节课是K8s系列的最后一篇文章，也是K8s运维的终极实战环节------集群优化。经过前面14篇的学习，我们已经掌握了K8s的基础入门、核心组件、应用部署、服务暴露、调度自愈、资源限制、日志收集、监控告警、故障排查等全流程技能，能够实现K8s集群的正常部署和日常运维，解决了"能用K8s"的问题。但在生产环境中，仅仅"能用"远远不够，还需要"用好"------确保集群具备高效的性能、稳定的运行状态、可靠的安全性，才能适配生产环境的高并发、高可用、高安全需求。

K8s集群优化的核心是"三位一体"： 性能优化、稳定性优化、安全性优化。 性能优化聚焦"提升集群运行效率，降低资源消耗"；稳定性优化聚焦"减少集群故障，确保服务持续可用"；安全性优化聚焦"防范安全风险，保护集群和应用数据"。本文依然针对小白，延续系列"全程实操、命令可复制、场景化讲解"的风格，从这三个核心维度，手把手教你掌握K8s集群优化的实战方法，结合前面学到的知识，帮你搭建一个高效、稳定、安全的K8s集群，为你的K8s学习之旅画上圆满句号，同时适配生产环境需求和面试重点。

前置要求：已搭建好K8s集群，掌握前面14篇教程的核心知识点（Pod、Deployment、Service、监控、日志、故障排查等）；熟悉Linux系统优化基础；已部署基础应用（如Nginx、Redis），用于优化效果验证；具备基本的资源管理和安全防护意识。

一、性能优化：提升效率，降低资源消耗

K8s集群的性能问题，主要体现在"资源利用率低、调度效率低、网络延迟高"三个方面。小白在部署集群后，很容易出现"CPU、内存浪费严重""Pod调度缓慢""应用访问卡顿"等问题，影响用户体验和集群运行效率。本节从"节点资源优化、Pod调度优化、网络优化、存储优化"四个维度，讲解性能优化的实操方法，帮你提升集群性能，降低资源消耗。

1.1 节点资源优化（核心：提高资源利用率）

节点是K8s集群的基础，节点资源（CPU、内存、磁盘）的利用效率，直接决定了集群的整体性能。常见问题：节点资源分配不合理、无用进程占用资源、磁盘IO性能不足。优化方法如下：

# 1. 查看节点资源使用情况，定位资源浪费问题
kubectl top node  # 查看所有节点CPU、内存使用率
kubectl get pods -n all --field-selector spec.nodeName=<节点名称>  # 查看节点上的Pod资源占用

# 2. 清理节点无用进程和资源，释放资源
# 登录节点，查看无用进程
ssh <节点IP>
ps -ef | grep -v kube | grep -v containerd  # 过滤非K8s相关的无用进程
kill -9 <无用进程ID>  # 终止无用进程

# 3. 优化节点磁盘IO（提升磁盘读写性能）
# 查看磁盘IO使用情况
iostat -x 1  # 查看磁盘IO使用率、响应时间
# 优化方法1：使用SSD磁盘（生产环境推荐，读写速度远高于机械硬盘）
# 优化方法2：清理磁盘碎片（针对机械硬盘）
ssh <节点IP>
fsck /dev/sda1  # 检查并修复磁盘碎片（需卸载磁盘，生产环境需谨慎）
# 优化方法3：限制磁盘IO占用过高的Pod（通过资源限制）
kubectl edit deployment <deployment名称> -n <命名空间>
# 添加磁盘IO限制（需容器运行时支持）
resources:
  limits:
    ephemeral-storage: 10Gi  # 临时存储限制
    storage: 20Gi  # 持久化存储限制

# 4. 节点资源预留（避免资源耗尽，影响K8s核心组件运行）
# 编辑kubelet配置文件，预留资源给节点系统和K8s组件
ssh <节点IP>
vim /etc/kubernetes/kubelet.conf
# 添加资源预留配置（在--kubelet-args中添加）
--system-reserved=cpu=100m,memory=1Gi  # 预留100m CPU、1Gi内存给系统
--kube-reserved=cpu=200m,memory=2Gi    # 预留200m CPU、2Gi内存给K8s组件
# 重启kubelet生效
systemctl restart kubelet

1.2 Pod调度优化（核心：提升调度效率，均衡节点负载）

Pod调度是K8s的核心功能之一，调度效率低、负载不均衡，会导致部分节点资源耗尽、部分节点资源闲置，影响集群整体性能。常见问题：Pod调度缓慢、节点负载不均、调度策略不合理。优化方法如下：

# 1. 查看Pod调度情况，定位调度问题
kubectl get pods -n all -o wide  # 查看Pod分布情况，判断是否负载均衡
kubectl describe pod <pod名称> -n <命名空间>  # 查看Pod调度过程，排查调度失败原因

# 2. 优化调度策略：使用节点亲和性，引导Pod调度到合适节点
# 编辑Deployment，添加节点亲和性配置
kubectl edit deployment <deployment名称> -n <命名空间>
# 在spec.template.spec中添加
affinity:
  nodeAffinity:
    requiredDuringSchedulingIgnoredDuringExecution:  # 调度时必须满足
      nodeSelectorTerms:
      - matchExpressions:
        - key: node-role.kubernetes.io/worker  # 匹配worker节点
          operator: In
          values:
          - worker
    preferredDuringSchedulingIgnoredDuringExecution:  # 优先满足
    - weight: 100
      preference:
        matchExpressions:
        - key: cpu-usage
          operator: Lt
          values:
          - "60"  # 优先调度到CPU使用率低于60%的节点

# 3. 配置Pod反亲和性，避免单个节点部署过多同类Pod
# 在spec.template.spec.affinity中添加
podAntiAffinity:
  preferredDuringSchedulingIgnoredDuringExecution:
  - weight: 100
    podAffinityTerm:
      labelSelector:
        matchExpressions:
        - key: app
          operator: In
          values:
          - nginx  # 避免同一节点部署多个nginx Pod
      topologyKey: kubernetes.io/hostname

# 4. 优化调度器参数，提升调度效率
# 编辑kube-scheduler配置文件（默认在kube-system命名空间）
kubectl edit configmap kube-scheduler-config -n kube-system
# 调整调度器缓存时间、调度周期
apiVersion: kubescheduler.config.k8s.io/v1beta3
kind: KubeSchedulerConfiguration
clientConnection:
  kubeconfig: /etc/kubernetes/scheduler.conf
cacheTTL: 30s  # 调度缓存时间，默认10s，适当延长减少调度开销
leaderElection:
  leaderElect: true
schedulerName: default-scheduler
# 重启kube-scheduler生效
kubectl delete pod -n kube-system -l component=kube-scheduler

1.3 网络优化（核心：降低网络延迟，提升网络吞吐量）

K8s集群的网络通信（Pod之间、Pod与外部）是性能瓶颈之一，尤其是高并发场景下，网络延迟高、吞吐量低，会严重影响应用响应速度。常见问题：网络延迟高、Pod之间通信卡顿、外部访问缓慢。优化方法如下：

# 1. 查看网络延迟和吞吐量，定位网络问题
# 测试Pod之间的网络延迟
kubectl exec -it <pod1名称> -n <命名空间> -- ping <pod2 IP> -c 10  # 查看ping延迟
# 测试网络吞吐量
kubectl exec -it <pod名称> -n <命名空间> -- iperf3 -c <目标IP>  # 需安装iperf3

# 2. 替换网络插件（提升网络性能，生产环境推荐）
# 卸载默认的calico/flannel网络插件（以calico为例）
kubectl delete -f https://docs.projectcalico.org/v3.25/manifests/calico.yaml
# 安装高性能网络插件（如cilium，支持eBPF，性能优于calico/flannel）
helm repo add cilium https://helm.cilium.io/
helm install cilium cilium/cilium --version 1.14.0 -n kube-system \
  --set kubeProxyReplacement=strict \
  --set k8sServiceHost=<kube-apiserver IP> \
  --set k8sServicePort=6443

# 3. 优化Service访问性能（减少网络转发开销）
# 对于高频访问的Service，使用NodePort类型时，优化端口范围
kubectl edit configmap kube-apiserver -n kube-system
# 添加NodePort端口范围配置（--service-node-port-range=30000-32767，默认范围，可根据需求调整）
# 对于内部通信的Service，使用ClusterIP类型，避免外部转发开销

# 4. 开启Pod网络加速（针对高并发场景）
# 编辑Pod配置，开启网络加速（需网络插件支持）
kubectl edit pod <pod名称> -n <命名空间>
# 在spec.template.spec中添加
annotations:
  kubernetes.io/network-accelerator: "true"  # 开启网络加速

# 5. 优化DNS解析性能（减少DNS解析延迟）
# 查看DNS解析延迟
kubectl exec -it <pod名称> -n <命名空间> -- nslookup kubernetes.default.svc.cluster.local
# 优化方法1：增加coredns副本数，提升解析能力
kubectl scale deployment coredns -n kube-system --replicas=3
# 优化方法2：配置DNS缓存（在Pod注解中添加）
annotations:
  dnsPolicy: "ClusterFirstWithHostNet"
  dnsConfig:
    options:
    - name: ndots
      value: "2"
    - name: timeout
      value: "1"  # 解析超时时间，单位秒

1.4 存储优化（核心：提升存储读写性能，减少存储开销）

存储性能直接影响应用的读写速度，尤其是数据库、文件服务等对存储敏感的应用，存储性能不足会导致应用响应缓慢。常见问题：存储读写延迟高、持久化存储占用过大、存储资源浪费。优化方法如下：

# 1. 查看存储使用情况，定位存储问题
# 查看PV/PVC使用情况
kubectl get pv
kubectl get pvc -n <命名空间>
# 查看Pod存储读写情况（需安装相关工具）
kubectl exec -it <pod名称> -n <命名空间> -- dd if=/dev/zero of=/test/file bs=1M count=100  # 测试写速度

# 2. 选择高性能存储类型（生产环境推荐）
# 替换默认存储为SSD持久化存储（以PV为例）
kubectl edit pv <pv名称>
# 修改storageClassName为ssd，确保后端存储为SSD
spec:
  storageClassName: "ssd"
  accessModes:
  - ReadWriteOnce
  capacity:
    storage: 50Gi

# 3. 优化存储挂载参数，提升读写性能
# 编辑PVC，添加挂载参数
kubectl edit pvc <pvc名称> -n <命名空间>
# 在spec中添加
mountOptions:
- noatime  # 禁止更新文件访问时间，减少磁盘IO
- nodiratime  # 禁止更新目录访问时间，减少磁盘IO

# 4. 清理无用存储资源，释放存储空间
# 删除未使用的PV/PVC
kubectl delete pv <无用PV名称>
kubectl delete pvc <无用PVC名称> -n <命名空间>
# 清理Pod临时存储（针对无持久化的Pod）
kubectl exec -it <pod名称> -n <命名空间> -- rm -rf /tmp/*  # 清理临时文件

# 5. 开启存储缓存（针对频繁读写的应用）
# 编辑Deployment，添加存储缓存配置（需存储插件支持）
kubectl edit deployment <deployment名称> -n <命名空间>
# 在spec.template.spec.volumes中添加
volumes:
- name: cache-volume
  emptyDir:
    medium: Memory  # 使用内存作为缓存，提升读写速度

二、稳定性优化：减少故障，确保服务持续可用

K8s集群的稳定性，是生产环境运行的核心保障。小白部署的集群，很容易出现"Pod频繁重启、节点宕机、核心组件故障、服务中断"等问题，影响业务连续性。稳定性优化的核心是"提升集群容灾能力、减少故障发生、快速故障自愈"，本节从"高可用部署、Pod自愈优化、核心组件优化、容灾备份"四个维度，讲解稳定性优化的实操方法，确保集群和应用持续可用。

2.1 集群高可用部署（核心：避免单节点故障导致集群瘫痪）

单节点集群（如单master节点）存在严重的单点故障，一旦master节点宕机，整个集群无法操作；单worker节点故障，所有Pod都会不可用。生产环境必须部署高可用集群，优化方法如下：

# 1. 部署多master节点（高可用核心）
# 现有单master集群扩容为3个master节点（推荐奇数个，避免脑裂）
# 步骤1：在新的master节点上安装容器运行时（containerd）、kubeadm、kubelet
# 步骤2：初始化新master节点（加入现有集群）
kubeadm join <kube-apiserver IP>:6443 --token <token> \
  --discovery-token-ca-cert-hash sha256:<hash值> \
  --control-plane  # 标记为master节点
# 步骤3：复制原master节点的kubeconfig文件到新master节点
scp /etc/kubernetes/admin.conf <新master节点IP>:/etc/kubernetes/
# 步骤4：验证master节点状态
kubectl get nodes  # 查看所有master节点状态为Ready

# 2. 部署多worker节点，实现负载均衡
# 加入新的worker节点（与master节点加入集群类似）
kubeadm join <kube-apiserver IP>:6443 --token <token> \
  --discovery-token-ca-cert-hash sha256:<hash值>
# 验证worker节点状态
kubectl get nodes

# 3. 配置负载均衡器（针对master节点）
# 部署HAProxy作为master节点的负载均衡器（推荐）
# 安装HAProxy
yum install haproxy -y  # CentOS系统
# 配置HAProxy（vim /etc/haproxy/haproxy.cfg）
frontend kubernetes-frontend
  bind *:6443
  mode tcp
  option tcplog
  default_backend kubernetes-backend
backend kubernetes-backend
  mode tcp
  option tcp-check
  balance roundrobin  # 轮询负载均衡
  server master1 <master1 IP>:6443 check fall 3 rise 2
  server master2 <master2 IP>:6443 check fall 3 rise 2
  server master3 <master3 IP>:6443 check fall 3 rise 2
# 重启HAProxy生效
systemctl restart haproxy
systemctl enable haproxy

# 4. 验证高可用：模拟master节点宕机
kubectl delete pod -n kube-system -l component=kube-apiserver -l node=<master1节点名称>
# 查看集群状态，确认其他master节点正常运行，集群可正常操作

2.2 Pod自愈优化（核心：减少Pod故障，快速恢复）

Pod是应用运行的载体，Pod频繁重启、运行异常，会导致应用服务中断。Pod自愈优化的核心是"提前预防故障、快速自动恢复"，优化方法如下：

# 1. 配置Pod健康检查（存活探针、就绪探针），及时发现故障Pod
# 编辑Deployment，添加探针配置
kubectl edit deployment <deployment名称> -n <命名空间>
# 在spec.template.spec.containers中添加
livenessProbe:  # 存活探针：检测Pod是否存活，存活则继续运行，否则重启
  httpGet:
    path: /health  # 应用健康检查接口
    port: 80
  initialDelaySeconds: 30  # 容器启动后，延迟30秒开始检测
  periodSeconds: 10  # 每10秒检测一次
  timeoutSeconds: 5  # 检测超时时间5秒
  failureThreshold: 3  # 连续3次检测失败，重启Pod
readinessProbe:  # 就绪探针：检测Pod是否就绪，就绪则接收请求，否则不转发流量
  httpGet:
    path: /ready
    port: 80
  initialDelaySeconds: 10
  periodSeconds: 5

# 2. 配置Pod自动扩缩容（HPA），应对流量波动，避免Pod过载
# 部署metrics-server（HPA依赖）
kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml
# 编辑Deployment，配置HPA
kubectl autoscale deployment <deployment名称> -n <命名空间> \
  --min=2 --max=10 --cpu-percent=70  # CPU使用率超过70%，自动扩容；低于70%，自动缩容
# 查看HPA状态
kubectl get hpa -n <命名空间>

# 3. 配置Pod反亲和性和节点亲和性，避免Pod集中部署（减少单点故障影响）
# 参考1.2节Pod调度优化的反亲和性配置，避免同一节点部署多个同类Pod
# 确保Pod分布在不同节点，即使某个节点故障，其他节点的Pod可正常运行

# 4. 优化Pod重启策略，减少不必要的重启
# 编辑Pod配置，设置合理的重启策略
kubectl edit pod <pod名称> -n <命名空间>
spec:
  restartPolicy: Always  # 总是重启（默认），适合应用类Pod
  # 对于一次性任务的Pod，设置为OnFailure（失败时重启）或Never（不重启）

2.3 核心组件优化（核心：确保K8s核心组件稳定运行）

K8s核心组件（kube-apiserver、kube-controller-manager、kube-scheduler、etcd）是集群运行的基础，核心组件故障会导致整个集群异常。优化方法如下：

# 1. 优化核心组件资源配置，避免资源不足导致故障
# 编辑核心组件的Deployment/StatefulSet，调整资源限制
# 以kube-apiserver为例
kubectl edit deployment kube-apiserver -n kube-system
spec:
  template:
    spec:
      containers:
      - name: kube-apiserver
        resources:
          requests:
            cpu: 500m
            memory: 1Gi
          limits:
            cpu: 2Gi
            memory: 4Gi  # 根据集群规模调整，避免资源不足

# 2. 配置核心组件日志轮转，避免日志过大占用磁盘
# 编辑核心组件的日志配置（以kube-apiserver为例）
kubectl edit deployment kube-apiserver -n kube-system
spec:
  template:
    spec:
      containers:
      - name: kube-apiserver
        args:
        - --log-dir=/var/log/kubernetes
        - --logtostderr=false
        - --log-rotate-max-files=7  # 保留7个日志文件
        - --log-rotate-max-size=100Mi  # 单个日志文件最大100Mi
# 其他核心组件（kube-controller-manager、kube-scheduler）配置类似

# 3. 优化etcd性能（etcd是集群数据存储核心，性能影响集群稳定性）
# 编辑etcd StatefulSet，优化配置
kubectl edit statefulset etcd -n kube-system
spec:
  template:
    spec:
      containers:
      - name: etcd
        args:
        - --data-dir=/var/lib/etcd
        - --wal-dir=/var/lib/etcd/wal  # 单独挂载wal目录，提升写入性能
        - --snapshot-count=10000  # 每10000次写入生成一次快照
        - --auto-compaction-retention=1h  # 自动压缩数据，保留1小时数据
        resources:
          limits:
            cpu: 1Gi
            memory: 2Gi
# 定期备份etcd数据（参考3.4节容灾备份）

# 4. 配置核心组件自动重启，快速恢复故障
# 编辑核心组件的Deployment，添加重启策略
kubectl edit deployment kube-controller-manager -n kube-system
spec:
  template:
    spec:
      restartPolicy: Always
      containers:
      - name: kube-controller-manager
        livenessProbe:  # 存活探针，故障时自动重启
          httpGet:
            path: /healthz
            port: 10257
            scheme: HTTPS
          initialDelaySeconds: 15
          periodSeconds: 10

2.4 容灾备份（核心：故障时快速恢复集群和数据）

容灾备份是集群稳定性的最后一道保障，即使集群出现严重故障，也能通过备份数据快速恢复，减少业务损失。优化方法如下：

# 1. etcd数据备份（核心，集群所有数据都存储在etcd）
# 手动备份etcd数据
kubectl exec -it <etcd-pod名称> -n kube-system -- etcdctl --endpoints=https://127.0.0.1:2379 \
  --cacert=/etc/kubernetes/pki/etcd/ca.crt \
  --cert=/etc/kubernetes/pki/etcd/server.crt \
  --key=/etc/kubernetes/pki/etcd/server.key \
  snapshot save /var/lib/etcd/etcd-snapshot-$(date +%Y%m%d).db

# 配置定时备份（通过crontab）
# 登录master节点，创建备份脚本
vim /root/etcd-backup.sh
#!/bin/bash
ETCD_POD=$(kubectl get pods -n kube-system -l component=etcd -o jsonpath='{.items[0].metadata.name}')
kubectl exec -it $ETCD_POD -n kube-system -- etcdctl --endpoints=https://127.0.0.1:2379 \
  --cacert=/etc/kubernetes/pki/etcd/ca.crt \
  --cert=/etc/kubernetes/pki/etcd/server.crt \
  --key=/etc/kubernetes/pki/etcd/server.key \
  snapshot save /var/lib/etcd/etcd-snapshot-$(date +%Y%m%d).db
# 清理7天前的备份文件
find /var/lib/etcd -name "etcd-snapshot-*.db" -mtime +7 -delete

# 给脚本添加执行权限
chmod +x /root/etcd-backup.sh
# 添加定时任务（每天凌晨2点执行备份）
crontab -e
0 2 * * * /root/etcd-backup.sh

# 2. 应用配置备份（Deployment、Service、ConfigMap等）
# 备份指定命名空间的所有资源
kubectl get all,configmap,secret -n <命名空间> -o yaml > app-backup-$(date +%Y%m%d).yaml
# 备份整个集群的所有资源
kubectl get all,configmap,secret --all-namespaces -o yaml > cluster-backup-$(date +%Y%m%d).yaml

# 3. 节点故障恢复（针对worker节点故障）
# 当worker节点宕机，快速替换节点
# 步骤1：删除故障节点
kubectl delete node <故障节点名称>
# 步骤2：部署新的worker节点，加入集群（参考2.1节加入worker节点）
# 步骤3：Pod会自动调度到新的worker节点，恢复服务

# 4. 备份数据恢复（以etcd数据恢复为例）
# 模拟etcd故障，恢复数据
kubectl exec -it <etcd-pod名称> -n kube-system -- etcdctl --endpoints=https://127.0.0.1:2379 \
  --cacert=/etc/kubernetes/pki/etcd/ca.crt \
  --cert=/etc/kubernetes/pki/etcd/server.crt \
  --key=/etc/kubernetes/pki/etcd/server.key \
  snapshot restore /var/lib/etcd/etcd-snapshot-20260310.db --data-dir=/var/lib/etcd/restore
# 重启etcd Pod，加载恢复的数据
kubectl delete pod <etcd-pod名称> -n kube-system

三、安全性优化：防范风险，保护集群和应用数据

K8s集群的安全性，是生产环境的重中之重。小白部署的集群，很容易存在"权限配置过宽、镜像不安全、网络无隔离、敏感数据泄露"等安全风险，可能导致集群被攻击、数据被窃取。安全性优化的核心是"最小权限原则、安全隔离、敏感数据保护"，本节从"权限控制优化、镜像安全优化、网络安全优化、敏感数据保护"四个维度，讲解安全性优化的实操方法，防范安全风险。

3.1 权限控制优化（核心：最小权限原则，避免权限滥用）

K8s的权限控制核心是RBAC（基于角色的访问控制），小白很容易给用户、Pod分配过高的权限，导致权限滥用，引发安全风险。优化方法如下：

# 1. 查看当前权限配置，排查过高权限
# 查看所有ClusterRole和Role
kubectl get clusterroles
kubectl get roles -n <命名空间>
# 查看权限绑定
kubectl get clusterrolebindings
kubectl get rolebindings -n <命名空间>

# 2. 遵循最小权限原则，创建自定义Role/ClusterRole
# 示例：创建一个仅能查看default命名空间Pod的Role
kubectl create role pod-reader -n default --verb=get,list,watch --resource=pods
# 创建RoleBinding，将Role绑定到用户
kubectl create rolebinding pod-reader-binding -n default --role=pod-reader --user=test-user

# 3. 限制Pod的权限（避免Pod拥有过高权限）
# 编辑Pod配置，添加安全上下文，限制Pod权限
kubectl edit pod <pod名称> -n <命名空间>
spec:
  securityContext:
    runAsUser: 1000  # 以普通用户身份运行Pod，避免root用户
    runAsGroup: 1000
    fsGroup: 1000
    allowPrivilegeEscalation: false  # 禁止权限提升
    capabilities:
      drop: ["ALL"]  # 禁用所有额外权限

# 4. 禁止使用特权容器（特权容器拥有主机的所有权限，风险极高）
# 查看所有特权容器
kubectl get pods --all-namespaces -o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.spec.containers[*].securityContext.privileged}{"\n"}{end}' | grep true
# 删除特权容器，或修改配置禁用特权
kubectl edit pod <特权Pod名称> -n <命名空间>
spec:
  containers:
  - name: <容器名称>
    securityContext:
      privileged: false  # 禁用特权

# 5. 限制kubeconfig文件的权限（避免泄露）
# 修改kubeconfig文件权限，仅当前用户可读写
chmod 600 /etc/kubernetes/admin.conf
# 避免将kubeconfig文件泄露给无关人员

3.2 镜像安全优化（核心：避免使用不安全镜像，防范镜像攻击）

镜像是Pod运行的基础，使用不安全的镜像（如恶意镜像、未授权镜像、存在漏洞的镜像），会导致集群被攻击。优化方法如下：

# 1. 禁止使用latest标签镜像（latest标签镜像易被篡改，版本不固定）
# 查看所有使用latest标签的Pod
kubectl get pods --all-namespaces -o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.spec.containers[*].image}{"\n"}{end}' | grep :latest
# 修改Pod配置，使用固定版本镜像（如nginx:1.24，而非nginx:latest）
kubectl edit deployment <deployment名称> -n <命名空间>
spec:
  template:
    spec:
      containers:
      - name: nginx
        image: nginx:1.24  # 固定版本，避免使用latest

# 2. 配置镜像拉取策略，禁止拉取未授权镜像
# 编辑Pod配置，设置镜像拉取策略为OnlyIfNotPresent（仅本地没有时拉取）
kubectl edit pod <pod名称> -n <命名空间>
spec:
  containers:
  - name: <容器名称>
    image: <镜像名称:版本>
    imagePullPolicy: OnlyIfNotPresent
# 配置镜像拉取密钥（针对私有仓库，避免未授权拉取）
kubectl create secret docker-registry regcred -n <命名空间> \
  --docker-server=<私有仓库地址> \
  --docker-username=<用户名> \
  --docker-password=<密码>
# 在Pod中引用密钥
kubectl edit pod <pod名称> -n <命名空间>
spec:
  imagePullSecrets:
  - name: regcred

# 3. 扫描镜像漏洞，删除存在高危漏洞的镜像
# 安装镜像扫描工具（如trivy）
curl -sfL https://raw.githubusercontent.com/aquasecurity/trivy/main/contrib/install.sh | sh -s -- -b /usr/local/bin
# 扫描镜像漏洞
trivy image nginx:1.24  # 扫描指定镜像
# 删除存在高危漏洞的镜像，替换为安全镜像
kubectl edit deployment <deployment名称> -n <命名空间>
# 将存在漏洞的镜像替换为无高危漏洞的版本

# 4. 禁止拉取外部镜像（生产环境推荐，仅允许拉取内部私有仓库镜像）
# 配置PodSecurityPolicy，禁止拉取外部镜像（需开启PodSecurityPolicy插件）
kubectl create podsecuritypolicy restrict-external-images \
  --allow-privilege-escalation=false \
  --default-allow-privilege-escalation=false \
  --required-drop-capabilities=ALL \
  --allowed-images=<私有仓库地址>/*  # 仅允许拉取内部私有仓库镜像

3.3 网络安全优化（核心：网络隔离，防范网络攻击）

K8s集群的网络默认是开放的，Pod之间、Pod与外部之间可以自由通信，容易引发网络攻击（如端口扫描、恶意访问）。优化方法如下：

# 1. 配置网络策略（NetworkPolicy），实现网络隔离
# 示例：创建NetworkPolicy，仅允许default命名空间的nginx Pod被同命名空间的web Pod访问
kubectl apply -f - <<EOF
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: nginx-network-policy
  namespace: default
spec:
  podSelector:
    matchLabels:
      app: nginx  # 目标Pod标签
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: web  # 仅允许app=web的Pod访问
    ports:
    - protocol: TCP
      port: 80  # 仅允许访问80端口
EOF

# 2. 限制Pod的网络访问端口，仅开放必要端口
# 编辑Pod配置，限制容器开放的端口
kubectl edit pod <pod名称> -n <命名空间>
spec:
  containers:
  - name: <容器名称>
    ports:
    - containerPort: 80  # 仅开放必要的80端口，关闭其他无用端口

# 3. 禁止Pod访问外部网络（针对不需要外部访问的Pod）
# 配置NetworkPolicy，禁止Pod访问外部网络
kubectl apply -f - <<EOF
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-external-network
  namespace: default
spec:
  podSelector:
    matchLabels:
      app: internal-app  # 不需要外部访问的Pod标签
  policyTypes:
  - Egress
  egress:
  - to:
    - podSelector: {}  # 仅允许访问同命名空间的Pod
EOF

# 4. 配置防火墙，限制集群节点的网络访问
# 登录节点，配置防火墙（以firewalld为例）
ssh <节点IP>
systemctl start firewalld
systemctl enable firewalld
# 开放必要端口（如6443、2379、10250等K8s核心端口）
firewall-cmd --permanent --add-port=6443/tcp
firewall-cmd --permanent --add-port=2379/tcp
firewall-cmd --permanent --add-port=10250/tcp
# 关闭无用端口
firewall-cmd --permanent --remove-port=8080/tcp
# 重新加载防火墙
firewall-cmd --reload

3.4 敏感数据保护（核心：避免敏感数据泄露）

生产环境中，Pod往往需要使用敏感数据（如数据库密码、API密钥、证书），小白很容易将敏感数据直接写在配置文件中，导致数据泄露。优化方法如下：

# 1. 使用Secret存储敏感数据，替代明文配置
# 创建Secret，存储数据库密码和API密钥
kubectl create secret generic app-secrets -n <命名空间> \
  --from-literal=db-password=Admin@123 \
  --from-literal=api-key=abc123456
# 在Pod中引用Secret（通过环境变量）
kubectl edit deployment <deployment名称> -n <命名空间>
spec:
  template:
    spec:
      containers:
      - name: <容器名称>
        env:
        - name: DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: app-secrets
              key: db-password
        - name: API_KEY
          valueFrom:
            secretKeyRef:
              name: app-secrets
              key: api-key

# 2. 使用ConfigMap存储非敏感配置，分离敏感与非敏感数据
# 创建ConfigMap，存储应用非敏感配置（如端口、日志级别）
kubectl create configmap app-config -n <命名空间> \
  --from-literal=app-port=80 \
  --from-literal=log-level=info
# 在Pod中引用ConfigMap
kubectl edit deployment <deployment名称> -n <命名空间>
spec:
  template:
    spec:
      containers:
      - name: <容器名称>
        env:
        - name: APP_PORT
          valueFrom:
            configMapKeyRef:
              name: app-config
              key: app-port

# 3. 加密Secret数据（避免Secret明文存储）
# 编辑K8s加密配置文件，创建加密密钥
vim /etc/kubernetes/encryption-config.yaml
apiVersion: apiserver.config.k8s.io/v1
kind: EncryptionConfiguration
resources:
- resources:
  - secrets
  providers:
  - aescbc:
      keys:
      - name: key1
        secret: <生成的AES密钥>  # 使用openssl rand -hex 32生成密钥
  - identity: {}
# 编辑kube-apiserver配置，引用加密配置文件
kubectl edit deployment kube-apiserver -n kube-system
spec:
  template:
    spec:
      containers:
      - name: kube-apiserver
        args:
        - --encryption-provider-config=/etc/kubernetes/encryption-config.yaml
# 重启kube-apiserver生效
kubectl delete pod -n kube-system -l component=kube-apiserver
# 重新创建Secret，使其被加密存储
kubectl delete secret app-secrets -n <命名空间>
kubectl create secret generic app-secrets -n <命名空间> \
  --from-literal=db-password=Admin@123 \
  --from-literal=api-key=abc123456

# 4. 限制Secret的访问权限，仅授权用户和Pod可访问
# 创建Role，仅允许查看和使用Secret
kubectl create role secret-user -n <命名空间> --verb=get,use --resource=secrets
# 创建RoleBinding，绑定到指定用户和Pod
kubectl create rolebinding secret-user-binding -n <命名空间> --role=secret-user --user=test-user

四、生产环境优化最佳实践（面试必问）

结合前面的性能、稳定性、安全性优化实操，本节总结生产环境K8s集群优化的最佳实践，帮助小白规范优化流程，避免踩坑，同时应对面试提问，重点关注"高效、稳定、安全"三个核心目标。

4.1 优化流程规范化

• 先监控后优化：优化前，通过Prometheus+Grafana监控集群和应用的性能、资源使用情况，定位优化痛点，避免盲目优化；

• 先测试后上线：所有优化操作（如网络插件替换、资源配置调整），先在测试环境验证，确认无问题后再在生产环境实施；

• 逐步优化，避免一次性大改：集群优化是一个持续的过程，逐步调整优化参数，观察优化效果，避免一次性修改过多配置导致集群故障。

4.2 性能优化最佳实践

• 资源配置合理化：根据应用需求，合理设置Pod的资源请求和限制，避免资源浪费和资源不足；节点资源预留合理，确保K8s核心组件和系统正常运行；

• 网络插件选型：生产环境优先选择高性能网络插件（如cilium），支持eBPF，降低网络延迟，提升吞吐量；

• 存储选型：对存储敏感的应用（如数据库），使用SSD持久化存储，优化存储挂载参数，开启存储缓存；

• 定期清理：定期清理无用的Pod、PV/PVC、日志文件，释放资源，避免资源占用过高。

4.3 稳定性优化最佳实践

• 高可用部署：生产环境必须部署多master、多worker节点，配置负载均衡器，避免单点故障；

• Pod自愈机制：所有应用Pod必须配置存活探针和就绪探针，配置HPA自动扩缩容，应对流量波动；

• 核心组件保障：优化核心组件的资源配置，配置日志轮转和自动重启，定期备份etcd数据；

• 定期巡检：定期查看集群状态、节点资源、应用运行情况，提前发现潜在问题，避免故障发生。

4.4 安全性优化最佳实践

• 最小权限原则：所有用户、Pod、组件都分配最小必要权限，禁止使用特权容器，限制权限提升；

• 镜像安全：使用固定版本镜像，扫描镜像漏洞，仅允许拉取内部私有仓库镜像，禁止使用不安全镜像；

• 网络隔离：配置NetworkPolicy，实现Pod之间、Pod与外部的网络隔离，限制不必要的网络访问；

• 敏感数据保护：使用Secret存储敏感数据，加密Secret存储，限制Secret的访问权限，避免敏感数据泄露。

五、K8s系列全套总结（圆满收官）

至此，K8s系列实战文章（共15篇）已全部更新完毕，从K8s基础入门到核心实战，从"能用K8s"到"用好K8s"，全程贴合小白学习节奏，以"实操为主、命令可复制、场景化讲解"为核心，覆盖了K8s运维的全流程核心模块，帮你彻底掌握K8s运维技能，适配生产环境需求和面试重点。

回顾整个系列，我们共分为5个核心阶段，梳理如下，方便你回顾复习：

第一阶段：基础入门（第1-3篇）------ 搭建K8s基础环境

核心内容：K8s核心概念（Pod、Deployment、Service等）、单节点/多节点集群部署、kubectl基础命令，帮你快速入门K8s，搭建基础运行环境，掌握K8s的核心思想和基础操作，解决"会用K8s"的第一步。

第二阶段：核心组件与应用部署（第4-7篇）------ 掌握应用部署与调度

核心内容：K8s核心组件（kube-apiserver、etcd等）工作原理、应用部署（Deployment、StatefulSet）、服务暴露（NodePort、LoadBalancer、Ingress）、应用调度与自愈，帮你掌握应用在K8s中的部署、访问和调度方法，实现应用的高可用部署。

第三阶段：应用运维基础（第8-10篇）------ 保障应用正常运行

核心内容：应用健康检查、资源限制与请求、日志收集（EFK/ELK），帮你掌握应用的日常运维方法，及时发现应用故障，控制应用资源消耗，收集应用日志，为后续故障排查提供支撑。

第四阶段：监控与故障排查（第11-14篇）------ 快速发现并解决问题

核心内容：Prometheus+Grafana监控告警部署与配置、故障排查核心思路与常用命令、常见故障实战排查、排查工具推荐，帮你搭建"监控→告警→排查→解决"的完整运维闭环，彻底解决"遇到故障无从下手"的痛点。

第五阶段：集群优化（第15篇，本篇）------ 用好K8s，适配生产需求

核心内容：性能优化、稳定性优化、安全性优化，帮你优化集群性能，提升集群稳定性，防范安全风险，搭建一个高效、稳定、安全的K8s集群，实现从"能用K8s"到"用好K8s"的跨越，适配生产环境的高要求。

学习K8s的核心是"多实操、多总结、多复盘"，前面15篇文章的命令均可直接复制执行，建议你结合实际环境，反复实操每一个案例，熟悉每一个命令的作用，理解每一个配置的含义，遇到问题时，结合故障排查思路，主动解决问题，逐步积累运维经验。

K8s是容器编排领域的主流技术，也是运维工程师、云原生工程师的核心技能之一，掌握K8s运维全流程，能极大提升你的职场竞争力。本系列文章旨在帮你快速入门、快速上手，后续你可以深入学习K8s进阶知识（如K8s集群联邦、Istio服务网格、云原生存储等），不断提升自己的技术水平。

最后，感谢你一路的陪伴和支持，希望本系列文章能对你的K8s学习之旅有所帮助，祝你在云原生的道路上越走越远，早日成为K8s运维高手！