Introduktion til Spring Cloud Netflix - Eureka

1. Oversigt

I denne vejledning introducerer vi service på klientsiden opdagelse via “Spring Cloud Netflix Eureka“.

Opdagelse af kundesiden giver tjenester mulighed for at finde og kommunikere med hinanden uden hårdt kodende værtsnavn og port. Det eneste 'faste punkt' i en sådan arkitektur består af en service register som hver tjeneste skal registreres med.

En ulempe er, at alle klienter skal implementere en bestemt logik for at interagere med dette faste punkt. Dette forudsætter en ekstra netværksrundtur inden den faktiske anmodning.

Med Netflix Eureka kan hver klient samtidig fungere som en server for at replikere sin status til en tilsluttet peer. Med andre ord henter en klient en liste over alle tilsluttede jævnaldrende fra en service register og fremsætter alle yderligere anmodninger til andre tjenester gennem en belastningsbalanceringsalgoritme.

For at blive informeret om en klients tilstedeværelse skal de sende et hjerterytmesignal til registreringsdatabasen.

For at nå målet med denne opskrivning implementerer vi tre mikrotjenester:

  • -en service register (Eureka Server),
  • -en HVILE tjeneste, der registrerer sig selv i registreringsdatabasen (Eureka-klient) og
  • en webapplikation, der forbruger HVILE tjeneste som en registreringsbevidst klient (Spring Cloud Netflix Feign-klient).

2. Eureka-server

Implementering af en Eureka Server til service-registreringsdatabasen er lige så let som:

  1. tilføjer spring-cloud-starter-netflix-eureka-server til afhængighederne
  2. aktivere Eureka Server i en @SpringBootApplication ved at kommentere det med @EnableEurekaServer
  3. konfigurere nogle egenskaber

Men vi gør det trin for trin.

For det første opretter vi et nyt Maven-projekt og lægger afhængighederne i det. Du er nødt til at bemærke, at vi importerer spring-cloud-starter-parent til alle projekter, der er beskrevet i denne vejledning:

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

Bemærk: Vi kan kontrollere de seneste Spring Cloud-udgivelser i Spring's Projects-dokumentation.

Dernæst opretter vi hovedapplikationsklassen:

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

Endelig konfigurerer vi egenskaberne i YAML format; så en ansøgning.yml vil være vores konfigurationsfil:

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

Her konfigurerer vi en applikationsport - 8761 er standard for Eureka servere. Vi fortæller det indbyggede Eureka-klient ikke at registrere sig med 'sig selv', fordi vores applikation skal fungere som en server.

Nu peger vi vores browser til // localhost: 8761 for at se Eureka dashboard, hvor vi senere inspicerer de registrerede forekomster.

I øjeblikket ser vi grundlæggende indikatorer såsom status- og sundhedsindikatorer.

3. Eureka-klient

For en @SpringBootApplication For at være opdagelsesbevidste skal vi medtage nogle Spring Discovery Client (for eksempel spring-cloud-starter-netflix-eureka-client) ind i vores klassesti.

Så er vi nødt til at kommentere a @Konfiguration med begge @EnableDiscoveryClient eller @EnableEurekaClient - bemærk, at denne kommentar er valgfri, hvis vi har spring-cloud-starter-netflix-eureka-client afhængighed af klassestien.

Sidstnævnte fortæller Spring Boot at bruge Spring Netflix Eureka eksplicit til opdagelse af tjenester. For at udfylde vores klientapplikation med noget prøvelevetid inkluderer vi også spring-boot-starter-web pakke i pom.xml og implementere en HVILE controller.

Men først tilføjer vi afhængighederne. Igen kan vi overlade det til spring-cloud-starter-parent afhængighed for at finde ud af artefaktversionerne for os:

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

Her implementerer vi den vigtigste applikationsklasse:

@SpringBootApplication @RestController offentlig klasse EurekaClientApplication implementerer GreetingController {@Autowired @Lazy private EurekaClient eurekaClient; @Value ("$ {spring.application.name}") privat streng appnavn; public static void main (String [] args) {SpringApplication.run (EurekaClientApplication.class, args); } @ Override offentlig strenghilsen () {return String.format ("Hej fra '% s'!", EurekaClient.getApplication (appName) .getName ()); }}

Og GreetingController grænseflade:

offentlig grænseflade GreetingController {@RequestMapping ("/ greeting") String greeting (); }

Her, i stedet for grænsefladen, kunne vi også kun erklære kortlægningen inde i EurekaClient-applikation klasse. Interfacet kan være nyttigt, hvis vi vil dele det mellem server og klient.

Derefter skal vi oprette en ansøgning.yml med en konfigureret Forår applikationsnavn for entydigt at identificere vores klient på listen over registrerede applikationer.

Vi kan lade Spring Boot vælg en tilfældig port for os, fordi vi senere får adgang til denne tjeneste med dens navn.

Endelig er vi nødt til at fortælle vores klient, hvor den skal finde registreringsdatabasen:

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

Da vi besluttede at oprette vores Eureka-klient på denne måde, havde vi i tankerne, at denne form for service senere skulle være let skalerbar.

Nu kører vi klienten og peger vores browser på // localhost: 8761 igen for at se dets registreringsstatus på Eureka Dashboard. Ved at bruge Dashboard kan vi foretage yderligere konfiguration, f.eks. link startsiden for en registreret klient med Dashboardet til administrative formål. Konfigurationsmulighederne ligger dog uden for denne artikels anvendelsesområde.

4. Feign-klient

For at færdiggøre vores projekt med tre afhængige mikrotjenester, implementerer vi nu en HVILE-forbruger webapplikation ved hjælp af Forår Netflix Feign-klient.

Tænke på Feign som opdagelsesbevidst ForårRestTemplate ved hjælp af grænseflader til at kommunikere med slutpunkter. Disse grænseflader implementeres automatisk ved kørsel og i stedet for service-webadresser, det bruger service-navne.

Uden Feign vi bliver nødt til at tråde en instans af EurekaClient ind i vores controller, som vi kunne modtage en serviceinformation af service-navn som en Ansøgning objekt.

Vi ville bruge dette Ansøgning for at få en liste over alle forekomster af denne service skal du vælge en passende og bruge denne InstanceInfo for at få værtsnavn og port. Med dette kunne vi gøre en standardanmodning med enhver http-klient.

For eksempel:

@Autowired privat EurekaClient eurekaClient; offentlig ugyldig doRequest () {Application application = eurekaClient.getApplication ("spring-cloud-eureka-client"); InstanceInfo instanceInfo = application.getInstances (). Get (0); Strengværtsnavn = instansInfo.getHostnavn (); int port = instansInfo.getPort (); // ...}

EN RestTemplate kan også bruges til at få adgang Eureka klienttjenester ved navn, men dette emne ligger uden for denne opskrivning.

At oprette vores Feign-klient projekt, vil vi tilføje følgende fire afhængigheder til dets pom.xml:

 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 

Det Feign-klient er placeret i spring-cloud-starter-feign pakke. For at aktivere det skal vi kommentere en @Konfiguration med @EnableFeignClients. For at bruge det annoterer vi simpelthen en grænseflade med @FeignClient (“service-name”) og tråd den automatisk ind i en controller.

En god metode til at skabe sådan FeignKunder er at oprette grænseflader med @RequestMapping annoterede metoder og sætte dem i et separat modul. På denne måde kan de deles mellem server og klient. På serversiden kan du implementere dem som @Kontrolog på klientsiden kan de udvides og kommenteres som @FeignClient.

Desuden er den spring-cloud-starter-eureka-pakke skal inkluderes i projektet og aktiveres ved at kommentere hovedapplikationsklassen med @EnableEurekaClient.

Det spring-boot-starter-web og spring-boot-starter-thymeleaf afhængigheder bruges til at præsentere en visning, der indeholder hentede data fra vores HVILE service.

Dette vil være vores Feign-klient grænseflade:

@FeignClient ("spring-cloud-eureka-client") offentlig grænseflade GreetingClient {@RequestMapping ("/ greeting") Strenghilsen (); }

Her implementerer vi hovedapplikationsklassen, som samtidig fungerer som en controller:

@SpringBootApplication @EnableFeignClients @Controller offentlig klasse FeignClientApplication {@Autowired private GreetingClient greetingClient; public static void main (String [] args) {SpringApplication.run (FeignClientApplication.class, args); } @RequestMapping ("/ get-greeting") offentlig strenghilsen (modelmodel) {model.addAttribute ("hilsen", greetingClient.greeting ()); returner "hilsen-visning"; }} 

Dette vil være HTML-skabelonen til vores opfattelse:

   Hilsen side 

I det mindste ansøgning.yml konfigurationsfil er næsten den samme som i det foregående trin:

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

Nu kan vi opbygge og køre denne service. Endelig vil vi pege vores browser på // localhost: 8080 / get-greeting og det skal vise noget som følgende:

Hej fra SPRING-CLOUD-EUREKA-CLIENT!

5. ‘Transportundtagelse: Kan ikke udføre anmodning på nogen kendt server '

Mens vi kører Eureka-server, løber vi ofte ind i undtagelser som:

com.netflix.discovery.shared.transport.TransportException: Kan ikke udføre anmodning på nogen kendt server

Dybest set sker dette på grund af den forkerte konfiguration i application.properties eller ansøgning.yml. Eureka giver to egenskaber til klienten, der kan konfigureres.

  • registerWithEureka: Hvis vi laver denne ejendom som rigtigt så mens serveren starter, vil den indbyggede klient prøve at registrere sig selv på Eureka-serveren.
  • hente Registrering: Den indbyggede klient vil prøve at hente Eureka registreringsdatabase, hvis vi konfigurerer denne egenskab som sand.

Nu når vi starter Eureka-serveren, vil vi ikke registrere den indbyggede klient for at konfigurere sig selv med serveren.

Hvis vi markerer ovenstående egenskaber som rigtigt (eller konfigurer dem ikke, som de er rigtigt som standard), mens den starter serveren, prøver den indbyggede klient at registrere sig selv hos Eureka server og forsøger også at hente registreringsdatabasen, som endnu ikke er tilgængelig. Som et resultat får vi Transportundtagelse.

Så vi bør aldrig konfigurere disse egenskaber som rigtigt i Eureka serverapplikationer. De korrekte indstillinger, der skal sættes i ansøgning.yml er angivet nedenfor:

eureka: client: registerWithEureka: false fetchRegistry: false

6. Konklusion

Som vi har set, er vi nu i stand til at implementere en service-registreringsdatabase ved hjælp af Forår Netflix Eureka Server og registrer nogle Eureka-klienter med det.

Fordi vores Eureka-klient fra trin 3 lytter til en tilfældigt valgt port, kender den ikke dens placering uden oplysningerne fra registreringsdatabasen. Med en Feign-klient og vores register, kan vi finde og forbruge HVILE service, selv når placeringen ændres.

Endelig har vi et stort billede af brug af serviceopdagelse i en mikroservicearkitektur.

Som normalt finder du kilderne på GitHub, som også inkluderer et sæt Docker-relaterede filer til brug med docker-komponere at skabe containere fra vores projekt.