Azure Managed Disks gebruiken met de Azure-bibliotheken (SDK) voor Python

Artikel
03/14/2024

Azure Managed Disks zijn krachtige, duurzame blokopslag die is ontworpen voor gebruik met Azure Virtual Machines en Azure VMware Solution. Azure Managed Disks bieden vereenvoudigd schijfbeheer, verbeterde schaalbaarheid, verbeterde beveiliging en betere schaalaanpassing zonder rechtstreeks met opslagaccounts te hoeven werken. Zie Azure Managed Disks voor meer informatie.

U gebruikt de bibliotheek voor het azure-mgmt-compute beheren van Beheerde schijven voor een bestaande virtuele machine.

Zie Voorbeeld: een virtuele machine maken voor een voorbeeld van het maken van een virtuele machine met de azure-mgmt-compute bibliotheek.

De codevoorbeelden in dit artikel laten zien hoe u enkele algemene taken met beheerde schijven uitvoert met behulp van de azure-mgmt-compute bibliotheek. Ze kunnen niet als zodanig worden uitgevoerd, maar zijn ontworpen om in uw eigen code op te nemen. U kunt het voorbeeld raadplegen : een virtuele machine maken om te leren hoe u een exemplaar van azure.mgmt.compute ComputeManagementClient uw code maakt om de voorbeelden uit te voeren.

Zie Azure SDK voor Python-voorbeelden voor berekeningen in GitHub voor meer volledige voorbeelden van het gebruik van de azure-mgmt-compute bibliotheek.

Zelfstandige beheerde schijven

U kunt zelfstandige beheerde schijven op veel manieren maken, zoals wordt geïllustreerd in de volgende secties.

Een lege beheerde schijf maken

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

Een beheerde schijf maken op basis van blobopslag

De beheerde schijf wordt gemaakt op basis van een virtuele harde schijf (VHD) die is opgeslagen als 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()

Een managed disk-installatiekopieën maken vanuit blobopslag

De installatiekopieën van de beheerde schijf worden gemaakt op basis van een virtuele harde schijf (VHD) die is opgeslagen als 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()

Een beheerde schijf maken op basis van uw eigen installatiekopieën

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

Virtuele machine met Managed Disks

U kunt een virtuele machine maken met een impliciete beheerde schijf voor een specifieke schijfinstallatiekopieën, waardoor u niet alle details kunt opgeven.

Een beheerde schijf wordt impliciet gemaakt bij het maken van een virtuele machine op basis van een installatiekopieën van het besturingssysteem in Azure. In de storage_profile parameter is de os_disk optie optioneel en hoeft u geen opslagaccount te maken als vereiste voorwaarde voor het maken van een virtuele machine.

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

Zie Voor Python een volledig voorbeeld van het maken van een virtuele machine met behulp van de Azure-beheerbibliotheken, voor Python: een virtuele machine maken. In het voorbeeld voor het maken gebruikt u de storage_profile parameter.

U kunt ook een storage_profile van uw eigen installatiekopieën maken:

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

U kunt eenvoudig een eerder ingerichte beheerde schijf koppelen:

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

Virtuele-machineschaalsets met beheerde schijven

Voordat u beheerde schijven hebt gemaakt, moet u handmatig een opslagaccount maken voor alle vm's die u in de schaalset wilt gebruiken en vervolgens de lijstparameter vhd_containers gebruiken om alle naam van het opslagaccount op te geven aan de RestAPI van de schaalset.

Omdat u geen opslagaccounts hoeft te beheren met Azure Managed Disks, kunnen uw storage_profile virtuele-machineschaalsets nu exact hetzelfde zijn als het account dat wordt gebruikt bij het maken van een virtuele machine:

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

Het volledige voorbeeld is als volgt:

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

Andere bewerkingen met Managed Disks

Het formaat van een beheerde schijf wijzigen

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

Het opslagaccounttype van de beheerde schijven bijwerken

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

Een afbeelding maken vanuit blobopslag

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

Een momentopname maken van een beheerde schijf die momenteel is gekoppeld aan een virtuele machine

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

Delen via