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 与虚拟机的区别？

架构组件	虚拟机（VM）	容器（Docker）
中间层	虚拟机管理器（Hypervisor）	Docker 引擎
操作系统层	每个虚拟机一个完整的操作系统	所有容器共享宿主操作系统内核
资源分配	为每个 VM 分配固定 CPU、内存等，资源隔离明显	容器之间共享资源，按需使用，隔离通过 namespace 和 cgroups 实现
启动时间	分钟级（需要启动整个操作系统）	秒级（只需启动应用进程）
系统开销	高（需要管理多个操作系统）	低（内核复用，运行开销小）
可移植性	跨平台部署较复杂	镜像一致，跨平台移植方便

补充：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 网络怎么解决
容器之间如何通信？	容器加入同一个网络，就像在一个局域网中
怎么访问宿主机或互联网？	Docker 默认提供 NAT 转发
怎么隔离容器？	网络可以分组，防止不同容器互相干扰
多服务（如 Web + DB）怎么互联？	用网络连接它们，像搭积木一样组服务

Docker Compose

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

你写好一个 yml 配置文件，
然后一句命令：docker-compose up
就能自动搭好整个应用环境：Web、数据库、缓存、后台进程……全部一次性启动

为什么需要docker compose？

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

传统方式	存在的问题
用 `docker run` 启多个容器	容器之间依赖配置麻烦
容器名字、端口、网络、数据卷要手动指定	容易错、不好维护
想重启整个应用需要 N 条命令	运维效率低下

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

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

组成	描述
`docker-compose.yml`	核心配置文件，定义了服务、网络、卷等
`.env`	可选的环境变量文件
项目目录结构	一般包括源码、Dockerfile 等

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 images`	列出本地所有镜像
`docker image ls`	同上，官方推荐写法
`docker pull <image>`	从远程仓库拉取镜像
`docker pull <image>:<tag>`	拉取指定标签的镜像
`docker build -t <name>:<tag> .`	从 Dockerfile 构建镜像
`docker rmi <image_id>`	删除镜像
`docker image rm <image_id>`	同上，更推荐的写法
`docker image prune`	删除未被使用的悬空镜像
`docker image inspect <image>`	查看镜像详细信息
`docker tag <image> <new_name>`	给已有镜像打新标签
`docker save -o <file>.tar <image>`	导出镜像为 tar 包
`docker load -i <file>.tar`	从 tar 包导入镜像
`docker history <image>`	查看镜像构建历史

容器管理命令

命令	说明
`docker ps`	查看正在运行的容器
`docker ps -a`	查看所有容器（包括已停止）
`docker run <image>`	运行一个容器
`docker run -it <image> bash`	以交互方式运行容器并进入 shell
`docker run -d <image>`	后台运行容器
`docker start <container_id>`	启动已停止的容器
`docker stop <container_id>`	停止运行中的容器
`docker restart <container_id>`	重启容器
`docker rm <container_id>`	删除容器
`docker exec -it <container_id> <command>`	在运行中的容器中执行命令
`docker attach <container_id>`	附着到容器控制台
`docker logs <container_id>`	查看容器输出日志
`docker inspect <container_id>`	查看容器详细信息
`docker cp <container_id>:<path> <local_path>`	从容器拷贝文件到本地
`docker cp <local_path> <container_id>:<path>`	从本地拷贝文件到容器
`docker top <container_id>`	查看容器中的进程
`docker stats`	实时查看容器资源使用情况
`docker rename <old_name> <new_name>`	重命名容器

网络管理命令

命令	说明
`docker network ls`	列出所有网络
`docker network inspect <network_name>`	查看指定网络详细信息
`docker network create <network_name>`	创建自定义网络（默认为 bridge）
`docker network create -d bridge <name>`	创建 bridge 网络
`docker network create -d overlay <name>`	创建 overlay 网络（Swarm 模式用）
`docker network connect <network> <container>`	将容器连接到网络
`docker network disconnect <network> <container>`	将容器从网络中移除
`docker network rm <network_name>`	删除网络

数据卷

命令	说明
`docker volume ls`	列出所有卷
`docker volume create <volume_name>`	创建卷
`docker volume inspect <volume_name>`	查看卷详细信息
`docker volume rm <volume_name>`	删除卷
`docker volume prune`	删除所有未被使用的卷
`docker run -v <volume_name>:<container_path> <image>`	使用卷运行容器
`docker run -v $(pwd):<container_path> <image>`	使用当前目录作为挂载点运行容器（bind mount）

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

命令	说明
`docker-compose up`	根据 docker-compose.yml 启动所有服务
`docker-compose up -d`	以后台方式启动服务
`docker-compose down`	停止并移除服务容器、网络等
`docker-compose ps`	查看 compose 管理的容器状态
`docker-compose logs`	查看服务日志
`docker-compose logs -f`	持续输出日志
`docker-compose build`	构建服务镜像
`docker-compose restart`	重启服务
`docker-compose exec <service> <cmd>`	在指定服务容器中执行命令
`docker-compose config`	验证和查看解析后的配置
`docker-compose pull`	拉取 compose 文件中定义的镜像
`docker-compose stop`	停止服务但不移除容器
`docker-compose start`	启动已存在但停止的服务容器

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

命令	说明
`docker swarm init`	初始化当前节点为 Swarm 管理节点
`docker swarm join --token <token> <manager_ip>:2377`	加入集群
`docker node ls`	查看集群节点
`docker service create --name <name> <image>`	创建服务
`docker service ls`	查看服务列表
`docker service ps <service_name>`	查看服务任务
`docker service scale <name>=<count>`	扩缩容服务
`docker service update --image <new_image> <service>`	更新服务
`docker service rm <service>`	删除服务
`docker stack deploy -c docker-compose.yml <stack_name>`	使用 compose 文件部署 stack
`docker stack rm <stack_name>`	移除 stack
`docker stack services <stack_name>`	查看 stack 中的服务

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

命令	说明
`docker login`	登录 Docker Hub 或私有仓库
`docker logout`	登出当前仓库
`docker login <registry_url>`	登录指定私有仓库
`docker push <image>`	推送镜像到远程仓库
`docker pull <image>`	拉取镜像
`docker tag <image> <registry_url>/<name>:<tag>`	给镜像打私有仓库标签

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

命令	说明
`docker system df`	查看 Docker 磁盘使用情况
`docker system prune`	清理未使用的数据（容器、镜像、网络、卷）
`docker system prune -a`	更彻底地清理，包括所有未使用镜像
`docker info`	显示 Docker 系统详细信息
`docker version`	查看 Docker 版本
`docker events`	实时输出 Docker 事件日志
`docker stats`	实时显示所有容器的资源使用情况

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

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

端口监听	端口映射
容器内的程序在某个端口（如 80）监听网络请求	把宿主机某个端口（如 8080）映射到容器内监听的端口（如 80）
是程序行为，程序决定监听哪个端口	是 Docker 网络配置，用户决定如何暴露端口

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区别

指令	执行时机	用途	是否可被覆盖	举例
RUN	镜像构建时	安装软件、构建环境	不可覆盖	RUN apt-get install
CMD	容器启动时	容器默认执行命令（可被覆盖）	可被覆盖	CMD ["nginx"]
ENTRYPOINT	容器启动时	容器固定入口命令	不轻易覆盖	ENTRYPOINT ["python"]

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"]