正文
一、compose介绍
在先前介绍Docker的内容中，我们从代码到部署容器需要经过两个步骤：
打包镜像docker build；
部署启动容器docker run；
在真实的企业级应用中，一个服务往往需要和很多个其它的服务进行关联，单个服务也有可能有多个容器实例，如果需要发布，很可能会需要人员手动对每一个容器进行打包和启动的操作，非常繁琐，容易出错。
在这种背景下，Docker Compose就有了用武之地。简单来说，Docker Compose是一个用于定义和运行多个容器的工具，通过docker-compose.yml来实现对容器集群的编排工作。
Docker Compose管理着如下三个内容：
- 工程，docker-compose运行的目录即为一个工程，在微服务场景下，我们往往都是使用git submodule的方式组建工程的，因此父项目就可以成为一个docker compose的工程；
- 服务，对应子项目，一个工程可以包含多个子项目；
- 容器，对应服务的实例，一个服务可以有多个实例；
Docker Compose当然也存在不足的地方，就是它只能用在单一host上进行容器编排，无法跨节点host对容器进行编排，那是Docker Swarm和K8s的范畴了，Docker Swarm
二、compose使用
2.1 单服务单容器使用
我们新建一个SpringBoot应用，仅仅包含一个Controller：
@Slf4j @RestController public class HelloController { @GetMapping("/getHello") public String getHello(){ log.info("myapp works!"); return "myapp is running ok!!!"; } }
请务必保证程序能正常运行，再进行如下操作。并进行package，打成jar包。
编写Dockerfile：
FROM openjdk:8 EXPOSE 8080 ADD target/myapp-0.0.1-SNAPSHOT.jar /demo.jar ENTRYPOINT ["java", "-jar", "demo.jar"]
编写docker-compose.yml文件：
# 使用的yml版本 version: "3.9" services: # 服务名称，可以自定义 myapp: # 容器名称，可以自定义 container_name: myapp # 指定Dockerfile所在的目录 build: . ports: - "8080:8080"
然后执行docker-compose up即可，主要完成以下的两步操作：
镜像构建docker build；
启动yml中的所有容器docker run；
执行过程如下：
[root@wlidc ~]# 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) ......
到此，我们的单容器使用方式完成了。
如下是一些常见的docker-compose操作(需要在工程目录下执行命令)：
[root@wlidc ~]# docker-compose down Stopping myapp ... done Removing myapp ... done Removing network myapp_default
docker-compose ls，查看所有运行的容器；
[root@wlidc ~]# docker-compose ps Name Command State Ports ----------------------------------------------------------- myapp java -jar demo.jar Up 0.0.0.0:8080->8080/tcp
- docker-compose logs -f container_name，查看具体容器的日志，-f参数表示实时日志输出；
- docker-compose port container_name container_port，查看和容器端口绑定的主机端口；
- docker-compose stop container_name，停止指定的容器，如果不指定则停止所有的容器；
- docker-compose start container_name，启动指定的容器，如果不指定则停止所有的容器；
- docker-compose rm container_name，删除指定的已停止容器，如果不指定则删除所有已停止容器；
- docker-compose build，构建或者重新构建服务的镜像，但不会创建和启动容器；
2.2 多服务多容器依赖使用
假设我们的应用需要依赖其它服务，比如需要使用redis，mysql等，那么这种场景下，就需要被依赖的容器先启动。
首先，我们改造上述例子中的myapp代码，需要引入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>
然后增加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
再增加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; } }
再后，我们需要修改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并返回结果。
最后，我们只需要修改docker-compose.yml：
version: "3.9" services: myapp: container_name: myapp build: . ports: - "8080:8080" depends_on: - myredis myredis: image: "redis:latest"
其它内容不变，如此配置就全部完成了，注意在执行如下操作之前，先确保程序能够正常运行，可以先自行运行一个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 May 2022 13:19:06.934 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo myredis_1 | 1:C 21 May 2022 13:19:06.934 # Redis version=6.2.6, bits=64, commit=00000000, modified=0, pid=1, just started myredis_1 | 1:C 21 May 2022 13: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 May 2022 13:19:06.935 * monotonic clock: POSIX clock_gettime myredis_1 | 1:M 21 May 2022 13:19:06.936 * Running mode=standalone, port=6379. myredis_1 | 1:M 21 May 2022 13:19:06.936 # Server initialized myredis_1 | 1:M 21 May 2022 13: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 May 2022 13:19:06.936 * Ready to accept connections myapp | myapp | . ____ _ __ _ _ myapp | /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ myapp | ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \ myapp | \\/ ___)| |_)| | | | | || (_| | ) ) ) ) myapp | ' |____| .__|_| |_|_| |_\__, | / / / / myapp | =========|_|==============|___/=/_/_/_/ myapp | :: Spring Boot :: (v2.6.0)
此处的redis是使用的已有镜像，所以不会再创建redis的镜像，但是myapp是需要build构建的，所以需要创建myapp的镜像，然后再基于这俩个镜像分别创建两个容器，这两个容器都属于myapp这个工程下面。
2.3 多服务多容器独立使用
除了如上依赖容器的使用，日常开发中，我们都是使用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"; } }
@Slf4j @RestController public class HelloRest { @GetMapping("/service2/getHello") public String getHello(){ return "hello from service2"; } }
确保两个子项目都能正常运行后再进行下面的步骤。
执行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"]
然后在父工程目录下新建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"
然后可以执行docker-compose up了，发现会新构建两个镜像demo_service1和demo_service2，同时创建两个容器并启动。
Creating service1 ... done Creating service2 ... done Attaching to service1, service2
2.4 单服务多容器使用
我们在一开始讲解docker-compose概念的时候，有提到过服务和容器之间的关系，即一个服务可以有多个容器，但是在上面的例子中，我们都是一个服务一个容器的，那么想要实现一个服务启动多个容器该怎么操作呢？
我们还是拿2.1节的例子作为演示，只要修改docker-compose.yml文件的内容：
version: "3.9" services: myapp: build: . ports: - "8080"
我们把container_name: myapp去掉了，因为容器的名称要求是唯一的，如果指定了名字，那么哪个容器叫这个名字呢？就不好区分了，去掉后，多个容器会使用工程名+服务名+数字进行自动命名。
还有，需要把端口也改造为只指定容器的端口，不要指定host的端口，这样会自动绑定host上未使用的随机端口。其实如果Dockerfile中指定了暴露的端口，此处也可以不需要ports设置了。
到此，设置完毕，执行启动命令 docker-compose up --scale myapp=2，就会启动一个服务的两个容器实例。
[root@wlidc ~]# 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 ...
[root@wlidc ~]# 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
当然，这两个容器都必须实现负载均衡，后续我会出一篇Nginx的使用入门实战演示。
