ಕುಬರ್ನೆಟ್ಸ್‌ಗಾಗಿ ಆಪರೇಟರ್‌ಗಳು: ಸ್ಟೇಟ್‌ಫುಲ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಹೇಗೆ ಚಲಾಯಿಸುವುದು

ಕುಬರ್ನೆಟ್ಸ್‌ನಲ್ಲಿನ ಸ್ಥಿತಿಯ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಸಮಸ್ಯೆ

ಸ್ಟೇಟ್‌ಲೆಸ್ ಎಂದು ವರ್ಗೀಕರಿಸಲಾದ ಪ್ರಕರಣಗಳಿಗೆ ಬಂದಾಗ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಮತ್ತು ಸೇವೆಗಳ ಕಾನ್ಫಿಗರೇಶನ್, ಲಾಂಚ್ ಮತ್ತು ಮತ್ತಷ್ಟು ಸ್ಕೇಲಿಂಗ್ ಸುಲಭ, ಅಂದರೆ. ಡೇಟಾವನ್ನು ಉಳಿಸದೆ. ಕುಬರ್ನೆಟ್ಸ್‌ನಲ್ಲಿ ಅದರ ಪ್ರಮಾಣಿತ API ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಅಂತಹ ಸೇವೆಗಳನ್ನು ಚಲಾಯಿಸಲು ಇದು ಅನುಕೂಲಕರವಾಗಿದೆ, ಏಕೆಂದರೆ ಎಲ್ಲವೂ "ಪೆಟ್ಟಿಗೆಯ ಹೊರಗೆ" ನಡೆಯುತ್ತದೆ: ಪ್ರಮಾಣಿತ ಸಂರಚನೆಗಳ ಪ್ರಕಾರ, ಯಾವುದೇ ನಿರ್ದಿಷ್ಟತೆ ಅಥವಾ ಮ್ಯಾಜಿಕ್ ಅನ್ನು ಒಳಗೊಳ್ಳದೆ.

ಸರಳವಾಗಿ ಹೇಳುವುದಾದರೆ, ಕಂಟೇನರ್‌ಗಳ ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ PHP/Ruby/Python ನಲ್ಲಿ ಬ್ಯಾಕೆಂಡ್‌ನ ಇನ್ನೂ ಐದು ಪ್ರತಿಗಳನ್ನು ಪ್ರಾರಂಭಿಸಲು, ನೀವು ಕೇವಲ 5 ಬಾರಿ ಹೊಸ ಸರ್ವರ್ ಅನ್ನು ಹೊಂದಿಸಿ ಮತ್ತು ಮೂಲಗಳನ್ನು ನಕಲಿಸಬೇಕಾಗುತ್ತದೆ. ಮೂಲ ಕೋಡ್ ಮತ್ತು init ಸ್ಕ್ರಿಪ್ಟ್ ಎರಡೂ ಚಿತ್ರದಲ್ಲಿರುವುದರಿಂದ, ಸ್ಥಿತಿಯಿಲ್ಲದ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸ್ಕೇಲಿಂಗ್ ಮಾಡುವುದು ಸಂಪೂರ್ಣವಾಗಿ ಪ್ರಾಥಮಿಕವಾಗುತ್ತದೆ. ಕಂಟೈನರ್‌ಗಳು ಮತ್ತು ಮೈಕ್ರೊ ಸರ್ವಿಸ್ ಆರ್ಕಿಟೆಕ್ಚರ್‌ನ ಅಭಿಮಾನಿಗಳಿಗೆ ಚೆನ್ನಾಗಿ ತಿಳಿದಿರುವಂತೆ, ತೊಂದರೆ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ರಾಜ್ಯಮಟ್ಟದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು, ಅಂದರೆ ಡೇಟಾಬೇಸ್‌ಗಳು ಮತ್ತು ಕ್ಯಾಷ್‌ಗಳಂತಹ ಡೇಟಾ ನಿರಂತರತೆಯೊಂದಿಗೆ (MySQL, PostgreSQL, Redis, ElasticSearch, Cassandra...). ಸ್ವತಂತ್ರವಾಗಿ ಕೋರಮ್ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಾಫ್ಟ್‌ವೇರ್ ಎರಡಕ್ಕೂ ಇದು ಅನ್ವಯಿಸುತ್ತದೆ (ಉದಾಹರಣೆಗೆ, ಪರ್ಕೋನಾ ಎಕ್ಸ್‌ಟ್ರಾಡಿಬಿ ಮತ್ತು ಕಸ್ಸಾಂಡ್ರಾ), ಮತ್ತು ಪ್ರತ್ಯೇಕ ನಿರ್ವಹಣಾ ಉಪಯುಕ್ತತೆಗಳ ಅಗತ್ಯವಿರುವ ಸಾಫ್ಟ್‌ವೇರ್ (ಉದಾಹರಣೆಗೆ Redis, MySQL, PostgreSQL...).

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

CoreOS ಆಪರೇಟರ್‌ಗಳು

ಕಾರ್ಯಾಚರಣೆಯ ಜ್ಞಾನವನ್ನು "ಪ್ರೋಗ್ರಾಂ" ಮಾಡಲು, ಕಳೆದ ವರ್ಷದ ಕೊನೆಯಲ್ಲಿ CoreOS ಯೋಜನೆ ಪರಿಚಯಿಸಲಾಗಿದೆ ಕುಬರ್ನೆಟ್ಸ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಾಗಿ "ಒಂದು ಹೊಸ ವರ್ಗದ ಸಾಫ್ಟ್‌ವೇರ್" - ಆಪರೇಟರ್‌ಗಳು (ಇಂಗ್ಲಿಷ್‌ನಿಂದ "ಕಾರ್ಯಾಚರಣೆ", ಅಂದರೆ "ಕಾರ್ಯಾಚರಣೆ").

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

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

ನಿರ್ವಾಹಕರು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತಾರೆ

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

ಇದು ಹೇಗೆ ಭಿನ್ನವಾಗಿದೆ ಸ್ಟೇಟ್‌ಫುಲ್ ಸೆಟ್‌ಗಳು, ಡೇಟಾ ಸಂಗ್ರಹಣೆ ಅಥವಾ ಸ್ಥಿರ IP ಗಳಂತಹ ಸ್ಥಿತಿಯ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಒದಗಿಸಲು ಕ್ಲಸ್ಟರ್ ಅಗತ್ಯವಿರುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆಯೇ? ಅಂತಹ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ, ನಿರ್ವಾಹಕರು ಬಳಸಬಹುದು ಸ್ಟೇಟ್‌ಫುಲ್ ಸೆಟ್‌ಗಳು (ಬದಲಿಗೆ ರೆಪ್ಲಿಕಾಸೆಟ್ಸ್) ಆಧಾರವಾಗಿ, ಕೊಡುಗೆ ಹೆಚ್ಚುವರಿ ಯಾಂತ್ರೀಕೃತಗೊಂಡ: ಕ್ರ್ಯಾಶ್‌ಗಳ ಸಂದರ್ಭದಲ್ಲಿ ಅಗತ್ಯ ಕ್ರಮಗಳನ್ನು ನಿರ್ವಹಿಸಿ, ಬ್ಯಾಕ್‌ಅಪ್‌ಗಳನ್ನು ಮಾಡಿ, ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ನವೀಕರಿಸಿ, ಇತ್ಯಾದಿ.

ಆದ್ದರಿಂದ, ಇದೆಲ್ಲವೂ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ? ನಿರ್ವಾಹಕರು ನಿರ್ವಾಹಕ ಡೀಮನ್ ಆಗಿದ್ದಾರೆ:

1. ಕುಬರ್ನೆಟ್ಸ್‌ನಲ್ಲಿ ಈವೆಂಟ್ API ಗೆ ಚಂದಾದಾರರಾಗುತ್ತಾರೆ;
2. ಅದರಿಂದ ಸಿಸ್ಟಮ್ ಬಗ್ಗೆ ಡೇಟಾವನ್ನು ಪಡೆಯುತ್ತದೆ (ಅದರ ಬಗ್ಗೆ ರೆಪ್ಲಿಕಾಸೆಟ್ಸ್, ಬೀಜಕೋಶಗಳು, ಸೇವೆಗಳು ಮತ್ತು ಇತ್ಯಾದಿ.);
3. ಬಗ್ಗೆ ಡೇಟಾವನ್ನು ಪಡೆಯುತ್ತದೆ ಮೂರನೇ ವ್ಯಕ್ತಿಯ ಸಂಪನ್ಮೂಲಗಳು (ಕೆಳಗಿನ ಉದಾಹರಣೆಗಳನ್ನು ನೋಡಿ);
4. ನೋಟ/ಬದಲಾವಣೆಗೆ ಪ್ರತಿಕ್ರಿಯಿಸುತ್ತದೆ ಮೂರನೇ ವ್ಯಕ್ತಿಯ ಸಂಪನ್ಮೂಲಗಳು (ಉದಾಹರಣೆಗೆ, ಗಾತ್ರವನ್ನು ಬದಲಾಯಿಸಲು, ಆವೃತ್ತಿಯನ್ನು ಬದಲಾಯಿಸಿ, ಮತ್ತು ಹೀಗೆ);
5. ವ್ಯವಸ್ಥೆಯ ಸ್ಥಿತಿಯಲ್ಲಿನ ಬದಲಾವಣೆಗಳಿಗೆ ಪ್ರತಿಕ್ರಿಯಿಸುತ್ತದೆ (ಅದರ ಬಗ್ಗೆ ರೆಪ್ಲಿಕಾಸೆಟ್ಸ್, ಬೀಜಕೋಶಗಳು, ಸೇವೆಗಳು ಮತ್ತು ಇತ್ಯಾದಿ.);
6. ಅತ್ಯಂತ ಪ್ರಮುಖವಾದದ್ದು:
   1. ಕುಬರ್ನೆಟ್ಸ್ API ಗೆ ಅಗತ್ಯವಿರುವ ಎಲ್ಲವನ್ನೂ ರಚಿಸಲು ಕರೆ ಮಾಡುತ್ತದೆ (ಮತ್ತೆ, ತನ್ನದೇ ಆದ ರೆಪ್ಲಿಕಾಸೆಟ್ಸ್, ಬೀಜಕೋಶಗಳು, ಸೇವೆಗಳು...),
   2. ಕೆಲವು ಮ್ಯಾಜಿಕ್ ಅನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ (ಸರಳಗೊಳಿಸಲು, ಆಪರೇಟರ್ ಸ್ವತಃ ಪಾಡ್‌ಗಳಿಗೆ ಹೋಗಿ ಆಜ್ಞೆಗಳನ್ನು ಕರೆಯುತ್ತಾರೆ ಎಂದು ನೀವು ಭಾವಿಸಬಹುದು, ಉದಾಹರಣೆಗೆ, ಕ್ಲಸ್ಟರ್‌ಗೆ ಸೇರಲು ಅಥವಾ ಆವೃತ್ತಿಯನ್ನು ನವೀಕರಿಸುವಾಗ ಡೇಟಾ ಸ್ವರೂಪವನ್ನು ಅಪ್‌ಗ್ರೇಡ್ ಮಾಡಲು).

ವಾಸ್ತವವಾಗಿ, ಚಿತ್ರದಿಂದ ನೋಡಬಹುದಾದಂತೆ, ಪ್ರತ್ಯೇಕ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಕುಬರ್ನೆಟ್ಸ್ಗೆ ಸರಳವಾಗಿ ಸೇರಿಸಲಾಗುತ್ತದೆ (ನಿಯಮಿತ ನಿಯೋಜನೆ с ರೆಪ್ಲಿಕಾಸೆಟ್), ಇದನ್ನು ಆಪರೇಟರ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಇದು ಸಾಮಾನ್ಯ ಪಾಡ್‌ನಲ್ಲಿ ವಾಸಿಸುತ್ತದೆ (ಸಾಮಾನ್ಯವಾಗಿ ಕೇವಲ ಒಂದು) ಮತ್ತು ನಿಯಮದಂತೆ, ಅದರ ಜವಾಬ್ದಾರಿ ಮಾತ್ರ ನೇಮ್‌ಸ್ಪೇಸ್. ಈ ಆಪರೇಟರ್ ಅಪ್ಲಿಕೇಶನ್ ಅದರ API ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ - ಆದರೂ ನೇರವಾಗಿ ಅಲ್ಲ, ಆದರೆ ಮೂಲಕ ಮೂರನೇ ವ್ಯಕ್ತಿಯ ಸಂಪನ್ಮೂಲಗಳು ಕುಬರ್ನೆಟ್ಸ್ನಲ್ಲಿ.

ಹೀಗಾಗಿ, ನಾವು ರಚಿಸಿದ ನಂತರ ನೇಮ್‌ಸ್ಪೇಸ್ ಆಪರೇಟರ್, ನಾವು ಅದನ್ನು ಸೇರಿಸಬಹುದು ಮೂರನೇ ವ್ಯಕ್ತಿಯ ಸಂಪನ್ಮೂಲಗಳು.

ಇತ್ಯಾದಿಗಳಿಗೆ ಉದಾಹರಣೆ (ವಿವರಗಳಿಗಾಗಿ ಕೆಳಗೆ ನೋಡಿ):

apiVersion: etcd.coreos.com/v1beta1
kind: Cluster
metadata:
  name: example-etcd-cluster
spec:
  size: 3
  version: 3.1.0

ಸ್ಥಿತಿಸ್ಥಾಪಕ ಹುಡುಕಾಟಕ್ಕೆ ಉದಾಹರಣೆ:

apiVersion: enterprises.upmc.com/v1
kind: ElasticsearchCluster
metadata:
  name: example-es-cluster
spec:
  client-node-replicas: 3
  master-node-replicas: 2
  data-node-replicas: 3
  zones:
  - us-east-1c
  - us-east-1d
  - us-east-1e
  data-volume-size: 10Gi
  java-options: "-Xms1024m -Xmx1024m"
  snapshot:
    scheduler-enabled: true
    bucket-name: elasticsnapshots99
    cron-schedule: "@every 2m"
  storage:
    type: gp2
    storage-class-provisioner: kubernetes.io/aws-ebs

ಆಪರೇಟರ್‌ಗಳಿಗೆ ಅಗತ್ಯತೆಗಳು

ಆಪರೇಟರ್‌ಗಳಲ್ಲಿ ಕೆಲಸ ಮಾಡುವಾಗ ಎಂಜಿನಿಯರ್‌ಗಳು ಪಡೆದ ಮುಖ್ಯ ಮಾದರಿಗಳನ್ನು CoreOS ರೂಪಿಸಿದೆ. ಎಲ್ಲಾ ಆಪರೇಟರ್‌ಗಳು ವೈಯಕ್ತಿಕವಾಗಿದ್ದರೂ (ಅದರ ಸ್ವಂತ ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ಅಗತ್ಯತೆಗಳೊಂದಿಗೆ ನಿರ್ದಿಷ್ಟ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ರಚಿಸಲಾಗಿದೆ), ಅವರ ರಚನೆಯು ಈ ಕೆಳಗಿನ ಅವಶ್ಯಕತೆಗಳನ್ನು ವಿಧಿಸುವ ಒಂದು ರೀತಿಯ ಚೌಕಟ್ಟನ್ನು ಆಧರಿಸಿರಬೇಕು:

1. ಅನುಸ್ಥಾಪನೆಯನ್ನು ಒಂದೇ ಮೂಲಕ ಮಾಡಬೇಕು ನಿಯೋಜನೆ: kubectl create -f SOME_OPERATOR_URL/deployment.yaml - ಮತ್ತು ಹೆಚ್ಚುವರಿ ಕ್ರಮಗಳ ಅಗತ್ಯವಿಲ್ಲ.
2. ಕುಬರ್ನೆಟ್ಸ್‌ನಲ್ಲಿ ಆಪರೇಟರ್ ಅನ್ನು ಸ್ಥಾಪಿಸುವಾಗ, ಹೊಸ ಮೂರನೇ ವ್ಯಕ್ತಿಯ ಪ್ರಕಾರವನ್ನು ರಚಿಸಬೇಕು (ಮೂರನೇ ಪಕ್ಷದ ಸಂಪನ್ಮೂಲ). ಅಪ್ಲಿಕೇಶನ್ ನಿದರ್ಶನಗಳನ್ನು ಪ್ರಾರಂಭಿಸಲು (ಕ್ಲಸ್ಟರ್ ನಿದರ್ಶನಗಳು) ಮತ್ತು ಅವುಗಳನ್ನು ಮತ್ತಷ್ಟು ನಿರ್ವಹಿಸಲು (ಆವೃತ್ತಿಗಳನ್ನು ನವೀಕರಿಸುವುದು, ಮರುಗಾತ್ರಗೊಳಿಸುವಿಕೆ, ಇತ್ಯಾದಿ), ಬಳಕೆದಾರರು ಈ ಪ್ರಕಾರವನ್ನು ಬಳಸುತ್ತಾರೆ.
3. ಸಾಧ್ಯವಾದಾಗಲೆಲ್ಲಾ, ನೀವು ಕುಬರ್ನೆಟ್ಸ್‌ನಲ್ಲಿ ನಿರ್ಮಿಸಲಾದ ಪ್ರಾಚೀನತೆಯನ್ನು ಬಳಸಬೇಕು ಸೇವೆಗಳು и ರೆಪ್ಲಿಕಾಸೆಟ್ಸ್ಚೆನ್ನಾಗಿ ಪರೀಕ್ಷಿಸಿದ ಮತ್ತು ಅರ್ಥವಾಗುವ ಕೋಡ್ ಅನ್ನು ಬಳಸಲು.
4. ಆಪರೇಟರ್‌ಗಳ ಹಿಂದುಳಿದ ಹೊಂದಾಣಿಕೆ ಮತ್ತು ಬಳಕೆದಾರ-ರಚಿಸಿದ ಸಂಪನ್ಮೂಲಗಳ ಹಳೆಯ ಆವೃತ್ತಿಗಳಿಗೆ ಬೆಂಬಲದ ಅಗತ್ಯವಿದೆ.
5. ಆಪರೇಟರ್ ಅನ್ನು ತೆಗೆದುಹಾಕಿದರೆ, ಅಪ್ಲಿಕೇಶನ್ ಸ್ವತಃ ಬದಲಾವಣೆಗಳಿಲ್ಲದೆ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದನ್ನು ಮುಂದುವರಿಸಬೇಕು.
6. ಬಳಕೆದಾರರು ಬಯಸಿದ ಅಪ್ಲಿಕೇಶನ್ ಆವೃತ್ತಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಆವೃತ್ತಿಯ ನವೀಕರಣಗಳನ್ನು ಆರ್ಕೆಸ್ಟ್ರೇಟ್ ಮಾಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಸಾಫ್ಟ್‌ವೇರ್ ನವೀಕರಣಗಳ ಕೊರತೆಯು ಕಾರ್ಯಾಚರಣೆಯ ಮತ್ತು ಭದ್ರತಾ ಸಮಸ್ಯೆಗಳ ಸಾಮಾನ್ಯ ಮೂಲವಾಗಿದೆ, ಆದ್ದರಿಂದ ಆಪರೇಟರ್‌ಗಳು ಈ ವಿಷಯದಲ್ಲಿ ಬಳಕೆದಾರರಿಗೆ ಸಹಾಯ ಮಾಡಬೇಕು.
7. ಪಾಡ್‌ಗಳು, ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳು ಮತ್ತು ನೆಟ್‌ವರ್ಕ್‌ನಲ್ಲಿ ಸಂಭಾವ್ಯ ವೈಫಲ್ಯಗಳನ್ನು ಗುರುತಿಸುವ ಚೋಸ್ ಮಂಕಿಯಂತಹ ಸಾಧನದೊಂದಿಗೆ ಆಪರೇಟರ್‌ಗಳನ್ನು ಪರೀಕ್ಷಿಸಬೇಕು.

ಇತ್ಯಾದಿ ಆಪರೇಟರ್

ಆಪರೇಟರ್ ಅನುಷ್ಠಾನದ ಉದಾಹರಣೆ - ಇತ್ಯಾದಿ ಆಪರೇಟರ್, ತಯಾರಾದ ಈ ಪರಿಕಲ್ಪನೆಯ ಘೋಷಣೆಯ ದಿನದಂದು. ಕೋರಂ ಅನ್ನು ನಿರ್ವಹಿಸುವ ಅಗತ್ಯತೆ, ಕ್ಲಸ್ಟರ್ ಸದಸ್ಯತ್ವವನ್ನು ಮರುಸಂರಚಿಸುವ ಅಗತ್ಯತೆ, ಬ್ಯಾಕ್‌ಅಪ್‌ಗಳನ್ನು ರಚಿಸುವುದು ಇತ್ಯಾದಿಗಳ ಕಾರಣದಿಂದಾಗಿ etcd ಕ್ಲಸ್ಟರ್ ಕಾನ್ಫಿಗರೇಶನ್ ಸಂಕೀರ್ಣವಾಗಬಹುದು. ಉದಾಹರಣೆಗೆ, etcd ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಸ್ಕೇಲಿಂಗ್ ಮಾಡುವುದು ಎಂದರೆ ನೀವು ಹೊಸ ಕ್ಲಸ್ಟರ್ ಸದಸ್ಯರಿಗೆ DNS ಹೆಸರನ್ನು ರಚಿಸಬೇಕು, ಹೊಸ etcd ಘಟಕವನ್ನು ಪ್ರಾರಂಭಿಸಬೇಕು ಮತ್ತು ಹೊಸ ಸದಸ್ಯರ ಬಗ್ಗೆ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಎಚ್ಚರಿಸಬೇಕು (etcdctl ಸದಸ್ಯರನ್ನು ಸೇರಿಸಿ) ಆಪರೇಟರ್‌ನ ಸಂದರ್ಭದಲ್ಲಿ, ಬಳಕೆದಾರರು ಕ್ಲಸ್ಟರ್ ಗಾತ್ರವನ್ನು ಮಾತ್ರ ಬದಲಾಯಿಸಬೇಕಾಗುತ್ತದೆ - ಉಳಿದಂತೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸಂಭವಿಸುತ್ತದೆ.

ಮತ್ತು CoreOS ನಲ್ಲಿ etcd ಅನ್ನು ಸಹ ರಚಿಸಲಾಗಿರುವುದರಿಂದ, ಅದರ ಆಪರೇಟರ್ ಮೊದಲು ಕಾಣಿಸಿಕೊಳ್ಳುವುದನ್ನು ನೋಡಲು ಸಾಕಷ್ಟು ತಾರ್ಕಿಕವಾಗಿದೆ. ಅವನು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತಾನೆ? ಆಪರೇಟರ್ ಲಾಜಿಕ್ ಇತ್ಯಾದಿ ಮೂರು ಘಟಕಗಳಿಂದ ನಿರ್ಧರಿಸಲಾಗುತ್ತದೆ:

1. ಗಮನಿಸಿ. ಕುಬರ್ನೆಟ್ಸ್ API ಅನ್ನು ಬಳಸಿಕೊಂಡು ಕ್ಲಸ್ಟರ್‌ನ ಸ್ಥಿತಿಯನ್ನು ನಿರ್ವಾಹಕರು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುತ್ತಾರೆ.
2. ವಿಶ್ಲೇಷಣೆ. ಪ್ರಸ್ತುತ ಸ್ಥಿತಿ ಮತ್ತು ಬಯಸಿದ ಒಂದರ ನಡುವಿನ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತದೆ (ಬಳಕೆದಾರರ ಸಂರಚನೆಯಿಂದ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ).
3. ಕ್ರಿಯೆ. ಇತ್ಯಾದಿ ಮತ್ತು/ಅಥವಾ ಕುಬರ್ನೆಟ್ಸ್ ಸೇವಾ API ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಪತ್ತೆಯಾದ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಪರಿಹರಿಸುತ್ತದೆ.

ಈ ತರ್ಕವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು, ಆಪರೇಟರ್‌ನಲ್ಲಿ ಕಾರ್ಯಗಳನ್ನು ಸಿದ್ಧಪಡಿಸಲಾಗಿದೆ ರಚಿಸಿ/ನಾಶ ಮಾಡಿ (ಇತ್ಯಾದಿ ಕ್ಲಸ್ಟರ್ ಸದಸ್ಯರನ್ನು ರಚಿಸುವುದು ಮತ್ತು ಅಳಿಸುವುದು) ಮತ್ತು ಮರುಗಾತ್ರಗೊಳಿಸಿ (ಕ್ಲಸ್ಟರ್ ಸದಸ್ಯರ ಸಂಖ್ಯೆಯಲ್ಲಿ ಬದಲಾವಣೆ). ನೆಟ್‌ಫ್ಲಿಕ್ಸ್‌ನಿಂದ ಚೋಸ್ ಮಂಕಿಯ ಹೋಲಿಕೆಯಲ್ಲಿ ರಚಿಸಲಾದ ಉಪಯುಕ್ತತೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಅದರ ಕಾರ್ಯಾಚರಣೆಯ ನಿಖರತೆಯನ್ನು ಪರಿಶೀಲಿಸಲಾಗಿದೆ, ಅಂದರೆ. ಇತ್ಯಾದಿಗಳನ್ನು ಯಾದೃಚ್ಛಿಕವಾಗಿ ಕೊಲ್ಲುವುದು.

ಇತ್ಯಾದಿಗಳ ಸಂಪೂರ್ಣ ಕಾರ್ಯಾಚರಣೆಗಾಗಿ, ಆಪರೇಟರ್ ಹೆಚ್ಚುವರಿ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ: ಬ್ಯಾಕಪ್ (ಸ್ವಯಂಚಾಲಿತ ಮತ್ತು ಬಳಕೆದಾರರಿಗೆ ಬ್ಯಾಕಪ್ ನಕಲುಗಳನ್ನು ರಚಿಸುವುದು ಅಗೋಚರವಾಗಿರುತ್ತದೆ - ಸಂರಚನೆಯಲ್ಲಿ ಅವುಗಳನ್ನು ಎಷ್ಟು ಬಾರಿ ತಯಾರಿಸಬೇಕು ಮತ್ತು ಎಷ್ಟು ಸಂಗ್ರಹಿಸಬೇಕು ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸಲು ಸಾಕು - ಮತ್ತು ಅವುಗಳಿಂದ ಡೇಟಾವನ್ನು ಮರುಸ್ಥಾಪಿಸುವುದು) ಮತ್ತು ಅಪ್ಗ್ರೇಡ್ (ಅಲಭ್ಯತೆಯಿಲ್ಲದೆ etcd ಸ್ಥಾಪನೆಗಳನ್ನು ನವೀಕರಿಸಲಾಗುತ್ತಿದೆ).

ಆಪರೇಟರ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು ಹೇಗೆ?

$ kubectl create -f https://coreos.com/operators/etcd/latest/deployment.yaml
$ kubectl create -f https://coreos.com/operators/etcd/latest/example-etcd-cluster.yaml
$ kubectl get pods
NAME                             READY     STATUS    RESTARTS   AGE
etcd-cluster-0000                1/1       Running   0          23s
etcd-cluster-0001                1/1       Running   0          16s
etcd-cluster-0002                1/1       Running   0          8s
etcd-cluster-backup-tool-rhygq   1/1       Running   0          18s

etcd ಆಪರೇಟರ್‌ನ ಪ್ರಸ್ತುತ ಸ್ಥಿತಿಯು ಬೀಟಾ ಆವೃತ್ತಿಯಾಗಿದ್ದು, ರನ್ ಮಾಡಲು Kubernetes 1.5.3+ ಮತ್ತು etcd 3.0+ ಅಗತ್ಯವಿದೆ. ಮೂಲ ಕೋಡ್ ಮತ್ತು ದಸ್ತಾವೇಜನ್ನು (ಬಳಕೆಗೆ ಸೂಚನೆಗಳನ್ನು ಒಳಗೊಂಡಂತೆ) ನಲ್ಲಿ ಲಭ್ಯವಿದೆ GitHub.

CoreOS ನಿಂದ ಮತ್ತೊಂದು ಉದಾಹರಣೆ ಅನುಷ್ಠಾನವನ್ನು ರಚಿಸಲಾಗಿದೆ - ಪ್ರಮೀತಿಯಸ್ ಆಪರೇಟರ್, ಆದರೆ ಇದು ಇನ್ನೂ ಆಲ್ಫಾ ಆವೃತ್ತಿಯಲ್ಲಿದೆ (ಎಲ್ಲಾ ಯೋಜಿತ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿಲ್ಲ).

ಸ್ಥಿತಿ ಮತ್ತು ನಿರೀಕ್ಷೆಗಳು

ಕುಬರ್ನೆಟ್ಸ್ ಆಪರೇಟರ್‌ಗಳ ಘೋಷಣೆಯಿಂದ 5 ತಿಂಗಳುಗಳು ಕಳೆದಿವೆ. ಅಧಿಕೃತ CoreOS ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಇನ್ನೂ ಎರಡು ಅಳವಡಿಕೆಗಳು ಲಭ್ಯವಿವೆ (ಇತ್ಯಾದಿ ಮತ್ತು ಪ್ರಮೀತಿಯಸ್‌ಗಾಗಿ). ಇಬ್ಬರೂ ಇನ್ನೂ ತಮ್ಮ ಸ್ಥಿರ ಆವೃತ್ತಿಗಳನ್ನು ತಲುಪಿಲ್ಲ, ಆದರೆ ಬದ್ಧತೆಗಳನ್ನು ಪ್ರತಿದಿನವೂ ಆಚರಿಸಲಾಗುತ್ತದೆ.

ಡೆವಲಪರ್‌ಗಳು "ಬಳಕೆದಾರರು ತಮ್ಮ ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್‌ಗಳಲ್ಲಿ ಪೋಸ್ಟ್‌ಗ್ರೆಸ್ ಆಪರೇಟರ್‌ಗಳು, ಕಸ್ಸಂಡ್ರಾ ಆಪರೇಟರ್‌ಗಳು ಅಥವಾ ರೆಡಿಸ್ ಆಪರೇಟರ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸುವ ಭವಿಷ್ಯವನ್ನು ರೂಪಿಸುತ್ತಾರೆ ಮತ್ತು ಸ್ಥಿತಿಯಿಲ್ಲದ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಪ್ರತಿಕೃತಿಗಳನ್ನು ನಿಯೋಜಿಸುವಷ್ಟು ಸುಲಭವಾಗಿ ಈ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಸ್ಕೇಲೆಬಲ್ ಘಟಕಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತಾರೆ." ಪ್ರಥಮ ಮೂರನೇ ಪಕ್ಷದ ಡೆವಲಪರ್‌ಗಳಿಂದ ನಿರ್ವಾಹಕರು ನಿಜವಾಗಿಯೂ ಕಾಣಿಸಿಕೊಳ್ಳಲು ಪ್ರಾರಂಭಿಸಿತು:

• ಸ್ಥಿತಿಸ್ಥಾಪಕ ಹುಡುಕಾಟ ಆಪರೇಟರ್ UPMC ಎಂಟರ್‌ಪ್ರೈಸಸ್‌ನಿಂದ;
• PostgreSQL ಆಪರೇಟರ್ ಕುರುಕುಲಾದ ಡೇಟಾದಿಂದ (ಮಾರ್ಚ್ 2017 ರ ಕೊನೆಯಲ್ಲಿ ಘೋಷಿಸಲಾಗಿದೆ);
• ರೂಕ್ ಆಪರೇಟರ್ Ceph (ರೂಕ್ ಆಲ್ಫಾ ಸ್ಥಿತಿಯಲ್ಲಿದೆ) ಆಧಾರಿತ ವಿತರಣಾ ಡೇಟಾ ಶೇಖರಣಾ ವ್ಯವಸ್ಥೆಯ ಲೇಖಕರಿಂದ;
• ಓಪನ್‌ಸ್ಟಾಕ್ ಆಪರೇಟರ್‌ಗಳು SAP CCloud ನಿಂದ.

ಫೆಬ್ರವರಿ 2017 ರಲ್ಲಿ ಬ್ರಸೆಲ್ಸ್‌ನಲ್ಲಿ ನಡೆದ ಅತಿದೊಡ್ಡ ಯುರೋಪಿಯನ್ ಉಚಿತ ಸಾಫ್ಟ್‌ವೇರ್ ಕಾನ್ಫರೆನ್ಸ್ FOSDEM ನಲ್ಲಿ, CoreOS ನಿಂದ ಜೋಶ್ ವುಡ್ ಆಪರೇಟರ್‌ಗಳನ್ನು ಘೋಷಿಸಿದರು ವರದಿ (ಲಿಂಕ್‌ನಲ್ಲಿ ವೀಡಿಯೊ ಲಭ್ಯವಿದೆ!), ಇದು ವಿಶಾಲವಾದ ಮುಕ್ತ ಮೂಲ ಸಮುದಾಯದಲ್ಲಿ ಈ ಪರಿಕಲ್ಪನೆಯ ಜನಪ್ರಿಯತೆಯ ಬೆಳವಣಿಗೆಗೆ ಕೊಡುಗೆ ನೀಡುತ್ತದೆ.

ಪಿಎಸ್ ಲೇಖನದಲ್ಲಿ ನಿಮ್ಮ ಆಸಕ್ತಿಗೆ ಧನ್ಯವಾದಗಳು! ನಮ್ಮ ಹಬ್‌ಗೆ ಚಂದಾದಾರರಾಗಿ, DevOps ಮತ್ತು GNU/Linux ಸಿಸ್ಟಮ್ ಆಡಳಿತದಲ್ಲಿ ಹೊಸ ಸಾಮಗ್ರಿಗಳು ಮತ್ತು ಪಾಕವಿಧಾನಗಳನ್ನು ಕಳೆದುಕೊಳ್ಳದಂತೆ - ನಾವು ಅವುಗಳನ್ನು ನಿಯಮಿತವಾಗಿ ಪ್ರಕಟಿಸುತ್ತೇವೆ!

ಮೂಲ: www.habr.com