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
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)
{
...
}
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 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 Infos eines Computers
Get-ComputerInfo
Get-ComputerInfo | select windows*
Get-ComputerInfo | select os*
Skript zum Anzeigen der installierten Features
Get-WindowsOptionalFeature -online
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 "Festplatten:" -ForegroundColor green
Write-Host
$HD = Get-WmiObject -ComputerName $Computer -Class MSFT_PhysicalDisk -Namespace root\Microsoft\Windows\Storage | Select FriendlyName, Size,
@{
name="MediaType";
expression={
switch ($_.MediaType) {
3 {"HDD"}
4 {"SSD"}
}
}
}
foreach ($Item in $HD)
{
$Item.Size = [Math]::Round($Item.Size/1GB, 3)
Write-Host "Name:" $Item.FriendlyName " Art:" $Item.MediaType " Groesse:" $Item.Size "GB"
}
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
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-Disk
Get-WmiObject -Class Win32_DiskDrive
Get-PhysicalDisk
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-table tag, banklabel, devicelocator, Manufacturer, PartNumber, capacity, speed
wmic memorychip list full
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
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
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"
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
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
Dateien aus Unterverzeichnissen in ein gemeinsames Verzeichnis kopieren
in den Hauptordner wechseln
Get-ChildItem -Recurse -File |
Copy -Item -Destination "Zielordner"
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
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
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")
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()
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
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
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
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
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
Befehle zum Verwalten von Organisationseinheiten
Get-ADOrganizationalUnit
New-ADOrganizationalUnit
Remove-ADOrganizationalUnit
Set-ADOrganizationalUnit
New-Item -name "ou=Zweigstelle" -ItemType organizationalUnit
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
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
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)
Netzwerktyp (privat/öffentlich) anzeigen
Get-netconnectionprofile
siehe NetworkCategory
Netzwerktyp ändern
Set-netconnectionprofile -name Network2 -NetworkCategory public oder private
(Name wie bei Get-netconnectionprofile)
TCP/IP-Eigenschaften anzeigen
Get-nettcpsetting -Setting internet