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