docker-compose + spring boot + mysql + redis + nginx 发布web应用： part 1

-----**  原创 **------

docker的使用现在越来越多，但多个容器的话，还要一个个的安装，比较麻烦。相比于k8s的“厚重”，docker-compose相对要简单得多。这里是一篇使用docker-compose，对spring boot应用进行一个集群（2个docker)发布的过程。

1. 前言
 
  架构：spring boot使用nginx作为反向代理，redis作为缓存，mysql作为数据库，全部docker化。
  环境：开发使用win 10笔记本, eclipse ide, maven. 这个是大家平时使用的。当然也有用idea的。
        发布环境：百度云的一个ecs, 1核2G. centos 7.x

本篇是第一部分，主要是spring boot应用。 第二部分看这里

2. spring boot的小应用
 
  一般情况下， spring boot应用都会用到redis, mysql。
  本例中redis是作为一个api调用的计数器，mysql有一个表，存储docker-compose命令及其描述（部分，为boot应用提供数据是主要功能）

好了，先来个项目结构图

然后直接上各种代码：没有行号，方便复制粘贴,  : )

1) pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>ex.dockercompose</groupId>
    <artifactId>compose-demo</artifactId>
    <version>1.0</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.1.RELEASE</version>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

         <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <fork>true</fork>
                    <mainClass>ex.dockercompose.DemoApplication</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

        </plugins>
    </build>

</project>

2) DemoApplication.java

@SpringBootApplication
public class DemoApplication {

    public static void main(String... args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

3) RedisConfig.java

@Configuration
public class RedisConfig {

    @Autowired
    private RedisConnectionFactory connectionFactory;

    @Bean
    public RedisTemplate<String, Integer> redisTemplate() {
        RedisTemplate<String, Integer> redisTemplate = new RedisTemplate<>();
        RedisSerializer<String> stringSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringSerializer);
        redisTemplate.setConnectionFactory(connectionFactory);

        return redisTemplate;
    }
}

4) CommandController.java

@RestController
public class CommandController {

    @Autowired
    private CommandService commandService;

    @GetMapping("/commands")
    @ResponseBody
    public List<Command> getCommands() {

        return commandService.getCommands();
    }
}

5) RedisController.java

@RestController
public class RedisController {

    @Autowired
    private RedisTemplate<String, Integer> redisTemplate;

    @GetMapping("/redis")
    @ResponseBody
    public String getValue(HttpServletRequest request) {
        String localAddress = request.getLocalAddr();

        Integer counter = redisTemplate.opsForValue().get("counter");
        if(counter == null) {
            counter = 0;
        }

        counter++;
        redisTemplate.opsForValue().set("counter", counter);

        return localAddress + " => " + counter;
    }
}

6) CommandDao.java

@Mapper
public interface CommandDao {

    @Select("select id, command, description from command order by id")
    List<Command> getCommands();
}

7) Command.java

public class Command {
    private int id;
    private String command;
    private String description;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return command;
    }
    public void setName(String name) {
        this.command = name;
    }
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
}

8) CommandService.java

@Service
public class CommandService {

    @Autowired
    private CommandDao commandDao;

    public List<Command> getCommands() {
        return commandDao.getCommands();
    }
}

9) application-compose.yml    (mysql是指docker-compose.yml里的mysql服务名)

server.port: 10101

spring:
  datasource:
    url: jdbc:mysql://mysql:3306/compose?serverTimezone=GMT%2B8
    username: boot
    password: boot123

  redis:
    host: redis
    port: 6379
    password: redis123

10) application-dev.yml  (本地开发时用)

server.port: 10101

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/compose?serverTimezone=GMT%2B8
    username: root
    password: 

  redis:
    host: 127.0.0.1
    port: 6379
    password: redis123

11) application.yml  (开发时用)

spring.profiles.active: dev

12) build.bat  这个文件稍加说明一下：使用这个脚本，是为了方便。只要鼠标双击这个文件即可在同一文件夹里生成 jar文件。

如果不用这个脚本，要在pom.xml所在目录， cmd里运行 mvn package， 生成的jar会在 target 文件夹里，喜欢用哪个自己选。

del target\compose-demo-1.0.jar
call mvn package
copy target\compose-demo-1.0.jar .
pause

13) compose.sql   初始化数据库用，这个在第二部分讲

-- ----------------------------
-- Create database
-- ----------------------------
DROP DATABASE IF EXISTS compose;
CREATE DATABASE compose DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_general_ci;

use compose;

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for command
-- ----------------------------
DROP TABLE IF EXISTS `command`;
CREATE TABLE `command` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `command` varchar(30) DEFAULT NULL,
  `description` varchar(100) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of command
-- ----------------------------
INSERT INTO `command` VALUES (‘1‘, ‘build‘, ‘Build or rebuild services‘);
INSERT INTO `command` VALUES (‘2‘, ‘bundle‘, ‘Generate a Docker bundle from the Compose file‘);
INSERT INTO `command` VALUES (‘3‘, ‘config‘, ‘Validate and view the Compose file‘);
INSERT INTO `command` VALUES (‘4‘, ‘create‘, ‘Create services‘);
INSERT INTO `command` VALUES (‘5‘, ‘down‘, ‘Stop and remove containers,  networks, images, and volumns‘);
INSERT INTO `command` VALUES (‘6‘, ‘events‘, ‘Receivve real time events from containers‘);
INSERT INTO `command` VALUES (‘7‘, ‘exec‘, ‘Excecute a command in a running container‘);
INSERT INTO `command` VALUES (‘8‘, ‘help‘, ‘Get help on a command‘);

14) docker-compose.yml   第三部分讲

version: ‘3‘

services:
  nginx:
    image: nginx:1.15
    volumes:
      - ./:/etc/nginx/conf.d
    ports:
      - 80:80
      - 443:443
    links:
      - spring-boot-1
      - spring-boot-2
    depends_on:
      - spring-boot-1
      - spring-boot-2

  mysql:
    image: mysql:5.7
    volumes:
      - db_data:/var/lib/mysql
    restart: always
    environment:
      MYSQL_ROOT_HOST: ‘%‘
      MYSQL_ROOT_PASSWORD: root123
      MYSQL_DATABASE: compose
      MYSQL_USER: boot
      MYSQL_PASSWORD: boot123

  redis:
    image: redis
    container_name: my_redis
    command: redis-server --requirepass redis123
    ports:
      - "6379:6379"

  spring-boot-1:
    image: compose-demo:1.0
    # build: .
    # ports:
    #   - "10101:10101"
    expose:
      - "10101"
    restart: always

    depends_on:
      - mysql
      - redis

  spring-boot-2:
    image: compose-demo:1.0
    # build: .
    expose:
      - "10101"
    restart: always

    depends_on:
      - mysql
      - redis

volumes:
  db_data:

15) Dockerfile

FROM java:8
COPY compose-demo-1.0.jar compose-demo-1.0.jar
ENV JAVA_OPTS=""
ENTRYPOINT exec java $JAVA_OPTS -Dspring.profiles.active=compose -jar compose-demo-1.0.jar

16) nginx.conf

upstream boots {
    server spring-boot-1:10101;
    server spring-boot-2:10101;
}

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

    location / {
        proxy_pass http://boots;
        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;
    }
}

3. 测试

先用compose.sql 生成相应的数据库。 然后本地运行一下。

4. 打包

为了

好了，本篇基本上是boot应用相关。 docker相关的部分在第二部分中讲解。

原文地址：https://www.cnblogs.com/bear129/p/12523573.html

时间： 2024-10-02 00:02:39

docker-compose + spring boot + mysql + redis + nginx 发布web应用： part 1的相关文章

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

我知道大家这段时间看了我写关于 docker 相关的几篇文章,不疼不痒的,仍然没有感受 docker 的便利,是的,我也是这样认为的,I know your felling . 前期了解概念什么的确实比较无聊,请不要着急精彩马上开始,当大家对 docker 相关概念有所了解之后,后面我会结合 Spring Boot 给大家来一系列的小例子,会让大家感受到使用 Docker 就是这么爽! 今天给大家演出的导演是 Docker 家族的 docker-compare ,主演是 Spring Boot.

【spring boot】【redis】spring boot 集成redis的发布订阅机制

一.简单介绍 1.redis的发布订阅功能,很简单. 消息发布者和消息订阅者互相不认得,也不关心对方有谁. 消息发布者,将消息发送给频道(channel). 然后是由 频道(channel)将消息发送给对自己感兴趣的 消息订阅者们,进行消费. 2.redis的发布订阅和专业的MQ相比较 1>redis的发布订阅只是最基本的功能,不支持持久化,消息发布者将消息发送给频道.如果没有订阅者消费,消息就丢失了. 2>在消息发布过程中,如果客户端和服务器连接超时,MQ会有重试机制,事务回滚等.但是Red

Spring Boot 2.0(六)：使用 Docker 部署 Spring Boot 开源软件云收

只需三步即可部署开源项目云收藏,打造专属个人的收藏系统,就是这么简单! 云收藏项目已经开源2年多了,作为当初刚开始学习 Spring Boot 的练手项目,使用了很多当时很新的技术,现在看来其实很多新技术是没有必要使用的,但做为学习案例来讲确实是一个绝佳的 Spring Boot 实践. 从开源到现在,写了一些教程给大家介绍如何部署云收藏,如何在IDE中运行云收藏,但是仍然有很多的朋友不知道如何使用,如何部署?就像"请提供一份云收藏数据结构" 这样的问题我至少都回答了一百多次,并且在

Spring boot、Redis、ActiveMQ、Nginx、Mycat、Netty、Jvm大型分布式项目实战视频教程

15套java架构师.集群.高可用.高可扩展.高性能.高并发.性能优化.Spring boot.Redis.ActiveMQ.Nginx.Mycat.Netty.Jvm大型分布式项目实战视频教程 视频课程内容包含: 高级Java架构师包含:Spring boot.Spring  cloud.Dubbo.Redis.ActiveMQ.Nginx.Mycat.Spring.MongoDB.ZeroMQ.Git.Nosql.Jvm.Mecached.Netty.Nio.Mina.性能调优.高并发.to

微服务架构实践 - 你只懂docker与spring boot就够了吗？

微服务架构实践 - 你只懂docker与spring boot就够了吗? 作者 浮云发发 已关注 2017.02.27 02:50* 字数 2613 阅读 2583评论 6喜欢 35赞赏 2 微服务并不是单独存在的,为了更好地实现微服务架构,需要整合许多组件混搭使用,方能打通任督二脉,天下无敌.网上很多大拿讲了微服务治理的内容,也有人单方面讲微服务的,比如spring boot与docker,本文着重于组件选型的较量,也积累了我们团队多次PK的精华:这些组件包括spring boot.sprin

Spring Boot使用redis实现数据缓存

基于Spring Boot 1.5.2.RELEASE版本,一方面验证与Redis的集成方法,另外了解使用方法. 集成方法 配置依赖 修改pom.xml,增加如下内容. <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> 配置Redis

【redis】spring boot利用redis的Keyspace Notifications实现消息通知

前言 需求:当redis中的某个key失效的时候,把失效时的value写入数据库. github: https://github.com/vergilyn/RedisSamples 1.修改redis.conf 安装的redis服务默认是: notify-keyspace-events "",修改成 notify-keyspace-events Ex; 位置:redis安装目下的redis.windows-service.conf 或 redis.windows.conf.(具体看re

Spring Boot 和 Redis 常用操作

1    第4-2课:Spring Boot 和 Redis 常用操作 Redis 是目前使用最广泛的缓存中间件,相比 Memcached,Redis 支持更多的数据结构和更丰富的数据操作,另外 Redis 有着丰富的集群方案和使用场景,这一课我们一起学习 Redis 的常用操作. 1.1    Redis 介绍 Redis 是一个速度非常快的非关系数据库(Non-Relational Database),它可以存储键(Key)与 5 种不同类型的值(Value)之间的映射(Mapping),可

spring boot,gradle,redis

今天做spring boot/gradle/redis相关的项目,遇到若干问题,记录如下: spring boot  org.springframework.session.data.redis.RedisFlushMode 这个报错是与redis服务器连接的问题,查看一下在application.properties里写的redis服务器IP是不是错了,改正即可;或者redis服务器启用了protected-mode,运行Redis时使用命令: nohup redis-server --pro