Java essay
Mr.Fire
2022-09-05
目录

Docker Compose介绍及使用

# 1.为什么需要Docker Compose？

在先前介绍Docker的内容中，我们从代码到部署容器需要经过两个步骤：

  • 打包镜像docker build
  • 部署启动容器docker run

这种方式有什么缺点？

  • 多次使用Dockerfile Build Image或者DockerHub拉取Image;
  • 需要创建多个Container，多次编写启动命令；
  • Container互相依赖的如何进行管理和编排；

在真实的企业级应用中，一个服务往往需要和很多个其它的服务进行关联，单个服务也有可能有多个容器实例，如果需要发布， 可能会需要人员手动对每一个容器进行打包和启动的操作，非常繁琐，容易出错。

在这种背景下，Docker Compose就有了用武之地。简单来说，Docker Compose是一个用于定义和运行多个容器的工具，通过docker-compose.yml来实现对容器集群的编排工作。

# 2.Docker Compose介绍

Docker Compose是一个用来定义和运行复杂应用的Docker工具。一个使用Docker容器的应用，通常由多个容器组成。使用Docker Compose不再需要使用shell脚本来启动容器。

Compose 通过一个配置文件来管理多个Docker容器，在配置文件中，所有的容器通过services来定义，然后使用docker-compose脚本来启动，停止和重启应用，和应用中的服务以及所有依赖服务的容器，非常适合组合使用多个容器进行开发的场景。

  • 工程，docker-compose运行的目录即为一个工程，在微服务场景下，我们往往都是使用git submodule的方式组建工程的，因此父项目就可以成为一个docker compose的工程；
  • 服务，对应子项目，一个工程可以包含多个子项目；
  • 容器，对应服务的实例，一个服务可以有多个实例；

Docker Compose当然也存在不足的地方，就是它只能用在单一host上进行容器编排，无法跨节点host对容器进行编排，那是Docker Swarm和K8s的范畴了。

# 3.Docker Compose安装

# 3.1.Linux安装

Linux 上我们可以从 Github 上下载它的二进制包来使用，最新发行的版本地址：https://github.com/docker/compose/releases (opens new window)

  1. 运行以下命令以下载 Docker Compose 的当前稳定版本：
sudo curl -L "https://github.com/docker/compose/releases/download/v2.2.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
1
  1. Docker Compose在GitHub，不太稳定。你也可以通过如下命令安装：
curl -L https://get.daocloud.io/docker/compose/releases/download/v2.4.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
1
  1. 将可执行权限应用于二进制文件
sudo chmod +x /usr/local/bin/docker-compose
1
  1. 创建软链
sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose
1
  1. 测试
docker-compose --version
1

# 3.2.Windows和Mac

Windows 、Mac 的 Docker 桌面版和 Docker Toolbox 已经包括 Compose 和其他 Docker 应用程序，因此 Mac 用户不需要单独安装Compose

# 4.Docker Compose使用

# 4.1单服务单容器使用

  1. 我们新建一个SpringBoot应用，仅仅包含一个Controller：
@Slf4j
@RestController
public class HelloController {

    @GetMapping("/getHello")
    public String getHello(){
        log.info("myapp works!");
        return "myapp is running ok!!!";
    }

}
1
2
3
4
5
6
7
8
9
10
11

请务必保证程序能正常运行，再进行如下操作。并进行package，打成jar包。

  1. 编写Dockerfile：
FROM openjdk:8
EXPOSE 8080
ADD  target/myapp-0.0.1-SNAPSHOT.jar /demo.jar
ENTRYPOINT ["java", "-jar", "demo.jar"]
1
2
3
4
  1. 编写docker-compose.yml文件
# 使用的yml版本
version: "3.9"
services:
  # 服务名称，可以自定义
  myapp:
    # 容器名称，可以自定义
    container_name: myapp
    # 指定Dockerfile所在的目录
    build: .
    ports:
      - "8080:8080"
1
2
3
4
5
6
7
8
9
10
11
  1. 然后执行docker-compose up即可，主要完成以下的两步操作：
  • 镜像构建docker build
  • 启动yml中的所有容器docker run

执行过程如下：

E:\myapp>docker-compose up
# 创建了默认类型的自定义网络，即bridge类型网络，而非使用默认的docker0桥接网络，拥有自己的独立网段，可以通过docker network ls及docker network inspect查看具体的网络信息
Creating network "myapp_default" with the default driver
Building myapp
[+] Building 0.5s (7/7) FINISHED
=> [internal] load build definition from Dockerfile                                                                                 0.0s
=> => transferring dockerfile: 153B                                                                                                 0.0s
=> [internal] load .dockerignore                                                                                                    0.0s
=> => transferring context: 2B                                                                                                      0.0s
=> [internal] load metadata for docker.io/library/openjdk:8                                                                         0.0s
=> [internal] load build context                                                                                                    0.2s
=> => transferring context: 17.62MB                                                                                                 0.1s
=> CACHED [1/2] FROM docker.io/library/openjdk:8                                                                                    0.0s
=> [2/2] ADD  target/myapp-0.0.1-SNAPSHOT.jar /demo.jar                                                                             0.1s
=> exporting to image                                                                                                               0.1s
=> => exporting layers                                                                                                              0.1s
# 将镜像写入本地的镜像仓库，并以项目名称_服务名称命名镜像
=> => writing image sha256:c387978706931f09fa16a737704f2c1047e8f632de192a25b0dc42dc151ac4c7                                         0.0s
=> => naming to docker.io/library/myapp_myapp                                                                                       0.0s

Use 'docker scan' to run Snyk tests against images to find vulnerabilities and learn how to fix them
WARNING: Image for service myapp was built because it did not already exist. To rebuild this image you must use `docker-compose build` or `docker-compose up --build`.
Creating myapp ... done
Attaching to myapp
myapp    |
myapp    |   .   ____          _            __ _ _
myapp    |  /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
myapp    | ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
myapp    |  \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
myapp    |   '  |____| .__|_| |_|_| |_\__, | / / / /
myapp    |  =========|_|==============|___/=/_/_/_/
myapp    |  :: Spring Boot ::                (v2.6.0)
......
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

到此，我们的单容器使用方式完成了。

# 4.2.常用命令

如下是一些常见的docker-compose操作(需要在工程目录下执行命令)：

  • 构建镜像并启动容器
docker-compose up
1
  • 停止容器，删除容器，移除自定义网络
docker-compose down
1
E:\myapp>docker-compose down
Stopping myapp ... done
Removing myapp ... done
Removing network myapp_default
1
2
3
4
  • 查看所有运行的容器
docker-compose ls
1
E:\myapp>docker-compose ps
Name         Command         State           Ports
-----------------------------------------------------------
myapp   java -jar demo.jar   Up      0.0.0.0:8080->8080/tcp`
1
2
3
4
  • 查看具体容器的日志，-f参数表示实时日志输出
docker-compose logs -f container_name
1
  • 查看和容器端口绑定的主机端口
docker-compose port container_name container_port
1
  • 停止指定的容器，如果不指定则停止所有的容器
docker-compose stop container_name
1
  • 启动指定的容器，如果不指定则停止所有的容器
docker-compose start container_name
1
  • 删除指定的已停止容器，如果不指定则删除所有已停止容器
docker-compose rm container_name
1
  • 构建或者重新构建服务的镜像，但不会创建和启动容器
docker-compose build
1

# 4.3.多服务多容器依赖使用

假设我们的应用需要依赖其它服务，比如需要使用redis，mysql等，那么这种场景下，就需要被依赖的容器先启动。

  1. 引入redis的支持依赖：
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>       
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>
1
2
3
4
5
6
7
8
  1. 增加redis的配置，容器启动的默认redis是没有密码的，所以不用配置password。
server:
  port: 8080
spring:
  redis:
    host: 127.0.0.1
    port: 6379
    lettuce:
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 0
1
2
3
4
5
6
7
8
9
10
11
  1. 增加redis的序列化和反序列化的配置：
@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
  1. 修改Controller的逻辑，使得返回的结果依赖redis：
@Slf4j
@RestController
public class HelloController {

    @Autowired
    private RedisTemplate redisTemplate;

    @GetMapping("/getHello")
    public String getHello(){
        log.info("myapp works!");
        Long counter = redisTemplate.opsForValue().increment("counter");
        return "myapp is running " + counter + "times!";
    }

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

如此，每次访问该接口都会使得计数器加1并返回结果。

  1. 修改docker-compose.yml
version: "3.9"
services:
  myapp:
    container_name: myapp
    build: .
    ports:
      - "8080:8080"
    depends_on:
      - myredis
  myredis:
    image: "redis:latest"
1
2
3
4
5
6
7
8
9
10
11
  1. 测试 其它内容不变，如此配置就全部完成了，注意在执行如下操作之前，先确保程序能够正常运行，可以先自行运行一个redis容器做下实验。

docker-compose up启动工程，过程如下：

......
Use 'docker scan' to run Snyk tests against images to find vulnerabilities and learn how to fix them
WARNING: Image for service myapp was built because it did not already exist. To rebuild this image you must use `docker-compose build` or `docker-compose up --build`.
Creating myapp           ... done
Creating myapp_myredis_1 ... done
Attaching to myapp_myredis_1, myapp
myredis_1  | 1:C 21 Nov 2021 03:19:06.934 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
myredis_1  | 1:C 21 Nov 2021 03:19:06.934 # Redis version=6.2.6, bits=64, commit=00000000, modified=0, pid=1, just started
myredis_1  | 1:C 21 Nov 2021 03:19:06.934 # Warning: no config file specified, using the default config. In order to specify a config file use redis-server /path/to/redis.conf
myredis_1  | 1:M 21 Nov 2021 03:19:06.935 * monotonic clock: POSIX clock_gettime
myredis_1  | 1:M 21 Nov 2021 03:19:06.936 * Running mode=standalone, port=6379.
myredis_1  | 1:M 21 Nov 2021 03:19:06.936 # Server initialized
myredis_1  | 1:M 21 Nov 2021 03:19:06.936 # WARNING overcommit_memory is set to 0! Background save may fail under low memory condition. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the
command 'sysctl vm.overcommit_memory=1' for this to take effect.
myredis_1  | 1:M 21 Nov 2021 03:19:06.936 * Ready to accept connections
myapp      |
myapp      |   .   ____          _            __ _ _
myapp      |  /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
myapp      | ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
myapp      |  \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
myapp      |   '  |____| .__|_| |_|_| |_\__, | / / / /
myapp      |  =========|_|==============|___/=/_/_/_/
myapp      |  :: Spring Boot ::                (v2.6.0)
......
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

此处的redis是使用的已有镜像，所以不会再创建redis的镜像，但是myapp是需要build构建的，所以需要创建myapp的镜像， 然后再基于这俩个镜像分别创建两个容器，这两个容器都属于myapp这个工程下面。

# 4.4.多服务多容器独立使用

除了如上依赖容器的使用，日常开发中，我们都是使用git submodule的方式组织父工程和多个子工程，那么部署的时候就需要同时部署多个微服务子工程。

我们重新新建一个SpringBoot的项目，名称为demo，然后将工程下面的src删除，因为它将是一个父工程，然后新建两个模块service1和service2，这两个服务分别对外提供getHello的服务，service1端口设置8080，service2端口设置8081。

@Slf4j
@RestController
public class HelloRest {

    @GetMapping("/service1/getHello")
    public String getHello(){
        return "hello from service1";
    }

}
1
2
3
4
5
6
7
8
9
10
11
@Slf4j
@RestController
public class HelloRest {

    @GetMapping("/service2/getHello")
    public String getHello(){
        return "hello from service2";
    }

}
1
2
3
4
5
6
7
8
9
10

确保两个子项目都能正常运行后再进行下面的步骤。

  1. 执行maven的package命令，确保两个服务都生成了各自的jar，然后在各自的目录内新建Dockerfile：
FROM openjdk:8
EXPOSE 8080
ADD  target/service1-0.0.1-SNAPSHOT.jar /demo.jar
ENTRYPOINT ["java", "-jar", "demo.jar"]
FROM openjdk:8
EXPOSE 8081
ADD  target/service2-0.0.1-SNAPSHOT.jar /demo.jar
ENTRYPOINT ["java", "-jar", "demo.jar"]
1
2
3
4
5
6
7
8
  1. 在父工程目录下新建docker-compose.yml
version: "3.9"
services:
  service1:
    container_name: service1
    # 指定Dockerfile的目录
    build: ./service1
    ports:
      - "8080:8080"
  service2:
    container_name: service2
    # 指定Dockerfile的目录
    build: ./service2
    ports:
      - "8081:8081"
1
2
3
4
5
6
7
8
9
10
11
12
13
14

然后可以执行docker-compose up了，发现会新构建两个镜像demo_service1和demo_service2，同时创建两个容器并启动。

Creating service1 ... done Creating service2 ... done Attaching to service1, service2

# 4.5.单服务多容器使用

我们在一开始讲解docker-compose概念的时候，有提到过服务和容器之间的关系，即一个服务可以有多个容器，但是在上面的例子中，我们都是一个服务一个容器的，那么想要实现一个服务启动多个容器该怎么操作呢？

我们还是拿2.1节的例子作为演示，只要修改docker-compose.yml文件的内容：

version: "3.9"
services:
  myapp:
    build: .
    ports:
      - "8080"
1
2
3
4
5
6

我们把container_name: myapp去掉了，因为容器的名称要求是唯一的，如果指定了名字，那么哪个容器叫这个名字呢？就不好区分了，去掉后，多个容器会使用工程名+服务名+数字进行自动命名。

还有，需要把端口也改造为只指定容器的端口，不要指定host的端口，这样会自动绑定host上未使用的随机端口。其实如果Dockerfile中指定了暴露的端口，此处也可以不需要ports设置了。

到此，设置完毕，执行启动命令myapp>docker-compose up --scale myapp=2就会启动一个服务的两个容器实例。

E:\myapp>docker-compose up --scale myapp=2
Creating network "myapp_default" with the default driver
Creating myapp_myapp_1 ... done
Creating myapp_myapp_2 ... done
Attaching to myapp_myapp_2, myapp_myapp_1
...
1
2
3
4
5
6
E:\myapp>docker-compose ps
Name             Command         State            Ports
--------------------------------------------------------------------
myapp_myapp_1   java -jar demo.jar   Up      0.0.0.0:53425->8080/tcp
myapp_myapp_2   java -jar demo.jar   Up      0.0.0.0:53424->8080/tcp
1
2
3
4
5

参考：

https://www.docker.com/ (opens new window)

https://www.jianshu.com/p/ee2fea4136f0 (opens new window)

https://www.runoob.com/docker/docker-tutorial.html (opens new window)

最后更新时间: 2022/09/06, 21:51:16
神奇的Docker镜像

←

最近更新
01
SuperBuilder
12-29
02
30岁我该怎么办
12-29
03
关于存钱
12-29
更多文章>
Theme by Vdoing | Copyright © 2021-2025 Mr.Fire | MIT License