claude-code-router/docker-build-proxy.sh

#!/bin/bash

# Docker 构建代理配置脚本
# 解决 apt/pip/npm install 等构建时网络超时问题
#
# 作者: Claude Code Assistant
# 版本: 1.0.0

set -e

# 配置变量
HARBOR_REGISTRY="192.168.1.83:8443"
HARBOR_USER="admin"
HARBOR_PASS="admin123"

# 代理配置 (根据你的网络环境调整)
# 如果你有代理服务器，请修改这里
HTTP_PROXY="${HTTP_PROXY:-}"
HTTPS_PROXY="${HTTPS_PROXY:-}"
NO_PROXY="localhost,127.0.0.1,192.168.1.83,192.168.*,10.*,172.16.*,.local,.internal"

# 颜色输出
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
PURPLE='\033[0;35m'
CYAN='\033[0;36m'
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}"; }
header() { echo -e "${PURPLE}🚀 $1${NC}"; }
step() { echo -e "${CYAN}▶ $1${NC}"; }

# 显示帮助信息
show_help() {
    cat << EOF
Docker 构建代理配置脚本

用法:
    $0 [选项]

选项:
    -h, --help          显示此帮助信息
    -p, --proxy URL     设置HTTP代理 (例如: http://127.0.0.1:7890)
    -s, --socks URL     设置SOCKS代理 (例如: socks5://127.0.0.1:7890)
    --detect            自动检测系统代理设置
    --setup             配置Docker代理透传
    --test              测试代理配置
    --create-templates  创建构建模板文件
    --status            显示当前配置状态

示例:
    $0 --detect                           # 自动检测代理
    $0 --proxy http://127.0.0.1:7890      # 配置HTTP代理
    $0 --setup --create-templates         # 完整配置并创建模板
    $0 --test                             # 测试配置

EOF
}

# 检测系统代理设置
detect_proxy() {
    header "检测系统代理设置..."

    # 检查环境变量
    if [ -n "$HTTP_PROXY" ]; then
        info "发现 HTTP_PROXY: $HTTP_PROXY"
    fi

    if [ -n "$HTTPS_PROXY" ]; then
        info "发现 HTTPS_PROXY: $HTTPS_PROXY"
    fi

    # 检查常见代理端口
    for port in 7890 1087 8080 8888; do
        if nc -z localhost $port 2>/dev/null; then
            info "发现本地代理服务在端口: $port"
            PROXY_URL="http://127.0.0.1:$port"
            echo "建议代理地址: $PROXY_URL"
        fi
    done

    # 检查 Clash 等工具
    if pgrep -f "clash" > /dev/null; then
        info "检测到 Clash 进程，通常代理端口为 7890"
        PROXY_URL="http://127.0.0.1:7890"
        echo "建议代理地址: $PROXY_URL"
    fi

    # 检查 Shadowsocks
    if pgrep -f "shadowsocks" > /dev/null; then
        info "检测到 Shadowsocks 进程"
    fi

    success "代理检测完成"
}

# 配置 Docker daemon 代理
configure_docker_daemon_proxy() {
    header "配置 Docker daemon 代理..."

    if [ -z "$HTTP_PROXY" ] && [ -z "$HTTPS_PROXY" ]; then
        warning "未设置代理地址，跳过 Docker daemon 配置"
        return
    fi

    # 创建 Docker 配置目录
    DOCKER_CONFIG_DIR="$HOME/.docker"
    mkdir -p "$DOCKER_CONFIG_DIR"

    # 创建 daemon 配置
    DAEMON_CONFIG="$DOCKER_CONFIG_DIR/config.json"

    if [ -f "$DAEMON_CONFIG" ]; then
        backup "$DAEMON_CONFIG"
    fi

    # 生成新的配置
    cat > "$DAEMON_CONFIG" << EOF
{
  "proxies": {
    "default": {
      "httpProxy": "$HTTP_PROXY",
      "httpsProxy": "$HTTPS_PROXY",
      "noProxy": "$NO_PROXY"
    }
  },
  "registry-mirrors": [
    "https://syxpn3chjq4bgj.xuanyuan.run",
    "https://$HARBOR_REGISTRY"
  ],
  "insecure-registries": [
    "syxpn3chjq4bgj.xuanyuan.run",
    "$HARBOR_REGISTRY"
  ],
  "max-concurrent-downloads": 15,
  "experimental": true,
  "features": {
    "buildkit": true
  }
}
EOF

    success "Docker daemon 代理配置完成"
    info "需要重启 Docker 服务使配置生效"

    if command -v orbctl > /dev/null 2>&1; then
        info "使用 OrbStack，请重启 OrbStack"
        info "或在 OrbStack 设置中手动配置代理"
    else
        info "使用 Docker Desktop，请在设置中配置代理"
    fi
}

# 创建构建配置模板
create_build_templates() {
    header "创建构建配置模板..."

    # 创建模板目录
    TEMPLATES_DIR="./docker-build-templates"
    mkdir -p "$TEMPLATES_DIR"

    # 1. 创建代理 Dockerfile 模板
    cat > "$TEMPLATES_DIR/Dockerfile.proxy" << 'EOF'
# Dockerfile 模板 - 启用代理支持
# 解决构建时 apt/pip/npm 网络超时问题

ARG HTTP_PROXY
ARG HTTPS_PROXY
ARG NO_PROXY
ENV HTTP_PROXY=${HTTP_PROXY}
ENV HTTPS_PROXY=${HTTPS_PROXY}
ENV NO_PROXY=${NO_PROXY}

# 选择基础镜像 (根据需要修改)
FROM ubuntu:22.04

# 如果需要使用国内镜像源，取消下面的注释
# RUN sed -i 's@http://archive.ubuntu.com@https://mirrors.aliyun.com@g' /etc/apt/sources.list || \
#     sed -i 's@http://security.ubuntu.com@https://mirrors.aliyun.com@g' /etc/apt/sources.list

# 配置 apt 代理 (如果设置了代理)
RUN if [ -n "${HTTP_PROXY}" ]; then \
        echo "Acquire::http::Proxy \"${HTTP_PROXY}\";" > /etc/apt/apt.conf.d/01proxy && \
        echo "Acquire::https::Proxy \"${HTTPS_PROXY}\";" >> /etc/apt/apt.conf.d/01proxy; \
    fi

# 更新包管理器并安装依赖 (使用重试机制)
RUN apt-get update --fix-missing || \
    (sleep 10 && apt-get update --fix-missing) || \
    (sleep 30 && apt-get update --fix-missing) && \
    apt-get install -y --no-install-recommends \
        ca-certificates \
        curl \
        wget \
        gnupg \
        && rm -rf /var/lib/apt/lists/*

# 后续构建步骤...
# RUN apt-get install -y your-dependencies
# COPY . /app
# WORKDIR /app
# RUN your-build-commands
# CMD ["your-app"]
EOF

    # 2. 创建多阶段构建模板 (支持缓存)
    cat > "$TEMPLATES_DIR/Dockerfile.multi-stage" << 'EOF'
# 多阶段构建模板 - 支持构建缓存和代理

ARG HTTP_PROXY
ARG HTTPS_PROXY
ARG NO_PROXY

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

# 继承代理参数
ARG HTTP_PROXY
ARG HTTPS_PROXY
ARG NO_PROXY
ENV HTTP_PROXY=${HTTP_PROXY}
ENV HTTPS_PROXY=${HTTPS_PROXY}
ENV NO_PROXY=${NO_PROXY}

# 如果使用国内镜像源，取消注释
# RUN sed -i 's/dl-cdn.alpinelinux.org/mirrors.aliyun.com/g' /etc/apk/repositories

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

# 设置工作目录
WORKDIR /app

# 配置 Go 代理
ENV GOPROXY=https://goproxy.cn,direct
ENV GOSUMDB=sum.golang.google.cn

# 使用缓存挂载下载依赖
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 \
    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 curl

# 设置时区
ENV TZ=Asia/Shanghai

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

WORKDIR /app
EXPOSE 8080
CMD ["./server"]
EOF

    # 3. 创建带代理的构建脚本
    cat > "$TEMPLATES_DIR/build-with-proxy.sh" << EOF
#!/bin/bash

# 带代理的构建脚本

# 配置代理 (根据实际情况修改)
PROXY_URL="${PROXY_URL:-http://127.0.0.1:7890}"
IMAGE_NAME="\${1:-myapp}"
IMAGE_TAG="\${2:-latest}"
DOCKERFILE="\${3:-Dockerfile}"

if [ -z "\$PROXY_URL" ]; then
    echo "❌ 未设置代理地址"
    echo "用法: PROXY_URL=http://127.0.0.1:7890 $0 [image] [tag] [dockerfile]"
    exit 1
fi

echo "🚀 构建镜像: \$IMAGE_NAME:\$IMAGE_TAG"
echo "🔗 代理地址: \$PROXY_URL"
echo "📄 Dockerfile: \$DOCKERFILE"

# 使用 BuildKit 构建
DOCKER_BUILDKIT=1 docker build \\
    --build-arg HTTP_PROXY="\$PROXY_URL" \\
    --build-arg HTTPS_PROXY="\$PROXY_URL" \\
    --build-arg NO_PROXY="localhost,127.0.0.1,192.168.1.83" \\
    -t "\$IMAGE_NAME:\$IMAGE_TAG" \\
    -f "\$DOCKERFILE" \\
    .

echo "✅ 构建完成"
EOF

    chmod +x "$TEMPLATES_DIR/build-with-proxy.sh"

    # 4. 创建 Docker Compose 模板
    cat > "$TEMPLATES_DIR/docker-compose.proxy.yml" << 'EOF'
version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
      args:
        HTTP_PROXY: ${HTTP_PROXY}
        HTTPS_PROXY: ${HTTPS_PROXY}
        NO_PROXY: ${NO_PROXY}
      cache_from:
        - 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
    image: app:latest
    ports:
      - "8080:8080"
    environment:
      - HTTP_PROXY=${HTTP_PROXY}
      - HTTPS_PROXY=${HTTPS_PROXY}
      - NO_PROXY=${NO_PROXY}

  # 可选：本地 apt 缓存代理
  apt-cacher:
    image: sameersbn/apt-cacher-ng:latest
    ports:
      - "3142:3142"
    volumes:
      - apt_cache_data:/var/cache/apt-cacher-ng
    restart: unless-stopped

volumes:
  apt_cache_data:
EOF

    # 5. 创建 Kubernetes 构建模板
    cat > "$TEMPLATES_DIR/k8s-build-with-proxy.yaml" << 'EOF'
apiVersion: v1
kind: ConfigMap
metadata:
  name: build-config
data:
  HTTP_PROXY: "http://proxy-service:7890"
  HTTPS_PROXY: "http://proxy-service:7890"
  NO_PROXY: "localhost,127.0.0.1,10.*,172.16.*,192.168.*,.svc,.cluster.local"
---
apiVersion: v1
kind: Pod
metadata:
  name: kaniko-build
spec:
  containers:
  - name: kaniko
    image: gcr.io/kaniko-project/executor:latest
    args:
    - "--dockerfile=Dockerfile"
    - "--context=gs://my-bucket"
    - "--destination=192.168.1.83:8443/myapp:latest"
    - "--cache=true"
    - "--cache-repo=192.168.1.83:8443/kaniko-cache"
    - "--insecure"
    envFrom:
    - configMapRef:
        name: build-config
  restartPolicy: Never
EOF

    # 6. 创建配置文件
    cat > "$TEMPLATES_DIR/.env.example" << EOF
# 代理配置示例
# 取消注释并设置你的代理地址

# HTTP 代理
HTTP_PROXY=http://127.0.0.1:7890
HTTPS_PROXY=http://127.0.0.1:7890

# SOCKS 代理
# HTTP_PROXY=socks5://127.0.0.1:7890
# HTTPS_PROXY=socks5://127.0.0.1:7890

# 无代理地址
NO_PROXY=localhost,127.0.0.1,192.168.1.83,192.168.*,10.*,172.16.*,.local,.internal

# Harbor 配置
HARBOR_REGISTRY=192.168.1.83:8443
HARBOR_USER=admin
HARBOR_PASS=admin123
EOF

    success "构建模板创建完成"
    info "模板位置: $TEMPLATES_DIR/"
    echo ""
    echo "📚 可用模板:"
    echo "  📄 Dockerfile.proxy        - 基础代理 Dockerfile"
    echo "  📄 Dockerfile.multi-stage - 多阶段构建模板"
    echo "  🚀 build-with-proxy.sh    - 代理构建脚本"
    echo "  🐳 docker-compose.proxy.yml - Docker Compose 模板"
    echo "  ☸️  k8s-build-with-proxy.yaml - Kubernetes 构建模板"
    echo "  ⚙️  .env.example           - 环境变量示例"
}

# 测试代理配置
test_proxy_config() {
    header "测试代理配置..."

    if [ -z "$HTTP_PROXY" ] && [ -z "$HTTPS_PROXY" ]; then
        warning "未配置代理，无法测试"
        return
    fi

    # 测试网络连接
    info "测试网络连接..."

    # 测试 apt 源连接
    if curl -s --connect-timeout 10 --proxy "$HTTP_PROXY" http://deb.debian.org > /dev/null; then
        success "✅ 通过代理访问 Debian 源成功"
    else
        error "❌ 通过代理访问 Debian 源失败"
    fi

    # 测试 Docker Hub 连接
    if curl -s --connect-timeout 10 --proxy "$HTTP_PROXY" https://registry-1.docker.io > /dev/null; then
        success "✅ 通过代理访问 Docker Hub 成功"
    else
        error "❌ 通过代理访问 Docker Hub 失败"
    fi

    # 测试构建
    info "测试 Docker 构建..."
    cat > /tmp/test-proxy.Dockerfile << 'EOF'
FROM alpine:3.18
RUN echo "Proxy test successful"
EOF

    if docker build \
        --build-arg HTTP_PROXY="$HTTP_PROXY" \
        --build-arg HTTPS_PROXY="$HTTPS_PROXY" \
        -t proxy-test /tmp/test-proxy.Dockerfile > /dev/null 2>&1; then
        success "✅ Docker 代理构建测试成功"
        docker rmi proxy-test > /dev/null 2>&1
    else
        error "❌ Docker 代理构建测试失败"
    fi

    rm -f /tmp/test-proxy.Dockerfile

    success "代理配置测试完成"
}

# 显示配置状态
show_status() {
    header "当前配置状态"

    echo "🔧 系统信息:"
    echo "   操作系统: $(uname -s)"
    echo "   架构: $(uname -m)"
    echo ""

    echo "🐳 Docker 信息:"
    if command -v docker > /dev/null; then
        echo "   Docker 版本: $(docker --version)"
        echo "   BuildKit: $(docker buildx version 2>/dev/null | head -1 || echo '不可用')"
    else
        echo "   Docker: 未安装"
    fi
    echo ""

    echo "🌐 代理配置:"
    if [ -n "$HTTP_PROXY" ]; then
        echo "   HTTP_PROXY: $HTTP_PROXY"
    else
        echo "   HTTP_PROXY: 未设置"
    fi

    if [ -n "$HTTPS_PROXY" ]; then
        echo "   HTTPS_PROXY: $HTTPS_PROXY"
    else
        echo "   HTTPS_PROXY: 未设置"
    fi
    echo ""

    echo "🏗️ Harbor 配置:"
    echo "   地址: $HARBOR_REGISTRY"
    echo "   用户: $HARBOR_USER"
    echo ""

    # 检查 Docker 配置文件
    if [ -f "$HOME/.docker/config.json" ]; then
        echo "📋 Docker 配置文件存在"
        if grep -q "proxies" "$HOME/.docker/config.json"; then
            echo "   ✅ 代理配置已添加"
        else
            echo "   ❌ 代理配置未添加"
        fi
    else
        echo "   ❌ Docker 配置文件不存在"
    fi
}

# 备份文件
backup() {
    local file="$1"
    local backup_file="${file}.backup.$(date +%Y%m%d_%H%M%S)"
    cp "$file" "$backup_file"
    info "已备份: $file -> $backup_file"
}

# 主函数
main() {
    # 解析命令行参数
    while [[ $# -gt 0 ]]; do
        case $1 in
            -h|--help)
                show_help
                exit 0
                ;;
            -p|--proxy)
                HTTP_PROXY="$2"
                HTTPS_PROXY="$2"
                shift 2
                ;;
            -s|--socks)
                HTTP_PROXY="$2"
                HTTPS_PROXY="$2"
                shift 2
                ;;
            --detect)
                detect_proxy
                exit 0
                ;;
            --setup)
                SETUP_MODE=true
                shift
                ;;
            --test)
                test_proxy_config
                exit 0
                ;;
            --create-templates)
                CREATE_TEMPLATES=true
                shift
                ;;
            --status)
                show_status
                exit 0
                ;;
            *)
                error "未知参数: $1"
                show_help
                exit 1
                ;;
        esac
    done

    # 显示欢迎信息
    header "Docker 构建代理配置工具"
    echo ""

    # 如果是设置模式
    if [ "$SETUP_MODE" = true ]; then
        step "1/5 检测系统代理..."
        detect_proxy
        echo ""

        step "2/5 配置 Docker daemon 代理..."
        configure_docker_daemon_proxy
        echo ""

        if [ "$CREATE_TEMPLATES" = true ]; then
            step "3/5 创建构建模板..."
            create_build_templates
            echo ""

            step "4/5 测试代理配置..."
            test_proxy_config
            echo ""

            step "5/5 生成使用指南..."
            generate_usage_guide
        else
            step "3/4 测试代理配置..."
            test_proxy_config
            echo ""

            step "4/4 生成使用指南..."
            generate_usage_guide
        fi
    else
        # 默认显示状态和帮助
        show_status
        echo ""
        show_help
    fi
}

# 生成使用指南
generate_usage_guide() {
    echo ""
    header "📚 使用指南"
    echo ""

    echo "🚀 快速开始:"
    echo "   1. 设置代理环境变量:"
    echo "      export HTTP_PROXY=http://127.0.0.1:7890"
    echo "      export HTTPS_PROXY=http://127.0.0.1:7890"
    echo ""
    echo "   2. 构建镜像:"
    echo "      docker build --build-arg HTTP_PROXY=\$HTTP_PROXY -t myapp ."
    echo ""
    echo "   3. 使用构建脚本:"
    echo "      cd docker-build-templates"
    echo "      ./build-with-proxy.sh myapp latest"
    echo ""

    echo "🔧 配置方法:"
    echo "   • 自动检测: $0 --detect"
    echo "   • 设置代理: $0 --proxy http://127.0.0.1:7890"
    echo "   • 完整配置: $0 --setup --create-templates"
    echo "   • 测试配置: $0 --test"
    echo "   • 查看状态: $0 --status"
    echo ""

    echo "📝 模板使用:"
    echo "   1. 复制模板到你的项目:"
    echo "      cp docker-build-templates/Dockerfile.proxy ./Dockerfile"
    echo ""
    echo "   2. 配置环境变量:"
    echo "      cp docker-build-templates/.env.example ./.env"
    echo "      # 编辑 .env 文件设置代理地址"
    echo ""
    echo "   3. 构建镜像:"
    echo "      docker build -t myapp ."
    echo ""

    echo "💡 最佳实践:"
    echo "   • 开发环境: 使用本地代理 (Clash/Shadowsocks)"
    echo "   • CI/CD 环境: 使用内网代理或 apt-cacher-ng"
    echo "   • 生产环境: 预构建镜像推送到 Harbor"
    echo "   • 多架构构建: 使用 buildx + Harbor 缓存"
    echo ""

    success "配置完成！现在你可以享受高速的 Docker 构建体验了！ 🎉"
}

# 执行主函数
main "$@"