macos-tools/harbor/scripts/setup-build-cache.sh

#!/bin/bash

# Docker 构建缓存配置脚本
# 配置构建时使用的镜像缓存，提高构建速度

set -e

HARBOR_REGISTRY="192.168.1.83:8443"
HARBOR_USER="admin"
HARBOR_PASS="admin123"

# 颜色输出
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m'

info() { echo -e "${BLUE}INFO: $1${NC}"; }
success() { echo -e "${GREEN}SUCCESS: $1${NC}"; }
warning() { echo -e "${YELLOW}WARNING: $1${NC}"; }
error() { echo -e "${RED}ERROR: $1${NC}"; }

# 检测 Docker 环境
detect_docker_environment() {
    info "检测 Docker 环境..."

    if command -v docker > /dev/null 2>&1; then
        DOCKER_CLIENT_VERSION=$(docker --version | cut -d' ' -f3 | cut -d',' -f1)
        info "Docker 客户端版本: $DOCKER_CLIENT_VERSION"
    else
        error "Docker 客户端未找到"
        exit 1
    fi

    if docker info > /dev/null 2>&1; then
        DOCKER_SERVER_VERSION=$(docker version --format '{{.Server.Version}}')
        info "Docker 服务器版本: $DOCKER_SERVER_VERSION"
    else
        error "无法连接到 Docker 服务器"
        exit 1
    fi

    # 检测 BuildKit
    if docker buildx version > /dev/null 2>&1; then
        info "BuildKit 可用: $(docker buildx version | head -1)"
        BUILDKIT_AVAILABLE=true
    else
        warning "BuildKit 不可用，将使用传统构建器"
        BUILDKIT_AVAILABLE=false
    fi
}

# 创建 BuildKit 构建器
setup_buildx_builder() {
    if [ "$BUILDKIT_AVAILABLE" = false ]; then
        return
    fi

    info "配置 BuildKit 构建器..."

    # 检查是否已有构建器
    if docker buildx ls | grep -q "harbor-builder"; then
        info "Harbor 构建器已存在"
        docker buildx use harbor-builder
    else
        info "创建 Harbor 构建器..."
        docker buildx create --name harbor-builder --use --bootstrap
    fi

    success "BuildKit 构建器配置完成"
}

# 配置 Docker BuildKit 缓存
configure_buildkit_cache() {
    info "配置 BuildKit 镜像缓存..."

    # 创建 BuildKit 配置目录
    BUILDKIT_CONFIG_DIR="$HOME/.docker/buildkit"
    mkdir -p "$BUILDKIT_CONFIG_DIR"

    # 创建 BuildKit 配置文件
    cat > "$BUILDKIT_CONFIG_DIR/buildkitd.toml" << 'EOF'
[worker.oci]
  max-parallelism = 4

[registry."docker.io"]
  mirrors = ["https://192.168.1.83:8443"]
  http = true
  insecure = true

[registry."192.168.1.83:8443"]
  http = true
  insecure = true
  mirrors = ["https://docker.io"]

[registry."ghcr.io"]
  mirrors = ["https://192.168.1.83:8443"]
  http = true
  insecure = true

[registry."quay.io"]
  mirrors = ["https://192.168.1.83:8443"]
  http = true
  insecure = true

[registry."gcr.io"]
  mirrors = ["https://192.168.1.83:8443"]
  http = true
  insecure = true

[registry."registry.k8s.io"]
  mirrors = ["https://192.168.1.83:8443"]
  http = true
  insecure = true
EOF

    success "BuildKit 缓存配置完成"
}

# 创建 Docker 构建配置模板
create_docker_build_templates() {
    info "创建 Docker 构建配置模板..."

    # 创建构建缓存配置目录
    BUILD_CACHE_DIR="./build-cache"
    mkdir -p "$BUILD_CACHE_DIR"

    # 创建 Dockerfile 模板
    cat > "$BUILD_CACHE_DIR/Dockerfile.template" << 'EOF'
# Dockerfile 模板 - 启用构建缓存
# 使用方法:
# 1. 将此文件复制为 Dockerfile
# 2. 修改基础镜像和应用程序代码
# 3. 运行: docker build -t myapp .

# 第一阶段: 构建阶段
FROM golang:1.21-alpine AS builder

# 设置工作目录
WORKDIR /app

# 配置 Go 模块缓存 (利用 Harbor 缓存)
RUN --mount=type=cache,target=/go/pkg/mod \
    --mount=type=cache,target=/root/.cache/go-build \
    go mod download

# 复制源代码
COPY go.mod go.sum ./
RUN --mount=type=cache,target=/go/pkg/mod \
    --mount=type=cache,target=/root/.cache/go-build \
    go mod verify

# 复制源代码并构建
COPY . .
RUN --mount=type=cache,target=/root/.cache/go-build \
    CGO_ENABLED=0 GOOS=linux go build -o /app/server .

# 第二阶段: 运行阶段
FROM alpine:3.18

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

# 设置工作目录
WORKDIR /root/

# 从构建阶段复制二进制文件
COPY --from=builder /app/server .

# 设置时区
ENV TZ=Asia/Shanghai

# 暴露端口
EXPOSE 8080

# 启动命令
CMD ["./server"]
EOF

    # 创建 docker-compose 构建模板
    cat > "$BUILD_CACHE_DIR/docker-compose.build.yml" << 'EOF'
version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
      cache_from:
        - type=registry,ref=192.168.1.83:8443/build-cache/myapp:buildcache
      cache_to:
        - type=registry,ref=192.168.1.83:8443/build-cache/myapp:buildcache,mode=max
    image: myapp:latest
    ports:
      - "8080:8080"
EOF

    # 创建多阶段构建 Makefile
    cat > "$BUILD_CACHE_DIR/Makefile" << 'EOF'
.PHONY: build build-no-cache push clean help

# 默认目标
help:
	@echo "可用命令:"
	@echo "  build         - 构建镜像 (使用缓存)"
	@echo "  build-no-cache - 构建镜像 (不使用缓存)"
	@echo "  push          - 推送镜像到 Harbor"
	@echo "  clean         - 清理本地镜像"

# 使用缓存构建
build:
	docker buildx build \
		--cache-from type=registry,ref=192.168.1.83:8443/build-cache/app:buildcache \
		--cache-to type=registry,ref=192.168.1.83:8443/build-cache/app:buildcache,mode=max \
		-t 192.168.1.83:8443/build/app:latest \
		--load .

# 不使用缓存构建
build-no-cache:
	docker buildx build \
		--no-cache \
		-t 192.168.1.83:8443/build/app:latest \
		--load .

# 推送镜像
push: build
	docker push 192.168.1.83:8443/build/app:latest

# 清理镜像
clean:
	docker rmi 192.168.1.83:8443/build/app:latest 2>/dev/null || true
	docker system prune -f
EOF

    success "构建配置模板创建完成"
    info "模板文件位置: $BUILD_CACHE_DIR/"
}

# 配置 Kaniko 构建器（用于 CI/CD）
setup_kaniko_builder() {
    info "配置 Kaniko 构建器..."

    # 创建 Kaniko 配置
    KANIKO_DIR="./kaniko"
    mkdir -p "$KANIKO_DIR"

    cat > "$KANIKO_DIR/config.json" << EOF
{
  "auths": {
    "https://192.168.1.83:8443": {
      "username": "$HARBOR_USER",
      "password": "$HARBOR_PASS"
    }
  },
  "cache-dir": "/workspace/.cache",
  "cache": true,
  "cache-repo": "192.168.1.83:8443/kaniko-cache"
}
EOF

    # 创建 Kaniko 执行脚本
    cat > "$KANIKO_DIR/build.sh" << 'EOF'
#!/bin/bash
# Kaniko 构建脚本

IMAGE_NAME="${1:-app}"
IMAGE_TAG="${2:-latest}"
DOCKERFILE="${3:-Dockerfile}"
CONTEXT="${4:-.}"

echo "使用 Kaniko 构建镜像..."
echo "镜像名: $IMAGE_NAME:$IMAGE_TAG"
echo "Dockerfile: $DOCKERFILE"
echo "构建上下文: $CONTEXT"

# 运行 Kaniko
docker run --rm \
    -v "$PWD:/workspace" \
    -v "$PWD/kaniko/config.json:/kaniko/.docker/config.json" \
    -v "$HOME/.docker/buildkit:/root/.cache/buildkit" \
    gcr.io/kaniko-project/executor:latest \
    --dockerfile "/workspace/$DOCKERFILE" \
    --destination "192.168.1.83:8443/build/$IMAGE_NAME:$IMAGE_TAG" \
    --context "/workspace/$CONTEXT" \
    --cache=true \
    --cache-repo "192.168.1.83:8443/kaniko-cache" \
    --insecure \
    --insecure-pull
EOF

    chmod +x "$KANIKO_DIR/build.sh"

    success "Kaniko 构建器配置完成"
}

# 测试构建缓存
test_build_cache() {
    info "测试构建缓存配置..."

    # 创建测试 Dockerfile
    cat > /tmp/test-build.Dockerfile << 'EOF'
FROM alpine:3.18
RUN apk add --no-cache curl
CMD ["curl", "--version"]
EOF

    echo "测试基础镜像拉取..."
    if docker pull alpine:3.18 > /dev/null 2>&1; then
        success "基础镜像拉取成功"
    else
        warning "基础镜像拉取失败，将尝试从 Harbor 缓存"
        if docker pull 192.168.1.83:8443/build/alpine:3.18 > /dev/null 2>&1; then
            success "从 Harbor 缓存拉取成功"
        else
            warning "Harbor 缓存中也没有，将直接拉取"
        fi
    fi

    echo "测试构建缓存..."
    if [ "$BUILDKIT_AVAILABLE" = true ]; then
        echo "测试 BuildKit 构建..."
        # 这里可以添加实际的构建测试
        success "BuildKit 配置正常"
    else
        success "传统构建器配置正常"
    fi

    # 清理测试文件
    rm -f /tmp/test-build.Dockerfile
}

# 生成使用指南
generate_usage_guide() {
    echo ""
    echo "📚 Docker 构建缓存使用指南"
    echo "=========================="
    echo ""

    echo "1. 启用构建缓存:"
    echo "   # 登录 Harbor"
    echo "   echo '$HARBOR_PASS' | docker login $HARBOR_REGISTRY -u $HARBOR_USER --password-stdin"
    echo ""
    echo "   # 使用 BuildKit 构建"
    echo "   docker buildx build --cache-from type=registry,ref=$HARBOR_REGISTRY/build-cache/app:buildcache \\"
    echo "                  --cache-to type=registry,ref=$HARBOR_REGISTRY/build-cache/app:buildcache,mode=max \\"
    echo "                  -t myapp:latest ."
    echo ""

    echo "2. 使用 Makefile:"
    echo "   cd build-cache"
    echo "   make build    # 使用缓存构建"
    echo "   make push     # 推送到 Harbor"
    echo "   make clean    # 清理镜像"
    echo ""

    echo "3. 使用 Kaniko (CI/CD):"
    echo "   ./kaniko/build.sh myapp latest Dockerfile ."
    echo ""

    echo "4. 配置项目使用缓存:"
    echo "   # 在项目根目录创建 .dockerignore"
    echo "   echo '.git' > .dockerignore"
    echo "   echo 'node_modules' >> .dockerignore"
    echo "   echo '*.tmp' >> .dockerignore"
    echo ""
    echo "   # 使用缓存友好的 Dockerfile"
    echo "   # 参考 build-cache/Dockerfile.template"
    echo ""

    echo "5. 缓存策略建议:"
    echo "   - 开发环境: 启用本地缓存"
    echo "   - CI/CD 环境: 使用 Kaniko + Harbor 缓存"
    echo "   - 生产环境: 预构建并推送到 Harbor"
    echo ""

    echo "💡 性能优化建议:"
    echo "   - 合理划分构建阶段"
    echo "   - 将变化频率低的内容放在前面"
    echo "   - 使用 .dockerignore 排除不必要文件"
    echo "   - 定期清理构建缓存"
}

# 主函数
main() {
    info "配置 Docker 构建缓存..."
    echo ""

    # 检测环境
    detect_docker_environment

    # 配置 BuildKit
    setup_buildx_builder

    # 配置缓存
    configure_buildkit_cache

    # 创建模板
    create_docker_build_templates

    # 配置 Kaniko
    setup_kaniko_builder

    # 测试配置
    test_build_cache

    # 生成使用指南
    generate_usage_guide

    success "Docker 构建缓存配置完成!"
    echo ""
    echo "📁 配置文件位置:"
    echo "   - BuildKit: $HOME/.docker/buildkit/buildkitd.toml"
    echo "   - 构建模板: ./build-cache/"
    echo "   - Kaniko 配置: ./kaniko/"
    echo ""
    echo "🔗 Harbor Web: https://192.168.1.83:8443"
    echo "👤 登录信息: $HARBOR_USER / [HARBOR_PASSWORD]"
}

# 执行主函数
main "$@"