负载均衡 四层 vs 七层

                      ┌──────────┐
   用户 ──────────▶   │    LB    │
                      └────┬─────┘
              ┌────────────┼────────────┐
              ▼            ▼            ▼
         ┌────────┐  ┌────────┐  ┌────────┐
         │ 服务器1 │  │ 服务器2 │  │ 服务器3 │
         └────────┘  └────────┘  └────────┘

       收到的数据帧
 ┌──────┬──────┬──────┬──────────────┐
 │ 帧头  │ IP头 │TCP头 │  HTTP 报文    │
 └──────┴──┬───┴──┬───┴──────┬───────┘
            │      │          │
       【四层 LB】拆到这     【七层 LB】一直拆到这
       只看 IP + 端口       能看到 URL、Header、Cookie、Body

客户端 ──▶ LB(改目标IP为后端) ──▶ 后端
客户端 ◀── LB(改源IP为VIP)   ◀── 后端

客户端 ──▶ LB(只改目标MAC地址) ──▶ 后端
客户端 ◀──────────────────────── 后端(直接回!)

        请求路径              响应路径
  客户端 ──▶ LB ──▶ 后端      后端 ──────────▶ 客户端
                              (绕开 LB,直接走)

# 按路径分发到不同的后端服务(微服务网关的基本能力)
location /api/quote/ { proxy_pass http://quote_service; }
location /api/swap/  { proxy_pass http://swap_service; }
location /static/    { proxy_pass http://cdn_origin; }

# 按 Header 分发 —— 灰度发布的实现方式
if ($http_x_canary = "true") { proxy_pass http://canary_backend; }

用户 ──[HTTPS]──▶ LB ──[HTTP]──▶ 后端服务
                   ↑
            证书只装在这一处

后端A 收到一个要跑 10 秒的大查询
后端B 收到的都是 10ms 的小查询

轮询:   照样一人一个轮着发 → A 越积越多,B 闲着
最少连接:A 手上一直有活(连接数高)→ 新请求自动都给 B ✅

3 台机器: hash("abc") % 3 = 1  → 机器1
加到 4 台: hash("abc") % 4 = 3  → 机器3   ← 变了!

结果:【几乎全部缓存失效】,所有请求瞬间穿透到数据库 → 雪崩

0                                                        2³²-1
├──k1────A────k2────k3────B────k4────C────k5─────────────┤
   │     ▲    │     │     ▲    │     ▲    │
   └─────┘    └─────┴─────┘    └─────┘    └─▶ 走到头,绕回 0 继续往右 → A

k1 → A      k2、k3 → B      k4 → C      k5 → A(绕回)

0                                                        2³²-1
├──k1────A────k2──D──k3────B────k4────C────k5─────────────┤
                  ▲
          D 截走了"A 到 D"这一段

k1 → A      k2 → D(原来是 B,需要迁移)      k3 → B      k4 → C      k5 → A

# 后端要提供一个专门的健康检查端点
location /healthz {
    access_log off;              # 别把探测日志刷满
    return 200 "ok";
}

upstream backend {
    server 10.0.0.1:8080 max_fails=3 fail_timeout=30s;
    # 30 秒内失败 3 次 → 摘除 30 秒后再试
}

// ❌ 太浅:进程活着就返回 200,但数据库连不上照样收流量
func healthz(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("ok"))
}

// ❌ 太深:依赖任何一个下游抖动,整个集群一起被摘除 → 雪崩
func healthz(w http.ResponseWriter, r *http.Request) {
    checkDB(); checkRedis(); checkAllRPCNodes(); checkKafka()
    // 某个 RPC 节点抖了一下 → 所有实例同时不健康 → 全部被摘 → 服务完全不可用
}

// ✅ 分开两个端点(Kubernetes 的 liveness/readiness 就是这个思路)
func liveness(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("ok"))  // 进程活着就行 → 决定"要不要重启我"
}
func readiness(w http.ResponseWriter, r *http.Request) {
    if !db.Ping() {         // 只检查【自己必需】的强依赖
        http.Error(w, "not ready", 503)
        return
    }
    w.Write([]byte("ok"))   // → 决定"要不要给我发流量"
}

                        用户
                          │
              ┌───────────▼───────────┐
              │  DNS                  │  最粗:选机房/地区
              └───────────┬───────────┘
              ┌───────────▼───────────┐
              │  CDN                  │  静态资源就近、TLS 卸载、抗 DDoS
              └───────────┬───────────┘
              ┌───────────▼───────────┐
              │  四层  LB(LVS/NLB)     │  扛海量连接,分给七层集群
              └───────────┬───────────┘
              ┌───────────▼───────────┐
              │  七层 LB(Nginx/Envoy)  │  按路径路由、限流、灰度
              └───────────┬───────────┘
              ┌───────────▼───────────┐
              │  应用服务集群           │
              └───────────────────────┘

import "net/http/httputil"

type Balancer struct {
    backends []*url.URL
    counter  uint64
}

func (b *Balancer) next() *url.URL {
    // 原子自增实现轮询
    after := atomic.AddUint64(&b.counter, 1)
    return b.backends[after%uint64(len(b.backends))]
}

func (b *Balancer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    target := b.next()
    proxy := httputil.NewSingleHostReverseProxy(target)

    // 关键:透传真实客户端 IP
    proxy.Director = func(req *http.Request) {
        req.URL.Scheme = target.Scheme
        req.URL.Host = target.Host
        if host, _, err := net.SplitHostPort(r.RemoteAddr); err == nil {
            req.Header.Set("X-Real-IP", host)
        }
    }
    // 后端挂了的兜底
    proxy.ErrorHandler = func(w http.ResponseWriter, r *http.Request, err error) {
        log.Printf("backend %s error: %v", target, err)
        http.Error(w, "bad gateway", http.StatusBadGateway) // 502
    }
    proxy.ServeHTTP(w, r)
}

func realIP(r *http.Request) string {
    if xrip := r.Header.Get("X-Real-IP"); xrip != "" {
        return xrip
    }
    if xff := r.Header.Get("X-Forwarded-For"); xff != "" {
        return strings.TrimSpace(strings.Split(xff, ",")[0])
    }
    host, _, _ := net.SplitHostPort(r.RemoteAddr)
    return host
}

// 收到退出信号后,先从 LB 摘掉自己,再等存量请求处理完
stop := make(chan os.Signal, 1)
signal.Notify(stop, syscall.SIGTERM, syscall.SIGINT)
<-stop

// ① 让健康检查开始返回 503,LB 在下次探测时把我摘掉
atomic.StoreInt32(&shuttingDown, 1)
// ② 等 LB 真的摘掉我(至少一个探测周期)—— 这一步最容易被漏掉!
time.Sleep(5 * time.Second)
// ③ 停止接收新请求,等存量请求处理完
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
srv.Shutdown(ctx)

type NodePool struct {
    nodes []*Node
}

func (p *NodePool) Pick() *Node {
    // 只从健康的节点里选,配合熔断([Go工程/08])
    healthy := p.healthyNodes()
    if len(healthy) == 0 {
        return nil
    }
    // 最少连接:比轮询更适合耗时差异大的场景
    sort.Slice(healthy, func(i, j int) bool {
        return healthy[i].InFlight() < healthy[j].InFlight()
    })
    return healthy[0]
}