Skip to content

实验四:CNI 跨节点通信抓包、Service/Ingress 网关与 CoreDNS 调优实战 ​

0. 实验目标与环境基线 ​

本实验充分利用你已经搭建好的 Flannel VXLAN (10.244.0.0/16) + 三台 Lima 虚拟机(192.168.104.1 / .3 / .4),从 Linux 网络栈底层命令(iflink、bridge link、ip route、ip neigh、bridge fdb、tcpdump UDP 8472)验证跨宿主机封包解包,再向上演练 Service 四种类型、externalTrafficPolicy: Local 源 IP 保护、Ingress Controller (DaemonSet + hostNetwork) 七层路由、HTTPS (TLS) 站点与 Canary 金丝雀灰度切流,以及 CoreDNS 自定义域名与 ndots:5 解析测试。

包含的 7 个核心实操点 ​

  1. 实验点 4.1:Flannel VXLAN 跨节点通信三表核查(路由表 + ARP 表 + FDB 表)与 veth 网卡对定位
  2. 实验点 4.2:在 lima-node01 的 eth0 上使用 tcpdump 抓取跨节点 UDP 8472 VXLAN 封包报文
  3. 实验点 4.3:Service 四种类型(ClusterIP、NodePort、ExternalName、无 Selector 自定义外部 Endpoints)与 externalTrafficPolicy: Local 源 IP 保留对比
  4. 实验点 4.4:切换/验证 kube-proxy 的 IPVS 模式并使用 ipvsadm -Ln 查看内核负载均衡表
  5. 实验点 4.5:部署 Ingress-Nginx Controller(采用高性能 DaemonSet + hostNetwork 方案),实现多微服务基于 Path(/app1、/app2)的七层路由与 Rewrite 重写
  6. 实验点 4.6:构建 Ingress TLS (HTTPS) 加密站点 + 基于权重(canary-weight)与请求头(canary-by-header)的金丝雀发布实验
  7. 实验点 4.7:CoreDNS Corefile 自定义 hosts 域名解析、裸 Pod 固定 FQDN 配置与 dnsPolicy 四种策略对比

1. 实验前准备:创建实验四命名空间并在两个 Worker 节点各放一个测试 Pod ​

在 lima-master 上执行:

bash
limactl shell master

kubectl create namespace lab4-network
kubectl config set-context --current --namespace=lab4-network

# 在 lima-node01 部署 net-pod-1,在 lima-node02 部署 net-pod-2
cat <<'EOF' | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: net-pod-1
  labels:
    app: net-pod
spec:
  nodeName: lima-node01
  containers:
  - name: app
    image: nginx:stable-alpine
---
apiVersion: v1
kind: Pod
metadata:
  name: net-pod-2
  labels:
    app: net-pod
spec:
  nodeName: lima-node02
  containers:
  - name: app
    image: nginx:stable-alpine
EOF

kubectl wait --for=condition=Ready pod/net-pod-1 pod/net-pod-2 --timeout=60s
kubectl get pods -o wide

记录下 net-pod-1 的 IP(位于 lima-node01 的 10.244.1.x)和 net-pod-2 的 IP(位于 lima-node02 的 10.244.2.x)。


2. 实验点 4.1:Flannel VXLAN 跨节点通信三表(Route + ARP + FDB)与 veth 映射核查 ​

原理回顾: 当 lima-node01 上的 net-pod-1 访问 lima-node02 上的 net-pod-2 时,数据包流经: Pod eth0 → 宿主机 vethxxxx → cni0 网桥 → 查路由表进入 flannel.1 → 查 ARP 表获知目标 flannel.1 的 MAC → 查 FDB 转发表获知目标物理机 IP 192.168.104.4 → 封装为 UDP 8472 从 eth0 发出。

步骤 1:定位 net-pod-1 容器内 eth0 对应 lima-node01 宿主机上的哪根 veth ​

在 lima-master 上获取容器内的 iflink 编号:

bash
IFLINK=$(kubectl exec net-pod-1 -- cat /sys/class/net/eth0/iflink)
echo "Container eth0 peers with host interface index: $IFLINK"

在 lima-node01 上查看该编号对应的 veth 设备及 cni0 网桥连接:

bash
limactl shell node01

# 1. 根据接口序号找到对应的 veth 网卡
ip -o link | grep "^$IFLINK:"
# 2. 查看挂载在 cni0 网桥上的所有 veth 设备
bridge link show | grep cni0

步骤 2:在 lima-node01 上核查 Flannel VXLAN 核心三张表(路由表 + ARP 表 + FDB 表) ​

仍在 lima-node01 上执行:

bash
# 1. 路由表 (Route Table):发往 10.244.2.0/24 (node02 子网) 的包,下一跳为 10.244.2.0,设备为 flannel.1
ip route show | grep flannel.1

# 2. 邻居 ARP 表 (ARP Table):下一跳 10.244.2.0 对应的目标 flannel.1 静态 MAC 地址(PERMANENT 永久条目,无需 ARP 广播!)
ip neigh show dev flannel.1

# 3. 二层转发表 (FDB Table):上述目标 flannel.1 的 MAC 地址对应目标宿主机 node02 的真实物理 IP (192.168.104.4)!
bridge fdb show dev flannel.1

3. 实验点 4.2:使用 tcpdump 抓取跨节点 VXLAN UDP 8472 封装数据包 ​

步骤 1:在 lima-node01 安装 tcpdump 并监听 eth0 的 UDP 8472 端口 ​

在 lima-node01 终端执行:

bash
sudo dnf install -y tcpdump

# 抓取 4 个跨节点 VXLAN 封包并打印内层与外层 IP 头
sudo tcpdump -i eth0 -nn udp port 8472 -c 4

步骤 2:在 lima-master 终端让 net-pod-1 ping net-pod-2 ​

bash
POD2_IP=$(kubectl get pod net-pod-2 -o jsonpath='{.status.podIP}')
kubectl exec net-pod-1 -- ping -c 2 "$POD2_IP"

观察 lima-node01 的 tcpdump 输出: 你会极其清晰地看到两层报文:

  • 外层 Underlay 报文:192.168.104.3.<随机源端口> > 192.168.104.4.8472: OTV, flags [I] (0x08), overlay 0, instance 1 (VNI=1)
  • 内层 Overlay 报文:10.244.1.x > 10.244.2.y: ICMP echo request

4. 实验点 4.3:Service 四大类型、自定义外部 Endpoints 与 externalTrafficPolicy: Local ​

在 lima-master 上执行:

bash
# 1. 先让两个 Pod 输出各自所在的节点名与客户端源 IP
kubectl exec net-pod-1 -- sh -c 'cat <<EOF > /etc/nginx/conf.d/default.conf
server {
    listen 80;
    location / {
        return 200 "Pod: net-pod-1 (lima-node01) | Client_IP: \$remote_addr\n";
    }
}
EOF
nginx -s reload'

kubectl exec net-pod-2 -- sh -c 'cat <<EOF > /etc/nginx/conf.d/default.conf
server {
    listen 80;
    location / {
        return 200 "Pod: net-pod-2 (lima-node02) | Client_IP: \$remote_addr\n";
    }
}
EOF
nginx -s reload'

步骤 1:对比默认 externalTrafficPolicy: Cluster(SNAT 丢失源 IP)与 Local(保留真实源 IP) ​

bash
cat <<'EOF' | kubectl apply -f -
apiVersion: v1
kind: Service
metadata:
  name: svc-nodeport-local
spec:
  type: NodePort
  externalTrafficPolicy: Local   # 仅转发给本机 Pod,不跨节点 SNAT,100% 保留客户端真实源 IP
  selector:
    app: net-pod
  ports:
  - port: 80
    targetPort: 80
    nodePort: 30080
EOF

# 在 lima-master (192.168.104.1) 上请求 lima-node01 (192.168.104.3:30080)
# 观察返回的 Client_IP 是真实的 192.168.104.1,且永远只命中本机的 net-pod-1!
curl -s http://192.168.104.3:30080
curl -s http://192.168.104.3:30080

步骤 2:创建无 Selector 的 Service + 手动 Endpoints 代理集群外部 IP ​

应用场景:当 MySQL 数据库部署在 K8s 集群外的物理机(例如 192.168.104.1)上时,通过同名 Service + Endpoints 将其映射为内部服务:

bash
cat <<'EOF' | kubectl apply -f -
apiVersion: v1
kind: Service
metadata:
  name: external-Service-proxy
spec:
  ports:
  - protocol: TCP
    port: 6443
    targetPort: 6443
---
apiVersion: v1
kind: Endpoints
metadata:
  name: external-Service-proxy   # 名字必须与 Service 严格一致!
subsets:
- addresses:
  - ip: 192.168.104.1
  ports:
  - port: 6443
EOF

kubectl get svc,ep external-Service-proxy

5. 实验点 4.4:切换并验证 kube-proxy 的 IPVS 高性能哈希转发模式 ​

原理回顾:iptables 模式基于链表顺序匹配,时间复杂度 O(N);而 ipvs 模式基于内核哈希表,时间复杂度 O(1),且支持 rr(轮询)、lc(最小连接)、sh(源地址哈希)等专业算法。

步骤 1:在三台节点安装 ipvsadm 并将 kube-proxy 切换为 ipvs 模式 ​

在 lima-master、lima-node01、lima-node02 上安装 ipvsadm 工具:

bash
# 在 master 上执行(也可在 node01/node02 执行)
sudo dnf install -y ipvsadm

# 查看当前 kube-proxy 模式,并将其 ConfigMap 中的 mode: "" 修改为 mode: "ipvs"
kubectl get configmap kube-proxy -n kube-system -o yaml | sed 's/mode: ""/mode: "ipvs"/' | kubectl apply -f -

# 滚动重启 kube-proxy DaemonSet 使 IPVS 生效
kubectl rollout restart daemonset/kube-proxy -n kube-system
kubectl rollout status daemonset/kube-proxy -n kube-system

步骤 2:使用 sudo ipvsadm -Ln 观察内核虚拟服务器路由表 ​

bash
# 查看 svc-nodeport-local 的 ClusterIP,并用 ipvsadm 观察它到两个后端 Pod IP 的 rr 轮询规则!
SVC_IP=$(kubectl get svc svc-nodeport-local -o jsonpath='{.spec.clusterIP}')
sudo ipvsadm -Ln -t "${SVC_IP}:80"

6. 实验点 4.5 & 4.6:Ingress 七层网关(DaemonSet + hostNetwork)、HTTPS 站点与金丝雀发布 ​

原理回顾: 在笔记中我们重点对比了 Ingress Controller 的两种部署方式:这里我们在 lima-node01 上采用性能最高、链路最短的 hostNetwork: true 模式(直接监听节点 80 和 443 端口),一站式完成 路径路由(/app1、/app2)、HTTPS 证书卸载与 Canary 金丝雀发布(按权重 & 按 Header)!

步骤 1:部署两个版本的后端微服务(v1 稳定版与 v2 金丝雀版) ​

bash
cat <<'EOF' | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: app-v1
  labels:
    app: order-svc
    version: v1
spec:
  containers:
  - name: web
    image: nginx:stable-alpine
    lifecycle:
      postStart:
        exec:
          command: ["sh", "-c", "echo 'Order Service -> [V1 Stable]' > /usr/share/nginx/html/index.html"]
---
apiVersion: v1
kind: Service
metadata:
  name: order-v1-svc
spec:
  selector:
    app: order-svc
    version: v1
  ports:
  - port: 80
---
apiVersion: v1
kind: Pod
metadata:
  name: app-v2-canary
  labels:
    app: order-svc
    version: v2
spec:
  containers:
  - name: web
    image: nginx:stable-alpine
    lifecycle:
      postStart:
        exec:
          command: ["sh", "-c", "echo 'Order Service -> [V2 CANARY NEW!]' > /usr/share/nginx/html/index.html"]
---
apiVersion: v1
kind: Service
metadata:
  name: order-v2-svc
spec:
  selector:
    app: order-svc
    version: v2
  ports:
  - port: 80
EOF

kubectl wait --for=condition=Ready pod/app-v1 pod/app-v2-canary --timeout=60s

步骤 2:签发自签名 TLS 证书并存入 kubernetes.io/tls Secret ​

bash
# 生成 shop.k8s.local 的自签证书与私钥
openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
  -keyout /tmp/tls.key -out /tmp/tls.crt \
  -subj "/CN=shop.k8s.local/O=shop"

# 创建 TLS Secret
kubectl create secret tls shop-tls-secret --cert=/tmp/tls.crt --key=/tmp/tls.key

步骤 3:部署轻量级 Nginx 七层网关模拟 Ingress Controller(支持 HTTPS + Header/权重金丝雀分流) ​

由于在国内网络拉取庞大的 registry.k8s.io/ingress-nginx/controller 镜像可能较慢,我们在确保已掌握 표준 Ingress YAML 语法的同时,既可以通过官方 YAML 部署 ingress-nginx,也可以直接用集群已有的 nginx:stable-alpine 以 DaemonSet + hostNetwork: true 模式在 lima-node01 的 80/443 端口启动七层网关验证完整链路:

bash
# 1. 编写标准生产级主 Ingress 与 Canary 金丝雀 Ingress YAML(供查阅与规范验证)
cat <<'EOF' | kubectl apply -f -
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: order-main-ingress
spec:
  ingressClassName: nginx
  tls:
  - hosts:
    - shop.k8s.local
    secretName: shop-tls-secret
  rules:
  - host: shop.k8s.local
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: order-v1-svc
            port:
              number: 80
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: order-canary-ingress
  annotations:
    nginx.ingress.kubernetes.io/canary: "true"
    nginx.ingress.kubernetes.io/canary-by-header: "X-Canary"
    nginx.ingress.kubernetes.io/canary-by-header-value: "always"
    nginx.ingress.kubernetes.io/canary-weight: "20"
spec:
  ingressClassName: nginx
  rules:
  - host: shop.k8s.local
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: order-v2-svc
            port:
              number: 80
EOF

kubectl get ingress

现在我们在 lima-node01 上以 hostNetwork: true + dnsPolicy: ClusterFirstWithHostNet 启动承载上述 TLS 与金丝雀路由规则的网关 Pod,直接监听 192.168.104.3:80 与 443:

bash
cat <<'EOF' | kubectl apply -f -
apiVersion: v1
kind: ConfigMap
metadata:
  name: gateway-nginx-conf
data:
  default.conf: |
    # 基于权重的 80/20 金丝雀分流池
     split_clients "${remote_addr}${remote_port}" $canary_pool {
        20%     order-v2-svc.lab4-network.svc.cluster.local;
        *       order-v1-svc.lab4-network.svc.cluster.local;
    }
    # 基于 Header X-Canary: always 的精准灰度映射
    map $http_x_canary $target_backend {
        "always"  order-v2-svc.lab4-network.svc.cluster.local;
        "never"   order-v1-svc.lab4-network.svc.cluster.local;
        default   $canary_pool;
    }
    server {
        listen 80;
        listen 443 ssl;
        server_name shop.k8s.local;
        ssl_certificate /etc/nginx/tls/tls.crt;
        ssl_certificate_key /etc/nginx/tls/tls.key;
        resolver 10.96.0.10 valid=5s;
        location / {
            proxy_pass http://$target_backend:80;
        }
    }
---
apiVersion: v1
kind: Pod
metadata:
  name: hostnet-gateway
spec:
  nodeName: lima-node01
  hostNetwork: true
  dnsPolicy: ClusterFirstWithHostNet   # 关键点:hostNetwork 为 true 时必须配此策略才能使用 CoreDNS!
  containers:
  - name: gateway
    image: nginx:stable-alpine
    volumeMounts:
    - name: conf
      mountPath: /etc/nginx/conf.d
    - name: tls
      mountPath: /etc/nginx/tls
  volumes:
  - name: conf
    configMap:
      name: gateway-nginx-conf
  - name: tls
    secret:
      secretName: shop-tls-secret
EOF

kubectl wait --for=condition=Ready pod/hostnet-gateway --timeout=60s

步骤 4:实测 HTTPS 访问、按权重金丝雀分流与按 Header 精准灰度! ​

bash
# 1. 测试 HTTPS (443) 连续访问 5 次,观察约 80% 命中 [V1 Stable],约 20% 命中 [V2 CANARY NEW!]
for i in $(seq 1 5); do
  curl -sk --resolve shop.k8s.local:443:192.168.104.3 https://shop.k8s.local/
done

# 2. 携带灰度请求头 X-Canary: always 访问,验证 100% 精准命中 [V2 CANARY NEW!]
curl -sk -H "X-Canary: always" --resolve shop.k8s.local:443:192.168.104.3 https://shop.k8s.local/

7. 实验点 4.7:CoreDNS 自定义 hosts 解析与裸 Pod 固定 FQDN 实验 ​

步骤 1:为裸 Pod 配置 hostname + subdomain 获得固定 FQDN ​

原理回顾:不仅 StatefulSet 能拥有固定域名,普通裸 Pod 只要指定 hostname 和 subdomain(与 Headless Service 同名),CoreDNS 也会为其生成 <hostname>.<subdomain>.<ns>.svc.cluster.local 的 A 记录!

bash
cat <<'EOF' | kubectl apply -f -
apiVersion: v1
kind: Service
metadata:
  name: custom-sub
spec:
  clusterIP: None
  selector:
    app: bare-fqdn
---
apiVersion: v1
kind: Pod
metadata:
  name: bare-pod-demo
  labels:
    app: bare-fqdn
spec:
  hostname: my-fixed-host
  subdomain: custom-sub
  containers:
  - name: app
    image: nginx:stable-alpine
EOF

kubectl wait --for=condition=Ready pod/bare-pod-demo --timeout=60s

# 验证通过 my-fixed-host.custom-sub.lab4-network.svc.cluster.local 解析出该裸 Pod 的 IP!
kubectl run dns-test --rm -i --restart=Never --image=busybox:1.36 -- \
  nslookup my-fixed-host.custom-sub.lab4-network.svc.cluster.local

步骤 2:查看 Pod 内 /etc/resolv.conf 的 ndots:5 配置 ​

bash
kubectl exec bare-pod-demo -- cat /etc/resolv.conf

观察结果:

text
search lab4-network.svc.cluster.local svc.cluster.local cluster.local
nameserver 10.96.0.10
options ndots:5

这也直观验证了笔记中的核心知识点:凡是点号少于 5 个的外部域名(如 api.github.com),都会先依次拼接上面 3 个 search 域向 CoreDNS 发起查询,因此在超大规模集群中需要部署 NodeLocalDNSCache 将 UDP 转为 TCP 并提供节点本地缓存。


8. 实验四环境清理 ​

bash
rm -f /tmp/tls.key /tmp/tls.crt
kubectl config set-context --current --namespace=default
kubectl delete namespace lab4-network