Go学习笔记-Build & Deployment

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101

// main.go
package main

import (
    "flag"
    "fmt"
    "log"
    "os"
    "runtime"
    "time"
)

// 构建信息变量（在编译时注入）
var (
    Version   = "dev"
    BuildTime = "unknown"
    GitCommit = "unknown"
    GoVersion = runtime.Version()
)

// 1. 命令行参数处理
func parseFlags() (string, bool, bool) {
    var (
        configFile = flag.String("config", "config.json", "配置文件路径")
        verbose    = flag.Bool("verbose", false, "详细输出")
        version    = flag.Bool("version", false, "显示版本信息")
    )
    
    flag.Parse()
    
    if *version {
        showVersion()
        os.Exit(0)
    }
    
    return *configFile, *verbose, *version
}

// 2. 版本信息显示
func showVersion() {
    fmt.Printf("应用版本信息:\n")
    fmt.Printf("  版本: %s\n", Version)
    fmt.Printf("  构建时间: %s\n", BuildTime)
    fmt.Printf("  Git提交: %s\n", GitCommit)
    fmt.Printf("  Go版本: %s\n", GoVersion)
    fmt.Printf("  操作系统: %s\n", runtime.GOOS)
    fmt.Printf("  架构: %s\n", runtime.GOARCH)
}

// 3. 应用配置
type Config struct {
    Port        int    `json:"port"`
    Host        string `json:"host"`
    Environment string `json:"environment"`
    LogLevel    string `json:"log_level"`
}

func loadConfig(configFile string) *Config {
    // 默认配置
    config := &Config{
        Port:        8080,
        Host:        "localhost",
        Environment: "development",
        LogLevel:    "info",
    }
    
    // 这里可以从文件加载配置
    fmt.Printf("加载配置文件: %s\n", configFile)
    
    return config
}

// 4. 应用主逻辑
func runApplication(config *Config, verbose bool) {
    fmt.Printf("启动应用程序...\n")
    fmt.Printf("监听地址: %s:%d\n", config.Host, config.Port)
    fmt.Printf("环境: %s\n", config.Environment)
    
    if verbose {
        fmt.Printf("详细模式已启用\n")
        fmt.Printf("日志级别: %s\n", config.LogLevel)
    }
    
    // 模拟应用运行
    fmt.Println("应用程序正在运行...")
    time.Sleep(2 * time.Second)
    fmt.Println("应用程序正常退出")
}

func main() {
    configFile, verbose, _ := parseFlags()
    
    config := loadConfig(configFile)
    
    if verbose {
        showVersion()
        fmt.Println()
    }
    
    runApplication(config, verbose)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

# build.sh - 构建脚本
#!/bin/bash

# 构建信息
VERSION=${VERSION:-$(git describe --tags --always --dirty 2>/dev/null || echo "dev")}
BUILD_TIME=$(date -u '+%Y-%m-%d %H:%M:%S UTC')
GIT_COMMIT=$(git rev-parse HEAD 2>/dev/null || echo "unknown")

# 输出目录
OUTPUT_DIR="./bin"
mkdir -p $OUTPUT_DIR

echo "开始构建 Go 应用程序..."
echo "版本: $VERSION"
echo "构建时间: $BUILD_TIME"
echo "Git提交: $GIT_COMMIT"

# 构建标志
LDFLAGS="-X 'main.Version=$VERSION' -X 'main.BuildTime=$BUILD_TIME' -X 'main.GitCommit=$GIT_COMMIT'"

# 1. 基本构建
echo "1. 基本构建..."
go build -ldflags "$LDFLAGS" -o $OUTPUT_DIR/myapp ./

# 2. 优化构建（减小二进制大小）
echo "2. 优化构建..."
go build -ldflags "$LDFLAGS -s -w" -o $OUTPUT_DIR/myapp-optimized ./

# 3. 静态链接构建
echo "3. 静态链接构建..."
CGO_ENABLED=0 go build -ldflags "$LDFLAGS -s -w" -a -installsuffix cgo -o $OUTPUT_DIR/myapp-static ./

# 4. 交叉编译
echo "4. 交叉编译..."

# Linux AMD64
GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -ldflags "$LDFLAGS -s -w" -o $OUTPUT_DIR/myapp-linux-amd64 ./

# Linux ARM64
GOOS=linux GOARCH=arm64 CGO_ENABLED=0 go build -ldflags "$LDFLAGS -s -w" -o $OUTPUT_DIR/myapp-linux-arm64 ./

# Windows AMD64
GOOS=windows GOARCH=amd64 CGO_ENABLED=0 go build -ldflags "$LDFLAGS -s -w" -o $OUTPUT_DIR/myapp-windows-amd64.exe ./

# macOS AMD64
GOOS=darwin GOARCH=amd64 CGO_ENABLED=0 go build -ldflags "$LDFLAGS -s -w" -o $OUTPUT_DIR/myapp-darwin-amd64 ./

# macOS ARM64 (Apple Silicon)
GOOS=darwin GOARCH=arm64 CGO_ENABLED=0 go build -ldflags "$LDFLAGS -s -w" -o $OUTPUT_DIR/myapp-darwin-arm64 ./

echo "构建完成！"
echo "输出文件:"
ls -la $OUTPUT_DIR/

# 显示文件大小
echo ""
echo "文件大小对比:"
du -h $OUTPUT_DIR/*

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// config_dev.go
//go:build dev
// +build dev

package main

import "fmt"

func init() {
    fmt.Println("开发环境配置已加载")
}

const (
    DatabaseURL = "localhost:5432"
    Debug       = true
    LogLevel    = "debug"
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// config_prod.go
//go:build prod
// +build prod

package main

import "fmt"

func init() {
    fmt.Println("生产环境配置已加载")
}

const (
    DatabaseURL = "prod-db.example.com:5432"
    Debug       = false
    LogLevel    = "error"
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// config_test.go
//go:build test
// +build test

package main

import "fmt"

func init() {
    fmt.Println("测试环境配置已加载")
}

const (
    DatabaseURL = "test-db:5432"
    Debug       = true
    LogLevel    = "info"
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// platform_unix.go
//go:build unix
// +build unix

package main

import (
    "fmt"
    "syscall"
)

func platformSpecificFunction() {
    fmt.Println("Unix平台特定功能")
    
    // Unix特定的系统调用
    var rusage syscall.Rusage
    syscall.Getrusage(syscall.RUSAGE_SELF, &rusage)
    
    fmt.Printf("用户CPU时间: %v\n", rusage.Utime)
    fmt.Printf("系统CPU时间: %v\n", rusage.Stime)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

// platform_windows.go
//go:build windows
// +build windows

package main

import (
    "fmt"
    "syscall"
    "unsafe"
)

func platformSpecificFunction() {
    fmt.Println("Windows平台特定功能")
    
    // Windows特定的API调用
    kernel32 := syscall.NewLazyDLL("kernel32.dll")
    getComputerName := kernel32.NewProc("GetComputerNameW")
    
    buffer := make([]uint16, 256)
    size := uint32(len(buffer))
    
    ret, _, _ := getComputerName.Call(
        uintptr(unsafe.Pointer(&buffer[0])),
        uintptr(unsafe.Pointer(&size)),
    )
    
    if ret != 0 {
        computerName := syscall.UTF16ToString(buffer[:size])
        fmt.Printf("计算机名: %s\n", computerName)
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# 使用构建标签编译
echo "使用不同构建标签编译:"

# 开发环境
echo "开发环境构建:"
go build -tags dev -o bin/myapp-dev ./

# 生产环境
echo "生产环境构建:"
go build -tags prod -o bin/myapp-prod ./

# 测试环境
echo "测试环境构建:"
go build -tags test -o bin/myapp-test ./

# 多个标签
echo "多标签构建:"
go build -tags "prod,monitoring" -o bin/myapp-prod-monitoring ./

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

# Dockerfile.multistage - 多阶段构建
# 第一阶段：构建阶段
FROM golang:1.21-alpine AS builder

# 设置工作目录
WORKDIR /app

# 安装必要的包
RUN apk add --no-cache git ca-certificates tzdata

# 复制go mod文件
COPY go.mod go.sum ./

# 下载依赖
RUN go mod download

# 复制源代码
COPY . .

# 构建应用
RUN CGO_ENABLED=0 GOOS=linux go build \
    -ldflags='-w -s -extldflags "-static"' \
    -a -installsuffix cgo \
    -o myapp .

# 第二阶段：运行阶段
FROM scratch

# 从构建阶段复制必要文件
COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
COPY --from=builder /usr/share/zoneinfo /usr/share/zoneinfo
COPY --from=builder /app/myapp /myapp

# 设置时区
ENV TZ=Asia/Shanghai

# 暴露端口
EXPOSE 8080

# 运行应用
ENTRYPOINT ["/myapp"]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

# Dockerfile.alpine - Alpine Linux基础镜像
FROM golang:1.21-alpine AS builder

WORKDIR /app

# 安装构建依赖
RUN apk add --no-cache git

# 复制依赖文件
COPY go.mod go.sum ./
RUN go mod download

# 复制源代码并构建
COPY . .
RUN go build -o myapp .

# 运行阶段
FROM alpine:latest

# 安装运行时依赖
RUN apk --no-cache add ca-certificates tzdata

WORKDIR /root/

# 复制二进制文件
COPY --from=builder /app/myapp .

# 复制配置文件
COPY config.json .

EXPOSE 8080

CMD ["./myapp"]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

# docker-compose.yml
version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile.multistage
    ports:
      - "8080:8080"
    environment:
      - ENV=production
      - LOG_LEVEL=info
    volumes:
      - ./config:/app/config:ro
      - ./logs:/app/logs
    depends_on:
      - redis
      - postgres
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "wget", "--quiet", "--tries=1", "--spider", "http://localhost:8080/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    restart: unless-stopped

  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: myapp
      POSTGRES_PASSWORD: myapp_password
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: unless-stopped

volumes:
  redis_data:
  postgres_data:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

# docker-build.sh - Docker构建脚本
#!/bin/bash

# 设置变量
IMAGE_NAME="myapp"
VERSION=${VERSION:-$(git describe --tags --always --dirty 2>/dev/null || echo "latest")}
REGISTRY=${REGISTRY:-"localhost:5000"}

echo "构建Docker镜像..."
echo "镜像名称: $IMAGE_NAME"
echo "版本: $VERSION"
echo "仓库: $REGISTRY"

# 构建镜像
docker build -t $IMAGE_NAME:$VERSION -f Dockerfile.multistage .

# 标记为latest
docker tag $IMAGE_NAME:$VERSION $IMAGE_NAME:latest

# 如果指定了仓库，则推送镜像
if [ "$REGISTRY" != "localhost:5000" ]; then
    echo "推送镜像到仓库..."
    docker tag $IMAGE_NAME:$VERSION $REGISTRY/$IMAGE_NAME:$VERSION
    docker tag $IMAGE_NAME:latest $REGISTRY/$IMAGE_NAME:latest
    
    docker push $REGISTRY/$IMAGE_NAME:$VERSION
    docker push $REGISTRY/$IMAGE_NAME:latest
fi

echo "Docker镜像构建完成！"
docker images | grep $IMAGE_NAME

1
2
3
4
5
6
7

# k8s/namespace.yaml
apiVersion: v1
kind: Namespace
metadata:
  name: myapp
  labels:
    name: myapp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# k8s/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: myapp-config
  namespace: myapp
data:
  config.json: |
    {
      "port": 8080,
      "host": "0.0.0.0",
      "environment": "production",
      "log_level": "info",
      "database": {
        "host": "postgres-service",
        "port": 5432,
        "name": "myapp",
        "ssl_mode": "require"
      },
      "redis": {
        "host": "redis-service",
        "port": 6379
      }
    }    

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# k8s/secret.yaml
apiVersion: v1
kind: Secret
metadata:
  name: myapp-secret
  namespace: myapp
type: Opaque
data:
  # base64编码的密码
  db-password: bXlhcHBfcGFzc3dvcmQ=  # myapp_password
  redis-password: cmVkaXNfcGFzc3dvcmQ=  # redis_password

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

# k8s/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-deployment
  namespace: myapp
  labels:
    app: myapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: myapp:latest
        ports:
        - containerPort: 8080
        env:
        - name: DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: myapp-secret
              key: db-password
        - name: REDIS_PASSWORD
          valueFrom:
            secretKeyRef:
              name: myapp-secret
              key: redis-password
        volumeMounts:
        - name: config-volume
          mountPath: /app/config
          readOnly: true
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 5
        resources:
          requests:
            memory: "64Mi"
            cpu: "250m"
          limits:
            memory: "128Mi"
            cpu: "500m"
      volumes:
      - name: config-volume
        configMap:
          name: myapp-config

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# k8s/service.yaml
apiVersion: v1
kind: Service
metadata:
  name: myapp-service
  namespace: myapp
spec:
  selector:
    app: myapp
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: ClusterIP

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# k8s/ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: myapp-ingress
  namespace: myapp
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
    cert-manager.io/cluster-issuer: "letsencrypt-prod"
spec:
  tls:
  - hosts:
    - myapp.example.com
    secretName: myapp-tls
  rules:
  - host: myapp.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: myapp-service
            port:
              number: 80

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

# deploy.sh - Kubernetes部署脚本
#!/bin/bash

NAMESPACE="myapp"
KUBECTL="kubectl"

echo "部署应用到Kubernetes..."

# 创建命名空间
echo "创建命名空间..."
$KUBECTL apply -f k8s/namespace.yaml

# 应用配置
echo "应用配置..."
$KUBECTL apply -f k8s/configmap.yaml
$KUBECTL apply -f k8s/secret.yaml

# 部署应用
echo "部署应用..."
$KUBECTL apply -f k8s/deployment.yaml
$KUBECTL apply -f k8s/service.yaml
$KUBECTL apply -f k8s/ingress.yaml

# 等待部署完成
echo "等待部署完成..."
$KUBECTL rollout status deployment/myapp-deployment -n $NAMESPACE

# 显示部署状态
echo "部署状态:"
$KUBECTL get pods -n $NAMESPACE
$KUBECTL get services -n $NAMESPACE
$KUBECTL get ingress -n $NAMESPACE

echo "部署完成！"