Markus Bäker

Wer die Powershell Module von SCVMM und die Community Module zu Hyper-V gleichzeitig benutzen will, bekommt bei einigen Funktionen einen Konflikt.

Eigentlich sind alle Funktionen vom SCVMM eindeutig mit einem SC bezeichnet. So heißt die Funktion, um das Objekt einer Virtuellen Maschine zu erhalten get-SCVirtualMachine. Wahrscheinlich aus historischen Gründen gibt es aber eine Alias namens “get-VM” auf diese Funktion.

Die CodePlex Hyper-V Funktionen haben keinen gesonderten Namensraum. Hier heißt die Funktion für die Virtuelle Maschine einfach get-VM. Dies wäre nicht so schlimm, wenn die Funktion nicht auch intern fleißig genutzt wird. Möchte man die CodePlex Funktionen nutzen, um Differenzielle Disks zu erstellen (etwas  was der SCVMM auch in 2012 nicht anbietet), so funktioniert dies nicht mehr, wenn beide Module geladen sind.

Die direkte Lösung wäre daher, den Alias auf get-SCVirtualMachine wieder zu entfernen.   Neue Aliase sind einfach per “new-Alias” erstellbar. Eine Funktion namens “remove-Alias” existiert aber nicht, da ein Alias für die aktuelle Sitzung definiert und dort auch bis zum Ende bestehen bleibt.

Trotzdem kann man einen Alias mit der generischen Funktion remove-item entfernen. Hier heißt der Alias “Alias:get-VM”. D.h. wie bei der Bezeichnung “ftp:sdfsdf” oder “c:\get-vm” steht Alias: für das Protokoll bzw. den Namensraum, damit die Funktion weiß, an welches Modul sie den Löschbefehl weitergeben muss. Hier ein Beispiel:

$alias= Get-Alias | where {$_.name -eq "Get-VM"}
if ($alias -ne $null) {
   $itemName=$alias.CommandType.ToString()+":"+$alias.name
   Remove-Item $itemName
}

In diesem Blogpost werde ich die Arbeit mit den neuen Custom Properties im SCVMM 2012 vorstellen.

In Vergangenheit gab es eine Reihe von vordefinierten Custom Properties (1-10). Mit SCVMM 2012 gibt es beliebige Erweiterungsfelder, die als Objekt abgebildet sind und an Virtuellen Maschinen, Hosts, Clouds und anderen Objekten hängen können.

Diese Objekte kann man in Powershell mittels get-SCCustomProperty abrufen. Diese Objekte beinhalten aber noch keine Werte, sondern stellen nur die Schlüssel dar. Die eigentlich eingestellten Werte hängen in einer Hashtable an den zu erweiternden Objekten, also z.B. an der jeweiligen Virtuellen Maschine in der Hashtable Eigenschaft CustomProperty. Möchte man den Wert der selbsterstellten Eigenschaft “Kostenstelle” abfragen, so kann man dies über

$kostenstelle=get-SCCustomProperty –Name "Kostenstelle"
$wert=$vm.CustomProperty.get_item($kostenstelle)

Nachfolgend noch eine etwas “komplexere” Funktion, um alle Custom Properties von der Virtuellen Maschine $vm auf die Maschine $targetVM zu übertragen:

if ($vm.CustomProperty.Count -gt 0)
{
    $vm.CustomProperty.Keys | ForEach-Object{
        Set-SCCustomPropertyValue -InputObject $targetvm -CustomProperty (Get-SCCustomProperty -Name $_) -Value $vm.CustomProperty.get_item($_)
    }
}

In der ersten Zeile wird zur Sicherheit überprüft, ob überhaupt Custom Properties an diesem Objekt hängen (HashTable speichert die Anzahl der Einträge in Count). Danach werden alle CustomProperty Objekte aus der Key Eigenschaft ausgelesen und durchlaufen. Durch set-SCCustomPropertyValue wird das Objekt und der Wert an das Zielobjekt übertragen.

Ich habe gerade das Glück etwas mehr mit Powershell und System Center Virtual Machine Manager 2012 (SCVMM, RC) zu arbeiten. Daher werde ich hier wieder ein paar Codesnippsel posten, um bestimmte Funktionen zu automatisieren:

die erste Funktion soll eine neue Cloud für Hyper-V erzeugen . Zusätzlich wird ein neue Rolle für diese Cloud angelegt, die nur VMs verwalten darf.

#creates a new cloud and a corresponding usergroup
function createCloud([string]$name,[string]$hostgroupname)
{
   #retrieving first GUID for creating the new cloud
     $job= ([System.Guid]::NewGuid().toString())
   #define Cloud limitations (here: no limit)
     Set-SCCloudCapacity -JobGroup $job -UseCustomQuotaCountMaximum $true -UseMemoryMBMaximum $true -UseCPUCountMaximum $true -UseStorageGBMaximum $true -UseVMCountMaximum $true
   #setting the used network (here: the network has the same name as the cloud)
     $resources = @()
     $resources += Get-SCLogicalNetwork -Name $Name
   #defining that the cloud can be used on hyper-v server
     $addCapabilityProfiles = @()
     $addCapabilityProfiles += Get-SCCapabilityProfile -Name "Hyper-V"
   #adding the settings to the cloud with the defined GUID
     Set-SCCloud -JobGroup $job -RunAsynchronously -AddCloudResource $resources -AddCapabilityProfile $addCapabilityProfiles
   #adding the cloud to the hostgroup
     $hostGroups = @()
     $hostGroups += Get-SCVMHostGroup -Name $hostgroupname
   #creating the cloud and the rest from the first job 
     New-SCCloud -JobGroup $Job -VMHostGroup $hostGroups -Name $Name -RunAsynchronously

#creating the usergroup
   #GUID for the second job
     $job= ([System.Guid]::NewGuid().toString())
   #the roleis for the newly created cloud
     $scopeToAdd = @()
     $scopeToAdd += Get-SCCloud -name $name
   #the user of this role can start, stop and shutdown virtual machines in the cloud and start a remote control
     Set-SCUserRole -JobGroup $job -AddScope $scopeToAdd -Permission @("RemoteConnect", "Shutdown", "Start", "Stop") -ShowPROTips $false
     $cloud = Get-SCCloud -Name $name
   #add all settings to the role
     Set-SCUserRoleQuota -Cloud $cloud -JobGroup $job -QuotaPerUser -UseCPUCountMaximum -UseMemoryMBMaximum -UseStorageGBMaximum -UseCustomQuotaCountMaximum -UseVMCountMaximum
   #create the role with the job guid
     New-SCUserRole -Name $name -UserRoleProfile "SelfServiceUser" -Description "" -JobGroup $job
}

Die Funktion kann einfach per

createCloud "MeineCloud" "Alle Hosts"

aufgerufen werden.

Auch diesmal wieder ein Script, um schnell eine statische Gruppen füllen zu können. Als Input wird nur eine Textdatei mit den PC Namen benötigt. Die Gruppe wird ebenfalls als Name hinterlegt.

Add-PSSnapin NwcServices.BlsAdministration
$server="\\enteoWebServiceServer"
$csvfile="C:\Computerliste.csv"
$groupName="Statische Gruppe"
New-PSDrive -Name emdb -psProvider BlsEmdb -Root $server
cd "emdb:\rootdse"
$csv=import-csv $csvfile

$grp=get-emdbgroup -recurse $groupName
if (-not $grp) {
   write-host "ERROR: Software nicht gefunden: " $groupName
}
else
{
   $csv | forEach-Object {
      write-host $_.pc
      $pc=get-emdbcomputer -recurse $_.pc
      $grp.addMember($pc)
   }
}

Die CSV Datei muss als erste Zeile die Überschrift definieren, d.h. eine Zeile mit PC besitzen. Das Skript selber ist wie üblich aufgebaut. Zuerst wird die Verbindung zum Enteo Webservice Server aufgebaut und danach die Zielgruppe gesucht. Wird diese gefunden, dann wird die CSV Datei geladen und aus jeder Zeile der Wert in der Spalte PC genommen. Nach diesem Namen wird gesucht und der gefundene PC der Gruppe hinzugefügt.

Zwischendurch ist es manchmal einfacher beim SCOM direkt die Datenbank abzufragen. Zwar bietet die Powershell auch eine einfache Zugriffsmöglichkeit, dies ist aber nicht immer der schnellste Weg.

Die Datenbankstruktur des SCOM ist relativ selbsterklärend, aber arbeitet stark mit Referenzen durch schwer lesbare GUIDs.

Um sich den Einstieg  etwas zu vereinfachen wurde hier ein paar SQL Abfragen zusammengetragen: http://www.braindumpblog.co.uk/?p=61

(der Blog Post ist zwar schon relativ alt, aber stellt trotzdem noch eine gute Übersicht dar)

Wird Software in Enteo per statischen Gruppen zugeordnet, so ist es bei einem Hardwareaustausch notwendig, die Zuordnungen des alten PCs auf den neuen zu übertragen. Dies kann man natürlich durch manuelles Drag&Drop machen, oder aber über ein kleines Powershell Skript:

param([string]$sourcename="source", [string]$targetname="target")
Add-PSSnapin NwcServices.BlsAdministration
$server="\\enteoserver"
New-PSDrive -Name emdb -psProvider BlsEmdb -Root $server
cd "emdb:\rootdse"
$source=get-emdbcomputer -recurse $sourcename

if ($source)
{
    $target=get-emdbcomputer -recurse $targetname
    if ($target)
    {
        $source.GetAssociatedItems() | where {$_.SchemaDisplayName -eq 'Static Group'} |foreach-Object{
        write-host "Cloning group " $_.Name " from $sourcename to $targetname"
        $_.addMember($target)
        }
    }
    else
    {
        write-host "Target $targetname cannot be found!"
    }
}
else
{
    Write-host "Source $sourcename cannot be found!"
}

Das Skript selber ist recht einfach aufgebaut. Es wird der Quellcomputer gesucht und das Objekt abgefragt, welche Verbindungen es hat.
Diese Verbindungen werden nach dem Typ statische Gruppen gefiltert. Über diese Gruppen wird iteriert und jeweils dem Zielobjekt hinzugefügt.

Um das Powershellskript einfach aufzurufen hier noch eine Batch-Datei:

@echo off
set /p source=Bitte Quellrechnernamen eingeben:
set /P target=Bitte Zielrechnernamen eingeben:
powershell "%~dp0clonecomputer.ps1" -sourcename "%source%" -targetname "%target%"
pause

Heute mal wieder eine kurze Powershell Zeile, um alle in Enteo hinterlegten PnP-IDs in den Driver Packages auszulesen und auszugeben.

Interessant kann diese Liste sein, um sie mit einer Enteo-externen Inventur zu vergleichen oder zu überprüfen, ob eine neue Hardware bereits unterstützt wird.

(Get-EmdbSoftwarePackage -recurse -Filter "SchemaTag=PnpPackage" |

where {$_.PnPEnabledIdList -ne $null}) |

foreach-object{$_.PnPEnabledIdList.Split(",")} > c:\temp\pnpids.txt

Zuerst wird in allen Software Paketen nach dem Typ PnPPackage gesucht. Aus diesen Ergebnissen werden alle Treiber ohne PnP Ids ausgefiltert. Das Ergebnis ist eine kommaseparierte Liste pro Treiber-Paket, die beim Komma getrennt wird. Am Ende steht eine Liste mit jeweils einer PnP Id pro Zeile:

[...]
OPTIONBUS\GTHSM501_DBG
OPTIONBUS\GTHSM501_DBG2
OPTIONBUS\GTHSM501_GPSD
OPTIONBUS\GTHSM501_GPSC
OPTIONBUS\GTHSM501_APP
OPTIONBUS\GTHSM501_APL
PCI\VEN_8086&DEV_105E&SUBSYS_105E8086
PCI\VEN_8086&DEV_105E&SUBSYS_005E8086
PCI\VEN_8086&DEV_105E&SUBSYS_115E8086
PCI\VEN_8086&DEV_105E&SUBSYS_125E8086
PCI\VEN_8086&DEV_105E&SUBSYS_135E8086
PCI\VEN_8086&DEV_105E&SUBSYS_704E103C
PCI\VEN_8086&DEV_105E
PCI\VEN_8086&DEV_105F&SUBSYS_005F8086
PCI\VEN_8086&DEV_105F&SUBSYS_115F8086
PCI\VEN_8086&DEV_105F&SUBSYS_125F8086
PCI\VEN_8086&DEV_105F&SUBSYS_704F103C
PCI\VEN_8086&DEV_105F
PCI\VEN_8086&DEV_1060&SUBSYS_00608086
[...]

Zentraler Punkt in dem Script ist die Erkennung in welchem status die Installation gerade ist. Folgende Status sind möglich:

• Installation noch nicht eingeplant
• Installation eingeplant aber noch nicht gestartet
• Installation ist angelaufen aber noch nicht beendet
• Installation ist durchgelaufen

Zur Ermittlung dierer Status greifen wir wieder auf das Auslesen von PolicyInstancen zurück. Dazu werden am Anfang einige Policy-IDs definiert, die die verschiedene Status beschreiben:
Read more…

In diesem Blog-Post werden zwei weitere Komponenten des Scripts vorgestellt: Ping und somit den Status eines Rechners ermitteln und die Ermittlung ob ein Benutzer angemeldet ist.

Je nach dem Status des Systems kann ein Rechner sofort neuinstalliert werden (wenn er aus ist, oder er läuft aber an einem Client kein Benutzer angemeldet ist). Sollte ein Benutzer angemeldet sein, dann darf eine Neuinstallation nur nach einer gewissen Uhrzeit erzwungen werden (z.B. ausserhalb der normalen Arbeitszeit).

Hier die Funktion um die Erreichbarkeit eines Rechners zu ermitteln:

function doPing
{param([string]$name)
   $ping = new-object System.Net.NetworkInformation.Ping
   $ping.send($name)
}

Als Übergabeparameter wird der Rechnername benötigt. Dies kann alternativ auch die IP Adresse sein. Verwendet wird die NetworkInformation-Class “Ping”. Die Funktion gibt ein Objekt des Typs PingReply zurück. Vergleicht man dessen Eigenschaft mit Success, dann weiß man, ob der Rechner erreichbar ist oder nicht (Beispiel für nicht ereichbar: (doPing $strIP).status -ne “Success”).

Die zweite Funktion versucht remote auszulesen, welcher Benutzer aktuell angemeldet ist:

function getUser
{param([string]$pc)
   ((Gwmi -class Win32_ComputerSystem -ComputerName $pc)| select-object username).username
}

Auch hier wird als Parameter der Rechnername mitgegeben. Anstatt .Net/Powershell interne Funktionen zu nutzen, wird eine WMI Abfrage durchgeführt. Im Standard Win32_ComputerSystem Objekt existiert die Eigenschaft UserName. Darin ist der gerade interaktiv angemeldet Benutzer hinterlegt (Consolenbenutzer). Vergleicht man mittels if (-not $username), ob der Wert leer ist, dann kann man einfach feststellen, ob gerade ein Benutzer angemeldet ist.

Jetzt wo wir einen Rechner per Powershell aufwecken können kommt als nächstes die Funktion um eine Neuinstallation anzustossen und sie wieder abzubrechen.

Der Abbruch ist deswegen relevant, da u.U. das WoL nicht funktioniert. Startet der Benutzer am nächsten Morgen den PC wieder ganz normal an, so würde die Installation direkt startet und er könnte ein paar Stunden nicht arbeiten. Daher stoppt das Script die Installation automatisch, falls sie nicht innerhalb eines bestimmten Zeitfenster gestartet werden konnte.

Read more…