pulumi-alicloud-kotlin/com.pulumi.alicloud.slb.kotlin/Listener

Listener

class Listener : KotlinCustomResource

Provides a Classic Load Balancer (SLB) Load Balancer Listener resource. For information about Classic Load Balancer (SLB) and how to use it, see What is Classic Load Balancer. For information about listener and how to use it, please see the following:

NOTE: Available since v1.0.0.

Example Usage

Basic Usage

import * as pulumi from "@pulumi/pulumi";
import * as alicloud from "@pulumi/alicloud";
import * as random from "@pulumi/random";
const config = new pulumi.Config();
const name = config.get("name") || "tf-example";
const _default = new random.index.Integer("default", {
    min: 10000,
    max: 99999,
});
const listener = new alicloud.slb.ApplicationLoadBalancer("listener", {
    loadBalancerName: `${name}-${_default.result}`,
    internetChargeType: "PayByTraffic",
    addressType: "internet",
    instanceChargeType: "PayByCLCU",
});
const listenerAcl = new alicloud.slb.Acl("listener", {
    name: `${name}-${_default.result}`,
    ipVersion: "ipv4",
});
const listenerListener = new alicloud.slb.Listener("listener", {
    loadBalancerId: listener.id,
    backendPort: 80,
    frontendPort: 80,
    protocol: "http",
    bandwidth: 10,
    stickySession: "on",
    stickySessionType: "insert",
    cookieTimeout: 86400,
    cookie: "tfslblistenercookie",
    healthCheck: "on",
    healthCheckDomain: "ali.com",
    healthCheckUri: "/cons",
    healthCheckConnectPort: 20,
    healthyThreshold: 8,
    unhealthyThreshold: 8,
    healthCheckTimeout: 8,
    healthCheckInterval: 5,
    healthCheckHttpCode: "http_2xx,http_3xx",
    xForwardedFor: {
        retriveSlbIp: true,
        retriveSlbId: true,
    },
    aclStatus: "on",
    aclType: "white",
    aclIds: [listenerAcl&#46;id],
    requestTimeout: 80,
    idleTimeout: 30,
});
const first = new alicloud.slb.AclEntryAttachment("first", {
    aclId: listenerAcl.id,
    entry: "10.10.10.0/24",
    comment: "first",
});
const second = new alicloud.slb.AclEntryAttachment("second", {
    aclId: listenerAcl.id,
    entry: "168.10.10.0/24",
    comment: "second",
});

import pulumi
import pulumi_alicloud as alicloud
import pulumi_random as random
config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "tf-example"
default = random.index.Integer("default",
    min=10000,
    max=99999)
listener = alicloud.slb.ApplicationLoadBalancer("listener",
    load_balancer_name=f"{name}-{default['result']}",
    internet_charge_type="PayByTraffic",
    address_type="internet",
    instance_charge_type="PayByCLCU")
listener_acl = alicloud.slb.Acl("listener",
    name=f"{name}-{default['result']}",
    ip_version="ipv4")
listener_listener = alicloud.slb.Listener("listener",
    load_balancer_id=listener.id,
    backend_port=80,
    frontend_port=80,
    protocol="http",
    bandwidth=10,
    sticky_session="on",
    sticky_session_type="insert",
    cookie_timeout=86400,
    cookie="tfslblistenercookie",
    health_check="on",
    health_check_domain="ali.com",
    health_check_uri="/cons",
    health_check_connect_port=20,
    healthy_threshold=8,
    unhealthy_threshold=8,
    health_check_timeout=8,
    health_check_interval=5,
    health_check_http_code="http_2xx,http_3xx",
    x_forwarded_for={
        "retrive_slb_ip": True,
        "retrive_slb_id": True,
    },
    acl_status="on",
    acl_type="white",
    acl_ids=[listener_acl&#46;id],
    request_timeout=80,
    idle_timeout=30)
first = alicloud.slb.AclEntryAttachment("first",
    acl_id=listener_acl.id,
    entry="10.10.10.0/24",
    comment="first")
second = alicloud.slb.AclEntryAttachment("second",
    acl_id=listener_acl.id,
    entry="168.10.10.0/24",
    comment="second")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AliCloud = Pulumi.AliCloud;
using Random = Pulumi.Random;
return await Deployment.RunAsync(() =>
{
    var config = new Config();
    var name = config.Get("name") ?? "tf-example";
    var @default = new Random.Index.Integer("default", new()
    {
        Min = 10000,
        Max = 99999,
    });
    var listener = new AliCloud.Slb.ApplicationLoadBalancer("listener", new()
    {
        LoadBalancerName = $"{name}-{@default.Result}",
        InternetChargeType = "PayByTraffic",
        AddressType = "internet",
        InstanceChargeType = "PayByCLCU",
    });
    var listenerAcl = new AliCloud.Slb.Acl("listener", new()
    {
        Name = $"{name}-{@default.Result}",
        IpVersion = "ipv4",
    });
    var listenerListener = new AliCloud.Slb.Listener("listener", new()
    {
        LoadBalancerId = listener.Id,
        BackendPort = 80,
        FrontendPort = 80,
        Protocol = "http",
        Bandwidth = 10,
        StickySession = "on",
        StickySessionType = "insert",
        CookieTimeout = 86400,
        Cookie = "tfslblistenercookie",
        HealthCheck = "on",
        HealthCheckDomain = "ali.com",
        HealthCheckUri = "/cons",
        HealthCheckConnectPort = 20,
        HealthyThreshold = 8,
        UnhealthyThreshold = 8,
        HealthCheckTimeout = 8,
        HealthCheckInterval = 5,
        HealthCheckHttpCode = "http_2xx,http_3xx",
        XForwardedFor = new AliCloud.Slb.Inputs.ListenerXForwardedForArgs
        {
            RetriveSlbIp = true,
            RetriveSlbId = true,
        },
        AclStatus = "on",
        AclType = "white",
        AclIds = new[]
        {
            listenerAcl.Id,
        },
        RequestTimeout = 80,
        IdleTimeout = 30,
    });
    var first = new AliCloud.Slb.AclEntryAttachment("first", new()
    {
        AclId = listenerAcl.Id,
        Entry = "10.10.10.0/24",
        Comment = "first",
    });
    var second = new AliCloud.Slb.AclEntryAttachment("second", new()
    {
        AclId = listenerAcl.Id,
        Entry = "168.10.10.0/24",
        Comment = "second",
    });
});

package main
import (
	"fmt"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/slb"
	"github.com/pulumi/pulumi-random/sdk/v4/go/random"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		name := "tf-example"
		if param := cfg.Get("name"); param != "" {
			name = param
		}
		_default, err := random.NewInteger(ctx, "default", &random.IntegerArgs{
			Min: 10000,
			Max: 99999,
		})
		if err != nil {
			return err
		}
		listener, err := slb.NewApplicationLoadBalancer(ctx, "listener", &slb.ApplicationLoadBalancerArgs{
			LoadBalancerName:   pulumi.Sprintf("%v-%v", name, _default.Result),
			InternetChargeType: pulumi.String("PayByTraffic"),
			AddressType:        pulumi.String("internet"),
			InstanceChargeType: pulumi.String("PayByCLCU"),
		})
		if err != nil {
			return err
		}
		listenerAcl, err := slb.NewAcl(ctx, "listener", &slb.AclArgs{
			Name:      pulumi.Sprintf("%v-%v", name, _default.Result),
			IpVersion: pulumi.String("ipv4"),
		})
		if err != nil {
			return err
		}
		_, err = slb.NewListener(ctx, "listener", &slb.ListenerArgs{
			LoadBalancerId:         listener.ID(),
			BackendPort:            pulumi.Int(80),
			FrontendPort:           pulumi.Int(80),
			Protocol:               pulumi.String("http"),
			Bandwidth:              pulumi.Int(10),
			StickySession:          pulumi.String("on"),
			StickySessionType:      pulumi.String("insert"),
			CookieTimeout:          pulumi.Int(86400),
			Cookie:                 pulumi.String("tfslblistenercookie"),
			HealthCheck:            pulumi.String("on"),
			HealthCheckDomain:      pulumi.String("ali.com"),
			HealthCheckUri:         pulumi.String("/cons"),
			HealthCheckConnectPort: pulumi.Int(20),
			HealthyThreshold:       pulumi.Int(8),
			UnhealthyThreshold:     pulumi.Int(8),
			HealthCheckTimeout:     pulumi.Int(8),
			HealthCheckInterval:    pulumi.Int(5),
			HealthCheckHttpCode:    pulumi.String("http_2xx,http_3xx"),
			XForwardedFor: &slb.ListenerXForwardedForArgs{
				RetriveSlbIp: pulumi.Bool(true),
				RetriveSlbId: pulumi.Bool(true),
			},
			AclStatus: pulumi.String("on"),
			AclType:   pulumi.String("white"),
			AclIds: pulumi.StringArray{
				listenerAcl.ID(),
			},
			RequestTimeout: pulumi.Int(80),
			IdleTimeout:    pulumi.Int(30),
		})
		if err != nil {
			return err
		}
		_, err = slb.NewAclEntryAttachment(ctx, "first", &slb.AclEntryAttachmentArgs{
			AclId:   listenerAcl.ID(),
			Entry:   pulumi.String("10.10.10.0/24"),
			Comment: pulumi.String("first"),
		})
		if err != nil {
			return err
		}
		_, err = slb.NewAclEntryAttachment(ctx, "second", &slb.AclEntryAttachmentArgs{
			AclId:   listenerAcl.ID(),
			Entry:   pulumi.String("168.10.10.0/24"),
			Comment: pulumi.String("second"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.random.integer;
import com.pulumi.random.integerArgs;
import com.pulumi.alicloud.slb.ApplicationLoadBalancer;
import com.pulumi.alicloud.slb.ApplicationLoadBalancerArgs;
import com.pulumi.alicloud.slb.Acl;
import com.pulumi.alicloud.slb.AclArgs;
import com.pulumi.alicloud.slb.Listener;
import com.pulumi.alicloud.slb.ListenerArgs;
import com.pulumi.alicloud.slb.inputs.ListenerXForwardedForArgs;
import com.pulumi.alicloud.slb.AclEntryAttachment;
import com.pulumi.alicloud.slb.AclEntryAttachmentArgs;
import java.util.List;
import java.util.ArrayList;
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) {
        final var config = ctx.config();
        final var name = config.get("name").orElse("tf-example");
        var default_ = new Integer("default", IntegerArgs.builder()
            .min(10000)
            .max(99999)
            .build());
        var listener = new ApplicationLoadBalancer("listener", ApplicationLoadBalancerArgs.builder()
            .loadBalancerName(String.format("%s-%s", name,default_.result()))
            .internetChargeType("PayByTraffic")
            .addressType("internet")
            .instanceChargeType("PayByCLCU")
            .build());
        var listenerAcl = new Acl("listenerAcl", AclArgs.builder()
            .name(String.format("%s-%s", name,default_.result()))
            .ipVersion("ipv4")
            .build());
        var listenerListener = new Listener("listenerListener", ListenerArgs.builder()
            .loadBalancerId(listener.id())
            .backendPort(80)
            .frontendPort(80)
            .protocol("http")
            .bandwidth(10)
            .stickySession("on")
            .stickySessionType("insert")
            .cookieTimeout(86400)
            .cookie("tfslblistenercookie")
            .healthCheck("on")
            .healthCheckDomain("ali.com")
            .healthCheckUri("/cons")
            .healthCheckConnectPort(20)
            .healthyThreshold(8)
            .unhealthyThreshold(8)
            .healthCheckTimeout(8)
            .healthCheckInterval(5)
            .healthCheckHttpCode("http_2xx,http_3xx")
            .xForwardedFor(ListenerXForwardedForArgs.builder()
                .retriveSlbIp(true)
                .retriveSlbId(true)
                .build())
            .aclStatus("on")
            .aclType("white")
            .aclIds(listenerAcl.id())
            .requestTimeout(80)
            .idleTimeout(30)
            .build());
        var first = new AclEntryAttachment("first", AclEntryAttachmentArgs.builder()
            .aclId(listenerAcl.id())
            .entry("10.10.10.0/24")
            .comment("first")
            .build());
        var second = new AclEntryAttachment("second", AclEntryAttachmentArgs.builder()
            .aclId(listenerAcl.id())
            .entry("168.10.10.0/24")
            .comment("second")
            .build());
    }
}

configuration:
  name:
    type: string
    default: tf-example
resources:
  default:
    type: random:integer
    properties:
      min: 10000
      max: 99999
  listener:
    type: alicloud:slb:ApplicationLoadBalancer
    properties:
      loadBalancerName: ${name}-${default.result}
      internetChargeType: PayByTraffic
      addressType: internet
      instanceChargeType: PayByCLCU
  listenerListener:
    type: alicloud:slb:Listener
    name: listener
    properties:
      loadBalancerId: ${listener.id}
      backendPort: 80
      frontendPort: 80
      protocol: http
      bandwidth: 10
      stickySession: on
      stickySessionType: insert
      cookieTimeout: 86400
      cookie: tfslblistenercookie
      healthCheck: on
      healthCheckDomain: ali.com
      healthCheckUri: /cons
      healthCheckConnectPort: 20
      healthyThreshold: 8
      unhealthyThreshold: 8
      healthCheckTimeout: 8
      healthCheckInterval: 5
      healthCheckHttpCode: http_2xx,http_3xx
      xForwardedFor:
        retriveSlbIp: true
        retriveSlbId: true
      aclStatus: on
      aclType: white
      aclIds:
        - ${listenerAcl.id}
      requestTimeout: 80
      idleTimeout: 30
  listenerAcl:
    type: alicloud:slb:Acl
    name: listener
    properties:
      name: ${name}-${default.result}
      ipVersion: ipv4
  first:
    type: alicloud:slb:AclEntryAttachment
    properties:
      aclId: ${listenerAcl.id}
      entry: 10.10.10.0/24
      comment: first
  second:
    type: alicloud:slb:AclEntryAttachment
    properties:
      aclId: ${listenerAcl.id}
      entry: 168.10.10.0/24
      comment: second

Import

Classic Load Balancer (SLB) Load Balancer Listener can be imported using the id, e.g.

$ pulumi import alicloud:slb/listener:Listener example <load_balancer_id>:<protocol>:<frontend_port>

$ pulumi import alicloud:slb/listener:Listener example <load_balancer_id>:<frontend_port>

Properties

aclId

val ~~aclId~~: Output<String>

aclIds

val aclIds: Output<List<String>>

aclStatus

val aclStatus: Output<String>?

aclType

val aclType: Output<String>?

backendPort

val backendPort: Output<Int>?

bandwidth

val bandwidth: Output<Int>

caCertificateId

val caCertificateId: Output<String>?

val cookie: Output<String>?

cookieTimeout

val cookieTimeout: Output<Int>?

deleteProtectionValidation

val deleteProtectionValidation: Output<Boolean>?

description

val description: Output<String>?

enableHttp2

val enableHttp2: Output<String>?

establishedTimeout

val establishedTimeout: Output<Int>?

forwardPort

val forwardPort: Output<Int>?

frontendPort

val frontendPort: Output<Int>

gzip

val gzip: Output<Boolean>?

healthCheck

val healthCheck: Output<String>?

healthCheckConnectPort

val healthCheckConnectPort: Output<Int>

healthCheckDomain

val healthCheckDomain: Output<String>?

healthCheckHttpCode

val healthCheckHttpCode: Output<String>

healthCheckInterval

val healthCheckInterval: Output<Int>?

healthCheckMethod

val healthCheckMethod: Output<String>

healthCheckTimeout

val healthCheckTimeout: Output<Int>?

healthCheckType

val healthCheckType: Output<String>?

healthCheckUri

val healthCheckUri: Output<String>?

healthyThreshold

val healthyThreshold: Output<Int>?

val id: Output<String>

idleTimeout

val idleTimeout: Output<Int>?

listenerForward

val listenerForward: Output<String>

loadBalancerId

val loadBalancerId: Output<String>

masterSlaveServerGroupId

val masterSlaveServerGroupId: Output<String>?

persistenceTimeout

val persistenceTimeout: Output<Int>?

protocol

val protocol: Output<String>

proxyProtocolV2Enabled

val proxyProtocolV2Enabled: Output<Boolean>

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

requestTimeout

val requestTimeout: Output<Int>?

scheduler

val scheduler: Output<String>?

serverCertificateId

val serverCertificateId: Output<String>

serverGroupId

val serverGroupId: Output<String>?

sslCertificateId

val ~~sslCertificateId~~: Output<String>

stickySession

val stickySession: Output<String>?

stickySessionType

val stickySessionType: Output<String>?

tlsCipherPolicy

val tlsCipherPolicy: Output<String>?

unhealthyThreshold

val unhealthyThreshold: Output<Int>?

urn

val urn: Output<String>

xForwardedFor

val xForwardedFor: Output<ListenerXForwardedFor>

Whether to set additional HTTP Header field "X-Forwarded-For".