Udostępnij za pomocą

Używaj zarządzanych dysków Azure z bibliotekami Azure (SDK) w języku Python

Dyski zarządzane platformy Azure to magazyn blokowy o wysokiej wydajności przeznaczony do użytku z usługami Azure Virtual Machines i Azure VMware Solution. Upraszczają zarządzanie dyskami, zapewniają większą skalowalność, zwiększają bezpieczeństwo i eliminują konieczność bezpośredniego zarządzania kontami magazynu. Aby uzyskać więcej informacji, zobacz Dyski zarządzane platformy Azure.

W przypadku operacji na dyskach zarządzanych skojarzonych z istniejącą maszyną wirtualną użyj biblioteki azure-mgmt-compute .

Przykłady kodu w tym artykule przedstawiają typowe operacje z dyskami zarządzanymi przy użyciu azure-mgmt-compute biblioteki. Te przykłady nie mają być uruchamiane jako autonomiczne skrypty, ale raczej integrowane z własnym kodem. Aby dowiedzieć się, jak utworzyć instancję ComputeManagementClient z azure.mgmt.compute w swoim skrypcie, zobacz Przykład - Tworzenie maszyny wirtualnej.

Aby uzyskać więcej kompletnych przykładów korzystania z biblioteki azure-mgmt-compute, zobacz przykłady użycia Azure SDK for Python dla obliczeń na GitHub.

Autonomiczne dyski zarządzane

W poniższych przykładach pokazano różne sposoby aprowizacji autonomicznych dysków zarządzanych.

Tworzenie pustego dysku zarządzanego

W tym przykładzie pokazano, jak utworzyć nowy pusty dysk zarządzany. Można go użyć jako pustego dysku, aby dołączyć do maszyny wirtualnej lub jako punkt wyjścia do tworzenia migawek lub obrazów.

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

Utwórz dysk zarządzany z magazynu BLOB

W tym przykładzie pokazano, jak utworzyć dysk zarządzany na podstawie pliku VHD przechowywanego w usłudze Azure Blob Storage. Jest to przydatne, gdy chcesz ponownie użyć lub przenieść istniejący wirtualny dysk twardy na platformę 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()

Tworzenie obrazu dysku zarządzanego z magazynu obiektów blob

W tym przykładzie pokazano, jak utworzyć obraz dysku zarządzanego z pliku VHD przechowywanego w usłudze Azure Blob Storage. Jest to przydatne, gdy chcesz utworzyć obraz wielokrotnego użytku, który może służyć do tworzenia nowych maszyn wirtualnych.

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

Tworzenie dysku zarządzanego na podstawie własnego obrazu

W tym przykładzie pokazano, jak utworzyć nowy dysk zarządzany, kopiując istniejący. Jest to przydatne, gdy chcesz utworzyć kopię zapasową lub użyć tej samej konfiguracji dysku na innej maszynie wirtualnej.

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

Maszyna wirtualna z dyskami zarządzanymi

Maszynę wirtualną z niejawnie utworzonym dyskiem zarządzanym można utworzyć na podstawie określonego obrazu dysku, eliminując konieczność ręcznego zdefiniowania wszystkich szczegółów dysku.

Dysk zarządzany jest tworzony niejawnie podczas tworzenia maszyny wirtualnej na podstawie obrazu systemu operacyjnego na platformie Azure. Platforma Azure automatycznie obsługuje konto magazynu, więc nie musisz ręcznie określać storage_profile.os_disk ani ręcznie tworzyć konta magazynu.

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

Pełny przykład pokazujący, jak utworzyć maszynę wirtualną przy użyciu bibliotek zarządzania platformy Azure dla języka Python, zobacz Przykład — tworzenie maszyny wirtualnej. W tym przykładzie pokazano, jak używać parametru storage_profile .

Możesz również utworzyć obiekt storage_profile na podstawie własnego obrazu:

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

Możesz łatwo dołączyć wcześniej aprowizowany dysk zarządzany:

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

Zestawy skalowania maszyn wirtualnych z zarządzanymi dyskami

Przed użyciem funkcji Dyski zarządzane platformy Azure trzeba było ręcznie utworzyć konto magazynu dla każdej maszyny wirtualnej w zestawie skalowania maszyn wirtualnych i użyć parametru vhd_containers , aby określić te konta magazynu w interfejsie API REST zestawu skalowania.

Zarządzanie kontami magazynu nie jest już wymagane w przypadku dysków zarządzanych Azure. W związku z tym zestawy storage_profileskalowania maszyn wirtualnych używane dla zestawów skalowania maszyn wirtualnych mogą teraz odpowiadać temu, który jest używany do tworzenia poszczególnych maszyn wirtualnych:

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

Pełny przykład wygląda następująco:

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

Inne operacje z dyskami zarządzanymi

Zmiana rozmiaru dysku zarządzanego

W tym przykładzie pokazano, jak zwiększyć istniejący dysk zarządzany. Jest to przydatne, gdy potrzebujesz więcej miejsca na dane lub aplikacje.

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

Zaktualizuj typ konta magazynu dla dysków zarządzanych

W tym przykładzie pokazano, jak zmienić typ magazynu dysku zarządzanego i zwiększyć go. Jest to przydatne, gdy potrzebujesz większej ilości miejsca lub lepszej wydajności dla danych lub aplikacji.

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

Tworzenie obrazu z przechowywania blobów

W tym przykładzie pokazano, jak utworzyć obraz dysku zarządzanego z pliku VHD przechowywanego w usłudze Azure Blob Storage. Jest to przydatne, gdy chcesz utworzyć obraz wielokrotnego użytku, którego można użyć do tworzenia nowych maszyn wirtualnych.

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

Utwórz migawkę dysku zarządzanego, który jest obecnie dołączony do maszyny wirtualnej

W tym przykładzie pokazano, jak utworzyć migawkę dysku zarządzanego dołączonego do maszyny wirtualnej. Możesz użyć migawki, aby utworzyć kopię zapasową dysku lub przywrócić go później w razie potrzeby.

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

Zobacz także

  • Last updated on