Docker Compose详细教程（从入门到放弃）-阿里云开发者社区

博主介绍：Java领域优质创作者,博客之星城市赛道TOP20、专注于前端流行技术框架、Java后端技术领域、项目实战运维以及GIS地理信息领域。

🍅文末获取源码下载地址🍅

👇🏻 精彩专栏推荐订阅👇🏻 欢迎点赞收藏评论拍砖........

【Docker Swarm总结】《容器技术 Docker+K8S专栏》✅

【uniapp+uinicloud多用户社区博客实战项目】《完整开发文档-从零到完整项目》✅

【Springcloud Alibaba微服务分布式架构 | Spring Cloud】《系列教程-更新完毕》✅

【SpringSecurity-从入门到精通】《学习完整笔记-附（完整demo源码）》✅

【从零开始Vue项目中使用MapboxGL开发三维地图教程】《系列教程-不定时更新》✅

【Vue.js学习详细课程系列】《共32节专栏收录内容》✅

感兴趣的可以先收藏起来相关问题都可以给我留言咨询，希望帮助更多的人。

对于现代应用来说，大多都是通过很多的微服务互相协同组成的一个完整应用。例如，
订单管理、用户管理、品类管理、缓存服务、数据库服务等，它们构成了一个电商平台的应
用。而部署和管理大量的服务容器是一件非常繁琐的事情。而 Docker Compose 就是解决这类问题的。

1、简介

Docker Compose 是一个需要在 Docker 主机上进行安装的 Docker 容器编排外部工具。其

并不是通过脚本或各种冗长的 Docker 命令来将应用组件组织起来，而是通过一个声明式的

配置文件描述整个应用，然后通过一条命令完成应用部署。部署成功后，还可通过一系列简

单命令实现对其完整生命周期的管理。

Docker Compose 的前身是 Fig（无花果）。

2、compose 文件

2.1 文件简介

Docker Compose 使用 YAML 文件来定义服务。官方推荐的默认文件名为 compose.yml ，

但同时也支持 docker-compose.yml。

由于一个 compose 文件中定义的为一个项目的所有服务，所以一般为在创建 compose

文件之前先新建一个目录，目录名称一般为项目名称，然后再将项目所需的所有镜像、微服

务的 Dockerfile 放入该目录，并在该目录中新建 compose 文件。

compose 文件中包含 6 个顶级属性：version、services、networks、volumes、configs 与secrets，及很多的它们下面所包含的属性。下面简单介绍一下常用的属性。

2.2 version

version 是一个顶级属性，但已经过时，不再需要在 compose 文件中出现了。

2.3 serivces

services 是一个顶级属性，用于定义一个应用中所包含的服务。Docker Compose 会将每

个服务部署在各自的容器中。其下包含的第一级的属性即为服务名称，这个名称可以根据服

务内容随意命名。而在服务名称下还可包含很多的属性，常用属性如下：

（1） build

用于指定一个 Dockerfile 的路径。而该 Dockerfile 则是用于创建当前服务镜像的。这个

路径可以是以斜杠(/)开头的绝对路径，也可以是相对于当前 compose 文件的、以点(.)号开头

的相对路径。

如果 Dockerfile 文件名不是默认名称，则需要通过 build 下的 context 属性指定路径，

dockerfile 属性指定文件名。

例如，

build:
 context: ./
 dockerfile: myDockerfile

（2） image

用户指定当前服务所需要使用的镜像，这个镜像可以是本地镜像，也可以是远程镜像仓

库中的镜像(会自动 pull)。

如果设置了 build，此时再设置的 image 属性即为构建出的镜像的名称与 Tag。

（3） container_name

该属性用于设置容器名称，但并不是必须的。如果没有设置该属性，容器名称则会采用

“合成方式”。而合成时需要用到 services 下的第一级属性。

在 services 下存在一级属性，称为服务名称。该级属性是作为 services 下的第一级属性

出现的。服务名称将来会作为容器名称的一部分出现。容器的名称格式为：当前 compose

文件所在目录名_ 服务名称。

如果在 services 下没有指定 image 属性，而是使用 bild 属性，即没有现成的镜像，而是

根据 build 下指定的 Dockerfile 生成镜像，此时生成的镜像名称格式为：当前 compose 文件

所在目录名-服务名称。

（4） ports

一个列表。前面为暴露出的端口号，后面为容器中应用的端口号。如果仅设置了一个端

口号，那么这个端口号是容器中应用的端口号，其暴露到宿主机的端口号会被随机分配。

ports:
 - 80:80 # 绑定容器的 80 端口到主机的 80 端口
 - 9000:80 # 绑定容器的 80 端口到主机的 9000 端口
 - 443 # 绑定容器的 443 端口到主机的任意端口，容器启动时随机分配绑定的主机端口号

（5） command

用于覆盖 Dockerfile 中的 CMD 指令内容，即启动该服务容器后立即运行的命令。如果

直接按照Dockerfile中的CMD指令内容执行即可，则compose文件中无需该command属性。

（6） depends_on

一个列表。用于指定当前服务的启动所依赖的应用名称。即列表中指定的服务会先于当

前服务启动。

（7） deploy

用于指定当前服务容器的部署设置。其下有一个常用属性 replicas，用于指定该服务启

动的容器的数量。即实现一个服务多个容器。一旦指定了 deploy:replicas，就不能再指定

container_name 属性了。因为各个启动的容器名称不能相同，而只能由系统自动生成。

services:
 frontend:
 image: awesome/webapp
 deploy:
 mode: replicated
 replicas: 6

（8） networks

用于指定当前服务容器要连接到的网络。该网络必须是已经存在的，或通过顶级属性

networks 创建的网络。

（9） volumes

用于指定当前服务容器所使用到的所有 volume。这些 volume 可以使用路径与卷标两种方式。

例如，下面是路径方式，非常直观，易于查看，但需要管理本地路径。

db:
 image: mariadb:latest
 ports:
 - "3306:3306"
 volumes:
 - /etc/mysql:/var/lib/mysql

再如，下面是卷标方式，backend 与 backup 两个服务共享了 db-data 的卷，逻辑简洁明

了，且无需管理本地路径。但具体卷标所代表的是 Docker 主机的哪个路径，并不能直观的

看到。需要通过 docker volume inspect [卷标]来查看。

services:
 backend:
 image: awesome/database
 volumes:
 - db-data:/etc/data
 backup:
 image: backup-service
 volumes:
 - db-data:/var/lib/backup/data
volumes:
 db-data:

2.4 networks

networks 作为一个顶级属性，用于定义和创建应用中所使用到的所有网络。其下包含的

第一级属性即为网络名称，这个网络名称可以随意命名。而在网络名称下还可包含很多的属

性，常用属性如下：

services:
  app:
    networks:
     - app_bridge: #这里使用的并不是网络名称
networks:
  app_bridge:
    name: appBGnet # 这才是网络名称
    driver: bridge

（1） name

networks 下的第一级属性—网络名称，并不是真正的网络名称，而仅仅是网络名称的一

部分。在真正生成网络后，其真正的网络名称格式为：当前 compose 文件所在目录名_

networks 下的第一级属性。

但如果设置了name属性，则网络名称即为这里指定的名称，不会出现名称再合成情况。

（2） driver

用于指定网络驱动，缺省驱动为 Bridge。

（3） attachable

如果该属性设置为 true，则除了当前 compose 中定义的服务外，其它独立容器也可以

连接到此网络，并能与该网络中的服务及也连接到该网络的其它独立容器通信。缺省状态为

false。

2.5 volumes

volumes 作为一个顶级属性，用于定义和创建应用中所使用到的所有 volume。其下包含

的第一级属性即为 volume 的卷标，这个卷标可以随意命名。这个卷标所代表的是当前Docker主机中的目录，至于该目录的具体位置，是由系统自动分配的。

在网络名称下还可包含很多的属性，但这些属性并不常用，所以这里不进行介绍了。

3、常用命令

Docker Compose通过docker-compose系列命令查看和控制compose中的所有服务容器。

docker-compose pull #拉取 compose 中服务依赖的全部镜像或指定镜像。通过在命令后添加服务名称来指定。
 
docker-compose config #检查 compose 文件是否正确。可添加选项-q，表示只有存在问题时才有输出。
 
docker-compose up #启动 compose 中的所有容器。-d 选项表示后台启动。
 
docker-compose logs #查看 comopse 中所有服务或指定服务的运行日志。通过在命令后添加服务名称来指定。默认情况下，将对不同的服务日志使用不同的颜色来区分。
 
docker-compose ps #列出 compose 中所有服务或指定服务。通过在命令后添加服务名称来指定。
 
docker-compose top #列出 compose 中当前正在运行的所有服务或指定服务。通过在命令后添加服务名称来指定。
 
docker-compose images #列出 compose 中所有服务或指定服务对应的镜像。通过在命令后添加服务名称来指定。
 
docker-compose port #列出指定服务容器的指定端口所映射的宿主机端口。
 
docker-compose run #在指定服务上执行一条命令。
 
docker-compose exec #进入指定服务容器。通过在命令后添加服务名称来指定。
 
docker-compose pause #暂停 compose 中所有服务容器或指定服务容器。通过在命令后添加服务名称来指定。
 
docker-compose unpause #恢复 compose 中处于暂停状态的所有服务容器或指定服务容器。通过在命令后添加服务名称来指定。
 
docker-compose stop #停止 compose 中所有服务容器或指定服务容器。通过在命令后添加服务名称来指定。
 
docker-compose restart #重启 compose 中所有服务容器或指定服务容器。通过在命令后添加服务名称来指定。
 
docker-compose start #启动 compose 中所有服务容器或指定服务容器。通过在命令后添加服务名称来指定。
 
docker-compose kill #通过发送 SIGKILL 信号停止指定服务的容器。
 
docker-compose rm #删除 compose 中的、处于停止状态的所有服务容器或指定服务容器。通过在命令后添加服务名称来指定。
 
docker-compose down #停止并删除 compose 中的所有服务容器、网络、镜像、数据卷。

4、安装

4.1 下载安装包

将上述文件copy到 /usr/local/bin目录下。

4.2 添加可执行权限

为 docker-compose 文件添加可执行权限。

chmod +x /usr/local/bin/docker-compose

查看文件：

ll /usr/local/bin

4.3 测试

通过 docker-compose version 测试安装是否成功。

docker-compose version

5、项目构建

5.1 项目代码

（1）功能描述

这是一个 Spring Boot 工程。控制器具有三个接口：查询所有、根据名称查询、新增记录。整个架构包含一个 Redis 与 MySQL服务器。

（2） pom依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.17</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>
  <groupId>com.tigerhhzz</groupId>
  <artifactId>demo</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>demo</name>
  <description>Demo project for Spring Boot</description>
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <java.version>1.8</java.version>
  </properties>
  <dependencies>
 
    <!--spring boot 与 redis 整合依赖-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!--lombok-->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
    </dependency>
 
    <!--mybatis 与 spring boot 整合依赖-->
    <dependency>
      <groupId>org.mybatis.spring.boot</groupId>
      <artifactId>mybatis-spring-boot-starter</artifactId>
      <version>1.3.2</version>
    </dependency>
 
    <!--mysql 驱动-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.47</version>
    </dependency>
 
    <!-- druid 驱动 -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.12</version>
    </dependency>
 
    <!--tomcat 内置的 JSP 解析器-->
    <dependency>
      <groupId>org.apache.tomcat.embed</groupId>
      <artifactId>tomcat-embed-jasper</artifactId>
    </dependency>
 
    <!--jstl 依赖-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
 
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
 
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
    </dependency>
 
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>
 
  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>
 
</project>

（3）实体类

package com.tigerhhzz.entities;
 
import lombok.Data;
 
import java.io.Serializable;
 
/**
 * @Author tigerhhzz
 * @Date 2023 11 06 14 18
 **/
@Data
public class Product implements Serializable {
 
        private Integer id;
        //产品名称
        private String name ;
        //年化利率
        private Double rate;
        //募集总额
        private Double amount;
        //已募集金额
        private Double raised;
        //产品周期
        private Integer cycle;
        //产品募集结束时间
        private String endTime;
 
}

（4） sql 文件

以下是生成 product 表及相应数据的 SQL 文件内容。

CREATE DATABASE IF NOT EXISTS `test`;
USE `test`;
DROP TABLE IF EXISTS `product`;
CREATE TABLE `product` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `name` varchar(20) DEFAULT NULL,
 `rate` double DEFAULT NULL,
 `amount` double DEFAULT NULL,
 `raised` double DEFAULT NULL,
 `cycle` int(11) DEFAULT NULL,
 `endTime` char(10) DEFAULT '0',
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8;

INSERT INTO `product` VALUES 
(1,'TXTY',2.76,50000,20000,30,'2022-07-10'),(2,'GTTY',2.86,30000,30000,60,'2
022-07-12'),(3,'GTGX',2.55,60000,50000,90,'2022-07-09'),(4,'GFMA',2.96,30000
,20000,7,'2022-05-10'),(5,'TYXD',2.65,80000,60000,20,'2022-07-05'),(6,'HNSY'
,3.05,30000,20000,10,'2022-06-10'),(7,'HNSX',2.76,50000,30000,30,'2022-07-02
'),(8,'LXSY',2.86,30000,20000,20,'2022-07-11');

（5） Controller 类

package com.tigerhhzz.controller;
 
import com.tigerhhzz.entities.Product;
import com.tigerhhzz.service.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
 
import java.util.List;
 
/**
 * @Author tigerhhzz
 * @Date 2023 11 06 14 28
 **/
@RestController
public class Productcontroller {
 
    @Autowired
    private ProductService productService;
 
    @GetMapping("/")
    public String indexHandle() {
        //查询所有产品
        List<Product> allProducts = productService.findAllProducts();
        StringBuilder sb = new StringBuilder();
        for (Product product : allProducts) {
            sb.append(product).append("<br>");
        }
        return sb.toString();
    }
 
    //上架新产品
    @PostMapping("/register")
    public String registerHandle(@RequestBody Product product) {
        //添加新产品
        productService.saveProduct(product);
        return "save success" ;
    }
 
    //根据产品名称查询产品
    @GetMapping("/list")
    public String listHandle(String name) {
        List<Product> result = productService.findProductsByName(name);
        StringBuilder stringBuilder = new StringBuilder();
 
        for (Product product : result) {
            stringBuilder.append(product).append("<br>");
        }
        return stringBuilder.toString();
    }
 
}

（6） Service 接口

package com.tigerhhzz.service;
 
import com.tigerhhzz.entities.Product;
 
import java.util.List;
 
/**
 * @Author tigerhhzz
 * @Date 2023 11 06 14 47
 **/
public interface ProductService {
    void saveProduct(Product product);
 
    List<Product> findAllProducts();
 
    List<Product> findProductsByName(String name);
}

（7） Service 实现类

package com.tigerhhzz.service;
 
import com.tigerhhzz.entities.Product;
import com.tigerhhzz.dao.ProductDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import java.util.List;
 
/**
 * @Author tigerhhzz
 * @Date 2023 11 06 14 49
 **/
@Service
public class ProductServiceImpl implements ProductService {
    @Autowired
    private ProductDao dao;
 
    @Override
    @Transactional(rollbackFor = Exception.class)
    @CacheEvict(value = "pc", allEntries = true)
    public void saveProduct(Product product) {
        dao.insertProduct(product);
    }
 
    @Cacheable(value = "pc", key = "'product_' +#name")
    @Override
    public List<Product> findProductsByName(String name) {
        return dao.selectProductsByName(name);
    }
 
    @Cacheable(value = "pc", key = "'product_all'")
    @Override
    public List<Product> findAllProducts() {
        return dao.selectAllProducts();
    }
}

（8） Dao 接口

package com.tigerhhzz.dao;
 
import com.tigerhhzz.entities.Product;
import org.apache.ibatis.annotations.Mapper;
 
import java.util.List;
 
/**
 * @Author tigerhhzz
 * @Date 2023 11 06 14 52
 **/
@Mapper
public interface ProductDao {
 
    void insertProduct(Product product);
 
    List<Product> selectAllProducts();
 
    List<Product> selectProductsByName(String name);
}

（9）映射文件

在 src/resources 资源目录中定义 ProductDao.xml 映射文件。

<?xml version="1.0" encoding="UTF-8" ?>
        <!DOCTYPE mapper
                PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
                "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.tigerhhzz.dao.ProductDao">
 
    <insert id="insertProduct">
        insert into product(id,name, rate, amount, raised, cycle, endTime)
        values(#{id},#{name}, #{rate}, #{amount}, #{raised}, #{cycle}, #{endTime})
    </insert>
 
    <select id="selectAllProducts" resultType="com.tigerhhzz.entities.Product">
        select id, name, rate, amount, raised, cycle, endTime from product
    </select>
 
    <select id="selectProductsByName" resultType="com.tigerhhzz.entities.Product">
        select id, name, rate, amount, raised, cycle, endTime
        from product
        where name like '%' #{name} '%'
    </select>
 
 
</mapper>

（10）配置文件

这里特别要注意 mysql 与 redis 的 IP，使用的是相应 Docker 主机的 IP。

# 注册mybatis
mybatis:
  # 注册映射文件
  mapper-locations: classpath:*.xml
  # 注册实体类别名
  type-aliases-package: com.tigerhhzz.entities
 
 
# 注册数据源
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://192.168.162.100:3306/test?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai&tinyInt1isBit=false
    username: root
    password: 123456
  #  messages:
  #    basename: i18n/message
  #    encoding: utf-8
  #  #与Redis整合
  redis:
    # 配置单机版redis
    host: 192.168.162.100
    port: 6379
    password: 12345
    #连接sentinel高可用集群
    #sentinel:
    #master: mymaster
    #nodes: redisOS:26380,redisOS:26381,redisOS:26382
 
    #连接Redis分布式系统
    #cluster:
    #nodes: redisOS:6380,redisOS:6381,redisOS:6382,redisOS:6383,redisOS:6384,redisOS:6385
 
  cache:
    type: redis  #指定缓存类型
    cache-names: pc #指定缓存空间名称，随意
#配置logback日志控制
logging:
  charset:
    file: "/var/applogs/finance.log" #文件输出路径
  pattern:
#    file: level-%-5level - %msg%n     #文件输出
    console: level-%-5level - %msg%n  #控制台输出
#  file:
#    name: "/var/applogs/finance.log" #文件输出路径
#  level:
#    root: warn #全局最低输出级别
#    com.tigerhhzz.dao: debug #特定包下的级别

（11）启动类

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

springboot完整demo项目下载链接：

https://download.csdn.net/download/weixin_43025151/88537578

5.2 项目打包

将项目 package 打为 jar 包，然后再上传到 Docker 主机的/root/demo 目录中。

5.3 定义 Dockerfile

在 Docker 主机的任意目录中新建一个目录，该新建目录名称与项目名称相同。这里在

/root 目录中 mkdir 一个名称为demo的目录。然后在该目录中新建 Dockerfile 文件。

# 指定当前镜像继承自 openjdk:8u102，因为下面要运行 Jar 包，需要 JDK 环境
FROM openjdk:8u102
# 作者与项目相关说明
MAINTAINER tiger tigerhhhzz@163.com
LABEL version="1.0" description="this is a spring boot application"
# 将当前目录下的 jar 包 copy 到容器中。
# 注意，这个当前目录指的是 docker build 命令最后一个参数指定的上下文路径
COPY demo.jar demo.jar
# 一定要执行的 exec
ENTRYPOINT ["java", "-jar", "demo.jar"]
# 指定对外暴露的端口号
EXPOSE 8080

6、Compose 编排启动项目

使用 Docker Compose 可以 mysql 与 redis 的 IP 进行了软编码。使得当前应用访问的 mysql 与 redis可以运行在如何容器中。方便以后维护！！

6.1 定义 compose.yml

在 demo目录中新建一个文件 compose.yml。

vi compose.yml

services:
  app:
    build: ./
    container_name: myapp
    ports:
      - 9000:8080
    volumes:
      - ./logs:/var/applogs
    depends_on:
      - mysql
      - redis
 
  mysql:
    image: mysql:latest
    environment:
      MYSQL_ROOT_PASSWORD: 123456
    ports:
      - 3306:3306
    volumes:
      - /root/mysql/log:/var/log/mysql
      - /root/mysql/data:/var/log/mysql
      - /root/mysql/conf:/etc/mysql/conf.d
 
  redis:
    image: redis:latest
    ports:
      - 6379:6379
    volumes:
      - /root/redis/redis.conf:/etc/redis/redis.conf
      - /root/redis/data:/data
    command: redis-server /etc/redis/redis.conf

6.2 修改应用

（1）修改配置文件

对于应用程序，需要修改其配置文件 application.yml。将 mysql 与 redis 的主机名修改为它们相应服务的名称。

（2）重新打包上传

由于应用程序的配置文件发生了变化，所以需要对应用程序重新进行 package 打包，并

将新的 jar 包上传到 Linux 系统中的/root/demo 目录中。

6.3 启动所有容器

docker-compose up -d

6.4 写入 mysql 数据

（1）进入 mysql

docker ps -a
 
docker exec -it fadc954dadf8  /bin/bash
 
 mysql -uroot -p

（2）准备数据

复制前面的 sql 文件中的内容，直接粘贴到 mysql 命令行即可。

CREATE DATABASE IF NOT EXISTS `test`;
 
USE `test`;
DROP TABLE IF EXISTS `product`;
CREATE TABLE `product` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `name` varchar(20) DEFAULT NULL,
 `rate` double DEFAULT NULL,
 `amount` double DEFAULT NULL,
 `raised` double DEFAULT NULL,
 `cycle` int(11) DEFAULT NULL,
 `endTime` char(10) DEFAULT '0',
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8;
 
INSERT INTO `product` VALUES 
(1,'TXTY',2.76,50000,20000,30,'2022-07-10'),(2,'GTTY',2.86,30000,30000,60,'2
022-07-12'),(3,'GTGX',2.55,60000,50000,90,'2022-07-09'),(4,'GFMA',2.96,30000
,20000,7,'2022-05-10'),(5,'TYXD',2.65,80000,60000,20,'2022-07-05'),(6,'HNSY'
,3.05,30000,20000,10,'2022-06-10'),(7,'HNSX',2.76,50000,30000,30,'2022-07-02
'),(8,'LXSY',2.86,30000,20000,20,'2022-07-11');

6.5 访问应用

启动项目的访问方式http://192.168.162.100:9002/

6.6 指定各组件名称

前面的 compose.yml 文件中应用生成的镜像采用的是默认名称，mysql 与 redis 生成的容

器名称采用的是默认名称，生成并加入的 bridge 网络也称默认名称的网络。这些组件的所

使用的默认名称，也可以被指定名称所代替。

（1）定义 compose2.yml

services:
  app:
    build: ./
    container_name: myapp
    image: mydemo:2.0
    ports:
      - 9003:8080
    volumes:
      - ./logs:/var/applogs
    networks:
      - tigernetworks
    depends_on:
      - mysql
      - redis
 
  mysql:
    image: mysql:latest
    container_name: tigermysql
    environment:
      MYSQL_ROOT_PASSWORD: 123456
    ports:
      - 3306:3306
    volumes:
      - /root/mysql/log:/var/log/mysql
      - /root/mysql/data:/var/log/mysql
      - /root/mysql/conf:/etc/mysql/conf.d
    networks:
      - tigernetworks
 
  redis:
    image: redis:latest
    container_name: tigerredis
    ports:
      - 6379:6379
    volumes:
      - /root/redis/redis.conf:/etc/redis/redis.conf
      - /root/redis/data:/data
    networks:
      - tigernetworks
    command: redis-server /etc/redis/redis.conf
networks:
  tigernetworks:

（2）启动所有容器

这里通过-f 选项指定要使用的 compose 文件。

docker-compose -f compose2.yml up -d

（3）查看容器

查看容器，可以看到容器名称为指定的名称。

（4）查看网络

此时查看网络可以看到，又新生成一个网络。对于生成的网络，其生成的名称为“当前

compose 文件所在目录名_ networks 下的第一级属性”。

docker network ls

（5）查看网络详情

通过 docker network inspect demo_tigernetworks命令，查看该网络的详情，可以看到，compose

中定义的三个服务容器都在该网络中。

docker network inspect demo_tigernetworks

Docker Compose详细教程（从入门到放弃）