YOLOv11 Docker 极速体验：一行命令运行 YOLOv11 并进行图片、视频推理

🎪 摸鱼匠：个人主页

🎒 个人专栏：《YOLOv11实战专栏》

🥇 没有好的理念，只有脚踏实地！

文章目录

一、为什么选择 Docker 来体验 YOLOv11

1.1 程序员的“环境配置恐惧症”与 Docker 的救赎

作为一名在代码堆里摸爬滚打多年的程序员，我太理解那种“本来只想跑个Demo，结果配环境配了一天”的绝望感了。特别是像 YOLOv11 这种集成了大量深度学习依赖的框架，CUDA 版本冲突、PyTorch 版本不匹配、Opencv 缺失依赖……随便一个小报错都能让人在 StackOverflow 上迷失一下午。

如果你只是想快速体验一下 YOLOv11 的强大功能，或者你有一台性能强劲的服务器但不想把本地环境搞得乱七八糟，那么 Docker 绝对是你的“救命稻草”。简单来说，Docker 就像是一个独立运行在宿主机上的“系统”。在这个系统里，环境是隔离的，你不用折腾本地环境，直接拉取一个已经配置好所有依赖的“镜像”，就能直接上手干活。

1.2 Docker 运行 YOLOv11 的核心优势解析

咱们不整那些虚头巴脑的定义，直接用大白话讲讲为什么选 Docker：

纯净性：你的本地电脑可能装了 Python 3.8，项目 A 要用 Python 3.9，YOLOv11 可能又推荐 Python 3.10。用 Docker，每个容器都是独立的房间，互不干扰。
一致性：你在自己 Windows 电脑上跑通的代码，丢到 Linux 服务器上可能就崩了。但如果是 Docker 镜像，只要能跑起来，换任何机器（只要架构兼容）效果都一样。
极速部署：Ultralytics 官方提供了现成的镜像，里面 Python、PyTorch、CUDA、Ultralytics 库全装好了。你只需要一条命令，就像是下载了一个免安装版的绿色软件，解压即用。

1.3 核心概念通俗解读

在开始敲命令之前，咱们得先把几个核心概念捋顺了，防止后面操作时晕头转向。

核心概念	学术定义	通俗解读	比喻
镜像	一个特殊的文件系统，包含了程序运行所需的代码、库、环境配置等。	一个做好的“模具”或者“压缩包”，里面把跑程序需要的一切都打包好了。	就像是一个装好系统、装好软件的虚拟机快照文件。
容器	镜像运行时的实体，可以被创建、启动、停止、删除。	镜像跑起来后，就成了容器。容器是活的，可以读可以写。	就像是把虚拟机快照启动起来，变成一个正在运行的虚拟机。
数据卷	容器与宿主机之间共享数据的目录，绕过容器文件系统。	容器用完就扔，数据会丢。数据卷就是在宿主机开个口子，把数据存下来。	就像是在宿主机和容器之间拉了一根网线，文件可以互相传输。
GPU 支持	宿主机通过 NVIDIA Container Toolkit 将 GPU 暴露给容器使用。	默认容器是用不了显卡的，必须通过特殊设置把显卡“借”给容器用。	就像是给租户（容器）配了一把主机（宿主机）显卡的钥匙。

下面这张流程图，能帮你迅速搞清楚从拉取镜像到运行推理的全过程：

二、工欲善其事：Docker 环境准备与核心配置

2.1 安装 Docker：从零开始的第一步

无论你是 Windows、Mac 还是 Linux，安装 Docker 都不难，但咱们得确保装对了。

Windows 用户：推荐安装 Docker Desktop。去 Docker 官网下载安装包，一路 Next 即可。注意，Windows 上可能需要开启 WSL 2（Windows Subsystem for Linux）功能，安装程序通常会提示你。这一步是必须的，它能让 Docker 在 Windows 上跑得更顺滑。

Linux 用户（推荐 Ubuntu）：这是服务器环境的主流。不要用 apt install docker.io 这种老旧方式，建议按照官方脚本安装最新版。

以下是在 Ubuntu 系统下安装 Docker 的标准操作流程，虽然是命令行，但我详细解释了每一步的含义：

# 1. 更新软件包索引，确保咱们能下载到最新的东西
sudo apt-get update

# 2. 安装必要的依赖包，这些是用来支持通过 HTTPS 下载软件源的
sudo apt-get install apt-transport-https ca-certificates curl gnupg lsb-release

# 3. 添加 Docker 的官方 GPG 密钥，这就像是加了一把锁，确保你下载的软件没被篡改
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# 4. 设置稳定版软件源，告诉系统去哪里找 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

# 5. 再次更新索引，把刚才加的 Docker 源更新进来
sudo apt-get update

# 6. 安装 Docker Engine
sudo apt-get install docker-ce docker-ce-cli containerd.io

# 7. 验证安装是否成功，跑个 hello-world 试试
sudo docker run hello-world

如果最后你看到了 “Hello from Docker!” 的字样，恭喜你，第一步迈出去了。

2.2 关键一步：显卡支持的配置

做 YOLOv11 目标检测，不用 GPU 简直就是暴殄天物。CPU 推理慢得像蜗牛，GPU 才是跑车。

前提条件：你的宿主机（物理机）必须已经安装了 NVIDIA 显卡驱动，并且最好安装了 CUDA Toolkit（虽然容器里有 CUDA，但宿主机驱动必须要有）。

核心组件：NVIDIA Container Toolkit。这个东西是连接宿主机显卡和 Docker 容器的桥梁。没它，容器就是个瞎子，看不见显卡。

以下是安装 NVIDIA Container Toolkit 的详细步骤（以 Ubuntu 为例）：

# 1. 设置 NVIDIA 的软件包仓库
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg

curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
  sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

# 2. 更新源并安装工具包
sudo apt-get update
sudo apt-get install -y nvidia-container-toolkit

# 3. 配置 Docker 运行时，让 Docker 知道要用 NVIDIA 的运行环境
sudo nvidia-ctk runtime configure --runtime=docker

# 4. 重启 Docker 服务，让配置生效
sudo systemctl restart docker

怎么验证显卡配置好了？
别急，咱们跑一个官方的测试镜像，看看容器能不能识别到显卡：

# 这条命令的意思是：运行 nvidia/cuda 镜像，使用 GPU，并在容器内执行 nvidia-smi 命令
sudo docker run --rm --gpus all nvidia/cuda:11.6.2-base-ubuntu20.04 nvidia-smi

如果你看到了熟悉的显卡信息表格（显存大小、显卡型号、驱动版本等），那就说明你的 Docker 已经具备了调用 GPU 的能力。如果报错，通常是因为宿主机驱动没装好，或者 Toolkit 没配置对，回头检查一下上面的步骤。

2.3 镜像拉取：获取 YOLOv11 的“绿色安装包”

Ultralytics 官方非常贴心，直接在 Docker Hub 上发布了维护好的镜像。我们不需要自己写 Dockerfile 去编译 PyTorch，直接“拿来主义”。

YOLOv11 对应的是 Ultralytics 的最新版本库。镜像标签通常有几种：

latest: 最新版，推荐尝鲜使用。
python: 仅包含 Python 环境，体积较小。
cuda11 / cuda12: 基于 CUDA 版本的镜像，体积较大，适合深度学习。

我们直接拉取最新的支持 GPU 的镜像：

# 拉取官方最新镜像，这可能会花几分钟，取决于你的网速
# 如果网速慢，可以考虑配置国内的 Docker 镜像加速器
sudo docker pull ultralytics/ultralytics:latest

这里有个小技巧，如果拉取速度慢得像乌龟爬，建议配置阿里云或腾讯云的容器镜像加速器。在 /etc/docker/daemon.json 文件里加上几行配置就行，这里不展开细说，不然篇幅太长。

三、核心实战：一行命令搞定图片推理

3.1 Docker 命令参数大起底

很多新手看到 docker run 后面跟着一大串参数就头大，觉得像是在念咒语。别怕，咱们把这行命令拆解开来，一个词一个词地嚼碎了喂给你。

标准的 YOLOv11 推理命令大概长这样：

sudo docker run -it --rm --gpus all -v /home/user/data:/app/data ultralytics/ultralytics:latest yolo predict model=yolo11n.pt source=/app/data/bus.jpg

咱们用个表格来详细剖析每个参数的作用：

参数	完整含义	通俗解释	必要性
`docker run`	运行一个容器	告诉 Docker，我要把刚才下载的镜像跑起来。	必须
`-it`	`-i` (interactive) + `-t` (tty)	开启交互模式，让你能像操作终端一样操作容器。如果不加，容器可能跑完就退出了，你看不到输出。	建议加上
`--rm`	Remove on exit	容器运行结束后自动删除。如果不加，你每跑一次，机器里就会留下一堆“尸体”容器，占满磁盘。	强烈建议
`--gpus all`	GPU support	把宿主机的所有显卡都借给容器用。如果只想用一张卡，可以写 `--gpus device=0`。	做 AI 必须
`-v 宿主路径:容器路径`	Volume mount	最关键的一步。把宿主机的一个文件夹（存图片）映射到容器里。不然容器是个封闭盒子，读不到你的图片。	必须
`ultralytics/ultralytics:latest`	Image Name	指定用哪个镜像来跑。	必须
`yolo predict ...`	Command	容器启动后要执行的命令。这里调用的是 YOLOv11 的命令行接口 (CLI)。	必须

3.2 实战：推理单张图片

假设你现在有一张名为 bus.jpg 的图片（这张图是 YOLO 系列经典的测试图），存放在你电脑的 /home/myuser/test_images 目录下。

第一步：确认文件路径
先看看文件在不在：

ls /home/myuser/test_images/
# 输出应该包含 bus.jpg

第二步：构建并运行 Docker 命令
我们的目标是将宿主机的 test_images 目录挂载到容器内的 /workspace 目录（这个名字你可以随便起，但在容器里访问路径要对应）。

# 定义宿主机数据目录变量，方便复用
HOST_DATA_DIR="/home/myuser/test_images"
# 定义容器内数据目录变量
CONTAINER_DATA_DIR="/workspace"

# 执行推理命令
docker run -it --rm \
  --gpus all \
  -v $HOST_DATA_DIR:$CONTAINER_DATA_DIR \
  ultralytics/ultralytics:latest \
  yolo predict model=yolo11n.pt source=$CONTAINER_DATA_DIR/bus.jpg

代码与逻辑详细分析：

挂载逻辑 (-v)：这步就像是把宿主机的 test_images 文件夹，通过一根管子插到了容器的 /workspace 口子上。容器里看到 /workspace/bus.jpg，实际上读的就是宿主机里的那个文件。
模型下载 (model=yolo11n.pt)：当你第一次运行这个命令时，Ultralytics 库会自动检测本地有没有 yolo11n.pt。如果没有，它会自动从 GitHub 下载。这里有个坑点：下载是在容器里进行的。一旦容器退出（因为有 --rm），下载的模型也没了。
- 解决方案：如果你不想每次都下载模型，可以再挂载一个目录专门存模型，或者提前下载好模型放到挂载目录里。
输出结果：推理完成后，结果默认会保存在容器内的 runs/detect/predict 目录下。但因为容器删了，结果也没了。
- 怎么办？ 上面提到的 -v 挂载目录里，其实也会自动保存结果，因为 Ultralytics 默认会把结果写在输入目录附近，或者你可以指定 project 参数保存到挂载目录。

改进后的完整命令（自动保存结果到宿主机）：

# 假设我们把结果保存在宿主机的 /home/myuser/outputs 目录
docker run -it --rm \
  --gpus all \
  -v /home/myuser/test_images:/workspace \
  -v /home/myuser/outputs:/app/runs \
  ultralytics/ultralytics:latest \
  yolo predict model=yolo11n.pt source=/workspace/bus.jpg project=/app/runs name=result

这样，你就可以在宿主机的 /home/myuser/outputs/result 目录下看到推理出来的图片了。

3.3 深入理解 YOLOv11 的模型选择

上面我们用了 yolo11n.pt，这是 Nano 版本。YOLOv11 系列通常包含 n, s, m, l, x 五个尺寸。对于 Docker 体验来说，选对模型至关重要。

模型名称	参数量	相对计算量	速度 (FPS)	精度 (mAP)	适用场景	Docker 体验建议
YOLO11n	最少	最低	最快	较低	边缘设备、极速预览	首选。体积小（几MB），下载快，跑得飞快。
YOLO11s	较少	较低	快	中等	移动端、实时性要求高	次选。精度比 n 高一丢丢，速度慢一丢丢。
YOLO11m	中等	中等	中等	较高	通用工业场景	显存要求稍高，体验时可尝试。
YOLO11l	较多	较高	较慢	高	高精度要求	需要较好的显卡，否则推理延迟大。
YOLO11x	最多	最高	最慢	最高	科研、极致精度	不建议体验时用，显存容易爆，模型下载慢。

口语化解读：
n 模型就像是“小电驴”，轻便、起步快、不占地儿，虽然载重（精度）有限，但在城里（简单场景）跑得飞快。x 模型就是“重型卡车”，载重无敌，但启动慢、费油（显存），还需要 A100 这种“重型卡车司机”才能驾驭。咱们体验嘛，骑骑“小电驴”最舒服，等真要干活了再开卡车。

3.4 图片推理的进阶参数调整

Docker 命令里不仅能跑默认参数，还能微调推理细节。咱们来看几个常用的：

docker run -it --rm --gpus all \
  -v /home/user/data:/data \
  ultralytics/ultralytics:latest \
  yolo predict model=yolo11n.pt source=/data/bus.jpg \
  conf=0.25 \
  iou=0.7 \
  imgsz=640 \
  save=True \
  show_labels=True

参数详解：

conf=0.25：置信度阈值。只有模型觉得“我有 25% 以上的把握这东西是个车”，它才会画框。调高这个值（比如 0.5），可以过滤掉那些模棱两可的误检。
iou=0.7：NMS (非极大值抑制) 的 IOU 阈值。简单说，模型可能会对同一个物体画好几个框，这个参数决定把重叠度高的框合并成一个。调低一点，去重效果更强。
imgsz=640：推理尺寸。图片会被缩放到 640x640 像素再喂给模型。如果显存够大，可以设成 1280，能检测出更多小物体，但速度会变慢。

四、进阶实战：视频流目标检测

4.1 视频推理的特殊性与挑战

图片推理是一次性的计算，视频推理则是连续的流处理。这对 Docker 容器提出了新的要求：

文件读取：视频文件通常很大，挂载路径必须准确无误。
编码解码：容器里得有 FFmpeg 等解码库（官方镜像里已经装好了，不用担心）。
显示问题：视频推理默认是想播放出来的，但在 Docker 无头模式（Headless，即无显示器）下，直接播放会报错。我们要设置 show=False。

4.2 运行视频推理的标准流程

假设你有一个 traffic.mp4 的视频文件，想统计车流量或者单纯看效果。

# 定义路径
VIDEO_PATH="/home/user/videos/traffic.mp4"
SAVE_DIR="/home/user/outputs"

# 运行命令
docker run -it --rm --gpus all \
  -v $VIDEO_PATH:/app/video.mp4 \
  -v $SAVE_DIR:/app/output \
  ultralytics/ultralytics:latest \
  yolo predict model=yolo11n.pt source=/app/video.mp4 \
  project=/app/output name=video_result \
  show=False save=True

代码逻辑深度剖析：

-v $VIDEO_PATH:/app/video.mp4：这里我直接把文件挂载成了文件，而不是挂载目录。这在 Docker 里也是允许的，可以防止容器里看到多余的文件。
source=/app/video.mp4：告诉 YOLOv11，源文件在容器内的这个路径。
show=False：关键点。在服务器或终端里，因为没有图形界面，如果你设置 show=True，程序会尝试弹窗播放视频，结果就是报错 Cannot connect to X server。所以在 Docker 环境下，一定要把这个关掉。
save=True：必须保存，否则跑完一通视频，啥也没留下。生成的结果通常是 video_result/video.mp4。

4.3 实时流与 RTSP 推理

很多做安防的程序员问我，怎么在 Docker 里接摄像头或者 RTSP 流？其实道理一样，source 参数不仅支持文件，还支持流地址。

docker run -it --rm --gpus all \
  ultralytics/ultralytics:latest \
  yolo predict model=yolo11n.pt source="rtsp://admin:[email protected]:554/stream" show=False save=True

注意：

这种方式不需要挂载卷，因为流数据是从网络来的。
但这有个前提：容器必须能访问到这个 RTSP 地址。如果摄像头在内网，宿主机能访问，但 Docker 容器默认用的是桥接网络，可能网络不通。
解决方案：使用 --network host 参数，让容器共享宿主机的网络命名空间。

# 加上 --network host，容器就能像宿主机一样访问内网摄像头了
docker run -it --rm --gpus all --network host \
  ultralytics/ultralytics:latest \
  yolo predict model=yolo11n.pt source="rtsp://..." show=False save=True

4.4 性能优化：视频推理的速度调优

视频推理慢是常态，但咱们可以用 Docker 的一些手段优化一下。

方法一：多线程解码
YOLOv11 后端依靠 OpenCV 或 PyAV 解码。可以通过环境变量来调整线程数，但这在 Docker 里属于高阶操作，通常默认即可。

方法二：流式处理而非全量加载
YOLOv11 会自动处理，它不会把整个几 GB 的视频读到内存里，而是读一帧、算一帧、存一帧。这就是为什么你会发现生成的视频文件是一点点变大的。

方法三：使用 TensorRT 加速镜像（高阶）
如果你有 NVIDIA 显卡，且显存够大，强烈推荐拉取 TensorRT 版本的镜像。虽然这在“极速体验”范畴稍微有点超纲，但不得不提。TensorRT 能把模型速度提升 2-5 倍。

# 拉取 TensorRT 版本镜像（注意标签变化）
docker pull ultralytics/ultralytics:latest-tensorrt

# 运行时会自动使用 TRT 引擎，或者你需要手动导出 engine
docker run -it --rm --gpus all \
  -v /home/user/data:/data \
  ultralytics/ultralytics:latest-tensorrt \
  yolo predict model=yolo11n.engine source=/data/video.mp4

注：第一次运行需要将 .pt 转换为 .engine，这会花费较长时间，但转换完成后，后续推理将极速。

五、数据持久化与文件管理

5.1 避免“容器一关，数据全丢”

初学者最容易踩的坑就是：跑完命令，看到终端里打印出结果了，兴冲冲地退出容器，结果发现本地啥也没留下。这是因为 Docker 容器的文件系统是临时的。

核心原则：凡是你想留下的东西，一定要放在挂载卷里。

我们来构建一个标准化的工程目录结构，方便管理。

宿主机目录结构建议：

/home/user/yolo_project/
├── datasets/          # 存放数据集和测试素材
│   ├── images/
│   └── videos/
├── models/            # 存放下载好的 .pt 模型文件
├── runs/              # 存放推理结果（自动生成）
└── scripts/           # 存放自定义脚本（如果有）

对应的 Docker 运行命令模板：

# 设置项目根目录变量
PROJ_ROOT="/home/user/yolo_project"

# 运行一个交互式容器，把所有相关目录都挂载进去
# 这样容器里就能读写宿主机的文件了
docker run -it --rm --gpus all \
  -v $PROJ_ROOT/datasets:/app/datasets \
  -v $PROJ_ROOT/models:/app/models \
  -v $PROJ_ROOT/runs:/app/runs \
  --workdir /app \
  ultralytics/ultralytics:latest \
  bash

解析：

我这里把入口命令换成了 bash。这意味着你不是直接运行推理，而是进入容器内部，打开了一个 Shell 终端。
--workdir /app：进入容器后，直接停留在 /app 目录下。
这样你就可以在容器里像操作本地 Linux 一样，敲 yolo predict ...，然后生成的文件会实时同步到宿主机的对应目录里。这种方式对于调试和多次测试非常方便。

5.2 权限问题：令人头疼的 Root 用户

在 Linux 下使用 Docker，经常会遇到一个尴尬的事：容器里默认是 root 用户运行。结果容器生成的文件，宿主机上看不到，或者提示“Permission denied”。

现象：
你在容器里生成了 result.jpg，回到宿主机一看，文件所有者是 root，你自己的账号打不开，得 sudo chown 改权限。

解决方案：
在 docker run 时加上用户映射参数 -u。

# 获取当前用户的 UID 和 GID
CURRENT_UID=$(id -u)
CURRENT_GID=$(id -g)

# 运行时指定用户
docker run -it --rm --gpus all \
  -u $CURRENT_UID:$CURRENT_GID \
  -v $PROJ_ROOT:/app \
  ultralytics/ultralytics:latest \
  yolo predict model=yolo11n.pt source=/app/datasets/images/bus.jpg

注意：
使用 -u 参数虽然解决了文件权限问题，但可能会导致容器内部某些需要 root 权限的操作失败（比如安装新的 apt 包）。不过对于仅仅是运行推理来说，通常是没问题的。

六、常见问题与排错指南

6.1 显存不足

报错信息：
RuntimeError: CUDA out of memory. Tried to allocate XXX MiB

原因分析：
模型太大了，或者图片/视频分辨率太高，显存塞不下了。

解决方案：

换小模型：把 yolo11l.pt 换成 yolo11n.pt 或者 yolo11s.pt。
降低推理尺寸：加上参数 imgsz=320，把输入变小。虽然精度会降，但显存占用会大幅减小。
清空缓存：有时候是之前的进程占着显存没放。在宿主机跑一下 nvidia-smi，看看显存占用，把不用的进程杀掉。

6.2 找不到文件

报错信息：
FileNotFoundError: [Errno 2] No such file or directory: '/app/data/bus.jpg'

原因分析：
路径映射搞错了。这是新手最容易犯的错。你可能以为挂载的是目录，结果写错了路径。

排查步骤：

检查 docker run 里的 -v 参数，冒号左边是宿主机路径，右边是容器路径。

如果你进了容器（用 bash），记得用 ls 看看容器里的路径下到底有没有文件。

# 进入容器调试
docker run -it --rm -v /home/user/data:/app/data ultralytics/ultralytics:latest bash
root@container_id:/# ls /app/data
# 如果这里啥都没有，说明挂载失败，回去检查宿主机路径

6.3 网络连接问题

现象：
模型下载不动，一直卡在 Downloading...。

原因：
容器网络环境受限，或者连不上 GitHub。

解决方案：

预下载：在宿主机上挂梯子或者用浏览器把 yolo11n.pt 下载下来，放到挂载目录里。

指定本地路径：

# 假设模型已经下载到了 /home/user/models/yolo11n.pt
docker run ... -v /home/user/models:/app/models ... yolo predict model=/app/models/yolo11n.pt ...

七、Docker 进阶玩法：自定义配置与 API 调用

7.1 使用 Python 脚本在容器内运行

虽然命令行 (CLI) 很方便，但有时候我们想写个 Python 脚本来控制流程（比如批量处理）。Docker 同样支持。

本地编写脚本 detect.py：

# detect.py
from ultralytics import YOLO

# 加载模型
model = YOLO('yolo11n.pt')

# 推理图片
results = model.predict(source='data/bus.jpg', save=True, conf=0.25)

# 打印结果信息
for result in results:
    print(f"检测到 {len(result.boxes)} 个目标")
    # 这里可以做更多逻辑，比如存数据库、发邮件等

挂载脚本并运行：

docker run -it --rm --gpus all \
  -v /home/user/project:/app \
  ultralytics/ultralytics:latest \
  python /app/detect.py

这种方式极大地扩展了 Docker 容器的用途，你可以在本地用 VS Code 写好代码，然后丢给 Docker 容器去跑，完全不用管本地环境乱成什么样。

7.2 使用 REST API 服务

Ultralytics 镜像其实还自带了一个 Web 服务功能。你可以把容器变成一个 API 服务器，通过 HTTP 请求来传图和获取结果。这对于做应用集成的开发者来说简直是福音。

启动服务：

# -p 参数是把容器的端口映射到宿主机
# 这里把容器的 8000 端口映射到了宿主机的 8000 端口
docker run -it --rm --gpus all \
  -p 8000:8000 \
  ultralytics/ultralytics:latest \
  yolo serve

客户端调用测试：
启动后，你就可以在浏览器或者 Postman 里访问 http://localhost:8000 来上传图片进行检测了。这让你可以在不安装任何深度学习环境的情况下，直接在别的编程语言（如 Java, Go, Node.js）里调用 YOLOv11 的能力。

至此，关于 YOLOv11 的 Docker 极速体验教程就告一段落了。从环境搭建到显卡配置，从简单的图片推理到复杂的视频流处理，再到数据持久化和 API 服务，这一套流程下来，相信你已经能像老司机一样熟练操作了。Docker 让环境配置不再是拦路虎，让我们能把更多精力放在算法逻辑和业务落地上。赶紧去试试吧！

转载自CSDN-专业IT技术社区

原文链接：https://blog.csdn.net/2501_92809516/article/details/159602876