streamalism.org

1. Overzicht

In deze tutorial introduceren we service aan de klant ontdekking via 'Spring Cloud Netflix Eureka“.

Service-detectie aan de clientzijde stelt services in staat elkaar te vinden en met elkaar te communiceren zonder de hostnaam en poort hard te coderen. Het enige ‘vaste punt 'in zo'n architectuur bestaat uit een service register waarbij elke dienst zich moet registreren.

Een nadeel is dat alle klanten een bepaalde logica moeten implementeren om met dit vaste punt te communiceren. Dit veronderstelt een extra netwerkronde-trip vóór het daadwerkelijke verzoek.

Met Netflix Eureka kan elke client tegelijkertijd als server fungeren om zijn status naar een aangesloten peer te repliceren. Met andere woorden, een client haalt een lijst op van alle verbonden peers van een service register en doet alle verdere verzoeken aan andere services via een load-balancing-algoritme.

Om geïnformeerd te worden over de aanwezigheid van een klant, moeten ze een hartslagsignaal naar de registry sturen.

Om het doel van dit artikel te bereiken, zullen we er drie implementeren microservices:

• een service register (Eureka-server),
• een RUST UIT service die zichzelf registreert bij het register (Eureka-klant) en
• een webtoepassing die de RUST UIT service als een registerbewuste client (Spring Cloud Netflix Doe alsof cliënt).

2. Eureka-server

Implementeren van een Eureka-server voor serviceregistratie is net zo eenvoudig als:

1. toevoegen spring-cloud-starter-netflix-eureka-server naar de afhankelijkheden
2. schakel de Eureka-server in een @SpringBootApplication door het te annoteren met @EnableEurekaServer
3. configureer enkele eigenschappen

Maar we zullen het stap voor stap doen.

Eerst maken we een nieuw Maven-project en plaatsen we de afhankelijkheden erin. U moet opmerken dat we het spring-cloud-starter-parent voor alle projecten die in deze tutorial worden beschreven:

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

Opmerking: we kunnen de nieuwste Spring Cloud-releases bekijken in de documentatie van Spring's Projects.

Vervolgens maken we de hoofdtoepassingsklasse:

@SpringBootApplication @EnableEurekaServer openbare klasse EurekaServerApplication {openbare statische leegte hoofd (String [] args) {SpringApplication.run (EurekaServerApplication.class, args); }}

Ten slotte configureren we de eigenschappen in YAML formaat; dus een application.yml wordt ons configuratiebestand:

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

Hier configureren we een applicatiepoort - 8761 is de standaardinstelling voor Eureka servers. We vertellen het ingebouwde Eureka-klant niet te registreren bij 'zichzelf' omdat onze applicatie als een server zou moeten werken.

Nu zullen we onze browser naar // localhost: 8761 wijzen om het Eureka dashboard, waar we later de geregistreerde exemplaren zullen inspecteren.

Op dit moment zien we basisindicatoren zoals status- en gezondheidsindicatoren.

3. Eureka-klant

Voor een @SpringBootApplication om ontdekkingsbewust te zijn, moeten we er enkele opnemen Spring Discovery-client (bijvoorbeeld spring-cloud-starter-netflix-eureka-client) in onze klassenpad.

Dan moeten we een @Configuratie met een van beide @EnableDiscoveryClient of @EnableEurekaClient - merk op dat deze annotatie optioneel is als we de spring-cloud-starter-netflix-eureka-client afhankelijkheid van het klassenpad.

De laatste vertelt Spring Boot om Spring Netflix Eureka expliciet te gebruiken voor het zoeken naar services. Om onze clienttoepassing te vullen met een beetje levensduur, zullen we ook de spring-boot-starter-web pakket in de pom.xml en implementeer een RUST UIT controller.

Maar eerst voegen we de afhankelijkheden toe. Nogmaals, we kunnen het overlaten aan de spring-cloud-starter-parent afhankelijkheid om de artefactversies voor ons te achterhalen:

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

Hier zullen we de hoofdtoepassingsklasse implementeren:

@SpringBootApplication @RestController openbare klasse EurekaClientApplication implementeert GreetingController {@Autowired @Lazy privé EurekaClient eurekaClient; @Value ("$ {spring.application.name}") private String appName; openbare statische leegte hoofd (String [] args) {SpringApplication.run (EurekaClientApplication.class, args); } @Override public String-begroeting () {return String.format ("Hallo van '% s'!", EurekaClient.getApplication (appName) .getName ()); }}

En de Groetcontroller koppel:

openbare interface GreetingController {@RequestMapping ("/ greeting") String-begroeting (); }

Hier kunnen we in plaats van de interface ook eenvoudig de toewijzing binnen het EurekaClientApplication klasse. De interface kan handig zijn als we deze willen delen tussen server en client.

Vervolgens moeten we een application.yml met een geconfigureerd Voorjaar applicatienaam om onze klant uniek te identificeren in de lijst met geregistreerde applicaties.

We kunnen laten Spring Boot kies een willekeurige poort voor ons omdat we later toegang krijgen tot deze service met zijn naam.

Ten slotte moeten we onze klant vertellen waar hij het register moet vinden:

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

Toen we besloten om onze Eureka Client op deze manier in te richten, hadden we in gedachten dat dit soort service later gemakkelijk schaalbaar moest zijn.

Nu zullen we de client starten en onze browser naar // localhost: 8761 nogmaals, om de registratiestatus op het Eureka Dashboard te zien. Door het Dashboard te gebruiken, kunnen we verdere configuratie doen, b.v. link de homepage van een geregistreerde klant met het Dashboard voor administratieve doeleinden. De configuratie-opties vallen echter buiten het bestek van dit artikel.

4. Doe alsof je klant bent

Om ons project met drie afhankelijke microservices af te ronden, zullen we nu een RUST UIT-consumerende webapplicatie met Spring Netflix Feign-client.

Denken aan Veinzen als ontdekkingsbewust VoorjaarRestTemplate interfaces gebruiken om met eindpunten te communiceren. Deze interfaces worden automatisch geïmplementeerd tijdens runtime en in plaats van service-URL's, het gebruikt servicenamen.

Zonder Veinzen we zouden een exemplaar van EurekaClient in onze controller waarmee we een service-informatie zouden kunnen ontvangen door servicenaam als een Toepassing voorwerp.

We zouden dit gebruiken Toepassing om een ​​lijst te krijgen van alle instanties van deze service, kiest u een geschikte en gebruikt u deze InstanceInfo om hostnaam en poort te krijgen. Hiermee kunnen we een standaardverzoek doen met elk http-client.

Bijvoorbeeld:

@Autowired privé EurekaClient eurekaClient; public void doRequest () {Applicatie-applicatie = eurekaClient.getApplication ("spring-cloud-eureka-client"); InstanceInfo instanceInfo = application.getInstances (). Get (0); String hostnaam = instanceInfo.getHostName (); int port = instanceInfo.getPort (); // ...}

EEN RestTemplate kan ook worden gebruikt om toegang te krijgen Eureka client-services op naam, maar dit onderwerp valt buiten dit artikel.

Om onze Doe alsof cliënt project, gaan we de volgende vier afhankelijkheden aan zijn 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 Doe alsof cliënt bevindt zich in de spring-cloud-starter-veinzen pakket. Om het in te schakelen, moeten we een @Configuratie met @EnableFeignClients. Om het te gebruiken, annoteren we eenvoudig een interface met @FeignClient ("servicenaam") en automatisch bedraden in een controller.

Een goede methode om zoiets te creëren VeinzenCliënten is om interfaces te maken met @RequestMapping geannoteerde methoden en zet ze in een aparte module. Op deze manier kunnen ze worden gedeeld tussen server en client. Aan serverzijde kunt u ze implementeren als @Controller, en aan clientzijde kunnen ze worden uitgebreid en geannoteerd als @Feyenoord.

Bovendien is de spring-cloud-starter-eureka-pakket moet in het project worden opgenomen en ingeschakeld door de hoofdtoepassingsklasse te annoteren met @EnableEurekaClient.

De spring-boot-starter-web en spring-boot-starter-thymeleaf afhankelijkheden worden gebruikt om een ​​weergave te presenteren, met daarin opgehaalde gegevens van onze RUST UIT onderhoud.

Dit wordt onze Doe alsof cliënt koppel:

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

Hier zullen we de hoofdtoepassingsklasse implementeren die tegelijkertijd als controller fungeert:

@SpringBootApplication @EnableFeignClients @Controller openbare klasse FeignClientApplication {@Autowired privé GreetingClient greetingClient; openbare statische leegte hoofd (String [] args) {SpringApplication.run (FeignClientApplication.class, args); } @RequestMapping ("/ get-greeting") openbare String-begroeting (modelmodel) {model.addAttribute ("groet", greetingClient.greeting ()); retourneer "begroetingsweergave"; }} 

Dit wordt de HTML-sjabloon voor onze weergave:

   Groet pagina 

Tenminste de application.yml configuratiebestand is bijna hetzelfde als in de vorige stap:

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

Nu kunnen we deze service bouwen en uitvoeren. Ten slotte zullen we onze browser naar // localhost: 8080 / get-groet en het zou iets als het volgende moeten weergeven:

Hallo van SPRING-CLOUD-EUREKA-CLIENT!

5. ‘Transportuitzondering: Kan verzoek niet uitvoeren op een bekende server '

Tijdens het draaien van de Eureka-server komen we vaak uitzonderingen tegen, zoals:

com.netflix.discovery.shared.transport.TransportException: kan verzoek niet uitvoeren op een bekende server

In principe gebeurt dit vanwege de verkeerde configuratie in application.properties of application.yml. Eureka biedt twee eigenschappen voor de klant die kunnen worden geconfigureerd.

• registerMetEureka: Als we deze woning zo maken waar terwijl de server start, zal de ingebouwde client proberen zichzelf te registreren bij de Eureka-server.
• fetchRegistry: De ingebouwde client zal proberen het Eureka registry als we deze eigenschap configureren als true.

Nu wanneer we de Eureka-server opstarten, willen we de ingebouwde client niet registreren om zichzelf met de server te configureren.

Als we de bovenstaande eigenschappen markeren als waar (of configureer ze niet zoals ze zijn waar standaard) tijdens het starten van de server, probeert de ingebouwde client zichzelf te registreren met de Eureka server en probeert ook een register op te halen dat nog niet beschikbaar is. Als resultaat krijgen we TransportException.

We moeten deze eigenschappen dus nooit configureren als waar in de Eureka servertoepassingen. De juiste instellingen die moeten worden ingevoerd application.yml worden hieronder gegeven:

eureka: client: registerWithEureka: false fetchRegistry: false

6. Conclusie

Zoals we hebben gezien, kunnen we nu een serviceregister implementeren met Lente Netflix Eureka-server en registreer wat Eureka-klanten ermee.

Omdat onze Eureka-klant vanaf stap 3 luistert op een willekeurig gekozen poort, het weet de locatie niet zonder de informatie van het register. Met een Doe alsof cliënt en ons register kunnen we het RUST UIT service, zelfs als de locatie verandert.

Ten slotte hebben we een goed beeld van het gebruik van service-detectie in een microservicearchitectuur.

Zoals gewoonlijk vind je de bronnen op GitHub, die ook een set van Docker-gerelateerde bestanden voor gebruik met docker-compose om containers van ons project te maken.