ਮਾਈਕ੍ਰੋ ਸਰਵਿਸਿਜ਼ ਨੂੰ ਕਿਵੇਂ ਤੈਨਾਤ ਕਰਨਾ ਹੈ ਸਿੱਖੋ। ਭਾਗ 1. ਸਪਰਿੰਗ ਬੂਟ ਅਤੇ ਡੌਕਰ

ਹੇ ਹਬਰ.

ਇਸ ਲੇਖ ਵਿੱਚ, ਮੈਂ ਮਾਈਕ੍ਰੋ ਸਰਵਿਸਿਜ਼ ਦੇ ਨਾਲ ਪ੍ਰਯੋਗ ਕਰਨ ਲਈ ਇੱਕ ਸਿੱਖਣ ਦਾ ਮਾਹੌਲ ਬਣਾਉਣ ਵਿੱਚ ਆਪਣੇ ਅਨੁਭਵ ਬਾਰੇ ਗੱਲ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹਾਂ। ਜਦੋਂ ਮੈਂ ਹਰ ਨਵੇਂ ਟੂਲ ਨੂੰ ਸਿੱਖਿਆ, ਮੈਂ ਹਮੇਸ਼ਾ ਇਸਨੂੰ ਨਾ ਸਿਰਫ਼ ਸਥਾਨਕ ਮਸ਼ੀਨ 'ਤੇ, ਸਗੋਂ ਹੋਰ ਯਥਾਰਥਵਾਦੀ ਸਥਿਤੀਆਂ ਵਿੱਚ ਵੀ ਅਜ਼ਮਾਉਣਾ ਚਾਹੁੰਦਾ ਸੀ। ਇਸ ਲਈ, ਮੈਂ ਇੱਕ ਸਰਲ ਮਾਈਕ੍ਰੋਸਰਵਿਸ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਹੈ, ਜਿਸਨੂੰ ਬਾਅਦ ਵਿੱਚ ਹਰ ਤਰ੍ਹਾਂ ਦੀਆਂ ਦਿਲਚਸਪ ਤਕਨੀਕਾਂ ਨਾਲ "ਕਵਰ" ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਪ੍ਰੋਜੈਕਟ ਲਈ ਮੁੱਖ ਲੋੜ ਅਸਲ ਸਿਸਟਮ ਦੀ ਵੱਧ ਤੋਂ ਵੱਧ ਕਾਰਜਸ਼ੀਲ ਨੇੜਤਾ ਹੈ.

ਸ਼ੁਰੂ ਵਿੱਚ, ਮੈਂ ਪ੍ਰੋਜੈਕਟ ਦੀ ਰਚਨਾ ਨੂੰ ਕਈ ਪੜਾਵਾਂ ਵਿੱਚ ਤੋੜ ਦਿੱਤਾ:

1. ਦੋ ਸੇਵਾਵਾਂ ਬਣਾਓ - 'ਬੈਕਐਂਡ' (ਬੈਕਐਂਡ) ਅਤੇ 'ਗੇਟਵੇਅ' (ਗੇਟਵੇ), ਉਹਨਾਂ ਨੂੰ ਡੌਕਰ ਚਿੱਤਰਾਂ ਵਿੱਚ ਪੈਕ ਕਰੋ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਇਕੱਠੇ ਕੰਮ ਕਰਨ ਲਈ ਸੈੱਟ ਕਰੋ

   ਕੀਵਰਡ: ਜਾਵਾ 11, ਸਪਰਿੰਗ ਬੂਟ, ਡੌਕਰ, ਚਿੱਤਰ ਅਨੁਕੂਲਤਾ

2. ਗੂਗਲ ਕੁਬਰਨੇਟਸ ਇੰਜਣ ਵਿੱਚ ਕੁਬਰਨੇਟਸ ਕੌਂਫਿਗਰੇਸ਼ਨ ਅਤੇ ਸਿਸਟਮ ਡਿਪਲਾਇਮੈਂਟ ਦਾ ਵਿਕਾਸ

   ਕੀਵਰਡਸ: ਕੁਬਰਨੇਟਸ, ਜੀਕੇਈ, ਸਰੋਤ ਪ੍ਰਬੰਧਨ, ਆਟੋਸਕੇਲਿੰਗ, ਸੀਕਰੇਟਸ

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). ਇਸ ਨੂੰ ਠੀਕ ਕਰਨ ਲਈ, ਸੇਵਾਵਾਂ ਨੂੰ ਇੱਕ ਨੈੱਟਵਰਕ ਵਿੱਚ ਜੋੜਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ, ਅਤੇ ਸਿਰਫ਼ ਗੇਟਵੇ ਨੂੰ ਬਾਹਰੋਂ "ਸਟਿੱਕ ਆਊਟ" ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।
ਨਾਲ ਹੀ, ਦੋਵੇਂ ਸੇਵਾਵਾਂ ਇੱਕ ਫਾਈਲ ਸਿਸਟਮ ਨੂੰ ਸਾਂਝਾ ਕਰਦੀਆਂ ਹਨ, ਸਟ੍ਰੀਮ ਪੈਦਾ ਕਰਦੀਆਂ ਹਨ ਅਤੇ ਇੱਕ ਪਲ 'ਤੇ ਇੱਕ ਦੂਜੇ ਨਾਲ ਦਖਲ ਦੇਣਾ ਸ਼ੁਰੂ ਕਰ ਸਕਦੀਆਂ ਹਨ। ਸਾਡੀਆਂ ਮਾਈਕ੍ਰੋਸੇਵਾਵਾਂ ਨੂੰ ਅਲੱਗ ਕਰਨਾ ਚੰਗਾ ਹੋਵੇਗਾ। ਇਹ ਵੱਖ-ਵੱਖ ਮਸ਼ੀਨਾਂ (ਬਹੁਤ ਸਾਰਾ ਪੈਸਾ, ਮੁਸ਼ਕਲ) 'ਤੇ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਵੰਡ ਕੇ, ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ (ਸਰੋਤ ਦੀ ਤੀਬਰ, ਲੰਬੀ ਸ਼ੁਰੂਆਤ), ਜਾਂ ਕੰਟੇਨਰਾਈਜ਼ੇਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਜਿਵੇਂ ਕਿ ਉਮੀਦ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਅਸੀਂ ਤੀਜਾ ਵਿਕਲਪ ਚੁਣਦੇ ਹਾਂ ਅਤੇ ਡੌਕਰ ਕੰਟੇਨਰਾਈਜ਼ੇਸ਼ਨ ਲਈ ਇੱਕ ਸਾਧਨ ਵਜੋਂ.

ਡੌਕਰ

ਸੰਖੇਪ ਵਿੱਚ, ਡੌਕਰ ਅਲੱਗ-ਥਲੱਗ ਕੰਟੇਨਰ ਬਣਾਉਂਦਾ ਹੈ, ਪ੍ਰਤੀ ਐਪਲੀਕੇਸ਼ਨ ਇੱਕ। ਡੌਕਰ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਇੱਕ ਡੌਕਰਫਾਈਲ ਲਿਖਣ ਦੀ ਲੋੜ ਹੈ - ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਣ ਅਤੇ ਚਲਾਉਣ ਲਈ ਨਿਰਦੇਸ਼। ਅੱਗੇ, ਤੁਸੀਂ ਚਿੱਤਰ ਬਣਾ ਸਕਦੇ ਹੋ, ਇਸਨੂੰ ਚਿੱਤਰ ਰਜਿਸਟਰੀ (ਨੰ. ਡੌਕਰਹੱਬ) ਅਤੇ ਆਪਣੀ ਮਾਈਕ੍ਰੋਸਰਵਿਸ ਨੂੰ ਇੱਕ ਕਮਾਂਡ ਵਿੱਚ ਕਿਸੇ ਵੀ ਡੌਕਰਾਈਜ਼ਡ ਵਾਤਾਵਰਣ ਵਿੱਚ ਤੈਨਾਤ ਕਰੋ।

ਡੌਕਰਫਾਈਲ

ਇੱਕ ਚਿੱਤਰ ਦੀ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚੋਂ ਇੱਕ ਇਸਦਾ ਆਕਾਰ ਹੈ. ਇੱਕ ਸੰਖੇਪ ਚਿੱਤਰ ਇੱਕ ਰਿਮੋਟ ਰਿਪੋਜ਼ਟਰੀ ਤੋਂ ਤੇਜ਼ੀ ਨਾਲ ਡਾਊਨਲੋਡ ਕਰੇਗਾ, ਘੱਟ ਥਾਂ ਲਵੇਗਾ, ਅਤੇ ਤੁਹਾਡੀ ਸੇਵਾ ਤੇਜ਼ੀ ਨਾਲ ਸ਼ੁਰੂ ਹੋ ਜਾਵੇਗੀ। ਕੋਈ ਵੀ ਚਿੱਤਰ ਅਧਾਰ ਚਿੱਤਰ ਦੇ ਅਧਾਰ 'ਤੇ ਬਣਾਇਆ ਗਿਆ ਹੈ, ਅਤੇ ਸਭ ਤੋਂ ਘੱਟ ਵਿਕਲਪ ਚੁਣਨ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ. ਇੱਕ ਵਧੀਆ ਵਿਕਲਪ ਐਲਪਾਈਨ ਹੈ, ਘੱਟੋ-ਘੱਟ ਪੈਕੇਜਾਂ ਦੇ ਨਾਲ ਇੱਕ ਸੰਪੂਰਨ ਲੀਨਕਸ ਵੰਡ।

ਪਹਿਲਾਂ, ਆਓ ਇੱਕ ਡੌਕਰਫਾਈਲ "ਮੱਥੇ ਉੱਤੇ" ਲਿਖਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ (ਮੈਂ ਤੁਰੰਤ ਕਹਾਂਗਾ ਕਿ ਇਹ ਇੱਕ ਬੁਰਾ ਤਰੀਕਾ ਹੈ, ਅਜਿਹਾ ਨਾ ਕਰੋ):

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 ਉੱਤੇ ਕਬਜ਼ਾ ਕੀਤਾ ਹੈ)। ਅਤੇ ਇਹ ਸਭ ਇਸ ਤੱਥ ਦੇ ਬਾਵਜੂਦ ਕਿ ਸਾਡੇ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਕਲਾਸਾਂ ਇੱਕ ਉਂਗਲੀ 'ਤੇ ਗਿਣੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ. ਸਾਡੇ ਚਿੱਤਰ ਦੇ ਆਕਾਰ ਨੂੰ ਘਟਾਉਣ ਲਈ:

• ਅਸੀਂ ਮਲਟੀ-ਸਟੈਪ ਅਸੈਂਬਲੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ। ਪਹਿਲੇ ਪੜਾਅ ਵਿੱਚ ਅਸੀਂ ਪ੍ਰੋਜੈਕਟ ਦਾ ਨਿਰਮਾਣ ਕਰਾਂਗੇ, ਦੂਜੇ ਪੜਾਅ ਵਿੱਚ ਅਸੀਂ ਜੇਆਰਈ ਨੂੰ ਸਥਾਪਿਤ ਕਰਾਂਗੇ, ਅਤੇ ਤੀਜੇ ਪੜਾਅ ਵਿੱਚ ਅਸੀਂ ਇਸਨੂੰ ਇੱਕ ਨਵੀਂ ਸਾਫ਼ ਅਲਪਾਈਨ ਚਿੱਤਰ ਵਿੱਚ ਕਾਪੀ ਕਰਾਂਗੇ। ਕੁੱਲ ਮਿਲਾ ਕੇ, ਸਿਰਫ ਲੋੜੀਂਦੇ ਹਿੱਸੇ ਫਾਈਨਲ ਚਿੱਤਰ ਵਿੱਚ ਹੋਣਗੇ.
• ਆਉ ਜਾਵਾ ਦੇ ਮਾਡਿਊਲਰਾਈਜ਼ੇਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੀਏ। 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 ਵਿਕਲਪਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ ਜੋ ਸਪਰਿੰਗ ਦੁਆਰਾ ਆਪਣੇ ਆਪ ਪੜ੍ਹੇ ਜਾਣਗੇ ਅਤੇ application.properties ਤੋਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਓਵਰਰਾਈਡ ਕਰਨਗੇ।

ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਕਾਲ ਕਰਦੇ ਹਾਂ http://localhost/ ਅਤੇ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਸਭ ਕੁਝ ਕੰਮ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਪਿਛਲੇ ਕੇਸ ਵਿੱਚ।

ਸਿੱਟਾ

ਨਤੀਜੇ ਵਜੋਂ, ਅਸੀਂ ਦੋ ਸਧਾਰਨ ਮਾਈਕ੍ਰੋ ਸਰਵਿਸਿਜ਼ ਬਣਾਏ, ਉਹਨਾਂ ਨੂੰ ਡੌਕਰ ਕੰਟੇਨਰਾਂ ਵਿੱਚ ਪੈਕ ਕੀਤਾ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਇੱਕੋ ਮਸ਼ੀਨ 'ਤੇ ਇਕੱਠੇ ਲਾਂਚ ਕੀਤਾ। ਨਤੀਜੇ ਵਜੋਂ ਸਿਸਟਮ ਦੇ, ਹਾਲਾਂਕਿ, ਕਈ ਨੁਕਸਾਨ ਹਨ:

• ਮਾੜੀ ਨੁਕਸ ਸਹਿਣਸ਼ੀਲਤਾ - ਇੱਕ ਸਰਵਰ 'ਤੇ ਸਾਡੇ ਲਈ ਸਭ ਕੁਝ ਕੰਮ ਕਰਦਾ ਹੈ
• ਮਾੜੀ ਮਾਪਯੋਗਤਾ - ਜਦੋਂ ਲੋਡ ਵਧਦਾ ਹੈ, ਤਾਂ ਆਪਣੇ ਆਪ ਵਾਧੂ ਸੇਵਾ ਉਦਾਹਰਨਾਂ ਨੂੰ ਤੈਨਾਤ ਕਰਨਾ ਅਤੇ ਉਹਨਾਂ ਵਿਚਕਾਰ ਲੋਡ ਨੂੰ ਸੰਤੁਲਿਤ ਕਰਨਾ ਚੰਗਾ ਹੋਵੇਗਾ
• ਲਾਂਚ ਦੀ ਗੁੰਝਲਤਾ - ਸਾਨੂੰ ਘੱਟੋ ਘੱਟ 3 ਕਮਾਂਡਾਂ ਦਾਖਲ ਕਰਨ ਦੀ ਲੋੜ ਸੀ, ਅਤੇ ਕੁਝ ਮਾਪਦੰਡਾਂ ਦੇ ਨਾਲ (ਇਹ ਸਿਰਫ 2 ਸੇਵਾਵਾਂ ਲਈ ਹੈ)

ਉਪਰੋਕਤ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ, ਬਹੁਤ ਸਾਰੇ ਹੱਲ ਹਨ ਜਿਵੇਂ ਕਿ ਡੌਕਰ ਸਵੈਰਮ, ਨੋਮੈਡ, ਕੁਬਰਨੇਟਸ ਜਾਂ ਓਪਨਸ਼ਿਫਟ। ਜੇ ਸਾਰਾ ਸਿਸਟਮ ਜਾਵਾ ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਸਪਰਿੰਗ ਕਲਾਉਡ (ਚੰਗਾ ਲੇਖ).

В ਅਗਲਾ ਭਾਗ ਮੈਂ ਇਸ ਬਾਰੇ ਗੱਲ ਕਰਾਂਗਾ ਕਿ ਮੈਂ ਕੁਬਰਨੇਟਸ ਨੂੰ ਕਿਵੇਂ ਸੈਟ ਅਪ ਕੀਤਾ ਅਤੇ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਗੂਗਲ ਕੁਬਰਨੇਟਸ ਇੰਜਨ 'ਤੇ ਤੈਨਾਤ ਕੀਤਾ।

ਸਰੋਤ: www.habr.com