RSAT über PowerShell installieren

RSAT über PowerShell installieren

4.9
(16)
Remoteserver-Verwaltungstools (RSAT) über PowerShell installieren

Update 13.02.2026
Es gibt mittlerweile einen unkomplizierten Weg, die RSAT-Tools direkt über PowerShell zu installieren.
HowTo: PowerShell-Skript erstellen mit dem Namen Ensure-RSAT.ps1 und als Administrator ausführen.

Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass -Force; .\Ensure-RSAT.ps1 -All
### Ensure-RSAT-Installer.ps1 ###
# =========================
# Ensure-RSAT.ps1 - Usage
# =========================
# Core (Default): AD + DNS + GPO
#   .\Ensure-RSAT.ps1
#   .\Ensure-RSAT.ps1 -Core
#
# All RSAT (install everything RSAT offers)
#   .\Ensure-RSAT.ps1 -All
#
# Only selected components (comma-separated)
#   .\Ensure-RSAT.ps1 -Components AD
#   .\Ensure-RSAT.ps1 -Components AD,DNS,GPO
#   .\Ensure-RSAT.ps1 -Components AD,DNS,GPO,DHCP
#   .\Ensure-RSAT.ps1 -Components AD,DNS,GPO,DHCP,ADCS
#
# Core + extra components (Core plus additions)
#   .\Ensure-RSAT.ps1 -Core -Components DHCP
#   .\Ensure-RSAT.ps1 -Core -Components DHCP,ADCS
#
# With logfile (optional)
#   .\Ensure-RSAT.ps1 -LogPath C:\Temp\ensure-rsat.log
#   .\Ensure-RSAT.ps1 -Core -LogPath C:\Temp\ensure-rsat.log
#   .\Ensure-RSAT.ps1 -All  -LogPath C:\Temp\ensure-rsat.log
#
# Components available:
#   AD, DNS, GPO, DHCP, ADCS, CLUSTER, HYPERV, BITLOCKER, RDS, FILE

# Skriptausführung für diese Sitzung erlauben
# Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass -Force; .\Ensure-RSAT.ps1 -All

# Funktionstest
# Import-Module ActiveDirectory; $c=Get-Credential; Get-ADUser -Server <IP-Adresse des DC> -Credential $c -Identity Administrator -Properties Enabled | Select SamAccountName,Enabled


#requires -RunAsAdministrator
[CmdletBinding()]
param(
    [switch]$All,      # Install all RSAT capabilities
    [switch]$Core,     # Install AD + DNS + GPO (default if nothing specified)
    [ValidateSet('AD','DNS','GPO','DHCP','ADCS','CLUSTER','HYPERV','BITLOCKER','RDS','FILE')]
    [string[]]$Components,
    [string]$LogPath = ""
)

# ---------------- Logging ----------------
function Write-Log {
    param(
        [Parameter(Mandatory)][string]$Message,
        [ValidateSet('INFO','OK','WARN','ERROR')][string]$Level = 'INFO'
    )
    $line = "{0} [{1}] {2}" -f (Get-Date -Format "yyyy-MM-dd HH:mm:ss"), $Level, $Message
    Write-Host $line
    if ($LogPath) { Add-Content -Path $LogPath -Value $line -Encoding UTF8 }
}

function Show-WSUSHint {
    Write-Log "Hint: 0x800f0954 often means WSUS/policy blocks optional feature installs." "WARN"
    Write-Log "Fix: Allow optional features/repair content from Windows Update (GPO/WSUS/Intune) or provide an FoD source." "WARN"
}

# ---------------- RSAT selection ----------------
function Get-CapabilityByPattern {
    param([Parameter(Mandatory)][string]$Pattern)

    $caps = Get-WindowsCapability -Online -ErrorAction Stop |
        Where-Object { $_.Name -like $Pattern }

    # Prefer entries containing "Tools" or "Management"
    $best = $caps | Sort-Object @{
        Expression = { if ($_.Name -match 'Tools|Management') { 0 } else { 1 } }
    }, Name | Select-Object -First 1

    return $best
}

function Ensure-Capability {
    param([Parameter(Mandatory)][string]$CapName)

    $cap = Get-WindowsCapability -Online -Name $CapName -ErrorAction Stop

    if ($cap.State -eq 'Installed') {
        Write-Log ("Already installed: {0}" -f $CapName) "OK"
        return
    }

    Write-Log ("Installing: {0}" -f $CapName) "INFO"
    Add-WindowsCapability -Online -Name $CapName -ErrorAction Stop
    Write-Log ("Installed: {0}" -f $CapName) "OK"
}

# Default behavior
if (-not $All -and -not $Core -and (-not $Components -or $Components.Count -eq 0)) {
    $Core = $true
}

# Prepare logfile directory if needed
if ($LogPath) {
    $dir = Split-Path -Parent $LogPath
    if ($dir -and -not (Test-Path $dir)) {
        New-Item -ItemType Directory -Path $dir -Force | Out-Null
    }
    Write-Log ("Logging enabled: {0}" -f $LogPath) "INFO"
}

# Dynamic patterns (more future proof)
$patterns = @{
    AD        = 'Rsat.ActiveDirectory*'
    DNS       = 'Rsat.Dns*'
    GPO       = 'Rsat.GroupPolicy*'
    DHCP      = 'Rsat.DHCP*'
    ADCS      = 'Rsat.*Cert*'
    CLUSTER   = 'Rsat.FailoverCluster*'
    HYPERV    = 'Rsat.Hyper-V*'
    BITLOCKER = 'Rsat.BitLocker*'
    RDS       = 'Rsat.RemoteDesktop*'
    FILE      = 'Rsat.FileServices*'
}

$targets = @()

try {
    # Build target list
    if ($All) {
        Write-Log "Mode: ALL - installing all RSAT capabilities." "INFO"
        $targets = Get-WindowsCapability -Online -ErrorAction Stop |
            Where-Object { $_.Name -like 'Rsat.*' } |
            Select-Object -ExpandProperty Name
    }
    else {
        $wanted = @()

        if ($Core) {
            Write-Log "Mode: CORE - AD + DNS + GPO." "INFO"
            $wanted += @('AD','DNS','GPO')
        }

        if ($Components) {
            Write-Log ("Components: {0}" -f ($Components -join ', ')) "INFO"
            $wanted += $Components
        }

        $wanted = $wanted | Select-Object -Unique

        foreach ($w in $wanted) {
            $pat = $patterns[$w]
            if (-not $pat) {
                Write-Log ("Unknown component: {0} (skipping)" -f $w) "WARN"
                continue
            }

            $cap = Get-CapabilityByPattern -Pattern $pat
            if (-not $cap) {
                Write-Log ("No capability found for {0} (pattern: {1})" -f $w, $pat) "WARN"
                continue
            }

            $targets += $cap.Name
        }

        $targets = $targets | Select-Object -Unique
    }

    if (-not $targets -or $targets.Count -eq 0) {
        throw "No RSAT targets found. Check Windows version/policies/patterns."
    }

    # Install/skip targets
    foreach ($capName in $targets) {
        try {
            Ensure-Capability -CapName $capName
        }
        catch {
            $msg = $_.Exception.Message
            Write-Log ("Error installing {0}: {1}" -f $capName, $msg) "ERROR"
            if ($msg -match '0x800f0954') { Show-WSUSHint }
            throw
        }
    }

    # Import AD module if present
    if (Get-Module -ListAvailable -Name ActiveDirectory) {
        Import-Module ActiveDirectory -ErrorAction Stop
        $count = (Get-Command -Module ActiveDirectory | Measure-Object).Count
        Write-Log ("ActiveDirectory imported. Cmdlets available: {0}" -f $count) "OK"
    }
    else {
        Write-Log "ActiveDirectory module not found (AD RSAT missing or install failed)." "WARN"
    }

    # ---------------- End verification ----------------
    Write-Log "Verification: target status" "INFO"
    foreach ($t in ($targets | Sort-Object -Unique)) {
        $st = (Get-WindowsCapability -Online -Name $t -ErrorAction SilentlyContinue).State
        if ($st -eq 'Installed') {
            Write-Log ("  {0} => {1}" -f $t, $st) "OK"
        } else {
            Write-Log ("  {0} => {1}" -f $t, $st) "WARN"
        }
    }

    Write-Log "Verification: installed RSAT capabilities (overall)" "INFO"
    $rsatInstalled = Get-WindowsCapability -Online -ErrorAction Stop |
        Where-Object { $_.Name -like 'Rsat.*' -and $_.State -eq 'Installed' } |
        Select-Object -ExpandProperty Name |
        Sort-Object

    Write-Log ("RSAT installed: {0} components" -f $rsatInstalled.Count) "OK"
    foreach ($r in $rsatInstalled) {
        Write-Log ("  RSAT: {0}" -f $r) "OK"
    }

    Write-Log "Done." "OK"
}
catch {
    Write-Log $_.Exception.Message "ERROR"
    throw
}


Bewährte Installationsanleitung
Die Remoteserver-Verwaltungstools für Windows ermöglichen IT-Administratoren die Verwaltung von Windows Server
und Active Directory von einem Remote-Computer aus. Mit Hilfe des PowerShell-Moduls für Active Directory z.B. können direkte Abfragen und Anpassungen über die PowerShell-Konsole durchgeführt werden.

Weitere Anwendungsbeispiele dazu werde ich in einem anderen Tutorial vorstellen. Hier soll es nun hauptsächlich um die Installation der gesamten RSAT-Tools über die PowerShell gehen, die Befehle sollten sowohl für Windows 10 als auch für Windows 11 gelten.

PowerShell-Konsole starten als Administrator

UAC-Abfrage mit Ja bestätigen

Damit es bei der Installation über PowerShell zu keinen Einschränkungen kommt, schalten wir für die Zeit der Installation der RSAT-Tools den Sicherheitsmechanismus auf Unrestrictet (uneingeschränktes Ausführen aller Skripte)

Set-ExecutionPolicy Unrestricted -Force

Aktuellen Installations-Status der RSAT-Tools anzeigen über die PowerShell

Get-WindowsCapability -Name RSAT* -Online | Select-Object -Property DisplayName, State

Die Installation der RSAT-Tools über PowerShell starten Sie über die folgende Befehlszeile

Get-WindowsCapability -Name RSAT* -Online | ForEach-Object { Add-WindowsCapability -Online -Name $_.Name }

Erneuten Installations-Status anzeigen, es wurden erfolgreich alles RSAT-Tools installiert und können sofort genutzt werden

Get-WindowsCapability -Name RSAT* -Online | Select-Object -Property DisplayName, State

Wichtig
die zuvor abgeschaltete Sicherheitsfunktion sollte nun unbedingt wieder aktiviert werden für einen höheren Schutz!

Set-ExecutionPolicy Restricted -Force

Mit dem Befeh Get-ExecutionPolicy können Sie sich den aktuellen Status zu der Sicherheitsfunktion nochmals anzeigen lassen, dieser sollte final wider auf Restricted stehen!

Get-ExecutionPolicy

Domäne mit WSUS-Server

Fehlermeldung
Add-WindowsCapability : Fehler bei "Add-WindowsCapability". Fehlercode: 0x800f0954
In Zeile:1 Zeichen:1
+ Add-WindowsCapability -Online -Name Rsat.WSUS.Tools~~~~0.0.1.0
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  + CategoryInfo          : NotSpecified: (:) [Add-WindowsCapability], COMException
  + FullyQualifiedErrorId : Microsoft.Dism.Commands.AddWindowsCapabilityCommand

Wenn Sie in Ihrer Domäne einen aktiven WSUS-Server in Einsatz haben, der u.a. für die Verteilung der Windows-Updates und Windows-Features zuständig ist, muss dieser für die Zeit der Installation der RSAT-Tools an dem speziell ausgewählten Client ausgesetzt werden, dies kann manuell über die Windows-Registry durchgeführt werden mit dem Befehl Regedit (Administrator-Rechte müssen vorhanden sein). Navigieren Sie nun zu dem folgenden Schlüssel und setzen Sie den Wert von 1 auf 0

HKEY_LOCAL_MACHINE \ Software \ Policies \ Microsoft \ Windows \ WindowsUpdate \ AU \ UseWUServer

Nach der Installation der RSAT-Tools sollten Sie diese Einstellung unbedingt wieder Rückgängig machen, damit Sie weiterhin über Ihren WSUS-Server mit Updates versorgt werden!

Alternativ können Sie auch die folgenden Befehle verwenden für das temporäre deaktivieren und wieder aktivieren des WSUS-Dienstes (Ausführen als Administrator)

Set-ItemProperty -Path HKLM:SOFTWARE\Policies\Microsoft\Windows\WindowsUpdate\AU -Name UseWUServer -Value 0
Restart-Service -Name wuauserv -Force
Set-ItemProperty -Path HKLM:SOFTWARE\Policies\Microsoft\Windows\WindowsUpdate\AU -Name UseWUServer -Value 1
Restart-Service -Name wuauserv -Force

wichtig ist jedoch, dann Sie bei beiden Varianten den Rechner neu starten müssen, damit die Einstellungen übernommen werden!
Führen Sie nun die zu Beginn genannten Schritte durch um die RSAT-Tools zu installieren

weitere Tutorials folgen…

Diesen Beitrag Bewerten

Durchschnittliche Bewertung 4.9 / 5. Anzahl der Bewertungen 16

Bislang wurde noch keine Bewertung zu diesem Beitrag abgegeben

Schreiben Sie einen Kommentar