gcp.datastream.Stream

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
import * as random from "@pulumi/random";

const project = gcp.organizations.getProject({});
const instance = new gcp.sql.DatabaseInstance("instance", {
    name: "my-instance",
    databaseVersion: "MYSQL_8_0",
    region: "us-central1",
    settings: {
        tier: "db-f1-micro",
        backupConfiguration: {
            enabled: true,
            binaryLogEnabled: true,
        },
        ipConfiguration: {
            authorizedNetworks: [
                {
                    value: "34.71.242.81",
                },
                {
                    value: "34.72.28.29",
                },
                {
                    value: "34.67.6.157",
                },
                {
                    value: "34.67.234.134",
                },
                {
                    value: "34.72.239.218",
                },
            ],
        },
    },
    deletionProtection: true,
});
const db = new gcp.sql.Database("db", {
    instance: instance.name,
    name: "db",
});
const pwd = new random.RandomPassword("pwd", {
    length: 16,
    special: false,
});
const user = new gcp.sql.User("user", {
    name: "user",
    instance: instance.name,
    host: "%",
    password: pwd.result,
});
const sourceConnectionProfile = new gcp.datastream.ConnectionProfile("source_connection_profile", {
    displayName: "Source connection profile",
    location: "us-central1",
    connectionProfileId: "source-profile",
    mysqlProfile: {
        hostname: instance.publicIpAddress,
        username: user.name,
        password: user.password,
    },
});
const bucket = new gcp.storage.Bucket("bucket", {
    name: "my-bucket",
    location: "US",
    uniformBucketLevelAccess: true,
});
const viewer = new gcp.storage.BucketIAMMember("viewer", {
    bucket: bucket.name,
    role: "roles/storage.objectViewer",
    member: project.then(project => `serviceAccount:service-${project.number}@gcp-sa-datastream.iam.gserviceaccount.com`),
});
const creator = new gcp.storage.BucketIAMMember("creator", {
    bucket: bucket.name,
    role: "roles/storage.objectCreator",
    member: project.then(project => `serviceAccount:service-${project.number}@gcp-sa-datastream.iam.gserviceaccount.com`),
});
const reader = new gcp.storage.BucketIAMMember("reader", {
    bucket: bucket.name,
    role: "roles/storage.legacyBucketReader",
    member: project.then(project => `serviceAccount:service-${project.number}@gcp-sa-datastream.iam.gserviceaccount.com`),
});
const keyUser = new gcp.kms.CryptoKeyIAMMember("key_user", {
    cryptoKeyId: "kms-name",
    role: "roles/cloudkms.cryptoKeyEncrypterDecrypter",
    member: project.then(project => `serviceAccount:service-${project.number}@gcp-sa-datastream.iam.gserviceaccount.com`),
});
const destinationConnectionProfile = new gcp.datastream.ConnectionProfile("destination_connection_profile", {
    displayName: "Connection profile",
    location: "us-central1",
    connectionProfileId: "destination-profile",
    gcsProfile: {
        bucket: bucket.name,
        rootPath: "/path",
    },
});
const _default = new gcp.datastream.Stream("default", {
    streamId: "my-stream",
    desiredState: "NOT_STARTED",
    location: "us-central1",
    displayName: "my stream",
    labels: {
        key: "value",
    },
    sourceConfig: {
        sourceConnectionProfile: sourceConnectionProfile.id,
        mysqlSourceConfig: {
            includeObjects: {
                mysqlDatabases: [{
                    database: "my-database",
                    mysqlTables: [
                        {
                            table: "includedTable",
                            mysqlColumns: [{
                                column: "includedColumn",
                                dataType: "VARCHAR",
                                collation: "utf8mb4",
                                primaryKey: false,
                                nullable: false,
                                ordinalPosition: 0,
                            }],
                        },
                        {
                            table: "includedTable_2",
                        },
                    ],
                }],
            },
            excludeObjects: {
                mysqlDatabases: [{
                    database: "my-database",
                    mysqlTables: [{
                        table: "excludedTable",
                        mysqlColumns: [{
                            column: "excludedColumn",
                            dataType: "VARCHAR",
                            collation: "utf8mb4",
                            primaryKey: false,
                            nullable: false,
                            ordinalPosition: 0,
                        }],
                    }],
                }],
            },
            maxConcurrentCdcTasks: 5,
        },
    },
    destinationConfig: {
        destinationConnectionProfile: destinationConnectionProfile.id,
        gcsDestinationConfig: {
            path: "mydata",
            fileRotationMb: 200,
            fileRotationInterval: "60s",
            jsonFileFormat: {
                schemaFileFormat: "NO_SCHEMA_FILE",
                compression: "GZIP",
            },
        },
    },
    backfillAll: {
        mysqlExcludedObjects: {
            mysqlDatabases: [{
                database: "my-database",
                mysqlTables: [{
                    table: "excludedTable",
                    mysqlColumns: [{
                        column: "excludedColumn",
                        dataType: "VARCHAR",
                        collation: "utf8mb4",
                        primaryKey: false,
                        nullable: false,
                        ordinalPosition: 0,
                    }],
                }],
            }],
        },
    },
    customerManagedEncryptionKey: "kms-name",
}, {
    dependsOn: [keyUser],
});

import pulumi
import pulumi_gcp as gcp
import pulumi_random as random

project = gcp.organizations.get_project()
instance = gcp.sql.DatabaseInstance("instance",
    name="my-instance",
    database_version="MYSQL_8_0",
    region="us-central1",
    settings={
        "tier": "db-f1-micro",
        "backup_configuration": {
            "enabled": True,
            "binary_log_enabled": True,
        },
        "ip_configuration": {
            "authorized_networks": [
                {
                    "value": "34.71.242.81",
                },
                {
                    "value": "34.72.28.29",
                },
                {
                    "value": "34.67.6.157",
                },
                {
                    "value": "34.67.234.134",
                },
                {
                    "value": "34.72.239.218",
                },
            ],
        },
    },
    deletion_protection=True)
db = gcp.sql.Database("db",
    instance=instance.name,
    name="db")
pwd = random.RandomPassword("pwd",
    length=16,
    special=False)
user = gcp.sql.User("user",
    name="user",
    instance=instance.name,
    host="%",
    password=pwd.result)
source_connection_profile = gcp.datastream.ConnectionProfile("source_connection_profile",
    display_name="Source connection profile",
    location="us-central1",
    connection_profile_id="source-profile",
    mysql_profile={
        "hostname": instance.public_ip_address,
        "username": user.name,
        "password": user.password,
    })
bucket = gcp.storage.Bucket("bucket",
    name="my-bucket",
    location="US",
    uniform_bucket_level_access=True)
viewer = gcp.storage.BucketIAMMember("viewer",
    bucket=bucket.name,
    role="roles/storage.objectViewer",
    member=f"serviceAccount:service-{project.number}@gcp-sa-datastream.iam.gserviceaccount.com")
creator = gcp.storage.BucketIAMMember("creator",
    bucket=bucket.name,
    role="roles/storage.objectCreator",
    member=f"serviceAccount:service-{project.number}@gcp-sa-datastream.iam.gserviceaccount.com")
reader = gcp.storage.BucketIAMMember("reader",
    bucket=bucket.name,
    role="roles/storage.legacyBucketReader",
    member=f"serviceAccount:service-{project.number}@gcp-sa-datastream.iam.gserviceaccount.com")
key_user = gcp.kms.CryptoKeyIAMMember("key_user",
    crypto_key_id="kms-name",
    role="roles/cloudkms.cryptoKeyEncrypterDecrypter",
    member=f"serviceAccount:service-{project.number}@gcp-sa-datastream.iam.gserviceaccount.com")
destination_connection_profile = gcp.datastream.ConnectionProfile("destination_connection_profile",
    display_name="Connection profile",
    location="us-central1",
    connection_profile_id="destination-profile",
    gcs_profile={
        "bucket": bucket.name,
        "root_path": "/path",
    })
default = gcp.datastream.Stream("default",
    stream_id="my-stream",
    desired_state="NOT_STARTED",
    location="us-central1",
    display_name="my stream",
    labels={
        "key": "value",
    },
    source_config={
        "source_connection_profile": source_connection_profile.id,
        "mysql_source_config": {
            "include_objects": {
                "mysql_databases": [{
                    "database": "my-database",
                    "mysql_tables": [
                        {
                            "table": "includedTable",
                            "mysql_columns": [{
                                "column": "includedColumn",
                                "data_type": "VARCHAR",
                                "collation": "utf8mb4",
                                "primary_key": False,
                                "nullable": False,
                                "ordinal_position": 0,
                            }],
                        },
                        {
                            "table": "includedTable_2",
                        },
                    ],
                }],
            },
            "exclude_objects": {
                "mysql_databases": [{
                    "database": "my-database",
                    "mysql_tables": [{
                        "table": "excludedTable",
                        "mysql_columns": [{
                            "column": "excludedColumn",
                            "data_type": "VARCHAR",
                            "collation": "utf8mb4",
                            "primary_key": False,
                            "nullable": False,
                            "ordinal_position": 0,
                        }],
                    }],
                }],
            },
            "max_concurrent_cdc_tasks": 5,
        },
    },
    destination_config={
        "destination_connection_profile": destination_connection_profile.id,
        "gcs_destination_config": {
            "path": "mydata",
            "file_rotation_mb": 200,
            "file_rotation_interval": "60s",
            "json_file_format": {
                "schema_file_format": "NO_SCHEMA_FILE",
                "compression": "GZIP",
            },
        },
    },
    backfill_all={
        "mysql_excluded_objects": {
            "mysql_databases": [{
                "database": "my-database",
                "mysql_tables": [{
                    "table": "excludedTable",
                    "mysql_columns": [{
                        "column": "excludedColumn",
                        "data_type": "VARCHAR",
                        "collation": "utf8mb4",
                        "primary_key": False,
                        "nullable": False,
                        "ordinal_position": 0,
                    }],
                }],
            }],
        },
    },
    customer_managed_encryption_key="kms-name",
    opts = pulumi.ResourceOptions(depends_on=[key_user]))

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/datastream"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/kms"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/organizations"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/sql"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/storage"
	"github.com/pulumi/pulumi-random/sdk/v4/go/random"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		project, err := organizations.LookupProject(ctx, nil, nil)
		if err != nil {
			return err
		}
		instance, err := sql.NewDatabaseInstance(ctx, "instance", &sql.DatabaseInstanceArgs{
			Name:            pulumi.String("my-instance"),
			DatabaseVersion: pulumi.String("MYSQL_8_0"),
			Region:          pulumi.String("us-central1"),
			Settings: &sql.DatabaseInstanceSettingsArgs{
				Tier: pulumi.String("db-f1-micro"),
				BackupConfiguration: &sql.DatabaseInstanceSettingsBackupConfigurationArgs{
					Enabled:          pulumi.Bool(true),
					BinaryLogEnabled: pulumi.Bool(true),
				},
				IpConfiguration: &sql.DatabaseInstanceSettingsIpConfigurationArgs{
					AuthorizedNetworks: sql.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArray{
						&sql.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs{
							Value: pulumi.String("34.71.242.81"),
						},
						&sql.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs{
							Value: pulumi.String("34.72.28.29"),
						},
						&sql.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs{
							Value: pulumi.String("34.67.6.157"),
						},
						&sql.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs{
							Value: pulumi.String("34.67.234.134"),
						},
						&sql.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs{
							Value: pulumi.String("34.72.239.218"),
						},
					},
				},
			},
			DeletionProtection: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = sql.NewDatabase(ctx, "db", &sql.DatabaseArgs{
			Instance: instance.Name,
			Name:     pulumi.String("db"),
		})
		if err != nil {
			return err
		}
		pwd, err := random.NewRandomPassword(ctx, "pwd", &random.RandomPasswordArgs{
			Length:  pulumi.Int(16),
			Special: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		user, err := sql.NewUser(ctx, "user", &sql.UserArgs{
			Name:     pulumi.String("user"),
			Instance: instance.Name,
			Host:     pulumi.String("%"),
			Password: pwd.Result,
		})
		if err != nil {
			return err
		}
		sourceConnectionProfile, err := datastream.NewConnectionProfile(ctx, "source_connection_profile", &datastream.ConnectionProfileArgs{
			DisplayName:         pulumi.String("Source connection profile"),
			Location:            pulumi.String("us-central1"),
			ConnectionProfileId: pulumi.String("source-profile"),
			MysqlProfile: &datastream.ConnectionProfileMysqlProfileArgs{
				Hostname: instance.PublicIpAddress,
				Username: user.Name,
				Password: user.Password,
			},
		})
		if err != nil {
			return err
		}
		bucket, err := storage.NewBucket(ctx, "bucket", &storage.BucketArgs{
			Name:                     pulumi.String("my-bucket"),
			Location:                 pulumi.String("US"),
			UniformBucketLevelAccess: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = storage.NewBucketIAMMember(ctx, "viewer", &storage.BucketIAMMemberArgs{
			Bucket: bucket.Name,
			Role:   pulumi.String("roles/storage.objectViewer"),
			Member: pulumi.Sprintf("serviceAccount:service-%v@gcp-sa-datastream.iam.gserviceaccount.com", project.Number),
		})
		if err != nil {
			return err
		}
		_, err = storage.NewBucketIAMMember(ctx, "creator", &storage.BucketIAMMemberArgs{
			Bucket: bucket.Name,
			Role:   pulumi.String("roles/storage.objectCreator"),
			Member: pulumi.Sprintf("serviceAccount:service-%v@gcp-sa-datastream.iam.gserviceaccount.com", project.Number),
		})
		if err != nil {
			return err
		}
		_, err = storage.NewBucketIAMMember(ctx, "reader", &storage.BucketIAMMemberArgs{
			Bucket: bucket.Name,
			Role:   pulumi.String("roles/storage.legacyBucketReader"),
			Member: pulumi.Sprintf("serviceAccount:service-%v@gcp-sa-datastream.iam.gserviceaccount.com", project.Number),
		})
		if err != nil {
			return err
		}
		keyUser, err := kms.NewCryptoKeyIAMMember(ctx, "key_user", &kms.CryptoKeyIAMMemberArgs{
			CryptoKeyId: pulumi.String("kms-name"),
			Role:        pulumi.String("roles/cloudkms.cryptoKeyEncrypterDecrypter"),
			Member:      pulumi.Sprintf("serviceAccount:service-%v@gcp-sa-datastream.iam.gserviceaccount.com", project.Number),
		})
		if err != nil {
			return err
		}
		destinationConnectionProfile, err := datastream.NewConnectionProfile(ctx, "destination_connection_profile", &datastream.ConnectionProfileArgs{
			DisplayName:         pulumi.String("Connection profile"),
			Location:            pulumi.String("us-central1"),
			ConnectionProfileId: pulumi.String("destination-profile"),
			GcsProfile: &datastream.ConnectionProfileGcsProfileArgs{
				Bucket:   bucket.Name,
				RootPath: pulumi.String("/path"),
			},
		})
		if err != nil {
			return err
		}
		_, err = datastream.NewStream(ctx, "default", &datastream.StreamArgs{
			StreamId:     pulumi.String("my-stream"),
			DesiredState: pulumi.String("NOT_STARTED"),
			Location:     pulumi.String("us-central1"),
			DisplayName:  pulumi.String("my stream"),
			Labels: pulumi.StringMap{
				"key": pulumi.String("value"),
			},
			SourceConfig: &datastream.StreamSourceConfigArgs{
				SourceConnectionProfile: sourceConnectionProfile.ID(),
				MysqlSourceConfig: &datastream.StreamSourceConfigMysqlSourceConfigArgs{
					IncludeObjects: &datastream.StreamSourceConfigMysqlSourceConfigIncludeObjectsArgs{
						MysqlDatabases: datastream.StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseArray{
							&datastream.StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseArgs{
								Database: pulumi.String("my-database"),
								MysqlTables: datastream.StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArray{
									&datastream.StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgs{
										Table: pulumi.String("includedTable"),
										MysqlColumns: datastream.StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableMysqlColumnArray{
											&datastream.StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs{
												Column:          pulumi.String("includedColumn"),
												DataType:        pulumi.String("VARCHAR"),
												Collation:       pulumi.String("utf8mb4"),
												PrimaryKey:      pulumi.Bool(false),
												Nullable:        pulumi.Bool(false),
												OrdinalPosition: pulumi.Int(0),
											},
										},
									},
									&datastream.StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgs{
										Table: pulumi.String("includedTable_2"),
									},
								},
							},
						},
					},
					ExcludeObjects: &datastream.StreamSourceConfigMysqlSourceConfigExcludeObjectsArgs{
						MysqlDatabases: datastream.StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseArray{
							&datastream.StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseArgs{
								Database: pulumi.String("my-database"),
								MysqlTables: datastream.StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableArray{
									&datastream.StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableArgs{
										Table: pulumi.String("excludedTable"),
										MysqlColumns: datastream.StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableMysqlColumnArray{
											&datastream.StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs{
												Column:          pulumi.String("excludedColumn"),
												DataType:        pulumi.String("VARCHAR"),
												Collation:       pulumi.String("utf8mb4"),
												PrimaryKey:      pulumi.Bool(false),
												Nullable:        pulumi.Bool(false),
												OrdinalPosition: pulumi.Int(0),
											},
										},
									},
								},
							},
						},
					},
					MaxConcurrentCdcTasks: pulumi.Int(5),
				},
			},
			DestinationConfig: &datastream.StreamDestinationConfigArgs{
				DestinationConnectionProfile: destinationConnectionProfile.ID(),
				GcsDestinationConfig: &datastream.StreamDestinationConfigGcsDestinationConfigArgs{
					Path:                 pulumi.String("mydata"),
					FileRotationMb:       pulumi.Int(200),
					FileRotationInterval: pulumi.String("60s"),
					JsonFileFormat: &datastream.StreamDestinationConfigGcsDestinationConfigJsonFileFormatArgs{
						SchemaFileFormat: pulumi.String("NO_SCHEMA_FILE"),
						Compression:      pulumi.String("GZIP"),
					},
				},
			},
			BackfillAll: &datastream.StreamBackfillAllArgs{
				MysqlExcludedObjects: &datastream.StreamBackfillAllMysqlExcludedObjectsArgs{
					MysqlDatabases: datastream.StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseArray{
						&datastream.StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseArgs{
							Database: pulumi.String("my-database"),
							MysqlTables: datastream.StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableArray{
								&datastream.StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableArgs{
									Table: pulumi.String("excludedTable"),
									MysqlColumns: datastream.StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableMysqlColumnArray{
										&datastream.StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableMysqlColumnArgs{
											Column:          pulumi.String("excludedColumn"),
											DataType:        pulumi.String("VARCHAR"),
											Collation:       pulumi.String("utf8mb4"),
											PrimaryKey:      pulumi.Bool(false),
											Nullable:        pulumi.Bool(false),
											OrdinalPosition: pulumi.Int(0),
										},
									},
								},
							},
						},
					},
				},
			},
			CustomerManagedEncryptionKey: pulumi.String("kms-name"),
		}, pulumi.DependsOn([]pulumi.Resource{
			keyUser,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
using Random = Pulumi.Random;

return await Deployment.RunAsync(() => 
{
    var project = Gcp.Organizations.GetProject.Invoke();

    var instance = new Gcp.Sql.DatabaseInstance("instance", new()
    {
        Name = "my-instance",
        DatabaseVersion = "MYSQL_8_0",
        Region = "us-central1",
        Settings = new Gcp.Sql.Inputs.DatabaseInstanceSettingsArgs
        {
            Tier = "db-f1-micro",
            BackupConfiguration = new Gcp.Sql.Inputs.DatabaseInstanceSettingsBackupConfigurationArgs
            {
                Enabled = true,
                BinaryLogEnabled = true,
            },
            IpConfiguration = new Gcp.Sql.Inputs.DatabaseInstanceSettingsIpConfigurationArgs
            {
                AuthorizedNetworks = new[]
                {
                    new Gcp.Sql.Inputs.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs
                    {
                        Value = "34.71.242.81",
                    },
                    new Gcp.Sql.Inputs.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs
                    {
                        Value = "34.72.28.29",
                    },
                    new Gcp.Sql.Inputs.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs
                    {
                        Value = "34.67.6.157",
                    },
                    new Gcp.Sql.Inputs.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs
                    {
                        Value = "34.67.234.134",
                    },
                    new Gcp.Sql.Inputs.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs
                    {
                        Value = "34.72.239.218",
                    },
                },
            },
        },
        DeletionProtection = true,
    });

    var db = new Gcp.Sql.Database("db", new()
    {
        Instance = instance.Name,
        Name = "db",
    });

    var pwd = new Random.RandomPassword("pwd", new()
    {
        Length = 16,
        Special = false,
    });

    var user = new Gcp.Sql.User("user", new()
    {
        Name = "user",
        Instance = instance.Name,
        Host = "%",
        Password = pwd.Result,
    });

    var sourceConnectionProfile = new Gcp.Datastream.ConnectionProfile("source_connection_profile", new()
    {
        DisplayName = "Source connection profile",
        Location = "us-central1",
        ConnectionProfileId = "source-profile",
        MysqlProfile = new Gcp.Datastream.Inputs.ConnectionProfileMysqlProfileArgs
        {
            Hostname = instance.PublicIpAddress,
            Username = user.Name,
            Password = user.Password,
        },
    });

    var bucket = new Gcp.Storage.Bucket("bucket", new()
    {
        Name = "my-bucket",
        Location = "US",
        UniformBucketLevelAccess = true,
    });

    var viewer = new Gcp.Storage.BucketIAMMember("viewer", new()
    {
        Bucket = bucket.Name,
        Role = "roles/storage.objectViewer",
        Member = $"serviceAccount:service-{project.Apply(getProjectResult => getProjectResult.Number)}@gcp-sa-datastream.iam.gserviceaccount.com",
    });

    var creator = new Gcp.Storage.BucketIAMMember("creator", new()
    {
        Bucket = bucket.Name,
        Role = "roles/storage.objectCreator",
        Member = $"serviceAccount:service-{project.Apply(getProjectResult => getProjectResult.Number)}@gcp-sa-datastream.iam.gserviceaccount.com",
    });

    var reader = new Gcp.Storage.BucketIAMMember("reader", new()
    {
        Bucket = bucket.Name,
        Role = "roles/storage.legacyBucketReader",
        Member = $"serviceAccount:service-{project.Apply(getProjectResult => getProjectResult.Number)}@gcp-sa-datastream.iam.gserviceaccount.com",
    });

    var keyUser = new Gcp.Kms.CryptoKeyIAMMember("key_user", new()
    {
        CryptoKeyId = "kms-name",
        Role = "roles/cloudkms.cryptoKeyEncrypterDecrypter",
        Member = $"serviceAccount:service-{project.Apply(getProjectResult => getProjectResult.Number)}@gcp-sa-datastream.iam.gserviceaccount.com",
    });

    var destinationConnectionProfile = new Gcp.Datastream.ConnectionProfile("destination_connection_profile", new()
    {
        DisplayName = "Connection profile",
        Location = "us-central1",
        ConnectionProfileId = "destination-profile",
        GcsProfile = new Gcp.Datastream.Inputs.ConnectionProfileGcsProfileArgs
        {
            Bucket = bucket.Name,
            RootPath = "/path",
        },
    });

    var @default = new Gcp.Datastream.Stream("default", new()
    {
        StreamId = "my-stream",
        DesiredState = "NOT_STARTED",
        Location = "us-central1",
        DisplayName = "my stream",
        Labels = 
        {
            { "key", "value" },
        },
        SourceConfig = new Gcp.Datastream.Inputs.StreamSourceConfigArgs
        {
            SourceConnectionProfile = sourceConnectionProfile.Id,
            MysqlSourceConfig = new Gcp.Datastream.Inputs.StreamSourceConfigMysqlSourceConfigArgs
            {
                IncludeObjects = new Gcp.Datastream.Inputs.StreamSourceConfigMysqlSourceConfigIncludeObjectsArgs
                {
                    MysqlDatabases = new[]
                    {
                        new Gcp.Datastream.Inputs.StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseArgs
                        {
                            Database = "my-database",
                            MysqlTables = new[]
                            {
                                new Gcp.Datastream.Inputs.StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgs
                                {
                                    Table = "includedTable",
                                    MysqlColumns = new[]
                                    {
                                        new Gcp.Datastream.Inputs.StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs
                                        {
                                            Column = "includedColumn",
                                            DataType = "VARCHAR",
                                            Collation = "utf8mb4",
                                            PrimaryKey = false,
                                            Nullable = false,
                                            OrdinalPosition = 0,
                                        },
                                    },
                                },
                                new Gcp.Datastream.Inputs.StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgs
                                {
                                    Table = "includedTable_2",
                                },
                            },
                        },
                    },
                },
                ExcludeObjects = new Gcp.Datastream.Inputs.StreamSourceConfigMysqlSourceConfigExcludeObjectsArgs
                {
                    MysqlDatabases = new[]
                    {
                        new Gcp.Datastream.Inputs.StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseArgs
                        {
                            Database = "my-database",
                            MysqlTables = new[]
                            {
                                new Gcp.Datastream.Inputs.StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableArgs
                                {
                                    Table = "excludedTable",
                                    MysqlColumns = new[]
                                    {
                                        new Gcp.Datastream.Inputs.StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs
                                        {
                                            Column = "excludedColumn",
                                            DataType = "VARCHAR",
                                            Collation = "utf8mb4",
                                            PrimaryKey = false,
                                            Nullable = false,
                                            OrdinalPosition = 0,
                                        },
                                    },
                                },
                            },
                        },
                    },
                },
                MaxConcurrentCdcTasks = 5,
            },
        },
        DestinationConfig = new Gcp.Datastream.Inputs.StreamDestinationConfigArgs
        {
            DestinationConnectionProfile = destinationConnectionProfile.Id,
            GcsDestinationConfig = new Gcp.Datastream.Inputs.StreamDestinationConfigGcsDestinationConfigArgs
            {
                Path = "mydata",
                FileRotationMb = 200,
                FileRotationInterval = "60s",
                JsonFileFormat = new Gcp.Datastream.Inputs.StreamDestinationConfigGcsDestinationConfigJsonFileFormatArgs
                {
                    SchemaFileFormat = "NO_SCHEMA_FILE",
                    Compression = "GZIP",
                },
            },
        },
        BackfillAll = new Gcp.Datastream.Inputs.StreamBackfillAllArgs
        {
            MysqlExcludedObjects = new Gcp.Datastream.Inputs.StreamBackfillAllMysqlExcludedObjectsArgs
            {
                MysqlDatabases = new[]
                {
                    new Gcp.Datastream.Inputs.StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseArgs
                    {
                        Database = "my-database",
                        MysqlTables = new[]
                        {
                            new Gcp.Datastream.Inputs.StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableArgs
                            {
                                Table = "excludedTable",
                                MysqlColumns = new[]
                                {
                                    new Gcp.Datastream.Inputs.StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableMysqlColumnArgs
                                    {
                                        Column = "excludedColumn",
                                        DataType = "VARCHAR",
                                        Collation = "utf8mb4",
                                        PrimaryKey = false,
                                        Nullable = false,
                                        OrdinalPosition = 0,
                                    },
                                },
                            },
                        },
                    },
                },
            },
        },
        CustomerManagedEncryptionKey = "kms-name",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            keyUser,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.organizations.OrganizationsFunctions;
import com.pulumi.gcp.organizations.inputs.GetProjectArgs;
import com.pulumi.gcp.sql.DatabaseInstance;
import com.pulumi.gcp.sql.DatabaseInstanceArgs;
import com.pulumi.gcp.sql.inputs.DatabaseInstanceSettingsArgs;
import com.pulumi.gcp.sql.inputs.DatabaseInstanceSettingsBackupConfigurationArgs;
import com.pulumi.gcp.sql.inputs.DatabaseInstanceSettingsIpConfigurationArgs;
import com.pulumi.gcp.sql.Database;
import com.pulumi.gcp.sql.DatabaseArgs;
import com.pulumi.random.RandomPassword;
import com.pulumi.random.RandomPasswordArgs;
import com.pulumi.gcp.sql.User;
import com.pulumi.gcp.sql.UserArgs;
import com.pulumi.gcp.datastream.ConnectionProfile;
import com.pulumi.gcp.datastream.ConnectionProfileArgs;
import com.pulumi.gcp.datastream.inputs.ConnectionProfileMysqlProfileArgs;
import com.pulumi.gcp.storage.Bucket;
import com.pulumi.gcp.storage.BucketArgs;
import com.pulumi.gcp.storage.BucketIAMMember;
import com.pulumi.gcp.storage.BucketIAMMemberArgs;
import com.pulumi.gcp.kms.CryptoKeyIAMMember;
import com.pulumi.gcp.kms.CryptoKeyIAMMemberArgs;
import com.pulumi.gcp.datastream.inputs.ConnectionProfileGcsProfileArgs;
import com.pulumi.gcp.datastream.Stream;
import com.pulumi.gcp.datastream.StreamArgs;
import com.pulumi.gcp.datastream.inputs.StreamSourceConfigArgs;
import com.pulumi.gcp.datastream.inputs.StreamSourceConfigMysqlSourceConfigArgs;
import com.pulumi.gcp.datastream.inputs.StreamSourceConfigMysqlSourceConfigIncludeObjectsArgs;
import com.pulumi.gcp.datastream.inputs.StreamSourceConfigMysqlSourceConfigExcludeObjectsArgs;
import com.pulumi.gcp.datastream.inputs.StreamDestinationConfigArgs;
import com.pulumi.gcp.datastream.inputs.StreamDestinationConfigGcsDestinationConfigArgs;
import com.pulumi.gcp.datastream.inputs.StreamDestinationConfigGcsDestinationConfigJsonFileFormatArgs;
import com.pulumi.gcp.datastream.inputs.StreamBackfillAllArgs;
import com.pulumi.gcp.datastream.inputs.StreamBackfillAllMysqlExcludedObjectsArgs;
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) {
        final var project = OrganizationsFunctions.getProject();

        var instance = new DatabaseInstance("instance", DatabaseInstanceArgs.builder()
            .name("my-instance")
            .databaseVersion("MYSQL_8_0")
            .region("us-central1")
            .settings(DatabaseInstanceSettingsArgs.builder()
                .tier("db-f1-micro")
                .backupConfiguration(DatabaseInstanceSettingsBackupConfigurationArgs.builder()
                    .enabled(true)
                    .binaryLogEnabled(true)
                    .build())
                .ipConfiguration(DatabaseInstanceSettingsIpConfigurationArgs.builder()
                    .authorizedNetworks(                    
                        DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs.builder()
                            .value("34.71.242.81")
                            .build(),
                        DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs.builder()
                            .value("34.72.28.29")
                            .build(),
                        DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs.builder()
                            .value("34.67.6.157")
                            .build(),
                        DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs.builder()
                            .value("34.67.234.134")
                            .build(),
                        DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs.builder()
                            .value("34.72.239.218")
                            .build())
                    .build())
                .build())
            .deletionProtection(true)
            .build());

        var db = new Database("db", DatabaseArgs.builder()
            .instance(instance.name())
            .name("db")
            .build());

        var pwd = new RandomPassword("pwd", RandomPasswordArgs.builder()
            .length(16)
            .special(false)
            .build());

        var user = new User("user", UserArgs.builder()
            .name("user")
            .instance(instance.name())
            .host("%")
            .password(pwd.result())
            .build());

        var sourceConnectionProfile = new ConnectionProfile("sourceConnectionProfile", ConnectionProfileArgs.builder()
            .displayName("Source connection profile")
            .location("us-central1")
            .connectionProfileId("source-profile")
            .mysqlProfile(ConnectionProfileMysqlProfileArgs.builder()
                .hostname(instance.publicIpAddress())
                .username(user.name())
                .password(user.password())
                .build())
            .build());

        var bucket = new Bucket("bucket", BucketArgs.builder()
            .name("my-bucket")
            .location("US")
            .uniformBucketLevelAccess(true)
            .build());

        var viewer = new BucketIAMMember("viewer", BucketIAMMemberArgs.builder()
            .bucket(bucket.name())
            .role("roles/storage.objectViewer")
            .member(String.format("serviceAccount:service-%s@gcp-sa-datastream.iam.gserviceaccount.com", project.applyValue(getProjectResult -> getProjectResult.number())))
            .build());

        var creator = new BucketIAMMember("creator", BucketIAMMemberArgs.builder()
            .bucket(bucket.name())
            .role("roles/storage.objectCreator")
            .member(String.format("serviceAccount:service-%s@gcp-sa-datastream.iam.gserviceaccount.com", project.applyValue(getProjectResult -> getProjectResult.number())))
            .build());

        var reader = new BucketIAMMember("reader", BucketIAMMemberArgs.builder()
            .bucket(bucket.name())
            .role("roles/storage.legacyBucketReader")
            .member(String.format("serviceAccount:service-%s@gcp-sa-datastream.iam.gserviceaccount.com", project.applyValue(getProjectResult -> getProjectResult.number())))
            .build());

        var keyUser = new CryptoKeyIAMMember("keyUser", CryptoKeyIAMMemberArgs.builder()
            .cryptoKeyId("kms-name")
            .role("roles/cloudkms.cryptoKeyEncrypterDecrypter")
            .member(String.format("serviceAccount:service-%s@gcp-sa-datastream.iam.gserviceaccount.com", project.applyValue(getProjectResult -> getProjectResult.number())))
            .build());

        var destinationConnectionProfile = new ConnectionProfile("destinationConnectionProfile", ConnectionProfileArgs.builder()
            .displayName("Connection profile")
            .location("us-central1")
            .connectionProfileId("destination-profile")
            .gcsProfile(ConnectionProfileGcsProfileArgs.builder()
                .bucket(bucket.name())
                .rootPath("/path")
                .build())
            .build());

        var default_ = new Stream("default", StreamArgs.builder()
            .streamId("my-stream")
            .desiredState("NOT_STARTED")
            .location("us-central1")
            .displayName("my stream")
            .labels(Map.of("key", "value"))
            .sourceConfig(StreamSourceConfigArgs.builder()
                .sourceConnectionProfile(sourceConnectionProfile.id())
                .mysqlSourceConfig(StreamSourceConfigMysqlSourceConfigArgs.builder()
                    .includeObjects(StreamSourceConfigMysqlSourceConfigIncludeObjectsArgs.builder()
                        .mysqlDatabases(StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseArgs.builder()
                            .database("my-database")
                            .mysqlTables(                            
                                StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgs.builder()
                                    .table("includedTable")
                                    .mysqlColumns(StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs.builder()
                                        .column("includedColumn")
                                        .dataType("VARCHAR")
                                        .collation("utf8mb4")
                                        .primaryKey(false)
                                        .nullable(false)
                                        .ordinalPosition(0)
                                        .build())
                                    .build(),
                                StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgs.builder()
                                    .table("includedTable_2")
                                    .build())
                            .build())
                        .build())
                    .excludeObjects(StreamSourceConfigMysqlSourceConfigExcludeObjectsArgs.builder()
                        .mysqlDatabases(StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseArgs.builder()
                            .database("my-database")
                            .mysqlTables(StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableArgs.builder()
                                .table("excludedTable")
                                .mysqlColumns(StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs.builder()
                                    .column("excludedColumn")
                                    .dataType("VARCHAR")
                                    .collation("utf8mb4")
                                    .primaryKey(false)
                                    .nullable(false)
                                    .ordinalPosition(0)
                                    .build())
                                .build())
                            .build())
                        .build())
                    .maxConcurrentCdcTasks(5)
                    .build())
                .build())
            .destinationConfig(StreamDestinationConfigArgs.builder()
                .destinationConnectionProfile(destinationConnectionProfile.id())
                .gcsDestinationConfig(StreamDestinationConfigGcsDestinationConfigArgs.builder()
                    .path("mydata")
                    .fileRotationMb(200)
                    .fileRotationInterval("60s")
                    .jsonFileFormat(StreamDestinationConfigGcsDestinationConfigJsonFileFormatArgs.builder()
                        .schemaFileFormat("NO_SCHEMA_FILE")
                        .compression("GZIP")
                        .build())
                    .build())
                .build())
            .backfillAll(StreamBackfillAllArgs.builder()
                .mysqlExcludedObjects(StreamBackfillAllMysqlExcludedObjectsArgs.builder()
                    .mysqlDatabases(StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseArgs.builder()
                        .database("my-database")
                        .mysqlTables(StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableArgs.builder()
                            .table("excludedTable")
                            .mysqlColumns(StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableMysqlColumnArgs.builder()
                                .column("excludedColumn")
                                .dataType("VARCHAR")
                                .collation("utf8mb4")
                                .primaryKey(false)
                                .nullable(false)
                                .ordinalPosition(0)
                                .build())
                            .build())
                        .build())
                    .build())
                .build())
            .customerManagedEncryptionKey("kms-name")
            .build(), CustomResourceOptions.builder()
                .dependsOn(keyUser)
                .build());

    }
}

resources:
  instance:
    type: gcp:sql:DatabaseInstance
    properties:
      name: my-instance
      databaseVersion: MYSQL_8_0
      region: us-central1
      settings:
        tier: db-f1-micro
        backupConfiguration:
          enabled: true
          binaryLogEnabled: true
        ipConfiguration:
          authorizedNetworks:
            - value: 34.71.242.81
            - value: 34.72.28.29
            - value: 34.67.6.157
            - value: 34.67.234.134
            - value: 34.72.239.218
      deletionProtection: true
  db:
    type: gcp:sql:Database
    properties:
      instance: ${instance.name}
      name: db
  pwd:
    type: random:RandomPassword
    properties:
      length: 16
      special: false
  user:
    type: gcp:sql:User
    properties:
      name: user
      instance: ${instance.name}
      host: '%'
      password: ${pwd.result}
  sourceConnectionProfile:
    type: gcp:datastream:ConnectionProfile
    name: source_connection_profile
    properties:
      displayName: Source connection profile
      location: us-central1
      connectionProfileId: source-profile
      mysqlProfile:
        hostname: ${instance.publicIpAddress}
        username: ${user.name}
        password: ${user.password}
  bucket:
    type: gcp:storage:Bucket
    properties:
      name: my-bucket
      location: US
      uniformBucketLevelAccess: true
  viewer:
    type: gcp:storage:BucketIAMMember
    properties:
      bucket: ${bucket.name}
      role: roles/storage.objectViewer
      member: serviceAccount:service-${project.number}@gcp-sa-datastream.iam.gserviceaccount.com
  creator:
    type: gcp:storage:BucketIAMMember
    properties:
      bucket: ${bucket.name}
      role: roles/storage.objectCreator
      member: serviceAccount:service-${project.number}@gcp-sa-datastream.iam.gserviceaccount.com
  reader:
    type: gcp:storage:BucketIAMMember
    properties:
      bucket: ${bucket.name}
      role: roles/storage.legacyBucketReader
      member: serviceAccount:service-${project.number}@gcp-sa-datastream.iam.gserviceaccount.com
  keyUser:
    type: gcp:kms:CryptoKeyIAMMember
    name: key_user
    properties:
      cryptoKeyId: kms-name
      role: roles/cloudkms.cryptoKeyEncrypterDecrypter
      member: serviceAccount:service-${project.number}@gcp-sa-datastream.iam.gserviceaccount.com
  destinationConnectionProfile:
    type: gcp:datastream:ConnectionProfile
    name: destination_connection_profile
    properties:
      displayName: Connection profile
      location: us-central1
      connectionProfileId: destination-profile
      gcsProfile:
        bucket: ${bucket.name}
        rootPath: /path
  default:
    type: gcp:datastream:Stream
    properties:
      streamId: my-stream
      desiredState: NOT_STARTED
      location: us-central1
      displayName: my stream
      labels:
        key: value
      sourceConfig:
        sourceConnectionProfile: ${sourceConnectionProfile.id}
        mysqlSourceConfig:
          includeObjects:
            mysqlDatabases:
              - database: my-database
                mysqlTables:
                  - table: includedTable
                    mysqlColumns:
                      - column: includedColumn
                        dataType: VARCHAR
                        collation: utf8mb4
                        primaryKey: false
                        nullable: false
                        ordinalPosition: 0
                  - table: includedTable_2
          excludeObjects:
            mysqlDatabases:
              - database: my-database
                mysqlTables:
                  - table: excludedTable
                    mysqlColumns:
                      - column: excludedColumn
                        dataType: VARCHAR
                        collation: utf8mb4
                        primaryKey: false
                        nullable: false
                        ordinalPosition: 0
          maxConcurrentCdcTasks: 5
      destinationConfig:
        destinationConnectionProfile: ${destinationConnectionProfile.id}
        gcsDestinationConfig:
          path: mydata
          fileRotationMb: 200
          fileRotationInterval: 60s
          jsonFileFormat:
            schemaFileFormat: NO_SCHEMA_FILE
            compression: GZIP
      backfillAll:
        mysqlExcludedObjects:
          mysqlDatabases:
            - database: my-database
              mysqlTables:
                - table: excludedTable
                  mysqlColumns:
                    - column: excludedColumn
                      dataType: VARCHAR
                      collation: utf8mb4
                      primaryKey: false
                      nullable: false
                      ordinalPosition: 0
      customerManagedEncryptionKey: kms-name
    options:
      dependson:
        - ${keyUser}
variables:
  project:
    fn::invoke:
      Function: gcp:organizations:getProject
      Arguments: {}