Docker-compose部署Springboot+Redis+Mysql

一、前言

docker-compose（服务编排工具）：Compose 是用于定义和运行多容器 Docker 应用程序的工具。通过 Compose，您可以使用 YML 文件来配置应用程序需要的所有服务。然后，使用一个命令，就可以从 YML 文件配置中创建并启动所有服务。

二、源码

Gitee地址：https://gitee.com/niusongcun/repair-manager.git

三、Springboot项目

3.1、配置文件

server:
  port: 8081

# DataSource Config
spring:
  redis:
    host: redis
    port: 6379
  datasource:
    host: mysql
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://${spring.datasource.host}:3306/repair?useUnicode=true&useSSL=false&characterEncoding=utf8&serverTimezone=Asia/Shanghai
    username: root
    password: 123456
  aop:
    proxy-target-class: true
  servlet:
    multipart:
      max-file-size: 10MB   #单个文件上传发大小
      max-request-size: 100MB  #多个文件上传的共大小不得超过100M

注：这里专门把 host 都配置为镜像文件的名字 环境

3.2、服务代码

这里以简单的从数据库查询和使用redis缓存验证码为例子

3.2.1、数据库查询服务

package com.zzuli.controller;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.zzuli.common.lang.Result;
import com.zzuli.entity.DeviceInfo;
import com.zzuli.service.DeviceInfoService;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.omg.CORBA.INTERNAL;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @author 关注公众号：One图云
 * @since 2021-05-17
 */
@RestController
@RequestMapping("/device")
@CrossOrigin(origins = "*", maxAge = 3600)
public class DeviceInfoController {

    @Autowired
    private DeviceInfoService deviceInfoService;


//    查询
    @GetMapping("/getOne/{deviceId}")
    public Result getOne(@PathVariable("deviceId") Integer deviceId){
        DeviceInfo deviceInfo = deviceInfoService.getById(deviceId);
        if (deviceId != null){
            return Result.succ(deviceInfo);
        }else{
            return Result.fail("查询失败");
        }
    }

}

3.2.2、Redis缓存验证码服务

package com.zzuli.common.veriCode;

import cn.hutool.core.lang.UUID;
import com.google.code.kaptcha.Constants;
import com.google.code.kaptcha.impl.DefaultKaptcha;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;

import javax.imageio.ImageIO;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.util.Random;
import java.util.concurrent.TimeUnit;

/*
验证码
 */

@Controller
public class CommonController {

    @Autowired
    private DefaultKaptcha captchaProducer;

    @Autowired
    private RedisTemplate<Object,Object> redisTemplate;  //Redis

    @GetMapping("/common/kaptcha")
    public void defaultKaptcha(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        byte[] captchaOutputStream = null;
        ByteArrayOutputStream imgOutputStream = new ByteArrayOutputStream();
        try {
            //生产验证码字符串并保存到session中
            String verifyCode = captchaProducer.createText();
            httpServletRequest.getSession().setAttribute("code", verifyCode);
          // 将验证码存入Redis中   60秒过期时间
            redisTemplate.opsForValue().set(Constants.KAPTCHA_SESSION_KEY,verifyCode,60, TimeUnit.SECONDS);

            BufferedImage challenge = captchaProducer.createImage(verifyCode);
            ImageIO.write(challenge, "jpg", imgOutputStream);
        } catch (IllegalArgumentException e) {
            httpServletResponse.sendError(HttpServletResponse.SC_NOT_FOUND);
            return;
        }
        captchaOutputStream = imgOutputStream.toByteArray();
        httpServletResponse.setHeader("Cache-Control", "no-store");
        httpServletResponse.setHeader("Pragma", "no-cache");
        httpServletResponse.setDateHeader("Expires", 0);
        httpServletResponse.setContentType("image/jpeg");
        ServletOutputStream responseOutputStream = httpServletResponse.getOutputStream();
        responseOutputStream.write(captchaOutputStream);
        responseOutputStream.flush();
        responseOutputStream.close();
    }
}

四、 Dockerfile文件

FROM java:8
COPY *.jar /app.jar

VOLUME /tmp

CMD ["--server.port=8081"]

EXPOSE 8081

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

FROM Java：8：基础镜像环境 JDK1.8
VOLUME /tmp：指定了挂载目录
CMD ["--server.port=8081"]：Dockerfile文件运行时执行的命令
EXPOSE 8081： 表示暴露端口8081
COPY *.jar /app.jar：把指定的 jar 包拷贝到 Docker 容器中并命名为 app.jar
ENTRYPOINT ["java","-jar","/app.jar"]：启动服务

五、docker-compose.yaml

5.1、文件说明

此文件的默认名称为 docker-compose，后缀名可以为 .yml 也可以为 .yaml。

这个 docker-compose.yaml 文件对应的就是上面所说的工程。

5.2、services

version: '3'
 
services:
 
    redis:
        ...
    
    mysql:
        ...
    
    service_springboot:
        ...
    
 

包含此工程中所有的服务列表。

服务可以是已存在的镜像（本地或远程），也可以是构建出来的镜像；如果其中有需要构建的镜像，则需要一个 Dockerfile 文件，正如此次部署我们需要构建 Springboot 镜像。

5.3、redis

redis:
    container_name: container_redis
    image: "library/redis:alpine"
    environment:
      - TZ=Asia/Shanghai
    ports:
      - "6379:6379"
    volumes:
      - ./config/redis/redis.conf:/usr/local/etc/redis/redis.conf
      - ./data/redis/:/data/
      - ./log/redis/:/var/log/redis/
    command: redis-server /usr/local/etc/redis/redis.conf
    restart: always

Redis 服务描述：

redis：服务名称，可自定义。

container_name：容器名称，可自定义；也可不写，那会自动生成，生成规则为 【docker-compose.yaml 文件的父目录名称 + _ + 服务名称 + 从一开始的数字】。

image：指定镜像来启动容器。此处指定为 Redis 官方镜像。

environment：为启动的容器添加环境变量。此处配置了容器的时区。

ports：端口映射，映射规则为 宿主机端口:容器端口。此处映射 宿主机 6379 端口到 容器 6379 端口。

volumes：配置映射，映射规则为 宿主机:容器，可以映射文件或目录。此处映射了 配置文件，数据目录以及日志目录。

command：容器启动后执行的命令。此处命令为 使用配置文件来启动 Redis 容器。

restart：赋固定值 always，表示如果容器启动失败，会一直尝试重连。

5.4、mysql

mysql:
    container_name: container_mysql
    image: mysql:5.7
    environment:
      TZ: Asia/Shanghai
      MYSQL_ROOT_PASSWORD: 123456
      MYSQL_ROOT_HOST: '%'
    ports:
      - "3306:3306"
    volumes:
      - ./config/mysql/my.cnf:/etc/mysql/conf.d/my.cnf
      - ./data/mysql/:/var/lib/mysql/
      - ./data/init/:/docker-entrypoint-initdb.d/
      - ./log/mysql/:/var/log/mysql/
    command: [
      '--character-set-server=utf8mb4',
      '--collation-server=utf8mb4_unicode_ci'
    ]
    restart: always

MySQL 服务描述：

mysql：服务名称，可自定义。

container_name：容器名称，可自定义；也可不写，那会自动生成，生成规则为 【docker-compose.yaml 文件的父目录名称 + _ + 服务名称 + 从一开始的数字】。

image：指定镜像来启动容器。此处指定为 MySQL 官方镜像，版本为 5.7。

environment：为启动的容器添加环境变量。此处配置了容器的时区，以及数据库 ROOT 密码和权限。

ports：端口映射，映射规则为 宿主机端口:容器端口。此处映射 宿主机 3306 端口到 容器 3306 端口。

volumes：配置映射，映射规则为 宿主机:容器，可以映射文件或目录。此处映射了 配置文件，数据目录，初始化 SQL 目录以及日志目录。

command：容器启动后执行的命令。此处命令为 设置字符编码。

restart：赋固定值 always，表示如果容器启动失败，会一直尝试重连。

5.5、service_springboot

service_springboot:
    build:
      context: .
      dockerfile: Dockerfile
    environment:
      TZ: Asia/Shanghai

    ports:
    - "8081:8081"
    depends_on:
      - redis
      - mysql
    restart: always

SpringBoot 服务描述：

service_springboot：服务名称，可自定义。

此处没有指定容器名称，是因为在启动工程时，会加上 scale 参数，此服务会被实例出多个容器，如果指定了容器名称，则会报错。这时容器名称会自动生成，生成规则为 【docker-compose.yaml 文件的父目录名称 + _ + 服务名称 + 从一开始的数字】。

build：指定 Dockerfile 文件位置，构建镜像，并使用这个镜像来启动容器。

environment：为启动的容器添加环境变量。此处配置了容器的时区；并指定了 MySQL 的 host 为 service_mysql 服务，Redis 的 host 为 service_redis 服务，这两个 host 正是对应 SpringBoot 项目的配置文件（application.properties）中两个 host；这也是上面提到的 用代码主动做处理。（注：由于 MySQL 服务和 Redis 服务都只有一个，所有这里指定服务名和容器名都是可以的）

ports：端口映射，映射规则为 宿主机端口:容器端口。此处映射 宿主机 8081端口到 容器 8081端口。
depends_on：依赖服务。在整个工程启动时，会先启动依赖服务，再启动当前服务。也就是说，这里 SpringBoot 服务会等待 MySQL 服务和 Redis 服务启动完成后，才会开始启动,服务名称就是自定义服务的名字

restart：赋固定值 always，表示如果容器启动失败，会一直尝试重连。

六、部署项目

6.1、安装环境

以下是centos7安装教程

安装Docker
安装Docker-compose

6.2、上传文件

将Springboot的jar包、Dockerfile文件以及 docker-compose.yaml文件拷贝到服务器上的一个单独目录

6.3、启动

启动Docker

systemctl start docker.service

部署项目

docker-compose up

如果docker-compose up失败可以换docker-compose up --build试一下

查看

部署成功

七、测试访问

前提是所有测试端口都已经打开，并支持外网访问

ifconfig

服务器ip

7.1、连接数据库

导入SQL文件

7.2、连接Redis

Redis可视化工具下载：https://github.com/qishibo/AnotherRedisDesktopManager.git

使用Redis可视化工具查看Redis是否部署成功

连接成功表示Redis部署成功

7.3、测试项目

7.3.1、数据库查询服务测试

7.3.2、Redis缓存验证码服务测试

八、问题

项目部署在网站上，所有的Ajax请求应该是服务器的IP.不能是localhost或者127.0.0.1

如果要停止服务比忘记删除镜像容器
删除所有镜像docker rmi -f $(docker images -qa)
删除所有容器docker rm $(docker ps -aq)
删除所有服务docker service rm $(docker service ls)

最后附上参考博客https://blog.csdn.net/qq_41402200/article/details/102585935
其它镜像的编排方式
mongodb：https://blog.csdn.net/yaobaoyu/article/details/106792226