
Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。
正文
Generated by kimi-k2.6 model
目录
- 1. 微服务架构基础
- 2. 服务治理
- 3. API 网关
- 4. 链路追踪与分布式追踪
- 5. 容器化技术
- 6. Kubernetes 核心原理
- 7. 可观测性体系
- 8. 服务网格 Service Mesh
- 9. 云原生设计模式
- 附录:面试高频速查
1. 微服务架构基础
1.1 单体架构 vs 微服务架构
TL;DR:微服务是将单体应用拆分为一组小型、独立部署的服务,每个服务围绕业务能力构建,但引入了分布式复杂度。
1. 场景与背景
当业务规模扩大,单体架构面临:
- 代码库臃肿,构建时间超过 30 分钟
- 团队规模扩大后协作冲突频繁
- 技术栈被锁定,无法引入新技术
- 某个模块故障导致整个系统不可用
2. 理论原理
微服务的核心特征(Martin Fowler 定义):
| 特征 | 说明 |
|---|---|
| 组件化与服务化 | 服务即组件,独立部署和替换 |
| 围绕业务能力组织 | 团队按业务领域划分,而非技术层 |
| 产品而非项目思维 | 团队对服务全生命周期负责 |
| 智能端点与傻瓜管道 | 业务逻辑在服务端,通信管道简单(REST/gRPC) |
| 去中心化治理 | 允许不同服务使用不同技术栈 |
| 去中心化数据管理 | 每个服务管理自己的数据库 |
| 基础设施自动化 | CI/CD、自动化测试、监控 |
| 容错设计 | 设计应对服务故障的机制 |
| 演进式设计 | 支持渐进式拆分和重构 |
类比:单体架构像一家大型百货公司(所有部门在一栋楼),微服务像商业街(每个店铺独立经营、独立装修,通过街道(网络)连接)。
3. 代码示例:服务拆分边界识别
// ❌ 单体中的紧耦合代码
type OrderService struct {
// 直接依赖其他模块的具体实现
inventoryRepo *InventoryRepository // 库存
paymentClient *PaymentClient // 支付
shippingService *ShippingService // 物流
notificationService *NotificationService // 通知
}
// ✅ 微服务中通过接口和解耦通信
type OrderService struct {
inventoryClient InventoryClient // RPC/HTTP 客户端
paymentClient PaymentClient
eventBus EventBus // 异步事件解耦
}
func (s *OrderService) CreateOrder(ctx context.Context, req *OrderRequest) (*Order, error) {
// 1. 检查库存(同步调用)
available, err := s.inventoryClient.CheckStock(ctx, req.ProductID, req.Quantity)
if err != nil {
return nil, fmt.Errorf("inventory check failed: %w", err)
}
if !available {
return nil, ErrInsufficientStock
}
// 2. 创建订单(本地事务)
order, err := s.createOrderRecord(ctx, req)
if err != nil {
return nil, err
}
// 3. 发送订单创建事件(异步解耦)
s.eventBus.Publish(ctx, &OrderCreatedEvent{
OrderID: order.ID,
ProductID: req.ProductID,
Quantity: req.Quantity,
Timestamp: time.Now(),
})
return order, nil
}4. 业界实践
Netflix 的微服务演进:
- 2009 年开始从单体迁移到微服务
- 服务数量从几十个增长到 2000+(2016 年)
- 核心经验:先拆分数据层,再拆分业务层;用事件溯源处理跨服务事务
阿里巴巴的中台战略:
- 业务中台:用户中心、商品中心、交易中心
- 数据中台:统一数据服务层
- 技术中台:中间件、DevOps 平台
5. 方案对比
| 维度 | 单体架构 | 微服务架构 |
|---|---|---|
| 部署复杂度 | 低(一个包) | 高(多个服务协调) |
| 团队规模 | < 30 人 | > 50 人 |
| 技术栈灵活性 | 低 | 高 |
| 故障隔离 | 差(单点故障) | 好(服务级隔离) |
| 数据一致性 | 容易(ACID) | 困难(最终一致) |
| 运维成本 | 低 | 高 |
| 扩展性 | 整体扩展 | 按需扩展 |
6. 常见误区
❌ 为拆而拆:没有明确的业务边界就拆分,导致分布式单体(Distributed Monolith) ❌ 共享数据库:多个服务直接操作同一张表,丧失独立部署能力 ❌ 过度同步:所有服务间调用都是同步 HTTP,形成级联故障
✅ 先识别限界上下文:使用领域驱动设计(DDD)识别 Bounded Context ✅ 数据库隔离:每个服务独立 Schema,通过 API 或事件交换数据 ✅ 异步优先:能用事件就用事件,减少服务间耦合
7. 延伸问题
- "微服务拆分粒度的标准是什么?"
- "什么是分布式单体,如何避免?"
- "微服务中的数据一致性如何保证?"
1.2 服务拆分原则
TL;DR:按业务能力(限界上下文)拆分,而非技术层;粒度以"两周内能重写"为标准。
核心拆分原则
1. 单一职责原则(SRP) 一个服务只负责一个明确的业务能力。判断标准:如果一个需求变更只需要修改一个服务,拆分就是合理的。
2. 共同闭包原则(CCP) 经常一起变更的类应该放在同一个服务中。减少跨服务协调发布。
3. 康威定律
"设计系统的架构受制于产生这些设计的组织的沟通结构。"
团队结构应该与微服务边界对齐。跨团队的频繁协调说明拆分不合理。
4. 两步拆分法(Sam Newman)
Step 1: 识别上下文边界(Strategic DDD)
└── 事件风暴工作坊 → 识别聚合、领域事件
Step 2: 按优先级逐步拆分
└── 优先拆分:变更最频繁的、性能瓶颈最明显的、团队冲突最大的
拆分粒度判断:
- 过小:服务间调用占比超过业务代码的 50%,网络开销成为瓶颈
- 过大:一个服务需要多人协作,发布频率超过每天一次仍需要协调
- 合适标准:一个小团队(2-5 人)能独立维护和演进
2. 服务治理
2.1 服务注册与发现
TL;DR:服务实例动态注册到注册中心,消费者通过注册中心查询可用实例,实现服务间的动态寻址。
1. 场景与背景
微服务环境中:
- 服务实例动态扩缩容,IP 和端口不断变化
- 服务故障后需要自动剔除 unhealthy 实例
- 需要支持多环境(dev/test/prod)的服务隔离
2. 理论原理
服务注册发现的两种模式:
┌─────────────────────────────────────────────┐
│ 客户端发现模式(Client-Side) │
│ ┌─────────┐ ┌──────────┐ ┌─────────┐ │
│ │ Service │───▶│ Registry │───▶│ Service │ │
│ │ A │◀───│ (Eureka) │ │ B │ │
│ └─────────┘ └──────────┘ └─────────┘ │
│ │ ▲ │
│ └──────直接调用(已缓存地址)──────┘ │
└─────────────────────────────────────────────┘
┌─────────────────────────────────────────────┐
│ 服务端发现模式(Server-Side) │
│ ┌─────────┐ ┌──────────┐ ┌─────────┐ │
│ │ Service │───▶│ LB/API │───▶│ Service │ │
│ │ A │ │ Gateway │ │ B │ │
│ └─────────┘ └────┬─────┘ └─────────┘ │
│ │ │
│ ┌──┴──┐ │
│ │Registry│ │
│ └─────┘ │
└─────────────────────────────────────────────┘
对比:
| 维度 | 客户端发现 | 服务端发现 |
|---|---|---|
| 代表实现 | Eureka + Ribbon, Consul | Kubernetes Service, AWS ALB |
| 优点 | 无中间跳点,延迟低;客户端可定制负载均衡策略 | 客户端简单,无需感知服务发现 |
| 缺点 | 客户端需集成 SDK;语言绑定 | 多一跳网络延迟;负载均衡策略受限 |
| 适用场景 | 同构技术栈(如全 Java) | 多语言混合、容器化环境 |
3. 代码示例:基于 Consul 的服务注册
// 服务注册
func RegisterService(consulAddr, serviceName, serviceID string, port int) error {
config := api.DefaultConfig()
config.Address = consulAddr
client, err := api.NewClient(config)
if err != nil {
return err
}
// 健康检查配置
check := &api.AgentServiceCheck{
HTTP: fmt.Sprintf("http://localhost:%d/health", port),
Interval: "10s",
Timeout: "5s",
DeregisterCriticalServiceAfter: "30s", // 30s 不健康自动注销
}
registration := &api.AgentServiceRegistration{
ID: serviceID, // 唯一标识,格式:serviceName-hostname-port
Name: serviceName,
Port: port,
Tags: []string{"v1", "go"},
Check: check,
Meta: map[string]string{
"version": "1.0.0",
"region": "us-east-1",
},
}
return client.Agent().ServiceRegister(registration)
}
// 服务发现 + 客户端负载均衡
type ConsulDiscovery struct {
client *api.Client
}
func (d *ConsulDiscovery) Discover(serviceName string) (*api.AgentService, error) {
services, _, err := d.client.Health().Service(serviceName, "", true, nil)
if err != nil {
return nil, err
}
if len(services) == 0 {
return nil, fmt.Errorf("no healthy instances of %s", serviceName)
}
// 简单轮询负载均衡
idx := rand.Intn(len(services))
return services[idx].Service, nil
}4. 业界实践
Netflix Eureka 设计:
- AP 设计:优先保证可用性,集群间数据最终一致
- 自我保护机制:当心跳丢失比例超过 85% 时,停止剔除服务(防止网络分区误杀)
- 客户端缓存:Eureka Client 本地缓存注册表,注册中心故障时仍能提供服务发现
Kubernetes DNS 发现:
# 集群内通过 DNS 发现服务
http://service-name.namespace.svc.cluster.local:port
# CoreDNS 配置自动将 Service 名解析为 ClusterIP
# EndpointSlice 维护后端 Pod IP 列表
5. 常见误区
❌ 注册中心单点:生产环境必须集群部署,否则注册中心故障导致全系统不可用 ❌ 无健康检查:只注册不检查,调用到已故障的实例 ❌ 长连接不更新:客户端缓存长期不刷新,新扩容的实例接收不到流量
✅ 多可用区部署:注册中心跨 AZ 部署,避免单点 ✅ 多级健康检查:Liveness(进程存活)+ Readiness(业务就绪) ✅ 平滑发布:先注册新实例,等待健康检查通过后,再下线旧实例
2.2 配置中心
TL;DR:集中管理多环境配置,支持动态推送和版本回滚,避免配置散落在代码和启动参数中。
核心能力矩阵
| 能力 | 说明 | 代表产品 |
|---|---|---|
| 配置集中管理 | 统一管理所有服务的配置 | Apollo, Nacos, Spring Cloud Config |
| 环境隔离 | dev/test/staging/prod 环境隔离 | 命名空间(Namespace)机制 |
| 动态推送 | 配置变更实时推送到客户端 | 长轮询(Long Polling)/ WebSocket |
| 灰度发布 | 按 IP、标签、百分比灰度推送 | 灰度规则引擎 |
| 版本管理 | 配置历史版本和一键回滚 | Git 后端存储 |
| 权限控制 | 配置的读写权限分离 | RBAC |
Apollo 架构:
┌─────────────┐ ┌──────────────┐ ┌─────────────┐
│ Admin │────▶│ Config │◀────│ Client │
│ Service │ │ Service │ │ (长轮询) │
│ (管理界面) │ │ (配置推送) │ │ │
└─────────────┘ └──────┬───────┘ └─────────────┘
│
┌──────┴──────┐
│ Meta DB │
│ (MySQL) │
└─────────────┘
动态配置代码示例:
// 监听配置变更
type ConfigWatcher struct {
apolloClient agollo.Client
callbacks map[string]func(string)
}
func (w *ConfigWatcher) Watch(key string, callback func(string)) {
w.callbacks[key] = callback
// 使用 Apollo 的变更监听
w.apolloClient.AddChangeListener(func(event *storage.ChangeEvent) {
for k, change := range event.Changes {
if cb, ok := w.callbacks[k]; ok {
cb(change.NewValue)
}
}
})
}
// 使用:动态调整日志级别
watcher.Watch("logging.level", func(newLevel string) {
level, _ := zapcore.ParseLevel(newLevel)
logger.Core().With([]zapcore.Field{})
zap.ReplaceGlobals(logger.WithOptions(zap.IncreaseLevel(level)))
})
// 使用:动态调整限流阈值
watcher.Watch("rate.limit.qps", func(newQPS string) {
qps, _ := strconv.Atoi(newQPS)
limiter.SetRate(rate.Limit(qps))
})2.3 灰度发布与金丝雀发布
TL;DR:灰度发布是将新版本先暴露给小部分用户,验证稳定后再全量 rollout;金丝雀发布是其一种实现方式。
灰度策略对比
| 策略 | 机制 | 风险 | 适用场景 |
|---|---|---|---|
| 金丝雀(Canary) | 先 1% → 5% → 25% → 100% 逐步放量 | 低 | 大多数场景 |
| 蓝绿部署(Blue-Green) | 两套环境切换,零停机 | 中(资源翻倍) | 需要快速回滚 |
| A/B 测试 | 按用户特征分流到不同版本 | 低 | 功能对比实验 |
| 影子流量(Shadow) | 复制生产流量到新版本,不返回结果 | 极低 | 压力测试 |
基于网关的灰度路由:
// 灰度路由规则引擎
type GrayRule struct {
Version string // 目标版本 v2
Percentage int // 流量百分比 10
HeaderMatch map[string]string // header 匹配: {"X-Gray-Version": "v2"}
CookieMatch map[string]string // cookie 匹配
IPList []string // IP 白名单
}
func (r *GrayRouter) Route(req *http.Request) (string, error) {
// 1. 优先精确匹配(Header/Cookie/IP)
for _, rule := range r.rules {
if r.matchHeader(req, rule.HeaderMatch) ||
r.matchCookie(req, rule.CookieMatch) ||
r.matchIP(req, rule.IPList) {
return rule.Version, nil
}
}
// 2. 按百分比随机分流
hash := crc32.ChecksumIEEE([]byte(req.Header.Get("X-Request-ID")))
bucket := hash % 100
cumulative := 0
for _, rule := range r.rules {
cumulative += rule.Percentage
if bucket < uint32(cumulative) {
return rule.Version, nil
}
}
return "stable", nil // 默认稳定版本
}Kubernetes 原生灰度(Deployment + Service):
# 稳定版本 Deployment
apiVersion: apps/v1
kind: Deployment
metadata:
name: app-stable
spec:
replicas: 9
selector:
matchLabels:
app: myapp
version: stable
---
# 金丝雀版本 Deployment
apiVersion: apps/v1
kind: Deployment
metadata:
name: app-canary
spec:
replicas: 1 # 10% 流量
selector:
matchLabels:
app: myapp
version: canary
---
# Service 同时选中两个版本
apiVersion: v1
kind: Service
metadata:
name: myapp
spec:
selector:
app: myapp # 匹配 stable + canary
ports:
- port: 803. API 网关
3.1 API 网关核心功能
TL;DR:API 网关是微服务的统一入口,承担路由转发、认证鉴权、限流熔断、协议转换等横切关注点。
网关功能分层
┌─────────────────────────────────────────────┐
│ L7 流量管理层 │
│ ├─ 路由(Path/Host/Header 匹配) │
│ ├─ 负载均衡(Round Robin/Least Conn) │
│ └─ 灰度发布(百分比/Header 分流) │
├─────────────────────────────────────────────┤
│ 安全认证层 │
│ ├─ JWT/OAuth2 认证 │
│ ├─ API Key 管理 │
│ ├─ HTTPS/TLS 终止 │
│ └─ WAF(SQL 注入/XSS 防护) │
├─────────────────────────────────────────────┤
│ 流量控制层 │
│ ├─ 限流(Token Bucket/Sliding Window) │
│ ├─ 熔断(Circuit Breaker) │
│ └─ 降级(Fallback) │
├─────────────────────────────────────────────┤
│ 协议转换层 │
│ ├─ HTTP ↔ gRPC │
│ ├─ REST ↔ GraphQL │
│ └─ WebSocket 代理 │
├─────────────────────────────────────────────┤
│ 可观测性层 │
│ ├─ 日志(Access Log) │
│ ├─ 指标(QPS/延迟/错误率) │
│ └─ 链路追踪(Trace ID 注入) │
└─────────────────────────────────────────────┘
主流网关对比
| 特性 | Kong | Spring Cloud Gateway | Nginx + Lua | Envoy |
|---|---|---|---|---|
| 架构 | OpenResty (Lua) | Java (WebFlux) | Nginx C + Lua | C++ |
| 性能 | 高 | 中 | 很高 | 很高 |
| 插件生态 | 丰富(150+) | Spring 生态 | 自定义 Lua | WASM |
| 动态配置 | 支持 | 支持 | 需 reload | 支持(xDS) |
| Service Mesh | 需集成 | 不适用 | 不适用 | Istio 默认 |
| 协议支持 | HTTP/gRPC | HTTP/WebFlux | HTTP/gRPC | HTTP/gRPC/Redis |
代码示例:Hertz 网关路由实现
// 基于 CloudWeGo Hertz 的 API 网关路由
func SetupGatewayRoutes(h *server.Hertz) {
// 全局中间件(按顺序执行)
h.Use(
middleware.Recovery(),
middleware.CORS(),
middleware.RequestID(),
middleware.Logger(),
middleware.Tracing(),
)
// 公共 API(无需认证)
public := h.Group("/api/v1/public")
{
public.GET("/health", handlers.HealthCheck)
public.POST("/auth/login", handlers.Login)
}
// 认证中间件组
auth := h.Group("/api/v1")
auth.Use(middleware.JWTAuth())
{
// 用户服务路由
auth.GET("/users/:id", proxyTo("user-service"))
auth.PUT("/users/:id", proxyTo("user-service"))
// 订单服务路由(附带限流)
order := auth.Group("/orders")
order.Use(middleware.RateLimit(100, time.Minute))
{
order.POST("/", proxyTo("order-service"))
order.GET("/:id", proxyTo("order-service"))
}
// 商品服务路由(附带熔断)
auth.GET("/products/:id",
middleware.CircuitBreaker("product-service", breakerConfig),
proxyTo("product-service"),
)
}
}
// 反向代理到下游服务
func proxyTo(serviceName string) app.HandlerFunc {
return func(ctx context.Context, c *app.RequestContext) {
// 1. 服务发现
instance, err := discovery.Resolve(serviceName)
if err != nil {
c.JSON(503, map[string]string{"error": "service unavailable"})
return
}
// 2. 构建转发请求
targetURL := fmt.Sprintf("http://%s%s", instance.Address, c.Request.URI().Path())
// 3. 复制 Header(含 Trace ID)
client := &http.Client{Timeout: 5 * time.Second}
req, _ := http.NewRequestWithContext(ctx, string(c.Method()), targetURL, c.Request.BodyStream())
c.Request.Header.VisitAll(func(key, value []byte) {
req.Header.Set(string(key), string(value))
})
// 4. 执行代理
resp, err := client.Do(req)
if err != nil {
c.JSON(502, map[string]string{"error": "bad gateway"})
return
}
defer resp.Body.Close()
// 5. 回写响应
c.SetStatusCode(resp.StatusCode)
for k, v := range resp.Header {
c.Header(k, v[0])
}
io.Copy(c.Writer(), resp.Body)
}
}3.2 认证与鉴权
TL;DR:网关层统一处理认证(你是谁),下游服务处理鉴权(你能做什么),通过 Token 携带身份信息。
JWT 认证流程
┌─────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────┐
│ Client │───▶│ API Gateway │───▶│ Auth Service│ │ Service │
│ │ │ │ │ │ │ │
│ login() │───▶│ /auth/login │───▶│ verify() │ │ │
│ │◀───│ return JWT │◀───│ sign token │ │ │
│ │ │ │ │ │ │ │
│ API + │───▶│ validate │ │ │───▶│ business│
│ JWT │ │ JWT (网关层) │ │ │ │ logic │
│ │◀───│ proxy + │◀───│ │◀───│ │
│ │ │ inject user │ │ │ │ │
└─────────┘ └─────────────┘ └─────────────┘ └─────────┘
网关层 JWT 验证:
func JWTAuth() app.HandlerFunc {
return func(ctx context.Context, c *app.RequestContext) {
token := extractBearerToken(c)
if token == "" {
c.AbortWithStatusJSON(401, map[string]string{"error": "missing token"})
return
}
// 验证 JWT(网关层只做签名验证,不查库)
claims, err := jwt.Parse(token, func(t *jwt.Token) (interface{}, error) {
return publicKey, nil
})
if err != nil || !claims.Valid {
c.AbortWithStatusJSON(401, map[string]string{"error": "invalid token"})
return
}
// 将用户信息注入上下文,下游服务无需再次解析
userClaims := claims.Claims.(jwt.MapClaims)
c.Set("user_id", userClaims["sub"])
c.Set("roles", userClaims["roles"])
c.Set("permissions", userClaims["permissions"])
c.Next(ctx)
}
}下游服务 RBAC 鉴权:
func RequirePermission(permission string) app.HandlerFunc {
return func(ctx context.Context, c *app.RequestContext) {
perms, _ := c.Get("permissions")
userPerms := perms.([]string)
if !slices.Contains(userPerms, permission) {
c.AbortWithStatusJSON(403, map[string]string{"error": "forbidden"})
return
}
c.Next(ctx)
}
}
// 使用
auth.POST("/admin/users", RequirePermission("user:create"), handlers.CreateUser)4. 链路追踪与分布式追踪
4.1 分布式链路追踪原理
TL;DR:通过 Trace ID 串联跨服务的请求链,记录每个 Span 的耗时和元数据,用于定位性能瓶颈和故障根因。
核心概念
| 概念 | 说明 | 类比 |
|---|---|---|
| Trace | 一次完整的端到端请求链路 | 一次快递从发货到签收的完整路径 |
| Span | 链路中的一个操作单元 | 快递经过的每一个站点 |
| Parent Span | 调用方的 Span | 上一级站点 |
| Child Span | 被调用方的 Span | 下一级站点 |
| Baggage | 跨 Span 传递的自定义数据 | 快递单上的备注信息 |
Trace 上下文传播:
┌──────────┐ TraceID: abc123 ┌──────────┐ TraceID: abc123 ┌──────────┐
│ Gateway │────────────────────▶│ Order │────────────────────▶│ Payment │
│ │ SpanID: span-1 │ Service │ SpanID: span-2 │ Service │
│ │ │ │ Parent: span-1 │ │
└──────────┘ └──────────┘ └──────────┘
│ │ │
│ HTTP Header: │ gRPC Metadata: │
│ X-Trace-ID: abc123 │ x-trace-id: abc123 │
│ X-Span-ID: span-1 │ x-parent-span-id: span-2│
│ │ │
OpenTelemetry 标准
OpenTelemetry(OTel)是 CNCF 项目,统一了 Metrics、Logs、Traces 的采集标准。
W3C Trace Context 标准:
# 请求头中传递的 Trace 上下文
traceparent: 00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01
# │ │ │ │
# │ │ │ └── flags (sampled)
# │ │ └── parent span id
# │ └── trace id (16 bytes hex)
# └── version
tracestate: congo=t61rcWkgMzE,rojo=00f067aa0ba902b7代码示例:Go 中实现链路追踪
// 初始化 Tracer Provider
func InitTracer(serviceName, endpoint string) (*sdktrace.TracerProvider, error) {
ctx := context.Background()
// OTLP gRPC Exporter
exp, err := otlptracegrpc.New(ctx,
otlptracegrpc.WithEndpoint(endpoint),
otlptracegrpc.WithInsecure(),
)
if err != nil {
return nil, err
}
tp := sdktrace.NewTracerProvider(
sdktrace.WithBatcher(exp),
sdktrace.WithResource(resource.NewWithAttributes(
semconv.SchemaURL,
semconv.ServiceNameKey.String(serviceName),
semconv.ServiceVersionKey.String("1.0.0"),
attribute.String("environment", "production"),
)),
)
otel.SetTracerProvider(tp)
return tp, nil
}
// HTTP 中间件:自动注入 Trace
func TracingMiddleware() app.HandlerFunc {
tracer := otel.Tracer("http-server")
return func(ctx context.Context, c *app.RequestContext) {
// 从请求头提取 Parent Span
propagator := propagation.TraceContext{}
ctx = propagator.Extract(ctx, carrierAdapter(c))
// 创建新的 Span
ctx, span := tracer.Start(ctx, fmt.Sprintf("%s %s", c.Method(), c.Path()),
trace.WithAttributes(
attribute.String("http.method", string(c.Method())),
attribute.String("http.path", string(c.Path())),
attribute.String("http.target", string(c.URI().Path())),
),
)
defer span.End()
// 将 Trace 信息写回响应头(便于客户端关联)
propagator.Inject(ctx, carrierAdapter(c))
c.Next(ctx)
// 记录响应状态
span.SetAttributes(attribute.Int("http.status_code", c.Response.StatusCode()))
if c.Response.StatusCode() >= 500 {
span.SetStatus(codes.Error, "server error")
}
}
}
// RPC 调用时传播 Trace
func CallWithTrace(ctx context.Context, client RPCClient, method string, req, resp interface{}) error {
tracer := otel.Tracer("rpc-client")
ctx, span := tracer.Start(ctx, method,
trace.WithAttributes(
attribute.String("rpc.system", "kitex"),
attribute.String("rpc.method", method),
),
)
defer span.End()
// 将 Trace 上下文注入到 RPC Metadata
md := metadata.MD{}
otel.GetTextMapPropagator().Inject(ctx, metadataCarrier(md))
ctx = metadata.NewOutgoingContext(ctx, md)
err := client.Call(ctx, method, req, resp)
if err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, err.Error())
}
return err
}采样策略
// 头部采样:根据 TraceID 哈希决定是否采样
func HeadBasedSampler(fraction float64) sdktrace.Sampler {
return sdktrace.TraceIDRatioBased(fraction) // 例如 0.1 = 10%
}
// 尾部采样:先缓存所有 Span,根据规则决定是否保留整个 Trace
// Jaeger 支持:错误率 > 5% 的 Trace 必采;延迟 > P99 的 Trace 必采
func TailBasedSampler() *jaegercfg.Reporter {
// 配置尾部采样规则
return &jaegercfg.Reporter{
LocalAgentHostPort: "jaeger-agent:6831",
// Tail-based 需要 collector 端配置
}
}采样策略对比:
| 策略 | 原理 | 优点 | 缺点 |
|---|---|---|---|
| 头部采样(Head) | 请求入口处决定是否采样 | 实现简单,资源可控 | 可能漏采重要 Trace |
| 尾部采样(Tail) | 收集完整 Trace 后按规则过滤 | 不漏采异常/慢请求 | 内存消耗大 |
| 自适应采样 | 根据系统负载动态调整 | 自动平衡精度与开销 | 实现复杂 |
5. 容器化技术
5.1 Docker 核心原理
TL;DR:Docker 利用 Linux Namespace 实现进程隔离、CGroup 实现资源限制、UnionFS 实现镜像分层,是轻量级的操作系统级虚拟化。
三大核心技术
┌─────────────────────────────────────────────┐
│ Linux Namespace(隔离) │
├─────────────────────────────────────────────┤
│ PID Namespace │ 进程 ID 隔离 │
│ NET Namespace │ 网络栈隔离(网卡/IP/路由) │
│ MNT Namespace │ 文件系统挂载点隔离 │
│ IPC Namespace │ 进程间通信隔离 │
│ UTS Namespace │ 主机名/域名隔离 │
│ USER Namespace │ 用户权限隔离 │
└─────────────────────────────────────────────┘
┌─────────────────────────────────────────────┐
│ CGroup(资源限制) │
├─────────────────────────────────────────────┤
│ cpu │ CPU 时间片分配/权重 │
│ memory │ 内存限额 + OOM 策略 │
│ blkio │ 块设备 I/O 限制 │
│ pids │ 进程数限制 │
│ devices │ 设备访问白名单 │
└─────────────────────────────────────────────┘
┌─────────────────────────────────────────────┐
│ UnionFS(镜像分层) │
├─────────────────────────────────────────────┤
│ Layer N (RW) │ 容器读写层(Container Layer)│
│ Layer 2 │ 应用层(APP) │
│ Layer 1 │ 运行时层(Go/Python/Node) │
│ Layer 0 │ 基础系统层(Alpine/Ubuntu) │
│ BootFS │ 引导层(只读,启动后卸载) │
└─────────────────────────────────────────────┘
Dockerfile 最佳实践
# ❌ 反模式
FROM ubuntu:latest # 非确定性版本
RUN apt-get update && apt-get install -y golang # 单一层安装
COPY . /app # 复制所有文件(含 .git, vendor)
RUN go build -o server # 无缓存优化
# ✅ 最佳实践
# 1. 使用确定性基础镜像 + 多阶段构建
FROM golang:1.22-alpine AS builder
WORKDIR /build
# 2. 先复制依赖文件,利用缓存层
COPY go.mod go.sum ./
RUN go mod download
# 3. 再复制源码(只有源码变更时才重新构建)
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-w -s" -o server ./cmd/server
# 4. 使用 distroless 或 alpine 作为运行镜像
FROM gcr.io/distroless/static:nonroot
WORKDIR /app
# 5. 仅复制构建产物
COPY --from=builder /build/server /app/server
COPY --from=builder /build/configs /app/configs
# 6. 非 root 运行
USER nonroot:nonroot
EXPOSE 8080
ENTRYPOINT ["/app/server"]Dockerfile 优化原则:
| 原则 | 说明 | 收益 |
|---|---|---|
| 多阶段构建 | 构建和运行分离 | 镜像从 GB 降到 20MB |
| 层缓存优化 | 不常变更的依赖放前面 | 加速构建 |
| 最小化基础镜像 | 使用 alpine/distroless/scratch | 减少攻击面 |
| .dockerignore | 排除不必要的文件 | 减小构建上下文 |
| 非 Root 运行 | USER 指令指定低权限用户 | 安全加固 |
| 单一进程 | 一个容器一个主进程 | 符合容器哲学 |
容器 vs VM 对比
| 维度 | Docker 容器 | 虚拟机 |
|---|---|---|
| 启动速度 | 秒级 | 分钟级 |
| 资源占用 | MB 级 | GB 级 |
| 隔离级别 | 进程级(Namespace) | 硬件级(Hypervisor) |
| 性能损耗 | < 5% | 10-20% |
| 镜像大小 | 几十 MB | 几 GB |
| 适用场景 | 微服务、CI/CD | 强隔离、多租户 |
5.2 容器网络
TL;DR:Docker 提供 Bridge(默认)、Host、None、Overlay 等网络模式,Kubernetes 在此之上构建了更复杂的 Pod 网络模型。
Docker 网络模式:
| 模式 | 说明 | 适用场景 |
|---|---|---|
| Bridge | 默认模式,容器通过 docker0 网桥通信 | 单机多容器 |
| Host | 容器共享宿主机网络栈 | 高性能网络需求 |
| None | 无网络 | 自定义网络栈 |
| Overlay | 跨主机容器通信(VxLAN) | Docker Swarm |
| Macvlan | 容器获得独立 MAC 地址 | 需要直连物理网络 |
容器网络核心问题:
问题 1:容器间如何通信?
└── 同一主机:veth pair + linux bridge
└── 跨主机:Overlay 网络(VxLAN)或 BGP 路由
问题 2:容器如何访问外网?
└── SNAT:iptables MASQUERADE 规则,源地址替换为宿主机 IP
问题 3:外网如何访问容器?
└── DNAT:端口映射 -p 8080:80,将宿主机 8080 转发到容器 80
└── 或负载均衡器(如 K8s Service)
6. Kubernetes 核心原理
6.1 K8s 架构与核心组件
TL;DR:Kubernetes 是容器编排平台,通过声明式 API 管理容器化应用的生命周期,核心组件包括 API Server、etcd、Scheduler、Controller Manager、Kubelet、Kube-proxy。
架构概览
┌──────────────────────────────────────────────────────────────┐
│ Control Plane │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────┐ │
│ │ API Server │ │ etcd │ │ Controller Manager │ │
│ │ (REST API) │ │ (状态存储) │ │ (Deployment/RS/...) │ │
│ └──────┬──────┘ └─────────────┘ └─────────────────────┘ │
│ │ ┌─────────────┐ │
│ └────────▶│ Scheduler │ │
│ │ (调度决策) │ │
│ └─────────────┘ │
└──────────────────────────────────────────────────────────────┘
│
┌──────────────────────────────────────────────────────────────┐
│ Worker Node │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────┐ │
│ │ Kubelet │ │ Kube-proxy │ │ Container Runtime │ │
│ │ (Pod 管理) │ │ (网络代理) │ │ (containerd/CRI-O)│ │
│ └──────┬──────┘ └─────────────┘ └─────────────────────┘ │
│ │ │
│ ┌────┴────┐ │
│ │ Pod │ │
│ │ ┌─────┐ │ │
│ │ │App A│ │ │
│ │ │App B│ │ ← 同一 Pod 共享网络/存储(Sidecar 模式) │
│ │ └─────┘ │ │
│ └─────────┘ │
└──────────────────────────────────────────────────────────────┘
核心组件职责
| 组件 | 职责 | 类比 |
|---|---|---|
| API Server | 所有操作的统一入口,验证和转发请求 | 公司前台 |
| etcd | 分布式键值存储,保存集群所有状态 | 档案室 |
| Scheduler | 根据资源需求和策略将 Pod 调度到 Node | 调度员 |
| Controller Manager | 维护期望状态与实际状态一致 | 监控中心 |
| Kubelet | 节点上的 Pod 生命周期管理 | 车间主任 |
| Kube-proxy | 维护 Service 的网络规则和负载均衡 | 门卫 |
代码示例:声明式工作负载
# Deployment:无状态应用
apiVersion: apps/v1
kind: Deployment
metadata:
name: api-server
labels:
app: api-server
spec:
replicas: 3 # 期望副本数
strategy:
type: RollingUpdate
rollingUpdate:
maxSurge: 25% # 升级时最多多创建 25%
maxUnavailable: 25% # 升级时最多不可用 25%
selector:
matchLabels:
app: api-server
template:
metadata:
labels:
app: api-server
version: v1.2.0
spec:
affinity:
podAntiAffinity: # 反亲和性:Pod 分散在不同节点
preferredDuringSchedulingIgnoredDuringExecution:
- weight: 100
podAffinityTerm:
labelSelector:
matchExpressions:
- key: app
operator: In
values:
- api-server
topologyKey: kubernetes.io/hostname
containers:
- name: api-server
image: myapp/api-server:v1.2.0
ports:
- containerPort: 8080
resources:
requests:
memory: "256Mi"
cpu: "250m"
limits:
memory: "512Mi"
cpu: "500m"
livenessProbe: # 存活探针
httpGet:
path: /health
port: 8080
initialDelaySeconds: 10
periodSeconds: 10
readinessProbe: # 就绪探针
httpGet:
path: /ready
port: 8080
initialDelaySeconds: 5
periodSeconds: 5
env:
- name: DB_HOST
valueFrom:
configMapKeyRef:
name: app-config
key: db.host# StatefulSet:有状态应用(数据库、消息队列)
apiVersion: apps/v1
kind: StatefulSet
metadata:
name: mongodb
spec:
serviceName: mongodb-headless # Headless Service,用于 DNS 发现
replicas: 3
selector:
matchLabels:
app: mongodb
template:
metadata:
labels:
app: mongodb
spec:
containers:
- name: mongodb
image: mongo:6.0
ports:
- containerPort: 27017
volumeMounts:
- name: data
mountPath: /data/db
volumeClaimTemplates: # 每个 Pod 独立 PVC
- metadata:
name: data
spec:
accessModes: ["ReadWriteOnce"]
storageClassName: "fast-ssd"
resources:
requests:
storage: 100Gi6.2 Pod 调度原理
TL;DR:Scheduler 通过 Predicate(过滤)+ Priority(打分)两阶段算法,将 Pod 绑定到最合适的 Node。
调度流程
┌─────────────────────────────────────────────────────────────┐
│ 调度流程(Filter + Score) │
├─────────────────────────────────────────────────────────────┤
│ 1. 获取待调度 Pod │
│ 2. 获取所有可用 Node 列表 │
│ 3. 【Predicate 阶段】过滤不满足条件的 Node │
│ ├── PodFitsResources: 资源是否充足(requests) │
│ ├── PodFitsHost: 是否匹配 nodeName │
│ ├── PodFitsHostPorts: 端口是否冲突 │
│ ├── MatchNodeSelector: 是否匹配节点标签 │
│ ├── NoVolumeZoneConflict: 存储可用区匹配 │
│ └── ... │
│ 4. 【Priority 阶段】为剩余 Node 打分 │
│ ├── LeastRequestedPriority: 选择负载最低的节点 │
│ ├── BalancedResourceAllocation: CPU/内存分配最均衡 │
│ ├── InterPodAffinityPriority: Pod 亲和性偏好 │
│ └── ... │
│ 5. 选择得分最高的 Node │
│ 6. 绑定 Pod 到 Node(写入 etcd) │
└─────────────────────────────────────────────────────────────┘
自定义调度器:
// 通过 Pod 的 spec.schedulerName 指定自定义调度器
apiVersion: v1
kind: Pod
spec:
schedulerName: my-custom-scheduler // 默认是 "default-scheduler"
// 实现 Framework 扩展点
type MyScheduler struct {
handle framework.Handle
}
func (s *MyScheduler) Filter(ctx context.Context, state *framework.CycleState,
pod *v1.Pod, nodeInfo *framework.NodeInfo) *framework.Status {
// 自定义过滤逻辑:例如要求 GPU 型号
gpuModel := nodeInfo.Node().Labels["gpu.model"]
if gpuModel != "nvidia-a100" {
return framework.NewStatus(framework.Unschedulable, "GPU model mismatch")
}
return nil
}6.3 K8s 网络模型
TL;DR:Kubernetes 要求每个 Pod 拥有独立 IP,Pod 间可直接通信(无需 NAT),Service 通过 kube-proxy 实现虚拟 IP 的负载均衡。
核心网络要求:
| 规则 | 说明 |
|---|---|
| 每个 Pod 一个 IP | Pod IP 在集群内唯一且可直接访问 |
| Pod 间无 NAT | 容器看到对方的源 IP 就是 Pod IP |
| Node 可与 Pod 通信 | Node 的 IP 和 Pod IP 互通 |
Service 类型对比:
| 类型 | 说明 | 适用场景 |
|---|---|---|
| ClusterIP | 集群内部虚拟 IP,仅集群内访问 | 内部服务通信 |
| NodePort | 在每个 Node 上开放一个端口 | 开发测试 |
| LoadBalancer | 云厂商负载均衡器(AWS ELB/Azure LB) | 生产环境公网暴露 |
| ExternalName | DNS CNAME 别名 | 外部服务引入 |
| Headless | 无 ClusterIP,直接返回 Pod IP | StatefulSet 服务发现 |
Ingress vs Service:
┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│ Client │────▶│ Ingress │────▶│ Service │────▶│ Pod │
│ │ │ (L7 路由) │ │(L4 负载) │ │ │
└──────────┘ └──────────┘ └──────────┘ └──────────┘
│
├─ /api/v1/users ──▶ user-service:80
├─ /api/v1/orders ──▶ order-service:80
└─ /static/* ──────▶ nginx-static:80
Ingress Controller(如 Nginx Ingress)功能:
- 基于 Host/Path 的 L7 路由
- TLS 终止(HTTPS)
- 重写/重定向
- 限流(rate limiting)
- 白名单/黑名单
- 灰度发布(canary)
6.4 K8s 存储
TL;DR:Kubernetes 通过 PV/PVC/StorageClass 实现存储的抽象和动态供给,支持云盘、NFS、本地盘等多种后端。
┌─────────────────────────────────────────────────────────────┐
│ 存储抽象层次 │
├─────────────────────────────────────────────────────────────┤
│ StorageClass (fast-ssd) │
│ ├── provisioner: kubernetes.io/aws-ebs │
│ ├── parameters: type=gp3, iops=10000 │
│ └── reclaimPolicy: Retain │
│ │
│ PersistentVolumeClaim (PVC) │
│ ├── storageClassName: fast-ssd │
│ ├── accessModes: ReadWriteOnce │
│ └── resources.requests.storage: 100Gi │
│ │
│ PersistentVolume (PV) —— 由 Provisioner 动态创建 │
│ ├── awsElasticBlockStore: volumeID=vol-xxx │
│ └── capacity: 100Gi │
└─────────────────────────────────────────────────────────────┘
Volume 类型对比:
| 类型 | 生命周期 | 多节点读写 | 适用场景 |
|---|---|---|---|
| emptyDir | Pod | 否 | 临时缓存 |
| hostPath | Node | 否 | 节点日志收集 |
| PVC (云盘) | 持久 | 否 | 数据库 |
| PVC (NFS/EFS) | 持久 | 是 | 共享存储 |
| ConfigMap/Secret | 持久 | 是 | 配置注入 |
| downwardAPI | Pod | 是 | Pod 元数据注入 |
7. 可观测性体系
7.1 三大支柱:Metrics / Logging / Tracing
TL;DR:可观测性通过 Metrics(指标)、Logs(日志)、Traces(链路)三个维度,回答系统"发生了什么""为什么发生""在哪里发生"。
三者关系
┌─────────────────────────────────────────────────────────────┐
│ 可观测性三大支柱 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────┐ │
│ │ Metrics │ │ Logs │ │ Traces │ │
│ │ (指标) │ │ (日志) │ │ (链路) │ │
│ │ │ │ │ │ │ │
│ │ "What" │ │ "Why" │ │ "Where" │ │
│ │ QPS/错误率 │ │ 错误详情 │ │ 跨服务路径 │ │
│ │ CPU/内存 │ │ 请求参数 │ │ 各阶段耗时 │ │
│ │ 延迟分位 │ │ 堆栈信息 │ │ 依赖拓扑 │ │
│ └──────┬──────┘ └──────┬──────┘ └────────┬────────┘ │
│ │ │ │ │
│ └────────────────┼────────────────────┘ │
│ │ │
│ ┌──────┴──────┐ │
│ │ Correlation │ │
│ │ (Trace ID) │ │
│ └─────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
Metrics 体系
指标类型:
| 类型 | 说明 | 示例 |
|---|---|---|
| Counter | 单调递增的计数器 | 请求总数、错误总数 |
| Gauge | 可增可减的瞬时值 | 当前连接数、内存使用量 |
| Histogram | 采样分布(桶计数) | 请求延迟分布 |
| Summary | 分位值计算 | P99 延迟 |
Prometheus 数据模型:
# Counter 示例
http_requests_total{method="POST", handler="/api/orders", status="200"} 1027
# Histogram 示例
http_request_duration_seconds_bucket{le="0.1"} 245
http_request_duration_seconds_bucket{le="0.5"} 892
http_request_duration_seconds_bucket{le="1.0"} 990
http_request_duration_seconds_bucket{le="+Inf"} 1027
http_request_duration_seconds_sum 420.5
http_request_duration_seconds_count 1027
Go 中暴露 Prometheus 指标:
var (
httpRequests = promauto.NewCounterVec(prometheus.CounterOpts{
Name: "http_requests_total",
Help: "Total number of HTTP requests",
}, []string{"method", "path", "status"})
httpDuration = promauto.NewHistogramVec(prometheus.HistogramOpts{
Name: "http_request_duration_seconds",
Help: "HTTP request latency",
Buckets: prometheus.DefBuckets, // [.005, .01, .025, .05, .1, .25, .5, 1, 2.5, 5, 10]
}, []string{"method", "path"})
activeConnections = promauto.NewGauge(prometheus.GaugeOpts{
Name: "active_connections",
Help: "Number of active connections",
})
)
func MetricsMiddleware() app.HandlerFunc {
return func(ctx context.Context, c *app.RequestContext) {
start := time.Now()
activeConnections.Inc()
defer activeConnections.Dec()
c.Next(ctx)
duration := time.Since(start).Seconds()
status := strconv.Itoa(c.Response.StatusCode())
path := string(c.Path())
method := string(c.Method())
httpRequests.WithLabelValues(method, path, status).Inc()
httpDuration.WithLabelValues(method, path).Observe(duration)
}
}Logging 体系
日志级别规范:
| 级别 | 使用场景 | 生产环境是否开启 |
|---|---|---|
| DEBUG | 开发调试细节 | 否(采样开启) |
| INFO | 正常业务流程 | 是 |
| WARN | 异常但可恢复 | 是 |
| ERROR | 功能受损,需人工介入 | 是(告警) |
| FATAL | 系统无法运行 | 是(立即告警) |
结构化日志(JSON)vs 非结构化:
// ❌ 非结构化(难以解析和检索)
log.Printf("User %d failed to create order %s: %v", userID, orderID, err)
// ✅ 结构化(可被 ELK/Loki 索引)
logger.Error("order_creation_failed",
zap.Int64("user_id", userID),
zap.String("order_id", orderID),
zap.String("error", err.Error()),
zap.String("trace_id", traceID), // 关联链路追踪
zap.Duration("elapsed", elapsed),
zap.String("client_ip", clientIP),
)
// 输出:
// {"level":"error","ts":1704067200.123,"msg":"order_creation_failed",
// "user_id":12345,"order_id":"ORD-20240101-001","error":"insufficient stock",
// "trace_id":"abc123","elapsed":0.234,"client_ip":"10.0.1.5"}日志收集架构(ELK / PLG):
┌─────────┐ ┌────────────┐ ┌────────────┐ ┌────────────┐
│ App │───▶│ Filebeat │───▶│ Logstash │───▶│ Elasticsearch│
│(JSON log)│ │(日志收集) │ │(解析/过滤) │ │(存储/索引) │
└─────────┘ └────────────┘ └────────────┘ └─────┬──────┘
│
┌──────┴──────┐
│ Kibana │
│ (查询/可视化) │
└─────────────┘
# 轻量替代方案:PLG (Promtail + Loki + Grafana)
┌─────────┐ ┌────────────┐ ┌────────────┐ ┌────────────┐
│ App │───▶│ Promtail │───▶│ Loki │───▶│ Grafana │
│(stdout) │ │(sidecar) │ │(日志存储) │ │(查询/告警) │
└─────────┘ └────────────┘ └────────────┘ └────────────┘
7.2 告警与 SLO
TL;DR:基于 SLO(服务等级目标)定义可量化的可靠性目标,通过 SLI(指标)监控和告警,避免告警疲劳。
SRE 黄金指标:
| 指标 | 说明 | 典型 SLI |
|---|---|---|
| 延迟(Latency) | 服务响应时间 | P99 < 200ms |
| 流量(Traffic) | 请求量 | QPS |
| 错误(Errors) | 错误率 | 错误率 < 0.1% |
| 饱和度(Saturation) | 资源利用率 | CPU < 70%,内存 < 80% |
SLO 与 Error Budget:
SLO: 99.9% 可用性(每月最多停机 43.8 分钟)
Error Budget: 0.1% = 允许的错误/停机时间配额
使用规则:
- Error Budget 充足 → 可以频繁发布、做实验
- Error Budget 耗尽 → 冻结发布,优先修复稳定性
告警分级:
| 级别 | 名称 | 响应时间 | 通知方式 | 示例 |
|---|---|---|---|---|
| P0 | 紧急 | 5 分钟 | 电话 + 短信 + 钉钉 | 服务完全不可用 |
| P1 | 严重 | 15 分钟 | 短信 + 钉钉 | 错误率 > 5% |
| P2 | 警告 | 1 小时 | 钉钉 | P99 延迟 > SLO |
| P3 | 提示 | 1 天 | 邮件 | 磁盘使用率 > 80% |
Prometheus 告警规则:
groups:
- name: api_alerts
rules:
# 高错误率告警
- alert: HighErrorRate
expr: |
(
sum(rate(http_requests_total{status=~"5.."}[5m]))
/
sum(rate(http_requests_total[5m]))
) > 0.01
for: 2m
labels:
severity: p1
annotations:
summary: "High error rate detected"
description: "Error rate is {{ $value | humanizePercentage }} for {{ $labels.service }}"
# P99 延迟告警
- alert: HighLatency
expr: |
histogram_quantile(0.99,
sum(rate(http_request_duration_seconds_bucket[5m])) by (le, service)
) > 0.5
for: 3m
labels:
severity: p2
annotations:
summary: "P99 latency exceeded"8. 服务网格 Service Mesh
8.1 Service Mesh 原理
TL;DR:Service Mesh 通过 Sidecar 代理(如 Envoy)接管服务间通信,将服务治理(流量管理、安全、观测)从业务代码中剥离。
Sidecar 模式
┌─────────────────────────────────────────────────────────────┐
│ Pod │
│ ┌─────────────────────┐ ┌─────────────────────┐ │
│ │ Application │ │ Envoy │ │
│ │ (业务容器) │ │ (Sidecar) │ │
│ │ │ │ │ │
│ │ 只关心业务逻辑 │◀──▶│ 服务发现 │ │
│ │ localhost:8080 │ │ 负载均衡 │ │
│ │ │ │ 熔断/重试/超时 │ │
│ │ │ │ mTLS 安全 │ │
│ │ │ │ 指标/链路采集 │ │
│ └─────────────────────┘ └─────────────────────┘ │
│ │ │ │
│ └──────── iptables ────────┘ │
│ (透明流量拦截) │
└─────────────────────────────────────────────────────────────┘
Istio 架构:
┌─────────────────────────────────────────────────────────────┐
│ Control Plane │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────┐ │
│ │ istiod │ │ Citadel │ │ Galley │ │
│ │(Pilot组件) │ │(证书管理) │ │(配置验证) │ │
│ │ │ │ │ │ │ │
│ │ - 流量管理 │ │ - mTLS │ │ │ │
│ │ - 服务发现 │ │ - 证书轮换 │ │ │ │
│ │ - 配置下发 │ │ │ │ │ │
│ │ (xDS API) │ │ │ │ │ │
│ └──────┬──────┘ └─────────────┘ └─────────────────────┘ │
│ │ │
│ │ gRPC xDS (Envoy Discovery Service) │
│ │ │
│ ┌──────┴──────────────────────────────────────────────┐ │
│ │ Data Plane │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │
│ │ │ Envoy A │◀────▶│ Envoy B │◀────▶│ Envoy C │ │ │
│ │ │(Sidecar)│ │(Sidecar)│ │(Sidecar)│ │ │
│ │ └────▲────┘ └────▲────┘ └────▲────┘ │ │
│ │ │ │ │ │ │
│ │ App A App B App C │ │
│ └─────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
Istio 核心能力
| 能力 | 说明 | 使用场景 |
|---|---|---|
| 流量管理 | 路由、灰度、金丝雀、A/B 测试 | 渐进式发布 |
| 安全 | mTLS、RBAC、认证/授权 | 零信任网络 |
| 观测 | 自动生成 Metrics、Logs、Traces | 无需代码侵入 |
| 熔断/重试 | 自动配置 | 提升可用性 |
Istio 流量管理示例:
# 金丝雀发布:90% 流量到 v1,10% 到 v2
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
name: reviews
spec:
hosts:
- reviews
http:
- route:
- destination:
host: reviews
subset: v1
weight: 90
- destination:
host: reviews
subset: v2
weight: 10
---
apiVersion: networking.istio.io/v1beta1
kind: DestinationRule
metadata:
name: reviews
spec:
host: reviews
subsets:
- name: v1
labels:
version: v1.0
- name: v2
labels:
version: v2.0
trafficPolicy:
connectionPool:
tcp:
maxConnections: 100
http:
http1MaxPendingRequests: 50
outlierDetection: # 熔断配置
consecutiveErrors: 5
interval: 30s
baseEjectionTime: 30s8.2 Service Mesh 对比
| 维度 | Istio | Linkerd | Consul Connect |
|---|---|---|---|
| 控制平面 | istiod | 内置(极简) | Consul Server |
| Sidecar | Envoy | Linkerd-proxy | Envoy |
| 资源占用 | 较高 | 极低 | 中等 |
| 性能损耗 | 3-10ms | < 1ms | 2-5ms |
| 成熟度 | 高(CNCF 毕业) | 高(CNCF 毕业) | 中 |
| 多集群 | 支持 | 支持 | 支持 |
| VM 支持 | 支持 | 支持 | 原生支持 |
| 适用场景 | 功能全面 | 追求极简和性能 | 已有 Consul |
9. 云原生设计模式
9.1 十二要素应用(12-Factor App)
TL;DR:十二要素是现代云原生应用的设计方法论,由 Heroku 提出,涵盖代码、依赖、配置、后端服务、构建/发布/运行、进程、端口绑定、并发、易处理、环境等价、日志、管理进程。
十二要素速查
| # | 要素 | 说明 | 反模式 |
|---|---|---|---|
| 1 | 基准代码 | 一份代码库,多环境部署 | 不同环境使用不同代码分支 |
| 2 | 依赖 | 显式声明依赖 | 依赖系统预装包 |
| 3 | 配置 | 配置存储在环境中 | 配置文件写死在代码里 |
| 4 | 后端服务 | 把数据库/缓存等当作附加资源 | 硬编码连接地址 |
| 5 | 构建/发布/运行 | 严格分离三个阶段 | 直接修改运行时代码 |
| 6 | 进程 | 无状态、无共享 | 在内存中缓存会话 |
| 7 | 端口绑定 | 通过端口提供服务 | 依赖外部 Web 服务器 |
| 8 | 并发 | 通过进程模型水平扩展 | 在进程内做多线程 |
| 9 | 易处理 | 快速启动、优雅终止 | 启动慢、关闭时丢失请求 |
| 10 | 环境等价 | 开发/测试/生产尽量一致 | 各环境配置差异大 |
| 11 | 日志 | 日志当作事件流输出到 stdout | 写入本地文件 |
| 12 | 管理进程 | 一次性管理脚本和主进程一致 | 手动执行 SQL 脚本 |
优雅关闭实现
func main() {
srv := &http.Server{Addr: ":8080", Handler: handler}
// 启动 HTTP 服务(在 goroutine 中)
go func() {
if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
log.Fatalf("listen: %s\n", err)
}
}()
// 等待中断信号
quit := make(chan os.Signal, 1)
signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
<-quit
log.Println("Shutting down server...")
// 优雅关闭:给进行中的请求最多 30s 完成
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
// 1. 标记 readiness probe 为 false(停止接收新流量)
healthz.SetReady(false)
time.Sleep(5 * time.Second) // 等待负载均衡器将 Pod 移出
// 2. 关闭 HTTP 服务器
if err := srv.Shutdown(ctx); err != nil {
log.Fatal("Server forced to shutdown:", err)
}
// 3. 关闭数据库连接等资源
db.Close()
redis.Close()
log.Println("Server exiting")
}9.2 云原生模式速查
| 模式 | 说明 | 类比 |
|---|---|---|
| Sidecar | 将辅助功能(日志、监控、代理)放到独立容器 | 汽车上的 GPS 导航仪 |
| Ambassador | 代理外部服务的访问(如数据库、API) | 外交大使 |
| Adapter | 统一不同服务的接口格式 | 电源转换插头 |
| Circuit Breaker | 服务故障时快速失败,防止级联 | 电路保险丝 |
| Bulkhead | 资源隔离,防止故障扩散 | 轮船水密舱 |
| Retry + Backoff | 失败后重试,间隔指数增长 | 打电话忙音后等待再拨 |
| Timeout | 设置调用超时,避免无限等待 | 餐厅等位超时离开 |
| Fallback | 主服务不可用时的降级方案 | 航班取消后改高铁 |
| Rate Limit | 限制请求速率 | 景区门票限量 |
| Queue-Based Load Leveling | 用队列削峰填谷 | 银行叫号系统 |
附录:面试高频速查
微服务与云原生面试 FAQ
Q1:微服务拆分粒度怎么把握?
一句话答案:以"一个团队能独立维护"和"两周内能重写"为标准。
展开:
- 过小信号:跨服务调用占代码量 50% 以上;发布一个功能需协调 3+ 服务
- 过大信号:一个服务需要多人协作;技术栈锁定无法演进
- 判断标准:DDD 限界上下文 + 团队结构(康威定律)
Q2:Service Mesh 相比传统微服务框架有什么优势?
一句话答案:将服务治理能力下沉到基础设施层,业务代码零侵入,支持多语言。
展开:
- 传统框架(如 Spring Cloud):语言绑定(Java),SDK 升级困难
- Service Mesh:Sidecar 代理统一处理,业务无感知;但增加延迟和资源开销
- 适用:多语言环境、已有大量遗留系统、需要统一治理能力
Q3:K8s 中 Deployment 和 StatefulSet 的区别?
| 特性 | Deployment | StatefulSet |
|---|---|---|
| 适用场景 | 无状态应用(API、Web) | 有状态应用(DB、MQ) |
| Pod 命名 | 随机哈希 | 有序序号(-0, -1, -2) |
| 存储 | 共享 PVC / emptyDir | 独立 PVC(每 Pod) |
| 删除策略 | 同时删除 | 按序号逆序删除 |
| 网络 | 任意 Pod 等价 | 固定网络标识(Headless DNS) |
| 扩容 | 任意顺序 | 按序号顺序 |
Q4:Docker 的 CGroup 和 Namespace 有什么区别?
- Namespace:隔离"能看到什么"(进程、网络、文件系统)
- CGroup:限制"能用多少"(CPU、内存、IO、网络带宽)
类比:Namespace 是办公室的隔断墙(互相看不到),CGroup 是每个工位的预算限制(能用多少电、多少纸)。
Q5:Ingress 和 Service 的区别?
- Service:L4(TCP/UDP)负载均衡,基于 IP:Port
- Ingress:L7(HTTP/HTTPS)路由,基于 Host/Path,提供 TLS 终止、重写、限流等高级功能
Q6:Prometheus 的 Pull 模式和 Push 模式各有什么优缺点?
| 维度 | Pull(Prometheus) | Push(InfluxDB / OTLP) |
|---|---|---|
| 优点 | 服务发现自动拉取;易于判断服务是否存活 | 适合短生命周期任务(Batch Job);防火墙友好 |
| 缺点 | 需要服务暴露端口;短任务可能采集不到 | 需要额外 Agent;可能压垮服务端 |
| 适用 | 长期运行的服务 | Serverless / CronJob |
Pushgateway:Prometheus 为 Batch Job 提供的 Push 桥接方案。
Q7:什么是优雅关闭(Graceful Shutdown)?为什么重要?
一句话答案:在接收到终止信号后,先停止接收新请求,等待进行中的请求完成后再退出,避免请求中断。
K8s 中的优雅关闭流程:
1. K8s 发送 SIGTERM 给 Pod
2. Pod 标记 readinessProbe 失败(从 Service Endpoint 移除)
3. 等待 terminationGracePeriodSeconds(默认 30s)
4. 如果仍未退出,发送 SIGKILL
Q8:容器镜像为什么要小?
- 安全:攻击面小,漏洞少
- 启动快:拉取和启动时间短,利于自动扩缩容
- 存储省:Registry 和节点存储占用少
- 网络省:传输带宽小,跨机房部署更快
优化手段:多阶段构建、distroless/alpine 基础镜像、.dockerignore。
Q9:Kubernetes 的 QoS(服务质量)等级有哪些?
| 等级 | 条件 | 驱逐优先级 |
|---|---|---|
| Guaranteed | 所有容器都设置了 limit = request,且只限制了 CPU/内存 | 最低(最后被驱逐) |
| Burstable | 至少一个容器设置了 request 或 limit,但不满足 Guaranteed | 中 |
| BestEffort | 没有设置任何 request/limit | 最高(最先被驱逐) |
建议:核心服务设为 Guaranteed,避免在节点资源紧张时被驱逐。
Q10:微服务中的分布式事务如何处理?
详见文档 22-distributed-systems-core-interview-k2.6.md 中的"分布式事务"章节。
简要:
- 首选:业务设计上避免分布式事务(事件驱动、最终一致)
- 次选:Saga 模式(编排式/协同式)
- 最后:TCC / Seata AT(复杂度高,性能损耗大)
关联文档:
- 22-distributed-systems-core-interview-k2.6.md — 分布式系统核心面试
- 20-spring-cloud-alibaba-core-interview-k2.6.md — Spring Cloud Alibaba 核心面试