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

gcp.datastream.ConnectionProfile

Explore with Pulumi AI

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

    A set of reusable connection configurations to be used as a source or destination for a stream.

    To get more information about ConnectionProfile, see:

    Example Usage

    Datastream Connection Profile Basic

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const _default = new gcp.datastream.ConnectionProfile("default", {
        displayName: "Connection profile",
        location: "us-central1",
        connectionProfileId: "my-profile",
        gcsProfile: {
            bucket: "my-bucket",
            rootPath: "/path",
        },
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    default = gcp.datastream.ConnectionProfile("default",
        display_name="Connection profile",
        location="us-central1",
        connection_profile_id="my-profile",
        gcs_profile=gcp.datastream.ConnectionProfileGcsProfileArgs(
            bucket="my-bucket",
            root_path="/path",
        ))
    
    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 {
    		_, err := datastream.NewConnectionProfile(ctx, "default", &datastream.ConnectionProfileArgs{
    			DisplayName:         pulumi.String("Connection profile"),
    			Location:            pulumi.String("us-central1"),
    			ConnectionProfileId: pulumi.String("my-profile"),
    			GcsProfile: &datastream.ConnectionProfileGcsProfileArgs{
    				Bucket:   pulumi.String("my-bucket"),
    				RootPath: pulumi.String("/path"),
    			},
    		})
    		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 @default = new Gcp.Datastream.ConnectionProfile("default", new()
        {
            DisplayName = "Connection profile",
            Location = "us-central1",
            ConnectionProfileId = "my-profile",
            GcsProfile = new Gcp.Datastream.Inputs.ConnectionProfileGcsProfileArgs
            {
                Bucket = "my-bucket",
                RootPath = "/path",
            },
        });
    
    });
    
    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.ConnectionProfileGcsProfileArgs;
    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 default_ = new ConnectionProfile("default", ConnectionProfileArgs.builder()
                .displayName("Connection profile")
                .location("us-central1")
                .connectionProfileId("my-profile")
                .gcsProfile(ConnectionProfileGcsProfileArgs.builder()
                    .bucket("my-bucket")
                    .rootPath("/path")
                    .build())
                .build());
    
        }
    }
    
    resources:
      default:
        type: gcp:datastream:ConnectionProfile
        properties:
          displayName: Connection profile
          location: us-central1
          connectionProfileId: my-profile
          gcsProfile:
            bucket: my-bucket
            rootPath: /path
    

    Datastream Connection Profile Postgresql Private Connection

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    import * as random from "@pulumi/random";
    
    const _default = new gcp.compute.Network("default", {name: "my-network"});
    const privateConnection = new gcp.datastream.PrivateConnection("private_connection", {
        displayName: "Connection profile",
        location: "us-central1",
        privateConnectionId: "my-connection",
        labels: {
            key: "value",
        },
        vpcPeeringConfig: {
            vpc: _default.id,
            subnet: "10.0.0.0/29",
        },
    });
    const instance = new gcp.sql.DatabaseInstance("instance", {
        name: "my-instance",
        databaseVersion: "POSTGRES_14",
        region: "us-central1",
        settings: {
            tier: "db-f1-micro",
            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,
        password: pwd.result,
    });
    const defaultConnectionProfile = new gcp.datastream.ConnectionProfile("default", {
        displayName: "Connection profile",
        location: "us-central1",
        connectionProfileId: "my-profile",
        postgresqlProfile: {
            hostname: instance.publicIpAddress,
            username: user.name,
            password: user.password,
            database: db.name,
        },
        privateConnectivity: {
            privateConnection: privateConnection.id,
        },
    });
    
    import pulumi
    import pulumi_gcp as gcp
    import pulumi_random as random
    
    default = gcp.compute.Network("default", name="my-network")
    private_connection = gcp.datastream.PrivateConnection("private_connection",
        display_name="Connection profile",
        location="us-central1",
        private_connection_id="my-connection",
        labels={
            "key": "value",
        },
        vpc_peering_config=gcp.datastream.PrivateConnectionVpcPeeringConfigArgs(
            vpc=default.id,
            subnet="10.0.0.0/29",
        ))
    instance = gcp.sql.DatabaseInstance("instance",
        name="my-instance",
        database_version="POSTGRES_14",
        region="us-central1",
        settings=gcp.sql.DatabaseInstanceSettingsArgs(
            tier="db-f1-micro",
            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,
        password=pwd.result)
    default_connection_profile = gcp.datastream.ConnectionProfile("default",
        display_name="Connection profile",
        location="us-central1",
        connection_profile_id="my-profile",
        postgresql_profile=gcp.datastream.ConnectionProfilePostgresqlProfileArgs(
            hostname=instance.public_ip_address,
            username=user.name,
            password=user.password,
            database=db.name,
        ),
        private_connectivity=gcp.datastream.ConnectionProfilePrivateConnectivityArgs(
            private_connection=private_connection.id,
        ))
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
    	"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 {
    		_, err := compute.NewNetwork(ctx, "default", &compute.NetworkArgs{
    			Name: pulumi.String("my-network"),
    		})
    		if err != nil {
    			return err
    		}
    		privateConnection, err := datastream.NewPrivateConnection(ctx, "private_connection", &datastream.PrivateConnectionArgs{
    			DisplayName:         pulumi.String("Connection profile"),
    			Location:            pulumi.String("us-central1"),
    			PrivateConnectionId: pulumi.String("my-connection"),
    			Labels: pulumi.StringMap{
    				"key": pulumi.String("value"),
    			},
    			VpcPeeringConfig: &datastream.PrivateConnectionVpcPeeringConfigArgs{
    				Vpc:    _default.ID(),
    				Subnet: pulumi.String("10.0.0.0/29"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		instance, err := sql.NewDatabaseInstance(ctx, "instance", &sql.DatabaseInstanceArgs{
    			Name:            pulumi.String("my-instance"),
    			DatabaseVersion: pulumi.String("POSTGRES_14"),
    			Region:          pulumi.String("us-central1"),
    			Settings: &sql.DatabaseInstanceSettingsArgs{
    				Tier: pulumi.String("db-f1-micro"),
    				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
    		}
    		db, 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,
    			Password: pwd.Result,
    		})
    		if err != nil {
    			return err
    		}
    		_, err = datastream.NewConnectionProfile(ctx, "default", &datastream.ConnectionProfileArgs{
    			DisplayName:         pulumi.String("Connection profile"),
    			Location:            pulumi.String("us-central1"),
    			ConnectionProfileId: pulumi.String("my-profile"),
    			PostgresqlProfile: &datastream.ConnectionProfilePostgresqlProfileArgs{
    				Hostname: instance.PublicIpAddress,
    				Username: user.Name,
    				Password: user.Password,
    				Database: db.Name,
    			},
    			PrivateConnectivity: &datastream.ConnectionProfilePrivateConnectivityArgs{
    				PrivateConnection: privateConnection.ID(),
    			},
    		})
    		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 @default = new Gcp.Compute.Network("default", new()
        {
            Name = "my-network",
        });
    
        var privateConnection = new Gcp.Datastream.PrivateConnection("private_connection", new()
        {
            DisplayName = "Connection profile",
            Location = "us-central1",
            PrivateConnectionId = "my-connection",
            Labels = 
            {
                { "key", "value" },
            },
            VpcPeeringConfig = new Gcp.Datastream.Inputs.PrivateConnectionVpcPeeringConfigArgs
            {
                Vpc = @default.Id,
                Subnet = "10.0.0.0/29",
            },
        });
    
        var instance = new Gcp.Sql.DatabaseInstance("instance", new()
        {
            Name = "my-instance",
            DatabaseVersion = "POSTGRES_14",
            Region = "us-central1",
            Settings = new Gcp.Sql.Inputs.DatabaseInstanceSettingsArgs
            {
                Tier = "db-f1-micro",
                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,
            Password = pwd.Result,
        });
    
        var defaultConnectionProfile = new Gcp.Datastream.ConnectionProfile("default", new()
        {
            DisplayName = "Connection profile",
            Location = "us-central1",
            ConnectionProfileId = "my-profile",
            PostgresqlProfile = new Gcp.Datastream.Inputs.ConnectionProfilePostgresqlProfileArgs
            {
                Hostname = instance.PublicIpAddress,
                Username = user.Name,
                Password = user.Password,
                Database = db.Name,
            },
            PrivateConnectivity = new Gcp.Datastream.Inputs.ConnectionProfilePrivateConnectivityArgs
            {
                PrivateConnection = privateConnection.Id,
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.gcp.compute.Network;
    import com.pulumi.gcp.compute.NetworkArgs;
    import com.pulumi.gcp.datastream.PrivateConnection;
    import com.pulumi.gcp.datastream.PrivateConnectionArgs;
    import com.pulumi.gcp.datastream.inputs.PrivateConnectionVpcPeeringConfigArgs;
    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.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.ConnectionProfilePostgresqlProfileArgs;
    import com.pulumi.gcp.datastream.inputs.ConnectionProfilePrivateConnectivityArgs;
    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 default_ = new Network("default", NetworkArgs.builder()
                .name("my-network")
                .build());
    
            var privateConnection = new PrivateConnection("privateConnection", PrivateConnectionArgs.builder()
                .displayName("Connection profile")
                .location("us-central1")
                .privateConnectionId("my-connection")
                .labels(Map.of("key", "value"))
                .vpcPeeringConfig(PrivateConnectionVpcPeeringConfigArgs.builder()
                    .vpc(default_.id())
                    .subnet("10.0.0.0/29")
                    .build())
                .build());
    
            var instance = new DatabaseInstance("instance", DatabaseInstanceArgs.builder()
                .name("my-instance")
                .databaseVersion("POSTGRES_14")
                .region("us-central1")
                .settings(DatabaseInstanceSettingsArgs.builder()
                    .tier("db-f1-micro")
                    .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())
                .password(pwd.result())
                .build());
    
            var defaultConnectionProfile = new ConnectionProfile("defaultConnectionProfile", ConnectionProfileArgs.builder()
                .displayName("Connection profile")
                .location("us-central1")
                .connectionProfileId("my-profile")
                .postgresqlProfile(ConnectionProfilePostgresqlProfileArgs.builder()
                    .hostname(instance.publicIpAddress())
                    .username(user.name())
                    .password(user.password())
                    .database(db.name())
                    .build())
                .privateConnectivity(ConnectionProfilePrivateConnectivityArgs.builder()
                    .privateConnection(privateConnection.id())
                    .build())
                .build());
    
        }
    }
    
    resources:
      privateConnection:
        type: gcp:datastream:PrivateConnection
        name: private_connection
        properties:
          displayName: Connection profile
          location: us-central1
          privateConnectionId: my-connection
          labels:
            key: value
          vpcPeeringConfig:
            vpc: ${default.id}
            subnet: 10.0.0.0/29
      default:
        type: gcp:compute:Network
        properties:
          name: my-network
      instance:
        type: gcp:sql:DatabaseInstance
        properties:
          name: my-instance
          databaseVersion: POSTGRES_14
          region: us-central1
          settings:
            tier: db-f1-micro
            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}
          password: ${pwd.result}
      defaultConnectionProfile:
        type: gcp:datastream:ConnectionProfile
        name: default
        properties:
          displayName: Connection profile
          location: us-central1
          connectionProfileId: my-profile
          postgresqlProfile:
            hostname: ${instance.publicIpAddress}
            username: ${user.name}
            password: ${user.password}
            database: ${db.name}
          privateConnectivity:
            privateConnection: ${privateConnection.id}
    

    Datastream Connection Profile Full

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const _default = new gcp.datastream.ConnectionProfile("default", {
        displayName: "Connection profile",
        location: "us-central1",
        connectionProfileId: "my-profile",
        gcsProfile: {
            bucket: "my-bucket",
            rootPath: "/path",
        },
        forwardSshConnectivity: {
            hostname: "google.com",
            username: "my-user",
            port: 8022,
            password: "swordfish",
        },
        labels: {
            key: "value",
        },
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    default = gcp.datastream.ConnectionProfile("default",
        display_name="Connection profile",
        location="us-central1",
        connection_profile_id="my-profile",
        gcs_profile=gcp.datastream.ConnectionProfileGcsProfileArgs(
            bucket="my-bucket",
            root_path="/path",
        ),
        forward_ssh_connectivity=gcp.datastream.ConnectionProfileForwardSshConnectivityArgs(
            hostname="google.com",
            username="my-user",
            port=8022,
            password="swordfish",
        ),
        labels={
            "key": "value",
        })
    
    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 {
    		_, err := datastream.NewConnectionProfile(ctx, "default", &datastream.ConnectionProfileArgs{
    			DisplayName:         pulumi.String("Connection profile"),
    			Location:            pulumi.String("us-central1"),
    			ConnectionProfileId: pulumi.String("my-profile"),
    			GcsProfile: &datastream.ConnectionProfileGcsProfileArgs{
    				Bucket:   pulumi.String("my-bucket"),
    				RootPath: pulumi.String("/path"),
    			},
    			ForwardSshConnectivity: &datastream.ConnectionProfileForwardSshConnectivityArgs{
    				Hostname: pulumi.String("google.com"),
    				Username: pulumi.String("my-user"),
    				Port:     pulumi.Int(8022),
    				Password: pulumi.String("swordfish"),
    			},
    			Labels: pulumi.StringMap{
    				"key": pulumi.String("value"),
    			},
    		})
    		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 @default = new Gcp.Datastream.ConnectionProfile("default", new()
        {
            DisplayName = "Connection profile",
            Location = "us-central1",
            ConnectionProfileId = "my-profile",
            GcsProfile = new Gcp.Datastream.Inputs.ConnectionProfileGcsProfileArgs
            {
                Bucket = "my-bucket",
                RootPath = "/path",
            },
            ForwardSshConnectivity = new Gcp.Datastream.Inputs.ConnectionProfileForwardSshConnectivityArgs
            {
                Hostname = "google.com",
                Username = "my-user",
                Port = 8022,
                Password = "swordfish",
            },
            Labels = 
            {
                { "key", "value" },
            },
        });
    
    });
    
    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.ConnectionProfileGcsProfileArgs;
    import com.pulumi.gcp.datastream.inputs.ConnectionProfileForwardSshConnectivityArgs;
    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 default_ = new ConnectionProfile("default", ConnectionProfileArgs.builder()
                .displayName("Connection profile")
                .location("us-central1")
                .connectionProfileId("my-profile")
                .gcsProfile(ConnectionProfileGcsProfileArgs.builder()
                    .bucket("my-bucket")
                    .rootPath("/path")
                    .build())
                .forwardSshConnectivity(ConnectionProfileForwardSshConnectivityArgs.builder()
                    .hostname("google.com")
                    .username("my-user")
                    .port(8022)
                    .password("swordfish")
                    .build())
                .labels(Map.of("key", "value"))
                .build());
    
        }
    }
    
    resources:
      default:
        type: gcp:datastream:ConnectionProfile
        properties:
          displayName: Connection profile
          location: us-central1
          connectionProfileId: my-profile
          gcsProfile:
            bucket: my-bucket
            rootPath: /path
          forwardSshConnectivity:
            hostname: google.com
            username: my-user
            port: 8022
            password: swordfish
          labels:
            key: value
    

    Datastream Connection Profile Postgres

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    import * as random from "@pulumi/random";
    
    const instance = new gcp.sql.DatabaseInstance("instance", {
        name: "my-instance",
        databaseVersion: "POSTGRES_14",
        region: "us-central1",
        settings: {
            tier: "db-f1-micro",
            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,
        password: pwd.result,
    });
    const _default = new gcp.datastream.ConnectionProfile("default", {
        displayName: "Connection profile",
        location: "us-central1",
        connectionProfileId: "my-profile",
        postgresqlProfile: {
            hostname: instance.publicIpAddress,
            username: user.name,
            password: user.password,
            database: db.name,
        },
    });
    
    import pulumi
    import pulumi_gcp as gcp
    import pulumi_random as random
    
    instance = gcp.sql.DatabaseInstance("instance",
        name="my-instance",
        database_version="POSTGRES_14",
        region="us-central1",
        settings=gcp.sql.DatabaseInstanceSettingsArgs(
            tier="db-f1-micro",
            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,
        password=pwd.result)
    default = gcp.datastream.ConnectionProfile("default",
        display_name="Connection profile",
        location="us-central1",
        connection_profile_id="my-profile",
        postgresql_profile=gcp.datastream.ConnectionProfilePostgresqlProfileArgs(
            hostname=instance.public_ip_address,
            username=user.name,
            password=user.password,
            database=db.name,
        ))
    
    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-random/sdk/v4/go/random"
    	"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("my-instance"),
    			DatabaseVersion: pulumi.String("POSTGRES_14"),
    			Region:          pulumi.String("us-central1"),
    			Settings: &sql.DatabaseInstanceSettingsArgs{
    				Tier: pulumi.String("db-f1-micro"),
    				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
    		}
    		db, 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,
    			Password: pwd.Result,
    		})
    		if err != nil {
    			return err
    		}
    		_, err = datastream.NewConnectionProfile(ctx, "default", &datastream.ConnectionProfileArgs{
    			DisplayName:         pulumi.String("Connection profile"),
    			Location:            pulumi.String("us-central1"),
    			ConnectionProfileId: pulumi.String("my-profile"),
    			PostgresqlProfile: &datastream.ConnectionProfilePostgresqlProfileArgs{
    				Hostname: instance.PublicIpAddress,
    				Username: user.Name,
    				Password: user.Password,
    				Database: db.Name,
    			},
    		})
    		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 instance = new Gcp.Sql.DatabaseInstance("instance", new()
        {
            Name = "my-instance",
            DatabaseVersion = "POSTGRES_14",
            Region = "us-central1",
            Settings = new Gcp.Sql.Inputs.DatabaseInstanceSettingsArgs
            {
                Tier = "db-f1-micro",
                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,
            Password = pwd.Result,
        });
    
        var @default = new Gcp.Datastream.ConnectionProfile("default", new()
        {
            DisplayName = "Connection profile",
            Location = "us-central1",
            ConnectionProfileId = "my-profile",
            PostgresqlProfile = new Gcp.Datastream.Inputs.ConnectionProfilePostgresqlProfileArgs
            {
                Hostname = instance.PublicIpAddress,
                Username = user.Name,
                Password = user.Password,
                Database = db.Name,
            },
        });
    
    });
    
    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.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.ConnectionProfilePostgresqlProfileArgs;
    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("my-instance")
                .databaseVersion("POSTGRES_14")
                .region("us-central1")
                .settings(DatabaseInstanceSettingsArgs.builder()
                    .tier("db-f1-micro")
                    .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())
                .password(pwd.result())
                .build());
    
            var default_ = new ConnectionProfile("default", ConnectionProfileArgs.builder()
                .displayName("Connection profile")
                .location("us-central1")
                .connectionProfileId("my-profile")
                .postgresqlProfile(ConnectionProfilePostgresqlProfileArgs.builder()
                    .hostname(instance.publicIpAddress())
                    .username(user.name())
                    .password(user.password())
                    .database(db.name())
                    .build())
                .build());
    
        }
    }
    
    resources:
      instance:
        type: gcp:sql:DatabaseInstance
        properties:
          name: my-instance
          databaseVersion: POSTGRES_14
          region: us-central1
          settings:
            tier: db-f1-micro
            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}
          password: ${pwd.result}
      default:
        type: gcp:datastream:ConnectionProfile
        properties:
          displayName: Connection profile
          location: us-central1
          connectionProfileId: my-profile
          postgresqlProfile:
            hostname: ${instance.publicIpAddress}
            username: ${user.name}
            password: ${user.password}
            database: ${db.name}
    

    Datastream Connection Profile 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 db = new gcp.sql.Database("db", {
        name: "db",
        instance: instance.name,
    });
    const user = new gcp.sql.User("user", {
        name: "user",
        instance: instance.name,
        password: "password",
    });
    const _default = new gcp.datastream.ConnectionProfile("default", {
        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,
        },
    });
    
    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",
                    ),
                ],
            ),
        ))
    db = gcp.sql.Database("db",
        name="db",
        instance=instance.name)
    user = gcp.sql.User("user",
        name="user",
        instance=instance.name,
        password="password")
    default = gcp.datastream.ConnectionProfile("default",
        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,
        ))
    
    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
    		}
    		db, err := sql.NewDatabase(ctx, "db", &sql.DatabaseArgs{
    			Name:     pulumi.String("db"),
    			Instance: instance.Name,
    		})
    		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
    		}
    		_, err = datastream.NewConnectionProfile(ctx, "default", &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
    		}
    		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 db = new Gcp.Sql.Database("db", new()
        {
            Name = "db",
            Instance = instance.Name,
        });
    
        var user = new Gcp.Sql.User("user", new()
        {
            Name = "user",
            Instance = instance.Name,
            Password = "password",
        });
    
        var @default = new Gcp.Datastream.ConnectionProfile("default", 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,
            },
        });
    
    });
    
    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.Database;
    import com.pulumi.gcp.sql.DatabaseArgs;
    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.ConnectionProfileSqlServerProfileArgs;
    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 db = new Database("db", DatabaseArgs.builder()
                .name("db")
                .instance(instance.name())
                .build());
    
            var user = new User("user", UserArgs.builder()
                .name("user")
                .instance(instance.name())
                .password("password")
                .build());
    
            var default_ = new ConnectionProfile("default", 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());
    
        }
    }
    
    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}
      user:
        type: gcp:sql:User
        properties:
          name: user
          instance: ${instance.name}
          password: password
      default:
        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}
    

    Create ConnectionProfile Resource

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

    Constructor syntax

    new ConnectionProfile(name: string, args: ConnectionProfileArgs, opts?: CustomResourceOptions);
    @overload
    def ConnectionProfile(resource_name: str,
                          args: ConnectionProfileArgs,
                          opts: Optional[ResourceOptions] = None)
    
    @overload
    def ConnectionProfile(resource_name: str,
                          opts: Optional[ResourceOptions] = None,
                          display_name: Optional[str] = None,
                          connection_profile_id: Optional[str] = None,
                          location: Optional[str] = None,
                          labels: Optional[Mapping[str, str]] = None,
                          forward_ssh_connectivity: Optional[ConnectionProfileForwardSshConnectivityArgs] = None,
                          gcs_profile: Optional[ConnectionProfileGcsProfileArgs] = None,
                          bigquery_profile: Optional[ConnectionProfileBigqueryProfileArgs] = None,
                          create_without_validation: Optional[bool] = None,
                          mysql_profile: Optional[ConnectionProfileMysqlProfileArgs] = None,
                          oracle_profile: Optional[ConnectionProfileOracleProfileArgs] = None,
                          postgresql_profile: Optional[ConnectionProfilePostgresqlProfileArgs] = None,
                          private_connectivity: Optional[ConnectionProfilePrivateConnectivityArgs] = None,
                          project: Optional[str] = None,
                          sql_server_profile: Optional[ConnectionProfileSqlServerProfileArgs] = None)
    func NewConnectionProfile(ctx *Context, name string, args ConnectionProfileArgs, opts ...ResourceOption) (*ConnectionProfile, error)
    public ConnectionProfile(string name, ConnectionProfileArgs args, CustomResourceOptions? opts = null)
    public ConnectionProfile(String name, ConnectionProfileArgs args)
    public ConnectionProfile(String name, ConnectionProfileArgs args, CustomResourceOptions options)
    
    type: gcp:datastream:ConnectionProfile
    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 ConnectionProfileArgs
    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 ConnectionProfileArgs
    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 ConnectionProfileArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args ConnectionProfileArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args ConnectionProfileArgs
    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 gcpConnectionProfileResource = new Gcp.Datastream.ConnectionProfile("gcpConnectionProfileResource", new()
    {
        DisplayName = "string",
        ConnectionProfileId = "string",
        Location = "string",
        Labels = 
        {
            { "string", "string" },
        },
        ForwardSshConnectivity = new Gcp.Datastream.Inputs.ConnectionProfileForwardSshConnectivityArgs
        {
            Hostname = "string",
            Username = "string",
            Password = "string",
            Port = 0,
            PrivateKey = "string",
        },
        GcsProfile = new Gcp.Datastream.Inputs.ConnectionProfileGcsProfileArgs
        {
            Bucket = "string",
            RootPath = "string",
        },
        BigqueryProfile = null,
        CreateWithoutValidation = false,
        MysqlProfile = new Gcp.Datastream.Inputs.ConnectionProfileMysqlProfileArgs
        {
            Hostname = "string",
            Password = "string",
            Username = "string",
            Port = 0,
            SslConfig = new Gcp.Datastream.Inputs.ConnectionProfileMysqlProfileSslConfigArgs
            {
                CaCertificate = "string",
                CaCertificateSet = false,
                ClientCertificate = "string",
                ClientCertificateSet = false,
                ClientKey = "string",
                ClientKeySet = false,
            },
        },
        OracleProfile = new Gcp.Datastream.Inputs.ConnectionProfileOracleProfileArgs
        {
            DatabaseService = "string",
            Hostname = "string",
            Password = "string",
            Username = "string",
            ConnectionAttributes = 
            {
                { "string", "string" },
            },
            Port = 0,
        },
        PostgresqlProfile = new Gcp.Datastream.Inputs.ConnectionProfilePostgresqlProfileArgs
        {
            Database = "string",
            Hostname = "string",
            Password = "string",
            Username = "string",
            Port = 0,
        },
        PrivateConnectivity = new Gcp.Datastream.Inputs.ConnectionProfilePrivateConnectivityArgs
        {
            PrivateConnection = "string",
        },
        Project = "string",
        SqlServerProfile = new Gcp.Datastream.Inputs.ConnectionProfileSqlServerProfileArgs
        {
            Database = "string",
            Hostname = "string",
            Password = "string",
            Username = "string",
            Port = 0,
        },
    });
    
    example, err := datastream.NewConnectionProfile(ctx, "gcpConnectionProfileResource", &datastream.ConnectionProfileArgs{
    	DisplayName:         pulumi.String("string"),
    	ConnectionProfileId: pulumi.String("string"),
    	Location:            pulumi.String("string"),
    	Labels: pulumi.StringMap{
    		"string": pulumi.String("string"),
    	},
    	ForwardSshConnectivity: &datastream.ConnectionProfileForwardSshConnectivityArgs{
    		Hostname:   pulumi.String("string"),
    		Username:   pulumi.String("string"),
    		Password:   pulumi.String("string"),
    		Port:       pulumi.Int(0),
    		PrivateKey: pulumi.String("string"),
    	},
    	GcsProfile: &datastream.ConnectionProfileGcsProfileArgs{
    		Bucket:   pulumi.String("string"),
    		RootPath: pulumi.String("string"),
    	},
    	BigqueryProfile:         nil,
    	CreateWithoutValidation: pulumi.Bool(false),
    	MysqlProfile: &datastream.ConnectionProfileMysqlProfileArgs{
    		Hostname: pulumi.String("string"),
    		Password: pulumi.String("string"),
    		Username: pulumi.String("string"),
    		Port:     pulumi.Int(0),
    		SslConfig: &datastream.ConnectionProfileMysqlProfileSslConfigArgs{
    			CaCertificate:        pulumi.String("string"),
    			CaCertificateSet:     pulumi.Bool(false),
    			ClientCertificate:    pulumi.String("string"),
    			ClientCertificateSet: pulumi.Bool(false),
    			ClientKey:            pulumi.String("string"),
    			ClientKeySet:         pulumi.Bool(false),
    		},
    	},
    	OracleProfile: &datastream.ConnectionProfileOracleProfileArgs{
    		DatabaseService: pulumi.String("string"),
    		Hostname:        pulumi.String("string"),
    		Password:        pulumi.String("string"),
    		Username:        pulumi.String("string"),
    		ConnectionAttributes: pulumi.StringMap{
    			"string": pulumi.String("string"),
    		},
    		Port: pulumi.Int(0),
    	},
    	PostgresqlProfile: &datastream.ConnectionProfilePostgresqlProfileArgs{
    		Database: pulumi.String("string"),
    		Hostname: pulumi.String("string"),
    		Password: pulumi.String("string"),
    		Username: pulumi.String("string"),
    		Port:     pulumi.Int(0),
    	},
    	PrivateConnectivity: &datastream.ConnectionProfilePrivateConnectivityArgs{
    		PrivateConnection: pulumi.String("string"),
    	},
    	Project: pulumi.String("string"),
    	SqlServerProfile: &datastream.ConnectionProfileSqlServerProfileArgs{
    		Database: pulumi.String("string"),
    		Hostname: pulumi.String("string"),
    		Password: pulumi.String("string"),
    		Username: pulumi.String("string"),
    		Port:     pulumi.Int(0),
    	},
    })
    
    var gcpConnectionProfileResource = new ConnectionProfile("gcpConnectionProfileResource", ConnectionProfileArgs.builder()
        .displayName("string")
        .connectionProfileId("string")
        .location("string")
        .labels(Map.of("string", "string"))
        .forwardSshConnectivity(ConnectionProfileForwardSshConnectivityArgs.builder()
            .hostname("string")
            .username("string")
            .password("string")
            .port(0)
            .privateKey("string")
            .build())
        .gcsProfile(ConnectionProfileGcsProfileArgs.builder()
            .bucket("string")
            .rootPath("string")
            .build())
        .bigqueryProfile()
        .createWithoutValidation(false)
        .mysqlProfile(ConnectionProfileMysqlProfileArgs.builder()
            .hostname("string")
            .password("string")
            .username("string")
            .port(0)
            .sslConfig(ConnectionProfileMysqlProfileSslConfigArgs.builder()
                .caCertificate("string")
                .caCertificateSet(false)
                .clientCertificate("string")
                .clientCertificateSet(false)
                .clientKey("string")
                .clientKeySet(false)
                .build())
            .build())
        .oracleProfile(ConnectionProfileOracleProfileArgs.builder()
            .databaseService("string")
            .hostname("string")
            .password("string")
            .username("string")
            .connectionAttributes(Map.of("string", "string"))
            .port(0)
            .build())
        .postgresqlProfile(ConnectionProfilePostgresqlProfileArgs.builder()
            .database("string")
            .hostname("string")
            .password("string")
            .username("string")
            .port(0)
            .build())
        .privateConnectivity(ConnectionProfilePrivateConnectivityArgs.builder()
            .privateConnection("string")
            .build())
        .project("string")
        .sqlServerProfile(ConnectionProfileSqlServerProfileArgs.builder()
            .database("string")
            .hostname("string")
            .password("string")
            .username("string")
            .port(0)
            .build())
        .build());
    
    gcp_connection_profile_resource = gcp.datastream.ConnectionProfile("gcpConnectionProfileResource",
        display_name="string",
        connection_profile_id="string",
        location="string",
        labels={
            "string": "string",
        },
        forward_ssh_connectivity=gcp.datastream.ConnectionProfileForwardSshConnectivityArgs(
            hostname="string",
            username="string",
            password="string",
            port=0,
            private_key="string",
        ),
        gcs_profile=gcp.datastream.ConnectionProfileGcsProfileArgs(
            bucket="string",
            root_path="string",
        ),
        bigquery_profile=gcp.datastream.ConnectionProfileBigqueryProfileArgs(),
        create_without_validation=False,
        mysql_profile=gcp.datastream.ConnectionProfileMysqlProfileArgs(
            hostname="string",
            password="string",
            username="string",
            port=0,
            ssl_config=gcp.datastream.ConnectionProfileMysqlProfileSslConfigArgs(
                ca_certificate="string",
                ca_certificate_set=False,
                client_certificate="string",
                client_certificate_set=False,
                client_key="string",
                client_key_set=False,
            ),
        ),
        oracle_profile=gcp.datastream.ConnectionProfileOracleProfileArgs(
            database_service="string",
            hostname="string",
            password="string",
            username="string",
            connection_attributes={
                "string": "string",
            },
            port=0,
        ),
        postgresql_profile=gcp.datastream.ConnectionProfilePostgresqlProfileArgs(
            database="string",
            hostname="string",
            password="string",
            username="string",
            port=0,
        ),
        private_connectivity=gcp.datastream.ConnectionProfilePrivateConnectivityArgs(
            private_connection="string",
        ),
        project="string",
        sql_server_profile=gcp.datastream.ConnectionProfileSqlServerProfileArgs(
            database="string",
            hostname="string",
            password="string",
            username="string",
            port=0,
        ))
    
    const gcpConnectionProfileResource = new gcp.datastream.ConnectionProfile("gcpConnectionProfileResource", {
        displayName: "string",
        connectionProfileId: "string",
        location: "string",
        labels: {
            string: "string",
        },
        forwardSshConnectivity: {
            hostname: "string",
            username: "string",
            password: "string",
            port: 0,
            privateKey: "string",
        },
        gcsProfile: {
            bucket: "string",
            rootPath: "string",
        },
        bigqueryProfile: {},
        createWithoutValidation: false,
        mysqlProfile: {
            hostname: "string",
            password: "string",
            username: "string",
            port: 0,
            sslConfig: {
                caCertificate: "string",
                caCertificateSet: false,
                clientCertificate: "string",
                clientCertificateSet: false,
                clientKey: "string",
                clientKeySet: false,
            },
        },
        oracleProfile: {
            databaseService: "string",
            hostname: "string",
            password: "string",
            username: "string",
            connectionAttributes: {
                string: "string",
            },
            port: 0,
        },
        postgresqlProfile: {
            database: "string",
            hostname: "string",
            password: "string",
            username: "string",
            port: 0,
        },
        privateConnectivity: {
            privateConnection: "string",
        },
        project: "string",
        sqlServerProfile: {
            database: "string",
            hostname: "string",
            password: "string",
            username: "string",
            port: 0,
        },
    });
    
    type: gcp:datastream:ConnectionProfile
    properties:
        bigqueryProfile: {}
        connectionProfileId: string
        createWithoutValidation: false
        displayName: string
        forwardSshConnectivity:
            hostname: string
            password: string
            port: 0
            privateKey: string
            username: string
        gcsProfile:
            bucket: string
            rootPath: string
        labels:
            string: string
        location: string
        mysqlProfile:
            hostname: string
            password: string
            port: 0
            sslConfig:
                caCertificate: string
                caCertificateSet: false
                clientCertificate: string
                clientCertificateSet: false
                clientKey: string
                clientKeySet: false
            username: string
        oracleProfile:
            connectionAttributes:
                string: string
            databaseService: string
            hostname: string
            password: string
            port: 0
            username: string
        postgresqlProfile:
            database: string
            hostname: string
            password: string
            port: 0
            username: string
        privateConnectivity:
            privateConnection: string
        project: string
        sqlServerProfile:
            database: string
            hostname: string
            password: string
            port: 0
            username: string
    

    ConnectionProfile Resource Properties

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

    Inputs

    The ConnectionProfile resource accepts the following input properties:

    ConnectionProfileId string
    The connection profile identifier.
    DisplayName string
    Display name.
    Location string
    The name of the location this connection profile is located in.


    BigqueryProfile ConnectionProfileBigqueryProfile
    BigQuery warehouse profile.
    CreateWithoutValidation bool
    Create the connection profile without validating it.
    ForwardSshConnectivity ConnectionProfileForwardSshConnectivity
    Forward SSH tunnel connectivity. Structure is documented below.
    GcsProfile ConnectionProfileGcsProfile
    Cloud Storage bucket profile. Structure is documented below.
    Labels Dictionary<string, string>
    Labels. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effective_labels for all of the labels present on the resource.
    MysqlProfile ConnectionProfileMysqlProfile
    MySQL database profile. Structure is documented below.
    OracleProfile ConnectionProfileOracleProfile
    Oracle database profile. Structure is documented below.
    PostgresqlProfile ConnectionProfilePostgresqlProfile
    PostgreSQL database profile. Structure is documented below.
    PrivateConnectivity ConnectionProfilePrivateConnectivity
    Private connectivity. Structure is documented below.
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    SqlServerProfile ConnectionProfileSqlServerProfile
    SQL Server database profile. Structure is documented below.
    ConnectionProfileId string
    The connection profile identifier.
    DisplayName string
    Display name.
    Location string
    The name of the location this connection profile is located in.


    BigqueryProfile ConnectionProfileBigqueryProfileArgs
    BigQuery warehouse profile.
    CreateWithoutValidation bool
    Create the connection profile without validating it.
    ForwardSshConnectivity ConnectionProfileForwardSshConnectivityArgs
    Forward SSH tunnel connectivity. Structure is documented below.
    GcsProfile ConnectionProfileGcsProfileArgs
    Cloud Storage bucket profile. Structure is documented below.
    Labels map[string]string
    Labels. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effective_labels for all of the labels present on the resource.
    MysqlProfile ConnectionProfileMysqlProfileArgs
    MySQL database profile. Structure is documented below.
    OracleProfile ConnectionProfileOracleProfileArgs
    Oracle database profile. Structure is documented below.
    PostgresqlProfile ConnectionProfilePostgresqlProfileArgs
    PostgreSQL database profile. Structure is documented below.
    PrivateConnectivity ConnectionProfilePrivateConnectivityArgs
    Private connectivity. Structure is documented below.
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    SqlServerProfile ConnectionProfileSqlServerProfileArgs
    SQL Server database profile. Structure is documented below.
    connectionProfileId String
    The connection profile identifier.
    displayName String
    Display name.
    location String
    The name of the location this connection profile is located in.


    bigqueryProfile ConnectionProfileBigqueryProfile
    BigQuery warehouse profile.
    createWithoutValidation Boolean
    Create the connection profile without validating it.
    forwardSshConnectivity ConnectionProfileForwardSshConnectivity
    Forward SSH tunnel connectivity. Structure is documented below.
    gcsProfile ConnectionProfileGcsProfile
    Cloud Storage bucket profile. Structure is documented below.
    labels Map<String,String>
    Labels. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effective_labels for all of the labels present on the resource.
    mysqlProfile ConnectionProfileMysqlProfile
    MySQL database profile. Structure is documented below.
    oracleProfile ConnectionProfileOracleProfile
    Oracle database profile. Structure is documented below.
    postgresqlProfile ConnectionProfilePostgresqlProfile
    PostgreSQL database profile. Structure is documented below.
    privateConnectivity ConnectionProfilePrivateConnectivity
    Private connectivity. Structure is documented below.
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    sqlServerProfile ConnectionProfileSqlServerProfile
    SQL Server database profile. Structure is documented below.
    connectionProfileId string
    The connection profile identifier.
    displayName string
    Display name.
    location string
    The name of the location this connection profile is located in.


    bigqueryProfile ConnectionProfileBigqueryProfile
    BigQuery warehouse profile.
    createWithoutValidation boolean
    Create the connection profile without validating it.
    forwardSshConnectivity ConnectionProfileForwardSshConnectivity
    Forward SSH tunnel connectivity. Structure is documented below.
    gcsProfile ConnectionProfileGcsProfile
    Cloud Storage bucket profile. Structure is documented below.
    labels {[key: string]: string}
    Labels. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effective_labels for all of the labels present on the resource.
    mysqlProfile ConnectionProfileMysqlProfile
    MySQL database profile. Structure is documented below.
    oracleProfile ConnectionProfileOracleProfile
    Oracle database profile. Structure is documented below.
    postgresqlProfile ConnectionProfilePostgresqlProfile
    PostgreSQL database profile. Structure is documented below.
    privateConnectivity ConnectionProfilePrivateConnectivity
    Private connectivity. Structure is documented below.
    project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    sqlServerProfile ConnectionProfileSqlServerProfile
    SQL Server database profile. Structure is documented below.
    connection_profile_id str
    The connection profile identifier.
    display_name str
    Display name.
    location str
    The name of the location this connection profile is located in.


    bigquery_profile ConnectionProfileBigqueryProfileArgs
    BigQuery warehouse profile.
    create_without_validation bool
    Create the connection profile without validating it.
    forward_ssh_connectivity ConnectionProfileForwardSshConnectivityArgs
    Forward SSH tunnel connectivity. Structure is documented below.
    gcs_profile ConnectionProfileGcsProfileArgs
    Cloud Storage bucket profile. Structure is documented below.
    labels Mapping[str, str]
    Labels. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effective_labels for all of the labels present on the resource.
    mysql_profile ConnectionProfileMysqlProfileArgs
    MySQL database profile. Structure is documented below.
    oracle_profile ConnectionProfileOracleProfileArgs
    Oracle database profile. Structure is documented below.
    postgresql_profile ConnectionProfilePostgresqlProfileArgs
    PostgreSQL database profile. Structure is documented below.
    private_connectivity ConnectionProfilePrivateConnectivityArgs
    Private connectivity. Structure is documented below.
    project str
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    sql_server_profile ConnectionProfileSqlServerProfileArgs
    SQL Server database profile. Structure is documented below.
    connectionProfileId String
    The connection profile identifier.
    displayName String
    Display name.
    location String
    The name of the location this connection profile is located in.


    bigqueryProfile Property Map
    BigQuery warehouse profile.
    createWithoutValidation Boolean
    Create the connection profile without validating it.
    forwardSshConnectivity Property Map
    Forward SSH tunnel connectivity. Structure is documented below.
    gcsProfile Property Map
    Cloud Storage bucket profile. Structure is documented below.
    labels Map<String>
    Labels. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effective_labels for all of the labels present on the resource.
    mysqlProfile Property Map
    MySQL database profile. Structure is documented below.
    oracleProfile Property Map
    Oracle database profile. Structure is documented below.
    postgresqlProfile Property Map
    PostgreSQL database profile. Structure is documented below.
    privateConnectivity Property Map
    Private connectivity. Structure is documented below.
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    sqlServerProfile Property Map
    SQL Server database profile. Structure is documented below.

    Outputs

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

    EffectiveLabels Dictionary<string, string>
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    Id string
    The provider-assigned unique ID for this managed resource.
    Name string
    The resource's name.
    PulumiLabels Dictionary<string, string>
    The combination of labels configured directly on the resource and default labels configured on the provider.
    EffectiveLabels map[string]string
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    Id string
    The provider-assigned unique ID for this managed resource.
    Name string
    The resource's name.
    PulumiLabels map[string]string
    The combination of labels configured directly on the resource and default labels configured on the provider.
    effectiveLabels Map<String,String>
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    id String
    The provider-assigned unique ID for this managed resource.
    name String
    The resource's name.
    pulumiLabels Map<String,String>
    The combination of labels configured directly on the resource and default labels configured on the provider.
    effectiveLabels {[key: string]: string}
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    id string
    The provider-assigned unique ID for this managed resource.
    name string
    The resource's name.
    pulumiLabels {[key: string]: string}
    The combination of labels configured directly on the resource and default labels configured on the provider.
    effective_labels Mapping[str, str]
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    id str
    The provider-assigned unique ID for this managed resource.
    name str
    The resource's name.
    pulumi_labels Mapping[str, str]
    The combination of labels configured directly on the resource and default labels configured on the provider.
    effectiveLabels Map<String>
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    id String
    The provider-assigned unique ID for this managed resource.
    name String
    The resource's name.
    pulumiLabels Map<String>
    The combination of labels configured directly on the resource and default labels configured on the provider.

    Look up Existing ConnectionProfile Resource

    Get an existing ConnectionProfile resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: ConnectionProfileState, opts?: CustomResourceOptions): ConnectionProfile
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            bigquery_profile: Optional[ConnectionProfileBigqueryProfileArgs] = None,
            connection_profile_id: Optional[str] = None,
            create_without_validation: Optional[bool] = None,
            display_name: Optional[str] = None,
            effective_labels: Optional[Mapping[str, str]] = None,
            forward_ssh_connectivity: Optional[ConnectionProfileForwardSshConnectivityArgs] = None,
            gcs_profile: Optional[ConnectionProfileGcsProfileArgs] = None,
            labels: Optional[Mapping[str, str]] = None,
            location: Optional[str] = None,
            mysql_profile: Optional[ConnectionProfileMysqlProfileArgs] = None,
            name: Optional[str] = None,
            oracle_profile: Optional[ConnectionProfileOracleProfileArgs] = None,
            postgresql_profile: Optional[ConnectionProfilePostgresqlProfileArgs] = None,
            private_connectivity: Optional[ConnectionProfilePrivateConnectivityArgs] = None,
            project: Optional[str] = None,
            pulumi_labels: Optional[Mapping[str, str]] = None,
            sql_server_profile: Optional[ConnectionProfileSqlServerProfileArgs] = None) -> ConnectionProfile
    func GetConnectionProfile(ctx *Context, name string, id IDInput, state *ConnectionProfileState, opts ...ResourceOption) (*ConnectionProfile, error)
    public static ConnectionProfile Get(string name, Input<string> id, ConnectionProfileState? state, CustomResourceOptions? opts = null)
    public static ConnectionProfile get(String name, Output<String> id, ConnectionProfileState state, CustomResourceOptions options)
    Resource lookup is not supported in YAML
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    BigqueryProfile ConnectionProfileBigqueryProfile
    BigQuery warehouse profile.
    ConnectionProfileId string
    The connection profile identifier.
    CreateWithoutValidation bool
    Create the connection profile without validating it.
    DisplayName string
    Display name.
    EffectiveLabels Dictionary<string, string>
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    ForwardSshConnectivity ConnectionProfileForwardSshConnectivity
    Forward SSH tunnel connectivity. Structure is documented below.
    GcsProfile ConnectionProfileGcsProfile
    Cloud Storage bucket profile. Structure is documented below.
    Labels Dictionary<string, string>
    Labels. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effective_labels for all of the labels present on the resource.
    Location string
    The name of the location this connection profile is located in.


    MysqlProfile ConnectionProfileMysqlProfile
    MySQL database profile. Structure is documented below.
    Name string
    The resource's name.
    OracleProfile ConnectionProfileOracleProfile
    Oracle database profile. Structure is documented below.
    PostgresqlProfile ConnectionProfilePostgresqlProfile
    PostgreSQL database profile. Structure is documented below.
    PrivateConnectivity ConnectionProfilePrivateConnectivity
    Private connectivity. Structure is documented below.
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    PulumiLabels Dictionary<string, string>
    The combination of labels configured directly on the resource and default labels configured on the provider.
    SqlServerProfile ConnectionProfileSqlServerProfile
    SQL Server database profile. Structure is documented below.
    BigqueryProfile ConnectionProfileBigqueryProfileArgs
    BigQuery warehouse profile.
    ConnectionProfileId string
    The connection profile identifier.
    CreateWithoutValidation bool
    Create the connection profile without validating it.
    DisplayName string
    Display name.
    EffectiveLabels map[string]string
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    ForwardSshConnectivity ConnectionProfileForwardSshConnectivityArgs
    Forward SSH tunnel connectivity. Structure is documented below.
    GcsProfile ConnectionProfileGcsProfileArgs
    Cloud Storage bucket profile. Structure is documented below.
    Labels map[string]string
    Labels. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effective_labels for all of the labels present on the resource.
    Location string
    The name of the location this connection profile is located in.


    MysqlProfile ConnectionProfileMysqlProfileArgs
    MySQL database profile. Structure is documented below.
    Name string
    The resource's name.
    OracleProfile ConnectionProfileOracleProfileArgs
    Oracle database profile. Structure is documented below.
    PostgresqlProfile ConnectionProfilePostgresqlProfileArgs
    PostgreSQL database profile. Structure is documented below.
    PrivateConnectivity ConnectionProfilePrivateConnectivityArgs
    Private connectivity. Structure is documented below.
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    PulumiLabels map[string]string
    The combination of labels configured directly on the resource and default labels configured on the provider.
    SqlServerProfile ConnectionProfileSqlServerProfileArgs
    SQL Server database profile. Structure is documented below.
    bigqueryProfile ConnectionProfileBigqueryProfile
    BigQuery warehouse profile.
    connectionProfileId String
    The connection profile identifier.
    createWithoutValidation Boolean
    Create the connection profile without validating it.
    displayName String
    Display name.
    effectiveLabels Map<String,String>
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    forwardSshConnectivity ConnectionProfileForwardSshConnectivity
    Forward SSH tunnel connectivity. Structure is documented below.
    gcsProfile ConnectionProfileGcsProfile
    Cloud Storage bucket profile. Structure is documented below.
    labels Map<String,String>
    Labels. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effective_labels for all of the labels present on the resource.
    location String
    The name of the location this connection profile is located in.


    mysqlProfile ConnectionProfileMysqlProfile
    MySQL database profile. Structure is documented below.
    name String
    The resource's name.
    oracleProfile ConnectionProfileOracleProfile
    Oracle database profile. Structure is documented below.
    postgresqlProfile ConnectionProfilePostgresqlProfile
    PostgreSQL database profile. Structure is documented below.
    privateConnectivity ConnectionProfilePrivateConnectivity
    Private connectivity. Structure is documented below.
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    pulumiLabels Map<String,String>
    The combination of labels configured directly on the resource and default labels configured on the provider.
    sqlServerProfile ConnectionProfileSqlServerProfile
    SQL Server database profile. Structure is documented below.
    bigqueryProfile ConnectionProfileBigqueryProfile
    BigQuery warehouse profile.
    connectionProfileId string
    The connection profile identifier.
    createWithoutValidation boolean
    Create the connection profile without validating it.
    displayName string
    Display name.
    effectiveLabels {[key: string]: string}
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    forwardSshConnectivity ConnectionProfileForwardSshConnectivity
    Forward SSH tunnel connectivity. Structure is documented below.
    gcsProfile ConnectionProfileGcsProfile
    Cloud Storage bucket profile. Structure is documented below.
    labels {[key: string]: string}
    Labels. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effective_labels for all of the labels present on the resource.
    location string
    The name of the location this connection profile is located in.


    mysqlProfile ConnectionProfileMysqlProfile
    MySQL database profile. Structure is documented below.
    name string
    The resource's name.
    oracleProfile ConnectionProfileOracleProfile
    Oracle database profile. Structure is documented below.
    postgresqlProfile ConnectionProfilePostgresqlProfile
    PostgreSQL database profile. Structure is documented below.
    privateConnectivity ConnectionProfilePrivateConnectivity
    Private connectivity. Structure is documented below.
    project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    pulumiLabels {[key: string]: string}
    The combination of labels configured directly on the resource and default labels configured on the provider.
    sqlServerProfile ConnectionProfileSqlServerProfile
    SQL Server database profile. Structure is documented below.
    bigquery_profile ConnectionProfileBigqueryProfileArgs
    BigQuery warehouse profile.
    connection_profile_id str
    The connection profile identifier.
    create_without_validation bool
    Create the connection profile without validating it.
    display_name str
    Display name.
    effective_labels Mapping[str, str]
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    forward_ssh_connectivity ConnectionProfileForwardSshConnectivityArgs
    Forward SSH tunnel connectivity. Structure is documented below.
    gcs_profile ConnectionProfileGcsProfileArgs
    Cloud Storage bucket profile. Structure is documented below.
    labels Mapping[str, str]
    Labels. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effective_labels for all of the labels present on the resource.
    location str
    The name of the location this connection profile is located in.


    mysql_profile ConnectionProfileMysqlProfileArgs
    MySQL database profile. Structure is documented below.
    name str
    The resource's name.
    oracle_profile ConnectionProfileOracleProfileArgs
    Oracle database profile. Structure is documented below.
    postgresql_profile ConnectionProfilePostgresqlProfileArgs
    PostgreSQL database profile. Structure is documented below.
    private_connectivity ConnectionProfilePrivateConnectivityArgs
    Private connectivity. Structure is documented below.
    project str
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    pulumi_labels Mapping[str, str]
    The combination of labels configured directly on the resource and default labels configured on the provider.
    sql_server_profile ConnectionProfileSqlServerProfileArgs
    SQL Server database profile. Structure is documented below.
    bigqueryProfile Property Map
    BigQuery warehouse profile.
    connectionProfileId String
    The connection profile identifier.
    createWithoutValidation Boolean
    Create the connection profile without validating it.
    displayName String
    Display name.
    effectiveLabels Map<String>
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    forwardSshConnectivity Property Map
    Forward SSH tunnel connectivity. Structure is documented below.
    gcsProfile Property Map
    Cloud Storage bucket profile. Structure is documented below.
    labels Map<String>
    Labels. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effective_labels for all of the labels present on the resource.
    location String
    The name of the location this connection profile is located in.


    mysqlProfile Property Map
    MySQL database profile. Structure is documented below.
    name String
    The resource's name.
    oracleProfile Property Map
    Oracle database profile. Structure is documented below.
    postgresqlProfile Property Map
    PostgreSQL database profile. Structure is documented below.
    privateConnectivity Property Map
    Private connectivity. Structure is documented below.
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    pulumiLabels Map<String>
    The combination of labels configured directly on the resource and default labels configured on the provider.
    sqlServerProfile Property Map
    SQL Server database profile. Structure is documented below.

    Supporting Types

    ConnectionProfileForwardSshConnectivity, ConnectionProfileForwardSshConnectivityArgs

    Hostname string
    Hostname for the SSH tunnel.
    Username string
    Username for the SSH tunnel.
    Password string
    SSH password. Note: This property is sensitive and will not be displayed in the plan.
    Port int
    Port for the SSH tunnel.
    PrivateKey string
    SSH private key. Note: This property is sensitive and will not be displayed in the plan.
    Hostname string
    Hostname for the SSH tunnel.
    Username string
    Username for the SSH tunnel.
    Password string
    SSH password. Note: This property is sensitive and will not be displayed in the plan.
    Port int
    Port for the SSH tunnel.
    PrivateKey string
    SSH private key. Note: This property is sensitive and will not be displayed in the plan.
    hostname String
    Hostname for the SSH tunnel.
    username String
    Username for the SSH tunnel.
    password String
    SSH password. Note: This property is sensitive and will not be displayed in the plan.
    port Integer
    Port for the SSH tunnel.
    privateKey String
    SSH private key. Note: This property is sensitive and will not be displayed in the plan.
    hostname string
    Hostname for the SSH tunnel.
    username string
    Username for the SSH tunnel.
    password string
    SSH password. Note: This property is sensitive and will not be displayed in the plan.
    port number
    Port for the SSH tunnel.
    privateKey string
    SSH private key. Note: This property is sensitive and will not be displayed in the plan.
    hostname str
    Hostname for the SSH tunnel.
    username str
    Username for the SSH tunnel.
    password str
    SSH password. Note: This property is sensitive and will not be displayed in the plan.
    port int
    Port for the SSH tunnel.
    private_key str
    SSH private key. Note: This property is sensitive and will not be displayed in the plan.
    hostname String
    Hostname for the SSH tunnel.
    username String
    Username for the SSH tunnel.
    password String
    SSH password. Note: This property is sensitive and will not be displayed in the plan.
    port Number
    Port for the SSH tunnel.
    privateKey String
    SSH private key. Note: This property is sensitive and will not be displayed in the plan.

    ConnectionProfileGcsProfile, ConnectionProfileGcsProfileArgs

    Bucket string
    The Cloud Storage bucket name.
    RootPath string
    The root path inside the Cloud Storage bucket.
    Bucket string
    The Cloud Storage bucket name.
    RootPath string
    The root path inside the Cloud Storage bucket.
    bucket String
    The Cloud Storage bucket name.
    rootPath String
    The root path inside the Cloud Storage bucket.
    bucket string
    The Cloud Storage bucket name.
    rootPath string
    The root path inside the Cloud Storage bucket.
    bucket str
    The Cloud Storage bucket name.
    root_path str
    The root path inside the Cloud Storage bucket.
    bucket String
    The Cloud Storage bucket name.
    rootPath String
    The root path inside the Cloud Storage bucket.

    ConnectionProfileMysqlProfile, ConnectionProfileMysqlProfileArgs

    Hostname string
    Hostname for the MySQL connection.
    Password string
    Password for the MySQL connection. Note: This property is sensitive and will not be displayed in the plan.
    Username string
    Username for the MySQL connection.
    Port int
    Port for the MySQL connection.
    SslConfig ConnectionProfileMysqlProfileSslConfig
    SSL configuration for the MySQL connection. Structure is documented below.
    Hostname string
    Hostname for the MySQL connection.
    Password string
    Password for the MySQL connection. Note: This property is sensitive and will not be displayed in the plan.
    Username string
    Username for the MySQL connection.
    Port int
    Port for the MySQL connection.
    SslConfig ConnectionProfileMysqlProfileSslConfig
    SSL configuration for the MySQL connection. Structure is documented below.
    hostname String
    Hostname for the MySQL connection.
    password String
    Password for the MySQL connection. Note: This property is sensitive and will not be displayed in the plan.
    username String
    Username for the MySQL connection.
    port Integer
    Port for the MySQL connection.
    sslConfig ConnectionProfileMysqlProfileSslConfig
    SSL configuration for the MySQL connection. Structure is documented below.
    hostname string
    Hostname for the MySQL connection.
    password string
    Password for the MySQL connection. Note: This property is sensitive and will not be displayed in the plan.
    username string
    Username for the MySQL connection.
    port number
    Port for the MySQL connection.
    sslConfig ConnectionProfileMysqlProfileSslConfig
    SSL configuration for the MySQL connection. Structure is documented below.
    hostname str
    Hostname for the MySQL connection.
    password str
    Password for the MySQL connection. Note: This property is sensitive and will not be displayed in the plan.
    username str
    Username for the MySQL connection.
    port int
    Port for the MySQL connection.
    ssl_config ConnectionProfileMysqlProfileSslConfig
    SSL configuration for the MySQL connection. Structure is documented below.
    hostname String
    Hostname for the MySQL connection.
    password String
    Password for the MySQL connection. Note: This property is sensitive and will not be displayed in the plan.
    username String
    Username for the MySQL connection.
    port Number
    Port for the MySQL connection.
    sslConfig Property Map
    SSL configuration for the MySQL connection. Structure is documented below.

    ConnectionProfileMysqlProfileSslConfig, ConnectionProfileMysqlProfileSslConfigArgs

    CaCertificate string
    PEM-encoded certificate of the CA that signed the source database server's certificate. Note: This property is sensitive and will not be displayed in the plan.
    CaCertificateSet bool
    (Output) Indicates whether the clientKey field is set.
    ClientCertificate string
    PEM-encoded certificate that will be used by the replica to authenticate against the source database server. If this field is used then the 'clientKey' and the 'caCertificate' fields are mandatory. Note: This property is sensitive and will not be displayed in the plan.
    ClientCertificateSet bool
    (Output) Indicates whether the clientCertificate field is set.
    ClientKey string
    PEM-encoded private key associated with the Client Certificate. If this field is used then the 'client_certificate' and the 'ca_certificate' fields are mandatory. Note: This property is sensitive and will not be displayed in the plan.
    ClientKeySet bool
    (Output) Indicates whether the clientKey field is set.
    CaCertificate string
    PEM-encoded certificate of the CA that signed the source database server's certificate. Note: This property is sensitive and will not be displayed in the plan.
    CaCertificateSet bool
    (Output) Indicates whether the clientKey field is set.
    ClientCertificate string
    PEM-encoded certificate that will be used by the replica to authenticate against the source database server. If this field is used then the 'clientKey' and the 'caCertificate' fields are mandatory. Note: This property is sensitive and will not be displayed in the plan.
    ClientCertificateSet bool
    (Output) Indicates whether the clientCertificate field is set.
    ClientKey string
    PEM-encoded private key associated with the Client Certificate. If this field is used then the 'client_certificate' and the 'ca_certificate' fields are mandatory. Note: This property is sensitive and will not be displayed in the plan.
    ClientKeySet bool
    (Output) Indicates whether the clientKey field is set.
    caCertificate String
    PEM-encoded certificate of the CA that signed the source database server's certificate. Note: This property is sensitive and will not be displayed in the plan.
    caCertificateSet Boolean
    (Output) Indicates whether the clientKey field is set.
    clientCertificate String
    PEM-encoded certificate that will be used by the replica to authenticate against the source database server. If this field is used then the 'clientKey' and the 'caCertificate' fields are mandatory. Note: This property is sensitive and will not be displayed in the plan.
    clientCertificateSet Boolean
    (Output) Indicates whether the clientCertificate field is set.
    clientKey String
    PEM-encoded private key associated with the Client Certificate. If this field is used then the 'client_certificate' and the 'ca_certificate' fields are mandatory. Note: This property is sensitive and will not be displayed in the plan.
    clientKeySet Boolean
    (Output) Indicates whether the clientKey field is set.
    caCertificate string
    PEM-encoded certificate of the CA that signed the source database server's certificate. Note: This property is sensitive and will not be displayed in the plan.
    caCertificateSet boolean
    (Output) Indicates whether the clientKey field is set.
    clientCertificate string
    PEM-encoded certificate that will be used by the replica to authenticate against the source database server. If this field is used then the 'clientKey' and the 'caCertificate' fields are mandatory. Note: This property is sensitive and will not be displayed in the plan.
    clientCertificateSet boolean
    (Output) Indicates whether the clientCertificate field is set.
    clientKey string
    PEM-encoded private key associated with the Client Certificate. If this field is used then the 'client_certificate' and the 'ca_certificate' fields are mandatory. Note: This property is sensitive and will not be displayed in the plan.
    clientKeySet boolean
    (Output) Indicates whether the clientKey field is set.
    ca_certificate str
    PEM-encoded certificate of the CA that signed the source database server's certificate. Note: This property is sensitive and will not be displayed in the plan.
    ca_certificate_set bool
    (Output) Indicates whether the clientKey field is set.
    client_certificate str
    PEM-encoded certificate that will be used by the replica to authenticate against the source database server. If this field is used then the 'clientKey' and the 'caCertificate' fields are mandatory. Note: This property is sensitive and will not be displayed in the plan.
    client_certificate_set bool
    (Output) Indicates whether the clientCertificate field is set.
    client_key str
    PEM-encoded private key associated with the Client Certificate. If this field is used then the 'client_certificate' and the 'ca_certificate' fields are mandatory. Note: This property is sensitive and will not be displayed in the plan.
    client_key_set bool
    (Output) Indicates whether the clientKey field is set.
    caCertificate String
    PEM-encoded certificate of the CA that signed the source database server's certificate. Note: This property is sensitive and will not be displayed in the plan.
    caCertificateSet Boolean
    (Output) Indicates whether the clientKey field is set.
    clientCertificate String
    PEM-encoded certificate that will be used by the replica to authenticate against the source database server. If this field is used then the 'clientKey' and the 'caCertificate' fields are mandatory. Note: This property is sensitive and will not be displayed in the plan.
    clientCertificateSet Boolean
    (Output) Indicates whether the clientCertificate field is set.
    clientKey String
    PEM-encoded private key associated with the Client Certificate. If this field is used then the 'client_certificate' and the 'ca_certificate' fields are mandatory. Note: This property is sensitive and will not be displayed in the plan.
    clientKeySet Boolean
    (Output) Indicates whether the clientKey field is set.

    ConnectionProfileOracleProfile, ConnectionProfileOracleProfileArgs

    DatabaseService string
    Database for the Oracle connection.
    Hostname string
    Hostname for the Oracle connection.
    Password string
    Password for the Oracle connection. Note: This property is sensitive and will not be displayed in the plan.
    Username string
    Username for the Oracle connection.
    ConnectionAttributes Dictionary<string, string>
    Connection string attributes
    Port int
    Port for the Oracle connection.
    DatabaseService string
    Database for the Oracle connection.
    Hostname string
    Hostname for the Oracle connection.
    Password string
    Password for the Oracle connection. Note: This property is sensitive and will not be displayed in the plan.
    Username string
    Username for the Oracle connection.
    ConnectionAttributes map[string]string
    Connection string attributes
    Port int
    Port for the Oracle connection.
    databaseService String
    Database for the Oracle connection.
    hostname String
    Hostname for the Oracle connection.
    password String
    Password for the Oracle connection. Note: This property is sensitive and will not be displayed in the plan.
    username String
    Username for the Oracle connection.
    connectionAttributes Map<String,String>
    Connection string attributes
    port Integer
    Port for the Oracle connection.
    databaseService string
    Database for the Oracle connection.
    hostname string
    Hostname for the Oracle connection.
    password string
    Password for the Oracle connection. Note: This property is sensitive and will not be displayed in the plan.
    username string
    Username for the Oracle connection.
    connectionAttributes {[key: string]: string}
    Connection string attributes
    port number
    Port for the Oracle connection.
    database_service str
    Database for the Oracle connection.
    hostname str
    Hostname for the Oracle connection.
    password str
    Password for the Oracle connection. Note: This property is sensitive and will not be displayed in the plan.
    username str
    Username for the Oracle connection.
    connection_attributes Mapping[str, str]
    Connection string attributes
    port int
    Port for the Oracle connection.
    databaseService String
    Database for the Oracle connection.
    hostname String
    Hostname for the Oracle connection.
    password String
    Password for the Oracle connection. Note: This property is sensitive and will not be displayed in the plan.
    username String
    Username for the Oracle connection.
    connectionAttributes Map<String>
    Connection string attributes
    port Number
    Port for the Oracle connection.

    ConnectionProfilePostgresqlProfile, ConnectionProfilePostgresqlProfileArgs

    Database string
    Database for the PostgreSQL connection.
    Hostname string
    Hostname for the PostgreSQL connection.
    Password string
    Password for the PostgreSQL connection. Note: This property is sensitive and will not be displayed in the plan.
    Username string
    Username for the PostgreSQL connection.
    Port int
    Port for the PostgreSQL connection.
    Database string
    Database for the PostgreSQL connection.
    Hostname string
    Hostname for the PostgreSQL connection.
    Password string
    Password for the PostgreSQL connection. Note: This property is sensitive and will not be displayed in the plan.
    Username string
    Username for the PostgreSQL connection.
    Port int
    Port for the PostgreSQL connection.
    database String
    Database for the PostgreSQL connection.
    hostname String
    Hostname for the PostgreSQL connection.
    password String
    Password for the PostgreSQL connection. Note: This property is sensitive and will not be displayed in the plan.
    username String
    Username for the PostgreSQL connection.
    port Integer
    Port for the PostgreSQL connection.
    database string
    Database for the PostgreSQL connection.
    hostname string
    Hostname for the PostgreSQL connection.
    password string
    Password for the PostgreSQL connection. Note: This property is sensitive and will not be displayed in the plan.
    username string
    Username for the PostgreSQL connection.
    port number
    Port for the PostgreSQL connection.
    database str
    Database for the PostgreSQL connection.
    hostname str
    Hostname for the PostgreSQL connection.
    password str
    Password for the PostgreSQL connection. Note: This property is sensitive and will not be displayed in the plan.
    username str
    Username for the PostgreSQL connection.
    port int
    Port for the PostgreSQL connection.
    database String
    Database for the PostgreSQL connection.
    hostname String
    Hostname for the PostgreSQL connection.
    password String
    Password for the PostgreSQL connection. Note: This property is sensitive and will not be displayed in the plan.
    username String
    Username for the PostgreSQL connection.
    port Number
    Port for the PostgreSQL connection.

    ConnectionProfilePrivateConnectivity, ConnectionProfilePrivateConnectivityArgs

    PrivateConnection string
    A reference to a private connection resource. Format: projects/{project}/locations/{location}/privateConnections/{name}
    PrivateConnection string
    A reference to a private connection resource. Format: projects/{project}/locations/{location}/privateConnections/{name}
    privateConnection String
    A reference to a private connection resource. Format: projects/{project}/locations/{location}/privateConnections/{name}
    privateConnection string
    A reference to a private connection resource. Format: projects/{project}/locations/{location}/privateConnections/{name}
    private_connection str
    A reference to a private connection resource. Format: projects/{project}/locations/{location}/privateConnections/{name}
    privateConnection String
    A reference to a private connection resource. Format: projects/{project}/locations/{location}/privateConnections/{name}

    ConnectionProfileSqlServerProfile, ConnectionProfileSqlServerProfileArgs

    Database string
    Database for the SQL Server connection.
    Hostname string
    Hostname for the SQL Server connection.
    Password string
    Password for the SQL Server connection. Note: This property is sensitive and will not be displayed in the plan.
    Username string
    Username for the SQL Server connection.
    Port int
    Port for the SQL Server connection.
    Database string
    Database for the SQL Server connection.
    Hostname string
    Hostname for the SQL Server connection.
    Password string
    Password for the SQL Server connection. Note: This property is sensitive and will not be displayed in the plan.
    Username string
    Username for the SQL Server connection.
    Port int
    Port for the SQL Server connection.
    database String
    Database for the SQL Server connection.
    hostname String
    Hostname for the SQL Server connection.
    password String
    Password for the SQL Server connection. Note: This property is sensitive and will not be displayed in the plan.
    username String
    Username for the SQL Server connection.
    port Integer
    Port for the SQL Server connection.
    database string
    Database for the SQL Server connection.
    hostname string
    Hostname for the SQL Server connection.
    password string
    Password for the SQL Server connection. Note: This property is sensitive and will not be displayed in the plan.
    username string
    Username for the SQL Server connection.
    port number
    Port for the SQL Server connection.
    database str
    Database for the SQL Server connection.
    hostname str
    Hostname for the SQL Server connection.
    password str
    Password for the SQL Server connection. Note: This property is sensitive and will not be displayed in the plan.
    username str
    Username for the SQL Server connection.
    port int
    Port for the SQL Server connection.
    database String
    Database for the SQL Server connection.
    hostname String
    Hostname for the SQL Server connection.
    password String
    Password for the SQL Server connection. Note: This property is sensitive and will not be displayed in the plan.
    username String
    Username for the SQL Server connection.
    port Number
    Port for the SQL Server connection.

    Import

    ConnectionProfile can be imported using any of these accepted formats:

    • projects/{{project}}/locations/{{location}}/connectionProfiles/{{connection_profile_id}}

    • {{project}}/{{location}}/{{connection_profile_id}}

    • {{location}}/{{connection_profile_id}}

    When using the pulumi import command, ConnectionProfile can be imported using one of the formats above. For example:

    $ pulumi import gcp:datastream/connectionProfile:ConnectionProfile default projects/{{project}}/locations/{{location}}/connectionProfiles/{{connection_profile_id}}
    
    $ pulumi import gcp:datastream/connectionProfile:ConnectionProfile default {{project}}/{{location}}/{{connection_profile_id}}
    
    $ pulumi import gcp:datastream/connectionProfile:ConnectionProfile default {{location}}/{{connection_profile_id}}
    

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    Google Cloud (GCP) Classic pulumi/pulumi-gcp
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the google-beta Terraform Provider.
    gcp logo
    Google Cloud Classic v7.27.0 published on Thursday, Jun 13, 2024 by Pulumi