05.6 阶段 5 Web 服务与 gRPC
本页目录
一、阶段定位
前四个阶段都在解决"一个进程内怎么写好代码",本阶段开始解决"怎么把代码暴露成网络服务"。Go 的 net/http 标准库非常完整,但真实项目里几乎都要用框架(Gin/Chi/Echo);服务间调用则用 gRPC。本阶段的目标不是"学会 Gin 怎么写路由",而是理解 Handler、中间件、超时、优雅关闭这四件事——换任何框架都不变。
与前后阶段的衔接:
- 往上接阶段 3 的 context:HTTP 服务每请求一个 goroutine,超时控制全靠
context;不打好 context 基础,本阶段的"读超时/写超时"会变成黑盒。 - 往上接阶段 4 的 pprof:服务上线后延迟抖、内存涨,要靠本阶段的 pprof HTTP 接口抓 profile。
- 往下接阶段 6(05.7):HTTP handler 后面要接数据库与 Redis,本阶段先把 HTTP 层做对。
- 再往下接阶段 7(05.8):服务要容器化、上 K8s,本阶段的优雅关闭是 K8s 滚动更新不报错的前提。
原提纲里的"卡点"展开成可判断的现象依据:
- 忽略读超时与写超时:服务起一个慢查询,连接一直挂着,并发上去后文件描述符打满。
- 中间件顺序错:panic recovery 放在日志中间件后面,结果 panic 先打了一堆日志才被捕获。
- gRPC 不传 deadline:请求挂死在下游,goroutine 泄漏,连接池被占满。
二、阶段目标与投入
| 能力目标(可验证的行为) | 验证方式 |
|---|---|
能解释 http.Handler 接口与中间件链的执行顺序 |
手写一个"日志 + recovery"中间件,能画出请求从进入到响应的链路 |
能配置 ReadTimeout、WriteTimeout、IdleTimeout |
一个服务起 1 秒读超时,用 curl --max-time 2 验证超时断开 |
| 能用 Gin 写路由分组与中间件,做参数校验 | 一个 POST 接口要求 JSON body 字段非空,校验失败返回 400 |
| 能实现优雅关闭:收到信号后处理完在途请求再退出 | 压测时发 SIGTERM,验证在途请求全部完成 |
| 能定义 proto 文件,生成 gRPC 服务端与客户端 | 一个一元 RPC 接口,客户端调用成功 |
| 能写 gRPC 拦截器做鉴权或日志 | 拦截器打印每个 RPC 的方法名与耗时 |
建议学时:
- 全职:2 周,约 50–60 小时。net/http 与中间件 15 小时、Gin 与参数校验 15 小时、优雅关闭 5 小时、gRPC 15 小时、拦截器 10 小时。
- 在职:4–5 周,约 60 小时。gRPC 单独占一周。
学时分配建议:net/http 原理 15%、中间件与超时 20%、Gin 与路由 15%、优雅关闭 10%、gRPC 与 proto 25%、拦截器 15%。
三、先修自检
| 先修项 | 合格标准 | 不合格时回到 |
|---|---|---|
| HTTP 模型 | 知道方法、状态码、头部,会用 curl | 05.1 的 5.5 节 |
| context | 能用 context.WithTimeout 让函数退出 |
05.4 的 5.3 节 |
| 错误包装 | 能用 %w 保留错误链 |
05.3 的 5.3 节 |
| 接口与依赖注入 | 能写小接口并注入实现 | 05.3 的 5.1 节 |
| pprof | 能抓 CPU/heap profile | 05.5 的 5.5 节 |
经验判断:有 Node.js 经验的人容易把 Gin 当 Express 用,到处写回调;有 Java 经验的人容易过度设计分层,一个接口拆三个文件。本阶段以"能跑、能观测、能优雅关闭"为目标。
四、知识地图
| 模块 | 知识点 | 掌握程度 | 对应题库章节 |
|---|---|---|---|
| net/http | Handler、ServeMux、连接复用、超时 | 能讲清原理 | 06.6 Go 后端 |
| 中间件 | 中间件链、Recovery、日志、超时 | 会用 | 06.6 Go 后端 |
| Web 框架 | Gin/Echo/Chi/Fiber 取舍 | 会用 | 06.6 Go 后端 |
| 优雅关闭 | 信号监听、在途请求处理、资源释放 | 会用 | 06.6 Go 后端 |
| gRPC | proto、服务定义、生成代码、流式 | 会用 | 06.6 Go 后端 |
| gRPC 拦截器 | unary 拦截器、stream 拦截器、鉴权 | 会用 | 06.6 Go 后端 |
| 限流熔断 | 令牌桶、熔断、降级 | 了解 | 09.2 流量治理 |
进度管理建议:net/http 与中间件是面试高频,必须到"能讲清原理";gRPC 要求"会用",能定义 proto 与拦截器即可。
五、分模块精讲
5.1 net/http 与 Handler 原理
为什么需要它:理解 net/http 才能理解为什么 Gin 能"包"在标准库上。每个请求一个 goroutine,Handler 是接口,这是 Go Web 服务的根基。
核心机制:
http.Handler接口:ServeHTTP(ResponseWriter, *Request)。任何实现该接口的类型都能注册为 handler。http.ServeMux:路由器,把请求路径映射到 handler;Go 1.22 起支持方法与路径参数(GET /users/{id})。- 连接模型:每个 TCP 连接一个读 goroutine,每个请求一个新 goroutine(
server.go里go c.serve())。 http.Server的超时参数:ReadTimeout(读完请求头+体的时间)、WriteTimeout(写完响应的时间)、IdleTimeout(keep-alive 空闲时间)。- 不设超时的后果:慢客户端让连接一直挂着,文件描述符打满。
最小可运行示例:
package main
import (
"encoding/json"
"log"
"net/http"
"time"
)
func main() {
mux := http.NewServeMux()
mux.HandleFunc("GET /users/{id}", func(w http.ResponseWriter, r *http.Request) {
id := r.PathValue("id")
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode(map[string]string{"id": id})
})
srv := &http.Server{
Addr: ":8080",
Handler: mux,
ReadTimeout: 5 * time.Second, // 读请求 5 秒
WriteTimeout: 10 * time.Second, // 写响应 10 秒
IdleTimeout: 120 * time.Second,
}
log.Fatal(srv.ListenAndServe())
}
curl -i http://127.0.0.1:8080/users/100
# HTTP/1.1 200 OK
# Content-Type: application/json
# {"id":"100"}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 连接一直挂着,并发上去 fd 打满 | 没设 ReadTimeout/WriteTimeout | 设 http.Server 的三个超时 |
404 page not found |
路径与注册不匹配 | Go 1.22 前要区分尾斜杠;1.22 起用 GET /users/{id} |
| handler 里 panic 导致整个连接断开 | 没 recovery 中间件 | 加 recovery 中间件 |
面试考法:"net/http 每个请求一个 goroutine 吗""ServeMux 怎么路由""为什么要设超时"。要点:每请求一个 goroutine;ServeMux 按路径匹配;超时防慢客户端耗尽连接。
5.2 中间件链与超时控制
为什么需要它:日志、鉴权、recovery、超时这些横切逻辑不能写进每个 handler,要用中间件统一处理。中间件顺序错会导致 panic 没被捕获、日志漏记。
核心机制:
- 中间件签名:
func(next http.Handler) http.Handler,包一层 handler 返回新 handler。 - 执行顺序:按注册顺序进入,按 LIFO 顺序返回(洋葱模型)。
- 必须最先注册:Recovery(捕获 panic,否则进程崩)、RequestID(贯穿日志)。
- 超时中间件:用
http.TimeoutHandler或自己包一层context.WithTimeout,超时后返回 504。 - 鉴权中间件:从
Authorization头解析 token,失败返回 401。
最小可运行示例:
package main
import (
"context"
"log"
"net/http"
"time"
)
// 中间件类型
type Middleware func(http.Handler) http.Handler
// 链多个中间件
func Chain(h http.Handler, mws ...Middleware) http.Handler {
for i := len(mws) - 1; i >= 0; i-- {
h = mws[i](h)
}
return h
}
func Recovery(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer func() {
if rec := recover(); rec != nil {
log.Printf("panic: %v", rec)
http.Error(w, "internal server error", http.StatusInternalServerError)
}
}()
next.ServeHTTP(w, r)
})
}
func Logger(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
next.ServeHTTP(w, r)
log.Printf("%s %s %v", r.Method, r.URL.Path, time.Since(start))
})
}
func Timeout(timeout time.Duration) Middleware {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
ctx, cancel := context.WithTimeout(r.Context(), timeout)
defer cancel()
next.ServeHTTP(w, r.WithContext(ctx))
})
}
}
func main() {
h := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// handler 里读 ctx 判断超时
select {
case <-r.Context().Done():
http.Error(w, "timeout", http.StatusGatewayTimeout)
default:
w.Write([]byte("ok"))
}
})
// 顺序:Recovery 最外,然后 Logger,然后 Timeout
wrapped := Chain(h, Recovery, Logger, Timeout(2*time.Second))
_ = http.ListenAndServe(":8080", wrapped)
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| panic 后整个进程崩了 | Recovery 没放在最外层 | Recovery 必须是第一个中间件 |
| 日志没记录请求路径 | Logger 放在 Timeout 之后,超时没走到 next | Logger 放 Timeout 外层 |
| 超时中间件设了但 handler 不响应 | handler 没用 r.Context() | 所有耗时操作接收 ctx |
面试考法:"中间件执行顺序""为什么 Recovery 要放最外层""怎么实现超时"。要点:洋葱模型 LIFO;Recovery 最外防进程崩;超时用 context 传播。
5.3 Gin 与路由分组
为什么需要它:标准库路由功能弱(Go 1.22 前)、参数校验繁琐,Gin 是最常用的框架。它围绕 http.Handler 接口扩展,中间件模型与标准库一致。
核心机制:
- Gin 的
*gin.Engine实现了http.Handler,可以直接传给http.Server。 - 路由分组:
r.Group("/api/v1")给一组路由加前缀与中间件。 gin.Context封装了http.ResponseWriter与*http.Request,提供JSON、ShouldBindJSON等便捷方法。- 参数校验:用
bindingtag(validate:"required"),ShouldBindJSON自动校验。 - Gin 的中间件签名:
gin.HandlerFunc,与标准库不同但模型一致。
最小可运行示例:
package main
import (
"net/http"
"github.com/gin-gonic/gin"
)
type CreateUserReq struct {
Name string `json:"name" binding:"required"`
Age int `json:"age" binding:"gte=0,lte=150"`
}
func main() {
r := gin.Default() // 自带 Logger 与 Recovery
// 分组:/api/v1
v1 := r.Group("/api/v1")
{
v1.POST("/users", func(c *gin.Context) {
var req CreateUserReq
if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
c.JSON(http.StatusCreated, gin.H{"name": req.Name, "age": req.Age})
})
}
_ = r.Run(":8080")
}
curl -i -X POST http://127.0.0.1:8080/api/v1/users \
-H "Content-Type: application/json" \
-d '{"name":"ann","age":30}'
# 201 {"name":"ann","age":30}
curl -i -X POST http://127.0.0.1:8080/api/v1/users \
-H "Content-Type: application/json" \
-d '{"age":200}'
# 400 {"error":"Key: 'CreateUserReq.Name' Error:Field validation for 'Name' failed on the 'required' tag"}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
ShouldBindJSON 报 EOF |
body 没设 Content-Type | 客户端设 Content-Type: application/json |
| 校验失败返回的英文错误不好看 | 直接用 err.Error() | 自定义校验错误映射 |
| Gin 的 Recovery 把 panic 变成 500 但没日志 | 没接 zap | 用 gin.LoggerWithConfig 或自定义 recovery |
面试考法:"Gin 与标准库关系""路由分组怎么用""参数校验怎么做"。要点:Engine 实现 http.Handler;Group 加前缀与中间件;binding tag + ShouldBindJSON。
5.4 优雅关闭
为什么需要它:K8s 滚动更新时,旧 Pod 收到 SIGTERM 后如果立刻退出,在途请求会被切断;如果等太久,K8s 的 terminationGracePeriodSeconds(默认 30s)会强制杀进程。优雅关闭就是在两者间平衡。
核心机制:
- 监听
syscall.SIGTERM与syscall.SIGINT。 - 收到信号后调用
srv.Shutdown(ctx):停止接收新连接,等在途请求完成,关闭监听。 - 同时关闭数据库连接池、消息队列消费者、Redis 连接。
- 给 Shutdown 一个超时(如 10 秒),超时强制退出。
最小可运行示例:
package main
import (
"context"
"log"
"net/http"
"os"
"os/signal"
"syscall"
"time"
)
func main() {
mux := http.NewServeMux()
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
time.Sleep(2 * time.Second) // 模拟慢请求
w.Write([]byte("ok"))
})
srv := &http.Server{Addr: ":8080", Handler: mux}
// 启动服务
go func() {
if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
log.Fatal(err)
}
}()
// 等待信号
quit := make(chan os.Signal, 1)
signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
<-quit
log.Println("shutting down...")
// 给 10 秒处理在途请求
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
if err := srv.Shutdown(ctx); err != nil {
log.Fatal("forced shutdown:", err)
}
log.Println("server exited")
}
# 压测时另开一个终端发 SIGTERM
# kill -TERM <pid>
# 期望:在途请求(2 秒)完成后才退出,不返回 502
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| K8s 滚动更新时偶发 502 | 没做优雅关闭,SIGTERM 立刻杀进程 | 用 srv.Shutdown(ctx) |
| 优雅关闭等了 30 秒才退 | Shutdown 超时设太长 | 按 K8s terminationGracePeriodSeconds 设(默认 30s,留 5s 余量) |
| 数据库连接没关 | Shutdown 只关 HTTP,没关 DB | 同时 db.Close()、关 consumer |
面试考法:"优雅关闭怎么做""为什么要监听 SIGTERM""K8s 滚动更新为什么不能直接杀进程"。要点:Shutdown 停新连接等在途;同时关资源;超时兜底。
5.5 gRPC 与 Protobuf 服务定义
为什么需要它:服务间内部调用,HTTP/JSON 有文本解析开销、契约不严格。gRPC 用 Protobuf 二进制序列化、HTTP/2 多路复用,契约由 .proto 文件定义,生成类型安全的代码。
核心机制:
.proto文件定义服务(service)与消息(message):rpc SayHello (HelloRequest) returns (HelloReply)。- 用
protoc-gen-go生成消息结构体,protoc-gen-go-grpc生成服务端与客户端 stub。 - 四种方法:一元(unary)、服务端流式、客户端流式、双向流式。
- 默认用 HTTP/2,一个连接多路复用多个 RPC。
- 错误码用 gRPC 标准码(
codes.InvalidArgument、codes.NotFound等),不要返回 HTTP 状态码。
最小可运行示例:
// hello.proto
syntax = "proto3";
option go_package = "example.com/hello/hellopb";
service HelloService {
rpc SayHello (HelloRequest) returns (HelloReply);
}
message HelloRequest {
string name = 1;
}
message HelloReply {
string message = 1;
}
# 生成代码
protoc --go_out=. --go_opt=paths=source_relative \
--go-grpc_out=. --go-grpc_opt=paths=source_relative \
hello.proto
# 产出 hello.pb.go 与 hello_grpc.pb.go
// 服务端
package main
import (
"context"
"log"
"net"
"example.com/hello/hellopb"
"google.golang.org/grpc"
)
type server struct {
hellopb.UnimplementedHelloServiceServer
}
func (s *server) SayHello(ctx context.Context, req *hellopb.HelloRequest) (*hellopb.HelloReply, error) {
return &hellopb.HelloReply{Message: "hello " + req.Name}, nil
}
func main() {
lis, _ := net.Listen("tcp", ":50051")
s := grpc.NewServer()
hellopb.RegisterHelloServiceServer(s, &server{})
log.Fatal(s.Serve(lis))
}
// 客户端
func main() {
conn, _ := grpc.Dial("127.0.0.1:50051", grpc.WithInsecure())
defer conn.Close()
c := hellopb.NewHelloServiceClient(conn)
resp, err := c.SayHello(context.Background(), &hellopb.HelloRequest{Name: "ann"})
if err != nil {
log.Fatal(err)
}
log.Println(resp.Message) // hello ann
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
生成代码报 protoc-gen-go: program not found |
没装 protoc 插件 | go install google.golang.org/protobuf/cmd/protoc-gen-go@latest |
客户端 rpc error: code = Unavailable |
服务端没起或端口错 | 确认 net.Listen 端口;客户端 grpc.Dial 地址对 |
| 不传 ctx 导致请求挂死 | 没设超时 | 客户端 c.SayHello(ctx, ...) 用 context.WithTimeout |
面试考法:"gRPC 与 HTTP/JSON 区别""四种方法模式""为什么用 Protobuf"。要点:二进制序列化、HTTP/2 多路复用、契约由 proto 定义;一元/服务端流/客户端流/双向流。
5.6 gRPC 拦截器与超时重试
为什么需要它:鉴权、日志、超时、限流这些横切逻辑不能写进每个 RPC,要用拦截器统一处理。
核心机制:
- 一元拦截器:
grpc.UnaryServerInterceptor,签名func(ctx, req, info, handler) (resp, error)。 - 流式拦截器:
grpc.StreamServerInterceptor,处理流式 RPC。 - 注册:
grpc.NewServer(grpc.UnaryInterceptor(myInterceptor))。 - 超时:客户端用
context.WithTimeout,服务端用grpc.WithUnaryServerTimeout或拦截器统一设。 - 重试:用
grpc-go的grpc.WithDefaultCallOptions或插件grpc-go-middleware;不要随便重试非幂等接口。
最小可运行示例:
package main
import (
"context"
"log"
"time"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
// 日志拦截器
func LoggingInterceptor(ctx context.Context, req any, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (any, error) {
start := time.Now()
resp, err := handler(ctx, req)
log.Printf("method=%s duration=%v err=%v", info.FullMethod, time.Since(start), err)
return resp, err
}
// 鉴权拦截器
func AuthInterceptor(ctx context.Context, req any, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (any, error) {
// 从 ctx 取 token(客户端用 metadata 传)
if err := checkAuth(ctx); err != nil {
return nil, status.Errorf(codes.Unauthenticated, "invalid token: %v", err)
}
return handler(ctx, req)
}
func checkAuth(ctx context.Context) error {
// 简化:从 metadata 取 authorization
return nil
}
func main() {
s := grpc.NewServer(
grpc.ChainUnaryInterceptor(LoggingInterceptor, AuthInterceptor),
)
_ = s
}
// 客户端超时
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
resp, err := c.SayHello(ctx, &hellopb.HelloRequest{Name: "ann"})
// 超时后 err == codes.DeadlineExceeded
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 拦截器没生效 | 用了 grpc.UnaryInterceptor 只注册一个,多个要 ChainUnaryInterceptor |
用 Chain |
| 客户端不传超时,请求挂死 | 忘了 context.WithTimeout | 所有 RPC 客户端调用都包超时 |
| 鉴权拦截器放在日志后面,401 没日志 | 顺序错 | 日志放最外,鉴权在里面 |
面试考法:"gRPC 拦截器怎么写""为什么要传 deadline""拦截器顺序"。要点:UnaryServerInterceptor;Chain 注册多个;客户端必须设超时;日志最外。
5.7 限流与熔断(了解)
为什么需要它:下游服务挂了,不能让请求全部打过去把自己也拖垮。限流保护自己,熔断保护下游。
核心机制:
- 令牌桶:固定速率往桶里放令牌,请求取令牌,取不到就拒绝。
- 漏桶:请求先进桶,按固定速率流出。
- 熔断:下游错误率超过阈值时,暂时停止调用(打开状态),过一段时间半开试探。
- Go 生态:
golang.org/x/time/rate(令牌桶)、sony/gobreaker(熔断)。
最小可运行示例:
package main
import (
"context"
"net/http"
"golang.org/x/time/rate"
)
var limiter = rate.NewLimiter(100, 200) // 100 QPS,桶容量 200
func LimitMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if !limiter.Allow() {
http.Error(w, "too many requests", http.StatusTooManyRequests)
return
}
next.ServeHTTP(w, r)
})
}
func main() {
_ = http.ListenAndServe(":8080", LimitMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("ok"))
})))
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 限流太严,正常请求被拒 | QPS 设太低 | 按压测结果调;用 429 而不是 500 |
| 熔断后一直不放行 | 半开状态没设 | 设熔断恢复时间 |
面试考法:"限流算法""熔断状态机"。要点:令牌桶允许突发;漏桶平滑;熔断三态(关闭/打开/半开)。
六、分层练习
6.1 复现型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 手写 Handler | 用标准库写 GET /users/{id} 返回 JSON |
curl 能拿到正确响应 |
1 小时 |
| 中间件链 | 写 Recovery + Logger 两个中间件 | 故意 panic 返回 500,进程不崩 | 1 小时 |
| 超时配置 | 设 ReadTimeout=2s,起一个 5 秒的 handler |
客户端 curl --max-time 3 看到连接断开 |
1 小时 |
| Gin 参数校验 | 写 POST /users,name 必填 |
缺 name 返回 400 | 1 小时 |
| 优雅关闭 | 起服务,压测时发 SIGTERM | 在途请求完成后退出 | 1 小时 |
6.2 改造型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 加 RequestID | 在中间件生成 request id,注入 context 与响应头 | 每个请求响应头有 X-Request-Id |
1 小时 |
| 错误响应规范 | 统一错误返回 {"error":"...","code":400} |
所有错误格式一致 | 1 小时 |
| gRPC 拦截器 | 给 gRPC 服务加日志拦截器 | 每个 RPC 打印方法名与耗时 | 2 小时 |
| gRPC 客户端超时 | 客户端调用加 2 秒超时 | 下游慢时返回 codes.DeadlineExceeded |
1 小时 |
| 限流中间件 | 给 HTTP 服务加令牌桶限流 | 超过 QPS 返回 429 | 1 小时 |
6.3 设计型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 分层 HTTP 服务 | handler / service / repository 三层,Gin 路由 + 优雅关闭 | 依赖注入清晰;压测时 SIGTERM 不丢请求 | 6 小时 |
| gRPC 用户服务 | 定义 proto,实现 GetUser 与 CreateUser,带鉴权拦截器 |
客户端调用成功;无 token 返回 401 | 6 小时 |
| 限流 + 熔断组合 | 入口限流 + 下游调用熔断 | 下游故障时快速失败,不拖垮 | 4 小时 |
七、排障表
| 现象 | 可能原因 | 排查步骤 | 解决办法 |
|---|---|---|---|
| 请求挂死不返回 | 没设超时;下游慢 | curl -v 看连接;pprof goroutine 看阻塞 |
设 ReadTimeout/WriteTimeout;客户端设 ctx 超时 |
| panic 后进程崩了 | Recovery 没放最外 | 看中间件注册顺序 | Recovery 必须是第一个 |
| K8s 滚动更新偶发 502 | 没优雅关闭 | 看 Pod 日志退出时机 | 用 srv.Shutdown(ctx) |
gRPC 客户端 code = Unavailable |
服务端没起、端口错、TLS 配置 | grpcurl 或 nc -zv host port |
确认服务与端口 |
| gRPC 请求挂死 | 没传 deadline | 客户端 ctx 加超时 | context.WithTimeout |
| 限流后正常请求被拒 | QPS 设太低 | 看 429 日志 | 按压测调;用 429 |
Gin 的 ShouldBindJSON 报 EOF |
Content-Type 没设 | 客户端 curl 加 -H "Content-Type: application/json" |
|
| 连接数持续上涨 | 没设 IdleTimeout,keep-alive 不释放 | netstat 看 TIME_WAIT | 设 IdleTimeout |
八、出口条件
全部勾选后再进入 05.7 阶段 6 数据层、缓存与消息。
- [ ] 能解释
http.Handler接口与每请求一个 goroutine 的模型 - [ ] 能配置
ReadTimeout/WriteTimeout/IdleTimeout - [ ] 能写 Recovery + Logger 中间件,顺序正确
- [ ] 能用 Gin 写路由分组与参数校验
- [ ] 能实现优雅关闭,K8s 滚动更新不丢请求
- [ ] 能定义 proto 并生成 gRPC 服务端与客户端
- [ ] 能写 gRPC 拦截器做日志或鉴权
- [ ] 客户端 RPC 调用都带超时
自测题:
- net/http 每个请求是一个 goroutine 吗?为什么?
- 要点:是;每个 TCP 连接一个读 goroutine,每个请求
go c.serve()起新 goroutine。
- 要点:是;每个 TCP 连接一个读 goroutine,每个请求
- 中间件执行顺序是什么?为什么 Recovery 要放最外?
- 要点:洋葱模型,LIFO;Recovery 放最外才能捕获所有内层 panic。
- 优雅关闭的步骤是什么?
- 要点:监听信号 →
srv.Shutdown(ctx)停新连接等在途 → 关 DB/consumer → 超时退出。
- 要点:监听信号 →
- gRPC 四种方法模式?
- 要点:一元、服务端流式、客户端流式、双向流式。
- gRPC 拦截器怎么注册多个?
- 要点:
grpc.ChainUnaryInterceptor按顺序注册。
- 要点:
- 为什么 gRPC 客户端必须传 deadline?
- 要点:不传则请求挂死时 goroutine 泄漏、连接池被占满;超时返回
codes.DeadlineExceeded。
- 要点:不传则请求挂死时 goroutine 泄漏、连接池被占满;超时返回