Windows PowerShell

PowerShell Integrated Scripting Environment (ISE) starten
%windir%\system32\WindowsPowerShell\v1.0\PowerShell_ISE.exe

Nach der Installation einer neuen Version der PowerShell oder von Windows
das Ausführen von Skripts erlauben (siehe unten) und
Update der Hilfe mit
Eingabeaufforderung als Administrator
powershell
Update-Help # kein Leerzeichen im Befehl
oder mit der PowerShell ISE im Menü Hilfe

Anzeigen der PowerShell-Version
get-host
(get-host).version # nur Version
$Host.Version # nur Version aus der System-Variablen $Host
$PSVersionTable

Installation der PowerShell Version 5.1 unter MS Windows 7
Es muss mindestens das .Net Framework 4.5.2 installiert sein.
Das Windows Management Framework 5.1 für Win 7 herunterladen
Alte Versionen vom Windows Management Framework in der Systemsteuerung unter
 Programme und Funktionen, Installierte Updates anzeigen,
 im Abschnitt Microsoft Windows deinstallieren
Die heruntergeladene Datei Win7AndW2K8R2-KB3191566-x64.zip entpacken
Die PowerShell als Administrator ausführen
Im PowerShell-Fenster ins das Verzeichnis mit den entpackten Dateien wechseln
Darin das Skript Install-WMF5.1.ps1 ausführen,
dabei das Ausführen von Microsoft zulassen
Es wird das Windows-Update KB3191566 installiert.
Neustart von Windows
Kontrolle der PowerShell-Version mit get-host

Skripts

Status zum Ausführen von Skripts anzeigen
Get-ExecutionPolicy
Get-ExecutionPolicy -List

Ausführen von Skripts erlauben
Set-ExecutionPolicy RemoteSigned
Set-ExecutionPolicy Unrestricted
Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy AllSigned -Force
(Hilfe mit: get-help about_signing)

Dateiendung für die Skript-Datei
*.ps1
(Die Zahl ist unabhängig von der PowerShell-Version.)

Starten eines Skripts
Das Ausführen von Skripts erfolgt mit der Angabe dessen kompletten Pfades.

Wenn sich die Skript-Datei im aktuellen Pfad befindet:
.\Datei.ps1
oder auch mit Angabe des Laufwerks:
c:Script.ps1

powershell -executionpolicy unrestricted -file c:\Script.ps1

Kommentar in einem Skript
#
(gilt nur bis Zeilenende)

mehrzeilig:
<#
Text
#>

Fortsetzungs-Zeichen bei langen Befehlen für den Umbruch auf die nächste Zeile
`
(Gravis: ASCII 96, Taste rechts neben dem <ß> mit <Shift> und danach <Leerzeichen>)

Starten eines Skripts im Hintergrund
Start-Job -filepath c:\scripts\Script.ps1

Löschen eines PowerShell-Hintergrundauftrags
Remove-Job

Aufrufen eines Skriptes aus einem Skript
Invoke-Expression h:\Powershell\Script2.ps1

Skript planen
powershell -noprofile -command h:\Powershell\Script.ps1

Ausführen eines Skriptes mit Ausgabe der Laufzeit
Measure-Command {.\Script.ps1}

Test, ob ein Skript aus der PowerShell ISE gestartet wurde
if ($psISE)
{
...
}

Allgemeine Cmdlets

Auflisten der Module
Get-Module -ListAvailable

Auflisten der Cmdlets eines Moduls
Get-Command
Get-Command -Module NetTCPIP

Hilfe zu einem Befehl
Get-Help
Get-Help Get-ADGroupMember -Full
Get-Help New-ADUser -Detailed
Get-Help Where-Object -Examples
Get-Help about*
Get-Help about_signing

Interaktive Hilfe zu einem Befehl mit den Parametern
Show-Command

Aktualisieren der PowerShell-Hilfe
Update-Help

Autovervollständigen von Cmdlets am Prompt
Get-Exe + <Tab> # ergibt Get-ExecutionPolicy.

Mit der <Tab>-Taste kann bei mehreren in Frage kommenden Befehlen
zum nächsten gewechselt werden.

Anzeige aller Aliase für die Cmdlets
Get-Alias

Bildschirm löschen
Clear-Host

Ende-Befehl im Skript
exit

Farben für Bildschirm-Ausgaben
Black (Schwarz)
DarkBlue (Dunkelblau)
DarkGreen (Dunkelgrün)
DarkCyan (Dunkelblaugrün)
DarkRed (Dunkelrot)
DarkMagenta (Dunkelviolett)
DarkYellow (Dunkelgelb)
Gray (Grau)
DarkGray (Dunkelgrau)
Blue (Blau)
Green (Grün)
Cyan (Blaugrün)
Red (Rot)
Magenta (Violett)
Yellow (Gelb)
White (Weiß)

Write-Host -foregroundColor yellow "/\" -noNewLine
Write-Host -foregroundColor red -backgroundColor yellow "Achtung!"

Skript-Beispiele

Skript zur Ausgabe einer Zeichenkette am Prompt

# HelloWorld.ps1

Write-Host "Hello world!"

Skript für Anlegen eines Benutzers

# BenutzerNeu.ps1

$Name = "Herrmann Maier"
$Accountname = "Herrmann.Maier"
$Description = "Leiter IT"
$Password = "Geheim+123"
$Computer = "localhost"

Write-Host "Erstellung eines Users auf Rechner $Computer."

$Container = [ADSI] "WinNT://$Computer"

$objUser = $Container.Create("user", $Accountname)
$objUser.Put("Fullname", $Name)
$objUser.Put("Description", $Description)
$objUser.SetPassword($Password)
$objUser.SetInfo()

Write-Host "Der User $Name wurde erstellt."

Skript zum Anzeigen von Dateien, auf die längere Zeit nicht zugegriffen wurde

# AlteDateien.ps1

$Pfad = "H:\"
$Heute = Get-Date
$Dauer = 30
$Dateien = $null

Get-ChildItem -Path $Pfad -Recurse -Force |
 # Nachfolgender Befehl mit einem Gravis-Zeichen oder in einer Zeile
 foreach-object `
 {
  $Zeitraum=($_.LastAccessTime).adddays($Dauer)
  $Vergleich = New-TimeSpan -start $Heute -end $Zeitraum
  if ($Vergleich -le 0)
  {
    $Dateien += @{ $_.FullName = $_.lastAccessTime }
  }
 }

Write-Host
# Nachfolgender Befehl mit einem Gravis-Zeichen oder in einer Zeile
Write-Host -ForegroundColor green  `
 "Im Pfad $Pfad wurde auf $($Dateien.count) Dateien seit $Dauer Tagen nicht zugegriffen."
Write-Host
Write-Host -ForegroundColor yellow "Diese Dateien sind in folgender Liste aufgeführt:"
$Dateien

# PS: Der Erstellungzeitpunkt ist in der Eigenschaft $_.CreationTime hinterlegt.

Skript zum Anzeigen der Platten-Belegung von mehreren Computern

# HD.ps1

$aryComputers = "Server01","Server02"   # die Computernamen anpassen

Set-Variable -name intDriveType -value 3 -option constant

foreach ($strComputer in $aryComputers)
{
 "Hard drives on: " + $strComputer
 Get-WmiObject -class win32_logicaldisk -computername $strComputer |
   Where { $_.drivetype -eq $intDriveType } | Format-table
}

Skript zum Anzeigen der Konfiguration eines Computers

# Computer.ps1 - Anzeige der Konfiguration eines Computers im Netzwerk

$Computer = "PC-Maier"  # den Computername anpassen

if ($Computer -eq "" -Or $Computer -eq ".")
{
 $Computer = (Get-WmiObject Win32_Computersystem).name   # für den lokalen Rechner
}

Write-Host
Write-Host $Computer -ForegroundColor yellow
Write-Host

$TestPing = Test-Connection -computername $Computer -Quiet -Count 1
$TestAdmin = Test-Path \\$Computer\ADMIN$

if (!$TestPing -or !$TestAdmin)
{
 Write-Host "Der Rechner ist nicht erreichbar." -ForegroundColor red
 Write-Host
 Write-Host "Ping:" $TestPing
 Write-Host "Administrative Freigabe:" $TestAdmin
 exit   # das Skript beenden
}

Write-Host "Der Rechner ist erreichbar." -ForegroundColor green

# Computername mit Domain aus DNS
$Hostname = [System.Net.Dns]::GetHostEntry($Computer).HostName
Write-Host
Write-Host "Hostname:" $Hostname
Write-Host

$Company = (Get-WmiObject -class win32_ComputerSystem -computername $Computer).Manufacturer
$Model = (Get-WmiObject -class win32_ComputerSystem -computername $Computer).Model
Write-Host "Modell:" $Company $Model

$OS = (Get-WmiObject -class win32_OperatingSystem -computername $Computer)
Write-Host "Betriebssystem:" $OS.Caption

$Arch = (Get-WmiObject Win32_OperatingSystem -computername $Computer).OSArchitecture

if (!$Arch)
{
 $Arch = (Get-WmiObject Win32_ComputerSystem -computername $Computer).SystemType
}

Write-Host "Betriebssystem-Architektur:" $Arch
Write-Host
Write-Host "Boot-Device:" $OS.bootdevice
Write-Host "System-Device:" $os.systemdevice
Write-Host "System-Directory:" $os.systemdirectory
Write-Host "Build-Type:" $os.buildtype
Write-Host

# Nachfolgender Befehl mit einem Gravis-Zeichen oder in einer Zeile
$Rolle = Get-WmiObject -Class win32_ComputerSystem -namespace "root\CIMV2"  `
 -computername $Computer

switch ($Rolle.domainRole)
{
 0 { Write-Host "Der Rechner $Computer ist eine Standalone-Workstation." }
 1 { Write-Host "Der Rechner $Computer ist eine Member-Workstation." }
 2 { Write-Host "Der Rechner $Computer ist ein Standalone-Server." }
 3 { Write-Host "Der Rechner $Computer ist ein Member-Server." }
 4 { Write-Host "Der Rechner $Computer ist ein Backup domain controller." }
 5 { Write-Host "Der Rechner $Computer ist ein Primary domain controller." }
 default { Write-Host "Die Rolle von $Computer konnte nicht ermittelt werden." }
}

$Info = Get-WmiObject -Class Win32_OperatingSystem -computername $Computer
$Start = $Info.ConvertToDateTime($Info.LastBootUpTime)
$Time = (Get-Date) - $Start
Write-Host
Write-Host "Startzeit:" $Start.ToString()

# Nachfolgender Befehl mit einem Gravis-Zeichen oder in einer Zeile
Write-Host "Laufzeit:" $Time.Days "Tage," $Time.Hours "Stunden," $Time.Minutes "Minuten,"  `
 $Time.Seconds "Sekunden"

Write-Host
Write-Host "BIOS:" -ForegroundColor green
Write-Host

$BIOS = Get-WmiObject -class "WIN32_bios" -computername $Computer
Write-Host $BIOS.Manufacturer $BIOS.Name $BIOS.Version $BIOS.SerialNumber

Write-Host
Write-Host "Grafik-Karten:" -ForegroundColor green
Write-Host

$Grafik = Get-WmiObject -class "Win32_VideoController" -computername $Computer

foreach ($Item in $Grafik)
{
  # Nachfolgender Befehl mit einem Gravis-Zeichen oder in einer Zeile
  Write-Host $Item.Name $Item.VideoModeDescription `
   "; Treiber:" $Item.DriverVersion $Item.DriverDate
}

Write-Host
Write-Host "Prozessoren:" -ForegroundColor green
Write-Host

$CPUs = Get-WmiObject -class "Win32_Processor" -namespace "root/CIMV2" -computername $Computer

foreach ($Item in $CPUs)
{
  # Nachfolgender Befehl mit einem Gravis-Zeichen oder in einer Zeile
  Write-Host $Item.DeviceID ":" $Item.Name ", Kerne:" $Item.NumberOfCores  `
   ", Max. Speed:" $Item.MaxClockSpeed ", Status:" $Item.Status
}

Write-Host
Write-Host "Auslastung der Kerne:" -ForegroundColor green
Write-Host

$Auslastung = Get-WmiObject Win32_PerfFormattedData_PerfOS_Processor

foreach ($Item in $Auslastung)
{
  Write-Host "Kern:" $Item.Name "Last % benutzt:" (100-$Item.PercentIdleTime)
}

Write-Host
Write-Host "TCP/IP aus DNS:" -ForegroundColor green
Write-Host

$IP = [System.Net.Dns]::GetHostEntry($Computer).AddressList  # für IPv6 und IPv4

foreach ($Item in $IP)
{
 Write-Host $Item
}

Write-Host
Write-Host "Netzwerk-Karten (mit TCP/IP):" -ForegroundColor green
Write-Host

# Nachfolgender Befehl mit einem Gravis-Zeichen oder in einer Zeile
$NIC = Get-Wmiobject Win32_NetworkAdapterConfiguration -Filter "IPEnabled=true"  `
  -computername $Computer

foreach ($Item in $NIC)
{
 Write-Host $Item.Description "TCP/IP:" $Item.IPAddress
}

Write-Host
Write-Host "Netzwerk-Adapter (auch virtuell):" -ForegroundColor green
Write-Host

$Adapter = $null
# Nachfolgender Befehl mit einem Gravis-Zeichen oder in einer Zeile
$Adapter = Get-WmiObject -class win32_networkadapter -computername $Computer  `
  -ErrorAction SilentlyContinue  # -filter "PhysicalAdapter='TRUE'"

If ($Adapter -ne $null)
{
 foreach ($Item in $Adapter)
 {
   $Ausgabe = "Device-ID: " + $Item.DeviceID + " " + $Item.Name

   If ($Item.AdapterType -ne $null)
  {
    $Ausgabe = $Ausgabe + " Type: " + $Item.AdapterType
  }

   If ($Item.MACAddress -ne $null)
  {
    $Ausgabe = $Ausgabe + " MAC-Adresse: " + $Item.MACAddress
  }

  Write-Host $Ausgabe
 }
}
Else
{
  Write-Host "Die Eigenschaften konnten nicht ermittelt werden." -ForegroundColor red
}

Write-Host
Write-Host "Ping:" -ForegroundColor green
Write-Host

Ping = Get-WmiObject -Query "SELECT * FROM Win32_PingStatus WHERE Address = '$Computer'"

# Nachfolgender Befehl mit einem Gravis-Zeichen oder in einer Zeile
Write-Host "Adresse:" $Ping.protocoladdress "Status:" $Ping.statuscode  `
 "Antwortzeit:" $Ping.responsetime "ms"

Write-Host
Write-Host "Interne Laufwerke:" -ForegroundColor green
Write-Host

$Disks = Get-WmiObject -class win32_logicaldisk -computername $Computer |
 Where-Object {$_.drivetype -eq 3}

foreach ($Item in $Disks)
{
 $Item.Size = $Item.Size/1GB

 $Item.FreeSpace = $Item.FreeSpace/1GB

  $DiskPercentFree = ($Item.FreeSpace / $Item.Size) * 100
  $DiskPercentFree = [Math]::Round($DiskPercentFree, 2)

  # Nachfolgender Befehl mit einem Gravis-Zeichen oder in einer Zeile
  Write-Host $Item.DeviceID "Volume:" $Item.VolumeName `
   " Gesamt:" $Item.Size "GB; Frei:" $Item.FreeSpace "GB Frei:" $DiskPercentFree "%"
}

Write-Host
Write-Host "RAM:" -ForegroundColor green
Write-Host

# Nachfolgender Befehl mit einem Gravis-Zeichen oder in einer Zeile
$RAMtotal = (Get-WmiObject -class win32_OperatingSystem `
 -computername $Computer).TotalVisibleMemorySize

# Nachfolgender Befehl mit einem Gravis-Zeichen oder in einer Zeile
$RAMfree = (Get-WmiObject -class win32_OperatingSystem `
 -computername $Computer).FreePhysicalMemory

$RAMPercentFree = ($RAMfree / $RAMtotal) * 100

$RAMtotal = $RAMtotal/1KB
$RAMtotal = [Math]::Round($RAMtotal, 3)

$RAMfree = $RAMfree/1KB
$RAMfree = [Math]::Round($RAMfree, 3)

$RAMPercentFree = [Math]::Round($RAMPercentFree, 2)

Write-Host "Gesamt:" $RAMtotal "MB; Frei:" $RAMfree "MB; Frei:" $RAMPercentFree "%"
Write-Host

Write-Host "Bezeichnung Bank Hersteller Kapazität Geschwindigkeit"

$Bank = get-wmiobject win32_physicalmemory -computername $Computer

foreach ($Item in $BANK)
{
  # Nachfolgender Befehl mit einem Gravis-Zeichen oder in einer Zeile
  Write-Host $Item.tag, $Item.banklabel, $Item.devicelocator, $Item.Manufacturer, `
   $Item.PartNumber, $Item.capacity, $Item.speed
}

Write-Host
Write-Host "Auslagerungsdatei:" -ForegroundColor green
Write-Host

$PF = Get-WmiObject -Query "SELECT * FROM Win32_PageFileUsage" -computername $Computer

foreach ($Item in $PF)
{
 $PFtotal = $Item.AllocatedBaseSize
 $PFused = $Item.CurrentUsage

 $PFPercentUsed = ($PFused / $PFtotal) * 100
 $PFPercentUsed = [Math]::Round($PFPercentUsed, 2)

  # Nachfolgender Befehl mit einem Gravis-Zeichen oder in einer Zeile
  Write-Host $Item.Name " Gesamt:" $PFtotal "MB; Benutzt:" $PFused "MB;" `
   " Benutzt:" $PFPercentUsed "%"
}

Write-Host
Write-Host "Drucker:" -ForegroundColor green
Write-Host

$Drucker = Get-WmiObject -Class Win32_Printer -computername $Computer

foreach ($Item in $Drucker)
{
 Write-Host $Item.Name
}

Write-Host
Write-Host "Freigaben:" -ForegroundColor green
Write-Host

$Freigaben = Get-WmiObject -Class Win32_Share -computername $Computer

foreach ($Item in $Freigaben)
{
 Write-Host $Item.Name " " $Item.Path
}

Write-Host
Write-Host "Die folgenden Dienste mit der Startart 'automatisch' sind gestoppt:" -ForegroundColor green
Write-Host

$Services = Get-WmiObject -Class Win32_Service -computername $Computer |
 Select-Object StartMode, State, DisplayName, Name |
 Where-Object {$_.StartMode -eq "Auto" -and $_.State -eq "Stopped"}

If ($Services -ne $null)
{
 foreach ($Item in $Services)
 {
   Write-Host $Item.StartMode $Item.State $Item.DisplayName " " $Item.Name
 }
}
Else
{
 Write-Host "Alle automatischen Dienste laufen."
}

# Ende des Scripts bei Windows XP
if ((Get-WmiObject -class win32_OperatingSystem -computername $Computer).Caption -match 'XP') { exit }

Write-Host
Write-Host "Autostart-Programme:" -ForegroundColor green

$Autostart = Get-Wmiobject Win32_StartupCommand -computername $Computer

foreach ($Item in $Autostart)
{
 Write-Host
 Write-Host $Item.Name $Item.Location $Item.Command
}

Write-Host
Write-Host "Leistungs-Index:" -ForegroundColor green
Write-Host

$Leistung = gwmi win32_winsat -ComputerName $Computer

Write-Host "Total:" $Leistung.WinSPRLevel
Write-Host "CPU:" $Leistung.CPUScore
Write-Host "RAM:" $Leistung.MemoryScore
Write-Host "Grafik:" $Leistung.GraphicsScore
Write-Host "Grafik 3D:" $Leistung.D3DScore
Write-Host "Disk1:" $Leistung.DiskScore

Skript zum Anzeigen der Computer-Konten im Active Directory

# Computer-Konten.ps1

# Domäne und Kontext anpassen
$objDomain = [adsi] ("LDAP://CN=Computers,dc=Firma,dc=local")
# $objDomain = [adsi] ("LDAP://OU=Domain Controllers,dc=Firma,dc=local")
# $objDomain = [adsi] ("LDAP://OU=Servers,dc=Firma,dc=local")

$objSearcher = New-Object System.DirectoryServices.DirectorySearcher
$objSearcher.SearchRoot = $objDomain
$objSearcher.PageSize = 1000
$objSearcher.Filter = '(objectClass=Computer)'
$colResults = $null
$colResults = $objSearcher.FindAll()

foreach ($Item in $colResults)
{
 $Server = $null; $OS = $null;

 [string]$Server = $Item.properties.name
 $OS = $Item.Properties.operatingsystem

 Write-Host $Server $OS
}

Skript zum Ermitteln der Rolle eines Computers

# Computerrolle - Eingabe.ps1

# Meldung ohne :
$Computer = Read-Host "Bitte den Namen des Computers eingeben"  

$objWMI = Get-WmiObject -Class win32_ComputerSystem -computername $Computer

switch ($objWMI.domainRole)
{
 0 { Write-Host "Der Rechner $Computer ist eine Standalone-Workstation." }
 1 { Write-Host "Der Rechner $Computer ist eine Member-Workstation." }
 2 { Write-Host "Der Rechner $Computer ist ein Standalone-Server." }
 3 { Write-Host "Der Rechner $Computer ist ein Member-Server." }
 4 { Write-Host "Der Rechner $Computer ist ein Backup domain controller." }
 5 { Write-Host "Der Rechner $Computer ist ein Primary domain controller." }
 default { Write-Host "Die Rolle von $Computer konnte nicht ermittelt werden." }
}

Skript zum Anzeigen der Spezial-Ordner von Windows

# für Desktop-Verknüpfungen mit shell:Ordner
$k = 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\FolderDescriptions'

dir $k | gpv -Name Name | sort

pause

Skript zum Sichern eines Pfades mit Unterverzeichnissen
in einen Ordner mit Zeitstempel:

# Backup.ps1

$NowDate = Get-Date -format "yyyy.MM.dd HH.mm.ss"

$BackupPath = "s:\Backup\$NowDate"

New-Item -Path $BackupPath -ItemType "Directory"

Copy-Item -Path d:\Homepage -Destination $BackupPath -recurse -force

Write-Host
Write-Host "Folgende Pfade wurden gesichert:" -ForegroundColor green
Write-Host

Get-ChildItem -Path $BackupPath -recurse -force | Where-Object { $_.mode -match "d" } |
 Foreach-Object { Write-Host $_.FullName -ForegroundColor green }

Skript zum Auslesen der Ereignis-Anzeige

# EventLog.ps1 - Fehler und Warnungen im System-Protokoll

$Computer = "PC-Maier"  # den Computername anpassen

$Events = Get-EventLog -computername $Computer -LogName System -EntryType Error, Warning |
 Select-Object EventID, Source, EntryType, TimeGenerated, Message |
 Sort-Object TimeGenerated -Descending

foreach ($Item in $Events)
{
 Write-Host
 Write-Host $Item.TimeGenerated $Item.EventID $Item.Source $Item.EntryType
 Write-Host $Item.Message
}

Skript mit der Übergabe von Parametern

# Temperatur-Parameter.ps1 - Uebergabe von Parametern an ein Skript

param(
[decimal]$Temperatur = 25.5,
[switch]$Fahrenheit = $false,
[string]$Ort = "Stuttgart"
)

Write-Host

If ($Fahrenheit -eq $false)
{
 Write-Host "Es sind $Temperatur Grad Celsius in $Ort."
 $TemperaturF = ($Temperatur * 1.8 + 32)
 Write-Host "Es sind $TemperaturF Grad Fahrenheit in $Ort."
}
Else
{
 $TemperaturF = $Temperatur
 Write-Host "Es sind $TemperaturF Grad Fahrenheit in $Ort."
 $Temperatur = (($TemperaturF - 32) * 5/9)
 Write-Host "Es sind $("{0:#.00}" -f $Temperatur) Grad Celsius in $Ort."
}

# Starten ohne Parameter:  .\Temperatur-Parameter.ps1
# Starten Celsius:  .\Temperatur-Parameter.ps1 -Temperatur 18.3 -Ort Bonn
# Starten Fahrenheit:  .\Temperatur-Parameter.ps1 -Temperatur -5.63 -Ort Boston -Fahrenheit

Durchschnitt, Maximum, Minimum und Summe der Daten aus einer Datei

# Statistik.ps1 - Einlesen einer CSV-Datei

Write-Host
Get-Content .\Statistik.txt

Import-Csv .\Statistik.txt | Measure-Object Temperatur -ave -max -min -sum

<# Inhalt der Datei Statistik.txt
Ort,Temperatur
Berlin,20
Hamburg,13
Stuttgart,25
Dresden,22
#>

Zähler in eine Datei fortschreiben

$ZaehlDatei = "C:\Zaehler.txt"

if (Test-Path $ZaehlDatei) {
 # $ZaehlDatei existiert, Zähler in Datei hochzählen
 # erste Zeile einlesen, hochzählen und zurückschreiben
 [int]$(Get-Content $ZaehlDatei -TotalCount 1) + 1 | Out-File $ZaehlDatei -Force
}
else {
 # $ZaehlDatei existiert nicht, Datei mit dem Wert 1 erstellen
 1 | Out-File $ZaehlDatei -Force
}

# Anzahl aus der Datei auslesen
Get-Content $ZaehlDatei -TotalCount 1

Allgemeines

Herunterfahren des Rechners
Stop-Computer
(Get-WmiObject -Class Win32_OperatingSystem -ComputerName .).Win32Shutdown(1)

Neustart des Rechners
Restart-Computer
Restart-Computer -Force
Restart-Computer -computername Server01, Server02
(Get-WmiObject -Class Win32_OperatingSystem -ComputerName .).Win32Shutdown(2)

Abmelden
(Get-WmiObject -Class Win32_OperatingSystem -ComputerName .).Win32Shutdown(0)

Starten eines Programms
Invoke-Item c:\windows\system32\calc.exe
Start calc

Anzeige einer Webseite im Internet Explorer
$ie = new-object -com "InternetExplorer.Application"
$ie.Navigate("https://www.uwelindner.de")
$ie.visible = $true

Umleiten der Ausgabe vom Prompt in eine Datei
Get-Process | Out-File c:\Daten\Prozess.txt -width 120

Umleiten mehrerer Ausgaben in eine Datei
# Prüfen, ob Pfad vorhanden, sonst anlegen
if (!(Test-Path "C:\temp"))
{
 New-Item -Path "C:\temp" -ItemType "Directory"
}
Clear-Host
Write-Host

$Computer = "."   # Computername anpassen !!!

if ($Computer -eq "" -Or $Computer -eq ".")
{
 $Computer = (Get-WmiObject Win32_Computersystem).name
}

# erste Ausgabe
$Computer | Out-File -FilePath "C:\temp\Computerlist.txt"

$Company = (Get-WmiObject -class win32_ComputerSystem -computername $Computer).Manufacturer
$Model = (Get-WmiObject -class win32_ComputerSystem -computername $Computer).Model
$Ausgabe = "Modell: " + $Company + $Model

# weitere Ausgaben mit append
Out-File -FilePath "C:\temp\Computerlist.txt" -append -InputObject $Ausgabe

$OS = (Get-WmiObject -class win32_OperatingSystem -computername $Computer)
$Ausgabe = "Betriebssystem: " + $OS.Caption

# weitere Ausgaben mit append
Out-File -FilePath "C:\temp\Computerlist.txt" -append -InputObject $Ausgabe

# Anzeige des Inhalts der Datei
Get-Content -Path "C:\temp\Computerlist.txt"

Umleiten der Ausgabe vom Prompt auf den Standard-Drucker
Get-Process | Out-Printer

Prozesse am Prompt anzeigen und in einer Datei speichern
get-process | tee-object -filepath C:\Daten\Process.txt

Ausgabe in Tabellenform am Bildschirm
Get-ChildItem | out-gridview
Get-ChildItem c:\ -Recurse -Force -Include *.log | Format-Table

Ausgabe in eine HTML-Datei
Get-Process | convertTo-Html -title "Alle Prozesse" > process.html

get-service | ConvertTo-Html -Property Name,Status | foreach {
if ($_ -like "*<td>Running</td>*") {$_ -replace "<tr>", "<tr bgcolor=green>"}
else {$_ -replace "<tr>", "<tr bgcolor=red>"}} > .\get-service.html

Anzeige der verfügbaren Laufwerke (auch der Registry)
Get-PSDrive
(mit Ausgabe vom freien und belegten Plattenplatz)

Neues Laufwerk FK: für c:\Pfad erzeugen
New-PSdrive -name FK -psprovider FileSystem -root c:\Pfad

Neues Laufwerk FK: wieder entfernen
Remove-PSDrive FK

Wechseln in einen Pfad der Registry
cd hklm:\software
Set-Location hkcu:\software\microsoft\windows

Anzeigen von Elementen der Registry
Get-ChildItem HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall
Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\AcroRd32.exe"

Wechseln zu den Umgebungsvariablen
Set-Location env:\

Anzeigen der Umgebungsvariablen
Get-ChildItem env:
$env:Path

Wechseln in das Laufwerk vom Active Directory
cd AD:

danach zur Domäne wechseln
cd "dc=test,dc=global"

danach in die Organisations-Einheit wechseln
cd "ou=Personal"

danach eine neue Organisations-Einheit erstellen
md "ou=Azubi"

Zurück in das Root-Verzeichnis wechseln
cd c:

Zufallszahl
$Lotto = New-Object System.Random
$Zahl = $Lotto.next(1,49)

Einlesen eines Kennwortes vom Prompt in eine Variable
# Meldung ohne :
$neuesPassword = (Read-Host -Prompt "Neues Kennwort" -AsSecureString)

Eingabe eines Datums
# Meldung ohne :
$Input = Read-Host "Bitte geben Sie ein Datum ein"
$Datum = [DateTime]::Parse($Input)

DOS-Befehl pause
# funktioniert nicht in PowerShell ISE
Write-Host
Write-Host "Press any key to continue ..."

$x = $host.UI.RawUI.ReadKey("NoEcho,IncludeKeyDown")

Ausgabe einer Warnung
write-warning "Error"
WARNUNG: Error wird in orange ausgegeben.

Message-Box mit einer Meldung anzeigen
[System.Windows.Forms.MessageBox]::Show("Meldung")

Message-Box mit Ja / Nein
$yes = New-Object System.Management.Automation.Host.ChoiceDescription "&Ja",""
$no = New-Object System.Management.Automation.Host.ChoiceDescription "&Nein",""
$choices = [System.Management.Automation.Host.ChoiceDescription[]]($yes,$no)
$caption = "Warnung!"
$message = "Wollen Sie fortfahren"

$result = $Host.UI.PromptForChoice($caption,$message,$choices,0)

if($result -eq 0) { Write-Host "Ihre Antwort lautet: Ja" }
if($result -eq 1) { Write-Host "Ihre Antwort lautet: Nein" }

Message-Box mit Abbrechen
# Nachfolgender Befehl mit einem Gravis-Zeichen oder in einer Zeile
$Result = [System.Windows.Forms.MessageBox]::Show("Meldung ?","Titel",3,  `
 [System.Windows.Forms.MessageBoxIcon]::Exclamation)

If ($Result -eq "Yes")
{
 "Antwort: Ja"
}
elseif ($Result -eq "No")
{
 "Antwort: Nein"
}
else
{
 "Antwort: Abbrechen"
}

Fortschrittsbalken
$activity = "Ein langer Prozess"
$status = "Initialisierung"

for ($counter = 0; $counter -lt 100; $counter++)
{
 $currentOperation = "Zähler: $counter"

  # Nachfolgender Befehl mit einem Gravis-Zeichen oder in einer Zeile
 Write-Progress $activity $status  `
   -PercentComplete $counter -CurrentOperation $currentOperation

 Start-Sleep -m 20
}

Funktionen
function sum ([int]$a, [int]$b)
{
 return $a + $b
}

sum 4 5  # am Bildschirm erscheint eine 9

$Wert = sum 3 67
Write-Host $Wert

$x=43
$y=123

$Wert = sum $x $y
Write-Host $Wert

Function netto_in_brutto
{
 param($netto, $ust_satz=19)

 $netto * ( 1 * (1 + $ust_satz / 100) )
}

netto_in_brutto -ust_satz 16 -netto 100
netto_in_brutto 50

# Architektur der Powershell
function Get-Bits() {
 Switch ([IntPtr]::Size) {
  4 {
   Return "32-bit"
  }

  8 {
   Return "64-bit"
  }

  default {
   Return "Unknown Type"
  }
 }
}

Get-Bits

Anzeige aller Benutzerkonten
wmic useraccount list full

Anzeige des aktuell angemeldeten Benutzers
[System.Security.Principal.WindowsIdentity]::GetCurrent()
[System.Security.Principal.WindowsIdentity]::GetCurrent().Name

# Nachfolgender Befehl mit einem Gravis-Zeichen oder in einer Zeile
$username = (get-wmiobject -class win32_computersystem `
 -computername $computer).username

Test des aktuell angemeldeten Benutzers auf Admin-Rechte
# Admin.ps1 - Wenn Admin wird das Fenster rot eingefärbt

function Admin-Test() {
$identity = [System.Security.Principal.WindowsIdentity]::GetCurrent()
$princ = New-Object System.Security.Principal.WindowsPrincipal($identity)
return $princ.IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator)
}

$ui = (Get-Host).UI.RawUI  # Konsole
Admin-Test  # Aufruf der Funktion

if(Admin-Test)
 {$ui.BackgroundColor= "Darkred"}

Anzeige aller angemeldeten Benutzer
$Computer = "Server01"

$SessionIDs=get-wmiObject -class "win32_logonsession" -namespace "root\CIMV2" -computer $Computer

$SessionIDs | %{
 $query="Associators of {win32_logonsession.LogonID=$($_.LogonID)}"
 get-wmiobject -query $query -computer $Computer |
 ?{$_.__class -eq "Win32_UserAccount"} | select name, caption}

Letzte Anmeldung eines Benutzers
Get-WmiObject -class Win32_NetworkLoginProfile -Filter "name like '%Maier%'" |
 select Name, @{Name="Letzter Login";Expression={$_.ConvertToDateTime($_.LastLogon)}}

Anzeige der Zeit
Get-Date
Get-Date -format "yyyy.MM.dd HH.mm.ss"

Warten
Start-Sleep 20   # 20 Sekunden
Start-Sleep -s 10   # 10 Sekunden
Start-Sleep -m 2000   # 2000 Millisekunden

Ermitteln einer Zeit-Differenz
New-TimeSpan $(Get-Date) $(Get-Date -month 12 -day 31 -year 2010 -hour 23 -minute 30)

Anzeige der Start- und Laufzeit des Rechners
$Computer = "Maier-PC"  # den Computername anpassen

$Info = Get-WmiObject -Class Win32_OperatingSystem -computername $Computer
$Start = $Info.ConvertToDateTime($Info.LastBootUpTime)
Write-Host "Startzeit: "$Start.ToString()

$Time = (Get-Date) - $Start
# Nachfolgender Befehl mit einem Gravis-Zeichen oder in einer Zeile
Write-Host "Laufzeit:" $Time.Days "Tage," $Time.Hours "Stunden," $Time.Minutes "Minuten,"  `
 $Time.Seconds "Sekunden"

Anzeige der Startart von Windows ab Version 8
# 0x0 - Normaler Start nach einem vollständigen Shutdown.
# 0x1 - Schnellstart nach einem hybriden Shutdown.
# 0x2 - Fortsetzen aus dem Ruhezustand.

# Nachfolgender Befehl mit einem Gravis-Zeichen oder in einer Zeile
Get-WinEvent -ProviderName Microsoft-Windows-Kernel-boot -MaxEvents 60 |  `
 Where-Object {$_.id -like "27"};

Anzeige des Computernamens
$(Get-WmiObject Win32_Computersystem).name
$SystemName = (New-Object -ComObject WScript.Network).computername

Ermittlung des Computernamens aus der Umgebungsvariablen
$Computer = gc env:computername

Anzeige des Computernamens mit der Domäne aus DNS
[System.Net.Dns]::GetHostEntry("PC-Maier").HostName  # den Computername anpassen

Ermitteln des Namens der Domäne
$DNSEntity = [Net.Dns]::GetHostEntry($Computer)
$Domain = ($DNSEntity.hostname).replace("$Computer.","")

Ermitteln des Namens der User-Domäne
$DomainName = (New-Object -ComObject WScript.Network).userDomain

Anzeige der MAC-Adresse
getmac

Anzeige der Netzwerk-Karten mit TCP/IP
Get-Wmiobject Win32_NetworkAdapterConfiguration -Filter "IPEnabled=true" |
 select Description,IPAddress

Anzeige der physikalischen Netzwerk-Karten
gwmi win32_networkadapter -filter "PhysicalAdapter='TRUE'"

Device-ID einer virtuellen Netzwerk-Karte ermitteln
gwmi win32_networkadapter -filter "PhysicalAdapter='FALSE'" | select Name, DeviceID | fl

Anzeige von Informationen zum Computer
gwmi win32_ComputerSystem
(Domäne, Hersteller, Modell, Name, Hauptbesitzer und RAM)

Anzeige des Betriebssystems
(Get-WmiObject Win32_OperatingSystem).Caption
(Get-WmiObject Win32_OperatingSystem).Name

Anzeige der Architektur des Betriebssystems
(Get-WmiObject Win32_OperatingSystem).OSArchitecture

Test auf 64bit-Version der Powershell
[Environment]::Is64BitProcess

Informationen zum BIOS
Get-CimInstance Win32_BIOS

get-wmiobject win32_bios

$BIOS = Get-WmiObject -class "WIN32_bios"
Write-Host $BIOS.Manufacturer $BIOS.Name $BIOS.Version $BIOS.SerialNumber

Informationen zum Motherboard
Get-CimInstance Win32_BaseBoard

Informationen zu den Prozessoren
$CPUs = Get-WmiObject -class "Win32_Processor" -namespace "root/CIMV2"

foreach ($Item in $CPUs)
{
 Write-Host
 Write-Host "CPU ID: " -foregroundcolor yellow -NoNewLine
 Write-Host $objItem.DeviceID -foregroundcolor white
 Write-Host "CPU Model: " -foregroundcolor yellow -NoNewLine
 Write-Host $objItem.Name -foregroundcolor white
 Write-Host "CPU Cores: " -foregroundcolor yellow -NoNewLine
 Write-Host $objItem.NumberOfCores -foregroundcolor white
 Write-Host "CPU Max Speed: " -foregroundcolor yellow -NoNewLine
 Write-Host $objItem.MaxClockSpeed
 Write-Host "CPU Status: " -foregroundcolor yellow -NoNewLine
 Write-Host $objItem.Status
}

Anzeige der Festplatten (physikalischen Laufwerke)
Get-WmiObject -Class Win32_DiskDrive

Anzeige der Festplatten-Belegung (logische Laufwerke)
gwmi win32_logicaldisk
Get-WmiObject Win32_LogicalDisk | Format-List *

Anzeige der lokalen Festplatten-Belegung
gwmi win32_logicaldisk -filter "drivetype = 3"

Anzeige des freien Platzes auf den lokalen Festplatten
gwmi win32_logicaldisk -filter "drivetype = 3" | select deviceid,freespace
gwmi win32_logicaldisk -filter "drivetype = 3" | % { $_.deviceid; $_.freespace/1GB }

Informationen zu den Partitionen der Festplatten
gwmi Win32_DiskPartition
gwmi Win32_DiskPartition |
 select deviceID, @{Name="GPT";Expression={$_.Type.StartsWith("GPT")}}

Anzeige der Clustergröße von Laufwerk C:
(Get-Volume C).AllocationUnitSize

Informationen zur Auslagerungsdatei
Get-WmiObject -Query "SELECT * FROM Win32_PageFileUsage"
Get-WmiObject -Class Win32_ComputerSystem | % {$_.AutomaticManagedPagefile}

$PF = gwmi Win32_PageFileUsage
$PF.Name
$PF.AllocatedBaseSize
$PF.CurrentUsage

Informationen zum Hauptspeicher
(Get-WmiObject -class win32_OperatingSystem).TotalVisibleMemorySize
(Get-WmiObject -class win32_OperatingSystem).FreePhysicalMemory

get-wmiobject win32_physicalmemory |
 format-format-table tag, banklabel, devicelocator, Manufacturer, PartNumber, capacity, speed

Informationen zu den Treibern
Get-WmiObject Win32_SystemDriver

Informationen zur Grafikkarte
Get-Wmiobject Win32_VideoController

Leistungsindex anzeigen
gwmi win32_winsat

$Leistung = gwmi win32_winsat
Write-Host "Total:" $Leistung.WinSPRLevel
Write-Host "CPU:" $Leistung.CPUScore
Write-Host "RAM:" $Leistung.MemoryScore
Write-Host "Grafik:" $Leistung.GraphicsScore
Write-Host "Grafik 3D:" $Leistung.D3DScore
Write-Host "Disk1:" $Leistung.DiskScore

Informationen zum Monitor
gwmi Win32_DesktopMonitor

Informationen zu den Freigaben
Get-WmiObject Win32_Share

Eine Freigabe erstellen für 25 Benutzer
(Get-WmiObject -List -ComputerName . |
 Where-Object -FilterScript {$_.Name -eq "Win32_Share"}).Create("C:\test","Test",0,25,"Test-Freigabe")

Mit einer Freigabe verbinden
(New-Object -ComObject WScript.Network).MapNetworkDrive("V:", "\\Server\Freigabe")

Informationen zur installierten Software
get-wmiobject win32_product

Get-WmiObject -Class Win32_Product |
 Where-Object {$_.Name -like "Microsoft .NET*"} |
 Format-Table name, version

Informationen zur Boot-Konfiguration
Get-Wmiobject Win32_BootConfiguration

Windows reparieren wie DISM
Repair-WindowsImage -Online -CheckHealth
Repair-WindowsImage -Online -ScanHealth
Repair-WindowsImage -Online -RestoreHealth

Anzeige der Dienste
Get-Service

Get-service | group-object status

Get-WmiObject -Class Win32_Service -computername $Computer |
 Select-Object StartMode, State, DisplayName, Name |
 Sort-Object StartMode, State

Get-WmiObject -Class Win32_Service -computername $Computer |
 Select-Object StartMode, State, DisplayName, Name |
 Where-Object {$_.StartMode -eq "Auto" -and $_.State -eq "Stopped"}

Anzeige der Prozesse
Get-Process
Get-Process | where {$_.Company -like "Microsoft*"}
Get-Process | sort CPU | select -last 5
Get-process | sort-object -property WS -Descending | select-object -First 10

Stoppen eines Prozesses
Stop-Process
spps -n excel
gps calc | Stop-Process -Confirm
Get-Process | where { $_.WS -gt 10MB } | Stop-Process

Überwachung der Prozessor-Auslastung für alle Prozesse für 10 Sekunden
get-counter "\prozess(*)\prozessorzeit (%)" -maxsamples 10

Andere Überwachungs-Parameter anzeigen
get-counter -listset *

Anzeige von Ereignissen im System-Protokoll
Get-Eventlog System | where {$_.EventID -eq 1000}

Get-EventLog -LogName System -EntryType Error, Warning |
 Select-Object EventID, Source, EntryType, TimeGenerated, Message |
 Sort-Object TimeGenerated -Descending

Anzeige von Ereignissen im Anwendungs-Protokoll
Get-Eventlog application | where {$_.EventID -eq 1000}

Log-Datei zu den Windows-Updates auf dem Desktop
Get-WindowsUpdatelog

Prüfung auf Sperrung einer bestimmten Software auf einem Computer
Import-Module AppLocker

Get-AppLockerPolicy -Effective -XML > C:\Effective.xml

Get-ChildItem 'C:\Program Files\Microsoft Office\' -filter *.exe -Recurse | Convert-Path |
 Test-AppLockerPolicy -XMLPolicy C:\Effective.xml -User Test\Maier
 -Filter Denied,DeniedByDefault |
 Export-CSV C:\BlockedFiles.csv

Hash von Dateien berechnen
Get-FileHash *.zip -Algorithm MD5

Drucker

Informationen zu den installierten Druckern
$Drucker = Get-WmiObject -Class Win32_Printer

foreach ($Item in $Drucker)
{
 Write-Host $Item.Name
}

Standard-Drucker festlegen
(Get-WmiObject -ComputerName . -Class Win32_Printer -Filter "Name='HP LaserJet 5'").SetDefaultPrinter()

Weitere Infos zum Drucken:
Win32_Printer – Druckerwarteschlangen
Win32_PrintJob – Druckjobs
Win32_PrinterDriver – alle Treiber, die installiert sind
Win32_TCPIPPrinterPort – IP-Ports
Win32_PrinterConfiguration – Druckerkonfiguration
Win32_PrinterSetting – Druckerinformationen zu allen Druckern
Win32_PrinterShare – Freigaben der Drucker
Win32_PrinterDriverDll – installierte DLLs

TCP/IP

Befehle zur Konfiguration von TCP/IP
Get-Command -Module NetTCPIP

Anzeige der TCP/IP-Adressen
Get-NetIPAddress | Format-Table

Get-NetIPAddress |
Where-Object PrefixOrigin -eq dhcp |
Select-Object -Property IPAddress, InterFaceAlias

$IP = [System.Net.Dns]::GetHostEntry($Computer).AddressList

Ping
Test-Connection -computername $Computer
Test-Connection -count 1 -computername $Computer
Test-Connection -computername $Computer -quiet

Anzeige des Ergebnisses eines Pings zum Rechner
$Computer = "Maier-PC"  # den Computername anpassen

$Ping = Get-WmiObject -Query "SELECT * FROM Win32_PingStatus WHERE Address = '$Computer'"

Write-Host $Ping
Write-Host "Antwortzeit:" $Ping.ResponseTime "ms"
Write-Host "TCP/IP:" $Ping.IPV4Address.IPAddressToString

If ($Ping.ResponseTime -ne $null)
{
 Write-Host "Rechner ist an." -ForegroundColor green
}
Else
{
 Write-Host "Rechner ist aus." -ForegroundColor red
}

TCP/IP konfigurieren (Windows 7)
Anzeige vom Index der Netzwerk-Karte:
Get-WMIObject Win32_NetworkAdapterConfiguration -filter IPenabled=true

Auswählen der Netzwerk-Karte über den Index:
$NIC = gwmi Win32_NetworkAdapterConfiguration -filter "index='0'"

DHCP aktivieren:
$NIC.EnableDHCP

Feste TCP/IP-Nummer setzen:
$NIC.EnableStatic("192.168.1.20", "255.255.255.0")
$NIC.SetGateways("192.168.1.254")
$NIC.SetDNSServerSearchOrder("192.168.1.10", "192.168.1.11")

TCP/IP konfigurieren (Windows 8 und 10, Windows Server 2012)
Anzeige vom Index der Netzwerk-Karte:
Get-NetAdapter|select ifDesc, ifAlias, ifIndex, MediaType | fl

Anzeige der Konfiguration der Netzwerk-Karte:
Get-NetIPConfiguration -ifAlias "Ethernet" -Detailed

DHCP aktivieren:
Set-NetIPInterface -ifAlias Ethernet -DHCP Enabled

Feste TCP/IP-Nummer setzen:
# Nachfolgender Befehl mit einem Gravis-Zeichen oder in einer Zeile
New-NetIPAddress -ifAlias Ethernet -IPAddress 192.168.1.21  `
 -PrefixLength 24 -DefaultGateway 192.168.1.254
# Nachfolgender Befehl mit einem Gravis-Zeichen oder in einer Zeile
Set-DnsClientServerAddress -InterfaceAlias "Ethernet"  `
 -ServerAddresses ("192.168.1.10", "192.168.1.11")

DNS-Test eines Rechners
resolve-dnsname IP-Adresse

Test der DNS-Server
resolve-dnsname -type all "DNS-Zone"

Windows-Firewall

Befehle zur Firewall
Get-Command -Module Netsecurity

Anzeigen der aktiven Firewall-Regeln
Show-NetFirewallRule -Policystore ActiveStore

Ausschalten der Windows-Firewall in allen Profilen
Set-NetFirewallProfile -Profile Domain,Public,Private -Enabled False

Einschalten der Windows-Firewall in allen Profilen
Set-NetFirewallProfile -Profile Domain,Public,Private -Enabled True

Dateien

Anzeige der Dateien inkl. in Unterverzeichnissen (DOS: dir /s)
Get-ChildItem -Recurse -Force # (evtl. mit -Force für gesperrte Dateien)

Anzeige aller Word-Dateien im Pfad Eigene Dateien
und den Unterverzeichnissen des Benutzers:
Get-ChildItem -Path $env:USERPROFILE -Filter *.doc -Recurse -Force

Suchen und Löschen aller Tmp-Dateien in einem Laufwerk
get-childitem -recurse c:\*.tmp | remove-item

Prüfen auf das Vorhandensein mit dem anschließenden Löschen einer Datei
if (Test-Path $strDatei) { Remove-Item $strDatei }

Test-Path \\$Computer\ADMIN$

Prüfen, ob der Pfad vorhanden ist, sonst diesen anlegen
if (!(Test-Path "C:\temp"))
{
 New-Item -Path "C:\temp" -ItemType "Directory"
}

Erstellen von Dateien, Ordnern und Registry-Schlüsseln
New-Item
New-Item -Path S:\Backup -ItemType "Directory"

Kopieren von Dateien, Ordnern und Registry-Schlüsseln
Copy-Item
Copy-Item -Path H:\Homepage -Destination S:\Backup -recurse -force

Verschieben von Dateien, Ordnern und Registry-Schlüsseln
Move-Item -path C:\Test.txt -destination E:\Temp\Test.txt
Move-Item -path C:\Temp -destination C:\Logs
Move-Item hklm:\software\Schlüssel\* hklm:\software\NeuerSchlüssel

Umbenennen von Dateien, Ordnern und Registry-Schlüsseln
# auch mit Umlauten im Gegensatz zum DOS-Befehl ren
Rename-Item -path C:\Temp\Test.txt -newname Test-alt.txt

Umbenennen der JPG-Dateien zu Bild.jpg mit einer fortlaufenden Nummer
Get-ChildItem *.jpg | ForEach-Object -begin { $count=1 }
 -process { rename-item $_ -NewName "Bild$count.jpg"; $count++ }

Entfernen der Punkte aus den Dateinamen (auch den für die Endung)
Get-ChildItem *.* | foreach {Rename-Item $_ -NewName $($_.name -replace '\.', $null)}

Verschieben von Text-Dateien auch aus den Unterverzeichnissen
Get-Childitem -path . -recurse -include *.txt | Move-Item -destination C:\TextFiles

Anzeige der Dateien mit einer Größe von mehr als 10.000.000 Byte
Get-ChildItem | where($_.Length -gt 10000000)

Anzeige der 5 größten mp3-Dateien auch in den Unterverzeichnissen
Get-Childitem -recurse -include *.mp3 |
 Sort-Object length -descending |
 Select-Object -first 5

Anzeige der 10 größten Dateien auch in den Unterverzeichnissen mit Größe in GB
gci -r | sort -descending -property length |
 select -first 10 name, @{Name="Gigabytes";Expression={[Math]::round($_.length / 1GB, 2)}}

Anzeige der Gesamtanzahl der Bytes aller Dateien in einem Verzeichnis
Get-ChildItem | Measure-Object -Property Length -Sum

Anzeige von Besitzer, Gruppe und Zugriffs-Rechten des aktuellen Pfades
Get-Acl | Format-List

Zugriffs-Rechte eines Pfades auf einen anderen übertragen
$acl = Get-Acl "C:\Program Files"
Set-Acl "D:\Programme" $acl

Anzeige des letzten Zugriffs
$(Get-Item computer.ps1).lastaccesstime

Anzeige der gestern bearbeiteten Dateien
Get-ChildItem -Recurse | Where-Object { $_.LastWriteTime -gt (Get-Date).AddDays(-1) }

Gruppieren der Dateien nach ihrer Endung
Get-ChildItem | Group-Object { $_.Extension }

Auslesen des Inhalts einer Text-Datei
get-content d:\Text.txt
Get-Content Test.txt -TotalCount 3 # nur die Zeilen 1 bis 3
(Get-Content Test.txt -TotalCount 3)[-1] # nur die Zeile 3

Suchen einer Zeichenkette in allen Text-Dateien eines Verzeichnisses
select-string C:\Text\*.txt -pattern "String"

Suchen einer Zeichenkette in allen Dateien außer PDFs auch in Unterverzeichnissen
Get-ChildItem *.* -exclude *.pdf -recurse | Select-String -Pattern "String"

Schreiben der ersten 100 Zeilen in eine neue Datei
get-content Bestenliste.txt -totalcount 100 | set-content Top100.txt

ZIP-Archiv erzeugen
Compress-Archive -Path *.txt -DestinationPath Texte.zip
dir *.ini | Compress-Archive -DestinationPath Config.zip

Sicherung

Cmdlets für Sicherung laden
Add-PSSnapin windows.serverbackup

New-WBPolicy
New-WBFileSpec
New-WBBackupTarget
Set-WBVssBackupOptions

Sicherung aller Gruppenrichtlinienobjekte, -berechtigungen und -verknüpfungen
Backup-Gpo -All -Path \\Server01\GPOBackup

Wiederherstellungspunkte eines Computers (Windows XP bis 10) ermitteln
Get-ComputerRestorePoint
Get-ComputerRestorePoint | format-table SequenceNumber, @{Label="Date";
 Expression={$_.ConvertToDateTime($_.CreationTime)}}, Description -auto

Wiederherstellung des Computers vom Wiederherstellungspunkt 255
Restore-Computer -RestorePoint 255

Prüfung der Wiederherstellung nach dem automatischen Neustart
Get-ComputerRestorePoint -LastStatus

Wiederherstellungspunkt erzeugen
Checkpoint-Computer -Description Datensicherung

Anzeige der Paketnamen der Metro-Apps (Windows 8 und 10)
Get-Appxpackage | ft packagefullName

E-Mail

Senden einer E-Mail mit einer Anlage im HTML-Format
$psEmailServer="ExchangeSrv.test.global"
send-mailmessage -to "mail@didier-cuche.ch" -from "Herrmann.Maier@test.global"
 -subject "Test-Mail"
 -body "Das ist ein E-Mail mit der PowerShell."
 -attachments "H:\Email - Anlage.txt"
 -BodyAsHtml

Excel

Neue Arbeitsmappe erstellen
# Excel starten
$excel = new-object -comobject excel.application

# Excel in den Vordergrund
$excel.visible = $true

# Neue Arbeitsmappe erstellen
$workbook = $excel.workbooks.add()

# Löschen von Tabelle 2 und 3
$workbook.WorkSheets.item(3).delete()
$workbook.WorkSheets.item(2).delete()

# Umbenennen der Tabelle 1
$workbook.WorkSheets.item(1).Name = "Test"
$sheet = $workbook.WorkSheets.Item("Test")

$lineStyle = "microsoft.office.interop.excel.xlLineStyle" -as [type]
$colorIndex = "microsoft.office.interop.excel.xlColorIndex" -as [type]
$borderWeight = "microsoft.office.interop.excel.xlBorderWeight" -as [type]
$chartType = "microsoft.office.interop.excel.xlChartType" -as [type]

# Überschriften in die Zeile 1 einfügen
$Titel = @("Spalte A","Spalte B","Spalte C","Spalte D","Spalte E")

$Spaltennr = 1

Foreach ($Item in $Titel)
{
 $sheet.cells.item(1,$Spaltennr).interior.ColorIndex = 1  # schwarzer Hintergrund
 $sheet.cells.item(1,$Spaltennr).font.bold = $true
 $sheet.cells.item(1,$Spaltennr).font.colorindex = 2  # weisse Schrift
 $sheet.cells.item(1,$Spaltennr).borders.LineStyle = $lineStyle::xlContinuous
 $sheet.cells.item(1,$Spaltennr).borders.ColorIndex = $colorIndex::xlColorIndexAutomatic
 #$sheet.cells.item(1,$Spaltennr).borders.Weight = $borderWeight::xlMedium

 $sheet.cells.item(1,$Spaltennr) = $item

 $Spaltennr = $Spaltennr + 1
}

$Wert = @("A","B","C","D","E")

$Spaltennr = 1

# die Zeilen 3 bis 7 füllen
for ($i=3; $i -lt 8; $i++)
{

 foreach ($Item in $Wert)
 {
  $sheet.cells.item($i,$Spaltennr) = $item + $i

  $Spaltennr = $Spaltennr + 1
 }

 $Spaltennr = 1
}

# optimale Spaltenbreite einstellen
$range = $sheet.usedRange
$range.EntireColumn.AutoFit() | out-null

# Datum und Uhrzeit ermitteln
$date = Get-Date -Format "yyyyMMd"
$time = Get-Date -Format "HHmmss"

# Speichern unter Eigene Dateien\Excel mit Zeitstempel
$strPath = "$HOME\Documents\Excel\Test-$date-$time.xlsx"
$excel.ActiveWorkbook.SaveAs($strPath)

# Excel beenden
$excel.quit()

# Stop-Process Excel
spps -n excel

Öffnen einer Arbeitsmappe und ein neues Blatt einfügen
# Excel starten
$excel = new-object -comobject excel.application
$excel.visible = $true

# die Excel-Meldungen abschalten
$excel.Application.DisplayAlerts = $False

# Öffnen im Pfad Eigene Dateien\Excel
$strPath = "$HOME\Documents\Excel\Test.xlsx"
$workbook = $excel.workbooks.open($strPath)

# Datum und Uhrzeit ermitteln
$date = Get-Date -Format "yyyyMMd"
$time = Get-Date -Format "HHmmss"

# neue Tabelle mit einem Zeitstempel erstellen
$worksheet=$excel.worksheets.add()
$worksheet.Name = "Tabelle-$date-$time"

Ausführen eines Makros einer Excel-Arbeitsmappe

# Excel-Makro.ps1
# Das Makro Wert muss in der makroaktivierten Arbeitsmappe Excel-Makro.xlsm existieren.

$Excel = New-Object -Comobject Excel.Application

# den Pfad und Dateiname anpassen
$Filepath="$HOME\Documents\Excel\Excel-Makro.xlsm"

$Workbook=$Excel.Workbooks.Open($Filepath)
$Excel.Visible = $true

# $worksheet = $workbook.worksheets.item(1)

$app = $Excel.Application

# den Makro-Name anpassen
$app.Run("Wert")

Word

Neues Dokument erstellen
# Word starten
$word=new-object -ComObject "Word.Application"

# Neues Dokument erstellen
$doc=$word.documents.Add()

# Word in den Vordergrund
$word.Visible=$True

# den Fokus zu Word
$selection=$word.Selection

# eine Überschrift einfügen
$os=Get-WmiObject -class win32_OperatingSystem
$selection.TypeText("Betriebssystem-Informationen für den Rechner: $($os.CSName)")

# einen Absatz einfügen
$selection.TypeParagraph()

# den Inhalt der Variablen einfügen
$selection.TypeText(($os | Out-String))

# die Zeit einfügen
$selection.TypeText((Get-Date))

# Speichern unter Eigene Dateien\Word\Rechnername-Info.doc
$strPath = "$HOME\Documents\Word\$($os.CSName)-Info.doc"
$doc.SaveAs($strPath)

# das Dokument schließen
$doc.Close()

# Word beenden
$word.quit()

Server-Rollen und -Features

SMB-1.0-Protokoll
Get-WindowsOptionalFeature -Online -FeatureName SMB1Protocol
Disable-WindowsOptionalFeature -Online -Feature-Name SMB1Protocol
Enable-WindowsOptionalFeature -Online -FeatureName SMB1Protocol

Modul Server-Manager laden
Import-Modul ServerManager

Installation des DHCP-Servers
Add-WindowsFeature DHCP

Installation des Distributed File Systems
Add-WindowsFeature FS-DFS

Hinzufügen des AD FS-Moduls
Add-PSSnapin Microsoft.Adfs.Powershell

Installation und Konfiguration von AD RMS
Import-Module AdRms

Administration von AD RMS
Import-Module AdRmsAdmin

Installation eines Web-Servers
Add-WindowsFeature Web-Server

Cmdlets für die Administration vom Web Server (IIS) laden
Add-PSSnapin WebAdministration

Installation eines NLB-Clusters
Add-WindowsFeature NLB,Web-Server

Deinstallation eines NLB-Clusters
Remove-WindowsFeature NLB,Web-Server -restart

Installation der Failover-Clusterunterstützung
Add-WindowsFeature Failover-Clustering

Installation des Routing- und RAS-Dienstes
Add-WindowsFeature NPAS-RRAS-Services

Installation des Netzwerkrichtlinienservers
Add-WindowsFeature NPAS

Installation von DirectAccess
Add-WindowsFeature DAMC

Installation vom Subsystem Linux
Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux

Installation von Hyper-V ab Server 2012
Add-WindowsFeature Hyper-V -IncludeManagementTools

Hyper-V Befehle
Get-Command -Module Hyper-V

New-VM -Name VM02 -MemoryStartupBytes 1GB
 -NewVHDPath c:\vhd\base.vhdx -NewVHDSize 50GB

Remote-Dienste und -verwaltung

Installation der Remotedesktop-Dienste
Add-WindowsFeature Remote-Desktop-Services

Installation der Remoteserver-Verwaltungstools
Add-WindowsFeature RSAT

Start-Art eines Dienstes (Remoteverwaltung) ändern
Set-Service Winrm -startuptype automatic

Starten eines Dienstes (Remoteverwaltung)
Start-Service winrm

Aktivierung der Remoteverwaltung mittels PowerShell auf einem Server
Enable-PSRemoting -force

Deaktivierung der Remoteverwaltung mittels PowerShell auf einem Server
Disable-PSRemoting -force

Ausführen von Befehlen auf einem Remotecomputer
Invoke-Command -script {Import-Module ServerManager; Get-WindowsFeature}
 -computername Server03

Ausführen eines Skripts auf einem Remotecomputer
Invoke-Command -filepath c:\scripts\test.ps1 -computername Server01

PowerShell-Version von allen in der Datei machines.txt aufgeführten Computern
$version = Invoke-Command -computername (get-content machines.txt) -scriptblock {(get-host).version}

Starten einer interaktiven Sitzung auf einem Remotecomputer
enter-pssession Server01

Beenden dieser interaktiven Sitzung auf dem Remotecomputer
exit-pssession

Active Directory

Test eines Domänencontrollers
Test-ADDSDomainControllerInstallation
 -Domainname "DNS-Name der Domäne"
 -SafeModeAdministratorPassword (read-host -prompt Kennwort -assecurestring)

Einer Domäne beitreten
Add-Computer -DomainName "meine-domain.local" -Restart

Laden des Active Directory-Moduls
Import-Module ActiveDirectory

Auflisten der Cmdlets des Active Directory-Moduls
Get-Command -Module ActiveDirectory
Get-Command -Noun AD* | more
Get-Command -Noun AD*User* | more
Get-Command *ADGroup*
Get-Command *ADComputer*
Get-Command *ADOrganizationalUnit*

Anzeige von Infos zur Gesamtstruktur
Get-ADForest

Anzeige von Infos zur Domäne
Get-ADDomain

Anzeige von Infos zum Domänen-Controller
Get-ADDomainController

Anzeige der Root Directory Service Einträge am Domänen-Controller
Get-ADRootDSE
(Domänen-Name, Schema, DNS, Funktionsebene von Gesamtstruktur, Domäne und DC)

Heraufstufen der Domäne auf Win 2008 R2
Set-ADDomainMode -Identity test.global -DomainMode Windows2008R2Domain

Heraufstufen der Gesamtstruktur auf Win 2008 R2
Set-ADForestMode -Identity test.global -ForestMode Windows2008R2Forest

Ändern der UPN-Suffixes-Eigenschaft für die Gesamtstruktur
Set-ADForest -Identity test.global -UPNSuffixes @{replace="test.global","test","sub.test.global"}

Set-ADForest -Identity test.global | Set-ADForest
 -UPNSuffixes @{replace="test.global","test","sub.test.global"}

$forest = Get-ADForest -Identity test.global
$forest.UPNSuffixes = "test.global","test","sub.test.global"
Set-ADForest -Instance $forest

Erstellung eines Subnetzes für den Standort Stuttgart
New-ADObject -Name '192.168.1.0/24' -Type subnet -Description '192.168.1.0/255.255.255.0'
 -OtherAttributes
 @{location="Stuttgart";siteObject="cn=Stuttgart,cn=Sites,cn=Configuration,dc=test,dc=global"}
 -Path "cn=Subnets,cn=Sites,cn=Configuration,dc=test,dc=global"

Best Practice Analyzer auf allen Domänencontrollern für die unterstützten Serverrollen
Import-Module ServerManager
Import-Module BestPractices

Get-WindowsFeature | Where {$_.BestPracticesModelId -ne $null} | Invoke-BPAModel

Get-BPAModel | Get-BPAResult

Neue abgestimmte Kennwortrichtlinie erstellen und konfigurieren
New-ADFineGrainedPasswordPolicy
(anschließend PSO mit ASDI-Edit msDS-PSOAppliesTo mit Objekt verbinden)

Verschieben eines AD-Objekts
Move-ADObject

AD-Objekt vor versehentlichem Löschen schützen
Set-ADObject "cn=Herrmann Maier,cn=Users,dc=test,dc=global"
 -protectedFromAccidentalDeletion $true

Aktivieren des Papierkorbs bei AD Win 2008 R2 für Gesamtstruktur
Enable-ADOptionalFeature -Identity 'cn=Recycle Bin Feature,cn=Optional Features,
 cn=Directory Service,cn=Windows NT,cn=Services,cn=Configuration,
 dc=test,dc=global' -Scope ForestOrConfigurationSet -Target 'test.global'

Wiederherstellen eines AD-Objekts aus dem Papierkorb
Get-ADObject -Filter {displayName -eq "Maier"} -IncludeDeletedObjects | Restore-ADObject

Wiederherstellen einer Organisations-Einheit aus dem Papierkorb
Get-ADObject -ldapFilter:"(msDS-LastKnownRDN=Marketing)" -IncludeDeletedObjects |
 Restore-ADObject

Wiederherstellen der Unterobjekte dieser Organisations-Einheit aus dem Papierkorb
Get-ADObject -SearchBase "cn=Deleted Objects,dc=test,dc=global"
 -Filter {lastKnownParent -eq "ou=Marketing,dc=test,dc=global}"
 -IncludeDeletedObjects | Restore-ADObject

Benutzer

Anzeige eines Benutzers
Get-ADUser -Identity Herrmann.Maier
Get-ADUser -Identity Herrmann.Maier -Properties *

Anzeigen der letzten Anmeldung eines Benutzers
$user = Get-ADUser "Administrator" |
 Get-ADObject -Properties lastLogon[DateTime]::FromFileTime($user.lastlogon)

Get-ADUser -Filter * -Properties lastlogon | FT
Get-ADUser -filter {*} -Properties name,lastlogon | Export-CSV -Path C:\out.csv

Benutzerkonten, die auf einem RODC zwischengespeicherte Kennwörter haben
Get-ADDomainControllerPasswordReplicationPolicyUsage -Identity "RODC1" -RevealedAccounts |
 ft Name,ObjectClass -A

Neuen Benutzer erstellen
New-ADUser -Path "cn=Users,dc=test,dc=global" -name "Hermann Maier"
 -SAMAccountname Hermann.Maier
 -UserPrincipalName "Hermann.Maier@test.global"
 -DisplayName "Maier, Herrmann"
 -EmailAddress "Herrmann.Maier@test.global"
 -Description "Leiter IT" -company "Test GmbH" -Department "IT" -Office "Stuttgart"
 -EmployeeNumber 12345
 -AccountPassword (ConvertTo-SecureString -AsPlaintext "Passwort" -force)
 -ChangePasswordAtLogon $true -Enabled $true

Neuen Benutzer bei AD LDS erstellen
New-ADUser -name "Hermann Maier" -DisplayName "Maier, Herrmann"
 -server Server03:31389
 -Path "cn=Users,dc=test,dc=local"

Neue Benutzer mit dem Import aus einer CSV-Datei erstellen
Import-Csv "C:\NeueBenutzer.csv" | NewADUser -organisation Test

Inhalt der Datei NeueBenutzer.csv:
name,sAmAccountName,GivenName,Surname
Hermann Maier,Herrmann.Maier,Maier,Hermann
Max Mustermann,Max.Mustermann,Mustermann,Max

Import-CSV Konten.csv | Foreach {New-ADUser -Name $_.Name -Enabled $true
 -AccountPassword (ConvertTo-SecureString $_.Password -AsPlainText -Force)}
(Password ist eine Spalte in der Datei Konten.csv)

Ändern eines Benutzers
Set-ADUser -Identity Herrmann.Maier -EmailAddress "Herrmann.Maier@test.global"

Entsperren eines Benutzers
Unlock-ADAccount -Identity "cn=Herrmann Maier,cn=Users,dc=test,dc=global"

Löschen eines Benutzers bei AD LDS
Remove-ADUser -Identity "cn=Herrmann Maier,cn=Users,dc=test,dc=local"
 -server Server03:31389
 -Path "cn=Users,dc=test,dc=local"

Aktivieren eines Benutzers
Set-ADUser -Identity "cn=Herrmann Maier,cn=Users,dc=test,dc=global"
 -Enabled $true

Enable-ADAccount

Einlesen eines Kennwortes vom Prompt in eine Variable
# die Meldung ohne : eingeben
$neuesPassword = (Read-Host -Prompt "Neues Kennwort" -AsSecureString)

Zurücksetzen aller Benutzer-Kennworte auf den Inhalt der Variable
Get-ADUser -Filter * | Set-ADAccountPassword -NewPassword $neuesPassword -Reset

Speichern eines Objekts in eine Variable
$user = Get-ADUser -Identity Herrmann.Maier

Ändern eines Objekts über diese Variable
Set-ADUser -Identity $user -Enabled $false

Ändern eines Objekts über eine Pipe
Get-ADGroupMember -Identity Personal | Set-ADUser -Enabled $true
Get-ADUser -Filter (office -eq "Stuttgart") | Set-ADUser -Enabled $true

Gruppen

Befehle zum Verwalten von Gruppen
New-ADGroup -Path "ou=Gruppen,dc=test,dc=global" -Name "Vertrieb"
 -sAMAccountname "Vertrieb" -GroupCategory Security -GroupScope Global

Remove-ADGroup
Get-ADGroup
Set-ADGroup

Add-ADGroupMember -Identity "Vertrieb"
 -Members "cn=Herrmann Maier,cn=Users,dc=test,dc=global"

Remove-ADGroupMember

Anzeige der Gruppen-Mitglieder
Get-ADGroupMember -Identity "cn=Personal,dc=test,dc=global"
Get-ADGroupMember -Identity Personal
Get-ADGroupMember Personal

Anzeige der Gruppen-Mitglieder auch in verschachtelten Gruppen
Get-ADGroupMember "Vertrieb" -recursive | Select sAMAccountname

Anzeige der Gruppen-Mitglieder bei AD LDS
Get-ADGroupMember -Identity "cn=Personal,dc=test,dc=local"
 -server Server03:31389 -partitition "ou=Anwendung1, dc=test,dc=local" |
 FT Name,DistinguishedName -A

Organisationseinheiten

Befehle zum Verwalten von Organisationseinheiten
Get-ADOrganizationalUnit
New-ADOrganizationalUnit
Remove-ADOrganizationalUnit
Set-ADOrganizationalUnit

New-Item -name "ou=Zweigstelle" -ItemType organizationalUnit

Computer-Konten

Befehle zum Verwalten von Computer-Konten
New-ADComputer -Name "DESKTOP13" -sAMAccountName "DESKTOP 13"
 -Path "cn=Computers,dc=test,dc=global"

Remove-ADComputer
Get-ADComputer
Set-ADComputer

Add-Computer -DomainName test.global

Add-Computer -DomainName test.global -NewName Desktop14
 -OUPath OU=Marketing,DC=test,DC=global -Restart

Verwaltete Dienst-Konten

Umwandeln eines Benutzer-Kontos in ein verwaltetes Dienst-Konto
Set-ADServiceAccount

Erstellen eines verwalteten Dienst-Kontos im Active Directory
New-ADServiceAccount SRV_APP01 -Enabled $true
 -Path "cn=Managed Service Accounts,dc=test,dc=global"

New-ADServiceAccount -name _msvc_SQL1

Anzeigen der Eigenschaften eines verwalteten Dienst-Kontos
Get-ADServiceAccount

Anzeigen der Eigenschaften aller verwalteten Dienst-Konten
Get-ADServiceAccount -Filter *

Ändern eines verwalteten Dienst-Kontos
Set-ADServiceAccount SRV_APP01 -Description "Anwendungspool 01 auf Server 01"

Löschen eines verwalteten Dienstkontos aus dem Active Directory
Remove-ADServiceAccount

Zuordnung eines verwalteten Dienst-Kontos zu einem Computerkonto
Add-ADComputerServiceAccount -computer SQL-Server01 -ServiceAccount _msvc_SQL1
(Ein verwaltetes Dienst-Konto kann nur einem Computer zugeordnet werden.
Deswegen ist die Verwendung bei Failover-Clustern nicht möglich,
da auf allen Knoten dasselbe Dienstkonto verwendet werden muss.)

Löschen der Zuordnung eines verwalteten Dienst-Kontos zu einem Computerkonto
Remove-ADComputerServiceAccount Server01

Installieren eines verwalteten Dienst-Kontos auf einem Computer
Install-ADServiceAccount -Identity SRV_APP01

Zurücksetzen des Passwortes des verwalteten Dienst-Kontos auf einem Computer
Reset-ADServiceAccountPassword -Identity SRV_APP01

Entfernen des verwalteten Dienst-Kontos vom Computer
Uninstall-ADServiceAccount -Identity SRV_APP01

Windows 10

Name aller Apps ermitteln
Get-AppxPackage | Select-Oject -Property Name

PackageFullName einer App ermitteln
# hier für die App: Microsoft-App Store
Get-AppxPackage -Name *WindowsStore*

Vorinstallierte Apps deinstallieren
Microsoft-App Store: Get-AppxPackage *WindowsStore* | Remove-AppxPackage
Alarm und Uhr: Get-AppxPackage *windowsalarms* | Remove-AppxPackage
Filme & TV: Get-AppxPackage *zunevideo* | Remove-AppxPackage
Fotos: Get-AppxPackage *photos* | Remove-AppxPackage
Groove-Musik: Get-AppxPackage *zunemusic* | Remove-AppxPackage
Kamera: Get-AppxPackage *windowscamera* | Remove-AppxPackage
Karten: Get-AppxPackage *windowsmaps* | Remove-AppxPackage
Kontakte: Get-AppxPackage *people* | Remove-AppxPackage
Kalender und Mail: Get-AppxPackage *windowscommunicationsapps* | Remove-AppxPackage
OneNote: Get-AppxPackage *onenote* | Remove-AppxPackage
Rechner: Get-AppxPackage *windowscalculator* | Remove-AppxPackage
Sprachrekorder: Get-AppxPackage *soundrecorder* | Remove-AppxPackage
Xbox: Get-AppxPackage *xboxapp* | Remove-AppxPackage

Alle vorinstallierten Apps wiederherstellen
Get-AppxPackage -allusers | foreach {Add-AppxPackage -register "$($_.InstallLocation)\appxmanifest.xml"
 -DisableDevelopmentMode}
"Get-AppXPackage | Foreach {Add-AppxPackage -DisableDevelopmentMode
 -Register “$($_.InstallLocation)\AppXManifest.xml”}"

SMB1 aktivieren
Enable-WindowsOptionalFeature -Online -FeatureName smb1protocol

Windows Update: Log-Dateien ansehen
# erstellt eine log-Datei auf dem Desktop
Get-WindowsUpdateLog

Erkennung unerwünschter Applikationen einschalten
Set-MpPreference -PUAProtection 1
(Neustart)

Netzwerkschutz einschalten
Set-MpPreference -EnableNetworkProtection Enabled
(Neustart)

TCP/IP-Eigenschaften anzeigen
Get-nettcpsetting -Setting internet