ListenerPolicy

Attaches a load balancer policy to an ELB Listener.

Example Usage

Custom Policy

using Pulumi;
using Aws = Pulumi.Aws;

class MyStack : Stack
{
    public MyStack()
    {
        var wu_tang = new Aws.Elb.LoadBalancer("wu-tang", new Aws.Elb.LoadBalancerArgs
        {
            AvailabilityZones = 
            {
                "us-east-1a",
            },
            Listeners = 
            {
                new Aws.Elb.Inputs.LoadBalancerListenerArgs
                {
                    InstancePort = 443,
                    InstanceProtocol = "http",
                    LbPort = 443,
                    LbProtocol = "https",
                    SslCertificateId = "arn:aws:iam::000000000000:server-certificate/wu-tang.net",
                },
            },
            Tags = 
            {
                { "Name", "wu-tang" },
            },
        });
        var wu_tang_ssl = new Aws.Elb.LoadBalancerPolicy("wu-tang-ssl", new Aws.Elb.LoadBalancerPolicyArgs
        {
            LoadBalancerName = wu_tang.Name,
            PolicyAttributes = 
            {
                new Aws.Elb.Inputs.LoadBalancerPolicyPolicyAttributeArgs
                {
                    Name = "ECDHE-ECDSA-AES128-GCM-SHA256",
                    Value = "true",
                },
                new Aws.Elb.Inputs.LoadBalancerPolicyPolicyAttributeArgs
                {
                    Name = "Protocol-TLSv1.2",
                    Value = "true",
                },
            },
            PolicyName = "wu-tang-ssl",
            PolicyTypeName = "SSLNegotiationPolicyType",
        });
        var wu_tang_listener_policies_443 = new Aws.Elb.ListenerPolicy("wu-tang-listener-policies-443", new Aws.Elb.ListenerPolicyArgs
        {
            LoadBalancerName = wu_tang.Name,
            LoadBalancerPort = 443,
            PolicyNames = 
            {
                wu_tang_ssl.PolicyName,
            },
        });
    }

}

package main

import (
    "github.com/pulumi/pulumi-aws/sdk/v2/go/aws/elb"
    "github.com/pulumi/pulumi/sdk/v2/go/pulumi"
)

func main() {
    pulumi.Run(func(ctx *pulumi.Context) error {
        _, err := elb.NewLoadBalancer(ctx, "wu_tang", &elb.LoadBalancerArgs{
            AvailabilityZones: pulumi.StringArray{
                pulumi.String("us-east-1a"),
            },
            Listeners: elb.LoadBalancerListenerArray{
                &elb.LoadBalancerListenerArgs{
                    InstancePort:     pulumi.Int(443),
                    InstanceProtocol: pulumi.String("http"),
                    LbPort:           pulumi.Int(443),
                    LbProtocol:       pulumi.String("https"),
                    SslCertificateId: pulumi.String("arn:aws:iam::000000000000:server-certificate/wu-tang.net"),
                },
            },
            Tags: pulumi.StringMap{
                "Name": pulumi.String("wu-tang"),
            },
        })
        if err != nil {
            return err
        }
        _, err = elb.NewLoadBalancerPolicy(ctx, "wu_tang_ssl", &elb.LoadBalancerPolicyArgs{
            LoadBalancerName: wu_tang.Name,
            PolicyAttributes: elb.LoadBalancerPolicyPolicyAttributeArray{
                &elb.LoadBalancerPolicyPolicyAttributeArgs{
                    Name:  pulumi.String("ECDHE-ECDSA-AES128-GCM-SHA256"),
                    Value: pulumi.String("true"),
                },
                &elb.LoadBalancerPolicyPolicyAttributeArgs{
                    Name:  pulumi.String("Protocol-TLSv1.2"),
                    Value: pulumi.String("true"),
                },
            },
            PolicyName:     pulumi.String("wu-tang-ssl"),
            PolicyTypeName: pulumi.String("SSLNegotiationPolicyType"),
        })
        if err != nil {
            return err
        }
        _, err = elb.NewListenerPolicy(ctx, "wu_tang_listener_policies_443", &elb.ListenerPolicyArgs{
            LoadBalancerName: wu_tang.Name,
            LoadBalancerPort: pulumi.Int(443),
            PolicyNames: pulumi.StringArray{
                wu_tang_ssl.PolicyName,
            },
        })
        if err != nil {
            return err
        }
        return nil
    })
}

import pulumi
import pulumi_aws as aws

wu_tang = aws.elb.LoadBalancer("wu-tang",
    availability_zones=["us-east-1a"],
    listeners=[{
        "instance_port": 443,
        "instanceProtocol": "http",
        "lb_port": 443,
        "lbProtocol": "https",
        "sslCertificateId": "arn:aws:iam::000000000000:server-certificate/wu-tang.net",
    }],
    tags={
        "Name": "wu-tang",
    })
wu_tang_ssl = aws.elb.LoadBalancerPolicy("wu-tang-ssl",
    load_balancer_name=wu_tang.name,
    policy_attributes=[
        {
            "name": "ECDHE-ECDSA-AES128-GCM-SHA256",
            "value": "true",
        },
        {
            "name": "Protocol-TLSv1.2",
            "value": "true",
        },
    ],
    policy_name="wu-tang-ssl",
    policy_type_name="SSLNegotiationPolicyType")
wu_tang_listener_policies_443 = aws.elb.ListenerPolicy("wu-tang-listener-policies-443",
    load_balancer_name=wu_tang.name,
    load_balancer_port=443,
    policy_names=[wu_tang_ssl.policy_name])

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const wu_tang = new aws.elb.LoadBalancer("wu-tang", {
    availabilityZones: ["us-east-1a"],
    listeners: [{
        instancePort: 443,
        instanceProtocol: "http",
        lbPort: 443,
        lbProtocol: "https",
        sslCertificateId: "arn:aws:iam::000000000000:server-certificate/wu-tang.net",
    }],
    tags: {
        Name: "wu-tang",
    },
});
const wu_tang_ssl = new aws.elb.LoadBalancerPolicy("wu-tang-ssl", {
    loadBalancerName: wu_tang.name,
    policyAttributes: [
        {
            name: "ECDHE-ECDSA-AES128-GCM-SHA256",
            value: "true",
        },
        {
            name: "Protocol-TLSv1.2",
            value: "true",
        },
    ],
    policyName: "wu-tang-ssl",
    policyTypeName: "SSLNegotiationPolicyType",
});
const wu_tang_listener_policies_443 = new aws.elb.ListenerPolicy("wu-tang-listener-policies-443", {
    loadBalancerName: wu_tang.name,
    loadBalancerPort: 443,
    policyNames: [wu_tang_ssl.policyName],
});

AWS Predefined Security Policy

using Pulumi;
using Aws = Pulumi.Aws;

class MyStack : Stack
{
    public MyStack()
    {
        var wu_tang = new Aws.Elb.LoadBalancer("wu-tang", new Aws.Elb.LoadBalancerArgs
        {
            AvailabilityZones = 
            {
                "us-east-1a",
            },
            Listeners = 
            {
                new Aws.Elb.Inputs.LoadBalancerListenerArgs
                {
                    InstancePort = 443,
                    InstanceProtocol = "http",
                    LbPort = 443,
                    LbProtocol = "https",
                    SslCertificateId = "arn:aws:iam::000000000000:server-certificate/wu-tang.net",
                },
            },
            Tags = 
            {
                { "Name", "wu-tang" },
            },
        });
        var wu_tang_ssl_tls_1_1 = new Aws.Elb.LoadBalancerPolicy("wu-tang-ssl-tls-1-1", new Aws.Elb.LoadBalancerPolicyArgs
        {
            LoadBalancerName = wu_tang.Name,
            PolicyAttributes = 
            {
                new Aws.Elb.Inputs.LoadBalancerPolicyPolicyAttributeArgs
                {
                    Name = "Reference-Security-Policy",
                    Value = "ELBSecurityPolicy-TLS-1-1-2017-01",
                },
            },
            PolicyName = "wu-tang-ssl",
            PolicyTypeName = "SSLNegotiationPolicyType",
        });
        var wu_tang_listener_policies_443 = new Aws.Elb.ListenerPolicy("wu-tang-listener-policies-443", new Aws.Elb.ListenerPolicyArgs
        {
            LoadBalancerName = wu_tang.Name,
            LoadBalancerPort = 443,
            PolicyNames = 
            {
                wu_tang_ssl_tls_1_1.PolicyName,
            },
        });
    }

}

package main

import (
    "github.com/pulumi/pulumi-aws/sdk/v2/go/aws/elb"
    "github.com/pulumi/pulumi/sdk/v2/go/pulumi"
)

func main() {
    pulumi.Run(func(ctx *pulumi.Context) error {
        _, err := elb.NewLoadBalancer(ctx, "wu_tang", &elb.LoadBalancerArgs{
            AvailabilityZones: pulumi.StringArray{
                pulumi.String("us-east-1a"),
            },
            Listeners: elb.LoadBalancerListenerArray{
                &elb.LoadBalancerListenerArgs{
                    InstancePort:     pulumi.Int(443),
                    InstanceProtocol: pulumi.String("http"),
                    LbPort:           pulumi.Int(443),
                    LbProtocol:       pulumi.String("https"),
                    SslCertificateId: pulumi.String("arn:aws:iam::000000000000:server-certificate/wu-tang.net"),
                },
            },
            Tags: pulumi.StringMap{
                "Name": pulumi.String("wu-tang"),
            },
        })
        if err != nil {
            return err
        }
        _, err = elb.NewLoadBalancerPolicy(ctx, "wu_tang_ssl_tls_1_1", &elb.LoadBalancerPolicyArgs{
            LoadBalancerName: wu_tang.Name,
            PolicyAttributes: elb.LoadBalancerPolicyPolicyAttributeArray{
                &elb.LoadBalancerPolicyPolicyAttributeArgs{
                    Name:  pulumi.String("Reference-Security-Policy"),
                    Value: pulumi.String("ELBSecurityPolicy-TLS-1-1-2017-01"),
                },
            },
            PolicyName:     pulumi.String("wu-tang-ssl"),
            PolicyTypeName: pulumi.String("SSLNegotiationPolicyType"),
        })
        if err != nil {
            return err
        }
        _, err = elb.NewListenerPolicy(ctx, "wu_tang_listener_policies_443", &elb.ListenerPolicyArgs{
            LoadBalancerName: wu_tang.Name,
            LoadBalancerPort: pulumi.Int(443),
            PolicyNames: pulumi.StringArray{
                wu_tang_ssl_tls_1_1.PolicyName,
            },
        })
        if err != nil {
            return err
        }
        return nil
    })
}

import pulumi
import pulumi_aws as aws

wu_tang = aws.elb.LoadBalancer("wu-tang",
    availability_zones=["us-east-1a"],
    listeners=[{
        "instance_port": 443,
        "instanceProtocol": "http",
        "lb_port": 443,
        "lbProtocol": "https",
        "sslCertificateId": "arn:aws:iam::000000000000:server-certificate/wu-tang.net",
    }],
    tags={
        "Name": "wu-tang",
    })
wu_tang_ssl_tls_1_1 = aws.elb.LoadBalancerPolicy("wu-tang-ssl-tls-1-1",
    load_balancer_name=wu_tang.name,
    policy_attributes=[{
        "name": "Reference-Security-Policy",
        "value": "ELBSecurityPolicy-TLS-1-1-2017-01",
    }],
    policy_name="wu-tang-ssl",
    policy_type_name="SSLNegotiationPolicyType")
wu_tang_listener_policies_443 = aws.elb.ListenerPolicy("wu-tang-listener-policies-443",
    load_balancer_name=wu_tang.name,
    load_balancer_port=443,
    policy_names=[wu_tang_ssl_tls_1_1.policy_name])

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const wu_tang = new aws.elb.LoadBalancer("wu-tang", {
    availabilityZones: ["us-east-1a"],
    listeners: [{
        instancePort: 443,
        instanceProtocol: "http",
        lbPort: 443,
        lbProtocol: "https",
        sslCertificateId: "arn:aws:iam::000000000000:server-certificate/wu-tang.net",
    }],
    tags: {
        Name: "wu-tang",
    },
});
const wu_tang_ssl_tls_1_1 = new aws.elb.LoadBalancerPolicy("wu-tang-ssl-tls-1-1", {
    loadBalancerName: wu_tang.name,
    policyAttributes: [{
        name: "Reference-Security-Policy",
        value: "ELBSecurityPolicy-TLS-1-1-2017-01",
    }],
    policyName: "wu-tang-ssl",
    policyTypeName: "SSLNegotiationPolicyType",
});
const wu_tang_listener_policies_443 = new aws.elb.ListenerPolicy("wu-tang-listener-policies-443", {
    loadBalancerName: wu_tang.name,
    loadBalancerPort: 443,
    policyNames: [wu_tang_ssl_tls_1_1.policyName],
});

Deprecated: aws.elasticloadbalancing.ListenerPolicy has been deprecated in favor of aws.elb.ListenerPolicy

Create a ListenerPolicy Resource

new ListenerPolicy(name: string, args: ListenerPolicyArgs, opts?: CustomResourceOptions);

def ListenerPolicy(resource_name, opts=None, load_balancer_name=None, load_balancer_port=None, policy_names=None, __props__=None);

func NewListenerPolicy(ctx *Context, name string, args ListenerPolicyArgs, opts ...ResourceOption) (*ListenerPolicy, error)

public ListenerPolicy(string name, ListenerPolicyArgs args, CustomResourceOptions? opts = null)

name string: The unique name of the resource.
args ListenerPolicyArgs: The arguments to resource properties.
opts CustomResourceOptions: Bag of options to control resource's behavior.

resource_name str: The unique name of the resource.
opts ResourceOptions: A bag of options that control this resource's behavior.

ctx Context: Context object for the current deployment.
name string: The unique name of the resource.
args ListenerPolicyArgs: The arguments to resource properties.
opts ResourceOption: Bag of options to control resource's behavior.

name string: The unique name of the resource.
args ListenerPolicyArgs: The arguments to resource properties.
opts CustomResourceOptions: Bag of options to control resource's behavior.

ListenerPolicy Resource Properties

To learn more about resource properties and how to use them, see Inputs and Outputs in the Programming Model docs.

Inputs

The ListenerPolicy resource accepts the following input properties:

LoadBalancerName string: The load balancer to attach the policy to.
LoadBalancerPort int: The load balancer listener port to apply the policy to.
PolicyNames List<string>: List of Policy Names to apply to the backend server.

LoadBalancerName string: The load balancer to attach the policy to.
LoadBalancerPort int: The load balancer listener port to apply the policy to.
PolicyNames []string: List of Policy Names to apply to the backend server.

loadBalancerName string: The load balancer to attach the policy to.
loadBalancerPort number: The load balancer listener port to apply the policy to.
policyNames string[]: List of Policy Names to apply to the backend server.

load_balancer_name str: The load balancer to attach the policy to.
load_balancer_port float: The load balancer listener port to apply the policy to.
policy_names List[str]: List of Policy Names to apply to the backend server.

Outputs

All input properties are implicitly available as output properties. Additionally, the ListenerPolicy resource produces the following output properties:

Id string: The provider-assigned unique ID for this managed resource.

Id string: The provider-assigned unique ID for this managed resource.

id string: The provider-assigned unique ID for this managed resource.

id str: The provider-assigned unique ID for this managed resource.

Look up an Existing ListenerPolicy Resource

Get an existing ListenerPolicy resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

public static get(name: string, id: Input<ID>, state?: ListenerPolicyState, opts?: CustomResourceOptions): ListenerPolicy

static get(resource_name, id, opts=None, load_balancer_name=None, load_balancer_port=None, policy_names=None, __props__=None);

func GetListenerPolicy(ctx *Context, name string, id IDInput, state *ListenerPolicyState, opts ...ResourceOption) (*ListenerPolicy, error)

public static ListenerPolicy Get(string name, Input<string> id, ListenerPolicyState? state, CustomResourceOptions? opts = null)

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

resource_name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

The following state arguments are supported:

LoadBalancerName string: The load balancer to attach the policy to.
LoadBalancerPort int: The load balancer listener port to apply the policy to.
PolicyNames List<string>: List of Policy Names to apply to the backend server.

LoadBalancerName string: The load balancer to attach the policy to.
LoadBalancerPort int: The load balancer listener port to apply the policy to.
PolicyNames []string: List of Policy Names to apply to the backend server.

loadBalancerName string: The load balancer to attach the policy to.
loadBalancerPort number: The load balancer listener port to apply the policy to.
policyNames string[]: List of Policy Names to apply to the backend server.

load_balancer_name str: The load balancer to attach the policy to.
load_balancer_port float: The load balancer listener port to apply the policy to.
policy_names List[str]: List of Policy Names to apply to the backend server.

Package Details

Repository: https://github.com/pulumi/pulumi-aws
License: Apache-2.0
Notes: This Pulumi package is based on the aws Terraform Provider.

The Pulumi Platform

Get Started

Migrate to Pulumi

Solutions for All Teams and Engineers

Any Code

Any Cloud