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 = ;
             listener.InstanceProtocol = "HTTP";
             listener.LoadBalancerPort = ;
             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 = ;
                 healthCheck.Interval = ;
                 healthCheck.Target = "HTTP:80/index.html";
                 healthCheck.Timeout = ;
                 healthCheck.UnhealthyThreshold = ;
                 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

     }