Compartir tecnología

SpringCloud: clúster Eureka

2024-07-12

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

Clúster de centros de registro de Eureka

¿Por qué agruparse?

Si solo hay un servidor del centro de registro, habrá un único punto de falla y no se podrá procesar con alta concurrencia, por lo que se requiere un clúster.

Cómo agrupar

Prepare tres EurekaServers para registrarse entre sí, lo que significa que cada EurekaServer debe registrarse con todos los EureakServers, incluido él mismo. Cada EurekaServer actúa como servidor y cliente. Nuestros otros microservicios (pedido, usuario) solo necesitan señalar la dirección de registro a todos los EurekaServers.

Código:

Lo que se utiliza aquí es un módulo Eureka, que configura varios archivos yml para lograr el efecto de agrupación.

clase de inicio

  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>

Equilibrio de carga de servicio

Por qué es necesario el equilibrio de carga

Para proporcionar simultaneidad, a veces el mismo proveedor de servicios puede implementar múltiples (servicios básicos). Este cliente debe completar la llamada de carga de acuerdo con una determinada estrategia de equilibrio responsable al llamar.

Configuración del proveedor de servicios

  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

Tecnologías comunes de implementación de equilibrio de carga

Cinta

A través de RestTmplate, complete la llamada de servicio con la URL

Implementación de código (lado del consumidor del servicio):

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

Llamada de equilibrio de carga de cinta

Ribbon es un proyecto de código abierto de servicio de capa intermedia en la nube lanzado por Netflix. Su función principal es proporcionar un algoritmo de equilibrio de carga del cliente. El componente del cliente Ribbon proporciona una serie de elementos de configuración completos, como tiempo de espera de conexión, reintento, etc. En pocas palabras, Ribbon es un equilibrador de carga del cliente. Podemos enumerar todas las máquinas detrás del equilibrador de carga en el archivo de configuración, y Ribbon lo ayudará automáticamente a conectarse según ciertas reglas (como sondeo simple, conexiones aleatorias, etc.) para estas. máquinas, podemos usar fácilmente Ribbon para implementar algoritmos de equilibrio de carga personalizados. Ribbon es un equilibrador de carga del cliente que puede completar llamadas de equilibrio de carga para múltiples instancias de un servicio de acuerdo con ciertas reglas. Estas reglas también admiten la personalización.

Esquemático:

Equilibrio de carga OpenFeign

OpenFeign es un cliente de servicios web declarativo cuyo propósito es facilitar las llamadas a servicios web. Feign proporciona una plantilla de interfaz para solicitudes HTTP (la dirección de acceso está marcada en ella). Al escribir una interfaz simple e insertar anotaciones, puede definir los parámetros, el formato, la dirección y otra información de la solicitud HTTP. OpenFeign representará completamente las solicitudes HTTP (proxy dinámico). Solo necesitamos llamarlo como un método para completar la solicitud de servicio y el procesamiento relacionado. Feign integra Ribbon y Hystrix (hablaremos de Hystrix más adelante), por lo que ya no necesitamos usar estos dos componentes explícitamente.

Estrategia de equilibrio de carga

Yo mando

Al configurar diferentes subclases de IRule, puede elegir diferentes estrategias de equilibrio de carga, es decir, seleccionar un servicio de la lista de servicios con una estrategia específica para completar la llamada. Por supuesto, también se puede personalizar. Por lo tanto, las estrategias de equilibrio de carga se pueden dividir en integradas y personalizadas.

Estrategia de equilibrio de carga incorporada

 

Perfil personal

Se ha dedicado a la investigación de tecnología durante más de treinta años, domina varios lenguajes como java, linux, javascript, php, css, etc., y ha realizado muchas contribuciones en el campo del código abierto. una estación de documentación para desarrolladores para compartir algunos problemas en el desarrollo de tecnología para referencia futura.

Mi informacion de contacto

Correo