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);
}
}
