# docker-docs

**Repository Path**: ukiot/docker-docs

## Basic Information

- **Project Name**: docker-docs
- **Description**: Docker 使用说明文档
- **Primary Language**: Unknown
- **License**: MIT
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-06-26
- **Last Updated**: 2025-11-02

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Docker 使用说明书

## 目录
1. [Docker 基础概念](#docker-基础概念)
2. [Docker 安装](#docker-安装)
3. [Docker 基础命令](#docker-基础命令)
4. [Docker Compose 基础](#docker-compose-基础)
5. [数据库部署说明](#数据库部署说明)
   - [MySQL](#mysql)
   - [Redis](#redis)
   - [PostgreSQL](#postgresql)
   - [InfluxDB](#influxdb)
6. [Web服务器部署](#web服务器部署)
   - [Nginx](#nginx)
7. [消息队列部署](#消息队列部署)
   - [MQTT (Eclipse Mosquitto)](#mqtt-eclipse-mosquitto)
   - [EMQX](#emqx)

---

## Docker 基础概念

Docker 是一个开源的容器化平台，允许开发者将应用程序及其依赖项打包到轻量级、可移植的容器中。

### 核心概念
- **镜像 (Image)**: 容器的模板，包含运行应用程序所需的所有文件
- **容器 (Container)**: 镜像的运行实例
- **仓库 (Repository)**: 存储镜像的地方
- **Dockerfile**: 用于构建镜像的文本文件

---

## Docker 安装

### Windows 安装
1. 下载 Docker Desktop for Windows
2. 运行安装程序
3. 启动 Docker Desktop
4. 验证安装：
```bash
docker --version
docker-compose --version
```

### Linux 安装
```bash
# Ubuntu/Debian
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# 启动 Docker 服务
sudo systemctl start docker
sudo systemctl enable docker

# 将用户添加到 docker 组
sudo usermod -aG docker $USER
```

### Docker仓库
```
/etc/docker/daemon.json
{
  "registry-mirrors": [
    "https://docker.m.daocloud.io/",
    "https://registry.docker-cn.com/",
    "https://quay.mirrors.ustc.edu.cn/",
    "https://hub-mirror.c.163.com/",
    "https://dockerhub.icu/"
  ]
}
```
---

## Docker 基础命令

### 镜像管理
```bash
# 搜索镜像
docker search <镜像名>

# 拉取镜像
docker pull <镜像名>:<标签>

# 查看本地镜像
docker images

# 删除镜像
docker rmi <镜像ID>

# 构建镜像
docker build -t <镜像名>:<标签> <Dockerfile路径>

# 给镜像打标签
docker tag <源镜像> <目标镜像>
```

### 容器管理
```bash
# 运行容器
docker run [选项] <镜像名>

# 常用选项
-d          # 后台运行
-p 8080:80  # 端口映射 (主机端口:容器端口)
-v /host:/container  # 挂载卷
--name <名称>        # 指定容器名称
-e ENV_VAR=value     # 设置环境变量
--rm                 # 容器停止后自动删除

# 查看运行中的容器
docker ps

# 查看所有容器
docker ps -a

# 停止容器
docker stop <容器ID/名称>

# 启动容器
docker start <容器ID/名称>

# 重启容器
docker restart <容器ID/名称>

# 删除容器
docker rm <容器ID/名称>

# 进入容器
docker exec -it <容器ID/名称> /bin/bash

# 查看容器日志
docker logs <容器ID/名称>

# 查看容器详细信息
docker inspect <容器ID/名称>
```

### 网络管理
```bash
# 查看网络
docker network ls

# 创建网络
docker network create <网络名>

# 删除网络
docker network rm <网络名>

# 将容器连接到网络
docker network connect <网络名> <容器名>
```

### 数据卷管理
```bash
# 查看数据卷
docker volume ls

# 创建数据卷
docker volume create <卷名>

# 删除数据卷
docker volume rm <卷名>

# 查看数据卷详情
docker volume inspect <卷名>
```

---

## Docker Compose 基础

Docker Compose 用于定义和运行多容器 Docker 应用程序。

### 基本命令
```bash
# 启动服务
docker-compose up -d

# 停止服务
docker-compose down

# 查看服务状态
docker-compose ps

# 查看日志
docker-compose logs [服务名]

# 重启服务
docker-compose restart [服务名]

# 构建服务
docker-compose build

# 拉取镜像
docker-compose pull
```

### docker-compose.yml 基本结构
```yaml
version: '3.8'
services:
  web:
    build: .
    ports:
      - "8000:8000"
    volumes:
      - .:/code
    environment:
      - DEBUG=1
  db:
    image: postgres:13
    environment:
      - POSTGRES_DB=mydb
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=password
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:
```

---

## 数据库部署说明

### MySQL

#### 快速启动 MySQL
```bash
# 基本启动
docker run --name mysql-server -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:8.0

# 完整配置启动
docker run --name mysql-server \
  -e MYSQL_ROOT_PASSWORD=rootpassword \
  -e MYSQL_DATABASE=mydb \
  -e MYSQL_USER=myuser \
  -e MYSQL_PASSWORD=mypassword \
  -p 3306:3306 \
  -v mysql-data:/var/lib/mysql \
  -d mysql:8.0
```

#### MySQL Docker Compose 配置
```yaml
version: '3.8'
services:
  mysql:
    image: mysql:8.0
    container_name: mysql-server
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_DATABASE: myapp
      MYSQL_USER: appuser
      MYSQL_PASSWORD: apppassword
    ports:
      - "3306:3306"
    volumes:
      - mysql_data:/var/lib/mysql
      - ./mysql/conf.d:/etc/mysql/conf.d
      - ./mysql/init:/docker-entrypoint-initdb.d
    command: --default-authentication-plugin=mysql_native_password

volumes:
  mysql_data:
```

#### 连接到 MySQL
```bash
# 使用 Docker 命令连接
docker exec -it mysql-server mysql -u root -p

# 使用外部客户端连接
mysql -h localhost -P 3306 -u root -p
```

#### MySQL 配置文件示例 (my.cnf)
```ini
[mysqld]
character-set-server=utf8mb4
collation-server=utf8mb4_unicode_ci
max_connections=200
innodb_buffer_pool_size=1G
slow_query_log=1
slow_query_log_file=/var/log/mysql/slow.log
long_query_time=2
```

---

### Redis

#### 快速启动 Redis
```bash
# 基本启动
docker run --name redis-server -d redis:7-alpine

# 带密码启动
docker run --name redis-server -d redis:7-alpine redis-server --requirepass mypassword

# 完整配置启动
docker run --name redis-server \
  -p 6379:6379 \
  -v redis-data:/data \
  -v $(pwd)/redis.conf:/usr/local/etc/redis/redis.conf \
  -d redis:7-alpine redis-server /usr/local/etc/redis/redis.conf
```

#### Redis Docker Compose 配置
```yaml
version: '3.8'
services:
  redis:
    image: redis:7-alpine
    container_name: redis-server
    restart: always
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
      - ./redis/redis.conf:/usr/local/etc/redis/redis.conf
    command: redis-server /usr/local/etc/redis/redis.conf
    environment:
      - REDIS_PASSWORD=mypassword

  redis-commander:
    image: rediscommander/redis-commander:latest
    container_name: redis-commander
    restart: always
    environment:
      - REDIS_HOSTS=local:redis:6379
      - REDIS_PASSWORD=mypassword
    ports:
      - "8081:8081"
    depends_on:
      - redis

volumes:
  redis_data:
```

#### 连接到 Redis
```bash
# 使用 Docker 命令连接
docker exec -it redis-server redis-cli

# 带密码连接
docker exec -it redis-server redis-cli -a mypassword
```

#### Redis 配置文件示例 (redis.conf)
```conf
# 监听端口
port 6379

# 设置密码
requirepass mypassword

# 数据持久化
save 900 1
save 300 10
save 60 10000

# AOF 持久化
appendonly yes
appendfilename "appendonly.aof"

# 最大内存
maxmemory 2gb
maxmemory-policy allkeys-lru

# 日志级别
loglevel notice
```

---

### PostgreSQL

#### 快速启动 PostgreSQL
```bash
# 基本启动
docker run --name postgres-server -e POSTGRES_PASSWORD=mypassword -d postgres:15

# 完整配置启动
docker run --name postgres-server \
  -e POSTGRES_DB=mydb \
  -e POSTGRES_USER=myuser \
  -e POSTGRES_PASSWORD=mypassword \
  -p 5432:5432 \
  -v postgres-data:/var/lib/postgresql/data \
  -d postgres:15
```

#### PostgreSQL Docker Compose 配置
```yaml
version: '3.8'
services:
  postgres:
    image: postgres:15
    container_name: postgres-server
    restart: always
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: appuser
      POSTGRES_PASSWORD: apppassword
      POSTGRES_INITDB_ARGS: "--encoding=UTF-8"
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./postgres/init:/docker-entrypoint-initdb.d
      - ./postgres/postgresql.conf:/etc/postgresql/postgresql.conf
    command: postgres -c config_file=/etc/postgresql/postgresql.conf

  pgadmin:
    image: dpage/pgadmin4:latest
    container_name: pgadmin
    restart: always
    environment:
      PGADMIN_DEFAULT_EMAIL: admin@example.com
      PGADMIN_DEFAULT_PASSWORD: adminpassword
    ports:
      - "8080:80"
    volumes:
      - pgadmin_data:/var/lib/pgadmin
    depends_on:
      - postgres

volumes:
  postgres_data:
  pgadmin_data:
```

#### 连接到 PostgreSQL
```bash
# 使用 Docker 命令连接
docker exec -it postgres-server psql -U myuser -d mydb

# 使用 psql 客户端连接
psql -h localhost -p 5432 -U myuser -d mydb
```

---

### InfluxDB

#### 快速启动 InfluxDB
```bash
# InfluxDB 2.x
docker run --name influxdb-server \
  -p 8086:8086 \
  -e DOCKER_INFLUXDB_INIT_MODE=setup \
  -e DOCKER_INFLUXDB_INIT_USERNAME=admin \
  -e DOCKER_INFLUXDB_INIT_PASSWORD=adminpassword \
  -e DOCKER_INFLUXDB_INIT_ORG=myorg \
  -e DOCKER_INFLUXDB_INIT_BUCKET=mybucket \
  -v influxdb-data:/var/lib/influxdb2 \
  -d influxdb:2.7
```

#### InfluxDB Docker Compose 配置
```yaml
version: '3.8'
services:
  influxdb:
    image: influxdb:2.7
    container_name: influxdb-server
    restart: always
    ports:
      - "8086:8086"
    environment:
      - DOCKER_INFLUXDB_INIT_MODE=setup
      - DOCKER_INFLUXDB_INIT_USERNAME=admin
      - DOCKER_INFLUXDB_INIT_PASSWORD=adminpassword
      - DOCKER_INFLUXDB_INIT_ORG=myorg
      - DOCKER_INFLUXDB_INIT_BUCKET=mybucket
      - DOCKER_INFLUXDB_INIT_ADMIN_TOKEN=my-super-secret-auth-token
    volumes:
      - influxdb_data:/var/lib/influxdb2
      - influxdb_config:/etc/influxdb2

  chronograf:
    image: chronograf:1.10
    container_name: chronograf
    restart: always
    ports:
      - "8888:8888"
    environment:
      - INFLUXDB_URL=http://influxdb:8086
    depends_on:
      - influxdb

volumes:
  influxdb_data:
  influxdb_config:
```

#### 连接到 InfluxDB
```bash
# 使用 influx CLI
docker exec -it influxdb-server influx

# 或者访问 Web UI
# http://localhost:8086
```

---

## Web服务器部署

### Nginx

#### 快速启动 Nginx
```bash
# 基本启动
docker run --name nginx-server -p 80:80 -d nginx:alpine

# 挂载配置文件
docker run --name nginx-server \
  -p 80:80 \
  -p 443:443 \
  -v $(pwd)/nginx.conf:/etc/nginx/nginx.conf \
  -v $(pwd)/html:/usr/share/nginx/html \
  -v $(pwd)/ssl:/etc/nginx/ssl \
  -d nginx:alpine
```

#### Nginx Docker Compose 配置
```yaml
version: '3.8'
services:
  nginx:
    image: nginx:alpine
    container_name: nginx-server
    restart: always
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf
      - ./nginx/conf.d:/etc/nginx/conf.d
      - ./html:/usr/share/nginx/html
      - ./ssl:/etc/nginx/ssl
      - ./logs:/var/log/nginx
    depends_on:
      - app

  app:
    image: myapp:latest
    container_name: myapp
    restart: always
    expose:
      - "3000"
```

#### Nginx 配置文件示例
```nginx
events {
    worker_connections 1024;
}

http {
    include /etc/nginx/mime.types;
    default_type application/octet-stream;

    log_format main '$remote_addr - $remote_user [$time_local] "$request" '
                    '$status $body_bytes_sent "$http_referer" '
                    '"$http_user_agent" "$http_x_forwarded_for"';

    access_log /var/log/nginx/access.log main;
    error_log /var/log/nginx/error.log;

    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    keepalive_timeout 65;
    types_hash_max_size 2048;

    # Gzip 压缩
    gzip on;
    gzip_vary on;
    gzip_min_length 1024;
    gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;

    # 负载均衡
    upstream backend {
        server app1:3000;
        server app2:3000;
    }

    server {
        listen 80;
        server_name example.com;

        location / {
            proxy_pass http://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;
            proxy_set_header X-Forwarded-Proto $scheme;
        }

        # 静态文件
        location /static/ {
            alias /usr/share/nginx/html/static/;
            expires 30d;
            add_header Cache-Control "public, immutable";
        }
    }
}
```

---

## 消息队列部署

### MQTT (Eclipse Mosquitto)

#### 快速启动 Mosquitto
```bash
# 基本启动
docker run --name mosquitto-server -p 1883:1883 -d eclipse-mosquitto:2.0

# 带配置文件启动
docker run --name mosquitto-server \
  -p 1883:1883 \
  -p 9001:9001 \
  -v $(pwd)/mosquitto.conf:/mosquitto/config/mosquitto.conf \
  -v $(pwd)/data:/mosquitto/data \
  -v $(pwd)/log:/mosquitto/log \
  -d eclipse-mosquitto:2.0
```

#### Mosquitto Docker Compose 配置
```yaml
version: '3.8'
services:
  mosquitto:
    image: eclipse-mosquitto:2.0
    container_name: mosquitto-server
    restart: always
    ports:
      - "1883:1883"  # MQTT
      - "9001:9001"  # WebSocket
    volumes:
      - ./mosquitto/config:/mosquitto/config
      - ./mosquitto/data:/mosquitto/data
      - ./mosquitto/log:/mosquitto/log
    environment:
      - MOSQUITTO_USERNAME=mqtt_user
      - MOSQUITTO_PASSWORD=mqtt_password

volumes:
  mosquitto_data:
  mosquitto_log:
```

#### Mosquitto 配置文件 (mosquitto.conf)
```conf
# 监听端口
listener 1883
protocol mqtt

# WebSocket 支持
listener 9001
protocol websockets

# 持久化
persistence true
persistence_location /mosquitto/data/

# 日志
log_dest file /mosquitto/log/mosquitto.log
log_type error
log_type warning
log_type notice
log_type information

# 连接日志
connection_messages true

# 认证
allow_anonymous false
password_file /mosquitto/config/passwd

# ACL 访问控制
acl_file /mosquitto/config/acl
```

#### 测试 MQTT 连接
```bash
# 订阅主题
docker exec -it mosquitto-server mosquitto_sub -h localhost -t test/topic

# 发布消息
docker exec -it mosquitto-server mosquitto_pub -h localhost -t test/topic -m "Hello MQTT"
```

---

### EMQX

#### 快速启动 EMQX
```bash
# 基本启动
docker run --name emqx-server -p 1883:1883 -p 8083:8083 -p 8084:8084 -p 18083:18083 -d emqx/emqx:5.0
```

#### EMQX Docker Compose 配置
```yaml
version: '3.8'
services:
  emqx:
    image: emqx/emqx:5.0
    container_name: emqx-server
    restart: always
    ports:
      - "1883:1883"    # MQTT
      - "8083:8083"    # MQTT/WebSocket
      - "8084:8084"    # MQTT/SSL
      - "8883:8883"    # MQTT/SSL
      - "18083:18083"  # Dashboard
    volumes:
      - emqx_data:/opt/emqx/data
      - emqx_log:/opt/emqx/log
      - ./emqx/etc:/opt/emqx/etc
    environment:
      - EMQX_NAME=emqx
      - EMQX_HOST=127.0.0.1
      - EMQX_DASHBOARD__DEFAULT_USERNAME=admin
      - EMQX_DASHBOARD__DEFAULT_PASSWORD=public

volumes:
  emqx_data:
  emqx_log:
```

#### EMQX 管理界面
访问 http://localhost:18083
- 默认用户名: admin
- 默认密码: public

#### 测试 EMQX 连接
```bash
# 使用 EMQX 内置客户端测试
docker exec -it emqx-server emqx_ctl broker

# 查看连接状态
docker exec -it emqx-server emqx_ctl status
```

---

## 完整的多服务部署示例

### 完整的 Docker Compose 配置
```yaml
version: '3.8'

services:
  # MySQL 数据库
  mysql:
    image: mysql:8.0
    container_name: mysql-server
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_DATABASE: appdb
      MYSQL_USER: appuser
      MYSQL_PASSWORD: apppassword
    ports:
      - "3306:3306"
    volumes:
      - mysql_data:/var/lib/mysql
    networks:
      - app-network

  # Redis 缓存
  redis:
    image: redis:7-alpine
    container_name: redis-server
    restart: always
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    networks:
      - app-network

  # PostgreSQL 数据库
  postgres:
    image: postgres:15
    container_name: postgres-server
    restart: always
    environment:
      POSTGRES_DB: appdb
      POSTGRES_USER: appuser
      POSTGRES_PASSWORD: apppassword
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - app-network

  # InfluxDB 时序数据库
  influxdb:
    image: influxdb:2.7
    container_name: influxdb-server
    restart: always
    ports:
      - "8086:8086"
    environment:
      - DOCKER_INFLUXDB_INIT_MODE=setup
      - DOCKER_INFLUXDB_INIT_USERNAME=admin
      - DOCKER_INFLUXDB_INIT_PASSWORD=adminpassword
      - DOCKER_INFLUXDB_INIT_ORG=myorg
      - DOCKER_INFLUXDB_INIT_BUCKET=mybucket
    volumes:
      - influxdb_data:/var/lib/influxdb2
    networks:
      - app-network

  # Nginx 反向代理
  nginx:
    image: nginx:alpine
    container_name: nginx-server
    restart: always
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf
      - ./nginx/conf.d:/etc/nginx/conf.d
      - ./ssl:/etc/nginx/ssl
    networks:
      - app-network

  # MQTT Broker (EMQX)
  emqx:
    image: emqx/emqx:5.0
    container_name: emqx-server
    restart: always
    ports:
      - "1883:1883"
      - "8083:8083"
      - "18083:18083"
    volumes:
      - emqx_data:/opt/emqx/data
    environment:
      - EMQX_DASHBOARD__DEFAULT_USERNAME=admin
      - EMQX_DASHBOARD__DEFAULT_PASSWORD=public
    networks:
      - app-network

volumes:
  mysql_data:
  redis_data:
  postgres_data:
  influxdb_data:
  emqx_data:

networks:
  app-network:
    driver: bridge
```

### 启动和管理脚本
```bash
#!/bin/bash

# 启动所有服务
start_services() {
    echo "启动所有服务..."
    docker-compose up -d
    echo "所有服务已启动"
}

# 停止所有服务
stop_services() {
    echo "停止所有服务..."
    docker-compose down
    echo "所有服务已停止"
}

# 查看服务状态
status_services() {
    echo "服务状态:"
    docker-compose ps
}

# 查看日志
logs_services() {
    if [ -z "$1" ]; then
        docker-compose logs -f
    else
        docker-compose logs -f $1
    fi
}

# 重启服务
restart_services() {
    if [ -z "$1" ]; then
        docker-compose restart
    else
        docker-compose restart $1
    fi
}

case "$1" in
    start)
        start_services
        ;;
    stop)
        stop_services
        ;;
    status)
        status_services
        ;;
    logs)
        logs_services $2
        ;;
    restart)
        restart_services $2
        ;;
    *)
        echo "用法: $0 {start|stop|status|logs|restart} [service_name]"
        exit 1
        ;;
esac
```

---

## 常用运维命令

### 监控和诊断
```bash
# 查看容器资源使用情况
docker stats

# 查看容器进程
docker top <容器名>

# 查看容器详细信息
docker inspect <容器名>

# 查看容器内部文件系统变化
docker diff <容器名>

# 导出容器为镜像
docker commit <容器名> <新镜像名>

# 导出镜像
docker save -o <文件名.tar> <镜像名>

# 导入镜像
docker load -i <文件名.tar>
```

### 清理命令
```bash
# 清理未使用的镜像
docker image prune

# 清理未使用的容器
docker container prune

# 清理未使用的网络
docker network prune

# 清理未使用的数据卷
docker volume prune

# 清理所有未使用的资源
docker system prune -a
```

### 备份和恢复
```bash
# 备份 MySQL 数据库
docker exec mysql-server mysqldump -u root -p数据库名 > backup.sql

# 恢复 MySQL 数据库
docker exec -i mysql-server mysql -u root -p数据库名 < backup.sql

# 备份 PostgreSQL 数据库
docker exec postgres-server pg_dump -U username database_name > backup.sql

# 恢复 PostgreSQL 数据库
docker exec -i postgres-server psql -U username database_name < backup.sql
```

---

## 最佳实践

### 1. 安全性
- 不要在镜像中包含敏感信息
- 使用非 root 用户运行容器
- 定期更新镜像
- 使用安全的镜像仓库

### 2. 性能优化
- 使用多阶段构建减小镜像大小
- 合理配置资源限制
- 使用缓存层优化构建时间
- 选择合适的基础镜像

### 3. 日志管理
- 配置日志轮转
- 使用集中化日志收集
- 设置合适的日志级别

### 4. 监控告警
- 设置容器健康检查
- 监控资源使用情况
- 配置告警规则

### 5. 数据管理
- 使用数据卷持久化重要数据
- 定期备份数据
- 实施数据加密

---

## 故障排除

### 常见问题及解决方案

#### 1. 容器无法启动
```bash
# 查看错误日志
docker logs <容器名>

# 检查镜像是否存在
docker images

# 检查端口是否被占用
netstat -tlnp | grep <端口号>
```

#### 2. 网络连接问题
```bash
# 检查网络配置
docker network ls
docker network inspect <网络名>

# 测试容器间连接
docker exec -it <容器名> ping <目标容器名>
```

#### 3. 存储空间不足
```bash
# 查看磁盘使用情况
docker system df

# 清理未使用的资源
docker system prune -a
```

#### 4. 性能问题
```bash
# 监控资源使用
docker stats

# 查看容器进程
docker top <容器名>
```

---

## 结语

这份 Docker 使用说明书涵盖了从基础概念到高级部署的全面内容。在实际使用中，请根据具体需求调整配置参数，并遵循最佳实践以确保系统的稳定性和安全性。

定期更新 Docker 版本和镜像，关注安全漏洞通告，保持系统的最新状态。

如有问题，请参考官方文档或社区资源：
- [Docker 官方文档](https://docs.docker.com/)
- [Docker Hub](https://hub.docker.com/)
- [Docker Compose 文档](https://docs.docker.com/compose/)