Im Rahmen des Azure Black Magic Workshops haben Tillmann Eitelberg und ich gezeigt, wie man eine virtuelle Maschine in Azure aufbaut bei der die Anmeldeinformationen aus dem Azure Key Vault kommen. In diesem Blogartikel beschreibe ich den Prozess noch einmal genau.
Seit einiger Zeit stellt Microsoft unter Azure ja den Azure Key Vault zur Verfügung. Ein Key Vault kann man sich wie einen zentralen Tresor für sicherheitsrelevante Informationen vorstellen der im Azure Rechenzentrum besonders stark geschützt ist. Die Idee hinter dem Azure Key Vault ist es sicherheitsrelevante Informationen zentral abzulegen und für unterschiedliche Dienste zur Verfügung zu stellen. Was man mit dem Azure Key Vault z.B. machen kann ist die Admin-Informationen für virtuelle Maschinen dort abzulegen und diese dann innerhalb von PowerShell beim Anlegen der VM zu verwenden. Vorteil ist, dass weder der Name noch das Kennwort des Administrators in der Powershell-Datei speichern müssen die die virtuelle Maschine erzeugt. So könnte beispielsweise ein Entwickler ein PowerShell Script für eine virtuelle Maschine erstellen ohne dass wir ihm Kennwort und Benutzername des Administrators übergeben müssen. Wir müssen für den entsprechenden Entwickler lediglich einen lesenden Zugriff auf den Azure Key Vault einrichten und ihm dann den Namen der Anmeldeinformationen mitteilen. Im folgenden zeige ich wie das im Einzelnen funktioniert.
Zunächst definieren wir einmal alle Variablen die wir im Script benötigen. Wenn wir dies direkt am Anfang des Scriptes machen hat dies den Vorteil, dass nur die ersten Zeilen des Scriptes geändert werden müssen wenn wir eine Maschine mit anderer Konfiguration bereitstellen möchten.
# Variables ## Global $ResourceGroupName = "KeyVaultTestRS" $Location = "WestEurope" ## Storage $StorageName = "kvstor01" $StorageType = "Standard_LRS" ## Network $InterfaceName = "ServerInterface06" $VNetName = "VNet09" $Subnet1Name = "Subnet1" $VNetAddressPrefix = "10.0.0.0/16" $VNetSubnetAddressPrefix = "10.0.0.0/24" ## Compute $VMName = "VirtualMachine12" $ComputerName = "Server22" $VMSize = "Standard_A2" $OSDiskName = $VMName + "OSDisk" $keyVaultName = "azurebmwkeyvault2"
Danach melden wir uns erst einmal bei Azure an und wählen die Subscription aus, in der sowohl der Azure Key Vault wie auch die virtuelle Maschine angelegt werden sollen
# Anmelden
Login-AzureRmAccount
# Subscription wählen
Select-AzureRmSubscription `
-SubscriptionId "xxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxxxxx"
Als nächstes legen wir eine Ressourcengruppe an
# Resource Group
New-AzureRmResourceGroup `
-Name $ResourceGroupName `
-Location $Location
Nun erzeugen wir in der Ressoucengruppe einen neuen Azure Key Vault. Dieser Schritt ist natürlich nicht bei jedem Anlegen einer AzureVM notwendig sondern muss nur ein einziges Mal gemacht werden. In Produktivumgebungen ist es nicht empfehlenswert den Key Vault in dieselbe Ressoucengruppe wie die virtuellen Maschinen zu legen. Löscht man die Ressourcengruppe wird der Key Vault mit allen enthaltenen Informationen auch gelöscht. Daher erstellt man in Produktivumgebungen eine eigene Ressourcengruppe in die alle wichtigen Objekte deployt werden die persistent zur Verfügung stehen sollen. Natürlich sollte man dann den Zugriff auf diese Ressourengruppe stark beschränken. Um den Azure Key Vault anzulegen müssen wir den Befehl New-AzureRmKeyVault verwenden.
# Azure Key Vault
New-AzureRmKeyVault `
-VaultName $keyVaultName `
-ResourceGroupName $ResourceGroupName `
-Location $Location
Um einen leeren Azure Key Vault anzulegen reichen den Name des Key Vaults, die Ressourcengruppe in die der Key Vault deployt werden soll und die Azure Location aus.
Als nächstes definieren wir über Set-AzureRmKeyVaultAccessPolicy wofür den Key Vault verwendet werden kann. In diesem Fall geben wir über -EnabledForDeployment an dass Microsoft.Compute auf den Key Vault zugreifen darf und wir auf bei der Erstellung von Ressourcen (z.B. Virtual Machine) Secrets aus dem Key Value Store zu verwenden.
# Key Vault Policy setzen
Set-AzureRmKeyVaultAccessPolicy `
-VaultName $keyVaultName `
-EnabledForDeployment
Nun müssen wir dem Benutzerkonto mit dem die virtuellen Maschinen angelegt werden Berechtigungen geben auf den Azure Key Vault zugreifen zu können. In diesem Fall gebe ich meinem Benutzerkonto sämtliche Berechtigungen. In einem realen Produktiv-Szenario würde man dem Benutzer der die virtuellen Maschinen anlegt nur die Leseberechtigung für die Secrets geben. Auch dies geht mit dem Befehl Set-AzureRmKeyVaultAccessPolicy.
Set-AzureRmKeyVaultAccessPolicy `
-VaultName $keyVaultName `
-ResourceGroupName $resourceGroupName `
-UserPrincipalName 'geislerfrank@hotmail.com' `
-PermissionsToCertificates all `
-PermissionsToKeys all `
-PermissionsToSecrets all
Als letzten Schritt in der Vorbereitung des Azure Key Vaults müssen wir noch ein Benutzerkonto und ein Kennwort im Key Vault speichern. Dies gelingt uns über den Befehl Set-AzureKeyVaultSecret:
# Admin-Kennwort im Key Vault speichern
Set-AzureKeyVaultSecret `
-VaultName $keyVaultName `
-Name "AdminPassword" `
-SecretValue (Get-Credential).Password
Im Beispiel lesen wir das Secret direkt vom Anwender über Get-Credential. Hierdurch wird ein Fenster geöffnet in dem wir die Anmeldeinformationen eingeben können.
Im weiteren Verlauf des Scriptes gehen wir wie gehabt vor. Zuerst wird ein Storage Account angelegt
# Storage
$StorageAccount = New-AzureRmStorageAccount `
-ResourceGroupName $ResourceGroupName `
-Name $StorageName `
-Type $StorageType `
-Location $Location
Dann ein Netzwerk inkl. Public IP Address, Subnetz und Netzwerk-Interface
# Network
$PIp = New-AzureRmPublicIpAddress `
-Name $InterfaceName `
-ResourceGroupName $ResourceGroupName `
-Location $Location `
-AllocationMethod Dynamic
$SubnetConfig = New-AzureRmVirtualNetworkSubnetConfig `
-Name $Subnet1Name `
-AddressPrefix $VNetSubnetAddressPrefix
$VNet = New-AzureRmVirtualNetwork `
-Name $VNetName `
-ResourceGroupName $ResourceGroupName `
-Location $Location `
-AddressPrefix $VNetAddressPrefix `
-Subnet $SubnetConfig
$Interface = New-AzureRmNetworkInterface `
-Name $InterfaceName `
-ResourceGroupName $ResourceGroupName `
-Location $Location `
-SubnetId $VNet.Subnets[0].Id `
-PublicIpAddressId $PIp.Id
Nun werden wir die virtuelle Maschine anlegen. Beim ersten Schritt lesen wir das Kennwort mit Get-AzureKeyVaultSecret aus dem Azure Key Vault aus. Dann erzeugen wir ein Credentials-Objekt dem wir das Kennwort und den Namen des lokalen Administrators übergeben.
# Compute
## Setup local VM object
$password = Get-AzureKeyVaultSecret `
-VaultName $keyvaultname `
-Name "AdminPassword"
$Credential = New-Object `
-TypeName System.Management.Automation.PSCredential `
-ArgumentList ("vmadmin", $password.SecretValue)
Danach legen wir dann wie gehabt die virtuelle Maschine an. Zunächst definieren wir die Konfiguration und das Betriebssystem, dann legen wir das Quell-Image fest und verbinden die Virtuelle Maschine mit der Netzwerkkarte. Dann wird noch der Name für die Festplatte mit dem Betriebssystem festgelegt. Zum Schluss wird die Maschine dann erzeugt.
$VirtualMachine = New-AzureRmVMConfig `
-VMName $VMName `
-VMSize $VMSize
$VirtualMachine = Set-AzureRmVMOperatingSystem `
-VM $VirtualMachine `
-Windows `
-ComputerName $ComputerName `
-Credential $Credential `
-ProvisionVMAgent `
-EnableAutoUpdate
$VirtualMachine = Set-AzureRmVMSourceImage `
-VM $VirtualMachine `
-PublisherName MicrosoftWindowsServer `
-Offer WindowsServer `
-Skus 2012-R2-Datacenter `
-Version "latest"
$VirtualMachine = Add-AzureRmVMNetworkInterface `
-VM $VirtualMachine `
-Id $Interface.Id
$OSDiskUri = $StorageAccount.PrimaryEndpoints.Blob.ToString() + "vhds/" + $OSDiskName + ".vhd"
$VirtualMachine = Set-AzureRmVMOSDisk `
-VM $VirtualMachine `
-Name $OSDiskName `
-VhdUri $OSDiskUri `
-CreateOption FromImage
## Create the VM in Azure
New-AzureRmVM `
-ResourceGroupName $ResourceGroupName `
-Location $Location `
-VM $VirtualMachine
Dieser Artikel hat gezeigt, wie man eine virtuelle Maschine erzeugt und die Anmeldeinformationen der virtuellen Maschine im Azure Key Vault speichert.