Partage de technologie

SpringCloud - cluster Eureka

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Cluster du centre d'enregistrement Eureka

Pourquoi regrouper

S'il n'y a qu'un seul serveur de centre d'enregistrement, il y aura un seul point de défaillance et il ne pourra pas être traité avec une concurrence élevée, un cluster est donc requis.

Comment regrouper

Préparez trois EurekaServers pour qu'ils s'enregistrent les uns auprès des autres, ce qui signifie que chaque EurekaServer doit s'enregistrer auprès de tous les EureakServers, y compris lui-même. Chaque EurekaServer agit à la fois comme serveur et comme client. Nos autres microservices (commande, utilisateur) n'ont qu'à pointer l'adresse d'enregistrement vers tous les EurekaServers.

Code:

Ce qui est utilisé ici est un module Eureka, qui configure plusieurs fichiers yml pour obtenir l'effet de clustering.

Classe de démarrage

  1. package org.example;
  2.  
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5. import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
  6.  
  7. /**
  8.  * @ClassName EurekaStart
  9.  * @Author 23
  10.  * @Date 2024/7/10 19:12
  11.  * @Version 1.0
  12.  * @Description TODO
  13.  **/
  14. @SpringBootApplication
  15. @EnableEurekaServer
  16. public class EurekaStart {
  17.     public static void main(String[] args) {
  18.         SpringApplication.run(EurekaStart.class,args);
  19.     }
  20. }

yml

  1. spring:
  2.   profiles:
  3.     active: peer3
  4. ---
  5. spring:
  6.   profiles: peer1
  7.   application:
  8.     name: Eureka1
  9. eureka:
  10.   instance:
  11.     hostname: localhost
  12.   client:
  13.     serviceUrl:
  14.       defaultZone: http://localhost:10070/eureka/
  15. server:
  16.   port: 10070
  17. ---
  18. spring:
  19.   profiles: peer2
  20.   application:
  21.     name: Eureka2
  22. eureka:
  23.   instance:
  24.     hostname: localhost
  25.   client:
  26.     serviceUrl:
  27.       defaultZone: http://localhost:10071/eureka/
  28. server:
  29.   port: 10071
  30. ---
  31. spring:
  32.   profiles: peer3
  33.   application:
  34.     name: Eureka3
  35. eureka:
  36.   instance:
  37.     hostname: localhost
  38.   client:
  39.     serviceUrl:
  40.       defaultZone: http://localhost:10072/eureka/
  41. server:
  42.   port: 10072

pom.xml

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.     <modelVersion>4.0.0</modelVersion>
  4.     <parent>
  5.         <groupId>org.example</groupId>
  6.         <artifactId>Springcloud-Netflix</artifactId>
  7.         <version>1.0-SNAPSHOT</version>
  8.     </parent>
  9.  
  10.     <artifactId>Eureka-Service</artifactId>
  11.     <packaging>jar</packaging>
  12.  
  13.     <name>Eureka-Service</name>
  14.     <url>http://maven.apache.org</url>
  15.  
  16.     <properties>
  17.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  18.     </properties>
  19.  
  20.     <dependencies>
  21.         <dependency>
  22.             <groupId>junit</groupId>
  23.             <artifactId>junit</artifactId>
  24.             <version>3.8.1</version>
  25.             <scope>test</scope>
  26.         </dependency>
  27.         <dependency>
  28.             <groupId>org.springframework.boot</groupId>
  29.             <artifactId>spring-boot-starter-web</artifactId>
  30.         </dependency>
  31.         <dependency>
  32.             <groupId>org.springframework.boot</groupId>
  33.             <artifactId>spring-boot-starter-test</artifactId>
  34.         </dependency>
  35.         <!-- Eureka服务端支持 -->
  36.         <dependency>
  37.             <groupId>org.springframework.cloud</groupId>
  38.             <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
  39.         </dependency>
  40.     </dependencies>
  41. </project>

Équilibrage de la charge des services

Pourquoi l'équilibrage de charge est nécessaire

Afin d'assurer la concurrence, le même fournisseur de services peut parfois en déployer plusieurs (services de base). Ce client doit effectuer l'appel de charge selon une certaine stratégie d'équilibrage responsable lors de l'appel.

Configuration du fournisseur de services

  1. spring:
  2.   profiles:
  3.     active: order2
  4. ---
  5. server:
  6.   port: 10010
  7. spring:
  8.   profiles: order1
  9.   application:
  10.     name: order-service
  11. eureka:
  12.   client:
  13.     service-url:
  14.       defaultZone:  http://localhost:10072/eureka
  15.   instance:
  16.     prefer-ip-address: true
  17. ---
  18. server:
  19.   port: 10012
  20. spring:
  21.   profiles: order2
  22.   application:
  23.     name: order-service
  24. eureka:
  25.   client:
  26.     service-url:
  27.       defaultZone: http://localhost:10072/eureka
  28.   instance:
  29.     prefer-ip-address: true

Technologies courantes de mise en œuvre de l'équilibrage de charge

Ruban

Via RestTmplate, complétez l'appel de service avec l'URL

Implémentation du code (côté consommateur du service) :

  1. package org.example.Controller;
  2.  
  3. import org.example.domain.Order;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.cloud.client.ServiceInstance;
  6. import org.springframework.cloud.client.discovery.DiscoveryClient;
  7. import org.springframework.web.bind.annotation.GetMapping;
  8. import org.springframework.web.bind.annotation.PathVariable;
  9. import org.springframework.web.bind.annotation.RequestMapping;
  10. import org.springframework.web.bind.annotation.RestController;
  11. import org.springframework.web.client.RestTemplate;
  12.  
  13. import java.util.Arrays;
  14. import java.util.List;
  15.  
  16. /**
  17.  * @ClassName UserController
  18.  * @Author 23
  19.  * @Date 2024/7/10 18:52
  20.  * @Version 1.0
  21.  * @Description TODO
  22.  **/
  23. @RestController
  24. @RequestMapping("/User")
  25. public class UserControllerrlb {
  26.     @Autowired
  27.     private RestTemplate restTemplate;
  28. //    @Autowired
  29. //    private DiscoveryClient discoveryClient;
  30.     @GetMapping("/getOrder/{id}")
  31.     public List<Order> getOrderById(@PathVariable("id") Integer id) {
  32. //        Order[] order = restTemplate.getForObject("http://localhost:10010/OrderService/user/" + id, Order[].class);
  33. //        return Arrays.asList(order);
  34. //        List<ServiceInstance> instances=discoveryClient.getInstances("order-service");//通过服务的名字去获取服务实例
  35. //        ServiceInstance serviceInstance=instances.get(0);//定死只获取第一个服务实例对象
  36. //        String ip=serviceInstance.getHost();//获取服务对象ip
  37. //        int port=serviceInstance.getPort();//获取获取的实例对象的服务端口号
  38.         Order[] orders=restTemplate.getForObject("http://Order-Service/OrderService/user/"+id,Order[].class);
  39.         return Arrays.asList(orders);
  40.  
  41.     }
  42. }

Appel d’équilibrage de charge du ruban

Ribbon est un projet open source de service cloud de couche intermédiaire publié par Netflix. Sa fonction principale est de fournir un algorithme d'équilibrage de charge client. Le composant client Ribbon fournit une série d'éléments de configuration complets, tels que le délai d'expiration de la connexion, la nouvelle tentative, etc. En termes simples, Ribbon est un équilibreur de charge client. Nous pouvons lister toutes les machines derrière l'équilibreur de charge dans le fichier de configuration, et Ribbon vous aidera automatiquement à vous connecter en fonction de certaines règles (telles qu'une simple interrogation, des connexions aléatoires, etc.). machines, nous pouvons facilement utiliser Ribbon pour implémenter des algorithmes d’équilibrage de charge personnalisés. Ribbon est un équilibreur de charge client qui peut effectuer des appels d'équilibrage de charge pour plusieurs instances de service d'un service selon certaines règles. Ces règles prennent également en charge la personnalisation.

Schématique:

Équilibrage de charge OpenFeign

OpenFeign est un client de service Web déclaratif dont le but est de faciliter les appels de services Web. Feign fournit un modèle d'interface pour les requêtes HTTP (l'adresse d'accès y est marquée). En écrivant une interface simple et en insérant des annotations, vous pouvez définir les paramètres, le format, l'adresse et d'autres informations de la requête HTTP. OpenFeign proxyera complètement les requêtes HTTP (proxy dynamique). Il nous suffit de l'appeler comme une méthode pour terminer la demande de service et le traitement associé. Feign intègre Ribbon et Hystrix (nous parlerons d'Hystrix plus tard), de sorte que nous n'avons plus besoin d'utiliser explicitement ces deux composants.

Stratégie d'équilibrage de charge

Je décide

En configurant différentes sous-classes d'IRule, vous pouvez choisir différentes stratégies d'équilibrage de charge, c'est-à-dire sélectionner un service dans la liste des services avec une stratégie spécifique pour terminer l'appel. Bien entendu, il peut également être personnalisé. Par conséquent, les stratégies d’équilibrage de charge peuvent être divisées en stratégies intégrées et personnalisées.

Stratégie d'équilibrage de charge intégrée

 

Profil personnel

Il se consacre à la recherche technologique depuis plus de 30 ans et maîtrise divers langages tels que java, linux, javascript, php, css, etc. Il a apporté de nombreuses contributions dans le domaine de l'open source. station de documentation pour les développeurs pour partager certains problèmes de développement technologique pour référence future.

mes coordonnées

Mail