streamalism.org

1. Oversikt

Spring Cloud er et rammeverk for å bygge robuste skyapplikasjoner. Rammeverket forenkler utviklingen av applikasjoner ved å tilby løsninger på mange av de vanlige problemene når man flytter til et distribuert miljø.

Applikasjoner som kjører med mikrotjenestearkitektur, har som mål å forenkle utvikling, distribusjon og vedlikehold. Applikasjonens nedbrutte natur lar utviklere fokusere på ett problem om gangen. Forbedringer kan innføres uten å påvirke andre deler av et system.

På den annen side oppstår forskjellige utfordringer når vi tar en mikroservicetilnærming:

• Eksternalisering av konfigurasjon slik at den er fleksibel og ikke krever ombygging av tjenesten ved endring
• Tjenesteoppdagelse
• Skjuler kompleksiteten til tjenester distribuert på forskjellige verter

I denne artikkelen bygger vi fem mikrotjenester: en konfigurasjonsserver, en oppdagelsesserver, en gateway-server, en boktjeneste og til slutt en rangeringstjeneste. Disse fem mikrotjenestene danner en solid baseapplikasjon for å begynne skyutvikling og løse de nevnte utfordringene.

2. Config Server

Når du utvikler en skyapplikasjon, er det et problem å opprettholde og distribuere konfigurasjon til våre tjenester. Vi ønsker egentlig ikke å bruke tid på å konfigurere hvert miljø før vi skalerer tjenesten vår horisontalt eller risikerer sikkerhetsbrudd ved å bake konfigurasjonen vår i applikasjonen vår.

For å løse dette vil vi konsolidere all vår konfigurasjon i et enkelt Git-depot og koble det til ett program som administrerer en konfigurasjon for alle våre applikasjoner. Vi skal sette opp en veldig enkel implementering.

For å lære mer detaljer og se et mer komplekst eksempel, ta en titt på vår Cloud Cloud Configuration-artikkel.

2.1. Oppsett

Navigere til //start.spring.io og velg Maven og Spring Boot 2.2.x.

Sett gjenstanden til “config“. I delen avhengigheter, søk etter “config server” og legg til den modulen. Trykk deretter på generere knappen, og vi kan laste ned en zip-fil med et forhåndskonfigurert prosjekt inne og klar til bruk.

Alternativt kan vi generere en Vårstøvel prosjekt og legg til noen avhengigheter til POM-filen manuelt.

Disse avhengighetene deles mellom alle prosjektene:

 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 

La oss legge til en avhengighet for konfigureringsserveren:

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

Som referanse kan vi finne den nyeste versjonen på Maven Central (vår-sky-avhengigheter, test, konfigurasjonsserver).

2.2. Vårkonfig

For å aktivere konfigurasjonsserveren, må vi legge til noen kommentarer i hovedapplikasjonsklassen:

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

@EnableConfigServer vil gjøre applikasjonen vår til en konfigurasjonsserver.

2.3. Eiendommer

La oss legge til application.properties i src / main / resources:

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

Den viktigste innstillingen for konfigureringsserveren er git.uri parameter. Dette er for øyeblikket satt til en relativ filbane som vanligvis løser seg for c: \ Brukere \ {brukernavn} \ på Windows eller / Brukere / {brukernavn} / på * nix. Denne egenskapen peker på et Git-arkiv der eiendomsfilene for alle andre applikasjoner er lagret. Det kan settes til en absolutt filbane om nødvendig.

Tips: På en Windows-maskin forhåndsinnstiller du verdien med "file: ///", og deretter bruker du "file: //" på * nix.

2.4. Git Repository

Naviger til mappen definert av spring.cloud.config.server.git.uri og legg til mappen programkonfigurasjon. CD i den mappen og skriv git init. Dette vil initialisere et Git-arkiv der vi kan lagre filer og spore endringene.

2.5. Løpe

La oss kjøre konfigureringsserver og sørge for at den fungerer. Fra kommandolinjetypen mvn spring-boot: run. Dette starter serveren.

Vi bør se denne utgangen som indikerer at serveren kjører:

Tomcat startet på port (er): 8081 (http)

2.6. Bootstrapping-konfigurasjon

I våre påfølgende servere vil vi ønske at applikasjonsegenskapene deres administreres av denne konfigureringsserveren. For å gjøre det, må vi faktisk gjøre litt kylling og egg: Konfigurer egenskaper i hvert program som vet hvordan du kan snakke tilbake til denne serveren.

Det er en bootstrap-prosess, og hver av disse appene skal ha en fil som heter bootstrap.properties. Den vil inneholde egenskaper akkurat som application.properties men med en vri:

En forelder vår ApplicationContext laster bootstrap.properties først. Dette er viktig for at Config Server kan begynne å administrere egenskapene i application.properties. Det er dette spesielle ApplicationContext som også vil dekryptere eventuelle krypterte applikasjonsegenskaper.

Det er smart å holde disse eiendomsfilene forskjellige.bootstrap.properties er for å gjøre konfigureringsserveren klar, og application.properties er for eiendommer som er spesifikke for vår applikasjon. Teknisk er det imidlertid mulig å plassere applikasjonsegenskaper i bootstrap.properties.

Til slutt, siden Config Server administrerer applikasjonsegenskapene våre, kan man lure på hvorfor man har en application.properties i det hele tatt? Svaret er at disse fremdeles er nyttige som standardverdier som Config Server kanskje ikke har.

3. Oppdagelse

Nå som vi har tatt vare på konfigurasjonen, trenger vi en måte for alle serverne våre å kunne finne hverandre. Vi løser dette problemet ved å sette Eureka oppdagingsserver opp. Siden applikasjonene våre kan kjøres på hvilken som helst ip / port-kombinasjon, trenger vi et sentralt adresseregister som kan fungere som en søknadsadresseoppslag.

Når en ny server er klargjort, vil den kommunisere med discovery-serveren og registrere adressen slik at andre kan kommunisere med den. På denne måten kan andre applikasjoner konsumere denne informasjonen når de kommer med forespørsler.

For å lære mer detaljer og se en mer komplisert implementering av funn, ta en titt på Spring Cloud Eureka-artikkelen.

3.1. Oppsett

Igjen navigerer vi til start.spring.io. Sett gjenstanden til “oppdagelse”. Søk etter "eureka-server" og legg til den avhengigheten. Søk etter "config client" og legg til den avhengigheten. Til slutt, generer prosjektet.

Alternativt kan vi lage en Vårstøvel prosjektet, kopier innholdet av POM fra config-serveren og bytt i disse avhengighetene:

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

For referanse finner vi pakkene på Maven Central (config-client, eureka-server).

3.2. Vårkonfig

La oss legge til Java config i hovedklassen:

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

@EnableEurekaServer vil konfigurere denne serveren som en funnserver som bruker Netflix Eureka. Vårstøvel vil automatisk oppdage konfigurasjonsavhengigheten på klassestien og slå opp konfigurasjonen fra konfigureringsserveren.

3.3. Eiendommer

Nå skal vi legge til to egenskapsfiler:

Først legger vi til bootstrap.properties inn i src / main / resources:

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

Disse egenskapene lar oppdagelsesserver spørre konfigureringsserveren ved oppstart.

Og for det andre legger vi til discovery.properties til Git-depotet vårt

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-register = falsk

Filnavnet må samsvare med spring.application.name eiendom.

I tillegg forteller vi denne serveren at den fungerer i standardsonen, dette samsvarer med konfigurasjonsklientens regioninnstilling. Vi ber også serveren om ikke å registrere seg med en annen oppdagelsesforekomst.

I produksjonen vil vi ha mer enn en av disse for å gi redundans i tilfelle feil, og den innstillingen vil være sant.

La oss forplikte filen til Git-depotet. Ellers blir filen ikke oppdaget.

3.4. Legg til avhengighet til Config Server

Legg til denne avhengigheten i konfigurasjonsserverens POM-fil:

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

Som referanse kan vi finne pakken på Maven Central (eureka-klient).

Legg til disse egenskapene til application.properties fil i src / main / resources av konfigurasjonsserveren:

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

3.5. Løpe

Start oppdagelsesserveren med samme kommando, mvn spring-boot: run. Utgangen fra kommandolinjen skal inneholde:

Henter konfigurasjon fra serveren på: // localhost: 8081 ... Tomcat startet på port (er): 8082 (http)

Stopp og kjør konfigurasjonstjenesten på nytt. Hvis alt er bra, skal produksjonen se ut som:

DiscoveryClient_CONFIG / 10.1.10.235: config: 8081: registrerer tjeneste ... Tomcat startet på port (er): 8081 (http) DiscoveryClient_CONFIG / 10.1.10.235: config: 8081 - registreringsstatus: 204

4. Gateway

Nå som vi har løst våre konfigurasjons- og oppdagelsesproblemer, har vi fortsatt problemer med at klienter får tilgang til alle applikasjonene våre.

Hvis vi lar alt være i et distribuert system, må vi administrere komplekse CORS-overskrifter for å tillate kryssopprinnelsesforespørsler på klienter. Vi kan løse dette ved å opprette en gateway-server. Dette vil fungere som en omvendt proxy-skyttelforespørsel fra klienter til våre back-servere.

En gateway-server er en utmerket applikasjon i mikrotjenestearkitektur, da den lar alle svarene stamme fra en enkelt vert. Dette vil eliminere behovet for CORS og gi oss et praktisk sted å håndtere vanlige problemer som autentisering.

4.1. Oppsett

Nå vet vi øvelsen. Navigere til //start.spring.io. Sett gjenstanden til “gateway”. Søk etter “zuul” og legg til den avhengigheten. Søk etter “config client” og legg til den avhengigheten. Søk etter "eureka discovery" og legg til den avhengigheten. Til slutt, generer det prosjektet.

Alternativt kan vi lage en Vårstøvel app med disse avhengighetene:

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

Som referanse kan vi finne pakken på Maven Central (config-client, eureka-client, zuul).

4.2. Vårkonfig

La oss legge til konfigurasjonen i hovedklassen:

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

4.3. Eiendommer

Nå skal vi legge til to egenskapsfiler:

bootstrap.properties i 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 i vårt Git-depot

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, Authorization zuul.routes.discovery.url = // localhost: 8082 hystrix.command.discovery.execution.isolation.thread.timeoutInMilliseconds = 600000

De zuul.routes egenskap lar oss definere et program for å rute visse forespørsler basert på en maur-URL-matcher. Eiendommen vår ber Zuul om å rute enhver forespørsel som kommer inn / book-service / ** til en søknad med våren.applikasjon.navn av boktjeneste. Zuul vil deretter slå opp verten fra discovery server ved å bruke applikasjonsnavnet og videresende forespørselen til den serveren.

Husk å foreta endringene i depotet!

4.4. Løpe

Kjør konfigurasjons- og oppdagelsesapplikasjonene og vent til konfigurasjonsprogrammet har registrert seg med oppdagelsesserveren. Hvis de allerede kjører, trenger vi ikke å starte dem på nytt. Når det er fullført, kjør gateway-serveren. Gateway-serveren skal starte på port 8080 og registrere seg hos discovery-serveren. Utgangen fra konsollen skal inneholde:

Henter konfigurasjon fra serveren på: //10.1.10.235:8081/ ... DiscoveryClient_GATEWAY / 10.1.10.235: gateway: 8080: registrerer tjeneste ... DiscoveryClient_GATEWAY / 10.1.10.235: gateway: 8080 - registreringsstatus: 204 Tomcat startet på port (s): 8080 (http)

En feil det er lett å gjøre er å starte serveren før config-serveren har registrert seg hos Eureka. I dette tilfellet ser vi en logg med denne utgangen:

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

Dette er standard URL og port for en konfigurasjonsserver og indikerer at oppdagelsestjenesten vår ikke hadde en adresse da konfigurasjonsforespørselen ble gjort. Bare vent noen sekunder og prøv igjen, når konfigurasjonsserveren har registrert seg hos Eureka, vil problemet løse.

5. Boktjeneste

I mikrotjenestearkitektur står vi fritt til å lage så mange applikasjoner for å oppfylle et forretningsmål. Ofte vil ingeniører dele sine tjenester etter domene. Vi vil følge dette mønsteret og lage en boktjeneste for å håndtere alle operasjoner for bøker i applikasjonen vår.

5.1. Oppsett

En gang til. Navigere til //start.spring.io. Sett gjenstanden til “book-service”. Søk etter "web" og legg til den avhengigheten. Søk etter “config client” og legg til den avhengigheten. Søk etter "eureka discovery" og legg til den avhengigheten. Generer prosjektet.

Alternativt kan du legge til disse avhengighetene til et prosjekt:

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

Som referanse kan vi finne pakken på Maven Central (config-client, eureka-client, web).

5.2. Vårkonfig

La oss endre hovedklassen vår:

@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 bok (1L, "Baeldung går til markedet", "Tim Schimandle"), ny bok (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 (). Equals (bookId)). FindFirst (). OrElse (null); }}

Vi har også lagt til en REST-kontroller og et felt som er satt av vår eiendomsfil for å returnere en verdi vi vil sette under konfigurasjonen.

La oss nå legge til boken POJO:

offentlig klasse Bok {privat Lang id; privat strengforfatter; privat strengetittel; // standard getters og setters}

5.3. Eiendommer

Nå trenger vi bare å legge til de to egenskapsfilene våre:

bootstrap.properties i src / main / resources:

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 vårt 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 /

La oss begå endringene i depotet.

5.4. Løpe

Når alle de andre programmene har startet, kan vi starte boktjenesten. Konsollutgangen skal se ut som:

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

Når det er oppe, kan vi bruke nettleseren vår til å få tilgang til sluttpunktet vi nettopp opprettet. Naviger til // localhost: 8080 / book-service / books, og vi får tilbake et JSON-objekt med to bøker vi har lagt til i ut-kontrolleren. Legg merke til at vi ikke får tilgang til boktjeneste direkte på port 8083, men vi går gjennom gateway-serveren.

6. Rangeringstjeneste

I likhet med vår boktjeneste, vil vår rangeringstjeneste være en domenedrevet tjeneste som vil håndtere operasjoner relatert til rangeringer.

6.1. Oppsett

En gang til. Navigere til //start.spring.io. Sett artefakten til “rating-service”. Søk etter "web" og legg til den avhengigheten. Søk etter "config client" og legg til den avhengigheten. Søk etter “eureka-funn“ og legg til den avhengigheten. Generer deretter prosjektet.

Alternativt kan du legge til disse avhengighetene i et prosjekt:

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

Som referanse kan vi finne pakken på Maven Central (config-client, eureka-client, web).

6.2. Vårkonfig

La oss endre hovedklassen vår:

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

Vi har også lagt til en REST-kontroller og et felt som er satt av vår eiendomsfil for å returnere en verdi vi vil sette under konfigurasjonen.

La oss legge til vurderingen POJO:

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

6.3. Eiendommer

Nå trenger vi bare å legge til de to egenskapsfilene våre:

bootstrap.properties i 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 i vårt 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 /

La oss begå endringene i depotet.

6.4. Løpe

Når alle de andre applikasjonene har startet, kan vi starte rangeringstjenesten. Konsollutgangen skal se ut som:

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

Når det er oppe, kan vi bruke nettleseren vår til å få tilgang til sluttpunktet vi nettopp opprettet. Navigere til // localhost: 8080 / rating-service / ratings / all og vi får tilbake JSON som inneholder alle våre vurderinger. Legg merke til at vi ikke får tilgang til rangeringstjenesten direkte på port 8084, men vi går gjennom gateway-serveren.

7. Konklusjon

Nå kan vi koble de forskjellige delene av Spring Cloud til en fungerende mikroserviceapplikasjon. Dette danner en base vi kan bruke til å begynne å bygge mer komplekse applikasjoner.

Som alltid kan vi finne denne kildekoden på GitHub.