Package: aws-cdk.aws-elasticloadbalancingv2
Amazon Elastic Load Balancing V2 Construct Library---AWS CDK v1 has reached End-of-Support on 2023-06-01.
This package is no longer being updated, and users should migrate to AWS CDK v2.For more information on how to migrate, see theMigrating to AWS CDK v2guide.The@aws-cdk/aws-elasticloadbalancingv2package provides constructs for
configuring application and network load balancers.For more information, see the AWS documentation forApplication Load BalancersandNetwork Load Balancers.Defining an Application Load BalancerYou define an application load balancer by creating an instance ofApplicationLoadBalancer, adding a Listener to the load balancer
and adding Targets to the Listener:fromaws_cdk.aws_autoscalingimportAutoScalingGroup# asg: AutoScalingGroup# vpc: ec2.Vpc# Create the load balancer in a VPC. 'internetFacing' is 'false'# by default, which creates an internal load balancer.lb=elbv2.ApplicationLoadBalancer(self,"LB",vpc=vpc,internet_facing=True)# Add a listener and open up the load balancer's security group# to the world.listener=lb.add_listener("Listener",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)# Create an AutoScaling group and add it as a load balancing# target to the listener.listener.add_targets("ApplicationFleet",port=8080,targets=[asg])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: ec2.Vpcsecurity_group1=ec2.SecurityGroup(self,"SecurityGroup1",vpc=vpc)lb=elbv2.ApplicationLoadBalancer(self,"LB",vpc=vpc,internet_facing=True,security_group=security_group1)security_group2=ec2.SecurityGroup(self,"SecurityGroup2",vpc=vpc)lb.add_security_group(security_group2)ConditionsIt'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 forexample.com/okorexample.com/path:# listener: elbv2.ApplicationListener# asg: autoscaling.AutoScalingGrouplistener.add_targets("Example.Com Fleet",priority=10,conditions=[elbv2.ListenerCondition.host_headers(["example.com"]),elbv2.ListenerCondition.path_patterns(["/ok","/path"])],port=8080,targets=[asg])A target with a condition contains eitherpathPatternsorhostHeader, or
both. If both are specified, both conditions must be met for the requests to
be routed to the given target.priorityis 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.Convenience methods and more complex ActionsRouting traffic from a Load Balancer to a Target involves the following steps:Create a Target Group, register the Target into the Target GroupAdd an Action to the Listener which forwards traffic to the Target Group.A new listener can be added to the Load Balancer by callingaddListener().
Listeners that have been added to the load balancer can be listed using thelistenersproperty.  Note that thelistenersproperty will throw an Error
for imported or looked up Load Balancers.Various methods on theListenertake 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).UsingaddAction()gives you access to some of the features of an Elastic Load
Balancer that the other two convenience methods don't:Routing stickiness: useListenerAction.forward()and supply astickinessDurationto make sure requests are routed to the same target group
for a given duration.Weighted Target Groups: useListenerAction.weightedForward()to give different weights to different target groups.Fixed Responses: useListenerAction.fixedResponse()to serve
a static response (ALB only).Redirects: useListenerAction.redirect()to serve an HTTP
redirect response (ALB only).Authentication: useListenerAction.authenticateOidc()to
perform OpenID authentication before serving a request (see the@aws-cdk/aws-elasticloadbalancingv2-actionspackage for direct authentication
integration with Cognito) (ALB only).Here's an example of serving a fixed response at the/okURL:# listener: elbv2.ApplicationListenerlistener.add_action("Fixed",priority=10,conditions=[elbv2.ListenerCondition.path_patterns(["/ok"])],action=elbv2.ListenerAction.fixed_response(200,content_type=elbv2.ContentType.TEXT_PLAIN,message_body="OK"))Here's an example of using OIDC authentication before forwarding to a TargetGroup:# listener: elbv2.ApplicationListener# my_target_group: elbv2.ApplicationTargetGrouplistener.add_action("DefaultAction",action=elbv2.ListenerAction.authenticate_oidc(authorization_endpoint="https://example.com/openid",# Other OIDC properties hereclient_id="...",client_secret=SecretValue.secrets_manager("..."),issuer="...",token_endpoint="...",user_info_endpoint="...",# Nextnext=elbv2.ListenerAction.forward([my_target_group])))If you just want to redirect all incoming traffic on one port to another port, you can use the following code:# lb: elbv2.ApplicationLoadBalancerlb.add_redirect(source_protocol=elbv2.ApplicationProtocol.HTTPS,source_port=8443,target_protocol=elbv2.ApplicationProtocol.HTTP,target_port=8080)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 setopen: falseand use the listener'sconnectionsobject to selectively grant access to the listener.Defining a Network Load BalancerNetwork Load Balancers are defined in a similar way to Application Load
Balancers:# vpc: ec2.Vpc# asg: autoscaling.AutoScalingGroup# Create the load balancer in a VPC. 'internetFacing' is 'false'# by default, which creates an internal load balancer.lb=elbv2.NetworkLoadBalancer(self,"LB",vpc=vpc,internet_facing=True)# Add a listener on a particular port.listener=lb.add_listener("Listener",port=443)# Add targets on a particular port.listener.add_targets("AppFleet",port=443,targets=[asg])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.  SeeTarget Groups for your Network Load
BalancersandRegister targets with your Target
Groupfor more information.Targets and Target GroupsApplication 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 appropriateTargetGroupwill be automatically created for you.If you need more control over the Target Groups created, create an instance ofApplicationTargetGrouporNetworkTargetGroup, add the members you desire,
and add it to the listener by callingaddTargetGroupsinstead ofaddTargets.addTargets()will always return the Target Group it just created for you:# listener: elbv2.NetworkListener# asg1: autoscaling.AutoScalingGroup# asg2: autoscaling.AutoScalingGroupgroup=listener.add_targets("AppFleet",port=443,targets=[asg1])group.add_target(asg2)Sticky sessions for your Application Load BalancerBy 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: ec2.Vpc# Target group with duration-based stickiness with load-balancer generated cookietg1=elbv2.ApplicationTargetGroup(self,"TG1",target_type=elbv2.TargetType.INSTANCE,port=80,stickiness_cookie_duration=Duration.minutes(5),vpc=vpc)# Target group with application-based stickinesstg2=elbv2.ApplicationTargetGroup(self,"TG2",target_type=elbv2.TargetType.INSTANCE,port=80,stickiness_cookie_duration=Duration.minutes(5),stickiness_cookie_name="MyDeliciousCookie",vpc=vpc)For more information see:https://docs.aws.amazon.com/elasticloadbalancing/latest/application/sticky-sessions.html#application-based-stickinessSetting the target group protocol versionBy default, Application Load Balancers send requests to targets using HTTP/1.1. You can use theprotocol versionto send requests to targets using HTTP/2 or gRPC.# vpc: ec2.Vpctg=elbv2.ApplicationTargetGroup(self,"TG",target_type=elbv2.TargetType.IP,port=50051,protocol=elbv2.ApplicationProtocol.HTTP,protocol_version=elbv2.ApplicationProtocolVersion.GRPC,health_check=elbv2.HealthCheck(enabled=True,healthy_grpc_codes="0-99"),vpc=vpc)Using Lambda TargetsTo use a Lambda Function as a target, use the integration class in the@aws-cdk/aws-elasticloadbalancingv2-targetspackage:importaws_cdk.aws_lambdaaslambda_importaws_cdk.aws_elasticloadbalancingv2_targetsastargets# lambda_function: lambda.Function# lb: elbv2.ApplicationLoadBalancerlistener=lb.add_listener("Listener",port=80)listener.add_targets("Targets",targets=[targets.LambdaTarget(lambda_function)],# For Lambda Targets, you need to explicitly enable health checks if you# want them.health_check=elbv2.HealthCheck(enabled=True))Only a single Lambda function can be added to a single listener rule.Using Application Load Balancer TargetsTo use a single application load balancer as a target for the network load balancer, use the integration class in the@aws-cdk/aws-elasticloadbalancingv2-targetspackage:importaws_cdk.aws_elasticloadbalancingv2_targetsastargetsimportaws_cdk.aws_ecsasecsimportaws_cdk.aws_ecs_patternsaspatterns# vpc: ec2.Vpctask=ecs.FargateTaskDefinition(self,"Task",cpu=256,memory_limit_mi_b=512)task.add_container("nginx",image=ecs.ContainerImage.from_registry("public.ecr.aws/nginx/nginx:latest"),port_mappings=[ecs.PortMapping(container_port=80)])svc=patterns.ApplicationLoadBalancedFargateService(self,"Service",vpc=vpc,task_definition=task,public_load_balancer=False)nlb=elbv2.NetworkLoadBalancer(self,"Nlb",vpc=vpc,cross_zone_enabled=True,internet_facing=True)listener=nlb.add_listener("listener",port=80)listener.add_targets("Targets",targets=[targets.AlbTarget(svc.load_balancer,80)],port=80)CfnOutput(self,"NlbEndpoint",value=f"http://{nlb.loadBalancerDnsName}")Only the network load balancer is allowed to add the application load balancer as the target.Configuring Health ChecksHealth checks are configured upon creation of a target group:# listener: elbv2.ApplicationListener# asg: autoscaling.AutoScalingGrouplistener.add_targets("AppFleet",port=8080,targets=[asg],health_check=elbv2.HealthCheck(path="/ping",interval=Duration.minutes(1)))The health check can also be configured after creation by callingconfigureHealthCheck()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:# lb: elbv2.ApplicationLoadBalancer# listener: elbv2.ApplicationListener# asg: autoscaling.AutoScalingGrouplistener.add_targets("AppFleet",port=8080,targets=[asg],health_check=elbv2.HealthCheck(port="8088"))asg.connections.allow_from(lb,ec2.Port.tcp(8088))Using a Load Balancer from a different StackIf 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 methodsloadBalancer.addListener()andlistener.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 anApplicationListenerin the target stack,
or an emptyTargetGroupin the load balancer stack that you attach your
service to.For an example of the alternatives while load balancing to an ECS service, see theecs/cross-stack-load-balancer
example.Protocol for Load Balancer TargetsConstructs that want to be a load balancer target should implementIApplicationLoadBalancerTargetand/orINetworkLoadBalancerTarget, and
provide an implementation for the functionattachToXxxTargetGroup(), which can
call functions on the load balancer and should return metadata about the
load balancing target:classMyTarget(elbv2.IApplicationLoadBalancerTarget):defattach_to_application_target_group(self,target_group):# If we need to add security group rules# targetGroup.registerConnectable(...);returnelbv2.LoadBalancerTargetProps(target_type=elbv2.TargetType.IP,target_json={"id":"1.2.3.4","port":8080})targetTypeshould be one ofInstanceorIp. If the target can be
directly added to the target group,targetJsonshould contain theidof
the target (either instance ID or IP address depending on the type) and
optionally aportoravailabilityZoneoverride.Application load balancer targets can callregisterConnectable()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 ontargetGroup.loadBalancerAttachedas follows:# resource: Resource# target_group: elbv2.ApplicationTargetGroup# 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).add_dependency(target_group.load_balancer_attached)Looking up Load Balancers and ListenersYou 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.Load Balancer lookup optionsYou 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 ARNload_balancer=elbv2.ApplicationLoadBalancer.from_lookup(self,"ALB",load_balancer_arn="arn:aws:elasticloadbalancing:us-east-2:123456789012:loadbalancer/app/my-load-balancer/1234567890123456")Look up an Application Load Balancer by tagsload_balancer=elbv2.ApplicationLoadBalancer.from_lookup(self,"ALB",load_balancer_tags={# Finds a load balancer matching all tags."some":"tag","someother":"tag"})Load Balancer Listener lookup optionsYou may look up a load balancer listener by the following criteria:Associated load balancer ARNAssociated load balancer tagsListener ARNListener portListener protocolThe 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 Protocollistener=elbv2.ApplicationListener.from_lookup(self,"ALBListener",load_balancer_arn="arn:aws:elasticloadbalancing:us-east-2:123456789012:loadbalancer/app/my-load-balancer/1234567890123456",listener_protocol=elbv2.ApplicationProtocol.HTTPS,listener_port=443)Look up a Listener by associated Load Balancer Tag, Port, and Protocollistener=elbv2.ApplicationListener.from_lookup(self,"ALBListener",load_balancer_tags={"Cluster":"MyClusterName"},listener_protocol=elbv2.ApplicationProtocol.HTTPS,listener_port=443)Look up a Network Listener by associated Load Balancer Tag, Port, and Protocollistener=elbv2.NetworkListener.from_lookup(self,"ALBListener",load_balancer_tags={"Cluster":"MyClusterName"},listener_protocol=elbv2.Protocol.TCP,listener_port=12345)