pulumi-digitalocean-kotlin/com.pulumi.digitalocean.kotlin/DatabaseKafkaTopic

DatabaseKafkaTopic

class DatabaseKafkaTopic : KotlinCustomResource

Provides a DigitalOcean Kafka topic for Kafka clusters.

Example Usage

Create a new Kafka topic

import * as pulumi from "@pulumi/pulumi";
import * as digitalocean from "@pulumi/digitalocean";
const kafka_example = new digitalocean.DatabaseCluster("kafka-example", {
    name: "example-kafka-cluster",
    engine: "kafka",
    version: "3.5",
    size: "db-s-2vcpu-2gb",
    region: digitalocean.Region.NYC1,
    nodeCount: 3,
    tags: ["production"],
});
const topic_01 = new digitalocean.DatabaseKafkaTopic("topic-01", {
    clusterId: kafka_example.id,
    name: "topic-01",
    partitionCount: 3,
    replicationFactor: 2,
    configs: [{
        cleanupPolicy: "compact",
        compressionType: "uncompressed",
        deleteRetentionMs: "14000",
        fileDeleteDelayMs: "170000",
        flushMessages: "92233",
        flushMs: "92233720368",
        indexIntervalBytes: "40962",
        maxCompactionLagMs: "9223372036854775807",
        maxMessageBytes: "1048588",
        messageDownConversionEnable: true,
        messageFormatVersion: "3.0-IV1",
        messageTimestampDifferenceMaxMs: "9223372036854775807",
        messageTimestampType: "log_append_time",
        minCleanableDirtyRatio: 0.5,
        minCompactionLagMs: "20000",
        minInsyncReplicas: 2,
        preallocate: false,
        retentionBytes: "-1",
        retentionMs: "-1",
        segmentBytes: "209715200",
        segmentIndexBytes: "10485760",
        segmentJitterMs: "0",
        segmentMs: "604800000",
    }],
});
Content copied to clipboard
import pulumi
import pulumi_digitalocean as digitalocean
kafka_example = digitalocean.DatabaseCluster("kafka-example",
    name="example-kafka-cluster",
    engine="kafka",
    version="3.5",
    size="db-s-2vcpu-2gb",
    region=digitalocean.Region.NYC1,
    node_count=3,
    tags=["production"])
topic_01 = digitalocean.DatabaseKafkaTopic("topic-01",
    cluster_id=kafka_example.id,
    name="topic-01",
    partition_count=3,
    replication_factor=2,
    configs=[digitalocean.DatabaseKafkaTopicConfigArgs(
        cleanup_policy="compact",
        compression_type="uncompressed",
        delete_retention_ms="14000",
        file_delete_delay_ms="170000",
        flush_messages="92233",
        flush_ms="92233720368",
        index_interval_bytes="40962",
        max_compaction_lag_ms="9223372036854775807",
        max_message_bytes="1048588",
        message_down_conversion_enable=True,
        message_format_version="3.0-IV1",
        message_timestamp_difference_max_ms="9223372036854775807",
        message_timestamp_type="log_append_time",
        min_cleanable_dirty_ratio=0.5,
        min_compaction_lag_ms="20000",
        min_insync_replicas=2,
        preallocate=False,
        retention_bytes="-1",
        retention_ms="-1",
        segment_bytes="209715200",
        segment_index_bytes="10485760",
        segment_jitter_ms="0",
        segment_ms="604800000",
    )])
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using DigitalOcean = Pulumi.DigitalOcean;
return await Deployment.RunAsync(() =>
{
    var kafka_example = new DigitalOcean.DatabaseCluster("kafka-example", new()
    {
        Name = "example-kafka-cluster",
        Engine = "kafka",
        Version = "3.5",
        Size = "db-s-2vcpu-2gb",
        Region = DigitalOcean.Region.NYC1,
        NodeCount = 3,
        Tags = new[]
        {
            "production",
        },
    });
    var topic_01 = new DigitalOcean.DatabaseKafkaTopic("topic-01", new()
    {
        ClusterId = kafka_example.Id,
        Name = "topic-01",
        PartitionCount = 3,
        ReplicationFactor = 2,
        Configs = new[]
        {
            new DigitalOcean.Inputs.DatabaseKafkaTopicConfigArgs
            {
                CleanupPolicy = "compact",
                CompressionType = "uncompressed",
                DeleteRetentionMs = "14000",
                FileDeleteDelayMs = "170000",
                FlushMessages = "92233",
                FlushMs = "92233720368",
                IndexIntervalBytes = "40962",
                MaxCompactionLagMs = "9223372036854775807",
                MaxMessageBytes = "1048588",
                MessageDownConversionEnable = true,
                MessageFormatVersion = "3.0-IV1",
                MessageTimestampDifferenceMaxMs = "9223372036854775807",
                MessageTimestampType = "log_append_time",
                MinCleanableDirtyRatio = 0.5,
                MinCompactionLagMs = "20000",
                MinInsyncReplicas = 2,
                Preallocate = false,
                RetentionBytes = "-1",
                RetentionMs = "-1",
                SegmentBytes = "209715200",
                SegmentIndexBytes = "10485760",
                SegmentJitterMs = "0",
                SegmentMs = "604800000",
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-digitalocean/sdk/v4/go/digitalocean"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := digitalocean.NewDatabaseCluster(ctx, "kafka-example", &digitalocean.DatabaseClusterArgs{
			Name:      pulumi.String("example-kafka-cluster"),
			Engine:    pulumi.String("kafka"),
			Version:   pulumi.String("3.5"),
			Size:      pulumi.String("db-s-2vcpu-2gb"),
			Region:    pulumi.String(digitalocean.RegionNYC1),
			NodeCount: pulumi.Int(3),
			Tags: pulumi.StringArray{
				pulumi.String("production"),
			},
		})
		if err != nil {
			return err
		}
		_, err = digitalocean.NewDatabaseKafkaTopic(ctx, "topic-01", &digitalocean.DatabaseKafkaTopicArgs{
			ClusterId:         kafka_example.ID(),
			Name:              pulumi.String("topic-01"),
			PartitionCount:    pulumi.Int(3),
			ReplicationFactor: pulumi.Int(2),
			Configs: digitalocean.DatabaseKafkaTopicConfigArray{
				&digitalocean.DatabaseKafkaTopicConfigArgs{
					CleanupPolicy:                   pulumi.String("compact"),
					CompressionType:                 pulumi.String("uncompressed"),
					DeleteRetentionMs:               pulumi.String("14000"),
					FileDeleteDelayMs:               pulumi.String("170000"),
					FlushMessages:                   pulumi.String("92233"),
					FlushMs:                         pulumi.String("92233720368"),
					IndexIntervalBytes:              pulumi.String("40962"),
					MaxCompactionLagMs:              pulumi.String("9223372036854775807"),
					MaxMessageBytes:                 pulumi.String("1048588"),
					MessageDownConversionEnable:     pulumi.Bool(true),
					MessageFormatVersion:            pulumi.String("3.0-IV1"),
					MessageTimestampDifferenceMaxMs: pulumi.String("9223372036854775807"),
					MessageTimestampType:            pulumi.String("log_append_time"),
					MinCleanableDirtyRatio:          pulumi.Float64(0.5),
					MinCompactionLagMs:              pulumi.String("20000"),
					MinInsyncReplicas:               pulumi.Int(2),
					Preallocate:                     pulumi.Bool(false),
					RetentionBytes:                  pulumi.String("-1"),
					RetentionMs:                     pulumi.String("-1"),
					SegmentBytes:                    pulumi.String("209715200"),
					SegmentIndexBytes:               pulumi.String("10485760"),
					SegmentJitterMs:                 pulumi.String("0"),
					SegmentMs:                       pulumi.String("604800000"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
resources:
  topic-01:
    type: digitalocean:DatabaseKafkaTopic
    properties:
      clusterId: ${["kafka-example"].id}
      name: topic-01
      partitionCount: 3
      replicationFactor: 2
      configs:
        - cleanupPolicy: compact
          compressionType: uncompressed
          deleteRetentionMs: 14000
          fileDeleteDelayMs: 170000
          flushMessages: 92233
          flushMs: 9.2233720368e+10
          indexIntervalBytes: 40962
          maxCompactionLagMs: 9.223372036854776e+18
          maxMessageBytes: 1.048588e+06
          messageDownConversionEnable: true
          messageFormatVersion: 3.0-IV1
          messageTimestampDifferenceMaxMs: 9.223372036854776e+18
          messageTimestampType: log_append_time
          minCleanableDirtyRatio: 0.5
          minCompactionLagMs: 20000
          minInsyncReplicas: 2
          preallocate: false
          retentionBytes: -1
          retentionMs: -1
          segmentBytes: 2.097152e+08
          segmentIndexBytes: 1.048576e+07
          segmentJitterMs: 0
          segmentMs: 6.048e+08
  kafka-example:
    type: digitalocean:DatabaseCluster
    properties:
      name: example-kafka-cluster
      engine: kafka
      version: '3.5'
      size: db-s-2vcpu-2gb
      region: nyc1
      nodeCount: 3
      tags:
        - production
Content copied to clipboard

Import

Topics can be imported using the id of the source cluster and the name of the topic joined with a comma. For example:

$ pulumi import digitalocean:index/databaseKafkaTopic:DatabaseKafkaTopic topic-01 245bcfd0-7f31-4ce6-a2bc-475a116cca97,topic-01
Content copied to clipboard

Properties

Link copied to clipboard
val clusterId: Output<String>

The ID of the source database cluster. Note: This must be a Kafka cluster.

Link copied to clipboard
val configs: Output<List<DatabaseKafkaTopicConfig>>

A set of advanced configuration parameters. Defaults will be set for any of the parameters that are not included. The config block is documented below.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val name: Output<String>

The name for the topic.

Link copied to clipboard
val partitionCount: Output<Int>?

The number of partitions for the topic. Default and minimum set at 3, maximum is 2048.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val replicationFactor: Output<Int>?

The number of nodes that topics are replicated across. Default and minimum set at 2, maximum is the number of nodes in the cluster.

Link copied to clipboard
val state: Output<String>

The current status of the topic. Possible values are 'active', 'configuring', and 'deleting'.

Link copied to clipboard
val urn: Output<String>