public async Task GlobalSetUp()
{
SubscriptionResource subscription = await GlobalClient.GetDefaultSubscriptionAsync();
var rgLro = await subscription.GetResourceGroups().CreateOrUpdateAsync(WaitUntil.Completed, SessionRecording.GenerateAssetName("bastionrg-"), new ResourceGroupData(AzureLocation.WestUS2));
ResourceGroupResource rg = rgLro.Value;
_resourceGroupIdentifier = rg.Id;
VirtualNetworkData vnetData = new VirtualNetworkData();
vnetData.Location = AzureLocation.WestUS2;
vnetData.AddressSpace = new AddressSpace();
vnetData.AddressSpace.AddressPrefixes.Add("10.0.0.0/16");
var vnetLro = await rg.GetVirtualNetworks().CreateOrUpdateAsync(WaitUntil.Completed, SessionRecording.GenerateAssetName("vnet-"), vnetData);
VirtualNetworkResource vnet = vnetLro.Value;
SubnetData subnetData = new SubnetData();
subnetData.AddressPrefix = "10.0.0.0/24";
var subnetLro = await vnet.GetSubnets().CreateOrUpdateAsync(WaitUntil.Completed, "AzureBastionSubnet", subnetData);
_subnetIdentifier = subnetLro.Value.Id;
PublicIPAddressData ipData = new PublicIPAddressData();
ipData.Location = AzureLocation.WestUS2;
ipData.PublicIPAllocationMethod = IPAllocationMethod.Static;
ipData.Sku = new PublicIPAddressSku();
ipData.Sku.Name = PublicIPAddressSkuName.Standard;
var ipLro = await rg.GetPublicIPAddresses().CreateOrUpdateAsync(WaitUntil.Completed, SessionRecording.GenerateAssetName("ip-"), ipData);
_publicIPAddressIdentifier = ipLro.Value.Id;
_bastionName = SessionRecording.GenerateAssetName("bastion-");
await StopSessionRecordingAsync();
}
public async Task CreateOrUpdate()
{
#region Snippet:Managing_Networks_CreateAVirtualNetwork
VirtualNetworkCollection virtualNetworkCollection = resourceGroup.GetVirtualNetworks();
string vnetName = "myVnet";
// Use the same location as the resource group
VirtualNetworkData input = 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",
} }
};
VirtualNetworkResource vnet = await virtualNetworkCollection.CreateOrUpdate(WaitUntil.Completed, vnetName, input).WaitForCompletionAsync();
#endregion
}
public async Task GetAllInSubscription()
{
var vnetName = Recording.GenerateAssetName("testvnet");
var _virtualNetworkCollection = await GetVirtualNetworkCollectionAsync();
var _extendedLocation = new ExtendedLocation()
{
Name = CustomLocationId,
ExtendedLocationType = EXTENDED_LOCATION_TYPE
};
var vnetBody = new VirtualNetworkData(DefaultLocation);
vnetBody.MoRefId = "network-o85628";
vnetBody.VCenterId = VcenterId;
vnetBody.ExtendedLocation = _extendedLocation;
// create virtual network
VirtualNetworkResource vnet1 = (await _virtualNetworkCollection.CreateOrUpdateAsync(WaitUntil.Completed, vnetName, vnetBody)).Value;
Assert.IsNotNull(vnet1);
Assert.AreEqual(vnet1.Id.Name, vnetName);
vnet1 = null;
await foreach (var vnet in DefaultSubscription.GetVirtualNetworksAsync())
{
if (vnet.Data.Name == vnetName)
{
vnet1 = vnet;
}
}
Assert.NotNull(vnet1);
}
public async Task Exists()
{
var vnetName = Recording.GenerateAssetName("testvnet");
var _virtualNetworkCollection = await GetVirtualNetworkCollectionAsync();
var _extendedLocation = new ExtendedLocation()
{
Name = CustomLocationId,
ExtendedLocationType = EXTENDED_LOCATION_TYPE
};
var vnetBody = new VirtualNetworkData(DefaultLocation);
vnetBody.MoRefId = "network-o114814";
vnetBody.VCenterId = VcenterId;
vnetBody.ExtendedLocation = _extendedLocation;
// create virtual network
VirtualNetworkResource vnet1 = (await _virtualNetworkCollection.CreateOrUpdateAsync(WaitUntil.Completed, vnetName, vnetBody)).Value;
Assert.IsNotNull(vnet1);
Assert.AreEqual(vnet1.Id.Name, vnetName);
// check for exists virtual network
bool exists = await _virtualNetworkCollection.ExistsAsync(vnetName);
Assert.IsTrue(exists);
}
public async Task GetAll()
{
var vnetName = Recording.GenerateAssetName("testvnet");
var _virtualNetworkCollection = await GetVirtualNetworkCollectionAsync();
var _extendedLocation = new ExtendedLocation()
{
Name = CustomLocationId,
ExtendedLocationType = EXTENDED_LOCATION_TYPE
};
var vnetBody = new VirtualNetworkData(DefaultLocation);
vnetBody.MoRefId = "network-o2286";
vnetBody.VCenterId = VcenterId;
vnetBody.ExtendedLocation = _extendedLocation;
// create virtual network
VirtualNetworkResource vnet1 = (await _virtualNetworkCollection.CreateOrUpdateAsync(WaitUntil.Completed, vnetName, vnetBody)).Value;
Assert.IsNotNull(vnet1);
Assert.AreEqual(vnet1.Id.Name, vnetName);
int count = 0;
await foreach (var vnet in _virtualNetworkCollection.GetAllAsync())
{
count++;
}
Assert.GreaterOrEqual(count, 1);
}
public async Task GlobalSetUp()
{
var rgLro = await GlobalClient.GetDefaultSubscriptionAsync().Result.GetResourceGroups().CreateOrUpdateAsync(WaitUntil.Completed, SessionRecording.GenerateAssetName("WebPubSubRG-"), new ResourceGroupData(AzureLocation.WestUS2));
ResourceGroupResource rg = rgLro.Value;
_resourceGroupIdentifier = rg.Id;
_vnetName = SessionRecording.GenerateAssetName("Vnet-");
_privateEndPointName = SessionRecording.GenerateAssetName("PrivateEndPoint-");
//create vnet
var vnetData = new VirtualNetworkData()
{
Location = "westus2",
Subnets =
{
new SubnetData()
{
Name = "subnet01", AddressPrefix = "10.10.1.0/24",
},
new SubnetData()
{
Name = "subnet02", AddressPrefix = "10.10.2.0/24", PrivateEndpointNetworkPolicies = "Disabled",
}
},
};
vnetData.AddressPrefixes.Add("10.10.0.0/16");
var vnetLro = await rg.GetVirtualNetworks().CreateOrUpdateAsync(WaitUntil.Completed, _vnetName, vnetData);
_vnet = vnetLro.Value;
await StopSessionRecordingAsync();
}
public async Task Get()
{
#region Snippet:Managing_Networks_GetAVirtualNetwork
VirtualNetworkCollection virtualNetworkCollection = resourceGroup.GetVirtualNetworks();
VirtualNetworkResource virtualNetwork = await virtualNetworkCollection.GetAsync("myVnet");
Console.WriteLine(virtualNetwork.Data.Name);
#endregion
}
public async Task TestSetUp()
{
var client = GetArmClient();
_resourceGroup = await client.GetResourceGroupResource(_resourceGroupIdentifier).GetAsync();
_network = await _resourceGroup.GetVirtualNetworks().GetAsync(_networkIdentifier.Name);
_publicIPAddress = await _resourceGroup.GetPublicIPAddresses().GetAsync(_publicIPAddressIdentifier.Name);
}
public async Task DeleteVirtualNetwork()
{
#region Snippet:Managing_Networks_DeleteAVirtualNetwork
VirtualNetworkCollection virtualNetworkCollection = resourceGroup.GetVirtualNetworks();
VirtualNetworkResource virtualNetwork = await virtualNetworkCollection.GetAsync("myVnet");
await virtualNetwork.DeleteAsync(WaitUntil.Completed);
#endregion
}
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.GetResourceGroupResource(_resourceGroupIdentifier).GetAsync();
VirtualNetworkResource 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()
{
SubscriptionResource subscription = await GlobalClient.GetDefaultSubscriptionAsync();
var rgLro = await subscription.GetResourceGroups().CreateOrUpdateAsync(WaitUntil.Completed, SessionRecording.GenerateAssetName("FirewallRG-"), new ResourceGroupData(AzureLocation.WestUS2));
ResourceGroupResource 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(WaitUntil.Completed, 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(WaitUntil.Completed, SessionRecording.GenerateAssetName("publicIp-"), ipData);
_publicIPAddress = ipLro.Value;
_publicIPAddressIdentifier = _publicIPAddress.Id;
_firewallName = SessionRecording.GenerateAssetName("firewall-");
await StopSessionRecordingAsync();
}
public async Task TestSetUp()
{
if (Mode == RecordedTestMode.Record || Mode == RecordedTestMode.Playback)
{
Initialize();
string groupName = Recording.GenerateAssetName(ResourceGroupPrefix);
string VnetName = Recording.GenerateAssetName("vnetname");
string SubnetName = Recording.GenerateAssetName("subnetname");
string EndpointName = Recording.GenerateAssetName("endpointxyz");
ResGroup = (await ArmClient.GetDefaultSubscriptionAsync().Result.GetResourceGroups().CreateOrUpdateAsync(WaitUntil.Completed, groupName, new ResourceGroupData(Location))).Value;
string configurationStoreName = Recording.GenerateAssetName("testapp-");
ConfigurationStoreData configurationStoreData = new ConfigurationStoreData(Location, new AppConfigurationSku("Standard"))
{
PublicNetworkAccess = PublicNetworkAccess.Disabled
};
ConfigStore = (await ResGroup.GetConfigurationStores().CreateOrUpdateAsync(WaitUntil.Completed, configurationStoreName, configurationStoreData)).Value;
// Prepare VNet and Private Endpoint
VirtualNetworkData vnetData = new VirtualNetworkData()
{
Location = "eastus",
Subnets = { new SubnetData()
{
Name = SubnetName, AddressPrefix = "10.0.0.0/24", PrivateEndpointNetworkPolicies = "Disabled"
} }
};
vnetData.AddressPrefixes.Add("10.0.0.0/16");
vnetData.DhcpOptionsDnsServers.Add("10.1.1.1");
vnetData.DhcpOptionsDnsServers.Add("10.1.2.4");
VirtualNetworkResource vnet = (await ResGroup.GetVirtualNetworks().CreateOrUpdateAsync(WaitUntil.Completed, VnetName, vnetData)).Value;
PrivateEndpointData privateEndpointData = new PrivateEndpointData()
{
Location = "eastus",
PrivateLinkServiceConnections = { new PrivateLinkServiceConnection()
{
Name = "myconnection",
PrivateLinkServiceId = ConfigStore.Data.Id,
GroupIds = { "configurationStores" },
RequestMessage = "Please approve my connection",
} },
Subnet = new SubnetData()
{
Id = "/subscriptions/" + TestEnvironment.SubscriptionId + "/resourceGroups/" + groupName + "/providers/Microsoft.Network/virtualNetworks/" + VnetName + "/subnets/" + SubnetName
}
};
PrivateEndpointResource = (await ResGroup.GetPrivateEndpoints().CreateOrUpdateAsync(WaitUntil.Completed, EndpointName, privateEndpointData)).Value;
List <AppConfigurationPrivateEndpointConnectionResource> connections = await ConfigStore.GetAppConfigurationPrivateEndpointConnections().GetAllAsync().ToEnumerableAsync();
Connection = connections.FirstOrDefault();
}
}
protected async Task <PrivateEndpointResource> CreatePrivateEndpoint()
{
var vnetName = Recording.GenerateAssetName("vnet-");
var vnet = new VirtualNetworkData()
{
Location = AzureLocation.WestUS,
Subnets = { new SubnetData()
{
Name = "default",
AddressPrefix = "10.0.1.0/24",
PrivateEndpointNetworkPolicies = VirtualNetworkPrivateEndpointNetworkPolicies.Disabled
} }
};
vnet.AddressPrefixes.Add("10.0.0.0/16");
vnet.DhcpOptionsDnsServers.Add("10.1.1.1");
vnet.DhcpOptionsDnsServers.Add("10.1.2.4");
VirtualNetworkResource virtualNetwork = (await _resourceGroup.GetVirtualNetworks().CreateOrUpdateAsync(WaitUntil.Completed, vnetName, vnet)).Value;
var name = Recording.GenerateAssetName("pe-");
var privateEndpointData = new PrivateEndpointData
{
Location = AzureLocation.WestUS,
Subnet = virtualNetwork.Data.Subnets[0],
ManualPrivateLinkServiceConnections =
{
new PrivateLinkServiceConnection
{
Name = Recording.GenerateAssetName("pec"),
// TODO: externalize or create the service on-demand, like virtual network
//PrivateLinkServiceId = $"/subscriptions/{TestEnvironment.SubscriptionId}/resourceGroups/{resourceGroup.Data.Name}/providers/Microsoft.Storage/storageAccounts/{storageAccount.Name}",
PrivateLinkServiceId = _databaseAccountIdentifier,
RequestMessage = "SDK test",
GroupIds = { "MongoDB" }
}
},
};
return((await _resourceGroup.GetPrivateEndpoints().CreateOrUpdateAsync(WaitUntil.Completed, name, privateEndpointData)).Value);
}
public async Task NewCode()
{
#endif
ArmClient armClient = new ArmClient(new DefaultAzureCredential());
SubscriptionResource subscription = await armClient.GetDefaultSubscriptionAsync();
ResourceGroupResource resourceGroup = await subscription.GetResourceGroups().GetAsync("abc");
VirtualNetworkCollection virtualNetworkContainer = resourceGroup.GetVirtualNetworks();
// Create VNet
VirtualNetworkData vnet = new VirtualNetworkData()
{
Location = "westus",
};
vnet.AddressSpace.AddressPrefixes.Add("10.0.0.0/16");
vnet.Subnets.Add(new SubnetData
{
Name = "mySubnet",
AddressPrefix = "10.0.0.0/24",
});
ArmOperation<VirtualNetworkResource> vnetOperation = await virtualNetworkContainer.CreateOrUpdateAsync(WaitUntil.Completed, "_vent", vnet);
VirtualNetworkResource virtualNetwork = vnetOperation.Value;
#endregion
}
public async Task VirtualNetworkPeeringTest()
{
string resourceGroupName = Recording.GenerateAssetName("csmrg");
string location = TestEnvironment.Location;
var resourceGroup = await CreateResourceGroup(resourceGroupName);
string vnet1Name = Recording.GenerateAssetName("azsmnet");
string vnet2Name = Recording.GenerateAssetName("azsmnet");
string subnet1Name = Recording.GenerateAssetName("azsmnet");
string subnet2Name = Recording.GenerateAssetName("azsmnet");
var vnet = new VirtualNetworkData()
{
Location = 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 = subnet1Name, AddressPrefix = "10.0.1.0/24",
}, new SubnetData()
{
Name = subnet2Name, AddressPrefix = "10.0.2.0/24"
} }
};
// Put Vnet
var virtualNetworkCollection = resourceGroup.GetVirtualNetworks();
var putVnetResponseOperation = await virtualNetworkCollection.CreateOrUpdateAsync(WaitUntil.Completed, vnet1Name, vnet);
Response <VirtualNetworkResource> putVnetResponse = await putVnetResponseOperation.WaitForCompletionAsync();;
Assert.AreEqual("Succeeded", putVnetResponse.Value.Data.ProvisioningState.ToString());
// Get Vnet
Response <VirtualNetworkResource> getVnetResponse = await virtualNetworkCollection.GetAsync(vnet1Name);
Assert.AreEqual(vnet1Name, getVnetResponse.Value.Data.Name);
Assert.NotNull(getVnetResponse.Value.Data.ResourceGuid);
Assert.AreEqual("Succeeded", getVnetResponse.Value.Data.ProvisioningState.ToString());
// Create vnet2
var vnet2 = new VirtualNetworkData()
{
Location = location,
AddressSpace = new AddressSpace()
{
AddressPrefixes = { "10.1.0.0/16", }
},
Subnets = { new SubnetData()
{
Name = subnet1Name, AddressPrefix = "10.1.1.0/24"
} }
};
// Put Vnet2
var putVnet2Operation = await virtualNetworkCollection.CreateOrUpdateAsync(WaitUntil.Completed, vnet2Name, vnet2);
Response <VirtualNetworkResource> putVnet2 = await putVnet2Operation.WaitForCompletionAsync();;
Assert.AreEqual("Succeeded", putVnet2.Value.Data.ProvisioningState.ToString());
// Create peering object
var peering = new VirtualNetworkPeeringData()
{
AllowForwardedTraffic = true,
RemoteVirtualNetwork = new WritableSubResource {
Id = putVnet2.Value.Id
}
};
// Create Peering
var virtualNetworkPeeringCollection = getVnetResponse.Value.GetVirtualNetworkPeerings();
await virtualNetworkPeeringCollection.CreateOrUpdateAsync(WaitUntil.Completed, "peer1", peering);
// Get Peering
VirtualNetworkPeeringResource getPeer = await virtualNetworkPeeringCollection.GetAsync("peer1");
Assert.AreEqual("peer1", getPeer.Data.Name);
Assert.True(getPeer.Data.AllowForwardedTraffic);
Assert.True(getPeer.Data.AllowVirtualNetworkAccess);
Assert.False(getPeer.Data.AllowGatewayTransit);
Assert.NotNull(getPeer.Data.RemoteVirtualNetwork);
Assert.AreEqual(putVnet2.Value.Id, getPeer.Data.RemoteVirtualNetwork.Id);
// List Peering
AsyncPageable <VirtualNetworkPeeringResource> listPeerAP = virtualNetworkPeeringCollection.GetAllAsync();
List <VirtualNetworkPeeringResource> listPeer = await listPeerAP.ToEnumerableAsync();
Has.One.EqualTo(listPeer);
Assert.AreEqual("peer1", listPeer[0].Data.Name);
Assert.True(listPeer[0].Data.AllowForwardedTraffic);
Assert.True(listPeer[0].Data.AllowVirtualNetworkAccess);
Assert.False(listPeer[0].Data.AllowGatewayTransit);
Assert.NotNull(listPeer[0].Data.RemoteVirtualNetwork);
Assert.AreEqual(putVnet2.Value.Id, listPeer[0].Data.RemoteVirtualNetwork.Id);
// Get peering from GET vnet
VirtualNetworkResource peeringVnet = await virtualNetworkCollection.GetAsync(vnet1Name);
Assert.AreEqual(vnet1Name, peeringVnet.Data.Name);
Has.One.EqualTo(peeringVnet.Data.VirtualNetworkPeerings);
Assert.AreEqual("peer1", peeringVnet.Data.VirtualNetworkPeerings[0].Name);
Assert.True(peeringVnet.Data.VirtualNetworkPeerings[0].AllowForwardedTraffic);
Assert.True(peeringVnet.Data.VirtualNetworkPeerings[0].AllowVirtualNetworkAccess);
Assert.False(peeringVnet.Data.VirtualNetworkPeerings[0].AllowGatewayTransit);
Assert.NotNull(peeringVnet.Data.VirtualNetworkPeerings[0].RemoteVirtualNetwork);
Assert.AreEqual(putVnet2.Value.Id, peeringVnet.Data.VirtualNetworkPeerings[0].RemoteVirtualNetwork.Id);
// Delete Peering
var deleteOperation = await getPeer.DeleteAsync(WaitUntil.Completed);
await deleteOperation.WaitForCompletionResponseAsync();;
listPeerAP = virtualNetworkPeeringCollection.GetAllAsync();
listPeer = await listPeerAP.ToEnumerableAsync();
Assert.IsEmpty(listPeer);
peeringVnet = await virtualNetworkCollection.GetAsync(vnet1Name);
Assert.AreEqual(vnet1Name, peeringVnet.Data.Name);
Assert.IsEmpty(peeringVnet.Data.VirtualNetworkPeerings);
// Delete Vnets
await putVnet2.Value.DeleteAsync(WaitUntil.Completed);
await putVnetResponse.Value.DeleteAsync(WaitUntil.Completed);
}
public async Task GlobalSetUp()
{
SubscriptionResource subscription = await GlobalClient.GetDefaultSubscriptionAsync();
var rgLro = await subscription.GetResourceGroups().CreateOrUpdateAsync(WaitUntil.Completed, SessionRecording.GenerateAssetName("FirewallPolicyRG-"), new ResourceGroupData(AzureLocation.WestUS2));
ResourceGroupResource rg = rgLro.Value;
_resourceGroupIdentifier = rg.Id;
VirtualNetworkData vnetData = new VirtualNetworkData()
{
Location = AzureLocation.WestUS2,
AddressSpace = new AddressSpace()
{
AddressPrefixes = { "10.26.0.0/16", }
},
Subnets =
{
new SubnetData()
{
Name = "Default", AddressPrefix = "10.26.1.0/26",
},
new SubnetData()
{
Name = "AzureFirewallSubnet", AddressPrefix = "10.26.2.0/26",
},
},
};
var vnetLro = await rg.GetVirtualNetworks().CreateOrUpdateAsync(WaitUntil.Completed, 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(WaitUntil.Completed, SessionRecording.GenerateAssetName("publicIp-"), ipData);
_publicIPAddress = ipLro.Value;
_publicIPAddressIdentifier = _publicIPAddress.Id;
AzureFirewallData firewallData = new AzureFirewallData();
firewallData.Location = AzureLocation.WestUS2;
firewallData.IPConfigurations.Add(new AzureFirewallIPConfiguration()
{
Name = "fwpip",
PublicIPAddress = new WritableSubResource()
{
Id = _publicIPAddressIdentifier
},
Subnet = new WritableSubResource()
{
Id = _networkIdentifier.AppendChildResource("subnets", "AzureFirewallSubnet")
},
});
var firewallLro = await rg.GetAzureFirewalls().CreateOrUpdateAsync(WaitUntil.Completed, SessionRecording.GenerateAssetName("firewall-"), firewallData);
_firewall = firewallLro.Value;
_firewallIdentifier = _firewall.Id;
await StopSessionRecordingAsync();
}
public async Task ExpandResourceTest()
{
string resourceGroupName = Recording.GenerateAssetName("csmrg");
string location = TestEnvironment.Location;
var resourceGroup = await CreateResourceGroup(resourceGroupName);
// Create lbPublicIP
string lbPublicIpName = Recording.GenerateAssetName("azsmnet");
string lbDomaingNameLabel = Recording.GenerateAssetName("azsmnet");
PublicIPAddressResource lbPublicIp = await CreateDefaultPublicIpAddress(
lbPublicIpName,
lbDomaingNameLabel,
location,
resourceGroup.GetPublicIPAddresses());
// Create Vnet
string vnetName = Recording.GenerateAssetName("azsmnet");
string subnetName = Recording.GenerateAssetName("azsmnet");
VirtualNetworkResource vnet = await CreateVirtualNetwork(vnetName, subnetName, location, resourceGroup.GetVirtualNetworks());
// Create Nics
string nic1name = Recording.GenerateAssetName("azsmnet");
string nic2name = Recording.GenerateAssetName("azsmnet");
string nic3name = Recording.GenerateAssetName("azsmnet");
NetworkInterfaceResource nic1 = await CreateNetworkInterface(
nic1name,
null,
vnet.Data.Subnets[0].Id,
location,
"ipconfig",
resourceGroup.GetNetworkInterfaces());
NetworkInterfaceResource nic2 = await CreateNetworkInterface(
nic2name,
null,
vnet.Data.Subnets[0].Id,
location,
"ipconfig",
resourceGroup.GetNetworkInterfaces());
NetworkInterfaceResource nic3 = await CreateNetworkInterface(
nic3name,
null,
vnet.Data.Subnets[0].Id,
location,
"ipconfig",
resourceGroup.GetNetworkInterfaces());
// Create the LoadBalancer
var lbName = Recording.GenerateAssetName("azsmnet");
var frontendIpConfigName = Recording.GenerateAssetName("azsmnet");
var backEndAddressPoolName = Recording.GenerateAssetName("azsmnet");
var loadBalancingRuleName = Recording.GenerateAssetName("azsmnet");
var probeName = Recording.GenerateAssetName("azsmnet");
var inboundNatRule1Name = Recording.GenerateAssetName("azsmnet");
var inboundNatRule2Name = Recording.GenerateAssetName("azsmnet");
// Populate the loadBalancerCreateOrUpdateParameter
var loadBalancerData = new LoadBalancerData()
{
Location = location,
FrontendIPConfigurations =
{
new FrontendIPConfigurationData()
{
Name = frontendIpConfigName,
PublicIPAddress = new PublicIPAddressData()
{
Id = lbPublicIp.Id
}
}
},
BackendAddressPools =
{
new BackendAddressPoolData()
{
Name = backEndAddressPoolName,
}
},
LoadBalancingRules =
{
new LoadBalancingRuleData()
{
Name = loadBalancingRuleName,
FrontendIPConfiguration = new WritableSubResource()
{
Id = GetChildLbResourceId(TestEnvironment.SubscriptionId,
resourceGroupName, lbName, "FrontendIPConfigurations", frontendIpConfigName)
},
Protocol = TransportProtocol.Tcp,
FrontendPort = 80,
BackendPort = 80,
EnableFloatingIP = false,
IdleTimeoutInMinutes = 15,
BackendAddressPool = new WritableSubResource()
{
Id = GetChildLbResourceId(TestEnvironment.SubscriptionId,
resourceGroupName, lbName, "backendAddressPools", backEndAddressPoolName)
},
Probe = new WritableSubResource()
{
Id = GetChildLbResourceId(TestEnvironment.SubscriptionId,
resourceGroupName, lbName, "probes", probeName)
}
}
},
Probes =
{
new ProbeData()
{
Name = probeName,
Protocol = ProbeProtocol.Http,
Port = 80,
RequestPath = "healthcheck.aspx",
IntervalInSeconds = 10,
NumberOfProbes = 2
}
},
InboundNatRules =
{
new InboundNatRuleData()
{
Name = inboundNatRule1Name,
FrontendIPConfiguration = new WritableSubResource()
{
Id = GetChildLbResourceId(TestEnvironment.SubscriptionId,
resourceGroupName, lbName, "FrontendIPConfigurations", frontendIpConfigName)
},
Protocol = TransportProtocol.Tcp,
FrontendPort = 3389,
BackendPort = 3389,
IdleTimeoutInMinutes = 15,
EnableFloatingIP = false
},
new InboundNatRuleData()
{
Name = inboundNatRule2Name,
FrontendIPConfiguration = new WritableSubResource()
{
Id = GetChildLbResourceId(TestEnvironment.SubscriptionId,
resourceGroupName, lbName, "FrontendIPConfigurations", frontendIpConfigName)
},
Protocol = TransportProtocol.Tcp,
FrontendPort = 3390,
BackendPort = 3389,
IdleTimeoutInMinutes = 15,
EnableFloatingIP = false,
}
}
};
// Create the loadBalancer
var loadBalancerCollection = resourceGroup.GetLoadBalancers();
LoadBalancerResource loadBalancer = (await loadBalancerCollection.CreateOrUpdateAsync(WaitUntil.Completed, lbName, loadBalancerData)).Value;
// Associate the nic with LB
//nic1.GetNetworkInterfaceIPConfigurations().List().First().`
// TODO: where do we have the following?
//nic1.IpConfigurations.First().LoadBalancerBackendAddressPools.Add(getLoadBalancer.Value.BackendAddressPools.First());
//nic1.IpConfigurations.First().LoadBalancerInboundNatRules.Add(getLoadBalancer.Value.InboundNatRules.First());
//nic2.IpConfigurations.First().LoadBalancerBackendAddressPools.Add(getLoadBalancer.Value.BackendAddressPools.First());
//nic3.IpConfigurations.First().LoadBalancerInboundNatRules.Add(getLoadBalancer.Value.InboundNatRules[1]);
nic1.Data.IPConfigurations.First().LoadBalancerBackendAddressPools.Add(loadBalancer.Data.BackendAddressPools.First());
nic1.Data.IPConfigurations.First().LoadBalancerInboundNatRules.Add(loadBalancer.Data.InboundNatRules[0]);
nic2.Data.IPConfigurations.First().LoadBalancerBackendAddressPools.Add(loadBalancer.Data.BackendAddressPools.First());
nic2.Data.IPConfigurations.First().LoadBalancerInboundNatRules.Add(loadBalancer.Data.InboundNatRules[1]);
nic3.Data.IPConfigurations.First().LoadBalancerBackendAddressPools.Add(loadBalancer.Data.BackendAddressPools.First());
// Put Nics
var networkInterfaceCollection = resourceGroup.GetNetworkInterfaces();
var createOrUpdateOperation1 = await networkInterfaceCollection.CreateOrUpdateAsync(WaitUntil.Completed, nic1name, nic1.Data);
await createOrUpdateOperation1.WaitForCompletionAsync();
var createOrUpdateOperation2 = await networkInterfaceCollection.CreateOrUpdateAsync(WaitUntil.Completed, nic2name, nic2.Data);
await createOrUpdateOperation2.WaitForCompletionAsync();
var createOrUpdateOperation3 = await networkInterfaceCollection.CreateOrUpdateAsync(WaitUntil.Completed, nic3name, nic3.Data);
await createOrUpdateOperation3.WaitForCompletionAsync();
// Get Nics
await networkInterfaceCollection.GetAsync(nic1name);
await networkInterfaceCollection.GetAsync(nic2name);
await networkInterfaceCollection.GetAsync(nic3name);
// Get lb with expanded nics from nat rules
loadBalancer = await loadBalancerCollection.GetAsync(lbName, "InboundNatRules/backendIPConfiguration");
await foreach (var natRule in loadBalancer.GetInboundNatRules())
{
Assert.NotNull(natRule.Data.BackendIPConfiguration);
Assert.NotNull(natRule.Data.BackendIPConfiguration.Id);
//Assert.NotNull(natRule.Data.BackendIPConfiguration.Name);
//Assert.NotNull(natRule.Data.BackendIPConfiguration.Etag);
//Assert.AreEqual(natRule.Id, natRule.Data.BackendIPConfiguration.LoadBalancerInboundNatRules[0].Id);
}
// Get lb with expanded nics from pools
loadBalancer = await loadBalancerCollection.GetAsync(lbName, "BackendAddressPools/backendIPConfigurations");
await foreach (var pool in loadBalancer.GetBackendAddressPools())
{
BackendAddressPoolResource firstPool = await GetFirstPoolAsync(loadBalancer);
foreach (var ipconfig in firstPool.Data.BackendIPConfigurations)
{
Assert.NotNull(ipconfig.Id);
//Assert.NotNull(ipconfig.Name);
//Assert.NotNull(ipconfig.Etag);
//Assert.AreEqual(pool.Id, ipconfig.LoadBalancerBackendAddressPools[0].Id);
}
}
// Get lb with expanded publicip
loadBalancer = await loadBalancerCollection.GetAsync(lbName, "FrontendIPConfigurations/PublicIPAddress");
foreach (var ipconfig in loadBalancer.Data.FrontendIPConfigurations)
{
Assert.NotNull(ipconfig.PublicIPAddress);
Assert.NotNull(ipconfig.PublicIPAddress.Id);
Assert.NotNull(ipconfig.PublicIPAddress.Name);
Assert.NotNull(ipconfig.PublicIPAddress.Etag);
Assert.AreEqual(ipconfig.Id, ipconfig.PublicIPAddress.IPConfiguration.Id);
}
// Get NIC with expanded subnet
nic1 = await networkInterfaceCollection.GetAsync(nic1name, "IPConfigurations/Subnet");
await foreach (NetworkInterfaceIPConfigurationResource ipconfig in nic1.GetNetworkInterfaceIPConfigurations())
{
Assert.NotNull(ipconfig.Data.Subnet);
Assert.NotNull(ipconfig.Data.Subnet.Id);
//Assert.NotNull(ipconfig.Subnet.Name);
//Assert.NotNull(ipconfig.Subnet.Etag);
//Assert.IsNotEmpty(ipconfig.Subnet.IpConfigurations);
}
// Get subnet with expanded ipconfigurations
Response <SubnetResource> subnet = await(await resourceGroup.GetVirtualNetworks().GetAsync(vnetName)).Value.GetSubnets().GetAsync(
subnetName,
"IPConfigurations");
foreach (IPConfiguration ipconfig in subnet.Value.Data.IPConfigurations)
{
Assert.NotNull(ipconfig.Id);
//Assert.NotNull(ipconfig.Name);
//Assert.NotNull(ipconfig.Etag);
Assert.NotNull(ipconfig.PrivateIPAddress);
}
// Get publicIPAddress with expanded ipconfigurations
Response <PublicIPAddressResource> publicip = await resourceGroup.GetPublicIPAddresses().GetAsync(
lbPublicIpName,
"IPConfiguration");
Assert.NotNull(publicip.Value.Data.IPConfiguration);
Assert.NotNull(publicip.Value.Data.IPConfiguration.Id);
//Assert.NotNull(publicip.Value.Data.IpConfiguration.Name);
//Assert.NotNull(publicip.Value.Data.IpConfiguration.Etag);
// Delete LoadBalancer
Operation deleteOperation = await(await loadBalancerCollection.GetAsync(lbName)).Value.DeleteAsync(WaitUntil.Completed);
await deleteOperation.WaitForCompletionResponseAsync();
// Verify Delete
AsyncPageable <LoadBalancerResource> listLoadBalancerAP = loadBalancerCollection.GetAllAsync();
List <LoadBalancerResource> listLoadBalancer = await listLoadBalancerAP.ToEnumerableAsync();
Assert.IsEmpty(listLoadBalancer);
// Delete all NetworkInterfaces
await(await networkInterfaceCollection.GetAsync(nic1name)).Value.DeleteAsync(WaitUntil.Completed);
await(await networkInterfaceCollection.GetAsync(nic2name)).Value.DeleteAsync(WaitUntil.Completed);
await(await networkInterfaceCollection.GetAsync(nic3name)).Value.DeleteAsync(WaitUntil.Completed);
// Delete all PublicIPAddresses
await(await resourceGroup.GetPublicIPAddresses().GetAsync(lbPublicIpName)).Value.DeleteAsync(WaitUntil.Completed);
}
public async Task MigrationExample()
{
#region Snippet:Construct_Client
ArmClient client = new ArmClient(new DefaultAzureCredential());
#endregion
#region Snippet:Create_ResourceGroup
SubscriptionResource subscription = await client.GetDefaultSubscriptionAsync();
ResourceGroupCollection resourceGroups = subscription.GetResourceGroups();
AzureLocation location = AzureLocation.WestUS2;
string resourceGroupName = "QuickStartRG";
ResourceGroupData resourceGroupData = new ResourceGroupData(location);
ArmOperation <ResourceGroupResource> resourceGroupOperation = await resourceGroups.CreateOrUpdateAsync(WaitUntil.Completed, resourceGroupName, resourceGroupData);
ResourceGroupResource resourceGroup = resourceGroupOperation.Value;
#endregion
#region Snippet:Create_AvailabilitySet
string virtualMachineName = "quickstartvm";
AvailabilitySetData availabilitySetData = new AvailabilitySetData(location);
AvailabilitySetCollection availabilitySets = resourceGroup.GetAvailabilitySets();
ArmOperation <AvailabilitySetResource> availabilitySetOperation = await availabilitySets.CreateOrUpdateAsync(WaitUntil.Completed, virtualMachineName + "_aSet", availabilitySetData);
AvailabilitySetResource availabilitySet = availabilitySetOperation.Value;
#endregion
#region Snippet:Create_Vnet_and_Subnet
string virtualNetworkName = "MYVM" + "_vnet";
string subnetName = "mySubnet";
VirtualNetworkData virtualNetworkData = new VirtualNetworkData()
{
Subnets =
{
new SubnetData()
{
Name = subnetName,
AddressPrefix = "10.0.0.0/24"
}
}
};
VirtualNetworkCollection virtualNetworks = resourceGroup.GetVirtualNetworks();
virtualNetworkData.AddressPrefixes.Add("10.0.0.0/16");
ArmOperation <VirtualNetworkResource> virtualNetworkOperation = await virtualNetworks.CreateOrUpdateAsync(WaitUntil.Completed, virtualNetworkName, virtualNetworkData);
VirtualNetworkResource virtualNetwork = virtualNetworkOperation.Value;
#endregion
#region Snippet:Create_NetworkSecurityGroup
string networkSecurityGroupName = virtualMachineName + "_nsg";
NetworkSecurityGroupData networkSecurityGroupData = new NetworkSecurityGroupData()
{
Location = location
};
NetworkSecurityGroupCollection networkSecurityGroups = resourceGroup.GetNetworkSecurityGroups();
ArmOperation <NetworkSecurityGroupResource> networkSecurityGroupOperation = await networkSecurityGroups.CreateOrUpdateAsync(WaitUntil.Completed, networkSecurityGroupName, networkSecurityGroupData);
NetworkSecurityGroupResource networkSecurityGroup = networkSecurityGroupOperation.Value;
#endregion
#region Snippet:Create_NetworkInterface
string networkInterfaceName = virtualMachineName + "_nic";
NetworkInterfaceIPConfigurationData networkInterfaceIPConfiguration = new NetworkInterfaceIPConfigurationData()
{
Name = "Primary",
Primary = true,
Subnet = new SubnetData()
{
Id = virtualNetwork.Data.Subnets.First().Id
},
PrivateIPAllocationMethod = IPAllocationMethod.Dynamic,
};
NetworkInterfaceData nicData = new NetworkInterfaceData();
nicData.Location = location;
nicData.IPConfigurations.Add(networkInterfaceIPConfiguration);
NetworkInterfaceCollection networkInterfaces = resourceGroup.GetNetworkInterfaces();
ArmOperation <NetworkInterfaceResource> networkInterfaceOperation = await networkInterfaces.CreateOrUpdateAsync(WaitUntil.Completed, networkInterfaceName, nicData);
NetworkInterfaceResource networkInterface = networkInterfaceOperation.Value;
#endregion
#region Snippet:Create_VirtualMachine
VirtualMachineData virutalMachineData = new VirtualMachineData(location);
virutalMachineData.OSProfile.AdminUsername = "******";
virutalMachineData.OSProfile.AdminPassword = "******";
virutalMachineData.OSProfile.ComputerName = "computer-name";
virutalMachineData.AvailabilitySetId = availabilitySet.Id;
NetworkInterfaceReference nicReference = new NetworkInterfaceReference();
nicReference.Id = networkInterface.Id;
virutalMachineData.NetworkProfile.NetworkInterfaces.Add(nicReference);
VirtualMachineCollection virtualMachines = resourceGroup.GetVirtualMachines();
ArmOperation <VirtualMachineResource> virtualMachineOperation = await virtualMachines.CreateOrUpdateAsync(WaitUntil.Completed, virtualMachineName, virutalMachineData);
VirtualMachineResource virtualMachine = virtualMachineOperation.Value;
Console.WriteLine("VM ID: " + virtualMachine.Id);
#endregion
}
public async Task <GenericResource> CreateLinuxVM(string vmName, string networkInterfaceName, string location, ResourceGroupResource resourceGroup, VirtualNetworkResource vnet)
{
SubscriptionResource subscription = await ArmClient.GetDefaultSubscriptionAsync();
var networkInterface = await CreateNetworkInterface(networkInterfaceName, null, vnet.Data.Subnets[0].Id, location, Recording.GenerateAssetName("ipconfig_"), resourceGroup.GetNetworkInterfaces());
var genericResouces = subscription.GetGenericResourcesAsync();
var adminUsername = Recording.GenerateAssetName("admin");
var vmId = new ResourceIdentifier($"{resourceGroup.Id}/providers/Microsoft.Compute/virtualMachines/{vmName}");
GenericResourceData data = new(location)
{
Properties = BinaryData.FromObjectAsJson(new Dictionary <string, object>
{
{ "hardwareProfile", new Dictionary <string, object>
{
{ "vmSize", "Standard_F2" }
} },
{ "storageProfile", new Dictionary <string, object>
{
{ "imageReference", new Dictionary <string, object>
{
{ "sku", "16.04-LTS" },
{ "publisher", "Canonical" },
{ "version", "latest" },
{ "offer", "UbuntuServer" }
} },
{ "osDisk", new Dictionary <string, object>
{
{ "name", $"{vmName}_os_disk" },
{ "osType", "Linux" },
{ "caching", "ReadWrite" },
{ "createOption", "FromImage" },
{ "managedDisk", new Dictionary <string, object>
{
{ "storageAccountType", "Standard_LRS" }
} }
} }
} },
{ "osProfile", new Dictionary <string, object>
{
{ "adminUsername", adminUsername },
{ "computerName", vmName },
{ "linuxConfiguration", new Dictionary <string, object>
{
{ "ssh", new Dictionary <string, object>
{
{ "publicKeys", new List <object>
{
new Dictionary <string, object>
{
{ "path", $"/home/{adminUsername}/.ssh/authorized_keys" },
{ "keyData", dummySSHKey }
}
} }
} },
{ "disablePasswordAuthentication", true },
} },
} },
{ "networkProfile", new Dictionary <string, object>
{
{ "networkInterfaces", new List <object>
{
new Dictionary <string, object>
{
{ "id", networkInterface.Id.ToString() },
{ "properties", new Dictionary <string, object>
{
{ "primary", true }
} }
}
} }
} }
})
};
var operation = await ArmClient.GetGenericResources().CreateOrUpdateAsync(WaitUntil.Completed, vmId, data);
return(operation.Value);
}
/// <summary>
/// create a default private endpoint for managed instance.
/// please make sure your MI built using CreateDefaultManagedInstance() or vnet AddressPrefixes = 10.10.0.0/16
/// </summary>
/// <param name="managedInstance"></param>
/// <param name="location"></param>
/// <param name="resourceGroup"></param>
/// <param name=""></param>
/// <returns></returns>
protected async Task <PrivateEndpointResource> CreateDefaultPrivateEndpoint(ManagedInstanceResource managedInstance, VirtualNetworkResource vnet, AzureLocation location, ResourceGroupResource resourceGroup)
{
// Add new subnet
SubnetData subnetData = new SubnetData()
{
AddressPrefix = "10.10.5.0/24",
PrivateEndpointNetworkPolicies = "Disabled"
};
var privateEndpointSubnet = await vnet.GetSubnets().CreateOrUpdateAsync(WaitUntil.Completed, $"private-endpoint-subnet", subnetData);
// Create private endpoint
string privateEndpointName = $"{managedInstance.Data.Name}-private-endpoint";
var endpointCollection = resourceGroup.GetPrivateEndpoints();
PrivateEndpointData data = new PrivateEndpointData()
{
Subnet = new SubnetData()
{
Id = privateEndpointSubnet.Value.Data.Id
},
Location = location,
PrivateLinkServiceConnections =
{
new PrivateLinkServiceConnection()
{
Name = privateEndpointName,
PrivateLinkServiceId = managedInstance.Data.Id.ToString(),
GroupIds = { "managedInstance" },
}
},
};
var privateEndpoint = await resourceGroup.GetPrivateEndpoints().CreateOrUpdateAsync(WaitUntil.Completed, privateEndpointName, data);
return(privateEndpoint.Value);
}
public async Task PrivateEndpointConnectionCreateAndUpdate()
{
/*
* CAUTION: all private endpoint methods do not work properly now, so just temporally use Network's private endpoint methods for testing.
* Will confirm service team that this is expected.
*/
// Create a vault first
VaultResource vaultResource = (await CreateVault()).Value;
// Create a vnet
VirtualNetworkResource vnetResource = (await createVirtualNetwork()).Value;
// Create the private endpoint
PrivateEndpointData privateEndpointData = new PrivateEndpointData
{
Location = Location,
Subnet = vnetResource.Data.Subnets[0],
ManualPrivateLinkServiceConnections =
{
new PrivateLinkServiceConnection
{
Name = Recording.GenerateAssetName("pec"),
// TODO: externalize or create the service on-demand, like virtual network
//PrivateLinkServiceId = $"/subscriptions/{SubscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}",
PrivateLinkServiceId = vaultResource.Data.Id.ToString(),
RequestMessage = "SDK test",
GroupIds = { "vault" }
}
},
};
string privateEndpointName = Recording.GenerateAssetName("pe-");
PrivateEndpointCollection privateEndpointCollection = ResourceGroupResource.GetPrivateEndpoints();
PrivateEndpointResource privateEndpoint = (await privateEndpointCollection.CreateOrUpdateAsync(WaitUntil.Completed, privateEndpointName, privateEndpointData)).Value;
// get
privateEndpoint = (await privateEndpointCollection.GetAsync(privateEndpointName)).Value;
Assert.AreEqual(privateEndpoint.Data.Name, privateEndpointName);
Assert.AreEqual(privateEndpoint.Data.Location, Location.ToString());
Assert.IsEmpty(privateEndpoint.Data.Tags);
// update
privateEndpointData.Tags.Add("test", "test");
privateEndpoint = (await privateEndpointCollection.CreateOrUpdateAsync(WaitUntil.Completed, privateEndpoint.Data.Name, privateEndpointData)).Value;
Assert.AreEqual(privateEndpoint.Data.Name, privateEndpointName);
Assert.AreEqual(privateEndpoint.Data.Location, Location.ToString());
Assert.That(privateEndpoint.Data.Tags, Has.Count.EqualTo(1));
Assert.That(privateEndpoint.Data.Tags, Does.ContainKey("test").WithValue("test"));
// list
List <PrivateEndpointResource> privateEndpoints = (await privateEndpointCollection.GetAllAsync().ToEnumerableAsync());
Assert.That(privateEndpoints, Has.Count.EqualTo(1));
Assert.AreEqual(privateEndpointName, privateEndpoint.Data.Name);
// delete
await privateEndpoint.DeleteAsync(WaitUntil.Completed);
// list all
privateEndpoints = (await Subscription.GetPrivateEndpointsAsync().ToEnumerableAsync());
Assert.That(privateEndpoints, Has.None.Matches <PrivateEndpointResource>(p => p.Data.Name == privateEndpointName));
}
public async Task SetGetNetworkRuleSets()
{
IgnoreTestInLiveMode();
//create namespace with premium
_resourceGroup = await CreateResourceGroupAsync();
ServiceBusNamespaceCollection namespaceCollection = _resourceGroup.GetServiceBusNamespaces();
string namespaceName = await CreateValidNamespaceName(namespacePrefix);
ServiceBusNamespaceData createParameters = new ServiceBusNamespaceData(DefaultLocation);
createParameters.Sku = new ServiceBusSku(ServiceBusSkuName.Premium)
{
Tier = ServiceBusSkuTier.Premium
};
ServiceBusNamespaceResource serviceBusNamespace = (await namespaceCollection.CreateOrUpdateAsync(WaitUntil.Completed, namespaceName, createParameters)).Value;
//prepare vnet
string vnetName = Recording.GenerateAssetName("sdktestvnet");
var parameters = new VirtualNetworkData
{
Subnets =
{
new SubnetData
{
Name = "default1",
AddressPrefix = "10.0.0.0/24",
ServiceEndpoints ={ new ServiceEndpointPropertiesFormat {
Service = "Microsoft.ServiceBus"
} }
},
new SubnetData
{
Name = "default2",
AddressPrefix = "10.0.1.0/24",
ServiceEndpoints ={ new ServiceEndpointPropertiesFormat {
Service = "Microsoft.ServiceBus"
} }
},
new SubnetData
{
Name = "default3",
AddressPrefix = "10.0.2.0/24",
ServiceEndpoints ={ new ServiceEndpointPropertiesFormat {
Service = "Microsoft.ServiceBus"
} }
}
},
Location = "eastus2"
};
parameters.AddressPrefixes.Add("10.0.0.0/16");
VirtualNetworkResource virtualNetwork = (await _resourceGroup.GetVirtualNetworks().CreateOrUpdateAsync(WaitUntil.Completed, vnetName, parameters)).Value;
//set network rule set
string subscriptionId = DefaultSubscription.Id.ToString();
ResourceIdentifier subnetId1 = new ResourceIdentifier(subscriptionId + "/resourceGroups/" + _resourceGroup.Id.Name + "/providers/Microsoft.Network/virtualNetworks/" + vnetName + "/subnets/default1");
ResourceIdentifier subnetId2 = new ResourceIdentifier(subscriptionId + "/resourceGroups/" + _resourceGroup.Id.Name + "/providers/Microsoft.Network/virtualNetworks/" + vnetName + "/subnets/default2");
ResourceIdentifier subnetId3 = new ResourceIdentifier(subscriptionId + "/resourceGroups/" + _resourceGroup.Id.Name + "/providers/Microsoft.Network/virtualNetworks/" + vnetName + "/subnets/default3");
NetworkRuleSetData parameter = new NetworkRuleSetData()
{
DefaultAction = DefaultAction.Deny,
VirtualNetworkRules =
{
new NetworkRuleSetVirtualNetworkRules()
{
Subnet = new WritableSubResource()
{
Id = subnetId1
}, IgnoreMissingVnetServiceEndpoint = true
},
new NetworkRuleSetVirtualNetworkRules()
{
Subnet = new WritableSubResource()
{
Id = subnetId2
}, IgnoreMissingVnetServiceEndpoint = false
},
new NetworkRuleSetVirtualNetworkRules()
{
Subnet = new WritableSubResource()
{
Id = subnetId3
}, IgnoreMissingVnetServiceEndpoint = false
}
},
IPRules =
{
new NetworkRuleSetIPRules()
{
IPMask = "1.1.1.1", Action = "Allow"
},
new NetworkRuleSetIPRules()
{
IPMask = "1.1.1.2", Action = "Allow"
},
new NetworkRuleSetIPRules()
{
IPMask = "1.1.1.3", Action = "Allow"
},
new NetworkRuleSetIPRules()
{
IPMask = "1.1.1.4", Action = "Allow"
},
new NetworkRuleSetIPRules()
{
IPMask = "1.1.1.5", Action = "Allow"
}
}
};
await serviceBusNamespace.GetNetworkRuleSet().CreateOrUpdateAsync(WaitUntil.Completed, parameter);
//get the network rule set
NetworkRuleSetResource networkRuleSet = await serviceBusNamespace.GetNetworkRuleSet().GetAsync();
Assert.NotNull(networkRuleSet);
Assert.NotNull(networkRuleSet.Data.IPRules);
Assert.NotNull(networkRuleSet.Data.VirtualNetworkRules);
Assert.AreEqual(networkRuleSet.Data.VirtualNetworkRules.Count, 3);
Assert.AreEqual(networkRuleSet.Data.IPRules.Count, 5);
//delete virtual network
await virtualNetwork.DeleteAsync(WaitUntil.Completed);
}
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"
} }
};
VirtualNetworkResource virtualNetwork = await virtualNetworkCollection.CreateOrUpdate(WaitUntil.Completed, 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"
}
};
PublicIPAddressResource publicIPAddress = await publicIPAddressCollection.CreateOrUpdate(WaitUntil.Completed, publicIPAddressName, publicIPInput).WaitForCompletionAsync();
NetworkInterfaceCollection networkInterfaceCollection = resourceGroup.GetNetworkInterfaces();
string networkInterfaceName = "myNetworkInterface";
NetworkInterfaceData networkInterfaceInput = new NetworkInterfaceData()
{
Location = resourceGroup.Data.Location,
IPConfigurations =
{
new NetworkInterfaceIPConfigurationData()
{
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
}
}
}
};
NetworkInterfaceResource networkInterface = await networkInterfaceCollection.CreateOrUpdate(WaitUntil.Completed, networkInterfaceName, networkInterfaceInput).WaitForCompletionAsync();
#endregion
}
public async Task PrivateEndpointTest()
{
virtualNetwork = (await createVirtualNetwork()).Value;
storageAccount = await createStorageAccount();
// create
var privateEndpointCollection = resourceGroup.GetPrivateEndpoints();
var name = Recording.GenerateAssetName("pe");
System.Console.WriteLine($"SubnetResource ID: {virtualNetwork.Data.Subnets[0].Id}");
var privateEndpointData = new PrivateEndpointData
{
Location = TestEnvironment.Location,
Subnet = virtualNetwork.Data.Subnets[0],
PrivateLinkServiceConnections =
{
new PrivateLinkServiceConnection
{
Name = Recording.GenerateAssetName("pec"),
// TODO: externalize or create the service on-demand, like virtual network
//PrivateLinkServiceId = $"/subscriptions/{TestEnvironment.SubscriptionId}/resourceGroups/{resourceGroup.Data.Name}/providers/Microsoft.Storage/storageAccounts/{storageAccount.Name}",
PrivateLinkServiceId = storageAccount.Id,
RequestMessage = "SDK test",
GroupIds = { "storage" }
}
},
};
var privateEndpoint = (await privateEndpointCollection.CreateOrUpdateAsync(WaitUntil.Completed, name, privateEndpointData)).Value;
Assert.AreEqual(name, privateEndpoint.Data.Name);
Assert.AreEqual(TestEnvironment.Location, privateEndpoint.Data.Location);
Assert.IsEmpty(privateEndpoint.Data.Tags);
// get
privateEndpoint = (await privateEndpointCollection.GetAsync(name)).Value;
Assert.AreEqual(name, privateEndpoint.Data.Name);
Assert.AreEqual(TestEnvironment.Location, privateEndpoint.Data.Location);
Assert.IsEmpty(privateEndpoint.Data.Tags);
// update
privateEndpointData.Tags.Add("test", "test");
privateEndpoint = (await privateEndpointCollection.CreateOrUpdateAsync(WaitUntil.Completed, name, privateEndpointData)).Value;
Assert.AreEqual(name, privateEndpoint.Data.Name);
Assert.AreEqual(TestEnvironment.Location, privateEndpoint.Data.Location);
Assert.That(privateEndpoint.Data.Tags, Has.Count.EqualTo(1));
Assert.That(privateEndpoint.Data.Tags, Does.ContainKey("test").WithValue("test"));
// list
var privateEndpoints = (await privateEndpointCollection.GetAllAsync().ToEnumerableAsync());
Assert.That(privateEndpoints, Has.Count.EqualTo(1));
Assert.AreEqual(name, privateEndpoint.Data.Name);
// delete
await privateEndpoint.DeleteAsync(WaitUntil.Completed);
// list all
privateEndpoints = (await _subscription.GetPrivateEndpointsAsync().ToEnumerableAsync());
Assert.That(privateEndpoints, Has.None.Matches <PrivateEndpointResource>(p => p.Data.Name == name));
}
public async Task NewCode()
{
#endif
var armClient = new ArmClient(new DefaultAzureCredential());
var location = AzureLocation.WestUS;
// Create ResourceGroupResource
SubscriptionResource subscription = await armClient.GetDefaultSubscriptionAsync();
ArmOperation<ResourceGroupResource> rgOperation = await subscription.GetResourceGroups().CreateOrUpdateAsync(WaitUntil.Completed, "myResourceGroup", new ResourceGroupData(location));
ResourceGroupResource resourceGroup = rgOperation.Value;
// Create AvailabilitySet
var availabilitySetData = new AvailabilitySetData(location)
{
PlatformUpdateDomainCount = 5,
PlatformFaultDomainCount = 2,
Sku = new ComputeSku() { Name = "Aligned" }
};
ArmOperation<AvailabilitySetResource> asetOperation = await resourceGroup.GetAvailabilitySets().CreateOrUpdateAsync(WaitUntil.Completed, "myAvailabilitySet", availabilitySetData);
AvailabilitySetResource availabilitySet = asetOperation.Value;
// Create VNet
var vnetData = new VirtualNetworkData()
{
Location = location,
Subnets =
{
new SubnetData()
{
Name = "mySubnet",
AddressPrefix = "10.0.0.0/24",
}
},
};
vnetData.AddressPrefixes.Add("10.0.0.0/16");
ArmOperation<VirtualNetworkResource> vnetOperation = await resourceGroup.GetVirtualNetworks().CreateOrUpdateAsync(WaitUntil.Completed, "myVirtualNetwork", vnetData);
VirtualNetworkResource vnet = vnetOperation.Value;
// Create Network interface
var nicData = new NetworkInterfaceData()
{
Location = location,
IPConfigurations =
{
new NetworkInterfaceIPConfigurationData()
{
Name = "Primary",
Primary = true,
Subnet = new SubnetData() { Id = vnet.Data.Subnets.First().Id },
PrivateIPAllocationMethod = IPAllocationMethod.Dynamic,
}
}
};
ArmOperation<NetworkInterfaceResource> nicOperation = await resourceGroup.GetNetworkInterfaces().CreateOrUpdateAsync(WaitUntil.Completed, "myNetworkInterface", nicData);
NetworkInterfaceResource nic = nicOperation.Value;
var vmData = new VirtualMachineData(location)
{
AvailabilitySet = new WritableSubResource() { Id = availabilitySet.Id },
NetworkProfile = new Compute.Models.NetworkProfile { NetworkInterfaces = { new NetworkInterfaceReference() { Id = nic.Id } } },
OSProfile = new OSProfile
{
ComputerName = "testVM",
AdminUsername = "******",
AdminPassword = "******",
LinuxConfiguration = new LinuxConfiguration { DisablePasswordAuthentication = false, ProvisionVmAgent = true }
},
StorageProfile = new StorageProfile()
{
ImageReference = new ImageReference()
{
Offer = "UbuntuServer",
Publisher = "Canonical",
Sku = "18.04-LTS",
Version = "latest"
}
},
HardwareProfile = new HardwareProfile() { VmSize = VirtualMachineSizeTypes.StandardB1Ms },
};
ArmOperation<VirtualMachineResource> vmOperation = await resourceGroup.GetVirtualMachines().CreateOrUpdateAsync(WaitUntil.Completed, "myVirtualMachine", vmData);
VirtualMachineResource vm = vmOperation.Value;
#endregion
}
public async Task PrivateDnsZoneGroupTest()
{
virtualNetwork = (await createVirtualNetwork()).Value;
storageAccount = await createStorageAccount();
// create
var privateEndpointCollection = resourceGroup.GetPrivateEndpoints();
var name = Recording.GenerateAssetName("pe");
System.Console.WriteLine($"SubnetResource ID: {virtualNetwork.Data.Subnets[0].Id}");
var privateEndpointData = new PrivateEndpointData
{
Location = TestEnvironment.Location,
Subnet = virtualNetwork.Data.Subnets[0],
PrivateLinkServiceConnections =
{
new PrivateLinkServiceConnection
{
Name = Recording.GenerateAssetName("pec"),
// TODO: externalize or create the service on-demand, like virtual network
//PrivateLinkServiceId = "/subscriptions/db1ab6f0-4769-4b27-930e-01e2ef9c123c/resourceGroups/sdktest7669/providers/Microsoft.KeyVault/vaults/TierRuanKeyVaultJustTest",
PrivateLinkServiceId = storageAccount.Id,
RequestMessage = "SDK test",
GroupIds = { "storage" }
}
},
};
var privateEndpoint = (await privateEndpointCollection.CreateOrUpdateAsync(WaitUntil.Completed, name, privateEndpointData)).Value;
var privateDnsZoneName = Recording.GenerateAssetName("private_dns_zone");
var privateDnsZoneResourceId = new ResourceIdentifier($"/subscriptions/{TestEnvironment.SubscriptionId}/resourceGroups/{resourceGroup.Data.Name}/Microsoft.Network/privateDnsZones/{privateDnsZoneName}");
privateDnsZone = ArmClient.GetGenericResources().CreateOrUpdate(WaitUntil.Completed, privateDnsZoneResourceId, new GenericResourceData(TestEnvironment.Location)).Value;
var privateDnsZoneGroupName = Recording.GenerateAssetName("private_dns_zone_group");
var privateDnsZoneGroupCollection = privateEndpoint.GetPrivateDnsZoneGroups();
var privateDnsZoneGroup = (await privateDnsZoneGroupCollection.CreateOrUpdateAsync(WaitUntil.Completed, privateDnsZoneGroupName, new PrivateDnsZoneGroupData {
PrivateDnsZoneConfigs =
{
new PrivateDnsZoneConfig
{
Name = privateDnsZoneName,
PrivateDnsZoneId = privateDnsZone.Id,
}
}
})).Value;
Assert.IsNotEmpty(privateDnsZoneGroup.Data.PrivateDnsZoneConfigs);
Assert.That(privateDnsZoneGroup.Data.PrivateDnsZoneConfigs, Has.Count.EqualTo(1));
Assert.AreEqual(privateDnsZoneName, privateDnsZoneGroup.Data.PrivateDnsZoneConfigs[0].Name);
Assert.AreEqual(privateDnsZone.Id, privateDnsZoneGroup.Data.PrivateDnsZoneConfigs[0].PrivateDnsZoneId);
// list
var groups = (await privateDnsZoneGroupCollection.GetAllAsync().ToEnumerableAsync());
Assert.That(groups, Has.Count.EqualTo(1));
privateDnsZoneGroup = groups[0];
Assert.IsNotEmpty(privateDnsZoneGroup.Data.PrivateDnsZoneConfigs);
Assert.That(privateDnsZoneGroup.Data.PrivateDnsZoneConfigs, Has.Count.EqualTo(1));
Assert.AreEqual(privateDnsZoneName, privateDnsZoneGroup.Data.PrivateDnsZoneConfigs[0].Name);
Assert.AreEqual(privateDnsZone.Id, privateDnsZoneGroup.Data.PrivateDnsZoneConfigs[0].PrivateDnsZoneId);
// get
privateDnsZoneGroup = (await privateDnsZoneGroupCollection.GetAsync(privateDnsZoneGroupName)).Value;
Assert.IsNotEmpty(privateDnsZoneGroup.Data.PrivateDnsZoneConfigs);
Assert.That(privateDnsZoneGroup.Data.PrivateDnsZoneConfigs, Has.Count.EqualTo(1));
Assert.AreEqual(privateDnsZoneName, privateDnsZoneGroup.Data.PrivateDnsZoneConfigs[0].Name);
Assert.AreEqual(privateDnsZone.Id, privateDnsZoneGroup.Data.PrivateDnsZoneConfigs[0].PrivateDnsZoneId);
// update
privateDnsZoneGroup = (await privateDnsZoneGroupCollection.CreateOrUpdateAsync(WaitUntil.Completed, privateDnsZoneGroupName, new PrivateDnsZoneGroupData {
})).Value;
Assert.IsEmpty(privateDnsZoneGroup.Data.PrivateDnsZoneConfigs);
// delete
await privateDnsZoneGroup.DeleteAsync(WaitUntil.Completed);
// list again
groups = (await privateDnsZoneGroupCollection.GetAllAsync().ToEnumerableAsync());
Assert.IsEmpty(groups);
await privateEndpoint.DeleteAsync(WaitUntil.Completed);
}
