types

package
v0.26.0 Latest Latest
Warning

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

 Go to latest Published: Sep 30, 2020 License: Apache-2.0 Imports: 4 Imported by: 0

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

func (*ALPNPolicyNotSupportedException) GetMessage 

func (e *ALPNPolicyNotSupportedException) GetMessage() string

func (*ALPNPolicyNotSupportedException) HasMessage 

func (e *ALPNPolicyNotSupportedException) HasMessage() bool

type Action 

type Action struct {
	// 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
	// [Application Load Balancer] Information for creating a redirect action. Specify
	// only when Type is redirect.
	RedirectConfig *RedirectActionConfig
	// [Application Load Balancer] Information for creating an action that returns a
	// custom HTTP response. Specify only when Type is fixed-response.
	FixedResponseConfig *FixedResponseActionConfig
	// 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
	// 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
	// [HTTPS listeners] Information for using Amazon Cognito to authenticate users.
	// Specify only when Type is authenticate-cognito.
	AuthenticateCognitoConfig *AuthenticateCognitoActionConfig
	// The type of action.
	Type ActionTypeEnum
	// [HTTPS listeners] Information about an identity provider that is compliant with
	// OpenID Connect (OIDC). Specify only when Type is authenticate-oidc.
	AuthenticateOidcConfig *AuthenticateOidcActionConfig
}

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

func (*AllocationIdNotFoundException) GetMessage 

func (e *AllocationIdNotFoundException) GetMessage() string

func (*AllocationIdNotFoundException) HasMessage 

func (e *AllocationIdNotFoundException) HasMessage() bool

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 query parameters (up to 10) to include in the redirect request to the
	// authorization endpoint.
	AuthenticationRequestExtraParams map[string]*string
	// The Amazon Resource Name (ARN) of the Amazon Cognito user pool.
	UserPoolArn *string
	// The ID of the Amazon Cognito user pool client.
	UserPoolClientId *string
	// The maximum duration of the authentication session, in seconds. The default is
	// 604800 seconds (7 days).
	SessionTimeout *int64
	// 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 domain prefix or fully-qualified domain name of the Amazon Cognito user
	// pool.
	UserPoolDomain *string
	// The name of the cookie used to maintain session information. The default is
	// AWSELBAuthSessionCookie.
	SessionCookieName *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
}

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 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 token endpoint of the IdP. This must be a full URL, including the HTTPS
	// protocol, the domain, and the path.
	TokenEndpoint *string
	// The OIDC issuer identifier of the IdP. This must be a full URL, including the
	// HTTPS protocol, the domain, and the path.
	Issuer *string
	// The authorization endpoint of the IdP. This must be a full URL, including the
	// HTTPS protocol, the domain, and the path.
	AuthorizationEndpoint *string
	// The maximum duration of the authentication session, in seconds. The default is
	// 604800 seconds (7 days).
	SessionTimeout *int64
	// 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 AuthenticateOidcActionConditionalBehaviorEnum
	// The name of the cookie used to maintain session information. The default is
	// AWSELBAuthSessionCookie.
	SessionCookieName *string
	// 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 user info endpoint of the IdP. This must be a full URL, including the HTTPS
	// protocol, the domain, and the path.
	UserInfoEndpoint *string
	// The OAuth 2.0 client identifier.
	ClientId *string
	// 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

func (*AvailabilityZoneNotSupportedException) GetMessage 

func (e *AvailabilityZoneNotSupportedException) GetMessage() string

func (*AvailabilityZoneNotSupportedException) HasMessage 

func (e *AvailabilityZoneNotSupportedException) HasMessage() bool

type Certificate 

type Certificate struct {
	// 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
	// The Amazon Resource Name (ARN) of the certificate.
	CertificateArn *string
}

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

func (*CertificateNotFoundException) GetMessage 

func (e *CertificateNotFoundException) GetMessage() string

func (*CertificateNotFoundException) HasMessage 

func (e *CertificateNotFoundException) HasMessage() bool

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

func (*DuplicateListenerException) GetMessage 

func (e *DuplicateListenerException) GetMessage() string

func (*DuplicateListenerException) HasMessage 

func (e *DuplicateListenerException) HasMessage() bool

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

func (*DuplicateLoadBalancerNameException) GetMessage 

func (e *DuplicateLoadBalancerNameException) GetMessage() string

func (*DuplicateLoadBalancerNameException) HasMessage 

func (e *DuplicateLoadBalancerNameException) HasMessage() bool

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

func (*DuplicateTagKeysException) GetMessage 

func (e *DuplicateTagKeysException) GetMessage() string

func (*DuplicateTagKeysException) HasMessage 

func (e *DuplicateTagKeysException) HasMessage() bool

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

func (*DuplicateTargetGroupNameException) GetMessage 

func (e *DuplicateTargetGroupNameException) GetMessage() string

func (*DuplicateTargetGroupNameException) HasMessage 

func (e *DuplicateTargetGroupNameException) HasMessage() bool

type FixedResponseActionConfig 

type FixedResponseActionConfig struct {
	// The HTTP response code (2XX, 4XX, or 5XX).
	StatusCode *string
	// The message.
	MessageBody *string
	// The content type. Valid Values: text/plain | text/css | text/html |
	// application/javascript | application/json
	ContentType *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

func (*HealthUnavailableException) GetMessage 

func (e *HealthUnavailableException) GetMessage() string

func (*HealthUnavailableException) HasMessage 

func (e *HealthUnavailableException) HasMessage() bool

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

func (*IncompatibleProtocolsException) GetMessage 

func (e *IncompatibleProtocolsException) GetMessage() string

func (*IncompatibleProtocolsException) HasMessage 

func (e *IncompatibleProtocolsException) HasMessage() bool

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

func (*InvalidConfigurationRequestException) GetMessage 

func (e *InvalidConfigurationRequestException) GetMessage() string

func (*InvalidConfigurationRequestException) HasMessage 

func (e *InvalidConfigurationRequestException) HasMessage() bool

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

func (*InvalidLoadBalancerActionException) GetMessage 

func (e *InvalidLoadBalancerActionException) GetMessage() string

func (*InvalidLoadBalancerActionException) HasMessage 

func (e *InvalidLoadBalancerActionException) HasMessage() bool

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

func (*InvalidSchemeException) GetMessage 

func (e *InvalidSchemeException) GetMessage() string

func (*InvalidSchemeException) HasMessage 

func (e *InvalidSchemeException) HasMessage() bool

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

func (*InvalidSecurityGroupException) GetMessage 

func (e *InvalidSecurityGroupException) GetMessage() string

func (*InvalidSecurityGroupException) HasMessage 

func (e *InvalidSecurityGroupException) HasMessage() bool

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

func (*InvalidSubnetException) GetMessage 

func (e *InvalidSubnetException) GetMessage() string

func (*InvalidSubnetException) HasMessage 

func (e *InvalidSubnetException) HasMessage() bool

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

func (*InvalidTargetException) GetMessage 

func (e *InvalidTargetException) GetMessage() string

func (*InvalidTargetException) HasMessage 

func (e *InvalidTargetException) HasMessage() bool

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 {
	// [HTTPS or TLS listener] The default certificate for the listener.
	Certificates []*Certificate
	// 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
	// The default actions for the listener.
	DefaultActions []*Action
	// The Amazon Resource Name (ARN) of the load balancer.
	LoadBalancerArn *string
	// [TLS listener] The name of the Application-Layer Protocol Negotiation (ALPN)
	// policy.
	AlpnPolicy []*string
	// The Amazon Resource Name (ARN) of the listener.
	ListenerArn *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

func (*ListenerNotFoundException) GetMessage 

func (e *ListenerNotFoundException) GetMessage() string

func (*ListenerNotFoundException) HasMessage 

func (e *ListenerNotFoundException) HasMessage() bool

type LoadBalancer 

type LoadBalancer struct {
	// The state of the load balancer.
	State *LoadBalancerState
	// The ID of the Amazon Route 53 hosted zone associated with the load balancer.
	CanonicalHostedZoneId *string
	// The name of the load balancer.
	LoadBalancerName *string
	// The public DNS name of the load balancer.
	DNSName *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 date and time the load balancer was created.
	CreatedTime *time.Time
	// The IDs of the security groups for the load balancer.
	SecurityGroups []*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 Availability Zones for the load balancer.
	AvailabilityZones []*AvailabilityZone
	// The type of load balancer.
	Type LoadBalancerTypeEnum
	// The Amazon Resource Name (ARN) of the load balancer.
	LoadBalancerArn *string
	// The ID of the VPC for the load balancer.
	VpcId *string
}

Information about a load balancer.

type LoadBalancerAddress 

type LoadBalancerAddress struct {
	// The static IP address.
	IpAddress *string
	// [Network Load Balancers] The allocation ID of the Elastic IP address for an
	// internal-facing load balancer.
	AllocationId *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

func (*LoadBalancerNotFoundException) GetMessage 

func (e *LoadBalancerNotFoundException) GetMessage() string

func (*LoadBalancerNotFoundException) HasMessage 

func (e *LoadBalancerNotFoundException) HasMessage() bool

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.
	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

func (*OperationNotPermittedException) GetMessage 

func (e *OperationNotPermittedException) GetMessage() string

func (*OperationNotPermittedException) HasMessage 

func (e *OperationNotPermittedException) HasMessage() bool

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

func (*PriorityInUseException) GetMessage 

func (e *PriorityInUseException) GetMessage() string

func (*PriorityInUseException) HasMessage 

func (e *PriorityInUseException) HasMessage() bool

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 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 HTTP redirect code. The redirect is either permanent (HTTP 301) or temporary
	// (HTTP 302).
	StatusCode RedirectActionStatusCodeEnum
	// 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
	// The port. You can specify a value from 1 to 65535 or #{port}.
	Port *string
	// 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
}

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

func (*ResourceInUseException) GetMessage 

func (e *ResourceInUseException) GetMessage() string

func (*ResourceInUseException) HasMessage 

func (e *ResourceInUseException) HasMessage() bool

type Rule 

type Rule struct {
	// Indicates whether this is the default rule.
	IsDefault *bool
	// The Amazon Resource Name (ARN) of the rule.
	RuleArn *string
	// The priority.
	Priority *string
	// 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
}

Information about a rule.

type RuleCondition 

type RuleCondition struct {
	// 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
	// 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 for a source IP condition. Specify only when Field is source-ip.
	SourceIpConfig *SourceIpConditionConfig
	// Information for a query string condition. Specify only when Field is
	// query-string.
	QueryStringConfig *QueryStringConditionConfig
	// Information for a path pattern condition. Specify only when Field is
	// path-pattern.
	PathPatternConfig *PathPatternConditionConfig
	// 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 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

func (*RuleNotFoundException) GetMessage 

func (e *RuleNotFoundException) GetMessage() string

func (*RuleNotFoundException) HasMessage 

func (e *RuleNotFoundException) HasMessage() bool

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

func (*SSLPolicyNotFoundException) GetMessage 

func (e *SSLPolicyNotFoundException) GetMessage() string

func (*SSLPolicyNotFoundException) HasMessage 

func (e *SSLPolicyNotFoundException) HasMessage() bool

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 protocols.
	SslProtocols []*string
	// The name of the policy.
	Name *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
	// The ID of the subnet.
	SubnetId *string
	// [Network Load Balancers] The private IPv4 address for an internal load balancer.
	PrivateIPv4Address *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

func (*SubnetNotFoundException) GetMessage 

func (e *SubnetNotFoundException) GetMessage() string

func (*SubnetNotFoundException) HasMessage 

func (e *SubnetNotFoundException) HasMessage() bool

type Tag 

type Tag struct {
	// The value of the tag.
	Value *string
	// The key of the tag.
	Key *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.
	Id *string
	// The port on which the target is listening. Not used if the target is a Lambda
	// function.
	Port *int32
	// 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
}

Information about a target.

type TargetGroup 

type TargetGroup struct {
	// The number of consecutive health check failures required before considering the
	// target unhealthy.
	UnhealthyThresholdCount *int32
	// 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 approximate amount of time, in seconds, between health checks of an
	// individual target.
	HealthCheckIntervalSeconds *int32
	// Indicates whether health checks are enabled.
	HealthCheckEnabled *bool
	// The ID of the VPC for the targets.
	VpcId *string
	// The protocol to use for routing traffic to the targets.
	Protocol ProtocolEnum
	// 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 HTTP codes to use when checking for a successful response from a target.
	Matcher *Matcher
	// The destination for the health check request.
	HealthCheckPath *string
	// The Amazon Resource Name (ARN) of the target group.
	TargetGroupArn *string
	// The port on which the targets are listening. Not used if the target is a Lambda
	// function.
	Port *int32
	// The protocol to use to connect with the target.
	HealthCheckProtocol ProtocolEnum
	// The port to use to connect with the target.
	HealthCheckPort *string
	// The Amazon Resource Names (ARN) of the load balancers that route traffic to this
	// target group.
	LoadBalancerArns []*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

func (*TargetGroupAssociationLimitException) GetMessage 

func (e *TargetGroupAssociationLimitException) GetMessage() string

func (*TargetGroupAssociationLimitException) HasMessage 

func (e *TargetGroupAssociationLimitException) HasMessage() bool

type TargetGroupAttribute 

type TargetGroupAttribute struct {
	// The value of the attribute.
	Value *string
	// The name of the attribute.  <p>The following attributes are supported by both
	// Application Load Balancers and Network Load Balancers:</p> <ul> <li> <p>
	// <code>deregistration_delay.timeout_seconds</code> - The amount of time, in
	// seconds, for Elastic Load Balancing to wait before changing the state of a
	// deregistering target from <code>draining</code> to <code>unused</code>. The
	// range is 0-3600 seconds. The default value is 300 seconds. If the target is a
	// Lambda function, this attribute is not supported.</p> </li> <li> <p>
	// <code>stickiness.enabled</code> - Indicates whether sticky sessions are enabled.
	// The value is <code>true</code> or <code>false</code>. The default is
	// <code>false</code>.</p> </li> <li> <p> <code>stickiness.type</code> - The type
	// of sticky sessions. The possible values are <code>lb_cookie</code> for
	// Application Load Balancers or <code>source_ip</code> for Network Load
	// Balancers.</p> </li> </ul> <p>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:</p> <ul> <li> <p> <code>load_balancing.algorithm.type</code> -
	// The load balancing algorithm determines how the load balancer selects targets
	// when routing requests. The value is <code>round_robin</code> or
	// <code>least_outstanding_requests</code>. The default is
	// <code>round_robin</code>.</p> </li> <li> <p>
	// <code>slow_start.duration_seconds</code> - 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.</p> </li> <li> <p>
	// <code>stickiness.lb_cookie.duration_seconds</code> - 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).</p> </li> </ul> <p>The following attribute is
	// supported only if the load balancer is an Application Load Balancer and the
	// target is a Lambda function:</p> <ul> <li> <p>
	// <code>lambda.multi_value_headers.enabled</code> - 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 <code>true</code> or
	// <code>false</code>. The default is <code>false</code>. If the value is
	// <code>false</code> and the request contains a duplicate header field name or
	// query parameter key, the load balancer uses the last value sent by the
	// client.</p> </li> </ul> <p>The following attribute is supported only by Network
	// Load Balancers:</p> <ul> <li> <p> <code>proxy_protocol_v2.enabled</code> -
	// Indicates whether Proxy Protocol version 2 is enabled. The value is
	// <code>true</code> or <code>false</code>. The default is <code>false</code>.</p>
	// </li> </ul>
	Key *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

func (*TargetGroupNotFoundException) GetMessage 

func (e *TargetGroupNotFoundException) GetMessage() string

func (*TargetGroupNotFoundException) HasMessage 

func (e *TargetGroupNotFoundException) HasMessage() bool

type TargetGroupStickinessConfig 

type TargetGroupStickinessConfig struct {
	// Indicates whether target group stickiness is enabled.
	Enabled *bool
	// 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
}

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

func (*TooManyActionsException) GetMessage 

func (e *TooManyActionsException) GetMessage() string

func (*TooManyActionsException) HasMessage 

func (e *TooManyActionsException) HasMessage() bool

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

func (*TooManyCertificatesException) GetMessage 

func (e *TooManyCertificatesException) GetMessage() string

func (*TooManyCertificatesException) HasMessage 

func (e *TooManyCertificatesException) HasMessage() bool

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

func (*TooManyListenersException) GetMessage 

func (e *TooManyListenersException) GetMessage() string

func (*TooManyListenersException) HasMessage 

func (e *TooManyListenersException) HasMessage() bool

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

func (*TooManyLoadBalancersException) GetMessage 

func (e *TooManyLoadBalancersException) GetMessage() string

func (*TooManyLoadBalancersException) HasMessage 

func (e *TooManyLoadBalancersException) HasMessage() bool

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

func (*TooManyRegistrationsForTargetIdException) GetMessage 

func (e *TooManyRegistrationsForTargetIdException) GetMessage() string

func (*TooManyRegistrationsForTargetIdException) HasMessage 

func (e *TooManyRegistrationsForTargetIdException) HasMessage() bool

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

func (*TooManyRulesException) GetMessage 

func (e *TooManyRulesException) GetMessage() string

func (*TooManyRulesException) HasMessage 

func (e *TooManyRulesException) HasMessage() bool

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

func (*TooManyTagsException) GetMessage 

func (e *TooManyTagsException) GetMessage() string

func (*TooManyTagsException) HasMessage 

func (e *TooManyTagsException) HasMessage() bool

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

func (*TooManyTargetGroupsException) GetMessage 

func (e *TooManyTargetGroupsException) GetMessage() string

func (*TooManyTargetGroupsException) HasMessage 

func (e *TooManyTargetGroupsException) HasMessage() bool

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

func (*TooManyTargetsException) GetMessage 

func (e *TooManyTargetsException) GetMessage() string

func (*TooManyTargetsException) HasMessage 

func (e *TooManyTargetsException) HasMessage() bool

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

func (*TooManyUniqueTargetGroupsPerLoadBalancerException) GetMessage 

func (e *TooManyUniqueTargetGroupsPerLoadBalancerException) GetMessage() string

func (*TooManyUniqueTargetGroupsPerLoadBalancerException) HasMessage 

func (e *TooManyUniqueTargetGroupsPerLoadBalancerException) HasMessage() bool

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

func (*UnsupportedProtocolException) GetMessage 

func (e *UnsupportedProtocolException) GetMessage() string

func (*UnsupportedProtocolException) HasMessage 

func (e *UnsupportedProtocolException) HasMessage() bool

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.