PowerShell Gelişmiş İşlevleri

PowerShell gelişmiş işlevleri, basit bir PowerShell betiğini yerel bir PowerShell cmdlet'i gibi davranan bir araca genişletme yeteneği sağlar. PowerShell gelişmiş işlevleri, normal komut dosyalarının yerel cmdlet'lerde bulunan özelliklerin aynısını kullanmasına olanak tanır.

PowerShell gelişmiş işlevleri dört temel üzerine kurulmuştur.

1. Akış Kontrolü
2. Parametre Doğrulaması
3. Boru Hattı Bağlama
4. Tedbirler

Sonraki birkaç bölümde bunları daha ayrıntılı olarak ele alacağız.

Akış Kontrolü

PowerShell motoru, bağlama göre farklı mesajlar göndermek için kullanılabilecek bir dizi akış sağlar.

1. Çıktı/Başarı
2. Hata
3. Uyarı
4. Ayrıntılı
5. Hata ayıklama

Bağlama bağlı olarak, belirli bir akışa yazmak için yerleşik cmdlet'lerden yararlanabiliriz; örneğin, ayrıntılı akışa yazmak istiyorsak, Write-Verbose cmdlet'ini vb. kullanabiliriz.

Ancak şekil 1'de gördüğümüz gibi sadece doğru cmdlet'i kullanmak yeterli değildir.

Şekil 1: Verbose akışını kullanmaya çalışan normal işlev

-Verbose anahtarının çalışabilmesi için işlevimizi değiştirmemiz ve aşağıdaki örnekte gösterildiği gibi CmdletBinding'i eklememiz gerekir:

Function Do-SomethingRegular{
		[CmdletBinding()]
		param(
				[String]$Message
		)
		Write-Verbose "We are going to write the message by the User"
		Write-Output $Message
}
Do-SomethingRegular -Message "Hi Mom" -Verbose

CmdletBinding özelliği, PowerShell motoru tarafından sağlanan bir dizi özelliği ortaya çıkarır. CmdletBinding özelliğinin fonksiyonumuzu gelişmiş hale getirdiğini söylemek yanlış olmaz. Şimdi şekil 2'de gözlemleyebileceğimiz gibi, fonksiyonumuz ayrıntılı akışa doğru bir şekilde yazıyor.

Şekil 2: İşleve CmdletBinding niteliğinin eklenmesi, işlevin ayrıntılı akışa doğru şekilde yazmasına yol açar

Daha sonra hata akışını içeren daha karmaşık bir örneğe bakacağız. Öncelikle sonlandırıcı ve sonlanmayan hatalar arasındaki farkı tanımlamamız gerekiyor:

• Sonlandırma hatası, programın yürütülmesini durduracak ölümcül bir hatadır.
• Sonlandırılmayan bir hata daha az ciddidir ve programın yürütülmesinin durdurulmasına neden olmaz.

PowerShell motoru sonlandırılmayan bir hatayla karşılaşırsa, yürütmeye devam etmesi mi yoksa sonlandırması mı gerektiğini belirlemek için önce ErrorActionPreference değişkeninin değerini kontrol eder. Varsayılan olarak bu değer "devam et" olarak ayarlanmıştır; bu, PowerShell motorunun bir hatayla karşılaşması durumunda betiğin geri kalanını işlemeye devam etmesi gerektiği anlamına gelir.

Bu davranışı şekil 3:'de görebiliriz: PowerShell motoru, sonlandırılmayan bir hatayla karşılaştığında bir hata mesajı oluşturur ve betiğin geri kalanını yürütmeye devam eder.

Şekil 3: PowerShell motoru, sonlandırılmayan bir hatayla karşılaştıktan sonra betiği çalıştırmaya devam ediyor

Peki ya sonlandırılmayan hatayla karşılaştığımızda betiği sonlandırmak istersek?
Çözüm ErrorActionPreference değişkeninin değerini “Stop” olarak değiştirmektir.

Ancak bu değişkenin değiştirilmesi sistemdeki diğer tüm komut dosyalarını da etkileyecektir ve bu global bir değişkendir. Çözüm, şekil 4'de gösterildiği gibi -ErrorAction anahtarını kullanmak ve PowerShell motoruna betiğimize "ErrorActionPreference" değişkeni gibi davranmasını söylemektir. duracak şekilde ayarlanmıştır. Yine ErrorAction anahtarının mevcut olmasının nedeni, gelişmiş işlevleri kullanıyor olmamızdır.

Şekil 4: ErrorAction anahtarı "Durdur" seçeneğiyle birlikte bir hatayla karşılaşıldığında PowerShell'in yürütmeyi sonlandırmasına yol açar

Parametre Doğrulaması

Fonksiyonlar parametreleri kabul edemedikleri sürece pek kullanışlı değillerdir. Yardımlı işlevler farklı bir hikaye olsa da bizim odak noktamız düzenli işlevlerdir.

Bu nedenle, sağlanan parametreleri programlama mantığımızda kullanmaya başlamadan önce parametre doğrulama çok önemli bir süreçtir. PowerShell motoru, parametreleri doğrulamak için bir dizi yerleşik mekanizma sağlar. Gelişmiş işlevler, kendi parametre doğrulama mantığımızı yazmak yerine parametrelerimizi doğrulamak için bu işlevsellikten yararlanmamıza yardımcı olabilir.

Bu bölümde bazı parametre doğrulama tekniklerini tartışacağız ancak bu liste hiçbir şekilde kapsamlı değildir.

1. Zorunlu Parametre

Zorunlu parametreler, işlevin gerektirdiği belirli parametrelerin bildirilmesine yardımcı olur. Değer eksikse PowerShell motoru kullanıcıdan bir değer ister (şekil 5'de gösterildiği gibi). İşte bir örnek:

# Writing a function with a mandatory parameter
Function Do-SomethingRegular {
		[CmdletBinding]()]
		Param(
				[Parameter(Mandatory)]
				[String] $Message
		)
		Write-Output $Message
}

# Calling the function
Do-SomethingRegular

Şekil 5: Bir parametrenin zorunlu olarak bildirilmesi

2. ValidateScript

ValidateScript, sağlanan parametre değerine göre bir komut dosyası çalıştırmak için kullanılabilir. Komut dosyası $true değerini döndürürse parametre değeri kabul edilir. İşte bir örnek:

Function Simple-Function {
		[CmdletBinding()]
		param(
				[Parameter(Mandatory)]
				[ValidateScript({Test-Connection -ComputerName $_ -Quiet -Count 1})]
				[string]$computerName
		)
		$ErrorActionPreference
		Get-CimInstance -ClassName win32_Process -ComputerName $ComputerName
}

Simple-Function -ComputerName 'CAT'

Şekil 6'da görebileceğimiz gibi, kullanıcı tarafından BilgisayarAdı parametresi olarak sağlanan makineye ulaşıp ulaşamayacağımızı test etmek için ValidateScript kullanıyoruz. Komut dosyası, doğru veya yanlış değerini döndürmek için -Quiet bayrağıyla birlikte Test-Connection cmdlet'ini kullanır. Laboratuvarımızda “CAT” adında bir bilgisayar bulunmadığından false değeri döndürmekte ve validate scripti parametre değerini kabul etmemektedir.

Şekil 6: PowerShell betiğini ValidateScript parametresiyle doğrulama

3. Deseni Doğrula

ValidatePattern, bir parametre değerini normal bir ifadeye göre doğrulamak için kullanılabilir. İşte bir örnek:

Function Do-SomethingRegular {
[CmdletBinding()]
Param(
[Parameter(Mandatory)]
[ValidatePattern('\b((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(.|$)){4}\b')]
[String] $MachineName
)
Get-CimInstance -ComputerName $MachineName -ClassName win32_Process
}
Do-SomethingRegular -MachineName 127.0.01.1

Şekil 7: Bir parametrenin sağlanan değerinin normal ifadeye göre doğrulanması

4. Doğrulama Ayarı

ValidateSet bir parametre için kabul edilebilir değerleri önceden tanımlamak için kullanılabilir (şekil 8'de gösterildiği gibi). Kullanıcı önceden tanımlanmış değerlerin dışında değerler sağlarsa işlev bir hata döndürür. İşte bir örnek:

Function Do-SomethingRegular{
		[CmdletBinding()]
		Param(
				[Parameter(Mandatory)]
				[ValidateSet('Mom','Dad')]
				[String] $Parent
		)
		Write-Output "Hello " $Parent
}

Do-SomethingRegular -Parent

Şekil 8: ValidateSet ile bir parametre için kabul edilebilir değerlerin önceden tanımlanması

Daha önce de belirtildiği gibi PowerShell bir dizi parametre doğrulama tekniği sağlar, ancak bu blog yazısı bunlardan yalnızca bazılarını kapsamaktadır. Daha fazla ayrıntı için Bruno Buyck'ın PowerShell ve ScriptRunner'da Parametre Doğrulama Kavramları hakkındaki makalesini okuyun. Tam liste için lütfen resmi Microsoft PowerShell belgelerini okuyun.

Boru Hattı Bağlama

Parametre işlem hattı bağlama, PowerShell'deki en önemli kavramlardan biridir. Bu bölüm yalnızca parametrelerin Boru Hattı girişini kabul etmesinin nasıl etkinleştirileceğine odaklanacaktır. Daha fazla ayrıntı için PowerShell'deki Parametre Bağlama Kavramları hakkındaki diğer makalemi ziyaret edin.

PowerShell motoru, ardışık düzen girişini "değere göre" veya "özelliğe göre" bağlar. Gelişmiş işlevler, hangi parametrelerin boru hattı girişini kabul edebileceğini ve bağlamanın nasıl gerçekleşmesi gerektiğini belirlememize olanak tanır.

byValue ardışık düzeni girişini kabul ettiğimiz basit bir örneği ele alalım:

Function Do-SomethingRegular{
		[CmdletBinding()]
		Param(
				[Parameter(Mandatory,valueFromPipeline)]
				[String] $name
		)
		Write-Output "You Entered $name"
}
"Sonny"|Do-SomethingRegular

Şekil 9'da fonksiyonumuza bir string nesnesinin aktarıldığı ve fonksiyonun boru hattından değer kabul eden bir parametreye sahip olması nedeniyle fonksiyonların hatasız yürütüldüğü görülmektedir.

Şekil 9: Bir dize nesnesinin parametre değeri olarak boru hattı üzerinden bir işleve geçirilmesi

Benzer şekilde, fonksiyonumuzu byProperty: ardışık düzen girişini kabul edecek şekilde değiştirebiliriz.

Function Do-SomethingRegular{
		[CmdletBinding()]
		Param(
				[Parameter(Mandatory,valueFromPipelineByProperty)]
				[String] $name
		)
		Write-Output "You Entered $name"
}
$MyNewObject = [PSCustomObject]@{name = 'Sonny'; age = 21}
$MyNewObject | Do-SomethingRegular

Şekil 10'da gösterildiği gibi parametremizin adıyla eşleşen özellik adına sahip bir nesne oluşturduk. Bu nesne ardışık düzende iletildiğinde, PowerShell motoru özelliği eşleşen ada sahip parametrelerle bağlar.

Şekil 10: Bir nesnenin tek bir özelliğinin ardışık düzen aracılığıyla bir fonksiyona parametre değeri olarak aktarılması

İşlem hattında birden fazla nesneyi geçirerek örneğimizi karmaşıklaştıralım. Birden fazla nesneyle uğraştığımız için Girdi İşleme yöntemlerini kullanmamız gerekiyor. Giriş işleme yöntemleri aynı zamanda BEGIN, PROCESS ve END bloğu olarak da bilinir. İyi bir PowerShell programcısı, gelişmiş bir işlev yazarken her zaman bunları kullanacaktır.

Şekil 11'de görebileceğimiz gibi, birden fazla nesnede bile bağlama, önceki örneğimizle aynı prensibi izler:

Function Do-SomethingRegular{
		[CmdletBinding()]
		Param(
				[Parameter(Mandatory,valueFromPipelineByPropertyName)]
				[String] $name
		)
		process{
		Write-Output "You Entered $name"
		}
}

$MyNewObject1 = [PSCustomObject]@{name = 'Sonny';age = 21}
$MyNewObject2 = [PSCustomObject]@{name = 'browninfosecguy';age = 21}
$MyNewObject1,$MyNewObject2|Do-SomethingRegular

Şekil 11: Birden çok nesnenin bir özelliğinin ardışık düzen aracılığıyla bir işleve parametre değerleri olarak aktarılması

Tedbirler

PowerShell iki dahili koruma mekanizması sağlar.

• Farzedelim
• Onaylamak

Bu korumalar, $WhatIfPreference ve $ConfirmPreference adlı iki sistem değişkeni tarafından kontrol edilir. Bu değişkenlerin her ikisinin de varsayılan değeri şekil 12'de gösterilmektedir.

Şekil 12: WhatIf ve Confirm Preference değişkeninin varsayılan değeri

Farzedelim

WhatIf anahtarı, hiçbir şeyi gerçekten değiştirmeden "ne olacağını" görmek için kullanılabilir. Davranış, $WhatIfPreference değişkeni tarafından kontrol edilir.
$WhatIfPreference'in varsayılan değeri false olarak ayarlanmıştır; herhangi bir cmdlet'i çalıştırdığımızda bu nedenle, eğer senaryosu gösterilmez. Whatif senaryosunu görüntülemek için şekil 13'te gösterildiği gibi whatif anahtarını açıkça kullanmamız gerekir.

Şekil 13: PowerShell'deki -WhatIf anahtarı örneği

Bir fonksiyonda WhatIf işlevselliğinin uygulanması şu şekilde gerçekleştirilebilir:

1. Şekil 14'te gösterildiği gibi SupportsShouldProcess bağımsız değişkenini CmdletBinding'e ekleme
2. $PSCmdlet.ShouldProcess(“ ”) tarafından döndürülen Boolean değeri yakalanıyor, DOĞRU ise bu, kullanıcının Whatif seçeneğini seçmediği anlamına gelir
3. Whatif mantığını $PSCmdlet.ShouldProcess(“ ”) etrafındaki bir if döngüsüne yerleştirme

Aşağıdaki örnek bu adımları göstermektedir:

Function Delete-Windows{
# First we're adding the “SupportsShouldProcess” argument to CmdletBinding
		[CmdletBinding(SupportsShouldProcess)]
		param(
		)
# Then, we're capturing the Boolean value returned by “$PSCmdlet.ShouldProcess("")”, If TRUE it means user has not selected whatif option
		if($PSCmdlet.ShouldProcess("Meow")){
				Write-Host "WhatIf flag not set, delete windows"
		}
		else{
				Write-Host "WhatIf flag set, do not delete windows or real"
		}
}

Şekil 14: Bir fonksiyonda WhatIf işlevselliğinin uygulanması

Onaylamak

Onayla anahtarı, cmdlet'i çalıştırmadan önce kullanıcıdan onay istemek için kullanılabilir. Aynısını fonksiyonumuzda da uygulayabiliriz. Daha önce tartışıldığı gibi, eğer $ConfirmPreference değişkeni "high" olarak ayarlanmışsa, ConfirmImpact değişkeni "high" olarak ayarlanmış cmdlet'ler, çalıştırmadan önce kullanıcıdan onay isteyecektir.

Bu bize başka bir kavramı getiriyor: bir fonksiyonun ciddiyetini tanımlamak için kullanılan $ConfirmImpact değişkeni. Aşağıdaki değerleri kabul edebilir:

• "Düşük "
• "Orta "
• "Yüksek "

Bunu “Yok” olarak da ayarlayabiliriz ancak bu onu devre dışı bırakacaktır.

İşlevimizde confirm'i uygulamak için ConfirmImpact bağımsız değişkenini CmdletBinding'e eklememiz ve bunun için bir değer başlatmamız gerekir. PowerShell motoru daha sonra bu değeri $ConfirmPreference değeriyle karşılaştıracak ve fonksiyonumuzun önem derecesi eşit veya daha yüksekse kullanıcıya onayla diyaloğuyla uyarı verilecektir. İşte bir örnek

Function Delete-Windows{
		[CmdletBinding(SupportsShouldProcess, ConfirmImpact = "Medium")]
		param(
		)
		if($PSCmdlet.ShouldProcess("Meow"){
		Write-Host "Delete Windows"
		}		
}

Şekil 15'te görebileceğimiz gibi $ConfirmPreference "High" olarak ayarlandığından PowerShell motoru, fonksiyonumuz "medium" <'a sahip olduğundan kullanıcıyı confirm diyaloguyla yönlendirmedi.ConfirmImpact.

Şekil 15: ConfirmImpact argümanını CmdletBinding'e ekleme ve değerini “Medium” olarak ayarlama

$ConfirmPreference değerini orta olarak değiştirirsek, kullanıcıya şekil 16'da gösterildiği gibi onayla iletişim kutusuyla bilgi verilir.

Şekil 16: $ConfirmPreference değeri orta olarak değiştirilirse kullanıcıya onayla iletişim kutusuyla bilgi verilir

Şimdi $ConfirmPreference değişkenini tekrar "Yüksek " olarak değiştirirsek ne olur? Beklendiği gibi, Delete-Windows komutunu çalıştırırsak onayla iletişim kutusuyla karşılaşmayız ancak açıkça -Confirm iletişim kutusunu kullanırsak geçiş yaptığımızda şekil 17'de gösterildiği gibi onayla diyalog kutusuyla karşılaşacağız.

Şekil 17: İşlev çağrılırken -Confirm anahtarının eklenmesi onayla iletişim kutusunu tetikler

Çözüm

Gelişmiş işlevleri kullanmanın değerini açıkça görebiliriz. Bu blog yazısında tartışılan parametre doğrulama mantığının uygulanması, güvenlik önlemlerinin uygulanması ve diğer işlevler gibi gereksiz yükü ortadan kaldırır.

Her zaman olduğu gibi herhangi bir sorunuz veya endişeniz varsa lütfen bizimle iletişime geçmekten çekinmeyin.

Şerefe!