Shell脚本如何实现批量发布策略

本文目录导读：

1. 基础批量发布脚本
2. 滚动更新策略
3. 蓝绿部署策略
4. 灰度发布策略
5. 完整的部署工具类
6. 使用示例
7. 最佳实践

我来介绍几种Shell脚本实现批量发布策略的方法：

基础批量发布脚本

#!/bin/bash
# 批量部署脚本
set -e
# 配置
SERVERS=(
    "10.0.1.101"
    "10.0.1.102"
    "10.0.1.103"
)
DEPLOY_USER="deploy"
DEPLOY_PATH="/var/www/app"
PACKAGE="app-v1.0.0.tar.gz"
# 颜色输出
RED='\033[0;31m'
GREEN='\033[0;32m'
NC='\033[0m'
# 日志函数
log_info() {
    echo -e "${GREEN}[INFO]${NC} $1"
}
log_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}
# 批量部署函数
deploy_to_server() {
    local server=$1
    log_info "开始部署到 $server"
    # 上传包
    scp "$PACKAGE" "$DEPLOY_USER@$server:/tmp/"
    # 远程执行部署
    ssh "$DEPLOY_USER@$server" "
        cd $DEPLOY_PATH
        tar -xzf /tmp/$PACKAGE
        ln -snf /tmp/$PACKAGE current
        # 重启服务
        systemctl restart app.service
    "
    if [ $? -eq 0 ]; then
        log_info "部署 $server 成功"
    else
        log_error "部署 $server 失败"
    fi
}
# 主流程
main() {
    log_info "开始批量部署"
    for server in "${SERVERS[@]}"; do
        deploy_to_server "$server"
    done
    log_info "批量部署完成"
}
main

滚动更新策略

#!/bin/bash
# 滚动更新策略
ROLLING_UPDATE() {
    local servers=("$@")
    local batch_size=${BATCH_SIZE:-2}  # 每批次数量
    local wait_time=${WAIT_TIME:-30}    # 等待时间
    echo "开始滚动更新，每批次 $batch_size 台，间隔 $wait_time 秒"
    # 分批处理
    for ((i=0; i<${#servers[@]}; i+=batch_size)); do
        echo "处理第 $((i/batch_size + 1)) 批次"
        # 获取当前批次
        batch=("${servers[@]:i:batch_size}")
        # 并行部署当前批次
        for server in "${batch[@]}"; do
            deploy_single "$server" &
        done
        # 等待当前批次完成
        wait
        # 健康检查
        for server in "${batch[@]}"; do
            health_check "$server"
        done
        # 批次间隔
        if [ $((i + batch_size)) -lt ${#servers[@]} ]; then
            echo "等待 $wait_time 秒后继续..."
            sleep $wait_time
        fi
    done
    echo "滚动更新完成"
}

蓝绿部署策略

#!/bin/bash
# 蓝绿部署
BLUE_GREEN_DEPLOY() {
    local env_file="/etc/app/deploy_env"
    local current_env=""
    # 读取当前环境
    if [ -f "$env_file" ]; then
        current_env=$(cat "$env_file")
    fi
    # 确定目标环境
    if [ "$current_env" == "blue" ]; then
        target_env="green"
    else
        target_env="blue"
    fi
    echo "当前环境: $current_env"
    echo "目标环境: $target_env"
    # 部署到目标环境
    deploy_to_environment "$target_env"
    # 切换流量
    switch_traffic "$target_env"
    # 更新环境标志
    echo "$target_env" > "$env_file"
    echo "蓝绿部署完成，当前环境: $target_env"
}
# 部署到指定环境
deploy_to_environment() {
    local env=$1
    local servers=($(get_env_servers "$env"))
    for server in "${servers[@]}"; do
        deploy_single "$server" &
    done
    wait
}

灰度发布策略

#!/bin/bash
# 灰度发布
GRAY_RELEASE() {
    local total_servers=($(get_all_servers))
    local gray_percent=${1:-20}  # 灰度比例
    local gray_count=$(( ${#total_servers[@]} * gray_percent / 100 ))
    echo "灰度发布: $gray_percent% ($gray_count 台)"
    # 获取灰度服务器
    local gray_servers=("${total_servers[@]:0:gray_count}")
    local normal_servers=("${total_servers[@]:gray_count}")
    # 灰度服务器部署
    echo "灰度服务器: ${gray_servers[*]}"
    for server in "${gray_servers[@]}"; do
        deploy_single "$server"
    done
    # 等待验证
    echo "等待验证灰度版本..."
    sleep 120  # 等待2分钟
    # 验证灰度结果
    if verify_gray_release; then
        echo "灰度验证通过，开始全量发布"
        for server in "${normal_servers[@]}"; do
            deploy_single "$server"
        done
    else
        echo "灰度验证失败，回滚灰度服务器"
        rollback_servers "${gray_servers[@]}"
    fi
}

完整的部署工具类

#!/bin/bash
# 批量部署配置
BATCH_CONFIG() {
    cat << EOF
# 发布管理工具配置
---
deploy:
  strategy: "rolling"  # rolling, blue_green, gray
  batch_size: 2
  wait_time: 30
  health_check:
    url: "http://localhost/health"
    timeout: 10
  rollback:
    enabled: true
    max_revisions: 5
EOF
}
# 健康检查
health_check() {
    local server=$1
    local retries=3
    for ((i=1; i<=retries; i++)); do
        if curl -f "${server}/health" >/dev/null 2>&1; then
            echo "健康检查通过: $server"
            return 0
        fi
        sleep 2
    done
    echo "健康检查失败: $server"
    return 1
}
# 回滚
rollback_server() {
    local server=$1
    local version=$2
    ssh "deploy@$server" "
        cd /var/www/app
        if [ -d \"releases/$version\" ]; then
            ln -snf \"releases/$version\" current
            systemctl restart app.service
            echo \"回滚到版本 $version 完成\"
        else
            echo \"版本 $version 不存在\"
            exit 1
        fi
    "
}
# 并行执行限制
PARRALLEL_EXEC() {
    local max_jobs=${1:-4}
    local servers=("${@:2}")
    limit_jobs() {
        while [ $(jobs -r | wc -l) -ge $max_jobs ]; do
            sleep 1
        done
    }
    for server in "${servers[@]}"; do
        limit_jobs
        deploy_to_server "$server" &
    done
    wait
}
# 主函数
main() {
    local strategy=${1:-"rolling"}
    case $strategy in
        "rolling")
            ROLLING_UPDATE "${SERVERS[@]}"
            ;;
        "blue_green")
            BLUE_GREEN_DEPLOY
            ;;
        "gray")
            GRAY_RELEASE 20
            ;;
        *)
            echo "未知策略: $strategy"
            exit 1
            ;;
    esac
}
# 执行
main "$@"

使用示例

# 基础批量部署
./deploy.sh
# 滚动更新（每批次3台）
BATCH_SIZE=3 ./deploy.sh
# 灰度发布（10%）
./deploy.sh gray 10

最佳实践

1. 错误处理：始终检查命令执行结果
2. 日志记录：详细记录每个步骤
3. 回滚机制：确保能快速回滚
4. 并行控制：合理控制并发数量
5. 健康检查：部署后必须验证

这些脚本可以根据实际需求进行定制,建议先在小范围测试。