GVKun编程网logo

Spring Boot 2 (五)：Docker Compose + Spring Boot + Nginx + Mysql 实践

2

对于SpringBoot2(五)：DockerCompose+SpringBoot+Nginx+Mysql实践感兴趣的读者，本文将提供您所需要的所有信息，并且为您提供关于62-docker-compo

对于Spring Boot 2 (五)：Docker Compose + Spring Boot + Nginx + Mysql 实践感兴趣的读者，本文将提供您所需要的所有信息，并且为您提供关于62-docker-compose 结合 dockerfile 部署 springboot 应用、Docker Compose + Spring Boot + Postgres 连接、docker compose 部署 springboot+mysql、Docker Compose 部署运行Spring Boot 项目+ MySQL的宝贵知识。

本文目录一览：

Spring Boot 2 (五)：Docker Compose + Spring Boot + Nginx + Mysql 实践

Spring Boot 2 (五)：Docker Compose + Spring Boot + Nginx + Mysql 实践

Spring Boot 2 (五)：Docker Compose + Spring Boot + Nginx + Mysql 实践

Spring Boot + Nginx + Mysql 是实际工作中最常用的一个组合，最前端使用 Nginx 代理请求转发到后端 Spring Boot 内嵌的 Tomcat 服务，Mysql 负责业务中数据相关的交互，那么在没有 docker 之前，我们是如何来搞定这些环境的呢？

  • 安装 Nginx，配置 Nginx 相关信息，重启。
  • 安装 Mysql ，配置字符集时区等信息，重启，最后初始化脚本。
  • 启动 Spring Boot 项目，整体进行联调测试。

大家看我只写了三行，但其实搭建这些环境的时候还挺费事的，但这还不是结局，在用了一段时间时候需要迁移到另外一个环境，怎么办又需要重新搞一次？正常情况下，测试环境、SIT 环境、UAT 环境、生产环境！我们需要重复搭建四次。有人说不就是搭建四次吗？也没什么大不了的，那么我想告诉你，Too yong ,Too Simple 。

让我们看看以下几个因素：

第一，这只是一个最简单的案例，如果项目涉及到 MongoDB、Redis、ES … 一些列的环境呢？ 第二，如果你经常搭建环境或者调试程序，你就会知道什么是环境问题？有的时候明明是一模一样的配置，但是到了另外一个环境就是跑不起来。于是你花费很多时间来查找，最后才发现是少了一个参数或者逗号的问题，或者是系统内核版本不一致、或者你最后也没搞懂是为什么！只能再换另外一台服务器，那么使用 Docker 呢就可以完美的避开这些坑。

一、Spring Boot 案例

首先我们先准备一个 Spring Boot 使用 Mysql 的小场景，我们做这样一个示例，使用 Spring Boot 做一个 Web 应用，提供一个按照 IP 地址统计访问次数的方法，每次请求时将统计数据存入 Mysql 并展示到页面中。

1，配置信息

（1）依赖包

<dependencies>
     <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

主要添加了 Spring Boot Web 支持，使用 Jpa 操作数据库、添加 Myql 驱动包等。

（2）配置文件

spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

spring.jpa.properties.hibernate.hbm2ddl.auto=update
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
spring.jpa.show-sql=true

配置了数据库的链接信息，以及 Jpa 更新表模式、方言和是否显示 Sql

2，核心代码

核心代码很简单，每过来一个请求，判断是否已经统计过，如果没有统计新增数据，如果有统计数据更新数据。

@RestController
public class VisitorController {

    @Autowired
    private VisitorRepository repository;
    
    @RequestMapping("/")
    public String index(HttpServletRequest request) {
        String ip=request.getRemoteAddr();
        Visitor visitor=repository.findByIp(ip);
        if(visitor==null){
            visitor=new Visitor();
            visitor.setIp(ip);
            visitor.setTimes(1);
        }else {
            visitor.setTimes(visitor.getTimes()+1);
        }
        repository.save(visitor);
        return "I have been seen ip "+visitor.getIp()+" "+visitor.getTimes()+" times.";
    }
}

实体类和 Repository 层代码比较简单，这里就不贴出来了，大家感兴趣可以下载源码查看。

以上内容都完成后，启动项目，访问：http://localhost:8080/ 我们就可以看到这样的返回结果：

I have been seen ip 0:0:0:0:0:0:0:1 1 times.

再访问一次会变成：

I have been seen ip 0:0:0:0:0:0:0:1 2 times.

多次访问一直叠加，说明演示项目开发完成。

二、Docker 化改造

首先我们将目录改造成这样一个结构：

我们先从最外层说起：

  • docker-compose.yaml：docker-compose 的核心文件，描述如何构建整个服务
  • nginx：有关 nginx 的配置
  • app：Spring Boot 项目地址

如果我们需要对 Mysql 有特殊的定制，也可以在最外层创建 mysql 文件夹，在此目录下进行配置。

1，文件详解 docker-compose.yaml

version: ''3''
services:
  nginx:
   container_name: v-nginx
   image: nginx:1.13
   restart: always
   ports:
   - 80:80
   - 443:443
   volumes:
   - ./nginx/conf.d:/etc/nginx/conf.d
    
  mysql:
   container_name: v-mysql
   image: mysql/mysql-server:5.7
   environment:
    MYSQL_DATABASE: test
    MYSQL_ROOT_PASSWORD: root
    MYSQL_ROOT_HOST: ''%''
   ports:
   - "3306:3306"
   restart: always
    
  app:
    restart: always
    build: ./app
    working_dir: /app
    volumes:
      - ./app:/app
      - ~/.m2:/root/.m2
    expose:
      - "8080"
    depends_on:
      - nginx
      - mysql
    command: mvn clean spring-boot:run -Dspring-boot.run.profiles=docker
  • version: ''3''： 表示使用第三代语法来构建 docker-compose.yaml 文件。
  • services: 用来表示 compose 需要启动的服务，我们可以看出此文件中有三个服务分别为：nginx、mysql、app。
  • container_name: 容器名称
  • environment: 此节点下的信息会当作环境变量传入容器，此示例中 mysql 服务配置了数据库、密码和权限信息。
  • ports: 表示对外开放的端口
  • restart: always 表示如果服务启动不成功会一直尝试。
  • volumes: 加载本地目录下的配置文件到容器目标地址下
  • depends_on：可以配置依赖服务，表示需要先启动 depends_on 下面的服务后，再启动本服务。
  • command: mvn clean spring-boot:run -Dspring-boot.run.profiles=docker: 表示以这个命令来启动项目，-Dspring-boot.run.profiles=docker 表示使用 application-docker.properties 文件配置信息进行启动。

2，Nginx 文件解读

nginx 在目录下有一个文件 app.conf，主要配置了服务转发信息：

server {
    listen 80;
    charset utf-8;
    access_log off;

    location / {
        proxy_pass http://app:8080;
        proxy_set_header Host $host:$server_port;
        proxy_set_header X-Forwarded-Host $server_name;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }

    location /static {
        access_log   off;
        expires      30d;

        alias /app/static;
    }
}

这块内容比较简单，配置请求转发，将 80 端口的请求转发到服务 app 的 8080 端口。其中 proxy_pass http://app:8080 这块的配置信息需要解释一下，这里使用是 app 而不是 localhost，是因为他们没有在一个容器中，在一组 compose 的服务通讯需要使用 services 的名称进行访问。

3，Spring Boot 项目改造

在 app 目录下也就是和 pom.xm 文件同级添加 Dockerfile 文件，文件内容如下：

FROM maven:3.5-jdk-8

只有一句，依赖于基础镜像 maven3.5 和 jdk 1.8。因为在 docker-compose.yaml 文件设置了项目启动命令，这里不需要再添加启动命令。

在项目的 resources 目录下创建 application-dev.properties 和 application-docker.properties 文件

  • application-dev.properties 中的配置信息和上面一致
  • application-docker.properties 中的配置信息做稍微的改造，将数据库的连接信息由 jdbc:mysql://localhost:3306/test 改为 jdbc:mysql://mysql:3306/test 。

三、部署

我们将项目拷贝到服务器中进行测试，服务器需要先安装 Docker 和 Docker Compos 环境。

将项目拷贝到服务器中，进入目录 cd dockercompose-springboot-mysql-nginx

（1）启动服务：docker-compose up

[root@VM_73_217_centos dockercompose-springboot-mysql-nginx]# docker-compose up
Creating network "dockercomposespringbootmysqlnginx_default" with the default driver
Creating v-nginx ... done
Creating v-mysql ... done
Creating dockercomposespringbootmysqlnginx_app_1 ... done
Attaching to v-nginx, v-mysql, dockercomposespringbootmysqlnginx_app_1
v-mysql  | [Entrypoint] MySQL Docker Image 5.7.21-1.1.4
v-mysql  | [Entrypoint] Initializing database
app_1    | [INFO] Scanning for projects...
... 
app_1    | 2018-03-26 02:54:55.658  INFO 1 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''''
app_1    | 2018-03-26 02:54:55.660  INFO 1 --- [           main] com.neo.ComposeApplication               : Started ComposeApplication in 14.869 seconds (JVM running for 30.202)

看到信息 Tomcat started on port(s): 8080 表示服务启动成功。也可以使用 docker-compose up -d 后台启动

访问服务器地址；http://58.87.69.230/，返回：I have been seen ip 172.19.0.2 1 times. 表示整体服务启动成功

（2）使用 docker-compose ps 查看项目中目前的所有容器

[root@VM_73_217_centos dockercompose-springboot-mysql-nginx]# docker-compose ps
                 Name                                Command                  State                        Ports                  
----------------------------------------------------------------------------------------------------------------------------------
dockercomposespringbootmysqlnginx_app_1   /usr/local/bin/mvn-entrypo ...   Up             8080/tcp                                
v-mysql                                   /entrypoint.sh mysqld            Up (healthy)   0.0.0.0:3306->3306/tcp, 33060/tcp       
v-nginx                                   nginx -g daemon off;             Up             0.0.0.0:443->443/tcp, 0.0.0.0:80->80/tcp

可以看到项目中服务的状态、命令、端口等信息。

（3）关闭服务 docker-compose down

[root@VM_73_217_centos dockercompose-springboot-mysql-nginx]# docker-compose down
Stopping dockercomposespringbootmysqlnginx_app_1 ... done
Stopping visitor-nginx                           ... done
Stopping visitor-mysql                           ... done
Removing dockercomposespringbootmysqlnginx_app_1 ... done
Removing visitor-nginx                           ... done
Removing visitor-mysql                           ... done

（4）docker-compose 顺序

在使用 docker-compose 启动的时候经常会出现项目报 Mysql 连接异常，跟踪了一天终于发现了问题。 docker-compose 虽然可以通过 depends_on 来定义服务启动的顺序，但是无法确定服务是否启动完成，因此会出现这样一个现象，Mysql 服务启动比较慢，当 Spring Boot 项目已经启动起来，但是 Mysql 还没有初始化好，这样当项目连接 Mysql 数据库的时候，就会出现连接数据库的异常。

针对这样的问题，有两种解决方案:

  • 足够的容错和重试机制，比如连接数据库，在初次连接不上的时候，服务消费者可以不断重试，直到连接上服务。也就是在服务中定义： restart: always
  • 同步等待，使用 wait-for-it.sh 或者其他 shell 脚本将当前服务启动阻塞，直到被依赖的服务加载完毕。这种方案后期可以尝试使用。

四、总结

没有对比就没有伤害，在没有使用 Docker 之前，我们需要搭建这样一个环境的话，需要安装 Nginx、Mysql ，再进行一系列的配置调试，还要担心各种环境问题；使用 Docker 之后简单两个命令就完成服务的上线、下线。

docker-compose up
docker-compose down

其实容器技术对部署运维的优化还有很多，这只是刚刚开始，后面使用了 Swarm 才会真正感受到它的便利和强大。


62-docker-compose 结合 dockerfile 部署 springboot 应用

62-docker-compose 结合 dockerfile 部署 springboot 应用

dockerfile 内容：

# 基础镜像
FROM  openjdk:8-jre
# author
MAINTAINER lw

# 挂载目录
VOLUME /home/ybss
# 创建目录
RUN mkdir -p /home/ybss
# 指定路径
WORKDIR /home/ybss

ADD ./jar/lib /home/ybss/lib
ADD ./jar/*.yml /home/ybss/
# 复制jar文件到路径
COPY ./jar/run.jar /home/ybss/run.jar
# 启动认证服务
ENTRYPOINT ["java","-jar","-Dserver.port=9200","-Dspring.profiles.active=dev","run.jar"]

docker-compose.yml 内容：

version : ''3.8''
services:
  ybss-auth:
    container_name: ybss-auth
    build:
      context: ./ybss/auth
      dockerfile: dockerfile
    ports:
      - "19200:9200"
    volumes:
      - /home/ybss/ybss/auth/jar:/home/ybss

networks:
  ybss_default:
    driver: bridge

volumes 挂载目录 /home/ybss/ybss/auth/jar，有更新时，只需要把更新 jar 和文件替换即可。

部署脚本 shell:

#!/bin/sh
auth(){
  chmod 777 -R ./ybss/auth/*
  docker-compose up -d ybss-auth
}
stop(){
	docker-compose stop
}
case "$1" in
"auth")
	auth
;;
"s")
	stop
;;

Docker Compose + Spring Boot + Postgres 连接

Docker Compose + Spring Boot + Postgres 连接

php小编西瓜今天为大家带来一篇关于如何使用docker compose连接spring boot和postgres的教程。docker compose是一个用于定义和运行多容器docker应用程序的工具，而spring boot则是一个用于构建java应用程序的框架，postgres则是一个功能强大的关系数据库。通过结合使用这三者，我们可以轻松地搭建一个包含spring boot应用程序和postgres数据库的开发环境。本教程将带你一步步学习如何配置和连接这三者，让你能够快速开始开发你的应用程序。

问题内容

我有一个可与 Postgres 数据库配合使用的 Java Spring Boot 应用程序。我想对它们都使用 Docker。我最初只将 Postgres 放入 Docker 中，并且有一个 docker-compose.yml 文件，定义如下：

version: ''2''
services:
    db:
        container_name: sample_db
        image: postgres:9.5
        volumes:
            - sample_db:/var/lib/postgresql/data
        environment:
            - POSTGRES_PASSWORD=sample
            - POSTGRES_USER=sample
            - POSTGRES_DB=sample
            - PGDATA=/var/lib/postgresql/data/pgdata
        ports:
            - 5432:5432

volumes:
    sample_db: {}
登录后复制

然后，当我发出命令 sudo dockerd 和 sudo docker-compose -f docker-compose.yml up 时，它正在启动数据库。例如，我可以使用 pgAdmin 进行连接，使用 localhost 作为服务器和端口 5432。然后，在我的 Spring Boot 应用程序中，在 application.properties 文件中定义了以下属性。

spring.datasource.url=jdbc:postgresql://localhost:5432/sample
spring.datasource.username=sample
spring.datasource.password=sample
spring.jpa.generate-ddl=true
登录后复制

此时，我可以通过 Spring Suite 在本地运行我的 Spring Boot 应用程序，并且一切正常。然后，我还想将我的 Spring Boot 应用程序添加为 Docker 映像。我首先在项目目录中创建了一个 Dockerfile，如下所示：

FROM java:8
EXPOSE 8080
ADD /target/manager.jar manager.jar
ENTRYPOINT ["java","-jar","manager.jar"]
登录后复制

然后，我进入了发布mvn clean的项目目录，然后是mvn install。接下来，发出 docker build -f Dockerfile -t manager . ，后跟 docker tag 9c6b1e3f1d5e myuser/manager:latest （id 是正确的）。最后，我编辑了现有的 docker-compose.yml 文件，如下所示：

version: ''2''
services:
    web:
      image: myuser/manager:latest
      ports: 
          - 8080:8080
      depends_on:
          - db
    db:
        container_name: sample_db
        image: postgres:9.5
        volumes:
            - sample_db:/var/lib/postgresql/data
        environment:
            - POSTGRES_PASSWORD=sample
            - POSTGRES_USER=sample
            - POSTGRES_DB=sample
            - PGDATA=/var/lib/postgresql/data/pgdata
        ports:
            - 5432:5432

volumes:
    sample_db: {}
登录后复制

但是，现在如果我发出 sudo docker-compose -f docker-compose.yml up 命令，数据库会再次正确启动，但我会收到错误并退出 Web 应用程序部分的代码 1。问题是连接字符串。我相信我必须将其更改为其他内容，但我不知道它应该是什么。我收到以下错误消息：

web_1  | 2017-06-27 22:11:54.418 ERROR 1 --- [           main] o.a.tomcat.jdbc.pool.ConnectionPool      : Unable to create initial connections of pool.
web_1  | 
web_1  | org.postgresql.util.PSQLException: Connection to localhost:5432 refused. Check that the hostname and port are correct and that the postmaster is accepting TCP/IP connections
登录后复制

有什么想法吗？

解决方法

每个容器都有自己的网络接口和自己的本地主机。因此改变 Java 指向 Postgres 的方式：

spring.datasource.url=jdbc:postgresql://localhost:5432/sample
登录后复制

致：

spring.datasource.url=jdbc:postgresql://db:5432/sample
登录后复制

db 将解析为正确的 Postgres IP。

<小时>

奖金。使用 docker-compose，您无需手动构建镜像。所以改变：

web:
  image: myuser/manager:latest
登录后复制

致：

web:
  build: .
登录后复制

我遇到了同样的问题，我花了一些时间来理解和解决这个问题：

org.postgresql.util.PSQLException: Connection to localhost:5432 refused. Check that the hostname and port are correct and that the postmaster is accepting TCP/IP connections.
登录后复制

我展示了所有属性，以便每个人都能理解。 application.properties:

spring.datasource.url=jdbc:postgresql://localhost:5432/testdb
spring.datasource.driver-class-name=org.postgresql.Driver
spring.datasource.username=postgres
spring.datasource.password=postgres
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQL82Dialect
spring.jpa.hibernate.ddl-auto=update
登录后复制

docker-compose.yml:

version: "3"
  services:
    springapp:
      build: .
      container_name: springapp
      environment:
        SPRING_DATASOURCE_URL: jdbc:postgresql://db:5432/testdb
      ports:
        - 8000:8080
      restart: always
      depends_on:
        - db
    db:
      image: postgres
      container_name: db
      environment:
        - POSTGRES_USER=postgres
        - POSTGRES_PASSWORD=postgres
        - POSTGRES_DB=testdb
        - PGDATA=/var/lib/postgresql/data/pgdata
      ports:
        - 5000:5432
      volumes:
        - pgdata:/var/lib/postgresql/data
      restart: always
  volumes:
    pgdata:
登录后复制

为了使用本地数据库启动 Spring 应用程序，我们使用 url localhost。 为了使用数据库连接到容器，我们需要更改数据库服务上的“localhost”，在我的例子中，将“localhost”更改为“db”。 解决方案：在docker-compose.yml中添加SPRING_DATASOURCE_URL环境，重写spring.datasource.url连接值：

environment:
    SPRING_DATASOURCE_URL: jdbc:postgresql://db:5432/testdb
登录后复制

我希望这可以帮助人们节省时间。

以上就是Docker Compose + Spring Boot + Postgres 连接的详细内容，更多请关注php中文网其它相关文章！

docker compose 部署 springboot+mysql

docker compose 部署 springboot+mysql

【直播预告】程序员逆袭 CEO 分几步？

1、宿主机为安装了 ubuntu22.04 系统的虚拟机。docker 和 docker-compose 的安装过程略过。

2、先看下项目结构：

项目为普通的 springboot 项目，只有一个测试接口，功能是从数据库表里查询数据。

Dockerfile 和 docker-compose.yml 文件在项目根目录下。

3、打 jar 包

mvn clean install

生成的 jar 包在 target 目录下，名为 demo-0.0.1-SNAPSHOT.jar。

4、编写 Dockerfile 文件，直接贴出文件内容：

FROM openjdk:11

ADD target/demo-0.0.1-SNAPSHOT.jar /myapp.jar
ADD src/main/resources/application.yml /application.yml

ENTRYPOINT ["java","-jar","/myapp.jar"]

From 就是从哪个镜像开始构建，这里使用 openjdk:11, openjdk 是镜像名称，11 是版本号。

ADD target/demo-0.0.1-SNAPSHOT.jar/myapp.jar， 是把 target 目录下的 jar 包，复制到容器的根目录下，并重命名为 myapp.jar。

ADD src/main/resources/application.yml/application.yml，是把项目的配置文件，复制到容器根目录下。

ENTRYPOINT ["java","-jar","/myapp.jar"]， ENTRYPOINT 是容器启动后执行的命令，这里是执行 jar 包，启动项目。

5、编写 docker-compose.yml

version: ''3''
services:
  mysql:
    image: mysql:8.0.26    # mysql镜像，版本为8.0.26
    container_name: mysql  # 容器名称，不是必须配置
    restart: always  # restart配置为always
    volumes:
      - dbdata:/var/lib/mysql  # 挂载目录，防止容器被停止并删除后，数据丢失
    environment:
      MYSQL_DATABASE: demo    # 创建一个空的数据库 
      MYSQL_ROOT_USER: root   # root角色用户 
      MYSQL_ROOT_PASSWORD: 123456  # root用户密码
      MYSQL_ROOT_HOST: ''%''  # 允许远程连接
      TZ: Asia/Shanghai  # 设置时区
  app:
    build: .
    container_name: app
    restart: always
    ports:
      - 8082:8082
    depends_on:
      - mysql
volumes:
  dbdata:

 

versrion 是 docker-compose 的版本；

services 表示服务列表，这里有两个服务，一个 mysql, 一个 app；

mysql 服务添加了挂载目录，格式为 - 宿主机目录：容器目录，宿主机目录可以写绝对路径，相对路径以及本例中的这种写法，直接写 dbdata，则这个目录位置在 docker 默认的工作目录下。

通过 sudo docker ps，可以看到 mysql 容器的 id。然后通过 sudo docker inspect mysql 容器 id，可以看到 mysql 容器的详情，注意其中的 Mounts 项：

mysql 服务没有配置端口映射，使用的是默认的 3306。

6、application.yml 中修改数据库连接信息。

用户名和密码以及数据库名称，用第 5 步中 mysql 服务的配置信息。需要注意的是这里的主机，用的是 mysql, 也就是 docker-compose.yml 文件中，mysql 服务的服务名。

初次启动时，数据库是空的，需要登录进去，建表。

sudo docker exec -it mysql 容器 id /bin/bash

进入容器后，执行：

    mysql -uroot -p

输入密码，进入 msyql 命令行，然后

use 数据库名称；

切换到指定数据库，执行建表命令。最后执行 quit 命令退出 mysql, 执行 exit 退出容器。

看到网上有许多无法连接数据库的问题，基本都是卡在这里。

然后有许多文章给出解决方案，基本丢失配置自定义的 network, 或者设置 network_mode，我本人都试过了，没有解决问题。按照上述配置，就可以了。

docker-compose 启动，会自动创建一个网络，一个 docker-compose 内的多个服务，共享这个网络，多个服务间通过域名或者说服务名，就可以访问。

如果这里启动的 mysql 服务，还需要被别的服务器访问，那就需要配置具体的 ip 地址。

以上。

Docker Compose 部署运行Spring Boot 项目+ MySQL

Docker Compose 部署运行Spring Boot 项目+ MySQL

描述

本文目的在于使用Docker Compose来创建一个运行Spring Boot项目的镜像并且该项目连接MysqL数据库。
文件结构

  Example/
    ------- t2.Dockerfile
    ------- docker-compose.yml
    ------- data/
              ------ schema.sql
              ------ data.sql

运行命令是所在的位置是Example里面

1. Dockerfile 文件

以下内容保存为t2.Dockerfile。

FROM adoptopenjdk/openjdk15-openj9:alpine-jre  #使用轻量级linux的镜像，里面使用JDK15
RUN mkdir /app        #在容器的根目录中 创建一个叫app的文件夹
copY ./t2.jar /app    #把当前所在路径中的t2.jar文件复制到容器的app的文件夹里面
workdir /app          #把容器的工作目录换成app，所以运行docker exec -it 容器名 /bin/bash 进入容器的时候，所在位置是app
EXPOSE 8081           #暴露端口 8081
ENTRYPOINT ["java", "-jar", "/app/t2.jar"]   #初始化运行容器时，运行程序

创建Docker镜像
-t name， name就是之后该镜像的名字。

docker build . -f t2.Dockerfile -t image-t2
docker images #列出镜像，确定是否创建成功

如果要上传到某个远程仓库中可以运行以下命令。在这里仓库网址是example.com

docker image tag image-t2 example.com:5000/image-t2
docker image push example.com:5000/yuwu-t2

2. Docker Compose 文件

以下内容保存为docker-compose.yml。

version: "3.9"
services:
    db:
        image: MysqL:5.7
        environment:
            MysqL_ROOT_PASSWORD: root
            MysqL_DATABASE: example
            MysqL_USER: MysqL
            MysqL_PASSWORD: MysqL
        volumes:
            - ./data:/docker-entrypoint-initdb.d  #在data的文件中包括了 .sql文件（建表，插入数据等），会在容器创建是自动运行。
        ports:
            - 3306:3306
        container_name: MysqL  #定义容器的名字为MysqL
      
    t2:
        build: 
            context: .
            dockerfile: t2.Dockerfile
        environment:
            - SPRING_DATASOURCE_URL=jdbc:MysqL://MysqL:3306/example?serverTimezone=UTC  #覆盖在spring boot项目中application.properties的spring.datasource.url的内容。 如果没有定义container_name，那么jdbc:MysqL://名字:3306... 这里的名字要写定义的服务的名字， 在这个例子中就是db
        ports:
            - 8081:8081
        depends_on: 
            - db  #依赖于MysqL容器
        links:
            - db
        container_name: t2

创建所有容器并且运行

docker-compose up -d

停止所有容器

docker-compose down

关于Spring Boot 2 (五)：Docker Compose + Spring Boot + Nginx + Mysql 实践的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于62-docker-compose 结合 dockerfile 部署 springboot 应用、Docker Compose + Spring Boot + Postgres 连接、docker compose 部署 springboot+mysql、Docker Compose 部署运行Spring Boot 项目+ MySQL等相关内容，可以在本站寻找。

本文标签：

上一篇CentOS 下利用 Docker 部署 Surging（centos docker安装部署）

下一篇使用 Docker 和 Nginx 打造高性能二维码服务（二）（docker nginx 502）

相关文章