in src/azure-cli/azure/cli/command_modules/vm/_template_builder.py [0:0]
def build_vmss_resource(cmd, name, computer_name_prefix, location, tags, overprovision, upgrade_policy_mode,
vm_sku, instance_count, ip_config_name, nic_name, subnet_id,
public_ip_per_vm, vm_domain_name, dns_servers, nsg, accelerated_networking,
admin_username, authentication_type, storage_profile, os_disk_name, disk_info,
os_type, image=None, admin_password=None, ssh_key_values=None,
ssh_key_path=None, os_publisher=None, os_offer=None, os_sku=None, os_version=None,
backend_address_pool_id=None, inbound_nat_pool_id=None, health_probe=None,
single_placement_group=None, platform_fault_domain_count=None, custom_data=None,
secrets=None, license_type=None, zones=None, priority=None, eviction_policy=None,
application_security_groups=None, ultra_ssd_enabled=None, proximity_placement_group=None,
terminate_notification_time=None, max_price=None, scale_in_policy=None,
os_disk_encryption_set=None, data_disk_encryption_sets=None,
data_disk_iops=None, data_disk_mbps=None, automatic_repairs_grace_period=None,
specialized=None, os_disk_size_gb=None, encryption_at_host=None, host_group=None,
max_batch_instance_percent=None, max_unhealthy_instance_percent=None,
max_unhealthy_upgraded_instance_percent=None, pause_time_between_batches=None,
enable_cross_zone_upgrade=None, prioritize_unhealthy_instances=None, edge_zone=None,
orchestration_mode=None, user_data=None, network_api_version=None,
enable_spot_restore=None, spot_restore_timeout=None, capacity_reservation_group=None,
enable_auto_update=None, patch_mode=None, enable_agent=None, security_type=None,
enable_secure_boot=None, enable_vtpm=None, automatic_repairs_action=None, v_cpus_available=None,
v_cpus_per_core=None, os_disk_security_encryption_type=None,
os_disk_secure_vm_disk_encryption_set=None, os_disk_delete_option=None,
regular_priority_count=None, regular_priority_percentage=None, disk_controller_type=None,
enable_osimage_notification=None, max_surge=None, enable_hibernation=None,
enable_auto_os_upgrade=None, enable_proxy_agent=None, proxy_agent_mode=None,
security_posture_reference_id=None, security_posture_reference_exclude_extensions=None,
enable_resilient_vm_creation=None, enable_resilient_vm_deletion=None,
additional_scheduled_events=None, enable_user_reboot_scheduled_events=None,
enable_user_redeploy_scheduled_events=None, skuprofile_vmsizes=None, skuprofile_allostrat=None,
security_posture_reference_is_overridable=None, zone_balance=None, wire_server_mode=None,
imds_mode=None, wire_server_access_control_profile_reference_id=None,
imds_access_control_profile_reference_id=None, enable_automatic_zone_balancing=None,
automatic_zone_balancing_strategy=None, automatic_zone_balancing_behavior=None):
# Build IP configuration
ip_configuration = {}
ip_config_properties = {}
if subnet_id:
ip_config_properties['subnet'] = {'id': subnet_id}
if public_ip_per_vm:
ip_config_properties['publicipaddressconfiguration'] = {
'name': 'instancepublicip',
'properties': {
'idleTimeoutInMinutes': 10,
}
}
if vm_domain_name:
ip_config_properties['publicipaddressconfiguration']['properties']['dnsSettings'] = {
'domainNameLabel': vm_domain_name
}
if backend_address_pool_id:
key = 'loadBalancerBackendAddressPools' if 'loadBalancers' in backend_address_pool_id \
else 'ApplicationGatewayBackendAddressPools'
ip_config_properties[key] = [
{'id': backend_address_pool_id}
]
if inbound_nat_pool_id:
ip_config_properties['loadBalancerInboundNatPools'] = [
{'id': inbound_nat_pool_id}
]
if application_security_groups and cmd.supported_api_version(min_api='2018-06-01',
operation_group='virtual_machine_scale_sets'):
ip_config_properties['applicationSecurityGroups'] = [{'id': x['id']} for x in application_security_groups]
if ip_config_properties:
ip_configuration = {
'name': ip_config_name,
'properties': ip_config_properties
}
# Build storage profile
storage_properties = {}
if disk_info:
os_caching = disk_info['os'].get('caching')
if storage_profile in [StorageProfile.SACustomImage, StorageProfile.SAPirImage]:
storage_properties['osDisk'] = {
'name': os_disk_name,
'caching': os_caching,
'createOption': 'FromImage',
}
if storage_profile == StorageProfile.SACustomImage:
storage_properties['osDisk'].update({
'osType': os_type,
'image': {
'uri': image
}
})
else:
storage_properties['osDisk']['vhdContainers'] = "[variables('vhdContainers')]"
if os_disk_size_gb is not None:
storage_properties['osDisk']['diskSizeGB'] = os_disk_size_gb
if os_disk_delete_option is not None:
storage_properties['osDisk']['deleteOption'] = os_disk_delete_option
elif storage_profile in [StorageProfile.ManagedPirImage, StorageProfile.ManagedCustomImage]:
storage_properties['osDisk'] = {
'createOption': 'FromImage',
'caching': os_caching,
'managedDisk': {'storageAccountType': disk_info['os'].get('storageAccountType')}
}
if os_disk_encryption_set is not None:
storage_properties['osDisk']['managedDisk']['diskEncryptionSet'] = {
'id': os_disk_encryption_set
}
if os_disk_security_encryption_type is not None:
storage_properties['osDisk']['managedDisk'].update({
'securityProfile': {
'securityEncryptionType': os_disk_security_encryption_type
}
})
if os_disk_secure_vm_disk_encryption_set is not None:
storage_properties['osDisk']['managedDisk']['securityProfile'].update({
'diskEncryptionSet': {
'id': os_disk_secure_vm_disk_encryption_set
}
})
if disk_info and disk_info['os'].get('diffDiskSettings'):
storage_properties['osDisk']['diffDiskSettings'] = disk_info['os']['diffDiskSettings']
if os_disk_size_gb is not None:
storage_properties['osDisk']['diskSizeGB'] = os_disk_size_gb
if os_disk_delete_option is not None:
storage_properties['osDisk']['deleteOption'] = os_disk_delete_option
if storage_profile in [StorageProfile.SAPirImage, StorageProfile.ManagedPirImage]:
storage_properties['imageReference'] = {
'publisher': os_publisher,
'offer': os_offer,
'sku': os_sku,
'version': os_version
}
if storage_profile == StorageProfile.ManagedCustomImage:
storage_properties['imageReference'] = {
'id': image
}
if storage_profile == StorageProfile.SharedGalleryImage:
storage_properties['osDisk'] = {
'caching': os_caching,
'managedDisk': {'storageAccountType': disk_info['os'].get('storageAccountType')},
"name": os_disk_name,
"createOption": "fromImage"
}
storage_properties['imageReference'] = {
'sharedGalleryImageId': image
}
if os_disk_encryption_set is not None:
storage_properties['osDisk']['managedDisk']['diskEncryptionSet'] = {
'id': os_disk_encryption_set
}
if os_disk_security_encryption_type is not None:
storage_properties['osDisk']['managedDisk'].update({
'securityProfile': {
'securityEncryptionType': os_disk_security_encryption_type,
}
})
if os_disk_secure_vm_disk_encryption_set is not None:
storage_properties['osDisk']['managedDisk']['securityProfile'].update({
'diskEncryptionSet': {
'id': os_disk_secure_vm_disk_encryption_set
}
})
if os_disk_delete_option is not None:
storage_properties['osDisk']['deleteOption'] = os_disk_delete_option
if storage_profile == StorageProfile.CommunityGalleryImage:
storage_properties['osDisk'] = {
'caching': os_caching,
'managedDisk': {'storageAccountType': disk_info['os'].get('storageAccountType')},
"name": os_disk_name,
"createOption": "fromImage"
}
storage_properties['imageReference'] = {
'communityGalleryImageId': image
}
if os_disk_encryption_set is not None:
storage_properties['osDisk']['managedDisk']['diskEncryptionSet'] = {
'id': os_disk_encryption_set
}
if os_disk_security_encryption_type is not None:
storage_properties['osDisk']['managedDisk'].update({
'securityProfile': {
'securityEncryptionType': os_disk_security_encryption_type,
}
})
if os_disk_secure_vm_disk_encryption_set is not None:
storage_properties['osDisk']['managedDisk']['securityProfile'].update({
'diskEncryptionSet': {
'id': os_disk_secure_vm_disk_encryption_set
}
})
if os_disk_delete_option is not None:
storage_properties['osDisk']['deleteOption'] = os_disk_delete_option
if disk_info:
data_disks = [v for k, v in disk_info.items() if k != 'os']
else:
data_disks = []
if data_disk_encryption_sets:
if len(data_disk_encryption_sets) != len(data_disks):
raise CLIError(
'usage error: Number of --data-disk-encryption-sets mismatches with number of data disks.')
for i, data_disk in enumerate(data_disks):
data_disk['managedDisk']['diskEncryptionSet'] = {'id': data_disk_encryption_sets[i]}
if data_disk_iops:
if len(data_disk_iops) != len(data_disks):
raise CLIError('usage error: Number of --data-disk-iops mismatches with number of data disks.')
for i, data_disk in enumerate(data_disks):
data_disk['diskIOPSReadWrite'] = data_disk_iops[i]
if data_disk_mbps:
if len(data_disk_mbps) != len(data_disks):
raise CLIError('usage error: Number of --data-disk-mbps mismatches with number of data disks.')
for i, data_disk in enumerate(data_disks):
data_disk['diskMBpsReadWrite'] = data_disk_mbps[i]
if data_disks:
storage_properties['dataDisks'] = data_disks
if disk_controller_type is not None:
storage_properties['diskControllerType'] = disk_controller_type
# Build OS Profile
os_profile = {}
if computer_name_prefix:
os_profile['computerNamePrefix'] = computer_name_prefix
if admin_username:
os_profile['adminUsername'] = admin_username
if admin_password:
os_profile['adminPassword'] = "[parameters('adminPassword')]"
if ssh_key_values and ssh_key_path:
os_profile['linuxConfiguration'] = {
'disablePasswordAuthentication': authentication_type == 'ssh',
'ssh': {
'publicKeys': [
{
'path': ssh_key_path,
'keyData': ssh_key_value
} for ssh_key_value in ssh_key_values
]
}
}
if custom_data:
os_profile['customData'] = b64encode(custom_data)
if secrets:
os_profile['secrets'] = secrets
if enable_agent is not None:
if os_type.lower() == 'linux':
if 'linuxConfiguration' not in os_profile:
os_profile['linuxConfiguration'] = {}
os_profile['linuxConfiguration']['provisionVMAgent'] = enable_agent
elif os_type.lower() == 'windows':
if 'windowsConfiguration' not in os_profile:
os_profile['windowsConfiguration'] = {}
os_profile['windowsConfiguration']['provisionVMAgent'] = enable_agent
if enable_auto_update is not None and os_type.lower() == 'windows':
os_profile['windowsConfiguration']['enableAutomaticUpdates'] = enable_auto_update
# Windows patch settings
if patch_mode is not None and os_type.lower() == 'windows':
if patch_mode.lower() not in ['automaticbyos', 'automaticbyplatform', 'manual']:
raise InvalidArgumentValueError(
'Invalid value of --patch-mode for Windows VMSS. Valid values are AutomaticByOS, '
'AutomaticByPlatform, Manual.')
os_profile['windowsConfiguration']['patchSettings'] = {
'patchMode': patch_mode
}
# Linux patch settings
if patch_mode is not None and os_type.lower() == 'linux':
if patch_mode.lower() not in ['automaticbyplatform', 'imagedefault']:
raise InvalidArgumentValueError(
'Invalid value of --patch-mode for Linux VMSS. Valid values are AutomaticByPlatform, ImageDefault.')
os_profile['linuxConfiguration']['patchSettings'] = {
'patchMode': patch_mode
}
# Build VMSS
nic_config = {}
nic_config_properties = {}
if ip_configuration:
nic_config_properties['ipConfigurations'] = [ip_configuration]
if cmd.supported_api_version(min_api='2017-03-30', operation_group='virtual_machine_scale_sets'):
if dns_servers:
nic_config_properties['dnsSettings'] = {'dnsServers': dns_servers}
if accelerated_networking:
nic_config_properties['enableAcceleratedNetworking'] = True
if nsg:
nic_config_properties['networkSecurityGroup'] = {'id': nsg}
if nic_config_properties:
nic_config_properties['primary'] = 'true'
nic_config = {
'name': nic_name,
'properties': nic_config_properties
}
vmss_properties = {}
network_profile = {}
virtual_machine_profile = {}
if nic_config:
network_profile['networkInterfaceConfigurations'] = [nic_config]
if overprovision is not None:
vmss_properties['overprovision'] = overprovision
if storage_properties:
virtual_machine_profile['storageProfile'] = storage_properties
hardware_profile = {}
vm_size_properties = {}
if v_cpus_available is not None:
vm_size_properties['vCPUsAvailable'] = v_cpus_available
if v_cpus_per_core is not None:
vm_size_properties['vCPUsPerCore'] = v_cpus_per_core
if vm_size_properties:
hardware_profile['vmSizeProperties'] = vm_size_properties
if hardware_profile:
virtual_machine_profile['hardwareProfile'] = hardware_profile
if not specialized and os_profile:
virtual_machine_profile['osProfile'] = os_profile
if upgrade_policy_mode:
vmss_properties['upgradePolicy'] = {
'mode': upgrade_policy_mode
}
if upgrade_policy_mode and cmd.supported_api_version(min_api='2020-12-01',
operation_group='virtual_machine_scale_sets'):
rolling_upgrade_policy = {}
if max_batch_instance_percent is not None:
rolling_upgrade_policy['maxBatchInstancePercent'] = max_batch_instance_percent
if max_unhealthy_instance_percent is not None:
rolling_upgrade_policy['maxUnhealthyInstancePercent'] = max_unhealthy_instance_percent
if max_unhealthy_upgraded_instance_percent is not None:
rolling_upgrade_policy['maxUnhealthyUpgradedInstancePercent'] = max_unhealthy_upgraded_instance_percent
if pause_time_between_batches is not None:
rolling_upgrade_policy['pauseTimeBetweenBatches'] = pause_time_between_batches
if enable_cross_zone_upgrade is not None:
rolling_upgrade_policy['enableCrossZoneUpgrade'] = enable_cross_zone_upgrade
if prioritize_unhealthy_instances is not None:
rolling_upgrade_policy['prioritizeUnhealthyInstances'] = prioritize_unhealthy_instances
if max_surge is not None:
rolling_upgrade_policy['maxSurge'] = max_surge
if rolling_upgrade_policy:
vmss_properties['upgradePolicy']['rollingUpgradePolicy'] = rolling_upgrade_policy
if upgrade_policy_mode and cmd.supported_api_version(min_api='2018-10-01',
operation_group='virtual_machine_scale_sets'):
automatic_os_upgrade_policy = {}
if enable_auto_os_upgrade is not None:
automatic_os_upgrade_policy['enableAutomaticOSUpgrade'] = enable_auto_os_upgrade
if automatic_os_upgrade_policy:
vmss_properties['upgradePolicy']['automaticOSUpgradePolicy'] = automatic_os_upgrade_policy
if upgrade_policy_mode and upgrade_policy_mode.lower() == 'rolling' and\
cmd.supported_api_version(min_api='2020-12-01', operation_group='virtual_machine_scale_sets'):
if os_type.lower() == 'linux':
from azure.cli.command_modules.vm._vmss_application_health import application_health_setting_for_linux
application_health_data = application_health_setting_for_linux
health_extension_name = 'ApplicationHealthLinux'
else:
from azure.cli.command_modules.vm._vmss_application_health import application_health_setting_for_windows
application_health_data = application_health_setting_for_windows
health_extension_name = 'ApplicationHealthWindows'
health_extension = [{
"name": health_extension_name,
"properties": {
"publisher": "Microsoft.ManagedServices",
"type": health_extension_name,
"typeHandlerVersion": "1.0",
"autoUpgradeMinorVersion": True,
"settings": {
"port": 80,
"protocol": "http",
"requestPath": "/"
}
}
}]
virtual_machine_profile['extensionProfile'] = {
'extensions': health_extension
}
os_profile['customData'] = b64encode(application_health_data)
if enable_spot_restore and cmd.supported_api_version(min_api='2021-04-01',
operation_group='virtual_machine_scale_sets'):
vmss_properties['spotRestorePolicy'] = {}
if enable_spot_restore:
vmss_properties['spotRestorePolicy']['enabled'] = enable_spot_restore
if spot_restore_timeout:
vmss_properties['spotRestorePolicy']['restoreTimeout'] = spot_restore_timeout
if regular_priority_count is not None or regular_priority_percentage is not None:
priority_mix_policy = {}
if regular_priority_count is not None:
priority_mix_policy['baseRegularPriorityCount'] = regular_priority_count
if regular_priority_percentage is not None:
priority_mix_policy['regularPriorityPercentageAboveBase'] = regular_priority_percentage
vmss_properties['priorityMixPolicy'] = priority_mix_policy
if license_type:
virtual_machine_profile['licenseType'] = license_type
if health_probe and cmd.supported_api_version(min_api='2017-03-30', operation_group='virtual_machine_scale_sets'):
network_profile['healthProbe'] = {'id': health_probe}
if network_api_version and \
cmd.supported_api_version(min_api='2021-03-01', operation_group='virtual_machine_scale_sets'):
network_profile['networkApiVersion'] = network_api_version
if cmd.supported_api_version(min_api='2016-04-30-preview', operation_group='virtual_machine_scale_sets'):
vmss_properties['singlePlacementGroup'] = single_placement_group
if priority and cmd.supported_api_version(min_api='2017-12-01', operation_group='virtual_machine_scale_sets'):
virtual_machine_profile['priority'] = priority
if eviction_policy and cmd.supported_api_version(min_api='2017-12-01',
operation_group='virtual_machine_scale_sets'):
virtual_machine_profile['evictionPolicy'] = eviction_policy
if max_price is not None and cmd.supported_api_version(
min_api='2019-03-01', operation_group='virtual_machine_scale_sets'):
virtual_machine_profile['billingProfile'] = {'maxPrice': max_price}
if platform_fault_domain_count is not None and cmd.supported_api_version(
min_api='2017-12-01', operation_group='virtual_machine_scale_sets'):
vmss_properties['platformFaultDomainCount'] = platform_fault_domain_count
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}
else:
virtual_machine_profile['additionalCapabilities'] = {'ultraSSDEnabled': ultra_ssd_enabled}
if proximity_placement_group:
vmss_properties['proximityPlacementGroup'] = {'id': proximity_placement_group}
if zone_balance is not None:
vmss_properties['zoneBalance'] = zone_balance
scheduled_events_profile = {}
if terminate_notification_time is not None:
scheduled_events_profile.update({
'terminateNotificationProfile': {
'notBeforeTimeout': terminate_notification_time,
'enable': 'true'
}
})
virtual_machine_profile['scheduledEventsProfile'] = scheduled_events_profile
if enable_osimage_notification is not None:
scheduled_events_profile.update({
'osImageNotificationProfile': {
'enable': enable_osimage_notification
}
})
virtual_machine_profile['scheduledEventsProfile'] = scheduled_events_profile
scheduled_events_policy = {}
if additional_scheduled_events is not None:
scheduled_events_policy.update({
"scheduledEventsAdditionalPublishingTargets": {
"eventGridAndResourceGraph": {
"enable": additional_scheduled_events
}
}
})
if enable_user_redeploy_scheduled_events is not None:
scheduled_events_policy.update({
"userInitiatedRedeploy": {
"automaticallyApprove": enable_user_redeploy_scheduled_events
}
})
if enable_user_reboot_scheduled_events is not None:
scheduled_events_policy.update({
"userInitiatedReboot": {
"automaticallyApprove": enable_user_reboot_scheduled_events
}
})
if scheduled_events_policy:
vmss_properties['scheduledEventsPolicy'] = scheduled_events_policy
if automatic_repairs_grace_period is not None or automatic_repairs_action is not None:
automatic_repairs_policy = {
'enabled': 'true',
'gracePeriod': automatic_repairs_grace_period or 'PT10M',
'repairAction': automatic_repairs_action or 'Replace'
}
vmss_properties['automaticRepairsPolicy'] = automatic_repairs_policy
if scale_in_policy:
vmss_properties['scaleInPolicy'] = {'rules': scale_in_policy}
resiliency_policy = {}
if enable_resilient_vm_creation is not None:
resiliency_policy['resilientVMCreationPolicy'] = {'enabled': enable_resilient_vm_creation}
if enable_resilient_vm_deletion is not None:
resiliency_policy['resilientVMDeletionPolicy'] = {'enabled': enable_resilient_vm_deletion}
automatic_zone_rebalancing_policy = {}
if enable_automatic_zone_balancing is not None:
automatic_zone_rebalancing_policy['enabled'] = enable_automatic_zone_balancing
if automatic_zone_balancing_strategy is not None:
automatic_zone_rebalancing_policy['rebalanceStrategy'] = automatic_zone_balancing_strategy
if automatic_zone_balancing_behavior is not None:
automatic_zone_rebalancing_policy['rebalanceBehavior'] = automatic_zone_balancing_behavior
if automatic_zone_rebalancing_policy:
resiliency_policy['automaticZoneRebalancingPolicy'] = automatic_zone_rebalancing_policy
if resiliency_policy:
vmss_properties['resiliencyPolicy'] = resiliency_policy
security_profile = {}
if encryption_at_host:
security_profile['encryptionAtHost'] = encryption_at_host
# The `Standard` is used for backward compatibility to allow customers to keep their current behavior
# after changing the default values to Trusted Launch VMs in the future.
if security_type is not None:
security_profile['securityType'] = security_type
from ._constants import COMPATIBLE_SECURITY_TYPE_VALUE
if security_type != COMPATIBLE_SECURITY_TYPE_VALUE and (
enable_secure_boot is not None or enable_vtpm is not None):
security_profile['uefiSettings'] = {
'secureBootEnabled': enable_secure_boot,
'vTpmEnabled': enable_vtpm
}
proxy_agent_settings = {}
wire_server = {}
imds = {}
if enable_proxy_agent is not None:
proxy_agent_settings['enabled'] = enable_proxy_agent
if proxy_agent_mode is not None:
proxy_agent_settings['mode'] = proxy_agent_mode
if wire_server_mode is not None or wire_server_access_control_profile_reference_id is not None:
wire_server['mode'] = wire_server_mode
wire_server['inVMAccessControlProfileReferenceId'] = wire_server_access_control_profile_reference_id
if imds_mode is not None or imds_access_control_profile_reference_id is not None:
imds['mode'] = imds_mode
imds['inVMAccessControlProfileReferenceId'] = imds_access_control_profile_reference_id
if wire_server:
proxy_agent_settings['wireServer'] = wire_server
if imds:
proxy_agent_settings['imds'] = imds
if proxy_agent_settings:
security_profile['proxyAgentSettings'] = proxy_agent_settings
if security_profile:
virtual_machine_profile['securityProfile'] = security_profile
if user_data:
virtual_machine_profile['userData'] = b64encode(user_data)
if host_group:
vmss_properties['hostGroup'] = {'id': host_group}
if network_profile:
virtual_machine_profile['networkProfile'] = network_profile
if capacity_reservation_group:
virtual_machine_profile['capacityReservation'] = {
'capacityReservationGroup': {
'id': capacity_reservation_group
}
}
if security_posture_reference_id:
virtual_machine_profile['securityPostureReference'] = {
'id': security_posture_reference_id,
}
if security_posture_reference_exclude_extensions:
security_posture_reference = virtual_machine_profile.get('securityPostureReference', {})
security_posture_reference['excludeExtensions'] = security_posture_reference_exclude_extensions
virtual_machine_profile['securityPostureReference'] = security_posture_reference
if security_posture_reference_is_overridable is not None:
security_posture_reference = virtual_machine_profile.get('securityPostureReference', {})
security_posture_reference['isOverridable'] = security_posture_reference_is_overridable
virtual_machine_profile['securityPostureReference'] = security_posture_reference
if virtual_machine_profile:
vmss_properties['virtualMachineProfile'] = virtual_machine_profile
if orchestration_mode and cmd.supported_api_version(min_api='2020-06-01',
operation_group='virtual_machine_scale_sets'):
vmss_properties['orchestrationMode'] = orchestration_mode
if enable_hibernation is not None:
if not vmss_properties.get('additionalCapabilities'):
vmss_properties['additionalCapabilities'] = {}
vmss_properties['additionalCapabilities']['hibernationEnabled'] = enable_hibernation
if skuprofile_vmsizes:
sku_profile_vmsizes_list = []
for vm_size in skuprofile_vmsizes:
vmsize_obj = {
'name': vm_size
}
sku_profile_vmsizes_list.append(vmsize_obj)
sku_profile = {
'vmSizes': sku_profile_vmsizes_list,
'allocationStrategy': skuprofile_allostrat
}
vmss_properties['skuProfile'] = sku_profile
vmss = {
'type': 'Microsoft.Compute/virtualMachineScaleSets',
'name': name,
'location': location,
'tags': tags,
'apiVersion': cmd.get_api_version(ResourceType.MGMT_COMPUTE, operation_group='virtual_machine_scale_sets'),
'dependsOn': [],
'properties': vmss_properties
}
if vm_sku:
vmss['sku'] = {
'name': vm_sku,
'capacity': instance_count
}
if vmss_properties:
vmss['properties'] = vmss_properties
if zones:
vmss['zones'] = zones
if edge_zone:
vmss['extendedLocation'] = edge_zone
return vmss