class AWS::ELB::LoadBalancer

A collection that help maanage the availability zones for this load balancer.

@example enable an availability zone

load_balancer.availability_zones.enable('us-east-1b')

@example disable an availability zone

load_balancer.availability_zones.disable('us-east-1b')

@example list enabled availability zoens

load_balancer.availability_zones.each do |zone|
  puts zone.name
end

@return [AvailabilityZoneCollection] Returns a collection that

represents this load balancer's availability zones.  You can
use this collection to enable and disable availability zones.

# File lib/aws/elb/load_balancer.rb, line 97
def availability_zones
  AvailabilityZoneCollection.new(self)
end

@return [BackendServerPolicyCollection]

# File lib/aws/elb/load_balancer.rb, line 117
def backend_server_policies
  BackendServerPolicyCollection.new(self)
end

Updates the configuration that drives the instance health checks.

You only need to pass the options you want to change. You can call {health_check_configuration} if you want to see what the current configuration values are.

@param [Hash] options

@option options [Integer] :healthy_threshold Specifies the number of

consecutive health probe successes required before moving the 
instance to the Healthy state.

@option options [Integer] :unhealthy_threshold Specifies the number

of consecutive health probe failures required before moving the 
instance to the Unhealthy state.

@option options [Integer] :interval Specifies the approximate

interval, in seconds, between health checks of an individual 
instance.

@option options [Integer] :timeout Specifies the amount of time, in

seconds, during which no response means a failed health probe.  
This value must be less than the +:interval+ value.

@option options [String] :target Specifies the instance being checked.

This option should be formatted like: "TCP:80"

* The protocol is either TCP, HTTP, HTTPS, or SSL. 
* The range of valid ports is one (1) through 65535.

TCP is the default, specified as a TCP: port pair, for example 
"TCP:5000". In this case a healthcheck simply attempts to open a 
TCP connection to the instance on the specified port. Failure to 
connect within the configured timeout is considered unhealthy.

SSL is also specified as SSL: port pair, for example, SSL:5000.
For HTTP or HTTPS protocol, the situation is different. You have 
to include a ping path in the string. HTTP is specified as a 
HTTP:port;/;PathToPing; grouping, for example 
"HTTP:80/weather/us/wa/seattle". In this case, a HTTP GET request 
is issued to the instance on the given port and path. Any answer 
other than "200 OK" within the timeout period is considered 
unhealthy.

The total length of the HTTP ping target needs to be 1024 16-bit 
Unicode characters or less.

# File lib/aws/elb/load_balancer.rb, line 169
def configure_health_check options = {}

  new_config = health_check_configuration.merge(options)

  response = client.configure_health_check(
    :load_balancer_name => name,
    :health_check => new_config)

  new_config

end

Deletes the load balancer. @return [nil]

# File lib/aws/elb/load_balancer.rb, line 237
def delete
  client.delete_load_balancer(:load_balancer_name => name)
  nil
end

@return [Boolean] Returns true if the load balancer exists.

# File lib/aws/elb/load_balancer.rb, line 228
def exists?
  client.describe_load_balancers(:load_balancer_names => [name])
  true
rescue Errors::LoadBalancerNotFound
  false
end

Returns a hash of the various health probes conducted on the load balancer instances. The following entries are returned:

* +:healthy_threshold+
* +:unhealthy_threshold+
* +:interval+
* +:target+
* +:timeout+

See {configure_health_check} for more details on what each of the configuration values mean.

@return [Hash]

# File lib/aws/elb/load_balancer.rb, line 195
def health_check_configuration
  cfg = health_check_description
  {
    :healthy_threshold => cfg.healthy_threshold,
    :unhealthy_threshold => cfg.unhealthy_threshold,
    :interval => cfg.interval,
    :target => cfg.target,
    :timeout => cfg.timeout,
  }
end

@return [InstanceCollection]

# File lib/aws/elb/load_balancer.rb, line 112
def instances
  InstanceCollection.new(self)
end

@return [ListenerCollection]

# File lib/aws/elb/load_balancer.rb, line 102
def listeners
  ListenerCollection.new(self)
end

@return [PolicyCollection]

# File lib/aws/elb/load_balancer.rb, line 107
def policies
  LoadBalancerPolicyCollection.new(self)
end

Generally you don’t need to call this method, rather you can just pass the load balancer as a source to the various authorize and revoke methods of {SecurityGroup}:

security_group.authorize_ingress(load_balancer)

security_group.revoke_ingress(load_balancer)

@return [Hash] Returns a hash that can be passed to the following

{SecurityGroup} methods as a source:

* {SecurityGroup#authorize_ingress}
* {SecurityGroup#authorize_egress}

# File lib/aws/elb/load_balancer.rb, line 220
def source_security_group
  { 
    :group_name => security_group_description.group_name,
    :user_id => security_group_description.owner_alias,
  }
end