אוטומטיזציה של משימות עם PowerShell PSake: הדרכה מפורטת

מדריכים
PowerShell

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

PSake הוא מנוע אורקסטרציה שנכתב כמודול PowerShell שמוסיף סדר לסקריפטים שלך ומעניק לך שליטה מלאה על מה שרץ מתי ובאילו תנאים. אף על פי ש-PSake הוא כלי אוטומציה לבנייה ושימושו העיקרי הוא בסקריפטי בנייה (שכלל מורץ על ידי שרת בנייה בתרחישי אוטומציה לשחרור), בדרך כלל הוא נתפס לא רק בתרחישי סקריפטים יומיומיים. בואו נשנה את זה.

במדריך הזה, תלמד איך PSake עובד יחד עם דוגמאות נהדרות שתוכל לשים לתרגול היום!

תנאי קדם

מאמר זה יהיה מדריך שידרוש ממך לעקוב. אם ברצונך לעקוב בדיוק כפי שנדון, ודא שיש לך:

  • PowerShell של Windows 3+. המדריך משתמש ב- PowerShell של Windows v5.1
  • קובץ zip של PSake מ- Github. מדריך זה משתמש ב-v4.9.0.

הגדרת המודול של PSake

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

  1. חלץ את קובץ ה-zip של PSake שהורדת מ-GitHub.
  2. העבר את התיקייה src לתוך תוכן הקובץ ZIP שנפתח לנתיב תחת $env:PSModulePath כדי לוודא ש-PowerShell מכיר במודול החדש.
  3. שנה את שם התיקייה src ל-PSake.
  4. כעת הרץ Get-Module PSake -ListAvailable כדי לוודא שהוא מופיע. אם לא קיבלת שגיאה, אתה מוכן להמשך.

קשור: הבנת ובניית מודולים של PowerShell

יצירת סקריפט בסיסי של PowerShell PSake

כדי להבין את PSake, עליך לבנות משהו. בוא נבנה סקריפט פשוט של PSake כדי לראות מה הוא יכול לעשות.

  1. צור סקריפט בשם psakefile.ps1 עם משימה יחידה. לפחות, משימה צריכה לכלול שם ובלוק פעולה. שם ה-psakefile.ps1 אינו חובה, אך זהו השם הברירת מחדל הצפוי על ידי המנוע.

A PSake task in its basic form is very similar to a PowerShell function:
a container for one or more commands that, when performed together, achieve a certain goal. These commands go into a script block that is passed to the Action parameter. A task has many advantages over a function. You will learn about these advantages as you read along.

להלן דוגמה ל-psakefile.ps1 עם משימה פשוטה מסוימת:

task HelloWorld -Action {
    Write-Host '*** Hello World ***' -ForegroundColor Yellow
}

2. עכשיו שבנית את קובץ ה-PSake, אתה יכול לקרוא אותו מקונסולת PowerShell עם הפקודה Invoke-PSake ולהעביר את שם המשימה כערך לפרמטר TaskList .

Invoke-PSake הוא מנוע ההרצה עבור PSake. פקודה זו מפעילה משימות שמוגדרות בקובץ psakefile.ps1. אתה מעביר שם משימה או רשימה של משימות מופרדות בפסיקים לפרמטר TaskList. אם אתה מפעיל מספר משימות, כל משימה תופעל בסדר שעברת עליהן ל- TaskList בלתי תלוי במיקומן ב- psakefile.ps1.

למטה תוכל לראות איך ניתן להפעיל את המשימה HelloWorld:

Invoke-PSake -BuildFile C:\Work\psakefile.ps1 -TaskList 'HelloWorld'

כל עוד אתה שומר על השם psakefile.ps1, ובהנחה שהקונסול הוא בתיקייה בה הקובץ נמצא, אתה יכול לוותר על פרמטר ה- BuildFile ועל הערך שלו.

  1. הרצת Invoke-PSake תציג את פלט PSake בקונסול. כאשר אתה מפעיל את המשימות ב- psakefile.ps1, תראה פלט דומה לזה שאתה רואה למטה.
Psake script output

הפלט כולל את הרכיבים הבאים:

  1. פרטים אודות גרסת PSake.
  2. שם כל משימת בנייה לפני שהיא מתחילה לרוץ (PSake רואה כל משימה כ-בנייה). בדוגמה: מבצע HelloWorld בצבע תכלת.
  3. כל פלט שהמשימה יצרה. בדוגמה: Hello World בצבע צהוב.
  4. הודעת הצלחה/כשלון. בדוגמה: psake הצליחה… בצבע ירוק.
  5. סיכום זמן (בשם דוח זמן בנייה) עם משך כל משימה, כמו גם הזמן הכולל של כל התסריט.

התקנת SQL עם PSake

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

בדוגמה זו, אתה הולך ליצור סקריפט PSake שיבצע את הפעולות הבאות:

  1. מאמת שטח פנוי בכונן במחשב.
  2. מוריד קובץ ZIP של SQL ממחסן מקומי.
  3. מחלץ את קובץ ה-ZIP.
  4. מריץ את ההתקנה על כונן C או D (התלוי בקיומם של שני הכוננים).

בוא נראה כיצד ניתן לנצל את PSake לעבודה זו.

עיצוב חטיבות הבנייה

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

  1. ValidateDiskSpace
  2. DownloadSql
  3. ExtractSql
  4. InstallSqlDriveC
  5. InstallSqlDriveD

בשלב זה, אתה לא באמת בונה את הקוד לביצוע פעולות; אתה פשוט בונה את מבנה המשימות ויוצר את קובץ ה-PSake. תשים לב להפניות ל-Write-Host במשימות למטה; תוסיף למשימות אלו מאוחר יותר.

תמיד כדאי להשתמש בפרמטר Description לכל משימה. הפרמטר Description מספק מידע נוסף על כל משימה הן בזמן ביצוע המשימות והן בעת סקירת הקוד.

task ValidateDiskSpace -Description 'Validate Disk Free Space' -Action {
	
	Write-Host "`n   *** Checking disk free space ***`n" -ForegroundColor Yellow
	
}

task DownloadSql -Description 'Download SQL Setup' -Action {
	
	Write-Host "`n   *** Downloading SQL Setup from LAN ***`n" -ForegroundColor Yellow
	
}

task ExtractSql -Description 'Extract SQL Setup' -Action {
	
	Write-Host "`n   *** Extracting SQL Setup files ***`n" -ForegroundColor Yellow
	
}

task InstallSqlDriveC -Description 'Install SQL on C:' -Action {
	
	Write-Host "`n   *** Installing SQL Server on C drive ... please wait... ***`n" -ForegroundColor Yellow

}

task InstallSqlDriveD -Description 'Install SQL on D:' -Action {
	
	Write-Host "`n   *** Installing SQL Server on D drive ... please wait... ***`n" -ForegroundColor Yellow
	
}

הגדרת סדר ביצוע המשימות

עכשיו יש לך קובץ PSake שמכיל קבוצת משימות. בנקודה זו, תוכל להריץ את כל המשימות פעם אחת או לבחור לבצע רק חלק מהן באמצעות הפקודה Invoke-PSake.

אתה יכול לקרוא לכמה משימות (או לכל המשימות) באמצעות Invoke-PSake ופרמטר ה- TaskList, כמו שעשית בדוגמה הפשוטה לפני כן. אם יש לך יותר ממשימה אחת להפעיל, יש ליצור מערך, ולהגדיר את שם כל משימה כפריט כפי שמוצג למטה.

Invoke-PSake יפעיל כל משימה בסדר המוגדר במערך.

$taskList = @()

$taskList += 'ValidateDiskSpace'
$taskList += 'DownloadSql'
$taskList += 'ExtractSql'
$taskList += 'InstallSqlDriveC'
$taskList += 'InstallSqlDriveD'

Invoke-PSake -TaskList $taskList

כאשר אתה מפעיל את הקוד לעיל, אתה צריך לקבל תוצאה כמו בדוגמה הבאה:

PSake script output

הוספת תנאי קדם

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

באפשרותך להשתמש בפרמטר ה- PreCondition כדי להריץ קטע קוד שמחזיר באמצעותו ערך בוליאני אמת או שקר שמקבע האם המשימה מופעלת או לא.

שים לב בדוגמה למטה למשתני ה- $installSqlOn_C_Drive ו- $installSqlOn_D_Drive. כאשר Invoke-PSake מפעיל את הסקריפט הזה, המשתנים הללו יכילו ערך של אמת או שקר בהתאם אם נפח C או D קיימים.

בכל שורת task, ניתן לראות שכל משימה כוללת פרמטר PreCondition שמכיל את ערך המשתנים הללו. בזמן ריצה, יתבצעו או משימת InstallSqlDriveC או משימת InstallSqlDriveD, בהתאם למשתנים הללו. 

$installSqlOn_C_Drive = (Test-Path -Path 'C:') -and (-not (Test-Path -Path 'D:'))
$installSqlOn_D_Drive = (-not (Test-Path -Path 'C:')) -and (Test-Path -Path 'D:')

task InstallSqlDriveC -Description 'Install SQL on C:' -PreCondition { $installSqlOn_C_Drive } -Action {
	
	Write-Host "`n   *** Installing SQL Server on C drive ... please wait... ***`n" -ForegroundColor Yellow
	
}

task InstallSqlDriveD -Description 'Install SQL on D:' -PreCondition { $installSqlOn_D_Drive } -Action {
	
	Write-Host "`n   *** Installing SQL Server on D drive ... please wait... ***`n" -ForegroundColor Yellow
	
}

פרמטרי המשימה

בנוסף למאפיין Action ו־Description, משימה תומכת גם בפרמטרים אלו:

  • PreCondition – מקטע סקריפט שמחזיר ערך בוליאני. על פי הערך השקר, המשימה הספציפית תדיל. (דוגמת שימוש מוצגת למעלה).
  • PostCondition – שלב אימות. מקטע סקריפט שמחזיר ערך בוליאני. שקר מהווה כישלון באימות שיגרום לסקריפט כולו להפסיק.
  • PreAction – מקטע סקריפט להרצתו לפני המשימה.
  • PostAction – מקטע סקריפט להרצתו ישירות לאחר שהמשימה הושלמה בהצלחה.
  • ContinueOnError – פרמטר מתג. בשימוש, שגיאות שעשויות להתרחש במהלך הרצת המשימה לא יגרמו להפסקת הסקריפט כולו.
  • Depends – שם של משימה (או רשימת שמות משימות) שחייבת להרוץ לפני ביצוע המשימה הנוכחית. PSake תשתמש במידע זה כדי לבצע את תלותי המשימות בסדר הנכון. לדוגמה, אם משימה A תלויה במשימה B, אז מנוע PSake יריץ את B לפני A.

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

בואו נראה דוגמה לשימוש למשימה עם חלק מהפרמטרים הללו:

הוספת פעולה קדם ותנאי סיום השהיה

בשימוש במשימת InstallSqlDriveD מהדוגמה למעלה כנקודת התחלה, אולי יש לך בקשה נוספת להתקנה.

אולי עליך לרשום את הזמנים בהם מתחילה ומסתיימת ההתקנה. עליך לרשום את הזמנים הללו לשני משתני סביבת העבודה בשמות SqlSetupStartDate ו־SqlSetupEndDate. שנית, לאחר שההתקנה מסתיימת, עליך לוודא שתיקיית D:\TempSqlFiles לא קיימת.

ממש נס משימת PSake פרמטרים PreAction, PostAction ו־PostCondition (בהתאמה) עונים בדיוק על דרישות אלו. להלן דוגמה לכיצד ניתן לעשות זאת:

task InstallSqlDriveD -Description 'Install SQL on D:' -PreAction {

     Write-Host '*** Writing SQL install start time to env. var. SqlSetupStartDate ***' -ForegroundColor Yellow
     $date = Get-Date -Format 'yyyy-MM-dd HH:mm:ss'
[Environment]::SetEnvironmentVariable('SqlSetupStartDate',$date,'Machine')

 } -PreCondition { 

     $installSqlOn_D_Drive

 } -Action {  
  
     Write-Host '*** Installing SQL Server on D drive... please wait... ***' -ForegroundColor Yellow 

} -PostAction {     

    Write-Host '*** Writing SQL install end time to env. var. SqlSetupEndDate ***' -ForegroundColor Yellow     
    $date = Get-Date -Format 'yyyy-MM-dd HH:mm:ss'
[Environment]::SetEnvironmentVariable('SqlSetupEndDate',$date,'Machine') 

} -PostCondition { 
    
Write-Host '*** Verifying temp files deleted ***' -ForegroundColor Yellow
     # במקרה שהתיקייה קיימת זה יחזיר שקר, מה שיגרום לתסריט כולו להפסיק
     (-not (Test-Path -Path 'D:\TempSqlFiles'))

 }

הרצת תסריטי PSake במבחני Pester

בכל מקום שתוכל להפעיל תסריט PowerShell, תוכל להפעיל קובץ PSake. אם אתה בונה מבחני תשתיות עם Pester, תוכל להפעיל את PSake בתוך הבדיקות.

דומה: כתיבת בדיקות Pester עבור PowerShell

לדוגמה, אולי יש לך בדיקת Pester כדי לאמת שהקובץ ZIP להתקנת ה־SQL קיים בתיקייה לאחר שאתה מריץ את המשימה DownloadSql. במקרה כזה, תבנה בדיקת Pester פשוטה ותפעיל את המשימה DownloadSql בתוך הבדיקה ותבדוק את הקובץ ZIP ישירות לאחר הרצתה.

Describe 'SQL install with PSake' {

    It 'Downloads Sql files' {

        $setup = 'C:\Downloads\SqlSetup.zip'

        if(Test-Path -Path $setup)
        {
            Remove-Item -Path $setup
        }

        # המשימה היחידה שנבדקת כאן היא DownloadSql
        Invoke-PSake -BuildFile C:\Work\psakefile.ps1 -TaskList DownloadSql
        
        $setup | Should -Exist
    }
}

עברת פרמטרים למשימות

ברגע שאתה מתחיל להשתמש ב-PSake ייתכן שתרצה להפרמטריז חלק מהמשימות. לרוב, עם פונקציות ותסריטים של PowerShell, תעביר פרמטרים שונים בשם לפונקציה/תסריט; PSake הוא שונה.

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

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

לדוגמה, כדי להעביר משתנים דינמיים כמו SqlYear ו-SqlVersion לכל משימה בקובץ PSake, תוכל להגדיר אותם כך כפי שמוצג למטה.

Properties {
    $SqlYear = '2017'
    $SqlVersion = '14.0'
}

task -Name DownloadSql -Action {
    
    Write-Host "SQL version to install: SQL $SqlYear (version $SqlVersion)"

}

כאשר אתה מפעיל לאחר מכן את קובץ ה-PSake עם Invoke-PSake, תראה את הפלט הבא. שים לב שהמשתנים $SqlYear ו-$SqlVersion נפרטו עם הערכים שהוגדרו בבלוק ה-נכסים.

psake version 4.9.1
Copyright (c) 2010-2018 James Kovacs & Contributors

Executing DownloadSql
SQL version to install: SQL 2017 (version 14.0)

psake succeeded executing C:\Work\PSakefile.ps1

--------------------------------------------------
Build Time Report
--------------------------------------------------

Name        Duration
----        --------
DownloadSql 00:00:00
------      --------
Total:      00:00:00

שימוש בפרמטר נכסים

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

כדי לעשות זאת, הגדר טבלה עם כל זוג קי/ערך שברצונך לדרוס. לאחר מכן, העבר את הטבלה לפרמטר Properties. מנוע PSake ישתמש בערכים בטבלה שהועברה על פני אלה שצוינו בבלוק ה-Properties בתסריט psakefile.ps1.

שים לב להבדלים בתחביר בין בלוק ה-Properties ובין הפרמטר Properties. בבלוק ה-Properties כל שורה היא משתנה ולכן מתחילה בסימן דולר, בעוד שהפרמטר Properties הוא טבלה כך שכל פריט הוא מפתח, ונכתב בלי דולר מוביל. עוד הבדל הוא שהטבלה מוקדמת בתו @.

מטה תראה דוגמה לשימוש בפרמטר Properties.

$myNewProperties = @{
    SqlYear = '2019'
    SqlVersion = '15.0'
}

Invoke-PSake -TaskList DownloadSql -Properties $myNewProperties

מודולריות משימות PSake: משימות כקבצים

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

קשור: איך לשרוד במהלך ריפקטורינג של סקריפט PowerShell מגיהנום

בדוגמה של המדריך הזה, עבדת עם חמישה משימות:

  • ValidateDiskSpace
  • DownloadSql
  • ExtractSql
  • InstallSqlDriveC
  • InstallSqlDriveD

כל אחת מהמשימות הללו מוגדרת בתוך קובץ ה־pssakefile.ps1. אם אתה מצפה להוסיף עוד משימות בעתיד, כדאי לך לפצל אותן לקבצים נפרדים, כאשר כל משימה נמצאת בקובץ נפרד, לדוגמה ValidateDiskSpace.ps1, DownloadSql.ps1, InstallSqlDriveD.ps1, InstallSqlDriveD.ps1, וכו'

. לדוגמה, InstallSqlDriveD.ps1 יכיל רק את הקוד הזה:

task InstallSqlDriveD -Description 'Install SQL on D:' -PreCondition { $installSqlOn_D_Drive } -Action {
	
	Write-Host "`n   *** Installing SQL Server on D drive ... please wait... ***`n" -ForegroundColor Yellow
	
}

. פעם שהמשימות נועדו מהקובץ, יש לייבא את הקבצים לתוך pssakefile.ps1 באמצעות הפונקציה Include. לאחר זאת, תוכן הקובץ pssakefile.ps1 יופחת לקוד כזה:

$installSqlOn_C_Drive = $true
$installSqlOn_D_Drive = $false

Include "$PSScriptRoot\ValidateDiskSpace.ps1"
Include "$PSScriptRoot\DownloadSql.ps1"
Include "$PSScriptRoot\ExtractSql.ps1"
Include "$PSScriptRoot\InstallSqlOnC.ps1"
Include "$PSScriptRoot\InstallSqlOnD.ps1"

כאשר Invoke-PSake מפעיל את קובץ ה־pssakefile.ps1, Invoke-PSake אינו יודע או מתעניין אם המשימות נמצאות בתוך קובץ ה־psake או שנייבאו באמצעות השיטה של Include.

שלבים הבאים

PSake הוא תסריט מתוזמן חזק שניתן להשתמש בו למגוון מטרות: בניית תוכנה, CI/CD, התקנת חבילות, יצירת מתקינים, ועוד. הגבול היחיד הוא הדמיון שלך. ההתמקדות בבניית סקריפטים גדולים עם PSake מכריחה אותך לחשוב במונחי משימות (יחידות בנייה של קוד). הקונספט של משימות משתמש בתחביר PowerShell, ובאמצעותן אתה מעשיר את הידע שלך בקווים המנחים הקיימים.

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

היכן אתה רואה את השימוש ב־PSake בפרויקטי העבודה שלך?

Source:
https://adamtheautomator.com/powershell-psake/