An der VHS Braunschweig findet vom 12. bis 16. Dezember 2016 ein Bildungsurlaub zum Thema "PowerShell - die Befehlszeile für den Windows-Profi" statt. In einem praxisorientiertem Seminar und mit den aktuellen Betriebssystemen und Anwendungen aus dem Hause Microsoft werden wir uns die moderne und zukunftsorientierte "Konsole - Kommandozeile - Shell" erarbeiten.

powershell basis screenshot 800px

Hier die Rahmendaten unseres Seminars:

Ort: VHS Braunschweig, Heydenstraße 2, Raum 2.03
Termine: Mo., 12.12. bis Fr., 16.12.2016; jeweils 08.30 - 16.00 Uhr!

Ich werde unsere Seminarthemen an dieser Stelle ausführlich begleiten und die Infos rund um die PowerShell nachhaltig verfügbar machen.
Ihr Trainer Joe Brandes

 

Tag 01

Montag, 12.12.2016, 08.30 - 16.00 Uhr

  • Orientierungsphase, Teilnehmer-Themen: Roter Faden Seminarankündigung,
    TN-Themen: kein spezielles Thema bei erster Orientierung genannt.
  • Allgemeines
    Wir setzen als Betriebssyteme Windows 10 Pro ein; später auch in einer Windows Server 2016 Active Directory Domänenumgebung (AD mit entsprechenden PowerShell AD-Modulen)
    Aktuelle PowerShell: PowerShell Version 5.0 (bzw. 5.1) oder eigentlich:
    Microsoft Windows Management Framework 5.0 (Link zum MS Download)
    Praxisumgebung.: es gibt auch bereits die Produkt Vorschauf auf Version 6.0 für Linux-Betriebssysteme! (Link / Link Linux Pakete)
    Übersicht zu PowerShell-Versionen und deren Betriebssystemverfügbarkeiten: Wikipedia
    Deutsche Einstiegsseite zum Thema Microsoft PowerShell: Microsoft Skriptcenter
    Installationsverzeichnis: C:\Windows\System32\WindowsPowerShell\v1.0  
    Anm.: ja immer noch Version 1.0 ;-) im Pfad; siehe vordefinierte Variable $PSHome
    View source
    1. # PS-Version anzeigen lassen
    2. echo $PSVersionTable
    3. # Host - in Console und ISE testen
    4. $host.Version
    5. # Installationsverzeichnis
    6. Write-Host $PSHome
    und hier ist die 64-Bit-Variante auf 64-Bit-OS zu finden (Tipp: Systemeigenschaften mit Win + Pause)
    Die 32-Bit-Variante im SysWoW64-Ordner (!):
    C:\Windows\SysWOW64\WindowsPowerShell\v1.0  
    Warum ist das wichtig? Z. B. beim Zugriff auf eine 32-Bit Access Datenbank
    Anm.: Die PowerShell (PS) kennt keine Groß-/Kleinschreibung (non case-sensitive).
  • Architektur der PowerShell:
    der Versuch das "Beste aus allen Welten" zu kombinieren und zu verbinden
    DOS-Shell (Befehle, Oberfläche, klassische Programme)
    Unix-Shells (Pipelinig, Syntax, Befehlsnamen)
    Andere Skriptsprachen z.B. Perl oder auch Hochsprachen C# (Syntax)
    Dot.NET Framework (Objektorientierung, Klassen)
    Windows Scripting Host - WSH (Klassen, Sicherheit; Einsatz bis ca. 2020! - PS bis min. 2030)
    Windows Management Interface - WMI (Klassen, Tool wmic.exe)
  • Abarbeitungsreihenfolge bei Aufrufen in der PowerShell:
    1) Aliase (dir, md)
    2) Funktionen (mkdir, C:)
    3) Commandlets (Get-Process)
    4) Externe Befehle (netstat, ipconfig, notepad, ...)
  • Commandlets
    abhängig vom jeweiligen Betriebssystem (Operating System - OS) in PS 5.0 weit über 1000 Commandlets
    Aufbau: Verb-Substantiv [-Parameterliste]  
    Get, Set, Add, New, Remove, Clear, Push, Pop, Write, Export, Select, Sort, Update, Start, Stop, Invoke, ...
    Ausgabekommandos wie Out und Format
    Cmdlets können ohne Verb aufgerufen werden (alias statt Get-Alias) - dann werden also die Get-Cmdlets ausgeführt
  • Hilfe in der PowerShell
    mit Tabulator Codevervollständigung (auch Umschalten + TAB rückwärts) inkl. Wildcards: Get-?e*
    View source
    1. Get-?e* TAB
    2. Get-Command Get-*
    3. Get-Command [gs]et-*
    4. Get-Command *-Service
    5. Get-Command –Noun Service
    6. Get-Command *wmi*
    7.  
    8. # Beispiel mit mehr Tiefe als Vorbereitung auf Pipelining und Filterungen
    9. Get-Command | Where-Object { $_.name -like "*cim*" -or $_.name -like "*wmi*" }
    10.  
    11. Get-Command ps # Alias
    12. Get-Command notepad.exe # Tool
    13. Get-Command C: # Function
    14.  
    15. # Anzahl von Cmdlets und Funktionen (so seit PS 2.0)
    16. Get-Command | Group-Object CommandType
    17. # Cmdlets und Funktionen exportieren:
    18. Get-Command | Format-Table name -HideTableHeaders | Out-File E:\_temp\pscommands.txt
    19.  
    20.  
    21. # Hilfe aktualisieren mit Update-Help Commandlet
    22. Update-Help –UICulture En-US -force
    23. # Beachten: Admin-PowerShell nötig! Anm.: Autor Weltner empfiehlt En-US Schalter!
    24.  
    25. Get-Help Get-Command
    26. # mit Parametern auch
    27. Get-Help Get-Command -Detailed # -Full, -Examples, -Online, -ShowWindow
    28. Get-Help Get-Process -parameter "*"
    29.  
    30. # Show-Command
    31. Show-Command Get-Process
    Grafische Oberfläche mit Show-Command seit PS 3.0: Show-Command Get-Process 
    Hilfe aktualisieren mit Update-Help Commandlet - Beachten: Administrator-PowerShell nötig!
    Websites: Skripting mit der PowerShell - Windows PowerShell for Server
    Hilfe zu PS-Befehlen und den Techniken für das spätere Skripting:
    Get-Help about_for
    Get-Help about_foreach
    Get-Help about (alle verfügbaren Hilfen - hier leider wieder Einschränkungen in der Production Preview 5.0);
    Empfehlung: auch einfach online suchen mit "PowerShell about_for, ...
    Online-Hilfe-Portal zur PowerShell (Technet - Skripterstellung mit Windows PowerShell)
  • PSReadline - ein PowerShell-Modul für das Verbessern der PowerShell Konsole
    in PS 5.0 hat man außerdem mit PowerShellGet, ein Modul, das die Fähigkeiten von NuGet (einem Paketmanager) bereitstellt
    Falls man also kein Modul PSReadline vorfindet, dann einfach neues Cmdlet Install-Modul zum Installieren nutzen: (in einer Administrator-Shell)
    Install-Modul -Name PSReadline  
    Wichtig: Abfragen nach Installation von Paketmanagement-Tool und Vertrauenswürdigkeit des Paketrepositories mit "Y" bestätigen!
    Verbesserungen in der PowerShell-Konsole durch PSReadline: (Beispiel-Link)
    - farbiges Syntax-Highlighting
    - im Prompt wird ">" in Rot angezeigt, wenn die Eingabe noch unvollständig ist
    - PS Konsole nimmt jetzt auch Strg + V an
    - mit Strg + Leertaste kann man in der Konsole Code-Completion (Syntax Vervollständigungen) nutzen
    - einfacheres "Error"-Handling (bei kleinen Vertippern nicht gleich mehrzeilige "Fehlermonster")
    - besserer Mehrzeilenmodus
    - mit Strg + L erreicht man ein cls (clear screen)
    - belegbare Tastenkombinationen (siehe cmdlet Get-PSReadlineKeyHandler bzw. das Pendant Set-PSReadlineKeyHandler)
  • PowerShell History
    Die PowerShell hat eine eigene History-Umgebung und entsprechende Cmdlets zur Nutzung.
    Am Besten aber nutzt man die History-Technik von Modul PSReadline
    View source
    1. # PSReadline
    2. (Get-PSReadlineOption).HistorySavePath
    3. $a = (Get-PSReadlineOption).HistorySavePath
    4. notepad.exe $a # oder besser mit dem ISE
    5. ise $a
    Es ist also mit der History.txt-Datei von PSReadline ein kompletter Fundus unserer/Ihrer Aufrufe am Ende der Seminarwoche automatisch verfügbar!
  • Erste Aufrufe in der PS
    Interaktive Aufrufe vergleichen:
    Get-Process vs. Get-EventLog (hier dann Parameter als Eingabe möglich: Application, System, ...)
    View source
    1. # Parameter - und einfache Parameter-Switches nutzen
    2. # Alle Aufrufe gleich:
    3. Get-ChildItem C:\temp *.txt # Hier: Reihenfolge entscheidend!
    4. Get-ChildItem -Path C:\temp -Filter *.txt
    5. Get-ChildItem -Filter *.txt -Path C:\temp
    6. # Verschiedene Platzhalter / Wildcards:
    7. Get-Process i*
    8. Get-Process i*ore
    9. Get-Process [st]*
    10. Get-Process [st][vf]*
    11. # Aktivieren / Deaktivieren von Schaltern:
    12. Get-ChildItem C:\temp -recurse
    13. Get-ChildItem C:\temp -recurse:$false
    Allgemeine Parameter: -Force, -Whatif, -Confirm, ...
    Aufrufe lassen sich zusammensetzen (später sinnvoll mit Variablen in Skripten)
    Get-ChildItem ("c:\" + "temp") *.txt –Recurse
  • Aliase
    ps ersetzt Get-Process   (Unix-Shell lässt grüßen)
    Befehle: Get-Alias ; Get-Alias ps
    Standardanzahl für Aliase: 4096  (siehe Variable $MaximumAliasCount)
    View source
    1. # Neue Aliase mit:
    2. Set-Alias procs Get-Process # neu oder überschreiben
    3. New-Alias procs Get-Process
    Wichtig: keine Parameter festlegbar - da brauchen wir später Funktionen!
    Die Aliase gelten nur in der aktuellen PS-Sitzung (Instanz), bei späterer Nutzung dann in Profile integrieren oder manuell exportieren / importieren:
    View source
    1. Export-Alias c:\temp\meinealias.csv # also in eine Textdatei
    2. Export-Alias c:\temp\meinealias.ps1 -as script # in ein PS-Skript
    3. # Laden:
    4. Import-Alias c:\temp\meinealias.csv
    5. . c:\meinealias.ps1 # Punktoperator - "Dot sourcing"
    Es werden alle Aliase exportiert und wieder importiert, was zu "Fehlermeldungen" beim Import führt. Man kann entweder manuelle Anpassungen der Exportdateien durchführen, so werden die Aliase "sauber" importiert, oder aber einfach später die gewünschten Aliase in den PS-Profilen sauber hinterlegen!
    Tipp Unterdrückung der Fehlerausgaben: -ErrorAction SilentlyContinue
  • Ausdrücke
    eine erste Annäherung mit () im Expression bzw. Command Mode
    Vergleiche:
    View source
    1. Write-Output 10 * (8 + 6) # mit
    2. Write-Output (10 * (8 + 6))
    3. # Aufrufe mit Unterausdruck:
    4. "Anzahl der laufenden Prozesse: (Get-Process).Count"
    5. # vergleichen mit:
    6. "Anzahl der laufenden Prozesse: $((Get-Process).Count)"
    Anm.: $ leitet also Subexpression (Unterausdruck) ein
  • ISE - Integrated Scripting Environment
    Auch hier wieder 32- und 64-Bit-Variante beachten!
    Integrated Scripting Environment (ISE - powershell_ise.exe) ist der Name des Skripteditors - mit PS 3.0 nochmals verbessert
    Intellisense Eingabeunterstützung - vervollständigen mit Tab, Strg + Leertaste
    Eigene Remote-Konsole (siehe Menü Datei)
    Copy & Paste: Hier funktionieren die Zwischenablage-Tastenkombinationen Strg + C / V
    Hilfe zu Befehlen mit F1; Show-Command mit Strg + F1
    Diverse Addons verfügbar - hier eine Link zu einer Microsoft Quelle: Link
    Skripte ausführen (Später auch "Debuggen Ausführen/Fortsetzen") oder F5
    Skriptauswahl (manuell markieren) ausführen mit F8
    Vorgriff auf Debugging: (heute noch nicht behandelt)
    Haltepunkte mit F9; mehr im Menü Debugging des ISE
    Wichtige Unterschiede zur "normalen" PowerShell Console:
    keine interaktiven Tools/Programme möglich: ftp, nslookup, ...
    kein Blättern mit more, keine Soundausgaben
    View source
    1. # Eigene Farbgebungen in ISE mittels:
    2. $psISE.Options.ConsolePaneBackgroundColor = "red"
    3. # alternativ:
    4. $host.ui.RawUI.BackgroundColor = "red"
    siehe auch $psISE.options für die möglichen Einstellungen / Optionen der ISE
    Tipp: Einstellungen mittels Tools - Optionen bearbeiten bzw. auf Standard zurückstellen
  • ExecutionPolicy für die PowerShell-Skripte
    Sicherheitlevel beachten (Restricted, RemoteSigned, Unrestricted, ...)
    Cmdlets: Get-ExecutionPolicy, Set-ExecutionPolicy
    die voreingestellte Policy (Richtlinie): Restricted - das würde aber gleich alle PowerShell-Skriptaufrufe (auch für unsere Profilskripte!) verhindern
    Also: mit  Set-ExcecutionPolicy Remotesigned   (in einer Administrator PowerShell !)
    eine Möglichkeit zur Ausführung lokaler Skripte - bei Skripten aus Netzressourcen wäre eine Signatur notwendig
    Anm.: bitte nicht die 32-Bit-PowerShell (x86) vergessen!
  • Profile (Part I)
    PowerShell-Hosts: Sowohl die PowerShell (console host) als auch die ISE (Windows PowerShell ISE) besitzen Profile (Profildateien / Konfigurationen). Außerdem kann man auch generelle Profile für alle User (AllUser) oder nur für den aktuellen (CurrentUser) konfigurieren.
    Anzeigen der Profile jeweils (!) mit $PROFILE in der PowerShell ergibt:
    C:\Users\joeb\Documents\WindowsPowerShell\Microsoft.PowerShell_profile.ps1
    in der ISE dann ebenfalls $PROFILE mit
    C:\Users\joeb\Documents\WindowsPowerShell\Microsoft.PowerShellISE_profile.ps1
    View source
    1. $PROFILE
    2. # genauer: (Anm.: siehe auch ISE)
    3. $PROFILE
    4. $PROFILE.CurrentUserCurrentHost
    5. $PROFILE.CurrentUserAllHosts
    6. $PROFILE.AllUsersCurrentHost
    7. $PROFILE.AllUsersAllHosts
    Cleveres Erstellen der $PROFILE inklusive notwendiger Ordner/Unterordner:
    New-Item -Path $PROFILE -ItemType File -force    
    Anpassen der Profile dann in weiteren Übungen, wenn wir das Skripten im Griff haben.
    Erste Übung mit Aliasen (Set-Alias) und Startverzeichnis für die PowerShell mit Set-Location

 

  • ISEISE
  • PS-Provider - PSDrivePS-Provider - PSDrive
  • $PROFILE$PROFILE
  • Set-Alias im ProfilSet-Alias im Profil
  • Administrator: (PowerShell)Administrator: (PowerShell)
  • Alias, Function, ApplicationAlias, Function, Application

 

Tag 02

Dienstag, 13.12.2016, 08.30 - 16.00 Uhr

  • Ausführliche Rekapitulation zu Tag 01, TN-Fragen
  • Übungen zu Datei- und Ordnerbehandlungen
    Quelle: Dr. Tobias Weltner, Free PowerShell Cookbooks, www.powertheshell.com; filesystem_cookbook.pdf; Power Tips Monthly Vol.1 | June 2013
    View source
    1. # Desktop Ordner finden mit [Systemklassen]:Methoden
    2. [Environment]::GetFolderPath('Desktop')
    3. # Folder anzeigen für GetFolderPath:
    4. [System.Enum]::GetNames([System.Environment+SpecialFolder])
    5. # also:
    6. [Environment]::GetFolderPath('Cookies')
    7. # Dateien umbenennen - die Win8/10 Screenshots haben Leerzeichen!
    8. $global:i = 1
    9. $path = "$env:userprofile\Pictures\Screenshots"
    10. Get-ChildItem -Path $path -Filter *.png |
    11.     Rename-Item -NewName { "screenshot_$i.png"; $global:i++}
    12. # 1GB Datei in Sekundenbruchteil
    13. $path =$env:temp\testfile.txt”
    14. $file = [io.file]::Create($path)
    15. $file.SetLength(1gb)
    16. $file.Close()
    17. Get-Item $path
    Übung nach dem Seminar (mit erweitertem Pipelining)
    View source
    1. $folder = "$env:userprofile\Downloads"
    2. >>> Get-ChildItem -Path $folder -Recurse -Force -Erroraction SilentlyContinue |
    3. >>> Measure-Object -Property Length -Sum |
    4. >>> ForEach-Object {
    5. >>> $sum = $_.Sum / 1MB
    6. >>> "Der Download-Ordner enthaelt derzeit {0:#,##0.0} MB storage." -f $sum
    7. >>> }
  • Pipelining (Online-Beitrag - inkl. Pipeline-Bild - von Schwichtenberg auf entwickler.de)
    in der PS ist alles objektorientiert bearbeitbar und eben auch weitergegeben (siehe Pipeline) Anm.: das besondere Konstrukt $_greift auf das aktuelle Objekt zu
    View source
    1. # komplexere Pipeline:
    2. Get-ChildItem c:\temp –r -filter *.txt |
    3. >>> Where-Object { $_.Length -gt 40000 } |
    4. >>> Select-Object Name, Length |
    5. >>> Sort-Object Length |
    6. >>> Format-List
    Neu: $PSItem als gleichwertiger Ersatz zu $_ (seit PS 3.0) Anm.: Erklärung für dieses Verhalten mit Get-Help Get-Service -full  (siehe nach -name byValue und byPropertyName)
    View source
    1. # Ein paar Beispiel für Pipeline-Aufrufe:
    2. Get-Process |
    3. >>> Where-Object {$_.name -eq "iexplore"} |
    4. >>> Format-Table ProcessName, WorkingSet64
    5. # Alle Prozesse, die mehr als 20 MB verbrauchen
    6. Get-Process | Where-Object {$_.WorkingSet64 -gt 20*1024*1024 }
    7. # kurze Variante
    8. ps | ? {$_.ws -gt 20MB }
    9. # alle Dienste, die mit i beginnen
    10. "i*" | Get-Service
    11. # Dienst "gleich" BITS
    12. "BITS" | Get-Service

    Auch die klassischen Befehle lassen sich "pipen":
    netstat -an | Select-String "HERGESTELLT" -case  (Select-String für reguläre Ausdrücke)
    Anzahl von Objekten in einer Pipeline: Get-Date  (erzeugt nur ein Objekt)
    Eigenschaften des Objekts ansprechen:
    (Get-Date).Year  (als auch .Month, .Hour, .Minute)
    Anm.: keine Probleme mehr (also keine Fehlermeldungen, falls man denn mal mit einem Einzelobjekt arbeitet)
    View source
    1. # Anzahl aller Prozesse
    2. (Get-Process).count
    3. # Anzahl von Prozessen mit mehr als 20 MB im RAM
    4. (Get-Process | where-object { $_.WorkingSet64 -gt 20MB }).Count
    5. # Objekte lassen sich dann mit Array-Technik einzeln ansprechen:
    6. (Get-Process | where-object { $_.WorkingSet64 -gt 20MB })[5]
    7. # früher:
    8. Get-Process | foreach-object {$_.Name }
    9. # seit PS 3.0:
    10. (Get-Process).Name
    11. # Für eine kombinierte Ausgabe ist foreach-Commandlet nötig:
    12. Get-Process | foreach-object {$_.Name + ": " + $_.Workingset64 }
    Methoden der Objekte: (also Funktionen zu denen die Objekte fähig sind)
    Automatic Unrolling (seit PowerShell 3.0)
    View source
    1. # Beispiel zu Automatic Unrolling
    2. $dll = Get-ChildItem C:\Windows\System32\*.dll | Select-Object -First 3
    3. $dll # Ausgabe
    4. # wieder 3 Versionen
    5. $dll.VersionInfo # ab PS 3.0
    6. $dll | Select-Object -ExpandProperty VersionInfo
    7. $dll | ForEach-Object { $_.VersionInfo }
    8.  
    9. # Analyse
    10. $dll | Get-Member # hier sieht man VersionInfo / ScriptProperty – nach der Pipeline!
    11. # im Vergleich mit
    12. Get-Member –InputObject $dll # Get-Member kennt kein VersionInfo

    Alle Techniken praktisch erprobt.
    View source
    1. # alle iexplore "killen"
    2. Get-Process iexplore | Foreach-Object { $_.Kill() }
    3. # seit PS 3.0:
    4. (Get-Process iexplore).Kill()
    5. # besseres Commandlet: Stop-Process
    6. # hier gibt es auch keine Fehler mehr, falls kein iexplore
    7. Get-Process | Where-Object { $_.Name -eq "iexplore" } | Stop-Process
    8. # Alle Methoden für Get-Date anzeigen lassen:
    9. Get-Date | Get-Member
    10. (Get-Date).ToLongDateString() # und viele Andere
    Anm.: die Fehlerbehandlung in unsere PowerShell Konsole wird durch Einsatz von PSReadline optimiert.
  • Skripting (Part I)
    Skriptausführung muss mit geeigneter ExecutionPolicy (RemoteSigned) erlaubt sein;
    Commandlets: Get-ExecutionPolicy und Set-ExecutionPolicy  (als Admin!)
    Dateiformat (Dateiendung): *.ps1
    Das erste Skript (nach Schwichtenberg - Quelle/Buch des Microsoft-Experten zeige ich noch)
    View source
    1. # Mein erstes Skript
    2. "Informationen über diesen Computer:"
    3. "Datum: " + (Get-Date).ToShortDateString()
    4. "Zeit: " + (Get-Date).ToLongTimeString()
    5. "Anzahl laufender Prozesse: " + (Get-Process).Count
    6. "Anzahl lauf. Dienste: " + (Get-Service | where { $_.Status -eq "running" } ).Count
    Anm.: Zeichenkodierungen bei alternativen Editoren (also nicht ISE) beachten:
    z.B. Notepad++ mit UTF (ohne BOM) vs. ANSI (mit Notepad, ISE, und Co)
    Starten von Skripten mittels:
    View source
    1. .\skript.ps1
    2. &.\skript.ps1
    3. Invoke-Expression .\skript.ps1
    Auch direkte Aufrufe mit powershell.exe g:\pfad\skript.ps1
    Skripte lassen sich mit Alias zuweisen:
    Set-Alias Get-JBComputerInfo C:\ps-skripte\01-dienstag.ps1 
    Übung: das Ganze verdrahtet und in die $PROFILE gepackt

 

  • Set-Alias für SkriptSet-Alias für Skript
  • 1GB Datei in Sekunde1GB Datei in Sekunde
  • Get-EventLog SystemGet-EventLog System
  • mehrzeilige PowerShellmehrzeilige PowerShell
  • Get-Help about_ForGet-Help about_For
  • Get-MemberGet-Member

 

Tag 03

Mittwoch, 14.12.2016, 08.30 - 16.00 Uhr

  • Rekapitulation, TN-Fragen
  • Bücher / Literatur zur PowerShell
    siehe eigene Registerkarte "Bücher und Co"; Hinweis auf Buchhandlung Graff und Online terrashop.de (Mängel-/Resteexemplare)
  • Filtern, Sortieren, Gruppieren
    Mit den Standard-Cmdlets (Verben: Where-, Sort-, Group-) praktische Übungen durchgeführt:
    View source
    1. # Prozesse, der Speicher größer als 10000000 Bytes
    2. Get-Process | Where-Object {$_.ws -gt 10000000 }
    3. # Inklusive Sortierung und Auswahl der Ergebnissätze
    4. Get-Process | Sort-Object ws -desc | Select-Object -first 5
    5. Get-Process | Sort-Object ws -desc | Select-Object -last 5
    6. # mit Regulären Ausdrücken
    7. # Systemdienste, deren Beschreibung aus zwei durch ein Leerzeichen getrennten Wörtern besteht.
    8. Get-Service | Where-Object { $_.DisplayName -match "^\w* \w*$" }
    9. # Prozesse, deren Namen mit einem "i" starten und danach drei Buchstaben
    10. Get-Process | Where-Object { $_.ProcessName -match "^i\w{3}$" }
    11. Vergleichsoperatoren (s. about_Comparison_Operator)
    12. # klassische Filter:
    13. Get-Service | where-object { $_.status -eq "running" }
    14. # können seit PS 3.0 auch mit
    15. Get-Service | where-object status -eq "running"
    16. # aber bei Kombinationen mit and oder or bitte wieder klassisch:
    17. Get-Process | Where-Object { $_.Name -eq "iexplore" -or $_.name -eq "Chrome" -or $_.name -eq "Firefox" } | Stop-Process
    18. Get-Service | where-object { $_.status -eq "running" -and $_.name -like "a*" }
    19. #Objekte für Ausgaben einschränken ("kastrieren")
    20. Get-Process | Select-Object processname, get_minworkingset, ws | Get-Member
    21. # Prozesse nach Speicherverbrauch sortieren
    22. Get-Process | Sort-Object ws –desc
    23. # Mehrere Sortierfelder
    24. Get-Service | Sort-Object Status, Displayname
    25. # mehrfach-Elemente finden - man muss immer erst sortieren!
    26. 1,5,7,8,5,7 | Sort-Object | Get-Unique
    27. # Elemente gruppieren
    28. Get-Service | Group-Object status
    29. # Dateien in System32 nach Erweiterungen gruppieren und sortiert ausgeben
    30. Get-ChildItem c:\windows\system32 | Group-Object extension | Sort-Object count –desc
    31. Get-ChildItem c:\windows\system32 | Select-Object extension -Unique
    32. # Auswertungen mit Measure-Object - Standard ist count, also Anzahl
    33. Get-ChildItem c:\windows | Measure-Object -Property length -min -max -average -sum
    Insbesondere bei der Nutzung der Regulären Ausdrücke (Regular Expression - Wikipedia Link - Signalwort "match") kratzen diese Beispiele natürlich nur an der Oberfläche
  • Parameter an Skripte übergeben:
    Lösung mittels Parameter/Argumente-Array args[..] (bei 0 beginnend)
    View source
    1. "Informationen über den Computer: " + $args[0]
    2. # oder aber mit param Deklaration und Variablenname
    3. param( [string] $Computer, [int32] $zahlvar2)
    4. "Informationen über den Computer: " + $Computer
    oder mittels param( [datatype] $var )  - Deklarationen am Anfang des Skript
    Empfehlung (siehe Übungen Tag 04): bitte die param-Definitionen nutzen
  • Variablen (Part I)
    Hier werden wir Variablen erst einmal interaktiv in der PS nutzen:
    View source
    1. # Übersichtlichkeit schaffen - Vorarbeiten für Skripting
    2. Get-Process |
    3. >>> Where-Object {$_.name -eq "iexplore"} |
    4. >>> Foreach-Object { $_.ws }
    5. # wird zu
    6. $x = Get-Process
    7. $y = $x | Where-Object {$_.name -eq "iexplore"}
    8. $z = $y | Foreach-Object { $_.ws }
    Übungen zu den Variablen in Bezug auf Sichtbarkeit (Console vs. ISE) und mit Get-ChildItem Variable:  Übersicht über die vorhandenen Variablen in einer PowerShell Host-Session
  • Vergleichsoperatoren
    siehe Google-Recherche "powershell vergleichsoperatoren" - beispielhafter Ergebnislink
    mit eingebauter PS-Hilfe: get-help about_Comparison_Operators -ShowWindow  
    -gt (greater than), -lt (lighter than), -eq (equal), -ne (not equal), -ge (greater equal), -le (lighter equal), ...
  • Variablen (Part II)
    bestimmte Variablennamen nicht erlaubt $_  oder $PSItem (klar - brauchen wir für die Objekte)
    Commandlets: Set-Variable und Get-Variable sowie Clear-Variable
    Variablen Read-Only: Set-Variable variablenname -Option readonly
    Typisierungen: [int], [string], [byte], [char], [bool], [xml], ...
    Vordefinierte Variablen: $true, $false, $Home, $PSHome, $host, ...
    mit z.B. $host.UI.RawUI.BackgroundColor = "darkgreen"
    Variablen werden bei/in Zeichenketten mit doppelten Anführungszeichen ausgewertet!
  • Datentypen - Übungen und Tests
    Wir haben zu den unterschiedlichen Typen diverse Aufrufe und Funktionen (Klassen) kennengelernt>\'";
    View source
    1. # Zahlen - Int
    2. [Int32]::MaxValue
    3. # 2147483647
    4. [UInt32]::MaxValue
    5. # 4294967295
    6. [Int32]::MinValue
    7. # -2147483648
    8. [Byte][Char]’A’
    9. # 65
    10. [Byte[]][Char[]]’Hello’
    11. # 72 #101 #108 #108 #111 (untereinander)
    12. [Char[]](65..90)
    13. [Char[]]'Hello'
    14. [Byte[]][Char[]]'Hello'
    15. # Spezielle Daten mit Klasse System.Net.Mail.MailAddress
    16. $email = [System.Net.Mail.MailAddress]'Some User<Diese E-Mail-Adresse ist vor Spambots geschützt! Zur Anzeige muss JavaScript eingeschaltet sein!>'
    Weitere Aufrufe und Techniken wurden den Teilnehmern zur Verfügung gestellt!
    Insbesondere mit $email.Displayname  bzw. mit $email. Strg+Leertaste (PSReadline - Intellisense) erkennt man immer wieder die "Objekte / Eigenschaften", die in der PowerShell nutzbar sind.
  • PowerShell Module
    mit Get-Module  erhält man eine Übersicht der aktuell geladenen (importierten) Module
    mit Get-Module -ListAvailable  erhält man eine Übersicht über alle ladbaren (importierbaren) Module
    in PowerShell 5.0 hat man außerdem mit PowerShellGet, ein Modul, das die Fähigkeiten von NuGet (einem Paketmanager) bereitstellt (s.o. für PSReadline, was wir mit PowerShell 5 ja schon haben)
    Man kann somit einfach mittels Install-Module -Name Pscx  (hier: PowerShell Community Extensions) ein Modul seiner Wahl nachinstallieren (Admin-PowerShell nötig!). Beim ersten Einsatz von Install-Module muss die Nutzung des Paketmanager und des Modul-Repositories (hier: PSGallery) positiv quittiert werden. Das Modul Pscx wird automatisch beim Aufruf einer Technik des Moduls nachgeladen (Autoloading).
    Beispiel Cmdlet:  Get-Content .\ansage.txt | Out-Speech   (Sprachausgabe einer Textdatei)
  • Funktionen (eine erste Annäherung - mehr dann morgen)
    Die Funktionen "kapseln" mehrere Abarbeitungsschritte und können später dann auch Parameter übergeben bekommen und Werte zurückgeben.
    Hier erst einmal ein Beispiel ohne Parameterübergabe - bitte einfach wieder zu den "Hilfen" greifen
    View source
    1. # Beispielfunktion cdd - Change Dir with Dialog
    2. function cdd {
    3.     $shell = New-Object -comObject "Shell.Application"
    4.     $options = 0x51 # Nur Dateisystem-Ordner - inklusive Edit-Box
    5.     $loc = $shell.BrowseForFolder(0, "Wohin soll es gehen?", $options)
    6.     if($loc) {Set-Location $loc.Self.Path}
    7. }
    Das Beispiel wurde über Suchbegriffe "Shell.Application" und/oder "BrowseForFolder" analysiert: bei $options = 0x41  entfernt man die Edit-Box am unteren Rand des cdd-Dialogfensters
    Das folgende Beispiel hier wurde der "Online-Dokumentation about_functions" entnommen:
    View source
    1. function Get-NewPix
    2. {
    3. $start = Get-Date -Month 1 -Day 1 -Year 2015
    4. $allpix = Get-ChildItem -Path $env:UserProfile\*.jpg -Recurse
    5. $allpix | where {$_.LastWriteTime -gt $Start}
    6. }
    Dieses kleine Beispiel zeigt uns alle jpg-Dateien in unserem Benutzerprofil, die nach einem Startdatum geändert worden sind. Für eine stetige Verfügbarkeit der Funktion Get-NewPix  brauchen wir nur den Code in unser $PROFILE Startskript zu packen.

 

  • PowerShell GalleryPowerShell Gallery
  • Formatoperator -fFormatoperator -f
  • types.ps1xmltypes.ps1xml
  • IntellisenseIntellisense
  • Get-Module -ListAvailableGet-Module -ListAvailable
  • Funktion cddFunktion cdd

 

Tag 04

Donnerstag, 15.12.2016, 08.30 - 16.00 Uhr

  • Rekapitulation, TN-Fragen
    Wiederholung zu Funktionen (siehe letztes Beispiel Tag 04)...
  • Skripting (Part II - einfache Ein- und Ausgaben)
    Auf den Unterschied achten zwischen einfachen und doppelten Anführungszeichen
    View source
    1. [int] $a = Read-Host "Bitte geben Sie Wert A ein"
    2. [int] $b = Read-Host "Bitte geben Sie Wert B ein"
    3. $c = $a + $b
    4. Start-Sleep -Seconds 10
    5. Write-Output 'Das Ergebnis lautet: $c mit einf. Anführungszeichen!'
    6. "Das Ergebnis lautet: $c mit doppelten Anführungszeichen!"
    7. 'Das Ergebnis lautet: ' + $c + ' mit einfachen Anführungszeichen!'
    Als Ausgabe gilt klassisch echo - und das ist bei unserer PowerShell ja der Alias für Write-Output
    Typ-Operatoren:
    wir sollten mit [int] den Datentyp (hier: Integer32) festlegen; Alternativ: [string], [boolean], ...
  • Zeichen / Strings
    siehe auch wieder die Online-Hilfen zu den Vorgehensweisen und Methoden:
    View source
    1. # Das "Echo" für die PS: Write-Host
    2. Write-Host "Guckst Du" -ForegroundColor Yellow
    3. # Zeichenketten Operationen (Methoden)
    4. "" | Get-Member -m Method
    5. [String] $CSVString = "Joe;Brandes;Braunschweig;Deutschland;www.pcsystembetreuer.de"
    6. $CSVArray = $CSVString.Split(";")
    7. $Surname = $CSVArray[1]
    8. $Surname
  • Arrays
    $a = 01,08,72,13,04,76
    Das Array kann auch explizit mit [array] deklariert werden: [array] $b
    $b = 01,08,72,13,04,76
    $b.Count
    assoziatives Array: (eine Hashtabelle)
    View source
    1. # Implicit Hashtable
    2. $Computers = @{ E01 = "192.168.1.10"; E02 = "192.168.1.20"; E03 = "192.168.1.30"; }
    3. # Explicit Hashtable
    4. [Hashtable] $Computers = @{ E01 = "192.168.1.10"; E02 = "192.168.1.20"; E03 =
    5. "192.168.1.30"; }
    6. $Computers["E02"]
    7. $Computers.E02
    Also: Arrays sind 2-spaltige Tabellen mit Indizes (Linke Spalte) und Werten (Rechte Spalte)
  • Vergleichsoperatoren
    siehe Google-Recherche "powershell vergleichsoperatoren" - beispielhafter Ergebnislink
    mit eingebauter PS-Hilfe: get-help about_Comparison_Operators -ShowWindow  
    -gt (greater than), -lt (lighter than), -eq (equal), -ne (not equal), -ge (greater equal), -le (lighter equal), ...
  • Ausgaben in Datei:
    verschiedene Wege führen hier zum Ziel:Umleitungsoperator ist > (Ersetzen) bzw. >> (Anhängen):
    View source
    1. Get-Process | Out-File "c:\temp\prozessliste.txt"
    2. # Ausgaben anhängen mit -Append
    3. Get-Process | Out-File "c:\temp\prozessliste.txt" -Append
    > Umleitung der Pipeline-Ausgabe
    2> Umleiten der Ausgabe von Fehlern
    3> Umleiten der Ausgabe von Warnungen (seit PowerShell-Version 3.0!)
    4> Umleiten der Ausgabe von Verbose-Texten (seit PowerShell-Version 3.0!)
    5> Umleiten der Ausgabe von Debug-Texten (seit PowerShell-Version 3.0!)
    *> Umleiten aller Ausgaben (seit PowerShell-Version 3.0!)Anm.: Umleitung an  Drucker mit Out-Printer
    View source
    1. # Fehler in Datei umleiten
    2. cat c:\temp\datei-exist-nicht.txt 2>> C:\temp\fehler.txt
    3. # Ausgabeströme umleiten
    4. dir u:\Daten 2>&1 | Format-Table > C:\temp\prozessliste.txt
    Ebenfalls getestet: Tee-Object zweigt Zwischenergebnisse in Dateien oder Variablen ab
  • Kontrollstrukturen
    siehe hierzu auch Nassi-Shneiderman Diagramme (Wikipedia-Link)
    Verzweigungen: if, switch  
    Schleifen: for, do, while  (Abbruchbedingen am Anfang oder Ende der Schleifen)
    Speziell: foreach (automatische Schleifen für Arrays/Objekte)
    Vorgriff auf Vertiefung zu Funktionen: function, return (eine kleine erste Einführung)
    Übungen zu if, switch, for, foreach
    weitere Beispielcodes aus den Online-Hilfen "kopiert", angepasst und getetstet
  • for (ein kleines Codebeispiel)
    Bitte wieder Hilfen beachten: Get-Help about_for 
    Beispiel-Codes aus den Hilfedateien durchgespielt
    View source
    1. # Fakultätsberechnung mit einer For-Schleife und vorzeitiger Abbruchbedingung
    2. # -------------------
    3. "Bitte eine Zahl eingeben:"
    4. $Fakultaet = Read-Host
    5. $FakultaetErgebnis = 1
    6. $Abbruch = $false
    7. for ($i = 1; $i -lt $Fakultaet; $i++)
    8. {
    9. $FakultaetErgebnis = $FakultaetErgebnis * $i
    10. if ($FakultaetErgebnis -gt [System.Int32]::MaxValue) { $Abbruch = $true; break; }
    11. }
    12. if ($Abbruch) { "Werteüberlauf!" }
    13. else { "Die Fakultät von " + $Fakultaet + " ist " + $FakultaetErgebnis }
    Code hier als Beispiel - im Seminar wurden auch andere Codes behandelt!
  • foreach (automatische Schleifen)
    automatischer Schleifenmechanismus
    View source
    1. # einfaches nummerisches Array
    2. $menge = 1,2,3,4,5
    3. foreach ($i in $menge)
    4. { $i }
    5. # Array/Objekt aus Get-Service
    6. $dienste = Get-Service
    7. foreach ($dienst in $dienste)
    8. { # Nutzung eines Ausgabeoperator -f
    9. "{0,-20}: {1}" -f $dienst.Name , $dienst.Status
    10. }
    Ausgabeoperator -f siehe später auch bei verbesserten Ausgabetechniken
  • Ausgaben (Part II - Forts. Ausgabeformate und Formatierungen)
    weitere Ausgabtechniken - siehe wieder Get-Command Out-*
    Cmdlets für Formatierungen:
    Format-Wide (kurz: fw): zweispaltige Liste
    Format-List (kurz: fl): detaillierte Liste
    Format-Table (kurz: ft): Tabellenausgabe
    View source
    1. # Gezieltes Ausgeben der Tabellen - Propierties (Methoden)
    2. Get-Service | Select-Object -first 5 | Format-Table
    3. Get-Service | Select-Object -first 5 | Format-Table *
    4. Get-Service | Select-Object -first 5 | Format-Table -property Name, CanStop
    5. # Standardausgabe gemäß DotNetTypes.Format.ps1xml (eigentlich also DOT.NET Formate!)
    6. Get-ViewDefinition System.Diagnostics.Process
    7. Get-Process | Format-Table –view priority
    8. # Ausgaben einschränken
    9. Get-Process | Format-Table -Property id,processname,workingset
    10. # als auch
    11. Get-Process | Select-Object id, processname, workingset | Format-Table
    12. # Seitenweise Ausgabe - oft sehr viel geschickter als altes more
    13. Get-Service | Out-Host -Paging
  • Ausgabe-Commandlets in Host/Konsole:
    Write-Host, Write-Warning und Write-Error
    Mit Write-Host manuelle Konfiguration möglich
    Write-Host "Hallo Joe" -foregroundcolor red -backgroundcolor white
  • Spezielle Formate/Formatierungen
    ein paar beispielhafte Codes
    View source
    1. $a = "Joe Brandes"
    2. $b = "info(at)pcsystembetreuer.de"
    3. $c = Get-Date
    4. # wieder: in doppelten Zeichenketten sind Variablen nutzbar
    5. $a + " ist erreichbar unter " + $b + ". Diese Information hat den Stand: " + $c + "."
    6. "$a ist erreichbar unter $b. Diese Information hat den Stand: $c."
    7. # Neu: mit Platzhaltern und Formatbezeichnern: Ausgabeoperator -f
    8. "{0} ist erreichbar unter {1}. Diese Information hat den Stand: {2:D}." -f $a, $b, $c
    9. # weitere Formatierungen
    10. Get-Process | ForEach-Object { "{0,-40} | {1}" -f $_.Name, ($_.ws/1MB)}
    11. Get-Process | ForEach-Object { "{0,-40} | {1:n}" -f $_.Name, ($_.ws/1MB)}
    12. Get-Process | ForEach-Object { "{0,-40} | {1:0.000}" -f $_.Name, ($_.ws/1MB)}
    13. # Benutzerdefinierte Ausgabeformatierung mit @-Symbol:
    14. Get-Process | sort workingset64 -desc | ft @{Label="Nr"; Expression={$_.ID}; Width=5}, @{Label="Name"; Expression={$_.Processname}; Width=20 }, @{Label="Speicher MB"; Expression={$_.WorkingSet64 / 1MB}; Width=11; Format="{0:0.0}" }
    15. # Unterobjekt mit eigenen Methoden und Eigenschaften richtig ausgeben:
    16. Get-Process | ft ProcessName, { $_.TotalProcessorTime.Hours }
    Bitte immer wieder mit manuellen Anpassungen die Wirkungen testen und Hilfen bemühen.
  • Ausgaben unterdrücken:
    Unterschiedliche Techniken, um die Ausgabe von Skriptcode zu verhindern:
    View source
    1. # Out-Null verwenden:
    2. Commandlet | Commandlet | Out-Null
    3. # Variable zugewiesen:
    4. $a = Commandlet | Commandlet
    5. # Typ [void] nutzen:
    6. [void] (Commandlet | Commandlet)
    7. # $null zuweisen:
    8. $null = Commandlet | Commandlet
  • Eingaben in der PowerShell (Interaktionen)
    Unterschiedliche Eingaben / Interaktionen mit der PowerShell durchgespielt:
    View source
    1. # Eingaben
    2. # ========
    3.  
    4. # in Shell: Standardeingaben mittels Read-Host (Typ: System.String)
    5. $name = read-host "Bitte Benutzernamen eingeben:"
    6. # Standardeingaben verschlüssel mittels Read-Host (Typ: System.Security.SecureString)
    7. $kennwort_verschluesselt = read-host -assecurestring "Bitte Kennwort eingeben:"
    8. # Das verschlüsselte Kennwort wieder zurückholen
    9. [String]$kennwort_unverschluesselt = [Runtime.InteropServices.Marshal]::PtrToStringAuto([Runtime.InteropServices.Marshal]::SecureStringToBSTR($kennwort_verschluesselt))
    10. "Kennwort: " + $kennwort_unverschluesselt
    11.  
    12. # GUI: mittels .NET Framework in der Klasse Microsoft.VisualBasic.Interaction
    13. [System.Reflection.Assembly]::LoadWithPartialName("Microsoft.VisualBasic")
    14. $eingabe = [Microsoft.VisualBasic.Interaction]::InputBox("Bitte geben Sie Ihren Namen ein!")
    15. "Hallo $Eingabe!"
    16.  
    17. # Dialogfenster (auch mit Dot.NET)
    18. [System.Reflection.Assembly]::LoadWithPartialName("System.windows.forms")
    19. [System.Console]::Beep(15440, 30)
    20. [System.Windows.Forms.MessageBox]::Show("Gleich kommt eine Frage","Vorwarnung",
    21. [System.Windows.Forms.MessageBoxButtons]::OK)
    22. $antwort = [System.Windows.Forms.MessageBox]::Show("Nachricht","Ueberschrift", [System.Windows.Forms.MessageBoxButtons]::YesNo)
    23. if ($antwort -eq "Yes") { "Sie haben zugestimmt!" } else { "Sie haben abgelehnt!" }

    Wichtig: die besondere Bedeutung von Parameter -Credential bzw. Cmdlet Get-Credential  für Zugriffe per "Remote"-Authentifizierungen

 

  • .NET Klasse nutzen.NET Klasse nutzen
  • Statische KlasseStatische Klasse
  • MSDN - HilfenMSDN - Hilfen
  • Out-GridViewOut-GridView
  • Interaktion mit VBInteraktion mit VB
  • .NET Dialogfenster.NET Dialogfenster

 

Tag 05

Freitag, 16.12.2016, 08.30 - 16.00 Uhr

  • Rekapitulation, TN-Fragen
  • Funktionen (ausführlich kommentiert)
    Durch die saubere Zuweisung mit Kommentarblock in einer Funktion wird die komplette Hilfe und Intellisense nutzbar.
    View source
    1. # aus Weltner S. 478
    2. function Get-CriticalEvent
    3. {
    4. <#
    5.  .SYNOPSIS
    6.  listet Fehler und Warnungen aus dem System-Ereignisprotokoll auf
    7.  .DESCRIPTION
    8.  liefert Fehler und Warnungen der letzten 48 Stunden aus dem
    9.  System-Ereignisprotokoll,
    10.  die auf Wunsch in einem GridView angezeigt werden. Der Beobachtungszeitraum
    11.  kann mit dem Parameter -Hours geändert werden.
    12.  .PARAMETER Hours
    13.  Anzahl der Stunden des Beobachtungszeitraums. Vorgabe ist 48.
    14.  .PARAMETER ShowWindow
    15.  Wenn dieser Switch-Parameter angegeben wird, erscheint das Ergebnis in einem
    16.  eigenen Fenster und wird nicht in die Konsole ausgegeben
    17.  .EXAMPLE
    18.  Get-CriticalEvent
    19.  liefert Fehler und Warnungen der letzten 48 Stunden aus dem
    20.  System-Ereignisprotokoll
    21.  .EXAMPLE
    22.  Get-CriticalEvent -Hours 100
    23.  liefert Fehler und Warnungen der letzten 100 Stunden aus dem
    24.  System-Ereignisprotokoll
    25.  .EXAMPLE
    26.  Get-CriticalEvent -Hours 24 -ShowWindow
    27.  liefert Fehler und Warnungen der letzten 24 Stunden aus dem
    28.  System-Ereignisprotokoll und stellt sie in einem eigenen Fenster dar
    29.  .NOTES
    30.  Dies ist ein Beispiel aus Tobias Weltners' PowerShell Buch
    31.  .LINK
    32.  http://www.powertheshell.com
    33. #>
    34. param($Hours=48, [Switch]$ShowWindow)
    35.  
    36. if ($ShowWindow)
    37. {
    38. Set-Alias Out-Default Out-GridView
    39. }
    40.  
    41. $Heute = Get-Date
    42. $Differenz = New-TimeSpan -Hours $Hours
    43. $Stichtag = $Heute - $Differenz
    44.  
    45. Get-EventLog -LogName System -EntryType Error, Warning -After $Stichtag |
    46. Select-Object -Property TimeGenerated, Message | Out-Default
    47. }
    Ausführliche Tests mit zusätzlichen Parameter $LogName.
  • Module (selbstgemacht)
    Module sind Container für eigene Funktionen und Cmdlets und lassen sich wie folgt einbinden.
    Damit die Module vom PowerShell-System erkannt und genutzt werden können, müssen die Module an entsprechenden Stellen etabliert werden.
    Ermitteln der Modulpfade (Modul-Hauptordner im PowerShell-System)
    View source
    1. # Modulpfade ermitteln
    2. $env:PSModulePath -split ";"
    3. ($env:PSModulePath).split ";" # Alternative
    4. ($env:PSModulePath -split ";")[0] # erstes Element
    Einfache Modultechnik:   
    - Ordner mit ModulName
    - Im Ordner gleichnamige *.psm1 Datei: ModulName.psm1 
    Für die folgenden Erstellungen muss der PowerShell-Host die Funktion kennen!
    Hier: Get-CriticalEvent – Fehler und Warnungen aus System-Ereignisprotokoll – letzte 48 Stunden).
    View source
    1. # folgende Befehle in Umgebung, wo Funktion Get-CriticalEvent bekannt ist!
    2. # Funktion siehe oben...
    3. $name = 'Get-CriticalEvent'
    4. $path = Split-Path -Path $profile
    5. $code = "function $name { $((Get-Item function:\$name).Definition) }"
    6. New-Item -Path $path\Modules\$name\$name.psm1 -ItemType File -Force -Value $code
    7.  
    8. # Erster Test für die Verfügbarkeit des Cmdlet per Modul:
    9. Get-Module get-cr* -ListAvailable
    Natürlich möchte man nicht nur eine Funktion pro Modul - dafür müssten wir uns noch intensiver mit Modulen beschäftigen.
  • Seminarnetz mit Domänen
    Ab heute ist der Seminarraum mit einem Domänen-Umgebung für das PowerShell-Seminar ausgestattet.
    Die Dokumentation der bereitgestellten Umgebung entnehmen Sie dem Vorseminar "Windows Server / VHS BS / 28.11. - 02.12.16"
    Wichtig: wir konzentrieren uns auf die PowerShell und lassen die "Server-Domänen-Active-Directory-Technik" beiseite
  • Analyse und Inbetriebnahme der PowerShell Umgebung
    PowerShell-Versionen? ( $PSVersionTable )
    Excecution Policy? (Get-ExecutionPolicy / Set-ExecutionPolicy)
    Hinweis auf Gruppenrichtlinie in seminar.local für Verteilung von Policy "RemoteSigned"
    PowerShell Umgebung: $PROFILE bereitstellen (Tipp: New-Item -ItemType File $PROFILE -Force )
    PowerShell Hilfe aktualisieren (Update-Help - als Administrator) und in Konsole nutzen
  • Get-WmiObject  und  Get-CimInstance
    die klassische WMI (Windows Management Interface) und die "neuere" Variante CIM (Common Information Model) bieten Zugriff auf Hunderte von Klassen mit Zugriff auf Systeminformationen und -Techniken
    Get-WmiObject -Class Win32_Bios -Computername DC01   (also gleich mit eingebautem "Fernzugriff")
    Nur mal so zum Schnuppern - morgen dann mehr:
    Auflistung aller Klassen mit Get-WmiObject -List 
    Bei CIM nutze man Get-CimClass 
    Beispielhafte Aufrufe:
    View source
    1. # Service Start Modi - Anmerkung: Get-Service kann keinen StartMode!
    2. Get-WmiObject Win32_Service | Select-Object Name, StartMode
    3. # ein spezieller Startmodus
    4. ([wmi]'Win32_Service.Name="Spooler"').StartMode
    5. # eingeloggte User
    6. $ComputerName = ‘localhost’
    7. Get-WmiObject Win32_ComputerSystem -ComputerName $ComputerName | Select-Object -ExpandProperty UserName
    8. # Netzwerkanalyse
    9. function Get-NetworkConfig {
    10. Get-WmiObject Win32_NetworkAdapter -Filter ‘NetConnectionStatus=2|
    11. ForEach-Object {
    12. $result = 1 | Select-Object Name, IP, MAC
    13. $result.Name = $_.Name
    14. $result.MAC = $_.MacAddress
    15. $config = $_.GetRelated(‘Win32_NetworkAdapterConfiguration’)
    16. $result.IP = $config | Select-Object -ExpandProperty IPAddress
    17. $result
    18. }
    19. }
    20. # Lokale Gruppen
    21. Get-WmiObject Win32_Group -Filter "domain='$env:computername'" | Select-Object Name,SID
    22. # Uptime Os
    23. $os = Get-WmiObject -Class Win32_OperatingSystem
    24. $boottime = [System.Management.ManagementDateTimeConverter]::ToDateTime($os.LastBootupTime)
    25. $timedifference = New-TimeSpan -Start $boottime
    26. $days = $timedifference.TotalDays
    27. 'Das System läuft seit {0:0.000} Tagen.' -f $days
    28. # Freier Speicher auf Disks
    29. Get-WmiObject Win32_LogicalDisk |
    30. ForEach-Object { ‘Disk {0} hat {1,20:0.00} MB Platz frei’ -f $_.Caption, ($_.FreeSpace / 1MB)
    31. }
    Vergleich WMI vs. CIM - Scripting Guy Blog (Link)
    Introduction to CIM - PowerShell Blog (Link)
    Hinweis auf PowerShell Cookbook PDFs von Autor Weltner (Link)
  • Fernverwaltungen
    Vier unterschiedliche Techniken gezeigt und genutzt:

    1) RSAT (Remoteserver Administration Tools - Download RSAT für Windows 10 - bitte Windows-Version beachten!)
    Analyse Anzahl Commandlets/Functions: Windows 8.1 hatte 1264
    ein Windows 8.1 + RSAT zählte dann 2211 (!)  und RSAT stellt mit dem "Active Directory-Verwaltungscenter" die moderne AD-Verwaltung mit Sicht auf die PowerShell-Befehle bereit (Windows PowerShell Verlauf History)
    Beispiel für AD-Commandlet aus Modul "ActiveDirectory": Get-ADUser -Filter { Name -like "*Joe*" }  

    2) Commandlets mit eingebauter Funktionalität (-ComputerName) für Fernaufrufe auf anderen Maschinen

    View source
    1. # Commandlets mit eingebauter "Fernwartung"
    2. Get-Command | where { $_.parameters.keys -contains "ComputerName" -and $_.parameters.keys -notcontains "Session"}
    3. # Aufrufsbeispiel: (auch gerne gleichzeiig auf mehreren Maschinen)
    4. Get-Service -ComputerName domvbox-2012r2 i*

    3) PowerShell Sessions - die moderne MS Terminalsitzung / Shellsession
    Technikhintergrund:
    WinRM (Windows Remote Management);
    Anforderungen für WinRM Services: Microsoft .NET Framework 2.0 oder höher; Windows PowerShell 2.0 oder höher; Windows Remote Management (WinRM) 2.0
    Rechner für PowerShell Sessions (PSRemoting) vorbereiten:
    View source
    1. # WinRM-Systemdienst starten (inkl. Firewall - Netzwerkverbindungstyp beachten - kein Öffentliches Profil!)
    2. Enable-PSRemoting
    3. # Unterdrücken der Nachfragen und aktueller Netzwerkprofile-Checks mit
    4. Enable-PSRemoting -SkipNetworkProfileCheck -force
    5. # Testen der Fähigkeit:
    6. New-PSSession   # bzw.: Test-WSMan

    in Firmen/Domänen kann man die folgende Gruppenrichtlinie nutzen:
    Computer Configuration\Administrative Templates\Windows Components\Windows Remote Management (WinRM)\WinRM service
    Beispielhafte Nutzung:
    View source
    1. # Interaktiv Sitzung:
    2. Enter-PSSession –Computername domvbox-2012r2
    3. # komplette Anmeldung inkl. -credential
    4. Enter-PSSession domvbox-2012r2 -Authentication Negotiate -credential dom2012r2\Administrator
    5. # Beenden:
    6. Exit-PSSession
    7. # aktuelle Konsolenmaschine
    8. [System.Environment]::MachineName
    Alternative Aufrufe und weitere technische Möglichkeiten mittels Commandlet Invoke-Command
    Anregung: Recherche nach Cmdlets mit *PSSession*

    4) PowerShell WebAccess (PSWA)
    Installation auf Server von Rolle "Web Server (IIS)" und Feature "Windows PowerShell/Windows PowerShell Web Access"
    alternativ mit PowerShell: Install-WindowsFeature -name web-server, windowspowershellwebaccess

    View source
    1. # Installieren/Bereitstellen von Test-Zertifikat
    2. Install-PswaWebApplication -UseTestCertificate
    3. # Anm.: jetzt Server erreichbar unter https://localhost/pswa # Regel (hier sehr "frei") für die Erreichbarkeit von PSWA erstellen:
    4. Add-PswaAuthorizationRule –UserName * -ComputerName * -ConfigurationName *
    Beim Aufruf der Webseite https: // dc-server/pswa  muss man natürlich das Zertifikat im Browser anerkennen (lassen)

  • Letzte TN-Fragen, Feedback-Bögen, TN-Bescheinigungen

 

  • SprachausgabeSprachausgabe
  • Eigenes ModulEigenes Modul
  • Get-Module -ListAvailableGet-Module -ListAvailable
  • WMI - CIMWMI - CIM
  • Funktionen sauber deklariertFunktionen sauber deklariert
  • PowerShell WebAccessPowerShell WebAccess

 

Bücher und Co

Ich habe in der Woche auch immer wieder auf online und offline Quellen hingewiesen, die ich an dieser Stelle nochmal darstellen möchte.

Die folgenden Bücher hatte ich auch im Seminar (Tag 03 - Mittwoch) vorgestellt und mit den Teilnehmern eingeschätzt:

  • Tobias WeltnerTobias Weltner
PowerShell 5: Windows Automation für Einsteiger und Profis Gebundene Ausgabe
2. Juni 2016 Dr. Tobias Weltner: 1158 Seiten Verlag: O'Reilly;
Auflage: 2., akt. Aufl. (2. Juni 2016)
Sprache: Deutsch
ISBN-10: 3960090099
ISBN-13: 978-3960090090

Windows PowerShell 4.0: Das Praxisbuch Gebundene Ausgabe – 8. Mai 2014
von Dr. Holger Schwichtenberg
Gebundene Ausgabe: 926 Seiten
Verlag: Carl Hanser Verlag GmbH & Co. KG (8. Mai 2014)
Sprache: Deutsch
ISBN-10: 3446440704
ISBN-13: 978-3446440708 

Windows PowerShell Cookbook: The Complete Guide to Scripting Microsoft's Command Shell (Englisch) Taschenbuch – 8. Januar 2013
von Lee Holmes
Taschenbuch: 1034 Seiten
Verlag: O'Reilly & Associates; Auflage: 3 (8. Januar 2013)
Sprache: Englisch
ISBN-10: 1449320686
ISBN-13: 978-1449320683

Schnelleinstieg in die Windows PowerShell. oreillys basics Broschiert – 28. März 2007
von Andy Oakley (Anm.: als Beispiel für eine sehr ordentliche Einstiegslektüre - natürlich nicht mehr aktuell!)
Broschiert: 240 Seiten
Verlag: O'Reilly; Auflage: 1 (28. März 2007)
Sprache: Deutsch
ISBN-10: 3897214873
ISBN-13: 978-3897214873

  • Lee Holmes
  • Cookbook
  • Tobias Weltner
  • Windows Automation
  • powershell50-praxis-00
  • powershell50-praxis-01
  • Dr. H. Schwichtenberg
  • Das Praxibuch
  • Andy Oakley
  • Schnelleinstieg

Falls Sie Anregungen hinsichtlich Büchern und Webseiten haben, dann bitte einfach per Mail an mich melden.

 

 

Vielen Dank für Ihre überaus positiven Feedbackbögen und Ihre persönlichen Rückmeldungen und Interessen an weiteren Seminaren.
Ihr Trainer Joe Brandes

  Privates

... zu Joe Brandes

Sie finden auf dieser Seite - als auch auf meiner privaten Visitenkarte joe-brandes.de einige Hintergrundinformationen zu mir und meinem Background.
Natürlich stellt die IT einen Schwerpunkt in meinem Leben dar - aber eben nicht nur ...

joe brandes 600px

Private Visitenkarte / Technik: HTML & CSS /
  joe-brandes.de

  Jobs

... IT-Trainer & Dozent

Ich erarbeite und konzipiere seit über 20 Jahren IT-Seminare und -Konzepte. Hierfür stehen der "PC-Systembetreuer / FITSN" und der "CMS Online Designer / CMSOD". Ich stehe Ihnen gerne als Ansprechpartner für Ihre Fragen rund um diese und andere IT-Themen zur Verfügung!

becss 600px

BECSS Visitenkarte / Technik: HTML & CSS /
  becss.de

  Hobby

... Snooker & more

Wer einmal zum Snookerqueue gegriffen hat, der wird es wohl nicht wieder weglegen. Und ich spiele auch immer wieder gerne eine Partie Billard mit den Kumpels und Vereinskameraden. Der Verein freut sich über jeden, der einmal in unserem schicken Vereinsheim vorbeischauen möchte.

bsb 2011 600px

Billard Sport BS / Joomla 3.x /
  billard-bs.de

PC Systembetreuer ist J. Brandes - IT seit über 35 Jahren - Technik: Joomla 3.4+, Bootstrap 3.3.4 und "Knowledge"

© 2017 - Websitedesign und Layout seit 07/2015 - Impressum
Nach oben