Docker 命令详细使用教程

一、Docker 概述

Docker 是一个开源的应用容器引擎，让开发者可以打包应用以及依赖包到一个可移植的镜像中，然后发布到任何流行的 Linux 或 Windows 机器上。

二、镜像管理命令

1. 搜索镜像

# 搜索 Docker Hub 上的镜像
docker search nginx

# 过滤搜索结果
docker search --filter stars=1000 nginx
docker search --filter is-official=true nginx

2. 拉取镜像

# 拉取最新版本镜像
docker pull nginx

# 拉取指定版本镜像
docker pull nginx:1.21

# 拉取指定平台的镜像
docker pull --platform linux/amd64 nginx

3. 列出镜像

# 列出所有镜像
docker images

# 列出所有镜像（包括中间层镜像）
docker images -a

# 只显示镜像ID
docker images -q

# 格式化输出
docker images --format "table {{.ID}}\t{{.Repository}}\t{{.Tag}}"

4. 删除镜像

# 删除指定镜像
docker rmi nginx

# 强制删除镜像
docker rmi -f nginx

# 删除所有镜像
docker rmi $(docker images -q)

# 删除悬空镜像（无标签）
docker image prune

5. 镜像历史

1 2	# 查看镜像构建历史 docker history nginx

6. 镜像标签

1 2	# 给镜像打标签 docker tag nginx my-nginx:v1

7. 保存和加载镜像

# 保存镜像到文件
docker save -o nginx.tar nginx

# 从文件加载镜像
docker load -i nginx.tar

# 保存多个镜像
docker save -o images.tar nginx redis

三、容器管理命令

1. 运行容器

# 运行容器（前台模式）
docker run nginx

# 运行容器（后台模式）
docker run -d nginx

# 运行容器并指定名称
docker run --name my-nginx -d nginx

# 运行容器并映射端口
docker run -p 8080:80 -d nginx

# 运行容器并挂载数据卷
docker run -v /host/path:/container/path -d nginx

# 运行容器并设置环境变量
docker run -e MY_VAR=value -d nginx

# 运行容器并设置重启策略
docker run --restart always -d nginx

# 运行容器并限制资源
docker run -m 512m --cpus=1 -d nginx

2. 列出容器

# 列出运行中的容器
docker ps

# 列出所有容器（包括停止的）
docker ps -a

# 列出最近创建的容器
docker ps -l

# 列出容器大小
docker ps -s

3. 启动/停止/重启容器

# 启动已停止的容器
docker start container_name

# 停止运行中的容器
docker stop container_name

# 强制停止容器
docker kill container_name

# 重启容器
docker restart container_name

# 暂停容器
docker pause container_name

# 恢复暂停的容器
docker unpause container_name

4. 进入容器

# 进入运行中的容器（创建新的终端）
docker exec -it container_name /bin/bash

# 在容器中执行命令
docker exec container_name ls /app

# 进入容器（使用现有终端）
docker attach container_name

5. 查看容器信息

# 查看容器日志
docker logs container_name

# 实时查看日志
docker logs -f container_name

# 查看最近10条日志
docker logs --tail 10 container_name

# 查看容器详细信息
docker inspect container_name

# 查看容器进程
docker top container_name

# 查看容器资源使用情况
docker stats container_name

# 查看所有容器资源使用
docker stats --all

6. 文件操作

# 从容器复制文件到主机
docker cp container_name:/path/to/file /host/path

# 从主机复制文件到容器
docker cp /host/path container_name:/path/to/file

7. 删除容器

# 删除已停止的容器
docker rm container_name

# 强制删除容器（包括运行中的）
docker rm -f container_name

# 删除所有已停止的容器
docker container prune

# 删除所有容器
docker rm -f $(docker ps -aq)

四、网络管理命令

1. 网络操作

# 列出网络
docker network ls

# 创建网络
docker network create my-network

# 查看网络详情
docker network inspect my-network

# 连接容器到网络
docker network connect my-network container_name

# 断开容器网络连接
docker network disconnect my-network container_name

# 删除网络
docker network rm my-network

2. 端口映射

1 2	# 查看端口映射 docker port container_name

五、数据卷管理命令

1. 数据卷操作

# 创建数据卷
docker volume create my-volume

# 列出数据卷
docker volume ls

# 查看数据卷详情
docker volume inspect my-volume

# 删除数据卷
docker volume rm my-volume

# 删除未使用的数据卷
docker volume prune

六、Docker Compose 命令

1. 基本命令

# 启动服务
docker-compose up

# 后台启动服务
docker-compose up -d

# 使用指定文件
docker-compose -f docker-compose.prod.yml up

# 停止服务
docker-compose down

# 查看服务状态
docker-compose ps

# 查看服务日志
docker-compose logs

# 实时查看日志
docker-compose logs -f

# 构建服务镜像
docker-compose build

# 重启服务
docker-compose restart

# 缩放服务实例
docker-compose up --scale web=3

七、系统管理命令

1. 系统信息

# 查看 Docker 系统信息
docker info

# 查看 Docker 版本
docker version

# 查看磁盘使用情况
docker system df

# 查看详细磁盘使用
docker system df -v

2. 清理资源

# 删除所有未使用的资源
docker system prune

# 删除所有资源（包括镜像、容器、网络等）
docker system prune -a

# 删除所有未使用的镜像
docker image prune -a

八、构建镜像命令

1. Dockerfile 构建

# 构建镜像
docker build -t my-image:latest .

# 指定 Dockerfile 路径
docker build -f Dockerfile.dev -t my-image:dev .

# 构建时不使用缓存
docker build --no-cache -t my-image .

# 设置构建参数
docker build --build-arg APP_VERSION=1.0 -t my-image .

九、实战示例

1. 运行 WordPress

# 创建网络
docker network create wordpress-network

# 运行 MySQL
docker run -d \
  --name mysql \
  --network wordpress-network \
  -e MYSQL_ROOT_PASSWORD=rootpass \
  -e MYSQL_DATABASE=wordpress \
  -e MYSQL_USER=wordpress \
  -e MYSQL_PASSWORD=wordpresspass \
  mysql:5.7

# 运行 WordPress
docker run -d \
  --name wordpress \
  --network wordpress-network \
  -p 8080:80 \
  -e WORDPRESS_DB_HOST=mysql \
  -e WORDPRESS_DB_USER=wordpress \
  -e WORDPRESS_DB_PASSWORD=wordpresspass \
  -e WORDPRESS_DB_NAME=wordpress \
  wordpress

2. 使用 Docker Compose

创建 docker-compose.yml：

version: '3'
services:
  web:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./html:/usr/share/nginx/html
  db:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: example

运行：

1	docker-compose up -d

十、常用命令总结

命令	描述	示例
`docker run`	运行容器	`docker run -d nginx`
`docker ps`	列出容器	`docker ps -a`
`docker stop`	停止容器	`docker stop container`
`docker rm`	删除容器	`docker rm container`
`docker images`	列出镜像	`docker images`
`docker rmi`	删除镜像	`docker rmi nginx`
`docker pull`	拉取镜像	`docker pull nginx`
`docker exec`	执行命令	`docker exec -it container bash`
`docker logs`	查看日志	`docker logs container`
`docker build`	构建镜像	`docker build -t myimage .`

十一、注意事项

权限问题：某些命令可能需要 sudo 权限或在 Docker 用户组中
数据持久化：重要数据要使用数据卷或绑定挂载
资源限制：生产环境要设置适当的内存和 CPU 限制
网络安全：注意端口暴露和网络配置的安全性
镜像来源：尽量使用官方镜像或可信来源的镜像

这个教程涵盖了 Docker 的大部分常用命令，建议在实际环境中多加练习以熟悉这些命令的使用。

我们以一个典型的Web项目为例，该项目包含：

Nginx：作为反向代理和静态文件服务器
Spring Boot Jar包：作为后端应用（需要JDK运行环境）
MySQL：作为数据库
文件目录：用于存储上传的文件和配置文件

我将详细讲解如何为每个组件编写Dockerfile，以及如何使用docker run命令和docker-compose来运行整个系统。

一、项目结构规划

假设项目目录结构如下：

/my-app
  ├── docker-compose.yml          # 编排所有服务
  ├── nginx/
  │   ├── Dockerfile              # Nginx的Dockerfile
  │   ├── nginx.conf              # Nginx配置文件
  │   └── conf.d/
  │       └── app.conf            # 站点配置
  ├── backend/
  │   ├── Dockerfile              # 后端应用的Dockerfile
  │   ├── app.jar                 # Spring Boot打包的jar文件
  │   └── config/
  │       └── application.yml     # 应用配置文件
  ├── mysql/
  │   └── init.sql                # 数据库初始化脚本
  └── data/                       # 挂载的数据卷目录
      ├── uploads/                # 文件上传目录
      └── mysql/                  # MySQL数据目录

二、详细Dockerfile编写

1. 后端应用（Spring Boot + JDK）的Dockerfile

/my-app/backend/Dockerfile:

# 第一阶段：构建阶段（如果需要从源码构建则启用，这里假设已有jar包）
# FROM maven:3.8.4-openjdk-17 AS builder
# WORKDIR /app
# COPY pom.xml .
# COPY src ./src
# RUN mvn clean package -DskipTests

# 第二阶段：运行阶段
FROM openjdk:17-jdk-slim

# 设置维护者信息（可选）
LABEL maintainer="your-email@example.com"

# 设置时区
ENV TZ=Asia/Shanghai
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone

# 创建应用目录
WORKDIR /app

# 复制jar包到容器中
COPY app.jar app.jar

# 复制配置文件（可选，也可以通过挂载方式）
COPY config/ /app/config/

# 创建非root用户运行应用（安全最佳实践）
RUN groupadd -r appgroup && useradd -r -g appgroup appuser
RUN chown -R appuser:appgroup /app
USER appuser

# 暴露端口
EXPOSE 8080

# 设置JVM参数
ENV JAVA_OPTS="-Xms512m -Xmx1024m -Dspring.profiles.active=prod"

# 启动应用
ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar app.jar"]

关键指令解析：

FROM：基于官方JDK镜像
WORKDIR：设置工作目录
COPY：复制文件到镜像中
RUN：执行命令（创建用户、设置权限）
ENV：设置环境变量
EXPOSE：声明暴露端口
ENTRYPOINT：容器启动时执行的命令

2. Nginx的Dockerfile

/my-app/nginx/Dockerfile:

# 使用官方Nginx镜像
FROM nginx:1.23-alpine

# 删除默认配置文件
RUN rm /etc/nginx/conf.d/default.conf

# 复制自定义配置文件
COPY nginx.conf /etc/nginx/nginx.conf
COPY conf.d/app.conf /etc/nginx/conf.d/app.conf

# 创建日志目录（确保权限正确）
RUN mkdir -p /var/log/nginx && \
    chown -R nginx:nginx /var/log/nginx

# 暴露端口
EXPOSE 80 443

# 使用nginx用户运行（安全最佳实践）
USER nginx

# 启动Nginx（保持前台运行）
CMD ["nginx", "-g", "daemon off;"]

配套的Nginx配置文件：

/my-app/nginx/conf.d/app.conf:

upstream backend {
    server backend:8080;
}

server {
    listen 80;
    server_name localhost;
    
    # 静态文件服务
    location /static/ {
        alias /data/uploads/;
        expires 30d;
    }
    
    # API反向代理
    location /api/ {
        proxy_pass http://backend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
    
    # 根路径重定向
    location / {
        proxy_pass http://backend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

三、使用Docker命令运行

1. 构建镜像

# 构建后端镜像
docker build -t my-app-backend:1.0.0 ./backend/

# 构建Nginx镜像
docker build -t my-app-nginx:1.0.0 ./nginx/

2. 创建网络

1	docker network create app-network

3. 运行MySQL容器

docker run -d \
  --name mysql \
  --network app-network \
  -e MYSQL_ROOT_PASSWORD=rootpassword123 \
  -e MYSQL_DATABASE=myapp \
  -e MYSQL_USER=myappuser \
  -e MYSQL_PASSWORD=myapppass123 \
  -v /my-app/data/mysql:/var/lib/mysql \
  -v /my-app/mysql/init.sql:/docker-entrypoint-initdb.d/init.sql \
  mysql:8.0

参数详解：

-d：后台运行
--name：容器名称
--network：加入的网络
-e：环境变量（数据库配置）
-v：挂载数据卷（数据持久化和初始化脚本）

4. 运行后端应用

docker run -d \
  --name backend \
  --network app-network \
  -p 8080:8080 \
  -e SPRING_DATASOURCE_URL=jdbc:mysql://mysql:3306/myapp \
  -e SPRING_DATASOURCE_USERNAME=myappuser \
  -e SPRING_DATASOURCE_PASSWORD=myapppass123 \
  -v /my-app/data/uploads:/app/uploads \
  my-app-backend:1.0.0

5. 运行Nginx

docker run -d \
  --name nginx \
  --network app-network \
  -p 80:80 \
  -p 443:443 \
  -v /my-app/data/uploads:/data/uploads \
  my-app-nginx:1.0.0

四、使用Docker Compose编排（推荐）

/my-app/docker-compose.yml:

version: '3.8'

services:
  # MySQL服务
  mysql:
    image: mysql:8.0
    container_name: mysql
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword123
      MYSQL_DATABASE: myapp
      MYSQL_USER: myappuser
      MYSQL_PASSWORD: myapppass123
    volumes:
      - ./data/mysql:/var/lib/mysql
      - ./mysql/init.sql:/docker-entrypoint-initdb.d/init.sql
    networks:
      - app-network
    restart: unless-stopped

  # 后端应用服务
  backend:
    build: ./backend  # 使用Dockerfile构建
    container_name: backend
    environment:
      SPRING_DATASOURCE_URL: jdbc:mysql://mysql:3306/myapp
      SPRING_DATASOURCE_USERNAME: myappuser
      SPRING_DATASOURCE_PASSWORD: myapppass123
      JAVA_OPTS: "-Xms512m -Xmx1024m"
    volumes:
      - ./data/uploads:/app/uploads
    networks:
      - app-network
    depends_on:
      - mysql
    restart: unless-stopped

  # Nginx服务
  nginx:
    build: ./nginx  # 使用Dockerfile构建
    container_name: nginx
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./data/uploads:/data/uploads
    networks:
      - app-network
    depends_on:
      - backend
    restart: unless-stopped

# 自定义网络
networks:
  app-network:
    driver: bridge

# 数据卷定义（可选）
volumes:
  mysql-data:
    driver: local
  uploads:
    driver: local

运行命令：

# 启动所有服务（后台模式）
docker-compose up -d

# 查看服务状态
docker-compose ps

# 查看日志
docker-compose logs -f

# 停止服务
docker-compose down

# 重新构建镜像并启动
docker-compose up -d --build

五、重要参数和参考文档

1. Docker run 常用参数参考

参数	说明	示例
`-d`	后台运行	`-d`
`-p`	端口映射	`-p 80:80`
`-v`	数据卷挂载	`-v /host:/container`
`-e`	环境变量	`-e KEY=VALUE`
`--name`	容器名称	`--name my-container`
`--network`	加入网络	`--network my-network`
`--restart`	重启策略	`--restart unless-stopped`
`-m`	内存限制	`-m 512m`
`--cpus`	CPU限制	`--cpus 1.5`

2. 官方文档参考

Dockerfile参考：https://docs.docker.com/engine/reference/builder/
Docker run参考：https://docs.docker.com/engine/reference/run/
Docker Compose参考：https://docs.docker.com/compose/compose-file/

3. 最佳实践建议

使用.dockerignore：避免将不必要的文件复制到镜像中
多阶段构建：减少最终镜像大小
使用特定标签：避免使用latest标签
非root用户：提高安全性
健康检查：添加健康检查机制
资源限制：生产环境必须设置资源限制

这样的架构和配置可以满足大多数Web应用的需求，并且具有良好的可维护性和扩展性。

后期使用

🧭 一、查看 Docker 容器资源占用情况

1️⃣ 查看总体资源消耗

1	sudo docker stats

这条命令类似于 Linux 的 top，会实时显示各容器的：

容器 ID / 名称
CPU 使用率
内存占用量
网络流量
磁盘 I/O

按 Ctrl + C 退出。

如果你只想查看内存占用前几名：

1	sudo docker stats --no-stream \| sort -k4 -h

2️⃣ 查看单个容器资源详情

例如查看 Nextcloud 主容器：

1	sudo docker inspect nextcloud-aio-mastercontainer

可以获取：

容器挂载卷、网络、IP 地址
资源限制（CPU/内存）
启动参数等信息

也可配合 grep：

1	sudo docker inspect nextcloud-aio-mastercontainer \| grep -i memory

3️⃣ 查看 Docker 系统整体资源使用

1	sudo docker system df

显示：

镜像占用空间
容器占用空间
卷（volumes）
构建缓存大小

🧰 二、Docker 容器生命周期管理

🚀 1️⃣ 创建容器

最常见两种方式：

a. 使用 `docker run`

例如运行一个测试容器：

1	sudo docker run -d --name my-nginx -p 8080:80 nginx

b. 使用 `docker compose`

在有 docker-compose.yml 的目录执行：

1	sudo docker compose up -d

⏸️ 2️⃣ 停止容器

1	sudo docker stop <容器名或ID>

例如：

1	sudo docker stop nextcloud-aio-apache

一次性停止所有容器：

1	sudo docker stop $(sudo docker ps -q)

▶️ 3️⃣ 启动容器

1	sudo docker start <容器名>

例如：

1	sudo docker start rocketchat-compose-rocketchat-1

🔄 4️⃣ 重启容器

1	sudo docker restart <容器名>

🧹 5️⃣ 删除容器

先停止再删除：

1 2	sudo docker stop <容器名> sudo docker rm <容器名>

一次性删除所有已停止的容器：

1	sudo docker container prune

（确认后会清理所有停止的容器）

🧱 6️⃣ 删除镜像

查看镜像：

1	sudo docker images

删除镜像：

1	sudo docker rmi <镜像名:tag>

清理未使用镜像：

1	sudo docker image prune -a

🪣 7️⃣ 删除卷（Volumes）

查看卷：

1	sudo docker volume ls

删除单个卷：

1	sudo docker volume rm <卷名>

清理未使用卷：

1	sudo docker volume prune

🧩 三、系统级管理命令

命令	说明
`sudo docker ps -a`	查看所有容器（包括停止的）
`sudo docker logs <容器名>`	查看容器日志
`sudo docker exec -it <容器名> bash`	进入容器交互终端
`sudo docker update --restart=always <容器名>`	设置容器自动重启策略
`sudo docker network ls`	查看网络
`sudo docker system prune -a`	清理未使用的镜像、容器、网络、缓存

📊 四、图形化监控方式（可选）

如果你想要更直观地查看资源使用，可选择以下工具：

Portainer

1
2
3

sudo docker run -d -p 9000:9000 --name portainer \
-v /var/run/docker.sock:/var/run/docker.sock \
portainer/portainer-ce

浏览器访问 http://localhost:9000。

LazyDocker
终端交互式管理工具：
1
2
sudo apt install lazydocker
lazydocker
类似 htop 的 Docker 管理界面。

⚙️ 五、实践建议（针对你的情况）

你当前运行的容器多且繁杂，建议：

定期执行：

1 2	sudo docker system df sudo docker stats --no-stream

来检查资源占用。

给重要容器设置自动重启：

1	sudo docker update --restart=always <容器名>

每月清理无用镜像与卷：
1
sudo docker system prune -a