ಮೈಕ್ರೊ ಸರ್ವೀಸ್‌ಗಳನ್ನು ನಿಯೋಜಿಸುವುದು ಹೇಗೆ ಎಂದು ತಿಳಿಯಿರಿ. ಭಾಗ 1. ಸ್ಪ್ರಿಂಗ್ ಬೂಟ್ ಮತ್ತು ಡಾಕರ್

ಹೇ ಹಬ್ರ್.

ಈ ಲೇಖನದಲ್ಲಿ, ಮೈಕ್ರೊ ಸರ್ವೀಸ್‌ಗಳ ಪ್ರಯೋಗಕ್ಕಾಗಿ ಕಲಿಕೆಯ ವಾತಾವರಣವನ್ನು ಸೃಷ್ಟಿಸುವ ನನ್ನ ಅನುಭವದ ಬಗ್ಗೆ ಮಾತನಾಡಲು ನಾನು ಬಯಸುತ್ತೇನೆ. ಪ್ರತಿ ಹೊಸ ಉಪಕರಣವನ್ನು ಕಲಿಯುವಾಗ, ನನ್ನ ಸ್ಥಳೀಯ ಯಂತ್ರದಲ್ಲಿ ಮಾತ್ರವಲ್ಲದೆ ಹೆಚ್ಚು ವಾಸ್ತವಿಕ ಪರಿಸ್ಥಿತಿಗಳಲ್ಲಿಯೂ ಪ್ರಯತ್ನಿಸಲು ನಾನು ಯಾವಾಗಲೂ ಬಯಸುತ್ತೇನೆ. ಆದ್ದರಿಂದ, ನಾನು ಸರಳೀಕೃತ ಮೈಕ್ರೋಸರ್ವಿಸ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರಚಿಸಲು ನಿರ್ಧರಿಸಿದೆ, ಅದನ್ನು ನಂತರ ಎಲ್ಲಾ ರೀತಿಯ ಆಸಕ್ತಿದಾಯಕ ತಂತ್ರಜ್ಞಾನಗಳೊಂದಿಗೆ "ಹ್ಯಾಂಗ್" ಮಾಡಬಹುದು. ಯೋಜನೆಗೆ ಮುಖ್ಯ ಅವಶ್ಯಕತೆಯು ನೈಜ ವ್ಯವಸ್ಥೆಗೆ ಅದರ ಗರಿಷ್ಠ ಕ್ರಿಯಾತ್ಮಕ ಸಾಮೀಪ್ಯವಾಗಿದೆ.

ಆರಂಭದಲ್ಲಿ, ನಾನು ಯೋಜನೆಯ ರಚನೆಯನ್ನು ಹಲವಾರು ಹಂತಗಳಾಗಿ ವಿಂಗಡಿಸಿದೆ:

1. ಎರಡು ಸೇವೆಗಳನ್ನು ರಚಿಸಿ - 'ಬ್ಯಾಕೆಂಡ್' ಮತ್ತು 'ಗೇಟ್‌ವೇ', ಅವುಗಳನ್ನು ಡಾಕರ್ ಚಿತ್ರಗಳಾಗಿ ಪ್ಯಾಕ್ ಮಾಡಿ ಮತ್ತು ಒಟ್ಟಿಗೆ ಕೆಲಸ ಮಾಡಲು ಅವುಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಿ

   ಕೀವರ್ಡ್‌ಗಳು: ಜಾವಾ 11, ಸ್ಪ್ರಿಂಗ್ ಬೂಟ್, ಡಾಕರ್, ಇಮೇಜ್ ಆಪ್ಟಿಮೈಸೇಶನ್

2. Google 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"));
    }
}

ಗೇಟ್ವೇ ಸೇವೆ

ಗೇಟ್‌ವೇ ವಿನಂತಿಯನ್ನು ಬ್ಯಾಕೆಂಡ್ ಸೇವೆಗೆ ರವಾನಿಸುತ್ತದೆ, ಈ ಕೆಳಗಿನ ಮಾಹಿತಿಯೊಂದಿಗೆ ಪೂರಕವಾಗಿದೆ:

• ಗೇಟ್ವೇ ಐಡಿ. ಸರ್ವರ್ ಪ್ರತಿಕ್ರಿಯೆಯಿಂದ ಗೇಟ್‌ವೇಯ ಒಂದು ನಿದರ್ಶನವನ್ನು ಇನ್ನೊಂದರಿಂದ ಪ್ರತ್ಯೇಕಿಸಲು ಇದು ಅಗತ್ಯವಿದೆ
• ಒಂದು ನಿರ್ದಿಷ್ಟ "ರಹಸ್ಯ" ಬಹಳ ಮುಖ್ಯವಾದ ಪಾಸ್‌ವರ್ಡ್‌ನ ಪಾತ್ರವನ್ನು ವಹಿಸುತ್ತದೆ (ಪ್ರಮುಖ ಕುಕೀಯ ಎನ್‌ಕ್ರಿಪ್ಶನ್‌ಗಾಗಿ ಪ್ರಮುಖ ಸಂಖ್ಯೆ)

ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಸಂರಚನೆ. ಗುಣಲಕ್ಷಣಗಳು:

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

ಮುಂದೆ, ಮೈಕ್ರೊಸರ್ವಿಸಸ್-ಬ್ಯಾಕೆಂಡ್:1.0.0 ಚಿತ್ರದೊಂದಿಗೆ 'ಬ್ಯಾಕೆಂಡ್' ಹೆಸರಿನ ಬ್ಯಾಕೆಂಡ್ ಕಂಟೇನರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸೋಣ:

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 ಆಯ್ಕೆಗಳನ್ನು ಬಳಸುತ್ತೇವೆ ಅದು ವಸಂತಕಾಲದ ವೇಳೆಗೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಓದುತ್ತದೆ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್.ಪ್ರಾಪರ್ಟೀಸ್‌ನಿಂದ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಅತಿಕ್ರಮಿಸುತ್ತದೆ.

ಪ್ರಾರಂಭಿಸಿದ ನಂತರ, ಕರೆ ಮಾಡಿ http://localhost/ ಮತ್ತು ಹಿಂದಿನ ಪ್ರಕರಣದಂತೆ ಎಲ್ಲವೂ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

ತೀರ್ಮಾನಕ್ಕೆ

ಪರಿಣಾಮವಾಗಿ, ನಾವು ಎರಡು ಸರಳ ಮೈಕ್ರೋಸರ್ವಿಸ್‌ಗಳನ್ನು ರಚಿಸಿದ್ದೇವೆ, ಅವುಗಳನ್ನು ಡಾಕರ್ ಕಂಟೇನರ್‌ಗಳಲ್ಲಿ ಪ್ಯಾಕ್ ಮಾಡಿದ್ದೇವೆ ಮತ್ತು ಅವುಗಳನ್ನು ಒಂದೇ ಯಂತ್ರದಲ್ಲಿ ಒಟ್ಟಿಗೆ ಪ್ರಾರಂಭಿಸಿದ್ದೇವೆ. ಆದಾಗ್ಯೂ, ಪರಿಣಾಮವಾಗಿ ವ್ಯವಸ್ಥೆಯು ಹಲವಾರು ಅನಾನುಕೂಲಗಳನ್ನು ಹೊಂದಿದೆ:

• ಕಳಪೆ ಸಹಿಷ್ಣುತೆ - ಎಲ್ಲವೂ ನಮಗೆ ಒಂದು ಸರ್ವರ್‌ನಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ
• ಕಳಪೆ ಸ್ಕೇಲೆಬಿಲಿಟಿ - ಲೋಡ್ ಹೆಚ್ಚಾದಂತೆ, ಹೆಚ್ಚುವರಿ ಸೇವಾ ನಿದರ್ಶನಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಿಯೋಜಿಸಲು ಮತ್ತು ಅವುಗಳ ನಡುವೆ ಲೋಡ್ ಅನ್ನು ಸಮತೋಲನಗೊಳಿಸುವುದು ಒಳ್ಳೆಯದು
• ಸಂಕೀರ್ಣತೆಯನ್ನು ಪ್ರಾರಂಭಿಸಿ - ನಾವು ಕೆಲವು ನಿಯತಾಂಕಗಳೊಂದಿಗೆ ಕನಿಷ್ಠ 3 ಆಜ್ಞೆಗಳನ್ನು ನಮೂದಿಸಬೇಕಾಗಿದೆ (ಇದು 2 ಸೇವೆಗಳಿಗೆ ಮಾತ್ರ)

ಮೇಲಿನ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು, ಡಾಕರ್ ಸ್ವಾರ್ಮ್, ನೊಮಾಡ್, ಕುಬರ್ನೆಟ್ಸ್ ಅಥವಾ ಓಪನ್‌ಶಿಫ್ಟ್‌ನಂತಹ ಹಲವಾರು ಪರಿಹಾರಗಳಿವೆ. ಸಂಪೂರ್ಣ ಸಿಸ್ಟಮ್ ಅನ್ನು ಜಾವಾದಲ್ಲಿ ಬರೆಯಲಾಗಿದ್ದರೆ, ನೀವು ಸ್ಪ್ರಿಂಗ್ ಕ್ಲೌಡ್ ಕಡೆಗೆ ನೋಡಬಹುದು (ಒಳ್ಳೆಯ ಲೇಖನ).

В ಮುಂದಿನ ಭಾಗ ನಾನು Kubernetes ಅನ್ನು ಹೇಗೆ ಹೊಂದಿಸಿದ್ದೇನೆ ಮತ್ತು Google Kubernetes ಎಂಜಿನ್‌ಗೆ ಯೋಜನೆಯನ್ನು ನಿಯೋಜಿಸಿದ್ದೇನೆ ಎಂಬುದರ ಕುರಿತು ನಾನು ನಿಮಗೆ ಹೇಳುತ್ತೇನೆ.

ಮೂಲ: www.habr.com