初级工程师和高级工程师对待一个Restful API的态度已经截然不同
你费了很大劲写了一个漂亮的 REST API,文档写得像诗一样。上线那天还挺有成就感的。然后你打开日志看了一眼: - 有个客户端每秒在刷 `/api/products` 五百次,整页整页地刮你的商品数据 - 另一个客户的 retry 机制写炸了——没有退避、没有抖动,超时就无限循环重试,把你的数据库负载翻了一倍,凌晨三点准时报警 你的账单肉眼可见地上涨,其他正常客户的响应时间跟着遭殃,然后一个竞争对手花了一个周末用 for 循环把你的产品目录克隆了一遍。 **初级工程师觉得 API 只要“能跑”就行。资深工程师深知能跑只是第一步:API 是给外界的共享资源,需要明确的规则——谁能访问、频率多高、超了怎么办。** --- ## 第一招:API Key 在网关层校验,不要在业务层 如果有人忘了在某个新接口里加鉴权,检查被遗漏了,那这个接口就敞开了。没人发现,直到某天出现在滥用报告里。 初级做法:在每个接口里自己检查 Key: ```go func GetProducts(c *gin.Context) { key := c.GetHeader("X-API-Key") if !validateKey(key) { c.JSON(401, gin.H{"error": "invalid key"}) return } // 业务逻辑... } ``` 资深做法:在一个中间件里校验一次,所有请求进来先过这道坎: ```go func APIAuth() gin.HandlerFunc { return func(c *gin.Context) { key := c.GetHeader("X-API-Key") if key == "" || !isValidKey(key) { c.AbortWithStatusJSON(401, gin.H{"error": "missing or invalid API key"}) return } c.Set("clientID", getClientID(key)) c.Next() } } // 路由注册的时候加上 r.Use(APIAuth()) ``` 这样做的好处: - 新加的接口天然受保护,不用依赖谁记得加 - 无效 Key 永远不会进入业务逻辑 - `clientID` 只查一次,后面直接用 --- ## 第二招:限流要基于共享存储,不能靠内存 在本地用 `sync.Map` 或 `ConcurrentHashMap` 做计数,本地跑没问题。一上生产,负载均衡后面三个实例,同一个客户的请求分散到三台机器上,每台都独立计数。你设的“每分钟 100 次”实际上变成了“300 次”,你还查不出为什么。 初级做法: ```go var counters = sync.Map{} func allow(clientID string) bool { val, _ := counters.LoadOrStore(clientID, 0) count := val.(int) if count >= 100 { return false } counters.Store(clientID, count+1) return true } ``` 资深做法:用 Redis,所有实例共享同一个计数器: ```go func tryConsume(clientID string) bool { key := "ratelimit:" + clientID count := redis.Incr(ctx, key).Val() if count == 1 { redis.Expire(ctx, key, 60*time.Second) } return count <= 100 } ``` 为什么有效: - Redis 的 `INCR` 是原子的,同一个毫秒内两个请求不会同时超限 - 所有实例看到的是同一个计数 - 只在第一个请求时设置过期时间,不会一直往后推 --- ## 第三招:把剩余额度告诉客户端,别让人瞎猜 限流最糟糕的体验是:客户端发着发着忽然收到 429,完全不知道还剩多少、什么时候重置。 初级做法:只返回一个“Rate limit exceeded”: ```go c.JSON(429, gin.H{"error": "too many requests"}) ``` 资深做法:每次响应都带上三个头: ```go func checkRateLimit(clientID string) (allowed bool, limit, remaining int64, resetSeconds int64) { key := "ratelimit:" + clientID count := redis.Incr(ctx, key).Val() if count == 1 { redis.Expire(ctx, key, 60*time.Second) } ttl := redis.TTL(ctx, key).Val() limit := 100 remaining := limit - count if remaining < 0 { remaining = 0 } return count <= limit, limit, remaining, int64(ttl.Seconds()) } // 在响应头里带上 c.Header("X-RateLimit-Limit", "100") c.Header("X-RateLimit-Remaining", fmt.Sprintf("%d", remaining)) c.Header("X-RateLimit-Reset", fmt.Sprintf("%d", resetSeconds)) ``` GitHub、Stripe、Twitter 都在用这套。客户端能看到自己还剩多少,会提前慢下来,而不是直接撞墙。 --- ## 第四招:API Key 不要明文存 用了 `uuid.New().String()` 生成 Key,然后明文存在数据库里。如果哪天数据库被拖了,所有客户的 Key 全暴露了,直接用。 初级做法:存明文: ```go type APIKey struct { ID string Key string // 明文! } ``` 资深做法:存哈希,只在生成时给客户端看一次: ```go import "crypto/sha256" func generateAPIKey() (raw string, hashed string) { raw = "sk_live_" + uuid.New().String() h := sha256.Sum256([]byte(raw)) return raw, hex.EncodeToString(h[:]) } func isValidKey(raw string) bool { h := sha256.Sum256([]byte(raw)) hashed := hex.EncodeToString(h[:]) // 查库里有没有这个哈希 return keyExists(hashed) } ``` 这样数据库泄露的话,攻击者拿到的是无用的哈希值,不是能用的 Key。 --- ## 拼在一起:一个完整的请求流程 ``` 请求进来 ↓ API Key 校验(缺 Key 或无 Key → 401) ↓ Scope 校验(Key 权限不够 → 403) ↓ 限流检查(超了 → 429,并带回剩余额度) ↓ 业务逻辑(正常返回) ``` 每一层返回的错误格式一致,客户端只需要处理一种错误结构。 --- **初级工程师觉得 API 就是一些接口,上线再说。资深工程师知道:API 一暴露到公网,就自动成为“攻击目标”——不是只有恶意攻击,还有自己写砸的 retry 逻辑也会造成伤害。** 现在加好防护,不是“过度设计”,是让自己不用半夜被叫醒。 下次你要暴露一个接口到公网时,先别急着写业务逻辑,把过滤层、限流层、可观测的头都装上。你的值班同事会感谢你的。