PowerCLI స్క్రిప్ట్‌ల కోసం రాకెట్ బూస్టర్‌ను ఎలా నిర్మించాలి 

త్వరలో లేదా తరువాత, ఏదైనా VMware సిస్టమ్ నిర్వాహకుడు సాధారణ పనులను ఆటోమేట్ చేయడానికి వస్తారు. ఇదంతా కమాండ్ లైన్‌తో ప్రారంభమవుతుంది, ఆపై పవర్‌షెల్ లేదా VMware PowerCLI వస్తుంది.

మీరు ISEని ప్రారంభించడం మరియు "ఒక రకమైన మాయాజాలం" కారణంగా పనిచేసే మాడ్యూల్స్ నుండి ప్రామాణిక cmdletలను ఉపయోగించడం కంటే పవర్‌షెల్‌లో కొంచెం ఎక్కువ ప్రావీణ్యం సంపాదించారని అనుకుందాం. మీరు వందల సంఖ్యలో వర్చువల్ మెషీన్‌లను లెక్కించడం ప్రారంభించినప్పుడు, చిన్న స్థాయిలో సహాయపడే స్క్రిప్ట్‌లు పెద్ద స్కేల్‌లో గమనించదగినంత నెమ్మదిగా నడుస్తున్నట్లు మీరు కనుగొంటారు. 

ఈ పరిస్థితిలో, 2 సాధనాలు సహాయపడతాయి:

• పవర్‌షెల్ రన్‌స్పేసెస్ - ప్రత్యేక థ్రెడ్‌లలో ప్రక్రియల అమలును సమాంతరంగా చేయడానికి మిమ్మల్ని అనుమతించే విధానం; 
• పొందండి-వీక్షణ – ప్రాథమిక PowerCLI ఫంక్షన్, Windowsలో Get-WMIObject యొక్క అనలాగ్. ఈ cmdlet ఎంటిటీలతో కూడిన వస్తువులను లాగదు, కానీ సాధారణ డేటా రకాలతో ఒక సాధారణ వస్తువు రూపంలో సమాచారాన్ని అందుకుంటుంది. చాలా సందర్భాలలో, ఇది వేగంగా బయటకు వస్తుంది.

తరువాత, నేను ప్రతి సాధనం గురించి క్లుప్తంగా మాట్లాడతాను మరియు ఉపయోగం యొక్క ఉదాహరణలను చూపుతాను. నిర్దిష్ట స్క్రిప్ట్‌లను విశ్లేషిద్దాం మరియు ఒకటి మరొకదాని కంటే మెరుగ్గా ఎప్పుడు పని చేస్తుందో చూద్దాం. వెళ్ళండి!

మొదటి దశ: రన్‌స్పేస్

కాబట్టి, ప్రధాన మాడ్యూల్ వెలుపల టాస్క్‌ల సమాంతర ప్రాసెసింగ్ కోసం రన్‌స్పేస్ రూపొందించబడింది. వాస్తవానికి, మీరు కొంత మెమరీ, ప్రాసెసర్ మొదలైనవాటిని నాశనం చేసే మరొక ప్రక్రియను ప్రారంభించవచ్చు. మీ స్క్రిప్ట్ కొన్ని నిమిషాల్లో రన్ అయి గిగాబైట్ మెమరీని వినియోగిస్తే, మీకు రన్‌స్పేస్ అవసరం ఉండదు. కానీ పదివేల వస్తువులకు స్క్రిప్ట్‌ల కోసం ఇది అవసరం.

మీరు ఇక్కడ నేర్చుకోవడం ప్రారంభించవచ్చు: 
పవర్‌షెల్ రన్‌స్పేస్‌ల ప్రారంభ వినియోగం: పార్ట్ 1

రన్‌స్పేస్ ఉపయోగించడం ఏమి ఇస్తుంది:

• అమలు చేయబడిన ఆదేశాల జాబితాను పరిమితం చేయడం ద్వారా వేగం,
• విధులను సమాంతరంగా అమలు చేయడం,
• భద్రత.

రన్‌స్పేస్ సహాయం చేసినప్పుడు ఇంటర్నెట్ నుండి ఒక ఉదాహరణ ఇక్కడ ఉంది:

“నిల్వ వివాదం vSphereలో ట్రాక్ చేయడానికి కష్టతరమైన మెట్రిక్‌లలో ఒకటి. vCenter లోపల, మీరు వెళ్లి ఏ VM ఎక్కువ నిల్వ వనరులను వినియోగిస్తుందో చూడలేరు. అదృష్టవశాత్తూ, మీరు PowerShellకి ధన్యవాదాలు నిమిషాల్లో ఈ డేటాను సేకరించవచ్చు.
VMware సిస్టమ్ నిర్వాహకులు త్వరగా vCenter అంతటా శోధించడానికి మరియు వారి సగటు వినియోగంపై డేటాతో VMల జాబితాను స్వీకరించడానికి అనుమతించే స్క్రిప్ట్‌ను నేను భాగస్వామ్యం చేస్తాను.  
స్క్రిప్ట్ పవర్‌షెల్ రన్‌స్పేస్‌లను ఉపయోగిస్తుంది, ప్రతి ESXi హోస్ట్ దాని స్వంత VMల నుండి వినియోగ సమాచారాన్ని విడిగా రన్‌స్పేస్‌లో సేకరించి వెంటనే పూర్తయినట్లు నివేదించడానికి అనుమతిస్తుంది. ఇది పవర్‌షెల్‌ని హోస్ట్‌ల ద్వారా పునరావృతం చేయకుండా మరియు ప్రతి దాని అభ్యర్థనను పూర్తి చేయడానికి వేచి ఉండకుండా వెంటనే ఉద్యోగాలను మూసివేయడానికి అనుమతిస్తుంది.

మూలం: ESXi డాష్‌బోర్డ్‌లో వర్చువల్ మెషిన్ I/Oని ఎలా చూపించాలి

దిగువ సందర్భంలో, Runspace ఇకపై ఉపయోగపడదు:

“నేను VM నుండి చాలా డేటాను సేకరించి అవసరమైనప్పుడు కొత్త డేటాను వ్రాసే స్క్రిప్ట్‌ను వ్రాయడానికి ప్రయత్నిస్తున్నాను. సమస్య ఏమిటంటే చాలా VMలు ఉన్నాయి మరియు ఒక మెషీన్‌లో 5-8 సెకన్లు ఖర్చు చేస్తారు. 

మూలం: రన్‌స్పేస్‌పూల్‌తో మల్టీథ్రెడింగ్ PowerCLI

ఇక్కడ మీకు గెట్-వ్యూ అవసరం, దానికి వెళ్దాం. 

రెండవ దశ: గెట్-వ్యూ

Get-View ఎందుకు ఉపయోగకరంగా ఉందో అర్థం చేసుకోవడానికి, cmdlets సాధారణంగా ఎలా పని చేస్తాయో గుర్తుంచుకోవడం విలువ. 

API రిఫరెన్స్ పుస్తకాలను అధ్యయనం చేయకుండా మరియు తదుపరి చక్రాన్ని తిరిగి ఆవిష్కరించాల్సిన అవసరం లేకుండా సౌకర్యవంతంగా సమాచారాన్ని పొందేందుకు Cmdlets అవసరం. పాత రోజుల్లో వంద లేదా రెండు లైన్ల కోడ్ తీసుకున్నది, పవర్‌షెల్ మిమ్మల్ని ఒక ఆదేశంతో చేయడానికి అనుమతిస్తుంది. మేము ఈ సౌలభ్యం కోసం వేగంతో చెల్లిస్తాము. cmdlets లోపల ఎటువంటి మ్యాజిక్ లేదు: అదే స్క్రిప్ట్, కానీ తక్కువ స్థాయిలో, ఎండ భారతదేశానికి చెందిన మాస్టర్ యొక్క నైపుణ్యం గల చేతులతో వ్రాయబడింది.

ఇప్పుడు, Get-Viewతో పోల్చడం కోసం, Get-VM cmdletని తీసుకుందాం: ఇది వర్చువల్ మెషీన్‌ను యాక్సెస్ చేస్తుంది మరియు మిశ్రమ వస్తువును తిరిగి ఇస్తుంది, అంటే, దానికి సంబంధించిన ఇతర వస్తువులను జతచేస్తుంది: VMHost, Datastore, మొదలైనవి.  

దాని స్థానంలో గెట్-వ్యూ తిరిగి వచ్చిన వస్తువుకు అనవసరమైన వాటిని జోడించదు. అంతేకాకుండా, ఇది మనకు అవసరమైన సమాచారాన్ని ఖచ్చితంగా పేర్కొనడానికి అనుమతిస్తుంది, ఇది అవుట్పుట్ వస్తువును సులభతరం చేస్తుంది. సాధారణంగా విండోస్ సర్వర్‌లో మరియు ముఖ్యంగా హైపర్-విలో, Get-WMIObject cmdlet ప్రత్యక్ష అనలాగ్ - ఆలోచన సరిగ్గా అదే.

పాయింట్ ఆబ్జెక్ట్‌లపై సాధారణ కార్యకలాపాలకు గెట్-వ్యూ అసౌకర్యంగా ఉంటుంది. అయితే వేల, పదుల వస్తువుల విషయానికి వస్తే దానికి ధర లేదు.

మీరు VMware బ్లాగ్‌లో మరింత చదవవచ్చు: గెట్-వ్యూకు పరిచయం

ఇప్పుడు నేను నిజమైన కేసును ఉపయోగించి ప్రతిదీ మీకు చూపిస్తాను. 

VMని అన్‌లోడ్ చేయడానికి స్క్రిప్ట్ రాయడం

ఒకరోజు నా సహోద్యోగి తన స్క్రిప్ట్‌ని ఆప్టిమైజ్ చేయమని అడిగాడు. విధి సాధారణ దినచర్య: అన్ని VMలను డూప్లికేట్ cloud.uuid పరామితితో కనుగొనండి (అవును, 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 నుండి హోస్ట్ మెట్రిక్‌లను పొందవలసి వచ్చినప్పుడు లేదా పదివేల ఆబ్జెక్ట్‌లను ప్రాసెస్ చేయవలసి వచ్చినప్పుడు రన్‌స్పేస్‌లు మొదట సహాయానికి వస్తాయి. ఈ విధానం ఏమి తెస్తుందో చూద్దాం.

మొదటి వేగాన్ని ఆన్ చేయండి: పవర్‌షెల్ రన్‌స్పేసెస్

ఈ స్క్రిప్ట్‌కు గుర్తుకు వచ్చే మొదటి విషయం ఏమిటంటే, లూప్‌ను వరుసగా కాకుండా, సమాంతర థ్రెడ్‌లలో అమలు చేయడం, మొత్తం డేటాను ఒక వస్తువుగా సేకరించి ఫిల్టర్ చేయడం. 

కానీ ఒక సమస్య ఉంది: 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.

దీన్ని పరిష్కరించడానికి, మీరు ముందుగా స్ట్రీమ్‌లో సెషన్ సమాచారాన్ని తప్పనిసరిగా పాస్ చేయాలి. పవర్‌షెల్ ఒక ఫంక్షన్‌కి లేదా స్క్రిప్ట్‌బ్లాక్‌కి పారామీటర్‌గా పంపబడే వస్తువులతో పనిచేస్తుందని గుర్తుంచుకోండి. $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 రూపంలో ఉన్న అడ్డంకి స్క్రిప్ట్ నుండి తొలగించబడింది. సెషన్‌ను అప్పగించేటప్పుడు స్క్వాట్ థ్రెడ్‌లలో స్లో టాస్క్‌ను సమాంతరంగా చేయాల్సిన అవసరం లేనందున రన్‌స్పేస్ పూల్స్‌ని ఉపయోగించడం ఇప్పుడు ఓవర్‌కిల్ లాగా కనిపిస్తోంది. సాధనం మంచిది, కానీ ఈ సందర్భంలో కాదు. 

ఎక్స్‌టెన్షన్‌డేటా యొక్క అవుట్‌పుట్‌ని చూద్దాం: ఇది గెట్-వ్యూ ఆబ్జెక్ట్ తప్ప మరేమీ కాదు. 

పవర్‌షెల్ మాస్టర్స్ యొక్క పురాతన సాంకేతికతను పిలుద్దాం: ఫిల్టర్‌లను ఉపయోగించి ఒక లైన్, సార్టింగ్ మరియు గ్రూపింగ్. మునుపటి భీభత్సం అంతా సొగసైన ఒక లైన్‌లో కుదించబడింది మరియు ఒక సెషన్‌లో అమలు చేయబడుతుంది:

$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

మేము సమయాన్ని కొలుస్తాము:

20 సెకన్లు దాదాపు 10k ఆబ్జెక్ట్‌లకు కావలసిన కండిషన్ ద్వారా ఫిల్టరింగ్ ఉంటుంది. గొప్ప!

ముగింపుకు బదులుగా

ఆమోదయోగ్యమైన ఫలితం నేరుగా సాధనం ఎంపికపై ఆధారపడి ఉంటుంది. దీన్ని సాధించడానికి సరిగ్గా ఏమి ఎంచుకోవాలి అని ఖచ్చితంగా చెప్పడం చాలా కష్టం. స్క్రిప్ట్‌లను వేగవంతం చేయడానికి జాబితా చేయబడిన ప్రతి పద్ధతులు దాని వర్తించే పరిమితుల్లో మంచివి. మీ ఇన్‌ఫ్రాస్ట్రక్చర్‌లో ప్రాసెస్ ఆటోమేషన్ మరియు ఆప్టిమైజేషన్ యొక్క ప్రాథమికాలను అర్థం చేసుకోవడంలో కష్టమైన పనిలో ఈ కథనం మీకు సహాయపడుతుందని నేను ఆశిస్తున్నాను.

PS: కథనాన్ని సిద్ధం చేయడంలో వారి సహాయం మరియు మద్దతు కోసం రచయిత సంఘం సభ్యులందరికీ ధన్యవాదాలు. పాదాలు ఉన్నవారు కూడా. మరియు కాళ్ళు లేని వారు కూడా బోవా కన్‌స్ట్రిక్టర్ లాగా ఉంటారు.

మూలం: www.habr.com