第29周：Cilium 与 eBPF 生态

字数统计: 2.1k字   |   阅读时长≈ 10分

第29周：Cilium 与 eBPF 生态

目标：理解 Cilium 等 eBPF 生态项目，掌握 eBPF 在生产环境的实际应用。

1. eBPF 生态概览

1.1 主流 eBPF 项目

1
2
3
4
5
6
7
8
9
10
eBPF 生态：

  ┌─────────────────────────────────────────────────┐
  │  网络          │  观察         │  安全          │
  ├─────────────────────────────────────────────────┤
  │  Cilium        │  Pixie        │  Tetragon      │
  │  Katran        │  bcc          │  Falco         │
  │  Calico        │  bpftrace     │  Tracee        │
  │  Cilium/Hubble │  OpenTelemetry │ seccomp-profile│
  └─────────────────────────────────────────────────┘

1.2 工具链生态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
工具链：

  ┌─────────────────────────────────────────────┐
  │ 用户空间                                     │
  │   bcc-tools                                 │
  │   bpftrace                                  │
  │   libbpf + bpftool                          │
  │   libbpf-bootstrap（CO-RE）                  │
  │   Cilium/Hubble                             │
  └──────────────┬──────────────────────────────┘
                 │
  ┌──────────────▼──────────────────────────────┐
  │ 验证器 + JIT                                 │
  │   验证器（safety）                          │
  │   BPF JIT（x86/ARM）                        │
  │   静态分析                                   │
  └──────────────┬──────────────────────────────┘
                 │
  ┌──────────────▼──────────────────────────────┐
  │ 内核态 Hook 点                               │
  │   XDP（驱动级）                             │
  │   TC（流量控制）                            │
  │   Socket                                    │
  │   kprobe/tracepoint                         │
  │   cgroup                                    │
  │   LSM                                      │
  └─────────────────────────────────────────────┘

2. Cilium 架构

2.1 核心组件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
Cilium 架构：

                ┌──────────────────────┐
                │  Cilium Agent        │
                │  (用户态守护进程)     │
                │  - API Server        │
                │  - CNI Plugin        │
                │  - Envoy Proxy       │
                └──────────┬───────────┘
                           │ 管理
                           ▼
                ┌──────────────────────┐
                │  BPF Maps            │
                │  - 端点信息          │
                │  - 策略              │
                │  - 连接跟踪          │
                │  - 服务后端          │
                └──────────┬───────────┘
                           │
                           ▼
        ┌──────────────────────────────────┐
        │  数据路径 (BPF 数据面)             │
        │                                   │
        │  XDP ─→ 端点 ─→ TC ─→ Socket    │
        │  (入)  (策略) (出)              │
        │                                   │
        │  绕过 iptables 和 kube-proxy      │
        └──────────────────────────────────┘

2.2 关键功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Cilium 提供的核心能力：

1. 网络策略（Network Policy）
   - L3/L4/L7 策略
   - 通过 BPF 直接在 NIC 强制执行
   - 不需要 iptables

2. 服务负载均衡
   - 替代 kube-proxy
   - 在 XDP/TC 阶段完成
   - 支持 ClusterIP、NodePort、ExternalIP

3. 可观测性（Hubble）
   - L3/L4/L7 流量可见
   - DNS 解析
   - 性能指标

4. 透明加密
   - WireGuard/IPSec
   - 节点间加密

5. 多集群
   - ClusterMesh
   - 跨集群服务发现

3. Cilium 数据路径详解

3.1 入站路径

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
入站（client → server pod）：

  ┌─────────┐
  │ 网卡 RX │
  └────┬────┘
       │
       ▼
  ┌─────────────┐
  │  XDP 程序    │ ← node-level 策略
  │  bpf_xdp_   │  - DDoS 防护
  │  process()   │  - 节点端口
  └────┬────────┘
       │
       ▼
  ┌─────────────┐
  │  协议栈     │
  │  ip_input   │
  └────┬────────┘
       │
       ▼
  ┌─────────────┐
  │  TC ingress │ ← pod-level 策略
  │  bpf_netdev │  - NetworkPolicy
  │  _ingress() │  - 加密解密
  └────┬────────┘
       │
       ▼
  ┌─────────────┐
  │  lxc-xxx    │ ← 端点策略
  │  (veth)     │  - Identity 检查
  └────┬────────┘
       │
       ▼
  ┌─────────────┐
  │  Pod 内      │
  │  应用进程    │
  └─────────────┘

3.2 出站路径

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
出站（pod → external）：

  ┌─────────────┐
  │  Pod 内     │
  │  应用进程    │
  └────┬────────┘
       │
       ▼
  ┌─────────────┐
  │  lxc-xxx    │ ← 端点策略
  │  (veth)     │  - NetworkPolicy
  └────┬────────┘
       │
       ▼
  ┌─────────────┐
  │  TC egress  │ ← 加密、SNAT
  │  bpf_netdev │  - 服务负载均衡
  │  _egress()  │
  └────┬────────┘
       │
       ▼
  ┌─────────────┐
  │  协议栈     │
  └────┬────────┘
       │
       ▼
  ┌─────────────┐
  │  网卡 TX    │
  └─────────────┘

4. Cilium 关键 BPF 代码片段

4.1 XDP 处理入口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// 节选自 bpf_xdp.c（Cilium 源码，简化版）

#include <bpf/ctx/xdp.h>
#include <bpf/api.h>
#include <node_config.h>

__section("to-container")
int to_container(struct xdp_md *ctx) {
    void *data_end = (void *)(long)ctx->data_end;
    void *data = (void *)(long)ctx->data;
    struct ethhdr *eth = data;
    int ret;

    // 1. 边界检查
    if (data + sizeof(*eth) > data_end) {
        return XDP_DROP;
    }

    // 2. 解析协议
    if (eth->h_proto == bpf_htons(ETH_P_IPV6)) {
        // IPv6 处理
        ret = handle_ipv6(ctx, eth, data, data_end);
    } else if (eth->h_proto == bpf_htons(ETH_P_IP)) {
        // IPv4 处理
        ret = handle_ipv4(ctx, eth, data, data_end);
    } else {
        return XDP_PASS;  // 未知协议透传
    }

    if (ret < 0) {
        return XDP_DROP;
    }

    return XDP_PASS;
}

4.2 服务负载均衡（XDP）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// 节选自 bpf_xdp.c（XDP 阶段的服务负载均衡）

static __always_inline int
handle_ipv4(struct xdp_md *ctx, struct ethhdr *eth,
             void *data, void *data_end) {
    struct iphdr *ip4 = (struct iphdr *)(eth + 1);

    // 1. 检查是否是本节点的服务 IP
    if (ip4->daddr == IDENTITY_HOST) {
        // 不做负载均衡，让协议栈处理
        return CTX_ACT_OK;
    }

    // 2. 查 NodePort 服务映射
    struct lb4_service_v2 *svc;
    svc = lb4_lookup_service_v2(svc_v2_map, ip4->daddr, l4_dport);
    if (svc) {
        // 3. 选择后端（一致性哈希 / 轮询）
        struct lb4_backend *backend;
        backend = lb4_select_backend(svc, ctx);

        // 4. DNAT 转发
        ip4->daddr = backend->address;
        tcp->dest = backend->port;

        // 5. 重新计算校验和
        csum_l4_update(ctx);

        // 6. 重定向到目标后端
        return bpf_redirect(backend->ifindex, 0);
    }

    return CTX_ACT_OK;  // 不是服务流量
}

4.3 TC 入口策略

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
// 节选自 bpf_netdev.c（TC ingress 策略执行）

__section("from-container")
int from_container(struct __sk_buff *skb) {
    // 1. 解析包
    struct identity_info *info;
    info = lookup_identity(skb->mark);
    if (!info) {
        // 未识别身份
        return TC_ACT_SHOT;
    }

    // 2. 检查策略
    struct policy_key key = {
        .src_identity = info->src_identity,
        .dst_identity = info->dst_identity,
        .dst_port = l4_dport,
    };

    struct policy_value *policy;
    policy = bpf_map_lookup_elem(&cilium_policy_map, &key);
    if (!policy || !policy->allowed) {
        return TC_ACT_SHOT;  // 拒绝
    }

    // 3. 服务负载均衡
    if (is_service_traffic) {
        do_lb(skb);
    }

    // 4. 加密（如果需要）
    if (needs_encryption) {
        do_encrypt(skb);
    }

    return TC_ACT_OK;
}

4.4 关键 Map 类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
// === 端点信息 ===
struct endpoint_info {
    u32 ifindex;
    u32 lxc_id;
    struct endpoint_key key;
    u8  mac[6];
    u8  host_mac[6];
};

// === 策略 ===
struct policy_key {
    u32 src_identity;  // 安全身份
    u32 dst_identity;
    u16 dst_port;
    u8  protocol;
    // ...
};

struct policy_value {
    u8  allowed;
    u8  audited;
    // ...
};

// === 服务负载均衡 ===
struct lb4_service_v2 {
    union {
        struct {
            u32 backend_id;  // 后端组 ID
            u8  affinity_timeout;  // 会话保持超时
            u8  chash_range;  // 一致性哈希范围
        };
        u32 v1_flags;
    };
    u16 count;  // 后端数量
    u8  flags;  // 协议类型等
    u8  external;
    u16 rev_nat_index;
    u16 port;
};

// === 连接跟踪 ===
struct ct_entry {
    u8  rev_nat_index;
    u8  flags;
    u16 src_sec_id;  // 源安全身份
    u32 backend_id;
    // ...
};

5. Cilium 部署实践

5.1 快速安装

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# === Kubernetes + Cilium（kind）===

# 1. 创建集群
cat <<EOF | kind create cluster --config=-
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
  - role: control-plane
  - role: worker
networking:
  disableDefaultCNI: true
EOF

# 2. 安装 Cilium
cilium install \
    --set kubeProxyReplacement=strict \
    --set bpf.masquerade=true \
    --set hubble.enabled=true \
    --set hubble.metrics.enabled="{dns,drop,tcp,flow,port-distribution,icmp,httpV2:exemplars=true;labelsContext=source_ip\,source_namespace\,source_workload\,destination_ip\,destination_namespace\,destination_workload}"

# 3. 验证
cilium status
cilium connectivity test

# 4. 安装 Hubble UI（可视化）
cilium hubble enable ui
cilium hubble port-forward &
# 访问 http://localhost:12000

5.2 替代 kube-proxy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# kube-proxy 模式
apiVersion: cilium.io/v2
kind: CiliumClusterwideNetworkPolicy
metadata:
  name: cluster-wide-policy
spec:
  nodeSelector: {}
  ingress:
    - fromEndpoints:
        - matchLabels:
            io.kubernetes.pod.namespace: default
      toPorts:
        - ports:
            - port: "80"
              protocol: TCP

5.3 观察 XDP 与 TC 加载

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 查看 Cilium 加载的 BPF 程序
cilium status --verbose

# 列出 BPF 程序
sudo bpftool prog list | head -20

# 输出示例：
# 42: xdp  tag ...  gpl
# 43: xdp  tag ...  gpl
# 44: sched_cls  tag ...  gpl
# 45: sk_filter  tag ...  gpl

# 查看 attach 点
sudo bpftool net show
# XDP:
#   eth0(2)  id 42
# TC:
#   eth0(2) ingress  id 44
#   eth0(2) egress   id 45

# 查看 Cilium 关键 map
sudo bpftool map list | grep cilium

6. 替代方案对比

6.1 Cilium vs 其他 CNI

特性 Cilium Calico Flannel
数据面 eBPF (XDP/TC) iptables + eBPF VxLAN
性能 极优 中等 中等
策略 L3/L4/L7 L3/L4 无
加密 WireGuard/IPSec IPsec 无
可观测性 Hubble 基础 无
替换 kube-proxy 支持 有限 不支持
资源占用 中等 中等 极低
学习曲线 陡 中等 平缓

6.2 eBPF vs iptables

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
性能对比（10GbE，64B 包）：

  iptables: 1-3 Mpps
  eBPF/XDP: 12-14 Mpps（线速）
  性能提升: 5-10x

特性对比：
  ┌──────────┬──────────┬──────────┐
  │          │ iptables │ eBPF/XDP │
  ├──────────┼──────────┼──────────┤
  │ 执行点   │ netfilter│ 驱动级   │
  │ 规则数   │ O(n)     │ O(1)     │
  │ 可观测性 │ 弱       │ 强       │
  │ 编程性   │ 静态     │ 动态     │
  │ 性能     │ 1-3M     │ 12-14M   │
  │ 升级     │ 慢       │ 热升级   │
  │ 调试     │ 难       │ bpftrace │
  └──────────┴──────────┴──────────┘

7. Tetragon（Cilium 安全）

7.1 Tetragon 概述

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
Tetragon：基于 eBPF 的安全可观测平台

能力：
  - 实时进程级安全策略
  - 文件访问监控
  - 网络连接监控
  - 系统调用过滤

示例 TracingPolicy：

  apiVersion: cilium.io/v1alpha1
  kind: TracingPolicy
  metadata:
    name: monitor-curl
  spec:
    kprobes:
      - call: "fd_install"
        syscall: false
        args:
          - index: 0
            type: "nop"
          - index: 1
            type: "nop"
    tracepoints:
      - subsystem: "net"
        event: "net_dev_xmit"
        args:
          - index: 0
            type: "nop"

7.2 Tetragon 安装

1
2
3
4
5
6
7
8
# 安装
helm install tetragon cilium/tetragon -n kube-system

# 加载示例
kubectl apply -f https://raw.githubusercontent.com/cilium/tetragon/main/examples/crds/tetragon-tracingpolicy.yaml

# 观察事件
kubectl logs -n kube-system -l app.kubernetes.io/name=tetragon

8. 其他 eBPF 项目

8.1 Katran（Facebook 负载均衡）

1
2
3
4
5
6
7
Katran：
  - Facebook 开发的 XDP 负载均衡器
  - 替代 IPVS
  - 4 层负载均衡
  - 性能：单核 10M+ pps

代码：https://github.com/facebookincubator/katran

8.2 Pixie（可观测性）

1
2
3
4
5
6
7
Pixie（New Relic）：
  - Kubernetes 应用可观测性
  - 自动 eBPF 跟踪
  - 无需修改应用
  - 实时查询

官网：https://px.dev

8.3 其他

项目 用途 关键特性
bcc BPF 工具集 Python/Lua 前端
bpftrace 高级 BPF 脚本语言 单行命令跟踪
Falco 运行时安全 系统调用监控
OpenTelemetry 分布式追踪 eBPF 自动插桩
Parca 持续分析 火焰图、低开销

9. eBPF 性能优化技巧

9.1 编写高性能 XDP 程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// === 优化 1：避免不必要的工作 ===
SEC("xdp")
int xdp_fast(struct xdp_md *ctx) {
    // 快速路径：早期返回
    void *data = (void *)(long)ctx->data;
    void *data_end = (void *)(long)ctx->data_end;

    struct ethhdr *eth = data;
    if ((void *)(eth + 1) > data_end)
        return XDP_PASS;  // 早返回

    // 不在快速路径上做日志
    // 不在快速路径上做复杂计算
    // ...

    return XDP_PASS;
}

// === 优化 2：使用 LPM_TRIE 而非 Hash ===
// 路由查找用 LPM（O(log n)），不要用 Hash

// === 优化 3：per-CPU 计数器 ===
// 避免共享锁

9.2 Map 选择

Map 类型 用例
HASH 通用 key-value
PERCPU_ARRAY 计数（避免锁）
LRU_HASH 自动淘汰
LPM_TRIE IP 路由
RINGBUF 事件传递（推荐）
ARRAY_OF_MAPS 复杂场景

9.3 验证器友好

1
2
3
4
5
6
7
8
9
10
11
12
// ✅ 静态循环
for (int i = 0; i < 4; i++) { }

// ❌ 动态循环（验证器拒绝）
while (count > 0) { count = ...; }

// ✅ 检查后访问
if (off + sizeof(struct x) > data_end) return XDP_PASS;
struct x *x = data + off;

// ❌ 信任指针
struct x *x = (struct x *)data;  // 验证器拒绝

10. eBPF 学习路径总结

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
入门路径：

Week 1-2: bpftrace 单行命令
  - 跟踪系统调用
  - 网络事件
  - 性能瓶颈定位

Week 3-4: bcc 工具
  - 预制工具使用（execsnoop, tcpconnect）
  - 编写简单 Python 风格 BPF

Week 5-6: libbpf + C
  - 编写 libbpf 程序
  - BPF map 交互
  - 用户态加载器

Week 7-8: XDP
  - XDP DROP/PASS/TX
  - DDoS 防护
  - 负载均衡

Week 9-10: TC + 高级
  - TC 挂载
  - 性能分析（火焰图）
  - 容器网络（Cilium）
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发、Linux开发、
公众号开发、开源爱好者、Linux

联系QQ:562054870