Windows Loginscripte – Scriptsprachen

Im letzten Artikel habe ich verschiedene Mechanismen für die Abarbeitung von Laufwerksverbindungen etc. gegenüber gestellt. Meine persönliche Präferenz dabei sind die klassichen Loginscripte und hier möchte ich ein wenig die verschiedenen Scriptsprachen gegenüberstellen, mit welchen ich schon hab Erfahrungen sammeln dürfen.



Batch

Der Klassiker schlechthin unter den Loginscripts. Die Befehle funktionieren seit ich IT-denken kann und sie machen was sie sollen.

Für einfachste Umgebungen sicherlich eine gute Wahl.

Der grösste Nachteil ist dem Alter geschuldeten schwachen Leistungsumfang. Solange z.B. alle Benutzer die gleichen Laufwerke benötigen funktioniert es tadellos. Sobald aber Gruppenmitgliedschaften geprüft werden müssen, kommt es schon langsam an seine Grenzen.

PowerShell

PowerShell bietet in seiner Fülle an Modulen und Befehlen viele Möglichkeiten und dies auch bei der Anmeldung.

Wenn man jedoch den Ursprung von PowerShell kennt wird einem schnell klar, dass die Sprache nicht auf Performance aus ist. PowerShell wurde entwickelt um den Administratoren eine Möglichkeit der Verwaltung und der Automatisierung zu bieten. Bei diesen Aufgaben kommt es sehr oft nicht auf die (Milli)Sekunden an und das bringt uns zum grossen Nachteil der Scriptsprache für den Anmeldeprozess. Je komplexer die Aufgaben des Loginscriptes sind, desto langsamer wird es und das spürt die Benutzerin/der Benutzer.

Ich hatte einen Kunden im Schulbereich mit einem Skript, welches mit rund 350 Zeilen die komplette Umgebung eines Benutzers eingerichtet hat. Vom Laufwerk, über die Drucker bis hin zu applikatorischen Einstellungen. Das Skript hat gemacht was es soll, es dauerte einfach jeweils zwischen 3 bis 4 Minuten pro Anmeldung!

Ein weiterer Nachteil kann sein, dass auf den Clients die PowerShell Versionen nachgepflegt werden müssen, je nach eingesetzten Befehlen.

VBScript (VBS)

VBScript ist für viele Systemtechniker erst einmal ein Buch mit sieben Siegeln. Es ist definitiv nicht so intuitiv wie Batch oder PowerShell, bietet jedoch auch eine Fülle von Möglichkeiten, wenn auch mit teils nicht verständlichen Einschränkungen.

Vor Jahren habe ich mich mit VBS auseinander gesetzt (auch geschuldet der Ausbildung) und es ist mittlerweile mein Favorit unter den Skriptsprachen aus folgenden Gründen:

  • Performance: VBS wird schnell abgearbeitet. Teilweise sogar zu schnell für das Windows, so dass bewusste Pausen eingepflegt werden müssen.
    Das vorher erwähnte PowerShell Skript wurde durch VBS abgelöst und benötigte nur noch 45 Sekunden statt mehrere Minuten.
  • Modular: Sauber geschrieben kann ein VBS basiertes Skript sehr modular aufgebaut werden.
  • OS integriert: VBS wird von sämtlichen aktuellen Windows Betriebssystemen unterstützt.

Die Skriptsprache hat auch seine Nachteile, über welche ich dank den Vorteilen hinweg sehen kann:

  • Fehlende Vereinfachung: Gewisse Aktionen können nicht einfach mit einer oder zwei Zeilen erledigt werden, sondern bedürfen um ein Vielfaches. So hatte nach der Ablösung des obigen genannten PowerShell Skriptes das neue VBS basierte nicht mehr rund 350 sondern über 3000 Zeilen.
  • Fehlende Funktionen: Verschachtelte Gruppenmitgliedschaften können z.B. nicht einfach ausgelesen werden. Für solche Fälle ist es jedoch möglich für diese eine Abfrage gezielt z.B. auf PowerShell auszuweichen.

KiXtart (aka KIX)

KIX ist eine weitere oft eingesetzte Skriptsprache. Auch diese ist einfach zu erlernen und anzuwenden. Sie bietet die Standardfunktionen, welche man üblicherweise benötigt. Vereinzelt habe ich diese schon vorgefunden, jedoch für mich hat sie folgenden erheblichen Nachteil:

  • Proprietär: benötigt zusätzliche Programmdateien (via NETLOGON) und ist in den letzten Jahren in der Community kaum mehr aktualisiert worden.

Ich würde somit KIX als umfangreicher wie Batch jedoch schwächer wie VBS/PowerShell einordnen.




Windows Loginscripte & Co.

Ich denke jeder Windows Admin kennt es. Die Benutzer möchten ihre Laufwerke gemappt und am liebsten auch gleich die Drucker verbunden haben. Ich möchte an dieser Stelle meine Sicht auf verschiedene Mechanismen werfen immer auch mit dem Fokus eines Citrix Admins.



Loginscripte

Irgendwelche Skripte welche während der Benutzeranmeldung Laufwerke und Drucker verbinden, Dateien kopieren, etc. gibt es schon seit eh und je. Oder zumindest kenne ich diese seit dem Beginn meiner IT Karriere (Windows 3.11, Windows 95, Windows NT).

Diese funktionieren in der Regel gut und schnell. Die Administratoren müssen sich lediglich mit der entsprechenden Skriptsprache auskennen und man kann loslegen.

Group Policy Preferences (GPP)

Mit Windows 2008/Windows Vista wurden die seit Windows 2000 bekannten Gruppenrichtlinien durch die „Group Policy Preferences“ (exakte Übersetzung mir nicht bekannt) erweitert. Diese kombiniert mit den dazu benötigten Clientseitigen Erweiterungen bieten eine einfach verständliche grafische Oberfläche für die gewünschten Aktionen, welche bei der Anmeldung eines Active-Directory Benutzers ausgeführt werden.

Die GPP sind wirklich intuitiv in der Handhabung und in einem einfachen Server-/Client-Netzwerk eine gute Wahl. Meiner Erfahrung und Meinung nach gibt es jedoch gerade im Citrix Virtual Apps and Desktop (oder DaaS) Umfeld zwei entscheidende Nachteile:

  • Performance: die Abarbeitung der GPP ist z.B. im Vergleich mit einem klassischen VBScript um einiges langsamer, was sich in der (negativen) Zufriedenheit der Benutzer widerspiegelt. Wenn dann noch viele Filter (WMI, Item-level Targeting, etc.) verwendet werden, wird es umso träger.
  • Abhängigkeiten: es gibt div. Applikationen, welche beim Start vollständig verbundene Laufwerke und Drucker erwarten. Die GPP werden jedoch im Hintergrund ausgeführt und dabei kann es vorkommen, dass beim Start einer veröffentlichten Applikation die erwarteten Laufwerke und Drucker fehlen und es so zu anderen Problemen kommt.

3rd Party

Es gibt auf dem Markt div. Dritthersteller, welche sich der einfachen Verwaltung und der optimierten Anmeldeleistung verschrieben haben. In der Regel machen diese auch ihren Job, jedoch gibt es dabei für mich folgende Punkte zu bedenken:

  • Kosten: Dritthersteller schenken in der Regel nichts, also muss eine saubere Kosten-/Nutzen-Rechnung gemacht werden.
  • Abhängigkeiten: Normalerweise bringt jedes Dritthersteller-Produkt seine eigenen Komponenten mit. Diese müssen implementiert und gepflegt werden. In der Fehlersuche hat man diese zusätzlich zu berücksichtigen.
  • Betrieb: Als Consultant und/oder Engineer versuche ich Umgebungen immer so aufzubauen, dass sie später auch im Support nicht zu komplex werden. Je mehr man sich an die integrierten Mittel hält, umso einfacher ist in der Regel auch die Wissensvermittlung an Betriebsteams. Jede Komponente mehr macht den Support in der Regel nicht einfacher sondern eher umgekehrt.

Tabellarische Gegenüberstellung

Loginscripte GPP 3rd Party
Vorteile – OS eigene Mittel
– Je nach Sprache einfache Handhabung
– theoretisch ohne Active-Directory möglich
– OS eigenes Mittel
– Intuitive Handhabung
– grafische Verwaltungsoberfläche
– meist intuitive Handhabung
Nachteile – Performance abhängig von der eingesetzten Scriptsprache
– Scriptsprache muss erlernt werden
– teilweise komplexes Scripting notwendig
– Active-Directory notwendig
– je nach AD/GPO Struktur komplexe Verschachtelungen
– Performance, besonders bei vielen Filtern
– Kosten
– Abhängigkeiten, da mehr Komponenten notwendig
– Komplexität im Betrieb, da mehr Komponenten zu verwalten

Persönliche Präferenz

Die beste Erfahrung habe ich mit dem klassischsten gemacht: den Loginscripten. Diese sind je nach eingesetzter Sprache und Komplexität der Kunden-/Benutzerwünsche teils langwierig in der Entwicklung, aber danach laufen die Scripte normalerweise in der gewünschten Leistung.

Schlussendlich muss jeder für sich die richtige Lösung finden. Meiner Meinung nach am wichtigsten dabei ist, dass in einer Umgebung nur eine Lösung eingesetzt wird und nicht x verschiedene. Das Leben des IT-Personals ist meist schon kompliziert genug.




WSUS – Konfiguration für MDT Umgebung

Ich habe mich in letzter Zeit mit MDT (Microsoft Deployment Toolkit) beschäftigt und mir da auch Gedanken zum WSUS gemacht. In meinem Umfeld wird MDT vor allem für die Installation/Wartung von Citrix Workern (Terminalserver und VDI) genutzt. Diese sind sehr oft auch aus dem Internet zugänglich und sollten daher auch auf einem zeitnahen Patch-Stand sein. Nur wie löst man dies am einfachsten?



Ich ging nun von folgenden Voraussetzungen aus:

  1. Der WSUS soll dediziert für MDT genutzt werden mit sparsamen Ressourcenverbrauch
  2. Die eingesetzten Produkte sind bekannt
  3. Die Client melden regelmässig den Patch-Level
  4. Updates werden freigegeben sobald verfügbar und benötigt

    • Die Tests finden bei der Abnahme der Citrix Worker statt

Die Installation eines WSUS ist im Internet bestens dokumentiert, ansonsten verweise ich auch gerne auf https://www.wsus.de/

Für die Automatisierung des WSUS habe ich bereits eine kleine Serie verfasst mit folgenden Artikeln:

Die Nummern in der Klammern referenzieren auf die entsprechenden Voraussetzungen.

Durch die Kombination der verschiedenen Automatisierungen läuft der WSUS nun soweit autonom und benötigt kaum mehr manuelle Pflege. :-)

Viel Spass beim Nachbauen.




WSUS – Automatisiertes Update Management

So cool WSUS (Windows Server Update Service) auch ist, so hat er sich leider seit dem Erscheinen mit Windows Server 2003 nicht wirklich weiter entwickelt. Im Bereich der Update-Pflege (Freigabe, Ablehnung, etc.) ist mir der WSUS noch immer nicht flexibel genug. Glücklicherweise kann man hier aber mit PowerShell Abhilfe schaffen und dafür habe ich in meinem Lab mehrere Scripte integriert.



Als erstes fangen wir einmal ganz zu Beginn an…

Beim Einrichten des WSUS wird man ja schön durch den Assistenten geführt mit der Frage nach den Produkten, Klassifizierungen, etc. und zu guter Letzt wird in der Regel die erste Synchronisation durchgeführt. Ist diese beendet würde man am liebsten schon die automatischen Freigaben konfigurieren… STOP!

Ersetzte Updates automatisch ablehnen

Leider schafft es Microsoft bis heute nicht, dass bereits ersetzte Updates gar nicht mehr auf alle WSUS in dieser Welt synchronisiert werden. Bei mir sah es zum Beispiel so aus, nachdem ich in meinem Lab die Windows 10 und Office 2016 Updates hinzugefügt hatte:

Hier kommt nun ein erstes Script in meiner Umgebung ins Spiel, welche ich bei Microsoft Learn gefunden habe. Das genannte Script habe ich für mich lediglich noch so modifiziert, dass ein eigener Pfad für die Logdateien genutzt werden kann, anstatt ein Unterordner vom Script-Pfad.

Das Script läuft bei mir als geplanter Task nach der WSUS Synchronisation und lehnt per se ersetzte Updates gleich einmal ab. So verhindere ich, dass die Update-Dateien später überhaupt heruntergeladen werden.

Voraussetzungen und Parameter für den ersten Task:
– Servicebenutzer benötigt WSUS Admin Rechte (entsprechende Gruppenmitgliedschaft)
– Programm: PowerShell.exe
– Parameter: -ExecutionPolicy Bypass <Pfad>\Decline-SupersededUpdates.ps1 -UpdateServer SERVERNAME -Port PORT#

Nachdem dieser Task ausgeführt wurde, sieht die Statistik schon ein erstes Mal aufgeräumter aus:

Nicht benötigte Updates automatisch ablehnen

Nun gibt es aber immer noch viele Updates, welche ich in meiner Umgebung nie benötigen werde. Ich habe mir deshalb ein Script aufgebaut, in welchem ich als erstes Ausschlüsse definiere wie z.B. Prozessortypen, Windows Editionen und Sprachen. Das Script wird ebenfalls in einem geplanten Task ausgeführt, nachdem die ersetzten Updates bereits bereinigt sind:

Voraussetzungen und Parameter für den ersten Task:
– Servicebenutzer benötigt WSUS Admin Rechte (entsprechende Gruppenmitgliedschaft)
– Programm: PowerShell.exe
– Parameter: -ExecutionPolicy Bypass <Script-Pfad>

Vergleicht man nun auch noch diese Statistik, so sieht es schon sehr viel aufgeräumter aus:

Benötigte Updates automatisch freigeben

Nun wollte ich in meiner Lab-Umgebung darauf verzichten mittels automatischer Freigabe einfach Updates freizugeben und herunter zu laden, obwohl ich sie wahrscheinlich nie benötige. Im vorherigen Artikel habe ich beschrieben, wie man die Clients dazu bringt einen regelmässigen Report zu erstellen. Diese Informationen nutze ich im dritten und letzten Script um angeforderte Updates automatisch freizugeben. Damit kann z.B. sichergestellt werden, dass beim nächsten Lauf einer MDT Tasksequenz der frisch aufgesetzte Rechner die aktuellsten Updates installiert hat.

Dieses Script lasse ich ebenfalls als geplanten Task nach den Bereinigungen ausführen:

Voraussetzungen und Parameter für den ersten Task:
– Servicebenutzer benötigt WSUS Admin Rechte (entsprechende Gruppenmitgliedschaft)
– Programm: PowerShell.exe
– Parameter: -ExecutionPolicy Bypass <Script-Pfad>

Hinweis: Dieses Script sollte natürlich NICHT in einer Umgebung eingesetzt werden, in welcher auch sämtliche Windows Updates einer Change- und Test-Prozedur unterstehen.

Viel Spass beim Nachbauen. :-)




WSUS – Clients zum Update Report zwingen

Wahrscheinlich kennt jeder Administrator, welcher auch WSUS im Einsatz hat die Thematik, dass die Clients mit den Reports auf sich warten lassen.

Nach ein wenig Recherche bin ich bei div. Blogs auf Scripts gestossen, welche den WU Client dazu bringen, dem WSUS sofort einen entsprechenden Report zu senden. Genanntes Script habe ich für mich so modifiziert, dass es nicht vom WSUS aus mittels „Invoke“ sondern direkt auf dem Client (Desktop OS wie auch Server OS) ausgeführt wird.

Voraussetzung ist natürlich, dass die entsprechenden GPO Einstellungen für die WSUS Kommunikation eingerichtet und funktionell sind. ;-)

Das unten verfügbare Script kann dann mittels geplantem Task als „SYSTEM“ regelmässig ausgeführt werden, damit der WSUS auch stets den aktuellen Patch-Stand seiner Zielcomputer weiss.

Parameter für den geplanten Task:
– Programm: PowerShell.exe
– Parameter: -ExecutionPolicy Bypass <Pfad zum Script>

Viel Spass beim Nachbauen. :-)




Installierte .NET Framework Version prüfen

Disclaimer: Bei diesem Artikel handelt es sich definitiv nicht um eine eigene „Entwicklung“.

Nicht selten setzen Programme eine bestimmte .NET Version voraus. Windows bietet leider keine einfache Möglichkeit um diese herauszufinden. Einzig der definierte Registry Wert gibt uns einen Aufschluss auf die interne Build-Nummer, aber nicht auf die konkrete Version.

Ich bin bei Microsoft selbst auf ein Skript gestossen, welches ich seither auf mit der entsprechenden Build Tabelle nachgeführt habe:

    $dotNet4Builds = @{
        '30319'  = @{ Version = [System.Version]'4.0'                                                     }
        '378389' = @{ Version = [System.Version]'4.5'                                                     }
        '378675' = @{ Version = [System.Version]'4.5.1'   ; Comment = '(8.1/2012R2)'                      }
        '378758' = @{ Version = [System.Version]'4.5.1'   ; Comment = '(8/7 SP1/Vista SP2)'               }
        '379893' = @{ Version = [System.Version]'4.5.2'   ; Comment = '(all Windows OS)'                  }
        '380042' = @{ Version = [System.Version]'4.5'     ; Comment = 'and later with KB3168275 rollup'   }
        '393295' = @{ Version = [System.Version]'4.6'     ; Comment = '(Windows 10)'                      }
        '393297' = @{ Version = [System.Version]'4.6'     ; Comment = '(NON Windows 10)'                  }
        '394254' = @{ Version = [System.Version]'4.6.1'   ; Comment = '(Windows 10)'                      }
        '394271' = @{ Version = [System.Version]'4.6.1'   ; Comment = '(NON Windows 10)'                  }
        '394802' = @{ Version = [System.Version]'4.6.2'   ; Comment = '(Windows 10 Anniversary Update)'   }
        '394806' = @{ Version = [System.Version]'4.6.2'   ; Comment = '(NON Windows 10)'                  }
        '460798' = @{ Version = [System.Version]'4.7'     ; Comment = '(Windows 10 Creators Update)'      }
        '460805' = @{ Version = [System.Version]'4.7'     ; Comment = '(NON Windows 10)'                  }
        '461308' = @{ Version = [System.Version]'4.7.1'   ; Comment = '(Windows 10 Fall Creators Update)' }
        '461310' = @{ Version = [System.Version]'4.7.1'   ; Comment = '(NON Windows 10)'                  }
        '461808' = @{ Version = [System.Version]'4.7.2'   ; Comment = '(Windows 10 / 1803)'               }
        '461814' = @{ Version = [System.Version]'4.7.2'   ; Comment = '(other OS than Windows 10 1803)'   }
        '528040' = @{ Version = [System.Version]'4.8'     ; Comment = '(Windows 10 / 1905 & 1911)'        }
        '528372' = @{ Version = [System.Version]'4.8'     ; Comment = '(Windows 10 / 2005 & 2010 & 2105)' }
        '528449' = @{ Version = [System.Version]'4.8'     ; Comment = '(Windows 11 / Server 2022)'        }
        '528049' = @{ Version = [System.Version]'4.8'     ; Comment = '(other OS or Windows 10 builds)'   }
        '533320' = @{ Version = [System.Version]'4.8.1'   ; Comment = '(Windows 11 / 2022)'               }
        '533325' = @{ Version = [System.Version]'4.8.1'   ; Comment = '(other OS or Windows 10 builds)'   }
    }

Die Ausführung sieht dann wie folgt aus:

Ich denke mit diesen Informationen kann man mehr anfangen als den reinen Build Nummern. ;-)

Viel Spass beim Nachbauen :-)




Installierte Windows Sprachpakete prüfen

In unseren Terminalservern und VDIs wollten wir mittels Scripten die Benutzer die OS Sprache ändern lassen. Die Aufbereitung des Images mittels Citrix AppLayering hatte so seine Tücken und für eine einfache Prüfung, ob und welche Sprachen zur Auswahl stehen, habe ich folgendes kleines Skript erstellt.

Es liest über WMI die OS Parameter aus und listet diese im Anschluss in der PowerShell Ausgabe:

$OSInfo = Get-WmiObject -Class Win32_OperatingSystem
$LanguagePacks = $OSInfo.MUILanguages
$LanguagePacks

Die Ausgabe sieht dann wie folgt aus:

Viel Spass beim Nachbauen :-)




Citrix PVS Store – Replikationsskript V2

Im kürzlich erschienene Artikel habe ich die erste Fassung des Replikationsskriptes vorgestellt. In der aktuell überarbeiteten Version habe ich einerseits die Ausgaben ein wenig „verschönert“ und vor allem werden die Stores nun direkt aus dem PVS ausgelesen.

Voraussetzungen dafür sind:

  • Citrix PVS PowerShell Module an den Standardpfaden (kann in einer Variable angepasst werden)
  • Der ausführende Benutzer muss entsprechende PVS Rechte besitzen
  • Die Stores sollten verständliche Namen (Auswahl) und Beschreibungen (Hilfetexte bei Auswahl) vorweisen.

Zuerst wird nun also der Store Array dynamisch aus dem PVS ausgelesen. Voraussetzung dazu ist ein Laden des entsprechenden PVS PowerShell Moduls:

# Script variables
$PVSModulePath = "C:\Program Files\Citrix\Provisioning Services Console\Citrix.PVS.SnapIn.dll"

# Load PVS PowerShell module
Import-Module $PVSModulePath
# Get PVS vDisk stores from PVS configuration
# Create an array for later use
$Stores = Get-PvsStore

$StoreArray = $null
$StoreArray = @()
$StoreID = 0
ForEach ($Store in $Stores){
    $StoreID = $StoreID +1
    $SplitChar = $Store.Path.IndexOf(":")
    $StoreDisk = $Store.Path.Substring(0,$SplitChar)
    $StorePath = $Store.Path.Substring($SplitChar+1)
    $StoreName = $Store.StoreName
    $StoreArray += [pscustomobject]@{StoreID=$StoreID;Store=$StoreName;StoreDisk=$StoreDisk;StorePath=$StorePath;StoreDescription=$Store.Description}
}

Nun wird aus dem Array eine entsprechende PowerShell Auswahl generiert, wobei hier aktuell auch eine Limite von maximal 5 Stores eingebaut ist:

# Prompt for Store choice
$StoreTitle = "PVS vDisk stores"
$StoreMessage = "Chose the store to replicate:"
$CancelAll = New-Object System.Management.Automation.Host.ChoiceDescription "&Cancel", "Skip this operation and all subsequent operations."

# Generate choice output of each vDisk store to replicate
$StoreOptionCount = 0
ForEach ($Store2 in $StoreArray) {
    $StoreOptionCount = $StoreOptionCount + 1
    $ChoiceID = $Store2.StoreID
    $ChoiceStore = $Store2.Store
    $ChoiceHelp = $Store2.StoreDescription
    $ChoiceCmd = New-Object System.Management.Automation.Host.ChoiceDescription "&$ChoiceID $ChoiceStore", $ChoiceHelp
    New-Variable "StoreOption$ChoiceID" $ChoiceCmd
}

# Generate $StoreOptions variable for final choice output depending on the amount of options
Switch ($StoreOptionCount) {
    0 {$StoreOptions = [System.Management.Automation.Host.ChoiceDescription[]]($CancelAll)}
    1 {$StoreOptions = [System.Management.Automation.Host.ChoiceDescription[]]($CancelAll, $StoreOption1)}
    2 {$StoreOptions = [System.Management.Automation.Host.ChoiceDescription[]]($CancelAll, $StoreOption1, $StoreOption2)}
    3 {$StoreOptions = [System.Management.Automation.Host.ChoiceDescription[]]($CancelAll, $StoreOption1, $StoreOption2, $StoreOption3)}
    4 {$StoreOptions = [System.Management.Automation.Host.ChoiceDescription[]]($CancelAll, $StoreOption1, $StoreOption2, $StoreOption3, $StoreOption4)}
    5 {$StoreOptions = [System.Management.Automation.Host.ChoiceDescription[]]($CancelAll, $StoreOption1, $StoreOption2, $StoreOption3, $StoreOption4, $StoreOption5)}
}

Zu guter Letzt werden anhand der Auswahl die Variablen definiert:

# Prepare variables after the user entry
If ($Store2Replicate -eq 0) {
    # Cancel all
    return; break
}
Else {
    $IDStore = $Store2Replicate-1
    $StoreDisk = $StoreArray[$IDStore].StoreDisk
    $StorePath = $StoreArray[$IDStore].StorePath
    $LocalStore = $StoreDisk + ":" + $StorePath + "\"
    $RemoteStore = "\\" + $PVSRemote + "\" + $StoreDisk + "$" + $StorePath + "\"
    $LocalStorePath = $LocalStore + "*"
    $RemoteStorePath = $RemoteStore + "*"
}

Der restliche Teil ist soweit gleich geblieben und im ersten Artikel bereits beschrieben.

Viel Spass beim Nachbauen :-)




Citrix PVS Store – Replikationsskript

Citrix Provisioning ist seit Jahren eine super Methode um Citrix Worker zu provisionieren. In der Konsole gibt es zwar seit ich denken kann die Möglichkeit den Replikationsstatus zu prüfen, jedoch bietet Citrix da keine eigenen Mechanismen innerhalb des PVS.

Wie viele andere auch haben wir seit Jahren auf einfache Skripte gesetzt, welche die lokalen Verzeichnisse zwischen den Servern kopiert. Mit dem Nachteil, dass bei mehreren Admins es zu grossen Kopierjobs kommen kann, wenn verschiedene vDisks gepflegt werden. Citrix hat dafür schon seit längerem das vDisk Replicator Utility veröffentlicht, welches wir jedoch nicht installieren wollten. Es ist für unsere Zwecke auch ein wenig überdimensioniert.

Ich habe mich dafür einmal hingesetzt und auf Basis unseres einfachen Skriptes ein neues mit Powershell kreiert, welches folgende Anforderungen erfüllen sollte:

  • das Skript sollte evaluieren, welches der lokale und welches der Remote PVS ist
  • das Skript sollte für mehrere Stores nutzbar sein – mit Auswahl
  • das Skript sollte innerhalb des gewählten Stores die möglichen zu kopierenden vDisks als Auswahl bereitstellen

Die erste Anforderung war leicht und schnell implementiert:

# Script variables
$PVS01 = "pvs01.domain.pit"
$PVS02 = "pvs02.domain.pit"

# Enumerate the local and the remote PVS
$PVSLocal = $env:COMPUTERNAME + ".domain.pit"
If ($PVSLocal -eq $PVS01) {
    $PVSRemote = $PVS02
}
Else {
    $PVSRemote = $PVS01
}

Für die Store-Auswahl habe ich mich in dieser ersten Skript-Version mit einem statischen Array begnügt:

# Define PVS vDisk stores
# Create an array for each store and let the user chose which one should be checked
# If a store is added to the array, the option has to be added for the choice as well
$StoreArray = @()
$StoreArray += [pscustomobject]@{Store="VDI";StoreDisk="V";StorePath="\vDisks\VDI"}
$StoreArray += [pscustomobject]@{Store="RDSH";StoreDisk="R";StorePath="\vDisks\RDSH"}
$StoreArray += [pscustomobject]@{Store="Test";StoreDisk="T";StorePath="\vDisks\Test"}

# Prompt for Store choice
$StoreTitle = "PVS Store"
$StoreMessage = "Which PVS store will you replicate"
$Store1 = New-Object System.Management.Automation.Host.ChoiceDescription "&VDI Store", "VDI"
$Store2 = New-Object System.Management.Automation.Host.ChoiceDescription "&RDSH Store", "RDSH"
$Store3 = New-Object System.Management.Automation.Host.ChoiceDescription "&Test Store", "TEST"
$StoreOptions = [System.Management.Automation.Host.ChoiceDescription[]]($Store1, $Store2, $Store3)
$Store2Replicate=$host.ui.PromptForChoice($StoreTitle, $StoreMessage, $StoreOptions, 2)

Anhand der Auswahl werden die nächsten Variablen definiert und das lokale und remote Verzeichnis verglichen, ohne den WriteCache Ordner und allfällige .lok oder .i.vhdx Dateien:

# Prepare variables after the user entry
$StoreID = $Store2Replicate
$StoreDisk = $StoreArray[$StoreID].StoreDisk
$StorePath = $StoreArray[$StoreID].StorePath
$LocalStore = $StoreDisk + ":" + $StorePath + "\"
$RemoteStore = "\\" + $PVSRemote + "\" + $StoreDisk + "$" + $StorePath + "\"
$LocalStorePath = $LocalStore + "*"
$RemoteStorePath = $RemoteStore + "*"

# Compare servers
$LocalStoreContent = Get-ChildItem -Path $LocalStorePath -Exclude WriteCache,*.lok,*.i.vhdx
$RemoteStoreContent = Get-ChildItem -Path $RemoteStorePath -Exclude WriteCache,*.lok,*.i.vhdx
$StoreDiff = Compare-Object -ReferenceObject $LocalStoreContent -DifferenceObject $RemoteStoreContent -Property Name, LastWriteTime

Die gefundenen Differenzen werden verglichen. Uns interessiert bei Ausführung des Skriptes jedoch nur, was auf unserem lokalen Server zum Kopieren ist (SideIndicator „<=“), sowie die eigentlichen vDisks (*.vhd*) ohne die Konfigurationsdateien. Aus diesen Informationen wird das nächste Array erstellt:

# Enumerate a list of vDisks
# Create an array with all disk names
$DiskArray = $null
$DiskArray = @()
$DiskID = 1
ForEach ($File in $StoreDiff) {
    If ($File.SideIndicator -eq "<="){
        $Filename = $File.Name
        If ($Filename -like "*.vhd*") {
            $DiskID = $DiskID+1
            $SplitChar = $Filename.IndexOf(".")
            $DiskName = $Filename.Substring(0, $SplitChar)
            $PVPName = $DiskName + ".pvp"
            $DiskArray += [pscustomobject]@{DiskID=$DiskID;vDisk=$Filename;vDiskName=$DiskName;PVPName=$PVPName}        
        }
    }
}

Aus diesem Array heraus wird dann die nächste Auswahl generiert. Die Auswahl enthält als erstes und auch Standardauswahl die Option alles zu kopieren und die Variante abzubrechen. Aktuell ist vorgesehen, dass maximal fünf vDisks zur Auswahl gestellt werden können für einen einzelnen Kopier-Job:

# Prompt for replication choice
$ReplTitle = "vDisk replication"
$ReplMessage = "Choose what to replicate"
$vDiskAll = New-Object System.Management.Automation.Host.ChoiceDescription "&All vDisks","Continue with all vDisks."
$CancelAll = New-Object System.Management.Automation.Host.ChoiceDescription "&Cancel", "Skip this operation and all subsequent operations."

# Generate choice output of each vDisk to replicate
$ReplOptionCount = 0
ForEach ($vDisk in $DiskArray) {
    $ReplOptionCount = $ReplOptionCount +1
    $ChoiceID = $vDisk.DiskID
    $ChoiceDisk = $vDisk.vDiskName
    $ChoiceCmd = New-Object System.Management.Automation.Host.ChoiceDescription "&$ChoiceID $ChoiceDisk", "Replicate selected vDisk."
    New-Variable "ReplOption$ChoiceID" $ChoiceCmd
}

# Generate $ReplOptions variable for final choice output depending on the amount of options
Switch ($ReplOptionCount) {
    0 {$ReplOptions = [System.Management.Automation.Host.ChoiceDescription[]]($vDiskAll, $CancelAll)}
    1 {$ReplOptions = [System.Management.Automation.Host.ChoiceDescription[]]($vDiskAll, $CancelAll, $ReplOption2)}
    2 {$ReplOptions = [System.Management.Automation.Host.ChoiceDescription[]]($vDiskAll, $CancelAll, $ReplOption2, $ReplOption3)}
    3 {$ReplOptions = [System.Management.Automation.Host.ChoiceDescription[]]($vDiskAll, $CancelAll, $ReplOption2, $ReplOption3, $ReplOption4)}
    4 {$ReplOptions = [System.Management.Automation.Host.ChoiceDescription[]]($vDiskAll, $CancelAll, $ReplOption2, $ReplOption3, $ReplOption4, $ReplOption5)}
    5 {$ReplOptions = [System.Management.Automation.Host.ChoiceDescription[]]($vDiskAll, $CancelAll, $ReplOption2, $ReplOption3, $ReplOption4, $ReplOption5, $ReplOption6)}
}

$vDisk2Replicate=$host.ui.PromptForChoice($ReplTitle, $ReplMessage, $ReplOptions, 0)

Nach der Auswahl werden entweder alle vDisks oder die ausgewählte kopiert, oder das Skript abgebrochen:

If ($vDisk2Replicate -eq 0) {
    # Copy all found vDisks and PVP files
    ForEach ($Disk in $DiskArray) {
        $SourcevDisk = $null
        $SourcePVP = $null
        $DestvDisk = $null
        $DestPVP = $null
        $vDiskFile = $Disk.vDisk
        $PVPFile = $Disk.PVPName

        $SourcevDisk = $LocalStore + $vDiskFile
        $SourcePVP = $LocalStore + $PVPFile
        $DestvDisk = $RemoteStore + $vDiskFile
        $DestPVP = $RemoteStore + $PVPFile

        Copy-Item $SourcevDisk -Destination $DestvDisk
        Copy-Item $SourcePVP -Destination $DestPVP
    }
}
ElseIf ($vDisk2Replicate -eq 1) {
    # Cancel all
    return; break
}
Else {
    # Copy the selected vDisk
    # ID has to be reduced by 2 to match the array IDs
    $SourceID = $vDisk2Replicate - 2
    $SourcevDisk = $null
    $SourcePVP = $null
    $DestvDisk = $null
    $DestPVP = $null
    $vDiskFile = $DiskArray[$SourceID].vDisk
    $PVPFile = $DiskArray[$SourceID].PVPName

    $SourcevDisk = $LocalStore + $vDiskFile
    $SourcePVP = $LocalStore + $PVPFile
    $DestvDisk = $RemoteStore + $vDiskFile
    $DestPVP = $RemoteStore + $PVPFile

    Copy-Item $SourcevDisk -Destination $DestvDisk
    Copy-Item $SourcePVP -Destination $DestPVP
}

Für einen ersten Wurf find ich das Skript nicht schlecht. Sollte ich die Zeit finden, könnte ich mir vorstellen, dass ich die Store-Auswahl auch noch dynamischer gestalte, in dem ich mittels Powershell die PVS Konfiguration abfrage. Ebenfalls fehlt aktuell noch so etwas wie ein Statusbalken. Das Ende des Kopierens erkennt man nur am geschlossenen Skriptfenster.

Viel Spass beim Nachbauen :-)




PRTG – Verfügbare VDIs überwachen

Im letzten Artikel habe ich beschrieben, wir mittels PRTG der Load Index der Terminalserver überwacht werden kann.

Wenn wir uns die VDIs (single user OS), dann interessiert uns da normalerweise die Auslastung weniger. Dafür wollen wir wissen, wie viele VDIs überhaupt noch zur Verfügung stehen im Kontext von „random non-static“.

Im Vergleich zu den Terminalservern ist hier die Erstellung eines Custom Sensors sogar einfacher, da uns der Citrix Controller mit allen notwendigen Informationen versorgt:

###
# Prepare an array and get the information from a Citrix controller by an Invoke-Command
# Citrix PS commands are only available on those servers
$Data = $null
$Data=@()

$Data += Invoke-Command -Computername $server -credential $credentials -ScriptBlock {

    # Load Citrix PS Snapin
    add-pssnapin citrix*

    # Get delivery groups with the needed information
    $DeliveryGroups=Get-BrokerDesktopGroup | Select-Object -Property Name, TotalDesktops, DesktopsAvailable, InMaintenanceMode

    # Set the array for later work
    $DG=@()
    ForEach ($group in $DeliveryGroups){
       $DG += [PSCustomObject]@{Name=$group.Name;Total=$group.TotalDesktops;Available=$group.DesktopsAvailable;Maintenance=$group.InMaintenanceMode} 
    }

    # Return data to PRTG probe
    return $DG
}

Diese Informationen können wir in einer weiteren Schlaufe dann auch gleich für die PRTG Ausgabe benutzen. Das komplette Skript steht zum Download bereit, daher beschreibe ich hier nur nochmals ein paar Eckpunkte.

Aus den Daten können die noch verfügbaren VDIs in Prozent umgerechnet und erneut für PRTG auf die nächste Ganzzahl gerundet werden:

    # Prepare variables based on the array data
    $DGName = $Dataset.Name
    $DGTotal = $Dataset.Total
    $DGAvailable = $Dataset.Available
    # Calculate the percentage of the available VDIs
    $DGPercent = "{0:N0}" -f (100/$DGTotal*$DGAvailable)
    $DGMaintenance = $Dataset.Maintenance

Kommt im Namen der Bereitstellungsgruppe „test“ vor, so wollen wir im PRTG nie einen Alarm sondern höchstens eine Warnung auslösen:

    # Determine if a delivery group is a test group
    # Test DGs will never go into alarm state
    # Test DGs in maintenance will have a percentage value of 100 to avoid an alarm
    If ($DGName -like "*test*"){
        $AlertString = $null
        $AlertLimit = $null
        $WarningString = "Warning - Test VDI capacity reachs the end"
        If ([Int64]$DGPercent -ge 20) {
            $RetState = $returnStateOK
            $returnState += [PSCustomObject]@{Name=$DGName;State=[Int64]$RetState} 
        }
        ElseIf ($DGMaintenance){
            $RetState=$returnStateWarning
            $DGPercent=100
        }
        Else {
            $RetState = $returnStateWarning
            $returnState += [PSCustomObject]@{Name=$DGName;State=[Int64]$RetState} 
        }
    }

Ist eine Bereitstellungsgruppe im Wartungsmodus, so geben wir eine Verfügbarkeit von 100% an PRTG aus, um einen Alarm oder eine Warnung komplett zu vermeiden:

    # Determine if a delivery group is in maintenance
    # DGs in maintenance goes into warning state, but doesn't affect the whole sensor
    # DGs in maintenance will not be stated based on her usage
    # DGs in maintenance will have a percentage value of 100 to avoid an alarm
    ElseIf ($DGMaintenance){
        $RetState=$returnStateWarning
        $DGPercent=100
    }

Die restlichen Bereitstellungsgruppen werden anhand der Prozentwerte eingestuft und entsprechende PRTG Ausgaben aufbereitet.

Die Ausgabe sieht dann folgendermassen aus, wobei die ausgegrauten Channels ehemalige bereits gelöschte Bereitstellungsgruppen sind:

Viel Spass beim Nachbauen :-)