Usare Azure Managed Disks con le librerie di Azure (SDK) per Python

Articolo
03/14/2024

Azure Managed Disks offre uno spazio di archiviazione a blocchi durevole e a prestazioni elevate progettato per essere usato con Macchine virtuali di Azure e la soluzione Azure VMware. Azure Managed Disks offre una gestione semplificata dei dischi, una scalabilità avanzata, una maggiore sicurezza e una migliore scalabilità senza dover lavorare direttamente con gli account di archiviazione. Per altre informazioni, vedere Azure Managed Disks.

Usare la azure-mgmt-compute libreria per amministrare Managed Disks per una macchina virtuale esistente.

Per un esempio di come creare una macchina virtuale con la azure-mgmt-compute libreria, vedere Esempio - Creare una macchina virtuale.

Gli esempi di codice in questo articolo illustrano come eseguire alcune attività comuni con i dischi gestiti usando la azure-mgmt-compute libreria . Non sono eseguibili così come sono, ma sono progettati per l'incorporamento nel proprio codice. Per informazioni su come creare un'istanza di azure.mgmt.compute ComputeManagementClient nel codice per eseguire gli esempi, vedere Esempio: creare una macchina virtuale.

Per esempi più completi su come usare la azure-mgmt-compute libreria, vedere Esempi di Azure SDK per Python per il calcolo in GitHub.

Dischi gestiti autonomi

È possibile creare dischi gestiti autonomi in molti modi, come illustrato nelle sezioni seguenti.

Creare un disco gestito vuoto

from azure.mgmt.compute.models import DiskCreateOption

poller = compute_client.disks.begin_create_or_update(
    'my_resource_group',
    'my_disk_name',
    {
        'location': 'eastus',
        'disk_size_gb': 20,
        'creation_data': {
            'create_option': DiskCreateOption.empty
        }
    }
)
disk_resource = poller.result()

Creare un disco gestito dall'archiviazione BLOB

Il disco gestito viene creato da un disco rigido virtuale (VHD) archiviato come BLOB.

from azure.mgmt.compute.models import DiskCreateOption

poller = compute_client.disks.begin_create_or_update(
    'my_resource_group',
    'my_disk_name',
    {
        'location': 'eastus',
        'creation_data': {
            'create_option': DiskCreateOption.IMPORT,
            'storage_account_id': '/subscriptions/<subscription-id>/resourceGroups/<resource-group-name>/providers/Microsoft.Storage/storageAccounts/<storage-account-name>',
            'source_uri': 'https://<storage-account-name>.blob.core.windows.net/vm-images/test.vhd'
        }
    }
)
disk_resource = poller.result()

Creare un'immagine di disco gestito dall'archiviazione BLOB

L'immagine del disco gestito viene creata da un disco rigido virtuale (VHD) archiviato come BLOB.

from azure.mgmt.compute.models import OperatingSystemStateTypes, HyperVGeneration

poller = compute_client.images.begin_create_or_update(
    'my_resource_group',
    'my_image_name',
    {
        'location': 'eastus',
        'storage_profile': {
           'os_disk': {
              'os_type': 'Linux',
              'os_state': OperatingSystemStateTypes.GENERALIZED,
              'blob_uri': 'https://<storage-account-name>.blob.core.windows.net/vm-images/test.vhd',
              'caching': "ReadWrite",
           },
        },
        'hyper_v_generation': HyperVGeneration.V2,
    }
)
image_resource = poller.result()

Creare un disco gestito da un'immagine personalizzata

from azure.mgmt.compute.models import DiskCreateOption

# If you don't know the id, do a 'get' like this to obtain it
managed_disk = compute_client.disks.get(self.group_name, 'myImageDisk')

poller = compute_client.disks.begin_create_or_update(
    'my_resource_group',
    'my_disk_name',
    {
        'location': 'eastus',
        'creation_data': {
            'create_option': DiskCreateOption.COPY,
            'source_resource_id': managed_disk.id
        }
    }
)

disk_resource = poller.result()

Macchina virtuale con dischi gestiti

È possibile creare una macchina virtuale con un disco gestito implicito per un'immagine del disco specifica, che evita di dover specificare tutti i dettagli.

Un disco gestito viene creato in modo implicito durante la creazione di una macchina virtuale da un'immagine del sistema operativo in Azure. Nel parametro storage_profile il valore os_disk è facoltativo e non è necessario creare un account di archiviazione come precondizione obbligatoria per la creazione di una macchina virtuale.

storage_profile = azure.mgmt.compute.models.StorageProfile(
    image_reference = azure.mgmt.compute.models.ImageReference(
        publisher='Canonical',
        offer='UbuntuServer',
        sku='16.04-LTS',
        version='latest'
    )
)

Per un esempio completo su come creare una macchina virtuale usando le librerie di gestione di Azure, per Python, vedere Esempio - Creare una macchina virtuale. Nell'esempio di creazione si usa il storage_profile parametro .

È anche possibile creare storage_profile dalla propria immagine:

# If you don't know the id, do a 'get' like this to obtain it
image = compute_client.images.get(self.group_name, 'myImageDisk')

storage_profile = azure.mgmt.compute.models.StorageProfile(
    image_reference = azure.mgmt.compute.models.ImageReference(
        id = image.id
    )
)

È possibile collegare facilmente un disco gestito di cui è stato eseguito il provisioning in precedenza:

vm = compute_client.virtual_machines.get(
    'my_resource_group',
    'my_vm'
)
managed_disk = compute_client.disks.get('my_resource_group', 'myDisk')

vm.storage_profile.data_disks.append({
    'lun': 12, # You choose the value, depending of what is available for you
    'name': managed_disk.name,
    'create_option': DiskCreateOptionTypes.attach,
    'managed_disk': {
        'id': managed_disk.id
    }
})

async_update = compute_client.virtual_machines.begin_create_or_update(
    'my_resource_group',
    vm.name,
    vm,
)
async_update.wait()

Set di scalabilità di macchine virtuali con Managed Disks

Senza Managed Disks, è necessario creare manualmente un account di archiviazione per tutte le VM da includere nel set di scalabilità e quindi usare il parametro di elenco vhd_containers per specificare i nomi di tutti gli account di archiviazione per l'API REST del set di scalabilità.

Poiché non è necessario gestire gli account di archiviazione con Azure Managed Disks, storage_profile per set di scalabilità di macchine virtuali ora può essere esattamente uguale a quello usato nella creazione della macchina virtuale:

'storage_profile': {
    'image_reference': {
        "publisher": "Canonical",
        "offer": "UbuntuServer",
        "sku": "16.04-LTS",
        "version": "latest"
    }
},

L'esempio completo è il seguente:

naming_infix = "PyTestInfix"

vmss_parameters = {
    'location': self.region,
    "overprovision": True,
    "upgrade_policy": {
        "mode": "Manual"
    },
    'sku': {
        'name': 'Standard_A1',
        'tier': 'Standard',
        'capacity': 5
    },
    'virtual_machine_profile': {
        'storage_profile': {
            'image_reference': {
                "publisher": "Canonical",
                "offer": "UbuntuServer",
                "sku": "16.04-LTS",
                "version": "latest"
            }
        },
        'os_profile': {
            'computer_name_prefix': naming_infix,
            'admin_username': 'Foo12',
            'admin_password': 'BaR@123!!!!',
        },
        'network_profile': {
            'network_interface_configurations' : [{
                'name': naming_infix + 'nic',
                "primary": True,
                'ip_configurations': [{
                    'name': naming_infix + 'ipconfig',
                    'subnet': {
                        'id': subnet.id
                    }
                }]
            }]
        }
    }
}

# Create VMSS test
result_create = compute_client.virtual_machine_scale_sets.begin_create_or_update(
    'my_resource_group',
    'my_scale_set',
    vmss_parameters,
)
vmss_result = result_create.result()

Altre operazioni con Managed Disks

Ridimensionamento di un disco gestito

managed_disk = compute_client.disks.get('my_resource_group', 'myDisk')
managed_disk.disk_size_gb = 25

async_update = self.compute_client.disks.begin_create_or_update(
    'my_resource_group',
    'myDisk',
    managed_disk
)
async_update.wait()

Aggiornare il tipo di account di archiviazione dei dischi gestiti

from azure.mgmt.compute.models import StorageAccountTypes

managed_disk = compute_client.disks.get('my_resource_group', 'myDisk')
managed_disk.account_type = StorageAccountTypes.STANDARD_LRS

async_update = self.compute_client.disks.begin_create_or_update(
    'my_resource_group',
    'myDisk',
    managed_disk
)
async_update.wait()

Creare un'immagine dall'archiviazione BLOB

async_create_image = compute_client.images.create_or_update(
    'my_resource_group',
    'myImage',
    {
        'location': 'eastus',
        'storage_profile': {
            'os_disk': {
                'os_type': 'Linux',
                'os_state': "Generalized",
                'blob_uri': 'https://<storage-account-name>.blob.core.windows.net/vm-images/test.vhd',
                'caching': "ReadWrite",
            }
        }
    }
)
image = async_create_image.result()

Creare uno snapshot di un disco gestito attualmente collegato a una macchina virtuale

managed_disk = compute_client.disks.get('my_resource_group', 'myDisk')

async_snapshot_creation = self.compute_client.snapshots.begin_create_or_update(
        'my_resource_group',
        'mySnapshot',
        {
            'location': 'eastus',
            'creation_data': {
                'create_option': 'Copy',
                'source_uri': managed_disk.id
            }
        }
    )
snapshot = async_snapshot_creation.result()

Condividi tramite