Class: Fog::AWS::ELB::Real

Inherits:
Object
  • Object
show all
Defined in:
lib/fog/aws/elb.rb,
lib/fog/aws/requests/elb/describe_load_balancers.rb,
lib/fog/aws/requests/elb/describe_instance_health.rb,
lib/fog/aws/requests/elb/register_instances_with_load_balancer.rb,
lib/fog/aws/requests/elb/deregister_instances_from_load_balancer.rb,
lib/fog/aws/requests/elb/enable_availability_zones_for_load_balancer.rb,
lib/fog/aws/requests/elb/disable_availability_zones_for_load_balancer.rb

Instance Method Summary collapse

Constructor Details

#initialize(options = {}) ⇒ Real

Initialize connection to ELB

Notes

options parameter must include values for :aws_access_key_id and :aws_secret_access_key in order to create a connection

Examples

elb = ELB.new(
 :aws_access_key_id => your_aws_access_key_id,
 :aws_secret_access_key => your_aws_secret_access_key
)

Parameters

  • options<~Hash> - config arguments for connection. Defaults to {}.

    • region<~String> - optional region to use, in [‘eu-west-1’, ‘us-east-1’, ‘us-west-1’i, ‘ap-southeast-1’]

Returns

  • ELB object with connection to AWS.



61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
# File 'lib/fog/aws/elb.rb', line 61

def initialize(options={})
  @aws_access_key_id      = options[:aws_access_key_id]
  @aws_secret_access_key  = options[:aws_secret_access_key]
  @hmac = HMAC::SHA256.new(@aws_secret_access_key)
  @host = options[:host] || case options[:region]
  when 'ap-southeast-1'
    'elasticloadbalancing.ap-southeast-1.amazonaws.com'
  when 'eu-west-1'
    'elasticloadbalancing.eu-west-1.amazonaws.com'
  when 'us-east-1'
    'elasticloadbalancing.us-east-1.amazonaws.com'
  when 'us-west-1'
    'elasticloadbalancing.us-west-1.amazonaws.com'
  else
    'elasticloadbalancing.amazonaws.com'
  end
  @port       = options[:port]      || 443
  @scheme     = options[:scheme]    || 'https'
end

Instance Method Details

#deregister_instances_from_load_balancer(instance_ids, lb_name) ⇒ Object Also known as: deregister_instances

Deregister an instance from an existing ELB

Parameters

  • instance_ids<~Array> - List of instance IDs to remove from ELB

  • lb_name<~String> - Load balancer to remove instances from

Returns

  • response<~Excon::Response>:

    • body<~Hash>:

      • ‘ResponseMetadata’<~Hash>:

        • ‘RequestId’<~String> - Id of request

      • ‘DeregisterInstancesFromLoadBalancerResult’<~Hash>:

        • ‘Instances’<~Array> - array of hashes describing instances currently enabled

          • ‘InstanceId’<~String>



20
21
22
23
24
25
26
27
 
# File 'lib/fog/aws/requests/elb/deregister_instances_from_load_balancer.rb', line 20

def deregister_instances_from_load_balancer(instance_ids, lb_name)
  params = ELB.indexed_param('Instances.member.%.InstanceId', [*instance_ids], 1)
  request({
    'Action'           => 'DeregisterInstancesFromLoadBalancer',
    'LoadBalancerName' => lb_name,
    :parser            => Fog::Parsers::AWS::ELB::DeregisterInstancesFromLoadBalancer.new
  }.merge!(params))
end

#describe_instance_health(lb_name, instance_ids = []) ⇒ Object

Get health status for one or more instances on an existing ELB

Parameters

  • lb_name<~String> - Load balancer to check instances health on

  • instance_ids<~Array> - Optional list of instance IDs to check

Returns

  • response<~Excon::Response>:

    • body<~Hash>:

      • ‘ResponseMetadata’<~Hash>:

        • ‘RequestId’<~String> - Id of request

      • ‘DescribeInstanceHealthResult’<~Hash>:

        • ‘InstanceStates’<~Array> - array of hashes describing instance health

          • ‘Description’<~String>

          • ‘State’<~String>

          • ‘InstanceId’<~String>

          • ‘ReasonCode’<~String>



23
24
25
26
27
28
29
30
 
# File 'lib/fog/aws/requests/elb/describe_instance_health.rb', line 23

def describe_instance_health(lb_name, instance_ids = [])
  params = ELB.indexed_param('Instances.member.%.InstanceId', [*instance_ids], 1)
  request({
    'Action'           => 'DescribeInstanceHealth',
    'LoadBalancerName' => lb_name,
    :parser            => Fog::Parsers::AWS::ELB::DescribeInstanceHealth.new
  }.merge!(params))
end

#describe_load_balancers(lb_name = []) ⇒ Object

Describe all or specified load balancers

Parameters

  • lb_name<~Array> - List of load balancer names to describe, defaults to all

Returns

  • response<~Excon::Response>:

    • body<~Hash>:

      • ‘ResponseMetadata’<~Hash>:

        • ‘RequestId’<~String> - Id of request

      • ‘DescribeLoadBalancersResult’<~Hash>:

        • ‘LoadBalancerDescriptions’<~Array>

          • ‘LoadBalancerName’<~String> - name of load balancer

          • ‘DNSName’<~String> - external DNS name of load balancer

          • ‘CreatedTime’<~Time> - time load balancer was created

          • ‘ListenerDescriptions’<~Array>

            • ‘PolicyNames’<~Array> - list of policies enabled

            • ‘Listener’<~Hash>:

              • ‘InstancePort’<~Integer> - port on instance that requests are sent to

              • ‘Protocol’<~String> - transport protocol used for routing in [TCP, HTTP]

              • ‘LoadBalancerPort’<~Integer> - port that load balancer listens on for requests

          • ‘HealthCheck’<~Hash>:

            • ‘HealthyThreshold’<~Integer> - number of consecutive health probe successes required before moving the instance to the Healthy state

            • ‘Timeout’<~Integer> - number of seconds after which no response means a failed health probe

            • ‘Interval’<~Integer> - interval (in seconds) between health checks of an individual instance

            • ‘UnhealthyThreshold’<~Integer> - number of consecutive health probe failures that move the instance to the unhealthy state

            • ‘Target’<~String> - string describing protocol type, port and URL to check

          • ‘Policies’<~Hash>:

            • ‘LBCookieStickinessPolicies’<~Array> - list of Load Balancer Generated Cookie Stickiness policies for the LoadBalancer

            • ‘AppCookieStickinessPolicies’<~Array> - list of Application Generated Cookie Stickiness policies for the LoadBalancer

          • ‘AvailabilityZones’<~Array> - list of availability zones covered by this load balancer

          • ‘Instances’<~Array> - list of instances that the load balancer balances between



38
39
40
41
42
43
44
 
# File 'lib/fog/aws/requests/elb/describe_load_balancers.rb', line 38

def describe_load_balancers(lb_name = [])
  params = ELB.indexed_param('LoadBalancerNames.member', [*lb_name], 1)
  request({
    'Action'  => 'DescribeLoadBalancers',
    :parser   => Fog::Parsers::AWS::ELB::DescribeLoadBalancers.new
  }.merge!(params))
end

#disable_availability_zones_for_load_balancer(availability_zones, lb_name) ⇒ Object Also known as: disable_zones

Disable an availability zone for an existing ELB

Parameters

  • availability_zones<~Array> - List of availability zones to disable on ELB

  • lb_name<~String> - Load balancer to disable availability zones on

Returns

  • response<~Excon::Response>:

    • body<~Hash>:

      • ‘ResponseMetadata’<~Hash>:

        • ‘RequestId’<~String> - Id of request

      • ‘DisableAvailabilityZonesForLoadBalancerResult’<~Hash>:

        • ‘AvailabilityZones’<~Array> - array of strings describing instances currently enabled



19
20
21
22
23
24
25
26
 
# File 'lib/fog/aws/requests/elb/disable_availability_zones_for_load_balancer.rb', line 19

def disable_availability_zones_for_load_balancer(availability_zones, lb_name)
  params = ELB.indexed_param('AvailabilityZones.member', [*availability_zones], 1)
  request({
    'Action'           => 'DisableAvailabilityZonesForLoadBalancer',
    'LoadBalancerName' => lb_name,
    :parser            => Fog::Parsers::AWS::ELB::DisableAvailabilityZonesForLoadBalancer.new
  }.merge!(params))
end

#enable_availability_zones_for_load_balancer(availability_zones, lb_name) ⇒ Object Also known as: enable_zones

Enable an availability zone for an existing ELB

Parameters

  • availability_zones<~Array> - List of availability zones to enable on ELB

  • lb_name<~String> - Load balancer to enable availability zones on

Returns

  • response<~Excon::Response>:

    • body<~Hash>:

      • ‘ResponseMetadata’<~Hash>:

        • ‘RequestId’<~String> - Id of request

      • ‘EnableAvailabilityZonesForLoadBalancerResult’<~Hash>:

        • ‘AvailabilityZones’<~Array> - array of strings describing instances currently enabled



19
20
21
22
23
24
25
26
 
# File 'lib/fog/aws/requests/elb/enable_availability_zones_for_load_balancer.rb', line 19

def enable_availability_zones_for_load_balancer(availability_zones, lb_name)
  params = ELB.indexed_param('AvailabilityZones.member', [*availability_zones], 1)
  request({
    'Action'           => 'EnableAvailabilityZonesForLoadBalancer',
    'LoadBalancerName' => lb_name,
    :parser            => Fog::Parsers::AWS::ELB::EnableAvailabilityZonesForLoadBalancer.new
  }.merge!(params))
end

#register_instances_with_load_balancer(instance_ids, lb_name) ⇒ Object Also known as: register_instances

Register an instance with an existing ELB

Parameters

  • instance_ids<~Array> - List of instance IDs to associate with ELB

  • lb_name<~String> - Load balancer to assign instances to

Returns

  • response<~Excon::Response>:

    • body<~Hash>:

      • ‘ResponseMetadata’<~Hash>:

        • ‘RequestId’<~String> - Id of request

      • ‘RegisterInstancesWithLoadBalancerResult’<~Hash>:

        • ‘Instances’<~Array> - array of hashes describing instances currently enabled

          • ‘InstanceId’<~String>



20
21
22
23
24
25
26
27
 
# File 'lib/fog/aws/requests/elb/register_instances_with_load_balancer.rb', line 20

def register_instances_with_load_balancer(instance_ids, lb_name)
  params = ELB.indexed_param('Instances.member.%.InstanceId', [*instance_ids], 1)
  request({
    'Action'           => 'RegisterInstancesWithLoadBalancer',
    'LoadBalancerName' => lb_name,
    :parser            => Fog::Parsers::AWS::ELB::RegisterInstancesWithLoadBalancer.new
  }.merge!(params))
end