客户端负载均衡(Ribbon)

最新推荐文章于 2024-10-08 11:15:00 发布
最新推荐文章于 2024-10-08 11:15:00 发布
阅读量4.2w 收藏 82
点赞数 14
分类专栏： SpringCloud微服务实战 文章标签： Ribbon
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pengjunlee/article/details/86594934
版权

目录

服务器端负载均衡

客户端负载均衡

Ribbon负载均衡示例搭建

创建服务提供者

引入依赖

添加配置

服务提供者

创建启动类

启动服务

服务消费者

引入Ribbon依赖

添加配置

使用Ribbon客户端

切换Ribbon负载均衡策略

自定义Ribbon客户端

自定义Ribbon客户端的默认配置

通过配置属性自定义Ribbon客户端

脱离Eureka使用Ribbon

在Ribbon中禁用Eureka

Ribbon缓存配置

参考文章

服务器端负载均衡

负载均衡是我们处理高并发、缓解网络压力和进行服务器扩容的重要手段之一，但是一般情况下我们所说的负载均衡通常都是指服务器端负载均衡，服务器端负载均衡又分为两种，一种是硬件负载均衡，还有一种是软件负载均衡。

硬件负载均衡主要通过在服务器节点之前安装专门用于负载均衡的设备，常见的如：F5。

软件负载均衡则主要是在服务器上安装一些具有负载均衡功能的软件来完成请求分发进而实现负载均衡，常见的如：LVS 、 Nginx 、Haproxy。

无论是硬件负载均衡还是软件负载均衡，它的工作原理都不外乎下面这张图：

客户端负载均衡

而微服务的出现，则为负载均衡的实现提供了另外一种思路：把负载均衡的功能以库的方式集成到服务的消费方，而不再是由一台指定的负载均衡设备集中提供。这种方案称为软负载均衡（Soft Load Balancing）或者客户端负载均衡。常见的如：Spring Cloud中的 Ribbon。

Ribbon是一个基于HTTP和TCP的客户端负载均衡器，当我们将Ribbon和Eureka一起使用时，Ribbon会到Eureka注册中心去获取服务端列表，然后进行轮询访问以到达负载均衡的作用，客户端负载均衡也需要心跳机制去维护服务端清单的有效性，当然这个过程需要配合服务注册中心一起完成。

服务器端负载均衡 VS 客户端负载均衡的特点如下：

服务器端负载均衡 客户端先发送请求到负载均衡服务器，然后由负载均衡服务器通过负载均衡算法，在众多可用的服务器之中选择一个来处理请求。

客户端负载均衡 客户端自己维护一个可用服务器地址列表，在发送请求前先通过负载均衡算法选择一个将用来处理本次请求的服务器，然后再直接将请求发送至该服务器。

接下来我们将延续上一章的Eureka注册中心，继续搭建一个基于Ribbon的客户端负载均衡示例。

Ribbon负载均衡示例搭建

创建服务提供者

引入依赖

新建一个 Maven 工程，取名 message-service 用来提供消息服务，在其 pom.xml 文件中引入依赖，内容如下：

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

	<properties>
		<spring-cloud.version>Finchley.SR2</spring-cloud.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<!-- Eureka-Client 依赖 -->
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
		</dependency>
	</dependencies>

	<dependencyManagement>
		<dependencies>
			<!-- SpringCloud 版本控制依赖 -->
			<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>

添加配置

application.yml 添加配置如下： 

spring:
  application:
    name: message-service
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

服务提供者

创建一个 MessageController 控制器对外提供一个http接口服务。

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/v1/msg")
public class MessageController {

	@Value("${server.port}")
	private String port;

	/**
	 * 返回一条消息
	 */
	@GetMapping("/get")
	public String getMsg() {
		return "This message is sent from port: " + port;
	}
}

创建启动类

import org.springframework.boot.WebApplicationType;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
public class MessageApplication {

	public static void main(String[] args) {
		new SpringApplicationBuilder(MessageApplication.class).web(WebApplicationType.SERVLET).run(args);
	}

}

启动服务

右键-->Run As --> Run Configurations...，分别使用 8771、8772、8773 三个端口各启动一个MessageApplication应用。

-Dserver.port=8771
-Dserver.port=8772
-Dserver.port=8773

 启动完成后，浏览器输入：http://localhost:8761/ 效果图如下：

服务消费者

引入Ribbon依赖

新建一个 Maven 工程，取名 message-center 用来调用消息服务，在其 pom.xml 文件中引入依赖，内容如下：

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

	<properties>
		<spring-cloud.version>Finchley.SR2</spring-cloud.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<!-- Eureka-Client 依赖 -->
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
		</dependency>

		<!-- Ribbon 依赖 -->
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
		</dependency>
	</dependencies>

	<dependencyManagement>
		<dependencies>
			<!-- SpringCloud 版本控制依赖 -->
			<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>

添加配置

application.yml 添加配置如下： 

server:
  port: 8781
spring:
  application:
    name: message-center
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

使用Ribbon客户端

方式一：

在启动类中向Spring容器中注入一个带有@LoadBalanced注解的RestTemplate Bean。

import org.springframework.boot.WebApplicationType;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
@EnableEurekaClient
public class MessageCenterApplication {

	@Bean

	@LoadBalanced

	public RestTemplate restTemplate() {

		return new RestTemplate();

	}

	public static void main(String[] args) {

		new SpringApplicationBuilder(MessageCenterApplication.class).web(WebApplicationType.SERVLET).run(args);

	}

}

在调用那些需要做负载均衡的服务时，使用上面注入的RestTemplate Bean进行调用即可。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
@RequestMapping("/api/v1/center")
public class MessageCenterController {

	@Autowired
	private RestTemplate restTemplate;

	@GetMapping("/msg/get")
	public Object getMsg() {

		String msg = restTemplate.getForObject("http://message-service/api/v1/msg/get", String.class);
		return msg;

	}

}

方式二：

直接使用 LoadBalancerClient 中的负载均衡策略获取一个可用的服务地址，然后再进行请求。

import java.net.URI;

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.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
@RequestMapping("/api/v1/center")
public class MessageCenterController {

	@Autowired
	private LoadBalancerClient loadBalancer;

	@GetMapping("/msg/get")
	public Object getMsg() {

		ServiceInstance instance = loadBalancer.choose("message-service");
		URI url = URI.create(String.format("http://%s:%s/api/v1/msg/get", instance.getHost(), instance.getPort()));
		RestTemplate restTemplate = new RestTemplate();
		String msg = restTemplate.getForObject(url, String.class);
		return msg;

	}

}

待应用启动之后，连续三次请求地址 http://localhost:8781/api/v1/center/msg/get ，返回的结果如图所示：

 

 

切换Ribbon负载均衡策略

Ribbon本身提供了下面几种负载均衡策略：

RoundRobinRule: 轮询策略，Ribbon以轮询的方式选择服务器，这个是默认值。所以示例中所启动的两个服务会被循环访问;

RandomRule: 随机策略，也就是说Ribbon会随机从服务器列表中选择一个进行访问;

BestAvailableRule: 最大可用策略，即先过滤出故障服务器后，选择一个当前并发请求数最小的;

WeightedResponseTimeRule: 带有加权的轮询策略，对各个服务器响应时间进行加权处理，然后在采用轮询的方式来获取相应的服务器;

AvailabilityFilteringRule: 可用过滤策略，先过滤出故障的或并发请求大于阈值的一部分服务实例，然后再以线性轮询的方式从过滤后的实例清单中选出一个;

ZoneAvoidanceRule: 区域感知策略，先使用主过滤条件（区域负载器，选择最优区域）对所有实例过滤并返回过滤后的实例清单，依次使用次过滤条件列表中的过滤条件对主过滤条件的结果进行过滤，判断最小过滤数（默认1）和最小过滤百分比（默认0），最后对满足条件的服务器则使用RoundRobinRule(轮询方式)选择一个服务器实例。

我们可以将上例中的message-service的负载均衡策略设置为随机访问RandomRule，application.yml配置如下：

message-service:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

当然，我们也可以通过继承ClientConfigEnabledRoundRobinRule，来实现自己的负载均衡策略。

自定义Ribbon客户端

您可以使用外部属性按照 <clientName>.<nameSpace>.<propertyName>=<value> 的格式对Ribbon客户端的某些特性进行配置，这与使用Netflix API类似。当然，你也可以在Springboot配置文件中进行配置。所有的配置项均以静态字段的形式定义在 CommonClientConfigKey 类（Ribbon核心的一部分）中。

SpringCloud还允许你在RibbonClientConfiguration的基础之上使用@RibbonClient声明一些额外配置，从而实现对Ribbon客户端的完全控制，如下例所示：

import org.springframework.cloud.netflix.ribbon.RibbonClient;
import org.springframework.cloud.netflix.ribbon.ZonePreferenceServerListFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.netflix.loadbalancer.IPing;
import com.netflix.loadbalancer.PingUrl;
import com.pengjunlee.TestConfiguration.MessageConfiguration;

@Configuration
@RibbonClient(name = "message-service", configuration = MessageConfiguration.class)
public class TestConfiguration {

	@Configuration
	protected static class MessageConfiguration {
		@Bean
		public ZonePreferenceServerListFilter serverListFilter() {
			ZonePreferenceServerListFilter filter = new ZonePreferenceServerListFilter();
			filter.setZone("myTestZone");
			return filter;
		}

		@Bean
		public IPing ribbonPing() {
			return new PingUrl();
		}
	}
}

在这个例子中，这个Ribbon客户端将由RibbonClientConfiguration和MessageConfiguration中的组件一起组成（后者会覆盖前者的配置）。

注意：本例中，MessageConfiguration必须用@Configuration注解标注，但是它不应该被包含在Spring的组件扫描路径之中，否则它将被所有的Ribbon客户端共享。如果你使用@ComponentScan（或者@SpringBootApplication），那么你应该采取措施来避免它被包含到扫描范围之中。

下表列出了 Spring Cloud Netflix 缺省为Ribbon提供的所有 Bean：

Bean Type

Bean Name

Class Name

IClientConfig

ribbonClientConfig

DefaultClientConfigImpl

IRule

ribbonRule

ZoneAvoidanceRule

IPing

ribbonPing

DummyPing

ServerList<Server>

ribbonServerList

ConfigurationBasedServerList

ServerListFilter<Server>

ribbonServerListFilter

ZonePreferenceServerListFilter

ILoadBalancer

ribbonLoadBalancer

ZoneAwareLoadBalancer

ServerListUpdater

ribbonServerListUpdater

PollingServerListUpdater

创建这些类型的一个Bean 并将它写到 @RibbonClient 声明的配置中，这样你就能够对这些Bean中的每一个进行重写。例如上面的 MessageConfiguration 中利用PingUrl替代了NoOpPing并提供了一个自定义的serverListFilter。

自定义Ribbon客户端的默认配置

通过@RibbonClients注解可以为所有的Ribbon客户端提供一个默认的配置。例如

import org.springframework.cloud.netflix.ribbon.RibbonClients;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.BestAvailableRule;
import com.netflix.loadbalancer.ConfigurationBasedServerList;
import com.netflix.loadbalancer.IPing;
import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.PingUrl;
import com.netflix.loadbalancer.Server;
import com.netflix.loadbalancer.ServerList;
import com.netflix.loadbalancer.ServerListSubsetFilter;

@RibbonClients(defaultConfiguration = DefaultRibbonConfig.class)
public class RibbonClientDefaultConfigurationTestsConfig {

	public static class BazServiceList extends ConfigurationBasedServerList {
		public BazServiceList(IClientConfig config) {
			super.initWithNiwsConfig(config);
		}
	}
}

@Configuration
class DefaultRibbonConfig {

	@Bean
	public IRule ribbonRule() {
		return new BestAvailableRule();
	}

	@Bean
	public IPing ribbonPing() {
		return new PingUrl();
	}

	@Bean
	public ServerList<Server> ribbonServerList(IClientConfig config) {
		return new RibbonClientDefaultConfigurationTestsConfig.BazServiceList(config);
	}

	@Bean
	public ServerListSubsetFilter serverListFilter() {
		ServerListSubsetFilter filter = new ServerListSubsetFilter();
		return filter;
	}

}

通过配置属性自定义Ribbon客户端

Spring Cloud Netflix 从1.2.0版本开始支持通过配置属性自定义Ribbon客户端，这可以让你在应用启动时根据不同的环境来改变Ribbon的行为。

支持配置的属性列表如下：

<clientName>.ribbon.NFLoadBalancerClassName: 需实现 ILoadBalancer
<clientName>.ribbon.NFLoadBalancerRuleClassName: 需实现 IRule
<clientName>.ribbon.NFLoadBalancerPingClassName: 需实现 IPing
<clientName>.ribbon.NIWSServerListClassName: 需实现 ServerList
<clientName>.ribbon.NIWSServerListFilterClassName: 需实现 ServerListFilter

 注意：通过配置属性定义的类与上述@RibbonClient配置类中定义的Bean以及Spring Cloud Netflix

提供的缺省配置相比具有更高的优先级。

例如对 message-service 服务的 IRule 属性进行修改，可以在application.yml中进行如下配置：

message-service:
  ribbon:
    NIWSServerListClassName: com.netflix.loadbalancer.ConfigurationBasedServerList
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.WeightedResponseTimeRule

脱离Eureka使用Ribbon

Eureka提供了一种抽象的发现远程服务的便捷的方式，这样你就不必在客户端中硬编码服务地址列表，但是如果你不用Eureka，也可以继续使用Ribbon和Feign。假设在不使用Eureka，你用@RibbonClient声明了一个"stores"服务，这个时候Ribbon Client 默认会引用一个配置好的服务列表，你可以在application.yml中对它进行配置：

stores:
  ribbon:
    listOfServers: example.com,google.com

在Ribbon中禁用Eureka

通过将 ribbon.eureka.enabled 属性设置为 false 可以在Ribbon中禁用Eureka。

ribbon:
  eureka:
   enabled: false

Ribbon缓存配置

对于每一个Ribbon客户端，Spring Cloud都会维护一个与其相应的应用上下文，这个应用上下文会在相应服务第一次被请求时进行懒加载。你可以使用饥饿加载来取代懒加载，通过指定那些需要饥饿加载Ribbon客户端名称，在应用启动时就对其应用上下文进行加载。

ribbon:
  eager-load:
    enabled: true
    clients: client1, client2, client3

参考文章

https://www.jianshu.com/p/d32ae141f680

https://blog.csdn.net/u014401141/article/details/78676296

https://cloud.spring.io/spring-cloud-static/spring-cloud-netflix/2.0.2.RELEASE/single/spring-cloud-netflix.html#spring-cloud-ribbon 

pengjunlee
关注
专栏目录
SpringClould之客户端负载均衡(Ribbon)
白大锅的博客，毕设WangLoveBai_999
10-22 3万+
一、Ribbon架构图 二、什么是负载均衡? LB（Load Balance，负载均衡）是一种集群技术，它将特定的业务（网络服务、网络流量等）分担给多台网络设备（包括服务器、防火墙等）或多条链路，从而提高了业务处理能力，保证了业务的高可靠性。 负载均衡技术具有一下优势： 1.高性能：负载均衡技术将业务较均衡的分担到多台设备或链路上，从而提高了整个系统的性能； 2.可扩展性：负载均衡技术可以方便的增加集群中设备或链路的数量，在不降低业务质量的前提下满足不断增长的业务需求； 3.高可靠性：单个甚至多个设备或
客户端负载均衡Ribbon
Lavender-csdn的博客
10-05 678
Spring Cloud中的Ribbon是什么？ 我们通常说的负载均衡是指将一个请求均匀地分摊到不同的节点单元上执行，负载均衡分为硬件负载均衡和软件负载均衡； 硬件负载均衡：比如F5、深信服、Array等； 软件负载均衡：比如Nginx、LVS、HAProxy等； 硬件负载均衡或者软件负载均衡，他们都会维护一个可用的服务端清单，通过心跳检测来剔除故障的服务端节点以保证清单中都是可以正常访问的服务端节点。当客户端发送请求到负载均衡设备的时候，该设备按照某种算法（比如轮询、权重、最小连接数等）从维护的可
Ribbon 客户端负载均衡
java后端攻城狮
08-07 727
将provider服务开启两次，第二次开始时修改端口，再此打开即可有两个程序运行（模拟两个服务）这个端口随机显示意思就是消费者随机使用eureka里的服务。Ribbon是Neflix提供的一个基于HTTP和TCP的。eureka向每个服务发一个数据包，哪个服务先响应 选哪个。2.host:port可以替换为 服务提供方的应用名。为了方便监控消费者调用了哪个服务，注入port监控。哪个访问的少选哪个（eureka内有记录）在consumer的启动类添加注解。Ribbon负载均衡策略。过滤掉坏的和并发高的。..
Ribbon负载均衡原理、负载均衡策略以及懒加载
最新发布
Xinnnnn的博客
10-08 1646
Ribbon负载均衡原理、负载均衡策略以及懒加载
客户端负载均衡 Ribbon
weixin_59248828的博客
08-01 1053
RibbonLoadBalanceClient是的实现类，它用来执行最终的负载均衡请求。其中，的一个choose()方法用于选择具体的服务实例，其内部是通过方法交给完成的。是一个接口，该接口定义了一系列实现负载均衡的方法。接口的实现类结果如下图所示。
Web负载均衡的几种实现方式
热门推荐
Jack Zhou的专栏
04-23 5万+
摘要： 　　负载均衡(Load Balance)是集群技术（Cluster）的一种应用。负载均衡可以将工作任务分摊到多个处理单元，从而提高并发处理能力。目前最常见的负载均衡应用是Web负载均衡。根据实现的原理不同，常见的web负载均衡技术包括：DNS轮询、IP负载均衡和CDN。其中IP负载均衡可以使用硬件设备或软件方式来实现。
ribbon客户端负载均衡
m0_68064743的博客
04-23 712
Ribbon简介 Ribbon是Netflix发布的负载均衡器，它有助于控制HTTP和TCP的客户端的行为。为Ribbon配置服务提供者地址后，Ribbon就可基于某种负载均衡算法，自动地帮助服务消费者去请求。Ribbon默认为我们提供了很多负载均衡算法，例如轮询、随机等。当然，我们也可为Ribbon实现自定义的负载均衡算法。 在Spring Cloud中，当Ribbon与Eureka配合使用时，Ribbon可自动从Eureka Server获取服务提供者地址列表，并基于负载均衡算法，请
73-Spring Cloud客户端负载均衡Ribbon笔记1
08-08
Spring Cloud中的Ribbon是实现客户端负载均衡的关键组件。在传统的服务端负载均衡中，像Nginx这样的代理服务器会接收请求并根据预设的算法（如轮询、权重轮询、随机等）转发到后端服务。而在客户端负载均衡模式下，...
02_SpringCloud客户端负载均衡Ribbon.md
01-03
DiscoveryClient 可以自己实现一个负载均衡的算法(使用请求总数 % 服务列表个数).算法文件跟新一下 @SpringBootApplication @EnableDiscoveryClient @RestController public class AppConsulClient { @...
spring cloud 之 客户端负载均衡Ribbon深入理解
08-30
【Spring Cloud Ribbon 深入理解：客户端负载均衡】 负载均衡是现代分布式系统中的关键组件，用于提升系统可用性和性能。在Spring Cloud框架中，Ribbon是一个轻量级的客户端负载均衡器，它实现了客户端的负载均衡...
SpringCloud微服务：深入理解客户端负载均衡Ribbon
SpringCloud中的Ribbon为微服务架构提供了强大的客户端负载均衡能力，它简化了服务间的调用逻辑，使得客户端无需关注具体的服务实例，只需关注服务接口，而负载均衡的工作则交由Ribbon来处理。这种设计提高了系统的...
【第三章】Ribbon客户端负载均衡
sunnyday0426的博客
03-24 1121
1.1 Ribbon概述 在微服务架构中，业务都会被拆分成一个独立的服务，服务与服务的通讯是基于http restful的。Spring Cloud有两种服务调用方式，一种是Ribbon+restTemplate，另一种是Feign，本文介绍使用Spring Cloud Ribbon在客户端负载均衡的调用服务。 Ribbon 是一个客户端负载均衡器，可以简单的理解成类似于 nginx的负载均衡模块的功能，Feign默认集成了Ribbon。 主流的LB方案可分成两类： 一种是集中式LB，即在服务的消费方和提
客户端负载均衡-Ribbon
我乐了的博客
01-17 938
众所周知，随着用户量的增加，应用的访问量也会随之增加，单台服务器已经远不能满足高并发的业务需求，这时就需要多台服务器组成集群来应对高并发带来的业务压力，同时也需要负均衡器来对流量进行合理分配。负载均衡是一种基础的网络服务，它的核心原理是按照指定的负载均衡算法，将请求分配到后端服务集群上，从而为系统提供并行处理和高可用的能力。负载均衡的方式有很多种，在 Spring Cloud 体系中，Ribbon就是负载均衡的组件，所有的请求都是通过 Ribbon 来选取对应的服务信息的。
客户端负载均衡
xiaokanfuchen86的博客
08-02 290
客户端负载均衡是相对于服务端负载均衡而言的。 服务端的负载均衡就是传统的Nginx方式，它的一个特点是调用的客户端不知道具体是哪一个Server提供的服务，只需要将请求发送给Nginx，再由Nginx转发给 Tomcat，客户端只需要记住Nginx的地址即可。 而在客户端负载均衡中，客户端可以知道所有服务端的详细信息，当需要调用 Server上的接口时，客户端从自身已知的Server列表中，根据提前配置的负载均衡策略，自己挑选一个服务端来调用，此时客户端知道自己调用的是哪一个 Server 在
Ribbon客户端负载均衡
qq_41300350的博客
04-27 528
前面我们了解了服务调用Rest和服务注册中心Eureka。现在我们来了解微服务架构springcloud技术栈之Ribbon负载均衡器。 什么是负载均衡？ LB，即负载均衡(Load Balance)，负载均衡是微服务架构中经常使用的一种技术。 负载均衡是我们处理高并发、缓解网络压力和进行服务端扩容的重要手段之一，简单的说就是将用户的请求平摊的分配到多个服务上，从而实现系统的高可用性集群。 负载...
Spring Cloud Ribbon实现客户端负载均衡
weixin_43442246的博客
05-17 1514
Ribbon是一个客户端负载插件，基于Netflix Ribbon，它本身做为一个客户端注册到Eureka Server，当有请求到ribbon，Eureka Server筛选符合条件的client进行消费；它是指定到符合条件的client具体接口的一种插件，用起来比较灵活。 使用ribbon需要有服务提供者（client），消费者ribbon，以及把它们注册到一个Eureka Server中。 ...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值