elb

package
v0.0.0-...-ac2c89b Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 6, 2015 License: Apache-2.0 Imports: 5 Imported by: 0

Documentation

Overview

Package elb provides a client for Elastic Load Balancing.

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessLog 

type AccessLog struct {
	// The interval for publishing the access logs. You can specify an interval
	// of either 5 minutes or 60 minutes.
	//
	// Default: 60 minutes
	EmitInterval *int64 `type:"integer"`

	// Specifies whether access log is enabled for the load balancer.
	Enabled *bool `type:"boolean" required:"true"`

	// The name of the Amazon S3 bucket where the access logs are stored.
	S3BucketName *string `type:"string"`

	// The logical hierarchy you created for your Amazon S3 bucket, for example
	// my-bucket-prefix/prod. If the prefix is not provided, the log is placed at
	// the root level of the bucket.
	S3BucketPrefix *string `type:"string"`
	// contains filtered or unexported fields
}

The AccessLog data type.

type AddTagsInput 

type AddTagsInput struct {
	// The name of the load balancer to tag. You can specify a maximum of one load
	// balancer name.
	LoadBalancerNames []*string `type:"list" required:"true"`

	// A list of tags for each load balancer.
	Tags []*Tag `type:"list" required:"true"`
	// contains filtered or unexported fields
}

The input for the AddTags action

type AddTagsOutput 

type AddTagsOutput struct {
	// contains filtered or unexported fields
}

The output for the AddTags action.

type AdditionalAttribute 

type AdditionalAttribute struct {
	Key *string `type:"string"`

	Value *string `type:"string"`
	// contains filtered or unexported fields
}

type AppCookieStickinessPolicy 

type AppCookieStickinessPolicy struct {
	// The name of the application cookie used for stickiness.
	CookieName *string `type:"string"`

	// The mnemonic name for the policy being created. The name must be unique within
	// a set of policies for this load balancer.
	PolicyName *string `type:"string"`
	// contains filtered or unexported fields
}

The AppCookieStickinessPolicy data type.

type ApplySecurityGroupsToLoadBalancerInput 

type ApplySecurityGroupsToLoadBalancerInput struct {
	// The name associated with the load balancer. The name must be unique within
	// the set of load balancers associated with your AWS account.
	LoadBalancerName *string `type:"string" required:"true"`

	// A list of security group IDs to associate with your load balancer in VPC.
	// The security group IDs must be provided as the ID and not the security group
	// name (For example, sg-1234).
	SecurityGroups []*string `type:"list" required:"true"`
	// contains filtered or unexported fields
}

The input for the ApplySecurityGroupsToLoadBalancer action.

type ApplySecurityGroupsToLoadBalancerOutput 

type ApplySecurityGroupsToLoadBalancerOutput struct {
	// A list of security group IDs associated with your load balancer.
	SecurityGroups []*string `type:"list"`
	// contains filtered or unexported fields
}

The out for the ApplySecurityGroupsToLoadBalancer action.

type AttachLoadBalancerToSubnetsInput 

type AttachLoadBalancerToSubnetsInput struct {
	// The name associated with the load balancer. The name must be unique within
	// the set of load balancers associated with your AWS account.
	LoadBalancerName *string `type:"string" required:"true"`

	// A list of subnet IDs to add for the load balancer. You can add only one subnet
	// per Availability Zone.
	Subnets []*string `type:"list" required:"true"`
	// contains filtered or unexported fields
}

The input for the AttachLoadBalancerToSubnets action.

type AttachLoadBalancerToSubnetsOutput 

type AttachLoadBalancerToSubnetsOutput struct {
	// A list of subnet IDs attached to the load balancer.
	Subnets []*string `type:"list"`
	// contains filtered or unexported fields
}

The output for the AttachLoadBalancerToSubnets action.

type BackendServerDescription 

type BackendServerDescription struct {
	// Provides the port on which the back-end server is listening.
	InstancePort *int64 `type:"integer"`

	// Provides a list of policy names enabled for the back-end server.
	PolicyNames []*string `type:"list"`
	// contains filtered or unexported fields
}

This data type is used as a response element in the DescribeLoadBalancers action to describe the configuration of the back-end server.

type ConfigureHealthCheckInput 

type ConfigureHealthCheckInput struct {
	// A structure containing the configuration information for the new healthcheck.
	HealthCheck *HealthCheck `type:"structure" required:"true"`

	// The mnemonic name associated with the load balancer. The name must be unique
	// within the set of load balancers associated with your AWS account.
	LoadBalancerName *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

Input for the ConfigureHealthCheck action.

type ConfigureHealthCheckOutput 

type ConfigureHealthCheckOutput struct {
	// The updated healthcheck for the instances.
	HealthCheck *HealthCheck `type:"structure"`
	// contains filtered or unexported fields
}

The output for the ConfigureHealthCheck action.

type ConnectionDraining 

type ConnectionDraining struct {
	// Specifies whether connection draining is enabled for the load balancer.
	Enabled *bool `type:"boolean" required:"true"`

	// Specifies the maximum time (in seconds) to keep the existing connections
	// open before deregistering the instances.
	Timeout *int64 `type:"integer"`
	// contains filtered or unexported fields
}

The ConnectionDraining data type.

type ConnectionSettings 

type ConnectionSettings struct {
	// Specifies the time (in seconds) the connection is allowed to be idle (no
	// data has been sent over the connection) before it is closed by the load balancer.
	IdleTimeout *int64 `type:"integer" required:"true"`
	// contains filtered or unexported fields
}

The ConnectionSettings data type.

type CreateAppCookieStickinessPolicyInput 

type CreateAppCookieStickinessPolicyInput struct {
	// Name of the application cookie used for stickiness.
	CookieName *string `type:"string" required:"true"`

	// The name of the load balancer.
	LoadBalancerName *string `type:"string" required:"true"`

	// The name of the policy being created. The name must be unique within the
	// set of policies for this load balancer.
	PolicyName *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

The input for the CreateAppCookieStickinessPolicy action.

type CreateAppCookieStickinessPolicyOutput 

type CreateAppCookieStickinessPolicyOutput struct {
	// contains filtered or unexported fields
}

The output for the CreateAppCookieStickinessPolicy action.

type CreateLBCookieStickinessPolicyInput 

type CreateLBCookieStickinessPolicyInput struct {
	// The time period in seconds after which the cookie should be considered stale.
	// Not specifying this parameter indicates that the sticky session will last
	// for the duration of the browser session.
	CookieExpirationPeriod *int64 `type:"long"`

	// The name associated with the load balancer.
	LoadBalancerName *string `type:"string" required:"true"`

	// The name of the policy being created. The name must be unique within the
	// set of policies for this load balancer.
	PolicyName *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

The input for the CreateLBCookieStickinessPolicy action.

type CreateLBCookieStickinessPolicyOutput 

type CreateLBCookieStickinessPolicyOutput struct {
	// contains filtered or unexported fields
}

The output for the CreateLBCookieStickinessPolicy action.

type CreateLoadBalancerInput 

type CreateLoadBalancerInput struct {
	// A list of Availability Zones.
	//
	//  At least one Availability Zone must be specified. Specified Availability
	// Zones must be in the same EC2 Region as the load balancer. Traffic will be
	// equally distributed across all zones.
	//
	//  You can later add more Availability Zones after the creation of the load
	// balancer by calling EnableAvailabilityZonesForLoadBalancer action.
	AvailabilityZones []*string `type:"list"`

	// A list of the following tuples: Protocol, LoadBalancerPort, InstanceProtocol,
	// InstancePort, and SSLCertificateId.
	Listeners []*Listener `type:"list" required:"true"`

	// The name associated with the load balancer. The name must be unique within
	// your set of load balancers, must have a maximum of 32 characters, and must
	// only contain alphanumeric characters or hyphens.
	LoadBalancerName *string `type:"string" required:"true"`

	// The type of a load balancer.
	//
	// By default, Elastic Load Balancing creates an Internet-facing load balancer
	// with a publicly resolvable DNS name, which resolves to public IP addresses.
	// For more information about Internet-facing and Internal load balancers, see
	// Internet-facing and Internal Load Balancers (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/vpc-loadbalancer-types.html).
	//
	// Specify the value internal for this option to create an internal load balancer
	// with a DNS name that resolves to private IP addresses.
	//
	//  This option is only available for load balancers created within EC2-VPC.
	Scheme *string `type:"string"`

	// The security groups to assign to your load balancer within your VPC.
	SecurityGroups []*string `type:"list"`

	// A list of subnet IDs in your VPC to attach to your load balancer. Specify
	// one subnet per Availability Zone.
	Subnets []*string `type:"list"`

	// A list of tags to assign to the load balancer.
	//
	// For more information about setting tags for your load balancer, see Tagging
	// (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/TerminologyandKeyConcepts.html#tagging-elb).
	Tags []*Tag `type:"list"`
	// contains filtered or unexported fields
}

The input for the CreateLoadBalancer action.

type CreateLoadBalancerListenersInput 

type CreateLoadBalancerListenersInput struct {
	// A list of LoadBalancerPort, InstancePort, Protocol, InstanceProtocol, and
	// SSLCertificateId items.
	Listeners []*Listener `type:"list" required:"true"`

	// The name of the load balancer.
	LoadBalancerName *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

The input for the CreateLoadBalancerListeners action.

type CreateLoadBalancerListenersOutput 

type CreateLoadBalancerListenersOutput struct {
	// contains filtered or unexported fields
}

The output for the CreateLoadBalancerListeners action.

type CreateLoadBalancerOutput 

type CreateLoadBalancerOutput struct {
	// The DNS name for the load balancer.
	DNSName *string `type:"string"`
	// contains filtered or unexported fields
}

The output for the CreateLoadBalancer action.

type CreateLoadBalancerPolicyInput 

type CreateLoadBalancerPolicyInput struct {
	// The name associated with the LoadBalancer for which the policy is being created.
	LoadBalancerName *string `type:"string" required:"true"`

	// A list of attributes associated with the policy being created.
	PolicyAttributes []*PolicyAttribute `type:"list"`

	// The name of the load balancer policy being created. The name must be unique
	// within the set of policies for this load balancer.
	PolicyName *string `type:"string" required:"true"`

	// The name of the base policy type being used to create this policy. To get
	// the list of policy types, use the DescribeLoadBalancerPolicyTypes action.
	PolicyTypeName *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

type CreateLoadBalancerPolicyOutput 

type CreateLoadBalancerPolicyOutput struct {
	// contains filtered or unexported fields
}

The output for the CreateLoadBalancerPolicy action.

type CrossZoneLoadBalancing 

type CrossZoneLoadBalancing struct {
	// Specifies whether cross-zone load balancing is enabled for the load balancer.
	Enabled *bool `type:"boolean" required:"true"`
	// contains filtered or unexported fields
}

The CrossZoneLoadBalancing data type.

type DeleteLoadBalancerInput 

type DeleteLoadBalancerInput struct {
	// The name associated with the load balancer.
	LoadBalancerName *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

The input for the DeleteLoadBalancer action.

type DeleteLoadBalancerListenersInput 

type DeleteLoadBalancerListenersInput struct {
	// The mnemonic name associated with the load balancer.
	LoadBalancerName *string `type:"string" required:"true"`

	// The client port number(s) of the load balancer listener(s) to be removed.
	LoadBalancerPorts []*int64 `type:"list" required:"true"`
	// contains filtered or unexported fields
}

The input for the DeleteLoadBalancerListeners action.

type DeleteLoadBalancerListenersOutput 

type DeleteLoadBalancerListenersOutput struct {
	// contains filtered or unexported fields
}

The output for the DeleteLoadBalancerListeners action.

type DeleteLoadBalancerOutput 

type DeleteLoadBalancerOutput struct {
	// contains filtered or unexported fields
}

The output for the DeleteLoadBalancer action.

type DeleteLoadBalancerPolicyInput 

type DeleteLoadBalancerPolicyInput struct {
	// The mnemonic name associated with the load balancer.
	LoadBalancerName *string `type:"string" required:"true"`

	// The mnemonic name for the policy being deleted.
	PolicyName *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

The input for the DeleteLoadBalancerPolicy action.

type DeleteLoadBalancerPolicyOutput 

type DeleteLoadBalancerPolicyOutput struct {
	// contains filtered or unexported fields
}

The output for the DeleteLoadBalancerPolicy action.

type DeregisterInstancesFromLoadBalancerInput 

type DeregisterInstancesFromLoadBalancerInput struct {
	// A list of EC2 instance IDs consisting of all instances to be deregistered.
	Instances []*Instance `type:"list" required:"true"`

	// The name associated with the load balancer.
	LoadBalancerName *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

The input for the DeregisterInstancesFromLoadBalancer action.

type DeregisterInstancesFromLoadBalancerOutput 

type DeregisterInstancesFromLoadBalancerOutput struct {
	// An updated list of remaining instances registered with the load balancer.
	Instances []*Instance `type:"list"`
	// contains filtered or unexported fields
}

The output for the DeregisterInstancesFromLoadBalancer action.

type DescribeInstanceHealthInput 

type DescribeInstanceHealthInput struct {
	// A list of instance IDs whose states are being queried.
	Instances []*Instance `type:"list"`

	// The name of the load balancer.
	LoadBalancerName *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

The input for the DescribeEndPointState action.

type DescribeInstanceHealthOutput 

type DescribeInstanceHealthOutput struct {
	// A list containing health information for the specified instances.
	InstanceStates []*InstanceState `type:"list"`
	// contains filtered or unexported fields
}

The output for the DescribeInstanceHealth action.

type DescribeLoadBalancerAttributesInput 

type DescribeLoadBalancerAttributesInput struct {
	// The name of the load balancer.
	LoadBalancerName *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

The input for the DescribeLoadBalancerAttributes action.

type DescribeLoadBalancerAttributesOutput 

type DescribeLoadBalancerAttributesOutput struct {
	// The load balancer attributes structure.
	LoadBalancerAttributes *LoadBalancerAttributes `type:"structure"`
	// contains filtered or unexported fields
}

The following element is returned in a structure named DescribeLoadBalancerAttributesResult.

type DescribeLoadBalancerPoliciesInput 

type DescribeLoadBalancerPoliciesInput struct {
	// The mnemonic name associated with the load balancer. If no name is specified,
	// the operation returns the attributes of either all the sample policies pre-defined
	// by Elastic Load Balancing or the specified sample polices.
	LoadBalancerName *string `type:"string"`

	// The names of load balancer policies you've created or Elastic Load Balancing
	// sample policy names.
	PolicyNames []*string `type:"list"`
	// contains filtered or unexported fields
}

type DescribeLoadBalancerPoliciesOutput 

type DescribeLoadBalancerPoliciesOutput struct {
	// A list of policy description structures.
	PolicyDescriptions []*PolicyDescription `type:"list"`
	// contains filtered or unexported fields
}

The output for the DescribeLoadBalancerPolicies action.

type DescribeLoadBalancerPolicyTypesInput 

type DescribeLoadBalancerPolicyTypesInput struct {
	// Specifies the name of the policy types. If no names are specified, returns
	// the description of all the policy types defined by Elastic Load Balancing
	// service.
	PolicyTypeNames []*string `type:"list"`
	// contains filtered or unexported fields
}

type DescribeLoadBalancerPolicyTypesOutput 

type DescribeLoadBalancerPolicyTypesOutput struct {
	// List of policy type description structures of the specified policy type.
	// If no policy type names are specified, returns the description of all the
	// policy types defined by Elastic Load Balancing service.
	PolicyTypeDescriptions []*PolicyTypeDescription `type:"list"`
	// contains filtered or unexported fields
}

The output for the DescribeLoadBalancerPolicyTypes action.

type DescribeLoadBalancersInput 

type DescribeLoadBalancersInput struct {
	// A list of load balancer names associated with the account.
	LoadBalancerNames []*string `type:"list"`

	// An optional parameter used for pagination of results from this call. If specified,
	// the response includes only records beyond the marker.
	Marker *string `type:"string"`

	// The number of results returned in each page. The default is 400. You cannot
	// specify a page size greater than 400 or less than 1.
	PageSize *int64 `type:"integer"`
	// contains filtered or unexported fields
}

The input for the DescribeLoadBalancers action.

type DescribeLoadBalancersOutput 

type DescribeLoadBalancersOutput struct {
	// A list of load balancer description structures.
	LoadBalancerDescriptions []*LoadBalancerDescription `type:"list"`

	// Specifies the value of next marker if the request returned more than one
	// page of results.
	NextMarker *string `type:"string"`
	// contains filtered or unexported fields
}

The output for the DescribeLoadBalancers action.

type DescribeTagsInput 

type DescribeTagsInput struct {
	// The names of the load balancers.
	LoadBalancerNames []*string `type:"list" required:"true"`
	// contains filtered or unexported fields
}

The input for the DescribeTags action.

type DescribeTagsOutput 

type DescribeTagsOutput struct {
	// A list of tag description structures.
	TagDescriptions []*TagDescription `type:"list"`
	// contains filtered or unexported fields
}

The output for the DescribeTags action.

type DetachLoadBalancerFromSubnetsInput 

type DetachLoadBalancerFromSubnetsInput struct {
	// The name associated with the load balancer to be detached.
	LoadBalancerName *string `type:"string" required:"true"`

	// A list of subnet IDs to remove from the set of configured subnets for the
	// load balancer.
	Subnets []*string `type:"list" required:"true"`
	// contains filtered or unexported fields
}

The input for the DetachLoadBalancerFromSubnets action.

type DetachLoadBalancerFromSubnetsOutput 

type DetachLoadBalancerFromSubnetsOutput struct {
	// A list of subnet IDs the load balancer is now attached to.
	Subnets []*string `type:"list"`
	// contains filtered or unexported fields
}

The output for the DetachLoadBalancerFromSubnets action.

type DisableAvailabilityZonesForLoadBalancerInput 

type DisableAvailabilityZonesForLoadBalancerInput struct {
	// A list of Availability Zones to be removed from the load balancer.
	//
	//  There must be at least one Availability Zone registered with a load balancer
	// at all times. Specified Availability Zones must be in the same region.
	AvailabilityZones []*string `type:"list" required:"true"`

	// The name associated with the load balancer.
	LoadBalancerName *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

The input for the DisableAvailabilityZonesForLoadBalancer action.

type DisableAvailabilityZonesForLoadBalancerOutput 

type DisableAvailabilityZonesForLoadBalancerOutput struct {
	// A list of updated Availability Zones for the load balancer.
	AvailabilityZones []*string `type:"list"`
	// contains filtered or unexported fields
}

The output for the DisableAvailabilityZonesForLoadBalancer action.

type ELB 

type ELB struct {
	*aws.Service
}

ELB is a client for Elastic Load Balancing.

func New 

func New(config *aws.Config) *ELB

New returns a new ELB client.

func (*ELB) AddTags 

func (c *ELB) AddTags(input *AddTagsInput) (output *AddTagsOutput, err error)

Adds one or more tags for the specified load balancer. Each load balancer can have a maximum of 10 tags. Each tag consists of a key and an optional value.

Tag keys must be unique for each load balancer. If a tag with the same key is already associated with the load balancer, this action will update the value of the key.

For more information, see Tagging (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/TerminologyandKeyConcepts.html#tagging-elb) in the Elastic Load Balancing Developer Guide.

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.AddTagsInput{
		LoadBalancerNames: []*string{ // Required
			aws.String("AccessPointName"), // Required
			// More values...
		},
		Tags: []*elb.Tag{ // Required
			&elb.Tag{ // Required
				Key:   aws.String("TagKey"), // Required
				Value: aws.String("TagValue"),
			},
			// More values...
		},
	}
	resp, err := svc.AddTags(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) AddTagsRequest 

func (c *ELB) AddTagsRequest(input *AddTagsInput) (req *aws.Request, output *AddTagsOutput)

AddTagsRequest generates a request for the AddTags operation.

func (*ELB) ApplySecurityGroupsToLoadBalancer 

func (c *ELB) ApplySecurityGroupsToLoadBalancer(input *ApplySecurityGroupsToLoadBalancerInput) (output *ApplySecurityGroupsToLoadBalancerOutput, err error)

Associates one or more security groups with your load balancer in Amazon Virtual Private Cloud (Amazon VPC). The provided security group IDs will override any currently applied security groups.

For more information, see Manage Security Groups in Amazon VPC (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/USVPC_ApplySG.html) in the Elastic Load Balancing Developer Guide.

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.ApplySecurityGroupsToLoadBalancerInput{
		LoadBalancerName: aws.String("AccessPointName"), // Required
		SecurityGroups: []*string{ // Required
			aws.String("SecurityGroupId"), // Required
			// More values...
		},
	}
	resp, err := svc.ApplySecurityGroupsToLoadBalancer(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) ApplySecurityGroupsToLoadBalancerRequest 

func (c *ELB) ApplySecurityGroupsToLoadBalancerRequest(input *ApplySecurityGroupsToLoadBalancerInput) (req *aws.Request, output *ApplySecurityGroupsToLoadBalancerOutput)

ApplySecurityGroupsToLoadBalancerRequest generates a request for the ApplySecurityGroupsToLoadBalancer operation.

func (*ELB) AttachLoadBalancerToSubnets 

func (c *ELB) AttachLoadBalancerToSubnets(input *AttachLoadBalancerToSubnetsInput) (output *AttachLoadBalancerToSubnetsOutput, err error)

Adds one or more subnets to the set of configured subnets in the Amazon Virtual Private Cloud (Amazon VPC) for the load balancer. 

The load balancers evenly distribute requests across all of the registered

subnets. For more information, see Deploy Elastic Load Balancing in Amazon VPC (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/UserScenariosForVPC.html) in the Elastic Load Balancing Developer Guide.

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.AttachLoadBalancerToSubnetsInput{
		LoadBalancerName: aws.String("AccessPointName"), // Required
		Subnets: []*string{ // Required
			aws.String("SubnetId"), // Required
			// More values...
		},
	}
	resp, err := svc.AttachLoadBalancerToSubnets(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) AttachLoadBalancerToSubnetsRequest 

func (c *ELB) AttachLoadBalancerToSubnetsRequest(input *AttachLoadBalancerToSubnetsInput) (req *aws.Request, output *AttachLoadBalancerToSubnetsOutput)

AttachLoadBalancerToSubnetsRequest generates a request for the AttachLoadBalancerToSubnets operation.

func (*ELB) ConfigureHealthCheck 

func (c *ELB) ConfigureHealthCheck(input *ConfigureHealthCheckInput) (output *ConfigureHealthCheckOutput, err error)

Specifies the health check settings to use for evaluating the health state of your back-end instances.

For more information, see Health Check (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/TerminologyandKeyConcepts.html#healthcheck) in the Elastic Load Balancing Developer Guide.

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.ConfigureHealthCheckInput{
		HealthCheck: &elb.HealthCheck{ // Required
			HealthyThreshold:   aws.Long(1),                     // Required
			Interval:           aws.Long(1),                     // Required
			Target:             aws.String("HealthCheckTarget"), // Required
			Timeout:            aws.Long(1),                     // Required
			UnhealthyThreshold: aws.Long(1),                     // Required
		},
		LoadBalancerName: aws.String("AccessPointName"), // Required
	}
	resp, err := svc.ConfigureHealthCheck(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) ConfigureHealthCheckRequest 

func (c *ELB) ConfigureHealthCheckRequest(input *ConfigureHealthCheckInput) (req *aws.Request, output *ConfigureHealthCheckOutput)

ConfigureHealthCheckRequest generates a request for the ConfigureHealthCheck operation.

func (*ELB) CreateAppCookieStickinessPolicy 

func (c *ELB) CreateAppCookieStickinessPolicy(input *CreateAppCookieStickinessPolicyInput) (output *CreateAppCookieStickinessPolicyOutput, err error)

Generates a stickiness policy with sticky session lifetimes that follow that of an application-generated cookie. This policy can be associated only with HTTP/HTTPS listeners. 

This policy is similar to the policy created by CreateLBCookieStickinessPolicy,

except that the lifetime of the special Elastic Load Balancing cookie follows the lifetime of the application-generated cookie specified in the policy configuration. The load balancer only inserts a new stickiness cookie when the application response includes a new application cookie. 

If the application cookie is explicitly removed or expires, the session

stops being sticky until a new application cookie is issued. 

An application client must receive and send two cookies: the application-generated

cookie and the special Elastic Load Balancing cookie named AWSELB. This is the default behavior for many common web browsers. For more information, see Enabling Application-Controlled Session Stickiness (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/US_StickySessions.html#US_EnableStickySessionsAppCookies) in the Elastic Load Balancing Developer Guide.

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.CreateAppCookieStickinessPolicyInput{
		CookieName:       aws.String("CookieName"),      // Required
		LoadBalancerName: aws.String("AccessPointName"), // Required
		PolicyName:       aws.String("PolicyName"),      // Required
	}
	resp, err := svc.CreateAppCookieStickinessPolicy(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) CreateAppCookieStickinessPolicyRequest 

func (c *ELB) CreateAppCookieStickinessPolicyRequest(input *CreateAppCookieStickinessPolicyInput) (req *aws.Request, output *CreateAppCookieStickinessPolicyOutput)

CreateAppCookieStickinessPolicyRequest generates a request for the CreateAppCookieStickinessPolicy operation.

func (*ELB) CreateLBCookieStickinessPolicy 

func (c *ELB) CreateLBCookieStickinessPolicy(input *CreateLBCookieStickinessPolicyInput) (output *CreateLBCookieStickinessPolicyOutput, err error)

Generates a stickiness policy with sticky session lifetimes controlled by the lifetime of the browser (user-agent) or a specified expiration period. This policy can be associated only with HTTP/HTTPS listeners. 

When a load balancer implements this policy, the load balancer uses a special

cookie to track the backend server instance for each request. When the load balancer receives a request, it first checks to see if this cookie is present in the request. If so, the load balancer sends the request to the application server specified in the cookie. If not, the load balancer sends the request to a server that is chosen based on the existing load balancing algorithm. 

A cookie is inserted into the response for binding subsequent requests

from the same user to that server. The validity of the cookie is based on the cookie expiration time, which is specified in the policy configuration.

For more information, see Enabling Duration-Based Session Stickiness (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/US_StickySessions.html#US_EnableStickySessionsLBCookies) in the Elastic Load Balancing Developer Guide.

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.CreateLBCookieStickinessPolicyInput{
		LoadBalancerName:       aws.String("AccessPointName"), // Required
		PolicyName:             aws.String("PolicyName"),      // Required
		CookieExpirationPeriod: aws.Long(1),
	}
	resp, err := svc.CreateLBCookieStickinessPolicy(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) CreateLBCookieStickinessPolicyRequest 

func (c *ELB) CreateLBCookieStickinessPolicyRequest(input *CreateLBCookieStickinessPolicyInput) (req *aws.Request, output *CreateLBCookieStickinessPolicyOutput)

CreateLBCookieStickinessPolicyRequest generates a request for the CreateLBCookieStickinessPolicy operation.

func (*ELB) CreateLoadBalancer 

func (c *ELB) CreateLoadBalancer(input *CreateLoadBalancerInput) (output *CreateLoadBalancerOutput, err error)

Creates a new load balancer. 

After the call has completed successfully, a new load balancer is created

with a unique Domain Name Service (DNS) name. The DNS name includes the name of the AWS region in which the load balance was created. For example, if your load balancer was created in the United States, the DNS name might end with either of the following: 

us-east-1.elb.amazonaws.com (for the Northern Virginia region)   us-west-1.elb.amazonaws.com

(for the Northern California region) For information about the AWS regions supported by Elastic Load Balancing, see Regions and Endpoints (http://docs.aws.amazon.com/general/latest/gr/rande.html#elb_region).

You can create up to 20 load balancers per region per account.

Elastic Load Balancing supports load balancing your Amazon EC2 instances launched within any one of the following platforms: 

EC2-Classic For information on creating and managing your load balancers

in EC2-Classic, see Deploy Elastic Load Balancing in Amazon EC2-Classic (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/UserScenariosForEC2.html). 

EC2-VPC For information on creating and managing your load balancers in

EC2-VPC, see Deploy Elastic Load Balancing in Amazon VPC (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/UserScenariosForVPC.html).

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.CreateLoadBalancerInput{
		Listeners: []*elb.Listener{ // Required
			&elb.Listener{ // Required
				InstancePort:     aws.Long(1),            // Required
				LoadBalancerPort: aws.Long(1),            // Required
				Protocol:         aws.String("Protocol"), // Required
				InstanceProtocol: aws.String("Protocol"),
				SSLCertificateID: aws.String("SSLCertificateId"),
			},
			// More values...
		},
		LoadBalancerName: aws.String("AccessPointName"), // Required
		AvailabilityZones: []*string{
			aws.String("AvailabilityZone"), // Required
			// More values...
		},
		Scheme: aws.String("LoadBalancerScheme"),
		SecurityGroups: []*string{
			aws.String("SecurityGroupId"), // Required
			// More values...
		},
		Subnets: []*string{
			aws.String("SubnetId"), // Required
			// More values...
		},
		Tags: []*elb.Tag{
			&elb.Tag{ // Required
				Key:   aws.String("TagKey"), // Required
				Value: aws.String("TagValue"),
			},
			// More values...
		},
	}
	resp, err := svc.CreateLoadBalancer(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) CreateLoadBalancerListeners 

func (c *ELB) CreateLoadBalancerListeners(input *CreateLoadBalancerListenersInput) (output *CreateLoadBalancerListenersOutput, err error)

Creates one or more listeners on a load balancer for the specified port. If a listener with the given port does not already exist, it will be created; otherwise, the properties of the new listener must match the properties of the existing listener.

For more information, see Add a Listener to Your Load Balancer (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/us-add-listener.html) in the Elastic Load Balancing Developer Guide.

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.CreateLoadBalancerListenersInput{
		Listeners: []*elb.Listener{ // Required
			&elb.Listener{ // Required
				InstancePort:     aws.Long(1),            // Required
				LoadBalancerPort: aws.Long(1),            // Required
				Protocol:         aws.String("Protocol"), // Required
				InstanceProtocol: aws.String("Protocol"),
				SSLCertificateID: aws.String("SSLCertificateId"),
			},
			// More values...
		},
		LoadBalancerName: aws.String("AccessPointName"), // Required
	}
	resp, err := svc.CreateLoadBalancerListeners(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) CreateLoadBalancerListenersRequest 

func (c *ELB) CreateLoadBalancerListenersRequest(input *CreateLoadBalancerListenersInput) (req *aws.Request, output *CreateLoadBalancerListenersOutput)

CreateLoadBalancerListenersRequest generates a request for the CreateLoadBalancerListeners operation.

func (*ELB) CreateLoadBalancerPolicy 

func (c *ELB) CreateLoadBalancerPolicy(input *CreateLoadBalancerPolicyInput) (output *CreateLoadBalancerPolicyOutput, err error)

Creates a new policy that contains the necessary attributes depending on the policy type. Policies are settings that are saved for your load balancer and that can be applied to the front-end listener, or the back-end application server, depending on your policy type.

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.CreateLoadBalancerPolicyInput{
		LoadBalancerName: aws.String("AccessPointName"), // Required
		PolicyName:       aws.String("PolicyName"),      // Required
		PolicyTypeName:   aws.String("PolicyTypeName"),  // Required
		PolicyAttributes: []*elb.PolicyAttribute{
			&elb.PolicyAttribute{ // Required
				AttributeName:  aws.String("AttributeName"),
				AttributeValue: aws.String("AttributeValue"),
			},
			// More values...
		},
	}
	resp, err := svc.CreateLoadBalancerPolicy(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) CreateLoadBalancerPolicyRequest 

func (c *ELB) CreateLoadBalancerPolicyRequest(input *CreateLoadBalancerPolicyInput) (req *aws.Request, output *CreateLoadBalancerPolicyOutput)

CreateLoadBalancerPolicyRequest generates a request for the CreateLoadBalancerPolicy operation.

func (*ELB) CreateLoadBalancerRequest 

func (c *ELB) CreateLoadBalancerRequest(input *CreateLoadBalancerInput) (req *aws.Request, output *CreateLoadBalancerOutput)

CreateLoadBalancerRequest generates a request for the CreateLoadBalancer operation.

func (*ELB) DeleteLoadBalancer 

func (c *ELB) DeleteLoadBalancer(input *DeleteLoadBalancerInput) (output *DeleteLoadBalancerOutput, err error)

Deletes the specified load balancer. 

If attempting to recreate the load balancer, you must reconfigure all the

settings. The DNS name associated with a deleted load balancer will no longer be usable. Once deleted, the name and associated DNS record of the load balancer no longer exist and traffic sent to any of its IP addresses will no longer be delivered to back-end instances. 

To successfully call this API, you must provide the same account credentials

as were used to create the load balancer. 

By design, if the load balancer does not exist or has already been deleted,

a call to DeleteLoadBalancer action still succeeds.

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.DeleteLoadBalancerInput{
		LoadBalancerName: aws.String("AccessPointName"), // Required
	}
	resp, err := svc.DeleteLoadBalancer(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) DeleteLoadBalancerListeners 

func (c *ELB) DeleteLoadBalancerListeners(input *DeleteLoadBalancerListenersInput) (output *DeleteLoadBalancerListenersOutput, err error)

Deletes listeners from the load balancer for the specified port.

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.DeleteLoadBalancerListenersInput{
		LoadBalancerName: aws.String("AccessPointName"), // Required
		LoadBalancerPorts: []*int64{ // Required
			aws.Long(1), // Required
			// More values...
		},
	}
	resp, err := svc.DeleteLoadBalancerListeners(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) DeleteLoadBalancerListenersRequest 

func (c *ELB) DeleteLoadBalancerListenersRequest(input *DeleteLoadBalancerListenersInput) (req *aws.Request, output *DeleteLoadBalancerListenersOutput)

DeleteLoadBalancerListenersRequest generates a request for the DeleteLoadBalancerListeners operation.

func (*ELB) DeleteLoadBalancerPolicy 

func (c *ELB) DeleteLoadBalancerPolicy(input *DeleteLoadBalancerPolicyInput) (output *DeleteLoadBalancerPolicyOutput, err error)

Deletes a policy from the load balancer. The specified policy must not be enabled for any listeners.

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.DeleteLoadBalancerPolicyInput{
		LoadBalancerName: aws.String("AccessPointName"), // Required
		PolicyName:       aws.String("PolicyName"),      // Required
	}
	resp, err := svc.DeleteLoadBalancerPolicy(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) DeleteLoadBalancerPolicyRequest 

func (c *ELB) DeleteLoadBalancerPolicyRequest(input *DeleteLoadBalancerPolicyInput) (req *aws.Request, output *DeleteLoadBalancerPolicyOutput)

DeleteLoadBalancerPolicyRequest generates a request for the DeleteLoadBalancerPolicy operation.

func (*ELB) DeleteLoadBalancerRequest 

func (c *ELB) DeleteLoadBalancerRequest(input *DeleteLoadBalancerInput) (req *aws.Request, output *DeleteLoadBalancerOutput)

DeleteLoadBalancerRequest generates a request for the DeleteLoadBalancer operation.

func (*ELB) DeregisterInstancesFromLoadBalancer 

func (c *ELB) DeregisterInstancesFromLoadBalancer(input *DeregisterInstancesFromLoadBalancerInput) (output *DeregisterInstancesFromLoadBalancerOutput, err error)

Deregisters instances from the load balancer. Once the instance is deregistered, it will stop receiving traffic from the load balancer. 

In order to successfully call this API, the same account credentials as

those used to create the load balancer must be provided.

For more information, see De-register and Register Amazon EC2 Instances (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/US_DeReg_Reg_Instances.html) in the Elastic Load Balancing Developer Guide.

You can use DescribeLoadBalancers to verify if the instance is deregistered from the load balancer.

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.DeregisterInstancesFromLoadBalancerInput{
		Instances: []*elb.Instance{ // Required
			&elb.Instance{ // Required
				InstanceID: aws.String("InstanceId"),
			},
			// More values...
		},
		LoadBalancerName: aws.String("AccessPointName"), // Required
	}
	resp, err := svc.DeregisterInstancesFromLoadBalancer(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) DeregisterInstancesFromLoadBalancerRequest 

func (c *ELB) DeregisterInstancesFromLoadBalancerRequest(input *DeregisterInstancesFromLoadBalancerInput) (req *aws.Request, output *DeregisterInstancesFromLoadBalancerOutput)

DeregisterInstancesFromLoadBalancerRequest generates a request for the DeregisterInstancesFromLoadBalancer operation.

func (*ELB) DescribeInstanceHealth 

func (c *ELB) DescribeInstanceHealth(input *DescribeInstanceHealthInput) (output *DescribeInstanceHealthOutput, err error)

Returns the current state of the specified instances registered with the specified load balancer. If no instances are specified, the state of all the instances registered with the load balancer is returned. 

You must provide the same account credentials as those that were used to

create the load balancer.

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.DescribeInstanceHealthInput{
		LoadBalancerName: aws.String("AccessPointName"), // Required
		Instances: []*elb.Instance{
			&elb.Instance{ // Required
				InstanceID: aws.String("InstanceId"),
			},
			// More values...
		},
	}
	resp, err := svc.DescribeInstanceHealth(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) DescribeInstanceHealthRequest 

func (c *ELB) DescribeInstanceHealthRequest(input *DescribeInstanceHealthInput) (req *aws.Request, output *DescribeInstanceHealthOutput)

DescribeInstanceHealthRequest generates a request for the DescribeInstanceHealth operation.

func (*ELB) DescribeLoadBalancerAttributes 

func (c *ELB) DescribeLoadBalancerAttributes(input *DescribeLoadBalancerAttributesInput) (output *DescribeLoadBalancerAttributesOutput, err error)

Returns detailed information about all of the attributes associated with the specified load balancer.

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.DescribeLoadBalancerAttributesInput{
		LoadBalancerName: aws.String("AccessPointName"), // Required
	}
	resp, err := svc.DescribeLoadBalancerAttributes(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) DescribeLoadBalancerAttributesRequest 

func (c *ELB) DescribeLoadBalancerAttributesRequest(input *DescribeLoadBalancerAttributesInput) (req *aws.Request, output *DescribeLoadBalancerAttributesOutput)

DescribeLoadBalancerAttributesRequest generates a request for the DescribeLoadBalancerAttributes operation.

func (*ELB) DescribeLoadBalancerPolicies 

func (c *ELB) DescribeLoadBalancerPolicies(input *DescribeLoadBalancerPoliciesInput) (output *DescribeLoadBalancerPoliciesOutput, err error)

Returns detailed descriptions of the policies. If you specify a load balancer name, the action returns the descriptions of all the policies created for the load balancer. If you specify a policy name associated with your load balancer, the action returns the description of that policy. If you don't specify a load balancer name, the action returns descriptions of the specified sample policies, or descriptions of all the sample policies. The names of the sample policies have the ELBSample- prefix.

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.DescribeLoadBalancerPoliciesInput{
		LoadBalancerName: aws.String("AccessPointName"),
		PolicyNames: []*string{
			aws.String("PolicyName"), // Required
			// More values...
		},
	}
	resp, err := svc.DescribeLoadBalancerPolicies(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) DescribeLoadBalancerPoliciesRequest 

func (c *ELB) DescribeLoadBalancerPoliciesRequest(input *DescribeLoadBalancerPoliciesInput) (req *aws.Request, output *DescribeLoadBalancerPoliciesOutput)

DescribeLoadBalancerPoliciesRequest generates a request for the DescribeLoadBalancerPolicies operation.

func (*ELB) DescribeLoadBalancerPolicyTypes 

func (c *ELB) DescribeLoadBalancerPolicyTypes(input *DescribeLoadBalancerPolicyTypesInput) (output *DescribeLoadBalancerPolicyTypesOutput, err error)

Returns meta-information on the specified load balancer policies defined by the Elastic Load Balancing service. The policy types that are returned from this action can be used in a CreateLoadBalancerPolicy action to instantiate specific policy configurations that will be applied to a load balancer.

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.DescribeLoadBalancerPolicyTypesInput{
		PolicyTypeNames: []*string{
			aws.String("PolicyTypeName"), // Required
			// More values...
		},
	}
	resp, err := svc.DescribeLoadBalancerPolicyTypes(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) DescribeLoadBalancerPolicyTypesRequest 

func (c *ELB) DescribeLoadBalancerPolicyTypesRequest(input *DescribeLoadBalancerPolicyTypesInput) (req *aws.Request, output *DescribeLoadBalancerPolicyTypesOutput)

DescribeLoadBalancerPolicyTypesRequest generates a request for the DescribeLoadBalancerPolicyTypes operation.

func (*ELB) DescribeLoadBalancers 

func (c *ELB) DescribeLoadBalancers(input *DescribeLoadBalancersInput) (output *DescribeLoadBalancersOutput, err error)

Returns detailed configuration information for all the load balancers created for the account. If you specify load balancer names, the action returns configuration information of the specified load balancers. 

In order to retrieve this information, you must provide the same account

credentials that was used to create the load balancer.

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.DescribeLoadBalancersInput{
		LoadBalancerNames: []*string{
			aws.String("AccessPointName"), // Required
			// More values...
		},
		Marker:   aws.String("Marker"),
		PageSize: aws.Long(1),
	}
	resp, err := svc.DescribeLoadBalancers(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) DescribeLoadBalancersRequest 

func (c *ELB) DescribeLoadBalancersRequest(input *DescribeLoadBalancersInput) (req *aws.Request, output *DescribeLoadBalancersOutput)

DescribeLoadBalancersRequest generates a request for the DescribeLoadBalancers operation.

func (*ELB) DescribeTags 

func (c *ELB) DescribeTags(input *DescribeTagsInput) (output *DescribeTagsOutput, err error)

Describes the tags associated with one or more load balancers.

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.DescribeTagsInput{
		LoadBalancerNames: []*string{ // Required
			aws.String("AccessPointName"), // Required
			// More values...
		},
	}
	resp, err := svc.DescribeTags(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) DescribeTagsRequest 

func (c *ELB) DescribeTagsRequest(input *DescribeTagsInput) (req *aws.Request, output *DescribeTagsOutput)

DescribeTagsRequest generates a request for the DescribeTags operation.

func (*ELB) DetachLoadBalancerFromSubnets 

func (c *ELB) DetachLoadBalancerFromSubnets(input *DetachLoadBalancerFromSubnetsInput) (output *DetachLoadBalancerFromSubnetsOutput, err error)

Removes subnets from the set of configured subnets in the Amazon Virtual Private Cloud (Amazon VPC) for the load balancer. 

After a subnet is removed all of the EC2 instances registered with the

load balancer that are in the removed subnet will go into the OutOfService state. When a subnet is removed, the load balancer will balance the traffic among the remaining routable subnets for the load balancer.

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.DetachLoadBalancerFromSubnetsInput{
		LoadBalancerName: aws.String("AccessPointName"), // Required
		Subnets: []*string{ // Required
			aws.String("SubnetId"), // Required
			// More values...
		},
	}
	resp, err := svc.DetachLoadBalancerFromSubnets(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) DetachLoadBalancerFromSubnetsRequest 

func (c *ELB) DetachLoadBalancerFromSubnetsRequest(input *DetachLoadBalancerFromSubnetsInput) (req *aws.Request, output *DetachLoadBalancerFromSubnetsOutput)

DetachLoadBalancerFromSubnetsRequest generates a request for the DetachLoadBalancerFromSubnets operation.

func (*ELB) DisableAvailabilityZonesForLoadBalancer 

func (c *ELB) DisableAvailabilityZonesForLoadBalancer(input *DisableAvailabilityZonesForLoadBalancerInput) (output *DisableAvailabilityZonesForLoadBalancerOutput, err error)

Removes the specified EC2 Availability Zones from the set of configured Availability Zones for the load balancer. 

There must be at least one Availability Zone registered with a load balancer

at all times. Once an Availability Zone is removed, all the instances registered with the load balancer that are in the removed Availability Zone go into the OutOfService state. Upon Availability Zone removal, the load balancer attempts to equally balance the traffic among its remaining usable Availability Zones. Trying to remove an Availability Zone that was not associated with the load balancer does nothing.

For more information, see Disable an Availability Zone from a Load-Balanced Application (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/US_ShrinkLBApp04.html) in the Elastic Load Balancing Developer Guide.

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.DisableAvailabilityZonesForLoadBalancerInput{
		AvailabilityZones: []*string{ // Required
			aws.String("AvailabilityZone"), // Required
			// More values...
		},
		LoadBalancerName: aws.String("AccessPointName"), // Required
	}
	resp, err := svc.DisableAvailabilityZonesForLoadBalancer(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) DisableAvailabilityZonesForLoadBalancerRequest 

func (c *ELB) DisableAvailabilityZonesForLoadBalancerRequest(input *DisableAvailabilityZonesForLoadBalancerInput) (req *aws.Request, output *DisableAvailabilityZonesForLoadBalancerOutput)

DisableAvailabilityZonesForLoadBalancerRequest generates a request for the DisableAvailabilityZonesForLoadBalancer operation.

func (*ELB) EnableAvailabilityZonesForLoadBalancer 

func (c *ELB) EnableAvailabilityZonesForLoadBalancer(input *EnableAvailabilityZonesForLoadBalancerInput) (output *EnableAvailabilityZonesForLoadBalancerOutput, err error)

Adds one or more EC2 Availability Zones to the load balancer. 

The load balancer evenly distributes requests across all its registered

Availability Zones that contain instances. 

The new EC2 Availability Zones to be added must be in the same EC2 Region

as the Availability Zones for which the load balancer was created. For more information, see Expand a Load Balanced Application to an Additional Availability Zone (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/US_AddLBAvailabilityZone.html) in the Elastic Load Balancing Developer Guide.

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.EnableAvailabilityZonesForLoadBalancerInput{
		AvailabilityZones: []*string{ // Required
			aws.String("AvailabilityZone"), // Required
			// More values...
		},
		LoadBalancerName: aws.String("AccessPointName"), // Required
	}
	resp, err := svc.EnableAvailabilityZonesForLoadBalancer(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) EnableAvailabilityZonesForLoadBalancerRequest 

func (c *ELB) EnableAvailabilityZonesForLoadBalancerRequest(input *EnableAvailabilityZonesForLoadBalancerInput) (req *aws.Request, output *EnableAvailabilityZonesForLoadBalancerOutput)

EnableAvailabilityZonesForLoadBalancerRequest generates a request for the EnableAvailabilityZonesForLoadBalancer operation.

func (*ELB) ModifyLoadBalancerAttributes 

func (c *ELB) ModifyLoadBalancerAttributes(input *ModifyLoadBalancerAttributesInput) (output *ModifyLoadBalancerAttributesOutput, err error)

Modifies the attributes of a specified load balancer.

You can modify the load balancer attributes, such as AccessLogs, ConnectionDraining, and CrossZoneLoadBalancing by either enabling or disabling them. Or, you can modify the load balancer attribute ConnectionSettings by specifying an idle connection timeout value for your load balancer.

For more information, see the following: 

Cross-Zone Load Balancing (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/TerminologyandKeyConcepts.html#request-routing)

Connection Draining (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/TerminologyandKeyConcepts.html#conn-drain) Access Logs (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/access-log-collection.html) Idle Connection Timeout (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/TerminologyandKeyConcepts.html#idle-timeout)

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.ModifyLoadBalancerAttributesInput{
		LoadBalancerAttributes: &elb.LoadBalancerAttributes{ // Required
			AccessLog: &elb.AccessLog{
				Enabled:        aws.Boolean(true), // Required
				EmitInterval:   aws.Long(1),
				S3BucketName:   aws.String("S3BucketName"),
				S3BucketPrefix: aws.String("AccessLogPrefix"),
			},
			AdditionalAttributes: []*elb.AdditionalAttribute{
				&elb.AdditionalAttribute{ // Required
					Key:   aws.String("StringVal"),
					Value: aws.String("StringVal"),
				},
				// More values...
			},
			ConnectionDraining: &elb.ConnectionDraining{
				Enabled: aws.Boolean(true), // Required
				Timeout: aws.Long(1),
			},
			ConnectionSettings: &elb.ConnectionSettings{
				IdleTimeout: aws.Long(1), // Required
			},
			CrossZoneLoadBalancing: &elb.CrossZoneLoadBalancing{
				Enabled: aws.Boolean(true), // Required
			},
		},
		LoadBalancerName: aws.String("AccessPointName"), // Required
	}
	resp, err := svc.ModifyLoadBalancerAttributes(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) ModifyLoadBalancerAttributesRequest 

func (c *ELB) ModifyLoadBalancerAttributesRequest(input *ModifyLoadBalancerAttributesInput) (req *aws.Request, output *ModifyLoadBalancerAttributesOutput)

ModifyLoadBalancerAttributesRequest generates a request for the ModifyLoadBalancerAttributes operation.

func (*ELB) RegisterInstancesWithLoadBalancer 

func (c *ELB) RegisterInstancesWithLoadBalancer(input *RegisterInstancesWithLoadBalancerInput) (output *RegisterInstancesWithLoadBalancerOutput, err error)

Adds new instances to the load balancer. 

Once the instance is registered, it starts receiving traffic and requests

from the load balancer. Any instance that is not in any of the Availability Zones registered for the load balancer will be moved to the OutOfService state. It will move to the InService state when the Availability Zone is added to the load balancer.

When an instance registered with a load balancer is stopped and then restarted, the IP addresses associated with the instance changes. Elastic Load Balancing cannot recognize the new IP address, which prevents it from routing traffic to the instances. We recommend that you de-register your Amazon EC2 instances from your load balancer after you stop your instance, and then register the load balancer with your instance after you've restarted. To de-register your instances from load balancer, use DeregisterInstancesFromLoadBalancer action.

For more information, see De-register and Register Amazon EC2 Instances (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/US_DeReg_Reg_Instances.html) in the Elastic Load Balancing Developer Guide. 

In order for this call to be successful, you must provide the same account

credentials as those that were used to create the load balancer. Completion of this API does not guarantee that operation has completed. Rather, it means that the request has been registered and the changes will happen shortly. 

You can use DescribeLoadBalancers or DescribeInstanceHealth action to check

the state of the newly registered instances.

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.RegisterInstancesWithLoadBalancerInput{
		Instances: []*elb.Instance{ // Required
			&elb.Instance{ // Required
				InstanceID: aws.String("InstanceId"),
			},
			// More values...
		},
		LoadBalancerName: aws.String("AccessPointName"), // Required
	}
	resp, err := svc.RegisterInstancesWithLoadBalancer(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) RegisterInstancesWithLoadBalancerRequest 

func (c *ELB) RegisterInstancesWithLoadBalancerRequest(input *RegisterInstancesWithLoadBalancerInput) (req *aws.Request, output *RegisterInstancesWithLoadBalancerOutput)

RegisterInstancesWithLoadBalancerRequest generates a request for the RegisterInstancesWithLoadBalancer operation.

func (*ELB) RemoveTags 

func (c *ELB) RemoveTags(input *RemoveTagsInput) (output *RemoveTagsOutput, err error)

Removes one or more tags from the specified load balancer.

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.RemoveTagsInput{
		LoadBalancerNames: []*string{ // Required
			aws.String("AccessPointName"), // Required
			// More values...
		},
		Tags: []*elb.TagKeyOnly{ // Required
			&elb.TagKeyOnly{ // Required
				Key: aws.String("TagKey"),
			},
			// More values...
		},
	}
	resp, err := svc.RemoveTags(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) RemoveTagsRequest 

func (c *ELB) RemoveTagsRequest(input *RemoveTagsInput) (req *aws.Request, output *RemoveTagsOutput)

RemoveTagsRequest generates a request for the RemoveTags operation.

func (*ELB) SetLoadBalancerListenerSSLCertificate 

func (c *ELB) SetLoadBalancerListenerSSLCertificate(input *SetLoadBalancerListenerSSLCertificateInput) (output *SetLoadBalancerListenerSSLCertificateOutput, err error)

Sets the certificate that terminates the specified listener's SSL connections. The specified certificate replaces any prior certificate that was used on the same load balancer and port.

For more information on updating your SSL certificate, see Updating an SSL Certificate for a Load Balancer (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/US_UpdatingLoadBalancerSSL.html) in the Elastic Load Balancing Developer Guide.

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.SetLoadBalancerListenerSSLCertificateInput{
		LoadBalancerName: aws.String("AccessPointName"),  // Required
		LoadBalancerPort: aws.Long(1),                    // Required
		SSLCertificateID: aws.String("SSLCertificateId"), // Required
	}
	resp, err := svc.SetLoadBalancerListenerSSLCertificate(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) SetLoadBalancerListenerSSLCertificateRequest 

func (c *ELB) SetLoadBalancerListenerSSLCertificateRequest(input *SetLoadBalancerListenerSSLCertificateInput) (req *aws.Request, output *SetLoadBalancerListenerSSLCertificateOutput)

SetLoadBalancerListenerSSLCertificateRequest generates a request for the SetLoadBalancerListenerSSLCertificate operation.

func (*ELB) SetLoadBalancerPoliciesForBackendServer 

func (c *ELB) SetLoadBalancerPoliciesForBackendServer(input *SetLoadBalancerPoliciesForBackendServerInput) (output *SetLoadBalancerPoliciesForBackendServerOutput, err error)

Replaces the current set of policies associated with a port on which the back-end server is listening with a new set of policies. After the policies have been created using CreateLoadBalancerPolicy, they can be applied here as a list. At this time, only the back-end server authentication policy type can be applied to the back-end ports; this policy type is composed of multiple public key policies. 

The SetLoadBalancerPoliciesForBackendServer replaces the current set of

policies associated with the specified instance port. Every time you use this action to enable the policies, use the PolicyNames parameter to list all the policies you want to enable. 

You can use DescribeLoadBalancers or DescribeLoadBalancerPolicies action

to verify that the policy has been associated with the back-end server.

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.SetLoadBalancerPoliciesForBackendServerInput{
		InstancePort:     aws.Long(1),                   // Required
		LoadBalancerName: aws.String("AccessPointName"), // Required
		PolicyNames: []*string{ // Required
			aws.String("PolicyName"), // Required
			// More values...
		},
	}
	resp, err := svc.SetLoadBalancerPoliciesForBackendServer(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) SetLoadBalancerPoliciesForBackendServerRequest 

func (c *ELB) SetLoadBalancerPoliciesForBackendServerRequest(input *SetLoadBalancerPoliciesForBackendServerInput) (req *aws.Request, output *SetLoadBalancerPoliciesForBackendServerOutput)

SetLoadBalancerPoliciesForBackendServerRequest generates a request for the SetLoadBalancerPoliciesForBackendServer operation.

func (*ELB) SetLoadBalancerPoliciesOfListener 

func (c *ELB) SetLoadBalancerPoliciesOfListener(input *SetLoadBalancerPoliciesOfListenerInput) (output *SetLoadBalancerPoliciesOfListenerOutput, err error)

Associates, updates, or disables a policy with a listener on the load balancer. You can associate multiple policies with a listener.

Example 
package main

import (
	"fmt"

	"github.com/datacratic/aws-sdk-go/aws"
	"github.com/datacratic/aws-sdk-go/aws/awsutil"
	"github.com/datacratic/aws-sdk-go/service/elb"
)

func main() {
	svc := elb.New(nil)

	params := &elb.SetLoadBalancerPoliciesOfListenerInput{
		LoadBalancerName: aws.String("AccessPointName"), // Required
		LoadBalancerPort: aws.Long(1),                   // Required
		PolicyNames: []*string{ // Required
			aws.String("PolicyName"), // Required
			// More values...
		},
	}
	resp, err := svc.SetLoadBalancerPoliciesOfListener(params)

	if awserr := aws.Error(err); awserr != nil {
		// A service error occurred.
		fmt.Println("Error:", awserr.Code, awserr.Message)
	} else if err != nil {
		// A non-service error occurred.
		panic(err)
	}

	// Pretty-print the response data.
	fmt.Println(awsutil.StringValue(resp))
}

Output:

func (*ELB) SetLoadBalancerPoliciesOfListenerRequest 

func (c *ELB) SetLoadBalancerPoliciesOfListenerRequest(input *SetLoadBalancerPoliciesOfListenerInput) (req *aws.Request, output *SetLoadBalancerPoliciesOfListenerOutput)

SetLoadBalancerPoliciesOfListenerRequest generates a request for the SetLoadBalancerPoliciesOfListener operation.

type EnableAvailabilityZonesForLoadBalancerInput 

type EnableAvailabilityZonesForLoadBalancerInput struct {
	// A list of new Availability Zones for the load balancer. Each Availability
	// Zone must be in the same region as the load balancer.
	AvailabilityZones []*string `type:"list" required:"true"`

	// The name associated with the load balancer.
	LoadBalancerName *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

The input for the EnableAvailabilityZonesForLoadBalancer action.

type EnableAvailabilityZonesForLoadBalancerOutput 

type EnableAvailabilityZonesForLoadBalancerOutput struct {
	// An updated list of Availability Zones for the load balancer.
	AvailabilityZones []*string `type:"list"`
	// contains filtered or unexported fields
}

The output for the EnableAvailabilityZonesForLoadBalancer action.

type HealthCheck 

type HealthCheck struct {
	// Specifies the number of consecutive health probe successes required before
	// moving the instance to the Healthy state.
	HealthyThreshold *int64 `type:"integer" required:"true"`

	// Specifies the approximate interval, in seconds, between health checks of
	// an individual instance.
	Interval *int64 `type:"integer" required:"true"`

	// Specifies the instance being checked. 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.
	Target *string `type:"string" required:"true"`

	// 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.
	Timeout *int64 `type:"integer" required:"true"`

	// Specifies the number of consecutive health probe failures required before
	// moving the instance to the Unhealthy state.
	UnhealthyThreshold *int64 `type:"integer" required:"true"`
	// contains filtered or unexported fields
}

The HealthCheck data type.

type Instance 

type Instance struct {
	// Provides an EC2 instance ID.
	InstanceID *string `locationName:"InstanceId" type:"string"`
	// contains filtered or unexported fields
}

The Instance data type.

type InstanceState 

type InstanceState struct {
	// Provides a description of the instance state.
	Description *string `type:"string"`

	// Provides an EC2 instance ID.
	InstanceID *string `locationName:"InstanceId" type:"string"`

	// Provides information about the cause of OutOfService instances. Specifically,
	// it indicates whether the cause is Elastic Load Balancing or the instance
	// behind the load balancer.
	//
	// Valid value: ELB|Instance|N/A
	ReasonCode *string `type:"string"`

	// Specifies the current state of the instance.
	//
	// Valid value: InService|OutOfService|Unknown
	State *string `type:"string"`
	// contains filtered or unexported fields
}

The InstanceState data type.

type LBCookieStickinessPolicy 

type LBCookieStickinessPolicy struct {
	// The time period in seconds after which the cookie should be considered stale.
	// Not specifying this parameter indicates that the stickiness session will
	// last for the duration of the browser session.
	CookieExpirationPeriod *int64 `type:"long"`

	// The name for the policy being created. The name must be unique within the
	// set of policies for this load balancer.
	PolicyName *string `type:"string"`
	// contains filtered or unexported fields
}

The LBCookieStickinessPolicy data type.

type Listener 

type Listener struct {
	// Specifies the TCP port on which the instance server is listening. This property
	// cannot be modified for the life of the load balancer.
	InstancePort *int64 `type:"integer" required:"true"`

	// 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 load balancer.
	//
	//  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.
	InstanceProtocol *string `type:"string"`

	// Specifies the external load balancer port number. This property cannot be
	// modified for the life of the load balancer.
	LoadBalancerPort *int64 `type:"integer" required:"true"`

	// Specifies the load balancer transport protocol to use for routing - HTTP,
	// HTTPS, TCP or SSL. This property cannot be modified for the life of the load
	// balancer.
	Protocol *string `type:"string" required:"true"`

	// The ARN string of the server certificate. To get the ARN of the server certificate,
	// call the AWS Identity and Access Management UploadServerCertificate  (http://docs.aws.amazon.com/IAM/latest/APIReference/index.html?API_UploadServerCertificate.html)
	// API.
	SSLCertificateID *string `locationName:"SSLCertificateId" type:"string"`
	// contains filtered or unexported fields
}

The Listener data type.

type ListenerDescription 

type ListenerDescription struct {
	// The Listener data type.
	Listener *Listener `type:"structure"`

	// A list of policies enabled for this listener. An empty list indicates that
	// no policies are enabled.
	PolicyNames []*string `type:"list"`
	// contains filtered or unexported fields
}

The ListenerDescription data type.

type LoadBalancerAttributes 

type LoadBalancerAttributes struct {
	// The name of the load balancer attribute. If enabled, the load balancer captures
	// detailed information of all the requests and delivers the information to
	// the Amazon S3 bucket that you specify.
	//
	// For more information, see Enable Access Logs (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/enable-access-logs.html).
	AccessLog *AccessLog `type:"structure"`

	AdditionalAttributes []*AdditionalAttribute `type:"list"`

	// The name of the load balancer attribute. If enabled, the load balancer allows
	// existing requests to complete before the load balancer shifts traffic away
	// from a deregistered or unhealthy back-end instance.
	//
	// For more information, see Enable Connection Draining (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/config-conn-drain.html).
	ConnectionDraining *ConnectionDraining `type:"structure"`

	// The name of the load balancer attribute.
	//
	// By default, Elastic Load Balancing maintains a 60-second idle connection
	// timeout for both front-end and back-end connections of your load balancer.
	// If the ConnectionSettings attribute is set, Elastic Load Balancing will allow
	// the connections to remain idle (no data is sent over the connection) for
	// the specified duration.
	//
	// For more information, see Configure Idle Connection Timeout (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/config-idle-timeout.html).
	ConnectionSettings *ConnectionSettings `type:"structure"`

	// The name of the load balancer attribute. If enabled, the load balancer routes
	// the request traffic evenly across all back-end instances regardless of the
	// Availability Zones.
	//
	// For more information, see Enable Cross-Zone Load Balancing (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/enable-disable-crosszone-lb.html).
	CrossZoneLoadBalancing *CrossZoneLoadBalancing `type:"structure"`
	// contains filtered or unexported fields
}

The LoadBalancerAttributes data type.

type LoadBalancerDescription 

type LoadBalancerDescription struct {
	// Specifies a list of Availability Zones.
	AvailabilityZones []*string `type:"list"`

	// Contains a list of back-end server descriptions.
	BackendServerDescriptions []*BackendServerDescription `type:"list"`

	// Provides the name of the Amazon Route 53 hosted zone that is associated with
	// the load balancer. For information on how to associate your load balancer
	// with a hosted zone, go to Using Domain Names With Elastic Load Balancing
	// (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/using-domain-names-with-elb.html)
	// in the Elastic Load Balancing Developer Guide.
	CanonicalHostedZoneName *string `type:"string"`

	// Provides the ID of the Amazon Route 53 hosted zone name that is associated
	// with the load balancer. For information on how to associate or disassociate
	// your load balancer with a hosted zone, go to Using Domain Names With Elastic
	// Load Balancing (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/using-domain-names-with-elb.html)
	// in the Elastic Load Balancing Developer Guide.
	CanonicalHostedZoneNameID *string `type:"string"`

	// Provides the date and time the load balancer was created.
	CreatedTime *time.Time `type:"timestamp" timestampFormat:"iso8601"`

	// Specifies the external DNS name associated with the load balancer.
	DNSName *string `type:"string"`

	// Specifies information regarding the various health probes conducted on the
	// load balancer.
	HealthCheck *HealthCheck `type:"structure"`

	// Provides a list of EC2 instance IDs for the load balancer.
	Instances []*Instance `type:"list"`

	// LoadBalancerPort, InstancePort, Protocol, InstanceProtocol, and PolicyNames
	// are returned in a list of tuples in the ListenerDescriptions element.
	ListenerDescriptions []*ListenerDescription `type:"list"`

	// Specifies the name associated with the load balancer.
	LoadBalancerName *string `type:"string"`

	// Provides a list of policies defined for the load balancer.
	Policies *Policies `type:"structure"`

	// Specifies the type of load balancer.
	//
	// If the Scheme is internet-facing, the load balancer has a publicly resolvable
	// DNS name that resolves to public IP addresses.
	//
	// If the Scheme is internal, the load balancer has a publicly resolvable DNS
	// name that resolves to private IP addresses.
	//
	//  This option is only available for load balancers attached to an Amazon
	// VPC.
	Scheme *string `type:"string"`

	// The security groups the load balancer is a member of (VPC only).
	SecurityGroups []*string `type:"list"`

	// The security group that you can use as part of your inbound rules for your
	// load balancer's back-end Amazon EC2 application instances. To only allow
	// traffic from load balancers, add a security group rule to your back end instance
	// that specifies this source security group as the inbound source.
	SourceSecurityGroup *SourceSecurityGroup `type:"structure"`

	// Provides a list of VPC subnet IDs for the load balancer.
	Subnets []*string `type:"list"`

	// Provides the ID of the VPC attached to the load balancer.
	VPCID *string `locationName:"VPCId" type:"string"`
	// contains filtered or unexported fields
}

Contains the result of a successful invocation of DescribeLoadBalancers.

type ModifyLoadBalancerAttributesInput 

type ModifyLoadBalancerAttributesInput struct {
	// Attributes of the load balancer.
	LoadBalancerAttributes *LoadBalancerAttributes `type:"structure" required:"true"`

	// The name of the load balancer.
	LoadBalancerName *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

The input for the ModifyLoadBalancerAttributes action.

type ModifyLoadBalancerAttributesOutput 

type ModifyLoadBalancerAttributesOutput struct {
	// The LoadBalancerAttributes data type.
	LoadBalancerAttributes *LoadBalancerAttributes `type:"structure"`

	// The name of the load balancer.
	LoadBalancerName *string `type:"string"`
	// contains filtered or unexported fields
}

The output for the ModifyLoadBalancerAttributes action.

type Policies 

type Policies struct {
	// A list of the AppCookieStickinessPolicy objects created with CreateAppCookieStickinessPolicy.
	AppCookieStickinessPolicies []*AppCookieStickinessPolicy `type:"list"`

	// A list of LBCookieStickinessPolicy objects created with CreateAppCookieStickinessPolicy.
	LBCookieStickinessPolicies []*LBCookieStickinessPolicy `type:"list"`

	// A list of policy names other than the stickiness policies.
	OtherPolicies []*string `type:"list"`
	// contains filtered or unexported fields
}

The policies data type.

type PolicyAttribute 

type PolicyAttribute struct {
	// The name of the attribute associated with the policy.
	AttributeName *string `type:"string"`

	// The value of the attribute associated with the policy.
	AttributeValue *string `type:"string"`
	// contains filtered or unexported fields
}

The PolicyAttribute data type. This data type contains a key/value pair that defines properties of a specific policy.

type PolicyAttributeDescription 

type PolicyAttributeDescription struct {
	// The name of the attribute associated with the policy.
	AttributeName *string `type:"string"`

	// The value of the attribute associated with the policy.
	AttributeValue *string `type:"string"`
	// contains filtered or unexported fields
}

The PolicyAttributeDescription data type. This data type is used to describe the attributes and values associated with a policy.

type PolicyAttributeTypeDescription 

type PolicyAttributeTypeDescription struct {
	// The name of the attribute associated with the policy type.
	AttributeName *string `type:"string"`

	// The type of attribute. For example, Boolean, Integer, etc.
	AttributeType *string `type:"string"`

	// The cardinality of the attribute. Valid Values:  ONE(1) : Single value required
	// ZERO_OR_ONE(0..1) : Up to one value can be supplied ZERO_OR_MORE(0..*) :
	// Optional. Multiple values are allowed ONE_OR_MORE(1..*0) : Required. Multiple
	// values are allowed
	Cardinality *string `type:"string"`

	// The default value of the attribute, if applicable.
	DefaultValue *string `type:"string"`

	// A human-readable description of the attribute.
	Description *string `type:"string"`
	// contains filtered or unexported fields
}

The PolicyAttributeTypeDescription data type. This data type is used to describe values that are acceptable for the policy attribute.

type PolicyDescription 

type PolicyDescription struct {
	// A list of policy attribute description structures.
	PolicyAttributeDescriptions []*PolicyAttributeDescription `type:"list"`

	// The name of the policy associated with the load balancer.
	PolicyName *string `type:"string"`

	// The name of the policy type associated with the load balancer.
	PolicyTypeName *string `type:"string"`
	// contains filtered or unexported fields
}

The PolicyDescription data type.

type PolicyTypeDescription 

type PolicyTypeDescription struct {
	// A human-readable description of the policy type.
	Description *string `type:"string"`

	// The description of the policy attributes associated with the load balancer
	// policies defined by the Elastic Load Balancing service.
	PolicyAttributeTypeDescriptions []*PolicyAttributeTypeDescription `type:"list"`

	// The name of the policy type.
	PolicyTypeName *string `type:"string"`
	// contains filtered or unexported fields
}

The PolicyTypeDescription data type.

type RegisterInstancesWithLoadBalancerInput 

type RegisterInstancesWithLoadBalancerInput struct {
	// A list of instance IDs that should be registered with the load balancer.
	Instances []*Instance `type:"list" required:"true"`

	// The name associated with the load balancer. The name must be unique within
	// your set of load balancers.
	LoadBalancerName *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

The input for the RegisterInstancesWithLoadBalancer action.

type RegisterInstancesWithLoadBalancerOutput 

type RegisterInstancesWithLoadBalancerOutput struct {
	// An updated list of instances for the load balancer.
	Instances []*Instance `type:"list"`
	// contains filtered or unexported fields
}

The output for the RegisterInstancesWithLoadBalancer action.

type RemoveTagsInput 

type RemoveTagsInput struct {
	// The name of the load balancer. You can specify a maximum of one load balancer
	// name.
	LoadBalancerNames []*string `type:"list" required:"true"`

	// A list of tag keys to remove.
	Tags []*TagKeyOnly `type:"list" required:"true"`
	// contains filtered or unexported fields
}

The input for the RemoveTags action.

type RemoveTagsOutput 

type RemoveTagsOutput struct {
	// contains filtered or unexported fields
}

The output for the RemoveTags action.

type SetLoadBalancerListenerSSLCertificateInput 

type SetLoadBalancerListenerSSLCertificateInput struct {
	// The name of the load balancer.
	LoadBalancerName *string `type:"string" required:"true"`

	// The port that uses the specified SSL certificate.
	LoadBalancerPort *int64 `type:"integer" required:"true"`

	// The Amazon Resource Number (ARN) of the SSL certificate chain to use. For
	// more information on SSL certificates, see  Managing Server Certificates (http://docs.aws.amazon.com/IAM/latest/UserGuide/ManagingServerCerts.html)
	// in the AWS Identity and Access Management User Guide.
	SSLCertificateID *string `locationName:"SSLCertificateId" type:"string" required:"true"`
	// contains filtered or unexported fields
}

The input for the SetLoadBalancerListenerSSLCertificate action.

type SetLoadBalancerListenerSSLCertificateOutput 

type SetLoadBalancerListenerSSLCertificateOutput struct {
	// contains filtered or unexported fields
}

The output for the SetLoadBalancerListenerSSLCertificate action.

type SetLoadBalancerPoliciesForBackendServerInput 

type SetLoadBalancerPoliciesForBackendServerInput struct {
	// The port number associated with the back-end server.
	InstancePort *int64 `type:"integer" required:"true"`

	// The mnemonic name associated with the load balancer. This name must be unique
	// within the set of your load balancers.
	LoadBalancerName *string `type:"string" required:"true"`

	// List of policy names to be set. If the list is empty, then all current polices
	// are removed from the back-end server.
	PolicyNames []*string `type:"list" required:"true"`
	// contains filtered or unexported fields
}

The input for the SetLoadBalancerPoliciesForBackendServer action.

type SetLoadBalancerPoliciesForBackendServerOutput 

type SetLoadBalancerPoliciesForBackendServerOutput struct {
	// contains filtered or unexported fields
}

The output for the SetLoadBalancerPoliciesForBackendServer action.

type SetLoadBalancerPoliciesOfListenerInput 

type SetLoadBalancerPoliciesOfListenerInput struct {
	// The name of the load balancer.
	LoadBalancerName *string `type:"string" required:"true"`

	// The external port of the load balancer to associate the policy.
	LoadBalancerPort *int64 `type:"integer" required:"true"`

	// List of policies to be associated with the listener. If the list is empty,
	// the current policy is removed from the listener.
	PolicyNames []*string `type:"list" required:"true"`
	// contains filtered or unexported fields
}

The input for the SetLoadBalancerPoliciesOfListener action.

type SetLoadBalancerPoliciesOfListenerOutput 

type SetLoadBalancerPoliciesOfListenerOutput struct {
	// contains filtered or unexported fields
}

The output for the SetLoadBalancerPoliciesOfListener action.

type SourceSecurityGroup 

type SourceSecurityGroup struct {
	// Name of the source security group. Use this value for the --source-group
	// parameter of the ec2-authorize command in the Amazon EC2 command line tool.
	GroupName *string `type:"string"`

	// Owner of the source security group. Use this value for the --source-group-user
	// parameter of the ec2-authorize command in the Amazon EC2 command line tool.
	OwnerAlias *string `type:"string"`
	// contains filtered or unexported fields
}

This data type is used as a response element in the DescribeLoadBalancers action. For information about Elastic Load Balancing security groups, go to Using Security Groups With Elastic Load Balancing (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/elb-security-features.html#using-elb-security-groups) in the Elastic Load Balancing Developer Guide.

type Tag 

type Tag struct {
	// The key of the tag.
	Key *string `type:"string" required:"true"`

	// The value of the tag.
	Value *string `type:"string"`
	// contains filtered or unexported fields
}

Metadata assigned to a load balancer consisting of key-value pair.

For more information, see Tagging (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/TerminologyandKeyConcepts.html#tagging-elb) in the Elastic Load Balancing Developer Guide.

type TagDescription 

type TagDescription struct {
	// The name of the load balancer.
	LoadBalancerName *string `type:"string"`

	// List of tags associated with the load balancer.
	Tags []*Tag `type:"list"`
	// contains filtered or unexported fields
}

The descriptions of all the tags associated with load balancer.

type TagKeyOnly 

type TagKeyOnly struct {
	// The name of the key.
	Key *string `type:"string"`
	// contains filtered or unexported fields
}

The key of a tag to be removed.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.