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

Artigo
03/14/2024

O Azure Managed Disks é um armazenamento de blocos durável e de elevado desempenho concebido para ser utilizado com as Máquinas Virtuais do Azure e o Azure VMware Solution. Os Managed Disks do Azure fornecem gestão de disco simplificada, escalabilidade melhorada, segurança melhorada e melhor dimensionamento sem ter de trabalhar diretamente com contas de armazenamento. Para obter mais informações, consulte Azure Managed Disks.

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 aprender a 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.

Discos gerenciados autônomos

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

Criar um disco gerenciado 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 disco gerenciado a partir do armazenamento de blob

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

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 disco gerenciado a partir de 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 discos gerenciados

Você pode criar uma máquina virtual com um disco gerenciado implícito para uma imagem de disco específica, o que o isenta de especificar todos os detalhes.

Um Disco Gerenciado é criado implicitamente ao criar uma VM a partir de uma imagem do sistema operacional no Azure. storage_profile No parâmetro, o os_disk é opcional e você não precisa criar uma conta de armazenamento como 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 a storage_profile 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 Managed Disks, você precisava criar uma conta de armazenamento manualmente para todas as VMs desejadas dentro do seu Scale set e, em seguida, usar o parâmetro vhd_containers list para fornecer todo o nome da conta de armazenamento para a Scale set RestAPI.

Como você não precisa gerenciar contas de armazenamento com os Discos Gerenciados do Azure, seus storage_profile Conjuntos de Dimensionamento de Máquina Virtual agora podem ser exatamente os mesmos usados na criação 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

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

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

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

Partilhar via