速来领取！压箱底的49个Docker自动化脚本

小周的数据库进阶之路 2025-09-15

245

正文开始

相逢即是缘，关注⭐星标不错过～，每天分享实操教程和技巧。

一、容器生命周期管理：从创建到自愈的全流程自动化

1. 自动化容器创建脚本（可复用配置）

适用场景：快速创建标准化容器（如Nginx、Redis），无需重复编写docker run
命令。

#!/bin/bash
# 配置参数（根据需求修改）
IMAGE_NAME="nginx"       # 镜像名称（如redis、mysql:8.0）
CONTAINER_NAME="my_nginx"# 容器名称（需唯一）
PORT_MAPPING="8080:80"   # 端口映射（主机:容器）
ENV_VARS="ENV=production"# 环境变量（多变量用空格分隔）
VOLUME_MAPPING="/host/data:/container/data"# 数据卷映射（可选）

# 清理同名旧容器
if docker ps -a | grep -q "$CONTAINER_NAME"; then
  docker stop "$CONTAINER_NAME" && docker rm"$CONTAINER_NAME"
echo"已删除同名旧容器：$CONTAINER_NAME"
fi

# 启动新容器（分离模式）
docker run -d \
  --name "$CONTAINER_NAME" \
  -p "$PORT_MAPPING" \
  -e "$ENV_VARS" \
  -v "$VOLUME_MAPPING" \
"$IMAGE_NAME"

echo "容器创建成功：$CONTAINER_NAME（镜像：$IMAGE_NAME）"

2. 批量启动所有容器（系统重启后恢复）

适用场景：服务器重启或维护后，一键启动所有已创建容器（含停止状态）。

#!/bin/bash
echo "开始批量启动所有容器..."
STARTED_CONTAINERS=$(docker start $(docker ps -aq))

if [ -n "$STARTED_CONTAINERS" ]; then
  echo "成功启动容器ID：$STARTED_CONTAINERS"
else
  echo "无可用容器可启动（或所有容器已运行）"
fi

3. 批量停止运行中容器（快速关闭服务）

适用场景：版本更新或维护前，一键停止所有运行中容器。

#!/bin/bash
echo "开始批量停止运行中容器..."
STOPPED_CONTAINERS=$(docker stop $(docker ps -q))

if [ -n "$STOPPED_CONTAINERS" ]; then
  echo "成功停止容器ID：$STOPPED_CONTAINERS"
else
  echo "无运行中容器可停止"
fi

4. 批量删除停止的容器（释放闲置资源）

适用场景：清理已停止的无用容器，避免占用磁盘/进程资源。

#!/bin/bash
echo "开始删除所有已停止的容器..."
DELETED_CONTAINERS=$(docker rm $(docker ps -aq -f "status=exited"))

if [ -n "$DELETED_CONTAINERS" ]; then
  echo "成功删除容器ID：$DELETED_CONTAINERS"
else
  echo "无停止状态的容器可删除"
fi

5. 运行临时容器（退出后自动清理）

适用场景：执行一次性任务（如数据校验、临时脚本），避免残留容器。

#!/bin/bash
# 参数：镜像名称（如alpine、ubuntu）
IMAGE_NAME=$1

if [ -z "$IMAGE_NAME" ]; then
  echo "用法：$0 <镜像名称>"
  exit 1
fi

echo "启动临时容器（退出后自动删除）：$IMAGE_NAME"
docker run --rm -it "$IMAGE_NAME" # --rm：停止后自动删除；-it：交互模式

6. 配置关键容器自动重启（服务高可用）

适用场景：核心容器（如数据库、API）意外停止后自动恢复。

#!/bin/bash
# 参数：容器名称/ID
CONTAINER_NAME=$1

if [ -z "$CONTAINER_NAME" ]; then
  echo "用法：$0 <容器名称/ID>"
  exit 1
fi

# --restart always：始终自动重启；可选on-failure:3（失败最多重启3次）
docker update --restart always "$CONTAINER_NAME"
echo "容器 $CONTAINER_NAME 已配置为'始终自动重启'"

7. 单个容器资源与日志监控（故障排查）

适用场景：实时查看指定容器的CPU/内存及最新日志，快速定位故障。

#!/bin/bash
# 配置参数
CONTAINER_NAME="my_app"# 目标容器
LOG_TAIL=50             # 最新日志行数

echo"=================== 容器 $CONTAINER_NAME 监控 ==================="
echo"1. 资源使用情况："
docker stats --no-stream "$CONTAINER_NAME"# --no-stream：非实时流

echo -e "\n2. 最新 $LOG_TAIL 行日志："
docker logs --tail"$LOG_TAIL" "$CONTAINER_NAME"

8. 所有容器资源监控（全局资源视图）

适用场景：查看所有容器的资源占用，识别资源瓶颈。

#!/bin/bash
echo "所有容器资源实时监控（按Ctrl+C退出）："
docker stats --all # --all：包含停止容器（仅基础信息）

9. 批量查看所有运行中容器日志（统一排查）

适用场景：多容器协同故障时，批量查看日志定位问题。

#!/bin/bash
echo "=================== 所有运行中容器日志 ==================="
# 遍历运行中容器，输出最新20行日志
docker ps -q | xargs -I {} sh -c 'echo -e "\n=== 容器 ID: {} ==="; docker logs --tail 20 {}'

10. 清理Docker未使用资源（释放磁盘）

适用场景：定期清理未使用的镜像、容器、卷、网络。

#!/bin/bash
echo "开始清理Docker未使用资源..."
docker system prune -f --volumes # -f：跳过确认；--volumes：清理未使用卷

echo -e "\n清理完成，当前资源占用："
docker system df # 查看资源使用情况

11. 删除悬空镜像（无标签镜像清理）

适用场景：清理“dangling”状态的无标签镜像（构建残留）。

#!/bin/bash
echo "开始删除悬空镜像..."
DANGLING_IMAGES=$(docker images -q -f "dangling=true")

if [ -n "$DANGLING_IMAGES" ]; then
  docker rmi "$DANGLING_IMAGES"
  echo "成功删除悬空镜像ID：$DANGLING_IMAGES"
else
  echo "无悬空镜像可删除"
fi

12. 容器内数据定时备份（数据持久化）

适用场景：备份容器内指定目录，结合Cron实现每日自动备份。

#!/bin/bash
# 配置参数
CONTAINER_NAME="my_app"   # 目标容器
CONTAINER_DATA_DIR="/data"# 容器内备份目录
BACKUP_HOST_DIR="/backup"# 主机备份目录
TIMESTAMP=$(date +%F)     # 时间戳（2024-05-20）

mkdir -p "$BACKUP_HOST_DIR"
BACKUP_FILE="$BACKUP_HOST_DIR/${CONTAINER_NAME}-backup-${TIMESTAMP}"

# 复制容器数据到主机
docker cp"$CONTAINER_NAME:$CONTAINER_DATA_DIR""$BACKUP_FILE"
echo"容器数据备份完成：$BACKUP_FILE"

# 定时执行：Cron添加 0 2 * * * path/to/this/script.sh

13. 容器文件系统完整备份（全量导出）

适用场景：备份整个容器文件系统，用于迁移或完整恢复。

#!/bin/bash
# 参数1：容器ID；参数2：备份文件路径（如/backup/my_container.tar）
CONTAINER_ID=$1
BACKUP_FILE=$2

if [ -z "$CONTAINER_ID" ] || [ -z "$BACKUP_FILE" ]; then
echo"用法：$0 <容器ID> <备份文件路径>"
exit 1
fi

echo"备份容器 $CONTAINER_ID 到 $BACKUP_FILE..."
docker export"$CONTAINER_ID" > "$BACKUP_FILE"# 导出文件系统为tar

if [ $? -eq 0 ]; then
echo"备份成功（大小：$(du -sh "$BACKUP_FILE" | awk '{print $1}')）"
else
echo"备份失败"
exit 1
fi

14. 从完整备份恢复容器（全量导入）

适用场景：基于docker export
的备份文件创建新镜像并启动容器。

#!/bin/bash
# 参数1：备份文件路径；参数2：新镜像名称（如restored-app:v1）
BACKUP_FILE=$1
NEW_IMAGE_NAME=$2

if [ -z "$BACKUP_FILE" ] || [ -z "$NEW_IMAGE_NAME" ]; then
echo"用法：$0 <备份文件路径> <新镜像名称>"
exit 1
fi

# 从tar包创建镜像
docker import "$BACKUP_FILE""$NEW_IMAGE_NAME"
echo"镜像创建成功：$NEW_IMAGE_NAME"

# 可选：启动恢复的容器
read -p "是否启动容器？(y/n) " -n 1 -r
if [[ $REPLY =~ ^[Yy]$ ]]; then
  docker run -d --name "restored-container""$NEW_IMAGE_NAME"
echo -e "\n容器已启动：restored-container"
fi

15. 数据卷备份到AWS S3（异地容灾）

适用场景：将数据卷备份到云端，实现异地容灾，清理旧备份。

#!/bin/bash
# 配置参数
BACKUP_HOST_DIR="/tmp/docker-backup"
S3_BUCKET="s3://your-bucket/docker-volumes"# 需配置AWS CLI
MAX_BACKUPS=5
TIMESTAMP=$(date +%Y%m%d%H%M%S)
BACKUP_TAR="$BACKUP_HOST_DIR/volumes-backup-$TIMESTAMP.tar.gz"

# 1. 创建临时目录
mkdir -p "$BACKUP_HOST_DIR"

# 2. 打包数据卷
docker run --rm -v /var/lib/docker/volumes:/volumes -v "$BACKUP_HOST_DIR:/backup" alpine \
  tar czf /backup/$(basename"$BACKUP_TAR") -C /volumes .

# 3. 上传到S3
aws s3 cp"$BACKUP_TAR""$S3_BUCKET/"
echo"备份已上传到S3：$S3_BUCKET/$(basename "$BACKUP_TAR")"

# 4. 清理本地旧备份
find "$BACKUP_HOST_DIR" -name "volumes-backup-*.tar.gz" | sort -r | tail -n +$((MAX_BACKUPS+1)) | xargs rm -f

16. 自定义Docker网络创建与容器接入（网络隔离）

适用场景：构建微服务隔离网络（如“数据库网络”“API网络”）。

#!/bin/bash
# 配置参数
NETWORK_NAME="custom-microservice-net"
NETWORK_DRIVER="bridge"
TARGET_CONTAINERS=("my-db""my-api")

# 1. 创建网络
if ! docker network ls | grep -q "$NETWORK_NAME"; then
  docker network create --driver "$NETWORK_DRIVER""$NETWORK_NAME"
echo"网络创建成功：$NETWORK_NAME"
else
echo"网络已存在：$NETWORK_NAME"
fi

# 2. 接入容器
for container in"${TARGET_CONTAINERS[@]}"; do
if docker ps -a | grep -q "$container"; then
    docker network connect "$NETWORK_NAME""$container"
    echo"容器 $container 已接入网络"
else
    echo"容器 $container 不存在，跳过"
fi
done

17. 列出所有容器暴露端口（端口管理）

适用场景：快速查看所有容器的端口映射，避免端口冲突。

#!/bin/bash
echo "=================== 容器端口映射列表 ==================="
# 自定义格式：容器ID | 名称 | 端口映射
docker ps --format "| {{.ID}} | {{.Names}} | {{.Ports}} |"
echo "======================================================"
echo "说明：0.0.0.0:8080->80/tcp 表示主机8080映射到容器80"

18. 运行中容器镜像更新（无缝升级）

适用场景：镜像发布新版本后，一键更新容器。

#!/bin/bash
# 参数：容器名称/ID
CONTAINER_NAME=$1

if [ -z "$CONTAINER_NAME" ]; then
echo"用法：$0 <容器名称/ID>"
exit 1
fi

# 1. 获取当前镜像
CURRENT_IMAGE=$(docker inspect --format='{{.Config.Image}}'"$CONTAINER_NAME")
echo"当前镜像：$CURRENT_IMAGE"

# 2. 拉取最新镜像
docker pull "$CURRENT_IMAGE"

# 3. 重启容器（保留原配置）
docker stop "$CONTAINER_NAME" && docker rm"$CONTAINER_NAME"
docker run -d --name "$CONTAINER_NAME""$CURRENT_IMAGE"# 复杂配置需补充参数
echo "容器 $CONTAINER_NAME 已更新"

19. 手动清理容器日志（日志瘦身）

适用场景：清理过大的容器日志文件（默认路径/var/lib/docker/containers/
）。

#!/bin/bash
# 配置参数
LOG_AGE=7 # 清理7天前的日志
LOG_DIR="/var/lib/docker/containers"

echo "1. 查看前10个最大日志文件："
find "$LOG_DIR" -name "*.log" -type f | xargs du -sh | sort -rh | head -10

echo -e "\n2. 清理 $LOG_AGE 天前的日志..."
find "$LOG_DIR" -name "*.log" -type f -mtime +$LOG_AGE -exec rm -f {} \;

echo "日志清理完成，当前日志目录占用：$(du -sh "$LOG_DIR" | awk '{print $1}')"

20. 配置Docker日志大小限制（防止日志膨胀）

适用场景：从根本上限制日志大小，避免日志占满磁盘。

#!/bin/bash
# 配置文件路径
DAEMON_CONFIG="/etc/docker/daemon.json"

# 1. 备份原有配置
if [ -f "$DAEMON_CONFIG" ]; then
cp"$DAEMON_CONFIG""${DAEMON_CONFIG}.bak"
echo"已备份原有配置到：${DAEMON_CONFIG}.bak"
fi

# 2. 写入日志限制配置
cat > "$DAEMON_CONFIG" <<EOF
{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "50m",  # 单个日志最大50MB
    "max-file": "3"     # 最多保留3个日志文件
  }
}
EOF

# 3. 重启Docker生效
systemctl restart docker
echo "日志限制配置已生效（单个50MB，保留3个）"

21. 智能容器启停控制脚本（参数化操作）

适用场景：通过参数统一控制容器“启动/停止/重启”，支持批量操作。

#!/bin/bash
# 参数：start/stop/restart
ACTION=$1

if [ -z "$ACTION" ] || [[ ! "$ACTION" =~ ^(start|stop|restart)$ ]]; then
echo"用法：$0 {start|stop|restart}"
exit 1
fi

case$ACTIONin
    start)
        echo"启动所有已停止的容器..."
        docker start $(docker ps -aq --filter "status=exited")
        ;;
    stop)
        echo"停止所有运行中的容器..."
        docker stop $(docker ps -q --filter "status=running")
        ;;
    restart)
        echo"重启所有运行中的容器..."
        docker restart $(docker ps -q --filter "status=running")
        ;;
esac

echo "$ACTION 操作完成"

22. 条件式容器清理脚本（按时间筛选）

适用场景：清理“超过指定天数未使用”的停止容器，避免误删临时容器。

#!/bin/bash
# 配置参数：清理超过7天的停止容器
RETENTION_DAYS=7
SEVEN_DAYS_AGO=$(date -d "$RETENTION_DAYS days ago" +%s)

echo"清理超过 $RETENTION_DAYS 天的停止容器..."
# 遍历停止容器，按时间筛选
docker ps -a --filter "status=exited" --format '{{.ID}} {{.CreatedAt}}' | whileread -r id create_time; do
  container_time=$(date -d "$create_time" +%s)
if [ "$container_time" -lt "$SEVEN_DAYS_AGO" ]; then
    docker rm"$id"
    echo"已删除容器 $id（创建于：$create_time）"
fi
done

echo "条件式清理完成"

23. 容器健康状态异常自动重启（故障自愈）

适用场景：核心容器配置健康检查后，状态异常时自动重启。

#!/bin/bash
# 参数：容器名称/ID（需配置HEALTHCHECK）
CONTAINER_NAME=$1
CHECK_INTERVAL=30 # 检查间隔（秒）

if [ -z "$CONTAINER_NAME" ]; then
echo"用法：$0 <容器名称/ID>"
exit 1
fi

echo"监控容器 $CONTAINER_NAME 健康状态（每 $CHECK_INTERVAL 秒检查）..."
whiletrue; do
  HEALTH_STATUS=$(docker inspect --format='{{.State.Health.Status}}'"$CONTAINER_NAME" 2>/dev/null)

if [ "$HEALTH_STATUS" != "healthy" ] || [ -z "$HEALTH_STATUS" ]; then
    echo"$(date +"%Y-%m-%d %H:%M:%S") - 容器异常（$HEALTH_STATUS），重启..."
    docker restart "$CONTAINER_NAME"
    sleep 30 # 避免频繁重启
fi

sleep"$CHECK_INTERVAL"
done

24. 容器配置变更自动更新（配置生效）

适用场景：配置文件修改后，自动检测并重启容器，确保配置生效。

#!/bin/bash
# 配置参数
CONTAINER_NAME="my_app"
CONFIG_FILE="/host/path/app.conf"# 主机配置文件
IMAGE_NAME="my_app_image:v1"
CHECK_INTERVAL=60 # 检查间隔（秒）

# 初始MD5哈希
OLD_HASH=$(md5sum"$CONFIG_FILE" | awk '{print $1}')

echo"监控配置文件 $CONFIG_FILE（每 $CHECK_INTERVAL 秒检查）..."
whiletrue; do
  NEW_HASH=$(md5sum"$CONFIG_FILE" | awk '{print $1}')

if [ "$NEW_HASH" != "$OLD_HASH" ]; then
    echo"$(date +"%Y-%m-%d %H:%M:%S") - 配置变更，重启容器..."
    docker stop "$CONTAINER_NAME" && docker rm"$CONTAINER_NAME"
    docker run -d --name "$CONTAINER_NAME" -v "$CONFIG_FILE:/container/path/app.conf""$IMAGE_NAME"
    OLD_HASH="$NEW_HASH"
    echo"容器重启完成，配置生效"
fi

sleep"$CHECK_INTERVAL"
done

25. 容器依赖顺序启动脚本（微服务启动）

适用场景：微服务有启动顺序依赖（如“数据库→API→前端”），确保依赖就绪后启动。

#!/bin/bash
# 容器启动顺序（按依赖排序）
CONTAINER_ORDER=("mysql-db""redis-cache""backend-api""frontend-nginx")
MAX_WAIT=60 # 每个容器最大等待时间（秒）

for container in"${CONTAINER_ORDER[@]}"; do
echo"启动容器：$container"
  docker start "$container"

# 等待容器就绪
  wait_time=0
whiletrue; do
    HEALTH=$(docker inspect --format='{{.State.Health.Status}}'"$container" 2>/dev/null || echo"running")
    STATUS=$(docker inspect --format='{{.State.Status}}'"$container")
    
    if [ "$HEALTH" = "healthy" ] || [ "$STATUS" = "running" ]; then
      echo"容器 $container 已就绪（等待 $wait_time 秒）"
      break
    fi
    
    if [ "$wait_time" -ge "$MAX_WAIT" ]; then
      echo"容器 $container 启动超时，终止流程"
      exit 1
    fi
    
    wait_time=$((wait_time + 1))
    sleep 1
done
done

echo "所有容器按依赖顺序启动完成"

二、资源监控与预警：提前解决资源瓶颈

26. 智能镜像垃圾回收脚本（按时间清理）

适用场景：清理“超过30天未使用”的悬空镜像，避免误删近期镜像。

#!/bin/bash
# 配置参数：清理超过30天的悬空镜像
RETENTION_DAYS=30

echo"清理超过 $RETENTION_DAYS 天的悬空镜像..."
# 遍历悬空镜像，按时间筛选
docker images --filter "dangling=true" --format '{{.ID}} {{.CreatedSince}}' | whileread -r id create_time; do
if [[ "$create_time" == *"months"* ]] || [[ "$create_time" == *"weeks"* && $(echo"$create_time" | awk '{print $1}') -ge 4 ]]; then
    docker rmi "$id"
    echo"已删除镜像 $id（创建于：$create_time）"
fi
done

echo "镜像垃圾回收完成"

27. 磁盘空间预警清理脚本（自动触发）

适用场景：Docker目录使用率超过阈值（80%）时，自动清理资源。

#!/bin/bash
# 配置参数
THRESHOLD=80 # 使用率阈值（%）
DOCKER_DIR="/var/lib/docker"

# 获取使用率（提取数字）
USAGE=$(df --output=pcent "$DOCKER_DIR" | tail -n 1 | tr -dc '0-9')

echo"当前Docker目录使用率：$USAGE%"
if [ "$USAGE" -gt "$THRESHOLD" ]; then
echo"使用率超过阈值，执行清理..."
  docker system prune -af --volumes

# 清理后使用率
  NEW_USAGE=$(df --output=pcent "$DOCKER_DIR" | tail -n 1 | tr -dc '0-9')
echo"清理完成，当前使用率：$NEW_USAGE%"
else
echo"使用率未超过阈值，无需清理"
fi

28. 清理前自动备份重要容器（安全清理）

适用场景：执行清理前，自动备份重要容器的数据卷，避免误删数据。

#!/bin/bash
# 配置参数
BACKUP_DIR="/docker-backups/$(date +%Y%m%d)"
IMPORTANT_CONTAINERS=("mysql-db""redis-cache") # 重要容器
CLEAN_AFTER_BACKUP=true# 备份后是否清理

# 1. 创建备份目录
mkdir -p "$BACKUP_DIR"
echo"备份目录：$BACKUP_DIR"

# 2. 备份重要容器数据卷
for container in"${IMPORTANT_CONTAINERS[@]}"; do
echo"备份容器 $container 的数据卷..."
# 获取数据卷路径
  VOLUME_PATHS=$(docker inspect --format='{{range .Mounts}}{{.Destination}} {{end}}'"$container" | tr' ''\n' | grep -v '^$')

for vol_path in$VOLUME_PATHS; do
    BACKUP_FILE="$BACKUP_DIR/${container}_$(echo "$vol_path" | tr '/' '_').tar"
    docker exec"$container" tar cf - -C "$(dirname "$vol_path")""$(basename "$vol_path")" > "$BACKUP_FILE"
    echo"备份完成：$BACKUP_FILE（大小：$(du -sh "$BACKUP_FILE" | awk '{print $1}')）"
done
done

# 3. 可选：执行清理
if [ "$CLEAN_AFTER_BACKUP" = true ]; then
echo"执行资源清理..."
  docker system prune -af --volumes
echo"清理完成"
fi

29. 容器资源限制检查脚本（资源管控）

适用场景：检查容器是否设置CPU/内存限制，避免单个容器过载。

#!/bin/bash
echo"=================== 容器资源限制检查 ==================="
printf"%-20s %-15s %-15s\n""容器名称""CPU限制""内存限制"
echo"------------------------------------------------------"

# 遍历运行中容器
docker ps --format "{{.Names}} {{.ID}}" | whileread -r name id; do
# CPU限制（纳核→核）
  CPU_LIMIT=$(docker inspect --format='{{.HostConfig.NanoCpus}}'"$id")
if [ "$CPU_LIMIT" -eq 0 ]; then
    CPU_LIMIT="无限制"
else
    CPU_LIMIT="$((CPU_LIMIT / 1000000000.0)) 核"
fi

# 内存限制（字节→MB）
  MEM_LIMIT=$(docker inspect --format='{{.HostConfig.Memory}}'"$id")
if [ "$MEM_LIMIT" -eq 0 ]; then
    MEM_LIMIT="无限制"
else
    MEM_LIMIT="$((MEM_LIMIT / 1024 / 1024)) MB"
fi

# 预警无限制容器
if [ "$CPU_LIMIT" = "无限制" ] || [ "$MEM_LIMIT" = "无限制" ]; then
    printf"%-20s \033[31m%-15s\033[0m \033[31m%-15s\033[0m\n""$name""$CPU_LIMIT""$MEM_LIMIT"
else
    printf"%-20s %-15s %-15s\n""$name""$CPU_LIMIT""$MEM_LIMIT"
fi
done

echo "建议：为核心容器设置限制（如 docker update --memory=512m 容器名）"

30. 容器资源配额动态调整脚本（弹性分配）

适用场景：根据系统可用内存，动态调整容器内存配额（如分配50%可用内存）。

#!/bin/bash
# 参数：容器名称/ID
CONTAINER_NAME=$1
MEM_RATIO=0.5 # 内存分配比例

if [ -z "$CONTAINER_NAME" ]; then
echo"用法：$0 <容器名称/ID>"
exit 1
fi

# 1. 获取可用内存（MB）
AVAIL_MEM=$(free -m | awk '/Mem:/ {print $7}')
echo"系统可用内存：$AVAIL_MEM MB"

# 2. 计算内存限制（最低100MB）
MEM_LIMIT=$((AVAIL_MEM * MEM_RATIO))
MEM_LIMIT=$((MEM_LIMIT < 100 ? 100 : MEM_LIMIT))
MEM_LIMIT="${MEM_LIMIT}m"

# 3. 调整内存配额
docker update --memory="$MEM_LIMIT" --memory-swap="$MEM_LIMIT""$CONTAINER_NAME"
echo "容器 $CONTAINER_NAME 内存限制已调整为：$MEM_LIMIT（可用内存的 $((MEM_RATIO * 100))%）"

31. 容器综合监控仪表脚本（全局监控）

适用场景：生成简洁监控面板，展示所有容器的状态、健康度、资源使用率。

#!/bin/bash
echo"=================== 容器综合监控仪表板 ==================="
printf"%-20s %-10s %-10s %-10s %-10s\n""容器名称""状态""健康状态""CPU使用率""内存使用率"
echo"----------------------------------------------------------"

# 遍历所有容器
docker ps -a --format "{{.Names}} {{.ID}} {{.State.Status}}" | whileread -r name id status; do
  HEALTH=$(docker inspect --format='{{.State.Health.Status}}'"$id" 2>/dev/null || echo"N/A")

# 资源使用率（停止容器为0%）
if [ "$status" = "running" ]; then
    CPU=$(docker stats --no-stream --format "{{.CPUPerc}}""$id")
    MEM=$(docker stats --no-stream --format "{{.MemPerc}}""$id")
else
    CPU="0%"
    MEM="0%"
fi

# 异常健康状态标红
if [ "$HEALTH" = "unhealthy" ]; then
    printf"%-20s %-10s \033[31m%-10s\033[0m %-10s %-10s\n""$name""$status""$HEALTH""$CPU""$MEM"
else
    printf"%-20s %-10s %-10s %-10s %-10s\n""$name""$status""$HEALTH""$CPU""$MEM"
fi
done

32. 异常日志实时报警脚本（故障预警）

适用场景：实时监控日志，出现“error”“fail”等关键词时触发报警。

#!/bin/bash
# 配置参数
CONTAINER_NAME=$1
KEYWORDS="error|fail|exception|timeout|critical"# 错误关键词
CHECK_INTERVAL=5 # 检查间隔（秒）

if [ -z "$CONTAINER_NAME" ]; then
echo"用法：$0 <容器名称/ID>"
exit 1
fi

echo"监控容器 $CONTAINER_NAME 异常日志（关键词：$KEYWORDS）..."
whiletrue; do
# 查看5分钟内日志，筛选错误关键词
  ERROR_LOGS=$(docker logs --since 5m "$CONTAINER_NAME" 2>&1 | grep -iE "$KEYWORDS")

if [ -n "$ERROR_LOGS" ]; then
    # 触发报警（示例：控制台打印，可扩展为钉钉/邮件）
    ALERT_TIME=$(date +"%Y-%m-%d %H:%M:%S")
    echo -e "\n\033[31m=================== 异常日志报警 ===================\033[0m"
    echo"时间：$ALERT_TIME | 容器：$CONTAINER_NAME"
    echo"异常日志：$ERROR_LOGS"
    echo -e "\033[31m====================================================\033[0m"
fi

sleep"$CHECK_INTERVAL"
done

33. 容器网络连通性测试脚本（网络排查）

适用场景：检查所有运行中容器之间的ping连通性，定位网络隔离问题。

#!/bin/bash
# 获取所有运行中容器名称
CONTAINERS=$(docker ps --format "{{.Names}}")

echo"=================== 容器网络连通性测试 ==================="
for src in$CONTAINERS; do
echo -e "\n=== 源容器：$src ==="
for dst in$CONTAINERS; do
    if [ "$src" != "$dst" ]; then
      # ping测试（1个包，超时1秒）
      if docker exec"$src" ping -c 1 -W 1 "$dst" >/dev/null 2>&1; then
        echo"$src -> $dst：\033[32m连通\033[0m"
      else
        echo"$src -> $dst：\033[31m不通\033[0m（可能无ping工具或网络隔离）"
      fi
    fi
done
done

34. 容器资源阈值报警脚本（过载预警）

适用场景：CPU/内存使用率超过阈值（80%）时发送报警，避免资源过载。

#!/bin/bash
# 配置参数
CONTAINER_NAME=$1
CPU_THRESHOLD=80 # CPU阈值（%）
MEM_THRESHOLD=80 # 内存阈值（%）
CHECK_INTERVAL=60 # 检查间隔（秒）

if [ -z "$CONTAINER_NAME" ]; then
echo"用法：$0 <容器名称/ID>"
exit 1
fi

echo"监控容器 $CONTAINER_NAME 资源使用率（阈值：CPU $CPU_THRESHOLD%，内存 $MEM_THRESHOLD%）..."
whiletrue; do
# 提取使用率（去除%）
  CPU=$(docker stats --no-stream --format "{{.CPUPerc}}""$CONTAINER_NAME" | tr -d '%')
  MEM=$(docker stats --no-stream --format "{{.MemPerc}}""$CONTAINER_NAME" | tr -d '%')

# CPU报警
if (( $(echo "$CPU > $CPU_THRESHOLD" | bc -l) )); then
    echo"$(date +"%Y-%m-%d %H:%M:%S") - \033[31m报警\033[0m：CPU过高（${CPU}%）"
fi

# 内存报警
if (( $(echo "$MEM > $MEM_THRESHOLD" | bc -l) )); then
    echo"$(date +"%Y-%m-%d %H:%M:%S") - \033[31m报警\033[0m：内存过高（${MEM}%）"
fi

sleep"$CHECK_INTERVAL"
done

三、数据备份与恢复：构建数据安全闭环

35. 容器安全漏洞扫描脚本（镜像安全）

适用场景：扫描镜像漏洞（如CVE），预警长期未更新的镜像。

#!/bin/bash
# 配置参数
SEVERITY="HIGH,CRITICAL"# 漏洞级别
UPDATE_WARN_DAYS=180      # 镜像更新预警天数（6个月）

echo"=================== 容器镜像安全扫描 ==================="
# 遍历运行中容器
docker ps --format "{{.Image}} {{.Names}}" | whileread -r image name; do
echo -e "\n=== 扫描容器：$name（镜像：$image）==="

# 1. 漏洞扫描（需安装docker scan依赖，如Trivy）
echo"1. 漏洞扫描（级别：$SEVERITY）："
  docker scan --severity "$SEVERITY""$image" 2>/dev/null

# 2. 镜像更新检查
echo -e "\n2. 镜像更新检查："
  CREATE_TIME=$(docker inspect --format='{{.Created}}'"$image" | cut -d'T' -f1)
  DAYS_SINCE_CREATE=$(( ( $(date +%s) - $(date -d "$CREATE_TIME" +%s) ) / 86400 ))

if [ "$DAYS_SINCE_CREATE" -gt "$UPDATE_WARN_DAYS" ]; then
    echo"\033[31m预警\033[0m：镜像已超过 $UPDATE_WARN_DAYS 天未更新（创建于：$CREATE_TIME）"
else
    echo"镜像更新正常（创建于：$CREATE_TIME，距今 $DAYS_SINCE_CREATE 天）"
fi
done

36. 容器数据增量备份脚本（节省空间）

适用场景：仅备份上次备份后变更的数据，大幅节省存储空间（基于rsync）。

#!/bin/bash
# 参数：容器名称/ID
CONTAINER_NAME=$1
CONTAINER_DATA_DIR="/data"# 容器内备份目录
BACKUP_HOST_DIR="/backup/incremental/$CONTAINER_NAME"
LATEST_DIR="$BACKUP_HOST_DIR/latest"# 最新全量目录
RETENTION_DAYS=7 # 保留增量备份天数
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
INCR_DIR="$BACKUP_HOST_DIR/$TIMESTAMP"# 本次增量目录

if [ -z "$CONTAINER_NAME" ]; then
echo"用法：$0 <容器名称/ID>"
exit 1
fi

# 1. 创建目录
mkdir -p "$LATEST_DIR""$INCR_DIR"

# 2. 增量备份（--backup：变更文件保存到增量目录）
echo"执行容器 $CONTAINER_NAME 的增量备份..."
docker exec"$CONTAINER_NAME" tar cf - -C "$CONTAINER_DATA_DIR" . | \
  rsync --archive --backup --backup-dir="$INCR_DIR" - "$LATEST_DIR/"

# 3. 清理旧增量备份
echo"清理超过 $RETENTION_DAYS 天的旧增量备份..."
find "$BACKUP_HOST_DIR" -type d -name "20*" -mtime +$RETENTION_DAYS | xargs rm -rf

echo "增量备份完成：最新全量=$LATEST_DIR，本次增量=$INCR_DIR"

37. 容器数据库自动转储脚本（数据库备份）

适用场景：自动导出MySQL/PostgreSQL数据库为.sql文件，支持定时备份。

#!/bin/bash
# 参数1：数据库容器名；参数2：数据库类型（mysql/postgres）；参数3：备份目录
DB_CONTAINER=$1
DB_TYPE=$2
BACKUP_DIR=$3

if [ -z "$DB_CONTAINER" ] || [ -z "$DB_TYPE" ] || [ -z "$BACKUP_DIR" ]; then
echo"用法：$0 <容器名> <mysql/postgres> <备份目录>"
exit 1
fi

# 配置
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="$BACKUP_DIR/${DB_CONTAINER}_${DB_TYPE}_backup_$TIMESTAMP.sql"
mkdir -p "$BACKUP_DIR"

echo"备份 $DB_TYPE 数据库容器 $DB_CONTAINER 到 $BACKUP_FILE..."
case$DB_TYPEin
    mysql)
        # MySQL：依赖MYSQL_ROOT_PASSWORD环境变量
        docker exec"$DB_CONTAINER" sh -c 'exec mysqldump --all-databases -uroot -p"$MYSQL_ROOT_PASSWORD"' > "$BACKUP_FILE"
        ;;
    postgres)
        # PostgreSQL：默认用户postgres
        docker exec"$DB_CONTAINER" sh -c 'exec pg_dumpall -U postgres' > "$BACKUP_FILE"
        ;;
    *)
        echo"不支持的数据库类型：$DB_TYPE"
        exit 1
esac

# 检查备份是否成功
if [ -s "$BACKUP_FILE" ]; then
echo"备份成功（大小：$(du -sh "$BACKUP_FILE" | awk '{print $1}')）"
else
echo"\033[31m备份失败（文件为空）\033[0m"
rm -f "$BACKUP_FILE"
exit 1
fi

38. 容器数据一致性检查脚本（备份验证）

适用场景：备份后模拟恢复，验证关键文件是否存在，确保备份可恢复。

#!/bin/bash
# 参数：备份文件路径（如/backup/my_container.tar）
BACKUP_FILE=$1

if [ -z "$BACKUP_FILE" ]; then
echo"用法：$0 <备份文件路径>"
exit 1
fi

# 1. 检查备份文件
if [ ! -f "$BACKUP_FILE" ]; then
echo"备份文件 $BACKUP_FILE 不存在"
exit 1
fi

# 2. 创建临时容器
TEMP_CONTAINER=$(docker run -d --rm busybox tail -f /dev/null)
echo"临时验证容器：$TEMP_CONTAINER"

# 3. 解压备份到临时容器
echo"验证备份文件 $BACKUP_FILE..."
docker cp"$BACKUP_FILE""$TEMP_CONTAINER:/backup.tar"
docker exec"$TEMP_CONTAINER" tar xf /backup.tar -C /

# 4. 检查关键文件（根据实际数据调整）
CHECK_FILES=("etc/passwd""data/app.conf""var/lib/mysql/mysql")
echo -e "\n关键文件检查结果："
VALID=true
for file in"${CHECK_FILES[@]}"; do
if docker exec"$TEMP_CONTAINER" [ -f "/$file" ] || docker exec"$TEMP_CONTAINER" [ -d "/$file" ]; then
    echo"✅ /$file 存在"
else
    echo"❌ /$file 缺失"
    VALID=false
fi
done

# 5. 清理临时容器
docker stop "$TEMP_CONTAINER"

# 6. 输出结果
if [ "$VALID" = true ]; then
echo -e "\n\033[32m备份验证通过，可恢复\033[0m"
else
echo -e "\n\033[31m备份验证失败，不可恢复\033[0m"
exit 1
fi

39. 跨主机容器数据同步脚本（灾备）

适用场景：将源主机容器数据同步到目标主机（如生产→灾备），支持多活部署。

#!/bin/bash
# 参数1：源容器名；参数2：目标主机IP；参数3：目标容器名；参数4：源容器数据目录
SRC_CONTAINER=$1
DEST_HOST=$2
DEST_CONTAINER=$3
SRC_DATA_DIR=$4

if [ -z "$SRC_CONTAINER" ] || [ -z "$DEST_HOST" ] || [ -z "$DEST_CONTAINER" ] || [ -z "$SRC_DATA_DIR" ]; then
echo"用法：$0 <源容器名> <目标IP> <目标容器名> <源数据目录>"
exit 1
fi

# 前提：源主机配置免密SSH登录目标主机（ssh-keygen && ssh-copy-id root@$DEST_HOST）
SSH_USER="root"

echo"同步 $SRC_CONTAINER:$SRC_DATA_DIR 到 $DEST_HOST:$DEST_CONTAINER..."
# 打包→SSH传输→解压
docker exec"$SRC_CONTAINER" tar cf - -C "$SRC_DATA_DIR" . | \
  ssh "$SSH_USER@$DEST_HOST""docker exec -i $DEST_CONTAINER tar xf - -C /$SRC_DATA_DIR"

if [ $? -eq 0 ]; then
echo"✅ 跨主机同步完成"
else
echo"❌ 跨主机同步失败"
exit 1
fi

40. 容器数据加密备份脚本（敏感数据）

适用场景：备份敏感数据时，通过AES256加密，防止数据泄露。

#!/bin/bash
# 参数：容器名称/ID
CONTAINER_NAME=$1
CONTAINER_DATA_DIR="/data"# 敏感数据目录
BACKUP_HOST_DIR="/backup/encrypted"
# 加密密钥：建议通过环境变量传入（export DOCKER_BACKUP_KEY="your-key"）
ENCRYPT_KEY=${DOCKER_BACKUP_KEY}

if [ -z "$CONTAINER_NAME" ] || [ -z "$ENCRYPT_KEY" ]; then
echo"用法：1. export DOCKER_BACKUP_KEY='密钥'; 2. $0 <容器名>"
exit 1
fi

# 1. 创建目录
mkdir -p "$BACKUP_HOST_DIR"

# 2. 备份并加密（AES256）
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="$BACKUP_HOST_DIR/${CONTAINER_NAME}_encrypted_$TIMESTAMP.tar.gpg"

echo"加密备份容器 $CONTAINER_NAME 的 $CONTAINER_DATA_DIR..."
docker exec"$CONTAINER_NAME" tar cf - -C "$CONTAINER_DATA_DIR" . | \
  gpg --batch --yes --passphrase "$ENCRYPT_KEY" --symmetric --cipher-algo AES256 -o "$BACKUP_FILE"

# 3. 检查备份
if [ -s "$BACKUP_FILE" ]; then
echo"✅ 加密备份完成：$BACKUP_FILE（大小：$(du -sh "$BACKUP_FILE" | awk '{print $1}')）"
else
echo"❌ 加密备份失败"
rm -f "$BACKUP_FILE"
exit 1
fi

# 解密方法：gpg --batch --yes --passphrase "$ENCRYPT_KEY" -d 备份文件 | tar xf -

四、网络精细化管理：解决网络隔离与连通问题

41. 指定端口的容器网络连通性测试（精准排查）

适用场景：微服务API调用失败时，测试“源容器→目标容器指定端口”的连通性。

#!/bin/bash
# 参数1：源容器名；参数2：目标容器名；参数3：目标端口（如8080）
SRC_CONTAINER=$1
DST_CONTAINER=$2
DST_PORT=$3

if [ -z "$SRC_CONTAINER" ] || [ -z "$DST_CONTAINER" ] || [ -z "$DST_PORT" ]; then
echo"用法：$0 <源容器名> <目标容器名> <目标端口>"
exit 1
fi

# 1. 获取目标容器IP
DST_IP=$(docker inspect --format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}'"$DST_CONTAINER")
if [ -z "$DST_IP" ]; then
echo"无法获取目标容器 $DST_CONTAINER 的IP"
exit 1
fi

echo"测试 $SRC_CONTAINER → $DST_CONTAINER（$DST_IP:$DST_PORT）..."
# 2. nc测试端口（-z：扫描端口；-w 3：超时3秒）
if docker exec"$SRC_CONTAINER" nc -z -w 3 "$DST_IP""$DST_PORT"; then
echo"✅ 端口 $DST_PORT 连通正常"
else
echo"❌ 端口 $DST_PORT 无法连通"
# 辅助排查：查看目标容器端口监听
echo -e "\n目标容器端口监听："
  docker exec"$DST_CONTAINER" netstat -tuln 2>/dev/null | grep "$DST_PORT" || echo"未监听端口 $DST_PORT"
fi

42. 容器网络流量实时监控（带宽排查）

适用场景：服务器带宽异常时，查看各容器的网络收发速率，定位“流量大户”。

#!/bin/bash
# 参数（可选）：容器名（不填则监控所有运行容器）
CONTAINER_NAME=$1
CHECK_INTERVAL=2 # 监控间隔（秒）

# 过滤条件
if [ -n "$CONTAINER_NAME" ]; then
  FILTER="--filter name=$CONTAINER_NAME"
else
  FILTER="--filter status=running"
fi

echo"容器网络流量监控（间隔 $CHECK_INTERVAL 秒，按Ctrl+C退出）..."
echo"======================================================"
printf"%-20s %-15s %-15s %-10s\n""容器名称""接收速率""发送速率""时间"
echo"------------------------------------------------------"

whiletrue; do
# 提取网络数据（NetIO格式：实时速率/累计速率）
  docker stats $FILTER --no-stream --format "{{.Name}} {{.NetIO}}" | \
  awk -v time=$(date +"%H:%M:%S") '{
    split($2, recv, "/"); 
    split($3, send, "/"); 
    printf "%-20s %-15s %-15s %-10s\n", $1, recv[1], send[1], time
  }'

sleep"$CHECK_INTERVAL"
echo"------------------------------------------------------"
done

五、镜像深度治理：规范镜像管理

43. 镜像冗余标签清理脚本（标签规范）

适用场景：CI/CD频繁构建镜像时，清理同一镜像的冗余标签（保留最新10个）。

#!/bin/bash
# 配置参数：保留同一镜像的最新标签数量
RETENTION_COUNT=10

echo "清理镜像冗余标签（保留最新 $RETENTION_COUNT 个）..."
# 按镜像ID分组，按创建时间倒序
docker images --format "{{.ID}} {{.Repository}}:{{.Tag}} {{.CreatedAt}}" | \
sort -k1,1 -k3,3r | # 先按ID排序，再按时间倒序
awk -v count="$RETENTION_COUNT" '
    BEGIN { prev_id = ""; tag_num = 0 }
    {
        if ($1 != prev_id) {
            prev_id = $1;
            tag_num = 1;
        } else {
            tag_num++;
            if (tag_num > count) {
                print "删除冗余标签：" $2;
                system("docker rmi " $2 " > /dev/null 2>&1");
            }
        }
    }
'

echo "镜像冗余标签清理完成"

44. 镜像跨环境导出与导入脚本（离线迁移）

适用场景：无网络环境部署镜像，通过“导出-拷贝-导入”实现离线迁移，保留元数据。

#!/bin/bash
# 参数1：操作类型（export/import）；参数2：镜像名/备份路径；参数3：备份路径/新镜像名
ACTION=$1
PARAM2=$2
PARAM3=$3

if [ -z "$ACTION" ] || [ -z "$PARAM2" ] || [ -z "$PARAM3" ] || [[ ! "$ACTION" =~ ^(export|import)$ ]]; then
echo"用法："
echo"  导出：$0 export <镜像名> <备份路径>"
echo"  导入：$0 import <备份路径> <新镜像名>"
exit 1
fi

case$ACTIONin
    export)
        IMAGE_NAME=$PARAM2
        BACKUP_FILE=$PARAM3
        echo"导出镜像 $IMAGE_NAME 到 $BACKUP_FILE..."
        
        # 备份元数据（标签、环境变量等）
        docker inspect "$IMAGE_NAME" > "${BACKUP_FILE}.json"
        
        # 导出镜像
        docker save -o "$BACKUP_FILE""$IMAGE_NAME"
        
        if [ $? -eq 0 ]; then
          echo"✅ 导出完成（含元数据：${BACKUP_FILE}.json）"
        else
          echo"❌ 导出失败"
          rm -f "$BACKUP_FILE""${BACKUP_FILE}.json"
          exit 1
        fi
        ;;
    import)
        BACKUP_FILE=$PARAM2
        NEW_IMAGE_NAME=$PARAM3
        echo"从 $BACKUP_FILE 导入镜像为 $NEW_IMAGE_NAME..."
        
        # 导入镜像
        docker load -i "$BACKUP_FILE"
        
        # 恢复标签（需安装jq工具）
        if [ -f "${BACKUP_FILE}.json" ] && command -v jq &> /dev/null; then
          ORIGINAL_TAG=$(jq -r '.[0].RepoTags[0]'"${BACKUP_FILE}.json")
          if [ "$ORIGINAL_TAG" != "null" ]; then
            IMAGE_ID=$(docker images --format "{{.ID}} {{.Repository}}:{{.Tag}}" | grep "<none>:<none>" | head -1 | awk '{print $1}')
            docker tag "$IMAGE_ID""$ORIGINAL_TAG"
            echo"✅ 标签恢复完成：$ORIGINAL_TAG"
          fi
        fi
        
        echo"✅ 导入完成"
        ;;
esac

45. Docker构建缓存清理脚本（构建异常修复）

适用场景：构建缓存未刷新导致依赖未升级时，清理构建缓存解决问题。

#!/bin/bash
echo"=================== Docker构建缓存清理 ==================="
# 1. 查看当前缓存占用
echo"当前构建缓存占用："
docker system df -v | grep -A 5 "Build Cache"

# 2. 确认清理
read -p "是否清理所有构建缓存？(y/n) " -n 1 -r
echo
if [[ $REPLY =~ ^[Yy]$ ]]; then
# 清理构建缓存
  docker builder prune -af
echo -e "\n✅ 构建缓存清理完成"

# 清理后占用
echo"清理后构建缓存占用："
  docker system df -v | grep -A 5 "Build Cache"
else
echo -e "\n❌ 取消清理"
fi

六、安全合规：加固容器安全

46. 检查容器是否以root用户运行（降低越权风险）

适用场景：预警root用户运行的容器，降低被入侵后越权的风险。

#!/bin/bash
echo"=================== 容器运行用户检查 ==================="
printf"%-20s %-15s %-10s\n""容器名称""启动用户""风险等级"
echo"------------------------------------------------------"

# 遍历所有运行中容器
docker ps --format "{{.Names}} {{.ID}}" | whileread -r name id; do
# 获取容器启动用户（默认root）
  USER=$(docker inspect --format='{{.Config.User}}'"$id")
if [ -z "$USER" ] || [ "$USER" = "root" ]; then
    RISK="高（root）"
    # 高风险标红
    printf"%-20s %-15s \033[31m%-10s\033[0m\n""$name""root""$RISK"
else
    RISK="低（非root）"
    printf"%-20s %-15s \033[32m%-10s\033[0m\n""$name""$USER""$RISK"
fi
done

echo"------------------------------------------------------"
echo "建议：通过Dockerfile的USER指令指定非root用户（如 USER 1000）"

47. Docker镜像签名验证脚本（防止恶意镜像）

适用场景：验证镜像是否经过签名，防止使用被篡改的恶意镜像。

#!/bin/bash
# 参数：待验证镜像名（如nginx:latest、your-registry/app:v1）
IMAGE_NAME=$1

if [ -z "$IMAGE_NAME" ]; then
echo"用法：$0 <镜像名称>"
exit 1
fi

# 前提：已通过docker trust初始化签名密钥（docker trust init）
echo"验证镜像 $IMAGE_NAME 的签名..."
if docker trust inspect --pretty "$IMAGE_NAME" > /dev/null 2>&1; then
# 输出签名信息（签名者、有效期等）
echo"✅ 镜像签名验证通过"
  docker trust inspect --pretty "$IMAGE_NAME"
else
echo -e "\033[31m❌ 镜像签名验证失败\033[0m"
echo"可能原因：1. 镜像未签名；2. 签名密钥未导入；3. 镜像被篡改"
echo"建议：仅使用已签名的官方镜像或内部可信镜像"
exit 1
fi

七、跨平台适配：支持Windows容器

48. Windows容器批量启停脚本（跨平台管理）

适用场景：管理Windows容器（如.NET Framework应用），实现批量启停。

#!/bin/bash
# 适用：Windows系统（WSL或原生Windows Docker）
# 参数：start/stop/restart
ACTION=$1

# 检查Docker是否为Windows容器模式
if ! docker info | grep -q "OSType: windows"; then
echo"❌ 当前为Linux容器模式，请切换到Windows容器模式后执行"
exit 1
fi

case$ACTIONin
    start)
        echo"启动所有已停止的Windows容器..."
        docker start $(docker ps -aq --filter "status=exited" --filter "Os=windows")
        ;;
    stop)
        echo"停止所有运行中的Windows容器..."
        docker stop $(docker ps -q --filter "Os=windows")
        ;;
    restart)
        echo"重启所有运行中的Windows容器..."
        docker restart $(docker ps -q --filter "Os=windows")
        ;;
    *)
        echo"用法：$0 {start|stop|restart}"
        exit 1
esac

echo "✅ Windows容器 $ACTION 操作完成"

49. 带“临时”标签的容器自动清理脚本（临时任务管理）

适用场景：清理测试环境的临时容器（按“temp-”前缀或“temporary=true”标签）。

#!/bin/bash
echo"=================== 临时容器清理 ==================="

# 1. 清理名称以"temp-"开头的容器（如temp-mysql-test）
echo"1. 清理名称前缀为'temp-'的容器："
TEMP_BY_NAME=$(docker ps -aq --filter "name=^/temp-")
if [ -n "$TEMP_BY_NAME" ]; then
  docker rm -f $TEMP_BY_NAME
echo"已删除 $(echo $TEMP_BY_NAME | wc -w) 个容器（ID：$TEMP_BY_NAME）"
else
echo"无符合条件的容器"
fi

# 2. 清理标签为"temporary=true"的容器（更灵活的标记方式）
echo -e "\n2. 清理标签为'temporary=true'的容器："
TEMP_BY_LABEL=$(docker ps -aq --filter "label=temporary=true")
if [ -n "$TEMP_BY_LABEL" ]; then
  docker rm -f $TEMP_BY_LABEL
echo"已删除 $(echo $TEMP_BY_LABEL | wc -w) 个容器（ID：$TEMP_BY_LABEL）"
else
echo"无符合条件的容器"
fi

echo -e "\n✅ 临时容器清理完成"