Class AWS::ELB::LoadBalancer
In: lib/aws/elb/load_balancer.rb
Parent: Core::Resource

@attr_reader [String] name The name of the load balancer.

@attr_reader [Array<String>] availability_zone_names Return the names of

  the availability zones this load balancer routes traffic to.

@attr_reader [String] canonical_hosted_zone_name Provides the name of

  the Amazon Route 53 hosted zone that is associated with the load
  balancer.  For more information: {http://docs.amazonwebservices.com/ElasticLoadBalancing/latest/DeveloperGuide/index.html?using-domain-names-with-elb.html}.

@attr_reader [String] canonical_hosted_zone_name_id Provides the ID of

  the Amazon Route 53 hosted zone name that is associated with the
  load balancer.  For more information: {http://docs.amazonwebservices.com/ElasticLoadBalancing/latest/DeveloperGuide/index.html?using-domain-names-with-elb.html}.

@attr_reader [String] dns_name Specifies the external DNS name

  associated with this load balancer.

Methods

Public Class methods

Public Instance methods

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.

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.

Deletes the load balancer. @return [nil]

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

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]

@return [PolicyCollection]

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 {EC2::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

  {EC2::SecurityGroup} methods as a source:

  * {EC2::SecurityGroup#authorize_ingress}
  * {EC2::SecurityGroup#authorize_egress}

Protected Instance methods

[Validate]