Release v1.5.0: Restructure chapters and update for Docker v30.x

09_compose/README.md

@@ -0,0 +1,5 @@
+# Docker Compose 项目
+
+`Docker Compose` 是 Docker 官方编排（Orchestration）项目之一，负责快速的部署分布式应用。
+
+本章将介绍 `Compose` 项目情况以及安装和使用。

09_compose/commands.md

@@ -0,0 +1,319 @@
+# Compose 命令说明
+
+## 命令对象与格式
+
+对于 Compose 来说，大部分命令的对象既可以是项目本身，也可以指定为项目中的服务或者容器。如果没有特别的说明，命令对象将是项目，这意味着项目中所有的服务都会受到命令影响。
+
+执行 `docker compose [COMMAND] --help` 或者 `docker compose help [COMMAND]` 可以查看具体某个命令的使用格式。
+
+`docker compose` 命令的基本的使用格式是
+
+```bash
+docker compose [-f=<arg>...] [options] [COMMAND] [ARGS...]
+```
+
+## 命令选项
+
+* `-f, --file FILE` 指定使用的 Compose 模板文件，默认为 `docker-compose.yml`，可以多次指定。
+
+* `-p, --project-name NAME` 指定项目名称，默认将使用所在目录名称作为项目名。
+
+* `--verbose` 输出更多调试信息。
+
+* `-v, --version` 打印版本并退出。
+
+## 命令使用说明
+
+### `build`
+
+格式为 `docker compose build [options] [SERVICE...]`。
+
+构建（重新构建）项目中的服务容器。
+
+服务容器一旦构建后，将会带上一个标记名，例如对于 web 项目中的一个 db 容器，可能是 web_db。
+
+可以随时在项目目录下运行 `docker compose build` 来重新构建服务。
+
+选项包括：
+
+* `--force-rm` 删除构建过程中的临时容器。
+
+* `--no-cache` 构建镜像过程中不使用 cache（这将加长构建过程）。
+
+* `--pull` 始终尝试通过 pull 来获取更新版本的镜像。
+
+### `config`
+
+验证 Compose 文件格式是否正确，若正确则显示配置，若格式错误显示错误原因。
+
+### `down`
+
+此命令将会停止 `up` 命令所启动的容器，并移除网络
+
+### `exec`
+
+进入指定的容器。
+
+### `help`
+
+获得一个命令的帮助。
+
+### `images`
+
+列出 Compose 文件中包含的镜像。
+
+### `kill`
+
+格式为 `docker compose kill [options] [SERVICE...]`。
+
+通过发送 `SIGKILL` 信号来强制停止服务容器。
+
+支持通过 `-s` 参数来指定发送的信号，例如通过如下指令发送 `SIGINT` 信号。
+
+```bash
+$ docker compose kill -s SIGINT
+```
+
+### `logs`
+
+格式为 `docker compose logs [options] [SERVICE...]`。
+
+查看服务容器的输出。默认情况下，docker compose 将对不同的服务输出使用不同的颜色来区分。可以通过 `--no-color` 来关闭颜色。
+
+该命令在调试问题的时候十分有用。
+
+### `pause`
+
+格式为 `docker compose pause [SERVICE...]`。
+
+暂停一个服务容器。
+
+### `port`
+
+格式为 `docker compose port [options] SERVICE PRIVATE_PORT`。
+
+打印某个容器端口所映射的公共端口。
+
+选项：
+
+* `--protocol=proto` 指定端口协议，tcp（默认值）或者 udp。
+
+* `--index=index` 如果同一服务存在多个容器，指定命令对象容器的序号（默认为 1）。
+
+### `ps`
+
+格式为 `docker compose ps [options] [SERVICE...]`。
+
+列出项目中目前的所有容器。
+
+选项：
+
+* `-q` 只打印容器的 ID 信息。
+
+### `pull`
+
+格式为 `docker compose pull [options] [SERVICE...]`。
+
+拉取服务依赖的镜像。
+
+选项：
+
+* `--ignore-pull-failures` 忽略拉取镜像过程中的错误。
+
+### `push`
+
+推送服务依赖的镜像到 Docker 镜像仓库。
+
+### `restart`
+
+格式为 `docker compose restart [options] [SERVICE...]`。
+
+重启项目中的服务。
+
+选项：
+
+* `-t, --timeout TIMEOUT` 指定重启前停止容器的超时（默认为 10 秒）。
+
+### `rm`
+
+格式为 `docker compose rm [options] [SERVICE...]`。
+
+删除所有（停止状态的）服务容器。推荐先执行 `docker compose stop` 命令来停止容器。
+
+选项：
+
+* `-f, --force` 强制直接删除，包括非停止状态的容器。一般尽量不要使用该选项。
+
+* `-v` 删除容器所挂载的数据卷。
+
+### `run`
+格式为 `docker compose run [options] [-p PORT...] [-e KEY=VAL...] SERVICE [COMMAND] [ARGS...]`。
+
+在指定服务上执行一个命令。
+
+例如：
+
+```bash
+$ docker compose run ubuntu ping docker.com
+```
+
+将会启动一个 ubuntu 服务容器，并执行 `ping docker.com` 命令。
+
+默认情况下，如果存在关联，则所有关联的服务将会自动被启动，除非这些服务已经在运行中。
+
+该命令类似启动容器后运行指定的命令，相关卷、链接等等都将会按照配置自动创建。
+
+两个不同点：
+
+* 给定命令将会覆盖原有的自动运行命令；
+
+* 不会自动创建端口，以避免冲突。
+
+如果不希望自动启动关联的容器，可以使用 `--no-deps` 选项，例如
+
+```bash
+$ docker compose run --no-deps web python manage.py shell
+```
+
+将不会启动 web 容器所关联的其它容器。
+
+选项：
+
+* `-d` 后台运行容器。
+
+* `--name NAME` 为容器指定一个名字。
+
+* `--entrypoint CMD` 覆盖默认的容器启动指令。
+
+* `-e KEY=VAL` 设置环境变量值，可多次使用选项来设置多个环境变量。
+
+* `-u, --user=""` 指定运行容器的用户名或者 uid。
+
+* `--no-deps` 不自动启动关联的服务容器。
+
+* `--rm` 运行命令后自动删除容器，`d` 模式下将忽略。
+
+* `-p, --publish=[]` 映射容器端口到本地主机。
+
+* `--service-ports` 配置服务端口并映射到本地主机。
+
+* `-T` 不分配伪 tty，意味着依赖 tty 的指令将无法运行。
+
+### `scale`
+
+格式为 `docker compose scale [options] [SERVICE=NUM...]`。
+
+设置指定服务运行的容器个数。
+
+通过 `service=num` 的参数来设置数量。例如：
+
+```bash
+$ docker compose scale web=3 db=2
+```
+
+将启动 3 个容器运行 web 服务，2 个容器运行 db 服务。
+
+一般的，当指定数目多于该服务当前实际运行容器，将新创建并启动容器；反之，将停止容器。
+
+选项：
+
+* `-t, --timeout TIMEOUT` 停止容器时候的超时（默认为 10 秒）。
+
+### `start`
+
+格式为 `docker compose start [SERVICE...]`。
+
+启动已经存在的服务容器。
+
+### `stop`
+
+格式为 `docker compose stop [options] [SERVICE...]`。
+
+停止已经处于运行状态的容器，但不删除它。通过 `docker compose start` 可以再次启动这些容器。
+
+选项：
+
+* `-t, --timeout TIMEOUT` 停止容器时候的超时（默认为 10 秒）。
+
+### `top`
+
+查看各个服务容器内运行的进程。
+
+### `unpause`
+
+格式为 `docker compose unpause [SERVICE...]`。
+
+恢复处于暂停状态中的服务。
+
+### `up`
+
+格式为 `docker compose up [options] [SERVICE...]`。
+
+该命令十分强大，它将尝试自动完成包括构建镜像，（重新）创建服务，启动服务，并关联服务相关容器的一系列操作。
+
+链接的服务都将会被自动启动，除非已经处于运行状态。
+
+可以说，大部分时候都可以直接通过该命令来启动一个项目。
+
+默认情况，`docker compose up` 启动的容器都在前台，控制台将会同时打印所有容器的输出信息，可以很方便进行调试。
+
+当通过 `Ctrl-C` 停止命令时，所有容器将会停止。
+
+如果使用 `docker compose up -d`，将会在后台启动并运行所有的容器。一般推荐生产环境下使用该选项。
+
+默认情况，如果服务容器已经存在，`docker compose up` 将会尝试停止容器，然后重新创建（保持使用 `volumes-from` 挂载的卷），以保证新启动的服务匹配 `docker-compose.yml` 文件的最新内容。如果用户不希望容器被停止并重新创建，可以使用 `docker compose up --no-recreate`。这样将只会启动处于停止状态的容器，而忽略已经运行的服务。如果用户只想重新部署某个服务，可以使用 `docker compose up --no-deps -d <SERVICE_NAME>` 来重新创建服务并后台停止旧服务，启动新服务，并不会影响到其所依赖的服务。
+
+选项：
+
+* `-d` 在后台运行服务容器。
+
+* `--no-color` 不使用颜色来区分不同的服务的控制台输出。
+
+* `--no-deps` 不启动服务所链接的容器。
+
+* `--force-recreate` 强制重新创建容器，不能与 `--no-recreate` 同时使用。
+
+* `--no-recreate` 如果容器已经存在了，则不重新创建，不能与 `--force-recreate` 同时使用。
+
+* `--no-build` 不自动构建缺失的服务镜像。
+
+* `-t, --timeout TIMEOUT` 停止容器时候的超时（默认为 10 秒）。
+
+### `version`
+
+格式为 `docker compose version`。
+
+打印版本信息。
+
+### `watch`
+
+格式为 `docker compose watch [options] [SERVICE...]`。
+
+启用开发模式，自动监视源代码并在文件发生变化时刷新服务。这需要项目中有 `compose.yaml` (或 `docker-compose.yml`)，且定义了 `x-develop` 或 `develop` 配置段。
+
+例如：
+
+```yaml
+services:
+  web:
+    build: .
+    develop:
+      watch:
+        - action: sync
+          path: ./web
+          target: /src/web
+          ignore:
+            - node_modules/
+        - action: rebuild
+          path: package.json
+```
+
+选项：
+
+* `--no-up` 不自动启动服务。
+
+* `--quiet` 静默模式。
+
+## 参考资料
+
+* [官方文档](https://docs.docker.com/compose/reference/overview/)

09_compose/compose_file.md

@@ -0,0 +1,579 @@
+# Compose 模板文件
+
+模板文件是使用 `Compose` 的核心，涉及到的指令关键字也比较多。但大家不用担心，这里面大部分指令跟 `docker run` 相关参数的含义都是类似的。
+
+默认的模板文件名称为 `docker-compose.yml`，格式为 YAML 格式。
+
+```yaml
+
+
+services:
+  webapp:
+    image: examples/web
+    ports:
+      - "80:80"
+    volumes:
+      - "/data"
+```
+
+注意每个服务都必须通过 `image` 指令指定镜像或 `build` 指令（需要 Dockerfile）等来自动构建生成镜像。
+
+如果使用 `build` 指令，在 `Dockerfile` 中设置的选项(例如：`CMD`, `EXPOSE`, `VOLUME`, `ENV` 等) 将会自动被获取，无需在 `docker-compose.yml` 中重复设置。
+
+下面分别介绍各个指令的用法。
+
+## `build`
+
+指定 `Dockerfile` 所在文件夹的路径（可以是绝对路径，或者相对 docker-compose.yml 文件的路径）。 `Compose` 将会利用它自动构建这个镜像，然后使用这个镜像。
+
+```yaml
+
+services:
+
+  webapp:
+    build: ./dir
+```
+
+你也可以使用 `context` 指令指定 `Dockerfile` 所在文件夹的路径。
+
+使用 `dockerfile` 指令指定 `Dockerfile` 文件名。
+
+使用 `arg` 指令指定构建镜像时的变量。
+
+```yaml
+
+services:
+
+  webapp:
+    build:
+      context: ./dir
+      dockerfile: Dockerfile-alternate
+      args:
+        buildno: 1
+```
+
+使用 `cache_from` 指定构建镜像的缓存
+
+```yaml
+build:
+  context: .
+  cache_from:
+    - alpine:latest
+    - corp/web_app:3.14
+```
+
+## `cap_add, cap_drop`
+
+指定容器的内核能力（capacity）分配。
+
+例如，让容器拥有所有能力可以指定为：
+
+```yaml
+cap_add:
+  - ALL
+```
+
+去掉 NET_ADMIN 能力可以指定为：
+
+```yaml
+cap_drop:
+  - NET_ADMIN
+```
+
+## `command`
+
+覆盖容器启动后默认执行的命令。
+
+```yaml
+command: echo "hello world"
+```
+
+## `configs`
+
+仅用于 `Swarm mode`（已弃用，推荐使用 Kubernetes）。
+
+## `cgroup_parent`
+
+指定父 `cgroup` 组，意味着将继承该组的资源限制。
+
+例如，创建了一个 cgroup 组名称为 `cgroups_1`。
+
+```yaml
+cgroup_parent: cgroups_1
+```
+
+## `container_name`
+
+指定容器名称。默认将会使用 `项目名称_服务名称_序号` 这样的格式。
+
+```yaml
+container_name: docker-web-container
+```
+
+>注意: 指定容器名称后，该服务将无法进行扩展（scale），因为 Docker 不允许多个容器具有相同的名称。
+
+## `deploy`
+
+仅用于 `Swarm mode`（已弃用，推荐使用 Kubernetes）。
+
+## `devices`
+
+指定设备映射关系。
+
+```yaml
+devices:
+  - "/dev/ttyUSB1:/dev/ttyUSB0"
+```
+
+## `depends_on`
+
+解决容器的依赖、启动先后的问题。以下例子中会先启动 `redis` `db` 再启动 `web`
+
+```yaml
+
+
+services:
+  web:
+    build: .
+    depends_on:
+      - db
+      - redis
+
+  redis:
+    image: redis
+
+  db:
+    image: postgres
+```
+
+>注意：`web` 服务不会等待 `redis` `db` 「完全启动」之后才启动。
+
+## `dns`
+
+自定义 `DNS` 服务器。可以是一个值，也可以是一个列表。
+
+```yaml
+dns: 8.8.8.8
+
+dns:
+  - 8.8.8.8
+  - 114.114.114.114
+```
+
+## `dns_search`
+
+配置 `DNS` 搜索域。可以是一个值，也可以是一个列表。
+
+```yaml
+dns_search: example.com
+
+dns_search:
+  - domain1.example.com
+  - domain2.example.com
+```
+
+## `tmpfs`
+
+挂载一个 tmpfs 文件系统到容器。
+
+```yaml
+tmpfs: /run
+tmpfs:
+  - /run
+  - /tmp
+```
+
+## `env_file`
+
+从文件中获取环境变量，可以为单独的文件路径或列表。
+
+如果通过 `docker-compose -f FILE` 方式来指定 Compose 模板文件，则 `env_file` 中变量的路径会基于模板文件路径。
+
+如果有变量名称与 `environment` 指令冲突，则按照惯例，以后者为准。
+
+```bash
+env_file: .env
+
+env_file:
+  - ./common.env
+  - ./apps/web.env
+  - /opt/secrets.env
+```
+
+环境变量文件中每一行必须符合格式，支持 `#` 开头的注释行。
+
+```bash
+# common.env: Set development environment
+PROG_ENV=development
+```
+
+## `environment`
+
+设置环境变量。你可以使用数组或字典两种格式。
+
+只给定名称的变量会自动获取运行 Compose 主机上对应变量的值，可以用来防止泄露不必要的数据。
+
+```yaml
+environment:
+  RACK_ENV: development
+  SESSION_SECRET:
+
+environment:
+  - RACK_ENV=development
+  - SESSION_SECRET
+```
+
+如果变量名称或者值中用到 `true|false，yes|no` 等表达 [布尔](https://yaml.org/type/bool.html) 含义的词汇，最好放到引号里，避免 YAML 自动解析某些内容为对应的布尔语义。这些特定词汇，包括
+
+```bash
+y|Y|yes|Yes|YES|n|N|no|No|NO|true|True|TRUE|false|False|FALSE|on|On|ON|off|Off|OFF
+```
+
+## `expose`
+
+暴露端口，但不映射到宿主机，只被连接的服务访问。
+
+仅可以指定内部端口为参数
+
+```yaml
+expose:
+ - "3000"
+ - "8000"
+```
+
+## `external_links`
+
+>注意：不建议使用该指令。
+
+链接到 `docker-compose.yml` 外部的容器，甚至并非 `Compose` 管理的外部容器。
+
+```yaml
+external_links:
+ - redis_1
+ - project_db_1:mysql
+ - project_db_1:postgresql
+```
+
+## `extra_hosts`
+
+类似 Docker 中的 `--add-host` 参数，指定额外的 host 名称映射信息。
+
+```yaml
+extra_hosts:
+ - "googledns:8.8.8.8"
+ - "dockerhub:52.1.157.61"
+```
+
+会在启动后的服务容器中 `/etc/hosts` 文件中添加如下两条条目。
+
+```bash
+8.8.8.8 googledns
+52.1.157.61 dockerhub
+```
+
+## `healthcheck`
+
+通过命令检查容器是否健康运行。
+
+```yaml
+healthcheck:
+  test: ["CMD", "curl", "-f", "http://localhost"]
+  interval: 1m30s
+  timeout: 10s
+  retries: 3
+```
+
+## `image`
+
+指定为镜像名称或镜像 ID。如果镜像在本地不存在，`Compose` 将会尝试拉取这个镜像。
+
+```yaml
+image: ubuntu
+image: orchardup/postgresql
+image: a4bc65fd
+```
+
+## `labels`
+
+为容器添加 Docker 元数据（metadata）信息。例如可以为容器添加辅助说明信息。
+
+```yaml
+labels:
+  com.startupteam.description: "webapp for a startup team"
+  com.startupteam.department: "devops department"
+  com.startupteam.release: "rc3 for v1.0"
+```
+
+## `links`
+
+>注意：不推荐使用该指令。容器之间应通过 Docker 网络（networks）进行互联。
+
+## `logging`
+
+配置日志选项。
+
+```yaml
+logging:
+  driver: syslog
+  options:
+    syslog-address: "tcp://192.168.0.42:123"
+```
+
+目前支持三种日志驱动类型。
+
+```yaml
+driver: "json-file"
+driver: "syslog"
+driver: "none"
+```
+
+`options` 配置日志驱动的相关参数。
+
+```yaml
+options:
+  max-size: "200k"
+  max-file: "10"
+```
+
+## `network_mode`
+
+设置网络模式。使用和 `docker run` 的 `--network` 参数一样的值。
+
+```yaml
+network_mode: "bridge"
+network_mode: "host"
+network_mode: "none"
+network_mode: "service:[service name]"
+network_mode: "container:[container name/id]"
+```
+
+## `networks`
+
+配置容器连接的网络。
+
+```yaml
+
+services:
+
+  some-service:
+    networks:
+     - some-network
+     - other-network
+
+networks:
+  some-network:
+  other-network:
+```
+
+## `pid`
+
+跟主机系统共享进程命名空间。打开该选项的容器之间，以及容器和宿主机系统之间可以通过进程 ID 来相互访问和操作。
+
+```yaml
+pid: "host"
+```
+
+## `ports`
+
+暴露端口信息。
+
+使用宿主端口：容器端口 `(HOST:CONTAINER)` 格式，或者仅仅指定容器的端口（宿主将会随机选择端口）都可以。
+
+```yaml
+ports:
+ - "3000"
+ - "8000:8000"
+ - "49100:22"
+ - "127.0.0.1:8001:8001"
+```
+
+*注意：当使用 `HOST:CONTAINER` 格式来映射端口时，如果你使用的容器端口小于 60 并且没放到引号里，可能会得到错误结果，因为 `YAML` 会自动解析 `xx:yy` 这种数字格式为 60 进制。为避免出现这种问题，建议数字串都采用引号包括起来的字符串格式。*
+
+## `secrets`
+
+存储敏感数据，例如 `mysql` 服务密码。
+
+```yaml
+
+services:
+
+mysql:
+  image: mysql
+  environment:
+    MYSQL_ROOT_PASSWORD_FILE: /run/secrets/db_root_password
+  secrets:
+    - db_root_password
+    - my_other_secret
+
+secrets:
+  my_secret:
+    file: ./my_secret.txt
+  my_other_secret:
+    external: true
+```
+
+## `security_opt`
+
+指定容器模板标签（label）机制的默认属性（用户、角色、类型、级别等）。例如配置标签的用户名和角色名。
+
+```yaml
+security_opt:
+    - label:user:USER
+    - label:role:ROLE
+```
+
+## `stop_signal`
+
+设置另一个信号来停止容器。在默认情况下使用的是 SIGTERM 停止容器。
+
+```yaml
+stop_signal: SIGUSR1
+```
+
+## `sysctls`
+
+配置容器内核参数。
+
+```yaml
+sysctls:
+  net.core.somaxconn: 1024
+  net.ipv4.tcp_syncookies: 0
+
+sysctls:
+  - net.core.somaxconn=1024
+  - net.ipv4.tcp_syncookies=0
+```
+
+## `ulimits`
+
+指定容器的 ulimits 限制值。
+
+例如，指定最大进程数为 65535，指定文件句柄数为 20000（软限制，应用可以随时修改，不能超过硬限制） 和 40000（系统硬限制，只能 root 用户提高）。
+
+```yaml
+  ulimits:
+    nproc: 65535
+    nofile:
+      soft: 20000
+      hard: 40000
+```
+
+## `volumes`
+
+数据卷所挂载路径设置。可以设置为宿主机路径(`HOST:CONTAINER`)或者数据卷名称(`VOLUME:CONTAINER`)，并且可以设置访问模式 （`HOST:CONTAINER:ro`）。
+
+该指令中路径支持相对路径。
+
+```yaml
+volumes:
+ - /var/lib/mysql
+ - cache/:/tmp/cache
+ - ~/configs:/etc/configs/:ro
+```
+
+如果路径为数据卷名称，必须在文件中配置数据卷。
+
+```yaml
+
+
+services:
+  my_src:
+    image: mysql:8.0
+    volumes:
+      - mysql_data:/var/lib/mysql
+
+volumes:
+  mysql_data:  
+```
+
+## 其它指令
+
+此外，还有包括 `domainname, entrypoint, hostname, ipc, mac_address, privileged, read_only, shm_size, restart, stdin_open, tty, user, working_dir` 等指令，基本跟 `docker run` 中对应参数的功能一致。
+
+指定服务容器启动后执行的入口文件。
+
+```yaml
+entrypoint: /code/entrypoint.sh
+```
+
+指定容器中运行应用的用户名。
+
+```yaml
+user: nginx
+```
+
+指定容器中工作目录。
+
+```yaml
+working_dir: /code
+```
+
+指定容器中搜索域名、主机名、mac 地址等。
+
+```yaml
+domainname: your_website.com
+hostname: test
+mac_address: 08-00-27-00-0C-0A
+```
+
+允许容器中运行一些特权命令。
+
+```yaml
+privileged: true
+```
+
+指定容器退出后的重启策略为始终重启。该命令对保持服务始终运行十分有效，在生产环境中推荐配置为 `always` 或者 `unless-stopped`。
+
+```yaml
+restart: always
+```
+
+以只读模式挂载容器的 root 文件系统，意味着不能对容器内容进行修改。
+
+```yaml
+read_only: true
+```
+
+打开标准输入，可以接受外部输入。
+
+```yaml
+stdin_open: true
+```
+
+模拟一个伪终端。
+
+```yaml
+tty: true
+```
+
+## 读取变量
+
+Compose 模板文件支持动态读取主机的系统环境变量和当前目录下的 `.env` 文件中的变量。
+
+例如，下面的 Compose 文件将从运行它的环境中读取变量 `${MONGO_VERSION}` 的值，并写入执行的指令中。
+
+```yaml
+
+services:
+
+db:
+  image: "mongo:${MONGO_VERSION}"
+```
+
+如果执行 `MONGO_VERSION=3.2 docker-compose up` 则会启动一个 `mongo:3.2` 镜像的容器；如果执行 `MONGO_VERSION=2.8 docker-compose up` 则会启动一个 `mongo:2.8` 镜像的容器。
+
+若当前目录存在 `.env` 文件，执行 `docker-compose` 命令时将从该文件中读取变量。
+
+在当前目录新建 `.env` 文件并写入以下内容。
+
+```bash
+# 支持 # 号注释
+MONGO_VERSION=3.6
+```
+
+执行 `docker-compose up` 则会启动一个 `mongo:3.6` 镜像的容器。
+
+## 参考资料
+
+* [官方文档](https://docs.docker.com/compose/compose-file/)
+* [awesome-compose](https://github.com/docker/awesome-compose)

09_compose/demo/app/Dockerfile

@@ -0,0 +1,5 @@
+FROM python:3.12-alpine
+ADD . /code
+WORKDIR /code
+RUN pip install redis flask
+CMD ["python", "app.py"]

09_compose/demo/app/app.py

@@ -0,0 +1,13 @@
+from flask import Flask
+from redis import Redis
+
+app = Flask(__name__)
+redis = Redis(host='redis', port=6379)
+
+@app.route('/')
+def hello():
+    count = redis.incr('hits')
+    return 'Hello World! 该页面已被访问 {} 次。\n'.format(count)
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", debug=True)

09_compose/demo/app/docker-compose.yml

@@ -0,0 +1,10 @@
+
+services:
+
+  web:
+    build: .
+    ports:
+     - "5000:5000"
+
+  redis:
+    image: "redis:alpine"

09_compose/demo/django/.gitignore

@@ -0,0 +1,2 @@
+django_example
+manage.py

09_compose/demo/django/Dockerfile

@@ -0,0 +1,7 @@
+FROM python:3
+ENV PYTHONUNBUFFERED 1
+RUN mkdir /code
+WORKDIR /code
+ADD requirements.txt /code/
+RUN pip install -r requirements.txt
+ADD . /code/

09_compose/demo/django/docker-compose.yml

@@ -0,0 +1,15 @@
+
+services:
+
+  db:
+    image: postgres
+    environment:
+      POSTGRES_PASSWORD: 'postgres'
+
+  web:
+    build: .
+    command: python manage.py runserver 0.0.0.0:8000
+    volumes:
+      - .:/code
+    ports:
+      - "8000:8000"

09_compose/demo/django/requirements.txt

@@ -0,0 +1,2 @@
+Django>=5.0.6,<6.0
+psycopg2>=2.7,<3.0

09_compose/demo/wordpress/docker-compose.yml

@@ -0,0 +1,31 @@
+
+services:
+
+   db:
+     image: mysql:8.0
+     command:
+      - --default_authentication_plugin=mysql_native_password
+      - --character-set-server=utf8mb4
+      - --collation-server=utf8mb4_unicode_ci
+     volumes:
+       - db_data:/var/lib/mysql
+     restart: always
+     environment:
+       MYSQL_ROOT_PASSWORD: somewordpress
+       MYSQL_DATABASE: wordpress
+       MYSQL_USER: wordpress
+       MYSQL_PASSWORD: wordpress
+
+   wordpress:
+     depends_on:
+       - db
+     image: wordpress:latest
+     ports:
+       - "8000:80"
+     restart: always
+     environment:
+       WORDPRESS_DB_HOST: db:3306
+       WORDPRESS_DB_USER: wordpress
+       WORDPRESS_DB_PASSWORD: wordpress
+volumes:
+  db_data:

09_compose/django.md

@@ -0,0 +1,339 @@
+# 使用 Django
+
+> 本小节内容适合 `Python` 开发人员阅读。
+
+本节将使用 Docker Compose 配置并运行一个 **Django + PostgreSQL** 应用。笔者不仅会介绍具体步骤，还会解释每个配置项的作用，以及开发环境和生产环境的差异。
+
+## 架构概览
+
+在开始之前，让我们先理解我们要构建的架构：
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                     Docker Compose 网络                     │
+│                                                             │
+│  ┌─────────────────────┐      ┌─────────────────────┐       │
+│  │     web 服务         │      │      db 服务        │       │
+│  │  ┌───────────────┐  │      │  ┌───────────────┐  │       │
+│  │  │   Django      │  │──────│  │  PostgreSQL   │  │       │
+│  │  │   应用        │  │ :5432│  │   数据库      │  │       │
+│  │  └───────────────┘  │      │  └───────────────┘  │       │
+│  │       :8000         │      │                     │       │
+│  └──────────┬──────────┘      └─────────────────────┘       │
+│             │                                               │
+└─────────────┼───────────────────────────────────────────────┘
+              │
+              ▼
+         localhost:8000
+         （浏览器访问）
+```
+
+**关键点**：
+- `web` 服务运行 Django 应用，对外暴露 8000 端口
+- `db` 服务运行 PostgreSQL 数据库，只在内部网络可访问
+- 两个服务通过 Docker Compose 自动创建的网络相互通信
+- `web` 服务可以通过服务名 `db` 访问数据库（Docker 内置 DNS）
+
+## 准备工作
+
+创建一个项目目录并进入：
+
+```bash
+$ mkdir django-docker && cd django-docker
+```
+
+我们需要创建三个文件：`Dockerfile`、`requirements.txt` 和 `docker-compose.yml`。
+
+## Step 1: 创建 Dockerfile
+
+```docker
+FROM python:3.12-slim
+
+# 防止 Python 缓冲 stdout/stderr，让日志实时输出
+ENV PYTHONUNBUFFERED=1
+
+# 设置工作目录
+WORKDIR /code
+
+# 先复制依赖文件，利用 Docker 缓存加速构建
+COPY requirements.txt /code/
+
+# 安装依赖
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 复制项目代码
+COPY . /code/
+```
+
+**逐行解释**：
+
+| 指令 | 作用 | 为什么这样写 |
+|------|------|-------------|
+| `FROM python:3.12-slim` | 基础镜像 | `slim` 版本比完整版小很多，但包含运行 Python 所需的一切 |
+| `ENV PYTHONUNBUFFERED=1` | 关闭输出缓冲 | 让 `print()` 和日志立即显示，便于调试 |
+| `WORKDIR /code` | 设置工作目录 | 后续命令都在此目录执行 |
+| `COPY requirements.txt` 在前 | 分层复制 | 只有 requirements.txt 变化时才重新安装依赖，加速构建 |
+| `--no-cache-dir` | 不缓存 pip 下载 | 减小镜像体积 |
+
+> 💡 **笔者建议**：总是将变化频率低的文件先复制，变化频率高的后复制。这样可以最大化利用 Docker 的构建缓存。
+
+## Step 2: 创建 requirements.txt
+
+```txt
+Django>=5.0,<6.0
+psycopg[binary]>=3.1,<4.0
+gunicorn>=21.0,<22.0
+```
+
+**依赖说明**：
+
+| 包名 | 作用 |
+|------|------|
+| `Django` | Web 框架 |
+| `psycopg[binary]` | PostgreSQL 数据库驱动（推荐使用 psycopg 3） |
+| `gunicorn` | 生产环境 WSGI 服务器（可选，开发时可不用） |
+
+## Step 3: 创建 docker-compose.yml
+
+```yaml
+services:
+  db:
+    image: postgres:16
+    environment:
+      POSTGRES_DB: django_db
+      POSTGRES_USER: django_user
+      POSTGRES_PASSWORD: django_password
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U django_user -d django_db"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+
+  web:
+    build: .
+    command: python manage.py runserver 0.0.0.0:8000
+    volumes:
+      - .:/code
+    ports:
+      - "8000:8000"
+    depends_on:
+      db:
+        condition: service_healthy
+    environment:
+      DATABASE_URL: postgres://django_user:django_password@db:5432/django_db
+
+volumes:
+  postgres_data:
+```
+
+**配置详解**：
+
+### db 服务
+
+```yaml
+db:
+  image: postgres:16                    # 使用官方 PostgreSQL 16 镜像
+  environment:
+    POSTGRES_DB: django_db              # 创建的数据库名
+    POSTGRES_USER: django_user          # 数据库用户
+    POSTGRES_PASSWORD: django_password  # 数据库密码
+  volumes:
+    - postgres_data:/var/lib/postgresql/data  # 持久化数据
+  healthcheck:                          # 健康检查，确保数据库就绪
+    test: ["CMD-SHELL", "pg_isready -U django_user -d django_db"]
+    interval: 5s
+```
+
+> ⚠️ **笔者提醒**：`volumes` 配置很重要！没有它，每次容器重启数据都会丢失。笔者见过不少新手因为忘记这一步，导致开发数据全部丢失。
+
+### web 服务
+
+```yaml
+web:
+  build: .                              # 从当前目录的 Dockerfile 构建
+  command: python manage.py runserver   # 启动 Django 开发服务器
+  volumes:
+    - .:/code                           # 挂载代码目录，支持热更新
+  ports:
+    - "8000:8000"                       # 映射端口
+  depends_on:
+    db:
+      condition: service_healthy        # 等待数据库健康后再启动
+```
+
+**关键配置说明**：
+
+| 配置项 | 作用 | 笔者建议 |
+|--------|------|---------|
+| `volumes: .:/code` | 代码挂载 | 开发时必备，修改代码无需重新构建镜像 |
+| `depends_on` + `healthcheck` | 启动顺序 | 确保数据库就绪后 Django 才启动，避免连接错误 |
+| `environment` | 环境变量 | 推荐用环境变量管理配置，避免硬编码 |
+
+## Step 4: 创建 Django 项目
+
+运行以下命令创建新的 Django 项目：
+
+```bash
+$ docker compose run --rm web django-admin startproject mysite .
+```
+
+**命令解释**：
+- `docker compose run`：运行一次性命令
+- `--rm`：命令执行后删除临时容器
+- `web`：在 web 服务环境中执行
+- `django-admin startproject mysite .`：在当前目录创建 Django 项目
+
+生成的目录结构：
+
+```
+django-docker/
+├── docker-compose.yml
+├── Dockerfile
+├── requirements.txt
+├── manage.py
+└── mysite/
+    ├── __init__.py
+    ├── settings.py
+    ├── urls.py
+    ├── asgi.py
+    └── wsgi.py
+```
+
+> 💡 **Linux 用户注意**：如果遇到权限问题，执行 `sudo chown -R $USER:$USER .`
+
+## Step 5: 配置数据库连接
+
+修改 `mysite/settings.py`，配置数据库连接：
+
+```python
+import os
+
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.db.backends.postgresql',
+        'NAME': os.environ.get('POSTGRES_DB', 'django_db'),
+        'USER': os.environ.get('POSTGRES_USER', 'django_user'),
+        'PASSWORD': os.environ.get('POSTGRES_PASSWORD', 'django_password'),
+        'HOST': 'db',  # Docker Compose 服务名
+        'PORT': 5432,
+    }
+}
+
+# 允许的主机（开发环境）
+ALLOWED_HOSTS = ['*']
+```
+
+**为什么 HOST 是 `db` 而不是 `localhost`？**
+
+在 Docker Compose 中，各服务通过服务名相互访问。Docker 内置的 DNS 会将 `db` 解析为 db 服务容器的 IP 地址。这是 Docker Compose 的核心功能之一。
+
+## Step 6: 启动应用
+
+```bash
+$ docker compose up
+```
+
+你会看到：
+1. 首先构建 web 镜像（第一次运行）
+2. 启动 db 服务，等待健康检查通过
+3. 启动 web 服务
+
+```
+db-1   | PostgreSQL init process complete; ready for start up.
+db-1   | LOG:  database system is ready to accept connections
+web-1  | Watching for file changes with StatReloader
+web-1  | Starting development server at http://0.0.0.0:8000/
+```
+
+打开浏览器访问 http://localhost:8000，可以看到 Django 欢迎页面！
+
+## 常用开发命令
+
+在另一个终端窗口执行：
+
+```bash
+# 执行数据库迁移
+$ docker compose exec web python manage.py migrate
+
+# 创建超级用户
+$ docker compose exec web python manage.py createsuperuser
+
+# 进入 Django shell
+$ docker compose exec web python manage.py shell
+
+# 进入 PostgreSQL 命令行
+$ docker compose exec db psql -U django_user -d django_db
+```
+
+> 💡 笔者建议使用 `exec` 而不是 `run`。`exec` 在已运行的容器中执行命令，`run` 会创建新容器。
+
+## 常见问题排查
+
+### Q1: 数据库连接失败
+
+**错误信息**：`django.db.utils.OperationalError: could not connect to server`
+
+**可能原因与解决方案**：
+
+| 原因 | 解决方案 |
+|------|---------|
+| 数据库还没启动完成 | 使用 `depends_on` + `healthcheck` |
+| HOST 配置错误 | 确保使用服务名 `db` 而不是 `localhost` |
+| 网络未创建 | 运行 `docker compose down` 后重新 `up` |
+
+```bash
+# 调试：检查数据库是否正常运行
+$ docker compose ps
+$ docker compose logs db
+```
+
+### Q2: 代码修改没有生效
+
+**可能原因**：
+
+1. **开发服务器没有自动重载**：确保使用 `runserver` 而不是 `gunicorn`
+2. **Volume 挂载问题**：检查 `docker-compose.yml` 中的 volumes 配置
+3. **缓存问题**：尝试 `docker compose restart web`
+
+### Q3: 权限问题（Linux）
+
+```bash
+# 如果容器内创建的文件 root 用户所有
+$ sudo chown -R $USER:$USER .
+```
+
+## 开发 vs 生产：关键差异
+
+笔者特别提醒，本节的配置是**开发环境**配置。生产环境需要以下调整：
+
+| 配置项 | 开发环境 | 生产环境 |
+|--------|---------|---------|
+| **Web 服务器** | `runserver` | `gunicorn` + Nginx |
+| **DEBUG** | `True` | `False` |
+| **密码管理** | 明文写在配置 | 使用 Docker Secrets 或环境变量 |
+| **Volume** | 挂载代码目录 | 代码直接 COPY 进镜像 |
+| **ALLOWED_HOSTS** | `['*']` | 具体域名 |
+
+**生产环境 docker-compose.yml 示例**：
+
+```yaml
+# docker-compose.prod.yml
+services:
+  web:
+    build: .
+    command: gunicorn mysite.wsgi:application --bind 0.0.0.0:8000
+    # 不挂载代码，使用镜像内的代码
+    environment:
+      DEBUG: 'False'
+      ALLOWED_HOSTS: 'example.com,www.example.com'
+    # ...
+```
+
+## 延伸阅读
+
+- [Compose 模板文件详解](compose_file.md)：深入理解 docker-compose.yml 的所有配置项
+- [使用 WordPress](wordpress.md)：另一个 Compose 实战案例
+- [Dockerfile 最佳实践](../15_appendix/best_practices.md)：构建更小、更安全的镜像
+- [数据管理](../07_data_network/README.md)：Volume 和数据持久化详解

09_compose/install.md

@@ -0,0 +1,54 @@
+# 安装与卸载
+
+`Compose` 是 Docker 官方的开源项目，负责实现对 Docker 容器集群的快速编排。
+
+从 `v2` 版本开始，`Compose` 作为 `docker` 的子命令存在，例如 `docker compose up`。
+
+`Compose` 支持 Linux、macOS、Windows 10 三大平台。
+
+`Docker Desktop for Mac/Windows` 自带 `docker compose` 命令。
+
+Linux 系统请使用以下介绍的方法安装。
+
+## Linux
+
+在 Linux 上，你可以通过下载 `docker-compose` 二进制包来安装。
+
+从 [官方 GitHub Release](https://github.com/docker/compose/releases) 处直接下载编译好的二进制文件即可。
+
+> **提示**：版本更新较快，请访问上述链接获取最新版本号，替换下方命令中的版本号。
+
+例如，在 Linux 64 位系统上直接下载对应的二进制包（以 v2.40.3 为例）。
+
+```bash
+$ DOCKER_CONFIG=${DOCKER_CONFIG:-$HOME/.docker}
+$ mkdir -p $DOCKER_CONFIG/cli-plugins
+$ curl -SL https://github.com/docker/compose/releases/download/v2.40.3/docker-compose-linux-x86_64 -o $DOCKER_CONFIG/cli-plugins/docker-compose
+```
+
+之后，执行
+
+```bash
+$ chmod +x $DOCKER_CONFIG/cli-plugins/docker-compose
+```
+
+## 测试安装
+
+```bash
+$ docker compose version
+Docker Compose version v2.40.3
+```
+
+## bash 补全命令
+
+```bash
+$ curl -L https://raw.githubusercontent.com/docker/compose/v2.40.3/contrib/completion/bash/docker-compose > /etc/bash_completion.d/docker-compose
+```
+
+## 卸载
+
+如果是二进制包方式安装的，删除二进制文件即可。
+
+```bash
+$ rm $DOCKER_CONFIG/cli-plugins/docker-compose
+```

09_compose/introduction.md

@@ -0,0 +1,33 @@
+# Compose 简介
+
+`Compose` 项目是 Docker 官方的开源项目，负责实现对 Docker 容器集群的快速编排。从功能上看，跟 `OpenStack` 中的 `Heat` 十分类似。
+
+其代码目前在 [https://github.com/docker/compose](https://github.com/docker/compose) 上开源。
+
+`Compose` 定位是 「定义和运行多个 Docker 容器的应用（Defining and running multi-container Docker applications）」，其前身是开源项目 Fig。
+
+通过第一部分中的介绍，我们知道使用一个 `Dockerfile` 模板文件，可以让用户很方便的定义一个单独的应用容器。然而，在日常工作中，经常会碰到需要多个容器相互配合来完成某项任务的情况。例如要实现一个 Web 项目，除了 Web 服务容器本身，往往还需要再加上后端的数据库服务容器，甚至还包括负载均衡容器等。
+
+`Compose` 恰好满足了这样的需求。它允许用户通过一个单独的 `docker-compose.yml` 模板文件（YAML 格式）来定义一组相关联的应用容器为一个项目（project）。
+
+## 模板文件规范
+
+Compose 模板文件采用 YAML 格式，扩展名为 `.yml` 或 `.yaml`。
+
+> **注意**：自 Compose V2 起，`version` 字段已不再强制要求。在 Docker Compose v5 中，规范已完全不需要顶层 `version` 字段。为了保持最佳兼容性，建议不在新文件中使用该字段。
+
+Docker Compose 默认使用 `docker-compose.yml` 作为模板文件。
+
+`Compose` 中有两个重要的概念：
+
+* 服务 (`service`)：一个应用的容器，实际上可以包括若干运行相同镜像的容器实例。
+
+* 项目 (`project`)：由一组关联的应用容器组成的一个完整业务单元，在 `docker-compose.yml` 文件中定义。
+
+`Compose` 的默认管理对象是项目，通过子命令对项目中的一组容器进行便捷地生命周期管理。
+
+`Compose` 项目早期由 Python 编写，称为 Docker Compose V1。
+
+现在的 Docker Compose V2 是一个 Go 语言编写的 Docker CLI 插件，已经集成到 Docker Desktop 和 Docker Engine 中，直接通过 `docker compose` 命令使用。它提供了更快的性能和更好的集成体验。
+
+只要所操作的平台支持 Docker API，就可以在其上利用 `Compose` 来进行编排管理。

09_compose/lnmp.md

@@ -0,0 +1,3 @@
+# 使用 compose 搭建 LNMP 环境
+
+本项目的维护者 [khs1994](https://github.com/khs1994) 的开源项目 [khs1994-docker/lnmp](https://github.com/khs1994-docker/lnmp) 使用 Docker Compose 搭建了一套 LNMP 环境，各位开发者可以参考该项目在 Docker 或 Kubernetes 中运行 LNMP。

09_compose/rails.md

@@ -0,0 +1,268 @@
+# 使用 Rails
+
+> 本小节内容适合 Ruby 开发人员阅读。
+
+本节使用 Docker Compose 配置并运行一个 **Rails + PostgreSQL** 应用。
+
+## 架构概览
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                     Docker Compose 网络                     │
+│                                                             │
+│  ┌─────────────────────┐      ┌─────────────────────┐       │
+│  │     web 服务         │      │      db 服务        │       │
+│  │  ┌───────────────┐  │      │  ┌───────────────┐  │       │
+│  │  │   Rails       │  │──────│  │  PostgreSQL   │  │       │
+│  │  │   应用        │  │ :5432│  │   数据库      │  │       │
+│  │  └───────────────┘  │      │  └───────────────┘  │       │
+│  │       :3000         │      │                     │       │
+│  └──────────┬──────────┘      └─────────────────────┘       │
+│             │                                               │
+└─────────────┼───────────────────────────────────────────────┘
+              │
+              ▼
+         localhost:3000
+```
+
+## 准备工作
+
+创建项目目录：
+
+```bash
+$ mkdir rails-docker && cd rails-docker
+```
+
+需要创建三个文件：`Dockerfile`、`Gemfile` 和 `docker-compose.yml`。
+
+## Step 1: 创建 Dockerfile
+
+```docker
+FROM ruby:3.2
+
+# 安装系统依赖
+RUN apt-get update -qq && \
+    apt-get install -y build-essential libpq-dev nodejs && \
+    rm -rf /var/lib/apt/lists/*
+
+# 设置工作目录
+WORKDIR /myapp
+
+# 先复制 Gemfile，利用缓存加速构建
+COPY Gemfile /myapp/Gemfile
+COPY Gemfile.lock /myapp/Gemfile.lock
+RUN bundle install
+
+# 复制应用代码
+COPY . /myapp
+```
+
+**配置说明**：
+
+| 指令 | 作用 |
+|------|------|
+| `build-essential` | 编译原生扩展所需 |
+| `libpq-dev` | PostgreSQL 客户端库 |
+| `nodejs` | Rails Asset Pipeline 需要 |
+| 先复制 Gemfile | 只有依赖变化时才重新 `bundle install` |
+
+## Step 2: 创建 Gemfile
+
+创建一个初始的 `Gemfile`，稍后会被 `rails new` 覆盖：
+
+```ruby
+source 'https://rubygems.org'
+gem 'rails', '~> 7.1'
+```
+
+创建空的 `Gemfile.lock`：
+
+```bash
+$ touch Gemfile.lock
+```
+
+## Step 3: 创建 docker-compose.yml
+
+```yaml
+services:
+  db:
+    image: postgres:16
+    environment:
+      POSTGRES_PASSWORD: password
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+
+  web:
+    build: .
+    command: bash -c "rm -f tmp/pids/server.pid && bundle exec rails s -p 3000 -b '0.0.0.0'"
+    volumes:
+      - .:/myapp
+    ports:
+      - "3000:3000"
+    depends_on:
+      - db
+    environment:
+      DATABASE_URL: postgres://postgres:password@db:5432/myapp_development
+
+volumes:
+  postgres_data:
+```
+
+**配置详解**：
+
+| 配置项 | 说明 |
+|--------|------|
+| `rm -f tmp/pids/server.pid` | 清理上次异常退出留下的 PID 文件 |
+| `volumes: .:/myapp` | 挂载代码目录，支持热更新 |
+| `depends_on: db` | 确保数据库先启动 |
+| `DATABASE_URL` | Rails 12-factor 风格的数据库配置 |
+
+## Step 4: 生成 Rails 项目
+
+使用 `docker compose run` 生成项目骨架：
+
+```bash
+$ docker compose run --rm web rails new . --force --database=postgresql --skip-bundle
+```
+
+**命令解释**：
+- `--rm`：执行后删除临时容器
+- `--force`：覆盖已存在的文件
+- `--database=postgresql`：配置使用 PostgreSQL
+- `--skip-bundle`：暂不安装依赖（稍后统一安装）
+
+生成的目录结构：
+
+```bash
+$ ls
+Dockerfile       Gemfile          Rakefile         config           lib              tmp
+Gemfile.lock     README.md        app              config.ru        log              vendor
+docker-compose.yml                bin              db               public
+```
+
+> ⚠️ **Linux 用户**：如遇权限问题，执行 `sudo chown -R $USER:$USER .`
+
+## Step 5: 重新构建镜像
+
+由于生成了新的 Gemfile，需要重新构建镜像以安装完整依赖：
+
+```bash
+$ docker compose build
+```
+
+## Step 6: 配置数据库连接
+
+修改 `config/database.yml`：
+
+```yaml
+default: &default
+  adapter: postgresql
+  encoding: unicode
+  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
+  url: <%= ENV['DATABASE_URL'] %>
+
+development:
+  <<: *default
+
+test:
+  <<: *default
+  database: myapp_test
+
+production:
+  <<: *default
+```
+
+> 💡 使用 `DATABASE_URL` 环境变量配置数据库，符合 12-factor 应用原则，便于在不同环境间切换。
+
+## Step 7: 启动应用
+
+```bash
+$ docker compose up
+```
+
+输出示例：
+
+```
+db-1   | PostgreSQL init process complete; ready for start up.
+db-1   | LOG:  database system is ready to accept connections
+web-1  | => Booting Puma
+web-1  | => Rails 7.1.0 application starting in development
+web-1  | => Run `bin/rails server --help` for more startup options
+web-1  | Puma starting in single mode...
+web-1  | * Listening on http://0.0.0.0:3000
+```
+
+## Step 8: 创建数据库
+
+在另一个终端执行：
+
+```bash
+$ docker compose exec web rails db:create
+Created database 'myapp_development'
+Created database 'myapp_test'
+```
+
+访问 http://localhost:3000 查看 Rails 欢迎页面。
+
+## 常用开发命令
+
+```bash
+# 数据库迁移
+$ docker compose exec web rails db:migrate
+
+# Rails 控制台
+$ docker compose exec web rails console
+
+# 运行测试
+$ docker compose exec web rails test
+
+# 生成脚手架
+$ docker compose exec web rails generate scaffold Post title:string body:text
+
+# 进入容器 Shell
+$ docker compose exec web bash
+```
+
+## 常见问题
+
+### Q: 数据库连接失败
+
+检查 `DATABASE_URL` 环境变量格式是否正确，确保 db 服务已启动：
+
+```bash
+$ docker compose ps
+$ docker compose logs db
+```
+
+### Q: server.pid 文件导致启动失败
+
+错误信息：`A server is already running`
+
+已在 command 中添加 `rm -f tmp/pids/server.pid` 处理。如仍有问题：
+
+```bash
+$ docker compose exec web rm -f tmp/pids/server.pid
+```
+
+### Q: Gem 安装失败
+
+可能需要更新 bundler 或清理缓存：
+
+```bash
+$ docker compose run --rm web bundle update
+```
+
+## 开发 vs 生产
+
+| 配置项 | 开发环境 | 生产环境 |
+|--------|---------|---------|
+| Rails 服务器 | Puma (开发模式) | Puma + Nginx |
+| 代码挂载 | 使用 volumes | 代码打包进镜像 |
+| 静态资源 | 动态编译 | 预编译 (`rails assets:precompile`) |
+| 数据库密码 | 明文配置 | 使用 Secrets 管理 |
+
+## 延伸阅读
+
+- [使用 Django](django.md)：Python Web 框架实战
+- [Compose 模板文件](compose_file.md)：配置详解
+- [数据管理](../07_data_network/README.md)：数据持久化

09_compose/usage.md

@@ -0,0 +1,134 @@
+# 使用
+
+## 术语
+
+首先介绍几个术语。
+
+* 服务 (`service`)：一个应用容器，实际上可以运行多个相同镜像的实例。
+
+* 项目 (`project`)：由一组关联的应用容器组成的一个完整业务单元。
+
+可见，一个项目可以由多个服务（容器）关联而成，`Compose` 面向项目进行管理。
+
+## 场景
+
+最常见的项目是 web 网站，该项目应该包含 web 应用和缓存。
+
+下面我们用 `Python` 来建立一个能够记录页面访问次数的 web 网站。
+
+### web 应用
+
+新建文件夹，在该目录中编写 `app.py` 文件
+
+```python
+from flask import Flask
+from redis import Redis
+
+app = Flask(__name__)
+redis = Redis(host='redis', port=6379)
+
+@app.route('/')
+def hello():
+    count = redis.incr('hits')
+    return 'Hello World! 该页面已被访问 {} 次。\n'.format(count)
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", debug=True)
+```
+
+### Dockerfile
+
+编写 `Dockerfile` 文件，内容为
+
+```docker
+FROM python:3.12-alpine
+ADD . /code
+WORKDIR /code
+RUN pip install redis flask
+CMD ["python", "app.py"]
+```
+
+### docker-compose.yml
+
+编写 `docker-compose.yml` 文件，这个是 Compose 使用的主模板文件。
+
+```yaml
+
+services:
+
+  web:
+    build: .
+    ports:
+     - "5000:5000"
+
+  redis:
+    image: "redis:alpine"
+```
+
+### 运行 compose 项目
+
+```bash
+$ docker compose up
+```
+
+此时访问本地 `5000` 端口，每次刷新页面，计数就会加 1。
+
+
+按下 `Ctrl-C` 停止项目。
+
+### 后台运行
+
+```bash
+$ docker compose up -d
+```
+
+### 停止
+
+```bash
+$ docker compose stop
+```
+
+### 进入服务
+
+```bash
+$ docker compose exec redis sh
+/data # redis-cli
+127.0.0.1:6379> get hits
+"9"
+```
+
+### 查看日志
+
+```bash
+$ docker compose logs -f
+```
+
+### 构建镜像
+
+```bash
+$ docker compose build
+```
+
+### 启动服务
+
+```bash
+$ docker compose start
+```
+
+### 运行一次性命令
+
+```bash
+$ docker compose run web python app.py
+```
+
+### 验证 `docker-compose.yml`
+
+```bash
+$ docker compose config
+```
+
+### 删除项目
+
+```bash
+$ docker compose down
+```

09_compose/wordpress.md

@@ -0,0 +1,210 @@
+# 实战 WordPress
+
+## 简介
+
+WordPress 是全球最流行的内容管理系统（CMS）。使用 Docker Compose 可以在几分钟内搭建一个包含数据库、Web 服务和持久化存储的生产级 WordPress 环境。
+
+---
+
+## 项目结构
+
+```
+wordpress/
+├── docker-compose.yml
+├── .env                # 环境变量（敏感信息）
+└── nginx/              # 可选：反向代理配置
+    └── nginx.conf
+```
+
+---
+
+## 编写 `docker-compose.yml`
+
+这是一个生产可用的最小化配置：
+
+```yaml
+services:
+  # 数据库服务
+  db:
+    image: mysql:8.0
+    container_name: wordpress_db
+    restart: always
+    command: 
+      # 使用原生密码认证（旧版 WP 兼容性）
+      - --default-authentication-plugin=mysql_native_password
+      - --character-set-server=utf8mb4
+      - --collation-server=utf8mb4_unicode_ci
+    environment:
+      MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}
+      MYSQL_DATABASE: wordpress
+      MYSQL_USER: wordpress
+      MYSQL_PASSWORD: ${DB_PASSWORD}
+    volumes:
+      - db_data:/var/lib/mysql
+    networks:
+      - wp_net
+
+  # WordPress 服务
+  wordpress:
+    image: wordpress:latest
+    container_name: wordpress_app
+    restart: always
+    ports:
+      - "8000:80"
+    environment:
+      WORDPRESS_DB_HOST: db:3306
+      WORDPRESS_DB_USER: wordpress
+      WORDPRESS_DB_PASSWORD: ${DB_PASSWORD}
+      WORDPRESS_DB_NAME: wordpress
+    volumes:
+      - wp_data:/var/www/html
+      # 增加上传文件大小限制
+      - ./uploads.ini:/usr/local/etc/php/conf.d/uploads.ini
+    depends_on:
+      - db
+    networks:
+      - wp_net
+
+volumes:
+  db_data:  # 数据库持久化
+  wp_data:  # WordPress 文件(插件/主题/上传)持久化
+
+networks:
+  wp_net:
+```
+
+---
+
+## 配置文件详解
+
+### 1. 环境变量 (.env)
+
+为了安全，不要在 `docker-compose.yml` 中直接写密码。创建 `.env` 文件：
+
+```ini
+DB_ROOT_PASSWORD=somestrongrootpassword
+DB_PASSWORD=somestronguserpassword
+```
+
+Compose 会自动读取此同级目录下的文件。
+
+### 2. 数据持久化
+
+我们定义了两个命名卷：
+- `db_data`: 确保 MySQL 容器重建后数据不丢失
+- `wp_data`: 保存 WordPress 的核心文件、插件、主题和上传的媒体文件
+
+### 3. PHP 配置优化
+
+默认的 WordPress 镜像上传文件限制较小（通常 2MB）。创建 `uploads.ini`：
+
+```ini
+file_uploads = On
+memory_limit = 256M
+upload_max_filesize = 64M
+post_max_size = 64M
+max_execution_time = 600
+```
+
+---
+
+## 启动与运行
+
+1. 启动服务：
+
+```bash
+$ docker compose up -d
+```
+
+2. 访问安装界面：
+   打开浏览器访问 `http://localhost:8000`
+
+3. 查看日志：
+
+```bash
+$ docker compose logs -f
+```
+
+---
+
+## 生产环境最佳实践
+
+### 1. 数据库备份
+
+不要只依赖 Volume。建议定期备份数据库：
+
+```bash
+# 导出 SQL
+$ docker exec wordpress_db mysqldump -u wordpress -pwordpress wordpress > backup.sql
+```
+
+或者添加一个自动备份容器：
+
+```yaml
+  backup:
+    image: tiredofit/db-backup
+    volumes:
+      - ./backups:/backup
+    environment:
+      - DB_TYPE=mysql
+      - DB_HOST=db
+      - DB_NAME=wordpress
+      - DB_USER=wordpress
+      - DB_PASS=${DB_PASSWORD}
+      - DB_DUMP_FREQ=1440 # 每天备份一次
+    depends_on:
+      - db
+    networks:
+      - wp_net
+```
+
+### 2. 使用 Nginx 反向代理
+
+在生产环境中，不要直接暴露 WordPress 端口，而是通过 Nginx 进行反向代理并配置 SSL。
+
+### 3. 使用 Redis 缓存
+
+WordPress 支持 Redis 缓存以提高性能。
+
+```yaml
+  redis:
+    image: redis:alpine
+    restart: always
+    networks:
+      - wp_net
+```
+
+在 WordPress 容器环境变量中添加：
+```yaml
+      WORDPRESS_REDIS_HOST: redis
+```
+并安装 Redis Object Cache 插件。
+
+---
+
+## 常见问题
+
+### Q: 数据库连接错误
+
+**现象**：访问页面显示 "Error establishing a database connection"。
+
+**排查**：
+1. 检查 `docker compose logs wordpress`
+2. 确认 `.env` 中的密码与 YAML 文件引用一致
+3. 确认 `WORDPRESS_DB_HOST` 也是 `db`（服务名）
+4. MySQL 8.0 可能需要几秒钟启动，WordPress 会自动重试，稍等片刻即可。
+
+### Q: 无法上传大文件
+
+**解决**：确保挂载了 `uploads.ini` 配置，并且重启了容器：
+```bash
+$ docker compose restart wordpress
+```
+
+---
+
+## 延伸阅读
+
+- [Compose 模板文件](compose_file.md)：深入了解配置项
+- [数据卷](../07_data_network/data/volume.md)：理解数据持久化
+- [Docker Hub WordPress](https://hub.docker.com/_/wordpress)：官方镜像文档