Docker Compose + Spring Boot + Nginx + Mysql 的奇妙之旅

首先要感谢纯洁的微笑的这篇博客 博客地址：http://www.ityouknow.com/springboot/2018/03/28/dockercompose-springboot-mysql-nginx.html

首先要安装docker Compose，在安装docker Compose之前，你要先安装docker ，我用的是centos7 

使用yum安装

[root@ip-192-168-61-152 ~]# yum install docker -y

启动docker

[root@ip-192-168-61-152 ~]# systemctl start docker.service
接下来就是安装docker Compose了

Docker Compose 是 Docker 的独立产品，因此需要安装 Docker 之后在单独安装 Docker Compose .

方法一：

#下载
sudo curl -L https://github.com/docker/compose/releases/download/1.20.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose

#安装
chmod +x /usr/local/bin/docker-compose
#查看版本
docker-compose version

方法二：

#安装pip
yum -y install epel-release
yum -y install python-pip
#确认版本
pip --version
#更新pip
pip install --upgrade pip
#安装docker-compose
pip install docker-compose 
#查看版本
docker-compose version

推荐使用方法一进行安装，安装成功后输入docker-compose version会返回 docker-compose 的版本信息，如下：

[root@ip-192-168-61-152 ~]# docker-compose version
docker-compose version 1.20.0, build ca8d3c6
docker-py version: 3.1.3
CPython version: 3.6.4
OpenSSL version: OpenSSL 1.0.1t  3 May 2016
 

出现以上信息，表明 docker-compose 安装成功

安装补全工具(可选)

为了方便我们输入命令，也可以安装 Docker 的补全提示工具帮忙我们快速输入命令

#安装
yum install bash-completion

#下载docker-compose脚本
curl -L https://raw.githubusercontent.com/docker/compose/$(docker-compose version --short)/contrib/completion/bash/docker-compose > /etc/bash_completion.d/docker-compose

快速上手

没有什么比来一个小例子练练手更好的学习方法了，我们以官网上的简单示例来看看 docker compose 的使用方法。

我们设计这么一个场景，使用 Python 启动一个 Web 服务，输出一个hello()方法，每次访问的时候在 Redis 缓存中进行计数，并且将统计的结果打印到页面中。

第一步，创建 Python 服务

创建项目路径:

mkdir composetest
cd composetest

在目录下创建app.py文件

import time

import redis
from flask import Flask

app = Flask(__name__)
cache = redis.Redis(host='redis', port=6379)

def get_hit_count():
    retries = 5
    while True:
        try:
            return cache.incr('hits')
        except redis.exceptions.ConnectionError as exc:
            if retries == 0:
                raise exc
            retries -= 1
            time.sleep(0.5)

@app.route('/')
def hello():
    count = get_hit_count()
    return 'Hello World! I have been seen {} times.\n'.format(count)

if __name__ == "__main__":
    app.run(host="0.0.0.0", debug=True)

在这个例子中, redis 使用了容器内的网络默认端口是6379。这段 Python 程序的内容就是，启动后连接 Redis 并且输出 hello()方法，当每次访问的时候累计访问次数并且将结果放回到页面。

在同目录下创建requirements.txt文件，添加项目依赖的python包：

flask
redis

Flask 是 Python 中一个微型的 Web 开发框架。

第二步，创建 Dockerfile

我们来写一个 Dockerfile 来定义 Docker 镜像，此镜像包含了 Python 的依赖包和 Python 环境。

同样在此目录下，我们创建一个 Dockerfile 文件。

FROM python:3.4-alpine
ADD . /code
WORKDIR /code
RUN pip install -r requirements.txt
CMD ["python", "app.py"]

这段代码表示:

• 使用基础镜像 Python 3.4
• 将当前目录映射到镜像/code目录下
• 设置工作目录为 /code
• 安装 Python 依赖包
• 启动 app.py 程序

第三步，使用 Compose 文件定义一个服务

在当期目录下，我们创建一个 docker-compose.yml 文件，内容如下：

version: '2'
services:
  web:
    build: .
    ports:
     - "5000:5000"
  redis:
    image: "redis:alpine"

这个 Compose 文件定义了两个服务, 一个 Pyhon Web 服务和 redis 服务。

• Pyhon Web 服务：使用 Dockerfile 构建了当前镜像。将 Web 容器内部的5000端口映射到 host 的5000端口；并将 Web 容器与 redis 容器连接。
• redis服务：该容器直接由官方的 redis 镜像创建。

第四步，使用 Compose 编译启动应用

使用命令docker-compose up启动

启动成功之后，在浏览器访问：http://ipaddress:5000/ ，返回如下：

Hello World! I have been seen 1 times.

刷新再次访问返回

Hello World! I have been seen 2 times.

不断的刷新数字会不断的增长。

以上都是本次项目的准备工作，现在我们正式开始写SpringBoot项目，首先新建一个maven项目，添加依赖

<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 驱动包等。

配置文件

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

核心代码

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

@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 文件夹，在此目录下进行配置。

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文件配置信息进行启动。

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 的名称进行访问。

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

启动服务：docker-compose up 或者使用docker-compose up -d在后台启动服务

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

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

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

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

关闭服务docker-compose down

docker-compose 顺序

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

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

1、足够的容错和重试机制，比如连接数据库，在初次连接不上的时候，服务消费者可以不断重试，直到连接上服务。也就是在服务中定义： restart: always

2、同步等待，使用wait-for-it.sh或者其他shell脚本将当前服务启动阻塞，直到被依赖的服务加载完毕。这种方案后期可以尝试使用。

示例代码-github