AWS 之Load Balance篇

 public class CreateELB
    {
        /// <summary>
        /// 连接AWS服务器
        /// </summary>
        /// <param name="awsAccessKeyId">Access Key Id</param>
        /// <param name="awsSecretAccessKey">Secret Access Key</param>
        /// <param name="regionEndpoint">服务器区域</param>
        /// <returns></returns>
        public AmazonElasticLoadBalancingClient CreateELB(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint regionEndpoint)
        {
            AmazonElasticLoadBalancingClient client = new AmazonElasticLoadBalancingClient(awsAccessKeyId, awsSecretAccessKey, regionEndpoint);
            return client;
        }

        #region 添加负载均衡器
        /// <summary>
        /// 添加负载均衡器
        /// </summary>
        /// <param name="client">连接请求</param>
        /// <param name="LoadBalancerName">负载均衡器名称</param>
        /// <returns></returns>
        private string CreateLoadBalancer(AmazonElasticLoadBalancingClient client, string LoadBalancerName)
        {
            string DNSName = "";
            try
            {
                List<string> availabilityZonesList = GetAvailabilityZonesList();
                List<Listener> listenerList = GetListenerList();
                List<Tag> tagList = GetTagList();
                List<string> securityGroupslist = GetSecurityGroupslist();
                if (!ExistLoadBalancer(client, LoadBalancerName))
                {
                    CreateLoadBalancerRequest request = new CreateLoadBalancerRequest()
                    {
                        //可用区域
                        AvailabilityZones = availabilityZonesList,
                        //侦听器
                        Listeners = listenerList,
                        //负载平衡名称
                        LoadBalancerName = LoadBalancerName,
                        //设置负载平衡是面向 Internet ， 默认 面向Internet
                        // Scheme = "",
                        //安全组
                        SecurityGroups = securityGroupslist,
                        //子网
                        //    Subnets = list,
                        //标签
                        Tags = tagList
                    };
                    CreateLoadBalancerResponse response = client.CreateLoadBalancer(request);
                    DNSName = response.DNSName;
                    if (RegisterInstancesWithLoadBalancer(client, LoadBalancerName))
                    {
                        Console.Write("添加实例成功");
                        Console.WriteLine("");
                    }
                    if (ConfigureHealthCheck(client, LoadBalancerName))
                    {
                        Console.Write("配置运行状况检查成功");
                        Console.WriteLine("");
                    }
                }
                else
                {
                    Console.Write("名为<" + LoadBalancerName + ">负载均衡存在");
                    Console.WriteLine("");
                }
            }
            catch (Exception)
            {
                throw;
            }
            return DNSName;
        }
        #endregion
        #region 可用区域实体
        /// <summary>
        /// 可用区域实体
        /// </summary>
        /// <returns></returns>
        private List<string> GetAvailabilityZonesList()
        {
            List<string> availabilityZonesList = new List<string>();
            string availabilityZones = "ap-southeast-1a";
            availabilityZonesList.Add(availabilityZones);
            return availabilityZonesList;
        }
        #endregion
        #region 监听器实体
        /// <summary>
        /// 监听器实体
        /// </summary>
        /// <returns></returns>
        private List<Listener> GetListenerList()
        {
            List<Listener> listenerList = new List<Listener>();
            Listener listener = new Listener();
            listener.InstancePort = 80;
            listener.InstanceProtocol = "HTTP";
            listener.LoadBalancerPort = 80;
            listener.Protocol = "HTTP";
            listenerList.Add(listener);
            return listenerList;
        }
        #endregion
        #region 标签实体
        /// <summary>
        /// 标签实体
        /// </summary>
        /// <returns></returns>
        private List<Tag> GetTagList()
        {
            //添加标签
            List<Tag> tagList = new List<Tag>();

            Tag tag = new Tag();
            tag.Key = "key";
            tag.Value = "value";
            tagList.Add(tag);
            return tagList;
        }
        #endregion
        #region 安全组实体
        /// <summary>
        /// 安全组实体
        /// </summary>
        /// <returns></returns>
        private List<string> GetSecurityGroupslist()
        {
            string str = "sg-4afa562f";
            List<string> securityGroupslist = new List<string>();
            securityGroupslist.Add(str);
            return securityGroupslist;
        }
        #endregion
        #region 添加实例
        /// <summary>
        /// 添加实例
        /// </summary>
        /// <param name="client"></param>
        /// <param name="LoadBalancerName"></param>
        /// <returns></returns>
        private bool RegisterInstancesWithLoadBalancer(AmazonElasticLoadBalancingClient client, string LoadBalancerName)
        {
            bool result = false;
            try
            {
                List<Instance> instanceList = new List<Instance>();
                Instance instance = new Instance();
                instance.InstanceId = "i-18de45d5";
                instanceList.Add(instance);

                Instance instance1 = new Instance();
                instance1.InstanceId = "i-26d918e9";
                instanceList.Add(instance1);
                RegisterInstancesWithLoadBalancerRequest requestInstance = new RegisterInstancesWithLoadBalancerRequest()
                {
                    Instances = instanceList,
                    LoadBalancerName = LoadBalancerName
                };
                RegisterInstancesWithLoadBalancerResponse responseInstance = client.RegisterInstancesWithLoadBalancer(requestInstance);
                result = true;
            }
            catch (Exception)
            {
                throw;
            }
            return result;
        }
        #endregion
        #region 配置运行状况检查
        /// <summary>
        /// 配置运行状况检查
        /// </summary>
        /// <param name="client"></param>
        /// <param name="LoadBalancerName"></param>
        /// <returns></returns>
        private bool ConfigureHealthCheck(AmazonElasticLoadBalancingClient client, string LoadBalancerName)
        {
            bool result = false;
            try
            {
                HealthCheck healthCheck = new HealthCheck();
                healthCheck.HealthyThreshold = 10;
                healthCheck.Interval = 30;
                healthCheck.Target = "HTTP:80/index.html";
                healthCheck.Timeout = 5;
                healthCheck.UnhealthyThreshold = 2;
                ConfigureHealthCheckRequest requestHealth = new ConfigureHealthCheckRequest()
                {
                    HealthCheck = healthCheck,
                    LoadBalancerName = LoadBalancerName
                };
                ConfigureHealthCheckResponse responseHealth = client.ConfigureHealthCheck(requestHealth);
                result = true;
            }
            catch (Exception)
            {
                throw;
            }
            return result;
        }
        #endregion
        #region 删除负载均衡器
        /// <summary>
        /// 删除负载均衡器
        /// </summary>
        /// <param name="client"></param>
        /// <param name="LoadBalancerName"></param>
        /// <returns></returns>
        private string DeleteLoadBalancer(AmazonElasticLoadBalancingClient client, string LoadBalancerName)
        {
            string result = "";
            try
            {
                DeleteLoadBalancerRequest request = new DeleteLoadBalancerRequest()
                {
                    LoadBalancerName = LoadBalancerName
                };
                DeleteLoadBalancerResponse response = client.DeleteLoadBalancer(request);
                result = response.HttpStatusCode.ToString();
            }
            catch (Exception)
            {
                throw;
            }
            return result;
        }
        #endregion
        #region 负载均衡器是否存在
        /// <summary>
        /// 负载均衡器是否存在
        /// </summary>
        /// <param name="client"></param>
        /// <param name="LoadBalancerName"></param>
        private bool ExistLoadBalancer(AmazonElasticLoadBalancingClient client, string LoadBalancerName)
        {
            bool result = false;
            DescribeLoadBalancersResponse response = client.DescribeLoadBalancers();
            List<LoadBalancerDescription> loadBalancerDescriptionList = response.LoadBalancerDescriptions;
            foreach (LoadBalancerDescription loadBalancerDescription in loadBalancerDescriptionList)
            {
                if (loadBalancerDescription.LoadBalancerName == LoadBalancerName)
                {
                    result = true;
                }
            }
            return result;
        }
        #endregion
        #region 得到负载均衡器DNS名称
        /// <summary>
        /// 得到负载均衡器DNS名称
        /// </summary>
        /// <param name="client"></param>
        /// <param name="LoadBalancerName"></param>
        /// <returns></returns>
        private string GetLoadBalancerDescription(AmazonElasticLoadBalancingClient client, string LoadBalancerName)
        {
            string DNSName = "";
            DescribeLoadBalancersResponse response = client.DescribeLoadBalancers();
            List<LoadBalancerDescription> loadBalancerDescriptionList = response.LoadBalancerDescriptions;
            foreach (LoadBalancerDescription loadBalancerDescription in loadBalancerDescriptionList)
            {
                if (loadBalancerDescription.LoadBalancerName == LoadBalancerName)
                {
                    DNSName = loadBalancerDescription.DNSName;
                }
            }
            return DNSName;
        }
        #endregion

    }