confluentcloud.KsqlCluster

# confluentcloud.KsqlCluster Resource

!> Warning: It is strongly recommended that you provision a data.confluent_schema_registry_cluster resource before you provision a confluentcloud.KsqlCluster resource in a given environment. If you’re provisioning the data.confluent_schema_registry_cluster and the confluentcloud.KsqlCluster resource in the same pulumi up command, reference the data.confluent_schema_registry_cluster from the depends_on argument inside the confluentcloud.KsqlCluster resource. This ensures that the data.confluent_schema_registry_cluster resource is created before the confluentcloud.KsqlCluster resource. If you provision a confluentcloud.KsqlCluster resource without a data.confluent_schema_registry_cluster resource, and later, you want to add a data.confluent_schema_registry_cluster resource, you must destroy and re-create your confluentcloud.KsqlCluster resource after provisioning a data.confluent_schema_registry_cluster resource.

confluentcloud.KsqlCluster provides a ksqlDB cluster resource that enables creating, editing, and deleting ksqlDB clusters on Confluent Cloud.

Create KsqlCluster Resource

Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

Constructor syntax

new KsqlCluster(name: string, args: KsqlClusterArgs, opts?: CustomResourceOptions);

@overload
def KsqlCluster(resource_name: str,
                args: KsqlClusterArgs,
                opts: Optional[ResourceOptions] = None)

@overload
def KsqlCluster(resource_name: str,
                opts: Optional[ResourceOptions] = None,
                credential_identity: Optional[KsqlClusterCredentialIdentityArgs] = None,
                csu: Optional[int] = None,
                display_name: Optional[str] = None,
                environment: Optional[KsqlClusterEnvironmentArgs] = None,
                kafka_cluster: Optional[KsqlClusterKafkaClusterArgs] = None,
                use_detailed_processing_log: Optional[bool] = None)

func NewKsqlCluster(ctx *Context, name string, args KsqlClusterArgs, opts ...ResourceOption) (*KsqlCluster, error)

public KsqlCluster(string name, KsqlClusterArgs args, CustomResourceOptions? opts = null)

public KsqlCluster(String name, KsqlClusterArgs args)
public KsqlCluster(String name, KsqlClusterArgs args, CustomResourceOptions options)

type: confluentcloud:KsqlCluster
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

Parameters

Constructor example

The following reference example uses placeholder values for all input properties.

var ksqlClusterResource = new ConfluentCloud.KsqlCluster("ksqlClusterResource", new()
{
    CredentialIdentity = new ConfluentCloud.Inputs.KsqlClusterCredentialIdentityArgs
    {
        Id = "string",
    },
    Csu = 0,
    DisplayName = "string",
    Environment = new ConfluentCloud.Inputs.KsqlClusterEnvironmentArgs
    {
        Id = "string",
    },
    KafkaCluster = new ConfluentCloud.Inputs.KsqlClusterKafkaClusterArgs
    {
        Id = "string",
    },
    UseDetailedProcessingLog = false,
});

example, err := confluentcloud.NewKsqlCluster(ctx, "ksqlClusterResource", &confluentcloud.KsqlClusterArgs{
	CredentialIdentity: &confluentcloud.KsqlClusterCredentialIdentityArgs{
		Id: pulumi.String("string"),
	},
	Csu:         pulumi.Int(0),
	DisplayName: pulumi.String("string"),
	Environment: &confluentcloud.KsqlClusterEnvironmentArgs{
		Id: pulumi.String("string"),
	},
	KafkaCluster: &confluentcloud.KsqlClusterKafkaClusterArgs{
		Id: pulumi.String("string"),
	},
	UseDetailedProcessingLog: pulumi.Bool(false),
})

var ksqlClusterResource = new KsqlCluster("ksqlClusterResource", KsqlClusterArgs.builder()
    .credentialIdentity(KsqlClusterCredentialIdentityArgs.builder()
        .id("string")
        .build())
    .csu(0)
    .displayName("string")
    .environment(KsqlClusterEnvironmentArgs.builder()
        .id("string")
        .build())
    .kafkaCluster(KsqlClusterKafkaClusterArgs.builder()
        .id("string")
        .build())
    .useDetailedProcessingLog(false)
    .build());

ksql_cluster_resource = confluentcloud.KsqlCluster("ksqlClusterResource",
    credential_identity={
        "id": "string",
    },
    csu=0,
    display_name="string",
    environment={
        "id": "string",
    },
    kafka_cluster={
        "id": "string",
    },
    use_detailed_processing_log=False)

const ksqlClusterResource = new confluentcloud.KsqlCluster("ksqlClusterResource", {
    credentialIdentity: {
        id: "string",
    },
    csu: 0,
    displayName: "string",
    environment: {
        id: "string",
    },
    kafkaCluster: {
        id: "string",
    },
    useDetailedProcessingLog: false,
});

type: confluentcloud:KsqlCluster
properties:
    credentialIdentity:
        id: string
    csu: 0
    displayName: string
    environment:
        id: string
    kafkaCluster:
        id: string
    useDetailedProcessingLog: false

KsqlCluster Resource Properties

To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

Inputs

The KsqlCluster resource accepts the following input properties:

Outputs

All input properties are implicitly available as output properties. Additionally, the KsqlCluster resource produces the following output properties:

Look up Existing KsqlCluster Resource

Get an existing KsqlCluster resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

public static get(name: string, id: Input<ID>, state?: KsqlClusterState, opts?: CustomResourceOptions): KsqlCluster

@staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        api_version: Optional[str] = None,
        credential_identity: Optional[KsqlClusterCredentialIdentityArgs] = None,
        csu: Optional[int] = None,
        display_name: Optional[str] = None,
        environment: Optional[KsqlClusterEnvironmentArgs] = None,
        kafka_cluster: Optional[KsqlClusterKafkaClusterArgs] = None,
        kind: Optional[str] = None,
        resource_name: Optional[str] = None,
        rest_endpoint: Optional[str] = None,
        storage: Optional[int] = None,
        topic_prefix: Optional[str] = None,
        use_detailed_processing_log: Optional[bool] = None) -> KsqlCluster

func GetKsqlCluster(ctx *Context, name string, id IDInput, state *KsqlClusterState, opts ...ResourceOption) (*KsqlCluster, error)

public static KsqlCluster Get(string name, Input<string> id, KsqlClusterState? state, CustomResourceOptions? opts = null)

public static KsqlCluster get(String name, Output<String> id, KsqlClusterState state, CustomResourceOptions options)

Resource lookup is not supported in YAML

Supporting Types

KsqlClusterCredentialIdentity, KsqlClusterCredentialIdentityArgs

KsqlClusterEnvironment, KsqlClusterEnvironmentArgs

KsqlClusterKafkaCluster, KsqlClusterKafkaClusterArgs

Import

You can import a ksqlDB cluster by using Environment ID and ksqlDB cluster ID, in the format <Environment ID>/<ksqlDB cluster ID>, for example:

$ export CONFLUENT_CLOUD_API_KEY="<cloud_api_key>"

$ export CONFLUENT_CLOUD_API_SECRET="<cloud_api_secret>"

$ pulumi import confluentcloud:index/ksqlCluster:KsqlCluster example env-abc123/lksqlc-abc123

!> Warning: Do not forget to delete the terminal’s command history afterward for security purposes.

To learn more about importing existing cloud resources, see Importing resources.

Package Details

Repository

Confluent Cloud pulumi/pulumi-confluentcloud

License

Apache-2.0

Notes

This Pulumi package is based on the confluent Terraform Provider.