Compartilhar via


Usar o Managed Disks do Azure com as bibliotecas do Azure (SDK) para Python

Managed Disks do Azure são armazenamentos em bloco duráveis de alto desempenho projetados para serem usados com Máquinas Virtuais do Microsoft Azure e a Solução VMware no Azure. Os Managed Disks do Azure fornecem gerenciamento de disco simplificado, escalabilidade aprimorada, segurança aprimorada e melhor dimensionamento sem precisar trabalhar diretamente com contas de armazenamento. Para obter mais informações, consulte Discos gerenciados do Azure.

Use a azure-mgmt-compute biblioteca para administrar discos gerenciados para uma máquina virtual existente.

Para obter um exemplo de como criar uma máquina virtual com a azure-mgmt-compute biblioteca, consulte Exemplo - Criar uma máquina virtual.

Os exemplos de código neste artigo demonstram como executar algumas tarefas comuns com discos gerenciados usando a azure-mgmt-compute biblioteca. Eles não são executáveis como estão, mas são projetados para você incorporar em seu próprio código. Você pode consultar Exemplo - Criar uma máquina virtual para saber como criar uma instância de azure.mgmt.compute ComputeManagementClient em seu código para executar os exemplos.

Para obter exemplos mais completos de como usar a azure-mgmt-compute biblioteca, consulte Exemplos do SDK do Azure para Python para computação no GitHub.

Managed Disks Autônomos

Você pode criar discos gerenciados autônomos de várias maneiras, conforme ilustrado nas seções a seguir.

Criar um Managed Disk vazio

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

Criar um Managed Disk com base no armazenamento de blobs

O disco gerenciado é criado a partir de um VHD (disco rígido virtual) armazenado como um 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()

Criar uma imagem de disco gerenciado com base no Armazenamento de Blobs

A imagem de disco gerenciado é criada a partir de um disco rígido virtual (VHD) armazenado como um 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()

Criar um Managed Disk com base na sua própria imagem

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

Máquina virtual com Managed Disks

Você pode criar uma Máquina Virtual com um Managed Disk implícito para uma imagem de disco específica, reduzindo a necessidade de especificar todos os detalhes.

Um Disco Gerenciado é criado implicitamente ao criar uma VM a partir de uma imagem do sistema operacional no Azure. No parâmetro storage_profile, o os_disk é opcional e você não precisa criar uma conta de armazenamento como uma pré-condição necessária para criar uma Máquina Virtual.

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

Para obter um exemplo completo sobre como criar uma máquina virtual usando as bibliotecas de gerenciamento do Azure, para Python, consulte Exemplo - Criar uma máquina virtual. No exemplo create, você usa o storage_profile parâmetro.

Você também pode criar um storage_profile usando sua própria imagem:

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

Você pode anexar facilmente um Managed Disk provisionado anteriormente:

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

Conjuntos de Dimensionamento de Máquina Virtual com Managed Disks

Antes dos Managed Disks, é necessário criar uma conta de armazenamento manualmente para todas as VMs que você deseja dentro dp seu Conjunto de Dimensionamento e, em seguida, usar o parâmetro de lista vhd_containers para fornecer todo o nome da conta de armazenamento para o API REST do Conjunto de Dimensionamento.

Como você não precisa gerenciar contas de armazenamento com os Discos Gerenciados do Azure, seus storage_profileConjuntos de Dimensionamento de Máquina Virtual agora podem ser exatamente iguais aos usados na criação de VM:

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

Veja o seguinte exemplo completo:

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

Outras operações com Managed Disks

Redimensionar um Managed Disk

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

Atualizar o tipo de conta de armazenamento dos Managed Disks

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

Criar uma imagem usando um armazenamento de blobs

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

Criar um instantâneo de um Managed Disk que está atualmente anexado a uma máquina virtual

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

Confira também