Hey Habr.
San Airteagal seo, ba mhaith liom labhairt faoi mo thaithí maidir le timpeallacht foghlama a chruthú chun triail a bhaint as micreasheirbhísí. Nuair a d'fhoghlaim mé gach uirlis nua, bhí mé i gcónaí ag iarraidh é a thriail ní hamháin ar an meaisín áitiúil, ach freisin i gcoinníollacha níos réadúla. Dá bhrí sin, chinn mé iarratas microservice simplithe a chruthú, ar féidir a "clúdach" níos déanaí le gach cineál teicneolaíochtaí suimiúla. Is é an príomhriachtanas don tionscadal ná a chóngaracht feidhme uasta don fhíorchóras.
Ar dtús, bhris mé cruthú an tionscadail i roinnt céimeanna:
-
Cruthaigh dhá sheirbhís - 'backend' (innill) agus 'geata' (geata), pacála isteach íomhánna duga iad agus socraigh iad le bheith ag obair le chéile
Eochairfhocail: Java 11, Tosaithe an Earraigh, Docker, leas iomlán a bhaint as íomhá
-
Eochairfhocail: Kubernetes, GKE, bainistíocht acmhainní, uathscálú, rúin
-
Cairt a chruthú le Helm 3 le haghaidh bainistíocht braisle níos fearr
Clibeanna: Helm 3 , imscaradh cairte
-
Jenkins agus píblíne a bhunú chun cód a sheachadadh go huathoibríoch chuig an mbraisle
Eochairfhocail: cumraíocht Jenkins, forlíontáin, stór configs ar leith
Tá sé beartaithe agam alt ar leith a chaitheamh ar gach céim.
Ní hé fócas na sraithe alt seo conas microservices a scríobh, ach conas iad a dhéanamh ag obair i gcóras amháin. Cé go bhfuil na rudaí seo go léir de ghnáth lasmuigh de fhreagracht an fhorbróra, is dóigh liom go bhfuil sé úsáideach fós a bheith eolach orthu 20% ar a laghad (a thugann, mar is eol duit, 80% den toradh). Fágfar roinnt topaicí tábhachtacha gan choinníoll, mar shlándáil, as an tionscadal seo, ós rud é nach dtuigeann an t-údar mórán faoin gcóras seo a chruthaítear d’úsáid phearsanta amháin. Fáiltím roimh aon tuairimí agus cáineadh cuiditheach.
Micreaseirbhísí a chruthú
Scríobhadh na seirbhísí i Java 11 ag baint úsáide as Spring Boot. Eagraítear idirghníomhaíocht idirsheirbhíse ag baint úsáide as REST. Áireofar leis an tionscadal líon íosta tástálacha (ionas go mbeidh rud éigin le tástáil i Jenkins níos déanaí). Tá cód foinse na seirbhísí ar fáil ar GitHub: и .
Chun a bheith in ann stádas gach ceann de na seirbhísí a sheiceáil, tá Actuator Earraigh curtha lena spleáchais. Cruthóidh sé críochphointe /actuator/sláinte agus tabharfaidh sé stádas 200 ar ais má tá an tseirbhís réidh le glacadh le trácht, nó 504 má bhíonn fadhb ann. Sa chás seo, is seiceáil sách bréagach é seo, ós rud é go bhfuil na seirbhísí an-simplí, agus i gcás roinnt force majeure, is dóichí nach mbeidh siad ar fáil go hiomlán ná go bhfanfaidh siad ag feidhmiú go páirteach. Ach i bhfíorchórais, is féidir le Actuator cabhrú le fadhb a dhiagnóiseadh sula dtosaíonn úsáideoirí ag troid faoi. Mar shampla, má bhíonn fadhbanna ag baint le rochtain a fháil ar an mbunachar sonraí, is féidir linn freagra a thabhairt go huathoibríoch air seo trí iarratais a stopadh le seirbhís briste.
Seirbhís deiridh cúil
Ní dhéanfaidh an tseirbhís inneall ach líon na n-iarratas glactha a chomhaireamh agus a sheoladh ar ais.
Cód rialtóir:
@RestController
public class RequestsCounterController {
private final AtomicLong counter = new AtomicLong();
@GetMapping("/requests")
public Long getRequestsCount() {
return counter.incrementAndGet();
}
}Tástáil rialaitheora:
@WebMvcTest(RequestsCounterController.class)
public class RequestsCounterControllerTests {
@Autowired
private MockMvc mockMvc;
@Test
public void firstRequest_one() throws Exception {
mockMvc.perform(get("/requests"))
.andExpect(status().isOk())
.andExpect(MockMvcResultMatchers.content().string("1"));
}
}Geata Seirbhíse
Cuirfidh an tairseach an t-iarratas ar aghaidh chuig an tseirbhís inneall, ag cur leis an bhfaisnéis seo a leanas:
- id gheata. Tá sé ag teastáil ionas gur féidir idirdhealú a dhéanamh idir cás amháin den gheata agus ceann eile trí fhreagra an fhreastalaí
- Roinnt "rúnda" a imreoidh ról pasfhocal an-tábhachtach (líon eochair criptithe fianán tábhachtach)
Cumraíocht in application.properties:
backend.url=http://localhost:8081
instance.id=${random.int}
secret="default-secret"adapter backend:
@Service
public class BackendAdapter {
private static final String REQUESTS_ENDPOINT = "/requests";
private final RestTemplate restTemplate;
@Value("${backend.url}")
private String backendUrl;
public BackendAdapter(RestTemplateBuilder builder) {
restTemplate = builder.build();
}
public String getRequests() {
ResponseEntity<String> response = restTemplate.getForEntity(
backendUrl + REQUESTS_ENDPOINT, String.class);
return response.getBody();
}
}Rialaitheoir:
@RestController
@RequiredArgsConstructor
public class EndpointController {
private final BackendAdapter backendAdapter;
@Value("${instance.id}")
private int instanceId;
@Value("${secret}")
private String secret;
@GetMapping("/")
public String getRequestsCount() {
return String.format("Number of requests %s (gateway %d, secret %s)", backendAdapter.getRequests(), instanceId, secret);
}
}Seoladh:
Cuirimid tús leis an gcúl:
./mvnw package -DskipTests
java -Dserver.port=8081 -jar target/microservices-backend-1.0.0.jarAg tosú an gheata:
./mvnw package -DskipTests
java -jar target/microservices-gateway-1.0.0.jarDéanaimid seiceáil:
$ curl http://localhost:8080/
Number of requests 1 (gateway 38560358, secret "default-secret")Tá gach rud ag obair. Tabharfaidh léitheoir aireach faoi deara nach gcuireann aon rud cosc orainn teacht ar an inneall díreach agus an geata a sheachaint (). Chun seo a shocrú, ní mór na seirbhísí a chomhcheangal i líonra amháin, agus níor cheart ach an geata "bata amach" taobh amuigh.
Chomh maith leis sin, roinneann an dá sheirbhís córas comhaid amháin, táirgeann sruthanna agus is féidir leo tosú ag cur isteach ar a chéile tráth amháin. Bheadh sé go deas ár micriseirbhísí a leithlisiú. Is féidir é seo a bhaint amach trí iarratais a dháileadh ar mheaisíní éagsúla (a lán airgid, deacair), ag baint úsáide as meaisíní fíorúla (dian ar acmhainní, tosaithe fada), nó ag baint úsáide as coimeádán. De réir mar a bhíothas ag súil leis, roghnaíonn muid an tríú rogha agus mar uirlis le haghaidh coimeádaithe.
dhugaire
I mbeagán focal, cruthaíonn docker coimeádáin scoite, ceann amháin in aghaidh an iarratais. Chun docker a úsáid, ní mór duit Dockerfile a scríobh - treoracha chun an feidhmchlár a thógáil agus a rith. Ansin, is féidir leat an íomhá a thógáil, é a uaslódáil chuig an gclár íomhá (Uimh. ) agus imscaradh do mhicrisheirbhís in aon timpeallacht dockerized in aon ordú amháin.
dockerfile
Ceann de na tréithe is tábhachtaí d'íomhá ná a mhéid. Déanfar íomhá dhlúth a íoslódáil níos tapúla ó stór cianda, tógfaidh sé níos lú spáis, agus cuirfear tús le do sheirbhís níos tapúla. Tógtar aon íomhá ar bhonn an íomhá bonn, agus moltar an rogha is íostach a roghnú. Rogha maith is ea Alpach, dáileadh Linux iomlán le pacáistí íosta.
Ar dtús, déanaimis iarracht Dockerfile a scríobh "ar an mhullach" (déarfaidh mé ar an bpointe boise gur droch-bhealach é seo, ná déan é):
FROM adoptopenjdk/openjdk11:jdk-11.0.5_10-alpine
ADD . /src
WORKDIR /src
RUN ./mvnw package -DskipTests
EXPOSE 8080
ENTRYPOINT ["java","-jar","target/microservices-gateway-1.0.0.jar"]Anseo táimid ag baint úsáide as buníomhá Alpach agus an JDK suiteáilte cheana féin chun ár dtionscadal a thógáil. Leis an ordú ADD, cuirimid an t-eolaire src reatha leis an íomhá, marcáil sé mar oibriú (WORKDIR) agus cuirimid tús leis an tógáil. Comharthaíonn an t-ordú EXPOSE 8080 don docker go n-úsáidfidh an feidhmchlár sa choimeádán a phort 8080 (ní dhéanfaidh sé seo rochtain a fháil ar an bhfeidhmchlár ón taobh amuigh, ach ceadóidh sé rochtain a fháil ar an bhfeidhmchlár, mar shampla, ó choimeádán eile ar an líonra dugaí céanna ).
Chun seirbhísí a phacáistiú ina n-íomhánna, ní mór duit orduithe a rith ó fhréamh gach tionscadail:
docker image build . -t msvc-backend:1.0.0Is é an toradh íomhá 456 MB (a raibh an buníomhá JDK áitiú 340 MB). Agus go léir in ainneoin gur féidir na ranganna inár dtionscadal a chomhaireamh ar mhéar. Chun méid ár n-íomhá a laghdú:
- Bainimid úsáid as tionól ilchéime. Sa chéad chéim tógfaimid an tionscadal, sa dara céim déanfaimid an JRE a shuiteáil, agus sa tríú céim déanfaimid é a chóipeáil go léir i íomhá Alpach glan nua. San iomlán, ní bheidh ach na comhpháirteanna riachtanacha san íomhá deiridh.
- Bainimis úsáid as modúlú java. Ag tosú le Java 9, is féidir leat an uirlis jlink a úsáid chun JRE a chruthú ó na modúil atá uait
Maidir leis an fiosrach, tá alt maith anseo ar chur chuige laghdaithe íomhá. .
Comhad Docker Deiridh:
FROM adoptopenjdk/openjdk11:jdk-11.0.5_10-alpine as builder
ADD . /src
WORKDIR /src
RUN ./mvnw package -DskipTests
FROM alpine:3.10.3 as packager
RUN apk --no-cache add openjdk11-jdk openjdk11-jmods
ENV JAVA_MINIMAL="/opt/java-minimal"
RUN /usr/lib/jvm/java-11-openjdk/bin/jlink
--verbose
--add-modules
java.base,java.sql,java.naming,java.desktop,java.management,java.security.jgss,java.instrument
--compress 2 --strip-debug --no-header-files --no-man-pages
--release-info="add:IMPLEMENTOR=radistao:IMPLEMENTOR_VERSION=radistao_JRE"
--output "$JAVA_MINIMAL"
FROM alpine:3.10.3
LABEL maintainer="Anton Shelenkov [email protected]"
ENV JAVA_HOME=/opt/java-minimal
ENV PATH="$PATH:$JAVA_HOME/bin"
COPY --from=packager "$JAVA_HOME" "$JAVA_HOME"
COPY --from=builder /src/target/microservices-backend-*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java","-jar","/app.jar"]Déanaimid an íomhá a athchruthú, agus mar thoradh air sin, chaill sé 6 huaire a meáchan, arbh ionann é agus 77 MB. Ní dona. Ina dhiaidh sin, is féidir íomhánna réamhdhéanta a uaslódáil chuig an gclárlann íomhánna ionas go mbeidh do chuid íomhánna ar fáil le híoslódáil ón Idirlíon.
Seirbhísí comhreáchtála i Docker
Ar dtús, caithfidh ár seirbhísí a bheith ar an líonra céanna. Tá roinnt cineálacha de líonraí i docker, agus úsáidimid an chuid is mó primitive acu - droichead, a ligeann duit a líonra coimeádáin ag rith ar an ósta céanna. Cruthaigh líonra leis an ordú seo a leanas:
docker network create msvc-networkAnsin, cuir tús leis an gcoimeádán inneall darb ainm 'Inneall' leis an íomhá microservices-back:1.0.0:
docker run -dit --name backend --network msvc-net microservices-backend:1.0.0Is fiú a thabhairt faoi deara go soláthraíonn an líonra droichead fionnachtain seirbhíse as an mbosca do choimeádáin faoina n-ainmneacha. Is é sin, beidh an tseirbhís inneall ar fáil taobh istigh den líonra docker ag .
Ag tosú an gheata:
docker run -dit -p 80:8080 --env secret=my-real-secret --env BACKEND_URL=http://backend:8080/ --name gateway --network msvc-net microservices-gateway:1.0.0Sa ordú seo, léirímid go bhfuilimid ag cur calafort 80 dár n-óstach ar aghaidh chuig calafort 8080 den choimeádán. Bainimid úsáid as na roghanna env chun athróga timpeallachta a shocrú a léifear go huathoibríoch faoin earrach agus a sháraíonn airíonna ó application.properties.
Tar éis tosú, glaoimid agus déan cinnte go n-oibríonn gach rud, mar a tharla sa chás roimhe seo.
Conclúid
Mar thoradh air sin, chruthaigh muid dhá mhicreirbhís simplí, phacáistithe iad i gcoimeádáin docker agus sheolamar iad le chéile ar an meaisín céanna. Mar sin féin, tá roinnt míbhuntáistí ag baint leis an gcóras mar thoradh air:
- Caoinfhulaingt locht lag - oibríonn gach rud dúinn ar fhreastalaí amháin
- Inscálaitheacht lag - nuair a mhéadaíonn an t-ualach, bheadh sé deas cásanna seirbhíse breise a imscaradh go huathoibríoch agus an t-ualach a chothromú eatarthu
- Castacht an tseolta - ní mór dúinn 3 ordú ar a laghad a chur isteach, agus le paraiméadair áirithe (níl sé seo ach le haghaidh 2 sheirbhís)
Chun na fadhbanna thuas a shocrú, tá roinnt réitigh ann mar Docker Swarm, Nomad, Kubernetes nó OpenShift. Má tá an córas iomlán scríofa i Java, is féidir leat breathnú i dtreo Spring Cloud ().
В Labhróidh mé faoin gcaoi ar bhunaigh mé Kubernetes agus ar imscaradh mé an tionscadal chuig Inneall Kubernetes Google.
Foinse: will.com