pulumi-gcp 6.68.0a1698127103__py3-none-any.whl → 6.68.0a1698199636__py3-none-any.whl

pulumi_gcp/databasemigrationservice/_inputs.py

@@ -44,9 +44,15 @@ class ConnectionProfileAlloydbArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             cluster_id: pulumi.Input[str],
+             cluster_id: Optional[pulumi.Input[str]] = None,
              settings: Optional[pulumi.Input['ConnectionProfileAlloydbSettingsArgs']] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if cluster_id is None and 'clusterId' in kwargs:
+            cluster_id = kwargs['clusterId']
+        if cluster_id is None:
+            raise TypeError("Missing 'cluster_id' argument")
+
         _setter("cluster_id", cluster_id)
         if settings is not None:
             _setter("settings", settings)
@@ -103,11 +109,23 @@ class ConnectionProfileAlloydbSettingsArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             initial_user: pulumi.Input['ConnectionProfileAlloydbSettingsInitialUserArgs'],
-             vpc_network: pulumi.Input[str],
+             initial_user: Optional[pulumi.Input['ConnectionProfileAlloydbSettingsInitialUserArgs']] = None,
+             vpc_network: Optional[pulumi.Input[str]] = None,
              labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
              primary_instance_settings: Optional[pulumi.Input['ConnectionProfileAlloydbSettingsPrimaryInstanceSettingsArgs']] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if initial_user is None and 'initialUser' in kwargs:
+            initial_user = kwargs['initialUser']
+        if initial_user is None:
+            raise TypeError("Missing 'initial_user' argument")
+        if vpc_network is None and 'vpcNetwork' in kwargs:
+            vpc_network = kwargs['vpcNetwork']
+        if vpc_network is None:
+            raise TypeError("Missing 'vpc_network' argument")
+        if primary_instance_settings is None and 'primaryInstanceSettings' in kwargs:
+            primary_instance_settings = kwargs['primaryInstanceSettings']
+
         _setter("initial_user", initial_user)
         _setter("vpc_network", vpc_network)
         if labels is not None:
@@ -189,10 +207,18 @@ class ConnectionProfileAlloydbSettingsInitialUserArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             password: pulumi.Input[str],
-             user: pulumi.Input[str],
+             password: Optional[pulumi.Input[str]] = None,
+             user: Optional[pulumi.Input[str]] = None,
              password_set: Optional[pulumi.Input[bool]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if password is None:
+            raise TypeError("Missing 'password' argument")
+        if user is None:
+            raise TypeError("Missing 'user' argument")
+        if password_set is None and 'passwordSet' in kwargs:
+            password_set = kwargs['passwordSet']
+
         _setter("password", password)
         _setter("user", user)
         if password_set is not None:
@@ -265,12 +291,24 @@ class ConnectionProfileAlloydbSettingsPrimaryInstanceSettingsArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             id: pulumi.Input[str],
-             machine_config: pulumi.Input['ConnectionProfileAlloydbSettingsPrimaryInstanceSettingsMachineConfigArgs'],
+             id: Optional[pulumi.Input[str]] = None,
+             machine_config: Optional[pulumi.Input['ConnectionProfileAlloydbSettingsPrimaryInstanceSettingsMachineConfigArgs']] = None,
              database_flags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
              labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
              private_ip: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if id is None:
+            raise TypeError("Missing 'id' argument")
+        if machine_config is None and 'machineConfig' in kwargs:
+            machine_config = kwargs['machineConfig']
+        if machine_config is None:
+            raise TypeError("Missing 'machine_config' argument")
+        if database_flags is None and 'databaseFlags' in kwargs:
+            database_flags = kwargs['databaseFlags']
+        if private_ip is None and 'privateIp' in kwargs:
+            private_ip = kwargs['privateIp']
+
         _setter("id", id)
         _setter("machine_config", machine_config)
         if database_flags is not None:
@@ -357,8 +395,14 @@ class ConnectionProfileAlloydbSettingsPrimaryInstanceSettingsMachineConfigArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             cpu_count: pulumi.Input[int],
-             opts: Optional[pulumi.ResourceOptions]=None):
+             cpu_count: Optional[pulumi.Input[int]] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if cpu_count is None and 'cpuCount' in kwargs:
+            cpu_count = kwargs['cpuCount']
+        if cpu_count is None:
+            raise TypeError("Missing 'cpu_count' argument")
+
         _setter("cpu_count", cpu_count)
 
     @property
@@ -405,7 +449,15 @@ class ConnectionProfileCloudsqlArgs:
              private_ip: Optional[pulumi.Input[str]] = None,
              public_ip: Optional[pulumi.Input[str]] = None,
              settings: Optional[pulumi.Input['ConnectionProfileCloudsqlSettingsArgs']] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if cloud_sql_id is None and 'cloudSqlId' in kwargs:
+            cloud_sql_id = kwargs['cloudSqlId']
+        if private_ip is None and 'privateIp' in kwargs:
+            private_ip = kwargs['privateIp']
+        if public_ip is None and 'publicIp' in kwargs:
+            public_ip = kwargs['publicIp']
+
         if cloud_sql_id is not None:
             _setter("cloud_sql_id", cloud_sql_id)
         if private_ip is not None:
@@ -539,7 +591,7 @@ class ConnectionProfileCloudsqlSettingsArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             source_id: pulumi.Input[str],
+             source_id: Optional[pulumi.Input[str]] = None,
              activation_policy: Optional[pulumi.Input[str]] = None,
              auto_storage_increase: Optional[pulumi.Input[bool]] = None,
              cmek_key_name: Optional[pulumi.Input[str]] = None,
@@ -556,7 +608,37 @@ class ConnectionProfileCloudsqlSettingsArgs:
              tier: Optional[pulumi.Input[str]] = None,
              user_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
              zone: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if source_id is None and 'sourceId' in kwargs:
+            source_id = kwargs['sourceId']
+        if source_id is None:
+            raise TypeError("Missing 'source_id' argument")
+        if activation_policy is None and 'activationPolicy' in kwargs:
+            activation_policy = kwargs['activationPolicy']
+        if auto_storage_increase is None and 'autoStorageIncrease' in kwargs:
+            auto_storage_increase = kwargs['autoStorageIncrease']
+        if cmek_key_name is None and 'cmekKeyName' in kwargs:
+            cmek_key_name = kwargs['cmekKeyName']
+        if data_disk_size_gb is None and 'dataDiskSizeGb' in kwargs:
+            data_disk_size_gb = kwargs['dataDiskSizeGb']
+        if data_disk_type is None and 'dataDiskType' in kwargs:
+            data_disk_type = kwargs['dataDiskType']
+        if database_flags is None and 'databaseFlags' in kwargs:
+            database_flags = kwargs['databaseFlags']
+        if database_version is None and 'databaseVersion' in kwargs:
+            database_version = kwargs['databaseVersion']
+        if ip_config is None and 'ipConfig' in kwargs:
+            ip_config = kwargs['ipConfig']
+        if root_password is None and 'rootPassword' in kwargs:
+            root_password = kwargs['rootPassword']
+        if root_password_set is None and 'rootPasswordSet' in kwargs:
+            root_password_set = kwargs['rootPasswordSet']
+        if storage_auto_resize_limit is None and 'storageAutoResizeLimit' in kwargs:
+            storage_auto_resize_limit = kwargs['storageAutoResizeLimit']
+        if user_labels is None and 'userLabels' in kwargs:
+            user_labels = kwargs['userLabels']
+
         _setter("source_id", source_id)
         if activation_policy is not None:
             _setter("activation_policy", activation_policy)
@@ -834,7 +916,17 @@ class ConnectionProfileCloudsqlSettingsIpConfigArgs:
              enable_ipv4: Optional[pulumi.Input[bool]] = None,
              private_network: Optional[pulumi.Input[str]] = None,
              require_ssl: Optional[pulumi.Input[bool]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if authorized_networks is None and 'authorizedNetworks' in kwargs:
+            authorized_networks = kwargs['authorizedNetworks']
+        if enable_ipv4 is None and 'enableIpv4' in kwargs:
+            enable_ipv4 = kwargs['enableIpv4']
+        if private_network is None and 'privateNetwork' in kwargs:
+            private_network = kwargs['privateNetwork']
+        if require_ssl is None and 'requireSsl' in kwargs:
+            require_ssl = kwargs['requireSsl']
+
         if authorized_networks is not None:
             _setter("authorized_networks", authorized_networks)
         if enable_ipv4 is not None:
@@ -918,11 +1010,17 @@ class ConnectionProfileCloudsqlSettingsIpConfigAuthorizedNetworkArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             value: pulumi.Input[str],
+             value: Optional[pulumi.Input[str]] = None,
              expire_time: Optional[pulumi.Input[str]] = None,
              label: Optional[pulumi.Input[str]] = None,
              ttl: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if value is None:
+            raise TypeError("Missing 'value' argument")
+        if expire_time is None and 'expireTime' in kwargs:
+            expire_time = kwargs['expireTime']
+
         _setter("value", value)
         if expire_time is not None:
             _setter("expire_time", expire_time)
@@ -1006,7 +1104,9 @@ class ConnectionProfileErrorArgs:
              code: Optional[pulumi.Input[int]] = None,
              details: Optional[pulumi.Input[Sequence[pulumi.Input[Mapping[str, Any]]]]] = None,
              message: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+
         if code is not None:
             _setter("code", code)
         if details is not None:
@@ -1090,14 +1190,28 @@ class ConnectionProfileMysqlArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             host: pulumi.Input[str],
-             password: pulumi.Input[str],
-             port: pulumi.Input[int],
-             username: pulumi.Input[str],
+             host: Optional[pulumi.Input[str]] = None,
+             password: Optional[pulumi.Input[str]] = None,
+             port: Optional[pulumi.Input[int]] = None,
+             username: Optional[pulumi.Input[str]] = None,
              cloud_sql_id: Optional[pulumi.Input[str]] = None,
              password_set: Optional[pulumi.Input[bool]] = None,
              ssl: Optional[pulumi.Input['ConnectionProfileMysqlSslArgs']] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if host is None:
+            raise TypeError("Missing 'host' argument")
+        if password is None:
+            raise TypeError("Missing 'password' argument")
+        if port is None:
+            raise TypeError("Missing 'port' argument")
+        if username is None:
+            raise TypeError("Missing 'username' argument")
+        if cloud_sql_id is None and 'cloudSqlId' in kwargs:
+            cloud_sql_id = kwargs['cloudSqlId']
+        if password_set is None and 'passwordSet' in kwargs:
+            password_set = kwargs['passwordSet']
+
         _setter("host", host)
         _setter("password", password)
         _setter("port", port)
@@ -1228,11 +1342,21 @@ class ConnectionProfileMysqlSslArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             ca_certificate: pulumi.Input[str],
+             ca_certificate: Optional[pulumi.Input[str]] = None,
              client_certificate: Optional[pulumi.Input[str]] = None,
              client_key: Optional[pulumi.Input[str]] = None,
              type: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if ca_certificate is None and 'caCertificate' in kwargs:
+            ca_certificate = kwargs['caCertificate']
+        if ca_certificate is None:
+            raise TypeError("Missing 'ca_certificate' argument")
+        if client_certificate is None and 'clientCertificate' in kwargs:
+            client_certificate = kwargs['clientCertificate']
+        if client_key is None and 'clientKey' in kwargs:
+            client_key = kwargs['clientKey']
+
         _setter("ca_certificate", ca_certificate)
         if client_certificate is not None:
             _setter("client_certificate", client_certificate)
@@ -1337,15 +1461,31 @@ class ConnectionProfilePostgresqlArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             host: pulumi.Input[str],
-             password: pulumi.Input[str],
-             port: pulumi.Input[int],
-             username: pulumi.Input[str],
+             host: Optional[pulumi.Input[str]] = None,
+             password: Optional[pulumi.Input[str]] = None,
+             port: Optional[pulumi.Input[int]] = None,
+             username: Optional[pulumi.Input[str]] = None,
              cloud_sql_id: Optional[pulumi.Input[str]] = None,
              network_architecture: Optional[pulumi.Input[str]] = None,
              password_set: Optional[pulumi.Input[bool]] = None,
              ssl: Optional[pulumi.Input['ConnectionProfilePostgresqlSslArgs']] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if host is None:
+            raise TypeError("Missing 'host' argument")
+        if password is None:
+            raise TypeError("Missing 'password' argument")
+        if port is None:
+            raise TypeError("Missing 'port' argument")
+        if username is None:
+            raise TypeError("Missing 'username' argument")
+        if cloud_sql_id is None and 'cloudSqlId' in kwargs:
+            cloud_sql_id = kwargs['cloudSqlId']
+        if network_architecture is None and 'networkArchitecture' in kwargs:
+            network_architecture = kwargs['networkArchitecture']
+        if password_set is None and 'passwordSet' in kwargs:
+            password_set = kwargs['passwordSet']
+
         _setter("host", host)
         _setter("password", password)
         _setter("port", port)
@@ -1491,11 +1631,21 @@ class ConnectionProfilePostgresqlSslArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             ca_certificate: pulumi.Input[str],
+             ca_certificate: Optional[pulumi.Input[str]] = None,
              client_certificate: Optional[pulumi.Input[str]] = None,
              client_key: Optional[pulumi.Input[str]] = None,
              type: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if ca_certificate is None and 'caCertificate' in kwargs:
+            ca_certificate = kwargs['caCertificate']
+        if ca_certificate is None:
+            raise TypeError("Missing 'ca_certificate' argument")
+        if client_certificate is None and 'clientCertificate' in kwargs:
+            client_certificate = kwargs['clientCertificate']
+        if client_key is None and 'clientKey' in kwargs:
+            client_key = kwargs['clientKey']
+
         _setter("ca_certificate", ca_certificate)
         if client_certificate is not None:
             _setter("client_certificate", client_certificate)

pulumi_gcp/databasemigrationservice/connection_profile.py

@@ -60,7 +60,7 @@ class ConnectionProfileArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             connection_profile_id: pulumi.Input[str],
+             connection_profile_id: Optional[pulumi.Input[str]] = None,
              alloydb: Optional[pulumi.Input['ConnectionProfileAlloydbArgs']] = None,
              cloudsql: Optional[pulumi.Input['ConnectionProfileCloudsqlArgs']] = None,
              display_name: Optional[pulumi.Input[str]] = None,
@@ -69,7 +69,15 @@ class ConnectionProfileArgs:
              mysql: Optional[pulumi.Input['ConnectionProfileMysqlArgs']] = None,
              postgresql: Optional[pulumi.Input['ConnectionProfilePostgresqlArgs']] = None,
              project: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if connection_profile_id is None and 'connectionProfileId' in kwargs:
+            connection_profile_id = kwargs['connectionProfileId']
+        if connection_profile_id is None:
+            raise TypeError("Missing 'connection_profile_id' argument")
+        if display_name is None and 'displayName' in kwargs:
+            display_name = kwargs['displayName']
+
         _setter("connection_profile_id", connection_profile_id)
         if alloydb is not None:
             _setter("alloydb", alloydb)
@@ -282,7 +290,15 @@ class _ConnectionProfileState:
              postgresql: Optional[pulumi.Input['ConnectionProfilePostgresqlArgs']] = None,
              project: Optional[pulumi.Input[str]] = None,
              state: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if connection_profile_id is None and 'connectionProfileId' in kwargs:
+            connection_profile_id = kwargs['connectionProfileId']
+        if create_time is None and 'createTime' in kwargs:
+            create_time = kwargs['createTime']
+        if display_name is None and 'displayName' in kwargs:
+            display_name = kwargs['displayName']
+
         if alloydb is not None:
             _setter("alloydb", alloydb)
         if cloudsql is not None:
@@ -519,120 +535,6 @@ class ConnectionProfile(pulumi.CustomResource):
         Read more about sensitive data in state.
 
         ## Example Usage
-        ### Database Migration Service Connection Profile Cloudsql
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        project = gcp.organizations.get_project()
-        cloudsqldb = gcp.sql.DatabaseInstance("cloudsqldb",
-            database_version="MYSQL_5_7",
-            settings=gcp.sql.DatabaseInstanceSettingsArgs(
-                tier="db-n1-standard-1",
-                deletion_protection_enabled=False,
-            ),
-            deletion_protection=False)
-        sql_client_cert = gcp.sql.SslCert("sqlClientCert",
-            common_name="my-cert",
-            instance=cloudsqldb.name,
-            opts=pulumi.ResourceOptions(depends_on=[cloudsqldb]))
-        sqldb_user = gcp.sql.User("sqldbUser",
-            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=gcp.databasemigrationservice.ConnectionProfileMysqlArgs(
-                host=cloudsqldb.ip_addresses[0].ip_address,
-                port=3306,
-                username=sqldb_user.name,
-                password=sqldb_user.password,
-                ssl=gcp.databasemigrationservice.ConnectionProfileMysqlSslArgs(
-                    client_key=sql_client_cert.private_key,
-                    client_certificate=sql_client_cert.cert,
-                    ca_certificate=sql_client_cert.server_ca_cert,
-                ),
-                cloud_sql_id="my-database",
-            ),
-            opts=pulumi.ResourceOptions(depends_on=[sqldb_user]))
-        cloudsqlprofile_destination = gcp.databasemigrationservice.ConnectionProfile("cloudsqlprofileDestination",
-            location="us-central1",
-            connection_profile_id="my-toprofileid",
-            display_name="my-toprofileid_displayname",
-            labels={
-                "foo": "bar",
-            },
-            cloudsql=gcp.databasemigrationservice.ConnectionProfileCloudsqlArgs(
-                settings=gcp.databasemigrationservice.ConnectionProfileCloudsqlSettingsArgs(
-                    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=gcp.databasemigrationservice.ConnectionProfileCloudsqlSettingsIpConfigArgs(
-                        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]))
-        ```
-        ### Database Migration Service Connection Profile Postgres
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        postgresqldb = gcp.sql.DatabaseInstance("postgresqldb",
-            database_version="POSTGRES_12",
-            settings=gcp.sql.DatabaseInstanceSettingsArgs(
-                tier="db-custom-2-13312",
-            ),
-            deletion_protection=False)
-        sql_client_cert = gcp.sql.SslCert("sqlClientCert",
-            common_name="my-cert",
-            instance=postgresqldb.name,
-            opts=pulumi.ResourceOptions(depends_on=[postgresqldb]))
-        sqldb_user = gcp.sql.User("sqldbUser",
-            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=gcp.databasemigrationservice.ConnectionProfilePostgresqlArgs(
-                host=postgresqldb.ip_addresses[0].ip_address,
-                port=5432,
-                username=sqldb_user.name,
-                password=sqldb_user.password,
-                ssl=gcp.databasemigrationservice.ConnectionProfilePostgresqlSslArgs(
-                    client_key=sql_client_cert.private_key,
-                    client_certificate=sql_client_cert.cert,
-                    ca_certificate=sql_client_cert.server_ca_cert,
-                ),
-                cloud_sql_id="my-database",
-            ),
-            opts=pulumi.ResourceOptions(depends_on=[sqldb_user]))
-        ```
 
         ## Import
 
@@ -690,120 +592,6 @@ class ConnectionProfile(pulumi.CustomResource):
         Read more about sensitive data in state.
 
         ## Example Usage
-        ### Database Migration Service Connection Profile Cloudsql
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        project = gcp.organizations.get_project()
-        cloudsqldb = gcp.sql.DatabaseInstance("cloudsqldb",
-            database_version="MYSQL_5_7",
-            settings=gcp.sql.DatabaseInstanceSettingsArgs(
-                tier="db-n1-standard-1",
-                deletion_protection_enabled=False,
-            ),
-            deletion_protection=False)
-        sql_client_cert = gcp.sql.SslCert("sqlClientCert",
-            common_name="my-cert",
-            instance=cloudsqldb.name,
-            opts=pulumi.ResourceOptions(depends_on=[cloudsqldb]))
-        sqldb_user = gcp.sql.User("sqldbUser",
-            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=gcp.databasemigrationservice.ConnectionProfileMysqlArgs(
-                host=cloudsqldb.ip_addresses[0].ip_address,
-                port=3306,
-                username=sqldb_user.name,
-                password=sqldb_user.password,
-                ssl=gcp.databasemigrationservice.ConnectionProfileMysqlSslArgs(
-                    client_key=sql_client_cert.private_key,
-                    client_certificate=sql_client_cert.cert,
-                    ca_certificate=sql_client_cert.server_ca_cert,
-                ),
-                cloud_sql_id="my-database",
-            ),
-            opts=pulumi.ResourceOptions(depends_on=[sqldb_user]))
-        cloudsqlprofile_destination = gcp.databasemigrationservice.ConnectionProfile("cloudsqlprofileDestination",
-            location="us-central1",
-            connection_profile_id="my-toprofileid",
-            display_name="my-toprofileid_displayname",
-            labels={
-                "foo": "bar",
-            },
-            cloudsql=gcp.databasemigrationservice.ConnectionProfileCloudsqlArgs(
-                settings=gcp.databasemigrationservice.ConnectionProfileCloudsqlSettingsArgs(
-                    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=gcp.databasemigrationservice.ConnectionProfileCloudsqlSettingsIpConfigArgs(
-                        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]))
-        ```
-        ### Database Migration Service Connection Profile Postgres
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        postgresqldb = gcp.sql.DatabaseInstance("postgresqldb",
-            database_version="POSTGRES_12",
-            settings=gcp.sql.DatabaseInstanceSettingsArgs(
-                tier="db-custom-2-13312",
-            ),
-            deletion_protection=False)
-        sql_client_cert = gcp.sql.SslCert("sqlClientCert",
-            common_name="my-cert",
-            instance=postgresqldb.name,
-            opts=pulumi.ResourceOptions(depends_on=[postgresqldb]))
-        sqldb_user = gcp.sql.User("sqldbUser",
-            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=gcp.databasemigrationservice.ConnectionProfilePostgresqlArgs(
-                host=postgresqldb.ip_addresses[0].ip_address,
-                port=5432,
-                username=sqldb_user.name,
-                password=sqldb_user.password,
-                ssl=gcp.databasemigrationservice.ConnectionProfilePostgresqlSslArgs(
-                    client_key=sql_client_cert.private_key,
-                    client_certificate=sql_client_cert.cert,
-                    ca_certificate=sql_client_cert.server_ca_cert,
-                ),
-                cloud_sql_id="my-database",
-            ),
-            opts=pulumi.ResourceOptions(depends_on=[sqldb_user]))
-        ```
 
         ## Import
 
@@ -858,17 +646,9 @@ class ConnectionProfile(pulumi.CustomResource):
                 raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
             __props__ = ConnectionProfileArgs.__new__(ConnectionProfileArgs)
 
-            if alloydb is not None and not isinstance(alloydb, ConnectionProfileAlloydbArgs):
-                alloydb = alloydb or {}
-                def _setter(key, value):
-                    alloydb[key] = value
-                ConnectionProfileAlloydbArgs._configure(_setter, **alloydb)
+            alloydb = _utilities.configure(alloydb, ConnectionProfileAlloydbArgs, True)
             __props__.__dict__["alloydb"] = alloydb
-            if cloudsql is not None and not isinstance(cloudsql, ConnectionProfileCloudsqlArgs):
-                cloudsql = cloudsql or {}
-                def _setter(key, value):
-                    cloudsql[key] = value
-                ConnectionProfileCloudsqlArgs._configure(_setter, **cloudsql)
+            cloudsql = _utilities.configure(cloudsql, ConnectionProfileCloudsqlArgs, True)
             __props__.__dict__["cloudsql"] = cloudsql
             if connection_profile_id is None and not opts.urn:
                 raise TypeError("Missing required property 'connection_profile_id'")
@@ -876,17 +656,9 @@ class ConnectionProfile(pulumi.CustomResource):
             __props__.__dict__["display_name"] = display_name
             __props__.__dict__["labels"] = labels
             __props__.__dict__["location"] = location
-            if mysql is not None and not isinstance(mysql, ConnectionProfileMysqlArgs):
-                mysql = mysql or {}
-                def _setter(key, value):
-                    mysql[key] = value
-                ConnectionProfileMysqlArgs._configure(_setter, **mysql)
+            mysql = _utilities.configure(mysql, ConnectionProfileMysqlArgs, True)
             __props__.__dict__["mysql"] = mysql
-            if postgresql is not None and not isinstance(postgresql, ConnectionProfilePostgresqlArgs):
-                postgresql = postgresql or {}
-                def _setter(key, value):
-                    postgresql[key] = value
-                ConnectionProfilePostgresqlArgs._configure(_setter, **postgresql)
+            postgresql = _utilities.configure(postgresql, ConnectionProfilePostgresqlArgs, True)
             __props__.__dict__["postgresql"] = postgresql
             __props__.__dict__["project"] = project
             __props__.__dict__["create_time"] = None