Orion K Blog
Linux容器化技术与Docker实战指南：从入门到生产环境的完整解决方案
Orion K Lv6
  2023-10-12 17:22:48  

Linux容器化技术与Docker实战指南：从入门到生产环境的完整解决方案

前言

随着云计算和微服务架构的快速发展，容器化技术已成为现代应用程序部署和管理的核心技术。Docker作为容器化技术的代表，以其轻量级、可移植性和一致性等优势，彻底改变了软件开发和运维的方式。本文将从Docker基础概念开始，深入探讨容器管理、数据备份恢复、网络配置、安全加固等实战技能，为您提供一套完整的Linux容器化解决方案。

一、Docker基础概念与架构

1.1 Docker核心概念

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#!/bin/bash
# Docker基础概念演示脚本

echo "=== Docker基础概念演示 ==="

# 镜像(Image)概念
echo "1. 镜像(Image) - 只读模板，用于创建容器"
docker images

# 容器(Container)概念
echo -e "\n2. 容器(Container) - 镜像的运行实例"
docker ps -a

# 仓库(Repository)概念
echo -e "\n3. 仓库(Repository) - 存储镜像的地方"
echo "Docker Hub: https://hub.docker.com"
echo "私有仓库: Harbor, Nexus等"

# Dockerfile概念
echo -e "\n4. Dockerfile - 构建镜像的脚本"
cat << 'EOF'
# Dockerfile示例
FROM ubuntu:20.04
RUN apt-get update && apt-get install -y nginx
COPY index.html /var/www/html/
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]
EOF

1.2 Docker架构组件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#!/bin/bash
# Docker架构组件检查脚本

echo "=== Docker架构组件检查 ==="

# Docker守护进程状态
echo "1. Docker守护进程状态:"
systemctl status docker

# Docker版本信息
echo -e "\n2. Docker版本信息:"
docker version

# Docker系统信息
echo -e "\n3. Docker系统信息:"
docker system info

# Docker存储驱动
echo -e "\n4. Docker存储驱动:"
docker info | grep "Storage Driver"

# Docker网络驱动
echo -e "\n5. Docker网络列表:"
docker network ls

# Docker数据目录
echo -e "\n6. Docker数据目录:"
echo "默认数据目录: /var/lib/docker"
du -sh /var/lib/docker 2>/dev/null || echo "需要root权限查看"

二、Docker安装与配置

2.1 Docker安装脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
#!/bin/bash
# Docker自动安装脚本

# 检测操作系统
detect_os() {
    if [ -f /etc/os-release ]; then
        . /etc/os-release
        OS=$NAME
        VER=$VERSION_ID
    else
        echo "无法检测操作系统"
        exit 1
    fi
    echo "检测到操作系统: $OS $VER"
}

# 安装Docker - CentOS/RHEL
install_docker_centos() {
    echo "在CentOS/RHEL上安装Docker..."
    
    # 卸载旧版本
    sudo yum remove -y docker docker-client docker-client-latest \
        docker-common docker-latest docker-latest-logrotate \
        docker-logrotate docker-engine
    
    # 安装依赖
    sudo yum install -y yum-utils device-mapper-persistent-data lvm2
    
    # 添加Docker仓库
    sudo yum-config-manager --add-repo \
        https://download.docker.com/linux/centos/docker-ce.repo
    
    # 安装Docker CE
    sudo yum install -y docker-ce docker-ce-cli containerd.io
    
    # 启动Docker服务
    sudo systemctl start docker
    sudo systemctl enable docker
    
    echo "Docker安装完成"
}

# 安装Docker - Ubuntu/Debian
install_docker_ubuntu() {
    echo "在Ubuntu/Debian上安装Docker..."
    
    # 卸载旧版本
    sudo apt-get remove -y docker docker-engine docker.io containerd runc
    
    # 更新包索引
    sudo apt-get update
    
    # 安装依赖
    sudo apt-get install -y apt-transport-https ca-certificates \
        curl gnupg lsb-release
    
    # 添加Docker GPG密钥
    curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
        sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
    
    # 添加Docker仓库
    echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] \
        https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | \
        sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
    
    # 安装Docker CE
    sudo apt-get update
    sudo apt-get install -y docker-ce docker-ce-cli containerd.io
    
    # 启动Docker服务
    sudo systemctl start docker
    sudo systemctl enable docker
    
    echo "Docker安装完成"
}

# 配置Docker
configure_docker() {
    echo "配置Docker..."
    
    # 添加当前用户到docker组
    sudo usermod -aG docker $USER
    
    # 配置Docker守护进程
    sudo mkdir -p /etc/docker
    
    cat << 'EOF' | sudo tee /etc/docker/daemon.json
{
  "registry-mirrors": [
    "https://docker.mirrors.ustc.edu.cn",
    "https://hub-mirror.c.163.com"
  ],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m",
    "max-file": "3"
  },
  "storage-driver": "overlay2",
  "storage-opts": [
    "overlay2.override_kernel_check=true"
  ]
}
EOF
    
    # 重启Docker服务
    sudo systemctl daemon-reload
    sudo systemctl restart docker
    
    echo "Docker配置完成"
    echo "请重新登录以使用户组变更生效"
}

# 验证安装
verify_installation() {
    echo "验证Docker安装..."
    
    # 检查Docker版本
    docker --version
    
    # 运行测试容器
    docker run --rm hello-world
    
    echo "Docker安装验证完成"
}

# 主安装流程
main() {
    detect_os
    
    case "$OS" in
        *"CentOS"*|*"Red Hat"*|*"Rocky"*|*"AlmaLinux"*)
            install_docker_centos
            ;;
        *"Ubuntu"*|*"Debian"*)
            install_docker_ubuntu
            ;;
        *)
            echo "不支持的操作系统: $OS"
            exit 1
            ;;
    esac
    
    configure_docker
    verify_installation
}

# 检查是否为root用户
if [ "$EUID" -eq 0 ]; then
    echo "请不要使用root用户运行此脚本"
    exit 1
fi

main

2.2 Docker Compose安装

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#!/bin/bash
# Docker Compose安装脚本

install_docker_compose() {
    echo "安装Docker Compose..."
    
    # 获取最新版本号
    COMPOSE_VERSION=$(curl -s https://api.github.com/repos/docker/compose/releases/latest | \
        grep 'tag_name' | cut -d'"' -f4)
    
    echo "最新版本: $COMPOSE_VERSION"
    
    # 下载Docker Compose
    sudo curl -L "https://github.com/docker/compose/releases/download/${COMPOSE_VERSION}/docker-compose-$(uname -s)-$(uname -m)" \
        -o /usr/local/bin/docker-compose
    
    # 添加执行权限
    sudo chmod +x /usr/local/bin/docker-compose
    
    # 创建软链接
    sudo ln -sf /usr/local/bin/docker-compose /usr/bin/docker-compose
    
    # 验证安装
    docker-compose --version
    
    echo "Docker Compose安装完成"
}

install_docker_compose

三、容器生命周期管理

3.1 容器基本操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
#!/bin/bash
# 容器生命周期管理脚本

echo "=== 容器生命周期管理 ==="

# 容器创建和运行
container_lifecycle() {
    echo "1. 容器创建和运行"
    
    # 运行简单容器
    echo "运行nginx容器:"
    docker run -d --name web-server -p 8080:80 nginx:latest
    
    # 查看运行中的容器
    echo "运行中的容器:"
    docker ps
    
    # 查看容器详细信息
    echo "容器详细信息:"
    docker inspect web-server
    
    # 查看容器日志
    echo "容器日志:"
    docker logs web-server
    
    # 进入容器
    echo "进入容器(交互式):"
    echo "docker exec -it web-server /bin/bash"
}

# 容器状态管理
container_state_management() {
    echo "2. 容器状态管理"
    
    local container_name="test-container"
    
    # 创建容器但不启动
    docker create --name $container_name ubuntu:20.04 sleep 3600
    
    # 启动容器
    echo "启动容器:"
    docker start $container_name
    
    # 暂停容器
    echo "暂停容器:"
    docker pause $container_name
    
    # 恢复容器
    echo "恢复容器:"
    docker unpause $container_name
    
    # 停止容器
    echo "停止容器:"
    docker stop $container_name
    
    # 重启容器
    echo "重启容器:"
    docker restart $container_name
    
    # 删除容器
    echo "删除容器:"
    docker rm -f $container_name
}

# 容器资源限制
container_resource_limits() {
    echo "3. 容器资源限制"
    
    # CPU限制
    echo "CPU限制示例:"
    docker run -d --name cpu-limited \
        --cpus="1.5" \
        --cpu-shares=1024 \
        nginx:latest
    
    # 内存限制
    echo "内存限制示例:"
    docker run -d --name memory-limited \
        --memory="512m" \
        --memory-swap="1g" \
        nginx:latest
    
    # 磁盘I/O限制
    echo "磁盘I/O限制示例:"
    docker run -d --name io-limited \
        --device-read-bps /dev/sda:1mb \
        --device-write-bps /dev/sda:1mb \
        nginx:latest
    
    # 查看容器资源使用情况
    echo "容器资源使用情况:"
    docker stats --no-stream
    
    # 清理测试容器
    docker rm -f cpu-limited memory-limited io-limited
}

# 容器网络管理
container_network_management() {
    echo "4. 容器网络管理"
    
    # 创建自定义网络
    echo "创建自定义网络:"
    docker network create --driver bridge my-network
    
    # 在自定义网络中运行容器
    echo "在自定义网络中运行容器:"
    docker run -d --name web1 --network my-network nginx:latest
    docker run -d --name web2 --network my-network nginx:latest
    
    # 查看网络信息
    echo "网络信息:"
    docker network ls
    docker network inspect my-network
    
    # 容器间通信测试
    echo "容器间通信测试:"
    docker exec web1 ping -c 3 web2
    
    # 清理
    docker rm -f web1 web2
    docker network rm my-network
}

container_lifecycle
container_state_management
container_resource_limits
container_network_management

3.2 容器监控和调试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
#!/bin/bash
# 容器监控和调试脚本

echo "=== 容器监控和调试 ==="

# 容器性能监控
container_monitoring() {
    echo "1. 容器性能监控"
    
    # 实时监控所有容器
    echo "实时监控所有容器:"
    docker stats --format "table {{.Container}}\t{{.CPUPerc}}\t{{.MemUsage}}\t{{.NetIO}}\t{{.BlockIO}}"
    
    # 监控特定容器
    if [ "$1" ]; then
        echo "监控特定容器: $1"
        docker stats $1
    fi
}

# 容器日志管理
container_log_management() {
    echo "2. 容器日志管理"
    
    local container_name="log-test"
    
    # 创建测试容器
    docker run -d --name $container_name \
        --log-driver json-file \
        --log-opt max-size=10m \
        --log-opt max-file=3 \
        nginx:latest
    
    # 查看日志
    echo "查看容器日志:"
    docker logs $container_name
    
    # 实时跟踪日志
    echo "实时跟踪日志(10秒):"
    timeout 10 docker logs -f $container_name
    
    # 查看日志文件位置
    echo "日志文件位置:"
    docker inspect $container_name | grep LogPath
    
    # 清理
    docker rm -f $container_name
}

# 容器故障排查
container_troubleshooting() {
    echo "3. 容器故障排查"
    
    # 检查容器状态
    check_container_status() {
        local container=$1
        echo "检查容器状态: $container"
        
        # 容器基本信息
        docker ps -a --filter name=$container
        
        # 容器详细状态
        docker inspect $container --format='{{.State.Status}}'
        
        # 容器退出码
        docker inspect $container --format='{{.State.ExitCode}}'
        
        # 容器错误信息
        docker inspect $container --format='{{.State.Error}}'
    }
    
    # 检查容器资源使用
    check_container_resources() {
        local container=$1
        echo "检查容器资源使用: $container"
        
        # CPU和内存使用
        docker stats --no-stream $container
        
        # 容器进程
        docker top $container
        
        # 容器文件系统使用
        docker exec $container df -h
    }
    
    # 网络连接检查
    check_container_network() {
        local container=$1
        echo "检查容器网络: $container"
        
        # 容器IP地址
        docker inspect $container --format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}'
        
        # 端口映射
        docker port $container
        
        # 网络连接测试
        docker exec $container netstat -tlnp
    }
    
    echo "故障排查函数已定义，使用方法:"
    echo "check_container_status <容器名>"
    echo "check_container_resources <容器名>"
    echo "check_container_network <容器名>"
}

# 容器健康检查
container_health_check() {
    echo "4. 容器健康检查"
    
    # 创建带健康检查的容器
    cat << 'EOF' > /tmp/Dockerfile.health
FROM nginx:latest
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
    CMD curl -f http://localhost/ || exit 1
EOF
    
    # 构建镜像
    docker build -t nginx-health -f /tmp/Dockerfile.health /tmp/
    
    # 运行容器
    docker run -d --name health-test nginx-health
    
    # 查看健康状态
    echo "查看健康状态:"
    sleep 10
    docker inspect health-test --format='{{.State.Health.Status}}'
    
    # 查看健康检查历史
    echo "健康检查历史:"
    docker inspect health-test --format='{{range .State.Health.Log}}{{.Output}}{{end}}'
    
    # 清理
    docker rm -f health-test
    docker rmi nginx-health
    rm -f /tmp/Dockerfile.health
}

container_monitoring
container_log_management
container_troubleshooting
container_health_check

四、Docker镜像管理

4.1 镜像构建与优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
#!/bin/bash
# Docker镜像构建与优化脚本

echo "=== Docker镜像构建与优化 ==="

# 创建优化的Dockerfile示例
create_optimized_dockerfile() {
    echo "1. 创建优化的Dockerfile"
    
    mkdir -p /tmp/docker-build
    cd /tmp/docker-build
    
    # 多阶段构建示例
    cat << 'EOF' > Dockerfile.multistage
# 多阶段构建示例 - 构建阶段
FROM node:16-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

# 运行阶段
FROM node:16-alpine AS runtime
WORKDIR /app

# 创建非root用户
RUN addgroup -g 1001 -S nodejs && \
    adduser -S nextjs -u 1001

# 复制构建产物
COPY --from=builder /app/node_modules ./node_modules
COPY . .

# 设置用户
USER nextjs

# 健康检查
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
    CMD curl -f http://localhost:3000/health || exit 1

EXPOSE 3000
CMD ["npm", "start"]
EOF
    
    # 优化的Python应用Dockerfile
    cat << 'EOF' > Dockerfile.python
FROM python:3.9-slim AS base

# 设置环境变量
ENV PYTHONUNBUFFERED=1 \
    PYTHONDONTWRITEBYTECODE=1 \
    PIP_NO_CACHE_DIR=1 \
    PIP_DISABLE_PIP_VERSION_CHECK=1

# 安装系统依赖
RUN apt-get update && apt-get install -y \
    gcc \
    && rm -rf /var/lib/apt/lists/*

# 创建应用用户
RUN useradd --create-home --shell /bin/bash app

# 设置工作目录
WORKDIR /app

# 复制依赖文件
COPY requirements.txt .

# 安装Python依赖
RUN pip install --no-cache-dir -r requirements.txt

# 复制应用代码
COPY . .

# 设置权限
RUN chown -R app:app /app
USER app

EXPOSE 8000
CMD ["python", "app.py"]
EOF
    
    echo "Dockerfile示例已创建"
}

# 镜像构建最佳实践
image_build_best_practices() {
    echo "2. 镜像构建最佳实践"
    
    # .dockerignore文件
    cat << 'EOF' > .dockerignore
# Git相关
.git
.gitignore

# 文档
*.md
README*

# 日志文件
*.log
logs/

# 临时文件
*.tmp
*.temp

# IDE文件
.vscode/
.idea/

# 依赖目录
node_modules/
__pycache__/
*.pyc

# 测试文件
tests/
*.test.js
EOF
    
    echo ".dockerignore文件已创建"
    
    # 构建脚本
    cat << 'EOF' > build.sh
#!/bin/bash
# 镜像构建脚本

IMAGE_NAME="myapp"
IMAGE_TAG="latest"
DOCKERFILE="Dockerfile"

# 构建参数
BUILD_ARGS=""
if [ "$BUILD_ENV" ]; then
    BUILD_ARGS="--build-arg ENV=$BUILD_ENV"
fi

# 构建镜像
echo "构建镜像: $IMAGE_NAME:$IMAGE_TAG"
docker build $BUILD_ARGS -t $IMAGE_NAME:$IMAGE_TAG -f $DOCKERFILE .

# 检查镜像大小
echo "镜像大小:"
docker images $IMAGE_NAME:$IMAGE_TAG

# 镜像安全扫描(如果有工具)
if command -v trivy >/dev/null 2>&1; then
    echo "安全扫描:"
    trivy image $IMAGE_NAME:$IMAGE_TAG
fi

# 镜像层分析
echo "镜像层分析:"
docker history $IMAGE_NAME:$IMAGE_TAG
EOF
    
    chmod +x build.sh
    echo "构建脚本已创建"
}

# 镜像优化技巧
image_optimization_tips() {
    echo "3. 镜像优化技巧"
    
    # 镜像大小分析
    analyze_image_size() {
        local image=$1
        echo "分析镜像大小: $image"
        
        # 显示镜像层
        docker history $image --format "table {{.CreatedBy}}\t{{.Size}}"
        
        # 使用dive工具分析(如果安装)
        if command -v dive >/dev/null 2>&1; then
            dive $image
        else
            echo "安装dive工具进行详细分析: https://github.com/wagoodman/dive"
        fi
    }
    
    # 镜像清理
    cleanup_images() {
        echo "清理无用镜像:"
        
        # 删除悬空镜像
        docker image prune -f
        
        # 删除未使用的镜像
        docker image prune -a -f
        
        # 显示镜像使用情况
        docker system df
    }
    
    echo "镜像优化函数已定义:"
    echo "analyze_image_size <镜像名>"
    echo "cleanup_images"
}

create_optimized_dockerfile
image_build_best_practices
image_optimization_tips

4.2 镜像仓库管理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
#!/bin/bash
# Docker镜像仓库管理脚本

echo "=== Docker镜像仓库管理 ==="

# Docker Hub操作
dockerhub_operations() {
    echo "1. Docker Hub操作"
    
    # 登录Docker Hub
    docker_login() {
        echo "登录Docker Hub:"
        read -p "输入Docker Hub用户名: " username
        docker login -u $username
    }
    
    # 推送镜像
    push_image() {
        local image=$1
        local tag=${2:-latest}
        
        if [ -z "$image" ]; then
            echo "用法: push_image <镜像名> [标签]"
            return 1
        fi
        
        echo "推送镜像: $image:$tag"
        docker tag $image:$tag $DOCKER_USERNAME/$image:$tag
        docker push $DOCKER_USERNAME/$image:$tag
    }
    
    # 拉取镜像
    pull_image() {
        local image=$1
        local tag=${2:-latest}
        
        if [ -z "$image" ]; then
            echo "用法: pull_image <镜像名> [标签]"
            return 1
        fi
        
        echo "拉取镜像: $image:$tag"
        docker pull $image:$tag
    }
    
    echo "Docker Hub函数已定义:"
    echo "docker_login"
    echo "push_image <镜像名> [标签]"
    echo "pull_image <镜像名> [标签]"
}

# 私有仓库搭建
setup_private_registry() {
    echo "2. 搭建私有Docker仓库"
    
    # 创建仓库目录
    sudo mkdir -p /opt/docker-registry/{data,certs,auth}
    
    # 生成自签名证书
    generate_certs() {
        echo "生成自签名证书:"
        
        openssl req -newkey rsa:4096 -nodes -sha256 \
            -keyout /opt/docker-registry/certs/domain.key \
            -x509 -days 365 \
            -out /opt/docker-registry/certs/domain.crt \
            -subj "/C=CN/ST=Beijing/L=Beijing/O=Company/CN=registry.local"
    }
    
    # 创建认证文件
    create_auth() {
        echo "创建认证文件:"
        
        read -p "输入用户名: " username
        read -s -p "输入密码: " password
        echo
        
        docker run --rm --entrypoint htpasswd \
            httpd:2 -Bbn $username $password > /opt/docker-registry/auth/htpasswd
    }
    
    # 启动私有仓库
    start_registry() {
        echo "启动私有Docker仓库:"
        
        docker run -d \
            --restart=always \
            --name registry \
            -p 5000:5000 \
            -v /opt/docker-registry/data:/var/lib/registry \
            -v /opt/docker-registry/certs:/certs \
            -v /opt/docker-registry/auth:/auth \
            -e REGISTRY_HTTP_TLS_CERTIFICATE=/certs/domain.crt \
            -e REGISTRY_HTTP_TLS_PRIVATE_KEY=/certs/domain.key \
            -e REGISTRY_AUTH=htpasswd \
            -e REGISTRY_AUTH_HTPASSWD_PATH=/auth/htpasswd \
            -e REGISTRY_AUTH_HTPASSWD_REALM="Registry Realm" \
            registry:2
    }
    
    echo "私有仓库函数已定义:"
    echo "generate_certs"
    echo "create_auth"
    echo "start_registry"
}

# Harbor仓库管理
harbor_management() {
    echo "3. Harbor企业级仓库管理"
    
    # Harbor安装脚本
    install_harbor() {
        echo "安装Harbor:"
        
        # 下载Harbor
        HARBOR_VERSION="v2.5.0"
        wget https://github.com/goharbor/harbor/releases/download/${HARBOR_VERSION}/harbor-offline-installer-${HARBOR_VERSION}.tgz
        
        # 解压
        tar xvf harbor-offline-installer-${HARBOR_VERSION}.tgz
        cd harbor
        
        # 配置Harbor
        cp harbor.yml.tmpl harbor.yml
        
        # 修改配置文件
        sed -i 's/hostname: reg.mydomain.com/hostname: harbor.local/' harbor.yml
        sed -i 's/harbor_admin_password: Harbor12345/harbor_admin_password: YourPassword/' harbor.yml
        
        # 安装Harbor
        sudo ./install.sh
    }
    
    # Harbor备份
    backup_harbor() {
        echo "备份Harbor数据:"
        
        local backup_dir="/opt/harbor-backup/$(date +%Y%m%d_%H%M%S)"
        mkdir -p $backup_dir
        
        # 停止Harbor
        cd /opt/harbor
        docker-compose down
        
        # 备份数据
        cp -r /data/database $backup_dir/
        cp -r /data/registry $backup_dir/
        cp harbor.yml $backup_dir/
        
        # 重启Harbor
        docker-compose up -d
        
        echo "备份完成: $backup_dir"
    }
    
    echo "Harbor函数已定义:"
    echo "install_harbor"
    echo "backup_harbor"
}

dockerhub_operations
setup_private_registry
harbor_management

五、容器数据管理与备份

5.1 数据卷管理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
#!/bin/bash
# Docker数据卷管理脚本

echo "=== Docker数据卷管理 ==="

# 数据卷基本操作
volume_basic_operations() {
    echo "1. 数据卷基本操作"
    
    # 创建数据卷
    echo "创建数据卷:"
    docker volume create my-volume
    
    # 查看数据卷
    echo "查看数据卷列表:"
    docker volume ls
    
    # 查看数据卷详细信息
    echo "数据卷详细信息:"
    docker volume inspect my-volume
    
    # 使用数据卷运行容器
    echo "使用数据卷运行容器:"
    docker run -d --name volume-test \
        -v my-volume:/data \
        nginx:latest
    
    # 在容器中写入数据
    docker exec volume-test sh -c 'echo "Hello Volume" > /data/test.txt'
    
    # 验证数据持久性
    echo "验证数据持久性:"
    docker rm -f volume-test
    docker run --rm -v my-volume:/data alpine cat /data/test.txt
    
    # 清理
    docker volume rm my-volume
}

# 绑定挂载管理
bind_mount_management() {
    echo "2. 绑定挂载管理"
    
    # 创建主机目录
    local host_dir="/tmp/docker-bind-mount"
    mkdir -p $host_dir
    echo "Host data" > $host_dir/host-file.txt
    
    # 绑定挂载
    echo "绑定挂载示例:"
    docker run -d --name bind-test \
        -v $host_dir:/app/data \
        nginx:latest
    
    # 在容器中创建文件
    docker exec bind-test sh -c 'echo "Container data" > /app/data/container-file.txt'
    
    # 验证主机上的文件
    echo "主机上的文件:"
    ls -la $host_dir
    
    # 只读挂载
    echo "只读挂载示例:"
    docker run --rm \
        -v $host_dir:/app/data:ro \
        alpine sh -c 'ls -la /app/data && echo "尝试写入..." && touch /app/data/readonly-test.txt || echo "写入失败(预期行为)"'
    
    # 清理
    docker rm -f bind-test
    rm -rf $host_dir
}

# tmpfs挂载
tmpfs_mount() {
    echo "3. tmpfs挂载(内存文件系统)"
    
    # 创建tmpfs挂载
    docker run -d --name tmpfs-test \
        --tmpfs /tmp:rw,noexec,nosuid,size=100m \
        nginx:latest
    
    # 测试tmpfs
    docker exec tmpfs-test sh -c '
        echo "写入tmpfs" > /tmp/tmpfs-test.txt
        df -h /tmp
        ls -la /tmp/
    '
    
    # 清理
    docker rm -f tmpfs-test
}

# 数据卷备份和恢复
volume_backup_restore() {
    echo "4. 数据卷备份和恢复"
    
    # 创建测试数据卷和容器
    docker volume create backup-test-volume
    docker run -d --name data-container \
        -v backup-test-volume:/data \
        alpine sh -c 'while true; do echo "$(date): Data entry" >> /data/log.txt; sleep 60; done'
    
    # 等待一些数据写入
    sleep 5
    
    # 备份数据卷
    backup_volume() {
        local volume_name=$1
        local backup_file=$2
        
        if [ -z "$volume_name" ] || [ -z "$backup_file" ]; then
            echo "用法: backup_volume <数据卷名> <备份文件路径>"
            return 1
        fi
        
        echo "备份数据卷: $volume_name -> $backup_file"
        docker run --rm \
            -v $volume_name:/data \
            -v $(dirname $backup_file):/backup \
            alpine tar czf /backup/$(basename $backup_file) -C /data .
    }
    
    # 恢复数据卷
    restore_volume() {
        local volume_name=$1
        local backup_file=$2
        
        if [ -z "$volume_name" ] || [ -z "$backup_file" ]; then
            echo "用法: restore_volume <数据卷名> <备份文件路径>"
            return 1
        fi
        
        echo "恢复数据卷: $backup_file -> $volume_name"
        docker run --rm \
            -v $volume_name:/data \
            -v $(dirname $backup_file):/backup \
            alpine sh -c 'rm -rf /data/* && tar xzf /backup/$(basename $backup_file) -C /data'
    }
    
    # 执行备份
    mkdir -p /tmp/volume-backup
    backup_volume backup-test-volume /tmp/volume-backup/backup.tar.gz
    
    # 创建新数据卷并恢复
    docker volume create restore-test-volume
    restore_volume restore-test-volume /tmp/volume-backup/backup.tar.gz
    
    # 验证恢复
    echo "验证恢复的数据:"
    docker run --rm -v restore-test-volume:/data alpine cat /data/log.txt
    
    # 清理
    docker rm -f data-container
    docker volume rm backup-test-volume restore-test-volume
    rm -rf /tmp/volume-backup
    
    echo "数据卷备份恢复函数已定义:"
    echo "backup_volume <数据卷名> <备份文件路径>"
    echo "restore_volume <数据卷名> <备份文件路径>"
}

volume_basic_operations
bind_mount_management
tmpfs_mount
volume_backup_restore

5.2 容器备份与恢复

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
#!/bin/bash
# 容器备份与恢复脚本

echo "=== 容器备份与恢复 ==="

# 容器镜像备份
container_image_backup() {
    echo "1. 容器镜像备份"
    
    # 备份运行中的容器为镜像
    backup_container_to_image() {
        local container_name=$1
        local image_name=$2
        local image_tag=${3:-latest}
        
        if [ -z "$container_name" ] || [ -z "$image_name" ]; then
            echo "用法: backup_container_to_image <容器名> <镜像名> [标签]"
            return 1
        fi
        
        echo "备份容器 $container_name 为镜像 $image_name:$image_tag"
        
        # 暂停容器以确保数据一致性
        docker pause $container_name
        
        # 创建镜像
        docker commit -p $container_name $image_name:$image_tag
        
        # 恢复容器
        docker unpause $container_name
        
        echo "备份完成"
    }
    
    # 导出镜像为tar文件
    export_image_to_tar() {
        local image_name=$1
        local tar_file=$2
        
        if [ -z "$image_name" ] || [ -z "$tar_file" ]; then
            echo "用法: export_image_to_tar <镜像名> <tar文件路径>"
            return 1
        fi
        
        echo "导出镜像 $image_name 到 $tar_file"
        docker save -o $tar_file $image_name
        
        # 压缩tar文件
        if command -v gzip >/dev/null 2>&1; then
            gzip $tar_file
            echo "已压缩为 ${tar_file}.gz"
        fi
    }
    
    # 从tar文件导入镜像
    import_image_from_tar() {
        local tar_file=$1
        
        if [ -z "$tar_file" ]; then
            echo "用法: import_image_from_tar <tar文件路径>"
            return 1
        fi
        
        echo "从 $tar_file 导入镜像"
        
        # 如果是压缩文件，先解压
        if [[ $tar_file == *.gz ]]; then
            gunzip $tar_file
            tar_file=${tar_file%.gz}
        fi
        
        docker load -i $tar_file
        echo "导入完成"
    }
    
    echo "容器镜像备份函数已定义:"
    echo "backup_container_to_image <容器名> <镜像名> [标签]"
    echo "export_image_to_tar <镜像名> <tar文件路径>"
    echo "import_image_from_tar <tar文件路径>"
}

# 容器文件系统备份
container_filesystem_backup() {
    echo "2. 容器文件系统备份"
    
    # 导出容器文件系统
    export_container_filesystem() {
        local container_name=$1
        local tar_file=$2
        
        if [ -z "$container_name" ] || [ -z "$tar_file" ]; then
            echo "用法: export_container_filesystem <容器名> <tar文件路径>"
            return 1
        fi
        
        echo "导出容器 $container_name 文件系统到 $tar_file"
        docker export -o $tar_file $container_name
        
        # 压缩
        if command -v gzip >/dev/null 2>&1; then
            gzip $tar_file
            echo "已压缩为 ${tar_file}.gz"
        fi
    }
    
    # 从文件系统备份创建镜像
    import_filesystem_to_image() {
        local tar_file=$1
        local image_name=$2
        local image_tag=${3:-latest}
        
        if [ -z "$tar_file" ] || [ -z "$image_name" ]; then
            echo "用法: import_filesystem_to_image <tar文件路径> <镜像名> [标签]"
            return 1
        fi
        
        echo "从 $tar_file 创建镜像 $image_name:$image_tag"
        
        # 如果是压缩文件，使用管道解压并导入
        if [[ $tar_file == *.gz ]]; then
            gunzip -c $tar_file | docker import - $image_name:$image_tag
        else
            docker import $tar_file $image_name:$image_tag
        fi
        
        echo "导入完成"
    }
    
    echo "容器文件系统备份函数已定义:"
    echo "export_container_filesystem <容器名> <tar文件路径>"
    echo "import_filesystem_to_image <tar文件路径> <镜像名> [标签]"
}

# 增量备份策略
incremental_backup_strategy() {
    echo "3. 增量备份策略"
    
    # 创建增量备份脚本
    create_incremental_backup_script() {
        cat << 'EOF' > /tmp/incremental_backup.sh
#!/bin/bash
# Docker增量备份脚本

BACKUP_DIR="/opt/docker-backups"
CONTAINER_NAME="$1"
BACKUP_TYPE="${2:-incremental}"  # full, incremental

if [ -z "$CONTAINER_NAME" ]; then
    echo "用法: $0 <容器名> [backup_type]"
    exit 1
fi

# 创建备份目录
mkdir -p "$BACKUP_DIR/$CONTAINER_NAME"

# 获取当前时间戳
TIMESTAMP=$(date +%Y%m%d_%H%M%S)

# 全量备份
full_backup() {
    echo "执行全量备份..."
    
    # 备份容器为镜像
    docker commit -p "$CONTAINER_NAME" "backup-$CONTAINER_NAME:$TIMESTAMP"
    
    # 导出镜像
    docker save -o "$BACKUP_DIR/$CONTAINER_NAME/full_$TIMESTAMP.tar" \
        "backup-$CONTAINER_NAME:$TIMESTAMP"
    
    # 压缩
    gzip "$BACKUP_DIR/$CONTAINER_NAME/full_$TIMESTAMP.tar"
    
    # 记录备份信息
    echo "$TIMESTAMP:full" >> "$BACKUP_DIR/$CONTAINER_NAME/backup.log"
    
    echo "全量备份完成: full_$TIMESTAMP.tar.gz"
}

# 增量备份(基于数据卷)
incremental_backup() {
    echo "执行增量备份..."
    
    # 获取上次备份时间
    LAST_BACKUP=$(tail -1 "$BACKUP_DIR/$CONTAINER_NAME/backup.log" 2>/dev/null | cut -d: -f1)
    
    if [ -z "$LAST_BACKUP" ]; then
        echo "未找到上次备份记录，执行全量备份"
        full_backup
        return
    fi
    
    # 查找容器的数据卷
    VOLUMES=$(docker inspect "$CONTAINER_NAME" --format '{{range .Mounts}}{{.Source}}:{{.Destination}} {{end}}')
    
    if [ -z "$VOLUMES" ]; then
        echo "容器无数据卷，执行全量备份"
        full_backup
        return
    fi
    
    # 备份变更的文件
    for VOLUME in $VOLUMES; do
        SOURCE=$(echo $VOLUME | cut -d: -f1)
        DEST=$(echo $VOLUME | cut -d: -f2)
        
        if [ -d "$SOURCE" ]; then
            # 查找自上次备份以来修改的文件
            find "$SOURCE" -newer "$BACKUP_DIR/$CONTAINER_NAME/full_${LAST_BACKUP}.tar.gz" \
                -type f -exec tar -czf "$BACKUP_DIR/$CONTAINER_NAME/incremental_$TIMESTAMP.tar.gz" {} +
        fi
    done
    
    # 记录备份信息
    echo "$TIMESTAMP:incremental" >> "$BACKUP_DIR/$CONTAINER_NAME/backup.log"
    
    echo "增量备份完成: incremental_$TIMESTAMP.tar.gz"
}

# 执行备份
case "$BACKUP_TYPE" in
    full)
        full_backup
        ;;
    incremental)
        incremental_backup
        ;;
    *)
        echo "不支持的备份类型: $BACKUP_TYPE"
        exit 1
        ;;
esac
EOF
        
        chmod +x /tmp/incremental_backup.sh
        echo "增量备份脚本已创建: /tmp/incremental_backup.sh"
    }
    
    create_incremental_backup_script
}

# 自动化备份调度
automated_backup_scheduling() {
    echo "4. 自动化备份调度"
    
    # 创建备份调度脚本
    create_backup_scheduler() {
        cat << 'EOF' > /tmp/backup_scheduler.sh
#!/bin/bash
# Docker备份调度脚本

BACKUP_CONFIG="/etc/docker-backup.conf"
LOG_FILE="/var/log/docker-backup.log"

# 日志函数
log_message() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a "$LOG_FILE"
}

# 读取配置文件
if [ -f "$BACKUP_CONFIG" ]; then
    source "$BACKUP_CONFIG"
else
    log_message "配置文件不存在: $BACKUP_CONFIG"
    exit 1
fi

# 执行备份
for CONTAINER in $CONTAINERS_TO_BACKUP; do
    log_message "开始备份容器: $CONTAINER"
    
    # 检查容器是否运行
    if ! docker ps --format '{{.Names}}' | grep -q "^$CONTAINER$"; then
        log_message "警告: 容器 $CONTAINER 未运行"
        continue
    fi
    
    # 执行备份
    if /tmp/incremental_backup.sh "$CONTAINER" "$BACKUP_TYPE"; then
        log_message "容器 $CONTAINER 备份成功"
    else
        log_message "错误: 容器 $CONTAINER 备份失败"
    fi
done

# 清理旧备份
if [ "$RETENTION_DAYS" ]; then
    log_message "清理 $RETENTION_DAYS 天前的备份"
    find "$BACKUP_DIR" -name "*.tar.gz" -mtime +$RETENTION_DAYS -delete
fi

log_message "备份调度完成"
EOF
        
        chmod +x /tmp/backup_scheduler.sh
        
        # 创建配置文件模板
        cat << 'EOF' > /tmp/docker-backup.conf
# Docker备份配置文件

# 要备份的容器列表(空格分隔)
CONTAINERS_TO_BACKUP="web-server database redis"

# 备份类型: full, incremental
BACKUP_TYPE="incremental"

# 备份目录
BACKUP_DIR="/opt/docker-backups"

# 备份保留天数
RETENTION_DAYS=30
EOF
        
        # 创建crontab条目
        echo "添加到crontab的示例条目:"
        echo "# 每天凌晨2点执行增量备份"
        echo "0 2 * * * /tmp/backup_scheduler.sh"
        echo "# 每周日凌晨1点执行全量备份"
        echo "0 1 * * 0 BACKUP_TYPE=full /tmp/backup_scheduler.sh"
        
        echo "备份调度脚本已创建: /tmp/backup_scheduler.sh"
        echo "配置文件模板: /tmp/docker-backup.conf"
    }
    
    create_backup_scheduler
}

container_image_backup
container_filesystem_backup
incremental_backup_strategy
automated_backup_scheduling

六、Docker网络配置

6.1 网络驱动和模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
#!/bin/bash
# Docker网络配置脚本

echo "=== Docker网络配置 ==="

# 网络驱动介绍
network_drivers_overview() {
    echo "1. Docker网络驱动概览"
    
    # 查看可用网络驱动
    echo "可用网络驱动:"
    docker network ls
    
    # 默认网络详情
    echo -e "\n默认bridge网络详情:"
    docker network inspect bridge
    
    echo -e "\n网络驱动类型说明:"
    echo "- bridge: 默认网络驱动，适用于单主机容器通信"
    echo "- host: 容器直接使用主机网络栈"
    echo "- none: 禁用容器网络"
    echo "- overlay: 用于跨主机容器通信(Swarm模式)"
    echo "- macvlan: 为容器分配MAC地址，使其看起来像物理设备"
}

# Bridge网络配置
bridge_network_configuration() {
    echo "2. Bridge网络配置"
    
    # 创建自定义bridge网络
    create_custom_bridge() {
        local network_name="custom-bridge"
        
        echo "创建自定义bridge网络: $network_name"
        docker network create \
            --driver bridge \
            --subnet=172.20.0.0/16 \
            --ip-range=172.20.240.0/20 \
            --gateway=172.20.0.1 \
            --opt "com.docker.network.bridge.name"="docker1" \
            --opt "com.docker.network.driver.mtu"="1500" \
            $network_name
        
        # 在自定义网络中运行容器
        echo "在自定义网络中运行容器:"
        docker run -d --name web1 --network $network_name nginx:latest
        docker run -d --name web2 --network $network_name nginx:latest
        
        # 测试容器间通信
        echo "测试容器间通信:"
        docker exec web1 ping -c 3 web2
        
        # 查看网络详情
        echo "网络详情:"
        docker network inspect $network_name
        
        # 清理
        docker rm -f web1 web2
        docker network rm $network_name
    }
    
    create_custom_bridge
}

# Host网络模式
host_network_mode() {
    echo "3. Host网络模式"
    
    # 使用host网络运行容器
    echo "使用host网络运行nginx:"
    docker run -d --name nginx-host --network host nginx:latest
    
    # 检查网络配置
    echo "容器网络配置:"
    docker exec nginx-host ip addr show
    
    # 检查端口监听
    echo "端口监听情况:"
    docker exec nginx-host netstat -tlnp
    
    # 从主机访问服务
    echo "从主机访问服务:"
    curl -I http://localhost:80 || echo "nginx可能未在80端口监听"
    
    # 清理
    docker rm -f nginx-host
}

# 容器网络连接管理
container_network_connection() {
    echo "4. 容器网络连接管理"
    
    # 创建多个网络
    docker network create frontend
    docker network create backend
    
    # 运行容器
    docker run -d --name web --network frontend nginx:latest
    docker run -d --name app --network backend alpine sleep 3600
    docker run -d --name db --network backend postgres:13 \
        -e POSTGRES_PASSWORD=password
    
    # 将web容器连接到backend网络
    echo "将web容器连接到backend网络:"
    docker network connect backend web
    
    # 查看容器网络连接
    echo "web容器网络连接:"
    docker inspect web --format='{{range $net, $conf := .NetworkSettings.Networks}}{{$net}}: {{$conf.IPAddress}} {{end}}'
    
    # 测试跨网络通信
    echo "测试跨网络通信:"
    docker exec web ping -c 3 app
    
    # 断开网络连接
    echo "断开web容器与backend网络的连接:"
    docker network disconnect backend web
    
    # 清理
    docker rm -f web app db
    docker network rm frontend backend
}

network_drivers_overview
bridge_network_configuration
host_network_mode
container_network_connection

6.2 网络安全和隔离

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
#!/bin/bash
# Docker网络安全和隔离脚本

echo "=== Docker网络安全和隔离 ==="

# 网络隔离策略
network_isolation_strategy() {
    echo "1. 网络隔离策略"
    
    # 创建隔离的网络环境
    create_isolated_environment() {
        echo "创建隔离的网络环境:"
        
        # 创建前端网络(DMZ)
        docker network create \
            --driver bridge \
            --subnet=172.30.1.0/24 \
            --opt "com.docker.network.bridge.enable_icc"="false" \
            frontend-dmz
        
        # 创建后端网络(内部)
        docker network create \
            --driver bridge \
            --subnet=172.30.2.0/24 \
            --internal \
            backend-internal
        
        # 创建数据库网络(高度隔离)
        docker network create \
            --driver bridge \
            --subnet=172.30.3.0/24 \
            --internal \
            database-secure
        
        echo "隔离网络创建完成"
    }
    
    # 部署分层应用
    deploy_layered_application() {
        echo "部署分层应用:"
        
        # Web层(前端DMZ)
        docker run -d --name web-tier \
            --network frontend-dmz \
            -p 80:80 \
            nginx:latest
        
        # 应用层(后端内部)
        docker run -d --name app-tier \
            --network backend-internal \
            alpine sleep 3600
        
        # 数据库层(高度隔离)
        docker run -d --name db-tier \
            --network database-secure \
            -e POSTGRES_PASSWORD=securepassword \
            postgres:13
        
        # 连接web到backend(受控访问)
        docker network connect backend-internal web-tier
        
        # 连接app到database(受控访问)
        docker network connect database-secure app-tier
        
        echo "分层应用部署完成"
    }
    
    create_isolated_environment
    deploy_layered_application
}

# 防火墙规则配置
firewall_rules_configuration() {
    echo "2. 防火墙规则配置"
    
    # iptables规则管理
    configure_iptables_rules() {
        echo "配置iptables规则:"
        
        # 备份现有规则
        sudo iptables-save > /tmp/iptables-backup-$(date +%Y%m%d_%H%M%S)
        
        # Docker链规则
        echo "Docker相关iptables规则:"
        sudo iptables -L DOCKER -n
        sudo iptables -L DOCKER-USER -n
        
        # 自定义规则示例
        cat << 'EOF'
# 限制容器对外访问的iptables规则示例:

# 阻止容器访问主机敏感端口
sudo iptables -I DOCKER-USER -p tcp --dport 22 -j DROP
sudo iptables -I DOCKER-USER -p tcp --dport 3306 -j DROP

# 允许特定容器访问外部服务
sudo iptables -I DOCKER-USER -s 172.30.1.0/24 -p tcp --dport 443 -j ACCEPT

# 阻止容器间未授权通信
sudo iptables -I DOCKER-USER -s 172.30.1.0/24 -d 172.30.3.0/24 -j DROP
EOF
    }
    
    configure_iptables_rules
}

# 容器安全扫描
container_security_scanning() {
    echo "3. 容器安全扫描"
    
    # 镜像安全扫描
    scan_image_vulnerabilities() {
        local image=$1
        
        if [ -z "$image" ]; then
            echo "用法: scan_image_vulnerabilities <镜像名>"
            return 1
        fi
        
        echo "扫描镜像安全漏洞: $image"
        
        # 使用Trivy扫描(如果安装)
        if command -v trivy >/dev/null 2>&1; then
            trivy image $image
        else
            echo "安装Trivy进行安全扫描:"
            echo "curl -sfL https://raw.githubusercontent.com/aquasecurity/trivy/main/contrib/install.sh | sh -s -- -b /usr/local/bin"
        fi
        
        # 使用Docker Bench Security(如果可用)
        if [ -f "/opt/docker-bench-security/docker-bench-security.sh" ]; then
            echo "运行Docker Bench Security:"
            sudo /opt/docker-bench-security/docker-bench-security.sh
        else
            echo "安装Docker Bench Security:"
            echo "git clone https://github.com/docker/docker-bench-security.git /opt/docker-bench-security"
        fi
    }
    
    echo "安全扫描函数已定义:"
    echo "scan_image_vulnerabilities <镜像名>"
}

network_isolation_strategy
firewall_rules_configuration
container_security_scanning

七、Docker Compose多容器编排

7.1 Compose文件编写

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
# docker-compose.yml - 完整的Web应用栈示例
version: '3.8'

services:
  # 反向代理
  nginx:
    image: nginx:alpine
    container_name: web-proxy
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
      - ./nginx/ssl:/etc/nginx/ssl:ro
      - web-static:/var/www/html
    depends_on:
      - web
    networks:
      - frontend
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  # Web应用
  web:
    build:
      context: ./web
      dockerfile: Dockerfile
      args:
        - NODE_ENV=production
    container_name: web-app
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgresql://user:password@db:5432/appdb
      - REDIS_URL=redis://redis:6379
    volumes:
      - web-static:/app/public
      - ./logs:/app/logs
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_started
    networks:
      - frontend
      - backend
    restart: unless-stopped
    deploy:
      resources:
        limits:
          cpus: '1.0'
          memory: 512M
        reservations:
          cpus: '0.5'
          memory: 256M

  # 数据库
  db:
    image: postgres:13-alpine
    container_name: database
    environment:
      - POSTGRES_DB=appdb
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD_FILE=/run/secrets/db_password
    volumes:
      - db-data:/var/lib/postgresql/data
      - ./db/init:/docker-entrypoint-initdb.d:ro
    networks:
      - backend
    restart: unless-stopped
    secrets:
      - db_password
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U user -d appdb"]
      interval: 10s
      timeout: 5s
      retries: 5

  # 缓存
  redis:
    image: redis:6-alpine
    container_name: cache
    command: redis-server --appendonly yes --requirepass ${REDIS_PASSWORD}
    volumes:
      - redis-data:/data
    networks:
      - backend
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 3s
      retries: 3

  # 监控
  prometheus:
    image: prom/prometheus:latest
    container_name: monitoring
    ports:
      - "9090:9090"
    volumes:
      - ./monitoring/prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - prometheus-data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--web.console.libraries=/etc/prometheus/console_libraries'
      - '--web.console.templates=/etc/prometheus/consoles'
    networks:
      - monitoring
    restart: unless-stopped

networks:
  frontend:
    driver: bridge
    ipam:
      config:
        - subnet: 172.20.1.0/24
  backend:
    driver: bridge
    internal: true
    ipam:
      config:
        - subnet: 172.20.2.0/24
  monitoring:
    driver: bridge
    ipam:
      config:
        - subnet: 172.20.3.0/24

volumes:
  db-data:
    driver: local
  redis-data:
    driver: local
  web-static:
    driver: local
  prometheus-data:
    driver: local

secrets:
  db_password:
    file: ./secrets/db_password.txt

7.2 Compose管理脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
#!/bin/bash
# Docker Compose管理脚本

echo "=== Docker Compose管理 ==="

# Compose项目管理
compose_project_management() {
    echo "1. Compose项目管理"
    
    # 项目初始化
    init_compose_project() {
        local project_name=$1
        
        if [ -z "$project_name" ]; then
            echo "用法: init_compose_project <项目名>"
            return 1
        fi
        
        echo "初始化Compose项目: $project_name"
        
        # 创建项目目录结构
        mkdir -p $project_name/{web,db,nginx,monitoring,secrets,logs}
        cd $project_name
        
        # 创建环境变量文件
        cat << 'EOF' > .env
# 项目配置
COMPOSE_PROJECT_NAME=myapp
COMPOSE_FILE=docker-compose.yml

# 数据库配置
POSTGRES_DB=appdb
POSTGRES_USER=user
POSTGRES_PASSWORD=changeme

# Redis配置
REDIS_PASSWORD=changeme

# 应用配置
NODE_ENV=production
APP_PORT=3000
EOF
        
        # 创建密钥文件
        echo "supersecretpassword" > secrets/db_password.txt
        chmod 600 secrets/db_password.txt
        
        # 创建基本的docker-compose.yml
        cat << 'EOF' > docker-compose.yml
version: '3.8'

services:
  web:
    image: nginx:alpine
    ports:
      - "80:80"
    restart: unless-stopped

networks:
  default:
    name: ${COMPOSE_PROJECT_NAME}_network
EOF
        
        echo "项目初始化完成: $project_name"
    }
    
    # 项目部署
    deploy_compose_project() {
        echo "部署Compose项目:"
        
        # 检查配置文件
        if [ ! -f "docker-compose.yml" ]; then
            echo "错误: 未找到docker-compose.yml文件"
            return 1
        fi
        
        # 验证配置
        echo "验证Compose配置:"
        docker-compose config
        
        # 拉取镜像
        echo "拉取所需镜像:"
        docker-compose pull
        
        # 构建自定义镜像
        echo "构建自定义镜像:"
        docker-compose build
        
        # 启动服务
        echo "启动服务:"
        docker-compose up -d
        
        # 检查服务状态
        echo "检查服务状态:"
        docker-compose ps
        
        # 查看日志
        echo "查看服务日志:"
        docker-compose logs --tail=50
    }
    
    echo "Compose项目管理函数已定义:"
    echo "init_compose_project <项目名>"
    echo "deploy_compose_project"
}

# 服务扩缩容管理
service_scaling_management() {
    echo "2. 服务扩缩容管理"
    
    # 服务扩容
    scale_service() {
        local service_name=$1
        local replicas=$2
        
        if [ -z "$service_name" ] || [ -z "$replicas" ]; then
            echo "用法: scale_service <服务名> <副本数>"
            return 1
        fi
        
        echo "扩容服务 $service_name 到 $replicas 个副本"
        docker-compose up -d --scale $service_name=$replicas
        
        # 检查扩容结果
        echo "扩容后的服务状态:"
        docker-compose ps $service_name
    }
    
    # 负载均衡配置
    configure_load_balancer() {
        echo "配置负载均衡:"
        
        # 创建nginx负载均衡配置
        cat << 'EOF' > nginx/nginx.conf
events {
    worker_connections 1024;
}

http {
    upstream web_backend {
        server web_1:3000;
        server web_2:3000;
        server web_3:3000;
    }
    
    server {
        listen 80;
        
        location / {
            proxy_pass http://web_backend;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }
        
        location /health {
            access_log off;
            return 200 "healthy\n";
            add_header Content-Type text/plain;
        }
    }
}
EOF
        
        echo "负载均衡配置已创建"
    }
    
    echo "服务扩缩容函数已定义:"
    echo "scale_service <服务名> <副本数>"
    echo "configure_load_balancer"
}

# 环境管理
environment_management() {
    echo "3. 环境管理"
    
    # 多环境配置
    setup_multi_environment() {
        echo "设置多环境配置:"
        
        # 开发环境
        cat << 'EOF' > docker-compose.dev.yml
version: '3.8'

services:
  web:
    build:
      context: ./web
      target: development
    volumes:
      - ./web:/app
      - /app/node_modules
    environment:
      - NODE_ENV=development
      - DEBUG=*
    ports:
      - "3000:3000"
      - "9229:9229"  # Debug port
EOF
        
        # 测试环境
        cat << 'EOF' > docker-compose.test.yml
version: '3.8'

services:
  web:
    build:
      context: ./web
      target: test
    environment:
      - NODE_ENV=test
      - CI=true
    command: npm test
EOF
        
        # 生产环境
        cat << 'EOF' > docker-compose.prod.yml
version: '3.8'

services:
  web:
    build:
      context: ./web
      target: production
    environment:
      - NODE_ENV=production
    deploy:
      replicas: 3
      resources:
        limits:
          cpus: '0.5'
          memory: 512M
      restart_policy:
        condition: on-failure
        delay: 5s
        max_attempts: 3
EOF
        
        echo "多环境配置文件已创建"
    }
    
    # 环境切换
    switch_environment() {
        local env=$1
        
        case "$env" in
            dev|development)
                echo "切换到开发环境"
                export COMPOSE_FILE="docker-compose.yml:docker-compose.dev.yml"
                ;;
            test)
                echo "切换到测试环境"
                export COMPOSE_FILE="docker-compose.yml:docker-compose.test.yml"
                ;;
            prod|production)
                echo "切换到生产环境"
                export COMPOSE_FILE="docker-compose.yml:docker-compose.prod.yml"
                ;;
            *)
                echo "不支持的环境: $env"
                echo "支持的环境: dev, test, prod"
                return 1
                ;;
        esac
        
        echo "当前Compose文件: $COMPOSE_FILE"
    }
    
    setup_multi_environment
    echo "环境管理函数已定义:"
    echo "switch_environment <环境名>"
}

compose_project_management
service_scaling_management
environment_management

八、生产环境部署与运维

8.1 生产环境最佳实践

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
#!/bin/bash
# 生产环境Docker部署脚本

echo "=== 生产环境Docker部署 ==="

# 生产环境安全配置
production_security_setup() {
    echo "1. 生产环境安全配置"
    
    # Docker守护进程安全配置
    configure_docker_daemon_security() {
        echo "配置Docker守护进程安全:"
        
        # 创建安全的daemon.json
        sudo mkdir -p /etc/docker
        cat << 'EOF' | sudo tee /etc/docker/daemon.json
{
  "hosts": ["unix:///var/run/docker.sock"],
  "tls": true,
  "tlscert": "/etc/docker/certs/server-cert.pem",
  "tlskey": "/etc/docker/certs/server-key.pem",
  "tlsverify": true,
  "tlscacert": "/etc/docker/certs/ca.pem",
  "storage-driver": "overlay2",
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
  },
  "live-restore": true,
  "userland-proxy": false,
  "no-new-privileges": true,
  "seccomp-profile": "/etc/docker/seccomp.json",
  "userns-remap": "default"
}
EOF
        
        # 重启Docker服务
        sudo systemctl daemon-reload
        sudo systemctl restart docker
        
        echo "Docker守护进程安全配置完成"
    }
    
    # 容器运行时安全
    configure_container_runtime_security() {
        echo "配置容器运行时安全:"
        
        # 创建安全的容器运行脚本
        cat << 'EOF' > /tmp/secure_container_run.sh
#!/bin/bash
# 安全的容器运行脚本

IMAGE=$1
CONTAINER_NAME=$2

if [ -z "$IMAGE" ] || [ -z "$CONTAINER_NAME" ]; then
    echo "用法: $0 <镜像名> <容器名>"
    exit 1
fi

# 安全参数运行容器
docker run -d \
    --name "$CONTAINER_NAME" \
    --read-only \
    --tmpfs /tmp:rw,noexec,nosuid,size=100m \
    --tmpfs /var/run:rw,noexec,nosuid,size=50m \
    --no-new-privileges \
    --cap-drop ALL \
    --cap-add NET_BIND_SERVICE \
    --security-opt no-new-privileges:true \
    --security-opt seccomp=unconfined \
    --user 1000:1000 \
    --memory 512m \
    --cpus 0.5 \
    --restart unless-stopped \
    "$IMAGE"
EOF
        
        chmod +x /tmp/secure_container_run.sh
        echo "安全容器运行脚本已创建: /tmp/secure_container_run.sh"
    }
    
    configure_docker_daemon_security
    configure_container_runtime_security
}

# 监控和日志配置
monitoring_logging_setup() {
    echo "2. 监控和日志配置"
    
    # 容器监控配置
    setup_container_monitoring() {
        echo "设置容器监控:"
        
        # 创建监控docker-compose.yml
        cat << 'EOF' > monitoring-stack.yml
version: '3.8'

services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./monitoring/prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - prometheus-data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--web.console.libraries=/etc/prometheus/console_libraries'
      - '--web.console.templates=/etc/prometheus/consoles'
      - '--storage.tsdb.retention.time=30d'
    restart: unless-stopped
    networks:
      - monitoring

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin123
      - GF_USERS_ALLOW_SIGN_UP=false
    volumes:
      - grafana-data:/var/lib/grafana
      - ./monitoring/grafana/dashboards:/etc/grafana/provisioning/dashboards:ro
      - ./monitoring/grafana/datasources:/etc/grafana/provisioning/datasources:ro
    restart: unless-stopped
    networks:
      - monitoring

  node-exporter:
    image: prom/node-exporter:latest
    container_name: node-exporter
    ports:
      - "9100:9100"
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro
    command:
      - '--path.procfs=/host/proc'
      - '--path.sysfs=/host/sys'
      - '--collector.filesystem.ignored-mount-points=^/(sys|proc|dev|host|etc)($$|/)'
    restart: unless-stopped
    networks:
      - monitoring

  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    container_name: cadvisor
    ports:
      - "8080:8080"
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:rw
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
    restart: unless-stopped
    networks:
      - monitoring

volumes:
  prometheus-data:
  grafana-data:

networks:
  monitoring:
    driver: bridge
EOF
        
        echo "监控栈配置已创建"
    }
    
    # 日志聚合配置
    setup_log_aggregation() {
        echo "设置日志聚合:"
        
        # ELK Stack配置
        cat << 'EOF' > logging-stack.yml
version: '3.8'

services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.15.0
    container_name: elasticsearch
    environment:
      - discovery.type=single-node
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
    volumes:
      - elasticsearch-data:/usr/share/elasticsearch/data
    ports:
      - "9200:9200"
    restart: unless-stopped
    networks:
      - logging

  logstash:
    image: docker.elastic.co/logstash/logstash:7.15.0
    container_name: logstash
    volumes:
      - ./logging/logstash.conf:/usr/share/logstash/pipeline/logstash.conf:ro
    ports:
      - "5044:5044"
    depends_on:
      - elasticsearch
    restart: unless-stopped
    networks:
      - logging

  kibana:
    image: docker.elastic.co/kibana/kibana:7.15.0
    container_name: kibana
    environment:
      - ELASTICSEARCH_HOSTS=http://elasticsearch:9200
    ports:
      - "5601:5601"
    depends_on:
      - elasticsearch
    restart: unless-stopped
    networks:
      - logging

  filebeat:
    image: docker.elastic.co/beats/filebeat:7.15.0
    container_name: filebeat
    user: root
    volumes:
      - ./logging/filebeat.yml:/usr/share/filebeat/filebeat.yml:ro
      - /var/lib/docker/containers:/var/lib/docker/containers:ro
      - /var/run/docker.sock:/var/run/docker.sock:ro
    depends_on:
      - logstash
    restart: unless-stopped
    networks:
      - logging

volumes:
  elasticsearch-data:

networks:
  logging:
    driver: bridge
EOF
        
        echo "日志聚合配置已创建"
    }
    
    setup_container_monitoring
    setup_log_aggregation
}

production_security_setup
monitoring_logging_setup

8.2 故障排查与维护

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
#!/bin/bash
# Docker故障排查与维护脚本

echo "=== Docker故障排查与维护 ==="

# 常见问题诊断
common_issues_diagnosis() {
    echo "1. 常见问题诊断"
    
    # 系统资源检查
    check_system_resources() {
        echo "检查系统资源:"
        
        # 磁盘空间
        echo "磁盘空间使用情况:"
        df -h
        
        # Docker磁盘使用
        echo "Docker磁盘使用情况:"
        docker system df
        
        # 内存使用
        echo "内存使用情况:"
        free -h
        
        # CPU使用
        echo "CPU使用情况:"
        top -bn1 | head -5
        
        # Docker守护进程状态
        echo "Docker守护进程状态:"
        systemctl status docker
    }
    
    # 容器健康检查
    check_container_health() {
        echo "检查容器健康状态:"
        
        # 运行中的容器
        echo "运行中的容器:"
        docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"
        
        # 退出的容器
        echo "退出的容器:"
        docker ps -a --filter "status=exited" --format "table {{.Names}}\t{{.Status}}\t{{.ExitCode}}"
        
        # 容器资源使用
        echo "容器资源使用:"
        docker stats --no-stream --format "table {{.Container}}\t{{.CPUPerc}}\t{{.MemUsage}}\t{{.NetIO}}\t{{.BlockIO}}"
    }
    
    # 网络连接检查
    check_network_connectivity() {
        echo "检查网络连接:"
        
        # Docker网络列表
        echo "Docker网络列表:"
        docker network ls
        
        # 端口监听
        echo "端口监听情况:"
        netstat -tlnp | grep docker
        
        # DNS解析测试
        echo "DNS解析测试:"
        nslookup google.com
    }
    
    check_system_resources
    check_container_health
    check_network_connectivity
}

# 日志分析
log_analysis() {
    echo "2. 日志分析"
    
    # Docker守护进程日志
    analyze_docker_daemon_logs() {
        echo "分析Docker守护进程日志:"
        
        # 系统日志中的Docker信息
        echo "最近的Docker守护进程日志:"
        journalctl -u docker.service --since "1 hour ago" --no-pager
        
        # 错误日志
        echo "Docker错误日志:"
        journalctl -u docker.service -p err --since "1 day ago" --no-pager
    }
    
    # 容器日志分析
    analyze_container_logs() {
        local container_name=$1
        
        if [ -z "$container_name" ]; then
            echo "用法: analyze_container_logs <容器名>"
            return 1
        fi
        
        echo "分析容器日志: $container_name"
        
        # 最近的日志
        echo "最近的容器日志:"
        docker logs --since 1h $container_name
        
        # 错误日志
        echo "容器错误日志:"
        docker logs $container_name 2>&1 | grep -i error
        
        # 日志统计
        echo "日志统计:"
        docker logs $container_name 2>&1 | wc -l
    }
    
    analyze_docker_daemon_logs
    echo "容器日志分析函数已定义:"
    echo "analyze_container_logs <容器名>"
}

# 性能优化
performance_optimization() {
    echo "3. 性能优化"
    
    # 镜像优化
    optimize_images() {
        echo "镜像优化建议:"
        
        # 查找大镜像
        echo "最大的镜像:"
        docker images --format "table {{.Repository}}\t{{.Tag}}\t{{.Size}}" | sort -k3 -hr | head -10
        
        # 查找悬空镜像
        echo "悬空镜像:"
        docker images -f "dangling=true"
        
        # 清理建议
        echo "清理建议:"
        echo "1. 删除悬空镜像: docker image prune"
        echo "2. 删除未使用镜像: docker image prune -a"
        echo "3. 使用多阶段构建减小镜像大小"
        echo "4. 使用.dockerignore文件"
    }
    
    # 容器优化
    optimize_containers() {
        echo "容器优化建议:"
        
        # 资源限制检查
        echo "检查容器资源限制:"
        docker ps --format "table {{.Names}}" | tail -n +2 | while read container; do
            echo "容器: $container"
            docker inspect $container --format '{{.HostConfig.Memory}}' | sed 's/0/无内存限制/'
            docker inspect $container --format '{{.HostConfig.CpuShares}}' | sed 's/0/无CPU限制/'
        done
        
        echo "优化建议:"
        echo "1. 为容器设置适当的资源限制"
        echo "2. 使用健康检查"
        echo "3. 配置重启策略"
        echo "4. 避免在容器中运行多个进程"
    }
    
    optimize_images
    optimize_containers
}

common_issues_diagnosis
log_analysis
performance_optimization

九、Docker最佳实践总结

9.1 开发最佳实践

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
#!/bin/bash
# Docker开发最佳实践脚本

echo "=== Docker开发最佳实践 ==="

# Dockerfile最佳实践
dockerfile_best_practices() {
    echo "1. Dockerfile最佳实践"
    
    cat << 'EOF'
Dockerfile编写最佳实践:

1. 使用官方基础镜像
   FROM node:16-alpine

2. 合并RUN指令减少层数
   RUN apt-get update && apt-get install -y \
       package1 \
       package2 && \
       rm -rf /var/lib/apt/lists/*

3. 利用构建缓存
   COPY package*.json ./
   RUN npm install
   COPY . .

4. 使用多阶段构建
   FROM node:16 AS builder
   # 构建阶段
   FROM node:16-alpine AS runtime
   # 运行阶段

5. 设置非root用户
   RUN addgroup -g 1001 -S nodejs
   RUN adduser -S nextjs -u 1001
   USER nextjs

6. 使用.dockerignore
   node_modules
   .git
   *.md

7. 添加健康检查
   HEALTHCHECK --interval=30s --timeout=3s \
     CMD curl -f http://localhost/ || exit 1

8. 设置适当的标签
   LABEL maintainer="your-email@example.com"
   LABEL version="1.0"
EOF
}

# 安全最佳实践
security_best_practices() {
    echo "2. 安全最佳实践"
    
    cat << 'EOF'
Docker安全最佳实践:

1. 使用最新的基础镜像
   - 定期更新基础镜像
   - 使用官方镜像
   - 扫描镜像漏洞

2. 最小权限原则
   - 不使用root用户运行容器
   - 删除不必要的权限
   - 使用只读文件系统

3. 网络安全
   - 使用自定义网络
   - 限制容器间通信
   - 配置防火墙规则

4. 密钥管理
   - 使用Docker secrets
   - 不在镜像中存储密钥
   - 使用环境变量注入密钥

5. 资源限制
   - 设置内存限制
   - 设置CPU限制
   - 限制文件描述符数量

6. 日志安全
   - 不在日志中记录敏感信息
   - 配置日志轮转
   - 集中化日志管理
EOF
}

# 性能最佳实践
performance_best_practices() {
    echo "3. 性能最佳实践"
    
    cat << 'EOF'
Docker性能最佳实践:

1. 镜像优化
   - 使用Alpine Linux基础镜像
   - 多阶段构建
   - 删除不必要的文件
   - 压缩镜像层

2. 容器配置
   - 设置适当的资源限制
   - 使用健康检查
   - 配置重启策略
   - 避免特权模式

3. 存储优化
   - 使用数据卷存储持久数据
   - 选择合适的存储驱动
   - 定期清理无用数据
   - 使用tmpfs存储临时数据

4. 网络优化
   - 使用host网络模式(适当时)
   - 优化网络驱动选择
   - 减少网络跳数
   - 使用负载均衡

5. 监控和调优
   - 监控容器资源使用
   - 分析性能瓶颈
   - 优化应用程序
   - 使用性能分析工具
EOF
}

dockerfile_best_practices
security_best_practices
performance_best_practices

9.2 运维最佳实践

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
#!/bin/bash
# Docker运维最佳实践脚本

echo "=== Docker运维最佳实践 ==="

# 部署策略
deployment_strategies() {
    echo "1. 部署策略"
    
    cat << 'EOF'
Docker部署策略:

1. 蓝绿部署
   - 维护两个相同的生产环境
   - 零停机时间部署
   - 快速回滚能力

2. 滚动更新
   - 逐步替换旧版本容器
   - 保持服务可用性
   - 渐进式部署

3. 金丝雀部署
   - 小规模测试新版本
   - 风险控制
   - 逐步扩大部署范围

4. A/B测试部署
   - 同时运行多个版本
   - 基于用户特征路由
   - 数据驱动决策
EOF
}

# 监控策略
monitoring_strategies() {
    echo "2. 监控策略"
    
    cat << 'EOF'
Docker监控策略:

1. 基础设施监控
   - 主机资源监控
   - Docker守护进程监控
   - 网络监控
   - 存储监控

2. 容器监控
   - 容器资源使用
   - 容器健康状态
   - 容器生命周期
   - 容器性能指标

3. 应用监控
   - 应用性能监控(APM)
   - 业务指标监控
   - 用户体验监控
   - 错误率监控

4. 日志监控
   - 集中化日志收集
   - 日志分析和告警
   - 日志保留策略
   - 安全日志审计
EOF
}

# 备份策略
backup_strategies() {
    echo "3. 备份策略"
    
    cat << 'EOF'
Docker备份策略:

1. 数据备份
   - 数据卷备份
   - 数据库备份
   - 配置文件备份
   - 定期备份验证

2. 镜像备份
   - 镜像仓库备份
   - 镜像版本管理
   - 跨区域备份
   - 备份加密

3. 配置备份
   - Docker Compose文件
   - 环境变量
   - 网络配置
   - 密钥和证书

4. 恢复测试
   - 定期恢复演练
   - 恢复时间目标(RTO)
   - 恢复点目标(RPO)
   - 灾难恢复计划
EOF
}

deployment_strategies
monitoring_strategies
backup_strategies

十、总结

Docker容器化技术已经成为现代应用程序开发和部署的标准实践。通过本文的深入探讨，我们涵盖了从Docker基础概念到生产环境部署的完整知识体系：

核心收获

  1. 容器化基础：掌握了Docker的核心概念、架构组件和基本操作
  2. 镜像管理：学会了镜像构建、优化和仓库管理的最佳实践
  3. 容器编排：深入了解了Docker Compose多容器应用编排
  4. 网络配置：掌握了容器网络管理和安全隔离策略
  5. 数据管理：学会了数据卷管理、备份恢复和持久化存储
  6. 生产部署：了解了生产环境的安全配置、监控和运维实践

实践要点

  • 安全第一：始终遵循最小权限原则，定期更新镜像，配置适当的安全策略
  • 性能优化：合理设置资源限制，优化镜像大小，监控容器性能
  • 可维护性：编写清晰的Dockerfile，使用标准化的部署流程，建立完善的监控体系
  • 可扩展性：设计支持水平扩展的架构，使用负载均衡和服务发现

发展趋势

随着云原生技术的发展，Docker容器化技术将继续演进：

  • Kubernetes集成：容器编排向Kubernetes生态发展
  • 无服务器容器：Serverless容器服务的兴起
  • 安全增强：更强的容器安全和隔离技术
  • 边缘计算：容器在边缘计算场景的应用

掌握Docker容器化技术不仅能提高开发效率，还能为云原生架构转型奠定坚实基础。在实际应用中，建议结合具体业务场景，逐步实施容器化改造，持续优化和完善容器化解决方案。

本文提供的所有脚本和配置仅供学习参考，在生产环境使用前请根据实际需求进行适当调整和测试。

  1. Linux容器化技术与Docker实战指南：从入门到生产环境的完整解决方案
    1. 前言
    2. 一、Docker基础概念与架构
      1. 1.1 Docker核心概念
      2. 1.2 Docker架构组件
    3. 二、Docker安装与配置
      1. 2.1 Docker安装脚本
      2. 2.2 Docker Compose安装
    4. 三、容器生命周期管理
      1. 3.1 容器基本操作
      2. 3.2 容器监控和调试
    5. 四、Docker镜像管理
      1. 4.1 镜像构建与优化
      2. 4.2 镜像仓库管理
    6. 五、容器数据管理与备份
      1. 5.1 数据卷管理
      2. 5.2 容器备份与恢复
    7. 六、Docker网络配置
      1. 6.1 网络驱动和模式
      2. 6.2 网络安全和隔离
    8. 七、Docker Compose多容器编排
      1. 7.1 Compose文件编写
      2. 7.2 Compose管理脚本
    9. 八、生产环境部署与运维
      1. 8.1 生产环境最佳实践
      2. 8.2 故障排查与维护
    10. 九、Docker最佳实践总结
      1. 9.1 开发最佳实践
      2. 9.2 运维最佳实践
    11. 十、总结
      1. 核心收获
      2. 实践要点
      3. 发展趋势
© 2025    Orion K
本站由 提供部署服务
  1. Linux容器化技术与Docker实战指南：从入门到生产环境的完整解决方案
    1. 前言
    2. 一、Docker基础概念与架构
      1. 1.1 Docker核心概念
      2. 1.2 Docker架构组件
    3. 二、Docker安装与配置
      1. 2.1 Docker安装脚本
      2. 2.2 Docker Compose安装
    4. 三、容器生命周期管理
      1. 3.1 容器基本操作
      2. 3.2 容器监控和调试
    5. 四、Docker镜像管理
      1. 4.1 镜像构建与优化
      2. 4.2 镜像仓库管理
    6. 五、容器数据管理与备份
      1. 5.1 数据卷管理
      2. 5.2 容器备份与恢复
    7. 六、Docker网络配置
      1. 6.1 网络驱动和模式
      2. 6.2 网络安全和隔离
    8. 七、Docker Compose多容器编排
      1. 7.1 Compose文件编写
      2. 7.2 Compose管理脚本
    9. 八、生产环境部署与运维
      1. 8.1 生产环境最佳实践
      2. 8.2 故障排查与维护
    10. 九、Docker最佳实践总结
      1. 9.1 开发最佳实践
      2. 9.2 运维最佳实践
    11. 十、总结
      1. 核心收获
      2. 实践要点
      3. 发展趋势