Package com.pulumi.aws.lb

Class Listener

  • public class Listener
extends com.pulumi.resources.CustomResource
    Provides a Load Balancer Listener resource. > **Note:** `aws.alb.Listener` is known as `aws.lb.Listener`. The functionality is identical. ## Example Usage ### Forward Action 
     
 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());
 
     }
 }
    With weighted target groups: 
     
 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());
 
     }
 }
    To a NLB: 
     
 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());
 
     }
 }
    ### Redirect Action 
     
 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());
 
     }
 }
    ### Fixed-response Action 
     
 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());
 
     }
 }
    ### Authenticate-cognito Action 
     
 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());
 
     }
 }
    ### Authenticate-OIDC Action 
     
 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());
 
     }
 }
    ### JWT Validation Action 
     
 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());
 
     }
 }
    ### Gateway Load Balancer Listener 
     
 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());
 
     }
 }
    ### Mutual TLS Authentication 
     
 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());
 
     }
 }
    ## Import ### Identity Schema #### Required - `arn` (String) ARN of the load balancer listener. Using `pulumi import`, import listeners using their ARN. For example: ```sh $ pulumi import aws:lb/listener:Listener front_end arn:aws:elasticloadbalancing:us-west-2:187416307283:listener/app/front-end-alb/8e4497da625e2d8a/9ab28ade35828f96 ```

    • Constructor Detail

      • Listener

        public Listener​(java.lang.String name)
        Parameters:
        name - The _unique_ name of the resulting resource.

      • Listener

        public Listener​(java.lang.String name,
                ListenerArgs args)
        Parameters:
        name - The _unique_ name of the resulting resource.
        args - The arguments to use to populate this resource's properties.

      • Listener

        public Listener​(java.lang.String name,
                ListenerArgs args,
                @Nullable
                com.pulumi.resources.CustomResourceOptions options)
        Parameters:
        name - The _unique_ name of the resulting resource.
        args - The arguments to use to populate this resource's properties.
        options - A bag of options that control this resource's behavior.

    • Method Detail

      • alpnPolicy

        public com.pulumi.core.Output<java.util.Optional<java.lang.String>> alpnPolicy()
        Returns:
        Name of the Application-Layer Protocol Negotiation (ALPN) policy. Can be set if `protocol` is `TLS`. Valid values are `HTTP1Only`, `HTTP2Only`, `HTTP2Optional`, `HTTP2Preferred`, and `None`.

      • arn

        public com.pulumi.core.Output<java.lang.String> arn()
        Returns:
        ARN of the listener.

      • certificateArn

        public com.pulumi.core.Output<java.util.Optional<java.lang.String>> certificateArn()
        Returns:
        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.ListenerCertificate` resource.

      • defaultActions

        public com.pulumi.core.Output<java.util.List<ListenerDefaultAction>> defaultActions()
        Returns:
        Configuration block for default actions. See below.

      • loadBalancerArn

        public com.pulumi.core.Output<java.lang.String> loadBalancerArn()
        Returns:
        ARN of the load balancer. The following arguments are optional:

      • mutualAuthentication

        public com.pulumi.core.Output<ListenerMutualAuthentication> mutualAuthentication()
        Returns:
        The mutual authentication configuration information. See below.

      • port

        public com.pulumi.core.Output<java.util.Optional<java.lang.Integer>> port()
        Returns:
        Port on which the load balancer is listening. Not valid for Gateway Load Balancers.

      • protocol

        public com.pulumi.core.Output<java.lang.String> protocol()
        Returns:
        Protocol for connections from clients to the load balancer. For Application Load Balancers, valid values are `HTTP` and `HTTPS`, with a default of `HTTP`. For Network Load Balancers, valid values are `TCP`, `TLS`, `UDP`, `TCP_UDP`, `QUIC`, and `TCP_QUIC`. Not valid to use `UDP` or `TCP_UDP` if dual-stack mode is enabled. Not valid to use `QUIC` or `TCP_QUIC` if security groups are configured or dual-stack mode is enabled. Not valid for Gateway Load Balancers.

      • region

        public com.pulumi.core.Output<java.lang.String> region()
        Returns:
        Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.

      • routingHttpRequestXAmznMtlsClientcertHeaderName

        public com.pulumi.core.Output<java.lang.String> routingHttpRequestXAmznMtlsClientcertHeaderName()
        Returns:
        Enables you to modify the header name of the `X-Amzn-Mtls-Clientcert` HTTP request header. Can only be set if protocol is `HTTPS` for Application Load Balancers.

      • routingHttpRequestXAmznMtlsClientcertIssuerHeaderName

        public com.pulumi.core.Output<java.lang.String> routingHttpRequestXAmznMtlsClientcertIssuerHeaderName()
        Returns:
        Enables you to modify the header name of the `X-Amzn-Mtls-Clientcert-Issuer` HTTP request header. Can only be set if protocol is `HTTPS` for Application Load Balancers.

      • routingHttpRequestXAmznMtlsClientcertLeafHeaderName

        public com.pulumi.core.Output<java.lang.String> routingHttpRequestXAmznMtlsClientcertLeafHeaderName()
        Returns:
        Enables you to modify the header name of the `X-Amzn-Mtls-Clientcert-Leaf` HTTP request header. Can only be set if protocol is `HTTPS` for Application Load Balancers.

      • routingHttpRequestXAmznMtlsClientcertSerialNumberHeaderName

        public com.pulumi.core.Output<java.lang.String> routingHttpRequestXAmznMtlsClientcertSerialNumberHeaderName()
        Returns:
        Enables you to modify the header name of the `X-Amzn-Mtls-Clientcert-Serial-Number` HTTP request header. Can only be set if protocol is `HTTPS` for Application Load Balancers.

      • routingHttpRequestXAmznMtlsClientcertSubjectHeaderName

        public com.pulumi.core.Output<java.lang.String> routingHttpRequestXAmznMtlsClientcertSubjectHeaderName()
        Returns:
        Enables you to modify the header name of the `X-Amzn-Mtls-Clientcert-Subject` HTTP request header. Can only be set if protocol is `HTTPS` for Application Load Balancers.

      • routingHttpRequestXAmznMtlsClientcertValidityHeaderName

        public com.pulumi.core.Output<java.lang.String> routingHttpRequestXAmznMtlsClientcertValidityHeaderName()
        Returns:
        Enables you to modify the header name of the `X-Amzn-Mtls-Clientcert-Validity` HTTP request header. Can only be set if protocol is `HTTPS` for Application Load Balancers.

      • routingHttpRequestXAmznTlsCipherSuiteHeaderName

        public com.pulumi.core.Output<java.lang.String> routingHttpRequestXAmznTlsCipherSuiteHeaderName()
        Returns:
        Enables you to modify the header name of the `X-Amzn-Tls-Cipher-Suite` HTTP request header. Can only be set if protocol is `HTTPS` for Application Load Balancers.

      • routingHttpRequestXAmznTlsVersionHeaderName

        public com.pulumi.core.Output<java.lang.String> routingHttpRequestXAmznTlsVersionHeaderName()
        Returns:
        Enables you to modify the header name of the `X-Amzn-Tls-Version` HTTP request header. Can only be set if protocol is `HTTPS` for Application Load Balancers.

      • routingHttpResponseAccessControlAllowCredentialsHeaderValue

        public com.pulumi.core.Output<java.lang.String> routingHttpResponseAccessControlAllowCredentialsHeaderValue()
        Returns:
        Specifies which headers the browser can expose to the requesting client. Can only be set if protocol is `HTTP` or `HTTPS` for Application Load Balancers. Not supported for Network Load Balancer, or with a Gateway Load Balancer. The only valid value is `true`.

      • routingHttpResponseAccessControlAllowHeadersHeaderValue

        public com.pulumi.core.Output<java.lang.String> routingHttpResponseAccessControlAllowHeadersHeaderValue()
        Returns:
        Specifies which headers can be used during the request. Can only be set if protocol is `HTTP` or `HTTPS` for 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.

      • routingHttpResponseAccessControlAllowMethodsHeaderValue

        public com.pulumi.core.Output<java.lang.String> routingHttpResponseAccessControlAllowMethodsHeaderValue()
        Returns:
        Set which HTTP methods are allowed when accessing the server from a different origin. Can only be set if protocol is `HTTP` or `HTTPS` for Application Load Balancers. Not supported for Network Load Balancer, or with a Gateway Load Balancer. Valid values are `GET`, `HEAD`, `POST`, `DELETE`, `CONNECT`, `OPTIONS`, `TRACE` or `PATCH`.

      • routingHttpResponseAccessControlAllowOriginHeaderValue

        public com.pulumi.core.Output<java.lang.String> routingHttpResponseAccessControlAllowOriginHeaderValue()
        Returns:
        Specifies which origins are allowed to access the server. Can only be set if protocol is `HTTP` or `HTTPS` for 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`.

      • routingHttpResponseAccessControlExposeHeadersHeaderValue

        public com.pulumi.core.Output<java.lang.String> routingHttpResponseAccessControlExposeHeadersHeaderValue()
        Returns:
        Specifies whether the browser should include credentials such as cookies or authentication when making requests. Can only be set if protocol is `HTTP` or `HTTPS` for 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`, or `Pragma`. Dependent on your use-case other headers can be exposed, consult the Access-Control-Expose-Headers documentation.

      • routingHttpResponseAccessControlMaxAgeHeaderValue

        public com.pulumi.core.Output<java.lang.String> routingHttpResponseAccessControlMaxAgeHeaderValue()
        Returns:
        Specifies how long the results of a preflight request can be cached, in seconds. Can only be set if protocol is `HTTP` or `HTTPS` for Application Load Balancers. Not supported for Network Load Balancer, or with a Gateway Load Balancer. Valid values are between `0` and `86400`. This value is browser specific, consult the Access-Control-Max-Age documentation.

      • routingHttpResponseContentSecurityPolicyHeaderValue

        public com.pulumi.core.Output<java.lang.String> routingHttpResponseContentSecurityPolicyHeaderValue()
        Returns:
        Specifies restrictions enforced by the browser to help minimize the risk of certain types of security threats. Can only be set if protocol is `HTTP` or `HTTPS` for 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.

      • routingHttpResponseServerEnabled

        public com.pulumi.core.Output<java.lang.Boolean> routingHttpResponseServerEnabled()
        Returns:
        Enables you to allow or remove the HTTP response server header. Can only be set if protocol is `HTTP` or `HTTPS` for Application Load Balancers. Not supported for Network Load Balancer, or with a Gateway Load Balancer. Valid values are `true` or `false`.

      • routingHttpResponseStrictTransportSecurityHeaderValue

        public com.pulumi.core.Output<java.lang.String> routingHttpResponseStrictTransportSecurityHeaderValue()
        Returns:
        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; preload` consult the Strict-Transport-Security documentation for further details.

      • routingHttpResponseXContentTypeOptionsHeaderValue

        public com.pulumi.core.Output<java.lang.String> routingHttpResponseXContentTypeOptionsHeaderValue()
        Returns:
        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 `HTTP` or `HTTPS` for Application Load Balancers. Not supported for Network Load Balancer, or with a Gateway Load Balancer. The only valid value is `nosniff`.

      • routingHttpResponseXFrameOptionsHeaderValue

        public com.pulumi.core.Output<java.lang.String> routingHttpResponseXFrameOptionsHeaderValue()
        Returns:
        Indicates whether the browser is allowed to render a page in a frame, iframe, embed or object. Can only be set if protocol is `HTTP` or `HTTPS` for Application Load Balancers. Not supported for Network Load Balancer, or with a Gateway Load Balancer. The only valid values are `DENY`, `SAMEORIGIN`, or `ALLOW-FROM https://example.com`.

      • sslPolicy

        public com.pulumi.core.Output<java.lang.String> sslPolicy()
        Returns:
        Name of the SSL Policy for the listener. Required if `protocol` is `HTTPS` or `TLS`. Default is `ELBSecurityPolicy-2016-08`.

      • tags

        public com.pulumi.core.Output<java.util.Optional<java.util.Map<java.lang.String,​java.lang.String>>> tags()
        Returns:
        A map of tags to assign to the resource. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level. > **Note::** When a `Name` key is specified in the map, the AWS Console maps the value to the `Name Tag` column value inside the `Listener Rules` table within a specific load balancer listener page. Otherwise, the value resolves to `Default`.

      • tagsAll

        public com.pulumi.core.Output<java.util.Map<java.lang.String,​java.lang.String>> tagsAll()
        Returns:
        A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.

      • tcpIdleTimeoutSeconds

        public com.pulumi.core.Output<java.lang.Integer> tcpIdleTimeoutSeconds()
        Returns:
        TCP idle timeout value in seconds. Can only be set if protocol is `TCP` on Network Load Balancer, or with a Gateway Load Balancer. Not supported for Application Load Balancers. Valid values are between `60` and `6000` inclusive. Default: `350`.

      • get

        public static Listener get​(java.lang.String name,
                           com.pulumi.core.Output<java.lang.String> id,
                           @Nullable
                           ListenerState state,
                           @Nullable
                           com.pulumi.resources.CustomResourceOptions options)
        Get an existing Host resource's state with the given name, ID, and optional extra properties used to qualify the lookup.
        Parameters:
        name - The _unique_ name of the resulting resource.
        id - The _unique_ provider ID of the resource to lookup.
        state -
        options - Optional settings to control the behavior of the CustomResource.