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 Managed Disks do Azure.

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. Estes exemplos não são feitos para serem executados como scripts autónomos, mas sim para serem integrados no 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. Este método é útil quando quiser 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. Este método é útil quando queres criar uma imagem reutilizável que possas usar 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. Este método é útil quando quiseres fazer uma cópia de segurança ou usar a mesma configuração de disco noutra 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

Pode criar uma máquina virtual com um disco gerido criado implicitamente com base numa imagem de disco específica, pelo que não precisa de definir manualmente todos os detalhes do disco.

Implicitamente crias um Disco Gerido quando crias uma VM a partir de uma imagem do sistema operativo 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 um exemplo completo que mostra como criar uma máquina virtual usando as bibliotecas de gestão do Azure para Python, veja 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 Managed Disks do Azure, já não precisa de gerir contas de armazenamento. Como resultado, o storage_profile para Conjuntos de Dimensionamento de Máquinas Virtuais pode agora corresponder ao usado para criação individual de VM:

'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. Esta mudança é útil quando precisa de mais espaço para os seus dados ou aplicações.

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. Esta mudança é útil quando precisa de mais espaço ou melhor desempenho para os seus dados ou aplicações.

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 gerida a partir de um ficheiro VHD armazenado no Armazenamento de Blobs do Azure. Este método é útil quando queres criar uma imagem reutilizável que possas 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()

Crie um snapshot de um disco gerido que esteja atualmente ligado a uma máquina virtual

Este exemplo mostra como tirar um snapshot de um disco gerido que está ligado 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 2026-06-18