Shell脚本如何配置容器自动化策

本文目录导读：

1. 基础环境检测与初始化
2. 容器生命周期管理
3. 自动扩缩容策略
4. 日志与监控策略
5. 备份与恢复策略
6. 自动化部署策略
7. 配置文件管理
8. 主执行脚本
9. 使用示例

我来详细说明Shell脚本配置容器自动化的几个关键策略。

基础环境检测与初始化

#!/bin/bash
# 容器环境检测
check_env() {
    # 检查是否在容器中运行
    if [ -f /.dockerenv ]; then
        echo "Running inside Docker container"
    fi
    # 检查必要工具
    for cmd in docker docker-compose kubectl; do
        if ! command -v $cmd &>/dev/null; then
            echo "$cmd not found"
            exit 1
        fi
    done
}

容器生命周期管理

#!/bin/bash
# 容器启动策略
start_container() {
    local container_name=$1
    local image_name=$2
    # 检查容器是否存在并运行
    if docker ps --format '{{.Names}}' | grep -q "^${container_name}$"; then
        echo "Container ${container_name} already running"
        return 0
    fi
    # 清理旧容器
    docker rm -f "${container_name}" 2>/dev/null
    # 启动新容器
    docker run -d \
        --name "${container_name}" \
        --restart unless-stopped \
        "${image_name}"
}
# 健康检查策略
health_check() {
    local container_name=$1
    local max_retries=5
    local retry_interval=2
    for i in $(seq 1 $max_retries); do
        if docker exec "${container_name}" curl -s -o /dev/null -w "%{http_code}" http://localhost:8080/health | grep -q "200"; then
            echo "Container ${container_name} is healthy"
            return 0
        fi
        echo "Retry ${i}/${max_retries}..."
        sleep $retry_interval
    done
    echo "Container ${container_name} health check failed"
    return 1
}

自动扩缩容策略

#!/bin/bash
# 基于资源使用率的自动扩缩容
autoscale_container() {
    local service_name=$1
    local min_instances=$2
    local max_instances=$3
    local cpu_threshold=80
    while true; do
        # 获取当前CPU使用率
        local cpu_usage=$(docker stats --no-stream --format "{{.CPUPerc}}" "${service_name}" | sed 's/%//')
        # 获取当前实例数
        local current_instances=$(docker ps --filter "name=${service_name}" --format "{{.Names}}" | wc -l)
        if (( $(echo "$cpu_usage > $cpu_threshold" | bc -l) )) && [ "$current_instances" -lt "$max_instances" ]; then
            echo "Scaling up ${service_name}..."
            docker-compose up -d --scale "${service_name}=$((current_instances + 1))"
        elif (( $(echo "$cpu_usage < 30" | bc -l) )) && [ "$current_instances" -gt "$min_instances" ]; then
            echo "Scaling down ${service_name}..."
            docker-compose up -d --scale "${service_name}=$((current_instances - 1))"
        fi
        sleep 30  # 每30秒检查一次
    done
}

日志与监控策略

#!/bin/bash
# 容器日志管理
manage_logs() {
    local container_name=$1
    local log_dir="/var/log/containers/${container_name}"
    local max_log_size=100  # MB
    local retention_days=7
    # 创建日志目录
    mkdir -p "${log_dir}"
    # 日志轮转
    docker logs -f "${container_name}" | while read line; do
        echo "${line}" >> "${log_dir}/current.log"
        # 检查日志大小
        local log_size=$(du -m "${log_dir}/current.log" | cut -f1)
        if [ "$log_size" -gt "$max_log_size" ]; then
            # 进行日志轮转
            mv "${log_dir}/current.log" "${log_dir}/$(date +%Y%m%d_%H%M%S).log"
            gzip "${log_dir}/$(date +%Y%m%d_%H%M%S).log"
        fi
        # 清理旧日志
        find "${log_dir}" -name "*.gz" -mtime +${retention_days} -delete
    done
}
# 资源监控
monitor_resources() {
    while true; do
        echo "=== Container Resources ==="
        docker stats --no-stream --format "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}\t{{.NetIO}}\t{{.BlockIO}}"
        # 告警检查
        docker stats --no-stream --format "{{.Name}} {{.MemPerc}}" | while read name mem; do
            local mem_usage=$(echo $mem | sed 's/%//')
            if (( $(echo "$mem_usage > 90" | bc -l) )); then
                echo "WARNING: ${name} memory usage high: ${mem_usage}%"
                # 发送告警（这里可以集成通知系统）
            fi
        done
        sleep 10
    done
}

备份与恢复策略

#!/bin/bash
# 容器数据备份
backup_containers() {
    local backup_dir="/backup/containers"
    local timestamp=$(date +%Y%m%d_%H%M%S)
    mkdir -p "${backup_dir}/${timestamp}"
    # 备份所有容器卷
    for container in $(docker ps -q); do
        local container_name=$(docker inspect --format '{{.Name}}' "${container}" | sed 's/\///')
        # 创建容器备份
        docker commit "${container}" "${container_name}_backup:${timestamp}"
        docker save -o "${backup_dir}/${timestamp}/${container_name}.tar" "${container_name}_backup:${timestamp}"
        # 备份挂载卷
        docker run --rm \
            --volumes-from "${container}" \
            -v "${backup_dir}/${timestamp}:/backup" \
            alpine tar czf "/backup/${container_name}_volume_${timestamp}.tar.gz" /data
    done
    # 清理旧备份（保留7天）
    find "${backup_dir}" -type d -mtime +7 -exec rm -rf {} \;
}
# 恢复容器
restore_container() {
    local backup_file=$1
    local container_name=$2
    # 加载备份镜像
    docker load -i "${backup_file}"
    # 重新创建容器
    docker run -d \
        --name "${container_name}" \
        --restart unless-stopped \
        "${container_name}_backup:latest"
}

自动化部署策略

#!/bin/bash
# 滚动更新策略
rolling_update() {
    local service_name=$1
    local new_version=$2
    # 逐步更新实例
    for container in $(docker ps --filter "name=${service_name}" --format "{{.Names}}"); do
        echo "Updating ${container}..."
        # 停止旧容器
        docker stop "${container}"
        # 启动新版本容器
        docker run -d \
            --name "${container}_new" \
            "${service_name}:${new_version}"
        # 健康检查
        sleep 5
        if docker exec "${container}_new" curl -s http://localhost:8080/health > /dev/null; then
            # 移除旧容器
            docker rm "${container}"
            docker rename "${container}_new" "${container}"
            echo "Successfully updated ${container}"
        else
            # 回滚
            docker rm "${container}_new"
            docker start "${container}"
            echo "Failed to update ${container}, rolling back"
        fi
    done
}
# 蓝绿部署策略
blue_green_deploy() {
    local app_name=$1
    local version=$2
    # 部署新版本到green环境
    echo "Deploying ${version} to green environment..."
    docker-compose -p "${app_name}_green" up -d --scale "${app_name}=1"
    # 检查健康状态
    local green_status=$(curl -s -o /dev/null -w "%{http_code}" http://green.${app_name}.local/health)
    if [ "$green_status" != "200" ]; then
        echo "Green deployment failed, rolling back..."
        docker-compose -p "${app_name}_green" down
        return 1
    fi
    # 切换流量到green环境
    echo "Switching traffic to green environment..."
    # 这里可以更新负载均衡器配置
    # 停止旧版本（blue环境）
    sleep 10
    docker-compose -p "${app_name}_blue" down
    echo "Blue-green deployment completed successfully"
}

配置文件管理

# docker-compose.automation.yaml
version: '3.8'
services:
  autoscaler:
    build: .
    environment:
      - AUTOSCALE_ENABLED=true
      - CPU_THRESHOLD=80
      - MIN_INSTANCES=2
      - MAX_INSTANCES=10
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 256M

主执行脚本

#!/bin/bash
# 主自动化脚本
main() {
    case "$1" in
        deploy)
            rolling_update "$2" "$3"
            ;;
        scale)
            autoscale_container "$2" "$3" "$4" &
            ;;
        backup)
            backup_containers
            ;;
        restore)
            restore_container "$2" "$3"
            ;;
        monitor)
            monitor_resources
            ;;
        health)
            health_check "$2"
            ;;
        *)
            echo "Usage: $0 {deploy|scale|backup|restore|monitor|health} [args]"
            exit 1
            ;;
    esac
}
# 执行主函数
main "$@"

使用示例

# 健康检查
./container_automation.sh health myapp
# 自动扩缩容（监控后台运行）
./container_automation.sh scale myapp 2 10 &
# 滚动更新
./container_automation.sh deploy myapp v2.0
# 备份所有容器
./container_automation.sh backup
# 监控资源
./container_automation.sh monitor

这些策略可以根据实际需求组合使用,实现完整的容器自动化管理方案，记得根据具体环境调整参数和告警阈值。