Esempio n. 1
0
        // Create VNet for the LB
        public IEnumerable <IPublicIPAddress> EnsurePIPs(IPublicIPAddresses pips)
        {
            var creatablePips = new List <ICreatable <IPublicIPAddress> >();

            for (int i = 0; i < PipNames.Length; i++)
            {
                creatablePips.Add(pips.Define(PipNames[i])
                                  .WithRegion(Region)
                                  .WithNewResourceGroup(GroupName));
            }

            return(pips.Create(creatablePips.ToArray()));
        }
Esempio n. 2
0
        public override ILoadBalancer CreateResource(ILoadBalancers resources)
        {
            pips             = resources.Manager.PublicIPAddresses;
            availabilitySets = computeManager.AvailabilitySets;
            networks         = resources.Manager.Networks;

            var existingVMs       = loadBalancerHelper.EnsureVMs(networks, computeManager, 2);
            var existingPips      = loadBalancerHelper.EnsurePIPs(pips);
            IPublicIPAddress pip0 = resources.Manager.PublicIPAddresses.GetByResourceGroup(
                loadBalancerHelper.GroupName,
                loadBalancerHelper.PipNames[0]);

            // Create a load balancer
            var lb = resources.Define(loadBalancerHelper.LoadBalancerName)
                     .WithRegion(loadBalancerHelper.Region)
                     .WithExistingResourceGroup(loadBalancerHelper.GroupName)

                                                          // Load balancing rules
                     .DefineLoadBalancingRule("rule1")
                     .WithProtocol(TransportProtocol.Tcp) // Required
                     .FromExistingPublicIPAddress(pip0)
                     .FromFrontendPort(81)
                     .ToBackend("backend1")
                     .ToBackendPort(82)                           // Optionals
                     .WithProbe("tcpProbe1")
                     .WithIdleTimeoutInMinutes(10)
                     .WithLoadDistribution(LoadDistribution.SourceIP)
                     .Attach()

                     // Inbound NAT pools
                     .DefineInboundNatPool("natpool1")
                     .WithProtocol(TransportProtocol.Tcp)
                     .FromExistingPublicIPAddress(pip0)
                     .FromFrontendPortRange(2000, 2001)
                     .ToBackendPort(8080)
                     .Attach()

                                                // Probes
                     .DefineTcpProbe("tcpProbe1")
                     .WithPort(25)              // Required
                     .WithIntervalInSeconds(15) // Optionals
                     .WithNumberOfProbes(5)
                     .Attach()
                     .DefineHttpProbe("httpProbe1")
                     .WithRequestPath("/")              // Required
                     .WithIntervalInSeconds(13)         // Optionals
                     .WithNumberOfProbes(4)
                     .Attach()

                     // Backends
                     .DefineBackend("backend1")
                     .WithExistingVirtualMachines(new List <IHasNetworkInterfaces>(existingVMs))
                     .Attach()

                     .Create();

            // Verify frontends
            Assert.Equal(1, lb.Frontends.Count);
            Assert.Equal(1, lb.PublicFrontends.Count);
            Assert.Equal(0, lb.PrivateFrontends.Count);
            var frontend = lb.Frontends.Values.First();

            Assert.True(frontend.IsPublic);
            var publicFrontend = (ILoadBalancerPublicFrontend)frontend;

            Assert.Equal(pip0.Id, publicFrontend.PublicIPAddressId, ignoreCase: true);

            // Verify backends
            Assert.Equal(1, lb.Backends.Count);

            // Verify probes
            Assert.Equal(1, lb.HttpProbes.Count);
            Assert.True(lb.HttpProbes.ContainsKey("httpProbe1"));
            Assert.Equal(1, lb.TcpProbes.Count);
            Assert.True(lb.TcpProbes.ContainsKey("tcpProbe1"));

            // Verify rules
            Assert.Equal(1, lb.LoadBalancingRules.Count);
            Assert.True(lb.LoadBalancingRules.ContainsKey("rule1"));
            var rule = lb.LoadBalancingRules["rule1"];

            Assert.NotNull(rule.Backend);
            Assert.Equal("tcpProbe1", rule.Probe.Name, ignoreCase: true);

            // Verify inbound NAT pools
            Assert.True(lb.InboundNatPools.ContainsKey("natpool1"));
            Assert.Equal(1, lb.InboundNatPools.Count);
            var inboundNatPool = lb.InboundNatPools["natpool1"];

            Assert.Equal(2000, inboundNatPool.FrontendPortRangeStart);
            Assert.Equal(2001, inboundNatPool.FrontendPortRangeEnd);
            Assert.Equal(8080, inboundNatPool.BackendPort);

            return(lb);
        }
        public override ILoadBalancer CreateResource(ILoadBalancers resources)
        {
            pips             = resources.Manager.PublicIPAddresses;
            networks         = resources.Manager.Networks;
            availabilitySets = computeManager.AvailabilitySets;
            var existingVMs = loadBalancerHelper.EnsureVMs(networks, computeManager, 2);

            Assert.Equal(2, existingVMs.Count());
            var existingPips     = loadBalancerHelper.EnsurePIPs(pips);
            var nic1             = existingVMs.ElementAt(0).GetPrimaryNetworkInterface();
            var nic2             = existingVMs.ElementAt(1).GetPrimaryNetworkInterface();
            IPublicIPAddress pip = resources.Manager.PublicIPAddresses.GetByResourceGroup(
                loadBalancerHelper.GroupName,
                loadBalancerHelper.PipNames[0]);

            // Create a load balancer
            var lb = resources.Define(loadBalancerHelper.LoadBalancerName)
                     .WithRegion(loadBalancerHelper.Region)
                     .WithExistingResourceGroup(loadBalancerHelper.GroupName)

                                                          // Load balancing rules
                     .DefineLoadBalancingRule("rule1")
                     .WithProtocol(TransportProtocol.Tcp) // Required
                     .FromExistingPublicIPAddress(pip)
                     .FromFrontendPort(81)
                     .ToBackend("backend1")
                     .ToBackendPort(82)                           // Optionals
                     .WithProbe("tcpProbe1")
                     .WithIdleTimeoutInMinutes(10)
                     .WithLoadDistribution(LoadDistribution.SourceIP)
                     .Attach()

                     // Inbound NAT rules
                     .DefineInboundNatRule("natrule1")
                     .WithProtocol(TransportProtocol.Tcp)
                     .FromExistingPublicIPAddress(pip)        // Implicitly uses the same frontend because the PIP is the same
                     .FromFrontendPort(88)
                     .Attach()

                     // Probes
                     .DefineTcpProbe("tcpProbe1")
                     .WithPort(25)                      // Required
                     .WithIntervalInSeconds(15)         // Optionals
                     .WithNumberOfProbes(5)
                     .Attach()
                     .DefineHttpProbe("httpProbe1")
                     .WithRequestPath("/")              // Required
                     .WithIntervalInSeconds(13)         // Optionals
                     .WithNumberOfProbes(4)
                     .Attach()

                     .Create();

            string backendName  = lb.Backends.Values.First().Name;
            string frontendName = lb.Frontends.Values.First().Name;

            // Connect NICs explicitly
            nic1.Update()
            .WithExistingLoadBalancerBackend(lb, backendName)
            .WithExistingLoadBalancerInboundNatRule(lb, "natrule1")
            .Apply();
            NetworkInterfaceHelper.PrintNic(nic1);
            Assert.Equal(nic1.PrimaryIPConfiguration.ListAssociatedLoadBalancerBackends().ElementAt(0)
                         .Name, backendName, ignoreCase: true);
            Assert.Equal("natrule1", nic1.PrimaryIPConfiguration.ListAssociatedLoadBalancerInboundNatRules().ElementAt(0)
                         .Name, ignoreCase: true);

            nic2.Update()
            .WithExistingLoadBalancerBackend(lb, backendName)
            .Apply();
            NetworkInterfaceHelper.PrintNic(nic2);
            Assert.Equal(nic2.PrimaryIPConfiguration.ListAssociatedLoadBalancerBackends().ElementAt(0)
                         .Name, backendName, ignoreCase: true);

            // Verify frontends
            Assert.Single(lb.Frontends.Values);
            Assert.Single(lb.PublicFrontends.Values);
            Assert.Empty(lb.PrivateFrontends.Values);
            Assert.True(lb.Frontends.ContainsKey(frontendName));
            var frontend = lb.Frontends[frontendName];

            Assert.True(frontend.IsPublic);
            var publicFrontend = (ILoadBalancerPublicFrontend)frontend;

            Assert.Equal(pip.Id, publicFrontend.PublicIPAddressId, ignoreCase: true);

            pip.Refresh();
            Assert.Equal(pip.GetAssignedLoadBalancerFrontend().Name, frontendName, ignoreCase: true);

            // Verify backends
            Assert.True(lb.Backends.ContainsKey(backendName));
            Assert.Single(lb.Backends.Values);

            // Verify probes
            Assert.True(lb.HttpProbes.ContainsKey("httpProbe1"));
            Assert.Single(lb.HttpProbes.Values);
            Assert.True(lb.TcpProbes.ContainsKey("tcpProbe1"));
            Assert.Single(lb.TcpProbes.Values);

            // Verify rules
            Assert.Single(lb.LoadBalancingRules.Values);
            Assert.True(lb.LoadBalancingRules.ContainsKey("rule1"));
            var rule = lb.LoadBalancingRules["rule1"];

            Assert.Equal(rule.Backend.Name, backendName, ignoreCase: true);
            Assert.Equal(rule.Frontend.Name, frontendName, ignoreCase: true);
            Assert.Equal("tcpProbe1", rule.Probe.Name, ignoreCase: true);

            // Verify inbound NAT rules
            Assert.Single(lb.InboundNatRules.Values);
            Assert.True(lb.InboundNatRules.ContainsKey("natrule1"));
            var inboundNatRule = lb.InboundNatRules["natrule1"];

            Assert.Equal(inboundNatRule.Frontend.Name, frontendName, ignoreCase: true);
            Assert.Equal(88, inboundNatRule.FrontendPort);
            Assert.Equal(88, inboundNatRule.BackendPort);

            return(lb);
        }