Docs Home Pulumi IaC Pulumi ESC Pulumi Cloud Packages Tutorials
  1. Packages
  2. Volcengine
  3. API Docs
  4. kafka
  5. SaslUsers
Volcengine v0.0.26 published on Friday, Sep 13, 2024 by Volcengine
volcengine/pulumi-volcengine

volcengine.kafka.SaslUsers

Explore with Pulumi AI

volcengine logo
Volcengine v0.0.26 published on Friday, Sep 13, 2024 by Volcengine
volcengine/pulumi-volcengine

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

    Example Usage

    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,
    });

});

    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
	})
}

    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());

    }
}

    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)

    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,
});

    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}

    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>
    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]
    func SaslUsers(ctx *Context, args *SaslUsersArgs, opts ...InvokeOption) (*SaslUsersResult, error)
func SaslUsersOutput(ctx *Context, args *SaslUsersOutputArgs, opts ...InvokeOption) SaslUsersResultOutput
    public static class SaslUsers 
{
    public static Task<SaslUsersResult> InvokeAsync(SaslUsersArgs args, InvokeOptions? opts = null)
    public static Output<SaslUsersResult> Invoke(SaslUsersInvokeArgs args, InvokeOptions? opts = null)
}
    public static CompletableFuture<SaslUsersResult> saslUsers(SaslUsersArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

    fn::invoke:
  function: volcengine:kafka:SaslUsers
  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.

    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 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.26 published on Friday, Sep 13, 2024 by Volcengine
    volcengine/pulumi-volcengine