🥇Modifichiamo e rimuoviamo le Azure VM utilizzando PowerShell

Con PowerShell, ingegneri e amministratori IT automatizzano con successo varie attività non solo su infrastrutture on-premises, ma anche su quelle cloud, in particolare su Azure. Lavorare tramite PowerShell è in molti casi molto più comodo e veloce rispetto all'Azure portal. Grazie alla sua natura cross-platform, PowerShell può essere utilizzato su qualsiasi OS.

Non importa se stai lavorando con Ubuntu, Red Hat o Windows: PowerShell ti aiuterà a controllare le risorse cloud. Utilizzando il modulo Azure PowerShell, ad esempio, è possibile impostare qualsiasi proprietà delle macchine virtuali.

In questo articolo esamineremo come utilizzare PowerShell per modificare le dimensioni di una VM nel cloud di Azure, nonché per eliminare una VM e gli oggetti a essa associati.

Importante! Non dimenticare di disinfettarti le mani con igienizzante per prepararti al lavoro:

Avrai bisogno del modulo Azure PowerShell Module — può essere scaricato dalla PowerShell Gallery con il comando Install-Module Az.
È necessario autenticarsi nel cloud di Azure in cui è in esecuzione la macchina virtuale, eseguendo il comando Connect-AzAccount.

Iniziamo a creare uno script che ridimensiona una VM di Azure. Apriamo VS Code e salviamo un nuovo script PowerShell con il nome Resize-AzVirtualMachine.ps1 — in esso aggiungeremo frammenti di codice nel corso dell'esempio.

Richiedere le dimensioni disponibili della VM

Prima di cambiare le dimensioni della VM, dobbiamo sapere quali sono le dimensioni ammissibili per le macchine virtuali nel cloud di Azure. Per farlo, è necessario eseguire il comando Get-AzVMSize.

Quindi, per la macchina virtuale devvm01 del gruppo di risorse dev richiediamo tutte le dimensioni ammissibili:

Get-AzVMSize -ResourceGroupName dev -VMName devvm01

(Nelle attività reali, ovviamente, al posto di ResourceGroupName=dev e VMName=devvm01 indicherai i tuoi valori per questi parametri.)

Il comando restituirà un elenco simile a questo:

Queste sono tutte le dimensioni disponibili che possono essere impostate per questa macchina virtuale.

Ridimensioniamo la macchina

Per esempio, effettueremo un ridimensionamento a una nuova dimensione Standard_B1ls — è al primo posto nell'elenco sopra. (Nelle attività reali, ovviamente, scegli qualsiasi dimensione ti necessiti.)

Iniziamo con il comando Get-AzVM per ottenere informazioni sul nostro oggetto (macchina virtuale), conservandole in una variabile $virtualMachine:
```
$virtualMachine = Get-AzVM -ResourceGroupName dev -VMName devvm01
```
Quindi, da questo oggetto prendiamo la proprietà .HardwareProfile.VmSize e impostiamo il nuovo valore desiderato:
```
$virtualMachine.HardwareProfile.VmSize = "Standard_B1ls"
```
E ora eseguiamo semplicemente il comando di aggiornamento della VM — Update-AzVm:
```
Update-AzVM -VM devvm01 -ResourceGroupName dev
```
Assicuriamoci che tutto sia andato a buon fine: per farlo, richiediamo nuovamente informazioni sul nostro oggetto e osserviamo la proprietà $virtualMachine.HardwareProfile:
```
$virtualMachine = Get-AzVM -ResourceGroupName dev -VMName devvm01
$virtualMachine.HardwareProfile
```

Se vediamo questo Standard_B1ls — significa che tutto va bene, la dimensione della macchina è stata modificata. Possiamo andare avanti e continuare il successo: ridimensionare più VM contemporaneamente utilizzando un array.

E per quanto riguarda la rimozione delle VM in Azure?

Con la rimozione non è tutto così semplice e lineare come potrebbe sembrare. Infatti, è necessario eliminare anche diversi altri oggetti associati a questa macchina, tra cui:

Container di storage per la diagnostica di avvio (Boot diagnostics storage containers)
Interfacce di rete
Indirizzi IP pubblici
Disco di sistema e blob in cui viene memorizzato il suo stato
Dischi dati (data disks)

Perciò creeremo una funzione e la chiameremo Remove-AzrVirtualMachine — e questa rimuoverà non solo la VM di Azure, ma anche tutto quanto sopra.

Seguiamo il percorso standard e prima otteniamo il nostro oggetto (VM) utilizzando il comando Get-AzVm. Per esempio, supponiamo che questa sia la macchina WINSRV19 del gruppo di risorse MyTestVMs.

Salviamo questo oggetto insieme a tutte le sue proprietà in una variabile $vm:

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

Eliminiamo il container con i file di diagnostica di avvio

Quando si crea una VM in Azure, viene anche offerta la possibilità di creare un container per la diagnostica di avvio (boot diagnostics container), affinché, in caso di problemi di avvio, ci sia qualcosa a cui fare riferimento per il troubleshooting. Tuttavia, quando si elimina la VM, questo container continua a esistere, ora senza scopo. Correggiamo questa situazione.

Innanzitutto cerchiamo quale account di storage appartiene a questo container: per farlo, dobbiamo rintracciare la proprietà storageUri all'interno dell'oggetto DiagnosticsProfile della nostra VM. Per questo utilizzo una regex come questa:
```
$diagSa = [regex]::match($vm.DiagnosticsProfile.bootDiagnostics.storageUri, '^http[s]?:\/\/(.+?)\.').groups[1].value
```

Ora dobbiamo scoprire il nome del container, e per questo dobbiamo ottenere l'ID della VM con il comando 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)

Successivamente otteniamo il nome del gruppo di risorse a cui appartiene il container:

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

E ora abbiamo tutto il necessario per rimuovere il contenitore con il comando Remove-AzStorageContainer:

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

Rimuoviamo la VM

Ora rimuoviamo la macchina virtuale stessa, dato che abbiamo già creato la variabile $vm per l'oggetto corrispondente. Beh, avviamo il comando Remove-AzVm:

$null = $vm | Remove-AzVM -Force

Rimuoviamo l'interfaccia di rete e l'indirizzo IP pubblico

La nostra VM ha una (o anche più) interfaccia di rete (NIC) — per rimuoverle se non necessarie, esaminiamo la proprietà NetworkInterfaces del nostro oggetto VM e rimuoviamo il NIC con il comando Remove-AzNetworkInterface. Nel caso ci siano più interfacce di rete, utilizziamo un ciclo. Ogni NIC, inoltre, verificherà la proprietà IpConfiguration per vedere se l'interfaccia ha un indirizzo IP pubblico. Se viene trovato, lo rimuoviamo con il comando Remove-AzPublicIpAddress.

Ecco un esempio di codice in cui esaminiamo in ciclo tutte le NIC, le rimuoviamo e controlliamo se c'è un IP pubblico. Se sì, estraiamo il valore della proprietà PublicIpAddress, prendiamo il nome della risorsa corrispondente tramite ID e la rimuoviamo:


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
        }
    }
}

Rimuoviamo il disco di sistema

Il disco OS è un blob, per rimuoverlo c'è il comando Remove-AzStorageBlob — ma prima di eseguirlo, sarà necessario impostare i valori richiesti per i suoi parametri. A tal fine, in particolare, è necessario ottenere il nome del contenitore di archiviazione che contiene il disco di sistema e poi passarlo a questo comando insieme all'account di archiviazione corrispondente.

$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]

Rimuoviamo il Blob dello stato del disco di sistema

Per farlo, come avrete già intuito, prendiamo il contenitore di archiviazione in cui questo disco è conservato e, supponendo che il blob alla fine contenga stato, passiamo i parametri corrispondenti al comando di rimozione Remove-AzStorageBlob:

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

E, infine, rimuoviamo i dischi con i dati

La nostra VM potrebbe avere dischi con dati che erano stati ad essa associati. Se non sono necessari, rimuoviamoli anche. Iniziamo a analizzare StorageProfile della nostra VM e troveremo la proprietà Uri. Se ci sono più dischi, organizziamo un ciclo su URI. Per ogni URI troveremo l'account di archiviazione corrispondente utilizzando Get-AzStorageAccount. Poi analizziamo l'URI di archiviazione per estrarre il nome del blob necessario e passarne il comando di eliminazione Remove-AzStorageBlob insieme all'account di archiviazione. Ecco come apparirà nel codice:

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]
    }
}

E ora "siamo arrivati alla felice conclusione!" Ora dobbiamo raccogliere tutti questi frammenti in un tutto unico. Il gentile autore Adam Bertram è andato incontro agli utenti e lo ha fatto lui stesso. Ecco il link allo script finale intitolato Remove-AzrVirtualMachine.ps1:

→ GitHub

Spero che questi consigli pratici possano esservi utili per risparmiare energie, tempo e risorse nella gestione delle Azure VM.

Fonte: habr.com