1. Packages
  2. Google Cloud (GCP) Classic
  3. API Docs
  4. datastream
  5. Stream
Google Cloud Classic v7.27.0 published on Thursday, Jun 13, 2024 by Pulumi

gcp.datastream.Stream

Explore with Pulumi AI

gcp logo
Google Cloud Classic v7.27.0 published on Thursday, Jun 13, 2024 by Pulumi

    A resource representing streaming data from a source to a destination.

    To get more information about Stream, see:

    Example Usage

    Datastream Stream Full

    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=gcp.sql.DatabaseInstanceSettingsArgs(
            tier="db-f1-micro",
            backup_configuration=gcp.sql.DatabaseInstanceSettingsBackupConfigurationArgs(
                enabled=True,
                binary_log_enabled=True,
            ),
            ip_configuration=gcp.sql.DatabaseInstanceSettingsIpConfigurationArgs(
                authorized_networks=[
                    gcp.sql.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs(
                        value="34.71.242.81",
                    ),
                    gcp.sql.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs(
                        value="34.72.28.29",
                    ),
                    gcp.sql.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs(
                        value="34.67.6.157",
                    ),
                    gcp.sql.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs(
                        value="34.67.234.134",
                    ),
                    gcp.sql.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs(
                        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=gcp.datastream.ConnectionProfileMysqlProfileArgs(
            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=gcp.datastream.ConnectionProfileGcsProfileArgs(
            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=gcp.datastream.StreamSourceConfigArgs(
            source_connection_profile=source_connection_profile.id,
            mysql_source_config=gcp.datastream.StreamSourceConfigMysqlSourceConfigArgs(
                include_objects=gcp.datastream.StreamSourceConfigMysqlSourceConfigIncludeObjectsArgs(
                    mysql_databases=[gcp.datastream.StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseArgs(
                        database="my-database",
                        mysql_tables=[
                            gcp.datastream.StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgs(
                                table="includedTable",
                                mysql_columns=[gcp.datastream.StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs(
                                    column="includedColumn",
                                    data_type="VARCHAR",
                                    collation="utf8mb4",
                                    primary_key=False,
                                    nullable=False,
                                    ordinal_position=0,
                                )],
                            ),
                            gcp.datastream.StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgs(
                                table="includedTable_2",
                            ),
                        ],
                    )],
                ),
                exclude_objects=gcp.datastream.StreamSourceConfigMysqlSourceConfigExcludeObjectsArgs(
                    mysql_databases=[gcp.datastream.StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseArgs(
                        database="my-database",
                        mysql_tables=[gcp.datastream.StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableArgs(
                            table="excludedTable",
                            mysql_columns=[gcp.datastream.StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs(
                                column="excludedColumn",
                                data_type="VARCHAR",
                                collation="utf8mb4",
                                primary_key=False,
                                nullable=False,
                                ordinal_position=0,
                            )],
                        )],
                    )],
                ),
                max_concurrent_cdc_tasks=5,
            ),
        ),
        destination_config=gcp.datastream.StreamDestinationConfigArgs(
            destination_connection_profile=destination_connection_profile.id,
            gcs_destination_config=gcp.datastream.StreamDestinationConfigGcsDestinationConfigArgs(
                path="mydata",
                file_rotation_mb=200,
                file_rotation_interval="60s",
                json_file_format=gcp.datastream.StreamDestinationConfigGcsDestinationConfigJsonFileFormatArgs(
                    schema_file_format="NO_SCHEMA_FILE",
                    compression="GZIP",
                ),
            ),
        ),
        backfill_all=gcp.datastream.StreamBackfillAllArgs(
            mysql_excluded_objects=gcp.datastream.StreamBackfillAllMysqlExcludedObjectsArgs(
                mysql_databases=[gcp.datastream.StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseArgs(
                    database="my-database",
                    mysql_tables=[gcp.datastream.StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableArgs(
                        table="excludedTable",
                        mysql_columns=[gcp.datastream.StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableMysqlColumnArgs(
                            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/v7/go/gcp/datastream"
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/kms"
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/sql"
    	"github.com/pulumi/pulumi-gcp/sdk/v7/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.String(fmt.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.String(fmt.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.String(fmt.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.String(fmt.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: {}
    

    Datastream Stream Postgresql

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const source = new gcp.datastream.ConnectionProfile("source", {
        displayName: "Postgresql Source",
        location: "us-central1",
        connectionProfileId: "source-profile",
        postgresqlProfile: {
            hostname: "hostname",
            port: 3306,
            username: "user",
            password: "pass",
            database: "postgres",
        },
    });
    const destination = new gcp.datastream.ConnectionProfile("destination", {
        displayName: "BigQuery Destination",
        location: "us-central1",
        connectionProfileId: "destination-profile",
        bigqueryProfile: {},
    });
    const _default = new gcp.datastream.Stream("default", {
        displayName: "Postgres to BigQuery",
        location: "us-central1",
        streamId: "my-stream",
        desiredState: "RUNNING",
        sourceConfig: {
            sourceConnectionProfile: source.id,
            postgresqlSourceConfig: {
                maxConcurrentBackfillTasks: 12,
                publication: "publication",
                replicationSlot: "replication_slot",
                includeObjects: {
                    postgresqlSchemas: [{
                        schema: "schema",
                        postgresqlTables: [{
                            table: "table",
                            postgresqlColumns: [{
                                column: "column",
                            }],
                        }],
                    }],
                },
                excludeObjects: {
                    postgresqlSchemas: [{
                        schema: "schema",
                        postgresqlTables: [{
                            table: "table",
                            postgresqlColumns: [{
                                column: "column",
                            }],
                        }],
                    }],
                },
            },
        },
        destinationConfig: {
            destinationConnectionProfile: destination.id,
            bigqueryDestinationConfig: {
                dataFreshness: "900s",
                sourceHierarchyDatasets: {
                    datasetTemplate: {
                        location: "us-central1",
                    },
                },
            },
        },
        backfillAll: {
            postgresqlExcludedObjects: {
                postgresqlSchemas: [{
                    schema: "schema",
                    postgresqlTables: [{
                        table: "table",
                        postgresqlColumns: [{
                            column: "column",
                        }],
                    }],
                }],
            },
        },
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    source = gcp.datastream.ConnectionProfile("source",
        display_name="Postgresql Source",
        location="us-central1",
        connection_profile_id="source-profile",
        postgresql_profile=gcp.datastream.ConnectionProfilePostgresqlProfileArgs(
            hostname="hostname",
            port=3306,
            username="user",
            password="pass",
            database="postgres",
        ))
    destination = gcp.datastream.ConnectionProfile("destination",
        display_name="BigQuery Destination",
        location="us-central1",
        connection_profile_id="destination-profile",
        bigquery_profile=gcp.datastream.ConnectionProfileBigqueryProfileArgs())
    default = gcp.datastream.Stream("default",
        display_name="Postgres to BigQuery",
        location="us-central1",
        stream_id="my-stream",
        desired_state="RUNNING",
        source_config=gcp.datastream.StreamSourceConfigArgs(
            source_connection_profile=source.id,
            postgresql_source_config=gcp.datastream.StreamSourceConfigPostgresqlSourceConfigArgs(
                max_concurrent_backfill_tasks=12,
                publication="publication",
                replication_slot="replication_slot",
                include_objects=gcp.datastream.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsArgs(
                    postgresql_schemas=[gcp.datastream.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArgs(
                        schema="schema",
                        postgresql_tables=[gcp.datastream.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTableArgs(
                            table="table",
                            postgresql_columns=[gcp.datastream.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs(
                                column="column",
                            )],
                        )],
                    )],
                ),
                exclude_objects=gcp.datastream.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsArgs(
                    postgresql_schemas=[gcp.datastream.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArgs(
                        schema="schema",
                        postgresql_tables=[gcp.datastream.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTableArgs(
                            table="table",
                            postgresql_columns=[gcp.datastream.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs(
                                column="column",
                            )],
                        )],
                    )],
                ),
            ),
        ),
        destination_config=gcp.datastream.StreamDestinationConfigArgs(
            destination_connection_profile=destination.id,
            bigquery_destination_config=gcp.datastream.StreamDestinationConfigBigqueryDestinationConfigArgs(
                data_freshness="900s",
                source_hierarchy_datasets=gcp.datastream.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs(
                    dataset_template=gcp.datastream.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs(
                        location="us-central1",
                    ),
                ),
            ),
        ),
        backfill_all=gcp.datastream.StreamBackfillAllArgs(
            postgresql_excluded_objects=gcp.datastream.StreamBackfillAllPostgresqlExcludedObjectsArgs(
                postgresql_schemas=[gcp.datastream.StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaArgs(
                    schema="schema",
                    postgresql_tables=[gcp.datastream.StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTableArgs(
                        table="table",
                        postgresql_columns=[gcp.datastream.StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs(
                            column="column",
                        )],
                    )],
                )],
            ),
        ))
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/datastream"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		source, err := datastream.NewConnectionProfile(ctx, "source", &datastream.ConnectionProfileArgs{
    			DisplayName:         pulumi.String("Postgresql Source"),
    			Location:            pulumi.String("us-central1"),
    			ConnectionProfileId: pulumi.String("source-profile"),
    			PostgresqlProfile: &datastream.ConnectionProfilePostgresqlProfileArgs{
    				Hostname: pulumi.String("hostname"),
    				Port:     pulumi.Int(3306),
    				Username: pulumi.String("user"),
    				Password: pulumi.String("pass"),
    				Database: pulumi.String("postgres"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		destination, err := datastream.NewConnectionProfile(ctx, "destination", &datastream.ConnectionProfileArgs{
    			DisplayName:         pulumi.String("BigQuery Destination"),
    			Location:            pulumi.String("us-central1"),
    			ConnectionProfileId: pulumi.String("destination-profile"),
    			BigqueryProfile:     nil,
    		})
    		if err != nil {
    			return err
    		}
    		_, err = datastream.NewStream(ctx, "default", &datastream.StreamArgs{
    			DisplayName:  pulumi.String("Postgres to BigQuery"),
    			Location:     pulumi.String("us-central1"),
    			StreamId:     pulumi.String("my-stream"),
    			DesiredState: pulumi.String("RUNNING"),
    			SourceConfig: &datastream.StreamSourceConfigArgs{
    				SourceConnectionProfile: source.ID(),
    				PostgresqlSourceConfig: &datastream.StreamSourceConfigPostgresqlSourceConfigArgs{
    					MaxConcurrentBackfillTasks: pulumi.Int(12),
    					Publication:                pulumi.String("publication"),
    					ReplicationSlot:            pulumi.String("replication_slot"),
    					IncludeObjects: &datastream.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsArgs{
    						PostgresqlSchemas: datastream.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArray{
    							&datastream.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArgs{
    								Schema: pulumi.String("schema"),
    								PostgresqlTables: datastream.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTableArray{
    									&datastream.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTableArgs{
    										Table: pulumi.String("table"),
    										PostgresqlColumns: datastream.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArray{
    											&datastream.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs{
    												Column: pulumi.String("column"),
    											},
    										},
    									},
    								},
    							},
    						},
    					},
    					ExcludeObjects: &datastream.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsArgs{
    						PostgresqlSchemas: datastream.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArray{
    							&datastream.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArgs{
    								Schema: pulumi.String("schema"),
    								PostgresqlTables: datastream.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTableArray{
    									&datastream.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTableArgs{
    										Table: pulumi.String("table"),
    										PostgresqlColumns: datastream.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArray{
    											&datastream.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs{
    												Column: pulumi.String("column"),
    											},
    										},
    									},
    								},
    							},
    						},
    					},
    				},
    			},
    			DestinationConfig: &datastream.StreamDestinationConfigArgs{
    				DestinationConnectionProfile: destination.ID(),
    				BigqueryDestinationConfig: &datastream.StreamDestinationConfigBigqueryDestinationConfigArgs{
    					DataFreshness: pulumi.String("900s"),
    					SourceHierarchyDatasets: &datastream.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs{
    						DatasetTemplate: &datastream.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs{
    							Location: pulumi.String("us-central1"),
    						},
    					},
    				},
    			},
    			BackfillAll: &datastream.StreamBackfillAllArgs{
    				PostgresqlExcludedObjects: &datastream.StreamBackfillAllPostgresqlExcludedObjectsArgs{
    					PostgresqlSchemas: datastream.StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaArray{
    						&datastream.StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaArgs{
    							Schema: pulumi.String("schema"),
    							PostgresqlTables: datastream.StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTableArray{
    								&datastream.StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTableArgs{
    									Table: pulumi.String("table"),
    									PostgresqlColumns: datastream.StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArray{
    										&datastream.StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs{
    											Column: pulumi.String("column"),
    										},
    									},
    								},
    							},
    						},
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Gcp = Pulumi.Gcp;
    
    return await Deployment.RunAsync(() => 
    {
        var source = new Gcp.Datastream.ConnectionProfile("source", new()
        {
            DisplayName = "Postgresql Source",
            Location = "us-central1",
            ConnectionProfileId = "source-profile",
            PostgresqlProfile = new Gcp.Datastream.Inputs.ConnectionProfilePostgresqlProfileArgs
            {
                Hostname = "hostname",
                Port = 3306,
                Username = "user",
                Password = "pass",
                Database = "postgres",
            },
        });
    
        var destination = new Gcp.Datastream.ConnectionProfile("destination", new()
        {
            DisplayName = "BigQuery Destination",
            Location = "us-central1",
            ConnectionProfileId = "destination-profile",
            BigqueryProfile = null,
        });
    
        var @default = new Gcp.Datastream.Stream("default", new()
        {
            DisplayName = "Postgres to BigQuery",
            Location = "us-central1",
            StreamId = "my-stream",
            DesiredState = "RUNNING",
            SourceConfig = new Gcp.Datastream.Inputs.StreamSourceConfigArgs
            {
                SourceConnectionProfile = source.Id,
                PostgresqlSourceConfig = new Gcp.Datastream.Inputs.StreamSourceConfigPostgresqlSourceConfigArgs
                {
                    MaxConcurrentBackfillTasks = 12,
                    Publication = "publication",
                    ReplicationSlot = "replication_slot",
                    IncludeObjects = new Gcp.Datastream.Inputs.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsArgs
                    {
                        PostgresqlSchemas = new[]
                        {
                            new Gcp.Datastream.Inputs.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArgs
                            {
                                Schema = "schema",
                                PostgresqlTables = new[]
                                {
                                    new Gcp.Datastream.Inputs.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTableArgs
                                    {
                                        Table = "table",
                                        PostgresqlColumns = new[]
                                        {
                                            new Gcp.Datastream.Inputs.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs
                                            {
                                                Column = "column",
                                            },
                                        },
                                    },
                                },
                            },
                        },
                    },
                    ExcludeObjects = new Gcp.Datastream.Inputs.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsArgs
                    {
                        PostgresqlSchemas = new[]
                        {
                            new Gcp.Datastream.Inputs.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArgs
                            {
                                Schema = "schema",
                                PostgresqlTables = new[]
                                {
                                    new Gcp.Datastream.Inputs.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTableArgs
                                    {
                                        Table = "table",
                                        PostgresqlColumns = new[]
                                        {
                                            new Gcp.Datastream.Inputs.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs
                                            {
                                                Column = "column",
                                            },
                                        },
                                    },
                                },
                            },
                        },
                    },
                },
            },
            DestinationConfig = new Gcp.Datastream.Inputs.StreamDestinationConfigArgs
            {
                DestinationConnectionProfile = destination.Id,
                BigqueryDestinationConfig = new Gcp.Datastream.Inputs.StreamDestinationConfigBigqueryDestinationConfigArgs
                {
                    DataFreshness = "900s",
                    SourceHierarchyDatasets = new Gcp.Datastream.Inputs.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs
                    {
                        DatasetTemplate = new Gcp.Datastream.Inputs.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs
                        {
                            Location = "us-central1",
                        },
                    },
                },
            },
            BackfillAll = new Gcp.Datastream.Inputs.StreamBackfillAllArgs
            {
                PostgresqlExcludedObjects = new Gcp.Datastream.Inputs.StreamBackfillAllPostgresqlExcludedObjectsArgs
                {
                    PostgresqlSchemas = new[]
                    {
                        new Gcp.Datastream.Inputs.StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaArgs
                        {
                            Schema = "schema",
                            PostgresqlTables = new[]
                            {
                                new Gcp.Datastream.Inputs.StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTableArgs
                                {
                                    Table = "table",
                                    PostgresqlColumns = new[]
                                    {
                                        new Gcp.Datastream.Inputs.StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs
                                        {
                                            Column = "column",
                                        },
                                    },
                                },
                            },
                        },
                    },
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.gcp.datastream.ConnectionProfile;
    import com.pulumi.gcp.datastream.ConnectionProfileArgs;
    import com.pulumi.gcp.datastream.inputs.ConnectionProfilePostgresqlProfileArgs;
    import com.pulumi.gcp.datastream.inputs.ConnectionProfileBigqueryProfileArgs;
    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.StreamSourceConfigPostgresqlSourceConfigArgs;
    import com.pulumi.gcp.datastream.inputs.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsArgs;
    import com.pulumi.gcp.datastream.inputs.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsArgs;
    import com.pulumi.gcp.datastream.inputs.StreamDestinationConfigArgs;
    import com.pulumi.gcp.datastream.inputs.StreamDestinationConfigBigqueryDestinationConfigArgs;
    import com.pulumi.gcp.datastream.inputs.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs;
    import com.pulumi.gcp.datastream.inputs.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs;
    import com.pulumi.gcp.datastream.inputs.StreamBackfillAllArgs;
    import com.pulumi.gcp.datastream.inputs.StreamBackfillAllPostgresqlExcludedObjectsArgs;
    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 source = new ConnectionProfile("source", ConnectionProfileArgs.builder()
                .displayName("Postgresql Source")
                .location("us-central1")
                .connectionProfileId("source-profile")
                .postgresqlProfile(ConnectionProfilePostgresqlProfileArgs.builder()
                    .hostname("hostname")
                    .port(3306)
                    .username("user")
                    .password("pass")
                    .database("postgres")
                    .build())
                .build());
    
            var destination = new ConnectionProfile("destination", ConnectionProfileArgs.builder()
                .displayName("BigQuery Destination")
                .location("us-central1")
                .connectionProfileId("destination-profile")
                .bigqueryProfile()
                .build());
    
            var default_ = new Stream("default", StreamArgs.builder()
                .displayName("Postgres to BigQuery")
                .location("us-central1")
                .streamId("my-stream")
                .desiredState("RUNNING")
                .sourceConfig(StreamSourceConfigArgs.builder()
                    .sourceConnectionProfile(source.id())
                    .postgresqlSourceConfig(StreamSourceConfigPostgresqlSourceConfigArgs.builder()
                        .maxConcurrentBackfillTasks(12)
                        .publication("publication")
                        .replicationSlot("replication_slot")
                        .includeObjects(StreamSourceConfigPostgresqlSourceConfigIncludeObjectsArgs.builder()
                            .postgresqlSchemas(StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArgs.builder()
                                .schema("schema")
                                .postgresqlTables(StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTableArgs.builder()
                                    .table("table")
                                    .postgresqlColumns(StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs.builder()
                                        .column("column")
                                        .build())
                                    .build())
                                .build())
                            .build())
                        .excludeObjects(StreamSourceConfigPostgresqlSourceConfigExcludeObjectsArgs.builder()
                            .postgresqlSchemas(StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArgs.builder()
                                .schema("schema")
                                .postgresqlTables(StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTableArgs.builder()
                                    .table("table")
                                    .postgresqlColumns(StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs.builder()
                                        .column("column")
                                        .build())
                                    .build())
                                .build())
                            .build())
                        .build())
                    .build())
                .destinationConfig(StreamDestinationConfigArgs.builder()
                    .destinationConnectionProfile(destination.id())
                    .bigqueryDestinationConfig(StreamDestinationConfigBigqueryDestinationConfigArgs.builder()
                        .dataFreshness("900s")
                        .sourceHierarchyDatasets(StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs.builder()
                            .datasetTemplate(StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs.builder()
                                .location("us-central1")
                                .build())
                            .build())
                        .build())
                    .build())
                .backfillAll(StreamBackfillAllArgs.builder()
                    .postgresqlExcludedObjects(StreamBackfillAllPostgresqlExcludedObjectsArgs.builder()
                        .postgresqlSchemas(StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaArgs.builder()
                            .schema("schema")
                            .postgresqlTables(StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTableArgs.builder()
                                .table("table")
                                .postgresqlColumns(StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs.builder()
                                    .column("column")
                                    .build())
                                .build())
                            .build())
                        .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      source:
        type: gcp:datastream:ConnectionProfile
        properties:
          displayName: Postgresql Source
          location: us-central1
          connectionProfileId: source-profile
          postgresqlProfile:
            hostname: hostname
            port: 3306
            username: user
            password: pass
            database: postgres
      destination:
        type: gcp:datastream:ConnectionProfile
        properties:
          displayName: BigQuery Destination
          location: us-central1
          connectionProfileId: destination-profile
          bigqueryProfile: {}
      default:
        type: gcp:datastream:Stream
        properties:
          displayName: Postgres to BigQuery
          location: us-central1
          streamId: my-stream
          desiredState: RUNNING
          sourceConfig:
            sourceConnectionProfile: ${source.id}
            postgresqlSourceConfig:
              maxConcurrentBackfillTasks: 12
              publication: publication
              replicationSlot: replication_slot
              includeObjects:
                postgresqlSchemas:
                  - schema: schema
                    postgresqlTables:
                      - table: table
                        postgresqlColumns:
                          - column: column
              excludeObjects:
                postgresqlSchemas:
                  - schema: schema
                    postgresqlTables:
                      - table: table
                        postgresqlColumns:
                          - column: column
          destinationConfig:
            destinationConnectionProfile: ${destination.id}
            bigqueryDestinationConfig:
              dataFreshness: 900s
              sourceHierarchyDatasets:
                datasetTemplate:
                  location: us-central1
          backfillAll:
            postgresqlExcludedObjects:
              postgresqlSchemas:
                - schema: schema
                  postgresqlTables:
                    - table: table
                      postgresqlColumns:
                        - column: column
    

    Datastream Stream Oracle

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const source = new gcp.datastream.ConnectionProfile("source", {
        displayName: "Oracle Source",
        location: "us-central1",
        connectionProfileId: "source-profile",
        oracleProfile: {
            hostname: "hostname",
            port: 1521,
            username: "user",
            password: "pass",
            databaseService: "ORCL",
        },
    });
    const destination = new gcp.datastream.ConnectionProfile("destination", {
        displayName: "BigQuery Destination",
        location: "us-central1",
        connectionProfileId: "destination-profile",
        bigqueryProfile: {},
    });
    const stream5 = new gcp.datastream.Stream("stream5", {
        displayName: "Oracle to BigQuery",
        location: "us-central1",
        streamId: "my-stream",
        desiredState: "RUNNING",
        sourceConfig: {
            sourceConnectionProfile: source.id,
            oracleSourceConfig: {
                maxConcurrentCdcTasks: 8,
                maxConcurrentBackfillTasks: 12,
                includeObjects: {
                    oracleSchemas: [{
                        schema: "schema",
                        oracleTables: [{
                            table: "table",
                            oracleColumns: [{
                                column: "column",
                            }],
                        }],
                    }],
                },
                excludeObjects: {
                    oracleSchemas: [{
                        schema: "schema",
                        oracleTables: [{
                            table: "table",
                            oracleColumns: [{
                                column: "column",
                            }],
                        }],
                    }],
                },
                dropLargeObjects: {},
            },
        },
        destinationConfig: {
            destinationConnectionProfile: destination.id,
            bigqueryDestinationConfig: {
                dataFreshness: "900s",
                sourceHierarchyDatasets: {
                    datasetTemplate: {
                        location: "us-central1",
                    },
                },
            },
        },
        backfillAll: {
            oracleExcludedObjects: {
                oracleSchemas: [{
                    schema: "schema",
                    oracleTables: [{
                        table: "table",
                        oracleColumns: [{
                            column: "column",
                        }],
                    }],
                }],
            },
        },
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    source = gcp.datastream.ConnectionProfile("source",
        display_name="Oracle Source",
        location="us-central1",
        connection_profile_id="source-profile",
        oracle_profile=gcp.datastream.ConnectionProfileOracleProfileArgs(
            hostname="hostname",
            port=1521,
            username="user",
            password="pass",
            database_service="ORCL",
        ))
    destination = gcp.datastream.ConnectionProfile("destination",
        display_name="BigQuery Destination",
        location="us-central1",
        connection_profile_id="destination-profile",
        bigquery_profile=gcp.datastream.ConnectionProfileBigqueryProfileArgs())
    stream5 = gcp.datastream.Stream("stream5",
        display_name="Oracle to BigQuery",
        location="us-central1",
        stream_id="my-stream",
        desired_state="RUNNING",
        source_config=gcp.datastream.StreamSourceConfigArgs(
            source_connection_profile=source.id,
            oracle_source_config=gcp.datastream.StreamSourceConfigOracleSourceConfigArgs(
                max_concurrent_cdc_tasks=8,
                max_concurrent_backfill_tasks=12,
                include_objects=gcp.datastream.StreamSourceConfigOracleSourceConfigIncludeObjectsArgs(
                    oracle_schemas=[gcp.datastream.StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaArgs(
                        schema="schema",
                        oracle_tables=[gcp.datastream.StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableArgs(
                            table="table",
                            oracle_columns=[gcp.datastream.StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArgs(
                                column="column",
                            )],
                        )],
                    )],
                ),
                exclude_objects=gcp.datastream.StreamSourceConfigOracleSourceConfigExcludeObjectsArgs(
                    oracle_schemas=[gcp.datastream.StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaArgs(
                        schema="schema",
                        oracle_tables=[gcp.datastream.StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableArgs(
                            table="table",
                            oracle_columns=[gcp.datastream.StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableOracleColumnArgs(
                                column="column",
                            )],
                        )],
                    )],
                ),
                drop_large_objects=gcp.datastream.StreamSourceConfigOracleSourceConfigDropLargeObjectsArgs(),
            ),
        ),
        destination_config=gcp.datastream.StreamDestinationConfigArgs(
            destination_connection_profile=destination.id,
            bigquery_destination_config=gcp.datastream.StreamDestinationConfigBigqueryDestinationConfigArgs(
                data_freshness="900s",
                source_hierarchy_datasets=gcp.datastream.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs(
                    dataset_template=gcp.datastream.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs(
                        location="us-central1",
                    ),
                ),
            ),
        ),
        backfill_all=gcp.datastream.StreamBackfillAllArgs(
            oracle_excluded_objects=gcp.datastream.StreamBackfillAllOracleExcludedObjectsArgs(
                oracle_schemas=[gcp.datastream.StreamBackfillAllOracleExcludedObjectsOracleSchemaArgs(
                    schema="schema",
                    oracle_tables=[gcp.datastream.StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableArgs(
                        table="table",
                        oracle_columns=[gcp.datastream.StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableOracleColumnArgs(
                            column="column",
                        )],
                    )],
                )],
            ),
        ))
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/datastream"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		source, err := datastream.NewConnectionProfile(ctx, "source", &datastream.ConnectionProfileArgs{
    			DisplayName:         pulumi.String("Oracle Source"),
    			Location:            pulumi.String("us-central1"),
    			ConnectionProfileId: pulumi.String("source-profile"),
    			OracleProfile: &datastream.ConnectionProfileOracleProfileArgs{
    				Hostname:        pulumi.String("hostname"),
    				Port:            pulumi.Int(1521),
    				Username:        pulumi.String("user"),
    				Password:        pulumi.String("pass"),
    				DatabaseService: pulumi.String("ORCL"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		destination, err := datastream.NewConnectionProfile(ctx, "destination", &datastream.ConnectionProfileArgs{
    			DisplayName:         pulumi.String("BigQuery Destination"),
    			Location:            pulumi.String("us-central1"),
    			ConnectionProfileId: pulumi.String("destination-profile"),
    			BigqueryProfile:     nil,
    		})
    		if err != nil {
    			return err
    		}
    		_, err = datastream.NewStream(ctx, "stream5", &datastream.StreamArgs{
    			DisplayName:  pulumi.String("Oracle to BigQuery"),
    			Location:     pulumi.String("us-central1"),
    			StreamId:     pulumi.String("my-stream"),
    			DesiredState: pulumi.String("RUNNING"),
    			SourceConfig: &datastream.StreamSourceConfigArgs{
    				SourceConnectionProfile: source.ID(),
    				OracleSourceConfig: &datastream.StreamSourceConfigOracleSourceConfigArgs{
    					MaxConcurrentCdcTasks:      pulumi.Int(8),
    					MaxConcurrentBackfillTasks: pulumi.Int(12),
    					IncludeObjects: &datastream.StreamSourceConfigOracleSourceConfigIncludeObjectsArgs{
    						OracleSchemas: datastream.StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaArray{
    							&datastream.StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaArgs{
    								Schema: pulumi.String("schema"),
    								OracleTables: datastream.StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableArray{
    									&datastream.StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableArgs{
    										Table: pulumi.String("table"),
    										OracleColumns: datastream.StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArray{
    											&datastream.StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArgs{
    												Column: pulumi.String("column"),
    											},
    										},
    									},
    								},
    							},
    						},
    					},
    					ExcludeObjects: &datastream.StreamSourceConfigOracleSourceConfigExcludeObjectsArgs{
    						OracleSchemas: datastream.StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaArray{
    							&datastream.StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaArgs{
    								Schema: pulumi.String("schema"),
    								OracleTables: datastream.StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableArray{
    									&datastream.StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableArgs{
    										Table: pulumi.String("table"),
    										OracleColumns: datastream.StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableOracleColumnArray{
    											&datastream.StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableOracleColumnArgs{
    												Column: pulumi.String("column"),
    											},
    										},
    									},
    								},
    							},
    						},
    					},
    					DropLargeObjects: nil,
    				},
    			},
    			DestinationConfig: &datastream.StreamDestinationConfigArgs{
    				DestinationConnectionProfile: destination.ID(),
    				BigqueryDestinationConfig: &datastream.StreamDestinationConfigBigqueryDestinationConfigArgs{
    					DataFreshness: pulumi.String("900s"),
    					SourceHierarchyDatasets: &datastream.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs{
    						DatasetTemplate: &datastream.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs{
    							Location: pulumi.String("us-central1"),
    						},
    					},
    				},
    			},
    			BackfillAll: &datastream.StreamBackfillAllArgs{
    				OracleExcludedObjects: &datastream.StreamBackfillAllOracleExcludedObjectsArgs{
    					OracleSchemas: datastream.StreamBackfillAllOracleExcludedObjectsOracleSchemaArray{
    						&datastream.StreamBackfillAllOracleExcludedObjectsOracleSchemaArgs{
    							Schema: pulumi.String("schema"),
    							OracleTables: datastream.StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableArray{
    								&datastream.StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableArgs{
    									Table: pulumi.String("table"),
    									OracleColumns: datastream.StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableOracleColumnArray{
    										&datastream.StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableOracleColumnArgs{
    											Column: pulumi.String("column"),
    										},
    									},
    								},
    							},
    						},
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Gcp = Pulumi.Gcp;
    
    return await Deployment.RunAsync(() => 
    {
        var source = new Gcp.Datastream.ConnectionProfile("source", new()
        {
            DisplayName = "Oracle Source",
            Location = "us-central1",
            ConnectionProfileId = "source-profile",
            OracleProfile = new Gcp.Datastream.Inputs.ConnectionProfileOracleProfileArgs
            {
                Hostname = "hostname",
                Port = 1521,
                Username = "user",
                Password = "pass",
                DatabaseService = "ORCL",
            },
        });
    
        var destination = new Gcp.Datastream.ConnectionProfile("destination", new()
        {
            DisplayName = "BigQuery Destination",
            Location = "us-central1",
            ConnectionProfileId = "destination-profile",
            BigqueryProfile = null,
        });
    
        var stream5 = new Gcp.Datastream.Stream("stream5", new()
        {
            DisplayName = "Oracle to BigQuery",
            Location = "us-central1",
            StreamId = "my-stream",
            DesiredState = "RUNNING",
            SourceConfig = new Gcp.Datastream.Inputs.StreamSourceConfigArgs
            {
                SourceConnectionProfile = source.Id,
                OracleSourceConfig = new Gcp.Datastream.Inputs.StreamSourceConfigOracleSourceConfigArgs
                {
                    MaxConcurrentCdcTasks = 8,
                    MaxConcurrentBackfillTasks = 12,
                    IncludeObjects = new Gcp.Datastream.Inputs.StreamSourceConfigOracleSourceConfigIncludeObjectsArgs
                    {
                        OracleSchemas = new[]
                        {
                            new Gcp.Datastream.Inputs.StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaArgs
                            {
                                Schema = "schema",
                                OracleTables = new[]
                                {
                                    new Gcp.Datastream.Inputs.StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableArgs
                                    {
                                        Table = "table",
                                        OracleColumns = new[]
                                        {
                                            new Gcp.Datastream.Inputs.StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArgs
                                            {
                                                Column = "column",
                                            },
                                        },
                                    },
                                },
                            },
                        },
                    },
                    ExcludeObjects = new Gcp.Datastream.Inputs.StreamSourceConfigOracleSourceConfigExcludeObjectsArgs
                    {
                        OracleSchemas = new[]
                        {
                            new Gcp.Datastream.Inputs.StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaArgs
                            {
                                Schema = "schema",
                                OracleTables = new[]
                                {
                                    new Gcp.Datastream.Inputs.StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableArgs
                                    {
                                        Table = "table",
                                        OracleColumns = new[]
                                        {
                                            new Gcp.Datastream.Inputs.StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableOracleColumnArgs
                                            {
                                                Column = "column",
                                            },
                                        },
                                    },
                                },
                            },
                        },
                    },
                    DropLargeObjects = null,
                },
            },
            DestinationConfig = new Gcp.Datastream.Inputs.StreamDestinationConfigArgs
            {
                DestinationConnectionProfile = destination.Id,
                BigqueryDestinationConfig = new Gcp.Datastream.Inputs.StreamDestinationConfigBigqueryDestinationConfigArgs
                {
                    DataFreshness = "900s",
                    SourceHierarchyDatasets = new Gcp.Datastream.Inputs.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs
                    {
                        DatasetTemplate = new Gcp.Datastream.Inputs.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs
                        {
                            Location = "us-central1",
                        },
                    },
                },
            },
            BackfillAll = new Gcp.Datastream.Inputs.StreamBackfillAllArgs
            {
                OracleExcludedObjects = new Gcp.Datastream.Inputs.StreamBackfillAllOracleExcludedObjectsArgs
                {
                    OracleSchemas = new[]
                    {
                        new Gcp.Datastream.Inputs.StreamBackfillAllOracleExcludedObjectsOracleSchemaArgs
                        {
                            Schema = "schema",
                            OracleTables = new[]
                            {
                                new Gcp.Datastream.Inputs.StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableArgs
                                {
                                    Table = "table",
                                    OracleColumns = new[]
                                    {
                                        new Gcp.Datastream.Inputs.StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableOracleColumnArgs
                                        {
                                            Column = "column",
                                        },
                                    },
                                },
                            },
                        },
                    },
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.gcp.datastream.ConnectionProfile;
    import com.pulumi.gcp.datastream.ConnectionProfileArgs;
    import com.pulumi.gcp.datastream.inputs.ConnectionProfileOracleProfileArgs;
    import com.pulumi.gcp.datastream.inputs.ConnectionProfileBigqueryProfileArgs;
    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.StreamSourceConfigOracleSourceConfigArgs;
    import com.pulumi.gcp.datastream.inputs.StreamSourceConfigOracleSourceConfigIncludeObjectsArgs;
    import com.pulumi.gcp.datastream.inputs.StreamSourceConfigOracleSourceConfigExcludeObjectsArgs;
    import com.pulumi.gcp.datastream.inputs.StreamSourceConfigOracleSourceConfigDropLargeObjectsArgs;
    import com.pulumi.gcp.datastream.inputs.StreamDestinationConfigArgs;
    import com.pulumi.gcp.datastream.inputs.StreamDestinationConfigBigqueryDestinationConfigArgs;
    import com.pulumi.gcp.datastream.inputs.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs;
    import com.pulumi.gcp.datastream.inputs.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs;
    import com.pulumi.gcp.datastream.inputs.StreamBackfillAllArgs;
    import com.pulumi.gcp.datastream.inputs.StreamBackfillAllOracleExcludedObjectsArgs;
    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 source = new ConnectionProfile("source", ConnectionProfileArgs.builder()
                .displayName("Oracle Source")
                .location("us-central1")
                .connectionProfileId("source-profile")
                .oracleProfile(ConnectionProfileOracleProfileArgs.builder()
                    .hostname("hostname")
                    .port(1521)
                    .username("user")
                    .password("pass")
                    .databaseService("ORCL")
                    .build())
                .build());
    
            var destination = new ConnectionProfile("destination", ConnectionProfileArgs.builder()
                .displayName("BigQuery Destination")
                .location("us-central1")
                .connectionProfileId("destination-profile")
                .bigqueryProfile()
                .build());
    
            var stream5 = new Stream("stream5", StreamArgs.builder()
                .displayName("Oracle to BigQuery")
                .location("us-central1")
                .streamId("my-stream")
                .desiredState("RUNNING")
                .sourceConfig(StreamSourceConfigArgs.builder()
                    .sourceConnectionProfile(source.id())
                    .oracleSourceConfig(StreamSourceConfigOracleSourceConfigArgs.builder()
                        .maxConcurrentCdcTasks(8)
                        .maxConcurrentBackfillTasks(12)
                        .includeObjects(StreamSourceConfigOracleSourceConfigIncludeObjectsArgs.builder()
                            .oracleSchemas(StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaArgs.builder()
                                .schema("schema")
                                .oracleTables(StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableArgs.builder()
                                    .table("table")
                                    .oracleColumns(StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArgs.builder()
                                        .column("column")
                                        .build())
                                    .build())
                                .build())
                            .build())
                        .excludeObjects(StreamSourceConfigOracleSourceConfigExcludeObjectsArgs.builder()
                            .oracleSchemas(StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaArgs.builder()
                                .schema("schema")
                                .oracleTables(StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableArgs.builder()
                                    .table("table")
                                    .oracleColumns(StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableOracleColumnArgs.builder()
                                        .column("column")
                                        .build())
                                    .build())
                                .build())
                            .build())
                        .dropLargeObjects()
                        .build())
                    .build())
                .destinationConfig(StreamDestinationConfigArgs.builder()
                    .destinationConnectionProfile(destination.id())
                    .bigqueryDestinationConfig(StreamDestinationConfigBigqueryDestinationConfigArgs.builder()
                        .dataFreshness("900s")
                        .sourceHierarchyDatasets(StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs.builder()
                            .datasetTemplate(StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs.builder()
                                .location("us-central1")
                                .build())
                            .build())
                        .build())
                    .build())
                .backfillAll(StreamBackfillAllArgs.builder()
                    .oracleExcludedObjects(StreamBackfillAllOracleExcludedObjectsArgs.builder()
                        .oracleSchemas(StreamBackfillAllOracleExcludedObjectsOracleSchemaArgs.builder()
                            .schema("schema")
                            .oracleTables(StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableArgs.builder()
                                .table("table")
                                .oracleColumns(StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableOracleColumnArgs.builder()
                                    .column("column")
                                    .build())
                                .build())
                            .build())
                        .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      source:
        type: gcp:datastream:ConnectionProfile
        properties:
          displayName: Oracle Source
          location: us-central1
          connectionProfileId: source-profile
          oracleProfile:
            hostname: hostname
            port: 1521
            username: user
            password: pass
            databaseService: ORCL
      destination:
        type: gcp:datastream:ConnectionProfile
        properties:
          displayName: BigQuery Destination
          location: us-central1
          connectionProfileId: destination-profile
          bigqueryProfile: {}
      stream5:
        type: gcp:datastream:Stream
        properties:
          displayName: Oracle to BigQuery
          location: us-central1
          streamId: my-stream
          desiredState: RUNNING
          sourceConfig:
            sourceConnectionProfile: ${source.id}
            oracleSourceConfig:
              maxConcurrentCdcTasks: 8
              maxConcurrentBackfillTasks: 12
              includeObjects:
                oracleSchemas:
                  - schema: schema
                    oracleTables:
                      - table: table
                        oracleColumns:
                          - column: column
              excludeObjects:
                oracleSchemas:
                  - schema: schema
                    oracleTables:
                      - table: table
                        oracleColumns:
                          - column: column
              dropLargeObjects: {}
          destinationConfig:
            destinationConnectionProfile: ${destination.id}
            bigqueryDestinationConfig:
              dataFreshness: 900s
              sourceHierarchyDatasets:
                datasetTemplate:
                  location: us-central1
          backfillAll:
            oracleExcludedObjects:
              oracleSchemas:
                - schema: schema
                  oracleTables:
                    - table: table
                      oracleColumns:
                        - column: column
    

    Datastream Stream Sql Server

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const instance = new gcp.sql.DatabaseInstance("instance", {
        name: "sql-server",
        databaseVersion: "SQLSERVER_2019_STANDARD",
        region: "us-central1",
        rootPassword: "root-password",
        deletionProtection: true,
        settings: {
            tier: "db-custom-2-4096",
            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",
                    },
                ],
            },
        },
    });
    const user = new gcp.sql.User("user", {
        name: "user",
        instance: instance.name,
        password: "password",
    });
    const db = new gcp.sql.Database("db", {
        name: "db",
        instance: instance.name,
    }, {
        dependsOn: [user],
    });
    const source = new gcp.datastream.ConnectionProfile("source", {
        displayName: "SQL Server Source",
        location: "us-central1",
        connectionProfileId: "source-profile",
        sqlServerProfile: {
            hostname: instance.publicIpAddress,
            port: 1433,
            username: user.name,
            password: user.password,
            database: db.name,
        },
    });
    const destination = new gcp.datastream.ConnectionProfile("destination", {
        displayName: "BigQuery Destination",
        location: "us-central1",
        connectionProfileId: "destination-profile",
        bigqueryProfile: {},
    });
    const _default = new gcp.datastream.Stream("default", {
        displayName: "SQL Server to BigQuery",
        location: "us-central1",
        streamId: "stream",
        sourceConfig: {
            sourceConnectionProfile: source.id,
            sqlServerSourceConfig: {
                includeObjects: {
                    schemas: [{
                        schema: "schema",
                        tables: [{
                            table: "table",
                        }],
                    }],
                },
            },
        },
        destinationConfig: {
            destinationConnectionProfile: destination.id,
            bigqueryDestinationConfig: {
                dataFreshness: "900s",
                sourceHierarchyDatasets: {
                    datasetTemplate: {
                        location: "us-central1",
                    },
                },
            },
        },
        backfillNone: {},
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    instance = gcp.sql.DatabaseInstance("instance",
        name="sql-server",
        database_version="SQLSERVER_2019_STANDARD",
        region="us-central1",
        root_password="root-password",
        deletion_protection=True,
        settings=gcp.sql.DatabaseInstanceSettingsArgs(
            tier="db-custom-2-4096",
            ip_configuration=gcp.sql.DatabaseInstanceSettingsIpConfigurationArgs(
                authorized_networks=[
                    gcp.sql.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs(
                        value="34.71.242.81",
                    ),
                    gcp.sql.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs(
                        value="34.72.28.29",
                    ),
                    gcp.sql.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs(
                        value="34.67.6.157",
                    ),
                    gcp.sql.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs(
                        value="34.67.234.134",
                    ),
                    gcp.sql.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs(
                        value="34.72.239.218",
                    ),
                ],
            ),
        ))
    user = gcp.sql.User("user",
        name="user",
        instance=instance.name,
        password="password")
    db = gcp.sql.Database("db",
        name="db",
        instance=instance.name,
        opts=pulumi.ResourceOptions(depends_on=[user]))
    source = gcp.datastream.ConnectionProfile("source",
        display_name="SQL Server Source",
        location="us-central1",
        connection_profile_id="source-profile",
        sql_server_profile=gcp.datastream.ConnectionProfileSqlServerProfileArgs(
            hostname=instance.public_ip_address,
            port=1433,
            username=user.name,
            password=user.password,
            database=db.name,
        ))
    destination = gcp.datastream.ConnectionProfile("destination",
        display_name="BigQuery Destination",
        location="us-central1",
        connection_profile_id="destination-profile",
        bigquery_profile=gcp.datastream.ConnectionProfileBigqueryProfileArgs())
    default = gcp.datastream.Stream("default",
        display_name="SQL Server to BigQuery",
        location="us-central1",
        stream_id="stream",
        source_config=gcp.datastream.StreamSourceConfigArgs(
            source_connection_profile=source.id,
            sql_server_source_config=gcp.datastream.StreamSourceConfigSqlServerSourceConfigArgs(
                include_objects=gcp.datastream.StreamSourceConfigSqlServerSourceConfigIncludeObjectsArgs(
                    schemas=[gcp.datastream.StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaArgs(
                        schema="schema",
                        tables=[gcp.datastream.StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableArgs(
                            table="table",
                        )],
                    )],
                ),
            ),
        ),
        destination_config=gcp.datastream.StreamDestinationConfigArgs(
            destination_connection_profile=destination.id,
            bigquery_destination_config=gcp.datastream.StreamDestinationConfigBigqueryDestinationConfigArgs(
                data_freshness="900s",
                source_hierarchy_datasets=gcp.datastream.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs(
                    dataset_template=gcp.datastream.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs(
                        location="us-central1",
                    ),
                ),
            ),
        ),
        backfill_none=gcp.datastream.StreamBackfillNoneArgs())
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/datastream"
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/sql"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		instance, err := sql.NewDatabaseInstance(ctx, "instance", &sql.DatabaseInstanceArgs{
    			Name:               pulumi.String("sql-server"),
    			DatabaseVersion:    pulumi.String("SQLSERVER_2019_STANDARD"),
    			Region:             pulumi.String("us-central1"),
    			RootPassword:       pulumi.String("root-password"),
    			DeletionProtection: pulumi.Bool(true),
    			Settings: &sql.DatabaseInstanceSettingsArgs{
    				Tier: pulumi.String("db-custom-2-4096"),
    				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"),
    						},
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		user, err := sql.NewUser(ctx, "user", &sql.UserArgs{
    			Name:     pulumi.String("user"),
    			Instance: instance.Name,
    			Password: pulumi.String("password"),
    		})
    		if err != nil {
    			return err
    		}
    		db, err := sql.NewDatabase(ctx, "db", &sql.DatabaseArgs{
    			Name:     pulumi.String("db"),
    			Instance: instance.Name,
    		}, pulumi.DependsOn([]pulumi.Resource{
    			user,
    		}))
    		if err != nil {
    			return err
    		}
    		source, err := datastream.NewConnectionProfile(ctx, "source", &datastream.ConnectionProfileArgs{
    			DisplayName:         pulumi.String("SQL Server Source"),
    			Location:            pulumi.String("us-central1"),
    			ConnectionProfileId: pulumi.String("source-profile"),
    			SqlServerProfile: &datastream.ConnectionProfileSqlServerProfileArgs{
    				Hostname: instance.PublicIpAddress,
    				Port:     pulumi.Int(1433),
    				Username: user.Name,
    				Password: user.Password,
    				Database: db.Name,
    			},
    		})
    		if err != nil {
    			return err
    		}
    		destination, err := datastream.NewConnectionProfile(ctx, "destination", &datastream.ConnectionProfileArgs{
    			DisplayName:         pulumi.String("BigQuery Destination"),
    			Location:            pulumi.String("us-central1"),
    			ConnectionProfileId: pulumi.String("destination-profile"),
    			BigqueryProfile:     nil,
    		})
    		if err != nil {
    			return err
    		}
    		_, err = datastream.NewStream(ctx, "default", &datastream.StreamArgs{
    			DisplayName: pulumi.String("SQL Server to BigQuery"),
    			Location:    pulumi.String("us-central1"),
    			StreamId:    pulumi.String("stream"),
    			SourceConfig: &datastream.StreamSourceConfigArgs{
    				SourceConnectionProfile: source.ID(),
    				SqlServerSourceConfig: &datastream.StreamSourceConfigSqlServerSourceConfigArgs{
    					IncludeObjects: &datastream.StreamSourceConfigSqlServerSourceConfigIncludeObjectsArgs{
    						Schemas: datastream.StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaArray{
    							&datastream.StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaArgs{
    								Schema: pulumi.String("schema"),
    								Tables: datastream.StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableArray{
    									&datastream.StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableArgs{
    										Table: pulumi.String("table"),
    									},
    								},
    							},
    						},
    					},
    				},
    			},
    			DestinationConfig: &datastream.StreamDestinationConfigArgs{
    				DestinationConnectionProfile: destination.ID(),
    				BigqueryDestinationConfig: &datastream.StreamDestinationConfigBigqueryDestinationConfigArgs{
    					DataFreshness: pulumi.String("900s"),
    					SourceHierarchyDatasets: &datastream.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs{
    						DatasetTemplate: &datastream.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs{
    							Location: pulumi.String("us-central1"),
    						},
    					},
    				},
    			},
    			BackfillNone: nil,
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Gcp = Pulumi.Gcp;
    
    return await Deployment.RunAsync(() => 
    {
        var instance = new Gcp.Sql.DatabaseInstance("instance", new()
        {
            Name = "sql-server",
            DatabaseVersion = "SQLSERVER_2019_STANDARD",
            Region = "us-central1",
            RootPassword = "root-password",
            DeletionProtection = true,
            Settings = new Gcp.Sql.Inputs.DatabaseInstanceSettingsArgs
            {
                Tier = "db-custom-2-4096",
                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",
                        },
                    },
                },
            },
        });
    
        var user = new Gcp.Sql.User("user", new()
        {
            Name = "user",
            Instance = instance.Name,
            Password = "password",
        });
    
        var db = new Gcp.Sql.Database("db", new()
        {
            Name = "db",
            Instance = instance.Name,
        }, new CustomResourceOptions
        {
            DependsOn =
            {
                user,
            },
        });
    
        var source = new Gcp.Datastream.ConnectionProfile("source", new()
        {
            DisplayName = "SQL Server Source",
            Location = "us-central1",
            ConnectionProfileId = "source-profile",
            SqlServerProfile = new Gcp.Datastream.Inputs.ConnectionProfileSqlServerProfileArgs
            {
                Hostname = instance.PublicIpAddress,
                Port = 1433,
                Username = user.Name,
                Password = user.Password,
                Database = db.Name,
            },
        });
    
        var destination = new Gcp.Datastream.ConnectionProfile("destination", new()
        {
            DisplayName = "BigQuery Destination",
            Location = "us-central1",
            ConnectionProfileId = "destination-profile",
            BigqueryProfile = null,
        });
    
        var @default = new Gcp.Datastream.Stream("default", new()
        {
            DisplayName = "SQL Server to BigQuery",
            Location = "us-central1",
            StreamId = "stream",
            SourceConfig = new Gcp.Datastream.Inputs.StreamSourceConfigArgs
            {
                SourceConnectionProfile = source.Id,
                SqlServerSourceConfig = new Gcp.Datastream.Inputs.StreamSourceConfigSqlServerSourceConfigArgs
                {
                    IncludeObjects = new Gcp.Datastream.Inputs.StreamSourceConfigSqlServerSourceConfigIncludeObjectsArgs
                    {
                        Schemas = new[]
                        {
                            new Gcp.Datastream.Inputs.StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaArgs
                            {
                                Schema = "schema",
                                Tables = new[]
                                {
                                    new Gcp.Datastream.Inputs.StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableArgs
                                    {
                                        Table = "table",
                                    },
                                },
                            },
                        },
                    },
                },
            },
            DestinationConfig = new Gcp.Datastream.Inputs.StreamDestinationConfigArgs
            {
                DestinationConnectionProfile = destination.Id,
                BigqueryDestinationConfig = new Gcp.Datastream.Inputs.StreamDestinationConfigBigqueryDestinationConfigArgs
                {
                    DataFreshness = "900s",
                    SourceHierarchyDatasets = new Gcp.Datastream.Inputs.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs
                    {
                        DatasetTemplate = new Gcp.Datastream.Inputs.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs
                        {
                            Location = "us-central1",
                        },
                    },
                },
            },
            BackfillNone = null,
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    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.DatabaseInstanceSettingsIpConfigurationArgs;
    import com.pulumi.gcp.sql.User;
    import com.pulumi.gcp.sql.UserArgs;
    import com.pulumi.gcp.sql.Database;
    import com.pulumi.gcp.sql.DatabaseArgs;
    import com.pulumi.gcp.datastream.ConnectionProfile;
    import com.pulumi.gcp.datastream.ConnectionProfileArgs;
    import com.pulumi.gcp.datastream.inputs.ConnectionProfileSqlServerProfileArgs;
    import com.pulumi.gcp.datastream.inputs.ConnectionProfileBigqueryProfileArgs;
    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.StreamSourceConfigSqlServerSourceConfigArgs;
    import com.pulumi.gcp.datastream.inputs.StreamSourceConfigSqlServerSourceConfigIncludeObjectsArgs;
    import com.pulumi.gcp.datastream.inputs.StreamDestinationConfigArgs;
    import com.pulumi.gcp.datastream.inputs.StreamDestinationConfigBigqueryDestinationConfigArgs;
    import com.pulumi.gcp.datastream.inputs.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs;
    import com.pulumi.gcp.datastream.inputs.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs;
    import com.pulumi.gcp.datastream.inputs.StreamBackfillNoneArgs;
    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 instance = new DatabaseInstance("instance", DatabaseInstanceArgs.builder()
                .name("sql-server")
                .databaseVersion("SQLSERVER_2019_STANDARD")
                .region("us-central1")
                .rootPassword("root-password")
                .deletionProtection("true")
                .settings(DatabaseInstanceSettingsArgs.builder()
                    .tier("db-custom-2-4096")
                    .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())
                .build());
    
            var user = new User("user", UserArgs.builder()
                .name("user")
                .instance(instance.name())
                .password("password")
                .build());
    
            var db = new Database("db", DatabaseArgs.builder()
                .name("db")
                .instance(instance.name())
                .build(), CustomResourceOptions.builder()
                    .dependsOn(user)
                    .build());
    
            var source = new ConnectionProfile("source", ConnectionProfileArgs.builder()
                .displayName("SQL Server Source")
                .location("us-central1")
                .connectionProfileId("source-profile")
                .sqlServerProfile(ConnectionProfileSqlServerProfileArgs.builder()
                    .hostname(instance.publicIpAddress())
                    .port(1433)
                    .username(user.name())
                    .password(user.password())
                    .database(db.name())
                    .build())
                .build());
    
            var destination = new ConnectionProfile("destination", ConnectionProfileArgs.builder()
                .displayName("BigQuery Destination")
                .location("us-central1")
                .connectionProfileId("destination-profile")
                .bigqueryProfile()
                .build());
    
            var default_ = new Stream("default", StreamArgs.builder()
                .displayName("SQL Server to BigQuery")
                .location("us-central1")
                .streamId("stream")
                .sourceConfig(StreamSourceConfigArgs.builder()
                    .sourceConnectionProfile(source.id())
                    .sqlServerSourceConfig(StreamSourceConfigSqlServerSourceConfigArgs.builder()
                        .includeObjects(StreamSourceConfigSqlServerSourceConfigIncludeObjectsArgs.builder()
                            .schemas(StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaArgs.builder()
                                .schema("schema")
                                .tables(StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableArgs.builder()
                                    .table("table")
                                    .build())
                                .build())
                            .build())
                        .build())
                    .build())
                .destinationConfig(StreamDestinationConfigArgs.builder()
                    .destinationConnectionProfile(destination.id())
                    .bigqueryDestinationConfig(StreamDestinationConfigBigqueryDestinationConfigArgs.builder()
                        .dataFreshness("900s")
                        .sourceHierarchyDatasets(StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs.builder()
                            .datasetTemplate(StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs.builder()
                                .location("us-central1")
                                .build())
                            .build())
                        .build())
                    .build())
                .backfillNone()
                .build());
    
        }
    }
    
    resources:
      instance:
        type: gcp:sql:DatabaseInstance
        properties:
          name: sql-server
          databaseVersion: SQLSERVER_2019_STANDARD
          region: us-central1
          rootPassword: root-password
          deletionProtection: 'true'
          settings:
            tier: db-custom-2-4096
            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
      db:
        type: gcp:sql:Database
        properties:
          name: db
          instance: ${instance.name}
        options:
          dependson:
            - ${user}
      user:
        type: gcp:sql:User
        properties:
          name: user
          instance: ${instance.name}
          password: password
      source:
        type: gcp:datastream:ConnectionProfile
        properties:
          displayName: SQL Server Source
          location: us-central1
          connectionProfileId: source-profile
          sqlServerProfile:
            hostname: ${instance.publicIpAddress}
            port: 1433
            username: ${user.name}
            password: ${user.password}
            database: ${db.name}
      destination:
        type: gcp:datastream:ConnectionProfile
        properties:
          displayName: BigQuery Destination
          location: us-central1
          connectionProfileId: destination-profile
          bigqueryProfile: {}
      default:
        type: gcp:datastream:Stream
        properties:
          displayName: SQL Server to BigQuery
          location: us-central1
          streamId: stream
          sourceConfig:
            sourceConnectionProfile: ${source.id}
            sqlServerSourceConfig:
              includeObjects:
                schemas:
                  - schema: schema
                    tables:
                      - table: table
          destinationConfig:
            destinationConnectionProfile: ${destination.id}
            bigqueryDestinationConfig:
              dataFreshness: 900s
              sourceHierarchyDatasets:
                datasetTemplate:
                  location: us-central1
          backfillNone: {}
    

    Datastream Stream Postgresql Bigquery Dataset Id

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    import * as random from "@pulumi/random";
    
    const postgres = new gcp.bigquery.Dataset("postgres", {
        datasetId: "postgres",
        friendlyName: "postgres",
        description: "Database of postgres",
        location: "us-central1",
    });
    const destinationConnectionProfile2 = new gcp.datastream.ConnectionProfile("destination_connection_profile2", {
        displayName: "Connection profile",
        location: "us-central1",
        connectionProfileId: "dest-profile",
        bigqueryProfile: {},
    });
    const instance = new gcp.sql.DatabaseInstance("instance", {
        name: "instance-name",
        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: false,
    });
    const pwd = new random.RandomPassword("pwd", {
        length: 16,
        special: false,
    });
    const user = new gcp.sql.User("user", {
        name: "my-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 _default = new gcp.datastream.Stream("default", {
        displayName: "postgres to bigQuery",
        location: "us-central1",
        streamId: "postgres-bigquery",
        sourceConfig: {
            sourceConnectionProfile: sourceConnectionProfile.id,
            mysqlSourceConfig: {},
        },
        destinationConfig: {
            destinationConnectionProfile: destinationConnectionProfile2.id,
            bigqueryDestinationConfig: {
                dataFreshness: "900s",
                singleTargetDataset: {
                    datasetId: postgres.id,
                },
            },
        },
        backfillAll: {},
    });
    const db = new gcp.sql.Database("db", {
        instance: instance.name,
        name: "db",
    });
    
    import pulumi
    import pulumi_gcp as gcp
    import pulumi_random as random
    
    postgres = gcp.bigquery.Dataset("postgres",
        dataset_id="postgres",
        friendly_name="postgres",
        description="Database of postgres",
        location="us-central1")
    destination_connection_profile2 = gcp.datastream.ConnectionProfile("destination_connection_profile2",
        display_name="Connection profile",
        location="us-central1",
        connection_profile_id="dest-profile",
        bigquery_profile=gcp.datastream.ConnectionProfileBigqueryProfileArgs())
    instance = gcp.sql.DatabaseInstance("instance",
        name="instance-name",
        database_version="MYSQL_8_0",
        region="us-central1",
        settings=gcp.sql.DatabaseInstanceSettingsArgs(
            tier="db-f1-micro",
            backup_configuration=gcp.sql.DatabaseInstanceSettingsBackupConfigurationArgs(
                enabled=True,
                binary_log_enabled=True,
            ),
            ip_configuration=gcp.sql.DatabaseInstanceSettingsIpConfigurationArgs(
                authorized_networks=[
                    gcp.sql.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs(
                        value="34.71.242.81",
                    ),
                    gcp.sql.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs(
                        value="34.72.28.29",
                    ),
                    gcp.sql.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs(
                        value="34.67.6.157",
                    ),
                    gcp.sql.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs(
                        value="34.67.234.134",
                    ),
                    gcp.sql.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs(
                        value="34.72.239.218",
                    ),
                ],
            ),
        ),
        deletion_protection=False)
    pwd = random.RandomPassword("pwd",
        length=16,
        special=False)
    user = gcp.sql.User("user",
        name="my-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=gcp.datastream.ConnectionProfileMysqlProfileArgs(
            hostname=instance.public_ip_address,
            username=user.name,
            password=user.password,
        ))
    default = gcp.datastream.Stream("default",
        display_name="postgres to bigQuery",
        location="us-central1",
        stream_id="postgres-bigquery",
        source_config=gcp.datastream.StreamSourceConfigArgs(
            source_connection_profile=source_connection_profile.id,
            mysql_source_config=gcp.datastream.StreamSourceConfigMysqlSourceConfigArgs(),
        ),
        destination_config=gcp.datastream.StreamDestinationConfigArgs(
            destination_connection_profile=destination_connection_profile2.id,
            bigquery_destination_config=gcp.datastream.StreamDestinationConfigBigqueryDestinationConfigArgs(
                data_freshness="900s",
                single_target_dataset=gcp.datastream.StreamDestinationConfigBigqueryDestinationConfigSingleTargetDatasetArgs(
                    dataset_id=postgres.id,
                ),
            ),
        ),
        backfill_all=gcp.datastream.StreamBackfillAllArgs())
    db = gcp.sql.Database("db",
        instance=instance.name,
        name="db")
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigquery"
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/datastream"
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/sql"
    	"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 {
    		postgres, err := bigquery.NewDataset(ctx, "postgres", &bigquery.DatasetArgs{
    			DatasetId:    pulumi.String("postgres"),
    			FriendlyName: pulumi.String("postgres"),
    			Description:  pulumi.String("Database of postgres"),
    			Location:     pulumi.String("us-central1"),
    		})
    		if err != nil {
    			return err
    		}
    		destinationConnectionProfile2, err := datastream.NewConnectionProfile(ctx, "destination_connection_profile2", &datastream.ConnectionProfileArgs{
    			DisplayName:         pulumi.String("Connection profile"),
    			Location:            pulumi.String("us-central1"),
    			ConnectionProfileId: pulumi.String("dest-profile"),
    			BigqueryProfile:     nil,
    		})
    		if err != nil {
    			return err
    		}
    		instance, err := sql.NewDatabaseInstance(ctx, "instance", &sql.DatabaseInstanceArgs{
    			Name:            pulumi.String("instance-name"),
    			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(false),
    		})
    		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("my-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
    		}
    		_, err = datastream.NewStream(ctx, "default", &datastream.StreamArgs{
    			DisplayName: pulumi.String("postgres to bigQuery"),
    			Location:    pulumi.String("us-central1"),
    			StreamId:    pulumi.String("postgres-bigquery"),
    			SourceConfig: &datastream.StreamSourceConfigArgs{
    				SourceConnectionProfile: sourceConnectionProfile.ID(),
    				MysqlSourceConfig:       nil,
    			},
    			DestinationConfig: &datastream.StreamDestinationConfigArgs{
    				DestinationConnectionProfile: destinationConnectionProfile2.ID(),
    				BigqueryDestinationConfig: &datastream.StreamDestinationConfigBigqueryDestinationConfigArgs{
    					DataFreshness: pulumi.String("900s"),
    					SingleTargetDataset: &datastream.StreamDestinationConfigBigqueryDestinationConfigSingleTargetDatasetArgs{
    						DatasetId: postgres.ID(),
    					},
    				},
    			},
    			BackfillAll: nil,
    		})
    		if err != nil {
    			return err
    		}
    		_, err = sql.NewDatabase(ctx, "db", &sql.DatabaseArgs{
    			Instance: instance.Name,
    			Name:     pulumi.String("db"),
    		})
    		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 postgres = new Gcp.BigQuery.Dataset("postgres", new()
        {
            DatasetId = "postgres",
            FriendlyName = "postgres",
            Description = "Database of postgres",
            Location = "us-central1",
        });
    
        var destinationConnectionProfile2 = new Gcp.Datastream.ConnectionProfile("destination_connection_profile2", new()
        {
            DisplayName = "Connection profile",
            Location = "us-central1",
            ConnectionProfileId = "dest-profile",
            BigqueryProfile = null,
        });
    
        var instance = new Gcp.Sql.DatabaseInstance("instance", new()
        {
            Name = "instance-name",
            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 = false,
        });
    
        var pwd = new Random.RandomPassword("pwd", new()
        {
            Length = 16,
            Special = false,
        });
    
        var user = new Gcp.Sql.User("user", new()
        {
            Name = "my-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 @default = new Gcp.Datastream.Stream("default", new()
        {
            DisplayName = "postgres to bigQuery",
            Location = "us-central1",
            StreamId = "postgres-bigquery",
            SourceConfig = new Gcp.Datastream.Inputs.StreamSourceConfigArgs
            {
                SourceConnectionProfile = sourceConnectionProfile.Id,
                MysqlSourceConfig = null,
            },
            DestinationConfig = new Gcp.Datastream.Inputs.StreamDestinationConfigArgs
            {
                DestinationConnectionProfile = destinationConnectionProfile2.Id,
                BigqueryDestinationConfig = new Gcp.Datastream.Inputs.StreamDestinationConfigBigqueryDestinationConfigArgs
                {
                    DataFreshness = "900s",
                    SingleTargetDataset = new Gcp.Datastream.Inputs.StreamDestinationConfigBigqueryDestinationConfigSingleTargetDatasetArgs
                    {
                        DatasetId = postgres.Id,
                    },
                },
            },
            BackfillAll = null,
        });
    
        var db = new Gcp.Sql.Database("db", new()
        {
            Instance = instance.Name,
            Name = "db",
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.gcp.bigquery.Dataset;
    import com.pulumi.gcp.bigquery.DatasetArgs;
    import com.pulumi.gcp.datastream.ConnectionProfile;
    import com.pulumi.gcp.datastream.ConnectionProfileArgs;
    import com.pulumi.gcp.datastream.inputs.ConnectionProfileBigqueryProfileArgs;
    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.random.RandomPassword;
    import com.pulumi.random.RandomPasswordArgs;
    import com.pulumi.gcp.sql.User;
    import com.pulumi.gcp.sql.UserArgs;
    import com.pulumi.gcp.datastream.inputs.ConnectionProfileMysqlProfileArgs;
    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.StreamDestinationConfigArgs;
    import com.pulumi.gcp.datastream.inputs.StreamDestinationConfigBigqueryDestinationConfigArgs;
    import com.pulumi.gcp.datastream.inputs.StreamDestinationConfigBigqueryDestinationConfigSingleTargetDatasetArgs;
    import com.pulumi.gcp.datastream.inputs.StreamBackfillAllArgs;
    import com.pulumi.gcp.sql.Database;
    import com.pulumi.gcp.sql.DatabaseArgs;
    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 postgres = new Dataset("postgres", DatasetArgs.builder()
                .datasetId("postgres")
                .friendlyName("postgres")
                .description("Database of postgres")
                .location("us-central1")
                .build());
    
            var destinationConnectionProfile2 = new ConnectionProfile("destinationConnectionProfile2", ConnectionProfileArgs.builder()
                .displayName("Connection profile")
                .location("us-central1")
                .connectionProfileId("dest-profile")
                .bigqueryProfile()
                .build());
    
            var instance = new DatabaseInstance("instance", DatabaseInstanceArgs.builder()
                .name("instance-name")
                .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(false)
                .build());
    
            var pwd = new RandomPassword("pwd", RandomPasswordArgs.builder()
                .length(16)
                .special(false)
                .build());
    
            var user = new User("user", UserArgs.builder()
                .name("my-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 default_ = new Stream("default", StreamArgs.builder()
                .displayName("postgres to bigQuery")
                .location("us-central1")
                .streamId("postgres-bigquery")
                .sourceConfig(StreamSourceConfigArgs.builder()
                    .sourceConnectionProfile(sourceConnectionProfile.id())
                    .mysqlSourceConfig()
                    .build())
                .destinationConfig(StreamDestinationConfigArgs.builder()
                    .destinationConnectionProfile(destinationConnectionProfile2.id())
                    .bigqueryDestinationConfig(StreamDestinationConfigBigqueryDestinationConfigArgs.builder()
                        .dataFreshness("900s")
                        .singleTargetDataset(StreamDestinationConfigBigqueryDestinationConfigSingleTargetDatasetArgs.builder()
                            .datasetId(postgres.id())
                            .build())
                        .build())
                    .build())
                .backfillAll()
                .build());
    
            var db = new Database("db", DatabaseArgs.builder()
                .instance(instance.name())
                .name("db")
                .build());
    
        }
    }
    
    resources:
      postgres:
        type: gcp:bigquery:Dataset
        properties:
          datasetId: postgres
          friendlyName: postgres
          description: Database of postgres
          location: us-central1
      default:
        type: gcp:datastream:Stream
        properties:
          displayName: postgres to bigQuery
          location: us-central1
          streamId: postgres-bigquery
          sourceConfig:
            sourceConnectionProfile: ${sourceConnectionProfile.id}
            mysqlSourceConfig: {}
          destinationConfig:
            destinationConnectionProfile: ${destinationConnectionProfile2.id}
            bigqueryDestinationConfig:
              dataFreshness: 900s
              singleTargetDataset:
                datasetId: ${postgres.id}
          backfillAll: {}
      destinationConnectionProfile2:
        type: gcp:datastream:ConnectionProfile
        name: destination_connection_profile2
        properties:
          displayName: Connection profile
          location: us-central1
          connectionProfileId: dest-profile
          bigqueryProfile: {}
      instance:
        type: gcp:sql:DatabaseInstance
        properties:
          name: instance-name
          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: false
      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: my-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}
    

    Datastream Stream Bigquery

    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 bqSa = gcp.bigquery.getDefaultServiceAccount({});
    const bigqueryKeyUser = new gcp.kms.CryptoKeyIAMMember("bigquery_key_user", {
        cryptoKeyId: "bigquery-kms-name",
        role: "roles/cloudkms.cryptoKeyEncrypterDecrypter",
        member: bqSa.then(bqSa => `serviceAccount:${bqSa.email}`),
    });
    const destinationConnectionProfile = new gcp.datastream.ConnectionProfile("destination_connection_profile", {
        displayName: "Connection profile",
        location: "us-central1",
        connectionProfileId: "destination-profile",
        bigqueryProfile: {},
    });
    const _default = new gcp.datastream.Stream("default", {
        streamId: "my-stream",
        location: "us-central1",
        displayName: "my stream",
        sourceConfig: {
            sourceConnectionProfile: sourceConnectionProfile.id,
            mysqlSourceConfig: {},
        },
        destinationConfig: {
            destinationConnectionProfile: destinationConnectionProfile.id,
            bigqueryDestinationConfig: {
                sourceHierarchyDatasets: {
                    datasetTemplate: {
                        location: "us-central1",
                        kmsKeyName: "bigquery-kms-name",
                    },
                },
            },
        },
        backfillNone: {},
    }, {
        dependsOn: [bigqueryKeyUser],
    });
    
    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=gcp.sql.DatabaseInstanceSettingsArgs(
            tier="db-f1-micro",
            backup_configuration=gcp.sql.DatabaseInstanceSettingsBackupConfigurationArgs(
                enabled=True,
                binary_log_enabled=True,
            ),
            ip_configuration=gcp.sql.DatabaseInstanceSettingsIpConfigurationArgs(
                authorized_networks=[
                    gcp.sql.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs(
                        value="34.71.242.81",
                    ),
                    gcp.sql.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs(
                        value="34.72.28.29",
                    ),
                    gcp.sql.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs(
                        value="34.67.6.157",
                    ),
                    gcp.sql.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs(
                        value="34.67.234.134",
                    ),
                    gcp.sql.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs(
                        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=gcp.datastream.ConnectionProfileMysqlProfileArgs(
            hostname=instance.public_ip_address,
            username=user.name,
            password=user.password,
        ))
    bq_sa = gcp.bigquery.get_default_service_account()
    bigquery_key_user = gcp.kms.CryptoKeyIAMMember("bigquery_key_user",
        crypto_key_id="bigquery-kms-name",
        role="roles/cloudkms.cryptoKeyEncrypterDecrypter",
        member=f"serviceAccount:{bq_sa.email}")
    destination_connection_profile = gcp.datastream.ConnectionProfile("destination_connection_profile",
        display_name="Connection profile",
        location="us-central1",
        connection_profile_id="destination-profile",
        bigquery_profile=gcp.datastream.ConnectionProfileBigqueryProfileArgs())
    default = gcp.datastream.Stream("default",
        stream_id="my-stream",
        location="us-central1",
        display_name="my stream",
        source_config=gcp.datastream.StreamSourceConfigArgs(
            source_connection_profile=source_connection_profile.id,
            mysql_source_config=gcp.datastream.StreamSourceConfigMysqlSourceConfigArgs(),
        ),
        destination_config=gcp.datastream.StreamDestinationConfigArgs(
            destination_connection_profile=destination_connection_profile.id,
            bigquery_destination_config=gcp.datastream.StreamDestinationConfigBigqueryDestinationConfigArgs(
                source_hierarchy_datasets=gcp.datastream.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs(
                    dataset_template=gcp.datastream.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs(
                        location="us-central1",
                        kms_key_name="bigquery-kms-name",
                    ),
                ),
            ),
        ),
        backfill_none=gcp.datastream.StreamBackfillNoneArgs(),
        opts=pulumi.ResourceOptions(depends_on=[bigquery_key_user]))
    
    package main
    
    import (
    	"fmt"
    
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigquery"
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/datastream"
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/kms"
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/sql"
    	"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 {
    		_, 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
    		}
    		bqSa, err := bigquery.GetDefaultServiceAccount(ctx, nil, nil)
    		if err != nil {
    			return err
    		}
    		bigqueryKeyUser, err := kms.NewCryptoKeyIAMMember(ctx, "bigquery_key_user", &kms.CryptoKeyIAMMemberArgs{
    			CryptoKeyId: pulumi.String("bigquery-kms-name"),
    			Role:        pulumi.String("roles/cloudkms.cryptoKeyEncrypterDecrypter"),
    			Member:      pulumi.String(fmt.Sprintf("serviceAccount:%v", bqSa.Email)),
    		})
    		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"),
    			BigqueryProfile:     nil,
    		})
    		if err != nil {
    			return err
    		}
    		_, err = datastream.NewStream(ctx, "default", &datastream.StreamArgs{
    			StreamId:    pulumi.String("my-stream"),
    			Location:    pulumi.String("us-central1"),
    			DisplayName: pulumi.String("my stream"),
    			SourceConfig: &datastream.StreamSourceConfigArgs{
    				SourceConnectionProfile: sourceConnectionProfile.ID(),
    				MysqlSourceConfig:       nil,
    			},
    			DestinationConfig: &datastream.StreamDestinationConfigArgs{
    				DestinationConnectionProfile: destinationConnectionProfile.ID(),
    				BigqueryDestinationConfig: &datastream.StreamDestinationConfigBigqueryDestinationConfigArgs{
    					SourceHierarchyDatasets: &datastream.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs{
    						DatasetTemplate: &datastream.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs{
    							Location:   pulumi.String("us-central1"),
    							KmsKeyName: pulumi.String("bigquery-kms-name"),
    						},
    					},
    				},
    			},
    			BackfillNone: nil,
    		}, pulumi.DependsOn([]pulumi.Resource{
    			bigqueryKeyUser,
    		}))
    		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 bqSa = Gcp.BigQuery.GetDefaultServiceAccount.Invoke();
    
        var bigqueryKeyUser = new Gcp.Kms.CryptoKeyIAMMember("bigquery_key_user", new()
        {
            CryptoKeyId = "bigquery-kms-name",
            Role = "roles/cloudkms.cryptoKeyEncrypterDecrypter",
            Member = $"serviceAccount:{bqSa.Apply(getDefaultServiceAccountResult => getDefaultServiceAccountResult.Email)}",
        });
    
        var destinationConnectionProfile = new Gcp.Datastream.ConnectionProfile("destination_connection_profile", new()
        {
            DisplayName = "Connection profile",
            Location = "us-central1",
            ConnectionProfileId = "destination-profile",
            BigqueryProfile = null,
        });
    
        var @default = new Gcp.Datastream.Stream("default", new()
        {
            StreamId = "my-stream",
            Location = "us-central1",
            DisplayName = "my stream",
            SourceConfig = new Gcp.Datastream.Inputs.StreamSourceConfigArgs
            {
                SourceConnectionProfile = sourceConnectionProfile.Id,
                MysqlSourceConfig = null,
            },
            DestinationConfig = new Gcp.Datastream.Inputs.StreamDestinationConfigArgs
            {
                DestinationConnectionProfile = destinationConnectionProfile.Id,
                BigqueryDestinationConfig = new Gcp.Datastream.Inputs.StreamDestinationConfigBigqueryDestinationConfigArgs
                {
                    SourceHierarchyDatasets = new Gcp.Datastream.Inputs.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs
                    {
                        DatasetTemplate = new Gcp.Datastream.Inputs.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs
                        {
                            Location = "us-central1",
                            KmsKeyName = "bigquery-kms-name",
                        },
                    },
                },
            },
            BackfillNone = null,
        }, new CustomResourceOptions
        {
            DependsOn =
            {
                bigqueryKeyUser,
            },
        });
    
    });
    
    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.bigquery.BigqueryFunctions;
    import com.pulumi.gcp.bigquery.inputs.GetDefaultServiceAccountArgs;
    import com.pulumi.gcp.kms.CryptoKeyIAMMember;
    import com.pulumi.gcp.kms.CryptoKeyIAMMemberArgs;
    import com.pulumi.gcp.datastream.inputs.ConnectionProfileBigqueryProfileArgs;
    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.StreamDestinationConfigArgs;
    import com.pulumi.gcp.datastream.inputs.StreamDestinationConfigBigqueryDestinationConfigArgs;
    import com.pulumi.gcp.datastream.inputs.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs;
    import com.pulumi.gcp.datastream.inputs.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs;
    import com.pulumi.gcp.datastream.inputs.StreamBackfillNoneArgs;
    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());
    
            final var bqSa = BigqueryFunctions.getDefaultServiceAccount();
    
            var bigqueryKeyUser = new CryptoKeyIAMMember("bigqueryKeyUser", CryptoKeyIAMMemberArgs.builder()
                .cryptoKeyId("bigquery-kms-name")
                .role("roles/cloudkms.cryptoKeyEncrypterDecrypter")
                .member(String.format("serviceAccount:%s", bqSa.applyValue(getDefaultServiceAccountResult -> getDefaultServiceAccountResult.email())))
                .build());
    
            var destinationConnectionProfile = new ConnectionProfile("destinationConnectionProfile", ConnectionProfileArgs.builder()
                .displayName("Connection profile")
                .location("us-central1")
                .connectionProfileId("destination-profile")
                .bigqueryProfile()
                .build());
    
            var default_ = new Stream("default", StreamArgs.builder()
                .streamId("my-stream")
                .location("us-central1")
                .displayName("my stream")
                .sourceConfig(StreamSourceConfigArgs.builder()
                    .sourceConnectionProfile(sourceConnectionProfile.id())
                    .mysqlSourceConfig()
                    .build())
                .destinationConfig(StreamDestinationConfigArgs.builder()
                    .destinationConnectionProfile(destinationConnectionProfile.id())
                    .bigqueryDestinationConfig(StreamDestinationConfigBigqueryDestinationConfigArgs.builder()
                        .sourceHierarchyDatasets(StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs.builder()
                            .datasetTemplate(StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs.builder()
                                .location("us-central1")
                                .kmsKeyName("bigquery-kms-name")
                                .build())
                            .build())
                        .build())
                    .build())
                .backfillNone()
                .build(), CustomResourceOptions.builder()
                    .dependsOn(bigqueryKeyUser)
                    .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}
      bigqueryKeyUser:
        type: gcp:kms:CryptoKeyIAMMember
        name: bigquery_key_user
        properties:
          cryptoKeyId: bigquery-kms-name
          role: roles/cloudkms.cryptoKeyEncrypterDecrypter
          member: serviceAccount:${bqSa.email}
      destinationConnectionProfile:
        type: gcp:datastream:ConnectionProfile
        name: destination_connection_profile
        properties:
          displayName: Connection profile
          location: us-central1
          connectionProfileId: destination-profile
          bigqueryProfile: {}
      default:
        type: gcp:datastream:Stream
        properties:
          streamId: my-stream
          location: us-central1
          displayName: my stream
          sourceConfig:
            sourceConnectionProfile: ${sourceConnectionProfile.id}
            mysqlSourceConfig: {}
          destinationConfig:
            destinationConnectionProfile: ${destinationConnectionProfile.id}
            bigqueryDestinationConfig:
              sourceHierarchyDatasets:
                datasetTemplate:
                  location: us-central1
                  kmsKeyName: bigquery-kms-name
          backfillNone: {}
        options:
          dependson:
            - ${bigqueryKeyUser}
    variables:
      project:
        fn::invoke:
          Function: gcp:organizations:getProject
          Arguments: {}
      bqSa:
        fn::invoke:
          Function: gcp:bigquery:getDefaultServiceAccount
          Arguments: {}
    

    Create Stream Resource

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

    Constructor syntax

    new Stream(name: string, args: StreamArgs, opts?: CustomResourceOptions);
    @overload
    def Stream(resource_name: str,
               args: StreamArgs,
               opts: Optional[ResourceOptions] = None)
    
    @overload
    def Stream(resource_name: str,
               opts: Optional[ResourceOptions] = None,
               destination_config: Optional[StreamDestinationConfigArgs] = None,
               display_name: Optional[str] = None,
               location: Optional[str] = None,
               source_config: Optional[StreamSourceConfigArgs] = None,
               stream_id: Optional[str] = None,
               backfill_all: Optional[StreamBackfillAllArgs] = None,
               backfill_none: Optional[StreamBackfillNoneArgs] = None,
               create_without_validation: Optional[bool] = None,
               customer_managed_encryption_key: Optional[str] = None,
               desired_state: Optional[str] = None,
               labels: Optional[Mapping[str, str]] = None,
               project: Optional[str] = None)
    func NewStream(ctx *Context, name string, args StreamArgs, opts ...ResourceOption) (*Stream, error)
    public Stream(string name, StreamArgs args, CustomResourceOptions? opts = null)
    public Stream(String name, StreamArgs args)
    public Stream(String name, StreamArgs args, CustomResourceOptions options)
    
    type: gcp:datastream:Stream
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    

    Parameters

    name string
    The unique name of the resource.
    args StreamArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args StreamArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args StreamArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args StreamArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args StreamArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Example

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

    var streamResource = new Gcp.Datastream.Stream("streamResource", new()
    {
        DestinationConfig = new Gcp.Datastream.Inputs.StreamDestinationConfigArgs
        {
            DestinationConnectionProfile = "string",
            BigqueryDestinationConfig = new Gcp.Datastream.Inputs.StreamDestinationConfigBigqueryDestinationConfigArgs
            {
                DataFreshness = "string",
                SingleTargetDataset = new Gcp.Datastream.Inputs.StreamDestinationConfigBigqueryDestinationConfigSingleTargetDatasetArgs
                {
                    DatasetId = "string",
                },
                SourceHierarchyDatasets = new Gcp.Datastream.Inputs.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs
                {
                    DatasetTemplate = new Gcp.Datastream.Inputs.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs
                    {
                        Location = "string",
                        DatasetIdPrefix = "string",
                        KmsKeyName = "string",
                    },
                },
            },
            GcsDestinationConfig = new Gcp.Datastream.Inputs.StreamDestinationConfigGcsDestinationConfigArgs
            {
                AvroFileFormat = null,
                FileRotationInterval = "string",
                FileRotationMb = 0,
                JsonFileFormat = new Gcp.Datastream.Inputs.StreamDestinationConfigGcsDestinationConfigJsonFileFormatArgs
                {
                    Compression = "string",
                    SchemaFileFormat = "string",
                },
                Path = "string",
            },
        },
        DisplayName = "string",
        Location = "string",
        SourceConfig = new Gcp.Datastream.Inputs.StreamSourceConfigArgs
        {
            SourceConnectionProfile = "string",
            MysqlSourceConfig = new Gcp.Datastream.Inputs.StreamSourceConfigMysqlSourceConfigArgs
            {
                ExcludeObjects = new Gcp.Datastream.Inputs.StreamSourceConfigMysqlSourceConfigExcludeObjectsArgs
                {
                    MysqlDatabases = new[]
                    {
                        new Gcp.Datastream.Inputs.StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseArgs
                        {
                            Database = "string",
                            MysqlTables = new[]
                            {
                                new Gcp.Datastream.Inputs.StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableArgs
                                {
                                    Table = "string",
                                    MysqlColumns = new[]
                                    {
                                        new Gcp.Datastream.Inputs.StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs
                                        {
                                            Collation = "string",
                                            Column = "string",
                                            DataType = "string",
                                            Length = 0,
                                            Nullable = false,
                                            OrdinalPosition = 0,
                                            PrimaryKey = false,
                                        },
                                    },
                                },
                            },
                        },
                    },
                },
                IncludeObjects = new Gcp.Datastream.Inputs.StreamSourceConfigMysqlSourceConfigIncludeObjectsArgs
                {
                    MysqlDatabases = new[]
                    {
                        new Gcp.Datastream.Inputs.StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseArgs
                        {
                            Database = "string",
                            MysqlTables = new[]
                            {
                                new Gcp.Datastream.Inputs.StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgs
                                {
                                    Table = "string",
                                    MysqlColumns = new[]
                                    {
                                        new Gcp.Datastream.Inputs.StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs
                                        {
                                            Collation = "string",
                                            Column = "string",
                                            DataType = "string",
                                            Length = 0,
                                            Nullable = false,
                                            OrdinalPosition = 0,
                                            PrimaryKey = false,
                                        },
                                    },
                                },
                            },
                        },
                    },
                },
                MaxConcurrentBackfillTasks = 0,
                MaxConcurrentCdcTasks = 0,
            },
            OracleSourceConfig = new Gcp.Datastream.Inputs.StreamSourceConfigOracleSourceConfigArgs
            {
                DropLargeObjects = null,
                ExcludeObjects = new Gcp.Datastream.Inputs.StreamSourceConfigOracleSourceConfigExcludeObjectsArgs
                {
                    OracleSchemas = new[]
                    {
                        new Gcp.Datastream.Inputs.StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaArgs
                        {
                            Schema = "string",
                            OracleTables = new[]
                            {
                                new Gcp.Datastream.Inputs.StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableArgs
                                {
                                    Table = "string",
                                    OracleColumns = new[]
                                    {
                                        new Gcp.Datastream.Inputs.StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableOracleColumnArgs
                                        {
                                            Column = "string",
                                            DataType = "string",
                                            Encoding = "string",
                                            Length = 0,
                                            Nullable = false,
                                            OrdinalPosition = 0,
                                            Precision = 0,
                                            PrimaryKey = false,
                                            Scale = 0,
                                        },
                                    },
                                },
                            },
                        },
                    },
                },
                IncludeObjects = new Gcp.Datastream.Inputs.StreamSourceConfigOracleSourceConfigIncludeObjectsArgs
                {
                    OracleSchemas = new[]
                    {
                        new Gcp.Datastream.Inputs.StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaArgs
                        {
                            Schema = "string",
                            OracleTables = new[]
                            {
                                new Gcp.Datastream.Inputs.StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableArgs
                                {
                                    Table = "string",
                                    OracleColumns = new[]
                                    {
                                        new Gcp.Datastream.Inputs.StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArgs
                                        {
                                            Column = "string",
                                            DataType = "string",
                                            Encoding = "string",
                                            Length = 0,
                                            Nullable = false,
                                            OrdinalPosition = 0,
                                            Precision = 0,
                                            PrimaryKey = false,
                                            Scale = 0,
                                        },
                                    },
                                },
                            },
                        },
                    },
                },
                MaxConcurrentBackfillTasks = 0,
                MaxConcurrentCdcTasks = 0,
                StreamLargeObjects = null,
            },
            PostgresqlSourceConfig = new Gcp.Datastream.Inputs.StreamSourceConfigPostgresqlSourceConfigArgs
            {
                Publication = "string",
                ReplicationSlot = "string",
                ExcludeObjects = new Gcp.Datastream.Inputs.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsArgs
                {
                    PostgresqlSchemas = new[]
                    {
                        new Gcp.Datastream.Inputs.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArgs
                        {
                            Schema = "string",
                            PostgresqlTables = new[]
                            {
                                new Gcp.Datastream.Inputs.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTableArgs
                                {
                                    Table = "string",
                                    PostgresqlColumns = new[]
                                    {
                                        new Gcp.Datastream.Inputs.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs
                                        {
                                            Column = "string",
                                            DataType = "string",
                                            Length = 0,
                                            Nullable = false,
                                            OrdinalPosition = 0,
                                            Precision = 0,
                                            PrimaryKey = false,
                                            Scale = 0,
                                        },
                                    },
                                },
                            },
                        },
                    },
                },
                IncludeObjects = new Gcp.Datastream.Inputs.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsArgs
                {
                    PostgresqlSchemas = new[]
                    {
                        new Gcp.Datastream.Inputs.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArgs
                        {
                            Schema = "string",
                            PostgresqlTables = new[]
                            {
                                new Gcp.Datastream.Inputs.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTableArgs
                                {
                                    Table = "string",
                                    PostgresqlColumns = new[]
                                    {
                                        new Gcp.Datastream.Inputs.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs
                                        {
                                            Column = "string",
                                            DataType = "string",
                                            Length = 0,
                                            Nullable = false,
                                            OrdinalPosition = 0,
                                            Precision = 0,
                                            PrimaryKey = false,
                                            Scale = 0,
                                        },
                                    },
                                },
                            },
                        },
                    },
                },
                MaxConcurrentBackfillTasks = 0,
            },
            SqlServerSourceConfig = new Gcp.Datastream.Inputs.StreamSourceConfigSqlServerSourceConfigArgs
            {
                ExcludeObjects = new Gcp.Datastream.Inputs.StreamSourceConfigSqlServerSourceConfigExcludeObjectsArgs
                {
                    Schemas = new[]
                    {
                        new Gcp.Datastream.Inputs.StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaArgs
                        {
                            Schema = "string",
                            Tables = new[]
                            {
                                new Gcp.Datastream.Inputs.StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableArgs
                                {
                                    Table = "string",
                                    Columns = new[]
                                    {
                                        new Gcp.Datastream.Inputs.StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableColumnArgs
                                        {
                                            Column = "string",
                                            DataType = "string",
                                            Length = 0,
                                            Nullable = false,
                                            OrdinalPosition = 0,
                                            Precision = 0,
                                            PrimaryKey = false,
                                            Scale = 0,
                                        },
                                    },
                                },
                            },
                        },
                    },
                },
                IncludeObjects = new Gcp.Datastream.Inputs.StreamSourceConfigSqlServerSourceConfigIncludeObjectsArgs
                {
                    Schemas = new[]
                    {
                        new Gcp.Datastream.Inputs.StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaArgs
                        {
                            Schema = "string",
                            Tables = new[]
                            {
                                new Gcp.Datastream.Inputs.StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableArgs
                                {
                                    Table = "string",
                                    Columns = new[]
                                    {
                                        new Gcp.Datastream.Inputs.StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableColumnArgs
                                        {
                                            Column = "string",
                                            DataType = "string",
                                            Length = 0,
                                            Nullable = false,
                                            OrdinalPosition = 0,
                                            Precision = 0,
                                            PrimaryKey = false,
                                            Scale = 0,
                                        },
                                    },
                                },
                            },
                        },
                    },
                },
                MaxConcurrentBackfillTasks = 0,
                MaxConcurrentCdcTasks = 0,
            },
        },
        StreamId = "string",
        BackfillAll = new Gcp.Datastream.Inputs.StreamBackfillAllArgs
        {
            MysqlExcludedObjects = new Gcp.Datastream.Inputs.StreamBackfillAllMysqlExcludedObjectsArgs
            {
                MysqlDatabases = new[]
                {
                    new Gcp.Datastream.Inputs.StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseArgs
                    {
                        Database = "string",
                        MysqlTables = new[]
                        {
                            new Gcp.Datastream.Inputs.StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableArgs
                            {
                                Table = "string",
                                MysqlColumns = new[]
                                {
                                    new Gcp.Datastream.Inputs.StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableMysqlColumnArgs
                                    {
                                        Collation = "string",
                                        Column = "string",
                                        DataType = "string",
                                        Length = 0,
                                        Nullable = false,
                                        OrdinalPosition = 0,
                                        PrimaryKey = false,
                                    },
                                },
                            },
                        },
                    },
                },
            },
            OracleExcludedObjects = new Gcp.Datastream.Inputs.StreamBackfillAllOracleExcludedObjectsArgs
            {
                OracleSchemas = new[]
                {
                    new Gcp.Datastream.Inputs.StreamBackfillAllOracleExcludedObjectsOracleSchemaArgs
                    {
                        Schema = "string",
                        OracleTables = new[]
                        {
                            new Gcp.Datastream.Inputs.StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableArgs
                            {
                                Table = "string",
                                OracleColumns = new[]
                                {
                                    new Gcp.Datastream.Inputs.StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableOracleColumnArgs
                                    {
                                        Column = "string",
                                        DataType = "string",
                                        Encoding = "string",
                                        Length = 0,
                                        Nullable = false,
                                        OrdinalPosition = 0,
                                        Precision = 0,
                                        PrimaryKey = false,
                                        Scale = 0,
                                    },
                                },
                            },
                        },
                    },
                },
            },
            PostgresqlExcludedObjects = new Gcp.Datastream.Inputs.StreamBackfillAllPostgresqlExcludedObjectsArgs
            {
                PostgresqlSchemas = new[]
                {
                    new Gcp.Datastream.Inputs.StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaArgs
                    {
                        Schema = "string",
                        PostgresqlTables = new[]
                        {
                            new Gcp.Datastream.Inputs.StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTableArgs
                            {
                                Table = "string",
                                PostgresqlColumns = new[]
                                {
                                    new Gcp.Datastream.Inputs.StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs
                                    {
                                        Column = "string",
                                        DataType = "string",
                                        Length = 0,
                                        Nullable = false,
                                        OrdinalPosition = 0,
                                        Precision = 0,
                                        PrimaryKey = false,
                                        Scale = 0,
                                    },
                                },
                            },
                        },
                    },
                },
            },
            SqlServerExcludedObjects = new Gcp.Datastream.Inputs.StreamBackfillAllSqlServerExcludedObjectsArgs
            {
                Schemas = new[]
                {
                    new Gcp.Datastream.Inputs.StreamBackfillAllSqlServerExcludedObjectsSchemaArgs
                    {
                        Schema = "string",
                        Tables = new[]
                        {
                            new Gcp.Datastream.Inputs.StreamBackfillAllSqlServerExcludedObjectsSchemaTableArgs
                            {
                                Table = "string",
                                Columns = new[]
                                {
                                    new Gcp.Datastream.Inputs.StreamBackfillAllSqlServerExcludedObjectsSchemaTableColumnArgs
                                    {
                                        Column = "string",
                                        DataType = "string",
                                        Length = 0,
                                        Nullable = false,
                                        OrdinalPosition = 0,
                                        Precision = 0,
                                        PrimaryKey = false,
                                        Scale = 0,
                                    },
                                },
                            },
                        },
                    },
                },
            },
        },
        BackfillNone = null,
        CreateWithoutValidation = false,
        CustomerManagedEncryptionKey = "string",
        DesiredState = "string",
        Labels = 
        {
            { "string", "string" },
        },
        Project = "string",
    });
    
    example, err := datastream.NewStream(ctx, "streamResource", &datastream.StreamArgs{
    	DestinationConfig: &datastream.StreamDestinationConfigArgs{
    		DestinationConnectionProfile: pulumi.String("string"),
    		BigqueryDestinationConfig: &datastream.StreamDestinationConfigBigqueryDestinationConfigArgs{
    			DataFreshness: pulumi.String("string"),
    			SingleTargetDataset: &datastream.StreamDestinationConfigBigqueryDestinationConfigSingleTargetDatasetArgs{
    				DatasetId: pulumi.String("string"),
    			},
    			SourceHierarchyDatasets: &datastream.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs{
    				DatasetTemplate: &datastream.StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs{
    					Location:        pulumi.String("string"),
    					DatasetIdPrefix: pulumi.String("string"),
    					KmsKeyName:      pulumi.String("string"),
    				},
    			},
    		},
    		GcsDestinationConfig: &datastream.StreamDestinationConfigGcsDestinationConfigArgs{
    			AvroFileFormat:       nil,
    			FileRotationInterval: pulumi.String("string"),
    			FileRotationMb:       pulumi.Int(0),
    			JsonFileFormat: &datastream.StreamDestinationConfigGcsDestinationConfigJsonFileFormatArgs{
    				Compression:      pulumi.String("string"),
    				SchemaFileFormat: pulumi.String("string"),
    			},
    			Path: pulumi.String("string"),
    		},
    	},
    	DisplayName: pulumi.String("string"),
    	Location:    pulumi.String("string"),
    	SourceConfig: &datastream.StreamSourceConfigArgs{
    		SourceConnectionProfile: pulumi.String("string"),
    		MysqlSourceConfig: &datastream.StreamSourceConfigMysqlSourceConfigArgs{
    			ExcludeObjects: &datastream.StreamSourceConfigMysqlSourceConfigExcludeObjectsArgs{
    				MysqlDatabases: datastream.StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseArray{
    					&datastream.StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseArgs{
    						Database: pulumi.String("string"),
    						MysqlTables: datastream.StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableArray{
    							&datastream.StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableArgs{
    								Table: pulumi.String("string"),
    								MysqlColumns: datastream.StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableMysqlColumnArray{
    									&datastream.StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs{
    										Collation:       pulumi.String("string"),
    										Column:          pulumi.String("string"),
    										DataType:        pulumi.String("string"),
    										Length:          pulumi.Int(0),
    										Nullable:        pulumi.Bool(false),
    										OrdinalPosition: pulumi.Int(0),
    										PrimaryKey:      pulumi.Bool(false),
    									},
    								},
    							},
    						},
    					},
    				},
    			},
    			IncludeObjects: &datastream.StreamSourceConfigMysqlSourceConfigIncludeObjectsArgs{
    				MysqlDatabases: datastream.StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseArray{
    					&datastream.StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseArgs{
    						Database: pulumi.String("string"),
    						MysqlTables: datastream.StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArray{
    							&datastream.StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgs{
    								Table: pulumi.String("string"),
    								MysqlColumns: datastream.StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableMysqlColumnArray{
    									&datastream.StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs{
    										Collation:       pulumi.String("string"),
    										Column:          pulumi.String("string"),
    										DataType:        pulumi.String("string"),
    										Length:          pulumi.Int(0),
    										Nullable:        pulumi.Bool(false),
    										OrdinalPosition: pulumi.Int(0),
    										PrimaryKey:      pulumi.Bool(false),
    									},
    								},
    							},
    						},
    					},
    				},
    			},
    			MaxConcurrentBackfillTasks: pulumi.Int(0),
    			MaxConcurrentCdcTasks:      pulumi.Int(0),
    		},
    		OracleSourceConfig: &datastream.StreamSourceConfigOracleSourceConfigArgs{
    			DropLargeObjects: nil,
    			ExcludeObjects: &datastream.StreamSourceConfigOracleSourceConfigExcludeObjectsArgs{
    				OracleSchemas: datastream.StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaArray{
    					&datastream.StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaArgs{
    						Schema: pulumi.String("string"),
    						OracleTables: datastream.StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableArray{
    							&datastream.StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableArgs{
    								Table: pulumi.String("string"),
    								OracleColumns: datastream.StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableOracleColumnArray{
    									&datastream.StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableOracleColumnArgs{
    										Column:          pulumi.String("string"),
    										DataType:        pulumi.String("string"),
    										Encoding:        pulumi.String("string"),
    										Length:          pulumi.Int(0),
    										Nullable:        pulumi.Bool(false),
    										OrdinalPosition: pulumi.Int(0),
    										Precision:       pulumi.Int(0),
    										PrimaryKey:      pulumi.Bool(false),
    										Scale:           pulumi.Int(0),
    									},
    								},
    							},
    						},
    					},
    				},
    			},
    			IncludeObjects: &datastream.StreamSourceConfigOracleSourceConfigIncludeObjectsArgs{
    				OracleSchemas: datastream.StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaArray{
    					&datastream.StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaArgs{
    						Schema: pulumi.String("string"),
    						OracleTables: datastream.StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableArray{
    							&datastream.StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableArgs{
    								Table: pulumi.String("string"),
    								OracleColumns: datastream.StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArray{
    									&datastream.StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArgs{
    										Column:          pulumi.String("string"),
    										DataType:        pulumi.String("string"),
    										Encoding:        pulumi.String("string"),
    										Length:          pulumi.Int(0),
    										Nullable:        pulumi.Bool(false),
    										OrdinalPosition: pulumi.Int(0),
    										Precision:       pulumi.Int(0),
    										PrimaryKey:      pulumi.Bool(false),
    										Scale:           pulumi.Int(0),
    									},
    								},
    							},
    						},
    					},
    				},
    			},
    			MaxConcurrentBackfillTasks: pulumi.Int(0),
    			MaxConcurrentCdcTasks:      pulumi.Int(0),
    			StreamLargeObjects:         nil,
    		},
    		PostgresqlSourceConfig: &datastream.StreamSourceConfigPostgresqlSourceConfigArgs{
    			Publication:     pulumi.String("string"),
    			ReplicationSlot: pulumi.String("string"),
    			ExcludeObjects: &datastream.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsArgs{
    				PostgresqlSchemas: datastream.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArray{
    					&datastream.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArgs{
    						Schema: pulumi.String("string"),
    						PostgresqlTables: datastream.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTableArray{
    							&datastream.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTableArgs{
    								Table: pulumi.String("string"),
    								PostgresqlColumns: datastream.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArray{
    									&datastream.StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs{
    										Column:          pulumi.String("string"),
    										DataType:        pulumi.String("string"),
    										Length:          pulumi.Int(0),
    										Nullable:        pulumi.Bool(false),
    										OrdinalPosition: pulumi.Int(0),
    										Precision:       pulumi.Int(0),
    										PrimaryKey:      pulumi.Bool(false),
    										Scale:           pulumi.Int(0),
    									},
    								},
    							},
    						},
    					},
    				},
    			},
    			IncludeObjects: &datastream.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsArgs{
    				PostgresqlSchemas: datastream.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArray{
    					&datastream.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArgs{
    						Schema: pulumi.String("string"),
    						PostgresqlTables: datastream.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTableArray{
    							&datastream.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTableArgs{
    								Table: pulumi.String("string"),
    								PostgresqlColumns: datastream.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArray{
    									&datastream.StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs{
    										Column:          pulumi.String("string"),
    										DataType:        pulumi.String("string"),
    										Length:          pulumi.Int(0),
    										Nullable:        pulumi.Bool(false),
    										OrdinalPosition: pulumi.Int(0),
    										Precision:       pulumi.Int(0),
    										PrimaryKey:      pulumi.Bool(false),
    										Scale:           pulumi.Int(0),
    									},
    								},
    							},
    						},
    					},
    				},
    			},
    			MaxConcurrentBackfillTasks: pulumi.Int(0),
    		},
    		SqlServerSourceConfig: &datastream.StreamSourceConfigSqlServerSourceConfigArgs{
    			ExcludeObjects: &datastream.StreamSourceConfigSqlServerSourceConfigExcludeObjectsArgs{
    				Schemas: datastream.StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaArray{
    					&datastream.StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaArgs{
    						Schema: pulumi.String("string"),
    						Tables: datastream.StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableArray{
    							&datastream.StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableArgs{
    								Table: pulumi.String("string"),
    								Columns: datastream.StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableColumnArray{
    									&datastream.StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableColumnArgs{
    										Column:          pulumi.String("string"),
    										DataType:        pulumi.String("string"),
    										Length:          pulumi.Int(0),
    										Nullable:        pulumi.Bool(false),
    										OrdinalPosition: pulumi.Int(0),
    										Precision:       pulumi.Int(0),
    										PrimaryKey:      pulumi.Bool(false),
    										Scale:           pulumi.Int(0),
    									},
    								},
    							},
    						},
    					},
    				},
    			},
    			IncludeObjects: &datastream.StreamSourceConfigSqlServerSourceConfigIncludeObjectsArgs{
    				Schemas: datastream.StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaArray{
    					&datastream.StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaArgs{
    						Schema: pulumi.String("string"),
    						Tables: datastream.StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableArray{
    							&datastream.StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableArgs{
    								Table: pulumi.String("string"),
    								Columns: datastream.StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableColumnArray{
    									&datastream.StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableColumnArgs{
    										Column:          pulumi.String("string"),
    										DataType:        pulumi.String("string"),
    										Length:          pulumi.Int(0),
    										Nullable:        pulumi.Bool(false),
    										OrdinalPosition: pulumi.Int(0),
    										Precision:       pulumi.Int(0),
    										PrimaryKey:      pulumi.Bool(false),
    										Scale:           pulumi.Int(0),
    									},
    								},
    							},
    						},
    					},
    				},
    			},
    			MaxConcurrentBackfillTasks: pulumi.Int(0),
    			MaxConcurrentCdcTasks:      pulumi.Int(0),
    		},
    	},
    	StreamId: pulumi.String("string"),
    	BackfillAll: &datastream.StreamBackfillAllArgs{
    		MysqlExcludedObjects: &datastream.StreamBackfillAllMysqlExcludedObjectsArgs{
    			MysqlDatabases: datastream.StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseArray{
    				&datastream.StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseArgs{
    					Database: pulumi.String("string"),
    					MysqlTables: datastream.StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableArray{
    						&datastream.StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableArgs{
    							Table: pulumi.String("string"),
    							MysqlColumns: datastream.StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableMysqlColumnArray{
    								&datastream.StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableMysqlColumnArgs{
    									Collation:       pulumi.String("string"),
    									Column:          pulumi.String("string"),
    									DataType:        pulumi.String("string"),
    									Length:          pulumi.Int(0),
    									Nullable:        pulumi.Bool(false),
    									OrdinalPosition: pulumi.Int(0),
    									PrimaryKey:      pulumi.Bool(false),
    								},
    							},
    						},
    					},
    				},
    			},
    		},
    		OracleExcludedObjects: &datastream.StreamBackfillAllOracleExcludedObjectsArgs{
    			OracleSchemas: datastream.StreamBackfillAllOracleExcludedObjectsOracleSchemaArray{
    				&datastream.StreamBackfillAllOracleExcludedObjectsOracleSchemaArgs{
    					Schema: pulumi.String("string"),
    					OracleTables: datastream.StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableArray{
    						&datastream.StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableArgs{
    							Table: pulumi.String("string"),
    							OracleColumns: datastream.StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableOracleColumnArray{
    								&datastream.StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableOracleColumnArgs{
    									Column:          pulumi.String("string"),
    									DataType:        pulumi.String("string"),
    									Encoding:        pulumi.String("string"),
    									Length:          pulumi.Int(0),
    									Nullable:        pulumi.Bool(false),
    									OrdinalPosition: pulumi.Int(0),
    									Precision:       pulumi.Int(0),
    									PrimaryKey:      pulumi.Bool(false),
    									Scale:           pulumi.Int(0),
    								},
    							},
    						},
    					},
    				},
    			},
    		},
    		PostgresqlExcludedObjects: &datastream.StreamBackfillAllPostgresqlExcludedObjectsArgs{
    			PostgresqlSchemas: datastream.StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaArray{
    				&datastream.StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaArgs{
    					Schema: pulumi.String("string"),
    					PostgresqlTables: datastream.StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTableArray{
    						&datastream.StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTableArgs{
    							Table: pulumi.String("string"),
    							PostgresqlColumns: datastream.StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArray{
    								&datastream.StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs{
    									Column:          pulumi.String("string"),
    									DataType:        pulumi.String("string"),
    									Length:          pulumi.Int(0),
    									Nullable:        pulumi.Bool(false),
    									OrdinalPosition: pulumi.Int(0),
    									Precision:       pulumi.Int(0),
    									PrimaryKey:      pulumi.Bool(false),
    									Scale:           pulumi.Int(0),
    								},
    							},
    						},
    					},
    				},
    			},
    		},
    		SqlServerExcludedObjects: &datastream.StreamBackfillAllSqlServerExcludedObjectsArgs{
    			Schemas: datastream.StreamBackfillAllSqlServerExcludedObjectsSchemaArray{
    				&datastream.StreamBackfillAllSqlServerExcludedObjectsSchemaArgs{
    					Schema: pulumi.String("string"),
    					Tables: datastream.StreamBackfillAllSqlServerExcludedObjectsSchemaTableArray{
    						&datastream.StreamBackfillAllSqlServerExcludedObjectsSchemaTableArgs{
    							Table: pulumi.String("string"),
    							Columns: datastream.StreamBackfillAllSqlServerExcludedObjectsSchemaTableColumnArray{
    								&datastream.StreamBackfillAllSqlServerExcludedObjectsSchemaTableColumnArgs{
    									Column:          pulumi.String("string"),
    									DataType:        pulumi.String("string"),
    									Length:          pulumi.Int(0),
    									Nullable:        pulumi.Bool(false),
    									OrdinalPosition: pulumi.Int(0),
    									Precision:       pulumi.Int(0),
    									PrimaryKey:      pulumi.Bool(false),
    									Scale:           pulumi.Int(0),
    								},
    							},
    						},
    					},
    				},
    			},
    		},
    	},
    	BackfillNone:                 nil,
    	CreateWithoutValidation:      pulumi.Bool(false),
    	CustomerManagedEncryptionKey: pulumi.String("string"),
    	DesiredState:                 pulumi.String("string"),
    	Labels: pulumi.StringMap{
    		"string": pulumi.String("string"),
    	},
    	Project: pulumi.String("string"),
    })
    
    var streamResource = new Stream("streamResource", StreamArgs.builder()
        .destinationConfig(StreamDestinationConfigArgs.builder()
            .destinationConnectionProfile("string")
            .bigqueryDestinationConfig(StreamDestinationConfigBigqueryDestinationConfigArgs.builder()
                .dataFreshness("string")
                .singleTargetDataset(StreamDestinationConfigBigqueryDestinationConfigSingleTargetDatasetArgs.builder()
                    .datasetId("string")
                    .build())
                .sourceHierarchyDatasets(StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs.builder()
                    .datasetTemplate(StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs.builder()
                        .location("string")
                        .datasetIdPrefix("string")
                        .kmsKeyName("string")
                        .build())
                    .build())
                .build())
            .gcsDestinationConfig(StreamDestinationConfigGcsDestinationConfigArgs.builder()
                .avroFileFormat()
                .fileRotationInterval("string")
                .fileRotationMb(0)
                .jsonFileFormat(StreamDestinationConfigGcsDestinationConfigJsonFileFormatArgs.builder()
                    .compression("string")
                    .schemaFileFormat("string")
                    .build())
                .path("string")
                .build())
            .build())
        .displayName("string")
        .location("string")
        .sourceConfig(StreamSourceConfigArgs.builder()
            .sourceConnectionProfile("string")
            .mysqlSourceConfig(StreamSourceConfigMysqlSourceConfigArgs.builder()
                .excludeObjects(StreamSourceConfigMysqlSourceConfigExcludeObjectsArgs.builder()
                    .mysqlDatabases(StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseArgs.builder()
                        .database("string")
                        .mysqlTables(StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableArgs.builder()
                            .table("string")
                            .mysqlColumns(StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs.builder()
                                .collation("string")
                                .column("string")
                                .dataType("string")
                                .length(0)
                                .nullable(false)
                                .ordinalPosition(0)
                                .primaryKey(false)
                                .build())
                            .build())
                        .build())
                    .build())
                .includeObjects(StreamSourceConfigMysqlSourceConfigIncludeObjectsArgs.builder()
                    .mysqlDatabases(StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseArgs.builder()
                        .database("string")
                        .mysqlTables(StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgs.builder()
                            .table("string")
                            .mysqlColumns(StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs.builder()
                                .collation("string")
                                .column("string")
                                .dataType("string")
                                .length(0)
                                .nullable(false)
                                .ordinalPosition(0)
                                .primaryKey(false)
                                .build())
                            .build())
                        .build())
                    .build())
                .maxConcurrentBackfillTasks(0)
                .maxConcurrentCdcTasks(0)
                .build())
            .oracleSourceConfig(StreamSourceConfigOracleSourceConfigArgs.builder()
                .dropLargeObjects()
                .excludeObjects(StreamSourceConfigOracleSourceConfigExcludeObjectsArgs.builder()
                    .oracleSchemas(StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaArgs.builder()
                        .schema("string")
                        .oracleTables(StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableArgs.builder()
                            .table("string")
                            .oracleColumns(StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableOracleColumnArgs.builder()
                                .column("string")
                                .dataType("string")
                                .encoding("string")
                                .length(0)
                                .nullable(false)
                                .ordinalPosition(0)
                                .precision(0)
                                .primaryKey(false)
                                .scale(0)
                                .build())
                            .build())
                        .build())
                    .build())
                .includeObjects(StreamSourceConfigOracleSourceConfigIncludeObjectsArgs.builder()
                    .oracleSchemas(StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaArgs.builder()
                        .schema("string")
                        .oracleTables(StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableArgs.builder()
                            .table("string")
                            .oracleColumns(StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArgs.builder()
                                .column("string")
                                .dataType("string")
                                .encoding("string")
                                .length(0)
                                .nullable(false)
                                .ordinalPosition(0)
                                .precision(0)
                                .primaryKey(false)
                                .scale(0)
                                .build())
                            .build())
                        .build())
                    .build())
                .maxConcurrentBackfillTasks(0)
                .maxConcurrentCdcTasks(0)
                .streamLargeObjects()
                .build())
            .postgresqlSourceConfig(StreamSourceConfigPostgresqlSourceConfigArgs.builder()
                .publication("string")
                .replicationSlot("string")
                .excludeObjects(StreamSourceConfigPostgresqlSourceConfigExcludeObjectsArgs.builder()
                    .postgresqlSchemas(StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArgs.builder()
                        .schema("string")
                        .postgresqlTables(StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTableArgs.builder()
                            .table("string")
                            .postgresqlColumns(StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs.builder()
                                .column("string")
                                .dataType("string")
                                .length(0)
                                .nullable(false)
                                .ordinalPosition(0)
                                .precision(0)
                                .primaryKey(false)
                                .scale(0)
                                .build())
                            .build())
                        .build())
                    .build())
                .includeObjects(StreamSourceConfigPostgresqlSourceConfigIncludeObjectsArgs.builder()
                    .postgresqlSchemas(StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArgs.builder()
                        .schema("string")
                        .postgresqlTables(StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTableArgs.builder()
                            .table("string")
                            .postgresqlColumns(StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs.builder()
                                .column("string")
                                .dataType("string")
                                .length(0)
                                .nullable(false)
                                .ordinalPosition(0)
                                .precision(0)
                                .primaryKey(false)
                                .scale(0)
                                .build())
                            .build())
                        .build())
                    .build())
                .maxConcurrentBackfillTasks(0)
                .build())
            .sqlServerSourceConfig(StreamSourceConfigSqlServerSourceConfigArgs.builder()
                .excludeObjects(StreamSourceConfigSqlServerSourceConfigExcludeObjectsArgs.builder()
                    .schemas(StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaArgs.builder()
                        .schema("string")
                        .tables(StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableArgs.builder()
                            .table("string")
                            .columns(StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableColumnArgs.builder()
                                .column("string")
                                .dataType("string")
                                .length(0)
                                .nullable(false)
                                .ordinalPosition(0)
                                .precision(0)
                                .primaryKey(false)
                                .scale(0)
                                .build())
                            .build())
                        .build())
                    .build())
                .includeObjects(StreamSourceConfigSqlServerSourceConfigIncludeObjectsArgs.builder()
                    .schemas(StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaArgs.builder()
                        .schema("string")
                        .tables(StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableArgs.builder()
                            .table("string")
                            .columns(StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableColumnArgs.builder()
                                .column("string")
                                .dataType("string")
                                .length(0)
                                .nullable(false)
                                .ordinalPosition(0)
                                .precision(0)
                                .primaryKey(false)
                                .scale(0)
                                .build())
                            .build())
                        .build())
                    .build())
                .maxConcurrentBackfillTasks(0)
                .maxConcurrentCdcTasks(0)
                .build())
            .build())
        .streamId("string")
        .backfillAll(StreamBackfillAllArgs.builder()
            .mysqlExcludedObjects(StreamBackfillAllMysqlExcludedObjectsArgs.builder()
                .mysqlDatabases(StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseArgs.builder()
                    .database("string")
                    .mysqlTables(StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableArgs.builder()
                        .table("string")
                        .mysqlColumns(StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableMysqlColumnArgs.builder()
                            .collation("string")
                            .column("string")
                            .dataType("string")
                            .length(0)
                            .nullable(false)
                            .ordinalPosition(0)
                            .primaryKey(false)
                            .build())
                        .build())
                    .build())
                .build())
            .oracleExcludedObjects(StreamBackfillAllOracleExcludedObjectsArgs.builder()
                .oracleSchemas(StreamBackfillAllOracleExcludedObjectsOracleSchemaArgs.builder()
                    .schema("string")
                    .oracleTables(StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableArgs.builder()
                        .table("string")
                        .oracleColumns(StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableOracleColumnArgs.builder()
                            .column("string")
                            .dataType("string")
                            .encoding("string")
                            .length(0)
                            .nullable(false)
                            .ordinalPosition(0)
                            .precision(0)
                            .primaryKey(false)
                            .scale(0)
                            .build())
                        .build())
                    .build())
                .build())
            .postgresqlExcludedObjects(StreamBackfillAllPostgresqlExcludedObjectsArgs.builder()
                .postgresqlSchemas(StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaArgs.builder()
                    .schema("string")
                    .postgresqlTables(StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTableArgs.builder()
                        .table("string")
                        .postgresqlColumns(StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs.builder()
                            .column("string")
                            .<