PowerCLI ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಿಗಾಗಿ ರಾಕೆಟ್ ಬೂಸ್ಟರ್ ಅನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸುವುದು 

ಶೀಘ್ರದಲ್ಲೇ ಅಥವಾ ನಂತರ, ಯಾವುದೇ VMware ಸಿಸ್ಟಮ್ ನಿರ್ವಾಹಕರು ದಿನನಿತ್ಯದ ಕಾರ್ಯಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ಬರುತ್ತಾರೆ. ಇದು ಎಲ್ಲಾ ಆಜ್ಞಾ ಸಾಲಿನೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ, ನಂತರ PowerShell ಅಥವಾ VMware PowerCLI ಬರುತ್ತದೆ.

ISE ಅನ್ನು ಪ್ರಾರಂಭಿಸುವುದಕ್ಕಿಂತ ಸ್ವಲ್ಪ ಮುಂದೆ ನೀವು ಪವರ್‌ಶೆಲ್ ಅನ್ನು ಕರಗತ ಮಾಡಿಕೊಂಡಿದ್ದೀರಿ ಎಂದು ಹೇಳೋಣ ಮತ್ತು "ಕೆಲವು ರೀತಿಯ ಮ್ಯಾಜಿಕ್" ನಿಂದ ಕೆಲಸ ಮಾಡುವ ಮಾಡ್ಯೂಲ್‌ಗಳಿಂದ ಪ್ರಮಾಣಿತ cmdlets ಅನ್ನು ಬಳಸುತ್ತದೆ. ನೀವು ನೂರಾರು ವರ್ಚುವಲ್ ಯಂತ್ರಗಳನ್ನು ಎಣಿಸಲು ಪ್ರಾರಂಭಿಸಿದಾಗ, ಸಣ್ಣ ಪ್ರಮಾಣದಲ್ಲಿ ಸಹಾಯ ಮಾಡುವ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ದೊಡ್ಡ ಪ್ರಮಾಣದಲ್ಲಿ ಗಮನಾರ್ಹವಾಗಿ ನಿಧಾನವಾಗಿ ಚಲಿಸುತ್ತವೆ ಎಂದು ನೀವು ಕಂಡುಕೊಳ್ಳುತ್ತೀರಿ. 

ಈ ಪರಿಸ್ಥಿತಿಯಲ್ಲಿ, 2 ಉಪಕರಣಗಳು ಸಹಾಯ ಮಾಡುತ್ತವೆ:

• ಪವರ್‌ಶೆಲ್ ರನ್‌ಸ್ಪೇಸ್‌ಗಳು - ಪ್ರತ್ಯೇಕ ಎಳೆಗಳಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಗಳ ಮರಣದಂಡನೆಯನ್ನು ಸಮಾನಾಂತರಗೊಳಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಒಂದು ವಿಧಾನ; 
• ಪಡೆಯಿರಿ-ವೀಕ್ಷಿಸಿ - ಮೂಲಭೂತ PowerCLI ಕಾರ್ಯ, ವಿಂಡೋಸ್‌ನಲ್ಲಿ Get-WMIObject ನ ಅನಲಾಗ್. ಈ cmdlet ಘಟಕಗಳ ಜೊತೆಗಿನ ವಸ್ತುಗಳನ್ನು ಎಳೆಯುವುದಿಲ್ಲ, ಆದರೆ ಸರಳವಾದ ಡೇಟಾ ಪ್ರಕಾರಗಳೊಂದಿಗೆ ಸರಳ ವಸ್ತುವಿನ ರೂಪದಲ್ಲಿ ಮಾಹಿತಿಯನ್ನು ಪಡೆಯುತ್ತದೆ. ಅನೇಕ ಸಂದರ್ಭಗಳಲ್ಲಿ ಇದು ವೇಗವಾಗಿ ಹೊರಬರುತ್ತದೆ.

ಮುಂದೆ, ನಾನು ಪ್ರತಿ ಉಪಕರಣದ ಬಗ್ಗೆ ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಮಾತನಾಡುತ್ತೇನೆ ಮತ್ತು ಬಳಕೆಯ ಉದಾಹರಣೆಗಳನ್ನು ತೋರಿಸುತ್ತೇನೆ. ನಿರ್ದಿಷ್ಟ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ವಿಶ್ಲೇಷಿಸೋಣ ಮತ್ತು ಒಂದು ಇನ್ನೊಂದಕ್ಕಿಂತ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಿದಾಗ ನೋಡೋಣ. ಹೋಗು!

ಮೊದಲ ಹಂತ: ರನ್‌ಸ್ಪೇಸ್

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

ನೀವು ಇಲ್ಲಿ ಕಲಿಯಲು ಪ್ರಾರಂಭಿಸಬಹುದು: 
ಪವರ್‌ಶೆಲ್ ರನ್‌ಸ್ಪೇಸ್‌ಗಳ ಆರಂಭದ ಬಳಕೆ: ಭಾಗ 1

ರನ್‌ಸ್ಪೇಸ್ ಬಳಕೆ ಏನು ನೀಡುತ್ತದೆ:

• ಕಾರ್ಯಗತಗೊಳಿಸಿದ ಆಜ್ಞೆಗಳ ಪಟ್ಟಿಯನ್ನು ಸೀಮಿತಗೊಳಿಸುವ ಮೂಲಕ ವೇಗ,
• ಕಾರ್ಯಗಳ ಸಮಾನಾಂತರ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆ,
• ಸುರಕ್ಷತೆ.

ರನ್‌ಸ್ಪೇಸ್ ಸಹಾಯ ಮಾಡಿದಾಗ ಇಂಟರ್ನೆಟ್‌ನಿಂದ ಒಂದು ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

"ಶೇಖರಣಾ ವಿವಾದವು vSphere ನಲ್ಲಿ ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಕಠಿಣವಾದ ಮೆಟ್ರಿಕ್‌ಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. vCenter ಒಳಗೆ, ನೀವು ಹೋಗಿ ಯಾವ VM ಹೆಚ್ಚು ಶೇಖರಣಾ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಬಳಸುತ್ತಿದೆ ಎಂಬುದನ್ನು ನೋಡಲು ಸಾಧ್ಯವಿಲ್ಲ. ಅದೃಷ್ಟವಶಾತ್, PowerShell ಗೆ ಧನ್ಯವಾದಗಳು ನೀವು ನಿಮಿಷಗಳಲ್ಲಿ ಈ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು.
VMware ಸಿಸ್ಟಮ್ ನಿರ್ವಾಹಕರು vCenter ನಾದ್ಯಂತ ತ್ವರಿತವಾಗಿ ಹುಡುಕಲು ಮತ್ತು ಅವರ ಸರಾಸರಿ ಬಳಕೆಯ ಡೇಟಾದೊಂದಿಗೆ VM ಗಳ ಪಟ್ಟಿಯನ್ನು ಸ್ವೀಕರಿಸಲು ಅನುಮತಿಸುವ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ನಾನು ಹಂಚಿಕೊಳ್ಳುತ್ತೇನೆ.  
ಪ್ರತಿ ESXi ಹೋಸ್ಟ್‌ಗೆ ತನ್ನದೇ ಆದ VM ಗಳಿಂದ ಬಳಕೆಯ ಮಾಹಿತಿಯನ್ನು ಪ್ರತ್ಯೇಕ ರನ್‌ಸ್ಪೇಸ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲು ಮತ್ತು ತಕ್ಷಣವೇ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯನ್ನು ವರದಿ ಮಾಡಲು ಸ್ಕ್ರಿಪ್ಟ್ PowerShell ರನ್‌ಸ್ಪೇಸ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ. ಇದು ಪವರ್‌ಶೆಲ್ ಅನ್ನು ಹೋಸ್ಟ್‌ಗಳ ಮೂಲಕ ಪುನರಾವರ್ತನೆ ಮಾಡುವ ಬದಲು ಮತ್ತು ಪ್ರತಿಯೊಂದೂ ತನ್ನ ವಿನಂತಿಯನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು ಕಾಯುವ ಬದಲು ತಕ್ಷಣವೇ ಉದ್ಯೋಗಗಳನ್ನು ಮುಚ್ಚಲು ಅನುಮತಿಸುತ್ತದೆ.

ಮೂಲ: ESXi ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ನಲ್ಲಿ ವರ್ಚುವಲ್ ಮೆಷಿನ್ I/O ಅನ್ನು ಹೇಗೆ ತೋರಿಸುವುದು

ಕೆಳಗಿನ ಸಂದರ್ಭದಲ್ಲಿ, ರನ್‌ಸ್ಪೇಸ್ ಇನ್ನು ಮುಂದೆ ಉಪಯುಕ್ತವಾಗುವುದಿಲ್ಲ:

"ನಾನು VM ನಿಂದ ಬಹಳಷ್ಟು ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುವ ಮತ್ತು ಅಗತ್ಯವಿದ್ದಾಗ ಹೊಸ ಡೇಟಾವನ್ನು ಬರೆಯುವ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬರೆಯಲು ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದೇನೆ. ಸಮಸ್ಯೆಯೆಂದರೆ ಸಾಕಷ್ಟು ವಿಎಂಗಳು ಇವೆ ಮತ್ತು ಒಂದು ಯಂತ್ರದಲ್ಲಿ 5-8 ಸೆಕೆಂಡುಗಳನ್ನು ಕಳೆಯಲಾಗುತ್ತದೆ. 

ಮೂಲ: ರನ್‌ಸ್ಪೇಸ್‌ಪೂಲ್‌ನೊಂದಿಗೆ ಮಲ್ಟಿಥ್ರೆಡಿಂಗ್ ಪವರ್‌ಸಿಎಲ್‌ಐ

ಇಲ್ಲಿ ನಿಮಗೆ ಗೆಟ್-ವೀಕ್ಷಿ ಬೇಕಾಗುತ್ತದೆ, ನಾವು ಅದಕ್ಕೆ ಹೋಗೋಣ. 

ಎರಡನೇ ಹಂತ: ಪಡೆಯಿರಿ-ವೀಕ್ಷಣೆ

Get-View ಏಕೆ ಉಪಯುಕ್ತವಾಗಿದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, cmdlets ಸಾಮಾನ್ಯವಾಗಿ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಟ್ಟುಕೊಳ್ಳುವುದು ಯೋಗ್ಯವಾಗಿದೆ. 

API ಉಲ್ಲೇಖ ಪುಸ್ತಕಗಳನ್ನು ಅಧ್ಯಯನ ಮಾಡದೆ ಮತ್ತು ಮುಂದಿನ ಚಕ್ರವನ್ನು ಮರುಶೋಧಿಸುವ ಅಗತ್ಯವಿಲ್ಲದೇ ಅನುಕೂಲಕರವಾಗಿ ಮಾಹಿತಿಯನ್ನು ಪಡೆಯಲು Cmdlets ಅಗತ್ಯವಿದೆ. ಹಳೆಯ ದಿನಗಳಲ್ಲಿ ನೂರು ಅಥವಾ ಎರಡು ಸಾಲುಗಳ ಕೋಡ್ ತೆಗೆದುಕೊಂಡಿತು, PowerShell ನಿಮಗೆ ಒಂದು ಆಜ್ಞೆಯೊಂದಿಗೆ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ. ಈ ಅನುಕೂಲಕ್ಕಾಗಿ ನಾವು ವೇಗದಲ್ಲಿ ಪಾವತಿಸುತ್ತೇವೆ. cmdlets ಒಳಗೆ ಯಾವುದೇ ಮ್ಯಾಜಿಕ್ ಇಲ್ಲ: ಅದೇ ಸ್ಕ್ರಿಪ್ಟ್, ಆದರೆ ಕಡಿಮೆ ಮಟ್ಟದಲ್ಲಿ, ಬಿಸಿಲು ಭಾರತದ ಮಾಸ್ಟರ್ನ ಕೌಶಲ್ಯಪೂರ್ಣ ಕೈಗಳಿಂದ ಬರೆಯಲಾಗಿದೆ.

ಈಗ, Get-View ನೊಂದಿಗೆ ಹೋಲಿಕೆಗಾಗಿ, Get-VM cmdlet ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳೋಣ: ಇದು ವರ್ಚುವಲ್ ಯಂತ್ರವನ್ನು ಪ್ರವೇಶಿಸುತ್ತದೆ ಮತ್ತು ಸಂಯೋಜಿತ ವಸ್ತುವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಅಂದರೆ, ಇದು ಇತರ ಸಂಬಂಧಿತ ವಸ್ತುಗಳನ್ನು ಲಗತ್ತಿಸುತ್ತದೆ: VMHost, Datastore, ಇತ್ಯಾದಿ.  

ಅದರ ಸ್ಥಳದಲ್ಲಿ ಪಡೆಯಿರಿ-ವೀಕ್ಷಣೆ ಹಿಂತಿರುಗಿದ ವಸ್ತುವಿಗೆ ಅನಗತ್ಯವಾದ ಯಾವುದನ್ನೂ ಸೇರಿಸುವುದಿಲ್ಲ. ಇದಲ್ಲದೆ, ನಮಗೆ ಅಗತ್ಯವಿರುವ ಮಾಹಿತಿಯನ್ನು ಕಟ್ಟುನಿಟ್ಟಾಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಇದು ಅನುಮತಿಸುತ್ತದೆ, ಇದು ಔಟ್ಪುಟ್ ವಸ್ತುವನ್ನು ಸುಲಭಗೊಳಿಸುತ್ತದೆ. ಸಾಮಾನ್ಯವಾಗಿ ವಿಂಡೋಸ್ ಸರ್ವರ್‌ನಲ್ಲಿ ಮತ್ತು ನಿರ್ದಿಷ್ಟವಾಗಿ ಹೈಪರ್-ವಿಯಲ್ಲಿ, Get-WMIObject cmdlet ನೇರ ಅನಲಾಗ್ ಆಗಿದೆ - ಕಲ್ಪನೆಯು ಒಂದೇ ಆಗಿರುತ್ತದೆ.

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

ನೀವು VMware ಬ್ಲಾಗ್‌ನಲ್ಲಿ ಇನ್ನಷ್ಟು ಓದಬಹುದು: ಗೆಟ್-ವೀವ್ ಗೆ ಪರಿಚಯ

ಈಗ ನಾನು ನಿಜವಾದ ಪ್ರಕರಣವನ್ನು ಬಳಸಿಕೊಂಡು ಎಲ್ಲವನ್ನೂ ನಿಮಗೆ ತೋರಿಸುತ್ತೇನೆ. 

VM ಅನ್ನು ಅನ್‌ಲೋಡ್ ಮಾಡಲು ಸ್ಕ್ರಿಪ್ಟ್ ಬರೆಯುವುದು

ಒಂದು ದಿನ ನನ್ನ ಸಹೋದ್ಯೋಗಿ ತನ್ನ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಆಪ್ಟಿಮೈಸ್ ಮಾಡಲು ನನ್ನನ್ನು ಕೇಳಿದರು. ಕಾರ್ಯವು ಸಾಮಾನ್ಯ ದಿನಚರಿಯಾಗಿದೆ: ನಕಲಿ cloud.uuid ಪ್ಯಾರಾಮೀಟರ್‌ನೊಂದಿಗೆ ಎಲ್ಲಾ VM ಗಳನ್ನು ಹುಡುಕಿ (ಹೌದು, vCloud ಡೈರೆಕ್ಟರ್‌ನಲ್ಲಿ VM ಅನ್ನು ಕ್ಲೋನಿಂಗ್ ಮಾಡುವಾಗ ಇದು ಸಾಧ್ಯ). 

ಮನಸ್ಸಿಗೆ ಬರುವ ಸ್ಪಷ್ಟ ಪರಿಹಾರವೆಂದರೆ:

1. ಎಲ್ಲಾ VM ಗಳ ಪಟ್ಟಿಯನ್ನು ಪಡೆಯಿರಿ.
2. ಹೇಗಾದರೂ ಪಟ್ಟಿಯನ್ನು ಪಾರ್ಸ್ ಮಾಡಿ.

ಮೂಲ ಆವೃತ್ತಿಯು ಈ ಸರಳ ಸ್ಕ್ರಿಪ್ಟ್ ಆಗಿತ್ತು:

function Get-CloudUUID1 {
   # Получаем список всех ВМ
   $vms = Get-VM
   $report = @()

   # Обрабатываем каждый объект, получая из него только 2 свойства: Имя ВМ и Cloud UUID.
   # Заносим данные в новый PS-объект с полями VM и UUID
   foreach ($vm in $vms)
   {
       $table = "" | select VM,UUID

       $table.VM = $vm.name
       $table.UUID = ($vm | Get-AdvancedSetting -Name cloud.uuid).Value
          
       $report += $table
   }
# Возвращаем все объекты
   $report
}
# Далее РУКАМИ парсим полученный результат

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

ಆದರೆ ಸಮಯವನ್ನು ಅಳೆಯೋಣ:

2 ನಿಮಿಷ 47 ಸೆಕೆಂಡುಗಳು ಸುಮಾರು 10k VM ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವಾಗ. ಬೋನಸ್ ಎಂದರೆ ಫಿಲ್ಟರ್‌ಗಳ ಅನುಪಸ್ಥಿತಿ ಮತ್ತು ಫಲಿತಾಂಶಗಳನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ವಿಂಗಡಿಸುವ ಅಗತ್ಯತೆ. ನಿಸ್ಸಂಶಯವಾಗಿ, ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಆಪ್ಟಿಮೈಸೇಶನ್ ಅಗತ್ಯವಿದೆ.

ನೀವು ಏಕಕಾಲದಲ್ಲಿ vCenter ನಿಂದ ಹೋಸ್ಟ್ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಪಡೆಯಬೇಕಾದಾಗ ಅಥವಾ ಹತ್ತಾರು ಸಾವಿರ ವಸ್ತುಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬೇಕಾದಾಗ ರನ್‌ಸ್ಪೇಸ್‌ಗಳು ರಕ್ಷಣೆಗೆ ಬರುತ್ತವೆ. ಈ ವಿಧಾನವು ಏನನ್ನು ತರುತ್ತದೆ ಎಂದು ನೋಡೋಣ.

ಮೊದಲ ವೇಗವನ್ನು ಆನ್ ಮಾಡಿ: ಪವರ್‌ಶೆಲ್ ರನ್‌ಸ್ಪೇಸಸ್

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

ಆದರೆ ಸಮಸ್ಯೆ ಇದೆ: ಪವರ್‌ಸಿಎಲ್‌ಐ ಅನೇಕ ಸ್ವತಂತ್ರ ಸೆಷನ್‌ಗಳನ್ನು vCenter ಗೆ ತೆರೆಯಲು ನಮಗೆ ಅನುಮತಿಸುವುದಿಲ್ಲ ಮತ್ತು ತಮಾಷೆಯ ದೋಷವನ್ನು ಎಸೆಯುತ್ತದೆ:

You have modified the global:DefaultVIServer and global:DefaultVIServers system variables. This is not allowed. Please reset them to $null and reconnect to the vSphere server.

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

$ConnectionString = @()
foreach ($vCenter in $vCenters)
   {
       try {
           $ConnectionString += Connect-VIServer -Server $vCenter -Credential $Credential -NotDefault -AllLinked -Force -ErrorAction stop -WarningAction SilentlyContinue -ErrorVariable er
       }
       catch {
           if ($er.Message -like "*not part of a linked mode*")
           {
               try {
                   $ConnectionString += Connect-VIServer -Server $vCenter -Credential $Credential -NotDefault -Force -ErrorAction stop -WarningAction SilentlyContinue -ErrorVariable er
               }
               catch {
                   throw $_
               }
              
           }
           else {
               throw $_
           }
       }
   }

ಈಗ ರನ್‌ಸ್ಪೇಸ್ ಪೂಲ್‌ಗಳ ಮೂಲಕ ಮಲ್ಟಿಥ್ರೆಡಿಂಗ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸೋಣ.  

ಅಲ್ಗಾರಿದಮ್ ಹೀಗಿದೆ:

1. ನಾವು ಎಲ್ಲಾ VM ಗಳ ಪಟ್ಟಿಯನ್ನು ಪಡೆಯುತ್ತೇವೆ.
2. ಸಮಾನಾಂತರ ಸ್ಟ್ರೀಮ್‌ಗಳಲ್ಲಿ ನಾವು cloud.uuid ಅನ್ನು ಪಡೆಯುತ್ತೇವೆ.
3. ನಾವು ಸ್ಟ್ರೀಮ್‌ಗಳಿಂದ ಡೇಟಾವನ್ನು ಒಂದು ವಸ್ತುವಿನೊಳಗೆ ಸಂಗ್ರಹಿಸುತ್ತೇವೆ.
4. ನಾವು CloudUUID ಕ್ಷೇತ್ರದ ಮೌಲ್ಯದಿಂದ ಅದನ್ನು ಗುಂಪು ಮಾಡುವ ಮೂಲಕ ವಸ್ತುವನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುತ್ತೇವೆ: ಅನನ್ಯ ಮೌಲ್ಯಗಳ ಸಂಖ್ಯೆ 1 ಕ್ಕಿಂತ ಹೆಚ್ಚಿದ್ದರೆ ನಾವು ಹುಡುಕುತ್ತಿರುವ VM ಗಳು.

ಪರಿಣಾಮವಾಗಿ, ನಾವು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಪಡೆಯುತ್ತೇವೆ:

function Get-VMCloudUUID {
   param (
       [string[]]
       [ValidateNotNullOrEmpty()]
       $vCenters = @(),
       [int]$MaxThreads,
       [System.Management.Automation.PSCredential]
       [System.Management.Automation.Credential()]
       $Credential
   )

   $ConnectionString = @()

   # Создаем объект с сессионным ключом
   foreach ($vCenter in $vCenters)
   {
       try {
           $ConnectionString += Connect-VIServer -Server $vCenter -Credential $Credential -NotDefault -AllLinked -Force -ErrorAction stop -WarningAction SilentlyContinue -ErrorVariable er
       }
       catch {
           if ($er.Message -like "*not part of a linked mode*")
           {
               try {
                   $ConnectionString += Connect-VIServer -Server $vCenter -Credential $Credential -NotDefault -Force -ErrorAction stop -WarningAction SilentlyContinue -ErrorVariable er
               }
               catch {
                   throw $_
               }
              
           }
           else {
               throw $_
           }
       }
   }

   # Получаем список всех ВМ
   $Global:AllVMs = Get-VM -Server $ConnectionString

   # Поехали!
   $ISS = [system.management.automation.runspaces.initialsessionstate]::CreateDefault()
   $RunspacePool = [runspacefactory]::CreateRunspacePool(1, $MaxThreads, $ISS, $Host)
   $RunspacePool.ApartmentState = "MTA"
   $RunspacePool.Open()
   $Jobs = @()

# ScriptBlock с магией!)))
# Именно он будет выполняться в потоке
   $scriptblock = {
       Param (
       $ConnectionString,
       $VM
       )

       $Data = $VM | Get-AdvancedSetting -Name Cloud.uuid -Server $ConnectionString | Select-Object @{N="VMName";E={$_.Entity.Name}},@{N="CloudUUID";E={$_.Value}},@{N="PowerState";E={$_.Entity.PowerState}}

       return $Data
   }
# Генерируем потоки

   foreach($VM in $AllVMs)
   {
       $PowershellThread = [PowerShell]::Create()
# Добавляем скрипт
       $null = $PowershellThread.AddScript($scriptblock)
# И объекты, которые передадим в качестве параметров скрипту
       $null = $PowershellThread.AddArgument($ConnectionString)
       $null = $PowershellThread.AddArgument($VM)
       $PowershellThread.RunspacePool = $RunspacePool
       $Handle = $PowershellThread.BeginInvoke()
       $Job = "" | Select-Object Handle, Thread, object
       $Job.Handle = $Handle
       $Job.Thread = $PowershellThread
       $Job.Object = $VM.ToString()
       $Jobs += $Job
   }

# Ставим градусник, чтобы наглядно отслеживать выполнение заданий
# И здесь же прибиваем отработавшие задания
   While (@($Jobs | Where-Object {$_.Handle -ne $Null}).count -gt 0)
   {
       $Remaining = "$($($Jobs | Where-Object {$_.Handle.IsCompleted -eq $False}).object)"

       If ($Remaining.Length -gt 60) {
           $Remaining = $Remaining.Substring(0,60) + "..."
       }

       Write-Progress -Activity "Waiting for Jobs - $($MaxThreads - $($RunspacePool.GetAvailableRunspaces())) of $MaxThreads threads running" -PercentComplete (($Jobs.count - $($($Jobs | Where-Object {$_.Handle.IsCompleted -eq $False}).count)) / $Jobs.Count * 100) -Status "$(@($($Jobs | Where-Object {$_.Handle.IsCompleted -eq $False})).count) remaining - $remaining"

       ForEach ($Job in $($Jobs | Where-Object {$_.Handle.IsCompleted -eq $True})){
           $Job.Thread.EndInvoke($Job.Handle)     
           $Job.Thread.Dispose()
           $Job.Thread = $Null
           $Job.Handle = $Null
       }
   }

   $RunspacePool.Close() | Out-Null
   $RunspacePool.Dispose() | Out-Null
}


function Get-CloudUUID2
{
   [CmdletBinding()]
   param(
   [string[]]
   [ValidateNotNullOrEmpty()]
   $vCenters = @(),
   [int]$MaxThreads = 50,
   [System.Management.Automation.PSCredential]
   [System.Management.Automation.Credential()]
   $Credential)

   if(!$Credential)
   {
       $Credential = Get-Credential -Message "Please enter vCenter credentials."
   }

   # Вызов функции Get-VMCloudUUID, где мы распараллеливаем операцию
   $AllCloudVMs = Get-VMCloudUUID -vCenters $vCenters -MaxThreads $MaxThreads -Credential $Credential
   $Result = $AllCloudVMs | Sort-Object Value | Group-Object -Property CloudUUID | Where-Object -FilterScript {$_.Count -gt 1} | Select-Object -ExpandProperty Group
   $Result
}

ಈ ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಸೌಂದರ್ಯವೆಂದರೆ ಸ್ಕ್ರಿಪ್ಟ್‌ಬ್ಲಾಕ್ ಮತ್ತು ಸ್ಟ್ರೀಮ್‌ಗೆ ರವಾನಿಸಲಾಗುವ ನಿಯತಾಂಕಗಳನ್ನು ಸರಳವಾಗಿ ಬದಲಿಸುವ ಮೂಲಕ ಇತರ ರೀತಿಯ ಸಂದರ್ಭಗಳಲ್ಲಿ ಇದನ್ನು ಬಳಸಬಹುದು. ಅದನ್ನು ಬಳಸಿಕೊಳ್ಳಿ!

ನಾವು ಸಮಯವನ್ನು ಅಳೆಯುತ್ತೇವೆ:

55 ಸೆಕೆಂಡುಗಳು. ಇದು ಉತ್ತಮವಾಗಿದೆ, ಆದರೆ ಇದು ಇನ್ನೂ ವೇಗವಾಗಿರುತ್ತದೆ. 

ಎರಡನೇ ವೇಗಕ್ಕೆ ಹೋಗೋಣ: GetView

ಏನು ತಪ್ಪಾಗಿದೆ ಎಂದು ಕಂಡುಹಿಡಿಯೋಣ.
ಮೊದಲ ಮತ್ತು ಅಗ್ರಗಣ್ಯವಾಗಿ, Get-VM cmdlet ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಹಳ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.
ಎರಡನೆಯದಾಗಿ, Get-AdvancedOptions cmdlet ಪೂರ್ಣಗೊಳ್ಳಲು ಇನ್ನೂ ಹೆಚ್ಚು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.
ಎರಡನೆಯದನ್ನು ಮೊದಲು ನಿಭಾಯಿಸೋಣ. 

Get-AdvancedOptions ವೈಯಕ್ತಿಕ VM ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗೆ ಅನುಕೂಲಕರವಾಗಿದೆ, ಆದರೆ ಅನೇಕ ವಸ್ತುಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ತುಂಬಾ ವಿಕಾರವಾಗಿರುತ್ತದೆ. ವರ್ಚುವಲ್ ಮೆಷಿನ್ ಆಬ್ಜೆಕ್ಟ್‌ನಿಂದಲೇ (Get-VM) ನಾವು ಅದೇ ಮಾಹಿತಿಯನ್ನು ಪಡೆಯಬಹುದು. ಇದು ಕೇವಲ ExtensionData ಆಬ್ಜೆಕ್ಟ್‌ನಲ್ಲಿ ಚೆನ್ನಾಗಿ ಸಮಾಧಿಯಾಗಿದೆ. ಫಿಲ್ಟರಿಂಗ್ನೊಂದಿಗೆ ಶಸ್ತ್ರಸಜ್ಜಿತವಾದ, ನಾವು ಅಗತ್ಯ ಡೇಟಾವನ್ನು ಪಡೆಯುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ವೇಗಗೊಳಿಸುತ್ತೇವೆ.

ಕೈಯ ಸ್ವಲ್ಪ ಚಲನೆಯೊಂದಿಗೆ ಇದು:

VM | Get-AdvancedSetting -Name Cloud.uuid -Server $ConnectionString | Select-Object @{N="VMName";E={$_.Entity.Name}},@{N="CloudUUID";E={$_.Value}},@{N="PowerState";E={$_.Entity.PowerState}}

ಇದಕ್ಕೆ ತಿರುಗುತ್ತದೆ:

$VM | Where-Object {($_.ExtensionData.Config.ExtraConfig | Where-Object {$_.key -eq "cloud.uuid"}).Value -ne $null} | Select-Object @{N="VMName";E={$_.Name}},@{N="CloudUUID";E={($_.ExtensionData.Config.ExtraConfig | Where-Object {$_.key -eq "cloud.uuid"}).Value}},@{N="PowerState";E={$_.summary.runtime.powerstate}}

ಔಟ್ಪುಟ್ ಗೆಟ್-ಅಡ್ವಾನ್ಸ್ಡ್ ಆಯ್ಕೆಗಳಂತೆಯೇ ಇರುತ್ತದೆ, ಆದರೆ ಇದು ಹಲವು ಪಟ್ಟು ವೇಗವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. 

ಈಗ Get-VM ಗೆ. ಇದು ಸಂಕೀರ್ಣ ವಸ್ತುಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವ ಕಾರಣ ಇದು ವೇಗವಲ್ಲ. ಒಂದು ತಾರ್ಕಿಕ ಪ್ರಶ್ನೆ ಉದ್ಭವಿಸುತ್ತದೆ: ನಮಗೆ VM ನ ಹೆಸರು, ಅದರ ಸ್ಥಿತಿ ಮತ್ತು ಟ್ರಿಕಿ ಗುಣಲಕ್ಷಣದ ಮೌಲ್ಯದ ಅಗತ್ಯವಿರುವಾಗ ನಮಗೆ ಹೆಚ್ಚುವರಿ ಮಾಹಿತಿ ಮತ್ತು ದೈತ್ಯಾಕಾರದ PSObject ಏಕೆ ಬೇಕು?  

ಜೊತೆಗೆ, Get-AdvancedOptions ರೂಪದಲ್ಲಿನ ಅಡಚಣೆಯನ್ನು ಸ್ಕ್ರಿಪ್ಟ್‌ನಿಂದ ತೆಗೆದುಹಾಕಲಾಗಿದೆ. ಸೆಷನ್ ಹಸ್ತಾಂತರಿಸುವಾಗ ಸ್ಕ್ವಾಟ್ ಥ್ರೆಡ್‌ಗಳಾದ್ಯಂತ ನಿಧಾನ ಕಾರ್ಯವನ್ನು ಸಮಾನಾಂತರಗೊಳಿಸುವ ಅಗತ್ಯವಿಲ್ಲದ ಕಾರಣ ರನ್‌ಸ್ಪೇಸ್ ಪೂಲ್‌ಗಳನ್ನು ಬಳಸುವುದು ಈಗ ಓವರ್‌ಕಿಲ್‌ನಂತೆ ತೋರುತ್ತದೆ. ಉಪಕರಣವು ಒಳ್ಳೆಯದು, ಆದರೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ ಅಲ್ಲ. 

ExtensionData ದ ಔಟ್‌ಪುಟ್ ಅನ್ನು ನೋಡೋಣ: ಇದು ಗೆಟ್-ವ್ಯೂ ಆಬ್ಜೆಕ್ಟ್‌ಗಿಂತ ಹೆಚ್ಚೇನೂ ಅಲ್ಲ. 

ಪವರ್‌ಶೆಲ್ ಮಾಸ್ಟರ್‌ಗಳ ಪ್ರಾಚೀನ ತಂತ್ರವನ್ನು ನಾವು ಕರೆಯೋಣ: ಫಿಲ್ಟರ್‌ಗಳನ್ನು ಬಳಸುವ ಒಂದು ಸಾಲು, ವಿಂಗಡಿಸುವುದು ಮತ್ತು ಗುಂಪು ಮಾಡುವುದು. ಹಿಂದಿನ ಎಲ್ಲಾ ಭಯಾನಕತೆಯನ್ನು ಸೊಗಸಾಗಿ ಒಂದು ಸಾಲಿನಲ್ಲಿ ಕುಗ್ಗಿಸಲಾಗಿದೆ ಮತ್ತು ಒಂದು ಸೆಷನ್‌ನಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿದೆ:

$AllVMs = Get-View -viewtype VirtualMachine -Property Name,Config.ExtraConfig,summary.runtime.powerstate | Where-Object {($_.Config.ExtraConfig | Where-Object {$_.key -eq "cloud.uuid"}).Value -ne $null} | Select-Object @{N="VMName";E={$_.Name}},@{N="CloudUUID";E={($_.Config.ExtraConfig | Where-Object {$_.key -eq "cloud.uuid"}).Value}},@{N="PowerState";E={$_.summary.runtime.powerstate}} | Sort-Object CloudUUID | Group-Object -Property CloudUUID | Where-Object -FilterScript {$_.Count -gt 1} | Select-Object -ExpandProperty Group

ನಾವು ಸಮಯವನ್ನು ಅಳೆಯುತ್ತೇವೆ:

9 ಸೆಕೆಂಡುಗಳು ಅಪೇಕ್ಷಿತ ಸ್ಥಿತಿಯ ಮೂಲಕ ಫಿಲ್ಟರಿಂಗ್‌ನೊಂದಿಗೆ ಸುಮಾರು 10k ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗೆ. ಗ್ರೇಟ್!

ಬದಲಿಗೆ ತೀರ್ಮಾನದ

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

ಪಿಎಸ್: ಲೇಖನವನ್ನು ಸಿದ್ಧಪಡಿಸುವಲ್ಲಿ ಅವರ ಸಹಾಯ ಮತ್ತು ಬೆಂಬಲಕ್ಕಾಗಿ ಲೇಖಕರು ಎಲ್ಲಾ ಸಮುದಾಯದ ಸದಸ್ಯರಿಗೆ ಧನ್ಯವಾದಗಳು. ಪಂಜಗಳನ್ನು ಹೊಂದಿರುವವರೂ ಸಹ. ಮತ್ತು ಕಾಲುಗಳನ್ನು ಹೊಂದಿರದವರೂ ಸಹ, ಬೋವಾ ಸಂಕೋಚಕರಂತೆ.

ಮೂಲ: www.habr.com