slb

Documentation

Index

• Constants
• type Slb
  • func ExtraNew(info *utils.UrlInfo, p client.ConfigProvider, cfgs ...*aws.Config) *Slb
  • func New(p client.ConfigProvider, cfgs ...*aws.Config) *Slb
  • func SdkNew(p client.ConfigProvider, cfgs *ksc.Config, info ...*utils.UrlInfo) *Slb
  • func (c *Slb) AssociateLoadBalancerAcl(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) AssociateLoadBalancerAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) AssociateLoadBalancerAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) ConfigureHealthCheck(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) ConfigureHealthCheckRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) ConfigureHealthCheckWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) CreateListeners(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) CreateListenersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) CreateListenersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) CreateLoadBalancer(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) CreateLoadBalancerAcl(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) CreateLoadBalancerAclEntry(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) CreateLoadBalancerAclEntryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) CreateLoadBalancerAclEntryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) CreateLoadBalancerAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) CreateLoadBalancerAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) CreateLoadBalancerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) CreateLoadBalancerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DeleteHealthCheck(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DeleteHealthCheckRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DeleteHealthCheckWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DeleteListeners(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DeleteListenersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DeleteListenersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DeleteLoadBalancer(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DeleteLoadBalancerAcl(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DeleteLoadBalancerAclEntry(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DeleteLoadBalancerAclEntryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DeleteLoadBalancerAclEntryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DeleteLoadBalancerAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DeleteLoadBalancerAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DeleteLoadBalancerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DeleteLoadBalancerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DeregisterInstancesFromListener(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DeregisterInstancesFromListenerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DeregisterInstancesFromListenerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DescribeHealthChecks(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DescribeHealthChecksRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DescribeHealthChecksWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DescribeInstancesWithListener(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DescribeInstancesWithListenerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DescribeInstancesWithListenerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DescribeListeners(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DescribeListenersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DescribeListenersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DescribeLoadBalancerAcls(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DescribeLoadBalancerAclsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DescribeLoadBalancerAclsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DescribeLoadBalancers(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DescribeLoadBalancersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DescribeLoadBalancersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) DisassociateLoadBalancerAcl(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) DisassociateLoadBalancerAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) DisassociateLoadBalancerAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) ModifyHealthCheck(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) ModifyHealthCheckRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) ModifyHealthCheckWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) ModifyInstancesWithListener(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) ModifyInstancesWithListenerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) ModifyInstancesWithListenerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) ModifyListeners(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) ModifyListenersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) ModifyListenersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) ModifyLoadBalancer(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) ModifyLoadBalancerAcl(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) ModifyLoadBalancerAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) ModifyLoadBalancerAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) ModifyLoadBalancerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) ModifyLoadBalancerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Slb) RegisterInstancesWithListener(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Slb) RegisterInstancesWithListenerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Slb) RegisterInstancesWithListenerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

Constants

const (
	ServiceName = "slb"       // Name of service.
	EndpointsID = ServiceName // ID to lookup a service endpoint with.
	ServiceID   = "slb"       // ServiceID is a unique identifer of a specific service.
)

Service information constants

Types

type Slb

type Slb struct {
	*client.Client
}

Slb provides the API operation methods for making requests to slb. See this package's package overview docs for details on the service.

Slb methods are safe to use concurrently. It is not safe to modify mutate any of the struct's properties though.

func ExtraNew

func ExtraNew(info *utils.UrlInfo, p client.ConfigProvider, cfgs ...*aws.Config) *Slb

extraNew create int can support ssl or region locate set

func New

func New(p client.ConfigProvider, cfgs ...*aws.Config) *Slb

New creates a new instance of the Slb client with a session. If additional configuration is needed for the client instance use the optional ksc.Config parameter to add your extra config.

Example:

// Create a Slb client from just a session.
svc := slb.New(mySession)

// Create a Slb client with additional configuration
svc := slb.New(mySession, aws.NewConfig().WithRegion("us-west-2"))

func SdkNew

func SdkNew(p client.ConfigProvider, cfgs *ksc.Config, info ...*utils.UrlInfo) *Slb

SdkNew create int can support ssl or region locate set

func (*Slb) AssociateLoadBalancerAcl

func (c *Slb) AssociateLoadBalancerAcl(input *map[string]interface{}) (*map[string]interface{}, error)

AssociateLoadBalancerAcl API operation for slb.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for slb's API operation AssociateLoadBalancerAcl for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/AssociateLoadBalancerAcl

func (*Slb) AssociateLoadBalancerAclRequest

func (c *Slb) AssociateLoadBalancerAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

AssociateLoadBalancerAclRequest generates a "ksc/request.Request" representing the client's request for the AssociateLoadBalancerAcl operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See AssociateLoadBalancerAcl for more information on using the AssociateLoadBalancerAcl API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the AssociateLoadBalancerAclRequest method.
req, resp := client.AssociateLoadBalancerAclRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/AssociateLoadBalancerAcl

func (*Slb) AssociateLoadBalancerAclWithContext

func (c *Slb) AssociateLoadBalancerAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

AssociateLoadBalancerAclWithContext is the same as AssociateLoadBalancerAcl with the addition of the ability to pass a context and additional request options.

See AssociateLoadBalancerAcl for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Slb) ConfigureHealthCheck

func (c *Slb) ConfigureHealthCheck(input *map[string]interface{}) (*map[string]interface{}, error)

ConfigureHealthCheck API operation for slb.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for slb's API operation ConfigureHealthCheck for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ConfigureHealthCheck

func (*Slb) ConfigureHealthCheckRequest

func (c *Slb) ConfigureHealthCheckRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ConfigureHealthCheckRequest generates a "ksc/request.Request" representing the client's request for the ConfigureHealthCheck operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ConfigureHealthCheck for more information on using the ConfigureHealthCheck API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ConfigureHealthCheckRequest method.
req, resp := client.ConfigureHealthCheckRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ConfigureHealthCheck

func (*Slb) ConfigureHealthCheckWithContext

func (c *Slb) ConfigureHealthCheckWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ConfigureHealthCheckWithContext is the same as ConfigureHealthCheck with the addition of the ability to pass a context and additional request options.

See ConfigureHealthCheck for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Slb) CreateListeners

func (c *Slb) CreateListeners(input *map[string]interface{}) (*map[string]interface{}, error)

CreateListeners API operation for slb.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for slb's API operation CreateListeners for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/CreateListeners

func (*Slb) CreateListenersRequest

func (c *Slb) CreateListenersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateListenersRequest generates a "ksc/request.Request" representing the client's request for the CreateListeners operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateListeners for more information on using the CreateListeners API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateListenersRequest method.
req, resp := client.CreateListenersRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/CreateListeners

func (*Slb) CreateListenersWithContext

func (c *Slb) CreateListenersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateListenersWithContext is the same as CreateListeners with the addition of the ability to pass a context and additional request options.

See CreateListeners for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Slb) CreateLoadBalancer

func (c *Slb) CreateLoadBalancer(input *map[string]interface{}) (*map[string]interface{}, error)

CreateLoadBalancer API operation for slb.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for slb's API operation CreateLoadBalancer for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/CreateLoadBalancer

func (*Slb) CreateLoadBalancerAcl

func (c *Slb) CreateLoadBalancerAcl(input *map[string]interface{}) (*map[string]interface{}, error)

CreateLoadBalancerAcl API operation for slb.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for slb's API operation CreateLoadBalancerAcl for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/CreateLoadBalancerAcl

func (*Slb) CreateLoadBalancerAclEntry

func (c *Slb) CreateLoadBalancerAclEntry(input *map[string]interface{}) (*map[string]interface{}, error)

CreateLoadBalancerAclEntry API operation for slb.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for slb's API operation CreateLoadBalancerAclEntry for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/CreateLoadBalancerAclEntry

func (*Slb) CreateLoadBalancerAclEntryRequest

func (c *Slb) CreateLoadBalancerAclEntryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateLoadBalancerAclEntryRequest generates a "ksc/request.Request" representing the client's request for the CreateLoadBalancerAclEntry operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateLoadBalancerAclEntry for more information on using the CreateLoadBalancerAclEntry API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateLoadBalancerAclEntryRequest method.
req, resp := client.CreateLoadBalancerAclEntryRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/CreateLoadBalancerAclEntry

func (*Slb) CreateLoadBalancerAclEntryWithContext

func (c *Slb) CreateLoadBalancerAclEntryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateLoadBalancerAclEntryWithContext is the same as CreateLoadBalancerAclEntry with the addition of the ability to pass a context and additional request options.

See CreateLoadBalancerAclEntry for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Slb) CreateLoadBalancerAclRequest

func (c *Slb) CreateLoadBalancerAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateLoadBalancerAclRequest generates a "ksc/request.Request" representing the client's request for the CreateLoadBalancerAcl operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateLoadBalancerAcl for more information on using the CreateLoadBalancerAcl API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateLoadBalancerAclRequest method.
req, resp := client.CreateLoadBalancerAclRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/CreateLoadBalancerAcl

func (*Slb) CreateLoadBalancerAclWithContext

func (c *Slb) CreateLoadBalancerAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateLoadBalancerAclWithContext is the same as CreateLoadBalancerAcl with the addition of the ability to pass a context and additional request options.

See CreateLoadBalancerAcl for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Slb) CreateLoadBalancerRequest

func (c *Slb) CreateLoadBalancerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateLoadBalancerRequest generates a "ksc/request.Request" representing the client's request for the CreateLoadBalancer operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateLoadBalancer for more information on using the CreateLoadBalancer API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateLoadBalancerRequest method.
req, resp := client.CreateLoadBalancerRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/CreateLoadBalancer

func (*Slb) CreateLoadBalancerWithContext

func (c *Slb) CreateLoadBalancerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateLoadBalancerWithContext is the same as CreateLoadBalancer with the addition of the ability to pass a context and additional request options.

See CreateLoadBalancer for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Slb) DeleteHealthCheck

func (c *Slb) DeleteHealthCheck(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteHealthCheck API operation for slb.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for slb's API operation DeleteHealthCheck for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteHealthCheck

func (*Slb) DeleteHealthCheckRequest

func (c *Slb) DeleteHealthCheckRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteHealthCheckRequest generates a "ksc/request.Request" representing the client's request for the DeleteHealthCheck operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteHealthCheck for more information on using the DeleteHealthCheck API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteHealthCheckRequest method.
req, resp := client.DeleteHealthCheckRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteHealthCheck

func (*Slb) DeleteHealthCheckWithContext

func (c *Slb) DeleteHealthCheckWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteHealthCheckWithContext is the same as DeleteHealthCheck with the addition of the ability to pass a context and additional request options.

See DeleteHealthCheck for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Slb) DeleteListeners

func (c *Slb) DeleteListeners(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteListeners API operation for slb.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for slb's API operation DeleteListeners for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteListeners

func (*Slb) DeleteListenersRequest

func (c *Slb) DeleteListenersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteListenersRequest generates a "ksc/request.Request" representing the client's request for the DeleteListeners operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteListeners for more information on using the DeleteListeners API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteListenersRequest method.
req, resp := client.DeleteListenersRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteListeners

func (*Slb) DeleteListenersWithContext

func (c *Slb) DeleteListenersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteListenersWithContext is the same as DeleteListeners with the addition of the ability to pass a context and additional request options.

See DeleteListeners for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Slb) DeleteLoadBalancer

func (c *Slb) DeleteLoadBalancer(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteLoadBalancer API operation for slb.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for slb's API operation DeleteLoadBalancer for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteLoadBalancer

func (*Slb) DeleteLoadBalancerAcl

func (c *Slb) DeleteLoadBalancerAcl(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteLoadBalancerAcl API operation for slb.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for slb's API operation DeleteLoadBalancerAcl for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteLoadBalancerAcl

func (*Slb) DeleteLoadBalancerAclEntry

func (c *Slb) DeleteLoadBalancerAclEntry(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteLoadBalancerAclEntry API operation for slb.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for slb's API operation DeleteLoadBalancerAclEntry for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteLoadBalancerAclEntry

func (*Slb) DeleteLoadBalancerAclEntryRequest

func (c *Slb) DeleteLoadBalancerAclEntryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteLoadBalancerAclEntryRequest generates a "ksc/request.Request" representing the client's request for the DeleteLoadBalancerAclEntry operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteLoadBalancerAclEntry for more information on using the DeleteLoadBalancerAclEntry API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteLoadBalancerAclEntryRequest method.
req, resp := client.DeleteLoadBalancerAclEntryRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteLoadBalancerAclEntry

func (*Slb) DeleteLoadBalancerAclEntryWithContext

func (c *Slb) DeleteLoadBalancerAclEntryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteLoadBalancerAclEntryWithContext is the same as DeleteLoadBalancerAclEntry with the addition of the ability to pass a context and additional request options.

See DeleteLoadBalancerAclEntry for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Slb) DeleteLoadBalancerAclRequest

func (c *Slb) DeleteLoadBalancerAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteLoadBalancerAclRequest generates a "ksc/request.Request" representing the client's request for the DeleteLoadBalancerAcl operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteLoadBalancerAcl for more information on using the DeleteLoadBalancerAcl API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteLoadBalancerAclRequest method.
req, resp := client.DeleteLoadBalancerAclRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteLoadBalancerAcl

func (*Slb) DeleteLoadBalancerAclWithContext

func (c *Slb) DeleteLoadBalancerAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteLoadBalancerAclWithContext is the same as DeleteLoadBalancerAcl with the addition of the ability to pass a context and additional request options.

See DeleteLoadBalancerAcl for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Slb) DeleteLoadBalancerRequest

func (c *Slb) DeleteLoadBalancerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteLoadBalancerRequest generates a "ksc/request.Request" representing the client's request for the DeleteLoadBalancer operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteLoadBalancer for more information on using the DeleteLoadBalancer API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteLoadBalancerRequest method.
req, resp := client.DeleteLoadBalancerRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeleteLoadBalancer

func (*Slb) DeleteLoadBalancerWithContext

func (c *Slb) DeleteLoadBalancerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteLoadBalancerWithContext is the same as DeleteLoadBalancer with the addition of the ability to pass a context and additional request options.

See DeleteLoadBalancer for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Slb) DeregisterInstancesFromListener

func (c *Slb) DeregisterInstancesFromListener(input *map[string]interface{}) (*map[string]interface{}, error)

DeregisterInstancesFromListener API operation for slb.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for slb's API operation DeregisterInstancesFromListener for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeregisterInstancesFromListener

func (*Slb) DeregisterInstancesFromListenerRequest

func (c *Slb) DeregisterInstancesFromListenerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeregisterInstancesFromListenerRequest generates a "ksc/request.Request" representing the client's request for the DeregisterInstancesFromListener operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeregisterInstancesFromListener for more information on using the DeregisterInstancesFromListener API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeregisterInstancesFromListenerRequest method.
req, resp := client.DeregisterInstancesFromListenerRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DeregisterInstancesFromListener

func (*Slb) DeregisterInstancesFromListenerWithContext

func (c *Slb) DeregisterInstancesFromListenerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeregisterInstancesFromListenerWithContext is the same as DeregisterInstancesFromListener with the addition of the ability to pass a context and additional request options.

See DeregisterInstancesFromListener for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Slb) DescribeHealthChecks

func (c *Slb) DescribeHealthChecks(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeHealthChecks API operation for slb.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for slb's API operation DescribeHealthChecks for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeHealthChecks

func (*Slb) DescribeHealthChecksRequest

func (c *Slb) DescribeHealthChecksRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeHealthChecksRequest generates a "ksc/request.Request" representing the client's request for the DescribeHealthChecks operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeHealthChecks for more information on using the DescribeHealthChecks API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeHealthChecksRequest method.
req, resp := client.DescribeHealthChecksRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeHealthChecks

func (*Slb) DescribeHealthChecksWithContext

func (c *Slb) DescribeHealthChecksWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeHealthChecksWithContext is the same as DescribeHealthChecks with the addition of the ability to pass a context and additional request options.

See DescribeHealthChecks for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Slb) DescribeInstancesWithListener

func (c *Slb) DescribeInstancesWithListener(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeInstancesWithListener API operation for slb.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for slb's API operation DescribeInstancesWithListener for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeInstancesWithListener

func (*Slb) DescribeInstancesWithListenerRequest

func (c *Slb) DescribeInstancesWithListenerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeInstancesWithListenerRequest generates a "ksc/request.Request" representing the client's request for the DescribeInstancesWithListener operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeInstancesWithListener for more information on using the DescribeInstancesWithListener API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeInstancesWithListenerRequest method.
req, resp := client.DescribeInstancesWithListenerRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeInstancesWithListener

func (*Slb) DescribeInstancesWithListenerWithContext

func (c *Slb) DescribeInstancesWithListenerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeInstancesWithListenerWithContext is the same as DescribeInstancesWithListener with the addition of the ability to pass a context and additional request options.

See DescribeInstancesWithListener for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Slb) DescribeListeners

func (c *Slb) DescribeListeners(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeListeners API operation for slb.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for slb's API operation DescribeListeners for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeListeners

func (*Slb) DescribeListenersRequest

func (c *Slb) DescribeListenersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeListenersRequest generates a "ksc/request.Request" representing the client's request for the DescribeListeners operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeListeners for more information on using the DescribeListeners API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeListenersRequest method.
req, resp := client.DescribeListenersRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeListeners

func (*Slb) DescribeListenersWithContext

func (c *Slb) DescribeListenersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeListenersWithContext is the same as DescribeListeners with the addition of the ability to pass a context and additional request options.

See DescribeListeners for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Slb) DescribeLoadBalancerAcls

func (c *Slb) DescribeLoadBalancerAcls(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeLoadBalancerAcls API operation for slb.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for slb's API operation DescribeLoadBalancerAcls for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeLoadBalancerAcls

func (*Slb) DescribeLoadBalancerAclsRequest

func (c *Slb) DescribeLoadBalancerAclsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeLoadBalancerAclsRequest generates a "ksc/request.Request" representing the client's request for the DescribeLoadBalancerAcls operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeLoadBalancerAcls for more information on using the DescribeLoadBalancerAcls API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeLoadBalancerAclsRequest method.
req, resp := client.DescribeLoadBalancerAclsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeLoadBalancerAcls

func (*Slb) DescribeLoadBalancerAclsWithContext

func (c *Slb) DescribeLoadBalancerAclsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeLoadBalancerAclsWithContext is the same as DescribeLoadBalancerAcls with the addition of the ability to pass a context and additional request options.

See DescribeLoadBalancerAcls for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Slb) DescribeLoadBalancers

func (c *Slb) DescribeLoadBalancers(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeLoadBalancers API operation for slb.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for slb's API operation DescribeLoadBalancers for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeLoadBalancers

func (*Slb) DescribeLoadBalancersRequest

func (c *Slb) DescribeLoadBalancersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeLoadBalancersRequest generates a "ksc/request.Request" representing the client's request for the DescribeLoadBalancers operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeLoadBalancers for more information on using the DescribeLoadBalancers API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeLoadBalancersRequest method.
req, resp := client.DescribeLoadBalancersRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DescribeLoadBalancers

func (*Slb) DescribeLoadBalancersWithContext

func (c *Slb) DescribeLoadBalancersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeLoadBalancersWithContext is the same as DescribeLoadBalancers with the addition of the ability to pass a context and additional request options.

See DescribeLoadBalancers for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Slb) DisassociateLoadBalancerAcl

func (c *Slb) DisassociateLoadBalancerAcl(input *map[string]interface{}) (*map[string]interface{}, error)

DisassociateLoadBalancerAcl API operation for slb.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for slb's API operation DisassociateLoadBalancerAcl for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DisassociateLoadBalancerAcl

func (*Slb) DisassociateLoadBalancerAclRequest

func (c *Slb) DisassociateLoadBalancerAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DisassociateLoadBalancerAclRequest generates a "ksc/request.Request" representing the client's request for the DisassociateLoadBalancerAcl operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DisassociateLoadBalancerAcl for more information on using the DisassociateLoadBalancerAcl API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DisassociateLoadBalancerAclRequest method.
req, resp := client.DisassociateLoadBalancerAclRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/DisassociateLoadBalancerAcl

func (*Slb) DisassociateLoadBalancerAclWithContext

func (c *Slb) DisassociateLoadBalancerAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DisassociateLoadBalancerAclWithContext is the same as DisassociateLoadBalancerAcl with the addition of the ability to pass a context and additional request options.

See DisassociateLoadBalancerAcl for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Slb) ModifyHealthCheck

func (c *Slb) ModifyHealthCheck(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyHealthCheck API operation for slb.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for slb's API operation ModifyHealthCheck for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyHealthCheck

func (*Slb) ModifyHealthCheckRequest

func (c *Slb) ModifyHealthCheckRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ModifyHealthCheckRequest generates a "ksc/request.Request" representing the client's request for the ModifyHealthCheck operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ModifyHealthCheck for more information on using the ModifyHealthCheck API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ModifyHealthCheckRequest method.
req, resp := client.ModifyHealthCheckRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyHealthCheck

func (*Slb) ModifyHealthCheckWithContext

func (c *Slb) ModifyHealthCheckWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ModifyHealthCheckWithContext is the same as ModifyHealthCheck with the addition of the ability to pass a context and additional request options.

See ModifyHealthCheck for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Slb) ModifyInstancesWithListener

func (c *Slb) ModifyInstancesWithListener(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyInstancesWithListener API operation for slb.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for slb's API operation ModifyInstancesWithListener for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyInstancesWithListener

func (*Slb) ModifyInstancesWithListenerRequest

func (c *Slb) ModifyInstancesWithListenerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ModifyInstancesWithListenerRequest generates a "ksc/request.Request" representing the client's request for the ModifyInstancesWithListener operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ModifyInstancesWithListener for more information on using the ModifyInstancesWithListener API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ModifyInstancesWithListenerRequest method.
req, resp := client.ModifyInstancesWithListenerRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyInstancesWithListener

func (*Slb) ModifyInstancesWithListenerWithContext

func (c *Slb) ModifyInstancesWithListenerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ModifyInstancesWithListenerWithContext is the same as ModifyInstancesWithListener with the addition of the ability to pass a context and additional request options.

See ModifyInstancesWithListener for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Slb) ModifyListeners

func (c *Slb) ModifyListeners(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyListeners API operation for slb.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for slb's API operation ModifyListeners for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyListeners

func (*Slb) ModifyListenersRequest

func (c *Slb) ModifyListenersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ModifyListenersRequest generates a "ksc/request.Request" representing the client's request for the ModifyListeners operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ModifyListeners for more information on using the ModifyListeners API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ModifyListenersRequest method.
req, resp := client.ModifyListenersRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyListeners

func (*Slb) ModifyListenersWithContext

func (c *Slb) ModifyListenersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ModifyListenersWithContext is the same as ModifyListeners with the addition of the ability to pass a context and additional request options.

See ModifyListeners for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Slb) ModifyLoadBalancer

func (c *Slb) ModifyLoadBalancer(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyLoadBalancer API operation for slb.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for slb's API operation ModifyLoadBalancer for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyLoadBalancer

func (*Slb) ModifyLoadBalancerAcl

func (c *Slb) ModifyLoadBalancerAcl(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyLoadBalancerAcl API operation for slb.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for slb's API operation ModifyLoadBalancerAcl for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyLoadBalancerAcl

func (*Slb) ModifyLoadBalancerAclRequest

func (c *Slb) ModifyLoadBalancerAclRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ModifyLoadBalancerAclRequest generates a "ksc/request.Request" representing the client's request for the ModifyLoadBalancerAcl operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ModifyLoadBalancerAcl for more information on using the ModifyLoadBalancerAcl API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ModifyLoadBalancerAclRequest method.
req, resp := client.ModifyLoadBalancerAclRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyLoadBalancerAcl

func (*Slb) ModifyLoadBalancerAclWithContext

func (c *Slb) ModifyLoadBalancerAclWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ModifyLoadBalancerAclWithContext is the same as ModifyLoadBalancerAcl with the addition of the ability to pass a context and additional request options.

See ModifyLoadBalancerAcl for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Slb) ModifyLoadBalancerRequest

func (c *Slb) ModifyLoadBalancerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ModifyLoadBalancerRequest generates a "ksc/request.Request" representing the client's request for the ModifyLoadBalancer operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ModifyLoadBalancer for more information on using the ModifyLoadBalancer API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ModifyLoadBalancerRequest method.
req, resp := client.ModifyLoadBalancerRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/ModifyLoadBalancer

func (*Slb) ModifyLoadBalancerWithContext

func (c *Slb) ModifyLoadBalancerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ModifyLoadBalancerWithContext is the same as ModifyLoadBalancer with the addition of the ability to pass a context and additional request options.

See ModifyLoadBalancer for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Slb) RegisterInstancesWithListener

func (c *Slb) RegisterInstancesWithListener(input *map[string]interface{}) (*map[string]interface{}, error)

RegisterInstancesWithListener API operation for slb.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for slb's API operation RegisterInstancesWithListener for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/RegisterInstancesWithListener

func (*Slb) RegisterInstancesWithListenerRequest

func (c *Slb) RegisterInstancesWithListenerRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

RegisterInstancesWithListenerRequest generates a "ksc/request.Request" representing the client's request for the RegisterInstancesWithListener operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See RegisterInstancesWithListener for more information on using the RegisterInstancesWithListener API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the RegisterInstancesWithListenerRequest method.
req, resp := client.RegisterInstancesWithListenerRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/slb-2016-03-04/RegisterInstancesWithListener

func (*Slb) RegisterInstancesWithListenerWithContext

func (c *Slb) RegisterInstancesWithListenerWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

RegisterInstancesWithListenerWithContext is the same as RegisterInstancesWithListener with the addition of the ability to pass a context and additional request options.

See RegisterInstancesWithListener for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.