മൈക്രോസർവീസുകൾ വിന്യസിക്കാൻ പഠിക്കുന്നു. ഭാഗം 1. സ്പ്രിംഗ് ബൂട്ടും ഡോക്കറും

ഹലോ, ഹബ്ർ.

ഈ ലേഖനത്തിൽ, മൈക്രോസർവീസുകൾ പരീക്ഷിക്കുന്നതിന് ഒരു പഠന അന്തരീക്ഷം സൃഷ്ടിക്കുന്ന എൻ്റെ അനുഭവത്തെക്കുറിച്ച് സംസാരിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. ഓരോ പുതിയ ടൂളും പഠിക്കുമ്പോൾ, എൻ്റെ ലോക്കൽ മെഷീനിൽ മാത്രമല്ല, കൂടുതൽ റിയലിസ്റ്റിക് അവസ്ഥയിലും അത് പരീക്ഷിക്കാൻ ഞാൻ എപ്പോഴും ആഗ്രഹിച്ചു. അതിനാൽ, ഒരു ലളിതമായ മൈക്രോസർവീസ് ആപ്ലിക്കേഷൻ സൃഷ്ടിക്കാൻ ഞാൻ തീരുമാനിച്ചു, അത് പിന്നീട് എല്ലാത്തരം രസകരമായ സാങ്കേതികവിദ്യകളും ഉപയോഗിച്ച് "തൂങ്ങിക്കിടക്കാവുന്നതാണ്". പ്രോജക്റ്റിൻ്റെ പ്രധാന ആവശ്യകത യഥാർത്ഥ സിസ്റ്റത്തോടുള്ള അതിൻ്റെ പരമാവധി പ്രവർത്തനപരമായ സാമീപ്യമാണ്.

തുടക്കത്തിൽ, പ്രോജക്റ്റിൻ്റെ സൃഷ്ടിയെ ഞാൻ പല ഘട്ടങ്ങളായി വിഭജിച്ചു:

1. രണ്ട് സേവനങ്ങൾ സൃഷ്‌ടിക്കുക - 'ബാക്കെൻഡ്', 'ഗേറ്റ്‌വേ', അവയെ ഡോക്കർ ഇമേജുകളായി പാക്ക് ചെയ്‌ത് ഒരുമിച്ച് പ്രവർത്തിക്കാൻ കോൺഫിഗർ ചെയ്യുക

   കീവേഡുകൾ: ജാവ 11, സ്പ്രിംഗ് ബൂട്ട്, ഡോക്കർ, ഇമേജ് ഒപ്റ്റിമൈസേഷൻ

2. Google Kubernetes എഞ്ചിനിലെ Kubernetes കോൺഫിഗറേഷൻ്റെയും വിന്യാസ സംവിധാനത്തിൻ്റെയും വികസനം

   കീവേഡുകൾ: കുബർനെറ്റസ്, ജികെഇ, റിസോഴ്‌സ് മാനേജ്‌മെൻ്റ്, ഓട്ടോസ്‌കേലിംഗ്, രഹസ്യങ്ങൾ

3. കൂടുതൽ കാര്യക്ഷമമായ ക്ലസ്റ്റർ മാനേജ്മെൻ്റിനായി ഹെൽം 3 ഉപയോഗിച്ച് ഒരു ചാർട്ട് സൃഷ്ടിക്കുക

   കീവേഡുകൾ: ഹെൽം 3, ചാർട്ട് വിന്യാസം

4. ക്ലസ്റ്ററിലേക്ക് സ്വയമേവ കോഡ് ഡെലിവർ ചെയ്യുന്നതിനായി ജെങ്കിൻസും പൈപ്പ് ലൈനും സജ്ജീകരിക്കുന്നു

   കീവേഡുകൾ: ജെൻകിൻസ് കോൺഫിഗറേഷൻ, പ്ലഗിനുകൾ, പ്രത്യേക കോൺഫിഗറേഷൻ ശേഖരം

ഓരോ ഘട്ടത്തിനും ഒരു പ്രത്യേക ലേഖനം സമർപ്പിക്കാൻ ഞാൻ പദ്ധതിയിടുന്നു.

ഈ ലേഖന പരമ്പരയുടെ ശ്രദ്ധാകേന്ദ്രം മൈക്രോസർവീസുകൾ എങ്ങനെ എഴുതാം എന്നല്ല, മറിച്ച് അവയെ എങ്ങനെ ഒരൊറ്റ സിസ്റ്റത്തിൽ പ്രവർത്തിപ്പിക്കാം എന്നതാണ്. ഇവയെല്ലാം സാധാരണയായി ഡവലപ്പറുടെ ഉത്തരവാദിത്തത്തിന് പുറത്താണെങ്കിലും, അവരുമായി കുറഞ്ഞത് 20% പരിചിതമായിരിക്കുന്നത് ഇപ്പോഴും ഉപയോഗപ്രദമാണെന്ന് ഞാൻ കരുതുന്നു (ഫലത്തിൻ്റെ 80% ഇത് കണക്കാക്കുന്നു). രചയിതാവിന് ഇതിനെക്കുറിച്ച് കുറച്ച് മനസ്സിലാകുന്നതിനാൽ, സുരക്ഷ പോലുള്ള വളരെ പ്രധാനപ്പെട്ട ചില വിഷയങ്ങൾ ഈ പ്രോജക്റ്റിൽ നിന്ന് ഒഴിവാക്കപ്പെടും; സിസ്റ്റം വ്യക്തിഗത ഉപയോഗത്തിന് മാത്രമായി സൃഷ്ടിക്കപ്പെടുന്നു. ഏത് അഭിപ്രായങ്ങളെയും സൃഷ്ടിപരമായ വിമർശനങ്ങളെയും ഞാൻ സ്വാഗതം ചെയ്യുന്നു.

മൈക്രോസർവീസുകൾ സൃഷ്ടിക്കുന്നു

സ്പ്രിംഗ് ബൂട്ട് ഉപയോഗിച്ച് ജാവ 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). ഇത് പരിഹരിക്കുന്നതിന്, സേവനങ്ങൾ ഒരു നെറ്റ്‌വർക്കിലേക്ക് കൂട്ടിച്ചേർക്കണം, കൂടാതെ ഗേറ്റ്‌വേ മാത്രമേ പുറത്ത് "ഒട്ടിനിൽക്കൂ".
കൂടാതെ, രണ്ട് സേവനങ്ങളും ഒരേ ഫയൽ സിസ്റ്റം പങ്കിടുന്നു, ത്രെഡുകൾ സൃഷ്ടിക്കുന്നു, ഒരു ഘട്ടത്തിൽ പരസ്പരം ഇടപെടാൻ തുടങ്ങും. ഞങ്ങളുടെ മൈക്രോസർവീസുകളെ ഒറ്റപ്പെടുത്തുന്നത് നന്നായിരിക്കും. വ്യത്യസ്‌ത മെഷീനുകളിൽ (ധാരാളം പണം, ബുദ്ധിമുട്ട്), വെർച്വൽ മെഷീനുകൾ (റിസോഴ്‌സ്-ഇൻ്റൻസീവ്, ലോംഗ് സ്റ്റാർട്ടപ്പ്) ഉപയോഗിച്ച് അല്ലെങ്കിൽ കണ്ടെയ്‌നറൈസേഷൻ ഉപയോഗിച്ച് അപ്ലിക്കേഷനുകൾ വിതരണം ചെയ്‌ത് ഇത് നേടാനാകും. പ്രതീക്ഷിച്ചതുപോലെ, ഞങ്ങൾ മൂന്നാമത്തെ ഓപ്ഷൻ തിരഞ്ഞെടുക്കുന്നു ഡോക്കർ കണ്ടെയ്നറൈസേഷനുള്ള ഒരു ഉപകരണമായി.

ഡോക്കർ

ചുരുക്കത്തിൽ, ഡോക്കർ ഒറ്റപ്പെട്ട കണ്ടെയ്നറുകൾ സൃഷ്ടിക്കുന്നു, ഓരോ ആപ്ലിക്കേഷനും. ഡോക്കർ ഉപയോഗിക്കുന്നതിന്, നിങ്ങൾ ഒരു ഡോക്കർഫയൽ എഴുതേണ്ടതുണ്ട് - ആപ്ലിക്കേഷൻ നിർമ്മിക്കുന്നതിനും പ്രവർത്തിപ്പിക്കുന്നതിനുമുള്ള നിർദ്ദേശങ്ങൾ. അടുത്തതായി, നിങ്ങൾക്ക് ചിത്രം നിർമ്മിക്കാനും ഇമേജ് രജിസ്ട്രിയിലേക്ക് അപ്‌ലോഡ് ചെയ്യാനും കഴിയും (നമ്പർ. ഡോക്കർഹബ്) കൂടാതെ ഒരു കമാൻഡിൽ ഏതെങ്കിലും ഡോക്കറൈസ്ഡ് പരിതസ്ഥിതിയിൽ നിങ്ങളുടെ മൈക്രോ സർവീസ് വിന്യസിക്കുക.

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) ബിൽഡ് ആരംഭിക്കുകയും ചെയ്യുന്നു. കണ്ടെയ്‌നറിലെ ആപ്ലിക്കേഷൻ അതിൻ്റെ പോർട്ട് 8080 ഉപയോഗിക്കുമെന്ന് EXPOSE 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 മടങ്ങ് കനം കുറഞ്ഞ് 77 MB ആയി. മോശമല്ല. അതിനുശേഷം, പൂർത്തിയായ ചിത്രങ്ങൾ ഇമേജ് രജിസ്ട്രിയിലേക്ക് അപ്‌ലോഡ് ചെയ്യാൻ കഴിയും, അങ്ങനെ നിങ്ങളുടെ ചിത്രങ്ങൾ ഇൻ്റർനെറ്റിൽ നിന്ന് ഡൗൺലോഡ് ചെയ്യാൻ ലഭ്യമാണ്.

ഡോക്കറിൽ സേവനങ്ങൾ ഒരുമിച്ച് പ്രവർത്തിക്കുന്നു

ആരംഭിക്കുന്നതിന്, ഞങ്ങളുടെ സേവനങ്ങൾ ഒരേ നെറ്റ്‌വർക്കിൽ ആയിരിക്കണം. ഡോക്കറിൽ നിരവധി തരം നെറ്റ്‌വർക്കുകൾ ഉണ്ട്, അവയിൽ ഏറ്റവും പ്രാകൃതമായത് ഞങ്ങൾ ഉപയോഗിക്കുന്നു - ബ്രിഡ്ജ്, ഒരേ ഹോസ്റ്റിൽ പ്രവർത്തിക്കുന്ന നെറ്റ്‌വർക്ക് കണ്ടെയ്‌നറുകൾ നിങ്ങളെ അനുവദിക്കുന്നു. ഇനിപ്പറയുന്ന കമാൻഡ് ഉപയോഗിച്ച് നമുക്ക് ഒരു നെറ്റ്‌വർക്ക് സൃഷ്ടിക്കാം:

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 സേവനങ്ങൾക്ക് മാത്രം)

മേൽപ്പറഞ്ഞ പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിന്, ഡോക്കർ സ്വാം, നോമാഡ്, കുബർനെറ്റസ് അല്ലെങ്കിൽ ഓപ്പൺഷിഫ്റ്റ് എന്നിങ്ങനെ നിരവധി പരിഹാരങ്ങളുണ്ട്. മുഴുവൻ സിസ്റ്റവും ജാവയിൽ എഴുതിയിട്ടുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് സ്പ്രിംഗ് ക്ലൗഡിലേക്ക് നോക്കാം (നല്ല ലേഖനം).

В അടുത്ത ഭാഗം ഞാൻ എങ്ങനെയാണ് Kubernetes സജ്ജീകരിച്ചതെന്നും Google Kubernetes എഞ്ചിനിലേക്ക് പ്രൊജക്റ്റ് വിന്യസിച്ചതെന്നും ഞാൻ നിങ്ങളോട് പറയും.

അവലംബം: www.habr.com