/// <summary> /// Initializes client properties. /// </summary> protected override void Initialize() { Operations = new Operations(this); AvailabilitySets = new AvailabilitySetsOperations(this); VirtualMachineExtensionImages = new VirtualMachineExtensionImagesOperations(this); VirtualMachineExtensions = new VirtualMachineExtensionsOperations(this); VirtualMachineImages = new VirtualMachineImagesOperations(this); Usage = new UsageOperations(this); VirtualMachines = new VirtualMachinesOperations(this); VirtualMachineSizes = new VirtualMachineSizesOperations(this); Images = new ImagesOperations(this); VirtualMachineScaleSets = new VirtualMachineScaleSetsOperations(this); VirtualMachineScaleSetExtensions = new VirtualMachineScaleSetExtensionsOperations(this); VirtualMachineScaleSetRollingUpgrades = new VirtualMachineScaleSetRollingUpgradesOperations(this); VirtualMachineScaleSetVMs = new VirtualMachineScaleSetVMsOperations(this); LogAnalytics = new LogAnalyticsOperations(this); VirtualMachineRunCommands = new VirtualMachineRunCommandsOperations(this); ResourceSkus = new ResourceSkusOperations(this); Disks = new DisksOperations(this); Snapshots = new SnapshotsOperations(this); Galleries = new GalleriesOperations(this); GalleryImages = new GalleryImagesOperations(this); GalleryImageVersions = new GalleryImageVersionsOperations(this); ContainerServices = new ContainerServicesOperations(this); BaseUri = new System.Uri("https://management.azure.com"); AcceptLanguage = "en-US"; LongRunningOperationRetryTimeout = 30; GenerateClientRequestId = true; SerializationSettings = new JsonSerializerSettings { Formatting = Newtonsoft.Json.Formatting.Indented, DateFormatHandling = Newtonsoft.Json.DateFormatHandling.IsoDateFormat, DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Utc, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore, ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Serialize, ContractResolver = new ReadOnlyJsonContractResolver(), Converters = new List <JsonConverter> { new Iso8601TimeSpanConverter() } }; SerializationSettings.Converters.Add(new TransformationJsonConverter()); DeserializationSettings = new JsonSerializerSettings { DateFormatHandling = Newtonsoft.Json.DateFormatHandling.IsoDateFormat, DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Utc, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore, ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Serialize, ContractResolver = new ReadOnlyJsonContractResolver(), Converters = new List <JsonConverter> { new Iso8601TimeSpanConverter() } }; DeserializationSettings.Converters.Add(new TransformationJsonConverter()); DeserializationSettings.Converters.Add(new CloudErrorJsonConverter()); }
private async Task TestVMScaleSetExtensionsImpl() { // Create resource group string rgName = Recording.GenerateAssetName(TestPrefix) + 1; var vmssName = Recording.GenerateAssetName("vmss"); string storageAccountName = Recording.GenerateAssetName(TestPrefix); VirtualMachineScaleSet inputVMScaleSet; bool passed = false; ImageReference imageRef = await GetPlatformVMImage(useWindowsImage : true); var storageAccountOutput = await CreateStorageAccount(rgName, storageAccountName); var getTwoVirtualMachineScaleSet = await CreateVMScaleSet_NoAsyncTracking( rgName, vmssName, storageAccountOutput, imageRef); VirtualMachineScaleSet vmScaleSet = getTwoVirtualMachineScaleSet.Response; inputVMScaleSet = getTwoVirtualMachineScaleSet.Input; VirtualMachineScaleSetExtension vmssExtension = GetTestVMSSVMExtension(); vmssExtension.ForceUpdateTag = "RerunExtension"; var response = await WaitForCompletionAsync(await VirtualMachineScaleSetExtensionsOperations.StartCreateOrUpdateAsync(rgName, vmssName, vmssExtension.Name, vmssExtension)); ValidateVmssExtension(vmssExtension, response.Value); // Perform a Get operation on the extension var getVmssExtResponse = await VirtualMachineScaleSetExtensionsOperations.GetAsync(rgName, vmssName, vmssExtension.Name); ValidateVmssExtension(vmssExtension, getVmssExtResponse); // Validate the extension instance view in the VMSS instance-view var getVmssWithInstanceViewResponse = await VirtualMachineScaleSetsOperations.GetInstanceViewAsync(rgName, vmssName); ValidateVmssExtensionInstanceView(getVmssWithInstanceViewResponse.Value.Extensions.FirstOrDefault()); // Update an extension in the VMSS vmssExtension.Settings = string.Empty; var patchVmssExtsResponse = await WaitForCompletionAsync(await VirtualMachineScaleSetExtensionsOperations.StartCreateOrUpdateAsync(rgName, vmssName, vmssExtension.Name, vmssExtension)); ValidateVmssExtension(vmssExtension, patchVmssExtsResponse.Value); // Perform a List operation on vmss extensions var listVmssExts = VirtualMachineScaleSetExtensionsOperations.ListAsync(rgName, vmssName); var listVmssExtsResponse = await listVmssExts.ToEnumerableAsync(); ValidateVmssExtension(vmssExtension, listVmssExtsResponse.FirstOrDefault(c => c.ForceUpdateTag == "RerunExtension")); // Validate the extension delete API await WaitForCompletionAsync(await VirtualMachineScaleSetExtensionsOperations.StartDeleteAsync(rgName, vmssName, vmssExtension.Name)); passed = true; Assert.True(passed); }
public async Task TestVMScaleSetWithDnsSettings() { 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 vnetResponse = await CreateVNETWithSubnets(rgName, 2); var vmssSubnet = vnetResponse.Subnets[1]; var nicDnsSettings = new VirtualMachineScaleSetNetworkConfigurationDnsSettings() { DnsServers = { "10.0.0.5", "10.0.0.6" } }; var getTwoVirtualMachineScaleSet = await CreateVMScaleSet_NoAsyncTracking( rgName : rgName, vmssName : vmssName, storageAccount : storageAccountOutput, imageRef : imageRef, vmScaleSetCustomizer : (virtualMachineScaleSet) => virtualMachineScaleSet.VirtualMachineProfile.NetworkProfile .NetworkInterfaceConfigurations[0].DnsSettings = nicDnsSettings, createWithPublicIpAddress : false, subnet : vmssSubnet); VirtualMachineScaleSet vmScaleSet = getTwoVirtualMachineScaleSet.Response; inputVMScaleSet = getTwoVirtualMachineScaleSet.Input; var vmss = (await VirtualMachineScaleSetsOperations.GetAsync(rgName, vmssName)).Value; Assert.NotNull(vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].DnsSettings); Assert.NotNull(vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].DnsSettings.DnsServers); Assert.AreEqual(2, vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].DnsSettings.DnsServers.Count); //bool containFive = false; //bool containSix = false; //foreach (var detail in vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].DnsSettings.DnsServers) //{ // if(detail.) //} //Assert.Contains(vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].DnsSettings.DnsServers, ip => string.Equals("10.0.0.5", ip)); //Assert.Contains(vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].DnsSettings.DnsServers, ip => string.Equals("10.0.0.6", ip)); //Assert.Contains(vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].DnsSettings.DnsServers, ip => string.Equals("10.0.0.5", ip)); //Assert.Contains(vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].DnsSettings.DnsServers, ip => string.Equals("10.0.0.6", ip)); passed = true; Assert.True(passed); }
public async Task TestVMSSWithMultiCA() { EnsureClientsInitialized(LocationWestCentralUs); 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 vnetResponse = await CreateVNETWithSubnets(rgName, 2); var vmssSubnet = vnetResponse.Subnets[1]; var secondaryCA = new VirtualMachineScaleSetIPConfiguration(Recording.GenerateAssetName("vmsstestnetconfig")) { Subnet = new ApiEntityReference() { Id = vmssSubnet.Id } }; var getTwoVirtualMachineScaleSet = await CreateVMScaleSet_NoAsyncTracking( rgName : rgName, vmssName : vmssName, storageAccount : storageAccountOutput, imageRef : imageRef, vmScaleSetCustomizer : (virtualMachineScaleSet) => { virtualMachineScaleSet.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].Primary = true; virtualMachineScaleSet.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations.Add(secondaryCA); }, createWithPublicIpAddress : false, subnet : vmssSubnet); VirtualMachineScaleSet vmScaleSet = getTwoVirtualMachineScaleSet.Item1; inputVMScaleSet = getTwoVirtualMachineScaleSet.Item2; var vmss = (await VirtualMachineScaleSetsOperations.GetAsync(rgName, vmssName)).Value; Assert.AreEqual(2, vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations.Count); Assert.True(vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations.Count(ip => ip.Primary == true) == 1); passed = true; Assert.True(passed); }
public async Task TestVMScaleSetWithnNsg() { EnsureClientsInitialized(DefaultLocation); ImageReference imageRef = await GetPlatformVMImage(useWindowsImage : true); // Create resource group string rgName = Recording.GenerateAssetName(TestPrefix) + 1; var vmssName = Recording.GenerateAssetName("vmss"); var dnsname = Recording.GenerateAssetName("dnsname"); var nsgname = Recording.GenerateAssetName("nsg"); string storageAccountName = Recording.GenerateAssetName(TestPrefix); VirtualMachineScaleSet inputVMScaleSet; bool passed = false; var storageAccountOutput = await CreateStorageAccount(rgName, storageAccountName); var vnetResponse = await CreateVNETWithSubnets(rgName, 2); var vmssSubnet = vnetResponse.Subnets[1]; var nsg = await CreateNsg(rgName, nsgname); Azure.ResourceManager.Compute.Models.SubResource nsgId = new Azure.ResourceManager.Compute.Models.SubResource() { Id = nsg.Id }; var getTwoVirtualMachineScaleSet = await CreateVMScaleSet_NoAsyncTracking( rgName : rgName, vmssName : vmssName, storageAccount : storageAccountOutput, imageRef : imageRef, vmScaleSetCustomizer : (virtualMachineScaleSet) => virtualMachineScaleSet.VirtualMachineProfile.NetworkProfile .NetworkInterfaceConfigurations[0].NetworkSecurityGroup = nsgId, 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].NetworkSecurityGroup); Assert.AreEqual(vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].NetworkSecurityGroup.Id, nsg.Id); var getNsgResponse = (await NetworkSecurityGroupsOperations.GetAsync(rgName, nsg.Name)).Value; Assert.AreEqual(2, getNsgResponse.NetworkInterfaces.Count); passed = true; Assert.True(passed); }
public async Task TestVMScaleSetWithPublicIPAndPublicIPPrefix() { 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; ImageReference imageRef = await GetPlatformVMImage(useWindowsImage : true); var storageAccountOutput = await CreateStorageAccount(rgName, storageAccountName); var vnetResponse = await CreateVNETWithSubnets(rgName, 2); var vmssSubnet = vnetResponse.Subnets[1]; var publicIpPrefix = await CreatePublicIPPrefix(rgName, 30); var publicipConfiguration = new VirtualMachineScaleSetPublicIPAddressConfiguration("pip1"); publicipConfiguration.IdleTimeoutInMinutes = 10; publicipConfiguration.DnsSettings = new VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettings(dnsname); publicipConfiguration.PublicIPPrefix = new Azure.ResourceManager.Compute.Models.SubResource(); publicipConfiguration.PublicIPPrefix.Id = publicIpPrefix.Id; 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.AreEqual(publicIpPrefix.Id, vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.PublicIPPrefix.Id); passed = true; Assert.True(passed); }
public async Task TestVMScaleSetWithPublicIP() { 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.IdleTimeoutInMinutes = 10; publicipConfiguration.DnsSettings = new VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettings(dnsname); 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); Assert.NotNull(vmss.Value.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration); Assert.AreEqual("pip1", vmss.Value.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.Name); Assert.AreEqual(10, vmss.Value.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.IdleTimeoutInMinutes); Assert.NotNull(vmss.Value.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.DnsSettings); Assert.AreEqual(dnsname, vmss.Value.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.DnsSettings.DomainNameLabel); passed = true; Assert.True(passed); }
public async Task TestVMScaleSetMarketplace() { EnsureClientsInitialized(DefaultLocation); ImageReference dummyImageRef = await GetPlatformVMImage(useWindowsImage : true); // Create resource group string rgName = Recording.GenerateAssetName(TestPrefix) + 1; var vmssName = Recording.GenerateAssetName("vmss"); string storageAccountName = Recording.GenerateAssetName(TestPrefix); var storageAccountOutput = await CreateStorageAccount(rgName, storageAccountName); var img = await GetMarketplaceImage(); Action <VirtualMachineScaleSet> useVMMImage = vmss => { vmss.VirtualMachineProfile.StorageProfile.ImageReference = new ImageReference { Publisher = vmmPublisherName, Offer = vmmOfferName, Sku = vmmSku, Version = "latest" }; vmss.Plan = new Plan { Name = img.Plan.Name, Product = img.Plan.Product, PromotionCode = null, Publisher = img.Plan.Publisher }; }; try { VirtualMachineScaleSet inputVMScaleSet; var getTwoVirtualMachineScaleSet = await CreateVMScaleSet_NoAsyncTracking(rgName, vmssName, storageAccountOutput, dummyImageRef, vmScaleSetCustomizer : useVMMImage); VirtualMachineScaleSet vmScaleSet = getTwoVirtualMachineScaleSet.Response; inputVMScaleSet = getTwoVirtualMachineScaleSet.Input; // Validate the VMM Plan field ValidateMarketplaceVMScaleSetPlanField(vmScaleSet, img); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartDeleteAsync(rgName, vmssName)); } catch (Exception ex) { if (ex.Message.Contains("Legal terms have not been accepted for this item on this subscription.")) { return; } } }
//[Trait("Name", "TestVMScaleSetExtensionUpgradeAPIs")] public async Task TestVMScaleSetExtensionUpgradeAPIs() { EnsureClientsInitialized(LocationEastUs2); string rgName = Recording.GenerateAssetName(TestPrefix); string vmssName = Recording.GenerateAssetName("vmss"); string storageAccountName = Recording.GenerateAssetName(TestPrefix); VirtualMachineScaleSet inputVMScaleSet; // Windows VM image ImageReference imageRef = await GetPlatformVMImage(true); imageRef.Version = "latest"; var extension = GetTestVMSSVMExtension(); VirtualMachineScaleSetExtensionProfile extensionProfile = new VirtualMachineScaleSetExtensionProfile() { Extensions = { extension, } }; var storageAccountOutput = await CreateStorageAccount(rgName, storageAccountName); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartDeleteAsync(rgName, "VMScaleSetDoesNotExist")); var getTwoVirtualMachineScaleSet = await CreateVMScaleSet_NoAsyncTracking( rgName, vmssName, storageAccountOutput, imageRef, extensionProfile, (vmScaleSet) => { vmScaleSet.Overprovision = false; vmScaleSet.UpgradePolicy.Mode = UpgradeMode.Automatic; }, createWithManagedDisks : true, createWithPublicIpAddress : false, createWithHealthProbe : true); VirtualMachineScaleSet getResponse = getTwoVirtualMachineScaleSet.Item1; inputVMScaleSet = getTwoVirtualMachineScaleSet.Item2; ValidateVMScaleSet(inputVMScaleSet, getResponse, hasManagedDisks: true); await WaitForCompletionAsync(await VirtualMachineScaleSetRollingUpgradesOperations.StartStartExtensionUpgradeAsync(rgName, vmssName)); var rollingUpgradeStatus = await VirtualMachineScaleSetRollingUpgradesOperations.GetLatestAsync(rgName, vmssName); Assert.AreEqual(inputVMScaleSet.Sku.Capacity, rollingUpgradeStatus.Value.Progress.SuccessfulInstanceCount); }
public async Task TestVMScaleSetWithnIpv6() { EnsureClientsInitialized(DefaultLocation); ImageReference imageRef = await GetPlatformVMImage(useWindowsImage : true); // 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; var storageAccountOutput = await CreateStorageAccount(rgName, storageAccountName); var vnetResponse = await CreateVNETWithSubnets(rgName, 2); var vmssSubnet = vnetResponse.Subnets[1]; var ipv6ipconfig = new VirtualMachineScaleSetIPConfiguration("ipv6"); ipv6ipconfig.Name = "ipv6"; ipv6ipconfig.PrivateIPAddressVersion = Azure.ResourceManager.Compute.Models.IPVersion.IPv6; var getTwoVirtualMachineScaleSet = await CreateVMScaleSet_NoAsyncTracking( rgName : rgName, vmssName : vmssName, storageAccount : storageAccountOutput, imageRef : imageRef, vmScaleSetCustomizer : (virtualMachineScaleSet) => { virtualMachineScaleSet.VirtualMachineProfile.NetworkProfile .NetworkInterfaceConfigurations[0].IpConfigurations[0].PrivateIPAddressVersion = Azure.ResourceManager.Compute.Models.IPVersion.IPv4; virtualMachineScaleSet.VirtualMachineProfile.NetworkProfile .NetworkInterfaceConfigurations[0].IpConfigurations.Add(ipv6ipconfig); }, createWithPublicIpAddress : false, subnet : vmssSubnet); VirtualMachineScaleSet vmScaleSet = getTwoVirtualMachineScaleSet.Item1; inputVMScaleSet = getTwoVirtualMachineScaleSet.Item2; var vmss = (await VirtualMachineScaleSetsOperations.GetAsync(rgName, vmssName)).Value; Assert.AreEqual(2, vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations.Count); passed = true; Assert.True(passed); }
public async Task <(VirtualMachineScaleSet, VirtualMachineScaleSet)> CreateVMScaleSet_NoAsyncTracking( string rgName, string vmssName, StorageAccount storageAccount, ImageReference imageRef, 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) { try { var createOrUpdateResponse = await CreateVMScaleSetAndGetOperationResponse(rgName, vmssName, storageAccount, imageRef, extensionProfile, vmScaleSetCustomizer, createWithPublicIpAddress, createWithManagedDisks, hasDiffDisks, createWithHealthProbe, subnet, zones, osDiskSizeInGB, ppgId : ppgId, machineSizeType : machineSizeType, enableUltraSSD : enableUltraSSD, diskEncryptionSetId : diskEncryptionSetId, automaticRepairsPolicy : automaticRepairsPolicy); var getResponse = await VirtualMachineScaleSetsOperations.GetAsync(rgName, vmssName); return(getResponse, createOrUpdateResponse.Item2); } catch { throw; } }
//[Trait("Name", "TestVMScaleSetRollingUpgradeHistory")] public async Task TestVMScaleSetRollingUpgradeHistory() { EnsureClientsInitialized(LocationSouthCentralUs); // 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); imageRef.Version = "latest"; 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; vmScaleSet.UpgradePolicy.Mode = UpgradeMode.Rolling; }, createWithManagedDisks : true, createWithPublicIpAddress : false, createWithHealthProbe : true); VirtualMachineScaleSet getResponse = getTwoVirtualMachineScaleSet.Item1; inputVMScaleSet = getTwoVirtualMachineScaleSet.Item2; ValidateVMScaleSet(inputVMScaleSet, getResponse, hasManagedDisks: true); WaitSeconds(600); var vmssStatus = await VirtualMachineScaleSetsOperations.GetInstanceViewAsync(rgName, vmssName); await WaitForCompletionAsync(await VirtualMachineScaleSetRollingUpgradesOperations.StartStartOSUpgradeAsync(rgName, vmssName)); var rollingUpgrade = VirtualMachineScaleSetsOperations.GetOSUpgradeHistoryAsync(rgName, vmssName); var rollingUpgradeHistory = await rollingUpgrade.ToEnumerableAsync(); Assert.NotNull(rollingUpgradeHistory); Assert.True(rollingUpgradeHistory.Count() == 1); Assert.AreEqual(inputVMScaleSet.Sku.Capacity, rollingUpgradeHistory.First().Properties.Progress.SuccessfulInstanceCount); }
/// <summary> /// Initializes client properties. /// </summary> private void Initialize() { AvailabilitySets = new AvailabilitySetsOperations(this); VirtualMachineExtensionImages = new VirtualMachineExtensionImagesOperations(this); VirtualMachineExtensions = new VirtualMachineExtensionsOperations(this); VirtualMachineImages = new VirtualMachineImagesOperations(this); Usage = new UsageOperations(this); VirtualMachineSizes = new VirtualMachineSizesOperations(this); Images = new ImagesOperations(this); VirtualMachines = new VirtualMachinesOperations(this); VirtualMachineScaleSets = new VirtualMachineScaleSetsOperations(this); VirtualMachineScaleSetVMs = new VirtualMachineScaleSetVMsOperations(this); Disks = new DisksOperations(this); Snapshots = new SnapshotsOperations(this); BaseUri = new System.Uri("https://management.azure.com"); ApiVersion = "2016-04-30-preview"; AcceptLanguage = "en-US"; LongRunningOperationRetryTimeout = 30; GenerateClientRequestId = true; SerializationSettings = new JsonSerializerSettings { Formatting = Newtonsoft.Json.Formatting.Indented, DateFormatHandling = Newtonsoft.Json.DateFormatHandling.IsoDateFormat, DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Utc, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore, ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Serialize, ContractResolver = new ReadOnlyJsonContractResolver(), Converters = new List <JsonConverter> { new Iso8601TimeSpanConverter() } }; SerializationSettings.Converters.Add(new TransformationJsonConverter()); DeserializationSettings = new JsonSerializerSettings { DateFormatHandling = Newtonsoft.Json.DateFormatHandling.IsoDateFormat, DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Utc, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore, ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Serialize, ContractResolver = new ReadOnlyJsonContractResolver(), Converters = new List <JsonConverter> { new Iso8601TimeSpanConverter() } }; CustomInitialize(); DeserializationSettings.Converters.Add(new TransformationJsonConverter()); DeserializationSettings.Converters.Add(new CloudErrorJsonConverter()); }
public async Task TestVMScaleSetBatchOperations_PerformMaintenance() { string rgName = Recording.GenerateAssetName(TestPrefix) + 1; string vmssName = Recording.GenerateAssetName("vmss"); string storageAccountName = Recording.GenerateAssetName(TestPrefix); VirtualMachineScaleSet inputVMScaleSet; VirtualMachineScaleSet vmScaleSet = null; bool passed = false; try { EnsureClientsInitialized(LocationEastUs2UpperCase); ImageReference imageRef = await GetPlatformVMImage(useWindowsImage : true); StorageAccount storageAccountOutput = await CreateStorageAccount(rgName, storageAccountName); var getTwoVirtualMachineScaleSet = await CreateVMScaleSet_NoAsyncTracking(rgName, vmssName, storageAccountOutput, imageRef, createWithManagedDisks : true, vmScaleSetCustomizer : virtualMachineScaleSet => virtualMachineScaleSet.UpgradePolicy = new UpgradePolicy { Mode = UpgradeMode.Manual }); vmScaleSet = getTwoVirtualMachineScaleSet.Item1; inputVMScaleSet = getTwoVirtualMachineScaleSet.Item2; List <string> virtualMachineScaleSetInstanceIDs = new List <string> { "0", "1" }; var virtualMachineScaleSetInstanceID = new VirtualMachineScaleSetVMInstanceIDs(new List <string>() { "0", "1" }); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartPerformMaintenanceAsync(rgName, vmScaleSet.Name, virtualMachineScaleSetInstanceID)); passed = true; } catch (Exception cex) { passed = true; string expectedMessage = $"Operation 'performMaintenance' is not allowed on VM '{vmScaleSet.Name}_0' " + "since the Subscription of this VM is not eligible."; Assert.IsTrue(cex.Message.Contains(expectedMessage)); } Assert.True(passed); }
public async Task TestVMScaleSetWithLicenseType() { EnsureClientsInitialized(DefaultLocation); // Create resource group string rgName = Recording.GenerateAssetName(TestPrefix) + 1; var vmssName = Recording.GenerateAssetName("vmss"); string storageAccountName = Recording.GenerateAssetName(TestPrefix); var storageAccountOutput = await CreateStorageAccount(rgName, storageAccountName); VirtualMachineScaleSet inputVMScaleSet; Action <VirtualMachineScaleSet> vmProfileCustomizer = vmss => { vmss.VirtualMachineProfile.StorageProfile.ImageReference = GetPlatformVMImage(true).Result; vmss.VirtualMachineProfile.LicenseType = "Windows_Server"; }; try { var getTwoVirtualMachineScaleSet = await CreateVMScaleSet_NoAsyncTracking( rgName : rgName, vmssName : vmssName, storageAccount : storageAccountOutput, imageRef : null, createWithManagedDisks : true, vmScaleSetCustomizer : vmProfileCustomizer ); VirtualMachineScaleSet vmScaleSet = getTwoVirtualMachineScaleSet.Item1; inputVMScaleSet = getTwoVirtualMachineScaleSet.Item2; var response = (await VirtualMachineScaleSetsOperations.GetAsync(rgName, vmssName)).Value; Assert.AreEqual("Windows_Server", response.VirtualMachineProfile.LicenseType); } catch (Exception ex) { if (ex.Message.Contains("One or more errors occurred while preparing VM disks. See disk instance view for details.")) { return; } throw; } }
public async Task TestVMScaleSetUpdateOperations() { EnsureClientsInitialized(DefaultLocation); 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); VirtualMachineScaleSet vmScaleSet = getTwoVirtualMachineScaleSet.Item1; inputVMScaleSet = getTwoVirtualMachineScaleSet.Item2; var getResponse = await VirtualMachineScaleSetsOperations.GetAsync(rgName, vmScaleSet.Name); ValidateVMScaleSet(inputVMScaleSet, getResponse); inputVMScaleSet.Sku.Name = VirtualMachineSizeTypes.StandardA1.ToString(); VirtualMachineScaleSetExtensionProfile extensionProfile = new VirtualMachineScaleSetExtensionProfile() { Extensions = { GetTestVMSSVMExtension(), } }; inputVMScaleSet.VirtualMachineProfile.ExtensionProfile = extensionProfile; await UpdateVMScaleSet(rgName, vmssName, inputVMScaleSet); getResponse = await VirtualMachineScaleSetsOperations.GetAsync(rgName, vmScaleSet.Name); ValidateVMScaleSet(inputVMScaleSet, getResponse); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartDeleteAsync(rgName, vmScaleSet.Name)); }
public async Task TestVMScaleSetScalingOperations() { EnsureClientsInitialized(DefaultLocation); 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); VirtualMachineScaleSet vmScaleSet = getTwoVirtualMachineScaleSet.Item1; inputVMScaleSet = getTwoVirtualMachineScaleSet.Item2; var getResponse = await VirtualMachineScaleSetsOperations.GetAsync(rgName, vmScaleSet.Name); ValidateVMScaleSet(inputVMScaleSet, getResponse); // Scale Out VMScaleSet inputVMScaleSet.Sku.Capacity = 3; await UpdateVMScaleSet(rgName, vmssName, inputVMScaleSet); getResponse = await VirtualMachineScaleSetsOperations.GetAsync(rgName, vmScaleSet.Name); ValidateVMScaleSet(inputVMScaleSet, getResponse); // Scale In VMScaleSet inputVMScaleSet.Sku.Capacity = 1; await UpdateVMScaleSet(rgName, vmssName, inputVMScaleSet); getResponse = await VirtualMachineScaleSetsOperations.GetAsync(rgName, vmScaleSet.Name); ValidateVMScaleSet(inputVMScaleSet, getResponse); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartDeleteAsync(rgName, vmScaleSet.Name)); }
public async Task TestVMSSAccelNtwkng() { EnsureClientsInitialized(LocationWestCentralUs); 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 vnetResponse = await CreateVNETWithSubnets(rgName, 2); var vmssSubnet = vnetResponse.Subnets[1]; var getTwoVirtualMachineScaleSet = await CreateVMScaleSet_NoAsyncTracking( rgName : rgName, vmssName : vmssName, storageAccount : storageAccountOutput, imageRef : imageRef, vmScaleSetCustomizer : (virtualMachineScaleSet) => { virtualMachineScaleSet.Sku.Name = VirtualMachineSizeTypes.StandardDS11V2.ToString(); virtualMachineScaleSet.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].EnableAcceleratedNetworking = true; }, createWithPublicIpAddress : false, subnet : vmssSubnet); VirtualMachineScaleSet vmScaleSet = getTwoVirtualMachineScaleSet.Item1; inputVMScaleSet = getTwoVirtualMachineScaleSet.Item2; var vmss = (await VirtualMachineScaleSetsOperations.GetAsync(rgName, vmssName)).Value; Assert.True(vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].EnableAcceleratedNetworking == true); passed = true; Assert.True(passed); }
private async Task TestVMScaleSetOperationsInternal(bool hasManagedDisks = false) { 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, vmssName, storageAccountOutput, imageRef, createWithManagedDisks : hasManagedDisks); VirtualMachineScaleSet vmScaleSet = getTwoVirtualMachineScaleSet.Item1; inputVMScaleSet = getTwoVirtualMachineScaleSet.Item2; // TODO: AutoRest skips the following methods - Start, Restart, PowerOff, Deallocate await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartStartAsync(rgName, vmScaleSet.Name)); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartReimageAsync(rgName, vmScaleSet.Name)); if (hasManagedDisks) { await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartReimageAllAsync(rgName, vmScaleSet.Name)); } await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartRestartAsync(rgName, vmScaleSet.Name)); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartPowerOffAsync(rgName, vmScaleSet.Name)); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartDeallocateAsync(rgName, vmScaleSet.Name)); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartDeleteAsync(rgName, vmScaleSet.Name)); passed = true; Assert.True(passed); }
public async Task TestVMScaleSetDiagnosticsProfile() { EnsureClientsInitialized(DefaultLocation); // Create resource group string rgName = Recording.GenerateAssetName(TestPrefix) + 1; var vmssName = Recording.GenerateAssetName("vmss"); string storageAccountName = Recording.GenerateAssetName(TestPrefix); var storageAccountOutput = await CreateStorageAccount(rgName, storageAccountName); VirtualMachineScaleSet inputVMScaleSet; Action <VirtualMachineScaleSet> vmProfileCustomizer = vmss => { vmss.VirtualMachineProfile.DiagnosticsProfile = new DiagnosticsProfile( new BootDiagnostics { Enabled = true, StorageUri = string.Format(Constants.StorageAccountBlobUriTemplate, storageAccountName) }); }; var getTwoVirtualMachineScaleSet = await CreateVMScaleSet_NoAsyncTracking( rgName : rgName, vmssName : vmssName, storageAccount : storageAccountOutput, imageRef : await GetPlatformVMImage(true), createWithManagedDisks : true, vmScaleSetCustomizer : vmProfileCustomizer ); VirtualMachineScaleSet getResponse = getTwoVirtualMachineScaleSet.Item1; inputVMScaleSet = getTwoVirtualMachineScaleSet.Item2; var response = (await VirtualMachineScaleSetsOperations.GetAsync(rgName, vmssName)).Value; Assert.True(response.VirtualMachineProfile.DiagnosticsProfile.BootDiagnostics.Enabled.GetValueOrDefault(true)); }
public async Task TestVMScaleSetBatchOperations_Redeploy() { string rgName = Recording.GenerateAssetName(TestPrefix) + 1; string vmssName = Recording.GenerateAssetName("vmss"); string storageAccountName = Recording.GenerateAssetName(TestPrefix); VirtualMachineScaleSet inputVMScaleSet; bool passed = false; EnsureClientsInitialized(LocationEastUs2UpperCase); ImageReference imageRef = await GetPlatformVMImage(useWindowsImage : true); StorageAccount storageAccountOutput = await CreateStorageAccount(rgName, storageAccountName); var getTwoVirtualMachineScaleSet = await CreateVMScaleSet_NoAsyncTracking(rgName, vmssName, storageAccountOutput, imageRef, createWithManagedDisks : true, vmScaleSetCustomizer : virtualMachineScaleSet => virtualMachineScaleSet.UpgradePolicy = new UpgradePolicy { Mode = UpgradeMode.Manual }); VirtualMachineScaleSet vmScaleSet = getTwoVirtualMachineScaleSet.Item1; inputVMScaleSet = getTwoVirtualMachineScaleSet.Item2; List <string> virtualMachineScaleSetInstanceIDs = new List <string> { "0", "1" }; var virtualMachineScaleSetInstanceID = new VirtualMachineScaleSetVMInstanceIDs(new List <string>() { "0", "1" }); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartRedeployAsync(rgName, vmScaleSet.Name, virtualMachineScaleSetInstanceID)); passed = true; Assert.True(passed); }
//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)); }
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.Response; inputVMScaleSet = getTwoVirtualMachineScaleSet.Input; 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)); }
//[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.Response; inputVMScaleSet = getTwoVirtualMachineScaleSet.Input; 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)); }
//[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.Response; inputVMScaleSet = getTwoVirtualMachineScaleSet.Input; 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); }
//[Trait("Name", "TestVMScaleSetRollingUpgrade")] public async Task TestVMScaleSetRollingUpgrade() { EnsureClientsInitialized(LocationSouthCentralUs); // 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); VirtualMachineScaleSetExtensionProfile extensionProfile = new VirtualMachineScaleSetExtensionProfile() { Extensions = { GetTestVMSSVMExtension(), } }; 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; vmScaleSet.UpgradePolicy.Mode = UpgradeMode.Rolling; }, createWithManagedDisks : true, createWithPublicIpAddress : false, createWithHealthProbe : true); VirtualMachineScaleSet getResponse = getTwoVirtualMachineScaleSet.Item1; inputVMScaleSet = getTwoVirtualMachineScaleSet.Item2; ValidateVMScaleSet(inputVMScaleSet, getResponse, hasManagedDisks: true); var getInstanceViewResponse = await VirtualMachineScaleSetsOperations.GetInstanceViewAsync(rgName, vmssName); Assert.NotNull(getInstanceViewResponse); ValidateVMScaleSetInstanceView(inputVMScaleSet, getInstanceViewResponse); var getVMInstanceViewResponse = await VirtualMachineScaleSetVMsOperations.GetInstanceViewAsync(rgName, vmssName, "0"); Assert.NotNull(getVMInstanceViewResponse); Assert.NotNull(getVMInstanceViewResponse.Value.VmHealth); Assert.AreEqual("HealthState/healthy", getVMInstanceViewResponse.Value.VmHealth.Status.Code); // Update the VMSS by adding an extension WaitSeconds(600); var vmssStatus = await VirtualMachineScaleSetsOperations.GetInstanceViewAsync(rgName, vmssName); inputVMScaleSet.VirtualMachineProfile.ExtensionProfile = extensionProfile; await UpdateVMScaleSet(rgName, vmssName, inputVMScaleSet); getResponse = await VirtualMachineScaleSetsOperations.GetAsync(rgName, vmssName); ValidateVMScaleSet(inputVMScaleSet, getResponse, hasManagedDisks: true); getInstanceViewResponse = await VirtualMachineScaleSetsOperations.GetInstanceViewAsync(rgName, vmssName); Assert.NotNull(getInstanceViewResponse); ValidateVMScaleSetInstanceView(inputVMScaleSet, getInstanceViewResponse); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartDeleteAsync(rgName, vmssName)); }
// This method is used to Update VM Scale Set but it internally calls PATCH verb instead of PUT. // PATCH verb is more relaxed and does not puts constraint to specify full parameters. protected async Task PatchVMScaleSet(string rgName, string vmssName, VirtualMachineScaleSetUpdate inputVMScaleSet) { var patchResponse = await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartUpdateAsync(rgName, vmssName, inputVMScaleSet)); }
//[Trait("Name", "TestVMScaleSetAutomaticOSUpgradePolicies")] public async Task TestVMScaleSetAutomaticOSUpgradePolicies() { EnsureClientsInitialized(LocationWestCentralUs); ImageReference imageRef = await GetPlatformVMImage(useWindowsImage : true); imageRef.Version = "latest"; // 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; vmScaleSet.UpgradePolicy.AutomaticOSUpgradePolicy = new AutomaticOSUpgradePolicy() { DisableAutomaticRollback = false }; }, createWithManagedDisks : true, createWithPublicIpAddress : false, createWithHealthProbe : true); VirtualMachineScaleSet getResponse = getTwoVirtualMachineScaleSet.Item1; inputVMScaleSet = getTwoVirtualMachineScaleSet.Item2; ValidateVMScaleSet(inputVMScaleSet, getResponse, hasManagedDisks: true); // Set Automatic OS Upgrade inputVMScaleSet.UpgradePolicy.AutomaticOSUpgradePolicy.EnableAutomaticOSUpgrade = true; await UpdateVMScaleSet(rgName, vmssName, inputVMScaleSet); getResponse = await VirtualMachineScaleSetsOperations.GetAsync(rgName, vmssName); ValidateVMScaleSet(inputVMScaleSet, getResponse, hasManagedDisks: true); // with automatic OS upgrade policy as null inputVMScaleSet.UpgradePolicy.AutomaticOSUpgradePolicy = null; await UpdateVMScaleSet(rgName, vmssName, inputVMScaleSet); getResponse = await VirtualMachineScaleSetsOperations.GetAsync(rgName, vmssName); ValidateVMScaleSet(inputVMScaleSet, getResponse, hasManagedDisks: true); Assert.NotNull(getResponse.UpgradePolicy.AutomaticOSUpgradePolicy); Assert.True(getResponse.UpgradePolicy.AutomaticOSUpgradePolicy.DisableAutomaticRollback == false); Assert.True(getResponse.UpgradePolicy.AutomaticOSUpgradePolicy.EnableAutomaticOSUpgrade == true); // Toggle Disable Auto Rollback inputVMScaleSet.UpgradePolicy.AutomaticOSUpgradePolicy = new AutomaticOSUpgradePolicy() { DisableAutomaticRollback = true, EnableAutomaticOSUpgrade = false }; await UpdateVMScaleSet(rgName, vmssName, inputVMScaleSet); getResponse = await VirtualMachineScaleSetsOperations.GetAsync(rgName, vmssName); ValidateVMScaleSet(inputVMScaleSet, getResponse, hasManagedDisks: true); }
private async Task <(VirtualMachineScaleSet, VirtualMachineScaleSet)> CreateVMScaleSetAndGetOperationResponse( string rgName, string vmssName, StorageAccount storageAccount, ImageReference imageRef, 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 = await ResourceGroupsOperations.CreateOrUpdateAsync( rgName, new ResourceGroup(m_location)); var getPublicIpAddressResponse = createWithPublicIpAddress ? null : await CreatePublicIP(rgName); var subnetResponse = subnet ?? await CreateVNET(rgName); var nicResponse = await CreateNIC( rgName, subnetResponse, getPublicIpAddressResponse != null?getPublicIpAddressResponse.IpAddress : null); var loadBalancer = ((getPublicIpAddressResponse != null && createWithHealthProbe) ? (await CreatePublicLoadBalancerWithProbe(rgName, getPublicIpAddressResponse)) : null); Assert.True(createWithManagedDisks || storageAccount != null); var 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(DiskCreateOptionTypes.FromImage); osDisk.Caching = CachingTypes.ReadOnly; osDisk.DiffDiskSettings = new DiffDiskSettings { Option = "Local", //TODO the value of "Placement" may not be given //Placement = DiffDiskPlacement.CacheDisk }; inputVMScaleSet.VirtualMachineProfile.StorageProfile.OsDisk = osDisk; } inputVMScaleSet.VirtualMachineProfile.ExtensionProfile = extensionProfile; if (ppgId != null) { inputVMScaleSet.ProximityPlacementGroup = new Azure.ResourceManager.Compute.Models.SubResource() { Id = ppgId }; } VirtualMachineScaleSet createOrUpdateResponse = null; try { createOrUpdateResponse = await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartCreateOrUpdateAsync(rgName, vmssName, inputVMScaleSet)); Assert.True(createOrUpdateResponse.Name == vmssName); Assert.True(createOrUpdateResponse.Location.ToLower() == inputVMScaleSet.Location.ToLower().Replace(" ", "")); } catch (Exception e) { if (e.Message.Contains("the allotted time")) { createOrUpdateResponse = await VirtualMachineScaleSetsOperations.GetAsync(rgName, vmssName); } else { throw; } } ValidateVMScaleSet(inputVMScaleSet, createOrUpdateResponse, createWithManagedDisks, ppgId: ppgId); return(createOrUpdateResponse, inputVMScaleSet); }
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(new List <string>() { "0", "1" }); var virtualMachineScaleSetInstanceID = new List <string>() { "0", "1" }; var virtualMachineScaleSetRequ = new VirtualMachineScaleSetVMInstanceRequiredIDs(new List <string>() { "0", "1" }); await WaitForCompletionAsync(await VirtualMachineScaleSetsOperations.StartStartAsync(rgName, vmScaleSet.Name, virtualMachineScaleSetInstanceIDs)); virtualMachineScaleSetInstanceIDs = new VirtualMachineScaleSetVMInstanceIDs(new List <string>() { "0" }); VirtualMachineScaleSetReimageParameters virtualMachineScaleSetReimageParameters = new VirtualMachineScaleSetReimageParameters { InstanceIds = virtualMachineScaleSetInstanceID }; 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)); virtualMachineScaleSetInstanceID = new List <string>() { "1" }; 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); }