罗罗编程学习记录
本页内容 展开查看

05.8 阶段 7 可观测性与云原生部署

所属:全栈开发面试题库 / 学习路径 / 05 Go 全栈

本页目录

一、阶段定位

前六个阶段解决的是"服务能跑",本阶段解决"服务在容器集群里能被看到、被重启、被水平扩展"。Go 服务天生适合云原生——单静态二进制、启动快、内存低——但"适合"不等于"自动会配":日志要结构化、指标要埋点、探针要分清就绪与存活、Dockerfile 要多阶段构建、K8s 资源限制要与 GOMAXPROCS/GOMEMLIMIT 对齐。

与前后阶段的衔接:

  • 往上接阶段 5 的优雅关闭:K8s 滚动更新依赖 SIGTERM,不做优雅关闭就会偶发 502。
  • 往上接阶段 4 的 GOMAXPROCS/GOMEMLIMIT:容器里 CPU/内存有配额,这两个参数必须配,否则调度抖动或 OOM。
  • 往下接阶段 8(05.9):压测时要看 Prometheus 的 QPS、P99、GC 停顿,本阶段先把指标埋点做对。

原提纲里的"卡点"展开成可判断的现象依据:

  • 容器内未适配 CPU 限制导致调度与内存估算偏差:GOMAXPROCS 按宿主机核数,P 太多互相抢。
  • 只配存活探针不配就绪探针:服务启动时还没连完 DB,K8s 就把流量打进来,请求全失败。
  • 日志直接打到标准输出却无采集配置:以为打到 stdout 就万事大吉,结果集群里没配日志收集器,日志丢了。

二、阶段目标与投入

能力目标(可验证的行为) 验证方式
能用 slog 或 zap 输出带 request id 的结构化 JSON 日志 一个请求贯穿日志都有相同 request_id 字段
能在 HTTP 与 gRPC 路径上埋 Counter、Gauge、Histogram 指标 /metrics 端点能被 Prometheus 抓到
能接入 OpenTelemetry,把 trace 贯通到下游 HTTP/DB 一次请求在 Jaeger/Tempo 里能看到完整调用链
能区分就绪探针与存活探针的用途 写一个就绪探针检查 DB 连接,失败时 Pod 被摘流但不重启
能写多阶段 Dockerfile,镜像体积 < 20 MB docker images 看镜像大小
能写 K8s Deployment,含探针、requests/limits、滚动更新策略 kubectl rollout status 成功,无请求报错

建议学时:

  • 全职:2 周,约 50–60 小时。日志与指标 15 小时、链路追踪 10 小时、Docker 10 小时、K8s 部署 15 小时。
  • 在职:4–5 周,约 60 小时。K8s 单独占一周。

学时分配建议:结构化日志 15%、指标埋点 20%、链路追踪 15%、健康检查 10%、Docker 构建 15%、K8s 部署 25%。

三、先修自检

先修项 合格标准 不合格时回到
优雅关闭 能用 srv.Shutdown(ctx) 处理 SIGTERM 05.6 的 5.4 节
GOMAXPROCS/GOMEMLIMIT 能按容器配额设参数 05.5 的 5.3 节
context 能用 ctx 传 request id 05.4 的 5.3 节
HTTP handler 能写分层服务 05.6 的 5.3 节
命令行 会用 docker、kubectl 05.1 的 5.6 节

经验判断:有 Java 经验的人容易照搬 Spring Boot 的 actuator 配置,不理解探针区别;有 DevOps 经验的人容易只写 YAML 不懂应用内埋点。本阶段两边都要。

四、知识地图

模块 知识点 掌握程度 对应题库章节
结构化日志 slog/zap、request id、级别、JSON 输出 会用 08.4 CI/CD 与可观测性
指标 Counter/Gauge/Histogram、标签设计、/metrics 会用 08.4 CI/CD 与可观测性
链路追踪 OpenTelemetry、span、上下文传播、采样 会用 08.4 CI/CD 与可观测性
健康检查 就绪探针、存活探针、依赖探测 能讲清原理 08.2 Kubernetes
Docker 多阶段构建、静态编译、基础镜像 会用 08.1 容器化
Kubernetes Deployment、探针、资源限制、滚动更新、HPA 会用 08.2 Kubernetes
配置与密钥 环境变量、ConfigMap、Secret 会用 08 云原生与 DevOps

进度管理建议:探针与多阶段构建是面试高频,必须到"能讲清原理";OTel 要求"会用",能接 SDK 即可。

五、分模块精讲

5.1 结构化日志与 request id

为什么需要它:fmt.Println("user not found") 这种非结构化日志无法按 request id 检索,线上排障时不知道哪条日志对应哪个请求。结构化日志输出 JSON,字段可索引。

核心机制:

  • Go 1.21 起标准库 log/slog 内置结构化日志,支持 JSON handler。
  • 字段:时间、级别、消息、request_id、user_id、error。
  • request id 来源:HTTP 头 X-Request-Id(入口生成或透传),注入 context.Context,日志从 ctx 取。
  • 级别:Debug/Info/Warn/Error;生产用 Info 或 Warn。
  • 性能:zap 比 slog 快但需额外依赖;多数场景 slog 足够。
  • 敏感信息:日志里不要打密码、token、身份证。

最小可运行示例:

package main

import (
	"context"
	"log/slog"
	"net/http"
	"time"
)

type ctxKey string

const requestIDKey ctxKey = "request_id"

func requestIDMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		rid := r.Header.Get("X-Request-Id")
		if rid == "" {
			rid = time.Now().Format("20060102150405.000000000")
		}
		ctx := context.WithValue(r.Context(), requestIDKey, rid)
		w.Header().Set("X-Request-Id", rid)
		next.ServeHTTP(w, r.WithContext(ctx))
	})
}

func main() {
	logger := slog.New(slog.NewJSONHandler(nil, &slog.HandlerOptions{Level: slog.LevelInfo}))
	slog.SetDefault(logger)

	http.HandleFunc("/users", func(w http.ResponseWriter, r *http.Request) {
		rid := r.Context().Value(requestIDKey).(string)
		slog.Info("get user", "request_id", rid, "path", r.URL.Path)
		// ...
		w.Write([]byte("ok"))
	})
	_ = http.ListenAndServe(":8080", requestIDMiddleware(http.DefaultServeMux))
}
curl -i http://127.0.0.1:8080/users
# 响应头带 X-Request-Id: 20260101120000.000000000
# stdout: {"time":"2026-01-01T12:00:00Z","level":"INFO","msg":"get user","request_id":"20260101120000...","path":"/users"}

常见坑:

现象 原因 修法
日志里没有 request_id ctx 没传进业务函数 业务函数接收 ctx,从 ctx 取 id
日志里打了密码 直接 log 整个请求体 只打必要字段
JSON 日志时间不可读 没设时区 slog 默认 UTC,可接受;或用 ReplaceAttr 转本地

面试考法:"为什么要结构化日志""request id 怎么贯通""日志里不能打什么"。要点:JSON 可索引;ctx 透传;不打敏感信息。

5.2 Prometheus 指标埋点

为什么需要它:日志告诉你"发生了什么",指标告诉你"系统现在怎么样"。QPS、P99、错误率、GC 停顿,这些必须是指标,不是日志。

核心机制:

  • 四种类型:Counter(只增,如请求总数)、Gauge(可增可减,如当前 goroutine 数)、Histogram(分布,如请求延迟)、Summary(分位数,客户端计算)。
  • 端点:/metrics,Prometheus 定期抓取。
  • 标签:code="200"、method="GET";标签基数要控制,不要把 user_id 当标签。
  • 常用:promhttp.Handler() 暴露 /metrics。

最小可运行示例:

package main

import (
	"net/http"
	"strconv"
	"time"

	"github.com/prometheus/client_golang/prometheus"
	"github.com/prometheus/client_golang/prometheus/promauto"
	"github.com/prometheus/client_golang/prometheus/promhttp"
)

var (
	httpRequests = promauto.NewCounterVec(prometheus.CounterOpts{
		Name: "http_requests_total",
		Help: "Total HTTP requests",
	}, []string{"method", "path", "code"})

	httpDuration = promauto.NewHistogramVec(prometheus.HistogramOpts{
		Name:    "http_request_duration_seconds",
		Help:    "HTTP request latency",
		Buckets: prometheus.DefBuckets, // 0.005, 0.01, 0.025, ...
	}, []string{"method", "path"})
)

func MetricsMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		start := time.Now()
		ww := &statusWriter{ResponseWriter: w, status: 200}
		next.ServeHTTP(ww, r)
		dur := time.Since(start).Seconds()
		httpRequests.WithLabelValues(r.Method, r.URL.Path, strconv.Itoa(ww.status)).Inc()
		httpDuration.WithLabelValues(r.Method, r.URL.Path).Observe(dur)
	})
}

type statusWriter struct {
	http.ResponseWriter
	status int
}

func (w *statusWriter) WriteHeader(code int) {
	w.status = code
	w.ResponseWriter.WriteHeader(code)
}

func main() {
	http.Handle("/metrics", promhttp.Handler())
	http.HandleFunc("/users", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("ok"))
	})
	_ = http.ListenAndServe(":8080", MetricsMiddleware(http.DefaultServeMux))
}

常见坑:

现象 原因 修法
指标内存暴涨 标签基数太大(如 user_id) 高基数字段放日志,不放指标
P99 算不出来 没用 Histogram 用 Histogram,不要用 Summary
/metrics 抓不到 没注册 promhttp.Handler() 加 http.Handle("/metrics", promhttp.Handler())

面试考法:"四种指标类型""Counter 与 Gauge 区别""标签基数"。要点:Counter 只增、Gauge 可增可减、Histogram 分布;标签基数要小。

5.3 OpenTelemetry 链路追踪

为什么需要它:一个请求经过 API 网关、用户服务、订单服务、DB,日志是分散的。链路追踪给每个请求一个 trace id,跨服务串联成调用图。

核心机制:

  • Span:一次操作(如 GET /users),有开始/结束时间、属性、事件。
  • Trace:一组有因果关系的 Span。
  • 上下文传播:用 HTTP 头 traceparent(W3C 标准)把 trace id 从上游传到下游。
  • SDK:go.opentelemetry.io/otel,导出到 Jaeger/Tempo/OTLP。
  • 采样:生产用 1%–10% 采样,全量采样成本高。

最小可运行示例:

package main

import (
	"context"
	"net/http"

	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/codes"
	"go.opentelemetry.io/otel/trace"
)

var tracer = otel.Tracer("example")

func handleUser(w http.ResponseWriter, r *http.Request) {
	ctx, span := tracer.Start(r.Context(), "handleUser")
	defer span.End()
	span.SetAttributes(attribute.String("user.id", "100"))

	// 调用下游
	if err := callOrderService(ctx); err != nil {
		span.RecordError(err)
		span.SetStatus(codes.Error, err.Error())
	}
	w.Write([]byte("ok"))
}

func callOrderService(ctx context.Context) error {
	_, span := otel.Tracer("order").Start(ctx, "callOrderService")
	defer span.End()
	// ... 实际 HTTP 调用,otel 中间件自动传 traceparent
	return nil
}

常见坑:

现象 原因 修法
跨服务 trace 断了 下游没读 traceparent 头 用 otelhttp 中间件自动传播
Span 里没有业务属性 没 SetAttributes 在关键分支加属性
采样率太高成本高 100% 采样 生产用 5%–10%

面试考法:"trace 怎么跨服务传播""Span 与 Trace 区别""为什么要采样"。要点:W3C traceparent 头;Span 是操作、Trace 是树;采样降本。

5.4 健康检查与探针

为什么需要它:K8s 要知道 Pod 什么时候该接流量、什么时候该重启。就绪探针(readiness)失败时摘流,存活探针(liveness)失败时重启。配错会导致启动时被打流量或死循环重启。

核心机制:

  • 存活探针(liveness):进程是否活着;失败时 K8s 重启容器。检查"进程是否卡死",不要检查 DB 依赖(DB 挂了不该重启进程)。
  • 就绪探针(readiness):是否能接流量;失败时从 Service 摘流。检查 DB/Redis 是否连好。
  • 启动探针(startup):慢启动应用用,成功前其他探针不生效。
  • 端点:/healthz(存活)、/readyz(就绪)。

最小可运行示例:

package main

import (
	"database/sql"
	"net/http"
)

func main() {
	var db *sql.DB // 已初始化

	// 存活:进程活着就返回 200
	http.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(200)
	})

	// 就绪:检查 DB 连接
	http.HandleFunc("/readyz", func(w http.ResponseWriter, r *http.Request) {
		if err := db.PingContext(r.Context()); err != nil {
			http.Error(w, "db not ready", http.StatusServiceUnavailable)
			return
		}
		w.WriteHeader(200)
	})

	_ = http.ListenAndServe(":8080", nil)
}

常见坑:

现象 原因 修法
服务启动时就被打流量,请求全失败 没配就绪探针,或就绪探针只返回 200 就绪探针检查 DB/Redis
DB 挂了 Pod 被反复重启 存活探针检查了 DB 存活只检查进程,DB 问题靠就绪摘流
慢启动应用启动探针没配 liveness 在启动时就开始探测 配 startupProbe,失败 30 次再 liveness

面试考法:"就绪与存活区别""为什么不要在存活里检查 DB"。要点:就绪摘流、存活重启;DB 挂了该摘流不该重启。

5.5 Docker 多阶段构建

为什么需要它:直接在 golang:1.23 镜像里跑,镜像体积 1 GB+。多阶段构建在编译阶段用大镜像,运行阶段用 alpine 或 scratch,镜像缩到 20 MB 以下。

核心机制:

  • 第一阶段:golang:1.23 编译二进制,CGO_ENABLED=0 静态编译。
  • 第二阶段:gcr.io/distroless/static 或 alpine,只拷二进制。
  • 静态编译后不依赖 libc,可以用 scratch(空镜像)。
  • 缓存:go mod download 单独一层,代码改动不重新下载依赖。

最小可运行示例:

# 阶段 1:编译
FROM golang:1.23-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -o /server ./cmd/server

# 阶段 2:运行
FROM gcr.io/distroless/static:nonroot
WORKDIR /
COPY --from=builder /server /server
EXPOSE 8080
USER nonroot:nonroot
ENTRYPOINT ["/server"]
docker build -t myapp:latest .
docker images myapp
# 期望 < 20 MB

常见坑:

现象 原因 修法
镜像体积 1 GB 没用多阶段构建 用 distroless 或 alpine 运行阶段
运行时报 no such file or directory CGO 启用了,distroless 没有 libc CGO_ENABLED=0 静态编译
每次构建都重新下载依赖 go mod download 放在代码拷贝之后 先 COPY go.mod go.sum,再 download

面试考法:"为什么多阶段构建""CGO_ENABLED=0 作用""distroless 好处"。要点:编译环境不进运行镜像;静态编译;distroless 无 shell 减攻击面。

5.6 Kubernetes 部署与滚动更新

为什么需要它:容器在 K8s 里跑,Deployment 描述"要几个副本、怎么更新、资源多少、探针怎么配"。配错会导致滚动更新时丢请求或资源不足。

核心机制:

  • replicas:副本数。
  • resources.requests:调度依据;resources.limits:硬上限。
  • livenessProbe / readinessProbe:见 5.4。
  • strategy.rollingUpdate:maxSurge(最多多几个)、maxUnavailable(最多不可用几个)。
  • terminationGracePeriodSeconds:SIGTERM 后等多久才 SIGKILL(默认 30s)。
  • HPA:按 CPU/自定义指标自动扩缩。

最小可运行示例:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 3
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  selector:
    matchLabels: { app: myapp }
  template:
    metadata: { labels: { app: myapp } }
    spec:
      terminationGracePeriodSeconds: 30
      containers:
        - name: server
          image: myapp:latest
          ports:
            - containerPort: 8080
          resources:
            requests: { cpu: "200m", memory: "256Mi" }
            limits:   { cpu: "1",    memory: "512Mi" }
          env:
            - name: GOMAXPROCS
              value: "1"
            - name: GOMEMLIMIT
              value: "450MiB"
          readinessProbe:
            httpGet: { path: /readyz, port: 8080 }
            initialDelaySeconds: 1
            periodSeconds: 5
          livenessProbe:
            httpGet: { path: /healthz, port: 8080 }
            initialDelaySeconds: 5
            periodSeconds: 10

常见坑:

现象 原因 修法
滚动更新时偶发 502 没优雅关闭 应用接 SIGTERM 调 srv.Shutdown(ctx)
OOMKilled memory limit 太小 设 GOMEMLIMIT 为 limit 的 90%
CPU throttle 严重 limit 太小 调大 limit;requests 与 limit 接近
Pod 一直不就绪 readiness 检查失败 看 kubectl describe pod Events

面试考法:"requests 与 limits 怎么设""maxUnavailable=0 含义""为什么要 GOMEMLIMIT"。要点:requests 调度、limit 硬上限;maxUnavailable=0 滚动时不减少可用副本;GOMEMLIMIT 防 OOM。

5.7 配置与密钥注入

为什么需要它:数据库密码、API key 不能写进镜像或代码。K8s 用 Secret 存敏感信息,ConfigMap 存非敏感配置。

核心机制:

  • ConfigMap:非敏感配置(端口、日志级别),可挂卷或环境变量。
  • Secret:敏感配置(密码、token),Base64 编码(不是加密!),生产建议接外部密钥管理(Vault)。
  • 环境变量:简单配置用;文件挂载:复杂配置用。
  • 12-Factor:配置与代码分离。

最小可运行示例:

apiVersion: v1
kind: Secret
metadata:
  name: db-secret
type: Opaque
stringData:
  password: "real-password-here"  # 生产不要提交到 Git

---
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  PORT: "8080"
  LOG_LEVEL: "info"
# Deployment 里引用
env:
  - name: PORT
    valueFrom: { configMapKeyRef: { name: app-config, key: PORT } }
  - name: DB_PASSWORD
    valueFrom: { secretKeyRef: { name: db-secret, key: password } }
// Go 里读
port := os.Getenv("PORT")
dbPassword := os.Getenv("DB_PASSWORD")

常见坑:

现象 原因 修法
Secret 提交到 Git 直接写 YAML 用 SealedSecret 或 ExternalSecret;本地用 .env
配置改了不生效 环境变量注入后 Pod 不重启 改 ConfigMap 后重启 Pod;或挂卷自动热加载
Secret 被当成加密 Base64 只是编码 生产接 Vault 等外部 KMS

面试考法:"ConfigMap 与 Secret 区别""Secret 是加密的吗""怎么热加载配置"。要点:非敏感 vs 敏感;Base64 不是加密;热加载需要重新挂卷。

六、分层练习

6.1 复现型

练习 要求 验收标准 预计耗时
slog 结构化日志 用 slog JSON 输出,带 request_id 一个请求贯穿日志都有相同 id 1 小时
Prometheus 指标 埋 HTTP 请求 Counter 与 Histogram /metrics 能抓到 1 小时
就绪/存活探针 写 /healthz 与 /readyz 故意断开 DB,就绪失败存活正常 1 小时
多阶段 Dockerfile 按 5.5 写 Dockerfile 镜像 < 20 MB 1 小时
K8s Deployment 按 5.6 写 YAML kubectl apply 成功 2 小时

6.2 改造型

练习 要求 验收标准 预计耗时
接入 OTel 给 HTTP 服务加 otelhttp 中间件 Jaeger 里能看到 trace 2 小时
加 GOMEMLIMIT 在 Deployment 里设 GOMEMLIMIT 不再 OOMKilled 0.5 小时
修复探针 给定一个把 DB 放进 liveness 的配置,改成 readiness DB 挂时摘流不重启 1 小时
配置外置 把硬编码的端口改成 ConfigMap 改 ConfigMap 重启后生效 1 小时
滚动更新不丢请求 给服务加优雅关闭 压测时 rollout 无 502 2 小时

6.3 设计型

练习 要求 验收标准 预计耗时
可观测性三件套 日志 + 指标 + trace 接进一个服务 一次请求在 Jaeger 可见、指标可抓、日志可检索 6 小时
完整 K8s 部署 Deployment + Service + HPA + Secret kubectl rollout 成功;HPA 按 CPU 扩缩 6 小时
灰度发布 配置 maxUnavailable=0 与 maxSurge=1 滚动更新无请求报错 3 小时

七、排障表

现象 可能原因 排查步骤 解决办法
日志里没有 request_id ctx 没透传 看业务函数签名 业务函数接收 ctx,从中取 id
/metrics 抓不到 没注册 promhttp 访问 curl /metrics 加 promhttp.Handler()
Pod 启动就被打流量失败 没配就绪探针 kubectl describe pod 看 Events 就绪探针检查 DB
DB 挂了 Pod 反复重启 存活探针检查了 DB 看 liveness 配置 存活只查进程;DB 问题走就绪
镜像体积 1 GB 没用多阶段构建 docker history 用 distroless 运行阶段
容器 OOMKilled GOMEMLIMIT 没设 看 kubectl describe pod 设 GOMEMLIMIT 为 limit 90%
滚动更新偶发 502 没优雅关闭 看应用日志退出时机 srv.Shutdown(ctx)
Secret 被提交到 Git YAML 直接写密码 看 Git 历史 用 SealedSecret 或 ExternalSecret

八、出口条件

全部勾选后再进入 05.9 阶段 8 高并发进阶(可选)。

  • [ ] 能用 slog/zap 输出带 request_id 的结构化 JSON 日志
  • [ ] 能埋 Counter/Gauge/Histogram 指标,/metrics 可抓取
  • [ ] 能接入 OpenTelemetry,trace 贯通下游
  • [ ] 能区分就绪探针与存活探针,配错能一次指出
  • [ ] 能写多阶段 Dockerfile,镜像 < 20 MB
  • [ ] 能写 K8s Deployment,含探针、requests/limits、滚动更新
  • [ ] 能用 ConfigMap 与 Secret 注入配置,敏感信息不进 Git

自测题:

  1. 就绪探针与存活探针的区别?为什么不要在存活里检查 DB?
    • 要点:就绪失败摘流、存活失败重启;DB 挂了该摘流不该重启进程。
  2. Counter 与 Gauge 区别?Histogram 解决什么问题?
    • 要点:Counter 只增(请求数)、Gauge 可增可减(当前 goroutine 数);Histogram 看延迟分布算 P99。
  3. 多阶段构建为什么能减小镜像?
    • 要点:编译阶段用大镜像,运行阶段只拷二进制到 distroless/alpine,不含编译工具。
  4. CGO_ENABLED=0 的作用?
    • 要点:静态编译,不依赖 libc,可以在 distroless/scratch 跑。
  5. GOMEMLIMIT 为什么要设为 memory limit 的 90%?
    • 要点:留 10% 余量给栈与其他开销;让运行时更早 GC,避免被 K8s OOMKill。
  6. Secret 是加密的吗?生产怎么管密钥?
    • 要点:不是,只是 Base64 编码;生产接 Vault 或 ExternalSecret。