pulumi-gcp-kotlin/com.pulumi.gcp.datastream.kotlin/ConnectionProfile

ConnectionProfile

class ConnectionProfile : KotlinCustomResource

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

Official Documentation

Warning: All arguments including the following potentially sensitive values will be stored in the raw state as plain text: oracle_profile.password, mysql_profile.password, mysql_profile.ssl_config.client_key, mysql_profile.ssl_config.client_certificate, mysql_profile.ssl_config.ca_certificate, postgresql_profile.password, forward_ssh_connectivity.password, forward_ssh_connectivity.private_key. Read more about sensitive data in state.

Example Usage

Datastream Connection Profile Basic

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()
            .connectionProfileId("my-profile")
            .displayName("Connection profile")
            .gcsProfile(ConnectionProfileGcsProfileArgs.builder()
                .bucket("my-bucket")
                .rootPath("/path")
                .build())
            .location("us-central1")
            .build());
    }
}

Datastream Connection Profile Bigquery Private Connection

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.datastream.PrivateConnection;
import com.pulumi.gcp.datastream.PrivateConnectionArgs;
import com.pulumi.gcp.datastream.inputs.PrivateConnectionVpcPeeringConfigArgs;
import com.pulumi.gcp.datastream.ConnectionProfile;
import com.pulumi.gcp.datastream.ConnectionProfileArgs;
import com.pulumi.gcp.datastream.inputs.ConnectionProfileBigqueryProfileArgs;
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 defaultNetwork = new Network("defaultNetwork");
        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(defaultNetwork.id())
                .subnet("10.0.0.0/29")
                .build())
            .build());
        var defaultConnectionProfile = new ConnectionProfile("defaultConnectionProfile", ConnectionProfileArgs.builder()
            .displayName("Connection profile")
            .location("us-central1")
            .connectionProfileId("my-profile")
            .bigqueryProfile()
            .privateConnectivity(ConnectionProfilePrivateConnectivityArgs.builder()
                .privateConnection(privateConnection.id())
                .build())
            .build());
    }
}

Datastream Connection Profile Full

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.ConnectionProfileForwardSshConnectivityArgs;
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()
            .connectionProfileId("my-profile")
            .displayName("Connection profile")
            .forwardSshConnectivity(ConnectionProfileForwardSshConnectivityArgs.builder()
                .hostname("google.com")
                .password("swordfish")
                .port(8022)
                .username("my-user")
                .build())
            .gcsProfile(ConnectionProfileGcsProfileArgs.builder()
                .bucket("my-bucket")
                .rootPath("/path")
                .build())
            .labels(Map.of("key", "value"))
            .location("us-central1")
            .build());
    }
}

Datastream Connection Profile Postgres

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()
            .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())
            .build());
        var pwd = new RandomPassword("pwd", RandomPasswordArgs.builder()
            .length(16)
            .special(false)
            .build());
        var user = new User("user", UserArgs.builder()
            .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());
    }
}

Import

ConnectionProfile can be imported using any of these accepted formats

$ 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}}

Properties

bigqueryProfile

val bigqueryProfile: Output<ConnectionProfileBigqueryProfile>?

BigQuery warehouse profile.

connectionProfileId

val connectionProfileId: Output<String>

The connection profile identifier.

displayName

val displayName: Output<String>

Display name.

forwardSshConnectivity

val forwardSshConnectivity: Output<ConnectionProfileForwardSshConnectivity>?

Forward SSH tunnel connectivity. Structure is documented below.

gcsProfile

val gcsProfile: Output<ConnectionProfileGcsProfile>?

Cloud Storage bucket profile. Structure is documented below.

val id: Output<String>

labels

val labels: Output<Map<String, String>>?

Labels.

location

val location: Output<String>

The name of the location this connection profile is located in.

mysqlProfile

val mysqlProfile: Output<ConnectionProfileMysqlProfile>?

MySQL database profile. Structure is documented below.

name

val name: Output<String>

The resource's name.

oracleProfile

val oracleProfile: Output<ConnectionProfileOracleProfile>?

Oracle database profile. Structure is documented below.

postgresqlProfile

val postgresqlProfile: Output<ConnectionProfilePostgresqlProfile>?

PostgreSQL database profile. Structure is documented below.

privateConnectivity

val privateConnectivity: Output<ConnectionProfilePrivateConnectivity>?

Private connectivity. Structure is documented below.

project

val project: Output<String>

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

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

urn

val urn: Output<String>