为什么要使用 Docker Compose ？

# 前言

我们学习了 Nest、Mysql、Redis，并且在 Nest 里远程连接 Mysql 和 Redis 来做数据存储、增删改查。

Mysql 和 Redis 都是跑在 Docker 容器里的。

部署 Nest 项目的时候也是跑的 dockerfile + docker build 产生的镜像。

这就涉及到了 3 个 Docker 容器：Nest、Mysql、Redis。

后面可能还会涉及到更多的 Docker 容器。

那么问题来了，每次想把项目跑起来都要 docker run 一堆镜像也太麻烦了，有没有什么简便方式呢？

而且，这么多的容器怎么保证启动顺序呢？

解决方式是有的，就是 Docker Compose。

# 我们先来看看不用 Docker Compose 的时候怎么部署：

nest new docker-compose-test -p npm

创建个 nest 项目：

# 安装 tyeporm、mysql2；

npm install --save @nestjs/typeorm typeorm mysql2

然后在 AppModule 引入 TypeOrmModule：

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AppController } from './app.controller';
import { AppService } from './app.service';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: "mysql",
      host: "localhost",
      port: 3306,
      username: "root",
      password: "guang",
      database: "aaa",
      synchronize: true,
      logging: true,
      entities: [],
      poolSize: 10,
      connectorPackage: 'mysql2',
      extra: {
          authPlugin: 'sha256_password',
      }
    }),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

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

这里的 database 我们在 mysql workbench 里创建下：

CREATE DATABASE `aaa` DEFAULT CHARACTER SET utf8mb4 ;

添加一个 aaa.entity.ts

import { Column, Entity, PrimaryGeneratedColumn } from "typeorm";

@Entity()
export class Aaa {
    @PrimaryGeneratedColumn()
    id: number;

    @Column({
        length: 30
    })
    aaa: string;

    @Column({
        length: 30
    })
    bbb: string;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

在 entities 里注册下：

然后把 nest 服务跑起来：

npm run start:dev

可以看到，执行了 create table 的 sql。

说明 mysql 是连接成功了。

# 然后再引入 redis：

npm install redis

添加一个 redis client 的 provider：

{
  provide: 'REDIS_CLIENT',
  async useFactory() {
    const client = createClient({
        socket: {
            host: 'localhost',
            port: 6379
        }
    });
    await client.connect();
    return client;
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

在 AppService 里注入下：

import { Controller, Get, Inject } from '@nestjs/common';
import { RedisClientType } from 'redis';
import { AppService } from './app.service';

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Inject('REDIS_CLIENT')
  private redisClient: RedisClientType;

  @Get()
  async getHello() {
    const keys = await this.redisClient.keys('*');
    console.log(keys);

    return this.appService.getHello();
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

这里用到的 mysql、redis 都是之前通过 docker 跑的：

忘记怎么跑 msyql 和 redis 的 docker 容器的同学去翻一下这两个的入门章节。

然后访问下 http://localhost:3000

打印了 redis 里的 key：

在 RedisInsight 里看到的也是这些：

这就说明 redis 服务连接成功了。

这里就不写具体的业务逻辑了。

# 假设我们 nest 服务开发完了，想部署，那就要写这样的 dockerfile：

FROM node:18.0-alpine3.14 as build-stage

WORKDIR /app

COPY package.json .

RUN npm install

COPY . .

RUN npm run build

# production stage
FROM node:18.0-alpine3.14 as production-stage

COPY --from=build-stage /app/dist /app
COPY --from=build-stage /app/package.json /app/package.json

WORKDIR /app

RUN npm install --production

EXPOSE 3000

CMD ["node", "/app/main.js"]

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

用多阶段构建的方式，最后只保留生产阶段的镜像。

用 alpine 的基础镜像，体积会减小很多。

这些前面讲过。

在根目录添加这个 Dockerfile，然后 docker build 一下：

docker build -t eee .

（我这里稍微有点久，用了 200 多秒）

在 docker desktop 里可以看到这个镜像：

# 那假设在服务器上，要怎么部署这个 nest 应用呢？

我们先把 mysql、redis 的容器停掉。

在服务器上，是没有 docker desktop 的，所以接下来我们通过命令行的方式：

# 先跑 mysql 的 docker 容器：

docker run -d -p 3306:3306 -v /Users/guang/mysql-data:/var/lib/mysql --name mysql-container mysql

-d 是 deamon，放到后台运行的意思。

-p 是端口映射

-v 是挂载数据卷，把宿主机目录映射到容器内的目录（这里要换成你自己的）

-name 是容器名

可能还需要指定环境变量：

-e MYSQL_ROOT_PASSWORD=xxx 设置 root 用户的密码

因为我之前跑过，在数据卷的那个目录有之前的设置，所以不用设置了。

跑起来可以看到容器 id：

# 然后再跑下 redis 的 docker 容器：

docker run -d -p 6379:6379 -v /Users/guang/aaa:/data --name redis-container redis

# 之后跑 nest 的：

docker run -d -p 3000:3000 --name nest-container eee

看下 3个容器的日志

docker logs mysql-container

docker logs redis-container

docker logs nest-container

# 这时候你会发现报错了，说是 127.0.0.1 的 6379 端口连不上。

为什么呢？

因为这时候 127.0.0.1 就是容器内的端口了，不是宿主机的。

所以要把 ip 换成宿主机 ip 才行。

查一下本机的 ip 地址：

然后把 AppModule 里的 redis 和 mysql 连接信息改一下：

之后重新 build 一个镜像：

docker build -t fff .

这次构建用了 120s，比上次快，因为本地有缓存了。

把之前的容器删掉：

docker rm nest-container

然后在数据库里把 aaa这个表删掉：

再跑 nest 容器：

docker run -d -p 3000:3000 --name nest-container fff

这时候再查看日志：

docker logs nest-container

这时候就正常了。

可以看到 sql 打印是正确的。

表也创建成功了：

浏览器访问下 http://localhost:3000

再次 docker logs 看看：

可以看到 redis 服务也连接成功了。

这样我们就把 mysql、redis、nest 3个 docker 容器跑了起来。

# 可以发现我们跑了 3 次 docker build，而且还要注意顺序，不然 nest 服务跑起来了，但是 mysql 服务没跑起来，就会报错。

# 前面说，docker compose 可以解决这种问题。

怎么解决呢？

把 3 个容器停掉：

docker stop nest-container mysql-container redis-container

# 然后在根目录添加一个 docker-compose.yml

services:
  nest-app:
    build:
      context: ./
      dockerfile: ./Dockerfile
    depends_on:
      - mysql-container
      - redis-container
    ports:
      - '3000:3000'
  mysql-container:
    image: mysql
    ports:
      - '3306:3306'
    volumes:
      - /Users/guang/mysql-data:/var/lib/mysql
    environment:
      MYSQL_DATABASE: aaa
      MYSQL_ROOT_PASSWORD: guang
  redis-container:
    image: redis
    ports:
      - '6379:6379'
    volumes:
      - /Users/guang/aaa:/data