🥇ක්ෂුද්‍ර සේවා යෙදවීමට ඉගෙනීම. 1 කොටස. Spring Boot සහ Docker

හේ හබ්ර්.

මෙම ලිපියෙන්, ක්ෂුද්‍ර සේවා සමඟ අත්හදා බැලීම සඳහා ඉගෙනුම් පරිසරයක් නිර්මාණය කිරීමේ මගේ අත්දැකීම් ගැන කතා කිරීමට මට අවශ්‍යය. මම සෑම නව මෙවලමක්ම ඉගෙන ගත් විට, මම සෑම විටම එය දේශීය යන්ත්රය මත පමණක් නොව, වඩාත් යථාර්ථවාදී තත්වයන් තුළ උත්සාහ කිරීමට අවශ්ය විය. එමනිසා, මම සරල කළ ක්ෂුද්‍ර සේවා යෙදුමක් නිර්මාණය කිරීමට තීරණය කළෙමි, එය පසුව සියලු ආකාරයේ රසවත් තාක්ෂණයන් සමඟ "ආවරණය" කළ හැකිය. ව්යාපෘතිය සඳහා ප්රධාන අවශ්යතාව වන්නේ සැබෑ පද්ධතියට එහි උපරිම ක්රියාකාරී සමීපත්වයයි.

මුලදී, මම ව්‍යාපෘතිය නිර්මාණය කිරීම පියවර කිහිපයකට කැඩීමි:

සේවා දෙකක් සාදන්න - 'පසුපස' (පසුපස) සහ 'ගේට්වේ' (ගේට්වේ), ඒවා ඩොකර් රූපවලට ඇසුරුම් කර එකට වැඩ කිරීමට සකසන්න

මූල පද: Java 11, Spring Boot, Docker, image optimization
Google Kubernetes එන්ජිම තුළ Kubernetes වින්‍යාසය සහ පද්ධති යෙදවීම සංවර්ධනය කිරීම

මූල පද: Kubernetes, GKE, සම්පත් කළමනාකරණය, autoscaling, රහස්
වඩා හොඳ පොකුරු කළමනාකරණය සඳහා Helm 3 සමඟ ප්‍රස්ථාරයක් නිර්මාණය කිරීම

ටැග්: හෙල්ම් 3, ප්‍රස්ථාර යෙදවීම
පොකුරට කේතය ස්වයංක්‍රීයව බෙදා හැරීම සඳහා ජෙන්කින්ස් සහ නල මාර්ගය සැකසීම

මූල පද: ජෙන්කින්ස් වින්‍යාසය, ප්ලගීන, වෙනම වින්‍යාස ගබඩාව

එක් එක් පියවර සඳහා වෙනම ලිපියක් කැප කිරීමට මම අදහස් කරමි.

මෙම ලිපි මාලාවේ අවධානය යොමු වන්නේ මයික්‍රො සර්විස් ලියන්නේ කෙසේද යන්න නොව, ඒවා තනි පද්ධතියක ක්‍රියාත්මක කරන්නේ කෙසේද යන්නයි. මේ සියල්ල සාමාන්‍යයෙන් සංවර්ධකයාගේ වගකීමෙන් බැහැර වුවද, අවම වශයෙන් 20% (ඔබ දන්නා පරිදි, ප්‍රතිඵලයෙන් 80% ලබා දෙන) ඔවුන් සමඟ හුරුපුරුදු වීම තවමත් ප්‍රයෝජනවත් යැයි මම සිතමි. ආරක්‍ෂාව වැනි කොන්දේසි විරහිතව වැදගත් මාතෘකා කිහිපයක් මෙම ව්‍යාපෘතියෙන් ඉවත් වනු ඇත, මන්ද කතුවරයා මෙම ක්‍රමය ගැන එතරම් අවබෝධයක් නැති නිසා තනිකරම පුද්ගලික භාවිතය සඳහා නිර්මාණය කර ඇත. ඕනෑම මතයක් සහ නිර්මාණාත්මක විවේචනයක් මම සාදරයෙන් පිළිගනිමි.

ක්ෂුද්ර සේවා නිර්මාණය කිරීම

මෙම සේවාවන් Spring Boot භාවිතයෙන් Java 11 හි ලියා ඇත. REST භාවිතයෙන් අන්තර් සේවා අන්තර්ක්‍රියා සංවිධානය කර ඇත. ව්‍යාපෘතියට අවම පරීක්ෂණ සංඛ්‍යාවක් ඇතුළත් වේ (එවිට ජෙන්කින්ස් හි පරීක්ෂා කිරීමට යමක් තිබේ). සේවාවන් සඳහා මූලාශ්‍ර කේතය GitHub හි ඇත: පසුතලය и දොරටුව.

එක් එක් සේවාවන්හි තත්ත්වය පරීක්ෂා කිරීමට හැකි වීම සඳහා, ඒවායේ පරායත්තතාවලට Spring Actuator එකක් එක් කර ඇත. එය /ක්‍රියාකාරක/සෞඛ්‍ය අන්ත ලක්ෂ්‍යයක් සාදනු ඇති අතර සේවාව ගමනාගමනය පිළිගැනීමට සූදානම් නම් 200 තත්වයක් හෝ ගැටලුවක් තිබේ නම් 504 ලබා දෙනු ඇත. මෙම අවස්ථාවෙහිදී, මෙය තරමක් මනඃකල්පිත චෙක්පතක් වන අතර, සේවාවන් ඉතා සරල වන අතර, යම් බලයක් ඇති අවස්ථාවක, ඒවා අර්ධ වශයෙන් ක්‍රියාත්මක වීමට වඩා සම්පූර්ණයෙන්ම නොපවතින බවට පත්වීමට ඉඩ ඇත. නමුත් සැබෑ පද්ධතිවල, පරිශීලකයන් ඒ ගැන සටන් කිරීමට පෙර ගැටලුවක් හඳුනා ගැනීමට Actuator හට උපකාර කළ හැක. උදාහරණයක් ලෙස, දත්ත සමුදායට ප්‍රවේශ වීමේ ගැටළු තිබේ නම්, කැඩුණු සේවා අවස්ථාවක් සමඟ ඉල්ලීම් සැකසීම නැවැත්වීමෙන් අපට ස්වයංක්‍රීයව මෙයට ප්‍රතිචාර දැක්විය හැක.

පසුගාමී සේවාව

පසුපෙළ සේවාව සරලව ගණන් කර පිළිගත් ඉල්ලීම් ගණන ආපසු ලබා දෙනු ඇත.

පාලක කේතය:

@RestController
public class RequestsCounterController {

    private final AtomicLong counter = new AtomicLong();

    @GetMapping("/requests")
    public Long getRequestsCount() {
        return counter.incrementAndGet();
    }
}

පාලක පරීක්ෂණය:

@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"));
    }
}

සේවා දොරටුව

ද්වාරය පහත තොරතුරු සමඟ එය අතිරේක කරමින් පසුපෙළ සේවාව වෙත ඉල්ලීම ඉදිරිපත් කරයි:

ද්වාර හැඳුනුම්පත. සේවාදායක ප්‍රතිචාරය මඟින් ද්වාරයෙහි එක් අවස්ථාවක් තවත් එකකින් වෙන්කර හඳුනාගත හැකි වන පරිදි එය අවශ්‍ය වේ.
ඉතා වැදගත් මුරපදයක භූමිකාව ඉටු කරන සමහර "රහස්" (වැදගත් කුකියක සංකේතන යතුරේ අංකය)

application.properties හි වින්‍යාසය:

backend.url=http://localhost:8081
instance.id=${random.int}
secret="default-secret"

පසුපෙළ ඇඩප්ටරය:

@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();
    }
}

පාලක:

@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);
    }
}

දියත් කරන්න:

අපි පසුබිම ආරම්භ කරමු:

./mvnw package -DskipTests
java -Dserver.port=8081 -jar target/microservices-backend-1.0.0.jar

දොරටුව ආරම්භ කිරීම:

./mvnw package -DskipTests
java -jar target/microservices-gateway-1.0.0.jar

අපි පරීක්ෂා කරමු:

$ curl http://localhost:8080/
Number of requests 1 (gateway 38560358, secret "default-secret")

හැම දෙයක්ම වැඩ කරනවා. ගේට්වේ මගහැර සෘජුවම පසුපෙළ වෙත ප්‍රවේශ වීමට කිසිවක් අපට බාධාවක් නොවන බව අවධානයෙන් සිටින පාඨකයෙකු සටහන් කරයි (http://localhost:8081/requests) මෙය නිවැරදි කිරීම සඳහා, සේවාවන් එක් ජාලයකට ඒකාබද්ධ කළ යුතු අතර, ද්වාරය පමණක් පිටත "ඇලවිය යුතුය".
එසේම, සේවා දෙකම එක් ගොනු පද්ධතියක් බෙදාහදා ගනී, ධාරාවන් නිපදවන අතර එක් මොහොතක එකිනෙකාට බාධා කිරීමට පටන් ගත හැකිය. අපගේ ක්ෂුද්‍ර සේවා හුදකලා කිරීම සතුටක්. මෙය විවිධ යන්ත්‍රවල යෙදුම් බෙදා හැරීමෙන් (මුදල් ගොඩක්, දුෂ්කර), අතථ්‍ය යන්ත්‍ර භාවිතා කිරීමෙන් (සම්පත් තීව්‍ර, දිගු ආරම්භය) හෝ බහාලුම්කරණය භාවිතා කිරීමෙන් මෙය සාක්ෂාත් කරගත හැකිය. අපේක්ෂා කළ පරිදි, අපි තුන්වන විකල්පය තෝරා ගනිමු Docker බහාලුම් සඳහා මෙවලමක් ලෙස.

Docker

කෙටියෙන් කිවහොත්, ඩොකර් හුදකලා බහාලුම් නිර්මාණය කරයි, එක් යෙදුමකට එකක්. ඩොකර් භාවිතා කිරීමට, ඔබ ඩොකර්ෆයිල් එකක් ලිවිය යුතුය - යෙදුම ගොඩනැගීම සහ ධාවනය කිරීම සඳහා උපදෙස්. ඊළඟට, ඔබට රූපය ගොඩනඟා, එය රූප රෙජිස්ට්රි වෙත උඩුගත කළ හැකිය (අංක. ඩොකර්හබ්) සහ එක් විධානයකින් ඕනෑම ඩොකරීකරණය කරන ලද පරිසරයක ඔබේ ක්ෂුද්‍ර සේවාව යොදවන්න.

ඩොකර්ෆයිල්

රූපයක වැදගත්ම ලක්ෂණයක් වන්නේ එහි විශාලත්වයයි. සංයුක්ත රූපයක් දුරස්ථ ගබඩාවකින් වේගයෙන් බාගත වනු ඇත, අඩු ඉඩක් ගනී, සහ ඔබේ සේවාව වේගයෙන් ආරම්භ වනු ඇත. ඕනෑම රූපයක් මූලික රූපයේ පදනම මත ගොඩනගා ඇති අතර, වඩාත්ම අවම විකල්පය තෝරා ගැනීමට නිර්දේශ කරනු ලැබේ. හොඳ විකල්පයක් වන්නේ ඇල්පයින්, අවම පැකේජ සහිත සම්පූර්ණ ලිනක්ස් බෙදාහැරීමක්.

පළමුව, අපි "නළලේ" Dockerfile එකක් ලිවීමට උත්සාහ කරමු (මෙය නරක ක්‍රමයක් බව මම වහාම කියමි, එය නොකරන්න):

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"]

මෙහිදී අපි අපගේ ව්‍යාපෘතිය ගොඩනැගීම සඳහා දැනටමත් ස්ථාපනය කර ඇති JDK සමඟ ඇල්පයින් පාදක පාදක රූපයක් භාවිතා කරමු. ADD විධානය සමඟ, අපි වත්මන් src නාමාවලිය රූපයට එකතු කර, එය වැඩ කරන ලෙස සලකුණු කරන්න (WORKDIR) සහ ගොඩනැගීම ආරම්භ කරන්න. EXPOSE 8080 විධානය මඟින් බහාලුම්වල ඇති යෙදුම එහි 8080 වරාය භාවිතා කරන බවට ඩොකර් වෙත සංඥා කරයි (මෙය යෙදුමට පිටතින් ප්‍රවේශ විය නොහැකි නමුත් යෙදුමට ප්‍රවේශ වීමට ඉඩ සලසයි, උදාහරණයක් ලෙස, එකම ඩොකර් ජාලයේ වෙනත් බහාලුමකින්. )

රූපවලට සේවාවන් ඇසුරුම් කිරීමට, ඔබ එක් එක් ව්‍යාපෘතියේ මූලයෙන් විධාන ක්‍රියාත්මක කළ යුතුය:

docker image build . -t msvc-backend:1.0.0

එහි ප්‍රතිඵලය වන්නේ 456 MB රූපයකි (එයින් මූලික JDK රූපය 340 MB පමණ වේ). අපගේ ව්‍යාපෘතියේ පන්ති ඇඟිල්ලකින් ගණන් කළ හැකි වුවද. අපගේ රූපයේ ප්‍රමාණය අඩු කිරීමට:

අපි බහු-පියවර එකලස් කිරීම භාවිතා කරමු. පළමු පියවරේදී අපි ව්‍යාපෘතිය ගොඩනඟමු, දෙවන පියවරේදී අපි JRE ස්ථාපනය කරන්නෙමු, තුන්වන පියවරේදී අපි ඒ සියල්ල නව පිරිසිදු ඇල්පයින් රූපයකට පිටපත් කරමු. සමස්තයක් වශයෙන්, අවසාන රූපයේ ඇත්තේ අවශ්ය සංරචක පමණි.
java වල modularization භාවිතා කරමු. ජාවා 9 සමඟින් පටන් ගෙන, ඔබට අවශ්‍ය මොඩියුල වලින් JRE නිර්මාණය කිරීමට jlink මෙවලම භාවිතා කළ හැක.

ගවේෂණ කරන්නන් සඳහා, රූපය අඩු කිරීමේ ප්‍රවේශයන් පිළිබඳ හොඳ ලිපියක් මෙන්න. https://habr.com/ru/company/ruvds/blog/485650/.

අවසාන ඩොකර් ගොනුව:

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"]

අපි රූපය ප්‍රතිනිර්මාණය කරන අතර එහි ප්‍රති result ලයක් ලෙස එහි බර 6 ගුණයකින් අඩු වූ අතර එය 77 MB පමණ වේ. නරක නැහැ. ඊට පසු, ඔබේ පින්තූර අන්තර්ජාලයෙන් බාගත කිරීම සඳහා සූදානම් කළ පින්තූර පින්තූර රෙජිස්ට්රි වෙත උඩුගත කළ හැකිය.

Docker හි සම-ධාවන සේවා

ආරම්භ කිරීමට, අපගේ සේවාවන් එකම ජාලයක තිබිය යුතුය. ඩොකර්හි ජාල වර්ග කිහිපයක් ඇති අතර, අපි ඒවායින් වඩාත්ම ප්‍රාථමික භාවිතා කරමු - පාලම, එකම ධාරකයක ක්‍රියාත්මක වන ජාල බහාලුම් කිරීමට ඔබට ඉඩ සලසයි. පහත විධානය සමඟ ජාලයක් සාදන්න:

docker network create msvc-network

මීළඟට, microservices-backend:1.0.0 රූපය සමඟින් 'backend' නම් පසුබිම් කන්ටේනරය ආරම්භ කරන්න:

docker run -dit --name backend --network msvc-net microservices-backend:1.0.0

පාලම් ජාලය බහාලුම් සඳහා ඔවුන්ගේ නම්වලින් පිටත සේවා සොයාගැනීමක් සපයන බව සඳහන් කිරීම වටී. එනම්, ඩොකර් ජාලය තුළ පසුබිම් සේවාව ලබා ගත හැකි වනු ඇත http://backend:8080.

දොරටුව ආරම්භ කිරීම:

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.0

මෙම විධානය තුළ, අපි අපගේ සත්කාරකයේ 80 වන වරාය බහාලුම් 8080 වරාය වෙත යොමු කරන බව පෙන්වමු. වසන්තය විසින් ස්වයංක්‍රීයව කියවන සහ application.properties වෙතින් ගුණාංග අභිබවා යන පරිසර විචල්‍යයන් සැකසීමට අපි env විකල්ප භාවිතා කරමු.

ආරම්භ කිරීමෙන් පසු අපි අමතන්නෙමු http://localhost/ සහ පෙර අවස්ථාවේ දී මෙන් සෑම දෙයක්ම ක්රියාත්මක වන බවට වග බලා ගන්න.

නිගමනය

එහි ප්‍රතිඵලයක් වශයෙන්, අපි සරල ක්ෂුද්‍ර සේවා දෙකක් නිර්මාණය කර, ඒවා ඩොකර් බහාලුම්වල ඇසුරුම් කර එකම යන්ත්‍රයක එකට දියත් කළෙමු. කෙසේ වෙතත්, ප්රතිඵල පද්ධතියට අවාසි ගණනාවක් ඇත:

දුර්වල වැරදි ඉවසීම - සෑම දෙයක්ම එක් සේවාදායකයක් මත අපට වැඩ කරයි
දුර්වල පරිමාණය - බර වැඩි වන විට, අමතර සේවා අවස්ථා ස්වයංක්‍රීයව යෙදවීම සහ ඒවා අතර බර සමතුලිත කිරීම සතුටක්.
දියත් කිරීමේ සංකීර්ණත්වය - අපට අවම වශයෙන් විධාන 3 ක් ඇතුළත් කිරීමට අවශ්‍ය විය, සහ ඇතැම් පරාමිතීන් සමඟ (මෙය සේවා 2 ක් සඳහා පමණි)

ඉහත ගැටළු නිරාකරණය කිරීම සඳහා, Docker Swarm, Nomad, Kubernetes හෝ OpenShift වැනි විසඳුම් ගණනාවක් තිබේ. මුළු පද්ධතියම ජාවා වලින් ලියා ඇත්නම්, ඔබට වසන්ත වලාකුළ දෙස බැලිය හැකිය (හොඳ ලිපියක්).

В ඊළඟ කොටස මම Kubernetes පිහිටුවා Google Kubernetes Engine වෙත ව්‍යාපෘතිය යෙදවූ ආකාරය ගැන කතා කරමි.

මූලාශ්රය: www.habr.com

ක්ෂුද්‍ර සේවා යෙදවීමට ඉගෙන ගන්න. 1 කොටස. Spring Boot සහ Docker

ක්ෂුද්ර සේවා නිර්මාණය කිරීම

පසුගාමී සේවාව

සේවා දොරටුව

දියත් කරන්න:

Docker

ඩොකර්ෆයිල්

Docker හි සම-ධාවන සේවා

නිගමනය

අදහස් එක් කරන්න

ක්ෂුද්‍ර සේවා යෙදවීමට ඉගෙන ගන්න. 1 කොටස. Spring Boot සහ Docker

ක්ෂුද්ර සේවා නිර්මාණය කිරීම

පසුගාමී සේවාව

සේවා දොරටුව

දියත් කරන්න:

Docker

ඩොකර්ෆයිල්

Docker හි සම-ධාවන සේවා

නිගමනය

අදහස් එක් කරන්න ඊ-මේල් මගින් පිලිතුරු දෙන්න අවලංගු

අදහස් එක් කරන්න