docker-compose(3):入门与实战_docker compose 传入参数

一、docker-compose介绍

在真实项目，我们需要对微服务项目进行调测，此时我们必然需要部署多个微服务实例，才可以进行测试，这个操作过程非常繁琐，而且相互之间的依赖关系，会有启动顺序的影响，容易出错。
而此时compose应用而生，docker-compose用于定义运行多个容器，通过docker-compose.yml来实现对容器集群的编排工作。
Docker-compose管理三个内容：

• 工程：docker-compose的运行即可一个工程
• 服务： 对应工程的子项目
• 容器：服务对应的实例，一个实例可以对应多个容器。

二、部署使用

1. 单容器单服务的使用

1. 我们新建一个springboot工程

package com.it2.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RestController
public class HelloController {
    @GetMapping("/test1")
    public String hello(){
        log.info("test1!!!");
        return "hello test1";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2. 编写Dockerfile

FROM openjdk:8
EXPOSE 8080
ADD target/*.jar /app.jar
ENTRYPOINT ["java", "-jar", "app.jar"]
1
2
3
4

3. 编写docker-compose.yml

# 使用的yml版本
version: "3.9"
services:
  # 服务名称，可以自定义
  test1:
    # 容器名称，可以自定义
    container_name: mytest1
    # 指定Dockerfile所在的目录
    build: .
    # 映射端口
    ports:
      - "8888:8080"
1
2
3
4
5
6
7
8
9
10
11
12

4. 打包上传文件(结构如图)
   
5. 然后执行命令docker-compose up一键编排启动，该步骤自动完成，分为两步

• 构建镜像docker build
• 启动yml文件指定的所有容器

6. 测试访问

7. 停止

docker-compose down
1

8. 移除镜像

docker rmi test1_test1
#或者
docker rmi [imageid]
1
2
3

2. 多服务多容器依赖

平时我们的项目开发，往往需要使用到redis，mysql等服务，此时我们就需要让被依赖的服务先启动。
继续改造项目，我们引入redis。

1. 配置pom依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
1
2
3
4

2. 配置application.yml文件

spring:
  redis:
    host: ${REDIS_HOST:127.0.0.1}
    port: ${REDIS_PORT:6379}
    lettuce:
      pool:
        max-active: 300
        max-idle: 30
        min-idle: 5

1
2
3
4
5
6
7
8
9
10

3. 配置redis序列化和反序列化的配置

package com.it2.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
@AutoConfigureAfter(RedisAutoConfiguration.class)
public class RedisConfig {

    /**
     * 配置自定义redisTemplate
     * @return
     */
    @Bean
    RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {

        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);

        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值
        Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(mapper);

        template.setValueSerializer(serializer);
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(serializer);
        template.afterPropertiesSet();
        return template;
    }

}
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
45
46

4. 稍微改动HelloController，实现每次访问自增+1

package com.it2.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RestController
public class HelloController {

    @Autowired
    private RedisTemplate redisTemplate;

    @GetMapping("/test1")
    public String hello(){
        log.info("test1!!!");
        Long counter = redisTemplate.opsForValue().increment("counter");
        return "hello test1,counter:"+counter;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

5. 修改docker-compose.yml，添加对redis的依赖

# 使用的yml版本
version: "3.9"
services:
  # 服务名称，可以自定义
  test1:
    # 容器名称，可以自定义
    container_name: mytest1
    # 指定Dockerfile所在的目录
    build: .
    # 映射端口
    ports:
      - "8888:8080"
    depends_on:
      - myredis
    environment:
      - REDIS_HOST=myredis
      - REDIS_PORT=6379

  myredis:
    image: "redis:latest"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

6. 重新打包上传文件
   
7. 启动编排运行docker-compose up --build
   

8 测试访问

9 停止

docker-compose down
1

3. 多服务多容器独立

根据《 2. 多服务多容器依赖》的案例，我们继续扩展新增一个test2子项目

1. 新建test2子项目
   controller

package com.it2.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RestController
public class HelloController {
    @GetMapping("/test2")
    public String hello(){
        log.info("test2!!!");
        return "hello test2";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Dockerfile

FROM openjdk:8
EXPOSE 8081
ADD target/*.jar /app.jar
ENTRYPOINT ["java", "-jar", "app.jar"]
1
2
3
4

2. 编写docker-compose.yml

# 使用的yml版本
version: "3.9"
services:
  # 服务名称，可以自定义
  test1:
    # 容器名称，可以自定义
    container_name: mytest1
    # 指定Dockerfile所在的目录
    build: ./test1
    # 映射端口
    ports:
      - "8888:8080"
    depends_on:
      - myredis
    environment:
      - REDIS_HOST=myredis
      - REDIS_PORT=6379
  test2:
    # 容器名称，可以自定义
    container_name: mytest2
    # 指定Dockerfile所在的目录
    build: ./test2
    # 映射端口
    ports:
      - "8889:8081"
  myredis:
    image: "redis:latest"
    # 服务名称，可以自定义
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

3. 打包上传文件到服务器
   
4. 启动编排运行docker-compose up --build

5. 测试访问

4.单服务多服务部署

服务和容器是可以一对多的，那么这样我们可以将一个服务启动多个容器。但是由于compose是单机运行，服务名称是唯一的，所以我们不能指定名称，也不只能映射端口，只能让docker随机映射端口。
接下来，我们继续使用test2子工程的代码。

1. 编辑docker-compose.yml

# 使用的yml版本
version: "3.9"
services:
  # 服务名称，可以自定义
  test2:
    # 指定Dockerfile所在的目录
    build: .
    # 映射端口
    ports:
      - "8081"
1
2
3
4
5
6
7
8
9
10

2. 上传文件如图
   
3. 编排运行

#test2启动了两个容器
docker-compose up --build --scale test2=2
1
2

4. 访问测试

三、关于docker-compose向项目配置文件传参

除了《2. 多服务多容器依赖》中介绍的直接在docker-compose.yml的environment参数声明文件，同样可以采用env文件传参。

1. 新建docker-compose2.yml文件

# 使用的yml版本
version: "3.9"
services:
  # 服务名称，可以自定义
  test1:
    # 容器名称，可以自定义
    container_name: mytest1
    # 指定Dockerfile所在的目录
    build: .
    # 映射端口
    ports:
      - "8888:8080"
    depends_on:
      - myredis
    env_file:
      - test.env
  myredis:
    image: "redis:latest"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2. 新建test.env文件

REDIS_HOST=myredis
REDIS_PORT=6379
1
2

3. 上传文件
   

4. 启动运行

docker-compose -f docker-compose2.yml up
1

5. 测试访问

四、常用指令

以下命令中出现得[]里得参数都是可选的

1、ps命令
列出所有运行容器
docker-compose ps

2、logs命令
查看容器日志输出，-f表示查看实时日志，容器名表示启动后的容器名，不指定则查看所有启动的容器
docker-compose logs [-f] [容器名]

3、port命令
打印绑定的公共端口，下面命令可以输出demo1服务8080端口所绑定的公共端口
docker-compose port demo1 8080

4、build命令
构建或者重新构建服务
docker-compose build

5、start命令
启动指定停止的容器, 如下实例中demo1为一个容器，如果不指定，则启动所有已存在的
docker-compose start [demo1]

6、stop命令
停止已运行的容器，不指定则停止所有的
docker-compose stop [demo1]

7、rm命令
删除指定容器，必须为已停止的，如果不指定容器名，则删除所有
docker-compose rm [demo1]

8、up命令
构建和启动容器，-d为后台运行
docker-compose up [-d]

9、kill命令
通过发送SIGKILL信号来停止容器，不指定容器名则停止所有启动中的容器
docker-compose kill [demo1]

10、-f指定文件运行
指定文件运行
docker-compose -f doccker-compose2.yml up

参考文档

使用Docker compose发布SpringBoot项目