gcp.datastream.ConnectionProfile
Explore with Pulumi AI
A set of reusable connection configurations to be used as a source or destination for a stream.
To get more information about ConnectionProfile, see:
- API documentation
 - How-to Guides
 
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={
        "bucket": "my-bucket",
        "root_path": "/path",
    })
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/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={
        "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={
        "tier": "db-f1-micro",
        "ip_configuration": {
            "authorized_networks": [
                {
                    "value": "34.71.242.81",
                },
                {
                    "value": "34.72.28.29",
                },
                {
                    "value": "34.67.6.157",
                },
                {
                    "value": "34.67.234.134",
                },
                {
                    "value": "34.72.239.218",
                },
            ],
        },
    },
    deletion_protection=True)
db = gcp.sql.Database("db",
    instance=instance.name,
    name="db")
pwd = random.RandomPassword("pwd",
    length=16,
    special=False)
user = gcp.sql.User("user",
    name="user",
    instance=instance.name,
    password=pwd.result)
default_connection_profile = gcp.datastream.ConnectionProfile("default",
    display_name="Connection profile",
    location="us-central1",
    connection_profile_id="my-profile",
    postgresql_profile={
        "hostname": instance.public_ip_address,
        "username": user.name,
        "password": user.password,
        "database": db.name,
    },
    private_connectivity={
        "private_connection": private_connection.id,
    })
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/datastream"
	"github.com/pulumi/pulumi-gcp/sdk/v8/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={
        "bucket": "my-bucket",
        "root_path": "/path",
    },
    forward_ssh_connectivity={
        "hostname": "google.com",
        "username": "my-user",
        "port": 8022,
        "password": "swordfish",
    },
    labels={
        "key": "value",
    })
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/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={
        "tier": "db-f1-micro",
        "ip_configuration": {
            "authorized_networks": [
                {
                    "value": "34.71.242.81",
                },
                {
                    "value": "34.72.28.29",
                },
                {
                    "value": "34.67.6.157",
                },
                {
                    "value": "34.67.234.134",
                },
                {
                    "value": "34.72.239.218",
                },
            ],
        },
    },
    deletion_protection=True)
db = gcp.sql.Database("db",
    instance=instance.name,
    name="db")
pwd = random.RandomPassword("pwd",
    length=16,
    special=False)
user = gcp.sql.User("user",
    name="user",
    instance=instance.name,
    password=pwd.result)
default = gcp.datastream.ConnectionProfile("default",
    display_name="Connection profile",
    location="us-central1",
    connection_profile_id="my-profile",
    postgresql_profile={
        "hostname": instance.public_ip_address,
        "username": user.name,
        "password": user.password,
        "database": db.name,
    })
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/datastream"
	"github.com/pulumi/pulumi-gcp/sdk/v8/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={
        "tier": "db-custom-2-4096",
        "ip_configuration": {
            "authorized_networks": [
                {
                    "value": "34.71.242.81",
                },
                {
                    "value": "34.72.28.29",
                },
                {
                    "value": "34.67.6.157",
                },
                {
                    "value": "34.67.234.134",
                },
                {
                    "value": "34.72.239.218",
                },
            ],
        },
    })
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={
        "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/v8/go/gcp/datastream"
	"github.com/pulumi/pulumi-gcp/sdk/v8/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.
 
Constructor 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:         &datastream.ConnectionProfileBigqueryProfileArgs{},
	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={
        "hostname": "string",
        "username": "string",
        "password": "string",
        "port": 0,
        "private_key": "string",
    },
    gcs_profile={
        "bucket": "string",
        "root_path": "string",
    },
    bigquery_profile={},
    create_without_validation=False,
    mysql_profile={
        "hostname": "string",
        "password": "string",
        "username": "string",
        "port": 0,
        "ssl_config": {
            "ca_certificate": "string",
            "ca_certificate_set": False,
            "client_certificate": "string",
            "client_certificate_set": False,
            "client_key": "string",
            "client_key_set": False,
        },
    },
    oracle_profile={
        "database_service": "string",
        "hostname": "string",
        "password": "string",
        "username": "string",
        "connection_attributes": {
            "string": "string",
        },
        "port": 0,
    },
    postgresql_profile={
        "database": "string",
        "hostname": "string",
        "password": "string",
        "username": "string",
        "port": 0,
    },
    private_connectivity={
        "private_connection": "string",
    },
    project="string",
    sql_server_profile={
        "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
In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.
The ConnectionProfile resource accepts the following input properties:
- Connection
Profile stringId  - The connection profile identifier.
 - Display
Name string - Display name.
 - Location string
 - The name of the location this connection profile is located in.
 - Bigquery
Profile ConnectionProfile Bigquery Profile  - BigQuery warehouse profile.
 - Create
Without boolValidation  - Create the connection profile without validating it.
 - Forward
Ssh ConnectionConnectivity Profile Forward Ssh Connectivity  - Forward SSH tunnel connectivity. Structure is documented below.
 - Gcs
Profile ConnectionProfile Gcs Profile  - 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_labelsfor all of the labels present on the resource. - Mysql
Profile ConnectionProfile Mysql Profile  - MySQL database profile. Structure is documented below.
 - Oracle
Profile ConnectionProfile Oracle Profile  - Oracle database profile. Structure is documented below.
 - Postgresql
Profile ConnectionProfile Postgresql Profile  - PostgreSQL database profile. Structure is documented below.
 - Private
Connectivity ConnectionProfile Private Connectivity  - 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.
 - Sql
Server ConnectionProfile Profile Sql Server Profile  - SQL Server database profile. Structure is documented below.
 
- Connection
Profile stringId  - The connection profile identifier.
 - Display
Name string - Display name.
 - Location string
 - The name of the location this connection profile is located in.
 - Bigquery
Profile ConnectionProfile Bigquery Profile Args  - BigQuery warehouse profile.
 - Create
Without boolValidation  - Create the connection profile without validating it.
 - Forward
Ssh ConnectionConnectivity Profile Forward Ssh Connectivity Args  - Forward SSH tunnel connectivity. Structure is documented below.
 - Gcs
Profile ConnectionProfile Gcs Profile Args  - 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_labelsfor all of the labels present on the resource. - Mysql
Profile ConnectionProfile Mysql Profile Args  - MySQL database profile. Structure is documented below.
 - Oracle
Profile ConnectionProfile Oracle Profile Args  - Oracle database profile. Structure is documented below.
 - Postgresql
Profile ConnectionProfile Postgresql Profile Args  - PostgreSQL database profile. Structure is documented below.
 - Private
Connectivity ConnectionProfile Private Connectivity Args  - 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.
 - Sql
Server ConnectionProfile Profile Sql Server Profile Args  - SQL Server database profile. Structure is documented below.
 
- connection
Profile StringId  - The connection profile identifier.
 - display
Name String - Display name.
 - location String
 - The name of the location this connection profile is located in.
 - bigquery
Profile ConnectionProfile Bigquery Profile  - BigQuery warehouse profile.
 - create
Without BooleanValidation  - Create the connection profile without validating it.
 - forward
Ssh ConnectionConnectivity Profile Forward Ssh Connectivity  - Forward SSH tunnel connectivity. Structure is documented below.
 - gcs
Profile ConnectionProfile Gcs Profile  - 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_labelsfor all of the labels present on the resource. - mysql
Profile ConnectionProfile Mysql Profile  - MySQL database profile. Structure is documented below.
 - oracle
Profile ConnectionProfile Oracle Profile  - Oracle database profile. Structure is documented below.
 - postgresql
Profile ConnectionProfile Postgresql Profile  - PostgreSQL database profile. Structure is documented below.
 - private
Connectivity ConnectionProfile Private Connectivity  - 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.
 - sql
Server ConnectionProfile Profile Sql Server Profile  - SQL Server database profile. Structure is documented below.
 
- connection
Profile stringId  - The connection profile identifier.
 - display
Name string - Display name.
 - location string
 - The name of the location this connection profile is located in.
 - bigquery
Profile ConnectionProfile Bigquery Profile  - BigQuery warehouse profile.
 - create
Without booleanValidation  - Create the connection profile without validating it.
 - forward
Ssh ConnectionConnectivity Profile Forward Ssh Connectivity  - Forward SSH tunnel connectivity. Structure is documented below.
 - gcs
Profile ConnectionProfile Gcs Profile  - 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_labelsfor all of the labels present on the resource. - mysql
Profile ConnectionProfile Mysql Profile  - MySQL database profile. Structure is documented below.
 - oracle
Profile ConnectionProfile Oracle Profile  - Oracle database profile. Structure is documented below.
 - postgresql
Profile ConnectionProfile Postgresql Profile  - PostgreSQL database profile. Structure is documented below.
 - private
Connectivity ConnectionProfile Private Connectivity  - 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.
 - sql
Server ConnectionProfile Profile Sql Server Profile  - SQL Server database profile. Structure is documented below.
 
- connection_
profile_ strid  - The connection profile identifier.
 - display_
name str - Display name.
 - location str
 - The name of the location this connection profile is located in.
 - bigquery_
profile ConnectionProfile Bigquery Profile Args  - BigQuery warehouse profile.
 - create_
without_ boolvalidation  - Create the connection profile without validating it.
 - forward_
ssh_ Connectionconnectivity Profile Forward Ssh Connectivity Args  - Forward SSH tunnel connectivity. Structure is documented below.
 - gcs_
profile ConnectionProfile Gcs Profile Args  - 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_labelsfor all of the labels present on the resource. - mysql_
profile ConnectionProfile Mysql Profile Args  - MySQL database profile. Structure is documented below.
 - oracle_
profile ConnectionProfile Oracle Profile Args  - Oracle database profile. Structure is documented below.
 - postgresql_
profile ConnectionProfile Postgresql Profile Args  - PostgreSQL database profile. Structure is documented below.
 - private_
connectivity ConnectionProfile Private Connectivity Args  - 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_ Connectionprofile Profile Sql Server Profile Args  - SQL Server database profile. Structure is documented below.
 
- connection
Profile StringId  - The connection profile identifier.
 - display
Name String - Display name.
 - location String
 - The name of the location this connection profile is located in.
 - bigquery
Profile Property Map - BigQuery warehouse profile.
 - create
Without BooleanValidation  - Create the connection profile without validating it.
 - forward
Ssh Property MapConnectivity  - Forward SSH tunnel connectivity. Structure is documented below.
 - gcs
Profile 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_labelsfor all of the labels present on the resource. - mysql
Profile Property Map - MySQL database profile. Structure is documented below.
 - oracle
Profile Property Map - Oracle database profile. Structure is documented below.
 - postgresql
Profile Property Map - PostgreSQL database profile. Structure is documented below.
 - private
Connectivity 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.
 - sql
Server Property MapProfile  - 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:
- Effective
Labels 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.
 - Pulumi
Labels Dictionary<string, string> - The combination of labels configured directly on the resource and default labels configured on the provider.
 
- Effective
Labels 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.
 - Pulumi
Labels map[string]string - The combination of labels configured directly on the resource and default labels configured on the provider.
 
- effective
Labels 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.
 - pulumi
Labels Map<String,String> - The combination of labels configured directly on the resource and default labels configured on the provider.
 
- effective
Labels {[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.
 - pulumi
Labels {[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.
 
- effective
Labels 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.
 - pulumi
Labels 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) -> ConnectionProfilefunc 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.
 
- Bigquery
Profile ConnectionProfile Bigquery Profile  - BigQuery warehouse profile.
 - Connection
Profile stringId  - The connection profile identifier.
 - Create
Without boolValidation  - Create the connection profile without validating it.
 - Display
Name string - Display name.
 - Effective
Labels 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.
 - Forward
Ssh ConnectionConnectivity Profile Forward Ssh Connectivity  - Forward SSH tunnel connectivity. Structure is documented below.
 - Gcs
Profile ConnectionProfile Gcs Profile  - 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_labelsfor all of the labels present on the resource. - Location string
 - The name of the location this connection profile is located in.
 - Mysql
Profile ConnectionProfile Mysql Profile  - MySQL database profile. Structure is documented below.
 - Name string
 - The resource's name.
 - Oracle
Profile ConnectionProfile Oracle Profile  - Oracle database profile. Structure is documented below.
 - Postgresql
Profile ConnectionProfile Postgresql Profile  - PostgreSQL database profile. Structure is documented below.
 - Private
Connectivity ConnectionProfile Private Connectivity  - 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.
 - Pulumi
Labels Dictionary<string, string> - The combination of labels configured directly on the resource and default labels configured on the provider.
 - Sql
Server ConnectionProfile Profile Sql Server Profile  - SQL Server database profile. Structure is documented below.
 
- Bigquery
Profile ConnectionProfile Bigquery Profile Args  - BigQuery warehouse profile.
 - Connection
Profile stringId  - The connection profile identifier.
 - Create
Without boolValidation  - Create the connection profile without validating it.
 - Display
Name string - Display name.
 - Effective
Labels 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.
 - Forward
Ssh ConnectionConnectivity Profile Forward Ssh Connectivity Args  - Forward SSH tunnel connectivity. Structure is documented below.
 - Gcs
Profile ConnectionProfile Gcs Profile Args  - 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_labelsfor all of the labels present on the resource. - Location string
 - The name of the location this connection profile is located in.
 - Mysql
Profile ConnectionProfile Mysql Profile Args  - MySQL database profile. Structure is documented below.
 - Name string
 - The resource's name.
 - Oracle
Profile ConnectionProfile Oracle Profile Args  - Oracle database profile. Structure is documented below.
 - Postgresql
Profile ConnectionProfile Postgresql Profile Args  - PostgreSQL database profile. Structure is documented below.
 - Private
Connectivity ConnectionProfile Private Connectivity Args  - 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.
 - Pulumi
Labels map[string]string - The combination of labels configured directly on the resource and default labels configured on the provider.
 - Sql
Server ConnectionProfile Profile Sql Server Profile Args  - SQL Server database profile. Structure is documented below.
 
- bigquery
Profile ConnectionProfile Bigquery Profile  - BigQuery warehouse profile.
 - connection
Profile StringId  - The connection profile identifier.
 - create
Without BooleanValidation  - Create the connection profile without validating it.
 - display
Name String - Display name.
 - effective
Labels 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.
 - forward
Ssh ConnectionConnectivity Profile Forward Ssh Connectivity  - Forward SSH tunnel connectivity. Structure is documented below.
 - gcs
Profile ConnectionProfile Gcs Profile  - 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_labelsfor all of the labels present on the resource. - location String
 - The name of the location this connection profile is located in.
 - mysql
Profile ConnectionProfile Mysql Profile  - MySQL database profile. Structure is documented below.
 - name String
 - The resource's name.
 - oracle
Profile ConnectionProfile Oracle Profile  - Oracle database profile. Structure is documented below.
 - postgresql
Profile ConnectionProfile Postgresql Profile  - PostgreSQL database profile. Structure is documented below.
 - private
Connectivity ConnectionProfile Private Connectivity  - 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.
 - pulumi
Labels Map<String,String> - The combination of labels configured directly on the resource and default labels configured on the provider.
 - sql
Server ConnectionProfile Profile Sql Server Profile  - SQL Server database profile. Structure is documented below.
 
- bigquery
Profile ConnectionProfile Bigquery Profile  - BigQuery warehouse profile.
 - connection
Profile stringId  - The connection profile identifier.
 - create
Without booleanValidation  - Create the connection profile without validating it.
 - display
Name string - Display name.
 - effective
Labels {[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.
 - forward
Ssh ConnectionConnectivity Profile Forward Ssh Connectivity  - Forward SSH tunnel connectivity. Structure is documented below.
 - gcs
Profile ConnectionProfile Gcs Profile  - 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_labelsfor all of the labels present on the resource. - location string
 - The name of the location this connection profile is located in.
 - mysql
Profile ConnectionProfile Mysql Profile  - MySQL database profile. Structure is documented below.
 - name string
 - The resource's name.
 - oracle
Profile ConnectionProfile Oracle Profile  - Oracle database profile. Structure is documented below.
 - postgresql
Profile ConnectionProfile Postgresql Profile  - PostgreSQL database profile. Structure is documented below.
 - private
Connectivity ConnectionProfile Private Connectivity  - 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.
 - pulumi
Labels {[key: string]: string} - The combination of labels configured directly on the resource and default labels configured on the provider.
 - sql
Server ConnectionProfile Profile Sql Server Profile  - SQL Server database profile. Structure is documented below.
 
- bigquery_
profile ConnectionProfile Bigquery Profile Args  - BigQuery warehouse profile.
 - connection_
profile_ strid  - The connection profile identifier.
 - create_
without_ boolvalidation  - 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_ Connectionconnectivity Profile Forward Ssh Connectivity Args  - Forward SSH tunnel connectivity. Structure is documented below.
 - gcs_
profile ConnectionProfile Gcs Profile Args  - 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_labelsfor all of the labels present on the resource. - location str
 - The name of the location this connection profile is located in.
 - mysql_
profile ConnectionProfile Mysql Profile Args  - MySQL database profile. Structure is documented below.
 - name str
 - The resource's name.
 - oracle_
profile ConnectionProfile Oracle Profile Args  - Oracle database profile. Structure is documented below.
 - postgresql_
profile ConnectionProfile Postgresql Profile Args  - PostgreSQL database profile. Structure is documented below.
 - private_
connectivity ConnectionProfile Private Connectivity Args  - 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_ Connectionprofile Profile Sql Server Profile Args  - SQL Server database profile. Structure is documented below.
 
- bigquery
Profile Property Map - BigQuery warehouse profile.
 - connection
Profile StringId  - The connection profile identifier.
 - create
Without BooleanValidation  - Create the connection profile without validating it.
 - display
Name String - Display name.
 - effective
Labels Map<String> - All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
 - forward
Ssh Property MapConnectivity  - Forward SSH tunnel connectivity. Structure is documented below.
 - gcs
Profile 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_labelsfor all of the labels present on the resource. - location String
 - The name of the location this connection profile is located in.
 - mysql
Profile Property Map - MySQL database profile. Structure is documented below.
 - name String
 - The resource's name.
 - oracle
Profile Property Map - Oracle database profile. Structure is documented below.
 - postgresql
Profile Property Map - PostgreSQL database profile. Structure is documented below.
 - private
Connectivity 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.
 - pulumi
Labels Map<String> - The combination of labels configured directly on the resource and default labels configured on the provider.
 - sql
Server Property MapProfile  - 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.
 - Private
Key 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.
 - Private
Key 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.
 - private
Key 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.
 - private
Key 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.
 - private
Key String - SSH private key. Note: This property is sensitive and will not be displayed in the plan.
 
ConnectionProfileGcsProfile, ConnectionProfileGcsProfileArgs        
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.
 - Ssl
Config ConnectionProfile Mysql Profile Ssl Config  - 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.
 - Ssl
Config ConnectionProfile Mysql Profile Ssl Config  - 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.
 - ssl
Config ConnectionProfile Mysql Profile Ssl Config  - 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.
 - ssl
Config ConnectionProfile Mysql Profile Ssl Config  - 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 ConnectionProfile Mysql Profile Ssl Config  - 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.
 - ssl
Config Property Map - SSL configuration for the MySQL connection. Structure is documented below.
 
ConnectionProfileMysqlProfileSslConfig, ConnectionProfileMysqlProfileSslConfigArgs            
- Ca
Certificate 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.
 - Ca
Certificate boolSet  - (Output) Indicates whether the clientKey field is set.
 - Client
Certificate 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.
 - Client
Certificate boolSet  - (Output) Indicates whether the clientCertificate field is set.
 - Client
Key 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.
 - Client
Key boolSet  - (Output) Indicates whether the clientKey field is set.
 
- Ca
Certificate 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.
 - Ca
Certificate boolSet  - (Output) Indicates whether the clientKey field is set.
 - Client
Certificate 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.
 - Client
Certificate boolSet  - (Output) Indicates whether the clientCertificate field is set.
 - Client
Key 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.
 - Client
Key boolSet  - (Output) Indicates whether the clientKey field is set.
 
- ca
Certificate 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.
 - ca
Certificate BooleanSet  - (Output) Indicates whether the clientKey field is set.
 - client
Certificate 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.
 - client
Certificate BooleanSet  - (Output) Indicates whether the clientCertificate field is set.
 - client
Key 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.
 - client
Key BooleanSet  - (Output) Indicates whether the clientKey field is set.
 
- ca
Certificate 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.
 - ca
Certificate booleanSet  - (Output) Indicates whether the clientKey field is set.
 - client
Certificate 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.
 - client
Certificate booleanSet  - (Output) Indicates whether the clientCertificate field is set.
 - client
Key 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.
 - client
Key booleanSet  - (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_ boolset  - (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_ boolset  - (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_ boolset  - (Output) Indicates whether the clientKey field is set.
 
- ca
Certificate 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.
 - ca
Certificate BooleanSet  - (Output) Indicates whether the clientKey field is set.
 - client
Certificate 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.
 - client
Certificate BooleanSet  - (Output) Indicates whether the clientCertificate field is set.
 - client
Key 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.
 - client
Key BooleanSet  - (Output) Indicates whether the clientKey field is set.
 
ConnectionProfileOracleProfile, ConnectionProfileOracleProfileArgs        
- Database
Service 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.
 - Connection
Attributes Dictionary<string, string> - Connection string attributes
 - Port int
 - Port for the Oracle connection.
 
- Database
Service 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.
 - Connection
Attributes map[string]string - Connection string attributes
 - Port int
 - Port for the Oracle connection.
 
- database
Service 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.
 - connection
Attributes Map<String,String> - Connection string attributes
 - port Integer
 - Port for the Oracle connection.
 
- database
Service 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.
 - connection
Attributes {[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.
 
- database
Service 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.
 - connection
Attributes 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        
- Private
Connection string - A reference to a private connection resource. Format: 
projects/{project}/locations/{location}/privateConnections/{name} 
- Private
Connection string - A reference to a private connection resource. Format: 
projects/{project}/locations/{location}/privateConnections/{name} 
- private
Connection String - A reference to a private connection resource. Format: 
projects/{project}/locations/{location}/privateConnections/{name} 
- private
Connection 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} 
- private
Connection 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-betaTerraform Provider.