// This test put multiple zonal virtual machine's NIC into backend pool of a zone-redundant load balancer.
// There is a bug in the service, where such an attempt will fail with error
// "error": {
// "code": "NetworkInterfaceAndLoadBalancerAreInDifferentAvailabilitySets",
// "message": "Network interface /subscriptions/<sub-id>/resourceGroups/<rg-name>/providers/Microsoft.Network/networkInterfaces/<nic-name> uses load balancer /subscriptions/<sub-id>/resourceGroups/<rg-name>/providers/Microsoft.Compute/virtualMachines/<vm-name>).",
// "details": []
// }
// Enable this test once it is fixed.
//
public void CanCreateZonedVMsAndAssociateThemWithSingleBackendPoolOfZoneResilientLB()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
string rgName = TestUtilities.GenerateName("rgzoned");
try
{
var region = Region.USEast2;
string networkName = TestUtilities.GenerateName("net");
var azure = TestHelper.CreateRollupClient();
var network = azure.Networks.Define(networkName)
.WithRegion(region)
.WithNewResourceGroup(rgName)
.WithAddressSpace("10.0.0.0/28")
.WithSubnet("subnet1", "10.0.0.0/29")
.WithSubnet("subnet2", "10.0.0.8/29")
.Create();
string pipDnsLabel = TestUtilities.GenerateName("pip");
var subnets = network.Subnets.Values.GetEnumerator();
// Define first regional virtual machine
//
subnets.MoveNext();
var creatableVM1 = azure.VirtualMachines
.Define(TestUtilities.GenerateName("vm1"))
.WithRegion(region)
.WithExistingResourceGroup(rgName)
.WithExistingPrimaryNetwork(network)
.WithSubnet(subnets.Current.Name) // Put VM in first subnet
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername("Foo12")
.WithRootPassword("abc!@#F0orL")
// Optionals
.WithAvailabilityZone(AvailabilityZoneId.Zone_1)
.WithSize(VirtualMachineSizeTypes.StandardD3V2);
subnets.MoveNext();
var creatableVM2 = azure.VirtualMachines
.Define(TestUtilities.GenerateName("vm2"))
.WithRegion(region)
.WithExistingResourceGroup(rgName)
.WithExistingPrimaryNetwork(network)
.WithSubnet(subnets.Current.Name) // Put VM in second subnet
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername("Foo12")
.WithRootPassword("abc!@#F0orL")
// Optionals
.WithAvailabilityZone(AvailabilityZoneId.Zone_1)
.WithSize(VirtualMachineSizeTypes.StandardD3V2);
ICreatedResources <IVirtualMachine> createdVMs = azure.VirtualMachines.Create(creatableVM1, creatableVM2);
var itr = createdVMs.GetEnumerator();
itr.MoveNext();
IVirtualMachine firstVirtualMachine = itr.Current;
itr.MoveNext();
IVirtualMachine secondVirtualMachine = itr.Current;
var publicIPAddress = azure.PublicIPAddresses
.Define(pipDnsLabel)
.WithRegion(region)
.WithExistingResourceGroup(rgName)
.WithStaticIP()
// Optionals
.WithSku(PublicIPSkuType.Standard) // STANDARD LB requires STANDARD PIP
// Create PIP
.Create();
// Creates a Internet-Facing LoadBalancer with one front-end IP configuration and
// two backend pool associated with this IP Config
//
var lbName = TestUtilities.GenerateName("lb");
ILoadBalancer lb = azure.LoadBalancers
.Define(lbName)
.WithRegion(region)
.WithExistingResourceGroup(rgName)
.DefineLoadBalancingRule("rule-1")
.WithProtocol(TransportProtocol.Tcp)
.FromFrontend("front-end-1")
.FromFrontendPort(80)
.ToExistingVirtualMachines(firstVirtualMachine, secondVirtualMachine)
.WithProbe("tcpProbe-1")
.Attach()
.DefinePublicFrontend("front-end-1") // Define the frontend IP configuration used by the LB rule
.WithExistingPublicIPAddress(publicIPAddress)
.Attach()
.DefineTcpProbe("tcpProbe-1") // Define the Probe used by the LB rule
.WithPort(25)
.WithIntervalInSeconds(15)
.WithNumberOfProbes(5)
.Attach()
.WithSku(LoadBalancerSkuType.Standard) // "zone-resilient LB" which don't have the constraint that all VMs needs to be in the same availability set
.Create();
// Zone resilient LB does not care VMs are zoned or regional, in the above cases VMs are regional.
//
// rx.Completable.merge(firstVirtualMachine.startAsync(), secondVirtualMachine.startAsync()).await();
// Verify frontends
Assert.Equal(1, lb.Frontends.Count);
Assert.Equal(1, lb.PublicFrontends.Count);
Assert.Equal(0, lb.PrivateFrontends.Count);
ILoadBalancerFrontend frontend = lb.Frontends.Values.First();
Assert.True(frontend.IsPublic);
ILoadBalancerPublicFrontend publicFrontend = (ILoadBalancerPublicFrontend)frontend;
Assert.Equal(publicIPAddress.Id, publicFrontend.PublicIPAddressId, ignoreCase: true);
// Verify backends
Assert.Equal(1, lb.Backends.Count);
// Verify probes
Assert.Equal(1, lb.TcpProbes.Count);
Assert.True(lb.TcpProbes.ContainsKey("tcpProbe-1"));
// Verify rules
Assert.Equal(1, lb.LoadBalancingRules.Count);
Assert.True(lb.LoadBalancingRules.ContainsKey("rule-1"));
ILoadBalancingRule rule = lb.LoadBalancingRules["rule-1"];
Assert.NotNull(rule.Backend);
Assert.Equal("tcpProbe-1", rule.Probe.Name, ignoreCase: true);
// Zone resilient LB does not care VMs are zoned or regional, in the above cases VMs are zoned.
//
// Note that above configuration is not possible for BASIC LB, BASIC LB has following limitation
// It supports VMs only in a single availability Set in a backend pool, though multiple backend pool
// can be associated with VMs in the single availability set, you cannot create a set of VMs in another
// availability set and put it in a different backend pool.
}
finally
{
try
{
var resourceManager = TestHelper.CreateResourceManager();
resourceManager.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
private PrivateLinkServiceImpl WithFrontendIpConfiguration(ILoadBalancerFrontend loadBalancerFrontend)
{
frontendIpConfigurations[loadBalancerFrontend.Name] = loadBalancerFrontend.Inner;
return(this);
}
PrivateLinkService.Update.IUpdate PrivateLinkService.Update.IWithFrontendIpConfiguration.WithFrontendIpConfiguration(ILoadBalancerFrontend loadBalancerFrontend)
{
return(WithFrontendIpConfiguration(loadBalancerFrontend));
}
PrivateLinkService.Definition.IWithCreate PrivateLinkService.Definition.IWithFrontendIpConfiguration.WithFrontendIpConfiguration(ILoadBalancerFrontend loadBalancerFrontend)
{
return(WithFrontendIpConfiguration(loadBalancerFrontend));
}
public void CanCreateUpdate()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var rgName = SdkContext.RandomResourceName("rg", 10);
var vnetName = SdkContext.RandomResourceName("vnet", 10);
var subnetName = SdkContext.RandomResourceName("subnet", 10);
var lbName = SdkContext.RandomResourceName("lb", 10);
var plsName = SdkContext.RandomResourceName("pls", 10);
var azure = TestHelper.CreateRollupClient();
try
{
var resourceGroup = azure.ResourceGroups.Define(rgName)
.WithRegion(REGION)
.Create();
var vnet = azure.Networks.Define(vnetName)
.WithRegion(REGION)
.WithExistingResourceGroup(resourceGroup)
.WithAddressSpace("10.0.0.0/16")
.WithSubnet(subnetName, "10.0.0.0/24")
.Create();
var loadBalancer = azure.LoadBalancers.Define(lbName)
.WithRegion(REGION)
.WithExistingResourceGroup(resourceGroup)
.DefineLoadBalancingRule("myHttpRule")
.WithProtocol(TransportProtocol.Tcp)
.FromFrontend("myFrontEnd")
.FromFrontendPort(80)
.ToBackend("myBackEnd")
.WithProbe("myProbe")
.Attach()
.DefinePrivateFrontend("myFrontEnd")
.WithExistingSubnet(vnet, subnetName)
.Attach()
.DefineBackend("myBackEnd")
.Attach()
.DefineHttpProbe("myProbe")
.WithRequestPath("/")
.WithPort(80)
.Attach()
.WithSku(LoadBalancerSkuType.Standard)
.Create();
vnet.Subnets[subnetName].Inner.PrivateLinkServiceNetworkPolicies = "Disabled";
vnet.Update()
.UpdateSubnet(subnetName)
.Parent()
.Apply();
ISubnet subnet = vnet.Subnets[subnetName];
ILoadBalancerFrontend lbFrontend = loadBalancer.Frontends["myFrontEnd"];
var privateLinkService = azure.PrivateLinkServices.Define(plsName)
.WithExistingResourceGroup(resourceGroup)
.WithRegion(REGION)
.WithFrontendIpConfiguration(lbFrontend)
.DefinePrivateLinkServiceIpConfiguration("myPrivateIPConfig")
.SetAsPrimaryIpConfiguration()
.WithSubnet(subnet.Inner.Id)
.Attach()
.Create();
Assert.NotNull(privateLinkService);
Assert.NotNull(privateLinkService.IpConfigurations);
Assert.True(privateLinkService.IpConfigurations.Count == 1);
Assert.False(privateLinkService.IsProxyProtocolEnabled);
Assert.True(privateLinkService.LoadBalancerFrontendIpConfigurations.Count == 1);
privateLinkService = azure.PrivateLinkServices.GetByResourceGroup(rgName, plsName);
Assert.Equal("myFrontEnd", privateLinkService.LoadBalancerFrontendIpConfigurations.First().Name);
Assert.Equal("myHttpRule", privateLinkService.LoadBalancerFrontendIpConfigurations.First().LoadBalancingRules["myHttpRule"].Name);
privateLinkService = azure.PrivateLinkServices.GetByResourceGroup(rgName, plsName);
privateLinkService.Update()
.EnableProxyProtocol()
.UpdatePrivateLinkServiceIpConfiguration("myPrivateIPConfig")
.WithStaticPrivateIpAllocation()
.WithPrivateIpAddress("10.0.0.5")
.Attach()
.Apply();
Assert.True(privateLinkService.IsProxyProtocolEnabled);
Assert.Equal(IPAllocationMethod.Static, privateLinkService.IpConfigurations[0].PrivateIPAllocationMethod);
}
finally
{
try
{
azure.ResourceGroups.DeleteByName(rgName);
}
catch
{
}
}
}
}
