Usar discos gerenciados do Azure com as bibliotecas do Azure (SDK) para Python

Os Discos Gerenciados do Azure são armazenamento em bloco durável de alto desempenho projetado para uso com máquinas virtuais do Azure e solução VMware no Azure. Eles simplificam o gerenciamento de disco, oferecem maior escalabilidade, aprimoram a segurança e eliminam a necessidade de gerenciar contas de armazenamento diretamente. Para obter mais informações, consulte Discos Gerenciados do Azure.

Para operações em discos gerenciados associados a uma VM existente, use a azure-mgmt-compute biblioteca.

Os exemplos de código neste artigo demonstram operações comuns com Discos Gerenciados usando a azure-mgmt-compute biblioteca. Esses exemplos não devem ser executados como scripts autônomos, mas sim para serem integrados ao seu próprio código. Para saber como criar uma instância ComputeManagementClientazure.mgmt.compute em seu script, veja Exemplo - Criar uma máquina virtual.

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

Discos Gerenciados Autônomos

Os exemplos a seguir mostram diferentes maneiras de provisionar discos gerenciados autônomos.

Criar um disco gerenciado vazio

Este exemplo mostra como criar um novo Disco Gerenciado vazio. Você pode usá-lo como um disco em branco para anexar a uma máquina virtual ou como ponto de partida para criar instantâneos ou imagens.

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 Disco Gerenciado com base no armazenamento de blobs

Este exemplo mostra como criar um Disco Gerenciado a partir de um arquivo VHD armazenado no Armazenamento de Blobs do Azure. Isso é útil quando você deseja reutilizar ou mover um disco rígido virtual existente para o 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()

Criar uma imagem de disco gerenciado a partir do armazenamento de blobs

Este exemplo mostra como criar uma imagem de Disco Gerenciado a partir de um arquivo VHD armazenado no Armazenamento de Blobs do Azure. Isso é útil quando você deseja fazer uma imagem reutilizável que pode ser usada para criar novas máquinas virtuais.

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 Disco Gerenciado a partir de sua própria imagem

Este exemplo mostra como criar um novo Managed Disk copiando um existente. Isso é útil quando você deseja fazer um backup ou usar a mesma configuração de disco em outra máquina virtual.

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 Discos Gerenciados

Você pode criar uma máquina virtual com um Managed Disk criado implicitamente com base em uma imagem de disco específica, eliminando a necessidade de definir manualmente todos os detalhes do disco.

Um Disco Gerenciado é criado implicitamente ao criar uma VM a partir de uma imagem do sistema operacional no Azure. O Azure manipula automaticamente a conta de armazenamento, portanto, você não precisa especificar storage_profile.os_disk ou criar uma conta de armazenamento manualmente.

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 mostrando como criar uma máquina virtual usando as bibliotecas de gerenciamento do Azure para Python, consulte Exemplo – Criar uma máquina virtual. Este exemplo demonstra como usar o storage_profile parâmetro.

Você também pode criar uma storage_profile com base em 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 Disco Gerenciado 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áquinas Virtuais com Discos Gerenciados

Antes dos Discos Gerenciados do Azure, você precisava criar manualmente uma conta de armazenamento para cada VM em seu Conjunto de Dimensionamento de Máquinas Virtuais e usar o vhd_containers parâmetro para especificar essas contas de armazenamento na API REST do Conjunto de Dimensionamento.

Com os Discos Gerenciados do Azure, o gerenciamento de conta de armazenamento não é mais necessário. Como resultado, os storage_profileConjuntos de Dimensionamento de Máquinas Virtuais usados para Conjuntos de Dimensionamento de Máquinas Virtuais agora podem corresponder ao usado para a criação de VM individual:

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

O exemplo completo é o seguinte:

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 Discos Gerenciados

Redimensionando um disco gerenciado

Este exemplo mostra como aumentar um Disco Gerenciado existente. Isso é útil quando você precisa de mais espaço para seus dados ou aplicativos.

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 Discos Gerenciados

Este exemplo mostra como alterar o tipo de armazenamento de um Disco Gerenciado e torná-lo maior. Isso é útil quando você precisa de mais espaço ou melhor desempenho para seus dados ou aplicativos.

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 a partir do armazenamento de blobs

Este exemplo mostra como criar uma imagem de Disco Gerenciado a partir de um arquivo VHD armazenado no Armazenamento de Blobs do Azure. Isso é útil quando você deseja criar uma imagem reutilizável que pode ser usada para criar novas máquinas virtuais.

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 Disco Gerenciado que está atualmente anexado a uma máquina virtual

Este exemplo mostra como tirar um instantâneo de um Disco Gerenciado anexado a uma máquina virtual. Você pode usar o instantâneo para fazer backup do disco ou restaurá-lo mais tarde, se necessário.

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

Consulte também

• Exemplo: criar uma máquina virtual
• Exemplo: criar um grupo de recursos
• Exemplo: listar grupos de recursos em uma assinatura
• Exemplo: criar o Armazenamento do Azure
• Exemplo: usar o Armazenamento do Azure
• Exemplo: criar e usar um banco de dados MySQL
• Conclua uma breve pesquisa sobre o SDK do Azure para Python