阶段2(上):后端专题 Go/Gin/PostgreSQL/MySQL/Redis/MQ/gRPC 的课程、企业场景、面试题和可运行示例

This commit is contained in:
Shikui Wang committed 2026-10-23 15:24:57 +08:00
1 parent 0bae9916a9
commit 5eb67c5d08
65 files changed
+6457 -77

No files matched your search

@@ -0,0 +1,114 @@
---
id: backend.grpc-microservices.grpc-proto
title: gRPC 和 Protobuf:IDL、四种调用方式、错误码、超时、拦截器
type: lesson
domain: backend
stack: [grpc-microservices, go]
tags: [gRPC, Protobuf, HTTP/2, 拦截器, deadline]
level: intermediate
prerequisites: [backend.go.errors-concurrency]
est_hours: 3
related: [backend.grpc-microservices.governance, backend.grpc-microservices.interview]
week: [14]
order: 1
---
# gRPC 和 Protobuf:IDL、四种调用方式、错误码、超时、拦截器
## 解释说明
- **gRPC**:基于 HTTP/2 的 RPC 框架。先用 **Protobuf** 写接口定义(`.proto`),再由工具生成各语言的客户端和服务端代码,调用远程方法像调用本地函数。
- **Protobuf**:二进制序列化格式。比 JSON 体积小、解析快,有强类型约束;缺点是不可读,浏览器不能直接调用(需要 gRPC-Web 或网关转 HTTP/JSON)。
- **字段编号**:序列化时用编号而不是字段名。**已发布的编号不能改、不能复用**;删除字段时用 `reserved` 保留编号和名字。新增字段是向后兼容的。
- **四种调用方式**:一元(一问一答)、服务端流(一次请求、多次返回,例如推送进度)、客户端流(多次上传、一次返回,例如上传分片)、双向流(聊天、实时协作)。
- **错误码**:gRPC 有自己的状态码,常用 `InvalidArgument`、`NotFound`、`AlreadyExists`、`PermissionDenied`、`Unauthenticated`、`DeadlineExceeded`、`Unavailable`、`Internal`。可重试的一般只有 `Unavailable`(以及部分 `DeadlineExceeded`、`ResourceExhausted`),由业务判断。
- **Deadline(截止时间)**:客户端每次调用都要设置;截止时间会随请求传到服务端,服务端的 `ctx` 到期后应该停止工作,并继续传给下游调用。
- **拦截器(interceptor)**:gRPC 的中间件,用来做日志、鉴权、指标、恢复 panic。元数据(metadata)相当于 HTTP 头,用来传 token、请求 ID。
**和 REST 怎么选**:对外开放的接口、浏览器直接调用用 REST/JSON;内部服务之间、对性能和强类型契约有要求时用 gRPC。
## 案例
订单服务需要查用户信息:定义 `UserService.GetUser`,用户服务实现,订单服务通过生成的客户端调用,每次调用带 300ms 截止时间;用户不存在返回 `NotFound`,订单服务据此返回业务错误,而不是 500。
## 代码示例
接口定义([examples/grpc-user/user.proto](examples/grpc-user/user.proto)):
```proto
syntax = "proto3";
package user.v1;
service UserService {
rpc GetUser(GetUserRequest) returns (User);
rpc ListUsers(ListUsersRequest) returns (stream User); // 服务端流
}
message GetUserRequest { int64 id = 1; }
message ListUsersRequest { int32 page_size = 1; }
message User {
int64 id = 1;
string name = 2;
string email = 3;
reserved 4; // 已删除字段的编号,不能复用
reserved "phone";
}
```
Go 服务端和客户端的关键写法(需要先用 `protoc --go_out --go-grpc_out` 生成 `userv1` 包;安装和生成命令以官方 Go 快速开始为准:https://grpc.io/docs/languages/go/quickstart/ ):
```go
// 服务端:实现生成的接口
type userServer struct {
userv1.UnimplementedUserServiceServer // 嵌入它,接口新增方法时不会编译失败
repo UserRepo
}
func (s *userServer) GetUser(ctx context.Context, req *userv1.GetUserRequest) (*userv1.User, error) {
if req.GetId() <= 0 {
return nil, status.Error(codes.InvalidArgument, "id 必须大于 0")
}
u, err := s.repo.Find(ctx, req.GetId()) // 把 ctx 继续往下传,截止时间才能生效
if errors.Is(err, ErrNotFound) {
return nil, status.Errorf(codes.NotFound, "用户 %d 不存在", req.GetId())
}
if err != nil {
return nil, status.Error(codes.Internal, "查询失败") // 不把内部错误细节暴露给调用方
}
return &userv1.User{Id: u.ID, Name: u.Name, Email: u.Email}, nil
}
// 一元拦截器:记录方法、耗时和状态码
func logging(ctx context.Context, req any, info *grpc.UnaryServerInfo, h grpc.UnaryHandler) (any, error) {
start := time.Now()
resp, err := h(ctx, req)
log.Printf("%s %s %v", info.FullMethod, status.Code(err), time.Since(start))
return resp, err
}
// 客户端:每次调用都带截止时间
func getUser(cli userv1.UserServiceClient, id int64) (*userv1.User, error) {
ctx, cancel := context.WithTimeout(context.Background(), 300*time.Millisecond)
defer cancel()
u, err := cli.GetUser(ctx, &userv1.GetUserRequest{Id: id})
if status.Code(err) == codes.NotFound {
return nil, ErrUserNotFound
}
return u, err
}
```
可直接运行的完整演示用 Python(不需要单独安装 protoc):[examples/grpc-user/demo.py](examples/grpc-user/demo.py),覆盖一元调用、服务端流、`NOT_FOUND` 和 `DEADLINE_EXCEEDED`。
## 易错点
- **修改或复用字段编号**:老客户端解析出错乱的数据,而且不会报错。
- **客户端不设截止时间**:下游卡住时请求无限等待,连接和 goroutine 堆积。
- **服务端不把 `ctx` 传给下游**:客户端已经放弃了,服务端还在查数据库。
- **所有错误都返回 `Unknown` / `Internal`**:调用方无法区分“参数错”和“服务挂了”,也就无法决定是否重试。
- **每次调用都新建连接**:gRPC 连接(`grpc.ClientConn`)应该复用,它内部会管理 HTTP/2 连接。
- **把 proto 文件复制到各个仓库**:容易不一致,放在统一的仓库或用 Buf 等工具管理版本。
## 面试常问
见 [gRPC 与微服务面试题](interview.md):gRPC 和 REST 的区别、为什么快、四种调用方式、字段编号规则、deadline 传递。
@@ -0,0 +1,101 @@
---
id: backend.grpc-microservices.governance
title: 服务治理:超时、重试、熔断、限流、注册发现、链路追踪、分布式事务
type: lesson
domain: backend
stack: [grpc-microservices]
tags: [超时, 重试, 熔断, 限流, 服务发现, 链路追踪, Saga, 分布式事务]
level: advanced
prerequisites: [backend.grpc-microservices.grpc-proto]
est_hours: 3
related: [backend.grpc-microservices.scenario.monolith-split, backend.mq.reliability, backend.grpc-microservices.interview]
week: [14]
order: 2
---
# 服务治理:超时、重试、熔断、限流、注册发现、链路追踪、分布式事务
## 解释说明
服务拆开之后,一次用户请求会经过多个服务,任何一个慢了或挂了都可能拖垮整条链路(**雪崩**)。服务治理就是防止这种情况、并且出问题时能定位。
| 手段 | 解决什么 | 要点 |
| --- | --- | --- |
| 超时 | 下游卡住时不无限等待 | 每次调用都设;越往下游超时越短,总和不超过入口超时 |
| 重试 | 偶发失败 | 只重试幂等操作和可重试错误;指数退避 + 抖动;限制次数;**不要每一层都重试**(会放大流量) |
| 熔断 | 下游已经故障时快速失败,给它恢复时间 | 关闭 → 打开(直接失败)→ 半开(试探)→ 关闭 |
| 限流 | 保护自己不被打垮 | 令牌桶 / 滑动窗口;超出返回 429 / `ResourceExhausted` |
| 降级 | 非核心功能出问题时保证核心可用 | 推荐服务挂了就返回默认列表 |
| 注册发现 | 服务实例动态变化时找到地址 | Consul、etcd、Nacos;Kubernetes 里直接用 Service 的 DNS |
| 负载均衡 | 请求分给多个实例 | gRPC 是长连接,需要客户端负载均衡或服务网格,否则请求会集中在一个实例 |
| 链路追踪 | 定位慢在哪个服务 | 用 OpenTelemetry 在请求中传递 trace ID,每个服务记录自己的 span |
**分布式事务**:一个业务操作跨多个服务的数据库。
- **2PC(两阶段提交)**:强一致,但协调者单点、锁持有时间长,互联网业务很少用。
- **TCC**:每个服务实现 Try(预留资源)/ Confirm / Cancel,业务侵入大。
- **Saga**:拆成一串本地事务,每一步有对应的补偿操作;失败时逆序执行补偿。
- **可靠消息 + 最终一致**:发件箱 + MQ + 幂等消费(见[消息可靠性](../mq/03-reliability.md)),大部分业务的首选,再加定时对账。
## 案例
订单服务调用库存服务和优惠券服务:
- 入口超时 2 秒;调用库存 500ms、优惠券 300ms;
- 优惠券服务故障时熔断,下单时提示“优惠券暂不可用”,仍然允许原价下单(降级);
- 下单跨“订单、库存、优惠券”三个数据库:用 Saga——创建订单(待确认)→ 扣库存 → 核销优惠券,任一步失败就逆序补偿(释放库存、取消订单)。
## 代码示例
完整代码和测试见 [examples/resilience](examples/resilience/)(Go 标准库实现)。重试的核心:
```go
func Retry(ctx context.Context, attempts int, base time.Duration, fn func(context.Context) error) error {
var err error
for i := range attempts {
if err = fn(ctx); err == nil {
return nil
}
var p Permanent
if errors.As(err, &p) || errors.Is(err, ErrOpen) || i == attempts-1 {
return err // 不可重试的错误、熔断中、最后一次:直接返回
}
backoff := base << i // 指数退避
backoff += time.Duration(rand.Int64N(int64(backoff)/2 + 1)) // 抖动
select {
case <-ctx.Done():
return errors.Join(err, ctx.Err()) // 截止时间到了就不再重试
case <-time.After(backoff):
}
}
return err
}
```
组合使用:先熔断后重试(熔断打开时 `ErrOpen` 不再重试),外层由 `context.WithTimeout` 控制总时长:
```go
ctx, cancel := context.WithTimeout(parent, 500*time.Millisecond)
defer cancel()
err := resilience.Retry(ctx, 3, 50*time.Millisecond, func(ctx context.Context) error {
return breaker.Do(ctx, func(ctx context.Context) error {
_, err := inventoryClient.Reserve(ctx, req)
return err
})
})
```
生产环境通常不自己写,而是用 gRPC 自带的重试配置(service config)、服务网格(Istio 等)或成熟的库;自己实现一遍是为了理解原理和面试。
## 易错点
- **每一层都重试 3 次**:三层调用会放大成 27 倍请求,雪上加霜。在一个地方重试即可。
- **重试非幂等操作**:扣款、下单重复执行。要么不重试,要么带幂等键。
- **下游超时比上游长**:上游已经超时返回,下游还在干活,白白浪费资源。
- **熔断把业务错误算作失败**:用户输错参数也能把熔断器打开。
- **gRPC 长连接 + Kubernetes Service 默认负载均衡**:连接建立后请求都落到同一个 Pod。用客户端负载均衡(headless Service + `round_robin`)或服务网格。
- **没有 trace ID**:出了问题只能在多个服务的日志里按时间猜。
## 面试常问
见 [gRPC 与微服务面试题](interview.md):服务雪崩怎么防、熔断器状态机、重试的注意事项、分布式事务方案对比。
@@ -0,0 +1,81 @@
# requires: grpc, grpc_tools
"""gRPC 演示:从 user.proto 生成代码 → 启动服务端 → 客户端调用(一元、服务端流、超时、错误码)。
运行:pip install grpcio grpcio-tools && python demo.py
生成的代码放在临时目录,不污染仓库。
"""
import importlib
import sys
import tempfile
import time
from concurrent import futures
from pathlib import Path
import grpc
from grpc_tools import protoc
HERE = Path(__file__).resolve().parent
def generate(out: Path):
rc = protoc.main(["protoc", f"-I{HERE}", f"--python_out={out}", f"--grpc_python_out={out}", str(HERE / "user.proto")])
assert rc == 0, "protoc 生成失败"
sys.path.insert(0, str(out))
return importlib.import_module("user_pb2"), importlib.import_module("user_pb2_grpc")
def main() -> None:
with tempfile.TemporaryDirectory() as tmp:
pb, pb_grpc = generate(Path(tmp))
users = {i: pb.User(id=i, name=f"用户{i}", email=f"u{i}@example.com") for i in range(1, 6)}
class UserService(pb_grpc.UserServiceServicer):
def GetUser(self, request, context):
if request.id == 99:
time.sleep(0.5) # 模拟慢请求
user = users.get(request.id)
if user is None:
context.abort(grpc.StatusCode.NOT_FOUND, f"用户 {request.id} 不存在")
return user
def ListUsers(self, request, context):
for i, u in enumerate(users.values()):
if i >= request.page_size:
break
yield u
server = grpc.server(futures.ThreadPoolExecutor(max_workers=4))
pb_grpc.add_UserServiceServicer_to_server(UserService(), server)
port = server.add_insecure_port("127.0.0.1:0") # 0 = 随机可用端口
server.start()
try:
with grpc.insecure_channel(f"127.0.0.1:{port}") as ch:
stub = pb_grpc.UserServiceStub(ch)
u = stub.GetUser(pb.GetUserRequest(id=1), timeout=1.0) # 每次调用都带超时
print("一元调用:", u.id, u.name)
assert u.name == "用户1"
names = [x.name for x in stub.ListUsers(pb.ListUsersRequest(page_size=3), timeout=1.0)]
print("服务端流:", names)
assert len(names) == 3
try:
stub.GetUser(pb.GetUserRequest(id=42), timeout=1.0)
raise AssertionError("应该返回 NOT_FOUND")
except grpc.RpcError as e:
print("错误码:", e.code().name, e.details())
assert e.code() == grpc.StatusCode.NOT_FOUND
try:
stub.GetUser(pb.GetUserRequest(id=99), timeout=0.1)
raise AssertionError("应该超时")
except grpc.RpcError as e:
print("超时:", e.code().name)
assert e.code() == grpc.StatusCode.DEADLINE_EXCEEDED
finally:
server.stop(grace=None)
print("gRPC 演示通过")
if __name__ == "__main__":
main()
@@ -0,0 +1,26 @@
syntax = "proto3";
package user.v1;
// 用户服务:一个一元调用 + 一个服务端流
service UserService {
rpc GetUser(GetUserRequest) returns (User);
rpc ListUsers(ListUsersRequest) returns (stream User);
}
message GetUserRequest {
int64 id = 1;
}
message ListUsersRequest {
int32 page_size = 1;
}
message User {
int64 id = 1;
string name = 2;
string email = 3;
// 字段编号一旦发布就不能修改或复用;删除字段时用 reserved
reserved 4;
reserved "phone";
}
@@ -0,0 +1,3 @@
module example/resilience
go 1.22
@@ -0,0 +1,119 @@
// Package resilience 服务调用的三件套:超时(由调用方的 context 控制)、带退避的重试、熔断器。只用标准库。
package resilience
import (
"context"
"errors"
"math/rand/v2"
"sync"
"time"
)
// ErrOpen 熔断器打开时直接返回,不再调用下游
var ErrOpen = errors.New("熔断中:下游暂时不可用")
// Permanent 包装不应该重试的错误(参数错误、没有权限、资源不存在等)
type Permanent struct{ Err error }
func (p Permanent) Error() string { return p.Err.Error() }
func (p Permanent) Unwrap() error { return p.Err }
// Retry 最多尝试 attempts 次,间隔指数增长并加随机抖动;context 取消或超时立即停止
func Retry(ctx context.Context, attempts int, base time.Duration, fn func(context.Context) error) error {
var err error
for i := range attempts {
if err = fn(ctx); err == nil {
return nil
}
var p Permanent
if errors.As(err, &p) || errors.Is(err, ErrOpen) || i == attempts-1 {
return err
}
backoff := base << i // base, 2*base, 4*base ...
backoff += time.Duration(rand.Int64N(int64(backoff)/2 + 1)) // 抖动,避免所有客户端同时重试
select {
case <-ctx.Done():
return errors.Join(err, ctx.Err())
case <-time.After(backoff):
}
}
return err
}
type state int
const (
closed state = iota // 正常放行
open // 熔断:直接拒绝
halfOpen // 试探:放一个请求过去
)
// Breaker 连续失败 threshold 次后打开,cooldown 之后进入半开,试探成功则关闭、失败则重新打开
type Breaker struct {
mu sync.Mutex
state state
failures int
threshold int
cooldown time.Duration
openedAt time.Time
probing bool
now func() time.Time // 测试时可以替换
}
func NewBreaker(threshold int, cooldown time.Duration) *Breaker {
return &Breaker{threshold: threshold, cooldown: cooldown, now: time.Now}
}
func (b *Breaker) allow() bool {
b.mu.Lock()
defer b.mu.Unlock()
switch b.state {
case open:
if b.now().Sub(b.openedAt) < b.cooldown {
return false
}
b.state = halfOpen
fallthrough
case halfOpen:
if b.probing {
return false // 半开状态只放一个试探请求
}
b.probing = true
return true
}
return true
}
func (b *Breaker) record(err error) {
b.mu.Lock()
defer b.mu.Unlock()
var p Permanent
failed := err != nil && !errors.As(err, &p) // 业务错误不算下游故障
if b.state == halfOpen {
b.probing = false
if failed {
b.state, b.openedAt = open, b.now()
} else {
b.state, b.failures = closed, 0
}
return
}
if !failed {
b.failures = 0
return
}
b.failures++
if b.failures >= b.threshold {
b.state, b.openedAt = open, b.now()
}
}
// Do 通过熔断器调用 fn
func (b *Breaker) Do(ctx context.Context, fn func(context.Context) error) error {
if !b.allow() {
return ErrOpen
}
err := fn(ctx)
b.record(err)
return err
}
@@ -0,0 +1,82 @@
package resilience
import (
"context"
"errors"
"sync/atomic"
"testing"
"time"
)
var errDown = errors.New("下游 503")
func TestRetrySucceedsAfterTransientErrors(t *testing.T) {
var calls atomic.Int32
err := Retry(context.Background(), 5, time.Millisecond, func(context.Context) error {
if calls.Add(1) < 3 {
return errDown
}
return nil
})
if err != nil || calls.Load() != 3 {
t.Fatalf("err=%v calls=%d", err, calls.Load())
}
}
func TestRetryStopsOnPermanent(t *testing.T) {
var calls int
err := Retry(context.Background(), 5, time.Millisecond, func(context.Context) error {
calls++
return Permanent{errors.New("参数错误")}
})
if calls != 1 || err == nil {
t.Fatalf("不可重试的错误只应调用一次,calls=%d", calls)
}
}
func TestRetryRespectsDeadline(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Millisecond)
defer cancel()
start := time.Now()
err := Retry(ctx, 10, 20*time.Millisecond, func(context.Context) error { return errDown })
if !errors.Is(err, context.DeadlineExceeded) || time.Since(start) > 200*time.Millisecond {
t.Fatalf("应该在截止时间后停止:%v,耗时 %v", err, time.Since(start))
}
}
func TestBreaker(t *testing.T) {
now := time.Unix(0, 0)
b := NewBreaker(3, 10*time.Second)
b.now = func() time.Time { return now }
ctx := context.Background()
fail := func(context.Context) error { return errDown }
ok := func(context.Context) error { return nil }
for range 3 {
_ = b.Do(ctx, fail)
}
if err := b.Do(ctx, ok); !errors.Is(err, ErrOpen) {
t.Fatalf("连续失败 3 次后应该熔断,得到 %v", err)
}
now = now.Add(11 * time.Second) // 冷却结束 → 半开,试探失败 → 重新打开
if err := b.Do(ctx, fail); !errors.Is(err, errDown) {
t.Fatalf("半开时应放行试探请求:%v", err)
}
if err := b.Do(ctx, ok); !errors.Is(err, ErrOpen) {
t.Fatal("试探失败后应该重新熔断")
}
now = now.Add(11 * time.Second) // 再次半开,试探成功 → 关闭
if err := b.Do(ctx, ok); err != nil {
t.Fatal(err)
}
if err := b.Do(ctx, ok); err != nil {
t.Fatal("恢复后应该正常放行")
}
// 业务错误不计入熔断
for range 5 {
_ = b.Do(ctx, func(context.Context) error { return Permanent{errors.New("用户不存在")} })
}
if err := b.Do(ctx, ok); err != nil {
t.Fatal("业务错误不应该触发熔断")
}
}
+31 -3
View File
@@ -4,12 +4,40 @@ title: gRPC 与微服务
type: index
domain: backend
stack: [grpc-microservices]
tags: []
tags: [gRPC, Protobuf, 微服务, 服务治理]
week: [14]
---
# gRPC 与微服务
proto、四种调用方式、超时重试、服务治理、分布式事务。
Go 岗位的 JD 里经常出现“熟悉 gRPC / 微服务架构”。这个专题讲清楚三件事:gRPC 和 Protobuf 怎么用;服务之间调用要做哪些治理(超时、重试、熔断、限流、注册发现、链路追踪);什么时候拆服务、怎么拆。转岗求职阶段的项目不需要真的拆成很多服务,但要能讲清楚取舍。
> 本专题建设中:课程、企业场景、面试题和示例代码会陆续补充。
## 学习路线
| 顺序 | 课程 | 级别 | 预计 |
| --- | --- | --- | --- |
| 1 | [gRPC 和 Protobuf:IDL、四种调用方式、错误码、超时、拦截器](01-grpc-proto.md) | 进阶 | 3 小时 |
| 2 | [服务治理:超时、重试、熔断、限流、注册发现、链路追踪、分布式事务](02-governance.md) | 进阶 | 3 小时 |
## 企业场景
- [单体拆分:从单体到“订单 + 用户”两个服务](scenarios/monolith-split.md)
## 面试题
- [gRPC 与微服务面试题](interview.md)
## 示例代码
- [examples/grpc-user](examples/grpc-user/):Python 从 `user.proto` 生成代码,演示一元调用、服务端流、错误码和超时(需要 `grpcio`、`grpcio-tools`)
- [examples/resilience](examples/resilience/):Go 标准库实现带退避的重试和熔断器,附测试
## 在 16 周计划中
- [第 14 周:后端扩展与部署](../../../plan/week14-backend-extend-deploy.md)
## 官方资料
- gRPC 文档(Go / Python 快速开始):https://grpc.io/docs/
- Protobuf 语言指南:https://protobuf.dev/programming-guides/proto3/
- OpenTelemetry:https://opentelemetry.io/docs/
@@ -0,0 +1,63 @@
---
id: backend.grpc-microservices.interview
title: gRPC 与微服务面试题
type: interview
domain: backend
stack: [grpc-microservices]
tags: [gRPC, 微服务, 服务治理, 分布式事务, 面试]
level: advanced
related: [backend.grpc-microservices.grpc-proto, backend.grpc-microservices.governance]
week: [14, 16]
---
# gRPC 与微服务面试题
## 基础
### 【基础】gRPC 和 REST 有什么区别?
**参考答案**:gRPC 基于 HTTP/2,用 Protobuf 二进制序列化,有 IDL 和代码生成,强类型契约,支持流式调用;REST 通常基于 HTTP/1.1 + JSON,可读性好、浏览器原生支持、生态通用。内部服务之间、追求性能和契约时用 gRPC;对外开放、前端直接调用用 REST。
### 【基础】gRPC 有哪几种调用方式?
**参考答案**:一元调用(一请求一响应)、服务端流(一请求多响应,如推送进度)、客户端流(多请求一响应,如分片上传)、双向流(如聊天)。
### 【基础】Protobuf 字段编号有什么规则?
**参考答案**:编号决定序列化后的字段标识,发布后不能修改、不能复用;删除字段用 `reserved` 保留编号和名字;新增字段使用新编号,对老客户端兼容(老客户端会忽略未知字段)。1~15 编码只占一个字节,留给高频字段。
### 【基础】微服务相比单体有什么优缺点?
**参考答案**:优点是独立部署、独立扩容、技术栈可以不同、故障隔离、团队可以独立开发。缺点是网络调用带来的延迟和失败、分布式事务和数据一致性、运维和监控复杂度、调试和排查困难。团队小、业务早期通常模块化单体更合适。
## 进阶
### 【进阶】什么是服务雪崩?怎么防止?
**参考答案**:一个下游服务变慢,调用方的线程 / 连接被占住,进而调用方也变慢,最终一层层传导导致整个系统不可用。防止:所有调用设超时;熔断故障的下游;限流保护自己;降级非核心功能;隔离资源(不同下游用不同的连接池 / 并发限制);重试要有限次数并退避。
### 【进阶】讲一下熔断器的状态机。
**参考答案**:关闭状态正常放行并统计失败;失败达到阈值(次数或比例)后打开,直接返回失败;冷却时间后进入半开,放少量请求试探;试探成功则关闭,失败则重新打开。只把下游故障(超时、不可用)计为失败,业务错误不算。
### 【进阶】重试要注意什么?
**参考答案**:只重试可重试的错误(如 `Unavailable`)和幂等操作;指数退避加随机抖动;限制次数,并受整体截止时间约束;只在一层做重试,避免逐层放大;熔断打开时不重试;非幂等操作需要幂等键。
### 【进阶】分布式事务有哪些方案?怎么选?
**参考答案**:2PC 强一致但性能差、协调者单点,很少用于互联网业务;TCC 通过 Try/Confirm/Cancel 预留资源,一致性较好但业务侵入大;Saga 把长事务拆成本地事务 + 补偿,适合流程长的业务;可靠消息(发件箱 + MQ + 幂等)实现最终一致,最常用。一般优先“可靠消息 + 对账”,对资金等强一致场景再考虑 TCC。
## 场景题
### 【场景题】订单服务调用库存服务,库存服务偶尔超时,应该怎么处理?
**参考答案**:设置合理的超时(小于订单接口自身的超时);扣库存接口要求幂等(带订单号作为幂等键),这样超时后可以安全重试一两次;超时结果不确定时,不能直接认为失败——通过查询接口或后续对账确认;持续超时时熔断,下单接口返回“系统繁忙”;排查库存服务本身的慢查询或资源问题。
### 【场景题】团队想把单体系统改成微服务,你怎么推进?
**参考答案**:先明确要解决的问题,能用模块化、读写分离、缓存解决的不急于拆;选边界清晰、需求明确的模块先拆;用绞杀者模式:先在单体内抽接口,再实现远程服务,用开关灰度切流,随时可回退;数据分库通过双写或 CDC 迁移并校验;同时建设超时熔断、链路追踪、集中日志等基础设施。详见[单体拆分场景](scenarios/monolith-split.md)。
### 【场景题】一个请求经过 5 个服务,用户反馈偶尔很慢,怎么定位?
**参考答案**:靠链路追踪:入口生成 trace ID,各服务通过 OpenTelemetry 记录 span 并传递上下文,在追踪系统里按耗时筛选慢请求,看是哪一个 span 慢;再结合该服务的日志(带 trace ID)和指标(CPU、GC、连接池、数据库慢查询)找原因。没有追踪系统时,至少要在日志里统一打印请求 ID。
@@ -0,0 +1,113 @@
---
id: backend.grpc-microservices.scenario.monolith-split
title: 单体拆分:从单体到“订单 + 用户”两个服务
type: scenario
domain: backend
stack: [grpc-microservices, go, mq]
tags: [单体拆分, 绞杀者模式, 数据拆分, gRPC, 灰度]
level: advanced
prerequisites: [backend.grpc-microservices.governance]
est_hours: 2
related: [backend.grpc-microservices.interview, backend.mq.reliability]
week: [14]
---
# 单体拆分:从单体到“订单 + 用户”两个服务
## 业务背景与问题
一个 Go 单体后台(用户、商品、订单、报表都在一个进程、一个数据库),团队从 3 人增加到 10 人后:多人改同一个仓库冲突多;报表的重查询拖慢下单;一个模块的 bug 导致整个服务重启。团队讨论“要不要全面改微服务”。
## 约束
- 业务不能停,拆分过程中要能随时回退。
- 运维人力有限,没有专职的平台团队。
- 用户数据被订单、报表等多处直接 JOIN 查询。
## 方案设计
1. **先判断是否真的需要拆**:很多问题不需要微服务就能解决——报表查询拖慢下单 → 报表走只读从库;代码冲突 → 按模块划分目录和负责人(模块化单体)。只有“独立部署、独立扩容、故障隔离”的需求明确的部分才拆出来。
2. **选第一个拆分对象**:边界清晰、被依赖多、变化少的模块——用户服务(登录、资料)。
3. **绞杀者模式(Strangler Fig)逐步迁移**:
- 第一步:在单体内部把用户模块整理成接口(`UserService`),其他模块只通过接口访问,不再直接 JOIN 用户表;
- 第二步:新建用户服务(gRPC),实现同样的接口;单体里的接口实现改为调用 gRPC 客户端,用开关控制走本地还是远程,灰度切换;
- 第三步:数据拆分——用户表迁到用户服务的独立数据库;迁移期间双写或用 CDC 同步,校验一致后切读、再切写;
- 第四步:订单需要的用户字段(如昵称)在订单里冗余一份或通过事件同步,避免每次查订单都远程调用。
4. **配套治理**:调用超时和熔断、统一 trace ID、错误码映射、接口契约(proto)放在独立仓库管理。
```mermaid
flowchart LR
subgraph 单体
O[订单模块] --> I{UserService 接口}
I -->|开关=本地| L[本地实现]
I -->|开关=远程| G[gRPC 客户端]
end
G -->|超时 + 熔断| U[用户服务] --> UDB[(用户库)]
L --> MDB[(原单体库)]
```
## 关键代码
接口先行,单体里的调用方不关心实现在本地还是远程:
```go
type UserService interface {
GetUser(ctx context.Context, id int64) (User, error)
}
// 远程实现:gRPC 客户端 + 超时 + 错误码映射
type remoteUsers struct{ cli userv1.UserServiceClient }
func (r remoteUsers) GetUser(ctx context.Context, id int64) (User, error) {
ctx, cancel := context.WithTimeout(ctx, 300*time.Millisecond)
defer cancel()
u, err := r.cli.GetUser(ctx, &userv1.GetUserRequest{Id: id})
switch status.Code(err) {
case codes.OK:
return User{ID: u.GetId(), Name: u.GetName()}, nil
case codes.NotFound:
return User{}, ErrUserNotFound
default:
return User{}, fmt.Errorf("用户服务调用失败:%w", err)
}
}
// 灰度开关:按比例把流量切到远程实现,出问题可以立即切回
type switchUsers struct {
local, remote UserService
percent func() int // 从配置中心读取 0~100
}
func (s switchUsers) GetUser(ctx context.Context, id int64) (User, error) {
if int(id%100) < s.percent() {
return s.remote.GetUser(ctx, id)
}
return s.local.GetUser(ctx, id)
}
```
gRPC 调用、错误码和超时的可运行演示见 [examples/grpc-user](../examples/grpc-user/);超时 / 重试 / 熔断见 [examples/resilience](../examples/resilience/)。
## 取舍
| 方案 | 适合 | 代价 |
| --- | --- | --- |
| 保持单体 + 模块化 | 团队小、业务变化快 | 部署和扩容不能独立 |
| **按需拆出少数服务(本方案)** | 有明确的独立部署 / 扩容 / 隔离需求 | 引入网络调用、分布式数据一致性、更多运维 |
| 一次性全面微服务 | 很少适合 | 风险高、周期长、运维成本陡增 |
## 易错点
- 拆了服务但还共用一个数据库:耦合没有解决,反而多了网络调用。
- 一次性切换、没有开关:出问题无法快速回退。
- 订单列表每行都远程查用户:N+1 远程调用。用批量接口或冗余字段。
- 拆分后跨服务事务直接用分布式锁硬凑:应该用可靠消息 / Saga 做最终一致。
- 拆得太细(每张表一个服务):调用链变长,问题更多。
## 面试怎么讲
> “我们没有一上来就全面微服务。先在单体里把用户模块抽成接口,让其他模块只通过接口访问;再把用户服务独立出来用 gRPC 提供,单体里加了按比例切流的开关,出问题可以立即切回;数据用双写加校验迁到独立库,订单里需要的用户昵称通过事件同步冗余。调用都加了超时、熔断和 trace ID。”
转岗求职时如果没有真实的拆分经历,可以讲“我在项目里做过模块化设计,并且了解拆分的步骤和风险”,不要编造经历。
追问准备:怎么判断一个模块该不该拆?数据迁移期间怎么保证一致?服务间调用失败怎么处理?