volcengine.kafka.ConsumedPartitions

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 fooGroup = new Volcengine.Kafka.Group("fooGroup", new()
    {
        InstanceId = fooInstance.Id,
        GroupId = "acc-test-group",
        Description = "tf-test",
    });

    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 fooTopic = new Volcengine.Kafka.Topic("fooTopic", new()
    {
        TopicName = "acc-test-topic",
        InstanceId = fooInstance.Id,
        Description = "tf-test",
        PartitionNumber = 15,
        ReplicaNumber = 3,
        Parameters = new Volcengine.Kafka.Inputs.TopicParametersArgs
        {
            MinInsyncReplicaNumber = 2,
            MessageMaxByte = 10,
            LogRetentionHours = 96,
        },
        AllAuthority = false,
        AccessPolicies = new[]
        {
            new Volcengine.Kafka.Inputs.TopicAccessPolicyArgs
            {
                UserName = fooSaslUser.UserName,
                AccessPolicy = "Pub",
            },
        },
    });

    var @default = Volcengine.Kafka.ConsumedPartitions.Invoke(new()
    {
        InstanceId = fooInstance.Id,
        GroupId = fooGroup.GroupId,
        TopicName = fooTopic.TopicName,
    });

});

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
		}
		fooGroup, err := kafka.NewGroup(ctx, "fooGroup", &kafka.GroupArgs{
			InstanceId:  fooInstance.ID(),
			GroupId:     pulumi.String("acc-test-group"),
			Description: pulumi.String("tf-test"),
		})
		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
		}
		fooTopic, err := kafka.NewTopic(ctx, "fooTopic", &kafka.TopicArgs{
			TopicName:       pulumi.String("acc-test-topic"),
			InstanceId:      fooInstance.ID(),
			Description:     pulumi.String("tf-test"),
			PartitionNumber: pulumi.Int(15),
			ReplicaNumber:   pulumi.Int(3),
			Parameters: &kafka.TopicParametersArgs{
				MinInsyncReplicaNumber: pulumi.Int(2),
				MessageMaxByte:         pulumi.Int(10),
				LogRetentionHours:      pulumi.Int(96),
			},
			AllAuthority: pulumi.Bool(false),
			AccessPolicies: kafka.TopicAccessPolicyArray{
				&kafka.TopicAccessPolicyArgs{
					UserName:     fooSaslUser.UserName,
					AccessPolicy: pulumi.String("Pub"),
				},
			},
		})
		if err != nil {
			return err
		}
		_ = kafka.ConsumedPartitionsOutput(ctx, kafka.ConsumedPartitionsOutputArgs{
			InstanceId: fooInstance.ID(),
			GroupId:    fooGroup.GroupId,
			TopicName:  fooTopic.TopicName,
		}, 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.Group;
import com.pulumi.volcengine.kafka.GroupArgs;
import com.pulumi.volcengine.kafka.SaslUser;
import com.pulumi.volcengine.kafka.SaslUserArgs;
import com.pulumi.volcengine.kafka.Topic;
import com.pulumi.volcengine.kafka.TopicArgs;
import com.pulumi.volcengine.kafka.inputs.TopicParametersArgs;
import com.pulumi.volcengine.kafka.inputs.TopicAccessPolicyArgs;
import com.pulumi.volcengine.kafka.KafkaFunctions;
import com.pulumi.volcengine.kafka.inputs.ConsumedPartitionsArgs;
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 fooGroup = new Group("fooGroup", GroupArgs.builder()        
            .instanceId(fooInstance.id())
            .groupId("acc-test-group")
            .description("tf-test")
            .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());

        var fooTopic = new Topic("fooTopic", TopicArgs.builder()        
            .topicName("acc-test-topic")
            .instanceId(fooInstance.id())
            .description("tf-test")
            .partitionNumber(15)
            .replicaNumber(3)
            .parameters(TopicParametersArgs.builder()
                .minInsyncReplicaNumber(2)
                .messageMaxByte(10)
                .logRetentionHours(96)
                .build())
            .allAuthority(false)
            .accessPolicies(TopicAccessPolicyArgs.builder()
                .userName(fooSaslUser.userName())
                .accessPolicy("Pub")
                .build())
            .build());

        final var default = KafkaFunctions.ConsumedPartitions(ConsumedPartitionsArgs.builder()
            .instanceId(fooInstance.id())
            .groupId(fooGroup.groupId())
            .topicName(fooTopic.topicName())
            .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_group = volcengine.kafka.Group("fooGroup",
    instance_id=foo_instance.id,
    group_id="acc-test-group",
    description="tf-test")
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")
foo_topic = volcengine.kafka.Topic("fooTopic",
    topic_name="acc-test-topic",
    instance_id=foo_instance.id,
    description="tf-test",
    partition_number=15,
    replica_number=3,
    parameters=volcengine.kafka.TopicParametersArgs(
        min_insync_replica_number=2,
        message_max_byte=10,
        log_retention_hours=96,
    ),
    all_authority=False,
    access_policies=[volcengine.kafka.TopicAccessPolicyArgs(
        user_name=foo_sasl_user.user_name,
        access_policy="Pub",
    )])
default = volcengine.kafka.consumed_partitions_output(instance_id=foo_instance.id,
    group_id=foo_group.group_id,
    topic_name=foo_topic.topic_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 fooGroup = new volcengine.kafka.Group("fooGroup", {
    instanceId: fooInstance.id,
    groupId: "acc-test-group",
    description: "tf-test",
});
const fooSaslUser = new volcengine.kafka.SaslUser("fooSaslUser", {
    userName: "acc-test-user",
    instanceId: fooInstance.id,
    userPassword: "suqsnis123!",
    description: "tf-test",
    allAuthority: true,
    passwordType: "Scram",
});
const fooTopic = new volcengine.kafka.Topic("fooTopic", {
    topicName: "acc-test-topic",
    instanceId: fooInstance.id,
    description: "tf-test",
    partitionNumber: 15,
    replicaNumber: 3,
    parameters: {
        minInsyncReplicaNumber: 2,
        messageMaxByte: 10,
        logRetentionHours: 96,
    },
    allAuthority: false,
    accessPolicies: [{
        userName: fooSaslUser.userName,
        accessPolicy: "Pub",
    }],
});
const default = volcengine.kafka.ConsumedPartitionsOutput({
    instanceId: fooInstance.id,
    groupId: fooGroup.groupId,
    topicName: fooTopic.topicName,
});

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'
  fooGroup:
    type: volcengine:kafka:Group
    properties:
      instanceId: ${fooInstance.id}
      groupId: acc-test-group
      description: tf-test
  fooSaslUser:
    type: volcengine:kafka:SaslUser
    properties:
      userName: acc-test-user
      instanceId: ${fooInstance.id}
      userPassword: suqsnis123!
      description: tf-test
      allAuthority: true
      passwordType: Scram
  fooTopic:
    type: volcengine:kafka:Topic
    properties:
      topicName: acc-test-topic
      instanceId: ${fooInstance.id}
      description: tf-test
      partitionNumber: 15
      replicaNumber: 3
      parameters:
        minInsyncReplicaNumber: 2
        messageMaxByte: 10
        logRetentionHours: 96
      allAuthority: false
      accessPolicies:
        - userName: ${fooSaslUser.userName}
          accessPolicy: Pub
variables:
  fooZones:
    fn::invoke:
      Function: volcengine:ecs:Zones
      Arguments: {}
  default:
    fn::invoke:
      Function: volcengine:kafka:ConsumedPartitions
      Arguments:
        instanceId: ${fooInstance.id}
        groupId: ${fooGroup.groupId}
        topicName: ${fooTopic.topicName}