types

package
v0.28.0 Latest Latest
Warning

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

 Go to latest Published: Oct 26, 2020 License: Apache-2.0 Imports: 3 Imported by: 97

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ALPNPolicyNotSupportedException 

type ALPNPolicyNotSupportedException struct {
	Message *string
}

The specified ALPN policy is not supported.

func (*ALPNPolicyNotSupportedException) Error 

func (e *ALPNPolicyNotSupportedException) Error() string

func (*ALPNPolicyNotSupportedException) ErrorCode 

func (e *ALPNPolicyNotSupportedException) ErrorCode() string

func (*ALPNPolicyNotSupportedException) ErrorFault 

func (e *ALPNPolicyNotSupportedException) ErrorFault() smithy.ErrorFault

func (*ALPNPolicyNotSupportedException) ErrorMessage 

func (e *ALPNPolicyNotSupportedException) ErrorMessage() string

type Action 

type Action struct {

	// The type of action.
	//
	// This member is required.
	Type ActionTypeEnum

	// [HTTPS listeners] Information for using Amazon Cognito to authenticate users.
	// Specify only when Type is authenticate-cognito.
	AuthenticateCognitoConfig *AuthenticateCognitoActionConfig

	// [HTTPS listeners] Information about an identity provider that is compliant with
	// OpenID Connect (OIDC). Specify only when Type is authenticate-oidc.
	AuthenticateOidcConfig *AuthenticateOidcActionConfig

	// [Application Load Balancer] Information for creating an action that returns a
	// custom HTTP response. Specify only when Type is fixed-response.
	FixedResponseConfig *FixedResponseActionConfig

	// Information for creating an action that distributes requests among one or more
	// target groups. For Network Load Balancers, you can specify a single target
	// group. Specify only when Type is forward. If you specify both ForwardConfig and
	// TargetGroupArn, you can specify only one target group using ForwardConfig and it
	// must be the same target group specified in TargetGroupArn.
	ForwardConfig *ForwardActionConfig

	// The order for the action. This value is required for rules with multiple
	// actions. The action with the lowest value for order is performed first. The last
	// action to be performed must be one of the following types of actions: a forward,
	// fixed-response, or redirect.
	Order *int32

	// [Application Load Balancer] Information for creating a redirect action. Specify
	// only when Type is redirect.
	RedirectConfig *RedirectActionConfig

	// The Amazon Resource Name (ARN) of the target group. Specify only when Type is
	// forward and you want to route to a single target group. To route to one or more
	// target groups, use ForwardConfig instead.
	TargetGroupArn *string
}

Information about an action.

type ActionTypeEnum 

type ActionTypeEnum string
const (
	ActionTypeEnumForward              ActionTypeEnum = "forward"
	ActionTypeEnumAuthenticate_oidc    ActionTypeEnum = "authenticate-oidc"
	ActionTypeEnumAuthenticate_cognito ActionTypeEnum = "authenticate-cognito"
	ActionTypeEnumRedirect             ActionTypeEnum = "redirect"
	ActionTypeEnumFixed_response       ActionTypeEnum = "fixed-response"
)

Enum values for ActionTypeEnum

type AllocationIdNotFoundException 

type AllocationIdNotFoundException struct {
	Message *string
}

The specified allocation ID does not exist.

func (*AllocationIdNotFoundException) Error 

func (e *AllocationIdNotFoundException) Error() string

func (*AllocationIdNotFoundException) ErrorCode 

func (e *AllocationIdNotFoundException) ErrorCode() string

func (*AllocationIdNotFoundException) ErrorFault 

func (e *AllocationIdNotFoundException) ErrorFault() smithy.ErrorFault

func (*AllocationIdNotFoundException) ErrorMessage 

func (e *AllocationIdNotFoundException) ErrorMessage() string

type AuthenticateCognitoActionConditionalBehaviorEnum 

type AuthenticateCognitoActionConditionalBehaviorEnum string
const (
	AuthenticateCognitoActionConditionalBehaviorEnumDeny         AuthenticateCognitoActionConditionalBehaviorEnum = "deny"
	AuthenticateCognitoActionConditionalBehaviorEnumAllow        AuthenticateCognitoActionConditionalBehaviorEnum = "allow"
	AuthenticateCognitoActionConditionalBehaviorEnumAuthenticate AuthenticateCognitoActionConditionalBehaviorEnum = "authenticate"
)

Enum values for AuthenticateCognitoActionConditionalBehaviorEnum

type AuthenticateCognitoActionConfig 

type AuthenticateCognitoActionConfig struct {

	// The Amazon Resource Name (ARN) of the Amazon Cognito user pool.
	//
	// This member is required.
	UserPoolArn *string

	// The ID of the Amazon Cognito user pool client.
	//
	// This member is required.
	UserPoolClientId *string

	// The domain prefix or fully-qualified domain name of the Amazon Cognito user
	// pool.
	//
	// This member is required.
	UserPoolDomain *string

	// The query parameters (up to 10) to include in the redirect request to the
	// authorization endpoint.
	AuthenticationRequestExtraParams map[string]*string

	// The behavior if the user is not authenticated. The following are possible
	// values:
	//
	//     * deny - Return an HTTP 401 Unauthorized error.
	//
	//     * allow -
	// Allow the request to be forwarded to the target.
	//
	//     * authenticate - Redirect
	// the request to the IdP authorization endpoint. This is the default value.
	OnUnauthenticatedRequest AuthenticateCognitoActionConditionalBehaviorEnum

	// The set of user claims to be requested from the IdP. The default is openid. To
	// verify which scope values your IdP supports and how to separate multiple values,
	// see the documentation for your IdP.
	Scope *string

	// The name of the cookie used to maintain session information. The default is
	// AWSELBAuthSessionCookie.
	SessionCookieName *string

	// The maximum duration of the authentication session, in seconds. The default is
	// 604800 seconds (7 days).
	SessionTimeout *int64
}

Request parameters to use when integrating with Amazon Cognito to authenticate users.

type AuthenticateOidcActionConditionalBehaviorEnum 

type AuthenticateOidcActionConditionalBehaviorEnum string
const (
	AuthenticateOidcActionConditionalBehaviorEnumDeny         AuthenticateOidcActionConditionalBehaviorEnum = "deny"
	AuthenticateOidcActionConditionalBehaviorEnumAllow        AuthenticateOidcActionConditionalBehaviorEnum = "allow"
	AuthenticateOidcActionConditionalBehaviorEnumAuthenticate AuthenticateOidcActionConditionalBehaviorEnum = "authenticate"
)

Enum values for AuthenticateOidcActionConditionalBehaviorEnum

type AuthenticateOidcActionConfig 

type AuthenticateOidcActionConfig struct {

	// The authorization endpoint of the IdP. This must be a full URL, including the
	// HTTPS protocol, the domain, and the path.
	//
	// This member is required.
	AuthorizationEndpoint *string

	// The OAuth 2.0 client identifier.
	//
	// This member is required.
	ClientId *string

	// The OIDC issuer identifier of the IdP. This must be a full URL, including the
	// HTTPS protocol, the domain, and the path.
	//
	// This member is required.
	Issuer *string

	// The token endpoint of the IdP. This must be a full URL, including the HTTPS
	// protocol, the domain, and the path.
	//
	// This member is required.
	TokenEndpoint *string

	// The user info endpoint of the IdP. This must be a full URL, including the HTTPS
	// protocol, the domain, and the path.
	//
	// This member is required.
	UserInfoEndpoint *string

	// The query parameters (up to 10) to include in the redirect request to the
	// authorization endpoint.
	AuthenticationRequestExtraParams map[string]*string

	// The OAuth 2.0 client secret. This parameter is required if you are creating a
	// rule. If you are modifying a rule, you can omit this parameter if you set
	// UseExistingClientSecret to true.
	ClientSecret *string

	// The behavior if the user is not authenticated. The following are possible
	// values:
	//
	//     * deny - Return an HTTP 401 Unauthorized error.
	//
	//     * allow -
	// Allow the request to be forwarded to the target.
	//
	//     * authenticate - Redirect
	// the request to the IdP authorization endpoint. This is the default value.
	OnUnauthenticatedRequest AuthenticateOidcActionConditionalBehaviorEnum

	// The set of user claims to be requested from the IdP. The default is openid. To
	// verify which scope values your IdP supports and how to separate multiple values,
	// see the documentation for your IdP.
	Scope *string

	// The name of the cookie used to maintain session information. The default is
	// AWSELBAuthSessionCookie.
	SessionCookieName *string

	// The maximum duration of the authentication session, in seconds. The default is
	// 604800 seconds (7 days).
	SessionTimeout *int64

	// Indicates whether to use the existing client secret when modifying a rule. If
	// you are creating a rule, you can omit this parameter or set it to false.
	UseExistingClientSecret *bool
}

Request parameters when using an identity provider (IdP) that is compliant with OpenID Connect (OIDC) to authenticate users.

type AvailabilityZone 

type AvailabilityZone struct {

	// [Network Load Balancers] If you need static IP addresses for your load balancer,
	// you can specify one Elastic IP address per Availability Zone when you create an
	// internal-facing load balancer. For internal load balancers, you can specify a
	// private IP address from the IPv4 range of the subnet.
	LoadBalancerAddresses []*LoadBalancerAddress

	// The ID of the subnet. You can specify one subnet per Availability Zone.
	SubnetId *string

	// The name of the Availability Zone.
	ZoneName *string
}

Information about an Availability Zone.

type AvailabilityZoneNotSupportedException 

type AvailabilityZoneNotSupportedException struct {
	Message *string
}

The specified Availability Zone is not supported.

func (*AvailabilityZoneNotSupportedException) Error 

func (e *AvailabilityZoneNotSupportedException) Error() string

func (*AvailabilityZoneNotSupportedException) ErrorCode 

func (e *AvailabilityZoneNotSupportedException) ErrorCode() string

func (*AvailabilityZoneNotSupportedException) ErrorFault 

func (e *AvailabilityZoneNotSupportedException) ErrorFault() smithy.ErrorFault

func (*AvailabilityZoneNotSupportedException) ErrorMessage 

func (e *AvailabilityZoneNotSupportedException) ErrorMessage() string

type Certificate 

type Certificate struct {

	// The Amazon Resource Name (ARN) of the certificate.
	CertificateArn *string

	// Indicates whether the certificate is the default certificate. Do not set this
	// value when specifying a certificate as an input. This value is not included in
	// the output when describing a listener, but is included when describing listener
	// certificates.
	IsDefault *bool
}

Information about an SSL server certificate.

type CertificateNotFoundException 

type CertificateNotFoundException struct {
	Message *string
}

The specified certificate does not exist.

func (*CertificateNotFoundException) Error 

func (e *CertificateNotFoundException) Error() string

func (*CertificateNotFoundException) ErrorCode 

func (e *CertificateNotFoundException) ErrorCode() string

func (*CertificateNotFoundException) ErrorFault 

func (e *CertificateNotFoundException) ErrorFault() smithy.ErrorFault

func (*CertificateNotFoundException) ErrorMessage 

func (e *CertificateNotFoundException) ErrorMessage() string

type Cipher 

type Cipher struct {

	// The name of the cipher.
	Name *string

	// The priority of the cipher.
	Priority *int32
}

Information about a cipher used in a policy.

type DuplicateListenerException 

type DuplicateListenerException struct {
	Message *string
}

A listener with the specified port already exists.

func (*DuplicateListenerException) Error 

func (e *DuplicateListenerException) Error() string

func (*DuplicateListenerException) ErrorCode 

func (e *DuplicateListenerException) ErrorCode() string

func (*DuplicateListenerException) ErrorFault 

func (e *DuplicateListenerException) ErrorFault() smithy.ErrorFault

func (*DuplicateListenerException) ErrorMessage 

func (e *DuplicateListenerException) ErrorMessage() string

type DuplicateLoadBalancerNameException 

type DuplicateLoadBalancerNameException struct {
	Message *string
}

A load balancer with the specified name already exists.

func (*DuplicateLoadBalancerNameException) Error 

func (e *DuplicateLoadBalancerNameException) Error() string

func (*DuplicateLoadBalancerNameException) ErrorCode 

func (e *DuplicateLoadBalancerNameException) ErrorCode() string

func (*DuplicateLoadBalancerNameException) ErrorFault 

func (e *DuplicateLoadBalancerNameException) ErrorFault() smithy.ErrorFault

func (*DuplicateLoadBalancerNameException) ErrorMessage 

func (e *DuplicateLoadBalancerNameException) ErrorMessage() string

type DuplicateTagKeysException 

type DuplicateTagKeysException struct {
	Message *string
}

A tag key was specified more than once.

func (*DuplicateTagKeysException) Error 

func (e *DuplicateTagKeysException) Error() string

func (*DuplicateTagKeysException) ErrorCode 

func (e *DuplicateTagKeysException) ErrorCode() string

func (*DuplicateTagKeysException) ErrorFault 

func (e *DuplicateTagKeysException) ErrorFault() smithy.ErrorFault

func (*DuplicateTagKeysException) ErrorMessage 

func (e *DuplicateTagKeysException) ErrorMessage() string

type DuplicateTargetGroupNameException 

type DuplicateTargetGroupNameException struct {
	Message *string
}

A target group with the specified name already exists.

func (*DuplicateTargetGroupNameException) Error 

func (e *DuplicateTargetGroupNameException) Error() string

func (*DuplicateTargetGroupNameException) ErrorCode 

func (e *DuplicateTargetGroupNameException) ErrorCode() string

func (*DuplicateTargetGroupNameException) ErrorFault 

func (e *DuplicateTargetGroupNameException) ErrorFault() smithy.ErrorFault

func (*DuplicateTargetGroupNameException) ErrorMessage 

func (e *DuplicateTargetGroupNameException) ErrorMessage() string

type FixedResponseActionConfig 

type FixedResponseActionConfig struct {

	// The HTTP response code (2XX, 4XX, or 5XX).
	//
	// This member is required.
	StatusCode *string

	// The content type. Valid Values: text/plain | text/css | text/html |
	// application/javascript | application/json
	ContentType *string

	// The message.
	MessageBody *string
}

Information about an action that returns a custom HTTP response.

type ForwardActionConfig 

type ForwardActionConfig struct {

	// The target group stickiness for the rule.
	TargetGroupStickinessConfig *TargetGroupStickinessConfig

	// One or more target groups. For Network Load Balancers, you can specify a single
	// target group.
	TargetGroups []*TargetGroupTuple
}

Information about a forward action.

type HealthUnavailableException 

type HealthUnavailableException struct {
	Message *string
}

The health of the specified targets could not be retrieved due to an internal error.

func (*HealthUnavailableException) Error 

func (e *HealthUnavailableException) Error() string

func (*HealthUnavailableException) ErrorCode 

func (e *HealthUnavailableException) ErrorCode() string

func (*HealthUnavailableException) ErrorFault 

func (e *HealthUnavailableException) ErrorFault() smithy.ErrorFault

func (*HealthUnavailableException) ErrorMessage 

func (e *HealthUnavailableException) ErrorMessage() string

type HostHeaderConditionConfig 

type HostHeaderConditionConfig struct {

	// One or more host names. The maximum size of each name is 128 characters. The
	// comparison is case insensitive. The following wildcard characters are supported:
	// * (matches 0 or more characters) and ? (matches exactly 1 character). If you
	// specify multiple strings, the condition is satisfied if one of the strings
	// matches the host name.
	Values []*string
}

Information about a host header condition.

type HttpHeaderConditionConfig 

type HttpHeaderConditionConfig struct {

	// The name of the HTTP header field. The maximum size is 40 characters. The header
	// name is case insensitive. The allowed characters are specified by RFC 7230.
	// Wildcards are not supported. You can't use an HTTP header condition to specify
	// the host header. Use HostHeaderConditionConfig to specify a host header
	// condition.
	HttpHeaderName *string

	// One or more strings to compare against the value of the HTTP header. The maximum
	// size of each string is 128 characters. The comparison strings are case
	// insensitive. The following wildcard characters are supported: * (matches 0 or
	// more characters) and ? (matches exactly 1 character). If the same header appears
	// multiple times in the request, we search them in order until a match is found.
	// If you specify multiple strings, the condition is satisfied if one of the
	// strings matches the value of the HTTP header. To require that all of the strings
	// are a match, create one condition per string.
	Values []*string
}

Information about an HTTP header condition. There is a set of standard HTTP header fields. You can also define custom HTTP header fields.

type HttpRequestMethodConditionConfig 

type HttpRequestMethodConditionConfig struct {

	// The name of the request method. The maximum size is 40 characters. The allowed
	// characters are A-Z, hyphen (-), and underscore (_). The comparison is case
	// sensitive. Wildcards are not supported; therefore, the method name must be an
	// exact match. If you specify multiple strings, the condition is satisfied if one
	// of the strings matches the HTTP request method. We recommend that you route GET
	// and HEAD requests in the same way, because the response to a HEAD request may be
	// cached.
	Values []*string
}

Information about an HTTP method condition. HTTP defines a set of request methods, also referred to as HTTP verbs. For more information, see the HTTP Method Registry (https://www.iana.org/assignments/http-methods/http-methods.xhtml). You can also define custom HTTP methods.

type IncompatibleProtocolsException 

type IncompatibleProtocolsException struct {
	Message *string
}

The specified configuration is not valid with this protocol.

func (*IncompatibleProtocolsException) Error 

func (e *IncompatibleProtocolsException) Error() string

func (*IncompatibleProtocolsException) ErrorCode 

func (e *IncompatibleProtocolsException) ErrorCode() string

func (*IncompatibleProtocolsException) ErrorFault 

func (e *IncompatibleProtocolsException) ErrorFault() smithy.ErrorFault

func (*IncompatibleProtocolsException) ErrorMessage 

func (e *IncompatibleProtocolsException) ErrorMessage() string

type InvalidConfigurationRequestException 

type InvalidConfigurationRequestException struct {
	Message *string
}

The requested configuration is not valid.

func (*InvalidConfigurationRequestException) Error 

func (e *InvalidConfigurationRequestException) Error() string

func (*InvalidConfigurationRequestException) ErrorCode 

func (e *InvalidConfigurationRequestException) ErrorCode() string

func (*InvalidConfigurationRequestException) ErrorFault 

func (e *InvalidConfigurationRequestException) ErrorFault() smithy.ErrorFault

func (*InvalidConfigurationRequestException) ErrorMessage 

func (e *InvalidConfigurationRequestException) ErrorMessage() string

type InvalidLoadBalancerActionException 

type InvalidLoadBalancerActionException struct {
	Message *string
}

The requested action is not valid.

func (*InvalidLoadBalancerActionException) Error 

func (e *InvalidLoadBalancerActionException) Error() string

func (*InvalidLoadBalancerActionException) ErrorCode 

func (e *InvalidLoadBalancerActionException) ErrorCode() string

func (*InvalidLoadBalancerActionException) ErrorFault 

func (e *InvalidLoadBalancerActionException) ErrorFault() smithy.ErrorFault

func (*InvalidLoadBalancerActionException) ErrorMessage 

func (e *InvalidLoadBalancerActionException) ErrorMessage() string

type InvalidSchemeException 

type InvalidSchemeException struct {
	Message *string
}

The requested scheme is not valid.

func (*InvalidSchemeException) Error 

func (e *InvalidSchemeException) Error() string

func (*InvalidSchemeException) ErrorCode 

func (e *InvalidSchemeException) ErrorCode() string

func (*InvalidSchemeException) ErrorFault 

func (e *InvalidSchemeException) ErrorFault() smithy.ErrorFault

func (*InvalidSchemeException) ErrorMessage 

func (e *InvalidSchemeException) ErrorMessage() string

type InvalidSecurityGroupException 

type InvalidSecurityGroupException struct {
	Message *string
}

The specified security group does not exist.

func (*InvalidSecurityGroupException) Error 

func (e *InvalidSecurityGroupException) Error() string

func (*InvalidSecurityGroupException) ErrorCode 

func (e *InvalidSecurityGroupException) ErrorCode() string

func (*InvalidSecurityGroupException) ErrorFault 

func (e *InvalidSecurityGroupException) ErrorFault() smithy.ErrorFault

func (*InvalidSecurityGroupException) ErrorMessage 

func (e *InvalidSecurityGroupException) ErrorMessage() string

type InvalidSubnetException 

type InvalidSubnetException struct {
	Message *string
}

The specified subnet is out of available addresses.

func (*InvalidSubnetException) Error 

func (e *InvalidSubnetException) Error() string

func (*InvalidSubnetException) ErrorCode 

func (e *InvalidSubnetException) ErrorCode() string

func (*InvalidSubnetException) ErrorFault 

func (e *InvalidSubnetException) ErrorFault() smithy.ErrorFault

func (*InvalidSubnetException) ErrorMessage 

func (e *InvalidSubnetException) ErrorMessage() string

type InvalidTargetException 

type InvalidTargetException struct {
	Message *string
}

The specified target does not exist, is not in the same VPC as the target group, or has an unsupported instance type.

func (*InvalidTargetException) Error 

func (e *InvalidTargetException) Error() string

func (*InvalidTargetException) ErrorCode 

func (e *InvalidTargetException) ErrorCode() string

func (*InvalidTargetException) ErrorFault 

func (e *InvalidTargetException) ErrorFault() smithy.ErrorFault

func (*InvalidTargetException) ErrorMessage 

func (e *InvalidTargetException) ErrorMessage() string

type IpAddressType 

type IpAddressType string
const (
	IpAddressTypeIpv4      IpAddressType = "ipv4"
	IpAddressTypeDualstack IpAddressType = "dualstack"
)

Enum values for IpAddressType

type Limit 

type Limit struct {

	// The maximum value of the limit.
	Max *string

	// The name of the limit. The possible values are:
	//
	//     *
	// application-load-balancers
	//
	//     * listeners-per-application-load-balancer
	//
	//     *
	// listeners-per-network-load-balancer
	//
	//     * network-load-balancers
	//
	//     *
	// rules-per-application-load-balancer
	//
	//     * target-groups
	//
	//     *
	// target-groups-per-action-on-application-load-balancer
	//
	//     *
	// target-groups-per-action-on-network-load-balancer
	//
	//     *
	// target-groups-per-application-load-balancer
	//
	//     *
	// targets-per-application-load-balancer
	//
	//     *
	// targets-per-availability-zone-per-network-load-balancer
	//
	//     *
	// targets-per-network-load-balancer
	Name *string
}

Information about an Elastic Load Balancing resource limit for your AWS account.

type Listener 

type Listener struct {

	// [TLS listener] The name of the Application-Layer Protocol Negotiation (ALPN)
	// policy.
	AlpnPolicy []*string

	// [HTTPS or TLS listener] The default certificate for the listener.
	Certificates []*Certificate

	// The default actions for the listener.
	DefaultActions []*Action

	// The Amazon Resource Name (ARN) of the listener.
	ListenerArn *string

	// The Amazon Resource Name (ARN) of the load balancer.
	LoadBalancerArn *string

	// The port on which the load balancer is listening.
	Port *int32

	// The protocol for connections from clients to the load balancer.
	Protocol ProtocolEnum

	// [HTTPS or TLS listener] The security policy that defines which protocols and
	// ciphers are supported.
	SslPolicy *string
}

Information about a listener.

type ListenerNotFoundException 

type ListenerNotFoundException struct {
	Message *string
}

The specified listener does not exist.

func (*ListenerNotFoundException) Error 

func (e *ListenerNotFoundException) Error() string

func (*ListenerNotFoundException) ErrorCode 

func (e *ListenerNotFoundException) ErrorCode() string

func (*ListenerNotFoundException) ErrorFault 

func (e *ListenerNotFoundException) ErrorFault() smithy.ErrorFault

func (*ListenerNotFoundException) ErrorMessage 

func (e *ListenerNotFoundException) ErrorMessage() string

type LoadBalancer 

type LoadBalancer struct {

	// The Availability Zones for the load balancer.
	AvailabilityZones []*AvailabilityZone

	// The ID of the Amazon Route 53 hosted zone associated with the load balancer.
	CanonicalHostedZoneId *string

	// The date and time the load balancer was created.
	CreatedTime *time.Time

	// The public DNS name of the load balancer.
	DNSName *string

	// The type of IP addresses used by the subnets for your load balancer. The
	// possible values are ipv4 (for IPv4 addresses) and dualstack (for IPv4 and IPv6
	// addresses).
	IpAddressType IpAddressType

	// The Amazon Resource Name (ARN) of the load balancer.
	LoadBalancerArn *string

	// The name of the load balancer.
	LoadBalancerName *string

	// The nodes of an Internet-facing load balancer have public IP addresses. The DNS
	// name of an Internet-facing load balancer is publicly resolvable to the public IP
	// addresses of the nodes. Therefore, Internet-facing load balancers can route
	// requests from clients over the internet. The nodes of an internal load balancer
	// have only private IP addresses. The DNS name of an internal load balancer is
	// publicly resolvable to the private IP addresses of the nodes. Therefore,
	// internal load balancers can route requests only from clients with access to the
	// VPC for the load balancer.
	Scheme LoadBalancerSchemeEnum

	// The IDs of the security groups for the load balancer.
	SecurityGroups []*string

	// The state of the load balancer.
	State *LoadBalancerState

	// The type of load balancer.
	Type LoadBalancerTypeEnum

	// The ID of the VPC for the load balancer.
	VpcId *string
}

Information about a load balancer.

type LoadBalancerAddress 

type LoadBalancerAddress struct {

	// [Network Load Balancers] The allocation ID of the Elastic IP address for an
	// internal-facing load balancer.
	AllocationId *string

	// The static IP address.
	IpAddress *string

	// [Network Load Balancers] The private IPv4 address for an internal load balancer.
	PrivateIPv4Address *string
}

Information about a static IP address for a load balancer.

type LoadBalancerAttribute 

type LoadBalancerAttribute struct {

	// The name of the attribute. The following attributes are supported by both
	// Application Load Balancers and Network Load Balancers:
	//
	//     *
	// access_logs.s3.enabled - Indicates whether access logs are enabled. The value is
	// true or false. The default is false.
	//
	//     * access_logs.s3.bucket - The name of
	// the S3 bucket for the access logs. This attribute is required if access logs are
	// enabled. The bucket must exist in the same region as the load balancer and have
	// a bucket policy that grants Elastic Load Balancing permissions to write to the
	// bucket.
	//
	//     * access_logs.s3.prefix - The prefix for the location in the S3
	// bucket for the access logs.
	//
	//     * deletion_protection.enabled - Indicates
	// whether deletion protection is enabled. The value is true or false. The default
	// is false.
	//
	// The following attributes are supported by only Application Load
	// Balancers:
	//
	//     * idle_timeout.timeout_seconds - The idle timeout value, in
	// seconds. The valid range is 1-4000 seconds. The default is 60 seconds.
	//
	//     *
	// routing.http.drop_invalid_header_fields.enabled - Indicates whether HTTP headers
	// with invalid header fields are removed by the load balancer (true) or routed to
	// targets (false). The default is false.
	//
	//     * routing.http2.enabled - Indicates
	// whether HTTP/2 is enabled. The value is true or false. The default is true.
	// Elastic Load Balancing requires that message header names contain only
	// alphanumeric characters and hyphens.
	//
	// The following attributes are supported by
	// only Network Load Balancers:
	//
	//     * load_balancing.cross_zone.enabled -
	// Indicates whether cross-zone load balancing is enabled. The value is true or
	// false. The default is false.
	Key *string

	// The value of the attribute.
	Value *string
}

Information about a load balancer attribute.

type LoadBalancerNotFoundException 

type LoadBalancerNotFoundException struct {
	Message *string
}

The specified load balancer does not exist.

func (*LoadBalancerNotFoundException) Error 

func (e *LoadBalancerNotFoundException) Error() string

func (*LoadBalancerNotFoundException) ErrorCode 

func (e *LoadBalancerNotFoundException) ErrorCode() string

func (*LoadBalancerNotFoundException) ErrorFault 

func (e *LoadBalancerNotFoundException) ErrorFault() smithy.ErrorFault

func (*LoadBalancerNotFoundException) ErrorMessage 

func (e *LoadBalancerNotFoundException) ErrorMessage() string

type LoadBalancerSchemeEnum 

type LoadBalancerSchemeEnum string
const (
	LoadBalancerSchemeEnumInternet_facing LoadBalancerSchemeEnum = "internet-facing"
	LoadBalancerSchemeEnumInternal        LoadBalancerSchemeEnum = "internal"
)

Enum values for LoadBalancerSchemeEnum

type LoadBalancerState 

type LoadBalancerState struct {

	// The state code. The initial state of the load balancer is provisioning. After
	// the load balancer is fully set up and ready to route traffic, its state is
	// active. If the load balancer could not be set up, its state is failed.
	Code LoadBalancerStateEnum

	// A description of the state.
	Reason *string
}

Information about the state of the load balancer.

type LoadBalancerStateEnum 

type LoadBalancerStateEnum string
const (
	LoadBalancerStateEnumActive          LoadBalancerStateEnum = "active"
	LoadBalancerStateEnumProvisioning    LoadBalancerStateEnum = "provisioning"
	LoadBalancerStateEnumActive_impaired LoadBalancerStateEnum = "active_impaired"
	LoadBalancerStateEnumFailed          LoadBalancerStateEnum = "failed"
)

Enum values for LoadBalancerStateEnum

type LoadBalancerTypeEnum 

type LoadBalancerTypeEnum string
const (
	LoadBalancerTypeEnumApplication LoadBalancerTypeEnum = "application"
	LoadBalancerTypeEnumNetwork     LoadBalancerTypeEnum = "network"
)

Enum values for LoadBalancerTypeEnum

type Matcher 

type Matcher struct {

	// The HTTP codes. For Application Load Balancers, you can specify values between
	// 200 and 499, and the default value is 200. You can specify multiple values (for
	// example, "200,202") or a range of values (for example, "200-299"). For Network
	// Load Balancers, this is 200–399.
	//
	// This member is required.
	HttpCode *string
}

Information to use when checking for a successful response from a target.

type OperationNotPermittedException 

type OperationNotPermittedException struct {
	Message *string
}

This operation is not allowed.

func (*OperationNotPermittedException) Error 

func (e *OperationNotPermittedException) Error() string

func (*OperationNotPermittedException) ErrorCode 

func (e *OperationNotPermittedException) ErrorCode() string

func (*OperationNotPermittedException) ErrorFault 

func (e *OperationNotPermittedException) ErrorFault() smithy.ErrorFault

func (*OperationNotPermittedException) ErrorMessage 

func (e *OperationNotPermittedException) ErrorMessage() string

type PathPatternConditionConfig 

type PathPatternConditionConfig struct {

	// One or more path patterns to compare against the request URL. The maximum size
	// of each string is 128 characters. The comparison is case sensitive. The
	// following wildcard characters are supported: * (matches 0 or more characters)
	// and ? (matches exactly 1 character). If you specify multiple strings, the
	// condition is satisfied if one of them matches the request URL. The path pattern
	// is compared only to the path of the URL, not to its query string. To compare
	// against the query string, use QueryStringConditionConfig.
	Values []*string
}

Information about a path pattern condition.

type PriorityInUseException 

type PriorityInUseException struct {
	Message *string
}

The specified priority is in use.

func (*PriorityInUseException) Error 

func (e *PriorityInUseException) Error() string

func (*PriorityInUseException) ErrorCode 

func (e *PriorityInUseException) ErrorCode() string

func (*PriorityInUseException) ErrorFault 

func (e *PriorityInUseException) ErrorFault() smithy.ErrorFault

func (*PriorityInUseException) ErrorMessage 

func (e *PriorityInUseException) ErrorMessage() string

type ProtocolEnum 

type ProtocolEnum string
const (
	ProtocolEnumHttp    ProtocolEnum = "HTTP"
	ProtocolEnumHttps   ProtocolEnum = "HTTPS"
	ProtocolEnumTcp     ProtocolEnum = "TCP"
	ProtocolEnumTls     ProtocolEnum = "TLS"
	ProtocolEnumUdp     ProtocolEnum = "UDP"
	ProtocolEnumTcp_udp ProtocolEnum = "TCP_UDP"
)

Enum values for ProtocolEnum

type QueryStringConditionConfig 

type QueryStringConditionConfig struct {

	// One or more key/value pairs or values to find in the query string. The maximum
	// size of each string is 128 characters. The comparison is case insensitive. The
	// following wildcard characters are supported: * (matches 0 or more characters)
	// and ? (matches exactly 1 character). To search for a literal '*' or '?'
	// character in a query string, you must escape these characters in Values using a
	// '\' character. If you specify multiple key/value pairs or values, the condition
	// is satisfied if one of them is found in the query string.
	Values []*QueryStringKeyValuePair
}

Information about a query string condition. The query string component of a URI starts after the first '?' character and is terminated by either a '#' character or the end of the URI. A typical query string contains key/value pairs separated by '&' characters. The allowed characters are specified by RFC 3986. Any character can be percentage encoded.

type QueryStringKeyValuePair 

type QueryStringKeyValuePair struct {

	// The key. You can omit the key.
	Key *string

	// The value.
	Value *string
}

Information about a key/value pair.

type RedirectActionConfig 

type RedirectActionConfig struct {

	// The HTTP redirect code. The redirect is either permanent (HTTP 301) or temporary
	// (HTTP 302).
	//
	// This member is required.
	StatusCode RedirectActionStatusCodeEnum

	// The hostname. This component is not percent-encoded. The hostname can contain
	// #{host}.
	Host *string

	// The absolute path, starting with the leading "/". This component is not
	// percent-encoded. The path can contain #{host}, #{path}, and #{port}.
	Path *string

	// The port. You can specify a value from 1 to 65535 or #{port}.
	Port *string

	// The protocol. You can specify HTTP, HTTPS, or #{protocol}. You can redirect HTTP
	// to HTTP, HTTP to HTTPS, and HTTPS to HTTPS. You cannot redirect HTTPS to HTTP.
	Protocol *string

	// The query parameters, URL-encoded when necessary, but not percent-encoded. Do
	// not include the leading "?", as it is automatically added. You can specify any
	// of the reserved keywords.
	Query *string
}

Information about a redirect action. A URI consists of the following components: protocol://hostname:port/path?query. You must modify at least one of the following components to avoid a redirect loop: protocol, hostname, port, or path. Any components that you do not modify retain their original values. You can reuse URI components using the following reserved keywords: 

*

#{protocol}

  • #{host}

  • #{port}

  • #{path} (the leading "/" is

removed)

  • #{query}

For example, you can change the path to "/new/#{path}", the hostname to "example.#{host}", or the query to "#{query}&value=xyz".

type RedirectActionStatusCodeEnum 

type RedirectActionStatusCodeEnum string
const (
	RedirectActionStatusCodeEnumHttp_301 RedirectActionStatusCodeEnum = "HTTP_301"
	RedirectActionStatusCodeEnumHttp_302 RedirectActionStatusCodeEnum = "HTTP_302"
)

Enum values for RedirectActionStatusCodeEnum

type ResourceInUseException 

type ResourceInUseException struct {
	Message *string
}

A specified resource is in use.

func (*ResourceInUseException) Error 

func (e *ResourceInUseException) Error() string

func (*ResourceInUseException) ErrorCode 

func (e *ResourceInUseException) ErrorCode() string

func (*ResourceInUseException) ErrorFault 

func (e *ResourceInUseException) ErrorFault() smithy.ErrorFault

func (*ResourceInUseException) ErrorMessage 

func (e *ResourceInUseException) ErrorMessage() string

type Rule 

type Rule struct {

	// The actions. Each rule must include exactly one of the following types of
	// actions: forward, redirect, or fixed-response, and it must be the last action to
	// be performed.
	Actions []*Action

	// The conditions. Each rule can include zero or one of the following conditions:
	// http-request-method, host-header, path-pattern, and source-ip, and zero or more
	// of the following conditions: http-header and query-string.
	Conditions []*RuleCondition

	// Indicates whether this is the default rule.
	IsDefault *bool

	// The priority.
	Priority *string

	// The Amazon Resource Name (ARN) of the rule.
	RuleArn *string
}

Information about a rule.

type RuleCondition 

type RuleCondition struct {

	// The field in the HTTP request. The following are the possible values:
	//
	//     *
	// http-header
	//
	//     * http-request-method
	//
	//     * host-header
	//
	//     * path-pattern
	//
	//
	// * query-string
	//
	//     * source-ip
	Field *string

	// Information for a host header condition. Specify only when Field is host-header.
	HostHeaderConfig *HostHeaderConditionConfig

	// Information for an HTTP header condition. Specify only when Field is
	// http-header.
	HttpHeaderConfig *HttpHeaderConditionConfig

	// Information for an HTTP method condition. Specify only when Field is
	// http-request-method.
	HttpRequestMethodConfig *HttpRequestMethodConditionConfig

	// Information for a path pattern condition. Specify only when Field is
	// path-pattern.
	PathPatternConfig *PathPatternConditionConfig

	// Information for a query string condition. Specify only when Field is
	// query-string.
	QueryStringConfig *QueryStringConditionConfig

	// Information for a source IP condition. Specify only when Field is source-ip.
	SourceIpConfig *SourceIpConditionConfig

	// The condition value. You can use Values if the rule contains only host-header
	// and path-pattern conditions. Otherwise, you can use HostHeaderConfig for
	// host-header conditions and PathPatternConfig for path-pattern conditions. If
	// Field is host-header, you can specify a single host name (for example,
	// my.example.com). A host name is case insensitive, can be up to 128 characters in
	// length, and can contain any of the following characters.
	//
	//     * A-Z, a-z, 0-9
	//
	//
	// * - .
	//
	//     * * (matches 0 or more characters)
	//
	//     * ? (matches exactly 1
	// character)
	//
	// If Field is path-pattern, you can specify a single path pattern (for
	// example, /img/*). A path pattern is case-sensitive, can be up to 128 characters
	// in length, and can contain any of the following characters.
	//
	//     * A-Z, a-z,
	// 0-9
	//
	//     * _ - . $ / ~ " ' @ : +
	//
	//     * & (using &)
	//
	//     * * (matches 0 or more
	// characters)
	//
	//     * ? (matches exactly 1 character)
	Values []*string
}

Information about a condition for a rule.

type RuleNotFoundException 

type RuleNotFoundException struct {
	Message *string
}

The specified rule does not exist.

func (*RuleNotFoundException) Error 

func (e *RuleNotFoundException) Error() string

func (*RuleNotFoundException) ErrorCode 

func (e *RuleNotFoundException) ErrorCode() string

func (*RuleNotFoundException) ErrorFault 

func (e *RuleNotFoundException) ErrorFault() smithy.ErrorFault

func (*RuleNotFoundException) ErrorMessage 

func (e *RuleNotFoundException) ErrorMessage() string

type RulePriorityPair 

type RulePriorityPair struct {

	// The rule priority.
	Priority *int32

	// The Amazon Resource Name (ARN) of the rule.
	RuleArn *string
}

Information about the priorities for the rules for a listener.

type SSLPolicyNotFoundException 

type SSLPolicyNotFoundException struct {
	Message *string
}

The specified SSL policy does not exist.

func (*SSLPolicyNotFoundException) Error 

func (e *SSLPolicyNotFoundException) Error() string

func (*SSLPolicyNotFoundException) ErrorCode 

func (e *SSLPolicyNotFoundException) ErrorCode() string

func (*SSLPolicyNotFoundException) ErrorFault 

func (e *SSLPolicyNotFoundException) ErrorFault() smithy.ErrorFault

func (*SSLPolicyNotFoundException) ErrorMessage 

func (e *SSLPolicyNotFoundException) ErrorMessage() string

type SourceIpConditionConfig 

type SourceIpConditionConfig struct {

	// One or more source IP addresses, in CIDR format. You can use both IPv4 and IPv6
	// addresses. Wildcards are not supported. If you specify multiple addresses, the
	// condition is satisfied if the source IP address of the request matches one of
	// the CIDR blocks. This condition is not satisfied by the addresses in the
	// X-Forwarded-For header. To search for addresses in the X-Forwarded-For header,
	// use HttpHeaderConditionConfig.
	Values []*string
}

Information about a source IP condition. You can use this condition to route based on the IP address of the source that connects to the load balancer. If a client is behind a proxy, this is the IP address of the proxy not the IP address of the client.

type SslPolicy 

type SslPolicy struct {

	// The ciphers.
	Ciphers []*Cipher

	// The name of the policy.
	Name *string

	// The protocols.
	SslProtocols []*string
}

Information about a policy used for SSL negotiation.

type SubnetMapping 

type SubnetMapping struct {

	// [Network Load Balancers] The allocation ID of the Elastic IP address for an
	// internet-facing load balancer.
	AllocationId *string

	// [Network Load Balancers] The private IPv4 address for an internal load balancer.
	PrivateIPv4Address *string

	// The ID of the subnet.
	SubnetId *string
}

Information about a subnet mapping.

type SubnetNotFoundException 

type SubnetNotFoundException struct {
	Message *string
}

The specified subnet does not exist.

func (*SubnetNotFoundException) Error 

func (e *SubnetNotFoundException) Error() string

func (*SubnetNotFoundException) ErrorCode 

func (e *SubnetNotFoundException) ErrorCode() string

func (*SubnetNotFoundException) ErrorFault 

func (e *SubnetNotFoundException) ErrorFault() smithy.ErrorFault

func (*SubnetNotFoundException) ErrorMessage 

func (e *SubnetNotFoundException) ErrorMessage() string

type Tag 

type Tag struct {

	// The key of the tag.
	//
	// This member is required.
	Key *string

	// The value of the tag.
	Value *string
}

Information about a tag.

type TagDescription 

type TagDescription struct {

	// The Amazon Resource Name (ARN) of the resource.
	ResourceArn *string

	// Information about the tags.
	Tags []*Tag
}

The tags associated with a resource.

type TargetDescription 

type TargetDescription struct {

	// The ID of the target. If the target type of the target group is instance,
	// specify an instance ID. If the target type is ip, specify an IP address. If the
	// target type is lambda, specify the ARN of the Lambda function.
	//
	// This member is required.
	Id *string

	// An Availability Zone or all. This determines whether the target receives traffic
	// from the load balancer nodes in the specified Availability Zone or from all
	// enabled Availability Zones for the load balancer. This parameter is not
	// supported if the target type of the target group is instance. If the target type
	// is ip and the IP address is in a subnet of the VPC for the target group, the
	// Availability Zone is automatically detected and this parameter is optional. If
	// the IP address is outside the VPC, this parameter is required. With an
	// Application Load Balancer, if the target type is ip and the IP address is
	// outside the VPC for the target group, the only supported value is all. If the
	// target type is lambda, this parameter is optional and the only supported value
	// is all.
	AvailabilityZone *string

	// The port on which the target is listening. Not used if the target is a Lambda
	// function.
	Port *int32
}

Information about a target.

type TargetGroup 

type TargetGroup struct {

	// Indicates whether health checks are enabled.
	HealthCheckEnabled *bool

	// The approximate amount of time, in seconds, between health checks of an
	// individual target.
	HealthCheckIntervalSeconds *int32

	// The destination for the health check request.
	HealthCheckPath *string

	// The port to use to connect with the target.
	HealthCheckPort *string

	// The protocol to use to connect with the target.
	HealthCheckProtocol ProtocolEnum

	// The amount of time, in seconds, during which no response means a failed health
	// check.
	HealthCheckTimeoutSeconds *int32

	// The number of consecutive health checks successes required before considering an
	// unhealthy target healthy.
	HealthyThresholdCount *int32

	// The Amazon Resource Names (ARN) of the load balancers that route traffic to this
	// target group.
	LoadBalancerArns []*string

	// The HTTP codes to use when checking for a successful response from a target.
	Matcher *Matcher

	// The port on which the targets are listening. Not used if the target is a Lambda
	// function.
	Port *int32

	// The protocol to use for routing traffic to the targets.
	Protocol ProtocolEnum

	// The Amazon Resource Name (ARN) of the target group.
	TargetGroupArn *string

	// The name of the target group.
	TargetGroupName *string

	// The type of target that you must specify when registering targets with this
	// target group. The possible values are instance (targets are specified by
	// instance ID) or ip (targets are specified by IP address).
	TargetType TargetTypeEnum

	// The number of consecutive health check failures required before considering the
	// target unhealthy.
	UnhealthyThresholdCount *int32

	// The ID of the VPC for the targets.
	VpcId *string
}

Information about a target group.

type TargetGroupAssociationLimitException 

type TargetGroupAssociationLimitException struct {
	Message *string
}

You've reached the limit on the number of load balancers per target group.

func (*TargetGroupAssociationLimitException) Error 

func (e *TargetGroupAssociationLimitException) Error() string

func (*TargetGroupAssociationLimitException) ErrorCode 

func (e *TargetGroupAssociationLimitException) ErrorCode() string

func (*TargetGroupAssociationLimitException) ErrorFault 

func (e *TargetGroupAssociationLimitException) ErrorFault() smithy.ErrorFault

func (*TargetGroupAssociationLimitException) ErrorMessage 

func (e *TargetGroupAssociationLimitException) ErrorMessage() string

type TargetGroupAttribute 

type TargetGroupAttribute struct {

	// The name of the attribute. The following attributes are supported by both
	// Application Load Balancers and Network Load Balancers:
	//
	//     *
	// deregistration_delay.timeout_seconds - The amount of time, in seconds, for
	// Elastic Load Balancing to wait before changing the state of a deregistering
	// target from draining to unused. The range is 0-3600 seconds. The default value
	// is 300 seconds. If the target is a Lambda function, this attribute is not
	// supported.
	//
	//     * stickiness.enabled - Indicates whether sticky sessions are
	// enabled. The value is true or false. The default is false.
	//
	//     *
	// stickiness.type - The type of sticky sessions. The possible values are
	//
	//
	// lb_cookie for Application Load Balancers or source_ip for Network Load
	// Balancers.
	//
	// The following attributes are supported only if the load balancer is
	// an Application Load Balancer and the target is an instance or an IP address:
	//
	//
	// * load_balancing.algorithm.type - The load balancing algorithm determines how
	// the load balancer selects targets when routing requests. The value is
	// round_robin or least_outstanding_requests. The default is round_robin.
	//
	//     *
	// slow_start.duration_seconds - The time period, in seconds, during which a newly
	// registered target receives an increasing share of the traffic to the target
	// group. After this time period ends, the target receives its full share of
	// traffic. The range is 30-900 seconds (15 minutes). Slow start mode is disabled
	// by default.
	//
	//     * stickiness.lb_cookie.duration_seconds - The time period, in
	// seconds, during which requests from a client should be routed to the same
	// target. After this time period expires, the load balancer-generated cookie is
	// considered stale. The range is 1 second to 1 week (604800 seconds). The default
	// value is 1 day (86400 seconds).
	//
	// The following attribute is supported only if
	// the load balancer is an Application Load Balancer and the target is a Lambda
	// function:
	//
	//     * lambda.multi_value_headers.enabled - Indicates whether the
	// request and response headers that are exchanged between the load balancer and
	// the Lambda function include arrays of values or strings. The value is true or
	// false. The default is false. If the value is false and the request contains a
	// duplicate header field name or query parameter key, the load balancer uses the
	// last value sent by the client.
	//
	// The following attribute is supported only by
	// Network Load Balancers:
	//
	//     * proxy_protocol_v2.enabled - Indicates whether
	// Proxy Protocol version 2 is enabled. The value is true or false. The default is
	// false.
	Key *string

	// The value of the attribute.
	Value *string
}

Information about a target group attribute.

type TargetGroupNotFoundException 

type TargetGroupNotFoundException struct {
	Message *string
}

The specified target group does not exist.

func (*TargetGroupNotFoundException) Error 

func (e *TargetGroupNotFoundException) Error() string

func (*TargetGroupNotFoundException) ErrorCode 

func (e *TargetGroupNotFoundException) ErrorCode() string

func (*TargetGroupNotFoundException) ErrorFault 

func (e *TargetGroupNotFoundException) ErrorFault() smithy.ErrorFault

func (*TargetGroupNotFoundException) ErrorMessage 

func (e *TargetGroupNotFoundException) ErrorMessage() string

type TargetGroupStickinessConfig 

type TargetGroupStickinessConfig struct {

	// The time period, in seconds, during which requests from a client should be
	// routed to the same target group. The range is 1-604800 seconds (7 days).
	DurationSeconds *int32

	// Indicates whether target group stickiness is enabled.
	Enabled *bool
}

Information about the target group stickiness for a rule.

type TargetGroupTuple 

type TargetGroupTuple struct {

	// The Amazon Resource Name (ARN) of the target group.
	TargetGroupArn *string

	// The weight. The range is 0 to 999.
	Weight *int32
}

Information about how traffic will be distributed between multiple target groups in a forward rule.

type TargetHealth 

type TargetHealth struct {

	// A description of the target health that provides additional details. If the
	// state is healthy, a description is not provided.
	Description *string

	// The reason code. If the target state is healthy, a reason code is not provided.
	// If the target state is initial, the reason code can be one of the following
	// values:
	//
	//     * Elb.RegistrationInProgress - The target is in the process of
	// being registered with the load balancer.
	//
	//     * Elb.InitialHealthChecking - The
	// load balancer is still sending the target the minimum number of health checks
	// required to determine its health status.
	//
	// If the target state is unhealthy, the
	// reason code can be one of the following values:
	//
	//     *
	// Target.ResponseCodeMismatch - The health checks did not return an expected HTTP
	// code. Applies only to Application Load Balancers.
	//
	//     * Target.Timeout - The
	// health check requests timed out. Applies only to Application Load Balancers.
	//
	//
	// * Target.FailedHealthChecks - The load balancer received an error while
	// establishing a connection to the target or the target response was malformed.
	//
	//
	// * Elb.InternalError - The health checks failed due to an internal error. Applies
	// only to Application Load Balancers.
	//
	// If the target state is unused, the reason
	// code can be one of the following values:
	//
	//     * Target.NotRegistered - The
	// target is not registered with the target group.
	//
	//     * Target.NotInUse - The
	// target group is not used by any load balancer or the target is in an
	// Availability Zone that is not enabled for its load balancer.
	//
	//     *
	// Target.InvalidState - The target is in the stopped or terminated state.
	//
	//     *
	// Target.IpUnusable - The target IP address is reserved for use by a load
	// balancer.
	//
	// If the target state is draining, the reason code can be the following
	// value:
	//
	//     * Target.DeregistrationInProgress - The target is in the process of
	// being deregistered and the deregistration delay period has not expired.
	//
	// If the
	// target state is unavailable, the reason code can be the following value:
	//
	//     *
	// Target.HealthCheckDisabled - Health checks are disabled for the target group.
	// Applies only to Application Load Balancers.
	//
	//     * Elb.InternalError - Target
	// health is unavailable due to an internal error. Applies only to Network Load
	// Balancers.
	Reason TargetHealthReasonEnum

	// The state of the target.
	State TargetHealthStateEnum
}

Information about the current health of a target.

type TargetHealthDescription 

type TargetHealthDescription struct {

	// The port to use to connect with the target.
	HealthCheckPort *string

	// The description of the target.
	Target *TargetDescription

	// The health information for the target.
	TargetHealth *TargetHealth
}

Information about the health of a target.

type TargetHealthReasonEnum 

type TargetHealthReasonEnum string
const (
	TargetHealthReasonEnumRegistration_in_progress   TargetHealthReasonEnum = "Elb.RegistrationInProgress"
	TargetHealthReasonEnumInitial_health_checking    TargetHealthReasonEnum = "Elb.InitialHealthChecking"
	TargetHealthReasonEnumResponse_code_mismatch     TargetHealthReasonEnum = "Target.ResponseCodeMismatch"
	TargetHealthReasonEnumTimeout                    TargetHealthReasonEnum = "Target.Timeout"
	TargetHealthReasonEnumFailed_health_checks       TargetHealthReasonEnum = "Target.FailedHealthChecks"
	TargetHealthReasonEnumNot_registered             TargetHealthReasonEnum = "Target.NotRegistered"
	TargetHealthReasonEnumNot_in_use                 TargetHealthReasonEnum = "Target.NotInUse"
	TargetHealthReasonEnumDeregistration_in_progress TargetHealthReasonEnum = "Target.DeregistrationInProgress"
	TargetHealthReasonEnumInvalid_state              TargetHealthReasonEnum = "Target.InvalidState"
	TargetHealthReasonEnumIp_unusable                TargetHealthReasonEnum = "Target.IpUnusable"
	TargetHealthReasonEnumHealth_check_disabled      TargetHealthReasonEnum = "Target.HealthCheckDisabled"
	TargetHealthReasonEnumInternal_error             TargetHealthReasonEnum = "Elb.InternalError"
)

Enum values for TargetHealthReasonEnum

type TargetHealthStateEnum 

type TargetHealthStateEnum string
const (
	TargetHealthStateEnumInitial     TargetHealthStateEnum = "initial"
	TargetHealthStateEnumHealthy     TargetHealthStateEnum = "healthy"
	TargetHealthStateEnumUnhealthy   TargetHealthStateEnum = "unhealthy"
	TargetHealthStateEnumUnused      TargetHealthStateEnum = "unused"
	TargetHealthStateEnumDraining    TargetHealthStateEnum = "draining"
	TargetHealthStateEnumUnavailable TargetHealthStateEnum = "unavailable"
)

Enum values for TargetHealthStateEnum

type TargetTypeEnum 

type TargetTypeEnum string
const (
	TargetTypeEnumInstance TargetTypeEnum = "instance"
	TargetTypeEnumIp       TargetTypeEnum = "ip"
	TargetTypeEnumLambda   TargetTypeEnum = "lambda"
)

Enum values for TargetTypeEnum

type TooManyActionsException 

type TooManyActionsException struct {
	Message *string
}

You've reached the limit on the number of actions per rule.

func (*TooManyActionsException) Error 

func (e *TooManyActionsException) Error() string

func (*TooManyActionsException) ErrorCode 

func (e *TooManyActionsException) ErrorCode() string

func (*TooManyActionsException) ErrorFault 

func (e *TooManyActionsException) ErrorFault() smithy.ErrorFault

func (*TooManyActionsException) ErrorMessage 

func (e *TooManyActionsException) ErrorMessage() string

type TooManyCertificatesException 

type TooManyCertificatesException struct {
	Message *string
}

You've reached the limit on the number of certificates per load balancer.

func (*TooManyCertificatesException) Error 

func (e *TooManyCertificatesException) Error() string

func (*TooManyCertificatesException) ErrorCode 

func (e *TooManyCertificatesException) ErrorCode() string

func (*TooManyCertificatesException) ErrorFault 

func (e *TooManyCertificatesException) ErrorFault() smithy.ErrorFault

func (*TooManyCertificatesException) ErrorMessage 

func (e *TooManyCertificatesException) ErrorMessage() string

type TooManyListenersException 

type TooManyListenersException struct {
	Message *string
}

You've reached the limit on the number of listeners per load balancer.

func (*TooManyListenersException) Error 

func (e *TooManyListenersException) Error() string

func (*TooManyListenersException) ErrorCode 

func (e *TooManyListenersException) ErrorCode() string

func (*TooManyListenersException) ErrorFault 

func (e *TooManyListenersException) ErrorFault() smithy.ErrorFault

func (*TooManyListenersException) ErrorMessage 

func (e *TooManyListenersException) ErrorMessage() string

type TooManyLoadBalancersException 

type TooManyLoadBalancersException struct {
	Message *string
}

You've reached the limit on the number of load balancers for your AWS account.

func (*TooManyLoadBalancersException) Error 

func (e *TooManyLoadBalancersException) Error() string

func (*TooManyLoadBalancersException) ErrorCode 

func (e *TooManyLoadBalancersException) ErrorCode() string

func (*TooManyLoadBalancersException) ErrorFault 

func (e *TooManyLoadBalancersException) ErrorFault() smithy.ErrorFault

func (*TooManyLoadBalancersException) ErrorMessage 

func (e *TooManyLoadBalancersException) ErrorMessage() string

type TooManyRegistrationsForTargetIdException 

type TooManyRegistrationsForTargetIdException struct {
	Message *string
}

You've reached the limit on the number of times a target can be registered with a load balancer.

func (*TooManyRegistrationsForTargetIdException) Error 

func (e *TooManyRegistrationsForTargetIdException) Error() string

func (*TooManyRegistrationsForTargetIdException) ErrorCode 

func (e *TooManyRegistrationsForTargetIdException) ErrorCode() string

func (*TooManyRegistrationsForTargetIdException) ErrorFault 

func (e *TooManyRegistrationsForTargetIdException) ErrorFault() smithy.ErrorFault

func (*TooManyRegistrationsForTargetIdException) ErrorMessage 

func (e *TooManyRegistrationsForTargetIdException) ErrorMessage() string

type TooManyRulesException 

type TooManyRulesException struct {
	Message *string
}

You've reached the limit on the number of rules per load balancer.

func (*TooManyRulesException) Error 

func (e *TooManyRulesException) Error() string

func (*TooManyRulesException) ErrorCode 

func (e *TooManyRulesException) ErrorCode() string

func (*TooManyRulesException) ErrorFault 

func (e *TooManyRulesException) ErrorFault() smithy.ErrorFault

func (*TooManyRulesException) ErrorMessage 

func (e *TooManyRulesException) ErrorMessage() string

type TooManyTagsException 

type TooManyTagsException struct {
	Message *string
}

You've reached the limit on the number of tags per load balancer.

func (*TooManyTagsException) Error 

func (e *TooManyTagsException) Error() string

func (*TooManyTagsException) ErrorCode 

func (e *TooManyTagsException) ErrorCode() string

func (*TooManyTagsException) ErrorFault 

func (e *TooManyTagsException) ErrorFault() smithy.ErrorFault

func (*TooManyTagsException) ErrorMessage 

func (e *TooManyTagsException) ErrorMessage() string

type TooManyTargetGroupsException 

type TooManyTargetGroupsException struct {
	Message *string
}

You've reached the limit on the number of target groups for your AWS account.

func (*TooManyTargetGroupsException) Error 

func (e *TooManyTargetGroupsException) Error() string

func (*TooManyTargetGroupsException) ErrorCode 

func (e *TooManyTargetGroupsException) ErrorCode() string

func (*TooManyTargetGroupsException) ErrorFault 

func (e *TooManyTargetGroupsException) ErrorFault() smithy.ErrorFault

func (*TooManyTargetGroupsException) ErrorMessage 

func (e *TooManyTargetGroupsException) ErrorMessage() string

type TooManyTargetsException 

type TooManyTargetsException struct {
	Message *string
}

You've reached the limit on the number of targets.

func (*TooManyTargetsException) Error 

func (e *TooManyTargetsException) Error() string

func (*TooManyTargetsException) ErrorCode 

func (e *TooManyTargetsException) ErrorCode() string

func (*TooManyTargetsException) ErrorFault 

func (e *TooManyTargetsException) ErrorFault() smithy.ErrorFault

func (*TooManyTargetsException) ErrorMessage 

func (e *TooManyTargetsException) ErrorMessage() string

type TooManyUniqueTargetGroupsPerLoadBalancerException 

type TooManyUniqueTargetGroupsPerLoadBalancerException struct {
	Message *string
}

You've reached the limit on the number of unique target groups per load balancer across all listeners. If a target group is used by multiple actions for a load balancer, it is counted as only one use.

func (*TooManyUniqueTargetGroupsPerLoadBalancerException) Error 

func (e *TooManyUniqueTargetGroupsPerLoadBalancerException) Error() string

func (*TooManyUniqueTargetGroupsPerLoadBalancerException) ErrorCode 

func (e *TooManyUniqueTargetGroupsPerLoadBalancerException) ErrorCode() string

func (*TooManyUniqueTargetGroupsPerLoadBalancerException) ErrorFault 

func (e *TooManyUniqueTargetGroupsPerLoadBalancerException) ErrorFault() smithy.ErrorFault

func (*TooManyUniqueTargetGroupsPerLoadBalancerException) ErrorMessage 

func (e *TooManyUniqueTargetGroupsPerLoadBalancerException) ErrorMessage() string

type UnsupportedProtocolException 

type UnsupportedProtocolException struct {
	Message *string
}

The specified protocol is not supported.

func (*UnsupportedProtocolException) Error 

func (e *UnsupportedProtocolException) Error() string

func (*UnsupportedProtocolException) ErrorCode 

func (e *UnsupportedProtocolException) ErrorCode() string

func (*UnsupportedProtocolException) ErrorFault 

func (e *UnsupportedProtocolException) ErrorFault() smithy.ErrorFault

func (*UnsupportedProtocolException) ErrorMessage 

func (e *UnsupportedProtocolException) ErrorMessage() string

Source Files

View all Source files

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.