【架构模式】边车模式

边车模式（Sidecar Pattern）是一种微服务架构设计模式，通过将辅助功能（如日志、监控、网络通信等）从主业务逻辑中分离出来，以独立进程（边车）的形式部署在主应用旁，共同组成一个服务单元。

---

核心概念

1. 解耦：主应用专注业务逻辑，边车处理横切关注点
2. 同生命周期：边车与主应用同时启动/停止
3. 本地通信：通常通过localhost、共享内存或Unix域套接字通信
4. 独立部署：边车可独立升级而不影响主应用

---

典型应用场景

• 日志收集
• 服务监控
• 配置管理
• 网络代理（TLS/重试/熔断）
• 身份认证

---

C++ 实现示例：日志收集系统

以下示例展示主应用与边车通过UDP通信实现日志分离：

1. 项目结构

sidecar_demo/
├── main_app/
│   ├── CMakeLists.txt
│   └── main.cpp      # 主业务逻辑
└── sidecar/
    ├── CMakeLists.txt
    └── sidecar.cpp   # 日志处理边车

2. 主应用代码 (main_app/main.cpp)

#include 
#include 
#include 
#include 
#include 

// 发送日志到边车
void send_log(const std::string& message) {
    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    sockaddr_in sidecar_addr{};
    sidecar_addr.sin_family = AF_INET;
    sidecar_addr.sin_port = htons(8081);  // 边车监听端口
    inet_pton(AF_INET, "127.0.0.1", &sidecar_addr.sin_addr);

    sendto(sock, message.c_str(), message.size(), 0,
          (sockaddr*)&sidecar_addr, sizeof(sidecar_addr));
    close(sock);
}

int main() {
    // 业务逻辑
    for (int i = 0; i < 5; ++i) {
        std::cout << "Processing task " << i << std::endl;
        
        // 发送日志到边车（非阻塞）
        send_log("Task " + std::to_string(i) + " completed");
        sleep(1);
    }
    send_log("Main app shutdown");
    return 0;
}

3. 边车代码 (sidecar/sidecar.cpp)

#include 
#include 
#include 
#include 
#include 

int main() {
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    sockaddr_in servaddr{};
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = INADDR_ANY;
    servaddr.sin_port = htons(8081);  // 监听端口

    bind(sockfd, (sockaddr*)&servaddr, sizeof(servaddr));
    std::cout << "Sidecar listening on port 8081..." << std::endl;

    char buffer[1024];
    while (true) {
        sockaddr_in client_addr;
        socklen_t len = sizeof(client_addr);
        
        ssize_t n = recvfrom(sockfd, buffer, sizeof(buffer), 0,
                            (sockaddr*)&client_addr, &len);
        buffer[n] = '\0';
        
        // 日志处理（此处打印+模拟存储）
        std::cout << "[LOG] " << buffer << std::endl;
        // 实际可写入文件/发送到日志服务器
    }
    close(sockfd);
    return 0;
}

4. CMake配置 (main_app/CMakeLists.txt)

cmake_minimum_required(VERSION 3.10)
project(MainApp)
add_executable(main_app main.cpp)

5. 编译运行

# 编译主应用
cd main_app && mkdir build && cd build
cmake .. && make

# 编译边车
cd ../../sidecar && mkdir build && cd build
cmake .. && make

# 开两个终端分别运行
./main_app   # 主应用终端
./sidecar    # 边车终端

---

运行结果

主应用输出：

Processing task 0
Processing task 1
Processing task 2
Processing task 3
Processing task 4

边车输出：

Sidecar listening on port 8081...
[LOG] Task 0 completed
[LOG] Task 1 completed
[LOG] Task 2 completed
[LOG] Task 3 completed
[LOG] Task 4 completed
[LOG] Main app shutdown

---

关键优势

优势	说明
关注点分离	业务代码不混杂日志/监控等代码
语言无关	边车可用不同语言实现（如Go/Python）
复用性	同一边车可服务多个应用
独立扩展	边车可单独进行资源分配

---

生产级优化建议

1. 通信协议：改用gRPC或共享内存提升性能
2. 错误处理：添加重试机制和死信队列
3. 资源隔离：通过cgroups限制边车资源
4. 部署方式：使用Docker/Kubernetes部署（主容器+边车容器）
5. 安全加固：通信加密（如mTLS）

# Dockerfile示例（Kubernetes Pod中双容器）
FROM alpine:latest AS main_app
COPY ./main_app/build/main_app /app/
CMD ["/app/main_app"]

FROM alpine:latest AS sidecar
COPY ./sidecar/build/sidecar /app/
CMD ["/app/sidecar"]

---

与其他模式对比

模式	区别
Ambassador	代理外部请求（边车侧重内部增强）
Adapter	标准化输出格式（边车更通用）