Praxisprojekt: AD-Onboarding-Skript

Zeit das Gelernte zusammenzubringen. In diesem letzten Kapitel bauen wir ein realistisches Skript das ein FISI tatsächlich täglich benutzen kann: ein AD-Onboarding-Skript. Aus einer CSV mit neuen Mitarbeitern werden komplett konfigurierte AD-Konten – mit Passwort, Gruppenmitgliedschaften, Mail-Aliasen, Welcome-Sheet, Logging.

Wir bauen es in fünf Iterationen auf – Anfang minimal, dann Schritt für Schritt produktionsreif. Das ist auch die professionelle Arbeitsweise: niemand schreibt 200 Zeilen am Stück. Stattdessen: kleinster lauffähiger Prototyp, dann härten, erweitern, polieren. Am Ende hast du ein Skript das sich messen lassen kann mit dem was in echten Unternehmen läuft.

1) Die Aufgabe: HR-Onboarding

Stell dir vor: HR schickt dir eine Excel-Liste mit 30 neuen Auszubildenden. Jeder braucht ein AD-Konto, soll in die richtigen Gruppen, eine E-Mail-Adresse haben und ein Welcome-Sheet ausgehändigt bekommen. Manuell über die ADUC-Konsole: pro User 5 Minuten = 2,5 Stunden Klicken. Mit PowerShell: ein Skript-Lauf von 30 Sekunden.

Die fachlichen Anforderungen:

Anforderungen unseres Onboarding-Skripts

CSV als Input

HR liefert Excel/CSV mit Vorname, Nachname, Abteilung, Standort, Manager

User anlegen

In der richtigen OU, mit konsistenten Konventionen

Initial-Passwort

Zufällig generiert, sicher, beim ersten Login ändern

Gruppen-Mitgliedschaft

Abteilungs- und Standort-Gruppen automatisch zuweisen

E-Mail-Konvention

vorname.nachname@firma.de, Konflikt-Behandlung

Welcome-Sheet

Pro User Text-Datei mit Login-Daten zum Aushändigen

Logging

Alles in Logfile + Konsolen-Output mit Farben

Idempotent

Bei erneutem Lauf: existierende User skippen, nicht abbrechen

Idempotenz ist ein wichtiges Konzept aus der Software-Entwicklung: ein Skript darf mehrmals laufen ohne Schaden anzurichten. Das ist wichtig wenn Teile fehlschlagen und du nochmal startest. Auch bekannt aus Configuration-Management-Tools wie Ansible/Puppet. Mehr dazu in K54 CI/CD.

2) Iterativer Aufbau – fünf Stufen

So bauen wir das Skript schrittweise auf. Jede Iteration ist lauffähig:

Stufen des Projekts

v1: Minimal

v2: Strikt + Idempotent

v3: Funktionen

v4: Gruppen + Welcome

v5: Production

3) Die CSV-Datei

Bevor wir Code schreiben, klären wir den Input. HR liefert so eine CSV:

# Datei: new-hires.csv Vorname,Nachname,Abteilung,Standort,Manager Lisa,Müller,Vertrieb,München,anna.schmidt Max,Schmidt,IT,Berlin,carla.roth Sarah,Weber,Marketing,München,anna.schmidt Tobias,Meier,Vertrieb,Hamburg,anna.schmidt Anna,Klein,IT,Berlin,carla.roth

PowerShell parsed CSV mit Import-Csv in ein Array von Objekten – jede Zeile wird ein Objekt mit den Spalten als Properties (siehe L6).

4) Iteration v1: der Prototyp

Wir fangen ganz simpel an. Hauptsache lauffähig:

# onboarding-v1.ps1 – minimaler Prototyp Import-Module ActiveDirectory $users = Import-Csv -Path C:\hr\new-hires.csv foreach ($user in $users) { $sam = "$($user.Vorname.ToLower()).$($user.Nachname.ToLower())" $pass = ConvertTo-SecureString "Start123!" -AsPlainText -Force New-ADUser ` -Name "$($user.Vorname) $($user.Nachname)" ` -GivenName $user.Vorname ` -Surname $user.Nachname ` -SamAccountName $sam ` -UserPrincipalName "$sam@firma.local" ` -Department $user.Abteilung ` -Path "OU=Azubis,DC=firma,DC=local" ` -AccountPassword $pass ` -ChangePasswordAtLogon $true ` -Enabled $true Write-Host "User $sam angelegt" }

Was ist dabei: CSV einlesen, foreach, New-ADUser aus L7. Lauffähig, aber: keine Fehlerbehandlung. Wenn ein User schon existiert → Abbruch. Wenn die OU nicht existiert → Abbruch. Wenn alle gleiches Passwort haben → Security-Problem. Das fixen wir.

5) Iteration v2: strikter Modus + Idempotenz

# onboarding-v2.ps1 – mit Fehlerbehandlung + Idempotenz $ErrorActionPreference = "Stop" Import-Module ActiveDirectory $users = Import-Csv -Path C:\hr\new-hires.csv foreach ($user in $users) { $sam = "$($user.Vorname.ToLower()).$($user.Nachname.ToLower())" # Existiert User schon? Dann skippen (Idempotenz!) $existiert = Get-ADUser -Filter "SamAccountName -eq '$sam'" -ErrorAction SilentlyContinue if ($existiert) { Write-Host "⊘ $sam existiert bereits - übersprungen" -ForegroundColor Yellow continue } $pass = ConvertTo-SecureString "Start123!" -AsPlainText -Force try { New-ADUser ` -Name "$($user.Vorname) $($user.Nachname)" ` -GivenName $user.Vorname ` -Surname $user.Nachname ` -SamAccountName $sam ` -UserPrincipalName "$sam@firma.local" ` -Department $user.Abteilung ` -Path "OU=Azubis,DC=firma,DC=local" ` -AccountPassword $pass ` -ChangePasswordAtLogon $true ` -Enabled $true Write-Host "✓ $sam angelegt" -ForegroundColor Green } catch { Write-Host "✗ $sam fehlgeschlagen: $_" -ForegroundColor Red } }

Drei wichtige Änderungen: $ErrorActionPreference = "Stop" macht Fehler zu Exceptions die wir fangen können (siehe L4). try/catch um New-ADUser – ein Fehler bei einem User bricht nicht den ganzen Lauf ab. Pre-Check auf Existenz mit Get-ADUser – wenn der User schon da ist, wird er einfach übersprungen statt einen Fehler zu werfen. Das macht das Skript idempotent: du kannst es problemlos zweimal starten.

6) Iteration v3: Funktionen, Zufalls-Passwort, Logging

# onboarding-v3.ps1 – modularisiert mit Logging $ErrorActionPreference = "Stop" Import-Module ActiveDirectory $logFile = "C:\Logs\onboarding-$(Get-Date -Format yyyyMMdd-HHmmss).log" $null = New-Item -Path (Split-Path $logFile) -ItemType Directory -Force # ===== Funktionen ===== function Write-Log { param([string]$Level, [string]$Message) $line = "[{0}] {1}: {2}" -f (Get-Date -Format "yyyy-MM-dd HH:mm:ss"), $Level, $Message Add-Content -Path $logFile -Value $line $color = switch ($Level) { "INFO" { "White" } "WARN" { "Yellow" } "ERROR" { "Red" } "OK" { "Green" } } Write-Host $line -ForegroundColor $color } function New-RandomPassword { param([int]$Length = 14) $chars = 'ABCDEFGHJKLMNPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz23456789!@#$%' -join (1..$Length | ForEach-Object { $chars[(Get-Random -Maximum $chars.Length)] }) } function New-OnboardingUser { param([pscustomobject]$User) $sam = "$($User.Vorname.ToLower()).$($User.Nachname.ToLower())" if (Get-ADUser -Filter "SamAccountName -eq '$sam'" -ErrorAction SilentlyContinue) { Write-Log WARN "$sam existiert bereits - übersprungen" return $null } $plainPass = New-RandomPassword $securePass = ConvertTo-SecureString $plainPass -AsPlainText -Force $params = @{ Name = "$($User.Vorname) $($User.Nachname)" GivenName = $User.Vorname Surname = $User.Nachname SamAccountName = $sam UserPrincipalName = "$sam@firma.local" Department = $User.Abteilung Office = $User.Standort Path = "OU=Azubis,DC=firma,DC=local" AccountPassword = $securePass ChangePasswordAtLogon = $true Enabled = $true } New-ADUser @params Write-Log OK "$sam angelegt, Passwort: $plainPass" return [PSCustomObject]@{ SAM = $sam; Password = $plainPass } } # ===== Hauptlogik ===== Write-Log INFO "=== Onboarding gestartet ===" $users = Import-Csv -Path C:\hr\new-hires.csv Write-Log INFO "Eingelesen: $($users.Count) User" foreach ($u in $users) { try { $result = New-OnboardingUser -User $u } catch { Write-Log ERROR "Fehler bei $($u.Vorname) $($u.Nachname): $_" } } Write-Log INFO "=== Onboarding beendet ==="

Das ist jetzt deutlich professioneller. Funktionen aus L5 trennen die Logik. Write-Log schreibt parallel in Datei und Konsole. New-RandomPassword erzeugt ein echt zufälliges, sicheres Passwort mit dem .NET-Get-Random-Cmdlet – nicht überall „Start123!". Splatting macht den New-ADUser-Aufruf lesbar.

7) Iteration v4: Gruppen + Welcome-Sheet

Jetzt die richtige Onboarding-Logik. Die zusätzlichen Funktionen:

# Mapping Abteilung → Gruppen $gruppenMap = @{ "IT" = @("GG-IT-User", "GG-VPN-User") "Vertrieb" = @("GG-Vertrieb", "GG-CRM-Zugriff") "Marketing" = @("GG-Marketing", "GG-Adobe-CC") } function Get-UniqueEmail { param([string]$Vorname, [string]$Nachname) $base = "$($Vorname.ToLower()).$($Nachname.ToLower())" $mail = "$base@firma.de" $counter = 1 # Konflikt? Dann mit Zähler erweitern while (Get-ADUser -Filter "EmailAddress -eq '$mail'" -ErrorAction SilentlyContinue) { $counter++ $mail = "$base$counter@firma.de" } return $mail } function New-WelcomeSheet { param( [pscustomobject]$User, [string]$SamAccount, [string]$Password, [string]$Email ) $content = @" ================================================ WILLKOMMEN BEI DER FIRMA, $($User.Vorname)! ================================================ Hier deine Zugangsdaten für IT-Systeme: Benutzername: $SamAccount Passwort: $Password E-Mail: $Email Abteilung: $($User.Abteilung) Standort: $($User.Standort) WICHTIG: - Beim ersten Login musst du das Passwort ändern - Niemals weitergeben, IT fragt nie nach deinem Passwort - Bei Problemen: helpdesk@firma.de Stand: $(Get-Date -Format 'dd.MM.yyyy') ================================================ "@ $file = "C:\Welcome\$SamAccount.txt" $null = New-Item -Path (Split-Path $file) -ItemType Directory -Force Set-Content -Path $file -Value $content -Encoding UTF8 return $file } # Erweiterte Hauptfunktion mit Gruppen+Welcome function New-OnboardingUser { param([pscustomobject]$User) $sam = "$($User.Vorname.ToLower()).$($User.Nachname.ToLower())" if (Get-ADUser -Filter "SamAccountName -eq '$sam'" -ErrorAction SilentlyContinue) { Write-Log WARN "$sam existiert bereits - übersprungen" return $null } $plainPass = New-RandomPassword $securePass = ConvertTo-SecureString $plainPass -AsPlainText -Force $mail = Get-UniqueEmail -Vorname $User.Vorname -Nachname $User.Nachname $params = @{ Name = "$($User.Vorname) $($User.Nachname)" GivenName = $User.Vorname Surname = $User.Nachname SamAccountName = $sam UserPrincipalName = "$sam@firma.local" EmailAddress = $mail Department = $User.Abteilung Office = $User.Standort Path = "OU=Azubis,DC=firma,DC=local" AccountPassword = $securePass ChangePasswordAtLogon = $true Enabled = $true } New-ADUser @params Write-Log OK "User $sam angelegt" # Zu Gruppen hinzufügen $gruppen = $gruppenMap[$User.Abteilung] if ($gruppen) { foreach ($g in $gruppen) { Add-ADGroupMember -Identity $g -Members $sam Write-Log INFO " + Gruppe: $g" } } # Welcome-Sheet $sheet = New-WelcomeSheet -User $User -SamAccount $sam ` -Password $plainPass -Email $mail Write-Log INFO " Welcome-Sheet: $sheet" return [PSCustomObject]@{ SAM = $sam Email = $mail Password = $plainPass WelcomeSheet = $sheet } }

Jetzt wird's richtig. Die Gruppen-Mapping-Hashtable ist elegant: pro Abteilung eine Liste von Gruppen. Neue Abteilung? Einfach Eintrag dazu. Die E-Mail-Konflikt-Behandlung mit while-Schleife: wenn anna.schmidt@firma.de schon vergeben, wird anna.schmidt2@firma.de probiert. Das Welcome-Sheet mit Here-String ist eine einfache Textdatei – in echt würdest du das PDF generieren oder per Mail verschicken.

8) Die Onboarding-Pipeline visualisiert

So fließen die Daten pro User durch das Skript. Klick die Stufen:

Onboarding-Pipeline pro User

CSV-Zeile lesen

SAM bilden + prüfen

Passwort + Email

AD-User anlegen

Gruppen + Sheet

Diese Pipeline ist das Herzstück. Jede Stufe ist eine eigene Funktion, das macht den Code testbar und wartbar. Ein neuer Schritt (z.B. Postfach im Exchange anlegen, Telefon-Eintrag im PBX, License im Microsoft 365) wird einfach hinten dran gehängt – ohne den Rest zu ändern. Genau so wachsen Onboarding-Skripte in echten Unternehmen über Jahre.

9) Iteration v5: Production-Ready

Die finale Version. Mit param-Block, Help-Kommentaren, ShouldProcess, Summary-Report. Das ist Code wie er in einem Unternehmen committed werden kann:

# ===================================================== # onboarding.ps1 – AD-Onboarding aus CSV # Author: Anna Schmidt, Stand: 2026-05-17 # ===================================================== [CmdletBinding(SupportsShouldProcess)] param( # Pfad zur CSV-Datei mit neuen Usern [Parameter(Mandatory)] [ValidateScript({Test-Path $_})] [string]$CsvPath, # Ziel-OU für neue User [string]$TargetOU = "OU=Azubis,DC=firma,DC=local", # Mail-Domain [string]$MailDomain = "firma.de", # Ausgabe-Verzeichnis für Welcome-Sheets [string]$WelcomeDir = "C:\Welcome", # Logfile-Verzeichnis [string]$LogDir = "C:\Logs" ) $ErrorActionPreference = "Stop" Import-Module ActiveDirectory #-- Globaler State -- $script:logFile = Join-Path $LogDir "onboarding-$(Get-Date -Format yyyyMMdd-HHmmss).log" $null = New-Item -Path $LogDir -ItemType Directory -Force $null = New-Item -Path $WelcomeDir -ItemType Directory -Force $gruppenMap = @{ "IT" = @("GG-IT-User", "GG-VPN-User") "Vertrieb" = @("GG-Vertrieb", "GG-CRM-Zugriff") "Marketing" = @("GG-Marketing", "GG-Adobe-CC") } #-- Funktionen -- function Write-Log { param([string]$Level, [string]$Message) $line = "[{0}] {1,-5}: {2}" -f (Get-Date -Format "yyyy-MM-dd HH:mm:ss"), $Level, $Message Add-Content -Path $script:logFile -Value $line $color = switch ($Level) { "INFO" { "White" } "WARN" { "Yellow" } "ERROR" { "Red" } "OK" { "Green" } default { "Gray" } } Write-Host $line -ForegroundColor $color } function New-RandomPassword { param([int]$Length = 14) $chars = 'ABCDEFGHJKLMNPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz23456789!@#$%' -join (1..$Length | ForEach-Object { $chars[(Get-Random -Maximum $chars.Length)] }) } function Get-UniqueEmail { param([string]$Vorname, [string]$Nachname) $base = "$($Vorname.ToLower()).$($Nachname.ToLower())" $mail = "$base@$MailDomain" $counter = 1 while (Get-ADUser -Filter "EmailAddress -eq '$mail'" -ErrorAction SilentlyContinue) { $counter++ $mail = "$base$counter@$MailDomain" } return $mail } function New-WelcomeSheet { param($User, $Sam, $Password, $Email) $content = @" ================================================ WILLKOMMEN BEI DER FIRMA, $($User.Vorname)! ================================================ Benutzername: $Sam Passwort: $Password E-Mail: $Email Abteilung: $($User.Abteilung) Standort: $($User.Standort) WICHTIG: - Beim ersten Login Passwort ändern - Niemals weitergeben - Bei Problemen: helpdesk@$MailDomain Stand: $(Get-Date -Format 'dd.MM.yyyy') ================================================ "@ $file = Join-Path $WelcomeDir "$Sam.txt" Set-Content -Path $file -Value $content -Encoding UTF8 return $file } function New-OnboardingUser { [CmdletBinding(SupportsShouldProcess)] param([pscustomobject]$User) $sam = "$($User.Vorname.ToLower()).$($User.Nachname.ToLower())" if (Get-ADUser -Filter "SamAccountName -eq '$sam'" -ErrorAction SilentlyContinue) { Write-Log WARN "$sam existiert bereits" return [PSCustomObject]@{ SAM=$sam; Status="Skipped" } } if (-not $PSCmdlet.ShouldProcess($sam, "User anlegen")) { return [PSCustomObject]@{ SAM=$sam; Status="WhatIf" } } $plainPass = New-RandomPassword $securePass = ConvertTo-SecureString $plainPass -AsPlainText -Force $mail = Get-UniqueEmail -Vorname $User.Vorname -Nachname $User.Nachname $params = @{ Name = "$($User.Vorname) $($User.Nachname)" GivenName = $User.Vorname Surname = $User.Nachname SamAccountName = $sam UserPrincipalName = "$sam@firma.local" EmailAddress = $mail Department = $User.Abteilung Office = $User.Standort Path = $TargetOU AccountPassword = $securePass ChangePasswordAtLogon = $true Enabled = $true } New-ADUser @params Write-Log OK "User $sam angelegt ($mail)" $gruppen = $gruppenMap[$User.Abteilung] foreach ($g in $gruppen) { try { Add-ADGroupMember -Identity $g -Members $sam Write-Log INFO " + $g" } catch { Write-Log WARN " Gruppe $g nicht gefunden" } } $sheet = New-WelcomeSheet -User $User -Sam $sam -Password $plainPass -Email $mail return [PSCustomObject]@{ SAM = $sam Email = $mail Password = $plainPass Sheet = $sheet Status = "Created" } } #-- Hauptlogik -- Write-Log INFO "=== Onboarding gestartet (CSV: $CsvPath) ===" $users = Import-Csv -Path $CsvPath Write-Log INFO "Eingelesen: $($users.Count) User" $results = @() foreach ($u in $users) { try { $r = New-OnboardingUser -User $u $results += $r } catch { Write-Log ERROR "Fehler bei $($u.Vorname) $($u.Nachname): $_" $results += [PSCustomObject]@{ SAM="$($u.Vorname).$($u.Nachname)" Status="Error" } } } #-- Summary-Report -- Write-Log INFO "=== Zusammenfassung ===" $created = ($results | Where-Object Status -eq "Created").Count $skipped = ($results | Where-Object Status -eq "Skipped").Count $errors = ($results | Where-Object Status -eq "Error").Count Write-Log OK "Angelegt: $created" Write-Log WARN "Übersprungen: $skipped" Write-Log ERROR "Fehler: $errors" $results | Export-Csv -Path (Join-Path $LogDir "onboarding-result.csv") ` -NoTypeInformation -Encoding UTF8 Write-Log INFO "=== Onboarding beendet ==="

Das ist Produktion. param-Block mit Validierung (siehe L5): die CSV-Datei muss existieren (ValidateScript Test-Path), alle anderen Parameter haben sinnvolle Defaults. SupportsShouldProcess: das Skript kann mit -WhatIf trocken laufen. Summary-Report am Ende mit Zählung und CSV-Export aller Ergebnisse. Try/catch um JEDEN User – ein Fehler bringt das Skript nicht zu Fall.

10) So sieht der Lauf aus

.\onboarding.ps1 -CsvPath C:\hr\new-hires.csv

[2026-05-17 14:32:01] INFO : === Onboarding gestartet (CSV: C:\hr\new-hires.csv) === [2026-05-17 14:32:01] INFO : Eingelesen: 5 User [2026-05-17 14:32:02] OK : User lisa.mueller angelegt (lisa.mueller@firma.de) [2026-05-17 14:32:02] INFO : + GG-Vertrieb [2026-05-17 14:32:02] INFO : + GG-CRM-Zugriff [2026-05-17 14:32:03] OK : User max.schmidt angelegt (max.schmidt@firma.de) [2026-05-17 14:32:03] INFO : + GG-IT-User [2026-05-17 14:32:03] INFO : + GG-VPN-User [2026-05-17 14:32:04] OK : User sarah.weber angelegt (sarah.weber@firma.de) [2026-05-17 14:32:04] INFO : + GG-Marketing [2026-05-17 14:32:04] INFO : + GG-Adobe-CC [2026-05-17 14:32:05] WARN : tobias.meier existiert bereits [2026-05-17 14:32:06] OK : User anna.klein angelegt (anna.klein@firma.de) [2026-05-17 14:32:06] INFO : + GG-IT-User [2026-05-17 14:32:06] INFO : + GG-VPN-User [2026-05-17 14:32:06] INFO : === Zusammenfassung === [2026-05-17 14:32:06] OK : Angelegt: 4 [2026-05-17 14:32:06] WARN : Übersprungen: 1 [2026-05-17 14:32:06] ERROR: Fehler: 0 [2026-05-17 14:32:06] INFO : === Onboarding beendet ===

Vier User angelegt, einer bereits existierend (übersprungen, weil idempotent!), keine Fehler. 5 Sekunden Laufzeit. Was manuell ein halber Tag wäre – fertig.

11) Integration mit Task Scheduler

Das Skript wird interessant wenn HR-Export automatisch eingeliefert wird. Pattern: Skript läuft alle 4 Stunden, prüft ob neue CSV da ist:

# Skript einrichten mit dem Task Scheduler aus L9 $action = New-ScheduledTaskAction ` -Execute "powershell.exe" ` -Argument "-NoProfile -ExecutionPolicy Bypass -File C:\Scripts\onboarding.ps1 -CsvPath \\hr-share\new-hires.csv" $trigger = New-ScheduledTaskTrigger -Daily -At "07:00" $principal = New-ScheduledTaskPrincipal ` -UserId "FIRMA\svc-onboarding" ` -LogonType ServiceAccount ` -RunLevel Highest Register-ScheduledTask -TaskName "AD-Onboarding" ` -Action $action -Trigger $trigger -Principal $principal

Jetzt läuft das Skript jeden Morgen um 7 Uhr. HR exportiert vor 7 Uhr, IT findet die neuen User um 7:05 Uhr bereit. Mehr zu Task Scheduler in L9.

12) Erweiterungs-Ideen

Was könntest du noch einbauen?

Exchange-Postfach automatisch anlegen via Exchange-Cmdlets (in O365: Enable-Mailbox)
Microsoft-365-Lizenzen zuweisen via Az/Microsoft Graph
Welcome-Mail an den Manager schicken mit Zugangsdaten als PDF-Anhang
Slack/Teams-Account erstellen via API (siehe L8 Invoke-RestMethod)
Helpdesk-Ticket aufmachen für Hardware-Bestellung
Photo aus HR-System ziehen und im AD als thumbnailPhoto setzen
Off-Boarding-Skript als Gegenstück: bei Austritt automatisch alles deaktivieren, Postfach archivieren
Workflow-Engine: Vorgesetzter muss in einer Web-App approven bevor User wirklich angelegt wird

Manche Firmen haben für das Onboarding/Offboarding spezialisierte Lösungen wie SailPoint IIQ, Microsoft Identity Manager oder Okta Workflows. Für mittlere Setups reicht aber genau so ein PowerShell-Skript – und du verstehst was passiert.

13) Was du im Kurs gelernt hast

Dieses Praxisprojekt vereint alle Konzepte des Kurses. Schau zurück was du benutzt hast:

Kursinhalte im Onboarding-Skript

L1 Grundlagen

Skript-Datei, Execution Policy, PowerShell starten

L2 Cmdlets

Verb-Substantiv-Schema, Get-Help, Parameter

L3 Pipeline

Variablen, Hashtables, Where-Object, Export-Csv

L4 Kontrollfluss

foreach, if, switch, try/catch

L5 Funktionen

param-Block, Splatting, CmdletBinding, SupportsShouldProcess

L6 Dateien

Import-Csv, Set-Content mit Encoding

L7 Active Directory

New-ADUser, Get-ADUser -Filter, Add-ADGroupMember

L8 Netzwerk

UNC-Pfade, Mail-Versand (optional)

L9 Task Scheduler

Automatisierter Lauf, Service-Account

Diese Mischung ist der Punkt: ein produktives PowerShell-Skript kombiniert alle Konzepte. Es gibt nicht „nur eine Funktion" oder „nur ein if" – du baust kleine Bausteine zu echten Tools zusammen. Genau das hast du jetzt gemacht.

14) Wie geht's weiter?

Nach diesem Kurs bist du im Windows-Admin-Geschäft direkt produktiv. Die natürlichen nächsten Schritte:

K27 Windows Server – PowerShell anwenden auf realer Server-Infrastruktur
K28 Active Directory – das Konzeptwissen hinter den AD-Cmdlets
Microsoft Graph – die moderne API für Microsoft 365, mit dem PowerShell-Modul Microsoft.Graph
Azure PowerShell (Az) – Cloud-Verwaltung in Azure
Pester – Unit-Tests für deine PowerShell-Funktionen (siehe K54 CI/CD)
Desired State Configuration (DSC) – deklarative Konfiguration ganzer Server-Farmen
K11 Secure Coding – Passwörter sicher handhaben, Secrets in PowerShell

Übe PowerShell am eigenen System: jede manuelle Klick-Aufgabe ist Übungsmaterial. Heute Klick im AD? Übermorgen ein Skript. Nach ein paar Wochen merkst du: viele Stunden gewonnen, viele Tipp-Fehler vermieden, alles dokumentiert in den Skripten. Das ist die Magie von PowerShell – und sie wartet darauf von dir entdeckt zu werden.

Zusammenfassung

In diesem Praxisprojekt haben wir ein produktionstaugliches Onboarding-Skript in 5 Iterationen aufgebaut: v1 minimal, v2 mit Idempotenz und try/catch, v3 mit Funktionen + Logging + Zufalls-Passwort, v4 mit Gruppen-Mapping + Mail-Konflikt + Welcome-Sheet, v5 production-ready mit param-Validation, ShouldProcess, Summary-Report und Task-Scheduler-Integration. Iterative Entwicklung ist Standard – nicht alles auf einmal! Wichtige Prinzipien: $ErrorActionPreference = "Stop", Pre-Check für Idempotenz, Splatting für lesbare Aufrufe, eigenes Write-Log, parametrisierte Konfiguration, Summary-Report. Alles aus diesem Kurs floss zusammen: Cmdlets (L2), Pipeline (L3), Kontrollstrukturen (L4), Funktionen (L5), Dateisystem (L6), Active Directory (L7), Netzwerk (L8), Task Scheduler (L9). PowerShell ist dein Werkzeug für tägliche Windows-Automation – produktiv mit kleinen Schritten am eigenen System trainieren!