Compartilhamento de tecnologia

Cluster SpringCloud--Eureka

2024-07-12

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

Cluster do centro de registro Eureka

Por que agrupar

Se houver apenas um servidor do centro de registro, haverá um único ponto de falha e ele não poderá ser processado com alta simultaneidade, portanto, será necessário um cluster.

Como agrupar

Prepare três EurekaServers para se registrarem entre si, o que significa que cada EurekaServer precisa se registrar em todos os EureakServers, incluindo ele mesmo. Cada EurekaServer atua como servidor e cliente. Nossos outros microsserviços (pedido, usuário) só precisam apontar o endereço de registro para todos os EurekaServers.

Código:

O que é usado aqui é um módulo Eureka, que configura vários arquivos yml para obter o efeito de cluster.

Aula de inicialização

  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>

Balanceamento de carga de serviço

Por que o balanceamento de carga é necessário

Para fornecer simultaneidade, às vezes o mesmo provedor de serviços pode implantar vários (serviços de commodities). Este cliente deve completar a chamada de carga de acordo com uma determinada estratégia de balanceamento responsável ao chamar.

Configuração do provedor de serviços

  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

Tecnologias comuns de implementação de balanceamento de carga

Fita

Através do RestTmplate, conclua a chamada de serviço com url

Implementação de código (lado do consumidor de serviço):

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

Chamada de balanceamento de carga de fita

Ribbon é um projeto de código aberto de serviço de camada intermediária em nuvem lançado pela Netflix. Sua principal função é fornecer algoritmo de balanceamento de carga do cliente. O componente cliente Ribbon fornece uma série de itens de configuração completos, como tempo limite de conexão, nova tentativa, etc. Simplificando, o Ribbon é um balanceador de carga do cliente. Podemos listar todas as máquinas por trás do balanceador de carga no arquivo de configuração, e o Ribbon irá ajudá-lo automaticamente a se conectar com base em certas regras (como pesquisa simples, conexões aleatórias, etc.). máquinas, podemos facilmente usar o Ribbon para implementar algoritmos de balanceamento de carga personalizados. Ribbon é um balanceador de carga de cliente que pode concluir chamadas de balanceamento de carga para várias instâncias de serviço de um serviço de acordo com determinadas regras. Essas regras também oferecem suporte à personalização.

Esquemático:

Balanceamento de carga OpenFeign

OpenFeign é um cliente de serviço Web declarativo cujo objetivo é facilitar as chamadas de serviços Web. Feign fornece um modelo de interface para solicitações HTTP (o endereço de acesso está marcado nela). Ao escrever uma interface simples e inserir anotações, você pode definir os parâmetros, formato, endereço e outras informações da solicitação HTTP. OpenFeign fará proxy completo de solicitações HTTP (proxy dinâmico). Precisamos apenas chamá-lo como um método para concluir a solicitação de serviço e o processamento relacionado. Feign integra Ribbon e Hystrix (falaremos sobre Hystrix mais tarde), de modo que não precisamos mais usar esses dois componentes explicitamente.

Estratégia de balanceamento de carga

Eu mando

Ao configurar diferentes subclasses de IRule, é possível escolher diferentes estratégias de balanceamento de carga, ou seja, selecionar um serviço da lista de serviços com uma estratégia específica para concluir a chamada. Claro que também pode ser personalizado. Portanto, as estratégias de balanceamento de carga podem ser divididas em integradas e personalizadas.

Estratégia de balanceamento de carga integrada

 

Perfil pessoal

Ele se dedica à pesquisa de tecnologia há mais de 30 anos e é proficiente em diversas linguagens como java, linux, javascript, php, css, etc. estação de documentação do desenvolvedor para compartilhar alguns problemas no desenvolvimento de tecnologia para referência futura.

minhas informações de contato

Correspondência