public override ILoadBalancer UpdateResource(ILoadBalancer resource)
{
ILoadBalancerBackend backend = resource.Backends.Values.First();
ILoadBalancerInboundNatRule natRule = resource.InboundNatRules.Values.First();
ILoadBalancerPublicFrontend publicFrontend = (ILoadBalancerPublicFrontend)natRule.Frontend;
IPublicIPAddress pip = resource.Manager.PublicIPAddresses.Define(loadBalancerHelper.PipNames[1])
.WithRegion(loadBalancerHelper.Region)
.WithExistingResourceGroup(loadBalancerHelper.GroupName)
.WithLeafDomainLabel(loadBalancerHelper.PipNames[1])
.Create();
resource = resource.Update()
.UpdatePublicFrontend(publicFrontend.Name)
.WithExistingPublicIPAddress(pip)
.Parent()
.DefineBackend("backend2")
.Attach()
.WithoutBackend(backend.Name)
.WithoutInboundNatRule("natrule1")
.WithTag("tag1", "value1")
.WithTag("tag2", "value2")
.Apply();
Assert.True(resource.Tags.ContainsKey("tag1"));
// Verify frontends
Assert.Equal(1, resource.Frontends.Count);
Assert.Equal(1, resource.PublicFrontends.Count);
Assert.Equal(0, resource.PrivateFrontends.Count);
Assert.True(resource.Frontends.ContainsKey(publicFrontend.Name));
var frontend = resource.Frontends[publicFrontend.Name];
Assert.True(frontend.IsPublic);
publicFrontend = (ILoadBalancerPublicFrontend)frontend;
Assert.Equal(pip.Id, publicFrontend.PublicIPAddressId, ignoreCase: true);
Assert.Equal(0, publicFrontend.LoadBalancingRules.Count);
// Verify probes
Assert.Equal(0, resource.TcpProbes.Count);
Assert.Equal(0, resource.HttpProbes.Count);
// Verify backends
Assert.True(resource.Backends.ContainsKey("backend2"));
Assert.True(!resource.Backends.ContainsKey(backend.Name));
// Verify NAT rules
Assert.Equal(0, resource.InboundNatRules.Count);
// Verify load balancing rules
Assert.Equal(0, resource.LoadBalancingRules.Count);
return(resource);
}
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);
}
