volcengine.alb.Listener

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

const fooZones = volcengine.ecs.getZones({});
const fooVpc = new volcengine.vpc.Vpc("fooVpc", {
    vpcName: "acc-test-vpc",
    cidrBlock: "172.16.0.0/16",
});
const fooSubnet = new volcengine.vpc.Subnet("fooSubnet", {
    subnetName: "acc-test-subnet",
    cidrBlock: "172.16.0.0/24",
    zoneId: fooZones.then(fooZones => fooZones.zones?.[0]?.id),
    vpcId: fooVpc.id,
});
const fooAlb = new volcengine.alb.Alb("fooAlb", {
    addressIpVersion: "IPv4",
    type: "private",
    loadBalancerName: "acc-test-alb-private",
    description: "acc-test",
    subnetIds: [fooSubnet.id],
    projectName: "default",
    deleteProtection: "off",
    tags: [{
        key: "k1",
        value: "v1",
    }],
});
const fooServerGroup = new volcengine.alb.ServerGroup("fooServerGroup", {
    vpcId: fooVpc.id,
    serverGroupName: "acc-test-server-group",
    description: "acc-test",
    serverGroupType: "instance",
    scheduler: "wlc",
    projectName: "default",
    healthCheck: {
        enabled: "on",
        interval: 3,
        timeout: 3,
        method: "GET",
    },
    stickySessionConfig: {
        stickySessionEnabled: "on",
        stickySessionType: "insert",
        cookieTimeout: 1100,
    },
});
const fooCertificate = new volcengine.alb.Certificate("fooCertificate", {
    description: "tf-test",
    publicKey: "public key",
    privateKey: "private key",
});
const fooListener = new volcengine.alb.Listener("fooListener", {
    loadBalancerId: fooAlb.id,
    listenerName: "acc-test-listener",
    protocol: "HTTPS",
    port: 6666,
    enabled: "off",
    certificateSource: "alb",
    certificateId: fooCertificate.id,
    serverGroupId: fooServerGroup.id,
    description: "acc test listener",
    accessLogRecordCustomizedHeadersEnabled: "off",
    caCertificateSource: "alb",
    caCertificateId: "cert-xoekc6lpu9s054ov5eo*****",
    domainExtensions: [{
        domain: "example.com",
        certificateSource: "alb",
        certificateId: "cert-1pf4a8k8tokcg845wf******",
    }],
    tags: [{
        key: "key1",
        value: "value2",
    }],
});

import pulumi
import pulumi_volcengine as volcengine

foo_zones = volcengine.ecs.get_zones()
foo_vpc = volcengine.vpc.Vpc("fooVpc",
    vpc_name="acc-test-vpc",
    cidr_block="172.16.0.0/16")
foo_subnet = volcengine.vpc.Subnet("fooSubnet",
    subnet_name="acc-test-subnet",
    cidr_block="172.16.0.0/24",
    zone_id=foo_zones.zones[0].id,
    vpc_id=foo_vpc.id)
foo_alb = volcengine.alb.Alb("fooAlb",
    address_ip_version="IPv4",
    type="private",
    load_balancer_name="acc-test-alb-private",
    description="acc-test",
    subnet_ids=[foo_subnet.id],
    project_name="default",
    delete_protection="off",
    tags=[volcengine.alb.AlbTagArgs(
        key="k1",
        value="v1",
    )])
foo_server_group = volcengine.alb.ServerGroup("fooServerGroup",
    vpc_id=foo_vpc.id,
    server_group_name="acc-test-server-group",
    description="acc-test",
    server_group_type="instance",
    scheduler="wlc",
    project_name="default",
    health_check=volcengine.alb.ServerGroupHealthCheckArgs(
        enabled="on",
        interval=3,
        timeout=3,
        method="GET",
    ),
    sticky_session_config=volcengine.alb.ServerGroupStickySessionConfigArgs(
        sticky_session_enabled="on",
        sticky_session_type="insert",
        cookie_timeout=1100,
    ))
foo_certificate = volcengine.alb.Certificate("fooCertificate",
    description="tf-test",
    public_key="public key",
    private_key="private key")
foo_listener = volcengine.alb.Listener("fooListener",
    load_balancer_id=foo_alb.id,
    listener_name="acc-test-listener",
    protocol="HTTPS",
    port=6666,
    enabled="off",
    certificate_source="alb",
    certificate_id=foo_certificate.id,
    server_group_id=foo_server_group.id,
    description="acc test listener",
    access_log_record_customized_headers_enabled="off",
    ca_certificate_source="alb",
    ca_certificate_id="cert-xoekc6lpu9s054ov5eo*****",
    domain_extensions=[volcengine.alb.ListenerDomainExtensionArgs(
        domain="example.com",
        certificate_source="alb",
        certificate_id="cert-1pf4a8k8tokcg845wf******",
    )],
    tags=[volcengine.alb.ListenerTagArgs(
        key="key1",
        value="value2",
    )])

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/alb"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/ecs"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/vpc"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		fooZones, err := ecs.GetZones(ctx, nil, nil)
		if err != nil {
			return err
		}
		fooVpc, err := vpc.NewVpc(ctx, "fooVpc", &vpc.VpcArgs{
			VpcName:   pulumi.String("acc-test-vpc"),
			CidrBlock: pulumi.String("172.16.0.0/16"),
		})
		if err != nil {
			return err
		}
		fooSubnet, err := vpc.NewSubnet(ctx, "fooSubnet", &vpc.SubnetArgs{
			SubnetName: pulumi.String("acc-test-subnet"),
			CidrBlock:  pulumi.String("172.16.0.0/24"),
			ZoneId:     pulumi.String(fooZones.Zones[0].Id),
			VpcId:      fooVpc.ID(),
		})
		if err != nil {
			return err
		}
		fooAlb, err := alb.NewAlb(ctx, "fooAlb", &alb.AlbArgs{
			AddressIpVersion: pulumi.String("IPv4"),
			Type:             pulumi.String("private"),
			LoadBalancerName: pulumi.String("acc-test-alb-private"),
			Description:      pulumi.String("acc-test"),
			SubnetIds: pulumi.StringArray{
				fooSubnet.ID(),
			},
			ProjectName:      pulumi.String("default"),
			DeleteProtection: pulumi.String("off"),
			Tags: alb.AlbTagArray{
				&alb.AlbTagArgs{
					Key:   pulumi.String("k1"),
					Value: pulumi.String("v1"),
				},
			},
		})
		if err != nil {
			return err
		}
		fooServerGroup, err := alb.NewServerGroup(ctx, "fooServerGroup", &alb.ServerGroupArgs{
			VpcId:           fooVpc.ID(),
			ServerGroupName: pulumi.String("acc-test-server-group"),
			Description:     pulumi.String("acc-test"),
			ServerGroupType: pulumi.String("instance"),
			Scheduler:       pulumi.String("wlc"),
			ProjectName:     pulumi.String("default"),
			HealthCheck: &alb.ServerGroupHealthCheckArgs{
				Enabled:  pulumi.String("on"),
				Interval: pulumi.Int(3),
				Timeout:  pulumi.Int(3),
				Method:   pulumi.String("GET"),
			},
			StickySessionConfig: &alb.ServerGroupStickySessionConfigArgs{
				StickySessionEnabled: pulumi.String("on"),
				StickySessionType:    pulumi.String("insert"),
				CookieTimeout:        pulumi.Int(1100),
			},
		})
		if err != nil {
			return err
		}
		fooCertificate, err := alb.NewCertificate(ctx, "fooCertificate", &alb.CertificateArgs{
			Description: pulumi.String("tf-test"),
			PublicKey:   pulumi.String("public key"),
			PrivateKey:  pulumi.String("private key"),
		})
		if err != nil {
			return err
		}
		_, err = alb.NewListener(ctx, "fooListener", &alb.ListenerArgs{
			LoadBalancerId:                          fooAlb.ID(),
			ListenerName:                            pulumi.String("acc-test-listener"),
			Protocol:                                pulumi.String("HTTPS"),
			Port:                                    pulumi.Int(6666),
			Enabled:                                 pulumi.String("off"),
			CertificateSource:                       pulumi.String("alb"),
			CertificateId:                           fooCertificate.ID(),
			ServerGroupId:                           fooServerGroup.ID(),
			Description:                             pulumi.String("acc test listener"),
			AccessLogRecordCustomizedHeadersEnabled: pulumi.String("off"),
			CaCertificateSource:                     pulumi.String("alb"),
			CaCertificateId:                         pulumi.String("cert-xoekc6lpu9s054ov5eo*****"),
			DomainExtensions: alb.ListenerDomainExtensionTypeArray{
				&alb.ListenerDomainExtensionTypeArgs{
					Domain:            pulumi.String("example.com"),
					CertificateSource: pulumi.String("alb"),
					CertificateId:     pulumi.String("cert-1pf4a8k8tokcg845wf******"),
				},
			},
			Tags: alb.ListenerTagArray{
				&alb.ListenerTagArgs{
					Key:   pulumi.String("key1"),
					Value: pulumi.String("value2"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Volcengine = Pulumi.Volcengine;

return await Deployment.RunAsync(() => 
{
    var fooZones = Volcengine.Ecs.GetZones.Invoke();

    var fooVpc = new Volcengine.Vpc.Vpc("fooVpc", new()
    {
        VpcName = "acc-test-vpc",
        CidrBlock = "172.16.0.0/16",
    });

    var fooSubnet = new Volcengine.Vpc.Subnet("fooSubnet", new()
    {
        SubnetName = "acc-test-subnet",
        CidrBlock = "172.16.0.0/24",
        ZoneId = fooZones.Apply(getZonesResult => getZonesResult.Zones[0]?.Id),
        VpcId = fooVpc.Id,
    });

    var fooAlb = new Volcengine.Alb.Alb("fooAlb", new()
    {
        AddressIpVersion = "IPv4",
        Type = "private",
        LoadBalancerName = "acc-test-alb-private",
        Description = "acc-test",
        SubnetIds = new[]
        {
            fooSubnet.Id,
        },
        ProjectName = "default",
        DeleteProtection = "off",
        Tags = new[]
        {
            new Volcengine.Alb.Inputs.AlbTagArgs
            {
                Key = "k1",
                Value = "v1",
            },
        },
    });

    var fooServerGroup = new Volcengine.Alb.ServerGroup("fooServerGroup", new()
    {
        VpcId = fooVpc.Id,
        ServerGroupName = "acc-test-server-group",
        Description = "acc-test",
        ServerGroupType = "instance",
        Scheduler = "wlc",
        ProjectName = "default",
        HealthCheck = new Volcengine.Alb.Inputs.ServerGroupHealthCheckArgs
        {
            Enabled = "on",
            Interval = 3,
            Timeout = 3,
            Method = "GET",
        },
        StickySessionConfig = new Volcengine.Alb.Inputs.ServerGroupStickySessionConfigArgs
        {
            StickySessionEnabled = "on",
            StickySessionType = "insert",
            CookieTimeout = 1100,
        },
    });

    var fooCertificate = new Volcengine.Alb.Certificate("fooCertificate", new()
    {
        Description = "tf-test",
        PublicKey = "public key",
        PrivateKey = "private key",
    });

    var fooListener = new Volcengine.Alb.Listener("fooListener", new()
    {
        LoadBalancerId = fooAlb.Id,
        ListenerName = "acc-test-listener",
        Protocol = "HTTPS",
        Port = 6666,
        Enabled = "off",
        CertificateSource = "alb",
        CertificateId = fooCertificate.Id,
        ServerGroupId = fooServerGroup.Id,
        Description = "acc test listener",
        AccessLogRecordCustomizedHeadersEnabled = "off",
        CaCertificateSource = "alb",
        CaCertificateId = "cert-xoekc6lpu9s054ov5eo*****",
        DomainExtensions = new[]
        {
            new Volcengine.Alb.Inputs.ListenerDomainExtensionArgs
            {
                Domain = "example.com",
                CertificateSource = "alb",
                CertificateId = "cert-1pf4a8k8tokcg845wf******",
            },
        },
        Tags = new[]
        {
            new Volcengine.Alb.Inputs.ListenerTagArgs
            {
                Key = "key1",
                Value = "value2",
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.volcengine.ecs.EcsFunctions;
import com.pulumi.volcengine.ecs.inputs.GetZonesArgs;
import com.pulumi.volcengine.vpc.Vpc;
import com.pulumi.volcengine.vpc.VpcArgs;
import com.pulumi.volcengine.vpc.Subnet;
import com.pulumi.volcengine.vpc.SubnetArgs;
import com.pulumi.volcengine.alb.Alb;
import com.pulumi.volcengine.alb.AlbArgs;
import com.pulumi.volcengine.alb.inputs.AlbTagArgs;
import com.pulumi.volcengine.alb.ServerGroup;
import com.pulumi.volcengine.alb.ServerGroupArgs;
import com.pulumi.volcengine.alb.inputs.ServerGroupHealthCheckArgs;
import com.pulumi.volcengine.alb.inputs.ServerGroupStickySessionConfigArgs;
import com.pulumi.volcengine.alb.Certificate;
import com.pulumi.volcengine.alb.CertificateArgs;
import com.pulumi.volcengine.alb.Listener;
import com.pulumi.volcengine.alb.ListenerArgs;
import com.pulumi.volcengine.alb.inputs.ListenerDomainExtensionArgs;
import com.pulumi.volcengine.alb.inputs.ListenerTagArgs;
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 fooZones = EcsFunctions.getZones();

        var fooVpc = new Vpc("fooVpc", VpcArgs.builder()        
            .vpcName("acc-test-vpc")
            .cidrBlock("172.16.0.0/16")
            .build());

        var fooSubnet = new Subnet("fooSubnet", SubnetArgs.builder()        
            .subnetName("acc-test-subnet")
            .cidrBlock("172.16.0.0/24")
            .zoneId(fooZones.applyValue(getZonesResult -> getZonesResult.zones()[0].id()))
            .vpcId(fooVpc.id())
            .build());

        var fooAlb = new Alb("fooAlb", AlbArgs.builder()        
            .addressIpVersion("IPv4")
            .type("private")
            .loadBalancerName("acc-test-alb-private")
            .description("acc-test")
            .subnetIds(fooSubnet.id())
            .projectName("default")
            .deleteProtection("off")
            .tags(AlbTagArgs.builder()
                .key("k1")
                .value("v1")
                .build())
            .build());

        var fooServerGroup = new ServerGroup("fooServerGroup", ServerGroupArgs.builder()        
            .vpcId(fooVpc.id())
            .serverGroupName("acc-test-server-group")
            .description("acc-test")
            .serverGroupType("instance")
            .scheduler("wlc")
            .projectName("default")
            .healthCheck(ServerGroupHealthCheckArgs.builder()
                .enabled("on")
                .interval(3)
                .timeout(3)
                .method("GET")
                .build())
            .stickySessionConfig(ServerGroupStickySessionConfigArgs.builder()
                .stickySessionEnabled("on")
                .stickySessionType("insert")
                .cookieTimeout("1100")
                .build())
            .build());

        var fooCertificate = new Certificate("fooCertificate", CertificateArgs.builder()        
            .description("tf-test")
            .publicKey("public key")
            .privateKey("private key")
            .build());

        var fooListener = new Listener("fooListener", ListenerArgs.builder()        
            .loadBalancerId(fooAlb.id())
            .listenerName("acc-test-listener")
            .protocol("HTTPS")
            .port(6666)
            .enabled("off")
            .certificateSource("alb")
            .certificateId(fooCertificate.id())
            .serverGroupId(fooServerGroup.id())
            .description("acc test listener")
            .accessLogRecordCustomizedHeadersEnabled("off")
            .caCertificateSource("alb")
            .caCertificateId("cert-xoekc6lpu9s054ov5eo*****")
            .domainExtensions(ListenerDomainExtensionArgs.builder()
                .domain("example.com")
                .certificateSource("alb")
                .certificateId("cert-1pf4a8k8tokcg845wf******")
                .build())
            .tags(ListenerTagArgs.builder()
                .key("key1")
                .value("value2")
                .build())
            .build());

    }
}

resources:
  fooVpc:
    type: volcengine:vpc:Vpc
    properties:
      vpcName: acc-test-vpc
      cidrBlock: 172.16.0.0/16
  fooSubnet:
    type: volcengine:vpc:Subnet
    properties:
      subnetName: acc-test-subnet
      cidrBlock: 172.16.0.0/24
      zoneId: ${fooZones.zones[0].id}
      vpcId: ${fooVpc.id}
  fooAlb:
    type: volcengine:alb:Alb
    properties:
      addressIpVersion: IPv4
      type: private
      loadBalancerName: acc-test-alb-private
      description: acc-test
      subnetIds:
        - ${fooSubnet.id}
      projectName: default
      deleteProtection: off
      tags:
        - key: k1
          value: v1
  fooServerGroup:
    type: volcengine:alb:ServerGroup
    properties:
      vpcId: ${fooVpc.id}
      serverGroupName: acc-test-server-group
      description: acc-test
      serverGroupType: instance
      scheduler: wlc
      projectName: default
      healthCheck:
        enabled: on
        interval: 3
        timeout: 3
        method: GET
      stickySessionConfig:
        stickySessionEnabled: on
        stickySessionType: insert
        cookieTimeout: '1100'
  fooCertificate:
    type: volcengine:alb:Certificate
    properties:
      description: tf-test
      publicKey: public key
      privateKey: private key
  fooListener:
    type: volcengine:alb:Listener
    properties:
      loadBalancerId: ${fooAlb.id}
      listenerName: acc-test-listener
      protocol: HTTPS
      port: 6666
      enabled: off
      certificateSource: alb
      #  cert_center_certificate_id = "cert-***"
      certificateId: ${fooCertificate.id}
      serverGroupId: ${fooServerGroup.id}
      description: acc test listener
      accessLogRecordCustomizedHeadersEnabled: off
      caCertificateSource: alb
      caCertificateId: cert-xoekc6lpu9s054ov5eo*****
      domainExtensions:
        - domain: example.com
          certificateSource: alb
          certificateId: cert-1pf4a8k8tokcg845wf******
      tags:
        - key: key1
          value: value2
variables:
  fooZones:
    fn::invoke:
      Function: volcengine:ecs:getZones
      Arguments: {}

var listenerResource = new Volcengine.Alb.Listener("listenerResource", new()
{
    LoadBalancerId = "string",
    ServerGroupId = "string",
    Protocol = "string",
    Port = 0,
    EnableHttp2 = "string",
    EnableQuic = "string",
    CertCenterCertificateId = "string",
    CertificateId = "string",
    CertificateSource = "string",
    CustomizedCfgId = "string",
    Description = "string",
    DomainExtensions = new[]
    {
        new Volcengine.Alb.Inputs.ListenerDomainExtensionArgs
        {
            CertCenterCertificateId = "string",
            CertificateId = "string",
            CertificateSource = "string",
            Domain = "string",
            DomainExtensionId = "string",
            PcaLeafCertificateId = "string",
        },
    },
    AccessLogRecordCustomizedHeadersEnabled = "string",
    CaCertificateSource = "string",
    Enabled = "string",
    ListenerName = "string",
    CaCertificateId = "string",
    PcaLeafCertificateId = "string",
    PcaRootCaCertificateId = "string",
    PcaSubCaCertificateId = "string",
    AclType = "string",
    AclStatus = "string",
    AclIds = new[]
    {
        "string",
    },
    Tags = new[]
    {
        new Volcengine.Alb.Inputs.ListenerTagArgs
        {
            Key = "string",
            Value = "string",
        },
    },
});

example, err := alb.NewListener(ctx, "listenerResource", &alb.ListenerArgs{
	LoadBalancerId:          pulumi.String("string"),
	ServerGroupId:           pulumi.String("string"),
	Protocol:                pulumi.String("string"),
	Port:                    pulumi.Int(0),
	EnableHttp2:             pulumi.String("string"),
	EnableQuic:              pulumi.String("string"),
	CertCenterCertificateId: pulumi.String("string"),
	CertificateId:           pulumi.String("string"),
	CertificateSource:       pulumi.String("string"),
	CustomizedCfgId:         pulumi.String("string"),
	Description:             pulumi.String("string"),
	DomainExtensions: alb.ListenerDomainExtensionTypeArray{
		&alb.ListenerDomainExtensionTypeArgs{
			CertCenterCertificateId: pulumi.String("string"),
			CertificateId:           pulumi.String("string"),
			CertificateSource:       pulumi.String("string"),
			Domain:                  pulumi.String("string"),
			DomainExtensionId:       pulumi.String("string"),
			PcaLeafCertificateId:    pulumi.String("string"),
		},
	},
	AccessLogRecordCustomizedHeadersEnabled: pulumi.String("string"),
	CaCertificateSource:                     pulumi.String("string"),
	Enabled:                                 pulumi.String("string"),
	ListenerName:                            pulumi.String("string"),
	CaCertificateId:                         pulumi.String("string"),
	PcaLeafCertificateId:                    pulumi.String("string"),
	PcaRootCaCertificateId:                  pulumi.String("string"),
	PcaSubCaCertificateId:                   pulumi.String("string"),
	AclType:                                 pulumi.String("string"),
	AclStatus:                               pulumi.String("string"),
	AclIds: pulumi.StringArray{
		pulumi.String("string"),
	},
	Tags: alb.ListenerTagArray{
		&alb.ListenerTagArgs{
			Key:   pulumi.String("string"),
			Value: pulumi.String("string"),
		},
	},
})

var listenerResource = new com.pulumi.volcengine.alb.Listener("listenerResource", com.pulumi.volcengine.alb.ListenerArgs.builder()
    .loadBalancerId("string")
    .serverGroupId("string")
    .protocol("string")
    .port(0)
    .enableHttp2("string")
    .enableQuic("string")
    .certCenterCertificateId("string")
    .certificateId("string")
    .certificateSource("string")
    .customizedCfgId("string")
    .description("string")
    .domainExtensions(ListenerDomainExtensionArgs.builder()
        .certCenterCertificateId("string")
        .certificateId("string")
        .certificateSource("string")
        .domain("string")
        .domainExtensionId("string")
        .pcaLeafCertificateId("string")
        .build())
    .accessLogRecordCustomizedHeadersEnabled("string")
    .caCertificateSource("string")
    .enabled("string")
    .listenerName("string")
    .caCertificateId("string")
    .pcaLeafCertificateId("string")
    .pcaRootCaCertificateId("string")
    .pcaSubCaCertificateId("string")
    .aclType("string")
    .aclStatus("string")
    .aclIds("string")
    .tags(ListenerTagArgs.builder()
        .key("string")
        .value("string")
        .build())
    .build());

listener_resource = volcengine.alb.Listener("listenerResource",
    load_balancer_id="string",
    server_group_id="string",
    protocol="string",
    port=0,
    enable_http2="string",
    enable_quic="string",
    cert_center_certificate_id="string",
    certificate_id="string",
    certificate_source="string",
    customized_cfg_id="string",
    description="string",
    domain_extensions=[{
        "cert_center_certificate_id": "string",
        "certificate_id": "string",
        "certificate_source": "string",
        "domain": "string",
        "domain_extension_id": "string",
        "pca_leaf_certificate_id": "string",
    }],
    access_log_record_customized_headers_enabled="string",
    ca_certificate_source="string",
    enabled="string",
    listener_name="string",
    ca_certificate_id="string",
    pca_leaf_certificate_id="string",
    pca_root_ca_certificate_id="string",
    pca_sub_ca_certificate_id="string",
    acl_type="string",
    acl_status="string",
    acl_ids=["string"],
    tags=[{
        "key": "string",
        "value": "string",
    }])

const listenerResource = new volcengine.alb.Listener("listenerResource", {
    loadBalancerId: "string",
    serverGroupId: "string",
    protocol: "string",
    port: 0,
    enableHttp2: "string",
    enableQuic: "string",
    certCenterCertificateId: "string",
    certificateId: "string",
    certificateSource: "string",
    customizedCfgId: "string",
    description: "string",
    domainExtensions: [{
        certCenterCertificateId: "string",
        certificateId: "string",
        certificateSource: "string",
        domain: "string",
        domainExtensionId: "string",
        pcaLeafCertificateId: "string",
    }],
    accessLogRecordCustomizedHeadersEnabled: "string",
    caCertificateSource: "string",
    enabled: "string",
    listenerName: "string",
    caCertificateId: "string",
    pcaLeafCertificateId: "string",
    pcaRootCaCertificateId: "string",
    pcaSubCaCertificateId: "string",
    aclType: "string",
    aclStatus: "string",
    aclIds: ["string"],
    tags: [{
        key: "string",
        value: "string",
    }],
});

type: volcengine:alb:Listener
properties:
    accessLogRecordCustomizedHeadersEnabled: string
    aclIds:
        - string
    aclStatus: string
    aclType: string
    caCertificateId: string
    caCertificateSource: string
    certCenterCertificateId: string
    certificateId: string
    certificateSource: string
    customizedCfgId: string
    description: string
    domainExtensions:
        - certCenterCertificateId: string
          certificateId: string
          certificateSource: string
          domain: string
          domainExtensionId: string
          pcaLeafCertificateId: string
    enableHttp2: string
    enableQuic: string
    enabled: string
    listenerName: string
    loadBalancerId: string
    pcaLeafCertificateId: string
    pcaRootCaCertificateId: string
    pcaSubCaCertificateId: string
    port: 0
    protocol: string
    serverGroupId: string
    tags:
        - key: string
          value: string