ស្វែងយល់ពីរបៀបដាក់ឱ្យប្រើប្រាស់សេវាមីក្រូ។ ផ្នែកទី 1. Spring Boot និង Docker

ហេ ហាប់

នៅក្នុងអត្ថបទនេះ ខ្ញុំចង់និយាយអំពីបទពិសោធន៍របស់ខ្ញុំក្នុងការបង្កើតបរិយាកាសសិក្សាសម្រាប់ការពិសោធន៍ជាមួយមីក្រូសឺវីស។ នៅពេលខ្ញុំរៀនឧបករណ៍ថ្មីនីមួយៗ ខ្ញុំតែងតែចង់សាកល្បងវាមិនត្រឹមតែនៅលើម៉ាស៊ីនក្នុងស្រុកប៉ុណ្ណោះទេ ប៉ុន្តែថែមទាំងនៅក្នុងលក្ខខណ្ឌជាក់ស្តែងថែមទៀត។ ដូច្នេះហើយ ខ្ញុំបានសម្រេចចិត្តបង្កើតកម្មវិធី microservice សាមញ្ញមួយ ដែលក្រោយមកអាចត្រូវបាន "គ្របដណ្តប់" ជាមួយនឹងគ្រប់ប្រភេទនៃបច្ចេកវិទ្យាគួរឱ្យចាប់អារម្មណ៍។ តម្រូវការចម្បងសម្រាប់គម្រោងគឺភាពជិតមុខងារអតិបរមារបស់វាទៅនឹងប្រព័ន្ធពិត។

ជាដំបូង ខ្ញុំបានបែងចែកការបង្កើតគម្រោងជាជំហានៗជាច្រើន៖

1. បង្កើតសេវាកម្មពីរ - 'backend' (backend) និង 'gateway' (gateway) ខ្ចប់វាទៅក្នុងរូបភាព docker ហើយកំណត់ពួកវាឱ្យដំណើរការជាមួយគ្នា

   ពាក្យគន្លឹះ៖ Java 11, Spring Boot, Docker, ការបង្កើនប្រសិទ្ធភាពរូបភាព

2. ការអភិវឌ្ឍនៃការកំណត់រចនាសម្ព័ន្ធ Kubernetes និងការដាក់ឱ្យប្រើប្រាស់ប្រព័ន្ធនៅក្នុង Google Kubernetes Engine

   ពាក្យគន្លឹះ៖ Kubernetes, GKE, ការគ្រប់គ្រងធនធាន, ការធ្វើមាត្រដ្ឋានដោយស្វ័យប្រវត្តិ, អាថ៌កំបាំង

3. បង្កើតតារាងដោយប្រើ Helm 3 សម្រាប់ការគ្រប់គ្រងចង្កោមកាន់តែមានប្រសិទ្ធភាព

   ស្លាក: Helm 3, ការដាក់ពង្រាយគំនូសតាង

4. ការដំឡើង Jenkins និងបំពង់សម្រាប់បញ្ជូនកូដដោយស្វ័យប្រវត្តិទៅចង្កោម

   ពាក្យគន្លឹះ៖ ការកំណត់រចនាសម្ព័ន្ធ Jenkins កម្មវិធីជំនួយ ឃ្លាំងកំណត់រចនាសម្ព័ន្ធដាច់ដោយឡែក

ខ្ញុំគ្រោងនឹងលះបង់អត្ថបទដាច់ដោយឡែកមួយទៅជំហាននីមួយៗ។

ការផ្តោតអារម្មណ៍នៃអត្ថបទស៊េរីនេះ មិនមែនជារបៀបសរសេរសេវាមីក្រូទេ ប៉ុន្តែរបៀបធ្វើឱ្យពួកវាដំណើរការក្នុងប្រព័ន្ធតែមួយ។ ទោះបីជារឿងទាំងអស់នេះជាធម្មតានៅខាងក្រៅការទទួលខុសត្រូវរបស់អ្នកអភិវឌ្ឍន៍ក៏ដោយ ខ្ញុំគិតថាវានៅតែមានប្រយោជន៍ក្នុងការស្គាល់ពួកគេយ៉ាងហោចណាស់ 20% (ដែលដូចដែលអ្នកបានដឹងហើយថា 80% នៃលទ្ធផល)។ ប្រធានបទសំខាន់ៗមួយចំនួនដោយគ្មានលក្ខខណ្ឌ ដូចជាសុវត្ថិភាព នឹងត្រូវបានទុកចោលពីគម្រោងនេះ ដោយសារអ្នកនិពន្ធយល់តិចតួចអំពីប្រព័ន្ធនេះត្រូវបានបង្កើតឡើងសម្រាប់តែការប្រើប្រាស់ផ្ទាល់ខ្លួនប៉ុណ្ណោះ។ ខ្ញុំស្វាគមន៍រាល់មតិយោបល់ និងការរិះគន់ក្នុងន័យស្ថាបនា។

ការបង្កើតសេវាកម្មមីក្រូ

សេវាកម្មត្រូវបានសរសេរនៅក្នុង Java 11 ដោយប្រើ Spring Boot ។ អន្តរសេវាកម្មត្រូវបានរៀបចំដោយប្រើ REST ។ គម្រោងនេះនឹងរួមបញ្ចូលចំនួនអប្បបរមានៃការធ្វើតេស្ត (ដូច្នេះនៅពេលក្រោយមានអ្វីដែលត្រូវសាកល្បងនៅក្នុង Jenkins) ។ កូដប្រភពសម្រាប់សេវាកម្មមាននៅលើ GitHub៖ ផ្នែកខាងក្រោយ и ច្រកផ្លូវ.

ដើម្បីអាចពិនិត្យមើលស្ថានភាពនៃសេវាកម្មនីមួយៗនោះ Spring Actuator ត្រូវបានបន្ថែមទៅភាពអាស្រ័យរបស់ពួកគេ។ វានឹងបង្កើតចំណុចបញ្ចប់ / actuator/health ហើយនឹងត្រឡប់ស្ថានភាព 200 ប្រសិនបើសេវាកម្មរួចរាល់ដើម្បីទទួលយកចរាចរណ៍ ឬ 504 ក្នុងករណីមានបញ្ហា។ ក្នុងករណីនេះ នេះគឺជាការឆែកឆេរប្រឌិតជាង ចាប់តាំងពីសេវាគឺសាមញ្ញណាស់ ហើយនៅក្រោមប្រភេទនៃមហាអំណាចមួយចំនួន ពួកវាទំនងជាមិនអាចប្រើបានទាំងស្រុងជាជាងនៅតែដំណើរការដោយផ្នែក។ ប៉ុន្តែនៅក្នុងប្រព័ន្ធពិត Actuator អាចជួយធ្វើរោគវិនិច្ឆ័យបញ្ហាមួយ មុនពេលអ្នកប្រើប្រាស់ចាប់ផ្តើមចុចទៅលើវា។ ឧទាហរណ៍ ប្រសិនបើបញ្ហាកើតឡើងជាមួយនឹងការចូលទៅកាន់មូលដ្ឋានទិន្នន័យ យើងអាចឆ្លើយតបដោយស្វ័យប្រវត្តិចំពោះបញ្ហានេះដោយបញ្ឈប់ការដំណើរការសំណើជាមួយនឹងឧទាហរណ៍ដែលខូចនៃសេវាកម្ម។

សេវាកម្មផ្នែកខាងក្រោយ

សេវាកម្ម backend នឹងគ្រាន់តែរាប់ និងត្រឡប់ចំនួនសំណើដែលបានទទួលយក។

លេខកូដឧបករណ៍បញ្ជា៖

@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 ដោយបន្ថែមវាជាមួយនឹងព័ត៌មានខាងក្រោម៖

• លេខសម្គាល់ច្រកផ្លូវ។ វាត្រូវការជាចាំបាច់ដើម្បីឱ្យវាអាចបែងចែកឧទាហរណ៍មួយនៃច្រកផ្លូវចេញពីមួយផ្សេងទៀតដោយការឆ្លើយតបរបស់ម៉ាស៊ីនមេ
• "អាថ៌កំបាំង" ជាក់លាក់ដែលនឹងដើរតួនាទីនៃពាក្យសម្ងាត់សំខាន់ខ្លាំងណាស់ (លេខគន្លឹះសម្រាប់ការអ៊ិនគ្រីបខូគីដ៏សំខាន់)

ការកំណត់រចនាសម្ព័ន្ធនៅក្នុង 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) ដើម្បីដោះស្រាយបញ្ហានេះ សេវាកម្មត្រូវតែរួមបញ្ចូលគ្នាទៅក្នុងបណ្តាញតែមួយ ហើយមានតែច្រកចេញចូលប៉ុណ្ណោះដែលគួរតែ "បិទ" នៅខាងក្រៅ។
ដូចគ្នានេះផងដែរ សេវាទាំងពីរចែករំលែកប្រព័ន្ធឯកសារតែមួយ បង្កើតស្ទ្រីម ហើយនៅពេលតែមួយអាចចាប់ផ្តើមជ្រៀតជ្រែកគ្នាទៅវិញទៅមក។ វាជាការប្រសើរណាស់ក្នុងការញែកសេវាកម្មមីក្រូរបស់យើង។ នេះអាចសម្រេចបានដោយការចែកចាយកម្មវិធីនៅលើម៉ាស៊ីនផ្សេងៗគ្នា (លុយច្រើន ពិបាក) ដោយប្រើម៉ាស៊ីននិម្មិត (ប្រើធនធានច្រើន ការចាប់ផ្តើមយូរ) ឬប្រើកុងតឺន័រ។ ដូចដែលបានរំពឹងទុកយើងជ្រើសរើសជម្រើសទីបីនិង Dockers ជាឧបករណ៍សម្រាប់កុងតឺន័រ។

Dockers

សរុបមក Docker បង្កើតធុងដាច់ដោយឡែក មួយក្នុងមួយកម្មវិធី។ ដើម្បីប្រើ Docker អ្នកត្រូវសរសេរ Dockerfile - ការណែនាំសម្រាប់បង្កើត និងដំណើរការកម្មវិធី។ បន្ទាប់​មក អ្នក​អាច​បង្កើត​រូបភាព ផ្ទុក​ឡើង​ទៅ​ក្នុង​បញ្ជី​ឈ្មោះ​រូបភាព (No. Dockerhub) និងដាក់ពង្រាយសេវាមីក្រូរបស់អ្នកនៅក្នុងបរិយាកាស dockered ណាមួយនៅក្នុងពាក្យបញ្ជាមួយ។

Dockerfile

លក្ខណៈសំខាន់បំផុតមួយនៃរូបភាពគឺទំហំរបស់វា។ រូបភាពបង្រួមនឹងទាញយកលឿនជាងមុនពីឃ្លាំងពីចម្ងាយ ប្រើទំហំតិច ហើយសេវាកម្មរបស់អ្នកនឹងចាប់ផ្តើមលឿនជាងមុន។ រូបភាពណាមួយត្រូវបានបង្កើតឡើងដោយផ្អែកលើរូបភាពជាមូលដ្ឋាន ហើយវាត្រូវបានណែនាំឱ្យជ្រើសរើសជម្រើសតិចតួចបំផុត។ ជម្រើសដ៏ល្អមួយគឺ Alpine ដែលជាការចែកចាយលីនុចពេញលេញជាមួយនឹងកញ្ចប់អប្បបរមា។

ដើម្បីចាប់ផ្តើម ចូរយើងព្យាយាមសរសេរ 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) ហើយចាប់ផ្តើមការស្ថាបនា។ ពាក្យបញ្ជា EXPOSE 8080 ផ្តល់សញ្ញាដល់ docker ថាកម្មវិធីនៅក្នុងកុងតឺន័រនឹងប្រើច្រក 8080 របស់វា (វានឹងមិនធ្វើឱ្យកម្មវិធីអាចចូលប្រើបានពីខាងក្រៅទេ ប៉ុន្តែនឹងអនុញ្ញាតឱ្យកម្មវិធីអាចចូលប្រើបាន ឧទាហរណ៍ ពីកុងតឺន័រផ្សេងទៀតនៅលើបណ្តាញ docker ដូចគ្នា )

ដើម្បីវេចខ្ចប់សេវាកម្មទៅជារូបភាព អ្នកត្រូវដំណើរការពាក្យបញ្ជាពី root នៃគម្រោងនីមួយៗ៖

docker image build . -t msvc-backend:1.0.0

លទ្ធផលគឺរូបភាព 456 MB (ដែលរូបភាព JDK មូលដ្ឋានកាន់កាប់ 340 MB) ។ ហើយទាំងអស់បើទោះបីជាការពិតដែលថាថ្នាក់នៅក្នុងគម្រោងរបស់យើងអាចត្រូវបានរាប់នៅលើម្រាមដៃមួយ។ ដើម្បីកាត់បន្ថយទំហំរូបភាពរបស់យើង៖

• យើងប្រើការផ្គុំពហុជំហាន។ នៅក្នុងជំហានដំបូង យើងនឹងប្រមូលផ្តុំគម្រោង ហើយនៅក្នុងទីពីរ យើងនឹងដំឡើង JRE ហើយក្នុងជំហានទីបី យើងនឹងចម្លងទាំងអស់នេះទៅជារូបភាពអាល់ផែនថ្មីស្អាត។ សរុបមក រូបភាពចុងក្រោយនឹងមានតែសមាសធាតុចាំបាច់ប៉ុណ្ណោះ។
• ចូរយើងប្រើ modularization នៃ java ។ ចាប់ផ្តើមជាមួយ Java 9 អ្នកអាចប្រើឧបករណ៍ jlink ដើម្បីបង្កើត JRE ពីម៉ូឌុលដែលអ្នកត្រូវការ

សម្រាប់អ្នកដែលចង់ដឹងចង់ឃើញ ខាងក្រោមនេះគឺជាអត្ថបទដ៏ល្អមួយស្តីពីវិធីសាស្រ្តកាត់បន្ថយរូបភាព។ https://habr.com/ru/company/ruvds/blog/485650/.

Dockerfile ចុងក្រោយ៖

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

ដើម្បីចាប់ផ្តើម សេវាកម្មរបស់យើងត្រូវតែស្ថិតនៅលើបណ្តាញតែមួយ។ មានបណ្តាញជាច្រើនប្រភេទនៅក្នុង docker ហើយយើងប្រើជាបឋមបំផុតនៃពួកវា - ស្ពាន ដែលអនុញ្ញាតឱ្យអ្នកបណ្តាញកុងតឺន័រដំណើរការលើម៉ាស៊ីនតែមួយ។ បង្កើតបណ្តាញដោយប្រើពាក្យបញ្ជាខាងក្រោម៖

docker network create msvc-network

បន្ទាប់មក ចាប់ផ្តើមកុងតឺន័រផ្នែកខាងក្រោយដែលមានឈ្មោះថា 'backend' ជាមួយនឹងរូបភាព microservices-backend: 1.0.0៖

docker run -dit --name backend --network msvc-net microservices-backend:1.0.0

វាគួរឱ្យកត់សម្គាល់ថាបណ្តាញស្ពានផ្តល់នូវការរកឃើញសេវាកម្មប្រអប់សម្រាប់កុងតឺន័រតាមឈ្មោះរបស់ពួកគេ។ នោះគឺសេវាកម្ម backend នឹងមាននៅក្នុងបណ្តាញ docker នៅ 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/ ហើយត្រូវប្រាកដថាអ្វីៗដំណើរការដូចករណីមុនដែរ។

សេចក្តីសន្និដ្ឋាន

ជាលទ្ធផល យើងបានបង្កើត microservices សាមញ្ញចំនួនពីរ ដោយខ្ចប់វានៅក្នុង docker containers ហើយដាក់ឱ្យដំណើរការវាជាមួយគ្នានៅលើម៉ាស៊ីនតែមួយ។ ទោះយ៉ាងណា ប្រព័ន្ធលទ្ធផលមានគុណវិបត្តិមួយចំនួន៖

• ការអត់ឱនចំពោះកំហុសមិនល្អ - អ្វីៗដំណើរការសម្រាប់យើងនៅលើម៉ាស៊ីនមេតែមួយ
• ការធ្វើមាត្រដ្ឋានមិនល្អ - នៅពេលដែលការផ្ទុកកើនឡើង វាជាការប្រសើរណាស់ក្នុងការដាក់ឱ្យប្រើប្រាស់សេវាកម្មបន្ថែមដោយស្វ័យប្រវត្តិ និងធ្វើឱ្យមានតុល្យភាពរវាងបន្ទុករវាងពួកវា។
• ភាពស្មុគស្មាញនៃការចាប់ផ្តើម - យើងត្រូវបញ្ចូលពាក្យបញ្ជាយ៉ាងហោចណាស់ 3 ហើយជាមួយនឹងប៉ារ៉ាម៉ែត្រជាក់លាក់ (នេះគឺសម្រាប់តែសេវាកម្ម 2 ប៉ុណ្ណោះ)

ដើម្បីដោះស្រាយបញ្ហាខាងលើ មានដំណោះស្រាយមួយចំនួនដូចជា Docker Swarm, Nomad, Kubernetes ឬ OpenShift ។ ប្រសិនបើប្រព័ន្ធទាំងមូលត្រូវបានសរសេរជា Java អ្នកអាចមើលទៅ Spring Cloud (អត្ថបទល្អ។).

В ផ្នែកបន្ទាប់ ខ្ញុំនឹងនិយាយអំពីរបៀបដែលខ្ញុំរៀបចំ Kubernetes និងដាក់ពង្រាយគម្រោងនេះទៅ Google Kubernetes Engine។

ប្រភព: www.habr.com