ಪ್ರೊಹೋಸ್ಟರ್ > Блог > ಆಡಳಿತ > ಕುಬರ್ನೆಟ್ಸ್ ಅಭಿವೃದ್ಧಿಗಾಗಿ ಸ್ಕ್ಯಾಫೋಲ್ಡ್ನ ವಿಮರ್ಶೆ

ಕುಬರ್ನೆಟ್ಸ್ ಅಭಿವೃದ್ಧಿಗಾಗಿ ಸ್ಕ್ಯಾಫೋಲ್ಡ್ನ ವಿಮರ್ಶೆ

ಕುಬರ್ನೆಟ್ಸ್ ಅಭಿವೃದ್ಧಿಗಾಗಿ ಸ್ಕ್ಯಾಫೋಲ್ಡ್ನ ವಿಮರ್ಶೆ

ಒಂದೂವರೆ ವರ್ಷದ ಹಿಂದೆ, ಮಾರ್ಚ್ 5, 2018 ರಂದು, ಗೂಗಲ್ ತನ್ನ ಓಪನ್ ಸೋರ್ಸ್ ಪ್ರಾಜೆಕ್ಟ್‌ನ ಮೊದಲ ಆಲ್ಫಾ ಆವೃತ್ತಿಯನ್ನು CI/CD ಗಾಗಿ ಬಿಡುಗಡೆ ಮಾಡಿದೆ ಸ್ಕ್ಯಾಫೋಲ್ಡ್, ಅವರ ಗುರಿ "ಸರಳ ಮತ್ತು ಪುನರಾವರ್ತನೀಯ ಕುಬರ್ನೆಟ್ಸ್ ಅಭಿವೃದ್ಧಿ" ಅನ್ನು ರಚಿಸುವುದು, ಇದರಿಂದಾಗಿ ಅಭಿವರ್ಧಕರು ಆಡಳಿತಕ್ಕಿಂತ ಹೆಚ್ಚಾಗಿ ಅಭಿವೃದ್ಧಿಯ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸಬಹುದು. ಸ್ಕಫೊಲ್ಡ್ ಬಗ್ಗೆ ಏನು ಆಸಕ್ತಿದಾಯಕವಾಗಿದೆ? ಅದು ಬದಲಾದಂತೆ, ಇದು ಡೆವಲಪರ್‌ಗೆ ಮತ್ತು ಬಹುಶಃ ಆಪರೇಷನ್ ಇಂಜಿನಿಯರ್‌ಗೆ ಪ್ರಬಲ ಸಾಧನವಾಗಬಲ್ಲ ತನ್ನ ತೋಳಿನ ಮೇಲೆ ಕೆಲವು ತಂತ್ರಗಳನ್ನು ಹೊಂದಿದೆ. ಯೋಜನೆ ಮತ್ತು ಅದರ ಸಾಮರ್ಥ್ಯಗಳೊಂದಿಗೆ ಪರಿಚಯ ಮಾಡಿಕೊಳ್ಳೋಣ.

NB: ಮೂಲಕ, ನಾವು ಈಗಾಗಲೇ ನಮ್ಮ ಸಾಮಾನ್ಯದಲ್ಲಿ ಸ್ಕಫೊಲ್ಡ್ ಬಗ್ಗೆ ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಮಾತನಾಡಿದ್ದೇವೆ ಡೆವಲಪರ್ ಪರಿಕರಗಳ ವಿಮರ್ಶೆ, ಅವರ ಜೀವನವು ಕುಬರ್ನೆಟ್ಸ್ನೊಂದಿಗೆ ಸಂಪರ್ಕ ಹೊಂದಿದೆ.

ಸಿದ್ಧಾಂತ. ಉದ್ದೇಶ ಮತ್ತು ಸಾಮರ್ಥ್ಯಗಳು

ಆದ್ದರಿಂದ, ಸಾಮಾನ್ಯವಾಗಿ ಹೇಳುವುದಾದರೆ, Skaffold CI/CD ಚಕ್ರವನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುತ್ತದೆ (ನಿರ್ಮಾಣ, ಪುಶ್, ನಿಯೋಜಿಸುವ ಹಂತಗಳಲ್ಲಿ), ಡೆವಲಪರ್ ಪ್ರಾಂಪ್ಟ್ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ನೀಡುತ್ತದೆ, ಅಂದರೆ. ನಂತರದ ಕೋಡ್ ಬದಲಾವಣೆಗಳ ಫಲಿತಾಂಶವನ್ನು ತ್ವರಿತವಾಗಿ ಸ್ವೀಕರಿಸುವ ಸಾಮರ್ಥ್ಯ - ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ನವೀಕರಿಸಿದ ಅಪ್ಲಿಕೇಶನ್‌ನ ರೂಪದಲ್ಲಿ. ಮತ್ತು ಇದು ವಿಭಿನ್ನ ಸರ್ಕ್ಯೂಟ್‌ಗಳಲ್ಲಿ ಕೆಲಸ ಮಾಡಬಹುದು (ದೇವ, ಹಂತ, ಉತ್ಪಾದನೆ ...), ಇದಕ್ಕಾಗಿ ರೋಲ್‌ಔಟ್‌ಗೆ ಅನುಗುಣವಾದ ಪೈಪ್‌ಲೈನ್‌ಗಳನ್ನು ವಿವರಿಸಲು ಸ್ಕಫೊಲ್ಡ್ ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಸ್ಕಫೊಲ್ಡ್‌ನ ಮೂಲ ಕೋಡ್ ಅನ್ನು Go ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ, ವಿತರಿಸುವವರು ಉಚಿತ ಅಪಾಚೆ ಪರವಾನಗಿ 2.0 (GitHub) ಅಡಿಯಲ್ಲಿ.

ಮುಖ್ಯ ಕಾರ್ಯಗಳು ಮತ್ತು ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ನೋಡೋಣ. ಮೊದಲನೆಯದು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಒಳಗೊಂಡಿದೆ:

  • ಸಿಐ/ಸಿಡಿ ಪೈಪ್‌ಲೈನ್‌ಗಳನ್ನು ರಚಿಸಲು ಸ್ಕ್ಯಾಫೋಲ್ಡ್ ಪರಿಕರಗಳನ್ನು ನೀಡುತ್ತದೆ.
  • ಹಿನ್ನೆಲೆಯಲ್ಲಿ ಮೂಲ ಕೋಡ್‌ನಲ್ಲಿನ ಬದಲಾವಣೆಗಳನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲು ಮತ್ತು ಕಂಟೇನರ್ ಇಮೇಜ್‌ಗಳಲ್ಲಿ ಕೋಡ್ ಅನ್ನು ಜೋಡಿಸುವ ಸ್ವಯಂಚಾಲಿತ ಪ್ರಕ್ರಿಯೆಯನ್ನು ರನ್ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಈ ಚಿತ್ರಗಳನ್ನು ಡಾಕರ್ ರಿಜಿಸ್ಟ್ರಿಯಲ್ಲಿ ಪ್ರಕಟಿಸಿ ಮತ್ತು ಅವುಗಳನ್ನು ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್‌ಗೆ ನಿಯೋಜಿಸುತ್ತದೆ.
  • ರೆಪೊಸಿಟರಿಯಲ್ಲಿರುವ ಫೈಲ್‌ಗಳನ್ನು ಕಂಟೇನರ್‌ನಲ್ಲಿ ಕೆಲಸ ಮಾಡುವ ಡೈರೆಕ್ಟರಿಯೊಂದಿಗೆ ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡುತ್ತದೆ.
  • ಕಂಟೇನರ್-ಸ್ಟ್ರಕ್ಚರ್-ಟೆಸ್ಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪರೀಕ್ಷಿಸುತ್ತದೆ.
  • ಮುಂದಕ್ಕೆ ಬಂದರುಗಳು.
  • ಕಂಟೇನರ್‌ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಅಪ್ಲಿಕೇಶನ್‌ನ ಲಾಗ್‌ಗಳನ್ನು ಓದುತ್ತದೆ.
  • Java, Node.js, Python, Go ನಲ್ಲಿ ಬರೆಯಲಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಡೀಬಗ್ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಈಗ ವೈಶಿಷ್ಟ್ಯಗಳ ಬಗ್ಗೆ:

  • ಸ್ಕಫೊಲ್ಡ್ ಸ್ವತಃ ಯಾವುದೇ ಕ್ಲಸ್ಟರ್-ಸೈಡ್ ಘಟಕಗಳನ್ನು ಹೊಂದಿಲ್ಲ. ಅಂದರೆ, ಈ ಉಪಯುಕ್ತತೆಯನ್ನು ಬಳಸಲು ಕುಬರ್ನೆಟ್ಸ್ ಅನ್ನು ಮತ್ತಷ್ಟು ಕಾನ್ಫಿಗರ್ ಮಾಡುವ ಅಗತ್ಯವಿಲ್ಲ.
  • ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ವಿವಿಧ ಪೈಪ್‌ಲೈನ್‌ಗಳು. ನೀವು ಅಭಿವೃದ್ಧಿಪಡಿಸುತ್ತಿರುವಾಗ ಸ್ಥಳೀಯ Minikube ಗೆ ಕೋಡ್ ಅನ್ನು ಹೊರತರಬೇಕೇ ಮತ್ತು ನಂತರ ಹಂತ ಅಥವಾ ಉತ್ಪಾದನೆಗೆ? ಈ ಉದ್ದೇಶಕ್ಕಾಗಿ ಇವೆ ಪ್ರೊಫೈಲ್ಗಳು ಮತ್ತು ಬಳಕೆದಾರರ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳು, ಪರಿಸರ ವೇರಿಯಬಲ್‌ಗಳು ಮತ್ತು ಫ್ಲ್ಯಾಗ್‌ಗಳು, ಇದು ಒಂದು ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ವಿವಿಧ ಪೈಪ್‌ಲೈನ್‌ಗಳನ್ನು ವಿವರಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
  • ಸಿಎಲ್ಐ. YAML ನಲ್ಲಿ ಕನ್ಸೋಲ್ ಉಪಯುಕ್ತತೆ ಮತ್ತು ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳು ಮಾತ್ರ. ಅಂತರ್ಜಾಲದಲ್ಲಿ ನೀವು ರಚಿಸುವ ಪ್ರಯತ್ನಗಳ ಉಲ್ಲೇಖಗಳನ್ನು ಕಾಣಬಹುದು ಪ್ರಾಯೋಗಿಕ GUIಆದಾಗ್ಯೂ, ಈ ಸಮಯದಲ್ಲಿ ಇದು ಬಹುಶಃ ಯಾರಿಗಾದರೂ ಅವನ ಅಗತ್ಯವಿದೆ ಎಂದು ಅರ್ಥ, ಆದರೆ ನಿಜವಾಗಿಯೂ ಅಲ್ಲ.
  • ಮಾಡ್ಯುಲಾರಿಟಿ. ಸ್ಕಫೊಲ್ಡ್ ಒಂದು ಸ್ವತಂತ್ರ ಹಾರ್ವೆಸ್ಟರ್ ಅಲ್ಲ, ಆದರೆ ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಗಳಿಗಾಗಿ ಪ್ರತ್ಯೇಕ ಮಾಡ್ಯೂಲ್‌ಗಳು ಅಥವಾ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪರಿಹಾರಗಳನ್ನು ಬಳಸಲು ಶ್ರಮಿಸುತ್ತದೆ.

ನಂತರದ ವಿವರಣೆ:

  • ಅಸೆಂಬ್ಲಿ ಹಂತದಲ್ಲಿ ನೀವು ಬಳಸಬಹುದು:
    • ಡಾಕರ್ ಸ್ಥಳೀಯವಾಗಿ, ಕನಿಕೋ ಬಳಸಿ ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಅಥವಾ ಗೂಗಲ್ ಕ್ಲೌಡ್ ಬಿಲ್ಡ್‌ನಲ್ಲಿ ನಿರ್ಮಿಸುವುದು;
    • ಸ್ಥಳೀಯವಾಗಿ ಬಾಜೆಲ್;
    • ಜಿಬ್ ಮಾವೆನ್ ಮತ್ತು ಜಿಬ್ ಗ್ರೇಡಲ್ ಸ್ಥಳೀಯವಾಗಿ ಅಥವಾ ಗೂಗಲ್ ಕ್ಲೌಡ್ ಬಿಲ್ಡ್‌ನಲ್ಲಿ;
    • ಕಸ್ಟಮ್ ಬಿಲ್ಡ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಸ್ಥಳೀಯವಾಗಿ ರನ್ ಆಗುತ್ತವೆ. ನೀವು ಇನ್ನೊಂದು (ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳುವ/ಪರಿಚಿತ/...) ಬಿಲ್ಡ್ ಪರಿಹಾರವನ್ನು ರನ್ ಮಾಡಬೇಕಾದರೆ, ಅದನ್ನು ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ ಇದರಿಂದ ಸ್ಕಫೊಲ್ಡ್ ಅದನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ (ದಸ್ತಾವೇಜನ್ನು ಉದಾಹರಣೆ) ಸ್ಕ್ರಿಪ್ಟ್ ಬಳಸಿ ಕರೆಯಬಹುದಾದ ಯಾವುದೇ ಸಂಗ್ರಾಹಕವನ್ನು ಬಳಸಲು ಇದು ನಿಮ್ಮನ್ನು ಅನುಮತಿಸುತ್ತದೆ;
  • ಪರೀಕ್ಷಾ ಹಂತದಲ್ಲಿ, ಈಗಾಗಲೇ ಉಲ್ಲೇಖಿಸಲಾಗಿದೆ ಕಂಟೇನರ್-ರಚನೆ-ಪರೀಕ್ಷೆ;
  • ನಿಯೋಜನೆಗಾಗಿ ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಒದಗಿಸಲಾಗಿದೆ:
    • ಕುಬೆಕ್ಟ್ಲ್;
    • ಹೆಲ್ಮ್;
    • ಕಸ್ಟಮೈಸ್ ಮಾಡಿ.

ಇದಕ್ಕೆ ಧನ್ಯವಾದಗಳು, ಸ್ಕಫೊಲ್ಡ್ ಅನ್ನು ಅನನ್ಯ ಎಂದು ಕರೆಯಬಹುದು CI/CD ನಿರ್ಮಿಸಲು ಚೌಕಟ್ಟು. ಇದನ್ನು ಬಳಸುವಾಗ ಕೆಲಸದ ಹರಿವಿನ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ (ಯೋಜನೆಯ ದಾಖಲಾತಿಯಿಂದ):

ಕುಬರ್ನೆಟ್ಸ್ ಅಭಿವೃದ್ಧಿಗಾಗಿ ಸ್ಕ್ಯಾಫೋಲ್ಡ್ನ ವಿಮರ್ಶೆ

ಸಾಮಾನ್ಯ ಪರಿಭಾಷೆಯಲ್ಲಿ ಸ್ಕಫೊಲ್ಡ್ ಅವರ ಕೆಲಸವು ಹೇಗೆ ಕಾಣುತ್ತದೆ?

  1. ಮೂಲ ಕೋಡ್ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿನ ಬದಲಾವಣೆಗಳನ್ನು ಉಪಯುಕ್ತತೆಯು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುತ್ತದೆ. ಫೈಲ್‌ಗಳಿಗೆ ಮಾರ್ಪಾಡುಗಳನ್ನು ಮಾಡಿದರೆ, ಅವುಗಳನ್ನು ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿರುವ ಅಪ್ಲಿಕೇಶನ್ ಪಾಡ್‌ನೊಂದಿಗೆ ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಲಾಗುತ್ತದೆ. ಸಾಧ್ಯವಾದರೆ, ಚಿತ್ರವನ್ನು ಮರುನಿರ್ಮಾಣ ಮಾಡದೆಯೇ. ಇಲ್ಲದಿದ್ದರೆ, ಹೊಸ ಚಿತ್ರವನ್ನು ಜೋಡಿಸಲಾಗಿದೆ.
  2. ಜೋಡಿಸಲಾದ ಚಿತ್ರವನ್ನು ಕಂಟೇನರ್-ಸ್ಟ್ರಕ್ಚರ್-ಟೆಸ್ಟ್ ಬಳಸಿ ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ, ಟ್ಯಾಗ್ ಮಾಡಲಾಗಿದೆ ಮತ್ತು ಡಾಕರ್ ರಿಜಿಸ್ಟ್ರಿಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ.
  3. ಇದರ ನಂತರ, ಚಿತ್ರವನ್ನು ನಿಯೋಜಿಸಲಾಗಿದೆ - ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್ನಲ್ಲಿ ನಿಯೋಜಿಸಲಾಗಿದೆ.
  4. ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಉಡಾವಣೆಯನ್ನು ಪ್ರಾರಂಭಿಸಿದರೆ skaffold dev, ನಂತರ ನಾವು ಅಪ್ಲಿಕೇಶನ್‌ನಿಂದ ಲಾಗ್‌ಗಳನ್ನು ಸ್ವೀಕರಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ ಮತ್ತು ಎಲ್ಲಾ ಕ್ರಿಯೆಗಳನ್ನು ಮತ್ತೆ ಪುನರಾವರ್ತಿಸಲು ಸ್ಕಫೊಲ್ಡ್ ಬದಲಾವಣೆಗಳಿಗಾಗಿ ಕಾಯುತ್ತದೆ.

ಕುಬರ್ನೆಟ್ಸ್ ಅಭಿವೃದ್ಧಿಗಾಗಿ ಸ್ಕ್ಯಾಫೋಲ್ಡ್ನ ವಿಮರ್ಶೆ
ಸ್ಕಫೊಲ್ಡ್ ಕಾರ್ಯಾಚರಣೆಯ ಮುಖ್ಯ ಹಂತಗಳ ವಿವರಣೆ

ಅಭ್ಯಾಸ ಮಾಡಿ. ಸ್ಕ್ಯಾಫೋಲ್ಡ್ ಪ್ರಯತ್ನಿಸುತ್ತಿದೆ

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

ಸ್ಕ್ಯಾಫೋಲ್ಡ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿ:

curl -Lo skaffold https://storage.googleapis.com/skaffold/releases/latest/skaffold-linux-amd64
chmod +x skaffold
sudo mv skaffold /usr/local/bin
skaffold version
v0.37.1

ಅಗತ್ಯ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ಸ್ಕಫೊಲ್ಡ್‌ನ ರೆಪೊಸಿಟರಿಯನ್ನು ಕ್ಲೋನ್ ಮಾಡೋಣ:

git clone https://github.com/GoogleContainerTools/skaffold
cd skaffold/examples/microservices

ನಾನು ಎರಡು ಪಾಡ್‌ಗಳೊಂದಿಗೆ ಉದಾಹರಣೆಯನ್ನು ಆರಿಸಿಕೊಂಡಿದ್ದೇನೆ, ಪ್ರತಿಯೊಂದೂ ಒಂದು ಸಣ್ಣ Go ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಹೊಂದಿದೆ. ಒಂದು ಅಪ್ಲಿಕೇಶನ್ ಮುಂಭಾಗ (leeroy-web), ಇದು ವಿನಂತಿಯನ್ನು ಎರಡನೇ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ - ಬ್ಯಾಕೆಂಡ್ (leeroy-app). ಅದು ಹೇಗೆ ಕಾಣುತ್ತದೆ ಎಂದು ನೋಡೋಣ:

~/skaffold/examples/microservices # tree
.
├── leeroy-app
│   ├── app.go
│   ├── Dockerfile
│   └── kubernetes
│       └── deployment.yaml
├── leeroy-web
│   ├── Dockerfile
│   ├── kubernetes
│   │   └── deployment.yaml
│   └── web.go
├── README.adoc
└── skaffold.yaml
 
4 directories, 8 files

leeroy-app ಮತ್ತು leeroy-web ಈ ಕೋಡ್ ಅನ್ನು ಸ್ಥಳೀಯವಾಗಿ ನಿರ್ಮಿಸಲು Go ಕೋಡ್ ಮತ್ತು ಸರಳ ಡಾಕರ್‌ಫೈಲ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿವೆ:

~/skaffold/examples/microservices # cat leeroy-app/Dockerfile
FROM golang:1.12.9-alpine3.10 as builder
COPY app.go .
RUN go build -o /app .
 
FROM alpine:3.10
CMD ["./app"]
COPY --from=builder /app .

ನಾನು ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್ ಅನ್ನು ನೀಡುವುದಿಲ್ಲ - ಅದನ್ನು ತಿಳಿದುಕೊಳ್ಳಲು ಸಾಕು leeroy-web ವಿನಂತಿಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ ಮತ್ತು ಅವುಗಳನ್ನು ಪ್ರಾಕ್ಸಿ ಮಾಡುತ್ತದೆ leeroy-app. ಆದ್ದರಿಂದ ಕಡತಗಳಲ್ಲಿ Deployment.yaml ಇದಕ್ಕಾಗಿ ಮಾತ್ರ ಸೇವೆ ಇದೆ app (ಆಂತರಿಕ ಮಾರ್ಗಕ್ಕಾಗಿ). ಪಾಡ್ ಪೋರ್ಟ್ web ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ತ್ವರಿತ ಪ್ರವೇಶಕ್ಕಾಗಿ ನಾವು ಅದನ್ನು ನಮಗೆ ರವಾನಿಸುತ್ತೇವೆ.

ತೋರುತ್ತಿದೆ skaffold.yaml:

~/skaffold/examples/microservices # cat skaffold.yaml
apiVersion: skaffold/v1beta13
kind: Config
build:
  artifacts:
    - image: leeroy-web
      context: ./leeroy-web/
    - image: leeroy-app
      context: ./leeroy-app/
deploy:
  kubectl:
    manifests:
      - ./leeroy-web/kubernetes/*
      - ./leeroy-app/kubernetes/*
portForward:
  - resourceType: deployment
    resourceName: leeroy-web
    port: 8080
    localPort: 9000

ಮೇಲೆ ತಿಳಿಸಿದ ಎಲ್ಲಾ ಹಂತಗಳನ್ನು ಇಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ. ಈ ಸಂರಚನೆಯ ಜೊತೆಗೆ, ಜಾಗತಿಕ ಸೆಟ್ಟಿಂಗ್‌ಗಳೊಂದಿಗೆ ಫೈಲ್ ಸಹ ಇದೆ - ~/.skaffold/config. ಇದನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಅಥವಾ CLI ಮೂಲಕ ಸಂಪಾದಿಸಬಹುದು - ಉದಾಹರಣೆಗೆ, ಈ ರೀತಿ:

skaffold config set --global local-cluster true

ಈ ಆಜ್ಞೆಯು ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಅನ್ನು ಹೊಂದಿಸುತ್ತದೆ local-cluster ಅರ್ಥದಲ್ಲಿ true, ಅದರ ನಂತರ ಸ್ಕಫೊಲ್ಡ್ ರಿಮೋಟ್ ರಿಜಿಸ್ಟ್ರಿಗೆ ಚಿತ್ರಗಳನ್ನು ತಳ್ಳಲು ಪ್ರಯತ್ನಿಸುವುದಿಲ್ಲ. ನೀವು ಸ್ಥಳೀಯವಾಗಿ ಅಭಿವೃದ್ಧಿಪಡಿಸುತ್ತಿದ್ದರೆ, ಸ್ಥಳೀಯವಾಗಿ ಚಿತ್ರಗಳನ್ನು ನಿರ್ಮಿಸಲು ನೀವು ಈ ಆಜ್ಞೆಯನ್ನು ಬಳಸಬಹುದು.

ಗೆ ಹಿಂತಿರುಗಿ skaffold.yaml:

  • ವೇದಿಕೆಯ ಮೇಲೆ build ನೀವು ಚಿತ್ರವನ್ನು ಸ್ಥಳೀಯವಾಗಿ ಸಂಗ್ರಹಿಸಬೇಕು ಮತ್ತು ಉಳಿಸಬೇಕು ಎಂದು ನಾವು ಸೂಚಿಸುತ್ತೇವೆ. ನಿರ್ಮಾಣವು ಮೊದಲ ಬಾರಿಗೆ ರನ್ ಆದ ನಂತರ, ನಾವು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ನೋಡುತ್ತೇವೆ: 
    // т.к. Minikube создает кластер в отдельной виртуальной машине,
// придется проникнуть внутрь, чтобы найти образы
# minikube ssh
$ docker images
REPOSITORY                                TAG                                                                IMAGE ID            CREATED             SIZE 
leeroy-app                                7d55a50803590b2ff62e47e6f240723451f3ef6f8c89aeb83b34e661aa287d2e   7d55a5080359        4 hours ago         13MB 
leeroy-app                                v0.37.1-171-g0270a0c-dirty                                         7d55a5080359        4 hours ago         13MB
leeroy-web                                5063bfb29d984db1ff70661f17d6efcc5537f2bbe6aa6907004ad1ab38879681   5063bfb29d98        5 hours ago         13.1MB
leeroy-web                                v0.37.1-171-g0270a0c-dirty                                         5063bfb29d98        5 hours ago         13.1MB

    ನೀವು ನೋಡುವಂತೆ, ಸ್ಕಫೊಲ್ಡ್ ಚಿತ್ರಗಳನ್ನು ಸ್ವತಃ ಟ್ಯಾಗ್ ಮಾಡಿದ್ದಾರೆ. ಮೂಲಕ, ಹಲವಾರು ಟ್ಯಾಗಿಂಗ್ ನೀತಿಗಳನ್ನು ಬೆಂಬಲಿಸಲಾಗುತ್ತದೆ.

  • ಮತ್ತಷ್ಟು ಸಂರಚನೆಯಲ್ಲಿ ಇದನ್ನು ಸೂಚಿಸಲಾಗುತ್ತದೆ context: ./leeroy-app/, ಅಂದರೆ ಚಿತ್ರವನ್ನು ಯಾವ ಸಂದರ್ಭದಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿದೆ.
  • ನಿಯೋಜನೆ ಹಂತದಲ್ಲಿ, ಅಗತ್ಯ ಮ್ಯಾನಿಫೆಸ್ಟ್‌ಗಳಿಗಾಗಿ ನಾವು kubectl ಮತ್ತು ಮುಖವಾಡವನ್ನು ಬಳಸುತ್ತೇವೆ ಎಂದು ನಿರ್ಧರಿಸಲಾಗುತ್ತದೆ.
  • PortForward: ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ಪೋರ್ಟ್‌ಗಳನ್ನು ಹೇಗೆ ಫಾರ್ವರ್ಡ್ ಮಾಡುತ್ತೇವೆ ಎಂಬುದನ್ನು ಹೋಲುತ್ತದೆ kubectl port-forward, ಈ ಆಜ್ಞೆಯನ್ನು ಕರೆಯಲು ನಾವು Skaffold ಗೆ ಸೂಚನೆಗಳನ್ನು ನೀಡುತ್ತೇವೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಸ್ಥಳೀಯ ಪೋರ್ಟ್ 9000 ಅನ್ನು ಹೆಸರಿನೊಂದಿಗೆ ನಿಯೋಜನೆಯಲ್ಲಿ 8080 ಗೆ ರವಾನಿಸಲಾಗುತ್ತದೆ leeroy-web.

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

ಉಡಾವಣಾ ಫಲಿತಾಂಶ ಇಲ್ಲಿದೆ skaffold dev --port-forward ಮರುಜೋಡಣೆ ಮಾಡುವಾಗ:

ಕುಬರ್ನೆಟ್ಸ್ ಅಭಿವೃದ್ಧಿಗಾಗಿ ಸ್ಕ್ಯಾಫೋಲ್ಡ್ನ ವಿಮರ್ಶೆ

ಮೊದಲಿಗೆ, ಸಂಗ್ರಹವನ್ನು ಬಳಸಲಾಗುತ್ತಿದೆ ಎಂದು ನೀವು ನೋಡಬಹುದು. ಮುಂದೆ, ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಜೋಡಿಸಲಾಗಿದೆ, ನಿಯೋಜಿಸಲಾಗಿದೆ ಮತ್ತು ಪೋರ್ಟ್‌ಗಳನ್ನು ಫಾರ್ವರ್ಡ್ ಮಾಡಲಾಗುತ್ತದೆ. ನಿರ್ದಿಷ್ಟಪಡಿಸಿದಾಗಿನಿಂದ --port-forward, ಸ್ಕಾಫೋಲ್ಡ್ ಪೋರ್ಟ್ ಅನ್ನು ಗೆ ಫಾರ್ವರ್ಡ್ ಮಾಡಿದೆ web, ಅವರು ಕೇಳಿದಂತೆ, ಆದರೆ ಇಲ್ಲಿ app ಅವನು ತನ್ನ ಸ್ವಂತ ವಿವೇಚನೆಯಿಂದ ಎಸೆದನು (ಹತ್ತಿರದ ಉಚಿತವನ್ನು ಆರಿಸಿಕೊಂಡನು). ಇದರ ನಂತರ, ನಾವು ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಂದ ಮೊದಲ ಲಾಗ್‌ಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತೇವೆ.

ಇದು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸೋಣವೇ?

~/skaffold/examples/microservices # kubectl get po
NAME                          READY   STATUS    RESTARTS   AGE
leeroy-app-6998dfcc95-2nxvf   1/1     Running   0          103s
leeroy-web-69f7d47c9d-5ff77   1/1     Running   0          103s
~/skaffold/examples/microservices # curl localhost:9000
leeroooooy app!!!

ಫೈಲ್ ಅನ್ನು ಮಾರ್ಪಡಿಸಲಾಗುತ್ತಿದೆ leeroy-app/app.go - ಕೆಲವು ಸೆಕೆಂಡುಗಳು ಹಾದುಹೋಗುತ್ತವೆ ... ಮತ್ತು:

~/skaffold/examples/microservices # kubectl get po
NAME                          READY   STATUS    RESTARTS   AGE
leeroy-app-ffd79d986-l6nwp    1/1     Running   0          11s
leeroy-web-69f7d47c9d-5ff77   1/1     Running   0          4m59s
~/skaffold/examples/microservices # curl localhost:9000
leeroooooy Habr!!!

ಅದೇ ಸಮಯದಲ್ಲಿ, ಸ್ಕಫೊಲ್ಡ್ ಸ್ವತಃ ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ಮೊದಲಿನಂತೆಯೇ ಅದೇ ವಿಷಯವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ, ಒಂದು ಬಿಂದುವನ್ನು ಹೊರತುಪಡಿಸಿ: ಅದು ಹೊರಹೊಮ್ಮಿತು leeroy-app, ಮತ್ತು ಒಂದೇ ಬಾರಿಗೆ ಅಲ್ಲ.

ಹೆಚ್ಚು ಅಭ್ಯಾಸ

ಹೊಸ ಯೋಜನೆಯನ್ನು ರಚಿಸುವಾಗ, ಸ್ಕ್ಯಾಫೋಲ್ಡ್‌ಗಾಗಿ ಸಂರಚನೆಗಳನ್ನು ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಬೂಟ್‌ಸ್ಟ್ರಾಪ್ ಮಾಡಬಹುದು ಎಂದು ನಮೂದಿಸುವುದು ಯೋಗ್ಯವಾಗಿದೆ init, ಇದು ತುಂಬಾ ಅನುಕೂಲಕರವಾಗಿದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ನೀವು ಹಲವಾರು ಸಂರಚನೆಗಳನ್ನು ಬರೆಯಬಹುದು: ಡೀಫಾಲ್ಟ್ ಕಾನ್ಫಿಗರ್‌ನಲ್ಲಿ ಅಭಿವೃದ್ಧಿಯನ್ನು ಕೈಗೊಳ್ಳಿ, ತದನಂತರ ಆಜ್ಞೆಯೊಂದಿಗೆ ಹಂತಕ್ಕೆ ರೋಲ್ ಮಾಡಿ run (ಅದೇ ಪ್ರಕ್ರಿಯೆ dev, ಕೇವಲ ಬದಲಾವಣೆಗಳನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುವುದಿಲ್ಲ), ವಿಭಿನ್ನ ಸಂರಚನೆಯನ್ನು ಬಳಸಿ.

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

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

ಮತ್ತು ಸೈನ್ ಈ ಪ್ರಕಟಣೆ ವೀವ್ವರ್ಕ್ಸ್ನಿಂದ ನೀವು ಉತ್ಪಾದನೆಗೆ ಪೈಪ್ಲೈನ್ ​​ರಚಿಸುವ ಉದಾಹರಣೆಯನ್ನು ಕಾಣಬಹುದು.

ತೀರ್ಮಾನಕ್ಕೆ

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

Skaffold ಈಗಾಗಲೇ GitHub ನಲ್ಲಿ ಸುಮಾರು 8000+ ನಕ್ಷತ್ರಗಳನ್ನು ಹೊಂದಿದೆ, ಇದನ್ನು Google ಅಭಿವೃದ್ಧಿಪಡಿಸಿದೆ ಮತ್ತು ಭಾಗವಾಗಿದೆ GoogleContainerTools - ಸಾಮಾನ್ಯವಾಗಿ, ಈ ಸಮಯದಲ್ಲಿ ಯೋಜನೆಯು ಎಂದೆಂದಿಗೂ ಸಂತೋಷದಿಂದ ಅಭಿವೃದ್ಧಿಗೊಳ್ಳುತ್ತದೆ ಎಂದು ನಂಬಲು ಎಲ್ಲ ಕಾರಣಗಳಿವೆ.

ಪಿಎಸ್

ನಮ್ಮ ಬ್ಲಾಗ್‌ನಲ್ಲಿಯೂ ಓದಿ:

ಮೂಲ: www.habr.com

ಕಾಮೆಂಟ್ ಅನ್ನು ಸೇರಿಸಿ