gcp.databasemigrationservice.ConnectionProfile

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],
});

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]))

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

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,
        },
    });

});

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());

    }
}

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: {}

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],
});

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]))

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

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,
        },
    });

});

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());

    }
}

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}

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],
});

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]))

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