第38周：高性能网关与 NAT 设计

字数统计: 2.6k字   |   阅读时长≈ 13分

第38周：高性能网关与 NAT 设计

目标：理解工业级 NAT 网关（conntrack 表设计、SNAT/DNAT、Full-NAT 行为差异），能够改进之前 DPDK L4 LB 的连接跟踪实现。

1. NAT 类型详解

1.1 NAT 行为分类（RFC 3489 / 5780）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
四种 NAT 行为：

┌─────────┬──────────────┬──────────────┬──────────────┐
│ 类型     │ 内网到外网     │ 外网到内网     │ 特点         │
├─────────┼──────────────┼──────────────┼──────────────┤
│ Full    │ 改 src IP+    │ 改 dst IP+   │ 最强，       │
│ Cone    │ port         │ port（一致）  │ 一致映射     │
├─────────┼──────────────┼──────────────┼──────────────┤
│ Restricted│改 src IP+  │ 改 dst IP+   │ 外网可主动   │
│ Cone    │ port         │ port         │ 但需用过的 IP│
├─────────┼──────────────┼──────────────┼──────────────┤
│ Port    │ 改 src IP+   │ 改 dst IP+   │ 每连接不同   │
│ Restricted│ port       │ port（每连接）│ 外网映射     │
│ Cone    │              │              │              │
├─────────┼──────────────┼──────────────┼──────────────┤
│ Symmetric│改 src IP+   │ 改 dst IP+   │ 最严格       │
│         │ port（每目的）│ port（每目的）│ 最难穿透     │
└─────────┴──────────────┴──────────────┴──────────────┘

1.2 Linux NAT 实际行为

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Linux NAT 实现：

1. 静态 SNAT/MASQUERADE：
   - 创建映射 (proto, src_ip, src_port) → (ext_ip, ext_port)
   - 对于同一内网 IP 的所有连接，使用同一外部端口（限制性锥形）
   - 实际行为：Restricted Cone

2. MASQUERADE（IP 伪装）：
   - 类似 SNAT，但动态获取外部 IP
   - 行为与 SNAT 相同

3. FULL CONE NAT 模拟：
   - Linux 不原生支持 Full Cone
   - 需要 full-cone-nat（iptables 模块）或应用层实现

4. Symmetric NAT：
   - Linux 行为取决于对端地址
   - 需要 ALG 或 STUN 协助

1.3 高级 NAT 工具

1
2
3
4
5
6
7
# full-cone-nat 项目（Netfilter）
git clone https://github.com/nicman239/full-cone-nat.git
cd full-cone-nat
make
sudo insmod full_cone_nat.ko
# 启用 Full NAT
sudo iptables -t nat -A PREROUTING -j FULLCONENAT

2. conntrack 表设计

2.1 conntrack 表结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
conntrack（connection tracking）表：
  - 跟踪每个连接的状态
  - NAT 映射的源数据
  - 超时回收

典型条目：
  ┌─────────────────────────────────────────┐
  │  Tuple:                                    │
  │  src_ip=10.0.1.10, src_port=12345        │
  │  dst_ip=10.0.0.5, dst_port=80            │
  │  protocol=TCP                              │
  ├─────────────────────────────────────────┤
  │  Reply tuple:                              │
  │  src_ip=10.0.0.5, src_port=80            │
  │  dst_ip=10.0.0.1, dst_port=40000         │  ← 替换
  │  protocol=TCP                              │
  ├─────────────────────────────────────────┤
  │  State: ESTABLISHED                       │
  │  Created: 2.5s ago                        │
  │  Bytes: 12345, Packets: 89               │
  └─────────────────────────────────────────┘

2.2 conntrack 超时参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# Linux conntrack 超时（/proc/sys/net/netfilter/）
nf_conntrack_tcp_timeout_established    # 默认 432000s（5天）
nf_conntrack_tcp_timeout_time_wait        # 默认 120s
nf_conntrack_tcp_timeout_close_wait       # 默认 60s
nf_conntrack_tcp_timeout_fin_wait         # 默认 120s
nf_conntrack_tcp_timeout_syn_sent        # 默认 120s
nf_conntrack_tcp_timeout_syn_recv        # 默认 60s
nf_conntrack_udp_timeout                  # 默认 30s
nf_conntrack_udp_timeout_stream           # 默认 180s
nf_conntrack_icmp_timeout                 # 默认 30s

# 表大小
nf_conntrack_max                          # 默认 65536
nf_conntrack_buckets                       # hash 桶数

2.3 DPDK L4 LB 中的 conntrack 设计

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
// conntrack.h — 高性能 conntrack 表
#ifndef CONNTRACK_H
#define CONNTRACK_H

#include <stdint.h>
#include <rte_hash.h>
#include <rte_mempool.h>

// 五元组
struct ct_key {
    uint32_t src_ip;
    uint32_t dst_ip;
    uint16_t src_port;
    uint16_t dst_port;
    uint8_t  protocol;
} __attribute__((packed));

// TCP 状态
enum ct_tcp_state {
    CT_TCP_NEW,
    CT_TCP_SYN_SENT,
    CT_TCP_SYN_RCVD,
    CT_TCP_ESTABLISHED,
    CT_TCP_FIN_WAIT,
    CT_TCP_CLOSE_WAIT,
    CT_TCP_LAST_ACK,
    CT_TCP_TIME_WAIT,
    CT_TCP_CLOSED
};

// 会话条目（完整 conntrack 条目）
struct ct_entry {
    struct ct_key   orig;           // 原始方向 5 元组
    struct ct_key   reply;          // 反向 5 元组
    uint32_t         ext_ip;        // 外部 IP（NAT 后）
    uint16_t         ext_port;      // 外部端口
    enum ct_tcp_state state;
    uint64_t         create_ts;
    uint64_t         last_ts;
    uint64_t         packets;
    uint64_t         bytes;
    uint32_t         flags;         // 标志位
};

// 标志位
#define CT_FLAG_STATIC    0x01     // 静态映射（不超时）
#define CT_FLAG_ASSURED   0x02     // 已确认（流量达到阈值）

// 哈希表（使用 DPDK rte_hash 避免锁）
struct conntrack {
    struct rte_hash      *hash;        // 精确匹配的 5 元组 hash
    struct rte_mempool   *entry_pool;  // 条目池
    uint32_t              max_entries;
    uint32_t              timeout_sec;
};

// 双键索引：双向都插入
struct conntrack *conntrack_create(uint32_t max_entries, uint32_t timeout_sec);

// 插入（双向）
int conntrack_add(struct conntrack *ct, struct ct_entry *entry);

// 查找
struct ct_entry *conntrack_lookup(struct conntrack *ct, struct ct_key *key);

// 删除
int conntrack_delete(struct conntrack *ct, struct ct_key *key);

// 老化清理
void conntrack_gc(struct conntrack *ct);

#endif

2.4 conntrack 老化实现

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
// conntrack.c
#include "conntrack.h"
#include <rte_cycles.h>

struct conntrack *conntrack_create(uint32_t max_entries, uint32_t timeout_sec) {
    struct conntrack *ct = rte_zmalloc(NULL, sizeof(*ct), 0);

    // 创建 hash 表（双向 5 元组映射）
    struct rte_hash_parameters hp = {
        .name = "CONNTRACK",
        .entries = max_entries * 2,  // 双向 × 2
        .key_len = sizeof(struct ct_key),
        .hash_func = rte_jhash,
        .hash_func_init_val = 0,
        .socket_id = SOCKET_ID_ANY,
    };
    ct->hash = rte_hash_create(&hp);

    // 条目池
    char name[64];
    snprintf(name, sizeof(name), "CT_ENTRY");
    ct->entry_pool = rte_mempool_create(name, max_entries,
                                          sizeof(struct ct_entry),
                                          256, 0, NULL, NULL, NULL,
                                          SOCKET_ID_ANY, 0);

    ct->max_entries = max_entries;
    ct->timeout_sec = timeout_sec;
    return ct;
}

int conntrack_add(struct conntrack *ct, struct ct_entry *entry) {
    // 分配条目
    struct ct_entry *new_entry = rte_mempool_get(ct->entry_pool, NULL);
    if (!new_entry) return -1;  // 表满

    *new_entry = *entry;
    new_entry->create_ts = rte_rdtsc();
    new_entry->last_ts = new_entry->create_ts;

    // 双向插入
    int ret;
    ret = rte_hash_add_key_data(ct->hash, &new_entry->orig, new_entry);
    if (ret != 0) {
        rte_mempool_put(ct->entry_pool, new_entry);
        return -1;
    }
    ret = rte_hash_add_key_data(ct->hash, &new_entry->reply, new_entry);
    if (ret != 0) {
        rte_hash_del_key(ct->hash, &new_entry->orig);
        rte_mempool_put(ct->entry_pool, new_entry);
        return -1;
    }

    return 0;
}

struct ct_entry *conntrack_lookup(struct conntrack *ct, struct ct_key *key) {
    struct ct_entry **entry;
    int ret = rte_hash_lookup_data(ct->hash, key, (void **)&entry);
    if (ret >= 0) return *entry;
    return NULL;
}

int conntrack_delete(struct conntrack *ct, struct ct_key *key) {
    struct ct_entry *entry;
    int ret = rte_hash_lookup_data(ct->hash, key, (void **)&entry);
    if (ret < 0) return -1;

    // 删除两条记录
    rte_hash_del_key(ct->hash, &entry->orig);
    rte_hash_del_key(ct->hash, &entry->reply);
    rte_mempool_put(ct->entry_pool, entry);
    return 0;
}

void conntrack_gc(struct conntrack *ct) {
    static uint64_t last_gc = 0;
    uint64_t now = rte_rdtsc();
    uint64_t hz = rte_get_timer_hz();

    // 每 10 秒清理一次
    if (now - last_gc < hz * 10) return;
    last_gc = now;

    uint64_t timeout_ticks = (uint64_t)ct->timeout_sec * hz;
    int collected = 0;

    // 遍历所有条目
    const void *next_key;
    void *next_data;
    uint32_t iter = 0;

    while (rte_hash_iterate(ct->hash, &next_key, &next_data, &iter) >= 0) {
        struct ct_entry *entry = (struct ct_entry *)next_data;

        // 检查静态标志
        if (entry->flags & CT_FLAG_STATIC) continue;

        // 检查超时
        if (now - entry->last_ts > timeout_ticks) {
            // 标记为过期（避免在迭代中删除导致问题）
            entry->flags |= 0x80;  // CT_FLAG_EXPIRED
            collected++;
        }
    }

    // 第二轮：删除标记过期的
    iter = 0;
    while (rte_hash_iterate(ct->hash, &next_key, &next_data, &iter) >= 0) {
        struct ct_entry *entry = (struct ct_entry *)next_data;
        if (entry->flags & 0x80) {
            rte_hash_del_key(ct->hash, &entry->orig);
            rte_hash_del_key(ct->hash, &entry->reply);
            rte_mempool_put(ct->entry_pool, entry);
        }
    }

    printf("[CT] GC: collected %d entries\n", collected);
}

2.5 LRU 优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 使用 LRU 哈希表避免显式 GC
struct conntrack *conntrack_create_lru(uint32_t max_entries, uint32_t timeout_sec) {
    struct conntrack *ct = rte_zmalloc(NULL, sizeof(*ct), 0);

    // 用 LRU hash（自动淘汰最久未访问的）
    struct rte_hash_parameters hp = {
        .name = "CONNTRACK_LRU",
        .entries = max_entries * 2,
        .key_len = sizeof(struct ct_key),
        .hash_func = rte_jhash,
        .socket_id = SOCKET_ID_ANY,
    };
    // 注：DPDK 没有原生 LRU hash，需要用 LRU 实现
    // 这里简化用普通 hash + 显式 GC

    return ct;
}

2.6 哈希冲突与锁竞争

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
conntrack 表性能瓶颈：

1. 哈希冲突
   - 使用 CRC32 或 xxHash（避免冲突）
   - 桶数 = 期望条目数 × 2

2. 锁竞争
   - DPDK rte_hash 无锁（rcu）
   - Linux nf_conntrack 需 spinlock（BIG LOCK）

3. 缓存缺失
   - 条目大小太大 → cache miss
   - 优化：分离热字段（state, last_ts）和冷字段（orig）

4. 老化延迟
   - 周期性 GC 慢
   - 优化：使用 epoch-based reclamation

2.7 Per-CPU 分片优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// conntrack 性能优化：per-CPU 切片

#define NUM_SHARDS 8  // 至少 = lcore 数

struct conntrack_shard {
    pthread_spinlock_t lock;
    struct rte_hash    *hash;
    struct rte_mempool *pool;
};

struct conntrack {
    struct conntrack_shard shards[NUM_SHARDS];
};

// 根据 src_ip 选 shard
static inline int get_shard(uint32_t src_ip) {
    return (src_ip >> 24) ^ (src_ip >> 16) ^
           (src_ip >> 8) ^ src_ip;
}

// 大部分操作无需跨 shard

3. NAT 实现细节

3.1 Full-NAT 完整流程

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
// nat.c — 完整 NAT 实现

struct nat_ctx {
    struct conntrack *ct;
    uint32_t          ext_ip;       // 外部 IP（LB 的 IP）
    uint16_t          ext_port_start;  // 端口分配起点
    uint16_t          ext_port_end;    // 端口分配终点
    uint16_t          next_port;       // 下一个可用端口（round-robin）
    pthread_spinlock_t port_lock;
};

// 分配外部端口
static uint16_t alloc_ext_port(struct nat_ctx *nat) {
    pthread_spin_lock(&nat->port_lock);

    uint16_t p = nat->next_port;
    do {
        p++;
        if (p >= nat->ext_port_end) p = nat->ext_port_start;
    } while (port_in_use(p));

    nat->next_port = p;
    pthread_spin_unlock(&nat->port_lock);
    return p;
}

// Client → Backend（SNAT + DNAT）
int nat_snat_dnat(struct nat_ctx *nat,
                   struct rte_mbuf *m,
                   struct ct_entry **out_sess) {
    struct rte_ether_hdr *eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
    struct rte_ipv4_hdr *ip = (void *)(eth + 1);
    struct rte_tcp_hdr *tcp = (void *)ip + (ip->ihl * 4);

    // 1. 检查 conntrack
    struct ct_key key = {
        .src_ip   = ip->saddr,
        .dst_ip   = ip->daddr,
        .src_port = tcp->source,
        .dst_port = tcp->dest,
        .protocol = ip->protocol,
    };
    struct ct_entry *sess = conntrack_lookup(nat->ct, &key);

    if (!sess) {
        // 新连接
        if (tcp->tcp_flags & RTE_TCP_SYN_FLAG) {
            sess = rte_mempool_get(nat->ct->entry_pool, NULL);
            sess->orig   = key;
            sess->ext_ip = nat->ext_ip;
            sess->ext_port = alloc_ext_port(nat);

            // reply tuple（计算）
            sess->reply.src_ip   = ip->daddr;
            sess->reply.dst_ip   = nat->ext_ip;  // 替换为 LB 的 IP
            sess->reply.src_port = tcp->dest;
            sess->reply.dst_port = htons(sess->ext_port);
            sess->reply.protocol = ip->protocol;

            sess->state = CT_TCP_SYN_RCVD;
            sess->create_ts = rte_rdtsc();

            conntrack_add(nat->ct, sess);
        } else {
            return -1;  // 未知包，丢弃
        }
    }

    sess->last_ts = rte_rdtsc();
    sess->packets++;
    sess->bytes += rte_pktmbuf_pkt_len(m);

    // 2. 更新 TCP 状态
    update_tcp_state(sess, tcp->tcp_flags);

    // 3. NAT 转换
    // SNAT: src IP 改为 LB 的 IP
    ip->saddr   = nat->ext_ip;
    tcp->source = htons(sess->ext_port);

    // 4. 重新计算校验和
    tcp->cksum = 0;
    tcp->cksum = rte_ipv4_udptcp_cksum(ip, tcp);
    ip->hdr_checksum = 0;
    ip->hdr_checksum = rte_ipv4_cksum(ip);

    *out_sess = sess;
    return 0;
}

3.2 NAT 模式选择策略

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
NAT 模式选择：

1. SNAT 模式
   - 简单：只改 src
   - 节省 conntrack 资源
   - 后端看到 LB 的 IP
   - 应用层需感知 SNAT

2. DNAT 模式
   - 反向代理
   - 后端看到 client IP
   - 应用层看到真实客户端

3. Full-NAT
   - 改 src + dst
   - 双层 conntrack
   - 灵活性最高
   - 性能略低
   - 用于阿里云 SLB 等

4. IP 直接转发（DSR）
   - 不改 src IP
   - 后端看到 client
   - 性能最好
   - 但限制：必须网关回包

4. 锁竞争优化

4.1 锁类型选择

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
DPDK 同步原语：

1. rte_spinlock_t
   - 自旋锁（忙等）
   - 适用：短临界区
   - 注意：不能在单核环境使用

2. rte_rwlock_t
   - 读写锁
   - 适用：读多写少

3. rte_atomic
   - 原子操作
   - 适用：单变量

4. RCU
   - 读-复制-更新
   - 适用：极少写

5. Lock-free hash（rte_hash）
   - DPDK 自带
   - 性能最好

4.2 锁竞争实测

1
2
3
4
5
6
7
8
9
# 使用 perf 观察锁竞争
perf stat -e cs,migrations,context-switches -p $(pidof lb_process) -- sleep 5

# 锁热点分析
perf lock contention -a -p $(pidof lb_process) -- sleep 5

# 调用栈热点
perf record -g -p $(pidof lb_process) -- sleep 5
perf report --sort=comm,symbol

4.3 无锁 conntrack 优化

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
// 用 epoch-based reclamation 减少锁
// DPDK 使用 rte_hash 已经无锁
// 只需优化条目池的分配/释放

// 实现一个简单的 epoch 回收器
#define EPOCH_SIZE 1024

struct epoch_ctx {
    struct rte_ring *reclaim[EPOCH_SIZE];
    uint16_t current;
};

// 在 N 个 epoch 后才真正释放
void epoch_reclaim(struct epoch_ctx *ctx, void *obj) {
    uint16_t next = (ctx->current + 1) % EPOCH_SIZE;
    rte_ring_enqueue(ctx->reclaim[next], obj);

    // 真正释放旧的 epoch
    void *old;
    while (rte_ring_dequeue(ctx->reclaim[ctx->current], &old) == 0) {
        rte_mempool_put(pool, old);
    }

    ctx->current = next;
}

5. conntrack 与 LB 集成

5.1 完整 LB 流程（含 conntrack）

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
// lb_with_ct.c
void lb_main_loop() {
    while (1) {
        // 收包
        nb_rx = rte_eth_rx_burst(port, 0, pkts, BURST);
        if (nb_rx == 0) continue;

        for (int i = 0; i < nb_rx; i++) {
            struct rte_mbuf *m = pkts[i];
            struct ct_entry *sess = NULL;

            if (is_client_packet(m)) {
                if (nat_snat_dnat(&nat_ctx, m, &sess) == 0) {
                    // 转发到 backend
                    forward_to_backend(m, sess);
                } else {
                    rte_pktmbuf_free(m);
                }
            } else {
                if (nat_unsnat(m, &sess) == 0) {
                    // 转发回 client
                    forward_to_client(m, sess);
                } else {
                    rte_pktmbuf_free(m);
                }
            }
        }

        // 定期清理 conntrack
        conntrack_gc(&nat_ctx.ct);
    }
}

5.2 性能测试

1
2
3
4
5
6
7
性能指标（10GbE）：
  - 收包：14M pps
  - NAT 转换：每包 ~ 200ns
  - conntrack lookup：~ 50ns
  - 校验和计算：~ 100ns
  - 总体：~ 500ns/packet
  - 单核吞吐：~ 2M pps（无 conntrack 可达 14M）

6. 主流 NAT 网关

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Linux iptables/nftables：
  - 内核态
  - 性能受限（1-3 Mpps）
  - 简单配置

Linux conntrack + NAT：
  - 内核态 conntrack 表
  - 性能受限
  - 功能完善

DPDK L4 LB：
  - 用户态
  - 14M+ pps
  - 需要自己实现 conntrack

Cilium（eBPF）：
  - 10M+ pps
  - eBPF 加速 conntrack
  - 业界领先

VPP（Vector Packet Processing）：
  - 10M+ pps
  - 图节点式处理
  - FD.io 项目

7. 实践：改进 DPDK L4 LB

1
2
3
4
5
6
7
8
// 在之前 phase3/week24 的 L4 LB 基础上，添加 conntrack 超时回收

// 修改 lb_main_loop：
//   1. 添加 conntrack_gc 调用
//   2. 使用 LRU 替代固定大小
//   3. 添加超时参数配置

// 关键代码片段（已包含在 conntrack.c 中）
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

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