Golang（簡稱 Go）是 Google 開發(fā)的靜態(tài)類型編程語言，語法上借鑒了 C 語言的簡潔性，但彌補了 C 語言的諸多痛點，比如自帶垃圾回收（不用手動管理內(nèi)存）、強類型安全（減少運行時錯誤）、原生支持并發(fā)（輕松處理高并發(fā)場景），還內(nèi)置了變長數(shù)組、鍵值映射（map）等實用類型，以及一個極其豐富的標準庫（從網(wǎng)絡(luò)請求到文件處理，不用依賴太多第三方庫）。

關(guān)于 Golang

Golang（簡稱 Go）是 Google 開發(fā)的靜態(tài)類型編程語言，語法上借鑒了 C 語言的簡潔性，但彌補了 C 語言的諸多痛點，比如自帶垃圾回收（不用手動管理內(nèi)存）、強類型安全（減少運行時錯誤）、原生支持并發(fā)（輕松處理高并發(fā)場景），還內(nèi)置了變長數(shù)組、鍵值映射（map）等實用類型，以及一個極其豐富的標準庫（從網(wǎng)絡(luò)請求到文件處理，不用依賴太多第三方庫）。

簡單說，Golang 的核心優(yōu)勢是“快、簡、穩(wěn)”：編譯快（幾分鐘能編譯大型項目）、運行快（編譯后是二進制文件，直接執(zhí)行，比解釋型語言快很多）、寫法簡潔（代碼量比 Java 少 30%-50%）、運行穩(wěn)定（垃圾回收機制減少內(nèi)存泄漏，并發(fā)模型避免死鎖）。

它的應(yīng)用場景幾乎覆蓋了后端開發(fā)的所有領(lǐng)域，也是當前云原生技術(shù)的“首選語言”：

• 后端服務(wù)開發(fā)：搭建 API 接口、用戶服務(wù)、訂單系統(tǒng)等（比如字節(jié)跳動、騰訊的很多后端服務(wù)用 Go 寫）；
• 微服務(wù)與云原生：Kubernetes（容器編排工具）、Docker（容器引擎）、Istio（服務(wù)網(wǎng)格）等核心組件全是 Go 開發(fā)的，用 Go 寫微服務(wù)能完美適配這些生態(tài)；
• 高并發(fā)場景：直播彈幕、實時聊天、秒殺系統(tǒng)等（Go 的 goroutine 并發(fā)模型，能輕松支撐百萬級并發(fā)，資源占用還少）；
• 工具開發(fā)：比如 Terraform（基礎(chǔ)設(shè)施即代碼工具）、Grafana（監(jiān)控工具）、 Hugo（靜態(tài)網(wǎng)站生成器），都是 Go 寫的，編譯后單文件，跨平臺易部署；
• 嵌入式開發(fā)：Go 編譯后的二進制體積小、不依賴虛擬機，適合嵌入式設(shè)備（比如物聯(lián)網(wǎng)設(shè)備的控制程序）。

為什么用 Docker 部署 Golang？

傳統(tǒng)方式用 Golang 開發(fā)部署，常踩這些坑：“本地跑的好好的，到服務(wù)器就報錯”（開發(fā)機 Go 1.24，服務(wù)器 1.22，版本不兼容）、“兩個項目依賴不同版本的庫，裝在同一臺機器沖突了”、“服務(wù)器沒裝 Go 環(huán)境，編譯都沒法弄”。而 Docker 能把這些問題全解決，核心優(yōu)勢有 5 點：

1. 環(huán)境絕對一致：Golang 鏡像里已經(jīng)打包好了指定版本的 Go 環(huán)境、系統(tǒng)依賴（比如 gcc、git），不管是開發(fā)機、測試機還是生產(chǎn)服務(wù)器，只要能跑 Docker，就能用一模一樣的 Go 環(huán)境——徹底告別“本地能跑、線上崩了”；
2. 輕量高效：Go 編譯后是單文件二進制，本身就小，再搭配 Alpine 版的 Golang 鏡像（僅幾十 MB），最終的容器體積比 Java、Python 容器小 80%，啟動只要幾秒，還能靈活限制 CPU/內(nèi)存；
3. 完全隔離：不同項目的 Go 環(huán)境互不干擾（比如 A 項目用 Go 1.25，B 項目用 1.24），就算一個項目的容器崩了，也不會影響其他項目，降低故障擴散風險；
4. 部署迭代快：編譯、打包、啟動全用命令行搞定，更新時只要重新構(gòu)建鏡像、重啟容器（10 秒內(nèi)完成）；如果新版本有問題，刪了新容器、啟動舊鏡像就能回滾，比傳統(tǒng)“裝環(huán)境→編譯→部署”快 10 倍；
5. 不用裝本地 Go 環(huán)境：就算你電腦沒裝 Go，只要有 Docker，就能拉取 Golang 鏡像，在容器里寫代碼、編譯、運行——尤其適合新手，不用折騰本地環(huán)境配置。

?? 準備工作：安裝 Docker 與 Docker Compose

如果你的 Linux 服務(wù)器還沒裝 Docker，直接用下面的一鍵安裝腳本（推薦新手用），能自動裝 Docker、Docker Compose，還會配置軒轅鏡像加速（拉取 Golang 鏡像更快）：

bash <(wget -qO- https://xuanyuan.cloud/docker.sh)

腳本支持 CentOS、Ubuntu、Debian 等主流 Linux 發(fā)行版，執(zhí)行后等幾分鐘，出現(xiàn)“Docker installed successfully”就說明裝好了。

1、查看 Golang 鏡像：選對版本很重要

首先打開軒轅鏡像的 Golang 頁面：?? https://xuanyuan.cloud/r/library/golang，頁面里列了所有“支持的標簽（tags）”，不同標簽對應(yīng)不同的 Go 版本和基礎(chǔ)系統(tǒng)，選對標簽?zāi)苌僮吆芏鄰澛贰?/p>

先簡單解釋下標簽的含義（新手必看，高級工程師可快速跳過）：

標簽示例	含義說明	適用場景
1.25.2-trixie	Go 1.25.2 版本，基于 Debian Trixie 系統(tǒng)	需要完整系統(tǒng)工具（如 git）
1.25.2-bookworm	Go 1.25.2 版本，基于 Debian Bookworm 系統(tǒng)	穩(wěn)定版系統(tǒng)，推薦生產(chǎn)用
1.25.2-alpine3.22	Go 1.25.2 版本，基于 Alpine 3.22 系統(tǒng)	追求最小鏡像體積（僅 ~50MB）
1.25.2-windowsservercore	Go 1.25.2 版本，基于 Windows Server Core	Windows 服務(wù)器環(huán)境
tip-trixie	Go 最新開發(fā)分支（不穩(wěn)定），基于 Debian Trixie	測試新特性，不適合生產(chǎn)

推薦選擇：生產(chǎn)環(huán)境用 1.25.2-bookworm（穩(wěn)定）或 1.25.2-alpine3.22（輕量）；測試用 1.25-bookworm（自動匹配 1.25 系列最新小版本）；Windows 環(huán)境用 1.25.2-windowsservercore-ltsc2022。

2、下載 Golang 鏡像：4 種拉取方式

下面提供 4 種拉取方式，新手優(yōu)先選“免登錄拉取”（不用配置賬戶，直接用），高級工程師可根據(jù)網(wǎng)絡(luò)環(huán)境選。所有方式拉取的鏡像內(nèi)容完全一致，只是地址不同。

2.1 免登錄拉取（推薦新手）

這是最簡單的方式，不用注冊登錄，直接拉取，還能自動用軒轅鏡像加速：

# 拉取 Go 1.25.2 穩(wěn)定版（基于 Debian Bookworm）
docker pull xxx.xuanyuan.run/library/golang:1.25.2-bookworm

# （可選）如果想簡化鏡像名，比如改成“golang:1.25”，后續(xù)命令更短
docker tag xxx.xuanyuan.run/library/golang:1.25.2-bookworm golang:1.25

# （可選）刪除臨時的長標簽鏡像，避免占用額外空間
docker rmi xxx.xuanyuan.run/library/golang:1.25.2-bookworm

2.2 登錄驗證拉?。ㄐ栀~戶）

如果用軒轅鏡像的登錄功能，可拉取 docker.xuanyuan.run 前綴的鏡像（需先在軒轅鏡像平臺注冊登錄）：

# 1. 先登錄（按提示輸入用戶名密碼）
docker login docker.xuanyuan.run

# 2. 拉取鏡像
docker pull docker.xuanyuan.run/library/golang:1.25.2-bookworm

# 3. （可選）改名+刪臨時標簽（同 2.1）
docker tag docker.xuanyuan.run/library/golang:1.25.2-bookworm golang:1.25
docker rmi docker.xuanyuan.run/library/golang:1.25.2-bookworm

2.3 官方直連拉取（網(wǎng)絡(luò)好時用）

如果你的服務(wù)器能直接連 Docker Hub（或已配置其他鏡像加速），可直接拉取官方鏡像：

docker pull library/golang:1.25.2-bookworm
# 簡化名：docker tag library/golang:1.25.2-bookworm golang:1.25

2.4 確認鏡像拉取成功

不管用哪種方式，拉取后執(zhí)行下面的命令，查看是否成功：

docker images

如果輸出類似下面的內(nèi)容，說明成功了（IMAGE ID 會不一樣，正常）：

REPOSITORY          TAG               IMAGE ID       CREATED        SIZE
golang              1.25              a1b2c3d4e5f6   1 week ago     980MB  # Debian 版
# 或 Alpine 版（體積更小）：
# golang              1.25-alpine       f5e6d7c8b9a0   1 week ago     45MB

3、部署 Golang：3 種場景，按需選擇

下面提供 3 種部署方案，覆蓋“快速測試”“開發(fā)生產(chǎn)”“企業(yè)級多服務(wù)”場景，步驟詳細到能照著敲命令。

3.1 快速部署：測試單個 Go 程序（新手入門）

適合想快速跑一段 Go 代碼，不用復雜配置的場景（比如測試“Hello World”）。

步驟 1：寫一個簡單的 Go 程序

在你的服務(wù)器上新建一個目錄（比如 golang-test），然后創(chuàng)建 main.go 文件：

# 1. 新建目錄并進入
mkdir -p ~/golang-test && cd ~/golang-test

# 2. 寫一個簡單的 Go 程序（輸出 Hello + 當前時間）
cat > main.go << 'EOF'
package main

import (
    "fmt"
    "time"
)

func main() {
    fmt.Printf("Hello Golang! Current time: %s\n", time.Now().Format("2006-01-02 15:04:05"))
    // 讓程序多跑 30 秒，方便查看容器
    time.Sleep(30 * time.Second)
}
EOF

步驟 2：用 Golang 鏡像運行程序

不用在本地裝 Go 環(huán)境，直接用容器里的 Go 執(zhí)行代碼：

docker run --rm -v $PWD:/app -w /app golang:1.25 go run main.go

命令解釋（新手必看）：

• --rm：容器退出后自動刪除（避免殘留無用容器）；
• -v $PWD:/app：把當前目錄（~/golang-test）掛載到容器的 /app 目錄（這樣容器能讀到 main.go）；
• -w /app：把容器的工作目錄設(shè)為 /app（相當于在容器里 cd /app）；
• golang:1.25：用我們之前拉取的鏡像；
• go run main.go：在容器里執(zhí)行 Go 程序的命令。

預期結(jié)果：

控制臺會輸出類似下面的內(nèi)容，說明運行成功：

Hello Golang! Current time: 2025-01-01 10:00:00

3.2 掛載目錄部署：開發(fā)/生產(chǎn)推薦（兼顧靈活與穩(wěn)定）

這種方式適合“需要保留編譯結(jié)果”“代碼經(jīng)常修改”的場景（比如開發(fā)中的項目，或生產(chǎn)環(huán)境的服務(wù)）。核心思路是：把宿主機的“代碼目錄”“編譯目錄”掛載到容器，在容器里編譯，編譯后的二進制文件存在宿主機，下次運行直接用二進制（不用重復編譯）。

步驟 1：創(chuàng)建宿主機目錄

先在宿主機建 3 個目錄，分別存代碼、編譯結(jié)果、日志（目錄路徑可自定義，這里用 /data/golang 為例）：

# 一次性創(chuàng)建 3 個目錄
mkdir -p /data/golang/{src,build,logs}

• /data/golang/src：放 Go 源代碼（比如 main.go、go.mod）；
• /data/golang/build：放編譯后的二進制文件；
• /data/golang/logs：放程序運行日志。

步驟 2：準備 Go 代碼與依賴文件

在 src 目錄下創(chuàng)建 main.go 和 go.mod（Go 1.11+ 依賴管理用 go mod，必須有這個文件）：

# 進入 src 目錄
cd /data/golang/src

# 1. 創(chuàng)建 go.mod（初始化模塊，模塊名自定義，比如 github.com/my-golang-app）
go mod init github.com/my-golang-app
# （如果宿主機沒裝 Go，也可以在容器里執(zhí)行：docker run --rm -v $PWD:/app -w /app golang:1.25 go mod init github.com/my-golang-app）

# 2. 創(chuàng)建 main.go（寫一個簡單的 HTTP 服務(wù)，監(jiān)聽 8080 端口，返回 Hello）
cat > main.go << 'EOF'
package main

import (
    "fmt"
    "log"
    "net/http"
    "os"
    "time"
)

// 日志文件路徑（容器里的路徑，對應(yīng)宿主機 /data/golang/logs）
const logPath = "/logs/app.log"

func main() {
    // 初始化日志（寫入文件，同時輸出到控制臺）
    logFile, err := os.OpenFile(logPath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
    if err != nil {
        log.Fatalf("Failed to open log file: %v", err)
    }
    defer logFile.Close()
    log.SetOutput(logFile)

    // 定義 HTTP 路由：訪問 / 時返回 Hello
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        msg := fmt.Sprintf("Hello Golang! Time: %s", time.Now().Format("2006-01-02 15:04:05"))
        log.Println(msg)  // 寫日志
        fmt.Fprintln(w, msg)  // 返回給客戶端
    })

    // 啟動 HTTP 服務(wù)，監(jiān)聽 8080 端口
    log.Println("Server starting on :8080...")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        log.Fatalf("Server failed: %v", err)
    }
}
EOF

步驟 3：在容器里編譯代碼

用 Golang 鏡像編譯 src 里的代碼，把二進制文件輸出到 build 目錄：

docker run --rm -v /data/golang/src:/app/src -v /data/golang/build:/app/build -w /app/src golang:1.25 go build -o /app/build/my-golang-server ./main.go

命令解釋：

• -v /data/golang/src:/app/src：掛載宿主機代碼目錄到容器 /app/src；
• -v /data/golang/build:/app/build：掛載宿主機編譯目錄到容器 /app/build；
• go build -o /app/build/my-golang-server：編譯 main.go，輸出二進制文件到 /app/build/my-golang-server（宿主機對應(yīng) /data/golang/build/my-golang-server）。

步驟 4：運行編譯后的二進制文件

編譯后的二進制文件是獨立的，不用 Go 環(huán)境也能運行——推薦用輕量的 alpine 鏡像運行（比 Golang 鏡像小很多，節(jié)省資源）：

# 啟動容器，命名為 golang-server，后臺運行
docker run -d --name golang-server \
  -p 8080:8080 \  # 宿主機 8080 端口映射到容器 8080 端口（服務(wù)監(jiān)聽的端口）
  -v /data/golang/logs:/logs \  # 掛載日志目錄，保存運行日志
  -v /data/golang/build:/app \  # 掛載編譯目錄，讀取二進制文件
  -w /app \  # 工作目錄設(shè)為 /app（二進制文件所在目錄）
  alpine:3.22 ./my-golang-server  # 用 alpine 鏡像運行二進制

步驟 5：驗證服務(wù)是否正常

有 3 種方式驗證：

1. 訪問 HTTP 服務(wù)：用瀏覽器或 curl 訪問服務(wù)器的 8080 端口：

   curl http://你的服務(wù)器IP:8080
   

   預期輸出：Hello Golang! Time: 2025-01-01 10:30:00

2. 查看容器狀態(tài)：

   docker ps | grep golang-server
   

   預期輸出（STATUS 為 Up，表示正常運行）：

   abc123def456   alpine:3.22   "./my-golang-server"   5 minutes ago   Up 5 minutes   0.0.0.0:8080->8080/tcp   golang-server
   

3. 查看運行日志：

   cat /data/golang/logs/app.log
   

   預期輸出（包含服務(wù)啟動日志和請求日志）：

   2025/01/01 10:30:00 Server starting on :8080...
   2025/01/01 10:30:05 Hello Golang! Time: 2025-01-02 10:30:05
   

3.3 Docker Compose 部署：企業(yè)級多服務(wù)場景（高級工程師用）

如果你的 Golang 服務(wù)需要依賴其他服務(wù)（比如 Redis、MySQL），用 docker-compose 能統(tǒng)一管理所有服務(wù)的配置，實現(xiàn)“一鍵啟動/停止”。下面以“Golang 服務(wù) + Redis”為例，演示部署流程。

步驟 1：創(chuàng)建 docker-compose.yml 文件

在宿主機新建一個目錄（比如 /data/golang-compose），然后創(chuàng)建 docker-compose.yml 文件：

# 新建目錄并進入
mkdir -p /data/golang-compose && cd /data/golang-compose

# 創(chuàng)建 docker-compose.yml
cat > docker-compose.yml << 'EOF'
version: '3.8'  # docker-compose 語法版本（3.8 兼容大部分 Docker 版本）

# 定義所有服務(wù)
services:
  # 1. Golang 服務(wù)
  golang-app:
    build:  # 用 Dockerfile 構(gòu)建鏡像（不用提前拉取，自動構(gòu)建）
      context: ./src  # Dockerfile 所在目錄（這里是 ./src）
      dockerfile: Dockerfile  # Dockerfile 文件名
    container_name: golang-app  # 容器名
    ports:
      - "8080:8080"  # 端口映射
    volumes:
      - ./logs:/logs  # 掛載日志目錄
    depends_on:
      - redis  # 依賴 redis 服務(wù)，redis 啟動后再啟動 golang-app
    restart: always  # 容器退出后自動重啟（保障服務(wù)可用性）
    environment:
      - REDIS_ADDR=redis:6379  # 給 Golang 服務(wù)傳環(huán)境變量：Redis 地址（容器名:端口）
      - TZ=Asia/Shanghai  # 設(shè)置時區(qū)（避免日志時間不對）

  # 2. Redis 服務(wù)（依賴的服務(wù)）
  redis:
    image: redis:7.2-alpine  # 用 Redis 輕量鏡像
    container_name: golang-redis
    volumes:
      - ./redis-data:/data  # 掛載 Redis 數(shù)據(jù)目錄，持久化數(shù)據(jù)
    restart: always
    environment:
      - TZ=Asia/Shanghai
EOF

步驟 2：創(chuàng)建 Golang 服務(wù)的 Dockerfile（多階段構(gòu)建）

在 src 目錄下創(chuàng)建 Dockerfile（多階段構(gòu)建能大幅減小最終鏡像體積，生產(chǎn)環(huán)境強烈推薦）：

# 新建 src 目錄
mkdir -p ./src && cd ./src

# 創(chuàng)建 Dockerfile
cat > Dockerfile << 'EOF'
# 第一階段：構(gòu)建階段（用完整的 Golang 鏡像編譯代碼）
FROM golang:1.25.2-bookworm AS builder

# 設(shè)置工作目錄
WORKDIR /app

# 復制 go.mod 和 go.sum（先復制依賴文件，利用 Docker 緩存，后續(xù)代碼修改不用重新下載依賴）
COPY go.mod go.sum ./
# 下載依賴（如果依賴沒改，這一步會用緩存）
RUN go mod download

# 復制所有源代碼
COPY . .

# 編譯代碼：CGO_ENABLED=0 禁用 CGO，生成靜態(tài)鏈接的二進制（能在 alpine 里運行）
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o my-golang-app ./main.go

# 第二階段：運行階段（用 alpine 鏡像，僅保留二進制文件，體積小）
FROM alpine:3.22

# 安裝必要工具（比如 ca-certificates，支持 HTTPS；tzdata 支持時區(qū)）
RUN apk --no-cache add ca-certificates tzdata

# 設(shè)置工作目錄
WORKDIR /app

# 從構(gòu)建階段復制二進制文件到當前鏡像
COPY --from=builder /app/my-golang-app .

# 暴露服務(wù)端口（和程序監(jiān)聽的端口一致）
EXPOSE 8080

# 啟動程序
CMD ["./my-golang-app"]
EOF

步驟 3：準備 Golang 代碼（帶 Redis 依賴）

在 src 目錄下創(chuàng)建 main.go、go.mod、go.sum（代碼會連接 Redis，記錄請求次數(shù)）：

# 1. 初始化 go mod（模塊名自定義）
go mod init github.com/my-golang-compose-app

# 2. 安裝 Redis 依賴（go-redis 庫）
go get github.com/redis/go-redis/v9@latest

# 3. 創(chuàng)建 main.go
cat > main.go << 'EOF'
package main

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "os"
    "time"

    "github.com/redis/go-redis/v9"
)

// 全局變量：Redis 客戶端、上下文、日志文件
var (
    redisClient *redis.Client
    ctx         = context.Background()
    logFile     *os.File
)

// 初始化函數(shù)：初始化 Redis 客戶端和日志
func init() {
    // 1. 初始化日志
    var err error
    logFile, err = os.OpenFile("/logs/app.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
    if err != nil {
        log.Fatalf("Failed to open log file: %v", err)
    }
    log.SetOutput(logFile)

    // 2. 從環(huán)境變量獲取 Redis 地址（docker-compose 里設(shè)置的 REDIS_ADDR）
    redisAddr := os.Getenv("REDIS_ADDR")
    if redisAddr == "" {
        redisAddr = "localhost:6379"  // 默認值（本地測試用）
    }

    // 3. 初始化 Redis 客戶端
    redisClient = redis.NewClient(&redis.Options{
        Addr:     redisAddr,
        Password: "",  // Redis 沒設(shè)密碼（生產(chǎn)環(huán)境要設(shè)，通過環(huán)境變量傳）
        DB:       0,   // 默認 DB
    })

    // 4. 測試 Redis 連接
    _, err = redisClient.Ping(ctx).Result()
    if err != nil {
        log.Fatalf("Failed to connect Redis: %v", err)
    }
    log.Println("Connected to Redis successfully")
}

// HTTP 處理函數(shù)：記錄請求次數(shù)，返回結(jié)果
func handleRequest(w http.ResponseWriter, r *http.Request) {
    // 1. Redis 自增，記錄請求次數(shù)
    count, err := redisClient.Incr(ctx, "request_count").Result()
    if err != nil {
        log.Printf("Redis Incr error: %v", err)
        http.Error(w, "Internal Server Error", http.StatusInternalServerError)
        return
    }

    // 2. 構(gòu)造響應(yīng)信息
    msg := fmt.Sprintf("Hello Golang + Redis! Request Count: %d, Time: %s",
        count, time.Now().Format("2006-01-02 15:04:05"))
    
    // 3. 寫日志
    log.Println(msg)

    // 4. 返回響應(yīng)
    fmt.Fprintln(w, msg)
}

func main() {
    // 注冊路由
    http.HandleFunc("/", handleRequest)

    // 啟動 HTTP 服務(wù)
    log.Println("Server starting on :8080...")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        log.Fatalf("Server failed: %v", err)
    }
}
EOF

步驟 4：啟動所有服務(wù)

在 docker-compose.yml 所在目錄（/data/golang-compose）執(zhí)行：

# 后臺啟動服務(wù)（-d 表示后臺運行）
docker compose up -d

第一次啟動會自動：1. 拉取 Redis 鏡像；2. 構(gòu)建 Golang 鏡像；3. 啟動兩個容器。耐心等幾分鐘，出現(xiàn)“Done”就說明啟動成功。

步驟 5：驗證服務(wù)

1. 訪問 Golang 服務(wù)：

   curl http://你的服務(wù)器IP:8080
   

   預期輸出（請求次數(shù)會遞增）：

   Hello Golang + Redis! Request Count: 1, Time: 2025-01-01 11:00:00
   

   再執(zhí)行一次 curl，請求次數(shù)會變成 2，說明 Redis 正常工作。

2. 查看服務(wù)狀態(tài)：

   docker compose ps
   

   預期輸出（兩個服務(wù)的 STATUS 都是 Up）：

   NAME                IMAGE                        COMMAND                  SERVICE             CREATED             STATUS              PORTS
   golang-app          golang-compose-golang-app    "./my-golang-app"        golang-app          2 minutes ago       Up 2 minutes        0.0.0.0:8080->8080/tcp
   golang-redis        redis:7.2-alpine             "docker-entrypoint.s…"   redis               2 minutes ago       Up 2 minutes        6379/tcp
   

3. 停止服務(wù)（如需）：

   # 停止并刪除容器（數(shù)據(jù)目錄 ./redis-data、./logs 會保留）
   docker compose down
   # 停止但不刪除容器：docker compose stop
   

4、常見問題：踩坑后怎么解決？

4.1 編譯后的二進制在 Alpine 里運行報錯：“exec format error”

原因：編譯時沒禁用 CGO，生成的二進制依賴 glibc，但 Alpine 用的是 musl libc，不兼容。
解決：編譯時加 CGO_ENABLED=0，比如：

# 容器里編譯時
RUN CGO_ENABLED=0 GOOS=linux go build -o /app/build/my-app ./main.go
# 或本地編譯時（用于掛載到容器）
CGO_ENABLED=0 GOOS=linux go build -o my-app ./main.go

4.2 容器里訪問不到宿主機的文件/目錄？

原因：掛載目錄時路徑寫錯，或權(quán)限不足。
解決：

1. 檢查掛載路徑：確保宿主機路徑是絕對路徑（比如用 $PWD 或 /data/golang/src，不要用相對路徑 ./src 除非在當前目錄）；
2. 調(diào)整目錄權(quán)限：給宿主機目錄加讀權(quán)限（比如 chmod -R 755 /data/golang）；
3. 用 --user 指定用戶：如果容器內(nèi)用戶和宿主機用戶 UID 不一致，掛載時加 --user $(id -u):$(id -g)，比如：

   docker run --rm -v $PWD:/app -w /app --user $(id -u):$(id -g) golang:1.25 go run main.go
   

4.3 Go 依賴下載慢，甚至超時？

原因：默認的 GOPROXY（proxy.golang.org）在國內(nèi)訪問慢。
解決：設(shè)置 GOPROXY 為國內(nèi)鏡像（比如阿里云、七牛云），有兩種方式：

1. 運行容器時指定環(huán)境變量：

   docker run --rm -v $PWD:/app -w /app -e GOPROXY=https://goproxy.cn,direct golang:1.25 go mod download
   

2. 在 Dockerfile 里設(shè)置：

   ENV GOPROXY=https://goproxy.cn,direct
   

4.4 容器內(nèi)時區(qū)不對，日志時間和本地差 8 小時？

原因：容器默認用 UTC 時區(qū)，國內(nèi)是東八區(qū)（Asia/Shanghai）。
解決：啟動容器時加 -e TZ=Asia/Shanghai，或在 Dockerfile 里加 ENV TZ=Asia/Shanghai（Alpine 鏡像要先裝 tzdata，參考 3.3 里的 Dockerfile）。

4.5 端口沖突：啟動容器時提示“port is already allocated”？

原因：宿主機的端口（比如 8080）已經(jīng)被其他進程占用。
解決：

1. 查看占用端口的進程：netstat -tuln | grep 8080 或 lsof -i:8080；
2. 要么停止占用端口的進程，要么換宿主機端口（比如把 -p 8080:8080 改成 -p 8081:8080）。

結(jié)尾

到這里，你已經(jīng)掌握了 Golang 鏡像的拉取和 Docker 部署全流程——從“快速測試代碼”到“生產(chǎn)環(huán)境服務(wù)”，再到“多服務(wù)編排”，覆蓋了大部分場景。

對于初學者，建議先從“3.1 快速部署”開始，熟悉容器和 Golang 鏡像的交互；然后嘗試“3.2 掛載目錄部署”，理解持久化和編譯分離的意義；最后再挑戰(zhàn)“3.3 Docker Compose 部署”，掌握多服務(wù)管理。

對于高級工程師，推薦用“多階段構(gòu)建”減小鏡像體積，用“環(huán)境變量”管理配置（避免硬編碼），用“volume 掛載”實現(xiàn)數(shù)據(jù)持久化——這些都是生產(chǎn)環(huán)境的最佳實踐。

如果遇到文檔沒覆蓋的問題，先看容器日志（docker logs 容器名），大部分錯誤都能在日志里找到原因；也可以參考 Golang 官方文檔 或 Docker 官方文檔，或在 Stack Overflow、Docker Community 提問。

隨著實踐深入，你還可以基于本文的基礎(chǔ)，探索更多高級用法：比如用 CI/CD 自動構(gòu)建 Golang 鏡像、用 Kubernetes 編排 Golang 服務(wù)、用 Prometheus 監(jiān)控 Golang 服務(wù)性能——Golang + Docker 的生態(tài)非常強大，能支撐從個人項目到企業(yè)級應(yīng)用的所有需求。