Salve, Habr.
In hoc articulo loqui volo de experientia mea creando ambitum discendi experiendi cum microservices. Cum omne instrumentum novum discere, semper id experiri volui non solum in machina locali, sed etiam in condiciones veriores. Ideo decrevi applicationem faciliorem microservii creare, quae postea cum omnibus technologiarum iucundarum technologiarum "suspenditur". Praecipua utilitas ad propositum est eius propinquitas maxime functionis ad realem rationem.
Initio propositi creationem distinxi in plures gradus;
-
Duas operas crea - 'backend' et 'portam', eas fac in imagines deceptor et configurare ad operandum
Keywords: Java;
-
Keywords: Kubernetes, GKE, administratio subsidiorum, autoscaling, secreta
-
Creare chart utens Helm 3 pro efficaciore botri administratione
Keywords: Helm 3, chart instruere
-
Jenkins et pipeline profecta sunt ut sponte libera codice ad botrum portassent
Keywords: Jenkins configuration, plugins, separata configs repositorium
Articulum separatum ad quemque gradum destinare cogito.
Focus huius articulorum seriei non est microservices scribere, sed in una ratione operari. Dum haec omnia extra activitates responsabilitatem solent esse, putamus adhuc utilem esse ut saltem 20% familiare cum illis (quod rationem 80% eventus rei notum est). Quaedam argumenta absolute momenti, ut securitatem, relinquentur ex hoc consilio, quoniam auctor parum de hoc intellegit, systema solum ad usum personalem creatur. Aliquas opiniones excipio et reprehensionem aedificabo.
Creando microservices
Officia in Java 11 scripta sunt utens vere Booz. Communicatio inter-serviens utens cetera constituitur. Propositum includit minimum numerum testium (ut postea in Jenkins aliquid probandi erit). Fons codice pro officiis praesto est in GitHub: ΠΈ .
Actuator vernum ad eorum dependentiam accesserat ut statum cuiusque officia reprimere posset. Finem /actuator/salutis creabit et statum 200 reddet si servitium est paratum ad negotiationem accipiendam, vel 504 in causa problematum. In hoc casu, haec est magis ficta perscriptio, cum officia simplicissima sint, et sub aliqua vi maioris momenti, magis verisimile fiet perfecte inaccessibile quam ex parte operativa manere. Sed in systematis realibus, Actuator quaestionem egritudinem adiuvare potest antequam users in eam ferendi committitur. Exempli gratia, si difficultates oriuntur accessu ad datorum, sponte respondere poterimus huic petitiones processus insistens fracto instantia servitii.
Backend ministerium
Revocatio muneris simpliciter numerabit et reddet numerum petitionum receptarum.
Code Controller:
@RestController
public class RequestsCounterController {
private final AtomicLong counter = new AtomicLong();
@GetMapping("/requests")
public Long getRequestsCount() {
return counter.incrementAndGet();
}
}Test moderatoris:
@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"));
}
}Porta muneris
Ianua petitio prompta erit ad servitium remittendum, eamque cum sequenti informatione supplendo:
- porta consequat turpis. Necessarium est ut una instantia portae ab alia responsione ministrantis distingui possit
- Quidam "secretum" quod munus tesserae gravissimae (clavis numeri ad encryptionem magni ponderis) aget.
Configurationis in application.properties:
backend.url=http://localhost:8081
instance.id=${random.int}
secret="default-secret"Adaptor communicationis cum 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();
}
}Controller:
@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);
}
}Lorem:
Demus backend:
./mvnw package -DskipTests
java -Dserver.port=8081 -jar target/microservices-backend-1.0.0.jarPorta lets committitur:
./mvnw package -DskipTests
java -jar target/microservices-gateway-1.0.0.jarreprehendo:
$ curl http://localhost:8080/
Number of requests 1 (gateway 38560358, secret "default-secret")Omnia laborat. Lector attentus animadvertet nihil obstare quominus ad tergum directe accedat, portae praetereundo.). Ad hoc figere, officia in unum retis componi debent, et solum foris "exsertare" debet.
Etiam utraeque officia eadem ratio limae communicant, sequela generant, et in uno puncto inter se impedire possunt. Nice quod microservices nostras segregare esset. Hoc effici potest applicationes distribuendo per varias machinas (multa pecunia, difficilis), utens machinis virtualibus (resource-intensive, diu satus) vel continentisizationis utendo. Sicut expectatur, eligimus tertiam optionem et ut instrumentum ad continensizationem.
Docker
In summa, Docker vascula solitaria creat, unum per applicationem. Uti Docker, scribere debes Dockerfile - instructiones ad aedificationem et applicationem currens. Deinde imaginem aedificare potes, subcriptio imaginis eam imposuisti (No. ) et microserviam tuam explica in uno praecepto dockerized .
Dockerfile
Una ex maximis notis imaginis est eius magnitudo. Simulacrum compactum citius e repositorio remoto capiet, minus spatii suscipe, et ministerium tuum citius incipiet. Quaevis imago e fundamento imaginis aedificatur et commendatur optio minimalistica eligendi. Optio bona Alpina est, distributio plena Linux cum minimum fasciculorum.
Primum, conetur scribere Dockerfile "caput-on" (ilicet dico hanc viam esse malam, id non facere);
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"]Hic utimur Alpino subnixa basi imagine cum JDK iam inauguratus est ad nostrum propositum aedificandum. Imperio ADD usi, hodiernam directorium imagini addimus, operantem (WORKDIR) signare et aedificare incipimus. EXPOSITIO 8080 annuit mandatum ad donarium ut applicatio in continente utatur portu 8080 (hoc applicationis accessibilis ab extra non faciet, sed applicationem ad accessionem admittet, exempli gratia, ab alio vase in eodem retis ).
Ad involucrum in imaginum officia, mandata ex radice cuiusque consilii currere debes;
docker image build . -t msvc-backend:1.0.0Quo fit, ut imago 456 MB magnitudine (e quibus basis JDK 340 imago MB acceperit). Et omnia non obstante quod classes in nostro proposito uno digito numerari possunt. Ad redigendum magnitudinem imaginis nostrae:
- ecclesia multi- gradatim utimur. In primo gradu consilium colligemus, in secundo JRE instituemus, et in tertio gradu haec omnia in novam imaginem mundi Alpinam effingemus. In summa, ultima imago solum necessarias partes continebit.
- Java modularizatione utamur. Incipiens ab Java 9, instrumento jlinki uti potes ut ex modo modulorum JRE creare debes
Nam curiosus hic bonus articulus est de accessibus ad redigendos magnitudines imaginum .
Final Dockerfile:
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"]Imaginem nos recreavimus, et tandem facta 6 tempora tenuior, ad 77 MB. Non malus. Postea imagines perfectae ad subcriptio imaginis impositi possunt ut imagines tuae praesto sint e interreti deprimendi.
Currens officia simul in Docker
In primis, officia nostra in eadem retis esse debent. Plures species reticulorum in Docker sunt, et eorum maxime primitivorum utimur pontis, qui permittit te vasis retis in eodem exercitu currentem. Faciamus network cum his mandatum:
docker network create msvc-networkDeinde mittamus vas backend nomine 'backend' cum imagine microservices-backend:1.0.0;
docker run -dit --name backend --network msvc-net microservices-backend:1.0.0Notatu dignum est quod retia pontis opera ex cistae vasis suis nominibus inventionem praebet. Hoc est, officium backendi praesto erit in retis Docker .
Porta lets committitur:
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.0In hoc praecepto significamus nos mitti portum 80 hospitii nostri ad portum 8080 continentis. Optionibus env utimur ad varias ambitus collocandas, quae sponte legentur veris et proprietates ab applicatione vincunt.
Post launch, voca et fac omnia opera, sicut in priore causa.
conclusio,
Quam ob rem duas res simplices microformas creavimus, eas in vasis dotales inseruimus et in eadem machina ejecimus. Ratio autem consequens plura incommoda habet;
- Pauperum culpae tolerantia - omnia in uno servo pro nobis operatur
- Pauperum scalabilitas - sicut onus augetur, pulchrum fore ut instantiae muneris accessiones automatice disponas ac onus inter eas aequivaleat.
- Launch implicationem - necesse est ut saltem 3 praecepta ingrediamur, cum quibusdam parametris (hoc tantum pro 2 officiis)
Ad quaestiones praedictas solvendas, nonnullae sunt solutiones ut Docker Swarm, Nomad, Kubernetes vel OpenShift. Si tota ratio in Java scripta est, ad Spring Cloudm spectare potes.).
Π Dicam tibi quomodo Kubernetes erexi ac project ad Google Engine Kubernetes direxit.
Source: www.habr.com