K8s集群运行时网络拥堵限流调度优化实操

项目	内容
适用版本	Kubernetes v1.28.15 + Calico v3.26.x + containerd 1.7.x + Rocky Linux 8.6
优化目标	降低网络延迟、消除拥堵、保障关键业务带宽、提升调度效率
编写日期	2026-08-18
文档版本	v1.0

1. 操作环境与前置准备

1.1 硬件要求

角色	CPU	内存	硬盘	网卡
Worker	8核+	16GB+	200GB SSD	万兆×1（推荐）
监控节点	4核+	8GB+	500GB SSD	千兆×1

网络优化场景建议万兆网卡，千兆环境瓶颈在物理带宽，优化效果有限。

1.2 软件版本矩阵

组件	版本	说明
内核	4.18.0-372+	需支持多队列、BPF
Kubernetes	v1.28.15	集群版本
containerd	1.7.11+	容器运行时
Calico	v3.26.x	CNI网络插件
kube-proxy	IPVS模式	负载均衡
iproute2	5.x+	流量控制工具
iperf3	3.x+	网络压测
netdata/Prometheus	最新稳定版	监控采集

1.3 节点规划

主机名	IP地址	角色	网卡
k8s-worker01	192.168.10.21	Worker	ens192（万兆）
k8s-worker02	192.168.10.22	Worker	ens192（万兆）
k8s-worker03	192.168.10.23	Worker	ens192（万兆）
k8s-monitor	192.168.10.40	监控	ens192（千兆）

1.4 网络拓扑说明

                    ┌─────────────┐
                    │  核心交换机  │ 万兆
                    └──────┬──────┘
                           │
          ┌────────────────┼────────────────┐
          │                │                │
   ┌──────▼──────┐  ┌──────▼──────┐  ┌──────▼──────┐
   │  Master     │  │  Worker01-03│  │  Monitor    │
   │  192.168.10 │  │  192.168.10 │  │  192.168.10 │
   └─────────────┘  └─────────────┘  └─────────────┘

• Pod CIDR：10.244.0.0/16
• Service CIDR：10.96.0.0/12
• Calico模式：BGP（万兆环境推荐，无封装开销）

2. 网络拥堵与调度优化原理

2.1 K8s网络拥堵成因分析

拥堵层级	成因	表现
内核层	conntrack表满、TCP参数不合理	连接超时、重传率高
CNI层	Calico路由表过大、封装开销	跨节点延迟高、CPU占用高
kube-proxy层	iptables规则过多、IPVS配置不当	Service访问慢、连接失败
Pod层	无带宽限制、QoS等级混乱	个别Pod抢占全部带宽
调度层	Pod分布不均、热点节点	部分节点网络过载、部分空闲
应用层	连接池不合理、超时过长	连接堆积、资源耗尽

2.2 优化体系架构

┌─────────────────────────────────────────────────┐
│              应用层（业务侧）                      │
│   连接池优化 │ 超时配置 │ 重试策略 │ 熔断降级      │
├─────────────────────────────────────────────────┤
│              调度层（K8s调度器）                   │
│   资源限制 │ 亲和反亲和 │ 拓扑分布 │ 污点容忍      │
├─────────────────────────────────────────────────┤
│              网络策略层（CNI/NetworkPolicy）       │
│   带宽限流 │ 访问控制 │ QoS等级 │ 流量隔离        │
├─────────────────────────────────────────────────┤
│              内核层（系统调优）                    │
│   TCP参数 │ conntrack │ 多队列 │ offload         │
├─────────────────────────────────────────────────┤
│              物理层（硬件/网卡）                   │
│   万兆网卡 │ 交换机QoS │ 网卡绑定 │ 中断亲和      │
└─────────────────────────────────────────────────┘

2.3 优化层级与手段对照

优化目标	手段	配置位置
提升并发连接数	调大conntrack、TCP参数	内核sysctl
防止单Pod占满带宽	Pod带宽annotations + CNI限速	Pod YAML
保障关键业务	QoS Guaranteed + 高优先级	Pod YAML
调度均衡	Pod拓扑分布约束 + 资源请求	Deployment YAML
减少iptables开销	kube-proxy切换IPVS模式	kube-proxy配置
提升网卡吞吐	多队列 + RPS/RFS + offload	网卡/内核
控制东西向流量	NetworkPolicy + GlobalNetworkPolicy	K8s资源

3. 网络监控与拥堵检测

3.1 节点网络指标采集

# 实时查看网卡流量
sar -n DEV 1 5

# 查看网卡吞吐量（需安装sysstat）
yum install -y sysstat
sar -n DEV --iface=ens192 1 10

# 查看TCP连接统计
ss -s

# 查看conntrack使用情况
sysctl net.netfilter.nf_conntrack_count
sysctl net.netfilter.nf_conntrack_max
cat /proc/net/nf_conntrack | wc -l

# 查看网卡队列与中断
ethtool -l ens192
cat /proc/interrupts | grep ens192

# 查看网络丢包与错误
ifconfig ens192 | grep -E 'RX|TX'
ip -s link show ens192

3.2 Pod级网络流量监控

# 查看Pod网络使用（需metrics-server）
kubectl top pods -A --sort-by=memory

# 使用Calico查看端点流量
calicoctl get workloadendpoints -o wide

# 进入Pod网络命名空间抓包
POD_NAME=<pod-name>
POD_NS=<namespace>
PID=$(kubectl get pod ${POD_NAME} -n ${POD_NS} -o jsonpath='{.status.containerStatuses[0].state.running.pid}')
nsenter -t ${PID} -n tcpdump -i any -w /tmp/pod-capture.pcap

# 使用crictl查看Pod网络
crictl inspectp <pod-id> | jq '.info.runtimeSpec.network'

3.3 拥堵检测脚本

创建 /opt/network-check.sh：

#!/bin/bash
# K8s节点网络拥堵检测脚本
echo "========== 网络拥堵检测 =========="
echo "[1] 网卡流量统计:"
sar -n DEV 1 3 | grep -E 'ens192|Average'

echo ""
echo "[2] TCP连接状态分布:"
ss -ant | awk 'NR>1{print $1}' | sort | uniq -c | sort -rn

echo ""
echo "[3] Conntrack使用率:"
COUNT=$(sysctl -n net.netfilter.nf_conntrack_count)
MAX=$(sysctl -n net.netfilter.nf_conntrack_max)
PERCENT=$(echo "scale=2; $COUNT*100/$MAX" | bc)
echo "当前: $COUNT / 最大: $MAX (使用率: ${PERCENT}%)"
if (( $(echo "$PERCENT > 80" | bc -l) )); then
  echo "  ⚠ WARNING: conntrack使用率超过80%，需调大！"
fi

echo ""
echo "[4] 网卡丢包/错误:"
ip -s link show ens192 | grep -A1 'RX:' | grep -v 'RX:'

echo ""
echo "[5] 重传率检测:"
nstat -az | grep -E 'TcpRetransSegs|TcpExtTCPLostRetransmit'

echo ""
echo "[6] 监听端口与队列:"
ss -lnt | head -20

echo ""
echo "========== 检测完成 =========="

执行：

chmod +x /opt/network-check.sh
/opt/network-check.sh

3.4 网络瓶颈定位

# 定位高带宽占用进程
nethogs ens192   # 需安装 nethogs

# 定位高连接数进程
ss -antp | grep ESTAB | awk '{print $6}' | sort | uniq -c | sort -rn | head

# 跨节点延迟测试
ping -c 100 -i 0.01 192.168.10.22 | tail -5

# 路由跟踪
traceroute 192.168.10.22

# DNS解析延迟
dig @10.96.0.10 kubernetes.default.svc.cluster.local +stats

4. CNI网络插件调优（Calico）

4.1 Calico BGP与VXLAN模式选择

模式	封装开销	适用场景	性能
VXLAN	有（UDP封装）	跨三层、云环境	中等
IPIP	有（IP封装）	跨三层、简单环境	中等

切换为BGP模式：

# 修改Calico配置
kubectl patch installation default --type=merge -p '{
  "spec": {
    "calicoNetwork": {
      "ipPools": [{
        "cidr": "10.244.0.0/16",
        "encapsulation": "None",
        "natOutgoing": "Enabled",
        "nodeSelector": "all()"
      }],
      "bgp": "Enabled"
    }
  }
}'

# 验证
calicoctl get ippool -o yaml | grep -E 'cidr|encapsulation'

4.2 Calico Felix参数调优

创建 calico-felix-config.yaml：

apiVersion: projectcalico.org/v3
kind: FelixConfiguration
metadata:
  name: default
spec:
  # 日志级别（生产用info，调试用debug）
  logSeverityScreen: Info
  # Prometheus指标
  prometheusMetricsEnabled: true
  prometheusMetricsPort: 9091
  # 连接跟踪
  conntrackLimitsEnabled: true
  # 路由表刷新间隔
  routeRefreshInterval: 90s
  # 端点同步
  endpointReportingEnabled: false
  # 外部流量管理
  externalNodesList: ""
  # 接口前缀
  interfacePrefix: cali
  # MTU自动检测
  wireguardEnabled: false
  # IPTables后台刷新
  iptablesRefreshInterval: 60s
  # 批量插入iptables规则
  iptablesInsertMode: insert
  # 连接跟踪清理
  conntrackCleanupInterval: 600s
  # 健康检查
  healthPort: 9099
  # 资源限制
  reportInterval: 30s
  reportingInterval: 30s
  # 关闭不必要的特性
  policySyncPathPrefix: ""
  # 优化大规模endpoint
  endpointsPerHost: 0

应用：

calicoctl apply -f calico-felix-config.yaml

4.3 Calico IPIP隧道优化

如必须使用IPIP/VXLAN，优化MTU：

# 查看当前MTU
ip link show | grep -E 'tunl0|vxlan|calico'

# 设置Calico MTU（VXLAN模式：物理MTU - 50；IPIP模式：物理MTU - 20）
# 万兆网卡MTU=9000时，VXLAN MTU=8950，IPIP MTU=8980
kubectl patch installation default --type=merge -p '{
  "spec": {
    "calicoNetwork": {
      "mtu": 8950
    }
  }
}'

# 验证
kubectl get installation default -o jsonpath='{.spec.calicoNetwork.mtu}'

4.4 大规模集群端点优化

# 关闭endpoint reporting减少API Server压力
calicoctl patch felixconfiguration default --type=merge \
  -p '{"spec":{"endpointReportingEnabled":false}}'

# 增大BGP保持时间
calicoctl patch bgpconfiguration default --type=merge \
  -p '{"spec":{"keepOriginalNextHop":true,"nodeToNodeMeshEnabled":true}}'

# 启用路由聚合（减少路由表条目）
calicoctl patch ippool default-ipv4-ippool --type=merge \
  -p '{"spec":{"blockSize":26}}'

5. 内核网络参数优化

5.1 连接跟踪与背压参数

创建 /etc/sysctl.d/99-k8s-network-optimize.conf：

# ========== Conntrack连接跟踪 ==========
net.netfilter.nf_conntrack_max = 1048576
net.netfilter.nf_conntrack_tcp_timeout_established = 86400
net.netfilter.nf_conntrack_tcp_timeout_time_wait = 30
net.netfilter.nf_conntrack_tcp_timeout_close_wait = 60
net.netfilter.nf_conntrack_tcp_timeout_fin_wait = 120
net.netfilter.nf_conntrack_buckets = 262144
net.nf_conntrack_max = 1048576

# ========== 端口范围 ==========
net.ipv4.ip_local_port_range = 1024 65535
net.ipv4.ip_local_reserved_ports = 30000-32767

# ========== 背压与队列 ==========
net.core.netdev_max_backlog = 16384
net.core.somaxconn = 32768
net.core.default_qdisc = fq
net.ipv4.tcp_max_syn_backlog = 16384
net.ipv4.tcp_syncookies = 1

# ========== 内存 ==========
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
net.core.rmem_default = 262144
net.core.wmem_default = 262144
net.ipv4.tcp_rmem = 4096 87380 16777216
net.ipv4.tcp_wmem = 4096 65536 16777216
net.ipv4.udp_rmem_min = 8192
net.ipv4.udp_wmem_min = 8192

5.2 TCP协议栈调优

追加到同一文件：

# ========== TCP协议栈 ==========
# 开启TCP快速打开
net.ipv4.tcp_fastopen = 3

# 拥塞控制算法（BBR需内核4.9+，高延迟高带宽推荐）
net.core.default_qdisc = fq
net.ipv4.tcp_congestion_control = bbr

# TCP窗口缩放
net.ipv4.tcp_window_scaling = 1

# 时间戳（NAT环境建议关闭以避免连接异常）
net.ipv4.tcp_timestamps = 1

# 选择确认
net.ipv4.tcp_sack = 1

# 复用TIME_WAIT连接
net.ipv4.tcp_tw_reuse = 1

# FIN超时
net.ipv4.tcp_fin_timeout = 15

# keepalive参数
net.ipv4.tcp_keepalive_time = 600
net.ipv4.tcp_keepalive_intvl = 30
net.ipv4.tcp_keepalive_probes = 5

# 最大孤儿连接
net.ipv4.tcp_max_orphans = 65536

# MTU探测
net.ipv4.tcp_mtu_probing = 1

# 自动调整接收缓冲区
net.ipv4.tcp_moderate_rcvbuf = 1

生效：

sysctl --system

# 验证BBR
sysctl net.ipv4.tcp_congestion_control
# 应输出 bbr

# 验证conntrack
sysctl net.netfilter.nf_conntrack_max

5.3 网卡多队列与RPS/RFS

# 查看网卡队列数
ethtool -l ens192

#  Combined: 8（当前） / 8（最大）

# 调大队列数（如支持）
ethtool -L ens192 combined 8

# 配置RPS（Receive Packet Steering）- 软件多队列
# 获取网卡rx队列对应的CPU掩码
QUEUES=$(ls /sys/class/net/ens192/queues/ | grep rx- | wc -l)
CPUS=$(nproc)
for i in $(seq 0 $((QUEUES-1))); do
  # ffffffff表示所有CPU参与，根据实际CPU数设置
  echo ffffffff > /sys/class/net/ens192/queues/rx-${i}/rps_cpus
  echo 4096 > /sys/class/net/ens192/queues/rx-${i}/rps_flow_cnt
done

# 配置RFS（Receive Flow Steering）
echo 32768 > /proc/sys/net/core/rps_sock_flow_entries

# 持久化RPS配置（创建udev规则或systemd服务）
cat > /etc/systemd/system/rps-config.service << 'EOF'
[Unit]
Description=Configure RPS/RFS for network interfaces
After=network.target

[Service]
Type=oneshot
ExecStart=/bin/bash -c 'for q in /sys/class/net/ens192/queues/rx-*; do echo ffffffff > $q/rps_cpus; echo 4096 > $q/rps_flow_cnt; done; echo 32768 > /proc/sys/net/core/rps_sock_flow_entries'
RemainAfterExit=yes

[Install]
WantedBy=multi-user.target
EOF

systemctl enable rps-config.service

5.4 网卡offload特性

# 查看当前offload状态
ethtool -k ens192

# 开启常用offload
ethtool -K ens192 tx on rx on sg on tso on gso on gro on lro on

# 开启校验和卸载
ethtool -K ens192 tx-checksum-ipv4 on tx-checksum-ip-generic on

# 查看网卡ring buffer
ethtool -g ens192

# 调大ring buffer（如支持）
ethtool -G ens192 rx 4096 tx 4096

# 中断亲和（将网卡中断绑定到特定CPU，避免CPU0瓶颈）
# 查看中断号
grep ens192 /proc/interrupts

# 设置中断亲和掩码（示例：绑定到CPU 4-7）
# echo f0 > /proc/irq/<中断号>/smp_affinity

6. Pod网络QoS与带宽限流

6.1 K8s QoS等级机制

QoS等级	条件	资源保障	驱逐优先级
Burstable	requests < limits 或只设requests	中等	中等
BestEffort	不设requests和limits	最低	最先被驱逐

Guaranteed示例：

apiVersion: v1
kind: Pod
metadata:
  name: critical-app
spec:
  containers:
  - name: app
    image: harbor.local/app/myapp:v1
    resources:
      requests:
        cpu: "2"
        memory: "4Gi"
        # 网络带宽请求（K8s 1.27+ alpha特性，需特性门控）
        # networking.kubernetes.io/request: "1G"
      limits:
        cpu: "2"
        memory: "4Gi"
        # networking.kubernetes.io/limit: "2G"
  priorityClassName: high-priority

6.2 Pod带宽限制（annotations）

Calico支持通过annotations限制Pod带宽：

apiVersion: v1
kind: Pod
metadata:
  name: bandwidth-limited-pod
  annotations:
    # 入口带宽限制（下载）
    kubernetes.io/ingress-bandwidth: 100M
    # 出口带宽限制（上传）
    kubernetes.io/egress-bandwidth: 50M
spec:
  containers:
  - name: app
    image: harbor.local/library/nginx:1.25

Deployment级批量限流：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: limited-app
spec:
  replicas: 3
  template:
    metadata:
      annotations:
        kubernetes.io/ingress-bandwidth: 200M
        kubernetes.io/egress-bandwidth: 100M
    spec:
      containers:
      - name: app
        image: harbor.local/app/myapp:v1

6.3 基于CNI的带宽限速

Calico带宽插件配置：

# 确认Calico带宽插件已启用
kubectl get pods -n kube-system -l k8s-app=calico-node -o yaml | grep -A5 bandwidth

# 如未启用，修改Calico DaemonSet
kubectl set env daemonset/calico-node -n kube-system \
  FELIX_BANDWIDTH_MANAGEMENT_ENABLED=true

# 验证限速规则（在节点上）
tc qdisc show dev cali<容器ID>
# 应看到 tbf 队列规则

6.4 关键业务带宽保障

通过优先级 + 资源预留 + 带宽限制组合保障关键业务：

apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata:
  name: high-priority
value: 1000000
globalDefault: false
description: "关键业务高优先级"
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: payment-service
  namespace: prod
spec:
  replicas: 3
  template:
    metadata:
      annotations:
        # 保障最低带宽，限制峰值带宽
        kubernetes.io/ingress-bandwidth: 1G
        kubernetes.io/egress-bandwidth: 1G
    spec:
      priorityClassName: high-priority
      containers:
      - name: payment
        image: harbor.local/app/payment:v2
        resources:
          requests:
            cpu: "4"
            memory: "8Gi"
          limits:
            cpu: "4"
            memory: "8Gi"
      # 节点亲和：调度到网络条件好的节点
      nodeSelector:
        network: 10ge
      # 拓扑分布：跨节点分散
      topologySpreadConstraints:
      - maxSkew: 1
        topologyKey: kubernetes.io/hostname
        whenUnsatisfiable: DoNotSchedule
        labelSelector:
          matchLabels:
            app: payment-service

7. NetworkPolicy网络策略

7.1 默认拒绝策略

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-all
  namespace: prod
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress

7.2 命名空间隔离策略

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: namespace-isolation
  namespace: prod
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  ingress:
  # 只允许同命名空间访问
  - from:
    - podSelector: {}
  # 允许监控命名空间访问
  - from:
    - namespaceSelector:
        matchLabels:
          name: monitoring

7.3 精细化流量控制

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: app-traffic-control
  namespace: prod
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes:
  - Ingress
  - Egress
  ingress:
  # 只允许前端服务的8080端口访问
  - from:
    - podSelector:
        matchLabels:
          app: frontend
    ports:
    - protocol: TCP
      port: 8080
  # 允许监控端口
  - from:
    - namespaceSelector:
        matchLabels:
          name: monitoring
    ports:
    - protocol: TCP
      port: 9090
  egress:
  # 允许访问数据库
  - to:
    - podSelector:
        matchLabels:
          app: database
    ports:
    - protocol: TCP
      port: 3306
  # 允许DNS解析
  - to:
    - namespaceSelector: {}
    ports:
    - protocol: UDP
      port: 53
    - protocol: TCP
      port: 53

7.4 全局网络策略（GlobalNetworkPolicy）

Calico全局策略，作用于所有命名空间：

apiVersion: projectcalico.org/v3
kind: GlobalNetworkPolicy
metadata:
  name: deny-egress-to-internal
spec:
  order: 100
  selector: all()
  types:
  - Egress
  egress:
  # 禁止Pod访问内网管理网段
  - action: Deny
    destination:
      nets:
      - 10.0.0.0/8
      - 172.16.0.0/12
      - 192.168.0.0/16
  - action: Allow
    destination:
      notNets:
      - 10.0.0.0/8
      - 172.16.0.0/12
      - 192.168.0.0/16

应用：

calicoctl apply -f global-policy.yaml

8. 调度器优化

8.1 资源请求与限制规范

强制规范：所有Pod必须设置requests和limits，避免BestEffort。

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
spec:
  replicas: 5
  template:
    spec:
      containers:
      - name: web
        image: harbor.local/app/web:v1
        resources:
          requests:
            cpu: "500m"
            memory: "512Mi"
          limits:
            cpu: "2"
            memory: "2Gi"

资源超售比例建议：

业务类型	CPU超售比	内存超售比
普通业务	1:2 ~ 1:3	1:1.5
测试环境	1:4 ~ 1:5	1:2

8.2 节点亲和与反亲和

节点亲和（调度到指定节点）：

spec:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: network
            operator: In
            values: ["10ge"]
      preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 100
        preference:
          matchExpressions:
          - key: disktype
            operator: In
            values: ["ssd"]

Pod反亲和（避免同节点部署）：

spec:
  affinity:
    podAntiAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
      - labelSelector:
          matchExpressions:
          - key: app
            operator: In
            values: ["web-app"]
        topologyKey: kubernetes.io/hostname

8.3 Pod拓扑分布约束

K8s 1.19+稳定特性，比podAntiAffinity更灵活：

spec:
  topologySpreadConstraints:
  # 跨节点均匀分布
  - maxSkew: 1
    topologyKey: kubernetes.io/hostname
    whenUnsatisfiable: DoNotSchedule
    labelSelector:
      matchLabels:
        app: web-app
  # 跨可用区均匀分布（如有zone标签）
  - maxSkew: 1
    topologyKey: topology.kubernetes.io/zone
    whenUnsatisfiable: ScheduleAnyway
    labelSelector:
      matchLabels:
        app: web-app

8.4 污点与容忍调度

# 为高网络节点打污点，只允许关键业务调度
kubectl taint nodes k8s-worker01 network=highspeed:NoSchedule

# Pod容忍该污点
spec:
  tolerations:
  - key: "network"
    operator: "Equal"
    value: "highspeed"
    effect: "NoSchedule"

8.5 调度器参数调优

创建 kube-scheduler-config.yaml：

apiVersion: kubescheduler.config.k8s.io/v1beta3
kind: KubeSchedulerConfiguration
profiles:
- schedulerName: default-scheduler
  plugins:
    score:
      enabled:
      - name: NodeResourcesBalancedAllocation
        weight: 5
      - name: NodeResourcesFit
        weight: 3
      - name: PodTopologySpread
        weight: 5
      - name: InterPodAffinity
        weight: 2
      - name: TaintToleration
        weight: 1
  pluginConfig:
  - name: NodeResourcesFit
    args:
      scoringStrategy:
        type: MostAllocated
        resources:
        - name: cpu
          weight: 1
        - name: memory
          weight: 1
- name: PodTopologySpread
  args:
    defaultingType: List
    defaultConstraints:
    - maxSkew: 3
      topologyKey: kubernetes.io/hostname
      whenUnsatisfiable: ScheduleAnyway

应用：

# 修改kube-scheduler静态Pod配置
cp /etc/kubernetes/manifests/kube-scheduler.yaml /etc/kubernetes/manifests/kube-scheduler.yaml.bak
# 在command中添加 --config=/etc/kubernetes/scheduler-config.yaml
# 挂载配置文件

8.6 自定义调度策略

基于网络资源的调度（Descheduler）：

# 安装Descheduler
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/descheduler/master/kubernetes/deployment.yaml

# 配置重调度策略
cat > descheduler-policy.yaml << 'EOF'
apiVersion: descheduler/v1alpha2
kind: DeschedulerPolicy
strategies:
  RemovePodsViolatingTopologySpreadConstraint:
    enabled: true
    params:
      includeSoftConstraints: true
  LowNodeUtilization:
    enabled: true
    params:
      nodeResourceUtilizationThresholds:
        thresholds:
          cpu: 30
          memory: 30
          pods: 20
        targetThresholds:
          cpu: 70
          memory: 70
          pods: 50
  RemoveDuplicates:
    enabled: true
EOF

9. 运行时网络配置优化

9.1 containerd网络配置

编辑 /etc/containerd/config.toml：

[plugins."io.containerd.grpc.v1.cri"]
  # 禁用streaming服务的TLS（内网）
  enable_tls_streaming = false
  stream_server_address = "127.0.0.1"
  stream_server_port = "0"
  
  # 最大并发镜像下载
  max_concurrent_downloads = 5
  
  # 禁用selinux
  enable_selinux = false
  
  [plugins."io.containerd.grpc.v1.cri".cni]
    bin_dir = "/opt/cni/bin"
    conf_dir = "/etc/cni/net.d"
    max_conf_num = 1
    # 网络插件配置
    conf_template = ""
  
  [plugins."io.containerd.grpc.v1.cri".containerd]
    # 快照器
    snapshotter = "overlayfs"
    # 默认运行时
    default_runtime_name = "runc"

9.2 Pod网络命名空间优化

# 查看Pod网络命名空间
ls -la /var/run/netns/

# 优化网络命名空间创建（通过kubelet配置）
cat > /var/lib/kubelet/config.yaml << 'EOF'
apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
cgroupDriver: systemd
clusterDomain: cluster.local
clusterDNS:
- 10.96.0.10
# 最大Pod数（影响网络端点数量）
maxPods: 110
# PodCIDR
podCIDR: 10.244.0.0/16
# 网络插件
networkPluginName: cni
# 关闭非必要的指标采集
enableControllerAttachDetach: true
EOF

systemctl restart kubelet

9.3 conntrack与端口范围

# 确保conntrack模块加载
modprobe nf_conntrack
modprobe nf_conntrack_ipv4

# 持久化
cat > /etc/modules-load.d/conntrack.conf << 'EOF'
nf_conntrack
nf_conntrack_ipv4
EOF

# 验证
lsmod | grep conntrack
sysctl net.netfilter.nf_conntrack_count

9.4 kube-proxy模式优化（IPVS）

# 查看当前模式
kubectl get configmap kube-proxy -n kube-system -o jsonpath='{.data.config\.conf}' | grep mode

# 修改为IPVS模式
kubectl edit configmap kube-proxy -n kube-system
# 将 mode: "" 改为 mode: "ipvs"

# 或通过patch
kubectl patch configmap kube-proxy -n kube-system --type merge \
  -p '{"data":{"config.conf":"mode: ipvs\nipvs:\n  scheduler: rr\n  excludeCIDRs: []\n  strictARP: false\n  syncPeriod: 30s\n  minSyncPeriod: 5s\n"}}'

# 重启kube-proxy
kubectl rollout restart daemonset kube-proxy -n kube-system

# 验证IPVS规则
ipvsadm -Ln

# IPVS调度算法选择
# rr: 轮询（默认，均匀）
# wrr: 加权轮询
# lc: 最少连接
# wlc: 加权最少连接（推荐，高并发场景）
# sh: 源地址哈希（会话保持）
# dh: 目标地址哈希

修改IPVS调度器为最少连接（高并发推荐）：

kubectl patch configmap kube-proxy -n kube-system --type merge \
  -p '{"data":{"config.conf":"mode: ipvs\nipvs:\n  scheduler: lc\n  syncPeriod: 30s\n"}}'
kubectl rollout restart daemonset kube-proxy -n kube-system

10. Service与Ingress流量控制

10.1 Service会话保持与连接参数

apiVersion: v1
kind: Service
metadata:
  name: app-service
spec:
  selector:
    app: web-app
  ports:
  - port: 80
    targetPort: 8080
  # 会话保持（ClientIP模式）
  sessionAffinity: ClientIP
  sessionAffinityConfig:
    clientIP:
      timeoutSeconds: 10800
  type: ClusterIP

10.2 Ingress限流配置

Nginx Ingress限流：

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: app-ingress
  annotations:
    # 每秒请求数限制（按客户端IP）
    nginx.ingress.kubernetes.io/limit-rps: "100"
    # 每分钟请求数限制
    nginx.ingress.kubernetes.io/limit-rpm: "6000"
    # 连接数限制
    nginx.ingress.kubernetes.io/limit-connections: "50"
    # 限流白名单
    nginx.ingress.kubernetes.io/limit-allowlist: "10.0.0.0/8"
    # 上游连接超时
    nginx.ingress.kubernetes.io/proxy-connect-timeout: "10"
    nginx.ingress.kubernetes.io/proxy-read-timeout: "30"
    nginx.ingress.kubernetes.io/proxy-send-timeout: "30"
    # 上游连接池
    nginx.ingress.kubernetes.io/upstream-keepalive-connections: "320"
    nginx.ingress.kubernetes.io/upstream-keepalive-timeout: "60"
spec:
  rules:
  - host: app.company.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: app-service
            port:
              number: 80

10.3 负载均衡算法调优

# IPVS模式下修改Service调度算法（需kube-proxy支持）
# 通过Service annotation（需启用feature gate）
# service.kubernetes.io/ipvs-scheduler: "wlc"

# 查看当前Service的IPVS虚拟服务
ipvsadm -Ln | grep -A5 <ClusterIP>

# 手动调整（临时，kube-proxy会覆盖）
ipvsadm -E -t <ClusterIP>:80 -s wlc

10.4 连接池与超时配置

应用层连接池建议：

参数	建议值	说明
连接超时	3-5s	建立连接超时
读取超时	10-30s	读数据超时
写入超时	10-30s	写数据超时
空闲回收	60s	空闲连接回收
最大重试	2-3次	失败重试

kubelet API连接优化：

# /var/lib/kubelet/config.yaml
apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
# API Server连接
kubeAPIQPS: 50
kubeAPIBurst: 100
# 事件记录
eventBurst: 50
eventRecordQPS: 50
# 序列化并发
serializeImagePulls: false
maxParallelImagePulls: 3

11. 验证与压测流程

11.1 网络基准测试

# 安装iperf3
yum install -y iperf3

# 节点间带宽测试（服务端）
iperf3 -s -p 5201

# 节点间带宽测试（客户端）
iperf3 -c 192.168.10.22 -p 5201 -t 60 -P 8

# 预期结果：万兆网卡应达到 9-10 Gbits/sec

# 延迟测试
ping -c 1000 -i 0.001 192.168.10.22 | tail -5
# 预期：同机房 < 1ms

11.2 带宽压测

# Pod间带宽测试
# 启动服务端Pod
kubectl run iperf-server --image=harbor.local/library/network-multitool:latest -- sleep 3600
kubectl exec -it iperf-server -- iperf3 -s

# 启动客户端Pod
kubectl run iperf-client --image=harbor.local/library/network-multitool:latest -- sleep 3600
kubectl exec -it iperf-client -- iperf3 -c <iperf-server-pod-ip> -t 30 -P 4

# 测试带限速的Pod（验证限流生效）
# 创建带100M限速的Pod，iperf测试应不超过100Mbps

11.3 并发连接压测

# 使用wrk压测HTTP服务
kubectl run wrk --image=harbor.local/library/wrk:latest -- \
  wrk -t8 -c1000 -d60s http://app-service.prod.svc.cluster.local

# 参数说明：-t8 8线程，-c1000 1000并发连接，-d60s 持续60秒

# 监控conntrack使用
watch -n1 'sysctl net.netfilter.nf_conntrack_count; ss -s'

# 监控节点CPU/网络
sar -n DEV 1 60
top

11.4 调度均衡性验证

# 查看Pod分布
kubectl get pods -A -o wide | awk '{print $7}' | sort | uniq -c | sort -rn

# 查看节点资源使用率
kubectl top nodes

# 查看Pod资源请求占比
kubectl describe nodes | grep -A5 "Allocated resources"

# 验证拓扑分布
kubectl get pods -l app=web-app -o wide
# 应均匀分布在不同节点