怎么使用dockercompose搭建springboot-mysql-nginx应用

使用docker构建spring-boot应用，是把编译好的jar包构建到镜像中。

这篇是把spring-boot连同数据库，做为一组docker服务运行起来。

这里只是把自己操作记录下来，完整运行的代码见“参考”中的引用1中的内容。（我修改mysql映射目录及获取远程ip的方法）

主要步骤：

  • 搭建简单的springboot应用

  • 应用添加docker下支持

  • 编写dockercompose配置文件

  • 使用Docker-Compose搭建SpringBoot-MySQL-Nginx应用，一次完成三个容器部署

    实践运行

搭建简单的springboot应用

做一个web应用，统计访问该站点的ip次数。

并存储到mysql数据库中，这里使用jpa的方式访问数据库。

依赖

<
parent>

<
groupid>
org.springframework.boot<
/groupid>

<
artifactid>
spring-boot-starter-parent<
/artifactid>

<
version>
2.0.0.release<
/version>

<
/parent>

web,jpa,mysql,tset库的依赖

<
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.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

核心代码

@restcontroller
public class visitorcontroller{
@autowired
private visitorrepository repository;

@requestmapping("
/"
)
public string index(httpservletrequest request)
{
string ip= request.getheader("
x-real-ip"
);

if(ip== null || "
"
.equals(ip))
{
ip = request.getremoteaddr();

}
visitor visitor = repository.findbyip(ip);

if(visitor == null)
{
visitor = new visitor();

visitor.setip(ip);

visitor.settimes(1l);

}
else
{
visitor.settimes(visitor.gettimes()+1);

}
repository.save(visitor);

return "
ip:"
+visitor.getip()+"
"
+visitor.gettimes()+"
times."
;

}
}

实体类

@entity
public class visitor {
@id
@generatedvalue
private long id;

@column(nullable=false)
private long times;

@column(nullable=false)
private string ip;

// get,set 方法略
}

repository 层代码参考jpa 相关内容。

本地数据库打开，密码是上面配置中的，使用mvn spring-boot:run运行起来之后，可以看到ip的次数，每次统计后就自增。

dockercompose配置文件

新建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"

volumes:
- ./mysqldata:/var/lib/mysql
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

主要对这个配置文件进行解释，并在文件系统中增加相关的配置。

services下面有三个服务nginx,mysql,app。images 指明使用镜像。nginx及mysql都是直接取docker仓库中已有的。app中没有指明镜像，但用build指定了dockerfile所在的目录。volumes 指定了本地目录下的文件与容器目标地址的映射。environment 配置了容器所需要的环境变量ports 配置了本地与容器的映射的端口，本地端口在前，容器端口在后

ngixn下的volumes配置的作用：把我们写好的nginx配置文件直接覆盖到容器中默认的nginx配置文件。

mysql下的volumes配置的作用：把mysql的数据文件映射到了本地mysqldata目录下。当容器删除后，数据还在。

app下的volumes配置的作用：第一行是把代码文件映射到容器中。第二行是把maven的仓库文件映射到本地。容器删除之后，再构建，不用重新下载依赖包。

command: mvn clean spring-boot:run -dspring-boot.run.profiles=docker

命令是编译运行容器中的项目，使用docker的profiles。

所以我们要添加的文件

  • dockerfile：新建文件，添加一行from maven:3.5-jdk-8

  • docker的profiles：复制application.properties为application-docker.properties，并把application-docker.properties中数据库连接地址改为jdbc:mysql://mysql:3306/test。

  • nginx的配置文件

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;

}
}

部署验证

把整体的文件拷贝到服务器上，使用docker-compose up来运行。



Docker-Compose是Docker推出的一个多容器应用管理工具，它让我们可以通过一个配置文件，轻松地定义、运行和管理多个Docker应用。本文将介绍如何使用Docker-Compose搭建一个简单的Spring Boot-MySQL-Nginx应用。下面将从环境搭建、编写Docker-Compose文件、构建容器镜像、启动容器、测试应用等方面进行具体的说明。
一、准备工作
1. 安装Docker和Docker-Compose
在ubuntu系统下,先安装Docker：
```
sudo apt install docker.io
```
安装完毕后再安装Docker-Compose：
```
sudo apt install docker-compose
```
2. 编写应用代码
假设我们要搭建一个使用Spring Boot作为后端框架，MySQL作为数据库，Nginx作为Web服务器的应用。这里我们只需要编写一个简单的REST接口，用于测试整个应用是否正常工作。
二、编写Docker-Compose文件
1. 创建目录和文件
我们在项目根目录下创建一个docker-compose.yml文件，然后在该文件所在的目录下创建一个backend子目录，以及一个frontend子目录。以下是项目的目录结构：
```
|- docker-compose.yml
|- backend/
|- Dockerfile
|- app/
|- springboot.jar
|- frontend/
|- Dockerfile
|- app/
|- index.html
|- nginx/
|- default.conf
```
2. 编写Docker-Compose配置
下面是我们的docker-compose.yml文件：
```
version: '3'
services:
mysql:
image: mysql:5.7
ports:
- \"3306:3306\"
environment:
- MYSQL_ROOT_PASSWORD=123456
- MYSQL_USER=user
- MYSQL_PASSWORD=pass
- MYSQL_DATABASE=app
backend:
build: ./backend
volumes:
- ./backend:/usr/src/app
environment:
- MYSQL_HOST=mysql
- MYSQL_PORT=3306
- MYSQL_USER=user
- MYSQL_PASSWORD=pass
- MYSQL_DATABASE=app
depends_on:
- mysql
ports:
- \"8080:8080\"
frontend:
build: ./frontend
volumes:
- ./frontend:/usr/share/nginx/html
ports:
- \"80:80\"
nginx:
image: nginx:alpine
volumes:
- ./nginx:/etc/nginx/conf.d
ports:
- \"8081:80\"
depends_on:
- backend
```
三、创建Docker容器镜像
1. 编写Dockerfile文件
后端应用的Dockerfile文件：
```
FROM openjdk:8-jre-alpine
VOLUME /tmp
ADD app/springboot.jar app.jar
ENTRYPOINT [\"java\",\"-jar\",\"/app.jar\"]
```
前端应用的Dockerfile文件：
```
FROM nginx:alpine
COPY app/index.html /usr/share/nginx/html
```
2. 创建Docker镜像
在backend目录下使用以下命令创建一个镜像：
```
docker build -t backend .
```
在frontend目录下使用以下命令创建一个镜像：
```
docker build -t frontend .
```
四、启动Docker容器
1. 启动Docker容器
在docker-compose.yml所在的目录下，使用以下命令启动容器：
```
docker-compose up -d
```
2. 停止Docker容器
在docker-compose.yml所在的目录下，使用以下命令停止容器：
```
docker-compose down
```
五、测试应用
1. 测试MySQL
我们可以通过以下方式测试MySQL是否已经正常工作：
```
docker exec -it mysql -uuser -ppass app
```
这将打开一个MySQL客户端，我们可以测试数据库是否正常工作。
2. 测试后端应用
我们可以通过以下方式测试后端应用是否已经正常工作：
```
curl http://localhost:8080/greeting
```
应该能够收到一个包含“Hello, world!”的JSON响应。
3. 测试前端应用
我们可以通过以下方式测试前端应用是否已经正常工作：
```
curl http://localhost:8081/
```
应该能够收到一个“Hello, world!”的HTML响应。
六、总结
本文介绍了如何使用Docker-Compose搭建一个简单的Spring Boot-MySQL-Nginx应用。我们从环境搭建、编写Docker-Compose文件、构建容器镜像、启动容器、测试应用等方面进行了具体的说明。通过Docker-Compose，我们可以在一次命令中启动三个容器，并快速、轻松地部署整个应用。