Merge branch 'dev' into agent-assist/azure-azure-cli-issue-34063-338c19fac314

Author: x-engineering-agent[bot]

src/azure-cli/azure/cli/command_modules/vm/_help.py

@@ -1121,6 +1121,12 @@
         az vm create -n MyVm -g MyResourceGroup --public-ip-address-dns-name MyUniqueDnsName \\
             --image Ubuntu2204 --data-disk-sizes-gb 10 20 --size Standard_DS2_v2 \\
             --generate-ssh-keys
+  - name: Create a VM in a single-zone Flexible VMSS with aligned OS and data disks.
+    text: |
+        az vm create -g MyResourceGroup -n MyVm --location eastus2 --vmss MyFlexibleVmss \\
+            --platform-fault-domain 0 --image Ubuntu2204 --size Standard_D4s_v5 \\
+            --data-disk-sizes-gb 10 --os-disk-storage-fd-alignment Aligned \\
+            --data-disk-storage-fd-alignment BestEffortAligned
   - name: Create a Debian11 VM using Key Vault secrets.
     text: >
         az keyvault certificate create --vault-name vaultname -n cert1 \\
@@ -2297,6 +2303,14 @@
     supported-profiles: latest
     text: >
         az vmss create -n MyVmss -g MyResourceGroup --image CentOS85Gen2 --zones 1
+  - name: Create a single-zone Flexible VMSS with aligned compute and storage fault domains.
+    text: |
+        az vmss create -g MyResourceGroup -n MyVmss --location eastus2 --zones 1 \\
+            --orchestration-mode Flexible --platform-fault-domain-count 3 \\
+            --zonal-fault-domain-align-mode BestEffortAligned \\
+            --os-disk-storage-fd-alignment Aligned --data-disk-sizes-gb 10 \\
+            --data-disk-storage-fd-alignment BestEffortAligned \\
+            --image Ubuntu2204 --vm-sku Standard_D4s_v5
   - name: Create a VMSS that supports SpotRestore.
     text: >
         az vmss create -n MyVmss -g MyResourceGroup  --location NorthEurope --instance-count 2 --image CentOS85Gen2 --priority Spot --eviction-policy Deallocate --single-placement-group --enable-spot-restore True --spot-restore-timeout PT1H

src/azure-cli/azure/cli/command_modules/vm/_params.py

@@ -24,7 +24,8 @@
     validate_asg_names_or_ids, validate_keyvault, _validate_proximity_placement_group,
     validate_vm_name_for_monitor_metrics)
 
-from azure.cli.command_modules.vm._vm_utils import MSI_LOCAL_ID, CachingTypes, UpgradeMode
+from azure.cli.command_modules.vm._vm_utils import (MSI_LOCAL_ID, CachingTypes, UpgradeMode, DiskStorageAlignment,
+                                                    FaultDomainAlignment)
 from azure.cli.command_modules.vm._image_builder import ScriptType
 
 from azure.cli.command_modules.monitor.validators import validate_metric_dimension
@@ -515,6 +516,24 @@ def load_arguments(self, _):
         c.argument('source_snapshots_or_disks_size_gb', options_list=['--source-snapshots-or-disks-size-gb', '--source-resource-size'], nargs='+', type=int, help='The size of the source disk in GB')
         c.argument('source_disk_restore_point', options_list=['--source-disk-restore-point', '--source-disk-rp'], nargs='+', help='create a data disk from a disk restore point. Can use the ID of a disk restore point.')
         c.argument('source_disk_restore_point_size_gb', options_list=['--source-disk-restore-point-size-gb', '--source-rp-size'], nargs='+', type=int, help='The size of the source disk restore point in GB')
+        c.argument(
+            'data_disk_storage_fault_domain_alignment',
+            options_list=['--data-disk-storage-fd-alignment', '--data-disk-fda'],
+            arg_type=get_enum_type(DiskStorageAlignment),
+            is_preview=True,
+            help='Specifies the storage fault domain alignment type for data disks. This option is only valid when '
+                 'the VM joins a single-zone Flexible VMSS and is set at create time. Omit this option to leave '
+                 'data disks unaligned.'
+        )
+        c.argument(
+            'os_disk_storage_fault_domain_alignment',
+            options_list=['--os-disk-storage-fd-alignment', '--os-disk-fda'],
+            arg_type=get_enum_type(DiskStorageAlignment),
+            is_preview=True,
+            help='Specifies the storage fault domain alignment type for the OS disk. This option is only valid when '
+                 'the VM joins a single-zone Flexible VMSS and is set at create time. Omit this option to leave '
+                 'the OS disk unaligned.'
+        )
 
     with self.argument_context('vm create', arg_group='Dedicated Host', min_api='2019-03-01') as c:
         c.argument('dedicated_host_group', options_list=['--host-group'], is_preview=True, help="Name or resource ID of the dedicated host group that the VM will reside in. --host and --host-group can't be used together.")
@@ -845,6 +864,32 @@ def load_arguments(self, _):
                  'to a single availability zone in the virtual machine scale set. '
                  'Valid values are integers between 1 and 100.'
         )
+        c.argument(
+            'data_disk_storage_fault_domain_alignment',
+            options_list=['--data-disk-storage-fd-alignment', '--data-disk-fda'],
+            arg_type=get_enum_type(DiskStorageAlignment),
+            is_preview=True,
+            help='Specifies the storage fault domain alignment type for data disks. This option is only valid for '
+                 'a single-zone Flexible VMSS and is set at create time. Omit this option to leave data disks '
+                 'unaligned.'
+        )
+        c.argument(
+            'os_disk_storage_fault_domain_alignment',
+            options_list=['--os-disk-storage-fd-alignment', '--os-disk-fda'],
+            arg_type=get_enum_type(DiskStorageAlignment),
+            is_preview=True,
+            help='Specifies the storage fault domain alignment type for the OS disk. This option is only valid for '
+                 'a single-zone Flexible VMSS and is set at create time. Omit this option to leave the OS disk '
+                 'unaligned.'
+        )
+        c.argument(
+            'zonal_platform_fault_domain_align_mode',
+            options_list=['--zonal-fault-domain-align-mode', '--zonal-fda'],
+            arg_type=get_enum_type(FaultDomainAlignment),
+            is_preview=True,
+            help='Specifies the alignment mode between Virtual Machine Scale Set compute and storage fault domains. '
+                 'This option is only valid for a single-zone Flexible VMSS.'
+        )
 
     with self.argument_context('vmss create', arg_group='Network Balancer') as c:
         c.argument('application_gateway', help='Name to use when creating a new application gateway (default) or referencing an existing one. Can also reference an existing application gateway by ID or specify "" for none.', options_list=['--app-gateway'])

src/azure-cli/azure/cli/command_modules/vm/_template_builder.py

@@ -324,7 +324,8 @@ def build_vm_resource(  # pylint: disable=too-many-locals, too-many-statements,
         wire_server_mode=None, wire_server_use_local_file_rules=None, imds_mode=None,
         wire_server_access_control_profile_reference_id=None,
         imds_access_control_profile_reference_id=None, key_incarnation_id=None, add_proxy_agent_extension=None,
-        disk_iops_read_write=None, disk_mbps_read_write=None, zone_movement=None):
+        disk_iops_read_write=None, disk_mbps_read_write=None, zone_movement=None,
+        os_disk_storage_fault_domain_alignment=None, data_disk_storage_fault_domain_alignment=None):
 
     os_caching = disk_info['os'].get('caching')
 
@@ -572,6 +573,8 @@ def _build_storage_profile():
             profile['osDisk']['writeAcceleratorEnabled'] = disk_info['os']['writeAcceleratorEnabled']
         if os_disk_delete_option is not None:
             profile['osDisk']['deleteOption'] = os_disk_delete_option
+        if os_disk_storage_fault_domain_alignment is not None:
+            profile['osDisk']['storageFaultDomainAlignment'] = os_disk_storage_fault_domain_alignment
         data_disks = [v for k, v in disk_info.items() if k != 'os']
         if data_disk_encryption_sets:
             if len(data_disk_encryption_sets) != len(data_disks):
@@ -586,6 +589,8 @@ def _build_storage_profile():
                     data_disk['diskIOPSReadWrite'] = disk_iops_read_write
                 if disk_mbps_read_write is not None:
                     data_disk['diskMBPSReadWrite'] = disk_mbps_read_write
+                if data_disk_storage_fault_domain_alignment is not None:
+                    data_disk['storageFaultDomainAlignment'] = data_disk_storage_fault_domain_alignment
         if disk_info['os'].get('diffDiskSettings'):
             profile['osDisk']['diffDiskSettings'] = disk_info['os']['diffDiskSettings']
 
@@ -1092,7 +1097,8 @@ def build_vmss_resource(cmd, name, computer_name_prefix, location, tags, overpro
                         automatic_zone_balancing_strategy=None, automatic_zone_balancing_behavior=None,
                         enable_automatic_repairs=None, zone_placement_policy=None, include_zones=None,
                         exclude_zones=None, max_zone_count=None, instance_percent_policy=None,
-                        max_instance_percent=None):
+                        max_instance_percent=None, data_disk_storage_fault_domain_alignment=None,
+                        os_disk_storage_fault_domain_alignment=None, zonal_platform_fault_domain_align_mode=None):
 
     # Build IP configuration
     ip_configuration = {}
@@ -1286,6 +1292,13 @@ def build_vmss_resource(cmd, name, computer_name_prefix, location, tags, overpro
     if disk_controller_type is not None:
         storage_properties['diskControllerType'] = disk_controller_type
 
+    # Aligned Zonal Fault Domains: per-disk storage fault domain alignment overrides.
+    if os_disk_storage_fault_domain_alignment is not None and 'osDisk' in storage_properties:
+        storage_properties['osDisk']['storageFaultDomainAlignment'] = os_disk_storage_fault_domain_alignment
+    if data_disk_storage_fault_domain_alignment is not None and storage_properties.get('dataDisks'):
+        for data_disk in storage_properties['dataDisks']:
+            data_disk['storageFaultDomainAlignment'] = data_disk_storage_fault_domain_alignment
+
     # Build OS Profile
     os_profile = {}
     if computer_name_prefix:
@@ -1518,6 +1531,9 @@ def build_vmss_resource(cmd, name, computer_name_prefix, location, tags, overpro
             min_api='2017-12-01', operation_group='virtual_machine_scale_sets'):
         vmss_properties['platformFaultDomainCount'] = platform_fault_domain_count
 
+    if zonal_platform_fault_domain_align_mode is not None:
+        vmss_properties['zonalPlatformFaultDomainAlignMode'] = zonal_platform_fault_domain_align_mode
+
     if ultra_ssd_enabled is not None:
         if cmd.supported_api_version(min_api='2019-03-01', operation_group='virtual_machine_scale_sets'):
             vmss_properties['additionalCapabilities'] = {'ultraSSDEnabled': ultra_ssd_enabled}

src/azure-cli/azure/cli/command_modules/vm/_validators.py

@@ -761,6 +761,68 @@ def _validate_vm_create_availability_set(cmd, namespace):
         logger.debug("adding to specified availability set '%s'", namespace.availability_set)
 
 
+def _validate_vm_create_disk_alignment(cmd, namespace):
+    from .operations.vmss import VMSSShow
+    from azure.mgmt.core.tools import parse_resource_id
+
+    if namespace.data_disk_storage_fault_domain_alignment is None \
+            and namespace.os_disk_storage_fault_domain_alignment is None:
+        return
+
+    if not namespace.vmss:
+        raise ArgumentUsageError('usage error: --data-disk-storage-fd-alignment/ '
+                                 '--os-disk-storage-fd-alignment '
+                                 'is only available for VM in a Flex VMSS.')
+
+    vmss_id = parse_resource_id(namespace.vmss)
+    vmss_show = VMSSShow(cli_ctx=cmd.cli_ctx)(command_args={
+        'resource_group': vmss_id.get('resource_group', namespace.resource_group_name),
+        'vm_scale_set_name': vmss_id['name']
+    })
+
+    if vmss_show.get('orchestrationMode', '').lower() != 'flexible':
+        raise ArgumentUsageError('usage error: --data-disk-storage-fd-alignment/ '
+                                 '--os-disk-storage-fd-alignment '
+                                 'is only available for VM in a Flex VMSS.')
+
+    if len(vmss_show.get('zones', [])) != 1:
+        raise ArgumentUsageError('usage error: --data-disk-storage-fd-alignment/ '
+                                 '--os-disk-storage-fd-alignment '
+                                 'is only available for VM in a single Availability Zone VMSS.')
+
+    _validate_data_disk_alignment(namespace)
+
+
+def _validate_data_disk_alignment(namespace):
+    if namespace.data_disk_storage_fault_domain_alignment is None:
+        return
+
+    data_disks = [disk for name, disk in getattr(namespace, 'disk_info', {}).items() if name != 'os']
+    if not data_disks:
+        raise ArgumentUsageError(
+            'usage error: --data-disk-storage-fd-alignment requires at least one data disk.')
+
+
+def _validate_vmss_create_alignment(namespace):
+    disk_alignment_requested = namespace.data_disk_storage_fault_domain_alignment is not None \
+        or namespace.os_disk_storage_fault_domain_alignment is not None
+    alignment_mode_requested = namespace.zonal_platform_fault_domain_align_mode is not None
+
+    if not disk_alignment_requested and not alignment_mode_requested:
+        return
+
+    if (namespace.orchestration_mode or '').lower() != 'flexible':
+        raise ArgumentUsageError('usage error: --data-disk-storage-fd-alignment/ '
+                                 '--os-disk-storage-fd-alignment/ '
+                                 '--zonal-fault-domain-align-mode '
+                                 'is only available for VMSS with flexible orchestration mode')
+    if not namespace.zones or len(namespace.zones) != 1:
+        raise ArgumentUsageError('usage error: --data-disk-storage-fd-alignment/ '
+                                 '--os-disk-storage-fd-alignment/ '
+                                 '--zonal-fault-domain-align-mode '
+                                 'is only available for VMSS with single Availability Zone')
+
+
 def _validate_vm_create_vmss(cmd, namespace):
     from azure.mgmt.core.tools import parse_resource_id, resource_id
     from azure.cli.core.commands.client_factory import get_subscription_id
@@ -1611,6 +1673,7 @@ def process_vm_create_namespace(cmd, namespace):
 
     _validate_vm_create_availability_set(cmd, namespace)
     _validate_vm_create_vmss(cmd, namespace)
+    _validate_vm_create_disk_alignment(cmd, namespace)
     _validate_vm_vmss_create_vnet(cmd, namespace)
     _validate_vm_create_nsg(cmd, namespace)
     _validate_vm_vmss_create_public_ip(cmd, namespace)
@@ -1802,13 +1865,15 @@ def process_vmss_create_namespace(cmd, namespace):
 
     if namespace.os_disk_delete_option is not None or namespace.data_disk_delete_option is not None:
         if namespace.orchestration_mode.lower() != flexible_str.lower():
-            raise InvalidArgumentValueError('usage error: --os-disk-delete-option/--data-disk-delete-option is only'
-                                            ' available for VMSS with flexible orchestration mode')
+            raise InvalidArgumentValueError('usage error: --os-disk-delete-option/--data-disk-delete-option is only '
+                                            'available for VMSS with flexible orchestration mode')
 
     if namespace.regular_priority_count is not None or namespace.regular_priority_percentage is not None:
         if namespace.orchestration_mode.lower() != flexible_str.lower():
-            raise InvalidArgumentValueError('usage error: --regular-priority-count/--regular-priority-percentage is'
-                                            ' only available for VMSS with flexible orchestration mode')
+            raise InvalidArgumentValueError('usage error: --regular-priority-count/--regular-priority-percentage is '
+                                            'only available for VMSS with flexible orchestration mode')
+
+    _validate_vmss_create_alignment(namespace)
 
     if namespace.orchestration_mode.lower() == flexible_str.lower():
 
@@ -1868,6 +1933,7 @@ def process_vmss_create_namespace(cmd, namespace):
 
         if getattr(namespace, 'attach_os_disk', None) or namespace.image is not None:
             _validate_vm_create_storage_profile(cmd, namespace, for_scale_set=True)
+        _validate_data_disk_alignment(namespace)
 
         if namespace.vnet_name or namespace.subnet or namespace.image:
             _validate_vm_vmss_create_vnet(cmd, namespace, for_scale_set=True)
@@ -1887,7 +1953,7 @@ def process_vmss_create_namespace(cmd, namespace):
                 namespace.authentication_type, namespace.os_type]):
             _validate_vm_vmss_create_auth(namespace, cmd)
         if namespace.assign_identity == '[system]':
-            raise InvalidArgumentValueError('usage error: only user assigned indetity is suppoprted for Flex mode.')
+            raise InvalidArgumentValueError('usage error: only user assigned identity is supported for Flex mode.')
         if namespace.assign_identity is not None:
             _validate_vm_vmss_msi(cmd, namespace)  # -- UserAssignedOnly
         _validate_proximity_placement_group(cmd, namespace)
@@ -1918,6 +1984,7 @@ def process_vmss_create_namespace(cmd, namespace):
     validate_edge_zone(cmd, namespace)
     validate_asg_names_or_ids(cmd, namespace)
     _validate_vm_create_storage_profile(cmd, namespace, for_scale_set=True)
+    _validate_data_disk_alignment(namespace)
     _validate_vm_vmss_create_vnet(cmd, namespace, for_scale_set=True)
 
     _validate_vmss_single_placement_group(namespace)

src/azure-cli/azure/cli/command_modules/vm/_vm_utils.py

@@ -842,3 +842,14 @@ class OrchestrationServiceNames(Enum):
 class OrchestrationServiceStateAction(Enum):
     RESUME = 'Resume'
     SUSPEND = 'Suspend'
+
+
+class DiskStorageAlignment(Enum):
+    ALIGNED = 'Aligned'
+    BEST_EFFORT_ALIGNED = 'BestEffortAligned'
+
+
+class FaultDomainAlignment(Enum):
+    ALIGNED = 'Aligned'
+    BEST_EFFORT_ALIGNED = 'BestEffortAligned'
+    UNALIGNED = 'Unaligned'