protected PublicIPAddress CreatePublicIP(string rgName)
{
// Create publicIP
string publicIpName = ComputeManagementTestUtilities.GenerateName("pip");
string domainNameLabel = ComputeManagementTestUtilities.GenerateName("dn");
var publicIp = new PublicIPAddress()
{
Location = m_location,
Tags = new Dictionary <string, string>()
{
{ "key", "value" }
},
PublicIPAllocationMethod = IPAllocationMethod.Dynamic,
DnsSettings = new PublicIPAddressDnsSettings()
{
DomainNameLabel = domainNameLabel
}
};
var putPublicIpAddressResponse = m_NrpClient.PublicIPAddresses.CreateOrUpdate(rgName, publicIpName, publicIp);
var getPublicIpAddressResponse = m_NrpClient.PublicIPAddresses.Get(rgName, publicIpName);
return(getPublicIpAddressResponse);
}
protected PublicIPAddress CreatePublicIP(string publicIPAddressName, string resourceGroupName, string dnsName)
{
PublicIPAddress publicIPAddressParams = GeneratePublicIPAddressModel(publicIPAddressName, dnsName);
PublicIPAddress publicIpAddress = m_NrpClient.PublicIPAddresses.CreateOrUpdate(resourceGroupName, publicIPAddressName, publicIPAddressParams);
return(publicIpAddress);
}
async Task <PublicIPAddress> SetupPublicIPAsync(ApiManagementTestBase testBase)
{
// put Public IP
string publicIpName = TestUtilities.GenerateName();
string domainNameLabel = TestUtilities.GenerateName(testBase.rgName);
var publicIp = new PublicIPAddress()
{
Location = testBase.location,
Tags = new Dictionary <string, string>()
{
{ "key", "value" }
},
PublicIPAllocationMethod = IPAllocationMethod.Static,
PublicIPAddressVersion = "IPv4",
DnsSettings = new PublicIPAddressDnsSettings()
{
DomainNameLabel = domainNameLabel
},
Sku = new PublicIPAddressSku()
{
Name = "Standard"
}
};
var putPublicIPResponse = await testBase.networkClient.PublicIPAddresses.CreateOrUpdateAsync(testBase.rgName, publicIpName, publicIp);
Assert.Equal("Succeeded", putPublicIPResponse.ProvisioningState);
return(putPublicIPResponse);
}
public static PublicIPAddress CreateDefaultPublicIpAddress(string name, string resourceGroupName, string domainNameLabel, string location,
NetworkManagementClient nrpClient)
{
var publicIp = new PublicIPAddress()
{
Location = location,
Tags = new Dictionary <string, string>()
{
{ "key", "value" }
},
PublicIPAllocationMethod = IPAllocationMethod.Dynamic,
DnsSettings = new PublicIPAddressDnsSettings()
{
DomainNameLabel = domainNameLabel
}
};
// Put nic1PublicIpAddress
var putPublicIpAddressResponse = nrpClient.PublicIPAddresses.CreateOrUpdate(resourceGroupName, name, publicIp);
Assert.Equal("Succeeded", putPublicIpAddressResponse.ProvisioningState);
var getPublicIpAddressResponse = nrpClient.PublicIPAddresses.Get(resourceGroupName, name);
return(getPublicIpAddressResponse);
}
public async Task PublicIpAddressApiTest()
{
string resourceGroupName = Recording.GenerateAssetName("csmrg");
string location = await NetworkManagementTestUtilities.GetResourceLocation(ResourceManagementClient, "Microsoft.Network/publicIPAddresses");
await ResourceGroupsOperations.CreateOrUpdateAsync(resourceGroupName, new ResourceGroup(location));
// Create the parameter for PUT PublicIPAddress
string publicIpName = Recording.GenerateAssetName("ipname");
string domainNameLabel = Recording.GenerateAssetName("domain");
PublicIPAddress publicIp = new PublicIPAddress()
{
Location = location,
Tags = { { "key", "value" } },
PublicIPAllocationMethod = IPAllocationMethod.Dynamic,
DnsSettings = new PublicIPAddressDnsSettings()
{
DomainNameLabel = domainNameLabel
}
};
// Put PublicIPAddress
PublicIPAddressesCreateOrUpdateOperation putPublicIpAddressResponseOperation = await NetworkManagementClient.PublicIPAddresses.StartCreateOrUpdateAsync(resourceGroupName, publicIpName, publicIp);
Response <PublicIPAddress> putPublicIpAddressResponse = await WaitForCompletionAsync(putPublicIpAddressResponseOperation);
Assert.AreEqual("Succeeded", putPublicIpAddressResponse.Value.ProvisioningState.ToString());
// Get PublicIPAddress
Response <PublicIPAddress> getPublicIpAddressResponse = await NetworkManagementClient.PublicIPAddresses.GetAsync(resourceGroupName, publicIpName);
Assert.AreEqual(4, getPublicIpAddressResponse.Value.IdleTimeoutInMinutes);
Assert.NotNull(getPublicIpAddressResponse.Value.ResourceGuid);
// Get List of PublicIPAddress
AsyncPageable <PublicIPAddress> getPublicIpAddressListResponseAP = NetworkManagementClient.PublicIPAddresses.ListAsync(resourceGroupName);
List <PublicIPAddress> getPublicIpAddressListResponse = await getPublicIpAddressListResponseAP.ToEnumerableAsync();
Has.One.EqualTo(getPublicIpAddressListResponse);
ArePublicIpAddressesEqual(getPublicIpAddressResponse, getPublicIpAddressListResponse.First());
// Get List of PublicIPAddress in a subscription
AsyncPageable <PublicIPAddress> getPublicIpAddressListSubscriptionResponseAP = NetworkManagementClient.PublicIPAddresses.ListAllAsync();
List <PublicIPAddress> getPublicIpAddressListSubscriptionResponse = await getPublicIpAddressListSubscriptionResponseAP.ToEnumerableAsync();
Assert.IsNotEmpty(getPublicIpAddressListSubscriptionResponse);
// Delete PublicIPAddress
PublicIPAddressesDeleteOperation deleteOperation = await NetworkManagementClient.PublicIPAddresses.StartDeleteAsync(resourceGroupName, publicIpName);
await WaitForCompletionAsync(deleteOperation);
// Get PublicIPAddress
getPublicIpAddressListResponseAP = NetworkManagementClient.PublicIPAddresses.ListAsync(resourceGroupName);
getPublicIpAddressListResponse = await getPublicIpAddressListResponseAP.ToEnumerableAsync();
Assert.IsEmpty(getPublicIpAddressListResponse);
}
public async Task TestSetUp()
{
var client = GetArmClient();
_resourceGroup = await client.GetResourceGroup(_resourceGroupIdentifier).GetAsync();
_network = await _resourceGroup.GetVirtualNetworks().GetAsync(_networkIdentifier.Name);
_publicIPAddress = await _resourceGroup.GetPublicIPAddresses().GetAsync(_publicIPAddressIdentifier.Name);
}
public async Task <PublicIPAddress> CreateDefaultPublicIpAddress(string name, string resourceGroupName, string domainNameLabel, string location,
NetworkManagementClient nrpClient)
{
PublicIPAddress publicIp = new PublicIPAddress()
{
Location = location,
Tags = new Dictionary <string, string>()
{
{ "key", "value" }
},
PublicIPAllocationMethod = IPAllocationMethod.Dynamic,
DnsSettings = new PublicIPAddressDnsSettings()
{
DomainNameLabel = domainNameLabel
}
};
// Put nic1PublicIpAddress
Operation <PublicIPAddress> putPublicIpAddressOperation = await nrpClient.PublicIPAddresses.StartCreateOrUpdateAsync(resourceGroupName, name, publicIp);
Response <PublicIPAddress> putPublicIpAddressResponse = await WaitForCompletionAsync(putPublicIpAddressOperation);
Assert.AreEqual("Succeeded", putPublicIpAddressResponse.Value.ProvisioningState.ToString());
Response <PublicIPAddress> getPublicIpAddressResponse = await nrpClient.PublicIPAddresses.GetAsync(resourceGroupName, name);
return(getPublicIpAddressResponse);
}
internal IPConfiguration(string id, string name, string etag, string privateIPAddress, IPAllocationMethod?privateIPAllocationMethod, Subnet subnet, PublicIPAddress publicIPAddress, ProvisioningState?provisioningState) : base(id)
{
Name = name;
Etag = etag;
PrivateIPAddress = privateIPAddress;
PrivateIPAllocationMethod = privateIPAllocationMethod;
Subnet = subnet;
PublicIPAddress = publicIPAddress;
ProvisioningState = provisioningState;
}
public async Task VmssNetworkInterfaceApiTest()
{
string resourceGroupName = Recording.GenerateAssetName("azsmnet");
string location = await NetworkManagementTestUtilities.GetResourceLocation(ResourceManagementClient, "Microsoft.Compute/virtualMachineScaleSets");
string deploymentName = Recording.GenerateAssetName("vmss");
await ResourceGroupsOperations.CreateOrUpdateAsync(resourceGroupName, new ResourceGroup(location));
await CreateVmss(ResourceManagementClient, resourceGroupName, deploymentName);
string virtualMachineScaleSetName = "vmssip";
AsyncPageable <PublicIPAddress> vmssListAllPageResultAP = NetworkManagementClient.PublicIPAddresses.ListVirtualMachineScaleSetPublicIPAddressesAsync(resourceGroupName, virtualMachineScaleSetName);
List <PublicIPAddress> vmssListAllPageResult = await vmssListAllPageResultAP.ToEnumerableAsync();
List <PublicIPAddress> vmssListAllResult = vmssListAllPageResult.ToList();
PublicIPAddress firstResult = vmssListAllResult.First();
Assert.NotNull(vmssListAllResult);
Assert.AreEqual("Succeeded", firstResult.ProvisioningState.ToString());
Assert.NotNull(firstResult.ResourceGuid);
string idItem = firstResult.Id;
string vmIndex = GetNameById(idItem, "virtualMachines");
string nicName = GetNameById(idItem, "networkInterfaces");
// Verify that NICs contain refernce to publicip, nsg and dns settings
AsyncPageable <NetworkInterface> listNicPerVmssAP = NetworkManagementClient.NetworkInterfaces.ListVirtualMachineScaleSetNetworkInterfacesAsync(resourceGroupName, virtualMachineScaleSetName);
List <NetworkInterface> listNicPerVmss = await listNicPerVmssAP.ToEnumerableAsync();
Assert.NotNull(listNicPerVmss);
foreach (NetworkInterface nic in listNicPerVmss)
{
VerifyVmssNicProperties(nic);
}
// Verify nics on a vm level
AsyncPageable <NetworkInterface> listNicPerVmAP = NetworkManagementClient.NetworkInterfaces.ListVirtualMachineScaleSetVMNetworkInterfacesAsync(resourceGroupName, virtualMachineScaleSetName, vmIndex);
List <NetworkInterface> listNicPerVm = await listNicPerVmAP.ToEnumerableAsync();
Assert.NotNull(listNicPerVm);
Has.One.EqualTo(listNicPerVm);
foreach (NetworkInterface nic in listNicPerVm)
{
VerifyVmssNicProperties(nic);
}
// Verify getting individual nic
Response <NetworkInterface> getNic = await NetworkManagementClient.NetworkInterfaces.GetVirtualMachineScaleSetNetworkInterfaceAsync(resourceGroupName, virtualMachineScaleSetName, vmIndex, nicName);
Assert.NotNull(getNic);
VerifyVmssNicProperties(getNic);
}
public ArmBuilder <PublicIpAddress, PublicIPAddressData> Construct(Location location = null)
{
var ipAddress = new PublicIPAddress()
{
PublicIPAddressVersion = IPVersion.IPv4.ToString(),
PublicIPAllocationMethod = IPAllocationMethod.Dynamic,
Location = location ?? DefaultLocation,
};
return(new ArmBuilder <PublicIpAddress, PublicIPAddressData>(this, new PublicIPAddressData(ipAddress)));
}
public static AzurePublicIpAddress ConstructIPAddress(this AzureResourceGroupBase resourceGroup)
{
var ipAddress = new PublicIPAddress()
{
PublicIPAddressVersion = Azure.ResourceManager.Network.Models.IPVersion.IPv4.ToString(),
PublicIPAllocationMethod = IPAllocationMethod.Dynamic,
Location = resourceGroup.Location,
};
return(new AzurePublicIpAddress(resourceGroup, new PhPublicIPAddress(ipAddress)));
}
private static void ArePublicIpAddressesEqual(PublicIPAddress publicIpAddress1, PublicIPAddress publicIpAddress2)
{
Assert.Equal(publicIpAddress1.Name, publicIpAddress2.Name);
Assert.Equal(publicIpAddress1.Location, publicIpAddress2.Location);
Assert.Equal(publicIpAddress1.Id, publicIpAddress2.Id);
Assert.Equal(publicIpAddress1.DnsSettings.DomainNameLabel, publicIpAddress2.DnsSettings.DomainNameLabel);
Assert.Equal(publicIpAddress1.DnsSettings.Fqdn, publicIpAddress2.DnsSettings.Fqdn);
Assert.Equal(publicIpAddress1.IdleTimeoutInMinutes, publicIpAddress2.IdleTimeoutInMinutes);
Assert.Equal(publicIpAddress1.Tags.Count, publicIpAddress2.Tags.Count);
Assert.Equal(publicIpAddress1.PublicIPAddressVersion, publicIpAddress2.PublicIPAddressVersion);
}
public PSPublicIpAddress ToPsPublicIpAddress(PublicIPAddress publicIp)
{
var psPublicIpAddress = Mapper.Map<PSPublicIpAddress>(publicIp);
psPublicIpAddress.Tag = TagsConversionHelper.CreateTagHashtable(publicIp.Tags);
if (string.IsNullOrEmpty(psPublicIpAddress.IpAddress))
{
psPublicIpAddress.IpAddress = "Not Assigned";
}
return psPublicIpAddress;
}
public PSPublicIpAddress ToPsPublicIpAddress(PublicIPAddress publicIp)
{
var psPublicIpAddress = Mapper.Map <PSPublicIpAddress>(publicIp);
psPublicIpAddress.Tag = TagsConversionHelper.CreateTagHashtable(publicIp.Tags);
if (string.IsNullOrEmpty(psPublicIpAddress.IpAddress))
{
psPublicIpAddress.IpAddress = "Not Assigned";
}
return(psPublicIpAddress);
}
/// <summary>
/// Construct an object used to create a public IP address.
/// </summary>
/// <param name="location"> The location to create the network security group. </param>
/// <returns> Object used to create a <see cref="PublicIpAddress"/>. </returns>
public ArmBuilder <PublicIpAddress, PublicIPAddressData> Construct(LocationData location = null)
{
var parent = GetParentResource <ResourceGroup, ResourceGroupOperations>();
var ipAddress = new PublicIPAddress()
{
PublicIPAddressVersion = IPVersion.IPv4.ToString(),
PublicIPAllocationMethod = IPAllocationMethod.Dynamic,
Location = location ?? parent.Data.Location,
};
return(new ArmBuilder <PublicIpAddress, PublicIPAddressData>(this, new PublicIPAddressData(ipAddress)));
}
public async Task TestSetUp()
{
var client = GetArmClient();
var _ = await client.GetDefaultSubscriptionAsync(); // TODO: hack to avoid mismatch of recordings so we don't need to re-record for the change. Remove when you need to run live tests next time.
_resourceGroup = await client.GetResourceGroup(_resourceGroupIdentifier).GetAsync();
VirtualNetwork vnet = await _resourceGroup.GetVirtualNetworks().GetAsync(_subnetIdentifier.Parent.Name);
_subnet = await vnet.GetSubnets().GetAsync(_subnetIdentifier.Name);
_publicIPAddress = await _resourceGroup.GetPublicIPAddresses().GetAsync(_publicIPAddressIdentifier.Name);
}
public async Task GlobalSetUp()
{
Subscription subscription = await GlobalClient.GetDefaultSubscriptionAsync();
var rgLro = await subscription.GetResourceGroups().CreateOrUpdateAsync(true, SessionRecording.GenerateAssetName("FirewallRG-"), new ResourceGroupData(AzureLocation.WestUS2));
ResourceGroup rg = rgLro.Value;
_resourceGroupIdentifier = rg.Id;
VirtualNetworkData vnetData = new VirtualNetworkData()
{
Location = AzureLocation.WestUS2,
AddressSpace = new AddressSpace()
{
AddressPrefixes = { "10.20.0.0/16", }
},
Subnets =
{
new SubnetData()
{
Name = "Default", AddressPrefix = "10.20.1.0/26",
},
new SubnetData()
{
Name = "AzureFirewallSubnet", AddressPrefix = "10.20.2.0/26",
},
},
};
var vnetLro = await rg.GetVirtualNetworks().CreateOrUpdateAsync(true, SessionRecording.GenerateAssetName("vnet-"), vnetData);
_network = vnetLro.Value;
_networkIdentifier = _network.Id;
PublicIPAddressData ipData = new PublicIPAddressData()
{
Location = AzureLocation.WestUS2,
PublicIPAllocationMethod = IPAllocationMethod.Static,
Sku = new PublicIPAddressSku()
{
Name = PublicIPAddressSkuName.Standard
},
};
var ipLro = await rg.GetPublicIPAddresses().CreateOrUpdateAsync(true, SessionRecording.GenerateAssetName("publicIp-"), ipData);
_publicIPAddress = ipLro.Value;
_publicIPAddressIdentifier = _publicIPAddress.Id;
_firewallName = SessionRecording.GenerateAssetName("firewall-");
await StopSessionRecordingAsync();
}
public static void PrintIPAddress(PublicIPAddress publicIPAddress)
{
Utilities.Log(new StringBuilder().Append("Public IP Address: ").Append(publicIPAddress.Id)
.Append("Name: ").Append(publicIPAddress.Name)
.Append("\n\tLocation: ").Append(publicIPAddress.Location)
.Append("\n\tTags: ").Append(FormatDictionary(publicIPAddress.Tags))
.Append("\n\tIP Address: ").Append(publicIPAddress.IpAddress)
.Append("\n\tLeaf domain label: ").Append(publicIPAddress.DnsSettings.DomainNameLabel)
.Append("\n\tFQDN: ").Append(publicIPAddress.DnsSettings.Fqdn)
.Append("\n\tReverse FQDN: ").Append(publicIPAddress.DnsSettings.ReverseFqdn)
.Append("\n\tIdle timeout (minutes): ").Append(publicIPAddress.IdleTimeoutInMinutes)
.Append("\n\tIP allocation method: ").Append(publicIPAddress.PublicIPAllocationMethod)
.ToString());
}
protected PublicIPAddress GeneratePublicIPAddressModel(string publicIPAddressName, string dnsName)
{
PublicIPAddress publicIPAddressParams = new PublicIPAddress(name: publicIPAddressName)
{
Location = m_location,
PublicIPAllocationMethod = IPAllocationMethod.Dynamic,
DnsSettings = new PublicIPAddressDnsSettings()
{
DomainNameLabel = dnsName
}
};
return(publicIPAddressParams);
}
public override bool Validate()
{
// TODO add these under a timeout
try
{
// TODO Include test name in the logs
logger.Info("Validations for Linux in progress...");
var token = AzureHelper.GetAccessTokenAsync();
var credential = new TokenCredentials(token.Result.AccessToken);
bool ifCustomDataValid = true;
PublicIPAddress ipAddress = AzureHelper.GetPublicAddressAsync(credential, groupName, subscriptionId, "myPublicIP").Result;
using (var client = new SshClient(ipAddress.IpAddress, username, password))
{
client.Connect();
SshCommand command = client.RunCommand("echo 'hello'");
logger.Info("Result of command 'x': " + command.Result);
if (!string.IsNullOrWhiteSpace(customData))
{
command = client.RunCommand("echo '<PASSWORD>' | sudo -S cat /var/lib/waagent/CustomData");
ifCustomDataValid = command.Result.Contains(customData);
}
client.Disconnect();
}
if (!ifCustomDataValid)
{
throw new ArgumentException("Incorrect custom data!!");
}
logger.Info("Validations for Linux...success!!");
}
catch (Exception e)
{
logger.Error(e);
return(false);
}
return(true);
}
public static void UseExistingPublicIP(this NetworkInterface nic, PublicIPAddress publicIp)
{
EnsureIpConfigrationsCollectionInitialized(nic);
if (nic.IpConfigurations.Count == 0)
{
nic.IpConfigurations.Add(new NetworkInterfaceIPConfiguration()
{
Name = "Primary",
Primary = true,
});
}
nic.IpConfigurations.First().PublicIPAddress = new PublicIPAddress()
{
Id = publicIp.Id
};
}
public static NetworkInterface CreateNetworkInterface(SqlVirtualMachineTestContext context, VirtualNetwork virtualNetwork = null, NetworkSecurityGroup networkSecurityGroup = null)
{
// Create NIC
MockClient client = context.client;
ComputeManagementClient computeClient = client.computeClient;
// Create virtual network
string subnetName = context.generateResourceName();
if (virtualNetwork == null)
{
virtualNetwork = CreateVirtualNetwork(context, subnetName: subnetName);
}
Subnet subnet = virtualNetwork.Subnets[0];
// Create pbulic IP address
PublicIPAddress publicIPAddress = CreatePublicIP(context);
// Create Network security group
if (networkSecurityGroup == null)
{
networkSecurityGroup = CreateNsg(context);
}
NetworkInterface nicParameters = new NetworkInterface()
{
Location = context.location,
IpConfigurations = new List <NetworkInterfaceIPConfiguration>()
{
new NetworkInterfaceIPConfiguration()
{
Name = context.generateResourceName(),
Subnet = subnet,
PrivateIPAllocationMethod = IPAllocationMethod.Dynamic,
PublicIPAddress = publicIPAddress
}
},
NetworkSecurityGroup = networkSecurityGroup
};
string nicName = context.generateResourceName();
client.networkClient.NetworkInterfaces.CreateOrUpdate(context.resourceGroup.Name, nicName, nicParameters);
return(client.networkClient.NetworkInterfaces.Get(context.resourceGroup.Name, nicName));
}
public async Task VmssPublicIpAddressApiTest()
{
string resourceGroupName = Recording.GenerateAssetName("azsmnet");
string location = await NetworkManagementTestUtilities.GetResourceLocation(ResourceManagementClient, "Microsoft.Compute/virtualMachineScaleSets");
string deploymentName = Recording.GenerateAssetName("vmss");
await ResourceGroupsOperations.CreateOrUpdateAsync(resourceGroupName, new ResourceGroup(location));
await CreateVmss(ResourceManagementClient, resourceGroupName, deploymentName);
string virtualMachineScaleSetName = "vmssip";
AsyncPageable <PublicIPAddress> vmssListAllPageResultAP = NetworkManagementClient.PublicIPAddresses.ListVirtualMachineScaleSetPublicIPAddressesAsync(resourceGroupName, virtualMachineScaleSetName);
List <PublicIPAddress> vmssListAllPageResult = await vmssListAllPageResultAP.ToEnumerableAsync();
List <PublicIPAddress> vmssListAllResult = vmssListAllPageResult.ToList();
PublicIPAddress firstResult = vmssListAllResult.First();
Assert.NotNull(vmssListAllResult);
Assert.AreEqual("Succeeded", firstResult.ProvisioningState.ToString());
Assert.NotNull(firstResult.ResourceGuid);
string idItem = firstResult.Id;
string vmIndex = GetNameById(idItem, "virtualMachines");
string nicName = GetNameById(idItem, "networkInterfaces");
string ipConfigName = GetNameById(idItem, "ipConfigurations");
string ipName = GetNameById(idItem, "publicIPAddresses");
AsyncPageable <PublicIPAddress> vmssListPageResultAP = NetworkManagementClient.PublicIPAddresses.ListVirtualMachineScaleSetVMPublicIPAddressesAsync(
resourceGroupName, virtualMachineScaleSetName, vmIndex, nicName, ipConfigName);
List <PublicIPAddress> vmssListPageResult = await vmssListPageResultAP.ToEnumerableAsync();
List <PublicIPAddress> vmssListResult = vmssListPageResult.ToList();
Has.One.EqualTo(vmssListResult);
Response <PublicIPAddress> vmssGetResult = await NetworkManagementClient.PublicIPAddresses.GetVirtualMachineScaleSetPublicIPAddressAsync(
resourceGroupName, virtualMachineScaleSetName, vmIndex, nicName, ipConfigName, ipName);
Assert.NotNull(vmssGetResult);
Assert.AreEqual("Succeeded", vmssGetResult.Value.ProvisioningState.ToString());
Assert.NotNull(vmssGetResult.Value.ResourceGuid);
}
protected PublicIPAddress CreatePublicIP(string rgName)
{
// Create publicIP
string publicIpName = "pip5913";
string domainNameLabel = "dn5913";
PublicIPAddress publicIp = null;
try
{
publicIp = NetworkClient.PublicIPAddresses.Get(rgName, publicIpName);
}
catch { }
if (publicIp == null)
{
publicIp = new PublicIPAddress()
{
Location = DEFAULT_LOCATION,
Tags = new Dictionary <string, string>()
{
{ "key", "value" }
},
PublicIPAllocationMethod = IPAllocationMethod.Dynamic,
DnsSettings = new PublicIPAddressDnsSettings()
{
DomainNameLabel = domainNameLabel
}
};
var putPublicIpAddressResponse = NetworkClient.PublicIPAddresses.CreateOrUpdate(rgName, publicIpName, publicIp);
var getPublicIpAddressResponse = NetworkClient.PublicIPAddresses.Get(rgName, publicIpName);
publicIp = getPublicIpAddressResponse;
}
return(publicIp);
}
public static PublicIPAddress CreatePublicIP(SqlVirtualMachineTestContext context, PublicIPAddress publicIp = null)
{
string publicIpName = context.generateResourceName();
string domainNameLabel = context.generateResourceName();
if (publicIp == null)
{
publicIp = new PublicIPAddress()
{
Location = context.location,
Tags = new Dictionary <string, string>()
{
{ "key", "value" }
},
PublicIPAllocationMethod = IPAllocationMethod.Dynamic,
DnsSettings = new PublicIPAddressDnsSettings()
{
DomainNameLabel = domainNameLabel
}
};
}
context.client.networkClient.PublicIPAddresses.CreateOrUpdate(context.resourceGroup.Name, publicIpName, publicIp);
return(context.client.networkClient.PublicIPAddresses.Get(context.resourceGroup.Name, publicIpName));
}
public async Task CreateOrUpdate()
{
VirtualNetworkCollection virtualNetworkCollection = resourceGroup.GetVirtualNetworks();
string vnetName = "myVnet";
// Use the same location as the resource group
VirtualNetworkData vnetInput = new VirtualNetworkData()
{
Location = resourceGroup.Data.Location,
AddressSpace = new AddressSpace()
{
AddressPrefixes = { "10.0.0.0/16", }
},
DhcpOptions = new DhcpOptions()
{
DnsServers = { "10.1.1.1", "10.1.2.4" }
},
Subnets = { new SubnetData()
{
Name = "mySubnet", AddressPrefix = "10.0.1.0/24"
} }
};
VirtualNetwork virtualNetwork = await virtualNetworkCollection.CreateOrUpdate(vnetName, vnetInput).WaitForCompletionAsync();
#region Snippet:Managing_Networks_CreateANetworkInterface
PublicIPAddressCollection publicIPAddressCollection = resourceGroup.GetPublicIPAddresses();
string publicIPAddressName = "myIPAddress";
PublicIPAddressData publicIPInput = new PublicIPAddressData()
{
Location = resourceGroup.Data.Location,
PublicIPAllocationMethod = IPAllocationMethod.Dynamic,
DnsSettings = new PublicIPAddressDnsSettings()
{
DomainNameLabel = "myDomain"
}
};
PublicIPAddress publicIPAddress = await publicIPAddressCollection.CreateOrUpdate(publicIPAddressName, publicIPInput).WaitForCompletionAsync();
NetworkInterfaceCollection networkInterfaceCollection = resourceGroup.GetNetworkInterfaces();
string networkInterfaceName = "myNetworkInterface";
NetworkInterfaceData networkInterfaceInput = new NetworkInterfaceData()
{
Location = resourceGroup.Data.Location,
IpConfigurations =
{
new NetworkInterfaceIPConfiguration()
{
Name = "ipConfig",
PrivateIPAllocationMethod = IPAllocationMethod.Dynamic,
PublicIPAddress = new PublicIPAddressData()
{
Id = publicIPAddress.Id
},
Subnet = new SubnetData()
{
// use the virtual network just created
Id = virtualNetwork.Data.Subnets[0].Id
}
}
}
};
NetworkInterface networkInterface = await networkInterfaceCollection.CreateOrUpdate(networkInterfaceName, networkInterfaceInput).WaitForCompletionAsync();
#endregion
}
public void PublicIpAddressApiTestWithIdletTimeoutAndReverseFqdn()
{
var handler1 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
var handler2 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
using (MockContext context = MockContext.Start(this.GetType()))
{
var resourcesClient = ResourcesManagementTestUtilities.GetResourceManagementClientWithHandler(context, handler1);
var networkManagementClient = NetworkManagementTestUtilities.GetNetworkManagementClientWithHandler(context, handler2);
var location = ResourcesManagementTestUtilities.GetResourceLocation(resourcesClient, "Microsoft.Network/publicIPAddresses");
string resourceGroupName = TestUtilities.GenerateName("csmrg");
resourcesClient.ResourceGroups.CreateOrUpdate(resourceGroupName,
new ResourceGroup
{
Location = location
});
// Create the parameter for PUT PublicIPAddress
string publicIpName = TestUtilities.GenerateName();
string domainNameLabel = TestUtilities.GenerateName();
string reverseFqdn;
var publicIp = new PublicIPAddress()
{
Location = location,
Tags = new Dictionary <string, string>()
{
{ "key", "value" }
},
PublicIPAllocationMethod = IPAllocationMethod.Dynamic,
DnsSettings = new PublicIPAddressDnsSettings()
{
DomainNameLabel = domainNameLabel,
},
IdleTimeoutInMinutes = 16,
};
// Put PublicIPAddress
var putPublicIpAddressResponse = networkManagementClient.PublicIPAddresses.CreateOrUpdate(resourceGroupName, publicIpName, publicIp);
Assert.Equal("Succeeded", putPublicIpAddressResponse.ProvisioningState);
// Get PublicIPAddress
var getPublicIpAddressResponse = networkManagementClient.PublicIPAddresses.Get(resourceGroupName, publicIpName);
// Add Reverse FQDN
reverseFqdn = getPublicIpAddressResponse.DnsSettings.Fqdn;
getPublicIpAddressResponse.DnsSettings.ReverseFqdn = reverseFqdn;
putPublicIpAddressResponse = networkManagementClient.PublicIPAddresses.CreateOrUpdate(resourceGroupName, publicIpName, getPublicIpAddressResponse);
Assert.Equal("Succeeded", putPublicIpAddressResponse.ProvisioningState);
// Get PublicIPAddress
getPublicIpAddressResponse = networkManagementClient.PublicIPAddresses.Get(resourceGroupName, publicIpName);
Assert.Equal(16, getPublicIpAddressResponse.IdleTimeoutInMinutes);
Assert.Equal(reverseFqdn, getPublicIpAddressResponse.DnsSettings.ReverseFqdn);
// Get List of PublicIPAddress
var getPublicIpAddressListResponse = networkManagementClient.PublicIPAddresses.List(resourceGroupName);
Assert.Single(getPublicIpAddressListResponse);
ArePublicIpAddressesEqual(getPublicIpAddressResponse, getPublicIpAddressListResponse.First());
// Get List of PublicIPAddress in a subscription
var getPublicIpAddressListSubscriptionResponse = networkManagementClient.PublicIPAddresses.ListAll();
Assert.NotEmpty(getPublicIpAddressListSubscriptionResponse);
// Delete PublicIPAddress
networkManagementClient.PublicIPAddresses.Delete(resourceGroupName, publicIpName);
// Get PublicIPAddress
getPublicIpAddressListResponse = networkManagementClient.PublicIPAddresses.List(resourceGroupName);
Assert.Empty(getPublicIpAddressListResponse);
}
}
public MyStack()
{
var tags = new InputMap <string> {
{ "resourceType", "Service Fabric" },
{ "clusterName", "thepulsf" }
};
// Create an Azure Resource Group
var resourceGroup = new ResourceGroup("resourceGroup", new ResourceGroupArgs
{
ResourceGroupName = "apulsf",
Location = "SoutheastAsia",
Tags = tags,
});
// Create a Storage Account for Log
var storageAccountLog = new StorageAccount("saLog", new StorageAccountArgs
{
ResourceGroupName = resourceGroup.Name,
AccountName = "sflogstore",
Location = resourceGroup.Location,
Sku = new SkuArgs
{
Name = "Standard_LRS",
Tier = "Standard"
},
Kind = "StorageV2",
Tags = tags,
});
// Create a Storage Account for Application Diagnostics
var storageAccountAppDx = new StorageAccount("saAppDx", new StorageAccountArgs
{
ResourceGroupName = resourceGroup.Name,
AccountName = "sfappdxstore",
Location = resourceGroup.Location,
Sku = new SkuArgs
{
Name = "Standard_LRS",
Tier = "Standard"
},
Kind = "StorageV2",
Tags = tags,
});
// Virtual Network
var vnet = new VirtualNetwork("vnet", new VirtualNetworkArgs {
ResourceGroupName = resourceGroup.Name,
VirtualNetworkName = "thevnet4sf",
Location = resourceGroup.Location,
AddressSpace = new nwin.AddressSpaceArgs {
AddressPrefixes = "10.10.0.0/16",
},
Subnets =
{
new nwin.SubnetArgs {
Name = "Subnet0",
AddressPrefix = "10.10.10.0/24",
}
},
Tags = tags,
});
// Public IP Address
var pubIpAddr = new PublicIPAddress("pubip4sf", new PublicIPAddressArgs {
ResourceGroupName = resourceGroup.Name,
PublicIpAddressName = "thesfpubip",
Location = resourceGroup.Location,
DnsSettings = new nwin.PublicIPAddressDnsSettingsArgs {
DomainNameLabel = "thepulsf",
},
PublicIPAllocationMethod = "Dynamic",
Tags = tags,
});
// Load Balancer
var loadBalancer = new LoadBalancer("lb", new LoadBalancerArgs {
ResourceGroupName = resourceGroup.Name,
Location = resourceGroup.Location,
LoadBalancerName = "thepulsflb4set0",
FrontendIPConfigurations = new nwin.FrontendIPConfigurationArgs {
Name = "lbipconfig",
PublicIPAddress = new nwin.PublicIPAddressArgs {
Id = pubIpAddr.Id,
},
},
Tags = tags,
});
var bepool0 = new lb.BackendAddressPool("bepool0", new lb.BackendAddressPoolArgs {
Name = "bepool0",
ResourceGroupName = resourceGroup.Name,
LoadbalancerId = loadBalancer.Id,
});
var lbPorts = new [] { 19000, 19080, 80, 443 };
for (int i = 0; i < lbPorts.Length; i++)
{
var port = lbPorts[i];
var probe = new lb.Probe($"lbProbe{i}", new lb.ProbeArgs {
ResourceGroupName = resourceGroup.Name,
LoadbalancerId = loadBalancer.Id,
Port = port,
IntervalInSeconds = 5,
NumberOfProbes = 2,
Protocol = "tcp",
});
var rule = new lb.Rule($"lbRule{i}", new lb.RuleArgs {
ResourceGroupName = resourceGroup.Name,
LoadbalancerId = loadBalancer.Id,
FrontendIpConfigurationName = "lbipconfig",
FrontendPort = port,
BackendAddressPoolId = bepool0.Id,
BackendPort = port,
IdleTimeoutInMinutes = 5,
EnableFloatingIp = false,
Protocol = "tcp",
});
}
var lbNatPool = new lb.NatPool("lbNatPool", new lb.NatPoolArgs {
ResourceGroupName = resourceGroup.Name,
LoadbalancerId = loadBalancer.Id,
FrontendIpConfigurationName = "lbipconfig",
FrontendPortStart = 3389,
FrontendPortEnd = 4500,
BackendPort = 3389,
Protocol = "tcp",
});
var sfCluster = new Cluster("thesf", new ClusterArgs {
ClusterName = "thesf",
ResourceGroupName = resourceGroup.Name,
Location = resourceGroup.Location,
AddOnFeatures =
{
"DnsService",
"BackupRestoreService"
},
Certificate = new sfi.CertificateDescriptionArgs {
Thumbprint = "4426C164D9E66C2C813DEEC0486F235C0E933212",
X509StoreName = "My",
},
DiagnosticsStorageAccountConfig = new sfi.DiagnosticsStorageAccountConfigArgs {
BlobEndpoint = storageAccountLog.PrimaryEndpoints.Apply(it => it.Blob),
ProtectedAccountKeyName = "StorageAccountKey1",
QueueEndpoint = storageAccountLog.PrimaryEndpoints.Apply(it => it.Queue),
StorageAccountName = storageAccountLog.Name,
TableEndpoint = storageAccountLog.PrimaryEndpoints.Apply(it => it.Table),
},
FabricSettings =
{
new sfi.SettingsSectionDescriptionArgs {
Parameters =
{
new sfi.SettingsParameterDescriptionArgs {
Name = "SecretEncryptionCertThumbprint",
Value = "4426C164D9E66C2C813DEEC0486F235C0E933212",
},
new sfi.SettingsParameterDescriptionArgs {
Name = "SecretEncryptionCertX509StoreName",
Value = "My",
},
},
Name = "BackupRestoreService",
},
new sfi.SettingsSectionDescriptionArgs {
Parameters =
{
new sfi.SettingsParameterDescriptionArgs {
Name = "ClusterProtectionLevel",
Value = "EncryptAndSign",
},
},
Name = "Security",
},
},
ManagementEndpoint = Output.Format($"https://{pubIpAddr.DnsSettings.Apply(it => it?.Fqdn)}:19080"),
NodeTypes =
{
new sfi.NodeTypeDescriptionArgs {
Name = "Type925",
ApplicationPorts = new sfi.EndpointRangeDescriptionArgs{
StartPort = 20000,
EndPort = 30000,
},
ClientConnectionEndpointPort = 19000,
DurabilityLevel = "Silver",
EphemeralPorts = new sfi.EndpointRangeDescriptionArgs {
StartPort = 49152,
EndPort = 65534,
},
HttpGatewayEndpointPort = 19080,
IsPrimary = true,
VmInstanceCount = 5,
},
},
ReliabilityLevel = "Silver",
UpgradeMode = "Automatic",
VmImage = "Windows",
});
Key1 = GetStorageKey(resourceGroup, storageAccountLog, 0);
Key2 = GetStorageKey(resourceGroup, storageAccountLog, 1);
Input <string> key1 = Key1;
Input <string> key2 = Key2;
var vmScaleSet = new VirtualMachineScaleSet("sfScaleSet", new VirtualMachineScaleSetArgs {
ResourceGroupName = resourceGroup.Name,
Location = resourceGroup.Location,
VmScaleSetName = "sfScaleSet0",
Sku = new cpi.SkuArgs {
Name = "Standard_D2s_v3",
Capacity = 5,
Tier = "Standard",
},
Overprovision = false,
UpgradePolicy = new cpi.UpgradePolicyArgs {
Mode = "Automatic",
},
VirtualMachineProfile = new cpi.VirtualMachineScaleSetVMProfileArgs {
ExtensionProfile = new cpi.VirtualMachineScaleSetExtensionProfileArgs {
Extensions =
{
new cpi.VirtualMachineScaleSetExtensionArgs {
Name = "Type925_ServiceFabricNode",
Type = "ServiceFabricNode",
TypeHandlerVersion = "1.1",
AutoUpgradeMinorVersion = true,
// EnableAutomaticUpgrade = true, // MUST NOT ENABLED
ProtectedSettings =
{
{ "StorageAccountKey1", key1 },
{ "StorageAccountKey2", key2 },
},
Publisher = "Microsoft.Azure.ServiceFabric",
Settings =
{
// { "id", "thepulsf" },
// { "clusterId", "thepulsf" },
// { "clusterEndpoint", pubIpAddr.DnsSettings.Apply(it => it?.Fqdn) },
{ "clusterEndpoint", sfCluster.ClusterEndpoint },
{ "nodeTypeRef", "Type925" },
{ "dataPath", @"D:\\SvcFab" },
{ "durabilityLevel", "Silver" },
{ "enableParallelJobs", true },
{ "nicPrefixOverride", "10.10.10.0/24" },
{ "certificate", new InputMap <string>
{
{ "thumbprint", "4426C164D9E66C2C813DEEC0486F235C0E933212" },
{ "x509StoreName", "My" },
} },
},
},
new cpi.VirtualMachineScaleSetExtensionArgs {
Name = "VMDiagnosticsVmExt_Set0",
Type = "IaaSDiagnostics",
TypeHandlerVersion = "1.5",
ProtectedSettings =
{
{ "storageAccountName", storageAccountAppDx.Name },
{ "storageAccountKey", GetStorageKey(resourceGroup, storageAccountAppDx, 0) },
{ "storageAccountEndPoint", "https://core.windows.net/" },
},
Publisher = "Microsoft.Azure.Diagnostics",
Settings =
{
{ "WadCfg", new InputMap <object>
{
{ "DiagnosticMonitorConfiguration", new InputMap <object>
{
{ "overallQuotaInMB", "50000" },
{ "EtwProviders", new InputMap <object>
{
{ "EtwEventSourceProviderConfiguration", new InputList <InputMap <object> >
{
new InputMap <object>
{
{ "provider", "Microsoft-ServiceFabric-Actors" },
{ "scheduledTransferKeywordFilter", "1" },
{ "scheduledTransferPeriod", "PT5M" },
{ "DefaultEvents", new InputMap <string>
{
{ "eventDestination", "ServiceFabricReliableActorEventTable" }
} },
},
new InputMap <object>
{
{ "provider", "Microsoft-ServiceFabric-Services" },
{ "scheduledTransferPeriod", "PT5M" },
{ "DefaultEvents", new InputMap <string>
{
{ "eventDestination", "ServiceFabricReliableServiceEventTable" }
} },
},
} },
{ "EtwManifestProviderConfiguration", new InputList <InputMap <object> >
{
new InputMap <object> {
{ "provider", "cbd93bc2-71e5-4566-b3a7-595d8eeca6e8" },
{ "scheduledTransferLogLevelFilter", "Information" },
{ "scheduledTransferKeywordFilter", "4611686018427387904" },
{ "scheduledTransferPeriod", "PT5M" },
{ "DefaultEvents", new InputMap <string>
{
{ "eventDestination", "ServiceFabricSystemEventTable" }
} },
}
} },
} },
} },
} },
{ "StorageAccount", storageAccountAppDx.Name },
},
},
},
},
NetworkProfile = new cpi.VirtualMachineScaleSetNetworkProfileArgs {
NetworkInterfaceConfigurations =
{
new cpi.VirtualMachineScaleSetNetworkConfigurationArgs {
Name = "nicSfSet-0",
IpConfigurations =
{
new cpi.VirtualMachineScaleSetIPConfigurationArgs {
Name = "nicSfSet-0",
LoadBalancerBackendAddressPools = new cpi.SubResourceArgs{
Id = bepool0.Id
},
LoadBalancerInboundNatPools = new cpi.SubResourceArgs{
Id = lbNatPool.Id
},
Subnet = new cpi.ApiEntityReferenceArgs {
Id = vnet.Subnets.First().Apply(it => it.Id ?? string.Empty),
},
},
},
Primary = true,
},
},
},
OsProfile = new cpi.VirtualMachineScaleSetOSProfileArgs {
AdminUsername = "******",
AdminPassword = "******",
ComputerNamePrefix = "Type925",
Secrets =
{
new cpi.VaultSecretGroupArgs {
SourceVault = new cpi.SubResourceArgs{
Id = "/subscriptions/5fb1076d-8ce2-4bf8-90af-d53f1b8f8289/resourceGroups/prepkvault/providers/Microsoft.KeyVault/vaults/thekv4sf"
},
VaultCertificates =
{
new cpi.VaultCertificateArgs {
CertificateStore = "My",
CertificateUrl = "https://thekv4sf.vault.azure.net/secrets/thesfcert/4379416a51dc4570bda6bc79a6fbfa59",
},
},
},
},
},
StorageProfile = new cpi.VirtualMachineScaleSetStorageProfileArgs {
ImageReference = new cpi.ImageReferenceArgs {
Publisher = "MicrosoftWindowsServer",
Offer = "WindowsServer",
Sku = "2019-Datacenter-with-Containers",
Version = "latest",
},
OsDisk = new cpi.VirtualMachineScaleSetOSDiskArgs {
Caching = "ReadOnly",
CreateOption = "FromImage",
ManagedDisk = new cpi.VirtualMachineScaleSetManagedDiskParametersArgs {
StorageAccountType = "Standard_LRS",
},
},
},
},
});
// Export the primary key of> the Storage Account
this.PrimaryStorageKey = Output.Tuple(resourceGroup.Name, storageAccountAppDx.Name).Apply(names =>
Output.CreateSecret(GetStorageAccountKey(names.Item1, names.Item2, 0)));
}
/// <summary>
/// Creates or updates a static or dynamic public IP address.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='publicIpAddressName'>
/// The name of the public IP address.
/// </param>
/// <param name='parameters'>
/// Parameters supplied to the create or update public IP address operation.
/// </param>
public static PublicIPAddress BeginCreateOrUpdate(this IPublicIPAddressesOperations operations, string resourceGroupName, string publicIpAddressName, PublicIPAddress parameters)
{
return(operations.BeginCreateOrUpdateAsync(resourceGroupName, publicIpAddressName, parameters).GetAwaiter().GetResult());
}
/// <summary>
/// Creates or updates a static or dynamic public IP address.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='publicIpAddressName'>
/// The name of the public IP address.
/// </param>
/// <param name='parameters'>
/// Parameters supplied to the create or update public IP address operation.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <PublicIPAddress> BeginCreateOrUpdateAsync(this IPublicIPAddressesOperations operations, string resourceGroupName, string publicIpAddressName, PublicIPAddress parameters, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.BeginCreateOrUpdateWithHttpMessagesAsync(resourceGroupName, publicIpAddressName, parameters, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public void MultiRole_CreateUpdateGetAndDeleteWithExtension_WorkerAndWebRole()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
EnsureClientsInitialized(context);
// Create resource group
var rgName = TestUtilities.GenerateName(TestPrefix);
var csName = TestUtilities.GenerateName("cs");
string cloudServiceName = "TestCloudServiceMultiRole";
string publicIPAddressName = TestUtilities.GenerateName("cspip");
string vnetName = TestUtilities.GenerateName("csvnet");
string subnetName = TestUtilities.GenerateName("subnet");
string dnsName = TestUtilities.GenerateName("dns");
string lbName = TestUtilities.GenerateName("lb");
string lbfeName = TestUtilities.GenerateName("lbfe");
try
{
CreateVirtualNetwork(rgName, vnetName, subnetName);
PublicIPAddress publicIPAddress = CreatePublicIP(publicIPAddressName, rgName, dnsName);
///
/// Create: Create a multi-role CloudService with 2 WorkerRoles, 1 WebRole, and RDP Extension.
///
string rdpExtensionPublicConfig = "<PublicConfig>" +
"<UserName>adminRdpTest</UserName>" +
"<Expiration>2021-10-27T23:59:59</Expiration>" +
"</PublicConfig>";
string rdpExtensionPrivateConfig = "<PrivateConfig>" +
"<Password>VsmrdpTest!</Password>" +
"</PrivateConfig>";
Extension rdpExtension = CreateExtension("RDPExtension", "Microsoft.Windows.Azure.Extensions", "RDP", "1.2.1", autoUpgrade: true,
publicConfig: rdpExtensionPublicConfig,
privateConfig: rdpExtensionPrivateConfig);
// Define Configurations
List <string> supportedRoleInstanceSizes = GetSupportedRoleInstanceSizes();
Dictionary <string, RoleConfiguration> roleNameToPropertiesMapping = new Dictionary <string, RoleConfiguration>
{
{ "WorkerRole1", new RoleConfiguration {
InstanceCount = 1, RoleInstanceSize = supportedRoleInstanceSizes[0]
} },
{ "WorkerRole2", new RoleConfiguration {
InstanceCount = 1, RoleInstanceSize = supportedRoleInstanceSizes[1]
} },
{ "WebRole1", new RoleConfiguration {
InstanceCount = 2, RoleInstanceSize = supportedRoleInstanceSizes[3]
} }
};
// Generate the request
CloudService cloudService = GenerateCloudServiceWithNetworkProfile(
resourceGroupName: rgName,
serviceName: cloudServiceName,
cspkgSasUri: CreateCspkgSasUrl(rgName, MultiRole2Worker1WebRolesPackageSasUri),
roleNameToPropertiesMapping: roleNameToPropertiesMapping,
publicIPAddressName: publicIPAddressName,
vnetName: vnetName,
subnetName: subnetName,
lbName: lbName,
lbFrontendName: lbfeName);
cloudService.Properties.ExtensionProfile = new CloudServiceExtensionProfile()
{
Extensions = new List <Extension>()
};
cloudService.Properties.ExtensionProfile.Extensions.Add(rdpExtension);
CloudService getResponse = CreateCloudService_NoAsyncTracking(
rgName,
csName,
cloudService);
// Validate the response for multirole
ValidateGetAndListResponseForMultiRole(rgName, csName, cloudService, roleNameToPropertiesMapping);
///
/// Update[1]: Delete RDP Extension, and Add Monitor Extension.
///
Extension monitorExtension = CreateExtension("MonitoringExtension", "Microsoft.Azure.Security", "Monitoring", "3.1.0.0");
cloudService.Properties.ExtensionProfile = new CloudServiceExtensionProfile()
{
Extensions = new List <Extension>()
};
cloudService.Properties.ExtensionProfile.Extensions.Add(monitorExtension);
getResponse = CreateCloudService_NoAsyncTracking(
rgName,
csName,
cloudService);
// Send the request
ValidateGetAndListResponseForMultiRole(rgName, csName, cloudService, roleNameToPropertiesMapping);
///
/// Update[2]: Delete Monitor Extension
///
cloudService.Properties.ExtensionProfile = null;
getResponse = CreateCloudService_NoAsyncTracking(
rgName,
csName,
cloudService);
// Send the request
ValidateGetAndListResponseForMultiRole(rgName, csName, cloudService, roleNameToPropertiesMapping);
///
/// Delete the CloudService
///
m_CrpClient.CloudServices.Delete(rgName, csName);
}
finally
{
// Fire and forget. No need to wait for RG deletion completion
try
{
m_ResourcesClient.ResourceGroups.BeginDelete(rgName);
}
catch (Exception e)
{
// Swallow this exception so that the original exception is thrown
Console.WriteLine(e);
}
}
}
}
/// <summary>
/// Create Virtual Network Interface Card, NIC
/// </summary>
/// <param name="credentials">Credentials to authorize application</param>
/// <param name="subscriptionId">SubscriptionID that identifies subscription to create resoruce in</param>
/// <param name="resourceGroup">Name of resource group</param>
/// <param name="location">Location for resource</param>
/// <param name="nicName">Internal name for NIC</param>
/// <param name="nicIPConfigName">Internal name for NIC Configuration. Sample only provides one configuration, but could be extended to provide more</param>
/// <param name="pip">Public IP Address to be assigned to NIC</param>
/// <param name="subnet">Subnet to use for current configuration</param>
/// <returns>Awaitable task</returns>
private static Task<NetworkInterface> CreateNetworkInterfaceAsync(TokenCredentials credentials, string subscriptionId, string resourceGroup, string location, string nicName, string nicIPConfigName, PublicIPAddress pip, Subnet subnet)
{
Console.WriteLine("Creating Network Interface");
var networkClient = new NetworkManagementClient(credentials) { SubscriptionId = subscriptionId };
var createNicTask = networkClient.NetworkInterfaces.CreateOrUpdateAsync(resourceGroup, nicName,
new NetworkInterface()
{
Location = location,
IpConfigurations = new[] {
new NetworkInterfaceIPConfiguration
{
Name = nicIPConfigName,
PrivateIPAllocationMethod = "Dynamic",
PublicIPAddress = pip,
Subnet = subnet
}
}
});
return createNicTask;
}