astra.StreamingSink

using System.Collections.Generic;
using System.Text.Json;
using Pulumi;
using Astra = Pulumiverse.Astra;

return await Deployment.RunAsync(() => 
{
    var streamingTenant_1 = new Astra.StreamingTenant("streamingTenant-1", new()
    {
        TenantName = "terraformtest2",
        Topic = "terraformtest",
        Region = "useast-4",
        CloudProvider = "gcp",
        UserEmail = "seb@datastax.com",
    });

    var cdc_1 = new Astra.Cdc("cdc-1", new()
    {
        DatabaseId = "5b70892f-e01a-4595-98e6-19ecc9985d50",
        DatabaseName = "sai_test",
        Table = "test",
        Keyspace = "sai_test",
        TopicPartitions = 3,
        TenantName = streamingTenant_1.TenantName,
    }, new CustomResourceOptions
    {
        DependsOn = new[]
        {
            streamingTenant_1,
        },
    });

    var streamingSink_1 = new Astra.StreamingSink("streamingSink-1", new()
    {
        TenantName = streamingTenant_1.TenantName,
        Topic = cdc_1.DataTopic,
        Region = "useast-4",
        CloudProvider = "gcp",
        SinkName = "jdbc-clickhouse",
        RetainOrdering = true,
        ProcessingGuarantees = "ATLEAST_ONCE",
        Parallelism = 3,
        Namespace = "default",
        SinkConfigs = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["userName"] = "clickhouse",
            ["password"] = "password",
            ["jdbcUrl"] = "jdbc:clickhouse://fake.clickhouse.url:8123/pulsar_clickhouse_jdbc_sink",
            ["tableName"] = "pulsar_clickhouse_jdbc_sink",
        }),
        AutoAck = true,
    }, new CustomResourceOptions
    {
        DependsOn = new[]
        {
            streamingTenant_1,
            cdc_1,
        },
    });

});

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-astra/sdk/go/astra"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := astra.NewStreamingTenant(ctx, "streamingTenant-1", &astra.StreamingTenantArgs{
			TenantName:    pulumi.String("terraformtest2"),
			Topic:         pulumi.String("terraformtest"),
			Region:        pulumi.String("useast-4"),
			CloudProvider: pulumi.String("gcp"),
			UserEmail:     pulumi.String("seb@datastax.com"),
		})
		if err != nil {
			return err
		}
		_, err = astra.NewCdc(ctx, "cdc-1", &astra.CdcArgs{
			DatabaseId:      pulumi.String("5b70892f-e01a-4595-98e6-19ecc9985d50"),
			DatabaseName:    pulumi.String("sai_test"),
			Table:           pulumi.String("test"),
			Keyspace:        pulumi.String("sai_test"),
			TopicPartitions: pulumi.Int(3),
			TenantName:      streamingTenant_1.TenantName,
		}, pulumi.DependsOn([]pulumi.Resource{
			streamingTenant_1,
		}))
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"userName":  "clickhouse",
			"password":  "password",
			"jdbcUrl":   "jdbc:clickhouse://fake.clickhouse.url:8123/pulsar_clickhouse_jdbc_sink",
			"tableName": "pulsar_clickhouse_jdbc_sink",
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err = astra.NewStreamingSink(ctx, "streamingSink-1", &astra.StreamingSinkArgs{
			TenantName:           streamingTenant_1.TenantName,
			Topic:                cdc_1.DataTopic,
			Region:               pulumi.String("useast-4"),
			CloudProvider:        pulumi.String("gcp"),
			SinkName:             pulumi.String("jdbc-clickhouse"),
			RetainOrdering:       pulumi.Bool(true),
			ProcessingGuarantees: pulumi.String("ATLEAST_ONCE"),
			Parallelism:          pulumi.Int(3),
			Namespace:            pulumi.String("default"),
			SinkConfigs:          pulumi.String(json0),
			AutoAck:              pulumi.Bool(true),
		}, pulumi.DependsOn([]pulumi.Resource{
			streamingTenant_1,
			cdc_1,
		}))
		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.astra.StreamingTenant;
import com.pulumi.astra.StreamingTenantArgs;
import com.pulumi.astra.Cdc;
import com.pulumi.astra.CdcArgs;
import com.pulumi.astra.StreamingSink;
import com.pulumi.astra.StreamingSinkArgs;
import static com.pulumi.codegen.internal.Serialization.*;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var streamingTenant_1 = new StreamingTenant("streamingTenant-1", StreamingTenantArgs.builder()        
            .tenantName("terraformtest2")
            .topic("terraformtest")
            .region("useast-4")
            .cloudProvider("gcp")
            .userEmail("seb@datastax.com")
            .build());

        var cdc_1 = new Cdc("cdc-1", CdcArgs.builder()        
            .databaseId("5b70892f-e01a-4595-98e6-19ecc9985d50")
            .databaseName("sai_test")
            .table("test")
            .keyspace("sai_test")
            .topicPartitions(3)
            .tenantName(streamingTenant_1.tenantName())
            .build(), CustomResourceOptions.builder()
                .dependsOn(streamingTenant_1)
                .build());

        var streamingSink_1 = new StreamingSink("streamingSink-1", StreamingSinkArgs.builder()        
            .tenantName(streamingTenant_1.tenantName())
            .topic(cdc_1.dataTopic())
            .region("useast-4")
            .cloudProvider("gcp")
            .sinkName("jdbc-clickhouse")
            .retainOrdering(true)
            .processingGuarantees("ATLEAST_ONCE")
            .parallelism(3)
            .namespace("default")
            .sinkConfigs(serializeJson(
                jsonObject(
                    jsonProperty("userName", "clickhouse"),
                    jsonProperty("password", "password"),
                    jsonProperty("jdbcUrl", "jdbc:clickhouse://fake.clickhouse.url:8123/pulsar_clickhouse_jdbc_sink"),
                    jsonProperty("tableName", "pulsar_clickhouse_jdbc_sink")
                )))
            .autoAck(true)
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    streamingTenant_1,
                    cdc_1)
                .build());

    }
}

import pulumi
import json
import pulumiverse_astra as astra

streaming_tenant_1 = astra.StreamingTenant("streamingTenant-1",
    tenant_name="terraformtest2",
    topic="terraformtest",
    region="useast-4",
    cloud_provider="gcp",
    user_email="seb@datastax.com")
cdc_1 = astra.Cdc("cdc-1",
    database_id="5b70892f-e01a-4595-98e6-19ecc9985d50",
    database_name="sai_test",
    table="test",
    keyspace="sai_test",
    topic_partitions=3,
    tenant_name=streaming_tenant_1.tenant_name,
    opts=pulumi.ResourceOptions(depends_on=[streaming_tenant_1]))
streaming_sink_1 = astra.StreamingSink("streamingSink-1",
    tenant_name=streaming_tenant_1.tenant_name,
    topic=cdc_1.data_topic,
    region="useast-4",
    cloud_provider="gcp",
    sink_name="jdbc-clickhouse",
    retain_ordering=True,
    processing_guarantees="ATLEAST_ONCE",
    parallelism=3,
    namespace="default",
    sink_configs=json.dumps({
        "userName": "clickhouse",
        "password": "password",
        "jdbcUrl": "jdbc:clickhouse://fake.clickhouse.url:8123/pulsar_clickhouse_jdbc_sink",
        "tableName": "pulsar_clickhouse_jdbc_sink",
    }),
    auto_ack=True,
    opts=pulumi.ResourceOptions(depends_on=[
            streaming_tenant_1,
            cdc_1,
        ]))

import * as pulumi from "@pulumi/pulumi";
import * as astra from "@pulumiverse/astra";

const streamingTenant_1 = new astra.StreamingTenant("streamingTenant-1", {
    tenantName: "terraformtest2",
    topic: "terraformtest",
    region: "useast-4",
    cloudProvider: "gcp",
    userEmail: "seb@datastax.com",
});
const cdc_1 = new astra.Cdc("cdc-1", {
    databaseId: "5b70892f-e01a-4595-98e6-19ecc9985d50",
    databaseName: "sai_test",
    table: "test",
    keyspace: "sai_test",
    topicPartitions: 3,
    tenantName: streamingTenant_1.tenantName,
}, {
    dependsOn: [streamingTenant_1],
});
const streamingSink_1 = new astra.StreamingSink("streamingSink-1", {
    tenantName: streamingTenant_1.tenantName,
    topic: cdc_1.dataTopic,
    region: "useast-4",
    cloudProvider: "gcp",
    sinkName: "jdbc-clickhouse",
    retainOrdering: true,
    processingGuarantees: "ATLEAST_ONCE",
    parallelism: 3,
    namespace: "default",
    sinkConfigs: JSON.stringify({
        userName: "clickhouse",
        password: "password",
        jdbcUrl: "jdbc:clickhouse://fake.clickhouse.url:8123/pulsar_clickhouse_jdbc_sink",
        tableName: "pulsar_clickhouse_jdbc_sink",
    }),
    autoAck: true,
}, {
    dependsOn: [
        streamingTenant_1,
        cdc_1,
    ],
});

resources:
  streamingTenant-1:
    type: astra:StreamingTenant
    properties:
      tenantName: terraformtest2
      topic: terraformtest
      region: useast-4
      cloudProvider: gcp
      userEmail: seb@datastax.com
  cdc-1:
    type: astra:Cdc
    properties:
      databaseId: 5b70892f-e01a-4595-98e6-19ecc9985d50
      databaseName: sai_test
      table: test
      keyspace: sai_test
      topicPartitions: 3
      tenantName: ${["streamingTenant-1"].tenantName}
    options:
      dependson:
        - ${["streamingTenant-1"]}
  streamingSink-1:
    type: astra:StreamingSink
    properties:
      tenantName: ${["streamingTenant-1"].tenantName}
      topic: ${["cdc-1"].dataTopic}
      region: useast-4
      cloudProvider: gcp
      sinkName: jdbc-clickhouse
      retainOrdering: true
      processingGuarantees: ATLEAST_ONCE
      parallelism: 3
      namespace: default
      sinkConfigs:
        Fn::ToJSON:
          userName: clickhouse
          password: password
          jdbcUrl: jdbc:clickhouse://fake.clickhouse.url:8123/pulsar_clickhouse_jdbc_sink
          tableName: pulsar_clickhouse_jdbc_sink
      autoAck: true
    options:
      dependson:
        - ${["streamingTenant-1"]}
        - ${["cdc-1"]}