Docker核心概念与架构

对于多容器应用，手动管理每个容器较为繁琐。是一个用于定义和运行多容器Docker应用的工具，通过一个文件描述服务、网络和卷，然后一条命令即可启动所有容器。services:web:ports:db:volumes:volumes:db-data:通过即可启动整个应用栈。Compose在生产环境中常与Docker Swarm或Kubernetes结合使用。Docker通过轻量级的容器化技术，重新定义

闲人编程

3213人浏览 · 2026-03-01 07:45:00

闲人编程 · 2026-03-01 07:45:00 发布

『宝藏代码胶囊开张啦！』—— 我的 CodeCapsule 来咯！✨写代码不再头疼！我的新站点 CodeCapsule 主打一个 “白菜价”+“量身定制”！无论是卡脖子的毕设/课设/文献复现，需要灵光一现的算法改进，还是想给项目加个“外挂”，这里都有便宜又好用的代码方案等你发现！低成本，高适配，助你轻松通关！速来围观 👉 CodeCapsule官网

Docker核心概念与架构：从入门到理解容器化基石

引言

在软件开发领域，环境一致性和部署效率一直是困扰开发者和运维人员的核心难题。传统的应用部署方式需要手动配置依赖、管理运行时环境，常常导致“在我机器上能跑”的尴尬局面。Docker的出现彻底改变了这一现状。作为一种轻量级的容器化平台，Docker通过将应用及其依赖打包成标准化的镜像，实现了“一次构建，随处运行”的目标，成为现代云原生应用的基石。

自2013年开源以来，Docker迅速成为容器技术的代名词，推动了DevOps、微服务架构和持续集成/持续部署（CI/CD）的普及。据统计，超过65%的企业在生产环境中使用容器，而其中绝大多数基于Docker技术。

本文将深入探讨Docker的核心概念与架构，帮助你理解其内部工作原理，并通过Python代码实战演示如何编程管理Docker容器。无论你是初学者还是有一定经验的开发者，本文都将为你构建扎实的Docker知识体系。

一、Docker核心概念

Docker围绕几个关键概念构建：镜像（Image）、容器（Container）、仓库（Registry）、Dockerfile、数据卷（Volume） 和 网络（Network）。理解这些概念是掌握Docker的基础。

1.1 镜像（Image）

镜像是一个只读的模板，包含运行应用程序所需的全部文件——代码、运行时、系统工具、库和设置。镜像可以理解为容器的“源代码”，它定义了容器启动时的文件系统内容和默认执行命令。

镜像由多个只读层（Layer）堆叠而成，每一层代表一个文件系统的变更。这种分层结构是Docker高效存储和传输的关键：

基础层：通常是一个基础操作系统（如Ubuntu、Alpine）的最小文件系统。
中间层：每次执行RUN、COPY等指令都会创建一个新层。
容器层：当容器运行时，会在镜像层之上添加一个可写层，所有对文件的修改都记录在这一层。

这种分层设计使得多个容器可以共享相同的底层镜像，节省磁盘空间，并加快镜像拉取和启动速度。

1.2 容器（Container）

容器是镜像的运行实例。它是一个轻量级的、隔离的运行时环境，拥有自己的文件系统、网络空间和进程树。容器与宿主机共享操作系统内核，因此比虚拟机更轻量、启动更快。

容器的生命周期包括：

创建：从镜像创建容器，分配文件系统、网络等资源。
启动：运行容器内的主进程。
停止：优雅或强制终止容器进程。
删除：清理容器的文件系统和元数据。

容器默认与宿主机隔离，但可以通过挂载数据卷、暴露端口等方式与外界交互。

1.3 仓库（Registry）

仓库用于存储和分发Docker镜像。最著名的公共仓库是 Docker Hub，包含数以万计的官方和社区镜像。企业也可以搭建私有仓库（如Harbor、Nexus）来存储内部镜像。

镜像的命名通常遵循格式：[仓库地址/]用户名/镜像名:标签。例如：

nginx:latest：从Docker Hub拉取Nginx最新镜像。
myregistry.com:5000/myapp:v1.0：从私有仓库拉取。

1.4 Dockerfile

Dockerfile是一个文本文件，包含构建镜像所需的指令。每一条指令对应镜像的一层。以下是一个简单的Node.js应用Dockerfile：

# 指定基础镜像
FROM node:14-alpine

# 设置工作目录
WORKDIR /app

# 复制依赖文件
COPY package*.json ./

# 安装依赖
RUN npm install

# 复制应用源码
COPY . .

# 暴露端口
EXPOSE 3000

# 启动命令
CMD ["node", "app.js"]

通过docker build命令，Docker会逐条执行指令，生成最终的镜像。

1.5 数据卷（Volume）

由于容器层在容器删除时会丢失，Docker提供了数据卷来持久化数据。数据卷是宿主机上的目录，被挂载到容器内，独立于容器的生命周期。

docker run -v /host/data:/container/data myimage

数据卷可用于数据库存储、日志输出等需要持久化的场景。

1.6 网络（Network）

Docker为容器提供多种网络模式，实现容器间通信和对外访问：

bridge（默认）：容器通过虚拟网桥连接到宿主机，使用NAT访问外网。
host：容器直接使用宿主机的网络栈，性能最佳，但隔离性较差。
none：容器无网络。
overlay：用于跨主机的容器集群（如Docker Swarm）。

二、Docker架构

Docker采用客户端-服务器（C/S）架构，包括三个主要组件：Docker客户端、Docker守护进程和容器运行时。

2.1 整体架构图

2.2 Docker客户端

Docker客户端是用户与Docker交互的主要方式，可以是命令行工具docker，也可以是使用Docker API的图形界面或程序。客户端将用户命令（如docker run）转换为REST API请求，发送给守护进程。

2.3 Docker守护进程（dockerd）

Docker守护进程是常驻后台的服务，负责管理容器的整个生命周期，包括：

接收客户端API请求
管理镜像（构建、拉取、存储）
管理容器（创建、启动、停止、删除）
管理网络和数据卷
与容器运行时（containerd）通信

守护进程本身不直接创建容器，而是通过调用containerd来完成。

2.4 containerd

containerd是一个行业标准的容器运行时，最初由Docker公司开发并捐献给CNCF。它负责管理容器的完整生命周期，包括镜像传输、存储、容器执行和监督等。containerd通过gRPC API与dockerd通信，并调用更底层的runc来实际创建容器。

containerd与dockerd的分离体现了Docker架构的模块化设计，也使得其他容器平台（如Kubernetes）可以使用containerd作为运行时。

2.5 runc

runc是OCI（Open Container Initiative）标准的参考实现，是一个轻量级的命令行工具，用于根据OCI规范生成和运行容器。它直接与Linux内核交互，通过namespace和cgroups创建隔离环境。

runc的工作流程：

准备容器的根文件系统和配置文件。
创建新的命名空间（PID、NET、IPC、UTS、MOUNT等）。
应用cgroups资源限制。
执行容器内的初始进程。

2.6 镜像存储与分发

镜像构建完成后，存储在本地或推送到仓库。镜像由多个层组成，Docker使用存储驱动（如overlay2、aufs）将这些层合并为统一的文件系统视图。常见的存储驱动有：

overlay2：当前推荐，性能好，支持所有Linux发行版。
aufs：较老，部分系统支持。
devicemapper：基于快照，性能稍差。

三、使用Python操作Docker

Docker提供了强大的HTTP API，官方Python库docker-py封装了这些API，使得我们可以用Python代码管理容器。这在自动化部署、测试环境搭建等场景中非常有用。

3.1 安装docker-py

pip install docker

3.2 连接Docker守护进程

默认情况下，客户端会尝试连接本地Unix socket /var/run/docker.sock。如果Docker守护进程监听在其他地址，可以通过环境变量或参数指定。

import docker

# 连接本地Docker
client = docker.from_env()

# 或者指定URL
# client = docker.DockerClient(base_url='tcp://192.168.1.100:2375')

3.3 常用操作示例

以下代码演示了如何列出本地镜像、运行容器、查看日志、停止和删除容器。

"""
Docker Python SDK 使用示例
展示常用容器管理操作
"""

import docker
import time
import logging

# 配置日志
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)


def list_images(client):
    """列出所有本地镜像"""
    images = client.images.list()
    logger.info("本地镜像列表:")
    for img in images:
        tags = img.tags if img.tags else ["<none>"]
        logger.info(f"  {tags[0]} (ID: {img.short_id})")
    return images


def run_nginx_container(client):
    """运行一个nginx容器"""
    logger.info("尝试运行nginx容器...")
    try:
        container = client.containers.run(
            "nginx:latest",          # 镜像
            name="my-nginx",          # 容器名
            ports={'80/tcp': 8080},   # 端口映射
            detach=True,              # 后台运行
            remove=False               # 停止后是否自动删除
        )
        logger.info(f"容器启动成功，ID: {container.short_id}")
        return container
    except docker.errors.ImageNotFound:
        logger.error("本地未找到nginx镜像，正在拉取...")
        client.images.pull("nginx:latest")
        return run_nginx_container(client)
    except Exception as e:
        logger.error(f"启动容器失败: {e}")
        return None


def get_container_logs(container, lines=10):
    """获取容器日志"""
    logs = container.logs(tail=lines).decode('utf-8')
    logger.info(f"容器 {container.short_id} 最新日志:\n{logs}")
    return logs


def stop_and_remove_container(container):
    """停止并删除容器"""
    logger.info(f"停止容器 {container.short_id}...")
    container.stop(timeout=5)
    logger.info(f"删除容器 {container.short_id}...")
    container.remove()
    logger.info("容器已删除")


def list_containers(client, all=False):
    """列出容器"""
    containers = client.containers.list(all=all)
    logger.info("容器列表:")
    for c in containers:
        status = c.status
        name = c.name
        logger.info(f"  {name} ({c.short_id}) - {status}")
    return containers


def main():
    """主函数"""
    # 连接Docker
    try:
        client = docker.from_env()
        client.ping()  # 测试连接
        logger.info("成功连接到Docker守护进程")
    except Exception as e:
        logger.error(f"无法连接到Docker: {e}")
        return

    # 1. 列出本地镜像
    list_images(client)

    # 2. 列出当前所有容器（包括停止的）
    list_containers(client, all=True)

    # 3. 运行nginx容器
    container = run_nginx_container(client)
    if not container:
        return

    # 4. 等待几秒让nginx启动
    time.sleep(2)

    # 5. 查看容器状态
    container.reload()  # 刷新状态
    logger.info(f"容器状态: {container.status}")

    # 6. 获取日志
    get_container_logs(container, 5)

    # 7. 列出运行中容器
    list_containers(client, all=False)

    # 8. 停止并删除容器
    stop_and_remove_container(container)

    # 9. 再次列出确认
    list_containers(client, all=True)

    logger.info("演示完成")


if __name__ == "__main__":
    main()

3.4 代码说明

连接：docker.from_env()读取环境变量和默认socket连接本地Docker。
镜像列表：client.images.list()返回所有本地镜像对象。
运行容器：client.containers.run()接受镜像名、端口映射等参数，返回容器对象。使用detach=True在后台运行。
端口映射：ports={'80/tcp': 8080}将容器的80端口映射到宿主机的8080端口。
日志获取：container.logs()返回容器日志，可指定tail限制行数。
停止删除：container.stop()发送SIGTERM信号，超时后强制终止；container.remove()删除容器。
异常处理：捕获镜像未找到异常并自动拉取。

3.5 运行前提

本地已安装Docker引擎并启动。
当前用户有权限访问Docker socket（通常将用户加入docker组，或使用root）。
网络可访问Docker Hub（拉取nginx镜像）。

四、Docker Compose简介

对于多容器应用，手动管理每个容器较为繁琐。Docker Compose是一个用于定义和运行多容器Docker应用的工具，通过一个docker-compose.yml文件描述服务、网络和卷，然后一条命令即可启动所有容器。

例如，一个Web应用+MySQL的Compose文件：

version: '3.8'
services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"
  db:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: rootpass
    volumes:
      - db-data:/var/lib/mysql

volumes:
  db-data: