1. Packages
  2. Volcengine
  3. API Docs
  4. tls
  5. RuleAppliers
Volcengine v0.0.45 published on Tuesday, Feb 10, 2026 by Volcengine
Schema (JSON)
volcengine/pulumi-volcengine

volcengine.tls.RuleAppliers

volcengine logo
Volcengine v0.0.45 published on Tuesday, Feb 10, 2026 by Volcengine
Schema (JSON)
volcengine/pulumi-volcengine
    Deprecated: volcengine.tls.RuleAppliers has been deprecated in favor of volcengine.tls.getRuleAppliers

    Use this data source to query detailed information of tls rule appliers

    Example Usage

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

const config = new pulumi.Config();
const name = config.get("name") || "tf-test-rule-applier";
const fooProject = new volcengine.tls.Project("fooProject", {
    projectName: name,
    description: "tf-test-project-desc",
});
const fooTopic = new volcengine.tls.Topic("fooTopic", {
    projectId: fooProject.id,
    topicName: name,
    ttl: 60,
    shardCount: 2,
    autoSplit: true,
    maxSplitShard: 10,
    enableTracking: true,
    timeKey: "request_time",
    timeFormat: "%Y-%m-%dT%H:%M:%S,%f",
    tags: [{
        key: "k1",
        value: "v1",
    }],
    logPublicIp: true,
    enableHotTtl: true,
    hotTtl: 30,
    coldTtl: 30,
    archiveTtl: 0,
});
const fooRule = new volcengine.tls.Rule("fooRule", {
    topicId: fooTopic.id,
    ruleName: "tf-test-rule",
    logType: "delimiter_log",
    logSample: "2018-05-22 15:35:53.850,INFO,XXXX",
    inputType: 1,
    extractRule: {
        delimiter: ",",
        keys: [
            "time",
            "level",
            "msg",
        ],
        timeKey: "time",
        timeFormat: "%Y-%m-%d %H:%M:%S.%f",
        quote: "\"",
        timeZone: "GMT+08:00",
    },
    userDefineRule: {
        enableRawLog: true,
        tailFiles: true,
        shardHashKey: {
            hashKey: "3C",
        },
        advanced: {
            closeInactive: 10,
            closeRemoved: false,
            closeRenamed: false,
            closeEof: false,
            closeTimeout: 1,
        },
    },
    containerRule: {
        stream: "all",
        containerNameRegex: ".*test.*",
        includeContainerLabelRegex: {
            Key1: "Value12",
            Key2: "Value23",
        },
        excludeContainerLabelRegex: {
            Key1: "Value12",
            Key2: "Value22",
        },
        includeContainerEnvRegex: {
            Key1: "Value1",
            Key2: "Value2",
        },
        excludeContainerEnvRegex: {
            Key1: "Value1",
            Key2: "Value2",
        },
        envTag: {
            Key1: "Value1",
            Key2: "Value2",
        },
        kubernetesRule: {
            namespaceNameRegex: ".*test.*",
            workloadType: "Deployment",
            workloadNameRegex: ".*test.*",
            includePodLabelRegex: {
                Key1: "Value1",
                Key2: "Value2",
            },
            excludePodLabelRegex: {
                Key1: "Value1",
                Key2: "Value2",
            },
            podNameRegex: ".*test.*",
            labelTag: {
                Key1: "Value1",
                Key2: "Value2",
            },
            annotationTag: {
                Key1: "Value1",
                Key2: "Value2",
            },
        },
    },
});
const fooHostGroup = new volcengine.tls.HostGroup("fooHostGroup", {
    hostGroupName: name,
    hostGroupType: "Label",
    hostIdentifier: "tf-controller",
    autoUpdate: false,
    serviceLogging: false,
});
// resource "volcengine_tls_rule_applier" "foo" {
//   rule_id       = volcengine_tls_rule.foo.id
//   host_group_id = volcengine_tls_host_group.foo.id
// }
const fooRuleAppliers = volcengine.tls.getRuleAppliersOutput({
    ruleId: fooRule.id,
});

    import pulumi
import pulumi_volcengine as volcengine

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "tf-test-rule-applier"
foo_project = volcengine.tls.Project("fooProject",
    project_name=name,
    description="tf-test-project-desc")
foo_topic = volcengine.tls.Topic("fooTopic",
    project_id=foo_project.id,
    topic_name=name,
    ttl=60,
    shard_count=2,
    auto_split=True,
    max_split_shard=10,
    enable_tracking=True,
    time_key="request_time",
    time_format="%Y-%m-%dT%H:%M:%S,%f",
    tags=[volcengine.tls.TopicTagArgs(
        key="k1",
        value="v1",
    )],
    log_public_ip=True,
    enable_hot_ttl=True,
    hot_ttl=30,
    cold_ttl=30,
    archive_ttl=0)
foo_rule = volcengine.tls.Rule("fooRule",
    topic_id=foo_topic.id,
    rule_name="tf-test-rule",
    log_type="delimiter_log",
    log_sample="2018-05-22 15:35:53.850,INFO,XXXX",
    input_type=1,
    extract_rule=volcengine.tls.RuleExtractRuleArgs(
        delimiter=",",
        keys=[
            "time",
            "level",
            "msg",
        ],
        time_key="time",
        time_format="%Y-%m-%d %H:%M:%S.%f",
        quote="\"",
        time_zone="GMT+08:00",
    ),
    user_define_rule=volcengine.tls.RuleUserDefineRuleArgs(
        enable_raw_log=True,
        tail_files=True,
        shard_hash_key=volcengine.tls.RuleUserDefineRuleShardHashKeyArgs(
            hash_key="3C",
        ),
        advanced=volcengine.tls.RuleUserDefineRuleAdvancedArgs(
            close_inactive=10,
            close_removed=False,
            close_renamed=False,
            close_eof=False,
            close_timeout=1,
        ),
    ),
    container_rule=volcengine.tls.RuleContainerRuleArgs(
        stream="all",
        container_name_regex=".*test.*",
        include_container_label_regex={
            "Key1": "Value12",
            "Key2": "Value23",
        },
        exclude_container_label_regex={
            "Key1": "Value12",
            "Key2": "Value22",
        },
        include_container_env_regex={
            "Key1": "Value1",
            "Key2": "Value2",
        },
        exclude_container_env_regex={
            "Key1": "Value1",
            "Key2": "Value2",
        },
        env_tag={
            "Key1": "Value1",
            "Key2": "Value2",
        },
        kubernetes_rule=volcengine.tls.RuleContainerRuleKubernetesRuleArgs(
            namespace_name_regex=".*test.*",
            workload_type="Deployment",
            workload_name_regex=".*test.*",
            include_pod_label_regex={
                "Key1": "Value1",
                "Key2": "Value2",
            },
            exclude_pod_label_regex={
                "Key1": "Value1",
                "Key2": "Value2",
            },
            pod_name_regex=".*test.*",
            label_tag={
                "Key1": "Value1",
                "Key2": "Value2",
            },
            annotation_tag={
                "Key1": "Value1",
                "Key2": "Value2",
            },
        ),
    ))
foo_host_group = volcengine.tls.HostGroup("fooHostGroup",
    host_group_name=name,
    host_group_type="Label",
    host_identifier="tf-controller",
    auto_update=False,
    service_logging=False)
# resource "volcengine_tls_rule_applier" "foo" {
#   rule_id       = volcengine_tls_rule.foo.id
#   host_group_id = volcengine_tls_host_group.foo.id
# }
foo_rule_appliers = volcengine.tls.get_rule_appliers_output(rule_id=foo_rule.id)

    package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/tls"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		name := "tf-test-rule-applier"
		if param := cfg.Get("name"); param != "" {
			name = param
		}
		fooProject, err := tls.NewProject(ctx, "fooProject", &tls.ProjectArgs{
			ProjectName: pulumi.String(name),
			Description: pulumi.String("tf-test-project-desc"),
		})
		if err != nil {
			return err
		}
		fooTopic, err := tls.NewTopic(ctx, "fooTopic", &tls.TopicArgs{
			ProjectId:      fooProject.ID(),
			TopicName:      pulumi.String(name),
			Ttl:            pulumi.Int(60),
			ShardCount:     pulumi.Int(2),
			AutoSplit:      pulumi.Bool(true),
			MaxSplitShard:  pulumi.Int(10),
			EnableTracking: pulumi.Bool(true),
			TimeKey:        pulumi.String("request_time"),
			TimeFormat:     pulumi.String("%Y-%m-%dT%H:%M:%S,%f"),
			Tags: tls.TopicTagArray{
				&tls.TopicTagArgs{
					Key:   pulumi.String("k1"),
					Value: pulumi.String("v1"),
				},
			},
			LogPublicIp:  pulumi.Bool(true),
			EnableHotTtl: pulumi.Bool(true),
			HotTtl:       pulumi.Int(30),
			ColdTtl:      pulumi.Int(30),
			ArchiveTtl:   pulumi.Int(0),
		})
		if err != nil {
			return err
		}
		fooRule, err := tls.NewRule(ctx, "fooRule", &tls.RuleArgs{
			TopicId:   fooTopic.ID(),
			RuleName:  pulumi.String("tf-test-rule"),
			LogType:   pulumi.String("delimiter_log"),
			LogSample: pulumi.String("2018-05-22 15:35:53.850,INFO,XXXX"),
			InputType: pulumi.Int(1),
			ExtractRule: &tls.RuleExtractRuleArgs{
				Delimiter: pulumi.String(","),
				Keys: pulumi.StringArray{
					pulumi.String("time"),
					pulumi.String("level"),
					pulumi.String("msg"),
				},
				TimeKey:    pulumi.String("time"),
				TimeFormat: pulumi.String("%Y-%m-%d %H:%M:%S.%f"),
				Quote:      pulumi.String("\""),
				TimeZone:   pulumi.String("GMT+08:00"),
			},
			UserDefineRule: &tls.RuleUserDefineRuleArgs{
				EnableRawLog: pulumi.Bool(true),
				TailFiles:    pulumi.Bool(true),
				ShardHashKey: &tls.RuleUserDefineRuleShardHashKeyArgs{
					HashKey: pulumi.String("3C"),
				},
				Advanced: &tls.RuleUserDefineRuleAdvancedArgs{
					CloseInactive: pulumi.Int(10),
					CloseRemoved:  pulumi.Bool(false),
					CloseRenamed:  pulumi.Bool(false),
					CloseEof:      pulumi.Bool(false),
					CloseTimeout:  pulumi.Int(1),
				},
			},
			ContainerRule: &tls.RuleContainerRuleArgs{
				Stream:             pulumi.String("all"),
				ContainerNameRegex: pulumi.String(".*test.*"),
				IncludeContainerLabelRegex: pulumi.StringMap{
					"Key1": pulumi.String("Value12"),
					"Key2": pulumi.String("Value23"),
				},
				ExcludeContainerLabelRegex: pulumi.StringMap{
					"Key1": pulumi.String("Value12"),
					"Key2": pulumi.String("Value22"),
				},
				IncludeContainerEnvRegex: pulumi.StringMap{
					"Key1": pulumi.String("Value1"),
					"Key2": pulumi.String("Value2"),
				},
				ExcludeContainerEnvRegex: pulumi.StringMap{
					"Key1": pulumi.String("Value1"),
					"Key2": pulumi.String("Value2"),
				},
				EnvTag: pulumi.StringMap{
					"Key1": pulumi.String("Value1"),
					"Key2": pulumi.String("Value2"),
				},
				KubernetesRule: &tls.RuleContainerRuleKubernetesRuleArgs{
					NamespaceNameRegex: pulumi.String(".*test.*"),
					WorkloadType:       pulumi.String("Deployment"),
					WorkloadNameRegex:  pulumi.String(".*test.*"),
					IncludePodLabelRegex: pulumi.StringMap{
						"Key1": pulumi.String("Value1"),
						"Key2": pulumi.String("Value2"),
					},
					ExcludePodLabelRegex: pulumi.StringMap{
						"Key1": pulumi.String("Value1"),
						"Key2": pulumi.String("Value2"),
					},
					PodNameRegex: pulumi.String(".*test.*"),
					LabelTag: pulumi.StringMap{
						"Key1": pulumi.String("Value1"),
						"Key2": pulumi.String("Value2"),
					},
					AnnotationTag: pulumi.StringMap{
						"Key1": pulumi.String("Value1"),
						"Key2": pulumi.String("Value2"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = tls.NewHostGroup(ctx, "fooHostGroup", &tls.HostGroupArgs{
			HostGroupName:  pulumi.String(name),
			HostGroupType:  pulumi.String("Label"),
			HostIdentifier: pulumi.String("tf-controller"),
			AutoUpdate:     pulumi.Bool(false),
			ServiceLogging: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		_ = tls.GetRuleAppliersOutput(ctx, tls.GetRuleAppliersOutputArgs{
			RuleId: fooRule.ID(),
		}, nil)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var name = config.Get("name") ?? "tf-test-rule-applier";
    var fooProject = new Volcengine.Tls.Project("fooProject", new()
    {
        ProjectName = name,
        Description = "tf-test-project-desc",
    });

    var fooTopic = new Volcengine.Tls.Topic("fooTopic", new()
    {
        ProjectId = fooProject.Id,
        TopicName = name,
        Ttl = 60,
        ShardCount = 2,
        AutoSplit = true,
        MaxSplitShard = 10,
        EnableTracking = true,
        TimeKey = "request_time",
        TimeFormat = "%Y-%m-%dT%H:%M:%S,%f",
        Tags = new[]
        {
            new Volcengine.Tls.Inputs.TopicTagArgs
            {
                Key = "k1",
                Value = "v1",
            },
        },
        LogPublicIp = true,
        EnableHotTtl = true,
        HotTtl = 30,
        ColdTtl = 30,
        ArchiveTtl = 0,
    });

    var fooRule = new Volcengine.Tls.Rule("fooRule", new()
    {
        TopicId = fooTopic.Id,
        RuleName = "tf-test-rule",
        LogType = "delimiter_log",
        LogSample = "2018-05-22 15:35:53.850,INFO,XXXX",
        InputType = 1,
        ExtractRule = new Volcengine.Tls.Inputs.RuleExtractRuleArgs
        {
            Delimiter = ",",
            Keys = new[]
            {
                "time",
                "level",
                "msg",
            },
            TimeKey = "time",
            TimeFormat = "%Y-%m-%d %H:%M:%S.%f",
            Quote = "\"",
            TimeZone = "GMT+08:00",
        },
        UserDefineRule = new Volcengine.Tls.Inputs.RuleUserDefineRuleArgs
        {
            EnableRawLog = true,
            TailFiles = true,
            ShardHashKey = new Volcengine.Tls.Inputs.RuleUserDefineRuleShardHashKeyArgs
            {
                HashKey = "3C",
            },
            Advanced = new Volcengine.Tls.Inputs.RuleUserDefineRuleAdvancedArgs
            {
                CloseInactive = 10,
                CloseRemoved = false,
                CloseRenamed = false,
                CloseEof = false,
                CloseTimeout = 1,
            },
        },
        ContainerRule = new Volcengine.Tls.Inputs.RuleContainerRuleArgs
        {
            Stream = "all",
            ContainerNameRegex = ".*test.*",
            IncludeContainerLabelRegex = 
            {
                { "Key1", "Value12" },
                { "Key2", "Value23" },
            },
            ExcludeContainerLabelRegex = 
            {
                { "Key1", "Value12" },
                { "Key2", "Value22" },
            },
            IncludeContainerEnvRegex = 
            {
                { "Key1", "Value1" },
                { "Key2", "Value2" },
            },
            ExcludeContainerEnvRegex = 
            {
                { "Key1", "Value1" },
                { "Key2", "Value2" },
            },
            EnvTag = 
            {
                { "Key1", "Value1" },
                { "Key2", "Value2" },
            },
            KubernetesRule = new Volcengine.Tls.Inputs.RuleContainerRuleKubernetesRuleArgs
            {
                NamespaceNameRegex = ".*test.*",
                WorkloadType = "Deployment",
                WorkloadNameRegex = ".*test.*",
                IncludePodLabelRegex = 
                {
                    { "Key1", "Value1" },
                    { "Key2", "Value2" },
                },
                ExcludePodLabelRegex = 
                {
                    { "Key1", "Value1" },
                    { "Key2", "Value2" },
                },
                PodNameRegex = ".*test.*",
                LabelTag = 
                {
                    { "Key1", "Value1" },
                    { "Key2", "Value2" },
                },
                AnnotationTag = 
                {
                    { "Key1", "Value1" },
                    { "Key2", "Value2" },
                },
            },
        },
    });

    var fooHostGroup = new Volcengine.Tls.HostGroup("fooHostGroup", new()
    {
        HostGroupName = name,
        HostGroupType = "Label",
        HostIdentifier = "tf-controller",
        AutoUpdate = false,
        ServiceLogging = false,
    });

    // resource "volcengine_tls_rule_applier" "foo" {
    //   rule_id       = volcengine_tls_rule.foo.id
    //   host_group_id = volcengine_tls_host_group.foo.id
    // }
    var fooRuleAppliers = Volcengine.Tls.GetRuleAppliers.Invoke(new()
    {
        RuleId = fooRule.Id,
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.volcengine.tls.Project;
import com.pulumi.volcengine.tls.ProjectArgs;
import com.pulumi.volcengine.tls.Topic;
import com.pulumi.volcengine.tls.TopicArgs;
import com.pulumi.volcengine.tls.inputs.TopicTagArgs;
import com.pulumi.volcengine.tls.Rule;
import com.pulumi.volcengine.tls.RuleArgs;
import com.pulumi.volcengine.tls.inputs.RuleExtractRuleArgs;
import com.pulumi.volcengine.tls.inputs.RuleUserDefineRuleArgs;
import com.pulumi.volcengine.tls.inputs.RuleUserDefineRuleShardHashKeyArgs;
import com.pulumi.volcengine.tls.inputs.RuleUserDefineRuleAdvancedArgs;
import com.pulumi.volcengine.tls.inputs.RuleContainerRuleArgs;
import com.pulumi.volcengine.tls.inputs.RuleContainerRuleKubernetesRuleArgs;
import com.pulumi.volcengine.tls.HostGroup;
import com.pulumi.volcengine.tls.HostGroupArgs;
import com.pulumi.volcengine.tls.TlsFunctions;
import com.pulumi.volcengine.tls.inputs.GetRuleAppliersArgs;
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-test-rule-applier");
        var fooProject = new Project("fooProject", ProjectArgs.builder()        
            .projectName(name)
            .description("tf-test-project-desc")
            .build());

        var fooTopic = new Topic("fooTopic", TopicArgs.builder()        
            .projectId(fooProject.id())
            .topicName(name)
            .ttl(60)
            .shardCount(2)
            .autoSplit(true)
            .maxSplitShard(10)
            .enableTracking(true)
            .timeKey("request_time")
            .timeFormat("%Y-%m-%dT%H:%M:%S,%f")
            .tags(TopicTagArgs.builder()
                .key("k1")
                .value("v1")
                .build())
            .logPublicIp(true)
            .enableHotTtl(true)
            .hotTtl(30)
            .coldTtl(30)
            .archiveTtl(0)
            .build());

        var fooRule = new Rule("fooRule", RuleArgs.builder()        
            .topicId(fooTopic.id())
            .ruleName("tf-test-rule")
            .logType("delimiter_log")
            .logSample("2018-05-22 15:35:53.850,INFO,XXXX")
            .inputType(1)
            .extractRule(RuleExtractRuleArgs.builder()
                .delimiter(",")
                .keys(                
                    "time",
                    "level",
                    "msg")
                .timeKey("time")
                .timeFormat("%Y-%m-%d %H:%M:%S.%f")
                .quote("\"")
                .timeZone("GMT+08:00")
                .build())
            .userDefineRule(RuleUserDefineRuleArgs.builder()
                .enableRawLog(true)
                .tailFiles(true)
                .shardHashKey(RuleUserDefineRuleShardHashKeyArgs.builder()
                    .hashKey("3C")
                    .build())
                .advanced(RuleUserDefineRuleAdvancedArgs.builder()
                    .closeInactive(10)
                    .closeRemoved(false)
                    .closeRenamed(false)
                    .closeEof(false)
                    .closeTimeout(1)
                    .build())
                .build())
            .containerRule(RuleContainerRuleArgs.builder()
                .stream("all")
                .containerNameRegex(".*test.*")
                .includeContainerLabelRegex(Map.ofEntries(
                    Map.entry("Key1", "Value12"),
                    Map.entry("Key2", "Value23")
                ))
                .excludeContainerLabelRegex(Map.ofEntries(
                    Map.entry("Key1", "Value12"),
                    Map.entry("Key2", "Value22")
                ))
                .includeContainerEnvRegex(Map.ofEntries(
                    Map.entry("Key1", "Value1"),
                    Map.entry("Key2", "Value2")
                ))
                .excludeContainerEnvRegex(Map.ofEntries(
                    Map.entry("Key1", "Value1"),
                    Map.entry("Key2", "Value2")
                ))
                .envTag(Map.ofEntries(
                    Map.entry("Key1", "Value1"),
                    Map.entry("Key2", "Value2")
                ))
                .kubernetesRule(RuleContainerRuleKubernetesRuleArgs.builder()
                    .namespaceNameRegex(".*test.*")
                    .workloadType("Deployment")
                    .workloadNameRegex(".*test.*")
                    .includePodLabelRegex(Map.ofEntries(
                        Map.entry("Key1", "Value1"),
                        Map.entry("Key2", "Value2")
                    ))
                    .excludePodLabelRegex(Map.ofEntries(
                        Map.entry("Key1", "Value1"),
                        Map.entry("Key2", "Value2")
                    ))
                    .podNameRegex(".*test.*")
                    .labelTag(Map.ofEntries(
                        Map.entry("Key1", "Value1"),
                        Map.entry("Key2", "Value2")
                    ))
                    .annotationTag(Map.ofEntries(
                        Map.entry("Key1", "Value1"),
                        Map.entry("Key2", "Value2")
                    ))
                    .build())
                .build())
            .build());

        var fooHostGroup = new HostGroup("fooHostGroup", HostGroupArgs.builder()        
            .hostGroupName(name)
            .hostGroupType("Label")
            .hostIdentifier("tf-controller")
            .autoUpdate(false)
            .serviceLogging(false)
            .build());

        // resource "volcengine_tls_rule_applier" "foo" {
        //   rule_id       = volcengine_tls_rule.foo.id
        //   host_group_id = volcengine_tls_host_group.foo.id
        // }
        final var fooRuleAppliers = TlsFunctions.getRuleAppliers(GetRuleAppliersArgs.builder()
            .ruleId(fooRule.id())
            .build());

    }
}

    configuration:
  name:
    type: string
    default: tf-test-rule-applier
resources:
  fooProject:
    type: volcengine:tls:Project
    properties:
      projectName: ${name}
      description: tf-test-project-desc
  fooTopic:
    type: volcengine:tls:Topic
    properties:
      projectId: ${fooProject.id}
      topicName: ${name}
      ttl: 60
      shardCount: 2
      autoSplit: true
      maxSplitShard: 10
      enableTracking: true
      timeKey: request_time
      timeFormat: '%Y-%m-%dT%H:%M:%S,%f'
      tags:
        - key: k1
          value: v1
      logPublicIp: true
      enableHotTtl: true
      hotTtl: 30
      coldTtl: 30
      archiveTtl: 0
  fooRule:
    type: volcengine:tls:Rule
    properties:
      topicId: ${fooTopic.id}
      ruleName: tf-test-rule
      logType: delimiter_log
      logSample: 2018-05-22 15:35:53.850,INFO,XXXX
      inputType: 1 #  exclude_paths {
      #   #    type = "File"
      #   #    value = "/data/nginx/log/*/*/exclude.log"
      #   #  }
      #   #  exclude_paths {
      #   #    type = "Path"
      #   #    value = "/data/nginx/log/*/exclude/"
      #   #  }
      extractRule:
        delimiter: ','
        keys:
          - time
          - level
          - msg
        timeKey: time
        timeFormat: '%Y-%m-%d %H:%M:%S.%f'
        quote: '"'
        timeZone: GMT+08:00
      userDefineRule:
        enableRawLog: true
        tailFiles: true
        shardHashKey:
          hashKey: 3C
        advanced:
          closeInactive: 10
          closeRemoved: false
          closeRenamed: false
          closeEof: false
          closeTimeout: 1
      containerRule:
        stream: all
        containerNameRegex: .*test.*
        includeContainerLabelRegex:
          Key1: Value12
          Key2: Value23
        excludeContainerLabelRegex:
          Key1: Value12
          Key2: Value22
        includeContainerEnvRegex:
          Key1: Value1
          Key2: Value2
        excludeContainerEnvRegex:
          Key1: Value1
          Key2: Value2
        envTag:
          Key1: Value1
          Key2: Value2
        kubernetesRule:
          namespaceNameRegex: .*test.*
          workloadType: Deployment
          workloadNameRegex: .*test.*
          includePodLabelRegex:
            Key1: Value1
            Key2: Value2
          excludePodLabelRegex:
            Key1: Value1
            Key2: Value2
          podNameRegex: .*test.*
          labelTag:
            Key1: Value1
            Key2: Value2
          annotationTag:
            Key1: Value1
            Key2: Value2
  fooHostGroup: # resource "volcengine_tls_rule_applier" "foo" {
  #   rule_id       = volcengine_tls_rule.foo.id
  #   host_group_id = volcengine_tls_host_group.foo.id
  # }
    type: volcengine:tls:HostGroup
    properties:
      hostGroupName: ${name}
      hostGroupType: Label
      hostIdentifier: tf-controller
      autoUpdate: false
      serviceLogging: false
variables:
  fooRuleAppliers:
    fn::invoke:
      Function: volcengine:tls:getRuleAppliers
      Arguments:
        ruleId: ${fooRule.id}

    Using RuleAppliers

    Two invocation forms are available. The direct form accepts plain arguments and either blocks until the result value is available, or returns a Promise-wrapped result. The output form accepts Input-wrapped arguments and returns an Output-wrapped result.

    function ruleAppliers(args: RuleAppliersArgs, opts?: InvokeOptions): Promise<RuleAppliersResult>
function ruleAppliersOutput(args: RuleAppliersOutputArgs, opts?: InvokeOptions): Output<RuleAppliersResult>
    def rule_appliers(output_file: Optional[str] = None,
                  rule_id: Optional[str] = None,
                  opts: Optional[InvokeOptions] = None) -> RuleAppliersResult
def rule_appliers_output(output_file: Optional[pulumi.Input[str]] = None,
                  rule_id: Optional[pulumi.Input[str]] = None,
                  opts: Optional[InvokeOptions] = None) -> Output[RuleAppliersResult]
    func RuleAppliers(ctx *Context, args *RuleAppliersArgs, opts ...InvokeOption) (*RuleAppliersResult, error)
func RuleAppliersOutput(ctx *Context, args *RuleAppliersOutputArgs, opts ...InvokeOption) RuleAppliersResultOutput
    public static class RuleAppliers 
{
    public static Task<RuleAppliersResult> InvokeAsync(RuleAppliersArgs args, InvokeOptions? opts = null)
    public static Output<RuleAppliersResult> Invoke(RuleAppliersInvokeArgs args, InvokeOptions? opts = null)
}
    public static CompletableFuture<RuleAppliersResult> ruleAppliers(RuleAppliersArgs args, InvokeOptions options)
public static Output<RuleAppliersResult> ruleAppliers(RuleAppliersArgs args, InvokeOptions options)

    fn::invoke:
  function: volcengine:tls:RuleAppliers
  arguments:
    # arguments dictionary

    The following arguments are supported:

    RuleId string
    The rule id.
    OutputFile string
    File name where to save data source results.
    RuleId string
    The rule id.
    OutputFile string
    File name where to save data source results.
    ruleId String
    The rule id.
    outputFile String
    File name where to save data source results.
    ruleId string
    The rule id.
    outputFile string
    File name where to save data source results.
    rule_id str
    The rule id.
    output_file str
    File name where to save data source results.
    ruleId String
    The rule id.
    outputFile String
    File name where to save data source results.

    RuleAppliers Result

    The following output properties are available:

    HostGroupInfos List<RuleAppliersHostGroupInfo>
    The host group info list.
    Id string
    The provider-assigned unique ID for this managed resource.
    RuleId string
    TotalCount int
    The total count of query.
    OutputFile string
    HostGroupInfos []RuleAppliersHostGroupInfo
    The host group info list.
    Id string
    The provider-assigned unique ID for this managed resource.
    RuleId string
    TotalCount int
    The total count of query.
    OutputFile string
    hostGroupInfos List<RuleAppliersHostGroupInfo>
    The host group info list.
    id String
    The provider-assigned unique ID for this managed resource.
    ruleId String
    totalCount Integer
    The total count of query.
    outputFile String
    hostGroupInfos RuleAppliersHostGroupInfo[]
    The host group info list.
    id string
    The provider-assigned unique ID for this managed resource.
    ruleId string
    totalCount number
    The total count of query.
    outputFile string
    host_group_infos Sequence[RuleAppliersHostGroupInfo]
    The host group info list.
    id str
    The provider-assigned unique ID for this managed resource.
    rule_id str
    total_count int
    The total count of query.
    output_file str
    hostGroupInfos List<Property Map>
    The host group info list.
    id String
    The provider-assigned unique ID for this managed resource.
    ruleId String
    totalCount Number
    The total count of query.
    outputFile String

    Supporting Types

    RuleAppliersHostGroupInfo

    AutoUpdate bool
    Whether to auto update.
    CreateTime string
    The create time.
    HostCount int
    The host count.
    HostGroupId string
    The host group id.
    HostGroupName string
    The host group name.
    HostGroupType string
    The host group type.
    HostIdentifier string
    The host identifier.
    IamProjectName string
    The iam project name.
    ModifyTime string
    The modify time.
    RuleCount int
    The rule count.
    ServiceLogging bool
    Whether to service logging.
    UpdateEndTime string
    The update end time.
    UpdateStartTime string
    The update start time.
    AutoUpdate bool
    Whether to auto update.
    CreateTime string
    The create time.
    HostCount int
    The host count.
    HostGroupId string
    The host group id.
    HostGroupName string
    The host group name.
    HostGroupType string
    The host group type.
    HostIdentifier string
    The host identifier.
    IamProjectName string
    The iam project name.
    ModifyTime string
    The modify time.
    RuleCount int
    The rule count.
    ServiceLogging bool
    Whether to service logging.
    UpdateEndTime string
    The update end time.
    UpdateStartTime string
    The update start time.
    autoUpdate Boolean
    Whether to auto update.
    createTime String
    The create time.
    hostCount Integer
    The host count.
    hostGroupId String
    The host group id.
    hostGroupName String
    The host group name.
    hostGroupType String
    The host group type.
    hostIdentifier String
    The host identifier.
    iamProjectName String
    The iam project name.
    modifyTime String
    The modify time.
    ruleCount Integer
    The rule count.
    serviceLogging Boolean
    Whether to service logging.
    updateEndTime String
    The update end time.
    updateStartTime String
    The update start time.
    autoUpdate boolean
    Whether to auto update.
    createTime string
    The create time.
    hostCount number
    The host count.
    hostGroupId string
    The host group id.
    hostGroupName string
    The host group name.
    hostGroupType string
    The host group type.
    hostIdentifier string
    The host identifier.
    iamProjectName string
    The iam project name.
    modifyTime string
    The modify time.
    ruleCount number
    The rule count.
    serviceLogging boolean
    Whether to service logging.
    updateEndTime string
    The update end time.
    updateStartTime string
    The update start time.
    auto_update bool
    Whether to auto update.
    create_time str
    The create time.
    host_count int
    The host count.
    host_group_id str
    The host group id.
    host_group_name str
    The host group name.
    host_group_type str
    The host group type.
    host_identifier str
    The host identifier.
    iam_project_name str
    The iam project name.
    modify_time str
    The modify time.
    rule_count int
    The rule count.
    service_logging bool
    Whether to service logging.
    update_end_time str
    The update end time.
    update_start_time str
    The update start time.
    autoUpdate Boolean
    Whether to auto update.
    createTime String
    The create time.
    hostCount Number
    The host count.
    hostGroupId String
    The host group id.
    hostGroupName String
    The host group name.
    hostGroupType String
    The host group type.
    hostIdentifier String
    The host identifier.
    iamProjectName String
    The iam project name.
    modifyTime String
    The modify time.
    ruleCount Number
    The rule count.
    serviceLogging Boolean
    Whether to service logging.
    updateEndTime String
    The update end time.
    updateStartTime String
    The update start time.

    Package Details

    Repository
    volcengine volcengine/pulumi-volcengine
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the volcengine Terraform Provider.
    volcengine logo
    Volcengine v0.0.45 published on Tuesday, Feb 10, 2026 by Volcengine
    Schema (JSON)
    volcengine/pulumi-volcengine
      Meet Neo: Your AI Platform Teammate