第8周：阶段项目——简易 HTTP 负载均衡器

字数统计: 3.5k字   |   阅读时长≈ 19分

第8周：阶段项目——简易 HTTP 负载均衡器

目标：综合运用前 7 周知识，实现一个高性能 L7 HTTP 反向代理。

1. 项目架构设计

1.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
               ┌──────────────┐
               │   Client     │
               └──────┬───────┘
                      │ HTTP Request
                      ▼
         ┌────────────────────────┐
         │   Load Balancer       │
         │   (epoll + multi-thread)│
         │                        │
         │  ┌────┐  ┌────┐        │
         │  │ alg│  │ alg│        │ ← 调度算法
         │  └────┘  └────┘        │
         └────────┬───────────────┘
                  │
     ┌────────────┼────────────┐
     ▼            ▼            ▼
┌──────────┐ ┌──────────┐ ┌──────────┐
│ Backend 1│ │ Backend 2│ │ Backend 3│
│:80       │ │:80       │ │:80       │
└──────────┘ └──────────┘ └──────────┘

     ┌──────────────────────────────────┐
     │    Health Check Thread           │
     │    (定时探活，更新节点状态)        │
     └──────────────────────────────────┘

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
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
// backend.h
#ifndef BACKEND_H
#define BACKEND_H

#include <stdint.h>
#include <time.h>

#define MAX_BACKENDS   32
#define MAX_NAME_LEN   64
#define MAX_URL_LEN    256
#define MAX_RESP_BODY  4096

// 后端节点状态
typedef enum {
    BACKEND_UP,        // 健康
    BACKEND_DOWN,      // 不可用
    BACKEND_CHECKING   // 正在检查
} BackendState;

// 后端节点
typedef struct {
    char    name[MAX_NAME_LEN];    // 名称标识
    char    host[MAX_URL_LEN];     // IP 或域名
    uint16_t port;                 // 端口
    BackendState state;            // 当前状态
    int     conn_count;            // 当前连接数
    int     fail_count;            // 连续失败次数
    time_t  last_check;            // 上次健康检查时间
    time_t  last_fail;             // 上次失败时间
    int     weight;                // 权重（加权轮询）
} Backend;

// 调度算法
typedef enum {
    SCHED_ROUND_ROBIN,    // 轮询
    SCHED_LEAST_CONN,     // 最少连接
    SCHED_WEIGHTED_RR,    // 加权轮询
    SCHED_RANDOM          // 随机
} SchedulerType;

// 后端池
typedef struct {
    Backend  backends[MAX_BACKENDS];
    int      count;               // 总节点数
    int      active_count;        // 健康节点数
    int      current_rr;          // 轮询计数器
    SchedulerType scheduler;
} BackendPool;

// 初始化
void backend_pool_init(BackendPool *pool, SchedulerType sched);

// 添加/移除后端
int backend_add(BackendPool *pool, const char *name,
                const char *host, uint16_t port, int weight);
int backend_remove(BackendPool *pool, int index);

// 调度（选择下一个后端）
int backend_select(BackendPool *pool);

// 标记失败/恢复
void backend_mark_fail(BackendPool *pool, int index);
void backend_mark_success(BackendPool *pool, int index);

// 健康检查
int backend_health_check(Backend *be);

// 获取健康后端数量
int backend_active_count(const BackendPool *pool);

#endif

1.3 后端池实现

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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
// backend.c
#include "backend.h"
#include <string.h>
#include <time.h>
#include <stdio.h>

void backend_pool_init(BackendPool *pool, SchedulerType sched) {
    memset(pool, 0, sizeof(BackendPool));
    pool->scheduler = sched;
}

int backend_add(BackendPool *pool, const char *name,
                const char *host, uint16_t port, int weight) {
    if (pool->count >= MAX_BACKENDS) return -1;

    Backend *be = &pool->backends[pool->count];
    strncpy(be->name, name, MAX_NAME_LEN - 1);
    strncpy(be->host, host, MAX_URL_LEN - 1);
    be->port = port;
    be->state = BACKEND_UP;
    be->weight = weight > 0 ? weight : 1;
    be->fail_count = 0;

    pool->count++;
    return pool->count - 1;
}

int backend_select(BackendPool *pool) {
    int active[MAX_BACKENDS];
    int n = 0;

    // 收集健康节点
    for (int i = 0; i < pool->count; i++) {
        if (pool->backends[i].state == BACKEND_UP) {
            active[n++] = i;
        }
    }

    if (n == 0) return -1;  // 没有可用后端
    if (n == 1) return active[0];

    int selected;

    switch (pool->scheduler) {
        case SCHED_ROUND_ROBIN: {
            pool->current_rr = (pool->current_rr + 1) % n;
            selected = active[pool->current_rr];
            break;
        }

        case SCHED_LEAST_CONN: {
            int min_conn = pool->backends[active[0]].conn_count;
            selected = active[0];
            for (int i = 1; i < n; i++) {
                if (pool->backends[active[i]].conn_count < min_conn) {
                    min_conn = pool->backends[active[i]].conn_count;
                    selected = active[i];
                }
            }
            break;
        }

        case SCHED_WEIGHTED_RR: {
            // 加权轮询：weight 越大，分配概率越高
            int total_weight = 0;
            for (int i = 0; i < n; i++) {
                total_weight += pool->backends[active[i]].weight;
            }

            int target = pool->current_rr % total_weight;
            int cumulative = 0;
            selected = active[0];
            for (int i = 0; i < n; i++) {
                cumulative += pool->backends[active[i]].weight;
                if (target < cumulative) {
                    selected = active[i];
                    break;
                }
            }
            pool->current_rr++;
            break;
        }

        case SCHED_RANDOM: {
            // 简单的线性同余随机数
            pool->current_rr = (pool->current_rr * 1103515245 + 12345) & 0x7fffffff;
            selected = active[pool->current_rr % n];
            break;
        }
    }

    return selected;
}

void backend_mark_fail(BackendPool *pool, int index) {
    if (index < 0 || index >= pool->count) return;
    Backend *be = &pool->backends[index];
    be->fail_count++;
    be->last_fail = time(NULL);

    if (be->fail_count >= 3) {
        be->state = BACKEND_DOWN;
        printf("[LB] Backend %s (%s:%d) marked DOWN (fails=%d)\n",
               be->name, be->host, be->port, be->fail_count);
    }
}

void backend_mark_success(BackendPool *pool, int index) {
    if (index < 0 || index >= pool->count) return;
    Backend *be = &pool->backends[index];
    be->fail_count = 0;
    if (be->state == BACKEND_DOWN) {
        be->state = BACKEND_UP;
        printf("[LB] Backend %s (%s:%d) recovered\n",
               be->name, be->host, be->port);
    }
}

int backend_health_check(Backend *be) {
    // 用 TCP connect 检查端口可达性
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    if (fd < 0) return 0;

    set_nonblocking(fd);
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(be->port);
    inet_pton(AF_INET, be->host, &addr.sin_addr);

    int ret = connect(fd, (struct sockaddr *)&addr, sizeof(addr));
    if (ret < 0 && errno == EINPROGRESS) {
        struct pollfd pfd = {fd, POLLOUT, 0};
        ret = poll(&pfd, 1, 3000);  // 3 秒超时
        if (ret > 0) {
            int err;
            socklen_t len = sizeof(err);
            getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &len);
            ret = (err == 0) ? 0 : -1;
        } else {
            ret = -1;
        }
    }

    close(fd);
    return ret == 0;
}

2. HTTP 反向代理核心逻辑

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
29
30
31
32
33
34
35
36
// proxy.h
#ifndef PROXY_H
#define PROXY_H

#include <stdint.h>
#include "backend.h"

typedef struct {
    int client_fd;          // 客户端连接
    int backend_fd;         // 后端连接
    int backend_index;      // 选中的后端索引
    char client_buffer[8192];
    char backend_buffer[8192];
    size_t client_len;
    size_t backend_len;
    int headers_parsed;     // 是否已解析请求头
    int request_sent;       // 请求是否已发往后端
    int response_started;   // 响应是否已开始
    int chunked;            // 是否为 chunked 编码
    int content_length;     // Content-Length
    int body_sent;          // 已发送 body 字节数
} ProxyContext;

// 创建代理上下文
ProxyContext *proxy_create(int client_fd);

// 处理客户端数据
void proxy_on_client_data(ProxyContext *ctx, const char *data, size_t len);

// 处理后端数据
void proxy_on_backend_data(ProxyContext *ctx, const char *data, size_t len);

// 清理
void proxy_destroy(ProxyContext *ctx);

#endif

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
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
// proxy.c
#include "proxy.h"
#include "backend.h"
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/epoll.h>

extern BackendPool g_backend_pool;

ProxyContext *proxy_create(int client_fd) {
    ProxyContext *ctx = calloc(1, sizeof(ProxyContext));
    ctx->client_fd = client_fd;
    set_nonblocking(client_fd);
    return ctx;
}

// 连接到后端
static int connect_backend(ProxyContext *ctx) {
    BackendPool *pool = &g_backend_pool;
    int idx = backend_select(pool);
    if (idx < 0) {
        // 没有可用后端
        const char *resp =
            "HTTP/1.1 503 Service Unavailable\r\n"
            "Content-Length: 23\r\n"
            "\r\n"
            "Service Unavailable";
        write(ctx->client_fd, resp, strlen(resp));
        return -1;
    }

    Backend *be = &pool->backends[idx];
    ctx->backend_index = idx;
    be->conn_count++;

    // 建立到后端的连接
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    set_nonblocking(fd);

    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(be->port);
    inet_pton(AF_INET, be->host, &addr.sin_addr);

    int ret = connect(fd, (struct sockaddr *)&addr, sizeof(addr));
    if (ret < 0 && errno == EINPROGRESS) {
        // 连接中，后面通过 epoll 监听
        ctx->backend_fd = fd;
        return 0;
    }

    if (ret < 0) {
        backend_mark_fail(pool, idx);
        close(fd);
        be->conn_count--;
        return -1;
    }

    ctx->backend_fd = fd;
    return 0;
}

// 处理完整的 HTTP 请求
void proxy_on_client_data(ProxyContext *ctx, const char *data, size_t len) {
    // 确保数据在缓冲区
    if (ctx->client_len + len > sizeof(ctx->client_buffer)) {
        close(ctx->client_fd);
        return;
    }
    memcpy(ctx->client_buffer + ctx->client_len, data, len);
    ctx->client_len += len;

    // 检查是否有完整的请求头（\r\n\r\n）
    if (!ctx->headers_parsed) {
        const char *end = memmem(ctx->client_buffer, ctx->client_len,
                                 "\r\n\r\n", 4);
        if (!end) return;  // 还没收完请求头

        ctx->headers_parsed = 1;
        size_t header_len = (end + 4) - ctx->client_buffer;

        // 连接到后端
        if (connect_backend(ctx) < 0) {
            proxy_destroy(ctx);
            return;
        }

        // 发送请求头到后端
        // （注意：可能只发送了头部，body 后续处理）
        // 这里简化处理：先转发已有数据
        int epfd = *(int *)get_epfd_ptr();
        struct epoll_event ev = {
            .events = EPOLLIN | EPOLLOUT | EPOLLET,
            .data.ptr = ctx
        };
        epoll_ctl(epfd, EPOLL_CTL_ADD, ctx->backend_fd, &ev);
    }
}

void proxy_destroy(ProxyContext *ctx) {
    if (ctx->client_fd >= 0) close(ctx->client_fd);
    if (ctx->backend_fd >= 0) {
        // 减少后端连接计数
        if (ctx->backend_index >= 0 &&
            ctx->backend_index < g_backend_pool.count) {
            g_backend_pool.backends[ctx->backend_index].conn_count--;
        }
        close(ctx->backend_fd);
    }
    free(ctx);
}

3. 健康检查线程

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
// health_check.c
#include "backend.h"
#include <pthread.h>
#include <time.h>
#include <unistd.h>
#include <stdio.h>

#define CHECK_INTERVAL 5    // 每 5 秒检查一次
#define CHECK_TIMEOUT  3    // 单次检查超时 3 秒
#define MAX_FAIL       3    // 连续失败 3 次标记为 DOWN

BackendPool g_backend_pool;
pthread_t health_thread;
int health_running = 1;

void *health_check_loop(void *arg) {
    (void)arg;

    while (health_running) {
        sleep(CHECK_INTERVAL);

        for (int i = 0; i < g_backend_pool.count; i++) {
            Backend *be = &g_backend_pool.backends[i];
            time_t now = time(NULL);

            // 已标记为 DOWN 的节点，定期尝试恢复
            if (be->state == BACKEND_DOWN) {
                if (now - be->last_check < 10) continue;  // 10 秒后再试
            }

            int ok = backend_health_check(be);

            if (ok) {
                backend_mark_success(&g_backend_pool, i);
                be->last_check = now;
            } else {
                printf("[HC] Backend %s (%s:%d) check FAILED\n",
                       be->name, be->host, be->port);
                backend_mark_fail(&g_backend_pool, i);
                be->last_check = now;
            }
        }

        // 打印状态
        printf("[HC] Active: %d/%d backends\n",
               backend_active_count(&g_backend_pool),
               g_backend_pool.count);
    }

    return NULL;
}

void start_health_check() {
    pthread_create(&health_thread, NULL, health_check_loop, NULL);
}

void stop_health_check() {
    health_running = 0;
    pthread_join(health_thread, NULL);
}

4. 完整负载均衡器

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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
// lb_server.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <pthread.h>

#include "backend.h"
#include "proxy.h"
#include "reactor.h"

#define LB_PORT         8080
#define LB_WORKERS      4
#define MAX_EVENTS      4096

BackendPool g_backend_pool;

// 初始化后端
void init_backends() {
    backend_pool_init(&g_backend_pool, SCHED_LEAST_CONN);

    backend_add(&g_backend_pool, "web-1", "127.0.0.1", 9001, 5);
    backend_add(&g_backend_pool, "web-2", "127.0.0.1", 9002, 3);
    backend_add(&g_backend_pool, "web-3", "127.0.0.1", 9003, 2);
    backend_add(&g_backend_pool, "web-4", "127.0.0.1", 9004, 1);
}

// 信号处理
volatile sig_atomic_t g_running = 1;

void signal_handler(int sig) {
    (void)sig;
    g_running = 0;
}

// 打印使用说明
void print_usage(const char *prog) {
    printf("Usage: %s [options]\n", prog);
    printf("Options:\n");
    printf("  -p <port>      Listen port (default: %d)\n", LB_PORT);
    printf("  -w <workers>   Worker threads (default: %d)\n", LB_WORKERS);
    printf("  -a <alg>       Algorithm: rr, lc, wrr, rand (default: lc)\n");
    printf("  -h             Show this help\n");
    printf("\nAlgorithms:\n");
    printf("  rr    - Round Robin\n");
    printf("  lc    - Least Connections\n");
    printf("  wrr   - Weighted Round Robin\n");
    printf("  rand  - Random\n");
}

int main(int argc, char *argv[]) {
    int port = LB_PORT;
    int workers = LB_WORKERS;
    SchedulerType sched = SCHED_LEAST_CONN;

    // 解析参数
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-p") == 0 && i + 1 < argc) {
            port = atoi(argv[++i]);
        } else if (strcmp(argv[i], "-w") == 0 && i + 1 < argc) {
            workers = atoi(argv[++i]);
        } else if (strcmp(argv[i], "-a") == 0 && i + 1 < argc) {
            i++;
            if (strcmp(argv[i], "rr") == 0) sched = SCHED_ROUND_ROBIN;
            else if (strcmp(argv[i], "lc") == 0) sched = SCHED_LEAST_CONN;
            else if (strcmp(argv[i], "wrr") == 0) sched = SCHED_WEIGHTED_RR;
            else if (strcmp(argv[i], "rand") == 0) sched = SCHED_RANDOM;
        } else if (strcmp(argv[i], "-h") == 0) {
            print_usage(argv[0]);
            return 0;
        }
    }

    // 初始化
    init_backends();
    g_backend_pool.scheduler = sched;

    signal(SIGINT, signal_handler);
    signal(SIGTERM, signal_handler);
    signal(SIGPIPE, SIG_IGN);

    printf("========================================\n");
    printf("  HTTP Load Balancer\n");
    printf("  Port:      %d\n", port);
    printf("  Workers:   %d\n", workers);
    printf("  Algorithm: %s\n",
           sched == SCHED_ROUND_ROBIN ? "Round Robin" :
           sched == SCHED_LEAST_CONN ? "Least Connections" :
           sched == SCHED_WEIGHTED_RR ? "Weighted RR" : "Random");
    printf("  Backends:  %d\n", g_backend_pool.count);
    printf("========================================\n");

    // 打印后端列表
    for (int i = 0; i < g_backend_pool.count; i++) {
        Backend *be = &g_backend_pool.backends[i];
        printf("  [%d] %s (%s:%d) weight=%d\n",
               i, be->name, be->host, be->port, be->weight);
    }
    printf("========================================\n\n");

    // 启动健康检查线程
    start_health_check();

    // 创建监听 socket
    int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    int opt = 1;
    setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    setsockopt(listen_fd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));

    struct sockaddr_in addr = {
        .sin_family = AF_INET,
        .sin_port   = htons(port),
        .sin_addr.s_addr = INADDR_ANY
    };
    bind(listen_fd, (struct sockaddr *)&addr, sizeof(addr));
    listen(listen_fd, 4096);

    // 多进程 worker（SO_REUSEPORT 负载均衡）
    printf("Starting %d workers...\n", workers);

    for (int i = 0; i < workers; i++) {
        pid_t pid = fork();
        if (pid == 0) {
            // Worker 进程
            printf("[Worker %d] PID=%d started\n", i, getpid());

            Reactor *r = reactor_create(port);
            // 这里应该在 reactor 中集成 proxy 逻辑
            // 简化版本用 epoll 直接处理

            // ... 主事件循环（代理逻辑）...
            reactor_run(r);
            reactor_destroy(r);
            return 0;
        }
    }

    // 父进程等待
    for (int i = 0; i < workers; i++) {
        wait(NULL);
    }

    stop_health_check();
    close(listen_fd);
    printf("\nLoad balancer stopped.\n");
    return 0;
}

5. 后端测试服务

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
// test_backend.c — 简单的后端测试服务
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>

volatile sig_atomic_t g_running = 1;

void handler(int sig) { (void)sig; g_running = 0; }

int main(int argc, char *argv[]) {
    int port = argc > 1 ? atoi(argv[1]) : 9001;
    char *name = argc > 2 ? argv[2] : "backend";

    signal(SIGINT, handler);
    signal(SIGTERM, handler);

    int fd = socket(AF_INET, SOCK_STREAM, 0);
    int opt = 1;
    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    struct sockaddr_in addr = {
        .sin_family = AF_INET,
        .sin_port   = htons(port),
        .sin_addr.s_addr = INADDR_ANY
    };
    bind(fd, (struct sockaddr *)&addr, sizeof(addr));
    listen(fd, 128);

    printf("[%s] Running on port %d (PID=%d)\n", name, port, getpid());

    while (g_running) {
        int conn = accept(fd, NULL, NULL);
        if (conn < 0) continue;

        char buf[4096];
        ssize_t n = read(conn, buf, sizeof(buf) - 1);
        if (n > 0) {
            buf[n] = '\0';

            // 简单的 HTTP 响应
            char body[256];
            snprintf(body, sizeof(body),
                     "<html><body><h1>%s:%d</h1>"
                     "<p>Served by backend %s</p>"
                     "<p>PID: %d</p>"
                     "</body></html>",
                     name, port, name, getpid());

            char resp[512];
            snprintf(resp, sizeof(resp),
                     "HTTP/1.1 200 OK\r\n"
                     "Content-Type: text/html\r\n"
                     "Content-Length: %zu\r\n"
                     "\r\n%s",
                     strlen(body), body);

            write(conn, resp, strlen(resp));
        }
        close(conn);
    }

    close(fd);
    return 0;
}
1
2
3
4
5
gcc -o backend test_backend.c
./backend 9001 web-1 &
./backend 9002 web-2 &
./backend 9003 web-3 &
./backend 9004 web-4 &

6. 压测与验证

6.1 编译和运行

1
2
3
4
5
# 编译
gcc -o lb_server lb_server.c backend.c proxy.c -lpthread

# 启动（先启动后端，再启动负载均衡器）
./lb_server -p 8080 -w 4 -a lc

6.2 压测

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 基本压测
ab -n 10000 -c 500 http://localhost:8080/

# 长连接压测
ab -n 10000 -c 500 -k http://localhost:8080/

# wrk 压测
wrk -t4 -c1000 -d60s http://localhost:8080/

# curl 验证负载均衡
for i in $(seq 1 10); do
    curl -s http://localhost:8080/ | grep "web-"
done
# 应该看到 web-1, web-2, web-3, web-4 交替出现

6.3 压测报告模板

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
=== 负载均衡器压测报告 ===

测试环境：
  机器配置：  X
  OS：        Linux X.X
  后端数量：  4
  调度算法：  Least Connections

测试结果：
  工具：      wrk
  线程：      4
  并发连接：  1000
  持续时间：  60s

性能指标：
  总请求数：  XXXXX
  完成请求：  XXXXX
  错误请求：  X (X.XX%)
  QPS：       XXXXX
  平均延迟：  XX ms
  最大延迟：  XXX ms
  P50 延迟：  XX ms
  P90 延迟：  XX ms
  P99 延迟：  XX ms

吞吐量：
  接收：      XX MB/s
  发送：      XX KB/s

各后端处理量（验证负载均衡）：
  web-1: XXXX (XX%)
  web-2: XXXX (XX%)
  web-3: XXXX (XX%)
  web-4: XXXX (XX%)

故障模拟：
  杀掉 web-2 → 流量自动转移到其他节点
  恢复 web-2 → 流量恢复正常分配

结论：
  [评估性能等级和可能的优化方向]

7. 优化方向

优化项 预期效果
使用 sendfile 转发静态资源 减少 CPU 使用，提升吞吐
连接池（到后端的持久连接） 减少连接建立开销
内存池替代 malloc/free 减少内存分配开销
缓存热点响应 减轻后端压力
SSL/TLS 卸载（OpenSSL/mbedTLS） 减少加密开销
批量发送（writev） 减少系统调用次数
协议解析优化（SIMD/查表） 提升小包处理能力

8. 扩展功能（可选）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
✓ HTTPS 支持（OpenSSL/BoringSSL）
✓ gRPC 代理（HTTP/2）
✓ 负载均衡算法扩展：
    - IP Hash（源地址哈希）
    - URL Hash（URL 哈希）
    - 响应时间加权
✓ 会话保持（Session Affinity）
✓ 访问日志（Access Log）
✓ 速率限制（Rate Limiting）
✓ 熔断器（Circuit Breaker）
✓ 配置热加载（reload 不中断服务）
✓ WebSocket 支持
✓ HTTP/2 支持
✓ gRPC/Protobuf 支持
✓ 集群发现（Consul/etcd）
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

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