SpringCloud构建微服务之Ribbon负载均衡

红太狼 2021-11-29 08:02 408阅读 0赞

## 前言 ##

大家应该都知道，服务要想能够扛住高并发，能够高可用，那么**负载均衡**是必不可少的。我们将已前面所讲的内容为基础，增加Ribbon组件来提供客户端的负载均衡。达到可以把请求分散到一个集群中不同的服务器中，以减轻每个服务器的负担。

## 什么是Ribbon？ ##

Spring Cloud Ribbon是基于Netflix Ribbon实现的一套**客户端 负载均衡的工具**。

简单的说，Ribbon是Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法，将Netflix的中间层服务连接在一起。Ribbon客户端组件提供一系列完善的配置项如连接超时，重试等。简单的说，就是在配置文件中列出Load Balancer（简称LB）后面所有的机器，Ribbon会自动的帮助你基于某种规则（如简单轮询，随机连接等）去连接这些机器。我们也很容易使用Ribbon实现自定义的负载均衡算法。

LB，即负载均衡(Load Balance)，在微服务或分布式集群中经常用的一种应用。  
负载均衡简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA。  
常见的负载均衡有软件Nginx，LVS，硬件 F5等。  
相应的在中间件，例如：dubbo和SpringCloud中均给我们提供了负载均衡， SpringCloud的负载均衡算法可以自定义。

负载均衡分类：

*  集中式LB：即在服务的消费方和提供方之间使用独立的LB设施(可以是硬件，如F5, 也可以是软件，如nginx), 由该设施负责把访问请求通过某种策略转发至服务的提供方；
 *  进程内LB：将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选择出一个合适的服务器。  
    Ribbon就属于进程内LB ，它只是一个类库，集成于消费方进程，消费方通过它来获取到服务提供方的地址。

Ribbon官方文档：[https://github.com/Netflix/ribbon/wiki][https_github.com_Netflix_ribbon_wiki]

## Ribbon初步配置 ##

修改服务消费者`pom`文件，增加`Ribbon`依赖：

<dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-ribbon</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-config</artifactId>
    </dependency>

完整pom如下：

<?xml version="1.0" encoding="UTF-8"?>
    <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">
        <parent>
            <artifactId>spring-cloud-examples</artifactId>
            <groupId>com.chaytech</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>spring-cloud-consumer-user</artifactId>
        <packaging>jar</packaging>
    
        <dependencies>
            <dependency>
                <groupId>com.chaytech</groupId>
                <artifactId>spring-cloud-model</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-eureka</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-ribbon</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-config</artifactId>
            </dependency>
    
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>springloaded</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-devtools</artifactId>
            </dependency>
        </dependencies>
    </project>

修改application.yml文件，增加eureka配置

eureka:
      client: #客户端注册进eureka服务列表内
        register-with-eureka: false
        service-url:
          defaultZone: http://eureka7001:7001/eureka/,http://eureka7002:7002/eureka/,http://eureka7003:7003/eureka/ #（集群）

修改`RestTemplateConfig`，加上`@LoadBalanced`注解，在获得Rest时加入Ribbon的配置

@Configuration
    public class RestTemplateConfig {
    
        @Bean
        @LoadBalanced // 对ConfigBean进行新注解@LoadBalanced  获得Rest时加入Ribbon的配置
        public RestTemplate getRestTemplate() {
            return new RestTemplate();
        }
    }

启动类加上`@EnableEurekaClient`注解，代表此服务是eureka客户端，服务启动后会自动注册进eureka服务中

@SpringBootApplication
    // 本服务启动后会自动注册进eureka服务中
    @EnableEurekaClient
    public class UserConsumer80_Application {
    
        public static void main(String[] args) {
            SpringApplication.run(UserConsumer80_Application.class,args);
        }
    }

修改服务提供者`controller`，将请求地址前缀，IP形式改为服务名称形式

@RestController
    public class UserController {
    
        // private static final String REST_URL_PREFIX = "http://127.0.0.1:8001";
        private static final String REST_URL_PREFIX = "http://USER-PROVIDER";
    
        @Autowired
        private RestTemplate restTemplate;
    
        @PostMapping("/consumer/user/add")
        public boolean add(UserEntity user) {
            return restTemplate.postForObject(REST_URL_PREFIX + "/user/createUser", user, Boolean.class);
        }
    
        @GetMapping("/consumer/user/getUser/{id}")
        public UserEntity get(@PathVariable("id") Integer id) {
            return restTemplate.getForObject(REST_URL_PREFIX + "/user/getUser/" + id, UserEntity.class);
        }
    
        @SuppressWarnings("unchecked")
        @GetMapping("/consumer/user/listUser")
        public List<UserEntity> list() {
            return restTemplate.getForObject(REST_URL_PREFIX + "/user/listUser", List.class);
        }
    
        @GetMapping("/consumer/user/discovery")
        public Object discovery() {
            return restTemplate.getForObject(REST_URL_PREFIX + "/user/discovery", Object.class);
        }
    }

依次启动eureka集群、服务提供者，服务消费者

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70]  
测试接口  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 1]  
可以看到能够正常访问

得到一个结论：`Ribbon`和`Eureka`整合后`Consumer`可以直接根据服务名调用服务而不用再关心地址和端口号

## Ribbon负载均衡 ##

Ribbon架构说明  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 2]  
Ribbon在工作时分成两步 ：

1.  第一步先选择 EurekaServer ,它优先选择在同一个区域内负载较少的server.
2.  第二步再根据用户指定的策略，在从server取到的服务注册列表中选择一个地址。  
    其中Ribbon提供了多种策略：比如轮询、随机和根据响应时间加权。

参照原有的`spring-cloud-provider-user`服务，再建两个相同的服务，端口号分别是`8002、8003`  
建好后的工程结构如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 3]  
在前面有说过微服务都是可以拥有自己独立的数据库，那么这两个新建的服务，也是拥有自己独立数据库的，分别是`spring_cloud_db02`、 `spring_cloud_db03`

`spring_cloud_db02` sql脚本

DROP DATABASE IF EXISTS spring_cloud_db02;
    CREATE DATABASE spring_cloud_db02 CHARACTER SET UTF8;
    USE spring_cloud_db02;
    
    DROP TABLE IF EXISTS `t_user`;
    CREATE TABLE `t_user`  (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `username` varchar(128) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
      `db_source` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
      PRIMARY KEY (`id`) USING BTREE
    ) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
    
    INSERT INTO `t_user(username,db_source) ` VALUES ( '小明', DATABASE());
    INSERT INTO `t_user(username,db_source) ` VALUES ('小红', DATABASE());

`spring_cloud_db03` sql脚本

DROP DATABASE IF EXISTS spring_cloud_db03;
    CREATE DATABASE spring_cloud_db03 CHARACTER SET UTF8;
    USE spring_cloud_db03;
    
    DROP TABLE IF EXISTS `t_user`;
    CREATE TABLE `t_user`  (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `username` varchar(128) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
      `db_source` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
      PRIMARY KEY (`id`) USING BTREE
    ) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
    
    INSERT INTO `t_user(username,db_source) ` VALUES ( '小明', DATABASE());
    INSERT INTO `t_user(username,db_source) ` VALUES ('小红', DATABASE());

将`spring-cloud-provider-user`服务的代码和配置文件copy一份到两个新工程里  
修改`spring-cloud-provider-user-8002`和`spring-cloud-provider-user-8003`服务的配置文件：  
主要修改内容就是，端口号、数据库链接、对外暴露的统一的服务实例名，完整yml如下：

`spring-cloud-provider-user-8002` application.yml

server:
      port: 8002
    
    mybatis:
      config-location: classpath:mybatis/mybatis-config.xml        # mybatis配置文件所在路径
      type-aliases-package: com.chaytech.model.*    # 所有Entity别名类所在包
      mapper-locations:
      - classpath:mybatis/mapper/**/*.xml                       # mapper映射文件
    
    spring:
       application:
        name: user-provider
       datasource:
        type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型
        driver-class-name: org.gjt.mm.mysql.Driver              # mysql驱动包
        url: jdbc:mysql://127.0.0.1:3306/spring_cloud_db02              # 数据库名称
        username: root
        password: root
        dbcp2:
          min-idle: 5                                           # 数据库连接池的最小维持连接数
          initial-size: 5                                       # 初始化连接数
          max-total: 5                                          # 最大连接数
          max-wait-millis: 200                                  # 等待连接获取的最大超时时间
    
    eureka:
      client: #客户端注册进eureka服务列表内
        service-url:
          #defaultZone: http://localhost:7001/eureka （单机）
          defaultZone: http://eureka7001:7001/eureka/,http://eureka7002:7002/eureka/,http://eureka7003:7003/eureka/ #（集群）
      instance:
        instance-id: user-provider8002 # 自定义服务名称信息
        prefer-ip-address: true # 访问路径可以现实IP
    info:
      app.name: user-provider
      build.artifactId: $project.artifactId$
      build.version: $project.version$

`spring-cloud-provider-user-8003` application.yml

server:
      port: 8003
    
    mybatis:
      config-location: classpath:mybatis/mybatis-config.xml        # mybatis配置文件所在路径
      type-aliases-package: com.chaytech.model.*    # 所有Entity别名类所在包
      mapper-locations:
      - classpath:mybatis/mapper/**/*.xml                       # mapper映射文件
    
    spring:
       application:
        name: user-provider
       datasource:
        type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型
        driver-class-name: org.gjt.mm.mysql.Driver              # mysql驱动包
        url: jdbc:mysql://127.0.0.1:3306/spring_cloud_db03              # 数据库名称
        username: root
        password: root
        dbcp2:
          min-idle: 5                                           # 数据库连接池的最小维持连接数
          initial-size: 5                                       # 初始化连接数
          max-total: 5                                          # 最大连接数
          max-wait-millis: 200                                  # 等待连接获取的最大超时时间
    
    eureka:
      client: #客户端注册进eureka服务列表内
        service-url:
          #defaultZone: http://localhost:7001/eureka （单机）
          defaultZone: http://eureka7001:7001/eureka/,http://eureka7002:7002/eureka/,http://eureka7003:7003/eureka/ #（集群）
      instance:
        instance-id: user-provider8003 # 自定义服务名称信息
        prefer-ip-address: true # 访问路径可以现实IP
    
    info:
      app.name: user-provider
      build.artifactId: $project.artifactId$
      build.version: $project.version$

ok，上述步骤做完之后，重启eureka集群，并启动`spring-cloud-provider-user`、`spring-cloud-provider-8002`、`spring-cloud-provider-8003`这些服务

访问注册中心  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 4]  
可以看到三个服务都分别注册到注册中心里了

测试三个服务，测试服务是否正常  
请求：127.0.01:8001/user/listUser  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 5]

请求：127.0.01:8002/user/listUser  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 6]

请求：127.0.01:8003/user/listUser  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 7]  
可以看到分别返回了不同的数据，服务正常。  
下面来启动消费者服务，请求同一个消费者服务的同一个接口，观察返回的数据

第一次请求：127.0.01:8080/consumer/user/listUser  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 8]

第二次请求：127.0.01:8080/consumer/user/listUser  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 9]

第三次请求：127.0.01:8080/consumer/user/listUser  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 10]

观察接口返回的结果里的数据库名字，各不相同，证明服务在不停的切换，也就达到了负载均衡

## 总结 ##

Ribbon其实就是一个软负载均衡的客户端组件，他可以和其他所需请求的客户端结合使用，和eureka结合只是其中的一个实例。

[https_github.com_Netflix_ribbon_wiki]: https://github.com/Netflix/ribbon/wiki
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70]: /images/20211129/38cab6dba48b4af1844445707c729993.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 1]: /images/20211129/f91bbad5362e473bad4a8a92a11fdb76.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 2]: /images/20211129/b107bac73dff46528334d3e3f770738b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 3]: /images/20211129/60bf02bcbe2e4bf2b5e2fd1abc2dc54c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 4]: /images/20211129/756b5c6b5f83433281cb8cab41f93062.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 5]: /images/20211129/e18e66f22def4529969541fb3f3c5baa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 6]: /images/20211129/6c235fb96cdc4e04bb6c37da803fd67a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 7]: /images/20211129/59687a7e5563424d9439f46f806b3189.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 8]: /images/20211129/cab320c309504a49ad0a50b8e8bd0228.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 9]: /images/20211129/5e271b32e56c49a6a2e28187c8f40fb3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 10]: /images/20211129/0bd509d5d155408cb44eaa2e90d42002.png