confluentcloud.FlinkMaterializedTable

Confluent v2.69.0, May 15 26

Viewing docs for Confluent v2.69.0
published on Friday, May 15, 2026 by Pulumi

Schema (JSON)

pulumi/pulumi-confluentcloud

Viewing docs for Confluent v2.69.0
published on Friday, May 15, 2026 by Pulumi

Schema (JSON)

pulumi/pulumi-confluentcloud

Note: It is recommended to set lifecycle { preventDestroy = true } on production instances to prevent accidental Flink Materialized Table deletion. This setting rejects plans that would destroy or recreate the Flink Materialized Table, such as attempting to change uneditable attributes. Read more about it in the Terraform docs.

Example Usage

Option #1: Manage multiple Flink Materialized Tables in the same Pulumi Stack

import * as pulumi from "@pulumi/pulumi";
import * as confluentcloud from "@pulumi/confluentcloud";

const example = new confluentcloud.FlinkMaterializedTable("example", {
    organization: {
        id: main.id,
    },
    environment: {
        id: staging.id,
    },
    computePool: {
        id: exampleConfluentFlinkComputePool.id,
    },
    principal: {
        id: app_manager_flink.id,
    },
    restEndpoint: mainConfluentFlinkRegion.restEndpoint,
    credentials: {
        key: flink.id,
        secret: flink.secret,
    },
    displayName: "my_materialized_table",
    kafkaCluster: {
        id: basic_cluster.id,
    },
    query: "SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;",
});

import pulumi
import pulumi_confluentcloud as confluentcloud

example = confluentcloud.FlinkMaterializedTable("example",
    organization={
        "id": main["id"],
    },
    environment={
        "id": staging["id"],
    },
    compute_pool={
        "id": example_confluent_flink_compute_pool["id"],
    },
    principal={
        "id": app_manager_flink["id"],
    },
    rest_endpoint=main_confluent_flink_region["restEndpoint"],
    credentials={
        "key": flink["id"],
        "secret": flink["secret"],
    },
    display_name="my_materialized_table",
    kafka_cluster={
        "id": basic_cluster["id"],
    },
    query="SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;")

package main

import (
	"github.com/pulumi/pulumi-confluentcloud/sdk/v2/go/confluentcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := confluentcloud.NewFlinkMaterializedTable(ctx, "example", &confluentcloud.FlinkMaterializedTableArgs{
			Organization: &confluentcloud.FlinkMaterializedTableOrganizationArgs{
				Id: pulumi.Any(main.Id),
			},
			Environment: &confluentcloud.FlinkMaterializedTableEnvironmentArgs{
				Id: pulumi.Any(staging.Id),
			},
			ComputePool: &confluentcloud.FlinkMaterializedTableComputePoolArgs{
				Id: pulumi.Any(exampleConfluentFlinkComputePool.Id),
			},
			Principal: &confluentcloud.FlinkMaterializedTablePrincipalArgs{
				Id: pulumi.Any(app_manager_flink.Id),
			},
			RestEndpoint: pulumi.Any(mainConfluentFlinkRegion.RestEndpoint),
			Credentials: &confluentcloud.FlinkMaterializedTableCredentialsArgs{
				Key:    pulumi.Any(flink.Id),
				Secret: pulumi.Any(flink.Secret),
			},
			DisplayName: pulumi.String("my_materialized_table"),
			KafkaCluster: &confluentcloud.FlinkMaterializedTableKafkaClusterArgs{
				Id: pulumi.Any(basic_cluster.Id),
			},
			Query: pulumi.String("SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using ConfluentCloud = Pulumi.ConfluentCloud;

return await Deployment.RunAsync(() => 
{
    var example = new ConfluentCloud.FlinkMaterializedTable("example", new()
    {
        Organization = new ConfluentCloud.Inputs.FlinkMaterializedTableOrganizationArgs
        {
            Id = main.Id,
        },
        Environment = new ConfluentCloud.Inputs.FlinkMaterializedTableEnvironmentArgs
        {
            Id = staging.Id,
        },
        ComputePool = new ConfluentCloud.Inputs.FlinkMaterializedTableComputePoolArgs
        {
            Id = exampleConfluentFlinkComputePool.Id,
        },
        Principal = new ConfluentCloud.Inputs.FlinkMaterializedTablePrincipalArgs
        {
            Id = app_manager_flink.Id,
        },
        RestEndpoint = mainConfluentFlinkRegion.RestEndpoint,
        Credentials = new ConfluentCloud.Inputs.FlinkMaterializedTableCredentialsArgs
        {
            Key = flink.Id,
            Secret = flink.Secret,
        },
        DisplayName = "my_materialized_table",
        KafkaCluster = new ConfluentCloud.Inputs.FlinkMaterializedTableKafkaClusterArgs
        {
            Id = basic_cluster.Id,
        },
        Query = "SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.confluentcloud.FlinkMaterializedTable;
import com.pulumi.confluentcloud.FlinkMaterializedTableArgs;
import com.pulumi.confluentcloud.inputs.FlinkMaterializedTableOrganizationArgs;
import com.pulumi.confluentcloud.inputs.FlinkMaterializedTableEnvironmentArgs;
import com.pulumi.confluentcloud.inputs.FlinkMaterializedTableComputePoolArgs;
import com.pulumi.confluentcloud.inputs.FlinkMaterializedTablePrincipalArgs;
import com.pulumi.confluentcloud.inputs.FlinkMaterializedTableCredentialsArgs;
import com.pulumi.confluentcloud.inputs.FlinkMaterializedTableKafkaClusterArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var example = new FlinkMaterializedTable("example", FlinkMaterializedTableArgs.builder()
            .organization(FlinkMaterializedTableOrganizationArgs.builder()
                .id(main.id())
                .build())
            .environment(FlinkMaterializedTableEnvironmentArgs.builder()
                .id(staging.id())
                .build())
            .computePool(FlinkMaterializedTableComputePoolArgs.builder()
                .id(exampleConfluentFlinkComputePool.id())
                .build())
            .principal(FlinkMaterializedTablePrincipalArgs.builder()
                .id(app_manager_flink.id())
                .build())
            .restEndpoint(mainConfluentFlinkRegion.restEndpoint())
            .credentials(FlinkMaterializedTableCredentialsArgs.builder()
                .key(flink.id())
                .secret(flink.secret())
                .build())
            .displayName("my_materialized_table")
            .kafkaCluster(FlinkMaterializedTableKafkaClusterArgs.builder()
                .id(basic_cluster.id())
                .build())
            .query("SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;")
            .build());

    }
}

resources:
  example:
    type: confluentcloud:FlinkMaterializedTable
    properties:
      organization:
        id: ${main.id}
      environment:
        id: ${staging.id}
      computePool:
        id: ${exampleConfluentFlinkComputePool.id}
      principal:
        id: ${["app-manager-flink"].id}
      restEndpoint: ${mainConfluentFlinkRegion.restEndpoint}
      credentials:
        key: ${flink.id}
        secret: ${flink.secret}
      displayName: my_materialized_table
      kafkaCluster:
        id: ${["basic-cluster"].id}
      query: SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;

Example coming soon!

Option #2: Manage a single Flink Materialized Table in the same Pulumi Stack

import * as pulumi from "@pulumi/pulumi";
import * as confluentcloud from "@pulumi/confluentcloud";

const example = new confluentcloud.FlinkMaterializedTable("example", {
    displayName: "my_materialized_table",
    kafkaCluster: {
        id: basic_cluster.id,
    },
    query: "SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;",
});

import pulumi
import pulumi_confluentcloud as confluentcloud

example = confluentcloud.FlinkMaterializedTable("example",
    display_name="my_materialized_table",
    kafka_cluster={
        "id": basic_cluster["id"],
    },
    query="SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;")

package main

import (
	"github.com/pulumi/pulumi-confluentcloud/sdk/v2/go/confluentcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := confluentcloud.NewFlinkMaterializedTable(ctx, "example", &confluentcloud.FlinkMaterializedTableArgs{
			DisplayName: pulumi.String("my_materialized_table"),
			KafkaCluster: &confluentcloud.FlinkMaterializedTableKafkaClusterArgs{
				Id: pulumi.Any(basic_cluster.Id),
			},
			Query: pulumi.String("SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using ConfluentCloud = Pulumi.ConfluentCloud;

return await Deployment.RunAsync(() => 
{
    var example = new ConfluentCloud.FlinkMaterializedTable("example", new()
    {
        DisplayName = "my_materialized_table",
        KafkaCluster = new ConfluentCloud.Inputs.FlinkMaterializedTableKafkaClusterArgs
        {
            Id = basic_cluster.Id,
        },
        Query = "SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.confluentcloud.FlinkMaterializedTable;
import com.pulumi.confluentcloud.FlinkMaterializedTableArgs;
import com.pulumi.confluentcloud.inputs.FlinkMaterializedTableKafkaClusterArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var example = new FlinkMaterializedTable("example", FlinkMaterializedTableArgs.builder()
            .displayName("my_materialized_table")
            .kafkaCluster(FlinkMaterializedTableKafkaClusterArgs.builder()
                .id(basic_cluster.id())
                .build())
            .query("SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;")
            .build());

    }
}

resources:
  example:
    type: confluentcloud:FlinkMaterializedTable
    properties:
      displayName: my_materialized_table
      kafkaCluster:
        id: ${["basic-cluster"].id}
      query: SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;

Example coming soon!

Stopping and Resuming a Materialized Table

A running Materialized Table can be paused and later resumed by toggling the stopped attribute. The default value is false (running). To stop the table, set stopped = true and run pulumi up; to resume it, set stopped = false (or remove the attribute) and apply again. The Materialized Table is preserved across stop/resume — only its execution is paused.

import * as pulumi from "@pulumi/pulumi";
import * as confluentcloud from "@pulumi/confluentcloud";

const example = new confluentcloud.FlinkMaterializedTable("example", {
    organization: {
        id: main.id,
    },
    environment: {
        id: staging.id,
    },
    computePool: {
        id: exampleConfluentFlinkComputePool.id,
    },
    principal: {
        id: app_manager_flink.id,
    },
    restEndpoint: mainConfluentFlinkRegion.restEndpoint,
    credentials: {
        key: flink.id,
        secret: flink.secret,
    },
    displayName: "my_materialized_table",
    kafkaCluster: {
        id: basic_cluster.id,
    },
    query: "SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;",
    stopped: false,
});

import pulumi
import pulumi_confluentcloud as confluentcloud

example = confluentcloud.FlinkMaterializedTable("example",
    organization={
        "id": main["id"],
    },
    environment={
        "id": staging["id"],
    },
    compute_pool={
        "id": example_confluent_flink_compute_pool["id"],
    },
    principal={
        "id": app_manager_flink["id"],
    },
    rest_endpoint=main_confluent_flink_region["restEndpoint"],
    credentials={
        "key": flink["id"],
        "secret": flink["secret"],
    },
    display_name="my_materialized_table",
    kafka_cluster={
        "id": basic_cluster["id"],
    },
    query="SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;",
    stopped=False)

package main

import (
	"github.com/pulumi/pulumi-confluentcloud/sdk/v2/go/confluentcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := confluentcloud.NewFlinkMaterializedTable(ctx, "example", &confluentcloud.FlinkMaterializedTableArgs{
			Organization: &confluentcloud.FlinkMaterializedTableOrganizationArgs{
				Id: pulumi.Any(main.Id),
			},
			Environment: &confluentcloud.FlinkMaterializedTableEnvironmentArgs{
				Id: pulumi.Any(staging.Id),
			},
			ComputePool: &confluentcloud.FlinkMaterializedTableComputePoolArgs{
				Id: pulumi.Any(exampleConfluentFlinkComputePool.Id),
			},
			Principal: &confluentcloud.FlinkMaterializedTablePrincipalArgs{
				Id: pulumi.Any(app_manager_flink.Id),
			},
			RestEndpoint: pulumi.Any(mainConfluentFlinkRegion.RestEndpoint),
			Credentials: &confluentcloud.FlinkMaterializedTableCredentialsArgs{
				Key:    pulumi.Any(flink.Id),
				Secret: pulumi.Any(flink.Secret),
			},
			DisplayName: pulumi.String("my_materialized_table"),
			KafkaCluster: &confluentcloud.FlinkMaterializedTableKafkaClusterArgs{
				Id: pulumi.Any(basic_cluster.Id),
			},
			Query:   pulumi.String("SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;"),
			Stopped: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using ConfluentCloud = Pulumi.ConfluentCloud;

return await Deployment.RunAsync(() => 
{
    var example = new ConfluentCloud.FlinkMaterializedTable("example", new()
    {
        Organization = new ConfluentCloud.Inputs.FlinkMaterializedTableOrganizationArgs
        {
            Id = main.Id,
        },
        Environment = new ConfluentCloud.Inputs.FlinkMaterializedTableEnvironmentArgs
        {
            Id = staging.Id,
        },
        ComputePool = new ConfluentCloud.Inputs.FlinkMaterializedTableComputePoolArgs
        {
            Id = exampleConfluentFlinkComputePool.Id,
        },
        Principal = new ConfluentCloud.Inputs.FlinkMaterializedTablePrincipalArgs
        {
            Id = app_manager_flink.Id,
        },
        RestEndpoint = mainConfluentFlinkRegion.RestEndpoint,
        Credentials = new ConfluentCloud.Inputs.FlinkMaterializedTableCredentialsArgs
        {
            Key = flink.Id,
            Secret = flink.Secret,
        },
        DisplayName = "my_materialized_table",
        KafkaCluster = new ConfluentCloud.Inputs.FlinkMaterializedTableKafkaClusterArgs
        {
            Id = basic_cluster.Id,
        },
        Query = "SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;",
        Stopped = false,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.confluentcloud.FlinkMaterializedTable;
import com.pulumi.confluentcloud.FlinkMaterializedTableArgs;
import com.pulumi.confluentcloud.inputs.FlinkMaterializedTableOrganizationArgs;
import com.pulumi.confluentcloud.inputs.FlinkMaterializedTableEnvironmentArgs;
import com.pulumi.confluentcloud.inputs.FlinkMaterializedTableComputePoolArgs;
import com.pulumi.confluentcloud.inputs.FlinkMaterializedTablePrincipalArgs;
import com.pulumi.confluentcloud.inputs.FlinkMaterializedTableCredentialsArgs;
import com.pulumi.confluentcloud.inputs.FlinkMaterializedTableKafkaClusterArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var example = new FlinkMaterializedTable("example", FlinkMaterializedTableArgs.builder()
            .organization(FlinkMaterializedTableOrganizationArgs.builder()
                .id(main.id())
                .build())
            .environment(FlinkMaterializedTableEnvironmentArgs.builder()
                .id(staging.id())
                .build())
            .computePool(FlinkMaterializedTableComputePoolArgs.builder()
                .id(exampleConfluentFlinkComputePool.id())
                .build())
            .principal(FlinkMaterializedTablePrincipalArgs.builder()
                .id(app_manager_flink.id())
                .build())
            .restEndpoint(mainConfluentFlinkRegion.restEndpoint())
            .credentials(FlinkMaterializedTableCredentialsArgs.builder()
                .key(flink.id())
                .secret(flink.secret())
                .build())
            .displayName("my_materialized_table")
            .kafkaCluster(FlinkMaterializedTableKafkaClusterArgs.builder()
                .id(basic_cluster.id())
                .build())
            .query("SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;")
            .stopped(false)
            .build());

    }
}

resources:
  example:
    type: confluentcloud:FlinkMaterializedTable
    properties:
      organization:
        id: ${main.id}
      environment:
        id: ${staging.id}
      computePool:
        id: ${exampleConfluentFlinkComputePool.id}
      principal:
        id: ${["app-manager-flink"].id}
      restEndpoint: ${mainConfluentFlinkRegion.restEndpoint}
      credentials:
        key: ${flink.id}
        secret: ${flink.secret}
      displayName: my_materialized_table
      kafkaCluster:
        id: ${["basic-cluster"].id}
      query: SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;
      stopped: false

Example coming soon!

Create FlinkMaterializedTable Resource

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

Constructor syntax

new FlinkMaterializedTable(name: string, args: FlinkMaterializedTableArgs, opts?: CustomResourceOptions);

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

@overload
def FlinkMaterializedTable(resource_name: str,
                           opts: Optional[ResourceOptions] = None,
                           display_name: Optional[str] = None,
                           kafka_cluster: Optional[FlinkMaterializedTableKafkaClusterArgs] = None,
                           environment: Optional[FlinkMaterializedTableEnvironmentArgs] = None,
                           credentials: Optional[FlinkMaterializedTableCredentialsArgs] = None,
                           constraints: Optional[Sequence[FlinkMaterializedTableConstraintArgs]] = None,
                           distribution: Optional[FlinkMaterializedTableDistributionArgs] = None,
                           columns: Optional[Sequence[FlinkMaterializedTableColumnArgs]] = None,
                           compute_pool: Optional[FlinkMaterializedTableComputePoolArgs] = None,
                           organization: Optional[FlinkMaterializedTableOrganizationArgs] = None,
                           principal: Optional[FlinkMaterializedTablePrincipalArgs] = None,
                           query: Optional[str] = None,
                           rest_endpoint: Optional[str] = None,
                           stopped: Optional[bool] = None,
                           watermark: Optional[FlinkMaterializedTableWatermarkArgs] = None)

func NewFlinkMaterializedTable(ctx *Context, name string, args FlinkMaterializedTableArgs, opts ...ResourceOption) (*FlinkMaterializedTable, error)

public FlinkMaterializedTable(string name, FlinkMaterializedTableArgs args, CustomResourceOptions? opts = null)

public FlinkMaterializedTable(String name, FlinkMaterializedTableArgs args)
public FlinkMaterializedTable(String name, FlinkMaterializedTableArgs args, CustomResourceOptions options)

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

resource "confluentcloud_flinkmaterializedtable" "name" {
    # resource properties
}

Parameters

name string: The unique name of the resource.
args FlinkMaterializedTableArgs: The arguments to resource properties.
opts CustomResourceOptions: Bag of options to control resource's behavior.

resource_name str: The unique name of the resource.
args FlinkMaterializedTableArgs: The arguments to resource properties.
opts ResourceOptions: Bag of options to control resource's behavior.

ctx Context: Context object for the current deployment.
name string: The unique name of the resource.
args FlinkMaterializedTableArgs: The arguments to resource properties.
opts ResourceOption: Bag of options to control resource's behavior.

name string: The unique name of the resource.
args FlinkMaterializedTableArgs: The arguments to resource properties.
opts CustomResourceOptions: Bag of options to control resource's behavior.

name String: The unique name of the resource.
args FlinkMaterializedTableArgs: The arguments to resource properties.
options CustomResourceOptions: Bag of options to control resource's behavior.

Constructor example

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

var flinkMaterializedTableResource = new ConfluentCloud.FlinkMaterializedTable("flinkMaterializedTableResource", new()
{
    DisplayName = "string",
    KafkaCluster = new ConfluentCloud.Inputs.FlinkMaterializedTableKafkaClusterArgs
    {
        Id = "string",
    },
    Environment = new ConfluentCloud.Inputs.FlinkMaterializedTableEnvironmentArgs
    {
        Id = "string",
    },
    Credentials = new ConfluentCloud.Inputs.FlinkMaterializedTableCredentialsArgs
    {
        Key = "string",
        Secret = "string",
    },
    Constraints = new[]
    {
        new ConfluentCloud.Inputs.FlinkMaterializedTableConstraintArgs
        {
            Columns = new[]
            {
                "string",
            },
            Enforced = false,
            Name = "string",
            Type = "string",
        },
    },
    Distribution = new ConfluentCloud.Inputs.FlinkMaterializedTableDistributionArgs
    {
        BucketCount = 0,
        Keys = new[]
        {
            "string",
        },
    },
    Columns = new[]
    {
        new ConfluentCloud.Inputs.FlinkMaterializedTableColumnArgs
        {
            ColumnsComputeds = new[]
            {
                new ConfluentCloud.Inputs.FlinkMaterializedTableColumnColumnsComputedArgs
                {
                    ColumnComputedComment = "string",
                    ColumnComputedExpression = "string",
                    ColumnComputedKind = "string",
                    ColumnComputedName = "string",
                    ColumnComputedType = "string",
                    ColumnComputedVirtual = false,
                },
            },
            ColumnsMetadatas = new[]
            {
                new ConfluentCloud.Inputs.FlinkMaterializedTableColumnColumnsMetadataArgs
                {
                    ColumnMetadataComment = "string",
                    ColumnMetadataKey = "string",
                    ColumnMetadataKind = "string",
                    ColumnMetadataName = "string",
                    ColumnMetadataType = "string",
                    ColumnMetadataVirtual = false,
                },
            },
            ColumnsPhysicals = new[]
            {
                new ConfluentCloud.Inputs.FlinkMaterializedTableColumnColumnsPhysicalArgs
                {
                    ColumnPhysicalComment = "string",
                    ColumnPhysicalKind = "string",
                    ColumnPhysicalName = "string",
                    ColumnPhysicalType = "string",
                },
            },
        },
    },
    ComputePool = new ConfluentCloud.Inputs.FlinkMaterializedTableComputePoolArgs
    {
        Id = "string",
    },
    Organization = new ConfluentCloud.Inputs.FlinkMaterializedTableOrganizationArgs
    {
        Id = "string",
    },
    Principal = new ConfluentCloud.Inputs.FlinkMaterializedTablePrincipalArgs
    {
        Id = "string",
    },
    Query = "string",
    RestEndpoint = "string",
    Stopped = false,
    Watermark = new ConfluentCloud.Inputs.FlinkMaterializedTableWatermarkArgs
    {
        Column = "string",
        Expression = "string",
    },
});

example, err := confluentcloud.NewFlinkMaterializedTable(ctx, "flinkMaterializedTableResource", &confluentcloud.FlinkMaterializedTableArgs{
	DisplayName: pulumi.String("string"),
	KafkaCluster: &confluentcloud.FlinkMaterializedTableKafkaClusterArgs{
		Id: pulumi.String("string"),
	},
	Environment: &confluentcloud.FlinkMaterializedTableEnvironmentArgs{
		Id: pulumi.String("string"),
	},
	Credentials: &confluentcloud.FlinkMaterializedTableCredentialsArgs{
		Key:    pulumi.String("string"),
		Secret: pulumi.String("string"),
	},
	Constraints: confluentcloud.FlinkMaterializedTableConstraintArray{
		&confluentcloud.FlinkMaterializedTableConstraintArgs{
			Columns: pulumi.StringArray{
				pulumi.String("string"),
			},
			Enforced: pulumi.Bool(false),
			Name:     pulumi.String("string"),
			Type:     pulumi.String("string"),
		},
	},
	Distribution: &confluentcloud.FlinkMaterializedTableDistributionArgs{
		BucketCount: pulumi.Int(0),
		Keys: pulumi.StringArray{
			pulumi.String("string"),
		},
	},
	Columns: confluentcloud.FlinkMaterializedTableColumnArray{
		&confluentcloud.FlinkMaterializedTableColumnArgs{
			ColumnsComputeds: confluentcloud.FlinkMaterializedTableColumnColumnsComputedArray{
				&confluentcloud.FlinkMaterializedTableColumnColumnsComputedArgs{
					ColumnComputedComment:    pulumi.String("string"),
					ColumnComputedExpression: pulumi.String("string"),
					ColumnComputedKind:       pulumi.String("string"),
					ColumnComputedName:       pulumi.String("string"),
					ColumnComputedType:       pulumi.String("string"),
					ColumnComputedVirtual:    pulumi.Bool(false),
				},
			},
			ColumnsMetadatas: confluentcloud.FlinkMaterializedTableColumnColumnsMetadataArray{
				&confluentcloud.FlinkMaterializedTableColumnColumnsMetadataArgs{
					ColumnMetadataComment: pulumi.String("string"),
					ColumnMetadataKey:     pulumi.String("string"),
					ColumnMetadataKind:    pulumi.String("string"),
					ColumnMetadataName:    pulumi.String("string"),
					ColumnMetadataType:    pulumi.String("string"),
					ColumnMetadataVirtual: pulumi.Bool(false),
				},
			},
			ColumnsPhysicals: confluentcloud.FlinkMaterializedTableColumnColumnsPhysicalArray{
				&confluentcloud.FlinkMaterializedTableColumnColumnsPhysicalArgs{
					ColumnPhysicalComment: pulumi.String("string"),
					ColumnPhysicalKind:    pulumi.String("string"),
					ColumnPhysicalName:    pulumi.String("string"),
					ColumnPhysicalType:    pulumi.String("string"),
				},
			},
		},
	},
	ComputePool: &confluentcloud.FlinkMaterializedTableComputePoolArgs{
		Id: pulumi.String("string"),
	},
	Organization: &confluentcloud.FlinkMaterializedTableOrganizationArgs{
		Id: pulumi.String("string"),
	},
	Principal: &confluentcloud.FlinkMaterializedTablePrincipalArgs{
		Id: pulumi.String("string"),
	},
	Query:        pulumi.String("string"),
	RestEndpoint: pulumi.String("string"),
	Stopped:      pulumi.Bool(false),
	Watermark: &confluentcloud.FlinkMaterializedTableWatermarkArgs{
		Column:     pulumi.String("string"),
		Expression: pulumi.String("string"),
	},
})

resource "confluentcloud_flinkmaterializedtable" "flinkMaterializedTableResource" {
  display_name = "string"
  kafka_cluster = {
    id = "string"
  }
  environment = {
    id = "string"
  }
  credentials = {
    key    = "string"
    secret = "string"
  }
  constraints {
    columns  = ["string"]
    enforced = false
    name     = "string"
    type     = "string"
  }
  distribution = {
    bucket_count = 0
    keys         = ["string"]
  }
  columns {
    columns_computeds {
      column_computed_comment    = "string"
      column_computed_expression = "string"
      column_computed_kind       = "string"
      column_computed_name       = "string"
      column_computed_type       = "string"
      column_computed_virtual    = false
    }
    columns_metadatas {
      column_metadata_comment = "string"
      column_metadata_key     = "string"
      column_metadata_kind    = "string"
      column_metadata_name    = "string"
      column_metadata_type    = "string"
      column_metadata_virtual = false
    }
    columns_physicals {
      column_physical_comment = "string"
      column_physical_kind    = "string"
      column_physical_name    = "string"
      column_physical_type    = "string"
    }
  }
  compute_pool = {
    id = "string"
  }
  organization = {
    id = "string"
  }
  principal = {
    id = "string"
  }
  query         = "string"
  rest_endpoint = "string"
  stopped       = false
  watermark = {
    column     = "string"
    expression = "string"
  }
}

var flinkMaterializedTableResource = new FlinkMaterializedTable("flinkMaterializedTableResource", FlinkMaterializedTableArgs.builder()
    .displayName("string")
    .kafkaCluster(FlinkMaterializedTableKafkaClusterArgs.builder()
        .id("string")
        .build())
    .environment(FlinkMaterializedTableEnvironmentArgs.builder()
        .id("string")
        .build())
    .credentials(FlinkMaterializedTableCredentialsArgs.builder()
        .key("string")
        .secret("string")
        .build())
    .constraints(FlinkMaterializedTableConstraintArgs.builder()
        .columns("string")
        .enforced(false)
        .name("string")
        .type("string")
        .build())
    .distribution(FlinkMaterializedTableDistributionArgs.builder()
        .bucketCount(0)
        .keys("string")
        .build())
    .columns(FlinkMaterializedTableColumnArgs.builder()
        .columnsComputeds(FlinkMaterializedTableColumnColumnsComputedArgs.builder()
            .columnComputedComment("string")
            .columnComputedExpression("string")
            .columnComputedKind("string")
            .columnComputedName("string")
            .columnComputedType("string")
            .columnComputedVirtual(false)
            .build())
        .columnsMetadatas(FlinkMaterializedTableColumnColumnsMetadataArgs.builder()
            .columnMetadataComment("string")
            .columnMetadataKey("string")
            .columnMetadataKind("string")
            .columnMetadataName("string")
            .columnMetadataType("string")
            .columnMetadataVirtual(false)
            .build())
        .columnsPhysicals(FlinkMaterializedTableColumnColumnsPhysicalArgs.builder()
            .columnPhysicalComment("string")
            .columnPhysicalKind("string")
            .columnPhysicalName("string")
            .columnPhysicalType("string")
            .build())
        .build())
    .computePool(FlinkMaterializedTableComputePoolArgs.builder()
        .id("string")
        .build())
    .organization(FlinkMaterializedTableOrganizationArgs.builder()
        .id("string")
        .build())
    .principal(FlinkMaterializedTablePrincipalArgs.builder()
        .id("string")
        .build())
    .query("string")
    .restEndpoint("string")
    .stopped(false)
    .watermark(FlinkMaterializedTableWatermarkArgs.builder()
        .column("string")
        .expression("string")
        .build())
    .build());

flink_materialized_table_resource = confluentcloud.FlinkMaterializedTable("flinkMaterializedTableResource",
    display_name="string",
    kafka_cluster={
        "id": "string",
    },
    environment={
        "id": "string",
    },
    credentials={
        "key": "string",
        "secret": "string",
    },
    constraints=[{
        "columns": ["string"],
        "enforced": False,
        "name": "string",
        "type": "string",
    }],
    distribution={
        "bucket_count": 0,
        "keys": ["string"],
    },
    columns=[{
        "columns_computeds": [{
            "column_computed_comment": "string",
            "column_computed_expression": "string",
            "column_computed_kind": "string",
            "column_computed_name": "string",
            "column_computed_type": "string",
            "column_computed_virtual": False,
        }],
        "columns_metadatas": [{
            "column_metadata_comment": "string",
            "column_metadata_key": "string",
            "column_metadata_kind": "string",
            "column_metadata_name": "string",
            "column_metadata_type": "string",
            "column_metadata_virtual": False,
        }],
        "columns_physicals": [{
            "column_physical_comment": "string",
            "column_physical_kind": "string",
            "column_physical_name": "string",
            "column_physical_type": "string",
        }],
    }],
    compute_pool={
        "id": "string",
    },
    organization={
        "id": "string",
    },
    principal={
        "id": "string",
    },
    query="string",
    rest_endpoint="string",
    stopped=False,
    watermark={
        "column": "string",
        "expression": "string",
    })

const flinkMaterializedTableResource = new confluentcloud.FlinkMaterializedTable("flinkMaterializedTableResource", {
    displayName: "string",
    kafkaCluster: {
        id: "string",
    },
    environment: {
        id: "string",
    },
    credentials: {
        key: "string",
        secret: "string",
    },
    constraints: [{
        columns: ["string"],
        enforced: false,
        name: "string",
        type: "string",
    }],
    distribution: {
        bucketCount: 0,
        keys: ["string"],
    },
    columns: [{
        columnsComputeds: [{
            columnComputedComment: "string",
            columnComputedExpression: "string",
            columnComputedKind: "string",
            columnComputedName: "string",
            columnComputedType: "string",
            columnComputedVirtual: false,
        }],
        columnsMetadatas: [{
            columnMetadataComment: "string",
            columnMetadataKey: "string",
            columnMetadataKind: "string",
            columnMetadataName: "string",
            columnMetadataType: "string",
            columnMetadataVirtual: false,
        }],
        columnsPhysicals: [{
            columnPhysicalComment: "string",
            columnPhysicalKind: "string",
            columnPhysicalName: "string",
            columnPhysicalType: "string",
        }],
    }],
    computePool: {
        id: "string",
    },
    organization: {
        id: "string",
    },
    principal: {
        id: "string",
    },
    query: "string",
    restEndpoint: "string",
    stopped: false,
    watermark: {
        column: "string",
        expression: "string",
    },
});

type: confluentcloud:FlinkMaterializedTable
properties:
    columns:
        - columnsComputeds:
            - columnComputedComment: string
              columnComputedExpression: string
              columnComputedKind: string
              columnComputedName: string
              columnComputedType: string
              columnComputedVirtual: false
          columnsMetadatas:
            - columnMetadataComment: string
              columnMetadataKey: string
              columnMetadataKind: string
              columnMetadataName: string
              columnMetadataType: string
              columnMetadataVirtual: false
          columnsPhysicals:
            - columnPhysicalComment: string
              columnPhysicalKind: string
              columnPhysicalName: string
              columnPhysicalType: string
    computePool:
        id: string
    constraints:
        - columns:
            - string
          enforced: false
          name: string
          type: string
    credentials:
        key: string
        secret: string
    displayName: string
    distribution:
        bucketCount: 0
        keys:
            - string
    environment:
        id: string
    kafkaCluster:
        id: string
    organization:
        id: string
    principal:
        id: string
    query: string
    restEndpoint: string
    stopped: false
    watermark:
        column: string
        expression: string

FlinkMaterializedTable Resource Properties

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

Inputs

In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

The FlinkMaterializedTable resource accepts the following input properties:

DisplayName string: The unique name of the Materialized Table.
KafkaCluster Pulumi.ConfluentCloud.Inputs.FlinkMaterializedTableKafkaCluster
Columns List<Pulumi.ConfluentCloud.Inputs.FlinkMaterializedTableColumn>: A list of column definitions. Each columns block supports the following sub-blocks:
ComputePool Pulumi.ConfluentCloud.Inputs.FlinkMaterializedTableComputePool
Constraints List<Pulumi.ConfluentCloud.Inputs.FlinkMaterializedTableConstraint>
Credentials Pulumi.ConfluentCloud.Inputs.FlinkMaterializedTableCredentials: The Cluster API Credentials.
Distribution Pulumi.ConfluentCloud.Inputs.FlinkMaterializedTableDistribution: The distribution definition for the Materialized Table. Supports the following:
Environment Pulumi.ConfluentCloud.Inputs.FlinkMaterializedTableEnvironment
Organization Pulumi.ConfluentCloud.Inputs.FlinkMaterializedTableOrganization
Principal Pulumi.ConfluentCloud.Inputs.FlinkMaterializedTablePrincipal
Query string: The SQL query that defines the Materialized Table, for example, SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;.
RestEndpoint string: The REST endpoint of the Flink region, for example, https://flink.us-east-1.aws.confluent.cloud.
Stopped bool: Indicates whether the Materialized Table is stopped. Defaults to false. Update it to true to stop the Materialized Table. Subsequently update it to false to resume it.
Watermark Pulumi.ConfluentCloud.Inputs.FlinkMaterializedTableWatermark: The watermark definition for the Materialized Table. Supports the following:

DisplayName string: The unique name of the Materialized Table.
KafkaCluster FlinkMaterializedTableKafkaClusterArgs
Columns []FlinkMaterializedTableColumnArgs: A list of column definitions. Each columns block supports the following sub-blocks:
ComputePool FlinkMaterializedTableComputePoolArgs
Constraints []FlinkMaterializedTableConstraintArgs
Credentials FlinkMaterializedTableCredentialsArgs: The Cluster API Credentials.
Distribution FlinkMaterializedTableDistributionArgs: The distribution definition for the Materialized Table. Supports the following:
Environment FlinkMaterializedTableEnvironmentArgs
Organization FlinkMaterializedTableOrganizationArgs
Principal FlinkMaterializedTablePrincipalArgs
Query string: The SQL query that defines the Materialized Table, for example, SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;.
RestEndpoint string: The REST endpoint of the Flink region, for example, https://flink.us-east-1.aws.confluent.cloud.
Stopped bool: Indicates whether the Materialized Table is stopped. Defaults to false. Update it to true to stop the Materialized Table. Subsequently update it to false to resume it.
Watermark FlinkMaterializedTableWatermarkArgs: The watermark definition for the Materialized Table. Supports the following:

display_name string: The unique name of the Materialized Table.
kafka_cluster object
columns list(object): A list of column definitions. Each columns block supports the following sub-blocks:
compute_pool object
constraints list(object)
credentials object: The Cluster API Credentials.
distribution object: The distribution definition for the Materialized Table. Supports the following:
environment object
organization object
principal object
query string: The SQL query that defines the Materialized Table, for example, SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;.
rest_endpoint string: The REST endpoint of the Flink region, for example, https://flink.us-east-1.aws.confluent.cloud.
stopped bool: Indicates whether the Materialized Table is stopped. Defaults to false. Update it to true to stop the Materialized Table. Subsequently update it to false to resume it.
watermark object: The watermark definition for the Materialized Table. Supports the following:

displayName String: The unique name of the Materialized Table.
kafkaCluster FlinkMaterializedTableKafkaCluster
columns List<FlinkMaterializedTableColumn>: A list of column definitions. Each columns block supports the following sub-blocks:
computePool FlinkMaterializedTableComputePool
constraints List<FlinkMaterializedTableConstraint>
credentials FlinkMaterializedTableCredentials: The Cluster API Credentials.
distribution FlinkMaterializedTableDistribution: The distribution definition for the Materialized Table. Supports the following:
environment FlinkMaterializedTableEnvironment
organization FlinkMaterializedTableOrganization
principal FlinkMaterializedTablePrincipal
query String: The SQL query that defines the Materialized Table, for example, SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;.
restEndpoint String: The REST endpoint of the Flink region, for example, https://flink.us-east-1.aws.confluent.cloud.
stopped Boolean: Indicates whether the Materialized Table is stopped. Defaults to false. Update it to true to stop the Materialized Table. Subsequently update it to false to resume it.
watermark FlinkMaterializedTableWatermark: The watermark definition for the Materialized Table. Supports the following:

displayName string: The unique name of the Materialized Table.
kafkaCluster FlinkMaterializedTableKafkaCluster
columns FlinkMaterializedTableColumn[]: A list of column definitions. Each columns block supports the following sub-blocks:
computePool FlinkMaterializedTableComputePool
constraints FlinkMaterializedTableConstraint[]
credentials FlinkMaterializedTableCredentials: The Cluster API Credentials.
distribution FlinkMaterializedTableDistribution: The distribution definition for the Materialized Table. Supports the following:
environment FlinkMaterializedTableEnvironment
organization FlinkMaterializedTableOrganization
principal FlinkMaterializedTablePrincipal
query string: The SQL query that defines the Materialized Table, for example, SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;.
restEndpoint string: The REST endpoint of the Flink region, for example, https://flink.us-east-1.aws.confluent.cloud.
stopped boolean: Indicates whether the Materialized Table is stopped. Defaults to false. Update it to true to stop the Materialized Table. Subsequently update it to false to resume it.
watermark FlinkMaterializedTableWatermark: The watermark definition for the Materialized Table. Supports the following:

display_name str: The unique name of the Materialized Table.
kafka_cluster FlinkMaterializedTableKafkaClusterArgs
columns Sequence[FlinkMaterializedTableColumnArgs]: A list of column definitions. Each columns block supports the following sub-blocks:
compute_pool FlinkMaterializedTableComputePoolArgs
constraints Sequence[FlinkMaterializedTableConstraintArgs]
credentials FlinkMaterializedTableCredentialsArgs: The Cluster API Credentials.
distribution FlinkMaterializedTableDistributionArgs: The distribution definition for the Materialized Table. Supports the following:
environment FlinkMaterializedTableEnvironmentArgs
organization FlinkMaterializedTableOrganizationArgs
principal FlinkMaterializedTablePrincipalArgs
query str: The SQL query that defines the Materialized Table, for example, SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;.
rest_endpoint str: The REST endpoint of the Flink region, for example, https://flink.us-east-1.aws.confluent.cloud.
stopped bool: Indicates whether the Materialized Table is stopped. Defaults to false. Update it to true to stop the Materialized Table. Subsequently update it to false to resume it.
watermark FlinkMaterializedTableWatermarkArgs: The watermark definition for the Materialized Table. Supports the following:

displayName String: The unique name of the Materialized Table.
kafkaCluster Property Map
columns List<Property Map>: A list of column definitions. Each columns block supports the following sub-blocks:
computePool Property Map
constraints List<Property Map>
credentials Property Map: The Cluster API Credentials.
distribution Property Map: The distribution definition for the Materialized Table. Supports the following:
environment Property Map
organization Property Map
principal Property Map
query String: The SQL query that defines the Materialized Table, for example, SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;.
restEndpoint String: The REST endpoint of the Flink region, for example, https://flink.us-east-1.aws.confluent.cloud.
stopped Boolean: Indicates whether the Materialized Table is stopped. Defaults to false. Update it to true to stop the Materialized Table. Subsequently update it to false to resume it.
watermark Property Map: The watermark definition for the Materialized Table. Supports the following:

Outputs

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

Id string: The provider-assigned unique ID for this managed resource.

Id string: The provider-assigned unique ID for this managed resource.

id string: The provider-assigned unique ID for this managed resource.

id String: The provider-assigned unique ID for this managed resource.

id string: The provider-assigned unique ID for this managed resource.

id str: The provider-assigned unique ID for this managed resource.

id String: The provider-assigned unique ID for this managed resource.

Look up Existing FlinkMaterializedTable Resource

Get an existing FlinkMaterializedTable 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?: FlinkMaterializedTableState, opts?: CustomResourceOptions): FlinkMaterializedTable

@staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        columns: Optional[Sequence[FlinkMaterializedTableColumnArgs]] = None,
        compute_pool: Optional[FlinkMaterializedTableComputePoolArgs] = None,
        constraints: Optional[Sequence[FlinkMaterializedTableConstraintArgs]] = None,
        credentials: Optional[FlinkMaterializedTableCredentialsArgs] = None,
        display_name: Optional[str] = None,
        distribution: Optional[FlinkMaterializedTableDistributionArgs] = None,
        environment: Optional[FlinkMaterializedTableEnvironmentArgs] = None,
        kafka_cluster: Optional[FlinkMaterializedTableKafkaClusterArgs] = None,
        organization: Optional[FlinkMaterializedTableOrganizationArgs] = None,
        principal: Optional[FlinkMaterializedTablePrincipalArgs] = None,
        query: Optional[str] = None,
        rest_endpoint: Optional[str] = None,
        stopped: Optional[bool] = None,
        watermark: Optional[FlinkMaterializedTableWatermarkArgs] = None) -> FlinkMaterializedTable

func GetFlinkMaterializedTable(ctx *Context, name string, id IDInput, state *FlinkMaterializedTableState, opts ...ResourceOption) (*FlinkMaterializedTable, error)

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

public static FlinkMaterializedTable get(String name, Output<String> id, FlinkMaterializedTableState state, CustomResourceOptions options)

resources:  _:    type: confluentcloud:FlinkMaterializedTable    get:      id: ${id}

import {
  to = confluentcloud_flinkmaterializedtable.example
  id = "${id}"
}

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

resource_name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

The following state arguments are supported:

Columns List<Pulumi.ConfluentCloud.Inputs.FlinkMaterializedTableColumn>: A list of column definitions. Each columns block supports the following sub-blocks:
ComputePool Pulumi.ConfluentCloud.Inputs.FlinkMaterializedTableComputePool
Constraints List<Pulumi.ConfluentCloud.Inputs.FlinkMaterializedTableConstraint>
Credentials Pulumi.ConfluentCloud.Inputs.FlinkMaterializedTableCredentials: The Cluster API Credentials.
DisplayName string: The unique name of the Materialized Table.
Distribution Pulumi.ConfluentCloud.Inputs.FlinkMaterializedTableDistribution: The distribution definition for the Materialized Table. Supports the following:
Environment Pulumi.ConfluentCloud.Inputs.FlinkMaterializedTableEnvironment
KafkaCluster Pulumi.ConfluentCloud.Inputs.FlinkMaterializedTableKafkaCluster
Organization Pulumi.ConfluentCloud.Inputs.FlinkMaterializedTableOrganization
Principal Pulumi.ConfluentCloud.Inputs.FlinkMaterializedTablePrincipal
Query string: The SQL query that defines the Materialized Table, for example, SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;.
RestEndpoint string: The REST endpoint of the Flink region, for example, https://flink.us-east-1.aws.confluent.cloud.
Stopped bool: Indicates whether the Materialized Table is stopped. Defaults to false. Update it to true to stop the Materialized Table. Subsequently update it to false to resume it.
Watermark Pulumi.ConfluentCloud.Inputs.FlinkMaterializedTableWatermark: The watermark definition for the Materialized Table. Supports the following:

Columns []FlinkMaterializedTableColumnArgs: A list of column definitions. Each columns block supports the following sub-blocks:
ComputePool FlinkMaterializedTableComputePoolArgs
Constraints []FlinkMaterializedTableConstraintArgs
Credentials FlinkMaterializedTableCredentialsArgs: The Cluster API Credentials.
DisplayName string: The unique name of the Materialized Table.
Distribution FlinkMaterializedTableDistributionArgs: The distribution definition for the Materialized Table. Supports the following:
Environment FlinkMaterializedTableEnvironmentArgs
KafkaCluster FlinkMaterializedTableKafkaClusterArgs
Organization FlinkMaterializedTableOrganizationArgs
Principal FlinkMaterializedTablePrincipalArgs
Query string: The SQL query that defines the Materialized Table, for example, SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;.
RestEndpoint string: The REST endpoint of the Flink region, for example, https://flink.us-east-1.aws.confluent.cloud.
Stopped bool: Indicates whether the Materialized Table is stopped. Defaults to false. Update it to true to stop the Materialized Table. Subsequently update it to false to resume it.
Watermark FlinkMaterializedTableWatermarkArgs: The watermark definition for the Materialized Table. Supports the following:

columns list(object): A list of column definitions. Each columns block supports the following sub-blocks:
compute_pool object
constraints list(object)
credentials object: The Cluster API Credentials.
display_name string: The unique name of the Materialized Table.
distribution object: The distribution definition for the Materialized Table. Supports the following:
environment object
kafka_cluster object
organization object
principal object
query string: The SQL query that defines the Materialized Table, for example, SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;.
rest_endpoint string: The REST endpoint of the Flink region, for example, https://flink.us-east-1.aws.confluent.cloud.
stopped bool: Indicates whether the Materialized Table is stopped. Defaults to false. Update it to true to stop the Materialized Table. Subsequently update it to false to resume it.
watermark object: The watermark definition for the Materialized Table. Supports the following:

columns List<FlinkMaterializedTableColumn>: A list of column definitions. Each columns block supports the following sub-blocks:
computePool FlinkMaterializedTableComputePool
constraints List<FlinkMaterializedTableConstraint>
credentials FlinkMaterializedTableCredentials: The Cluster API Credentials.
displayName String: The unique name of the Materialized Table.
distribution FlinkMaterializedTableDistribution: The distribution definition for the Materialized Table. Supports the following:
environment FlinkMaterializedTableEnvironment
kafkaCluster FlinkMaterializedTableKafkaCluster
organization FlinkMaterializedTableOrganization
principal FlinkMaterializedTablePrincipal
query String: The SQL query that defines the Materialized Table, for example, SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;.
restEndpoint String: The REST endpoint of the Flink region, for example, https://flink.us-east-1.aws.confluent.cloud.
stopped Boolean: Indicates whether the Materialized Table is stopped. Defaults to false. Update it to true to stop the Materialized Table. Subsequently update it to false to resume it.
watermark FlinkMaterializedTableWatermark: The watermark definition for the Materialized Table. Supports the following:

columns FlinkMaterializedTableColumn[]: A list of column definitions. Each columns block supports the following sub-blocks:
computePool FlinkMaterializedTableComputePool
constraints FlinkMaterializedTableConstraint[]
credentials FlinkMaterializedTableCredentials: The Cluster API Credentials.
displayName string: The unique name of the Materialized Table.
distribution FlinkMaterializedTableDistribution: The distribution definition for the Materialized Table. Supports the following:
environment FlinkMaterializedTableEnvironment
kafkaCluster FlinkMaterializedTableKafkaCluster
organization FlinkMaterializedTableOrganization
principal FlinkMaterializedTablePrincipal
query string: The SQL query that defines the Materialized Table, for example, SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;.
restEndpoint string: The REST endpoint of the Flink region, for example, https://flink.us-east-1.aws.confluent.cloud.
stopped boolean: Indicates whether the Materialized Table is stopped. Defaults to false. Update it to true to stop the Materialized Table. Subsequently update it to false to resume it.
watermark FlinkMaterializedTableWatermark: The watermark definition for the Materialized Table. Supports the following:

columns Sequence[FlinkMaterializedTableColumnArgs]: A list of column definitions. Each columns block supports the following sub-blocks:
compute_pool FlinkMaterializedTableComputePoolArgs
constraints Sequence[FlinkMaterializedTableConstraintArgs]
credentials FlinkMaterializedTableCredentialsArgs: The Cluster API Credentials.
display_name str: The unique name of the Materialized Table.
distribution FlinkMaterializedTableDistributionArgs: The distribution definition for the Materialized Table. Supports the following:
environment FlinkMaterializedTableEnvironmentArgs
kafka_cluster FlinkMaterializedTableKafkaClusterArgs
organization FlinkMaterializedTableOrganizationArgs
principal FlinkMaterializedTablePrincipalArgs
query str: The SQL query that defines the Materialized Table, for example, SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;.
rest_endpoint str: The REST endpoint of the Flink region, for example, https://flink.us-east-1.aws.confluent.cloud.
stopped bool: Indicates whether the Materialized Table is stopped. Defaults to false. Update it to true to stop the Materialized Table. Subsequently update it to false to resume it.
watermark FlinkMaterializedTableWatermarkArgs: The watermark definition for the Materialized Table. Supports the following:

columns List<Property Map>: A list of column definitions. Each columns block supports the following sub-blocks:
computePool Property Map
constraints List<Property Map>
credentials Property Map: The Cluster API Credentials.
displayName String: The unique name of the Materialized Table.
distribution Property Map: The distribution definition for the Materialized Table. Supports the following:
environment Property Map
kafkaCluster Property Map
organization Property Map
principal Property Map
query String: The SQL query that defines the Materialized Table, for example, SELECT user_id, product_id, price, quantity FROM orders WHERE price > 1000;.
restEndpoint String: The REST endpoint of the Flink region, for example, https://flink.us-east-1.aws.confluent.cloud.
stopped Boolean: Indicates whether the Materialized Table is stopped. Defaults to false. Update it to true to stop the Materialized Table. Subsequently update it to false to resume it.
watermark Property Map: The watermark definition for the Materialized Table. Supports the following:

Supporting Types

FlinkMaterializedTableColumn, FlinkMaterializedTableColumnArgs

ColumnsComputeds List<Pulumi.ConfluentCloud.Inputs.FlinkMaterializedTableColumnColumnsComputed>: Computed column definitions. Each block supports:
ColumnsMetadatas List<Pulumi.ConfluentCloud.Inputs.FlinkMaterializedTableColumnColumnsMetadata>: Metadata column definitions. Each block supports:
ColumnsPhysicals List<Pulumi.ConfluentCloud.Inputs.FlinkMaterializedTableColumnColumnsPhysical>: Physical column definitions. Each block supports:

ColumnsComputeds []FlinkMaterializedTableColumnColumnsComputed: Computed column definitions. Each block supports:
ColumnsMetadatas []FlinkMaterializedTableColumnColumnsMetadata: Metadata column definitions. Each block supports:
ColumnsPhysicals []FlinkMaterializedTableColumnColumnsPhysical: Physical column definitions. Each block supports:

columns_computeds list(object): Computed column definitions. Each block supports:
columns_metadatas list(object): Metadata column definitions. Each block supports:
columns_physicals list(object): Physical column definitions. Each block supports:

columnsComputeds List<FlinkMaterializedTableColumnColumnsComputed>: Computed column definitions. Each block supports:
columnsMetadatas List<FlinkMaterializedTableColumnColumnsMetadata>: Metadata column definitions. Each block supports:
columnsPhysicals List<FlinkMaterializedTableColumnColumnsPhysical>: Physical column definitions. Each block supports:

columnsComputeds FlinkMaterializedTableColumnColumnsComputed[]: Computed column definitions. Each block supports:
columnsMetadatas FlinkMaterializedTableColumnColumnsMetadata[]: Metadata column definitions. Each block supports:
columnsPhysicals FlinkMaterializedTableColumnColumnsPhysical[]: Physical column definitions. Each block supports:

columns_computeds Sequence[FlinkMaterializedTableColumnColumnsComputed]: Computed column definitions. Each block supports:
columns_metadatas Sequence[FlinkMaterializedTableColumnColumnsMetadata]: Metadata column definitions. Each block supports:
columns_physicals Sequence[FlinkMaterializedTableColumnColumnsPhysical]: Physical column definitions. Each block supports:

columnsComputeds List<Property Map>: Computed column definitions. Each block supports:
columnsMetadatas List<Property Map>: Metadata column definitions. Each block supports:
columnsPhysicals List<Property Map>: Physical column definitions. Each block supports:

FlinkMaterializedTableColumnColumnsComputed, FlinkMaterializedTableColumnColumnsComputedArgs

ColumnComputedComment string: Comment for the computed column.
ColumnComputedExpression string: Expression of the computed column.
ColumnComputedKind string: Kind of the computed column.
ColumnComputedName string: Name of the computed column.
ColumnComputedType string: Type of the computed column.
ColumnComputedVirtual bool: Whether the computed column is virtual. Defaults to false.

ColumnComputedComment string: Comment for the computed column.
ColumnComputedExpression string: Expression of the computed column.
ColumnComputedKind string: Kind of the computed column.
ColumnComputedName string: Name of the computed column.
ColumnComputedType string: Type of the computed column.
ColumnComputedVirtual bool: Whether the computed column is virtual. Defaults to false.

column_computed_comment string: Comment for the computed column.
column_computed_expression string: Expression of the computed column.
column_computed_kind string: Kind of the computed column.
column_computed_name string: Name of the computed column.
column_computed_type string: Type of the computed column.
column_computed_virtual bool: Whether the computed column is virtual. Defaults to false.

columnComputedComment String: Comment for the computed column.
columnComputedExpression String: Expression of the computed column.
columnComputedKind String: Kind of the computed column.
columnComputedName String: Name of the computed column.
columnComputedType String: Type of the computed column.
columnComputedVirtual Boolean: Whether the computed column is virtual. Defaults to false.

columnComputedComment string: Comment for the computed column.
columnComputedExpression string: Expression of the computed column.
columnComputedKind string: Kind of the computed column.
columnComputedName string: Name of the computed column.
columnComputedType string: Type of the computed column.
columnComputedVirtual boolean: Whether the computed column is virtual. Defaults to false.

column_computed_comment str: Comment for the computed column.
column_computed_expression str: Expression of the computed column.
column_computed_kind str: Kind of the computed column.
column_computed_name str: Name of the computed column.
column_computed_type str: Type of the computed column.
column_computed_virtual bool: Whether the computed column is virtual. Defaults to false.

columnComputedComment String: Comment for the computed column.
columnComputedExpression String: Expression of the computed column.
columnComputedKind String: Kind of the computed column.
columnComputedName String: Name of the computed column.
columnComputedType String: Type of the computed column.
columnComputedVirtual Boolean: Whether the computed column is virtual. Defaults to false.

FlinkMaterializedTableColumnColumnsMetadata, FlinkMaterializedTableColumnColumnsMetadataArgs

ColumnMetadataComment string

Comment for the metadata column.

ColumnMetadataKey string

Metadata key of the metadata column.

ColumnMetadataKind string

Kind of the metadata column.

ColumnMetadataName string

Name of the metadata column.

ColumnMetadataType string

Type of the metadata column.

ColumnMetadataVirtual bool

Whether the metadata column is virtual. Defaults to false.

Note: A Flink API key consists of a key and a secret. Flink API keys are required to interact with Flink Materialized Tables in Confluent Cloud. Each Flink API key is valid for one specific Flink Region.

Note: Use Option #2 to simplify the key rotation process. When using Option #1, to rotate a Flink API key, create a new Flink API key, update the credentials block in all configuration files to use the new Flink API key, run pulumi up -target="confluent_flink_materialized_table.example", and remove the old Flink API key. Alternatively, in case the old Flink API Key was deleted already, you might need to run pulumi preview -refresh=false -target="confluent_flink_materialized_table.example" -out=rotate-flink-api-key and pulumi up rotate-flink-api-key instead.

!> Warning: Use Option #2 to avoid exposing sensitive credentials value in a state file. When using Option #1, Terraform doesn't encrypt the sensitive credentials value of the confluentcloud.FlinkMaterializedTable resource, so you must keep your state file secure to avoid exposing it. Refer to the Terraform documentation to learn more about securing your state file.

Note: When using OAuth to authenticate a Flink Materialized Table, if the intended principal.id is a service account instead of an Identity Pool, make sure the Identity Pool has an Assigner role binding on the service account. Otherwise, you may encounter a 403 Forbidden error. For example:

import * as pulumi from "@pulumi/pulumi";
import * as confluentcloud from "@pulumi/confluentcloud";
const identity_pool_assigner = new confluentcloud.RoleBinding("identity-pool-assigner", {
principal: "User:pool-abc123",
roleName: "Assigner",
crnPattern: ${main.resourceName}/service-account=sa-def456,
});

import pulumi
import pulumi_confluentcloud as confluentcloud

identity_pool_assigner = confluentcloud.RoleBinding("identity-pool-assigner",
    principal="User:pool-abc123",
    role_name="Assigner",
    crn_pattern=f"{main['resourceName']}/service-account=sa-def456")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using ConfluentCloud = Pulumi.ConfluentCloud;

return await Deployment.RunAsync(() => 
{
    var identity_pool_assigner = new ConfluentCloud.RoleBinding("identity-pool-assigner", new()
    {
        Principal = "User:pool-abc123",
        RoleName = "Assigner",
        CrnPattern = $"{main.ResourceName}/service-account=sa-def456",
    });

});

package main

import (
	"github.com/pulumi/pulumi-confluentcloud/sdk/v2/go/confluentcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := confluentcloud.NewRoleBinding(ctx, "identity-pool-assigner", &confluentcloud.RoleBindingArgs{
			Principal:  pulumi.String("User:pool-abc123"),
			RoleName:   pulumi.String("Assigner"),
			CrnPattern: pulumi.Sprintf("%v/service-account=sa-def456", main.ResourceName),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.confluentcloud.RoleBinding;
import com.pulumi.confluentcloud.RoleBindingArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var identity_pool_assigner = new RoleBinding("identity-pool-assigner", RoleBindingArgs.builder()
            .principal("User:pool-abc123")
            .roleName("Assigner")
            .crnPattern(String.format("%s/service-account=sa-def456", main.resourceName()))
            .build());

    }
}

resources:
  identity-pool-assigner:
    type: confluentcloud:RoleBinding
    properties:
      principal: User:pool-abc123
      roleName: Assigner
      crnPattern: ${main.resourceName}/service-account=sa-def456

ColumnMetadataComment string

Comment for the metadata column.

ColumnMetadataKey string

Metadata key of the metadata column.

ColumnMetadataKind string

Kind of the metadata column.

ColumnMetadataName string

Name of the metadata column.

ColumnMetadataType string

Type of the metadata column.

ColumnMetadataVirtual bool

Whether the metadata column is virtual. Defaults to false.

Note: A Flink API key consists of a key and a secret. Flink API keys are required to interact with Flink Materialized Tables in Confluent Cloud. Each Flink API key is valid for one specific Flink Region.

Note: Use Option #2 to simplify the key rotation process. When using Option #1, to rotate a Flink API key, create a new Flink API key, update the credentials block in all configuration files to use the new Flink API key, run pulumi up -target="confluent_flink_materialized_table.example", and remove the old Flink API key. Alternatively, in case the old Flink API Key was deleted already, you might need to run pulumi preview -refresh=false -target="confluent_flink_materialized_table.example" -out=rotate-flink-api-key and pulumi up rotate-flink-api-key instead.

Note: When using OAuth to authenticate a Flink Materialized Table, if the intended principal.id is a service account instead of an Identity Pool, make sure the Identity Pool has an Assigner role binding on the service account. Otherwise, you may encounter a 403 Forbidden error. For example:

import * as pulumi from "@pulumi/pulumi";
import * as confluentcloud from "@pulumi/confluentcloud";
const identity_pool_assigner = new confluentcloud.RoleBinding("identity-pool-assigner", {
principal: "User:pool-abc123",
roleName: "Assigner",
crnPattern: ${main.resourceName}/service-account=sa-def456,
});

import pulumi
import pulumi_confluentcloud as confluentcloud

identity_pool_assigner = confluentcloud.RoleBinding("identity-pool-assigner",
    principal="User:pool-abc123",
    role_name="Assigner",
    crn_pattern=f"{main['resourceName']}/service-account=sa-def456")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using ConfluentCloud = Pulumi.ConfluentCloud;

return await Deployment.RunAsync(() => 
{
    var identity_pool_assigner = new ConfluentCloud.RoleBinding("identity-pool-assigner", new()
    {
        Principal = "User:pool-abc123",
        RoleName = "Assigner",
        CrnPattern = $"{main.ResourceName}/service-account=sa-def456",
    });

});

package main

import (
	"github.com/pulumi/pulumi-confluentcloud/sdk/v2/go/confluentcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := confluentcloud.NewRoleBinding(ctx, "identity-pool-assigner", &confluentcloud.RoleBindingArgs{
			Principal:  pulumi.String("User:pool-abc123"),
			RoleName:   pulumi.String("Assigner"),
			CrnPattern: pulumi.Sprintf("%v/service-account=sa-def456", main.ResourceName),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.confluentcloud.RoleBinding;
import com.pulumi.confluentcloud.RoleBindingArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var identity_pool_assigner = new RoleBinding("identity-pool-assigner", RoleBindingArgs.builder()
            .principal("User:pool-abc123")
            .roleName("Assigner")
            .crnPattern(String.format("%s/service-account=sa-def456", main.resourceName()))
            .build());

    }
}

resources:
  identity-pool-assigner:
    type: confluentcloud:RoleBinding
    properties:
      principal: User:pool-abc123
      roleName: Assigner
      crnPattern: ${main.resourceName}/service-account=sa-def456

column_metadata_comment string

Comment for the metadata column.

column_metadata_key string

Metadata key of the metadata column.

column_metadata_kind string

Kind of the metadata column.

column_metadata_name string

Name of the metadata column.

column_metadata_type string

Type of the metadata column.

column_metadata_virtual bool

Whether the metadata column is virtual. Defaults to false.

Note: A Flink API key consists of a key and a secret. Flink API keys are required to interact with Flink Materialized Tables in Confluent Cloud. Each Flink API key is valid for one specific Flink Region.

Note: Use Option #2 to simplify the key rotation process. When using Option #1, to rotate a Flink API key, create a new Flink API key, update the credentials block in all configuration files to use the new Flink API key, run pulumi up -target="confluent_flink_materialized_table.example", and remove the old Flink API key. Alternatively, in case the old Flink API Key was deleted already, you might need to run pulumi preview -refresh=false -target="confluent_flink_materialized_table.example" -out=rotate-flink-api-key and pulumi up rotate-flink-api-key instead.

Note: When using OAuth to authenticate a Flink Materialized Table, if the intended principal.id is a service account instead of an Identity Pool, make sure the Identity Pool has an Assigner role binding on the service account. Otherwise, you may encounter a 403 Forbidden error. For example:

import * as pulumi from "@pulumi/pulumi";
import * as confluentcloud from "@pulumi/confluentcloud";
const identity_pool_assigner = new confluentcloud.RoleBinding("identity-pool-assigner", {
principal: "User:pool-abc123",
roleName: "Assigner",
crnPattern: ${main.resourceName}/service-account=sa-def456,
});

import pulumi
import pulumi_confluentcloud as confluentcloud

identity_pool_assigner = confluentcloud.RoleBinding("identity-pool-assigner",
    principal="User:pool-abc123",
    role_name="Assigner",
    crn_pattern=f"{main['resourceName']}/service-account=sa-def456")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using ConfluentCloud = Pulumi.ConfluentCloud;

return await Deployment.RunAsync(() => 
{
    var identity_pool_assigner = new ConfluentCloud.RoleBinding("identity-pool-assigner", new()
    {
        Principal = "User:pool-abc123",
        RoleName = "Assigner",
        CrnPattern = $"{main.ResourceName}/service-account=sa-def456",
    });

});

package main

import (
	"github.com/pulumi/pulumi-confluentcloud/sdk/v2/go/confluentcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := confluentcloud.NewRoleBinding(ctx, "identity-pool-assigner", &confluentcloud.RoleBindingArgs{
			Principal:  pulumi.String("User:pool-abc123"),
			RoleName:   pulumi.String("Assigner"),
			CrnPattern: pulumi.Sprintf("%v/service-account=sa-def456", main.ResourceName),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.confluentcloud.RoleBinding;
import com.pulumi.confluentcloud.RoleBindingArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var identity_pool_assigner = new RoleBinding("identity-pool-assigner", RoleBindingArgs.builder()
            .principal("User:pool-abc123")
            .roleName("Assigner")
            .crnPattern(String.format("%s/service-account=sa-def456", main.resourceName()))
            .build());

    }
}

resources:
  identity-pool-assigner:
    type: confluentcloud:RoleBinding
    properties:
      principal: User:pool-abc123
      roleName: Assigner
      crnPattern: ${main.resourceName}/service-account=sa-def456

columnMetadataComment String

Comment for the metadata column.

columnMetadataKey String

Metadata key of the metadata column.

columnMetadataKind String

Kind of the metadata column.

columnMetadataName String

Name of the metadata column.

columnMetadataType String

Type of the metadata column.

columnMetadataVirtual Boolean

Whether the metadata column is virtual. Defaults to false.

Note: A Flink API key consists of a key and a secret. Flink API keys are required to interact with Flink Materialized Tables in Confluent Cloud. Each Flink API key is valid for one specific Flink Region.

Note: Use Option #2 to simplify the key rotation process. When using Option #1, to rotate a Flink API key, create a new Flink API key, update the credentials block in all configuration files to use the new Flink API key, run pulumi up -target="confluent_flink_materialized_table.example", and remove the old Flink API key. Alternatively, in case the old Flink API Key was deleted already, you might need to run pulumi preview -refresh=false -target="confluent_flink_materialized_table.example" -out=rotate-flink-api-key and pulumi up rotate-flink-api-key instead.

Note: When using OAuth to authenticate a Flink Materialized Table, if the intended principal.id is a service account instead of an Identity Pool, make sure the Identity Pool has an Assigner role binding on the service account. Otherwise, you may encounter a 403 Forbidden error. For example:

import * as pulumi from "@pulumi/pulumi";
import * as confluentcloud from "@pulumi/confluentcloud";
const identity_pool_assigner = new confluentcloud.RoleBinding("identity-pool-assigner", {
principal: "User:pool-abc123",
roleName: "Assigner",
crnPattern: ${main.resourceName}/service-account=sa-def456,
});

import pulumi
import pulumi_confluentcloud as confluentcloud

identity_pool_assigner = confluentcloud.RoleBinding("identity-pool-assigner",
    principal="User:pool-abc123",
    role_name="Assigner",
    crn_pattern=f"{main['resourceName']}/service-account=sa-def456")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using ConfluentCloud = Pulumi.ConfluentCloud;

return await Deployment.RunAsync(() => 
{
    var identity_pool_assigner = new ConfluentCloud.RoleBinding("identity-pool-assigner", new()
    {
        Principal = "User:pool-abc123",
        RoleName = "Assigner",
        CrnPattern = $"{main.ResourceName}/service-account=sa-def456",
    });

});

package main

import (
	"github.com/pulumi/pulumi-confluentcloud/sdk/v2/go/confluentcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := confluentcloud.NewRoleBinding(ctx, "identity-pool-assigner", &confluentcloud.RoleBindingArgs{
			Principal:  pulumi.String("User:pool-abc123"),
			RoleName:   pulumi.String("Assigner"),
			CrnPattern: pulumi.Sprintf("%v/service-account=sa-def456", main.ResourceName),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.confluentcloud.RoleBinding;
import com.pulumi.confluentcloud.RoleBindingArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var identity_pool_assigner = new RoleBinding("identity-pool-assigner", RoleBindingArgs.builder()
            .principal("User:pool-abc123")
            .roleName("Assigner")
            .crnPattern(String.format("%s/service-account=sa-def456", main.resourceName()))
            .build());

    }
}

resources:
  identity-pool-assigner:
    type: confluentcloud:RoleBinding
    properties:
      principal: User:pool-abc123
      roleName: Assigner
      crnPattern: ${main.resourceName}/service-account=sa-def456

columnMetadataComment string

Comment for the metadata column.

columnMetadataKey string

Metadata key of the metadata column.

columnMetadataKind string

Kind of the metadata column.

columnMetadataName string

Name of the metadata column.

columnMetadataType string

Type of the metadata column.

columnMetadataVirtual boolean

Whether the metadata column is virtual. Defaults to false.

Note: A Flink API key consists of a key and a secret. Flink API keys are required to interact with Flink Materialized Tables in Confluent Cloud. Each Flink API key is valid for one specific Flink Region.

Note: Use Option #2 to simplify the key rotation process. When using Option #1, to rotate a Flink API key, create a new Flink API key, update the credentials block in all configuration files to use the new Flink API key, run pulumi up -target="confluent_flink_materialized_table.example", and remove the old Flink API key. Alternatively, in case the old Flink API Key was deleted already, you might need to run pulumi preview -refresh=false -target="confluent_flink_materialized_table.example" -out=rotate-flink-api-key and pulumi up rotate-flink-api-key instead.

Note: When using OAuth to authenticate a Flink Materialized Table, if the intended principal.id is a service account instead of an Identity Pool, make sure the Identity Pool has an Assigner role binding on the service account. Otherwise, you may encounter a 403 Forbidden error. For example:

import * as pulumi from "@pulumi/pulumi";
import * as confluentcloud from "@pulumi/confluentcloud";
const identity_pool_assigner = new confluentcloud.RoleBinding("identity-pool-assigner", {
principal: "User:pool-abc123",
roleName: "Assigner",
crnPattern: ${main.resourceName}/service-account=sa-def456,
});

import pulumi
import pulumi_confluentcloud as confluentcloud

identity_pool_assigner = confluentcloud.RoleBinding("identity-pool-assigner",
    principal="User:pool-abc123",
    role_name="Assigner",
    crn_pattern=f"{main['resourceName']}/service-account=sa-def456")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using ConfluentCloud = Pulumi.ConfluentCloud;

return await Deployment.RunAsync(() => 
{
    var identity_pool_assigner = new ConfluentCloud.RoleBinding("identity-pool-assigner", new()
    {
        Principal = "User:pool-abc123",
        RoleName = "Assigner",
        CrnPattern = $"{main.ResourceName}/service-account=sa-def456",
    });

});

package main

import (
	"github.com/pulumi/pulumi-confluentcloud/sdk/v2/go/confluentcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := confluentcloud.NewRoleBinding(ctx, "identity-pool-assigner", &confluentcloud.RoleBindingArgs{
			Principal:  pulumi.String("User:pool-abc123"),
			RoleName:   pulumi.String("Assigner"),
			CrnPattern: pulumi.Sprintf("%v/service-account=sa-def456", main.ResourceName),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.confluentcloud.RoleBinding;
import com.pulumi.confluentcloud.RoleBindingArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var identity_pool_assigner = new RoleBinding("identity-pool-assigner", RoleBindingArgs.builder()
            .principal("User:pool-abc123")
            .roleName("Assigner")
            .crnPattern(String.format("%s/service-account=sa-def456", main.resourceName()))
            .build());

    }
}

resources:
  identity-pool-assigner:
    type: confluentcloud:RoleBinding
    properties:
      principal: User:pool-abc123
      roleName: Assigner
      crnPattern: ${main.resourceName}/service-account=sa-def456

column_metadata_comment str

Comment for the metadata column.

column_metadata_key str

Metadata key of the metadata column.

column_metadata_kind str

Kind of the metadata column.

column_metadata_name str

Name of the metadata column.

column_metadata_type str

Type of the metadata column.

column_metadata_virtual bool

Whether the metadata column is virtual. Defaults to false.

Note: A Flink API key consists of a key and a secret. Flink API keys are required to interact with Flink Materialized Tables in Confluent Cloud. Each Flink API key is valid for one specific Flink Region.

Note: Use Option #2 to simplify the key rotation process. When using Option #1, to rotate a Flink API key, create a new Flink API key, update the credentials block in all configuration files to use the new Flink API key, run pulumi up -target="confluent_flink_materialized_table.example", and remove the old Flink API key. Alternatively, in case the old Flink API Key was deleted already, you might need to run pulumi preview -refresh=false -target="confluent_flink_materialized_table.example" -out=rotate-flink-api-key and pulumi up rotate-flink-api-key instead.

Note: When using OAuth to authenticate a Flink Materialized Table, if the intended principal.id is a service account instead of an Identity Pool, make sure the Identity Pool has an Assigner role binding on the service account. Otherwise, you may encounter a 403 Forbidden error. For example:

import * as pulumi from "@pulumi/pulumi";
import * as confluentcloud from "@pulumi/confluentcloud";
const identity_pool_assigner = new confluentcloud.RoleBinding("identity-pool-assigner", {
principal: "User:pool-abc123",
roleName: "Assigner",
crnPattern: ${main.resourceName}/service-account=sa-def456,
});

import pulumi
import pulumi_confluentcloud as confluentcloud

identity_pool_assigner = confluentcloud.RoleBinding("identity-pool-assigner",
    principal="User:pool-abc123",
    role_name="Assigner",
    crn_pattern=f"{main['resourceName']}/service-account=sa-def456")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using ConfluentCloud = Pulumi.ConfluentCloud;

return await Deployment.RunAsync(() => 
{
    var identity_pool_assigner = new ConfluentCloud.RoleBinding("identity-pool-assigner", new()
    {
        Principal = "User:pool-abc123",
        RoleName = "Assigner",
        CrnPattern = $"{main.ResourceName}/service-account=sa-def456",
    });

});

package main

import (
	"github.com/pulumi/pulumi-confluentcloud/sdk/v2/go/confluentcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := confluentcloud.NewRoleBinding(ctx, "identity-pool-assigner", &confluentcloud.RoleBindingArgs{
			Principal:  pulumi.String("User:pool-abc123"),
			RoleName:   pulumi.String("Assigner"),
			CrnPattern: pulumi.Sprintf("%v/service-account=sa-def456", main.ResourceName),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.confluentcloud.RoleBinding;
import com.pulumi.confluentcloud.RoleBindingArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var identity_pool_assigner = new RoleBinding("identity-pool-assigner", RoleBindingArgs.builder()
            .principal("User:pool-abc123")
            .roleName("Assigner")
            .crnPattern(String.format("%s/service-account=sa-def456", main.resourceName()))
            .build());

    }
}

resources:
  identity-pool-assigner:
    type: confluentcloud:RoleBinding
    properties:
      principal: User:pool-abc123
      roleName: Assigner
      crnPattern: ${main.resourceName}/service-account=sa-def456

columnMetadataComment String

Comment for the metadata column.

columnMetadataKey String

Metadata key of the metadata column.

columnMetadataKind String

Kind of the metadata column.

columnMetadataName String

Name of the metadata column.

columnMetadataType String

Type of the metadata column.

columnMetadataVirtual Boolean

Whether the metadata column is virtual. Defaults to false.

Note: A Flink API key consists of a key and a secret. Flink API keys are required to interact with Flink Materialized Tables in Confluent Cloud. Each Flink API key is valid for one specific Flink Region.

Note: Use Option #2 to simplify the key rotation process. When using Option #1, to rotate a Flink API key, create a new Flink API key, update the credentials block in all configuration files to use the new Flink API key, run pulumi up -target="confluent_flink_materialized_table.example", and remove the old Flink API key. Alternatively, in case the old Flink API Key was deleted already, you might need to run pulumi preview -refresh=false -target="confluent_flink_materialized_table.example" -out=rotate-flink-api-key and pulumi up rotate-flink-api-key instead.

Note: When using OAuth to authenticate a Flink Materialized Table, if the intended principal.id is a service account instead of an Identity Pool, make sure the Identity Pool has an Assigner role binding on the service account. Otherwise, you may encounter a 403 Forbidden error. For example:

import * as pulumi from "@pulumi/pulumi";
import * as confluentcloud from "@pulumi/confluentcloud";
const identity_pool_assigner = new confluentcloud.RoleBinding("identity-pool-assigner", {
principal: "User:pool-abc123",
roleName: "Assigner",
crnPattern: ${main.resourceName}/service-account=sa-def456,
});

import pulumi
import pulumi_confluentcloud as confluentcloud

identity_pool_assigner = confluentcloud.RoleBinding("identity-pool-assigner",
    principal="User:pool-abc123",
    role_name="Assigner",
    crn_pattern=f"{main['resourceName']}/service-account=sa-def456")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using ConfluentCloud = Pulumi.ConfluentCloud;

return await Deployment.RunAsync(() => 
{
    var identity_pool_assigner = new ConfluentCloud.RoleBinding("identity-pool-assigner", new()
    {
        Principal = "User:pool-abc123",
        RoleName = "Assigner",
        CrnPattern = $"{main.ResourceName}/service-account=sa-def456",
    });

});

package main

import (
	"github.com/pulumi/pulumi-confluentcloud/sdk/v2/go/confluentcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := confluentcloud.NewRoleBinding(ctx, "identity-pool-assigner", &confluentcloud.RoleBindingArgs{
			Principal:  pulumi.String("User:pool-abc123"),
			RoleName:   pulumi.String("Assigner"),
			CrnPattern: pulumi.Sprintf("%v/service-account=sa-def456", main.ResourceName),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.confluentcloud.RoleBinding;
import com.pulumi.confluentcloud.RoleBindingArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var identity_pool_assigner = new RoleBinding("identity-pool-assigner", RoleBindingArgs.builder()
            .principal("User:pool-abc123")
            .roleName("Assigner")
            .crnPattern(String.format("%s/service-account=sa-def456", main.resourceName()))
            .build());

    }
}

resources:
  identity-pool-assigner:
    type: confluentcloud:RoleBinding
    properties:
      principal: User:pool-abc123
      roleName: Assigner
      crnPattern: ${main.resourceName}/service-account=sa-def456

FlinkMaterializedTableColumnColumnsPhysical, FlinkMaterializedTableColumnColumnsPhysicalArgs

ColumnPhysicalComment string: Comment for the physical column.
ColumnPhysicalKind string: Kind of the physical column.
ColumnPhysicalName string: Name of the physical column.
ColumnPhysicalType string: Type of the physical column.

ColumnPhysicalComment string: Comment for the physical column.
ColumnPhysicalKind string: Kind of the physical column.
ColumnPhysicalName string: Name of the physical column.
ColumnPhysicalType string: Type of the physical column.

column_physical_comment string: Comment for the physical column.
column_physical_kind string: Kind of the physical column.
column_physical_name string: Name of the physical column.
column_physical_type string: Type of the physical column.

columnPhysicalComment String: Comment for the physical column.
columnPhysicalKind String: Kind of the physical column.
columnPhysicalName String: Name of the physical column.
columnPhysicalType String: Type of the physical column.

columnPhysicalComment string: Comment for the physical column.
columnPhysicalKind string: Kind of the physical column.
columnPhysicalName string: Name of the physical column.
columnPhysicalType string: Type of the physical column.

column_physical_comment str: Comment for the physical column.
column_physical_kind str: Kind of the physical column.
column_physical_name str: Name of the physical column.
column_physical_type str: Type of the physical column.

columnPhysicalComment String: Comment for the physical column.
columnPhysicalKind String: Kind of the physical column.
columnPhysicalName String: Name of the physical column.
columnPhysicalType String: Type of the physical column.

FlinkMaterializedTableComputePool, FlinkMaterializedTableComputePoolArgs

Id string: The ID of the Flink Compute Pool, for example, lfcp-abc123.

Id string: The ID of the Flink Compute Pool, for example, lfcp-abc123.

id string: The ID of the Flink Compute Pool, for example, lfcp-abc123.

id String: The ID of the Flink Compute Pool, for example, lfcp-abc123.

id string: The ID of the Flink Compute Pool, for example, lfcp-abc123.

id str: The ID of the Flink Compute Pool, for example, lfcp-abc123.

id String: The ID of the Flink Compute Pool, for example, lfcp-abc123.

FlinkMaterializedTableConstraint, FlinkMaterializedTableConstraintArgs

Columns List<string>: The column names of the constraint.
Enforced bool: Whether the constraint is enforced. Defaults to false.
Name string: The name of the constraint, for example, pkOrders.
Type string: The type of the constraint, for example, PRIMARY_KEY.

Columns []string: The column names of the constraint.
Enforced bool: Whether the constraint is enforced. Defaults to false.
Name string: The name of the constraint, for example, pkOrders.
Type string: The type of the constraint, for example, PRIMARY_KEY.

columns list(string): The column names of the constraint.
enforced bool: Whether the constraint is enforced. Defaults to false.
name string: The name of the constraint, for example, pkOrders.
type string: The type of the constraint, for example, PRIMARY_KEY.

columns List<String>: The column names of the constraint.
enforced Boolean: Whether the constraint is enforced. Defaults to false.
name String: The name of the constraint, for example, pkOrders.
type String: The type of the constraint, for example, PRIMARY_KEY.

columns string[]: The column names of the constraint.
enforced boolean: Whether the constraint is enforced. Defaults to false.
name string: The name of the constraint, for example, pkOrders.
type string: The type of the constraint, for example, PRIMARY_KEY.

columns Sequence[str]: The column names of the constraint.
enforced bool: Whether the constraint is enforced. Defaults to false.
name str: The name of the constraint, for example, pkOrders.
type str: The type of the constraint, for example, PRIMARY_KEY.

columns List<String>: The column names of the constraint.
enforced Boolean: Whether the constraint is enforced. Defaults to false.
name String: The name of the constraint, for example, pkOrders.
type String: The type of the constraint, for example, PRIMARY_KEY.

FlinkMaterializedTableCredentials, FlinkMaterializedTableCredentialsArgs

Key string: The Flink API Key.
Secret string: The Flink API Secret.

Key string: The Flink API Key.
Secret string: The Flink API Secret.

key string: The Flink API Key.
secret string: The Flink API Secret.

key String: The Flink API Key.
secret String: The Flink API Secret.

key string: The Flink API Key.
secret string: The Flink API Secret.

key str: The Flink API Key.
secret str: The Flink API Secret.

key String: The Flink API Key.
secret String: The Flink API Secret.

FlinkMaterializedTableDistribution, FlinkMaterializedTableDistributionArgs

BucketCount int: The number of buckets the table is distributed by.
Keys List<string>: The names of the columns the table is distributed by.

BucketCount int: The number of buckets the table is distributed by.
Keys []string: The names of the columns the table is distributed by.

bucket_count number: The number of buckets the table is distributed by.
keys list(string): The names of the columns the table is distributed by.

bucketCount Integer: The number of buckets the table is distributed by.
keys List<String>: The names of the columns the table is distributed by.

bucketCount number: The number of buckets the table is distributed by.
keys string[]: The names of the columns the table is distributed by.

bucket_count int: The number of buckets the table is distributed by.
keys Sequence[str]: The names of the columns the table is distributed by.

bucketCount Number: The number of buckets the table is distributed by.
keys List<String>: The names of the columns the table is distributed by.

FlinkMaterializedTableEnvironment, FlinkMaterializedTableEnvironmentArgs

Id string: The ID of the Environment, for example, env-abc123.

Id string: The ID of the Environment, for example, env-abc123.

id string: The ID of the Environment, for example, env-abc123.

id String: The ID of the Environment, for example, env-abc123.

id string: The ID of the Environment, for example, env-abc123.

id str: The ID of the Environment, for example, env-abc123.

id String: The ID of the Environment, for example, env-abc123.

FlinkMaterializedTableKafkaCluster, FlinkMaterializedTableKafkaClusterArgs

Id string: The ID of the Kafka Cluster hosting the Materialized Table's topic, for example, lkc-abc123.

Id string: The ID of the Kafka Cluster hosting the Materialized Table's topic, for example, lkc-abc123.

id string: The ID of the Kafka Cluster hosting the Materialized Table's topic, for example, lkc-abc123.

id String: The ID of the Kafka Cluster hosting the Materialized Table's topic, for example, lkc-abc123.

id string: The ID of the Kafka Cluster hosting the Materialized Table's topic, for example, lkc-abc123.

id str: The ID of the Kafka Cluster hosting the Materialized Table's topic, for example, lkc-abc123.

id String: The ID of the Kafka Cluster hosting the Materialized Table's topic, for example, lkc-abc123.

FlinkMaterializedTableOrganization, FlinkMaterializedTableOrganizationArgs

Id string: The ID of the Organization, for example, 1111aaaa-11aa-11aa-11aa-111111aaaaaa.

Id string: The ID of the Organization, for example, 1111aaaa-11aa-11aa-11aa-111111aaaaaa.

id string: The ID of the Organization, for example, 1111aaaa-11aa-11aa-11aa-111111aaaaaa.

id String: The ID of the Organization, for example, 1111aaaa-11aa-11aa-11aa-111111aaaaaa.

id string: The ID of the Organization, for example, 1111aaaa-11aa-11aa-11aa-111111aaaaaa.

id str: The ID of the Organization, for example, 1111aaaa-11aa-11aa-11aa-111111aaaaaa.

id String: The ID of the Organization, for example, 1111aaaa-11aa-11aa-11aa-111111aaaaaa.

FlinkMaterializedTablePrincipal, FlinkMaterializedTablePrincipalArgs

Id string: The ID of the Principal the Flink Materialized Table runs as, for example, sa-abc123.

Id string: The ID of the Principal the Flink Materialized Table runs as, for example, sa-abc123.

id string: The ID of the Principal the Flink Materialized Table runs as, for example, sa-abc123.

id String: The ID of the Principal the Flink Materialized Table runs as, for example, sa-abc123.

id string: The ID of the Principal the Flink Materialized Table runs as, for example, sa-abc123.

id str: The ID of the Principal the Flink Materialized Table runs as, for example, sa-abc123.

id String: The ID of the Principal the Flink Materialized Table runs as, for example, sa-abc123.

FlinkMaterializedTableWatermark, FlinkMaterializedTableWatermarkArgs

Column string: The name of the watermark column.
Expression string: The watermark expression, for example, eventTime - INTERVAL '5' SECOND.

Column string: The name of the watermark column.
Expression string: The watermark expression, for example, eventTime - INTERVAL '5' SECOND.

column string: The name of the watermark column.
expression string: The watermark expression, for example, eventTime - INTERVAL '5' SECOND.

column String: The name of the watermark column.
expression String: The watermark expression, for example, eventTime - INTERVAL '5' SECOND.

column string: The name of the watermark column.
expression string: The watermark expression, for example, eventTime - INTERVAL '5' SECOND.

column str: The name of the watermark column.
expression str: The watermark expression, for example, eventTime - INTERVAL '5' SECOND.

column String: The name of the watermark column.
expression String: The watermark expression, for example, eventTime - INTERVAL '5' SECOND.

Import

You can import a Flink Materialized Table by using the Materialized Table name, for example:

Option #1: Manage multiple Flink Materialized Tables in the same Pulumi Stack

$ export IMPORT_CONFLUENT_ORGANIZATION_ID="<organization_id>"
$ export IMPORT_CONFLUENT_ENVIRONMENT_ID="<environment_id>"
$ export IMPORT_FLINK_COMPUTE_POOL_ID="<flink_compute_pool_id>"
$ export IMPORT_FLINK_API_KEY="<flink_api_key>"
$ export IMPORT_FLINK_API_SECRET="<flink_api_secret>"
$ export IMPORT_FLINK_REST_ENDPOINT="<flink_rest_endpoint>"
$ export IMPORT_FLINK_PRINCIPAL_ID="<flink_principal_id>"
$ pulumi import confluentcloud:index/flinkMaterializedTable:FlinkMaterializedTable example env-abc123/lkc-xyz123/my_materialized_table

Option #2: Manage a single Flink Materialized Table in the same Pulumi Stack

$ pulumi import confluentcloud:index/flinkMaterializedTable:FlinkMaterializedTable example env-abc123/lkc-xyz123/my_materialized_table

!> Warning: Do not forget to delete terminal command history afterwards 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.

Viewing docs for Confluent v2.69.0
published on Friday, May 15, 2026 by Pulumi

Schema (JSON)

pulumi/pulumi-confluentcloud

confluentcloud.FlinkMaterializedTable

On this page

On this page

Example Usage

Option #1: Manage multiple Flink Materialized Tables in the same Pulumi Stack

Option #2: Manage a single Flink Materialized Table in the same Pulumi Stack

Stopping and Resuming a Materialized Table

Create FlinkMaterializedTable Resource

Constructor syntax

Parameters

Constructor example

FlinkMaterializedTable Resource Properties

Inputs

Outputs

Look up Existing FlinkMaterializedTable Resource

Supporting Types

FlinkMaterializedTableColumn, FlinkMaterializedTableColumnArgs

FlinkMaterializedTableColumnColumnsComputed, FlinkMaterializedTableColumnColumnsComputedArgs

FlinkMaterializedTableColumnColumnsMetadata, FlinkMaterializedTableColumnColumnsMetadataArgs

FlinkMaterializedTableColumnColumnsPhysical, FlinkMaterializedTableColumnColumnsPhysicalArgs

FlinkMaterializedTableComputePool, FlinkMaterializedTableComputePoolArgs

FlinkMaterializedTableConstraint, FlinkMaterializedTableConstraintArgs

FlinkMaterializedTableCredentials, FlinkMaterializedTableCredentialsArgs

FlinkMaterializedTableDistribution, FlinkMaterializedTableDistributionArgs

FlinkMaterializedTableEnvironment, FlinkMaterializedTableEnvironmentArgs

FlinkMaterializedTableKafkaCluster, FlinkMaterializedTableKafkaClusterArgs

FlinkMaterializedTableOrganization, FlinkMaterializedTableOrganizationArgs

FlinkMaterializedTablePrincipal, FlinkMaterializedTablePrincipalArgs

FlinkMaterializedTableWatermark, FlinkMaterializedTableWatermarkArgs

Import

Package Details

On this page

On this page