0


云原生之 Docker篇 Docker Compose介绍及使用入门

目录导航

一、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 可以看我另一篇文章 《云原生之 Docker Swarm服务编排介绍及使用入门》 k8s后续再讨论。

二、compose使用

2.1 单服务单容器使用

我们新建一个SpringBoot应用,仅仅包含一个Controller:

@Slf4j@RestControllerpublicclassHelloController{@GetMapping("/getHello")publicStringgetHello(){
        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操作(需要在工程目录下执行命令):

  • docker-compose up,构建镜像并启动容器;
  • docker-compose down,停止容器,删除容器,移除自定义网络;
[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:8080spring:redis:host: 127.0.0.1
    port:6379lettuce:pool:max-active:8max-idle:8min-idle:0

再增加redis的序列化和反序列化的配置:

@Configuration@AutoConfigureAfter(RedisAutoConfiguration.class)publicclassRedisConfig{/**
     * 配置自定义redisTemplate
     * @return
     */@BeanRedisTemplate<String,Object>redisTemplate(RedisConnectionFactory redisConnectionFactory){RedisTemplate<String,Object> template =newRedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);//使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值Jackson2JsonRedisSerializer serializer =newJackson2JsonRedisSerializer(Object.class);ObjectMapper mapper =newObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL,JsonAutoDetect.Visibility.ANY);
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(mapper);

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

再后,我们需要修改Controller的逻辑,使得返回的结果依赖redis:

@Slf4j@RestControllerpublicclassHelloController{@AutowiredprivateRedisTemplate redisTemplate;@GetMapping("/getHello")publicStringgetHello(){
        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@RestControllerpublicclassHelloRest{@GetMapping("/service1/getHello")publicStringgetHello(){return"hello from service1";}}
@Slf4j@RestControllerpublicclassHelloRest{@GetMapping("/service2/getHello")publicStringgetHello(){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的使用入门实战演示。

三、参考文档

使用Docker compose发布SpringBoot项目-阿里云开发者社区 (aliyun.com)

Overview of Docker Compose | Docker Documentation

Compose file version 3 reference | Docker Documentation

标签: docker 云原生 容器

本文转载自: https://blog.csdn.net/weixin_42469135/article/details/124897057
版权归原作者 掂掂三生有幸 所有, 如有侵权,请联系我们删除。

“云原生之 Docker篇 Docker Compose介绍及使用入门”的评论:

还没有评论