PowerCLI ਸਕ੍ਰਿਪਟਾਂ ਲਈ ਇੱਕ ਰਾਕੇਟ ਬੂਸਟਰ ਕਿਵੇਂ ਬਣਾਇਆ ਜਾਵੇ 

ਜਲਦੀ ਜਾਂ ਬਾਅਦ ਵਿੱਚ, ਕੋਈ ਵੀ VMware ਸਿਸਟਮ ਪ੍ਰਸ਼ਾਸਕ ਰੁਟੀਨ ਕੰਮਾਂ ਨੂੰ ਆਟੋਮੈਟਿਕ ਕਰਨ ਲਈ ਆਉਂਦਾ ਹੈ। ਇਹ ਸਭ ਕਮਾਂਡ ਲਾਈਨ ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ, ਫਿਰ PowerShell ਜਾਂ VMware PowerCLI ਆਉਂਦਾ ਹੈ।

ਮੰਨ ਲਓ ਕਿ ਤੁਸੀਂ ISE ਨੂੰ ਲਾਂਚ ਕਰਨ ਅਤੇ "ਕਿਸੇ ਕਿਸਮ ਦੇ ਜਾਦੂ" ਦੇ ਕਾਰਨ ਕੰਮ ਕਰਨ ਵਾਲੇ ਮੋਡਿਊਲਾਂ ਤੋਂ ਮਿਆਰੀ cmdlets ਦੀ ਵਰਤੋਂ ਕਰਨ ਤੋਂ ਥੋੜ੍ਹਾ ਅੱਗੇ ਪਾਵਰਸ਼ੇਲ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕੀਤੀ ਹੈ। ਜਦੋਂ ਤੁਸੀਂ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਨੂੰ ਸੈਂਕੜਿਆਂ ਵਿੱਚ ਗਿਣਨਾ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਦੇਖੋਗੇ ਕਿ ਛੋਟੇ ਪੈਮਾਨੇ 'ਤੇ ਮਦਦ ਕਰਨ ਵਾਲੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਵੱਡੇ ਪੈਮਾਨੇ 'ਤੇ ਕਾਫ਼ੀ ਹੌਲੀ ਚੱਲਦੀਆਂ ਹਨ। 

ਇਸ ਸਥਿਤੀ ਵਿੱਚ, 2 ਸਾਧਨ ਮਦਦ ਕਰਨਗੇ:

• PowerShell Runspaces - ਇੱਕ ਪਹੁੰਚ ਜੋ ਤੁਹਾਨੂੰ ਵੱਖ-ਵੱਖ ਥਰਿੱਡਾਂ ਵਿੱਚ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ; 
• ਪ੍ਰਾਪਤਿ-ਦ੍ਰਿਸ਼ਟੀ - ਇੱਕ ਬੁਨਿਆਦੀ PowerCLI ਫੰਕਸ਼ਨ, ਵਿੰਡੋਜ਼ ਵਿੱਚ Get-WMIObject ਦਾ ਇੱਕ ਐਨਾਲਾਗ। ਇਹ cmdlet ਇਕਾਈਆਂ ਦੇ ਨਾਲ ਵਸਤੂਆਂ ਨੂੰ ਨਹੀਂ ਖਿੱਚਦਾ, ਪਰ ਸਧਾਰਨ ਡੇਟਾ ਕਿਸਮਾਂ ਦੇ ਨਾਲ ਇੱਕ ਸਧਾਰਨ ਵਸਤੂ ਦੇ ਰੂਪ ਵਿੱਚ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ। ਕਈ ਮਾਮਲਿਆਂ ਵਿੱਚ ਇਹ ਤੇਜ਼ੀ ਨਾਲ ਸਾਹਮਣੇ ਆਉਂਦਾ ਹੈ।

ਅੱਗੇ, ਮੈਂ ਸੰਖੇਪ ਵਿੱਚ ਹਰੇਕ ਟੂਲ ਬਾਰੇ ਗੱਲ ਕਰਾਂਗਾ ਅਤੇ ਵਰਤੋਂ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਦਿਖਾਵਾਂਗਾ। ਆਉ ਖਾਸ ਸਕ੍ਰਿਪਟਾਂ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰੀਏ ਅਤੇ ਦੇਖਦੇ ਹਾਂ ਕਿ ਇੱਕ ਦੂਜੀ ਨਾਲੋਂ ਬਿਹਤਰ ਕਦੋਂ ਕੰਮ ਕਰਦੀ ਹੈ। ਜਾਣਾ!

ਪਹਿਲਾ ਪੜਾਅ: ਰਨਸਪੇਸ

ਇਸ ਲਈ, ਰਨਸਪੇਸ ਨੂੰ ਮੁੱਖ ਮੋਡੀਊਲ ਤੋਂ ਬਾਹਰ ਕੰਮਾਂ ਦੀ ਸਮਾਨਾਂਤਰ ਪ੍ਰਕਿਰਿਆ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ। ਬੇਸ਼ੱਕ, ਤੁਸੀਂ ਇੱਕ ਹੋਰ ਪ੍ਰਕਿਰਿਆ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹੋ ਜੋ ਕੁਝ ਮੈਮੋਰੀ, ਪ੍ਰੋਸੈਸਰ, ਆਦਿ ਨੂੰ ਖਾ ਲਵੇਗੀ। ਜੇਕਰ ਤੁਹਾਡੀ ਸਕ੍ਰਿਪਟ ਕੁਝ ਮਿੰਟਾਂ ਵਿੱਚ ਚੱਲਦੀ ਹੈ ਅਤੇ ਇੱਕ ਗੀਗਾਬਾਈਟ ਮੈਮੋਰੀ ਦੀ ਖਪਤ ਕਰਦੀ ਹੈ, ਤਾਂ ਸੰਭਵ ਤੌਰ 'ਤੇ ਤੁਹਾਨੂੰ ਰਨਸਪੇਸ ਦੀ ਲੋੜ ਨਹੀਂ ਪਵੇਗੀ। ਪਰ ਹਜ਼ਾਰਾਂ ਵਸਤੂਆਂ ਲਈ ਸਕ੍ਰਿਪਟਾਂ ਲਈ ਇਸਦੀ ਲੋੜ ਹੈ।

ਤੁਸੀਂ ਇੱਥੇ ਸਿੱਖਣਾ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹੋ: 
PowerShell Runspaces ਦੀ ਸ਼ੁਰੂਆਤੀ ਵਰਤੋਂ: ਭਾਗ 1

ਰਨਸਪੇਸ ਦੀ ਵਰਤੋਂ ਨਾਲ ਕੀ ਮਿਲਦਾ ਹੈ:

• ਚਲਾਈਆਂ ਕਮਾਂਡਾਂ ਦੀ ਸੂਚੀ ਨੂੰ ਸੀਮਿਤ ਕਰਕੇ ਗਤੀ,
• ਕਾਰਜਾਂ ਦਾ ਸਮਾਨਾਂਤਰ ਐਗਜ਼ੀਕਿਊਸ਼ਨ,
• ਸੁਰੱਖਿਆ.

ਇੱਥੇ ਇੰਟਰਨੈੱਟ ਤੋਂ ਇੱਕ ਉਦਾਹਰਨ ਹੈ ਜਦੋਂ Runspace ਮਦਦ ਕਰਦਾ ਹੈ:

"ਸਟੋਰੇਜ ਵਿਵਾਦ vSphere ਵਿੱਚ ਟਰੈਕ ਕਰਨ ਲਈ ਸਭ ਤੋਂ ਔਖੇ ਮੈਟ੍ਰਿਕਸ ਵਿੱਚੋਂ ਇੱਕ ਹੈ। vCenter ਦੇ ਅੰਦਰ, ਤੁਸੀਂ ਸਿਰਫ਼ ਜਾ ਕੇ ਇਹ ਨਹੀਂ ਦੇਖ ਸਕਦੇ ਕਿ ਕਿਹੜਾ VM ਵਧੇਰੇ ਸਟੋਰੇਜ ਸਰੋਤਾਂ ਦੀ ਖਪਤ ਕਰ ਰਿਹਾ ਹੈ। ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, ਤੁਸੀਂ PowerShell ਦਾ ਧੰਨਵਾਦ ਮਿੰਟਾਂ ਵਿੱਚ ਇਸ ਡੇਟਾ ਨੂੰ ਇਕੱਠਾ ਕਰ ਸਕਦੇ ਹੋ।
ਮੈਂ ਇੱਕ ਸਕ੍ਰਿਪਟ ਸਾਂਝੀ ਕਰਾਂਗਾ ਜੋ VMware ਸਿਸਟਮ ਪ੍ਰਸ਼ਾਸਕਾਂ ਨੂੰ vCenter ਵਿੱਚ ਤੇਜ਼ੀ ਨਾਲ ਖੋਜ ਕਰਨ ਅਤੇ ਉਹਨਾਂ ਦੀ ਔਸਤ ਖਪਤ 'ਤੇ ਡੇਟਾ ਦੇ ਨਾਲ VMs ਦੀ ਇੱਕ ਸੂਚੀ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦੇਵੇਗੀ।  
ਸਕਰਿਪਟ ਪਾਵਰਸ਼ੇਲ ਰਨਸਪੇਸ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ ਤਾਂ ਜੋ ਹਰੇਕ ESXi ਹੋਸਟ ਨੂੰ ਇੱਕ ਵੱਖਰੀ ਰਨਸਪੇਸ ਵਿੱਚ ਇਸਦੇ ਆਪਣੇ VMs ਤੋਂ ਖਪਤ ਜਾਣਕਾਰੀ ਇਕੱਠੀ ਕਰਨ ਅਤੇ ਤੁਰੰਤ ਮੁਕੰਮਲ ਹੋਣ ਦੀ ਰਿਪੋਰਟ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੱਤੀ ਜਾ ਸਕੇ। ਇਹ PowerShell ਨੂੰ ਹੋਸਟਾਂ ਦੁਆਰਾ ਦੁਹਰਾਉਣ ਅਤੇ ਹਰ ਇੱਕ ਦੀ ਬੇਨਤੀ ਨੂੰ ਪੂਰਾ ਕਰਨ ਦੀ ਉਡੀਕ ਕਰਨ ਦੀ ਬਜਾਏ, ਨੌਕਰੀਆਂ ਨੂੰ ਤੁਰੰਤ ਬੰਦ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।"

ਸਰੋਤ: ਇੱਕ ESXi ਡੈਸ਼ਬੋਰਡ 'ਤੇ ਵਰਚੁਅਲ ਮਸ਼ੀਨ I/O ਨੂੰ ਕਿਵੇਂ ਦਿਖਾਉਣਾ ਹੈ

ਹੇਠਾਂ ਦਿੱਤੇ ਕੇਸ ਵਿੱਚ, Runspace ਹੁਣ ਉਪਯੋਗੀ ਨਹੀਂ ਹੈ:

“ਮੈਂ ਇੱਕ ਸਕ੍ਰਿਪਟ ਲਿਖਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਿਹਾ ਹਾਂ ਜੋ VM ਤੋਂ ਬਹੁਤ ਸਾਰਾ ਡੇਟਾ ਇਕੱਠਾ ਕਰਦੀ ਹੈ ਅਤੇ ਲੋੜ ਪੈਣ 'ਤੇ ਨਵਾਂ ਡੇਟਾ ਲਿਖਦੀ ਹੈ। ਸਮੱਸਿਆ ਇਹ ਹੈ ਕਿ ਇੱਥੇ ਬਹੁਤ ਸਾਰੇ VM ਹਨ, ਅਤੇ ਇੱਕ ਮਸ਼ੀਨ 'ਤੇ 5-8 ਸਕਿੰਟ ਖਰਚੇ ਜਾਂਦੇ ਹਨ। 

ਸਰੋਤ: RunspacePool ਨਾਲ ਮਲਟੀਥ੍ਰੈਡਿੰਗ PowerCLI

ਇੱਥੇ ਤੁਹਾਨੂੰ Get-View ਦੀ ਲੋੜ ਪਵੇਗੀ, ਆਓ ਇਸ 'ਤੇ ਚੱਲੀਏ। 

ਦੂਜਾ ਪੜਾਅ: ਪ੍ਰਾਪਤ ਕਰੋ

ਇਹ ਸਮਝਣ ਲਈ ਕਿ Get-View ਉਪਯੋਗੀ ਕਿਉਂ ਹੈ, ਇਹ ਯਾਦ ਰੱਖਣ ਯੋਗ ਹੈ ਕਿ ਆਮ ਤੌਰ 'ਤੇ cmdlets ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ। 

API ਸੰਦਰਭ ਕਿਤਾਬਾਂ ਦਾ ਅਧਿਐਨ ਕਰਨ ਅਤੇ ਅਗਲੇ ਪਹੀਏ ਨੂੰ ਮੁੜ ਖੋਜਣ ਦੀ ਲੋੜ ਤੋਂ ਬਿਨਾਂ ਸੁਵਿਧਾਜਨਕ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ Cmdlets ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਪੁਰਾਣੇ ਦਿਨਾਂ ਵਿੱਚ ਕੋਡ ਦੀਆਂ ਸੌ ਜਾਂ ਦੋ ਲਾਈਨਾਂ ਕੀ ਹੁੰਦੀਆਂ ਸਨ, ਪਾਵਰਸ਼ੇਲ ਤੁਹਾਨੂੰ ਇੱਕ ਕਮਾਂਡ ਨਾਲ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਅਸੀਂ ਇਸ ਸਹੂਲਤ ਲਈ ਗਤੀ ਨਾਲ ਭੁਗਤਾਨ ਕਰਦੇ ਹਾਂ। ਆਪਣੇ ਆਪ ਵਿੱਚ cmdlets ਦੇ ਅੰਦਰ ਕੋਈ ਜਾਦੂ ਨਹੀਂ ਹੈ: ਉਹੀ ਸਕ੍ਰਿਪਟ, ਪਰ ਇੱਕ ਹੇਠਲੇ ਪੱਧਰ 'ਤੇ, ਸੰਨੀ ਭਾਰਤ ਦੇ ਇੱਕ ਮਾਸਟਰ ਦੇ ਹੁਨਰਮੰਦ ਹੱਥਾਂ ਦੁਆਰਾ ਲਿਖੀ ਗਈ।

ਹੁਣ, Get-View ਨਾਲ ਤੁਲਨਾ ਕਰਨ ਲਈ, ਆਓ Get-VM cmdlet ਲੈਂਦੇ ਹਾਂ: ਇਹ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਨੂੰ ਐਕਸੈਸ ਕਰਦਾ ਹੈ ਅਤੇ ਇੱਕ ਸੰਯੁਕਤ ਆਬਜੈਕਟ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਅਰਥਾਤ, ਇਹ ਇਸ ਨਾਲ ਹੋਰ ਸਬੰਧਤ ਵਸਤੂਆਂ ਨੂੰ ਜੋੜਦਾ ਹੈ: VMHost, Datastore, ਆਦਿ।  

Get-View ਇਸਦੀ ਥਾਂ 'ਤੇ ਵਾਪਸ ਕੀਤੀ ਵਸਤੂ ਵਿੱਚ ਕੋਈ ਵੀ ਬੇਲੋੜੀ ਨਹੀਂ ਜੋੜਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇਹ ਸਾਨੂੰ ਸਖਤੀ ਨਾਲ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਕਿ ਸਾਨੂੰ ਕਿਹੜੀ ਜਾਣਕਾਰੀ ਦੀ ਲੋੜ ਹੈ, ਜੋ ਆਉਟਪੁੱਟ ਆਬਜੈਕਟ ਨੂੰ ਆਸਾਨ ਬਣਾ ਦੇਵੇਗੀ। ਵਿੰਡੋਜ਼ ਸਰਵਰ ਵਿੱਚ ਆਮ ਤੌਰ 'ਤੇ ਅਤੇ ਹਾਈਪਰ-ਵੀ ਵਿੱਚ ਖਾਸ ਤੌਰ 'ਤੇ, Get-WMIObject cmdlet ਇੱਕ ਸਿੱਧਾ ਐਨਾਲਾਗ ਹੈ - ਵਿਚਾਰ ਬਿਲਕੁਲ ਉਹੀ ਹੈ।

Get-View ਬਿੰਦੂ ਵਸਤੂਆਂ 'ਤੇ ਰੁਟੀਨ ਓਪਰੇਸ਼ਨਾਂ ਲਈ ਅਸੁਵਿਧਾਜਨਕ ਹੈ। ਪਰ ਜਦੋਂ ਇਹ ਹਜ਼ਾਰਾਂ ਅਤੇ ਹਜ਼ਾਰਾਂ ਵਸਤੂਆਂ ਦੀ ਗੱਲ ਆਉਂਦੀ ਹੈ, ਤਾਂ ਇਸਦਾ ਕੋਈ ਮੁੱਲ ਨਹੀਂ ਹੁੰਦਾ.

ਤੁਸੀਂ VMware ਬਲੌਗ 'ਤੇ ਹੋਰ ਪੜ੍ਹ ਸਕਦੇ ਹੋ: Get-View ਨਾਲ ਜਾਣ-ਪਛਾਣ

ਹੁਣ ਮੈਂ ਤੁਹਾਨੂੰ ਅਸਲ ਕੇਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਭ ਕੁਝ ਦਿਖਾਵਾਂਗਾ। 

ਇੱਕ 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 VMs ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਦੇ ਸਮੇਂ। ਇੱਕ ਬੋਨਸ ਫਿਲਟਰਾਂ ਦੀ ਅਣਹੋਂਦ ਅਤੇ ਨਤੀਜਿਆਂ ਨੂੰ ਹੱਥੀਂ ਕ੍ਰਮਬੱਧ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਸਪੱਸ਼ਟ ਹੈ, ਸਕ੍ਰਿਪਟ ਨੂੰ ਅਨੁਕੂਲਨ ਦੀ ਲੋੜ ਹੈ.

ਜਦੋਂ ਤੁਹਾਨੂੰ vCenter ਤੋਂ ਇੱਕੋ ਸਮੇਂ ਹੋਸਟ ਮੈਟ੍ਰਿਕਸ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਜਾਂ ਹਜ਼ਾਰਾਂ ਵਸਤੂਆਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਤਾਂ ਰਨਸਪੇਸ ਬਚਾਅ ਲਈ ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਆਉਂਦੇ ਹਨ। ਆਓ ਦੇਖੀਏ ਕਿ ਇਹ ਪਹੁੰਚ ਕੀ ਲਿਆਉਂਦੀ ਹੈ।

ਪਹਿਲੀ ਸਪੀਡ ਚਾਲੂ ਕਰੋ: PowerShell Runspaces

ਇਸ ਸਕ੍ਰਿਪਟ ਲਈ ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਜੋ ਦਿਮਾਗ ਵਿੱਚ ਆਉਂਦਾ ਹੈ ਉਹ ਹੈ ਲੂਪ ਨੂੰ ਕ੍ਰਮਵਾਰ ਨਹੀਂ, ਪਰ ਸਮਾਨਾਂਤਰ ਥਰਿੱਡਾਂ ਵਿੱਚ, ਸਾਰੇ ਡੇਟਾ ਨੂੰ ਇੱਕ ਵਸਤੂ ਵਿੱਚ ਇਕੱਠਾ ਕਰਨਾ ਅਤੇ ਇਸਨੂੰ ਫਿਲਟਰ ਕਰਨਾ ਹੈ। 

ਪਰ ਇੱਕ ਸਮੱਸਿਆ ਹੈ: PowerCLI ਸਾਨੂੰ 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.

ਇਸ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਪਹਿਲਾਂ ਸਟ੍ਰੀਮ ਦੇ ਅੰਦਰ ਸੈਸ਼ਨ ਜਾਣਕਾਰੀ ਪਾਸ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ। ਸਾਨੂੰ ਯਾਦ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ PowerShell ਉਹਨਾਂ ਵਸਤੂਆਂ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ ਜੋ ਕਿਸੇ ਫੰਕਸ਼ਨ ਜਾਂ ਸਕ੍ਰਿਪਟਬਲਾਕ ਨੂੰ ਪੈਰਾਮੀਟਰ ਦੇ ਤੌਰ 'ਤੇ ਪਾਸ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ। ਚਲੋ $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) ਤੋਂ ਉਹੀ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਾਂ। ਇਹ ਐਕਸਟੈਂਸ਼ਨ ਡੇਟਾ ਆਬਜੈਕਟ ਵਿੱਚ ਚੰਗੀ ਤਰ੍ਹਾਂ ਦੱਬਿਆ ਹੋਇਆ ਹੈ। ਫਿਲਟਰਿੰਗ ਨਾਲ ਲੈਸ, ਅਸੀਂ ਜ਼ਰੂਰੀ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਤੇਜ਼ ਕਰਦੇ ਹਾਂ।

ਹੱਥ ਦੀ ਥੋੜੀ ਜਿਹੀ ਹਿਲਜੁਲ ਨਾਲ ਇਹ ਹੈ:

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-AdvancedOptions ਦੇ ਸਮਾਨ ਹੈ, ਪਰ ਇਹ ਕਈ ਗੁਣਾ ਤੇਜ਼ੀ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ। 

ਹੁਣ Get-VM ਲਈ। ਇਹ ਤੇਜ਼ ਨਹੀਂ ਹੈ ਕਿਉਂਕਿ ਇਹ ਗੁੰਝਲਦਾਰ ਵਸਤੂਆਂ ਨਾਲ ਨਜਿੱਠਦਾ ਹੈ। ਇੱਕ ਤਰਕਪੂਰਨ ਸਵਾਲ ਉੱਠਦਾ ਹੈ: ਸਾਨੂੰ ਇਸ ਮਾਮਲੇ ਵਿੱਚ ਵਾਧੂ ਜਾਣਕਾਰੀ ਅਤੇ ਇੱਕ ਭਿਆਨਕ PSOਬਜੈਕਟ ਦੀ ਕਿਉਂ ਲੋੜ ਹੈ, ਜਦੋਂ ਸਾਨੂੰ ਸਿਰਫ਼ VM ਦੇ ਨਾਮ, ਇਸਦੀ ਸਥਿਤੀ ਅਤੇ ਇੱਕ ਛਲ ਵਿਸ਼ੇਸ਼ਤਾ ਦੇ ਮੁੱਲ ਦੀ ਲੋੜ ਹੈ?  

ਇਸ ਤੋਂ ਇਲਾਵਾ, Get-AdvancedOptions ਦੇ ਰੂਪ ਵਿੱਚ ਰੁਕਾਵਟ ਨੂੰ ਸਕ੍ਰਿਪਟ ਤੋਂ ਹਟਾ ਦਿੱਤਾ ਗਿਆ ਹੈ। ਰਨਸਪੇਸ ਪੂਲ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਹੁਣ ਓਵਰਕਿੱਲ ਵਾਂਗ ਜਾਪਦਾ ਹੈ ਕਿਉਂਕਿ ਸੈਸ਼ਨ ਨੂੰ ਸੌਂਪਣ ਵੇਲੇ ਸਕੁਐਟ ਥਰਿੱਡਾਂ ਵਿੱਚ ਇੱਕ ਹੌਲੀ ਕੰਮ ਨੂੰ ਬਰਾਬਰ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਸੰਦ ਵਧੀਆ ਹੈ, ਪਰ ਇਸ ਕੇਸ ਲਈ ਨਹੀਂ. 

ਆਉ ਐਕਸਟੈਂਸ਼ਨ ਡੇਟਾ ਦੇ ਆਉਟਪੁੱਟ ਨੂੰ ਵੇਖੀਏ: ਇਹ ਇੱਕ Get-View ਆਬਜੈਕਟ ਤੋਂ ਵੱਧ ਕੁਝ ਨਹੀਂ ਹੈ। 

ਆਉ PowerShell ਮਾਸਟਰਾਂ ਦੀ ਪ੍ਰਾਚੀਨ ਤਕਨੀਕ 'ਤੇ ਕਾਲ ਕਰੀਏ: ਫਿਲਟਰ, ਛਾਂਟੀ ਅਤੇ ਗਰੁੱਪਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਲਾਈਨ। ਪਿਛਲੀਆਂ ਸਾਰੀਆਂ ਦਹਿਸ਼ਤਾਂ ਨੂੰ ਸ਼ਾਨਦਾਰ ਢੰਗ ਨਾਲ ਇੱਕ ਲਾਈਨ ਵਿੱਚ ਸਮੇਟਿਆ ਗਿਆ ਹੈ ਅਤੇ ਇੱਕ ਸੈਸ਼ਨ ਵਿੱਚ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ:

$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 ਵਸਤੂਆਂ ਲਈ। ਬਹੁਤ ਵਧੀਆ!

ਸੰਪੂਰਨ ਹੋਣ ਦੇ ਬਜਾਏ

ਇੱਕ ਸਵੀਕਾਰਯੋਗ ਨਤੀਜਾ ਸਿੱਧਾ ਸੰਦ ਦੀ ਚੋਣ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ. ਇਹ ਯਕੀਨੀ ਤੌਰ 'ਤੇ ਕਹਿਣਾ ਅਕਸਰ ਮੁਸ਼ਕਲ ਹੁੰਦਾ ਹੈ ਕਿ ਇਸ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਅਸਲ ਵਿੱਚ ਕੀ ਚੁਣਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਤੇਜ਼ ਕਰਨ ਲਈ ਸੂਚੀਬੱਧ ਢੰਗਾਂ ਵਿੱਚੋਂ ਹਰ ਇੱਕ ਇਸਦੀ ਲਾਗੂ ਹੋਣ ਦੀ ਸੀਮਾ ਦੇ ਅੰਦਰ ਵਧੀਆ ਹੈ। ਮੈਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਇਹ ਲੇਖ ਤੁਹਾਡੇ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਵਿੱਚ ਪ੍ਰਕਿਰਿਆ ਆਟੋਮੇਸ਼ਨ ਅਤੇ ਅਨੁਕੂਲਨ ਦੀਆਂ ਮੂਲ ਗੱਲਾਂ ਨੂੰ ਸਮਝਣ ਦੇ ਮੁਸ਼ਕਲ ਕੰਮ ਵਿੱਚ ਤੁਹਾਡੀ ਮਦਦ ਕਰੇਗਾ।

PS: ਲੇਖ ਨੂੰ ਤਿਆਰ ਕਰਨ ਵਿੱਚ ਮਦਦ ਅਤੇ ਸਹਿਯੋਗ ਲਈ ਲੇਖਕ ਸਾਰੇ ਭਾਈਚਾਰੇ ਦੇ ਮੈਂਬਰਾਂ ਦਾ ਧੰਨਵਾਦ ਕਰਦਾ ਹੈ। ਪੰਜੇ ਵਾਲੇ ਵੀ। ਅਤੇ ਉਹ ਵੀ ਜਿਨ੍ਹਾਂ ਦੀਆਂ ਲੱਤਾਂ ਨਹੀਂ ਹਨ, ਜਿਵੇਂ ਕਿ ਬੋਆ ਕੰਸਟ੍ਰਕਟਰ।

ਸਰੋਤ: www.habr.com