You are viewing documentation for version 1 of the AWS SDK for Ruby. Version 2 documentation can be found here.

Class: AWS::ELB::LoadBalancerCollection

Inherits:
Object
  • Object
show all
Includes:
Core::Collection::WithNextToken
Defined in:
lib/aws/elb/load_balancer_collection.rb

Instance Method Summary collapse

Methods included from Core::Collection

#each, #each_batch, #enum, #first, #in_groups_of, #page

Instance Method Details

#[](name) ⇒ LoadBalancer

Returns the load balancer with the given name. This does not make a request, just returns a reference.

Returns:

  • (LoadBalancer) —

    Returns the load balancer with the given name. This does not make a request, just returns a reference.



124
125
126
 
# File 'lib/aws/elb/load_balancer_collection.rb', line 124

def [] name
  LoadBalancer.new(name, :config => config)
end

#create(name, options = {}) ⇒ Object

Creates and returns a load balancer. A load balancer requires:

  • a unique name
  • at least one availability zone
  • at least one listener

An example that creates a load balancer in two availability zones with a single listener:

load_balancer = elb.load_balancers.create('my-load-balancer',
  :availability_zones => %w(us-west-2a us-west-2b),
  :listeners => [{
    :port => 80,
    :protocol => :http,
    :instance_port => 80,
    :instance_protocol => :http,
  }])

Parameters:

  • name (String) —

    The name of your load balancer. The name must be unique within your set of load balancers.

  • options (Hash) (defaults to: {})

Options Hash (options):

  • :availability_zones (required, Array) —

    An array of one or more availability zones. Values may be availability zone name strings, or AWS::EC2::AvailabilityZone objects.

  • :listeners (required, Array<Hash>) —

    An array of load balancer listener options: * :protocol - required - (String) Specifies the LoadBalancer transport protocol to use for routing - HTTP, HTTPS, TCP or SSL. This property cannot be modified for the life of the LoadBalancer. * :load_balancer_port - required - (Integer) Specifies the external LoadBalancer port number. This property cannot be modified for the life of the LoadBalancer. * :instance_protocol - (String) Specifies the protocol to use for routing traffic to back-end instances - HTTP, HTTPS, TCP, or SSL. This property cannot be modified for the life of the LoadBalancer. If the front-end protocol is HTTP or HTTPS, InstanceProtocol has to be at the same protocol layer, i.e., HTTP or HTTPS. Likewise, if the front-end protocol is TCP or SSL, InstanceProtocol has to be TCP or SSL. If there is another listener with the same InstancePort whose InstanceProtocol is secure, i.e., HTTPS or SSL, the listener's InstanceProtocol has to be secure, i.e., HTTPS or SSL. If there is another listener with the same InstancePort whose InstanceProtocol is HTTP or TCP, the listener's InstanceProtocol must be either HTTP or TCP. * :instance_port - required - (Integer) Specifies the TCP port on which the instance server is listening. This property cannot be modified for the life of the LoadBalancer. * :ssl_certificate_id - (String) The ARN string of the server certificate. To get the ARN of the server certificate, call the AWS Identity and Access Management UploadServerCertificate API.

  • :subnets (Array) —

    An list of VPC subets to attach the load balancer to. This can be an array of subnet ids (strings) or AWS::EC2::Subnet objects. VPC only.

  • :security_groups (Array) —

    The security groups assigned to your load balancer within your VPC. This can be an array of security group ids or AWS::EC2::SecurityGroup objects. VPC only.

  • :scheme (String) — default: 'internal' The type of a load balancer. Accepts 'internet-facing' or 'internal'. VPC only. —

    'internal' The type of a load balancer. Accepts 'internet-facing' or 'internal'. VPC only.



88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'lib/aws/elb/load_balancer_collection.rb', line 88

def create name, options = {}

  if listeners = options[:listeners]
    options[:listeners] = [listeners].flatten.map do |listener|
      format_listener_opts(listener)
    end
  end

  if zones = options[:availability_zones]
    options[:availability_zones] = [zones].flatten.map do |zone|
      zone.is_a?(EC2::AvailabilityZone) ? zone.name : zone
    end
  end

  if groups = options[:security_groups]
    options[:security_groups] = [groups].flatten.map do |group|
      group.is_a?(EC2::SecurityGroup) ? group.id : group
    end
  end

  if subnets = options[:subnets]
    options[:subnets] = [subnets].flatten.map do |subnet|
      subnet.is_a?(EC2::Subnet) ? subnet.id : subnet
    end
  end

  options[:load_balancer_name] = name.to_s

  resp = client.create_load_balancer(options)

  LoadBalancer.new(name, :dns_name => resp[:dns_name], :config => config)

end