private VirtualMachineScaleSet CreateVMScaleSetAndGetOperationResponse( string rgName, string vmssName, StorageAccount storageAccount, ImageReference imageRef, out VirtualMachineScaleSet inputVMScaleSet, VirtualMachineScaleSetExtensionProfile extensionProfile = null, Action <VirtualMachineScaleSet> vmScaleSetCustomizer = null, bool createWithPublicIpAddress = false, bool createWithManagedDisks = false, bool hasDiffDisks = false, bool createWithHealthProbe = false, Subnet subnet = null, IList <string> zones = null, int?osDiskSizeInGB = null, string ppgId = null, string machineSizeType = null, bool?enableUltraSSD = false, string diskEncryptionSetId = null, AutomaticRepairsPolicy automaticRepairsPolicy = null, bool?encryptionAtHostEnabled = null, bool singlePlacementGroup = true, DiagnosticsProfile bootDiagnosticsProfile = null, int?faultDomainCount = null, int?capacity = null, string dedicatedHostGroupReferenceId = null, string dedicatedHostGroupName = null, string dedicatedHostName = null, string userData = null, string capacityReservationGroupReferenceId = null, VirtualMachineScaleSetHardwareProfile hardwareProfile = null) { // Create the resource Group, it might have been already created during StorageAccount creation. var resourceGroup = m_ResourcesClient.ResourceGroups.CreateOrUpdate( rgName, new ResourceGroup { Location = m_location }); var getPublicIpAddressResponse = createWithPublicIpAddress ? null : CreatePublicIP(rgName); var subnetResponse = subnet ?? CreateVNET(rgName); var nicResponse = CreateNIC( rgName, subnetResponse, getPublicIpAddressResponse != null ? getPublicIpAddressResponse.IpAddress : null); var loadBalancer = (getPublicIpAddressResponse != null && createWithHealthProbe) ? CreatePublicLoadBalancerWithProbe(rgName, getPublicIpAddressResponse) : null; Assert.True(createWithManagedDisks || storageAccount != null); inputVMScaleSet = CreateDefaultVMScaleSetInput(rgName, storageAccount?.Name, imageRef, subnetResponse.Id, hasManagedDisks: createWithManagedDisks, healthProbeId: loadBalancer?.Probes?.FirstOrDefault()?.Id, loadBalancerBackendPoolId: loadBalancer?.BackendAddressPools?.FirstOrDefault()?.Id, zones: zones, osDiskSizeInGB: osDiskSizeInGB, machineSizeType: machineSizeType, enableUltraSSD: enableUltraSSD, diskEncryptionSetId: diskEncryptionSetId, automaticRepairsPolicy: automaticRepairsPolicy, bootDiagnosticsProfile: bootDiagnosticsProfile, faultDomainCount: faultDomainCount, capacity: capacity, hardwareProfile: hardwareProfile); if (vmScaleSetCustomizer != null) { vmScaleSetCustomizer(inputVMScaleSet); } if (encryptionAtHostEnabled != null) { inputVMScaleSet.VirtualMachineProfile.SecurityProfile = new SecurityProfile { EncryptionAtHost = encryptionAtHostEnabled.Value }; } inputVMScaleSet.VirtualMachineProfile.UserData = userData; if (hasDiffDisks) { VirtualMachineScaleSetOSDisk osDisk = new VirtualMachineScaleSetOSDisk(); osDisk.Caching = CachingTypes.ReadOnly; osDisk.CreateOption = DiskCreateOptionTypes.FromImage; osDisk.DiffDiskSettings = new DiffDiskSettings { Option = DiffDiskOptions.Local, Placement = DiffDiskPlacement.CacheDisk }; inputVMScaleSet.VirtualMachineProfile.StorageProfile.OsDisk = osDisk; } inputVMScaleSet.VirtualMachineProfile.ExtensionProfile = extensionProfile; if (ppgId != null) { inputVMScaleSet.ProximityPlacementGroup = new Microsoft.Azure.Management.Compute.Models.SubResource() { Id = ppgId }; } if (dedicatedHostGroupReferenceId != null) { CreateDedicatedHostGroup(rgName, dedicatedHostGroupName, availabilityZone: null); CreateDedicatedHost(rgName, dedicatedHostGroupName, dedicatedHostName, "DSv3-Type1"); inputVMScaleSet.HostGroup = new CM.SubResource() { Id = dedicatedHostGroupReferenceId }; } if (!string.IsNullOrEmpty(capacityReservationGroupReferenceId)) { inputVMScaleSet.VirtualMachineProfile.CapacityReservation = new CapacityReservationProfile { CapacityReservationGroup = new CM.SubResource { Id = capacityReservationGroupReferenceId } }; } inputVMScaleSet.SinglePlacementGroup = singlePlacementGroup ? (bool?)null : false; VirtualMachineScaleSet createOrUpdateResponse = null; try { createOrUpdateResponse = m_CrpClient.VirtualMachineScaleSets.CreateOrUpdate(rgName, vmssName, inputVMScaleSet); Assert.True(createOrUpdateResponse.Name == vmssName); Assert.True(createOrUpdateResponse.Location.ToLower() == inputVMScaleSet.Location.ToLower().Replace(" ", "")); } catch (CloudException e) { if (e.Message.Contains("the allotted time")) { createOrUpdateResponse = m_CrpClient.VirtualMachineScaleSets.Get(rgName, vmssName); } else { throw; } } ValidateVMScaleSet(inputVMScaleSet, createOrUpdateResponse, createWithManagedDisks, ppgId: ppgId, dedicatedHostGroupReferenceId: dedicatedHostGroupReferenceId); return(createOrUpdateResponse); }
protected VirtualMachineScaleSet CreateDefaultVMScaleSetInput( string rgName, string storageAccountName, ImageReference imageRef, string subnetId, bool hasManagedDisks = false, string healthProbeId = null, string loadBalancerBackendPoolId = null, IList <string> zones = null, int?osDiskSizeInGB = null, string machineSizeType = null, bool?enableUltraSSD = false, string diskEncryptionSetId = null, AutomaticRepairsPolicy automaticRepairsPolicy = null, DiagnosticsProfile bootDiagnosticsProfile = null, int?faultDomainCount = null, int?capacity = null, VirtualMachineScaleSetHardwareProfile hardwareProfile = null) { // Generate Container name to hold disk VHds string containerName = TestUtilities.GenerateName(TestPrefix); var vhdContainer = "https://" + storageAccountName + ".blob.core.windows.net/" + containerName; var vmssName = TestUtilities.GenerateName("vmss"); bool createOSDisk = !hasManagedDisks || osDiskSizeInGB != null; string vmSize = zones == null ? VirtualMachineSizeTypes.StandardA1V2 : VirtualMachineSizeTypes.StandardA1V2; var vmScaleSet = new VirtualMachineScaleSet() { Location = m_location, Tags = new Dictionary <string, string>() { { "RG", "rg" }, { "testTag", "1" } }, Sku = new CM.Sku() { Capacity = capacity ?? 2, Name = machineSizeType == null ? vmSize : machineSizeType }, Zones = zones, Overprovision = false, UpgradePolicy = new UpgradePolicy() { Mode = UpgradeMode.Automatic }, VirtualMachineProfile = new VirtualMachineScaleSetVMProfile() { StorageProfile = new VirtualMachineScaleSetStorageProfile() { ImageReference = imageRef, OsDisk = !createOSDisk ? null : new VirtualMachineScaleSetOSDisk { Caching = CachingTypes.None, CreateOption = DiskCreateOptionTypes.FromImage, Name = hasManagedDisks ? null : "test", VhdContainers = hasManagedDisks ? null : new List <string> { vhdContainer }, DiskSizeGB = osDiskSizeInGB, ManagedDisk = diskEncryptionSetId == null ? null: new VirtualMachineScaleSetManagedDiskParameters() { StorageAccountType = StorageAccountTypes.StandardLRS, DiskEncryptionSet = new DiskEncryptionSetParameters() { Id = diskEncryptionSetId } } }, DataDisks = !hasManagedDisks ? null : new List <VirtualMachineScaleSetDataDisk> { new VirtualMachineScaleSetDataDisk { Lun = 1, CreateOption = DiskCreateOptionTypes.Empty, DiskSizeGB = 128, ManagedDisk = diskEncryptionSetId == null ? null: new VirtualMachineScaleSetManagedDiskParameters() { StorageAccountType = StorageAccountTypes.StandardLRS, DiskEncryptionSet = new DiskEncryptionSetParameters() { Id = diskEncryptionSetId } } } } }, HardwareProfile = hardwareProfile, OsProfile = new VirtualMachineScaleSetOSProfile() { ComputerNamePrefix = "test", AdminUsername = "******", AdminPassword = PLACEHOLDER, CustomData = Convert.ToBase64String(Encoding.UTF8.GetBytes("Custom data")) }, NetworkProfile = new VirtualMachineScaleSetNetworkProfile() { HealthProbe = healthProbeId == null ? null : new ApiEntityReference { Id = healthProbeId }, NetworkInterfaceConfigurations = new List <VirtualMachineScaleSetNetworkConfiguration>() { new VirtualMachineScaleSetNetworkConfiguration() { Name = TestUtilities.GenerateName("vmsstestnetconfig"), Primary = true, IpConfigurations = new List <VirtualMachineScaleSetIPConfiguration> { new VirtualMachineScaleSetIPConfiguration() { Name = TestUtilities.GenerateName("vmsstestnetconfig"), Subnet = new Microsoft.Azure.Management.Compute.Models.ApiEntityReference() { Id = subnetId }, LoadBalancerBackendAddressPools = (loadBalancerBackendPoolId != null) ? new List <Microsoft.Azure.Management.Compute.Models.SubResource> { new Microsoft.Azure.Management.Compute.Models.SubResource(loadBalancerBackendPoolId) } : null, ApplicationGatewayBackendAddressPools = new List <Microsoft.Azure.Management.Compute.Models.SubResource>(), } } } } }, ExtensionProfile = new VirtualMachineScaleSetExtensionProfile(), }, AutomaticRepairsPolicy = automaticRepairsPolicy }; if (bootDiagnosticsProfile != null) { vmScaleSet.VirtualMachineProfile.DiagnosticsProfile = bootDiagnosticsProfile; } if (faultDomainCount != null) { vmScaleSet.PlatformFaultDomainCount = faultDomainCount; } if (enableUltraSSD == true) { vmScaleSet.AdditionalCapabilities = new AdditionalCapabilities { UltraSSDEnabled = true }; VirtualMachineScaleSetOSDisk osDisk = vmScaleSet.VirtualMachineProfile.StorageProfile.OsDisk; osDisk.ManagedDisk = osDisk.ManagedDisk ?? new VirtualMachineScaleSetManagedDiskParameters(); osDisk.ManagedDisk.StorageAccountType = StorageAccountTypes.PremiumLRS; foreach (VirtualMachineScaleSetDataDisk dataDisk in vmScaleSet.VirtualMachineProfile.StorageProfile.DataDisks) { dataDisk.ManagedDisk = dataDisk.ManagedDisk ?? new VirtualMachineScaleSetManagedDiskParameters(); dataDisk.ManagedDisk.StorageAccountType = StorageAccountTypes.UltraSSDLRS; } } return(vmScaleSet); }
public VirtualMachineScaleSet CreateVMScaleSet_NoAsyncTracking( string rgName, string vmssName, StorageAccount storageAccount, ImageReference imageRef, out VirtualMachineScaleSet inputVMScaleSet, VirtualMachineScaleSetExtensionProfile extensionProfile = null, Action <VirtualMachineScaleSet> vmScaleSetCustomizer = null, bool createWithPublicIpAddress = false, bool createWithManagedDisks = false, bool hasDiffDisks = false, bool createWithHealthProbe = false, Subnet subnet = null, IList <string> zones = null, int?osDiskSizeInGB = null, string ppgId = null, string machineSizeType = null, bool?enableUltraSSD = false, string diskEncryptionSetId = null, AutomaticRepairsPolicy automaticRepairsPolicy = null, bool?encryptionAtHostEnabled = null, bool singlePlacementGroup = true, DiagnosticsProfile bootDiagnosticsProfile = null, int?faultDomainCount = null, int?capacity = null, string dedicatedHostGroupReferenceId = null, string dedicatedHostGroupName = null, string dedicatedHostName = null, string userData = null, string capacityReservationGroupReferenceId = null, VirtualMachineScaleSetHardwareProfile hardwareProfile = null) { try { var createOrUpdateResponse = CreateVMScaleSetAndGetOperationResponse(rgName, vmssName, storageAccount, imageRef, out inputVMScaleSet, extensionProfile, vmScaleSetCustomizer, createWithPublicIpAddress, createWithManagedDisks, hasDiffDisks, createWithHealthProbe, subnet, zones, osDiskSizeInGB, ppgId: ppgId, machineSizeType: machineSizeType, enableUltraSSD: enableUltraSSD, diskEncryptionSetId: diskEncryptionSetId, automaticRepairsPolicy: automaticRepairsPolicy, encryptionAtHostEnabled: encryptionAtHostEnabled, singlePlacementGroup: singlePlacementGroup, bootDiagnosticsProfile: bootDiagnosticsProfile, faultDomainCount: faultDomainCount, capacity: capacity, dedicatedHostGroupReferenceId: dedicatedHostGroupReferenceId, dedicatedHostGroupName: dedicatedHostGroupName, dedicatedHostName: dedicatedHostName, userData: userData, capacityReservationGroupReferenceId: capacityReservationGroupReferenceId, hardwareProfile: hardwareProfile); var getResponse = m_CrpClient.VirtualMachineScaleSets.Get(rgName, vmssName); return(getResponse); } catch { // TODO: It is better to issue Delete and forget. m_ResourcesClient.ResourceGroups.Delete(rgName); throw; } }
private void TestScaleSetOperationsInternal(MockContext context, string vmSize = null, bool hasManagedDisks = false, bool useVmssExtension = true, bool hasDiffDisks = false, IList <string> zones = null, int?osDiskSizeInGB = null, bool isPpgScenario = false, bool?enableUltraSSD = false, Action <VirtualMachineScaleSet> vmScaleSetCustomizer = null, Action <VirtualMachineScaleSet> vmScaleSetValidator = null, string diskEncryptionSetId = null, bool?encryptionAtHostEnabled = null, bool isAutomaticPlacementOnDedicatedHostGroupScenario = false, int?faultDomainCount = null, int?capacity = null, bool shouldOverProvision = true, bool validateVmssVMInstanceView = false, ImageReference imageReference = null, bool validateListSku = true, bool deleteAsPartOfTest = true, bool associateWithCapacityReservationGroup = false, VirtualMachineScaleSetHardwareProfile hardwareProfile = null) { EnsureClientsInitialized(context); ImageReference imageRef = imageReference ?? GetPlatformVMImage(useWindowsImage: true); // Create resource group var rgName = TestUtilities.GenerateName(TestPrefix); var vmssName = TestUtilities.GenerateName("vmss"); string storageAccountName = TestUtilities.GenerateName(TestPrefix); VirtualMachineScaleSet inputVMScaleSet; VirtualMachineScaleSetExtensionProfile extensionProfile = new VirtualMachineScaleSetExtensionProfile() { Extensions = new List <VirtualMachineScaleSetExtension>() { GetTestVMSSVMExtension(autoUpdateMinorVersion: false), } }; try { var storageAccountOutput = CreateStorageAccount(rgName, storageAccountName); m_CrpClient.VirtualMachineScaleSets.Delete(rgName, "VMScaleSetDoesNotExist"); string ppgId = null; string ppgName = null; if (isPpgScenario) { ppgName = ComputeManagementTestUtilities.GenerateName("ppgtest"); ppgId = CreateProximityPlacementGroup(rgName, ppgName); } string dedicatedHostGroupName = null, dedicatedHostName = null, dedicatedHostGroupReferenceId = null, dedicatedHostReferenceId = null; if (isAutomaticPlacementOnDedicatedHostGroupScenario) { dedicatedHostGroupName = ComputeManagementTestUtilities.GenerateName("dhgtest"); dedicatedHostName = ComputeManagementTestUtilities.GenerateName("dhtest"); dedicatedHostGroupReferenceId = Helpers.GetDedicatedHostGroupRef(m_subId, rgName, dedicatedHostGroupName); dedicatedHostReferenceId = Helpers.GetDedicatedHostRef(m_subId, rgName, dedicatedHostGroupName, dedicatedHostName); } bool singlePlacementGroup = true; string capacityReservationGroupName = null, capacityReservationGroupReferenceId = null, capacityReservationName = null; if (associateWithCapacityReservationGroup) { capacityReservationGroupName = ComputeManagementTestUtilities.GenerateName("crgtest"); capacityReservationName = ComputeManagementTestUtilities.GenerateName("crtest"); CreateCapacityReservationGroup(rgName, capacityReservationGroupName); CreateCapacityReservation(rgName, capacityReservationGroupName, capacityReservationName, VirtualMachineSizeTypes.StandardDS1V2, reservedCount: 1); capacityReservationGroupReferenceId = Helpers.GetCapacityReservationGroupRef(m_subId, rgName, capacityReservationGroupName); singlePlacementGroup = false; } VirtualMachineScaleSet getResponse = CreateVMScaleSet_NoAsyncTracking( rgName, vmssName, storageAccountOutput, imageRef, out inputVMScaleSet, useVmssExtension ? extensionProfile : null, (vmScaleSet) => { vmScaleSet.Overprovision = shouldOverProvision; if (!String.IsNullOrEmpty(vmSize)) { vmScaleSet.Sku.Name = vmSize; } vmScaleSetCustomizer?.Invoke(vmScaleSet); }, createWithManagedDisks: hasManagedDisks, hasDiffDisks: hasDiffDisks, zones: zones, osDiskSizeInGB: osDiskSizeInGB, ppgId: ppgId, enableUltraSSD: enableUltraSSD, diskEncryptionSetId: diskEncryptionSetId, encryptionAtHostEnabled: encryptionAtHostEnabled, faultDomainCount: faultDomainCount, capacity: capacity, dedicatedHostGroupReferenceId: dedicatedHostGroupReferenceId, dedicatedHostGroupName: dedicatedHostGroupName, dedicatedHostName: dedicatedHostName, capacityReservationGroupReferenceId: capacityReservationGroupReferenceId, singlePlacementGroup: singlePlacementGroup, hardwareProfile: hardwareProfile); if (diskEncryptionSetId != null) { Assert.True(getResponse.VirtualMachineProfile.StorageProfile.OsDisk.ManagedDisk.DiskEncryptionSet != null, "OsDisk.ManagedDisk.DiskEncryptionSet is null"); Assert.True(string.Equals(diskEncryptionSetId, getResponse.VirtualMachineProfile.StorageProfile.OsDisk.ManagedDisk.DiskEncryptionSet.Id, StringComparison.OrdinalIgnoreCase), "OsDisk.ManagedDisk.DiskEncryptionSet.Id is not matching with expected DiskEncryptionSet resource"); Assert.Equal(1, getResponse.VirtualMachineProfile.StorageProfile.DataDisks.Count); Assert.True(getResponse.VirtualMachineProfile.StorageProfile.DataDisks[0].ManagedDisk.DiskEncryptionSet != null, ".DataDisks.ManagedDisk.DiskEncryptionSet is null"); Assert.True(string.Equals(diskEncryptionSetId, getResponse.VirtualMachineProfile.StorageProfile.DataDisks[0].ManagedDisk.DiskEncryptionSet.Id, StringComparison.OrdinalIgnoreCase), "DataDisks.ManagedDisk.DiskEncryptionSet.Id is not matching with expected DiskEncryptionSet resource"); } if (!string.IsNullOrEmpty(capacityReservationGroupReferenceId)) { Assert.True(getResponse.VirtualMachineProfile.CapacityReservation.CapacityReservationGroup != null, "CapacityReservation.CapacityReservationGroup is null"); Assert.True(string.Equals(capacityReservationGroupReferenceId, getResponse.VirtualMachineProfile.CapacityReservation.CapacityReservationGroup.Id, StringComparison.OrdinalIgnoreCase), "CapacityReservation.CapacityReservationGroup.Id is not matching with expected CapacityReservationGroup resource"); CapacityReservation capacityReservation = m_CrpClient.CapacityReservations.Get(rgName, capacityReservationGroupName, capacityReservationName, CapacityReservationInstanceViewTypes.InstanceView); var queryForVmssVM = new Microsoft.Rest.Azure.OData.ODataQuery <VirtualMachineScaleSetVM>(); queryForVmssVM.SetFilter(vm => vm.LatestModelApplied == true); var listVmssVMsResponse = m_CrpClient.VirtualMachineScaleSetVMs.List(rgName, vmssName, queryForVmssVM); string expectedVMReferenceId = Helpers.GetVMScaleSetVMReferenceId(m_subId, rgName, vmssName, listVmssVMsResponse.First().InstanceId); Assert.True(capacityReservation.VirtualMachinesAssociated.Any(), "capacityReservation.VirtualMachinesAssociated is not empty"); Assert.True(string.Equals(expectedVMReferenceId, capacityReservation.VirtualMachinesAssociated.First().Id, StringComparison.OrdinalIgnoreCase), "capacityReservation.VirtualMachinesAssociated are not matching"); /* * Assert.True(capacityReservation.InstanceView.UtilizationInfo.VirtualMachinesAllocated.Any(), "InstanceView.UtilizationInfo.VirtualMachinesAllocated is empty"); * Assert.True(string.Equals(expectedVMReferenceId, capacityReservation.InstanceView.UtilizationInfo.VirtualMachinesAllocated.First().Id), * "InstanceView.UtilizationInfo.VirtualMachinesAllocated are not matching"); */ } if (encryptionAtHostEnabled != null) { Assert.True(getResponse.VirtualMachineProfile.SecurityProfile.EncryptionAtHost == encryptionAtHostEnabled.Value, "SecurityProfile.EncryptionAtHost is not same as expected"); } ValidateVMScaleSet(inputVMScaleSet, getResponse, hasManagedDisks, ppgId: ppgId, dedicatedHostGroupReferenceId: dedicatedHostGroupReferenceId); var getInstanceViewResponse = m_CrpClient.VirtualMachineScaleSets.GetInstanceView(rgName, vmssName); Assert.NotNull(getInstanceViewResponse); ValidateVMScaleSetInstanceView(inputVMScaleSet, getInstanceViewResponse); if (isPpgScenario) { ProximityPlacementGroup outProximityPlacementGroup = m_CrpClient.ProximityPlacementGroups.Get(rgName, ppgName); Assert.Equal(1, outProximityPlacementGroup.VirtualMachineScaleSets.Count); string expectedVmssReferenceId = Helpers.GetVMScaleSetReferenceId(m_subId, rgName, vmssName); Assert.Equal(expectedVmssReferenceId, outProximityPlacementGroup.VirtualMachineScaleSets.First().Id, StringComparer.OrdinalIgnoreCase); } var listResponse = m_CrpClient.VirtualMachineScaleSets.List(rgName); ValidateVMScaleSet(inputVMScaleSet, listResponse.FirstOrDefault(x => x.Name == vmssName), hasManagedDisks); if (validateListSku) { var listSkusResponse = m_CrpClient.VirtualMachineScaleSets.ListSkus(rgName, vmssName); Assert.NotNull(listSkusResponse); Assert.False(listSkusResponse.Count() == 0); } if (zones != null) { var query = new Microsoft.Rest.Azure.OData.ODataQuery <VirtualMachineScaleSetVM>(); query.SetFilter(vm => vm.LatestModelApplied == true); var listVMsResponse = m_CrpClient.VirtualMachineScaleSetVMs.List(rgName, vmssName, query); Assert.False(listVMsResponse == null, "VMScaleSetVMs not returned"); Assert.True(listVMsResponse.Count() == inputVMScaleSet.Sku.Capacity); foreach (var vmScaleSetVM in listVMsResponse) { string instanceId = vmScaleSetVM.InstanceId; var getVMResponse = m_CrpClient.VirtualMachineScaleSetVMs.Get(rgName, vmssName, instanceId); ValidateVMScaleSetVM(inputVMScaleSet, instanceId, getVMResponse, hasManagedDisks); } } if (validateVmssVMInstanceView) { VirtualMachineScaleSetVMInstanceView vmssVMInstanceView = m_CrpClient.VirtualMachineScaleSetVMs.GetInstanceView(rgName, vmssName, "0"); ValidateVMScaleSetVMInstanceView(vmssVMInstanceView, hasManagedDisks, dedicatedHostReferenceId); } vmScaleSetValidator?.Invoke(getResponse); if (deleteAsPartOfTest) { m_CrpClient.VirtualMachineScaleSets.Delete(rgName, vmssName); } } finally { if (deleteAsPartOfTest) { m_ResourcesClient.ResourceGroups.Delete(rgName); } else { // Fire and forget. No need to wait for RG deletion completion m_ResourcesClient.ResourceGroups.BeginDelete(rgName); } } }