ಕ್ಷಮಿಸಿ, OpenShift, ನಾವು ನಿಮ್ಮನ್ನು ಸಾಕಷ್ಟು ಪ್ರಶಂಸಿಸಲಿಲ್ಲ ಮತ್ತು ನಿಮ್ಮನ್ನು ಲಘುವಾಗಿ ಪರಿಗಣಿಸಿದ್ದೇವೆ

ಈ ಪೋಸ್ಟ್ ಅನ್ನು ಬರೆಯಲಾಗಿದೆ ಏಕೆಂದರೆ ನಮ್ಮ ಉದ್ಯೋಗಿಗಳು ಕ್ಲೈಂಟ್‌ಗಳೊಂದಿಗೆ ಕುಬರ್ನೆಟ್ಸ್‌ನಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್ ಡೆವಲಪ್‌ಮೆಂಟ್ ಮತ್ತು ಓಪನ್‌ಶಿಫ್ಟ್‌ನಲ್ಲಿ ಅಂತಹ ಅಭಿವೃದ್ಧಿಯ ವಿಶೇಷತೆಗಳ ಕುರಿತು ಸಾಕಷ್ಟು ಸಂಭಾಷಣೆಗಳನ್ನು ನಡೆಸಿದ್ದಾರೆ.

ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ಕುಬರ್ನೆಟ್ಸ್ ಕೇವಲ ಕುಬರ್ನೆಟ್ಸ್ ಎಂಬ ಪ್ರಬಂಧದೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ ಮತ್ತು OpenShift ಈಗಾಗಲೇ ಮೈಕ್ರೋಸಾಫ್ಟ್ AKS ಅಥವಾ Amazon EKS ನಂತಹ ಕುಬರ್ನೆಟ್ಸ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಆಗಿದೆ. ಈ ಪ್ರತಿಯೊಂದು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳು ತನ್ನದೇ ಆದ ಅನುಕೂಲಗಳನ್ನು ಹೊಂದಿವೆ, ನಿರ್ದಿಷ್ಟ ಗುರಿ ಪ್ರೇಕ್ಷಕರನ್ನು ಗುರಿಯಾಗಿರಿಸಿಕೊಳ್ಳುತ್ತವೆ. ಮತ್ತು ಇದರ ನಂತರ, ಸಂಭಾಷಣೆಯು ನಿರ್ದಿಷ್ಟ ವೇದಿಕೆಗಳ ಸಾಮರ್ಥ್ಯ ಮತ್ತು ದೌರ್ಬಲ್ಯಗಳನ್ನು ಹೋಲಿಸಲು ತಿರುಗುತ್ತದೆ.

ಸಾಮಾನ್ಯವಾಗಿ, ನಾವು ಈ ಪೋಸ್ಟ್ ಅನ್ನು "ಕೇಳಿರಿ, ಓಪನ್‌ಶಿಫ್ಟ್‌ನಲ್ಲಿ ಅಥವಾ ಎಕೆಎಸ್‌ನಲ್ಲಿ, ಇಕೆಎಸ್‌ನಲ್ಲಿ, ಕೆಲವು ಕಸ್ಟಮ್ ಕುಬರ್ನೆಟ್‌ಗಳಲ್ಲಿ ಅಥವಾ ಯಾವುದೇ ಕುಬರ್ನೆಟ್‌ಗಳಲ್ಲಿ ಕೋಡ್ ಅನ್ನು ಎಲ್ಲಿ ರನ್ ಮಾಡಬೇಕು ಎಂಬುದು ಮುಖ್ಯವಲ್ಲ. (ಸಂಕ್ಷಿಪ್ತತೆಗಾಗಿ ಇದನ್ನು KUK ಎಂದು ಕರೆಯೋಣ) "ಇದು ನಿಜವಾಗಿಯೂ ಸರಳವಾಗಿದೆ, ಅಲ್ಲಿ ಮತ್ತು ಅಲ್ಲಿ ಎರಡೂ."

ನಂತರ ನಾವು ಸರಳವಾದ "ಹಲೋ ವರ್ಲ್ಡ್" ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ಯೋಜಿಸಿದ್ದೇವೆ ಮತ್ತು KUC ಮತ್ತು Red Hat OpenShift ಕಂಟೈನರ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ (ಇನ್ನು ಮುಂದೆ, OCP ಅಥವಾ ಸರಳವಾಗಿ OpenShift) ನಡುವಿನ ವ್ಯತ್ಯಾಸವೇನು ಎಂಬುದನ್ನು ತೋರಿಸಲು ಅದರ ಉದಾಹರಣೆಯನ್ನು ಬಳಸುತ್ತೇವೆ.

ಆದಾಗ್ಯೂ, ನಾವು ಈ ಪೋಸ್ಟ್ ಅನ್ನು ಬರೆದಂತೆ, ನಾವು ಇಷ್ಟು ದಿನ OpenShift ಅನ್ನು ಬಳಸುತ್ತಿದ್ದೇವೆ ಎಂದು ನಾವು ಅರಿತುಕೊಂಡಿದ್ದೇವೆ, ಅದು ಹೇಗೆ ಬೆಳೆದಿದೆ ಮತ್ತು ಅದ್ಭುತವಾದ ವೇದಿಕೆಯಾಗಿ ಮಾರ್ಪಟ್ಟಿದೆ ಎಂದು ನಮಗೆ ತಿಳಿದಿರಲಿಲ್ಲ, ಅದು ಕೇವಲ ಕುಬರ್ನೆಟ್ ವಿತರಣೆಗಿಂತ ಹೆಚ್ಚಾಯಿತು. ನಾವು OpenShift ನ ಪ್ರಬುದ್ಧತೆ ಮತ್ತು ಸರಳತೆಯನ್ನು ಲಘುವಾಗಿ ಪರಿಗಣಿಸುತ್ತೇವೆ ಮತ್ತು ಅದರ ತೇಜಸ್ಸಿನ ದೃಷ್ಟಿ ಕಳೆದುಕೊಳ್ಳುತ್ತೇವೆ.

ಸಾಮಾನ್ಯವಾಗಿ, ಸಕ್ರಿಯ ಪಶ್ಚಾತ್ತಾಪದ ಸಮಯ ಬಂದಿದೆ, ಮತ್ತು ಈಗ ನಾವು KUK ಮತ್ತು ಓಪನ್‌ಶಿಫ್ಟ್‌ನಲ್ಲಿ ನಮ್ಮ “ಹಲೋ ವರ್ಲ್ಡ್” ಕಾರ್ಯಾರಂಭವನ್ನು ಹಂತ ಹಂತವಾಗಿ ಹೋಲಿಸುತ್ತೇವೆ ಮತ್ತು ನಾವು ಇದನ್ನು ಸಾಧ್ಯವಾದಷ್ಟು ವಸ್ತುನಿಷ್ಠವಾಗಿ ಮಾಡುತ್ತೇವೆ (ಅಲ್ಲದೆ, ಕೆಲವೊಮ್ಮೆ ತೋರಿಸುವುದನ್ನು ಹೊರತುಪಡಿಸಿ ವಿಷಯದ ಬಗ್ಗೆ ವೈಯಕ್ತಿಕ ವರ್ತನೆ). ಈ ವಿಷಯದ ಬಗ್ಗೆ ಸಂಪೂರ್ಣವಾಗಿ ವ್ಯಕ್ತಿನಿಷ್ಠ ಅಭಿಪ್ರಾಯದಲ್ಲಿ ನೀವು ಆಸಕ್ತಿ ಹೊಂದಿದ್ದರೆ, ನೀವು ಅದನ್ನು ಓದಬಹುದು ಇಲ್ಲಿ (EN). ಮತ್ತು ಈ ಪೋಸ್ಟ್‌ನಲ್ಲಿ ನಾವು ಸತ್ಯಗಳಿಗೆ ಮತ್ತು ಸತ್ಯಗಳಿಗೆ ಮಾತ್ರ ಅಂಟಿಕೊಳ್ಳುತ್ತೇವೆ.

ಸಮೂಹಗಳು

ಆದ್ದರಿಂದ, ನಮ್ಮ "ಹಲೋ ವರ್ಲ್ಡ್" ಗೆ ಕ್ಲಸ್ಟರ್‌ಗಳ ಅಗತ್ಯವಿದೆ. ಸರ್ವರ್‌ಗಳು, ರಿಜಿಸ್ಟ್ರಿಗಳು, ನೆಟ್‌ವರ್ಕ್‌ಗಳು, ಡೇಟಾ ವರ್ಗಾವಣೆ ಇತ್ಯಾದಿಗಳಿಗೆ ಪಾವತಿಸದಂತೆ ಯಾವುದೇ ಸಾರ್ವಜನಿಕ ಮೋಡಗಳಿಗೆ ತಕ್ಷಣವೇ "ಇಲ್ಲ" ಎಂದು ಹೇಳೋಣ. ಅಂತೆಯೇ, ನಾವು ಸರಳ ಏಕ-ನೋಡ್ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತೇವೆ ಮಿನಿಕೂಬ್ (KUK ಗಾಗಿ) ಮತ್ತು ಕೋಡ್ ರೆಡಿ ಕಂಟೇನರ್‌ಗಳು (ಓಪನ್‌ಶಿಫ್ಟ್ ಕ್ಲಸ್ಟರ್‌ಗಾಗಿ). ಈ ಎರಡೂ ಆಯ್ಕೆಗಳನ್ನು ಸ್ಥಾಪಿಸಲು ನಿಜವಾಗಿಯೂ ಸುಲಭ, ಆದರೆ ನಿಮ್ಮ ಲ್ಯಾಪ್‌ಟಾಪ್‌ನಲ್ಲಿ ಸಾಕಷ್ಟು ಸಂಪನ್ಮೂಲಗಳ ಅಗತ್ಯವಿರುತ್ತದೆ.

KUK-e ನಲ್ಲಿ ಅಸೆಂಬ್ಲಿ

ಆದ್ದರಿಂದ ಹೋಗೋಣ.

ಹಂತ 1 - ನಮ್ಮ ಕಂಟೇನರ್ ಚಿತ್ರವನ್ನು ನಿರ್ಮಿಸುವುದು

ನಮ್ಮ “ಹಲೋ ವರ್ಲ್ಡ್” ಅನ್ನು ಮಿನಿಕ್ಯೂಬ್‌ಗೆ ನಿಯೋಜಿಸುವ ಮೂಲಕ ಪ್ರಾರಂಭಿಸೋಣ. ಇದನ್ನು ಮಾಡಲು ನಿಮಗೆ ಅಗತ್ಯವಿರುತ್ತದೆ:

1. 1. ಡಾಕರ್ ಅನ್ನು ಸ್ಥಾಪಿಸಲಾಗಿದೆ.
2. 2. Git ಸ್ಥಾಪಿಸಲಾಗಿದೆ.
3. 3. ಸ್ಥಾಪಿಸಲಾದ ಮಾವೆನ್ (ವಾಸ್ತವವಾಗಿ, ಈ ಯೋಜನೆಯು mvnw ಬೈನರಿಯನ್ನು ಬಳಸುತ್ತದೆ, ಆದ್ದರಿಂದ ನೀವು ಅದನ್ನು ಮಾಡದೆಯೇ ಮಾಡಬಹುದು).
4. 4. ವಾಸ್ತವವಾಗಿ, ಮೂಲ ಸ್ವತಃ, ಅಂದರೆ. ರೆಪೊಸಿಟರಿ ಕ್ಲೋನ್ github.com/gcolman/quarkus-hello-world.git

ಕ್ವಾರ್ಕಸ್ ಯೋಜನೆಯನ್ನು ರಚಿಸುವುದು ಮೊದಲ ಹಂತವಾಗಿದೆ. Quarkus.io ನೊಂದಿಗೆ ನೀವು ಎಂದಿಗೂ ಕೆಲಸ ಮಾಡದಿದ್ದರೆ ಗಾಬರಿಯಾಗಬೇಡಿ - ಇದು ಸುಲಭ. ನೀವು ಯೋಜನೆಯಲ್ಲಿ ಬಳಸಲು ಬಯಸುವ ಘಟಕಗಳನ್ನು (ರೆಸ್ಟ್ ಈಸಿ, ಹೈಬರ್ನೇಟ್, ಅಮೆಜಾನ್ SQS, ಒಂಟೆ, ಇತ್ಯಾದಿ) ಆಯ್ಕೆ ಮಾಡಿ, ತದನಂತರ ಕ್ವಾರ್ಕಸ್ ಸ್ವತಃ ನಿಮ್ಮ ಯಾವುದೇ ಭಾಗವಹಿಸುವಿಕೆ ಇಲ್ಲದೆ, ಮೇವೆನ್ ಆರ್ಕಿಟೈಪ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಎಲ್ಲವನ್ನೂ ಗಿಥಬ್‌ನಲ್ಲಿ ಇರಿಸುತ್ತದೆ. ಅಂದರೆ, ಅಕ್ಷರಶಃ ಮೌಸ್ನ ಒಂದು ಕ್ಲಿಕ್ ಮತ್ತು ನೀವು ಮುಗಿಸಿದ್ದೀರಿ. ಇದಕ್ಕಾಗಿಯೇ ನಾವು ಕ್ವಾರ್ಕಸ್ ಅನ್ನು ಪ್ರೀತಿಸುತ್ತೇವೆ.

ನಮ್ಮ "ಹಲೋ ವರ್ಲ್ಡ್" ಅನ್ನು ಕಂಟೇನರ್ ಇಮೇಜ್ ಆಗಿ ನಿರ್ಮಿಸಲು ಸುಲಭವಾದ ಮಾರ್ಗವೆಂದರೆ ಡಾಕರ್‌ಗಾಗಿ ಕ್ವಾರ್ಕಸ್-ಮಾವೆನ್ ವಿಸ್ತರಣೆಗಳನ್ನು ಬಳಸುವುದು, ಇದು ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಕೆಲಸಗಳನ್ನು ಮಾಡುತ್ತದೆ. ಕ್ವಾರ್ಕಸ್ ಆಗಮನದೊಂದಿಗೆ, ಇದು ನಿಜವಾಗಿಯೂ ಸುಲಭ ಮತ್ತು ಸರಳವಾಗಿದೆ: ಕಂಟೇನರ್-ಇಮೇಜ್-ಡಾಕರ್ ವಿಸ್ತರಣೆಯನ್ನು ಸೇರಿಸಿ ಮತ್ತು ನೀವು ಮಾವೆನ್ ಆಜ್ಞೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಚಿತ್ರಗಳನ್ನು ರಚಿಸಬಹುದು.

./mvnw quarkus:add-extension -Dextensions=”container-image-docker”

ಅಂತಿಮವಾಗಿ, ನಾವು ಮಾವೆನ್ ಬಳಸಿ ನಮ್ಮ ಚಿತ್ರವನ್ನು ನಿರ್ಮಿಸುತ್ತೇವೆ. ಪರಿಣಾಮವಾಗಿ, ನಮ್ಮ ಮೂಲ ಕೋಡ್ ಈಗಾಗಲೇ ಕಂಟೇನರ್ ರನ್ಟೈಮ್ ಪರಿಸರದಲ್ಲಿ ರನ್ ಮಾಡಬಹುದಾದ ರೆಡಿಮೇಡ್ ಕಂಟೇನರ್ ಇಮೇಜ್ ಆಗಿ ಬದಲಾಗುತ್ತದೆ.

./mvnw -X clean package -Dquarkus.container-image.build=true

ಅಷ್ಟೆ, ಈಗ ನೀವು ಡಾಕರ್ ರನ್ ಆಜ್ಞೆಯೊಂದಿಗೆ ಕಂಟೇನರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಬಹುದು, ನಮ್ಮ ಸೇವೆಯನ್ನು ಪೋರ್ಟ್ 8080 ಗೆ ಮ್ಯಾಪಿಂಗ್ ಮಾಡಬಹುದು ಇದರಿಂದ ಅದನ್ನು ಪ್ರವೇಶಿಸಬಹುದು.

docker run -i — rm -p 8080:8080 gcolman/quarkus-hello-world

ಕಂಟೇನರ್ ನಿದರ್ಶನವನ್ನು ಪ್ರಾರಂಭಿಸಿದ ನಂತರ, ನಮ್ಮ ಸೇವೆಯು ಚಾಲನೆಯಲ್ಲಿದೆ ಎಂದು ಕರ್ಲ್ ಆಜ್ಞೆಯೊಂದಿಗೆ ಪರಿಶೀಲಿಸುವುದು ಮಾತ್ರ ಉಳಿದಿದೆ:

ಆದ್ದರಿಂದ ಎಲ್ಲವೂ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಮತ್ತು ಇದು ನಿಜವಾಗಿಯೂ ಸುಲಭ ಮತ್ತು ಸರಳವಾಗಿದೆ.

ಹಂತ 2 - ನಮ್ಮ ಕಂಟೇನರ್ ಅನ್ನು ಕಂಟೇನರ್ ಇಮೇಜ್ ರೆಪೊಸಿಟರಿಗೆ ಕಳುಹಿಸಿ

ಸದ್ಯಕ್ಕೆ, ನಾವು ರಚಿಸಿದ ಚಿತ್ರವನ್ನು ನಮ್ಮ ಸ್ಥಳೀಯ ಕಂಟೇನರ್ ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ಸ್ಥಳೀಯವಾಗಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ. ನಾವು ಈ ಚಿತ್ರವನ್ನು ನಮ್ಮ COOK ಪರಿಸರದಲ್ಲಿ ಬಳಸಲು ಬಯಸಿದರೆ, ಅದನ್ನು ಬೇರೆ ಯಾವುದಾದರೂ ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಇರಿಸಬೇಕು. ಕುಬರ್ನೆಟ್ಸ್ ಅಂತಹ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಹೊಂದಿಲ್ಲ, ಆದ್ದರಿಂದ ನಾವು ಡಾಕರ್‌ಹಬ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ. ಏಕೆಂದರೆ, ಮೊದಲನೆಯದಾಗಿ, ಇದು ಉಚಿತ, ಮತ್ತು ಎರಡನೆಯದಾಗಿ, (ಬಹುತೇಕ) ಎಲ್ಲರೂ ಇದನ್ನು ಮಾಡುತ್ತಾರೆ.

ಇದು ತುಂಬಾ ಸರಳವಾಗಿದೆ ಮತ್ತು ನಿಮಗೆ ಬೇಕಾಗಿರುವುದು ಡಾಕರ್‌ಹಬ್ ಖಾತೆ.

ಆದ್ದರಿಂದ, ನಾವು ಡಾಕರ್‌ಹಬ್ ಅನ್ನು ಸ್ಥಾಪಿಸುತ್ತೇವೆ ಮತ್ತು ನಮ್ಮ ಚಿತ್ರವನ್ನು ಅಲ್ಲಿಗೆ ಕಳುಹಿಸುತ್ತೇವೆ.

ಹಂತ 3 - ಕುಬರ್ನೆಟ್ಸ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ

ನಮ್ಮ "ಹಲೋ ವರ್ಲ್ಡ್" ಅನ್ನು ಚಲಾಯಿಸಲು ಕುಬರ್ನೆಟ್ಸ್ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಜೋಡಿಸಲು ಹಲವು ಮಾರ್ಗಗಳಿವೆ, ಆದರೆ ನಾವು ಅವುಗಳಲ್ಲಿ ಸರಳವಾದದನ್ನು ಬಳಸುತ್ತೇವೆ, ಅದು ನಾವು ಮಾಡುವ ವಿಧಾನವಾಗಿದೆ ...

ಮೊದಲಿಗೆ, ಮಿನಿಕ್ಯೂಬ್ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸೋಣ:

minikube start

ಹಂತ 4 - ನಮ್ಮ ಕಂಟೇನರ್ ಚಿತ್ರವನ್ನು ನಿಯೋಜಿಸಿ

ಈಗ ನಾವು ನಮ್ಮ ಕೋಡ್ ಮತ್ತು ಕಂಟೇನರ್ ಇಮೇಜ್ ಅನ್ನು ಕುಬರ್ನೆಟ್ಸ್ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳಾಗಿ ಪರಿವರ್ತಿಸಬೇಕಾಗಿದೆ. ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಡಾಕರ್‌ಹಬ್‌ನಲ್ಲಿನ ನಮ್ಮ ಕಂಟೈನರ್ ಚಿತ್ರವನ್ನು ಸೂಚಿಸುವ ಪಾಡ್ ಮತ್ತು ನಿಯೋಜನೆಯ ವ್ಯಾಖ್ಯಾನದ ಅಗತ್ಯವಿದೆ. ಇದನ್ನು ಮಾಡಲು ಸುಲಭವಾದ ಮಾರ್ಗವೆಂದರೆ ನಮ್ಮ ಚಿತ್ರವನ್ನು ಸೂಚಿಸುವ ರಚನೆಯ ನಿಯೋಜನೆ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸುವುದು:

kubectl create deployment hello-quarkus — image =gcolman/quarkus-hello-world:1.0.0-SNAPSHOT

ಈ ಆಜ್ಞೆಯೊಂದಿಗೆ ನಾವು ನಿಯೋಜನೆ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ರಚಿಸಲು ನಮ್ಮ COO ಗೆ ಹೇಳಿದ್ದೇವೆ, ಅದು ನಮ್ಮ ಕಂಟೇನರ್ ಚಿತ್ರಕ್ಕಾಗಿ ಪಾಡ್ ವಿವರಣೆಯನ್ನು ಹೊಂದಿರಬೇಕು. ಈ ಆಜ್ಞೆಯು ಈ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ನಮ್ಮ ಮಿನಿಕ್ಯೂಬ್ ಕ್ಲಸ್ಟರ್‌ಗೆ ಅನ್ವಯಿಸುತ್ತದೆ ಮತ್ತು ನಮ್ಮ ಕಂಟೇನರ್ ಚಿತ್ರವನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡುವ ಮತ್ತು ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಪಾಡ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವ ನಿಯೋಜನೆಯನ್ನು ರಚಿಸುತ್ತದೆ.

ಹಂತ 5 - ನಮ್ಮ ಸೇವೆಗೆ ಮುಕ್ತ ಪ್ರವೇಶ

ಈಗ ನಾವು ನಿಯೋಜಿತ ಕಂಟೇನರ್ ಇಮೇಜ್ ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ, ಈ ರೆಸ್ಟ್‌ಫುಲ್ ಸೇವೆಗೆ ಬಾಹ್ಯ ಪ್ರವೇಶವನ್ನು ಹೇಗೆ ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು ಎಂಬುದರ ಕುರಿತು ಯೋಚಿಸುವ ಸಮಯ ಬಂದಿದೆ, ಇದನ್ನು ವಾಸ್ತವವಾಗಿ ನಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿ ಪ್ರೋಗ್ರಾಮ್ ಮಾಡಲಾಗಿದೆ.

ಇಲ್ಲಿ ಹಲವು ಮಾರ್ಗಗಳಿವೆ. ಉದಾಹರಣೆಗೆ, ಸೇವೆಗಳು ಮತ್ತು ಅಂತಿಮ ಬಿಂದುಗಳಂತಹ ಸೂಕ್ತವಾದ ಕುಬರ್ನೆಟ್ಸ್ ಘಟಕಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ರಚಿಸಲು ನೀವು ಎಕ್ಸ್ಪೋಸ್ ಆಜ್ಞೆಯನ್ನು ಬಳಸಬಹುದು. ವಾಸ್ತವವಾಗಿ, ನಮ್ಮ ನಿಯೋಜನೆ ವಸ್ತುವಿಗಾಗಿ ಎಕ್ಸ್‌ಪೋಸ್ ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮೂಲಕ ನಾವು ಇದನ್ನು ಮಾಡುತ್ತೇವೆ:

kubectl expose deployment hello-quarkus — type=NodePort — port=8080

ಎಕ್ಸ್‌ಪೋಸ್ ಕಮಾಂಡ್‌ನ "-ಟೈಪ್" ಆಯ್ಕೆಯನ್ನು ನೋಡಲು ಸ್ವಲ್ಪ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳೋಣ.

ನಮ್ಮ ಸೇವೆಯನ್ನು ಚಲಾಯಿಸಲು ಅಗತ್ಯವಾದ ಘಟಕಗಳನ್ನು ನಾವು ಬಹಿರಂಗಪಡಿಸಿದಾಗ ಮತ್ತು ರಚಿಸಿದಾಗ, ನಾವು ಇತರ ವಿಷಯಗಳ ಜೊತೆಗೆ, ನಮ್ಮ ಸಾಫ್ಟ್‌ವೇರ್-ವ್ಯಾಖ್ಯಾನಿತ ನೆಟ್‌ವರ್ಕ್‌ನೊಳಗೆ ಇರುವ ಹಲೋ-ಕ್ವಾರ್ಕಸ್ ಸೇವೆಗೆ ಹೊರಗಿನಿಂದ ಸಂಪರ್ಕಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಮತ್ತು ನಿಯತಾಂಕ ಮಾದರಿ ಈ ನೆಟ್‌ವರ್ಕ್‌ಗೆ ಟ್ರಾಫಿಕ್ ಅನ್ನು ಮಾರ್ಗ ಮಾಡಲು ಲೋಡ್ ಬ್ಯಾಲೆನ್ಸರ್‌ಗಳಂತಹ ವಿಷಯಗಳನ್ನು ರಚಿಸಲು ಮತ್ತು ಸಂಪರ್ಕಿಸಲು ನಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

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

ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ ಟೈಪ್=ನೋಡ್‌ಪೋರ್ಟ್, ಅಂದರೆ, ನೋಡ್‌ನ IP ವಿಳಾಸ ಮತ್ತು ಪೋರ್ಟ್ ಸಂಖ್ಯೆಯಿಂದ ನಮ್ಮ ಸೇವೆಯನ್ನು ಪ್ರವೇಶಿಸಲಾಗುತ್ತದೆ. ಈ ಆಯ್ಕೆಯು ಯಾವುದೇ ಸಾರ್ವಜನಿಕ ಮೋಡಗಳನ್ನು ಬಳಸದಿರಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಆದರೆ ಹಲವಾರು ಹೆಚ್ಚುವರಿ ಹಂತಗಳ ಅಗತ್ಯವಿದೆ. ಮೊದಲನೆಯದಾಗಿ, ನಿಮಗೆ ನಿಮ್ಮ ಸ್ವಂತ ಲೋಡ್ ಬ್ಯಾಲೆನ್ಸರ್ ಅಗತ್ಯವಿದೆ, ಆದ್ದರಿಂದ ನಾವು ನಮ್ಮ ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ NGINX ಲೋಡ್ ಬ್ಯಾಲೆನ್ಸರ್ ಅನ್ನು ನಿಯೋಜಿಸುತ್ತೇವೆ.

ಹಂತ 6 - ಲೋಡ್ ಬ್ಯಾಲೆನ್ಸರ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿ

minikube ಹಲವಾರು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಕಾರ್ಯಗಳನ್ನು ಹೊಂದಿದೆ, ಅದು ಪ್ರವೇಶ ನಿಯಂತ್ರಕಗಳಂತಹ ಬಾಹ್ಯವಾಗಿ ಪ್ರವೇಶಿಸಬಹುದಾದ ಘಟಕಗಳನ್ನು ರಚಿಸಲು ಸುಲಭಗೊಳಿಸುತ್ತದೆ. Minikube Nginx ಪ್ರವೇಶ ನಿಯಂತ್ರಕದೊಂದಿಗೆ ಬರುತ್ತದೆ, ಮತ್ತು ನಾವು ಮಾಡಬೇಕಾಗಿರುವುದು ಅದನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುವುದು ಮತ್ತು ಅದನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು.

minikube addons enable ingress

ಈಗ ನಾವು ಕೇವಲ ಒಂದು ಆಜ್ಞೆಯೊಂದಿಗೆ Nginx ಪ್ರವೇಶ ನಿಯಂತ್ರಕವನ್ನು ರಚಿಸುತ್ತೇವೆ, ಅದು ನಮ್ಮ ಮಿನಿಕ್ಯೂಬ್ ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ:

ingress-nginx-controller-69ccf5d9d8-j5gs9 1/1 Running 1 33m

ಹಂತ 7 - ಪ್ರವೇಶವನ್ನು ಹೊಂದಿಸುವುದು

ಈಗ ನಾವು Nginx ಪ್ರವೇಶ ನಿಯಂತ್ರಕವನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಬೇಕಾಗಿದೆ ಇದರಿಂದ ಅದು ಹಲೋ-ಕ್ವಾರ್ಕಸ್ ವಿನಂತಿಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ.

ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಾವು ಈ ಸಂರಚನೆಯನ್ನು ಅನ್ವಯಿಸಬೇಕಾಗಿದೆ.

kubectl apply -f ingress.yml

ನಾವು ಇದನ್ನೆಲ್ಲ ನಮ್ಮದೇ ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿ ಮಾಡುತ್ತಿರುವುದರಿಂದ, ನಮ್ಮ ಮಿನಿಕ್ಯೂಬ್‌ಗೆ NGINX ಲೋಡ್ ಬ್ಯಾಲೆನ್ಸರ್‌ಗೆ http ವಿನಂತಿಗಳನ್ನು ಮಾರ್ಗ ಮಾಡಲು ನಾವು /etc/ hosts ಫೈಲ್‌ಗೆ ನಮ್ಮ ನೋಡ್‌ನ IP ವಿಳಾಸವನ್ನು ಸೇರಿಸುತ್ತೇವೆ.

192.168.99.100 hello-quarkus.info

ಅಷ್ಟೇ, ಈಗ ನಮ್ಮ minikube ಸೇವೆಯನ್ನು Nginx ಪ್ರವೇಶ ನಿಯಂತ್ರಕದ ಮೂಲಕ ಬಾಹ್ಯವಾಗಿ ಪ್ರವೇಶಿಸಬಹುದಾಗಿದೆ.

ಸರಿ, ಅದು ಸುಲಭವಾಗಿತ್ತು, ಸರಿ? ಅಥವಾ ತುಂಬಾ ಅಲ್ಲವೇ?

ಓಪನ್‌ಶಿಫ್ಟ್‌ನಲ್ಲಿ ಚಾಲನೆಯಾಗುತ್ತಿದೆ (ಕೋಡ್ ರೆಡಿ ಕಂಟೈನರ್‌ಗಳು)

ಈಗ Red Hat OpenShift ಕಂಟೈನರ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ (OCP) ನಲ್ಲಿ ಇದೆಲ್ಲವನ್ನೂ ಹೇಗೆ ಮಾಡಲಾಗುತ್ತದೆ ಎಂದು ನೋಡೋಣ.

ಮಿನಿಕ್ಯೂಬ್‌ನಂತೆ, ಕೋಡ್ ರೆಡಿ ಕಂಟೈನರ್‌ಗಳ (ಸಿಆರ್‌ಸಿ) ರೂಪದಲ್ಲಿ ನಾವು ಸಿಂಗಲ್-ನೋಡ್ ಓಪನ್‌ಶಿಫ್ಟ್ ಕ್ಲಸ್ಟರ್ ವಿನ್ಯಾಸವನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತೇವೆ. ಹಿಂದೆ, ಇದನ್ನು ಮಿನಿಶಿಫ್ಟ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತಿತ್ತು ಮತ್ತು ಇದು ಓಪನ್‌ಶಿಫ್ಟ್ ಒರಿಜಿನ್ ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ಆಧರಿಸಿದೆ, ಆದರೆ ಈಗ ಇದು CRC ಆಗಿದೆ ಮತ್ತು Red Hat ನ ಓಪನ್‌ಶಿಫ್ಟ್ ಕಂಟೈನರ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಲ್ಲಿ ನಿರ್ಮಿಸಲಾಗಿದೆ.

ಇಲ್ಲಿ ನಾವು, ಕ್ಷಮಿಸಿ, ಸಹಾಯ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ ಆದರೆ ಹೇಳಲು ಸಾಧ್ಯವಿಲ್ಲ: "ಓಪನ್‌ಶಿಫ್ಟ್ ಅದ್ಭುತವಾಗಿದೆ!"

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

ಪ್ರಕ್ರಿಯೆಯ ಮೂಲಕ ಹೋಗೋಣ ಮತ್ತು ನಾವು ಏನು ಮಾಡಬೇಕೆಂದು ನೋಡೋಣ.

ಆದ್ದರಿಂದ, ಮಿನಿಕ್ಯೂಬ್ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಡಾಕರ್‌ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿದ್ದೇವೆ... ನಿರೀಕ್ಷಿಸಿ, ಇನ್ನು ಮುಂದೆ ನಮಗೆ ಡಾಕರ್ ಅನ್ನು ಯಂತ್ರದಲ್ಲಿ ಸ್ಥಾಪಿಸುವ ಅಗತ್ಯವಿಲ್ಲ.

ಮತ್ತು ನಮಗೆ ಸ್ಥಳೀಯ ಜಿಟ್ ಅಗತ್ಯವಿಲ್ಲ.
ಮತ್ತು ಮಾವೆನ್ ಅಗತ್ಯವಿಲ್ಲ.
ಮತ್ತು ನಿಮ್ಮ ಕೈಗಳಿಂದ ಕಂಟೇನರ್ ಚಿತ್ರವನ್ನು ನೀವು ರಚಿಸಬೇಕಾಗಿಲ್ಲ.
ಮತ್ತು ನೀವು ಕಂಟೇನರ್ ಚಿತ್ರಗಳ ಯಾವುದೇ ರೆಪೊಸಿಟರಿಯನ್ನು ನೋಡಬೇಕಾಗಿಲ್ಲ.
ಮತ್ತು ಪ್ರವೇಶ ನಿಯಂತ್ರಕವನ್ನು ಸ್ಥಾಪಿಸುವ ಅಗತ್ಯವಿಲ್ಲ.
ಮತ್ತು ನೀವು ಪ್ರವೇಶವನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುವ ಅಗತ್ಯವಿಲ್ಲ.

ನಿಮಗೆ ಅರ್ಥವಾಯಿತು, ಸರಿ? OpenShift ನಲ್ಲಿ ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿಯೋಜಿಸಲು ಮತ್ತು ಚಲಾಯಿಸಲು, ನಿಮಗೆ ಮೇಲಿನ ಯಾವುದೇ ಅಗತ್ಯವಿಲ್ಲ. ಮತ್ತು ಪ್ರಕ್ರಿಯೆಯು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ.

ಹಂತ 1 - ನಿಮ್ಮ ಓಪನ್‌ಶಿಫ್ಟ್ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ

ನಾವು Red Hat ನಿಂದ ಕೋಡ್ ರೆಡಿ ಕಂಟೈನರ್‌ಗಳನ್ನು ಬಳಸುತ್ತೇವೆ, ಇದು ಮೂಲಭೂತವಾಗಿ ಅದೇ Minikube ಆಗಿದೆ, ಆದರೆ ಪೂರ್ಣ ಪ್ರಮಾಣದ ಸಿಂಗಲ್-ನೋಡ್ ಓಪನ್‌ಶಿಫ್ಟ್ ಕ್ಲಸ್ಟರ್‌ನೊಂದಿಗೆ ಮಾತ್ರ.

crc start

ಹಂತ 2 - ಓಪನ್‌ಶಿಫ್ಟ್ ಕ್ಲಸ್ಟರ್‌ಗೆ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ಮಿಸಿ ಮತ್ತು ನಿಯೋಜಿಸಿ

ಈ ಹಂತದಲ್ಲಿಯೇ ಓಪನ್‌ಶಿಫ್ಟ್‌ನ ಸರಳತೆ ಮತ್ತು ಅನುಕೂಲತೆಯು ಅದರ ಎಲ್ಲಾ ವೈಭವದಲ್ಲಿ ಬಹಿರಂಗಗೊಳ್ಳುತ್ತದೆ. ಎಲ್ಲಾ ಕುಬರ್ನೆಟ್ಸ್ ವಿತರಣೆಗಳಂತೆ, ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರನ್ ಮಾಡಲು ನಾವು ಹಲವು ಮಾರ್ಗಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ. ಮತ್ತು, KUK ಯಂತೆಯೇ, ನಾವು ನಿರ್ದಿಷ್ಟವಾಗಿ ಸರಳವಾದದನ್ನು ಆರಿಸಿಕೊಳ್ಳುತ್ತೇವೆ.

OpenShift ಅನ್ನು ಯಾವಾಗಲೂ ಕಂಟೈನರೈಸ್ ಮಾಡಿದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ರಚಿಸಲು ಮತ್ತು ಚಲಾಯಿಸಲು ಒಂದು ವೇದಿಕೆಯಾಗಿ ನಿರ್ಮಿಸಲಾಗಿದೆ. ಕಂಟೇನರ್ ಕಟ್ಟಡವು ಯಾವಾಗಲೂ ಈ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನ ಅವಿಭಾಜ್ಯ ಅಂಗವಾಗಿದೆ, ಆದ್ದರಿಂದ ಸಂಬಂಧಿತ ಕಾರ್ಯಗಳಿಗಾಗಿ ಒಂದು ಟನ್ ಹೆಚ್ಚುವರಿ ಕುಬರ್ನೆಟ್ ಸಂಪನ್ಮೂಲಗಳಿವೆ.

ನಾವು OpenShift ನ ಮೂಲ 2 ಇಮೇಜ್ (S2I) ಪ್ರಕ್ರಿಯೆಯನ್ನು ಬಳಸುತ್ತೇವೆ, ಇದು ನಮ್ಮ ಮೂಲವನ್ನು (ಕೋಡ್ ಅಥವಾ ಬೈನರಿಗಳು) ತೆಗೆದುಕೊಳ್ಳಲು ಹಲವಾರು ವಿಭಿನ್ನ ಮಾರ್ಗಗಳನ್ನು ಹೊಂದಿದೆ ಮತ್ತು ಅದನ್ನು OpenShift ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಚಲಿಸುವ ಕಂಟೈನರೈಸ್ಡ್ ಇಮೇಜ್ ಆಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ.

ಇದನ್ನು ಮಾಡಲು ನಮಗೆ ಎರಡು ವಿಷಯಗಳು ಬೇಕಾಗುತ್ತವೆ:

• ನಮ್ಮ ಮೂಲ ಕೋಡ್ ಜಿಟ್ ರೆಪೊಸಿಟರಿಯಲ್ಲಿದೆ
• ಅದರ ಆಧಾರದ ಮೇಲೆ ಬಿಲ್ಡರ್ ಇಮೇಜ್ ಅನ್ನು ನಿರ್ಮಿಸಲಾಗುವುದು.

Red Hat ಮತ್ತು ಸಮುದಾಯ ಮಟ್ಟದಲ್ಲಿ ಇಂತಹ ಅನೇಕ ಚಿತ್ರಗಳನ್ನು ನಿರ್ವಹಿಸಲಾಗಿದೆ, ಮತ್ತು ನಾನು Java ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತಿರುವ ಕಾರಣ ನಾವು OpenJDK ಚಿತ್ರವನ್ನು ಬಳಸುತ್ತೇವೆ.

ನೀವು ಓಪನ್‌ಶಿಫ್ಟ್ ಡೆವಲಪರ್ ಗ್ರಾಫಿಕಲ್ ಕನ್ಸೋಲ್‌ನಿಂದ ಮತ್ತು ಆಜ್ಞಾ ಸಾಲಿನಿಂದ S2I ಬಿಲ್ಡ್ ಅನ್ನು ಚಲಾಯಿಸಬಹುದು. ನಾವು ಹೊಸ-ಅಪ್ಲಿಕೇಶನ್ ಆಜ್ಞೆಯನ್ನು ಬಳಸುತ್ತೇವೆ, ಬಿಲ್ಡರ್ ಇಮೇಜ್ ಮತ್ತು ನಮ್ಮ ಮೂಲ ಕೋಡ್ ಅನ್ನು ಎಲ್ಲಿ ಪಡೆಯಬೇಕೆಂದು ಹೇಳುತ್ತೇವೆ.

oc new-app registry.access.redhat.com/ubi8/openjdk-11:latest~https://github.com/gcolman/quarkus-hello-world.git

ಅಷ್ಟೆ, ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರಚಿಸಲಾಗಿದೆ. ಹಾಗೆ ಮಾಡುವಾಗ, S2I ಪ್ರಕ್ರಿಯೆಯು ಈ ಕೆಳಗಿನ ವಿಷಯಗಳನ್ನು ಮಾಡಿದೆ:

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

ಈ ಪಟ್ಟಿಯಲ್ಲಿ ಬಹಳಷ್ಟು ಇದೆ, ಆದರೆ ಮುಖ್ಯ ವಿಷಯವೆಂದರೆ ಸಂಪೂರ್ಣ ನಿರ್ಮಾಣವು ಓಪನ್‌ಶಿಫ್ಟ್‌ನಲ್ಲಿ ಪ್ರತ್ಯೇಕವಾಗಿ ನಡೆಯುತ್ತದೆ, ಆಂತರಿಕ ಡಾಕರ್ ನೋಂದಾವಣೆ ಓಪನ್‌ಶಿಫ್ಟ್‌ನಲ್ಲಿದೆ, ಮತ್ತು ನಿರ್ಮಾಣ ಪ್ರಕ್ರಿಯೆಯು ಎಲ್ಲಾ ಕುಬರ್ನೆಟ್ಸ್ ಘಟಕಗಳನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು ಅವುಗಳನ್ನು ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ರನ್ ಮಾಡುತ್ತದೆ.

ನೀವು ಕನ್ಸೋಲ್‌ನಲ್ಲಿ S2I ನ ಉಡಾವಣೆಯನ್ನು ದೃಷ್ಟಿಗೋಚರವಾಗಿ ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಿದರೆ, ನಿರ್ಮಾಣ ಪೂರ್ಣಗೊಂಡಾಗ ಬಿಲ್ಡ್ ಪಾಡ್ ಅನ್ನು ಹೇಗೆ ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ನೀವು ನೋಡಬಹುದು.

ಈಗ ಬಿಲ್ಡರ್ ಪಾಡ್ ಲಾಗ್‌ಗಳನ್ನು ನೋಡೋಣ: ಮೊದಲನೆಯದಾಗಿ, ನಮ್ಮ ಜಾವಾ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ಮಾವೆನ್ ತನ್ನ ಕೆಲಸವನ್ನು ಹೇಗೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಅವಲಂಬನೆಗಳನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ಇದು ತೋರಿಸುತ್ತದೆ.

ಮಾವೆನ್ ಬಿಲ್ಡ್ ಪೂರ್ಣಗೊಂಡ ನಂತರ, ಕಂಟೇನರ್ ಚಿತ್ರದ ನಿರ್ಮಾಣವನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ನಂತರ ಈ ನಿರ್ಮಿಸಿದ ಚಿತ್ರವನ್ನು ಆಂತರಿಕ ರೆಪೊಸಿಟರಿಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ.

ಅಷ್ಟೆ, ನಿರ್ಮಾಣ ಪ್ರಕ್ರಿಯೆಯು ಪೂರ್ಣಗೊಂಡಿದೆ. ಈಗ ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ಪಾಡ್‌ಗಳು ಮತ್ತು ಸೇವೆಗಳು ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳೋಣ.

oc get service

ಅಷ್ಟೇ. ಮತ್ತು ಕೇವಲ ಒಂದು ತಂಡ. ನಾವು ಮಾಡಬೇಕಾಗಿರುವುದು ಹೊರಗಿನಿಂದ ಪ್ರವೇಶಕ್ಕಾಗಿ ಈ ಸೇವೆಯನ್ನು ಬಹಿರಂಗಪಡಿಸುವುದು.

ಹಂತ 3 - ಹೊರಗಿನಿಂದ ಪ್ರವೇಶಕ್ಕಾಗಿ ಸೇವೆಯನ್ನು ಬಹಿರಂಗಪಡಿಸಿ

KUC ಯಂತೆಯೇ, ಓಪನ್‌ಶಿಫ್ಟ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಲ್ಲಿ ನಮ್ಮ "ಹಲೋ ವರ್ಲ್ಡ್" ಕ್ಲಸ್ಟರ್‌ನೊಳಗಿನ ಸೇವೆಗೆ ಬಾಹ್ಯ ಸಂಚಾರವನ್ನು ನಿರ್ದೇಶಿಸಲು ರೂಟರ್‌ನ ಅಗತ್ಯವಿದೆ. OpenShift ಇದನ್ನು ತುಂಬಾ ಸುಲಭಗೊಳಿಸುತ್ತದೆ. ಮೊದಲನೆಯದಾಗಿ, HAProxy ರೂಟಿಂಗ್ ಘಟಕವನ್ನು ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಸ್ಥಾಪಿಸಲಾಗಿದೆ (ಇದನ್ನು ಅದೇ NGINX ಗೆ ಬದಲಾಯಿಸಬಹುದು). ಎರಡನೆಯದಾಗಿ, ಮಾರ್ಗಗಳು ಎಂದು ಕರೆಯಲ್ಪಡುವ ವಿಶೇಷ ಮತ್ತು ಹೆಚ್ಚು ಗ್ರಾಹಕೀಯಗೊಳಿಸಬಹುದಾದ ಸಂಪನ್ಮೂಲಗಳಿವೆ ಮತ್ತು ಅವು ಉತ್ತಮ ಹಳೆಯ ಕುಬರ್ನೆಟ್‌ಗಳಲ್ಲಿನ ಪ್ರವೇಶ ವಸ್ತುಗಳನ್ನು ಹೋಲುತ್ತವೆ (ವಾಸ್ತವವಾಗಿ, ಓಪನ್‌ಶಿಫ್ಟ್‌ನ ಮಾರ್ಗಗಳು ಪ್ರವೇಶ ವಸ್ತುಗಳ ವಿನ್ಯಾಸವನ್ನು ಹೆಚ್ಚು ಪ್ರಭಾವ ಬೀರಿದೆ, ಅದನ್ನು ಈಗ ಓಪನ್‌ಶಿಫ್ಟ್‌ನಲ್ಲಿ ಬಳಸಬಹುದು) , ಆದರೆ ನಮ್ಮ “ಹಲೋ ವರ್ಲ್ಡ್” ಗಾಗಿ , ಮತ್ತು ಎಲ್ಲಾ ಇತರ ಸಂದರ್ಭಗಳಲ್ಲಿ, ಹೆಚ್ಚುವರಿ ಸಂರಚನೆಯಿಲ್ಲದೆ ನಮಗೆ ಪ್ರಮಾಣಿತ ಮಾರ್ಗವು ಸಾಕಾಗುತ್ತದೆ.

"ಹಲೋ ವರ್ಲ್ಡ್" ಗಾಗಿ ರೂಟಬಲ್ FQDN ಅನ್ನು ರಚಿಸಲು (ಹೌದು, ಸೇವೆಯ ಹೆಸರುಗಳ ಮೂಲಕ ರೂಟಿಂಗ್ ಮಾಡಲು OpenShift ತನ್ನದೇ ಆದ DNS ಅನ್ನು ಹೊಂದಿದೆ), ನಾವು ನಮ್ಮ ಸೇವೆಯನ್ನು ಸರಳವಾಗಿ ಬಹಿರಂಗಪಡಿಸುತ್ತೇವೆ:

oc expose service quarkus-hello-world

ನೀವು ಹೊಸದಾಗಿ ರಚಿಸಲಾದ ಮಾರ್ಗವನ್ನು ನೋಡಿದರೆ, ನೀವು ಅಲ್ಲಿ FQDN ಮತ್ತು ಇತರ ರೂಟಿಂಗ್ ಮಾಹಿತಿಯನ್ನು ಕಾಣಬಹುದು:

oc get route

ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಾವು ಬ್ರೌಸರ್‌ನಿಂದ ನಮ್ಮ ಸೇವೆಯನ್ನು ಪ್ರವೇಶಿಸುತ್ತೇವೆ:

ಆದರೆ ಈಗ ಅದು ತುಂಬಾ ಸುಲಭವಾಗಿತ್ತು!

ನಾವು ಕುಬರ್ನೆಟ್ಸ್ ಮತ್ತು ಈ ತಂತ್ರಜ್ಞಾನವು ನಮಗೆ ಮಾಡಲು ಅನುಮತಿಸುವ ಎಲ್ಲವನ್ನೂ ಪ್ರೀತಿಸುತ್ತೇವೆ ಮತ್ತು ನಾವು ಸರಳತೆ ಮತ್ತು ಸುಲಭತೆಯನ್ನು ಪ್ರೀತಿಸುತ್ತೇವೆ. ವಿತರಿಸಲಾದ, ಸ್ಕೇಲೆಬಲ್ ಕಂಟೈನರ್‌ಗಳ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ನಂಬಲಾಗದಷ್ಟು ಸರಳಗೊಳಿಸಲು ಕುಬರ್ನೆಟ್ಸ್ ಅನ್ನು ರಚಿಸಲಾಗಿದೆ, ಆದರೆ ಅದರ ಸರಳತೆಯು ಇಂದು ಉತ್ಪಾದನೆಗೆ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಹಾಕಲು ಸಾಕಾಗುವುದಿಲ್ಲ. ಇಲ್ಲಿ OpenShift ಕಾರ್ಯರೂಪಕ್ಕೆ ಬರುತ್ತದೆ, ಸಮಯಕ್ಕೆ ಅನುಗುಣವಾಗಿರುತ್ತದೆ ಮತ್ತು ಕುಬರ್ನೆಟ್ಸ್ ಅನ್ನು ಪ್ರಾಥಮಿಕವಾಗಿ ಡೆವಲಪರ್ ಅನ್ನು ಗುರಿಯಾಗಿರಿಸಿಕೊಳ್ಳುತ್ತದೆ. S2I, ODI, ಡೆವಲಪರ್ ಪೋರ್ಟಲ್, ಓಪನ್‌ಶಿಫ್ಟ್ ಆಪರೇಟರ್ ಫ್ರೇಮ್‌ವರ್ಕ್, IDE ಏಕೀಕರಣ, ಡೆವಲಪರ್ ಕ್ಯಾಟಲಾಗ್‌ಗಳು, ಹೆಲ್ಮ್ ಏಕೀಕರಣ, ಮೇಲ್ವಿಚಾರಣೆ ಮತ್ತು ಇತರ ಹಲವು ಸಾಧನಗಳ ರಚನೆ ಸೇರಿದಂತೆ ಡೆವಲಪರ್‌ಗಾಗಿ ನಿರ್ದಿಷ್ಟವಾಗಿ OpenShift ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಅನ್ನು ಹೊಂದಿಸಲು ಸಾಕಷ್ಟು ಪ್ರಯತ್ನಗಳನ್ನು ಹೂಡಿಕೆ ಮಾಡಲಾಗಿದೆ.

ಈ ಲೇಖನವು ನಿಮಗೆ ಆಸಕ್ತಿದಾಯಕ ಮತ್ತು ಉಪಯುಕ್ತವಾಗಿದೆ ಎಂದು ನಾವು ಭಾವಿಸುತ್ತೇವೆ. ಪೋರ್ಟಲ್‌ನಲ್ಲಿ ಓಪನ್‌ಶಿಫ್ಟ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಲ್ಲಿ ಅಭಿವೃದ್ಧಿಗೆ ಉಪಯುಕ್ತವಾದ ಹೆಚ್ಚುವರಿ ಸಂಪನ್ಮೂಲಗಳು, ವಸ್ತುಗಳು ಮತ್ತು ಇತರ ವಿಷಯಗಳನ್ನು ನೀವು ಕಾಣಬಹುದು Red Hat ಡೆವಲಪರ್ಸ್.

ಮೂಲ: www.habr.com