🥇 माइक्रोसर्विसेज को परिनियोजित करना सीखना। भाग 1. स्प्रिंग बूट और डोकर

हे हबर।

इस लेख में, मैं माइक्रोसर्विसेज के साथ प्रयोग करने के लिए सीखने का माहौल बनाने के अपने अनुभव के बारे में बात करना चाहता हूं। जब मैंने प्रत्येक नए टूल को सीखा, तो मैं हमेशा इसे न केवल स्थानीय मशीन पर, बल्कि अधिक यथार्थवादी परिस्थितियों में भी आज़माना चाहता था। इसलिए, मैंने एक सरलीकृत माइक्रोसर्विस एप्लिकेशन बनाने का फैसला किया, जिसे बाद में सभी प्रकार की दिलचस्प तकनीकों के साथ "कवर" किया जा सकता है। परियोजना के लिए मुख्य आवश्यकता इसकी वास्तविक प्रणाली से अधिकतम कार्यात्मक निकटता है।

प्रारंभ में, मैंने परियोजना के निर्माण को कई चरणों में तोड़ा:

दो सेवाएं बनाएं - 'बैकएंड' (बैकएंड) और 'गेटवे' (गेटवे), उन्हें डॉकर इमेज में पैक करें और उन्हें एक साथ काम करने के लिए सेट करें

कीवर्ड: जावा 11, स्प्रिंग बूट, डॉकर, छवि अनुकूलन
Google Kubernetes Engine में Kubernetes कॉन्फ़िगरेशन और सिस्टम परिनियोजन का विकास

कीवर्ड: कुबेरनेट्स, जीकेई, संसाधन प्रबंधन, ऑटोस्केलिंग, रहस्य
बेहतर क्लस्टर प्रबंधन के लिए हेल्म 3 के साथ चार्ट बनाना

टैग: पतवार 3, चार्ट परिनियोजन
क्लस्टर को कोड की स्वचालित डिलीवरी के लिए जेनकींस और पाइपलाइन की स्थापना

कीवर्ड: जेनकिंस कॉन्फ़िगरेशन, प्लगइन्स, अलग कॉन्फ़िगरेशन रिपॉजिटरी

मैं प्रत्येक चरण के लिए एक अलग लेख समर्पित करने की योजना बना रहा हूं।

लेखों की इस श्रृंखला का फोकस यह नहीं है कि माइक्रोसर्विसेज को कैसे लिखा जाए, बल्कि यह है कि उन्हें एक सिस्टम में कैसे काम किया जाए। हालाँकि ये सभी चीजें आमतौर पर डेवलपर की जिम्मेदारी से बाहर होती हैं, फिर भी मुझे लगता है कि कम से कम 20% (जो, जैसा कि आप जानते हैं, परिणाम का 80% देते हैं) अभी भी उनसे परिचित होना उपयोगी है। सुरक्षा जैसे कुछ बिना शर्त महत्वपूर्ण विषयों को इस परियोजना से बाहर रखा जाएगा, क्योंकि लेखक इस बारे में बहुत कम समझता है कि यह प्रणाली पूरी तरह से व्यक्तिगत उपयोग के लिए बनाई गई है। मैं किसी भी राय और रचनात्मक आलोचना का स्वागत करता हूं।

माइक्रोसर्विसेज बनाना

सेवा जावा 11 में स्प्रिंग बूट का उपयोग करके लिखी गई थी। इंटरसर्विस इंटरैक्शन REST का उपयोग करके आयोजित किया जाता है। परियोजना में न्यूनतम संख्या में परीक्षण शामिल होंगे (ताकि बाद में जेनकींस में परीक्षण करने के लिए कुछ हो)। सेवाओं के लिए स्रोत कोड GitHub पर उपलब्ध है: बैकएंड и द्वार.

प्रत्येक सेवा की स्थिति की जांच करने में सक्षम होने के लिए, उनकी निर्भरता में एक स्प्रिंग एक्ट्यूएटर जोड़ा गया है। यह एक/एक्ट्यूएटर/स्वास्थ्य समापन बिंदु बनाएगा और यदि सेवा ट्रैफ़िक स्वीकार करने के लिए तैयार है, या कोई समस्या होने पर 200 स्थिति लौटाएगा। इस मामले में, यह एक काल्पनिक जांच है, क्योंकि सेवाएं बहुत सरल हैं, और कुछ अप्रत्याशित घटनाओं के मामले में, वे आंशिक रूप से चालू रहने की तुलना में पूरी तरह से अनुपलब्ध होने की अधिक संभावना रखते हैं। लेकिन वास्तविक प्रणालियों में, उपयोगकर्ता इसके बारे में जूझना शुरू करने से पहले एक्चुएटर किसी समस्या का निदान करने में मदद कर सकता है। उदाहरण के लिए, यदि डेटाबेस तक पहुँचने में समस्याएँ हैं, तो हम टूटे हुए सेवा उदाहरण के साथ प्रसंस्करण अनुरोधों को रोककर स्वचालित रूप से इसका जवाब दे सकते हैं।

बैक एंड सर्विस

बैकएंड सेवा केवल स्वीकृत अनुरोधों की संख्या की गणना और वापसी करेगी।

नियंत्रक कोड:

@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). इसे ठीक करने के लिए, सेवाओं को एक नेटवर्क में संयोजित किया जाना चाहिए, और केवल गेटवे को बाहर "चिपकना" चाहिए।
साथ ही, दोनों सेवाएं एक फाइल सिस्टम साझा करती हैं, धाराएं उत्पन्न करती हैं और एक क्षण में एक दूसरे के साथ हस्तक्षेप करना शुरू कर सकती हैं। हमारी माइक्रोसर्विसेज को अलग करना अच्छा होगा। यह वर्चुअल मशीनों (संसाधन गहन, लंबे स्टार्टअप) का उपयोग करके या कंटेनरीकरण का उपयोग करके विभिन्न मशीनों (बहुत सारा पैसा, कठिन) पर अनुप्रयोगों को वितरित करके प्राप्त किया जा सकता है। जैसा कि अपेक्षित था, हम तीसरा विकल्प चुनते हैं और डाक में काम करनेवाला मज़दूर कंटेनरीकरण के लिए एक उपकरण के रूप में।

डाक में काम करनेवाला मज़दूर

संक्षेप में, डॉकटर अलग-अलग कंटेनर बनाता है, प्रति एप्लिकेशन एक। डॉकर का उपयोग करने के लिए, आपको डॉकरफाइल लिखने की जरूरत है - एप्लिकेशन बनाने और चलाने के लिए निर्देश। इसके बाद, आप इमेज बना सकते हैं, इसे इमेज रजिस्ट्री में अपलोड कर सकते हैं (नंबर XNUMX. डॉकरहब) और एक आदेश में किसी भी डॉकरीकृत वातावरण में अपनी माइक्रोसेवा को तैनात करें।

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 एमबी छवि है (जिसमें से आधार जेडीके छवि 340 एमबी पर कब्जा कर लेती है)। और सब इस तथ्य के बावजूद कि हमारी परियोजना में कक्षाओं को एक उंगली पर गिना जा सकता है। हमारी छवि के आकार को कम करने के लिए:

हम मल्टी-स्टेप असेंबली का उपयोग करते हैं। पहले चरण में हम परियोजना का निर्माण करेंगे, दूसरे चरण में हम जेआरई स्थापित करेंगे, और तीसरे चरण में हम इसे एक नई स्वच्छ अल्पाइन छवि में कॉपी करेंगे। कुल मिलाकर, अंतिम छवि में केवल आवश्यक घटक होंगे।
आइए जावा के मॉड्यूलरलाइजेशन का उपयोग करें। Java 9 से शुरू करते हुए, आप jlink टूल का उपयोग सिर्फ अपने लिए आवश्यक मॉड्यूल से JRE बनाने के लिए कर सकते हैं

जिज्ञासुओं के लिए, यहां इमेज रिडक्शन एप्रोच पर एक अच्छा लेख है। 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"]

हमने छवि को फिर से बनाया, और इसके परिणामस्वरूप, इसका वजन 6 गुना कम हो गया, जिसकी मात्रा 77 एमबी थी। इतना खराब भी नहीं। उसके बाद, तैयार छवियों को छवि रजिस्ट्री में अपलोड किया जा सकता है ताकि आपकी छवियां इंटरनेट से डाउनलोड करने के लिए उपलब्ध हों।

डॉकर में सह-चल रही सेवाएं

आरंभ करने के लिए, हमारी सेवाएं एक ही नेटवर्क पर होनी चाहिए। डॉकटर में कई प्रकार के नेटवर्क हैं, और हम उनमें से सबसे आदिम - ब्रिज का उपयोग करते हैं, जो आपको एक ही होस्ट पर चलने वाले नेटवर्क कंटेनरों की अनुमति देता है। निम्न आदेश के साथ एक नेटवर्क बनाएँ:

docker network create msvc-network

इसके बाद, 'बैकएंड' नाम के बैकएंड कंटेनर को माइक्रोसर्विसेज-बैकएंड:1.0.0 इमेज के साथ शुरू करें:

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

यह ध्यान देने योग्य है कि ब्रिज नेटवर्क कंटेनरों के लिए उनके नाम से आउट ऑफ द बॉक्स सर्विस डिस्कवरी प्रदान करता है। यानी बैकएंड सर्विस docker network के अंदर at पर उपलब्ध होगी 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 पर अग्रेषित कर रहे हैं। हम पर्यावरण चर सेट करने के लिए env विकल्पों का उपयोग करते हैं जो स्वचालित रूप से वसंत द्वारा पढ़े जाएंगे और application.properties से गुणों को ओवरराइड करेंगे।

शुरू करने के बाद, हम कॉल करते हैं http://localhost/ और सुनिश्चित करें कि सब कुछ काम करता है, जैसा कि पिछले मामले में था।

निष्कर्ष

नतीजतन, हमने दो सरल माइक्रोसर्विसेज बनाए, उन्हें डॉकटर कंटेनरों में पैक किया और उन्हें एक ही मशीन पर एक साथ लॉन्च किया। हालाँकि, परिणामी प्रणाली के कई नुकसान हैं:

खराब दोष सहिष्णुता - हमारे लिए सब कुछ एक सर्वर पर काम करता है
खराब अनुमापनीयता - जब लोड बढ़ता है, तो अच्छा होगा कि स्वचालित रूप से अतिरिक्त सेवा इंस्टेंस को तैनात किया जाए और उनके बीच लोड को संतुलित किया जाए
लॉन्च की जटिलता - हमें कम से कम 3 कमांड दर्ज करने की आवश्यकता थी, और कुछ मापदंडों के साथ (यह केवल 2 सेवाओं के लिए है)

उपरोक्त समस्याओं को ठीक करने के लिए, कई समाधान हैं जैसे डॉकर झुंड, घुमंतू, कुबेरनेट्स या ओपनशिफ्ट। यदि पूरा सिस्टम जावा में लिखा गया है, तो आप स्प्रिंग क्लाउड की ओर देख सकते हैं (अच्छा लेख).

В अगला भाग मैं इस बारे में बात करूंगा कि मैंने कैसे कुबेरनेट्स की स्थापना की और परियोजना को Google कुबेरनेट्स इंजन में तैनात किया।

स्रोत: www.habr.com

जानें कि माइक्रोसर्विसेज को कैसे तैनात किया जाए। भाग 1. स्प्रिंग बूट और डॉकर