Condivisione della tecnologia

SpringCloud: cluster Eureka

2024-07-12

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

Cluster del centro di registrazione Eureka

Perché raggrupparsi

Se è presente un solo server del centro di registrazione, sarà presente un singolo punto di errore e non potrà essere elaborato con elevata concorrenza, pertanto è necessario un cluster.

Come raggruppare

Preparare tre EurekaServer per registrarsi tra loro, il che significa che ogni EurekaServer deve registrarsi con tutti gli EureakServer, incluso se stesso. Ogni EurekaServer agisce sia come server che come client. Gli altri nostri microservizi (ordine, utente) devono solo indirizzare l'indirizzo di registrazione a tutti gli EurekaServer.

Codice:

Ciò che viene utilizzato qui è un modulo Eureka, che configura più file yml per ottenere l'effetto del clustering.

Classe di avvio

  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. }

piccolo formato

  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>

Bilanciamento del carico del servizio

Perché è necessario il bilanciamento del carico

Per garantire la concorrenza, a volte lo stesso fornitore di servizi può distribuirne più (servizi di base). Questo client deve completare la chiamata di carico secondo una determinata strategia di bilanciamento responsabile durante la chiamata.

Configurazione del fornitore di servizi

  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

Tecnologie comuni di implementazione del bilanciamento del carico

Nastro

Tramite RestTmplate, completa la chiamata di servizio con l'URL

Implementazione del codice (lato consumatore del servizio):

  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. }

Chiamata di bilanciamento del carico della barra multifunzione

Ribbon è un progetto open source del servizio di livello intermedio cloud rilasciato da Netflix. La sua funzione principale è fornire un algoritmo di bilanciamento del carico del client. Il componente client della barra multifunzione fornisce una serie di elementi di configurazione completi, come timeout della connessione, nuovo tentativo, ecc. In poche parole, Ribbon è un bilanciatore del carico del client. Possiamo elencare tutte le macchine dietro il bilanciatore del carico nel file di configurazione e Ribbon ti aiuterà automaticamente a connetterti in base a determinate regole (come polling semplice, connessioni casuali, ecc.) Per queste. macchine, possiamo facilmente utilizzare Ribbon per implementare algoritmi di bilanciamento del carico personalizzati. La barra multifunzione è un bilanciatore del carico client in grado di completare le chiamate di bilanciamento del carico per più istanze di un servizio in base a determinate regole. Queste regole supportano anche la personalizzazione.

Schema:

Bilanciamento del carico OpenFeign

OpenFeign è un client di servizi Web dichiarativo il cui scopo è semplificare le chiamate ai servizi Web. Feign fornisce un modello di interfaccia per le richieste HTTP (su di esso è indicato l'indirizzo di accesso). Scrivendo una semplice interfaccia e inserendo annotazioni, è possibile definire i parametri, il formato, l'indirizzo e altre informazioni della richiesta HTTP. OpenFeign eseguirà completamente il proxy delle richieste HTTP (proxy dinamico). Dobbiamo solo chiamarlo come un metodo per completare la richiesta di servizio e la relativa elaborazione. Feign integra Ribbon e Hystrix (di Hystrix parleremo più avanti), in modo che non abbiamo più bisogno di utilizzare questi due componenti esplicitamente.

Strategia di bilanciamento del carico

Io domino

Configurando diverse sottoclassi IRule, è possibile scegliere diverse strategie di bilanciamento del carico, ovvero selezionare un servizio dall'elenco dei servizi con una strategia specifica per completare la chiamata. Naturalmente può anche essere personalizzato. Pertanto, le strategie di bilanciamento del carico possono essere suddivise in integrate e personalizzate.

Strategia di bilanciamento del carico integrata

 

Profilo personale

Si dedica alla ricerca tecnologica da più di 30 anni ed è esperto in vari linguaggi come Java, Linux, Javascript, php, css, ecc. Ha dato numerosi contributi nel campo dell'open source stazione di documentazione per gli sviluppatori per condividere alcuni problemi nello sviluppo della tecnologia per riferimento futuro

le mie informazioni di contatto

Posta