របៀបបង្កើតឧបករណ៍ជំរុញគ្រាប់រ៉ុក្កែតសម្រាប់ស្គ្រីប PowerCLI 

មិនយូរមិនឆាប់ អ្នកគ្រប់គ្រងប្រព័ន្ធ VMware ណាមួយមកធ្វើកិច្ចការធម្មតាដោយស្វ័យប្រវត្តិ។ វាទាំងអស់ចាប់ផ្តើមដោយបន្ទាត់ពាក្យបញ្ជា បន្ទាប់មកមក PowerShell ឬ VMware PowerCLI ។

ចូរនិយាយថាអ្នកបានស្ទាត់ជំនាញ PowerShell បន្តិចជាងការបើកដំណើរការ ISE និងប្រើ cmdlets ស្តង់ដារពីម៉ូឌុលដែលដំណើរការដោយសារតែ "ប្រភេទនៃវេទមន្ត" ។ នៅពេលអ្នកចាប់ផ្តើមរាប់ម៉ាស៊ីននិម្មិតក្នុងចំនួនរាប់រយ អ្នកនឹងឃើញថាស្គ្រីបដែលជួយក្នុងកម្រិតតូចមួយដំណើរការយឺតគួរឱ្យកត់សម្គាល់នៅលើខ្នាតធំ។ 

ក្នុងស្ថានភាពនេះ ឧបករណ៍ចំនួន ២ នឹងជួយ៖

• PowerShell Runspaces - វិធីសាស្រ្តដែលអនុញ្ញាតឱ្យអ្នកធ្វើស្របគ្នានៃការប្រតិបត្តិនៃដំណើរការនៅក្នុងខ្សែស្រឡាយដាច់ដោយឡែក; 
• ទទួលបាន-មើល - មុខងារ PowerCLI មូលដ្ឋានដែលជា analogue នៃ Get-WMIObject នៅក្នុង Windows ។ cmdlet នេះ​មិន​ទាញ​វត្ថុ​ដែល​អម​ជាមួយ​អង្គភាព​ទេ ប៉ុន្តែ​ទទួល​ព័ត៌មាន​ក្នុង​ទម្រង់​ជា​វត្ថុ​សាមញ្ញ​ដែល​មាន​ប្រភេទ​ទិន្នន័យ​សាមញ្ញ។ ក្នុងករណីជាច្រើនវាចេញមកលឿនជាង។

បន្ទាប់ ខ្ញុំនឹងនិយាយដោយសង្ខេបអំពីឧបករណ៍នីមួយៗ និងបង្ហាញឧទាហរណ៍នៃការប្រើប្រាស់។ ចូរយើងវិភាគស្គ្រីបជាក់លាក់ ហើយមើលថាតើពេលណាមួយដំណើរការល្អជាងមួយទៀត។ ទៅ!

ដំណាក់កាលដំបូង៖ កន្លែងរត់

ដូច្នេះ Runspace ត្រូវបានរចនាឡើងសម្រាប់ដំណើរការប៉ារ៉ាឡែលនៃភារកិច្ចនៅខាងក្រៅម៉ូឌុលមេ។ ជាការពិតណាស់ អ្នកអាចចាប់ផ្តើមដំណើរការមួយផ្សេងទៀតដែលនឹងស៊ីអង្គចងចាំមួយចំនួន ខួរក្បាលជាដើម។ ប្រសិនបើស្គ្រីបរបស់អ្នកដំណើរការក្នុងរយៈពេលពីរបីនាទី ហើយប្រើប្រាស់អង្គចងចាំមួយជីហ្គាបៃ ភាគច្រើនទំនងជាអ្នកនឹងមិនត្រូវការ Runspace ទេ។ ប៉ុន្តែសម្រាប់ស្គ្រីបសម្រាប់វត្ថុរាប់ម៉ឺនគឺត្រូវការ។

អ្នកអាចចាប់ផ្តើមរៀននៅទីនេះ៖ 
ការចាប់ផ្តើមប្រើប្រាស់ PowerShell Runspaces៖ ផ្នែកទី 1

តើការប្រើប្រាស់ Runspace ផ្តល់អ្វីខ្លះ៖

• ល្បឿនដោយកំណត់បញ្ជីពាក្យបញ្ជាដែលបានប្រតិបត្តិ,
• ការអនុវត្តភារកិច្ចស្របគ្នា,
• សុវត្ថិភាព។

នេះគឺជាឧទាហរណ៍ពីអ៊ីនធឺណិតនៅពេលដែល Runspace ជួយ៖

"ការឈ្លោះប្រកែកគ្នានៃទំហំផ្ទុកគឺជារង្វាស់ដ៏លំបាកបំផុតមួយក្នុងការតាមដាននៅក្នុង vSphere ។ នៅខាងក្នុង vCenter អ្នកមិនត្រឹមតែអាចចូលទៅមើលថា VM មួយណាកំពុងប្រើប្រាស់ធនធានផ្ទុកបន្ថែមនោះទេ។ ជាសំណាងល្អ អ្នកអាចប្រមូលទិន្នន័យនេះក្នុងរយៈពេលប៉ុន្មាននាទី ដោយសារ PowerShell ។
ខ្ញុំនឹងចែករំលែកស្គ្រីបដែលនឹងអនុញ្ញាតឱ្យអ្នកគ្រប់គ្រងប្រព័ន្ធ VMware ស្វែងរកយ៉ាងលឿនទូទាំង vCenter និងទទួលបានបញ្ជី VM ជាមួយនឹងទិន្នន័យលើការប្រើប្រាស់ជាមធ្យមរបស់ពួកគេ។  
ស្គ្រីបប្រើ PowerShell runspaces ដើម្បីអនុញ្ញាតឱ្យម៉ាស៊ីន ESXi នីមួយៗប្រមូលព័ត៌មានអំពីការប្រើប្រាស់ពី VMs ផ្ទាល់របស់វានៅក្នុង Runspace ដាច់ដោយឡែក ហើយរាយការណ៍ពីការបញ្ចប់ភ្លាមៗ។ នេះអនុញ្ញាតឱ្យ PowerShell បិទការងារភ្លាមៗ ជាជាងធ្វើម្តងទៀតតាមរយៈម៉ាស៊ីន និងរង់ចាំឱ្យពួកគេបំពេញសំណើរបស់ខ្លួន។"

ប្រភព: របៀបបង្ហាញម៉ាស៊ីននិម្មិត I/O នៅលើផ្ទាំងគ្រប់គ្រង ESXi

ក្នុងករណីខាងក្រោម Runspace លែងមានប្រយោជន៍ទៀតហើយ៖

“ខ្ញុំកំពុងព្យាយាមសរសេរស្គ្រីបដែលប្រមូលទិន្នន័យជាច្រើនពី VM ហើយសរសេរទិន្នន័យថ្មីនៅពេលចាំបាច់។ បញ្ហាគឺថាមាន VM ច្រើនណាស់ ហើយ 5-8 វិនាទីត្រូវចំណាយលើម៉ាស៊ីនតែមួយ។ 

ប្រភព: Multithreading PowerCLI ជាមួយ RunspacePool

នៅទីនេះអ្នកនឹងត្រូវការ Get-View តោះបន្តទៅវា។ 

ដំណាក់កាលទីពីរ៖ ទទួលបានទិដ្ឋភាព

ដើម្បីយល់ពីមូលហេតុដែល Get-View មានប្រយោជន៍ វាត្រូវចងចាំពីរបៀបដែល cmdlets ដំណើរការជាទូទៅ។ 

Cmdlets ត្រូវការជាចាំបាច់ ដើម្បីទទួលបានព័ត៌មានយ៉ាងងាយស្រួល ដោយមិនចាំបាច់សិក្សាសៀវភៅយោង API និងបង្កើតកង់បន្ទាប់ឡើងវិញ។ អ្វី​ដែល​នៅ​សម័យ​ដើម​យក​កូដ​មួយ​រយ ឬ​ពីរ​បន្ទាត់ PowerShell អនុញ្ញាត​ឱ្យ​អ្នក​ធ្វើ​ដោយ​ពាក្យ​បញ្ជា​មួយ។ យើងបង់ប្រាក់សម្រាប់ភាពងាយស្រួលនេះជាមួយនឹងល្បឿន។ មិនមានវេទមន្តនៅខាងក្នុង cmdlets ខ្លួនឯងទេ: អក្សរដូចគ្នាប៉ុន្តែនៅកម្រិតទាបដែលសរសេរដោយដៃដ៏ប៉ិនប្រសប់របស់មេមកពីប្រទេសឥណ្ឌាដែលមានពន្លឺថ្ងៃ។

ឥឡូវនេះ សម្រាប់ការប្រៀបធៀបជាមួយ Get-View សូមយក Get-VM cmdlet៖ វាចូលប្រើម៉ាស៊ីននិម្មិត ហើយត្រឡប់វត្ថុផ្សំ ពោលគឺវាភ្ជាប់វត្ថុដែលពាក់ព័ន្ធផ្សេងទៀតទៅវា៖ VMHost, Datastore ជាដើម។  

Get-View នៅក្នុងកន្លែងរបស់វាមិនបន្ថែមអ្វីដែលមិនចាំបាច់ទៅវត្ថុដែលបានត្រឡប់មកវិញនោះទេ។ លើសពីនេះទៅទៀត វាអនុញ្ញាតឱ្យយើងបញ្ជាក់យ៉ាងតឹងរ៉ឹងនូវព័ត៌មានដែលយើងត្រូវការ ដែលនឹងធ្វើឱ្យវត្ថុទិន្នផលមានភាពងាយស្រួល។ នៅក្នុង Windows Server ជាទូទៅ និងនៅក្នុង Hyper-V ជាពិសេស Get-WMIObject cmdlet គឺជា analogue ផ្ទាល់ - គំនិតគឺដូចគ្នាបេះបិទ។

Get-View មានការរអាក់រអួលសម្រាប់ប្រតិបត្តិការជាប្រចាំលើវត្ថុចំណុច។ ប៉ុន្តែ​បើ​និយាយ​ដល់​វត្ថុ​រាប់​ពាន់​រាប់​ម៉ឺន​នោះ​មិន​មាន​តម្លៃ​ទេ។

អ្នកអាចអានបន្ថែមនៅលើប្លក់ VMware៖ ការណែនាំអំពី Get-View

ឥឡូវនេះខ្ញុំនឹងបង្ហាញអ្នកនូវអ្វីគ្រប់យ៉ាងដោយប្រើករណីពិត។ 

សរសេរស្គ្រីបដើម្បីដក VM

ថ្ងៃមួយ មិត្តរួមការងាររបស់ខ្ញុំបានសុំឱ្យខ្ញុំបង្កើនប្រសិទ្ធភាពស្គ្រីបរបស់គាត់។ ភារកិច្ចគឺជាទម្លាប់ទូទៅ៖ ស្វែងរក VM ទាំងអស់ដែលមានប៉ារ៉ាម៉ែត្រ cloud.uuid ស្ទួន (បាទ វាអាចទៅរួចនៅពេលក្លូន VM នៅក្នុង vCloud Director)។ 

ដំណោះស្រាយជាក់ស្តែងដែលត្រូវគិតគឺ៖

1. ទទួលបានបញ្ជីនៃ VMs ទាំងអស់។
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
}
# Далее РУКАМИ парсим полученный результат

អ្វីគ្រប់យ៉ាងគឺសាមញ្ញបំផុតនិងច្បាស់លាស់។ វាអាចត្រូវបានសរសេរក្នុងរយៈពេលពីរបីនាទីជាមួយនឹងការសម្រាកកាហ្វេ។ វីសលើការច្រោះហើយវារួចរាល់។

ប៉ុន្តែយើងវាស់ពេលវេលា៖

៤ នាទី ៣០ វិនាទី នៅពេលដំណើរការស្ទើរតែ 10k VMs ។ ប្រាក់រង្វាន់គឺអវត្តមាននៃតម្រង និងតម្រូវការដើម្បីតម្រៀបលទ្ធផលដោយដៃ។ ជាក់ស្តែង ស្គ្រីបទាមទារឱ្យមានការបង្កើនប្រសិទ្ធភាព។

Runspaces គឺជាកម្មវិធីដំបូងគេដែលមកជួយសង្គ្រោះ នៅពេលដែលអ្នកត្រូវការទទួលបាន host metrics ពី 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 ដំណើរការជាមួយវត្ថុដែលអាចត្រូវបានបញ្ជូនជាប៉ារ៉ាម៉ែត្រទាំងទៅមុខងារមួយឬទៅ ScriptBlock ។ តោះឆ្លងកាត់វគ្គក្នុងទម្រង់នៃវត្ថុបែបនេះ ដោយឆ្លងកាត់ $global:DefaultVIServers (Connect-VIServer ជាមួយ-NotDefault key)៖

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

ឥឡូវនេះ ចូរយើងអនុវត្ត multithreading តាមរយៈ Runspace Pools។  

ក្បួនដោះស្រាយមានដូចខាងក្រោម៖

1. យើងទទួលបានបញ្ជី VMs ទាំងអស់។
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
}

ភាពស្រស់ស្អាតនៃស្គ្រីបនេះគឺថាវាអាចត្រូវបានប្រើនៅក្នុងករណីស្រដៀងគ្នាផ្សេងទៀតដោយគ្រាន់តែជំនួស ScriptBlock និងប៉ារ៉ាម៉ែត្រដែលនឹងត្រូវបានបញ្ជូនទៅស្ទ្រីម។ កេងចំណេញ!

យើងវាស់ពេលវេលា៖

៧២០០០ វិនាទី។ វាប្រសើរជាង ប៉ុន្តែវានៅតែអាចលឿនជាងមុន។ 

ចូរផ្លាស់ទីទៅល្បឿនទីពីរ: 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-AdvancedOptions ដែរ ប៉ុន្តែវាដំណើរការលឿនជាងមុនច្រើនដង។ 

ឥឡូវនេះដើម្បី Get-VM ។ វាមិនលឿនទេព្រោះវាដោះស្រាយជាមួយវត្ថុស្មុគស្មាញ។ សំណួរឡូជីខលកើតឡើង៖ ហេតុអ្វីបានជាយើងត្រូវការព័ត៌មានបន្ថែម និង PSObject ដ៏មហិមាមួយនៅក្នុងករណីនេះ នៅពេលដែលយើងគ្រាន់តែត្រូវការឈ្មោះ VM ស្ថានភាពរបស់វា និងតម្លៃនៃគុណលក្ខណៈល្បិច?  

លើសពីនេះ ឧបសគ្គក្នុងទម្រង់ Get-AdvancedOptions ត្រូវបានដកចេញពីស្គ្រីប។ ការប្រើប្រាស់ Runspace Pools ឥឡូវនេះ ហាក់បីដូចជាជ្រុលហួសហេតុ ព្រោះវាលែងមានតំរូវការក្នុងការប្រៀបធៀបកិច្ចការយឺត ៗ ឆ្លងកាត់ខ្សែស្រលាយនៅពេលប្រគល់វគ្គមួយ។ ឧបករណ៍គឺល្អប៉ុន្តែមិនមែនសម្រាប់ករណីនេះទេ។ 

សូមក្រឡេកមើលលទ្ធផលនៃ ExtensionData៖ វាគ្មានអ្វីក្រៅពី Get-View object នោះទេ។ 

ចូរ​ហៅ​បច្ចេកទេស​បុរាណ​របស់​ចៅហ្វាយនាយ 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: អ្នកនិពន្ធសូមអរគុណសមាជិកសហគមន៍ទាំងអស់សម្រាប់ជំនួយ និងការគាំទ្ររបស់ពួកគេក្នុងការរៀបចំអត្ថបទ។ សូម្បីតែអ្នកដែលមានក្រញាំ។ ហើយសូម្បីតែអ្នកដែលមិនមានជើងដូចជា boa constrictor ។

ប្រភព: www.habr.com