ConnectionProfile class
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
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",
})
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 main
import (
"github.com/pulumi/pulumi-gcp/sdk/v9/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
})
}
pulumi {
required_providers {
gcp = {
source = "pulumi/gcp"
}
}
}
resource "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 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.ArrayList;
import java.util.Arrays;
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",
autoCreateSubnetworks: false,
});
const defaultSubnetwork = new gcp.compute.Subnetwork("default", {
name: "my-subnetwork",
ipCidrRange: "10.1.0.0/16",
region: "us-central1",
network: _default.id,
});
const privateConnection = new gcp.datastream.PrivateConnection("private_connection", {
displayName: "Private connection",
location: "us-central1",
privateConnectionId: "my-connection",
vpcPeeringConfig: {
vpc: _default.id,
subnet: "10.0.0.0/29",
},
});
const natVmIp = new gcp.compute.Address("nat_vm_ip", {name: "nat-vm-ip"});
const instance = new gcp.sql.DatabaseInstance("instance", {
name: "my-instance",
databaseVersion: "POSTGRES_14",
region: "us-central1",
settings: {
tier: "db-f1-micro",
ipConfiguration: {
authorizedNetworks: [{
value: natVmIp.address,
}],
},
},
deletionProtection: true,
});
const db = new gcp.sql.Database("db", {
instance: instance.name,
name: "db",
});
const pwd = new random.index.Password("pwd", {
length: 16,
special: false,
});
const user = new gcp.sql.User("user", {
name: "user",
instance: instance.name,
password: pwd.result,
});
const natVm = new gcp.compute.Instance("nat_vm", {
name: "nat-vm",
machineType: "e2-medium",
zone: "us-central1-a",
desiredStatus: "RUNNING",
bootDisk: {
initializeParams: {
image: "debian-cloud/debian-12",
},
},
networkInterfaces: [{
network: privateConnection.vpcPeeringConfig.apply(vpcPeeringConfig => vpcPeeringConfig?.vpc),
subnetwork: defaultSubnetwork.selfLink,
accessConfigs: [{
natIp: natVmIp.address,
}],
}],
metadataStartupScript: pulumi.interpolate`#! /bin/bash
# See https://cloud.google.com/datastream/docs/private-connectivity#set-up-reverse-proxy
export DB_ADDR=${instance.publicIpAddress}
export DB_PORT=5432
echo 1 > /proc/sys/net/ipv4/ip_forward
md_url_prefix=\"http://169.254.169.254/computeMetadata/v1/instance\"
vm_nic_ip=\"$(curl -H \"Metadata-Flavor: Google\" ${md_url_prefix}/network-interfaces/0/ip)\"
iptables -t nat -F
iptables -t nat -A PREROUTING \\
-p tcp --dport $DB_PORT \\
-j DNAT \\
--to-destination $DB_ADDR
iptables -t nat -A POSTROUTING \\
-p tcp --dport $DB_PORT \\
-j SNAT \\
--to-source $vm_nic_ip
iptables-save
`,
});
const rules = new gcp.compute.Firewall("rules", {
name: "ingress-rule",
network: privateConnection.vpcPeeringConfig.apply(vpcPeeringConfig => vpcPeeringConfig?.vpc),
description: "Allow traffic into NAT VM",
direction: "INGRESS",
allows: [{
protocol: "tcp",
ports: ["5432"],
}],
sourceRanges: [privateConnection.vpcPeeringConfig.apply(vpcPeeringConfig => vpcPeeringConfig?.subnet)],
});
const defaultConnectionProfile = new gcp.datastream.ConnectionProfile("default", {
displayName: "Connection profile",
location: "us-central1",
connectionProfileId: "my-profile",
postgresqlProfile: {
hostname: natVm.networkInterfaces[0].networkIp,
username: user.name,
password: user.password,
database: db.name,
port: 5432,
},
privateConnectivity: {
privateConnection: privateConnection.id,
},
});
import pulumi
import pulumi_gcp as gcp
import pulumi_random as random
default = gcp.compute.Network("default",
name="my-network",
auto_create_subnetworks=False)
default_subnetwork = gcp.compute.Subnetwork("default",
name="my-subnetwork",
ip_cidr_range="10.1.0.0/16",
region="us-central1",
network=default.id)
private_connection = gcp.datastream.PrivateConnection("private_connection",
display_name="Private connection",
location="us-central1",
private_connection_id="my-connection",
vpc_peering_config={
"vpc": default.id,
"subnet": "10.0.0.0/29",
})
nat_vm_ip = gcp.compute.Address("nat_vm_ip", name="nat-vm-ip")
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": nat_vm_ip.address,
}],
},
},
deletion_protection=True)
db = gcp.sql.Database("db",
instance=instance.name,
name="db")
pwd = random.Password("pwd",
length=16,
special=False)
user = gcp.sql.User("user",
name="user",
instance=instance.name,
password=pwd["result"])
nat_vm = gcp.compute.Instance("nat_vm",
name="nat-vm",
machine_type="e2-medium",
zone="us-central1-a",
desired_status="RUNNING",
boot_disk={
"initialize_params": {
"image": "debian-cloud/debian-12",
},
},
network_interfaces=[{
"network": private_connection.vpc_peering_config.vpc,
"subnetwork": default_subnetwork.self_link,
"access_configs": [{
"nat_ip": nat_vm_ip.address,
}],
}],
metadata_startup_script=instance.public_ip_address.apply(lambda public_ip_address: f"""#! /bin/bash
# See https://cloud.google.com/datastream/docs/private-connectivity#set-up-reverse-proxy
export DB_ADDR={public_ip_address}
export DB_PORT=5432
echo 1 > /proc/sys/net/ipv4/ip_forward
md_url_prefix=\"http://169.254.169.254/computeMetadata/v1/instance\"
vm_nic_ip=\"$(curl -H \"Metadata-Flavor: Google\" ${{md_url_prefix}}/network-interfaces/0/ip)\"
iptables -t nat -F
iptables -t nat -A PREROUTING \\
-p tcp --dport $DB_PORT \\
-j DNAT \\
--to-destination $DB_ADDR
iptables -t nat -A POSTROUTING \\
-p tcp --dport $DB_PORT \\
-j SNAT \\
--to-source $vm_nic_ip
iptables-save
"""))
rules = gcp.compute.Firewall("rules",
name="ingress-rule",
network=private_connection.vpc_peering_config.vpc,
description="Allow traffic into NAT VM",
direction="INGRESS",
allows=[{
"protocol": "tcp",
"ports": ["5432"],
}],
source_ranges=[private_connection.vpc_peering_config.subnet])
default_connection_profile = gcp.datastream.ConnectionProfile("default",
display_name="Connection profile",
location="us-central1",
connection_profile_id="my-profile",
postgresql_profile={
"hostname": nat_vm.network_interfaces[0].network_ip,
"username": user.name,
"password": user.password,
"database": db.name,
"port": 5432,
},
private_connectivity={
"private_connection": private_connection.id,
})
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",
AutoCreateSubnetworks = false,
});
var defaultSubnetwork = new Gcp.Compute.Subnetwork("default", new()
{
Name = "my-subnetwork",
IpCidrRange = "10.1.0.0/16",
Region = "us-central1",
Network = @default.Id,
});
var privateConnection = new Gcp.Datastream.PrivateConnection("private_connection", new()
{
DisplayName = "Private connection",
Location = "us-central1",
PrivateConnectionId = "my-connection",
VpcPeeringConfig = new Gcp.Datastream.Inputs.PrivateConnectionVpcPeeringConfigArgs
{
Vpc = @default.Id,
Subnet = "10.0.0.0/29",
},
});
var natVmIp = new Gcp.Compute.Address("nat_vm_ip", new()
{
Name = "nat-vm-ip",
});
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 = natVmIp.IPAddress,
},
},
},
},
DeletionProtection = true,
});
var db = new Gcp.Sql.Database("db", new()
{
Instance = instance.Name,
Name = "db",
});
var pwd = new Random.Password("pwd", new()
{
Length = 16,
Special = false,
});
var user = new Gcp.Sql.User("user", new()
{
Name = "user",
Instance = instance.Name,
Password = pwd.Result,
});
var natVm = new Gcp.Compute.Instance("nat_vm", new()
{
Name = "nat-vm",
MachineType = "e2-medium",
Zone = "us-central1-a",
DesiredStatus = "RUNNING",
BootDisk = new Gcp.Compute.Inputs.InstanceBootDiskArgs
{
InitializeParams = new Gcp.Compute.Inputs.InstanceBootDiskInitializeParamsArgs
{
Image = "debian-cloud/debian-12",
},
},
NetworkInterfaces = new[]
{
new Gcp.Compute.Inputs.InstanceNetworkInterfaceArgs
{
Network = privateConnection.VpcPeeringConfig.Apply(vpcPeeringConfig => vpcPeeringConfig?.Vpc),
Subnetwork = defaultSubnetwork.SelfLink,
AccessConfigs = new[]
{
new Gcp.Compute.Inputs.InstanceNetworkInterfaceAccessConfigArgs
{
NatIp = natVmIp.IPAddress,
},
},
},
},
MetadataStartupScript = instance.PublicIpAddress.Apply(publicIpAddress => @$"#! /bin/bash
# See https://cloud.google.com/datastream/docs/private-connectivity#set-up-reverse-proxy
export DB_ADDR={publicIpAddress}
export DB_PORT=5432
echo 1 > /proc/sys/net/ipv4/ip_forward
md_url_prefix=\""http://169.254.169.254/computeMetadata/v1/instance\""
vm_nic_ip=\""$(curl -H \""Metadata-Flavor: Google\"" ${{md_url_prefix}}/network-interfaces/0/ip)\""
iptables -t nat -F
iptables -t nat -A PREROUTING \\
-p tcp --dport $DB_PORT \\
-j DNAT \\
--to-destination $DB_ADDR
iptables -t nat -A POSTROUTING \\
-p tcp --dport $DB_PORT \\
-j SNAT \\
--to-source $vm_nic_ip
iptables-save
"),
});
var rules = new Gcp.Compute.Firewall("rules", new()
{
Name = "ingress-rule",
Network = privateConnection.VpcPeeringConfig.Apply(vpcPeeringConfig => vpcPeeringConfig?.Vpc),
Description = "Allow traffic into NAT VM",
Direction = "INGRESS",
Allows = new[]
{
new Gcp.Compute.Inputs.FirewallAllowArgs
{
Protocol = "tcp",
Ports = new[]
{
"5432",
},
},
},
SourceRanges = new[]
{
privateConnection.VpcPeeringConfig.Apply(vpcPeeringConfig => vpcPeeringConfig?.Subnet),
},
});
var defaultConnectionProfile = new Gcp.Datastream.ConnectionProfile("default", new()
{
DisplayName = "Connection profile",
Location = "us-central1",
ConnectionProfileId = "my-profile",
PostgresqlProfile = new Gcp.Datastream.Inputs.ConnectionProfilePostgresqlProfileArgs
{
Hostname = natVm.NetworkInterfaces.Apply(networkInterfaces => networkInterfaces[0].NetworkIp),
Username = user.Name,
Password = user.Password,
Database = db.Name,
Port = 5432,
},
PrivateConnectivity = new Gcp.Datastream.Inputs.ConnectionProfilePrivateConnectivityArgs
{
PrivateConnection = privateConnection.Id,
},
});
});
package main
import (
"fmt"
"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/compute"
"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/datastream"
"github.com/pulumi/pulumi-gcp/sdk/v9/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 {
_default, err := compute.NewNetwork(ctx, "default", &compute.NetworkArgs{
Name: pulumi.String("my-network"),
AutoCreateSubnetworks: pulumi.Bool(false),
})
if err != nil {
return err
}
defaultSubnetwork, err := compute.NewSubnetwork(ctx, "default", &compute.SubnetworkArgs{
Name: pulumi.String("my-subnetwork"),
IpCidrRange: pulumi.String("10.1.0.0/16"),
Region: pulumi.String("us-central1"),
Network: _default.ID().ToIDOutput().ToStringOutput(),
})
if err != nil {
return err
}
privateConnection, err := datastream.NewPrivateConnection(ctx, "private_connection", &datastream.PrivateConnectionArgs{
DisplayName: pulumi.String("Private connection"),
Location: pulumi.String("us-central1"),
PrivateConnectionId: pulumi.String("my-connection"),
VpcPeeringConfig: &datastream.PrivateConnectionVpcPeeringConfigArgs{
Vpc: _default.ID().ToIDOutput().ToStringOutput(),
Subnet: pulumi.String("10.0.0.0/29"),
},
})
if err != nil {
return err
}
natVmIp, err := compute.NewAddress(ctx, "nat_vm_ip", &compute.AddressArgs{
Name: pulumi.String("nat-vm-ip"),
})
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: natVmIp.Address,
},
},
},
},
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.NewPassword(ctx, "pwd", &random.PasswordArgs{
Length: 16,
Special: 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
}
natVm, err := compute.NewInstance(ctx, "nat_vm", &compute.InstanceArgs{
Name: pulumi.String("nat-vm"),
MachineType: pulumi.String("e2-medium"),
Zone: pulumi.String("us-central1-a"),
DesiredStatus: pulumi.String("RUNNING"),
BootDisk: &compute.InstanceBootDiskArgs{
InitializeParams: &compute.InstanceBootDiskInitializeParamsArgs{
Image: pulumi.String("debian-cloud/debian-12"),
},
},
NetworkInterfaces: compute.InstanceNetworkInterfaceArray{
&compute.InstanceNetworkInterfaceArgs{
Network: privateConnection.VpcPeeringConfig.Vpc(),
Subnetwork: defaultSubnetwork.SelfLink,
AccessConfigs: compute.InstanceNetworkInterfaceAccessConfigArray{
&compute.InstanceNetworkInterfaceAccessConfigArgs{
NatIp: natVmIp.Address,
},
},
},
},
MetadataStartupScript: instance.PublicIpAddress.ApplyT(func(publicIpAddress string) (string, error) {
return fmt.Sprintf(`#! /bin/bash
# See https://cloud.google.com/datastream/docs/private-connectivity#set-up-reverse-proxy
export DB_ADDR=%v
export DB_PORT=5432
echo 1 > /proc/sys/net/ipv4/ip_forward
md_url_prefix=\"http://169.254.169.254/computeMetadata/v1/instance\"
vm_nic_ip=\"$(curl -H \"Metadata-Flavor: Google\" ${md_url_prefix}/network-interfaces/0/ip)\"
iptables -t nat -F
iptables -t nat -A PREROUTING \\
-p tcp --dport $DB_PORT \\
-j DNAT \\
--to-destination $DB_ADDR
iptables -t nat -A POSTROUTING \\
-p tcp --dport $DB_PORT \\
-j SNAT \\
--to-source $vm_nic_ip
iptables-save
`, publicIpAddress), nil
}).(pulumi.StringOutput),
})
if err != nil {
return err
}
_, err = compute.NewFirewall(ctx, "rules", &compute.FirewallArgs{
Name: pulumi.String("ingress-rule"),
Network: privateConnection.VpcPeeringConfig.Vpc(),
Description: pulumi.String("Allow traffic into NAT VM"),
Direction: pulumi.String("INGRESS"),
Allows: compute.FirewallAllowArray{
&compute.FirewallAllowArgs{
Protocol: pulumi.String("tcp"),
Ports: pulumi.StringArray{
pulumi.String("5432"),
},
},
},
SourceRanges: pulumi.StringArray{
privateConnection.VpcPeeringConfig.Subnet(),
},
})
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: natVm.NetworkInterfaces.ApplyT(func(networkInterfaces []compute.InstanceNetworkInterface) (*string, error) {
return networkInterfaces[0].NetworkIp, nil
}).(pulumi.StringPtrOutput),
Username: user.Name,
Password: user.Password,
Database: db.Name,
Port: pulumi.Int(5432),
},
PrivateConnectivity: &datastream.ConnectionProfilePrivateConnectivityArgs{
PrivateConnection: privateConnection.ID().ToIDOutput().ToStringOutput(),
},
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
gcp = {
source = "pulumi/gcp"
}
random = {
source = "pulumi/random"
}
}
}
resource "gcp_compute_network" "default" {
name = "my-network"
auto_create_subnetworks = false
}
resource "gcp_compute_subnetwork" "default" {
name = "my-subnetwork"
ip_cidr_range = "10.1.0.0/16"
region = "us-central1"
network = gcp_compute_network.default.id
}
resource "gcp_datastream_privateconnection" "private_connection" {
display_name = "Private connection"
location = "us-central1"
private_connection_id = "my-connection"
vpc_peering_config = {
vpc = gcp_compute_network.default.id
subnet = "10.0.0.0/29"
}
}
resource "gcp_sql_databaseinstance" "instance" {
name = "my-instance"
database_version = "POSTGRES_14"
region = "us-central1"
settings = {
tier = "db-f1-micro"
ip_configuration = {
authorized_networks = [{
"value" = gcp_compute_address.nat_vm_ip.address
}]
}
}
deletion_protection = true
}
resource "gcp_sql_database" "db" {
instance = gcp_sql_databaseinstance.instance.name
name = "db"
}
resource "random_password" "pwd" {
length = 16
special = false
}
resource "gcp_sql_user" "user" {
name = "user"
instance = gcp_sql_databaseinstance.instance.name
password = random_password.pwd.result
}
resource "gcp_compute_address" "nat_vm_ip" {
name = "nat-vm-ip"
}
resource "gcp_compute_instance" "nat_vm" {
name = "nat-vm"
machine_type = "e2-medium"
zone = "us-central1-a"
desired_status = "RUNNING"
boot_disk = {
initialize_params = {
image = "debian-cloud/debian-12"
}
}
network_interfaces {
network = gcp_datastream_privateconnection.private_connection.vpc_peering_config.vpc
subnetwork = gcp_compute_subnetwork.default.self_link
access_configs {
nat_ip = gcp_compute_address.nat_vm_ip.address
}
}
metadata_startup_script ="#! /bin/bash
# See https://cloud.google.com/datastream/docs/private-connectivity#set-up-reverse-proxy
export DB_ADDR=${gcp_sql_databaseinstance.instance.public_ip_address}
export DB_PORT=5432
echo 1 > /proc/sys/net/ipv4/ip_forward
md_url_prefix=\"http://169.254.169.254/computeMetadata/v1/instance\"
vm_nic_ip=\"$(curl -H \"Metadata-Flavor: Google\" ${md_url_prefix}/network-interfaces/0/ip)\"
iptables -t nat -F
iptables -t nat -A PREROUTING \\
-p tcp --dport $DB_PORT \\
-j DNAT \\
--to-destination $DB_ADDR
iptables -t nat -A POSTROUTING \\
-p tcp --dport $DB_PORT \\
-j SNAT \\
--to-source $vm_nic_ip
iptables-save
"
}
resource "gcp_compute_firewall" "rules" {
name = "ingress-rule"
network = gcp_datastream_privateconnection.private_connection.vpc_peering_config.vpc
description = "Allow traffic into NAT VM"
direction = "INGRESS"
allows {
protocol = "tcp"
ports = ["5432"]
}
source_ranges = [gcp_datastream_privateconnection.private_connection.vpc_peering_config.subnet]
}
resource "gcp_datastream_connectionprofile" "default" {
display_name = "Connection profile"
location = "us-central1"
connection_profile_id = "my-profile"
postgresql_profile = {
hostname = gcp_compute_instance.nat_vm.network_interfaces[0].network_ip
username = gcp_sql_user.user.name
password = gcp_sql_user.user.password
database = gcp_sql_database.db.name
port = 5432
}
private_connectivity = {
private_connection = gcp_datastream_privateconnection.private_connection.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.compute.Subnetwork;
import com.pulumi.gcp.compute.SubnetworkArgs;
import com.pulumi.gcp.datastream.PrivateConnection;
import com.pulumi.gcp.datastream.PrivateConnectionArgs;
import com.pulumi.gcp.datastream.inputs.PrivateConnectionVpcPeeringConfigArgs;
import com.pulumi.gcp.compute.Address;
import com.pulumi.gcp.compute.AddressArgs;
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.inputs.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs;
import com.pulumi.gcp.sql.Database;
import com.pulumi.gcp.sql.DatabaseArgs;
import com.pulumi.random.Password;
import com.pulumi.random.PasswordArgs;
import com.pulumi.gcp.sql.User;
import com.pulumi.gcp.sql.UserArgs;
import com.pulumi.gcp.compute.Instance;
import com.pulumi.gcp.compute.InstanceArgs;
import com.pulumi.gcp.compute.inputs.InstanceBootDiskArgs;
import com.pulumi.gcp.compute.inputs.InstanceBootDiskInitializeParamsArgs;
import com.pulumi.gcp.compute.inputs.InstanceNetworkInterfaceArgs;
import com.pulumi.gcp.compute.inputs.InstanceNetworkInterfaceAccessConfigArgs;
import com.pulumi.gcp.compute.Firewall;
import com.pulumi.gcp.compute.FirewallArgs;
import com.pulumi.gcp.compute.inputs.FirewallAllowArgs;
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.ArrayList;
import java.util.Arrays;
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")
.autoCreateSubnetworks(false)
.build());
var defaultSubnetwork = new Subnetwork("defaultSubnetwork", SubnetworkArgs.builder()
.name("my-subnetwork")
.ipCidrRange("10.1.0.0/16")
.region("us-central1")
.network(default_.id())
.build());
var privateConnection = new PrivateConnection("privateConnection", PrivateConnectionArgs.builder()
.displayName("Private connection")
.location("us-central1")
.privateConnectionId("my-connection")
.vpcPeeringConfig(PrivateConnectionVpcPeeringConfigArgs.builder()
.vpc(default_.id())
.subnet("10.0.0.0/29")
.build())
.build());
var natVmIp = new Address("natVmIp", AddressArgs.builder()
.name("nat-vm-ip")
.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(natVmIp.address())
.build())
.build())
.build())
.deletionProtection(true)
.build());
var db = new Database("db", DatabaseArgs.builder()
.instance(instance.name())
.name("db")
.build());
var pwd = new Password("pwd", PasswordArgs.builder()
.length(16)
.special(false)
.build());
var user = new User("user", UserArgs.builder()
.name("user")
.instance(instance.name())
.password(pwd.get("result"))
.build());
var natVm = new Instance("natVm", InstanceArgs.builder()
.name("nat-vm")
.machineType("e2-medium")
.zone("us-central1-a")
.desiredStatus("RUNNING")
.bootDisk(InstanceBootDiskArgs.builder()
.initializeParams(InstanceBootDiskInitializeParamsArgs.builder()
.image("debian-cloud/debian-12")
.build())
.build())
.networkInterfaces(InstanceNetworkInterfaceArgs.builder()
.network(privateConnection.vpcPeeringConfig().applyValue(_vpcPeeringConfig -> _vpcPeeringConfig.vpc()))
.subnetwork(defaultSubnetwork.selfLink())
.accessConfigs(InstanceNetworkInterfaceAccessConfigArgs.builder()
.natIp(natVmIp.address())
.build())
.build())
.metadataStartupScript(instance.publicIpAddress().applyValue(_publicIpAddress -> """
#! /bin/bash
# See https://cloud.google.com/datastream/docs/private-connectivity#set-up-reverse-proxy
export DB_ADDR=%s
export DB_PORT=5432
echo 1 > /proc/sys/net/ipv4/ip_forward
md_url_prefix=\"http://169.254.169.254/computeMetadata/v1/instance\"
vm_nic_ip=\"$(curl -H \"Metadata-Flavor: Google\" ${md_url_prefix}/network-interfaces/0/ip)\"
iptables -t nat -F
iptables -t nat -A PREROUTING \\
-p tcp --dport $DB_PORT \\
-j DNAT \\
--to-destination $DB_ADDR
iptables -t nat -A POSTROUTING \\
-p tcp --dport $DB_PORT \\
-j SNAT \\
--to-source $vm_nic_ip
iptables-save
", _publicIpAddress)))
.build());
var rules = new Firewall("rules", FirewallArgs.builder()
.name("ingress-rule")
.network(privateConnection.vpcPeeringConfig().applyValue(_vpcPeeringConfig -> _vpcPeeringConfig.vpc()))
.description("Allow traffic into NAT VM")
.direction("INGRESS")
.allows(FirewallAllowArgs.builder()
.protocol("tcp")
.ports("5432")
.build())
.sourceRanges(privateConnection.vpcPeeringConfig().applyValue(_vpcPeeringConfig -> _vpcPeeringConfig.subnet()))
.build());
var defaultConnectionProfile = new ConnectionProfile("defaultConnectionProfile", ConnectionProfileArgs.builder()
.displayName("Connection profile")
.location("us-central1")
.connectionProfileId("my-profile")
.postgresqlProfile(ConnectionProfilePostgresqlProfileArgs.builder()
.hostname(natVm.networkInterfaces().applyValue(_networkInterfaces -> _networkInterfaces.get(0).networkIp()))
.username(user.name())
.password(user.password())
.database(db.name())
.port(5432)
.build())
.privateConnectivity(ConnectionProfilePrivateConnectivityArgs.builder()
.privateConnection(privateConnection.id())
.build())
.build());
}
}
resources:
default:
type: gcp:compute:Network
properties:
name: my-network
autoCreateSubnetworks: false
defaultSubnetwork:
type: gcp:compute:Subnetwork
name: default
properties:
name: my-subnetwork
ipCidrRange: 10.1.0.0/16
region: us-central1
network: ${default.id}
privateConnection:
type: gcp:datastream:PrivateConnection
name: private_connection
properties:
displayName: Private connection
location: us-central1
privateConnectionId: my-connection
vpcPeeringConfig:
vpc: ${default.id}
subnet: 10.0.0.0/29
instance:
type: gcp:sql:DatabaseInstance
properties:
name: my-instance
databaseVersion: POSTGRES_14
region: us-central1
settings:
tier: db-f1-micro
ipConfiguration:
authorizedNetworks:
- value: ${natVmIp.address}
deletionProtection: true
db:
type: gcp:sql:Database
properties:
instance: ${instance.name}
name: db
pwd:
type: random:Password
properties:
length: 16
special: false
user:
type: gcp:sql:User
properties:
name: user
instance: ${instance.name}
password: ${pwd.result}
natVmIp:
type: gcp:compute:Address
name: nat_vm_ip
properties:
name: nat-vm-ip
natVm:
type: gcp:compute:Instance
name: nat_vm
properties:
name: nat-vm
machineType: e2-medium
zone: us-central1-a
desiredStatus: RUNNING
bootDisk:
initializeParams:
image: debian-cloud/debian-12
networkInterfaces:
- network: ${privateConnection.vpcPeeringConfig.vpc}
subnetwork: ${defaultSubnetwork.selfLink}
accessConfigs:
- natIp: ${natVmIp.address}
metadataStartupScript: |
#! /bin/bash
# See https://cloud.google.com/datastream/docs/private-connectivity#set-up-reverse-proxy
export DB_ADDR=${instance.publicIpAddress}
export DB_PORT=5432
echo 1 > /proc/sys/net/ipv4/ip_forward
md_url_prefix=\"http://169.254.169.254/computeMetadata/v1/instance\"
vm_nic_ip=\"$(curl -H \"Metadata-Flavor: Google\" $${md_url_prefix}/network-interfaces/0/ip)\"
iptables -t nat -F
iptables -t nat -A PREROUTING \\
-p tcp --dport $DB_PORT \\
-j DNAT \\
--to-destination $DB_ADDR
iptables -t nat -A POSTROUTING \\
-p tcp --dport $DB_PORT \\
-j SNAT \\
--to-source $vm_nic_ip
iptables-save
rules:
type: gcp:compute:Firewall
properties:
name: ingress-rule
network: ${privateConnection.vpcPeeringConfig.vpc}
description: Allow traffic into NAT VM
direction: INGRESS
allows:
- protocol: tcp
ports:
- '5432'
sourceRanges:
- ${privateConnection.vpcPeeringConfig.subnet}
defaultConnectionProfile:
type: gcp:datastream:ConnectionProfile
name: default
properties:
displayName: Connection profile
location: us-central1
connectionProfileId: my-profile
postgresqlProfile:
hostname: ${natVm.networkInterfaces[0].networkIp}
username: ${user.name}
password: ${user.password}
database: ${db.name}
port: 5432
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",
},
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",
},
labels={
"key": "value",
})
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",
},
Labels =
{
{ "key", "value" },
},
});
});
package main
import (
"github.com/pulumi/pulumi-gcp/sdk/v9/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"),
},
Labels: pulumi.StringMap{
"key": pulumi.String("value"),
},
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
gcp = {
source = "pulumi/gcp"
}
}
}
resource "gcp_datastream_connectionprofile" "default" {
display_name = "Connection profile"
location = "us-central1"
connection_profile_id = "my-profile"
gcs_profile = {
bucket = "my-bucket"
root_path = "/path"
}
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 java.util.ArrayList;
import java.util.Arrays;
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())
.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
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.index.Password("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.Password("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,
})
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.Password("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 main
import (
"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/datastream"
"github.com/pulumi/pulumi-gcp/sdk/v9/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.NewPassword(ctx, "pwd", &random.PasswordArgs{
Length: 16,
Special: 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
})
}
pulumi {
required_providers {
gcp = {
source = "pulumi/gcp"
}
random = {
source = "pulumi/random"
}
}
}
resource "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
}
resource "gcp_sql_database" "db" {
instance = gcp_sql_databaseinstance.instance.name
name = "db"
}
resource "random_password" "pwd" {
length = 16
special = false
}
resource "gcp_sql_user" "user" {
name = "user"
instance = gcp_sql_databaseinstance.instance.name
password = random_password.pwd.result
}
resource "gcp_datastream_connectionprofile" "default" {
display_name = "Connection profile"
location = "us-central1"
connection_profile_id = "my-profile"
postgresql_profile = {
hostname = gcp_sql_databaseinstance.instance.public_ip_address
username = gcp_sql_user.user.name
password = gcp_sql_user.user.password
database = gcp_sql_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.inputs.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs;
import com.pulumi.gcp.sql.Database;
import com.pulumi.gcp.sql.DatabaseArgs;
import com.pulumi.random.Password;
import com.pulumi.random.PasswordArgs;
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.ArrayList;
import java.util.Arrays;
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 Password("pwd", PasswordArgs.builder()
.length(16)
.special(false)
.build());
var user = new User("user", UserArgs.builder()
.name("user")
.instance(instance.name())
.password(pwd.get("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:Password
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_2022_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_2022_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,
})
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_2022_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 main
import (
"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/datastream"
"github.com/pulumi/pulumi-gcp/sdk/v9/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_2022_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
})
}
pulumi {
required_providers {
gcp = {
source = "pulumi/gcp"
}
}
}
resource "gcp_sql_databaseinstance" "instance" {
name = "sql-server"
database_version = "SQLSERVER_2022_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"
}]
}
}
}
resource "gcp_sql_database" "db" {
name = "db"
instance = gcp_sql_databaseinstance.instance.name
}
resource "gcp_sql_user" "user" {
name = "user"
instance = gcp_sql_databaseinstance.instance.name
password = "password"
}
resource "gcp_datastream_connectionprofile" "default" {
display_name = "SQL Server Source"
location = "us-central1"
connection_profile_id = "source-profile"
sql_server_profile = {
hostname = gcp_sql_databaseinstance.instance.public_ip_address
port = 1433
username = gcp_sql_user.user.name
password = gcp_sql_user.user.password
database = gcp_sql_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.inputs.DatabaseInstanceSettingsIpConfigurationAuthorizedNetworkArgs;
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.ArrayList;
import java.util.Arrays;
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_2022_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_2022_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}
Datastream Stream Postgresql Sslconfig Server And Client Verification
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
import * as random from "@pulumi/random";
import * as std from "@pulumi/std";
const datastreamIps = gcp.datastream.getStaticIps({
location: "us-central1",
});
const instance = new gcp.sql.DatabaseInstance("instance", {
name: "my-instance",
databaseVersion: "POSTGRES_15",
region: "us-central1",
settings: {
tier: "db-f1-micro",
ipConfiguration: {
authorizedNetworks: std.format({
input: "datastream-%d",
args: [entry.key],
}).then(invoke => .map(entry => ({
name: invoke.result,
value: entry.value,
}))),
ipv4Enabled: true,
sslMode: "TRUSTED_CLIENT_CERTIFICATE_REQUIRED",
},
},
deletionProtection: true,
});
const db = new gcp.sql.Database("db", {
instance: instance.name,
name: "db",
});
const pwd = new random.index.Password("pwd", {
length: 16,
special: false,
});
const user = new gcp.sql.User("user", {
name: "user",
instance: instance.name,
password: pwd.result,
});
const clientCert = new gcp.sql.SslCert("client_cert", {
commonName: "client-name",
instance: instance.name,
});
const _default = new gcp.datastream.ConnectionProfile("default", {
displayName: "Connection Profile",
location: "us-central1",
connectionProfileId: "profile-id",
postgresqlProfile: {
hostname: instance.publicIpAddress,
port: 5432,
username: "user",
password: pwd.result,
database: db.name,
sslConfig: {
serverAndClientVerification: {
clientCertificate: clientCert.cert,
clientKey: clientCert.privateKey,
caCertificate: clientCert.serverCaCert,
},
},
},
});
import pulumi
import pulumi_gcp as gcp
import pulumi_random as random
import pulumi_std as std
datastream_ips = gcp.datastream.get_static_ips(location="us-central1")
instance = gcp.sql.DatabaseInstance("instance",
name="my-instance",
database_version="POSTGRES_15",
region="us-central1",
settings={
"tier": "db-f1-micro",
"ip_configuration": {
"authorized_networks": [{"key": k, "value": v} for k, v in sorted(datastream_ips.static_ips.items())].apply(lambda entries: [{
"name": std.format(input="datastream-%d",
args=[entry["key"]]).result,
"value": entry["value"],
} for entry in entries]),
"ipv4_enabled": True,
"ssl_mode": "TRUSTED_CLIENT_CERTIFICATE_REQUIRED",
},
},
deletion_protection=True)
db = gcp.sql.Database("db",
instance=instance.name,
name="db")
pwd = random.Password("pwd",
length=16,
special=False)
user = gcp.sql.User("user",
name="user",
instance=instance.name,
password=pwd["result"])
client_cert = gcp.sql.SslCert("client_cert",
common_name="client-name",
instance=instance.name)
default = gcp.datastream.ConnectionProfile("default",
display_name="Connection Profile",
location="us-central1",
connection_profile_id="profile-id",
postgresql_profile={
"hostname": instance.public_ip_address,
"port": 5432,
"username": "user",
"password": pwd["result"],
"database": db.name,
"ssl_config": {
"server_and_client_verification": {
"client_certificate": client_cert.cert,
"client_key": client_cert.private_key,
"ca_certificate": client_cert.server_ca_cert,
},
},
})
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
using Random = Pulumi.Random;
using Std = Pulumi.Std;
return await Deployment.RunAsync(() =>
{
var datastreamIps = Gcp.Datastream.GetStaticIps.Invoke(new()
{
Location = "us-central1",
});
var instance = new Gcp.Sql.DatabaseInstance("instance", new()
{
Name = "my-instance",
DatabaseVersion = "POSTGRES_15",
Region = "us-central1",
Settings = new Gcp.Sql.Inputs.DatabaseInstanceSettingsArgs
{
Tier = "db-f1-micro",
IpConfiguration = new Gcp.Sql.Inputs.DatabaseInstanceSettingsIpConfigurationArgs
{
AuthorizedNetworks = Std.Format.Invoke(new()
{
Input = "datastream-%d",
Args = new[]
{
entry.Key,
},
}).Apply(invoke => ),
Ipv4Enabled = true,
SslMode = "TRUSTED_CLIENT_CERTIFICATE_REQUIRED",
},
},
DeletionProtection = true,
});
var db = new Gcp.Sql.Database("db", new()
{
Instance = instance.Name,
Name = "db",
});
var pwd = new Random.Password("pwd", new()
{
Length = 16,
Special = false,
});
var user = new Gcp.Sql.User("user", new()
{
Name = "user",
Instance = instance.Name,
Password = pwd.Result,
});
var clientCert = new Gcp.Sql.SslCert("client_cert", new()
{
CommonName = "client-name",
Instance = instance.Name,
});
var @default = new Gcp.Datastream.ConnectionProfile("default", new()
{
DisplayName = "Connection Profile",
Location = "us-central1",
ConnectionProfileId = "profile-id",
PostgresqlProfile = new Gcp.Datastream.Inputs.ConnectionProfilePostgresqlProfileArgs
{
Hostname = instance.PublicIpAddress,
Port = 5432,
Username = "user",
Password = pwd.Result,
Database = db.Name,
SslConfig = new Gcp.Datastream.Inputs.ConnectionProfilePostgresqlProfileSslConfigArgs
{
ServerAndClientVerification = new Gcp.Datastream.Inputs.ConnectionProfilePostgresqlProfileSslConfigServerAndClientVerificationArgs
{
ClientCertificate = clientCert.Cert,
ClientKey = clientCert.PrivateKey,
CaCertificate = clientCert.ServerCaCert,
},
},
},
});
});
pulumi {
required_providers {
gcp = {
source = "pulumi/gcp"
}
random = {
source = "pulumi/random"
}
std = {
source = "pulumi/std"
}
}
}
data "std_format" "invoke_0" {
for_each = toset(entries(data.gcp_datastream_getstaticips.datastreamIps.static_ips))
input = "datastream-%d"
args = [each.value.key]
}
data "gcp_datastream_getstaticips" "datastreamIps" {
location = "us-central1"
}
resource "gcp_sql_databaseinstance" "instance" {
name = "my-instance"
database_version = "POSTGRES_15"
region = "us-central1"
settings = {
tier = "db-f1-micro"
ip_configuration = {
authorized_networks = [for entry in entries(data.gcp_datastream_getstaticips.datastreamIps.static_ips) : {
"name" = data.std_format.invoke_0[entry].result
"value" = entry.value
} ]
ipv4_enabled = true
ssl_mode = "TRUSTED_CLIENT_CERTIFICATE_REQUIRED"
}
}
deletion_protection = true
}
resource "gcp_sql_database" "db" {
instance = gcp_sql_databaseinstance.instance.name
name = "db"
}
resource "random_password" "pwd" {
length = 16
special = false
}
resource "gcp_sql_user" "user" {
name = "user"
instance = gcp_sql_databaseinstance.instance.name
password = random_password.pwd.result
}
resource "gcp_sql_sslcert" "client_cert" {
common_name = "client-name"
instance = gcp_sql_databaseinstance.instance.name
}
resource "gcp_datastream_connectionprofile" "default" {
display_name = "Connection Profile"
location = "us-central1"
connection_profile_id = "profile-id"
postgresql_profile = {
hostname = gcp_sql_databaseinstance.instance.public_ip_address
port = 5432
username = "user"
password = random_password.pwd.result
database = gcp_sql_database.db.name
ssl_config = {
server_and_client_verification = {
client_certificate = gcp_sql_sslcert.client_cert.cert
client_key = gcp_sql_sslcert.client_cert.private_key
ca_certificate = gcp_sql_sslcert.client_cert.server_ca_cert
}
}
}
}
Datastream Connection Profile Salesforce
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const _default = new gcp.datastream.ConnectionProfile("default", {
displayName: "Salesforce Source",
location: "us-central1",
connectionProfileId: "source-profile",
createWithoutValidation: true,
salesforceProfile: {
domain: "fake-domain.my.salesforce.com",
userCredentials: {
username: "fake-username",
secretManagerStoredPassword: "fake-password",
secretManagerStoredSecurityToken: "fake-token",
},
},
});
import pulumi
import pulumi_gcp as gcp
default = gcp.datastream.ConnectionProfile("default",
display_name="Salesforce Source",
location="us-central1",
connection_profile_id="source-profile",
create_without_validation=True,
salesforce_profile={
"domain": "fake-domain.my.salesforce.com",
"user_credentials": {
"username": "fake-username",
"secret_manager_stored_password": "fake-password",
"secret_manager_stored_security_token": "fake-token",
},
})
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 = "Salesforce Source",
Location = "us-central1",
ConnectionProfileId = "source-profile",
CreateWithoutValidation = true,
SalesforceProfile = new Gcp.Datastream.Inputs.ConnectionProfileSalesforceProfileArgs
{
Domain = "fake-domain.my.salesforce.com",
UserCredentials = new Gcp.Datastream.Inputs.ConnectionProfileSalesforceProfileUserCredentialsArgs
{
Username = "fake-username",
SecretManagerStoredPassword = "fake-password",
SecretManagerStoredSecurityToken = "fake-token",
},
},
});
});
package main
import (
"github.com/pulumi/pulumi-gcp/sdk/v9/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("Salesforce Source"),
Location: pulumi.String("us-central1"),
ConnectionProfileId: pulumi.String("source-profile"),
CreateWithoutValidation: pulumi.Bool(true),
SalesforceProfile: &datastream.ConnectionProfileSalesforceProfileArgs{
Domain: pulumi.String("fake-domain.my.salesforce.com"),
UserCredentials: &datastream.ConnectionProfileSalesforceProfileUserCredentialsArgs{
Username: pulumi.String("fake-username"),
SecretManagerStoredPassword: pulumi.String("fake-password"),
SecretManagerStoredSecurityToken: pulumi.String("fake-token"),
},
},
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
gcp = {
source = "pulumi/gcp"
}
}
}
resource "gcp_datastream_connectionprofile" "default" {
display_name = "Salesforce Source"
location = "us-central1"
connection_profile_id = "source-profile"
create_without_validation = true
salesforce_profile = {
domain = "fake-domain.my.salesforce.com"
user_credentials = {
username = "fake-username"
secret_manager_stored_password = "fake-password"
secret_manager_stored_security_token = "fake-token"
}
}
}
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.ConnectionProfileSalesforceProfileArgs;
import com.pulumi.gcp.datastream.inputs.ConnectionProfileSalesforceProfileUserCredentialsArgs;
import java.util.ArrayList;
import java.util.Arrays;
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("Salesforce Source")
.location("us-central1")
.connectionProfileId("source-profile")
.createWithoutValidation(true)
.salesforceProfile(ConnectionProfileSalesforceProfileArgs.builder()
.domain("fake-domain.my.salesforce.com")
.userCredentials(ConnectionProfileSalesforceProfileUserCredentialsArgs.builder()
.username("fake-username")
.secretManagerStoredPassword("fake-password")
.secretManagerStoredSecurityToken("fake-token")
.build())
.build())
.build());
}
}
resources:
default:
type: gcp:datastream:ConnectionProfile
properties:
displayName: Salesforce Source
location: us-central1
connectionProfileId: source-profile
createWithoutValidation: true
salesforceProfile:
domain: fake-domain.my.salesforce.com
userCredentials:
username: fake-username
secretManagerStoredPassword: fake-password
secretManagerStoredSecurityToken: fake-token
Datastream Connection Profile Spanner
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const _default = new gcp.datastream.ConnectionProfile("default", {
displayName: "Spanner Source",
location: "us-central1",
connectionProfileId: "source-profile",
createWithoutValidation: true,
spannerProfile: {
database: "projects/example-project/instances/example-instance/databases/example-database",
host: "https://spanner.example-region.rep.googleapis.com",
},
});
import pulumi
import pulumi_gcp as gcp
default = gcp.datastream.ConnectionProfile("default",
display_name="Spanner Source",
location="us-central1",
connection_profile_id="source-profile",
create_without_validation=True,
spanner_profile={
"database": "projects/example-project/instances/example-instance/databases/example-database",
"host": "https://spanner.example-region.rep.googleapis.com",
})
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 = "Spanner Source",
Location = "us-central1",
ConnectionProfileId = "source-profile",
CreateWithoutValidation = true,
SpannerProfile = new Gcp.Datastream.Inputs.ConnectionProfileSpannerProfileArgs
{
Database = "projects/example-project/instances/example-instance/databases/example-database",
Host = "https://spanner.example-region.rep.googleapis.com",
},
});
});
package main
import (
"github.com/pulumi/pulumi-gcp/sdk/v9/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("Spanner Source"),
Location: pulumi.String("us-central1"),
ConnectionProfileId: pulumi.String("source-profile"),
CreateWithoutValidation: pulumi.Bool(true),
SpannerProfile: &datastream.ConnectionProfileSpannerProfileArgs{
Database: pulumi.String("projects/example-project/instances/example-instance/databases/example-database"),
Host: pulumi.String("https://spanner.example-region.rep.googleapis.com"),
},
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
gcp = {
source = "pulumi/gcp"
}
}
}
resource "gcp_datastream_connectionprofile" "default" {
display_name = "Spanner Source"
location = "us-central1"
connection_profile_id = "source-profile"
create_without_validation = true
spanner_profile = {
database = "projects/example-project/instances/example-instance/databases/example-database"
host = "https://spanner.example-region.rep.googleapis.com"
}
}
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.ConnectionProfileSpannerProfileArgs;
import java.util.ArrayList;
import java.util.Arrays;
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("Spanner Source")
.location("us-central1")
.connectionProfileId("source-profile")
.createWithoutValidation(true)
.spannerProfile(ConnectionProfileSpannerProfileArgs.builder()
.database("projects/example-project/instances/example-instance/databases/example-database")
.host("https://spanner.example-region.rep.googleapis.com")
.build())
.build());
}
}
resources:
default:
type: gcp:datastream:ConnectionProfile
properties:
displayName: Spanner Source
location: us-central1
connectionProfileId: source-profile
createWithoutValidation: true
spannerProfile:
database: projects/example-project/instances/example-instance/databases/example-database
host: https://spanner.example-region.rep.googleapis.com
Datastream Connection Profile Postgres Secret Manager
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const _default = new gcp.datastream.ConnectionProfile("default", {
displayName: "Postgres Source With Secret Manager",
location: "us-central1",
connectionProfileId: "source-profile",
createWithoutValidation: true,
postgresqlProfile: {
hostname: "fake-hostname",
port: 3306,
username: "fake-username",
secretManagerStoredPassword: "projects/fake-project/secrets/fake-secret/versions/1",
database: "fake-database",
},
});
import pulumi
import pulumi_gcp as gcp
default = gcp.datastream.ConnectionProfile("default",
display_name="Postgres Source With Secret Manager",
location="us-central1",
connection_profile_id="source-profile",
create_without_validation=True,
postgresql_profile={
"hostname": "fake-hostname",
"port": 3306,
"username": "fake-username",
"secret_manager_stored_password": "projects/fake-project/secrets/fake-secret/versions/1",
"database": "fake-database",
})
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 = "Postgres Source With Secret Manager",
Location = "us-central1",
ConnectionProfileId = "source-profile",
CreateWithoutValidation = true,
PostgresqlProfile = new Gcp.Datastream.Inputs.ConnectionProfilePostgresqlProfileArgs
{
Hostname = "fake-hostname",
Port = 3306,
Username = "fake-username",
SecretManagerStoredPassword = "projects/fake-project/secrets/fake-secret/versions/1",
Database = "fake-database",
},
});
});
package main
import (
"github.com/pulumi/pulumi-gcp/sdk/v9/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("Postgres Source With Secret Manager"),
Location: pulumi.String("us-central1"),
ConnectionProfileId: pulumi.String("source-profile"),
CreateWithoutValidation: pulumi.Bool(true),
PostgresqlProfile: &datastream.ConnectionProfilePostgresqlProfileArgs{
Hostname: pulumi.String("fake-hostname"),
Port: pulumi.Int(3306),
Username: pulumi.String("fake-username"),
SecretManagerStoredPassword: pulumi.String("projects/fake-project/secrets/fake-secret/versions/1"),
Database: pulumi.String("fake-database"),
},
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
gcp = {
source = "pulumi/gcp"
}
}
}
resource "gcp_datastream_connectionprofile" "default" {
display_name = "Postgres Source With Secret Manager"
location = "us-central1"
connection_profile_id = "source-profile"
create_without_validation = true
postgresql_profile = {
hostname = "fake-hostname"
port = 3306
username = "fake-username"
secret_manager_stored_password = "projects/fake-project/secrets/fake-secret/versions/1"
database = "fake-database"
}
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.datastream.ConnectionProfile;
import com.pulumi.gcp.datastream.ConnectionProfileArgs;
import com.pulumi.gcp.datastream.inputs.ConnectionProfilePostgresqlProfileArgs;
import java.util.ArrayList;
import java.util.Arrays;
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("Postgres Source With Secret Manager")
.location("us-central1")
.connectionProfileId("source-profile")
.createWithoutValidation(true)
.postgresqlProfile(ConnectionProfilePostgresqlProfileArgs.builder()
.hostname("fake-hostname")
.port(3306)
.username("fake-username")
.secretManagerStoredPassword("projects/fake-project/secrets/fake-secret/versions/1")
.database("fake-database")
.build())
.build());
}
}
resources:
default:
type: gcp:datastream:ConnectionProfile
properties:
displayName: Postgres Source With Secret Manager
location: us-central1
connectionProfileId: source-profile
createWithoutValidation: true
postgresqlProfile:
hostname: fake-hostname
port: 3306
username: fake-username
secretManagerStoredPassword: projects/fake-project/secrets/fake-secret/versions/1
database: fake-database
Datastream Connection Profile Mongodb
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const _default = new gcp.datastream.ConnectionProfile("default", {
displayName: "Mongodb Source",
location: "us-central1",
connectionProfileId: "source-profile",
mongodbProfile: {
hostAddresses: [{
hostname: "mongodb-primary.example.com",
port: 27017,
}],
replicaSet: "myReplicaSet",
username: "mongoUser",
password: "mongoPassword",
standardConnectionFormat: {},
additionalOptions: {
readPreference: "secondary",
readPreferenceTags: "nodeType:ANALYTICS",
},
},
});
import pulumi
import pulumi_gcp as gcp
default = gcp.datastream.ConnectionProfile("default",
display_name="Mongodb Source",
location="us-central1",
connection_profile_id="source-profile",
mongodb_profile={
"host_addresses": [{
"hostname": "mongodb-primary.example.com",
"port": 27017,
}],
"replica_set": "myReplicaSet",
"username": "mongoUser",
"password": "mongoPassword",
"standard_connection_format": {},
"additional_options": {
"readPreference": "secondary",
"readPreferenceTags": "nodeType:ANALYTICS",
},
})
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 = "Mongodb Source",
Location = "us-central1",
ConnectionProfileId = "source-profile",
MongodbProfile = new Gcp.Datastream.Inputs.ConnectionProfileMongodbProfileArgs
{
HostAddresses = new[]
{
new Gcp.Datastream.Inputs.ConnectionProfileMongodbProfileHostAddressArgs
{
Hostname = "mongodb-primary.example.com",
Port = 27017,
},
},
ReplicaSet = "myReplicaSet",
Username = "mongoUser",
Password = "mongoPassword",
StandardConnectionFormat = null,
AdditionalOptions =
{
{ "readPreference", "secondary" },
{ "readPreferenceTags", "nodeType:ANALYTICS" },
},
},
});
});
package main
import (
"github.com/pulumi/pulumi-gcp/sdk/v9/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("Mongodb Source"),
Location: pulumi.String("us-central1"),
ConnectionProfileId: pulumi.String("source-profile"),
MongodbProfile: &datastream.ConnectionProfileMongodbProfileArgs{
HostAddresses: datastream.ConnectionProfileMongodbProfileHostAddressArray{
&datastream.ConnectionProfileMongodbProfileHostAddressArgs{
Hostname: pulumi.String("mongodb-primary.example.com"),
Port: pulumi.Int(27017),
},
},
ReplicaSet: pulumi.String("myReplicaSet"),
Username: pulumi.String("mongoUser"),
Password: pulumi.String("mongoPassword"),
StandardConnectionFormat: &datastream.ConnectionProfileMongodbProfileStandardConnectionFormatArgs{},
AdditionalOptions: pulumi.StringMap{
"readPreference": pulumi.String("secondary"),
"readPreferenceTags": pulumi.String("nodeType:ANALYTICS"),
},
},
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
gcp = {
source = "pulumi/gcp"
}
}
}
resource "gcp_datastream_connectionprofile" "default" {
display_name = "Mongodb Source"
location = "us-central1"
connection_profile_id = "source-profile"
mongodb_profile = {
host_addresses = [{
"hostname" = "mongodb-primary.example.com"
"port" = 27017
}]
replica_set = "myReplicaSet"
username = "mongoUser"
password = "mongoPassword"
standard_connection_format = {}
additional_options = {
"readPreference" = "secondary"
"readPreferenceTags" = "nodeType:ANALYTICS"
}
}
}
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.ConnectionProfileMongodbProfileArgs;
import com.pulumi.gcp.datastream.inputs.ConnectionProfileMongodbProfileHostAddressArgs;
import com.pulumi.gcp.datastream.inputs.ConnectionProfileMongodbProfileStandardConnectionFormatArgs;
import java.util.ArrayList;
import java.util.Arrays;
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("Mongodb Source")
.location("us-central1")
.connectionProfileId("source-profile")
.mongodbProfile(ConnectionProfileMongodbProfileArgs.builder()
.hostAddresses(ConnectionProfileMongodbProfileHostAddressArgs.builder()
.hostname("mongodb-primary.example.com")
.port(27017)
.build())
.replicaSet("myReplicaSet")
.username("mongoUser")
.password("mongoPassword")
.standardConnectionFormat(ConnectionProfileMongodbProfileStandardConnectionFormatArgs.builder()
.build())
.additionalOptions(Map.ofEntries(
Map.entry("readPreference", "secondary"),
Map.entry("readPreferenceTags", "nodeType:ANALYTICS")
))
.build())
.build());
}
}
resources:
default:
type: gcp:datastream:ConnectionProfile
properties:
displayName: Mongodb Source
location: us-central1
connectionProfileId: source-profile
mongodbProfile:
hostAddresses:
- hostname: mongodb-primary.example.com
port: 27017
replicaSet: myReplicaSet
username: mongoUser
password: mongoPassword
standardConnectionFormat: {}
additionalOptions:
readPreference: secondary
readPreferenceTags: nodeType:ANALYTICS
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}}
Constructors
- ConnectionProfile(String name, {ConnectionProfileArgs? args, CustomResourceOptions? options})
-
Creates a new ConnectionProfile.
nameThe Pulumi resource name.argsArguments used to configure this ConnectionProfile. The set of arguments for ConnectionProfile.optionsResource options controlling this resource's behavior. - ConnectionProfile.reference(String urn)
- Creates a typed reference to an existing ConnectionProfile resource.
Properties
-
bigqueryProfile
↔ Output<
Map< String, dynamic> ?> -
BigQuery warehouse profile.
latefinal
-
childResources
→ Set<
Resource> -
finalinherited
-
completionSources
↔ Map<
String, IOutputCompletionSource> -
latefinalinherited
-
connectionProfileId
↔ Output<
String> -
The connection profile identifier.
latefinal
-
createWithoutValidation
↔ Output<
bool?> -
Create the connection profile without validating it.
latefinal
-
deletionPolicy
↔ Output<
String> -
Whether Terraform will be prevented from destroying the resource. Defaults to DELETE.
When a 'terraform destroy' or 'pulumi up' would delete the resource,
the command will fail if this field is set to "PREVENT" in Terraform state.
When set to "ABANDON", the command will remove the resource from Terraform
management without updating or deleting the resource in the API.
When set to "DELETE", deleting the resource is allowed.
latefinal
-
displayName
↔ Output<
String> -
Display name.
latefinal
-
effectiveLabels
↔ Output<
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.
latefinal
-
forwardSshConnectivity
↔ Output<
ConnectionProfileForwardSshConnectivity?> -
Forward SSH tunnel connectivity.
Structure is documented below.
latefinal
-
gcsProfile
↔ Output<
ConnectionProfileGcsProfile?> -
Cloud Storage bucket profile.
Structure is documented below.
latefinal
- hashCode → int
-
The hash code for this object.
no setterinherited
-
id
↔ Output<
String> -
getter/setter pairinherited
- isCustom → bool
-
Returns whether this resource is provider-managed.
no setterinherited
- isProtected → bool
-
Returns whether this resource is protected from deletion.
no setterinherited
- isRemote → bool
-
Whether this resource is registered as remote.
no setterinherited
- isResourceReference → bool
-
Whether this instance represents a resource value returned over RPC.
finalinherited
-
labels
↔ Output<
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
effectiveLabelsfor all of the labels present on the resource.latefinal -
location
↔ Output<
String> -
The name of the location this connection profile is located in.
latefinal
-
mongodbProfile
↔ Output<
ConnectionProfileMongodbProfile?> -
Configuration for connecting to a MongoDB database.
Structure is documented below.
latefinal
-
mysqlProfile
↔ Output<
ConnectionProfileMysqlProfile?> -
MySQL database profile.
Structure is documented below.
latefinal
-
name
↔ Output<
String> -
The resource's name.
latefinal
-
oracleProfile
↔ Output<
ConnectionProfileOracleProfile?> -
Oracle database profile.
Structure is documented below.
latefinal
-
postgresqlProfile
↔ Output<
ConnectionProfilePostgresqlProfile?> -
PostgreSQL database profile.
Structure is documented below.
latefinal
-
privateConnectivity
↔ Output<
ConnectionProfilePrivateConnectivity?> -
Private connectivity.
Structure is documented below.
latefinal
-
project
↔ Output<
String> -
The ID of the project in which the resource belongs.
If it is not provided, the provider project is used.
latefinal
-
pulumiLabels
↔ Output<
Map< String, String> > -
The combination of labels configured directly on the resource
and default labels configured on the provider.
latefinal
-
resourceTransforms
→ List<
ResourceTransform> -
Inherited/explicit async transforms.
no setterinherited
- runtimeType → Type
-
A representation of the runtime type of the object.
no setterinherited
-
salesforceProfile
↔ Output<
ConnectionProfileSalesforceProfile?> -
(Optional, Beta)
Salesforce profile.
Structure is documented below.
latefinal
-
spannerProfile
↔ Output<
ConnectionProfileSpannerProfile?> -
(Optional, Beta)
Spanner profile.
Structure is documented below.
latefinal
-
sqlServerProfile
↔ Output<
ConnectionProfileSqlServerProfile?> -
SQL Server database profile.
Structure is documented below.
latefinal
-
transformations
→ List<
ResourceTransformation> -
Inherited/explicit legacy transformations.
no setterinherited
-
urn
↔ Output<
String> -
latefinalinherited
Methods
-
failId(
Object error) → void -
Completes this resource ID with an error when registration fails.
inherited
-
failOutputs(
Object error) → void -
Completes all output properties with
error.inherited -
failUrn(
Object error) → void -
Completes this resource URN with an error when registration fails.
inherited
-
getProvider(
String moduleMember) → ProviderResource? -
Returns provider for
moduleMember's package, if configured.inherited -
getResourceName(
) → String -
Returns this resource's logical name.
inherited
-
getResourceType(
) → String -
Returns this resource's Pulumi type token.
inherited
-
noSuchMethod(
Invocation invocation) → dynamic -
Invoked when a nonexistent method or property is accessed.
inherited
-
registerOutput<
T> (String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output< T> -
Registers a dynamic output property for this resource.
inherited
-
resolveId(
String? value, {required bool isKnown}) → void -
Resolves the provider-assigned ID for this resource.
inherited
-
resolveOutputs(
Struct outputs) → void -
Resolves all output properties from a monitor response payload.
inherited
-
resolveUrn(
String value) → void -
Resolves this resource's URN once assigned by the engine.
inherited
-
serializeProperties(
Map< String, dynamic> properties) → Future<Struct> -
Serializes resource properties for RPC transmission.
inherited
-
toString(
) → String -
A string representation of this object.
inherited
Operators
-
operator ==(
Object other) → bool -
The equality operator.
inherited
Static Methods
-
get(
String name, Input< String> id, {ConnectionProfileState? state, CustomResourceOptions? options}) → ConnectionProfile -
Gets an existing ConnectionProfile resource's state with the given
nameandid.