כיצד לבנות מאיץ רקטה עבור סקריפטים של PowerCLI 

במוקדם או במאוחר, כל מנהל מערכת של VMware בא לבצע אוטומציה של משימות שגרתיות. הכל מתחיל בשורת הפקודה, ואז מגיע PowerShell או VMware PowerCLI.

נניח שליטת ב-PowerShell קצת יותר רחוק מהשקת ISE ושימוש ב-cmdlets סטנדרטיים ממודולים שעובדים בגלל "סוג של קסם". כאשר תתחילו לספור מכונות וירטואליות במאות, תגלו שסקריפטים שעוזרים בקנה מידה קטן פועלים לאט יותר בקנה מידה גדול. 

במצב זה, 2 כלים יעזרו:

• PowerShell Runspaces - גישה המאפשרת להקביל את ביצוע תהליכים בשרשורים נפרדים; 
• Get-View – פונקציית PowerCLI בסיסית, אנלוגי של Get-WMIObject ב-Windows. cmdlet זה אינו מושך אובייקטים הנלווים לישויות, אלא מקבל מידע בצורה של אובייקט פשוט עם סוגי נתונים פשוטים. במקרים רבים זה יוצא מהר יותר.

לאחר מכן, אדבר בקצרה על כל כלי ואראה דוגמאות לשימוש. בואו ננתח סקריפטים ספציפיים ונראה מתי אחד עובד טוב יותר מהשני. ללכת!

שלב ראשון: Runspace

אז, Runspace מיועד לעיבוד מקביל של משימות מחוץ למודול הראשי. כמובן, אתה יכול להפעיל תהליך אחר שיאכל קצת זיכרון, מעבד וכו'. אם הסקריפט שלך פועל תוך מספר דקות וצורך גיגה-בייט של זיכרון, סביר להניח שלא תזדקק ל-Runspace. אבל עבור סקריפטים לעשרות אלפי אובייקטים יש צורך בכך.

אתה יכול להתחיל ללמוד כאן: 
תחילת השימוש ב-PowerShell Runspaces: חלק 1

מה השימוש ב-Runspace נותן:

• מהירות על ידי הגבלת רשימת הפקודות המבוצעות,
• ביצוע מקביל של משימות,
• בְּטִיחוּת.

הנה דוגמה מהאינטרנט כאשר Runspace עוזר:

"מחלוקת אחסון היא אחד המדדים הקשים ביותר למעקב ב-vSphere. בתוך vCenter, אתה לא יכול פשוט ללכת ולראות איזה VM צורך יותר משאבי אחסון. למרבה המזל, אתה יכול לאסוף את הנתונים האלה תוך דקות הודות ל- PowerShell.
אני אחלוק סקריפט שיאפשר למנהלי מערכת VMware לחפש במהירות ברחבי vCenter ולקבל רשימה של VMs עם נתונים על הצריכה הממוצעת שלהם.  
הסקריפט משתמש במרחבי ריצה של PowerShell כדי לאפשר לכל מארח ESXi לאסוף מידע צריכה ממכשירי ה-VM שלו ב-Runspace נפרד ולדווח באופן מיידי על סיום. זה מאפשר ל-PowerShell לסגור עבודות באופן מיידי, במקום לעבור דרך מארחים ולחכות שכל אחד ישלים את בקשתו."

מקור: כיצד להציג I/O של מחשב וירטואלי בלוח מחוונים של ESXi

במקרה שלהלן, Runspace כבר לא שימושי:

"אני מנסה לכתוב סקריפט שאוסף הרבה נתונים מ-VM וכותב נתונים חדשים כשצריך. הבעיה היא שיש די הרבה מכשירי VM ו-5-8 שניות מושקעות במכונה אחת". 

מקור: Multithreading PowerCLI עם RunspacePool

כאן תצטרך Get-View, בואו נעבור לזה. 

שלב שני: Get-View

כדי להבין מדוע Get-View שימושי, כדאי לזכור כיצד עובדות cmdlets באופן כללי. 

יש צורך ב-Cmdlets כדי להשיג מידע בצורה נוחה ללא צורך בלימוד ספרי עזר של API ולהמציא מחדש את הגלגל הבא. מה שבימים עברו לקח מאה או שתיים שורות קוד, PowerShell מאפשר לך לעשות בפקודה אחת. אנחנו משלמים על הנוחות הזו במהירות. אין קסם בתוך ה-cmdlets עצמם: אותו תסריט, אבל ברמה נמוכה יותר, שנכתב בידיו המיומנות של מאסטר מהודו שטופת השמש.

כעת, לשם השוואה ל-Get-View, ניקח את ה-cmdlet Get-VM: הוא ניגש למכונה הווירטואלית ומחזיר אובייקט מורכב, כלומר, הוא מצרף אליו אובייקטים קשורים אחרים: VMHost, Datastore וכו'.  

Get-View במקומו אינו מוסיף שום דבר מיותר לאובייקט המוחזר. יתר על כן, זה מאפשר לנו לציין בקפדנות איזה מידע אנחנו צריכים, מה שיקל על אובייקט הפלט. ב-Windows Server בכלל וב-Hyper-V בפרט, ה-cmdlet Get-WMIObject הוא אנלוגי ישיר - הרעיון זהה לחלוטין.

Get-View אינו נוח עבור פעולות שגרתיות על אובייקטים נקודתיים. אבל כשמדובר באלפי ועשרות אלפי חפצים, אין לזה מחיר.

אתה יכול לקרוא עוד בבלוג VMware: מבוא ל-Get-View

עכשיו אני אראה לך הכל באמצעות מקרה אמיתי. 

כתיבת סקריפט לפריקת VM

יום אחד עמית שלי ביקש ממני לבצע אופטימיזציה של התסריט שלו. המשימה היא שגרה נפוצה: מצא את כל ה-VMs עם פרמטר 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
}
# Далее РУКАМИ парсим полученный результат

הכל פשוט וברור במיוחד. אפשר לכתוב את זה תוך כמה דקות עם הפסקת קפה. הברג את הסינון וזה נגמר.

אבל בואו נמדוד את הזמן:

2 דקות 47 שניות כאשר מעבדים כמעט 10 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 עובד עם אובייקטים שניתן להעביר כפרמטר לפונקציה או ל-ScriptBlock. בואו נעביר את ההפעלה בצורה של אובייקט כזה, תוך עקיפת $global:DefaultVIServers (התחבר-VIServer עם מפתח -NotDefault):

$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. אנו מקבלים רשימה של כל ה-VMs.
2. בזרמים מקבילים אנחנו מקבלים cloud.uuid.
3. אנו אוספים נתונים מזרמים לאובייקט אחד.
4. אנו מסננים את האובייקט על ידי קיבוץ אותו לפי הערך של שדה CloudUUID: אלה שבהם מספר הערכים הייחודיים גדול מ-1 הם ה-VMs שאנו מחפשים.

כתוצאה מכך, אנו מקבלים את התסריט:

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 והפרמטרים שיועברו לזרם. נצל את זה!

אנו מודדים זמן:

55 שניות. זה טוב יותר, אבל זה עדיין יכול להיות מהיר יותר. 

בואו נעבור למהירות השנייה: GetView

בואו לגלות מה לא בסדר.
בראש ובראשונה, ה-cmdlet Get-VM לוקח הרבה זמן לביצוע.
שנית, ה-cmdlet Get-AdvancedOptions לוקח עוד יותר זמן.
בוא נתמודד קודם כל עם השני. 

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. 

בואו נתקשר לטכניקה העתיקה של מאסטרי 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