1. Packages
  2. Volcengine
  3. API Docs
  4. kafka
  5. getSaslUsers
Volcengine v0.0.38 published on Friday, Oct 31, 2025 by Volcengine
Schema (JSON)
volcengine/pulumi-volcengine

volcengine.kafka.getSaslUsers

volcengine logo
Volcengine v0.0.38 published on Friday, Oct 31, 2025 by Volcengine
Schema (JSON)
volcengine/pulumi-volcengine

    Use this data source to query detailed information of kafka sasl users

    Example Usage

    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 fooInstance = new volcengine.kafka.Instance("fooInstance", {
    instanceName: "acc-test-kafka",
    instanceDescription: "tf-test",
    version: "2.2.2",
    computeSpec: "kafka.20xrate.hw",
    subnetId: fooSubnet.id,
    userName: "tf-user",
    userPassword: "tf-pass!@q1",
    chargeType: "PostPaid",
    storageSpace: 300,
    partitionNumber: 350,
    projectName: "default",
    tags: [{
        key: "k1",
        value: "v1",
    }],
    parameters: [
        {
            parameterName: "MessageMaxByte",
            parameterValue: "12",
        },
        {
            parameterName: "LogRetentionHours",
            parameterValue: "70",
        },
    ],
});
const fooSaslUser = new volcengine.kafka.SaslUser("fooSaslUser", {
    userName: "acc-test-user",
    instanceId: fooInstance.id,
    userPassword: "suqsnis123!",
    description: "tf-test",
    allAuthority: true,
    passwordType: "Scram",
});
const default = volcengine.kafka.getSaslUsersOutput({
    instanceId: fooInstance.id,
    userName: fooSaslUser.userName,
});

    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_instance = volcengine.kafka.Instance("fooInstance",
    instance_name="acc-test-kafka",
    instance_description="tf-test",
    version="2.2.2",
    compute_spec="kafka.20xrate.hw",
    subnet_id=foo_subnet.id,
    user_name="tf-user",
    user_password="tf-pass!@q1",
    charge_type="PostPaid",
    storage_space=300,
    partition_number=350,
    project_name="default",
    tags=[volcengine.kafka.InstanceTagArgs(
        key="k1",
        value="v1",
    )],
    parameters=[
        volcengine.kafka.InstanceParameterArgs(
            parameter_name="MessageMaxByte",
            parameter_value="12",
        ),
        volcengine.kafka.InstanceParameterArgs(
            parameter_name="LogRetentionHours",
            parameter_value="70",
        ),
    ])
foo_sasl_user = volcengine.kafka.SaslUser("fooSaslUser",
    user_name="acc-test-user",
    instance_id=foo_instance.id,
    user_password="suqsnis123!",
    description="tf-test",
    all_authority=True,
    password_type="Scram")
default = volcengine.kafka.get_sasl_users_output(instance_id=foo_instance.id,
    user_name=foo_sasl_user.user_name)

    package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/ecs"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/kafka"
	"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
		}
		fooInstance, err := kafka.NewInstance(ctx, "fooInstance", &kafka.InstanceArgs{
			InstanceName:        pulumi.String("acc-test-kafka"),
			InstanceDescription: pulumi.String("tf-test"),
			Version:             pulumi.String("2.2.2"),
			ComputeSpec:         pulumi.String("kafka.20xrate.hw"),
			SubnetId:            fooSubnet.ID(),
			UserName:            pulumi.String("tf-user"),
			UserPassword:        pulumi.String("tf-pass!@q1"),
			ChargeType:          pulumi.String("PostPaid"),
			StorageSpace:        pulumi.Int(300),
			PartitionNumber:     pulumi.Int(350),
			ProjectName:         pulumi.String("default"),
			Tags: kafka.InstanceTagArray{
				&kafka.InstanceTagArgs{
					Key:   pulumi.String("k1"),
					Value: pulumi.String("v1"),
				},
			},
			Parameters: kafka.InstanceParameterArray{
				&kafka.InstanceParameterArgs{
					ParameterName:  pulumi.String("MessageMaxByte"),
					ParameterValue: pulumi.String("12"),
				},
				&kafka.InstanceParameterArgs{
					ParameterName:  pulumi.String("LogRetentionHours"),
					ParameterValue: pulumi.String("70"),
				},
			},
		})
		if err != nil {
			return err
		}
		fooSaslUser, err := kafka.NewSaslUser(ctx, "fooSaslUser", &kafka.SaslUserArgs{
			UserName:     pulumi.String("acc-test-user"),
			InstanceId:   fooInstance.ID(),
			UserPassword: pulumi.String("suqsnis123!"),
			Description:  pulumi.String("tf-test"),
			AllAuthority: pulumi.Bool(true),
			PasswordType: pulumi.String("Scram"),
		})
		if err != nil {
			return err
		}
		_ = kafka.GetSaslUsersOutput(ctx, kafka.GetSaslUsersOutputArgs{
			InstanceId: fooInstance.ID(),
			UserName:   fooSaslUser.UserName,
		}, nil)
		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 fooInstance = new Volcengine.Kafka.Instance("fooInstance", new()
    {
        InstanceName = "acc-test-kafka",
        InstanceDescription = "tf-test",
        Version = "2.2.2",
        ComputeSpec = "kafka.20xrate.hw",
        SubnetId = fooSubnet.Id,
        UserName = "tf-user",
        UserPassword = "tf-pass!@q1",
        ChargeType = "PostPaid",
        StorageSpace = 300,
        PartitionNumber = 350,
        ProjectName = "default",
        Tags = new[]
        {
            new Volcengine.Kafka.Inputs.InstanceTagArgs
            {
                Key = "k1",
                Value = "v1",
            },
        },
        Parameters = new[]
        {
            new Volcengine.Kafka.Inputs.InstanceParameterArgs
            {
                ParameterName = "MessageMaxByte",
                ParameterValue = "12",
            },
            new Volcengine.Kafka.Inputs.InstanceParameterArgs
            {
                ParameterName = "LogRetentionHours",
                ParameterValue = "70",
            },
        },
    });

    var fooSaslUser = new Volcengine.Kafka.SaslUser("fooSaslUser", new()
    {
        UserName = "acc-test-user",
        InstanceId = fooInstance.Id,
        UserPassword = "suqsnis123!",
        Description = "tf-test",
        AllAuthority = true,
        PasswordType = "Scram",
    });

    var @default = Volcengine.Kafka.GetSaslUsers.Invoke(new()
    {
        InstanceId = fooInstance.Id,
        UserName = fooSaslUser.UserName,
    });

});

    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.kafka.Instance;
import com.pulumi.volcengine.kafka.InstanceArgs;
import com.pulumi.volcengine.kafka.inputs.InstanceTagArgs;
import com.pulumi.volcengine.kafka.inputs.InstanceParameterArgs;
import com.pulumi.volcengine.kafka.SaslUser;
import com.pulumi.volcengine.kafka.SaslUserArgs;
import com.pulumi.volcengine.kafka.KafkaFunctions;
import com.pulumi.volcengine.kafka.inputs.GetSaslUsersArgs;
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 fooInstance = new Instance("fooInstance", InstanceArgs.builder()        
            .instanceName("acc-test-kafka")
            .instanceDescription("tf-test")
            .version("2.2.2")
            .computeSpec("kafka.20xrate.hw")
            .subnetId(fooSubnet.id())
            .userName("tf-user")
            .userPassword("tf-pass!@q1")
            .chargeType("PostPaid")
            .storageSpace(300)
            .partitionNumber(350)
            .projectName("default")
            .tags(InstanceTagArgs.builder()
                .key("k1")
                .value("v1")
                .build())
            .parameters(            
                InstanceParameterArgs.builder()
                    .parameterName("MessageMaxByte")
                    .parameterValue("12")
                    .build(),
                InstanceParameterArgs.builder()
                    .parameterName("LogRetentionHours")
                    .parameterValue("70")
                    .build())
            .build());

        var fooSaslUser = new SaslUser("fooSaslUser", SaslUserArgs.builder()        
            .userName("acc-test-user")
            .instanceId(fooInstance.id())
            .userPassword("suqsnis123!")
            .description("tf-test")
            .allAuthority(true)
            .passwordType("Scram")
            .build());

        final var default = KafkaFunctions.getSaslUsers(GetSaslUsersArgs.builder()
            .instanceId(fooInstance.id())
            .userName(fooSaslUser.userName())
            .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}
  fooInstance:
    type: volcengine:kafka:Instance
    properties:
      instanceName: acc-test-kafka
      instanceDescription: tf-test
      version: 2.2.2
      computeSpec: kafka.20xrate.hw
      subnetId: ${fooSubnet.id}
      userName: tf-user
      userPassword: tf-pass!@q1
      chargeType: PostPaid
      storageSpace: 300
      partitionNumber: 350
      projectName: default
      tags:
        - key: k1
          value: v1
      parameters:
        - parameterName: MessageMaxByte
          parameterValue: '12'
        - parameterName: LogRetentionHours
          parameterValue: '70'
  fooSaslUser:
    type: volcengine:kafka:SaslUser
    properties:
      userName: acc-test-user
      instanceId: ${fooInstance.id}
      userPassword: suqsnis123!
      description: tf-test
      allAuthority: true
      passwordType: Scram
variables:
  fooZones:
    fn::invoke:
      Function: volcengine:ecs:getZones
      Arguments: {}
  default:
    fn::invoke:
      Function: volcengine:kafka:getSaslUsers
      Arguments:
        instanceId: ${fooInstance.id}
        userName: ${fooSaslUser.userName}

    Using getSaslUsers

    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 getSaslUsers(args: GetSaslUsersArgs, opts?: InvokeOptions): Promise<GetSaslUsersResult>
function getSaslUsersOutput(args: GetSaslUsersOutputArgs, opts?: InvokeOptions): Output<GetSaslUsersResult>
    def get_sasl_users(instance_id: Optional[str] = None,
                   output_file: Optional[str] = None,
                   user_name: Optional[str] = None,
                   opts: Optional[InvokeOptions] = None) -> GetSaslUsersResult
def get_sasl_users_output(instance_id: Optional[pulumi.Input[str]] = None,
                   output_file: Optional[pulumi.Input[str]] = None,
                   user_name: Optional[pulumi.Input[str]] = None,
                   opts: Optional[InvokeOptions] = None) -> Output[GetSaslUsersResult]
    func GetSaslUsers(ctx *Context, args *GetSaslUsersArgs, opts ...InvokeOption) (*GetSaslUsersResult, error)
func GetSaslUsersOutput(ctx *Context, args *GetSaslUsersOutputArgs, opts ...InvokeOption) GetSaslUsersResultOutput

    > Note: This function is named GetSaslUsers in the Go SDK.

    public static class GetSaslUsers 
{
    public static Task<GetSaslUsersResult> InvokeAsync(GetSaslUsersArgs args, InvokeOptions? opts = null)
    public static Output<GetSaslUsersResult> Invoke(GetSaslUsersInvokeArgs args, InvokeOptions? opts = null)
}
    public static CompletableFuture<GetSaslUsersResult> getSaslUsers(GetSaslUsersArgs args, InvokeOptions options)
public static Output<GetSaslUsersResult> getSaslUsers(GetSaslUsersArgs args, InvokeOptions options)

    fn::invoke:
  function: volcengine:kafka/getSaslUsers:getSaslUsers
  arguments:
    # arguments dictionary

    The following arguments are supported:

    InstanceId string
    The id of instance.
    OutputFile string
    File name where to save data source results.
    UserName string
    The user name, support fuzzy matching.
    InstanceId string
    The id of instance.
    OutputFile string
    File name where to save data source results.
    UserName string
    The user name, support fuzzy matching.
    instanceId String
    The id of instance.
    outputFile String
    File name where to save data source results.
    userName String
    The user name, support fuzzy matching.
    instanceId string
    The id of instance.
    outputFile string
    File name where to save data source results.
    userName string
    The user name, support fuzzy matching.
    instance_id str
    The id of instance.
    output_file str
    File name where to save data source results.
    user_name str
    The user name, support fuzzy matching.
    instanceId String
    The id of instance.
    outputFile String
    File name where to save data source results.
    userName String
    The user name, support fuzzy matching.

    getSaslUsers Result

    The following output properties are available:

    Id string
    The provider-assigned unique ID for this managed resource.
    InstanceId string
    TotalCount int
    The total count of query.
    Users List<GetSaslUsersUser>
    The collection of query.
    OutputFile string
    UserName string
    The name of user.
    Id string
    The provider-assigned unique ID for this managed resource.
    InstanceId string
    TotalCount int
    The total count of query.
    Users []GetSaslUsersUser
    The collection of query.
    OutputFile string
    UserName string
    The name of user.
    id String
    The provider-assigned unique ID for this managed resource.
    instanceId String
    totalCount Integer
    The total count of query.
    users List<GetSaslUsersUser>
    The collection of query.
    outputFile String
    userName String
    The name of user.
    id string
    The provider-assigned unique ID for this managed resource.
    instanceId string
    totalCount number
    The total count of query.
    users GetSaslUsersUser[]
    The collection of query.
    outputFile string
    userName string
    The name of user.
    id str
    The provider-assigned unique ID for this managed resource.
    instance_id str
    total_count int
    The total count of query.
    users Sequence[GetSaslUsersUser]
    The collection of query.
    output_file str
    user_name str
    The name of user.
    id String
    The provider-assigned unique ID for this managed resource.
    instanceId String
    totalCount Number
    The total count of query.
    users List<Property Map>
    The collection of query.
    outputFile String
    userName String
    The name of user.

    Supporting Types

    GetSaslUsersUser

    AllAuthority bool
    Whether this user has read and write permissions for all topics.
    CreateTime string
    The create time.
    Description string
    The description of user.
    PasswordType string
    The type of password.
    UserName string
    The user name, support fuzzy matching.
    AllAuthority bool
    Whether this user has read and write permissions for all topics.
    CreateTime string
    The create time.
    Description string
    The description of user.
    PasswordType string
    The type of password.
    UserName string
    The user name, support fuzzy matching.
    allAuthority Boolean
    Whether this user has read and write permissions for all topics.
    createTime String
    The create time.
    description String
    The description of user.
    passwordType String
    The type of password.
    userName String
    The user name, support fuzzy matching.
    allAuthority boolean
    Whether this user has read and write permissions for all topics.
    createTime string
    The create time.
    description string
    The description of user.
    passwordType string
    The type of password.
    userName string
    The user name, support fuzzy matching.
    all_authority bool
    Whether this user has read and write permissions for all topics.
    create_time str
    The create time.
    description str
    The description of user.
    password_type str
    The type of password.
    user_name str
    The user name, support fuzzy matching.
    allAuthority Boolean
    Whether this user has read and write permissions for all topics.
    createTime String
    The create time.
    description String
    The description of user.
    passwordType String
    The type of password.
    userName String
    The user name, support fuzzy matching.

    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.38 published on Friday, Oct 31, 2025 by Volcengine
    Schema (JSON)
    volcengine/pulumi-volcengine
      Meet Neo: Your AI Platform Teammate