🥇सूक्ष्म सेवा उपयोजित करणे शिकणे. भाग 1. स्प्रिंग बूट आणि डॉकर

अहो हब्र.

या लेखात, मी मायक्रो सर्व्हिसेससह प्रयोग करण्यासाठी शिकण्याचे वातावरण तयार करण्याच्या माझ्या अनुभवाबद्दल बोलू इच्छितो. जेव्हा मी प्रत्येक नवीन साधन शिकलो तेव्हा मला ते केवळ स्थानिक मशीनवरच नव्हे तर अधिक वास्तववादी परिस्थितीतही वापरून पहायचे होते. म्हणून, मी एक सरलीकृत मायक्रोसर्व्हिस ऍप्लिकेशन तयार करण्याचा निर्णय घेतला, जो नंतर सर्व प्रकारच्या मनोरंजक तंत्रज्ञानासह "कव्हर" केला जाऊ शकतो. प्रकल्पाची मुख्य आवश्यकता ही वास्तविक प्रणालीची जास्तीत जास्त कार्यात्मक समीपता आहे.

सुरुवातीला, मी प्रकल्पाची निर्मिती अनेक चरणांमध्ये मोडली:

दोन सेवा तयार करा - 'बॅकएंड' (बॅकएंड) आणि 'गेटवे' (गेटवे), त्यांना डॉकर प्रतिमांमध्ये पॅक करा आणि त्यांना एकत्र काम करण्यासाठी सेट करा

कीवर्ड: Java 11, स्प्रिंग बूट, डॉकर, इमेज ऑप्टिमायझेशन
Google Kubernetes Engine मध्ये Kubernetes कॉन्फिगरेशन आणि सिस्टीम उपयोजन विकसित करणे

कीवर्ड: Kubernetes, GKE, संसाधन व्यवस्थापन, ऑटोस्केलिंग, रहस्ये
उत्तम क्लस्टर व्यवस्थापनासाठी Helm 3 सह चार्ट तयार करणे

टॅग्ज: हेल्म 3, चार्ट डिप्लॉयमेंट
क्लस्टरला कोडचे स्वयंचलित वितरण करण्यासाठी जेनकिन्स आणि पाइपलाइन सेट करणे

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

प्रत्येक पायरीवर स्वतंत्र लेख देण्याची माझी योजना आहे.

लेखांच्या या मालिकेचा फोकस मायक्रोसर्व्हिसेस कसा लिहायचा हा नाही, तर त्यांना एकाच प्रणालीमध्ये कसे कार्य करावे हे आहे. जरी या सर्व गोष्टी सहसा विकसकाच्या जबाबदारीच्या बाहेर असतात, तरीही मला वाटते की त्यांच्याशी किमान 20% परिचित असणे उपयुक्त आहे (जे, तुम्हाला माहिती आहे, 80% निकाल देतात). सुरक्षेसारखे काही बिनशर्त महत्त्वाचे विषय या प्रकल्पातून वगळले जातील, कारण ही प्रणाली केवळ वैयक्तिक वापरासाठी तयार करण्यात आली आहे याबद्दल लेखकाला फारच कमी माहिती आहे. मी कोणत्याही मतांचे आणि रचनात्मक टीकेचे स्वागत करतो.

मायक्रो सर्व्हिसेस तयार करणे

स्प्रिंग बूट वापरून सेवा Java 11 मध्ये लिहिल्या गेल्या. REST वापरून इंटरसर्व्हिस संवाद आयोजित केला जातो. प्रकल्पामध्ये किमान चाचण्यांचा समावेश असेल (जेनकिन्समध्ये नंतर चाचणी करण्यासाठी काहीतरी असेल). सेवांसाठी स्त्रोत कोड GitHub वर उपलब्ध आहे: बॅकएंड и प्रवेशद्वार.

प्रत्येक सेवेची स्थिती तपासण्यात सक्षम होण्यासाठी, त्यांच्या अवलंबनांमध्ये स्प्रिंग अॅक्ट्युएटर जोडले गेले आहे. ते /अॅक्ट्युएटर/हेल्थ एंडपॉइंट तयार करेल आणि सेवा ट्रॅफिक स्वीकारण्यास तयार असल्यास 200 स्थिती देईल किंवा समस्या असल्यास 504 देईल. या प्रकरणात, ही एक काल्पनिक तपासणी आहे, कारण सेवा अगदी सोप्या आहेत आणि काही सक्तीच्या बाबतीत, ते अंशतः कार्यरत राहण्यापेक्षा पूर्णपणे अनुपलब्ध होण्याची शक्यता जास्त असते. परंतु वास्तविक प्रणालींमध्ये, वापरकर्ते त्याबद्दल लढा देण्यास सुरुवात करण्यापूर्वी अॅक्ट्युएटर समस्येचे निदान करण्यात मदत करू शकतात. उदाहरणार्थ, डेटाबेसमध्ये प्रवेश करण्यात समस्या असल्यास, आम्ही तुटलेल्या सेवेच्या उदाहरणासह विनंतीवर प्रक्रिया करणे थांबवून स्वयंचलितपणे प्रतिसाद देऊ शकतो.

बॅक एंड सेवा

बॅकएंड सेवा स्वीकारलेल्या विनंत्यांची संख्या मोजेल आणि परत करेल.

कंट्रोलर कोड:

@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). याचे निराकरण करण्यासाठी, सेवा एका नेटवर्कमध्ये एकत्र केल्या पाहिजेत आणि फक्त गेटवे बाहेर "स्टिक आउट" असावा.
तसेच, दोन्ही सेवा एक फाइल सिस्टम सामायिक करतात, प्रवाह तयार करतात आणि एका क्षणी एकमेकांमध्ये व्यत्यय आणू शकतात. आमच्या मायक्रोसर्व्हिसेस वेगळे करणे चांगले होईल. हे वेगवेगळ्या मशीन्सवर ऍप्लिकेशन्स वितरित करून (खूप पैसे, अवघड), आभासी मशीन वापरून (संसाधन गहन, लांब स्टार्टअप) किंवा कंटेनरायझेशन वापरून प्राप्त केले जाऊ शकते. अपेक्षेप्रमाणे, आम्ही तिसरा पर्याय निवडतो आणि गोदी कामगार कंटेनरीकरणासाठी एक साधन म्हणून.

गोदी कामगार

थोडक्यात, डॉकर पृथक कंटेनर तयार करतो, प्रति अनुप्रयोग एक. डॉकर वापरण्यासाठी, तुम्हाला डॉकरफाइल लिहिणे आवश्यक आहे - अनुप्रयोग तयार करण्यासाठी आणि चालविण्यासाठी सूचना. पुढे, तुम्ही इमेज तयार करू शकता, इमेज रेजिस्ट्रीमध्ये अपलोड करू शकता (क्र. डॉकरहब) आणि तुमची मायक्रोसर्व्हिस कोणत्याही डॉकराइज्ड वातावरणात एका कमांडमध्ये तैनात करा.

डॉकरफाइल

प्रतिमेचे सर्वात महत्त्वाचे वैशिष्ट्य म्हणजे त्याचा आकार. एक संक्षिप्त प्रतिमा रिमोट रिपॉजिटरीमधून जलद डाउनलोड करेल, कमी जागा घेईल आणि तुमची सेवा जलद सुरू होईल. कोणतीही प्रतिमा मूळ प्रतिमेच्या आधारावर तयार केली जाते आणि सर्वात कमी पर्याय निवडण्याची शिफारस केली जाते. एक चांगला पर्याय म्हणजे अल्पाइन, किमान पॅकेजेससह संपूर्ण लिनक्स वितरण.

प्रथम, "कपाळावर" डॉकरफाइल लिहिण्याचा प्रयत्न करूया (मी लगेच म्हणेन की हा एक वाईट मार्ग आहे, ते करू नका):

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 वापरू. Java 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"]

आम्ही प्रतिमा पुन्हा तयार करतो आणि परिणामी, तिचे वजन 6 पट कमी झाले, 77 एमबी. वाईट नाही. त्यानंतर, तयार केलेल्या प्रतिमा इमेज रेजिस्ट्रीमध्ये अपलोड केल्या जाऊ शकतात जेणेकरून तुमच्या प्रतिमा इंटरनेटवरून डाउनलोड करण्यासाठी उपलब्ध असतील.

डॉकरमध्ये सह-चालवणाऱ्या सेवा

सुरुवातीला, आमच्या सेवा समान नेटवर्कवर असणे आवश्यक आहे. डॉकरमध्ये नेटवर्कचे अनेक प्रकार आहेत आणि आम्ही त्यापैकी सर्वात प्राचीन वापरतो - ब्रिज, जे तुम्हाला त्याच होस्टवर चालणारे कंटेनर नेटवर्क करण्यास अनुमती देते. खालील आदेशासह नेटवर्क तयार करा:

docker network create msvc-network

पुढे, microservices-backend:1.0.0 image सह 'बॅकएंड' नावाचा बॅकएंड कंटेनर सुरू करा:

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 वर फॉरवर्ड करत आहोत. आम्ही पर्यावरण व्हेरिएबल्स सेट करण्यासाठी env पर्याय वापरतो जे स्प्रिंगद्वारे स्वयंचलितपणे वाचले जातील आणि application.properties वरून गुणधर्म अधिलिखित केले जातील.

सुरू केल्यानंतर, आम्ही कॉल करतो http://localhost/ आणि मागील प्रकरणाप्रमाणे सर्वकाही कार्य करते याची खात्री करा.

निष्कर्ष

परिणामी, आम्ही दोन साध्या मायक्रोसर्व्हिसेस तयार केल्या, त्या डॉकर कंटेनरमध्ये पॅक केल्या आणि त्याच मशीनवर एकत्र लॉन्च केल्या. परिणामी प्रणालीचे, तथापि, अनेक तोटे आहेत:

खराब दोष सहिष्णुता - सर्व काही आमच्यासाठी एका सर्व्हरवर कार्य करते
खराब स्केलेबिलिटी - जेव्हा लोड वाढते, तेव्हा अतिरिक्त सेवा उदाहरणे आपोआप तैनात करणे आणि त्यांच्या दरम्यान लोड संतुलित करणे चांगले होईल
लाँचची जटिलता - आम्हाला किमान 3 कमांड प्रविष्ट करणे आवश्यक आहे आणि काही पॅरामीटर्ससह (हे फक्त 2 सेवांसाठी आहे)

वरील समस्यांचे निराकरण करण्यासाठी, डॉकर स्वॉर्म, नोमॅड, कुबर्नेट्स किंवा ओपनशिफ्ट सारखे अनेक उपाय आहेत. जर संपूर्ण प्रणाली Java मध्ये लिहिलेली असेल, तर तुम्ही स्प्रिंग क्लाउडकडे पाहू शकता (चांगला लेख).

В पुढील भाग मी Kubernetes कसे सेट केले आणि प्रोजेक्ट Google Kubernetes Engine वर कसा तैनात केला याबद्दल मी बोलेन.

स्त्रोत: www.habr.com

मायक्रो सर्व्हिसेस कसे उपयोजित करायचे ते शिका. भाग 1. स्प्रिंग बूट आणि डॉकर