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

Mit PowerShell automatisieren Ingenieure und IT-Administratoren erfolgreich verschiedene Aufgaben, sowohl in lokalen als auch in Cloud-Infrastrukturen, insbesondere in Azure. Die Arbeit über PowerShell ist oft viel komfortabler und schneller als über das Azure-Portal. Dank der plattformübergreifenden Fähigkeit von PowerShell kann es in allen Betriebssystemen verwendet werden.

Egal, ob Sie mit Ubuntu, Red Hat oder Windows arbeiten – PowerShell hilft dabei, Cloud-Ressourcen zu verwalten. Mit dem Modul Azure PowerShellkönnen Sie beispielsweise beliebige Eigenschaften von virtuellen Maschinen festlegen.

In diesem Artikel zeigen wir, wie Sie PowerShell verwenden können, um die Größe einer VM in Azure zu ändern und um VMs sowie die damit verbundenen Objekte zu löschen.

Wichtig! Vergessen Sie nicht, sich die Hände mit Desinfektionsmittel zu reinigen, um sich auf die Arbeit vorzubereiten:

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

Zuerst erstellen wir ein Skript, das die Azure VM resized. Öffnen Sie VS Code und speichern Sie ein neues PowerShell-Skript mit dem Namen Resize-AzVirtualMachine.ps1 — wir werden ihm im Laufe des Beispiels Codeabschnitte hinzufügen.

Fordern Sie die verfügbaren VM-Größen an

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

Also, für die virtuelle Maschine devvm01 aus der Ressourcengruppe dev fordern wir alle zulässigen Größen an:

Get-AzVMSize -ResourceGroupName dev -VMName devvm01

(In realen Szenarien werden Sie natürlich anstelle von ResourceGroupName=dev und VMName=devvm01 Ihre eigenen Werte für diese Parameter angeben.)

Der Befehl gibt ungefähr diese Liste zurück:

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

Ändern wir die Größe der Maschine

Zur Veranschaulichung ändern wir die Größe auf Standard_B1ls — er steht an erster Stelle in der obigen Liste. (In realen Szenarien wählen Sie natürlich eine beliebige benötigte Größe.)

Zuerst verwenden wir den Befehl Get-AzVM um Informationen über unser Objekt (virtuelle Maschine) abzurufen und sie in der Variablen $virtualMachine:
```
$virtualMachine = Get-AzVM -ResourceGroupName dev -VMName devvm01
```
Dann nehmen wir von diesem Objekt das Attribut .HardwareProfile.VmSize und setzen den gewünschten neuen Wert fest:
```
$virtualMachine.HardwareProfile.VmSize = "Standard_B1ls"
```
Und nun führen wir einfach den Befehl zum Aktualisieren der VM aus — Update-AzVm:
```
Update-AzVM -VM devvm01 -ResourceGroupName dev
```
Wir stellen sicher, dass alles erfolgreich war — dazu rufen wir erneut Informationen über unser Objekt ab und schauen auf den Punkt $virtualMachine.HardwareProfile:
```
$virtualMachine = Get-AzVM -ResourceGroupName dev -VMName devvm01
$virtualMachine.HardwareProfile
```

Wenn wir dort sehen Standard_B1ls — bedeutet das, alles ist in Ordnung, die Maschine wurde erfolgreich geändert. Wir können weitergehen und den Erfolg ausbauen — gleich mehrere VMs mithilfe eines Arrays umgruppieren.

Wie sieht es mit dem Löschen einer VM in Azure aus?

Beim Löschen ist nicht alles so einfach und geradlinig, wie es scheint. Denn es müssen auch mehrere Ressourcen entfernt werden, die mit dieser Maschine verbunden sind, darunter:

Speichercontainer für die Bootdiagnose (Boot diagnostics storage containers)
Netzwerkschnittstellen
Öffentliche IP-Adressen
Systemdisk und Blob, in dem der Status gespeichert wird
Datenlaufwerke (data disks)

Deshalb werden wir eine Funktion erstellen und sie nennen Remove-AzrVirtualMachine — und diese wird nicht nur die Azure-VM löschen, sondern auch alles, was oben aufgeführt ist.

Wir gehen den Standardweg und rufen zunächst unser Objekt (die VM) mit dem Befehl Get-AzVmab. Zum Beispiel soll es die Maschine WINSRV19 aus der Ressourcengruppe MyTestVMs.

sein. 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 Boot-Diagnosedateien.

Beim Erstellen einer VM in Azure hat der Benutzer die Möglichkeit, auch einen Container für die Speicherung der Boot-Diagnose (boot diagnostics container) zu erstellen, um im Falle von Bootproblemen eine Anlaufstelle für Troubleshooting zu haben. Wenn jedoch die VM gelöscht wird, bleibt dieser Container weiterhin ohne Zweck bestehen. Lassen Sie uns diese Situation beheben.

Zunächst müssen wir herausfinden, zu welchem Storage-Account dieser Container gehört – dazu müssen wir das Attribut finden storageUri im Inneren des Objekts DiagnosticsProfile unserer VM. Ich benutze dafür folgenden regulären Ausdruck:
```
$diagSa = [regex]::match($vm.DiagnosticsProfile.bootDiagnostics.storageUri, '^http[s]?:\/\/(.+?)\.').groups[1].value
```

Jetzt müssen wir den Namen des Containers herausfinden, und dafür müssen 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)

Als Nächstes holen wir uns den Namen der Ressourcengruppe, zu der der Container gehört:

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

Und jetzt haben wir alles, was wir brauchen, 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 eine Variable erstellt haben $vm für das entsprechende Objekt. Also, lasst uns den Befehl ausführen Remove-AzVm:

$null = $vm | Remove-AzVM -Force

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

Unsere VM hat eins (oder sogar mehrere) Netzwerkinterfaces (NICs) – um sie bei Nichtgebrauch zu entfernen, schauen wir uns die Eigenschaft NetworkInterfaces unseres VM-Objekts an und löschen das NIC mit dem Befehl Remove-AzNetworkInterface. Für den Fall, dass es mehr als ein Netzwerkinterface gibt, verwenden wir eine Schleife. Außerdem überprüfen wir für jedes NIC die Eigenschaft IpConfiguration um zu sehen, ob das Interface eine öffentliche IP-Adresse hat. Wenn eine gefunden wird, löschen wir sie mit dem Befehl Remove-AzPublicIpAddress.

Hier ist ein Beispiel für solch einen Code, wo wir in einer Schleife alle NICs durchlaufen, sie löschen und überprüfen, ob eine öffentliche IP vorhanden ist. Wenn ja, analysieren wir die Eigenschaft PublicIpAddress, holen wir den Namen des entsprechenden Ressourcen-IDs und entfernen 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 Systemdisk

Die Betriebssystemdisk ist ein Blob, für dessen Löschung es einen Befehl gibt Remove-AzStorageBlob — aber bevor wir diesen ausführen, müssen die erforderlichen Werte für seine Parameter festgelegt werden. Dazu gehört insbesondere das Abrufen des Namens des Speichercontainers, der die Systemdisk enthält, und anschließend die Übergabe an diesen Befehl zusammen mit dem entsprechenden Speicheraccount.

$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 Status-Blogs der Systemdisk

Dazu, wie Sie sich wahrscheinlich schon gedacht haben, nehmen wir den Speichercontainer, in dem diese Disk gespeichert ist, und unter der Annahme, dass der Blob am Ende enthält status, wir übergeben die entsprechenden Parameter an den Löschbefehl Remove-AzStorageBlob:

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

Und schließlich entfernen wir die Datenträger

Unsere VM könnte Datenträger gehabt haben, die ihr angehängt waren. Wenn wir sie nicht mehr benötigen, werden wir auch diese löschen. Zunächst parsen wir StorageProfile unserer VM und finden die Eigenschaft Uri. Wenn es mehrere Datenträger gibt, organisieren wir eine Schleife über URI. Für jede URI finden wir das entsprechende Speicher-Konto mit Hilfe von Get-AzStorageAccount. Dann parsen wir die Speicher-URI, um den benötigten Blob-Namen herauszuziehen und ihn zusammen mit dem Speicher-Konto an den Löschbefehl zu übergeben Remove-AzStorageBlob . So könnte 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 aus all diesen Fragmente ein Ganzes schaffen. Der freundliche Autor Adam Bertram hat es den Nutzern erleichtert und dies selbst gemacht. Hier ist der Link zum finalen Skript mit dem Titel Remove-AzrVirtualMachine.ps1:

→ GitHub

Ich hoffe, dass Ihnen diese praktischen Tipps helfen, Ressourcen, Zeit und Kosten bei der Arbeit mit Azure VMs einzusparen.

Quelle: habr.com