面试题集锦:微服务与云原生问答大全

面试题集锦:微服务与云原生问答大全

Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。


正文

Generated by kimi-k2.6 model


目录


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, ConsulKubernetes 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: 80

3. 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 注入)                  │
└─────────────────────────────────────────────┘

主流网关对比

特性KongSpring Cloud GatewayNginx + LuaEnvoy
架构OpenResty (Lua)Java (WebFlux)Nginx C + LuaC++
性能高中很高很高
插件生态丰富(150+)Spring 生态自定义 LuaWASM
动态配置支持支持需 reload支持(xDS)
Service Mesh需集成不适用不适用Istio 默认
协议支持HTTP/gRPCHTTP/WebFluxHTTP/gRPCHTTP/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: 100Gi

6.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 一个 IPPod IP 在集群内唯一且可直接访问
Pod 间无 NAT容器看到对方的源 IP 就是 Pod IP
Node 可与 Pod 通信Node 的 IP 和 Pod IP 互通

Service 类型对比:

类型说明适用场景
ClusterIP集群内部虚拟 IP,仅集群内访问内部服务通信
NodePort在每个 Node 上开放一个端口开发测试
LoadBalancer云厂商负载均衡器(AWS ELB/Azure LB)生产环境公网暴露
ExternalNameDNS CNAME 别名外部服务引入
Headless无 ClusterIP,直接返回 Pod IPStatefulSet 服务发现

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 类型对比:

类型生命周期多节点读写适用场景
emptyDirPod否临时缓存
hostPathNode否节点日志收集
PVC (云盘)持久否数据库
PVC (NFS/EFS)持久是共享存储
ConfigMap/Secret持久是配置注入
downwardAPIPod是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: 30s

8.2 Service Mesh 对比

维度IstioLinkerdConsul Connect
控制平面istiod内置(极简)Consul Server
SidecarEnvoyLinkerd-proxyEnvoy
资源占用较高极低中等
性能损耗3-10ms< 1ms2-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 的区别?

特性DeploymentStatefulSet
适用场景无状态应用(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:容器镜像为什么要小?

  1. 安全:攻击面小,漏洞少
  2. 启动快:拉取和启动时间短,利于自动扩缩容
  3. 存储省:Registry 和节点存储占用少
  4. 网络省:传输带宽小,跨机房部署更快

优化手段:多阶段构建、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(复杂度高,性能损耗大)

关联文档: