Ribbon负载均衡（三）SpringCloud Ribbon负载均衡详解及实现

已于 2022-05-24 16:57:57 修改
阅读量1.2k 收藏 2
点赞数
分类专栏： SpringCloud全家桶 文章标签： spring cloud ribbon 负载均衡 eureka移除ribbon ribbon负载均衡实现
于 2022-05-24 00:23:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010134642/article/details/124918820
版权

SpringCloud Ribbon负载均衡实现

文章目录


我们都知道 Springcloud 2020.0.1 版本之后 删除了eureka中的ribbon，替代ribbon的是spring cloud自带的LoadBalancer，但是SpringCloud 的LoadBalancer 只默认了两种策略， 轮询和随机， 其他的都要自定义实现，这就坑爹了 ， 不知道为啥坑爹的看看前面的文章
Ribbon负载均衡（一）Ribbon实战

比如： 我想按照权重取匹配优先级

我如何计算权重？Ribbon之前的方式是定时任务，每30s去访问Ping请求，计算请求时间，反应时间来算出权重，现在这么一套我要如何实现？我们不可能一 一实现这7种策略，所以我们还是要用SpringCloud 结合Ribbon 来使用他的负载均衡， 下面我们使用固定版本的SpringCloud来做demo
我使用的版本如下

本文使用的版本是
 Spring-boot-starter-parent <version>2.3.0.RELEASE</version> 
Spring-cloud-dependencies   <spring-cloud.version>Hoxton.SR1</spring-cloud.version>
引入上面的包后
自动就引入了Ribbon的版本 spring-cloud-starter-netflix-ribbon:2.2.1.RELEASE

Ribbon 一共7 种策略

  1. 轮询策略 RoundRobinRule
  2. 随机策略 RandomRule
  3. 轮询重试策略 RetryRule
  4. 响应速度决定权重 WeightedResponseTimeRule
  5. 最优可用 BestAvailableRule， 采用并发连接数判断最优，连接数最小的节点
  6. 可用性过滤规则 AvailabilityFilteringRule
  7. 区域内可用性能最优 ZoneAvoidanceRule

包依赖如图所示
在这里插入图片描述
本次我们使用四个微服务 + 一个Eureka注册中心 不知道如何构建的请参考前面的文章
Ribbon负载均衡（一）Ribbon实战

1.User客户端调用方

我们都知道 Ribbon是进程级别的负载均衡，而负载均衡策略实现是在调用端也就是client客户端，客户端user去判断你要调用的服务order有多少个服务注册到eureka上，而且客户端计算你每个order服务权重，计算每个order服务的请求时间，响应时间等等，所以我们的orderOne，orderTwo，orderThree这三个不用处理，因为他们order服务提供者

我们只需要改造user服务即可

我们改造一下

1.1 修改User服务，Pom文件，引入Ribbon

user微服务的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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <!--  2.6.7 和 springcloud Hoxton.SR1不匹配，  ribbon的2.2.1也不匹配        <version>2.6.7</version>-->
        <version>2.3.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.ribbon.user</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>user</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
        <!--        原来SpringCloud 版本种 没有了 Ribbon -->
        <!--        <spring-cloud.version>2021.0.2</spring-cloud.version>-->

        <spring-cloud.version>Hoxton.SR1</spring-cloud.version>


    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
            <scope>compile</scope>
        </dependency>

    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>
1.2 RibbonConfiguration配置

切记切记切记
在主启动类的最外层，不要把配置Ribbon的文件放在启动类及包扫描目录，也就是 java文件夹下 , 新建一个文件夹 ribbon
在这里插入图片描述

文件夹ribbon下新建 RibbonConfiguration.java

package ribbon;

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RibbonConfiguration {

    @Bean
    public IRule myRandomRule() {
        // 随机策略
        return new RandomRule();
    }


//    @Bean
//    public IRule myWeightedRule() {
//        // 权重优先
//        return new WeightedResponseTimeRule();
//    }
//
//
//    @Bean
//    public IRule myRoundRule() {
//        // 轮询策略
//        return new RoundRobinRule();
//    }
//
//
//    @Bean
//    public IRule myBestRule() {
//        // 最高可用策略
//        return new BestAvailableRule();
//    }

}
1.3 配置 RestTemplate访问Order订单服务

新建 config/ribbon 下面RestTemplateConfig.java 配置RestTemplate来访问Controller，使用Ribbon负载均衡

package com.ribbon.user.config.ribbon;//package com.ribbon.user.config.cloudconfig;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.netflix.ribbon.RibbonClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
import ribbon.RibbonConfiguration;


/**
 * 如果是 SpringCloud 使用Ribbon 配置下面的
 */
//在这里配置我们自定义的LoadBalancer策略
//注意这里的name属性 需要和eureka页面中的服务提供者名字保持一致
@RibbonClient(name = "order", configuration = RibbonConfiguration.class)
@Configuration
public class RestTemplateConfig {

    //如果不加上面的注释 @LoadBalanced 就不会从eureka上获取 order服务地址， 也就不会使用负载均衡，
    // 你访问的 http://order/order order服务的host就会找不到
    @Bean
    @LoadBalanced
    //使用这个     @LoadBalanced 注解给restTemplate赋予了负载均衡的能力
    RestTemplate restTemplate() {
        return new RestTemplate();
    }


}
1.4 配置 UserController 服务
package com.ribbon.user.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;

@RestController
@Slf4j
public class UserController {


    @Autowired
    private LoadBalancerClient loadBalancerClient;

    @Resource
    private RestTemplate restTemplate;

    @GetMapping("/user")
    public String test() {
        log.info("client 发起UserController");
        return "user";
    }


    @GetMapping("/client")
    public String client() {

        //通过Ribbon client 去实现负载均衡算法，获取URL信息
        log.info("client 开始调用");
        //我们选择的是eureka 上的 order 应用服务，因为我们直到 order有两个
        ServiceInstance order = loadBalancerClient.choose("order");
        log.info("Uri:{}", order.getUri());
        log.info("Host:{}", order.getHost());
        log.info("Port:{}", order.getPort());
        log.info("InstanceId:{}", order.getInstanceId());
        log.info("Metadata:{}", order.getMetadata());
        log.info("Weight:{}", order.getMetadata().get("weight"));
        log.info("ServiceId:{}", order.getServiceId());
        log.info("Scheme:{}", order.getScheme());
        log.info("==================================================");
        return "user";
    }


    @GetMapping("/testribbon")
    public String testRibbon() {


        //restTemplate 请求访问 order订单服务的 order URL ,
        // 参数URL   http://order/order   第一个order 就是服务名字 就是注册在Eureka上的 服务名字 第二个order就是 controller 入口
        // 第二个参数String.class 就是 访问返回值
        String result = restTemplate.getForObject("http://order/order", String.class);
        log.info("user 发起UserController 测试ribbon 调用 :{} ", result);
        return result;
    }


}
1.5 重启user服务

访问 localhost:8088/testribbon
如果报错， 看下你的RestTemplate种的@LoadBalanced 注解是否加上，不加上默认是使用正常的restTemplate 访问IP+PORT ，你的URL是 http://order/order 不会去Eureka上获取order服务的地址及端口的

没有@LoadBalanced 注解 会报如下错误
nested exception is java.net.UnknownHostException: order] with root cause
java.net.UnknownHostException: order

2022-05-15 21:51:03.169 ERROR 6216 --- [nio-8088-exec-1] o.a.c.c.C.[.[.[/].[dispatcherServlet]    : Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed; nested exception is org.springframework.web.client.ResourceAccessException: I/O error on GET request for "http://order/order": order; nested exception is java.net.UnknownHostException: order] with root cause

java.net.UnknownHostException: order
at java.net.AbstractPlainSocketImpl.connect(AbstractPlainSocketImpl.java:184) ~[na:1.8.0_181]

服务正常启动

2.测试Ribbon访问
2.1 随机访问 RandomRule

采用 随机负载均衡策略

    @Bean
    public IRule myRandomRule() {
        // 随机策略
        return new RandomRule();
    }

访问testribbon接口 http://localhost:8088/testribbon
看看RestTemplate访问的是否是随机访问三个节点中的一个

在这里插入图片描述

2.2 轮询访问 RoundRobinRule

RibbonConfiguration.java 种 把随机策略注释掉， 放开轮询策略

    @Bean
    public IRule myRoundRule() {
        // 轮询策略
        return new RoundRobinRule();
    }

重启User服务
访问testribbon接口 http://localhost:8088/testribbon
看看RestTemplate访问的是否是轮询访问三个节点中的一个

在这里插入图片描述

2.3 最优可用，也就是并发连接数最小的 BestAvailableRule

RibbonConfiguration.java 种 把轮询策略注释掉， 放开最优可用策略

    @Bean
    public IRule myBestRule() {
        // 最高可用策略
        return new BestAvailableRule();
    }

重启User服务
访问testribbon接口 http://localhost:8088/testribbon
看看RestTemplate访问的是否是 最优访问三个节点中的节点
在这里插入图片描述
是不是 最优解怎么确认？ 我们看下面的日志

DynamicServerListLoadBalancer for client order initialized: DynamicServerListLoadBalancer:{NFLoadBalancer:name=order,current list of Servers=[localhost:8090, localhost:8089, localhost:8091],Load balancer stats=Zone stats: {defaultzone=[Zone:defaultzone;	Instance count:3;	Active connections count: 0;	Circuit breaker tripped count: 0;	Active connections per server: 0.0;]
},Server stats: [[Server:localhost:8090;	Zone:defaultZone;	Total Requests:0;	Successive connection failure:0;	Total blackout seconds:0;	Last connection made:Thu Jan 01 08:00:00 CST 1970;	First connection made: Thu Jan 01 08:00:00 CST 1970;	Active Connections:0;	total failure count in last (1000) msecs:0;	average resp time:0.0;	90 percentile resp time:0.0;	95 percentile resp time:0.0;	min resp time:0.0;	max resp time:0.0;	stddev resp time:0.0]
, [Server:localhost:8091;	Zone:defaultZone;	Total Requests:0;	Successive connection failure:0;	Total blackout seconds:0;	Last connection made:Thu Jan 01 08:00:00 CST 1970;	First connection made: Thu Jan 01 08:00:00 CST 1970;	Active Connections:0;	total failure count in last (1000) msecs:0;	average resp time:0.0;	90 percentile resp time:0.0;	95 percentile resp time:0.0;	min resp time:0.0;	max resp time:0.0;	stddev resp time:0.0]
, [Server:localhost:8089;	Zone:defaultZone;	Total Requests:0;	Successive connection failure:0;	Total blackout seconds:0;	Last connection made:Thu Jan 01 08:00:00 CST 1970;	First connection made: Thu Jan 01 08:00:00 CST 1970;	Active Connections:0;	total failure count in last (1000) msecs:0;	average resp time:0.0;	90 percentile resp time:0.0;	95 percentile resp time:0.0;	min resp time:0.0;	max resp time:0.0;	stddev resp time:0.0]

什么意思，下面解释一下

#注册了三个地址
current list of Servers=[localhost:8090, localhost:8089, localhost:8091],
#8090 地址 
[Server:localhost:8090
# 总请求数量 0
Total Requests:0;
#连续（successive）请求异常数量 0
Successive connection failure:0;
#总的断路时长 0s
Total blackout seconds:0;	
# 活跃连接数 底层源码取的就是  activeRequestsCount
Active Connections:0;	
#一定时间内失败 连接数量
total failure count in last (1000) msecs:0;
#平均响应时间
average resp time:0.0;	
#90%，95%的请求响应时间
90 percentile resp time:0.0;	
95 percentile resp time:0.0;

因为 第一个就是8090， 因为是模拟的， 也没有请求，所以三个order服务的并发链接数都是0， 也就是orderTwo 相等于 orderOne和orderThree， 所以每次用最优选取的时候都会选第一个orderTwo

2.4 权重优先 WeightedResponseTimeRule

RibbonConfiguration.java 种 把最优可用策略注释掉， 放开权重优先策略

    @Bean
    public IRule myWeightedRule() {
        // 权重优先
        return new WeightedResponseTimeRule();
    }

重启User服务
http://localhost:8088/testribbon 访问testribbon接口
看看RestTemplate访问的是否是 权重优先三个节点中的节点
在这里插入图片描述

是不是 权重优先怎么确认？ 我们看下面的日志,节点选择不规则， 而且 日志
Weight adjusting job started 说明有定时任务在不停的计算权重， 到底是怎么计算的？

2022-05-24 00:00:11.922  INFO 15920 --- [nio-8088-exec-3] c.ribbon.user.controller.UserController  : user 发起UserController 测试ribbon 调用 :orderOne 
2022-05-24 00:00:12.466  INFO 15920 --- [nio-8088-exec-5] c.ribbon.user.controller.UserController  : user 发起UserController 测试ribbon 调用 :orderTwo 
2022-05-24 00:00:12.919  INFO 15920 --- [nio-8088-exec-4] c.ribbon.user.controller.UserController  : user 发起UserController 测试ribbon 调用 :orderThree 
2022-05-24 00:00:13.346  INFO 15920 --- [nio-8088-exec-6] c.ribbon.user.controller.UserController  : user 发起UserController 测试ribbon 调用 :orderOne 
2022-05-24 00:00:13.742  INFO 15920 --- [nio-8088-exec-7] c.ribbon.user.controller.UserController  : user 发起UserController 测试ribbon 调用 :orderOne 
2022-05-24 00:00:14.088  INFO 15920 --- [nio-8088-exec-9] c.ribbon.user.controller.UserController  : user 发起UserController 测试ribbon 调用 :orderThree 
2022-05-24 00:00:14.545  INFO 15920 --- [nio-8088-exec-8] c.ribbon.user.controller.UserController  : user 发起UserController 测试ribbon 调用 :orderTwo 
2022-05-24 00:00:14.909  INFO 15920 --- [io-8088-exec-10] c.ribbon.user.controller.UserController  : user 发起UserController 测试ribbon 调用 :orderTwo 
2022-05-24 00:00:15.123  INFO 15920 --- [nio-8088-exec-1] c.ribbon.user.controller.UserController  : user 发起UserController 测试ribbon 调用 :orderTwo 
2022-05-24 00:00:16.218  INFO 15920 --- [nio-8088-exec-2] c.ribbon.user.controller.UserController  : user 发起UserController 测试ribbon 调用 :orderTwo 
2022-05-24 00:00:16.632  INFO 15920 --- [nio-8088-exec-3] c.ribbon.user.controller.UserController  : user 发起UserController 测试ribbon 调用 :orderOne 
2022-05-24 00:00:26.597  INFO 15920 --- [ightTimer-order] c.n.l.WeightedResponseTimeRule           : Weight adjusting job started
2022-05-24 00:00:26.612  INFO 15920 --- [der_defaultzone] c.n.l.WeightedResponseTimeRule           : Weight adjusting job started
2022-05-24 00:00:27.627  INFO 15920 --- [der_defaultzone] c.n.l.WeightedResponseTimeRule           : Weight adjusting job started
2022-05-24 00:00:56.608  INFO 15920 --- [ightTimer-order] c.n.l.WeightedResponseTimeRule           : Weight adjusting job started
2022-05-24 00:00:56.624  INFO 15920 --- [der_defaultzone] c.n.l.WeightedResponseTimeRule           : Weight adjusting job started

权重计算过程
初始化时，启动一个定时器，每隔 30s 根据服务的响应时间分配一次权重，响应时间越长，权重越低，被选择到的概率也越低。响应时间越短，权重越高，实例被选中概率越高。得到权重后，生成随机权重，命中权重比随机权重大的第一个服务实例

先 看下权重优先 源码的注释

 * Using the Random API, generate a random number between 1 and10+30+40+20.
 * Let's assume that the above list is randomized. Based on the weights, we
 * have intervals as follows:
 * <p>
 * 1-----10 (A's weight)
 * <br>
 * 11----40 (A's weight + B's weight)
 * <br>
 * 41----80 (A's weight + B's weight + C's weight)
 * <br>
 * 81----100(A's weight + B's weight + C's weight + C's weight)
 * <p>
 * Here's the psuedo code for deciding where to send the request:
 * <p>
 * if (random_number between 1 &amp; 10) {send request to A;}
 * <br>
 * else if (random_number between 11 &amp; 40) {send request to B;}
 * <br>
 * else if (random_number between 41 &amp; 80) {send request to C;}
 * <br>
 * else if (random_number between 81 &amp; 100) {send request to D;}
 * <p>
 * When there is not enough statistics gathered for the servers, this rule
 * will fall back to use {@link RoundRobinRule}.

也就是说：现在有三个服务实例，平均响应时间分别为：
A：100ms
B：200ms
C：300ms
则权重分别是：
A：600-100 = 500
B：500+600-200 = 900
C：900+600-300 = 1200
生成的随机数若在 0-500 之间，则命中服务 A，如在 500 - 900 之间，则命中服务 B，如在 900 - 1200，则命中服务 C，如果没有命中任何服务实例，则取轮询策略的结果。

我还没找打 怎么把权重打印出来， 因为源码中打印了Weight adjusting job started ，改源码肯定是可以的，但是应该有更简洁的方法，暂时我还没找到而已

至此我们已经 可以熟练的使用Ribbon了 ， 也可以定制自己的负载均衡策略， 除了这7种，也可以自定义负载均衡策略 ，比如A机器5次，换B机器5次，换C机器这样的自定义负载均衡

jzjie
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解spring cloud中使用Ribbon实现客户端的软负载均衡
08-28
主要介绍了详解spring cloud中使用Ribbon实现客户端的软负载均衡，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
详解SpringCloud Ribbon 负载均衡通过服务器名无法连接的神坑
08-25
"SpringCloud Ribbon 负载均衡通过服务器名无法连接的神坑" 对 SpringCloud Ribbon 负载均衡通过服务器名无法连接的问题进行了详细的分析和解决。该问题主要是由于 Ribbon 服务器没有注册到 Eureka 服务器中，而...
使用 Spring Cloud Gateway + Ribbon 负载均衡实战
m0_67390379的博客
04-11 2082
前言 通常我们如果有一个服务，会部署到多台服务器上，这些微服务如果都暴露给客户，是非常难以管理的，我们系统需要有一个唯一的出口，Spring Cloud Gateway网关是一个服务，是系统的唯一出口。Spring Cloud Gateway网关封装了系统内部的微服务，为客户端提供一个定制的API。客户端只需要调用网关接口，就可以调用到实际的微服务，实际的服务对客户不可见，并且容易扩展服务。 Spring Cloud Gateway网关可以结合Ribbon完成负载均衡的功能，可以自动检查微服务的状况，及时剔
org.springframewor.cloud.client.loadbalancer.LoadBalancerProperties.isUseRawStatIsCodeInResponseData
最新发布
qq_73296527的博客
06-03 255
查询资料后发现导入的Fegin版本过高，我原来的版本是3.1.5将版本降低为3.1.0该问题即解决。调用Fegin时idea控制台报。
微服务负载均衡器Ribbon实战
qq_36109477的博客
08-06 480
目前主流的负载均衡方式有两种：集中式负载均衡，在客户端和服务端中间建立一个独立的代理来做负载均衡，硬件比如F5;软件比如Nginx。 根据客户自己的情况做负载均衡，Ribbon 就属于这一种。Spring Cloud Ribbon是基于Netflix Ribbon 实现的一套客户端的负载均衡工具，Ribbon客户端组件提供一系列的完善的配置，如超时，重试等。通过Load Balancer获取到服务提供的所有机器实例，Ribbon会自动基于某种规则(轮询，随机)去调用这些服务。Ribbon也可以实现我们自己的
使用ribbon实现负载均衡
qq_52183856的博客
02-20 492
使用ribbon实现负载均衡
使用Ribbon实现负载均衡
weixin_44740328的博客
03-12 292
1.1、什么是Ribbon Ribbon是Netflix发布的负载均衡器，Ribbon是基于某种负载均衡算法，自动地帮助服务消费者去请求，它默认为我们提供了很多地负载均衡算法如：轮询、随机等等。我们也可以为Ribbon实现自定义地负载均衡算法。 当Ribbon和Eureka配合使用时，Ribbon可自动从Eureka Server获取服务提供者地址列表，并基于负载均衡算法，请求其中一个服务者实例。 Ribbon的依赖 <dependency> <groupId>o
Ribbon实现负载均衡
摆渡人一直都在
09-03 3403
Ribbon实现负载均衡 一、项目模块创建 我们首先创建一个order-ribbon的子项目模块，在此项目模块中进行操作，因为我们在导入springcloudAlibaba依赖的时候，已经默认引入了ribbon组件。 二、通过定义配置类实现负载均衡（第一种方式） 1.通过定义配置类RibbonRandomRuleConfig去重写iRule方法，其中使用了随机负载均衡方法。在定义类的时候不能与启动类在同一包下。 2.之后再启动类中，加入@RibbonClients注解，指定需要负载均衡的服务名称 3.
Spring Cloud负载均衡及远程调用实现详解
08-24
当访问`/ribbon/service-user`时，请求会被Ribbon负载均衡到service-user服务的不同实例上，展示不同实例的响应。 远程调用在微服务架构中也是一个关键点。Spring Cloud提供了一种名为Feign的声明式客户端，它使得...
详解Spring Cloud负载均衡重要组件Ribbon中重要类的用法
08-27
Ribbon是Spring Cloud负载均衡重要组件，通过Ribbon，我们能在不涉及到具体实现细节的基础上“透明”地用到负载均衡，而不必在项目里过多地编写实现负载均衡的代码。Ribbon中有三个比较重要的接口：ILoadBalancer、...
Spring Cloud面试题 服务注册、负载均衡等
03-25
- Ribbon是Spring Cloud的一个组件，提供了客户端负载均衡的功能。 - 它可以配合Eureka使用，实现对服务实例的轮询、随机等不同策略的负载均衡。 - Ribbon还可以与Feign结合使用，简化调用逻辑。 #### 五、...
负载均衡Ribbon
m0_69513977的博客
08-15 280
负载均衡就是将负载（工作任务，访问请求）进行分摊到多个操作单元（服务器,组件）上进行执行。
Ribbon~负载均衡
爪哇人的博客
05-02 1341
1 前言 什么是负载均衡 负载均衡就是将负载（工作任务，访问请求）进行分摊到多个操作单元（服务器、组件）上进行执行。根据负载均衡发生的位置，一般分为服务端负载均衡和客户端负载均衡。 服务端负载均衡：发生在服务提供者一方，比如常见的nginx负载均衡。 客户端负载均衡：发生在服务请求一方，就是在发送请求之前选好了由哪个实例处理请求。 一般在微服务调用中都选择客户端负载均衡，也就是在服务调用的一方来决定服务由哪个提供者执行。 2 负载均衡实现 2.1 idea配置 因为本微服务是在订单微服务调用
Ribbon负载均衡实现
weixin_44836655的博客
08-10 1393
ribbon负载均衡简单搭建
Ribbon负载均衡基本概念+实操
bad_boy的博客
10-10 149
概念 主要功能是提供客户端的软件负载均衡算法和服务调用。在配置文件中列出Load Balance 后面所有的机器，Ribbon会自动的帮助你基于某种规则去连接这些机器。 Ribbon其实就是一个软负载均衡的客户端组件，他可以和其他所需请求的客户端结合使用，和Eureka结合是其中的一个实例 Ribbon核心组件IRule 根据特定算法从服务列表中选取一个要访问的服务 RoundRobinRule：轮询 RandomRule：随机 RetryRule：先按照轮询的策略获取服务，如果获取服务器失败则
【SpringCloud总结】6. Ribbon负载均衡
FullStackDeveloper0的博客
05-23 307
一、简介 Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端负载均衡的工具。 简单的说，Ribbon是Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法，将Netflix的中间层服务连接在一起。Ribbon客户端组件提供一系列完善的配置项如连接超时，重试等。简单的说，就是在配置文件中列出Load Balancer（简称LB）后面所有的机...
【Ribbon】负载均衡学习记录
m0_46628950的博客
10-26 190
Ribbon是Netflix发布的云中间层服务开源项目，其主要功能是提供客户端实现负载均衡算法。Ribbon客户端组件提供一系列完善的配置项如连接超时，重试等。简单的说，，我们可以在配置文件中Load Balancer后面的所有机器，Ribbon会自动的帮助你基于某种规则（如简单轮询，随机连接等）去连接这些机器，我们也很容易使用Ribbon实现自定义的负载均衡算法。
如何修改Jupyter Notebook的工作空间的默认路径？
qq_30935743的博客
10-18 184
查看Jupyter使用的配置文件在哪个目录： cmd： jupyter --config-dir 切换到当面的目录下，查看否存在配置文件：jupyter_notebook_config.py。如果不存在使用以下命令创建： jupyter notebook --generate-config 在配置文件jupyter_notebook_config.py中，添加配置内容： c.NotebookApp.notebook_dir = ‘工作空间地址’ 最后一步，点击Jupyter No.
Ribbon的介绍和使用（一）
吉京伟
05-19 614
1.关于Ribbon Netflix开源的客户端侧负载均衡器，也可以理解成是一个用于选择微服务的小组件。 2.架构的演进 3.三板斧整合Ribbon实现负载均衡 3.1加依赖 不需要加，nacos-discover包含了netflix-ribbon,如图： 3.2写注解 为restTemplate整合Ribbon package com.ding.contentcenter; import org.mybatis.spring.annotation.MapperScan; import org.s
Spring Cloud Ribbon：详解负载均衡与RestTemplate调用
"Spring Cloud Ribbon是Spring Cloud Netflix项目中的关键组件，主要用于在微服务架构中实现服务间的负载均衡。Ribbon的主要功能是为API网关和服务之间的调用提供均衡策略，确保高可用性和可扩展性。本文将详细介绍...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值