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

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"; thendocker 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" ]; thenecho "成功启动容器ID：$STARTED_CONTAINERS"
elseecho "无可用容器可启动（或所有容器已运行）"
fi

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

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

#!/bin/bash
echo "开始批量停止运行中容器..."
STOPPED_CONTAINERS=$(docker stop $(docker ps -q))if [ -n "$STOPPED_CONTAINERS" ]; thenecho "成功停止容器ID：$STOPPED_CONTAINERS"
elseecho "无运行中容器可停止"
fi

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

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

#!/bin/bash
echo "开始删除所有已停止的容器..."
DELETED_CONTAINERS=$(docker rm $(docker ps -aq -f "status=exited"))if [ -n "$DELETED_CONTAINERS" ]; thenecho "成功删除容器ID：$DELETED_CONTAINERS"
elseecho "无停止状态的容器可删除"
fi

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

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

#!/bin/bash
# 参数：镜像名称（如alpine、ubuntu）
IMAGE_NAME=$1if [ -z "$IMAGE_NAME" ]; thenecho "用法：$0 <镜像名称>"exit 1
fiecho "启动临时容器（退出后自动删除）：$IMAGE_NAME"
docker run --rm -it "$IMAGE_NAME" # --rm：停止后自动删除；-it：交互模式

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

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

#!/bin/bash
# 参数：容器名称/ID
CONTAINER_NAME=$1if [ -z "$CONTAINER_NAME" ]; thenecho "用法：$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" ]; thendocker rmi "$DANGLING_IMAGES"echo "成功删除悬空镜像ID：$DANGLING_IMAGES"
elseecho "无悬空镜像可删除"
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=$2if [ -z "$CONTAINER_ID" ] || [ -z "$BACKUP_FILE" ]; thenecho "用法：$0 <容器ID> <备份文件路径>"exit 1
fiecho "备份容器 $CONTAINER_ID 到 $BACKUP_FILE..."
docker export "$CONTAINER_ID" > "$BACKUP_FILE" # 导出文件系统为tarif [ $? -eq 0 ]; thenecho "备份成功（大小：$(du -sh "$BACKUP_FILE" | awk '{print $1}')）"
elseecho "备份失败"exit 1
fi

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

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

#!/bin/bash
# 参数1：备份文件路径；参数2：新镜像名称（如restored-app:v1）
BACKUP_FILE=$1
NEW_IMAGE_NAME=$2if [ -z "$BACKUP_FILE" ] || [ -z "$NEW_IMAGE_NAME" ]; thenecho "用法：$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]$ ]]; thendocker 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"; thendocker network create --driver "$NETWORK_DRIVER" "$NETWORK_NAME"echo "网络创建成功：$NETWORK_NAME"
elseecho "网络已存在：$NETWORK_NAME"
fi# 2. 接入容器
for container in "${TARGET_CONTAINERS[@]}"; doif docker ps -a | grep -q "$container"; thendocker network connect "$NETWORK_NAME" "$container"echo "容器 $container 已接入网络"elseecho "容器 $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=$1if [ -z "$CONTAINER_NAME" ]; thenecho "用法：$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 -10echo -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" ]; thencp "$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=$1if [ -z "$ACTION" ] || [[ ! "$ACTION" =~ ^(start|stop|restart)$ ]]; thenecho "用法：$0 {start|stop|restart}"exit 1
ficase $ACTION instart)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");;
esacecho "$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}}' | while read -r id create_time; docontainer_time=$(date -d "$create_time" +%s)if [ "$container_time" -lt "$SEVEN_DAYS_AGO" ]; thendocker rm "$id"echo "已删除容器 $id（创建于：$create_time）"fi
doneecho "条件式清理完成"

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

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

#!/bin/bash
# 参数：容器名称/ID（需配置HEALTHCHECK）
CONTAINER_NAME=$1
CHECK_INTERVAL=30 # 检查间隔（秒）if [ -z "$CONTAINER_NAME" ]; thenecho "用法：$0 <容器名称/ID>"exit 1
fiecho "监控容器 $CONTAINER_NAME 健康状态（每 $CHECK_INTERVAL 秒检查）..."
while true; doHEALTH_STATUS=$(docker inspect --format='{{.State.Health.Status}}' "$CONTAINER_NAME" 2>/dev/null)if [ "$HEALTH_STATUS" != "healthy" ] || [ -z "$HEALTH_STATUS" ]; thenecho "$(date +"%Y-%m-%d %H:%M:%S") - 容器异常（$HEALTH_STATUS），重启..."docker restart "$CONTAINER_NAME"sleep 30 # 避免频繁重启fisleep "$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 秒检查）..."
while true; doNEW_HASH=$(md5sum "$CONFIG_FILE" | awk '{print $1}')if [ "$NEW_HASH" != "$OLD_HASH" ]; thenecho "$(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 "容器重启完成，配置生效"fisleep "$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[@]}"; doecho "启动容器：$container"docker start "$container"# 等待容器就绪wait_time=0while true; doHEALTH=$(docker inspect --format='{{.State.Health.Status}}' "$container" 2>/dev/null || echo "running")STATUS=$(docker inspect --format='{{.State.Status}}' "$container")if [ "$HEALTH" = "healthy" ] || [ "$STATUS" = "running" ]; thenecho "容器 $container 已就绪（等待 $wait_time 秒）"breakfiif [ "$wait_time" -ge "$MAX_WAIT" ]; thenecho "容器 $container 启动超时，终止流程"exit 1fiwait_time=$((wait_time + 1))sleep 1done
doneecho "所有容器按依赖顺序启动完成"

二、资源监控与预警（26-34）：提前解决资源瓶颈

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

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

#!/bin/bash
# 配置参数：清理超过30天的悬空镜像
RETENTION_DAYS=30echo "清理超过 $RETENTION_DAYS 天的悬空镜像..."
# 遍历悬空镜像，按时间筛选
docker images --filter "dangling=true" --format '{{.ID}} {{.CreatedSince}}' | while read -r id create_time; doif [[ "$create_time" == *"months"* ]] || [[ "$create_time" == *"weeks"* && $(echo "$create_time" | awk '{print $1}') -ge 4 ]]; thendocker rmi "$id"echo "已删除镜像 $id（创建于：$create_time）"fi
doneecho "镜像垃圾回收完成"

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" ]; thenecho "使用率超过阈值，执行清理..."docker system prune -af --volumes# 清理后使用率NEW_USAGE=$(df --output=pcent "$DOCKER_DIR" | tail -n 1 | tr -dc '0-9')echo "清理完成，当前使用率：$NEW_USAGE%"
elseecho "使用率未超过阈值，无需清理"
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[@]}"; doecho "备份容器 $container 的数据卷..."# 获取数据卷路径VOLUME_PATHS=$(docker inspect --format='{{range .Mounts}}{{.Destination}} {{end}}' "$container" | tr ' ' '\n' | grep -v '^$')for vol_path in $VOLUME_PATHS; doBACKUP_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 ]; thenecho "执行资源清理..."docker system prune -af --volumesecho "清理完成"
fi

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

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

#!/bin/bash
echo "=================== 容器资源限制检查 ==================="
printf "%-20s %-15s %-15s\n" "容器名称" "CPU限制" "内存限制"
echo "------------------------------------------------------"# 遍历运行中容器
docker ps --format "{{.Names}} {{.ID}}" | while read -r name id; do# CPU限制（纳核→核）CPU_LIMIT=$(docker inspect --format='{{.HostConfig.NanoCpus}}' "$id")if [ "$CPU_LIMIT" -eq 0 ]; thenCPU_LIMIT="无限制"elseCPU_LIMIT="$((CPU_LIMIT / 1000000000.0)) 核"fi# 内存限制（字节→MB）MEM_LIMIT=$(docker inspect --format='{{.HostConfig.Memory}}' "$id")if [ "$MEM_LIMIT" -eq 0 ]; thenMEM_LIMIT="无限制"elseMEM_LIMIT="$((MEM_LIMIT / 1024 / 1024)) MB"fi# 预警无限制容器if [ "$CPU_LIMIT" = "无限制" ] || [ "$MEM_LIMIT" = "无限制" ]; thenprintf "%-20s \033[31m%-15s\033[0m \033[31m%-15s\033[0m\n" "$name" "$CPU_LIMIT" "$MEM_LIMIT"elseprintf "%-20s %-15s %-15s\n" "$name" "$CPU_LIMIT" "$MEM_LIMIT"fi
doneecho "建议：为核心容器设置限制（如 docker update --memory=512m 容器名）"

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

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

#!/bin/bash
# 参数：容器名称/ID
CONTAINER_NAME=$1
MEM_RATIO=0.5 # 内存分配比例if [ -z "$CONTAINER_NAME" ]; thenecho "用法：$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}}" | while read -r name id status; doHEALTH=$(docker inspect --format='{{.State.Health.Status}}' "$id" 2>/dev/null || echo "N/A")# 资源使用率（停止容器为0%）if [ "$status" = "running" ]; thenCPU=$(docker stats --no-stream --format "{{.CPUPerc}}" "$id")MEM=$(docker stats --no-stream --format "{{.MemPerc}}" "$id")elseCPU="0%"MEM="0%"fi# 异常健康状态标红if [ "$HEALTH" = "unhealthy" ]; thenprintf "%-20s %-10s \033[31m%-10s\033[0m %-10s %-10s\n" "$name" "$status" "$HEALTH" "$CPU" "$MEM"elseprintf "%-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" ]; thenecho "用法：$0 <容器名称/ID>"exit 1
fiecho "监控容器 $CONTAINER_NAME 异常日志（关键词：$KEYWORDS）..."
while true; 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"fisleep "$CHECK_INTERVAL"
done

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

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

#!/bin/bash
# 获取所有运行中容器名称
CONTAINERS=$(docker ps --format "{{.Names}}")echo "=================== 容器网络连通性测试 ==================="
for src in $CONTAINERS; doecho -e "\n=== 源容器：$src ==="for dst in $CONTAINERS; doif [ "$src" != "$dst" ]; then# ping测试（1个包，超时1秒）if docker exec "$src" ping -c 1 -W 1 "$dst" >/dev/null 2>&1; thenecho "$src -> $dst：\033[32m连通\033[0m"elseecho "$src -> $dst：\033[31m不通\033[0m（可能无ping工具或网络隔离）"fifidone
done

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

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

#!/bin/bash
# 配置参数
CONTAINER_NAME=$1
CPU_THRESHOLD=80 # CPU阈值（%）
MEM_THRESHOLD=80 # 内存阈值（%）
CHECK_INTERVAL=60 # 检查间隔（秒）if [ -z "$CONTAINER_NAME" ]; thenecho "用法：$0 <容器名称/ID>"exit 1
fiecho "监控容器 $CONTAINER_NAME 资源使用率（阈值：CPU $CPU_THRESHOLD%，内存 $MEM_THRESHOLD%）..."
while true; 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) )); thenecho "$(date +"%Y-%m-%d %H:%M:%S") - \033[31m报警\033[0m：CPU过高（${CPU}%）"fi# 内存报警if (( $(echo "$MEM > $MEM_THRESHOLD" | bc -l) )); thenecho "$(date +"%Y-%m-%d %H:%M:%S") - \033[31m报警\033[0m：内存过高（${MEM}%）"fisleep "$CHECK_INTERVAL"
done

三、数据备份与恢复（35-40）：构建数据安全闭环

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

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

#!/bin/bash
# 配置参数
SEVERITY="HIGH,CRITICAL" # 漏洞级别
UPDATE_WARN_DAYS=180      # 镜像更新预警天数（6个月）echo "=================== 容器镜像安全扫描 ==================="
# 遍历运行中容器
docker ps --format "{{.Image}} {{.Names}}" | while read -r image name; doecho -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" ]; thenecho "\033[31m预警\033[0m：镜像已超过 $UPDATE_WARN_DAYS 天未更新（创建于：$CREATE_TIME）"elseecho "镜像更新正常（创建于：$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" ]; thenecho "用法：$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 -rfecho "增量备份完成：最新全量=$LATEST_DIR，本次增量=$INCR_DIR"

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

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

#!/bin/bash
# 参数1：数据库容器名；参数2：数据库类型（mysql/postgres）；参数3：备份目录
DB_CONTAINER=$1
DB_TYPE=$2
BACKUP_DIR=$3if [ -z "$DB_CONTAINER" ] || [ -z "$DB_TYPE" ] || [ -z "$BACKUP_DIR" ]; thenecho "用法：$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_TYPE inmysql)# MySQL：依赖MYSQL_ROOT_PASSWORD环境变量docker exec "$DB_CONTAINER" sh -c 'exec mysqldump --all-databases -uroot -p"$MYSQL_ROOT_PASSWORD"' > "$BACKUP_FILE";;postgres)# PostgreSQL：默认用户postgresdocker exec "$DB_CONTAINER" sh -c 'exec pg_dumpall -U postgres' > "$BACKUP_FILE";;*)echo "不支持的数据库类型：$DB_TYPE"exit 1
esac# 检查备份是否成功
if [ -s "$BACKUP_FILE" ]; thenecho "备份成功（大小：$(du -sh "$BACKUP_FILE" | awk '{print $1}')）"
elseecho "\033[31m备份失败（文件为空）\033[0m"rm -f "$BACKUP_FILE"exit 1
fi

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

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

#!/bin/bash
# 参数：备份文件路径（如/backup/my_container.tar）
BACKUP_FILE=$1if [ -z "$BACKUP_FILE" ]; thenecho "用法：$0 <备份文件路径>"exit 1
fi# 1. 检查备份文件
if [ ! -f "$BACKUP_FILE" ]; thenecho "备份文件 $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[@]}"; doif docker exec "$TEMP_CONTAINER" [ -f "/$file" ] || docker exec "$TEMP_CONTAINER" [ -d "/$file" ]; thenecho "✅ /$file 存在"elseecho "❌ /$file 缺失"VALID=falsefi
done# 5. 清理临时容器
docker stop "$TEMP_CONTAINER"# 6. 输出结果
if [ "$VALID" = true ]; thenecho -e "\n\033[32m备份验证通过，可恢复\033[0m"
elseecho -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=$4if [ -z "$SRC_CONTAINER" ] || [ -z "$DEST_HOST" ] || [ -z "$DEST_CONTAINER" ] || [ -z "$SRC_DATA_DIR" ]; thenecho "用法：$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 ]; thenecho "✅ 跨主机同步完成"
elseecho "❌ 跨主机同步失败"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" ]; thenecho "用法：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" ]; thenecho "✅ 加密备份完成：$BACKUP_FILE（大小：$(du -sh "$BACKUP_FILE" | awk '{print $1}')）"
elseecho "❌ 加密备份失败"rm -f "$BACKUP_FILE"exit 1
fi# 解密方法：gpg --batch --yes --passphrase "$ENCRYPT_KEY" -d 备份文件 | tar xf -

四、网络精细化管理（41-42）：解决网络隔离与连通问题

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

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

#!/bin/bash
# 参数1：源容器名；参数2：目标容器名；参数3：目标端口（如8080）
SRC_CONTAINER=$1
DST_CONTAINER=$2
DST_PORT=$3if [ -z "$SRC_CONTAINER" ] || [ -z "$DST_CONTAINER" ] || [ -z "$DST_PORT" ]; thenecho "用法：$0 <源容器名> <目标容器名> <目标端口>"exit 1
fi# 1. 获取目标容器IP
DST_IP=$(docker inspect --format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' "$DST_CONTAINER")
if [ -z "$DST_IP" ]; thenecho "无法获取目标容器 $DST_CONTAINER 的IP"exit 1
fiecho "测试 $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"; thenecho "✅ 端口 $DST_PORT 连通正常"
elseecho "❌ 端口 $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" ]; thenFILTER="--filter name=$CONTAINER_NAME"
elseFILTER="--filter status=running"
fiecho "容器网络流量监控（间隔 $CHECK_INTERVAL 秒，按Ctrl+C退出）..."
echo "======================================================"
printf "%-20s %-15s %-15s %-10s\n" "容器名称" "接收速率" "发送速率" "时间"
echo "------------------------------------------------------"while true; 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-45）：规范镜像管理

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

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

#!/bin/bash
# 配置参数：保留同一镜像的最新标签数量
RETENTION_COUNT=10echo "清理镜像冗余标签（保留最新 $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=$3if [ -z "$ACTION" ] || [ -z "$PARAM2" ] || [ -z "$PARAM3" ] || [[ ! "$ACTION" =~ ^(export|import)$ ]]; thenecho "用法："echo "  导出：$0 export <镜像名> <备份路径>"echo "  导入：$0 import <备份路径> <新镜像名>"exit 1
ficase $ACTION inexport)IMAGE_NAME=$PARAM2BACKUP_FILE=$PARAM3echo "导出镜像 $IMAGE_NAME 到 $BACKUP_FILE..."# 备份元数据（标签、环境变量等）docker inspect "$IMAGE_NAME" > "${BACKUP_FILE}.json"# 导出镜像docker save -o "$BACKUP_FILE" "$IMAGE_NAME"if [ $? -eq 0 ]; thenecho "✅ 导出完成（含元数据：${BACKUP_FILE}.json）"elseecho "❌ 导出失败"rm -f "$BACKUP_FILE" "${BACKUP_FILE}.json"exit 1fi;;import)BACKUP_FILE=$PARAM2NEW_IMAGE_NAME=$PARAM3echo "从 $BACKUP_FILE 导入镜像为 $NEW_IMAGE_NAME..."# 导入镜像docker load -i "$BACKUP_FILE"# 恢复标签（需安装jq工具）if [ -f "${BACKUP_FILE}.json" ] && command -v jq &> /dev/null; thenORIGINAL_TAG=$(jq -r '.[0].RepoTags[0]' "${BACKUP_FILE}.json")if [ "$ORIGINAL_TAG" != "null" ]; thenIMAGE_ID=$(docker images --format "{{.ID}} {{.Repository}}:{{.Tag}}" | grep "<none>:<none>" | head -1 | awk '{print $1}')docker tag "$IMAGE_ID" "$ORIGINAL_TAG"echo "✅ 标签恢复完成：$ORIGINAL_TAG"fifiecho "✅ 导入完成";;
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 -afecho -e "\n✅ 构建缓存清理完成"# 清理后占用echo "清理后构建缓存占用："docker system df -v | grep -A 5 "Build Cache"
elseecho -e "\n❌ 取消清理"
fi

六、安全合规（46-47）：加固容器安全

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

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

#!/bin/bash
echo "=================== 容器运行用户检查 ==================="
printf "%-20s %-15s %-10s\n" "容器名称" "启动用户" "风险等级"
echo "------------------------------------------------------"# 遍历所有运行中容器
docker ps --format "{{.Names}} {{.ID}}" | while read -r name id; do# 获取容器启动用户（默认root）USER=$(docker inspect --format='{{.Config.User}}' "$id")if [ -z "$USER" ] || [ "$USER" = "root" ]; thenRISK="高（root）"# 高风险标红printf "%-20s %-15s \033[31m%-10s\033[0m\n" "$name" "root" "$RISK"elseRISK="低（非root）"printf "%-20s %-15s \033[32m%-10s\033[0m\n" "$name" "$USER" "$RISK"fi
doneecho "------------------------------------------------------"
echo "建议：通过Dockerfile的USER指令指定非root用户（如 USER 1000）"

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

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

#!/bin/bash
# 参数：待验证镜像名（如nginx:latest、your-registry/app:v1）
IMAGE_NAME=$1if [ -z "$IMAGE_NAME" ]; thenecho "用法：$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"
elseecho -e "\033[31m❌ 镜像签名验证失败\033[0m"echo "可能原因：1. 镜像未签名；2. 签名密钥未导入；3. 镜像被篡改"echo "建议：仅使用已签名的官方镜像或内部可信镜像"exit 1
fi

七、跨平台适配（48-49）：支持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"; thenecho "❌ 当前为Linux容器模式，请切换到Windows容器模式后执行"exit 1
ficase $ACTION instart)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
esacecho "✅ 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" ]; thendocker rm -f $TEMP_BY_NAMEecho "已删除 $(echo $TEMP_BY_NAME | wc -w) 个容器（ID：$TEMP_BY_NAME）"
elseecho "无符合条件的容器"
fi# 2. 清理标签为"temporary=true"的容器（更灵活的标记方式）
echo -e "\n2. 清理标签为'temporary=true'的容器："
TEMP_BY_LABEL=$(docker ps -aq --filter "label=temporary=true")
if [ -n "$TEMP_BY_LABEL" ]; thendocker rm -f $TEMP_BY_LABELecho "已删除 $(echo $TEMP_BY_LABEL | wc -w) 个容器（ID：$TEMP_BY_LABEL）"
elseecho "无符合条件的容器"
fiecho -e "\n✅ 临时容器清理完成"