נתיב מודול PowerShell: קוד שניתן לשוב עליו בלי להעתיק

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

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

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

A module is a collection of functions in a text file with a psm1 extension. There are some optional additions, such as a module manifest and comment-based or external help that may also be included. These will be covered later on.

דרישות מוקדמות

I’ll be using Windows PowerShell 5.1 in this article. If you’re using an older version or PowerShell Core, your mileage may vary as to results you see.

התקשורת עם מודולים

כשאתה פותח הפעם הראשונה את ההפעלה של PowerShell, תתחיל עם שני מודולים. הראשון הוא Microsoft.PowerShell.Utility המכיל פונקציות בסיסיות רבות שאתה כבר משתמש בהן. המודול השני הוא PSReadline. תוכל לראות את המודולים האלו התחלתיים באמצעות הפקודה Get-Module.

אמנם, זה אינו רשימה מלאה של כל המודולים הזמינים. מאז PowerShell 3, מודולים שמותקנים ייובאו כפי שנדרש. אם אתה מפעיל גרסה ישנה יותר של PowerShell, תצטרך להשתמש בפקודה Import-Module כדי לייבא את המודול לפני שתשתמש באחת מהפקודות.

ישנם רגעים בהם עדיין תרצה להשתמש ב- Import-Module גם בגרסאות מאוחרות יותר. אם תרצה לייבא מודול לאחר שהוא כבר מותקן, תוכל להשתמש ב- Import-Module כמו כן:

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

לא כל הפקודות מוצגות כברירת מחדל

המאפיין ExportedCommands מכיל רשימה של כל הפקודות הזמינות שמיוצאות מהמודול. תוכל לראות כמה הבדלים בין הרשימה הזו למה שבקובץ המודול. פקודות שמיוצאות היא תכונה שנבנתה בתוך המניפסט של המודול שמאפשרת לכותב להשאיר פונקציה כמוסתרת. כותבי מודול יכולים גם להשתמש בפקודה Export-ModuleMember אך זה מחוץ לטווח של מאמר זה.

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

ייבוא מודולים

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

ייבוא פקודות באופן בחירתי

ניתן להשתמש בפקודת Import-Module כדי לייבא פונקציות מסוימות במקום לייבא את כל המודול באמצעות הפרמטר Function. זה יכול לחסוך זמן בעת ייבוא מודולים ממערכות מרוחקות, כמו מודולי Office 365.

מודולים לכל המשתמשים

המודולים המותקנים לכל המשתמשים מונחים בתיקיית C:\Program Files\WindowsPowerShell\Modules. התיקייה כוללת מודולים מוגדרים מראש רבים וכן מודולים שמותקנים באמצעות הפקודה Install-Module בתחום ברירת המחדל AllUsers.

מודולים למשתמש נוכחי

אם אתה מתקין מודול אך רוצה שרק משתמש יחיד יוכל להשתמש בו, יש תחום CurrentUser. זה מציב את קבצי המודול בתיקיית המסמכים שלך בנתיב C:\Users\<username>\Documents\WindowsPowerShell\Modules. זה יכול להיות שימושי בסביבה שבה אתה משתמש בהפניה לתיקיית המסמכים.

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

מודולים מערכתיים

למלוא השלמות, קיימת גם תיקיית מודולים ב-C:\Windows\System32\WindowsPowerShell\1.0\Modules. מבחינה טכנית, מודול שמונח בנתיב זה ייובא כמו אחד מהנתיבים האחרים, אך זה אינו מומלץ מאחר והוא שמור למודולים המערכתיים של מיקרוסופט.

השם חשוב

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

באמצעות Get-Module -ListAvailable שציינו מראש, מתייחסים לנתיבים אלה. ניתן לראות את כל נתיבי המודול באמצעות $env:PSModulePath -Split ';'. עשויים להופיע נתיבים נוספים ברשימה מאשר מה שמוצג כאן. רבים מהתוכניות מוסיפות את נתיבי המודולים שלהם בעת התקנתן. אחד הדוגמאות לכך היא SQL, שכוללת מודולים משלה בנתיבי המודולים המיועדים לה.

קיימים גם מודולים שתכניתם שונה להתקנה. אחת הדוגמאות המשמעותיות ביותר לכך היא תוכנית המודול ActiveDirectory. מ- Windows 7 עד Windows 10 1803, הייתה ניתן להתקין אותו בעזרת המתקין של כלי ניהול שרתים רחוקים (RSAT).

בגרסאות חדשות יותר של Windows 10 (1809+), הוא זמין רק דרך תכונות על פי דרישה. התקנת RSAT מתקינה את מודולי ה- ActiveDirectory ועוד רבים אחרים שתשתמש בהם לנהל תפקידים אחרים ב- Windows. במערכות ההפעלה של Windows Server, מודולים אלו מותקנים דרך מנהל השרתים.

ייבוא מודולים מרחוק (שימוש בפקודות מרחוק)

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

שימוש נוסף בייבוא מודולים מרחוק הוא כאשר אין לך את המודול מותקן מקומית. זה מה שתקבל אם אין לך את המודול ActiveDirectory מותקן, אך תנסה לייבא אותו.

כדי לייבא מודול מרחוק, עליך תחילה ליצור PSSession. ניתן להשתמש ב-New-PSSession כדי ליצור את ההפעלה. לאחר מכן תייבא את המודול הזמין על המכשיר המרוחק באמצעות הפרמטר PSSession עם Import-Module.

PS51> $AdminServer = New-PSSession -ComputerName $AdminServerName -Credential (Get-Credential)
PS51> Import-Module -Name ActiveDirectory -PSSession $AdminServer -Prefix 'Rmt'

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

הוספת תחילית מודול

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

אם הרצת את פקודת הייבוא לעיל וזה מה שתראה כאשר תבדוק את הפקודות:

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

הסרת מודולים

ניתן גם להסיר מודול מהסשן הנוכחי בלי להשתמש ב־Remove-Module. פעולה זו מסירה את המודול מהסשן המקומי מבלי למחוק את קבצי המודול. ניתן להשתמש בזה במקרה שבו השתמשת בסשן מרוחק כדי להשתמש במודול. ניתן להשתמש ב־Remove-Module כדי לנקות את הסשן ולנתק את הסשן המרוחק.

שימוש נוסף של Remove-Module הוא אם אתה עושה שינויים במודול ואינך רוצה להפעיל סשן חדש של PowerShell. במקרה זה, יש להשתמש ב־Remove-Module ואז ב־Import-Module כדי לטעון אותו מחדש לסשן שלך. בנוסף, ניתן להשתמש בפרמטר Force עם Import-Module. פעולה זו תושל את פעולת הפטור והטעינה מחדש של המודול עבורך.

מה מרכיב את מודול PowerShell

A module can consist of one or more files. To meet the minimum requirements for a module, you must have a module file. This can be a PSM1 file or any other module file such as a binary module file. To build upon that, your psm1 should have functions defined in it, or it will not be much use to anyone.

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

מודולים מכילים פונקציות בעלות דמיון

לדוגמה, המודול ActiveDirectory כולל רק פונקציות שמתמקדות בהתקשרות עם Active Directory באופן כלשהו. לרוב שמות הפונקציות מכילים גם תחילית. כשאתה חוזר למודול ActiveDirectory כדוגמה, כל השמות של העצם בשמות הפונקציות מתחילים בתחילית AD.

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

בשימוש בהנחיות אלו, אם יש לך קומץ של פונקציות שכולן קשורות להתקשרות עם הרשומות, תוכל להשתמש במשהו כמו:

function Get-ATARegistryKey {...}

function Set-ATARegistryKey {...}

מניפסטי מודול

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

כאן דוגמה למניפסט שיכול להיות למודול הרישומים שלנו:

#קובץ רפרנסים עבור מודול 'ATARegistry'
#נוצר על ידי: טיילר
#נוצר בתאריך: 11/8/2019
@{
	#מודול סקריפט או קובץ מודול בינארי הקשור לרפרנס זה
	RootModule = 'ATARegistry'
	#מספר גרסה של מודול זה
	ModuleVersion = '1.0'
	#PSEditions נתמכות
	#CompatiblePSEditions = @()
	#זיהוי ייחודי המשמש לזיהוי מודול זה
	GUID = 'fef619fa-016d-4b11-a09d-b222e094de3e'
	#יוצר של מודול זה
	Author = 'Tyler Muir'
	#חברה או יצרן של מודול זה
	CompanyName = 'Adam the Automator'
	#הצהרת זכויות יוצרים עבור מודול זה
	Copyright = '(c) 2019 tyler. All rights reserved.'
	#תיאור של הפונקציות המסופקות על ידי מודול זה
	Description = 'This is a test module.'
	#גרסת מינימום של מנוע ה-Windows PowerShell הנדרשת על ידי מודול זה
	#PowerShellVersion = ''
	#שם של מארח ה-Windows PowerShell הנדרש על ידי מודול זה
	#PowerShellHostName = ''
	#גרסת מינימום של מארח ה-Windows PowerShell הנדרשת על ידי מודול זה
	#PowerShellHostVersion = ''
	#גרסת מינימום של הגירסה של Microsoft .NET Framework הנדרשת על ידי מודול זה. יחיד עבור הגרסה של PowerShell Desktop בלבד.
	#DotNetFrameworkVersion = ''
	#גרסת מינימום של סביבת הריצה המשותפת (CLR) הנדרשת על ידי מודול זה. יחיד עבור הגרסה של PowerShell Desktop בלבד.
	#CLRVersion = ''
	#ארכיטקטורת מעבד (None, X86, Amd64) הנדרשת על ידי מודול זה
	#ProcessorArchitecture = ''
	#מודולים שחייבים להיות מיובאים לסביבת הסביבה הגלובלית לפני יבוא מודול זה
	#RequiredModules = @()
	#קבצי Assembly שחייבים להיות נטענים לפני יבוא מודול זה
	#RequiredAssemblies = @()
	#קבצי סקריפט (.ps1) שיורצו בסביבת הקורא לפני יבוא מודול זה
	#ScriptsToProcess = @()
	#קבצי טיפוס (.ps1xml) שיש לטעון בעת יבוא מודול זה
	#TypesToProcess = @()
	#קבצי פורמט (.ps1xml) שיש לטעון בעת יבוא מודול זה
	#FormatsToProcess = @()
	#מודולים לייבא כמודולים מקוננים של המודול שצויין ב-RootModule/ModuleToProcess
	#NestedModules = @()
	#פונקציות לייצוא ממודול זה. לביצוע יעיל, אין להשתמש בכוכביות ולא למחוק את הרשומה, להשתמש במערך ריק אם אין פונקציות לייצוא
	FunctionsToExport = @('Get-RegistryKey','Set-RegistryKey')
	#Cmdlets לייצוא ממודול זה. לביצוע יעיל, אין להשתמש בכוכביות ולא למחוק את הרשומה, להשתמש במערך ריק אם אין cmdlets לייצוא
	CmdletsToExport = @()
	#משתנים לייצא ממודול זהVariablesToExport = '*'
	#אלפי לייצוא ממודול זה. לביצוע יעיל, אין להשתמש בכוכביות ולא למחוק את הרשומה, להשתמש במערך ריק אם אין כתובות לייצא
	AliasesToExport = @()
	#משאבי DSC לייצוא ממודול זה
	#DscResourcesToExport = @()
	#רשימת כל המודולים הארוזים יחד עם מודול זה
	#ModuleList = @()
	#רשימת כל הקבצים הארוזים יחד עם מודול זה
	#FileList = @()
	#נתונים פרטיים להעברה למודול שצוין ב-RootModule/ModuleToProcess. יתכן גם שיכיל טבלת PSData עם מטא-נתונים נוספים המשמשים על ידי PowerShell.
	PrivateData = @{
		PSData = @{
			#תגיות שיוחלקו על מודול זה. אלו עוזרות עם גילוי מודולים בגלריות מקוונות.
			#Tags = @()
			#כתובת URL לרשיון של מודול זה.
			#LicenseUri = ''
			#כתובת URL לאתר הראשי של פרויקט זה.
			#ProjectUri = ''
			#כתובת URL לסמל המייצג את מודול זה.
			#IconUri = ''
			#הערות הגרסה של מודול זה
			#ReleaseNotes = ''
		} 
		#סיום של טבלת PSData
	} 
	#סיום של טבלת נתונים פרטית
	#HelpInfo URI של מודול זה
	#HelpInfoURI = ''
	#קידומת ברירת המחדל לפקודות שיוצאות ממודול זה. דרך ניתן לדרוס את ברירת המחדל באמצעות Import-Module -Prefix.
	#DefaultCommandPrefix = ''
}

על אף שזה עשוי להיראות מאיים בהתחלה, ל-Microsoft יש cmdlet ידידותי שניתן להשתמש בו כדי ליצור מניפסט של מודול. הפקודה שנכללת היא `New-ModuleManifest`. כדי ליצור את המניפסט שמופיע למעלה, ניתן היה להשתמש:

PS51> New-ModuleManifest -Path .\Scripts\TestModule.psd1 -Author 'Tyler Muir' -CompanyName 'Adam the Automator' -RootModule 'TestModule.psm1' -FunctionsToExport @('Get-RegistryKey','Set-RegistryKey') -Description 'This is a test module.'

קבצי עזר חיצוניים

לעיתים תראה קבצי עזר חיצוניים במודולים מסוימים. אתה יכול לזהות אותם על ידי <שם המודול>-Help.xml בסופו של שם הקובץ. קבצי העזר החיצוניים הללו מכילים את אותו המידע שבדרך כלל יכילו בעזרה המבוססת על פקודות שתמצא בהגדרת פונקציה.

כדי שזה יעבוד כראוי כאשר אתה משתמש בפקודה Get-Help לאחר שמירת המודול, יש לך גם להוסיף את # .ExternalHelp <ModulePath>-Help.xml לפונקציה שלך. זה נראה רק במודולים גדולים מאוד ולכן הם מחוץ לתחום הנורמה.

קבצים קשורים

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

כדי שקבצי המודול שאינם תקניים ייפורסו כראוי, עליך לכלול קבצים נוספים בפרמטר `FileList` במניפסט של המודול שלך.

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

PSRepositories

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

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

כברירת מחדל, יהיה לך רק ערך אחד והוא יהיה עבור PowerShell Gallery. עשוי להישמע שהוא אינו מהימן. זה בגלל ש-PowerShell מודיע לך שבאמצעות PowerShell Gallery ייתכן שתשתמש בקוד שלא נכתב ואושר על ידי Microsoft. זה אומר שלפני שמודולים כלשהם יתקינו ממנו, יהיה עליך לתת הרשאה חד מכרעת.

הוספת PSRepositories

ניתן גם להוסיף מאגרים משלך. כדי לבטח את PowerShell Gallery, תוכל להריץ את הפקודה Get-PSRepository -Name PSGallery | Set-PSRepository -InstallationPolicy Trusted או לקבל את האזהרה בפעם הראשונה שאתה מתקין מודול מ-PowerShell Gallery.

כל הפקודות שתשתמש בהן כדי להתקשר עם אלה המאגרים של PSRepositories ניתן למצוא בתוך המודול PowerShellGet. תוכל לראות את הפונקציות כאן:

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

מציאת מודולים

תכונה עיקרית נוספת בשימוש ב- PSRepository היא היכולת לחפש מודולים. זה נעשה באמצעות הפקודה Find-Module. ישנם מספר דרכים לסנן כדי למצוא בדיוק את מה שאתה מחפש, אך לעת עתה תוכל לחפש את מודולי VMware כך:

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

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

התקנת מודולים

כדי להשתמש בפקודת Install-Module, עליך להיות בעל מאגר PSRepository מהימין המארח את המודול. זה יכול להיות גלריית PowerShell, מאגר אינטרנט אחר ל-PSRepository, או אתר שאתה מארח בעצמך. תוכל להעביר מהפקודה Find-Module כדי לוודא בקלות את המודול לפני שתתקין אותו.

תוכל גם להגדיר את גרסת המודול על ידי שימוש בפרמטרים MinimumVersion, MaximumVersion, או RequiredVersion.

לראות את כל המודולים שהותקנו באמצעות Install-Module, תוכל להשתמש ב- Get-InstalledModule. זה יציג לך את כל המודולים שהותקנו בהקצאה של AllUsers או בהקצאת המשתמש הנוכחי שלך, CurrentUser.

הסרת מודולים

כמו שאתה יכול להתקין מודול, אתה יכול גם להסיר מודול. אם המודול לא הותקן באמצעות פקודת Install-Module, אתה לא יכול להסיר אותו באמצעות פקודת Uninstall-Module.

כפי שאתה רואה כאן, אנו מנסים להסיר את המודול ActiveDirectory. מכיוון שהמודול הזה לא הותקן עם Install-Module, תקבל שגיאה בעת ניסיון להשתמש ב- Uninstall-Module. כדי להסיר את המודול הזה, יהיה עליך להסיר אותו דרך ההפוך לכל מה שהשתמשת בו להתקנת המודול.

כדי לראות הסרת מוצלחת של מודול, אתה יכול להסיר את המודול VMware.PowerCLI שהותקן לך לפני כן.

אף שהסרת את VMware.PowerCLI, תוכל לראות שיש עדיין התקנה של התלויות רבות. אם תרצה להסיר את כל המודולים, ניתן להשתמש ב- Get-InstalledModule VMware.* | Uninstall-Module -Force.

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

עדכון של מודולים

עכשיו שאתה יודע כיצד להתקין ולהסיר מודול, ייתכן שתתעניין כיצד לעדכן מודול שהתקנת.

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

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

בדיקת/שמירת מודול

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

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

בדוגמה זו, לא רק המודול VMware.PowerCLI נורד, אלא גם כל התלותים. כך נראה בתיקיית VMware.PowerCLI:

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

כתיבת מודול משלך

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

צור קבצי תבנית

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

PS51> New-Item -Path .\Scripts -Name ATARegistry -ItemType Directory
PS51> New-Item -Path .\Scripts\ATARegistry -Name ATARegistry.psm1

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

PS51> New-ModuleManifest -Path .\Scripts\ATARegistry\ATARegistry.psd1 -Author 'Tyler Muir' -CompanyName 'Adam the Automator' -RootModule ATARegistry.psm1 -Description 'Used for interacting with registry keys'

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

הרשמת PSRepository

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

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

PS51> New-Item -Path C:\ -Name Repo -ItemType Directory
PS51> Register-PSRepository -Name 'LocalRepo' -SourceLocation 'C:\Repo' -PublishLocation 'C:\Repo' -InstallationPolicy Trusted

אם היית רוצה להוריד רק מ-PSRepository ולא לפרסם, תוכל לא לכלול את הפרמטר PublishLocation.

פרסום המודול שלך

מאחר שכבר הגדרת את מדיניות ההתקנה למהימנה, לא תקבל אישור לאפשר למודול להתקין מהמאגר. עכשיו שיש לך PSRepository זמין, תוכל לפרסם את המודול שלך באמצעות Publish-Module -Name .\Scripts\ATARegistry -Repository LocalRepo.

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

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

הוספת פונקציות למודול שלך

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

function Get-ATARegistryKey {
    param (
        [string]$Path
    )
    Get-Item $Path
}

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

ייצוא פונקציות מודול

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

בעוד שהפונקציה שלך תוכל להימצא בשימוש ללא רשימת ה- FunctionsToExport, זה יקשה הרבה יותר לאתר אותה.

כל עוד אינך מגדיר מערך ריק, @(), עבור הפונקציות שלך FunctionsToExport, כל הפונקציות, משתנים וכינויים מיוצאים באופן ברירת מחדל.

כדי לתקן את שני הבעיות הללו, תוכל לעדכן את קובץ המודול שלך כמו כן:

ModuleVersion = '1.1'
FunctionsToExport = 'Get-RegistryKey'

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

PS51> Publish-Module -Name .\Scripts\ATARegistry -Repository LocalRepo.

בחירה בין FunctionsToExport ו-Export-ModuleMember

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

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

A few notes about Export-ModuleMember:

• עוקף את ההתנהגות של FunctionsToExport, לכן אם נעשה שימוש בפקודה Export-ModuleMember, פונקציות שנמצאות ב-FunctionsToExport אין להן השפעה.
• Export-ModuleMember לא מייצא משתנים וכינויים ללא הגדרה באופן פשוט, לעומת FunctionsToExport, שמייצאת את הערכים האלו.
• ניתן להשתמש במספר פקודות Export-ModuleMember והן מתודרות במקום להקדים.

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

עדכון המודול שלך

השלב האחרון יהיה עבורך לעדכן את המודול שלך בסשן שלך כדי להשתמש בקבצים המעודכנים. באמצעות Update-Module ATARegistry אתה מוריד את העדכון שפרסמת לאחרונה למאגר.

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

בניית תוכן עזר

אחת האפשרויות שעברה עליך מאוחר יותר היא מערכת העזר שמובנית בפוורשל. ייתכן ובמהלך כתיבת מודולים כבר השתמשת ב-Get-Help על פונקציה מסוימת. מידע זה ניתן להוספה בשני דרכים עיקריות.

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

כפי שתוכל לראות, אכן אין הרבה מידע והמידע הזנות שתקבל כנראה לא יהיה מועיל לאף אחד.

תוכל להוסיף מידע מבוסס הערות לקובץ המודול שלך כדי למלא את השדות האלה במערכת העזר. תוכל לקרוא על כל האפשרויות לקבלת עזר מבוסס הערות באמצעות Get-Help about_Comment_Based_Help.

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

עכשיו הפונקציה שלך נראית כך:

 function Get-RegistryKey {
	<#
    .SYNOPSIS
    מחזיר מפתח רשומות באמצעות נתיב מסוים.
    .DESCRIPTION
    הפונקציה משתמשת בפקודת Get-Item כדי להחזיר את המידע עבור מפתח רשומות מסוים.
    .PARAMETER Path
    הנתיב שבו יחפש מפתח רשומות.
    .EXAMPLE
    Get-RegistryKey -Path 'HKLM:\HARDWARE\DESCRIPTION\System'
    .INPUTS
    System.String
    .OUTPUTS
    Microsoft.Win32.RegistryKey
    .NOTES
    מודול זה הוא דוגמה לפונקציה מתועדת היטב.
    .LINK
    
ATA Learning

#>
	param(
		[string]$Path
	)
	Get-Item $Path
}

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

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

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

במקרה של קובץ עזר חיצוני, המידע הנוסף זהה, אך המידע מונח בקובץ נפרד ומקושר בתוך הפונקציה.

אם תסתכל בנתיב המודול AllUsers, תוכל לראות את גרסת המודול ואת כל קבצי המודול שהתקנת.

אם תחזור לנתיב PSRepository שלך C:\Repo שיצרת לפני כן, תוכל לראות מספר של קבצי NUPKG. יהיו קובץ אחד לכל גרסה שיצאה. אלו הם גרסאות דחוסות של מה שפרסמת כאשר אתה משתמש ב-Publish-Module.

סיכום

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

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