Parent

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")

Constants

API_VERSION

Amazon ELB API version being used

DEFAULT_HOST
DEFAULT_PATH
DEFAULT_PORT
DEFAULT_PROTOCOL

Public Class Methods

bench_service() click to toggle source
# File lib/elb/right_elb_interface.rb, line 75
def self.bench_service
  @@bench.service
end
bench_xml() click to toggle source
# File lib/elb/right_elb_interface.rb, line 72
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

  • :multi_thread: true=HTTP connection per thread, false=per process

  • :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 91
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 252
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.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.

lb = 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 } ])
  puts lb #=> "test-kd1-1519253964.us-east-1.elb.amazonaws.com"
# File lib/elb/right_elb_interface.rb, line 181
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.blank?
    listeners = { :protocol           => :http,
                  :load_balancer_port => 80,
                  :instance_port      => 80 }
  end
  listeners = [listeners] unless listeners.is_a?(Array)
  request_hash.merge!( amazonize_list( ['Listeners.member.?.Protocol',
                                        'Listeners.member.?.LoadBalancerPort',
                                        'Listeners.member.?.InstancePort'],
                                         listeners.map{|i| [ (i[:protocol] || 'HTTP').to_s.upcase,
                                                             (i[:load_balancer_port] || 80),
                                                             (i[:instance_port] || 80) ] } ) )
  link = generate_request("CreateLoadBalancer", request_hash)
  request_info(link, CreateLoadBalancerParser.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 210
def delete_load_balancer(load_balancer_name)
  link = generate_request("DeleteLoadBalancer", 'LoadBalancerName' => load_balancer_name)
  request_info(link, DeleteLoadBalancerParser.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 302
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 276
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 165
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.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 233
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 220
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 289
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_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 347
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 }
  request_hash.merge!(amazonize_list('PolicyNames.member', policy_names))
  link = generate_request("SetLoadBalancerPoliciesOfListener", request_hash)
  request_info(link, RightHttp2xxParser.new(:logger => @logger))
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.