Usar Discos Gerenciados do Azure com as bibliotecas do Azure (SDK) para Python

Os Managed Disks do Azure são armazenamento de blocos duráveis e de alto desempenho concebidos para utilização com as Máquinas Virtuais do Azure e a Solução VMware do Azure. Eles simplificam o gerenciamento de disco, oferecem maior escalabilidade, aumentam a segurança e eliminam a necessidade de gerenciar contas de armazenamento diretamente. Para obter mais informações, consulte Azure Managed Disks.

Para operações em Discos Geridos 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 integrados ao seu próprio código. Para saber como criar uma ComputeManagementClient instância a partir do azure.mgmt.compute script, consulte Exemplo - Criar uma máquina virtual.

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.

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 Managed Disk vazio. Você pode usá-lo como um disco em branco para anexar a uma máquina virtual ou como um 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 gerido a partir do 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 gerido a partir do armazenamento de bolha

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.

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 disco gerenciado 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 processa automaticamente a conta de armazenamento, pelo que não precisa de 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 um storage_profile a partir de 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 Geridos do Azure, necessitava criar manualmente uma conta de armazenamento para cada VM no seu Conjunto de Dimensionamento de Máquinas Virtuais e usar o parâmetro vhd_containers para especificar essas contas de armazenamento na API REST do Conjunto de Dimensionamento.

Com o Azure Managed Disks, o gerenciamento de contas de armazenamento não é mais necessário. Como resultado, os Conjuntos de Escala de storage_profileMáquina Virtual usados para Conjuntos de Dimensionamento de Máquina Virtual 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"
    }
},

A amostra completa é a 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 Managed Disks

Redimensionamento de um disco gerenciado

Este exemplo mostra como aumentar um Managed Disk 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 Managed Disks

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 blob

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 você pode usar 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 conectado a uma máquina virtual

Este exemplo mostra como tirar um instantâneo de um disco gerenciado conectado 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()

Ver também

Comentários

Esta página foi útil?

Last updated on 2025-06-12