Spring Cloud - Bootstrapping

1. Overzicht

Spring Cloud is een raamwerk voor het bouwen van robuuste cloudapplicaties. Het framework vergemakkelijkt de ontwikkeling van applicaties door oplossingen te bieden voor veel van de veelvoorkomende problemen bij het verhuizen naar een gedistribueerde omgeving.

Toepassingen die worden uitgevoerd met een microservices-architectuur zijn bedoeld om ontwikkeling, implementatie en onderhoud te vereenvoudigen. Door de ontbonden aard van de applicatie kunnen ontwikkelaars zich op één probleem tegelijk concentreren. Verbeteringen kunnen worden aangebracht zonder dat dit gevolgen heeft voor andere delen van een systeem.

Aan de andere kant doen zich verschillende uitdagingen voor wanneer we een microservice-aanpak volgen:

Externaliserende configuratie zodat deze flexibel is en bij verandering de service niet opnieuw hoeft te worden opgebouwd
Service-detectie
De complexiteit van services die op verschillende hosts worden geïmplementeerd, verbergen

In dit artikel gaan we vijf microservices bouwen: een configuratieserver, een detectieserver, een gatewayserver, een boekenservice en tot slot een beoordelingsservice. Deze vijf microservices vormen een solide basistoepassing om met cloudontwikkeling te beginnen en de bovengenoemde uitdagingen aan te pakken.

2. Configuratieserver

Een probleem bij het ontwikkelen van een cloudapplicatie is het onderhouden en distribueren van de configuratie naar onze services. We willen echt geen tijd besteden aan het configureren van elke omgeving voordat we onze service horizontaal schalen, of we riskeren inbreuk op de beveiliging door onze configuratie in onze applicatie te verwerken.

Om dit op te lossen, zullen we al onze configuratie consolideren in een enkele Git-repository en die verbinden met één applicatie die een configuratie beheert voor al onze applicaties. We gaan een heel eenvoudige implementatie opzetten.

Bekijk ons Spring Cloud Configuration-artikel voor meer informatie en een complexer voorbeeld.

2.1. Opstelling

Navigeren naar //start.spring.io en selecteer Maven en Spring Boot 2.2.x.

Stel het artefact in op “config“. Zoek in het gedeelte afhankelijkheden naar "configuratieserver" en voeg die module toe. Druk vervolgens op de genereren knop en we kunnen een zip-bestand downloaden met een voorgeconfigureerd project erin en klaar voor gebruik.

Als alternatief kunnen we een Spring Boot project en voeg handmatig enkele afhankelijkheden toe aan het POM-bestand.

Deze afhankelijkheden worden gedeeld tussen alle projecten:

 org.springframework.boot spring-boot-starter-parent 2.2.6.RELEASE org.springframework.boot spring-boot-starter-test org.springframework.cloud spring-cloud-afhankelijkheden Hoxton.SR4 pom import org.springframework.boot spring-boot-maven-plugin

Laten we een afhankelijkheid toevoegen voor de configuratieserver:

 org.springframework.cloud spring-cloud-config-server

Ter referentie kunnen we de nieuwste versie vinden op Maven Central (spring-cloud-afhankelijkheden, test, config-server).

2.2. Spring Config

Om de configuratieserver in te schakelen, moeten we enkele annotaties toevoegen aan de hoofdtoepassingsklasse:

@SpringBootApplication @EnableConfigServer openbare klasse ConfigApplication {...}

@EnableConfigServer verandert onze applicatie in een configuratieserver.

2.3. Eigendommen

Laten we de application.properties in src / main / resources:

server.port = 8081 spring.application.name = config spring.cloud.config.server.git.uri = file: // $ {user.home} / application-config

De belangrijkste instelling voor de configuratieserver is de git.uri parameter. Dit is momenteel ingesteld op een relatief bestandspad dat doorgaans wordt omgezet in c: \ Users \ {gebruikersnaam} \ op Windows of / Users / {gebruikersnaam} / op * nix. Deze eigenschap verwijst naar een Git-repository waar de eigenschappenbestanden voor alle andere applicaties zijn opgeslagen. Het kan indien nodig worden ingesteld op een absoluut bestandspad.

Tip: Op een Windows-machine laat u de waarde voorafgaan door “file: ///”, op * nix gebruik dan “file: //”.

2.4. Git-opslagplaats

Navigeer naar de map die is gedefinieerd door spring.cloud.config.server.git.uri en voeg de map toe application-config. CD in die map en typ git init. Dit zal een Git-repository initialiseren waar we bestanden kunnen opslaan en hun wijzigingen kunnen volgen.

2.5. Rennen

Laten we de configuratieserver starten en controleren of deze werkt. Typ vanaf de opdrachtregel mvn spring-boot: run. Dit zal de server starten.

We zouden deze uitvoer moeten zien die aangeeft dat de server actief is:

Tomcat is gestart op poort (en): 8081 (http)

2.6. Bootstrapping-configuratie

Op onze volgende servers willen we dat hun applicatie-eigenschappen door deze configuratieserver worden beheerd. Om dat te doen, moeten we eigenlijk een beetje kip-en-ei doen: Configureer eigenschappen in elke applicatie die weten hoe ze terug moeten praten met deze server.

Het is een bootstrap-proces, en elk van deze apps krijgt een bestand met de naam bootstrap.properties. Het bevat eigenschappen zoals application.properties maar met een twist:

Een bovenliggende lente ApplicationContext laadt het bootstrap.properties eerste. Dit is van cruciaal belang zodat Config Server kan beginnen met het beheren van de eigenschappen in application.properties. Het is zo speciaal ApplicationContext waarmee ook alle versleutelde applicatie-eigenschappen worden gedecodeerd.

Het is slim om deze eigenschappenbestanden verschillend te houden.bootstrap.properties is om de configuratieserver gereed te maken, en application.properties is voor eigenschappen die specifiek zijn voor onze toepassing. Technisch gezien is het echter mogelijk om applicatie-eigenschappen in bootstrap.properties.

Ten slotte, aangezien Config Server onze applicatie-eigenschappen beheert, kan men zich afvragen waarom een application.properties helemaal? Het antwoord is dat deze nog steeds van pas komen als standaardwaarden die Config Server misschien niet heeft.

3. Ontdekking

Nu we de configuratie hebben geregeld, hebben we een manier nodig waarop al onze servers elkaar kunnen vinden. We lossen dit probleem op door de Eureka discovery server up. Omdat onze applicaties op elke ip / poort-combinatie kunnen draaien, hebben we een centraal adresregister nodig dat kan dienen als het opzoeken van het applicatieadres.

Wanneer een nieuwe server wordt ingericht, communiceert deze met de detectieserver en registreert het zijn adres zodat anderen ermee kunnen communiceren. Op deze manier kunnen andere applicaties deze informatie gebruiken terwijl ze verzoeken doen.

Bekijk het Spring Cloud Eureka-artikel voor meer informatie en om een meer complexe discovery-implementatie te zien.

3.1. Opstelling

We gaan opnieuw naar start.spring.io. Stel het artefact in op "ontdekken". Zoek naar "eureka-server" en voeg die afhankelijkheid toe. Zoek naar "config client" en voeg die afhankelijkheid toe. Genereer ten slotte het project.

Als alternatief kunnen we een Spring Boot project, kopieer dan de inhoud van het POM van de configuratieserver en wissel deze afhankelijkheden in:

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

Ter referentie vinden we de bundels op Maven Central (config-client, eureka-server).

3.2. Spring Config

Laten we Java-configuratie toevoegen aan de hoofdklasse:

@SpringBootApplication @EnableEurekaServer openbare klasse DiscoveryApplication {...}

@EnableEurekaServer configureert deze server als een detectieserver met behulp van Netflix Eureka. Spring Boot zal automatisch de afhankelijkheid van de configuratie op het klassenpad detecteren en de configuratie opzoeken op de configuratieserver.

3.3. Eigendommen

Nu zullen we twee eigenschappenbestanden toevoegen:

Ten eerste voegen we toe bootstrap.properties in src / main / resources:

spring.cloud.config.name = ontdekking spring.cloud.config.uri = // localhost: 8081

Met deze eigenschappen kan de detectieserver de configuratieserver opvragen bij het opstarten.

En ten tweede voegen we toe discovery.properties naar onze Git-opslagplaats

spring.application.name = discovery server.port = 8082 eureka.instance.hostname = localhost eureka.client.serviceUrl.defaultZone = // localhost: 8082 / eureka / eureka.client.register-with-eureka = false eureka.client. fetch-registry = false

De bestandsnaam moet overeenkomen met de spring.application.name eigendom.

Bovendien vertellen we deze server dat deze in de standaardzone werkt, dit komt overeen met de regio-instelling van de configuratieclient. We vertellen de server ook dat hij zich niet moet registreren bij een ander detectie-exemplaar.

In productie zouden we er meer dan één hebben om redundantie te bieden in geval van storing en die instelling zou waar zijn.

Laten we het bestand vastleggen in de Git-repository. Anders wordt het bestand niet gedetecteerd.

3.4. Voeg afhankelijkheid toe aan de configuratieserver

Voeg deze afhankelijkheid toe aan het POM-bestand van de configuratieserver:

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

Ter referentie kunnen we de bundel vinden op Maven Central (eureka-klant).

Voeg deze eigenschappen toe aan het application.properties bestand in src / main / resources van de configuratieserver:

eureka.client.region = standaard eureka.client.registryFetchIntervalSeconds = 5 eureka.client.serviceUrl.defaultZone = // localhost: 8082 / eureka /

3.5. Rennen

Start de detectieserver met dezelfde opdracht, mvn spring-boot: run. De uitvoer van de opdrachtregel moet het volgende bevatten:

Configuratie ophalen van server op: // localhost: 8081 ... Tomcat is gestart op poort (en): 8082 (http)

Stop en voer de configuratieservice opnieuw uit. Als alles goed is, zou de output er als volgt uit moeten zien:

DiscoveryClient_CONFIG / 10.1.10.235: config: 8081: service registreren ... Tomcat gestart op poort (en): 8081 (http) DiscoveryClient_CONFIG / 10.1.10.235: config: 8081 - registratiestatus: 204

4. Gateway

Nu we onze configuratie- en detectieproblemen hebben opgelost, hebben we nog steeds een probleem met clients die toegang hebben tot al onze applicaties.

Als we alles in een gedistribueerd systeem achterlaten, zullen we complexe CORS-headers moeten beheren om cross-origin-verzoeken op clients mogelijk te maken. We kunnen dit oplossen door een gateway-server te maken. Dit fungeert als een omgekeerde proxy-shuttling-verzoeken van klanten naar onze back-endservers.

Een gateway-server is een uitstekende toepassing in de microservicearchitectuur omdat alle reacties afkomstig kunnen zijn van een enkele host. Dit maakt CORS overbodig en geeft ons een handige plek om veelvoorkomende problemen zoals authenticatie op te lossen.

4.1. Opstelling

Inmiddels kennen we de oefening. Navigeren naar //start.spring.io. Stel het artefact in op "gateway". Zoek naar "zuul" en voeg die afhankelijkheid toe. Zoek naar "config client" en voeg die afhankelijkheid toe. Zoek naar "eureka discovery" en voeg die afhankelijkheid toe. Genereer ten slotte dat project.

Als alternatief kunnen we een Spring Boot app met deze afhankelijkheden:

 org.springframework.cloud spring-cloud-starter-config org.springframework.cloud spring-cloud-starter-eureka org.springframework.cloud spring-cloud-starter-zuul

Ter referentie kunnen we de bundel vinden op Maven Central (config-client, eureka-client, zuul).

4.2. Spring Config

Laten we de configuratie toevoegen aan de hoofdklasse:

@SpringBootApplication @EnableZuulProxy @EnableEurekaClient openbare klasse GatewayApplication {...}

4.3. Eigendommen

Nu zullen we twee eigenschappenbestanden toevoegen:

bootstrap.properties in src / main / resources:

spring.cloud.config.name = gateway spring.cloud.config.discovery.service-id = config spring.cloud.config.discovery.enabled = true eureka.client.serviceUrl.defaultZone = // localhost: 8082 / eureka /

gateway.properties in onze Git-opslagplaats

spring.application.name = gateway server.port = 8080 eureka.client.region = standaard eureka.client.registryFetchIntervalSeconds = 5 zuul.routes.book-service.path = / book-service / ** zuul.routes.book-service .sensitive-headers = Set-Cookie, Autorisatie hystrix.command.book-service.execution.isolation.thread.timeoutInMilliseconds = 600000 zuul.routes.rating-service.path = / rating-service / ** zuul.routes.rating- service.sensitive-headers = Set-Cookie, autorisatie hystrix.command.rating-service.execution.isolation.thread.timeoutInMilliseconds = 600000 zuul.routes.discovery.path = / discovery / ** zuul.routes.discovery.sensitive-headers = Set-Cookie, Autorisatie zuul.routes.discovery.url = // localhost: 8082 hystrix.command.discovery.execution.isolation.thread.timeoutInMilliseconds = 600000

De zuul.routes eigenschap stelt ons in staat om een applicatie te definiëren om bepaalde verzoeken te routeren op basis van een ant URL-matcher. Ons eigendom vertelt Zuul om elk binnenkomend verzoek door te sturen / boekservice / ** naar een applicatie met de spring.application.name van boekenservice. Zuul zal dan de host van de detectieserver opzoeken met behulp van de applicatienaam en het verzoek doorsturen naar die server.

Vergeet niet om de wijzigingen in de repository door te voeren!

4.4. Rennen

Voer de configuratie- en detectietoepassingen uit en wacht tot de configuratietoepassing is geregistreerd bij de detectieserver. Als ze al actief zijn, hoeven we ze niet opnieuw op te starten. Zodra dat is voltooid, voert u de gateway-server uit. De gatewayserver moet starten op poort 8080 en zichzelf registreren bij de detectieserver. De uitvoer van de console moet het volgende bevatten:

Configuratie ophalen van server op: //10.1.10.235:8081/ ... DiscoveryClient_GATEWAY / 10.1.10.235: gateway: 8080: service registreren ... DiscoveryClient_GATEWAY / 10.1.10.235: gateway: 8080 - registratiestatus: 204 Tomcat gestart op poort (s): 8080 (http)

Een fout die gemakkelijk te maken is, is om de server te starten voordat de configuratieserver zich bij Eureka heeft geregistreerd. In dit geval zien we een logboek met deze uitvoer:

Configuratie ophalen van server op: // localhost: 8888

Dit is de standaard URL en poort voor een configuratieserver en geeft aan dat onze zoekservice geen adres had toen het configuratieverzoek werd gedaan. Wacht gewoon een paar seconden en probeer het opnieuw, zodra de configuratieserver zich bij Eureka heeft geregistreerd, zal het probleem oplossen.

5. Boekingsservice

In microservice-architectuur zijn we vrij om zoveel mogelijk applicaties te maken om aan een bedrijfsdoelstelling te voldoen. Vaak verdelen ingenieurs hun diensten per domein. We zullen dit patroon volgen en een boekenservice maken om alle bewerkingen voor boeken in onze applicatie uit te voeren.

5.1. Opstelling

Nog een keer. Navigeren naar //start.spring.io. Stel het artefact in op "boekservice". Zoek naar "web" en voeg die afhankelijkheid toe. Zoek naar "config client" en voeg die afhankelijkheid toe. Zoek naar "eureka discovery" en voeg die afhankelijkheid toe. Genereer dat project.

U kunt ook deze afhankelijkheden aan een project toevoegen:

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

Ter referentie kunnen we de bundel vinden op Maven Central (config-client, eureka-client, web).

5.2. Spring Config

Laten we onze hoofdklasse aanpassen:

@SpringBootApplication @EnableEurekaClient @RestController @RequestMapping ("/ books") openbare klasse BookServiceApplication {openbare statische leegte hoofd (String [] args) {SpringApplication.run (BookServiceApplication.class, args); } private List bookList = Arrays.asList (nieuw boek (1L, "Baeldung gaat naar de markt", "Tim Schimandle"), nieuw boek (2L, "Baeldung gaat naar het park", "Slavisa")); @GetMapping ("") openbare lijst findAllBooks () {return bookList; } @GetMapping ("/ {bookId}") openbaar boek findBook (@PathVariable Long bookId) {return bookList.stream (). Filter (b -> b.getId (). Equals (bookId)). FindFirst (). OrElse (nul); }}

We hebben ook een REST-controller en een veld toegevoegd dat is ingesteld door ons eigenschappenbestand om een waarde te retourneren die we tijdens de configuratie zullen instellen.

Laten we nu het boek POJO toevoegen:

openbare klas Boek {privé Lange id; private String-auteur; private String-titel; // standaard getters en setters}

5.3. Eigendommen

Nu hoeven we alleen maar onze twee eigenschappenbestanden toe te voegen:

bootstrap.properties in src / main / resources:

spring.cloud.config.name = boekservice spring.cloud.config.discovery.service-id = configuratie spring.cloud.config.discovery.enabled = true eureka.client.serviceUrl.defaultZone = // localhost: 8082 / eureka /

book-service.properties in onze Git-repository:

spring.application.name = boekservice server.port = 8083 eureka.client.region = standaard eureka.client.registryFetchIntervalSeconds = 5 eureka.client.serviceUrl.defaultZone = // localhost: 8082 / eureka /

Laten we de wijzigingen aan de repository vastleggen.

5.4. Rennen

Zodra alle andere applicaties zijn gestart, kunnen we de boekenservice starten. De console-uitvoer zou er als volgt uit moeten zien:

DiscoveryClient_BOOK-SERVICE / 10.1.10.235: book-service: 8083: service registreren ... DiscoveryClient_BOOK-SERVICE / 10.1.10.235: book-service: 8083 - registratiestatus: 204 Tomcat gestart op poort (en): 8083 (http)

Zodra het klaar is, kunnen we onze browser gebruiken om toegang te krijgen tot het eindpunt dat we zojuist hebben gemaakt. Navigeer naar // localhost: 8080 / book-service / books en we krijgen een JSON-object terug met twee boeken die we in de controller hebben toegevoegd. Merk op dat we de boekenservice niet rechtstreeks op poort 8083 benaderen, maar via de gateway-server.

6. Beoordelingsservice

Net als onze boekenservice zal onze beoordelingsservice een domeingestuurde service zijn die bewerkingen met betrekking tot beoordelingen afhandelt.

6.1. Opstelling

Nog een keer. Navigeren naar //start.spring.io. Stel het artefact in op "rating-service". Zoek naar "web" en voeg die afhankelijkheid toe. Zoek naar "config client" en voeg die afhankelijkheid toe. Zoeken naar “eureka ontdekking“ en voeg die afhankelijkheid toe. Genereer vervolgens dat project.

U kunt ook deze afhankelijkheden aan een project toevoegen:

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

Ter referentie kunnen we de bundel vinden op Maven Central (config-client, eureka-client, web).

6.2. Spring Config

Laten we onze hoofdklasse aanpassen:

@SpringBootApplication @EnableEurekaClient @RestController @RequestMapping ("/ ratings") public class RatingServiceApplication {public static void main (String [] args) {SpringApplication.run (RatingServiceApplication.class, args); } private List ratingList = Arrays.asList (nieuwe Rating (1L, 1L, 2), nieuwe Rating (2L, 1L, 3), nieuwe Rating (3L, 2L, 4), nieuwe Rating (4L, 2L, 5)); @GetMapping ("") openbare lijst findRatingsByBookId (@RequestParam Lange bookId) bookId.equals (0L)? Collections.EMPTY_LIST: ratingList.stream (). Filter (r -> r.getBookId (). Is gelijk aan (bookId)). Collect (Collectors.toList ()); @GetMapping ("/ all") openbare lijst findAllRatings () {return ratingList; }}

We hebben ook een REST-controller en een veld toegevoegd dat is ingesteld door ons eigenschappenbestand om een waarde te retourneren die we tijdens de configuratie zullen instellen.

Laten we de beoordeling POJO toevoegen:

openbare klasse Beoordeling {privé Lange id; privé Long bookId; privé int sterren; // standaard getters en setters}

6.3. Eigendommen

Nu hoeven we alleen maar onze twee eigenschappenbestanden toe te voegen:

bootstrap.properties in src / main / resources:

spring.cloud.config.name = rating-service spring.cloud.config.discovery.service-id = config spring.cloud.config.discovery.enabled = true eureka.client.serviceUrl.defaultZone = // localhost: 8082 / eureka /

rating-service.properties in onze Git-repository:

spring.application.name = rating-service server.port = 8084 eureka.client.region = standaard eureka.client.registryFetchIntervalSeconds = 5 eureka.client.serviceUrl.defaultZone = // localhost: 8082 / eureka /

Laten we de wijzigingen aan de repository vastleggen.

6.4. Rennen

Zodra alle andere applicaties zijn gestart, kunnen we de beoordelingsservice starten. De console-uitvoer zou er als volgt uit moeten zien:

DiscoveryClient_RATING-SERVICE / 10.1.10.235: rating-service: 8083: service registreren ... DiscoveryClient_RATING-SERVICE / 10.1.10.235: rating-service: 8083 - registratiestatus: 204 Tomcat gestart op poort (en): 8084 (http)

Zodra het klaar is, kunnen we onze browser gebruiken om toegang te krijgen tot het eindpunt dat we zojuist hebben gemaakt. Navigeren naar // localhost: 8080 / rating-service / ratings / all en we krijgen JSON terug met al onze beoordelingen. Merk op dat we de beoordelingsservice niet rechtstreeks op poort 8084 openen, maar via de gateway-server.

7. Conclusie

Nu zijn we in staat om de verschillende delen van Spring Cloud te verbinden tot een functionerende microservice-applicatie. Dit vormt een basis die we kunnen gebruiken om te beginnen met het bouwen van complexere applicaties.

Zoals altijd kunnen we deze broncode vinden op GitHub.