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

Azure Managed Disks è un'archiviazione a blocchi durevole e a prestazioni elevate progettata per l'uso con macchine virtuali di Azure e la soluzione Azure VMware. Semplificano la gestione dei dischi, offrono maggiore scalabilità, migliorano la sicurezza ed eliminano la necessità di gestire direttamente gli account di archiviazione. Per altre informazioni, vedere Azure Managed Disks.

Per le operazioni su Managed Disks associate a una macchina virtuale esistente, usare la azure-mgmt-compute libreria .

Gli esempi di codice in questo articolo illustrano le operazioni comuni con Managed Disks usando la azure-mgmt-compute libreria . Questi esempi non devono essere eseguiti come script autonomi, ma piuttosto essere integrati nel proprio codice. Per informazioni su come creare un'istanza ComputeManagementClient da azure.mgmt.compute nello script, 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

Gli esempi seguenti illustrano diversi modi per effettuare il provisioning di Managed Disks autonomi.

Creare un disco gestito vuoto

Questo esempio illustra come creare un nuovo disco gestito vuoto. È possibile usarlo come disco vuoto per collegarsi a una macchina virtuale o come punto di partenza per la creazione di snapshot o immagini.

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

Questo esempio illustra come creare un disco gestito da un file VHD archiviato in Archiviazione BLOB di Azure. Ciò è utile quando si vuole riutilizzare o spostare un disco rigido virtuale esistente in Azure.

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 del disco gestito da un archivio BLOB

Questo esempio illustra come creare un'immagine del disco gestito da un file VHD archiviato in Archiviazione BLOB di Azure. Ciò è utile quando si vuole creare un'immagine riutilizzabile che può essere usata per creare nuove macchine virtuali.

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

Questo esempio illustra come creare un nuovo disco gestito copiando uno esistente. Ciò è utile quando si vuole eseguire un backup o usare la stessa configurazione del disco in un'altra macchina virtuale.

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 Managed Disks

È possibile creare una macchina virtuale con un disco gestito creato in modo implicito in base a un'immagine disco specifica, eliminando la necessità di definire manualmente tutti i dettagli del disco.

Un disco gestito viene creato in modo implicito durante la creazione di una macchina virtuale da un'immagine del sistema operativo in Azure. Azure gestisce automaticamente l'account di archiviazione, quindi non è necessario specificare storage_profile.os_disk o creare manualmente un account di archiviazione.

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 che illustra come creare una macchina virtuale usando le librerie di gestione di Azure per Python, vedere Esempio - Creare una macchina virtuale. In questo esempio viene illustrato come usare il storage_profile parametro .

È anche possibile creare un oggetto 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 provisionato 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

Prima di Azure Managed Disks, è stato necessario creare manualmente un account di archiviazione per ogni macchina virtuale nel set di scalabilità di macchine virtuali e usare il vhd_containers parametro per specificare tali account di archiviazione nell'API REST del set di scalabilità.

Con Azure Managed Disks, la gestione degli account di archiviazione non è più necessaria. Di conseguenza, il storage_profile per i set di scalabilità di macchine virtuali utilizzati per i set di scalabilità di macchine virtuali può ora corrispondere a quello usato per la creazione di singole macchine virtuali.

'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

Questo esempio mostra come ingrandire un disco gestito esistente. Ciò è utile quando sono necessari più spazio per i dati o le applicazioni.

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 di Managed Disks

Questo esempio illustra come modificare il tipo di archiviazione di un disco gestito e renderlo più grande. Ciò è utile quando sono necessari più spazio o prestazioni migliori per i dati o le applicazioni.

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'archivio BLOB

Questo esempio illustra come creare un'immagine del disco gestito da un file VHD archiviato in Archiviazione BLOB di Azure. Ciò è utile quando si vuole creare un'immagine riutilizzabile che è possibile usare per creare nuove macchine virtuali.

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

Questo esempio illustra come creare uno snapshot di un disco gestito collegato a una macchina virtuale. È possibile usare lo snapshot per eseguire il backup del disco o ripristinarlo in un secondo momento, se necessario.

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()

Vedere anche

• Esempio: Creare una macchina virtuale
• Esempio: Creare un gruppo di risorse
• Esempio: Elencare i gruppi di risorse in una sottoscrizione
• Esempio: Creare Archiviazione di Azure
• Esempio di : Usare Azure Storage
• Esempio: Creare e usare un database MySQL
• Completare un breve sondaggio su Azure SDK per Python