Parent

Files

RightAws::ElbInterface

RightAWS::ElbInterface -- RightScale Amazon Elastic Load Balancer interface

The RightAws::ElbInterface class provides a complete interface to Amazon's Elastic Load Balancer service.

For explanations of the semantics of each call, please refer to Amazon's documentation at docs.amazonwebservices.com/ElasticLoadBalancing/latest/DeveloperGuide/

Create an interface handle:

elb = RightAws::ElbInterface.new(aws_access_key_id, aws_security_access_key)

Create an new load balancer:

elb.create_load_balancer( 'test-kd1',
                         ['us-east-1a', 'us-east-1b'],
                         [ { :protocol => :http, :load_balancer_port => 80,  :instance_port => 80 },
                                     { :protocol => :tcp,  :load_balancer_port => 443, :instance_port => 443 } ])

Configure its health checking:

elb.configure_health_check( 'test-kd1',
                            { :healthy_threshold => 9,
                              :unhealthy_threshold => 3,
                              :target => "TCP:433",
                              :timeout => 6,
                              :interval => 31}

Register instances with the balancer:

elb.register_instances_with_load_balancer('test-kd1', 'i-8b8bcbe2', 'i-bf8bcbd6') #=> ["i-8b8bcbe2", "i-bf8bcbd6"]

Add new availability zones:

elb.enable_availability_zones_for_load_balancer("test-kd1", "us-east-1c")

Public Class Methods

bench_service() click to toggle source
# File lib/elb/right_elb_interface.rb, line 77
def self.bench_service
  @@bench.service
end
bench_xml() click to toggle source
# File lib/elb/right_elb_interface.rb, line 74
def self.bench_xml
  @@bench.xml
end
new(aws_access_key_id=nil, aws_secret_access_key=nil, params={}) click to toggle source

Create a new handle to an ELB account. All handles share the same per process or per thread HTTP connection to Amazon ELB. Each handle is for a specific account. The params have the following options:

  • :endpoint_url a fully qualified url to Amazon API endpoint (this overwrites: :server, :port, :service, :protocol). Example: 'elasticloadbalancing.amazonaws.com'

  • :server: ELB service host, default: DEFAULT_HOST

  • :port: ELB service port, default: DEFAULT_PORT

  • :protocol: 'http' or 'https', default: DEFAULT_PROTOCOL

  • :logger: for log messages, default: RAILS_DEFAULT_LOGGER else STDOUT

  • :signature_version: The signature version : '0','1' or '2'(default)

  • :cache: true/false(default): caching works for: describe_load_balancers

# File lib/elb/right_elb_interface.rb, line 92
def initialize(aws_access_key_id=nil, aws_secret_access_key=nil, params={})
  init({ :name                => 'ELB',
         :default_host        => ENV['ELB_URL'] ? URI.parse(ENV['ELB_URL']).host   : DEFAULT_HOST,
         :default_port        => ENV['ELB_URL'] ? URI.parse(ENV['ELB_URL']).port   : DEFAULT_PORT,
         :default_service     => ENV['ELB_URL'] ? URI.parse(ENV['ELB_URL']).path   : DEFAULT_PATH,
         :default_protocol    => ENV['ELB_URL'] ? URI.parse(ENV['ELB_URL']).scheme : DEFAULT_PROTOCOL,
         :default_api_version => ENV['ELB_API_VERSION'] || API_VERSION },
       aws_access_key_id    || ENV['AWS_ACCESS_KEY_ID'] ,
       aws_secret_access_key|| ENV['AWS_SECRET_ACCESS_KEY'],
       params)
end

Public Instance Methods

configure_health_check(load_balancer_name, health_check) click to toggle source

Define an application healthcheck for the instances. Returns an updated health check configuration for the load balancer.

hc = elb.configure_health_check( 'test-kd1',
                                 { :healthy_threshold => 9,
                                   :unhealthy_threshold => 3,
                                   :target => "TCP:433",
                                   :timeout => 6,
                                   :interval => 31}
pp hc #=> { :target=>"TCP:433", :timeout=>6, :interval=>31, :healthy_threshold=>9, :unhealthy_threshold=>3 }
# File lib/elb/right_elb_interface.rb, line 282
def configure_health_check(load_balancer_name, health_check)
  request_hash = { 'LoadBalancerName' => load_balancer_name }
  health_check.each{ |key, value| request_hash["HealthCheck.#{key.to_s.right_camelize}"] = value }
  link = generate_request("ConfigureHealthCheck", request_hash)
  request_info(link, HealthCheckParser.new(:logger => @logger))
end
create_load_balancer(load_balancer_name, availability_zones=[], listeners=[]) click to toggle source

Create new load balancer. Returns a new load balancer DNS name.

Listener options: :protocol, :load_balancer_port, :instance_port and :ssl_certificate_id Protocols: :tcp, :http, :https or :ssl

elb.create_load_balancer( 'test-kd1',
                          ['us-east-1a', 'us-east-1b'],
                          [ { :protocol => :http,  :load_balancer_port => 80,  :instance_port => 80 },
                            { :protocol => :https, :load_balancer_port => 443, :instance_port => 443,
                              :ssl_certificate_id => 'arn:aws:iam::123456789012:user/division_abc/subdivision_xyz/Bob' } ])
                              #=> "test-kd1-1519253964.us-east-1.elb.amazonaws.com"
# File lib/elb/right_elb_interface.rb, line 186
def create_load_balancer(load_balancer_name, availability_zones=[], listeners=[])
  request_hash = { 'LoadBalancerName' => load_balancer_name }
  # merge zones
  request_hash.merge!( amazonize_list("AvailabilityZones.member", availability_zones) )
  # merge listeners
  if listeners.right_blank?
    listeners = { :protocol           => :http,
                  :load_balancer_port => 80,
                  :instance_port      => 80 }
  end
  request_hash = merge_listeners_into_request_hash(request_hash, listeners)
  link = generate_request("CreateLoadBalancer", request_hash)
  request_info(link, CreateLoadBalancerParser.new(:logger => @logger))
end
create_load_balancer_listeners(load_balancer_name, listeners) click to toggle source

Creates one or more new listeners on a LoadBalancer for the specified port. If a listener with the given port does not already exist, it will be created; otherwise, the properties of the new listener must match the the properties of the existing listener.

Listener options: :protocol, :load_balancer_port, :instance_port and :ssl_certificate_id Protocols: :tcp, :http, :https or :ssl

elb.create_load_balancer_listeners( 'test-kd1',
                                    [ { :protocol => :http,  :load_balancer_port => 80,  :instance_port => 80 },
                                      { :protocol => :https, :load_balancer_port => 443, :instance_port => 443,
                                        :ssl_certificate_id => 'arn:aws:iam::123456789012:user/division_abc/subdivision_xyz/Bob' } ]) #=> true
# File lib/elb/right_elb_interface.rb, line 226
def create_load_balancer_listeners(load_balancer_name, listeners)
  request_hash = { 'LoadBalancerName' => load_balancer_name }
  request_hash = merge_listeners_into_request_hash(request_hash, listeners)
  link = generate_request("CreateLoadBalancerListeners", request_hash)
  request_info(link, RightHttp2xxParser.new(:logger => @logger))
end
delete_load_balancer(load_balancer_name) click to toggle source

Delete load balancer. Returns true on success.

elb.delete_load_balancer('test-kd1') #=> true

Amazon: Because this API has been designed to be idempotent, even if the LoadBalancer does not exist or has been deleted, DeleteLoadBalancer still returns a success.

# File lib/elb/right_elb_interface.rb, line 209
def delete_load_balancer(load_balancer_name)
  link = generate_request("DeleteLoadBalancer", 'LoadBalancerName' => load_balancer_name)
  request_info(link, DeleteLoadBalancerParser.new(:logger => @logger))
end
delete_load_balancer_listeners(load_balancer_name, *load_balancer_ports) click to toggle source

Removes listeners from the load balancer for the specified port number.

elb.delete_load_balancer_listeners( 'kd_test', 80, 443) #=> true
# File lib/elb/right_elb_interface.rb, line 237
def delete_load_balancer_listeners(load_balancer_name, *load_balancer_ports)
  load_balancer_ports.flatten!
  request_hash = { 'LoadBalancerName' => load_balancer_name }
  request_hash.merge!( amazonize_list("LoadBalancerPorts.member", load_balancer_ports ) )
  link = generate_request("DeleteLoadBalancerListeners", request_hash )
  request_info(link, DeleteLoadBalancerParser.new(:logger => @logger))
end
delete_load_balancer_policy(load_balancer_name, policy_name) click to toggle source

Deletes a policy from the load balancer. The specified policy must not be enabled for any listeners.

elb.delete_load_balancer_policy('my-load-balancer', 'MyLoadBalancerPolicy') #=> true
# File lib/elb/right_elb_interface.rb, line 394
def delete_load_balancer_policy(load_balancer_name, policy_name)
  request_hash = { 'LoadBalancerName'        => load_balancer_name,
                   'PolicyName'              => policy_name }
  link = generate_request("DeleteLoadBalancerPolicy", request_hash)
  request_info(link, RightHttp2xxParser.new(:logger => @logger))
end
deregister_instances_with_load_balancer(load_balancer_name, *instances) click to toggle source

Remove instance(s) from the load balancer. Returns an updated list of instances for the load balancer.

elb.deregister_instances_with_load_balancer('test-kd1', 'i-8b8bcbe2') #=> ["i-bf8bcbd6"]
# File lib/elb/right_elb_interface.rb, line 332
def deregister_instances_with_load_balancer(load_balancer_name, *instances)
  instances.flatten!
  request_hash = amazonize_list("Instances.member.?.InstanceId", instances)
  request_hash.merge!( 'LoadBalancerName' => load_balancer_name )
  link = generate_request("DeregisterInstancesFromLoadBalancer", request_hash)
  request_info(link, InstancesWithLoadBalancerParser.new(:logger => @logger))
end
describe_instance_health(load_balancer_name, *instances) click to toggle source

Describe the current state of the instances of the specified load balancer. Returns a list of the instances.

elb.describe_instance_health('test-kd1', 'i-8b8bcbe2', 'i-bf8bcbd6') #=>
    [ { :description => "Instance registration is still in progress",
        :reason_code => "ELB",
        :instance_id => "i-8b8bcbe2",
        :state       => "OutOfService" },
      { :description => "Instance has failed at least the UnhealthyThreshold number of health checks consecutively.",
        :reason_code => "Instance",
        :instance_id => "i-bf8bcbd6",
        :state       => "OutOfService" } ]
# File lib/elb/right_elb_interface.rb, line 306
def describe_instance_health(load_balancer_name, *instances)
  instances.flatten!
  request_hash = amazonize_list("Instances.member.?.InstanceId", instances)
  request_hash.merge!( 'LoadBalancerName' => load_balancer_name )
  link = generate_request("DescribeInstanceHealth", request_hash)
  request_info(link, DescribeInstanceHealthParser.new(:logger => @logger))
end
describe_load_balancers(*load_balancers) click to toggle source
# File lib/elb/right_elb_interface.rb, line 166
def describe_load_balancers(*load_balancers)
  load_balancers = load_balancers.flatten.compact
  request_hash = amazonize_list("LoadBalancerNames.member", load_balancers)
  link = generate_request("DescribeLoadBalancers", request_hash)
  request_cache_or_info(:describe_load_balancers, link,  DescribeLoadBalancersParser, @@bench, load_balancers.right_blank?)
end
disable_availability_zones_for_load_balancer(load_balancer_name, *availability_zones) click to toggle source

Remove one or more zones from a load balancer. Returns a list of updated availability zones for the load balancer.

elb.disable_availability_zones_for_load_balancer("test-kd1", "us-east-1c") #=> ["us-east-1a"]
# File lib/elb/right_elb_interface.rb, line 263
def disable_availability_zones_for_load_balancer(load_balancer_name, *availability_zones)
  availability_zones.flatten!
  request_hash = amazonize_list("AvailabilityZones.member", availability_zones)
  request_hash.merge!( 'LoadBalancerName' => load_balancer_name )
  link = generate_request("DisableAvailabilityZonesForLoadBalancer", request_hash)
  request_info(link, AvailabilityZonesForLoadBalancerParser.new(:logger => @logger))
end
enable_availability_zones_for_load_balancer(load_balancer_name, *availability_zones) click to toggle source

Add one or more zones to a load balancer. Returns a list of updated availability zones for the load balancer.

elb.enable_availability_zones_for_load_balancer("test-kd1", "us-east-1c") #=> ["us-east-1a", "us-east-1c"]
# File lib/elb/right_elb_interface.rb, line 250
def enable_availability_zones_for_load_balancer(load_balancer_name, *availability_zones)
  availability_zones.flatten!
  request_hash = amazonize_list("AvailabilityZones.member", availability_zones)
  request_hash.merge!( 'LoadBalancerName' => load_balancer_name )
  link = generate_request("EnableAvailabilityZonesForLoadBalancer", request_hash)
  request_info(link, AvailabilityZonesForLoadBalancerParser.new(:logger => @logger))
end
register_instances_with_load_balancer(load_balancer_name, *instances) click to toggle source

Add new instance(s) to the load balancer. Returns an updated list of instances for the load balancer.

elb.register_instances_with_load_balancer('test-kd1', 'i-8b8bcbe2', 'i-bf8bcbd6') #=> ["i-8b8bcbe2", "i-bf8bcbd6"]
# File lib/elb/right_elb_interface.rb, line 319
def register_instances_with_load_balancer(load_balancer_name, *instances)
  instances.flatten!
  request_hash = amazonize_list("Instances.member.?.InstanceId", instances)
  request_hash.merge!( 'LoadBalancerName' => load_balancer_name )
  link = generate_request("RegisterInstancesWithLoadBalancer", request_hash)
  request_info(link, InstancesWithLoadBalancerParser.new(:logger => @logger))
end
set_load_balancer_listener_ssl_certificate(load_balancer_name, load_balancer_port, ssl_sertificate_id) click to toggle source
# File lib/elb/right_elb_interface.rb, line 401
def set_load_balancer_listener_ssl_certificate(load_balancer_name, load_balancer_port, ssl_sertificate_id)
  request_hash = { 'LoadBalancerName' => load_balancer_name,
                   'LoadBalancerPort' => load_balancer_port,
                   'SSLCertificateId' => ssl_sertificate_id }
  link = generate_request("SetLoadBalancerListenerSSLCertificate", request_hash)
  request_info(link, RightHttp2xxParser.new(:logger => @logger))
end
set_load_balancer_policies_of_listener(load_balancer_name, load_balancer_port, *policy_names) click to toggle source

Associates, updates, or disables a policy with a listener on the load balancer. Only zero(0) or one(1) policy can be associated with a listener.

elb.set_load_balancer_policies_of_listener('my-load-balancer', 80, 'MyLoadBalancerPolicy') #=> true
# File lib/elb/right_elb_interface.rb, line 377
def set_load_balancer_policies_of_listener(load_balancer_name, load_balancer_port, *policy_names)
  policy_names.flatten!
  request_hash = { 'LoadBalancerName' => load_balancer_name,
                   'LoadBalancerPort' => load_balancer_port }
  if policy_names.right_blank?
    request_hash['PolicyNames'] = ''
  else
    request_hash.merge!(amazonize_list('PolicyNames.member', policy_names))
  end
  link = generate_request("SetLoadBalancerPoliciesOfListener", request_hash)
  request_info(link, RightHttp2xxParser.new(:logger => @logger))
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.