SpringCloud – Eureka cluster

SpringCloud – Eureka-Cluster

2024-07-12

Cluster der Eureka-Registrierungszentren

Warum Cluster

Wenn nur ein Registrierungscenter-Server vorhanden ist, liegt ein einzelner Fehlerpunkt vor, der nicht mit hoher Parallelität verarbeitet werden kann. Daher ist ein Cluster erforderlich.

So gruppieren Sie

Bereiten Sie drei EurekaServer für die gegenseitige Registrierung vor, was bedeutet, dass sich jeder EurekaServer bei allen EureakServern registrieren muss, einschließlich sich selbst. Jeder EurekaServer fungiert sowohl als Server als auch als Client. Unsere anderen Microservices (Bestellung, Benutzer) müssen lediglich die Registrierungsadresse auf alle EurekaServer verweisen.

Code:

Hier wird ein Eureka-Modul verwendet, das mehrere YML-Dateien konfiguriert, um den Clustering-Effekt zu erzielen.

Startup-Klasse


package org.example;
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
 
/**
 * @ClassName EurekaStart
 * @Author 23
 * @Date 2024/7/10 19:12
 * @Version 1.0
 * @Description TODO
 **/
@SpringBootApplication
@EnableEurekaServer
public class EurekaStart {
    public static void main(String[] args) {
        SpringApplication.run(EurekaStart.class,args);
    }
}

yml


spring:
  profiles:
    active: peer3
---
spring:
  profiles: peer1
  application:
    name: Eureka1
eureka:
  instance:
    hostname: localhost
  client:
    serviceUrl:
      defaultZone: http://localhost:10070/eureka/
server:
  port: 10070
---
spring:
  profiles: peer2
  application:
    name: Eureka2
eureka:
  instance:
    hostname: localhost
  client:
    serviceUrl:
      defaultZone: http://localhost:10071/eureka/
server:
  port: 10071
---
spring:
  profiles: peer3
  application:
    name: Eureka3
eureka:
  instance:
    hostname: localhost
  client:
    serviceUrl:
      defaultZone: http://localhost:10072/eureka/
server:
  port: 10072

pom.xml


<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.example</groupId>
        <artifactId>Springcloud-Netflix</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
 
    <artifactId>Eureka-Service</artifactId>
    <packaging>jar</packaging>
 
    <name>Eureka-Service</name>
    <url>http://maven.apache.org</url>
 
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
 
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <!-- Eureka服务端支持 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>
</project>

Dienstlastausgleich

Warum Lastausgleich erforderlich ist

Um Parallelität zu gewährleisten, kann derselbe Dienstanbieter manchmal mehrere (Commodity-Dienste) bereitstellen. Dieser Client muss den Ladeaufruf beim Aufruf gemäß einer bestimmten verantwortungsvollen Ausgleichsstrategie abschließen.

Konfiguration des Dienstanbieters


spring:
  profiles:
    active: order2
---
server:
  port: 10010
spring:
  profiles: order1
  application:
    name: order-service
eureka:
  client:
    service-url:
      defaultZone:  http://localhost:10072/eureka
  instance:
    prefer-ip-address: true
---
server:
  port: 10012
spring:
  profiles: order2
  application:
    name: order-service
eureka:
  client:
    service-url:
      defaultZone: http://localhost:10072/eureka
  instance:
    prefer-ip-address: true

Gängige Implementierungstechnologien für den Lastausgleich

Schleife

Schließen Sie über RestTmplate den Serviceaufruf mit der URL ab

Code-Implementierung (Dienstkonsumentenseite):


package org.example.Controller;
 
import org.example.domain.Order;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
 
import java.util.Arrays;
import java.util.List;
 
/**
 * @ClassName UserController
 * @Author 23
 * @Date 2024/7/10 18:52
 * @Version 1.0
 * @Description TODO
 **/
@RestController
@RequestMapping("/User")
public class UserControllerrlb {
    @Autowired
    private RestTemplate restTemplate;
//    @Autowired
//    private DiscoveryClient discoveryClient;
    @GetMapping("/getOrder/{id}")
    public List<Order> getOrderById(@PathVariable("id") Integer id) {
//        Order[] order = restTemplate.getForObject("http://localhost:10010/OrderService/user/" + id, Order[].class);
//        return Arrays.asList(order);
//        List<ServiceInstance> instances=discoveryClient.getInstances("order-service");//通过服务的名字去获取服务实例
//        ServiceInstance serviceInstance=instances.get(0);//定死只获取第一个服务实例对象
//        String ip=serviceInstance.getHost();//获取服务对象ip
//        int port=serviceInstance.getPort();//获取获取的实例对象的服务端口号
        Order[] orders=restTemplate.getForObject("http://Order-Service/OrderService/user/"+id,Order[].class);
        return Arrays.asList(orders);
 
    }
}

Aufruf zum Ribbon-Lastausgleich

Ribbon ist ein Open-Source-Projekt des von Netflix veröffentlichten Cloud-Middle-Layer-Dienstes. Seine Hauptfunktion besteht darin, einen Client-Lastausgleichsalgorithmus bereitzustellen. Die Ribbon-Client-Komponente stellt eine Reihe vollständiger Konfigurationselemente bereit, z. B. Verbindungszeitlimit, Wiederholung usw. Einfach ausgedrückt ist Ribbon ein Client-Load-Balancer. Wir können alle Maschinen hinter dem Load-Balancer in der Konfigurationsdatei auflisten, und Ribbon hilft Ihnen automatisch dabei, eine Verbindung basierend auf bestimmten Regeln (z. B. einfacher Abfrage, zufälliger Verbindung usw.) herzustellen Maschinen können wir Ribbon problemlos verwenden, um benutzerdefinierte Lastausgleichsalgorithmen zu implementieren. Ribbon ist ein Client-Lastausgleichsmodul, das Lastausgleichsaufrufe für mehrere Dienstinstanzen eines Dienstes gemäß bestimmten Regeln durchführen kann. Diese Regeln unterstützen auch die Anpassung.

Schema:

OpenFeign-Lastausgleich

OpenFeign ist ein deklarativer Webdienst-Client, dessen Zweck darin besteht, Webdienstaufrufe einfacher zu machen. Feign stellt eine Schnittstellenvorlage für HTTP-Anfragen bereit (die Zugriffsadresse ist darauf markiert). Durch Schreiben einer einfachen Schnittstelle und Einfügen von Anmerkungen können Sie die Parameter, das Format, die Adresse und andere Informationen der HTTP-Anfrage definieren. OpenFeign leitet HTTP-Anfragen vollständig weiter (dynamischer Proxy). Wir müssen es nur wie eine Methode aufrufen, um die Dienstanforderung und die damit verbundene Verarbeitung abzuschließen. Feign integriert Ribbon und Hystrix (wir werden später über Hystrix sprechen), sodass wir diese beiden Komponenten nicht mehr explizit verwenden müssen.

Lastausgleichsstrategie

Ich regiere

Durch die Konfiguration verschiedener IRule-Unterklassen können Sie unterschiedliche Lastausgleichsstrategien auswählen, d. h. einen Dienst aus der Dienstliste mit einer bestimmten Strategie zum Abschließen des Anrufs auswählen. Natürlich kann es auch individuell angepasst werden. Daher können Lastausgleichsstrategien in integrierte und benutzerdefinierte Strategien unterteilt werden.

Technologieaustausch