માઇક્રોસેવાઓ કેવી રીતે જમાવવી તે જાણો. ભાગ 1. સ્પ્રિંગ બૂટ અને ડોકર

હે હબર.

આ લેખમાં, હું માઇક્રોસર્વિસિસ સાથે પ્રયોગ કરવા માટે શીખવાનું વાતાવરણ બનાવવાના મારા અનુભવ વિશે વાત કરવા માંગુ છું. દરેક નવું સાધન શીખતી વખતે, હું હંમેશા તેને માત્ર મારા સ્થાનિક મશીન પર જ નહીં, પણ વધુ વાસ્તવિક પરિસ્થિતિઓમાં પણ અજમાવવા માંગતો હતો. તેથી, મેં એક સરળ માઇક્રોસર્વિસ એપ્લિકેશન બનાવવાનું નક્કી કર્યું, જે પછીથી તમામ પ્રકારની રસપ્રદ તકનીકો સાથે "હંગ" થઈ શકે છે. પ્રોજેક્ટ માટેની મુખ્ય આવશ્યકતા એ વાસ્તવિક સિસ્ટમની તેની મહત્તમ કાર્યાત્મક નિકટતા છે.

શરૂઆતમાં, મેં પ્રોજેક્ટની રચનાને ઘણા પગલાઓમાં વિભાજિત કરી:

1. બે સેવાઓ બનાવો - 'બેકએન્ડ' અને 'ગેટવે', તેમને ડોકર ઈમેજીસમાં પેક કરો અને તેમને એકસાથે કામ કરવા માટે ગોઠવો

   કીવર્ડ્સ: જાવા 11, સ્પ્રિંગ બૂટ, ડોકર, ઇમેજ ઓપ્ટિમાઇઝેશન

2. Google Kubernetes Engine માં કુબરનેટ્સ કન્ફિગરેશન અને ડિપ્લોયમેન્ટ સિસ્ટમનો વિકાસ

   કીવર્ડ્સ: કુબરનેટ્સ, જીકેઇ, રિસોર્સ મેનેજમેન્ટ, ઓટોસ્કેલિંગ, સિક્રેટ

3. વધુ કાર્યક્ષમ ક્લસ્ટર મેનેજમેન્ટ માટે હેલ્મ 3 નો ઉપયોગ કરીને ચાર્ટ બનાવો

   કીવર્ડ્સ: હેલ્મ 3, ચાર્ટ જમાવટ

4. ક્લસ્ટરમાં કોડ આપમેળે પહોંચાડવા માટે જેનકિન્સ અને પાઇપલાઇન સેટ કરી રહ્યાં છીએ

   કીવર્ડ્સ: જેનકિન્સ રૂપરેખાંકન, પ્લગઈન્સ, અલગ રૂપરેખાઓ ભંડાર

હું દરેક પગલા માટે એક અલગ લેખ સમર્પિત કરવાની યોજના ઘડી રહ્યો છું.

લેખોની આ શ્રેણીનું ધ્યાન માઇક્રોસર્વિસિસ કેવી રીતે લખવું તે નથી, પરંતુ તેમને એક સિસ્ટમમાં કેવી રીતે કાર્ય કરવું તે છે. જ્યારે આ બધી વસ્તુઓ સામાન્ય રીતે વિકાસકર્તાની જવાબદારીની બહાર હોય છે, ત્યારે મને લાગે છે કે તેમની સાથે ઓછામાં ઓછા 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). આને ઠીક કરવા માટે, સેવાઓને એક નેટવર્કમાં જોડવી આવશ્યક છે, અને ફક્ત ગેટવે જ બહાર "સ્ટીક આઉટ" હોવો જોઈએ.
ઉપરાંત, બંને સેવાઓ સમાન ફાઇલ સિસ્ટમ શેર કરે છે, થ્રેડો જનરેટ કરે છે અને એક સમયે એકબીજા સાથે દખલ કરવાનું શરૂ કરી શકે છે. અમારી માઈક્રોસર્વિસિસને અલગ કરવી સરસ રહેશે. આ વિવિધ મશીનો (ઘણા પૈસા, મુશ્કેલ), વર્ચ્યુઅલ મશીનો (સંસાધન-સઘન, લાંબા સ્ટાર્ટઅપ) નો ઉપયોગ કરીને અથવા કન્ટેનરાઇઝેશનનો ઉપયોગ કરીને એપ્લિકેશન્સનું વિતરણ કરીને પ્રાપ્ત કરી શકાય છે. અપેક્ષા મુજબ, અમે ત્રીજો વિકલ્પ પસંદ કરીએ છીએ અને Docker કન્ટેનરાઇઝેશન માટેના સાધન તરીકે.

Docker

ટૂંકમાં, ડોકર દરેક એપ્લિકેશન દીઠ એક અલગ કન્ટેનર બનાવે છે. ડોકરનો ઉપયોગ કરવા માટે, તમારે ડોકરફાઈલ લખવાની જરૂર છે - એપ્લિકેશન બનાવવા અને ચલાવવા માટેની સૂચનાઓ. આગળ, તમે ઇમેજ બનાવી શકો છો, તેને ઇમેજ રજિસ્ટ્રીમાં અપલોડ કરી શકો છો (નં. ડોકરહબ) અને તમારી માઇક્રોસર્વિસને એક આદેશમાં કોઈપણ ડોકરાઇઝ્ડ એન્વાયર્નમેન્ટમાં તૈનાત કરો.

ડોકરફાઇલ

છબીની સૌથી મહત્વપૂર્ણ લાક્ષણિકતાઓમાંની એક તેનું કદ છે. કોમ્પેક્ટ ઇમેજ રિમોટ રિપોઝીટરીમાંથી ઝડપથી ડાઉનલોડ થશે, ઓછી જગ્યા લેશે અને તમારી સેવા ઝડપથી શરૂ થશે. કોઈપણ છબી મૂળભૂત છબીના આધારે બનાવવામાં આવે છે, અને સૌથી સરળ વિકલ્પ પસંદ કરવાની ભલામણ કરવામાં આવે છે. એક સારો વિકલ્પ આલ્પાઇન છે, જે ન્યૂનતમ પેકેજો સાથે સંપૂર્ણ સુવિધાયુક્ત Linux વિતરણ છે.

પ્રથમ, ચાલો ડોકરફાઈલ "હેડ-ઓન" લખવાનો પ્રયાસ કરીએ (હું તરત જ કહીશ કે આ એક ખરાબ રીત છે, તે કરશો નહીં):

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 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 MB જેટલી 77 ગણી પાતળી બની. ખરાબ નથી. પછીથી, ફિનિશ્ડ ઈમેજો ઈમેજ રજિસ્ટ્રી પર અપલોડ કરી શકાય છે જેથી તમારી ઈમેજો ઈન્ટરનેટ પરથી ડાઉનલોડ કરવા માટે ઉપલબ્ધ હોય.

ડોકરમાં એકસાથે સેવાઓ ચલાવવી

શરૂઆતમાં, અમારી સેવાઓ સમાન નેટવર્ક પર હોવી આવશ્યક છે. ડોકરમાં ઘણા પ્રકારના નેટવર્ક છે, અને અમે તેમાંના સૌથી આદિમ - બ્રિજનો ઉપયોગ કરીએ છીએ, જે તમને સમાન હોસ્ટ પર ચાલતા કન્ટેનરને નેટવર્ક કરવાની મંજૂરી આપે છે. ચાલો નીચેના આદેશ સાથે નેટવર્ક બનાવીએ:

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 પર ફોરવર્ડ કરી રહ્યા છીએ. અમે પર્યાવરણ ચલોને સેટ કરવા માટે env વિકલ્પોનો ઉપયોગ કરીએ છીએ જે વસંત દ્વારા આપમેળે વાંચવામાં આવશે અને application.propertiesમાંથી ગુણધર્મોને ઓવરરાઇડ કરશે.

લોન્ચ કર્યા પછી, કૉલ કરો http://localhost/ અને ખાતરી કરો કે બધું કામ કરે છે, અગાઉના કેસની જેમ.

નિષ્કર્ષ

પરિણામે, અમે બે સરળ માઇક્રો સર્વિસીસ બનાવી, તેમને ડોકર કન્ટેનરમાં પેક કર્યા અને એક જ મશીન પર એકસાથે લોન્ચ કર્યા. પરિણામી સિસ્ટમમાં, જોકે, સંખ્યાબંધ ગેરફાયદા છે:

• નબળી ખામી સહનશીલતા - અમારા માટે એક સર્વર પર બધું કામ કરે છે
• નબળી માપનીયતા - જેમ જેમ લોડ વધે છે, તેમ તેમ વધારાની સેવાના દાખલાઓ આપમેળે જમાવવામાં અને તેમની વચ્ચેના ભારને સંતુલિત કરવા માટે સરસ રહેશે.
• લોન્ચ જટિલતા - અમારે ચોક્કસ પરિમાણો સાથે ઓછામાં ઓછા 3 આદેશો દાખલ કરવાની જરૂર છે (આ ફક્ત 2 સેવાઓ માટે છે)

ઉપરોક્ત સમસ્યાઓ ઉકેલવા માટે, ડોકર સ્વોર્મ, નોમેડ, કુબરનેટ્સ અથવા ઓપનશિફ્ટ જેવા ઘણા ઉકેલો છે. જો આખી સિસ્ટમ જાવામાં લખેલી હોય, તો તમે સ્પ્રિંગ ક્લાઉડ તરફ જોઈ શકો છો (સારો લેખ).

В આગળનો ભાગ હું તમને જણાવીશ કે મેં કુબરનેટ્સ કેવી રીતે સેટ કર્યું અને પ્રોજેક્ટને Google Kubernetes Engine પર કેવી રીતે ગોઠવ્યો.

સોર્સ: www.habr.com