Spring Cloud - Bootstrapping

1. Oversigt

Spring Cloud er en ramme til opbygning af robuste skyapplikationer. Rammerne letter udviklingen af applikationer ved at levere løsninger på mange af de almindelige problemer, der opstår, når de flytter til et distribueret miljø.

Applikationer, der kører med mikrotjenestearkitektur, sigter mod at forenkle udvikling, implementering og vedligeholdelse. Den nedbrudte karakter af applikationen giver udviklere mulighed for at fokusere på et problem ad gangen. Forbedringer kan indføres uden at påvirke andre dele af et system.

På den anden side opstår forskellige udfordringer, når vi tager en mikroservicetilgang:

Eksternisering af konfiguration, så den er fleksibel og ikke kræver genopbygning af tjenesten ved ændring
Service opdagelse
Skjuler kompleksiteten af tjenester implementeret på forskellige værter

I denne artikel bygger vi fem mikrotjenester: en konfigurationsserver, en opdagelsesserver, en gateway-server, en bogtjeneste og endelig en vurderingstjeneste. Disse fem mikrotjenester udgør en solid base-applikation til at begynde skyudvikling og tackle ovennævnte udfordringer.

2. Config Server

Når man udvikler en skyapplikation, er et problem vedligeholdelse og distribution af konfiguration til vores tjenester. Vi ønsker virkelig ikke at bruge tid på at konfigurere hvert miljø, før vi skalerer vores service vandret eller risikerer sikkerhedsbrud ved at bage vores konfiguration i vores applikation.

For at løse dette konsoliderer vi al vores konfiguration i et enkelt Git-arkiv og forbinder det til en applikation, der administrerer en konfiguration til alle vores applikationer. Vi vil oprette en meget enkel implementering.

Hvis du vil lære flere detaljer og se et mere komplekst eksempel, skal du se på vores Spring Cloud Configuration-artikel.

2.1. Opsætning

Naviger til //start.spring.io og vælg Maven og Spring Boot 2.2.x.

Indstil artefakten til “config“. I afsnittet afhængigheder skal du søge efter “konfigurationsserver” og tilføje dette modul. Tryk derefter på frembringe knappen, og vi kan downloade en zip-fil med et forudkonfigureret projekt indeni og klar til brug.

Alternativt kan vi generere en Spring Boot projekt og tilføj nogle afhængigheder til POM-filen manuelt.

Disse afhængigheder deles mellem alle projekterne:

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

Lad os tilføje en afhængighed af konfigurationsserveren:

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

Til reference kan vi finde den nyeste version på Maven Central (spring-cloud-afhængigheder, test, config-server).

2.2. Spring Config

For at aktivere konfigurationsserveren skal vi tilføje nogle kommentarer til hovedapplikationsklassen:

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

@EnableConfigServer vil gøre vores applikation til en konfigurationsserver.

2.3. Ejendomme

Lad os tilføje application.properties i src / main / ressourcer:

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

Den mest betydningsfulde indstilling for konfigurationsserveren er git.uri parameter. Dette er i øjeblikket indstillet til en relativ filsti, der generelt løser c: \ Brugere \ {brugernavn} \ på Windows eller / Brugere / {brugernavn} / på * nix. Denne egenskab peger på et Git-lager, hvor ejendomsfilerne til alle de andre applikationer er gemt. Det kan indstilles til en absolut filsti, hvis det er nødvendigt.

Tip: På en Windows-maskine forudindstilles værdien med "fil: ///", og brug derefter "fil: //" på * nix.

2.4. Git Repository

Naviger til den mappe, der er defineret af spring.cloud.config.server.git.uri og tilføj mappen applikationskonfiguration. CD i den mappe og type git init. Dette initialiserer et Git-lager, hvor vi kan gemme filer og spore deres ændringer.

2.5. Løb

Lad os køre konfigurationsserver og sørge for, at den fungerer. Fra kommandolinjetypen mvn spring-boot: løb. Dette starter serveren.

Vi skulle se dette output angive, at serveren kører:

Tomcat startede på havn (er): 8081 (http)

2.6. Bootstrapping-konfiguration

I vores efterfølgende servere vil vi ønske, at deres applikationsegenskaber administreres af denne konfigurationsserver. For at gøre det skal vi faktisk lave lidt kylling og æg: Konfigurer egenskaber i hver applikation, der ved, hvordan man kan tale tilbage til denne server.

Det er en bootstrap-proces, og hver af disse apps har en fil, der hedder bootstrap.properties. Det vil indeholde egenskaber ligesom application.properties men med et twist:

En forældres forår ApplicationContext indlæser bootstrap.properties først. Dette er kritisk, så Config Server kan begynde at administrere egenskaberne i application.properties. Det er dette specielle ApplicationContext der også dekrypterer alle krypterede applikationsegenskaber.

Det er smart at holde disse egenskabsfiler adskilte.bootstrap.properties er til at gøre konfigurationsserveren klar, og application.properties er til egenskaber, der er specifikke for vores applikation. Teknisk er det dog muligt at placere applikationsegenskaber i bootstrap.properties.

Endelig, da Config Server administrerer vores applikationsegenskaber, kan man undre sig over, hvorfor man har en application.properties overhovedet? Svaret er, at disse stadig er nyttige som standardværdier, som Config Server måske ikke har.

3. Opdagelse

Nu hvor konfigurationen er taget hånd om, har vi brug for en måde, hvorpå alle vores servere kan finde hinanden. Vi løser dette problem ved at indstille Eureka opdagelsesserver op. Da vores applikationer kunne køre på en hvilken som helst ip / port-kombination, har vi brug for et centralt adresseregister, der kan fungere som en applikationsadresseopslag.

Når en ny server tildeles, kommunikerer den med opdagelseserveren og registrerer dens adresse, så andre kan kommunikere med den. På denne måde kan andre applikationer forbruge disse oplysninger, når de fremsætter anmodninger.

Hvis du vil lære flere detaljer og se en mere kompleks opdagelsesimplementering, skal du se på Spring Cloud Eureka-artiklen.

3.1. Opsætning

Igen navigerer vi til start.spring.io. Indstil artefakten til "opdagelse". Søg efter “eureka-server”, og tilføj denne afhængighed. Søg efter "config client", og tilføj denne afhængighed. Til sidst skal du generere projektet.

Alternativt kan vi oprette en Spring Boot projekt, kopier indholdet af POM fra konfigurationsserver og bytt i disse afhængigheder:

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

Til reference finder vi bundterne på Maven Central (config-client, eureka-server).

3.2. Spring Config

Lad os tilføje Java config til hovedklassen:

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

@EnableEurekaServer konfigurerer denne server som en opdagelsesserver ved hjælp af Netflix Eureka. Spring Boot registrerer automatisk konfigurationsafhængigheden på klassestien og søger konfigurationen fra konfigurationsserveren.

3.3. Ejendomme

Nu vil vi tilføje to egenskabsfiler:

Først tilføjer vi bootstrap.properties ind i src / main / ressourcer:

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

Disse egenskaber gør det muligt for opdagelsesserveren at spørge konfigurationsserveren ved opstart.

Og for det andet tilføjer vi discovery.properties til vores Git-arkiv

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. hente-registreringsdatabase = falsk

Filnavnet skal matche spring.application.name ejendom.

Derudover fortæller vi denne server, at den fungerer i standardzonen, dette matcher konfigurationsklientens regionindstilling. Vi beder også serveren om ikke at registrere sig med en anden opdagelsesinstans.

I produktionen ville vi have mere end en af disse til at give redundans i tilfælde af fiasko, og denne indstilling ville være sand.

Lad os forpligte filen til Git-arkivet. Ellers registreres filen ikke.

3.4. Føj afhængighed til Config Server

Føj denne afhængighed til konfigurationsserverens POM-fil:

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

Til reference kan vi finde pakken på Maven Central (eureka-klient).

Føj disse egenskaber til application.properties fil i src / main / ressourcer af konfigurationsserveren:

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

3.5. Løb

Start discovery-serveren ved hjælp af den samme kommando, mvn spring-boot: løb. Outputtet fra kommandolinjen skal omfatte:

Henter config fra server på: // localhost: 8081 ... Tomcat startede på port (er): 8082 (http)

Stop og kør konfigurationstjenesten igen. Hvis alt er godt, skal output se ud:

DiscoveryClient_CONFIG / 10.1.10.235: config: 8081: registrerer tjeneste ... Tomcat startede på porte (r): 8081 (http) DiscoveryClient_CONFIG / 10.1.10.235: config: 8081 - registreringsstatus: 204

4. Gateway

Nu hvor vi har løst vores konfigurations- og opdagelsesproblemer, har vi stadig et problem med klienter, der får adgang til alle vores applikationer.

Hvis vi efterlader alt i et distribueret system, bliver vi nødt til at administrere komplekse CORS-overskrifter for at tillade krydsoprindelsesanmodninger på klienter. Vi kan løse dette ved at oprette en gateway-server. Dette fungerer som en reverse proxy-shuttling-anmodning fra klienter til vores back-end-servere.

En gateway-server er en fremragende applikation i mikroservicearkitektur, da den giver mulighed for at alle svar stammer fra en enkelt vært. Dette eliminerer behovet for CORS og giver os et praktisk sted at håndtere almindelige problemer som godkendelse.

4.1. Opsætning

Nu kender vi boret. Naviger til //start.spring.io. Indstil artefakten til "gateway". Søg efter "zuul", og tilføj denne afhængighed. Søg efter "config client", og tilføj denne afhængighed. Søg efter "eureka discovery", og tilføj denne afhængighed. Til sidst skal du generere dette projekt.

Alternativt kunne vi oprette en Spring Boot app med disse afhængigheder:

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

Til reference kan vi finde pakken på Maven Central (config-client, eureka-client, zuul).

4.2. Spring Config

Lad os tilføje konfigurationen til hovedklassen:

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

4.3. Ejendomme

Nu vil vi tilføje to egenskabsfiler:

bootstrap.properties i src / main / ressourcer:

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 i vores Git-arkiv

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

Det zuul.routes egenskab giver os mulighed for at definere en applikation til at dirigere visse anmodninger baseret på en ant URL-matcher. Vores ejendom beder Zuul om at rute enhver anmodning, der kommer ind / bog-service / ** til en ansøgning med spring.application.name af bog-service. Zuul vil derefter slå værten op fra discovery-serveren ved hjælp af applikationsnavnet og videresende anmodningen til den pågældende server.

Husk at foretage ændringerne i arkivet!

4.4. Løb

Kør konfigurations- og opdagelsesapplikationerne, og vent, indtil konfigurationsapplikationen er registreret hos opdagelseserveren. Hvis de allerede kører, behøver vi ikke genstarte dem. Når det er afsluttet, skal du køre gateway-serveren. Gateway-serveren skal starte på port 8080 og registrere sig selv på discovery-serveren. Outputtet fra konsollen skal indeholde:

Henter konfiguration fra server på: //10.1.10.235:8081/ ... DiscoveryClient_GATEWAY / 10.1.10.235: gateway: 8080: registrerer service ... DiscoveryClient_GATEWAY / 10.1.10.235: gateway: 8080 - registreringsstatus: 204 Tomcat startede på port (s): 8080 (http)

En fejl, der er let at lave, er at starte serveren, før config-serveren er registreret hos Eureka. I dette tilfælde ser vi en log med denne output:

Henter konfiguration fra serveren på: // localhost: 8888

Dette er standard-URL'en og porten til en konfigurationsserver og indikerer, at vores opdagelsestjeneste ikke havde en adresse, da konfigurationsanmodningen blev foretaget. Vent bare et par sekunder, og prøv igen, når konfigurationsserveren er registreret hos Eureka, løses problemet.

5. Bogtjeneste

I mikroservicearkitektur er vi fri til at lave så mange applikationer for at opfylde et forretningsmål. Ofte deler ingeniører deres tjenester efter domæne. Vi følger dette mønster og opretter en bogtjeneste til at håndtere alle operationer for bøger i vores applikation.

5.1. Opsætning

En gang til. Naviger til //start.spring.io. Indstil artefakten til "bogtjeneste". Søg efter “web”, og tilføj denne afhængighed. Søg efter "config client", og tilføj denne afhængighed. Søg efter "eureka discovery", og tilføj denne afhængighed. Generer dette projekt.

Alternativt kan du føje disse afhængigheder til et projekt:

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

Til reference kan vi finde pakken på Maven Central (config-client, eureka-client, web).

5.2. Spring Config

Lad os ændre vores hovedklasse:

@SpringBootApplication @EnableEurekaClient @RestController @RequestMapping ("/ books") public class BookServiceApplication {public static void main (String [] args) {SpringApplication.run (BookServiceApplication.class, args); } privat liste bookList = Arrays.asList (ny bog (1L, "Baeldung går på markedet", "Tim Schimandle"), ny bog (2L, "Baeldung går til parken", "Slavisa")); @GetMapping ("") offentlig liste findAllBooks () {return bookList; } @GetMapping ("/ {bookId}") public Book findBook (@PathVariable Long bookId) {return bookList.stream (). Filter (b -> b.getId (). Er lig med (bookId)). FindFirst (). OrElse (nul); }}

Vi tilføjede også en REST-controller og et felt indstillet af vores egenskabsfil for at returnere en værdi, som vi vil indstille under konfigurationen.

Lad os nu tilføje bogen POJO:

offentlig klasse Bog {privat Lang id; privat strengforfatter; privat streng titel; // standard getters og setter}

5.3. Ejendomme

Nu skal vi bare tilføje vores to egenskabsfiler:

bootstrap.properties i src / main / ressourcer:

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

book-service.properties i vores Git-arkiv:

spring.application.name = book-service server.port = 8083 eureka.client.region = standard eureka.client.registryFetchIntervalSeconds = 5 eureka.client.serviceUrl.defaultZone = // localhost: 8082 / eureka /

Lad os begå ændringerne i arkivet.

5.4. Løb

Når alle andre applikationer er startet, kan vi starte bogtjenesten. Konsoludgangen skal se ud:

DiscoveryClient_BOOK-SERVICE / 10.1.10.235: book-service: 8083: registrering af service ... DiscoveryClient_BOOK-SERVICE / 10.1.10.235: book-service: 8083 - registreringsstatus: 204 Tomcat startet på port (er): 8083 (http)

Når det er op, kan vi bruge vores browser til at få adgang til det slutpunkt, vi lige har oprettet. Naviger til // localhost: 8080 / book-service / books, og vi får et JSON-objekt tilbage med to bøger, som vi tilføjede i vores controller. Bemærk, at vi ikke har adgang til bogtjeneste direkte på port 8083, men vi går gennem gateway-serveren.

6. Vurderingstjeneste

Ligesom vores bogtjeneste vil vores ratingservice være en domænestyret tjeneste, der håndterer operationer relateret til ratings.

6.1. Opsætning

En gang til. Naviger til //start.spring.io. Indstil artefakten til “rating-service”. Søg efter “web”, og tilføj denne afhængighed. Søg efter "config client", og tilføj denne afhængighed. Søge efter “eureka opdagelse“ og tilføj den afhængighed. Derefter genererer dette projekt.

Alternativt kan du føje disse afhængigheder til et projekt:

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

Til reference kan vi finde pakken på Maven Central (config-client, eureka-client, web).

6.2. Spring Config

Lad os ændre vores hovedklasse:

@SpringBootApplication @EnableEurekaClient @RestController @RequestMapping ("/ ratings") offentlig klasse RatingServiceApplication {public static void main (String [] args) {SpringApplication.run (RatingServiceApplication.class, args); } privat liste ratingList = Arrays.asList (ny Rating (1L, 1L, 2), ny Rating (2L, 1L, 3), ny Rating (3L, 2L, 4), ny Rating (4L, 2L, 5)); @GetMapping ("") offentlig liste findRatingsByBookId (@RequestParam Long bookId) bookId.equals (0L)? Collections.EMPTY_LIST: ratingList.stream (). Filter (r -> r.getBookId (). Er lig med (bookId)). Collect (Collectors.toList ()); @GetMapping ("/ all") offentlig liste findAllRatings () {return ratingList; }}

Vi tilføjede også en REST-controller og et felt indstillet af vores egenskabsfil for at returnere en værdi, som vi vil indstille under konfigurationen.

Lad os tilføje vurderingen POJO:

offentlig klassevurdering {privat Lang id; privat Lang bog-id; private int-stjerner; // standard getters og setter}

6.3. Ejendomme

Nu skal vi bare tilføje vores to egenskabsfiler:

bootstrap.properties i src / main / ressourcer:

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 i vores Git-arkiv:

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

Lad os begå ændringerne i arkivet.

6.4. Løb

Når alle andre applikationer er startet, kan vi starte klassificeringstjenesten. Konsoludgangen skal se ud:

DiscoveryClient_RATING-SERVICE / 10.1.10.235: rating-service: 8083: registrering af service ... DiscoveryClient_RATING-SERVICE / 10.1.10.235: rating-service: 8083 - registreringsstatus: 204 Tomcat startede på port (er): 8084 (http)

Når det er op, kan vi bruge vores browser til at få adgang til det slutpunkt, vi lige har oprettet. Naviger til // localhost: 8080 / rating-service / ratings / all og vi får JSON tilbage, der indeholder alle vores vurderinger. Bemærk, at vi ikke har adgang til klassificeringstjenesten direkte på port 8084, men vi går gennem gateway-serveren.

7. Konklusion

Nu er vi i stand til at forbinde de forskellige stykker Spring Cloud til en fungerende mikroserviceapplikation. Dette danner en base, som vi kan bruge til at begynde at opbygge mere komplekse applikationer.

Som altid kan vi finde denne kildekode over på GitHub.