docker介绍与常用命令汇总

docker简介

docker是什么？

Docker 是一个开源的应用容器引擎，它可以让开发者将应用与运行环境打包成一个标准的、可移植的容器（Container），在任何地方都可以快速部署和运行，无需关心底层环境是否一致。

核心优势：

• 快速启动与部署

• 高效利用资源

• 易于迁移与复制

• 开发环境一致性

一句话总结： Docker 是一个“构建-打包-交付-运行”一体化的容器平台。

docker 的基本架构？

Docker 采用了 客户端-服务器 架构，核心组件包括：

• Docker 客户端（Client）：用户通过命令行工具 docker 与 Docker 守护进程通信。

• Docker 守护进程（Docker Daemon）：负责构建、运行和管理容器。

• Docker 镜像（Image）：容器的模板，是构建容器的基础。

• Docker 容器（Container）：镜像的运行实例，是应用的实际运行环境。

• Docker 仓库（Registry）：存储和分发镜像，官方默认使用 Docker Hub。

+-------------------------+        +--------------------+
|   Docker 客户端 (CLI)   |<-------> Docker 守护进程     |
+-------------------------+        |  (dockerd)         |
                                    +--------------------+
                                            |
                    +-----------------------+------------------------+
                    |                        |                        |
            +---------------+        +---------------+        +------------------+
            |   镜像管理器   |        | 容器运行时 (runc)|        | 网络/存储管理器   |
            +---------------+        +---------------+        +------------------+
                    |
                    v
           +------------------+
           | Docker 镜像仓库   |
           | (Docker Hub / 私有)|
           +------------------+

• Client 发起命令 -> 守护进程执行操作。

• 守护进程拉取镜像、创建容器、上传/下载镜像到 Registry。

docker 与虚拟机的区别？

补充：Guest OS中文是客户操作系统，是指运行在虚拟机中的操作系统，他与我们平时安装在电脑上的操作系统(Host OS：主机操作系统)是并列概念。

传统虚拟机：

+----------------------------+
|      硬件服务器             |
+----------------------------+
|      主机操作系统           |
+----------------------------+
| 虚拟机管理程序（Hypervisor）|
+----------------------------+
|   VM1   |   VM2   |   VM3   |
|   OS    |   OS    |   OS    |
|  App1   |  App2   |  App3   |
+----------------------------+

虚拟机的“重”在于完整操作系统

在 VM 架构中，每一个 VM 都包含一个完整的 Guest OS（比如 Ubuntu、CentOS），这意味着：

• 要为每个 VM 分配独立的系统资源；

• 启动慢，运行中资源占用高；

• 升级或维护成本大（多个系统要分别更新）。

这也是 Hypervisor 存在的原因：它在物理机与 Guest OS 之间提供虚拟化支持，但这层抽象带来性能损耗。

Docker 容器结构：

+----------------------------+
|      硬件服务器             |
+----------------------------+
|      主机操作系统           |
+----------------------------+
|        Docker 引擎         |
+----------------------------+
| 容器1 | 容器2 | 容器3       |
| App1  | App2  | App3        |
+----------------------------+

容器的“轻”源于共享宿主内核

Docker 容器运行在 Docker 引擎之上，所有容器共享宿主 OS 的内核，但通过内核提供的：

• namespace（名字空间）机制：隔离进程、网络、文件系统等；

• cgroups（控制组）机制：限制资源使用（如内存、CPU）；

从而实现逻辑上的“隔离”，同时保留极高的运行效率。

docker应用场景？

开发环境快速搭建

通过 Dockerfile 或镜像，一键构建完整开发环境，如 Node.js + Redis + MySQL 组合。

多版本/多实例服务运行

不同版本的同一服务可同时部署在不同容器中，避免端口/依赖冲突。

微服务架构部署

Docker 非常适合微服务架构的部署，每个微服务一个容器，统一管理和升级。

docker涉及的一些概念

镜像(image)------docker的可执行模板

Docker 镜像是一个只读模板，它包含了运行某个应用所需要的所有内容，包括：

• 操作系统（如 Ubuntu、Alpine）

• 应用程序（如 nginx、redis）

• 应用所需依赖（如库文件、环境变量）

• 初始化指令（如启动服务）

镜像就像一个“安装包 + 配置说明书”，你可以从镜像中创建出“运行中的实例” —— 容器。

镜像怎么创建？

方式一：直接拉取别人构建好的镜像

比如你拉取了 nginx 镜像，它里面可能包含：

• 一个轻量操作系统（如 Alpine）

• nginx 主程序

• 默认配置文件

• 启动命令（如 CMD ["nginx", "-g", "daemon off;"]）

方式二：自己通过编写Dockerfile创建自己的镜像

注意：我们也可以在拉取别人镜像的基础上创建属于自己的镜像。

容器(container)-----镜像的运行实例

容器是基于镜像创建的、可运行的独立环境，它就像一个轻量级的虚拟机，但比传统虚拟机：

• 启动更快（秒级）

• 占用更少资源（共享宿主机内核）

• 更易移植（镜像打包后“无差运行”）

容器 = 镜像 + 运行时状态（进程、网络、挂载点、环境变量等）

数据卷(volume)

前提：容器是“临时的”，容器被创建时，它是干净的；容器被删除时，它的数据也会一同消失

这就带来一个问题：

• 如果我运行的是一个数据库容器（如 MySQL），数据怎么保存下来？

• 如果我写入了日志或用户上传了文件，容器一删这些数据就没了？

所以我们需要“数据持久化”机制 —— 数据卷

数据卷就是 Docker 提供的一块专门用来保存数据的“独立存储空间”，它不属于容器，但可以被容器挂载和访问。

我们可以这样理解：

• 容器就像一个快递盒子

• 数据卷就像一个外接硬盘

• 你可以把快递盒子丢了（删除容器），但外接硬盘里的数据还在（数据卷不被删除）

docker网络(docker network)

Docker 网络，是容器之间进行通信的桥梁，就像现实中的“网线”和“交换机”，让容器能够相互“看见”并访问彼此。

Docker 网络解决了几个关键问题：

Docker Compose

Docker 官方提供的一个多容器应用编排工具，通过一个 docker-compose.yml 文件，你可以用一行命令启动、停止、构建多个服务容器，非常适合管理复杂应用。

• 你写好一个 yml 配置文件，

• 然后一句命令：docker-compose up

• 就能自动搭好整个应用环境：Web、数据库、缓存、后台进程……全部一次性启动

为什么需要docker compose？

在开发中，经常会遇到下面这种情况：

Docker Compose就是为了解决这些问题。

一个完整的 Compose 项目一般包括 3 部分：

docker-compose.yml 文件示例

version: '3.8'

services:
  web:
    build: .
    ports:
      - "8080:80"
    depends_on:
      - db

  db:
    image: mysql:8.0
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: 123456
    volumes:
      - dbdata:/var/lib/mysql

volumes:
  dbdata:

• services：定义所有容器服务，如 web、db

• build：从当前目录的 Dockerfile 构建镜像

• image：使用已有镜像

• ports：端口映射（宿主机:容器）

• volumes：挂载卷（可复用数据）

• depends_on：依赖关系（控制启动顺序）

• environment：设置环境变量

• networks 和 volumes：可选，全局定义网络或数据卷

docker常用命令

镜像相关命令

容器管理命令

 网络管理命令

 数据卷

 Docker Compose 命令（需要安装 docker-compose）

 Swarm 管理命令（用于集群部署）

 安全与身份验证相关命令（Login、Registry）

系统清理与信息查看命令（System） 

dockerfile的编写 

制作一个docker镜像需要编写相应的dockerfile，dockerfile的内容是由一系列指令构成的，每个指令都会构建一个新的镜像层，因为 Docker 的镜像是通过多个只读的文件系统层堆叠而成的。每个 Dockerfile 指令都会生成一个新的镜像层，并在前一层的基础上进行修改。这样的设计使得 Docker 镜像具有可重复构建和高度可定制的特性。

Dockerfile:
  FROM ubuntu
    |
    v
  RUN apt update
    |
    v
  RUN apt install -y python3
    |
    v
  COPY . /app
    |
    v
  CMD ["python3", "/app/main.py"]

每个指令生成一个镜像层
[ 镜像层 1: FROM ubuntu ]
       ↓
-----------------------------
       ↓
[ 镜像层 2: RUN apt update ]
       ↓
-----------------------------
       ↓
[ 镜像层 3: RUN apt install -y python3 ]
       ↓
-----------------------------
       ↓
[ 镜像层 4: COPY . /app ]
       ↓
-----------------------------
       ↓
[ 镜像层 5: CMD ["python3", "/app/main.py"] ]

dockerfile常用指令

FROM

指定构建镜像所基于的基础镜像。

FROM <image>[:tag]

<image>：镜像的名称
官方镜像名（如：ubuntu、node、python 等）
用户镜像名（如：myrepo/myapp、username/image-name）
私有仓库路径（如：registry.example.com/myapp）
注意：镜像默认从 Docker Hub 拉取，除非指定了私有仓库地址。

:tag 镜像的版本标签
用于标识镜像的特定版本
如果省略则默认使用lastest标签，即最新版本
python:3.11, node:18, ubuntu:20.04

注意：每个 Dockerfile必须以 FROM 开头（除非使用 scratch：代表一个空白的基础镜像）。

LABEL

为镜像添加元数据信息（键值对形式），用于标注作者、版本、描述等信息。

LABEL key=value

• 添加作者信息：LABEL maintainer="admin@example.com"

• 添加版本描述：LABEL version="1.0"

• 添加镜像简要说明：LABEL description="my image"

ENV

设置环境变量，在后续的 RUN、CMD、ENTRYPOINT 中可使用。环境变量可用于统一配置，如语言环境、应用路径等。

ENV <key> <value>

ENV CC=gcc \
    CXX=g++ \
    CFLAGS="-O2" \
    APP_HOME=/usr/src/app

RUN

执行命令并提交为新镜像层。常用于安装软件包、修改系统配置等。

RUN <command>（shell 形式）或 RUN ["executable", "param1", "param2"]（exec 形式）

安装依赖：RUN apt update && apt install -y curl
创建目录：RUN mkdir -p /opt/myapp
执行程序并传入参数：RUN ["./myapp", "--mode", "release"]

COPY

将构建上下文中的文件复制到镜像中。适合复制本地静态资源、源码文件等。
构建上下文是什么？

当你执行docker build -t myapp .时

这个.就是构建上下文，表示当前目录。Docker 会把这个目录里的所有内容（除 .dockerignore 排除的）打包发送给 Docker 引擎，然后 Dockerfile 才能用 COPY 或 ADD 去访问这些文件。

COPY <src> <dest>

复制代码文件：COPY . /app
复制配置文件：COPY config.json /etc/app/config.json

 ADD

与COPY 类似，但功能更强，支持解压 tar 文件和 URL。简单复制场景推荐使用COPY

ADD <src> <dest>

自动解压：ADD app.tar.gz /opt/

WORKDIR

设置工作目录，影响后续命令的执行路径。自动创建目录，不存在会自动创建。

WORKDIR <path>

设置应用目录：WORKDIR /app
效果类似于cd到某个目录下，然后接下来的操作默认都是在这个目录下完成
# 在 /app 目录下创建 main.cpp
COPY main.cpp .     # 实际效果相当于 COPY main.cpp /app/main.cpp
# 在 /app 目录下执行编译
RUN g++ main.cpp -o myapp

EXPOSE

声明镜像运行时容器会监听的端口（仅供文档/说明用，不实际打开端口，容器内部端口的监听，是由容器里运行的程序决定的。EXPOSE 本身不启动程序，也不绑定端口）。

EXPOSE <port>

Web 应用：EXPOSE 8080
数据库服务：EXPOSE 3306

补充：端口监听与端口映射

CMD

指定容器启动时默认执行的命令。只能有一个 CMD，若多个则只保留最后一个。

CMD ["executable","param1","param2"]

启动应用：CMD ["python3", "app.py"]

ENTRYPOINT

设置容器的主命令，不可被 docker run 参数覆盖（可与 CMD 配合）。

ENTRYPOINT ["executable", "param1", "param2"]

以某应用作为容器唯一入口：ENTRYPOINT ["nginx", "-g", "daemon off;"]
与cmd配合
ENTRYPOINT ["python3", "app.py"]
CMD ["--help"]
运行容器时如果不带参数：docker run myimage   这时 Docker 会执行：python3 app.py --help
运行容器时如果带参数：docker run myimage --version   
这时 Docker 会执行：python3 app.py --version

ENTRYPOINT 定义的是主命令，这个命令基本不会变。
CMD 定义的是默认参数，可以被运行容器时的参数替代。
运行容器时的额外参数，会替代 CMD 的参数，但不会替代 ENTRYPOINT。

补充：RUN CMD ENTRYPOINT区别

VOLUME

定义匿名卷，挂载目录以便持久化数据，防止容器删除后数据丢失。

VOLUME ["<path>"]

持久化数据库数据：VOLUME ["/var/lib/mysql"]

补充：VOLUME ["/var/lib/mysql"] 这条指令，是在容器里定义了一个挂载点目录。那么，数据实际存储在宿主机的哪里？我在本地电脑上怎么找到这些数据？

• VOLUME 只是在容器中声明了一个卷挂载点，数据不会直接存放在容器的普通文件系统层，而是存到 Docker 管理的宿主机卷存储位置。

• 这个位置一般是 Docker 引擎管理的目录，比如在 Linux 系统默认路径通常是：/var/lib/docker/volumes/

• 具体数据会在这个目录下的某个子目录里，名称是 Docker 自动生成的卷名或者你自己创建的卷名。

假设你启动了一个带卷的容器，可以用下面命令找到卷对应的宿主机目录：

docker volume ls            # 列出所有卷
docker volume inspect 卷名  # 查看某个卷的详细信息

USER

设置运行镜像时的用户身份。

USER <user>[:<group>]

如果不指定，默认情况下 Docker 容器是以 root 用户身份运行的。
安全起见，不以 root 运行：USER nobody

ARG

定义构建时的参数，也就是在构建镜像过程中可传递的变量，在镜像构建时传入（不能用于运行时）。常用于传递版本号、路径、配置选项等，灵活定制镜像。

ARG <name>[=<default>]

构建时指定版本号：ARG APP_VERSION=1.0
然后用：RUN echo $APP_VERSION
RUN是构建时执行
构建时不传入参数docker build -t myapp .
输出：1.0
构建时传入参数：docker build --build-arg APP_VERSION=2.3 -t myapp .
输出：2.3

• ARG 定义的变量只能用于 Dockerfile 中构建阶段的命令，比如 RUN、ENV 等。

• ARG 变量不会保存在镜像中，镜像运行时无法访问。

• 如果想让变量在镜像运行时可用，需要使用 ENV。

FROM ubuntu:20.04

ARG APP_VERSION=1.0
RUN echo "Building version $APP_VERSION"

ENV APP_VERSION=$APP_VERSION
CMD echo "Running version $APP_VERSION"

示例：

我们有一个简单的 C++ 项目，目录结构如下：

├── Dockerfile
├── main.cpp
├── config.json
├── resources.tar.gz

我们的目标是用 Docker 构建这个项目的镜像，自动编译 main.cpp，并运行编译后的可执行程序。

# 1. 基础镜像
FROM ubuntu:20.04

# 2. 添加标签
LABEL maintainer="admin@example.com"
LABEL version="1.0"
LABEL description="C++项目的Docker示例，包含全部常用Dockerfile指令"

# 3. 构建参数
ARG APP_VERSION=1.0

# 4. 设置环境变量
ENV APP_HOME=/app
ENV LANG=C.UTF-8
ENV VERSION=$APP_VERSION

# 5. 创建工作目录
WORKDIR $APP_HOME

# 6. 复制源代码和配置文件
COPY main.cpp $APP_HOME/
COPY config.json /etc/app/config.json

# 7. 添加压缩资源（会自动解压）
ADD resources.tar.gz /opt/

# 8. 安装依赖并构建应用
RUN apt-get update && \
    apt-get install -y g++ && \
    g++ main.cpp -o myapp && \
    rm main.cpp

# 9. 暴露端口（假设该应用监听 8080）
EXPOSE 8080

# 10. 定义匿名卷用于持久化日志或数据
VOLUME ["/var/log/myapp"]

# 11. 使用非 root 用户运行
USER nobody

# 12. 设置程序执行入口（执行二进制）
ENTRYPOINT ["./myapp"]

# 13. 默认参数（可选传参）
CMD ["--version"]