Använda Azure Managed Disks med Azure-bibliotek (SDK) för Python

Azure Managed Disks är högpresterande, beständig blocklagring utformad för användning med Azure Virtual Machines och Azure VMware Solution. De förenklar diskhanteringen, ger bättre skalbarhet, förbättrar säkerheten och eliminerar behovet av att hantera lagringskonton direkt. Mer information finns i Azure Managed Disks.

Använd biblioteket för åtgärder på hanterade diskar som är associerade med en befintlig virtuell dator azure-mgmt-compute .

Kodexemplen i den här artikeln visar vanliga åtgärder med hanterade diskar med hjälp av azure-mgmt-compute biblioteket. De här exemplen är inte avsedda att köras som fristående skript, utan snarare att integreras i din egen kod. Mer information om hur du skapar en ComputeManagementClient instans från azure.mgmt.compute i skriptet finns i Exempel – Skapa en virtuell dator.

Mer fullständiga exempel på hur du använder biblioteket finns i azure-mgmt-computeAzure SDK för Python-exempel för beräkning i GitHub.

Fristående hanterade diskar

I följande exempel visas olika sätt att etablera fristående hanterade diskar.

Skapa en tom hanterad disk

Det här exemplet visar hur du skapar en ny tom hanterad disk. Du kan använda den som en tom disk för att ansluta till en virtuell dator eller som utgångspunkt för att skapa ögonblicksbilder eller avbildningar.

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

Skapa en hanterad disk från bloblagring

Det här exemplet visar hur du skapar en hanterad disk från en VHD-fil som lagras i Azure Blob Storage. Det här är användbart när du vill återanvända eller flytta en befintlig virtuell hårddisk till 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()

Skapa en Hanterad disk-avbildning från Blob Storage

Det här exemplet visar hur du skapar en Hanterad disk-avbildning från en VHD-fil som lagras i Azure Blob Storage. Det här är användbart när du vill skapa en återanvändbar avbildning som kan användas för att skapa nya virtuella datorer.

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

Skapa en hanterad disk från din egen avbildning

Det här exemplet visar hur du skapar en ny hanterad disk genom att kopiera en befintlig disk. Det här är användbart när du vill göra en säkerhetskopia eller använda samma diskkonfiguration på en annan virtuell dator.

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

Virtuell dator med hanterade diskar

Du kan skapa en virtuell dator med en implicit skapad hanterad disk baserat på en specifik diskbild, vilket eliminerar behovet av att manuellt definiera all diskinformation.

En hanterad disk skapas implicit när du skapar en virtuell dator från en OS-avbildning i Azure. Azure hanterar lagringskontot automatiskt, så du behöver inte ange storage_profile.os_disk eller skapa ett lagringskonto manuellt.

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

Ett fullständigt exempel som visar hur du skapar en virtuell dator med hjälp av Azure-hanteringsbiblioteken för Python finns i Exempel – Skapa en virtuell dator. Det här exemplet visar hur du använder parametern storage_profile .

Du kan också skapa en storage_profile från din egen avbildning:

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

Du kan enkelt ansluta en tidigare tilldelad hanterad disk.

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

Virtuella Maskin Skalningsuppsättningar med Hanterade Diskar

Innan Azure Managed Disks var du tvungen att manuellt skapa ett lagringskonto för varje virtuell dator i vm-skalningsuppsättningen och använda parametern vhd_containers för att ange dessa lagringskonton i REST API för skalningsuppsättning.

Med Azure Managed Disks krävs inte längre hantering av lagringskonton. Därför kan storage_profile för virtuella datorer som används för VM-skalningsuppsättningar nu matcha den som används för att skapa enskilda virtuella datorer:

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

Det fullständiga exemplet är följande:

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

Andra åtgärder med hanterade diskar

Ändra storlek på en hanterad disk

Det här exemplet visar hur du gör en befintlig hanterad disk större. Detta är användbart när du behöver mer utrymme för dina data eller program.

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

Uppdatera lagringskontotypen för hanterade diskar

Det här exemplet visar hur du ändrar lagringstypen för en hanterad disk och gör den större. Detta är användbart när du behöver mer utrymme eller bättre prestanda för dina data eller program.

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

Skapa en avbildning från Blob Storage

Det här exemplet visar hur du skapar en Hanterad disk-avbildning från en VHD-fil som lagras i Azure Blob Storage. Det här är användbart när du vill skapa en återanvändbar avbildning som du kan använda för att skapa nya virtuella datorer.

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

Skapa en ögonblicksbild av en hanterad disk som för närvarande är ansluten till en virtuell dator

Det här exemplet visar hur du tar en ögonblicksbild av en hanterad disk som är ansluten till en virtuell dator. Du kan använda ögonblicksbilden för att säkerhetskopiera disken eller återställa den senare om det behövs.

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

Se även

• Exempel: Skapa en virtuell dator
• Exempel: Skapa en resursgrupp
• Exempel: Lista resursgrupper i en prenumeration
• Exempel: Skapa Azure Storage
• Exempel: Använda Azure Storage
• Exempel: Skapa och använda en MySQL-databas
• Slutför en kort undersökning om Azure SDK för Python