PowerCLI സ്ക്രിപ്റ്റുകൾക്കായി ഒരു റോക്കറ്റ് ബൂസ്റ്റർ എങ്ങനെ നിർമ്മിക്കാം 

താമസിയാതെ അല്ലെങ്കിൽ പിന്നീട്, ഏതെങ്കിലും വിഎംവെയർ സിസ്റ്റം അഡ്മിനിസ്ട്രേറ്റർ പതിവ് ജോലികൾ ഓട്ടോമേറ്റ് ചെയ്യാൻ വരുന്നു. ഇതെല്ലാം കമാൻഡ് ലൈനിൽ ആരംഭിക്കുന്നു, തുടർന്ന് PowerShell അല്ലെങ്കിൽ VMware PowerCLI വരുന്നു.

ഐ‌എസ്‌ഇ സമാരംഭിക്കുന്നതിനേക്കാളും "ചില മാജിക്" കാരണം പ്രവർത്തിക്കുന്ന മൊഡ്യൂളുകളിൽ നിന്നുള്ള സ്റ്റാൻഡേർഡ് cmdlets ഉപയോഗിക്കുന്നതിനേക്കാളും കുറച്ചുകൂടി മുന്നോട്ട് നിങ്ങൾ PowerShell മാസ്റ്റേഴ്സ് ചെയ്തുവെന്ന് പറയാം. നിങ്ങൾ നൂറുകണക്കിന് വെർച്വൽ മെഷീനുകൾ എണ്ണാൻ തുടങ്ങുമ്പോൾ, ചെറിയ സ്കെയിലിൽ സഹായിക്കുന്ന സ്ക്രിപ്റ്റുകൾ വലിയ തോതിൽ വളരെ സാവധാനത്തിൽ പ്രവർത്തിക്കുന്നത് നിങ്ങൾ കണ്ടെത്തും. 

ഈ സാഹചര്യത്തിൽ, 2 ഉപകരണങ്ങൾ സഹായിക്കും:

• പവർഷെൽ റൺസ്‌പേസുകൾ - പ്രത്യേക ത്രെഡുകളിൽ പ്രക്രിയകളുടെ നിർവ്വഹണം സമാന്തരമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു സമീപനം; 
• ഗെറ്റ്-വ്യൂ – ഒരു അടിസ്ഥാന PowerCLI ഫംഗ്‌ഷൻ, Windows-ലെ Get-WMIObject-ന്റെ അനലോഗ്. ഈ cmdlet എന്റിറ്റികളോടൊപ്പമുള്ള ഒബ്‌ജക്‌റ്റുകളെ വലിക്കുന്നില്ല, എന്നാൽ ലളിതമായ ഡാറ്റ തരങ്ങളുള്ള ഒരു ലളിതമായ ഒബ്‌ജക്റ്റിന്റെ രൂപത്തിൽ വിവരങ്ങൾ സ്വീകരിക്കുന്നു. പല കേസുകളിലും അത് വേഗത്തിൽ പുറത്തുവരുന്നു.

അടുത്തതായി, ഓരോ ഉപകരണത്തെക്കുറിച്ചും ഞാൻ ചുരുക്കമായി സംസാരിക്കുകയും ഉപയോഗത്തിന്റെ ഉദാഹരണങ്ങൾ കാണിക്കുകയും ചെയ്യും. നിർദ്ദിഷ്ട സ്ക്രിപ്റ്റുകൾ വിശകലനം ചെയ്ത് ഒന്ന് മറ്റൊന്നിനേക്കാൾ നന്നായി പ്രവർത്തിക്കുമ്പോൾ നോക്കാം. പോകൂ!

ആദ്യ ഘട്ടം: റൺസ്പെയ്സ്

അതിനാൽ, പ്രധാന മൊഡ്യൂളിന് പുറത്തുള്ള ടാസ്‌ക്കുകളുടെ സമാന്തര പ്രോസസ്സിംഗിനായി റൺസ്‌പെയ്‌സ് രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു. തീർച്ചയായും, കുറച്ച് മെമ്മറി, പ്രോസസർ മുതലായവ ഇല്ലാതാക്കുന്ന മറ്റൊരു പ്രക്രിയ നിങ്ങൾക്ക് സമാരംഭിക്കാം. നിങ്ങളുടെ സ്ക്രിപ്റ്റ് രണ്ട് മിനിറ്റിനുള്ളിൽ പ്രവർത്തിക്കുകയും ഒരു ജിഗാബൈറ്റ് മെമ്മറി ഉപയോഗിക്കുകയും ചെയ്താൽ, മിക്കവാറും നിങ്ങൾക്ക് Runspace ആവശ്യമില്ല. എന്നാൽ പതിനായിരക്കണക്കിന് വസ്തുക്കൾക്കുള്ള സ്ക്രിപ്റ്റുകൾക്ക് അത് ആവശ്യമാണ്.

നിങ്ങൾക്ക് ഇവിടെ പഠിക്കാൻ തുടങ്ങാം: 
പവർഷെൽ റൺസ്‌പേസുകളുടെ പ്രാരംഭ ഉപയോഗം: ഭാഗം 1

Runspace ഉപയോഗിക്കുന്നത് എന്താണ് നൽകുന്നത്:

• എക്സിക്യൂട്ട് ചെയ്ത കമാൻഡുകളുടെ ലിസ്റ്റ് പരിമിതപ്പെടുത്തി വേഗത,
• ചുമതലകളുടെ സമാന്തര നിർവ്വഹണം,
• സുരക്ഷ.

Runspace സഹായിക്കുമ്പോൾ ഇന്റർനെറ്റിൽ നിന്നുള്ള ഒരു ഉദാഹരണം ഇതാ:

"സംഭരണ ​​തർക്കമാണ് vSphere-ൽ ട്രാക്ക് ചെയ്യാൻ ഏറ്റവും പ്രയാസമുള്ള മെട്രിക്കുകളിലൊന്ന്. vCenter-നുള്ളിൽ, ഏത് VM ആണ് കൂടുതൽ സ്റ്റോറേജ് ഉറവിടങ്ങൾ ഉപയോഗിക്കുന്നതെന്ന് നിങ്ങൾക്ക് പോയി കാണാനാകില്ല. ഭാഗ്യവശാൽ, PowerShell-ന് നന്ദി മിനിറ്റുകൾക്കുള്ളിൽ നിങ്ങൾക്ക് ഈ ഡാറ്റ ശേഖരിക്കാനാകും.
VMware സിസ്റ്റം അഡ്‌മിനിസ്‌ട്രേറ്റർമാരെ vCenter-ൽ ഉടനീളം വേഗത്തിൽ തിരയാനും അവരുടെ ശരാശരി ഉപഭോഗത്തിന്റെ ഡാറ്റയുള്ള VM-കളുടെ ഒരു ലിസ്റ്റ് സ്വീകരിക്കാനും അനുവദിക്കുന്ന ഒരു സ്‌ക്രിപ്റ്റ് ഞാൻ പങ്കിടും.  
ഓരോ ESXi ഹോസ്റ്റിനെയും സ്വന്തം VM-കളിൽ നിന്ന് ഒരു പ്രത്യേക റൺസ്‌പെയ്‌സിൽ നിന്ന് ഉപഭോഗ വിവരങ്ങൾ ശേഖരിക്കാനും ഉടൻ പൂർത്തിയാക്കിയതായി റിപ്പോർട്ട് ചെയ്യാനും സ്‌ക്രിപ്റ്റ് PowerShell റൺസ്‌പേസുകൾ ഉപയോഗിക്കുന്നു. ഹോസ്റ്റുകളിലൂടെ ആവർത്തിച്ച് ഓരോരുത്തർക്കും അതിന്റെ അഭ്യർത്ഥന പൂർത്തീകരിക്കുന്നതിനായി കാത്തിരിക്കുന്നതിനുപകരം, ജോലികൾ ഉടനടി അവസാനിപ്പിക്കാൻ ഇത് PowerShell-നെ അനുവദിക്കുന്നു.

അവലംബം: ഒരു ESXi ഡാഷ്‌ബോർഡിൽ വെർച്വൽ മെഷീൻ I/O എങ്ങനെ കാണിക്കാം

ചുവടെയുള്ള സാഹചര്യത്തിൽ, Runspace മേലിൽ ഉപയോഗപ്രദമല്ല:

“ഒരു വിഎമ്മിൽ നിന്ന് ധാരാളം ഡാറ്റ ശേഖരിക്കുകയും ആവശ്യമുള്ളപ്പോൾ പുതിയ ഡാറ്റ എഴുതുകയും ചെയ്യുന്ന ഒരു സ്ക്രിപ്റ്റ് എഴുതാൻ ഞാൻ ശ്രമിക്കുന്നു. ധാരാളം വിഎമ്മുകൾ ഉണ്ട് എന്നതാണ് പ്രശ്നം, ഒരു മെഷീനിൽ 5-8 സെക്കൻഡ് ചെലവഴിക്കുന്നു. 

അവലംബം: RunspacePool ഉള്ള മൾട്ടിത്രെഡിംഗ് PowerCLI

ഇവിടെ നിങ്ങൾക്ക് ഗെറ്റ്-വ്യൂ ആവശ്യമാണ്, നമുക്ക് അതിലേക്ക് പോകാം. 

രണ്ടാം ഘട്ടം: ഗെറ്റ്-വ്യൂ

Get-View ഉപയോഗപ്രദമാകുന്നത് എന്തുകൊണ്ടാണെന്ന് മനസിലാക്കാൻ, cmdlets പൊതുവായി എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് ഓർമ്മിക്കുന്നത് മൂല്യവത്താണ്. 

API റഫറൻസ് ബുക്കുകൾ പഠിക്കാതെയും അടുത്ത ചക്രം പുനർനിർമ്മിക്കാതെയും സൗകര്യപൂർവ്വം വിവരങ്ങൾ നേടുന്നതിന് Cmdlets ആവശ്യമാണ്. പഴയ കാലത്ത് നൂറോ രണ്ടോ വരി കോഡ് എടുത്തത്, ഒരു കമാൻഡ് ഉപയോഗിച്ച് ചെയ്യാൻ PowerShell നിങ്ങളെ അനുവദിക്കുന്നു. ഈ സൗകര്യത്തിനായി ഞങ്ങൾ വേഗത്തിൽ പണം നൽകുന്നു. cmdlets ഉള്ളിൽ തന്നെ മാന്ത്രികതയില്ല: അതേ സ്ക്രിപ്റ്റ്, എന്നാൽ താഴ്ന്ന തലത്തിൽ, സണ്ണി ഇന്ത്യയിൽ നിന്നുള്ള ഒരു മാസ്റ്ററുടെ നൈപുണ്യമുള്ള കൈകളാൽ എഴുതിയിരിക്കുന്നു.

ഇപ്പോൾ, Get-View-മായി താരതമ്യപ്പെടുത്തുന്നതിന്, നമുക്ക് Get-VM cmdlet എടുക്കാം: ഇത് വെർച്വൽ മെഷീനിലേക്ക് പ്രവേശിക്കുകയും ഒരു സംയോജിത ഒബ്‌ജക്റ്റ് തിരികെ നൽകുകയും ചെയ്യുന്നു, അതായത്, അത് മറ്റ് അനുബന്ധ ഒബ്‌ജക്റ്റുകൾ അതിലേക്ക് അറ്റാച്ചുചെയ്യുന്നു: VMHost, Datastore, മുതലായവ.  

തിരിച്ചുകിട്ടിയ ഒബ്‌ജക്‌റ്റിൽ അനാവശ്യമായി ഒന്നും ചേർക്കുന്നില്ല അതിന്റെ സ്ഥാനത്ത് Get-View. മാത്രമല്ല, നമുക്ക് ആവശ്യമുള്ള വിവരങ്ങൾ കർശനമായി വ്യക്തമാക്കാൻ ഇത് അനുവദിക്കുന്നു, അത് ഔട്ട്പുട്ട് ഒബ്ജക്റ്റ് എളുപ്പമാക്കും. വിൻഡോസ് സെർവറിൽ പൊതുവെയും ഹൈപ്പർ-വിയിൽ പ്രത്യേകിച്ചും, Get-WMIObject cmdlet ഒരു നേരിട്ടുള്ള അനലോഗ് ആണ് - ആശയം സമാനമാണ്.

പോയിന്റ് ഒബ്‌ജക്‌റ്റുകളിലെ പതിവ് പ്രവർത്തനങ്ങൾക്ക് ഗെറ്റ്-വ്യൂ അസൗകര്യമാണ്. എന്നാൽ ആയിരക്കണക്കിന്, പതിനായിരക്കണക്കിന് വസ്തുക്കളുടെ കാര്യം വരുമ്പോൾ അതിന് വിലയില്ല.

നിങ്ങൾക്ക് VMware ബ്ലോഗിൽ കൂടുതൽ വായിക്കാം: ഗെറ്റ്-വ്യൂവിനുള്ള ആമുഖം

ഇപ്പോൾ ഞാൻ ഒരു യഥാർത്ഥ കേസ് ഉപയോഗിച്ച് എല്ലാം കാണിക്കും. 

ഒരു വിഎം അൺലോഡ് ചെയ്യാൻ ഒരു സ്ക്രിപ്റ്റ് എഴുതുന്നു

ഒരു ദിവസം എന്റെ സഹപ്രവർത്തകൻ എന്നോട് അവന്റെ സ്ക്രിപ്റ്റ് ഒപ്റ്റിമൈസ് ചെയ്യാൻ ആവശ്യപ്പെട്ടു. ടാസ്‌ക്ക് ഒരു സാധാരണ ദിനചര്യയാണ്: ഡ്യൂപ്ലിക്കേറ്റ് 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-ൽ നിന്ന് ഒരേസമയം ഹോസ്റ്റ് മെട്രിക്‌സ് ലഭിക്കുമ്പോഴോ പതിനായിരക്കണക്കിന് ഒബ്‌ജക്‌റ്റുകൾ പ്രോസസ്സ് ചെയ്യേണ്ടിവരുമ്പോഴോ ആദ്യം രക്ഷാപ്രവർത്തനത്തിനെത്തുന്നത് റൺസ്‌പേസുകളാണ്. ഈ സമീപനം എന്താണ് കൊണ്ടുവരുന്നതെന്ന് നോക്കാം.

ആദ്യ വേഗത ഓണാക്കുക: PowerShell Runspaces

ഈ സ്ക്രിപ്റ്റിനായി ആദ്യം മനസ്സിൽ വരുന്നത് ലൂപ്പ് തുടർച്ചയായി നടപ്പിലാക്കുകയല്ല, സമാന്തര ത്രെഡുകളിൽ, എല്ലാ ഡാറ്റയും ഒരു ഒബ്ജക്റ്റിലേക്ക് ശേഖരിച്ച് ഫിൽട്ടർ ചെയ്യുക എന്നതാണ്. 

എന്നാൽ ഒരു പ്രശ്‌നമുണ്ട്: vCenter-ലേക്ക് നിരവധി സ്വതന്ത്ര സെഷനുകൾ തുറക്കാൻ PowerCLI ഞങ്ങളെ അനുവദിക്കില്ല കൂടാതെ ഒരു തമാശ പിശക് വരുത്തുകയും ചെയ്യും:

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 $_
           }
       }
   }

ഇനി നമുക്ക് Runspace Pools വഴി മൾട്ടിത്രെഡിംഗ് നടപ്പിലാക്കാം.  

അൽഗോരിതം ഇപ്രകാരമാണ്:

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 വ്യക്തിഗത വിഎം ഒബ്‌ജക്റ്റുകൾക്ക് സൗകര്യപ്രദമാണ്, എന്നാൽ നിരവധി ഒബ്‌ജക്‌റ്റുകൾക്കൊപ്പം പ്രവർത്തിക്കുമ്പോൾ വളരെ വിചിത്രമാണ്. വെർച്വൽ മെഷീൻ ഒബ്‌ജക്റ്റിൽ നിന്ന് തന്നെ (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-AdvancedOptions പോലെയാണ്, എന്നാൽ ഇത് പല മടങ്ങ് വേഗത്തിൽ പ്രവർത്തിക്കുന്നു. 

ഇപ്പോൾ Get-VM-ലേക്ക്. സങ്കീർണ്ണമായ വസ്തുക്കളുമായി ഇടപെടുന്നതിനാൽ ഇത് വേഗതയുള്ളതല്ല. ഒരു യുക്തിസഹമായ ചോദ്യം ഉയർന്നുവരുന്നു: ഞങ്ങൾക്ക് VM-ന്റെ പേരും അതിന്റെ അവസ്ഥയും ഒരു തന്ത്രപരമായ ആട്രിബ്യൂട്ടിന്റെ മൂല്യവും ആവശ്യമുള്ളപ്പോൾ, ഈ സാഹചര്യത്തിൽ ഞങ്ങൾക്ക് അധിക വിവരങ്ങളും ഒരു ഭീകരമായ PSObject ഉം ആവശ്യമായിരിക്കുന്നത് എന്തുകൊണ്ട്?  

കൂടാതെ, Get-AdvancedOptions എന്ന രൂപത്തിലുള്ള തടസ്സം സ്‌ക്രിപ്റ്റിൽ നിന്ന് നീക്കം ചെയ്‌തു. ഒരു സെഷൻ കൈമാറുമ്പോൾ സ്ക്വാറ്റ് ത്രെഡുകളിലുടനീളം സ്ലോ ടാസ്‌ക് സമാന്തരമാക്കേണ്ട ആവശ്യമില്ലാത്തതിനാൽ Runspace Pools ഉപയോഗിക്കുന്നത് ഇപ്പോൾ ഓവർകിൽ പോലെ തോന്നുന്നു. ഉപകരണം നല്ലതാണ്, പക്ഷേ ഈ കേസിൽ അല്ല. 

എക്സ്റ്റൻഷൻഡാറ്റയുടെ ഔട്ട്പുട്ട് നോക്കാം: ഇത് ഒരു ഗെറ്റ്-വ്യൂ ഒബ്ജക്റ്റ് അല്ലാതെ മറ്റൊന്നുമല്ല. 

പവർഷെൽ മാസ്റ്റേഴ്സിന്റെ പുരാതന സാങ്കേതികതയെക്കുറിച്ച് നമുക്ക് വിളിക്കാം: ഫിൽട്ടറുകൾ ഉപയോഗിച്ച് ഒരു വരി, തരംതിരിക്കുക, ഗ്രൂപ്പുചെയ്യുക. മുമ്പത്തെ എല്ലാ ഭയാനകങ്ങളും മനോഹരമായി ഒരു വരിയിലേക്ക് ചുരുക്കി ഒരു സെഷനിൽ നടപ്പിലാക്കുന്നു:

$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