Listener class
Provides a Load Balancer Listener resource.
> Note: aws.alb.Listener is known as aws.lb.Listener. The functionality is identical.
Example Usage
Forward Action
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const frontEnd = new aws.lb.LoadBalancer("front_end", {});
const frontEndTargetGroup = new aws.lb.TargetGroup("front_end", {});
const frontEndListener = new aws.lb.Listener("front_end", {
defaultActions: [{
type: "forward",
targetGroupArn: frontEndTargetGroup.arn,
}],
loadBalancerArn: frontEnd.arn,
port: 443,
protocol: "HTTPS",
sslPolicy: "ELBSecurityPolicy-2016-08",
certificateArn: "arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4",
});
import pulumi
import pulumi_aws as aws
front_end = aws.lb.LoadBalancer("front_end")
front_end_target_group = aws.lb.TargetGroup("front_end")
front_end_listener = aws.lb.Listener("front_end",
default_actions=[{
"type": "forward",
"target_group_arn": front_end_target_group.arn,
}],
load_balancer_arn=front_end.arn,
port=443,
protocol="HTTPS",
ssl_policy="ELBSecurityPolicy-2016-08",
certificate_arn="arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var frontEnd = new Aws.LB.LoadBalancer("front_end");
var frontEndTargetGroup = new Aws.LB.TargetGroup("front_end");
var frontEndListener = new Aws.LB.Listener("front_end", new()
{
DefaultActions = new[]
{
new Aws.LB.Inputs.ListenerDefaultActionArgs
{
Type = "forward",
TargetGroupArn = frontEndTargetGroup.Arn,
},
},
LoadBalancerArn = frontEnd.Arn,
Port = 443,
Protocol = "HTTPS",
SslPolicy = "ELBSecurityPolicy-2016-08",
CertificateArn = "arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4",
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lb"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
frontEnd, err := lb.NewLoadBalancer(ctx, "front_end", nil)
if err != nil {
return err
}
frontEndTargetGroup, err := lb.NewTargetGroup(ctx, "front_end", nil)
if err != nil {
return err
}
_, err = lb.NewListener(ctx, "front_end", &lb.ListenerArgs{
DefaultActions: lb.ListenerDefaultActionArray{
&lb.ListenerDefaultActionArgs{
Type: pulumi.String("forward"),
TargetGroupArn: frontEndTargetGroup.Arn,
},
},
LoadBalancerArn: frontEnd.Arn,
Port: pulumi.Int(443),
Protocol: pulumi.String("HTTPS"),
SslPolicy: pulumi.String("ELBSecurityPolicy-2016-08"),
CertificateArn: pulumi.String("arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4"),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_lb_loadbalancer" "front_end" {
}
resource "aws_lb_targetgroup" "front_end" {
}
resource "aws_lb_listener" "front_end" {
default_actions {
type = "forward"
target_group_arn = aws_lb_targetgroup.front_end.arn
}
load_balancer_arn = aws_lb_loadbalancer.front_end.arn
port = "443"
protocol = "HTTPS"
ssl_policy = "ELBSecurityPolicy-2016-08"
certificate_arn = "arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4"
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lb.LoadBalancer;
import com.pulumi.aws.lb.TargetGroup;
import com.pulumi.aws.lb.Listener;
import com.pulumi.aws.lb.ListenerArgs;
import com.pulumi.aws.lb.inputs.ListenerDefaultActionArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var frontEnd = new LoadBalancer("frontEnd");
var frontEndTargetGroup = new TargetGroup("frontEndTargetGroup");
var frontEndListener = new Listener("frontEndListener", ListenerArgs.builder()
.defaultActions(ListenerDefaultActionArgs.builder()
.type("forward")
.targetGroupArn(frontEndTargetGroup.arn())
.build())
.loadBalancerArn(frontEnd.arn())
.port(443)
.protocol("HTTPS")
.sslPolicy("ELBSecurityPolicy-2016-08")
.certificateArn("arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4")
.build());
}
}
resources:
frontEnd:
type: aws:lb:LoadBalancer
name: front_end
frontEndTargetGroup:
type: aws:lb:TargetGroup
name: front_end
frontEndListener:
type: aws:lb:Listener
name: front_end
properties:
defaultActions:
- type: forward
targetGroupArn: ${frontEndTargetGroup.arn}
loadBalancerArn: ${frontEnd.arn}
port: '443'
protocol: HTTPS
sslPolicy: ELBSecurityPolicy-2016-08
certificateArn: arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4
With weighted target groups:
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const frontEnd = new aws.lb.LoadBalancer("front_end", {});
const frontEndBlue = new aws.lb.TargetGroup("front_end_blue", {});
const frontEndGreen = new aws.lb.TargetGroup("front_end_green", {});
const frontEndListener = new aws.lb.Listener("front_end", {
defaultActions: [{
forward: {
targetGroups: [
{
arn: frontEndBlue.arn,
weight: 100,
},
{
arn: frontEndGreen.arn,
weight: 0,
},
],
},
type: "forward",
}],
loadBalancerArn: frontEnd.arn,
port: 443,
protocol: "HTTPS",
sslPolicy: "ELBSecurityPolicy-2016-08",
certificateArn: "arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4",
});
import pulumi
import pulumi_aws as aws
front_end = aws.lb.LoadBalancer("front_end")
front_end_blue = aws.lb.TargetGroup("front_end_blue")
front_end_green = aws.lb.TargetGroup("front_end_green")
front_end_listener = aws.lb.Listener("front_end",
default_actions=[{
"forward": {
"target_groups": [
{
"arn": front_end_blue.arn,
"weight": 100,
},
{
"arn": front_end_green.arn,
"weight": 0,
},
],
},
"type": "forward",
}],
load_balancer_arn=front_end.arn,
port=443,
protocol="HTTPS",
ssl_policy="ELBSecurityPolicy-2016-08",
certificate_arn="arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var frontEnd = new Aws.LB.LoadBalancer("front_end");
var frontEndBlue = new Aws.LB.TargetGroup("front_end_blue");
var frontEndGreen = new Aws.LB.TargetGroup("front_end_green");
var frontEndListener = new Aws.LB.Listener("front_end", new()
{
DefaultActions = new[]
{
new Aws.LB.Inputs.ListenerDefaultActionArgs
{
Forward = new Aws.LB.Inputs.ListenerDefaultActionForwardArgs
{
TargetGroups = new[]
{
new Aws.LB.Inputs.ListenerDefaultActionForwardTargetGroupArgs
{
Arn = frontEndBlue.Arn,
Weight = 100,
},
new Aws.LB.Inputs.ListenerDefaultActionForwardTargetGroupArgs
{
Arn = frontEndGreen.Arn,
Weight = 0,
},
},
},
Type = "forward",
},
},
LoadBalancerArn = frontEnd.Arn,
Port = 443,
Protocol = "HTTPS",
SslPolicy = "ELBSecurityPolicy-2016-08",
CertificateArn = "arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4",
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lb"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
frontEnd, err := lb.NewLoadBalancer(ctx, "front_end", nil)
if err != nil {
return err
}
frontEndBlue, err := lb.NewTargetGroup(ctx, "front_end_blue", nil)
if err != nil {
return err
}
frontEndGreen, err := lb.NewTargetGroup(ctx, "front_end_green", nil)
if err != nil {
return err
}
_, err = lb.NewListener(ctx, "front_end", &lb.ListenerArgs{
DefaultActions: lb.ListenerDefaultActionArray{
&lb.ListenerDefaultActionArgs{
Forward: &lb.ListenerDefaultActionForwardArgs{
TargetGroups: lb.ListenerDefaultActionForwardTargetGroupArray{
&lb.ListenerDefaultActionForwardTargetGroupArgs{
Arn: frontEndBlue.Arn,
Weight: pulumi.Int(100),
},
&lb.ListenerDefaultActionForwardTargetGroupArgs{
Arn: frontEndGreen.Arn,
Weight: pulumi.Int(0),
},
},
},
Type: pulumi.String("forward"),
},
},
LoadBalancerArn: frontEnd.Arn,
Port: pulumi.Int(443),
Protocol: pulumi.String("HTTPS"),
SslPolicy: pulumi.String("ELBSecurityPolicy-2016-08"),
CertificateArn: pulumi.String("arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4"),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_lb_loadbalancer" "front_end" {
}
resource "aws_lb_targetgroup" "front_end_blue" {
}
resource "aws_lb_targetgroup" "front_end_green" {
}
resource "aws_lb_listener" "front_end" {
default_actions {
forward = {
target_groups = [{
"arn" = aws_lb_targetgroup.front_end_blue.arn
"weight" = 100
}, {
"arn" = aws_lb_targetgroup.front_end_green.arn
"weight" = 0
}]
}
type = "forward"
}
load_balancer_arn = aws_lb_loadbalancer.front_end.arn
port = "443"
protocol = "HTTPS"
ssl_policy = "ELBSecurityPolicy-2016-08"
certificate_arn = "arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4"
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lb.LoadBalancer;
import com.pulumi.aws.lb.TargetGroup;
import com.pulumi.aws.lb.Listener;
import com.pulumi.aws.lb.ListenerArgs;
import com.pulumi.aws.lb.inputs.ListenerDefaultActionArgs;
import com.pulumi.aws.lb.inputs.ListenerDefaultActionForwardArgs;
import com.pulumi.aws.lb.inputs.ListenerDefaultActionForwardTargetGroupArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var frontEnd = new LoadBalancer("frontEnd");
var frontEndBlue = new TargetGroup("frontEndBlue");
var frontEndGreen = new TargetGroup("frontEndGreen");
var frontEndListener = new Listener("frontEndListener", ListenerArgs.builder()
.defaultActions(ListenerDefaultActionArgs.builder()
.forward(ListenerDefaultActionForwardArgs.builder()
.targetGroups(
ListenerDefaultActionForwardTargetGroupArgs.builder()
.arn(frontEndBlue.arn())
.weight(100)
.build(),
ListenerDefaultActionForwardTargetGroupArgs.builder()
.arn(frontEndGreen.arn())
.weight(0)
.build())
.build())
.type("forward")
.build())
.loadBalancerArn(frontEnd.arn())
.port(443)
.protocol("HTTPS")
.sslPolicy("ELBSecurityPolicy-2016-08")
.certificateArn("arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4")
.build());
}
}
resources:
frontEnd:
type: aws:lb:LoadBalancer
name: front_end
frontEndBlue:
type: aws:lb:TargetGroup
name: front_end_blue
frontEndGreen:
type: aws:lb:TargetGroup
name: front_end_green
frontEndListener:
type: aws:lb:Listener
name: front_end
properties:
defaultActions:
- forward:
targetGroups:
- arn: ${frontEndBlue.arn}
weight: 100
- arn: ${frontEndGreen.arn}
weight: 0
type: forward
loadBalancerArn: ${frontEnd.arn}
port: '443'
protocol: HTTPS
sslPolicy: ELBSecurityPolicy-2016-08
certificateArn: arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4
To a NLB:
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const frontEnd = new aws.lb.Listener("front_end", {
defaultActions: [{
type: "forward",
targetGroupArn: frontEndAwsLbTargetGroup.arn,
}],
loadBalancerArn: frontEndAwsLb.arn,
port: 443,
protocol: "TLS",
sslPolicy: "ELBSecurityPolicy-2016-08",
certificateArn: "arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4",
alpnPolicy: "HTTP2Preferred",
});
import pulumi
import pulumi_aws as aws
front_end = aws.lb.Listener("front_end",
default_actions=[{
"type": "forward",
"target_group_arn": front_end_aws_lb_target_group["arn"],
}],
load_balancer_arn=front_end_aws_lb["arn"],
port=443,
protocol="TLS",
ssl_policy="ELBSecurityPolicy-2016-08",
certificate_arn="arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4",
alpn_policy="HTTP2Preferred")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var frontEnd = new Aws.LB.Listener("front_end", new()
{
DefaultActions = new[]
{
new Aws.LB.Inputs.ListenerDefaultActionArgs
{
Type = "forward",
TargetGroupArn = frontEndAwsLbTargetGroup.Arn,
},
},
LoadBalancerArn = frontEndAwsLb.Arn,
Port = 443,
Protocol = "TLS",
SslPolicy = "ELBSecurityPolicy-2016-08",
CertificateArn = "arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4",
AlpnPolicy = "HTTP2Preferred",
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lb"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := lb.NewListener(ctx, "front_end", &lb.ListenerArgs{
DefaultActions: lb.ListenerDefaultActionArray{
&lb.ListenerDefaultActionArgs{
Type: pulumi.String("forward"),
TargetGroupArn: pulumi.Any(frontEndAwsLbTargetGroup.Arn),
},
},
LoadBalancerArn: pulumi.Any(frontEndAwsLb.Arn),
Port: pulumi.Int(443),
Protocol: pulumi.String("TLS"),
SslPolicy: pulumi.String("ELBSecurityPolicy-2016-08"),
CertificateArn: pulumi.String("arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4"),
AlpnPolicy: pulumi.String("HTTP2Preferred"),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_lb_listener" "front_end" {
default_actions {
type = "forward"
target_group_arn = frontEndAwsLbTargetGroup.arn
}
load_balancer_arn = frontEndAwsLb.arn
port = "443"
protocol = "TLS"
ssl_policy = "ELBSecurityPolicy-2016-08"
certificate_arn = "arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4"
alpn_policy = "HTTP2Preferred"
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lb.Listener;
import com.pulumi.aws.lb.ListenerArgs;
import com.pulumi.aws.lb.inputs.ListenerDefaultActionArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var frontEnd = new Listener("frontEnd", ListenerArgs.builder()
.defaultActions(ListenerDefaultActionArgs.builder()
.type("forward")
.targetGroupArn(frontEndAwsLbTargetGroup.arn())
.build())
.loadBalancerArn(frontEndAwsLb.arn())
.port(443)
.protocol("TLS")
.sslPolicy("ELBSecurityPolicy-2016-08")
.certificateArn("arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4")
.alpnPolicy("HTTP2Preferred")
.build());
}
}
resources:
frontEnd:
type: aws:lb:Listener
name: front_end
properties:
defaultActions:
- type: forward
targetGroupArn: ${frontEndAwsLbTargetGroup.arn}
loadBalancerArn: ${frontEndAwsLb.arn}
port: '443'
protocol: TLS
sslPolicy: ELBSecurityPolicy-2016-08
certificateArn: arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4
alpnPolicy: HTTP2Preferred
Redirect Action
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const frontEnd = new aws.lb.LoadBalancer("front_end", {});
const frontEndListener = new aws.lb.Listener("front_end", {
defaultActions: [{
redirect: {
port: "443",
protocol: "HTTPS",
statusCode: "HTTP_301",
},
type: "redirect",
}],
loadBalancerArn: frontEnd.arn,
port: 80,
protocol: "HTTP",
});
import pulumi
import pulumi_aws as aws
front_end = aws.lb.LoadBalancer("front_end")
front_end_listener = aws.lb.Listener("front_end",
default_actions=[{
"redirect": {
"port": "443",
"protocol": "HTTPS",
"status_code": "HTTP_301",
},
"type": "redirect",
}],
load_balancer_arn=front_end.arn,
port=80,
protocol="HTTP")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var frontEnd = new Aws.LB.LoadBalancer("front_end");
var frontEndListener = new Aws.LB.Listener("front_end", new()
{
DefaultActions = new[]
{
new Aws.LB.Inputs.ListenerDefaultActionArgs
{
Redirect = new Aws.LB.Inputs.ListenerDefaultActionRedirectArgs
{
Port = "443",
Protocol = "HTTPS",
StatusCode = "HTTP_301",
},
Type = "redirect",
},
},
LoadBalancerArn = frontEnd.Arn,
Port = 80,
Protocol = "HTTP",
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lb"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
frontEnd, err := lb.NewLoadBalancer(ctx, "front_end", nil)
if err != nil {
return err
}
_, err = lb.NewListener(ctx, "front_end", &lb.ListenerArgs{
DefaultActions: lb.ListenerDefaultActionArray{
&lb.ListenerDefaultActionArgs{
Redirect: &lb.ListenerDefaultActionRedirectArgs{
Port: pulumi.String("443"),
Protocol: pulumi.String("HTTPS"),
StatusCode: pulumi.String("HTTP_301"),
},
Type: pulumi.String("redirect"),
},
},
LoadBalancerArn: frontEnd.Arn,
Port: pulumi.Int(80),
Protocol: pulumi.String("HTTP"),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_lb_loadbalancer" "front_end" {
}
resource "aws_lb_listener" "front_end" {
default_actions {
redirect = {
port = "443"
protocol = "HTTPS"
status_code = "HTTP_301"
}
type = "redirect"
}
load_balancer_arn = aws_lb_loadbalancer.front_end.arn
port = "80"
protocol = "HTTP"
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lb.LoadBalancer;
import com.pulumi.aws.lb.Listener;
import com.pulumi.aws.lb.ListenerArgs;
import com.pulumi.aws.lb.inputs.ListenerDefaultActionArgs;
import com.pulumi.aws.lb.inputs.ListenerDefaultActionRedirectArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var frontEnd = new LoadBalancer("frontEnd");
var frontEndListener = new Listener("frontEndListener", ListenerArgs.builder()
.defaultActions(ListenerDefaultActionArgs.builder()
.redirect(ListenerDefaultActionRedirectArgs.builder()
.port("443")
.protocol("HTTPS")
.statusCode("HTTP_301")
.build())
.type("redirect")
.build())
.loadBalancerArn(frontEnd.arn())
.port(80)
.protocol("HTTP")
.build());
}
}
resources:
frontEnd:
type: aws:lb:LoadBalancer
name: front_end
frontEndListener:
type: aws:lb:Listener
name: front_end
properties:
defaultActions:
- redirect:
port: '443'
protocol: HTTPS
statusCode: HTTP_301
type: redirect
loadBalancerArn: ${frontEnd.arn}
port: '80'
protocol: HTTP
Fixed-response Action
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const frontEnd = new aws.lb.LoadBalancer("front_end", {});
const frontEndListener = new aws.lb.Listener("front_end", {
defaultActions: [{
fixedResponse: {
contentType: "text/plain",
messageBody: "Fixed response content",
statusCode: "200",
},
type: "fixed-response",
}],
loadBalancerArn: frontEnd.arn,
port: 80,
protocol: "HTTP",
});
import pulumi
import pulumi_aws as aws
front_end = aws.lb.LoadBalancer("front_end")
front_end_listener = aws.lb.Listener("front_end",
default_actions=[{
"fixed_response": {
"content_type": "text/plain",
"message_body": "Fixed response content",
"status_code": "200",
},
"type": "fixed-response",
}],
load_balancer_arn=front_end.arn,
port=80,
protocol="HTTP")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var frontEnd = new Aws.LB.LoadBalancer("front_end");
var frontEndListener = new Aws.LB.Listener("front_end", new()
{
DefaultActions = new[]
{
new Aws.LB.Inputs.ListenerDefaultActionArgs
{
FixedResponse = new Aws.LB.Inputs.ListenerDefaultActionFixedResponseArgs
{
ContentType = "text/plain",
MessageBody = "Fixed response content",
StatusCode = "200",
},
Type = "fixed-response",
},
},
LoadBalancerArn = frontEnd.Arn,
Port = 80,
Protocol = "HTTP",
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lb"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
frontEnd, err := lb.NewLoadBalancer(ctx, "front_end", nil)
if err != nil {
return err
}
_, err = lb.NewListener(ctx, "front_end", &lb.ListenerArgs{
DefaultActions: lb.ListenerDefaultActionArray{
&lb.ListenerDefaultActionArgs{
FixedResponse: &lb.ListenerDefaultActionFixedResponseArgs{
ContentType: pulumi.String("text/plain"),
MessageBody: pulumi.String("Fixed response content"),
StatusCode: pulumi.String("200"),
},
Type: pulumi.String("fixed-response"),
},
},
LoadBalancerArn: frontEnd.Arn,
Port: pulumi.Int(80),
Protocol: pulumi.String("HTTP"),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_lb_loadbalancer" "front_end" {
}
resource "aws_lb_listener" "front_end" {
default_actions {
fixed_response = {
content_type = "text/plain"
message_body = "Fixed response content"
status_code = "200"
}
type = "fixed-response"
}
load_balancer_arn = aws_lb_loadbalancer.front_end.arn
port = "80"
protocol = "HTTP"
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lb.LoadBalancer;
import com.pulumi.aws.lb.Listener;
import com.pulumi.aws.lb.ListenerArgs;
import com.pulumi.aws.lb.inputs.ListenerDefaultActionArgs;
import com.pulumi.aws.lb.inputs.ListenerDefaultActionFixedResponseArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var frontEnd = new LoadBalancer("frontEnd");
var frontEndListener = new Listener("frontEndListener", ListenerArgs.builder()
.defaultActions(ListenerDefaultActionArgs.builder()
.fixedResponse(ListenerDefaultActionFixedResponseArgs.builder()
.contentType("text/plain")
.messageBody("Fixed response content")
.statusCode("200")
.build())
.type("fixed-response")
.build())
.loadBalancerArn(frontEnd.arn())
.port(80)
.protocol("HTTP")
.build());
}
}
resources:
frontEnd:
type: aws:lb:LoadBalancer
name: front_end
frontEndListener:
type: aws:lb:Listener
name: front_end
properties:
defaultActions:
- fixedResponse:
contentType: text/plain
messageBody: Fixed response content
statusCode: '200'
type: fixed-response
loadBalancerArn: ${frontEnd.arn}
port: '80'
protocol: HTTP
Authenticate-cognito Action
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const frontEnd = new aws.lb.LoadBalancer("front_end", {});
const frontEndTargetGroup = new aws.lb.TargetGroup("front_end", {});
const pool = new aws.cognito.UserPool("pool", {});
const client = new aws.cognito.UserPoolClient("client", {});
const domain = new aws.cognito.UserPoolDomain("domain", {});
const frontEndListener = new aws.lb.Listener("front_end", {
defaultActions: [
{
authenticateCognito: {
userPoolArn: pool.arn,
userPoolClientId: client.id,
userPoolDomain: domain.domain,
},
type: "authenticate-cognito",
},
{
type: "forward",
targetGroupArn: frontEndTargetGroup.arn,
},
],
loadBalancerArn: frontEnd.arn,
port: 80,
protocol: "HTTP",
});
import pulumi
import pulumi_aws as aws
front_end = aws.lb.LoadBalancer("front_end")
front_end_target_group = aws.lb.TargetGroup("front_end")
pool = aws.cognito.UserPool("pool")
client = aws.cognito.UserPoolClient("client")
domain = aws.cognito.UserPoolDomain("domain")
front_end_listener = aws.lb.Listener("front_end",
default_actions=[
{
"authenticate_cognito": {
"user_pool_arn": pool.arn,
"user_pool_client_id": client.id,
"user_pool_domain": domain.domain,
},
"type": "authenticate-cognito",
},
{
"type": "forward",
"target_group_arn": front_end_target_group.arn,
},
],
load_balancer_arn=front_end.arn,
port=80,
protocol="HTTP")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var frontEnd = new Aws.LB.LoadBalancer("front_end");
var frontEndTargetGroup = new Aws.LB.TargetGroup("front_end");
var pool = new Aws.Cognito.UserPool("pool");
var client = new Aws.Cognito.UserPoolClient("client");
var domain = new Aws.Cognito.UserPoolDomain("domain");
var frontEndListener = new Aws.LB.Listener("front_end", new()
{
DefaultActions = new[]
{
new Aws.LB.Inputs.ListenerDefaultActionArgs
{
AuthenticateCognito = new Aws.LB.Inputs.ListenerDefaultActionAuthenticateCognitoArgs
{
UserPoolArn = pool.Arn,
UserPoolClientId = client.Id,
UserPoolDomain = domain.Domain,
},
Type = "authenticate-cognito",
},
new Aws.LB.Inputs.ListenerDefaultActionArgs
{
Type = "forward",
TargetGroupArn = frontEndTargetGroup.Arn,
},
},
LoadBalancerArn = frontEnd.Arn,
Port = 80,
Protocol = "HTTP",
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cognito"
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lb"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
frontEnd, err := lb.NewLoadBalancer(ctx, "front_end", nil)
if err != nil {
return err
}
frontEndTargetGroup, err := lb.NewTargetGroup(ctx, "front_end", nil)
if err != nil {
return err
}
pool, err := cognito.NewUserPool(ctx, "pool", nil)
if err != nil {
return err
}
client, err := cognito.NewUserPoolClient(ctx, "client", nil)
if err != nil {
return err
}
domain, err := cognito.NewUserPoolDomain(ctx, "domain", nil)
if err != nil {
return err
}
_, err = lb.NewListener(ctx, "front_end", &lb.ListenerArgs{
DefaultActions: lb.ListenerDefaultActionArray{
&lb.ListenerDefaultActionArgs{
AuthenticateCognito: &lb.ListenerDefaultActionAuthenticateCognitoArgs{
UserPoolArn: pool.Arn,
UserPoolClientId: client.ID().ToIDOutput().ToStringOutput(),
UserPoolDomain: domain.Domain,
},
Type: pulumi.String("authenticate-cognito"),
},
&lb.ListenerDefaultActionArgs{
Type: pulumi.String("forward"),
TargetGroupArn: frontEndTargetGroup.Arn,
},
},
LoadBalancerArn: frontEnd.Arn,
Port: pulumi.Int(80),
Protocol: pulumi.String("HTTP"),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_lb_loadbalancer" "front_end" {
}
resource "aws_lb_targetgroup" "front_end" {
}
resource "aws_cognito_userpool" "pool" {
}
resource "aws_cognito_userpoolclient" "client" {
}
resource "aws_cognito_userpooldomain" "domain" {
}
resource "aws_lb_listener" "front_end" {
default_actions {
authenticate_cognito = {
user_pool_arn = aws_cognito_userpool.pool.arn
user_pool_client_id = aws_cognito_userpoolclient.client.id
user_pool_domain = aws_cognito_userpooldomain.domain.domain
}
type = "authenticate-cognito"
}
default_actions {
type = "forward"
target_group_arn = aws_lb_targetgroup.front_end.arn
}
load_balancer_arn = aws_lb_loadbalancer.front_end.arn
port = "80"
protocol = "HTTP"
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lb.LoadBalancer;
import com.pulumi.aws.lb.TargetGroup;
import com.pulumi.aws.cognito.UserPool;
import com.pulumi.aws.cognito.UserPoolClient;
import com.pulumi.aws.cognito.UserPoolDomain;
import com.pulumi.aws.lb.Listener;
import com.pulumi.aws.lb.ListenerArgs;
import com.pulumi.aws.lb.inputs.ListenerDefaultActionArgs;
import com.pulumi.aws.lb.inputs.ListenerDefaultActionAuthenticateCognitoArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var frontEnd = new LoadBalancer("frontEnd");
var frontEndTargetGroup = new TargetGroup("frontEndTargetGroup");
var pool = new UserPool("pool");
var client = new UserPoolClient("client");
var domain = new UserPoolDomain("domain");
var frontEndListener = new Listener("frontEndListener", ListenerArgs.builder()
.defaultActions(
ListenerDefaultActionArgs.builder()
.authenticateCognito(ListenerDefaultActionAuthenticateCognitoArgs.builder()
.userPoolArn(pool.arn())
.userPoolClientId(client.id())
.userPoolDomain(domain.domain())
.build())
.type("authenticate-cognito")
.build(),
ListenerDefaultActionArgs.builder()
.type("forward")
.targetGroupArn(frontEndTargetGroup.arn())
.build())
.loadBalancerArn(frontEnd.arn())
.port(80)
.protocol("HTTP")
.build());
}
}
resources:
frontEnd:
type: aws:lb:LoadBalancer
name: front_end
frontEndTargetGroup:
type: aws:lb:TargetGroup
name: front_end
pool:
type: aws:cognito:UserPool
client:
type: aws:cognito:UserPoolClient
domain:
type: aws:cognito:UserPoolDomain
frontEndListener:
type: aws:lb:Listener
name: front_end
properties:
defaultActions:
- authenticateCognito:
userPoolArn: ${pool.arn}
userPoolClientId: ${client.id}
userPoolDomain: ${domain.domain}
type: authenticate-cognito
- type: forward
targetGroupArn: ${frontEndTargetGroup.arn}
loadBalancerArn: ${frontEnd.arn}
port: '80'
protocol: HTTP
Authenticate-OIDC Action
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const frontEnd = new aws.lb.LoadBalancer("front_end", {});
const frontEndTargetGroup = new aws.lb.TargetGroup("front_end", {});
const frontEndListener = new aws.lb.Listener("front_end", {
defaultActions: [
{
authenticateOidc: {
authorizationEndpoint: "https://example.com/authorization_endpoint",
clientId: "client_id",
clientSecret: "client_secret",
issuer: "https://example.com",
tokenEndpoint: "https://example.com/token_endpoint",
userInfoEndpoint: "https://example.com/user_info_endpoint",
},
type: "authenticate-oidc",
},
{
type: "forward",
targetGroupArn: frontEndTargetGroup.arn,
},
],
loadBalancerArn: frontEnd.arn,
port: 80,
protocol: "HTTP",
});
import pulumi
import pulumi_aws as aws
front_end = aws.lb.LoadBalancer("front_end")
front_end_target_group = aws.lb.TargetGroup("front_end")
front_end_listener = aws.lb.Listener("front_end",
default_actions=[
{
"authenticate_oidc": {
"authorization_endpoint": "https://example.com/authorization_endpoint",
"client_id": "client_id",
"client_secret": "client_secret",
"issuer": "https://example.com",
"token_endpoint": "https://example.com/token_endpoint",
"user_info_endpoint": "https://example.com/user_info_endpoint",
},
"type": "authenticate-oidc",
},
{
"type": "forward",
"target_group_arn": front_end_target_group.arn,
},
],
load_balancer_arn=front_end.arn,
port=80,
protocol="HTTP")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var frontEnd = new Aws.LB.LoadBalancer("front_end");
var frontEndTargetGroup = new Aws.LB.TargetGroup("front_end");
var frontEndListener = new Aws.LB.Listener("front_end", new()
{
DefaultActions = new[]
{
new Aws.LB.Inputs.ListenerDefaultActionArgs
{
AuthenticateOidc = new Aws.LB.Inputs.ListenerDefaultActionAuthenticateOidcArgs
{
AuthorizationEndpoint = "https://example.com/authorization_endpoint",
ClientId = "client_id",
ClientSecret = "client_secret",
Issuer = "https://example.com",
TokenEndpoint = "https://example.com/token_endpoint",
UserInfoEndpoint = "https://example.com/user_info_endpoint",
},
Type = "authenticate-oidc",
},
new Aws.LB.Inputs.ListenerDefaultActionArgs
{
Type = "forward",
TargetGroupArn = frontEndTargetGroup.Arn,
},
},
LoadBalancerArn = frontEnd.Arn,
Port = 80,
Protocol = "HTTP",
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lb"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
frontEnd, err := lb.NewLoadBalancer(ctx, "front_end", nil)
if err != nil {
return err
}
frontEndTargetGroup, err := lb.NewTargetGroup(ctx, "front_end", nil)
if err != nil {
return err
}
_, err = lb.NewListener(ctx, "front_end", &lb.ListenerArgs{
DefaultActions: lb.ListenerDefaultActionArray{
&lb.ListenerDefaultActionArgs{
AuthenticateOidc: &lb.ListenerDefaultActionAuthenticateOidcArgs{
AuthorizationEndpoint: pulumi.String("https://example.com/authorization_endpoint"),
ClientId: pulumi.String("client_id"),
ClientSecret: pulumi.String("client_secret"),
Issuer: pulumi.String("https://example.com"),
TokenEndpoint: pulumi.String("https://example.com/token_endpoint"),
UserInfoEndpoint: pulumi.String("https://example.com/user_info_endpoint"),
},
Type: pulumi.String("authenticate-oidc"),
},
&lb.ListenerDefaultActionArgs{
Type: pulumi.String("forward"),
TargetGroupArn: frontEndTargetGroup.Arn,
},
},
LoadBalancerArn: frontEnd.Arn,
Port: pulumi.Int(80),
Protocol: pulumi.String("HTTP"),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_lb_loadbalancer" "front_end" {
}
resource "aws_lb_targetgroup" "front_end" {
}
resource "aws_lb_listener" "front_end" {
default_actions {
authenticate_oidc = {
authorization_endpoint = "https://example.com/authorization_endpoint"
client_id = "client_id"
client_secret = "client_secret"
issuer = "https://example.com"
token_endpoint = "https://example.com/token_endpoint"
user_info_endpoint = "https://example.com/user_info_endpoint"
}
type = "authenticate-oidc"
}
default_actions {
type = "forward"
target_group_arn = aws_lb_targetgroup.front_end.arn
}
load_balancer_arn = aws_lb_loadbalancer.front_end.arn
port = "80"
protocol = "HTTP"
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lb.LoadBalancer;
import com.pulumi.aws.lb.TargetGroup;
import com.pulumi.aws.lb.Listener;
import com.pulumi.aws.lb.ListenerArgs;
import com.pulumi.aws.lb.inputs.ListenerDefaultActionArgs;
import com.pulumi.aws.lb.inputs.ListenerDefaultActionAuthenticateOidcArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var frontEnd = new LoadBalancer("frontEnd");
var frontEndTargetGroup = new TargetGroup("frontEndTargetGroup");
var frontEndListener = new Listener("frontEndListener", ListenerArgs.builder()
.defaultActions(
ListenerDefaultActionArgs.builder()
.authenticateOidc(ListenerDefaultActionAuthenticateOidcArgs.builder()
.authorizationEndpoint("https://example.com/authorization_endpoint")
.clientId("client_id")
.clientSecret("client_secret")
.issuer("https://example.com")
.tokenEndpoint("https://example.com/token_endpoint")
.userInfoEndpoint("https://example.com/user_info_endpoint")
.build())
.type("authenticate-oidc")
.build(),
ListenerDefaultActionArgs.builder()
.type("forward")
.targetGroupArn(frontEndTargetGroup.arn())
.build())
.loadBalancerArn(frontEnd.arn())
.port(80)
.protocol("HTTP")
.build());
}
}
resources:
frontEnd:
type: aws:lb:LoadBalancer
name: front_end
frontEndTargetGroup:
type: aws:lb:TargetGroup
name: front_end
frontEndListener:
type: aws:lb:Listener
name: front_end
properties:
defaultActions:
- authenticateOidc:
authorizationEndpoint: https://example.com/authorization_endpoint
clientId: client_id
clientSecret: client_secret
issuer: https://example.com
tokenEndpoint: https://example.com/token_endpoint
userInfoEndpoint: https://example.com/user_info_endpoint
type: authenticate-oidc
- type: forward
targetGroupArn: ${frontEndTargetGroup.arn}
loadBalancerArn: ${frontEnd.arn}
port: '80'
protocol: HTTP
JWT Validation Action
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const test = new aws.lb.Listener("test", {
defaultActions: [
{
jwtValidation: {
additionalClaims: [
{
format: "string-array",
name: "claim_name1",
values: [
"value1",
"value2",
],
},
{
format: "single-string",
name: "claim_name2",
values: ["value1"],
},
],
issuer: "https://example.com",
jwksEndpoint: "https://example.com/.well-known/jwks.json",
},
type: "jwt-validation",
},
{
targetGroupArn: testAwsLbTargetGroup.id,
type: "forward",
},
],
loadBalancerArn: testAwsLb.id,
protocol: "HTTPS",
port: 443,
sslPolicy: "ELBSecurityPolicy-2016-08",
certificateArn: testAwsIamServerCertificate.arn,
});
import pulumi
import pulumi_aws as aws
test = aws.lb.Listener("test",
default_actions=[
{
"jwt_validation": {
"additional_claims": [
{
"format": "string-array",
"name": "claim_name1",
"values": [
"value1",
"value2",
],
},
{
"format": "single-string",
"name": "claim_name2",
"values": ["value1"],
},
],
"issuer": "https://example.com",
"jwks_endpoint": "https://example.com/.well-known/jwks.json",
},
"type": "jwt-validation",
},
{
"target_group_arn": test_aws_lb_target_group["id"],
"type": "forward",
},
],
load_balancer_arn=test_aws_lb["id"],
protocol="HTTPS",
port=443,
ssl_policy="ELBSecurityPolicy-2016-08",
certificate_arn=test_aws_iam_server_certificate["arn"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var test = new Aws.LB.Listener("test", new()
{
DefaultActions = new[]
{
new Aws.LB.Inputs.ListenerDefaultActionArgs
{
JwtValidation = new Aws.LB.Inputs.ListenerDefaultActionJwtValidationArgs
{
AdditionalClaims = new[]
{
new Aws.LB.Inputs.ListenerDefaultActionJwtValidationAdditionalClaimArgs
{
Format = "string-array",
Name = "claim_name1",
Values = new[]
{
"value1",
"value2",
},
},
new Aws.LB.Inputs.ListenerDefaultActionJwtValidationAdditionalClaimArgs
{
Format = "single-string",
Name = "claim_name2",
Values = new[]
{
"value1",
},
},
},
Issuer = "https://example.com",
JwksEndpoint = "https://example.com/.well-known/jwks.json",
},
Type = "jwt-validation",
},
new Aws.LB.Inputs.ListenerDefaultActionArgs
{
TargetGroupArn = testAwsLbTargetGroup.Id,
Type = "forward",
},
},
LoadBalancerArn = testAwsLb.Id,
Protocol = "HTTPS",
Port = 443,
SslPolicy = "ELBSecurityPolicy-2016-08",
CertificateArn = testAwsIamServerCertificate.Arn,
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lb"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := lb.NewListener(ctx, "test", &lb.ListenerArgs{
DefaultActions: lb.ListenerDefaultActionArray{
&lb.ListenerDefaultActionArgs{
JwtValidation: &lb.ListenerDefaultActionJwtValidationArgs{
AdditionalClaims: lb.ListenerDefaultActionJwtValidationAdditionalClaimArray{
&lb.ListenerDefaultActionJwtValidationAdditionalClaimArgs{
Format: pulumi.String("string-array"),
Name: pulumi.String("claim_name1"),
Values: pulumi.StringArray{
pulumi.String("value1"),
pulumi.String("value2"),
},
},
&lb.ListenerDefaultActionJwtValidationAdditionalClaimArgs{
Format: pulumi.String("single-string"),
Name: pulumi.String("claim_name2"),
Values: pulumi.StringArray{
pulumi.String("value1"),
},
},
},
Issuer: pulumi.String("https://example.com"),
JwksEndpoint: pulumi.String("https://example.com/.well-known/jwks.json"),
},
Type: pulumi.String("jwt-validation"),
},
&lb.ListenerDefaultActionArgs{
TargetGroupArn: pulumi.Any(testAwsLbTargetGroup.Id),
Type: pulumi.String("forward"),
},
},
LoadBalancerArn: pulumi.Any(testAwsLb.Id),
Protocol: pulumi.String("HTTPS"),
Port: pulumi.Int(443),
SslPolicy: pulumi.String("ELBSecurityPolicy-2016-08"),
CertificateArn: pulumi.Any(testAwsIamServerCertificate.Arn),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_lb_listener" "test" {
default_actions {
jwt_validation = {
additional_claims = [{
"format" = "string-array"
"name" = "claim_name1"
"values" = ["value1", "value2"]
}, {
"format" = "single-string"
"name" = "claim_name2"
"values" = ["value1"]
}]
issuer = "https://example.com"
jwks_endpoint = "https://example.com/.well-known/jwks.json"
}
type = "jwt-validation"
}
default_actions {
target_group_arn = testAwsLbTargetGroup.id
type = "forward"
}
load_balancer_arn = testAwsLb.id
protocol = "HTTPS"
port = "443"
ssl_policy = "ELBSecurityPolicy-2016-08"
certificate_arn = testAwsIamServerCertificate.arn
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lb.Listener;
import com.pulumi.aws.lb.ListenerArgs;
import com.pulumi.aws.lb.inputs.ListenerDefaultActionArgs;
import com.pulumi.aws.lb.inputs.ListenerDefaultActionJwtValidationArgs;
import com.pulumi.aws.lb.inputs.ListenerDefaultActionJwtValidationAdditionalClaimArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var test = new Listener("test", ListenerArgs.builder()
.defaultActions(
ListenerDefaultActionArgs.builder()
.jwtValidation(ListenerDefaultActionJwtValidationArgs.builder()
.additionalClaims(
ListenerDefaultActionJwtValidationAdditionalClaimArgs.builder()
.format("string-array")
.name("claim_name1")
.values(
"value1",
"value2")
.build(),
ListenerDefaultActionJwtValidationAdditionalClaimArgs.builder()
.format("single-string")
.name("claim_name2")
.values("value1")
.build())
.issuer("https://example.com")
.jwksEndpoint("https://example.com/.well-known/jwks.json")
.build())
.type("jwt-validation")
.build(),
ListenerDefaultActionArgs.builder()
.targetGroupArn(testAwsLbTargetGroup.id())
.type("forward")
.build())
.loadBalancerArn(testAwsLb.id())
.protocol("HTTPS")
.port(443)
.sslPolicy("ELBSecurityPolicy-2016-08")
.certificateArn(testAwsIamServerCertificate.arn())
.build());
}
}
resources:
test:
type: aws:lb:Listener
properties:
defaultActions:
- jwtValidation:
additionalClaims:
- format: string-array
name: claim_name1
values:
- value1
- value2
- format: single-string
name: claim_name2
values:
- value1
issuer: https://example.com
jwksEndpoint: https://example.com/.well-known/jwks.json
type: jwt-validation
- targetGroupArn: ${testAwsLbTargetGroup.id}
type: forward
loadBalancerArn: ${testAwsLb.id}
protocol: HTTPS
port: '443'
sslPolicy: ELBSecurityPolicy-2016-08
certificateArn: ${testAwsIamServerCertificate.arn}
Gateway Load Balancer Listener
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.lb.LoadBalancer("example", {
subnetMappings: [{
subnetId: exampleAwsSubnet.id,
}],
loadBalancerType: "gateway",
name: "example",
});
const exampleTargetGroup = new aws.lb.TargetGroup("example", {
healthCheck: {
port: "80",
protocol: "HTTP",
},
name: "example",
port: 6081,
protocol: "GENEVE",
vpcId: exampleAwsVpc.id,
});
const exampleListener = new aws.lb.Listener("example", {
defaultActions: [{
targetGroupArn: exampleTargetGroup.id,
type: "forward",
}],
loadBalancerArn: example.id,
});
import pulumi
import pulumi_aws as aws
example = aws.lb.LoadBalancer("example",
subnet_mappings=[{
"subnet_id": example_aws_subnet["id"],
}],
load_balancer_type="gateway",
name="example")
example_target_group = aws.lb.TargetGroup("example",
health_check={
"port": "80",
"protocol": "HTTP",
},
name="example",
port=6081,
protocol="GENEVE",
vpc_id=example_aws_vpc["id"])
example_listener = aws.lb.Listener("example",
default_actions=[{
"target_group_arn": example_target_group.id,
"type": "forward",
}],
load_balancer_arn=example.id)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.LB.LoadBalancer("example", new()
{
SubnetMappings = new[]
{
new Aws.LB.Inputs.LoadBalancerSubnetMappingArgs
{
SubnetId = exampleAwsSubnet.Id,
},
},
LoadBalancerType = "gateway",
Name = "example",
});
var exampleTargetGroup = new Aws.LB.TargetGroup("example", new()
{
HealthCheck = new Aws.LB.Inputs.TargetGroupHealthCheckArgs
{
Port = "80",
Protocol = "HTTP",
},
Name = "example",
Port = 6081,
Protocol = "GENEVE",
VpcId = exampleAwsVpc.Id,
});
var exampleListener = new Aws.LB.Listener("example", new()
{
DefaultActions = new[]
{
new Aws.LB.Inputs.ListenerDefaultActionArgs
{
TargetGroupArn = exampleTargetGroup.Id,
Type = "forward",
},
},
LoadBalancerArn = example.Id,
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lb"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
example, err := lb.NewLoadBalancer(ctx, "example", &lb.LoadBalancerArgs{
SubnetMappings: lb.LoadBalancerSubnetMappingArray{
&lb.LoadBalancerSubnetMappingArgs{
SubnetId: pulumi.Any(exampleAwsSubnet.Id),
},
},
LoadBalancerType: pulumi.String("gateway"),
Name: pulumi.String("example"),
})
if err != nil {
return err
}
exampleTargetGroup, err := lb.NewTargetGroup(ctx, "example", &lb.TargetGroupArgs{
HealthCheck: &lb.TargetGroupHealthCheckArgs{
Port: pulumi.String("80"),
Protocol: pulumi.String("HTTP"),
},
Name: pulumi.String("example"),
Port: pulumi.Int(6081),
Protocol: pulumi.String("GENEVE"),
VpcId: pulumi.Any(exampleAwsVpc.Id),
})
if err != nil {
return err
}
_, err = lb.NewListener(ctx, "example", &lb.ListenerArgs{
DefaultActions: lb.ListenerDefaultActionArray{
&lb.ListenerDefaultActionArgs{
TargetGroupArn: exampleTargetGroup.ID().ToIDOutput().ToStringOutput(),
Type: pulumi.String("forward"),
},
},
LoadBalancerArn: example.ID().ToIDOutput().ToStringOutput(),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_lb_loadbalancer" "example" {
subnet_mappings {
subnet_id = exampleAwsSubnet.id
}
load_balancer_type = "gateway"
name = "example"
}
resource "aws_lb_targetgroup" "example" {
health_check = {
port = 80
protocol = "HTTP"
}
name = "example"
port = 6081
protocol = "GENEVE"
vpc_id = exampleAwsVpc.id
}
resource "aws_lb_listener" "example" {
default_actions {
target_group_arn = aws_lb_targetgroup.example.id
type = "forward"
}
load_balancer_arn = aws_lb_loadbalancer.example.id
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lb.LoadBalancer;
import com.pulumi.aws.lb.LoadBalancerArgs;
import com.pulumi.aws.lb.inputs.LoadBalancerSubnetMappingArgs;
import com.pulumi.aws.lb.TargetGroup;
import com.pulumi.aws.lb.TargetGroupArgs;
import com.pulumi.aws.lb.inputs.TargetGroupHealthCheckArgs;
import com.pulumi.aws.lb.Listener;
import com.pulumi.aws.lb.ListenerArgs;
import com.pulumi.aws.lb.inputs.ListenerDefaultActionArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var example = new LoadBalancer("example", LoadBalancerArgs.builder()
.subnetMappings(LoadBalancerSubnetMappingArgs.builder()
.subnetId(exampleAwsSubnet.id())
.build())
.loadBalancerType("gateway")
.name("example")
.build());
var exampleTargetGroup = new TargetGroup("exampleTargetGroup", TargetGroupArgs.builder()
.healthCheck(TargetGroupHealthCheckArgs.builder()
.port("80")
.protocol("HTTP")
.build())
.name("example")
.port(6081)
.protocol("GENEVE")
.vpcId(exampleAwsVpc.id())
.build());
var exampleListener = new Listener("exampleListener", ListenerArgs.builder()
.defaultActions(ListenerDefaultActionArgs.builder()
.targetGroupArn(exampleTargetGroup.id())
.type("forward")
.build())
.loadBalancerArn(example.id())
.build());
}
}
resources:
example:
type: aws:lb:LoadBalancer
properties:
subnetMappings:
- subnetId: ${exampleAwsSubnet.id}
loadBalancerType: gateway
name: example
exampleTargetGroup:
type: aws:lb:TargetGroup
name: example
properties:
healthCheck:
port: 80
protocol: HTTP
name: example
port: 6081
protocol: GENEVE
vpcId: ${exampleAwsVpc.id}
exampleListener:
type: aws:lb:Listener
name: example
properties:
defaultActions:
- targetGroupArn: ${exampleTargetGroup.id}
type: forward
loadBalancerArn: ${example.id}
Mutual TLS Authentication
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.lb.LoadBalancer("example", {loadBalancerType: "application"});
const exampleTargetGroup = new aws.lb.TargetGroup("example", {});
const exampleListener = new aws.lb.Listener("example", {
mutualAuthentication: {
mode: "verify",
trustStoreArn: "...",
},
defaultActions: [{
targetGroupArn: exampleTargetGroup.id,
type: "forward",
}],
loadBalancerArn: example.id,
});
import pulumi
import pulumi_aws as aws
example = aws.lb.LoadBalancer("example", load_balancer_type="application")
example_target_group = aws.lb.TargetGroup("example")
example_listener = aws.lb.Listener("example",
mutual_authentication={
"mode": "verify",
"trust_store_arn": "...",
},
default_actions=[{
"target_group_arn": example_target_group.id,
"type": "forward",
}],
load_balancer_arn=example.id)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.LB.LoadBalancer("example", new()
{
LoadBalancerType = "application",
});
var exampleTargetGroup = new Aws.LB.TargetGroup("example");
var exampleListener = new Aws.LB.Listener("example", new()
{
MutualAuthentication = new Aws.LB.Inputs.ListenerMutualAuthenticationArgs
{
Mode = "verify",
TrustStoreArn = "...",
},
DefaultActions = new[]
{
new Aws.LB.Inputs.ListenerDefaultActionArgs
{
TargetGroupArn = exampleTargetGroup.Id,
Type = "forward",
},
},
LoadBalancerArn = example.Id,
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lb"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
example, err := lb.NewLoadBalancer(ctx, "example", &lb.LoadBalancerArgs{
LoadBalancerType: pulumi.String("application"),
})
if err != nil {
return err
}
exampleTargetGroup, err := lb.NewTargetGroup(ctx, "example", nil)
if err != nil {
return err
}
_, err = lb.NewListener(ctx, "example", &lb.ListenerArgs{
MutualAuthentication: &lb.ListenerMutualAuthenticationArgs{
Mode: pulumi.String("verify"),
TrustStoreArn: pulumi.String("..."),
},
DefaultActions: lb.ListenerDefaultActionArray{
&lb.ListenerDefaultActionArgs{
TargetGroupArn: exampleTargetGroup.ID().ToIDOutput().ToStringOutput(),
Type: pulumi.String("forward"),
},
},
LoadBalancerArn: example.ID().ToIDOutput().ToStringOutput(),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_lb_loadbalancer" "example" {
load_balancer_type = "application"
}
resource "aws_lb_targetgroup" "example" {
}
resource "aws_lb_listener" "example" {
mutual_authentication = {
mode = "verify"
trust_store_arn = "..."
}
default_actions {
target_group_arn = aws_lb_targetgroup.example.id
type = "forward"
}
load_balancer_arn = aws_lb_loadbalancer.example.id
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lb.LoadBalancer;
import com.pulumi.aws.lb.LoadBalancerArgs;
import com.pulumi.aws.lb.TargetGroup;
import com.pulumi.aws.lb.Listener;
import com.pulumi.aws.lb.ListenerArgs;
import com.pulumi.aws.lb.inputs.ListenerMutualAuthenticationArgs;
import com.pulumi.aws.lb.inputs.ListenerDefaultActionArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var example = new LoadBalancer("example", LoadBalancerArgs.builder()
.loadBalancerType("application")
.build());
var exampleTargetGroup = new TargetGroup("exampleTargetGroup");
var exampleListener = new Listener("exampleListener", ListenerArgs.builder()
.mutualAuthentication(ListenerMutualAuthenticationArgs.builder()
.mode("verify")
.trustStoreArn("...")
.build())
.defaultActions(ListenerDefaultActionArgs.builder()
.targetGroupArn(exampleTargetGroup.id())
.type("forward")
.build())
.loadBalancerArn(example.id())
.build());
}
}
resources:
example:
type: aws:lb:LoadBalancer
properties:
loadBalancerType: application
exampleTargetGroup:
type: aws:lb:TargetGroup
name: example
exampleListener:
type: aws:lb:Listener
name: example
properties:
mutualAuthentication:
mode: verify
trustStoreArn: '...'
defaultActions:
- targetGroupArn: ${exampleTargetGroup.id}
type: forward
loadBalancerArn: ${example.id}
Import
Identity Schema
Required
arn(String) ARN of the load balancer listener.
Using pulumi import, import listeners using their ARN. For example:
$ pulumi import aws:lb/listener:Listener front_end arn:aws:elasticloadbalancing:us-west-2:187416307283:listener/app/front-end-alb/8e4497da625e2d8a/9ab28ade35828f96
Constructors
- Listener(String name, {ListenerArgs? args, CustomResourceOptions? options})
-
Creates a new Listener.
nameThe Pulumi resource name.argsArguments used to configure this Listener. The set of arguments for Listener.optionsResource options controlling this resource's behavior. - Listener.reference(String urn)
- Creates a typed reference to an existing Listener resource.
Properties
-
alpnPolicy
↔ Output<
String?> -
Name of the Application-Layer Protocol Negotiation (ALPN) policy. Can be set if
protocolisTLS. Valid values areHTTP1Only,HTTP2Only,HTTP2Optional,HTTP2Preferred, andNone.latefinal -
arn
↔ Output<
String> -
ARN of the listener.
latefinal
-
certificateArn
↔ Output<
String?> -
ARN of the default SSL server certificate. Exactly one certificate is required if the protocol is HTTPS. For adding additional SSL certificates, see the
aws.lb.ListenerCertificateresource.latefinal -
childResources
→ Set<
Resource> -
finalinherited
-
completionSources
↔ Map<
String, IOutputCompletionSource> -
latefinalinherited
-
defaultActions
↔ Output<
List< ListenerDefaultAction> > -
Configuration block for default actions. See below.
latefinal
- hashCode → int
-
The hash code for this object.
no setterinherited
-
id
↔ Output<
String> -
getter/setter pairinherited
- isCustom → bool
-
Returns whether this resource is provider-managed.
no setterinherited
- isProtected → bool
-
Returns whether this resource is protected from deletion.
no setterinherited
- isRemote → bool
-
Whether this resource is registered as remote.
no setterinherited
- isResourceReference → bool
-
Whether this instance represents a resource value returned over RPC.
finalinherited
-
loadBalancerArn
↔ Output<
String> -
ARN of the load balancer.
latefinal
-
mutualAuthentication
↔ Output<
ListenerMutualAuthentication> -
The mutual authentication configuration information. See below.
latefinal
-
port
↔ Output<
int?> -
Port on which the load balancer is listening. Not valid for Gateway Load Balancers.
latefinal
-
protocol
↔ Output<
String> -
Protocol for connections from clients to the load balancer. For Application Load Balancers, valid values are
HTTPandHTTPS, with a default ofHTTP. For Network Load Balancers, valid values areTCP,TLS,UDP,TCP_UDP,QUIC, andTCP_QUIC. Not valid to useUDPorTCP_UDPif dual-stack mode is enabled. Not valid to useQUICorTCP_QUICif security groups are configured or dual-stack mode is enabled. Not valid for Gateway Load Balancers.latefinal -
region
↔ Output<
String> -
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
-
resourceTransforms
→ List<
ResourceTransform> -
Inherited/explicit async transforms.
no setterinherited
-
routingHttpRequestXAmznMtlsClientcertHeaderName
↔ Output<
String> -
Enables you to modify the header name of the
X-Amzn-Mtls-ClientcertHTTP request header. Can only be set if protocol isHTTPSfor Application Load Balancers.latefinal -
routingHttpRequestXAmznMtlsClientcertIssuerHeaderName
↔ Output<
String> -
Enables you to modify the header name of the
X-Amzn-Mtls-Clientcert-IssuerHTTP request header. Can only be set if protocol isHTTPSfor Application Load Balancers.latefinal -
routingHttpRequestXAmznMtlsClientcertLeafHeaderName
↔ Output<
String> -
Enables you to modify the header name of the
X-Amzn-Mtls-Clientcert-LeafHTTP request header. Can only be set if protocol isHTTPSfor Application Load Balancers.latefinal -
routingHttpRequestXAmznMtlsClientcertSerialNumberHeaderName
↔ Output<
String> -
Enables you to modify the header name of the
X-Amzn-Mtls-Clientcert-Serial-NumberHTTP request header. Can only be set if protocol isHTTPSfor Application Load Balancers.latefinal -
routingHttpRequestXAmznMtlsClientcertSubjectHeaderName
↔ Output<
String> -
Enables you to modify the header name of the
X-Amzn-Mtls-Clientcert-SubjectHTTP request header. Can only be set if protocol isHTTPSfor Application Load Balancers.latefinal -
routingHttpRequestXAmznMtlsClientcertValidityHeaderName
↔ Output<
String> -
Enables you to modify the header name of the
X-Amzn-Mtls-Clientcert-ValidityHTTP request header. Can only be set if protocol isHTTPSfor Application Load Balancers.latefinal -
routingHttpRequestXAmznTlsCipherSuiteHeaderName
↔ Output<
String> -
Enables you to modify the header name of the
X-Amzn-Tls-Cipher-SuiteHTTP request header. Can only be set if protocol isHTTPSfor Application Load Balancers.latefinal -
routingHttpRequestXAmznTlsVersionHeaderName
↔ Output<
String> -
Enables you to modify the header name of the
X-Amzn-Tls-VersionHTTP request header. Can only be set if protocol isHTTPSfor Application Load Balancers.latefinal -
routingHttpResponseAccessControlAllowCredentialsHeaderValue
↔ Output<
String> -
Specifies which headers the browser can expose to the requesting client. Can only be set if protocol is
HTTPorHTTPSfor Application Load Balancers. Not supported for Network Load Balancer, or with a Gateway Load Balancer. The only valid value istrue.latefinal -
routingHttpResponseAccessControlAllowHeadersHeaderValue
↔ Output<
String> -
Specifies which headers can be used during the request. Can only be set if protocol is
HTTPorHTTPSfor Application Load Balancers. Not supported for Network Load Balancer, or with a Gateway Load Balancer. Valid values are*,Accept,Accept-Language,Cache-Control,Content-Language,Content-Length,Content-Type,Expires,Last-Modified,Pragma. Dependent on your use-case other headers can be exposed and then set as a value consult the Access-Control-Allow-Headers documentation.latefinal -
routingHttpResponseAccessControlAllowMethodsHeaderValue
↔ Output<
String> -
Set which HTTP methods are allowed when accessing the server from a different origin. Can only be set if protocol is
HTTPorHTTPSfor Application Load Balancers. Not supported for Network Load Balancer, or with a Gateway Load Balancer. Valid values areGET,HEAD,POST,DELETE,CONNECT,OPTIONS,TRACEorPATCH.latefinal -
routingHttpResponseAccessControlAllowOriginHeaderValue
↔ Output<
String> -
Specifies which origins are allowed to access the server. Can only be set if protocol is
HTTPorHTTPSfor Application Load Balancers. Not supported for Network Load Balancer, or with a Gateway Load Balancer. A valid value is a URI, eg:https://example.com.latefinal -
routingHttpResponseAccessControlExposeHeadersHeaderValue
↔ Output<
String> -
Specifies whether the browser should include credentials such as cookies or authentication when making requests. Can only be set if protocol is
HTTPorHTTPSfor Application Load Balancers. Not supported for Network Load Balancer, or with a Gateway Load Balancer. Valid values are*,Cache-Control,Content-Language,Content-Length,Content-Type,Expires,Last-Modified, orPragma. Dependent on your use-case other headers can be exposed, consult the Access-Control-Expose-Headers documentation.latefinal -
routingHttpResponseAccessControlMaxAgeHeaderValue
↔ Output<
String> -
Specifies how long the results of a preflight request can be cached, in seconds. Can only be set if protocol is
HTTPorHTTPSfor Application Load Balancers. Not supported for Network Load Balancer, or with a Gateway Load Balancer. Valid values are between0and86400. This value is browser specific, consult the Access-Control-Max-Age documentation.latefinal -
routingHttpResponseContentSecurityPolicyHeaderValue
↔ Output<
String> -
Specifies restrictions enforced by the browser to help minimize the risk of certain types of security threats. Can only be set if protocol is
HTTPorHTTPSfor Application Load Balancers. Not supported for Network Load Balancer, or with a Gateway Load Balancer. Values for this are extensive, and can be impactful when set, consult Content-Security-Policy documentation.latefinal -
routingHttpResponseServerEnabled
↔ Output<
bool> -
Enables you to allow or remove the HTTP response server header. Can only be set if protocol is
HTTPorHTTPSfor Application Load Balancers. Not supported for Network Load Balancer, or with a Gateway Load Balancer. Valid values aretrueorfalse.latefinal -
routingHttpResponseStrictTransportSecurityHeaderValue
↔ Output<
String> -
Informs browsers that the site should only be accessed using HTTPS, and that any future attempts to access it using HTTP should automatically be converted to HTTPS. Default values are
max-age=31536000; includeSubDomains; preloadconsult the Strict-Transport-Security documentation for further details.latefinal -
routingHttpResponseXContentTypeOptionsHeaderValue
↔ Output<
String> -
Indicates whether the MIME types advertised in the Content-Type headers should be followed and not be changed. Can only be set if protocol is
HTTPorHTTPSfor Application Load Balancers. Not supported for Network Load Balancer, or with a Gateway Load Balancer. The only valid value isnosniff.latefinal -
routingHttpResponseXFrameOptionsHeaderValue
↔ Output<
String> -
Indicates whether the browser is allowed to render a page in a frame, iframe, embed or object. Can only be set if protocol is
HTTPorHTTPSfor Application Load Balancers. Not supported for Network Load Balancer, or with a Gateway Load Balancer. The only valid values areDENY,SAMEORIGIN, orALLOW-FROM https://example.com.latefinal - runtimeType → Type
-
A representation of the runtime type of the object.
no setterinherited
-
sslPolicy
↔ Output<
String> -
Name of the SSL Policy for the listener. Required if
protocolisHTTPSorTLS. Default isELBSecurityPolicy-2016-08.latefinal -
A map of tags to assign to the resource. .If configured with a provider
defaultTagsconfiguration block present, tags with matching keys will overwrite those defined at the provider-level.latefinal -
A map of tags assigned to the resource, including those inherited from the provider
defaultTagsconfiguration block.latefinal -
tcpIdleTimeoutSeconds
↔ Output<
int> -
TCP idle timeout value in seconds. Can only be set if protocol is
TCPon Network Load Balancer, or with a Gateway Load Balancer. Not supported for Application Load Balancers. Valid values are between60and6000inclusive. Default:350.latefinal -
transformations
→ List<
ResourceTransformation> -
Inherited/explicit legacy transformations.
no setterinherited
-
urn
↔ Output<
String> -
latefinalinherited
Methods
-
failId(
Object error) → void -
Completes this resource ID with an error when registration fails.
inherited
-
failOutputs(
Object error) → void -
Completes all output properties with
error.inherited -
failUrn(
Object error) → void -
Completes this resource URN with an error when registration fails.
inherited
-
getProvider(
String moduleMember) → ProviderResource? -
Returns provider for
moduleMember's package, if configured.inherited -
getResourceName(
) → String -
Returns this resource's logical name.
inherited
-
getResourceType(
) → String -
Returns this resource's Pulumi type token.
inherited
-
noSuchMethod(
Invocation invocation) → dynamic -
Invoked when a nonexistent method or property is accessed.
inherited
-
registerOutput<
T> (String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output< T> -
Registers a dynamic output property for this resource.
inherited
-
resolveId(
String? value, {required bool isKnown}) → void -
Resolves the provider-assigned ID for this resource.
inherited
-
resolveOutputs(
Struct outputs) → void -
Resolves all output properties from a monitor response payload.
inherited
-
resolveUrn(
String value) → void -
Resolves this resource's URN once assigned by the engine.
inherited
-
serializeProperties(
Map< String, dynamic> properties) → Future<Struct> -
Serializes resource properties for RPC transmission.
inherited
-
toString(
) → String -
A string representation of this object.
inherited
Operators
-
operator ==(
Object other) → bool -
The equality operator.
inherited