网络工程师的eBPF速成指南-从数据包过滤到负载均衡的优化实战

eBPF，网络性能优化的瑞士军刀

作为一名老网络工程师，我深知网络性能优化是个永恒的挑战。传统方案往往需要修改内核代码或者依赖复杂的用户态程序，既耗时又容易出错。直到我遇到了 eBPF（extended Berkeley Packet Filter），才发现原来网络优化可以如此高效、灵活。

什么是 eBPF？

简单来说，eBPF 是一个内核级的虚拟机，允许你在内核中安全地运行自定义代码，而无需修改内核源码或加载内核模块。你可以把它想象成一个可以在内核中“热插拔”的程序，用来监控、分析和修改内核行为。

为什么网络工程师需要学习 eBPF？

• 性能卓越：eBPF 代码直接在内核中运行，避免了用户态和内核态之间频繁切换的开销，性能远超传统方案。
• 高度灵活：你可以用 C 或 Rust 等高级语言编写 eBPF 程序，然后编译成字节码加载到内核中。这意味着你可以根据实际需求定制网络功能，而无需受限于内核的预设行为。
• 安全可靠：eBPF 运行时会经过严格的校验，确保程序的安全性和稳定性，避免对内核造成损害。
• 应用广泛：eBPF 不仅可以用于网络优化，还可以用于安全、监控、追踪等领域。掌握 eBPF，你就能打开一扇通往内核的大门，探索无限可能。

eBPF 在网络优化中的三大应用场景

接下来，我将结合实际案例，分享 eBPF 在网络优化中的三大应用场景：数据包过滤、流量整形和负载均衡。

1. 数据包过滤：精准拦截，安全加固

传统方案的痛点

传统的 iptables 规则虽然强大，但配置复杂，维护困难，而且性能相对较低。每当需要添加或修改规则时，都需要刷新整个规则集，对线上业务造成潜在影响。

eBPF 的解决方案

使用 eBPF，你可以编写高效的数据包过滤器，直接在网络接口处拦截恶意流量。与 iptables 相比，eBPF 过滤器具有以下优势：

• 更高的性能：eBPF 代码直接在内核中运行，避免了 iptables 的规则匹配开销。
• 更强的灵活性：你可以根据数据包的任意字段进行过滤，包括自定义协议头部。
• 动态更新：你可以随时更新 eBPF 过滤器，无需刷新整个规则集，对线上业务无感知。

实战案例：DDoS 防护

假设你的网站遭受了 SYN Flood 攻击，传统的 iptables 方案可能无法有效应对。使用 eBPF，你可以编写一个简单的程序，统计每个 IP 地址的 SYN 包数量，并对超过阈值的 IP 地址进行限流。

#include <linux/bpf.h>
#include <linux/pkt_cls.h>
#include <linux/ip.h>
#include <linux/tcp.h>
 
#define MAX_SYN_PER_IP 100
 
struct bpf_map_def SEC("maps") syn_count_map = {
    .type = BPF_MAP_TYPE_HASH,
    .key_size = sizeof(unsigned int), // IP address
    .value_size = sizeof(unsigned int), // SYN count
    .max_entries = 1024,
};
 
SEC("action")
int syn_flood_filter(struct __sk_buff *skb) {
    // 获取 IP 头部
    struct iphdr *ip = bpf_hdr_pointer(skb, 0, sizeof(struct iphdr), iphdr);
    if (!ip) {
        return TC_ACT_OK; // 放行非 IP 包
    }
 
    // 获取 TCP 头部
    struct tcphdr *tcp = bpf_hdr_pointer(skb, ip->ihl * 4, sizeof(struct tcphdr), tcphdr);
    if (!tcp) {
        return TC_ACT_OK; // 放行非 TCP 包
    }
 
    // 只处理 SYN 包
    if (!tcp->syn) {
        return TC_ACT_OK; // 放行非 SYN 包
    }
 
    // 统计 SYN 包数量
    unsigned int ip_addr = ip->saddr;
    unsigned int *count = bpf_map_lookup_elem(&syn_count_map, &ip_addr);
    if (!count) {
        unsigned int init_count = 1;
        bpf_map_update_elem(&syn_count_map, &ip_addr, &init_count, BPF_ANY);
    } else {
        *count += 1;
        if (*count > MAX_SYN_PER_IP) {
            return TC_ACT_SHOT; // 丢弃 SYN 包
        }
    }
 
    return TC_ACT_OK; // 放行 SYN 包
}
 
char _license[] SEC("license") = "GPL";

这段代码首先定义了一个 eBPF Map，用于存储每个 IP 地址的 SYN 包数量。然后，它定义了一个 eBPF 程序，用于过滤 SYN 包。该程序会检查每个 SYN 包的源 IP 地址，如果该 IP 地址的 SYN 包数量超过了 MAX_SYN_PER_IP，则丢弃该包，否则放行。将此程序加载到网络接口，即可有效缓解 SYN Flood 攻击。

总结

通过 eBPF，你可以构建高性能、高灵活性的数据包过滤器，有效提升网络安全防护能力。

2. 流量整形：智能调度，优化体验

传统方案的痛点

传统的流量整形方案通常依赖 tc 命令，配置复杂，难以维护，而且对突发流量的处理效果不佳。此外，tc 只能基于简单的规则进行流量控制，无法根据应用类型或用户优先级进行智能调度。

eBPF 的解决方案

使用 eBPF，你可以编写智能的流量整形器，根据应用类型、用户优先级等因素动态调整流量分配。与 tc 相比，eBPF 流量整形器具有以下优势：

• 更精细的控制：你可以根据数据包的任意字段进行流量控制，包括应用层协议头部。
• 动态调整：你可以根据网络状况或应用需求动态调整流量分配策略。
• 更高的优先级：eBPF 代码直接在内核中运行，可以优先处理关键应用的流量。

实战案例：保障 VoIP 通话质量

假设你的网络中同时运行着 VoIP 和文件传输应用。为了保障 VoIP 通话质量，你需要优先处理 VoIP 流量，限制文件传输流量。使用 eBPF，你可以编写一个程序，识别 VoIP 流量（例如，基于端口号），并将其放入高优先级队列，限制文件传输流量的带宽。

#include <linux/bpf.h>
#include <linux/pkt_cls.h>
#include <linux/ip.h>
#include <linux/udp.h>
 
#define VOIP_PORT 5060 // SIP 端口
#define MAX_VOIP_BANDWIDTH 1000000 // 1 Mbps
 
struct bpf_map_def SEC("maps") voip_bandwidth_map = {
    .type = BPF_MAP_TYPE_ARRAY,
    .key_size = sizeof(unsigned int), // Queue ID
    .value_size = sizeof(unsigned long long), // Bandwidth usage
    .max_entries = 1,
};
 
SEC("action")
int voip_qos(struct __sk_buff *skb) {
    // 获取 IP 头部
    struct iphdr *ip = bpf_hdr_pointer(skb, 0, sizeof(struct iphdr), iphdr);
    if (!ip) {
        return TC_ACT_OK; // 放行非 IP 包
    }
 
    // 获取 UDP 头部
    struct udphdr *udp = bpf_hdr_pointer(skb, ip->ihl * 4, sizeof(struct udphdr), udphdr);
    if (!udp) {
        return TC_ACT_OK; // 放行非 UDP 包
    }
 
    // 判断是否为 VoIP 流量
    if (udp->dest == htons(VOIP_PORT) || udp->source == htons(VOIP_PORT)) {
        // 放入高优先级队列
        bpf_skb_change_prio(skb, 1); // 假设队列 ID 为 1
 
        // 限制 VoIP 带宽
        unsigned int queue_id = 0;
        unsigned long long *bandwidth = bpf_map_lookup_elem(&voip_bandwidth_map, &queue_id);
        if (!bandwidth) {
            unsigned long long init_bandwidth = skb->len;
            bpf_map_update_elem(&voip_bandwidth_map, &queue_id, &init_bandwidth, BPF_ANY);
        } else {
            if (*bandwidth + skb->len > MAX_VOIP_BANDWIDTH) {
                return TC_ACT_SHOT; // 丢弃超额流量
            } else {
                *bandwidth += skb->len;
            }
        }
    } else {
        // 放入低优先级队列
        bpf_skb_change_prio(skb, 0); // 假设队列 ID 为 0
    }
 
    return TC_ACT_OK; // 放行数据包
}
 
char _license[] SEC("license") = "GPL";

这段代码首先定义了一个 eBPF Map，用于存储 VoIP 队列的带宽使用情况。然后，它定义了一个 eBPF 程序，用于识别 VoIP 流量并将其放入高优先级队列，限制 VoIP 流量的带宽。将此程序加载到网络接口，即可有效保障 VoIP 通话质量。

总结

通过 eBPF，你可以构建智能的流量整形器，根据应用类型、用户优先级等因素动态调整流量分配，优化网络体验。

3. 负载均衡：智能分发，提升性能

传统方案的痛点

传统的负载均衡方案通常依赖 LVS 或 HAProxy 等软件，配置复杂，性能有限，而且难以应对动态变化的应用场景。此外，传统的负载均衡器只能基于简单的规则进行流量分发，无法根据后端服务器的实际负载进行智能调度。

eBPF 的解决方案

使用 eBPF，你可以构建高性能、高灵活性的负载均衡器，直接在内核中进行流量分发。与传统方案相比，eBPF 负载均衡器具有以下优势：

• 更高的性能：eBPF 代码直接在内核中运行，避免了用户态和内核态之间频繁切换的开销。
• 更强的灵活性：你可以根据后端服务器的实际负载、健康状况等因素动态调整流量分发策略。
• 无缝集成：eBPF 负载均衡器可以与 Kubernetes 等容器编排平台无缝集成，实现自动化运维。

实战案例：Kubernetes Service 负载均衡

在 Kubernetes 中，Service 是一种抽象层，用于暴露应用程序的访问入口。传统的 Kubernetes Service 负载均衡依赖 kube-proxy 组件，性能较低。使用 eBPF，你可以直接在内核中实现 Service 负载均衡，提升性能。

#include <linux/bpf.h>
#include <linux/pkt_cls.h>
#include <linux/ip.h>
#include <linux/tcp.h>
 
#define SERVICE_PORT 80
#define BACKEND_COUNT 2
 
struct backend {
    unsigned int ip;
    unsigned short port;
};
 
struct backend backends[BACKEND_COUNT] = {
    { .ip = 0x01020304, .port = 8080 }, // 1.2.3.4:8080
    { .ip = 0x05060708, .port = 8080 }  // 5.6.7.8:8080
};
 
struct bpf_map_def SEC("maps") backend_map = {
    .type = BPF_MAP_TYPE_ARRAY,
    .key_size = sizeof(unsigned int), // Backend ID
    .value_size = sizeof(struct backend),
    .max_entries = BACKEND_COUNT,
};
 
SEC("action")
int service_load_balancer(struct __sk_buff *skb) {
    // 获取 IP 头部
    struct iphdr *ip = bpf_hdr_pointer(skb, 0, sizeof(struct iphdr), iphdr);
    if (!ip) {
        return TC_ACT_OK; // 放行非 IP 包
    }
 
    // 获取 TCP 头部
    struct tcphdr *tcp = bpf_hdr_pointer(skb, ip->ihl * 4, sizeof(struct tcphdr), tcphdr);
    if (!tcp) {
        return TC_ACT_OK; // 放行非 TCP 包
    }
 
    // 只处理访问 Service 端口的流量
    if (tcp->dest != htons(SERVICE_PORT)) {
        return TC_ACT_OK; // 放行非 Service 流量
    }
 
    // 选择后端服务器
    unsigned int backend_id = bpf_get_prandom_u32() % BACKEND_COUNT;
    struct backend *backend = bpf_map_lookup_elem(&backend_map, &backend_id);
    if (!backend) {
        return TC_ACT_OK; // 放行数据包
    }
 
    // 修改目标 IP 和端口
    ip->daddr = backend->ip;
    tcp->dest = backend->port;
 
    // 重新计算校验和
    bpf_l4_csum_replace(skb, ip->check, ip->daddr, backend->ip, BPF_F_PSEUDO_HDR | BPF_F_MARK_MANGLED_0);
    bpf_l4_csum_replace(skb, tcp->check, tcp->dest, backend->port, BPF_F_PSEUDO_HDR | BPF_F_MARK_MANGLED_0);
 
    return TC_ACT_OK; // 放行数据包
}
 
char _license[] SEC("license") = "GPL";

这段代码首先定义了一个 eBPF Map，用于存储后端服务器的信息。然后，它定义了一个 eBPF 程序，用于选择后端服务器并修改目标 IP 和端口。将此程序加载到网络接口，即可实现 Kubernetes Service 负载均衡。

总结

通过 eBPF，你可以构建高性能、高灵活性的负载均衡器，提升应用性能和可用性。

eBPF 的学习曲线和工具链

不可否认，eBPF 的学习曲线相对陡峭。你需要掌握 C 或 Rust 等编程语言，了解 Linux 内核网络协议栈，熟悉 eBPF 的编程模型和工具链。

常用工具

• bcc (BPF Compiler Collection)：一个 Python 库，用于编写、编译和加载 eBPF 程序。它提供了一系列高级 API，简化了 eBPF 开发流程。
• bpftool：一个命令行工具，用于管理和调试 eBPF 程序。你可以用它来加载、卸载、查看 eBPF 程序和 Map。
• cilium：一个基于 eBPF 的网络和安全解决方案，提供了丰富的功能，包括网络策略、服务网格、可观测性等。

学习资源

• 官方文档：Linux 内核文档、bcc 文档、bpftool 文档等。
• 在线课程：Coursera、edX、Udemy 等平台上的 eBPF 相关课程。
• 开源项目：GitHub 上的 eBPF 相关项目，例如 cilium、falco、bpftrace 等。

总结与展望

eBPF 是一项革命性的技术，为网络工程师带来了前所未有的机遇。掌握 eBPF，你就能深入内核，定制网络功能，优化网络性能，提升网络安全。

虽然 eBPF 的学习曲线较陡峭，但只要你肯投入时间和精力，就能掌握这项强大的技术，成为网络领域的佼佼者。

未来，eBPF 将在网络领域发挥越来越重要的作用。随着技术的不断发展，eBPF 将会变得更加易用、强大和普及。让我们一起拥抱 eBPF，迎接网络技术的新时代！