# docker快速上手教程

**Repository Path**: gjj2006/docker-quick-start-tutorial

## Basic Information

- **Project Name**: docker快速上手教程
- **Description**: 一分钟速成docker，明眼人一看就能学会的教程，有手就行一秒搞定！
- **Primary Language**: Unknown
- **License**: GPL-3.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 2
- **Forks**: 1
- **Created**: 2025-12-06
- **Last Updated**: 2025-12-20

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 一、Docker 简介

## 1.1 Docker 原理简介

你可以把 Docker 理解为另一种虚拟机。以下你可以把容器当作虚拟机。

**对比虚拟机：**
- **虚拟机**：模拟整个电脑（硬件+完整系统），笨重、启动慢、占用资源多。
- **Docker**：只虚拟软件环境，和当前系统有重合的部分就直接调用了，所以很快，开销小。

**Docker 的优势：**
- Docker 很方便打包成"镜像"：把整个容器全部打个包带走，可以在别的机器上直接跑。
- 一键部署：无需手动配环境，一行命令就能跑起来，再也不说"在我电脑上好好的"。

> （有时间还是简易完整了解一下 Docker 到底是怎么一回事，具体了解一下你会发现我上面的简介极不严谨）

## 1.2 Docker 相关名词

- **Image 镜像**：和你安装虚拟机的那个镜像是一个道理

- **Container 容器**：和你用镜像装出来一个能用的 Ubuntu 是一个道理，但是这个很方便打包

- **Dockerfile**：这是个新东西，是一个文本文件，里面写着构建镜像的步骤。比如你想在容器里自动执行 `sudo apt update` 这个命令，就可以写进 Dockerfile，构建镜像时就会自动执行，不用每次手动敲命令

# 二、Docker 使用

## 2.1 基本操作

```bash
docker info
```
查看 Docker 系统信息，包括容器数量、镜像数量、存储驱动等详细配置

```bash
docker version
```
查看 Docker 版本信息，显示客户端和服务端的详细版本号

```bash
docker --version
```
查看 Docker 简略版本信息，只显示版本号

```bash
docker login
```
登录 DockerHub，需要输入用户名和密码，登录后可以推送和拉取私有镜像

```bash
docker login nvcr.io
```
登录 NVIDIA 容器镜像仓库，用于拉取 NVIDIA 官方的 GPU 相关镜像

## 2.2 镜像管理

```bash
docker images
```
查看本地所有镜像，显示镜像名称、标签、ID、创建时间和大小

```bash
docker pull [IMAGE]
```
从 Docker Hub 或其他镜像仓库拉取镜像到本地电脑，例如：`docker pull ubuntu:22.04`

说明：`ubuntu:22.04` 中，`ubuntu` 是镜像名，`:22.04` 是标签（版本号），不写标签默认是 `:latest`

```bash
docker rmi [IMAGE]
```
删除本地指定的镜像，释放磁盘空间，例如：`docker rmi ubuntu:22.04`

```bash
docker commit [CONTAINER] [IMAGE]:[TAG]
```
将一个运行中的容器保存为新的镜像，可以把你对容器的修改打包成新镜像

```bash
docker save -o myimage.tar [IMAGE]
```
将镜像导出保存为 tar 文件，方便在没有网络的环境下传输镜像

```bash
docker load -i path/to/myimage.tar
```
从 tar 文件中加载镜像到本地，与 `docker save` 配合使用

```bash
docker tag [IMAGE_ID] [NEW_NAME]:[NEW_TAG]
```
给镜像重命名或添加新标签，不会复制镜像，只是给同一个镜像起个新名字

## 2.3 容器管理

```bash
docker create [IMAGE]
```
创建一个新容器但不启动它，容器处于停止状态

```bash
docker run [IMAGE]
```
创建并立即运行容器，这是最常用的启动容器命令

```bash
docker start [CONTAINER]
```
启动一个已经停止的容器，让它重新运行

```bash
docker stop [CONTAINER]
```
停止一个正在运行的容器，会给容器时间保存数据后再关闭

```bash
docker restart [CONTAINER]
```
重启容器，相当于先 stop 再 start

```bash
docker ps
```
列出当前正在运行的所有容器，显示容器 ID、名称、状态等信息

```bash
docker ps -a
```
列出所有容器，包括正在运行的和已停止的容器

```bash
docker exec -it [CONTAINER] /bin/bash
```
进入正在运行的容器内部，启动交互式终端，可以在容器里执行命令

```bash
docker rm [CONTAINER]
```
删除一个已停止的容器，释放资源

说明：`[CONTAINER]` 可以填容器的 ID 或容器的名字，下面所有 `[CONTAINER]` 和 `[IMAGE]` 都是一样的道理

```bash
docker port [CONTAINER]
```
查看容器的端口映射情况，显示容器端口和主机端口的对应关系

```bash
docker top [CONTAINER]
```
查看容器内正在运行的进程，类似 Linux 的 top 命令

```bash
docker stats [CONTAINER]
```
实时查看容器的资源使用情况，包括 CPU、内存、网络等

```bash
docker cp [CONTAINER]:[PATH] [LOCAL_PATH]
```
从容器内拷贝文件到本地电脑，例如：`docker cp mycontainer:/app/log.txt ./log.txt`

```bash
docker cp [LOCAL_PATH] [CONTAINER]:[PATH]
```
从本地电脑拷贝文件到容器内，例如：`docker cp ./config.json mycontainer:/app/`

```bash
docker export -o mycontainer.tar [CONTAINER]
```
将容器导出为 tar 文件，可以用于备份或迁移容器

```bash
docker import path/to/mycontainer.tar [IMAGE]:[TAG]
```
从 tar 文件导入并创建新镜像

## 2.4 容器运行参数

```bash
docker run --name [NAME] [IMAGE]
```
创建并运行容器，同时给容器指定一个名字，方便后续管理

```bash
docker run -d [IMAGE]
```
创建容器并在后台运行，不会占用当前终端，容器会一直在后台默默运行

```bash
docker run -p [LOCAL_PORT]:[CONTAINER_PORT] [IMAGE]
```
创建容器并指定端口映射，将主机端口映射到容器端口，例如：`-p 8080:80` 表示访问主机 8080 端口就是访问容器的 80 端口

```bash
docker run -v [LOCAL_PATH]:[CONTAINER_PATH] [IMAGE]
```
创建容器并将本地目录挂载到容器目录，实现主机和容器之间的文件共享

```bash
docker run -it [IMAGE] /bin/bash
```
创建容器并启动交互式 shell，可以直接在容器内执行命令

# 三、Docker 实战示例

使用 Docker 前，先检查一下 Docker 是否正常运行：

```bash
docker info
```

## 3.1 获取镜像的两种方法

### 3.1.1 从 Docker Hub 获取镜像

可以用 `docker pull` 命令从 Docker Hub 拉取镜像。例如，以下命令可拉取带有 Nginx 服务的镜像：

```bash
docker pull nginx:stable-alpine-perl
```

### 3.1.2 用 Dockerfile 构建镜像

可以用 Dockerfile 定义一个镜像的构建过程，包括基础镜像、安装软件、环境变量等。

下面这个 Dockerfile 以 Ubuntu 22.04 为基础镜像，安装了 Miniconda 和 Jupyter Lab，并将 Jupyter Lab 日志写入工作目录的 jupyter_lab.log 文件。

```dockerfile
# Dockerfile 文件

# 使用 Ubuntu 22.04 LTS 作为基础镜像
FROM ubuntu:22.04

# 设置环境变量
ENV DEBIAN_FRONTEND=noninteractive

# 更新 apt-get 并安装必要的依赖
RUN apt-get update && apt-get install -y \
    wget \
    bzip2 \
    curl \
    git \
    && rm -rf /var/lib/apt/lists/*

# 安装 Miniconda
RUN wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O miniconda.sh && \
    bash miniconda.sh -b -f -p /opt/conda && \
    rm miniconda.sh && \
    /opt/conda/bin/conda init bash

# 设置 conda 环境路径
ENV PATH=/opt/conda/bin:$PATH

# 安装 Jupyter Lab
RUN conda install -y jupyterlab

# 创建工作目录
WORKDIR /workspace

# 暴露 Jupyter Lab 默认端口
EXPOSE 8888

# 启动 Jupyter Lab，设置根目录为工作目录，禁用浏览器，禁用 token
CMD ["sh", "-c", "nohup jupyter lab --ip=0.0.0.0 --allow-root --notebook-dir=/ --no-browser > /workspace/jupyter_lab.log 2>&1"]
```

使用以下命令构建镜像：

```bash
# 1. 检查 docker 环境是否正常
docker info

# 2. 构建镜像，-t 参数指定镜像名称，. 表示使用当前目录的 Dockerfile
docker build -t jupyter_server_image .
```

镜像构建完成后，可以在客户端中查看镜像信息：

```bash
docker images
```

## 3.2 如何启动容器

一旦镜像完成构建，可以通过以下命令启动容器：

```bash
# 3. 测试容器
docker run \
    --rm \
    --gpus all \
    -it \
    --name jupyter_server_app \
    jupyter_server_image /bin/bash

# 4. 运行容器
docker run \
    --gpus all \
    --name jupyter_server_app \
    -d \
    -p 9999:8888 \
    -v $(pwd)/jupyter_workspace:/workspace \
    jupyter_server_image
```

**运行选项说明：**

- `--rm`: 当容器退出时自动删除容器，常用于测试
- `--gpus all`: 启用所有可用的 GPU 资源，让容器可以使用显卡
- `-it`: 启动交互式终端，可以在容器内输入命令
- `--name`: 为容器指定名字，方便管理
- `-d`: 以后台模式运行容器，不占用当前终端
- `-p <local-port>:<container-port>`: 将主机端口映射到容器端口，实现外部访问
- `-v <local-path>:<container-path>`: 将主机路径挂载到容器路径，实现文件共享

## 3.3 GPU 机器配置（可选）

如果你需要在 Docker 容器里使用 GPU（比如跑深度学习模型），需要做以下配置。如果不需要 GPU，可以跳过这一节。

### 1）检查 NVIDIA 驱动程序

确保你的系统上已经安装了 NVIDIA 驱动程序。你可以通过 `nvidia-smi` 命令来检查是否已安装并输出版本信息。

```bash
nvidia-smi
```
这个命令会显示 GPU 信息、驱动版本、显存使用情况等

### 2）安装 NVIDIA Container Toolkit

如果还没有安装 NVIDIA Container Toolkit，可以通过以下命令安装（以 Ubuntu 为例）：

```bash
# 1. 添加 NVIDIA 软件包列表
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

# 2. 更新 apt 缓存，并安装 NVIDIA Container Toolkit
sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit

# 3. 重启Docker服务
sudo systemctl restart docker
```

### 3）检查 CUDA 和 PyTorch

CUDA 和 PyTorch 通常在 NVIDIA 官方容器中已经安装好了。运行以下命令验证是否已安装：

```bash
# 输出 CUDA 版本，CUDA 是 NVIDIA 的并行计算平台
nvcc --version

# 输出 PyTorch 版本，查看深度学习框架是否安装
pip show torch
```

## 3.4 修改默认存储目录（可选）

在 Linux 系统下，Docker 的所有数据（镜像、容器、数据卷）默认存储在 `/var/lib/docker` 目录。如果你的 Docker 镜像和容器很多，这个目录可能会占满磁盘空间，这时候就需要把存储目录改到空间更大的磁盘上。以下是具体步骤：

### 1）停止 Docker 服务

在修改存储目录之前，需要先停止 Docker 服务，避免数据损坏：

```bash
sudo systemctl stop docker
```
停止 Docker 服务，确保没有容器在运行

### 2）迁移现有数据（可选）

如果已经有 Docker 容器和镜像，需要将 `/var/lib/docker` 目录下的数据迁移到新的存储目录。假设新的存储目录为 `/new_docker_location`，可以使用以下命令进行迁移：

```bash
# 创建新的存储目录
sudo mkdir -p /new_docker_location

# 使用 rsync 同步数据，保留文件权限和属性
sudo rsync -avzP /var/lib/docker/ /new_docker_location/
```

### 3）配置 Docker 的新存储目录

创建或编辑 `/etc/docker/daemon.json` 文件，如果文件不存在则创建它，并添加以下内容：

```json
{
    "data-root": "/new_docker_location"
}
```

### 4）启动 Docker 服务

完成上述配置后，启动 Docker 服务：

```bash
sudo systemctl start docker
```
启动 Docker 服务，使新配置生效

确认新的存储目录配置成功且 Docker 可以正常工作后，可以删除旧的存储目录：

```bash
# 删除旧的存储目录，释放磁盘空间（请确认新目录工作正常后再执行）
sudo rm -rf /var/lib/docker
```


# 四、新手第一次使用 Docker（Hello World）

> **重要提示**：建议你自己手动敲一遍下面的命令，而不是复制粘贴。这样能帮助你更好地理解和记忆每个命令的作用。

这是一个完整的从零开始的 Docker 使用流程，使用 Docker 官方的 hello-world 镜像作为示例。

## 4.1 完整操作流程

### 步骤 1：检查 Docker 是否正常运行

```bash
docker info
```
如果能看到 Docker 的系统信息，说明 Docker 已经正常运行了

### 步骤 2：拉取 hello-world 镜像

```bash
docker pull hello-world
```
这个命令会从 Docker Hub 下载官方的 hello-world 镜像到你的电脑

### 步骤 3：查看本地镜像

```bash
docker images
```
你应该能看到刚才下载的 hello-world 镜像，大小只有几 KB

### 步骤 4：运行容器

```bash
docker run hello-world
```
这个命令会创建并运行一个容器，你会看到一段欢迎信息，说明 Docker 安装成功了

### 步骤 5：查看所有容器（包括已停止的）

```bash
docker ps -a
```
你会看到刚才运行的 hello-world 容器，状态是 Exited（已退出），因为它打印完信息就自动退出了

### 步骤 6：删除容器

```bash
docker rm [容器ID或容器名称]
```
把上一步看到的容器 ID 或名称填进去，删除这个已经停止的容器

### 步骤 7：删除镜像

```bash
docker rmi hello-world
```
删除 hello-world 镜像，释放磁盘空间

## 4.2 简单的 Dockerfile 示例

现在我们自己写一个超级简单的 Dockerfile，创建一个会打印 "Hello Docker!" 的镜像。

### 步骤 1：创建一个新文件夹

```bash
mkdir my-first-docker
cd my-first-docker
```

### 步骤 2：创建 Dockerfile 文件

在 my-first-docker 文件夹里创建一个名为 `Dockerfile` 的文件（注意没有扩展名），内容如下：

```dockerfile
# 使用 Ubuntu 作为基础镜像
FROM ubuntu:22.04

# 容器启动时执行的命令
CMD echo "Hello Docker! 这是我的第一个 Docker 镜像！"
```

**解释：**
- `FROM ubuntu:22.04`：告诉 Docker 以 Ubuntu 22.04 为基础来构建镜像
- `CMD`：指定容器启动时要执行的命令，这里就是打印一句话

### 步骤 3：构建镜像

```bash
docker build -t my-hello-image .
```
- `-t my-hello-image`：给镜像起个名字叫 my-hello-image
- `.`：表示 Dockerfile 在当前目录

### 步骤 4：查看镜像

```bash
docker images
```
你应该能看到刚才创建的 my-hello-image 镜像

### 步骤 5：运行你的镜像

```bash
docker run my-hello-image
```
你会看到输出：`Hello Docker! 这是我的第一个 Docker 镜像！`

### 步骤 6：清理资源

```bash
# 查看所有容器
docker ps -a

# 删除容器（把容器ID替换成你看到的）
docker rm [容器ID]

# 删除镜像
docker rmi my-hello-image
```

## 4.3 一个稍微复杂一点的例子

再来一个稍微复杂点的 Dockerfile，让容器里能执行多个命令：

```dockerfile
# 使用 Ubuntu 作为基础镜像
FROM ubuntu:22.04

# 在镜像里安装 curl 工具
RUN apt-get update && apt-get install -y curl

# 设置工作目录
WORKDIR /app

# 创建一个文本文件
RUN echo "这是在构建镜像时创建的文件" > hello.txt

# 容器启动时执行的命令
CMD cat hello.txt && echo "容器启动成功！"
```

**解释：**
- `RUN`：在构建镜像时执行的命令，这里用来安装软件和创建文件
- `WORKDIR`：设置工作目录为 /app，后续的命令都在这个目录下执行
- `CMD`：容器启动时执行，这里会先显示文件内容，再打印一句话

构建并运行：

```bash
# 构建镜像
docker build -t my-second-image .

# 运行容器
docker run my-second-image
```

你会看到输出文件内容和启动成功的提示。

---

**恭喜！** 你已经完成了 Docker 的基本操作，从拉取镜像、运行容器，到自己编写 Dockerfile 构建镜像。接下来可以尝试更复杂的应用了！


# 五、Docker Compose 简介（可选）

Docker Compose 是一个用于管理多容器 Docker 应用的工具。如果你的项目需要同时运行多个容器（比如一个 Web 服务器 + 一个数据库），用 Docker Compose 可以一次性启动和管理所有容器，非常方便。

通过一个 YAML 文件（`docker-compose.yml`）就可以定义多个服务及其配置，然后用一条命令启动所有服务。

## 5.1 安装 Docker Compose

**对于 MacOS 和 Linux：**

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

# 给文件添加执行权限
chmod +x ~/docker-compose

# 移动到系统路径
sudo mv ~/docker-compose /usr/local/bin/docker-compose
```

**对于 Windows：**

Docker Desktop for Windows 已经自带了 Docker Compose，无需单独安装。

安装完成后，验证安装：

```bash
docker-compose --version
```

## 5.2 常用命令

```bash
docker-compose version
```
显示 Docker Compose 的版本信息

```bash
docker-compose up
```
创建并启动所有服务容器，会在前台运行并显示日志

```bash
docker-compose up -d
```
以后台模式启动所有服务容器，不占用当前终端

```bash
docker-compose down
```
停止并删除所有容器、网络，清理环境

```bash
docker-compose start
```
启动已经创建但停止的服务容器

```bash
docker-compose stop
```
停止正在运行的服务容器，但不删除它们

```bash
docker-compose restart
```
重启所有服务容器

```bash
docker-compose ps
```
列出所有服务容器及其状态信息

```bash
docker-compose logs
```
查看所有服务容器的日志输出

```bash
docker-compose logs -f [SERVICE]
```
实时查看指定服务的日志，`-f` 表示持续跟踪

```bash
docker-compose exec [SERVICE] [COMMAND]
```
在运行中的服务容器内执行命令，例如：`docker-compose exec web bash`

```bash
docker-compose build
```
构建或重新构建服务镜像

```bash
docker-compose config
```
检查 `docker-compose.yml` 文件是否有语法错误

```bash
docker-compose rm
```
删除已停止的服务容器

```bash
docker-compose top
```
显示所有服务容器的运行进程

```bash
docker-compose pause
```
暂停服务容器

```bash
docker-compose unpause
```
恢复已暂停的服务容器

```bash
docker-compose images
```
列出所有服务使用的镜像

```bash
docker-compose port [SERVICE] [PORT]
```
显示指定服务的端口绑定情况

```bash
docker-compose kill
```
强制终止服务容器

```bash
docker-compose help
```
查看帮助信息

## 5.3 简单示例

创建一个 `docker-compose.yml` 文件，定义一个简单的 Web 应用：

```yaml
version: '3'
services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html
```

**解释：**
- `version: '3'`：指定 Docker Compose 文件格式版本
- `services`：定义要运行的服务
- `web`：服务名称
- `image: nginx:latest`：使用 nginx 最新版镜像
- `ports`：端口映射，主机 8080 映射到容器 80
- `volumes`：挂载本地 html 目录到容器

启动服务：

```bash
# 启动服务
docker-compose up -d

# 查看运行状态
docker-compose ps

# 停止并清理
docker-compose down
```

---

**提示**：Docker Compose 适合开发环境和小型项目。如果你只是运行单个容器，直接用 `docker run` 就够了。