Module types

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that Elastic Load Balancing can respond with.

Structs

Action

Information about an action.

Each rule must include exactly one of the following types of actions: forward, fixed-response, or redirect, and it must be the last action to be performed.

AdministrativeOverride

Information about the override status applied to a target.

AnomalyDetection

Information about anomaly detection and mitigation.

AuthenticateCognitoActionConfig

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

AuthenticateOidcActionConfig

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

AvailabilityZone

Information about an Availability Zone.

CapacityReservationStatus

The status of a capacity reservation.

Certificate

Information about an SSL server certificate.

Cipher

Information about a cipher used in a policy.

DescribeTrustStoreRevocation

Information about the revocations used by a trust store.

FixedResponseActionConfig

Information about an action that returns a custom HTTP response.

ForwardActionConfig

Information about a forward action.

HostHeaderConditionConfig

Information about a host header condition.

HttpHeaderConditionConfig

Information about an HTTP header condition.

There is a set of standard HTTP header fields. You can also define custom HTTP header fields.

HttpRequestMethodConditionConfig

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. You can also define custom HTTP methods.

IpamPools

An IPAM pool is a collection of IP address CIDRs. IPAM pools enable you to organize your IP addresses according to your routing and security needs.

Limit

Information about an Elastic Load Balancing resource limit for your Amazon Web Services account.

For more information, see the following:

• Quotas for your Application Load Balancers

• Quotas for your Network Load Balancers

• Quotas for your Gateway Load Balancers

Listener

Information about a listener.

ListenerAttribute

Information about a listener attribute.

LoadBalancer

Information about a load balancer.

LoadBalancerAddress

Information about a static IP address for a load balancer.

LoadBalancerAttribute

Information about a load balancer attribute.

LoadBalancerState

Information about the state of the load balancer.

Matcher

The codes to use when checking for a successful response from a target. If the protocol version is gRPC, these are gRPC codes. Otherwise, these are HTTP codes.

MinimumLoadBalancerCapacity

The minimum capacity for a load balancer.

MutualAuthenticationAttributes

Information about the mutual authentication attributes of a listener.

PathPatternConditionConfig

Information about a path pattern condition.

QueryStringConditionConfig

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.

QueryStringKeyValuePair

Information about a key/value pair.

RedirectActionConfig

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

RevocationContent

Information about a revocation file.

Rule

Information about a rule.

RuleCondition

Information about a condition for a rule.

Each rule can optionally include up to one of each of the following conditions: http-request-method, host-header, path-pattern, and source-ip. Each rule can also optionally include one or more of each of the following conditions: http-header and query-string. Note that the value for a condition can't be empty.

For more information, see Quotas for your Application Load Balancers.

RulePriorityPair

Information about the priorities for the rules for a listener.

SourceIpConditionConfig

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.

SslPolicy

Information about a policy used for SSL negotiation.

SubnetMapping

Information about a subnet mapping.

Tag

Information about a tag.

TagDescription

The tags associated with a resource.

TargetDescription

Information about a target.

TargetGroup

Information about a target group.

TargetGroupAttribute

Information about a target group attribute.

TargetGroupStickinessConfig

Information about the target group stickiness for a rule.

TargetGroupTuple

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

TargetHealth

Information about the current health of a target.

TargetHealthDescription

Information about the health of a target.

TrustStore

Information about a trust store.

TrustStoreAssociation

Information about the resources a trust store is associated with.

TrustStoreRevocation

Information about a revocation file in use by a trust store.

ZonalCapacityReservationState

The capacity reservation status for each availability zone.

Enums

ActionTypeEnum

When writing a match expression against ActionTypeEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

AdvertiseTrustStoreCaNamesEnum

When writing a match expression against AdvertiseTrustStoreCaNamesEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

AnomalyResultEnum

When writing a match expression against AnomalyResultEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

AuthenticateCognitoActionConditionalBehaviorEnum

When writing a match expression against AuthenticateCognitoActionConditionalBehaviorEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

AuthenticateOidcActionConditionalBehaviorEnum

When writing a match expression against AuthenticateOidcActionConditionalBehaviorEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

CapacityReservationStateEnum

When writing a match expression against CapacityReservationStateEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DescribeTargetHealthInputIncludeEnum

When writing a match expression against DescribeTargetHealthInputIncludeEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

EnablePrefixForIpv6SourceNatEnum

When writing a match expression against EnablePrefixForIpv6SourceNatEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

EnforceSecurityGroupInboundRulesOnPrivateLinkTrafficEnum

When writing a match expression against EnforceSecurityGroupInboundRulesOnPrivateLinkTrafficEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

IpAddressType

When writing a match expression against IpAddressType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LoadBalancerSchemeEnum

When writing a match expression against LoadBalancerSchemeEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LoadBalancerStateEnum

When writing a match expression against LoadBalancerStateEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LoadBalancerTypeEnum

When writing a match expression against LoadBalancerTypeEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

MitigationInEffectEnum

When writing a match expression against MitigationInEffectEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ProtocolEnum

When writing a match expression against ProtocolEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

RedirectActionStatusCodeEnum

When writing a match expression against RedirectActionStatusCodeEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

RemoveIpamPoolEnum

When writing a match expression against RemoveIpamPoolEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

RevocationType

When writing a match expression against RevocationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TargetAdministrativeOverrideReasonEnum

When writing a match expression against TargetAdministrativeOverrideReasonEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TargetAdministrativeOverrideStateEnum

When writing a match expression against TargetAdministrativeOverrideStateEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TargetGroupIpAddressTypeEnum

When writing a match expression against TargetGroupIpAddressTypeEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TargetHealthReasonEnum

When writing a match expression against TargetHealthReasonEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TargetHealthStateEnum

When writing a match expression against TargetHealthStateEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TargetTypeEnum

When writing a match expression against TargetTypeEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TrustStoreAssociationStatusEnum

When writing a match expression against TrustStoreAssociationStatusEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TrustStoreStatus

When writing a match expression against TrustStoreStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.