Docker

发表于 更新于 本文字数： 13k 阅读时长 ≈ 12 分钟

Docker的学习笔记——基于黑马教程

一、介绍

Docker 是一个开源的容器化平台，旨在通过将应用及其依赖打包成容器，简化应用的开发、交付和运行过程。容器是一种轻量级的虚拟化技术，允许开发者在不同环境中一致地运行应用程序。Docker 提供了一个简单的方式来构建、分享和运行应用程序，广泛应用于软件开发、部署和运维领域。

说人话就是： Docker自带了一套环境，可以供里面运行的应用在不同的虚拟机中有相同的运行环境。方便快速的部署项目，不用一直调运行环境。

请自备虚拟机CentOS 8 的安装。本笔记用CentOS8.5 演示

1

二、Linus虚拟机基础命令

1、配置下载源（必做）

由于默认下载源已过期，所以需要手动配置下载源，要不然下载不了任何东西

  1. 备份数据源

    2

依次输入命令：

1
2
3
4
5
6
7
8
#打开yum下载源配置目录
cd /etc/yum.repos.d/
#查看当前路径下的文件
ll
#创建bak目录
mkdir bak
#将所有 CentOS-Stream- 开头的全部移动到bak目录下
mv CentOS-Stream-* bak

输入命令：

1
wget -O /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-vault-8.5.2111.repo

完成后建立元数据缓存：

1
yum makecache

2、开启网卡

有时候会发现centos网络没了。输入ifconfig看不到一个网卡

依次输入：

nmcli为： NetworkManager Command Line Interface

1
2
3
4
5
6
#查看网卡设备状态
nmcli device
#查看是否关闭
nmcli networking
#打开
nmcli networking on

3、解决vmware虚拟机复制粘贴

  1. 先卸载原本安装的open-vm-tools

1
yum remove open-vm-tools

  1. 安装

1
yum install open-vm-tools

总结是，别用vmware自带的控制台。会变得不幸

4、配置ssh

CentOS8 SSH设置及安装（详细）-CSDN博客

1
rpm -qa | grep ssh

rpm是一个常用的包管理工具，在基于 RPM 包管理系统（例如 CentOS、RHEL、Fedora 等 Linux 发行版）中使用。

-q 表示query查询

-a表示all全部

| 是管道符 表示将搜索的结果作为后面工具的输入

grep是一个文本搜索工具

所以连起来就是查找rpm中是否安装了ssh这个软件包

Centos8自带ssh所以不需要安装

安装，一般来说安装完即可使用：

1
yum install openssh-server

5、查看网络

1
ifconfig

可以用于查看ip地址

7

6、查看文件命令

  1. 显示文件内容

    1
    cat file.txt

  2. 创建新文件

    1
    cat > newfile.txt

  3. 追加内容到文件： 使用 >> 可以将内容追加到现有的文件中。例如，将 file1.txt 的内容追加到 file2.txt：

    1
    bashcat file1.txt >> file2.txt

  4. 显示行号： -n 选项用于显示文件的行号：

    1
    cat -n file.txt

7、获取网站内容

1
curl www.baidu.com

8、解压文件

1
unzip 文件名

9、删除文件

删除路径下所有文件

1
rm -rf /path/to/directory/*

三、安装Docker

1、安装Docker命令

依次执行以下命令：

1
2
3
4
5
6
## 安装Docker所需要的一些工具包
sudo yum install -y yum-utils
## 建立Docker仓库 (映射仓库地址)
sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
# 安装Docker引擎
sudo yum install docker-ce docker-ce-cli containerd.io

安装完成打开docker:

1
sudo systemctl start docker

测试

1
sudo docker run hello-world

2、配置docker镜像源

如图所示，镜像源失效

3

1
2
#打开或创建/etc/docker/daemon.json
sudo vim  /etc/docker/daemon.json

输入如下mirror：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
{
  "registry-mirrors": [
    "https://docker.hpcloud.cloud",
    "https://docker.m.daocloud.io",
    "https://docker.unsee.tech",
    "https://docker.1panel.live",
    "http://mirrors.ustc.edu.cn",
    "https://docker.chenby.cn",
    "http://mirror.azure.cn",
    "https://dockerpull.org",
    "https://dockerhub.icu",
    "https://hub.rat.dev"
  ]
}

4

依次输入 "esc"键、 “:” 、 “wq” 保存文件

1
2
3
4
#重新加载配置源
sudo systemctl daemon-reload
#重启docker容器
sudo systemctl restart docker

然后尝试拉取文件，应该可以用了：

1
sudo docker pull hello-world

5

四、docker基础命令

命令大全：

命令 说明 文档地址
docker pull 拉取镜像 docker pull
docker push 推送镜像到DockerRegistry docker push
docker images 查看本地镜像 docker images
docker rmi 删除本地镜像 docker rmi
docker run 创建并运行容器（不能重复创建） docker run
docker stop 停止指定容器 docker stop
docker start 启动指定容器 docker start
docker restart 重新启动容器 docker restart
docker rm 删除指定容器 docs.docker.com
docker ps 查看容器 docker ps
docker logs 查看容器运行日志 docker logs
docker exec 进入容器 docker exec
docker save 保存镜像到本地压缩文件 docker save
docker load 加载本地压缩文件到镜像 docker load
docker inspect 查看容器详细信息 docker inspect

0、命令别名

给长长的命令起一个别名。方便使用命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 修改/root/.bashrc文件
vi /root/.bashrc
内容如下：
# .bashrc

# User specific aliases and functions

alias rm='rm -i'
alias cp='cp -i'
alias mv='mv -i'
alias dps='docker ps --format "table {{.ID}}\t{{.Image}}\t{{.Ports}}\t{{.Status}}\t{{.Names}}"'
alias dis='docker images'

# Source global definitions
if [ -f /etc/bashrc ]; then
        . /etc/bashrc
fi

执行命令使得别名生效

1
source /root/.bashrc

1、查看安装所有的容器

1
2
3
4
5
6
7
8
9
10
11
# 查看所有容器，包括停止的容器
docker ps -a

# 显示容器ID、名称和状态
docker ps --format "table {{.ID}}\t{{.Names}}\t{{.Status}}"

# 查看最近创建的容器
docker ps -l

# 过滤只显示退出状态为 'exited' 的容器
docker ps -f "status=exited"xxxxxxxxxx docker ps # 查看所有容器，包括停止的容器docker ps -a# 显示容器ID、名称和状态docker ps --format "table {{.ID}}\t{{.Names}}\t{{.Status}}"# 查看最近创建的容器docker ps -l# 过滤只显示退出状态为 'exited' 的容器docker ps -f "status=exited"

6

2、基础命令使用演示

  1. 去DockerHub查看nginx镜像仓库及相关信息

  2. 拉取Nginx镜像

    1
    docker pull nginx

    9_2

  3. 查看镜像

    1
    docker images

    9_3

  4. 创建并允许Nginx容器

    1
    docker run -d --name nginx -p 80:80 nginx

    9_4

  5. 查看运行中容器

    1
    2
    3
    docker ps
    # 也可以加格式化方式访问，格式会更加清爽
    docker ps --format "table {{.ID}}\t{{.Image}}\t{{.Ports}}\t{{.Status}}\t{{.Names}}"

    9_5

  6. 测试运行结果： 访问网页，地址：http://虚拟机地址 例如 ： http://192.168.101.129

    9_6

  7. 打开关闭容器

    1
    2
    3
    4
    #打开
    docker start nginx
    #关闭
    docker stop nginx

  8. 查看容器基本信息

    1
    docker inspect nginx

  9. 进入容器内目录

    1
    2
    3
    docker exec -it nginx bash
    # 或者，可以进入MySQL
    docker exec -it mysql mysql -uroot -p

    -i（或 --interactive）：

    • 这个选项表示让 Docker 容器保持标准输入（STDIN）打开，使你能够与容器交互。例如，在执行命令时，可以输入数据或指令。

    -t（或 --tty）：

    • 这个选项表示分配一个伪终端（TTY）。这会为容器创建一个虚拟的终端，使得输出格式更友好，类似于在本地终端中执行命令的体验。

    -it使你能够进入容器并与容器内部的命令进行交互

    9_8

  10. 删除容器

    1
    2
    3
    docker rm nginx
    # 发现无法删除，因为容器运行中，强制删除容器
    docker rm -f nginx

3、配置容器自启

  1. 新建容器时配置自启参数

    1
    docker run --restart=always 容器id 或 容器名称

  2. 已存在的容器配置自启

    1
    2
    3
    docker update --restart=always 容器id 或 容器名称

    #取消把always改成no

五、安装一些常用程序的命令

1、mysql

1
2
3
4
5
6
docker run -d \
  --name mysql \
  -p 3306:3306 \
  -e TZ=Asia/Shanghai \
  -e MYSQL_ROOT_PASSWORD=123 \
  mysql

解读：

  • docker run -d ：创建并运行一个容器，-d则是让容器以后台进程运行
  • --name`` mysql : 给容器起个名字叫mysql，你可以叫别的
  • -p 3306:3306 : 设置端口映射。
    • 容器是隔离环境，外界不可访问。但是可以将宿主机端口映射容器内到端口，当访问宿主机指定端口时，就是在访问容器内的端口了。
    • 容器内端口往往是由容器内的进程决定，例如MySQL进程默认端口是3306，因此容器内端口一定是3306；而宿主机端口则可以任意指定，一般与容器内保持一致。
    • 格式： -p 宿主机端口:容器内端口，示例中就是将宿主机的3306映射到容器内的3306端口
  • -e TZ=Asia/Shanghai : 配置容器内进程运行时的一些参数
    • 格式：-e KEY=VALUE，KEY和VALUE都由容器内进程决定
    • 案例中，TZ=Asia/Shanghai是设置时区；MYSQL_ROOT_PASSWORD=123是设置MySQL默认密码
  • mysql : 设置镜像名称，Docker会根据这个名字搜索并下载镜像
    • 格式：REPOSITORY:TAG，例如mysql:8.0，其中REPOSITORY可以理解为镜像名，TAG是版本号
    • 在未指定TAG的情况下，默认是最新版本，也就是mysql:latest

安装完即可用宿主机软件连接mysql。这里用IDEA演示

8

六、数据卷

1、介绍

数据卷（volume）是一个虚拟目录，是容器内目录与宿主机目录之间映射的桥梁。

以Nginx为例，我们知道Nginx中有两个关键的目录：

  • html：放置一些静态资源

  • conf：放置配置文件

如果我们要让Nginx代理我们的静态资源，最好是放到html目录；如果我们要修改Nginx的配置，最好是找到conf下的nginx.conf文件。

但遗憾的是，容器运行的Nginx所有的文件都在容器内部。所以我们必须利用数据卷将两个目录与宿主机目录关联，方便我们操作。

10

2、相关命令

命令 说明 文档地址
docker volume create 创建数据卷 docker volume create
docker volume ls 查看所有数据卷 docs.docker.com
docker volume rm 删除指定数据卷 docs.docker.com
docker volume inspect 查看某个数据卷的详情 docs.docker.com
docker volume prune 清除数据卷 docker volume prune

3、小例子

  1. 首先创建容器并指定数据卷，注意通过 -v 参数来指定数据卷

    1
    docker run -d --name nginx -p 80:80 -v html:/usr/share/nginx/html nginx

  2. 查看数据卷

    1
    docker volume ls

    11_1

  3. 查看数据卷详情

    1
    docker volume inspect html

    11_2

  4. 查看/var/lib/docker/volumes/html/_data目录

    1
    ll /var/lib/docker/volumes/html/_data

    11_3

  5. 进入该目录，并随意修改index.html内容

    1
    2
    3
    cd /var/lib/docker/volumes/html/_data

    vi index.html

  6. 打开页面，查看效果

  7. 进入容器内部，查看/usr/share/nginx/html目录内的文件是否变化

    1
    2
    3
    docker exec -it nginx bash

    ls /usr/share/nginx/html

    11_7

4、挂载本地自定义目录

之前生成的数据卷都是在volume目录下。有时候我们需要挂载docker容器内目录到宿主机目录下

1
2
3
4
# 挂载本地目录
-v 本地目录:容器内目录
# 挂载本地文件
-v 本地文件:容器内文件

例如：

1
2
3
4
5
6
7
8
docker run -d \
  --name nginx \
  -p 18080:18080 \
  -p 18081:18081 \
  -v /root/nginx/html:/usr/share/nginx/html \
  -v /root/nginx/nginx.conf:/etc/nginx/nginx.conf \
  --network hmall \
  nginx

七、镜像

1、打包镜像

12

记录镜像结构的文件就称为Dockerfile，其对应的语法可以参考官方文档：

https://docs.docker.com/engine/reference/builder/

其中的语法比较多，比较常用的有：

指令 说明 示例
FROM 指定基础镜像 FROM centos:6
ENV 设置环境变量，可在后面指令使用 ENV key value
COPY 拷贝本地文件到镜像的指定目录 COPY ./xx.jar /tmp/app.jar
RUN 执行Linux的shell命令，一般是安装过程的命令 RUN yum install gcc
EXPOSE 指定容器运行时监听的端口，是给镜像使用者看的 EXPOSE 8080
ENTRYPOINT 镜像中应用的启动命令，容器运行时调用 ENTRYPOINT java -jar xx.jar

例如一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 指定基础镜像
FROM ubuntu:16.04
# 配置环境变量，JDK的安装目录、容器内时区
ENV JAVA_DIR=/usr/local
ENV TZ=Asia/Shanghai
# 拷贝jdk和java项目的包
COPY ./jdk8.tar.gz $JAVA_DIR/
COPY ./docker-demo.jar /tmp/app.jar
# 设定时区
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
# 安装JDK
RUN cd $JAVA_DIR \
 && tar -xf ./jdk8.tar.gz \
 && mv ./jdk1.8.0_144 ./java8
# 配置环境变量
ENV JAVA_HOME=$JAVA_DIR/java8
ENV PATH=$PATH:$JAVA_HOME/bin
# 指定项目监听的端口
EXPOSE 8080
# 入口，java项目的启动命令
ENTRYPOINT ["java", "-jar", "/app.jar"]

详细解释：

  1. 指定基础镜像

1
FROM ubuntu:16.04

  • FROM 指定了 Docker 镜像的基础镜像。在这里，基础镜像是 ubuntu:16.04，也就是 Ubuntu 16.04 操作系统的官方 Docker 镜像。

  • 这意味着构建的镜像将基于 Ubuntu 16.04，后续的操作和软件包安装都会在此操作系统基础上进行。

  1. 配置环境变量

1
2
ENV JAVA_DIR=/usr/local
ENV TZ=Asia/Shanghai

  • ENV 用于在 Docker 镜像中设置环境变量。

  • JAVA_DIR=/usr/local 定义了 JDK 的安装路径，在后续的步骤中会使用这个路径来安装和配置 JDK。

  • TZ=Asia/Shanghai 设置容器的时区为 上海时区 (Asia/Shanghai)，以确保容器内的时间与本地时间一致。

  1. 拷贝 JDK 和 Java 项目的包

1
2
COPY ./jdk8.tar.gz $JAVA_DIR/
COPY ./docker-demo.jar /tmp/app.jar

  • COPY 命令用于将本地的文件或目录复制到 Docker 镜像内的指定位置。

  • COPY ./jdk8.tar.gz $JAVA_DIR/ 将当前目录下的 jdk8.tar.gz 文件复制到 Docker 镜像的 $JAVA_DIR 目录中（即 /usr/local/）。

  • COPY ./docker-demo.jar /tmp/app.jar 将当前目录下的 docker-demo.jar 文件复制到 Docker 镜像中的 /tmp/ 目录，并重命名为 app.jar。

  1. 设置时区

1
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone

  • RUN 命令用于在镜像构建过程中执行一条命令。

  • ln -snf /usr/share/zoneinfo/$TZ /etc/localtime 创建一个符号链接，将容器内的时区设置为 Asia/Shanghai，这会影响容器的本地时间。

  • echo $TZ > /etc/timezone 将时区信息写入到 /etc/timezone 文件中，以确保系统和应用程序识别到正确的时区。

  1. 安装 JDK

1
2
3
RUN cd $JAVA_DIR \
 && tar -xf ./jdk8.tar.gz \
 && mv ./jdk1.8.0_144 ./java8

  • 这段代码通过以下几步安装 JDK：

    1. cd $JAVA_DIR 进入 $JAVA_DIR 目录（即 /usr/local/）。
    2. tar -xf ./jdk8.tar.gz 解压 jdk8.tar.gz 文件，安装 JDK 8。
    3. mv ./jdk1.8.0_144 ./java8 将解压后的 JDK 目录 jdk1.8.0_144 重命名为 java8，以便后续使用。

  1. 配置 JDK 环境变量

1
2
ENV JAVA_HOME=$JAVA_DIR/java8
ENV PATH=$PATH:$JAVA_HOME/bin

  • JAVA_HOME=$JAVA_DIR/java8 设置 JDK 安装路径的环境变量为 /usr/local/java8。

  • PATH=$PATH:$JAVA_HOME/bin 将 JDK 的 bin 目录添加到环境变量 PATH 中，这样就可以在容器中直接使用 java 和 javac 命令。

  1. 暴露端口

1
EXPOSE 8080

  • EXPOSE 命令指定容器监听的端口。在这里，容器将暴露端口 8080，这通常是 Java 应用（例如 Spring Boot 应用）监听的端口。

  • 它不会自动映射端口到主机系统，只是声明容器内应用将监听此端口，您在运行容器时还需要通过 docker run -p 映射到主机端口。

  1. 设置容器启动命令

1
ENTRYPOINT ["java", "-jar", "/app.jar"]

  • ENTRYPOINT 指定容器启动时执行的命令。

  • 在这里，java -jar /app.jar 会在容器启动时运行 Java 程序，即通过 java 命令执行 JAR 文件 /app.jar。

  • 这个命令会启动您的 Java 应用，因此容器启动后，应用程序会自动运行。

2、优化镜像生成

之前我们发现在创建java环境上非常麻烦。所以有人就帮我们配好了jdk

1
2
3
4
5
6
7
8
9
# 基础镜像
FROM openjdk:11.0-jre-buster
# 设定时区
ENV TZ=Asia/Shanghai
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
# 拷贝jar包
COPY docker-demo.jar /app.jar
# 入口
ENTRYPOINT ["java", "-jar", "/app.jar"]

紧接着就是构建镜像：

目录结构：

13

1
docker build -t docker-demo:1.0 .

八、网络

docker中可以创建一个虚拟网络。当容器互联的时候，只需要指定这个网络名。docker会自动帮它们两连接，解决写死IP导致的IP变化的问题

命令 说明 文档地址
docker network create 创建一个网络 docker network create
docker network ls 查看所有网络 docs.docker.com
docker network rm 删除指定网络 docs.docker.com
docker network prune 清除未使用的网络 docs.docker.com
docker network connect 使指定容器连接加入某网络 docs.docker.com
docker network disconnect 使指定容器连接离开某网络 docker network disconnect
docker network inspect 查看网络详细信息 docker network inspect

1、小例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
# 1.首先通过命令创建一个网络
docker network create hmall

# 2.然后查看网络
docker network ls
# 结果：
NETWORK ID     NAME      DRIVER    SCOPE
ee13adab5f92   bridge    bridge    local
d569c994b67c   hmall     bridge    local
f8f14c49d0d0   host      host      local
d0f2255320a5   none      null      local
# 其中，除了hmall以外，其它都是默认的网络

# 3.让dd和mysql都加入该网络，注意，在加入网络时可以通过--alias给容器起别名
# 这样该网络内的其它容器可以用别名互相访问！
# 3.1.mysql容器，指定别名为db，另外每一个容器都有一个别名是容器名
docker network connect hmall mysql --alias db
# 3.2.db容器，也就是我们的java项目
docker network connect hmall dd

# 4.进入dd容器，尝试利用别名访问db
# 4.1.进入容器
docker exec -it dd bash
# 4.2.用db别名访问
ping db
# 结果
PING db (172.18.0.2) 56(84) bytes of data.
64 bytes from mysql.hmall (172.18.0.2): icmp_seq=1 ttl=64 time=0.070 ms
64 bytes from mysql.hmall (172.18.0.2): icmp_seq=2 ttl=64 time=0.056 ms
# 4.3.用容器名访问
ping mysql
# 结果：
PING mysql (172.18.0.2) 56(84) bytes of data.
64 bytes from mysql.hmall (172.18.0.2): icmp_seq=1 ttl=64 time=0.044 ms
64 bytes from mysql.hmall (172.18.0.2): icmp_seq=2 ttl=64 time=0.054 ms

加入相同网络的容器可以在容器内部通过容器名或者是别名连接

九、项目部署

1、部署java项目

  1. 首先将java项目打包，然后配置好镜像信息加载镜像即可

    例如Dockerfile：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    # 基础镜像
    FROM openjdk:11.0-jre-buster
    # 设定时区
    ENV TZ=Asia/Shanghai
    RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
    # 拷贝jar包
    COPY hm-service.jar /app.jar
    # 入口
    ENTRYPOINT ["java", "-jar", "/app.jar"]

  2. 将dockerfile和jar包放到一个文件夹下然后build

    1
    docker build -t hmall .

  3. 运行容器

    1
    docker run -d --name hmall --network hmall -p 8080:8080 hmall

2、部署前端项目

  1. 配置数据卷，直接运行nginx，将数据卷目录和前端资源目录映射

    1
    2
    3
    4
    5
    6
    7
    8
    docker run -d \
      --name nginx \
      -p 18080:18080 \
      -p 18081:18081 \
      -v /root/nginx/html:/usr/share/nginx/html \
      -v /root/nginx/nginx.conf:/etc/nginx/nginx.conf \
      --network hmall \
      nginx

3、DockerCompose

可以将部署java项目以及前端项目合并

docker-compose.yml文件基本语法

docker run 参数 docker compose 指令 说明
–name container_name 容器名称
-p ports 端口映射
-e environment 环境变量
-v volumes 数据卷配置
–network networks 网络

例子：

原本运行mysql容器命令如下：

1
2
3
4
5
6
7
8
9
10
docker run -d \
  --name mysql \
  -p 3306:3306 \
  -e TZ=Asia/Shanghai \
  -e MYSQL_ROOT_PASSWORD=123 \
  -v ./mysql/data:/var/lib/mysql \
  -v ./mysql/conf:/etc/mysql/conf.d \
  -v ./mysql/init:/docker-entrypoint-initdb.d \
  --network hmall
  mysql

用docker-compose.yml文件定义 :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
version: "3.8"

services:
  mysql:
    image: mysql
    container_name: mysql
    ports:
      - "3306:3306"
    environment:
      TZ: Asia/Shanghai
      MYSQL_ROOT_PASSWORD: 123
    volumes:
      - "./mysql/conf:/etc/mysql/conf.d"
      - "./mysql/data:/var/lib/mysql"
    networks:
      - new
networks:
  new:
    name: hmall

一个完整例子docker-compose.yml：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
version: "3.8"

services:
  mysql:
    image: mysql
    container_name: mysql
    ports:
      - "3306:3306"
    environment:
      TZ: Asia/Shanghai
      MYSQL_ROOT_PASSWORD: 123
    volumes:
      - "./mysql/conf:/etc/mysql/conf.d"
      - "./mysql/data:/var/lib/mysql"
      - "./mysql/init:/docker-entrypoint-initdb.d"
    networks:
      - hm-net
  hmall:
    build: 
      context: .
      dockerfile: Dockerfile
    container_name: hmall
    ports:
      - "8080:8080"
    networks:
      - hm-net
    depends_on:  #这里的依赖则说明需要先加载mysql
      - mysql
  nginx:
    image: nginx
    container_name: nginx
    ports:
      - "18080:18080"
      - "18081:18081"
    volumes:
      - "./nginx/nginx.conf:/etc/nginx/nginx.conf"
      - "./nginx/html:/usr/share/nginx/html"
    depends_on: #这里的依赖则说明需要先加载hmall
      - hmall
    networks:
      - hm-net
networks:
  hm-net:
    name: hmall

基本语法：

1
docker compose [OPTIONS] [COMMAND]

其中，OPTIONS和COMMAND都是可选参数，比较常见的有：

类型 参数或指令 说明
Options -f 指定compose文件的路径和名称
-p 指定project名称。project就是当前compose文件中设置的多个service的集合，是逻辑概念
Commands up 创建并启动所有service容器
down 停止并移除所有容器、网络
ps 列出所有启动的容器
logs 查看指定容器的日志
stop 停止容器
start 启动容器
restart 重启容器
top 查看运行的进程
exec 在指定的运行中容器中执行命令

把构建过程需要的文件放在一个目录下执行：

14

1
docker compose up -d