【YOLO】Docker搭建镜像+运行容器

引言

镜像和容器的关系和区别

1. 验证宿主机安装了docker、nvidia-docker、显卡驱动

查看服务器上是否安装了docker

docker -v

查看服务器上是否安装了nvidia-docker

dpkg -l | grep nvidia-docker

查看服务器安装了显卡驱动

nvidia-smi

2. 在docker的配置文件中配置镜像加速器

cd /etc/docker
sudo vim daemon.json

添加或修改以下内容：

{
       "registry-mirrors": [
              "https://registry.docker-cn.com",
                  "https://docker.mirrors.ustc.edu.cn",
                   "https://hub-mirror.c.163.com",
                   "https://mirror.baidubce.com",
                   "https://docker.m.daocloud.io",
                   "https://noohub.ru",
                   "https://huecker.io",
                   "https://dockerhub.timeweb.cloud"
       ],
       "runtimes": {
        "nvidia": {
            "args": [],
            "path": "/usr/bin/nvidia-container-runtime"
        }
    }
}

然后重启 Docker 服务

sudo systemctl daemon-reload
sudo systemctl restart docker

3. 构建docker镜像

3.1 手动拉取镜像

sudo docker pull [基础环境]
sudo docker pull pytorch/pytorch:2.0.1-cuda11.7-cudnn8-runtime

3.2 编辑Dockerfile

3.2.1 x86_64/AMD64 架构

博主使用的可用镜像配置（Dockerfile）如下:

# 基础环境（根据不同的宿主机架构修改）
FROM pytorch/pytorch:2.0.1-cuda11.7-cudnn8-runtime
# 安装基本工具（根据不同的宿主机架构修改）
RUN apt-get update && \
    apt-get install -y --no-install-recommends \
    gcc git zip unzip wget curl vim htop libgl1 libglib2.0-0 libpython3-dev gnupg g++ libusb-1.0-0 libsm6 \
    && rm -rf /var/lib/apt/lists/*

# 安装 X11 依赖（可视化）
RUN apt-get update && apt-get install -y \
    x11-apps \
    libgl1-mesa-glx \
    libxcb-xinerama0 \
    && rm -rf /var/lib/apt/lists/*

# 设置环境变量（可视化）
ENV QT_QPA_PLATFORM=xcb
ENV QT_X11_NO_MITSHM=1

# 设置工作目录（容器的根目录）
WORKDIR /alian

# 安装 pip 并更新到最新版本，同时配置使用阿里源
RUN curl -sS https://bootstrap.pypa.io/get-pip.py | python3 \
    && pip config set global.index-url https://mirrors.aliyun.com/pypi/simple

# 其他所需要的包
RUN pip install flask scipy numpy matplotlib tqdm PyYAML Pillow opencv-python==4.10.0.84 open3d tensorboard h5py Seaborn ultralytics yolo \
    && rm -rf /var/lib/apt/lists/*

若宿主机已经搭建好可用的yolov11的虚拟环境，则可以导出为requirements.txt

cd [本地项目]
conda activate [虚拟环境名]
pip freeze > requirements.txt

在Dockerfile添加：

COPY requirements.txt .
RUN pip install --no-cache-dir  -r requirements.txt 

3.2.2 linux/arm64/v8架构

# 查看指令
uname -m

Dockerfile如下:

FROM nvcr.io/nvidia/l4t-pytorch:r35.2.1-pth2.0-py3

# 安装系统依赖（确保换行符正确）
RUN apt-get update && \
    apt-get install -y --no-install-recommends \
    libhdf5-dev libhdf5-serial-dev \
    gcc git zip unzip wget curl vim htop \
    libgl1 libglib2.0-0 libpython3-dev gnupg g++ \
    libusb-1.0-0 libsm6 \
    && rm -rf /var/lib/apt/lists/*

# 安装 X11 依赖
RUN apt-get update && apt-get install -y \
    x11-apps libgl1-mesa-glx libxcb-xinerama0 \
    && rm -rf /var/lib/apt/lists/*

# 设置环境变量
ENV QT_QPA_PLATFORM=xcb
ENV QT_X11_NO_MITSHM=1

# 工作目录
WORKDIR /home/nvidia

# 配置阿里源并安装 Python 包
RUN pip config set global.index-url https://mirrors.aliyun.com/pypi/simple \
    && pip install --no-cache-dir \
    flask scipy numpy matplotlib tqdm PyYAML Pillow \
    opencv-python==4.10.0.84 open3d tensorboard h5py==3.10.0 Seaborn \
    && pip install --no-cache-dir ultralytics yolo

# 复制并安装项目依赖
#COPY requirements.txt .
#RUN pip install --no-cache-dir -r requirements.txt

# 复制应用代码
COPY . .

3.3 构建 Docker 镜像

docker build -t [镜像名称] [Dockerfile所在的目录]
docker build -t yolo11:v0 /media/ll/L/llr/a2023_my_3d/Arail_fusion

查看镜像

docker images

测试可视化

xhost +local:docker
docker run --rm -it -e DISPLAY=$DISPLAY -v /tmp/.X11-unix:/tmp/.X11-unix yolo11:v0 xeyes
xhost -local:docker

出现随鼠标移动的眼睛，则说明可视化成功！

4.运行docker容器

先启动容器，确保容器在运行，再进入容器

4.1 启动容器

docker run [选项] <镜像名> [命令]
docker run -it <镜像名> /bin/bash
docker run -it --name [容器名] -v [宿主机目录]:[容器目录]-p 8000:80 [镜像名称:版本号] /bin/bash

-i: 交互式操作
-t: 终端。
/bin/bash：放在镜像名后的是命令，希望有个交互式 Shell，因此用的是/bin/bash。
-d：指定容器在后台运行。
-v：将宿主机目录挂载到容器目录，注意：不能挂到容器的/tmp目录，不然进入容器运行apt-get update命令会报错，挂载到其他目录可以。
-p：后面的数字表示端口映射中主机端和容器端分别使用的端口，主机端口:容器端口。
–name：指定容器名字
–gpus all：表示将所有可用的 GPU 分配给容器。
–rm：表示容器退出后自动删除，一般用于查看镜像配置

docker run -it --name yolo11 yolo11:v0 /bin/bash
docker run -it  --env="DISPLAY" --env="QT_X11_NO_MITSHM=1" --volume="/tmp/.X11-unix:/tmp/.X11-unix:rw" --name yolo11 -v /media/ll/L/llr/a2023_my_3d/Arail_fusion:/alian/Arail_fusion -v/media/ll/0FE806A40FE806A41/DATASET/3D_data:/alian/3D_data -p 1111:1111  yolo11:v0

4.2 进入容器

docker exec -it [容器名] /bin/bash

5.验证容器内的环境

在容器中运行下面代码alian_detect.py，终端成功输出并可视化则说明容器环境成功！

from ultralytics import YOLO
 
# 加载预训练的YOLOv11n模型
model = YOLO(r"weights_yolo/yolo11n.pt")
 
# 对'bus.jpg'图像进行推理，并获取结果
results = model.predict(r"test_image/test1.jpg", save=True, imgsz=640, conf=0.5)
 
# 处理返回的结果
for result in results:
    boxes = result.boxes       # 获取边界框信息
    result.show()              # 显示结果

6. Docker其他常用命令

# 1.退出容器
exit
 
# 2.查看运行中的容器
docker ps
 
# 3.查看所有容器
docker ps -a
 
# 4.开启已有的容器
docker start <容器ID前3位>
 
# 5.进入已存在的容器，利用exce命令时，需保证该容器是开启状态
docker exec -it <容器ID前3位> /bin/bash
 
# 6.删除容器,必须将容器停止后才能删除
docker rm <容器ID前3位>
 
# 7.依赖镜像的容器都删除完后，才能删除镜像
docker rmi <镜像ID前3位>
 
# 8.将容器导出为镜像
docker export -o /path/to/output/file.tar <容器ID前3位> 
 
# 9.导入镜像快照
docker import name.tar <镜像名称:版本号>
 
# 10.将容器存为镜像
docker commit <容器ID前3位> <镜像名称:版本号>
 
# 11.将镜像导出保存为tar文件
docker save -o <保存路径/*.tar> <镜像名称:版本号>
 
# 12.导入镜像
docker load -i <镜像文件*.tar>
 
# 13.通过指定 URL 或者某个目录来导入
docker import http://example.com/exampleimage.tgz example/imagerepo
 
# 14.通过命令 docker commit 来提交容器副本(同命令10)
docker commit -m="has update" -a="runoob" <容器ID前3位> runoob/ubuntu:v2
#### -m提交更改信息, -a创建者名称
 
# 15.使用 docker tag 命令，为镜像添加一个新的标签。
docker tag <镜像ID前3位> <镜像名>:新标签
 
# 16.从容器到宿主机，或从宿主机到容器的文件复制操作
docker cp [OPTIONS] SRC_PATH CONTAINER:DEST_PATH
docker cp [OPTIONS] CONTAINER:SRC_PATH DEST_PATH

7. 镜像与容器的指令对比

# 构建镜像（Dockerfile所在目录）
docker build -t myapp:v1 .
# 运行容器（基于镜像）
docker run -d --name myapp_container myapp:v1

# 查看镜像列表
docker images
# 查看容器详情（包括IP、挂载卷等）
docker inspect myapp_container

# 删除镜像（需先删除依赖容器）
docker rmi myapp:v1
# 删除已停止的容器
docker rm myapp_container

# 停止并删除容器
docker stop myapp_container && docker rm myapp_container

# 导出镜像
docker save -o myapp.tar myapp:v1
# 进入运行中的容器
docker exec -it myapp_container bash

8. 启动容器之后还能再挂在目录吗？

方案 1：提交容器为新镜像并重新运行

# 1. 停止原容器
docker stop <容器名>

# 2. 将容器当前状态保存为新镜像
docker commit <容器名> <新镜像名>

# 3. 重新运行容器并添加新挂载
docker run -it \
  -v /host/data:/container/data \      # 原挂载（需保留）
  -v /host/new_data:/container/new_data \  # 新增挂载
  <新镜像名>

方案 2：临时文件复制（无需重建）

# 将主机文件复制到运行中的容器
docker cp /host/new_data <容器名>:/container/new_data

限制：复制是静态的，后续主机文件变更不会同步到容器内。

方案 3：使用 Docker Volume（推荐持久化场景）

# 1. 创建可管理的卷
docker volume create my_volume

# 2. 将卷挂载到运行中的容器（需停止后重新运行）
docker run -it -v my_volume:/container/data <镜像名>

生产环境建议

预先规划挂载：在 docker run 时声明所有需要的挂载

docker run -it \
  -v /host/config:/app/config \
  -v /host/logs:/app/logs \
  my_image

使用 Docker Compose：通过配置文件管理复杂挂载

services:
  app:
    volumes:
      - "./config:/app/config"
      - "./data:/app/data"

在主机修改文件后，手动同步到容器

rsync -avz /host/new_data/ $(docker inspect --format='{{.Id}}' <容器名>):/container/new_data/