Docker核心概念与架构

通过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 整体架构图

Docker 架构主要包括：

• Docker 客户端：用户交互接口。
• Docker 守护进程（dockerd）：后台管理服务。
• containerd：容器运行时管理。
• runc：容器执行引擎。

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 的工作流程：

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

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:

通过docker-compose up -d即可启动整个应用栈。Compose 在生产环境中常与 Docker Swarm 或 Kubernetes 结合使用。

五、总结

Docker 通过轻量级的容器化技术，重新定义了软件交付和部署的方式。本文深入探讨了 Docker 的核心概念——镜像、容器、仓库、数据卷和网络，解析了其分层存储和 C/S 架构，并通过 Python 代码展示了如何编程管理容器。

核心要点回顾：

• 镜像是只读模板，由多层构成，支持分层复用。
• 容器是镜像的运行实例，拥有独立的环境。
• Docker 架构包括客户端、守护进程、containerd 和 runc，模块化设计保证了灵活性和标准化。
• docker-py提供了强大的 API，方便将 Docker 集成到自动化流程中。
• Docker Compose简化了多容器应用的编排。

随着云原生生态的发展，Docker 已成为开发者工具箱中不可或缺的一部分。无论是本地开发测试，还是生产环境的大规模部署，理解 Docker 的核心原理都将帮助你更高效地构建和运行应用。