SpringCloudAlibaba- Ribbon (Best Practices for Production Environments)

Ribbon

The Ribbon is a client-side IPC library and Netflix’s open source client-side load balancer. It provides the following capabilities:

Load balancing

Fault tolerance

Support for asynchrony and multiple protocols (HTTP, TCP, UDP) in the corresponding model

Caching and batching

Why use the Ribbon

In our system (distributed system), there is process communication between services; Before using the Ribbon, you need to manually implement the load balancer. With the Ribbon, we can automatically get service lists from nacOS services and use user-specified load balancing algorithms to calculate the instances that need to be invoked. This enables us to achieve load balancing easily and efficiently. The Ribbon is scalable enough to meet 99.9999% of production scenarios.

There are two load balancing modes

Server-side load balancing

Load balancing on the client

Manually implement the load balancer on the client side

No load balancer is used

@Override
    public ShareDTO findById(Integer id) {
        // Get share details
        Share share = baseMapper.selectById(id);
        // Get the publisher ID
        Integer userId = share.getUserId();

        List<ServiceInstance> instances = discoveryClient.getInstances("user-center");
        String url = instances.stream().map(instance -> instance.getUri().toString() + "/users/{id}").findFirst().orElse("");
        // Remotely invoke the user center service interface
        UserDTO userDTO = restTemplate.getForObject(url, UserDTO.class, userId);

        // Message assembly
        ShareDTO shareDTO = ShareDTO.builder()
                .wxNickname(userDTO.getWxNickname())
                .build();
        BeanUtils.copyProperties(share, shareDTO);
        return shareDTO;
    }
Copy the code

Manual Load balancer implementation (random)

@Override
    public ShareDTO findById(Integer id) {
        // Get share details
        Share share = baseMapper.selectById(id);
        // Get the publisher ID
        Integer userId = share.getUserId();

        List<ServiceInstance> instances = discoveryClient.getInstances("user-center");
        List<String> urls = instances.stream().map(instance -> instance.getUri().toString() + "/users/{id}").collect(Collectors.toList());

        // Random algorithm
        int i = ThreadLocalRandom.current().nextInt(urls.size());
        // Remotely invoke the user center service interface
        UserDTO userDTO = restTemplate.getForObject(urls.get(i), UserDTO.class, userId);

        // Message assembly
        ShareDTO shareDTO = ShareDTO.builder()
                .wxNickname(userDTO.getWxNickname())
                .build();
        BeanUtils.copyProperties(share, shareDTO);
        return shareDTO;
    }
Copy the code

The Ribbon implements load balancing

1. Add dependencies (if you are using NacOS Discovery, you do not need to introduce ribbon dependencies separately)

2. Write notes

   // If you use RestTemplate to integrate the Ribbon, annotate the RestTemplate
   @Bean
   @LoadBalanced
   RestTemplate restTemplate(a) {
     return new RestTemplate();
   }
   Copy the code

3. Write configuration (not configured)

Of Ribbon

We can implement these interfaces and customize our requirements.

Load balancing rules built into the Ribbon

Fine-grained configuration

Java code approach

Note: RibbonConfiguration must be outside the Springboot package scan. (Parent-child context explanation)

1. Create the Ribbon configuration class for a service

   package com.samir.contentcenter.configuration;
   
   import org.springframework.cloud.netflix.ribbon.RibbonClient;
   import org.springframework.context.annotation.Configuration;
   import ribbonconfiguration.RibbonConfiguration;
   
   @Configuration
   @RibbonClient(name = "user-center", configuration = RibbonConfiguration.class)
   public class UserCenterRibbonConfiguration {}Copy the code

2. Create a load balancing rule for the current service

   package ribbonconfiguration;
   
   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 ribbonRule(a) {
           return newRandomRule(); }}Copy the code

Parent and child context

1. The @Configuration annotation is also a special Component annotation, and the @SpringBootApplication on top of the bootstrap class is an aggregate annotation that contains the @ComponentScan annotation.

2. All Component annotations will be scanned (the package and subpackages of the currently launched class).

3. The Component annotation scanned by @SpringBootApplication is the parent context.

4. The Ribbon also scans the Component annotation as a subcontext.

5. Packages of load balancing rules can only be placed outside. Overlapping parent and child contexts can lead to a series of strange problems such as transaction invalidity.

   The Ribbon explains that the @Configuration annotation must be used to configure load balancing rules for clients. Note that this annotation cannot be scanned by @ComponentScan. Otherwise, it will be shared by all @RibbonClients. It becomes a global configuration.

Configuring Attribute Mode

The full path. Ribbon. NFLoadBalancerRuleClassName = rules

The name of the service in the registry
user-center:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule Rule full path
Copy the code

Two ways to compare

The best implementation

• Use attribute configuration as much as possible, and consider code configuration when attribute mode is not possible.
• Try to keep the same microservice simple, do not mix the two ways, increase the complexity of the location code. Simple is beautiful.

Global configuration

• Method 1: Make ComponentSacn parent-child context overlap (strongly not recommended). (See parent context or official documentation)

• Mode 2: @RibbonClients(defaultConfiguration= XXX.class)

  package com.samir.contentcenter.configuration;
  
  import org.springframework.cloud.netflix.ribbon.RibbonClients;
  import org.springframework.context.annotation.Configuration;
  import ribbonconfiguration.RibbonConfiguration;
  
  @Configuration
  @RibbonClients(defaultConfiguration = RibbonConfiguration.class) // Notice here
  public class UserCenterRibbonConfiguration {}Copy the code

Supported configuration items

Code way

1. Create the Ribbon configuration class for a service

   package com.samir.contentcenter.configuration;
   
   import org.springframework.cloud.netflix.ribbon.RibbonClient;
   import org.springframework.context.annotation.Configuration;
   import ribbonconfiguration.RibbonConfiguration;
   
   @Configuration
   @RibbonClient(name = "user-center", configuration = RibbonConfiguration.class)
   public class UserCenterRibbonConfiguration {}Copy the code

2. Create a load balancing rule for the current service

   package ribbonconfiguration;
   
   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 ribbonRule(a) {
           return new RandomRule();
       }
     
     	@Bean
       public IPing ping(a) {
           return new PingUrl();
       }
     
     	// The Ribbon provides the corresponding interface
   }
   Copy the code

Configuring Attribute Mode

Use the **.ribbon. Property **. The following attributes:

• NFLoadBalancerRuleClassName: ILoadBalancer implementation class
• NFLoadBalancerRuleClassClassName: IRule implementation class
• NFLoadBalancerPingClassClassName: IPing implementation class
• NIWSServerListClassName: Implementation class of ServerList
• NIWSServerListFilterClassName: ServerListFilter implementation class

Hunger is loaded

The following solutions can solve the problem that causes the first request to be slow

# ribbon enables hungry loading (default is off)
ribbon:
  eager-load:
    enabled: true
    clients: user-center Configure which services to enable hungry loading (multiple, split)
Copy the code

Extend the Ribbon

Nacos weights are supported

1. Weight information can be configured for each instance on the NACOS console. The diagram below:

The larger the threshold value is, the greater the probability of being requested is. The use of thresholds is useful in distributed scenarios, where the performance of our servers is inconsistent, and we can use thresholds to get more requests from good servers.

2. The Ribbon’s built-in load balancing rules do not support thresholds, so we need to extend the Ribbon with nacOS (implement the IRule interface and inherit AbstractLoadBalancerRule). The following is a partial configuration as a configuration property.

   1. Edit custom load balancing rules

      package com.samir.contentcenter.configuration;
      
      import com.alibaba.cloud.nacos.NacosDiscoveryProperties;
      import com.alibaba.cloud.nacos.ribbon.NacosServer;
      import com.alibaba.nacos.api.exception.NacosException;
      import com.alibaba.nacos.api.naming.NamingService;
      import com.alibaba.nacos.api.naming.pojo.Instance;
      import com.netflix.client.config.IClientConfig;
      import com.netflix.loadbalancer.AbstractLoadBalancerRule;
      import com.netflix.loadbalancer.BaseLoadBalancer;
      import com.netflix.loadbalancer.Server;
      import lombok.extern.slf4j.Slf4j;
      import org.springframework.beans.factory.annotation.Autowired;
      
      @Slf4j
      public class NacosWeightedRule  extends AbstractLoadBalancerRule {
          @Autowired
          private NacosDiscoveryProperties nacosDiscoveryProperties;
      
          @Override
          public void initWithNiwsConfig(IClientConfig iClientConfig) {
              // Read the configuration file and initialize it
          }
      
          @Override
          public Server choose(Object o) {
              try {
                  // The ribbon entry
                  BaseLoadBalancer loadBalancer = (BaseLoadBalancer) this.getLoadBalancer();
                  // Get the name of the microservice you want to request
                  String name = loadBalancer.getName();
                  // Get the API for service discovery
                  NamingService namingService = nacosDiscoveryProperties.namingServiceInstance();
                  // The Nacos client automatically selects an instance for me through a weight-based load balancing algorithm
                  Instance instance = namingService.selectOneHealthyInstance(name);
      
                  log.info("The selected instance is: port = {}, instance = {}", instance.getPort(), instance);
                  return new NacosServer(instance);
              } catch (NacosException e) {
                  e.printStackTrace();
                  return null; }}}Copy the code

   2. Editing a Configuration File

      The name of the service in the registry
      user-center:
        ribbon:
          NFLoadBalancerRuleClassName: com.samir.contentcenter.configuration.NacosWeightedRule Rule full path
      Copy the code

The same cluster is preferentially loaded

1. Edit custom load balancing rules

   package com.samir.contentcenter.configuration;
   
   import com.alibaba.cloud.nacos.NacosDiscoveryProperties;
   import com.alibaba.cloud.nacos.ribbon.NacosServer;
   import com.alibaba.nacos.api.exception.NacosException;
   import com.alibaba.nacos.api.naming.NamingService;
   import com.alibaba.nacos.api.naming.pojo.Instance;
   import com.alibaba.nacos.client.naming.core.Balancer;
   import com.netflix.client.config.IClientConfig;
   import com.netflix.loadbalancer.AbstractLoadBalancerRule;
   import com.netflix.loadbalancer.BaseLoadBalancer;
   import com.netflix.loadbalancer.Server;
   import lombok.extern.slf4j.Slf4j;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.util.CollectionUtils;
   
   import java.util.ArrayList;
   import java.util.List;
   import java.util.Objects;
   import java.util.stream.Collectors;
   
   @Slf4j
   public class NacosSameClusterWeigthedRule extends AbstractLoadBalancerRule {
   
       @Autowired
       private NacosDiscoveryProperties nacosDiscoveryProperties;
   
       @Override
       public void initWithNiwsConfig(IClientConfig iClientConfig) {}@Override
       public Server choose(Object o) {
           try {
               / / get the current application (spring configuration file. Cloud. Nacos. Discovery. The cluster - name: BJ) the name of the cluster
               String clusterName = nacosDiscoveryProperties.getClusterName();
               BaseLoadBalancer loadBalancer = (BaseLoadBalancer) this.getLoadBalancer();
               // Get the name of the microservice you want to request
               String name = loadBalancer.getName();
               // Get the API for service discovery
               NamingService namingService = nacosDiscoveryProperties.namingServiceInstance();
   
               // 1. Find all instances A of the specified service
               List<Instance> instances = namingService.selectInstances(name, true);// true gets only healthy instances
               // 2. Filter out all instance B in the same cluster
               List<Instance> instanceList = instances.stream().filter(instance -> Objects.equals(instance.getClusterName(), clusterName)).collect(Collectors.toList());
               // 3. If B is empty, use A
               List<Instance> instancesToBeChosen = new ArrayList<>();
               if (CollectionUtils.isEmpty(instanceList)) {
                   instancesToBeChosen = instances;
                   log.warn(Name = {}, clusterName = {}, instances = {}", name, clusterName, instancesToBeChosen);
               } else {
                   instancesToBeChosen = instanceList;
               }
               // 4. Return an instance based on the weighted non-load balancing algorithm
               Instance instance = MyBalancer.myGetHostByRandomWeight(instancesToBeChosen);
               return new NacosServer(instance);
           } catch (NacosException e) {
               log.error("Something abnormal has happened.", e);
               return null; }}}/ * * * this method is to inherit the Balancer class to use his protected type of method by namingService. * * selectOneHealthyInstance method of tracking, Public Instance selectOneHealthyInstance(String serviceName, String groupName, List
           
             Clusters, boolean subscribe) throws NacosException { * return subscribe ? RandomByWeight.selectHost(this.hostReactor.getServiceInfo(NamingUtils.getGroupedName(serviceName, groupName), StringUtils.join(clusters, ","))) : RandomByWeight.selectHost(this.hostReactor.getServiceInfoDirectlyFromServer(NamingUtils.getGroupedName(serviceName, groupName), StringUtils.join(clusters, ","))); Public static Instance selectHost(ServiceInfo dom) {* List
            
              hosts = selectAll(dom); * if (CollectionUtils.isEmpty(hosts)) { * throw new IllegalStateException("no host to srv for service: " + dom.getName()); * } else { * return Balancer.getHostByRandomWeight(hosts); // This static method is the key to implementation *} *} */
            
           
   class MyBalancer extends Balancer {
       public static Instance myGetHostByRandomWeight(List<Instance> hosts) {
           returngetHostByRandomWeight(hosts); }}Copy the code

2. Editing a Configuration File

   The name of the service in the registry
   user-center:
     ribbon:
       NFLoadBalancerRuleClassName: com.samir.contentcenter.configuration.NacosSameClusterWeigthedRule Rule full path
   Copy the code

Versioning based on metadata

1. Edit custom load balancing rules

   @Slf4j
   public class NacosFinalRule extends AbstractLoadBalancerRule {
       @Autowired
       private NacosDiscoveryProperties nacosDiscoveryProperties;
   
       @Override
       public Server choose(Object key) {
           // Load balancing rule: Select instances that meet metadata requirements in the same cluster
           // If not, select all instances that match metadata in the cluster
   
           // 1. Query all instance A
           // 2. Filter instance B that matches metadata
           // 3. Select instance C that matches the metadata in cluster
           // 4. If C is empty, use B
           // 5. Randomly select instances
         
         	/ / the metadata information (spring configuration file. Cloud. Nacos. Metadata. Version: v1) your application version here
         	/ / the metadata information (spring configuration file. Cloud. Nacos. Metadata. The target - version: v1) allows the provider's version of the call
           try {
               String clusterName = this.nacosDiscoveryProperties.getClusterName();
               String targetVersion = this.nacosDiscoveryProperties.getMetadata().get("target-version");
   
               DynamicServerListLoadBalancer loadBalancer = (DynamicServerListLoadBalancer) getLoadBalancer();
               String name = loadBalancer.getName();
   
               NamingService namingService = this.nacosDiscoveryProperties.namingServiceInstance();
   
               // All instances
               List<Instance> instances = namingService.selectInstances(name, true);
   
               List<Instance> metadataMatchInstances = instances;
               // If version mapping is configured, only instances of metadata matching are called
               if (StringUtils.isNotBlank(targetVersion)) {
                   metadataMatchInstances = instances.stream()
                           .filter(instance -> Objects.equals(targetVersion, instance.getMetadata().get("version")))
                           .collect(Collectors.toList());
                   if (CollectionUtils.isEmpty(metadataMatchInstances)) {
                       log.warn("No metadata matching target instance found! Check the configuration. targetVersion = {}, instance = {}", targetVersion, instances);
                       return null;
                   }
               }
   
               List<Instance> clusterMetadataMatchInstances = metadataMatchInstances;
               // If the cluster name is specified, filter the instances whose metadata matches the cluster
               if(StringUtils.isNotBlank(clusterName)) { clusterMetadataMatchInstances = metadataMatchInstances.stream() .filter(instance  -> Objects.equals(clusterName, instance.getClusterName())) .collect(Collectors.toList());if (CollectionUtils.isEmpty(clusterMetadataMatchInstances)) {
                       clusterMetadataMatchInstances = metadataMatchInstances;
                       log.warn("A cross-cluster call occurred. clusterName = {}, targetVersion = {}, clusterMetadataMatchInstances = {}", clusterName, targetVersion, clusterMetadataMatchInstances);
                   }
               }
   
               Instance instance = ExtendBalancer.getHostByRandomWeight2(clusterMetadataMatchInstances);
               return new NacosServer(instance);
           } catch (Exception e) {
               log.warn("Abnormal", e);
               return null; }}@Override
       public void initWithNiwsConfig(IClientConfig iClientConfig) {}}class ExtendBalancer extends Balancer {
       /** * select instance ** randomly according to weight@paramInstances List of instances *@returnThe selected instance */
       public static Instance getHostByRandomWeight2(List<Instance> instances) {
           returngetHostByRandomWeight(instances); }}Copy the code

2. Editing a Configuration File

   The name of the service in the registry
   user-center:
     ribbon:
       NFLoadBalancerRuleClassName: com.samir.contentcenter.configuration.NacosFinalRule Rule full path
   Copy the code