public static ILoadBalancer CreateInternalLoadBalancer(
IAzure azure,
IResourceGroup resourceGroup,
INetwork network,
string id,
Region location)
{
string loadBalancerName = TestUtilities.GenerateName("InternalLb" + id);
string privateFrontEndName = loadBalancerName + "-FE1";
string backendPoolName1 = loadBalancerName + "-BAP1";
string backendPoolName2 = loadBalancerName + "-BAP2";
string natPoolName1 = loadBalancerName + "-INP1";
string natPoolName2 = loadBalancerName + "-INP2";
string subnetName = "subnet1";
ILoadBalancer loadBalancer = azure.LoadBalancers.Define(loadBalancerName)
.WithRegion(location)
.WithExistingResourceGroup(resourceGroup)
// Add two rules that uses above backend and probe
.DefineLoadBalancingRule("httpRule")
.WithProtocol(TransportProtocol.Tcp)
.FromFrontend(privateFrontEndName)
.FromFrontendPort(1000)
.ToBackend(backendPoolName1)
.WithProbe("httpProbe")
.Attach()
.DefineLoadBalancingRule("httpsRule")
.WithProtocol(TransportProtocol.Tcp)
.FromFrontend(privateFrontEndName)
.FromFrontendPort(1001)
.ToBackend(backendPoolName2)
.WithProbe("httpsProbe")
.Attach()
// Add two nat pools to enable direct VM connectivity to port 44 and 45
.DefineInboundNatPool(natPoolName1)
.WithProtocol(TransportProtocol.Tcp)
.FromFrontend(privateFrontEndName)
.FromFrontendPortRange(8000, 8099)
.ToBackendPort(44)
.Attach()
.DefineInboundNatPool(natPoolName2)
.WithProtocol(TransportProtocol.Tcp)
.FromFrontend(privateFrontEndName)
.FromFrontendPortRange(9000, 9099)
.ToBackendPort(45)
.Attach()
// Explicitly define the frontend
.DefinePrivateFrontend(privateFrontEndName)
.WithExistingSubnet(network, subnetName)
.Attach()
// Add two probes one per rule
.DefineHttpProbe("httpProbe")
.WithRequestPath("/")
.Attach()
.DefineHttpProbe("httpsProbe")
.WithRequestPath("/")
.Attach()
.Create();
loadBalancer = azure.LoadBalancers.GetByResourceGroup(resourceGroup.Name, loadBalancerName);
Assert.Empty(loadBalancer.PublicIPAddressIds);
Assert.Equal(2, loadBalancer.Backends.Count());
ILoadBalancerBackend backend1 = null;
Assert.True(loadBalancer.Backends.TryGetValue(backendPoolName1, out backend1));
ILoadBalancerBackend backend2 = null;
Assert.True(loadBalancer.Backends.TryGetValue(backendPoolName2, out backend2));
ILoadBalancerHttpProbe httpProbe = null;
Assert.True(loadBalancer.HttpProbes.TryGetValue("httpProbe", out httpProbe));
Assert.Single(httpProbe.LoadBalancingRules);
ILoadBalancerHttpProbe httpsProbe = null;
Assert.True(loadBalancer.HttpProbes.TryGetValue("httpsProbe", out httpsProbe));
Assert.Single(httpProbe.LoadBalancingRules);
Assert.Equal(2, loadBalancer.InboundNatPools.Count());
return(loadBalancer);
}
public void CanCRUDProbe()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
string rgName = TestUtilities.GenerateName("rg");
string lbName = TestUtilities.GenerateName("lb");
string nwName = TestUtilities.GenerateName("nw");
Region region = Region.USEast;
IAzure azure = null;
try
{
azure = TestHelper.CreateRollupClient();
IResourceGroup resourceGroup = azure.ResourceGroups
.Define(rgName)
.WithRegion(region)
.Create();
INetwork network = azure.Networks
.Define(nwName)
.WithRegion(region)
.WithExistingResourceGroup(resourceGroup)
.WithAddressSpace("172.18.0.0/28")
.WithSubnet(subnetName1, "172.18.0.0/28")
.Create();
ILoadBalancer loadBalancer = CreateLoadBalancer(azure, resourceGroup, network, lbName);
// verify created probes
loadBalancer.Refresh();
Assert.Equal(2, loadBalancer.LoadBalancingRules.Count);
Assert.Empty(loadBalancer.TcpProbes);
Assert.Single(loadBalancer.HttpProbes);
Assert.Single(loadBalancer.HttpsProbes);
ILoadBalancerHttpProbe httpProbe = null;
Assert.True(loadBalancer.HttpProbes.TryGetValue(probeName1, out httpProbe));
Assert.Single(httpProbe.LoadBalancingRules);
ILoadBalancerHttpProbe httpsProbe = null;
Assert.True(loadBalancer.HttpsProbes.TryGetValue(probeName2, out httpsProbe));
Assert.Single(httpsProbe.LoadBalancingRules);
// verify https probe
Assert.Equal(ProbeProtocol.Https, httpsProbe.Protocol);
Assert.Equal(443, httpsProbe.Port);
Assert.Equal("/", httpsProbe.RequestPath);
// update probe
loadBalancer.Update()
.UpdateHttpsProbe(probeName2)
.WithIntervalInSeconds(60)
.WithRequestPath("/health")
.Parent().Apply();
// verify probe updated
loadBalancer.Refresh();
Assert.True(loadBalancer.HttpProbes.TryGetValue(probeName1, out httpProbe));
Assert.True(loadBalancer.HttpsProbes.TryGetValue(probeName2, out httpsProbe));
Assert.Single(httpsProbe.LoadBalancingRules);
Assert.Equal(ProbeProtocol.Https, httpsProbe.Protocol);
Assert.Equal(443, httpsProbe.Port);
Assert.Equal(60, httpsProbe.IntervalInSeconds);
Assert.Equal("/health", httpsProbe.RequestPath);
// delete probe
loadBalancer.Update()
.WithoutProbe(probeName2)
.Apply();
// verify probe deleted (and deref from rule)
loadBalancer.Refresh();
Assert.True(loadBalancer.HttpProbes.TryGetValue(probeName1, out httpProbe));
Assert.False(loadBalancer.HttpsProbes.TryGetValue(probeName2, out httpsProbe));
Assert.Null(loadBalancer.LoadBalancingRules[ruleName2].Probe);
// add probe
loadBalancer.Update()
.DefineHttpsProbe(probeName2)
.WithRequestPath("/")
.Attach()
.Apply();
// verify probe added
loadBalancer.Refresh();
Assert.True(loadBalancer.HttpProbes.TryGetValue(probeName1, out httpProbe));
Assert.True(loadBalancer.HttpsProbes.TryGetValue(probeName2, out httpsProbe));
Assert.Empty(httpsProbe.LoadBalancingRules);
}
finally
{
try
{
azure?.ResourceGroups.BeginDeleteByName(rgName);
}
catch { }
}
}
}
