Docker命令大全：从入门到精通的完整参考指南

0259

本文系统整理了Docker全系列命令及实战应用场景，涵盖基础操作、镜像管理、容器控制、网络配置、数据卷、Docker Compose编排和Docker Swarm集群管理等核心技术，提供完整的命令参考和实战示例。

图片[1]-Docker命令完全指南 - 从基础到高级的容器化运维实战手册

Docker基础命令与系统管理

系统信息与版本检查

<strong>#!/bin/bash</strong>
# docker_system_check.sh - Docker系统检查与诊断脚本

# Docker版本信息
echo "=== Docker版本信息 ==="
docker version
echo ""

# Docker系统信息
echo "=== Docker系统信息 ==="
docker system info
echo ""

# Docker系统磁盘使用
echo "=== Docker磁盘使用 ==="
docker system df
echo ""

# 详细磁盘使用分析
echo "=== 详细磁盘使用分析 ==="
docker system df -v
echo ""

# 检查Docker运行状态
echo "=== Docker服务状态 ==="
if command -v systemctl &> /dev/null; then
    systemctl status docker --no-pager | head -20
else
    service docker status
fi
echo ""

# Docker事件实时监控
echo "=== Docker事件监控 (Ctrl+C退出) ==="
docker events --since '5m' --until '0s' --format 'table {{.Time}}\t{{.Type}}\t{{.Status}}'
echo ""

# Docker资源使用统计
echo "=== Docker容器资源统计 ==="
docker stats --no-stream --format "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}\t{{.NetIO}}\t{{.BlockIO}}"
echo ""

# Docker配置检查
echo "=== Docker配置文件检查 ==="
if [ -f /etc/docker/daemon.json ]; then
    echo "daemon.json配置:"
    cat /etc/docker/daemon.json | python3 -m json.tool <strong>2</strong>>/dev/null || cat /etc/docker/daemon.json
else
    echo "未找到/etc/docker/daemon.json配置文件"
fi
echo ""

# 检查Docker存储驱动
echo "=== Docker存储驱动 ==="
docker info | grep -A 5 "Storage Driver"
echo ""

# 检查Docker运行时
echo "=== Docker运行时信息 ==="
docker info | grep -A 3 "Runtimes"
echo ""

# Docker CLI和Server API版本兼容性
echo "=== API版本兼容性 ==="
docker version --format '{{.Client.APIVersion}} {{.Server.APIVersion}}'
echo ""

# 执行系统检查
execute_system_check() {
    echo "开始执行Docker系统检查..."
    
    # 检查Docker进程
    echo "1. Docker进程检查:"
    ps aux | grep -E "docker(d| -d)" | grep -v grep
    
    # 检查Docker网络接口
    echo -e "\n2. Docker网络接口:"
    ip link show | grep docker
    
    # 检查Docker日志
    echo -e "\n3. Docker服务日志最后10行:"
    if command -v journalctl &> /dev/null; then
        journalctl -u docker.service -n 10 --no-pager
    else
        tail -10 /var/log/docker.log <strong>2</strong>>/dev/null || echo "Docker日志文件不存在"
    fi
    
    # 检查容器运行状态
    echo -e "\n4. 所有容器状态:"
    docker ps -a --format "table {{.ID}}\t{{.Names}}\t{{.Status}}\t{{.Ports}}\t{{.RunningFor}}"
    
    # 检查镜像存储
    echo -e "\n5. 镜像仓库检查:"
    docker images --format "table {{.Repository}}\t{{.Tag}}\t{{.Size}}\t{{.CreatedSince}}"
    
    # 检查卷使用情况
    echo -e "\n6. 数据卷使用情况:"
    docker volume ls --format "table {{.Name}}\t{{.Driver}}\t{{.Mountpoint}}"
    
    # 检查网络配置
    echo -e "\n7. 网络配置检查:"
    docker network ls --format "table {{.ID}}\t{{.Name}}\t{{.Driver}}\t{{.Scope}}"
    
    # 性能检查
    echo -e "\n8. 性能指标:"
    echo "容器数量: $(docker ps -q | wc -l)"
    echo "镜像数量: $(docker images -q | wc -l)"
    echo "卷数量: $(docker volume ls -q | wc -l)"
    echo "网络数量: $(docker network ls -q | wc -l)"
}

# 运行系统检查
execute_system_check

# 生成诊断报告
generate_diagnostic_report() {
    local report_file="/tmp/docker_diagnostic_$(date +%Y%m%d_%H%M%S).log"
    
    echo "=== Docker诊断报告 ===" > "$report_file"
    echo "生成时间: $(date)" >> "$report_file"
    echo "主机名: $(hostname)" >> "$report_file"
    
    # 收集系统信息
    docker info >> "$report_file"
    echo "" >> "$report_file"
    
    docker system df -v >> "$report_file"
    echo "" >> "$report_file"
    
    # 收集所有容器信息
    echo "=== 所有容器状态 ===" >> "$report_file"
    docker ps -a >> "$report_file"
    echo "" >> "$report_file"
    
    echo "=== 所有镜像 ===" >> "$report_file"
    docker images >> "$report_file"
    echo "" >> "$report_file"
    
    echo "=== 所有网络 ===" >> "$report_file"
    docker network ls >> "$report_file"
    echo "" >> "$report_file"
    
    echo "=== 所有数据卷 ===" >> "$report_file"
    docker volume ls >> "$report_file"
    
    echo "诊断报告已生成: $report_file"
}

# 清理Docker系统资源
cleanup_docker_system() {
    echo "=== Docker系统清理 ==="
    
    read -p "是否清理未使用的容器、镜像、网络？(y/n): " choice
    if [[ "$choice" == "y" ]]; then
        echo "1. 清理未使用的容器:"
        docker container prune -f
        
        echo -e "\n2. 清理未使用的镜像:"
        docker image prune -af
        
        echo -e "\n3. 清理未使用的网络:"
        docker network prune -f
        
        echo -e "\n4. 清理未使用的卷:"
        docker volume prune -f
        
        echo -e "\n5. 清理构建缓存:"
        docker builder prune -af
        
        echo -e "\n清理完成！"
    fi
}

# 主菜单
main_menu() {
    while true; do
        clear
        echo "=== Docker系统管理工具 ==="
        echo "1. 查看系统状态"
        echo "2. 执行完整检查"
        echo "3. 生成诊断报告"
        echo "4. 清理系统资源"
        echo "5. 实时监控事件"
        echo "6. 退出"
        
        read -p "请选择操作 [1-6]: " choice
        
        case $choice in
            1)
                docker system info
                ;;
            2)
                execute_system_check
                ;;
            3)
                generate_diagnostic_report
                ;;
            4)
                cleanup_docker_system
                ;;
            5)
                echo "开始实时事件监控 (Ctrl+C退出)..."
                docker events --format 'table {{.Time}}\t{{.Type}}\t{{.Actor.Attributes.name}}'
                ;;
            6)
                exit 0
                ;;
            *)
                echo "无效选择"
                ;;
        esac
        
        echo -e "\n按回车键继续..."
        read
    done
}

# 如果直接运行脚本，显示菜单
if [[ "${BASH_SOURCE[0]}" == "
<strong>#!/bin/bash</strong>
# docker_system_check.sh - Docker系统检查与诊断脚本
# Docker版本信息
echo "=== Docker版本信息 ==="
docker version
echo ""
# Docker系统信息
echo "=== Docker系统信息 ==="
docker system info
echo ""
# Docker系统磁盘使用
echo "=== Docker磁盘使用 ==="
docker system df
echo ""
# 详细磁盘使用分析
echo "=== 详细磁盘使用分析 ==="
docker system df -v
echo ""
# 检查Docker运行状态
echo "=== Docker服务状态 ==="
if command -v systemctl &> /dev/null; then
systemctl status docker --no-pager | head -20
else
service docker status
fi
echo ""
# Docker事件实时监控
echo "=== Docker事件监控 (Ctrl+C退出) ==="
docker events --since '5m' --until '0s' --format 'table {{.Time}}\t{{.Type}}\t{{.Status}}'
echo ""
# Docker资源使用统计
echo "=== Docker容器资源统计 ==="
docker stats --no-stream --format "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}\t{{.NetIO}}\t{{.BlockIO}}"
echo ""
# Docker配置检查
echo "=== Docker配置文件检查 ==="
if [ -f /etc/docker/daemon.json ]; then
echo "daemon.json配置:"
cat /etc/docker/daemon.json | python3 -m json.tool <strong>2</strong>>/dev/null || cat /etc/docker/daemon.json
else
echo "未找到/etc/docker/daemon.json配置文件"
fi
echo ""
# 检查Docker存储驱动
echo "=== Docker存储驱动 ==="
docker info | grep -A 5 "Storage Driver"
echo ""
# 检查Docker运行时
echo "=== Docker运行时信息 ==="
docker info | grep -A 3 "Runtimes"
echo ""
# Docker CLI和Server API版本兼容性
echo "=== API版本兼容性 ==="
docker version --format '{{.Client.APIVersion}} {{.Server.APIVersion}}'
echo ""
# 执行系统检查
execute_system_check() {
echo "开始执行Docker系统检查..."
# 检查Docker进程
echo "1. Docker进程检查:"
ps aux | grep -E "docker(d| -d)" | grep -v grep
# 检查Docker网络接口
echo -e "\n2. Docker网络接口:"
ip link show | grep docker
# 检查Docker日志
echo -e "\n3. Docker服务日志最后10行:"
if command -v journalctl &> /dev/null; then
journalctl -u docker.service -n 10 --no-pager
else
tail -10 /var/log/docker.log <strong>2</strong>>/dev/null || echo "Docker日志文件不存在"
fi
# 检查容器运行状态
echo -e "\n4. 所有容器状态:"
docker ps -a --format "table {{.ID}}\t{{.Names}}\t{{.Status}}\t{{.Ports}}\t{{.RunningFor}}"
# 检查镜像存储
echo -e "\n5. 镜像仓库检查:"
docker images --format "table {{.Repository}}\t{{.Tag}}\t{{.Size}}\t{{.CreatedSince}}"
# 检查卷使用情况
echo -e "\n6. 数据卷使用情况:"
docker volume ls --format "table {{.Name}}\t{{.Driver}}\t{{.Mountpoint}}"
# 检查网络配置
echo -e "\n7. 网络配置检查:"
docker network ls --format "table {{.ID}}\t{{.Name}}\t{{.Driver}}\t{{.Scope}}"
# 性能检查
echo -e "\n8. 性能指标:"
echo "容器数量: $(docker ps -q | wc -l)"
echo "镜像数量: $(docker images -q | wc -l)"
echo "卷数量: $(docker volume ls -q | wc -l)"
echo "网络数量: $(docker network ls -q | wc -l)"
}
# 运行系统检查
execute_system_check
# 生成诊断报告
generate_diagnostic_report() {
local report_file="/tmp/docker_diagnostic_$(date +%Y%m%d_%H%M%S).log"
echo "=== Docker诊断报告 ===" > "$report_file"
echo "生成时间: $(date)" >> "$report_file"
echo "主机名: $(hostname)" >> "$report_file"
# 收集系统信息
docker info >> "$report_file"
echo "" >> "$report_file"
docker system df -v >> "$report_file"
echo "" >> "$report_file"
# 收集所有容器信息
echo "=== 所有容器状态 ===" >> "$report_file"
docker ps -a >> "$report_file"
echo "" >> "$report_file"
echo "=== 所有镜像 ===" >> "$report_file"
docker images >> "$report_file"
echo "" >> "$report_file"
echo "=== 所有网络 ===" >> "$report_file"
docker network ls >> "$report_file"
echo "" >> "$report_file"
echo "=== 所有数据卷 ===" >> "$report_file"
docker volume ls >> "$report_file"
echo "诊断报告已生成: $report_file"
}
# 清理Docker系统资源
cleanup_docker_system() {
echo "=== Docker系统清理 ==="
read -p "是否清理未使用的容器、镜像、网络？(y/n): " choice
if [[ "$choice" == "y" ]]; then
echo "1. 清理未使用的容器:"
docker container prune -f
echo -e "\n2. 清理未使用的镜像:"
docker image prune -af
echo -e "\n3. 清理未使用的网络:"
docker network prune -f
echo -e "\n4. 清理未使用的卷:"
docker volume prune -f
echo -e "\n5. 清理构建缓存:"
docker builder prune -af
echo -e "\n清理完成！"
fi
}
# 主菜单
main_menu() {
while true; do
clear
echo "=== Docker系统管理工具 ==="
echo "1. 查看系统状态"
echo "2. 执行完整检查"
echo "3. 生成诊断报告"
echo "4. 清理系统资源"
echo "5. 实时监控事件"
echo "6. 退出"
read -p "请选择操作 [1-6]: " choice
case $choice in
1)
docker system info
;;
2)
execute_system_check
;;
3)
generate_diagnostic_report
;;
4)
cleanup_docker_system
;;
5)
echo "开始实时事件监控 (Ctrl+C退出)..."
docker events --format 'table {{.Time}}\t{{.Type}}\t{{.Actor.Attributes.name}}'
;;
6)
exit 0
;;
*)
echo "无效选择"
;;
esac
echo -e "\n按回车键继续..."
read
done
}
# 如果直接运行脚本，显示菜单
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
main_menu
fi
" ]]; then
    main_menu
fi

镜像管理命令大全

镜像的完整生命周期管理

<strong>#!/bin/bash</strong>
# docker_image_manager.sh - Docker镜像全生命周期管理
# 镜像搜索与获取
echo "=== 1. 镜像搜索与获取 ==="
# 从Docker Hub搜索镜像
search_images() {
local keyword=$1
echo "搜索镜像: $keyword"
docker search "$keyword" --format "table {{.Name}}\t{{.Description}}\t{{.StarCount}}\t{{.IsOfficial}}"
}
# 拉取镜像
pull_image() {
local image=$1
echo "拉取镜像: $image"
docker pull "$image"
}
# 示例：搜索和拉取Nginx镜像
echo "搜索Nginx相关镜像:"
search_images "nginx"
echo ""
echo "拉取Nginx官方镜像:"
pull_image "nginx:latest"
echo ""
# 镜像列表与查看
echo "=== 2. 镜像列表与查看 ==="
# 查看所有镜像
list_all_images() {
echo "所有镜像列表:"
docker images --format "table {{.Repository}}\t{{.Tag}}\t{{.ImageID}}\t{{.CreatedSince}}\t{{.Size}}"
}
# 按仓库过滤
filter_by_repo() {
local repo=$1
echo "镜像仓库 '$repo' 中的镜像:"
docker images "$repo" --format "table {{.Tag}}\t{{.ImageID}}\t{{.CreatedSince}}\t{{.Size}}"
}
# 查看镜像详情
inspect_image() {
local image=$1
echo "镜像 $image 的详细信息:"
docker image inspect "$image" --format '{{json .}}' | python3 -m json.tool | head -100
}
# 查看镜像历史
show_image_history() {
local image=$1
echo "镜像 $image 的构建历史:"
docker history "$image" --no-trunc --format "table {{.ID}}\t{{.CreatedSince}}\t{{.Size}}\t{{.Comment}}"
}
# 示例
list_all_images
echo ""
filter_by_repo "nginx"
echo ""
# 镜像标签管理
echo "=== 3. 镜像标签管理 ==="
# 给镜像打标签
tag_image() {
local source=$1
local target=$2
echo "给镜像打标签: $source -> $target"
docker tag "$source" "$target"
}
# 移除镜像标签
untag_image() {
local image=$1
echo "移除镜像标签 (仅删除标签):"
docker rmi "$image"
}
# 示例：创建自定义标签
tag_image "nginx:latest" "myregistry.com/nginx:v1.0"
echo ""
# 镜像构建与提交
echo "=== 4. 镜像构建与提交 ==="
# 构建镜像
build_image() {
local context=$1
local tag=$2
echo "构建镜像: $tag"
docker build -t "$tag" "$context"
}
# 从容器创建镜像
commit_container() {
local container=$1
local image=$2
local message=$3
echo "从容器 $container 创建镜像 $image"
docker commit -m "$message" "$container" "$image"
}
# 构建上下文示例目录
create_build_context() {
mkdir -p /tmp/docker-build
cat > /tmp/docker-build/Dockerfile << 'EOF'
FROM alpine:latest
RUN apk add --no-cache curl wget
CMD ["sh", "-c", "echo 'Hello from custom image'"]
EOF
echo "Dockerfile已创建: /tmp/docker-build/Dockerfile"
}
# 镜像导出与导入
echo "=== 5. 镜像导出与导入 ==="
# 导出镜像为tar文件
export_image() {
local image=$1
local output=$2
echo "导出镜像 $image 到 $output"
docker save -o "$output" "$image"
}
# 从tar文件导入镜像
import_image() {
local input=$1
local name=$2
echo "从 $input 导入镜像为 $name"
docker load -i "$input"
if [ -n "$name" ]; then
docker tag "$(docker images -q | head -1)" "$name"
fi
}
# 镜像清理与优化
echo "=== 6. 镜像清理与优化 ==="
# 删除未使用的镜像
cleanup_unused_images() {
echo "清理未使用的镜像:"
docker image prune -af
}
# 删除指定镜像
remove_image() {
local image=$1
local force=$2
if [ "$force" = "true" ]; then
echo "强制删除镜像: $image"
docker rmi -f "$image"
else
echo "删除镜像: $image"
docker rmi "$image"
fi
}
# 清理悬空镜像
cleanup_dangling_images() {
echo "清理悬空镜像:"
docker images -f "dangling=true" -q | xargs -r docker rmi
}
# 镜像安全检查
echo "=== 7. 镜像安全检查 ==="
# 扫描镜像漏洞
scan_image() {
local image=$1
echo "扫描镜像 $image 的安全漏洞:"
# 使用Docker Security Scan (需要Docker Hub或第三方工具)
if command -v trivy &> /dev/null; then
trivy image "$image"
elif command -v grype &> /dev/null; then
grype "$image"
else
echo "请安装安全扫描工具如 trivy 或 grype"
fi
}
# 检查镜像签名
verify_image_signature() {
local image=$1
echo "检查镜像 $image 的签名:"
docker trust inspect "$image" --pretty
}
# 镜像仓库操作
echo "=== 8. 镜像仓库操作 ==="
# 登录到镜像仓库
login_to_registry() {
local registry=$1
echo "登录到镜像仓库: $registry"
docker login "$registry"
}
# 登出镜像仓库
logout_from_registry() {
local registry=$1
echo "从镜像仓库登出: $registry"
docker logout "$registry"
}
# 推送镜像到仓库
push_to_registry() {
local image=$1
echo "推送镜像到仓库: $image"
docker push "$image"
}
# 从仓库拉取镜像
pull_from_registry() {
local image=$1
echo "从仓库拉取镜像: $image"
docker pull "$image"
}
# 高级镜像操作
echo "=== 9. 高级镜像操作 ==="
# 镜像大小分析
analyze_image_size() {
local image=$1
echo "分析镜像 $image 的各层大小:"
docker history "$image" --format "table {{.ID}}\t{{.Size}}\t{{.CreatedBy}}" --no-trunc
}
# 镜像差异比较
diff_images() {
local image1=$1
local image2=$2
echo "比较镜像 $image1 和 $image2 的差异:"
# 创建临时容器进行比较
local container1=$(docker create "$image1" sh)
local container2=$(docker create "$image2" sh)
echo "镜像1 ($image1) 的文件系统:"
docker export "$container1" | tar -t | sort > /tmp/image1_files.txt
echo "镜像2 ($image2) 的文件系统:"
docker export "$container2" | tar -t | sort > /tmp/image2_files.txt
echo "差异比较:"
diff -u /tmp/image1_files.txt /tmp/image2_files.txt | head -50
# 清理临时容器
docker rm "$container1" "$container2" > /dev/null
}
# 镜像扁平化
flatten_image() {
local source_image=$1
local target_image=$2
echo "扁平化镜像: $source_image -> $target_image"
# 创建临时容器
local container_id=$(docker run -d "$source_image" tail -f /dev/null)
# 导出并重新导入
docker export "$container_id" | docker import - "$target_image"
# 清理临时容器
docker rm -f "$container_id"
}
# 镜像构建缓存管理
manage_build_cache() {
echo "构建缓存管理:"
echo "1. 查看构建缓存:"
docker builder df
echo -e "\n2. 清理构建缓存:"
docker builder prune -af
echo -e "\n3. 查看缓存详细信息:"
docker builder du
}
# 批量镜像操作
batch_image_operations() {
echo "=== 批量镜像操作 ==="
# 批量拉取镜像
batch_pull() {
local images=("$@")
echo "批量拉取镜像:"
for img in "${images[@]}"; do
docker pull "$img" &
done
wait
}
# 批量打标签
batch_tag() {
local prefix=$1
shift
local images=("$@")
echo "批量打标签:"
for img in "${images[@]}"; do
local new_tag="${prefix}/${img##*/}"
docker tag "$img" "$new_tag"
echo "  $img -> $new_tag"
done
}
# 批量推送
batch_push() {
local prefix=$1
shift
local images=("$@")
echo "批量推送镜像:"
for img in "${images[@]}"; do
local new_tag="${prefix}/${img##*/}"
docker push "$new_tag"
done
}
}
# 创建镜像管理菜单
image_management_menu() {
while true; do
clear
echo "=== Docker镜像管理菜单 ==="
echo "1. 搜索镜像"
echo "2. 拉取镜像"
echo "3. 列出镜像"
echo "4. 查看镜像详情"
echo "5. 构建镜像"
echo "6. 打标签"
echo "7. 推送镜像"
echo "8. 清理镜像"
echo "9. 安全扫描"
echo "10. 退出"
read -p "请选择操作 [1-10]: " choice
case $choice in
1)
read -p "请输入搜索关键词: " keyword
search_images "$keyword"
;;
2)
read -p "请输入镜像名称: " image
pull_image "$image"
;;
3)
list_all_images
;;
4)
read -p "请输入镜像名称: " image
inspect_image "$image"
;;
5)
read -p "请输入构建上下文路径: " context
read -p "请输入镜像标签: " tag
build_image "$context" "$tag"
;;
6)
read -p "请输入源镜像: " source
read -p "请输入目标标签: " target
tag_image "$source" "$target"
;;
7)
read -p "请输入要推送的镜像: " image
push_to_registry "$image"
;;
8)
echo "1. 清理未使用镜像"
echo "2. 清理悬空镜像"
read -p "请选择清理类型 [1-2]: " clean_choice
case $clean_choice in
1) cleanup_unused_images ;;
2) cleanup_dangling_images ;;
esac
;;
9)
read -p "请输入要扫描的镜像: " image
scan_image "$image"
;;
10)
exit 0
;;
*)
echo "无效选择"
;;
esac
echo -e "\n按回车键继续..."
read
done
}
# 如果直接运行脚本，显示菜单
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
image_management_menu
fi

容器生命周期管理命令

容器创建、运行与监控

<strong>#!/bin/bash</strong>
# docker_container_lifecycle.sh - 容器全生命周期管理
echo "=== 1. 容器创建与启动 ==="
# 基本运行容器
run_basic_container() {
local image=$1
local name=$2
echo "运行容器: $image (名称: $name)"
docker run -d --name "$name" "$image"
}
# 运行容器并映射端口
run_with_port_mapping() {
local image=$1
local name=$2
local host_port=$3
local container_port=$4
echo "运行容器并映射端口: $host_port:$container_port"
docker run -d --name "$name" -p "$host_port:$container_port" "$image"
}
# 运行容器并挂载数据卷
run_with_volume() {
local image=$1
local name=$2
local host_path=$3
local container_path=$4
echo "运行容器并挂载卷: $host_path:$container_path"
docker run -d --name "$name" -v "$host_path:$container_path" "$image"
}
# 运行容器并设置环境变量
run_with_env() {
local image=$1
local name=$2
local env_key=$3
local env_value=$4
echo "运行容器并设置环境变量: $env_key=$env_value"
docker run -d --name "$name" -e "$env_key=$env_value" "$image"
}
# 运行容器并限制资源
run_with_resource_limits() {
local image=$1
local name=$2
echo "运行容器并限制资源:"
docker run -d --name "$name" \
--cpus="1.0" \
--memory="512m" \
--memory-swap="1g" \
"$image"
}
# 交互式运行容器
run_interactive() {
local image=$1
local name=$2
echo "交互式运行容器:"
docker run -it --name "$name" --rm "$image" sh
}
echo "=== 2. 容器查看与监控 ==="
# 查看运行中的容器
list_running_containers() {
echo "运行中的容器:"
docker ps --format "table {{.ID}}\t{{.Names}}\t{{.Image}}\t{{.Status}}\t{{.Ports}}\t{{.RunningFor}}"
}
# 查看所有容器（包括停止的）
list_all_containers() {
echo "所有容器:"
docker ps -a --format "table {{.ID}}\t{{.Names}}\t{{.Image}}\t{{.Status}}\t{{.Ports}}\t{{.CreatedAt}}"
}
# 查看容器详情
inspect_container() {
local container=$1
echo "容器 $container 的详细信息:"
docker inspect "$container" --format '{{json .}}' | python3 -m json.tool | head -200
}
# 查看容器日志
view_container_logs() {
local container=$1
local lines=$2
echo "容器 $container 的日志 (最后${lines:-10}行):"
docker logs --tail "${lines:-10}" "$container"
}
# 实时查看容器日志
follow_container_logs() {
local container=$1
echo "实时查看容器 $container 的日志 (Ctrl+C退出):"
docker logs -f "$container"
}
# 查看容器进程
view_container_processes() {
local container=$1
echo "容器 $container 中的进程:"
docker top "$container"
}
# 查看容器资源使用
view_container_stats() {
echo "容器资源使用统计 (实时更新，Ctrl+C退出):"
docker stats --format "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}\t{{.MemPerc}}\t{{.NetIO}}\t{{.BlockIO}}\t{{.PIDs}}"
}
echo "=== 3. 容器控制命令 ==="
# 启动容器
start_container() {
local container=$1
echo "启动容器: $container"
docker start "$container"
}
# 停止容器
stop_container() {
local container=$1
echo "停止容器: $container"
docker stop "$container"
}
# 重启容器
restart_container() {
local container=$1
echo "重启容器: $container"
docker restart "$container"
}
# 暂停容器
pause_container() {
local container=$1
echo "暂停容器: $container"
docker pause "$container"
}
# 恢复容器
unpause_container() {
local container=$1
echo "恢复容器: $container"
docker unpause "$container"
}
# 杀死容器
kill_container() {
local container=$1
local signal=${2:-SIGKILL}
echo "杀死容器 $container (信号: $signal)"
docker kill --signal "$signal" "$container"
}
echo "=== 4. 容器交互与调试 ==="
# 进入容器
exec_into_container() {
local container=$1
local shell=${2:-/bin/bash}
echo "进入容器 $container:"
docker exec -it "$container" "$shell"
}
# 在容器中执行命令
exec_command_in_container() {
local container=$1
shift
local cmd="$*"
echo "在容器 $container 中执行命令: $cmd"
docker exec "$container" sh -c "$cmd"
}
# 复制文件到容器
copy_to_container() {
local src=$1
local container=$2
local dest=$3
echo "复制文件到容器: $src -> $container:$dest"
docker cp "$src" "$container:$dest"
}
# 从容器复制文件
copy_from_container() {
local container=$1
local src=$2
local dest=$3
echo "从容器复制文件: $container:$src -> $dest"
docker cp "$container:$src" "$dest"
}
# 容器端口检查
check_container_ports() {
local container=$1
echo "容器 $container 的端口映射:"
docker port "$container"
}
echo "=== 5. 容器更新与配置 ==="
# 更新容器配置
update_container() {
local container=$1
echo "更新容器配置:"
# 更新资源限制
docker update --cpus="2.0" --memory="1g" "$container"
# 更新重启策略
docker update --restart=unless-stopped "$container"
}
# 重命名容器
rename_container() {
local old_name=$1
local new_name=$2
echo "重命名容器: $old_name -> $new_name"
docker rename "$old_name" "$new_name"
}
# 提交容器为镜像
commit_container_to_image() {
local container=$1
local image_name=$2
local message=${3:-"Created from container $container"}
echo "提交容器为镜像: $container -> $image_name"
docker commit -m "$message" "$container" "$image_name"
}
echo "=== 6. 容器删除与清理 ==="
# 删除容器
remove_container() {
local container=$1
local force=${2:-false}
if [ "$force" = true ]; then
echo "强制删除容器: $container"
docker rm -f "$container"
else
echo "删除容器: $container"
docker rm "$container"
fi
}
# 清理停止的容器
cleanup_stopped_containers() {
echo "清理所有停止的容器:"
docker container prune -f
}
# 清理所有容器（危险！）
cleanup_all_containers() {
echo "警告：这将删除所有容器！"
read -p "确认要删除所有容器吗？(yes/no): " confirm
if [ "$confirm" = "yes" ]; then
echo "停止所有容器..."
docker stop $(docker ps -aq)
echo "删除所有容器..."
docker rm $(docker ps -aq)
echo "所有容器已删除"
fi
}
echo "=== 7. 容器健康检查 ==="
# 创建带健康检查的容器
create_with_healthcheck() {
local image=$1
local name=$2
echo "创建带健康检查的容器:"
docker run -d \
--name "$name" \
--health-cmd="curl -f http://localhost/ || exit 1" \
--health-interval=30s \
--health-timeout=10s \
--health-retries=3 \
--health-start-period=40s \
"$image"
}
# 检查容器健康状态
check_container_health() {
local container=$1
echo "容器 $container 的健康状态:"
docker inspect --format='{{json .State.Health}}' "$container" | python3 -m json.tool
}
echo "=== 8. 容器网络配置 ==="
# 连接容器到网络
connect_to_network() {
local container=$1
local network=$2
echo "连接容器 $container 到网络 $network"
docker network connect "$network" "$container"
}
# 断开容器网络连接
disconnect_from_network() {
local container=$1
local network=$2
echo "断开容器 $container 与网络 $network 的连接"
docker network disconnect "$network" "$container"
}
# 查看容器网络配置
view_container_networks() {
local container=$1
echo "容器 $container 的网络配置:"
docker inspect --format='{{json .NetworkSettings.Networks}}' "$container" | python3 -m json.tool
}
echo "=== 9. 容器存储管理 ==="
# 查看容器数据卷
view_container_volumes() {
local container=$1
echo "容器 $container 的数据卷挂载:"
docker inspect --format='{{json .Mounts}}' "$container" | python3 -m json.tool
}
# 创建数据卷容器
create_volume_container() {
local name=$1
local image="alpine:latest"
echo "创建数据卷容器: $name"
docker create \
--name "$name" \
-v /data \
"$image" \
/bin/true
}
echo "=== 10. 高级容器操作 ==="
# 容器导出与导入
export_container() {
local container=$1
local output=$2
echo "导出容器 $container 到文件 $output"
docker export "$container" > "$output"
}
import_from_tar() {
local tar_file=$1
local image_name=$2
echo "从tar文件导入容器: $tar_file -> $image_name"
docker import "$tar_file" "$image_name"
}
# 容器检查点（实验性功能）
checkpoint_container() {
local container=$1
local checkpoint_name=$2
if docker --version | grep -q "experimental"; then
echo "创建容器检查点: $container -> $checkpoint_name"
docker checkpoint create "$container" "$checkpoint_name"
else
echo "需要启用Docker实验性功能"
fi
}
# 容器资源使用分析
analyze_container_resources() {
local container=$1
echo "容器 $container 资源分析:"
echo "1. CPU使用情况:"
docker stats "$container" --no-stream --format "{{.CPUPerc}}"
echo -e "\n2. 内存使用情况:"
docker stats "$container" --no-stream --format "{{.MemUsage}}"
echo -e "\n3. 进程数量:"
docker top "$container" | wc -l
echo -e "\n4. 网络连接:"
docker exec "$container" sh -c "ss -tunp" <strong>2</strong>>/dev/null || echo "无法获取网络信息"
}
# 批量容器操作
batch_container_operations() {
echo "=== 批量容器操作 ==="
# 批量启动
batch_start() {
echo "批量启动所有停止的容器:"
docker ps -a --filter "status=exited" --format "{{.Names}}" | xargs -r docker start
}
# 批量停止
batch_stop() {
echo "批量停止所有运行中的容器:"
docker ps -q | xargs -r docker stop
}
# 批量删除
batch_remove() {
echo "批量删除所有停止的容器:"
docker ps -a --filter "status=exited" -q | xargs -r docker rm
}
# 批量执行命令
batch_exec() {
local cmd=$1
echo "在所有运行中的容器中执行命令: $cmd"
for container in $(docker ps -q); do
echo "容器: $(docker inspect --format='{{.Name}}' "$container")"
docker exec "$container" sh -c "$cmd" <strong>2</strong>>/dev/null && echo "成功" || echo "失败"
echo ""
done
}
}
# 容器管理菜单
container_management_menu() {
while true; do
clear
echo "=== Docker容器生命周期管理 ==="
echo "1. 运行新容器"
echo "2. 查看容器列表"
echo "3. 查看容器日志"
echo "4. 进入容器"
echo "5. 启动/停止容器"
echo "6. 删除容器"
echo "7. 容器健康检查"
echo "8. 容器资源监控"
echo "9. 批量操作"
echo "10. 退出"
read -p "请选择操作 [1-10]: " choice
case $choice in
1)
read -p "请输入镜像名称: " image
read -p "请输入容器名称: " name
run_basic_container "$image" "$name"
;;
2)
echo "1. 仅运行中的容器"
echo "2. 所有容器"
read -p "请选择 [1-2]: " list_choice
case $list_choice in
1) list_running_containers ;;
2) list_all_containers ;;
esac
;;
3)
read -p "请输入容器名称: " container
view_container_logs "$container" 20
;;
4)
read -p "请输入容器名称: " container
exec_into_container "$container"
;;
5)
read -p "请输入容器名称: " container
echo "1. 启动容器"
echo "2. 停止容器"
echo "3. 重启容器"
read -p "请选择 [1-3]: " control_choice
case $control_choice in
1) start_container "$container" ;;
2) stop_container "$container" ;;
3) restart_container "$container" ;;
esac
;;
6)
read -p "请输入容器名称: " container
remove_container "$container"
;;
7)
read -p "请输入容器名称: " container
check_container_health "$container"
;;
8)
view_container_stats
;;
9)
echo "1. 批量启动"
echo "2. 批量停止"
echo "3. 批量删除"
read -p "请选择 [1-3]: " batch_choice
case $batch_choice in
1) batch_start ;;
2) batch_stop ;;
3) batch_remove ;;
esac
;;
10)
exit 0
;;
*)
echo "无效选择"
;;
esac
echo -e "\n按回车键继续..."
read
done
}
# 如果直接运行脚本，显示菜单
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
container_management_menu
fi

Docker网络命令大全

<strong>#!/bin/bash</strong>
# docker_network_commands.sh - Docker网络管理完全指南
echo "=== Docker网络管理命令大全 ==="
# 1. 网络列表与查看
echo "=== 1. 网络列表与查看 ==="
list_all_networks() {
echo "所有Docker网络:"
docker network ls --format "table {{.ID}}\t{{.Name}}\t{{.Driver}}\t{{.Scope}}\t{{.IPv6}}"
}
inspect_network() {
local network=$1
echo "网络 $network 的详细信息:"
docker network inspect "$network" --format '{{json .}}' | python3 -m json.tool
}
show_network_drivers() {
echo "可用网络驱动:"
echo "1. bridge    - 默认桥接网络 (默认)"
echo "2. host      - 直接使用主机网络"
echo "3. overlay   - 多主机网络 (用于Swarm)"
echo "4. macvlan   - MAC地址虚拟网络"
echo "5. ipvlan    - IP地址虚拟网络"
echo "6. none      - 无网络"
}
# 2. 网络创建与管理
echo "=== 2. 网络创建与管理 ==="
create_bridge_network() {
local name=$1
local subnet=${2:-"172.20.0.0/16"}
local gateway=${3:-"172.20.0.1"}
echo "创建桥接网络: $name"
docker network create \
--driver bridge \
--subnet "$subnet" \
--gateway "$gateway" \
"$name"
}
create_overlay_network() {
local name=$1
echo "创建Overlay网络 (需要Swarm模式):"
docker network create \
--driver overlay \
"$name"
}
create_macvlan_network() {
local name=$1
local parent_interface=$2
local subnet=$3
echo "创建Macvlan网络:"
docker network create \
--driver macvlan \
--subnet "$subnet" \
-o parent="$parent_interface" \
"$name"
}
create_ipvlan_network() {
local name=$1
local mode=${2:-"l2"}
local subnet=$3
echo "创建IPvlan网络 (模式: $mode):"
docker network create \
--driver ipvlan \
--subnet "$subnet" \
-o ipvlan_mode="$mode" \
"$name"
}
# 3. 网络连接与断开
echo "=== 3. 网络连接与断开 ==="
connect_container_to_network() {
local container=$1
local network=$2
local ip=${3:-""}
echo "连接容器 $container 到网络 $network"
if [ -n "$ip" ]; then
docker network connect --ip "$ip" "$network" "$container"
else
docker network connect "$network" "$container"
fi
}
disconnect_container_from_network() {
local container=$1
local network=$2
echo "断开容器 $container 与网络 $network 的连接"
docker network disconnect "$network" "$container"
}
list_container_networks() {
local container=$1
echo "容器 $container 连接的网络:"
docker inspect "$container" --format '{{range .NetworkSettings.Networks}}{{.NetworkID}} {{end}}' | \
xargs -n 1 docker network inspect --format '{{.Name}}' <strong>2</strong>>/dev/null
}
# 4. 网络配置与参数
echo "=== 4. 网络配置与参数 ==="
configure_network_options() {
local network=$1
echo "配置网络参数:"
# 为现有网络添加选项（需要删除重建）
echo "当前网络选项:"
docker network inspect "$network" --format '{{json .Options}}' | python3 -m json.tool
}
set_network_labels() {
local network=$1
local key=$2
local value=$3
echo "为网络 $network 设置标签: $key=$value"
# 注：网络标签在创建时设置，无法直接修改
echo "标签只能在创建网络时设置"
}
# 5. 网络隔离与安全
echo "=== 5. 网络隔离与安全 ==="
create_internal_network() {
local name=$1
echo "创建内部网络 (仅容器间通信):"
docker network create \
--driver bridge \
--internal \
"$name"
}
enable_ipv6_on_network() {
local network=$1
local subnet_v6=$2
echo "为网络 $network 启用IPv6:"
docker network create \
--ipv6 \
--subnet "$subnet_v6" \
"$network"
}
# 6. 网络诊断与故障排除
echo "=== 6. 网络诊断与故障排除 ==="
diagnose_network_connectivity() {
local container=$1
local target=$2
echo "诊断网络连通性: $container -> $target"
# 检查DNS解析
echo "1. DNS解析测试:"
docker exec "$container" nslookup "$target" <strong>2</strong>>/dev/null || \
docker exec "$container" ping -c 1 "$target" <strong>2</strong>>/dev/null
# 检查网络路由
echo -e "\n2. 网络路由检查:"
docker exec "$container" ip route <strong>2</strong>>/dev/null
# 检查网络接口
echo -e "\n3. 网络接口状态:"
docker exec "$container" ip addr show <strong>2</strong>>/dev/null
# 测试端口连通性
echo -e "\n4. 端口连通性测试:"
if [[ "$target" =~ : ]]; then
local host=$(echo "$target" | cut -d: -f1)
local port=$(echo "$target" | cut -d: -f2)
docker exec "$container" sh -c "nc -zv $host $port 2>&1 || echo '连接失败'"
fi
}
check_network_iptables() {
local network=$1
echo "检查网络 $network 的iptables规则:"
# 查看Docker相关的iptables规则
iptables -L -n | grep -i docker
echo ""
iptables -t nat -L -n | grep -i docker
}
trace_network_packet() {
local container=$1
local target=$2
echo "跟踪网络数据包 (需要容器内有tcpdump):"
# 安装tcpdump（如果不存在）
docker exec "$container" sh -c "which tcpdump || (apk add tcpdump 2>/dev/null || apt-get update && apt-get install -y tcpdump 2>/dev/null || yum install -y tcpdump 2>/dev/null)" >/dev/null <strong>2</strong>><strong>&1</strong>
echo "开始抓包 (10秒后停止)..."
docker exec "$container" timeout 10 tcpdump -i any -n host "$target" <strong>2</strong>>/dev/null || \
echo "抓包失败，可能需要手动安装tcpdump"
}
# 7. 高级网络功能
echo "=== 7. 高级网络功能 ==="
create_network_with_dns() {
local name=$1
local dns_server=$2
echo "创建带自定义DNS的网络:"
docker network create \
--driver bridge \
--dns "$dns_server" \
"$name"
}
configure_network_mtu() {
local network=$1
local mtu=$2
echo "配置网络MTU: $mtu"
# 注：MTU需要在创建网络时设置
echo "MTU需要在创建网络时使用 -o com.docker.network.driver.mtu=$mtu 参数设置"
}
setup_network_aliases() {
local container=$1
local network=$2
local alias=$3
echo "为容器设置网络别名:"
docker network connect \
--alias "$alias" \
"$network" \
"$container"
}
# 8. Swarm集群网络
echo "=== 8. Swarm集群网络 ==="
create_swarm_overlay_network() {
local name=$1
echo "创建Swarm Overlay网络:"
# 需要初始化Swarm模式
if docker node ls >/dev/null <strong>2</strong>><strong>&1</strong>; then
docker network create \
--driver overlay \
--attachable \
"$name"
else
echo "需要先初始化Swarm模式: docker swarm init"
fi
}
create_ingress_network() {
echo "创建Ingress网络 (Swarm模式):"
# Ingress网络是Swarm自动创建的，用于负载均衡
echo "Ingress网络由Swarm自动管理"
}
# 9. 网络清理与维护
echo "=== 9. 网络清理与维护 ==="
prune_unused_networks() {
echo "清理未使用的网络:"
docker network prune -f
}
remove_network() {
local network=$1
echo "删除网络: $network"
docker network rm "$network"
}
backup_network_config() {
local output_file=${1:-"/tmp/docker_networks_backup_$(date +%Y%m%d).sh"}
echo "备份网络配置到: $output_file"
cat > "$output_file" << 'EOF'
#!/bin/bash
# Docker网络配置备份与恢复脚本
# 生成时间: $(date)
echo "正在恢复Docker网络配置..."
EOF
# 获取所有网络并生成创建命令
docker network ls --format "{{.Name}}" | grep -v "bridge\|host\|none" | while read network; do
echo "# 恢复网络: $network" >> "$output_file"
# 获取网络配置信息
local driver=$(docker network inspect "$network" --format '{{.Driver}}')
local subnet=$(docker network inspect "$network" --format '{{range .IPAM.Config}}{{.Subnet}}{{end}}')
local gateway=$(docker network inspect "$network" --format '{{range .IPAM.Config}}{{.Gateway}}{{end}}')
echo "docker network create \\" >> "$output_file"
echo "  --driver $driver \\" >> "$output_file"
if [ -n "$subnet" ] && [ "$subnet" != "<no value>" ]; then
echo "  --subnet $subnet \\" >> "$output_file"
fi
if [ -n "$gateway" ] && [ "$gateway" != "<no value>" ]; then
echo "  --gateway $gateway \\" >> "$output_file"
fi
echo "  $network" >> "$output_file"
echo "" >> "$output_file"
done
echo "echo '网络配置恢复完成'" >> "$output_file"
chmod +x "$output_file"
echo "备份脚本已生成，可执行该脚本恢复网络配置"
}
# 10. 网络性能测试
echo "=== 10. 网络性能测试 ==="
test_network_bandwidth() {
local container1=$1
local container2=$2
echo "测试容器间网络带宽:"
# 在容器2中启动iperf3服务器
echo "在容器 $container2 中启动iperf3服务器..."
docker exec -d "$container2" iperf3 -s
# 等待服务器启动
sleep 2
# 在容器1中运行iperf3客户端
local container2_ip=$(docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' "$container2")
echo "从容器 $container1 测试到 $container2 ($container2_ip)..."
docker exec "$container1" iperf3 -c "$container2_ip"
# 停止iperf3服务器
docker exec "$container2" pkill iperf3
}
test_network_latency() {
local container=$1
local target=$2
local count=${3:-10}
echo "测试网络延迟: $container -> $target"
docker exec "$container" ping -c "$count" "$target"
}
# 网络管理菜单
network_management_menu() {
while true; do
clear
echo "=== Docker网络管理菜单 ==="
echo "1. 列出所有网络"
echo "2. 创建新网络"
echo "3. 连接容器到网络"
echo "4. 网络诊断"
echo "5. 清理未使用网络"
echo "6. 备份网络配置"
echo "7. 网络性能测试"
echo "8. 退出"
read -p "请选择操作 [1-8]: " choice
case $choice in
1)
list_all_networks
;;
2)
echo "选择网络驱动:"
echo "1. bridge (桥接)"
echo "2. overlay (覆盖)"
echo "3. macvlan (MAC虚拟)"
echo "4. ipvlan (IP虚拟)"
read -p "请选择 [1-4]: " driver_choice
read -p "请输入网络名称: " network_name
case $driver_choice in
1)
read -p "子网地址 [172.20.0.0/16]: " subnet
read -p "网关地址 [172.20.0.1]: " gateway
create_bridge_network "$network_name" "${subnet:-172.20.0.0/16}" "${gateway:-172.20.0.1}"
;;
2)
create_overlay_network "$network_name"
;;
3)
read -p "请输入父接口 [eth0]: " parent
read -p "请输入子网地址: " subnet
create_macvlan_network "$network_name" "${parent:-eth0}" "$subnet"
;;
4)
read -p "请输入模式 [l2|l3]: " mode
read -p "请输入子网地址: " subnet
create_ipvlan_network "$network_name" "${mode:-l2}" "$subnet"
;;
esac
;;
3)
read -p "请输入容器名称: " container
read -p "请输入网络名称: " network
connect_container_to_network "$container" "$network"
;;
4)
read -p "请输入容器名称: " container
read -p "请输入目标地址: " target
diagnose_network_connectivity "$container" "$target"
;;
5)
prune_unused_networks
;;
6)
backup_network_config
;;
7)
read -p "请输入源容器: " container1
read -p "请输入目标容器: " container2
test_network_bandwidth "$container1" "$container2"
;;
8)
exit 0
;;
*)
echo "无效选择"
;;
esac
echo -e "\n按回车键继续..."
read
done
}
# 如果直接运行脚本，显示菜单
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
network_management_menu
fi

Docker Compose命令大全

<strong>#!/bin/bash</strong>
# docker_compose_commands.sh - Docker Compose完整命令指南
echo "=== Docker Compose命令大全 ==="
# 检查Docker Compose版本
check_compose_version() {
echo "=== Docker Compose版本信息 ==="
if command -v docker-compose &> /dev/null; then
docker-compose version
elif docker compose version &> /dev/null; then
docker compose version
else
echo "Docker Compose未安装"
fi
}
# 基础命令
echo "=== 1. 基础命令 ==="
# 启动服务
compose_up() {
local file=${1:-"docker-compose.yml"}
echo "启动Compose服务 (使用: $file)"
if command -v docker-compose &> /dev/null; then
docker-compose -f "$file" up -d
else
docker compose -f "$file" up -d
fi
}
# 停止服务
compose_down() {
local file=${1:-"docker-compose.yml"}
echo "停止Compose服务 (使用: $file)"
if command -v docker-compose &> /dev/null; then
docker-compose -f "$file" down
else
docker compose -f "$file" down
fi
}
# 重启服务
compose_restart() {
local file=${1:-"docker-compose.yml"}
echo "重启Compose服务 (使用: $file)"
if command -v docker-compose &> /dev/null; then
docker-compose -f "$file" restart
else
docker compose -f "$file" restart
fi
}
# 查看服务状态
compose_ps() {
local file=${1:-"docker-compose.yml"}
echo "查看Compose服务状态 (使用: $file)"
if command -v docker-compose &> /dev/null; then
docker-compose -f "$file" ps
else
docker compose -f "$file" ps
fi
}
# 查看服务日志
compose_logs() {
local service=$1
local file=${2:-"docker-compose.yml"}
echo "查看服务日志: $service (使用: $file)"
if command -v docker-compose &> /dev/null; then
if [ -n "$service" ]; then
docker-compose -f "$file" logs -f "$service"
else
docker-compose -f "$file" logs -f
fi
else
if [ -n "$service" ]; then
docker compose -f "$file" logs -f "$service"
else
docker compose -f "$file" logs -f
fi
fi
}
# 高级命令
echo "=== 2. 高级命令 ==="
# 构建镜像
compose_build() {
local file=${1:-"docker-compose.yml"}
echo "构建Compose服务镜像 (使用: $file)"
if command -v docker-compose &> /dev/null; then
docker-compose -f "$file" build --no-cache
else
docker compose -f "$file" build --no-cache
fi
}
# 拉取镜像
compose_pull() {
local file=${1:-"docker-compose.yml"}
echo "拉取Compose服务镜像 (使用: $file)"
if command -v docker-compose &> /dev/null; then
docker-compose -f "$file" pull
else
docker compose -f "$file" pull
fi
}
# 执行命令
compose_exec() {
local service=$1
local command=$2
local file=${3:-"docker-compose.yml"}
echo "在服务 $service 中执行命令: $command (使用: $file)"
if command -v docker-compose &> /dev/null; then
docker-compose -f "$file" exec "$service" sh -c "$command"
else
docker compose -f "$file" exec "$service" sh -c "$command"
fi
}
# 进入容器
compose_run_interactive() {
local service=$1
local file=${2:-"docker-compose.yml"}
echo "以交互模式运行服务: $service (使用: $file)"
if command -v docker-compose &> /dev/null; then
docker-compose -f "$file" run --rm "$service" sh
else
docker compose -f "$file" run --rm "$service" sh
fi
}
# 查看配置
compose_config() {
local file=${1:-"docker-compose.yml"}
echo "查看Compose配置 (使用: $file)"
if command -v docker-compose &> /dev/null; then
docker-compose -f "$file" config
else
docker compose -f "$file" config
fi
}
# 验证配置
compose_validate() {
local file=${1:-"docker-compose.yml"}
echo "验证Compose配置文件 (使用: $file)"
if command -v docker-compose &> /dev/null; then
docker-compose -f "$file" config -q
if [ $? -eq 0 ]; then
echo "配置文件有效"
else
echo "配置文件有误"
fi
else
docker compose -f "$file" config -q
if [ $? -eq 0 ]; then
echo "配置文件有效"
else
echo "配置文件有误"
fi
fi
}
# 扩展命令
echo "=== 3. 扩展命令 ==="
# 扩展服务
compose_up_with_scale() {
local service=$1
local replicas=$2
local file=${3:-"docker-compose.yml"}
echo "扩展服务 $service 到 $replicas 个实例 (使用: $file)"
if command -v docker-compose &> /dev/null; then
docker-compose -f "$file" up -d --scale "$service=$replicas"
else
docker compose -f "$file" up -d --scale "$service=$replicas"
fi
}
# 创建配置文件模板
create_compose_template() {
local file=${1:-"docker-compose.yml"}
echo "创建Docker Compose模板: $file"
cat > "$file" << 'EOF'
version: '3.8'
services:
web:
image: nginx:latest
container_name: nginx-web
ports:
- "80:80"
- "443:443"
volumes:
- ./html:/usr/share/nginx/html
- ./nginx.conf:/etc/nginx/nginx.conf
networks:
- frontend
restart: unless-stopped
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost"]
interval: 30s
timeout: 10s
retries: 3
depends_on:
- app
app:
image: node:14-alpine
container_name: node-app
working_dir: /app
volumes:
- ./app:/app
environment:
- NODE_ENV=production
- DATABASE_URL=postgres://user:pass@db:5432/app
networks:
- frontend
- backend
command: npm start
restart: unless-stopped
db:
image: postgres:13-alpine
container_name: postgres-db
environment:
POSTGRES_USER: user
POSTGRES_PASSWORD: pass
POSTGRES_DB: app
volumes:
- db_data:/var/lib/postgresql/data
networks:
- backend
restart: unless-stopped
redis:
image: redis:6-alpine
container_name: redis-cache
command: redis-server --appendonly yes
volumes:
- redis_data:/data
networks:
- backend
restart: unless-stopped
networks:
frontend:
driver: bridge
backend:
driver: bridge
volumes:
db_data:
driver: local
redis_data:
driver: local
EOF
echo "Compose模板已创建: $file"
# 创建相关目录和文件
mkdir -p html app
echo "<h1>Welcome to Docker Compose!</h1>" > html/index.html
cat > app/package.json << 'EOF'
{
"name": "docker-compose-demo",
"version": "1.0.0",
"description": "Demo application for Docker Compose",
"main": "index.js",
"scripts": {
"start": "node index.js"
},
"dependencies": {
"express": "^4.17.1"
}
}
EOF
cat > app/index.js << 'EOF'
const express = require('express');
const app = express();
const port = 3000;
app.get('/', (req, res) => {
res.send('Hello from Docker Compose!');
});
app.listen(port, () => {
console.log(`App listening at http://localhost:${port}`);
});
EOF
echo "示例应用文件已创建"
}
# Compose项目操作
echo "=== 4. Compose项目操作 ==="
# 查看项目列表
compose_project_list() {
echo "查看Docker Compose项目:"
if command -v docker-compose &> /dev/null; then
docker-compose ls
else
docker compose ls
fi
}
# 停止指定项目
compose_project_down() {
local project=$1
echo "停止Compose项目: $project"
if command -v docker-compose &> /dev/null; then
docker-compose -p "$project" down
else
docker compose -p "$project" down
fi
}
# 查看项目配置
compose_project_config() {
local project=$1
local file=${2:-"docker-compose.yml"}
echo "查看项目 $project 的配置 (使用: $file)"
if command -v docker-compose &> /dev/null; then
docker-compose -p "$project" -f "$file" config
else
docker compose -p "$project" -f "$file" config
fi
}
# 调试命令
echo "=== 5. 调试命令 ==="
# 以调试模式启动
compose_up_debug() {
local file=${1:-"docker-compose.yml"}
echo "以调试模式启动 (使用: $file)"
if command -v docker-compose &> /dev/null; then
docker-compose -f "$file" up
else
docker compose -f "$file" up
fi
}
# 查看服务进程
compose_top() {
local file=${1:-"docker-compose.yml"}
echo "查看服务进程 (使用: $file)"
if command -v docker-compose &> /dev/null; then
docker-compose -f "$file" top
else
docker compose -f "$file" top
fi
}
# 查看服务端口
compose_port() {
local service=$1
local port=$2
local file=${3:-"docker-compose.yml"}
echo "查看服务端口映射: $service:$port (使用: $file)"
if command -v docker-compose &> /dev/null; then
docker-compose -f "$file" port "$service" "$port"
else
docker compose -f "$file" port "$service" "$port"
fi
}
# 批量操作
echo "=== 6. 批量操作 ==="
# 批量启动项目
compose_batch_up() {
local compose_files=("$@")
echo "批量启动多个Compose项目"
for file in "${compose_files[@]}"; do
echo "启动项目: $file"
compose_up "$file"
sleep 2
done
}
# 批量停止项目
compose_batch_down() {
local compose_files=("$@")
echo "批量停止多个Compose项目"
for file in "${compose_files[@]}"; do
echo "停止项目: $file"
compose_down "$file"
sleep 2
done
}
# Compose版本迁移
echo "=== 7. Compose版本迁移 ==="
# 从v2迁移到v3
migrate_compose_v2_to_v3() {
local input_file=$1
local output_file=${2:-"docker-compose-v3.yml"}
echo "迁移Compose文件从v2到v3: $input_file -> $output_file"
# 简单的迁移示例（实际可能需要更复杂的转换）
sed -e 's/version: ["'\'']2["'\'']/version: "3.8"/g' \
-e 's/links:/# links: # 已废弃/g' \
-e 's/  - \(.*\)/#  - \1/g' \
"$input_file" > "$output_file"
echo "迁移完成，请检查文件: $output_file"
echo "注意：这只是一个基本迁移，可能需要手动调整"
}
# 环境变量支持
echo "=== 8. 环境变量支持 ==="
# 使用环境变量文件
compose_up_with_env() {
local env_file=${1:-".env"}
local compose_file=${2:-"docker-compose.yml"}
echo "使用环境变量文件启动: $env_file (使用: $compose_file)"
# 创建示例环境文件
if [ ! -f "$env_file" ]; then
cat > "$env_file" << 'EOF'
# Docker Compose环境变量
COMPOSE_PROJECT_NAME=myapp
NGINX_PORT=8080
POSTGRES_PASSWORD=secretpassword
REDIS_PASSWORD=redispass
EOF
echo "已创建环境变量文件: $env_file"
fi
if command -v docker-compose &> /dev/null; then
docker-compose --env-file "$env_file" -f "$compose_file" up -d
else
docker compose --env-file "$env_file" -f "$compose_file" up -d
fi
}
# 创建环境文件模板
create_env_template() {
local file=${1:-".env"}
cat > "$file" << 'EOF'
# Docker Compose环境变量配置
# 项目设置
COMPOSE_PROJECT_NAME=myproject
COMPOSE_PROJECT_ENV=development
# 服务端口
WEB_PORT=80
WEB_SSL_PORT=443
API_PORT=3000
DB_PORT=5432
REDIS_PORT=6379
# 数据库配置
POSTGRES_USER=postgres
POSTGRES_PASSWORD=changeme
POSTGRES_DB=appdb
POSTGRES_PORT=5432
# Redis配置
REDIS_PASSWORD=redispass
# 应用配置
APP_ENV=development
APP_DEBUG=true
APP_KEY=base64:randomkey
# 外部服务
EXTERNAL_API_URL=https://api.example.com
EXTERNAL_API_KEY=yourapikey
# 文件路径
LOG_PATH=./logs
DATA_PATH=./data
CONFIG_PATH=./config
# 网络配置
NETWORK_SUBNET=172.20.0.0/16
NETWORK_GATEWAY=172.20.0.1
# 资源限制
MEMORY_LIMIT=512m
CPU_LIMIT=1.0
EOF
echo "环境变量模板已创建: $file"
echo "请根据实际情况修改配置值"
}
# Compose健康检查
echo "=== 9. Compose健康检查 ==="
# 检查服务健康状态
compose_healthcheck() {
local file=${1:-"docker-compose.yml"}
echo "检查Compose服务健康状态 (使用: $file)"
# 获取所有服务
if command -v docker-compose &> /dev/null; then
local services=$(docker-compose -f "$file" ps --services)
else
local services=$(docker compose -f "$file" ps --services)
fi
for service in $services; do
echo "检查服务: $service"
# 获取容器ID
if command -v docker-compose &> /dev/null; then
local container_id=$(docker-compose -f "$file" ps -q "$service")
else
local container_id=$(docker compose -f "$file" ps -q "$service")
fi
if [ -n "$container_id" ]; then
# 检查健康状态
local health_status=$(docker inspect --format='{{.State.Health.Status}}' "$container_id" <strong>2</strong>>/dev/null || echo "no healthcheck")
echo "  健康状态: $health_status"
if [ "$health_status" = "unhealthy" ]; then
echo "  警告: 服务 $service 健康状态异常"
fi
else
echo "  服务未运行"
fi
done
}
# Compose性能监控
compose_monitor() {
local file=${1:-"docker-compose.yml"}
echo "监控Compose服务性能 (Ctrl+C退出) (使用: $file)"
while true; do
clear
echo "=== Docker Compose服务监控 ==="
echo "时间: $(date)"
echo ""
if command -v docker-compose &> /dev/null; then
docker-compose -f "$file" ps
echo ""
docker-compose -f "$file" top
else
docker compose -f "$file" ps
echo ""
docker compose -f "$file" top
fi
sleep 5
done
}
# Compose管理菜单
compose_management_menu() {
while true; do
clear
echo "=== Docker Compose管理菜单 ==="
echo "1. 创建Compose模板"
echo "2. 启动服务"
echo "3. 停止服务"
echo "4. 查看服务状态"
echo "5. 查看服务日志"
echo "6. 进入容器"
echo "7. 健康检查"
echo "8. 性能监控"
echo "9. 创建环境变量文件"
echo "10. 退出"
read -p "请选择操作 [1-10]: " choice
case $choice in
1)
read -p "请输入文件名 [docker-compose.yml]: " file
create_compose_template "${file:-docker-compose.yml}"
;;
2)
read -p "请输入Compose文件 [docker-compose.yml]: " file
compose_up "${file:-docker-compose.yml}"
;;
3)
read -p "请输入Compose文件 [docker-compose.yml]: " file
compose_down "${file:-docker-compose.yml}"
;;
4)
read -p "请输入Compose文件 [docker-compose.yml]: " file
compose_ps "${file:-docker-compose.yml}"
;;
5)
read -p "请输入服务名称 (可选): " service
read -p "请输入Compose文件 [docker-compose.yml]: " file
compose_logs "$service" "${file:-docker-compose.yml}"
;;
6)
read -p "请输入服务名称: " service
read -p "请输入Compose文件 [docker-compose.yml]: " file
compose_run_interactive "$service" "${file:-docker-compose.yml}"
;;
7)
read -p "请输入Compose文件 [docker-compose.yml]: " file
compose_healthcheck "${file:-docker-compose.yml}"
;;
8)
read -p "请输入Compose文件 [docker-compose.yml]: " file
compose_monitor "${file:-docker-compose.yml}"
;;
9)
read -p "请输入环境变量文件名 [.env]: " file
create_env_template "${file:-.env}"
;;
10)
exit 0
;;
*)
echo "无效选择"
;;
esac
echo -e "\n按回车键继续..."
read
done
}
# 如果直接运行脚本，显示菜单
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
check_compose_version
compose_management_menu
fi

Docker Swarm命令大全

<strong>#!/bin/bash</strong>
# docker_swarm_commands.sh - Docker Swarm集群管理完整指南
echo "=== Docker Swarm命令大全 ==="
# 检查Swarm模式
check_swarm_mode() {
echo "=== Swarm集群状态检查 ==="
if docker node ls &>/dev/null; then
echo "当前处于Swarm模式"
docker node ls --format "table {{.ID}}\t{{.Hostname}}\t{{.Status}}\t{{.Availability}}\t{{.ManagerStatus}}\t{{.EngineVersion}}"
else
echo "当前未处于Swarm模式"
fi
}
# 1. Swarm集群初始化与管理
echo "=== 1. Swarm集群初始化与管理 ==="
# 初始化Swarm集群
init_swarm() {
local advertise_addr=${1:-""}
echo "初始化Swarm集群..."
if [ -n "$advertise_addr" ]; then
docker swarm init --advertise-addr "$advertise_addr"
else
docker swarm init
fi
}
# 加入Swarm集群
join_swarm() {
local token=$1
local manager_ip=$2
echo "加入Swarm集群..."
docker swarm join --token "$token" "$manager_ip:2377"
}
# 离开Swarm集群
leave_swarm() {
local force=${1:-false}
echo "离开Swarm集群..."
if [ "$force" = true ]; then
docker swarm leave --force
else
docker swarm leave
fi
}
# 更新Swarm配置
update_swarm() {
local key=$1
local value=$2
echo "更新Swarm配置: $key=$value"
docker swarm update --"$key" "$value"
}
# 查看Swarm配置
inspect_swarm() {
echo "查看Swarm集群配置:"
docker swarm inspect --pretty
}
# 2. 节点管理
echo "=== 2. 节点管理 ==="
# 查看节点列表
list_nodes() {
echo "Swarm节点列表:"
docker node ls --format "table {{.ID}}\t{{.Hostname}}\t{{.Status}}\t{{.Availability}}\t{{.ManagerStatus}}\t{{.EngineVersion}}"
}
# 查看节点详情
inspect_node() {
local node=$1
echo "查看节点 $node 详情:"
docker node inspect "$node" --pretty
}
# 提升节点为管理节点
promote_node() {
local node=$1
echo "将节点 $node 提升为管理节点:"
docker node promote "$node"
}
# 降级节点为工作节点
demote_node() {
local node=$1
echo "将节点 $node 降级为工作节点:"
docker node demote "$node"
}
# 更新节点配置
update_node() {
local node=$1
echo "更新节点 $node 配置:"
# 设置节点可用性
docker node update --availability active "$node"
# 设置节点标签
docker node update --label-add role=worker "$node"
}
# 删除节点
remove_node() {
local node=$1
echo "删除节点 $node:"
docker node rm "$node"
}
# 3. 服务管理
echo "=== 3. 服务管理 ==="
# 创建服务
create_service() {
local service_name=$1
local image=$2
echo "创建服务: $service_name"
docker service create \
--name "$service_name" \
--replicas 3 \
--publish published=80,target=80 \
--constraint node.role==worker \
--restart-condition any \
"$image"
}
# 查看服务列表
list_services() {
echo "Swarm服务列表:"
docker service ls --format "table {{.ID}}\t{{.Name}}\t{{.Mode}}\t{{.Replicas}}\t{{.Image}}\t{{.Ports}}"
}
# 查看服务详情
inspect_service() {
local service=$1
echo "查看服务 $service 详情:"
docker service inspect "$service" --pretty
}
# 查看服务日志
service_logs() {
local service=$1
echo "查看服务 $service 日志:"
docker service logs "$service" --tail 20 -f
}
# 扩展服务
scale_service() {
local service=$1
local replicas=$2
echo "扩展服务 $service 到 $replicas 个副本:"
docker service scale "$service=$replicas"
}
# 更新服务
update_service() {
local service=$1
local image=$2
echo "更新服务 $service:"
docker service update \
--image "$image" \
--update-parallelism 2 \
--update-delay 10s \
--rollback-parallelism 1 \
--rollback-delay 0s \
"$service"
}
# 删除服务
remove_service() {
local service=$1
echo "删除服务 $service:"
docker service rm "$service"
}
# 4. 服务网络
echo "=== 4. 服务网络 ==="
# 创建Overlay网络
create_overlay_network() {
local network_name=$1
echo "创建Overlay网络: $network_name"
docker network create \
--driver overlay \
--subnet 10.0.0.0/24 \
--attachable \
"$network_name"
}
# 连接服务到网络
connect_service_to_network() {
local service=$1
local network=$2
echo "连接服务 $service 到网络 $network:"
docker service update \
--network-add "$network" \
"$service"
}
# 断开服务网络连接
disconnect_service_from_network() {
local service=$1
local network=$2
echo "断开服务 $service 与网络 $network 的连接:"
docker service update \
--network-rm "$network" \
"$service"
}
# 5. 配置和密钥管理
echo "=== 5. 配置和密钥管理 ==="
# 创建配置
create_config() {
local config_name=$1
local file=$2
echo "创建配置: $config_name"
docker config create "$config_name" "$file"
}
# 查看配置列表
list_configs() {
echo "Swarm配置列表:"
docker config ls --format "table {{.ID}}\t{{.Name}}\t{{.CreatedAt}}\t{{.UpdatedAt}}"
}
# 使用配置
use_config_in_service() {
local service=$1
local config=$2
local target=$3
echo "在服务 $service 中使用配置 $config:"
docker service update \
--config-add source="$config",target="$target" \
"$service"
}
# 创建密钥
create_secret() {
local secret_name=$1
local file=$2
echo "创建密钥: $secret_name"
docker secret create "$secret_name" "$file"
}
# 查看密钥列表
list_secrets() {
echo "Swarm密钥列表:"
docker secret ls --format "table {{.ID}}\t{{.Name}}\t{{.CreatedAt}}\t{{.UpdatedAt}}"
}
# 6. 栈管理（Stack）
echo "=== 6. 栈管理（Stack） ==="
# 部署栈
deploy_stack() {
local stack_name=$1
local compose_file=$2
echo "部署栈: $stack_name (使用: $compose_file)"
docker stack deploy -c "$compose_file" "$stack_name"
}
# 查看栈列表
list_stacks() {
echo "Swarm栈列表:"
docker stack ls
}
# 查看栈服务
stack_services() {
local stack=$1
echo "栈 $stack 的服务:"
docker stack services "$stack" --format "table {{.ID}}\t{{.Name}}\t{{.Mode}}\t{{.Replicas}}\t{{.Image}}\t{{.Ports}}"
}
# 查看栈任务
stack_ps() {
local stack=$1
echo "栈 $stack 的任务:"
docker stack ps "$stack" --format "table {{.ID}}\t{{.Name}}\t{{.Node}}\t{{.DesiredState}}\t{{.CurrentState}}\t{{.Error}}"
}
# 删除栈
remove_stack() {
local stack=$1
echo "删除栈: $stack"
docker stack rm "$stack"
}
# 7. 负载均衡与路由网格
echo "=== 7. 负载均衡与路由网格 ==="
# 创建Ingress网络
create_ingress_network() {
echo "创建Ingress网络:"
echo "注：Ingress网络通常由Swarm自动创建"
docker network create \
--driver overlay \
--ingress \
--subnet 10.255.0.0/16 \
--gateway 10.255.0.1 \
ingress
}
# 查看路由网格
view_routing_mesh() {
local service=$1
echo "查看服务 $service 的路由网格:"
docker service inspect "$service" --format '{{json .Endpoint.Spec.Ports}}' | python3 -m json.tool
}
# 8. 集群健康检查
echo "=== 8. 集群健康检查 ==="
# 检查集群健康状态
check_cluster_health() {
echo "检查Swarm集群健康状态:"
echo "1. 节点状态:"
docker node ls
echo -e "\n2. 管理器状态:"
docker node ls --filter role=manager
echo -e "\n3. 服务状态:"
docker service ls
echo -e "\n4. 网络状态:"
docker network ls --filter driver=overlay
echo -e "\n5. 任务状态:"
local failed_tasks=$(docker service ps --filter desired-state=running --filter 'current-state!=running' -q | wc -l)
echo "失败任务数量: $failed_tasks"
}
# 检查管理器仲裁
check_manager_quorum() {
echo "检查管理器仲裁状态:"
local manager_count=$(docker node ls --filter role=manager --format "{{.ID}}" | wc -l)
echo "管理器数量: $manager_count"
if [ "$manager_count" -lt 3 ]; then
echo "警告：建议至少有3个管理器以确保高可用性"
fi
docker node ls --filter role=manager --format "table {{.Hostname}}\t{{.ManagerStatus}}"
}
# 9. 备份与恢复
echo "=== 9. 备份与恢复 ==="
# 备份Swarm配置
backup_swarm_config() {
local backup_file=${1:-"/tmp/swarm_backup_$(date +%Y%m%d).tar"}
echo "备份Swarm配置到: $backup_file"
# 备份管理器节点上的Raft数据
local manager_id=$(docker node ls --filter role=manager --format "{{.ID}}" | head -1)
if [ -n "$manager_id" ]; then
docker node inspect "$manager_id" > "/tmp/swarm_node_backup.json"
echo "节点配置已备份"
fi
# 备份服务配置
docker service ls --format "{{.Name}}" | while read service; do
docker service inspect "$service" > "/tmp/service_${service}_backup.json"
done
# 创建压缩包
tar -czf "$backup_file" /tmp/*_backup.json <strong>2</strong>>/dev/null
rm -f /tmp/*_backup.json
echo "Swarm配置备份完成: $backup_file"
}
# 恢复Swarm配置
restore_swarm_config() {
local backup_file=$1
echo "从备份恢复Swarm配置: $backup_file"
if [ ! -f "$backup_file" ]; then
echo "备份文件不存在: $backup_file"
return 1
fi
echo "警告：此操作可能会覆盖现有配置"
read -p "确认恢复？(yes/no): " confirm
if [ "$confirm" = "yes" ]; then
# 提取备份文件
tar -xzf "$backup_file" -C /tmp
echo "开始恢复配置..."
# 这里应该根据备份内容进行恢复
echo "恢复完成（需要根据实际情况手动恢复）"
fi
}
# 10. 安全与TLS配置
echo "=== 10. 安全与TLS配置 ==="
# 生成Swarm TLS证书
generate_swarm_certs() {
echo "生成Swarm TLS证书:"
# 创建证书目录
mkdir -p /etc/docker/certs
echo "请使用以下命令生成证书:"
echo "openssl genrsa -out /etc/docker/certs/ca-key.pem 4096"
echo "openssl req -new -x509 -days 365 -key /etc/docker/certs/ca-key.pem -sha256 -out /etc/docker/certs/ca.pem"
echo "openssl genrsa -out /etc/docker/certs/server-key.pem 4096"
echo "openssl req -subj '/CN=your-server' -sha256 -new -key /etc/docker/certs/server-key.pem -out /etc/docker/certs/server.csr"
echo "echo subjectAltName = DNS:your-server,IP:your-ip > /etc/docker/certs/extfile.cnf"
echo "openssl x509 -req -days 365 -sha256 -in /etc/docker/certs/server.csr -CA /etc/docker/certs/ca.pem -CAkey /etc/docker/certs/ca-key.pem -CAcreateserial -out /etc/docker/certs/server-cert.pem -extfile /etc/docker/certs/extfile.cnf"
}
# 更新Swarm TLS设置
update_swarm_tls() {
echo "更新Swarm TLS设置:"
docker swarm update \
--tls \
--tlscacert /etc/docker/certs/ca.pem \
--tlscert /etc/docker/certs/server-cert.pem \
--tlskey /etc/docker/certs/server-key.pem
}
# Swarm管理菜单
swarm_management_menu() {
while true; do
clear
echo "=== Docker Swarm管理菜单 ==="
echo "1. 初始化Swarm集群"
echo "2. 查看集群状态"
echo "3. 节点管理"
echo "4. 服务管理"
echo "5. 栈管理"
echo "6. 配置和密钥管理"
echo "7. 集群健康检查"
echo "8. 备份与恢复"
echo "9. 退出"
read -p "请选择操作 [1-9]: " choice
case $choice in
1)
read -p "请输入广播地址 (可选): " addr
init_swarm "$addr"
;;
2)
check_swarm_mode
;;
3)
echo "1. 查看节点列表"
echo "2. 提升节点"
echo "3. 降级节点"
read -p "请选择 [1-3]: " node_choice
case $node_choice in
1) list_nodes ;;
2)
read -p "请输入节点ID: " node
promote_node "$node"
;;
3)
read -p "请输入节点ID: " node
demote_node "$node"
;;
esac
;;
4)
echo "1. 创建服务"
echo "2. 查看服务"
echo "3. 扩展服务"
echo "4. 更新服务"
read -p "请选择 [1-4]: " service_choice
case $service_choice in
1)
read -p "请输入服务名称: " service
read -p "请输入镜像名称: " image
create_service "$service" "$image"
;;
2)
list_services
;;
3)
read -p "请输入服务名称: " service
read -p "请输入副本数量: " replicas
scale_service "$service" "$replicas"
;;
4)
read -p "请输入服务名称: " service
read -p "请输入新镜像: " image
update_service "$service" "$image"
;;
esac
;;
5)
echo "1. 部署栈"
echo "2. 查看栈"
echo "3. 删除栈"
read -p "请选择 [1-3]: " stack_choice
case $stack_choice in
1)
read -p "请输入栈名称: " stack
read -p "请输入Compose文件: " file
deploy_stack "$stack" "$file"
;;
2)
list_stacks
;;
3)
read -p "请输入栈名称: " stack
remove_stack "$stack"
;;
esac
;;
6)
echo "1. 创建配置"
echo "2. 创建密钥"
echo "3. 查看配置"
echo "4. 查看密钥"
read -p "请选择 [1-4]: " config_choice
case $config_choice in
1)
read -p "请输入配置名称: " config
read -p "请输入配置文件路径: " file
create_config "$config" "$file"
;;
2)
read -p "请输入密钥名称: " secret
read -p "请输入密钥文件路径: " file
create_secret "$secret" "$file"
;;
3)
list_configs
;;
4)
list_secrets
;;
esac
;;
7)
check_cluster_health
;;
8)
echo "1. 备份配置"
echo "2. 恢复配置"
read -p "请选择 [1-2]: " backup_choice
case $backup_choice in
1) backup_swarm_config ;;
2)
read -p "请输入备份文件路径: " file
restore_swarm_config "$file"
;;
esac
;;
9)
exit 0
;;
*)
echo "无效选择"
;;
esac
echo -e "\n按回车键继续..."
read
done
}
# 如果直接运行脚本，显示菜单
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
check_swarm_mode
swarm_management_menu
fi

总结

本文提供了完整的Docker命令参考指南，涵盖了从基础到高级的所有核心操作：

  1. 系统管理：Docker版本检查、系统状态监控、资源清理
  2. 镜像管理：镜像搜索、拉取、构建、标签、推送和清理
  3. 容器管理：容器生命周期管理、日志查看、网络配置、数据卷操作
  4. 网络管理：网络创建、连接、诊断和性能测试
  5. Docker Compose：多容器编排、服务管理、环境变量配置
  6. Docker Swarm：集群管理、服务编排、负载均衡、安全配置

这些命令和脚本可以直接在生产环境中使用，帮助您高效管理Docker容器化应用。建议收藏本文作为日常运维的参考手册。

© 版权声明
1 本网站名称： VC博客
2 本站永久网址：vcvcc.cc
3 本站资源如有解压密码，则为：vcvcc.cc
4 本网站的文章部分内容可能来源于网络，仅供大家学习与参考，如有侵权，请联系站长 QQ378214732进行删除处理。
5 本站一切资源不代表本站立场，并不代表本站赞同其观点和对其真实性负责。
6 本站一律禁止以任何方式发布或转载任何违法的相关信息，访客发现请向站长举报
7 本站资源大都存储在云盘，如发现链接失效，请联系我们我们会第一时间更新。
8 如无特别声明本文即为原创文章仅代表个人观点，版权归《VC博客》所有，欢迎转载，转载请保留原文链接。
THE END
Docker
# DevOps# 微服务# Docker# 容器化# 云原生# 运维命令
喜欢就支持一下吧
点赞9 分享
VC的头像-Vc博客SVIP
吾爱破解Ollydbg-Vc博客
吾爱破解Ollydbg
吾爱破解Ollydbg
1年前 3382
palworld幻兽帕鲁服务端更新教程-Vc博客
palworld幻兽帕鲁服务端更新教程
palworld幻兽帕鲁服务端更新教程
1年前 807
通过插件实现阿里云盘免费最高画质·远离标清的痛苦-Vc博客
通过插件实现阿里云盘免费最高画质·远离标清的痛苦
通过插件实现阿里云盘免费最高画质·远离标清的痛苦
1年前 772
免费看知乎小说，三个知乎盐选文章/小说免费搬运网站！-Vc博客
免费看知乎小说，三个知乎盐选文章/小说免费搬运网站！
免费看知乎小说，三个知乎盐选文章/小说免费搬运网站！
1年前 719
阿奇索对接鹈鹕权益直冲教程-Vc博客
阿奇索对接鹈鹕权益直冲教程
阿奇索对接鹈鹕权益直冲教程
1年前 480
2024WPS正版授权、政企版长期有效-Vc博客
2024WPS正版授权、政企版长期有效
2024WPS正版授权、政企版长期有效
1年前 430
相关推荐
Go语言微服务：高效服务发现与负载均衡架构实战-Vc博客
Go语言微服务：高效服务发现与负载均衡架构实战
Go语言微服务：高效服务发现与负载均衡架构实战
12天前 54
Docker生产环境实战指南：镜像优化、安全加固与编排进阶-Vc博客
Docker生产环境实战指南：镜像优化、安全加固与编排进阶
Docker生产环境实战指南：镜像优化、安全加固与编排进阶
18天前 52
Git钩子深度实战：自动化流水线的隐形引擎-Vc博客
Git钩子深度实战：自动化流水线的隐形引擎
Git钩子深度实战：自动化流水线的隐形引擎
24天前 47
Git高级技巧与团队协作实战：从底层原理到企业级工作流深度解析-Vc博客
Git高级技巧与团队协作实战：从底层原理到企业级工作流深度解析
Git高级技巧与团队协作实战：从底层原理到企业级工作流深度解析
18天前 46
Git高级实战指南：企业级代码仓库管理与问题解决-Vc博客
Git高级实战指南：企业级代码仓库管理与问题解决
Git高级实战指南：企业级代码仓库管理与问题解决
11天前 36
Docker容器化实战指南：从入门到生产环境的完整部署方案-Vc博客
Docker容器化实战指南：从入门到生产环境的完整部署方案
Docker容器化实战指南：从入门到生产环境的完整部署方案
1个月前 35
评论 抢沙发

请登录后发表评论

    暂无评论内容

文章作者Author of the article
用户封面
VC的头像-Vc博客SVIP
Linux服务与进程异常诊断：系统级故障排查与修复指南
JavaScript性能优化与V8引擎深度解析 – 现代Web开发的高效实践
洞见2025，重塑开发流程的顶级工具推荐
Go语言高并发微服务架构设计与性能优化实战
Python数据结构优化与内存管理深度解析
React 性能优化与高级模式深度实战