Ändern und Löschen von Azure-VMs mit PowerShell

Mit PowerShell automatisieren Ingenieure und IT-Administratoren erfolgreich verschiedene Aufgaben bei der Arbeit nicht nur mit On-Premises, sondern auch mit Cloud-Infrastrukturen, insbesondere mit Azure. Die Arbeit über PowerShell ist in vielen Fällen viel bequemer und schneller als über das Azure-Portal. Dank der plattformübergreifenden Natur von PowerShell kann es für jedes Betriebssystem genutzt werden.

Egal, ob Sie mit Ubuntu, Red Hat oder Windows arbeiten - PowerShell hilft Ihnen, Cloud-Ressourcen zu steuern. Mithilfe des Moduls Azure PowerShell, können beispielsweise beliebige Eigenschaften von virtuellen Maschinen festgelegt werden.

In diesem Artikel werden wir untersuchen, wie PowerShell verwendet werden kann, um die Größe einer VM in der Azure-Cloud zu ändern und um eine VM sowie die damit verbundenen Objekte zu löschen.

Wichtig! Vergessen Sie nicht, die Hände mit Desinfektionsmittel zu reinigen, bevor Sie mit der Arbeit beginnen:

• Sie benötigen das Modul Azure PowerShell Module — es kann mit dem Befehl aus der PowerShell Gallery heruntergeladen werden: Install-Module Az.
• Sie müssen sich in der Azure-Cloud, in der die virtuelle Maschine betrieben wird, authentifizieren, indem Sie den Befehl ausführen: Connect-AzAccount.

Lassen Sie uns zunächst ein Skript erstellen, das die Azure-VM in der Größe ändert. Öffnen Sie VS Code und speichern Sie ein neues PowerShell-Skript mit dem Namen Resize-AzVirtualMachine.ps1 — darin werden wir im Laufe des Beispiels Code-Schnipsel hinzufügen.

Ermitteln der verfügbaren VM-Größen

Bevor Sie die VM-Größe ändern, müssen Sie herausfinden, welche zulässigen Größen für virtuelle Maschinen in der Azure-Cloud vorhanden sind. Führen Sie dazu den Befehl aus: Get-AzVMSize.

Für die virtuelle Maschine devvm01 aus der Ressourcengruppe dev fordern wir alle möglichen zulässigen Größen an:

Get-AzVMSize -ResourceGroupName dev -VMName devvm01

(In realen Aufgaben würden Sie natürlich Ihre eigenen Werte für diese Parameter angeben.) ResourceGroupName=dev und VMName=devvm01 Der Befehl gibt etwa folgendes zurück:

Dies sind alle möglichen Größenversionen, die für diese virtuelle Maschine angegeben werden können.

Ändern der Größe der Maschine

In unserem Beispiel ändern wir die Größe auf die neue Größe

Standard_B1ls — sie steht an erster Stelle in der Liste oben. (In realen Aufgaben wählen Sie natürlich jede gewünschte Größe aus.) Zunächst erhalten wir mit dem Befehl

1. Get-AzVM Informationen über unser Objekt (virtuelle Maschine) und speichern diese in der Variablen $virtualMachine $virtualMachine = Get-AzVM -ResourceGroupName dev -VMName devvm01:

   Anschließend nehmen wir dieses Objekt und verwenden die Eigenschaft

2. .HardwareProfile.VmSize und setzen den gewünschten neuen Wert: $virtualMachine.HardwareProfile.VmSize = "Standard_B1ls"

   $virtualMachine.HardwareProfile.VmSize = "Standard_B1ls"

3. Und jetzt führen wir einfach den Befehl zum Aktualisieren der VM aus — Update-AzVm:

   Update-AzVM -VM devvm01 -ResourceGroupName dev

4. Stellen wir sicher, dass alles erfolgreich war — dazu fragen wir erneut Informationen zu unserem Objekt an und schauen uns die Eigenschaft an $virtualMachine.HardwareProfile:

   $virtualMachine = Get-AzVM -ResourceGroupName dev -VMName devvm01
   $virtualMachine.HardwareProfile

Wenn wir dort sehen — sie steht an erster Stelle in der Liste oben. (In realen Aufgaben wählen Sie natürlich jede gewünschte Größe aus.) — dann ist alles in Ordnung, die Größe der Maschine wurde geändert. Man kann weitermachen und den Erfolg ausbauen — gleich mehrere VMs resizing, indem man ein Array verwendet.

Und wie sieht es mit dem Löschen von VMs in Azure aus?

Das Löschen ist nicht so einfach und geradlinig, wie es zunächst scheinen mag. Denn man muss eine Reihe von Ressourcen entfernen, die mit dieser Maschine verbunden sind, darunter:

• Diagnose-Storage-Container für Bootdiagnosen
• Netzwerkschnittstellen
• Öffentliche IP-Adressen
• Das Systemlaufwerk und Blob, in dem sein Status gespeichert ist
• Datenträger (data disks)

Daher erstellen wir eine Funktion und nennen sie Remove-AzrVirtualMachine — und sie wird nicht nur die Azure-VM löschen, sondern auch alles oben Genannte.

Wir gehen den Standardweg und erhalten zunächst unser Objekt (VM) mit dem Befehl Get-AzVm. Zur Veranschaulichung nehmen wir die Maschine WINSRV19 aus der Ressourcengruppe MyTestVMs.

Wir speichern dieses Objekt zusammen mit all seinen Eigenschaften in einer Variablen $vm:

$vm = Get-AzVm -Name WINSRV19 -ResourceGroupName MyTestVMs

Wir löschen den Container mit den Bootdiagnose-Dateien.

Bei der Erstellung einer VM in Azure wird dem Benutzer auch angeboten, einen Container für die Speicherung von Bootdiagnosen zu erstellen, um im Falle von Problemen bei der boot diagnose referenzieren zu können. Beim Löschen der VM bleibt dieser Container jedoch weiterhin bestehen und führt seine nun sinnlose Existenz. Lassen Sie uns dieses Problem beheben.

1. Zuerst finden wir heraus, zu welchem Storage-Konto dieser Container gehört — dazu müssen wir die Eigenschaft storageUri im Inneren des Objekts DiagnosticsProfile unserer VM ermitteln. Dafür benutze ich folgendes reguläres Ausdruck:

   $diagSa = [regex]::match($vm.DiagnosticsProfile.bootDiagnostics.storageUri, '^http[s]?:\/\/(.+?)\.').groups[1].value

2. Jetzt müssen wir den Namen des Containers herausfinden, dafür benötigen wir die VM-ID mit dem Befehl Get-AzResource:

   
   if ($vm.Name.Length -gt 9) {
       $i = 9
   } else {
       $i = $vm.Name.Length - 1
   }
    
   $azResourceParams = @{
       'ResourceName' = WINSRV
       'ResourceType' = 'Microsoft.Compute\/virtualMachines'
       'ResourceGroupName' = MyTestVMs
   }
    
   $vmResource = Get-AzResource @azResourceParams
   $vmId = $vmResource.Properties.VmId
   $diagContainerName = ('bootdiagnostics-{0}-{1}' -f $vm.Name.ToLower().Substring(0, $i), $vmId)
   

3. Dann erhalten wir den Namen der Ressourcengruppe, zu der der Container gehört:

   $diagSaRg = (Get-AzStorageAccount | where { $_.StorageAccountName -eq $diagSa }).ResourceGroupName

4. Und jetzt haben wir alles, was wir benötigen, um den Container mit dem Befehl zu löschen Remove-AzStorageContainer:

   $saParams = @{
       'ResourceGroupName' = $diagSaRg
       'Name' = $diagSa
   }
    
   Get-AzStorageAccount @saParams | Get-AzStorageContainer | where { $_.Name-eq $diagContainerName } | Remove-AzStorageContainer -Force

Löschen der VM

Jetzt löschen wir die virtuelle Maschine, da wir bereits die Variable erstellt haben $vm für das entsprechende Objekt. Nun, lassen Sie uns den Befehl ausführen Remove-AzVm:

$null = $vm | Remove-AzVM -Force

Löschen des Netzwerkinterfaces und der öffentlichen IP-Adresse

Unsere VM hat ein (oder mehrere) Netzwerkinterfaces (NICs) — um diese aus Unnötigkeit zu löschen, gehen wir das Attribut NetworkInterfaces unseres VM-Objekts durch und löschen das NIC mit dem Befehl Remove-AzNetworkInterface. Falls mehr als ein Netzwerkinterface vorhanden ist, verwenden wir eine Schleife. Außerdem überprüfen wir für jedes NIC das Attribut IpConfiguration darüber, ob das Interface eine öffentliche IP-Adresse hat. Sollte eine solche vorhanden sein, löschen wir sie mit dem Befehl Remove-AzPublicIpAddress.

Hier ist ein Beispiel eines solchen Codes, bei dem wir in einer Schleife alle NICs durchgehen, sie löschen und überprüfen, ob eine öffentliche IP vorhanden ist. Wenn ja, parsen wir das Attribut PublicIpAddress, holen wir den Namen des zugehörigen Ressourcen-IDs und löschen ihn:

foreach($nicUri in $vm.NetworkProfile.NetworkInterfaces.Id) {
    $nic = Get-AzNetworkInterface -ResourceGroupName $vm.ResourceGroupName -Name $nicUri.Split('\/')[-1]
    Remove-AzNetworkInterface -Name $nic.Name -ResourceGroupName $vm.ResourceGroupName -Force

    foreach($ipConfig in $nic.IpConfigurations) {
        if($ipConfig.PublicIpAddress -ne $null) {
            Remove-AzPublicIpAddress -ResourceGroupName $vm.ResourceGroupName -Name $ipConfig.PublicIpAddress.Id.Split('\/')[-1] -Force
        }
    }
}

Löschen der Systemfestplatte

Die OS-Festplatte ist ein Blob, für dessen Löschung es einen Befehl gibt Remove-AzStorageBlob — aber bevor wir diesen ausführen, müssen wir die erforderlichen Werte für seine Parameter festlegen. Dazu ist es erforderlich, den Namen des Speichercontainers zu erhalten, der die Systemfestplatte enthält, und diesen dann diesem Befehl zusammen mit dem entsprechenden Storage-Account zu übergeben.

$osDiskUri = $vm.StorageProfile.OSDisk.Vhd.Uri
$osDiskContainerName = $osDiskUri.Split('\/')[-2]
$osDiskStorageAcct = Get-AzStorageAccount | where { $_.StorageAccountName -eq $osDiskUri.Split('\/')[2].Split('.')[0] }
$osDiskStorageAcct | Remove-AzStorageBlob -Container $osDiskContainerName -Blob $osDiskUri.Split('\/')[-1]

Löschen des Blobs des Status der Systemfestplatte

Dafür nehmen wir, wie Sie sicherlich bereits vermutet haben, den Speichercontainer, in dem sich diese Festplatte befindet, und, vorausgesetzt, dass der Blob am Ende enthält status, übergeben wir die entsprechenden Parameter dem Löschbefehl Remove-AzStorageBlob:

$osDiskStorageAcct | Get-AzStorageBlob -Container $osDiskContainerName -Blob "$($vm.Name)*.status" | Remove-AzStorageBlob

Und schließlich löschen wir die Datenträger

An unserer VM könnten Datenträger angehängt geblieben sein. Wenn sie nicht mehr benötigt werden, löschen wir auch diese. Zuerst parsen wir StorageProfile unserer VM und finden die Eigenschaft Uri. Wenn mehrere Datenträger vorhanden sind, organisieren wir eine Schleife über URI. Für jede URI finden wir das entsprechende Speicherkonto mithilfe von Get-AzStorageAccount. Dann parsen wir die Speicher-URI, um den benötigten Blob-Namen herauszuziehen und ihn an den Löschbefehl weiterzugeben Remove-AzStorageBlob zusammen mit dem Speicherkonto. So wird das im Code aussehen:

if ($vm.DataDiskNames.Count -gt 0) {
    foreach ($uri in $vm.StorageProfile.DataDisks.Vhd.Uri) {
        $dataDiskStorageAcct = Get-AzStorageAccount -Name $uri.Split('\/')[2].Split('.')[0]
        $dataDiskStorageAcct | Remove-AzStorageBlob -Container $uri.Split('\/')[-2] -Blob $uri.Split('\/')[-1]
    }
}

Und nun "sind wir am glücklichen Ende angekommen!" Jetzt müssen wir all diese Fragmente zu einem Ganzen zusammenfügen. Der freundliche Autor Adam Bertram hat sich den Nutzern zuliebe die Mühe gemacht und das selbst erledigt. Hier ist der Link zum endgültigen Skript mit dem Titel Remove-AzrVirtualMachine.ps1:

→ GitHub

Ich hoffe, diese praktischen Tipps helfen Ihnen, Kraft, Zeit und Ressourcen bei der Arbeit mit Azure VMs zu sparen.

Quelle: habr.com