public async Task TestVMScaleSetWithPublicIP()
{
EnsureClientsInitialized(LocationWestCentralUs);
// Create resource group
string rgName = Recording.GenerateAssetName(TestPrefix) + 1;
var vmssName = Recording.GenerateAssetName("vmss");
var dnsname = Recording.GenerateAssetName("dnsname");
string storageAccountName = Recording.GenerateAssetName(TestPrefix);
VirtualMachineScaleSet inputVMScaleSet;
bool passed = false;
// Hard code the location to "westcentralus".
// This is because NRP is still deploying to other regions and is not available worldwide.
// Before changing the default location, we have to save it to be reset it at the end of the test.
// Since ComputeManagementTestUtilities.DefaultLocation is a static variable and can affect other tests if it is not reset.
ImageReference imageRef = await GetPlatformVMImage(useWindowsImage : true);
var storageAccountOutput = await CreateStorageAccount(rgName, storageAccountName);
var vnetResponse = await CreateVNETWithSubnets(rgName, 2);
var vmssSubnet = vnetResponse.Subnets[1];
var publicipConfiguration = new VirtualMachineScaleSetPublicIPAddressConfiguration("pip1");
publicipConfiguration.IdleTimeoutInMinutes = 10;
publicipConfiguration.DnsSettings = new VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettings(dnsname);
var getTwoVirtualMachineScaleSet = await CreateVMScaleSet_NoAsyncTracking(
rgName : rgName,
vmssName : vmssName,
storageAccount : storageAccountOutput,
imageRef : imageRef,
vmScaleSetCustomizer :
(virtualMachineScaleSet) =>
virtualMachineScaleSet.VirtualMachineProfile.NetworkProfile
.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration = publicipConfiguration,
createWithPublicIpAddress : false,
subnet : vmssSubnet);
VirtualMachineScaleSet vmScaleSet = getTwoVirtualMachineScaleSet.Item1;
inputVMScaleSet = getTwoVirtualMachineScaleSet.Item2;
var vmss = await VirtualMachineScaleSetsOperations.GetAsync(rgName, vmssName);
Assert.NotNull(vmss.Value.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration);
Assert.AreEqual("pip1", vmss.Value.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.Name);
Assert.AreEqual(10, vmss.Value.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.IdleTimeoutInMinutes);
Assert.NotNull(vmss.Value.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.DnsSettings);
Assert.AreEqual(dnsname, vmss.Value.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.DnsSettings.DomainNameLabel);
passed = true;
Assert.True(passed);
}
public async Task TestVMScaleSetWithPublicIPAndPublicIPPrefix()
{
EnsureClientsInitialized(LocationWestCentralUs);
// Create resource group
string rgName = Recording.GenerateAssetName(TestPrefix) + 1;
var vmssName = Recording.GenerateAssetName("vmss");
var dnsname = Recording.GenerateAssetName("dnsname");
string storageAccountName = Recording.GenerateAssetName(TestPrefix);
VirtualMachineScaleSet inputVMScaleSet;
bool passed = false;
ImageReference imageRef = await GetPlatformVMImage(useWindowsImage : true);
var storageAccountOutput = await CreateStorageAccount(rgName, storageAccountName);
var vnetResponse = await CreateVNETWithSubnets(rgName, 2);
var vmssSubnet = vnetResponse.Subnets[1];
var publicIpPrefix = await CreatePublicIPPrefix(rgName, 30);
var publicipConfiguration = new VirtualMachineScaleSetPublicIPAddressConfiguration("pip1");
publicipConfiguration.IdleTimeoutInMinutes = 10;
publicipConfiguration.DnsSettings = new VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettings(dnsname);
publicipConfiguration.PublicIPPrefix = new Azure.ResourceManager.Compute.Models.SubResource();
publicipConfiguration.PublicIPPrefix.Id = publicIpPrefix.Id;
var getTwoVirtualMachineScaleSet = await CreateVMScaleSet_NoAsyncTracking(
rgName : rgName,
vmssName : vmssName,
storageAccount : storageAccountOutput,
imageRef : imageRef,
vmScaleSetCustomizer :
(virtualMachineScaleSet) =>
virtualMachineScaleSet.VirtualMachineProfile.NetworkProfile
.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration = publicipConfiguration,
createWithPublicIpAddress : false,
subnet : vmssSubnet);
VirtualMachineScaleSet vmScaleSet = getTwoVirtualMachineScaleSet.Item1;
inputVMScaleSet = getTwoVirtualMachineScaleSet.Item2;
var vmss = (await VirtualMachineScaleSetsOperations.GetAsync(rgName, vmssName)).Value;
Assert.NotNull(vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration);
Assert.AreEqual("pip1", vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.Name);
Assert.AreEqual(10, vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.IdleTimeoutInMinutes);
Assert.NotNull(vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.DnsSettings);
Assert.AreEqual(dnsname, vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.DnsSettings.DomainNameLabel);
Assert.AreEqual(publicIpPrefix.Id, vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration.PublicIPPrefix.Id);
passed = true;
Assert.True(passed);
}
public 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);
}
}
private void TestDiskEncryptionOnScaleSetVMInternal(MockContext context, bool hasManagedDisks = true, bool useVmssExtension = true)
{
EnsureClientsInitialized(context);
// Get platform image for VMScaleSet create
ImageReference imageRef = GetPlatformVMImage(useWindowsImage: true);
// Create resource group
string rgName = TestUtilities.GenerateName(TestPrefix);
string vmssName = TestUtilities.GenerateName("vmss");
string storageAccountName = TestUtilities.GenerateName(TestPrefix);
var dnsname = TestUtilities.GenerateName("dnsname");
// Create ADE extension to enable disk encryption
VirtualMachineScaleSetExtensionProfile extensionProfile = new VirtualMachineScaleSetExtensionProfile()
{
Extensions = new List <VirtualMachineScaleSetExtension>()
{
GetAzureDiskEncryptionExtension(),
}
};
bool testSucceeded = false;
try
{
StorageAccount storageAccountOutput = CreateStorageAccount(rgName, storageAccountName);
m_CrpClient.VirtualMachineScaleSets.Delete(rgName, "VMScaleSetDoesNotExist");
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;
VirtualMachineScaleSet inputVMScaleSet;
VirtualMachineScaleSet vmScaleSet = CreateVMScaleSet_NoAsyncTracking(
rgName,
vmssName,
storageAccountOutput,
imageRef,
out inputVMScaleSet,
useVmssExtension ? extensionProfile : null,
(vmss) =>
{
vmss.Sku.Name = VirtualMachineSizeTypes.StandardA3;
vmss.Sku.Tier = "Standard";
vmss.VirtualMachineProfile.StorageProfile.OsDisk = new VirtualMachineScaleSetOSDisk()
{
CreateOption = DiskCreateOptionTypes.FromImage,
};
vmss.VirtualMachineProfile.NetworkProfile
.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration = publicipConfiguration;
},
createWithManagedDisks: hasManagedDisks,
createWithPublicIpAddress: false,
subnet: vmssSubnet);
VirtualMachineScaleSetVMInstanceView vmInstanceViewResponse =
m_CrpClient.VirtualMachineScaleSetVMs.GetInstanceView(rgName, vmScaleSet.Name, "0");
Assert.True(vmInstanceViewResponse != null, "VMScaleSetVM not returned.");
ValidateEncryptionSettingsInVMScaleSetVMInstanceView(vmInstanceViewResponse, hasManagedDisks);
m_CrpClient.VirtualMachineScaleSets.Delete(rgName, vmssName);
testSucceeded = 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(testSucceeded);
}
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);
}
}
public void TestFlexVMScaleSetFilter()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
string originalTestLocation = Environment.GetEnvironmentVariable("AZURE_VM_TEST_LOCATION");
EnsureClientsInitialized(context);
ImageReference imageRef = GetPlatformVMImage(useWindowsImage: true);
// 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;
try
{
Environment.SetEnvironmentVariable("AZURE_VM_TEST_LOCATION", "eastus2");
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,
capacity: 2);
String vmssFilterMatch = $"'virtualMachineScaleSet/id' eq '/subscriptions/{m_subId}/resourceGroups/{rgName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmssName}'";
var listResponse = m_CrpClient.VirtualMachines.ListAll(null, vmssFilterMatch);
var vmss = m_CrpClient.VirtualMachineScaleSets.Get(rgName, vmssName);
foreach (VirtualMachine vm in listResponse)
{
Assert.True(string.Equals(vm.VirtualMachineScaleSet.Id, vmss.Id, StringComparison.OrdinalIgnoreCase));
}
m_CrpClient.VirtualMachineScaleSets.Delete(rgName, vmssName);
}
finally
{
m_ResourcesClient.ResourceGroups.DeleteIfExists(rgName);
Environment.SetEnvironmentVariable("AZURE_VM_TEST_LOCATION", originalTestLocation);
}
}
}
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);
}
}
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 = new List <VirtualMachineScaleSetExtension>()
{
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.Item1;
inputVMScaleSet = getTwoVirtualMachineScaleSet.Item2;
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);
}
public void TestVmssFlexDeleteOptionForDisks()
{
string originalTestLocation = Environment.GetEnvironmentVariable("AZURE_VM_TEST_LOCATION");
using (MockContext context = MockContext.Start(this.GetType()))
{
// Hard code the location to "eastus2euap" while feature rolls out to all PROD regions
Environment.SetEnvironmentVariable("AZURE_VM_TEST_LOCATION", "eastus2euap");
EnsureClientsInitialized(context);
ImageReference imageRef = GetPlatformVMImage(useWindowsImage: true);
// 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
{
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;
VirtualMachineScaleSetOSDisk osDisk = new VirtualMachineScaleSetOSDisk
{
Caching = CachingTypes.None,
CreateOption = DiskCreateOptionTypes.FromImage,
DeleteOption = DiskDeleteOptionTypes.Detach,
};
VirtualMachineScaleSetDataDisk dataDisk = new VirtualMachineScaleSetDataDisk
{
Lun = 1,
CreateOption = DiskCreateOptionTypes.Empty,
DeleteOption = DiskDeleteOptionTypes.Detach,
DiskSizeGB = 128,
};
VirtualMachineScaleSet vmScaleSet = CreateVMScaleSet_NoAsyncTracking(
rgName: rgName,
vmssName: vmssName,
storageAccount: null,
imageRef: imageRef,
inputVMScaleSet: out inputVMScaleSet,
singlePlacementGroup: false,
createWithManagedDisks: true,
createWithPublicIpAddress: false,
subnet: vmssSubnet,
vmScaleSetCustomizer:
(virtualMachineScaleSet) => {
virtualMachineScaleSet.UpgradePolicy = null;
virtualMachineScaleSet.Overprovision = null;
virtualMachineScaleSet.PlatformFaultDomainCount = 1;
virtualMachineScaleSet.VirtualMachineProfile.NetworkProfile.NetworkApiVersion = NetworkApiVersion.TwoZeroTwoZeroHyphenMinusOneOneHyphenMinusZeroOne;
virtualMachineScaleSet.VirtualMachineProfile.NetworkProfile
.NetworkInterfaceConfigurations[0].IpConfigurations[0].PublicIPAddressConfiguration = publicipConfiguration;
virtualMachineScaleSet.OrchestrationMode = OrchestrationMode.Flexible.ToString();
virtualMachineScaleSet.VirtualMachineProfile.StorageProfile.OsDisk = osDisk;
virtualMachineScaleSet.VirtualMachineProfile.StorageProfile.DataDisks = new List <VirtualMachineScaleSetDataDisk> {
dataDisk
};
}
);
Assert.Equal(DiskDeleteOptionTypes.Detach, vmScaleSet.VirtualMachineProfile.StorageProfile.OsDisk.DeleteOption);
foreach (VirtualMachineScaleSetDataDisk disk in vmScaleSet.VirtualMachineProfile.StorageProfile.DataDisks)
{
Assert.Equal(DiskDeleteOptionTypes.Detach, disk.DeleteOption);
}
passed = true;
m_CrpClient.VirtualMachineScaleSets.Delete(rgName, vmssName);
}
finally
{
Environment.SetEnvironmentVariable("AZURE_VM_TEST_LOCATION", originalTestLocation);
m_ResourcesClient.ResourceGroups.Delete(rgName);
}
Assert.True(passed);
}
}
