Docker入门教程 - 从零开始学习容器化技术

1. Docker简介

Docker是一个开源的容器化平台，它允许开发者将应用程序及其依赖项打包到一个轻量级、可移植的容器中，然后在任何支持Docker的环境中运行。

核心优势：

✅ 轻量级：容器共享主机操作系统内核，比虚拟机更轻量
✅ 可移植性：一次构建，到处运行
✅ 隔离性：容器之间相互隔离，互不影响
✅ 快速部署：秒级启动，快速扩展
✅ 版本控制：镜像可以版本化管理
✅ 资源高效：充分利用系统资源

特性	Docker容器	虚拟机
启动速度	秒级	分钟级
资源占用	小	大
性能	接近原生	有损耗
隔离性	进程级	系统级
操作系统	共享宿主机内核	独立操作系统

应用部署：快速部署和扩展应用
开发环境：统一开发环境，避免"在我机器上能跑"的问题
CI/CD：持续集成和持续部署
微服务架构：容器化微服务
云原生应用：Kubernetes等容器编排平台的基础

2. Docker核心概念

镜像是一个只读的模板，用于创建Docker容器。镜像包含了运行应用所需的所有内容：代码、运行时、库、环境变量和配置文件。

镜像特点：

只读的
分层的
可以基于其他镜像构建
可以版本化管理

容器是镜像的运行实例。容器可以被创建、启动、停止、删除。每个容器都是相互隔离的。

容器特点：

可读写的
轻量级
可移植
相互隔离

仓库是存放镜像的地方，类似于Git仓库。Docker Hub是Docker官方的公共仓库。

仓库类型：

公共仓库：Docker Hub、阿里云镜像仓库等
私有仓库：自己搭建的镜像仓库

┌─────────────────────────────────────┐
│         Docker Client               │
│    (docker命令、Docker API)          │
└──────────────┬──────────────────────┘
               │
┌──────────────▼──────────────────────┐
│         Docker Daemon               │
│    (Docker守护进程)                  │
└──────────────┬──────────────────────┘
               │
    ┌──────────┴──────────┐
    │                     │
┌───▼────┐          ┌─────▼───┐
│ Images │          │Containers│
│ (镜像) │          │  (容器)  │
└────────┘          └─────────┘

3. Docker安装与配置

Ubuntu/Debian系统

# 1. 更新apt包索引
sudo apt-get update

# 2. 安装必要的依赖
sudo apt-get install \
    ca-certificates \
    curl \
    gnupg \
    lsb-release

# 3. 添加Docker官方GPG密钥
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

# 4. 设置仓库
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 5. 安装Docker Engine
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin

# 6. 验证安装
sudo docker run hello-world

CentOS/RHEL系统

# 1. 安装必要的工具
sudo yum install -y yum-utils

# 2. 添加Docker仓库
sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

# 3. 安装Docker Engine
sudo yum install docker-ce docker-ce-cli containerd.io docker-compose-plugin

# 4. 启动Docker
sudo systemctl start docker
sudo systemctl enable docker

# 5. 验证安装
sudo docker run hello-world

使用Docker Desktop（推荐）

访问Docker官网：https://www.docker.com/products/docker-desktop
下载Docker Desktop for Mac
双击安装包进行安装
启动Docker Desktop
验证安装：docker run hello-world

使用Homebrew

brew install --cask docker

访问Docker官网：https://www.docker.com/products/docker-desktop
下载Docker Desktop for Windows
运行安装程序
重启计算机
启动Docker Desktop
验证安装：docker run hello-world

注意： Windows需要启用WSL 2或Hyper-V

配置镜像加速器（国内用户）

阿里云镜像加速：

登录阿里云容器镜像服务
获取专属加速地址
配置Docker：

# 创建或编辑daemon.json
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://your-mirror.mirror.aliyuncs.com"]
}
EOF

# 重启Docker
sudo systemctl daemon-reload
sudo systemctl restart docker

其他镜像源：

{
  "registry-mirrors": [
    "https://docker.mirrors.ustc.edu.cn",
    "https://hub-mirror.c.163.com",
    "https://mirror.baidubce.com"
  ]
}

配置用户权限（Linux）

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

# 重新登录或执行
newgrp docker

# 验证（不需要sudo）
docker run hello-world

# 查看Docker版本
docker --version
docker version

# 查看Docker信息
docker info

# 运行测试容器
docker run hello-world

4. Docker基础命令

搜索镜像

# 搜索镜像
docker search nginx

# 搜索特定数量的结果
docker search --limit 5 nginx

拉取镜像

# 拉取最新版本
docker pull nginx

# 拉取指定版本
docker pull nginx:1.21

# 拉取指定标签
docker pull ubuntu:20.04

查看镜像

# 查看本地镜像列表
docker images

# 查看镜像详细信息
docker inspect nginx

# 查看镜像历史
docker history nginx

删除镜像

# 删除镜像
docker rmi nginx

# 强制删除
docker rmi -f nginx

# 删除所有未使用的镜像
docker image prune -a

运行容器

# 运行容器（前台运行）
docker run nginx

# 运行容器（后台运行）
docker run -d nginx

# 运行容器并指定名称
docker run -d --name my-nginx nginx

# 运行容器并映射端口
docker run -d -p 8080:80 nginx

# 运行容器并挂载卷
docker run -d -v /host/path:/container/path nginx

# 运行容器并设置环境变量
docker run -d -e ENV_VAR=value nginx

# 运行容器并进入交互模式
docker run -it ubuntu /bin/bash

查看容器

# 查看运行中的容器
docker ps

# 查看所有容器（包括停止的）
docker ps -a

# 查看容器详细信息
docker inspect container_name

# 查看容器日志
docker logs container_name

# 实时查看日志
docker logs -f container_name

# 查看容器资源使用情况
docker stats container_name

容器操作

# 启动容器
docker start container_name

# 停止容器
docker stop container_name

# 重启容器
docker restart container_name

# 暂停容器
docker pause container_name

# 恢复容器
docker unpause container_name

# 删除容器
docker rm container_name

# 强制删除运行中的容器
docker rm -f container_name

# 删除所有停止的容器
docker container prune

进入容器

# 进入运行中的容器（推荐）
docker exec -it container_name /bin/bash

# 使用sh
docker exec -it container_name /bin/sh

# 在容器中执行命令
docker exec container_name ls -la

# 查看Docker系统信息
docker info

# 查看Docker版本
docker version

# 构建镜像
docker build -t image_name:tag .

# 查看容器进程
docker top container_name

# 复制文件到容器
docker cp file.txt container_name:/path/

# 从容器复制文件
docker cp container_name:/path/file.txt ./

5. Docker镜像管理

Docker镜像采用分层存储结构，每一层都是只读的，多个镜像可以共享相同的层。

# 查看镜像分层
docker history nginx

# 查看镜像详细信息
docker inspect nginx

# 给镜像打标签
docker tag nginx:latest my-nginx:v1.0

# 查看镜像标签
docker images | grep nginx

# 导出镜像为tar文件
docker save -o nginx.tar nginx:latest

# 或者
docker save nginx:latest > nginx.tar

# 导入镜像
docker load -i nginx.tar

# 或者
docker load < nginx.tar

# 登录Docker Hub
docker login

# 给镜像打标签（格式：username/repository:tag）
docker tag nginx:latest username/my-nginx:v1.0

# 推送镜像到Docker Hub
docker push username/my-nginx:v1.0

# 从私有仓库拉取
docker pull registry.example.com/image:tag

# 删除悬空镜像（dangling images）
docker image prune

# 删除所有未使用的镜像
docker image prune -a

# 删除指定镜像
docker rmi image_id

# 批量删除镜像
docker rmi $(docker images -q)

6. Docker容器操作

创建(create) → 启动(start) → 运行(running) → 停止(stop) → 删除(rm)
                ↑                                    ↓
                └──────────── 重启(restart) ──────────┘

前台运行

# 前台运行，输出日志到控制台
docker run nginx

后台运行

# 后台运行（detached mode）
docker run -d nginx

交互模式

# 交互模式运行
docker run -it ubuntu /bin/bash

# 参数说明：
# -i: 保持STDIN开放
# -t: 分配一个伪终端

# 映射单个端口
docker run -d -p 8080:80 nginx

# 映射多个端口
docker run -d -p 8080:80 -p 8443:443 nginx

# 指定IP和端口
docker run -d -p 127.0.0.1:8080:80 nginx

# 随机端口映射
docker run -d -p 80 nginx
docker port container_name  # 查看端口映射

# 设置环境变量
docker run -d -e ENV_VAR=value nginx

# 设置多个环境变量
docker run -d -e VAR1=value1 -e VAR2=value2 nginx

# 从文件读取环境变量
docker run -d --env-file .env nginx

# 限制内存使用
docker run -d -m 512m nginx

# 限制CPU使用
docker run -d --cpus="1.5" nginx

# 限制CPU份额
docker run -d --cpu-shares=512 nginx

# 组合限制
docker run -d -m 512m --cpus="1.0" nginx

# 挂载主机目录
docker run -d -v /host/path:/container/path nginx

# 挂载数据卷
docker run -d -v volume_name:/container/path nginx

# 只读挂载
docker run -d -v /host/path:/container/path:ro nginx

7. Dockerfile详解

Dockerfile是一个文本文件，包含了一系列指令，用于构建Docker镜像。

FROM - 指定基础镜像

# 使用官方镜像
FROM ubuntu:20.04

# 使用Alpine Linux（轻量级）
FROM alpine:latest

# 多阶段构建
FROM node:14 AS builder
FROM nginx:alpine

RUN - 执行命令

# 执行单个命令
RUN apt-get update

# 执行多个命令（推荐，减少层数）
RUN apt-get update && \
    apt-get install -y nginx && \
    rm -rf /var/lib/apt/lists/*

# 使用shell形式
RUN echo "Hello" > /tmp/hello.txt

# 使用exec形式
RUN ["/bin/bash", "-c", "echo Hello"]

COPY - 复制文件

# 复制文件
COPY app.jar /app/app.jar

# 复制目录
COPY src/ /app/src/

# 复制多个文件
COPY file1.txt file2.txt /app/

# 使用通配符
COPY *.jar /app/

ADD - 添加文件（不推荐）

# ADD功能类似COPY，但支持URL和自动解压
ADD https://example.com/file.tar.gz /tmp/
ADD file.tar.gz /tmp/  # 自动解压

WORKDIR - 设置工作目录

# 设置工作目录
WORKDIR /app

# 后续命令在此目录执行
RUN pwd  # 输出: /app

ENV - 设置环境变量

# 设置环境变量
ENV APP_HOME=/app
ENV JAVA_HOME=/usr/lib/jvm/java-8-openjdk

# 使用环境变量
WORKDIR $APP_HOME

ARG - 构建参数

# 定义构建参数
ARG VERSION=latest

# 使用构建参数
FROM nginx:${VERSION}

EXPOSE - 暴露端口

# 暴露端口
EXPOSE 80

# 暴露多个端口
EXPOSE 80 443

CMD - 默认命令

# shell形式
CMD echo "Hello World"

# exec形式（推荐）
CMD ["nginx", "-g", "daemon off;"]

# 作为ENTRYPOINT的参数
CMD ["--help"]

ENTRYPOINT - 入口点

# exec形式（推荐）
ENTRYPOINT ["docker-entrypoint.sh"]

# shell形式
ENTRYPOINT echo "Hello"

VOLUME - 数据卷

# 创建数据卷
VOLUME ["/data"]

# 多个数据卷
VOLUME ["/data", "/logs"]

USER - 指定用户

# 切换到指定用户
USER nginx

# 切换到指定用户和组
USER nginx:nginx

7.3 Dockerfile最佳实践示例

示例1：Java应用

# 多阶段构建
FROM maven:3.8-openjdk-11 AS builder
WORKDIR /app
COPY pom.xml .
COPY src ./src
RUN mvn clean package -DskipTests

FROM openjdk:11-jre-slim
WORKDIR /app
COPY --from=builder /app/target/app.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

示例2：Node.js应用

FROM node:16-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:16-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
COPY package*.json ./
EXPOSE 3000
CMD ["npm", "start"]

示例3：Python应用

FROM python:3.9-slim
WORKDIR /app

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

# 复制应用代码
COPY . .

# 设置环境变量
ENV PYTHONUNBUFFERED=1

EXPOSE 8000
CMD ["python", "app.py"]

示例4：Nginx静态网站

FROM nginx:alpine
COPY nginx.conf /etc/nginx/nginx.conf
COPY dist/ /usr/share/nginx/html/
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

# 构建镜像
docker build -t my-app:latest .

# 指定Dockerfile路径
docker build -f Dockerfile.prod -t my-app:prod .

# 构建时传递参数
docker build --build-arg VERSION=1.0 -t my-app:1.0 .

# 不使用缓存构建
docker build --no-cache -t my-app:latest .

使用多阶段构建：减小镜像大小
合理使用缓存：将变化少的层放在前面
合并RUN命令：减少镜像层数
使用.dockerignore：排除不需要的文件
选择合适的基础镜像：优先使用Alpine等轻量级镜像
避免在镜像中存储敏感信息
使用非root用户运行

8. Docker网络

bridge网络（默认）

# 查看网络列表
docker network ls

# 创建bridge网络
docker network create my-network

# 运行容器并连接到网络
docker run -d --network my-network --name container1 nginx
docker run -d --network my-network --name container2 nginx

# 容器可以通过容器名互相访问
docker exec container1 ping container2

host网络

# 使用主机网络
docker run -d --network host nginx

# 容器直接使用主机网络，端口映射无效

none网络

# 不使用网络
docker run -d --network none nginx

# 容器完全隔离，无网络连接

overlay网络（Swarm）

# 创建overlay网络（用于Swarm集群）
docker network create --driver overlay my-overlay

# 创建网络
docker network create my-network

# 创建网络并指定子网
docker network create --subnet=172.20.0.0/16 my-network

# 查看网络详情
docker network inspect my-network

# 连接容器到网络
docker network connect my-network container_name

# 断开容器网络
docker network disconnect my-network container_name

# 删除网络
docker network rm my-network

# 删除所有未使用的网络
docker network prune

# 方式1：使用容器名（推荐）
docker run -d --name web --network my-network nginx
docker run -d --name app --network my-network my-app
# app容器可以通过 http://web 访问nginx

# 方式2：使用--link（已废弃）
docker run -d --name app --link web:web my-app

# 方式3：使用host网络
docker run -d --network host nginx

9. Docker数据管理

数据卷是Docker管理的数据存储方式，独立于容器的生命周期。

# 创建数据卷
docker volume create my-volume

# 查看数据卷列表
docker volume ls

# 查看数据卷详情
docker volume inspect my-volume

# 使用数据卷
docker run -d -v my-volume:/data nginx

# 删除数据卷
docker volume rm my-volume

# 删除所有未使用的数据卷
docker volume prune

# 挂载主机目录到容器
docker run -d -v /host/path:/container/path nginx

# 只读挂载
docker run -d -v /host/path:/container/path:ro nginx

9.3 tmpfs挂载

# 使用内存文件系统
docker run -d --tmpfs /tmp nginx

# 创建数据卷
docker volume create mysql-data

# 运行MySQL并使用数据卷
docker run -d \
  --name mysql \
  -v mysql-data:/var/lib/mysql \
  -e MYSQL_ROOT_PASSWORD=password \
  mysql:8.0

# 即使删除容器，数据仍然保留
docker rm mysql

# 重新创建容器，数据仍然存在
docker run -d \
  --name mysql \
  -v mysql-data:/var/lib/mysql \
  mysql:8.0

10. Docker Compose

Docker Compose是一个用于定义和运行多容器Docker应用的工具。通过YAML文件配置应用服务，然后使用一个命令就可以启动所有服务。

Linux系统

# 下载Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/download/v2.20.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

# 添加执行权限
sudo chmod +x /usr/local/bin/docker-compose

# 验证安装
docker-compose --version

macOS/Windows

Docker Desktop已包含Docker Compose，无需单独安装。

基本结构

version: '3.8'

services:
  web:
    image: nginx:alpine
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html
  
  app:
    build: .
    ports:
      - "3000:3000"
    depends_on:
      - db
  
  db:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: password
      MYSQL_DATABASE: myapp
    volumes:
      - db-data:/var/lib/mysql

volumes:
  db-data:

services - 服务定义

services:
  web:
    # 使用镜像
    image: nginx:alpine
    
    # 构建镜像
    build:
      context: .
      dockerfile: Dockerfile
      args:
        VERSION: 1.0
    
    # 容器名称
    container_name: my-nginx
    
    # 端口映射
    ports:
      - "8080:80"
      - "8443:443"
    
    # 环境变量
    environment:
      - ENV_VAR=value
      - DEBUG=true
    
    # 环境变量文件
    env_file:
      - .env
    
    # 数据卷
    volumes:
      - ./data:/app/data
      - volume-name:/app/storage
    
    # 网络
    networks:
      - frontend
      - backend
    
    # 依赖服务
    depends_on:
      - db
      - redis
    
    # 重启策略
    restart: always
    
    # 命令
    command: nginx -g "daemon off;"
    
    # 入口点
    entrypoint: /docker-entrypoint.sh
    
    # 工作目录
    working_dir: /app
    
    # 用户
    user: nginx
    
    # 资源限制
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 512M
        reservations:
          cpus: '0.25'
          memory: 256M

networks - 网络定义

networks:
  frontend:
    driver: bridge
  backend:
    driver: bridge
  custom:
    driver: overlay

volumes - 数据卷定义

volumes:
  db-data:
    driver: local
  cache:
    driver: local

10.5 Docker Compose命令

# 启动服务
docker-compose up

# 后台启动
docker-compose up -d

# 构建并启动
docker-compose up --build

# 停止服务
docker-compose stop

# 停止并删除容器
docker-compose down

# 查看服务状态
docker-compose ps

# 查看日志
docker-compose logs

# 实时查看日志
docker-compose logs -f

# 查看特定服务日志
docker-compose logs web

# 执行命令
docker-compose exec web ls -la

# 进入容器
docker-compose exec web /bin/bash

# 重启服务
docker-compose restart

# 扩展服务
docker-compose up -d --scale web=3

# 构建服务
docker-compose build

# 拉取镜像
docker-compose pull

示例1：Web应用 + 数据库

version: '3.8'

services:
  web:
    build: .
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgresql://user:password@db:5432/mydb
    depends_on:
      - db
    networks:
      - app-network
  
  db:
    image: postgres:14
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: mydb
    volumes:
      - postgres-data:/var/lib/postgresql/data
    networks:
      - app-network

volumes:
  postgres-data:

networks:
  app-network:
    driver: bridge

示例2：LNMP环境

version: '3.8'

services:
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./html:/usr/share/nginx/html
    depends_on:
      - php
    networks:
      - lnmp-network
  
  php:
    image: php:8.0-fpm
    volumes:
      - ./php:/var/www/html
    networks:
      - lnmp-network
  
  mysql:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_DATABASE: mydb
    volumes:
      - mysql-data:/var/lib/mysql
    networks:
      - lnmp-network

volumes:
  mysql-data:

networks:
  lnmp-network:
    driver: bridge

11. Docker实际应用

步骤1：准备应用

# 创建项目目录
mkdir my-app
cd my-app

# 创建应用文件
echo "Hello Docker" > index.html

步骤2：创建Dockerfile

FROM nginx:alpine
COPY index.html /usr/share/nginx/html/
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

步骤3：构建和运行

# 构建镜像
docker build -t my-app:latest .

# 运行容器
docker run -d -p 8080:80 --name my-app my-app:latest

# 访问 http://localhost:8080

11.2 部署数据库

# 运行MySQL
docker run -d \
  --name mysql \
  -e MYSQL_ROOT_PASSWORD=password \
  -e MYSQL_DATABASE=myapp \
  -p 3306:3306 \
  -v mysql-data:/var/lib/mysql \
  mysql:8.0

# 连接数据库
docker exec -it mysql mysql -uroot -ppassword

# 运行Redis
docker run -d \
  --name redis \
  -p 6379:6379 \
  -v redis-data:/data \
  redis:alpine

# 连接Redis
docker exec -it redis redis-cli

使用Docker Compose部署完整应用：

version: '3.8'

services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - DB_HOST=db
      - REDIS_HOST=redis
    depends_on:
      - db
      - redis
  
  db:
    image: postgres:14
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    volumes:
      - db-data:/var/lib/postgresql/data
  
  redis:
    image: redis:alpine
    volumes:
      - redis-data:/data

volumes:
  db-data:
  redis-data:

12. Docker最佳实践

使用多阶段构建
选择合适的基础镜像（Alpine等）
合并RUN命令减少层数
使用.dockerignore排除不需要的文件
清理缓存和临时文件
使用非root用户
扫描镜像漏洞
不在镜像中存储敏感信息
使用最小权限原则
定期更新基础镜像
合理使用缓存
优化Dockerfile指令顺序
使用数据卷而非绑定挂载（Linux）
限制容器资源使用
使用健康检查

# 配置日志驱动
docker run --log-driver json-file --log-opt max-size=10m --log-opt max-file=3 nginx

# 查看日志
docker logs container_name

# 清理日志
docker system prune --volumes

# Dockerfile中定义
HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost/health || exit 1

# docker-compose.yml中定义
services:
  web:
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost/health"]
      interval: 30s
      timeout: 10s
      retries: 3

13. 常见问题与故障排除

问题1：容器无法启动

# 查看容器日志
docker logs container_name

# 查看容器详细信息
docker inspect container_name

# 检查端口占用
netstat -tulpn | grep port

问题2：镜像拉取失败

# 配置镜像加速器
# 检查网络连接
# 使用代理

问题3：容器间无法通信

# 检查网络配置
docker network inspect network_name

# 确保容器在同一网络
docker network connect network_name container_name

问题4：数据卷权限问题

# 检查文件权限
ls -la /host/path

# 使用数据卷而非绑定挂载
docker volume create my-volume

# 查看Docker系统信息
docker system df

# 查看容器资源使用
docker stats

# 查看Docker事件
docker events

# 清理系统
docker system prune -a

# 查看Docker版本
docker version
docker info

14. 总结与进阶

通过本教程，你已经掌握了：

✅ Docker的基本概念和架构
✅ Docker的安装和配置
✅ 镜像和容器的管理
✅ Dockerfile的编写
✅ Docker网络和数据管理
✅ Docker Compose的使用
✅ 实际应用部署

Docker Swarm：容器编排
Kubernetes：生产级容器编排
容器安全：安全扫描和加固
CI/CD集成：Jenkins、GitLab CI等
监控和日志：Prometheus、ELK等
服务网格：Istio、Linkerd等

官方文档：https://docs.docker.com/
Docker Hub：https://hub.docker.com/
GitHub：https://github.com/docker
社区论坛：https://forums.docker.com/

多动手实践：通过实际项目练习
阅读官方文档：深入了解每个特性
参与社区：学习最佳实践
关注安全：及时更新和扫描
性能优化：持续优化容器性能

结语

Docker作为现代容器化技术的代表，已经成为了开发和运维的必备技能。通过本教程的学习，相信你已经掌握了Docker的核心功能和使用方法。

记住：

多实践：理论结合实践，多部署应用
理解原理：理解容器化的工作原理
关注安全：注意容器安全最佳实践
持续学习：关注Docker和容器技术的新发展

祝你学习愉快，容器化之路顺利！ 🐳

本教程由Java突击队学习社区编写，如有问题欢迎反馈。