Introduksjon til Spring Cloud Netflix - Eureka

1. Oversikt

I denne opplæringen vil vi introdusere tjenesten på klientsiden funn via “Spring Cloud Netflix Eureka“.

Tjenesteoppdagelse på klientsiden tillater tjenester å finne og kommunisere med hverandre uten hardkodende vertsnavn og port. Det eneste 'faste punktet' i en slik arkitektur består av en service register som hver tjeneste må registrere seg med.

En ulempe er at alle klienter må implementere en viss logikk for å samhandle med dette faste punktet. Dette forutsetter en ekstra nettverksrundtur før selve forespørselen.

Med Netflix Eureka kan hver klient samtidig fungere som en server for å replikere statusen til en tilkoblet peer. Med andre ord, en klient henter en liste over alle tilkoblede jevnaldrende til a service register og gjør alle ytterligere forespørsler til andre tjenester gjennom en lastbalanseringsalgoritme.

For å bli informert om tilstedeværelsen til en klient, må de sende et hjerterytmesignal til registret.

For å nå målet med denne oppskriften, implementerer vi tre mikrotjenester:

  • en service register (Eureka Server),
  • en HVILE tjeneste som registrerer seg selv i registret (Eureka-klient) og
  • en webapplikasjon som bruker HVILE tjenesten som en registerbevisst klient (Spring Cloud Netflix Feign-klient).

2. Eureka Server

Implementering a Eureka Server for service register er like enkelt som:

  1. legge til spring-cloud-starter-netflix-eureka-server til avhengighetene
  2. aktivere Eureka Server i en @SpringBootApplication ved å kommentere den med @EnableEurekaServer
  3. konfigurere noen egenskaper

Men vi gjør det trinn for trinn.

For det første oppretter vi et nytt Maven-prosjekt og legger avhengighetene i det. Du må legge merke til at vi importerer vår-sky-start-foreldre til alle prosjekter beskrevet i denne veiledningen:

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

Merk: vi kan sjekke de siste Spring Cloud-utgivelsene i vårens prosjektdokumentasjon.

Deretter lager vi hovedapplikasjonsklassen:

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

Til slutt konfigurerer vi egenskapene i YAML format; så en application.yml vil være vår konfigurasjonsfil:

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

Her konfigurerer vi en applikasjonsport - 8761 er standard for Eureka servere. Vi forteller den innebygde Eureka-klient ikke å registrere seg med ‘seg selv’ fordi søknaden vår skal fungere som en server.

Nå peker vi nettleseren vår til // localhost: 8761 for å se Eureka dashbord, der vi senere vil inspisere de registrerte forekomster.

For øyeblikket ser vi grunnleggende indikatorer som status- og helseindikatorer.

3. Eureka-klient

For en @SpringBootApplication for å være oppdagelsesbevisste, må vi ta med noen Spring Discovery Client (for eksempel vår-sky-start-netflix-eureka-klient) inn i vår klassesti.

Da må vi kommentere a @Konfigurasjon med enten @EnableDiscoveryClient eller @EnableEurekaClient - Vær oppmerksom på at denne merknaden er valgfri hvis vi har vår-sky-start-netflix-eureka-klient avhengighet av klassestien.

Sistnevnte forteller Vårstøvel å bruke Spring Netflix Eureka for å oppdage tjenester eksplisitt. For å fylle kundesøknaden vår med noen prøvetider, inkluderer vi også spring-boot-starter-web pakken i pom.xml og implementere en HVILE kontrolleren.

Men først legger vi til avhengighetene. Igjen kan vi overlate det til vår-sky-start-foreldre avhengighet for å finne ut gjenstandsversjonene for oss:

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

Her vil vi implementere hovedapplikasjonsklassen:

@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 ("Hei fra '% s'!", EurekaClient.getApplication (appName) .getName ()); }}

Og HilsenKontroller grensesnitt:

offentlig grensesnitt GreetingController {@RequestMapping ("/ greeting") String greeting (); }

Her, i stedet for grensesnittet, kunne vi også bare erklære kartleggingen inne i EurekaClientApplication klasse. Grensesnittet kan være nyttig hvis vi vil dele det mellom server og klient.

Deretter må vi sette opp en application.yml med en konfigurert Vår applikasjonsnavn for å identifisere vår klient unikt i listen over registrerte applikasjoner.

Vi kan la Vårstøvel velg en tilfeldig port for oss fordi vi senere får tilgang til denne tjenesten med navnet.

Til slutt må vi fortelle klienten hvor den må finne registeret:

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

Da vi bestemte oss for å sette opp Eureka-klienten på denne måten, hadde vi i tankene at denne typen tjenester senere skulle være lett skalerbare.

Nå skal vi kjøre klienten og peke nettleseren mot // lokal vert: 8761 igjen, for å se registreringsstatusen på Eureka Dashboard. Ved å bruke dashbordet kan vi gjøre ytterligere konfigurasjon f.eks. koble hjemmesiden til en registrert klient med dashbordet for administrative formål. Konfigurasjonsalternativene ligger imidlertid utenfor omfanget av denne artikkelen.

4. Feign-klient

For å fullføre prosjektet vårt med tre avhengige mikrotjenester, vil vi nå implementere en HVILE-forbruker webapplikasjon ved hjelp av Våren Netflix Feign-klient.

Tenker på Late som som oppdagelsesbevisst VårRestTemplate bruker grensesnitt for å kommunisere med sluttpunkter. Disse grensesnittene implementeres automatisk ved kjøretid og i stedet for tjeneste-nettadresser, den bruker tjenestenavn.

Uten Late som vi må autowire en forekomst av EurekaClient inn i vår kontroller som vi kunne motta en tjenesteinformasjon av tjenestenavn som en applikasjon gjenstand.

Vi vil bruke dette applikasjon for å få en liste over alle forekomster av denne tjenesten, velg en passende og bruk denne InstanceInfo for å få vertsnavn og port. Med dette kan vi gjøre en standard forespørsel med hvilken som helst http-klient.

For eksempel:

@Autowired private EurekaClient eurekaClient; public void doRequest () {Application application = eurekaClient.getApplication ("spring-cloud-eureka-client"); InstanceInfo instanceInfo = application.getInstances (). Get (0); String vertsnavn = instansInfo.getHostnavn (); int port = instansInfo.getPort (); // ...}

EN RestTemplate kan også brukes til å få tilgang til Eureka klienttjenester etter navn, men dette emnet er utenfor denne oppskriften.

Å sette opp vår Feign-klient prosjekt, skal vi legge til følgende fire avhengigheter til det 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 

De Feign-klient ligger i vår-sky-start-feign pakke. For å aktivere det, må vi kommentere a @Konfigurasjon med @EnableFeignClients. For å bruke den, kommenterer vi bare et grensesnitt med @FeignClient (“service-name”) og koble den automatisk til en kontroller.

En god metode for å lage slike Late somKunder er å lage grensesnitt med @RequestMapping merkede metoder og satte dem i en egen modul. På denne måten kan de deles mellom server og klient. På serversiden kan du implementere dem som @Kontrollørog på klientsiden kan de utvides og kommenteres som @FeignClient.

Videre er den vår-sky-start-eureka-pakke må inkluderes i prosjektet og aktiveres ved å kommentere hovedapplikasjonsklassen med @EnableEurekaClient.

De spring-boot-starter-web og spring-boot-starter-thymeleaf avhengigheter brukes til å presentere en visning som inneholder hentede data fra vår HVILE service.

Dette blir vårt Feign-klient grensesnitt:

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

Her vil vi implementere hovedapplikasjonsklassen som samtidig fungerer som en kontroller:

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

Dette vil være HTML-malen for vårt syn:

   Hilsen side 

I det minste application.yml konfigurasjonsfilen er nesten den samme som i forrige trinn:

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

Nå kan vi bygge og kjøre denne tjenesten. Til slutt vil vi peke nettleseren vår mot // localhost: 8080 / hilsen og det skal vise noe sånt som følgende:

Hei fra SPRING-CLOUD-EUREKA-CLIENT!

5. ‘Transport unntak: Kan ikke utføre forespørsel på noen kjent server '

Mens vi kjører Eureka-server, støter vi ofte på unntak som:

com.netflix.discovery.shared.transport.TransportException: Kan ikke utføre forespørsel på noen kjent server

I utgangspunktet skjer dette på grunn av feil konfigurasjon i application.properties eller application.yml. Eureka gir to egenskaper for klienten som kan konfigureres.

  • registerWithEureka: Hvis vi lager denne eiendommen som ekte så mens serveren starter, vil den innebygde klienten prøve å registrere seg hos Eureka-serveren.
  • fetchRegistry: Den innebygde klienten vil prøve å hente Eureka registeret hvis vi konfigurerer denne egenskapen som sant.

når vi starter Eureka-serveren, vil vi ikke registrere den innebygde klienten for å konfigurere seg selv med serveren.

Hvis vi merker ovennevnte egenskaper som ekte (eller ikke konfigurer dem slik de er ekte som standard) mens den starter serveren, prøver den innebygde klienten å registrere seg hos Eureka server og prøver også å hente register som ennå ikke er tilgjengelig. Som et resultat får vi Transport unntak.

Så vi skal aldri konfigurere disse egenskapene som ekte i Eureka serverapplikasjoner. De riktige innstillingene som skal legges inn application.yml er gitt nedenfor:

eureka: client: registerWithEureka: false fetchRegistry: false

6. Konklusjon

Som vi har sett, er vi nå i stand til å implementere et tjeneregister ved hjelp av Våren Netflix Eureka Server og registrer noen Eureka-klienter med det.

Fordi vår Eureka-klient fra trinn 3 lytter på en tilfeldig valgt port, vet den ikke plasseringen uten informasjonen fra registeret. Med en Feign-klient og vårt register, kan vi finne og konsumere HVILE tjeneste, selv når stedet endres.

Til slutt har vi et stort bilde av bruk av tjenesteoppdagelse i en mikroservicearkitektur.

Som vanlig finner du kildene på GitHub, som også inkluderer et sett med Docker-relaterte filer for bruk med docker-compose å lage containere fra prosjektet vårt.


$config[zx-auto] not found$config[zx-overlay] not found