小白Docker入门 on 小马哥博客

01-为什么学Docker？告别"在我电脑上能运行"的魔咒

Sat, 21 Feb 2026 00:00:00 +0000

别再被"环境配置"折磨了

说实话，你是不是也有过这些瞬间：

开发环境运行好好的，部署到服务器就崩了
换台电脑重新配置环境要花一整天
团队开发时，每个人环境都不一样，bug复现都困难
服务器上同时运行多个项目，依赖包冲突到爆炸

别再假装这些问题是"正常"的了，用Docker吧！

为什么是Docker？不是虚拟机？

先说说虚拟机（Virtual Machine, VM）：

模拟一整台电脑，有自己的操作系统
启动慢，占用资源多（几个G的内存）
性能损耗大，毕竟是"虚拟"出来的

而Docker容器：

共享宿主机的操作系统内核，不需要完整的系统
启动快（秒级启动），占用资源少（几MB）
性能接近原生应用

打个比方：

虚拟机就像租一整栋房子，虽然自由但太浪费
Docker就像住精装公寓，该有的都有还省空间

Docker能帮你解决什么问题？

痛点	Docker解决方案	效果
环境不一致	镜像打包环境	任何地方都能运行
依赖包冲突	容器隔离	每个项目独立环境
部署复杂	一键启动	30秒部署完成
资源浪费	共享内核	节省80%内存
版本管理	镜像标签	轻松切换版本

Docker的核心概念（先混个脸熟）

别被这些术语吓到，它们其实很好理解：

1. 镜像（Image）

镜像就是一个"打包好的程序包"，包含了：

运行程序需要的所有文件（代码、依赖、配置）
运行环境（操作系统、运行时库）

类比：镜像就像一个"模板"或者"食谱"，根据这个模板可以创建出很多相同的实例。

2. 容器（Container）

容器就是镜像运行起来的实例，一个镜像可以启动多个容器。

类比：镜像是"蛋糕模子"，容器是"做出来的蛋糕"。同一个模子可以做多个蛋糕，每个蛋糕都是独立的。

3. 仓库（Registry）

仓库就是存放镜像的地方，官方仓库叫Docker Hub。

类比：仓库就像"菜市场"或者"应用商店"，里面有各种现成的镜像供你下载使用。

Docker的工作原理

技术原理大白话版本：

Linux容器技术（LXC）：Docker利用Linux内核的特性（namespaces、cgroups）实现进程隔离
- Namespace：给进程创建独立的"视野"，让它以为自己独占系统
- Cgroups：限制进程能用的资源（CPU、内存、磁盘）
分层存储：镜像采用分层结构，每层都是只读的
- 多个镜像可以共享相同的层，节省空间
- 容器启动时在镜像最上层添加一个可写层
UnionFS（联合文件系统）：把多个目录"联合"成一个文件系统
- 看起来是一个完整的系统，实际上是由多个层叠加而成

简单理解：Docker用Linux内核的能力，让程序以为自己运行在一个独立的系统里，但实际上共享了宿主机的资源。

Docker vs 虚拟机对比

特性	Docker容器	虚拟机
启动时间	秒级	分钟级
内存占用	几MB	几GB
磁盘占用	几十MB	几GB
隔离性	进程级隔离	系统级隔离
性能	接近原生	有损耗
安全性	相对较低	较高

真实场景示例

场景1：Python项目部署

传统方式：

1. 安装Python 3.9
2. pip install 各种依赖包
3. 配置环境变量
4. 遇到版本冲突，各种排查
5. 换台电脑重来一遍...

Docker方式：

docker run -d -p 8000:8000 my-python-app
# 完成！

场景2：多版本共存

问题：项目A需要Python 3.8，项目B需要Python 3.11

传统方式：安装多个Python版本，用虚拟环境隔离，容易混乱

Docker方式：

# 项目A
docker run -d python:3.8 python app_a.py

# 项目B
docker run -d python:3.11 python app_b.py
# 互不干扰！

场景3：团队协作

问题：新同事入职，配置环境要花一天

02-Docker快速入门-10分钟理解容器

Sat, 21 Feb 2026 00:00:00 +0000

10分钟看懂Docker核心概念

别急着想复杂的概念，我们先通过一个简单的例子理解Docker。

一个最简单的例子

想象你要开一家咖啡店：

传统部署方式

每开一家分店都要：

找房子（服务器）
装修（安装操作系统、依赖环境）
买设备（安装软件）
招人培训（配置环境）
开业（部署应用）

每家店都要从头开始，而且每家店的装修、设备可能都不一样，导致咖啡品质不一致。

Docker方式

先在一个地方把一切都准备好：

做一个标准化的"店铺模板"（镜像）
包含所有的装修、设备、配方
要开新店时，直接复制这个模板（容器）
瞬间开业

每家店都一模一样，品质完全一致。

Docker的三大核心概念

1. 镜像（Image）

镜像是一个只读的"模板"，包含：

应用程序代码
运行环境（操作系统、运行时库）
依赖文件
配置参数

镜像的特点：

只读：创建后不能修改
分层：由多层叠加而成
可复用：可以基于已有镜像创建新镜像

常见镜像：

nginx：Web服务器
python：Python运行环境
mysql：MySQL数据库
redis：缓存服务

2. 容器（Container）

容器是镜像运行起来的"实例"。

容器的特点：

可以启动、停止、删除
相互隔离，互不影响
可以访问宿主机资源（需要配置）
容器内部修改不会影响镜像

类比：

镜像 = 类（Class）
容器 = 对象（Object）
一个类可以创建多个对象，一个镜像可以启动多个容器

3. 仓库（Registry）

仓库是存放镜像的地方，类似代码仓库（如GitHub）。

常见仓库：

Docker Hub：官方公共仓库（https://hub.docker.com）
阿里云镜像加速器：国内访问更快
私有仓库：企业内部使用

镜像命名规范：

仓库地址/组织名/镜像名:标签

例如：
docker.io/library/nginx:latest
registry.cn-hangzhou.aliyuncs.com/library/nginx:latest
nginx:latest  # 省略仓库地址，默认用Docker Hub

Docker的工作流程

┌─────────────┐    拉取/构建    ┌──────────────┐
│  Dockerfile │ ────────────> │    镜像      │
└─────────────┘              └──────────────┘
                                  │
                            启动容器
                                  ↓
                            ┌──────────────┐
                            │    容器      │
                            │ (运行中的应用)│
                            └──────────────┘

流程说明：

编写Dockerfile：定义如何构建镜像
构建镜像：根据Dockerfile创建镜像
推送/拉取：把镜像推送到仓库或从仓库拉取
启动容器：基于镜像运行容器

第一个Docker容器

让我们运行一个真正的容器：

# 运行一个nginx容器
docker run -d -p 80:80 --name my-web nginx

命令解析：

docker run：运行容器的命令
-d：后台运行（detach）
-p 80:80：端口映射（宿主机80 -> 容器80）
--name my-web：给容器起个名字
nginx：使用的镜像名称

验证：

打开浏览器访问 http://localhost
你会看到nginx的欢迎页面！

查看容器：

# 查看运行中的容器
docker ps

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

容器的生命周期

创建 ──> 启动 ──> 运行中 ──> 停止 ──> 删除
   ↑        ↓        ↓        ↓        ↓
   └────────────────┴────────────────┘
         任意状态都可以重启

常用操作：

03-Docker安装配置-30分钟搞定

Sat, 21 Feb 2026 00:00:00 +0000

第一次装Docker别翻车

很多人第一步就放弃了，因为装软件装崩了。别慌，我带你一步步来，保证你30分钟内搞定。

Windows用户看这里

方案1：Docker Desktop（推荐）

下载地址：https://www.docker.com/products/docker-desktop

Docker Desktop是最方便的方式，包含了：

Docker Engine
Docker Compose
图形化管理界面

安装步骤：

下载安装包并双击运行
勾选"Use WSL 2 instead of Hyper-V"（推荐）
点击"OK"开始安装
安装完成后重启电脑

验证安装：

打开PowerShell，输入：

docker --version

如果看到类似 Docker version 24.0.x，恭喜你，安装成功！

再输入：

docker run hello-world

看到 “Hello from Docker!” 就说明Docker能正常工作了。

方案2：使用WSL 2（进阶）

如果你用WSL 2开发，可以直接在WSL里安装Docker：

确保WSL 2已启用
在WSL 2中执行：

curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

启动Docker服务：

sudo service docker start

配置国内镜像加速器

重要：Docker Hub在国外，不配置镜像加速器会很慢。

打开Docker Desktop
进入设置（Settings）-> Docker Engine
添加以下配置：

{
  "registry-mirrors": [
    "https://docker.mirrors.ustc.edu.cn",
    "https://hub-mirror.c.163.com"
  ]
}

点击"Apply & Restart"

Mac用户看这里

方案1：Docker Desktop for Mac（推荐）

下载地址：https://www.docker.com/products/docker-desktop

安装步骤：

下载.dmg文件并双击
把Docker拖到Applications文件夹
打开Docker Desktop
输入管理员密码

验证安装：

docker --version
docker run hello-world

方案2：Homebrew安装（开发者首选）

# 安装Docker Desktop
brew install --cask docker

或者直接用命令行安装Docker Engine：

brew install docker
brew install docker-compose

配置国内镜像加速器

打开Docker Desktop
进入Preferences -> Docker Engine
添加镜像配置：

{
  "registry-mirrors": [
    "https://docker.mirrors.ustc.edu.cn",
    "https://hub-mirror.c.163.com"
  ]
}

点击"Apply & Restart"

Linux用户看这里

Ubuntu/Debian系统

# 1. 更新软件包索引
sudo apt-get update

# 2. 安装依赖
sudo apt-get install \
    ca-certificates \
    curl \
    gnupg \
    lsb-release

# 3. 添加Docker的官方GPG密钥
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

# 4. 设置仓库
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

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

# 6. 验证安装
sudo docker run hello-world

CentOS/RHEL系统

# 1. 安装yum-utils
sudo yum install -y yum-utils

# 2. 添加Docker仓库
sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

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

# 4. 启动Docker
sudo systemctl start docker

# 5. 设置开机自启
sudo systemctl enable docker

# 6. 验证安装
sudo docker run hello-world

配置国内镜像加速器

编辑 /etc/docker/daemon.json：

04-镜像操作-理解Docker的"蓝图"

Sat, 21 Feb 2026 00:00:00 +0000

镜像是Docker的核心

前几章我们说镜像是一个"模板"，现在深入理解一下：镜像是Docker的核心，没有镜像就没有容器。

镜像的基本操作

1. 拉取镜像

从仓库下载镜像到本地：

# 基本用法
docker pull 镜像名

# 示例
docker pull nginx
docker pull python:3.11
docker pull mysql:8.0

镜像标签（Tag）：

nginx：默认使用latest标签
nginx:1.24：指定版本1.24
python:3.11-alpine：使用alpine基础镜像（体积更小）

常用镜像源：

Docker Hub（默认）：nginx
阿里云：registry.cn-hangzhou.aliyuncs.com/library/nginx

2. 查看本地镜像

# 列出所有镜像
docker images

# 只显示镜像ID
docker images -q

# 显示完整的镜像信息（包括层信息）
docker images --digests

输出说明：

REPOSITORY    TAG       IMAGE ID       CREATED        SIZE
nginx         latest    123456789abc   2 weeks ago    142MB
python        3.11      abcdef123456   3 days ago     1GB
mysql         8.0       123abc456def   1 month ago    542MB

REPOSITORY：镜像名称
TAG：标签（版本）
IMAGE ID：镜像唯一标识
CREATED：创建时间
SIZE：镜像大小

3. 删除镜像

# 删除指定镜像
docker rmi 镜像名

# 删除多个镜像
docker rmi nginx nginx:1.24 python:3.11

# 删除所有镜像（慎用）
docker rmi $(docker images -q)

# 强制删除镜像（即使有容器在使用）
docker rmi -f nginx

注意：删除镜像前要先删除基于这个镜像的容器。

4. 查看镜像详细信息

# 查看镜像详细信息
docker inspect 镜像名

# 查看镜像的层信息
docker history 镜像名

镜像的分层原理

什么是分层？

Docker镜像由多个只读层叠加而成，每层代表镜像构建的一个步骤：

┌────────────────────┐
│  应用层（你的代码）  │  ← 这层最小
├────────────────────┤
│   依赖包层         │
├────────────────────┤
│   运行环境层       │
├────────────────────┤
│   基础系统层       │  ← 这层最大
└────────────────────┘

分层的好处

1. 节省空间： 多个镜像可以共享相同的层，例如：

05-容器操作-运行你的第一个程序

Sat, 21 Feb 2026 00:00:00 +0000

容器是镜像的运行实例

前几章我们说镜像是"模板"，容器就是"根据模板做出来的实例"。今天深入学习容器的操作。

容器的生命周期

┌─────────┐   create    ┌─────────┐
│   创建   │ ────────>  │  启动   │
└─────────┘            └────┬────┘
                            │
                         start
                            ↓
┌─────────┐   restart   ┌────┴────┐
│  停止   │ <────────── │  运行中  │
└────┬────┘             └─────────┘
     │
  kill/stop
     ↓
┌─────────┐   rm       ┌─────────┐
│  删除   │ ────────>  │  已结束  │
└─────────┘            └─────────┘

创建和启动容器

docker run 详解

docker run 是最常用的命令，它包含了创建和启动两个步骤：

docker run [选项] 镜像 [命令] [参数]

常用选项

后台运行

# -d, --detach
docker run -d nginx

端口映射

# -p 宿主机端口:容器端口
docker run -d -p 8080:80 nginx

# 多个端口
docker run -d -p 80:80 -p 443:443 nginx

# 随机端口
docker run -d -P nginx

容器名称

# --name 给容器起名
docker run -d --name my-nginx nginx

为什么建议给容器起名？

方便管理（不用记容器ID）
容器重启后名称不变
其他容器可以通过名称访问

环境变量

# -e, --env 设置环境变量
docker run -d -e MYSQL_ROOT_PASSWORD=123456 mysql

# 多个环境变量
docker run -d -e TZ=Asia/Shanghai -e LANG=C.UTF-8 nginx

# 从文件读取
cat > env.txt << 'EOF'
TZ=Asia/Shanghai
LANG=C.UTF-8
EOF
docker run -d --env-file env.txt nginx

数据卷挂载

# -v 宿主机路径:容器路径
docker run -d -v /data/nginx:/usr/share/nginx/html nginx

# 只读挂载
docker run -d -v /data:/data:ro nginx

# 命名卷
docker run -d -v mydata:/data nginx

工作目录

# -w, --workdir 设置工作目录
docker run -d -w /app python:3.11 python app.py

用户

# -u, --user 指定运行用户
docker run -d -u 1000:1000 nginx

资源限制

# 限制内存
docker run -d -m 512m nginx

# 限制CPU（使用0.5个核心）
docker run -d --cpus 0.5 nginx

# 组合限制
docker run -d -m 512m --cpus 1 nginx

自动重启

# --restart=always 容器退出后自动重启
docker run -d --restart=always nginx

# --restart=on-failure 只在失败时重启
docker run -d --restart=on-failure:3 nginx

# --restart=unless-stopped 除非手动停止，否则自动重启
docker run -d --restart=unless-stopped nginx

交互式运行

# -i, --interactive 保持标准输入打开
# -t, --tty 分配一个伪终端
docker run -it ubuntu bash

# 示例：进入Python交互环境
docker run -it python:3.11 python

清理容器

# --rm 容器退出后自动删除
docker run --rm nginx

查看容器

查看运行中的容器

docker ps

# 只显示容器ID
docker ps -q

# 显示完整信息（包括停止的）
docker ps -a

# 显示最后创建的容器
docker ps -l

# 显示最近N个容器
docker ps -n 5

输出说明：

06-Dockerfile-编写自己的镜像

Sat, 21 Feb 2026 00:00:00 +0000

Dockerfile是镜像的"配方"

前几章我们用现成的镜像，今天学习如何编写Dockerfile，创建自己的镜像。

什么是Dockerfile？

Dockerfile是一个文本文件，包含一系列指令，用于构建Docker镜像。

类比：

Dockerfile = 烹饪食谱
镜像 = 做好的菜
容器 = 端上桌的菜

Dockerfile基础语法

基本结构

# 注释以#开头
FROM ubuntu:20.04
RUN apt-get update
CMD ["echo", "Hello, Docker!"]

指令执行顺序

Docker会按照从上到下的顺序执行指令，每执行一条指令就会创建一个新的镜像层。

常用指令详解

1. FROM - 基础镜像

# 基本用法
FROM python:3.11
FROM ubuntu:20.04

# 多阶段构建的第一阶段
FROM python:3.11 AS builder

选择基础镜像的原则：

官方镜像优先：python、node、nginx等
版本明确：python:3.11.7 比 python:3.11 更明确
体积要小：使用alpine或slim版本
安全可靠：优先使用经过安全审计的镜像

常用基础镜像：

alpine：最轻量（5MB）
slim：比完整版小很多
latest：最新版（生产环境不推荐）

2. LABEL - 镜像元数据

LABEL maintainer="yourname@example.com"
LABEL version="1.0"
LABEL description="My awesome application"

查看镜像标签：

docker inspect myapp | grep Labels

3. RUN - 执行命令

# Shell形式（默认）
RUN apt-get update && apt-get install -y curl

# Exec形式（推荐）
RUN ["apt-get", "update"]
RUN ["apt-get", "install", "-y", "curl"]

# 组合多个命令（减少层数）
RUN apt-get update && \
    apt-get install -y \
    curl \
    wget \
    vim && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*

优化建议：

合并RUN指令（减少层数）
清理缓存（减小镜像体积）
使用 --no-cache-dir（Python）
使用 && 连接命令

4. COPY - 复制文件

# 复制文件
COPY requirements.txt /app/

# 复制目录
COPY . /app/

# 使用--from从其他阶段复制（多阶段构建）
COPY --from=builder /app/dist /app/

COPY vs ADD的区别：

07-数据持久化-容器里数据不丢失

Sat, 21 Feb 2026 00:00:00 +0000

容器删除，数据还在吗？

问题：容器默认的文件系统是临时的，容器删除后，所有数据都会丢失。

场景：

运行一个MySQL数据库，插入了大量数据
删除容器重新创建
数据全部丢失！

解决：使用数据卷（Volume）实现数据持久化。

数据卷（Volume）

什么是数据卷？

数据卷是Docker管理的数据存储机制，独立于容器生命周期。

特点：

独立于容器，容器删除后数据还在
可以在容器之间共享
性能好（直接读写宿主机文件系统）
备份和迁移方便

基本操作

1. 创建数据卷

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

# 查看数据卷
docker volume ls

# 查看数据卷详细信息
docker volume inspect my-data

输出示例：

[
    {
        "CreatedAt": "2023-01-01T00:00:00Z",
        "Driver": "local",
        "Labels": {},
        "Mountpoint": "/var/lib/docker/volumes/my-data/_data",
        "Name": "my-data",
        "Options": {},
        "Scope": "local"
    }
]

Mountpoint：数据卷在宿主机的实际路径

2. 使用数据卷运行容器

# 挂载数据卷
docker run -d -v my-data:/data nginx

# 多个数据卷
docker run -d \
  -v mysql-data:/var/lib/mysql \
  -v mysql-logs:/var/log/mysql \
  mysql:8.0

3. 查看数据卷

# 列出所有数据卷
docker volume ls

# 查看数据卷详细信息
docker volume inspect my-data

# 查看数据卷内容
sudo ls /var/lib/docker/volumes/my-data/_data

4. 删除数据卷

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

# 删除指定数据卷
docker volume rm my-data

# 删除容器时同时删除数据卷（慎用）
docker rm -v my-container

注意：删除数据卷会永久删除数据，无法恢复！

绑定挂载（Bind Mount）

什么是绑定挂载？

将宿主机的目录或文件挂载到容器中。

特点：

直接映射宿主机文件系统
适合开发环境（实时同步代码）
需要处理权限问题

基本用法

# 挂载宿主机目录到容器
docker run -d -v /path/on/host:/path/in/container nginx

# 相对路径（相对于当前目录）
docker run -d -v $(pwd)/html:/usr/share/nginx/html nginx

# 挂载单个文件
docker run -d -v $(pwd)/nginx.conf:/etc/nginx/nginx.conf nginx

读写权限

# 读写（默认）
docker run -d -v /data:/app nginx

# 只读
docker run -d -v /data:/app:ro nginx

# 读写+指定用户
docker run -d -v /data:/app:ro -u 1000:1000 nginx

实战：同步开发代码

# 项目目录
cd my-flask-app

# 挂载当前目录到容器
docker run -d -p 8000:8000 -v $(pwd):/app python:3.11 \
  python -u /app/app.py

修改代码后，容器内立即生效！

08-网络管理-让容器之间互相通信

Sat, 21 Feb 2026 00:00:00 +0000

容器之间怎么通信？

问题：默认情况下，容器之间是隔离的，无法直接访问。

场景：

Web应用容器需要访问数据库容器
多个微服务容器需要互相调用
外部需要访问容器内的服务

解决：使用Docker网络实现容器间通信。

Docker网络基础

网络类型

1. bridge（桥接网络，默认）

特点：

默认网络类型
每个容器分配独立IP
容器通过bridge互相通信
通过端口映射对外暴露服务

原理：

宿主机
    │
    ├── docker0（虚拟网桥）
    │       │
    │       ├── 容器A (172.17.0.2)
    │       ├── 容器B (172.17.0.3)
    │       └── 容器C (172.17.0.4)

2. host（主机网络）

特点：

容器使用宿主机网络栈
没有网络隔离
性能最好
不需要端口映射

使用场景：

高性能应用
需要直接访问宿主机网络

docker run --network=host nginx

3. none（无网络）

特点：

容器没有网络
完全隔离
适合不需要网络的应用

docker run --network=none alpine sleep 3600

4. overlay（覆盖网络）

特点：

跨主机容器通信
需要Swarm或Kubernetes
生产环境常用

使用场景：

分布式应用
微服务架构

网络基本操作

1. 查看网络

# 列出所有网络
docker network ls

# 查看网络详细信息
docker network inspect bridge

# 查看网络中的容器
docker network inspect bridge | grep -A 10 Containers

输出示例：

NETWORK ID     NAME      DRIVER    SCOPE
a1b2c3d4e5f6   bridge    bridge    local
abc123def456   host      host      local
123abc456def   none      null      local

2. 创建网络

# 创建bridge网络
docker network create my-network

# 创建自定义bridge网络（指定子网）
docker network create \
  --driver=bridge \
  --subnet=172.20.0.0/16 \
  --ip-range=172.20.10.0/24 \
  --gateway=172.20.10.1 \
  my-custom-network

# 创建overlay网络（Swarm集群）
docker network create --driver=overlay my-overlay-network

3. 删除网络

# 删除网络
docker network rm my-network

# 删除未使用的网络
docker network prune

4. 连接容器到网络

# 运行容器时指定网络
docker run -d --network=bridge --name myapp nginx

# 将已有容器连接到网络
docker network connect my-network myapp

# 断开容器与网络的连接
docker network disconnect my-network myapp

# 连接时指定别名
docker network connect --alias web my-network myapp

容器间通信

场景1：同一网络中的容器通信

# 1. 创建网络
docker network create app-network

# 2. 运行Web应用容器
docker run -d \
  --network=app-network \
  --name webapp \
  nginx

# 3. 运行数据库容器
docker run -d \
  --network=app-network \
  --name db \
  -e MYSQL_ROOT_PASSWORD=123456 \
  mysql:8.0

# 4. Web应用可以直接通过名称访问数据库
docker exec webapp ping db
docker exec webapp nc -zv db 3306

关键点：

09-Docker Compose-一键启动多个服务

Sat, 21 Feb 2026 00:00:00 +0000

一个命令启动整个项目？

问题：一个完整的Web应用通常需要多个服务：

Web服务器
数据库
缓存
消息队列

传统方式：

docker run -d --name web -p 80:80 nginx
docker run -d --name db -e MYSQL_ROOT_PASSWORD=123456 mysql:8.0
docker run -d --name cache redis
...

Docker Compose方式：

docker-compose up -d
# 一键启动所有服务！

什么是Docker Compose？

定义：Docker Compose是用于定义和运行多容器Docker应用的工具。

特点：

使用YAML文件定义服务
一条命令启动/停止所有服务
自动创建和管理网络
服务之间通过名称互相访问
支持环境变量和配置文件

安装：

# Linux安装
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

# Docker Desktop自带
# Windows和Mac用户无需单独安装

验证安装：

docker-compose --version

docker-compose.yml基本结构

最简单的示例

version: '3.8'

services:
  web:
    image: nginx
    ports:
      - "80:80"

解释：

version：Compose文件版本
services：定义服务
web：服务名称
image：使用的镜像
ports：端口映射

完整示例

version: '3.8'

services:
  web:
    image: nginx:latest
    container_name: my-web
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html
      - ./nginx.conf:/etc/nginx/nginx.conf
    networks:
      - app-network
    environment:
      - TZ=Asia/Shanghai
    restart: unless-stopped

  db:
    image: mysql:8.0
    container_name: my-db
    environment:
      MYSQL_ROOT_PASSWORD: 123456
      MYSQL_DATABASE: mydb
    volumes:
      - mysql-data:/var/lib/mysql
    networks:
      - app-network
    restart: unless-stopped

  cache:
    image: redis:alpine
    container_name: my-cache
    command: redis-server --appendonly yes
    volumes:
      - redis-data:/data
    networks:
      - app-network
    restart: unless-stopped

networks:
  app-network:
    driver: bridge

volumes:
  mysql-data:
  redis-data:

常用配置项

1. image - 镜像

services:
  web:
    image: nginx:latest
  app:
    image: myapp:v1.0

2. build - 构建镜像

services:
  app:
    build: .
    # 或
    build:
      context: .
      dockerfile: Dockerfile
      args:
        VERSION: 1.0

3. ports - 端口映射

services:
  web:
    ports:
      - "80:80"              # 宿主机80映射到容器80
      - "443:443"
      - "8000-8010:8000-8010"  # 端口范围
      - "127.0.0.1:8080:80"    # 只绑定localhost

4. volumes - 数据卷

services:
  db:
    volumes:
      - db-data:/var/lib/mysql      # 命名卷
      - ./data:/data                 # 绑定挂载
      - /etc/localtime:/etc/localtime:ro  # 只读挂载

volumes:
  db-data:

5. environment - 环境变量

services:
  db:
    environment:
      - MYSQL_ROOT_PASSWORD=123456
      - MYSQL_DATABASE=mydb
      # 或
      MYSQL_ROOT_PASSWORD: 123456
      MYSQL_DATABASE: mydb

6. env_file - 环境变量文件

services:
  app:
    env_file:
      - .env
      - .env.prod

.env文件内容：

10-实战项目1-Python项目打包部署

Sat, 21 Feb 2026 00:00:00 +0000

用Docker部署Python项目

今天我们来做第一个实战项目：把一个Python Web应用打包成Docker镜像并部署。

项目背景

假设我们有一个Flask Web应用：

提供RESTful API
使用MySQL数据库
使用Redis缓存
需要持久化数据

项目结构

my-flask-app/
├── app.py              # Flask应用主文件
├── requirements.txt    # Python依赖
├── Dockerfile         # Docker镜像定义
├── docker-compose.yml # 多容器编排
├── .env              # 环境变量
├── .dockerignore     # Docker忽略文件
└── data/            # 本地数据目录（可选）

1. 创建Flask应用

app.py

from flask import Flask, jsonify, request
from flask_cors import CORS
import os
import mysql.connector
import redis
import datetime

app = Flask(__name__)
CORS(app)

# 数据库配置
db_config = {
    'host': os.getenv('DB_HOST', 'localhost'),
    'user': os.getenv('DB_USER', 'root'),
    'password': os.getenv('DB_PASSWORD', '123456'),
    'database': os.getenv('DB_NAME', 'mydb')
}

# Redis配置
redis_config = {
    'host': os.getenv('REDIS_HOST', 'localhost'),
    'port': int(os.getenv('REDIS_PORT', 6379)),
    'db': 0
}

def get_db_connection():
    """获取数据库连接"""
    return mysql.connector.connect(**db_config)

def get_redis_connection():
    """获取Redis连接"""
    return redis.Redis(**redis_config)

@app.route('/')
def index():
    """首页"""
    return jsonify({
        'message': 'Welcome to Flask API',
        'version': '1.0',
        'timestamp': datetime.datetime.now().isoformat()
    })

@app.route('/health')
def health():
    """健康检查"""
    try:
        # 检查数据库
        conn = get_db_connection()
        cursor = conn.cursor()
        cursor.execute("SELECT 1")
        cursor.close()
        conn.close()

        # 检查Redis
        r = get_redis_connection()
        r.ping()

        return jsonify({'status': 'healthy', 'checks': {'db': 'ok', 'redis': 'ok'}})
    except Exception as e:
        return jsonify({'status': 'unhealthy', 'error': str(e)}), 500

@app.route('/users', methods=['GET'])
def get_users():
    """获取所有用户"""
    try:
        # 先从Redis缓存获取
        r = get_redis_connection()
        cached = r.get('users')

        if cached:
            return jsonify({'source': 'cache', 'data': eval(cached)})

        # 缓存未命中，从数据库获取
        conn = get_db_connection()
        cursor = conn.cursor(dictionary=True)
        cursor.execute("SELECT * FROM users")
        users = cursor.fetchall()
        cursor.close()
        conn.close()

        # 写入缓存，有效期300秒
        r.setex('users', 300, str(users))

        return jsonify({'source': 'database', 'data': users})

    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/users', methods=['POST'])
def create_user():
    """创建用户"""
    try:
        data = request.json
        name = data.get('name')
        email = data.get('email')

        if not name or not email:
            return jsonify({'error': 'Name and email are required'}), 400

        conn = get_db_connection()
        cursor = conn.cursor()
        cursor.execute(
            "INSERT INTO users (name, email) VALUES (%s, %s)",
            (name, email)
        )
        conn.commit()
        user_id = cursor.lastrowid
        cursor.close()
        conn.close()

        # 清除缓存
        r = get_redis_connection()
        r.delete('users')

        return jsonify({'id': user_id, 'name': name, 'email': email}), 201

    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/users/<int:user_id>', methods=['GET'])
def get_user(user_id):
    """获取单个用户"""
    try:
        conn = get_db_connection()
        cursor = conn.cursor(dictionary=True)
        cursor.execute("SELECT * FROM users WHERE id = %s", (user_id,))
        user = cursor.fetchone()
        cursor.close()
        conn.close()

        if not user:
            return jsonify({'error': 'User not found'}), 404

        return jsonify(user)

    except Exception as e:
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8000, debug=os.getenv('DEBUG', 'False') == 'True')

2. 依赖文件

requirements.txt

flask==2.3.0
flask-cors==4.0.0
mysql-connector-python==8.1.0
redis==4.6.0
gunicorn==21.2.0

3. Docker镜像定义

Dockerfile

# 多阶段构建

# 构建阶段
FROM python:3.11-slim AS builder

WORKDIR /app

# 安装系统依赖
RUN apt-get update && \
    apt-get install -y --no-install-recommends \
    gcc \
    default-libmysqlclient-dev \
    pkg-config \
    && rm -rf /var/lib/apt/lists/*

# 只复制依赖文件（利用构建缓存）
COPY requirements.txt .

# 安装Python依赖
RUN pip install --no-cache-dir -r requirements.txt

# 运行阶段
FROM python:3.11-slim

WORKDIR /app

# 复制依赖
COPY --from=builder /usr/local/lib/python3.11/site-packages /usr/local/lib/python3.11/site-packages
COPY --from=builder /usr/local/bin /usr/local/bin

# 复制应用代码
COPY . .

# 创建非root用户
RUN groupadd -r appuser && useradd -r -g appuser appuser
RUN chown -R appuser:appuser /app
USER appuser

# 设置环境变量
ENV PYTHONUNBUFFERED=1
ENV TZ=Asia/Shanghai

# 暴露端口
EXPOSE 8000

# 健康检查
HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
    CMD python -c "import requests; requests.get('http://localhost:8000/health')" || exit 1

# 启动命令
CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:8000", "--timeout", "120", "app:app"]

.dockerignore

# Git文件
.git
.gitignore

# Python缓存
__pycache__
*.py[cod]
*$py.class
*.so
.Python

# 虚拟环境
venv/
env/
ENV/
.venv

# IDE配置
.vscode/
.idea/
*.swp
*.swo

# 日志文件
*.log
logs/

# 环境变量
.env

# 测试文件
tests/
.pytest_cache/
.coverage

# 文档
docs/
*.md

4. 多容器编排

docker-compose.yml

version: '3.8'

services:
  # Flask应用
  app:
    build: .
    container_name: flask-app
    ports:
      - "${APP_PORT:-8000}:8000"
    environment:
      - DB_HOST=db
      - DB_USER=root
      - DB_PASSWORD=${DB_PASSWORD:-123456}
      - DB_NAME=${DB_NAME:-mydb}
      - REDIS_HOST=redis
      - REDIS_PORT=6379
      - DEBUG=${DEBUG:-False}
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_healthy
    networks:
      - app-network
    restart: unless-stopped

  # MySQL数据库
  db:
    image: mysql:8.0
    container_name: mysql-db
    environment:
      MYSQL_ROOT_PASSWORD: ${DB_PASSWORD:-123456}
      MYSQL_DATABASE: ${DB_NAME:-mydb}
    volumes:
      - mysql-data:/var/lib/mysql
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
    ports:
      - "${DB_PORT:-3306}:3306"
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-uroot", "-p${DB_PASSWORD:-123456}"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s
    restart: unless-stopped

  # Redis缓存
  redis:
    image: redis:7-alpine
    container_name: redis-cache
    ports:
      - "${REDIS_PORT:-6379}:6379"
    volumes:
      - redis-data:/data
    command: redis-server --appendonly yes
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 3
    restart: unless-stopped

networks:
  app-network:
    driver: bridge

volumes:
  mysql-data:
  redis-data:

init.sql（数据库初始化脚本）

-- 创建用户表
CREATE TABLE IF NOT EXISTS users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) NOT NULL UNIQUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 插入测试数据
INSERT INTO users (name, email) VALUES
('Alice', 'alice@example.com'),
('Bob', 'bob@example.com'),
('Charlie', 'charlie@example.com');

.env（环境变量文件）

# 应用配置
APP_PORT=8000
DEBUG=False

# 数据库配置
DB_PASSWORD=123456
DB_NAME=mydb
DB_PORT=3306

# Redis配置
REDIS_PORT=6379

5. 技术原理解释

为什么用Docker？

问题1：环境一致性

11-实战项目2-Web应用完整部署

Sat, 21 Feb 2026 00:00:00 +0000

完整的Web应用部署方案

上一章我们部署了Python后端API，今天我们来做前后端分离的完整Web应用部署。

项目架构

┌─────────────────────────────────────────────────────────┐
│                        Nginx                             │
│                    (反向代理 + SSL)                      │
│                     ┌────────┬────────┐                 │
│                     │        │        │                 │
│                     ↓        ↓        ↓                 │
│                  React    Flask     Admin              │
│                  (前端)   (API)   (后台)                │
│                     │        │        │                 │
│                     └────────┴────────┘                 │
│                              ↓                          │
│                    ┌──────────────────┐                 │
│                    │   MySQL + Redis   │                 │
│                    └──────────────────┘                 │
└─────────────────────────────────────────────────────────┘

1. 前端项目（React）

项目结构

frontend/
├── package.json
├── Dockerfile
├── nginx.conf
└── src/
    ├── App.js
    └── index.js

Dockerfile

# 构建阶段
FROM node:18-alpine AS builder

WORKDIR /app

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

# 安装依赖
RUN npm ci --only=production

# 复制源代码
COPY . .

# 构建应用
RUN npm run build

# 运行阶段
FROM nginx:alpine

# 复制构建产物
COPY --from=builder /app/build /usr/share/nginx/html

# 复制nginx配置
COPY nginx.conf /etc/nginx/conf.d/default.conf

# 暴露端口
EXPOSE 80

# 启动nginx
CMD ["nginx", "-g", "daemon off;"]

nginx.conf

server {
    listen 80;
    server_name localhost;

    root /usr/share/nginx/html;
    index index.html;

    # Gzip压缩
    gzip on;
    gzip_vary on;
    gzip_min_length 1024;
    gzip_types text/plain text/css text/xml text/javascript application/x-javascript application/xml+rss application/json;

    # 路由配置（React Router）
    location / {
        try_files $uri $uri/ /index.html;
    }

    # API代理
    location /api/ {
        proxy_pass http://api:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    # 静态资源缓存
    location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg)$ {
        expires 30d;
        add_header Cache-Control "public, immutable";
    }
}

package.json

{
  "name": "frontend",
  "version": "1.0.0",
  "scripts": {
    "start": "react-scripts start",
    "build": "react-scripts build",
    "test": "react-scripts test"
  },
  "dependencies": {
    "react": "^18.2.0",
    "react-dom": "^18.2.0",
    "react-router-dom": "^6.14.0",
    "axios": "^1.4.0"
  },
  "devDependencies": {
    "react-scripts": "5.0.1"
  }
}

2. 后端API（Flask）

项目结构

backend/
├── app.py
├── requirements.txt
└── Dockerfile

Dockerfile

FROM python:3.11-slim

WORKDIR /app

# 安装系统依赖
RUN apt-get update && \
    apt-get install -y --no-install-recommends \
    gcc \
    default-libmysqlclient-dev \
    pkg-config \
    && rm -rf /var/lib/apt/lists/*

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

# 安装Python依赖
RUN pip install --no-cache-dir -r requirements.txt

# 复制应用代码
COPY . .

# 创建非root用户
RUN groupadd -r appuser && useradd -r -g appuser appuser
RUN chown -R appuser:appuser /app
USER appuser

# 环境变量
ENV PYTHONUNBUFFERED=1

# 暴露端口
EXPOSE 8000

# 启动命令
CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:8000", "--timeout", "120", "app:app"]

requirements.txt

flask==2.3.0
flask-cors==4.0.0
mysql-connector-python==8.1.0
redis==4.6.0
gunicorn==21.2.0

3. 管理后台（Flask Admin）

项目结构

admin/
├── app.py
├── requirements.txt
└── Dockerfile

Dockerfile

FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

RUN groupadd -r admin && useradd -r -g admin admin
RUN chown -R admin:admin /app
USER admin

ENV PYTHONUNBUFFERED=1

EXPOSE 8001

CMD ["gunicorn", "-w", "2", "-b", "0.0.0.0:8001", "app:app"]

requirements.txt

flask==2.3.0
flask-admin==1.6.1
flask-sqlalchemy==3.0.5
mysql-connector-python==8.1.0
gunicorn==21.2.0

4. Nginx反向代理

nginx/nginx.conf

events {
    worker_connections 1024;
}

http {
    # 前端
    upstream frontend {
        server frontend:80;
    }

    # 后端API
    upstream api {
        server api:8000;
    }

    # 管理后台
    upstream admin {
        server admin:8001;
    }

    # 限流配置
    limit_req_zone $binary_remote_addr zone=api_limit:10m rate=10r/s;

    server {
        listen 80;
        server_name example.com www.example.com;

        # SSL重定向
        return 301 https://$server_name$request_uri;
    }

    server {
        listen 443 ssl http2;
        server_name example.com www.example.com;

        # SSL证书配置
        ssl_certificate /etc/nginx/ssl/cert.pem;
        ssl_certificate_key /etc/nginx/ssl/key.pem;

        # SSL优化
        ssl_protocols TLSv1.2 TLSv1.3;
        ssl_ciphers HIGH:!aNULL:!MD5;
        ssl_prefer_server_ciphers on;
        ssl_session_cache shared:SSL:10m;
        ssl_session_timeout 10m;

        # Gzip压缩
        gzip on;
        gzip_vary on;
        gzip_min_length 1024;
        gzip_types text/plain text/css text/xml text/javascript application/x-javascript application/xml+rss application/json;

        # 前端
        location / {
            proxy_pass http://frontend;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
        }

        # API限流
        location /api/ {
            limit_req zone=api_limit burst=20 nodelay;

            proxy_pass http://api;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;

            # 超时配置
            proxy_connect_timeout 60s;
            proxy_send_timeout 60s;
            proxy_read_timeout 60s;
        }

        # 管理后台
        location /admin/ {
            proxy_pass http://admin/;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;

            # IP白名单（可选）
            # allow 192.168.1.0/24;
            # deny all;
        }

        # 日志配置
        access_log /var/log/nginx/access.log;
        error_log /var/log/nginx/error.log;
    }
}

5. Docker Compose编排

docker-compose.yml

version: '3.8'

services:
  # Nginx反向代理
  nginx:
    image: nginx:alpine
    container_name: nginx-proxy
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf
      - ./nginx/ssl:/etc/nginx/ssl
      - nginx-logs:/var/log/nginx
    depends_on:
      - frontend
      - api
      - admin
    networks:
      - app-network
    restart: unless-stopped

  # 前端
  frontend:
    build:
      context: ./frontend
      dockerfile: Dockerfile
    container_name: frontend-app
    networks:
      - app-network
    restart: unless-stopped

  # 后端API
  api:
    build:
      context: ./backend
      dockerfile: Dockerfile
    container_name: api-server
    environment:
      - DB_HOST=db
      - DB_USER=root
      - DB_PASSWORD=${DB_PASSWORD:-123456}
      - DB_NAME=${DB_NAME:-mydb}
      - REDIS_HOST=redis
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_healthy
    networks:
      - app-network
    restart: unless-stopped

  # 管理后台
  admin:
    build:
      context: ./admin
      dockerfile: Dockerfile
    container_name: admin-panel
    environment:
      - DB_HOST=db
      - DB_USER=root
      - DB_PASSWORD=${DB_PASSWORD:-123456}
      - DB_NAME=${DB_NAME:-mydb}
    depends_on:
      db:
        condition: service_healthy
    networks:
      - app-network
    restart: unless-stopped

  # MySQL数据库
  db:
    image: mysql:8.0
    container_name: mysql-db
    environment:
      MYSQL_ROOT_PASSWORD: ${DB_PASSWORD:-123456}
      MYSQL_DATABASE: ${DB_NAME:-mydb}
    volumes:
      - mysql-data:/var/lib/mysql
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
    ports:
      - "${DB_PORT:-3306}:3306"
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-uroot", "-p${DB_PASSWORD:-123456}"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s
    restart: unless-stopped

  # Redis缓存
  redis:
    image: redis:7-alpine
    container_name: redis-cache
    volumes:
      - redis-data:/data
    command: redis-server --appendonly yes --requirepass ${REDIS_PASSWORD:-123456}
    ports:
      - "${REDIS_PORT:-6379}:6379"
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "redis-cli", "-a", "${REDIS_PASSWORD:-123456}", "ping"]
      interval: 10s
      timeout: 5s
      retries: 3
    restart: unless-stopped

networks:
  app-network:
    driver: bridge

volumes:
  mysql-data:
  redis-data:
  nginx-logs:

6. 数据库初始化

init.sql

-- 创建数据库表
USE mydb;

-- 用户表
CREATE TABLE IF NOT EXISTS users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(50) NOT NULL UNIQUE,
    email VARCHAR(100) NOT NULL UNIQUE,
    password VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 文章表
CREATE TABLE IF NOT EXISTS articles (
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(200) NOT NULL,
    content TEXT,
    author_id INT,
    status ENUM('draft', 'published') DEFAULT 'draft',
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    FOREIGN KEY (author_id) REFERENCES users(id) ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 评论表
CREATE TABLE IF NOT EXISTS comments (
    id INT AUTO_INCREMENT PRIMARY KEY,
    article_id INT,
    user_id INT,
    content TEXT NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (article_id) REFERENCES articles(id) ON DELETE CASCADE,
    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 插入测试数据
INSERT INTO users (username, email, password) VALUES
('admin', 'admin@example.com', '$2b$12$LQv3c1yqBWVHxkd0LHAkCOYz6TtxMQJqhN8/LewY5GyY6X7yGKJ2i'),
('user1', 'user1@example.com', '$2b$12$LQv3c1yqBWVHxkd0LHAkCOYz6TtxMQJqhN8/LewY5GyY6X7yGKJ2i');

INSERT INTO articles (title, content, author_id, status) VALUES
('第一篇文章', '这是第一篇文章的内容', 1, 'published'),
('第二篇文章', '这是第二篇文章的内容', 1, 'published'),
('草稿文章', '这是一篇草稿', 1, 'draft');

7. 部署和测试

构建和启动

# 构建所有镜像
docker-compose build

# 启动所有服务
docker-compose up -d

# 查看状态
docker-compose ps

# 查看日志
docker-compose logs -f

测试各服务

# 测试前端
curl http://localhost

# 测试API健康检查
curl http://localhost/api/health

# 测试管理后台
curl http://localhost/admin/

# 查看数据库
docker exec -it mysql-db mysql -uroot -p123456 -e "USE mydb; SELECT * FROM users;"

性能测试

# 使用ab进行压力测试
ab -n 1000 -c 100 http://localhost/api/health

# 查看Nginx日志
docker exec nginx-proxy tail -f /var/log/nginx/access.log

8. 监控和日志

安装监控工具

# 添加到docker-compose.yml
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus-data:/prometheus
    ports:
      - "9090:9090"
    networks:
      - app-network

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    volumes:
      - grafana-data:/var/lib/grafana
    ports:
      - "3000:3000"
    networks:
      - app-network

volumes:
  prometheus-data:
  grafana-data:

日志聚合

# 查看所有服务日志
docker-compose logs

# 查看特定服务日志
docker-compose logs -f api

# 导出日志
docker-compose logs --since 24h > logs.txt

9. 备份和恢复

数据库备份

# 备份数据库
docker exec mysql-db mysqldump -uroot -p123456 mydb > backup_$(date +%Y%m%d).sql

# 恢复数据库
docker exec -i mysql-db mysql -uroot -p123456 mydb < backup_20231201.sql

定时备份

# 添加到crontab
0 2 * * * /path/to/backup.sh

# backup.sh内容
#!/bin/bash
BACKUP_DIR="/data/backups"
DATE=$(date +%Y%m%d)
docker exec mysql-db mysqldump -uroot -p123456 mydb > ${BACKUP_DIR}/backup_${DATE}.sql
find ${BACKUP_DIR} -name "backup_*.sql" -mtime +7 -delete

10. SSL证书配置

使用Let’s Encrypt

# 安装certbot
sudo apt-get install certbot

# 获取证书
sudo certbot certonly --standalone -d example.com -d www.example.com

# 复制证书到项目
sudo cp /etc/letsencrypt/live/example.com/fullchain.pem ./nginx/ssl/cert.pem
sudo cp /etc/letsencrypt/live/example.com/privkey.pem ./nginx/ssl/key.pem

本章小结

完整架构：前端 + 后端 + 后台 + 数据库 + 缓存
反向代理：Nginx + SSL + 负载均衡 + 限流
部署方案：Docker Compose一键部署
监控日志：Prometheus + Grafana + 日志聚合
备份恢复：数据库备份 + 定时任务

现在已经掌握了完整Web应用部署，下一章我们来实战微服务架构！

12-实战项目3-多容器微服务部署

Sat, 21 Feb 2026 00:00:00 +0000

微服务架构部署

今天我们实战部署一个微服务架构的应用，包含API网关、多个微服务、数据库、缓存、消息队列等。

微服务架构设计

┌─────────────────────────────────────────────────────────────┐
│                      API Gateway (Nginx)                      │
│              (反向代理 + 负载均衡 + 限流)                     │
│                    ┌─────────┬─────────┬─────────┐            │
│                    │         │         │         │            │
│              ┌─────┴────┐ ┌──┴────┐ ┌──┴────┐ ┌──┴────┐     │
│              │   用户   │ │  订单 │ │ 商品 │ │ 支付 │     │
│              │  服务    │ │ 服务 │ │ 服务 │ │ 服务 │     │
│              └─────┬────┘ └──┬────┘ └──┬────┘ └──┬────┘     │
│                    │         │         │         │            │
│                    └─────────┴─────────┴─────────┘            │
│                              │                               │
│              ┌───────────────┼───────────────┐              │
│              ↓               ↓               ↓              │
│      ┌──────────────┐ ┌──────────────┐ ┌──────────────┐     │
│      │   MySQL      │ │    Redis     │ │   RabbitMQ   │     │
│      │  (主+从)     │ │    集群       │ │  (消息队列)   │     │
│      └──────────────┘ └──────────────┘ └──────────────┘     │
└─────────────────────────────────────────────────────────────┘

1. API网关

nginx/nginx.conf

events {
    worker_connections 2048;
}

http {
    # 限流配置
    limit_req_zone $binary_remote_addr zone=api_limit:10m rate=100r/s;
    limit_conn_zone $binary_remote_addr zone=conn_limit:10m;

    # 负载均衡
    upstream user_service {
        least_conn;
        server user-service-1:8001;
        server user-service-2:8002;
        server user-service-3:8003;
    }

    upstream order_service {
        least_conn;
        server order-service-1:8001;
        server order-service-2:8002;
    }

    upstream product_service {
        least_conn;
        server product-service-1:8001;
        server product-service-2:8002;
    }

    upstream payment_service {
        least_conn;
        server payment-service-1:8001;
    }

    server {
        listen 80;
        server_name api.example.com;

        # 用户服务
        location /api/users {
            limit_req zone=api_limit burst=200 nodelay;
            limit_conn conn_limit 10;

            proxy_pass http://user_service;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Service-Name "user-service";

            # 超时配置
            proxy_connect_timeout 30s;
            proxy_send_timeout 30s;
            proxy_read_timeout 30s;
        }

        # 订单服务
        location /api/orders {
            limit_req zone=api_limit burst=100 nodelay;

            proxy_pass http://order_service;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Service-Name "order-service";
        }

        # 商品服务
        location /api/products {
            limit_req zone=api_limit burst=200 nodelay;

            proxy_pass http://product_service;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Service-Name "product-service";
        }

        # 支付服务
        location /api/payments {
            limit_req zone=api_limit burst=50 nodelay;

            proxy_pass http://payment_service;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Service-Name "payment-service";
        }

        # 健康检查
        location /health {
            access_log off;
            return 200 "OK\n";
            add_header Content-Type text/plain;
        }

        # 日志格式
        access_log /var/log/nginx/access.log combined;
        error_log /var/log/nginx/error.log warn;
    }
}

2. 用户服务

services/user-service/Dockerfile

FROM python:3.11-slim

WORKDIR /app

# 安装依赖
RUN apt-get update && \
    apt-get install -y --no-install-recommends \
    gcc \
    default-libmysqlclient-dev \
    pkg-config \
    && rm -rf /var/lib/apt/lists/*

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

# 创建用户
RUN groupadd -r appuser && useradd -r -g appuser appuser
RUN chown -R appuser:appuser /app
USER appuser

ENV PYTHONUNBUFFERED=1
ENV SERVICE_NAME=user-service

EXPOSE 8001

CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:8001", "app:app"]

services/user-service/app.py

from flask import Flask, jsonify, request
from flask_cors import CORS
import mysql.connector
import redis
import os

app = Flask(__name__)
CORS(app)

# 配置
db_config = {
    'host': os.getenv('DB_HOST', 'mysql-master'),
    'user': os.getenv('DB_USER', 'root'),
    'password': os.getenv('DB_PASSWORD', '123456'),
    'database': os.getenv('DB_NAME', 'users_db')
}

redis_config = {
    'host': os.getenv('REDIS_HOST', 'redis'),
    'port': int(os.getenv('REDIS_PORT', 6379)),
    'db': 0
}

@app.route('/health')
def health():
    return jsonify({'status': 'healthy', 'service': 'user-service'})

@app.route('/users', methods=['GET'])
def get_users():
    try:
        # Redis缓存
        r = redis.Redis(**redis_config)
        cached = r.get('users')
        if cached:
            return jsonify({'source': 'cache', 'data': eval(cached)})

        # 数据库查询
        conn = mysql.connector.connect(**db_config)
        cursor = conn.cursor(dictionary=True)
        cursor.execute("SELECT id, username, email FROM users")
        users = cursor.fetchall()
        cursor.close()
        conn.close()

        # 写入缓存
        r.setex('users', 300, str(users))

        return jsonify({'source': 'database', 'data': users})
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/users/<int:user_id>', methods=['GET'])
def get_user(user_id):
    try:
        r = redis.Redis(**redis_config)
        cache_key = f'user:{user_id}'
        cached = r.get(cache_key)

        if cached:
            return jsonify({'source': 'cache', 'data': eval(cached)})

        conn = mysql.connector.connect(**db_config)
        cursor = conn.cursor(dictionary=True)
        cursor.execute("SELECT * FROM users WHERE id = %s", (user_id,))
        user = cursor.fetchone()
        cursor.close()
        conn.close()

        if not user:
            return jsonify({'error': 'User not found'}), 404

        r.setex(cache_key, 3600, str(user))

        return jsonify(user)
    except Exception as e:
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8001)

3. 订单服务

services/order-service/app.py

from flask import Flask, jsonify, request
import pika
import mysql.connector
import json
import os

app = Flask(__name__)

# 配置
db_config = {
    'host': os.getenv('DB_HOST', 'mysql-master'),
    'user': os.getenv('DB_USER', 'root'),
    'password': os.getenv('DB_PASSWORD', '123456'),
    'database': 'orders_db'
}

# RabbitMQ连接
rabbitmq_config = {
    'host': os.getenv('RABBITMQ_HOST', 'rabbitmq'),
    'port': int(os.getenv('RABBITMQ_PORT', 5672)),
    'user': os.getenv('RABBITMQ_USER', 'guest'),
    'password': os.getenv('RABBITMQ_PASSWORD', 'guest')
}

def send_to_queue(message):
    """发送消息到队列"""
    connection = pika.BlockingConnection(
        pika.ConnectionParameters(**rabbitmq_config)
    )
    channel = connection.channel()
    channel.queue_declare(queue='order_events', durable=True)
    channel.basic_publish(
        exchange='',
        routing_key='order_events',
        body=json.dumps(message),
        properties=pika.BasicProperties(delivery_mode=2)
    )
    connection.close()

@app.route('/health')
def health():
    return jsonify({'status': 'healthy', 'service': 'order-service'})

@app.route('/orders', methods=['GET'])
def get_orders():
    try:
        conn = mysql.connector.connect(**db_config)
        cursor = conn.cursor(dictionary=True)
        cursor.execute("SELECT * FROM orders ORDER BY created_at DESC LIMIT 100")
        orders = cursor.fetchall()
        cursor.close()
        conn.close()

        return jsonify(orders)
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/orders', methods=['POST'])
def create_order():
    try:
        data = request.json
        user_id = data.get('user_id')
        product_id = data.get('product_id')
        quantity = data.get('quantity', 1)

        # 创建订单
        conn = mysql.connector.connect(**db_config)
        cursor = conn.cursor()
        cursor.execute(
            "INSERT INTO orders (user_id, product_id, quantity, status) VALUES (%s, %s, %s, %s)",
            (user_id, product_id, quantity, 'pending')
        )
        conn.commit()
        order_id = cursor.lastrowid
        cursor.close()
        conn.close()

        # 发送消息到队列
        message = {
            'event': 'order_created',
            'order_id': order_id,
            'user_id': user_id,
            'product_id': product_id,
            'quantity': quantity
        }
        send_to_queue(message)

        return jsonify({'order_id': order_id, 'status': 'pending'}), 201
    except Exception as e:
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8001)

4. 商品服务

services/product-service/app.py

from flask import Flask, jsonify
import mysql.connector
import os

app = Flask(__name__)

db_config = {
    'host': os.getenv('DB_HOST', 'mysql-master'),
    'user': os.getenv('DB_USER', 'root'),
    'password': os.getenv('DB_PASSWORD', '123456'),
    'database': 'products_db'
}

@app.route('/health')
def health():
    return jsonify({'status': 'healthy', 'service': 'product-service'})

@app.route('/products', methods=['GET'])
def get_products():
    try:
        conn = mysql.connector.connect(**db_config)
        cursor = conn.cursor(dictionary=True)
        cursor.execute("SELECT * FROM products WHERE status = 'active'")
        products = cursor.fetchall()
        cursor.close()
        conn.close()

        return jsonify(products)
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/products/<int:product_id>', methods=['GET'])
def get_product(product_id):
    try:
        conn = mysql.connector.connect(**db_config)
        cursor = conn.cursor(dictionary=True)
        cursor.execute("SELECT * FROM products WHERE id = %s", (product_id,))
        product = cursor.fetchone()
        cursor.close()
        conn.close()

        if not product:
            return jsonify({'error': 'Product not found'}), 404

        return jsonify(product)
    except Exception as e:
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8001)

5. Docker Compose编排

docker-compose.yml

version: '3.8'

services:
  # API网关
  gateway:
    image: nginx:alpine
    container_name: api-gateway
    ports:
      - "80:80"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf
      - nginx-logs:/var/log/nginx
    depends_on:
      - user-service-1
      - user-service-2
      - user-service-3
      - order-service-1
      - order-service-2
      - product-service-1
      - product-service-2
    networks:
      - microservices
    restart: unless-stopped

  # 用户服务（3个实例）
  user-service-1:
    build:
      context: ./services/user-service
      dockerfile: Dockerfile
    container_name: user-service-1
    ports:
      - "8001:8001"
    environment:
      - DB_HOST=mysql-master
      - DB_PASSWORD=123456
      - DB_NAME=users_db
      - REDIS_HOST=redis
      - INSTANCE_ID=1
    depends_on:
      - mysql-master
      - redis
    networks:
      - microservices
    restart: unless-stopped

  user-service-2:
    build:
      context: ./services/user-service
      dockerfile: Dockerfile
    container_name: user-service-2
    ports:
      - "8002:8001"
    environment:
      - DB_HOST=mysql-master
      - DB_PASSWORD=123456
      - DB_NAME=users_db
      - REDIS_HOST=redis
      - INSTANCE_ID=2
    depends_on:
      - mysql-master
      - redis
    networks:
      - microservices
    restart: unless-stopped

  user-service-3:
    build:
      context: ./services/user-service
      dockerfile: Dockerfile
    container_name: user-service-3
    ports:
      - "8003:8001"
    environment:
      - DB_HOST=mysql-master
      - DB_PASSWORD=123456
      - DB_NAME=users_db
      - REDIS_HOST=redis
      - INSTANCE_ID=3
    depends_on:
      - mysql-master
      - redis
    networks:
      - microservices
    restart: unless-stopped

  # 订单服务（2个实例）
  order-service-1:
    build:
      context: ./services/order-service
      dockerfile: Dockerfile
    container_name: order-service-1
    ports:
      - "8011:8001"
    environment:
      - DB_HOST=mysql-master
      - DB_PASSWORD=123456
      - DB_NAME=orders_db
      - RABBITMQ_HOST=rabbitmq
    depends_on:
      - mysql-master
      - rabbitmq
    networks:
      - microservices
    restart: unless-stopped

  order-service-2:
    build:
      context: ./services/order-service
      dockerfile: Dockerfile
    container_name: order-service-2
    ports:
      - "8012:8001"
    environment:
      - DB_HOST=mysql-master
      - DB_PASSWORD=123456
      - DB_NAME=orders_db
      - RABBITMQ_HOST=rabbitmq
    depends_on:
      - mysql-master
      - rabbitmq
    networks:
      - microservices
    restart: unless-stopped

  # 商品服务（2个实例）
  product-service-1:
    build:
      context: ./services/product-service
      dockerfile: Dockerfile
    container_name: product-service-1
    ports:
      - "8021:8001"
    environment:
      - DB_HOST=mysql-master
      - DB_PASSWORD=123456
      - DB_NAME=products_db
    depends_on:
      - mysql-master
    networks:
      - microservices
    restart: unless-stopped

  product-service-2:
    build:
      context: ./services/product-service
      dockerfile: Dockerfile
    container_name: product-service-2
    ports:
      - "8022:8001"
    environment:
      - DB_HOST=mysql-master
      - DB_PASSWORD=123456
      - DB_NAME=products_db
    depends_on:
      - mysql-master
    networks:
      - microservices
    restart: unless-stopped

  # MySQL主库
  mysql-master:
    image: mysql:8.0
    container_name: mysql-master
    environment:
      MYSQL_ROOT_PASSWORD: 123456
    volumes:
      - mysql-master-data:/var/lib/mysql
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
    networks:
      - microservices
    restart: unless-stopped

  # MySQL从库
  mysql-slave:
    image: mysql:8.0
    container_name: mysql-slave
    environment:
      MYSQL_ROOT_PASSWORD: 123456
    networks:
      - microservices
    restart: unless-stopped

  # Redis集群
  redis:
    image: redis:7-alpine
    container_name: redis-cache
    command: redis-server --appendonly yes
    volumes:
      - redis-data:/data
    ports:
      - "6379:6379"
    networks:
      - microservices
    restart: unless-stopped

  # RabbitMQ消息队列
  rabbitmq:
    image: rabbitmq:3-management
    container_name: rabbitmq
    ports:
      - "5672:5672"
      - "15672:15672"
    volumes:
      - rabbitmq-data:/var/lib/rabbitmq
    networks:
      - microservices
    restart: unless-stopped

networks:
  microservices:
    driver: bridge

volumes:
  mysql-master-data:
  redis-data:
  rabbitmq-data:
  nginx-logs:

6. 服务发现和负载均衡

技术原理

1. 负载均衡策略

13-Docker进阶-镜像优化与最佳实践

Sat, 21 Feb 2026 00:00:00 +0000

Docker进阶技巧

前面我们已经学习了Docker的基础知识和实战项目，今天我们深入探讨镜像优化、安全加固、性能调优等高级话题。

1. 镜像体积优化

多阶段构建

问题：传统构建方式镜像体积大（包含构建工具）

# 不好：镜像包含gcc、make等构建工具
FROM python:3.11
RUN apt-get update && apt-get install -y gcc
COPY . .
RUN pip install -r requirements.txt
CMD ["python", "app.py"]
# 镜像大小：900MB

解决方案：多阶段构建

# 好：分离构建和运行环境
FROM python:3.11-slim AS builder
RUN apt-get update && apt-get install -y gcc
COPY requirements.txt .
RUN pip install --user -r requirements.txt

FROM python:3.11-slim
COPY --from=builder /root/.local /root/.local
COPY . .
ENV PATH=/root/.local/bin:$PATH
CMD ["python", "app.py"]
# 镜像大小：150MB

使用alpine基础镜像

对比：

python:3.11：900MB（完整版）
python:3.11-slim：120MB（瘦身版）
python:3.11-alpine：50MB（Alpine版）

# 使用alpine
FROM python:3.11-alpine

# 注意：alpine使用musl libc，某些C扩展可能不兼容
# 如果遇到兼容性问题，用slim版本

合并RUN指令

不好：

RUN apt-get update
RUN apt-get install -y curl
RUN apt-get install -y wget
RUN apt-get clean
# 创建4层，每层都有缓存

好：

RUN apt-get update && \
    apt-get install -y curl wget && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*
# 只创建1层

清理缓存

# Python：使用--no-cache-dir
RUN pip install --no-cache-dir -r requirements.txt

# apt：清理apt缓存
RUN apt-get update && \
    apt-get install -y curl && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*

# npm：清理npm缓存
RUN npm install && npm cache clean --force

利用构建缓存

原理：如果Dockerfile指令和文件没变化，Docker复用缓存。