See: Description
Interface | Description |
---|---|
AddApplicationActionProps |
Properties for adding a new action to a listener.
|
AddApplicationTargetGroupsProps |
Properties for adding a new target group to a listener.
|
AddApplicationTargetsProps |
Properties for adding new targets to a listener.
|
AddFixedResponseProps | Deprecated
Use `ApplicationListener.addAction` instead.
|
AddNetworkActionProps |
Properties for adding a new action to a listener.
|
AddNetworkTargetsProps |
Properties for adding new network targets to a listener.
|
AddRedirectResponseProps | Deprecated
Use `ApplicationListener.addAction` instead.
|
AddRuleProps |
Properties for adding a conditional load balancing rule.
|
ApplicationListenerAttributes |
Properties to reference an existing listener.
|
ApplicationListenerCertificateProps |
Properties for adding a set of certificates to a listener.
|
ApplicationListenerLookupOptions |
Options for ApplicationListener lookup.
|
ApplicationListenerProps |
Properties for defining a standalone ApplicationListener.
|
ApplicationListenerRuleProps |
Properties for defining a listener rule.
|
ApplicationLoadBalancerAttributes |
Properties to reference an existing load balancer.
|
ApplicationLoadBalancerLookupOptions |
Options for looking up an ApplicationLoadBalancer.
|
ApplicationLoadBalancerProps |
Properties for defining an Application Load Balancer.
|
ApplicationLoadBalancerRedirectConfig |
Properties for a redirection config.
|
ApplicationTargetGroupProps |
Properties for defining an Application Target Group.
|
AuthenticateOidcOptions |
Options for `ListenerAction.authenciateOidc()`.
|
BaseApplicationListenerProps |
Basic properties for an ApplicationListener.
|
BaseApplicationListenerRuleProps |
Basic properties for defining a rule on a listener.
|
BaseListenerLookupOptions |
Options for listener lookup.
|
BaseLoadBalancerLookupOptions |
Options for looking up load balancers.
|
BaseLoadBalancerProps |
Shared properties of both Application and Network Load Balancers.
|
BaseNetworkListenerProps |
Basic properties for a Network Listener.
|
BaseTargetGroupProps |
Basic properties of both Application and Network Target Groups.
|
CfnListener.ActionProperty |
Specifies an action for a listener rule.
|
CfnListener.AuthenticateCognitoConfigProperty |
Specifies information required when integrating with Amazon Cognito to authenticate users.
|
CfnListener.AuthenticateOidcConfigProperty |
Specifies information required using an identity provide (IdP) that is compliant with OpenID Connect (OIDC) to authenticate users.
|
CfnListener.CertificateProperty |
Specifies an SSL server certificate to use as the default certificate for a secure listener.
|
CfnListener.FixedResponseConfigProperty |
Specifies information required when returning a custom HTTP response.
|
CfnListener.ForwardConfigProperty |
Information for creating an action that distributes requests among one or more target groups.
|
CfnListener.RedirectConfigProperty |
Information about a redirect action.
|
CfnListener.TargetGroupStickinessConfigProperty |
Information about the target group stickiness for a rule.
|
CfnListener.TargetGroupTupleProperty |
Information about how traffic will be distributed between multiple target groups in a forward rule.
|
CfnListenerCertificate.CertificateProperty |
Specifies an SSL server certificate for the certificate list of a secure listener.
|
CfnListenerCertificateProps |
Properties for defining a `CfnListenerCertificate`.
|
CfnListenerProps |
Properties for defining a `CfnListener`.
|
CfnListenerRule.ActionProperty |
Specifies an action for a listener rule.
|
CfnListenerRule.AuthenticateCognitoConfigProperty |
Specifies information required when integrating with Amazon Cognito to authenticate users.
|
CfnListenerRule.AuthenticateOidcConfigProperty |
Specifies information required using an identity provide (IdP) that is compliant with OpenID Connect (OIDC) to authenticate users.
|
CfnListenerRule.FixedResponseConfigProperty |
Specifies information required when returning a custom HTTP response.
|
CfnListenerRule.ForwardConfigProperty |
Information for creating an action that distributes requests among one or more target groups.
|
CfnListenerRule.HostHeaderConfigProperty |
Information about a host header condition.
|
CfnListenerRule.HttpHeaderConfigProperty |
Information about an HTTP header condition.
|
CfnListenerRule.HttpRequestMethodConfigProperty |
Information about an HTTP method condition.
|
CfnListenerRule.PathPatternConfigProperty |
Information about a path pattern condition.
|
CfnListenerRule.QueryStringConfigProperty |
Information about a query string condition.
|
CfnListenerRule.QueryStringKeyValueProperty |
Information about a key/value pair.
|
CfnListenerRule.RedirectConfigProperty |
Information about a redirect action.
|
CfnListenerRule.RuleConditionProperty |
Specifies a condition for a listener rule.
|
CfnListenerRule.SourceIpConfigProperty |
Information about a source IP condition.
|
CfnListenerRule.TargetGroupStickinessConfigProperty |
Information about the target group stickiness for a rule.
|
CfnListenerRule.TargetGroupTupleProperty |
Information about how traffic will be distributed between multiple target groups in a forward rule.
|
CfnListenerRuleProps |
Properties for defining a `CfnListenerRule`.
|
CfnLoadBalancer.LoadBalancerAttributeProperty |
Specifies an attribute for an Application Load Balancer, a Network Load Balancer, or a Gateway Load Balancer.
|
CfnLoadBalancer.SubnetMappingProperty |
Specifies a subnet for a load balancer.
|
CfnLoadBalancerProps |
Properties for defining a `CfnLoadBalancer`.
|
CfnTargetGroup.MatcherProperty |
Specifies the HTTP codes that healthy targets must use when responding to an HTTP health check.
|
CfnTargetGroup.TargetDescriptionProperty |
Specifies a target to add to a target group.
|
CfnTargetGroup.TargetGroupAttributeProperty |
Specifies a target group attribute.
|
CfnTargetGroupProps |
Properties for defining a `CfnTargetGroup`.
|
FixedResponse | Deprecated
superceded by `ListenerAction.fixedResponse()`.
|
FixedResponseOptions |
Options for `ListenerAction.fixedResponse()`.
|
ForwardOptions |
Options for `ListenerAction.forward()`.
|
HealthCheck |
Properties for configuring a health check.
|
IApplicationListener |
Properties to reference an existing listener.
|
IApplicationListener.Jsii$Default |
Internal default implementation for
IApplicationListener . |
IApplicationLoadBalancer |
An application load balancer.
|
IApplicationLoadBalancer.Jsii$Default |
Internal default implementation for
IApplicationLoadBalancer . |
IApplicationLoadBalancerTarget |
Interface for constructs that can be targets of an application load balancer.
|
IApplicationLoadBalancerTarget.Jsii$Default |
Internal default implementation for
IApplicationLoadBalancerTarget . |
IApplicationTargetGroup |
A Target Group for Application Load Balancers.
|
IApplicationTargetGroup.Jsii$Default |
Internal default implementation for
IApplicationTargetGroup . |
IListenerAction |
Interface for listener actions.
|
IListenerAction.Jsii$Default |
Internal default implementation for
IListenerAction . |
IListenerCertificate |
A certificate source for an ELBv2 listener.
|
IListenerCertificate.Jsii$Default |
Internal default implementation for
IListenerCertificate . |
ILoadBalancerV2 | |
ILoadBalancerV2.Jsii$Default |
Internal default implementation for
ILoadBalancerV2 . |
INetworkListener |
Properties to reference an existing listener.
|
INetworkListener.Jsii$Default |
Internal default implementation for
INetworkListener . |
INetworkListenerCertificateProps | Deprecated
Use IListenerCertificate instead
|
INetworkListenerCertificateProps.Jsii$Default |
Internal default implementation for
INetworkListenerCertificateProps . |
INetworkLoadBalancer |
A network load balancer.
|
INetworkLoadBalancer.Jsii$Default |
Internal default implementation for
INetworkLoadBalancer . |
INetworkLoadBalancerTarget |
Interface for constructs that can be targets of an network load balancer.
|
INetworkLoadBalancerTarget.Jsii$Default |
Internal default implementation for
INetworkLoadBalancerTarget . |
INetworkTargetGroup |
A network target group.
|
INetworkTargetGroup.Jsii$Default |
Internal default implementation for
INetworkTargetGroup . |
ITargetGroup |
A target group.
|
ITargetGroup.Jsii$Default |
Internal default implementation for
ITargetGroup . |
LoadBalancerTargetProps |
Result of attaching a target to load balancer.
|
NetworkForwardOptions |
Options for `NetworkListenerAction.forward()`.
|
NetworkListenerLookupOptions |
Options for looking up a network listener.
|
NetworkListenerProps |
Properties for a Network Listener attached to a Load Balancer.
|
NetworkLoadBalancerAttributes |
Properties to reference an existing load balancer.
|
NetworkLoadBalancerLookupOptions |
Options for looking up an NetworkLoadBalancer.
|
NetworkLoadBalancerProps |
Properties for a network load balancer.
|
NetworkTargetGroupProps |
Properties for a new Network Target Group.
|
NetworkWeightedTargetGroup |
A Target Group and weight combination.
|
QueryStringCondition |
Properties for the key/value pair of the query string.
|
RedirectOptions |
Options for `ListenerAction.redirect()`.
|
RedirectResponse | Deprecated
superceded by `ListenerAction.redirect()`.
|
TargetGroupAttributes |
Properties to reference an existing target group.
|
TargetGroupImportProps | Deprecated
Use TargetGroupAttributes instead
|
WeightedTargetGroup |
A Target Group and weight combination.
|
Enum | Description |
---|---|
AlpnPolicy |
Application-Layer Protocol Negotiation Policies for network load balancers.
|
ApplicationProtocol |
Load balancing protocol for application load balancers.
|
ApplicationProtocolVersion |
Load balancing protocol version for application load balancers.
|
ContentType | Deprecated
superceded by `FixedResponseOptions`.
|
HttpCodeElb |
Count of HTTP status originating from the load balancer.
|
HttpCodeTarget |
Count of HTTP status originating from the targets.
|
IpAddressType |
What kind of addresses to allocate to the load balancer.
|
Protocol |
Backend protocol for network load balancers and health checks.
|
SslPolicy |
Elastic Load Balancing provides the following security policies for Application Load Balancers.
|
TargetGroupLoadBalancingAlgorithmType |
Load balancing algorithmm type for target groups.
|
TargetType |
How to interpret the load balancing target identifiers.
|
UnauthenticatedAction |
What to do with unauthenticated requests.
|
---
The @aws-cdk/aws-elasticloadbalancingv2
package provides constructs for
configuring application and network load balancers.
For more information, see the AWS documentation for Application Load Balancers and Network Load Balancers.
You define an application load balancer by creating an instance of
ApplicationLoadBalancer
, adding a Listener to the load balancer
and adding Targets to the Listener:
import software.amazon.awscdk.services.autoscaling.AutoScalingGroup; AutoScalingGroup asg; Vpc vpc; // Create the load balancer in a VPC. 'internetFacing' is 'false' // by default, which creates an internal load balancer. ApplicationLoadBalancer lb = ApplicationLoadBalancer.Builder.create(this, "LB") .vpc(vpc) .internetFacing(true) .build(); // Add a listener and open up the load balancer's security group // to the world. ApplicationListener listener = lb.addListener("Listener", BaseApplicationListenerProps.builder() .port(80) // 'open: true' is the default, you can leave it out if you want. Set it // to 'false' and use `listener.connections` if you want to be selective // about who can access the load balancer. .open(true) .build()); // Create an AutoScaling group and add it as a load balancing // target to the listener. listener.addTargets("ApplicationFleet", AddApplicationTargetsProps.builder() .port(8080) .targets(List.of(asg)) .build());
The security groups of the load balancer and the target are automatically updated to allow the network traffic.
One (or more) security groups can be associated with the load balancer; if a security group isn't provided, one will be automatically created.
Vpc vpc; SecurityGroup securityGroup1 = SecurityGroup.Builder.create(this, "SecurityGroup1").vpc(vpc).build(); ApplicationLoadBalancer lb = ApplicationLoadBalancer.Builder.create(this, "LB") .vpc(vpc) .internetFacing(true) .securityGroup(securityGroup1) .build(); SecurityGroup securityGroup2 = SecurityGroup.Builder.create(this, "SecurityGroup2").vpc(vpc).build(); lb.addSecurityGroup(securityGroup2);
It's possible to route traffic to targets based on conditions in the incoming
HTTP request. For example, the following will route requests to the indicated
AutoScalingGroup only if the requested host in the request is either for
example.com/ok
or example.com/path
:
ApplicationListener listener; AutoScalingGroup asg; listener.addTargets("Example.Com Fleet", AddApplicationTargetsProps.builder() .priority(10) .conditions(List.of(ListenerCondition.hostHeaders(List.of("example.com")), ListenerCondition.pathPatterns(List.of("/ok", "/path")))) .port(8080) .targets(List.of(asg)) .build());
A target with a condition contains either pathPatterns
or hostHeader
, or
both. If both are specified, both conditions must be met for the requests to
be routed to the given target. priority
is a required field when you add
targets with conditions. The lowest number wins.
Every listener must have at least one target without conditions, which is where all requests that didn't match any of the conditions will be sent.
Routing traffic from a Load Balancer to a Target involves the following steps:
A new listener can be added to the Load Balancer by calling addListener()
.
Listeners that have been added to the load balancer can be listed using the
listeners
property. Note that the listeners
property will throw an Error
for imported or looked up Load Balancers.
Various methods on the Listener
take care of this work for you to a greater
or lesser extent:
addTargets()
performs both steps: automatically creates a Target Group and the
required Action.addTargetGroups()
gives you more control: you create the Target Group (or
Target Groups) yourself and the method creates Action that routes traffic to
the Target Groups.addAction()
gives you full control: you supply the Action and wire it up
to the Target Groups yourself (or access one of the other ELB routing features).
Using addAction()
gives you access to some of the features of an Elastic Load
Balancer that the other two convenience methods don't:
ListenerAction.forward()
and supply a
stickinessDuration
to make sure requests are routed to the same target group
for a given duration.ListenerAction.weightedForward()
to give different weights to different target groups.ListenerAction.fixedResponse()
to serve
a static response (ALB only).ListenerAction.redirect()
to serve an HTTP
redirect response (ALB only).ListenerAction.authenticateOidc()
to
perform OpenID authentication before serving a request (see the
@aws-cdk/aws-elasticloadbalancingv2-actions
package for direct authentication
integration with Cognito) (ALB only).
Here's an example of serving a fixed response at the /ok
URL:
ApplicationListener listener; listener.addAction("Fixed", AddApplicationActionProps.builder() .priority(10) .conditions(List.of(ListenerCondition.pathPatterns(List.of("/ok")))) .action(ListenerAction.fixedResponse(200, FixedResponseOptions.builder() .contentType(ContentType.TEXT_PLAIN) .messageBody("OK") .build())) .build());
Here's an example of using OIDC authentication before forwarding to a TargetGroup:
ApplicationListener listener; ApplicationTargetGroup myTargetGroup; listener.addAction("DefaultAction", AddApplicationActionProps.builder() .action(ListenerAction.authenticateOidc(AuthenticateOidcOptions.builder() .authorizationEndpoint("https://example.com/openid") // Other OIDC properties here .clientId("...") .clientSecret(SecretValue.secretsManager("...")) .issuer("...") .tokenEndpoint("...") .userInfoEndpoint("...") // Next .next(ListenerAction.forward(List.of(myTargetGroup))) .build())) .build());
If you just want to redirect all incoming traffic on one port to another port, you can use the following code:
ApplicationLoadBalancer lb; lb.addRedirect(ApplicationLoadBalancerRedirectConfig.builder() .sourceProtocol(ApplicationProtocol.HTTPS) .sourcePort(8443) .targetProtocol(ApplicationProtocol.HTTP) .targetPort(8080) .build());
If you do not provide any options for this method, it redirects HTTP port 80 to HTTPS port 443.
By default all ingress traffic will be allowed on the source port. If you want to be more selective with your
ingress rules then set open: false
and use the listener's connections
object to selectively grant access to the listener.
Network Load Balancers are defined in a similar way to Application Load Balancers:
Vpc vpc; AutoScalingGroup asg; // Create the load balancer in a VPC. 'internetFacing' is 'false' // by default, which creates an internal load balancer. NetworkLoadBalancer lb = NetworkLoadBalancer.Builder.create(this, "LB") .vpc(vpc) .internetFacing(true) .build(); // Add a listener on a particular port. NetworkListener listener = lb.addListener("Listener", BaseNetworkListenerProps.builder() .port(443) .build()); // Add targets on a particular port. listener.addTargets("AppFleet", AddNetworkTargetsProps.builder() .port(443) .targets(List.of(asg)) .build());
One thing to keep in mind is that network load balancers do not have security groups, and no automatic security group configuration is done for you. You will have to configure the security groups of the target yourself to allow traffic by clients and/or load balancer instances, depending on your target types. See Target Groups for your Network Load Balancers and Register targets with your Target Group for more information.
Application and Network Load Balancers organize load balancing targets in Target
Groups. If you add your balancing targets (such as AutoScalingGroups, ECS
services or individual instances) to your listener directly, the appropriate
TargetGroup
will be automatically created for you.
If you need more control over the Target Groups created, create an instance of
ApplicationTargetGroup
or NetworkTargetGroup
, add the members you desire,
and add it to the listener by calling addTargetGroups
instead of addTargets
.
addTargets()
will always return the Target Group it just created for you:
NetworkListener listener; AutoScalingGroup asg1; AutoScalingGroup asg2; NetworkTargetGroup group = listener.addTargets("AppFleet", AddNetworkTargetsProps.builder() .port(443) .targets(List.of(asg1)) .build()); group.addTarget(asg2);
By default, an Application Load Balancer routes each request independently to a registered target based on the chosen load-balancing algorithm. However, you can use the sticky session feature (also known as session affinity) to enable the load balancer to bind a user's session to a specific target. This ensures that all requests from the user during the session are sent to the same target. This feature is useful for servers that maintain state information in order to provide a continuous experience to clients. To use sticky sessions, the client must support cookies.
Application Load Balancers support both duration-based cookies (lb_cookie
) and application-based cookies (app_cookie
). The key to managing sticky sessions is determining how long your load balancer should consistently route the user's request to the same target. Sticky sessions are enabled at the target group level. You can use a combination of duration-based stickiness, application-based stickiness, and no stickiness across all of your target groups.
Vpc vpc; // Target group with duration-based stickiness with load-balancer generated cookie ApplicationTargetGroup tg1 = ApplicationTargetGroup.Builder.create(this, "TG1") .targetType(TargetType.INSTANCE) .port(80) .stickinessCookieDuration(Duration.minutes(5)) .vpc(vpc) .build(); // Target group with application-based stickiness ApplicationTargetGroup tg2 = ApplicationTargetGroup.Builder.create(this, "TG2") .targetType(TargetType.INSTANCE) .port(80) .stickinessCookieDuration(Duration.minutes(5)) .stickinessCookieName("MyDeliciousCookie") .vpc(vpc) .build();
For more information see: https://docs.aws.amazon.com/elasticloadbalancing/latest/application/sticky-sessions.html#application-based-stickiness
By default, Application Load Balancers send requests to targets using HTTP/1.1. You can use the protocol version to send requests to targets using HTTP/2 or gRPC.
Vpc vpc; ApplicationTargetGroup tg = ApplicationTargetGroup.Builder.create(this, "TG") .targetType(TargetType.IP) .port(50051) .protocol(ApplicationProtocol.HTTP) .protocolVersion(ApplicationProtocolVersion.GRPC) .healthCheck(HealthCheck.builder() .enabled(true) .healthyGrpcCodes("0-99") .build()) .vpc(vpc) .build();
To use a Lambda Function as a target, use the integration class in the
@aws-cdk/aws-elasticloadbalancingv2-targets
package:
import software.amazon.awscdk.services.lambda.*; import software.amazon.awscdk.services.elasticloadbalancingv2.targets.*; Function lambdaFunction; ApplicationLoadBalancer lb; ApplicationListener listener = lb.addListener("Listener", BaseApplicationListenerProps.builder().port(80).build()); listener.addTargets("Targets", AddApplicationTargetsProps.builder() .targets(List.of(new LambdaTarget(lambdaFunction))) // For Lambda Targets, you need to explicitly enable health checks if you // want them. .healthCheck(HealthCheck.builder() .enabled(true) .build()) .build());
Only a single Lambda function can be added to a single listener rule.
To use a single application load balancer as a target for the network load balancer, use the integration class in the
@aws-cdk/aws-elasticloadbalancingv2-targets
package:
import software.amazon.awscdk.services.elasticloadbalancingv2.targets.*; import software.amazon.awscdk.services.ecs.*; import software.amazon.awscdk.services.ecs.patterns.*; Vpc vpc; FargateTaskDefinition task = FargateTaskDefinition.Builder.create(this, "Task").cpu(256).memoryLimitMiB(512).build(); task.addContainer("nginx", ContainerDefinitionOptions.builder() .image(ContainerImage.fromRegistry("public.ecr.aws/nginx/nginx:latest")) .portMappings(List.of(PortMapping.builder().containerPort(80).build())) .build()); ApplicationLoadBalancedFargateService svc = ApplicationLoadBalancedFargateService.Builder.create(this, "Service") .vpc(vpc) .taskDefinition(task) .publicLoadBalancer(false) .build(); NetworkLoadBalancer nlb = NetworkLoadBalancer.Builder.create(this, "Nlb") .vpc(vpc) .crossZoneEnabled(true) .internetFacing(true) .build(); NetworkListener listener = nlb.addListener("listener", BaseNetworkListenerProps.builder().port(80).build()); listener.addTargets("Targets", AddNetworkTargetsProps.builder() .targets(List.of(new AlbTarget(svc.getLoadBalancer(), 80))) .port(80) .build()); CfnOutput.Builder.create(this, "NlbEndpoint").value(String.format("http://%s", nlb.getLoadBalancerDnsName())).build();
Only the network load balancer is allowed to add the application load balancer as the target.
Health checks are configured upon creation of a target group:
ApplicationListener listener; AutoScalingGroup asg; listener.addTargets("AppFleet", AddApplicationTargetsProps.builder() .port(8080) .targets(List.of(asg)) .healthCheck(HealthCheck.builder() .path("/ping") .interval(Duration.minutes(1)) .build()) .build());
The health check can also be configured after creation by calling
configureHealthCheck()
on the created object.
No attempts are made to configure security groups for the port you're configuring a health check for, but if the health check is on the same port you're routing traffic to, the security group already allows the traffic. If not, you will have to configure the security groups appropriately:
ApplicationLoadBalancer lb; ApplicationListener listener; AutoScalingGroup asg; listener.addTargets("AppFleet", AddApplicationTargetsProps.builder() .port(8080) .targets(List.of(asg)) .healthCheck(HealthCheck.builder() .port("8088") .build()) .build()); asg.connections.allowFrom(lb, Port.tcp(8088));
If you want to put your Load Balancer and the Targets it is load balancing to in
different stacks, you may not be able to use the convenience methods
loadBalancer.addListener()
and listener.addTargets()
.
The reason is that these methods will create resources in the same Stack as the
object they're called on, which may lead to cyclic references between stacks.
Instead, you will have to create an ApplicationListener
in the target stack,
or an empty TargetGroup
in the load balancer stack that you attach your
service to.
For an example of the alternatives while load balancing to an ECS service, see the ecs/cross-stack-load-balancer example.
Constructs that want to be a load balancer target should implement
IApplicationLoadBalancerTarget
and/or INetworkLoadBalancerTarget
, and
provide an implementation for the function attachToXxxTargetGroup()
, which can
call functions on the load balancer and should return metadata about the
load balancing target:
public class MyTarget implements IApplicationLoadBalancerTarget { public LoadBalancerTargetProps attachToApplicationTargetGroup(ApplicationTargetGroup targetGroup) { // If we need to add security group rules // targetGroup.registerConnectable(...); return LoadBalancerTargetProps.builder() .targetType(TargetType.IP) .targetJson(Map.of("id", "1.2.3.4", "port", 8080)) .build(); } }
targetType
should be one of Instance
or Ip
. If the target can be
directly added to the target group, targetJson
should contain the id
of
the target (either instance ID or IP address depending on the type) and
optionally a port
or availabilityZone
override.
Application load balancer targets can call registerConnectable()
on the
target group to register themselves for addition to the load balancer's security
group rules.
If your load balancer target requires that the TargetGroup has been
associated with a LoadBalancer before registration can happen (such as is the
case for ECS Services for example), take a resource dependency on
targetGroup.loadBalancerAttached
as follows:
Resource resource; ApplicationTargetGroup targetGroup; // Make sure that the listener has been created, and so the TargetGroup // has been associated with the LoadBalancer, before 'resource' is created. Node.of(resource).addDependency(targetGroup.getLoadBalancerAttached());
You may look up load balancers and load balancer listeners by using one of the following lookup methods:
ApplicationLoadBalancer.fromlookup(options)
- Look up an application load
balancer.ApplicationListener.fromLookup(options)
- Look up an application load
balancer listener.NetworkLoadBalancer.fromLookup(options)
- Look up a network load balancer.NetworkListener.fromLookup(options)
- Look up a network load balancer
listener.
You may look up a load balancer by ARN or by associated tags. When you look a load balancer up by ARN, that load balancer will be returned unless CDK detects that the load balancer is of the wrong type. When you look up a load balancer by tags, CDK will return the load balancer matching all specified tags. If more than one load balancer matches, CDK will throw an error requesting that you provide more specific criteria.
Look up a Application Load Balancer by ARN
IApplicationLoadBalancer loadBalancer = ApplicationLoadBalancer.fromLookup(this, "ALB", ApplicationLoadBalancerLookupOptions.builder() .loadBalancerArn("arn:aws:elasticloadbalancing:us-east-2:123456789012:loadbalancer/app/my-load-balancer/1234567890123456") .build());
Look up an Application Load Balancer by tags
IApplicationLoadBalancer loadBalancer = ApplicationLoadBalancer.fromLookup(this, "ALB", ApplicationLoadBalancerLookupOptions.builder() .loadBalancerTags(Map.of( // Finds a load balancer matching all tags. "some", "tag", "someother", "tag")) .build());
You may look up a load balancer listener by the following criteria:
The lookup method will return the matching listener. If more than one listener matches, CDK will throw an error requesting that you specify additional criteria.
Look up a Listener by associated Load Balancer, Port, and Protocol
IApplicationListener listener = ApplicationListener.fromLookup(this, "ALBListener", ApplicationListenerLookupOptions.builder() .loadBalancerArn("arn:aws:elasticloadbalancing:us-east-2:123456789012:loadbalancer/app/my-load-balancer/1234567890123456") .listenerProtocol(ApplicationProtocol.HTTPS) .listenerPort(443) .build());
Look up a Listener by associated Load Balancer Tag, Port, and Protocol
IApplicationListener listener = ApplicationListener.fromLookup(this, "ALBListener", ApplicationListenerLookupOptions.builder() .loadBalancerTags(Map.of( "Cluster", "MyClusterName")) .listenerProtocol(ApplicationProtocol.HTTPS) .listenerPort(443) .build());
Look up a Network Listener by associated Load Balancer Tag, Port, and Protocol
INetworkListener listener = NetworkListener.fromLookup(this, "ALBListener", NetworkListenerLookupOptions.builder() .loadBalancerTags(Map.of( "Cluster", "MyClusterName")) .listenerProtocol(Protocol.TCP) .listenerPort(12345) .build());