Docker的容器编排

1. 什么是容器编排（Docker Compose）

（1）docker-compose 是 Docker 官方的开源项目，使用 python 编写，实现上调用了Docker 服务的 API 进行容器管理及编排，其官方定义为定义和运行多个 Docker 容器的应用。docker-compose 中有两个非常重要的概念：

• 服务 ( service )：一个应用的容器，实际上可以包括若干运行相同镜像的容器实例。
• 项目( project )：由一组关联的应用容器组成的一个完整业务单元，在 dockercompose.yml 文件中定义, 整个 docker-compose.yml 定义一个项目。

（2）Compose 的默认管理对象是项目，通过子命令对项目中的一组容器进行便捷地生命周期管理。通过 compose 可以方便的管理多个服务。

（3）生活案例来理解容器编排：

• docker compose 就像航母一样，有舰载机、防空导弹，舰载机、导弹呢就是一个个容器。

2. 容器编排的功能

（1）在介绍功能之前先解释一下为什么需要容器编排（Docker Compose）：

• Docker 是一个轻量化的应用程序， Docker 官方推荐每个 Docker 容器中只运行一个进程。
• 如果一个应用需要涉及到 MySQL、 nginx 等环境， 那么我们需要分别为应用、数据库和 nginx 创建单独的 docker 容器，然后分别启动容器。
• 想象一下，当我们构建好 Docker 之后，每次启动应用，都至少需要 docker run三次， 或者写一些脚本来实现， 这样会比较繁琐。
• 另外，这些 docker 容器都是分散独立的，也不方便镜像管理。那既然这些 docker容器 都是为了同一个应用服务，我们就应该把它们放到一起，这就引出了 dockercompose 来解决这类型的问题。

（2）Docker Compose 的安装：

• 安装 docker 的时候，我们默认已经安装了 docker-compose,安装的组件包名称为docker-compose-plugin，此处不再赘述

#检查安装是否成功
[xiaomaker@xiaomaker-virtual-machine:compose]$ docker compose version
Docker Compose version v2.16.

（3）Docker Compose 的功能：

1. Compose的使用的步骤：
   • 使用 docker-compose.yml 定义构成应用程序的服务，这样它们可以在隔离环境中一起运行。
   • 最后，执行 docker compose up 命令来启动并运行整个应用程序。
2. 核心功能：Compose 具有管理应用程序整个生命周期的命令。
   • 启动，停止和重建服务。
   • 查看正在运行的服务的状态。
   • 流式传输运行服务的日志输出。
   • 在服务上运行一次性命令。

（4）Docker Compose的使用场景：

1. 单主机部署：快速搭建一个单节点开发或者测试环境，方便使用。
2. 不同环境隔离：通过指定 project 来运行不同的环境，实现隔离的目的。

3. 容器编排文件（docker-compose.yml）的介绍

3.1 文件语法版本

（1）目前官方支持三个大版本， 即 Version 1、 Version 2 及 Version 3， 其中 Version 1 已经被废弃掉了。当前最新的版本是 3.8，它支持的 Docker Engine 版本不得低于 19.03.0。我们是基于 3.8 版本的 Compose file 语法进行讲解，其他版本介绍参见官方文档。

3.2 文件基本结构及常见指令

（1）基本格式如下：

version: "3.8" # 定义版本， 表示当前使用的 docker-compose 语法的版本
services: # 服务，可以存在多个
servicename: # 服务名字，它也是内部 bridge 网络可以使用的 DNS name，如果不是集群模式相当于 docker run 的时候指定的一个名称，
#集群（Swarm）模式是多个容器的逻辑抽象
	image: # 必选，镜像的名字
	command: # 可选，如果设置，则会覆盖默认镜像里的 CMD 命令
	environment: # 可选，等价于 docker container run 里的 --env 选项设置环境变量
	volumes: # 可选，等价于 docker container run 里的 -v 选项 绑定数据卷
	networks: # 可选，等价于 docker container run 里的 --network 选项指定网络
	ports: # 可选，等价于 docker container run 里的 -p 选项指定端口映射
	expose: # 可选，指定容器暴露的端口
	build: #构建目录
	depends_on: #服务依赖配置
	env_file: #环境变量文件
servicename2:
	image:
	command:
	networks:
	ports:
servicename3:
	#...
	volumes: # 可选，等价于 docker volume create
	networks: # 可选，等价于 docker network create

（2）下面将逐个介绍常见字段格式语法。

• image：指定容器运行的镜像。以下格式都可以：

image: redis
image: redis:5
image: redis@sha256:0ed5d5928d4737458944eb604cc8509e245c3e19d02ad83935398bc4b991aac7
image: library/redis
image: docker.io/library/redis
image: my_private.registry:5000/redis

• command：覆盖容器启动的默认命令。

command: ["bundle", "exec", "thin", "-p", "3000"]
command: bundle exec thin -p 3000

• entrypoint：覆盖容器默认的 entrypoint。

entrypoint: /code/entrypoint.sh

• entrypoint也可以是以下格式：

entrypoint:
	- php
	- -d
	- zend_extension=/usr/local/lib/php/extensions/no-debug-nonzts-20100525/xdebug.so
	- -d
	- memory_limit=-1
	- vendor/bin/phpunit

• environment：添加环境变量。您可以使用数组或字典、任何布尔值，布尔值需要用引号引起来，以确保 YML 解析器不会将其转换为 True 或 False。

#map 语法
	environment:
	RACK_ENV: development
	SHOW: "true"
	USER_INPUT:
#数组语法
environment:
	- RACK_ENV=development
	- SHOW=true
	- USER_INPUT

• networks：指定容器运行的网络。首先配置容器网络：

services:
	frontend:
		image: awesome/webapp
		networks:
			- front-tier
			- back-tier
	monitoring:
		image: awesome/monitoring
		networks:
			- admin
	backend:
		image: awesome/backend
		networks:
			back-tier:
				aliases:
					- database
		admin:
			aliases:
				- mysql
networks:
	front-tier:
	back-tier:
	admin:

• networks配置网络驱动和子网信息：

services:
	frontend:
		image: awesome/webapp
		networks:
			front-tier:
				ipv4_address: 172.16.238.10
networks:
	front-tier:
		ipam:
			driver: default
			config:
				- subnet: "172.16.238.0/24"

• volumes：将主机的数据卷或者文件挂载到容器里。

#短语法
services:
	db:
		image: postgres:latest
		volumes:
			- "/localhost/postgres.sock:/var/run/postgres/postgres.sock"
			- "/localhost/data:/var/lib/postgresql/data"

#完整语法
services:
	backend:
		image: awesome/backend
		volumes:
			- type: volume
			#命名卷
			source: db-data
			target: /data
			volume:
				nocopy: true
			#绑定卷
			- type: bind
				source: /var/run/postgres/postgres.sock
				target: /var/run/postgres/postgres.sock
volumes:
	db-data:

• ports：指定端口映射。以下格式都可以：

#完整语法
ports:
	- target: 80
	host_ip: 127.0.0.1
	published: 8080
	protocol: tcp
	mode: host
	- target: 80
	host_ip: 127.0.0.1
	published: 8000-9000
	protocol: tcp
	mode: host

#短语法
ports:
	- "3000"
	- "3000-3005"
	- "8000:8000"
	- "9090-9091:8080-8081"
	- "49100:22"
	- "127.0.0.1:8001:8001"
	- "127.0.0.1:5000-5010:5000-5010"
	- "6060:6060/udp"

• expose：暴露端口，但不映射到宿主机，只被连接的服务访问。仅可以指定内部端口为参数：

expose:
	- "3000"
	- "8000"

• build：指定为构建镜像上下文路径。例如 webapp 服务，指定为从上下文路径 ./dir/Dockerfile 所构建的镜像：

version: "3.7"
services:
	webapp:
		build: ./dir

• build也可以作为具有在上下文指定的路径的对象，以及可选的 Dockerfile 和 args：

version: "3.7"
services:
	webapp:
		build:
			context: ./dir
			dockerfile: Dockerfile-alternate
			args:
			buildno: 1
			labels:
				- "com.example.description=Accounting webapp"
				- "com.example.department=Finance"
				- "com.example.label-with-empty-value"

• build构建下各个字段的含义：

  • context：上下文路径。
  • dockerfile：指定构建镜像的 Dockerfile 文件名。
  • args：添加构建参数，这是只能在构建过程中访问的环境变量。
  • labels：设置构建镜像的标签。

• depends_on：设置依赖关系。

  • docker compose up：以依赖性顺序启动服务。在以下示例中，先启动 db 和redis ，才会启动 web。
  • docker compose up SERVICE：自动包含 SERVICE 的依赖项。在以下示例中，docker compose up web 还将创建并启动 db 和 redis。
  • docker compose stop：按依赖关系顺序停止服务。在以下示例中， web 在 db 和redis 之前停止。

version: "3.7"
services:
	web:
		build: .
		depends_on:
			- db
			- redis
	redis:
		image: redis
	db:
		image: postgres

• depends_on可以指定条件， healthy 需要配置 healthcheck 来完成：

services:
	web:
		build: .
		depends_on:
	db:
		condition: service_healthy
	redis:
		condition: service_started
	redis:
		image: redis
	db:
		image: postgres

• health check 样例：

version: "3.8"
services:
	web:
		image: nginx:1.24.0
		environment:
			TEST: 1
		depends_on:
			mysql:
				condition: service_healthy
	mysql:
		image: mysql:5.7
		environment:
			MYSQL_ROOT_PASSWORD: "bit@123"
		volumes:
			- /data/maxhou/mysqldata/varlib/:/var/lib/mysql
		healthcheck:
			test: mysql --user=root --password='bit@123' -e "SELECT 1;"
			interval: 10s
			timeout: 5s
			retries: 10

• env_file：从文件添加环境变量。可以是单个值或列表的多个值。

env_file: .env

• env_file也可以是列表格式：

env_file:
	- ./common.env
	- ./apps/web.env
	- /opt/secrets.env

其他的指令可以参考官方文档。 建议多看官方文档。

4. Docker Compose命令详解

（1）Docker Compose命令官网参考地址：https://docs.docker.com/reference/cli/docker/compose/。

4.1 Docker Compose命令清单

（1）命令清单如下：

4.2 命令格式和常见选项说明

（1）对于 Compose 来说，大部分命令的对象既可以是项目本身，也可以指定为项目中的服务或者容器。如果没有特别的说明，命令对象将是项目，这意味着项目中所有的服务都会受到命令影响。docker-compose 命令的基本的使用格式为：

docker compose [OPTIONS] COMMAND [ARGS...]

（2）常见选项说明：

• -f，–file 指定使用的 Compose 模板文件，默认为 docker-compose.yml，可
  以多次指定。
• -p, --project-name 指定项目名称，默认将使用所在目录名称作为项目名。

4.3 常见命令说明

4.3.1 docker compose up命令

（1）该命令的作用十分强大，它会尝试自动完成包括构建镜像、（重新）创建服务、启动服务并关联服务相关容器的一系列操作，可以直接通过该命令来启动一个项目。

docker compose up [options] [SERVICE...]

• -d 在后台运行服务容器， 推荐在生产环境下使用该选项。
• –force-recreate 强制重新创建容器，不能与 --no-recreate 同时使用。
• –no-recreate 如果容器已经存在了，则不重新创建，不能与 --forcerecreate 同时使用。

4.3.2 docker compose down命令

（1）停止所有容器，并删除容器和网络：

docker compose down [options] [SERVICE...]

• -v，–volumes 删除容器同时删除目录映射。

4.3.3 docker compose run命令

（1）该命令可以在指定服务容器上执行相关的命令：

# 例如:启动一个 ubuntu 服务容器，并执行 ping docker.com 命令
# docker compose run ubuntu ping docker.com
docker compose run [options] SERVICE [COMMAND] [ARGS...]

• -d 后台运行容器。
• –name NAME 为容器指定一个名字。
• –entrypoint CMD 覆盖默认的容器启动指令。
• -e KEY=VAL 设置环境变量值，可多次使用选项来设置多个环境变量。
• -u, --user=“” 指定运行容器的用户名或者 uid。
• –rm 运行命令后自动删除容器。
• -p，–publish=[] 映射容器端口到本地主机。

5. Docker Compose的基本操作

（1）创建 compose 目录：

mkdir -p /data/myworkdir/compose/base
cd /data/myworkdir/compose/base

（2）进入 base 目录，创建 docker-compose.yml 文件：

cd /data/myworkdir/compose/base/
vi docker-compose.yml

（3）输入以下内容：

version: 3.8
services:
	web:
		image: nginx:1.24.0
		environment:
			TEST: 1
		ports:
			- 8979:80
		networks:
			- mytestnet
		volumes:
			- ./mynginxhome:/usr/share/nginx/html
		depends_on:
			mysql:
				condition: service_healthy
			redis:
				condition: service_healthy
	mysql:
		image: mysql:5.7
		environment:
			MYSQL_ROOT_PASSWORD: "bit@123"
		networks:
			- mytestnet
		volumes:
			- /data/maxhou/mysqldata/varlib/:/var/lib/mysql
		healthcheck:
			test: mysql --user=root --password='bit@123' -e "SELECT 1;"
			interval: 10s
			timeout: 5s
			retries: 10
	redis:
		image: redis:7
		networks:
			- mytestnet
		healthcheck:
			test: redis-cli ping
			interval: 10s
			timeout: 5s
			retries: 10
networks:
		mytestnet:

（4）输入 docker config 会做检查：

[xiaomaker@xiaomaker-virtual-machine:base]$ docker compose config
version must be a string

（5）我们修改错误信息，将版本转为字符串，再次检查：

version: "3.8"
services:
	web:
		image: nginx:1.24.0
		environment:
			TEST: 1
		ports:
			- 8979:80
		networks:
			- mytestnet
		volumes:
			- ./mynginxhome:/usr/share/nginx/html
		depends_on:
			mysql:
				condition: service_healthy
			redis:
				condition: service_healthy
	mysql:
		image: mysql:5.7
		environment:
			MYSQL_ROOT_PASSWORD: "bit@123"
		networks:
			- mytestnet
		volumes:
			- /data/maxhou/mysqldata/varlib/:/var/lib/mysql
		healthcheck:
			test: mysql --user=root --password='bit@123' -e "SELECT 1;"
			interval: 10s
			timeout: 5s
			retries: 10
	redis:
		image: redis:7
		networks:
			- mytestnet
		healthcheck:
			test: redis-cli ping
			interval: 10s
			timeout: 5s
			retries: 10
networks:
	mytestnet:

[xiaomaker@xiaomaker-virtual-machine:base]$ docker compose config
name: base
services:
	mysql:
		environment:
			MYSQL_ROOT_PASSWORD: bit@123
		healthcheck:
			test:
				- CMD-SHELL
				- mysql --user=root --password='bit@123' -e "SELECT 1;"
			timeout: 5s
			interval: 10s
			retries: 10
		image: mysql:5.7
		networks:
			mytestnet: null
		volumes:
			- type: bind
			source: /data/maxhou/mysqldata/varlib/
			target: /var/lib/mysql
			bind:
				create_host_path: true
	redis:
		healthcheck:
		test:
			- CMD-SHELL
			- redis-cli ping
			timeout: 5s
			interval: 10s
			retries: 10
		image: redis:7
		networks:
			mytestnet: null
	web:
		depends_on:
			mysql:
				condition: service_healthy
			redis:
				condition: service_healthy
		environment:
			TEST: "1"
		image: nginx:1.24.0
		networks:
			mytestnet: null
		ports:
			- mode: ingress
			target: 80
			published: "8979"
			protocol: tcp
		volumes:
			- type: bind
			source: /data/myworkdir/compose/base/mynginxhome
			target: /usr/share/nginx/html
			bind:
				create_host_path: true
networks:
	mytestnet:
		name: base_mytestnet

（6）创建首页目录，编辑首页内容：

[xiaomaker@xiaomaker-virtual-machine:base]$ mkdir -p ./mynginxhome
[xiaomaker@xiaomaker-virtual-machine:base]$ cd ./mynginxhome/
[xiaomaker@xiaomaker-virtual-machine:mynginxhome]$ echo "Hello" > index.html

（7）启动服务：

[xiaomaker@xiaomaker-virtual-machine:base]$ docker compose up -d
[+] Running 4/4
? Network base_mytestnet Created 0.1s
? Container base-mysql-1 Healthy 11.6s
? Container base-redis-1 Healthy 11.6s
? Container base-web-1 Started 11.8s

（8）通过页面访问：

（9）停止服务：

[xiaomaker@xiaomaker-virtual-machine:base]$ docker compose stop
[+] Running 3/3
✔ Container base-web-1 Stopped 10.2s
✔ Container base-mysql-1 Stopped 2.0s
✔ Container base-redis-1 Stopped 0.2s

（10）启动服务：

[xiaomaker@xiaomaker-virtual-machine:base]$ docker compose start
[+] Running 3/3
✔ Container base-redis-1 Healthy 11.3s
✔ Container base-mysql-1 Healthy 11.3s
✔ Container base-web-1 Started 0.4s

（11）删除服务：

[xiaomaker@xiaomaker-virtual-machine:base]$ docker compose down
[+] Running 4/4
✔ Container base-web-1 Removed 0.2s
✔ Container base-redis-1 Removed 0.2s
✔ Container base-mysql-1 Removed 1.8s
✔ Network base_mytestnet Removed 0.1s

6. Docker Compose 部署自定义服务

我们编写一个简单的案例， nginx 反向代理到我们的一个 springboot 微服务，微服务访问我们的 msyql 数据库查询用户信息。

（1）设计数据非常简单的一个表信息，写入两条数据，文件为 init.sql：

drop database if exists test;
CREATE DATABASE `test` DEFAULT CHARACTER SET utf8mb4 ;
use `test`;
CREATE TABLE `users` (
`sno` int(11) DEFAULT NULL,
`sname` varchar(50) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
INSERT INTO users (sno,sname) VALUES
(1,'pony'),
(2,'maxhou');

（2）创建一个 springboot 应用，配置 maven 项目。

（3）添加启动类：

package com.bit.demojdbc;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class DemojdbcApplication {
	public static void main(String[] args) {
		SpringApplication.run(DemojdbcApplication.class, args);
	}
}

（4）配置数据库信息，注意本地测试的时候红色部分调整为 ip 地址，而我们实际的服务使用的 mysql 的一个服务名称。

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://mysql:3306/test
spring.datasource.username=root
spring.datasource.password=roo

（5）配置用户控制器，简单配置，不再去涉及 mapper 那些内容通过 jdbc 直接完成操作：

package com.bit.demojdbc;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/user")
public class UserController {
	@Autowired
	JdbcTemplate jdbcTemplate;
	@RequestMapping("/list")
	@ResponseBody
	public Object Users(){
		return jdbcTemplate.queryForList("select * from users");
	}
}

（6）编译打包：

（7）进入打包的目录，本地测试正常启动。

（8）本地测试正常访问：

（9）编写 docker-compose.yml：

version: "3.8"
services:
	web:
		image: nginx:1.24.0
		ports:
			- 8112:80
		networks:
			- myhellonet
		volumes:
			- ./nginx/conf.d:/etc/nginx/conf.d
		depends_on:
			mysys:
				condition: service_started
	mysys:
		image: java:8
		depends_on:
			mysql:
				condition: service_healthy
		command: java -jar /app/demojdbc-0.0.1-SNAPSHOT.jar
		volumes:
			- ./app/:/app/
		networks:
			- myhellonet
	mysql:
		image: mysql:5.7
		environment:
			MYSQL_ROOT_PASSWORD: "root"
		networks:
			- myhellonet
		volumes:
			- ./mysql/varlib/:/var/lib/mysql
			- ./mysql/init/:/docker-entrypoint-initdb.d/
		healthcheck:
			test: mysql --user=root --password='root' -e "SELECT 1;"
			interval: 10s
			timeout: 5s
			retries: 10
networks:
	myhellonet:

（10）创建工程目录和卷目录：

mkdir -p /data/maxhou/mycompose/prj16
cd /data/maxhou/mycompose/prj16
mkdir -p ./nginx/conf.d
mkdir -p ./app
mkdir -p ./mysql/varlib/
mkdir -p ./mysql/init/

（11）将 nginx 的反向代理配置 bit.conf 放入到./nginx/conf.d，其中内容为：

server {
	listen 80;
	access_log off;
	location / {
		proxy_pass http://mysys:8080/user/;
	}
}

（12）将数据库初始化文件 init.sql 放入到./mysql/init 目录

（13）将应用 jar 包放入到./app 目录：

[xiaomaker@xiaomaker-virtual-machine:prj16]$ ll ./app
total 19132
drwxr-xr-x 2 root root 4096 Apr 25 23:44 ./
drwxr-xr-x 5 root root 4096 Apr 26 00:04 ../
-rw-r--r-- 1 root root 19579363 Apr 26 00:07 demojdbc-0.0.1-
SNAPSHOT.jar
[xiaomaker@xiaomaker-virtual-machine:prj16]$ ll ./nginx/conf.d/
total 12
drwxr-xr-x 2 root root 4096 Apr 25 23:49 ./
drwxr-xr-x 3 root root 4096 Apr 25 23:42 ../
-rw-r--r-- 1 root root 117 Apr 25 23:49 bit.conf
[xiaomaker@xiaomaker-virtual-machine:prj16]$ ll ./mysql/init/
total 12
drwxr-xr-x 2 root root 4096 Apr 25 23:49 ./
drwxr-xr-x 4 root root 4096 Apr 25 23:43 ../
-rw-r--r-- 1 root root 417 Apr 26 00:11 init.sql

（14）启动我们的项目：

[xiaomaker@xiaomaker-virtual-machine:prj16]$ docker compose up -d
[+] Running 4/4
✔ Network prj16_myhellonet Created 0.1s
✔ Container prj16-mysql-1 Healthy 11.2s
✔ Container prj16-mysys-1 Started 11.5s
✔ Container prj16-web-1 Started 12.2s

（15）浏览器访问 nginx，可以看到用户信息正常返回：

至此我们完成了我们的 nginx 服务，后台服务和数据的完整的一个应用。

7. Docker Compose 部署 WordPress

7.1 什么是 WordPress

（1）概念如下：

• WordPress 是使用 PHP 语言开发的博客平台，用户可以在支持 PHP 和 MySQL 数据库的服务器上架设属于自己的网站。也可以把 WordPress 当作一个内容管理系统（CMS）来使用。
• WordPress 是一款个人博客系统，并逐步演化成一款内容管理系统软件，它是使用PHP 语言和 MySQL 数据库开发的，用户可以在支持 PHP 和 MySQL 数据库的服务器上使用自己的博客。
• WordPress 有许多第三方开发的免费模板，安装方式简单易用。不过要做一个自己的模板，则需要你有一定的专业知识。比如你至少要懂的标准通用标记语言下的一个应用 HTML 代码、 CSS、 PHP 等相关知识。
• WordPress 官方支持中文版，同时有爱好者开发的第三方中文语言包，如 wopus 中文语言包。 WordPress 拥有成千上万个各式插件和不计其数的主题模板样式。

7.2 部署 WordPress

（1）编写 Docker Compose：

version: '3.8'
# 定义所有的 service 信息, services 下面的第一级别的 key 既是一个service 的名称
services:
	db:
		image: mysql:5.7
	volumes:
		- ./db_data:/var/lib/mysql
	# 定义容器重启策略
	restart: always
	# 设置环境变量， environment 的值可以覆盖 env_file 的值
	environment:
		MYSQL_ROOT_PASSWORD: mywordpress
		MYSQL_DATABASE: wordpress
		MYSQL_USER: wordpress
		MYSQL_PASSWORD: wordpress
	healthcheck:
		test: mysql --user=root --password='mywordpress' -e "SELECT 1;"
		interval: 10s
		timeout: 5s
		retries: 10
	wordpress:
		#docker compose up 以依赖顺序启动服务，先启动 db
		depends_on:
			db:
				condition: service_healthy
		image: wordpress:latest
			# 建立宿主机和容器之间的端口映射关系,容器的 80 端口和宿主机的 8000端口建立映射关系
		ports:
			- "8000:80"
		restart: always
		volumes:
			- ./wordpress:/var/www/html
		environment:
			WORDPRESS_DB_HOST: db:3306
			WORDPRESS_DB_USER: wordpress
			WORDPRESS_DB_PASSWORD: wordpress
			WORDPRESS_DB_NAME: wordpress

（2）运行站点：

docker compose up -d

（3）访问 web 页面：

（4）配置参数，点击安装：

（5）登录：

（6）进入后台：

（7）删除，释放空间：

[xiaomaker@xiaomaker-virtual-machine:compose]$ docker compose down
[+] Running 3/2
⠿ Container compose-wordpress-1 Removed 3.3s
⠿ Container compose-db-1 Removed 1.9s
⠿ Network compose_default Removed

8. 常见问题总结

（1）up、 run 和 start 之间有什么区别：

• 通常，你想要 docker compose up. 用于 up 启动或重新启动 docker-compose.yml.在默认的“附加”模式下，会看到来自所有容器的所有日志。在“分离”模式 ( -d) 中，启动容器后 Compose 退出，但容器继续在后台运行。
• 该 docker compose run 命令用于运行“一次性”或“临时”任务。它需要您要运行的服务名称，并且只为正在运行的服务所依赖的服务启动容器。用于 run 运行测试或执行管理任务，例如从数据卷容器中删除或添加数据。
• 该 run 命令的作用类似于 dockerrun -ti 它打开容器的交互式终端并返回与容器中进程的退出状态匹配的退出状态。docker compose start 命令仅对重新启动先前创建但已停止的容器有用。它从不创建新容器。

（2）如何在同一主机上运行 Compose 文件的多个副本：

• Compose 使用项目名称为项目的所有容器和其他资源创建唯一标识符。要运行项目的多个副本，请使用-p 命令行选项 或 COMPOSE_PROJECT_NAME 环境变量设置自定义项目名称。

（3）可以控制服务启动顺序吗？

• 可以控制启动顺序，通过依赖指定，并且可以配合 healthcheck 等健康检查成功以后再启动。