Skrypt i PowerShell

Ett PowerShell-skript är en samling av PowerShell-kommandon, cmdlets och andra PowerShell-uttryck som lagras i en textfil med filändelsen ”.ps1”. Du sparar dina skript på någon mapp så att du kan starta dina script från den mappen. I alla labborationer sparar vi alla script i mappen c:\PShell\Scripts (galler för mina elever). Skript används för att automatisera uppgifter och kan innehålla sekvenser av PowerShell-kommandon som utförs i en viss ordning.

PowerShell skryp komponenter

  • Cmdlets: Cmdlets är grundläggande PowerShell-kommandon som utför specifika uppgifter. De har en verb-noun namnstruktur, som till exempel Get-Process eller New-Item.
  • Pipe (|): Används för att skicka utdata från en cmdlet som indata till en annan. Det möjliggör kedjade operationer.
  • Variabler: Variabler används för att lagra och referera till data. De kan deklareras genom att använda $-tecknet, som $variabelNamn.
  • Villkorssatser och loopar: Används för att skapa logik och iteration i skript.

Skapande av PowerShell-skript

PowerShell är ett kraftfullt skriptspråk som stöder objektorienterad programmering. Dess syntax varierar från korta och koncisa koder till mer omfattande skript som kan omfatta tusentals rader kod. PowerShell använder sig av en pipelinemodell, vilket möjliggör en effektiv överföring av objekt mellan olika cmdlets.

För att hantera PowerShell skrypt ska man använda en utvecklingsmiljö som inkluderar verktyg exempelvis en kodredigerare, eller bara redigerare, som har stöd för PowerShell cmdlets samt färg som skiljer kod när man arbetar med skrypt. Den miljö kallas på engelska IDE eller Integrated Scripting Environment. Här är en kort översikt över några populära redigerare:

  • Notepad: Enklaste textredigeraren, men fungerar för enklare skript.
  • Notepad++: En generell kodredigerare som är mycket anpassningsbar och stöder PowerShell med hjälp av plugin.
  • PowerShell ISE (Integrated Scripting Environment): En inbyggd redigerare i PowerShell, med funktioner som flikhantering, färgkodning och felsökning. Den är dock inte längre aktivt utvecklad.
  • Visual Studio Code (VSCode): En kraftfull, lättviktig kodredigerare från Microsoft som stöder PowerShell. Många utvecklare föredrar VSCode för dess flexibilitet och funktioner.
  • Sublime Text: En annan mångsidig kodredigerare med många funktioner och plugins som stöder PowerShell.

Valet av kodredigerare beror på personliga preferenser och kraven i ditt projekt. I vårt fall, där vi kommer att arbeta med hantering av olika Active Directory-objekt, kommer vi att använda Notepad, PowerShell ISE och VSCode för att utnyttja deras olika funktioner och anpassa oss efter specifika behov.

Exekveringspolicy (Execution Policy)

För att köra skript måste exekveringspolicyn tillåta skriptkörning i PowerShell. Det finns fyra olika exekveringspolicyer som reglerar användningen av skript:

  • Restricted (Begränsad) – Detta är standardinställningen som inte tillåter körning av skript.
  • RemoteSigned (Fjärrsignerad) – Lokalt skapade skript kan köras, medan andra skript måste vara signerade av en betrodd utgivare.
  • AllSigned (Alla signerade) – Endast skript som är signerade av betrodda utgivare kommer att köras, inklusive lokala skript.
  • Unrestricted (Obegränsad) – Alla skript, oavsett deras ursprung, kommer att köras.
  • Bypass (Passera) – Inget blockeras, och det ges varken varningar eller uppmaningar.
  • Undefined (Odefinierat) – Detta representerar standardinställningen, vilket innebär att policyn är inställd på ett begränsat läge.

Exekveringspolicyomfattning (Scope)

Inom PowerShell används termen ”variabelomfattning” för att översätta ”Scope”. Så när man pratar om variabelomfattning i PowerShell, refererar man till hur variabler är synliga och tillgängliga i olika delar av skriptet eller sessionen. Här är de vanligaste variabelomfattningarna:

  • Global variabelomfattning (Global Scope): Variabler som definieras på global nivå är tillgängliga över hela PowerShell-sessionen.
  • Skriptomfattning (Script Scope): Variabler som definieras i ett skript är synliga endast inom det aktuella skriptet.
  • Lokal variabelomfattning (Local Scope): Variabler som definieras i en funktion eller cmdlet är synliga endast i den specifika funktionen eller cmdleten.
  • Privat variabelomfattning (Private Scope): Variabler som definieras inuti ett skriptblock (ofta används i loopar eller villkorliga satser) är synliga endast inom det specifika skriptblocket.

Nu när de olika områdena har beskrivits ovan återstår det att fundera över var dessa ska tillämpas. I PowerShell har du möjligheten att ställa in ”Execution Policy” på din dator på olika nivåer.

  • MachinePolicy: Detta representerar den globala inställningen för hela datorn. Det är ofta satt genom Group Policy och gäller för alla användare och alla processer på datorn.
  • UserPolicy: Detta representerar användarpolicyn och gäller för alla användare på datorn. Den sätts ofta genom Group Policy och kan skräddarsys för varje användare.
  • Process: Detta gäller för den specifika PowerShell-processen som körs. Det betyder att det bara gäller för PowerShell-sessionen som är igång. När processen stängs kommer detta att återställas.
  • CurrentUser: Detta representerar den aktuella användarens inställningar. Det gäller för den inloggade användaren och är inte globalt för alla användare på datorn.
  • LocalMachine: Detta representerar de lokala maskininställningarna som gäller för hela datorn. Det är generellt sett genom Group Policy och gäller för alla användare och processer på datorn.

När man lär sig att skapa och köra PowerShell-skript, är det vanligt att ställa in exekveringspolicyn till RemoteSigned på den lokala maskinen. Detta tillåter körning av lokalt skapade skript utan signatur, medan skript från fjärrkällor måste vara signerade av en betrodd utgivare. För att ställa in exekveringspolicyn till RemoteSigned, kör följande kommando:

  • Get-ExecutionPolicy
    • Utdata: RemoteSigned
    • I detta fall behöver du inte ändra exekveringspolicyn, annars kör:
  • Set-ExecutionPolicy RemoteSigned.

Vi börjar med att skapa enkla PowerShell-skript genom att använda Notepad. För att göra detta skriver vi koden och sparar den med ett lämpligt namn och filändelse .ps1. Detta filformat indikerar att det är ett PowerShell-skript.

  1. Skapa en ny katalog:
    • # Frågar användaren efter namnet och sökvägen för den katalog som ska skapas.
      $directoryName = Read-Host ”Please specify the name for the directory you wish to create.”
      $directoryPath = Read-Host ”Please specify the path for the directory you wish to create.”
    • # Skapar den fullständiga sökvägen genom att sätta ihop namn och sökväg.
      $fullPath = Join-Path -Path $directoryPath -ChildPath $directoryName
    • # Kontrollerar om katalogen redan finns.
      if (-not (Test-Path $fullPath -PathType Container)) {
      # Katalogen skapas om den inte redan finns.
      New-Item -Path $fullPath -ItemType Directory
      Write-Host ”Directory created successfully at: $fullPath”
      } else {
      Write-Host ”Directory already exists at: $fullPath” }
  2. Skapa flera kataloger (Lesson-1, Lesson-2 och så vidare)
    • # Fråga användaren och lagra svar i olika variabler
      $hostInputPath = Read-Host ”Ange sökvägen där katalogerna ska skapas”
      $hostInputCount = Read-Host ”Ange antal kataloger att skapa”
      $hostInputName = Read-Host ”Ange namnet som ska användas för katalogerna”
    • # Loopa igenom och skapa katalogerna
      for ($i = 1; $i -le $hostInputCount; $i++) {
      $newFolderPath = Join-Path -Path $hostInputPath -ChildPath ”$hostInputName$i”
    • # Kontrollera om katalogen redan existerar
      if (!(Test-Path $newFolderPath)) {
      New-Item -ItemType Directory -Path $newFolderPath -Force
      Write-Host ”Katalogen skapades: $newFolderPath”
      } else {
      Write-Host ”Katalogen finns redan: $newFolderPath”}
      }
  3. Skapa flera filer:
    • # Fråga användaren och lagra svar i olika variabler
      $sourcePath = Read-Host ”Ange sökvägen där filerna ska skapas: ”
      $fileCount = Read-Host ”Ange antal filer att skapa: ”
      $fileNamePrefix = Read-Host ”Ange filnamnets prefix: ”
    • # Loopa igenom och skapa filerna
      for ($i = 1; $i -le $fileCount; $i++) {
      $filePath = Join-Path -Path $sourcePath -ChildPath ”$fileNamePrefix$i.txt”
      Set-Content -Path $filePath -Value ”Detta är innehållet i fil $i”
      Write-Host ”Skapad fil: $filePath”}
  4. Skapa en skrypt som Visar en välkomsthälsning och frågar användaren efter deras namn. Hälsar användaren och  använder deras namn. Visar dagens datum. Avslutar skriptet och ger ett avslutningsmeddelande.
    • # Steg 1: Fråga användaren efter deras namn
    • $namn = Read-Host ”Vad är ditt namn?”
    • # Steg 2: Hälsa användaren
      Write-Host -f Yellow ”Hej, $namn! Välkommen till PowerShell-världen.”
    • # Steg 3: Visa dagens datum
      $dagensDatum = Get-Date Write-Host ”Idag är det $dagensDatum.”
    • # Steg 4: Skriptets avslutning
      Write-Host -f Yellow ”Hejdå, ses vi snart!”
  5. Skapa en skrypt som söker efter filer
    • # Skriptets inledning
    • Write-Host ”Detta skript listar filer i en mapp och dess undermappar.”
    • Write-Host ”====================================”
    • Write-Host ” ”
    • # Steg 1: Fråga användaren efter sökvägen till mappen
    • $mappSokvag = Read-Host ”Ange sökvägen till mappen du vill lista filer för.”
    • # Steg 2: Skapa en lista över alla filer i mappen och dess undermappar
    • $filLista = Get-ChildItem -Path $mappSokvag -Recurse | Where-Object { $_.PSIsContainer -eq $false
    • }
    • # Steg 3: Visa filerna i listan
    • Write-Host ”Följande filer hittades i $mappSokvag :”
    • foreach ($fil in $filLista) {
    • Write-Host ”- $($fil.FullName)”
    • }
    • # Skriptets avslutning
    • Write-Host ”Skriptet har avslutats.”

Dessa exempel ger en översikt av hur PowerShell-skript kan skapas och exekveras. I nästa avsnitt kommer vi att fokusera på användningen av PowerShell-skript för att hantera Active Directory-objekt.