ಪ್ರೊಹೋಸ್ಟರ್ > Блог > ಆಡಳಿತ > ಇಸ್ಟಿಯೊಗಾಗಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸಿದ್ಧಪಡಿಸಲಾಗುತ್ತಿದೆ

ಇಸ್ಟಿಯೊಗಾಗಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸಿದ್ಧಪಡಿಸಲಾಗುತ್ತಿದೆ

ಇಸ್ಟಿಯೊಗಾಗಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸಿದ್ಧಪಡಿಸಲಾಗುತ್ತಿದೆ

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

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

ಕಾರ್ಯಗಳನ್ನು

ಈ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ, ನೀವು ಈ ಕೆಳಗಿನ ಕಾರ್ಯಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸುತ್ತೀರಿ:

  1. ಬಹು ಸೇವೆಗಳೊಂದಿಗೆ ಸರಳವಾದ ಹಲೋ ವರ್ಲ್ಡ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಕಲಿಯುವುದು.
  2. ಮೂಲ ಕೋಡ್‌ನಿಂದ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರನ್ ಮಾಡಿ.
  3. ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಕಂಟೇನರ್‌ಗಳಲ್ಲಿ ಪ್ಯಾಕೇಜಿಂಗ್ ಮಾಡುವುದು.
  4. ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ರಚಿಸಲಾಗುತ್ತಿದೆ.
  5. ಕಂಟೈನರ್‌ಗಳನ್ನು ಕ್ಲಸ್ಟರ್‌ಗೆ ನಿಯೋಜಿಸಲಾಗುತ್ತಿದೆ.

ನೀವು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು

ಕುಬರ್ನೆಟ್ಸ್ ಎಂಜಿನ್ API ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲು ಸೂಚನೆಗಳನ್ನು ಅನುಸರಿಸಿ:

  1. ಗೆ ಹೋಗಿ ಕುಬರ್ನೆಟ್ಸ್ ಎಂಜಿನ್ ಪುಟ Google Cloud Platform ಕನ್ಸೋಲ್‌ನಲ್ಲಿ.
  2. ಯೋಜನೆಯನ್ನು ರಚಿಸಿ ಅಥವಾ ಆಯ್ಕೆಮಾಡಿ.
  3. API ಮತ್ತು ಸಂಬಂಧಿತ ಸೇವೆಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುವವರೆಗೆ ನಿರೀಕ್ಷಿಸಿ. ಇದು ಕೆಲವು ನಿಮಿಷಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು.
  4. ನಿಮ್ಮ Google ಕ್ಲೌಡ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಪ್ರಾಜೆಕ್ಟ್‌ಗಾಗಿ ಬಿಲ್ಲಿಂಗ್ ಅನ್ನು ಹೊಂದಿಸಲಾಗಿದೆಯೇ ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ಬಿಲ್ಲಿಂಗ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುವುದು ಹೇಗೆ ಎಂದು ತಿಳಿಯಿರಿ.

ಈ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ, ನೀವು ವರ್ಚುವಲ್ ಯಂತ್ರವನ್ನು ಸಿದ್ಧಪಡಿಸುವ ಕ್ಲೌಡ್ ಶೆಲ್ ಅನ್ನು ಬಳಸಬಹುದು ಗೂಗಲ್ ಕಂಪ್ಯೂಟ್ ಇಂಜಿನ್‌ನಲ್ಲಿ g1-ಚಿಕ್ಕ ಡೆಬಿಯನ್-ಆಧಾರಿತ ಲಿನಕ್ಸ್, ಅಥವಾ ಲಿನಕ್ಸ್ ಅಥವಾ ಮ್ಯಾಕೋಸ್ ಕಂಪ್ಯೂಟರ್‌ನೊಂದಿಗೆ.

ಆಯ್ಕೆ ಎ: ಕ್ಲೌಡ್ ಶೆಲ್ ಅನ್ನು ಬಳಸುವುದು

ಕ್ಲೌಡ್ ಶೆಲ್ ಬಳಸುವ ಪ್ರಯೋಜನಗಳು:

  • ಪೈಥಾನ್ 2 ಮತ್ತು ಪೈಥಾನ್ 3 ಅಭಿವೃದ್ಧಿ ಪರಿಸರಗಳು (ಸೇರಿದಂತೆ ವರ್ಚುವಲೆನ್ವ್) ಸಂಪೂರ್ಣವಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗಿದೆ.
  • ಕಮಾಂಡ್ ಲೈನ್ ಪರಿಕರಗಳು gCloud, ಡಾಕರ್, ಹೋಗಿ и kubectl, ನಾವು ಬಳಸುವದನ್ನು ಈಗಾಗಲೇ ಸ್ಥಾಪಿಸಲಾಗಿದೆ.
  • ನೀವು ಆಯ್ಕೆ ಮಾಡಲು ಹಲವಾರು ಇವೆ ಪಠ್ಯ ಸಂಪಾದಕರು:
    1. ಕೋಡ್ ಸಂಪಾದಕ, ಇದು ಮೇಘ ಶೆಲ್ ವಿಂಡೋದ ಮೇಲ್ಭಾಗದಲ್ಲಿರುವ ಸಂಪಾದನೆ ಐಕಾನ್‌ನೊಂದಿಗೆ ತೆರೆಯುತ್ತದೆ.
    2. ಇಮ್ಯಾಕ್ಸ್, ವಿಮ್ ಅಥವಾ ನ್ಯಾನೋ, ಇದು ಕ್ಲೌಡ್ ಶೆಲ್‌ನಲ್ಲಿನ ಕಮಾಂಡ್ ಲೈನ್‌ನಿಂದ ತೆರೆಯುತ್ತದೆ.

ಉಪಯೋಗಿಸಲು ಮೇಘ ಶೆಲ್:

  1. GCP ಕನ್ಸೋಲ್‌ಗೆ ಹೋಗಿ.
  2. ಬಟನ್ ಕ್ಲಿಕ್ ಮಾಡಿ ಮೇಘ ಶೆಲ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ (ಕ್ಲೌಡ್ ಶೆಲ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ) GCP ಕನ್ಸೋಲ್ ವಿಂಡೋದ ಮೇಲ್ಭಾಗದಲ್ಲಿ.

ಇಸ್ಟಿಯೊಗಾಗಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸಿದ್ಧಪಡಿಸಲಾಗುತ್ತಿದೆ

ಕೆಳಗಿನ ಭಾಗದಲ್ಲಿ GCP ಕನ್ಸೋಲ್ ಆಜ್ಞಾ ಸಾಲಿನೊಂದಿಗೆ ಕ್ಲೌಡ್ ಶೆಲ್ ಸೆಷನ್ ಹೊಸ ವಿಂಡೋದಲ್ಲಿ ತೆರೆಯುತ್ತದೆ.

ಇಸ್ಟಿಯೊಗಾಗಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸಿದ್ಧಪಡಿಸಲಾಗುತ್ತಿದೆ

ಆಯ್ಕೆ ಬಿ: ಕಮಾಂಡ್ ಲೈನ್ ಪರಿಕರಗಳನ್ನು ಸ್ಥಳೀಯವಾಗಿ ಬಳಸುವುದು

ನೀವು Linux ಅಥವಾ macOS ಚಾಲನೆಯಲ್ಲಿರುವ ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದರೆ, ನೀವು ಈ ಕೆಳಗಿನ ಘಟಕಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಿ ಮತ್ತು ಸ್ಥಾಪಿಸಬೇಕಾಗುತ್ತದೆ:

  1. ಕಸ್ಟಮೈಸ್ ಮಾಡಿ ಪೈಥಾನ್ 3 ಮತ್ತು ಪೈಥಾನ್ 2 ಅಭಿವೃದ್ಧಿ ಪರಿಸರ.

  2. ಮೇಘ SDK ಅನ್ನು ಸ್ಥಾಪಿಸಿ ಆಜ್ಞಾ ಸಾಲಿನ ಉಪಕರಣದೊಂದಿಗೆ gCloud.

  3. ಸ್ಥಾಪಿಸಿ kubectl - ಕೆಲಸ ಮಾಡಲು ಆಜ್ಞಾ ಸಾಲಿನ ಸಾಧನ ಕುಬರ್ನೆಟ್ಸ್.

    gcloud components install kubectl

  4. ಸ್ಥಾಪಿಸಿ ಡಾಕರ್ ಸಮುದಾಯ ಆವೃತ್ತಿ (CE). ನೀವು ಆಜ್ಞಾ ಸಾಲಿನ ಉಪಕರಣವನ್ನು ಬಳಸುತ್ತೀರಿ ಡಾಕರ್ಮಾದರಿ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಕಂಟೇನರ್ ಚಿತ್ರಗಳನ್ನು ರಚಿಸಲು.

  5. ಉಪಕರಣವನ್ನು ಸ್ಥಾಪಿಸಿ Git ಆವೃತ್ತಿ ನಿಯಂತ್ರಣGitHub ನಿಂದ ಮಾದರಿ ಅಪ್ಲಿಕೇಶನ್ ಪಡೆಯಲು.

ಮಾದರಿ ಕೋಡ್ ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ

  1. ಮೂಲ ಕೋಡ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ ಹಲೋ ಸರ್ವರ್:

    git clone https://github.com/GoogleCloudPlatform/istio-samples

  2. ಉದಾಹರಣೆ ಕೋಡ್ ಡೈರೆಕ್ಟರಿಗೆ ಹೋಗಿ:

    cd istio-samples/sample-apps/helloserver

ಬಹು ಸೇವೆಗಳೊಂದಿಗೆ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಅನ್ವೇಷಿಸಲಾಗುತ್ತಿದೆ

ಮಾದರಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪೈಥಾನ್‌ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ ಮತ್ತು ಬಳಸಿಕೊಂಡು ಸಂವಹನ ಮಾಡುವ ಎರಡು ಘಟಕಗಳನ್ನು ಒಳಗೊಂಡಿದೆ ಉಳಿದ:

  • ಸರ್ವರ್: ಒಂದು ಅಂತಿಮ ಬಿಂದುವನ್ನು ಹೊಂದಿರುವ ಸರಳ ಸರ್ವರ್ ಪಡೆಯಿರಿ, /, ಇದು ಕನ್ಸೋಲ್‌ಗೆ "ಹಲೋ ವರ್ಲ್ಡ್" ಅನ್ನು ಮುದ್ರಿಸುತ್ತದೆ.
  • ಲೋಡ್ಜೆನ್: ದಟ್ಟಣೆಯನ್ನು ಕಳುಹಿಸುವ ಸ್ಕ್ರಿಪ್ಟ್ ಸರ್ವರ್, ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದಾದ ಸಂಖ್ಯೆಯ ವಿನಂತಿಗಳೊಂದಿಗೆ ಪ್ರತಿ ಸೆಕೆಂಡಿಗೆ.

ಇಸ್ಟಿಯೊಗಾಗಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸಿದ್ಧಪಡಿಸಲಾಗುತ್ತಿದೆ

ಮೂಲ ಕೋಡ್‌ನಿಂದ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರನ್ ಮಾಡಲಾಗುತ್ತಿದೆ

ಮಾದರಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಅನ್ವೇಷಿಸಲು, ಅದನ್ನು ಕ್ಲೌಡ್ ಶೆಲ್‌ನಲ್ಲಿ ಅಥವಾ ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿ ರನ್ ಮಾಡಿ.
1) ಕ್ಯಾಟಲಾಗ್‌ನಲ್ಲಿ istio-samples/samples-apps/helloserver ಓಡು ಸರ್ವರ್:

python3 server/server.py

ಪ್ರಾರಂಭದಲ್ಲಿ ಸರ್ವರ್ ಕೆಳಗಿನವುಗಳನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ:

INFO:root:Starting server...

2) ವಿನಂತಿಗಳನ್ನು ಕಳುಹಿಸಲು ಮತ್ತೊಂದು ಟರ್ಮಿನಲ್ ವಿಂಡೋವನ್ನು ತೆರೆಯಿರಿ ಸರ್ವರ್. ನೀವು ಕ್ಲೌಡ್ ಶೆಲ್ ಅನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ, ಮತ್ತೊಂದು ಸೆಶನ್ ತೆರೆಯಲು ಸೇರಿಸು ಐಕಾನ್ ಅನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ.
3) ವಿನಂತಿಯನ್ನು ಕಳುಹಿಸಿ ಸರ್ವರ್:

curl http://localhost:8080

ಸರ್ವರ್ ಉತ್ತರಗಳು:

Hello World!

4) ನೀವು ಮಾದರಿ ಕೋಡ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿದ ಡೈರೆಕ್ಟರಿಯಿಂದ, ಒಳಗೊಂಡಿರುವ ಡೈರೆಕ್ಟರಿಗೆ ಹೋಗಿ ಲೋಡ್ಜೆನ್:

cd YOUR_WORKING_DIRECTORY/istio-samples/sample-apps/helloserver/loadgen

5) ಕೆಳಗಿನ ಪರಿಸರ ಅಸ್ಥಿರಗಳನ್ನು ರಚಿಸಿ:

export SERVER_ADDR=http://localhost:8080
export REQUESTS_PER_SECOND=5

6) ಉಡಾವಣೆ ವರ್ಚುವಲೆನ್ವ್:

virtualenv --python python3 env

7) ವರ್ಚುವಲ್ ಪರಿಸರವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ:

source env/bin/activate

8) ಅವಶ್ಯಕತೆಗಳನ್ನು ಹೊಂದಿಸಿ ಲೋಡ್ಜೆನ್:

pip3 install -r requirements.txt

9) ಉಡಾವಣೆ ಲೋಡ್ಜೆನ್:

python3 loadgen.py

ಪ್ರಾರಂಭದಲ್ಲಿ ಲೋಡ್ಜೆನ್ ಕೆಳಗಿನ ಸಂದೇಶದಂತಹದನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ:

Starting loadgen: 2019-05-20 10:44:12.448415
5 request(s) complete to http://localhost:8080

ಮತ್ತೊಂದು ಟರ್ಮಿನಲ್ ವಿಂಡೋದಲ್ಲಿ ಸರ್ವರ್ ಕೆಳಗಿನ ಸಂದೇಶಗಳನ್ನು ಕನ್ಸೋಲ್‌ಗೆ ಔಟ್‌ಪುಟ್ ಮಾಡುತ್ತದೆ:

127.0.0.1 - - [21/Jun/2019 14:22:01] "GET / HTTP/1.1" 200 -
INFO:root:GET request,
Path: /
Headers:
Host: localhost:8080
User-Agent: python-requests/2.22.0
Accept-Encoding: gzip, deflate
Accept: */*

ನೆಟ್‌ವರ್ಕಿಂಗ್ ದೃಷ್ಟಿಕೋನದಿಂದ, ಸಂಪೂರ್ಣ ಅಪ್ಲಿಕೇಶನ್ ಒಂದೇ ಹೋಸ್ಟ್‌ನಲ್ಲಿ ಚಲಿಸುತ್ತದೆ (ಸ್ಥಳೀಯ ಕಂಪ್ಯೂಟರ್ ಅಥವಾ ಕ್ಲೌಡ್ ಶೆಲ್ ವರ್ಚುವಲ್ ಯಂತ್ರ). ಆದ್ದರಿಂದ ನೀವು ಬಳಸಬಹುದು ಸ್ಥಳೀಯ ಹೋಸ್ಟ್ಗೆ ವಿನಂತಿಗಳನ್ನು ಕಳುಹಿಸಲು ಸರ್ವರ್.
10) ನಿಲ್ಲಿಸಲು ಲೋಡ್ಜೆನ್ и ಸರ್ವರ್, ನಮೂದಿಸಿ Ctrl-c ಪ್ರತಿ ಟರ್ಮಿನಲ್ ವಿಂಡೋದಲ್ಲಿ.
11) ಟರ್ಮಿನಲ್ ವಿಂಡೋದಲ್ಲಿ ಲೋಡ್ಜೆನ್ ವರ್ಚುವಲ್ ಪರಿಸರವನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಿ:

deactivate

ಧಾರಕಗಳಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ಯಾಕೇಜಿಂಗ್ ಮಾಡುವುದು

GKE ನಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಚಲಾಯಿಸಲು, ನೀವು ಮಾದರಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ಯಾಕೇಜ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ - ಸರ್ವರ್ и ಲೋಡ್ಜೆನ್ - ಇನ್ ಪಾತ್ರೆಗಳು. ಕಂಟೇನರ್ ಎನ್ನುವುದು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಅದರ ಪರಿಸರದಿಂದ ಪ್ರತ್ಯೇಕಿಸಲು ಪ್ಯಾಕೇಜ್ ಮಾಡುವ ಒಂದು ಮಾರ್ಗವಾಗಿದೆ.

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

ಉದಾಹರಣೆ ಈಗಾಗಲೇ ಇದೆ ಡಾಕರ್‌ಫೈಲ್ ಗೆ ಸರ್ವರ್ и ಲೋಡ್ಜೆನ್ ಚಿತ್ರಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಆಜ್ಞೆಗಳೊಂದಿಗೆ. ಕೆಳಗೆ - ಡಾಕರ್‌ಫೈಲ್ ಗೆ ಸರ್ವರ್:

FROM python:3-slim as base
FROM base as builder
RUN apt-get -qq update 
    && apt-get install -y --no-install-recommends 
        g++ 
    && rm -rf /var/lib/apt/lists/*

# Enable unbuffered logging
FROM base as final
ENV PYTHONUNBUFFERED=1

RUN apt-get -qq update 
    && apt-get install -y --no-install-recommends 
        wget

WORKDIR /helloserver

# Grab packages from builder
COPY --from=builder /usr/local/lib/python3.7/ /usr/local/lib/python3.7/

# Add the application
COPY . .

EXPOSE 8080
ENTRYPOINT [ "python", "server.py" ]

  • ತಂಡದ ಪೈಥಾನ್‌ನಿಂದ: 3-ಸ್ಲಿಮ್ ಬೇಸ್ ಇತ್ತೀಚಿನದನ್ನು ಬಳಸಲು ಡಾಕರ್‌ಗೆ ಹೇಳುತ್ತದೆ ಪೈಥಾನ್ 3 ಚಿತ್ರ ಆಧಾರವಾಗಿ.
  • ತಂಡದ ನಕಲಿಸಿ. . ಮೂಲ ಫೈಲ್‌ಗಳನ್ನು ಪ್ರಸ್ತುತ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಡೈರೆಕ್ಟರಿಗೆ ನಕಲಿಸುತ್ತದೆ (ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ ಮಾತ್ರ server.py) ಕಂಟೇನರ್‌ನ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗೆ.
  • ENTRYPOINT ಕಂಟೇನರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು ಬಳಸಲಾಗುವ ಆಜ್ಞೆಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಈ ಆಜ್ಞೆಯು ನೀವು ಚಲಾಯಿಸಲು ಬಳಸಿದಂತೆಯೇ ಇರುತ್ತದೆ server.py ಮೂಲ ಕೋಡ್‌ನಿಂದ.
  • ತಂಡದ ಎಕ್ಸ್‌ಪೋಸ್ ಮಾಡಿ ಎಂದು ಸೂಚಿಸುತ್ತದೆ ಸರ್ವರ್ ಪೋರ್ಟ್ ಮೂಲಕ ಡೇಟಾಕ್ಕಾಗಿ ಕಾಯುತ್ತದೆ 8080. ಈ ತಂಡ ಹಾಗಲ್ಲ ಬಂದರುಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಇದು ಬಂದರನ್ನು ತೆರೆಯಲು ಅಗತ್ಯವಿರುವ ಕೆಲವು ರೀತಿಯ ದಾಖಲಾತಿಯಾಗಿದೆ 8080 ಧಾರಕವನ್ನು ಪ್ರಾರಂಭಿಸುವಾಗ.

ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಕಂಟೈನರೈಸ್ ಮಾಡಲು ಸಿದ್ಧವಾಗುತ್ತಿದೆ

1) ಕೆಳಗಿನ ಪರಿಸರ ಅಸ್ಥಿರಗಳನ್ನು ಹೊಂದಿಸಿ. ಬದಲಾಯಿಸಿ PROJECT_ID ನಿಮ್ಮ GCP ಯೋಜನೆಯ ID ಗೆ.

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

ಮೌಲ್ಯಗಳನ್ನು ಬಳಸುವುದು PROJECT_ID и GCR_REPO ನೀವು ಡಾಕರ್ ಚಿತ್ರವನ್ನು ನಿರ್ಮಿಸಿದಾಗ ಅದನ್ನು ಟ್ಯಾಗ್ ಮಾಡಿ ಮತ್ತು ಅದನ್ನು ಖಾಸಗಿ ಕಂಟೈನರ್ ರಿಜಿಸ್ಟ್ರಿಗೆ ತಳ್ಳಿರಿ.

2) ಆಜ್ಞಾ ಸಾಲಿನ ಉಪಕರಣಕ್ಕಾಗಿ ಡೀಫಾಲ್ಟ್ GCP ಯೋಜನೆಯನ್ನು ಹೊಂದಿಸಿ gCloud.

gcloud config set project $PROJECT_ID

3) ಆಜ್ಞಾ ಸಾಲಿನ ಉಪಕರಣಕ್ಕಾಗಿ ಡೀಫಾಲ್ಟ್ ವಲಯವನ್ನು ಹೊಂದಿಸಿ gCloud.

gcloud config set compute/zone us-central1-b

4) GCP ಯೋಜನೆಯಲ್ಲಿ ಕಂಟೈನರ್ ರಿಜಿಸ್ಟ್ರಿ ಸೇವೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

gcloud services enable containerregistry.googleapis.com

ಕಂಟೈನರೈಸೇಶನ್ ಸರ್ವರ್

  1. ಉದಾಹರಣೆ ಇರುವ ಡೈರೆಕ್ಟರಿಗೆ ಹೋಗಿ ಸರ್ವರ್:

    cd YOUR_WORKING_DIRECTORY/istio-samples/sample-apps/helloserver/server/

  2. ಬಳಸಿ ಚಿತ್ರವನ್ನು ಜೋಡಿಸಿ ಡಾಕರ್‌ಫೈಲ್ ಮತ್ತು ನೀವು ಮೊದಲು ವ್ಯಾಖ್ಯಾನಿಸಿದ ಪರಿಸರ ಅಸ್ಥಿರಗಳು:

    docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1 .

ನಿಯತಾಂಕ -t ಡಾಕರ್ ಟ್ಯಾಗ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಕಂಟೇನರ್ ಅನ್ನು ನಿಯೋಜಿಸುವಾಗ ನೀವು ಬಳಸುವ ಚಿತ್ರದ ಹೆಸರು ಇದು.

  1. ಕಂಟೈನರ್ ರಿಜಿಸ್ಟ್ರಿಗೆ ಚಿತ್ರವನ್ನು ಅಪ್ಲೋಡ್ ಮಾಡಿ: 
    docker push gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1

ಲೋಡ್ಜೆನ್ನ ಕಂಟೈನರೈಸೇಶನ್

1) ಉದಾಹರಣೆ ಇರುವ ಡೈರೆಕ್ಟರಿಗೆ ಹೋಗಿ ಲೋಡ್ಜೆನ್:

cd ../loadgen

2) ಚಿತ್ರವನ್ನು ಸಂಗ್ರಹಿಸಿ:

docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/loadgen:v0.0.1 .

3) ಕಂಟೈನರ್ ರಿಜಿಸ್ಟ್ರಿಗೆ ಚಿತ್ರವನ್ನು ಅಪ್ಲೋಡ್ ಮಾಡಿ:

docker push gcr.io/$PROJECT_ID/$GCR_REPO/loadgen:v0.0.1

ಚಿತ್ರಗಳ ಪಟ್ಟಿಯನ್ನು ವೀಕ್ಷಿಸಿ

ರೆಪೊಸಿಟರಿಯಲ್ಲಿರುವ ಚಿತ್ರಗಳ ಪಟ್ಟಿಯನ್ನು ಪರಿಶೀಲಿಸಿ ಮತ್ತು ಚಿತ್ರಗಳನ್ನು ಅಪ್‌ಲೋಡ್ ಮಾಡಲಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ:

gcloud container images list --repository gcr.io/$PROJECT_ID/preparing-istio

ಆಜ್ಞೆಯು ಹೊಸದಾಗಿ ಅಪ್‌ಲೋಡ್ ಮಾಡಿದ ಚಿತ್ರಗಳ ಹೆಸರನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ:

NAME
gcr.io/PROJECT_ID/preparing-istio/helloserver
gcr.io/PROJECT_ID/preparing-istio/loadgen

GKE ಕ್ಲಸ್ಟರ್ ಅನ್ನು ರಚಿಸಲಾಗುತ್ತಿದೆ.

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

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

GKE ಕ್ಲಸ್ಟರ್ ಅನ್ನು ರಚಿಸುವುದು:

1) ಕ್ಲಸ್ಟರ್ ರಚಿಸಿ:

gcloud container clusters create istioready 
  --cluster-version latest 
  --machine-type=n1-standard-2 
  --num-nodes 4

ತಂಡದ gCloud ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ GCP ಯೋಜನೆ ಮತ್ತು ಡೀಫಾಲ್ಟ್ ವಲಯದಲ್ಲಿ istioready ಕ್ಲಸ್ಟರ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ. ಇಸ್ಟಿಯೊವನ್ನು ಚಲಾಯಿಸಲು, ಕನಿಷ್ಠ 4 ನೋಡ್‌ಗಳು ಮತ್ತು ವರ್ಚುವಲ್ ಯಂತ್ರವನ್ನು ಹೊಂದಲು ನಾವು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ n1-ಸ್ಟ್ಯಾಂಡರ್ಡ್-2.

ತಂಡವು ಕೆಲವು ನಿಮಿಷಗಳಲ್ಲಿ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ. ಕ್ಲಸ್ಟರ್ ಸಿದ್ಧವಾದಾಗ, ಆಜ್ಞೆಯು ಈ ರೀತಿಯದನ್ನು ಔಟ್ಪುಟ್ ಮಾಡುತ್ತದೆ ಸಂದೇಶ.

2) ಆಜ್ಞಾ ಸಾಲಿನ ಉಪಕರಣದಲ್ಲಿ ರುಜುವಾತುಗಳನ್ನು ಒದಗಿಸಿ kubectlಕ್ಲಸ್ಟರ್ ಅನ್ನು ನಿರ್ವಹಿಸಲು ಅದನ್ನು ಬಳಸಲು:

gcloud container clusters get-credentials istioready

3) ಈಗ ನೀವು ಕುಬರ್ನೆಟ್ಸ್ ಮೂಲಕ ಸಂವಹನ ಮಾಡಬಹುದು kubectl. ಉದಾಹರಣೆಗೆ, ಕೆಳಗಿನ ಆಜ್ಞೆಯು ನೋಡ್‌ಗಳ ಸ್ಥಿತಿಯನ್ನು ಕಂಡುಹಿಡಿಯಬಹುದು:

kubectl get nodes

ಆಜ್ಞೆಯು ನೋಡ್‌ಗಳ ಪಟ್ಟಿಯನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ:

NAME                                       STATUS   ROLES    AGE    VERSION
gke-istoready-default-pool-dbeb23dc-1vg0   Ready    <none>   99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-36z5   Ready    <none>   100s   v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-fj7s   Ready    <none>   99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-wbjw   Ready    <none>   99s    v1.13.6-gke.13

ಕುಬರ್ನೆಟ್ಸ್ ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳು

ರೇಖಾಚಿತ್ರವು GKE ನಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ತೋರಿಸುತ್ತದೆ:

ಇಸ್ಟಿಯೊಗಾಗಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸಿದ್ಧಪಡಿಸಲಾಗುತ್ತಿದೆ

ನೀವು GKE ನಲ್ಲಿ ಕಂಟೈನರ್‌ಗಳನ್ನು ನಿಯೋಜಿಸುವ ಮೊದಲು, ಕುಬರ್ನೆಟ್ಸ್‌ನ ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಕಲಿಯಿರಿ. ನೀವು ಇನ್ನಷ್ಟು ತಿಳಿದುಕೊಳ್ಳಲು ಬಯಸಿದರೆ ಕೊನೆಯಲ್ಲಿ ಲಿಂಕ್‌ಗಳಿವೆ.

  • ನೋಡ್‌ಗಳು ಮತ್ತು ಕ್ಲಸ್ಟರ್‌ಗಳು. GKE ನಲ್ಲಿ, ನೋಡ್ ಒಂದು ವರ್ಚುವಲ್ ಯಂತ್ರವಾಗಿದೆ. ಇತರ ಕುಬರ್ನೆಟ್ಸ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳಲ್ಲಿ, ನೋಡ್ ಕಂಪ್ಯೂಟರ್ ಅಥವಾ ವರ್ಚುವಲ್ ಯಂತ್ರವಾಗಿರಬಹುದು. ಕ್ಲಸ್ಟರ್ ಎನ್ನುವುದು ನೋಡ್‌ಗಳ ಸಂಗ್ರಹವಾಗಿದ್ದು, ನೀವು ಕಂಟೈನರೈಸ್ ಮಾಡಿದ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿಯೋಜಿಸುವ ಏಕೈಕ ಘಟಕವೆಂದು ಪರಿಗಣಿಸಬಹುದು.
  • ಪಾಡ್ಸ್. ಕುಬರ್ನೆಟ್ಸ್ನಲ್ಲಿ, ಧಾರಕಗಳು ಪಾಡ್ಗಳಲ್ಲಿ ಚಲಿಸುತ್ತವೆ. ಕುಬರ್ನೆಟ್ಸ್‌ನಲ್ಲಿರುವ ಪಾಡ್ ಒಂದು ಅವಿಭಾಜ್ಯ ಘಟಕವಾಗಿದೆ. ಒಂದು ಪಾಡ್ ಒಂದು ಅಥವಾ ಹೆಚ್ಚಿನ ಪಾತ್ರೆಗಳನ್ನು ಹೊಂದಿದೆ. ನೀವು ಸರ್ವರ್ ಕಂಟೈನರ್‌ಗಳನ್ನು ನಿಯೋಜಿಸುತ್ತೀರಿ ಮತ್ತು ಲೋಡ್ಜೆನ್ ಪ್ರತ್ಯೇಕ ಬೀಜಕೋಶಗಳಲ್ಲಿ. ಪಾಡ್‌ನಲ್ಲಿ ಹಲವಾರು ಕಂಟೈನರ್‌ಗಳು ಇದ್ದಾಗ (ಉದಾಹರಣೆಗೆ, ಅಪ್ಲಿಕೇಶನ್ ಸರ್ವರ್ ಮತ್ತು ಪ್ರಾಕ್ಸಿ ಸರ್ವರ್), ಕಂಟೈನರ್‌ಗಳನ್ನು ಒಂದೇ ಘಟಕವಾಗಿ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಪಾಡ್ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳಲಾಗುತ್ತದೆ.
  • ನಿಯೋಜನೆಗಳು. ಕುಬರ್ನೆಟ್ಸ್‌ನಲ್ಲಿ, ನಿಯೋಜನೆಯು ಒಂದೇ ರೀತಿಯ ಪಾಡ್‌ಗಳ ಸಂಗ್ರಹವಾಗಿರುವ ವಸ್ತುವಾಗಿದೆ. ನಿಯೋಜನೆಯು ಕ್ಲಸ್ಟರ್ ನೋಡ್‌ಗಳಾದ್ಯಂತ ವಿತರಿಸಲಾದ ಪಾಡ್‌ಗಳ ಬಹು ಪ್ರತಿಕೃತಿಗಳನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ. ನಿಯೋಜನೆಯು ವಿಫಲವಾದ ಅಥವಾ ಸ್ಪಂದಿಸದಿರುವ ಪಾಡ್‌ಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಬದಲಾಯಿಸುತ್ತದೆ.
  • ಕುಬರ್ನೆಟ್ಸ್ ಸೇವೆ. GKE ನಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡುವಾಗ, ನಡುವಿನ ಸಂಪರ್ಕ ಲೋಡ್ಜೆನ್ и ಸರ್ವರ್. ನೀವು ಕ್ಲೌಡ್ ಶೆಲ್ ವರ್ಚುವಲ್ ಯಂತ್ರ ಅಥವಾ ಡೆಸ್ಕ್‌ಟಾಪ್‌ನಲ್ಲಿ ಸೇವೆಗಳನ್ನು ಪ್ರಾರಂಭಿಸಿದಾಗ, ನೀವು ವಿನಂತಿಗಳನ್ನು ಕಳುಹಿಸಿದ್ದೀರಿ ಸರ್ವರ್ ನಲ್ಲಿ ಲೋಕಲ್ ಹೋಸ್ಟ್: 8080. ಒಮ್ಮೆ GKE ಗೆ ನಿಯೋಜಿಸಿದರೆ, ಲಭ್ಯವಿರುವ ನೋಡ್‌ಗಳಲ್ಲಿ ಪಾಡ್‌ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಪಾಡ್ ಯಾವ ನೋಡ್‌ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿದೆ ಎಂಬುದರ ಮೇಲೆ ನಿಮಗೆ ಯಾವುದೇ ನಿಯಂತ್ರಣವಿಲ್ಲ, ಆದ್ದರಿಂದ ನೀವು ಬೀಜಕೋಶಗಳು ಯಾವುದೇ ಶಾಶ್ವತ IP ವಿಳಾಸಗಳಿಲ್ಲ.
    IP ವಿಳಾಸವನ್ನು ಪಡೆಯಲು ಸರ್ವರ್, ನೀವು ಪಾಡ್‌ಗಳ ಮೇಲೆ ನೆಟ್‌ವರ್ಕ್ ಅಮೂರ್ತತೆಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬೇಕಾಗಿದೆ. ಅದು ಏನು ಕುಬರ್ನೆಟ್ಸ್ ಸೇವೆ. ಕುಬರ್ನೆಟ್ಸ್ ಸೇವೆಯು ಪಾಡ್‌ಗಳ ಗುಂಪಿಗೆ ನಿರಂತರವಾದ ಅಂತಿಮ ಬಿಂದುವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಕೆಲವು ಇವೆ ಸೇವೆಗಳ ವಿಧಗಳು. ಸರ್ವರ್ ಉಪಯೋಗಿಸುತ್ತದೆ ಲೋಡ್ ಬ್ಯಾಲೆನ್ಸರ್, ಇದು ಸಂಪರ್ಕಿಸಲು ಬಾಹ್ಯ IP ವಿಳಾಸವನ್ನು ಒದಗಿಸುತ್ತದೆ ಸರ್ವರ್ ಕ್ಲಸ್ಟರ್ ಹೊರಗಿನಿಂದ.
    ಕುಬರ್ನೆಟ್ಸ್ DNS ಹೆಸರುಗಳನ್ನು ನಿಯೋಜಿಸುವ ಅಂತರ್ನಿರ್ಮಿತ DNS ವ್ಯವಸ್ಥೆಯನ್ನು ಸಹ ಹೊಂದಿದೆ (ಉದಾಹರಣೆಗೆ, helloserver.default.cluster.local) ಸೇವೆಗಳು. ಇದಕ್ಕೆ ಧನ್ಯವಾದಗಳು, ಕ್ಲಸ್ಟರ್‌ನೊಳಗಿನ ಪಾಡ್‌ಗಳು ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿರುವ ಇತರ ಪಾಡ್‌ಗಳೊಂದಿಗೆ ನಿರಂತರ ವಿಳಾಸದಲ್ಲಿ ಸಂವಹನ ನಡೆಸುತ್ತವೆ. ಕ್ಲೌಡ್ ಶೆಲ್ ಅಥವಾ ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿರುವಂತಹ ಕ್ಲಸ್ಟರ್‌ನ ಹೊರಗೆ DNS ಹೆಸರನ್ನು ಬಳಸಲಾಗುವುದಿಲ್ಲ.

ಕುಬರ್ನೆಟ್ಸ್ ಪ್ರಕಟವಾಗುತ್ತದೆ

ನೀವು ಮೂಲದಿಂದ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಚಲಾಯಿಸಿದಾಗ, ನೀವು ಕಡ್ಡಾಯ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿದ್ದೀರಿ ಪೈಥಾನ್ಎಕ್ಸ್ಎನ್ಎಕ್ಸ್

server.py

ಕಡ್ಡಾಯವು ಕ್ರಿಯಾಪದವನ್ನು ಸೂಚಿಸುತ್ತದೆ: "ಇದನ್ನು ಮಾಡು."

ಕುಬರ್ನೆಟ್ಸ್ ಬಳಸುತ್ತದೆ ಘೋಷಣಾತ್ಮಕ ಮಾದರಿ. ಇದರರ್ಥ ನಾವು ಕುಬರ್ನೆಟ್‌ಗಳಿಗೆ ನಿಖರವಾಗಿ ಏನು ಮಾಡಬೇಕೆಂದು ಹೇಳುತ್ತಿಲ್ಲ, ಬದಲಿಗೆ ಬಯಸಿದ ಸ್ಥಿತಿಯನ್ನು ವಿವರಿಸುತ್ತೇವೆ. ಉದಾಹರಣೆಗೆ, ಕುಬರ್ನೆಟ್ಸ್ ಸಿಸ್ಟಮ್ನ ನೈಜ ಸ್ಥಿತಿಯನ್ನು ಅಪೇಕ್ಷಿತ ಸ್ಥಿತಿಗೆ ಅನುಗುಣವಾಗಿ ಇರಿಸಿಕೊಳ್ಳಲು ಅಗತ್ಯವಿರುವಂತೆ ಪಾಡ್ಗಳನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ ಮತ್ತು ನಿಲ್ಲಿಸುತ್ತದೆ.

ನೀವು ಮ್ಯಾನಿಫೆಸ್ಟ್ ಅಥವಾ ಫೈಲ್‌ಗಳಲ್ಲಿ ಬಯಸಿದ ಸ್ಥಿತಿಯನ್ನು ಸೂಚಿಸುತ್ತೀರಿ YAML. YAML ಫೈಲ್ ಒಂದು ಅಥವಾ ಹೆಚ್ಚಿನ ಕುಬರ್ನೆಟ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗೆ ವಿಶೇಷಣಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.

ಉದಾಹರಣೆಯು YAML ಫೈಲ್ ಅನ್ನು ಒಳಗೊಂಡಿದೆ ಸರ್ವರ್ и ಲೋಡ್ಜೆನ್. ಪ್ರತಿಯೊಂದು YAML ಫೈಲ್ ನಿಯೋಜನೆ ವಸ್ತು ಮತ್ತು ಕುಬರ್ನೆಟ್ ಸೇವೆಯ ಅಪೇಕ್ಷಿತ ಸ್ಥಿತಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ.

ಸರ್ವರ್.ಯಾಮ್ಲ್

apiVersion: apps/v1
kind: Deployment
metadata:
  name: helloserver
spec:
  selector:
    matchLabels:
      app: helloserver
  replicas: 1
  template:
    metadata:
      labels:
        app: helloserver
    spec:
      terminationGracePeriodSeconds: 5
      restartPolicy: Always
      containers:
      - name: main
        image: gcr.io/google-samples/istio/helloserver:v0.0.1
        imagePullPolicy: Always

  • ರೀತಿಯ ವಸ್ತುವಿನ ಪ್ರಕಾರವನ್ನು ಸೂಚಿಸುತ್ತದೆ.
  • ಮೆಟಾಡೇಟಾ.ಹೆಸರು ನಿಯೋಜನೆಯ ಹೆಸರನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ.
  • ಮೊದಲ ಕ್ಷೇತ್ರ ಸ್ಪೆಕ್ ಬಯಸಿದ ಸ್ಥಿತಿಯ ವಿವರಣೆಯನ್ನು ಒಳಗೊಂಡಿದೆ.
  • ಸ್ಪೆಕ್.ಪ್ರತಿಕೃತಿಗಳು ಅಪೇಕ್ಷಿತ ಸಂಖ್ಯೆಯ ಬೀಜಕೋಶಗಳನ್ನು ಸೂಚಿಸುತ್ತದೆ.
  • ವಿಭಾಗ spec.template ಪಾಡ್ ಟೆಂಪ್ಲೇಟ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ಪಾಡ್ ವಿವರಣೆಯಲ್ಲಿ ಕ್ಷೇತ್ರವಿದೆ ಚಿತ್ರ, ಇದು ಕಂಟೈನರ್ ರಿಜಿಸ್ಟ್ರಿಯಿಂದ ಹೊರತೆಗೆಯಬೇಕಾದ ಚಿತ್ರದ ಹೆಸರನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ.

ಸೇವೆಯನ್ನು ಈ ಕೆಳಗಿನಂತೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ:

apiVersion: v1
kind: Service
metadata:
  name: hellosvc
spec:
  type: LoadBalancer
  selector:
    app: helloserver
  ports:
  - name: http
    port: 80
    targetPort: 8080

  • ಲೋಡ್ ಬ್ಯಾಲೆನ್ಸರ್: ಕ್ಲೈಂಟ್‌ಗಳು ಲೋಡ್ ಬ್ಯಾಲೆನ್ಸರ್‌ನ IP ವಿಳಾಸಕ್ಕೆ ವಿನಂತಿಗಳನ್ನು ಕಳುಹಿಸುತ್ತಾರೆ, ಇದು ನಿರಂತರ IP ವಿಳಾಸವನ್ನು ಹೊಂದಿದೆ ಮತ್ತು ಕ್ಲಸ್ಟರ್‌ನ ಹೊರಗಿನಿಂದ ಪ್ರವೇಶಿಸಬಹುದಾಗಿದೆ.
  • ಗುರಿ ಬಂದರು: ನಿಮಗೆ ನೆನಪಿರುವಂತೆ, ತಂಡ ಎಕ್ಸ್‌ಪೋಸ್ 8080 в ಡಾಕರ್‌ಫೈಲ್ ಬಂದರುಗಳನ್ನು ಒದಗಿಸಲಿಲ್ಲ. ನೀವು ಬಂದರನ್ನು ಒದಗಿಸುತ್ತೀರಿ 8080ಇದರಿಂದ ನೀವು ಕಂಟೇನರ್ ಅನ್ನು ಸಂಪರ್ಕಿಸಬಹುದು ಸರ್ವರ್ ಕ್ಲಸ್ಟರ್ ಹೊರಗೆ. ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ hellosvc.default.cluster.local:80 (ಚಿಕ್ಕ ಹೆಸರು: ಹಲೋಸ್ವಿಸಿ) ಬಂದರಿಗೆ ಅನುರೂಪವಾಗಿದೆ 8080 ಪಾಡ್ ಐಪಿ ವಿಳಾಸಗಳು ಹಲೋ ಸರ್ವರ್.
  • ಬಂದರು: ಇದು ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿರುವ ಇತರ ಸೇವೆಗಳು ವಿನಂತಿಗಳನ್ನು ಕಳುಹಿಸುವ ಪೋರ್ಟ್ ಸಂಖ್ಯೆ.

loadgen.yaml

ನಿಯೋಜನೆ ವಸ್ತು loadgen.yaml ಹಾಗೆ ಸರ್ವರ್.ಯಾಮ್ಲ್. ವ್ಯತ್ಯಾಸವೆಂದರೆ ನಿಯೋಜನೆ ವಸ್ತುವು ವಿಭಾಗವನ್ನು ಒಳಗೊಂಡಿದೆ ಕಳುಹಿಸು. ಇದು ಅಗತ್ಯವಿರುವ ಪರಿಸರ ಅಸ್ಥಿರಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ ಲೋಡ್ಜೆನ್ ಮತ್ತು ಮೂಲದಿಂದ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡುವಾಗ ನೀವು ಸ್ಥಾಪಿಸಿರುವಿರಿ.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: loadgenerator
spec:
  selector:
    matchLabels:
      app: loadgenerator
  replicas: 1
  template:
    metadata:
      labels:
        app: loadgenerator
    spec:
      terminationGracePeriodSeconds: 5
      restartPolicy: Always
      containers:
      - name: main
        image: gcr.io/google-samples/istio/loadgen:v0.0.1
        imagePullPolicy: Always
        env:
        - name: SERVER_ADDR
          value: "http://hellosvc:80/"
        - name: REQUESTS_PER_SECOND
          value: "10"
        resources:
          requests:
            cpu: 300m
            memory: 256Mi
          limits:
            cpu: 500m
            memory: 512Mi

ಒಮ್ಮೆ ಲೋಡ್ಜೆನ್ ಕ್ಷೇತ್ರಕ್ಕಾಗಿ ಒಳಬರುವ ವಿನಂತಿಗಳನ್ನು ಸ್ವೀಕರಿಸುವುದಿಲ್ಲ ಮಾದರಿ ಸೂಚಿಸಲಾಗಿದೆ ClusterIP. ಈ ಪ್ರಕಾರವು ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿನ ಸೇವೆಗಳನ್ನು ಬಳಸಬಹುದಾದ ನಿರಂತರ IP ವಿಳಾಸವನ್ನು ಒದಗಿಸುತ್ತದೆ, ಆದರೆ ಈ IP ವಿಳಾಸವು ಬಾಹ್ಯ ಕ್ಲೈಂಟ್‌ಗಳಿಗೆ ತೆರೆದುಕೊಳ್ಳುವುದಿಲ್ಲ.

apiVersion: v1
kind: Service
metadata:
  name: loadgensvc
spec:
  type: ClusterIP
  selector:
    app: loadgenerator
  ports:
  - name: http
    port: 80
    targetPort: 8080

GKE ನಲ್ಲಿ ಕಂಟೈನರ್‌ಗಳನ್ನು ನಿಯೋಜಿಸಲಾಗುತ್ತಿದೆ

1) ಉದಾಹರಣೆ ಇರುವ ಡೈರೆಕ್ಟರಿಗೆ ಹೋಗಿ ಸರ್ವರ್:

cd YOUR_WORKING_DIRECTORY/istio-samples/sample-apps/helloserver/server/

2) ತೆರೆಯಿರಿ ಸರ್ವರ್.ಯಾಮ್ಲ್ ಪಠ್ಯ ಸಂಪಾದಕದಲ್ಲಿ.
3) ಕ್ಷೇತ್ರದಲ್ಲಿ ಹೆಸರನ್ನು ಬದಲಾಯಿಸಿ ಚಿತ್ರ ನಿಮ್ಮ ಡಾಕರ್ ಚಿತ್ರದ ಹೆಸರಿಗೆ.

image: gcr.io/PROJECT_ID/preparing-istio/helloserver:v0.0.1

ಬದಲಾಯಿಸಿ PROJECT_ID ನಿಮ್ಮ GCP ಯೋಜನೆಯ ID ಗೆ.
4) ಉಳಿಸಿ ಮತ್ತು ಮುಚ್ಚಿ ಸರ್ವರ್.ಯಾಮ್ಲ್.
5) YAML ಫೈಲ್ ಅನ್ನು ಕುಬರ್ನೆಟ್ಸ್ಗೆ ನಿಯೋಜಿಸಿ:

kubectl apply -f server.yaml

ಯಶಸ್ವಿಯಾಗಿ ಪೂರ್ಣಗೊಂಡ ನಂತರ, ಆಜ್ಞೆಯು ಈ ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ:

deployment.apps/helloserver created
service/hellosvc created

6) ಡೈರೆಕ್ಟರಿಗೆ ಹೋಗಿ ಲೋಡ್ಜೆನ್:

cd ../loadgen

7) ತೆರೆಯಿರಿ loadgen.yaml ಪಠ್ಯ ಸಂಪಾದಕದಲ್ಲಿ.
8) ಕ್ಷೇತ್ರದಲ್ಲಿ ಹೆಸರನ್ನು ಬದಲಾಯಿಸಿ ಚಿತ್ರ ನಿಮ್ಮ ಡಾಕರ್ ಚಿತ್ರದ ಹೆಸರಿಗೆ.

image: gcr.io/PROJECT_ID/preparing-istio/loadgenv0.0.1

ಬದಲಾಯಿಸಿ PROJECT_ID ನಿಮ್ಮ GCP ಯೋಜನೆಯ ID ಗೆ.
9) ಉಳಿಸಿ ಮತ್ತು ಮುಚ್ಚಿ loadgen.yaml, ಪಠ್ಯ ಸಂಪಾದಕವನ್ನು ಮುಚ್ಚಿ.
10) YAML ಫೈಲ್ ಅನ್ನು ಕುಬರ್ನೆಟ್ಸ್ಗೆ ನಿಯೋಜಿಸಿ:

kubectl apply -f loadgen.yaml

ಯಶಸ್ವಿಯಾಗಿ ಪೂರ್ಣಗೊಂಡ ನಂತರ, ಆಜ್ಞೆಯು ಈ ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ:

deployment.apps/loadgenerator created
service/loadgensvc created

11) ಬೀಜಕೋಶಗಳ ಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸಿ:

kubectl get pods

ಆಜ್ಞೆಯು ಸ್ಥಿತಿಯನ್ನು ತೋರಿಸುತ್ತದೆ:

NAME                             READY   STATUS    RESTARTS   AGE
helloserver-69b9576d96-mwtcj     1/1     Running   0          58s
loadgenerator-774dbc46fb-gpbrz   1/1     Running   0          57s

12) ಪಾಡ್‌ನಿಂದ ಅಪ್ಲಿಕೇಶನ್ ಲಾಗ್‌ಗಳನ್ನು ಹೊರತೆಗೆಯಿರಿ ಲೋಡ್ಜೆನ್. ಬದಲಾಯಿಸಿ POD_ID ಹಿಂದಿನ ಉತ್ತರದಿಂದ ಗುರುತಿಸುವಿಕೆಗೆ.

kubectl logs loadgenerator-POD_ID

13) ಬಾಹ್ಯ IP ವಿಳಾಸಗಳನ್ನು ಪಡೆದುಕೊಳ್ಳಿ ಹಲೋಸ್ವಿಸಿ:

kubectl get service

ಆಜ್ಞೆಯ ಪ್ರತಿಕ್ರಿಯೆಯು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

NAME         TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
hellosvc     LoadBalancer   10.81.15.158   192.0.2.1       80:31127/TCP   33m
kubernetes   ClusterIP      10.81.0.1      <none>          443/TCP        93m
loadgensvc   ClusterIP      10.81.15.155   <none>          80/TCP         4m52s

14) ವಿನಂತಿಯನ್ನು ಕಳುಹಿಸಿ ಹಲೋಸ್ವಿಸಿ: ಬದಲಿ EXTERNAL_IP ಬಾಹ್ಯ IP ವಿಳಾಸಕ್ಕೆ ಹಲೋಸ್ವಿಸಿ.

curl http://EXTERNAL_IP

ಇಸ್ಟಿಯೋವನ್ನು ತೆಗೆದುಕೊಳ್ಳೋಣ

ನೀವು ಈಗಾಗಲೇ GKE ಗೆ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿಯೋಜಿಸಿರುವಿರಿ. ಲೋಡ್ಜೆನ್ ಕುಬರ್ನೆಟ್ಸ್ DNS ಅನ್ನು ಬಳಸಬಹುದು (hellovc:80) ವಿನಂತಿಗಳನ್ನು ಕಳುಹಿಸಲು ಸರ್ವರ್ಮತ್ತು ನೀವು ವಿನಂತಿಗಳನ್ನು ಕಳುಹಿಸಬಹುದು ಸರ್ವರ್ ಬಾಹ್ಯ IP ವಿಳಾಸದಿಂದ. ಕುಬರ್ನೆಟ್ಸ್ ಹಲವು ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಹೊಂದಿದ್ದರೂ, ಸೇವೆಗಳ ಬಗ್ಗೆ ಕೆಲವು ಮಾಹಿತಿಯು ಕಾಣೆಯಾಗಿದೆ:

  • ಸೇವೆಗಳು ಹೇಗೆ ಸಂವಹನ ನಡೆಸುತ್ತವೆ? ಸೇವೆಗಳ ನಡುವಿನ ಸಂಬಂಧಗಳು ಯಾವುವು? ಸೇವೆಗಳ ನಡುವೆ ಸಂಚಾರ ಹೇಗೆ ಹರಿಯುತ್ತದೆ? ಅದರ ಅರಿವಿದೆಯೇ ಲೋಡ್ಜೆನ್ ಗೆ ವಿನಂತಿಗಳನ್ನು ಕಳುಹಿಸುತ್ತದೆ ಸರ್ವರ್, ಆದರೆ ಅಪ್ಲಿಕೇಶನ್ ಬಗ್ಗೆ ನಿಮಗೆ ಏನೂ ತಿಳಿದಿಲ್ಲ ಎಂದು ಊಹಿಸಿ. ಈ ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರಿಸಲು, GKE ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಪಾಡ್‌ಗಳ ಪಟ್ಟಿಯನ್ನು ನೋಡೋಣ.
  • ಮೆಟ್ರಿಕ್ಸ್. ಎಷ್ಟು ಹೊತ್ತು ಸರ್ವರ್ ಒಳಬರುವ ವಿನಂತಿಗೆ ಪ್ರತಿಕ್ರಿಯಿಸುತ್ತದೆಯೇ? ಪ್ರತಿ ಸೆಕೆಂಡಿಗೆ ಎಷ್ಟು ವಿನಂತಿಗಳನ್ನು ಸರ್ವರ್ ಸ್ವೀಕರಿಸುತ್ತದೆ? ಇದು ದೋಷ ಸಂದೇಶಗಳನ್ನು ನೀಡುತ್ತದೆಯೇ?
  • ಭದ್ರತಾ ಮಾಹಿತಿ. ನಡುವೆ ಸಂಚಾರ ಲೋಡ್ಜೆನ್ и ಸರ್ವರ್ ಕೇವಲ ಹಾದುಹೋಗುತ್ತದೆ HTTP ಅಥವಾ ಮೂಲಕ mTLS?

ಈ ಎಲ್ಲಾ ಪ್ರಶ್ನೆಗಳಿಗೆ ಇಸ್ಟಿಯೋ ಉತ್ತರಿಸುತ್ತಾನೆ. ಇದನ್ನು ಮಾಡಲು, ಇಸ್ಟಿಯೊ ಸೈಡ್‌ಕಾರ್ ಪ್ರಾಕ್ಸಿಯನ್ನು ಇರಿಸುತ್ತದೆ ಪ್ರತಿನಿಧಿ ಪ್ರತಿ ಪಾಡ್ನಲ್ಲಿ. ಎನ್ವಾಯ್ ಪ್ರಾಕ್ಸಿ ಎಲ್ಲಾ ಒಳಬರುವ ಮತ್ತು ಹೊರಹೋಗುವ ಟ್ರಾಫಿಕ್ ಅನ್ನು ಅಪ್ಲಿಕೇಶನ್ ಕಂಟೈನರ್‌ಗಳಿಗೆ ಪ್ರತಿಬಂಧಿಸುತ್ತದೆ. ಎಂದು ಅರ್ಥ ಸರ್ವರ್ и ಲೋಡ್ಜೆನ್ ಸೈಡ್‌ಕಾರ್ ಪ್ರಾಕ್ಸಿ ಎನ್ವಾಯ್ ಮೂಲಕ ಮತ್ತು ಎಲ್ಲಾ ಟ್ರಾಫಿಕ್ ಮೂಲಕ ಸ್ವೀಕರಿಸಿ ಲೋಡ್ಜೆನ್ к ಸರ್ವರ್ ಎನ್ವಾಯ್ ಪ್ರಾಕ್ಸಿ ಮೂಲಕ ಹೋಗುತ್ತದೆ.

ಎನ್ವಾಯ್ ಪ್ರಾಕ್ಸಿಗಳ ನಡುವಿನ ಸಂಪರ್ಕಗಳು ಸೇವಾ ಜಾಲರಿಯನ್ನು ರೂಪಿಸುತ್ತವೆ. ಸೇವಾ ಜಾಲರಿ ಆರ್ಕಿಟೆಕ್ಚರ್ ಕುಬರ್ನೆಟ್ಸ್ ಮೇಲೆ ನಿಯಂತ್ರಣದ ಪದರವನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಇಸ್ಟಿಯೊಗಾಗಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸಿದ್ಧಪಡಿಸಲಾಗುತ್ತಿದೆ

ಎನ್ವಾಯ್ ಪ್ರಾಕ್ಸಿಗಳು ತಮ್ಮದೇ ಆದ ಕಂಟೈನರ್‌ಗಳಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದರಿಂದ, ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್‌ಗೆ ಯಾವುದೇ ಬದಲಾವಣೆಗಳಿಲ್ಲದೆ GKE ಕ್ಲಸ್ಟರ್‌ನ ಮೇಲೆ ಇಸ್ಟಿಯೊವನ್ನು ಸ್ಥಾಪಿಸಬಹುದು. ಆದರೆ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಇಸ್ಟಿಯೊ ಮೂಲಕ ನಿರ್ವಹಿಸಲು ಸಿದ್ಧವಾಗಲು ನೀವು ಕೆಲವು ಕೆಲಸವನ್ನು ಮಾಡಿದ್ದೀರಿ:

  • ಎಲ್ಲಾ ಕಂಟೈನರ್‌ಗಳಿಗೆ ಸೇವೆಗಳು. ನಿಯೋಜನೆಗಳಿಗೆ ಸರ್ವರ್ и ಲೋಡ್ಜೆನ್ ಕುಬರ್ನೆಟ್ಸ್ ಸೇವೆಗೆ ಬಂಧಿಸಲಾಗಿದೆ. ಸಹ ಲೋಡ್ಜೆನ್, ಇದು ಒಳಬರುವ ವಿನಂತಿಗಳನ್ನು ಸ್ವೀಕರಿಸುವುದಿಲ್ಲ, ಸೇವೆ ಇದೆ.
  • ಸೇವೆಗಳಲ್ಲಿನ ಬಂದರುಗಳು ಹೆಸರುಗಳನ್ನು ಹೊಂದಿರಬೇಕು. GKE ನಲ್ಲಿ ಸೇವಾ ಪೋರ್ಟ್‌ಗಳನ್ನು ಹೆಸರಿಸದೆ ಬಿಡಬಹುದಾದರೂ, Istio ಗೆ ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಅಗತ್ಯವಿದೆ ಬಂದರು ಹೆಸರು ಅವನ ಪ್ರೋಟೋಕಾಲ್ಗೆ ಅನುಗುಣವಾಗಿ. YAML ಫೈಲ್‌ನಲ್ಲಿ ಪೋರ್ಟ್ ಫಾರ್ ಸರ್ವರ್ ಕರೆಯಲಾಗುತ್ತದೆ HTTPಏಕೆಂದರೆ ಸರ್ವರ್ ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಬಳಸುತ್ತದೆ HTTP. ಒಂದು ವೇಳೆ ಸೇವೆ ಬಳಸಲಾಗಿದೆ gRPC, ನೀವು ಬಂದರಿಗೆ ಹೆಸರಿಸುತ್ತೀರಿ grpc.
  • ನಿಯೋಜನೆಗಳನ್ನು ಫ್ಲ್ಯಾಗ್ ಮಾಡಲಾಗಿದೆ. ಆದ್ದರಿಂದ, ನೀವು ಅದೇ ಸೇವೆಯ ಆವೃತ್ತಿಗಳ ನಡುವೆ ಟ್ರಾಫಿಕ್ ಅನ್ನು ವಿಭಜಿಸುವಂತಹ ಇಸ್ಟಿಯೊದ ಸಂಚಾರ ನಿರ್ವಹಣೆ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಬಳಸಬಹುದು.

ಇಸ್ಟಿಯೊವನ್ನು ಸ್ಥಾಪಿಸಲಾಗುತ್ತಿದೆ

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

ಆಯ್ಕೆಯನ್ನು ಆರಿಸಿ, ಸೂಕ್ತವಾದ ಮಾರ್ಗದರ್ಶಿಯನ್ನು ಪರಿಶೀಲಿಸಿ ಮತ್ತು ನಿಮ್ಮ ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ Istio ಅನ್ನು ಸ್ಥಾಪಿಸಲು ಸೂಚನೆಗಳನ್ನು ಅನುಸರಿಸಿ. ನಿಮ್ಮ ಹೊಸದಾಗಿ ನಿಯೋಜಿಸಲಾದ ಅಪ್ಲಿಕೇಶನ್‌ನೊಂದಿಗೆ ನೀವು ಇಸ್ಟಿಯೊವನ್ನು ಬಳಸಲು ಬಯಸಿದರೆ, ಸೈಡ್‌ಕಾರ್ ಅನುಷ್ಠಾನವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ ನೇಮ್‌ಸ್ಪೇಸ್‌ಗಾಗಿ ಡೀಫಾಲ್ಟ್.

ಸ್ವಚ್ಛಗೊಳಿಸುವ

ಈ ಟ್ಯುಟೋರಿಯಲ್‌ನಲ್ಲಿ ನೀವು ಬಳಸಿದ ಸಂಪನ್ಮೂಲಗಳಿಗಾಗಿ ನಿಮ್ಮ Google ಕ್ಲೌಡ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಖಾತೆಗೆ ಶುಲ್ಕ ವಿಧಿಸುವುದನ್ನು ತಪ್ಪಿಸಲು, ನೀವು Istio ಅನ್ನು ಸ್ಥಾಪಿಸಿದ ನಂತರ ಮತ್ತು ಮಾದರಿ ಅಪ್ಲಿಕೇಶನ್‌ನೊಂದಿಗೆ ಪ್ಲೇ ಮಾಡಿದ ನಂತರ ಕಂಟೇನರ್ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಅಳಿಸಿ. ಇದು ಕಂಪ್ಯೂಟ್ ನಿದರ್ಶನಗಳು, ಡಿಸ್ಕ್ಗಳು ​​ಮತ್ತು ನೆಟ್ವರ್ಕ್ ಸಂಪನ್ಮೂಲಗಳಂತಹ ಎಲ್ಲಾ ಕ್ಲಸ್ಟರ್ ಸಂಪನ್ಮೂಲಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ.

ಮುಂದಿನ ಏನು?

ಮೂಲ: www.habr.com

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