TOC

Einführung in Spring Cloud Netflix - Eureka

Einführung in Spring Cloud Netflix - Eureka

1. Überblick

In diesem Tutorial stellen wir die Entdeckung vonclient-side serviceüber "Spring Cloud Netflix Eureka" vor.

Client-side service discovery allows services to find and communicate with each other without hard-coding hostname and port. Der einzige „feste Punkt“ in einer solchen Architektur besteht ausservice registry, bei denen sich jeder Dienst registrieren muss.

Ein Nachteil ist, dass alle Clients eine bestimmte Logik implementieren müssen, um mit diesem Fixpunkt zu interagieren. Dies setzt eine zusätzliche Netzwerkrundreise vor der eigentlichen Anfrage voraus.

Mit Netflix Eureka kann jeder Client gleichzeitig als Server fungieren, um seinen Status einem verbundenen Peer zu replizieren. Mit anderen Worten, ein Client ruft eine Liste aller verbundenen Peers vonservice registry ab und stellt alle weiteren Anforderungen über einen Lastausgleichsalgorithmus an andere Dienste.

Um über die Anwesenheit eines Kunden informiert zu werden, muss dieser ein Heartbeat-Signal an die Registry senden.

Um das Ziel dieser Zuschreibung zu erreichen, implementieren wir dreimicroservices:

  • aservice registry (Eureka Server),

  • aREST Dienst, der sich bei der Registrierung registriert (Eureka Client) und

  • Eine Webanwendung, die den DienstRESTals registrierungsbewussten Client (Spring Cloud Netflix *Feign Client*) verwendet.

    == Weiterführende Literatur:

Ein Leitfaden für Spring Cloud Netflix - Hystrix

Der Artikel zeigt, wie Sie mithilfe von Spring Cloud Hystrix ein Fallback in Ihrer Anwendungslogik einrichten.

Read more →

Spring REST mit einem Zuul Proxy

Erkundung der Verwendung des Zuul-Proxys für eine Spring REST-API unter Umgehung von CORS und der Richtlinieneinschränkung für denselben Ursprung des Browsers.

Read more →

2. Eureka Server

Das Implementieren vonEureka Server für die Serviceregistrierung ist so einfach wie:

  1. Hinzufügen vonspring-cloud-starter-netflix-eureka-server zu den Abhängigkeiten

  2. Aktivieren Sie den Eureka-Server in@SpringBootApplication, indem Sie ihn mit@EnableEurekaServer versehen

  3. Konfigurieren Sie einige Eigenschaften

Aber wir werden es Schritt für Schritt tun.

Zuerst erstellen wir ein neues Maven-Projekt und fügen die Abhängigkeiten ein. Sie müssen beachten, dass wir diespring-cloud-starter-parent in alle in diesem Tutorial beschriebenen Projekte importieren: 


    org.springframework.cloud
    spring-cloud-starter-netflix-eureka-server



    
        
            org.springframework.cloud
            spring-cloud-starter-parent
            Greenwich.RELEASE
            pom
            import

Hinweis: Wir können die neuesten Spring Cloud-Versionen inthe Spring’s Projects documentation überprüfen.

Als Nächstes erstellen wir die Hauptanwendungsklasse: 

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

Schließlich konfigurieren wir die Eigenschaften im FormatYAML. Einapplication.yml ist also unsere Konfigurationsdatei: 

server:
  port: 8761
eureka:
  client:
    registerWithEureka: false
    fetchRegistry: false

Here we’re configuring an application port – 8761 is the default one for Eureka servers. Wir weisen die integriertenEureka Client an, sich nicht bei "sich selbst" zu registrieren, da unsere Anwendung als Server fungieren sollte.

Jetzt zeigen wir unseren Browser aufhttp://localhost:8761, um das Dashboard vonEurekaanzuzeigen, in dem wir später die registrierten Instanzen überprüfen.

Derzeit sehen wir grundlegende Indikatoren wie Status- und Gesundheitsindikatoren.

image

3. Eureka Client

Damit ein@SpringBootApplication erkennungsbewusst ist, müssen wir einigeSpring Discovery Client (zum Beispielspring-cloud-starter-netflix-eureka-client) in unsereclasspath. aufnehmen

Dann müssen wir@Configuration mit@EnableDiscoveryClient oder@EnableEurekaClient – annotieren. Beachten Sie, dass diese Annotation optional ist, wenn wir die Abhängigkeit vonspring-cloud-starter-netflix-eureka-client vom Klassenpfad haben.

Letzteres weistSpring Boot an, Spring Netflix Eureka explizit für die Serviceerkennung zu verwenden. Um unsere Client-Anwendung mit einer gewissen Lebensdauer zu füllen, werden wir auch dasspring-boot-starter-web-Paket in diepom.xml aufnehmen und einenREST-Controller implementieren.

Aber zuerst werden wir die Abhängigkeiten hinzufügen. Auch hier können wir es derspring-cloud-starter-parent -abhängigkeit überlassen, die Artefaktversionen für uns herauszufinden: 


    org.springframework.cloud
    spring-cloud-starter-netflix-eureka-starter


    org.springframework.boot
    spring-boot-starter-web

Hier werden wir die Hauptanwendungsklasse implementieren: 

@SpringBootApplication
@RestController
public class EurekaClientApplication implements GreetingController {

    @Autowired
    @Lazy
    private EurekaClient eurekaClient;

    @Value("${spring.application.name}")
    private String appName;

    public static void main(String[] args) {
        SpringApplication.run(EurekaClientApplication.class, args);
    }

    @Override
    public String greeting() {
        return String.format(
          "Hello from '%s'!", eurekaClient.getApplication(appName).getName());
    }
}

Und dieGreetingController-Schnittstelle: 

public interface GreetingController {
    @RequestMapping("/greeting")
    String greeting();
}

Hier könnten wir anstelle der Schnittstelle auch einfach die Zuordnung innerhalb der KlasseEurekaClientApplicationdeklarieren. Die Schnittstelle kann nützlich sein, wenn wir sie zwischen Server und Client teilen möchten.

Als Nächstes müssen wir einapplication.yml mit einem konfiguriertenSpring-Anwendungsnamen einrichten, um unseren Client in der Liste der registrierten Anwendungen eindeutig zu identifizieren.

Wir könnenSpring Boot einen zufälligen Port für uns auswählen lassen, da wir später mit seinem Namen auf diesen Dienst zugreifen.

Schließlich müssen wir unserem Kunden mitteilen, wo er die Registrierung finden muss: 

spring:
  application:
    name: spring-cloud-eureka-client
server:
  port: 0
eureka:
  client:
    serviceUrl:
      defaultZone: ${EUREKA_URI:http://localhost:8761/eureka}
  instance:
    preferIpAddress: true

Als wir beschlossen haben, unseren Eureka-Client auf diese Weise einzurichten, hatten wir uns vorgenommen, dass diese Art von Service später leicht skalierbar sein sollte.

Jetzt führen wir den Client aus und zeigen unseren Browser erneut aufhttp://localhost:8761, um den Registrierungsstatus im Eureka-Dashboard anzuzeigen. Über das Dashboard können wir weitere Einstellungen vornehmen, z. Verknüpfen Sie die Homepage eines registrierten Kunden zu Verwaltungszwecken mit dem Dashboard. Die Konfigurationsoptionen sprengen jedoch den Rahmen dieses Artikels.

image

4. Kunden vortäuschen

Um unser Projekt mit drei abhängigen Microservices abzuschließen, implementieren wir jetzt eine Webanwendung, dieREST verbraucht undSpring Netflix Feign Client verwendet.

Stellen Sie sichFeignals entdeckungsbewussteSpring RestTemplatevor, die Schnittstellen für die Kommunikation mit Endpunkten verwenden. Diese Schnittstellen werden zur Laufzeit automatisch implementiert und verwenden anstelle vonservice-urlsservice-names.

OhneFeign müssten wir eine Instanz vonEurekaClient automatisch in unseren Controller verdrahten, mit der wir eine Dienstinformation vonservice-name alsApplication-Objekt erhalten könnten.

Wir würden dieseApplication verwenden, um eine Liste aller Instanzen dieses Dienstes zu erhalten, eine geeignete auswählen und dieseInstanceInfo verwenden, um den Hostnamen und den Port abzurufen. Damit könnten wir eine Standardanforderung mit jedemhttp client durchführen.

Zum Beispiel: 

@Autowired
private EurekaClient eurekaClient;

public void doRequest() {
    Application application =
      eurekaClient.getApplication("spring-cloud-eureka-client");
    InstanceInfo instanceInfo = application.getInstances().get(0);
    String hostname = instanceInfo.getHostName();
    int port = instanceInfo.getPort();
    // ...
}

EinRestTemplate kann auch verwendet werden, um namentlich aufEureka Client-Services zuzugreifen, aber dieses Thema geht über diese Beschreibung hinaus.

Um unserFeign Client-Projekt einzurichten, fügen wir denpom.xml die folgenden vier Abhängigkeiten hinzu: 


    org.springframework.cloud
    spring-cloud-starter-feign


    org.springframework.cloud
    spring-cloud-starter-netflix-eureka-client


    org.springframework.boot
    spring-boot-starter-web


    org.springframework.boot
    spring-boot-starter-thymeleaf

DasFeign Client befindet sich im Paketspring-cloud-starter-feign. Um dies zu aktivieren, müssen wir@Configuration mit@EnableFeignClients versehen. Um es zu verwenden, kommentieren wir einfach eine Schnittstelle mit@FeignClient(“service-name”) und verdrahten sie automatisch mit einem Controller.

Eine gute Methode, um solcheFeignClients zu erstellen, besteht darin, Schnittstellen mit@RequestMapping annotierten Methoden zu erstellen und diese in ein separates Modul zu stellen. Auf diese Weise können sie zwischen Server und Client geteilt werden. Auf der Serverseite können Sie sie als@Controller implementieren, und auf der Clientseite können sie als@FeignClient erweitert und mit Anmerkungen versehen werden.

Darüber hinaus müssen diespring-cloud-starter-eureka package in das Projekt aufgenommen und durch Annotieren der Hauptanwendungsklasse mit@EnableEurekaClient aktiviert werden.

Die Abhängigkeitenspring-boot-starter-web undspring-boot-starter-thymeleaf werden fürpresent a view verwendet und enthalten abgerufene Daten von unserem DienstREST.

Dies wird unsereFeign Client-Schnittstelle sein: 

@FeignClient("spring-cloud-eureka-client")
public interface GreetingClient {
    @RequestMapping("/greeting")
    String greeting();
}

Hier implementieren wir die Hauptanwendungsklasse, die gleichzeitig als Controller fungiert: 

@SpringBootApplication
@EnableFeignClients
@Controller
public class FeignClientApplication {
    @Autowired
    private GreetingClient greetingClient;

    public static void main(String[] args) {
        SpringApplication.run(FeignClientApplication.class, args);
    }

    @RequestMapping("/get-greeting")
    public String greeting(Model model) {
        model.addAttribute("greeting", greetingClient.greeting());
        return "greeting-view";
    }
}

Dies wird die HTML-Vorlage für unsere Ansicht sein: 



    
        Greeting Page

Zumindest die Konfigurationsdatei vonapplication.ymlist fast dieselbe wie im vorherigen Schritt: 

spring:
  application:
    name: spring-cloud-eureka-feign-client
server:
  port: 8080
eureka:
  client:
    serviceUrl:
      defaultZone: ${EUREKA_URI:http://localhost:8761/eureka}

Jetzt können wir diesen Dienst erstellen und ausführen. Schließlich zeigen wir unseren Browser aufhttp://localhost:8080/get-greeting und er sollte ungefähr Folgendes anzeigen: 

Hello from SPRING-CLOUD-EUREKA-CLIENT!

5. KeinTransportException: Anforderung kann auf keinem bekannten Server ausgeführt werden '

Während des Betriebs eines Eureka-Servers treten häufig Ausnahmen auf wie: 

com.netflix.discovery.shared.transport.TransportException: Cannot execute request on any known server

Grundsätzlich geschieht dies aufgrund der falschen Konfiguration inapplication.properties oderapplication.yml. Eureka bietet zwei Eigenschaften für den Client, die konfiguriert werden können.

  • registerWithEureka: Wenn wir diese Eigenschaft alstrue festlegen, versucht der eingebaute Client beim Starten des Servers, sich beim Eureka-Server zu registrieren.

  • fetchRegistry: Der eingebaute Client versucht, die Registrierung vonEurekaabzurufen, wenn wir diese Eigenschaft als true konfigurieren.

Jetztwhen we start up the Eureka server, we don’t want to register the inbuilt client to configure itself with the server.

Wenn wir die obigen Eigenschaften beim Starten des Servers alstrue markieren (oder sie nicht standardmäßig alstrue konfigurieren), versucht der eingebaute Client, sich beiEureka zu registrieren Server und versucht auch, eine Registrierung abzurufen, die noch nicht verfügbar ist. Als Ergebnis erhalten wirTransportException.

Daher sollten wir diese Eigenschaften in den Serveranwendungen vonEurekaniemals alstrue konfigurieren. Die korrekten Einstellungen, die inapplication.yml eingegeben werden sollten, sind unten angegeben: 

eureka:
  client:
    registerWithEureka: false
    fetchRegistry: false

6. Fazit

Wie wir gesehen haben, können wir jetzt eine Dienstregistrierung mitSpring Netflix Eureka Server implementieren und einigeEureka Clients damit registrieren.

Da unserEureka Clientaus Schritt 3 einen zufällig ausgewählten Port überwacht, kennt er seinen Speicherort ohne die Informationen aus der Registrierung nicht. MitFeign Client und unserer Registrierung können wir den DienstRESTuchen und nutzen, auch wenn sich der Standort ändert.

Schließlich haben wir ein umfassendes Bild von der Verwendung der Serviceerkennung in einer Microservice-Architektur.

Wie üblich finden Sie die Quellenon GitHub,, die auch eine Reihe vonDocker-bezogenen Dateien enthalten, die Sie mitdocker-compose verwenden können, um Container aus unserem Projekt zu erstellen.

Related