Utiliser des disques managés Azure avec les bibliothèques Azure (SDK) pour Python

Les disques managés Azure sont un stockage de blocs performant et durable conçu pour une utilisation avec des machines virtuelles Azure et Azure VMware Solution. Ils simplifient la gestion des disques, offrent une plus grande scalabilité, améliorent la sécurité et éliminent la nécessité de gérer directement les comptes de stockage. Pour plus d’informations, consultez Disques managés Azure.

Pour les opérations sur les disques managés associés à une machine virtuelle existante, utilisez la azure-mgmt-compute bibliothèque.

Les exemples de code de cet article illustrent les opérations courantes avec disques managés à l’aide de la azure-mgmt-compute bibliothèque. Ces exemples ne sont pas destinés à être exécutés en tant que scripts autonomes, mais plutôt à être intégrés dans votre propre code. Pour savoir comment créer une ComputeManagementClient instance à partir de azure.mgmt.compute votre script, consultez l’exemple - Créer une machine virtuelle.

Pour obtenir des exemples plus complets d’utilisation de la azure-mgmt-compute bibliothèque, consultez les exemples du Kit de développement logiciel (SDK) Azure pour Python pour le calcul dans GitHub.

Disques managés autonomes

Les exemples suivants montrent différentes façons de provisionner des disques managés autonomes.

Créer un disque managé vide

Cet exemple montre comment créer un disque managé vide. Vous pouvez l’utiliser comme disque vide pour l’attacher à une machine virtuelle ou comme point de départ pour créer des instantanés ou des images.

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

Créer un disque géré à partir du stockage blob

Cet exemple montre comment créer un disque géré à partir d'un fichier VHD stocké dans Azure Blob Storage. Cela est utile lorsque vous souhaitez réutiliser ou déplacer un disque dur virtuel existant vers 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()

Créer une image de disque managé à partir du blob storage

Cet exemple montre comment créer une image de disque géré à partir d’un fichier VHD stocké dans Azure Blob Storage. Cela est utile lorsque vous souhaitez créer une image réutilisable qui peut être utilisée pour créer de nouvelles machines virtuelles.

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

Créer un disque managé à partir de votre propre image

Cet exemple montre comment créer un disque managé en copiant un disque existant. Cela est utile lorsque vous souhaitez effectuer une sauvegarde ou utiliser la même configuration de disque sur une autre machine virtuelle.

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

Machine virtuelle avec disques managés

Vous pouvez créer une machine virtuelle avec un disque managé créé implicitement en fonction d’une image de disque spécifique, ce qui élimine la nécessité de définir manuellement tous les détails du disque.

Un disque managé est créé implicitement lors de la création d’une machine virtuelle à partir d’une image de système d’exploitation dans Azure. Azure gère automatiquement le compte de stockage. Vous n’avez donc pas besoin de spécifier storage_profile.os_disk ou de créer manuellement un compte de stockage.

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

Pour obtenir un exemple complet montrant comment créer une machine virtuelle à l’aide des bibliothèques de gestion Azure pour Python, consultez l’exemple - Créer une machine virtuelle. Cet exemple montre comment utiliser le storage_profile paramètre.

Vous pouvez également créer une storage_profile image à partir de votre propre image :

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

Vous pouvez facilement attacher un disque managé précédemment approvisionné :

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

Groupes de machines virtuelles avec disques gérés

Avant les disques managés Azure, vous deviez créer manuellement un compte de stockage pour chaque machine virtuelle de votre ensemble à échelle de machines virtuelles et utiliser le paramètre vhd_containers pour spécifier ces comptes de stockage dans l’API REST de l’ensemble à échelle.

Avec les disques managés Azure, la gestion des comptes de stockage n’est plus nécessaire. Par conséquent, les storage_profile pour les Virtual Machine Scale Sets utilisés pour les Virtual Machine Scale Sets peuvent désormais correspondre à celui utilisé pour la création d’une machine virtuelle individuelle :

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

L’exemple complet est le suivant :

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

Autres opérations avec disques managés

Redimensionnement d’un disque managé

Cet exemple montre comment agrandir un disque managé existant. Cela est utile lorsque vous avez besoin d’un espace supplémentaire pour vos données ou applications.

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

Mettre à jour le type de compte de stockage des disques managés

Cet exemple montre comment modifier le type de stockage d’un disque managé et le rendre plus grand. Cela est utile lorsque vous avez besoin de plus d’espace ou de meilleures performances pour vos données ou applications.

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

Créer une image à partir du stockage blob

Cet exemple montre comment créer une image de disque géré à partir d’un fichier VHD stocké dans Azure Blob Storage. Cela est utile lorsque vous souhaitez créer une image réutilisable que vous pouvez utiliser pour créer de nouvelles machines virtuelles.

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

Créer un instantané d’un disque managé actuellement attaché à une machine virtuelle

Cet exemple montre comment prendre un instantané d’un disque managé attaché à une machine virtuelle. Vous pouvez utiliser l’instantané pour sauvegarder le disque ou le restaurer ultérieurement si nécessaire.

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

Voir aussi

• Exemple : Créer une machine virtuelle
• Exemple : Créer un groupe de ressources
• Exemple : répertorier les groupes de ressources dans un abonnement
• Exemple : Créer un stockage Azure
• Exemple : utiliser le stockage Azure
• Exemple : Créer et utiliser une base de données MySQL
• Effectuer une courte enquête sur le Kit de développement logiciel (SDK) Azure pour Python