Connection
A connection profile definition. To get more information about ConnectionProfile, see:
How-to Guides
Example Usage
Database Migration Service Connection Profile Cloudsql
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const project = gcp.organizations.getProject({});
const cloudsqldb = new gcp.sql.DatabaseInstance("cloudsqldb", {
name: "my-database",
databaseVersion: "MYSQL_5_7",
settings: {
tier: "db-n1-standard-1",
deletionProtectionEnabled: false,
},
deletionProtection: false,
});
const sqlClientCert = new gcp.sql.SslCert("sql_client_cert", {
commonName: "my-cert",
instance: cloudsqldb.name,
}, {
dependsOn: [cloudsqldb],
});
const sqldbUser = new gcp.sql.User("sqldb_user", {
name: "my-username",
instance: cloudsqldb.name,
password: "my-password",
}, {
dependsOn: [sqlClientCert],
});
const cloudsqlprofile = new gcp.databasemigrationservice.ConnectionProfile("cloudsqlprofile", {
location: "us-central1",
connectionProfileId: "my-fromprofileid",
displayName: "my-fromprofileid_display",
labels: {
foo: "bar",
},
mysql: {
host: cloudsqldb.ipAddresses.apply(ipAddresses => ipAddresses[0].ipAddress),
port: 3306,
username: sqldbUser.name,
password: sqldbUser.password,
ssl: {
clientKey: sqlClientCert.privateKey,
clientCertificate: sqlClientCert.cert,
caCertificate: sqlClientCert.serverCaCert,
type: "SERVER_CLIENT",
},
cloudSqlId: "my-database",
},
}, {
dependsOn: [sqldbUser],
});
const cloudsqlprofileDestination = new gcp.databasemigrationservice.ConnectionProfile("cloudsqlprofile_destination", {
location: "us-central1",
connectionProfileId: "my-toprofileid",
displayName: "my-toprofileid_displayname",
labels: {
foo: "bar",
},
cloudsql: {
settings: {
databaseVersion: "MYSQL_5_7",
userLabels: {
cloudfoo: "cloudbar",
},
tier: "db-n1-standard-1",
edition: "ENTERPRISE",
storageAutoResizeLimit: "0",
activationPolicy: "ALWAYS",
ipConfig: {
enableIpv4: true,
requireSsl: true,
},
autoStorageIncrease: true,
dataDiskType: "PD_HDD",
dataDiskSizeGb: "11",
zone: "us-central1-b",
sourceId: project.then(project => `projects/${project.projectId}/locations/us-central1/connectionProfiles/my-fromprofileid`),
rootPassword: "testpasscloudsql",
},
},
}, {
dependsOn: [cloudsqlprofile],
});Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
project = gcp.organizations.get_project()
cloudsqldb = gcp.sql.DatabaseInstance("cloudsqldb",
name="my-database",
database_version="MYSQL_5_7",
settings={
"tier": "db-n1-standard-1",
"deletion_protection_enabled": False,
},
deletion_protection=False)
sql_client_cert = gcp.sql.SslCert("sql_client_cert",
common_name="my-cert",
instance=cloudsqldb.name,
opts = pulumi.ResourceOptions(depends_on=[cloudsqldb]))
sqldb_user = gcp.sql.User("sqldb_user",
name="my-username",
instance=cloudsqldb.name,
password="my-password",
opts = pulumi.ResourceOptions(depends_on=[sql_client_cert]))
cloudsqlprofile = gcp.databasemigrationservice.ConnectionProfile("cloudsqlprofile",
location="us-central1",
connection_profile_id="my-fromprofileid",
display_name="my-fromprofileid_display",
labels={
"foo": "bar",
},
mysql={
"host": cloudsqldb.ip_addresses[0].ip_address,
"port": 3306,
"username": sqldb_user.name,
"password": sqldb_user.password,
"ssl": {
"client_key": sql_client_cert.private_key,
"client_certificate": sql_client_cert.cert,
"ca_certificate": sql_client_cert.server_ca_cert,
"type": "SERVER_CLIENT",
},
"cloud_sql_id": "my-database",
},
opts = pulumi.ResourceOptions(depends_on=[sqldb_user]))
cloudsqlprofile_destination = gcp.databasemigrationservice.ConnectionProfile("cloudsqlprofile_destination",
location="us-central1",
connection_profile_id="my-toprofileid",
display_name="my-toprofileid_displayname",
labels={
"foo": "bar",
},
cloudsql={
"settings": {
"database_version": "MYSQL_5_7",
"user_labels": {
"cloudfoo": "cloudbar",
},
"tier": "db-n1-standard-1",
"edition": "ENTERPRISE",
"storage_auto_resize_limit": "0",
"activation_policy": "ALWAYS",
"ip_config": {
"enable_ipv4": True,
"require_ssl": True,
},
"auto_storage_increase": True,
"data_disk_type": "PD_HDD",
"data_disk_size_gb": "11",
"zone": "us-central1-b",
"source_id": f"projects/{project.project_id}/locations/us-central1/connectionProfiles/my-fromprofileid",
"root_password": "testpasscloudsql",
},
},
opts = pulumi.ResourceOptions(depends_on=[cloudsqlprofile]))Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
var project = Gcp.Organizations.GetProject.Invoke();
var cloudsqldb = new Gcp.Sql.DatabaseInstance("cloudsqldb", new()
{
Name = "my-database",
DatabaseVersion = "MYSQL_5_7",
Settings = new Gcp.Sql.Inputs.DatabaseInstanceSettingsArgs
{
Tier = "db-n1-standard-1",
DeletionProtectionEnabled = false,
},
DeletionProtection = false,
});
var sqlClientCert = new Gcp.Sql.SslCert("sql_client_cert", new()
{
CommonName = "my-cert",
Instance = cloudsqldb.Name,
}, new CustomResourceOptions
{
DependsOn =
{
cloudsqldb,
},
});
var sqldbUser = new Gcp.Sql.User("sqldb_user", new()
{
Name = "my-username",
Instance = cloudsqldb.Name,
Password = "my-password",
}, new CustomResourceOptions
{
DependsOn =
{
sqlClientCert,
},
});
var cloudsqlprofile = new Gcp.DatabaseMigrationService.ConnectionProfile("cloudsqlprofile", new()
{
Location = "us-central1",
ConnectionProfileId = "my-fromprofileid",
DisplayName = "my-fromprofileid_display",
Labels =
{
{ "foo", "bar" },
},
Mysql = new Gcp.DatabaseMigrationService.Inputs.ConnectionProfileMysqlArgs
{
Host = cloudsqldb.IpAddresses.Apply(ipAddresses => ipAddresses[0].IpAddress),
Port = 3306,
Username = sqldbUser.Name,
Password = sqldbUser.Password,
Ssl = new Gcp.DatabaseMigrationService.Inputs.ConnectionProfileMysqlSslArgs
{
ClientKey = sqlClientCert.PrivateKey,
ClientCertificate = sqlClientCert.Cert,
CaCertificate = sqlClientCert.ServerCaCert,
Type = "SERVER_CLIENT",
},
CloudSqlId = "my-database",
},
}, new CustomResourceOptions
{
DependsOn =
{
sqldbUser,
},
});
var cloudsqlprofileDestination = new Gcp.DatabaseMigrationService.ConnectionProfile("cloudsqlprofile_destination", new()
{
Location = "us-central1",
ConnectionProfileId = "my-toprofileid",
DisplayName = "my-toprofileid_displayname",
Labels =
{
{ "foo", "bar" },
},
Cloudsql = new Gcp.DatabaseMigrationService.Inputs.ConnectionProfileCloudsqlArgs
{
Settings = new Gcp.DatabaseMigrationService.Inputs.ConnectionProfileCloudsqlSettingsArgs
{
DatabaseVersion = "MYSQL_5_7",
UserLabels =
{
{ "cloudfoo", "cloudbar" },
},
Tier = "db-n1-standard-1",
Edition = "ENTERPRISE",
StorageAutoResizeLimit = "0",
ActivationPolicy = "ALWAYS",
IpConfig = new Gcp.DatabaseMigrationService.Inputs.ConnectionProfileCloudsqlSettingsIpConfigArgs
{
EnableIpv4 = true,
RequireSsl = true,
},
AutoStorageIncrease = true,
DataDiskType = "PD_HDD",
DataDiskSizeGb = "11",
Zone = "us-central1-b",
SourceId = $"projects/{project.Apply(getProjectResult => getProjectResult.ProjectId)}/locations/us-central1/connectionProfiles/my-fromprofileid",
RootPassword = "testpasscloudsql",
},
},
}, new CustomResourceOptions
{
DependsOn =
{
cloudsqlprofile,
},
});
});Content copied to clipboard
package main
import (
"fmt"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/databasemigrationservice"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/organizations"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/sql"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
project, err := organizations.LookupProject(ctx, &organizations.LookupProjectArgs{}, nil)
if err != nil {
return err
}
cloudsqldb, err := sql.NewDatabaseInstance(ctx, "cloudsqldb", &sql.DatabaseInstanceArgs{
Name: pulumi.String("my-database"),
DatabaseVersion: pulumi.String("MYSQL_5_7"),
Settings: &sql.DatabaseInstanceSettingsArgs{
Tier: pulumi.String("db-n1-standard-1"),
DeletionProtectionEnabled: pulumi.Bool(false),
},
DeletionProtection: pulumi.Bool(false),
})
if err != nil {
return err
}
sqlClientCert, err := sql.NewSslCert(ctx, "sql_client_cert", &sql.SslCertArgs{
CommonName: pulumi.String("my-cert"),
Instance: cloudsqldb.Name,
}, pulumi.DependsOn([]pulumi.Resource{
cloudsqldb,
}))
if err != nil {
return err
}
sqldbUser, err := sql.NewUser(ctx, "sqldb_user", &sql.UserArgs{
Name: pulumi.String("my-username"),
Instance: cloudsqldb.Name,
Password: pulumi.String("my-password"),
}, pulumi.DependsOn([]pulumi.Resource{
sqlClientCert,
}))
if err != nil {
return err
}
cloudsqlprofile, err := databasemigrationservice.NewConnectionProfile(ctx, "cloudsqlprofile", &databasemigrationservice.ConnectionProfileArgs{
Location: pulumi.String("us-central1"),
ConnectionProfileId: pulumi.String("my-fromprofileid"),
DisplayName: pulumi.String("my-fromprofileid_display"),
Labels: pulumi.StringMap{
"foo": pulumi.String("bar"),
},
Mysql: &databasemigrationservice.ConnectionProfileMysqlArgs{
Host: cloudsqldb.IpAddresses.ApplyT(func(ipAddresses []sql.DatabaseInstanceIpAddress) (*string, error) {
return &ipAddresses[0].IpAddress, nil
}).(pulumi.StringPtrOutput),
Port: pulumi.Int(3306),
Username: sqldbUser.Name,
Password: sqldbUser.Password,
Ssl: &databasemigrationservice.ConnectionProfileMysqlSslArgs{
ClientKey: sqlClientCert.PrivateKey,
ClientCertificate: sqlClientCert.Cert,
CaCertificate: sqlClientCert.ServerCaCert,
Type: pulumi.String("SERVER_CLIENT"),
},
CloudSqlId: pulumi.String("my-database"),
},
}, pulumi.DependsOn([]pulumi.Resource{
sqldbUser,
}))
if err != nil {
return err
}
_, err = databasemigrationservice.NewConnectionProfile(ctx, "cloudsqlprofile_destination", &databasemigrationservice.ConnectionProfileArgs{
Location: pulumi.String("us-central1"),
ConnectionProfileId: pulumi.String("my-toprofileid"),
DisplayName: pulumi.String("my-toprofileid_displayname"),
Labels: pulumi.StringMap{
"foo": pulumi.String("bar"),
},
Cloudsql: &databasemigrationservice.ConnectionProfileCloudsqlArgs{
Settings: &databasemigrationservice.ConnectionProfileCloudsqlSettingsArgs{
DatabaseVersion: pulumi.String("MYSQL_5_7"),
UserLabels: pulumi.StringMap{
"cloudfoo": pulumi.String("cloudbar"),
},
Tier: pulumi.String("db-n1-standard-1"),
Edition: pulumi.String("ENTERPRISE"),
StorageAutoResizeLimit: pulumi.String("0"),
ActivationPolicy: pulumi.String("ALWAYS"),
IpConfig: &databasemigrationservice.ConnectionProfileCloudsqlSettingsIpConfigArgs{
EnableIpv4: pulumi.Bool(true),
RequireSsl: pulumi.Bool(true),
},
AutoStorageIncrease: pulumi.Bool(true),
DataDiskType: pulumi.String("PD_HDD"),
DataDiskSizeGb: pulumi.String("11"),
Zone: pulumi.String("us-central1-b"),
SourceId: pulumi.Sprintf("projects/%v/locations/us-central1/connectionProfiles/my-fromprofileid", project.ProjectId),
RootPassword: pulumi.String("testpasscloudsql"),
},
},
}, pulumi.DependsOn([]pulumi.Resource{
cloudsqlprofile,
}))
if err != nil {
return err
}
return nil
})
}Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.organizations.OrganizationsFunctions;
import com.pulumi.gcp.organizations.inputs.GetProjectArgs;
import com.pulumi.gcp.sql.DatabaseInstance;
import com.pulumi.gcp.sql.DatabaseInstanceArgs;
import com.pulumi.gcp.sql.inputs.DatabaseInstanceSettingsArgs;
import com.pulumi.gcp.sql.SslCert;
import com.pulumi.gcp.sql.SslCertArgs;
import com.pulumi.gcp.sql.User;
import com.pulumi.gcp.sql.UserArgs;
import com.pulumi.gcp.databasemigrationservice.ConnectionProfile;
import com.pulumi.gcp.databasemigrationservice.ConnectionProfileArgs;
import com.pulumi.gcp.databasemigrationservice.inputs.ConnectionProfileMysqlArgs;
import com.pulumi.gcp.databasemigrationservice.inputs.ConnectionProfileMysqlSslArgs;
import com.pulumi.gcp.databasemigrationservice.inputs.ConnectionProfileCloudsqlArgs;
import com.pulumi.gcp.databasemigrationservice.inputs.ConnectionProfileCloudsqlSettingsArgs;
import com.pulumi.gcp.databasemigrationservice.inputs.ConnectionProfileCloudsqlSettingsIpConfigArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
final var project = OrganizationsFunctions.getProject(GetProjectArgs.builder()
.build());
var cloudsqldb = new DatabaseInstance("cloudsqldb", DatabaseInstanceArgs.builder()
.name("my-database")
.databaseVersion("MYSQL_5_7")
.settings(DatabaseInstanceSettingsArgs.builder()
.tier("db-n1-standard-1")
.deletionProtectionEnabled(false)
.build())
.deletionProtection(false)
.build());
var sqlClientCert = new SslCert("sqlClientCert", SslCertArgs.builder()
.commonName("my-cert")
.instance(cloudsqldb.name())
.build(), CustomResourceOptions.builder()
.dependsOn(cloudsqldb)
.build());
var sqldbUser = new User("sqldbUser", UserArgs.builder()
.name("my-username")
.instance(cloudsqldb.name())
.password("my-password")
.build(), CustomResourceOptions.builder()
.dependsOn(sqlClientCert)
.build());
var cloudsqlprofile = new ConnectionProfile("cloudsqlprofile", ConnectionProfileArgs.builder()
.location("us-central1")
.connectionProfileId("my-fromprofileid")
.displayName("my-fromprofileid_display")
.labels(Map.of("foo", "bar"))
.mysql(ConnectionProfileMysqlArgs.builder()
.host(cloudsqldb.ipAddresses().applyValue(_ipAddresses -> _ipAddresses[0].ipAddress()))
.port(3306)
.username(sqldbUser.name())
.password(sqldbUser.password())
.ssl(ConnectionProfileMysqlSslArgs.builder()
.clientKey(sqlClientCert.privateKey())
.clientCertificate(sqlClientCert.cert())
.caCertificate(sqlClientCert.serverCaCert())
.type("SERVER_CLIENT")
.build())
.cloudSqlId("my-database")
.build())
.build(), CustomResourceOptions.builder()
.dependsOn(sqldbUser)
.build());
var cloudsqlprofileDestination = new ConnectionProfile("cloudsqlprofileDestination", ConnectionProfileArgs.builder()
.location("us-central1")
.connectionProfileId("my-toprofileid")
.displayName("my-toprofileid_displayname")
.labels(Map.of("foo", "bar"))
.cloudsql(ConnectionProfileCloudsqlArgs.builder()
.settings(ConnectionProfileCloudsqlSettingsArgs.builder()
.databaseVersion("MYSQL_5_7")
.userLabels(Map.of("cloudfoo", "cloudbar"))
.tier("db-n1-standard-1")
.edition("ENTERPRISE")
.storageAutoResizeLimit("0")
.activationPolicy("ALWAYS")
.ipConfig(ConnectionProfileCloudsqlSettingsIpConfigArgs.builder()
.enableIpv4(true)
.requireSsl(true)
.build())
.autoStorageIncrease(true)
.dataDiskType("PD_HDD")
.dataDiskSizeGb("11")
.zone("us-central1-b")
.sourceId(String.format("projects/%s/locations/us-central1/connectionProfiles/my-fromprofileid", project.projectId()))
.rootPassword("testpasscloudsql")
.build())
.build())
.build(), CustomResourceOptions.builder()
.dependsOn(cloudsqlprofile)
.build());
}
}Content copied to clipboard
resources:
cloudsqldb:
type: gcp:sql:DatabaseInstance
properties:
name: my-database
databaseVersion: MYSQL_5_7
settings:
tier: db-n1-standard-1
deletionProtectionEnabled: false
deletionProtection: false
sqlClientCert:
type: gcp:sql:SslCert
name: sql_client_cert
properties:
commonName: my-cert
instance: ${cloudsqldb.name}
options:
dependsOn:
- ${cloudsqldb}
sqldbUser:
type: gcp:sql:User
name: sqldb_user
properties:
name: my-username
instance: ${cloudsqldb.name}
password: my-password
options:
dependsOn:
- ${sqlClientCert}
cloudsqlprofile:
type: gcp:databasemigrationservice:ConnectionProfile
properties:
location: us-central1
connectionProfileId: my-fromprofileid
displayName: my-fromprofileid_display
labels:
foo: bar
mysql:
host: ${cloudsqldb.ipAddresses[0].ipAddress}
port: 3306
username: ${sqldbUser.name}
password: ${sqldbUser.password}
ssl:
clientKey: ${sqlClientCert.privateKey}
clientCertificate: ${sqlClientCert.cert}
caCertificate: ${sqlClientCert.serverCaCert}
type: SERVER_CLIENT
cloudSqlId: my-database
options:
dependsOn:
- ${sqldbUser}
cloudsqlprofileDestination:
type: gcp:databasemigrationservice:ConnectionProfile
name: cloudsqlprofile_destination
properties:
location: us-central1
connectionProfileId: my-toprofileid
displayName: my-toprofileid_displayname
labels:
foo: bar
cloudsql:
settings:
databaseVersion: MYSQL_5_7
userLabels:
cloudfoo: cloudbar
tier: db-n1-standard-1
edition: ENTERPRISE
storageAutoResizeLimit: '0'
activationPolicy: ALWAYS
ipConfig:
enableIpv4: true
requireSsl: true
autoStorageIncrease: true
dataDiskType: PD_HDD
dataDiskSizeGb: '11'
zone: us-central1-b
sourceId: projects/${project.projectId}/locations/us-central1/connectionProfiles/my-fromprofileid
rootPassword: testpasscloudsql
options:
dependsOn:
- ${cloudsqlprofile}
variables:
project:
fn::invoke:
function: gcp:organizations:getProject
arguments: {}Content copied to clipboard
Database Migration Service Connection Profile Postgres
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const postgresqldb = new gcp.sql.DatabaseInstance("postgresqldb", {
name: "my-database",
databaseVersion: "POSTGRES_12",
settings: {
tier: "db-custom-2-13312",
},
deletionProtection: false,
});
const sqlClientCert = new gcp.sql.SslCert("sql_client_cert", {
commonName: "my-cert",
instance: postgresqldb.name,
}, {
dependsOn: [postgresqldb],
});
const sqldbUser = new gcp.sql.User("sqldb_user", {
name: "my-username",
instance: postgresqldb.name,
password: "my-password",
}, {
dependsOn: [sqlClientCert],
});
const postgresprofile = new gcp.databasemigrationservice.ConnectionProfile("postgresprofile", {
location: "us-central1",
connectionProfileId: "my-profileid",
displayName: "my-profileid_display",
labels: {
foo: "bar",
},
postgresql: {
host: postgresqldb.ipAddresses.apply(ipAddresses => ipAddresses[0].ipAddress),
port: 5432,
username: sqldbUser.name,
password: sqldbUser.password,
ssl: {
clientKey: sqlClientCert.privateKey,
clientCertificate: sqlClientCert.cert,
caCertificate: sqlClientCert.serverCaCert,
type: "SERVER_CLIENT",
},
cloudSqlId: "my-database",
},
}, {
dependsOn: [sqldbUser],
});Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
postgresqldb = gcp.sql.DatabaseInstance("postgresqldb",
name="my-database",
database_version="POSTGRES_12",
settings={
"tier": "db-custom-2-13312",
},
deletion_protection=False)
sql_client_cert = gcp.sql.SslCert("sql_client_cert",
common_name="my-cert",
instance=postgresqldb.name,
opts = pulumi.ResourceOptions(depends_on=[postgresqldb]))
sqldb_user = gcp.sql.User("sqldb_user",
name="my-username",
instance=postgresqldb.name,
password="my-password",
opts = pulumi.ResourceOptions(depends_on=[sql_client_cert]))
postgresprofile = gcp.databasemigrationservice.ConnectionProfile("postgresprofile",
location="us-central1",
connection_profile_id="my-profileid",
display_name="my-profileid_display",
labels={
"foo": "bar",
},
postgresql={
"host": postgresqldb.ip_addresses[0].ip_address,
"port": 5432,
"username": sqldb_user.name,
"password": sqldb_user.password,
"ssl": {
"client_key": sql_client_cert.private_key,
"client_certificate": sql_client_cert.cert,
"ca_certificate": sql_client_cert.server_ca_cert,
"type": "SERVER_CLIENT",
},
"cloud_sql_id": "my-database",
},
opts = pulumi.ResourceOptions(depends_on=[sqldb_user]))Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
var postgresqldb = new Gcp.Sql.DatabaseInstance("postgresqldb", new()
{
Name = "my-database",
DatabaseVersion = "POSTGRES_12",
Settings = new Gcp.Sql.Inputs.DatabaseInstanceSettingsArgs
{
Tier = "db-custom-2-13312",
},
DeletionProtection = false,
});
var sqlClientCert = new Gcp.Sql.SslCert("sql_client_cert", new()
{
CommonName = "my-cert",
Instance = postgresqldb.Name,
}, new CustomResourceOptions
{
DependsOn =
{
postgresqldb,
},
});
var sqldbUser = new Gcp.Sql.User("sqldb_user", new()
{
Name = "my-username",
Instance = postgresqldb.Name,
Password = "my-password",
}, new CustomResourceOptions
{
DependsOn =
{
sqlClientCert,
},
});
var postgresprofile = new Gcp.DatabaseMigrationService.ConnectionProfile("postgresprofile", new()
{
Location = "us-central1",
ConnectionProfileId = "my-profileid",
DisplayName = "my-profileid_display",
Labels =
{
{ "foo", "bar" },
},
Postgresql = new Gcp.DatabaseMigrationService.Inputs.ConnectionProfilePostgresqlArgs
{
Host = postgresqldb.IpAddresses.Apply(ipAddresses => ipAddresses[0].IpAddress),
Port = 5432,
Username = sqldbUser.Name,
Password = sqldbUser.Password,
Ssl = new Gcp.DatabaseMigrationService.Inputs.ConnectionProfilePostgresqlSslArgs
{
ClientKey = sqlClientCert.PrivateKey,
ClientCertificate = sqlClientCert.Cert,
CaCertificate = sqlClientCert.ServerCaCert,
Type = "SERVER_CLIENT",
},
CloudSqlId = "my-database",
},
}, new CustomResourceOptions
{
DependsOn =
{
sqldbUser,
},
});
});Content copied to clipboard
package main
import (
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/databasemigrationservice"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/sql"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
postgresqldb, err := sql.NewDatabaseInstance(ctx, "postgresqldb", &sql.DatabaseInstanceArgs{
Name: pulumi.String("my-database"),
DatabaseVersion: pulumi.String("POSTGRES_12"),
Settings: &sql.DatabaseInstanceSettingsArgs{
Tier: pulumi.String("db-custom-2-13312"),
},
DeletionProtection: pulumi.Bool(false),
})
if err != nil {
return err
}
sqlClientCert, err := sql.NewSslCert(ctx, "sql_client_cert", &sql.SslCertArgs{
CommonName: pulumi.String("my-cert"),
Instance: postgresqldb.Name,
}, pulumi.DependsOn([]pulumi.Resource{
postgresqldb,
}))
if err != nil {
return err
}
sqldbUser, err := sql.NewUser(ctx, "sqldb_user", &sql.UserArgs{
Name: pulumi.String("my-username"),
Instance: postgresqldb.Name,
Password: pulumi.String("my-password"),
}, pulumi.DependsOn([]pulumi.Resource{
sqlClientCert,
}))
if err != nil {
return err
}
_, err = databasemigrationservice.NewConnectionProfile(ctx, "postgresprofile", &databasemigrationservice.ConnectionProfileArgs{
Location: pulumi.String("us-central1"),
ConnectionProfileId: pulumi.String("my-profileid"),
DisplayName: pulumi.String("my-profileid_display"),
Labels: pulumi.StringMap{
"foo": pulumi.String("bar"),
},
Postgresql: &databasemigrationservice.ConnectionProfilePostgresqlArgs{
Host: postgresqldb.IpAddresses.ApplyT(func(ipAddresses []sql.DatabaseInstanceIpAddress) (*string, error) {
return &ipAddresses[0].IpAddress, nil
}).(pulumi.StringPtrOutput),
Port: pulumi.Int(5432),
Username: sqldbUser.Name,
Password: sqldbUser.Password,
Ssl: &databasemigrationservice.ConnectionProfilePostgresqlSslArgs{
ClientKey: sqlClientCert.PrivateKey,
ClientCertificate: sqlClientCert.Cert,
CaCertificate: sqlClientCert.ServerCaCert,
Type: pulumi.String("SERVER_CLIENT"),
},
CloudSqlId: pulumi.String("my-database"),
},
}, pulumi.DependsOn([]pulumi.Resource{
sqldbUser,
}))
if err != nil {
return err
}
return nil
})
}Content copied to clipboard
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.SslCert;
import com.pulumi.gcp.sql.SslCertArgs;
import com.pulumi.gcp.sql.User;
import com.pulumi.gcp.sql.UserArgs;
import com.pulumi.gcp.databasemigrationservice.ConnectionProfile;
import com.pulumi.gcp.databasemigrationservice.ConnectionProfileArgs;
import com.pulumi.gcp.databasemigrationservice.inputs.ConnectionProfilePostgresqlArgs;
import com.pulumi.gcp.databasemigrationservice.inputs.ConnectionProfilePostgresqlSslArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var postgresqldb = new DatabaseInstance("postgresqldb", DatabaseInstanceArgs.builder()
.name("my-database")
.databaseVersion("POSTGRES_12")
.settings(DatabaseInstanceSettingsArgs.builder()
.tier("db-custom-2-13312")
.build())
.deletionProtection(false)
.build());
var sqlClientCert = new SslCert("sqlClientCert", SslCertArgs.builder()
.commonName("my-cert")
.instance(postgresqldb.name())
.build(), CustomResourceOptions.builder()
.dependsOn(postgresqldb)
.build());
var sqldbUser = new User("sqldbUser", UserArgs.builder()
.name("my-username")
.instance(postgresqldb.name())
.password("my-password")
.build(), CustomResourceOptions.builder()
.dependsOn(sqlClientCert)
.build());
var postgresprofile = new ConnectionProfile("postgresprofile", ConnectionProfileArgs.builder()
.location("us-central1")
.connectionProfileId("my-profileid")
.displayName("my-profileid_display")
.labels(Map.of("foo", "bar"))
.postgresql(ConnectionProfilePostgresqlArgs.builder()
.host(postgresqldb.ipAddresses().applyValue(_ipAddresses -> _ipAddresses[0].ipAddress()))
.port(5432)
.username(sqldbUser.name())
.password(sqldbUser.password())
.ssl(ConnectionProfilePostgresqlSslArgs.builder()
.clientKey(sqlClientCert.privateKey())
.clientCertificate(sqlClientCert.cert())
.caCertificate(sqlClientCert.serverCaCert())
.type("SERVER_CLIENT")
.build())
.cloudSqlId("my-database")
.build())
.build(), CustomResourceOptions.builder()
.dependsOn(sqldbUser)
.build());
}
}Content copied to clipboard
resources:
postgresqldb:
type: gcp:sql:DatabaseInstance
properties:
name: my-database
databaseVersion: POSTGRES_12
settings:
tier: db-custom-2-13312
deletionProtection: false
sqlClientCert:
type: gcp:sql:SslCert
name: sql_client_cert
properties:
commonName: my-cert
instance: ${postgresqldb.name}
options:
dependsOn:
- ${postgresqldb}
sqldbUser:
type: gcp:sql:User
name: sqldb_user
properties:
name: my-username
instance: ${postgresqldb.name}
password: my-password
options:
dependsOn:
- ${sqlClientCert}
postgresprofile:
type: gcp:databasemigrationservice:ConnectionProfile
properties:
location: us-central1
connectionProfileId: my-profileid
displayName: my-profileid_display
labels:
foo: bar
postgresql:
host: ${postgresqldb.ipAddresses[0].ipAddress}
port: 5432
username: ${sqldbUser.name}
password: ${sqldbUser.password}
ssl:
clientKey: ${sqlClientCert.privateKey}
clientCertificate: ${sqlClientCert.cert}
caCertificate: ${sqlClientCert.serverCaCert}
type: SERVER_CLIENT
cloudSqlId: my-database
options:
dependsOn:
- ${sqldbUser}Content copied to clipboard
Database Migration Service Connection Profile Postgres No Ssl
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const postgresqldb = new gcp.sql.DatabaseInstance("postgresqldb", {
name: "my-database",
databaseVersion: "POSTGRES_12",
settings: {
tier: "db-custom-2-13312",
},
deletionProtection: false,
});
const sqlClientCert = new gcp.sql.SslCert("sql_client_cert", {
commonName: "my-cert",
instance: postgresqldb.name,
}, {
dependsOn: [postgresqldb],
});
const sqldbUser = new gcp.sql.User("sqldb_user", {
name: "my-username",
instance: postgresqldb.name,
password: "my-password",
}, {
dependsOn: [sqlClientCert],
});
const postgresprofile = new gcp.databasemigrationservice.ConnectionProfile("postgresprofile", {
location: "us-central1",
connectionProfileId: "my-profileid",
displayName: "my-profileid_display",
labels: {
foo: "bar",
},
postgresql: {
host: postgresqldb.ipAddresses.apply(ipAddresses => ipAddresses[0].ipAddress),
port: 5432,
username: sqldbUser.name,
password: sqldbUser.password,
ssl: {
type: "NONE",
},
cloudSqlId: "my-database",
},
}, {
dependsOn: [sqldbUser],
});Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
postgresqldb = gcp.sql.DatabaseInstance("postgresqldb",
name="my-database",
database_version="POSTGRES_12",
settings={
"tier": "db-custom-2-13312",
},
deletion_protection=False)
sql_client_cert = gcp.sql.SslCert("sql_client_cert",
common_name="my-cert",
instance=postgresqldb.name,
opts = pulumi.ResourceOptions(depends_on=[postgresqldb]))
sqldb_user = gcp.sql.User("sqldb_user",
name="my-username",
instance=postgresqldb.name,
password="my-password",
opts = pulumi.ResourceOptions(depends_on=[sql_client_cert]))
postgresprofile = gcp.databasemigrationservice.ConnectionProfile("postgresprofile",
location="us-central1",
connection_profile_id="my-profileid",
display_name="my-profileid_display",
labels={
"foo": "bar",
},
postgresql={
"host": postgresqldb.ip_addresses[0].ip_address,
"port": 5432,
"username": sqldb_user.name,
"password": sqldb_user.password,
"ssl": {
"type": "NONE",
},
"cloud_sql_id": "my-database",
},
opts = pulumi.ResourceOptions(depends_on=[sqldb_user]))Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
var postgresqldb = new Gcp.Sql.DatabaseInstance("postgresqldb", new()
{
Name = "my-database",
DatabaseVersion = "POSTGRES_12",
Settings = new Gcp.Sql.Inputs.DatabaseInstanceSettingsArgs
{
Tier = "db-custom-2-13312",
},
DeletionProtection = false,
});
var sqlClientCert = new Gcp.Sql.SslCert("sql_client_cert", new()
{
CommonName = "my-cert",
Instance = postgresqldb.Name,
}, new CustomResourceOptions
{
DependsOn =
{
postgresqldb,
},
});
var sqldbUser = new Gcp.Sql.User("sqldb_user", new()
{
Name = "my-username",
Instance = postgresqldb.Name,
Password = "my-password",
}, new CustomResourceOptions
{
DependsOn =
{
sqlClientCert,
},
});
var postgresprofile = new Gcp.DatabaseMigrationService.ConnectionProfile("postgresprofile", new()
{
Location = "us-central1",
ConnectionProfileId = "my-profileid",
DisplayName = "my-profileid_display",
Labels =
{
{ "foo", "bar" },
},
Postgresql = new Gcp.DatabaseMigrationService.Inputs.ConnectionProfilePostgresqlArgs
{
Host = postgresqldb.IpAddresses.Apply(ipAddresses => ipAddresses[0].IpAddress),
Port = 5432,
Username = sqldbUser.Name,
Password = sqldbUser.Password,
Ssl = new Gcp.DatabaseMigrationService.Inputs.ConnectionProfilePostgresqlSslArgs
{
Type = "NONE",
},
CloudSqlId = "my-database",
},
}, new CustomResourceOptions
{
DependsOn =
{
sqldbUser,
},
});
});Content copied to clipboard
package main
import (
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/databasemigrationservice"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/sql"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
postgresqldb, err := sql.NewDatabaseInstance(ctx, "postgresqldb", &sql.DatabaseInstanceArgs{
Name: pulumi.String("my-database"),
DatabaseVersion: pulumi.String("POSTGRES_12"),
Settings: &sql.DatabaseInstanceSettingsArgs{
Tier: pulumi.String("db-custom-2-13312"),
},
DeletionProtection: pulumi.Bool(false),
})
if err != nil {
return err
}
sqlClientCert, err := sql.NewSslCert(ctx, "sql_client_cert", &sql.SslCertArgs{
CommonName: pulumi.String("my-cert"),
Instance: postgresqldb.Name,
}, pulumi.DependsOn([]pulumi.Resource{
postgresqldb,
}))
if err != nil {
return err
}
sqldbUser, err := sql.NewUser(ctx, "sqldb_user", &sql.UserArgs{
Name: pulumi.String("my-username"),
Instance: postgresqldb.Name,
Password: pulumi.String("my-password"),
}, pulumi.DependsOn([]pulumi.Resource{
sqlClientCert,
}))
if err != nil {
return err
}
_, err = databasemigrationservice.NewConnectionProfile(ctx, "postgresprofile", &databasemigrationservice.ConnectionProfileArgs{
Location: pulumi.String("us-central1"),
ConnectionProfileId: pulumi.String("my-profileid"),
DisplayName: pulumi.String("my-profileid_display"),
Labels: pulumi.StringMap{
"foo": pulumi.String("bar"),
},
Postgresql: &databasemigrationservice.ConnectionProfilePostgresqlArgs{
Host: postgresqldb.IpAddresses.ApplyT(func(ipAddresses []sql.DatabaseInstanceIpAddress) (*string, error) {
return &ipAddresses[0].IpAddress, nil
}).(pulumi.StringPtrOutput),
Port: pulumi.Int(5432),
Username: sqldbUser.Name,
Password: sqldbUser.Password,
Ssl: &databasemigrationservice.ConnectionProfilePostgresqlSslArgs{
Type: pulumi.String("NONE"),
},
CloudSqlId: pulumi.String("my-database"),
},
}, pulumi.DependsOn([]pulumi.Resource{
sqldbUser,
}))
if err != nil {
return err
}
return nil
})
}Content copied to clipboard
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.SslCert;
import com.pulumi.gcp.sql.SslCertArgs;
import com.pulumi.gcp.sql.User;
import com.pulumi.gcp.sql.UserArgs;
import com.pulumi.gcp.databasemigrationservice.ConnectionProfile;
import com.pulumi.gcp.databasemigrationservice.ConnectionProfileArgs;
import com.pulumi.gcp.databasemigrationservice.inputs.ConnectionProfilePostgresqlArgs;
import com.pulumi.gcp.databasemigrationservice.inputs.ConnectionProfilePostgresqlSslArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var postgresqldb = new DatabaseInstance("postgresqldb", DatabaseInstanceArgs.builder()
.name("my-database")
.databaseVersion("POSTGRES_12")
.settings(DatabaseInstanceSettingsArgs.builder()
.tier("db-custom-2-13312")
.build())
.deletionProtection(false)
.build());
var sqlClientCert = new SslCert("sqlClientCert", SslCertArgs.builder()
.commonName("my-cert")
.instance(postgresqldb.name())
.build(), CustomResourceOptions.builder()
.dependsOn(postgresqldb)
.build());
var sqldbUser = new User("sqldbUser", UserArgs.builder()
.name("my-username")
.instance(postgresqldb.name())
.password("my-password")
.build(), CustomResourceOptions.builder()
.dependsOn(sqlClientCert)
.build());
var postgresprofile = new ConnectionProfile("postgresprofile", ConnectionProfileArgs.builder()
.location("us-central1")
.connectionProfileId("my-profileid")
.displayName("my-profileid_display")
.labels(Map.of("foo", "bar"))
.postgresql(ConnectionProfilePostgresqlArgs.builder()
.host(postgresqldb.ipAddresses().applyValue(_ipAddresses -> _ipAddresses[0].ipAddress()))
.port(5432)
.username(sqldbUser.name())
.password(sqldbUser.password())
.ssl(ConnectionProfilePostgresqlSslArgs.builder()
.type("NONE")
.build())
.cloudSqlId("my-database")
.build())
.build(), CustomResourceOptions.builder()
.dependsOn(sqldbUser)
.build());
}
}Content copied to clipboard
resources:
postgresqldb:
type: gcp:sql:DatabaseInstance
properties:
name: my-database
databaseVersion: POSTGRES_12
settings:
tier: db-custom-2-13312
deletionProtection: false
sqlClientCert:
type: gcp:sql:SslCert
name: sql_client_cert
properties:
commonName: my-cert
instance: ${postgresqldb.name}
options:
dependsOn:
- ${postgresqldb}
sqldbUser:
type: gcp:sql:User
name: sqldb_user
properties:
name: my-username
instance: ${postgresqldb.name}
password: my-password
options:
dependsOn:
- ${sqlClientCert}
postgresprofile:
type: gcp:databasemigrationservice:ConnectionProfile
properties:
location: us-central1
connectionProfileId: my-profileid
displayName: my-profileid_display
labels:
foo: bar
postgresql:
host: ${postgresqldb.ipAddresses[0].ipAddress}
port: 5432
username: ${sqldbUser.name}
password: ${sqldbUser.password}
ssl:
type: NONE
cloudSqlId: my-database
options:
dependsOn:
- ${sqldbUser}Content copied to clipboard
Database Migration Service Connection Profile Postgres Required Ssl
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const postgresqldb = new gcp.sql.DatabaseInstance("postgresqldb", {
name: "my-database",
databaseVersion: "POSTGRES_12",
settings: {
tier: "db-custom-2-13312",
},
deletionProtection: false,
});
const sqlClientCert = new gcp.sql.SslCert("sql_client_cert", {
commonName: "my-cert",
instance: postgresqldb.name,
}, {
dependsOn: [postgresqldb],
});
const sqldbUser = new gcp.sql.User("sqldb_user", {
name: "my-username",
instance: postgresqldb.name,
password: "my-password",
}, {
dependsOn: [sqlClientCert],
});
const postgresprofile = new gcp.databasemigrationservice.ConnectionProfile("postgresprofile", {
location: "us-central1",
connectionProfileId: "my-profileid",
displayName: "my-profileid_display",
labels: {
foo: "bar",
},
postgresql: {
host: postgresqldb.ipAddresses.apply(ipAddresses => ipAddresses[0].ipAddress),
port: 5432,
username: sqldbUser.name,
password: sqldbUser.password,
ssl: {
type: "REQUIRED",
},
cloudSqlId: "my-database",
},
}, {
dependsOn: [sqldbUser],
});Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
postgresqldb = gcp.sql.DatabaseInstance("postgresqldb",
name="my-database",
database_version="POSTGRES_12",
settings={
"tier": "db-custom-2-13312",
},
deletion_protection=False)
sql_client_cert = gcp.sql.SslCert("sql_client_cert",
common_name="my-cert",
instance=postgresqldb.name,
opts = pulumi.ResourceOptions(depends_on=[postgresqldb]))
sqldb_user = gcp.sql.User("sqldb_user",
name="my-username",
instance=postgresqldb.name,
password="my-password",
opts = pulumi.ResourceOptions(depends_on=[sql_client_cert]))
postgresprofile = gcp.databasemigrationservice.ConnectionProfile("postgresprofile",
location="us-central1",
connection_profile_id="my-profileid",
display_name="my-profileid_display",
labels={
"foo": "bar",
},
postgresql={
"host": postgresqldb.ip_addresses[0].ip_address,
"port": 5432,
"username": sqldb_user.name,
"password": sqldb_user.password,
"ssl": {
"type": "REQUIRED",
},
"cloud_sql_id": "my-database",
},
opts = pulumi.ResourceOptions(depends_on=[sqldb_user]))Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
var postgresqldb = new Gcp.Sql.DatabaseInstance("postgresqldb", new()
{
Name = "my-database",
DatabaseVersion = "POSTGRES_12",
Settings = new Gcp.Sql.Inputs.DatabaseInstanceSettingsArgs
{
Tier = "db-custom-2-13312",
},
DeletionProtection = false,
});
var sqlClientCert = new Gcp.Sql.SslCert("sql_client_cert", new()
{
CommonName = "my-cert",
Instance = postgresqldb.Name,
}, new CustomResourceOptions
{
DependsOn =
{
postgresqldb,
},
});
var sqldbUser = new Gcp.Sql.User("sqldb_user", new()
{
Name = "my-username",
Instance = postgresqldb.Name,
Password = "my-password",
}, new CustomResourceOptions
{
DependsOn =
{
sqlClientCert,
},
});
var postgresprofile = new Gcp.DatabaseMigrationService.ConnectionProfile("postgresprofile", new()
{
Location = "us-central1",
ConnectionProfileId = "my-profileid",
DisplayName = "my-profileid_display",
Labels =
{
{ "foo", "bar" },
},
Postgresql = new Gcp.DatabaseMigrationService.Inputs.ConnectionProfilePostgresqlArgs
{
Host = postgresqldb.IpAddresses.Apply(ipAddresses => ipAddresses[0].IpAddress),
Port = 5432,
Username = sqldbUser.Name,
Password = sqldbUser.Password,
Ssl = new Gcp.DatabaseMigrationService.Inputs.ConnectionProfilePostgresqlSslArgs
{
Type = "REQUIRED",
},
CloudSqlId = "my-database",
},
}, new CustomResourceOptions
{
DependsOn =
{
sqldbUser,
},
});
});Content copied to clipboard
package main
import (
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/databasemigrationservice"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/sql"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
postgresqldb, err := sql.NewDatabaseInstance(ctx, "postgresqldb", &sql.DatabaseInstanceArgs{
Name: pulumi.String("my-database"),
DatabaseVersion: pulumi.String("POSTGRES_12"),
Settings: &sql.DatabaseInstanceSettingsArgs{
Tier: pulumi.String("db-custom-2-13312"),
},
DeletionProtection: pulumi.Bool(false),
})
if err != nil {
return err
}
sqlClientCert, err := sql.NewSslCert(ctx, "sql_client_cert", &sql.SslCertArgs{
CommonName: pulumi.String("my-cert"),
Instance: postgresqldb.Name,
}, pulumi.DependsOn([]pulumi.Resource{
postgresqldb,
}))
if err != nil {
return err
}
sqldbUser, err := sql.NewUser(ctx, "sqldb_user", &sql.UserArgs{
Name: pulumi.String("my-username"),
Instance: postgresqldb.Name,
Password: pulumi.String("my-password"),
}, pulumi.DependsOn([]pulumi.Resource{
sqlClientCert,
}))
if err != nil {
return err
}
_, err = databasemigrationservice.NewConnectionProfile(ctx, "postgresprofile", &databasemigrationservice.ConnectionProfileArgs{
Location: pulumi.String("us-central1"),
ConnectionProfileId: pulumi.String("my-profileid"),
DisplayName: pulumi.String("my-profileid_display"),
Labels: pulumi.StringMap{
"foo": pulumi.String("bar"),
},
Postgresql: &databasemigrationservice.ConnectionProfilePostgresqlArgs{
Host: postgresqldb.IpAddresses.ApplyT(func(ipAddresses []sql.DatabaseInstanceIpAddress) (*string, error) {
return &ipAddresses[0].IpAddress, nil
}).(pulumi.StringPtrOutput),
Port: pulumi.Int(5432),
Username: sqldbUser.Name,
Password: sqldbUser.Password,
Ssl: &databasemigrationservice.ConnectionProfilePostgresqlSslArgs{
Type: pulumi.String("REQUIRED"),
},
CloudSqlId: pulumi.String("my-database"),
},
}, pulumi.DependsOn([]pulumi.Resource{
sqldbUser,
}))
if err != nil {
return err
}
return nil
})
}Content copied to clipboard
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.SslCert;
import com.pulumi.gcp.sql.SslCertArgs;
import com.pulumi.gcp.sql.User;
import com.pulumi.gcp.sql.UserArgs;
import com.pulumi.gcp.databasemigrationservice.ConnectionProfile;
import com.pulumi.gcp.databasemigrationservice.ConnectionProfileArgs;
import com.pulumi.gcp.databasemigrationservice.inputs.ConnectionProfilePostgresqlArgs;
import com.pulumi.gcp.databasemigrationservice.inputs.ConnectionProfilePostgresqlSslArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var postgresqldb = new DatabaseInstance("postgresqldb", DatabaseInstanceArgs.builder()
.name("my-database")
.databaseVersion("POSTGRES_12")
.settings(DatabaseInstanceSettingsArgs.builder()
.tier("db-custom-2-13312")
.build())
.deletionProtection(false)
.build());
var sqlClientCert = new SslCert("sqlClientCert", SslCertArgs.builder()
.commonName("my-cert")
.instance(postgresqldb.name())
.build(), CustomResourceOptions.builder()
.dependsOn(postgresqldb)
.build());
var sqldbUser = new User("sqldbUser", UserArgs.builder()
.name("my-username")
.instance(postgresqldb.name())
.password("my-password")
.build(), CustomResourceOptions.builder()
.dependsOn(sqlClientCert)
.build());
var postgresprofile = new ConnectionProfile("postgresprofile", ConnectionProfileArgs.builder()
.location("us-central1")
.connectionProfileId("my-profileid")
.displayName("my-profileid_display")
.labels(Map.of("foo", "bar"))
.postgresql(ConnectionProfilePostgresqlArgs.builder()
.host(postgresqldb.ipAddresses().applyValue(_ipAddresses -> _ipAddresses[0].ipAddress()))
.port(5432)
.username(sqldbUser.name())
.password(sqldbUser.password())
.ssl(ConnectionProfilePostgresqlSslArgs.builder()
.type("REQUIRED")
.build())
.cloudSqlId("my-database")
.build())
.build(), CustomResourceOptions.builder()
.dependsOn(sqldbUser)
.build());
}
}Content copied to clipboard
resources:
postgresqldb:
type: gcp:sql:DatabaseInstance
properties:
name: my-database
databaseVersion: POSTGRES_12
settings:
tier: db-custom-2-13312
deletionProtection: false
sqlClientCert:
type: gcp:sql:SslCert
name: sql_client_cert
properties:
commonName: my-cert
instance: ${postgresqldb.name}
options:
dependsOn:
- ${postgresqldb}
sqldbUser:
type: gcp:sql:User
name: sqldb_user
properties:
name: my-username
instance: ${postgresqldb.name}
password: my-password
options:
dependsOn:
- ${sqlClientCert}
postgresprofile:
type: gcp:databasemigrationservice:ConnectionProfile
properties:
location: us-central1
connectionProfileId: my-profileid
displayName: my-profileid_display
labels:
foo: bar
postgresql:
host: ${postgresqldb.ipAddresses[0].ipAddress}
port: 5432
username: ${sqldbUser.name}
password: ${sqldbUser.password}
ssl:
type: REQUIRED
cloudSqlId: my-database
options:
dependsOn:
- ${sqldbUser}Content copied to clipboard
Database Migration Service Connection Profile Oracle
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const oracleprofile = new gcp.databasemigrationservice.ConnectionProfile("oracleprofile", {
location: "us-central1",
connectionProfileId: "my-profileid",
displayName: "my-profileid_display",
labels: {
foo: "bar",
},
oracle: {
host: "host",
port: 1521,
username: "username",
password: "password",
databaseService: "dbprovider",
staticServiceIpConnectivity: {},
},
});Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
oracleprofile = gcp.databasemigrationservice.ConnectionProfile("oracleprofile",
location="us-central1",
connection_profile_id="my-profileid",
display_name="my-profileid_display",
labels={
"foo": "bar",
},
oracle={
"host": "host",
"port": 1521,
"username": "username",
"password": "password",
"database_service": "dbprovider",
"static_service_ip_connectivity": {},
})Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
var oracleprofile = new Gcp.DatabaseMigrationService.ConnectionProfile("oracleprofile", new()
{
Location = "us-central1",
ConnectionProfileId = "my-profileid",
DisplayName = "my-profileid_display",
Labels =
{
{ "foo", "bar" },
},
Oracle = new Gcp.DatabaseMigrationService.Inputs.ConnectionProfileOracleArgs
{
Host = "host",
Port = 1521,
Username = "username",
Password = "password",
DatabaseService = "dbprovider",
StaticServiceIpConnectivity = null,
},
});
});Content copied to clipboard
package main
import (
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/databasemigrationservice"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := databasemigrationservice.NewConnectionProfile(ctx, "oracleprofile", &databasemigrationservice.ConnectionProfileArgs{
Location: pulumi.String("us-central1"),
ConnectionProfileId: pulumi.String("my-profileid"),
DisplayName: pulumi.String("my-profileid_display"),
Labels: pulumi.StringMap{
"foo": pulumi.String("bar"),
},
Oracle: &databasemigrationservice.ConnectionProfileOracleArgs{
Host: pulumi.String("host"),
Port: pulumi.Int(1521),
Username: pulumi.String("username"),
Password: pulumi.String("password"),
DatabaseService: pulumi.String("dbprovider"),
StaticServiceIpConnectivity: &databasemigrationservice.ConnectionProfileOracleStaticServiceIpConnectivityArgs{},
},
})
if err != nil {
return err
}
return nil
})
}Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.databasemigrationservice.ConnectionProfile;
import com.pulumi.gcp.databasemigrationservice.ConnectionProfileArgs;
import com.pulumi.gcp.databasemigrationservice.inputs.ConnectionProfileOracleArgs;
import com.pulumi.gcp.databasemigrationservice.inputs.ConnectionProfileOracleStaticServiceIpConnectivityArgs;
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 oracleprofile = new ConnectionProfile("oracleprofile", ConnectionProfileArgs.builder()
.location("us-central1")
.connectionProfileId("my-profileid")
.displayName("my-profileid_display")
.labels(Map.of("foo", "bar"))
.oracle(ConnectionProfileOracleArgs.builder()
.host("host")
.port(1521)
.username("username")
.password("password")
.databaseService("dbprovider")
.staticServiceIpConnectivity(ConnectionProfileOracleStaticServiceIpConnectivityArgs.builder()
.build())
.build())
.build());
}
}Content copied to clipboard
resources:
oracleprofile:
type: gcp:databasemigrationservice:ConnectionProfile
properties:
location: us-central1
connectionProfileId: my-profileid
displayName: my-profileid_display
labels:
foo: bar
oracle:
host: host
port: 1521
username: username
password: password
databaseService: dbprovider
staticServiceIpConnectivity: {}Content copied to clipboard
Database Migration Service Connection Profile Alloydb
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const project = gcp.organizations.getProject({});
const _default = new gcp.compute.Network("default", {name: "vpc-network"});
const privateIpAlloc = new gcp.compute.GlobalAddress("private_ip_alloc", {
name: "private-ip-alloc",
addressType: "INTERNAL",
purpose: "VPC_PEERING",
prefixLength: 16,
network: _default.id,
});
const vpcConnection = new gcp.servicenetworking.Connection("vpc_connection", {
network: _default.id,
service: "servicenetworking.googleapis.com",
reservedPeeringRanges: [privateIpAlloc.name],
});
const alloydbprofile = new gcp.databasemigrationservice.ConnectionProfile("alloydbprofile", {
location: "us-central1",
connectionProfileId: "my-profileid",
displayName: "my-profileid_display",
labels: {
foo: "bar",
},
alloydb: {
clusterId: "tf-test-dbmsalloycluster_85840",
settings: {
initialUser: {
user: "alloyuser_60302",
password: "alloypass_22811",
},
vpcNetwork: _default.id,
labels: {
alloyfoo: "alloybar",
},
primaryInstanceSettings: {
id: "priminstid",
machineConfig: {
cpuCount: 2,
},
databaseFlags: {},
labels: {
alloysinstfoo: "allowinstbar",
},
},
},
},
}, {
dependsOn: [vpcConnection],
});Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
project = gcp.organizations.get_project()
default = gcp.compute.Network("default", name="vpc-network")
private_ip_alloc = gcp.compute.GlobalAddress("private_ip_alloc",
name="private-ip-alloc",
address_type="INTERNAL",
purpose="VPC_PEERING",
prefix_length=16,
network=default.id)
vpc_connection = gcp.servicenetworking.Connection("vpc_connection",
network=default.id,
service="servicenetworking.googleapis.com",
reserved_peering_ranges=[private_ip_alloc.name])
alloydbprofile = gcp.databasemigrationservice.ConnectionProfile("alloydbprofile",
location="us-central1",
connection_profile_id="my-profileid",
display_name="my-profileid_display",
labels={
"foo": "bar",
},
alloydb={
"cluster_id": "tf-test-dbmsalloycluster_85840",
"settings": {
"initial_user": {
"user": "alloyuser_60302",
"password": "alloypass_22811",
},
"vpc_network": default.id,
"labels": {
"alloyfoo": "alloybar",
},
"primary_instance_settings": {
"id": "priminstid",
"machine_config": {
"cpu_count": 2,
},
"database_flags": {},
"labels": {
"alloysinstfoo": "allowinstbar",
},
},
},
},
opts = pulumi.ResourceOptions(depends_on=[vpc_connection]))Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
var project = Gcp.Organizations.GetProject.Invoke();
var @default = new Gcp.Compute.Network("default", new()
{
Name = "vpc-network",
});
var privateIpAlloc = new Gcp.Compute.GlobalAddress("private_ip_alloc", new()
{
Name = "private-ip-alloc",
AddressType = "INTERNAL",
Purpose = "VPC_PEERING",
PrefixLength = 16,
Network = @default.Id,
});
var vpcConnection = new Gcp.ServiceNetworking.Connection("vpc_connection", new()
{
Network = @default.Id,
Service = "servicenetworking.googleapis.com",
ReservedPeeringRanges = new[]
{
privateIpAlloc.Name,
},
});
var alloydbprofile = new Gcp.DatabaseMigrationService.ConnectionProfile("alloydbprofile", new()
{
Location = "us-central1",
ConnectionProfileId = "my-profileid",
DisplayName = "my-profileid_display",
Labels =
{
{ "foo", "bar" },
},
Alloydb = new Gcp.DatabaseMigrationService.Inputs.ConnectionProfileAlloydbArgs
{
ClusterId = "tf-test-dbmsalloycluster_85840",
Settings = new Gcp.DatabaseMigrationService.Inputs.ConnectionProfileAlloydbSettingsArgs
{
InitialUser = new Gcp.DatabaseMigrationService.Inputs.ConnectionProfileAlloydbSettingsInitialUserArgs
{
User = "alloyuser_60302",
Password = "alloypass_22811",
},
VpcNetwork = @default.Id,
Labels =
{
{ "alloyfoo", "alloybar" },
},
PrimaryInstanceSettings = new Gcp.DatabaseMigrationService.Inputs.ConnectionProfileAlloydbSettingsPrimaryInstanceSettingsArgs
{
Id = "priminstid",
MachineConfig = new Gcp.DatabaseMigrationService.Inputs.ConnectionProfileAlloydbSettingsPrimaryInstanceSettingsMachineConfigArgs
{
CpuCount = 2,
},
DatabaseFlags = null,
Labels =
{
{ "alloysinstfoo", "allowinstbar" },
},
},
},
},
}, new CustomResourceOptions
{
DependsOn =
{
vpcConnection,
},
});
});Content copied to clipboard
package main
import (
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/databasemigrationservice"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/organizations"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/servicenetworking"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := organizations.LookupProject(ctx, &organizations.LookupProjectArgs{}, nil)
if err != nil {
return err
}
_default, err := compute.NewNetwork(ctx, "default", &compute.NetworkArgs{
Name: pulumi.String("vpc-network"),
})
if err != nil {
return err
}
privateIpAlloc, err := compute.NewGlobalAddress(ctx, "private_ip_alloc", &compute.GlobalAddressArgs{
Name: pulumi.String("private-ip-alloc"),
AddressType: pulumi.String("INTERNAL"),
Purpose: pulumi.String("VPC_PEERING"),
PrefixLength: pulumi.Int(16),
Network: _default.ID(),
})
if err != nil {
return err
}
vpcConnection, err := servicenetworking.NewConnection(ctx, "vpc_connection", &servicenetworking.ConnectionArgs{
Network: _default.ID(),
Service: pulumi.String("servicenetworking.googleapis.com"),
ReservedPeeringRanges: pulumi.StringArray{
privateIpAlloc.Name,
},
})
if err != nil {
return err
}
_, err = databasemigrationservice.NewConnectionProfile(ctx, "alloydbprofile", &databasemigrationservice.ConnectionProfileArgs{
Location: pulumi.String("us-central1"),
ConnectionProfileId: pulumi.String("my-profileid"),
DisplayName: pulumi.String("my-profileid_display"),
Labels: pulumi.StringMap{
"foo": pulumi.String("bar"),
},
Alloydb: &databasemigrationservice.ConnectionProfileAlloydbArgs{
ClusterId: pulumi.String("tf-test-dbmsalloycluster_85840"),
Settings: &databasemigrationservice.ConnectionProfileAlloydbSettingsArgs{
InitialUser: &databasemigrationservice.ConnectionProfileAlloydbSettingsInitialUserArgs{
User: pulumi.String("alloyuser_60302"),
Password: pulumi.String("alloypass_22811"),
},
VpcNetwork: _default.ID(),
Labels: pulumi.StringMap{
"alloyfoo": pulumi.String("alloybar"),
},
PrimaryInstanceSettings: &databasemigrationservice.ConnectionProfileAlloydbSettingsPrimaryInstanceSettingsArgs{
Id: pulumi.String("priminstid"),
MachineConfig: &databasemigrationservice.ConnectionProfileAlloydbSettingsPrimaryInstanceSettingsMachineConfigArgs{
CpuCount: pulumi.Int(2),
},
DatabaseFlags: pulumi.StringMap{},
Labels: pulumi.StringMap{
"alloysinstfoo": pulumi.String("allowinstbar"),
},
},
},
},
}, pulumi.DependsOn([]pulumi.Resource{
vpcConnection,
}))
if err != nil {
return err
}
return nil
})
}Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.organizations.OrganizationsFunctions;
import com.pulumi.gcp.organizations.inputs.GetProjectArgs;
import com.pulumi.gcp.compute.Network;
import com.pulumi.gcp.compute.NetworkArgs;
import com.pulumi.gcp.compute.GlobalAddress;
import com.pulumi.gcp.compute.GlobalAddressArgs;
import com.pulumi.gcp.servicenetworking.Connection;
import com.pulumi.gcp.servicenetworking.ConnectionArgs;
import com.pulumi.gcp.databasemigrationservice.ConnectionProfile;
import com.pulumi.gcp.databasemigrationservice.ConnectionProfileArgs;
import com.pulumi.gcp.databasemigrationservice.inputs.ConnectionProfileAlloydbArgs;
import com.pulumi.gcp.databasemigrationservice.inputs.ConnectionProfileAlloydbSettingsArgs;
import com.pulumi.gcp.databasemigrationservice.inputs.ConnectionProfileAlloydbSettingsInitialUserArgs;
import com.pulumi.gcp.databasemigrationservice.inputs.ConnectionProfileAlloydbSettingsPrimaryInstanceSettingsArgs;
import com.pulumi.gcp.databasemigrationservice.inputs.ConnectionProfileAlloydbSettingsPrimaryInstanceSettingsMachineConfigArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
final var project = OrganizationsFunctions.getProject(GetProjectArgs.builder()
.build());
var default_ = new Network("default", NetworkArgs.builder()
.name("vpc-network")
.build());
var privateIpAlloc = new GlobalAddress("privateIpAlloc", GlobalAddressArgs.builder()
.name("private-ip-alloc")
.addressType("INTERNAL")
.purpose("VPC_PEERING")
.prefixLength(16)
.network(default_.id())
.build());
var vpcConnection = new Connection("vpcConnection", ConnectionArgs.builder()
.network(default_.id())
.service("servicenetworking.googleapis.com")
.reservedPeeringRanges(privateIpAlloc.name())
.build());
var alloydbprofile = new ConnectionProfile("alloydbprofile", ConnectionProfileArgs.builder()
.location("us-central1")
.connectionProfileId("my-profileid")
.displayName("my-profileid_display")
.labels(Map.of("foo", "bar"))
.alloydb(ConnectionProfileAlloydbArgs.builder()
.clusterId("tf-test-dbmsalloycluster_85840")
.settings(ConnectionProfileAlloydbSettingsArgs.builder()
.initialUser(ConnectionProfileAlloydbSettingsInitialUserArgs.builder()
.user("alloyuser_60302")
.password("alloypass_22811")
.build())
.vpcNetwork(default_.id())
.labels(Map.of("alloyfoo", "alloybar"))
.primaryInstanceSettings(ConnectionProfileAlloydbSettingsPrimaryInstanceSettingsArgs.builder()
.id("priminstid")
.machineConfig(ConnectionProfileAlloydbSettingsPrimaryInstanceSettingsMachineConfigArgs.builder()
.cpuCount(2)
.build())
.databaseFlags(Map.ofEntries(
))
.labels(Map.of("alloysinstfoo", "allowinstbar"))
.build())
.build())
.build())
.build(), CustomResourceOptions.builder()
.dependsOn(vpcConnection)
.build());
}
}Content copied to clipboard
resources:
default:
type: gcp:compute:Network
properties:
name: vpc-network
privateIpAlloc:
type: gcp:compute:GlobalAddress
name: private_ip_alloc
properties:
name: private-ip-alloc
addressType: INTERNAL
purpose: VPC_PEERING
prefixLength: 16
network: ${default.id}
vpcConnection:
type: gcp:servicenetworking:Connection
name: vpc_connection
properties:
network: ${default.id}
service: servicenetworking.googleapis.com
reservedPeeringRanges:
- ${privateIpAlloc.name}
alloydbprofile:
type: gcp:databasemigrationservice:ConnectionProfile
properties:
location: us-central1
connectionProfileId: my-profileid
displayName: my-profileid_display
labels:
foo: bar
alloydb:
clusterId: tf-test-dbmsalloycluster_85840
settings:
initialUser:
user: alloyuser_60302
password: alloypass_22811
vpcNetwork: ${default.id}
labels:
alloyfoo: alloybar
primaryInstanceSettings:
id: priminstid
machineConfig:
cpuCount: 2
databaseFlags: {}
labels:
alloysinstfoo: allowinstbar
options:
dependsOn:
- ${vpcConnection}
variables:
project:
fn::invoke:
function: gcp:organizations:getProject
arguments: {}Content copied to clipboard
Database Migration Service Connection Profile Existing Mysql
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const project = gcp.organizations.getProject({});
const destinationCsql = new gcp.sql.DatabaseInstance("destination_csql", {
name: "destination-csql",
databaseVersion: "MYSQL_5_7",
settings: {
tier: "db-n1-standard-1",
deletionProtectionEnabled: false,
},
deletionProtection: false,
});
const existing_mysql = new gcp.databasemigrationservice.ConnectionProfile("existing-mysql", {
location: "us-central1",
connectionProfileId: "destination-cp",
displayName: "destination-cp_display",
labels: {
foo: "bar",
},
mysql: {
cloudSqlId: "destination-csql",
},
}, {
dependsOn: [destinationCsql],
});Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
project = gcp.organizations.get_project()
destination_csql = gcp.sql.DatabaseInstance("destination_csql",
name="destination-csql",
database_version="MYSQL_5_7",
settings={
"tier": "db-n1-standard-1",
"deletion_protection_enabled": False,
},
deletion_protection=False)
existing_mysql = gcp.databasemigrationservice.ConnectionProfile("existing-mysql",
location="us-central1",
connection_profile_id="destination-cp",
display_name="destination-cp_display",
labels={
"foo": "bar",
},
mysql={
"cloud_sql_id": "destination-csql",
},
opts = pulumi.ResourceOptions(depends_on=[destination_csql]))Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
var project = Gcp.Organizations.GetProject.Invoke();
var destinationCsql = new Gcp.Sql.DatabaseInstance("destination_csql", new()
{
Name = "destination-csql",
DatabaseVersion = "MYSQL_5_7",
Settings = new Gcp.Sql.Inputs.DatabaseInstanceSettingsArgs
{
Tier = "db-n1-standard-1",
DeletionProtectionEnabled = false,
},
DeletionProtection = false,
});
var existing_mysql = new Gcp.DatabaseMigrationService.ConnectionProfile("existing-mysql", new()
{
Location = "us-central1",
ConnectionProfileId = "destination-cp",
DisplayName = "destination-cp_display",
Labels =
{
{ "foo", "bar" },
},
Mysql = new Gcp.DatabaseMigrationService.Inputs.ConnectionProfileMysqlArgs
{
CloudSqlId = "destination-csql",
},
}, new CustomResourceOptions
{
DependsOn =
{
destinationCsql,
},
});
});Content copied to clipboard
package main
import (
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/databasemigrationservice"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/organizations"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/sql"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := organizations.LookupProject(ctx, &organizations.LookupProjectArgs{}, nil)
if err != nil {
return err
}
destinationCsql, err := sql.NewDatabaseInstance(ctx, "destination_csql", &sql.DatabaseInstanceArgs{
Name: pulumi.String("destination-csql"),
DatabaseVersion: pulumi.String("MYSQL_5_7"),
Settings: &sql.DatabaseInstanceSettingsArgs{
Tier: pulumi.String("db-n1-standard-1"),
DeletionProtectionEnabled: pulumi.Bool(false),
},
DeletionProtection: pulumi.Bool(false),
})
if err != nil {
return err
}
_, err = databasemigrationservice.NewConnectionProfile(ctx, "existing-mysql", &databasemigrationservice.ConnectionProfileArgs{
Location: pulumi.String("us-central1"),
ConnectionProfileId: pulumi.String("destination-cp"),
DisplayName: pulumi.String("destination-cp_display"),
Labels: pulumi.StringMap{
"foo": pulumi.String("bar"),
},
Mysql: &databasemigrationservice.ConnectionProfileMysqlArgs{
CloudSqlId: pulumi.String("destination-csql"),
},
}, pulumi.DependsOn([]pulumi.Resource{
destinationCsql,
}))
if err != nil {
return err
}
return nil
})
}Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.organizations.OrganizationsFunctions;
import com.pulumi.gcp.organizations.inputs.GetProjectArgs;
import com.pulumi.gcp.sql.DatabaseInstance;
import com.pulumi.gcp.sql.DatabaseInstanceArgs;
import com.pulumi.gcp.sql.inputs.DatabaseInstanceSettingsArgs;
import com.pulumi.gcp.databasemigrationservice.ConnectionProfile;
import com.pulumi.gcp.databasemigrationservice.ConnectionProfileArgs;
import com.pulumi.gcp.databasemigrationservice.inputs.ConnectionProfileMysqlArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
final var project = OrganizationsFunctions.getProject(GetProjectArgs.builder()
.build());
var destinationCsql = new DatabaseInstance("destinationCsql", DatabaseInstanceArgs.builder()
.name("destination-csql")
.databaseVersion("MYSQL_5_7")
.settings(DatabaseInstanceSettingsArgs.builder()
.tier("db-n1-standard-1")
.deletionProtectionEnabled(false)
.build())
.deletionProtection(false)
.build());
var existing_mysql = new ConnectionProfile("existing-mysql", ConnectionProfileArgs.builder()
.location("us-central1")
.connectionProfileId("destination-cp")
.displayName("destination-cp_display")
.labels(Map.of("foo", "bar"))
.mysql(ConnectionProfileMysqlArgs.builder()
.cloudSqlId("destination-csql")
.build())
.build(), CustomResourceOptions.builder()
.dependsOn(destinationCsql)
.build());
}
}Content copied to clipboard
resources:
destinationCsql:
type: gcp:sql:DatabaseInstance
name: destination_csql
properties:
name: destination-csql
databaseVersion: MYSQL_5_7
settings:
tier: db-n1-standard-1
deletionProtectionEnabled: false
deletionProtection: false
existing-mysql:
type: gcp:databasemigrationservice:ConnectionProfile
properties:
location: us-central1
connectionProfileId: destination-cp
displayName: destination-cp_display
labels:
foo: bar
mysql:
cloudSqlId: destination-csql
options:
dependsOn:
- ${destinationCsql}
variables:
project:
fn::invoke:
function: gcp:organizations:getProject
arguments: {}Content copied to clipboard
Database Migration Service Connection Profile Existing Postgres
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const project = gcp.organizations.getProject({});
const destinationCsql = new gcp.sql.DatabaseInstance("destination_csql", {
name: "destination-csql",
databaseVersion: "POSTGRES_15",
settings: {
tier: "db-custom-2-13312",
deletionProtectionEnabled: false,
},
deletionProtection: false,
});
const existing_psql = new gcp.databasemigrationservice.ConnectionProfile("existing-psql", {
location: "us-central1",
connectionProfileId: "destination-cp",
displayName: "destination-cp_display",
labels: {
foo: "bar",
},
postgresql: {
cloudSqlId: "destination-csql",
},
}, {
dependsOn: [destinationCsql],
});Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
project = gcp.organizations.get_project()
destination_csql = gcp.sql.DatabaseInstance("destination_csql",
name="destination-csql",
database_version="POSTGRES_15",
settings={
"tier": "db-custom-2-13312",
"deletion_protection_enabled": False,
},
deletion_protection=False)
existing_psql = gcp.databasemigrationservice.ConnectionProfile("existing-psql",
location="us-central1",
connection_profile_id="destination-cp",
display_name="destination-cp_display",
labels={
"foo": "bar",
},
postgresql={
"cloud_sql_id": "destination-csql",
},
opts = pulumi.ResourceOptions(depends_on=[destination_csql]))Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
var project = Gcp.Organizations.GetProject.Invoke();
var destinationCsql = new Gcp.Sql.DatabaseInstance("destination_csql", new()
{
Name = "destination-csql",
DatabaseVersion = "POSTGRES_15",
Settings = new Gcp.Sql.Inputs.DatabaseInstanceSettingsArgs
{
Tier = "db-custom-2-13312",
DeletionProtectionEnabled = false,
},
DeletionProtection = false,
});
var existing_psql = new Gcp.DatabaseMigrationService.ConnectionProfile("existing-psql", new()
{
Location = "us-central1",
ConnectionProfileId = "destination-cp",
DisplayName = "destination-cp_display",
Labels =
{
{ "foo", "bar" },
},
Postgresql = new Gcp.DatabaseMigrationService.Inputs.ConnectionProfilePostgresqlArgs
{
CloudSqlId = "destination-csql",
},
}, new CustomResourceOptions
{
DependsOn =
{
destinationCsql,
},
});
});Content copied to clipboard
package main
import (
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/databasemigrationservice"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/organizations"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/sql"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := organizations.LookupProject(ctx, &organizations.LookupProjectArgs{}, nil)
if err != nil {
return err
}
destinationCsql, err := sql.NewDatabaseInstance(ctx, "destination_csql", &sql.DatabaseInstanceArgs{
Name: pulumi.String("destination-csql"),
DatabaseVersion: pulumi.String("POSTGRES_15"),
Settings: &sql.DatabaseInstanceSettingsArgs{
Tier: pulumi.String("db-custom-2-13312"),
DeletionProtectionEnabled: pulumi.Bool(false),
},
DeletionProtection: pulumi.Bool(false),
})
if err != nil {
return err
}
_, err = databasemigrationservice.NewConnectionProfile(ctx, "existing-psql", &databasemigrationservice.ConnectionProfileArgs{
Location: pulumi.String("us-central1"),
ConnectionProfileId: pulumi.String("destination-cp"),
DisplayName: pulumi.String("destination-cp_display"),
Labels: pulumi.StringMap{
"foo": pulumi.String("bar"),
},
Postgresql: &databasemigrationservice.ConnectionProfilePostgresqlArgs{
CloudSqlId: pulumi.String("destination-csql"),
},
}, pulumi.DependsOn([]pulumi.Resource{
destinationCsql,
}))
if err != nil {
return err
}
return nil
})
}Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.organizations.OrganizationsFunctions;
import com.pulumi.gcp.organizations.inputs.GetProjectArgs;
import com.pulumi.gcp.sql.DatabaseInstance;
import com.pulumi.gcp.sql.DatabaseInstanceArgs;
import com.pulumi.gcp.sql.inputs.DatabaseInstanceSettingsArgs;
import com.pulumi.gcp.databasemigrationservice.ConnectionProfile;
import com.pulumi.gcp.databasemigrationservice.ConnectionProfileArgs;
import com.pulumi.gcp.databasemigrationservice.inputs.ConnectionProfilePostgresqlArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
final var project = OrganizationsFunctions.getProject(GetProjectArgs.builder()
.build());
var destinationCsql = new DatabaseInstance("destinationCsql", DatabaseInstanceArgs.builder()
.name("destination-csql")
.databaseVersion("POSTGRES_15")
.settings(DatabaseInstanceSettingsArgs.builder()
.tier("db-custom-2-13312")
.deletionProtectionEnabled(false)
.build())
.deletionProtection(false)
.build());
var existing_psql = new ConnectionProfile("existing-psql", ConnectionProfileArgs.builder()
.location("us-central1")
.connectionProfileId("destination-cp")
.displayName("destination-cp_display")
.labels(Map.of("foo", "bar"))
.postgresql(ConnectionProfilePostgresqlArgs.builder()
.cloudSqlId("destination-csql")
.build())
.build(), CustomResourceOptions.builder()
.dependsOn(destinationCsql)
.build());
}
}Content copied to clipboard
resources:
destinationCsql:
type: gcp:sql:DatabaseInstance
name: destination_csql
properties:
name: destination-csql
databaseVersion: POSTGRES_15
settings:
tier: db-custom-2-13312
deletionProtectionEnabled: false
deletionProtection: false
existing-psql:
type: gcp:databasemigrationservice:ConnectionProfile
properties:
location: us-central1
connectionProfileId: destination-cp
displayName: destination-cp_display
labels:
foo: bar
postgresql:
cloudSqlId: destination-csql
options:
dependsOn:
- ${destinationCsql}
variables:
project:
fn::invoke:
function: gcp:organizations:getProject
arguments: {}Content copied to clipboard
Database Migration Service Connection Profile Existing Alloydb
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const project = gcp.organizations.getProject({});
const _default = new gcp.compute.Network("default", {name: "destination-alloydb"});
const destinationAlloydb = new gcp.alloydb.Cluster("destination_alloydb", {
clusterId: "destination-alloydb",
location: "us-central1",
networkConfig: {
network: _default.id,
},
databaseVersion: "POSTGRES_15",
initialUser: {
user: "destination-alloydb",
password: "destination-alloydb",
},
});
const privateIpAlloc = new gcp.compute.GlobalAddress("private_ip_alloc", {
name: "destination-alloydb",
addressType: "INTERNAL",
purpose: "VPC_PEERING",
prefixLength: 16,
network: _default.id,
});
const vpcConnection = new gcp.servicenetworking.Connection("vpc_connection", {
network: _default.id,
service: "servicenetworking.googleapis.com",
reservedPeeringRanges: [privateIpAlloc.name],
});
const destinationAlloydbPrimary = new gcp.alloydb.Instance("destination_alloydb_primary", {
cluster: destinationAlloydb.name,
instanceId: "destination-alloydb-primary",
instanceType: "PRIMARY",
}, {
dependsOn: [vpcConnection],
});
const existing_alloydb = new gcp.databasemigrationservice.ConnectionProfile("existing-alloydb", {
location: "us-central1",
connectionProfileId: "destination-cp",
displayName: "destination-cp_display",
labels: {
foo: "bar",
},
postgresql: {
alloydbClusterId: "destination-alloydb",
},
}, {
dependsOn: [
destinationAlloydb,
destinationAlloydbPrimary,
],
});Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
project = gcp.organizations.get_project()
default = gcp.compute.Network("default", name="destination-alloydb")
destination_alloydb = gcp.alloydb.Cluster("destination_alloydb",
cluster_id="destination-alloydb",
location="us-central1",
network_config={
"network": default.id,
},
database_version="POSTGRES_15",
initial_user={
"user": "destination-alloydb",
"password": "destination-alloydb",
})
private_ip_alloc = gcp.compute.GlobalAddress("private_ip_alloc",
name="destination-alloydb",
address_type="INTERNAL",
purpose="VPC_PEERING",
prefix_length=16,
network=default.id)
vpc_connection = gcp.servicenetworking.Connection("vpc_connection",
network=default.id,
service="servicenetworking.googleapis.com",
reserved_peering_ranges=[private_ip_alloc.name])
destination_alloydb_primary = gcp.alloydb.Instance("destination_alloydb_primary",
cluster=destination_alloydb.name,
instance_id="destination-alloydb-primary",
instance_type="PRIMARY",
opts = pulumi.ResourceOptions(depends_on=[vpc_connection]))
existing_alloydb = gcp.databasemigrationservice.ConnectionProfile("existing-alloydb",
location="us-central1",
connection_profile_id="destination-cp",
display_name="destination-cp_display",
labels={
"foo": "bar",
},
postgresql={
"alloydb_cluster_id": "destination-alloydb",
},
opts = pulumi.ResourceOptions(depends_on=[
destination_alloydb,
destination_alloydb_primary,
]))Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
var project = Gcp.Organizations.GetProject.Invoke();
var @default = new Gcp.Compute.Network("default", new()
{
Name = "destination-alloydb",
});
var destinationAlloydb = new Gcp.Alloydb.Cluster("destination_alloydb", new()
{
ClusterId = "destination-alloydb",
Location = "us-central1",
NetworkConfig = new Gcp.Alloydb.Inputs.ClusterNetworkConfigArgs
{
Network = @default.Id,
},
DatabaseVersion = "POSTGRES_15",
InitialUser = new Gcp.Alloydb.Inputs.ClusterInitialUserArgs
{
User = "destination-alloydb",
Password = "destination-alloydb",
},
});
var privateIpAlloc = new Gcp.Compute.GlobalAddress("private_ip_alloc", new()
{
Name = "destination-alloydb",
AddressType = "INTERNAL",
Purpose = "VPC_PEERING",
PrefixLength = 16,
Network = @default.Id,
});
var vpcConnection = new Gcp.ServiceNetworking.Connection("vpc_connection", new()
{
Network = @default.Id,
Service = "servicenetworking.googleapis.com",
ReservedPeeringRanges = new[]
{
privateIpAlloc.Name,
},
});
var destinationAlloydbPrimary = new Gcp.Alloydb.Instance("destination_alloydb_primary", new()
{
Cluster = destinationAlloydb.Name,
InstanceId = "destination-alloydb-primary",
InstanceType = "PRIMARY",
}, new CustomResourceOptions
{
DependsOn =
{
vpcConnection,
},
});
var existing_alloydb = new Gcp.DatabaseMigrationService.ConnectionProfile("existing-alloydb", new()
{
Location = "us-central1",
ConnectionProfileId = "destination-cp",
DisplayName = "destination-cp_display",
Labels =
{
{ "foo", "bar" },
},
Postgresql = new Gcp.DatabaseMigrationService.Inputs.ConnectionProfilePostgresqlArgs
{
AlloydbClusterId = "destination-alloydb",
},
}, new CustomResourceOptions
{
DependsOn =
{
destinationAlloydb,
destinationAlloydbPrimary,
},
});
});Content copied to clipboard
package main
import (
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/alloydb"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/databasemigrationservice"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/organizations"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/servicenetworking"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := organizations.LookupProject(ctx, &organizations.LookupProjectArgs{}, nil)
if err != nil {
return err
}
_default, err := compute.NewNetwork(ctx, "default", &compute.NetworkArgs{
Name: pulumi.String("destination-alloydb"),
})
if err != nil {
return err
}
destinationAlloydb, err := alloydb.NewCluster(ctx, "destination_alloydb", &alloydb.ClusterArgs{
ClusterId: pulumi.String("destination-alloydb"),
Location: pulumi.String("us-central1"),
NetworkConfig: &alloydb.ClusterNetworkConfigArgs{
Network: _default.ID(),
},
DatabaseVersion: pulumi.String("POSTGRES_15"),
InitialUser: &alloydb.ClusterInitialUserArgs{
User: pulumi.String("destination-alloydb"),
Password: pulumi.String("destination-alloydb"),
},
})
if err != nil {
return err
}
privateIpAlloc, err := compute.NewGlobalAddress(ctx, "private_ip_alloc", &compute.GlobalAddressArgs{
Name: pulumi.String("destination-alloydb"),
AddressType: pulumi.String("INTERNAL"),
Purpose: pulumi.String("VPC_PEERING"),
PrefixLength: pulumi.Int(16),
Network: _default.ID(),
})
if err != nil {
return err
}
vpcConnection, err := servicenetworking.NewConnection(ctx, "vpc_connection", &servicenetworking.ConnectionArgs{
Network: _default.ID(),
Service: pulumi.String("servicenetworking.googleapis.com"),
ReservedPeeringRanges: pulumi.StringArray{
privateIpAlloc.Name,
},
})
if err != nil {
return err
}
destinationAlloydbPrimary, err := alloydb.NewInstance(ctx, "destination_alloydb_primary", &alloydb.InstanceArgs{
Cluster: destinationAlloydb.Name,
InstanceId: pulumi.String("destination-alloydb-primary"),
InstanceType: pulumi.String("PRIMARY"),
}, pulumi.DependsOn([]pulumi.Resource{
vpcConnection,
}))
if err != nil {
return err
}
_, err = databasemigrationservice.NewConnectionProfile(ctx, "existing-alloydb", &databasemigrationservice.ConnectionProfileArgs{
Location: pulumi.String("us-central1"),
ConnectionProfileId: pulumi.String("destination-cp"),
DisplayName: pulumi.String("destination-cp_display"),
Labels: pulumi.StringMap{
"foo": pulumi.String("bar"),
},
Postgresql: &databasemigrationservice.ConnectionProfilePostgresqlArgs{
AlloydbClusterId: pulumi.String("destination-alloydb"),
},
}, pulumi.DependsOn([]pulumi.Resource{
destinationAlloydb,
destinationAlloydbPrimary,
}))
if err != nil {
return err
}
return nil
})
}Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.organizations.OrganizationsFunctions;
import com.pulumi.gcp.organizations.inputs.GetProjectArgs;
import com.pulumi.gcp.compute.Network;
import com.pulumi.gcp.compute.NetworkArgs;
import com.pulumi.gcp.alloydb.Cluster;
import com.pulumi.gcp.alloydb.ClusterArgs;
import com.pulumi.gcp.alloydb.inputs.ClusterNetworkConfigArgs;
import com.pulumi.gcp.alloydb.inputs.ClusterInitialUserArgs;
import com.pulumi.gcp.compute.GlobalAddress;
import com.pulumi.gcp.compute.GlobalAddressArgs;
import com.pulumi.gcp.servicenetworking.Connection;
import com.pulumi.gcp.servicenetworking.ConnectionArgs;
import com.pulumi.gcp.alloydb.Instance;
import com.pulumi.gcp.alloydb.InstanceArgs;
import com.pulumi.gcp.databasemigrationservice.ConnectionProfile;
import com.pulumi.gcp.databasemigrationservice.ConnectionProfileArgs;
import com.pulumi.gcp.databasemigrationservice.inputs.ConnectionProfilePostgresqlArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
final var project = OrganizationsFunctions.getProject(GetProjectArgs.builder()
.build());
var default_ = new Network("default", NetworkArgs.builder()
.name("destination-alloydb")
.build());
var destinationAlloydb = new Cluster("destinationAlloydb", ClusterArgs.builder()
.clusterId("destination-alloydb")
.location("us-central1")
.networkConfig(ClusterNetworkConfigArgs.builder()
.network(default_.id())
.build())
.databaseVersion("POSTGRES_15")
.initialUser(ClusterInitialUserArgs.builder()
.user("destination-alloydb")
.password("destination-alloydb")
.build())
.build());
var privateIpAlloc = new GlobalAddress("privateIpAlloc", GlobalAddressArgs.builder()
.name("destination-alloydb")
.addressType("INTERNAL")
.purpose("VPC_PEERING")
.prefixLength(16)
.network(default_.id())
.build());
var vpcConnection = new Connection("vpcConnection", ConnectionArgs.builder()
.network(default_.id())
.service("servicenetworking.googleapis.com")
.reservedPeeringRanges(privateIpAlloc.name())
.build());
var destinationAlloydbPrimary = new Instance("destinationAlloydbPrimary", InstanceArgs.builder()
.cluster(destinationAlloydb.name())
.instanceId("destination-alloydb-primary")
.instanceType("PRIMARY")
.build(), CustomResourceOptions.builder()
.dependsOn(vpcConnection)
.build());
var existing_alloydb = new ConnectionProfile("existing-alloydb", ConnectionProfileArgs.builder()
.location("us-central1")
.connectionProfileId("destination-cp")
.displayName("destination-cp_display")
.labels(Map.of("foo", "bar"))
.postgresql(ConnectionProfilePostgresqlArgs.builder()
.alloydbClusterId("destination-alloydb")
.build())
.build(), CustomResourceOptions.builder()
.dependsOn(
destinationAlloydb,
destinationAlloydbPrimary)
.build());
}
}Content copied to clipboard
resources:
destinationAlloydb:
type: gcp:alloydb:Cluster
name: destination_alloydb
properties:
clusterId: destination-alloydb
location: us-central1
networkConfig:
network: ${default.id}
databaseVersion: POSTGRES_15
initialUser:
user: destination-alloydb
password: destination-alloydb
destinationAlloydbPrimary:
type: gcp:alloydb:Instance
name: destination_alloydb_primary
properties:
cluster: ${destinationAlloydb.name}
instanceId: destination-alloydb-primary
instanceType: PRIMARY
options:
dependsOn:
- ${vpcConnection}
privateIpAlloc:
type: gcp:compute:GlobalAddress
name: private_ip_alloc
properties:
name: destination-alloydb
addressType: INTERNAL
purpose: VPC_PEERING
prefixLength: 16
network: ${default.id}
vpcConnection:
type: gcp:servicenetworking:Connection
name: vpc_connection
properties:
network: ${default.id}
service: servicenetworking.googleapis.com
reservedPeeringRanges:
- ${privateIpAlloc.name}
default:
type: gcp:compute:Network
properties:
name: destination-alloydb
existing-alloydb:
type: gcp:databasemigrationservice:ConnectionProfile
properties:
location: us-central1
connectionProfileId: destination-cp
displayName: destination-cp_display
labels:
foo: bar
postgresql:
alloydbClusterId: destination-alloydb
options:
dependsOn:
- ${destinationAlloydb}
- ${destinationAlloydbPrimary}
variables:
project:
fn::invoke:
function: gcp:organizations:getProject
arguments: {}Content copied to clipboard
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 thepulumi importcommand, ConnectionProfile can be imported using one of the formats above. For example:
$ pulumi import gcp:databasemigrationservice/connectionProfile:ConnectionProfile default projects/{{project}}/locations/{{location}}/connectionProfiles/{{connection_profile_id}}Content copied to clipboard
$ pulumi import gcp:databasemigrationservice/connectionProfile:ConnectionProfile default {{project}}/{{location}}/{{connection_profile_id}}Content copied to clipboard
$ pulumi import gcp:databasemigrationservice/connectionProfile:ConnectionProfile default {{location}}/{{connection_profile_id}}Content copied to clipboard
Properties
Link copied to clipboard
Specifies required connection parameters, and the parameters required to create an AlloyDB destination cluster. Structure is documented below.
Link copied to clipboard
Specifies required connection parameters, and, optionally, the parameters required to create a Cloud SQL destination database instance. Structure is documented below.
Link copied to clipboard
The ID of the connection profile.
Link copied to clipboard
Output only. The timestamp when the resource was created. A timestamp in RFC3339 UTC 'Zulu' format, accurate to nanoseconds. Example: '2014-10-02T15:01:23.045123456Z'.
Link copied to clipboard
The database provider.
Link copied to clipboard
The connection profile display name.
Link copied to clipboard
All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
Link copied to clipboard
Output only. The error details in case of state FAILED. Structure is documented below.
Link copied to clipboard
The resource labels for connection profile to use to annotate any related underlying resources such as Compute Engine VMs. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effective_labels for all of the labels present on the resource.
Link copied to clipboard
Specifies connection parameters required specifically for MySQL databases. Structure is documented below.
Link copied to clipboard
Specifies connection parameters required specifically for Oracle databases. Structure is documented below.
Link copied to clipboard
Specifies connection parameters required specifically for PostgreSQL databases. Structure is documented below.
Link copied to clipboard
Link copied to clipboard
The combination of labels configured directly on the resource and default labels configured on the provider.
Link copied to clipboard
Link copied to clipboard