pulumi-gcp-kotlin/com.pulumi.gcp.managedkafka.kotlin/Connector

Connector

class Connector : KotlinCustomResource

Example Usage

Managedkafka Connector Basic

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
import * as time from "@pulumi/time";
const project = new gcp.organizations.Project("project", {
    projectId: "tf-test_80332",
    name: "tf-test_13293",
    orgId: "123456789",
    billingAccount: "000000-0000000-0000000-000000",
    deletionPolicy: "DELETE",
});
const wait60Seconds = new time.index.Sleep("wait_60_seconds", {createDuration: "60s"}, {
    dependsOn: [project],
});
const compute = new gcp.projects.Service("compute", {
    project: project.projectId,
    service: "compute.googleapis.com",
}, {
    dependsOn: [wait60Seconds],
});
const managedkafka = new gcp.projects.Service("managedkafka", {
    project: project.projectId,
    service: "managedkafka.googleapis.com",
}, {
    dependsOn: [compute],
});
const wait120Seconds = new time.index.Sleep("wait_120_seconds", {createDuration: "120s"}, {
    dependsOn: [managedkafka],
});
const mkcSecondarySubnet = new gcp.compute.Subnetwork("mkc_secondary_subnet", {
    project: project.projectId,
    name: "my-secondary-subnetwork-00",
    ipCidrRange: "10.5.0.0/16",
    region: "us-central1",
    network: "default",
}, {
    dependsOn: [wait120Seconds],
});
const cpsTopic = new gcp.pubsub.Topic("cps_topic", {
    project: project.projectId,
    name: "my-cps-topic",
    messageRetentionDuration: "86600s",
});
const gmkCluster = new gcp.managedkafka.Cluster("gmk_cluster", {
    project: project.projectId,
    clusterId: "my-cluster",
    location: "us-central1",
    capacityConfig: {
        vcpuCount: "3",
        memoryBytes: "3221225472",
    },
    gcpConfig: {
        accessConfig: {
            networkConfigs: [{
                subnet: pulumi.interpolate`projects/${project.projectId}/regions/us-central1/subnetworks/default`,
            }],
        },
    },
}, {
    dependsOn: [managedkafka],
});
const gmkTopic = new gcp.managedkafka.Topic("gmk_topic", {
    project: project.projectId,
    topicId: "my-topic",
    cluster: gmkCluster.clusterId,
    location: "us-central1",
    partitionCount: 2,
    replicationFactor: 3,
}, {
    dependsOn: [managedkafka],
});
const mkcCluster = new gcp.managedkafka.ConnectCluster("mkc_cluster", {
    project: project.projectId,
    connectClusterId: "my-connect-cluster",
    kafkaCluster: pulumi.interpolate`projects/${project.projectId}/locations/us-central1/clusters/${gmkCluster.clusterId}`,
    location: "us-central1",
    capacityConfig: {
        vcpuCount: "12",
        memoryBytes: "21474836480",
    },
    gcpConfig: {
        accessConfig: {
            networkConfigs: [{
                primarySubnet: pulumi.interpolate`projects/${project.projectId}/regions/us-central1/subnetworks/default`,
                additionalSubnets: [mkcSecondarySubnet.id],
                dnsDomainNames: [pulumi.interpolate`${gmkCluster.clusterId}.us-central1.managedkafka.${project.projectId}.cloud.goog`],
            }],
        },
    },
    labels: {
        key: "value",
    },
}, {
    dependsOn: [managedkafka],
});
const example = new gcp.managedkafka.Connector("example", {
    project: project.projectId,
    connectorId: "my-connector",
    connectCluster: mkcCluster.connectClusterId,
    location: "us-central1",
    configs: {
        "connector.class": "com.google.pubsub.kafka.sink.CloudPubSubSinkConnector",
        name: "my-connector",
        "tasks.max": "1",
        topics: gmkTopic.topicId,
        "cps.topic": cpsTopic.name,
        "cps.project": project.projectId,
        "value.converter": "org.apache.kafka.connect.storage.StringConverter",
        "key.converter": "org.apache.kafka.connect.storage.StringConverter",
    },
    taskRestartPolicy: {
        minimumBackoff: "60s",
        maximumBackoff: "1800s",
    },
}, {
    dependsOn: [managedkafka],
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
import pulumi_time as time
project = gcp.organizations.Project("project",
    project_id="tf-test_80332",
    name="tf-test_13293",
    org_id="123456789",
    billing_account="000000-0000000-0000000-000000",
    deletion_policy="DELETE")
wait60_seconds = time.index.Sleep("wait_60_seconds", create_duration=60s,
opts = pulumi.ResourceOptions(depends_on=[project]))
compute = gcp.projects.Service("compute",
    project=project.project_id,
    service="compute.googleapis.com",
    opts = pulumi.ResourceOptions(depends_on=[wait60_seconds]))
managedkafka = gcp.projects.Service("managedkafka",
    project=project.project_id,
    service="managedkafka.googleapis.com",
    opts = pulumi.ResourceOptions(depends_on=[compute]))
wait120_seconds = time.index.Sleep("wait_120_seconds", create_duration=120s,
opts = pulumi.ResourceOptions(depends_on=[managedkafka]))
mkc_secondary_subnet = gcp.compute.Subnetwork("mkc_secondary_subnet",
    project=project.project_id,
    name="my-secondary-subnetwork-00",
    ip_cidr_range="10.5.0.0/16",
    region="us-central1",
    network="default",
    opts = pulumi.ResourceOptions(depends_on=[wait120_seconds]))
cps_topic = gcp.pubsub.Topic("cps_topic",
    project=project.project_id,
    name="my-cps-topic",
    message_retention_duration="86600s")
gmk_cluster = gcp.managedkafka.Cluster("gmk_cluster",
    project=project.project_id,
    cluster_id="my-cluster",
    location="us-central1",
    capacity_config={
        "vcpu_count": "3",
        "memory_bytes": "3221225472",
    },
    gcp_config={
        "access_config": {
            "network_configs": [{
                "subnet": project.project_id.apply(lambda project_id: f"projects/{project_id}/regions/us-central1/subnetworks/default"),
            }],
        },
    },
    opts = pulumi.ResourceOptions(depends_on=[managedkafka]))
gmk_topic = gcp.managedkafka.Topic("gmk_topic",
    project=project.project_id,
    topic_id="my-topic",
    cluster=gmk_cluster.cluster_id,
    location="us-central1",
    partition_count=2,
    replication_factor=3,
    opts = pulumi.ResourceOptions(depends_on=[managedkafka]))
mkc_cluster = gcp.managedkafka.ConnectCluster("mkc_cluster",
    project=project.project_id,
    connect_cluster_id="my-connect-cluster",
    kafka_cluster=pulumi.Output.all(
        project_id=project.project_id,
        cluster_id=gmk_cluster.cluster_id
).apply(lambda resolved_outputs: f"projects/{resolved_outputs['project_id']}/locations/us-central1/clusters/{resolved_outputs['cluster_id']}")
,
    location="us-central1",
    capacity_config={
        "vcpu_count": "12",
        "memory_bytes": "21474836480",
    },
    gcp_config={
        "access_config": {
            "network_configs": [{
                "primary_subnet": project.project_id.apply(lambda project_id: f"projects/{project_id}/regions/us-central1/subnetworks/default"),
                "additional_subnets": [mkc_secondary_subnet.id],
                "dns_domain_names": [pulumi.Output.all(
                    cluster_id=gmk_cluster.cluster_id,
                    project_id=project.project_id
).apply(lambda resolved_outputs: f"{resolved_outputs['cluster_id']}.us-central1.managedkafka.{resolved_outputs['project_id']}.cloud.goog")
],
            }],
        },
    },
    labels={
        "key": "value",
    },
    opts = pulumi.ResourceOptions(depends_on=[managedkafka]))
example = gcp.managedkafka.Connector("example",
    project=project.project_id,
    connector_id="my-connector",
    connect_cluster=mkc_cluster.connect_cluster_id,
    location="us-central1",
    configs={
        "connector.class": "com.google.pubsub.kafka.sink.CloudPubSubSinkConnector",
        "name": "my-connector",
        "tasks.max": "1",
        "topics": gmk_topic.topic_id,
        "cps.topic": cps_topic.name,
        "cps.project": project.project_id,
        "value.converter": "org.apache.kafka.connect.storage.StringConverter",
        "key.converter": "org.apache.kafka.connect.storage.StringConverter",
    },
    task_restart_policy={
        "minimum_backoff": "60s",
        "maximum_backoff": "1800s",
    },
    opts = pulumi.ResourceOptions(depends_on=[managedkafka]))
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
using Time = Pulumi.Time;
return await Deployment.RunAsync(() =>
{
    var project = new Gcp.Organizations.Project("project", new()
    {
        ProjectId = "tf-test_80332",
        Name = "tf-test_13293",
        OrgId = "123456789",
        BillingAccount = "000000-0000000-0000000-000000",
        DeletionPolicy = "DELETE",
    });
    var wait60Seconds = new Time.Index.Sleep("wait_60_seconds", new()
    {
        CreateDuration = "60s",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            project,
        },
    });
    var compute = new Gcp.Projects.Service("compute", new()
    {
        Project = project.ProjectId,
        ServiceName = "compute.googleapis.com",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            wait60Seconds,
        },
    });
    var managedkafka = new Gcp.Projects.Service("managedkafka", new()
    {
        Project = project.ProjectId,
        ServiceName = "managedkafka.googleapis.com",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            compute,
        },
    });
    var wait120Seconds = new Time.Index.Sleep("wait_120_seconds", new()
    {
        CreateDuration = "120s",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            managedkafka,
        },
    });
    var mkcSecondarySubnet = new Gcp.Compute.Subnetwork("mkc_secondary_subnet", new()
    {
        Project = project.ProjectId,
        Name = "my-secondary-subnetwork-00",
        IpCidrRange = "10.5.0.0/16",
        Region = "us-central1",
        Network = "default",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            wait120Seconds,
        },
    });
    var cpsTopic = new Gcp.PubSub.Topic("cps_topic", new()
    {
        Project = project.ProjectId,
        Name = "my-cps-topic",
        MessageRetentionDuration = "86600s",
    });
    var gmkCluster = new Gcp.ManagedKafka.Cluster("gmk_cluster", new()
    {
        Project = project.ProjectId,
        ClusterId = "my-cluster",
        Location = "us-central1",
        CapacityConfig = new Gcp.ManagedKafka.Inputs.ClusterCapacityConfigArgs
        {
            VcpuCount = "3",
            MemoryBytes = "3221225472",
        },
        GcpConfig = new Gcp.ManagedKafka.Inputs.ClusterGcpConfigArgs
        {
            AccessConfig = new Gcp.ManagedKafka.Inputs.ClusterGcpConfigAccessConfigArgs
            {
                NetworkConfigs = new[]
                {
                    new Gcp.ManagedKafka.Inputs.ClusterGcpConfigAccessConfigNetworkConfigArgs
                    {
                        Subnet = project.ProjectId.Apply(projectId => $"projects/{projectId}/regions/us-central1/subnetworks/default"),
                    },
                },
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            managedkafka,
        },
    });
    var gmkTopic = new Gcp.ManagedKafka.Topic("gmk_topic", new()
    {
        Project = project.ProjectId,
        TopicId = "my-topic",
        Cluster = gmkCluster.ClusterId,
        Location = "us-central1",
        PartitionCount = 2,
        ReplicationFactor = 3,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            managedkafka,
        },
    });
    var mkcCluster = new Gcp.ManagedKafka.ConnectCluster("mkc_cluster", new()
    {
        Project = project.ProjectId,
        ConnectClusterId = "my-connect-cluster",
        KafkaCluster = Output.Tuple(project.ProjectId, gmkCluster.ClusterId).Apply(values =>
        {
            var projectId = values.Item1;
            var clusterId = values.Item2;
            return $"projects/{projectId}/locations/us-central1/clusters/{clusterId}";
        }),
        Location = "us-central1",
        CapacityConfig = new Gcp.ManagedKafka.Inputs.ConnectClusterCapacityConfigArgs
        {
            VcpuCount = "12",
            MemoryBytes = "21474836480",
        },
        GcpConfig = new Gcp.ManagedKafka.Inputs.ConnectClusterGcpConfigArgs
        {
            AccessConfig = new Gcp.ManagedKafka.Inputs.ConnectClusterGcpConfigAccessConfigArgs
            {
                NetworkConfigs = new[]
                {
                    new Gcp.ManagedKafka.Inputs.ConnectClusterGcpConfigAccessConfigNetworkConfigArgs
                    {
                        PrimarySubnet = project.ProjectId.Apply(projectId => $"projects/{projectId}/regions/us-central1/subnetworks/default"),
                        AdditionalSubnets = new[]
                        {
                            mkcSecondarySubnet.Id,
                        },
                        DnsDomainNames = new[]
                        {
                            Output.Tuple(gmkCluster.ClusterId, project.ProjectId).Apply(values =>
                            {
                                var clusterId = values.Item1;
                                var projectId = values.Item2;
                                return $"{clusterId}.us-central1.managedkafka.{projectId}.cloud.goog";
                            }),
                        },
                    },
                },
            },
        },
        Labels =
        {
            { "key", "value" },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            managedkafka,
        },
    });
    var example = new Gcp.ManagedKafka.Connector("example", new()
    {
        Project = project.ProjectId,
        ConnectorId = "my-connector",
        ConnectCluster = mkcCluster.ConnectClusterId,
        Location = "us-central1",
        Configs =
        {
            { "connector.class", "com.google.pubsub.kafka.sink.CloudPubSubSinkConnector" },
            { "name", "my-connector" },
            { "tasks.max", "1" },
            { "topics", gmkTopic.TopicId },
            { "cps.topic", cpsTopic.Name },
            { "cps.project", project.ProjectId },
            { "value.converter", "org.apache.kafka.connect.storage.StringConverter" },
            { "key.converter", "org.apache.kafka.connect.storage.StringConverter" },
        },
        TaskRestartPolicy = new Gcp.ManagedKafka.Inputs.ConnectorTaskRestartPolicyArgs
        {
            MinimumBackoff = "60s",
            MaximumBackoff = "1800s",
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            managedkafka,
        },
    });
});
Content copied to clipboard
package main
import (
	"fmt"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/managedkafka"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/organizations"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/projects"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/pubsub"
	"github.com/pulumi/pulumi-time/sdk/go/time"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		project, err := organizations.NewProject(ctx, "project", &organizations.ProjectArgs{
			ProjectId:      pulumi.String("tf-test_80332"),
			Name:           pulumi.String("tf-test_13293"),
			OrgId:          pulumi.String("123456789"),
			BillingAccount: pulumi.String("000000-0000000-0000000-000000"),
			DeletionPolicy: pulumi.String("DELETE"),
		})
		if err != nil {
			return err
		}
		wait60Seconds, err := time.NewSleep(ctx, "wait_60_seconds", &time.SleepArgs{
			CreateDuration: "60s",
		}, pulumi.DependsOn([]pulumi.Resource{
			project,
		}))
		if err != nil {
			return err
		}
		compute, err := projects.NewService(ctx, "compute", &projects.ServiceArgs{
			Project: project.ProjectId,
			Service: pulumi.String("compute.googleapis.com"),
		}, pulumi.DependsOn([]pulumi.Resource{
			wait60Seconds,
		}))
		if err != nil {
			return err
		}
		managedkafka, err := projects.NewService(ctx, "managedkafka", &projects.ServiceArgs{
			Project: project.ProjectId,
			Service: pulumi.String("managedkafka.googleapis.com"),
		}, pulumi.DependsOn([]pulumi.Resource{
			compute,
		}))
		if err != nil {
			return err
		}
		wait120Seconds, err := time.NewSleep(ctx, "wait_120_seconds", &time.SleepArgs{
			CreateDuration: "120s",
		}, pulumi.DependsOn([]pulumi.Resource{
			managedkafka,
		}))
		if err != nil {
			return err
		}
		mkcSecondarySubnet, err := compute.NewSubnetwork(ctx, "mkc_secondary_subnet", &compute.SubnetworkArgs{
			Project:     project.ProjectId,
			Name:        pulumi.String("my-secondary-subnetwork-00"),
			IpCidrRange: pulumi.String("10.5.0.0/16"),
			Region:      pulumi.String("us-central1"),
			Network:     pulumi.String("default"),
		}, pulumi.DependsOn([]pulumi.Resource{
			wait120Seconds,
		}))
		if err != nil {
			return err
		}
		cpsTopic, err := pubsub.NewTopic(ctx, "cps_topic", &pubsub.TopicArgs{
			Project:                  project.ProjectId,
			Name:                     pulumi.String("my-cps-topic"),
			MessageRetentionDuration: pulumi.String("86600s"),
		})
		if err != nil {
			return err
		}
		gmkCluster, err := managedkafka.NewCluster(ctx, "gmk_cluster", &managedkafka.ClusterArgs{
			Project:   project.ProjectId,
			ClusterId: pulumi.String("my-cluster"),
			Location:  pulumi.String("us-central1"),
			CapacityConfig: &managedkafka.ClusterCapacityConfigArgs{
				VcpuCount:   pulumi.String("3"),
				MemoryBytes: pulumi.String("3221225472"),
			},
			GcpConfig: &managedkafka.ClusterGcpConfigArgs{
				AccessConfig: &managedkafka.ClusterGcpConfigAccessConfigArgs{
					NetworkConfigs: managedkafka.ClusterGcpConfigAccessConfigNetworkConfigArray{
						&managedkafka.ClusterGcpConfigAccessConfigNetworkConfigArgs{
							Subnet: project.ProjectId.ApplyT(func(projectId string) (string, error) {
								return fmt.Sprintf("projects/%v/regions/us-central1/subnetworks/default", projectId), nil
							}).(pulumi.StringOutput),
						},
					},
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			managedkafka,
		}))
		if err != nil {
			return err
		}
		gmkTopic, err := managedkafka.NewTopic(ctx, "gmk_topic", &managedkafka.TopicArgs{
			Project:           project.ProjectId,
			TopicId:           pulumi.String("my-topic"),
			Cluster:           gmkCluster.ClusterId,
			Location:          pulumi.String("us-central1"),
			PartitionCount:    pulumi.Int(2),
			ReplicationFactor: pulumi.Int(3),
		}, pulumi.DependsOn([]pulumi.Resource{
			managedkafka,
		}))
		if err != nil {
			return err
		}
		mkcCluster, err := managedkafka.NewConnectCluster(ctx, "mkc_cluster", &managedkafka.ConnectClusterArgs{
			Project:          project.ProjectId,
			ConnectClusterId: pulumi.String("my-connect-cluster"),
			KafkaCluster: pulumi.All(project.ProjectId, gmkCluster.ClusterId).ApplyT(func(_args []interface{}) (string, error) {
				projectId := _args[0].(string)
				clusterId := _args[1].(string)
				return fmt.Sprintf("projects/%v/locations/us-central1/clusters/%v", projectId, clusterId), nil
			}).(pulumi.StringOutput),
			Location: pulumi.String("us-central1"),
			CapacityConfig: &managedkafka.ConnectClusterCapacityConfigArgs{
				VcpuCount:   pulumi.String("12"),
				MemoryBytes: pulumi.String("21474836480"),
			},
			GcpConfig: &managedkafka.ConnectClusterGcpConfigArgs{
				AccessConfig: &managedkafka.ConnectClusterGcpConfigAccessConfigArgs{
					NetworkConfigs: managedkafka.ConnectClusterGcpConfigAccessConfigNetworkConfigArray{
						&managedkafka.ConnectClusterGcpConfigAccessConfigNetworkConfigArgs{
							PrimarySubnet: project.ProjectId.ApplyT(func(projectId string) (string, error) {
								return fmt.Sprintf("projects/%v/regions/us-central1/subnetworks/default", projectId), nil
							}).(pulumi.StringOutput),
							AdditionalSubnets: pulumi.StringArray{
								mkcSecondarySubnet.ID(),
							},
							DnsDomainNames: pulumi.StringArray{
								pulumi.All(gmkCluster.ClusterId, project.ProjectId).ApplyT(func(_args []interface{}) (string, error) {
									clusterId := _args[0].(string)
									projectId := _args[1].(string)
									return fmt.Sprintf("%v.us-central1.managedkafka.%v.cloud.goog", clusterId, projectId), nil
								}).(pulumi.StringOutput),
							},
						},
					},
				},
			},
			Labels: pulumi.StringMap{
				"key": pulumi.String("value"),
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			managedkafka,
		}))
		if err != nil {
			return err
		}
		_, err = managedkafka.NewConnector(ctx, "example", &managedkafka.ConnectorArgs{
			Project:        project.ProjectId,
			ConnectorId:    pulumi.String("my-connector"),
			ConnectCluster: mkcCluster.ConnectClusterId,
			Location:       pulumi.String("us-central1"),
			Configs: pulumi.StringMap{
				"connector.class": pulumi.String("com.google.pubsub.kafka.sink.CloudPubSubSinkConnector"),
				"name":            pulumi.String("my-connector"),
				"tasks.max":       pulumi.String("1"),
				"topics":          gmkTopic.TopicId,
				"cps.topic":       cpsTopic.Name,
				"cps.project":     project.ProjectId,
				"value.converter": pulumi.String("org.apache.kafka.connect.storage.StringConverter"),
				"key.converter":   pulumi.String("org.apache.kafka.connect.storage.StringConverter"),
			},
			TaskRestartPolicy: &managedkafka.ConnectorTaskRestartPolicyArgs{
				MinimumBackoff: pulumi.String("60s"),
				MaximumBackoff: pulumi.String("1800s"),
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			managedkafka,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.organizations.Project;
import com.pulumi.gcp.organizations.ProjectArgs;
import com.pulumi.time.sleep;
import com.pulumi.time.sleepArgs;
import com.pulumi.gcp.projects.Service;
import com.pulumi.gcp.projects.ServiceArgs;
import com.pulumi.gcp.compute.Subnetwork;
import com.pulumi.gcp.compute.SubnetworkArgs;
import com.pulumi.gcp.managedkafka.Cluster;
import com.pulumi.gcp.managedkafka.ClusterArgs;
import com.pulumi.gcp.managedkafka.inputs.ClusterCapacityConfigArgs;
import com.pulumi.gcp.managedkafka.inputs.ClusterGcpConfigArgs;
import com.pulumi.gcp.managedkafka.inputs.ClusterGcpConfigAccessConfigArgs;
import com.pulumi.gcp.managedkafka.ConnectCluster;
import com.pulumi.gcp.managedkafka.ConnectClusterArgs;
import com.pulumi.gcp.managedkafka.inputs.ConnectClusterCapacityConfigArgs;
import com.pulumi.gcp.managedkafka.inputs.ConnectClusterGcpConfigArgs;
import com.pulumi.gcp.managedkafka.inputs.ConnectClusterGcpConfigAccessConfigArgs;
import com.pulumi.gcp.managedkafka.Connector;
import com.pulumi.gcp.managedkafka.ConnectorArgs;
import com.pulumi.gcp.managedkafka.inputs.ConnectorTaskRestartPolicyArgs;
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 project = new Project("project", ProjectArgs.builder()
            .projectId("tf-test_80332")
            .name("tf-test_13293")
            .orgId("123456789")
            .billingAccount("000000-0000000-0000000-000000")
            .deletionPolicy("DELETE")
            .build());
        var wait60Seconds = new Sleep("wait60Seconds", SleepArgs.builder()
            .createDuration("60s")
            .build(), CustomResourceOptions.builder()
                .dependsOn(List.of(project))
                .build());
        var compute = new Service("compute", ServiceArgs.builder()
            .project(project.projectId())
            .service("compute.googleapis.com")
            .build(), CustomResourceOptions.builder()
                .dependsOn(wait60Seconds)
                .build());
        var managedkafka = new Service("managedkafka", ServiceArgs.builder()
            .project(project.projectId())
            .service("managedkafka.googleapis.com")
            .build(), CustomResourceOptions.builder()
                .dependsOn(compute)
                .build());
        var wait120Seconds = new Sleep("wait120Seconds", SleepArgs.builder()
            .createDuration("120s")
            .build(), CustomResourceOptions.builder()
                .dependsOn(List.of(managedkafka))
                .build());
        var mkcSecondarySubnet = new Subnetwork("mkcSecondarySubnet", SubnetworkArgs.builder()
            .project(project.projectId())
            .name("my-secondary-subnetwork-00")
            .ipCidrRange("10.5.0.0/16")
            .region("us-central1")
            .network("default")
            .build(), CustomResourceOptions.builder()
                .dependsOn(wait120Seconds)
                .build());
        var cpsTopic = new com.pulumi.gcp.pubsub.Topic("cpsTopic", com.pulumi.gcp.pubsub.TopicArgs.builder()
            .project(project.projectId())
            .name("my-cps-topic")
            .messageRetentionDuration("86600s")
            .build());
        var gmkCluster = new Cluster("gmkCluster", ClusterArgs.builder()
            .project(project.projectId())
            .clusterId("my-cluster")
            .location("us-central1")
            .capacityConfig(ClusterCapacityConfigArgs.builder()
                .vcpuCount("3")
                .memoryBytes("3221225472")
                .build())
            .gcpConfig(ClusterGcpConfigArgs.builder()
                .accessConfig(ClusterGcpConfigAccessConfigArgs.builder()
                    .networkConfigs(ClusterGcpConfigAccessConfigNetworkConfigArgs.builder()
                        .subnet(project.projectId().applyValue(_projectId -> String.format("projects/%s/regions/us-central1/subnetworks/default", _projectId)))
                        .build())
                    .build())
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(managedkafka)
                .build());
        var gmkTopic = new com.pulumi.gcp.managedkafka.Topic("gmkTopic", com.pulumi.gcp.managedkafka.TopicArgs.builder()
            .project(project.projectId())
            .topicId("my-topic")
            .cluster(gmkCluster.clusterId())
            .location("us-central1")
            .partitionCount(2)
            .replicationFactor(3)
            .build(), CustomResourceOptions.builder()
                .dependsOn(managedkafka)
                .build());
        var mkcCluster = new ConnectCluster("mkcCluster", ConnectClusterArgs.builder()
            .project(project.projectId())
            .connectClusterId("my-connect-cluster")
            .kafkaCluster(Output.tuple(project.projectId(), gmkCluster.clusterId()).applyValue(values -> {
                var projectId = values.t1;
                var clusterId = values.t2;
                return String.format("projects/%s/locations/us-central1/clusters/%s", projectId,clusterId);
            }))
            .location("us-central1")
            .capacityConfig(ConnectClusterCapacityConfigArgs.builder()
                .vcpuCount("12")
                .memoryBytes("21474836480")
                .build())
            .gcpConfig(ConnectClusterGcpConfigArgs.builder()
                .accessConfig(ConnectClusterGcpConfigAccessConfigArgs.builder()
                    .networkConfigs(ConnectClusterGcpConfigAccessConfigNetworkConfigArgs.builder()
                        .primarySubnet(project.projectId().applyValue(_projectId -> String.format("projects/%s/regions/us-central1/subnetworks/default", _projectId)))
                        .additionalSubnets(mkcSecondarySubnet.id())
                        .dnsDomainNames(Output.tuple(gmkCluster.clusterId(), project.projectId()).applyValue(values -> {
                            var clusterId = values.t1;
                            var projectId = values.t2;
                            return String.format("%s.us-central1.managedkafka.%s.cloud.goog", clusterId,projectId);
                        }))
                        .build())
                    .build())
                .build())
            .labels(Map.of("key", "value"))
            .build(), CustomResourceOptions.builder()
                .dependsOn(managedkafka)
                .build());
        var example = new Connector("example", ConnectorArgs.builder()
            .project(project.projectId())
            .connectorId("my-connector")
            .connectCluster(mkcCluster.connectClusterId())
            .location("us-central1")
            .configs(Map.ofEntries(
                Map.entry("connector.class", "com.google.pubsub.kafka.sink.CloudPubSubSinkConnector"),
                Map.entry("name", "my-connector"),
                Map.entry("tasks.max", "1"),
                Map.entry("topics", gmkTopic.topicId()),
                Map.entry("cps.topic", cpsTopic.name()),
                Map.entry("cps.project", project.projectId()),
                Map.entry("value.converter", "org.apache.kafka.connect.storage.StringConverter"),
                Map.entry("key.converter", "org.apache.kafka.connect.storage.StringConverter")
            ))
            .taskRestartPolicy(ConnectorTaskRestartPolicyArgs.builder()
                .minimumBackoff("60s")
                .maximumBackoff("1800s")
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(managedkafka)
                .build());
    }
}
Content copied to clipboard
resources:
  project:
    type: gcp:organizations:Project
    properties:
      projectId: tf-test_80332
      name: tf-test_13293
      orgId: '123456789'
      billingAccount: 000000-0000000-0000000-000000
      deletionPolicy: DELETE
  wait60Seconds:
    type: time:sleep
    name: wait_60_seconds
    properties:
      createDuration: 60s
    options:
      dependsOn:
        - ${project}
  compute:
    type: gcp:projects:Service
    properties:
      project: ${project.projectId}
      service: compute.googleapis.com
    options:
      dependsOn:
        - ${wait60Seconds}
  managedkafka:
    type: gcp:projects:Service
    properties:
      project: ${project.projectId}
      service: managedkafka.googleapis.com
    options:
      dependsOn:
        - ${compute}
  wait120Seconds:
    type: time:sleep
    name: wait_120_seconds
    properties:
      createDuration: 120s
    options:
      dependsOn:
        - ${managedkafka}
  mkcSecondarySubnet:
    type: gcp:compute:Subnetwork
    name: mkc_secondary_subnet
    properties:
      project: ${project.projectId}
      name: my-secondary-subnetwork-00
      ipCidrRange: 10.5.0.0/16
      region: us-central1
      network: default
    options:
      dependsOn:
        - ${wait120Seconds}
  cpsTopic:
    type: gcp:pubsub:Topic
    name: cps_topic
    properties:
      project: ${project.projectId}
      name: my-cps-topic
      messageRetentionDuration: 86600s
  gmkCluster:
    type: gcp:managedkafka:Cluster
    name: gmk_cluster
    properties:
      project: ${project.projectId}
      clusterId: my-cluster
      location: us-central1
      capacityConfig:
        vcpuCount: 3
        memoryBytes: 3.221225472e+09
      gcpConfig:
        accessConfig:
          networkConfigs:
            - subnet: projects/${project.projectId}/regions/us-central1/subnetworks/default
    options:
      dependsOn:
        - ${managedkafka}
  gmkTopic:
    type: gcp:managedkafka:Topic
    name: gmk_topic
    properties:
      project: ${project.projectId}
      topicId: my-topic
      cluster: ${gmkCluster.clusterId}
      location: us-central1
      partitionCount: 2
      replicationFactor: 3
    options:
      dependsOn:
        - ${managedkafka}
  mkcCluster:
    type: gcp:managedkafka:ConnectCluster
    name: mkc_cluster
    properties:
      project: ${project.projectId}
      connectClusterId: my-connect-cluster
      kafkaCluster: projects/${project.projectId}/locations/us-central1/clusters/${gmkCluster.clusterId}
      location: us-central1
      capacityConfig:
        vcpuCount: 12
        memoryBytes: 2.147483648e+10
      gcpConfig:
        accessConfig:
          networkConfigs:
            - primarySubnet: projects/${project.projectId}/regions/us-central1/subnetworks/default
              additionalSubnets:
                - ${mkcSecondarySubnet.id}
              dnsDomainNames:
                - ${gmkCluster.clusterId}.us-central1.managedkafka.${project.projectId}.cloud.goog
      labels:
        key: value
    options:
      dependsOn:
        - ${managedkafka}
  example:
    type: gcp:managedkafka:Connector
    properties:
      project: ${project.projectId}
      connectorId: my-connector
      connectCluster: ${mkcCluster.connectClusterId}
      location: us-central1
      configs:
        connector.class: com.google.pubsub.kafka.sink.CloudPubSubSinkConnector
        name: my-connector
        tasks.max: '1'
        topics: ${gmkTopic.topicId}
        cps.topic: ${cpsTopic.name}
        cps.project: ${project.projectId}
        value.converter: org.apache.kafka.connect.storage.StringConverter
        key.converter: org.apache.kafka.connect.storage.StringConverter
      taskRestartPolicy:
        minimumBackoff: 60s
        maximumBackoff: 1800s
    options:
      dependsOn:
        - ${managedkafka}
Content copied to clipboard

Import

Connector can be imported using any of these accepted formats:

  • projects/{{project}}/locations/{{location}}/connectClusters/{{connect_cluster}}/connectors/{{connector_id}}

  • {{project}}/{{location}}/{{connect_cluster}}/{{connector_id}}

  • {{location}}/{{connect_cluster}}/{{connector_id}} When using the pulumi import command, Connector can be imported using one of the formats above. For example:

$ pulumi import gcp:managedkafka/connector:Connector default projects/{{project}}/locations/{{location}}/connectClusters/{{connect_cluster}}/connectors/{{connector_id}}
Content copied to clipboard
$ pulumi import gcp:managedkafka/connector:Connector default {{project}}/{{location}}/{{connect_cluster}}/{{connector_id}}
Content copied to clipboard
$ pulumi import gcp:managedkafka/connector:Connector default {{location}}/{{connect_cluster}}/{{connector_id}}
Content copied to clipboard

Properties

Link copied to clipboard
val configs: Output<Map<String, String>>?

Connector config as keys/values. The keys of the map are connector property names, for example: connector.class, tasks.max, key.converter.

Link copied to clipboard
val connectCluster: Output<String>

The connect cluster name.

Link copied to clipboard
val connectorId: Output<String>

The ID to use for the connector, which will become the final component of the connector's name. This value is structured like: my-connector-id.

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

ID of the location of the Kafka Connect resource. See https://cloud.google.com/managed-kafka/docs/locations for a list of supported locations.

Link copied to clipboard
val name: Output<String>

The name of the connector. The connector segment is used when connecting directly to the connect cluster. Structured like: projects/PROJECT_ID/locations/LOCATION/connectClusters/CONNECT_CLUSTER/connectors/CONNECTOR_ID.

Link copied to clipboard
val project: Output<String>

The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val state: Output<String>

The current state of the connect. Possible values: STATE_UNSPECIFIED, UNASSIGNED, RUNNING, PAUSED, FAILED, RESTARTING, and STOPPED.

Link copied to clipboard
val taskRestartPolicy: Output<ConnectorTaskRestartPolicy>?

A policy that specifies how to restart the failed connectors/tasks in a Cluster resource. If not set, the failed connectors/tasks won't be restarted. Structure is documented below.

Link copied to clipboard
val urn: Output<String>