Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

部署与升级：拥抱云原生，实现Go应用持续交付（上）

你好，我是Tony Bai。

在前面的课程中，我们已经走过了Go项目的设计、编码、测试以及核心组件构建的完整旅程。我们学习了如何编写出结构清晰、功能健壮、质量有保障的Go代码。但仅仅拥有高质量的代码还不够， 如何将我们精心打造的Go应用高效、可靠地部署到生产环境，并在后续快速迭代和需求变更中实现平滑、无缝的升级，是衡量一个项目工程化成熟度的关键标准，也是我们Go工程师在工程实践中必须面对的重要课题。

传统的部署方式，例如手动拷贝二进制文件、逐台服务器配置环境、编写复杂的启停脚本，往往充满了痛点：

  • 环境不一致：开发、测试、生产环境的差异可能导致“在我这里明明是好的”这类经典问题。

  • 手动操作易错：部署和升级过程涉及大量手动步骤，容易因人为疏忽引入故障。

  • 升级过程复杂且风险高：发布新版本时，如何保证服务不中断？如何快速回滚？这些都是棘手的难题。

幸运的是，以容器化（特别是Docker）和容器编排（特别是Kubernetes）为代表的云原生技术栈，为现代应用的部署和升级带来了革命性的变化。它们使得我们可以将Go应用及其依赖打包成轻量、可移植的“集装箱”，并在强大的编排平台上实现自动化部署、弹性伸缩和复杂的发布策略，从而真正拥抱持续交付（Continuous Delivery）。

Go是天然适合云原生的，因为很多云原生基础设施，比如Docker、Kubernetes都是由Go语言打造的。

接下来的两节课，我们将一起探索Go应用在云原生时代的部署与升级之道。这节课，我们先学习如何将Go应用容器化，掌握编写高效、安全的Dockerfile的最佳实践，以及优化Go镜像体积的技巧。接着，我们再了解一个开发阶段的利器——Docker Compose，学习如何用它快速搭建和管理包含多个服务的本地Go应用环境。下节课，我们再入门Kubernetes的核心概念，并深入剖析主流的平滑发布策略。

Go应用的容器化：构建轻量、高效、可移植的“集装箱”

在现代软件开发中，容器化几乎已成为应用交付的标准方式。对于Go应用而言，容器化同样能带来诸多益处：

  • 环境一致性：容器将应用及其所有运行时依赖（库、配置文件、环境变量等）打包在一起，形成一个自包含的单元。无论是在开发者的本地机器、测试服务器还是生产集群，这个容器都能以完全相同的方式运行，彻底解决了“环境不一致”的痛点。

  • 可移植性：容器镜像可以在任何支持容器运行时的环境（如Docker Desktop、Kubernetes、AWS ECS、Google Cloud Run等）中运行，实现了“一次构建，到处运行”。

  • 轻量与高效：相比于虚拟机，容器共享宿主机的操作系统内核，启动更快，资源占用更少。Go语言编译出的静态链接二进制文件本身就很小巧，与容器技术结合更能发挥其轻量高效的优势。

  • 易于部署和扩展：容器化的应用更容易通过编排工具（如Kubernetes）进行自动化部署、水平扩展和版本管理。

  • 隔离性：容器之间提供了一定程度的隔离（尽管不如虚拟机彻底），有助于应用间的资源管理和安全性。

接下来，我们以目前最流行的容器化技术Docker为例，探讨如何为Go应用构建优秀的容器镜像。

容器化技术概览（以Docker为例）

要理解什么是容器，首先要了解容器与虚拟机（VM）的区别。

虚拟机通过Hypervisor在物理硬件之上虚拟化出一整套独立的操作系统内核和硬件资源，每个虚拟机都运行一个完整的操作系统。这使得虚拟机之间具有良好的隔离性，但同时也带来了较大的资源开销和较慢的启动速度。相比之下，容器则在宿主机操作系统之上，利用操作系统层面的虚拟化技术（例如 Linux 的 Namespaces 和 Cgroups）来创建隔离的运行时环境。容器共享宿主机的内核，只打包应用本身及其所需的依赖库和二进制文件。因此，容器更为轻量级，启动速度更快，并且能够实现更高的资源密度。

Docker 作为容器化技术的代表，其核心概念包括镜像（Image）、容器（Container）和仓库（Repository）。

镜像是一个只读的模板，它包含了运行应用所需的所有文件系统内容，如代码、运行时环境、库、环境变量和配置文件，以及启动应用的指令。镜像采用分层结构，每一层都对应着 Dockerfile 中的一条指令。

容器则是镜像的一个可运行实例。 当一个镜像被启动时，会在其顶层添加一个可写层，从而形成一个容器。可以将镜像理解为面向对象编程中的“类”，而容器则是“对象”，即类的具体实例。也可以将镜像理解为可执行文件，而容器则是基于该可执行文件启动的一个进程。

最后， 仓库是用于存储和分发 Docker 镜像的平台。这些仓库可以是公共的，例如 Docker Hub，也可以是私有的，例如 Harbor、AWS ECR 或 Google GCR，它们方便用户共享和管理自己的镜像。

那么如何将Go应用构建为一个包含了所有运行环境的容器镜像呢？这就需要Dockerfile。下面我们就来看看Go应用的Dockerfile最佳实践。

Go应用的Dockerfile最佳实践

Dockerfile是一个文本文件，它包含了一系列指令，用于指导Docker如何从一个基础镜像开始，一步步构建出我们应用的目标镜像。编写一个优秀的Dockerfile对于构建出体积小、构建速度快、安全性高的Go应用镜像至关重要。下面是一些有关Dockerfile的最佳实践，我们逐一来看一下。

选择合适的基础镜像

基础镜像是我们构建应用镜像的起点。对于Go应用，常见的选择有：

  • scratch：这是一个完全空的镜像，不包含任何文件系统和用户空间工具。如果你的Go应用是静态链接编译的（即不依赖任何外部动态链接库，包括C库如glibc/musl），那么使用 scratch 作为最终运行阶段的基础镜像，可以构建出体积极致精简（可能只有几MB）的镜像。

  • alpine：一个基于Alpine Linux的非常小巧的Linux发行版镜像（通常只有5MB左右）。它包含了musl libc和一个基本的包管理器（apk），如果你的应用需要一些基础的shell工具或者依赖某些C库但又希望镜像尽可能小，Alpine是一个不错的选择。但要注意musl libc与glibc在某些行为上可能存在的细微差异。

  • distroless（Google’s Distroless Images）：这类镜像仅包含应用运行所需的最小依赖（例如，仅包含语言运行时和必要的库，没有shell、包管理器或其他不必要的工具），旨在减小攻击面，提升安全性。Google提供了针对Go的 gcr.io/distroless/static（用于静态链接二进制文件）和 gcr.io/distroless/base（包含glibc等基础库）等镜像。

  • 官方Go语言镜像（如 golang:1.xx-alpine）：通常用于构建阶段，它包含了完整的Go SDK和编译环境。不推荐直接将其作为最终的生产镜像，因为它体积较大，包含许多运行时不需要的工具。

有了适合的基础镜像后，接下来，我们就要考虑如何构建一个体积小、启动快的Go应用镜像了。

长期以来，构建轻量级的Go应用镜像一直是一个挑战，开发者们常常需要在镜像体积和启动速度之间进行权衡。传统方法通常需要将整个Go编译环境打包进镜像，导致镜像体积庞大且不够灵活。直到Docker多阶段构建功能的出现，使得这一过程得以简化。

多阶段构建（Multi-stage Builds）

多阶段构建就是我们可以在一个阶段中编译Go应用，然后在下一个阶段中将最终的可执行文件复制到一个更小的基础镜像中，从而显著减小镜像的体积并提升启动速度。 这种方法不仅优化了资源使用，还提高了部署效率，是优化Go镜像体积的核心最佳实践。

多阶段构建允许我们在一个Dockerfile中定义多个构建阶段，每个阶段都可以使用不同的基础镜像。通常，我们会有一个“构建阶段”（builder stage）和一个“运行阶段”（final stage）：

  • 构建阶段：使用一个包含完整Go编译环境的基础镜像（如 golang:1.21-alpine），在这个阶段复制源代码、下载依赖、编译Go应用生成静态链接的二进制文件。

  • 运行阶段：从一个非常轻量级的基础镜像开始（如 scratch 或 distroless/static），然后只从构建阶段 COPY --from=builder 编译好的二进制文件以及任何必要的运行时文件（如配置文件模板、TLS证书等，如果有的话）。

这种方式可以确保最终的生产镜像只包含运行应用所必需的最小内容，而不会包含庞大的编译工具链和中间产物，从而大幅减小镜像体积。

除了选择基础镜像以及多阶段构建的实践外，还有一些实践也是非常重要的。我们继续来看几个。

优化镜像层缓存

Docker镜像是分层的，每一条Dockerfile指令都会创建一个新的镜像层。Docker在构建镜像时会尝试复用已有的层来加速构建。为了最大限度地利用层缓存：

  • 将不经常变动的指令（如安装基础依赖、设置环境变量）放在Dockerfile的前面。

  • 将经常变动的指令（如 COPY . . 复制整个项目源代码）放在后面。

  • 例如，先 COPY go.mod go.sum ./ 并运行 go mod download，利用Go模块的缓存。然后再 COPY . . 复制剩余代码并编译。这样，如果只有业务代码变动而依赖未变， go mod download 这一层就可以被缓存复用。

非root用户运行

默认情况下，容器内的进程以root用户身份运行，这存在一定的安全风险。最佳实践是创建一个非root用户，并在运行阶段使用 USER 指令切换到该用户来运行应用。

处理静态资源和配置文件

  • 如果应用包含静态资源（如HTML模板、JS/CSS文件），可以将它们与编译好的二进制文件一起 COPY 到最终镜像中。

  • 对于配置文件，一种常见的做法是在镜像中包含一个默认的配置文件或配置文件模板，然后在运行时通过ConfigMap或Secret挂载实际的配置文件来覆盖或填充它。

设置工作目录、暴露端口、定义启动命令

  • WORKDIR /app：设置容器内的工作目录。

  • EXPOSE 8080：声明容器运行时会监听的端口（这只是一个元数据声明，实际端口映射在 docker run -p 或Kubernetes Service中定义）。

  • CMD ["/app/myapp"] 或 ENTRYPOINT ["/app/myapp"]：定义容器启动时执行的默认命令。 ENTRYPOINT 通常用于定义容器的主命令，而 CMD 可以为其提供默认参数（可以被 docker run 时覆盖）。对于Go应用，通常直接使用 CMD ["/path/to/your/binary", "arg1", "arg2"] 或 ENTRYPOINT ["/path/to/your/binary"] 配合 CMD ["arg1", "arg2"]。

示例：一个优化的Go应用Dockerfile

下面我们展示一个包含上述主要最佳实践的Dockerfile样板。假设我们有一个简单的Go Web应用，它是静态链接的，其Dockerfile如下（代码中包含了详尽的注释，这里就不再一一解释了）：

# ---- Build Stage ----
# Use an official Go image as a builder.
# Specify the Go version. Alpine versions are smaller.
FROM golang:1.21-alpine AS builder

# Set the Current Working Directory inside the container
WORKDIR /app

# Copy go mod and sum files to leverage Docker cache
COPY go.mod go.sum ./
# Download all dependencies. Dependencies will be cached if the go.mod and go.sum files are not changed.
RUN go mod download && go mod verify

# Copy the source code into the container
COPY . .

# Build the Go app for a static release.
# CGO_ENABLED=0 disables Cgo, producing a static binary (no external C libraries).
# -ldflags="-w -s" strips debugging information, reducing binary size.
# -o /app/myapp specifies the output path for the binary.
RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-w -s" -o /app/myapp .

# ---- Run Stage ----
# Start from a scratch image for the smallest possible footprint.
FROM scratch

# (Optional) If your app needs CA certificates for HTTPS calls, or timezone data
# COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
# COPY --from=builder /usr/share/zoneinfo /usr/share/zoneinfo

# Set the Current Working Directory for the runtime container
WORKDIR /app

# Copy the Pre-built binary file from the previous stage.
COPY --from=builder /app/myapp /app/myapp

# (Optional) If you created a non-root user in the builder stage or have a base image with one
# USER nonroot:nonroot

# Expose port 8080 to the outside world
EXPOSE 8080

# Command to run the executable
ENTRYPOINT ["/app/myapp"]
# CMD ["--config=/etc/app/config.yaml"] # Optional default arguments for ENTRYPOINT

Go镜像优化技巧

除了Dockerfile的最佳实践，还有一些额外的技巧可以帮助进一步优化Go应用的容器镜像。

首先是静态链接编译（上面Dockerfile示例中已做）。 通过设置 CGO_ENABLED=0 和合适的GOOS/GOARCH，可以编译出不依赖外部C库的纯静态Go二进制文件。这使得我们可以使用极小的基础镜像（如scratch）。 ldflags "-w -s" 可以去除调试信息和符号表，进一步减小二进制文件体积。

CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -a -ldflags="-w -s" -o myapp .
# -a 标志强制重新构建所有依赖的包（通常与静态链接一起使用，确保所有部分都是静态的）

其次是使用 .dockerignore 文件。 在项目根目录下创建一个 .dockerignore 文件，列出那些不需要（也不应该）被 COPY 到Docker构建上下文中的文件和目录。这类似于 .gitignore。例如，可以忽略 .git 目录、本地开发环境的配置文件、 *.md 文件、测试文件、临时的构建产物等。这能减小构建上下文的大小，加快 COPY 指令的速度，并避免将敏感或不必要的文件打包到镜像中。

# .dockerignore example
.git
.vscode
*.md
*.test.go
tmp/
bin/
# Any other local dev files or build artifacts not needed in the image

然后是压缩镜像（工具辅助）。 虽然Docker本身会对镜像层进行压缩存储和传输，但有一些工具（如 slim 或 dive）可以帮助你分析镜像内容、找出不必要的膨胀，并通过各种技术（如静态/动态分析、移除不必要的文件、甚至重新构建应用>）来进一步“瘦身”镜像，有时能取得显著的效果。但使用这类工具需要谨慎，并充分测试瘦身后的镜像以确保其功能完好。

最后是扫描镜像安全漏洞。

在构建出镜像后，使用镜像扫描工具（如开源的 Trivy、 Clair 或商业SaaS服务）对其进行安全漏洞扫描，是非常重要的安全实践。这些工具会检查镜像中包含的操作系统包和应用依赖是否存在已知的CVE（Common Vulnerabilities and Exposures）。

通过上述实践和技巧，我们可以为Go应用构建出理想的容器镜像，为后续部署奠定基础。但在进入生产级的Kubernetes编排之前，对于本地开发和测试，我们有一个更轻便的工具——Docker Compose。

开发阶段的利器：Docker Compose简化多服务环境搭建

我们已经学会了如何为Go应用构建优化的Docker镜像，这解决了单个应用的环境一致性和可移植性问题。但是，现代应用往往不是孤立存在的，它们通常需要与数据库（如PostgreSQL、MySQL）、缓存服务（如Redis）、消息队列（如Kafka）等多个后端服务协同工作。

在本地开发或进行集成测试时，如果需要手动逐个启动和配置这些依赖服务，将会非常耗时且容易出错，尤其对于新加入团队的成员来说，搭建一套完整的开发环境可能就需要半天甚至更长时间。

Docker Compose 应运而生，它正是为了解决在 开发和测试阶段 轻松管理多容器应用的痛点而设计的。

Docker Compose是什么？它解决了什么核心问题？

Docker Compose 是一个用于 定义和运行多容器Docker应用 的工具。它的核心价值和解决的主要问题可以归纳为如下几点：

  • 一键式环境编排：它允许你通过一个单一的YAML配置文件（通常是 docker-compose.yml 或 compose.yaml）来描述构成你整个应用所需的所有服务（包括你的Go应用容器、数据库容器、缓存容器等）、它们之间的网络连接、数据卷、端口映射以及启动依赖等。然后，只需一条命令（如 docker-compose up），Compose就能为你自动完成所有这些服务的构建（如果需要）、启动和连接。

  • 简化本地开发环境搭建：这是Docker Compose最主要的应用场景。开发者不再需要在本地机器上分别安装和配置PostgreSQL、Redis等，只需一个 docker-compose.yml 文件和Docker环境，就能快速拉起一套包含所有依赖的、隔离的开发环境。

  • 保障开发/测试环境一致性：Compose文件本身可以纳入版本控制，确保团队所有成员以及CI/CD流程中的测试环境所使用的依赖服务版本和基础配置是一致的，大大减少了“在我机器上是好的”这类问题。

  • 快速迭代与调试：结合源码卷挂载和热重载工具，可以实现Go应用代码修改后在容器内自动重新编译和运行，提升开发效率。

简单来说，如果Dockerfile是用来定义如何“制造”一个“集装箱”（镜像）的说明书，那么Docker Compose就是用来指挥多个不同的“集装箱”如何在一起协同工作的“港口调度系统”（但主要用于开发和测试的小型“港口”）。它大大降低了在本地处理微服务架构或依赖复杂应用的门槛。

Docker Compose典型用法与关键实践

让我们通过一个典型的场景——一个Go Web应用依赖PostgreSQL数据库——来看看Docker Compose是如何工作的。

首先我们看看Go应用的代码片段：

// ch27/composeapp/app/main.go
package main

import (
    "database/sql"
    "fmt"
    "log"
    "net/http"
    "os"
    "time"

    _ "github.com/lib/pq" // PostgreSQL driver
)

func main() {
    dbHost := os.Getenv("DB_HOST_APP") // 从环境变量读取
    dbPort := os.Getenv("DB_PORT_APP")
    dbUser := os.Getenv("DB_USER_APP")
    dbPassword := os.Getenv("DB_PASSWORD_APP")
    dbName := os.Getenv("DB_NAME_APP")
    appPort := os.Getenv("APP_PORT")
    if appPort == "" {
        appPort = "8080"
    }

    psqlInfo := fmt.Sprintf("host=%s port=%s user=%s password=%s dbname=%s sslmode=disable",
        dbHost, dbPort, dbUser, dbPassword, dbName)

    var db *sql.DB
    var err error
    // Retry logic for DB connection
    for i := 0; i < 5; i++ {
        db, err = sql.Open("postgres", psqlInfo)
        if err == nil {
            err = db.Ping()
            if err == nil {
                log.Println("Successfully connected to PostgreSQL via Docker Compose!")
                break
            }
        }
        log.Printf("DB conn attempt %d failed: %v. Retrying in 2s...", i+1, err)
        time.Sleep(2 * time.Second)
    }
    if err != nil {
        log.Fatalf("Could not connect to DB: %v", err)
    }
    defer db.Close()

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Hello from Go App! DB Host from env: %s\n", dbHost)
        // ... (可以加一个简单的DB查询)
    })

    log.Printf("Go app listening on port %s...", appPort)
    http.ListenAndServe(":"+appPort, nil)
}

下面是基于多阶段构建的Dockerfile的内容：

# ch27/composeapp/app/Dockerfile

FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN go build -o /app/main .

FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/main /app/main
RUN chmod +x /app/main
# COPY config.yaml /app/config.yaml # 如果有配置文件也可以拷贝
EXPOSE 8080
CMD ["/app/main"]

最后则是用于启动应用调试环境的docker-compose.yml文件：

# ch27/composeapp/docker-compose.yml

version: '3.8' # Or a newer compatible version

services:
  # Go Application Service
  go-app:
    build:
      context: ./app    # 指向Go应用代码和Dockerfile的目录
      dockerfile: Dockerfile
    container_name: my_go_app_dev
    ports:
      - "8080:8080"   # 将主机的8080端口映射到容器的8080端口
    # volumes:
      # - ./app:/app    # 关键：将本地Go源码目录挂载到容器的/app目录
                      # 这样本地代码修改后，如果配合热重载工具（如air），容器内应用能自动重启
    environment:      # 通过环境变量传递配置给Go应用
      - APP_PORT=8080
      - DB_HOST_APP=postgres-db # 使用postgres-db服务名作为主机名
      - DB_PORT_APP=5432
      - DB_USER_APP=devuser
      - DB_PASSWORD_APP=devpass
      - DB_NAME_APP=devdb
    depends_on:       # 确保postgres-db服务先于go-app启动
      postgres-db:
        condition: service_healthy # 更可靠的依赖：等待DB健康检查通过
    networks:
      - app-net

  # PostgreSQL Database Service
  postgres-db:
    image: postgres:15-alpine
    container_name: my_postgres_dev
    environment:
      - POSTGRES_USER=devuser
      - POSTGRES_PASSWORD=devpass
      - POSTGRES_DB=devdb
    volumes:
      - postgres_dev_data:/var/lib/postgresql/data # 使用命名卷持久化数据
    ports: # 可选：如果需要从主机直接访问DB调试
      - "5433:5432" # 主机5433映射到容器5432
    networks:
      - app-net
    healthcheck: # 确保数据库真正可用
      test: ["CMD-SHELL", "pg_isready -U devuser -d devdb"]
      interval: 5s
      timeout: 3s
      retries: 5

# 定义网络
networks:
  app-net:
    driver: bridge

# 定义命名卷
volumes:
  postgres_dev_data:

我们重点看一下这份docker-compose.yml文件：

  • 服务定义（ services）：go-app和postgres-db是我们定义的两个服务。

  • 服务镜像构建：go-app服务的build下面提供了该服务的源码路径（ ./app）与镜像构建文件名（ Dockerfile），docker-compose启动服务前会先使用该路径下的Dockerfile构建go-app的镜像。

  • 环境变量配置（environment）：Go应用所需的数据库连接信息等配置，通过环境变量从Compose文件注入。Go应用内部使用 os.Getenv() 读取。

  • 服务名解析与网络（ networks、 DB_HOST_APP=postgres-db）：Compose会自动为在同一个自定义网络（这里是 app-net）中的服务创建DNS记录，使得 go-app 容器可以通过服务名 postgres-db 直接访问PostgreSQL容器，而无需关心其动态分配的IP地址。

  • 启动依赖与健康检查（ depends_on、 healthcheck）： go-app 的 depends_on 确保 postgres-db 先启动。更进一步， condition: service_healthy 会等待 postgres-db 的 healthcheck 通过后， go-app 才启动，这比简单等待容器启动更可靠，避免了Go应用启动时DB尚未就绪的问题。

  • 数据持久化（ volumes 顶层和service内）： postgres_dev_data 是一个命名卷，用于持久化PostgreSQL的数据。即使 postgres-db 容器被删除和重新创建，数据也能保留。

docker-compose的使用也非常简单。

然后，在包含 docker-compose.yml 文件的目录（ ch27/composeapp/）下，我们可以通过docker-compose完成下面操作：

  • 启动所有服务： docker-compose up（前台运行，看日志）或 docker-compose up -d（后台运行）

  • 查看服务状态： docker-compose ps

  • 查看日志： docker-compose logs go-app（或 -f 实时跟踪）

  • 停止并移除所有服务： docker-compose down（加 -v 移除命名卷）

  • 进入容器执行命令： docker-compose exec go-app sh

Docker Compose通过一个简单的YAML文件，极大地简化了包含多个相互依赖服务的本地开发环境的搭建和管理。它让开发者能够快速启动一个与生产环境服务架构相似（但更轻量）的本地副本，专注于代码编写和调试，而无需深陷复杂的环境配置泥潭。它是从单个Dockerfile到生产级Kubernetes编排之间一个非常实用和高效的过渡工具，尤其适合Go这类编译型语言的快速迭代开发。

到这里，我们的Go应用已经容器化，并且在Docker Compose环境中测试完毕了，能够与依赖服务协同工作了。但是，如何在生产环境中大规模地管理、伸缩、容错并自动化这些容器化应用呢？Docker Compose主要面向单机开发和测试，其能力在生产级编排上是不足的。这时，Kubernetes（K8s）就该登场了。它已经成为云原生时代容器编排的事实标准，为我们提供了在生产环境中运行和管理分布式应用的强大平台。

小结

这节课，我们首先学习了如何将Go应用容器化。通过掌握Dockerfile的最佳实践（如选择合适的基础镜像、利用多阶段构建、优化层缓存、非root用户运行）和镜像优化技巧（如静态链接编译、使用 .dockerignore），我们可以为Go应用构建出轻量、高效、安全且可移植的“集装箱”。

在进入生产级编排之前，我们特别介绍了开发阶段的利器——Docker Compose。我们学习了如何通过 docker-compose.yml 文件定义和运行多容器Go应用及其依赖（如数据库、缓存），如何利用卷挂载实现代码热重载，以及Compose在简化本地开发、保障环境一致性和加速迭代方面的核心价值。

欢迎在留言区分享你的思考和方案！我是Tony Bai，我们下节课见。