【Docker】Docker容器技术详解

山沐与山2025-12-20 10:31

Docker容器技术详解

前言

作为程序员，你一定听过这句话："这程序在我电脑上明明是好的，怎么到你那就不行了？"这背后的根本原因是环境不一致。Docker 就是为了解决这个问题而生的。本文将用最通俗的方式，带你理解 Docker 的核心概念和工作原理。

🏠个人主页：你的主页

文章目录

一、从一个比喻开始理解Docker

1.1 大豆的跨国运输问题

假设你是一个农产品贸易商，需要把美国的大豆运到中国。

最原始的方式：直接把大豆散装在船舱里。

问题来了：

  • 大豆可能受潮发霉
  • 和其他货物混在一起
  • 装卸效率低下

改进方式：用麻袋装好再运。

还是有问题：

  • 麻袋大小不一，堆放困难
  • 不同货物需要不同包装
  • 换船时要重新装卸

最终方案 ：使用集装箱。

把大豆装进标准化的集装箱里：

  • 集装箱尺寸统一，方便堆放
  • 密封防潮，保护货物
  • 可以直接从船上吊装到卡车上
  • 不管里面装的是大豆、手机还是药品，外面看起来都一样

1.2 集装箱思想与Docker

船 = 服务器
货物 = 应用程序
集装箱 = Docker 容器

物流领域 IT 领域
货物（大豆、手机、药品） 应用程序（博客、商城、数据库）
船舱 服务器/虚拟机
集装箱 Docker 容器
集装箱标准化 容器镜像标准化
货物+集装箱一起运输 应用+环境一起打包部署

Docker 的核心思想：把应用程序和它依赖的环境打包成一个标准化的"集装箱"（容器），这个"集装箱"可以在任何支持 Docker 的服务器上运行。

1.3 为什么不直接用船（虚拟机）

你可能会问：直接用船运不行吗？为什么要加集装箱？

直接用船（虚拟机）的问题：

假设你要运 100 箱大豆和 50 箱手机：

  • 方案一：租两艘船，一艘运大豆，一艘运手机
  • 问题：两艘船太贵了，而且每艘船都没装满

用集装箱（Docker）的好处：

  • 一艘船可以装很多集装箱
  • 每个集装箱相互隔离，互不影响
  • 大豆不会把手机弄湿，手机不会把大豆压坏
  • 装卸效率高，标准化操作

对应到 IT 领域：

方案 类比 资源消耗
每个应用一台虚拟机 每种货物一艘船 高（每个虚拟机都要完整操作系统）
多个容器共享一台服务器 多个集装箱共享一艘船 低（容器共享宿主机内核）

二、Docker解决了什么问题

2.1 环境不一致问题

场景：你在 Ubuntu 上开发了一个 Python 应用，要部署到 CentOS 服务器上。

没有 Docker：

bash 复制代码 
# Ubuntu 上安装依赖
apt-get install python3 python3-pip libmysqlclient-dev

# CentOS 上安装依赖（命令不一样！）
yum install python3 python3-pip mysql-devel

# 可能还有版本差异、路径差异、配置差异...

有了 Docker：

bash 复制代码 
# 不管什么系统，命令都一样
docker pull my-python-app
docker run my-python-app

2.2 依赖冲突问题

场景：服务器上要同时运行两个应用，一个需要 Python 2.7，一个需要 Python 3.9。

没有 Docker：

复制代码 
服务器
├── Python 2.7  ← 应用A需要
└── Python 3.9  ← 应用B需要
    ↑ 冲突！系统默认只能用一个版本

有了 Docker：

复制代码 
服务器
├── 容器A（内置 Python 2.7）← 应用A
└── 容器B（内置 Python 3.9）← 应用B
    ↑ 互不影响！

2.3 部署效率问题

场景：新来了 10 台服务器，要部署同一个应用。

没有 Docker：

复制代码 
登录服务器1 → 安装依赖 → 配置环境 → 部署应用
登录服务器2 → 安装依赖 → 配置环境 → 部署应用
...
登录服务器10 → 安装依赖 → 配置环境 → 部署应用

耗时：可能一整天

有了 Docker：

bash 复制代码 
# 在所有服务器上执行同一条命令
docker pull my-app && docker run my-app

# 耗时：几分钟

2.4 资源利用率问题

场景：有 3 个小应用，每个只需要 1GB 内存。

用虚拟机：

复制代码 
物理服务器（16GB 内存）
├── 虚拟机1（4GB）→ 应用A（实际用 1GB）
├── 虚拟机2（4GB）→ 应用B（实际用 1GB）
└── 虚拟机3（4GB）→ 应用C（实际用 1GB）

浪费：12GB - 3GB = 9GB

用 Docker：

复制代码 
物理服务器（16GB 内存）
├── 容器A（限制 1.5GB）→ 应用A
├── 容器B（限制 1.5GB）→ 应用B
└── 容器C（限制 1.5GB）→ 应用C

剩余：16GB - 4.5GB = 11.5GB 可用于其他容器

三、Docker核心概念

3.1 镜像（Image）

镜像是什么：镜像就是一个"压缩包"，里面包含了应用程序和它运行所需的一切环境（操作系统文件、依赖库、配置文件等）。

打个比方：镜像就像是一个"模具"，你可以用这个模具生产出无数个一模一样的"产品"（容器）。

镜像的特点：

  • 只读：镜像一旦创建就不能修改
  • 分层：镜像由多层组成，可以复用
  • 可分享：可以上传到镜像仓库供他人使用

3.2 容器（Container）

容器是什么：容器是镜像的"运行实例"，是一个独立运行的环境。

打个比方：

  • 镜像 = 类（Class）
  • 容器 = 对象（Object）

你可以从一个镜像创建多个容器，就像从一个类可以 new 多个对象。

复制代码 
镜像：nginx:latest
    ↓ docker run
容器1：nginx-web1（运行中）
容器2：nginx-web2（运行中）
容器3：nginx-web3（已停止）

3.3 Dockerfile

Dockerfile 是什么：Dockerfile 是一个"菜谱"，告诉 Docker 如何一步步构建镜像。

举个例子：

dockerfile 复制代码 
# 基础镜像：从 Python 3.9 开始
FROM python:3.9-slim

# 设置工作目录
WORKDIR /app

# 复制依赖文件
COPY requirements.txt .

# 安装依赖
RUN pip install -r requirements.txt

# 复制应用代码
COPY . .

# 暴露端口
EXPOSE 8000

# 启动命令
CMD ["python", "app.py"]

Dockerfile 就像做菜的步骤：

复制代码 
1. 准备一口锅（FROM：基础镜像）
2. 放入食材（COPY：复制文件）
3. 加调料翻炒（RUN：执行命令）
4. 装盘上桌（CMD：启动应用）

3.4 镜像仓库（Registry）

镜像仓库是什么：存放镜像的地方，类似于代码的 GitHub。

代码管理 镜像管理
GitHub Docker Hub
git push docker push
git pull docker pull
代码仓库 镜像仓库

常见的镜像仓库：

  • Docker Hub：官方公共仓库
  • 阿里云容器镜像服务：国内访问快
  • Harbor：企业私有仓库
  • 公司内部仓库：存放公司私有镜像

3.5 概念关系图

复制代码 
┌─────────────────────────────────────────────────────────────┐
│                      Docker 核心概念                         │
└─────────────────────────────────────────────────────────────┘

Dockerfile（菜谱）
    │
    │ docker build
    ▼
Image（镜像/模具）
    │
    ├── docker push ──────► Registry（镜像仓库）
    │                            │
    │                            │ docker pull
    │                            ▼
    │                       Image（镜像）
    │                            │
    │ docker run                 │ docker run
    ▼                            ▼
Container（容器）           Container（容器）

四、Docker架构原理

4.1 整体架构

Docker 采用经典的 Client-Server 架构：

复制代码 
┌─────────────────────────────────────────────────────────────┐
│                      Docker 架构                             │
└─────────────────────────────────────────────────────────────┘

┌──────────────┐         ┌──────────────────────────────────┐
│              │         │         Docker Daemon            │
│   Docker     │  REST   │  ┌────────────────────────────┐  │
│   Client     │  API    │  │      Docker Server         │  │
│              │ ──────► │  │   (HTTP API 服务器)         │  │
│  docker run  │         │  └─────────────┬──────────────┘  │
│  docker pull │         │                │                 │
│  docker build│         │  ┌─────────────▼──────────────┐  │
│              │         │  │         Engine             │  │
└──────────────┘         │  │   (创建 Job 执行任务)       │  │
                         │  └─────────────┬──────────────┘  │
                         │                │                 │
                         │  ┌─────────────▼──────────────┐  │
                         │  │      containerd            │  │
                         │  │   (容器运行时管理)          │  │
                         │  └─────────────┬──────────────┘  │
                         │                │                 │
                         │  ┌─────────────▼──────────────┐  │
                         │  │         runc               │  │
                         │  │   (实际创建容器)            │  │
                         │  └────────────────────────────┘  │
                         └──────────────────────────────────┘

4.2 各组件职责

组件 职责
Docker Client 命令行工具，解析用户命令，调用 API
Docker Daemon 守护进程，接收请求，管理容器和镜像
Docker Server HTTP 服务器，提供 RESTful API
Engine 核心引擎，创建 Job 执行具体任务
containerd 容器运行时，管理容器生命周期
runc 底层工具，实际创建和运行容器

4.3 不同命令的执行流程

docker build（构建镜像）：

复制代码 
docker build -t my-app .
        │
        ▼
Docker Client 解析命令
        │
        ▼
调用 Docker Daemon API
        │
        ▼
Engine 创建 Build Job
        │
        ▼
按 Dockerfile 一层层构建镜像
        │
        ▼
生成镜像文件，存储到本地

docker pull（拉取镜像）：

复制代码 
docker pull nginx:latest
        │
        ▼
Docker Client 解析命令
        │
        ▼
调用 Docker Daemon API
        │
        ▼
Engine 创建 Pull Job
        │
        ▼
连接 Docker Registry（镜像仓库）
        │
        ▼
下载镜像层，存储到本地

docker run（运行容器）：

复制代码 
docker run -d nginx
        │
        ▼
Docker Client 解析命令
        │
        ▼
调用 Docker Daemon API
        │
        ▼
Engine 创建 Run Job
        │
        ▼
调用 containerd
        │
        ▼
containerd 调用 runc
        │
        ▼
runc 创建容器进程
        │
        ▼
容器运行！

4.4 容器的底层原理

容器本质上是一个特殊的进程，它利用 Linux 内核的两个关键技术：

Namespace（命名空间）：实现隔离

复制代码 
┌─────────────────────────────────────────────────────────────┐
│                    宿主机操作系统                            │
├─────────────────────────────────────────────────────────────┤
│  ┌─────────────────┐  ┌─────────────────┐                  │
│  │    容器 A       │  │    容器 B       │                  │
│  │  ┌───────────┐  │  │  ┌───────────┐  │                  │
│  │  │ PID: 1    │  │  │  │ PID: 1    │  │  ← 各自认为自己  │
│  │  │ 网络: eth0│  │  │  │ 网络: eth0│  │    是独立系统    │
│  │  │ 文件系统  │  │  │  │ 文件系统  │  │                  │
│  │  └───────────┘  │  │  └───────────┘  │                  │
│  └─────────────────┘  └─────────────────┘                  │
│                                                             │
│  Namespace 让每个容器看起来像独立的操作系统                  │
└─────────────────────────────────────────────────────────────┘

Namespace 类型：

Namespace 隔离内容
PID 进程 ID
Network 网络设备、端口
Mount 文件系统挂载点
UTS 主机名
IPC 进程间通信
User 用户和用户组

Cgroups（控制组）：实现资源限制

bash 复制代码 
# 限制容器最多使用 512MB 内存和 1 个 CPU
docker run -m 512m --cpus 1 nginx

Cgroups 可以限制：

  • CPU 使用率
  • 内存使用量
  • 磁盘 I/O
  • 网络带宽

五、Docker与虚拟机的区别

5.1 架构对比

虚拟机架构：

复制代码 
┌─────────────────────────────────────────────────────────────┐
│                      物理服务器                              │
├─────────────────────────────────────────────────────────────┤
│                    宿主机操作系统                            │
├─────────────────────────────────────────────────────────────┤
│                   Hypervisor（虚拟化层）                     │
├───────────────────┬───────────────────┬─────────────────────┤
│      虚拟机 A     │      虚拟机 B     │      虚拟机 C       │
│  ┌─────────────┐  │  ┌─────────────┐  │  ┌─────────────┐    │
│  │   应用 A    │  │  │   应用 B    │  │  │   应用 C    │    │
│  ├─────────────┤  │  ├─────────────┤  │  ├─────────────┤    │
│  │   依赖库    │  │  │   依赖库    │  │  │   依赖库    │    │
│  ├─────────────┤  │  ├─────────────┤  │  ├─────────────┤    │
│  │ 完整操作系统│  │  │ 完整操作系统│  │  │ 完整操作系统│    │
│  │  (几个GB)   │  │  │  (几个GB)   │  │  │  (几个GB)   │    │
│  └─────────────┘  │  └─────────────┘  │  └─────────────┘    │
└───────────────────┴───────────────────┴─────────────────────┘

Docker 架构：

复制代码 
┌─────────────────────────────────────────────────────────────┐
│                      物理服务器                              │
├─────────────────────────────────────────────────────────────┤
│                    宿主机操作系统                            │
├─────────────────────────────────────────────────────────────┤
│                    Docker Engine                            │
├───────────────────┬───────────────────┬─────────────────────┤
│     容器 A        │     容器 B        │     容器 C          │
│  ┌─────────────┐  │  ┌─────────────┐  │  ┌─────────────┐    │
│  │   应用 A    │  │  │   应用 B    │  │  │   应用 C    │    │
│  ├─────────────┤  │  ├─────────────┤  │  ├─────────────┤    │
│  │   依赖库    │  │  │   依赖库    │  │  │   依赖库    │    │
│  │  (几十MB)   │  │  │  (几十MB)   │  │  │  (几十MB)   │    │
│  └─────────────┘  │  └─────────────┘  │  └─────────────┘    │
│                   │                   │                     │
│        共享宿主机操作系统内核                                │
└───────────────────┴───────────────────┴─────────────────────┘

5.2 详细对比

特性 虚拟机 Docker 容器
启动时间 分钟级 秒级
磁盘占用 GB 级 MB 级
性能 有损耗（5-20%） 接近原生
隔离性 强（完全隔离） 较强（共享内核）
操作系统 每个虚拟机一个完整 OS 共享宿主机内核
单机容量 通常几十个 可达上千个
迁移性 较差 很好

5.3 什么时候用虚拟机，什么时候用 Docker

用虚拟机的场景：

  • 需要运行不同操作系统（如在 Linux 上运行 Windows）
  • 需要强隔离（如多租户环境）
  • 遗留系统迁移

用 Docker 的场景：

  • 微服务架构
  • CI/CD 流水线
  • 开发测试环境
  • 快速部署和扩缩容

实际中常见的组合：

复制代码 
物理服务器
    └── 虚拟机（ECS）
            └── Docker 容器
                    └── 应用服务

六、Docker实战入门

6.1 安装 Docker

Ubuntu/Debian：

bash 复制代码 
# 更新包索引
sudo apt-get update

# 安装依赖
sudo apt-get install ca-certificates curl gnupg

# 添加 Docker 官方 GPG 密钥
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

# 设置仓库
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 安装 Docker
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io

# 验证安装
docker --version

CentOS：

bash 复制代码 
# 安装依赖
sudo yum install -y yum-utils

# 设置仓库
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

# 安装 Docker
sudo yum install docker-ce docker-ce-cli containerd.io

# 启动 Docker
sudo systemctl start docker
sudo systemctl enable docker

# 验证安装
docker --version

6.2 常用命令

镜像相关：

bash 复制代码 
# 搜索镜像
docker search nginx

# 拉取镜像
docker pull nginx:latest

# 查看本地镜像
docker images

# 删除镜像
docker rmi nginx:latest

# 构建镜像
docker build -t my-app:v1 .

容器相关：

bash 复制代码 
# 运行容器
docker run -d --name my-nginx -p 80:80 nginx

# 查看运行中的容器
docker ps

# 查看所有容器（包括已停止的）
docker ps -a

# 停止容器
docker stop my-nginx

# 启动已停止的容器
docker start my-nginx

# 删除容器
docker rm my-nginx

# 进入容器内部
docker exec -it my-nginx /bin/bash

# 查看容器日志
docker logs my-nginx

# 查看容器资源使用
docker stats

6.3 实战：部署一个 Java 应用

步骤一：编写 Dockerfile

dockerfile 复制代码 
# 基础镜像
FROM openjdk:17-jdk-slim

# 维护者信息
LABEL maintainer="your-email@example.com"

# 设置工作目录
WORKDIR /app

# 复制 JAR 包
COPY target/my-app.jar app.jar

# 暴露端口
EXPOSE 8080

# JVM 参数
ENV JAVA_OPTS="-Xms256m -Xmx512m"

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

步骤二：构建镜像

bash 复制代码 
# 先用 Maven 打包
mvn clean package -DskipTests

# 构建 Docker 镜像
docker build -t my-java-app:v1 .

步骤三：运行容器

bash 复制代码 
# 运行容器
docker run -d \
  --name my-java-app \
  -p 8080:8080 \
  -e SPRING_PROFILES_ACTIVE=prod \
  -v /data/logs:/app/logs \
  my-java-app:v1

# 查看日志
docker logs -f my-java-app

6.4 数据持久化

容器删除后，里面的数据也会丢失。如果需要持久化数据，有两种方式：

方式一：Volume（数据卷）

bash 复制代码 
# 创建数据卷
docker volume create my-data

# 使用数据卷
docker run -d \
  --name mysql \
  -v my-data:/var/lib/mysql \
  -e MYSQL_ROOT_PASSWORD=123456 \
  mysql:8.0

方式二：Bind Mount（绑定挂载）

bash 复制代码 
# 将宿主机目录挂载到容器
docker run -d \
  --name nginx \
  -v /home/user/html:/usr/share/nginx/html \
  nginx

七、Docker Compose多容器编排

7.1 为什么需要 Docker Compose

实际项目中，一个应用往往由多个服务组成：

复制代码 
博客系统
├── 前端服务（Nginx）
├── 后端服务（Java/Python）
├── 数据库（MySQL）
└── 缓存（Redis）

如果手动一个个启动：

bash 复制代码 
docker run -d mysql ...
docker run -d redis ...
docker run -d backend ...
docker run -d nginx ...

问题：

  • 命令太多，容易出错
  • 启动顺序有要求（先数据库，后应用）
  • 服务之间的网络配置复杂

7.2 Docker Compose 是什么

Docker Compose 是一个多容器编排工具，通过一个 YAML 文件定义所有服务，一条命令启动整个应用。

7.3 docker-compose.yml 示例

yaml 复制代码 
version: '3.8'

services:
  # MySQL 数据库
  mysql:
    image: mysql:8.0
    container_name: blog-mysql
    environment:
      MYSQL_ROOT_PASSWORD: root123
      MYSQL_DATABASE: blog
    volumes:
      - mysql-data:/var/lib/mysql
    ports:
      - "3306:3306"
    networks:
      - blog-network
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 10s
      timeout: 5s
      retries: 3

  # Redis 缓存
  redis:
    image: redis:7-alpine
    container_name: blog-redis
    ports:
      - "6379:6379"
    networks:
      - blog-network

  # 后端服务
  backend:
    build: ./backend
    container_name: blog-backend
    ports:
      - "8080:8080"
    environment:
      SPRING_DATASOURCE_URL: jdbc:mysql://mysql:3306/blog
      SPRING_REDIS_HOST: redis
    depends_on:
      mysql:
        condition: service_healthy
      redis:
        condition: service_started
    networks:
      - blog-network

  # Nginx 前端
  nginx:
    image: nginx:alpine
    container_name: blog-nginx
    ports:
      - "80:80"
    volumes:
      - ./frontend/dist:/usr/share/nginx/html
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - backend
    networks:
      - blog-network

volumes:
  mysql-data:

networks:
  blog-network:
    driver: bridge

7.4 Docker Compose 常用命令

bash 复制代码 
# 启动所有服务（后台运行）
docker-compose up -d

# 查看服务状态
docker-compose ps

# 查看日志
docker-compose logs -f

# 停止所有服务
docker-compose down

# 停止并删除数据卷
docker-compose down -v

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

# 只启动某个服务
docker-compose up -d mysql

# 扩缩容（启动 3 个 backend 实例）
docker-compose up -d --scale backend=3

7.5 服务依赖与启动顺序

depends_on 可以控制启动顺序：

yaml 复制代码 
services:
  backend:
    depends_on:
      mysql:
        condition: service_healthy  # 等 MySQL 健康检查通过
      redis:
        condition: service_started  # 等 Redis 启动

八、Docker Swarm与K8s的关系

8.1 单机到集群的演进

复制代码 
┌─────────────────────────────────────────────────────────────┐
│                    容器编排演进路线                          │
└─────────────────────────────────────────────────────────────┘

Docker（单容器）
    │
    │ 需要管理多个容器
    ▼
Docker Compose（单机多容器）
    │
    │ 需要跨多台服务器部署
    ▼
Docker Swarm / Kubernetes（集群多容器）

8.2 Docker Swarm 是什么

Docker Swarm 是 Docker 官方的集群管理工具，可以将多台服务器组成一个集群，统一管理和调度容器。

核心概念：

概念 说明
Node 集群中的一台服务器
Manager 管理节点，负责调度
Worker 工作节点，运行容器
Service 服务定义（镜像、副本数等）
Task 具体的容器实例

8.3 Docker Swarm vs Kubernetes

Docker Swarm 和 Kubernetes 是竞争关系，都是容器编排工具。

特性 Docker Swarm Kubernetes
学习曲线 简单 陡峭
功能丰富度 基础 非常丰富
社区生态 较小 非常庞大
适用规模 中小规模 大规模
与 Docker 集成 原生集成 需要额外配置

现状：Kubernetes 已经成为事实上的标准，大多数公司选择 K8s。

8.4 Docker 与 K8s 的关系

很多人搞不清 Docker 和 K8s 的关系，其实很简单：

复制代码 
┌─────────────────────────────────────────────────────────────┐
│                  Docker 与 K8s 的关系                        │
└─────────────────────────────────────────────────────────────┘

Docker 容器 ≈ K8s Pod 中的 Container
Docker Compose ≈ K8s Pod（多个容器组成一个单元）
Docker Swarm ≈ Kubernetes（集群编排）

┌─────────────────────────────────────────────────────────────┐
│                    Kubernetes 集群                          │
├─────────────────────────────────────────────────────────────┤
│  ┌─────────────────────────────────────────────────────┐   │
│  │                      Pod                            │   │
│  │  ┌─────────────┐  ┌─────────────┐                  │   │
│  │  │ Container A │  │ Container B │  ← 这就是 Docker │   │
│  │  │ (应用服务)  │  │ (日志收集)  │    容器          │   │
│  │  └─────────────┘  └─────────────┘                  │   │
│  └─────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘

一句话总结：Docker 负责打包和运行单个容器，K8s 负责管理和调度大量容器。

九、总结

9.1 核心概念速查

概念 说明
镜像（Image） 应用+环境的打包文件，只读
容器（Container） 镜像的运行实例，可读写
Dockerfile 构建镜像的"菜谱"
Registry 镜像仓库，存放和分发镜像
Docker Compose 单机多容器编排工具
Docker Swarm 多机集群编排工具

9.2 Docker 解决的问题

问题 Docker 的解决方案
环境不一致 应用+环境一起打包
依赖冲突 容器隔离，互不影响
部署效率低 一条命令部署
资源利用率低 容器轻量，共享内核

9.3 常用命令速查

bash 复制代码 
# 镜像
docker pull <image>      # 拉取镜像
docker build -t <tag> .  # 构建镜像
docker images            # 查看镜像
docker rmi <image>       # 删除镜像

# 容器
docker run -d <image>    # 运行容器
docker ps                # 查看容器
docker stop <container>  # 停止容器
docker rm <container>    # 删除容器
docker logs <container>  # 查看日志
docker exec -it <container> /bin/bash  # 进入容器

# Compose
docker-compose up -d     # 启动服务
docker-compose down      # 停止服务
docker-compose logs -f   # 查看日志

9.4 下一步学习

掌握了 Docker 之后，建议继续学习：

  1. Kubernetes：容器编排的事实标准
  2. CI/CD：Jenkins、GitLab CI 与 Docker 集成
  3. 容器安全：镜像扫描、运行时安全
  4. 服务网格：Istio、Linkerd

热门专栏推荐

等等等还有许多优秀的合集在主页等着大家的光顾，感谢大家的支持

文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起来评论区一起讨论😊

希望能和诸佬们一起努力，今后我们一起观看感谢您的阅读🙏

如果帮助到您不妨3连支持一下，创造不易您们的支持是我的动力🌟

相关推荐
梦想的旅途22 小时前
探索界面自动化技术在企业微信外部群管理中的应用场景与实现思路
运维·自动化·企业微信
wanhengidc2 小时前
巨 椰 云手机 性能稳定
运维·服务器·arm开发·智能手机·云计算
weixin_307779132 小时前
赋能插件，驱动图表：Jenkins ECharts API插件详解
运维·开发语言·自动化·jenkins·echarts
互联网哪些事情2 小时前
Docker 容器化部署宝塔 Linux 面板
linux·docker·容器·宝塔云服务器
翼龙云_cloud2 小时前
阿里云渠道商：阿里云GPU怎么搭建部署个人作品集博客？
运维·服务器·阿里云·云计算
坚定信念，勇往无前2 小时前
docker安装mongodb
mongodb·docker·容器
全栈工程师修炼指南2 小时前
Nginx | HTTPS 加密传输：客户端与Nginx服务端 SSL 双向认证实践
运维·网络·nginx·https·ssl
Destiny_where2 小时前
k8s常用指令集合
linux·docker·kubernetes
ToB营销学堂2 小时前
自动化营销是什么？B2B企业高效增长的核心引擎
大数据·运维·自动化·b2b营销获客·b2b系统管理
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03Linux下V2Ray安装配置指南04安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）05RedissonClient的配置解析06在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）07BongoCat - 跨平台键盘猫动画工具08Open-AutoGLM Windows 安装部署教程09Labelme从安装到标注：零基础完整指南10jdk21下载、安装（Windows、Linux、macOS）