小Cの已经记不起来的博客

从零实现一个简易的灰度发布

最近给一个内部服务做灰度发布,本来想直接上 Nginx 的 split_clients,结果发现这玩意儿按 cookie 做一致性分流还得配合 map 和 Lua,配置越写越长。又看了一圈开源的网关,功能倒是全,但为了一个 10% 的灰度把整套东西搬进来,实在有点重。可能是我没找到更轻的写法吧。最后干脆用 Go 标准库写了一个几十行的反向代理,够用,改配置也不用重启。

下面就是实测能跑起来的那一版。

先明确一下规则

我需要的功能很简单:

  1. 请求头 X-Gray-User 或者 cookie gray_uid 里带用户标识的,按这个标识做 hash,落在 0-99 里小于 gray_percent 的走灰度,否则走主版本。同一个用户只要标识不变,结果就稳定。
  2. 白名单里的用户强制走灰度,方便自己先验。
  3. 没有用户标识的请求,就纯随机按比例走,适合那种无状态的接口。
  4. 配置文件改完 2 秒内生效,不重启进程。

后端也简单,主版本跑在 9001,灰度版本跑在 9002,网关监听 8080。就三个端口,别搞复杂了。

配置文件

先写一个 config.json,差不多长这样:

{
  "listen": ":8080",
  "gray_percent": 10,
  "gray_header": "X-Gray-User",
  "gray_cookie": "gray_uid",
  "whitelist": ["user-1001", "user-1002"],
  "primary": "http://127.0.0.1:9001",
  "gray": "http://127.0.0.1:9002"
}

gray_percent 就是灰度比例,10 表示 10%。白名单别写死在代码里,放配置里,回滚的时候把 gray_percent 改成 0 就行,不用重新发版。

核心代码

新建 main.go,直接抄下面这段:

package main

import (
	"encoding/json"
	"flag"
	"fmt"
	"hash/fnv"
	"log"
	"math/rand"
	"net/http"
	"net/http/httputil"
	"net/url"
	"os"
	"sync/atomic"
	"time"
)

type Config struct {
	Listen      string   `json:"listen"`
	GrayPercent int      `json:"gray_percent"`
	GrayHeader  string   `json:"gray_header"`
	GrayCookie  string   `json:"gray_cookie"`
	Whitelist   []string `json:"whitelist"`
	Primary     string   `json:"primary"`
	Gray        string   `json:"gray"`
}

var current atomic.Value

func loadConfig(path string) (Config, error) {
	var c Config
	data, err := os.ReadFile(path)
	if err != nil {
		return c, err
	}
	if err := json.Unmarshal(data, &c); err != nil {
		return c, err
	}
	if c.Listen == "" {
		return c, fmt.Errorf("listen is empty")
	}
	if c.Primary == "" || c.Gray == "" {
		return c, fmt.Errorf("primary/gray is empty")
	}
	if c.GrayPercent < 0 {
		c.GrayPercent = 0
	}
	if c.GrayPercent > 100 {
		c.GrayPercent = 100
	}
	return c, nil
}

func reloadLoop(path string) {
	for {
		time.Sleep(2 * time.Second)
		c, err := loadConfig(path)
		if err != nil {
			log.Printf("reload config failed: %v", err)
			continue
		}
		current.Store(c)
		log.Printf("config reloaded, gray_percent=%d", c.GrayPercent)
	}
}

func getConfig() Config {
	return current.Load().(Config)
}

func pickUpstream(c Config, r *http.Request) string {
	user := r.Header.Get(c.GrayHeader)

	if user == "" && c.GrayCookie != "" {
		if ck, err := r.Cookie(c.GrayCookie); err == nil {
			user = ck.Value
		}
	}

	if user == "" {
		if rand.Intn(100) < c.GrayPercent {
			return c.Gray
		}
		return c.Primary
	}

	for _, u := range c.Whitelist {
		if u == user {
			return c.Gray
		}
	}

	h := fnv.New32a()
	_, _ = h.Write([]byte(user))
	if int(h.Sum32()%100) < c.GrayPercent {
		return c.Gray
	}
	return c.Primary
}

func main() {
	configPath := flag.String("config", "config.json", "config file path")
	flag.Parse()

	c, err := loadConfig(*configPath)
	if err != nil {
		log.Fatal(err)
	}
	current.Store(c)
	go reloadLoop(*configPath)

	proxy := &httputil.ReverseProxy{
		Director: func(req *http.Request) {
			c := getConfig()
			target := pickUpstream(c, req)

			u, err := url.Parse(target)
			if err != nil {
				log.Printf("parse upstream failed: %v", err)
				return
			}

			req.URL.Scheme = u.Scheme
			req.URL.Host = u.Host
			req.Host = u.Host
			req.Header.Set("X-Gray-Upstream", target)
		},
		ErrorHandler: func(w http.ResponseWriter, r *http.Request, err error) {
			log.Printf("proxy error: %v", err)
			http.Error(w, "bad gateway", http.StatusBadGateway)
		},
	}

	http.Handle("/", proxy)
	log.Printf("gray gateway listening on %s", c.Listen)
	log.Fatal(http.ListenAndServe(c.Listen, nil))
}

这里没有服务发现,也没有动态 upstream,就是两个固定后端。X-Gray-Upstream 这个头主要是方便排查问题,至少在日志里能看出来这次请求去了哪边。reloadLoop 每 2 秒读一次配置,读失败就保留旧配置,不会因为手抖写坏 JSON 直接把网关搞挂。

跑起来看看

先起两个后端,随便返回点啥就行。我图省事,直接拿 Python 的 http.server:

mkdir -p v1 v2
echo "v1" > v1/index.html
echo "v2" > v2/index.html

(cd v1 && python3 -m http.server 9001) &
(cd v2 && python3 -m http.server 9002) &

然后跑网关:

go run main.go -config config.json

不出问题的话就没有问题了。另开一个终端测一下:

curl -s -H 'X-Gray-User: user-1001' http://127.0.0.1:8080/
# 白名单,应该返回 v2

curl -s -H 'X-Gray-User: user-2002' http://127.0.0.1:8080/
# 没命中灰度,应该返回 v1

想看比例的话,可以多打几个用户标识:

for i in $(seq 1 200); do
  curl -s -H "X-Gray-User: user-$i" http://127.0.0.1:8080/
  echo
done | sort | uniq -c

我这里跑出来大概是 180 个 v1、20 个 v2,白名单会多一个,差不多就行。要调比例就直接改 config.json 里的 gray_percent,等两秒再请求,不用重启网关。

一些容易踩的坑

没有用户标识的时候是纯随机,不是按连接粘的。登录态、购物车这类有状态请求别这么干,最好先从登录信息里拿用户 ID,或者先种一个 gray_uid cookie,不然同一个用户一会儿 v1 一会儿 v2,出了问题很难查。

hash 取模本身有一点点不均,但 10% 这种量级够用了。要更均匀可以换 CRC32 或者 murmur,别为了这点事上 MD5 全量,没必要。

回滚路径一定要简单。我的做法就是先把 gray_percent 改成 0,观察一会儿,再慢慢查灰度版本的问题。白名单也放配置里,别改代码重新编译,一急起来容易出错。

最后,这一套没有管理页面,也没有漂亮的监控,但把灰度发布最核心的按用户稳定分流和改配置不重启跑通了。后面如果流量大了,再考虑把配置放 Redis、加个简单的控制台,或者直接换 Envoy。先这样,够用就行。

评论

还没有评论。

发表评论

提交后评论将经过自动审核,审核通过后公开展示。

未在播放