protected override void ProcessRecord() { // Sku Microsoft.Azure.Management.Compute.Models.Sku vSku = null; // UpgradePolicy Microsoft.Azure.Management.Compute.Models.UpgradePolicy vUpgradePolicy = null; // VirtualMachineProfile Microsoft.Azure.Management.Compute.Models.VirtualMachineScaleSetVMProfile vVirtualMachineProfile = null; if (this.SkuName != null) { if (vSku == null) { vSku = new Microsoft.Azure.Management.Compute.Models.Sku(); } vSku.Name = this.SkuName; } if (this.SkuTier != null) { if (vSku == null) { vSku = new Microsoft.Azure.Management.Compute.Models.Sku(); } vSku.Tier = this.SkuTier; } if (this.SkuCapacity != null) { if (vSku == null) { vSku = new Microsoft.Azure.Management.Compute.Models.Sku(); } vSku.Capacity = this.SkuCapacity; } if (this.UpgradePolicyMode != null) { if (vUpgradePolicy == null) { vUpgradePolicy = new Microsoft.Azure.Management.Compute.Models.UpgradePolicy(); } vUpgradePolicy.Mode = this.UpgradePolicyMode; } if (this.OsProfile != null) { if (vVirtualMachineProfile == null) { vVirtualMachineProfile = new Microsoft.Azure.Management.Compute.Models.VirtualMachineScaleSetVMProfile(); } vVirtualMachineProfile.OsProfile = this.OsProfile; } if (this.StorageProfile != null) { if (vVirtualMachineProfile == null) { vVirtualMachineProfile = new Microsoft.Azure.Management.Compute.Models.VirtualMachineScaleSetVMProfile(); } vVirtualMachineProfile.StorageProfile = this.StorageProfile; } if (this.NetworkInterfaceConfiguration != null) { if (vVirtualMachineProfile == null) { vVirtualMachineProfile = new Microsoft.Azure.Management.Compute.Models.VirtualMachineScaleSetVMProfile(); } if (vVirtualMachineProfile.NetworkProfile == null) { vVirtualMachineProfile.NetworkProfile = new Microsoft.Azure.Management.Compute.Models.VirtualMachineScaleSetNetworkProfile(); } vVirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations = this.NetworkInterfaceConfiguration; } if (this.Extension != null) { if (vVirtualMachineProfile == null) { vVirtualMachineProfile = new Microsoft.Azure.Management.Compute.Models.VirtualMachineScaleSetVMProfile(); } if (vVirtualMachineProfile.ExtensionProfile == null) { vVirtualMachineProfile.ExtensionProfile = new Microsoft.Azure.Management.Compute.Models.VirtualMachineScaleSetExtensionProfile(); } vVirtualMachineProfile.ExtensionProfile.Extensions = this.Extension; } var vVirtualMachineScaleSet = new VirtualMachineScaleSet { OverProvision = this.OverProvision, Location = this.Location, Tags = (this.Tag == null) ? null : this.Tag.Cast<DictionaryEntry>().ToDictionary(ht => (string)ht.Key, ht => (string)ht.Value), Sku = vSku, UpgradePolicy = vUpgradePolicy, VirtualMachineProfile = vVirtualMachineProfile, }; WriteObject(vVirtualMachineScaleSet); }
protected void ValidateVMScaleSet(VirtualMachineScaleSet vmScaleSet, VirtualMachineScaleSet vmScaleSetOut, bool hasManagedDisks = false) { Assert.True(!string.IsNullOrEmpty(vmScaleSetOut.ProvisioningState)); Assert.True(vmScaleSetOut.Sku.Name == vmScaleSet.Sku.Name); Assert.NotNull(vmScaleSetOut.VirtualMachineProfile.StorageProfile.OsDisk); if (vmScaleSet.VirtualMachineProfile.StorageProfile.OsDisk?.DiskSizeGB != null) { Assert.NotNull(vmScaleSetOut.VirtualMachineProfile.StorageProfile.OsDisk.DiskSizeGB); Assert.Equal(vmScaleSet.VirtualMachineProfile.StorageProfile.OsDisk.DiskSizeGB, vmScaleSetOut.VirtualMachineProfile.StorageProfile.OsDisk.DiskSizeGB); } if (!hasManagedDisks) { Assert.True(vmScaleSetOut.VirtualMachineProfile.StorageProfile.OsDisk.Name == vmScaleSet.VirtualMachineProfile.StorageProfile.OsDisk.Name); if (vmScaleSet.VirtualMachineProfile.StorageProfile.OsDisk.Image != null) { Assert.True(vmScaleSetOut.VirtualMachineProfile.StorageProfile.OsDisk.Image.Uri == vmScaleSet.VirtualMachineProfile.StorageProfile.OsDisk.Image.Uri); } Assert.True(vmScaleSetOut.VirtualMachineProfile.StorageProfile.OsDisk.Caching == vmScaleSet.VirtualMachineProfile.StorageProfile.OsDisk.Caching); } else { Assert.NotNull(vmScaleSetOut.VirtualMachineProfile.StorageProfile.OsDisk.ManagedDisk); if (vmScaleSet.VirtualMachineProfile.StorageProfile.OsDisk != null) { VirtualMachineScaleSetOSDisk osDisk = vmScaleSet.VirtualMachineProfile.StorageProfile.OsDisk; VirtualMachineScaleSetOSDisk osDiskOut = vmScaleSetOut.VirtualMachineProfile.StorageProfile.OsDisk; if (osDisk.Caching != null) { Assert.True(osDisk.Caching == osDiskOut.Caching); } else { Assert.NotNull(osDiskOut.Caching); } if (osDisk.DiffDiskSettings != null) { Assert.True(osDisk.DiffDiskSettings.Option == osDiskOut.DiffDiskSettings.Option); } Assert.NotNull(osDiskOut.ManagedDisk); if (osDisk.ManagedDisk != null && osDisk.ManagedDisk.StorageAccountType != null) { Assert.True(osDisk.ManagedDisk.StorageAccountType == osDiskOut.ManagedDisk.StorageAccountType); } else { Assert.NotNull(osDiskOut.ManagedDisk.StorageAccountType); } if (osDisk.Name != null) { Assert.Equal(osDiskOut.Name, osDisk.Name); } Assert.True(osDiskOut.CreateOption == DiskCreateOptionTypes.FromImage); } if (vmScaleSet.VirtualMachineProfile.StorageProfile.DataDisks != null && vmScaleSet.VirtualMachineProfile.StorageProfile.DataDisks.Count > 0) { Assert.Equal( vmScaleSet.VirtualMachineProfile.StorageProfile.DataDisks.Count, vmScaleSetOut.VirtualMachineProfile.StorageProfile.DataDisks.Count); foreach (VirtualMachineScaleSetDataDisk dataDisk in vmScaleSet.VirtualMachineProfile.StorageProfile.DataDisks) { VirtualMachineScaleSetDataDisk matchingDataDisk = vmScaleSetOut.VirtualMachineProfile.StorageProfile.DataDisks.FirstOrDefault(disk => disk.Lun == dataDisk.Lun); Assert.NotNull(matchingDataDisk); if (dataDisk.Caching != null) { Assert.True(dataDisk.Caching == matchingDataDisk.Caching); } else { Assert.NotNull(matchingDataDisk.Caching); } if (dataDisk.ManagedDisk != null && dataDisk.ManagedDisk.StorageAccountType != null) { Assert.True(dataDisk.ManagedDisk.StorageAccountType == matchingDataDisk.ManagedDisk.StorageAccountType); } else { Assert.NotNull(matchingDataDisk.ManagedDisk.StorageAccountType); } if (dataDisk.Name != null) { Assert.Equal(dataDisk.Name, matchingDataDisk.Name); } Assert.True(dataDisk.CreateOption == matchingDataDisk.CreateOption); } } } if (vmScaleSet.UpgradePolicy.AutomaticOSUpgradePolicy != null) { bool expectedDisableAutomaticRollbackValue = vmScaleSet.UpgradePolicy.AutomaticOSUpgradePolicy.DisableAutomaticRollback ?? false; Assert.True(vmScaleSetOut.UpgradePolicy.AutomaticOSUpgradePolicy.DisableAutomaticRollback == expectedDisableAutomaticRollbackValue); bool expectedEnableAutomaticOSUpgradeValue = vmScaleSet.UpgradePolicy.AutomaticOSUpgradePolicy.EnableAutomaticOSUpgrade ?? false; Assert.True(vmScaleSetOut.UpgradePolicy.AutomaticOSUpgradePolicy.EnableAutomaticOSUpgrade == expectedEnableAutomaticOSUpgradeValue); } if (vmScaleSet.VirtualMachineProfile.OsProfile.Secrets != null && vmScaleSet.VirtualMachineProfile.OsProfile.Secrets.Any()) { foreach (var secret in vmScaleSet.VirtualMachineProfile.OsProfile.Secrets) { Assert.NotNull(secret.VaultCertificates); var secretOut = vmScaleSetOut.VirtualMachineProfile.OsProfile.Secrets.FirstOrDefault(s => string.Equals(secret.SourceVault.Id, s.SourceVault.Id)); Assert.NotNull(secretOut); // Disabling resharper null-ref check as it doesn't seem to understand the not-null assert above. // ReSharper disable PossibleNullReferenceException Assert.NotNull(secretOut.VaultCertificates); var VaultCertComparer = new VaultCertComparer(); Assert.True(secretOut.VaultCertificates.SequenceEqual(secret.VaultCertificates, VaultCertComparer)); // ReSharper enable PossibleNullReferenceException } } if (vmScaleSet.VirtualMachineProfile.ExtensionProfile != null && vmScaleSet.VirtualMachineProfile.ExtensionProfile.Extensions.Any()) { foreach (var vmExtension in vmScaleSet.VirtualMachineProfile.ExtensionProfile.Extensions) { var vmExt = vmScaleSetOut.VirtualMachineProfile.ExtensionProfile.Extensions.FirstOrDefault(s => String.Compare(s.Name, vmExtension.Name, StringComparison.OrdinalIgnoreCase) == 0); Assert.NotNull(vmExt); } } if (vmScaleSet.VirtualMachineProfile.NetworkProfile != null) { if (vmScaleSet.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations != null && vmScaleSet.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations.Count > 0) { Assert.NotNull(vmScaleSetOut.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations); Assert.Equal( vmScaleSetOut.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations.Count, vmScaleSet.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations.Count); foreach (var nicconfig in vmScaleSet.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations) { var outnicconfig = vmScaleSetOut.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations.First( nc => string.Equals(nc.Name, nicconfig.Name, StringComparison.OrdinalIgnoreCase)); Assert.NotNull(outnicconfig); CompareVmssNicConfig(nicconfig, outnicconfig); } } } else { Assert.True((vmScaleSetOut.VirtualMachineProfile.NetworkProfile == null) || (vmScaleSetOut.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations.Count == 0)); } if (vmScaleSet.Zones != null) { Assert.True(vmScaleSet.Zones.SequenceEqual(vmScaleSetOut.Zones), "Zones don't match"); if (vmScaleSet.ZoneBalance.HasValue) { Assert.Equal(vmScaleSet.ZoneBalance, vmScaleSetOut.ZoneBalance); } else { if (vmScaleSet.Zones.Count > 1) { Assert.True(vmScaleSetOut.ZoneBalance.HasValue); } else { Assert.False(vmScaleSetOut.ZoneBalance.HasValue); } } if (vmScaleSet.PlatformFaultDomainCount.HasValue) { Assert.Equal(vmScaleSet.PlatformFaultDomainCount, vmScaleSetOut.PlatformFaultDomainCount); } else { Assert.True(vmScaleSetOut.PlatformFaultDomainCount.HasValue); } } else { Assert.Null(vmScaleSetOut.Zones); Assert.Null(vmScaleSetOut.ZoneBalance); Assert.Null(vmScaleSetOut.PlatformFaultDomainCount); } }
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) { // 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 } } } } }, 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); }
private async Task TestDiskEncryptionOnScaleSetVMInternal(bool hasManagedDisks = true, bool useVmssExtension = true) { // Get platform image for VMScaleSet create ImageReference imageRef = await GetPlatformVMImage(useWindowsImage : true); // Create resource group string rgName = Recording.GenerateAssetName(TestPrefix); string vmssName = Recording.GenerateAssetName("vmss"); string storageAccountName = Recording.GenerateAssetName(TestPrefix); var dnsname = Recording.GenerateAssetName("dnsname"); // Create ADE extension to enable disk encryption VirtualMachineScaleSetExtensionProfile extensionProfile = new VirtualMachineScaleSetExtensionProfile() { Extensions = { GetAzureDiskEncryptionExtension(), } }; bool testSucceeded = false; StorageAccount storageAccountOutput = await CreateStorageAccount(rgName, storageAccountName); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartDeleteAsync(rgName, "VMScaleSetDoesNotExist")); var vnetResponse = await CreateVNETWithSubnets(rgName, 2); var vmssSubnet = vnetResponse.Subnets[1]; var publicipConfiguration = new VirtualMachineScaleSetPublicIPAddressConfiguration("pip1"); publicipConfiguration.IdleTimeoutInMinutes = 10; publicipConfiguration.DnsSettings = new VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettings(dnsname); VirtualMachineScaleSet inputVMScaleSet; var getTwoVirtualMachineScaleSet = await CreateVMScaleSet_NoAsyncTracking( rgName, vmssName, storageAccountOutput, imageRef, useVmssExtension?extensionProfile : null, (vmss) => { vmss.Sku.Name = VirtualMachineSizeTypes.StandardA3.ToString(); vmss.Sku.Tier = "Standard"; vmss.VirtualMachineProfile.StorageProfile.OsDisk = new VirtualMachineScaleSetOSDisk(DiskCreateOptionTypes.FromImage); vmss.VirtualMachineProfile.NetworkProfile .NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration = publicipConfiguration; }, createWithManagedDisks : hasManagedDisks, createWithPublicIpAddress : false, subnet : vmssSubnet); VirtualMachineScaleSet vmScaleSet = getTwoVirtualMachineScaleSet.Response; inputVMScaleSet = getTwoVirtualMachineScaleSet.Input; VirtualMachineScaleSetVMInstanceView vmInstanceViewResponse = await VirtualMachineScaleSetVMsOperations.GetInstanceViewAsync(rgName, vmScaleSet.Name, "0"); Assert.True(vmInstanceViewResponse != null, "VMScaleSetVM not returned."); ValidateEncryptionSettingsInVMScaleSetVMInstanceView(vmInstanceViewResponse, hasManagedDisks); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartDeleteAsync(rgName, vmssName)); testSucceeded = true; Assert.True(testSucceeded); }
protected void UpdateVMScaleSet(string rgName, string vmssName, VirtualMachineScaleSet inputVMScaleSet) { var createOrUpdateResponse = m_CrpClient.VirtualMachineScaleSets.CreateOrUpdate(rgName, vmssName, inputVMScaleSet); }
public static async Task <VirtualMachineScaleSet> CreateOrUpdateWithCustomHeaderAsync(this IVirtualMachineScaleSetsOperations operations, string resourceGroupName, string vmssName, VirtualMachineScaleSet virtualMachineScaleSet, CancellationToken cancellationToken = default(CancellationToken)) { var auxAuthHeader = virtualMachineScaleSet.GetAuxAuthHeader(); if (auxAuthHeader == null) { return(operations.CreateOrUpdate(resourceGroupName, vmssName, virtualMachineScaleSet)); } virtualMachineScaleSet.RemoveAuxAuthHeader(); using (var _result = await operations.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, vmssName, virtualMachineScaleSet, auxAuthHeader, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
//not use in track one //protected async Task<VirtualMachineScaleSet> CreateVMScaleSet( // string rgName, // string vmssName, // StorageAccount storageAccount, // ImageReference imageRef, // VirtualMachineScaleSetExtensionProfile extensionProfile = null, // Action<VirtualMachineScaleSet> vmScaleSetCustomizer = null, // bool createWithPublicIpAddress = false, // bool createWithManagedDisks = false) //{ // try // { // var createOrUpdateResponse = CreateVMScaleSetAndGetOperationResponse( // rgName, // vmssName, // storageAccount, // imageRef, // extensionProfile, // vmScaleSetCustomizer, // createWithPublicIpAddress, // createWithManagedDisks); // var lroResponse = await VirtualMachineScaleSetsClient.StartCreateOrUpdateAsync(rgName, inputVMScaleSet.Name, inputVMScaleSet); // var getResponse = await VirtualMachineScaleSetsClient.Get(rgName, inputVMScaleSet.Name); // return getResponse; // } // catch // { // await ResourceGroupsClient.Delete(rgName); // throw; // } //} protected async Task UpdateVMScaleSet(string rgName, string vmssName, VirtualMachineScaleSet inputVMScaleSet) { var createOrUpdateResponse = await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartCreateOrUpdateAsync(rgName, vmssName, inputVMScaleSet)); }
protected override void ProcessRecord() { // Sku Microsoft.Azure.Management.Compute.Models.Sku vSku = null; // UpgradePolicy Microsoft.Azure.Management.Compute.Models.UpgradePolicy vUpgradePolicy = null; // VirtualMachineProfile Microsoft.Azure.Management.Compute.Models.VirtualMachineScaleSetVMProfile vVirtualMachineProfile = null; if (this.SkuName != null) { if (vSku == null) { vSku = new Microsoft.Azure.Management.Compute.Models.Sku(); } vSku.Name = this.SkuName; } if (this.SkuTier != null) { if (vSku == null) { vSku = new Microsoft.Azure.Management.Compute.Models.Sku(); } vSku.Tier = this.SkuTier; } if (this.SkuCapacity != null) { if (vSku == null) { vSku = new Microsoft.Azure.Management.Compute.Models.Sku(); } vSku.Capacity = this.SkuCapacity; } if (this.UpgradePolicyMode != null) { if (vUpgradePolicy == null) { vUpgradePolicy = new Microsoft.Azure.Management.Compute.Models.UpgradePolicy(); } vUpgradePolicy.Mode = this.UpgradePolicyMode; } if (this.OsProfile != null) { if (vVirtualMachineProfile == null) { vVirtualMachineProfile = new Microsoft.Azure.Management.Compute.Models.VirtualMachineScaleSetVMProfile(); } vVirtualMachineProfile.OsProfile = this.OsProfile; } if (this.StorageProfile != null) { if (vVirtualMachineProfile == null) { vVirtualMachineProfile = new Microsoft.Azure.Management.Compute.Models.VirtualMachineScaleSetVMProfile(); } vVirtualMachineProfile.StorageProfile = this.StorageProfile; } if (this.NetworkInterfaceConfiguration != null) { if (vVirtualMachineProfile == null) { vVirtualMachineProfile = new Microsoft.Azure.Management.Compute.Models.VirtualMachineScaleSetVMProfile(); } if (vVirtualMachineProfile.NetworkProfile == null) { vVirtualMachineProfile.NetworkProfile = new Microsoft.Azure.Management.Compute.Models.VirtualMachineScaleSetNetworkProfile(); } vVirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations = this.NetworkInterfaceConfiguration; } if (this.Extension != null) { if (vVirtualMachineProfile == null) { vVirtualMachineProfile = new Microsoft.Azure.Management.Compute.Models.VirtualMachineScaleSetVMProfile(); } if (vVirtualMachineProfile.ExtensionProfile == null) { vVirtualMachineProfile.ExtensionProfile = new Microsoft.Azure.Management.Compute.Models.VirtualMachineScaleSetExtensionProfile(); } vVirtualMachineProfile.ExtensionProfile.Extensions = this.Extension; } var vVirtualMachineScaleSet = new VirtualMachineScaleSet { ProvisioningState = this.ProvisioningState, OverProvision = this.OverProvision, Location = this.Location, Tags = (this.Tag == null) ? null : this.Tag.Cast <DictionaryEntry>().ToDictionary(ht => (string)ht.Key, ht => (string)ht.Value), Sku = vSku, UpgradePolicy = vUpgradePolicy, VirtualMachineProfile = vVirtualMachineProfile, }; WriteObject(vVirtualMachineScaleSet); }
private void Run() { // Sku Microsoft.Azure.Management.Compute.Models.Sku vSku = null; // Plan Microsoft.Azure.Management.Compute.Models.Plan vPlan = null; // UpgradePolicy Microsoft.Azure.Management.Compute.Models.UpgradePolicy vUpgradePolicy = null; // VirtualMachineProfile Microsoft.Azure.Management.Compute.Models.VirtualMachineScaleSetVMProfile vVirtualMachineProfile = null; if (this.SkuName != null) { if (vSku == null) { vSku = new Microsoft.Azure.Management.Compute.Models.Sku(); } vSku.Name = this.SkuName; } if (this.SkuTier != null) { if (vSku == null) { vSku = new Microsoft.Azure.Management.Compute.Models.Sku(); } vSku.Tier = this.SkuTier; } if (this.SkuCapacity != null) { if (vSku == null) { vSku = new Microsoft.Azure.Management.Compute.Models.Sku(); } vSku.Capacity = this.SkuCapacity; } if (this.PlanName != null) { if (vPlan == null) { vPlan = new Microsoft.Azure.Management.Compute.Models.Plan(); } vPlan.Name = this.PlanName; } if (this.PlanPublisher != null) { if (vPlan == null) { vPlan = new Microsoft.Azure.Management.Compute.Models.Plan(); } vPlan.Publisher = this.PlanPublisher; } if (this.PlanProduct != null) { if (vPlan == null) { vPlan = new Microsoft.Azure.Management.Compute.Models.Plan(); } vPlan.Product = this.PlanProduct; } if (this.PlanPromotionCode != null) { if (vPlan == null) { vPlan = new Microsoft.Azure.Management.Compute.Models.Plan(); } vPlan.PromotionCode = this.PlanPromotionCode; } if (this.UpgradePolicyMode != null) { if (vUpgradePolicy == null) { vUpgradePolicy = new Microsoft.Azure.Management.Compute.Models.UpgradePolicy(); } vUpgradePolicy.Mode = this.UpgradePolicyMode; } if (this.OsProfile != null) { if (vVirtualMachineProfile == null) { vVirtualMachineProfile = new Microsoft.Azure.Management.Compute.Models.VirtualMachineScaleSetVMProfile(); } vVirtualMachineProfile.OsProfile = this.OsProfile; } if (this.StorageProfile != null) { if (vVirtualMachineProfile == null) { vVirtualMachineProfile = new Microsoft.Azure.Management.Compute.Models.VirtualMachineScaleSetVMProfile(); } vVirtualMachineProfile.StorageProfile = this.StorageProfile; } if (this.NetworkInterfaceConfiguration != null) { if (vVirtualMachineProfile == null) { vVirtualMachineProfile = new Microsoft.Azure.Management.Compute.Models.VirtualMachineScaleSetVMProfile(); } if (vVirtualMachineProfile.NetworkProfile == null) { vVirtualMachineProfile.NetworkProfile = new Microsoft.Azure.Management.Compute.Models.VirtualMachineScaleSetNetworkProfile(); } vVirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations = this.NetworkInterfaceConfiguration; } if (this.Extension != null) { if (vVirtualMachineProfile == null) { vVirtualMachineProfile = new Microsoft.Azure.Management.Compute.Models.VirtualMachineScaleSetVMProfile(); } if (vVirtualMachineProfile.ExtensionProfile == null) { vVirtualMachineProfile.ExtensionProfile = new Microsoft.Azure.Management.Compute.Models.VirtualMachineScaleSetExtensionProfile(); } vVirtualMachineProfile.ExtensionProfile.Extensions = this.Extension; } var vVirtualMachineScaleSet = new VirtualMachineScaleSet { Overprovision = this.Overprovision, SinglePlacementGroup = this.SinglePlacementGroup, Location = this.Location, Tags = (this.Tag == null) ? null : this.Tag.Cast <DictionaryEntry>().ToDictionary(ht => (string)ht.Key, ht => (string)ht.Value), Sku = vSku, Plan = vPlan, UpgradePolicy = vUpgradePolicy, VirtualMachineProfile = vVirtualMachineProfile, }; WriteObject(vVirtualMachineScaleSet); }
public void TestVMScaleSetBatchOperations() { using (MockContext context = MockContext.Start(this.GetType().FullName)) { EnsureClientsInitialized(context); ImageReference imageRef = GetPlatformVMImage(useWindowsImage: true); // Create resource group string rgName = TestUtilities.GenerateName(TestPrefix) + 1; var vmssName = TestUtilities.GenerateName("vmss"); string storageAccountName = TestUtilities.GenerateName(TestPrefix); VirtualMachineScaleSet inputVMScaleSet; bool passed = false; try { var storageAccountOutput = CreateStorageAccount(rgName, storageAccountName); VirtualMachineScaleSet vmScaleSet = CreateVMScaleSet_NoAsyncTracking( rgName: rgName, vmssName: vmssName, storageAccount: storageAccountOutput, imageRef: imageRef, inputVMScaleSet: out inputVMScaleSet, createWithManagedDisks: true, vmScaleSetCustomizer: (virtualMachineScaleSet) => virtualMachineScaleSet.UpgradePolicy = new UpgradePolicy { Mode = UpgradeMode.Manual } ); var virtualMachineScaleSetInstanceIDs = new List <string>() { "0", "1" }; m_CrpClient.VirtualMachineScaleSets.Start(rgName, vmScaleSet.Name, virtualMachineScaleSetInstanceIDs); virtualMachineScaleSetInstanceIDs = new List <string>() { "0" }; VirtualMachineScaleSetReimageParameters virtualMachineScaleSetReimageParameters = new VirtualMachineScaleSetReimageParameters { InstanceIds = virtualMachineScaleSetInstanceIDs }; m_CrpClient.VirtualMachineScaleSets.Reimage(rgName, vmScaleSet.Name, virtualMachineScaleSetReimageParameters); m_CrpClient.VirtualMachineScaleSets.ReimageAll(rgName, vmScaleSet.Name, virtualMachineScaleSetInstanceIDs); m_CrpClient.VirtualMachineScaleSets.PowerOff(rgName, vmScaleSet.Name, virtualMachineScaleSetInstanceIDs); m_CrpClient.VirtualMachineScaleSets.UpdateInstances(rgName, vmScaleSet.Name, virtualMachineScaleSetInstanceIDs); virtualMachineScaleSetInstanceIDs = new List <string>() { "1" }; m_CrpClient.VirtualMachineScaleSets.Restart(rgName, vmScaleSet.Name, virtualMachineScaleSetInstanceIDs); m_CrpClient.VirtualMachineScaleSets.Deallocate(rgName, vmScaleSet.Name, virtualMachineScaleSetInstanceIDs); m_CrpClient.VirtualMachineScaleSets.DeleteInstances(rgName, vmScaleSet.Name, virtualMachineScaleSetInstanceIDs); passed = true; } finally { m_ResourcesClient.ResourceGroups.DeleteIfExists(rgName); } Assert.True(passed); } }
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) { 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); } 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); 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 (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); } } }
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) { EnsureClientsInitialized(context); ImageReference imageRef = 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(), } }; 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); } VirtualMachineScaleSet getResponse = CreateVMScaleSet_NoAsyncTracking( rgName, vmssName, storageAccountOutput, imageRef, out inputVMScaleSet, useVmssExtension ? extensionProfile : null, (vmScaleSet) => { vmScaleSet.Overprovision = true; 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); 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"); } ValidateVMScaleSet(inputVMScaleSet, getResponse, hasManagedDisks, ppgId: ppgId); 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); 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); } } vmScaleSetValidator?.Invoke(getResponse); m_CrpClient.VirtualMachineScaleSets.Delete(rgName, vmssName); } finally { //Cleanup the created resources. But don't wait since it takes too long, and it's not the purpose //of the test to cover deletion. CSM does persistent retrying over all RG resources. m_ResourcesClient.ResourceGroups.Delete(rgName); } }
public static VirtualMachineScaleSet GetVirtualMachineScaleSet(this ArmClient armClient, ResourceIdentifier id) { VirtualMachineScaleSet.ValidateResourceId(id); return(armClient.UseClientContext((uri, credential, clientOptions, pipeline) => new VirtualMachineScaleSet(clientOptions, credential, uri, pipeline, id))); }
public async Task TestVMScaleSetBatchOperations() { EnsureClientsInitialized(DefaultLocation); ImageReference imageRef = await GetPlatformVMImage(useWindowsImage : true); // Create resource group string rgName = Recording.GenerateAssetName(TestPrefix) + 1; var vmssName = Recording.GenerateAssetName("vmss"); string storageAccountName = Recording.GenerateAssetName(TestPrefix); VirtualMachineScaleSet inputVMScaleSet; bool passed = false; var storageAccountOutput = await CreateStorageAccount(rgName, storageAccountName); var getTwoVirtualMachineScaleSet = await CreateVMScaleSet_NoAsyncTracking( rgName : rgName, vmssName : vmssName, storageAccount : storageAccountOutput, imageRef : imageRef, createWithManagedDisks : true, vmScaleSetCustomizer : (virtualMachineScaleSet) => virtualMachineScaleSet.UpgradePolicy = new UpgradePolicy { Mode = UpgradeMode.Manual } ); VirtualMachineScaleSet vmScaleSet = getTwoVirtualMachineScaleSet.Item1; inputVMScaleSet = getTwoVirtualMachineScaleSet.Item2; var virtualMachineScaleSetInstanceIDs = new VirtualMachineScaleSetVMInstanceIDs() { InstanceIds = { "0", "1" } }; var virtualMachineScaleSetRequ = new VirtualMachineScaleSetVMInstanceRequiredIDs(new List <string>() { "0", "1" }); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartStartAsync(rgName, vmScaleSet.Name, virtualMachineScaleSetInstanceIDs)); virtualMachineScaleSetInstanceIDs = new VirtualMachineScaleSetVMInstanceIDs() { InstanceIds = { "0", "1" } }; VirtualMachineScaleSetReimageParameters virtualMachineScaleSetReimageParameters = new VirtualMachineScaleSetReimageParameters { InstanceIds = { "0", "1" } }; await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartReimageAsync(rgName, vmScaleSet.Name, virtualMachineScaleSetReimageParameters)); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartReimageAllAsync(rgName, vmScaleSet.Name, virtualMachineScaleSetInstanceIDs)); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartPowerOffAsync(rgName, vmScaleSet.Name, null, virtualMachineScaleSetInstanceIDs)); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartUpdateInstancesAsync(rgName, vmScaleSet.Name, virtualMachineScaleSetRequ)); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartRestartAsync(rgName, vmScaleSet.Name, virtualMachineScaleSetInstanceIDs)); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartDeallocateAsync(rgName, vmScaleSet.Name, virtualMachineScaleSetInstanceIDs)); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartDeleteInstancesAsync(rgName, vmScaleSet.Name, virtualMachineScaleSetRequ)); passed = true; Assert.True(passed); }
public override void ExecuteCmdlet() { base.ExecuteCmdlet(); ExecuteClientAction(() => { if (this.ShouldProcess(VMScaleSetName, Properties.Resources.RemoveDiskEncryptionAction) && (this.Force.IsPresent || this.ShouldContinue(Properties.Resources.VirtualMachineExtensionRemovalConfirmation, Properties.Resources.VirtualMachineExtensionRemovalCaption))) { VirtualMachineScaleSet vmss = this.VirtualMachineScaleSetClient.Get(this.ResourceGroupName, this.VMScaleSetName); if (vmss == null || vmss.VirtualMachineProfile == null) { ThrowTerminatingError(new ErrorRecord( new ArgumentException("The given VM Scale Set does not exist."), "InvalidArgument", ErrorCategory.InvalidArgument, null)); } SetOSType(vmss.VirtualMachineProfile); if (OperatingSystemTypes.Windows.Equals(this.CurrentOSType)) { this.ExtensionName = this.ExtensionName ?? AzureVmssDiskEncryptionExtensionContext.ExtensionDefaultName; } else if (OperatingSystemTypes.Linux.Equals(this.CurrentOSType)) { this.ExtensionName = this.ExtensionName ?? AzureVmssDiskEncryptionExtensionContext.LinuxExtensionDefaultName; } this.VolumeType = GetVolumeType(this.VolumeType, vmss.VirtualMachineProfile.StorageProfile); if (vmss.VirtualMachineProfile.ExtensionProfile == null || vmss.VirtualMachineProfile.ExtensionProfile.Extensions == null || vmss.VirtualMachineProfile.ExtensionProfile.Extensions.Count == 0) { ThrowTerminatingError(new ErrorRecord( new ArgumentException("Disk Encryption extension is not installed in the VM Scale Set."), "InvalidArgument", ErrorCategory.InvalidArgument, null)); } foreach (var ext in vmss.VirtualMachineProfile.ExtensionProfile.Extensions) { if (ext.Name.Equals(this.ExtensionName)) { ext.Settings = GetDisalbeEncryptionSetting(); ext.ProtectedSettings = null; ext.ForceUpdateTag = this.ForceUpdate.IsPresent ? Guid.NewGuid().ToString() : null; VirtualMachineScaleSetExtension result = this.VirtualMachineScaleSetExtensionsClient.CreateOrUpdate( this.ResourceGroupName, this.VMScaleSetName, this.ExtensionName, ext); var psResult = result.ToPSVirtualMachineScaleSetExtension(this.ResourceGroupName, this.VMScaleSetName); WriteObject(psResult); break; } ThrowTerminatingError(new ErrorRecord( new ArgumentException(string.Format("Extension, {0}, is not installed in the VM Scale Set.", this.ExtensionName)), "InvalidArgument", ErrorCategory.InvalidArgument, null)); } } }); }
private async Task TestVMScaleSetPriorityOperationsInternal( string priority, BillingProfile billingProfile = null, VirtualMachineEvictionPolicyTypes?evictionPolicy = null, bool hasManagedDisks = false, IList <string> zones = null ) { string originalTestLocation = Environment.GetEnvironmentVariable("AZURE_VM_TEST_LOCATION"); // Create resource group var rgName = Recording.GenerateAssetName(TestPrefix); var vmssName = Recording.GenerateAssetName("vmss"); string storageAccountName = Recording.GenerateAssetName(TestPrefix); VirtualMachineScaleSet inputVMScaleSet; ImageReference imageRef = await GetPlatformVMImage(useWindowsImage : true); var storageAccountOutput = await CreateStorageAccount(rgName, storageAccountName); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartDeleteAsync(rgName, "VMScaleSetDoesNotExist")); var getTwoVirtualMachineScaleSet = await CreateVMScaleSet_NoAsyncTracking( rgName, vmssName, storageAccountOutput, imageRef, null, (vmScaleSet) => { vmScaleSet.Overprovision = true; vmScaleSet.VirtualMachineProfile.Priority = priority; vmScaleSet.VirtualMachineProfile.EvictionPolicy = evictionPolicy; vmScaleSet.VirtualMachineProfile.BillingProfile = billingProfile; vmScaleSet.Sku.Name = VirtualMachineSizeTypes.StandardA1.ToString(); vmScaleSet.Sku.Tier = "Standard"; vmScaleSet.Sku.Capacity = 2; }, createWithManagedDisks : hasManagedDisks, zones : zones); VirtualMachineScaleSet getResponse = getTwoVirtualMachineScaleSet.Item1; inputVMScaleSet = getTwoVirtualMachineScaleSet.Item2; ValidateVMScaleSet(inputVMScaleSet, getResponse, hasManagedDisks); var getInstanceViewResponse = await VirtualMachineScaleSetsOperations.GetInstanceViewAsync(rgName, vmssName); Assert.NotNull(getInstanceViewResponse); ValidateVMScaleSetInstanceView(inputVMScaleSet, getInstanceViewResponse); var listResponse = await(VirtualMachineScaleSetsOperations.ListAsync(rgName)).ToEnumerableAsync(); ValidateVMScaleSet( inputVMScaleSet, listResponse.FirstOrDefault(x => x.Name == vmssName), hasManagedDisks); var listSkusResp = VirtualMachineScaleSetsOperations.ListSkusAsync(rgName, vmssName); var listSkusResponse = await listSkusResp.ToEnumerableAsync(); Assert.NotNull(listSkusResponse); Assert.False(listSkusResponse.Count() == 0); Assert.AreEqual(inputVMScaleSet.VirtualMachineProfile.Priority.ToString(), priority); //Assert.Same(inputVMScaleSet.VirtualMachineProfile.Priority.ToString(), priority); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartDeleteAsync(rgName, vmssName)); }
private async Task TestScaleSetOperationsInternal(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) { ImageReference imageRef = await GetPlatformVMImage(useWindowsImage : true); // Create resource group var rgName = Recording.GenerateAssetName(TestPrefix); var vmssName = Recording.GenerateAssetName("vmss"); string storageAccountName = Recording.GenerateAssetName(TestPrefix); VirtualMachineScaleSet inputVMScaleSet; VirtualMachineScaleSetExtensionProfile extensionProfile = new VirtualMachineScaleSetExtensionProfile() { Extensions = { GetTestVMSSVMExtension(), } }; var storageAccountOutput = await CreateStorageAccount(rgName, storageAccountName); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartDeleteAsync(rgName, "VMScaleSetDoesNotExist")); string ppgId = null; string ppgName = null; if (isPpgScenario) { ppgName = Recording.GenerateAssetName("ppgtest"); ppgId = await CreateProximityPlacementGroup(rgName, ppgName); } var getTwoVirtualMachineScaleSet = await CreateVMScaleSet_NoAsyncTracking( rgName, vmssName, storageAccountOutput, imageRef, useVmssExtension?extensionProfile : null, (vmScaleSet) => { vmScaleSet.Overprovision = true; 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); VirtualMachineScaleSet getResponse = getTwoVirtualMachineScaleSet.Item1; inputVMScaleSet = getTwoVirtualMachineScaleSet.Item2; 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.AreEqual(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"); } ValidateVMScaleSet(inputVMScaleSet, getResponse, hasManagedDisks, ppgId: ppgId); var getInstanceViewResponse = await VirtualMachineScaleSetsOperations.GetInstanceViewAsync(rgName, vmssName); Assert.NotNull(getInstanceViewResponse); ValidateVMScaleSetInstanceView(inputVMScaleSet, getInstanceViewResponse); if (isPpgScenario) { ProximityPlacementGroup outProximityPlacementGroup = await ProximityPlacementGroupsOperations.GetAsync(rgName, ppgName); Assert.AreEqual(1, outProximityPlacementGroup.VirtualMachineScaleSets.Count); string expectedVmssReferenceId = Helpers.GetVMScaleSetReferenceId(m_subId, rgName, vmssName); Assert.AreEqual(expectedVmssReferenceId.ToLower(), outProximityPlacementGroup.VirtualMachineScaleSets.First().Id.ToLower()); } var listResponse = await(VirtualMachineScaleSetsOperations.ListAsync(rgName)).ToEnumerableAsync(); ValidateVMScaleSet(inputVMScaleSet, listResponse.FirstOrDefault(x => x.Name == vmssName), hasManagedDisks); var listSkusResponse = await(VirtualMachineScaleSetsOperations.ListSkusAsync(rgName, vmssName)).ToEnumerableAsync(); Assert.NotNull(listSkusResponse); Assert.False(listSkusResponse.Count() == 0); if (zones != null) { var query = "properties/latestModelApplied eq true"; var listVMsResponse = await(VirtualMachineScaleSetVMsOperations.ListAsync(rgName, vmssName, query)).ToEnumerableAsync(); 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 = await VirtualMachineScaleSetVMsOperations.GetAsync(rgName, vmssName, instanceId); ValidateVMScaleSetVM(inputVMScaleSet, instanceId, getVMResponse, hasManagedDisks); } } vmScaleSetValidator?.Invoke(getResponse); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartDeleteAsync(rgName, vmssName)); }
private void TestVMScaleSetVMOperationsInternal(MockContext context, bool hasManagedDisks = false) { InitializeCommon(context); instanceId = "0"; bool passed = false; try { var storageAccountOutput = CreateStorageAccount(rgName, storageAccountName); VirtualMachineScaleSet vmScaleSet = CreateVMScaleSet_NoAsyncTracking( rgName, vmssName, storageAccountOutput, imageRef, out inputVMScaleSet, createWithManagedDisks: hasManagedDisks); var getResponse = m_CrpClient.VirtualMachineScaleSetVMs.Get(rgName, vmScaleSet.Name, instanceId); VirtualMachineScaleSetVM vmScaleSetVMModel = GenerateVMScaleSetVMModel(vmScaleSet, instanceId, hasManagedDisks); ValidateVMScaleSetVM(vmScaleSetVMModel, vmScaleSet.Sku.Name, getResponse, hasManagedDisks); var getInstanceViewResponse = m_CrpClient.VirtualMachineScaleSetVMs.GetInstanceView(rgName, vmScaleSet.Name, instanceId); Assert.True(getInstanceViewResponse != null, "VMScaleSetVM not returned."); ValidateVMScaleSetVMInstanceView(getInstanceViewResponse, hasManagedDisks); var query = new Microsoft.Rest.Azure.OData.ODataQuery <VirtualMachineScaleSetVM>(); query.SetFilter(vm => vm.LatestModelApplied == true); var listResponse = m_CrpClient.VirtualMachineScaleSetVMs.List(rgName, vmssName, query); Assert.False(listResponse == null, "VMScaleSetVMs not returned"); Assert.True(listResponse.Count() == inputVMScaleSet.Sku.Capacity); query.Filter = null; query.Expand = "instanceView"; listResponse = m_CrpClient.VirtualMachineScaleSetVMs.List(rgName, vmssName, query, "instanceView"); Assert.False(listResponse == null, "VMScaleSetVMs not returned"); Assert.True(listResponse.Count() == inputVMScaleSet.Sku.Capacity); m_CrpClient.VirtualMachineScaleSetVMs.Start(rgName, vmScaleSet.Name, instanceId); m_CrpClient.VirtualMachineScaleSetVMs.Reimage(rgName, vmScaleSet.Name, instanceId, tempDisk: null); if (hasManagedDisks) { m_CrpClient.VirtualMachineScaleSetVMs.ReimageAll(rgName, vmScaleSet.Name, instanceId); } m_CrpClient.VirtualMachineScaleSetVMs.Restart(rgName, vmScaleSet.Name, instanceId); m_CrpClient.VirtualMachineScaleSetVMs.PowerOff(rgName, vmScaleSet.Name, instanceId); m_CrpClient.VirtualMachineScaleSetVMs.Deallocate(rgName, vmScaleSet.Name, instanceId); m_CrpClient.VirtualMachineScaleSetVMs.Delete(rgName, vmScaleSet.Name, instanceId); passed = true; } finally { // Cleanup the created resources. But don't wait since it takes too long, and it's not the purpose // of the test to cover deletion. CSM does persistent retrying over all RG resources. m_ResourcesClient.ResourceGroups.Delete(rgName); } Assert.True(passed); }
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) { // Generate Container name to hold disk VHds string containerName = Recording.GenerateAssetName(TestPrefix); var vhdContainer = "https://" + storageAccountName + ".blob.core.windows.net/" + containerName; var vmssName = Recording.GenerateAssetName("vmss"); bool createOSDisk = !hasManagedDisks || osDiskSizeInGB != null; string vmSize = zones == null?VirtualMachineSizeTypes.StandardA0.ToString() : VirtualMachineSizeTypes.StandardA1V2.ToString(); var test1 = Recording.GenerateAssetName("vmsstestnetconfig"); var test2 = Recording.GenerateAssetName("vmsstestnetconfig"); var virtualMachineScaleSetIpConfiguration = new VirtualMachineScaleSetIPConfiguration(test2) { Subnet = new Azure.ResourceManager.Compute.Models.ApiEntityReference() { Id = subnetId } }; virtualMachineScaleSetIpConfiguration.ApplicationGatewayBackendAddressPools.Clear(); if (loadBalancerBackendPoolId != null) { virtualMachineScaleSetIpConfiguration.LoadBalancerBackendAddressPools.Add(new Models.SubResource(loadBalancerBackendPoolId)); } var virtualMachineScaleSetOsDisk = !createOSDisk ? null : new VirtualMachineScaleSetOSDisk(DiskCreateOptionTypes.FromImage) { Caching = CachingTypes.None, Name = hasManagedDisks ? null : "test", DiskSizeGB = osDiskSizeInGB, ManagedDisk = diskEncryptionSetId == null ? null : new VirtualMachineScaleSetManagedDiskParameters() { StorageAccountType = StorageAccountTypes.StandardLRS, DiskEncryptionSet = new DiskEncryptionSetParameters() { Id = diskEncryptionSetId } } }; if (!hasManagedDisks) { virtualMachineScaleSetOsDisk?.VhdContainers.Add(vhdContainer); } var virtualMachineScaleSetStorageProfile = new VirtualMachineScaleSetStorageProfile() { ImageReference = imageRef, OsDisk = virtualMachineScaleSetOsDisk }; if (hasManagedDisks) { virtualMachineScaleSetStorageProfile.DataDisks.Add(new VirtualMachineScaleSetDataDisk(1, DiskCreateOptionTypes.Empty) { DiskSizeGB = 128, ManagedDisk = diskEncryptionSetId == null ? null : new VirtualMachineScaleSetManagedDiskParameters() { StorageAccountType = StorageAccountTypes.StandardLRS, DiskEncryptionSet = new DiskEncryptionSetParameters() { Id = diskEncryptionSetId } } }); } var vmScaleSet = new VirtualMachineScaleSet(m_location) { Location = m_location, Tags = { { "RG", "rg" }, { "testTag", "1" } }, Sku = new CM.Sku() { Capacity = 2, Name = machineSizeType == null ? vmSize : machineSizeType }, Overprovision = false, UpgradePolicy = new UpgradePolicy() { Mode = UpgradeMode.Automatic }, VirtualMachineProfile = new VirtualMachineScaleSetVMProfile() { StorageProfile = virtualMachineScaleSetStorageProfile, 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 VirtualMachineScaleSetNetworkConfiguration(test1) { Primary = true, IpConfigurations = { virtualMachineScaleSetIpConfiguration } } } }, ExtensionProfile = new VirtualMachineScaleSetExtensionProfile(), }, AutomaticRepairsPolicy = automaticRepairsPolicy }; vmScaleSet.Zones.InitializeFrom(zones); 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); }
internal static ResourceConfig <VirtualMachineScaleSet> CreateVirtualMachineScaleSetConfig( this ResourceConfig <ResourceGroup> resourceGroup, string name, NestedResourceConfig <Subnet, VirtualNetwork> subnet, IEnumerable <NestedResourceConfig <FrontendIPConfiguration, LoadBalancer> > frontendIpConfigurations, NestedResourceConfig <BackendAddressPool, LoadBalancer> backendAdressPool, Func <ImageAndOsType> getImageAndOsType, string adminUsername, string adminPassword, string vmSize, int instanceCount, UpgradeMode?upgradeMode) => Strategy.CreateResourceConfig( resourceGroup: resourceGroup, name: name, createModel: subscriptionId => { var imageAndOsType = getImageAndOsType(); var vmss = new VirtualMachineScaleSet() { Zones = frontendIpConfigurations ?.Select(f => f.CreateModel(subscriptionId)) ?.Where(z => z?.Zones != null) .SelectMany(z => z.Zones) .Where(z => z != null) .ToList(), UpgradePolicy = new UpgradePolicy { Mode = upgradeMode ?? UpgradeMode.Manual }, Sku = new Azure.Management.Compute.Models.Sku() { Capacity = instanceCount, Name = vmSize, }, VirtualMachineProfile = new VirtualMachineScaleSetVMProfile() }; vmss.VirtualMachineProfile.OsProfile = new VirtualMachineScaleSetOSProfile { ComputerNamePrefix = name.Substring(0, Math.Min(name.Length, 9)), WindowsConfiguration = imageAndOsType.OsType == OperatingSystemTypes.Windows ? new WindowsConfiguration() : null, LinuxConfiguration = imageAndOsType.OsType == OperatingSystemTypes.Linux ? new LinuxConfiguration() : null, AdminUsername = adminUsername, AdminPassword = adminPassword, }; vmss.VirtualMachineProfile.StorageProfile = new VirtualMachineScaleSetStorageProfile { ImageReference = imageAndOsType.Image }; var ipConfig = new VirtualMachineScaleSetIPConfiguration { Name = name, LoadBalancerBackendAddressPools = new[] { new Azure.Management.Compute.Models.SubResource( id: backendAdressPool.GetId(subscriptionId).IdToString()) }, Subnet = new ApiEntityReference { Id = subnet.GetId(subscriptionId).IdToString() } }; vmss.VirtualMachineProfile.NetworkProfile = new VirtualMachineScaleSetNetworkProfile { NetworkInterfaceConfigurations = new[] { new VirtualMachineScaleSetNetworkConfiguration { Name = name, IpConfigurations = new [] { ipConfig }, Primary = true } } }; return(vmss); }, dependencies: new IEntityConfig[] { subnet, backendAdressPool } .Concat(frontendIpConfigurations));
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) { // 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); if (vmScaleSetCustomizer != null) { vmScaleSetCustomizer(inputVMScaleSet); } 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 }; } 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); return(createOrUpdateResponse); }
public void TestFlexVMScaleSetWithPublicIP() { using (MockContext context = MockContext.Start(this.GetType())) { string originalTestLocation = Environment.GetEnvironmentVariable("AZURE_VM_TEST_LOCATION"); // Create resource group string rgName = TestUtilities.GenerateName(TestPrefix) + 1; var vmssName = TestUtilities.GenerateName("vmss"); var dnsname = TestUtilities.GenerateName("dnsname"); string storageAccountName = TestUtilities.GenerateName(TestPrefix); VirtualMachineScaleSet inputVMScaleSet; bool passed = false; try { Environment.SetEnvironmentVariable("AZURE_VM_TEST_LOCATION", "eastus2euap"); EnsureClientsInitialized(context); ImageReference imageRef = GetPlatformVMImage(useWindowsImage: true); var storageAccountOutput = CreateStorageAccount(rgName, storageAccountName); var vnetResponse = CreateVNETWithSubnets(rgName, 2); var vmssSubnet = vnetResponse.Subnets[1]; var publicipConfiguration = new VirtualMachineScaleSetPublicIPAddressConfiguration(); publicipConfiguration.Name = "pip1"; publicipConfiguration.IdleTimeoutInMinutes = 10; publicipConfiguration.DnsSettings = new VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettings(); publicipConfiguration.DnsSettings.DomainNameLabel = dnsname; publicipConfiguration.DeleteOption = DeleteOptions.Detach.ToString(); VirtualMachineScaleSet vmScaleSet = CreateVMScaleSet_NoAsyncTracking( rgName: rgName, vmssName: vmssName, storageAccount: null, imageRef: imageRef, inputVMScaleSet: out inputVMScaleSet, singlePlacementGroup: false, createWithManagedDisks: true, vmScaleSetCustomizer: (virtualMachineScaleSet) => { virtualMachineScaleSet.UpgradePolicy = null; virtualMachineScaleSet.Overprovision = null; virtualMachineScaleSet.PlatformFaultDomainCount = 1; virtualMachineScaleSet.VirtualMachineProfile.NetworkProfile.NetworkApiVersion = NetworkApiVersion.TwoZeroTwoZeroHyphenMinusOneOneHyphenMinusZeroOne; virtualMachineScaleSet.VirtualMachineProfile.NetworkProfile .NetworkInterfaceConfigurations[0].DeleteOption = DeleteOptions.Delete.ToString(); virtualMachineScaleSet.VirtualMachineProfile.NetworkProfile .NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration = publicipConfiguration; virtualMachineScaleSet.OrchestrationMode = OrchestrationMode.Flexible.ToString(); virtualMachineScaleSet.VirtualMachineProfile.StorageProfile.DataDisks = null; }, createWithPublicIpAddress: false, subnet: vmssSubnet); var vmss = m_CrpClient.VirtualMachineScaleSets.Get(rgName, vmssName); Assert.NotNull(vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration); Assert.Equal("pip1", vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.Name); Assert.Equal(10, vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.IdleTimeoutInMinutes); Assert.NotNull(vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.DnsSettings); Assert.Equal(dnsname, vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.DnsSettings.DomainNameLabel); passed = true; m_CrpClient.VirtualMachineScaleSets.Delete(rgName, vmssName); } finally { Environment.SetEnvironmentVariable("AZURE_VM_TEST_LOCATION", originalTestLocation); m_ResourcesClient.ResourceGroups.DeleteIfExists(rgName); } Assert.True(passed); } }
public async Task TestVMScaleSetWithPublicIPAndIPTags() { EnsureClientsInitialized(LocationWestCentralUs); // Create resource group string rgName = Recording.GenerateAssetName(TestPrefix) + 1; var vmssName = Recording.GenerateAssetName("vmss"); var dnsname = Recording.GenerateAssetName("dnsname"); string storageAccountName = Recording.GenerateAssetName(TestPrefix); VirtualMachineScaleSet inputVMScaleSet; bool passed = false; // Hard code the location to "westcentralus". // This is because NRP is still deploying to other regions and is not available worldwide. // Before changing the default location, we have to save it to be reset it at the end of the test. // Since ComputeManagementTestUtilities.DefaultLocation is a static variable and can affect other tests if it is not reset. ImageReference imageRef = await GetPlatformVMImage(useWindowsImage : true); var storageAccountOutput = await CreateStorageAccount(rgName, storageAccountName); var vnetResponse = await CreateVNETWithSubnets(rgName, 2); var vmssSubnet = vnetResponse.Subnets[1]; var publicipConfiguration = new VirtualMachineScaleSetPublicIPAddressConfiguration("pip1"); //publicipConfiguration.Name = "pip1"; publicipConfiguration.IdleTimeoutInMinutes = 10; publicipConfiguration.DnsSettings = new VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettings(dnsname); //publicipConfiguration.DnsSettings.DomainNameLabel = dnsname; publicipConfiguration.IpTags.Add(new VirtualMachineScaleSetIpTag("FirstPartyUsage", "/Sql")); var getTwoVirtualMachineScaleSet = await CreateVMScaleSet_NoAsyncTracking( rgName : rgName, vmssName : vmssName, storageAccount : storageAccountOutput, imageRef : imageRef, vmScaleSetCustomizer : (virtualMachineScaleSet) => virtualMachineScaleSet.VirtualMachineProfile.NetworkProfile .NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration = publicipConfiguration, createWithPublicIpAddress : false, subnet : vmssSubnet); VirtualMachineScaleSet vmScaleSet = getTwoVirtualMachineScaleSet.Item1; inputVMScaleSet = getTwoVirtualMachineScaleSet.Item2; var vmss = (await VirtualMachineScaleSetsOperations.GetAsync(rgName, vmssName)).Value; Assert.NotNull(vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration); Assert.AreEqual("pip1", vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.Name); Assert.AreEqual(10, vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.IdleTimeoutInMinutes); Assert.NotNull(vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.DnsSettings); Assert.AreEqual(dnsname, vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.DnsSettings.DomainNameLabel); Assert.NotNull(vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.IpTags); Assert.AreEqual("FirstPartyUsage", vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.IpTags[0].IpTagType); Assert.AreEqual("/Sql", vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.IpTags[0].Tag); passed = true; Assert.True(passed); }
public void TestVMScaleSetWithPublicIPAndIPTags() { using (MockContext context = MockContext.Start(this.GetType())) { string originalTestLocation = Environment.GetEnvironmentVariable("AZURE_VM_TEST_LOCATION"); // Create resource group string rgName = TestUtilities.GenerateName(TestPrefix) + 1; var vmssName = TestUtilities.GenerateName("vmss"); var dnsname = TestUtilities.GenerateName("dnsname"); string storageAccountName = TestUtilities.GenerateName(TestPrefix); VirtualMachineScaleSet inputVMScaleSet; bool passed = false; try { // Hard code the location to "westcentralus". // This is because NRP is still deploying to other regions and is not available worldwide. // Before changing the default location, we have to save it to be reset it at the end of the test. // Since ComputeManagementTestUtilities.DefaultLocation is a static variable and can affect other tests if it is not reset. Environment.SetEnvironmentVariable("AZURE_VM_TEST_LOCATION", "eastus2"); EnsureClientsInitialized(context); ImageReference imageRef = GetPlatformVMImage(useWindowsImage: true); var storageAccountOutput = CreateStorageAccount(rgName, storageAccountName); var vnetResponse = CreateVNETWithSubnets(rgName, 2); var vmssSubnet = vnetResponse.Subnets[1]; var publicipConfiguration = new VirtualMachineScaleSetPublicIPAddressConfiguration(); publicipConfiguration.Name = "pip1"; publicipConfiguration.IdleTimeoutInMinutes = 10; publicipConfiguration.DnsSettings = new VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettings(); publicipConfiguration.DnsSettings.DomainNameLabel = dnsname; publicipConfiguration.IpTags = new List <VirtualMachineScaleSetIpTag> { new VirtualMachineScaleSetIpTag("FirstPartyUsage", "/Sql") }; VirtualMachineScaleSet vmScaleSet = CreateVMScaleSet_NoAsyncTracking( rgName: rgName, vmssName: vmssName, storageAccount: storageAccountOutput, imageRef: imageRef, inputVMScaleSet: out inputVMScaleSet, vmScaleSetCustomizer: (virtualMachineScaleSet) => virtualMachineScaleSet.VirtualMachineProfile.NetworkProfile .NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration = publicipConfiguration, createWithPublicIpAddress: false, subnet: vmssSubnet); var vmss = m_CrpClient.VirtualMachineScaleSets.Get(rgName, vmssName); Assert.NotNull(vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration); Assert.Equal("pip1", vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.Name); Assert.Equal(10, vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.IdleTimeoutInMinutes); Assert.NotNull(vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.DnsSettings); Assert.Equal(dnsname, vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.DnsSettings.DomainNameLabel); Assert.NotNull(vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.IpTags); Assert.Equal("FirstPartyUsage", vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.IpTags[0].IpTagType); Assert.Equal("/Sql", vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.IpTags[0].Tag); passed = true; } finally { Environment.SetEnvironmentVariable("AZURE_VM_TEST_LOCATION", originalTestLocation); m_ResourcesClient.ResourceGroups.DeleteIfExists(rgName); } Assert.True(passed); } }
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 machineSizeType = 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); if (vmScaleSetCustomizer != null) { vmScaleSetCustomizer(inputVMScaleSet); } if (hasDiffDisks) { VirtualMachineScaleSetOSDisk osDisk = new VirtualMachineScaleSetOSDisk(); osDisk.Caching = CachingTypes.ReadOnly; osDisk.CreateOption = DiskCreateOptionTypes.FromImage; osDisk.DiffDiskSettings = new DiffDiskSettings { Option = DiffDiskOptions.Local }; inputVMScaleSet.VirtualMachineProfile.StorageProfile.OsDisk = osDisk; } inputVMScaleSet.VirtualMachineProfile.ExtensionProfile = extensionProfile; var createOrUpdateResponse = m_CrpClient.VirtualMachineScaleSets.CreateOrUpdate(rgName, vmssName, inputVMScaleSet); Assert.True(createOrUpdateResponse.Name == vmssName); Assert.True(createOrUpdateResponse.Location.ToLower() == inputVMScaleSet.Location.ToLower().Replace(" ", "")); ValidateVMScaleSet(inputVMScaleSet, createOrUpdateResponse, createWithManagedDisks); return(createOrUpdateResponse); }
public void TestVMScaleSetWithPublicIPAndPublicIPPrefix() { using (MockContext context = MockContext.Start(this.GetType())) { string originalTestLocation = Environment.GetEnvironmentVariable("AZURE_VM_TEST_LOCATION"); if (originalTestLocation == null) { originalTestLocation = String.Empty; } // Create resource group string rgName = TestUtilities.GenerateName(TestPrefix) + 1; var vmssName = TestUtilities.GenerateName("vmss"); var dnsname = TestUtilities.GenerateName("dnsname"); string storageAccountName = TestUtilities.GenerateName(TestPrefix); VirtualMachineScaleSet inputVMScaleSet; bool passed = false; try { EnsureClientsInitialized(context); ImageReference imageRef = GetPlatformVMImage(useWindowsImage: true); var storageAccountOutput = CreateStorageAccount(rgName, storageAccountName); var vnetResponse = CreateVNETWithSubnets(rgName, 2); var vmssSubnet = vnetResponse.Subnets[1]; var publicIpPrefix = CreatePublicIPPrefix(rgName, 30); var publicipConfiguration = new VirtualMachineScaleSetPublicIPAddressConfiguration(); publicipConfiguration.Name = "pip1"; publicipConfiguration.IdleTimeoutInMinutes = 10; publicipConfiguration.DnsSettings = new VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettings(); publicipConfiguration.DnsSettings.DomainNameLabel = dnsname; publicipConfiguration.PublicIPPrefix = new Microsoft.Azure.Management.Compute.Models.SubResource(); publicipConfiguration.PublicIPPrefix.Id = publicIpPrefix.Id; VirtualMachineScaleSet vmScaleSet = CreateVMScaleSet_NoAsyncTracking( rgName: rgName, vmssName: vmssName, storageAccount: storageAccountOutput, imageRef: imageRef, inputVMScaleSet: out inputVMScaleSet, vmScaleSetCustomizer: (virtualMachineScaleSet) => virtualMachineScaleSet.VirtualMachineProfile.NetworkProfile .NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration = publicipConfiguration, createWithPublicIpAddress: false, subnet: vmssSubnet); var vmss = m_CrpClient.VirtualMachineScaleSets.Get(rgName, vmssName); Assert.NotNull(vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration); Assert.Equal("pip1", vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.Name); Assert.Equal(10, vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.IdleTimeoutInMinutes); Assert.NotNull(vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.DnsSettings); Assert.Equal(dnsname, vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.DnsSettings.DomainNameLabel); Assert.Equal(publicIpPrefix.Id, vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.PublicIPPrefix.Id); passed = true; } finally { Environment.SetEnvironmentVariable("AZURE_VM_TEST_LOCATION", originalTestLocation); m_ResourcesClient.ResourceGroups.DeleteIfExists(rgName); } Assert.True(passed); } }
internal Task AddCertToVmssTask(VirtualMachineScaleSet vmss, CertificateInformation certInformation) { var secretGroup = vmss.VirtualMachineProfile.OsProfile.Secrets.SingleOrDefault( s => s.SourceVault.Id.Equals(certInformation.KeyVault.Id, StringComparison.OrdinalIgnoreCase)); if (secretGroup == null) { vmss.VirtualMachineProfile.OsProfile.Secrets.Add( new VaultSecretGroup() { SourceVault = new Management.Compute.Models.SubResource() { Id = certInformation.KeyVault.Id }, VaultCertificates = new List <VaultCertificate>() { new VaultCertificate() { CertificateStore = Constants.DefaultCertificateStore, CertificateUrl = certInformation.SecretUrl } } }); } else { if (secretGroup.VaultCertificates != null) { var exsit = secretGroup.VaultCertificates.Any( cert => cert.CertificateUrl.Equals(certInformation.SecretUrl, StringComparison.OrdinalIgnoreCase)); if (!exsit) { secretGroup.VaultCertificates.Add( new VaultCertificate() { CertificateStore = Constants.DefaultCertificateStore, CertificateUrl = certInformation.SecretUrl }); } } else { secretGroup.VaultCertificates = new List <VaultCertificate>() { new VaultCertificate() { CertificateStore = Constants.DefaultCertificateStore, CertificateUrl = certInformation.SecretUrl } }; } } return(ComputeClient.VirtualMachineScaleSets.CreateOrUpdateAsync( this.ResourceGroupName, vmss.Name, vmss)); }
//[Trait("Name", "TestVMScaleSetScenarioOperations_AutomaticRepairsPolicyTest")] public async Task TestVMScaleSetScenarioOperations_AutomaticRepairsPolicyTest() { EnsureClientsInitialized(LocationEastUs2); ImageReference imageRef = await GetPlatformVMImage(useWindowsImage : true); // Create resource group var rgName = Recording.GenerateAssetName(TestPrefix); var vmssName = Recording.GenerateAssetName("vmss"); string storageAccountName = Recording.GenerateAssetName(TestPrefix); VirtualMachineScaleSet inputVMScaleSet; var storageAccountOutput = await CreateStorageAccount(rgName, storageAccountName); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartDeleteAsync(rgName, "VMScaleSetDoesNotExist")); var getTwoVirtualMachineScaleSet = await CreateVMScaleSet_NoAsyncTracking( rgName, vmssName, storageAccountOutput, imageRef, null, (vmScaleSet) => { vmScaleSet.Overprovision = false; }, createWithManagedDisks : true, createWithPublicIpAddress : false, createWithHealthProbe : true); VirtualMachineScaleSet getResponse = getTwoVirtualMachineScaleSet.Item1; inputVMScaleSet = getTwoVirtualMachineScaleSet.Item2; ValidateVMScaleSet(inputVMScaleSet, getResponse, hasManagedDisks: true); // Set Automatic Repairs to true inputVMScaleSet.AutomaticRepairsPolicy = new AutomaticRepairsPolicy() { Enabled = true }; await UpdateVMScaleSet(rgName, vmssName, inputVMScaleSet); getResponse = await VirtualMachineScaleSetsOperations.GetAsync(rgName, vmssName); Assert.NotNull(getResponse.AutomaticRepairsPolicy); ValidateVMScaleSet(inputVMScaleSet, getResponse, hasManagedDisks: true); // Update Automatic Repairs default values inputVMScaleSet.AutomaticRepairsPolicy = new AutomaticRepairsPolicy() { Enabled = true, GracePeriod = "PT35M" }; await UpdateVMScaleSet(rgName, vmssName, inputVMScaleSet); getResponse = await VirtualMachineScaleSetsOperations.GetAsync(rgName, vmssName); Assert.NotNull(getResponse.AutomaticRepairsPolicy); ValidateVMScaleSet(inputVMScaleSet, getResponse, hasManagedDisks: true); // Set automatic repairs to null inputVMScaleSet.AutomaticRepairsPolicy = null; await UpdateVMScaleSet(rgName, vmssName, inputVMScaleSet); getResponse = await VirtualMachineScaleSetsOperations.GetAsync(rgName, vmssName); ValidateVMScaleSet(inputVMScaleSet, getResponse, hasManagedDisks: true); Assert.NotNull(getResponse.AutomaticRepairsPolicy); Assert.True(getResponse.AutomaticRepairsPolicy.Enabled == true); Assert.AreEqual("PT35M", getResponse.AutomaticRepairsPolicy.GracePeriod); // Disable Automatic Repairs inputVMScaleSet.AutomaticRepairsPolicy = new AutomaticRepairsPolicy() { Enabled = false }; await UpdateVMScaleSet(rgName, vmssName, inputVMScaleSet); getResponse = await VirtualMachineScaleSetsOperations.GetAsync(rgName, vmssName); Assert.NotNull(getResponse.AutomaticRepairsPolicy); Assert.True(getResponse.AutomaticRepairsPolicy.Enabled == false); }
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) { 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); 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; } }
//[Trait("Name", "TestVMScaleSetScenarioOperations_OrchestrationService")] public async Task TestVMScaleSetScenarioOperations_OrchestrationService() { EnsureClientsInitialized(LocationNorthEurope); ImageReference imageRef = await GetPlatformVMImage(useWindowsImage : true); // Create resource group var rgName = Recording.GenerateAssetName(TestPrefix); var vmssName = Recording.GenerateAssetName("vmss"); string storageAccountName = Recording.GenerateAssetName(TestPrefix); VirtualMachineScaleSet inputVMScaleSet; var storageAccountOutput = await CreateStorageAccount(rgName, storageAccountName); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartDeleteAsync(rgName, "VMScaleSetDoesNotExist")); AutomaticRepairsPolicy automaticRepairsPolicy = new AutomaticRepairsPolicy() { Enabled = true }; var getTwoVirtualMachineScaleSet = await CreateVMScaleSet_NoAsyncTracking( rgName, vmssName, storageAccountOutput, imageRef, null, (vmScaleSet) => { vmScaleSet.Overprovision = false; }, createWithManagedDisks : true, createWithPublicIpAddress : false, createWithHealthProbe : true, automaticRepairsPolicy : automaticRepairsPolicy); VirtualMachineScaleSet getResponse = getTwoVirtualMachineScaleSet.Item1; inputVMScaleSet = getTwoVirtualMachineScaleSet.Item2; ValidateVMScaleSet(inputVMScaleSet, getResponse, hasManagedDisks: true); var getInstanceViewResponse = (await VirtualMachineScaleSetsOperations.GetInstanceViewAsync(rgName, vmssName)).Value; Assert.True(getInstanceViewResponse.OrchestrationServices.Count == 1); Assert.AreEqual("Running", getInstanceViewResponse.OrchestrationServices[0].ServiceState.ToString()); Assert.AreEqual("AutomaticRepairs", getInstanceViewResponse.OrchestrationServices[0].ServiceName.ToString()); ////TODO OrchestrationServiceStateInput orchestrationServiceStateInput = new OrchestrationServiceStateInput(OrchestrationServiceNames.AutomaticRepairs, OrchestrationServiceStateAction.Suspend); //OrchestrationServiceStateAction orchestrationServiceStateAction = new OrchestrationServiceStateAction(); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartSetOrchestrationServiceStateAsync(rgName, vmssName, orchestrationServiceStateInput)); getInstanceViewResponse = await VirtualMachineScaleSetsOperations.GetInstanceViewAsync(rgName, vmssName); Assert.AreEqual(OrchestrationServiceState.Suspended.ToString(), getInstanceViewResponse.OrchestrationServices[0].ServiceState.ToString()); orchestrationServiceStateInput = new OrchestrationServiceStateInput(OrchestrationServiceNames.AutomaticRepairs, OrchestrationServiceStateAction.Resume); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartSetOrchestrationServiceStateAsync(rgName, vmssName, orchestrationServiceStateInput)); getInstanceViewResponse = await VirtualMachineScaleSetsOperations.GetInstanceViewAsync(rgName, vmssName); Assert.AreEqual(OrchestrationServiceState.Running.ToString(), getInstanceViewResponse.OrchestrationServices[0].ServiceState.ToString()); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartDeleteAsync(rgName, vmssName)); }
protected PSArgument[] CreateVirtualMachineScaleSetCreateOrUpdateParameters() { string resourceGroupName = string.Empty; string name = string.Empty; VirtualMachineScaleSet parameters = new VirtualMachineScaleSet(); return ConvertFromObjectsToArguments( new string[] { "ResourceGroupName", "Name", "Parameters" }, new object[] { resourceGroupName, name, parameters }); }
public void TestVMScaleSetVMOperations() { using (MockContext context = MockContext.Start(this.GetType().FullName)) { EnsureClientsInitialized(context); ImageReference imageRef = GetPlatformVMImage(useWindowsImage: true); // Create resource group string rgName = TestUtilities.GenerateName(TestPrefix) + 1; string vmssName = TestUtilities.GenerateName("vmss"); string storageAccountName = TestUtilities.GenerateName(TestPrefix); const string instanceId = "0"; VirtualMachineScaleSet inputVMScaleSet; bool passed = false; try { var storageAccountOutput = CreateStorageAccount(rgName, storageAccountName); VirtualMachineScaleSet vmScaleSet = CreateVMScaleSet_NoAsyncTracking( rgName, vmssName, storageAccountOutput, imageRef, out inputVMScaleSet); var getResponse = m_CrpClient.VirtualMachineScaleSetVMs.Get(rgName, vmScaleSet.Name, instanceId); VirtualMachineScaleSetVM vmScaleSetVMModel = GenerateVMScaleSetVMModel(vmScaleSet, instanceId); ValidateVMScaleSetVM(vmScaleSetVMModel, vmScaleSet.Sku.Name, getResponse); var getInstanceViewResponse = m_CrpClient.VirtualMachineScaleSetVMs.GetInstanceView(rgName, vmScaleSet.Name, instanceId); Assert.True(getInstanceViewResponse != null, "VMScaleSetVM not returned."); ValidateVMScaleSetVMInstanceView(getInstanceViewResponse); var query = new Microsoft.Rest.Azure.OData.ODataQuery <VirtualMachineScaleSetVM>(); query.SetFilter(vm => vm.LatestModelApplied == true); var listResponse = m_CrpClient.VirtualMachineScaleSetVMs.List(rgName, vmssName, query); Assert.False(listResponse == null, "VMScaleSetVMs not returned"); Assert.True(listResponse.Count() == inputVMScaleSet.Sku.Capacity); query.Filter = null; query.Expand = "instanceView"; listResponse = m_CrpClient.VirtualMachineScaleSetVMs.List(rgName, vmssName, query, "instanceView"); Assert.False(listResponse == null, "VMScaleSetVMs not returned"); Assert.True(listResponse.Count() == inputVMScaleSet.Sku.Capacity); m_CrpClient.VirtualMachineScaleSetVMs.Start(rgName, vmScaleSet.Name, instanceId); // TODO: Re-enable the test once GA //m_CrpClient.VirtualMachineScaleSetVMs.Reimage(rgName, vmScaleSet.Name, instanceId); m_CrpClient.VirtualMachineScaleSetVMs.Restart(rgName, vmScaleSet.Name, instanceId); m_CrpClient.VirtualMachineScaleSetVMs.PowerOff(rgName, vmScaleSet.Name, instanceId); m_CrpClient.VirtualMachineScaleSetVMs.Deallocate(rgName, vmScaleSet.Name, instanceId); m_CrpClient.VirtualMachineScaleSetVMs.Delete(rgName, vmScaleSet.Name, instanceId); passed = true; } finally { // Cleanup the created resources. But don't wait since it takes too long, and it's not the purpose // of the test to cover deletion. CSM does persistent retrying over all RG resources. m_ResourcesClient.ResourceGroups.Delete(rgName); } Assert.True(passed); } }