Docker用法总结｜实用指南+常用指令速查（2025最新）

作为深耕AI、算法与机器学习领域的技术从业者，日常工作中难免要面对「环境不一致」「依赖冲突」「部署繁琐」等痛点——本地调试好的算法模型，放到服务器就报错；不同同事的开发环境差异，导致代码无法复用；训练好的模型部署到生产，要花大量时间配置依赖。而Docker，正是解决这些问题的“终极利器”。

本文不堆砌冗余理论，聚焦「实用」与「严谨」，从基础定义到核心原理，从入门操作到进阶实战，再到常用指令速查，帮你快速掌握Docker的核心用法，真正落地到AI/算法工作流中，提升开发、部署效率。

一、Docker基础认知：是什么 & 为什么用

1.1 核心定义

Docker 是一个开源的容器化平台，核心作用是「将应用程序及其依赖打包成一个可移植的容器」，让应用可以在任何支持Docker的环境中（开发机、服务器、云平台）一致运行，实现“一次构建，到处运行”。

这里要明确两个关键概念，避免混淆：

容器（Container）：运行中的Docker实例，是一个独立的、隔离的运行环境，包含应用程序及其所有依赖（库、配置文件、环境变量等），本质是“轻量级的沙箱”。
镜像（Image）：容器的“模板”，是一个只读的文件集合，包含运行应用所需的所有代码、依赖和环境配置，容器是镜像的实例化结果（类似“类与对象”的关系）。

1.2 发展历程（极简梳理）

Docker的发展离不开Linux容器技术（LXC）的铺垫，核心时间线如下：

2013年：Docker项目正式开源，基于LXC实现，解决了LXC配置复杂、可移植性差的问题，迅速走红。
2014年：Docker Inc. 成立，推出Docker Hub（公共镜像仓库），完善生态。
2016年：推出Docker Swarm（容器编排工具），与Kubernetes形成竞争。
2019年：Docker Inc. 宣布将Docker Swarm捐赠给CNCF，专注于容器引擎和开发者工具。
2022-2025年：Docker进一步轻量化，支持更多架构（如ARM64），与AI/机器学习场景深度融合，推出Docker AI工具链，简化模型部署流程。

1.3 为什么Docker是AI/算法从业者的必备工具？

对于AI、算法开发来说，Docker的价值远不止“环境一致”，更能解决核心痛点：

解决「环境地狱」：算法开发依赖大量库（如TensorFlow、PyTorch、OpenCV），不同版本的库之间可能存在冲突，Docker可将依赖打包，避免“本地能跑，服务器跑不了”。
简化模型部署：训练好的模型，打包成Docker镜像，可直接部署到云服务器、边缘设备，无需重新配置依赖，降低部署门槛。
资源隔离与高效利用：容器相比虚拟机（VM）更轻量（无需虚拟操作系统），启动速度快（秒级），可在一台服务器上部署多个算法容器，提升资源利用率。
便于协作与版本管理：镜像可版本化，不同版本的算法模型、依赖配置可通过镜像版本管理，方便团队协作与回溯。
适配AI工程化：与Kubernetes、Airflow等工具结合，可实现算法模型的批量部署、自动扩缩容，助力AI项目从研发落地到生产。

二、Docker核心原理：不搞懂底层，用不明白

Docker的核心优势（轻量、隔离、可移植），本质是基于Linux内核的三大核心技术实现，无需深入底层代码，但需理解其工作逻辑，避免踩坑。

2.1 三大核心底层技术

2.1.1 命名空间（Namespaces）：实现“隔离”

命名空间的作用是“隔离容器的运行环境”，让容器看起来像一个独立的操作系统，主要包括6种命名空间：

UTS：隔离主机名和域名，容器有自己的主机名。
PID：隔离进程ID，容器内的进程ID从1开始，与宿主机进程不冲突。
Mount：隔离文件系统挂载点，容器有自己的文件系统。
Network：隔离网络栈，容器有自己的网卡、IP、端口。
User：隔离用户和组ID，容器内的用户与宿主机用户独立。
IPC：隔离进程间通信，容器内的进程无法直接与宿主机或其他容器的进程通信（除非配置网络）。

2.1.2 控制组（cgroups）：实现“资源限制”

cgroups（Control Groups）的作用是“限制容器使用的系统资源”，避免单个容器占用过多资源（如CPU、内存、磁盘IO），影响其他容器或宿主机。

核心功能包括：

资源限制：限制容器可使用的CPU核心数、内存大小、磁盘IO速率等。
资源统计：统计容器使用的资源情况（如CPU使用率、内存占用）。
优先级分配：为不同容器分配不同的资源优先级（如核心算法容器优先级高于辅助容器）。

对于AI/算法场景，cgroups尤为重要——训练模型时，可通过cgroups限制容器使用的GPU、CPU资源，避免单个训练任务占用全部资源，导致其他任务卡顿。

2.1.3 联合文件系统（UnionFS）：实现“镜像分层”

UnionFS是Docker镜像的核心技术，采用“分层存储”机制，让镜像更轻量、可复用。

核心逻辑：

镜像由多个只读层（Layer）组成，每层对应一个操作（如安装一个库、配置一个环境变量）。
多个镜像可共享相同的底层层，减少存储空间（如多个AI镜像都基于Ubuntu镜像，可共享Ubuntu的底层层）。
容器启动时，会在镜像的只读层之上，添加一个可写层（Writable Layer），容器内的所有操作（如修改文件、安装依赖）都在可写层进行，不会影响底层镜像（实现“写时复制”Copy-on-Write）。

举个例子：一个PyTorch镜像，底层是Ubuntu层，之上是Python层，再之上是PyTorch层，每层都是只读的；启动容器后，添加可写层，后续安装的依赖的都在可写层，删除容器后，可写层被删除，镜像不变。

2.2 镜像与容器的工作流程（极简）

从镜像仓库（如Docker Hub）拉取镜像（或本地构建镜像）。
基于镜像创建容器（添加可写层）。
容器启动时，通过Namespaces实现隔离，通过cgroups限制资源。
容器运行过程中，所有操作都在可写层进行。
容器停止后，可写层保留（可重新启动容器）；若删除容器，可写层被删除，镜像不变。

三、Docker入门实操：从安装到第一个容器

本节聚焦“实操”，覆盖Windows、Mac、Linux三大系统的安装步骤，以及从拉取镜像到运行容器的完整流程，适合零基础入门。

3.1 安装Docker（2025最新版）

Docker分为「Docker Engine」（核心引擎，用于Linux）和「Docker Desktop」（适用于Windows、Mac，包含Engine、GUI工具、Kubernetes等）。

3.1.1 Windows安装（Win10/11 专业版/企业版）

开启「Hyper-V」和「容器」功能：控制面板 → 程序 → 程序和功能 → 启用或关闭Windows功能，勾选Hyper-V、容器，重启电脑。
下载Docker Desktop：从Docker官方网站下载最新版，双击安装，一路下一步（默认勾选“使用WSL 2而非Hyper-V”，推荐WSL 2，性能更好）。
启动Docker Desktop：安装完成后启动，首次启动可能需要等待几分钟，右下角出现Docker图标即启动成功。
验证：打开CMD或PowerShell，输入 docker --version，显示版本信息即安装成功。

注意：Windows家庭版需先安装WSL 2，再安装Docker Desktop，具体步骤参考Docker官方文档。

3.1.2 Mac安装

下载Docker Desktop for Mac：从Docker官方网站下载（区分Intel芯片和Apple Silicon芯片）。
安装：将下载的.dmg文件拖拽到Applications文件夹，启动Docker。
验证：打开终端，输入 docker --version，显示版本信息即安装成功。

3.1.3 Linux安装（Ubuntu 22.04，最常用）

推荐使用官方脚本安装，步骤如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 卸载旧版本（若有）
sudo apt-get remove docker docker-engine docker.io containerd runc

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

# 安装依赖包
sudo apt-get install -y 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=$(dpkg --print-architecture) 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 Engine
sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io

# 验证安装（启动Docker服务并运行hello-world容器）
sudo systemctl start docker
sudo docker run hello-world

若运行hello-world容器成功，显示“Hello from Docker!”，即安装成功。

可选优化：配置非root用户使用Docker（避免每次都输sudo）：

1
2
sudo usermod -aG docker $USER
# 重启终端生效

3.2 第一个Docker容器：运行Ubuntu

掌握“拉取镜像→创建容器→启动容器→进入容器→停止/删除容器”的完整流程，其他容器操作可依此类推。

 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
# 1. 拉取Ubuntu镜像（从Docker Hub拉取，默认最新版）
docker pull ubuntu

# 2. 查看本地镜像（确认镜像已拉取成功）
docker images

# 3. 创建并启动容器（交互式启动，--name指定容器名，-it表示交互式终端）
docker run -it --name my-ubuntu ubuntu

# 4. 进入容器后，可执行Ubuntu命令（如更新包、安装软件）
apt update
apt install -y vim

# 5. 退出容器（不停止容器：Ctrl+P+Q；停止并退出：Ctrl+D）
# 若退出后，查看运行中的容器
docker ps
# 查看所有容器（包括停止的）
docker ps -a

# 6. 重新进入已启动的容器
docker exec -it my-ubuntu /bin/bash

# 7. 停止容器
docker stop my-ubuntu

# 8. 启动已停止的容器
docker start my-ubuntu

# 9. 删除容器（需先停止容器，或加-f强制删除）
docker rm my-ubuntu
# 强制删除运行中的容器
docker rm -f my-ubuntu

四、Docker常用指令速查（重中之重，收藏即用）

按「镜像操作」「容器操作」「仓库操作」「网络操作」「数据卷操作」分类，标注核心用法和示例，覆盖90%的日常场景，尤其适配AI/算法开发需求。

4.1 镜像操作（核心）

指令	功能说明	示例
docker pull [镜像名]:[标签]	拉取镜像，标签不写默认latest	docker pull pytorch/pytorch:2.2.0-cuda12.1-cudnn8-runtime
docker images	查看本地所有镜像	docker images（加-q只显示镜像ID）
docker rmi [镜像ID/镜像名]	删除镜像，需先删除依赖该镜像的容器	docker rmi 123456（或docker rmi ubuntu）
docker build -t [镜像名]:[标签] [Dockerfile路径]	基于Dockerfile构建镜像	docker build -t my-pytorch:v1.0 .（当前目录的Dockerfile）
docker tag [原镜像] [新镜像名]:[新标签]	给镜像打标签（用于推送仓库）	docker tag my-pytorch:v1.0 username/my-pytorch:v1.0
docker save -o [文件路径] [镜像名]	将镜像保存为本地文件（用于离线传输）	docker save -o ./pytorch.tar pytorch/pytorch
docker load -i [文件路径]	从本地文件加载镜像	docker load -i ./pytorch.tar

4.2 容器操作（核心）

指令	功能说明	示例
docker run [参数] 镜像名 [命令]	创建并启动容器，核心参数：-it（交互式）、-d（后台运行）、–name（容器名）、-p（端口映射）、-v（数据卷挂载）、–gpus（GPU支持）	docker run -d –name my-pytorch -p 8888:8888 –gpus all pytorch/pytorch:latest
docker ps	查看运行中的容器	docker ps -a（查看所有容器）、docker ps -q（只显示容器ID）
docker start/stop/restart [容器ID/容器名]	启动/停止/重启容器	docker start my-pytorch
docker exec -it [容器ID/容器名] [命令]	进入运行中的容器（交互式）	docker exec -it my-pytorch /bin/bash
docker logs [容器ID/容器名]	查看容器日志（用于调试）	docker logs -f my-pytorch（实时查看日志）
docker rm [容器ID/容器名]	删除容器，-f强制删除运行中的容器	docker rm -f my-pytorch
docker inspect [容器ID/容器名]	查看容器详细信息（如IP、挂载、资源限制）	docker inspect my-pytorch
docker cp [本地路径] [容器ID:容器路径]	本地文件复制到容器内（反之亦然）	docker cp ./model.py my-pytorch:/root/

4.3 仓库操作（常用）

指令	功能说明	示例
docker login	登录Docker Hub（或私有仓库）	docker login -u 用户名 -p 密码
docker push [镜像名]:[标签]	推送镜像到仓库（需先打标签）	docker push username/my-pytorch:v1.0
docker search [镜像名]	搜索Docker Hub上的镜像	docker search pytorch
docker logout	退出Docker仓库登录	docker logout

4.4 网络操作（AI部署常用）

指令	功能说明	示例
docker network ls	查看所有Docker网络	docker network ls
docker network create [网络名]	创建自定义网络（用于容器间通信）	docker network create ai-network
docker run –network [网络名] …	指定容器加入的网络	docker run -d –name model-server –network ai-network my-model
docker network connect [网络名] [容器名]	将已运行的容器加入网络	docker network connect ai-network my-model

4.5 数据卷操作（AI数据持久化常用）

数据卷（Volume）是Docker中用于“持久化数据”的机制，避免容器删除后数据丢失，尤其适合AI场景（如训练数据、模型文件的存储）。

指令	功能说明	示例
docker volume ls	查看所有数据卷	docker volume ls
docker volume create [卷名]	创建数据卷	docker volume create ai-data
docker run -v [卷名]:[容器路径] …	挂载数据卷到容器	docker run -d -v ai-data:/root/data my-pytorch
docker volume inspect [卷名]	查看数据卷详细信息（如本地存储路径）	docker volume inspect ai-data
docker volume rm [卷名]	删除数据卷（需先卸载）	docker volume rm ai-data

五、Docker进阶实战：AI/算法场景落地

本节聚焦AI/算法开发的核心场景，包括「构建自定义AI镜像」「Docker Compose编排多容器」「GPU支持配置」「模型部署实战」，帮你将Docker真正融入工作流。

5.1 构建自定义AI镜像（Dockerfile实战）

官方镜像（如PyTorch、TensorFlow）往往无法满足个性化需求（如需要特定版本的依赖、自定义配置），此时需要通过Dockerfile构建自定义镜像。

以下是「PyTorch+OpenCV+Jupyter」的Dockerfile示例（适配GPU，用于算法开发和模型训练）：

 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
# 基础镜像：选择带GPU的PyTorch官方镜像（避免自己配置CUDA）
FROM pytorch/pytorch:2.2.0-cuda12.1-cudnn8-runtime

# 维护者信息
LABEL maintainer="ai-dev@example.com"

# 设置工作目录
WORKDIR /root

# 安装系统依赖
RUN apt update && apt install -y \
    build-essential \
    libopencv-dev \
    git \
    wget \
    && rm -rf /var/lib/apt/lists/*

# 安装Python依赖（根据自己的需求修改）
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 暴露Jupyter端口
EXPOSE 8888

# 启动Jupyter Notebook
CMD ["jupyter", "notebook", "--ip=0.0.0.0", "--port=8888", "--allow-root", "--no-browser"]

配套的requirements.txt：

1
2
3
4
5
6
opencv-python==4.9.0.80
matplotlib==3.8.4
numpy==1.26.4
scikit-learn==1.4.2
pandas==2.2.1
jupyter==1.0.0

构建镜像并运行：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
# 构建镜像
docker build -t my-ai-dev:v1.0 .

# 运行容器（挂载数据卷，映射端口，支持GPU）
docker run -d \
  --name ai-dev-container \
  -p 8888:8888 \
  --gpus all \
  -v ai-data:/root/data \
  my-ai-dev:v1.0

# 查看Jupyter登录链接（容器日志中获取token）
docker logs ai-dev-container

5.2 Docker Compose：多容器编排（AI项目常用）

AI项目往往需要多个服务协同工作（如模型服务、数据库、前端界面），Docker Compose可通过一个yaml文件定义多个容器的配置，实现“一键启动、一键停止”。

示例：「PyTorch模型服务 + Redis缓存」的docker-compose.yml：

 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
version: '3.8'

services:
  # 模型服务容器
  model-server:
    build: .  # 基于当前目录的Dockerfile构建
    image: my-model-server:v1.0
    container_name: model-server
    ports:
      - "8000:8000"  # 映射模型服务端口
    volumes:
      - model-data:/root/model  # 挂载模型文件
    gpus: all  # 支持GPU
    depends_on:
      - redis  # 依赖Redis容器，Redis启动后再启动模型服务
    environment:
      - REDIS_HOST=redis  # 容器间通过服务名通信
      - REDIS_PORT=6379

  # Redis缓存容器
  redis:
    image: redis:7.2-alpine
    container_name: redis
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data

# 数据卷定义
volumes:
  model-data:
  redis-data:

常用Docker Compose指令：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
# 启动所有容器（后台运行）
docker-compose up -d

# 查看容器状态
docker-compose ps

# 查看日志
docker-compose logs -f

# 停止并删除所有容器、网络、数据卷
docker-compose down -v

# 重新构建镜像并启动
docker-compose up -d --build

5.3 GPU支持配置（关键！AI训练/推理必备）

AI场景中，训练和推理往往需要GPU加速，Docker支持GPU的前提是：宿主机已安装NVIDIA显卡驱动和NVIDIA Container Toolkit。

5.3.1 宿主机配置（Linux）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
# 1. 安装NVIDIA显卡驱动（略，需根据显卡型号安装）
# 2. 安装NVIDIA Container Toolkit
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list

sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit
sudo systemctl restart docker

# 3. 验证GPU支持（运行带GPU的容器）
docker run --gpus all nvidia/cuda:12.1.0-base-ubuntu22.04 nvidia-smi

若输出NVIDIA显卡信息，即GPU配置成功。

5.3.2 Windows/Mac GPU支持

Windows：需安装WSL 2，且WSL 2中安装NVIDIA显卡驱动和Container Toolkit，具体参考NVIDIA官方文档。
Mac（Apple Silicon）：暂不支持NVIDIA GPU，可使用Apple Metal加速（需PyTorch支持Metal）。

5.4 模型部署实战：FastAPI + Docker

将训练好的PyTorch模型，通过FastAPI封装成API，再用Docker打包部署，实现快速上线。

5.4.1 项目结构

1
2
3
4
5
6
7
model-deploy/
├── Dockerfile
├── docker-compose.yml
├── requirements.txt
├── main.py  # FastAPI服务代码
└── model/   # 训练好的模型文件
    └── model.pth

5.4.2 核心代码（main.py）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from fastapi import FastAPI
import torch
import numpy as np

app = FastAPI(title="AI Model API")

# 加载模型（启动时加载，避免每次请求都加载）
model = torch.load("./model/model.pth")
model.eval()

@app.post("/predict")
def predict(data: list):
    # 数据预处理
    input_data = torch.tensor(np.array(data), dtype=torch.float32)
    # 模型推理
    with torch.no_grad():
        output = model(input_data)
    # 结果处理
    return {"predictions": output.numpy().tolist()}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

5.4.3 构建并部署

Dockerfile和docker-compose.yml参考5.1和5.2，启动后，通过http://localhost:8000/docs访问API文档，即可测试模型推理。

六、Docker实战经验与避坑指南

结合多年AI/算法场景的Docker使用经验，总结以下高频坑点和优化技巧，帮你少走弯路。

6.1 镜像优化技巧（减少体积，提升拉取速度）

使用「轻量级基础镜像」：优先选择alpine、slim版本的镜像（如ubuntu:slim、python:3.11-slim），而非完整版，可大幅减少镜像体积。
合并RUN指令：Dockerfile中每个RUN指令都会创建一个镜像层，合并多个RUN指令（用&&连接），减少镜像层数。
清理缓存：安装依赖后，清理apt、pip缓存（如rm -rf /var/lib/apt/lists/*、–no-cache-dir），避免缓存占用空间。
使用多阶段构建：对于需要编译的项目（如C++依赖的AI库），可通过多阶段构建，只保留最终需要的文件，删除编译过程中的临时文件。

6.2 高频坑点及解决方案

坑点1：容器启动后，GPU无法使用。解决方案：确认宿主机已安装NVIDIA Container Toolkit，运行容器时加–gpus all参数，且基础镜像支持GPU（如pytorch/pytorch带cuda标签的镜像）。
坑点2：容器内无法访问网络。解决方案：检查Docker网络配置，确保容器加入正确的网络，或使用–net=host参数（共享宿主机网络，适合调试）。
坑点3：数据丢失（容器删除后，数据消失）。解决方案：使用数据卷（Volume）或绑定挂载（-v 本地路径:容器路径），实现数据持久化。
坑点4：镜像拉取速度慢。解决方案：配置Docker镜像加速器（如阿里云、网易云加速器），参考阿里云Docker加速器。
坑点5：多容器通信失败。解决方案：使用自定义网络，容器间通过服务名（Docker Compose）或容器IP通信，避免使用localhost（容器内的localhost是自身，不是宿主机）。

6.3 生产环境使用建议

使用「固定标签」的镜像：避免使用latest标签（镜像更新后，可能导致环境不一致），建议使用具体版本标签（如pytorch/pytorch:2.2.0-cuda12.1）。
限制容器资源：通过–memory、–cpus参数限制容器的内存和CPU使用，避免影响宿主机和其他容器。
配置容器日志：将容器日志挂载到本地或日志服务（如ELK），便于问题排查。
使用私有仓库：企业场景中，将自定义镜像推送到私有仓库（如阿里云ACR、Harbor），避免镜像泄露。

七、Docker最新进展（2024-2025）

Docker持续迭代，近年来的更新主要聚焦于「轻量化」「AI融合」「云原生适配」，以下是核心进展：

「Docker Scout」：推出AI驱动的镜像安全扫描工具，可检测镜像中的漏洞、恶意软件，帮助AI项目规避安全风险。
「Docker AI Toolchain」：集成AI模型构建、打包、部署的全流程工具，支持一键将PyTorch、TensorFlow模型打包成Docker镜像，并部署到云平台或边缘设备。
「Docker+Wasm」：支持WebAssembly容器，比传统容器更轻量、启动更快，适合边缘设备上的AI推理场景。
「Docker Compose V2」：全面支持Kubernetes，可将Docker Compose配置转换为Kubernetes YAML文件，便于AI项目从Docker迁移到K8s集群。
「ARM64架构支持优化」：针对ARM架构（如AWS Graviton、Apple Silicon）的镜像优化，提升AI模型在ARM设备上的运行性能。

八、学习资源推荐（从入门到精通）

结合AI/算法从业者的需求，推荐以下优质学习资源，循序渐进掌握Docker：

8.1 官方文档（最权威）

Docker官方入门指南：适合零基础，从安装到实战，步骤清晰。
Dockerfile官方文档：详细介绍Dockerfile的所有指令，必备参考。
Docker Compose官方文档：多容器编排的权威指南。
NVIDIA Container Toolkit文档：GPU支持的详细配置教程。

8.2 实战课程

Udemy - 《Docker Mastery》：由Docker核心贡献者授课，覆盖从基础到进阶的全知识点，适合深入学习。
极客时间 - 《Docker实战：从入门到进阶》：适合国内开发者，结合国内云平台（阿里云、腾讯云）的实战场景。
B站 - 「狂神说Docker」：免费入门课程，通俗易懂，适合零基础快速上手。

8.3 书籍

《Docker实战》（第2版）：Docker领域的经典书籍，覆盖核心概念和实战场景。
《Docker容器与容器云》：结合云原生场景，适合AI项目部署到云平台的需求。
《AI模型部署：基于Docker与Kubernetes》：专门针对AI场景的Docker部署书籍，贴合算法从业者需求。

8.4 社区与工具

Docker Hub：https://hub.docker.com/，查找官方镜像和开源镜像。
GitHub - Docker Samples：https://github.com/docker/samples，大量Docker实战示例（含AI场景）。
阿里云容器镜像服务（ACR）：https://cr.console.aliyun.com/，国内私有仓库，拉取镜像速度快。

九、总结

Docker作为AI/算法从业者的必备工具，核心价值在于「解决环境一致性、简化部署流程、提升资源利用率」。本文从基础认知、核心原理、实操指南、指令速查，到进阶实战、避坑技巧、最新进展，全面覆盖Docker的核心用法，尤其贴合AI/算法场景的落地需求。

对于算法开发来说，Docker不是“额外的负担”，而是“提升效率的利器”——掌握Docker，能让你从繁琐的环境配置中解放出来，专注于模型研发和业务落地。建议从「构建第一个自定义镜像」「部署一个简单的模型服务」开始，逐步积累实战经验，最终将Docker融入AI项目的全流程（开发、测试、部署）。

最后，Docker的生态一直在发展，结合Kubernetes、云平台、AI工具链的使用，能进一步发挥其价值，助力AI项目的工程化落地。

（注：文档部分内容可能由 AI 生成）