Docs Home Pulumi IaC Pulumi ESC Pulumi Insights Pulumi Cloud Packages Tutorials
  1. Packages
  2. Volcengine
  3. API Docs
  4. kafka
  5. SaslUsers
Volcengine v0.0.27 published on Tuesday, Dec 10, 2024 by Volcengine
volcengine/pulumi-volcengine

volcengine.kafka.SaslUsers

Explore with Pulumi AI

Volcengine v0.0.27 published on Tuesday, Dec 10, 2024 by Volcengine
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.Zones({});
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.SaslUsersOutput({
    instanceId: fooInstance.id,
    userName: fooSaslUser.userName,
});
Copy
import pulumi
import pulumi_volcengine as volcengine

foo_zones = volcengine.ecs.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.sasl_users_output(instance_id=foo_instance.id,
    user_name=foo_sasl_user.user_name)
Copy
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.Zones(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.SaslUsersOutput(ctx, kafka.SaslUsersOutputArgs{
			InstanceId: fooInstance.ID(),
			UserName:   fooSaslUser.UserName,
		}, nil)
		return nil
	})
}
Copy
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Volcengine = Pulumi.Volcengine;

return await Deployment.RunAsync(() => 
{
    var fooZones = Volcengine.Ecs.Zones.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(zonesResult => zonesResult.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.SaslUsers.Invoke(new()
    {
        InstanceId = fooInstance.Id,
        UserName = fooSaslUser.UserName,
    });

});
Copy
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.ZonesArgs;
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.SaslUsersArgs;
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.Zones();

        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(zonesResult -> zonesResult.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.SaslUsers(SaslUsersArgs.builder()
            .instanceId(fooInstance.id())
            .userName(fooSaslUser.userName())
            .build());

    }
}
Copy
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:Zones
      Arguments: {}
  default:
    fn::invoke:
      Function: volcengine:kafka:SaslUsers
      Arguments:
        instanceId: ${fooInstance.id}
        userName: ${fooSaslUser.userName}
Copy

Using SaslUsers

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 saslUsers(args: SaslUsersArgs, opts?: InvokeOptions): Promise<SaslUsersResult>
function saslUsersOutput(args: SaslUsersOutputArgs, opts?: InvokeOptions): Output<SaslUsersResult>
Copy
def sasl_users(instance_id: Optional[str] = None,
               output_file: Optional[str] = None,
               user_name: Optional[str] = None,
               opts: Optional[InvokeOptions] = None) -> SaslUsersResult
def 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[SaslUsersResult]
Copy
func SaslUsers(ctx *Context, args *SaslUsersArgs, opts ...InvokeOption) (*SaslUsersResult, error)
func SaslUsersOutput(ctx *Context, args *SaslUsersOutputArgs, opts ...InvokeOption) SaslUsersResultOutput
Copy
public static class SaslUsers 
{
    public static Task<SaslUsersResult> InvokeAsync(SaslUsersArgs args, InvokeOptions? opts = null)
    public static Output<SaslUsersResult> Invoke(SaslUsersInvokeArgs args, InvokeOptions? opts = null)
}
Copy
public static CompletableFuture<SaslUsersResult> saslUsers(SaslUsersArgs args, InvokeOptions options)
public static Output<SaslUsersResult> saslUsers(SaslUsersArgs args, InvokeOptions options)
Copy
fn::invoke:
  function: volcengine:kafka:SaslUsers
  arguments:
    # arguments dictionary
Copy

The following arguments are supported:

InstanceId This property is required. string
The id of instance.
OutputFile string
File name where to save data source results.
UserName string
The user name, support fuzzy matching.
InstanceId This property is required. string
The id of instance.
OutputFile string
File name where to save data source results.
UserName string
The user name, support fuzzy matching.
instanceId This property is required. String
The id of instance.
outputFile String
File name where to save data source results.
userName String
The user name, support fuzzy matching.
instanceId This property is required. 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 This property is required. 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 This property is required. String
The id of instance.
outputFile String
File name where to save data source results.
userName String
The user name, support fuzzy matching.

SaslUsers 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<SaslUsersUser>
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 []SaslUsersUser
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<SaslUsersUser>
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 SaslUsersUser[]
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[SaslUsersUser]
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

SaslUsersUser

AllAuthority This property is required. bool
Whether this user has read and write permissions for all topics.
CreateTime This property is required. string
The create time.
Description This property is required. string
The description of user.
PasswordType This property is required. string
The type of password.
UserName This property is required. string
The user name, support fuzzy matching.
AllAuthority This property is required. bool
Whether this user has read and write permissions for all topics.
CreateTime This property is required. string
The create time.
Description This property is required. string
The description of user.
PasswordType This property is required. string
The type of password.
UserName This property is required. string
The user name, support fuzzy matching.
allAuthority This property is required. Boolean
Whether this user has read and write permissions for all topics.
createTime This property is required. String
The create time.
description This property is required. String
The description of user.
passwordType This property is required. String
The type of password.
userName This property is required. String
The user name, support fuzzy matching.
allAuthority This property is required. boolean
Whether this user has read and write permissions for all topics.
createTime This property is required. string
The create time.
description This property is required. string
The description of user.
passwordType This property is required. string
The type of password.
userName This property is required. string
The user name, support fuzzy matching.
all_authority This property is required. bool
Whether this user has read and write permissions for all topics.
create_time This property is required. str
The create time.
description This property is required. str
The description of user.
password_type This property is required. str
The type of password.
user_name This property is required. str
The user name, support fuzzy matching.
allAuthority This property is required. Boolean
Whether this user has read and write permissions for all topics.
createTime This property is required. String
The create time.
description This property is required. String
The description of user.
passwordType This property is required. String
The type of password.
userName This property is required. 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 v0.0.27 published on Tuesday, Dec 10, 2024 by Volcengine
volcengine/pulumi-volcengine