ಎಲ್ಲರಿಗೂ ನಮಸ್ಕಾರ, ಸ್ನೇಹಿತರೇ!
* ಈ ಲೇಖನವು REBRAIN & Yandex.Cloud ತೆರೆದ ಕಾರ್ಯಾಗಾರವನ್ನು ಆಧರಿಸಿದೆ, ನೀವು ವೀಡಿಯೊವನ್ನು ವೀಕ್ಷಿಸಲು ಬಯಸಿದರೆ, ನೀವು ಅದನ್ನು ಈ ಲಿಂಕ್‌ನಲ್ಲಿ ಕಾಣಬಹುದು -
Yandex.Cloud ಲೈವ್ ಅನ್ನು ಪ್ರಯತ್ನಿಸಲು ನಮಗೆ ಇತ್ತೀಚೆಗೆ ಅವಕಾಶವಿದೆ. ನಾವು ದೀರ್ಘ ಮತ್ತು ಕಠಿಣವಾಗಿ ತನಿಖೆ ಮಾಡಲು ಬಯಸಿದ್ದರಿಂದ, ಕ್ಲೌಡ್ ಬೇಸ್ನೊಂದಿಗೆ ಸರಳವಾದ ವರ್ಡ್ಪ್ರೆಸ್ ಬ್ಲಾಗ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವ ಕಲ್ಪನೆಯನ್ನು ನಾವು ತಕ್ಷಣವೇ ಕೈಬಿಟ್ಟಿದ್ದೇವೆ - ಇದು ತುಂಬಾ ನೀರಸವಾಗಿತ್ತು. ಸ್ವಲ್ಪ ಯೋಚಿಸಿದ ನಂತರ, ನೈಜ ಸಮಯದ ಮೋಡ್‌ನಲ್ಲಿ ಈವೆಂಟ್‌ಗಳನ್ನು ಸ್ವೀಕರಿಸಲು ಮತ್ತು ವಿಶ್ಲೇಷಿಸಲು ಉತ್ಪಾದನಾ ಸೇವೆಯ ಆರ್ಕಿಟೆಕ್ಚರ್‌ಗೆ ಹೋಲುವ ಯಾವುದನ್ನಾದರೂ ನಿಯೋಜಿಸಲು ನಾವು ನಿರ್ಧರಿಸಿದ್ದೇವೆ.
ಬಹುಪಾಲು ಆನ್‌ಲೈನ್ (ಮತ್ತು ಮಾತ್ರವಲ್ಲ) ವ್ಯವಹಾರಗಳು ಹೇಗಾದರೂ ತಮ್ಮ ಬಳಕೆದಾರರು ಮತ್ತು ಅವರ ಕ್ರಿಯೆಗಳ ಬಗ್ಗೆ ಪರ್ವತದ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸುತ್ತವೆ ಎಂದು ನನಗೆ ಸಂಪೂರ್ಣವಾಗಿ ಖಚಿತವಾಗಿದೆ. ಕನಿಷ್ಠ, ಕೆಲವು ನಿರ್ಧಾರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ಇದು ಅವಶ್ಯಕವಾಗಿದೆ - ಉದಾಹರಣೆಗೆ, ನೀವು ಆನ್‌ಲೈನ್ ಆಟವನ್ನು ನಿರ್ವಹಿಸಿದರೆ, ಬಳಕೆದಾರರು ಯಾವ ಮಟ್ಟದಲ್ಲಿ ಹೆಚ್ಚಾಗಿ ಸಿಲುಕಿಕೊಳ್ಳುತ್ತಾರೆ ಮತ್ತು ನಿಮ್ಮ ಆಟಿಕೆ ಅಳಿಸಿಹಾಕುವ ಅಂಕಿಅಂಶಗಳನ್ನು ನೀವು ನೋಡಬಹುದು. ಅಥವಾ ಬಳಕೆದಾರರು ಏನನ್ನೂ ಖರೀದಿಸದೆಯೇ ನಿಮ್ಮ ಸೈಟ್ ಅನ್ನು ಏಕೆ ಬಿಡುತ್ತಾರೆ (ಹಲೋ, Yandex.Metrica).
ಆದ್ದರಿಂದ, ನಮ್ಮ ಕಥೆ: ನಾವು ಗೋಲಾಂಗ್‌ನಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಹೇಗೆ ಬರೆದಿದ್ದೇವೆ, ಕಾಫ್ಕಾ vs rabbitmq vs yqs ಅನ್ನು ಪರೀಕ್ಷಿಸಿದ್ದೇವೆ, ಕ್ಲಿಕ್‌ಹೌಸ್ ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಡೇಟಾ ಸ್ಟ್ರೀಮಿಂಗ್ ಅನ್ನು ಬರೆದಿದ್ದೇವೆ ಮತ್ತು ಯಾಂಡೆಕ್ಸ್ ಡೇಟಾಲೆನ್ಸ್ ಬಳಸಿ ಡೇಟಾವನ್ನು ದೃಶ್ಯೀಕರಿಸಿದ್ದೇವೆ. ಸ್ವಾಭಾವಿಕವಾಗಿ, ಇವೆಲ್ಲವೂ ಡಾಕರ್, ಟೆರಾಫಾರ್ಮ್, ಗಿಟ್ಲ್ಯಾಬ್ ಸಿಐ ಮತ್ತು, ಸಹಜವಾಗಿ, ಪ್ರಮೀತಿಯಸ್ ರೂಪದಲ್ಲಿ ಮೂಲಸೌಕರ್ಯ ಸಂತೋಷಗಳೊಂದಿಗೆ ಮಸಾಲೆಯುಕ್ತವಾಗಿವೆ. ಹೋಗೋಣ!
ನಾವು ಎಲ್ಲವನ್ನೂ ಒಂದೇ ಸಿಟ್ಟಿಂಗ್‌ನಲ್ಲಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ ಎಂದು ತಕ್ಷಣವೇ ಕಾಯ್ದಿರಿಸಲು ನಾನು ಬಯಸುತ್ತೇನೆ - ಇದಕ್ಕಾಗಿ ನಮಗೆ ಸರಣಿಯಲ್ಲಿ ಹಲವಾರು ಲೇಖನಗಳು ಬೇಕಾಗುತ್ತವೆ. ರಚನೆಯ ಬಗ್ಗೆ ಸ್ವಲ್ಪ:
ಭಾಗ 1 (ನೀವು ಅದನ್ನು ಓದುತ್ತಿದ್ದೀರಿ). ಪರಿಹಾರದ ವಿಶೇಷಣಗಳು ಮತ್ತು ವಾಸ್ತುಶಿಲ್ಪವನ್ನು ನಾವು ನಿರ್ಧರಿಸುತ್ತೇವೆ ಮತ್ತು ಗೋಲಾಂಗ್‌ನಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸಹ ಬರೆಯುತ್ತೇವೆ.
ಭಾಗ 2. ನಾವು ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಉತ್ಪಾದನೆಗೆ ಬಿಡುಗಡೆ ಮಾಡುತ್ತೇವೆ, ಅದನ್ನು ಸ್ಕೇಲೆಬಲ್ ಮಾಡಿ ಮತ್ತು ಲೋಡ್ ಅನ್ನು ಪರೀಕ್ಷಿಸುತ್ತೇವೆ.
ಭಾಗ 3. ನಾವು ಸಂದೇಶಗಳನ್ನು ಬಫರ್‌ನಲ್ಲಿ ಏಕೆ ಸಂಗ್ರಹಿಸಬೇಕು ಮತ್ತು ಫೈಲ್‌ಗಳಲ್ಲಿ ಅಲ್ಲ ಮತ್ತು kafka, rabbitmq ಮತ್ತು yandex ಕ್ಯೂ ಸೇವೆಯನ್ನು ಹೋಲಿಕೆ ಮಾಡುವುದನ್ನು ಕಂಡುಹಿಡಿಯಲು ಪ್ರಯತ್ನಿಸೋಣ.
ಭಾಗ 4 ನಾವು ಕ್ಲಿಕ್‌ಹೌಸ್ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ನಿಯೋಜಿಸುತ್ತೇವೆ, ಬಫರ್‌ನಿಂದ ಡೇಟಾವನ್ನು ವರ್ಗಾಯಿಸಲು ಸ್ಟ್ರೀಮಿಂಗ್ ಸೇವೆಯನ್ನು ಬರೆಯುತ್ತೇವೆ ಮತ್ತು ಡೇಟಾಲೆನ್ಸ್‌ನಲ್ಲಿ ದೃಶ್ಯೀಕರಣವನ್ನು ಹೊಂದಿಸುತ್ತೇವೆ.
ಭಾಗ 5 ಸಂಪೂರ್ಣ ಮೂಲಸೌಕರ್ಯವನ್ನು ಸರಿಯಾದ ಆಕಾರಕ್ಕೆ ತರೋಣ - gitlab ci ಅನ್ನು ಬಳಸಿಕೊಂಡು ci/cd ಅನ್ನು ಹೊಂದಿಸಿ, ಪ್ರಮೀತಿಯಸ್ ಮತ್ತು ಕಾನ್ಸುಲ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಮೇಲ್ವಿಚಾರಣೆ ಮತ್ತು ಸೇವೆಯ ಅನ್ವೇಷಣೆಯನ್ನು ಸಂಪರ್ಕಿಸಿ.
ಟಿ.ಕೆ
ಮೊದಲಿಗೆ, ಉಲ್ಲೇಖದ ನಿಯಮಗಳನ್ನು ರೂಪಿಸೋಣ - ಪರಿಣಾಮವಾಗಿ ನಾವು ನಿಖರವಾಗಿ ಏನನ್ನು ಪಡೆಯಲು ಬಯಸುತ್ತೇವೆ.
- ನಾವು events.kis.im (kis.im ನಾವು ಎಲ್ಲಾ ಲೇಖನಗಳಲ್ಲಿ ಬಳಸುವ ಪರೀಕ್ಷಾ ಡೊಮೇನ್) ನಂತಹ ಅಂತಿಮ ಬಿಂದುವನ್ನು ಹೊಂದಲು ಬಯಸುತ್ತೇವೆ, ಇದು HTTPS ಬಳಸಿಕೊಂಡು ಈವೆಂಟ್‌ಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ.
- ಈವೆಂಟ್‌ಗಳು ಈ ರೀತಿಯ ಸರಳ json: {“ಈವೆಂಟ್”: “ವೀಕ್ಷಣೆ”, “os”: “linux”, “ಬ್ರೌಸರ್”: “chrome”}. ಅಂತಿಮ ಹಂತದಲ್ಲಿ ನಾವು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಕ್ಷೇತ್ರಗಳನ್ನು ಸೇರಿಸುತ್ತೇವೆ, ಆದರೆ ಇದು ದೊಡ್ಡ ಪಾತ್ರವನ್ನು ವಹಿಸುವುದಿಲ್ಲ. ನೀವು ಬಯಸಿದರೆ, ನೀವು ಪ್ರೋಟೋಬಫ್‌ಗೆ ಬದಲಾಯಿಸಬಹುದು.
- ಸೇವೆಯು ಸೆಕೆಂಡಿಗೆ 10 ಈವೆಂಟ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಶಕ್ತವಾಗಿರಬೇಕು.
- ನಮ್ಮ ಪರಿಹಾರಕ್ಕೆ ಹೊಸ ನಿದರ್ಶನಗಳನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ಅಡ್ಡಲಾಗಿ ಅಳೆಯಲು ಸಾಧ್ಯವಾಗಬೇಕು. ಮತ್ತು ಕ್ಲೈಂಟ್ ವಿನಂತಿಗಳಿಗೆ ಸುಪ್ತತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಲು ನಾವು ಮುಂಭಾಗದ ಭಾಗವನ್ನು ವಿವಿಧ ಜಿಯೋಲೊಕೇಶನ್‌ಗಳಿಗೆ ಸರಿಸಿದರೆ ಅದು ಚೆನ್ನಾಗಿರುತ್ತದೆ.
- ದೋಷಸಹಿಷ್ಣುತೆ. ಪರಿಹಾರವು ಸಾಕಷ್ಟು ಸ್ಥಿರವಾಗಿರಬೇಕು ಮತ್ತು ಯಾವುದೇ ಭಾಗಗಳ ಪತನವನ್ನು ಬದುಕಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ (ಒಂದು ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯವರೆಗೆ, ಸಹಜವಾಗಿ).
ವಾಸ್ತುಶಿಲ್ಪ
ಸಾಮಾನ್ಯವಾಗಿ, ಈ ರೀತಿಯ ಕಾರ್ಯಕ್ಕಾಗಿ, ಸಮರ್ಥ ಸ್ಕೇಲಿಂಗ್ ಅನ್ನು ಅನುಮತಿಸುವ ಶಾಸ್ತ್ರೀಯ ವಾಸ್ತುಶಿಲ್ಪಗಳನ್ನು ದೀರ್ಘಕಾಲದವರೆಗೆ ಕಂಡುಹಿಡಿಯಲಾಗಿದೆ. ಚಿತ್ರವು ನಮ್ಮ ಪರಿಹಾರದ ಉದಾಹರಣೆಯನ್ನು ತೋರಿಸುತ್ತದೆ.
ಆದ್ದರಿಂದ ನಾವು ಏನು ಹೊಂದಿದ್ದೇವೆ:
1. ಎಡಭಾಗದಲ್ಲಿ ವಿವಿಧ ಈವೆಂಟ್‌ಗಳನ್ನು ರಚಿಸುವ ನಮ್ಮ ಸಾಧನಗಳಿವೆ, ಅದು ಆಟಗಾರರು ಸ್ಮಾರ್ಟ್‌ಫೋನ್‌ನಲ್ಲಿ ಆಟಿಕೆಯಲ್ಲಿ ಮಟ್ಟವನ್ನು ಪೂರ್ಣಗೊಳಿಸಬಹುದು ಅಥವಾ ಸಾಮಾನ್ಯ ಬ್ರೌಸರ್ ಮೂಲಕ ಆನ್‌ಲೈನ್ ಸ್ಟೋರ್‌ನಲ್ಲಿ ಆದೇಶವನ್ನು ರಚಿಸಬಹುದು. ಈವೆಂಟ್, ವಿವರಣೆಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದಂತೆ, ನಮ್ಮ ಅಂತಿಮ ಬಿಂದುವಿಗೆ ಕಳುಹಿಸಲಾದ ಒಂದು ಸರಳವಾದ json ಆಗಿದೆ - events.kis.im.
2. ಮೊದಲ ಎರಡು ಸರ್ವರ್‌ಗಳು ಸರಳ ಬ್ಯಾಲೆನ್ಸರ್‌ಗಳು, ಅವುಗಳ ಮುಖ್ಯ ಕಾರ್ಯಗಳು:
- ನಿರಂತರವಾಗಿ ಲಭ್ಯವಿರಲಿ. ಇದನ್ನು ಮಾಡಲು, ನೀವು ಉದಾಹರಣೆಗೆ, ಕೀಪಲೈವ್ ಅನ್ನು ಬಳಸಬಹುದು, ಇದು ಸಮಸ್ಯೆಗಳ ಸಂದರ್ಭದಲ್ಲಿ ನೋಡ್ಗಳ ನಡುವೆ ವರ್ಚುವಲ್ ಐಪಿ ಅನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ.
- TLS ಅನ್ನು ಕೊನೆಗೊಳಿಸಿ. ಹೌದು, ನಾವು ಅವುಗಳ ಮೇಲೆ TLS ಅನ್ನು ಕೊನೆಗೊಳಿಸುತ್ತೇವೆ. ಮೊದಲನೆಯದಾಗಿ, ನಮ್ಮ ಪರಿಹಾರವು ತಾಂತ್ರಿಕ ವಿಶೇಷಣಗಳಿಗೆ ಅನುಗುಣವಾಗಿರುತ್ತದೆ ಮತ್ತು ಎರಡನೆಯದಾಗಿ, ನಮ್ಮ ಬ್ಯಾಕೆಂಡ್ ಸರ್ವರ್‌ಗಳಿಂದ ಎನ್‌ಕ್ರಿಪ್ಟ್ ಮಾಡಿದ ಸಂಪರ್ಕವನ್ನು ಸ್ಥಾಪಿಸುವ ಹೊರೆಯನ್ನು ನಿವಾರಿಸಲು.
- ಲಭ್ಯವಿರುವ ಬ್ಯಾಕೆಂಡ್ ಸರ್ವರ್‌ಗಳಿಗೆ ಒಳಬರುವ ವಿನಂತಿಗಳನ್ನು ಸಮತೋಲನಗೊಳಿಸಿ. ಇಲ್ಲಿ ಪ್ರಮುಖ ಪದವನ್ನು ಪ್ರವೇಶಿಸಬಹುದು. ಇದರ ಆಧಾರದ ಮೇಲೆ, ಲೋಡ್ ಬ್ಯಾಲೆನ್ಸರ್‌ಗಳು ನಮ್ಮ ಸರ್ವರ್ಗಳನ್ನು ಅಪ್ಲಿಕೇಶನ್‌ಗಳೊಂದಿಗೆ ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲು ಮತ್ತು ವಿಫಲವಾದ ನೋಡ್‌ಗಳಿಗೆ ದಟ್ಟಣೆಯನ್ನು ಸಮತೋಲನಗೊಳಿಸುವುದನ್ನು ನಿಲ್ಲಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ಎಂದು ನಾವು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುತ್ತೇವೆ.
3. ಬ್ಯಾಲೆನ್ಸರ್‌ಗಳ ನಂತರ, ನಾವು ಸಾಕಷ್ಟು ಸರಳವಾದ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡುವ ಅಪ್ಲಿಕೇಶನ್ ಸರ್ವರ್ಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ. ಇದು HTTP ಮೂಲಕ ಒಳಬರುವ ವಿನಂತಿಗಳನ್ನು ಸ್ವೀಕರಿಸಲು, ಕಳುಹಿಸಿದ json ಅನ್ನು ಮೌಲ್ಯೀಕರಿಸಲು ಮತ್ತು ಡೇಟಾವನ್ನು ಬಫರ್‌ಗೆ ಹಾಕಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.
4. ರೇಖಾಚಿತ್ರವು ಕಾಫ್ಕಾವನ್ನು ಬಫರ್ ಎಂದು ತೋರಿಸುತ್ತದೆ, ಆದಾಗ್ಯೂ, ಈ ಮಟ್ಟದಲ್ಲಿ ಇತರ ರೀತಿಯ ಸೇವೆಗಳನ್ನು ಬಳಸಬಹುದು. ನಾವು ಮೂರನೇ ಲೇಖನದಲ್ಲಿ ಕಾಫ್ಕಾ, rabbitmq ಮತ್ತು yqs ಅನ್ನು ಹೋಲಿಸುತ್ತೇವೆ.
5. ನಮ್ಮ ಆರ್ಕಿಟೆಕ್ಚರ್‌ನ ಅಂತಿಮ ಹಂತವೆಂದರೆ ಕ್ಲಿಕ್‌ಹೌಸ್ - ಇದು ಸ್ತಂಭಾಕಾರದ ಡೇಟಾಬೇಸ್ ಆಗಿದ್ದು ಅದು ನಿಮಗೆ ಹೆಚ್ಚಿನ ಪ್ರಮಾಣದ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಈ ಹಂತದಲ್ಲಿ, ನಾವು ಬಫರ್‌ನಿಂದ ಶೇಖರಣಾ ವ್ಯವಸ್ಥೆಗೆ ಡೇಟಾವನ್ನು ವರ್ಗಾಯಿಸಬೇಕಾಗಿದೆ (ಇದರ ಬಗ್ಗೆ ಲೇಖನ 4 ರಲ್ಲಿ ಇನ್ನಷ್ಟು).
ಈ ವಿನ್ಯಾಸವು ಪ್ರತಿ ಪದರವನ್ನು ಸ್ವತಂತ್ರವಾಗಿ ಅಡ್ಡಲಾಗಿ ಅಳೆಯಲು ನಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಬ್ಯಾಕೆಂಡ್ ಸರ್ವರ್‌ಗಳು ನಿಭಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ - ಇನ್ನೊಂದು ವಿಷಯವನ್ನು ಸೇರಿಸೋಣ - ಎಲ್ಲಾ ನಂತರ, ಅವು ಸ್ಥಿತಿಯಿಲ್ಲದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಾಗಿವೆ ಮತ್ತು ಆದ್ದರಿಂದ, ಇದನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸಹ ಮಾಡಬಹುದು. ಕಾಫ್ಕಾ-ಶೈಲಿಯ ಬಫರ್ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ-ಹೆಚ್ಚು ಸರ್ವರ್ಗಳನ್ನು ಸೇರಿಸೋಣ ಮತ್ತು ನಮ್ಮ ವಿಷಯದ ಕೆಲವು ವಿಭಾಗಗಳನ್ನು ಅವರಿಗೆ ವರ್ಗಾಯಿಸೋಣ. ಕ್ಲಿಕ್‌ಹೌಸ್ ಅದನ್ನು ನಿಭಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ - ಇದು ಅಸಾಧ್ಯ :) ವಾಸ್ತವವಾಗಿ, ನಾವು ಸರ್ವರ್ಗಳನ್ನು ಸಹ ಸಂಪರ್ಕಿಸುತ್ತೇವೆ ಮತ್ತು ಡೇಟಾವನ್ನು ಚೂರು ಮಾಡುತ್ತೇವೆ.
ಮೂಲಕ, ನಮ್ಮ ತಾಂತ್ರಿಕ ವಿಶೇಷಣಗಳ ಐಚ್ಛಿಕ ಭಾಗವನ್ನು ನೀವು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಯಸಿದರೆ ಮತ್ತು ವಿಭಿನ್ನ ಜಿಯೋಲೋಕಲೈಸೇಶನ್‌ಗಳಲ್ಲಿ, ನಂತರ ಸರಳವಾದ ಏನೂ ಇಲ್ಲ:
ಪ್ರತಿ ಜಿಯೋಲೋಕಲೈಸೇಶನ್‌ನಲ್ಲಿ ನಾವು ಅಪ್ಲಿಕೇಶನ್ ಮತ್ತು ಕಾಫ್ಕಾದೊಂದಿಗೆ ಲೋಡ್ ಬ್ಯಾಲೆನ್ಸರ್ ಅನ್ನು ನಿಯೋಜಿಸುತ್ತೇವೆ. ಸಾಮಾನ್ಯವಾಗಿ, 2 ಅಪ್ಲಿಕೇಶನ್ ಸರ್ವರ್‌ಗಳು, 3 ಕಾಫ್ಕಾ ನೋಡ್‌ಗಳು ಮತ್ತು ಕ್ಲೌಡ್ ಬ್ಯಾಲೆನ್ಸರ್, ಉದಾಹರಣೆಗೆ, ಕ್ಲೌಡ್‌ಫ್ಲೇರ್, ಸಾಕಾಗುತ್ತದೆ, ಇದು ಕ್ಲೈಂಟ್‌ನ ಮೂಲ IP ವಿಳಾಸವನ್ನು ಆಧರಿಸಿ ಜಿಯೋಲೊಕೇಶನ್ ಮೂಲಕ ಅಪ್ಲಿಕೇಶನ್ ನೋಡ್‌ಗಳು ಮತ್ತು ಬ್ಯಾಲೆನ್ಸ್ ವಿನಂತಿಗಳ ಲಭ್ಯತೆಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಹೀಗಾಗಿ, ಅಮೇರಿಕನ್ ಕ್ಲೈಂಟ್ ಕಳುಹಿಸಿದ ಡೇಟಾವು ಅಮೇರಿಕನ್ ಸರ್ವರ್‌ಗಳಲ್ಲಿ ಇಳಿಯುತ್ತದೆ. ಮತ್ತು ಆಫ್ರಿಕಾದ ಡೇಟಾ ಆಫ್ರಿಕನ್‌ನಲ್ಲಿದೆ.
ನಂತರ ಎಲ್ಲವೂ ತುಂಬಾ ಸರಳವಾಗಿದೆ - ನಾವು ಕಾಫ್ಕಾ ಸೆಟ್‌ನಿಂದ ಕನ್ನಡಿ ಉಪಕರಣವನ್ನು ಬಳಸುತ್ತೇವೆ ಮತ್ತು ರಷ್ಯಾದಲ್ಲಿರುವ ನಮ್ಮ ಕೇಂದ್ರ ಡೇಟಾ ಕೇಂದ್ರಕ್ಕೆ ಎಲ್ಲಾ ಸ್ಥಳಗಳಿಂದ ಎಲ್ಲಾ ಡೇಟಾವನ್ನು ನಕಲಿಸುತ್ತೇವೆ. ಆಂತರಿಕವಾಗಿ, ನಾವು ಡೇಟಾವನ್ನು ಪಾರ್ಸ್ ಮಾಡುತ್ತೇವೆ ಮತ್ತು ನಂತರದ ದೃಶ್ಯೀಕರಣಕ್ಕಾಗಿ ಕ್ಲಿಕ್‌ಹೌಸ್‌ನಲ್ಲಿ ರೆಕಾರ್ಡ್ ಮಾಡುತ್ತೇವೆ.
ಆದ್ದರಿಂದ, ನಾವು ವಾಸ್ತುಶಿಲ್ಪವನ್ನು ವಿಂಗಡಿಸಿದ್ದೇವೆ - Yandex.Cloud ಅನ್ನು ಅಲುಗಾಡಿಸಲು ಪ್ರಾರಂಭಿಸೋಣ!
ಅಪ್ಲಿಕೇಶನ್ ಬರೆಯುವುದು
ಮೇಘದ ಮೊದಲು, ನೀವು ಇನ್ನೂ ಸ್ವಲ್ಪ ತಾಳ್ಮೆಯಿಂದಿರಬೇಕು ಮತ್ತು ಒಳಬರುವ ಈವೆಂಟ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಸಾಕಷ್ಟು ಸರಳವಾದ ಸೇವೆಯನ್ನು ಬರೆಯಬೇಕು. ನಾವು ಗೊಲಾಂಗ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ ಏಕೆಂದರೆ ಅದು ನೆಟ್ವರ್ಕ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಬರೆಯಲು ಭಾಷೆಯಾಗಿ ಉತ್ತಮವಾಗಿ ಸಾಬೀತಾಗಿದೆ.
ಒಂದು ಗಂಟೆ ಕಳೆದ ನಂತರ (ಬಹುಶಃ ಒಂದೆರಡು ಗಂಟೆಗಳು), ನಾವು ಈ ರೀತಿಯದನ್ನು ಪಡೆಯುತ್ತೇವೆ: .
ನಾನು ಇಲ್ಲಿ ಗಮನಿಸಲು ಬಯಸುವ ಮುಖ್ಯ ಅಂಶಗಳು ಯಾವುವು:
1. ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವಾಗ, ನೀವು ಎರಡು ಧ್ವಜಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು. ಒಳಬರುವ http ವಿನಂತಿಗಳನ್ನು (-addr) ನಾವು ಕೇಳುವ ಪೋರ್ಟ್‌ಗೆ ಒಬ್ಬರು ಜವಾಬ್ದಾರರಾಗಿರುತ್ತಾರೆ. ಎರಡನೆಯದು ಕಾಫ್ಕಾ ಸರ್ವರ್ ವಿಳಾಸಕ್ಕಾಗಿ ನಾವು ನಮ್ಮ ಈವೆಂಟ್‌ಗಳನ್ನು ರೆಕಾರ್ಡ್ ಮಾಡುತ್ತೇವೆ (-ಕಾಫ್ಕಾ):
addr = flag.String("addr", ":8080", "TCP address to listen to")
kafka = flag.String("kafka", "127.0.0.1:9092", "Kafka endpoints”)2. ಅಪ್ಲಿಕೇಶನ್ ಸರಮಾ ಲೈಬ್ರರಿಯನ್ನು ಬಳಸುತ್ತದೆ () ಕಾಫ್ಕಾ ಕ್ಲಸ್ಟರ್‌ಗೆ ಸಂದೇಶಗಳನ್ನು ಕಳುಹಿಸಲು. ಗರಿಷ್ಠ ಪ್ರಕ್ರಿಯೆ ವೇಗವನ್ನು ಗುರಿಯಾಗಿಟ್ಟುಕೊಂಡು ನಾವು ತಕ್ಷಣ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಹೊಂದಿಸಿದ್ದೇವೆ:
config := sarama.NewConfig()
config.Producer.RequiredAcks = sarama.WaitForLocal
config.Producer.Compression = sarama.CompressionSnappy
config.Producer.Return.Successes = true3. ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಅಂತರ್ನಿರ್ಮಿತ ಪ್ರಮೀತಿಯಸ್ ಕ್ಲೈಂಟ್ ಕೂಡ ಇದೆ, ಇದು ವಿವಿಧ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ, ಅವುಗಳೆಂದರೆ:
- ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ಗೆ ವಿನಂತಿಗಳ ಸಂಖ್ಯೆ;
- ವಿನಂತಿಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಾಗ ದೋಷಗಳ ಸಂಖ್ಯೆ (ಪೋಸ್ಟ್ ವಿನಂತಿಯನ್ನು ಓದಲು ಅಸಾಧ್ಯ, ಮುರಿದ json, ಕಾಫ್ಕಾಗೆ ಬರೆಯಲು ಅಸಾಧ್ಯ);
- ಕಾಫ್ಕಾಗೆ ಸಂದೇಶವನ್ನು ಬರೆಯುವ ಸಮಯವನ್ನು ಒಳಗೊಂಡಂತೆ ಕ್ಲೈಂಟ್‌ನಿಂದ ಒಂದು ವಿನಂತಿಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಸಮಯ.
4. ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಮೂರು ಅಂತಿಮ ಬಿಂದುಗಳು:
- / ಸ್ಥಿತಿ - ನಾವು ಜೀವಂತವಾಗಿದ್ದೇವೆ ಎಂದು ತೋರಿಸಲು ಸರಿ ಎಂದು ಹಿಂತಿರುಗಿ. ನೀವು ಕಾಫ್ಕಾ ಕ್ಲಸ್ಟರ್‌ನ ಲಭ್ಯತೆಯಂತಹ ಕೆಲವು ಚೆಕ್‌ಗಳನ್ನು ಸೇರಿಸಬಹುದು.
- /ಮೆಟ್ರಿಕ್ಸ್ - ಈ url ಪ್ರಕಾರ, ಪ್ರಮೀತಿಯಸ್ ಕ್ಲೈಂಟ್ ತಾನು ಸಂಗ್ರಹಿಸಿದ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
- /ಪೋಸ್ಟ್ ಮುಖ್ಯ ಅಂತಿಮ ಬಿಂದುವಾಗಿದ್ದು, ಒಳಗೆ json ಜೊತೆಗೆ POST ವಿನಂತಿಗಳನ್ನು ಕಳುಹಿಸಲಾಗುತ್ತದೆ. ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಮಾನ್ಯತೆಗಾಗಿ json ಅನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಎಲ್ಲವೂ ಸರಿಯಾಗಿದ್ದರೆ, ಅದು ಕಾಫ್ಕಾ ಕ್ಲಸ್ಟರ್‌ಗೆ ಡೇಟಾವನ್ನು ಬರೆಯುತ್ತದೆ.
ಕೋಡ್ ಪರಿಪೂರ್ಣವಾಗಿಲ್ಲ ಎಂದು ನಾನು ಕಾಯ್ದಿರಿಸುತ್ತೇನೆ - ಅದನ್ನು ಪೂರ್ಣಗೊಳಿಸಬಹುದು (ಮತ್ತು ಮಾಡಬೇಕು!). ಉದಾಹರಣೆಗೆ, ನೀವು ಅಂತರ್ನಿರ್ಮಿತ ನೆಟ್/http ಬಳಸುವುದನ್ನು ನಿಲ್ಲಿಸಬಹುದು ಮತ್ತು ವೇಗವಾದ ಫಾಸ್ಟ್‌http ಗೆ ಬದಲಾಯಿಸಬಹುದು. ಅಥವಾ ನೀವು json ವ್ಯಾಲಿಡಿಟಿ ಚೆಕ್ ಅನ್ನು ನಂತರದ ಹಂತಕ್ಕೆ ಸರಿಸುವ ಮೂಲಕ ಪ್ರಕ್ರಿಯೆಯ ಸಮಯ ಮತ್ತು cpu ಸಂಪನ್ಮೂಲಗಳನ್ನು ಪಡೆಯಬಹುದು - ಡೇಟಾವನ್ನು ಬಫರ್‌ನಿಂದ ಕ್ಲಿಕ್‌ಹೌಸ್ ಕ್ಲಸ್ಟರ್‌ಗೆ ವರ್ಗಾಯಿಸಿದಾಗ.
ಸಮಸ್ಯೆಯ ಅಭಿವೃದ್ಧಿಯ ಭಾಗದ ಜೊತೆಗೆ, ನಾವು ತಕ್ಷಣ ನಮ್ಮ ಭವಿಷ್ಯದ ಮೂಲಸೌಕರ್ಯಗಳ ಬಗ್ಗೆ ಯೋಚಿಸಿದ್ದೇವೆ ಮತ್ತು ಡಾಕರ್ ಮೂಲಕ ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿಯೋಜಿಸಲು ನಿರ್ಧರಿಸಿದ್ದೇವೆ. ಅಪ್ಲಿಕೇಶನ್ ನಿರ್ಮಿಸಲು ಅಂತಿಮ ಡಾಕರ್‌ಫೈಲ್ ಆಗಿದೆ . ಸಾಮಾನ್ಯವಾಗಿ, ಇದು ತುಂಬಾ ಸರಳವಾಗಿದೆ, ನಾನು ಗಮನ ಕೊಡಲು ಬಯಸುವ ಏಕೈಕ ಅಂಶವೆಂದರೆ ಮಲ್ಟಿಸ್ಟೇಜ್ ಅಸೆಂಬ್ಲಿ, ಇದು ನಮ್ಮ ಕಂಟೇನರ್ನ ಅಂತಿಮ ಚಿತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
ಮೋಡದಲ್ಲಿ ಮೊದಲ ಹೆಜ್ಜೆಗಳು
ಮೊದಲನೆಯದಾಗಿ, ನೋಂದಾಯಿಸಿ . ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಕ್ಷೇತ್ರಗಳನ್ನು ಭರ್ತಿ ಮಾಡಿದ ನಂತರ, ನಾವು ಖಾತೆಯನ್ನು ರಚಿಸುತ್ತೇವೆ ಮತ್ತು ನಿರ್ದಿಷ್ಟ ಪ್ರಮಾಣದ ಹಣಕ್ಕಾಗಿ ಅನುದಾನವನ್ನು ನೀಡುತ್ತೇವೆ, ಅದನ್ನು ಕ್ಲೌಡ್ ಸೇವೆಗಳನ್ನು ಪರೀಕ್ಷಿಸಲು ಬಳಸಬಹುದು. ನಮ್ಮ ಲೇಖನದಿಂದ ಎಲ್ಲಾ ಹಂತಗಳನ್ನು ಪುನರಾವರ್ತಿಸಲು ನೀವು ಬಯಸಿದರೆ, ಈ ಅನುದಾನವು ನಿಮಗೆ ಸಾಕಾಗುತ್ತದೆ.
ನೋಂದಣಿಯ ನಂತರ, ನಿಮಗಾಗಿ ಪ್ರತ್ಯೇಕ ಕ್ಲೌಡ್ ಮತ್ತು ಡೀಫಾಲ್ಟ್ ಡೈರೆಕ್ಟರಿಯನ್ನು ರಚಿಸಲಾಗುತ್ತದೆ, ಇದರಲ್ಲಿ ನೀವು ಕ್ಲೌಡ್ ಸಂಪನ್ಮೂಲಗಳನ್ನು ರಚಿಸಲು ಪ್ರಾರಂಭಿಸಬಹುದು. ಸಾಮಾನ್ಯವಾಗಿ, Yandex.Cloud ನಲ್ಲಿ, ಸಂಪನ್ಮೂಲಗಳ ಸಂಬಂಧವು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:
ಒಂದು ಖಾತೆಗಾಗಿ ನೀವು ಹಲವಾರು ಮೋಡಗಳನ್ನು ರಚಿಸಬಹುದು. ಮತ್ತು ಕ್ಲೌಡ್ ಒಳಗೆ, ವಿವಿಧ ಕಂಪನಿ ಯೋಜನೆಗಳಿಗೆ ವಿವಿಧ ಡೈರೆಕ್ಟರಿಗಳನ್ನು ಮಾಡಿ. ದಸ್ತಾವೇಜನ್ನು ನೀವು ಇದರ ಬಗ್ಗೆ ಇನ್ನಷ್ಟು ಓದಬಹುದು - . ಮೂಲಕ, ನಾನು ಅದನ್ನು ಪಠ್ಯದಲ್ಲಿ ಕೆಳಗೆ ಉಲ್ಲೇಖಿಸುತ್ತೇನೆ. ನಾನು ಸಂಪೂರ್ಣ ಮೂಲಸೌಕರ್ಯವನ್ನು ಮೊದಲಿನಿಂದ ಹೊಂದಿಸಿದಾಗ, ದಸ್ತಾವೇಜನ್ನು ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಬಾರಿ ನನಗೆ ಸಹಾಯ ಮಾಡಿದೆ, ಆದ್ದರಿಂದ ನಾನು ಅದನ್ನು ಅಧ್ಯಯನ ಮಾಡಲು ಸಲಹೆ ನೀಡುತ್ತೇನೆ.
ಕ್ಲೌಡ್ ಅನ್ನು ನಿರ್ವಹಿಸಲು, ನೀವು ವೆಬ್ ಇಂಟರ್ಫೇಸ್ ಮತ್ತು ಕನ್ಸೋಲ್ ಯುಟಿಲಿಟಿ ಎರಡನ್ನೂ ಬಳಸಬಹುದು - yc. ಅನುಸ್ಥಾಪನೆಯನ್ನು ಒಂದು ಆಜ್ಞೆಯೊಂದಿಗೆ ನಡೆಸಲಾಗುತ್ತದೆ (Linux ಮತ್ತು Mac Os ಗಾಗಿ):
curl https://storage.yandexcloud.net/yandexcloud-yc/install.sh | bashನಿಮ್ಮ ಆಂತರಿಕ ಭದ್ರತಾ ತಜ್ಞರು ಇಂಟರ್ನೆಟ್‌ನಿಂದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಚಲಾಯಿಸುವ ಬಗ್ಗೆ ಕೆರಳಿಸುತ್ತಿದ್ದರೆ, ಮೊದಲನೆಯದಾಗಿ, ನೀವು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ತೆರೆಯಬಹುದು ಮತ್ತು ಅದನ್ನು ಓದಬಹುದು ಮತ್ತು ಎರಡನೆಯದಾಗಿ, ನಾವು ಅದನ್ನು ನಮ್ಮ ಬಳಕೆದಾರರ ಅಡಿಯಲ್ಲಿ ರನ್ ಮಾಡುತ್ತೇವೆ - ಮೂಲ ಹಕ್ಕುಗಳಿಲ್ಲದೆ.
ನೀವು ವಿಂಡೋಸ್‌ಗಾಗಿ ಕ್ಲೈಂಟ್ ಅನ್ನು ಸ್ಥಾಪಿಸಲು ಬಯಸಿದರೆ, ನೀವು ಸೂಚನೆಗಳನ್ನು ಬಳಸಬಹುದು ತದನಂತರ ಕಾರ್ಯಗತಗೊಳಿಸಿ yc initಅದನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಕಸ್ಟಮೈಸ್ ಮಾಡಲು:
vozerov@mba:~ $ yc init
Welcome! This command will take you through the configuration process.
Please go to https://oauth.yandex.ru/authorize?response_type=token&client_id= in order to obtain OAuth token.
Please enter OAuth token:
Please select cloud to use:
[1] cloud-b1gv67ihgfu3bp (id = b1gv67ihgfu3bpt24o0q)
[2] fevlake-cloud (id = b1g6bvup3toribomnh30)
Please enter your numeric choice: 2
Your current cloud has been set to 'fevlake-cloud' (id = b1g6bvup3toribomnh30).
Please choose folder to use:
[1] default (id = b1g5r6h11knotfr8vjp7)
[2] Create a new folder
Please enter your numeric choice: 1
Your current folder has been set to 'default' (id = b1g5r6h11knotfr8vjp7).
Do you want to configure a default Compute zone? [Y/n]
Which zone do you want to use as a profile default?
[1] ru-central1-a
[2] ru-central1-b
[3] ru-central1-c
[4] Don't set default zone
Please enter your numeric choice: 1
Your profile default Compute zone has been set to 'ru-central1-a'.
vozerov@mba:~ $ತಾತ್ವಿಕವಾಗಿ, ಪ್ರಕ್ರಿಯೆಯು ಸರಳವಾಗಿದೆ - ಮೊದಲು ನೀವು ಕ್ಲೌಡ್ ಅನ್ನು ನಿರ್ವಹಿಸಲು ಪ್ರಮಾಣ ಟೋಕನ್ ಅನ್ನು ಪಡೆಯಬೇಕು, ಕ್ಲೌಡ್ ಮತ್ತು ನೀವು ಬಳಸುವ ಫೋಲ್ಡರ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಿ.
ನೀವು ಒಂದೇ ಕ್ಲೌಡ್‌ನಲ್ಲಿ ಹಲವಾರು ಖಾತೆಗಳು ಅಥವಾ ಫೋಲ್ಡರ್‌ಗಳನ್ನು ಹೊಂದಿದ್ದರೆ, ನೀವು yc config ಪ್ರೊಫೈಲ್ ರಚಿಸಿ ಮತ್ತು ಅವುಗಳ ನಡುವೆ ಬದಲಾಯಿಸುವ ಮೂಲಕ ಪ್ರತ್ಯೇಕ ಸೆಟ್ಟಿಂಗ್‌ಗಳೊಂದಿಗೆ ಹೆಚ್ಚುವರಿ ಪ್ರೊಫೈಲ್‌ಗಳನ್ನು ರಚಿಸಬಹುದು.
ಮೇಲಿನ ವಿಧಾನಗಳ ಜೊತೆಗೆ, Yandex.Cloud ತಂಡವು ತುಂಬಾ ಚೆನ್ನಾಗಿ ಬರೆದಿದೆ ಕ್ಲೌಡ್ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಿರ್ವಹಿಸಲು. ನನ್ನ ಪಾಲಿಗೆ, ನಾನು ಜಿಟ್ ರೆಪೊಸಿಟರಿಯನ್ನು ಸಿದ್ಧಪಡಿಸಿದೆ, ಅಲ್ಲಿ ಲೇಖನದ ಭಾಗವಾಗಿ ರಚಿಸಲಾದ ಎಲ್ಲಾ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಾನು ವಿವರಿಸಿದ್ದೇನೆ - . ನಾವು ಮಾಸ್ಟರ್ ಶಾಖೆಯಲ್ಲಿ ಆಸಕ್ತಿ ಹೊಂದಿದ್ದೇವೆ, ಅದನ್ನು ಸ್ಥಳೀಯವಾಗಿ ಕ್ಲೋನ್ ಮಾಡೋಣ:
vozerov@mba:~ $ git clone https://github.com/rebrainme/yandex-cloud-events/ events
Cloning into 'events'...
remote: Enumerating objects: 100, done.
remote: Counting objects: 100% (100/100), done.
remote: Compressing objects: 100% (68/68), done.
remote: Total 100 (delta 37), reused 89 (delta 26), pack-reused 0
Receiving objects: 100% (100/100), 25.65 KiB | 168.00 KiB/s, done.
Resolving deltas: 100% (37/37), done.
vozerov@mba:~ $ cd events/terraform/ಟೆರಾಫಾರ್ಮ್‌ನಲ್ಲಿ ಬಳಸಲಾಗುವ ಎಲ್ಲಾ ಮುಖ್ಯ ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು main.tf ಫೈಲ್‌ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ. ಪ್ರಾರಂಭಿಸಲು, ಈ ಕೆಳಗಿನ ವಿಷಯದೊಂದಿಗೆ ಟೆರಾಫಾರ್ಮ್ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ private.auto.tfvars ಫೈಲ್ ಅನ್ನು ರಚಿಸಿ:
# Yandex Cloud Oauth token
yc_token = ""
# Yandex Cloud ID
yc_cloud_id = ""
# Yandex Cloud folder ID
yc_folder_id = ""
# Default Yandex Cloud Region
yc_region = "ru-central1-a"
# Cloudflare email
cf_email = ""
# Cloudflare token
cf_token = ""
# Cloudflare zone id
cf_zone_id = ""ಎಲ್ಲಾ ಅಸ್ಥಿರಗಳನ್ನು yc config ಪಟ್ಟಿಯಿಂದ ತೆಗೆದುಕೊಳ್ಳಬಹುದು, ಏಕೆಂದರೆ ನಾವು ಈಗಾಗಲೇ ಕನ್ಸೋಲ್ ಉಪಯುಕ್ತತೆಯನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಿದ್ದೇವೆ. ಆಕಸ್ಮಿಕವಾಗಿ ಖಾಸಗಿ ಡೇಟಾವನ್ನು ಪ್ರಕಟಿಸದಂತೆ, ತಕ್ಷಣವೇ private.auto.tfvars ಅನ್ನು .gitignore ಗೆ ಸೇರಿಸಲು ನಾನು ನಿಮಗೆ ಸಲಹೆ ನೀಡುತ್ತೇನೆ.
private.auto.tfvars ನಲ್ಲಿ ನಾವು ಕ್ಲೌಡ್‌ಫ್ಲೇರ್‌ನಿಂದ ಡೇಟಾವನ್ನು ಸಹ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ್ದೇವೆ - DNS ದಾಖಲೆಗಳನ್ನು ರಚಿಸಲು ಮತ್ತು ನಮ್ಮ ಸರ್ವರ್‌ಗಳಿಗೆ ಮುಖ್ಯ ಡೊಮೇನ್ events.kis.im ಅನ್ನು ಪ್ರಾಕ್ಸಿ ಮಾಡಲು. ನೀವು ಕ್ಲೌಡ್‌ಫ್ಲೇರ್ ಅನ್ನು ಬಳಸಲು ಬಯಸದಿದ್ದರೆ, ಮೈನ್.ಟಿಎಫ್‌ನಲ್ಲಿ ಕ್ಲೌಡ್‌ಫ್ಲೇರ್ ಪೂರೈಕೆದಾರರ ಪ್ರಾರಂಭವನ್ನು ತೆಗೆದುಹಾಕಿ ಮತ್ತು ಅಗತ್ಯ ಡಿಎನ್‌ಎಸ್ ದಾಖಲೆಗಳನ್ನು ರಚಿಸಲು ಜವಾಬ್ದಾರರಾಗಿರುವ ಡಿಎನ್‌ಎಸ್.ಟಿಎಫ್ ಫೈಲ್ ಅನ್ನು ತೆಗೆದುಹಾಕಿ.
ನಮ್ಮ ಕೆಲಸದಲ್ಲಿ ನಾವು ಎಲ್ಲಾ ಮೂರು ವಿಧಾನಗಳನ್ನು ಸಂಯೋಜಿಸುತ್ತೇವೆ - ವೆಬ್ ಇಂಟರ್ಫೇಸ್, ಕನ್ಸೋಲ್ ಉಪಯುಕ್ತತೆ ಮತ್ತು ಟೆರಾಫಾರ್ಮ್.
ವರ್ಚುವಲ್ ನೆಟ್ವರ್ಕ್ಗಳು
ನಿಜ ಹೇಳಬೇಕೆಂದರೆ, ನೀವು ಈ ಹಂತವನ್ನು ಬಿಟ್ಟುಬಿಡಬಹುದು, ಏಕೆಂದರೆ ನೀವು ಹೊಸ ಕ್ಲೌಡ್ ಅನ್ನು ರಚಿಸಿದಾಗ, ನೀವು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪ್ರತ್ಯೇಕ ನೆಟ್ವರ್ಕ್ ಅನ್ನು ಹೊಂದಿರುತ್ತೀರಿ ಮತ್ತು 3 ಸಬ್‌ನೆಟ್‌ಗಳನ್ನು ರಚಿಸಲಾಗುತ್ತದೆ - ಪ್ರತಿ ಲಭ್ಯತೆಯ ವಲಯಕ್ಕೆ ಒಂದು. ಆದರೆ ನಾವು ಇನ್ನೂ ನಮ್ಮ ಯೋಜನೆಗೆ ತನ್ನದೇ ಆದ ವಿಳಾಸದೊಂದಿಗೆ ಪ್ರತ್ಯೇಕ ನೆಟ್ವರ್ಕ್ ಮಾಡಲು ಬಯಸುತ್ತೇವೆ. Yandex.Cloud ನಲ್ಲಿ ನೆಟ್ವರ್ಕ್ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದರ ಸಾಮಾನ್ಯ ರೇಖಾಚಿತ್ರವನ್ನು ಕೆಳಗಿನ ಚಿತ್ರದಲ್ಲಿ ತೋರಿಸಲಾಗಿದೆ (ಪ್ರಾಮಾಣಿಕವಾಗಿ ತೆಗೆದುಕೊಳ್ಳಲಾಗಿದೆ )
ಆದ್ದರಿಂದ, ಸಂಪನ್ಮೂಲಗಳು ಪರಸ್ಪರ ಸಂವಹನ ನಡೆಸುವ ಸಾಮಾನ್ಯ ನೆಟ್ವರ್ಕ್ ಅನ್ನು ನೀವು ರಚಿಸುತ್ತೀರಿ. ಪ್ರತಿ ಲಭ್ಯತೆಯ ವಲಯಕ್ಕೆ, ತನ್ನದೇ ಆದ ವಿಳಾಸದೊಂದಿಗೆ ಸಬ್ನೆಟ್ ಅನ್ನು ರಚಿಸಲಾಗಿದೆ ಮತ್ತು ಸಾಮಾನ್ಯ ನೆಟ್ವರ್ಕ್ಗೆ ಸಂಪರ್ಕಿಸಲಾಗಿದೆ. ಪರಿಣಾಮವಾಗಿ, ಅದರಲ್ಲಿರುವ ಎಲ್ಲಾ ಕ್ಲೌಡ್ ಸಂಪನ್ಮೂಲಗಳು ವಿಭಿನ್ನ ಲಭ್ಯತೆಯ ವಲಯಗಳಲ್ಲಿದ್ದರೂ ಸಹ ಸಂವಹನ ಮಾಡಬಹುದು. ವಿವಿಧ ಕ್ಲೌಡ್ ನೆಟ್‌ವರ್ಕ್‌ಗಳಿಗೆ ಸಂಪರ್ಕಗೊಂಡಿರುವ ಸಂಪನ್ಮೂಲಗಳು ಬಾಹ್ಯ ವಿಳಾಸಗಳ ಮೂಲಕ ಮಾತ್ರ ಪರಸ್ಪರ ನೋಡಬಹುದು. ಅಂದಹಾಗೆ, ಈ ಮ್ಯಾಜಿಕ್ ಒಳಗೆ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ, .
ನೆಟ್ವರ್ಕ್ ರಚನೆಯನ್ನು ರೆಪೊಸಿಟರಿಯಿಂದ network.tf ಫೈಲ್‌ನಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ. ಅಲ್ಲಿ ನಾವು ಒಂದು ಸಾಮಾನ್ಯ ಖಾಸಗಿ ನೆಟ್ವರ್ಕ್ ಆಂತರಿಕವನ್ನು ರಚಿಸುತ್ತೇವೆ ಮತ್ತು ಅದಕ್ಕೆ ಮೂರು ಸಬ್‌ನೆಟ್‌ಗಳನ್ನು ವಿವಿಧ ಲಭ್ಯತೆಯ ವಲಯಗಳಲ್ಲಿ ಸಂಪರ್ಕಿಸುತ್ತೇವೆ - ಇಂಟರ್ನಲ್-ಎ (172.16.1.0/24), ಇಂಟರ್ನಲ್-ಬಿ (172.16.2.0/24), ಇಂಟರ್ನಲ್-ಸಿ (172.16.3.0/24 )
ಟೆರಾಫಾರ್ಮ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ನೆಟ್‌ವರ್ಕ್‌ಗಳನ್ನು ರಚಿಸಿ:
vozerov@mba:~/events/terraform (master) $ terraform init
... skipped ..
vozerov@mba:~/events/terraform (master) $ terraform apply -target yandex_vpc_subnet.internal-a -target yandex_vpc_subnet.internal-b -target yandex_vpc_subnet.internal-c
... skipped ...
Plan: 4 to add, 0 to change, 0 to destroy.
Do you want to perform these actions?
Terraform will perform the actions described above.
Only 'yes' will be accepted to approve.
Enter a value: yes
yandex_vpc_network.internal: Creating...
yandex_vpc_network.internal: Creation complete after 3s [id=enp2g2rhile7gbqlbrkr]
yandex_vpc_subnet.internal-a: Creating...
yandex_vpc_subnet.internal-b: Creating...
yandex_vpc_subnet.internal-c: Creating...
yandex_vpc_subnet.internal-a: Creation complete after 6s [id=e9b1dad6mgoj2v4funog]
yandex_vpc_subnet.internal-b: Creation complete after 7s [id=e2liv5i4amu52p64ac9p]
yandex_vpc_subnet.internal-c: Still creating... [10s elapsed]
yandex_vpc_subnet.internal-c: Creation complete after 10s [id=b0c2qhsj2vranoc9vhcq]
Apply complete! Resources: 4 added, 0 changed, 0 destroyed.ಗ್ರೇಟ್! ನಾವು ನಮ್ಮ ನೆಟ್ವರ್ಕ್ ಅನ್ನು ರಚಿಸಿದ್ದೇವೆ ಮತ್ತು ಈಗ ನಮ್ಮ ಆಂತರಿಕ ಸೇವೆಗಳನ್ನು ರಚಿಸಲು ಸಿದ್ಧರಿದ್ದೇವೆ.
ವರ್ಚುವಲ್ ಯಂತ್ರಗಳನ್ನು ರಚಿಸುವುದು
ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಲು, ನಾವು ಕೇವಲ ಎರಡು ವರ್ಚುವಲ್ ಯಂತ್ರಗಳನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ - ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ಮತ್ತು ಚಲಾಯಿಸಲು ನಮಗೆ ಮೊದಲನೆಯದು ಅಗತ್ಯವಿದೆ, ಎರಡನೆಯದು ಕಾಫ್ಕಾವನ್ನು ಚಲಾಯಿಸಲು, ನಾವು ಒಳಬರುವ ಸಂದೇಶಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಬಳಸುತ್ತೇವೆ. ಮತ್ತು ನಾವು ಇನ್ನೊಂದು ಯಂತ್ರವನ್ನು ರಚಿಸುತ್ತೇವೆ, ಅಲ್ಲಿ ನಾವು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲು ಪ್ರಮೀತಿಯಸ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುತ್ತೇವೆ.
ವರ್ಚುವಲ್ ಯಂತ್ರಗಳನ್ನು ಅನ್ಸಿಬಲ್ ಬಳಸಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಟೆರಾಫಾರ್ಮ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು, ನೀವು ಅನ್ಸಿಬಲ್‌ನ ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಗಳಲ್ಲಿ ಒಂದನ್ನು ಹೊಂದಿರುವಿರಾ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ಮತ್ತು ಅನ್ಸಿಬಲ್ ಗ್ಯಾಲಕ್ಸಿಯೊಂದಿಗೆ ಅಗತ್ಯ ಪಾತ್ರಗಳನ್ನು ಸ್ಥಾಪಿಸಿ:
vozerov@mba:~/events/terraform (master) $ cd ../ansible/
vozerov@mba:~/events/ansible (master) $ ansible-galaxy install -r requirements.yml
- cloudalchemy-prometheus (master) is already installed, skipping.
- cloudalchemy-grafana (master) is already installed, skipping.
- sansible.kafka (master) is already installed, skipping.
- sansible.zookeeper (master) is already installed, skipping.
- geerlingguy.docker (master) is already installed, skipping.
vozerov@mba:~/events/ansible (master) $ansible ಫೋಲ್ಡರ್ ಒಳಗೆ ನಾನು ಬಳಸುವ ಉದಾಹರಣೆ .ansible.cfg ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್ ಇದೆ. ಇದು ಸೂಕ್ತವಾಗಿ ಬರಬಹುದು.
ವರ್ಚುವಲ್ ಯಂತ್ರಗಳನ್ನು ರಚಿಸುವ ಮೊದಲು, ನೀವು ssh-agent ಚಾಲನೆಯಲ್ಲಿರುವಿರಿ ಮತ್ತು ssh ಕೀಲಿಯನ್ನು ಸೇರಿಸಿದ್ದೀರಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ, ಇಲ್ಲದಿದ್ದರೆ ಟೆರಾಫಾರ್ಮ್ ರಚಿಸಿದ ಯಂತ್ರಗಳಿಗೆ ಸಂಪರ್ಕಿಸಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ. ನಾನು, ಸಹಜವಾಗಿ, os x ನಲ್ಲಿ ದೋಷವನ್ನು ಕಂಡಿದ್ದೇನೆ: . ಇದು ಮತ್ತೆ ಸಂಭವಿಸದಂತೆ ತಡೆಯಲು, ಟೆರಾಫಾರ್ಮ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು env ಗೆ ಸಣ್ಣ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಸೇರಿಸಿ:
vozerov@mba:~/events/terraform (master) $ export OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YESಟೆರಾಫಾರ್ಮ್ ಹೊಂದಿರುವ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ನಾವು ಅಗತ್ಯ ಸಂಪನ್ಮೂಲಗಳನ್ನು ರಚಿಸುತ್ತೇವೆ:
vozerov@mba:~/events/terraform (master) $ terraform apply -target yandex_compute_instance.build -target yandex_compute_instance.monitoring -target yandex_compute_instance.kafka
yandex_vpc_network.internal: Refreshing state... [id=enp2g2rhile7gbqlbrkr]
data.yandex_compute_image.ubuntu_image: Refreshing state...
yandex_vpc_subnet.internal-a: Refreshing state... [id=e9b1dad6mgoj2v4funog]
An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
+ create
... skipped ...
Plan: 3 to add, 0 to change, 0 to destroy.
... skipped ...ಎಲ್ಲವೂ ಯಶಸ್ವಿಯಾಗಿ ಕೊನೆಗೊಂಡರೆ (ಮತ್ತು ಅದು ಇರಬೇಕು), ನಂತರ ನಾವು ಮೂರು ವರ್ಚುವಲ್ ಯಂತ್ರಗಳನ್ನು ಹೊಂದಿರುತ್ತೇವೆ:
- ಬಿಲ್ಡ್ - ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಲು ಮತ್ತು ನಿರ್ಮಿಸಲು ಒಂದು ಯಂತ್ರ. Ansible ಮೂಲಕ ಡಾಕರ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸ್ಥಾಪಿಸಲಾಗಿದೆ.
- ಮಾನಿಟರಿಂಗ್ - ಮೇಲ್ವಿಚಾರಣಾ ಯಂತ್ರ - ಅದರ ಮೇಲೆ ಸ್ಥಾಪಿಸಲಾದ ಪ್ರಮೀತಿಯಸ್ ಮತ್ತು ಗ್ರಾಫನಾ. ಲಾಗಿನ್ / ಪಾಸ್ವರ್ಡ್ ಪ್ರಮಾಣಿತ: ನಿರ್ವಾಹಕ / ನಿರ್ವಾಹಕ
- ಕಾಫ್ಕಾ ಎಂಬುದು ಕಾಫ್ಕಾವನ್ನು ಸ್ಥಾಪಿಸಿದ ಸಣ್ಣ ಯಂತ್ರವಾಗಿದ್ದು, ಪೋರ್ಟ್ 9092 ನಲ್ಲಿ ಪ್ರವೇಶಿಸಬಹುದು.
ಅವೆಲ್ಲವೂ ಸ್ಥಳದಲ್ಲಿವೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳೋಣ:
vozerov@mba:~/events (master) $ yc compute instance list
+----------------------+------------+---------------+---------+---------------+-------------+
| ID | NAME | ZONE ID | STATUS | EXTERNAL IP | INTERNAL IP |
+----------------------+------------+---------------+---------+---------------+-------------+
| fhm081u8bkbqf1pa5kgj | monitoring | ru-central1-a | RUNNING | 84.201.159.71 | 172.16.1.35 |
| fhmf37k03oobgu9jmd7p | kafka | ru-central1-a | RUNNING | 84.201.173.41 | 172.16.1.31 |
| fhmt9pl1i8sf7ga6flgp | build | ru-central1-a | RUNNING | 84.201.132.3 | 172.16.1.26 |
+----------------------+------------+---------------+---------+---------------+-------------+
ಸಂಪನ್ಮೂಲಗಳು ಸ್ಥಳದಲ್ಲಿವೆ ಮತ್ತು ಇಲ್ಲಿಂದ ನಾವು ಅವರ IP ವಿಳಾಸಗಳನ್ನು ಪಡೆಯಬಹುದು. ಕೆಳಗಿನವುಗಳಾದ್ಯಂತ ನಾನು ssh ಮೂಲಕ ಸಂಪರ್ಕಿಸಲು ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಲು IP ವಿಳಾಸಗಳನ್ನು ಬಳಸುತ್ತೇನೆ. ನೀವು ಕ್ಲೌಡ್‌ಫ್ಲೇರ್ ಖಾತೆಯನ್ನು ಟೆರಾಫಾರ್ಮ್‌ಗೆ ಸಂಪರ್ಕಿಸಿದ್ದರೆ, ಹೊಸದಾಗಿ ರಚಿಸಲಾದ DNS ಹೆಸರುಗಳನ್ನು ಬಳಸಲು ಹಿಂಜರಿಯಬೇಡಿ.
ಮೂಲಕ, ವರ್ಚುವಲ್ ಯಂತ್ರವನ್ನು ರಚಿಸುವಾಗ, ಆಂತರಿಕ IP ಮತ್ತು ಆಂತರಿಕ DNS ಹೆಸರನ್ನು ನೀಡಲಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ನೀವು ಹೆಸರಿನ ಮೂಲಕ ನೆಟ್ವರ್ಕ್ನಲ್ಲಿ ಸರ್ವರ್ಗಳನ್ನು ಪ್ರವೇಶಿಸಬಹುದು:
ubuntu@build:~$ ping kafka.ru-central1.internal
PING kafka.ru-central1.internal (172.16.1.31) 56(84) bytes of data.
64 bytes from kafka.ru-central1.internal (172.16.1.31): icmp_seq=1 ttl=63 time=1.23 ms
64 bytes from kafka.ru-central1.internal (172.16.1.31): icmp_seq=2 ttl=63 time=0.625 ms
^C
--- kafka.ru-central1.internal ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1001ms
rtt min/avg/max/mdev = 0.625/0.931/1.238/0.308 msಅಪ್ಲಿಕೇಶನ್ಗೆ kafk ನೊಂದಿಗೆ ಅಂತಿಮ ಬಿಂದುವನ್ನು ಸೂಚಿಸಲು ಇದು ನಮಗೆ ಉಪಯುಕ್ತವಾಗಿದೆ.
ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಜೋಡಿಸುವುದು
ಅದ್ಭುತವಾಗಿದೆ, ಸರ್ವರ್‌ಗಳಿವೆ, ಅಪ್ಲಿಕೇಶನ್ ಇದೆ - ಅದನ್ನು ಜೋಡಿಸುವುದು ಮತ್ತು ಪ್ರಕಟಿಸುವುದು ಮಾತ್ರ ಉಳಿದಿದೆ. ನಿರ್ಮಾಣಕ್ಕಾಗಿ ನಾವು ಸಾಮಾನ್ಯ ಡಾಕರ್ ಬಿಲ್ಡ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಆದರೆ ಇಮೇಜ್ ಶೇಖರಣೆಯಾಗಿ ನಾವು Yandex - ಕಂಟೇನರ್ ರಿಜಿಸ್ಟ್ರಿಯಿಂದ ಸೇವೆಯನ್ನು ಬಳಸುತ್ತೇವೆ. ಆದರೆ ಮೊದಲ ವಿಷಯಗಳು ಮೊದಲು.
ನಾವು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಬಿಲ್ಡ್ ಯಂತ್ರಕ್ಕೆ ನಕಲಿಸುತ್ತೇವೆ, ssh ಮೂಲಕ ಲಾಗ್ ಇನ್ ಮಾಡಿ ಮತ್ತು ಚಿತ್ರವನ್ನು ಜೋಡಿಸಿ:
vozerov@mba:~/events/terraform (master) $ cd ..
vozerov@mba:~/events (master) $ rsync -av app/ [email protected]:app/
... skipped ...
sent 3849 bytes received 70 bytes 7838.00 bytes/sec
total size is 3644 speedup is 0.93
vozerov@mba:~/events (master) $ ssh 84.201.132.3 -l ubuntu
ubuntu@build:~$ cd app
ubuntu@build:~/app$ sudo docker build -t app .
Sending build context to Docker daemon 6.144kB
Step 1/9 : FROM golang:latest AS build
... skipped ...
Successfully built 9760afd8ef65
Successfully tagged app:latestಅರ್ಧ ಯುದ್ಧ ಮುಗಿದಿದೆ - ಈಗ ನಾವು ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮೂಲಕ ಮತ್ತು ಕಾಫ್ಕಾಗೆ ಕಳುಹಿಸುವ ಮೂಲಕ ಅದರ ಕಾರ್ಯವನ್ನು ಪರಿಶೀಲಿಸಬಹುದು:
ubuntu@build:~/app$ sudo docker run --name app -d -p 8080:8080 app /app/app -kafka=kafka.ru-central1.internal:9092</code>
С локальной машинки можно отправить тестовый event и посмотреть на ответ:
<code>vozerov@mba:~/events (master) $ curl -D - -s -X POST -d '{"key1":"data1"}' http://84.201.132.3:8080/post
HTTP/1.1 200 OK
Content-Type: application/json
Date: Mon, 13 Apr 2020 13:53:54 GMT
Content-Length: 41
{"status":"ok","partition":0,"Offset":0}
vozerov@mba:~/events (master) $ಅಪ್ಲಿಕೇಶನ್ ರೆಕಾರ್ಡಿಂಗ್‌ನ ಯಶಸ್ಸಿನೊಂದಿಗೆ ಪ್ರತಿಕ್ರಿಯಿಸಿತು ಮತ್ತು ಸಂದೇಶವನ್ನು ಒಳಗೊಂಡಿರುವ ವಿಭಜನೆ ಮತ್ತು ಆಫ್‌ಸೆಟ್‌ನ ಐಡಿಯನ್ನು ಸೂಚಿಸುತ್ತದೆ. Yandex.Cloud ನಲ್ಲಿ ನೋಂದಾವಣೆ ರಚಿಸುವುದು ಮತ್ತು ಅಲ್ಲಿ ನಮ್ಮ ಚಿತ್ರವನ್ನು ಅಪ್ಲೋಡ್ ಮಾಡುವುದು ಮಾತ್ರ ಉಳಿದಿದೆ (ಮೂರು ಸಾಲುಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಇದನ್ನು ಹೇಗೆ ಮಾಡಬೇಕೆಂದು registry.tf ಫೈಲ್‌ನಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ). ಸಂಗ್ರಹಣೆಯನ್ನು ರಚಿಸಿ:
vozerov@mba:~/events/terraform (master) $ terraform apply -target yandex_container_registry.events
... skipped ...
Plan: 1 to add, 0 to change, 0 to destroy.
... skipped ...
Apply complete! Resources: 1 added, 0 changed, 0 destroyed.ಕಂಟೈನರ್ ರಿಜಿಸ್ಟ್ರಿಯಲ್ಲಿ ದೃಢೀಕರಿಸಲು ಹಲವಾರು ಮಾರ್ಗಗಳಿವೆ - ಪ್ರಮಾಣ ಟೋಕನ್, ಐಯಾಮ್ ಟೋಕನ್ ಅಥವಾ ಸೇವಾ ಖಾತೆ ಕೀ ಬಳಸಿ. ಈ ವಿಧಾನಗಳ ಬಗ್ಗೆ ಹೆಚ್ಚಿನ ವಿವರಗಳನ್ನು ದಸ್ತಾವೇಜನ್ನು ಕಾಣಬಹುದು. . ನಾವು ಸೇವಾ ಖಾತೆಯ ಕೀಲಿಯನ್ನು ಬಳಸುತ್ತೇವೆ, ಆದ್ದರಿಂದ ನಾವು ಖಾತೆಯನ್ನು ರಚಿಸುತ್ತೇವೆ:
vozerov@mba:~/events/terraform (master) $ terraform apply -target yandex_iam_service_account.docker -target yandex_resourcemanager_folder_iam_binding.puller -target yandex_resourcemanager_folder_iam_binding.pusher
... skipped ...
Apply complete! Resources: 3 added, 0 changed, 0 destroyed.ಈಗ ಉಳಿದಿರುವುದು ಅದರ ಕೀಲಿಯನ್ನು ಮಾಡುವುದು:
vozerov@mba:~/events/terraform (master) $ yc iam key create --service-account-name docker -o key.json
id: ajej8a06kdfbehbrh91p
service_account_id: ajep6d38k895srp9osij
created_at: "2020-04-13T14:00:30Z"
key_algorithm: RSA_2048ನಮ್ಮ ಸಂಗ್ರಹಣೆಯ ಐಡಿ ಬಗ್ಗೆ ನಾವು ಮಾಹಿತಿಯನ್ನು ಸ್ವೀಕರಿಸುತ್ತೇವೆ, ಕೀಲಿಯನ್ನು ವರ್ಗಾಯಿಸಿ ಮತ್ತು ಲಾಗ್ ಇನ್ ಮಾಡಿ:
vozerov@mba:~/events/terraform (master) $ scp key.json [email protected]:
key.json 100% 2392 215.1KB/s 00:00
vozerov@mba:~/events/terraform (master) $ ssh 84.201.132.3 -l ubuntu
ubuntu@build:~$ cat key.json | sudo docker login --username json_key --password-stdin cr.yandex
WARNING! Your password will be stored unencrypted in /home/ubuntu/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store
Login Succeeded
ubuntu@build:~$ಚಿತ್ರವನ್ನು ನೋಂದಾವಣೆಗೆ ಅಪ್ಲೋಡ್ ಮಾಡಲು, ನಮಗೆ ಕಂಟೇನರ್ ರಿಜಿಸ್ಟ್ರಿ ಐಡಿ ಅಗತ್ಯವಿದೆ, ನಾವು ಅದನ್ನು yc ಯುಟಿಲಿಟಿಯಿಂದ ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ:
vozerov@mba:~ $ yc container registry get events
id: crpdgj6c9umdhgaqjfmm
folder_id:
name: events
status: ACTIVE
created_at: "2020-04-13T13:56:41.914Z"ಅದರ ನಂತರ, ನಾವು ನಮ್ಮ ಚಿತ್ರವನ್ನು ಹೊಸ ಹೆಸರಿನೊಂದಿಗೆ ಟ್ಯಾಗ್ ಮಾಡುತ್ತೇವೆ ಮತ್ತು ಅಪ್ಲೋಡ್ ಮಾಡುತ್ತೇವೆ:
ubuntu@build:~$ sudo docker tag app cr.yandex/crpdgj6c9umdhgaqjfmm/events:v1
ubuntu@build:~$ sudo docker push cr.yandex/crpdgj6c9umdhgaqjfmm/events:v1
The push refers to repository [cr.yandex/crpdgj6c9umdhgaqjfmm/events]
8c286e154c6e: Pushed
477c318b05cb: Pushed
beee9f30bc1f: Pushed
v1: digest: sha256:1dd5aaa9dbdde2f60d833be0bed1c352724be3ea3158bcac3cdee41d47c5e380 size: 946ಚಿತ್ರವನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಲೋಡ್ ಮಾಡಲಾಗಿದೆ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸಬಹುದು:
vozerov@mba:~/events/terraform (master) $ yc container repository list
+----------------------+-----------------------------+
| ID | NAME |
+----------------------+-----------------------------+
| crpe8mqtrgmuq07accvn | crpdgj6c9umdhgaqjfmm/events |
+----------------------+-----------------------------+ಮೂಲಕ, ನೀವು Linux ಗಣಕದಲ್ಲಿ yc ಉಪಯುಕ್ತತೆಯನ್ನು ಸ್ಥಾಪಿಸಿದರೆ, ನೀವು ಆಜ್ಞೆಯನ್ನು ಬಳಸಬಹುದು
yc container registry configure-dockerಡಾಕರ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲು.
ತೀರ್ಮಾನಕ್ಕೆ
ನಾವು ಸಾಕಷ್ಟು ಕಠಿಣ ಕೆಲಸವನ್ನು ಮಾಡಿದ್ದೇವೆ ಮತ್ತು ಪರಿಣಾಮವಾಗಿ:
- ನಮ್ಮ ಭವಿಷ್ಯದ ಸೇವೆಯ ವಾಸ್ತುಶಿಲ್ಪದೊಂದಿಗೆ ನಾವು ಬಂದಿದ್ದೇವೆ.
- ನಮ್ಮ ವ್ಯವಹಾರ ತರ್ಕವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಾವು ಗೋಲಾಂಗ್‌ನಲ್ಲಿ ಬರೆದಿದ್ದೇವೆ.
- ನಾವು ಅದನ್ನು ಸಂಗ್ರಹಿಸಿ ಖಾಸಗಿ ಕಂಟೇನರ್ ರಿಜಿಸ್ಟ್ರಿಯಲ್ಲಿ ಸುರಿಯುತ್ತೇವೆ.
ಮುಂದಿನ ಭಾಗದಲ್ಲಿ, ನಾವು ಆಸಕ್ತಿದಾಯಕ ವಿಷಯಕ್ಕೆ ಹೋಗುತ್ತೇವೆ - ನಾವು ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಉತ್ಪಾದನೆಗೆ ಬಿಡುಗಡೆ ಮಾಡುತ್ತೇವೆ ಮತ್ತು ಅಂತಿಮವಾಗಿ ಅದರ ಮೇಲೆ ಲೋಡ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ. ಬದಲಾಯಿಸಬೇಡಿ!
ಈ ವಸ್ತುವು ತೆರೆದ ಕಾರ್ಯಾಗಾರ REBRAIN & Yandex.Cloud ನ ವೀಡಿಯೊ ರೆಕಾರ್ಡಿಂಗ್‌ನಲ್ಲಿದೆ: Yandex ಕ್ಲೌಡ್‌ನಲ್ಲಿ ನಾವು ಪ್ರತಿ ಸೆಕೆಂಡಿಗೆ 10 ವಿನಂತಿಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತೇವೆ -
ನೀವು ಆನ್‌ಲೈನ್‌ನಲ್ಲಿ ಇಂತಹ ಈವೆಂಟ್‌ಗಳಿಗೆ ಹಾಜರಾಗಲು ಮತ್ತು ನೈಜ ಸಮಯದಲ್ಲಿ ಪ್ರಶ್ನೆಗಳನ್ನು ಕೇಳಲು ಆಸಕ್ತಿ ಹೊಂದಿದ್ದರೆ, ಸಂಪರ್ಕಿಸಿ.
ಅಂತಹ ಈವೆಂಟ್ ಅನ್ನು ಹೋಸ್ಟ್ ಮಾಡುವ ಅವಕಾಶಕ್ಕಾಗಿ ನಾವು Yandex.Cloud ಗೆ ವಿಶೇಷ ಧನ್ಯವಾದಗಳನ್ನು ಹೇಳಲು ಬಯಸುತ್ತೇವೆ. ಅವರಿಗೆ ಲಿಂಕ್ -
ನೀವು ಕ್ಲೌಡ್‌ಗೆ ಚಲಿಸಬೇಕಾದರೆ ಅಥವಾ ನಿಮ್ಮ ಮೂಲಸೌಕರ್ಯದ ಕುರಿತು ಪ್ರಶ್ನೆಗಳನ್ನು ಹೊಂದಿದ್ದರೆ, .
PS ನಾವು ತಿಂಗಳಿಗೆ 2 ಉಚಿತ ಆಡಿಟ್‌ಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ, ಬಹುಶಃ ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್ ಅವುಗಳಲ್ಲಿ ಒಂದಾಗಿರಬಹುದು.
ಮೂಲ: www.habr.com