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

pulumi_gcp/container/cluster.py

@@ -429,7 +429,129 @@ class ClusterArgs:
              tpu_config: Optional[pulumi.Input['ClusterTpuConfigArgs']] = None,
              vertical_pod_autoscaling: Optional[pulumi.Input['ClusterVerticalPodAutoscalingArgs']] = None,
              workload_identity_config: Optional[pulumi.Input['ClusterWorkloadIdentityConfigArgs']] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if addons_config is None and 'addonsConfig' in kwargs:
+            addons_config = kwargs['addonsConfig']
+        if allow_net_admin is None and 'allowNetAdmin' in kwargs:
+            allow_net_admin = kwargs['allowNetAdmin']
+        if authenticator_groups_config is None and 'authenticatorGroupsConfig' in kwargs:
+            authenticator_groups_config = kwargs['authenticatorGroupsConfig']
+        if binary_authorization is None and 'binaryAuthorization' in kwargs:
+            binary_authorization = kwargs['binaryAuthorization']
+        if cluster_autoscaling is None and 'clusterAutoscaling' in kwargs:
+            cluster_autoscaling = kwargs['clusterAutoscaling']
+        if cluster_ipv4_cidr is None and 'clusterIpv4Cidr' in kwargs:
+            cluster_ipv4_cidr = kwargs['clusterIpv4Cidr']
+        if cluster_telemetry is None and 'clusterTelemetry' in kwargs:
+            cluster_telemetry = kwargs['clusterTelemetry']
+        if confidential_nodes is None and 'confidentialNodes' in kwargs:
+            confidential_nodes = kwargs['confidentialNodes']
+        if cost_management_config is None and 'costManagementConfig' in kwargs:
+            cost_management_config = kwargs['costManagementConfig']
+        if database_encryption is None and 'databaseEncryption' in kwargs:
+            database_encryption = kwargs['databaseEncryption']
+        if datapath_provider is None and 'datapathProvider' in kwargs:
+            datapath_provider = kwargs['datapathProvider']
+        if default_max_pods_per_node is None and 'defaultMaxPodsPerNode' in kwargs:
+            default_max_pods_per_node = kwargs['defaultMaxPodsPerNode']
+        if default_snat_status is None and 'defaultSnatStatus' in kwargs:
+            default_snat_status = kwargs['defaultSnatStatus']
+        if dns_config is None and 'dnsConfig' in kwargs:
+            dns_config = kwargs['dnsConfig']
+        if enable_autopilot is None and 'enableAutopilot' in kwargs:
+            enable_autopilot = kwargs['enableAutopilot']
+        if enable_binary_authorization is None and 'enableBinaryAuthorization' in kwargs:
+            enable_binary_authorization = kwargs['enableBinaryAuthorization']
+        if enable_fqdn_network_policy is None and 'enableFqdnNetworkPolicy' in kwargs:
+            enable_fqdn_network_policy = kwargs['enableFqdnNetworkPolicy']
+        if enable_intranode_visibility is None and 'enableIntranodeVisibility' in kwargs:
+            enable_intranode_visibility = kwargs['enableIntranodeVisibility']
+        if enable_k8s_beta_apis is None and 'enableK8sBetaApis' in kwargs:
+            enable_k8s_beta_apis = kwargs['enableK8sBetaApis']
+        if enable_kubernetes_alpha is None and 'enableKubernetesAlpha' in kwargs:
+            enable_kubernetes_alpha = kwargs['enableKubernetesAlpha']
+        if enable_l4_ilb_subsetting is None and 'enableL4IlbSubsetting' in kwargs:
+            enable_l4_ilb_subsetting = kwargs['enableL4IlbSubsetting']
+        if enable_legacy_abac is None and 'enableLegacyAbac' in kwargs:
+            enable_legacy_abac = kwargs['enableLegacyAbac']
+        if enable_multi_networking is None and 'enableMultiNetworking' in kwargs:
+            enable_multi_networking = kwargs['enableMultiNetworking']
+        if enable_shielded_nodes is None and 'enableShieldedNodes' in kwargs:
+            enable_shielded_nodes = kwargs['enableShieldedNodes']
+        if enable_tpu is None and 'enableTpu' in kwargs:
+            enable_tpu = kwargs['enableTpu']
+        if gateway_api_config is None and 'gatewayApiConfig' in kwargs:
+            gateway_api_config = kwargs['gatewayApiConfig']
+        if identity_service_config is None and 'identityServiceConfig' in kwargs:
+            identity_service_config = kwargs['identityServiceConfig']
+        if initial_node_count is None and 'initialNodeCount' in kwargs:
+            initial_node_count = kwargs['initialNodeCount']
+        if ip_allocation_policy is None and 'ipAllocationPolicy' in kwargs:
+            ip_allocation_policy = kwargs['ipAllocationPolicy']
+        if logging_config is None and 'loggingConfig' in kwargs:
+            logging_config = kwargs['loggingConfig']
+        if logging_service is None and 'loggingService' in kwargs:
+            logging_service = kwargs['loggingService']
+        if maintenance_policy is None and 'maintenancePolicy' in kwargs:
+            maintenance_policy = kwargs['maintenancePolicy']
+        if master_auth is None and 'masterAuth' in kwargs:
+            master_auth = kwargs['masterAuth']
+        if master_authorized_networks_config is None and 'masterAuthorizedNetworksConfig' in kwargs:
+            master_authorized_networks_config = kwargs['masterAuthorizedNetworksConfig']
+        if mesh_certificates is None and 'meshCertificates' in kwargs:
+            mesh_certificates = kwargs['meshCertificates']
+        if min_master_version is None and 'minMasterVersion' in kwargs:
+            min_master_version = kwargs['minMasterVersion']
+        if monitoring_config is None and 'monitoringConfig' in kwargs:
+            monitoring_config = kwargs['monitoringConfig']
+        if monitoring_service is None and 'monitoringService' in kwargs:
+            monitoring_service = kwargs['monitoringService']
+        if network_policy is None and 'networkPolicy' in kwargs:
+            network_policy = kwargs['networkPolicy']
+        if networking_mode is None and 'networkingMode' in kwargs:
+            networking_mode = kwargs['networkingMode']
+        if node_config is None and 'nodeConfig' in kwargs:
+            node_config = kwargs['nodeConfig']
+        if node_locations is None and 'nodeLocations' in kwargs:
+            node_locations = kwargs['nodeLocations']
+        if node_pool_auto_config is None and 'nodePoolAutoConfig' in kwargs:
+            node_pool_auto_config = kwargs['nodePoolAutoConfig']
+        if node_pool_defaults is None and 'nodePoolDefaults' in kwargs:
+            node_pool_defaults = kwargs['nodePoolDefaults']
+        if node_pools is None and 'nodePools' in kwargs:
+            node_pools = kwargs['nodePools']
+        if node_version is None and 'nodeVersion' in kwargs:
+            node_version = kwargs['nodeVersion']
+        if notification_config is None and 'notificationConfig' in kwargs:
+            notification_config = kwargs['notificationConfig']
+        if pod_security_policy_config is None and 'podSecurityPolicyConfig' in kwargs:
+            pod_security_policy_config = kwargs['podSecurityPolicyConfig']
+        if private_cluster_config is None and 'privateClusterConfig' in kwargs:
+            private_cluster_config = kwargs['privateClusterConfig']
+        if private_ipv6_google_access is None and 'privateIpv6GoogleAccess' in kwargs:
+            private_ipv6_google_access = kwargs['privateIpv6GoogleAccess']
+        if protect_config is None and 'protectConfig' in kwargs:
+            protect_config = kwargs['protectConfig']
+        if release_channel is None and 'releaseChannel' in kwargs:
+            release_channel = kwargs['releaseChannel']
+        if remove_default_node_pool is None and 'removeDefaultNodePool' in kwargs:
+            remove_default_node_pool = kwargs['removeDefaultNodePool']
+        if resource_labels is None and 'resourceLabels' in kwargs:
+            resource_labels = kwargs['resourceLabels']
+        if resource_usage_export_config is None and 'resourceUsageExportConfig' in kwargs:
+            resource_usage_export_config = kwargs['resourceUsageExportConfig']
+        if security_posture_config is None and 'securityPostureConfig' in kwargs:
+            security_posture_config = kwargs['securityPostureConfig']
+        if service_external_ips_config is None and 'serviceExternalIpsConfig' in kwargs:
+            service_external_ips_config = kwargs['serviceExternalIpsConfig']
+        if tpu_config is None and 'tpuConfig' in kwargs:
+            tpu_config = kwargs['tpuConfig']
+        if vertical_pod_autoscaling is None and 'verticalPodAutoscaling' in kwargs:
+            vertical_pod_autoscaling = kwargs['verticalPodAutoscaling']
+        if workload_identity_config is None and 'workloadIdentityConfig' in kwargs:
+            workload_identity_config = kwargs['workloadIdentityConfig']
+
         if addons_config is not None:
             _setter("addons_config", addons_config)
         if allow_net_admin is not None:
@@ -1952,7 +2074,139 @@ class _ClusterState:
              tpu_ipv4_cidr_block: Optional[pulumi.Input[str]] = None,
              vertical_pod_autoscaling: Optional[pulumi.Input['ClusterVerticalPodAutoscalingArgs']] = None,
              workload_identity_config: Optional[pulumi.Input['ClusterWorkloadIdentityConfigArgs']] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if addons_config is None and 'addonsConfig' in kwargs:
+            addons_config = kwargs['addonsConfig']
+        if allow_net_admin is None and 'allowNetAdmin' in kwargs:
+            allow_net_admin = kwargs['allowNetAdmin']
+        if authenticator_groups_config is None and 'authenticatorGroupsConfig' in kwargs:
+            authenticator_groups_config = kwargs['authenticatorGroupsConfig']
+        if binary_authorization is None and 'binaryAuthorization' in kwargs:
+            binary_authorization = kwargs['binaryAuthorization']
+        if cluster_autoscaling is None and 'clusterAutoscaling' in kwargs:
+            cluster_autoscaling = kwargs['clusterAutoscaling']
+        if cluster_ipv4_cidr is None and 'clusterIpv4Cidr' in kwargs:
+            cluster_ipv4_cidr = kwargs['clusterIpv4Cidr']
+        if cluster_telemetry is None and 'clusterTelemetry' in kwargs:
+            cluster_telemetry = kwargs['clusterTelemetry']
+        if confidential_nodes is None and 'confidentialNodes' in kwargs:
+            confidential_nodes = kwargs['confidentialNodes']
+        if cost_management_config is None and 'costManagementConfig' in kwargs:
+            cost_management_config = kwargs['costManagementConfig']
+        if database_encryption is None and 'databaseEncryption' in kwargs:
+            database_encryption = kwargs['databaseEncryption']
+        if datapath_provider is None and 'datapathProvider' in kwargs:
+            datapath_provider = kwargs['datapathProvider']
+        if default_max_pods_per_node is None and 'defaultMaxPodsPerNode' in kwargs:
+            default_max_pods_per_node = kwargs['defaultMaxPodsPerNode']
+        if default_snat_status is None and 'defaultSnatStatus' in kwargs:
+            default_snat_status = kwargs['defaultSnatStatus']
+        if dns_config is None and 'dnsConfig' in kwargs:
+            dns_config = kwargs['dnsConfig']
+        if enable_autopilot is None and 'enableAutopilot' in kwargs:
+            enable_autopilot = kwargs['enableAutopilot']
+        if enable_binary_authorization is None and 'enableBinaryAuthorization' in kwargs:
+            enable_binary_authorization = kwargs['enableBinaryAuthorization']
+        if enable_fqdn_network_policy is None and 'enableFqdnNetworkPolicy' in kwargs:
+            enable_fqdn_network_policy = kwargs['enableFqdnNetworkPolicy']
+        if enable_intranode_visibility is None and 'enableIntranodeVisibility' in kwargs:
+            enable_intranode_visibility = kwargs['enableIntranodeVisibility']
+        if enable_k8s_beta_apis is None and 'enableK8sBetaApis' in kwargs:
+            enable_k8s_beta_apis = kwargs['enableK8sBetaApis']
+        if enable_kubernetes_alpha is None and 'enableKubernetesAlpha' in kwargs:
+            enable_kubernetes_alpha = kwargs['enableKubernetesAlpha']
+        if enable_l4_ilb_subsetting is None and 'enableL4IlbSubsetting' in kwargs:
+            enable_l4_ilb_subsetting = kwargs['enableL4IlbSubsetting']
+        if enable_legacy_abac is None and 'enableLegacyAbac' in kwargs:
+            enable_legacy_abac = kwargs['enableLegacyAbac']
+        if enable_multi_networking is None and 'enableMultiNetworking' in kwargs:
+            enable_multi_networking = kwargs['enableMultiNetworking']
+        if enable_shielded_nodes is None and 'enableShieldedNodes' in kwargs:
+            enable_shielded_nodes = kwargs['enableShieldedNodes']
+        if enable_tpu is None and 'enableTpu' in kwargs:
+            enable_tpu = kwargs['enableTpu']
+        if gateway_api_config is None and 'gatewayApiConfig' in kwargs:
+            gateway_api_config = kwargs['gatewayApiConfig']
+        if identity_service_config is None and 'identityServiceConfig' in kwargs:
+            identity_service_config = kwargs['identityServiceConfig']
+        if initial_node_count is None and 'initialNodeCount' in kwargs:
+            initial_node_count = kwargs['initialNodeCount']
+        if ip_allocation_policy is None and 'ipAllocationPolicy' in kwargs:
+            ip_allocation_policy = kwargs['ipAllocationPolicy']
+        if label_fingerprint is None and 'labelFingerprint' in kwargs:
+            label_fingerprint = kwargs['labelFingerprint']
+        if logging_config is None and 'loggingConfig' in kwargs:
+            logging_config = kwargs['loggingConfig']
+        if logging_service is None and 'loggingService' in kwargs:
+            logging_service = kwargs['loggingService']
+        if maintenance_policy is None and 'maintenancePolicy' in kwargs:
+            maintenance_policy = kwargs['maintenancePolicy']
+        if master_auth is None and 'masterAuth' in kwargs:
+            master_auth = kwargs['masterAuth']
+        if master_authorized_networks_config is None and 'masterAuthorizedNetworksConfig' in kwargs:
+            master_authorized_networks_config = kwargs['masterAuthorizedNetworksConfig']
+        if master_version is None and 'masterVersion' in kwargs:
+            master_version = kwargs['masterVersion']
+        if mesh_certificates is None and 'meshCertificates' in kwargs:
+            mesh_certificates = kwargs['meshCertificates']
+        if min_master_version is None and 'minMasterVersion' in kwargs:
+            min_master_version = kwargs['minMasterVersion']
+        if monitoring_config is None and 'monitoringConfig' in kwargs:
+            monitoring_config = kwargs['monitoringConfig']
+        if monitoring_service is None and 'monitoringService' in kwargs:
+            monitoring_service = kwargs['monitoringService']
+        if network_policy is None and 'networkPolicy' in kwargs:
+            network_policy = kwargs['networkPolicy']
+        if networking_mode is None and 'networkingMode' in kwargs:
+            networking_mode = kwargs['networkingMode']
+        if node_config is None and 'nodeConfig' in kwargs:
+            node_config = kwargs['nodeConfig']
+        if node_locations is None and 'nodeLocations' in kwargs:
+            node_locations = kwargs['nodeLocations']
+        if node_pool_auto_config is None and 'nodePoolAutoConfig' in kwargs:
+            node_pool_auto_config = kwargs['nodePoolAutoConfig']
+        if node_pool_defaults is None and 'nodePoolDefaults' in kwargs:
+            node_pool_defaults = kwargs['nodePoolDefaults']
+        if node_pools is None and 'nodePools' in kwargs:
+            node_pools = kwargs['nodePools']
+        if node_version is None and 'nodeVersion' in kwargs:
+            node_version = kwargs['nodeVersion']
+        if notification_config is None and 'notificationConfig' in kwargs:
+            notification_config = kwargs['notificationConfig']
+        if pod_security_policy_config is None and 'podSecurityPolicyConfig' in kwargs:
+            pod_security_policy_config = kwargs['podSecurityPolicyConfig']
+        if private_cluster_config is None and 'privateClusterConfig' in kwargs:
+            private_cluster_config = kwargs['privateClusterConfig']
+        if private_ipv6_google_access is None and 'privateIpv6GoogleAccess' in kwargs:
+            private_ipv6_google_access = kwargs['privateIpv6GoogleAccess']
+        if protect_config is None and 'protectConfig' in kwargs:
+            protect_config = kwargs['protectConfig']
+        if release_channel is None and 'releaseChannel' in kwargs:
+            release_channel = kwargs['releaseChannel']
+        if remove_default_node_pool is None and 'removeDefaultNodePool' in kwargs:
+            remove_default_node_pool = kwargs['removeDefaultNodePool']
+        if resource_labels is None and 'resourceLabels' in kwargs:
+            resource_labels = kwargs['resourceLabels']
+        if resource_usage_export_config is None and 'resourceUsageExportConfig' in kwargs:
+            resource_usage_export_config = kwargs['resourceUsageExportConfig']
+        if security_posture_config is None and 'securityPostureConfig' in kwargs:
+            security_posture_config = kwargs['securityPostureConfig']
+        if self_link is None and 'selfLink' in kwargs:
+            self_link = kwargs['selfLink']
+        if service_external_ips_config is None and 'serviceExternalIpsConfig' in kwargs:
+            service_external_ips_config = kwargs['serviceExternalIpsConfig']
+        if services_ipv4_cidr is None and 'servicesIpv4Cidr' in kwargs:
+            services_ipv4_cidr = kwargs['servicesIpv4Cidr']
+        if tpu_config is None and 'tpuConfig' in kwargs:
+            tpu_config = kwargs['tpuConfig']
+        if tpu_ipv4_cidr_block is None and 'tpuIpv4CidrBlock' in kwargs:
+            tpu_ipv4_cidr_block = kwargs['tpuIpv4CidrBlock']
+        if vertical_pod_autoscaling is None and 'verticalPodAutoscaling' in kwargs:
+            vertical_pod_autoscaling = kwargs['verticalPodAutoscaling']
+        if workload_identity_config is None and 'workloadIdentityConfig' in kwargs:
+            workload_identity_config = kwargs['workloadIdentityConfig']
+
         if addons_config is not None:
             _setter("addons_config", addons_config)
         if allow_net_admin is not None:
@@ -3209,47 +3463,6 @@ class Cluster(pulumi.CustomResource):
         plaintext. [Read more about secrets in state](https://www.pulumi.com/docs/intro/concepts/programming-model/#secrets).
 
         ## Example Usage
-        ### With A Separately Managed Node Pool (Recommended)
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        default = gcp.service_account.Account("default",
-            account_id="service-account-id",
-            display_name="Service Account")
-        primary = gcp.container.Cluster("primary",
-            location="us-central1",
-            remove_default_node_pool=True,
-            initial_node_count=1)
-        primary_preemptible_nodes = gcp.container.NodePool("primaryPreemptibleNodes",
-            location="us-central1",
-            cluster=primary.name,
-            node_count=1,
-            node_config=gcp.container.NodePoolNodeConfigArgs(
-                preemptible=True,
-                machine_type="e2-medium",
-                service_account=default.email,
-                oauth_scopes=["https://www.googleapis.com/auth/cloud-platform"],
-            ))
-        ```
-
-        > **Note:** It is recommended that node pools be created and managed as separate resources as in the example above.
-        This allows node pools to be added and removed without recreating the cluster.  Node pools defined directly in the
-        `container.Cluster` resource cannot be removed without re-creating the cluster.
-        ### Autopilot
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        default = gcp.service_account.Account("default",
-            account_id="service-account-id",
-            display_name="Service Account")
-        primary = gcp.container.Cluster("primary",
-            enable_autopilot=True,
-            location="us-central1-a")
-        ```
 
         ## Import
 
@@ -3494,47 +3707,6 @@ class Cluster(pulumi.CustomResource):
         plaintext. [Read more about secrets in state](https://www.pulumi.com/docs/intro/concepts/programming-model/#secrets).
 
         ## Example Usage
-        ### With A Separately Managed Node Pool (Recommended)
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        default = gcp.service_account.Account("default",
-            account_id="service-account-id",
-            display_name="Service Account")
-        primary = gcp.container.Cluster("primary",
-            location="us-central1",
-            remove_default_node_pool=True,
-            initial_node_count=1)
-        primary_preemptible_nodes = gcp.container.NodePool("primaryPreemptibleNodes",
-            location="us-central1",
-            cluster=primary.name,
-            node_count=1,
-            node_config=gcp.container.NodePoolNodeConfigArgs(
-                preemptible=True,
-                machine_type="e2-medium",
-                service_account=default.email,
-                oauth_scopes=["https://www.googleapis.com/auth/cloud-platform"],
-            ))
-        ```
-
-        > **Note:** It is recommended that node pools be created and managed as separate resources as in the example above.
-        This allows node pools to be added and removed without recreating the cluster.  Node pools defined directly in the
-        `container.Cluster` resource cannot be removed without re-creating the cluster.
-        ### Autopilot
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        default = gcp.service_account.Account("default",
-            account_id="service-account-id",
-            display_name="Service Account")
-        primary = gcp.container.Cluster("primary",
-            enable_autopilot=True,
-            location="us-central1-a")
-        ```
 
         ## Import
 
@@ -3648,80 +3820,36 @@ class Cluster(pulumi.CustomResource):
                 raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
             __props__ = ClusterArgs.__new__(ClusterArgs)
 
-            if addons_config is not None and not isinstance(addons_config, ClusterAddonsConfigArgs):
-                addons_config = addons_config or {}
-                def _setter(key, value):
-                    addons_config[key] = value
-                ClusterAddonsConfigArgs._configure(_setter, **addons_config)
+            addons_config = _utilities.configure(addons_config, ClusterAddonsConfigArgs, True)
             __props__.__dict__["addons_config"] = addons_config
             __props__.__dict__["allow_net_admin"] = allow_net_admin
-            if authenticator_groups_config is not None and not isinstance(authenticator_groups_config, ClusterAuthenticatorGroupsConfigArgs):
-                authenticator_groups_config = authenticator_groups_config or {}
-                def _setter(key, value):
-                    authenticator_groups_config[key] = value
-                ClusterAuthenticatorGroupsConfigArgs._configure(_setter, **authenticator_groups_config)
+            authenticator_groups_config = _utilities.configure(authenticator_groups_config, ClusterAuthenticatorGroupsConfigArgs, True)
             __props__.__dict__["authenticator_groups_config"] = authenticator_groups_config
-            if binary_authorization is not None and not isinstance(binary_authorization, ClusterBinaryAuthorizationArgs):
-                binary_authorization = binary_authorization or {}
-                def _setter(key, value):
-                    binary_authorization[key] = value
-                ClusterBinaryAuthorizationArgs._configure(_setter, **binary_authorization)
+            binary_authorization = _utilities.configure(binary_authorization, ClusterBinaryAuthorizationArgs, True)
             __props__.__dict__["binary_authorization"] = binary_authorization
-            if cluster_autoscaling is not None and not isinstance(cluster_autoscaling, ClusterClusterAutoscalingArgs):
-                cluster_autoscaling = cluster_autoscaling or {}
-                def _setter(key, value):
-                    cluster_autoscaling[key] = value
-                ClusterClusterAutoscalingArgs._configure(_setter, **cluster_autoscaling)
+            cluster_autoscaling = _utilities.configure(cluster_autoscaling, ClusterClusterAutoscalingArgs, True)
             __props__.__dict__["cluster_autoscaling"] = cluster_autoscaling
             __props__.__dict__["cluster_ipv4_cidr"] = cluster_ipv4_cidr
-            if cluster_telemetry is not None and not isinstance(cluster_telemetry, ClusterClusterTelemetryArgs):
-                cluster_telemetry = cluster_telemetry or {}
-                def _setter(key, value):
-                    cluster_telemetry[key] = value
-                ClusterClusterTelemetryArgs._configure(_setter, **cluster_telemetry)
+            cluster_telemetry = _utilities.configure(cluster_telemetry, ClusterClusterTelemetryArgs, True)
             __props__.__dict__["cluster_telemetry"] = cluster_telemetry
-            if confidential_nodes is not None and not isinstance(confidential_nodes, ClusterConfidentialNodesArgs):
-                confidential_nodes = confidential_nodes or {}
-                def _setter(key, value):
-                    confidential_nodes[key] = value
-                ClusterConfidentialNodesArgs._configure(_setter, **confidential_nodes)
+            confidential_nodes = _utilities.configure(confidential_nodes, ClusterConfidentialNodesArgs, True)
             __props__.__dict__["confidential_nodes"] = confidential_nodes
-            if cost_management_config is not None and not isinstance(cost_management_config, ClusterCostManagementConfigArgs):
-                cost_management_config = cost_management_config or {}
-                def _setter(key, value):
-                    cost_management_config[key] = value
-                ClusterCostManagementConfigArgs._configure(_setter, **cost_management_config)
+            cost_management_config = _utilities.configure(cost_management_config, ClusterCostManagementConfigArgs, True)
             __props__.__dict__["cost_management_config"] = cost_management_config
-            if database_encryption is not None and not isinstance(database_encryption, ClusterDatabaseEncryptionArgs):
-                database_encryption = database_encryption or {}
-                def _setter(key, value):
-                    database_encryption[key] = value
-                ClusterDatabaseEncryptionArgs._configure(_setter, **database_encryption)
+            database_encryption = _utilities.configure(database_encryption, ClusterDatabaseEncryptionArgs, True)
             __props__.__dict__["database_encryption"] = database_encryption
             __props__.__dict__["datapath_provider"] = datapath_provider
             __props__.__dict__["default_max_pods_per_node"] = default_max_pods_per_node
-            if default_snat_status is not None and not isinstance(default_snat_status, ClusterDefaultSnatStatusArgs):
-                default_snat_status = default_snat_status or {}
-                def _setter(key, value):
-                    default_snat_status[key] = value
-                ClusterDefaultSnatStatusArgs._configure(_setter, **default_snat_status)
+            default_snat_status = _utilities.configure(default_snat_status, ClusterDefaultSnatStatusArgs, True)
             __props__.__dict__["default_snat_status"] = default_snat_status
             __props__.__dict__["description"] = description
-            if dns_config is not None and not isinstance(dns_config, ClusterDnsConfigArgs):
-                dns_config = dns_config or {}
-                def _setter(key, value):
-                    dns_config[key] = value
-                ClusterDnsConfigArgs._configure(_setter, **dns_config)
+            dns_config = _utilities.configure(dns_config, ClusterDnsConfigArgs, True)
             __props__.__dict__["dns_config"] = dns_config
             __props__.__dict__["enable_autopilot"] = enable_autopilot
             __props__.__dict__["enable_binary_authorization"] = enable_binary_authorization
             __props__.__dict__["enable_fqdn_network_policy"] = enable_fqdn_network_policy
             __props__.__dict__["enable_intranode_visibility"] = enable_intranode_visibility
-            if enable_k8s_beta_apis is not None and not isinstance(enable_k8s_beta_apis, ClusterEnableK8sBetaApisArgs):
-                enable_k8s_beta_apis = enable_k8s_beta_apis or {}
-                def _setter(key, value):
-                    enable_k8s_beta_apis[key] = value
-                ClusterEnableK8sBetaApisArgs._configure(_setter, **enable_k8s_beta_apis)
+            enable_k8s_beta_apis = _utilities.configure(enable_k8s_beta_apis, ClusterEnableK8sBetaApisArgs, True)
             __props__.__dict__["enable_k8s_beta_apis"] = enable_k8s_beta_apis
             __props__.__dict__["enable_kubernetes_alpha"] = enable_kubernetes_alpha
             __props__.__dict__["enable_l4_ilb_subsetting"] = enable_l4_ilb_subsetting
@@ -3729,165 +3857,69 @@ class Cluster(pulumi.CustomResource):
             __props__.__dict__["enable_multi_networking"] = enable_multi_networking
             __props__.__dict__["enable_shielded_nodes"] = enable_shielded_nodes
             __props__.__dict__["enable_tpu"] = enable_tpu
-            if gateway_api_config is not None and not isinstance(gateway_api_config, ClusterGatewayApiConfigArgs):
-                gateway_api_config = gateway_api_config or {}
-                def _setter(key, value):
-                    gateway_api_config[key] = value
-                ClusterGatewayApiConfigArgs._configure(_setter, **gateway_api_config)
+            gateway_api_config = _utilities.configure(gateway_api_config, ClusterGatewayApiConfigArgs, True)
             __props__.__dict__["gateway_api_config"] = gateway_api_config
-            if identity_service_config is not None and not isinstance(identity_service_config, ClusterIdentityServiceConfigArgs):
-                identity_service_config = identity_service_config or {}
-                def _setter(key, value):
-                    identity_service_config[key] = value
-                ClusterIdentityServiceConfigArgs._configure(_setter, **identity_service_config)
+            identity_service_config = _utilities.configure(identity_service_config, ClusterIdentityServiceConfigArgs, True)
             __props__.__dict__["identity_service_config"] = identity_service_config
             __props__.__dict__["initial_node_count"] = initial_node_count
-            if ip_allocation_policy is not None and not isinstance(ip_allocation_policy, ClusterIpAllocationPolicyArgs):
-                ip_allocation_policy = ip_allocation_policy or {}
-                def _setter(key, value):
-                    ip_allocation_policy[key] = value
-                ClusterIpAllocationPolicyArgs._configure(_setter, **ip_allocation_policy)
+            ip_allocation_policy = _utilities.configure(ip_allocation_policy, ClusterIpAllocationPolicyArgs, True)
             __props__.__dict__["ip_allocation_policy"] = ip_allocation_policy
             __props__.__dict__["location"] = location
-            if logging_config is not None and not isinstance(logging_config, ClusterLoggingConfigArgs):
-                logging_config = logging_config or {}
-                def _setter(key, value):
-                    logging_config[key] = value
-                ClusterLoggingConfigArgs._configure(_setter, **logging_config)
+            logging_config = _utilities.configure(logging_config, ClusterLoggingConfigArgs, True)
             __props__.__dict__["logging_config"] = logging_config
             __props__.__dict__["logging_service"] = logging_service
-            if maintenance_policy is not None and not isinstance(maintenance_policy, ClusterMaintenancePolicyArgs):
-                maintenance_policy = maintenance_policy or {}
-                def _setter(key, value):
-                    maintenance_policy[key] = value
-                ClusterMaintenancePolicyArgs._configure(_setter, **maintenance_policy)
+            maintenance_policy = _utilities.configure(maintenance_policy, ClusterMaintenancePolicyArgs, True)
             __props__.__dict__["maintenance_policy"] = maintenance_policy
-            if master_auth is not None and not isinstance(master_auth, ClusterMasterAuthArgs):
-                master_auth = master_auth or {}
-                def _setter(key, value):
-                    master_auth[key] = value
-                ClusterMasterAuthArgs._configure(_setter, **master_auth)
+            master_auth = _utilities.configure(master_auth, ClusterMasterAuthArgs, True)
             __props__.__dict__["master_auth"] = master_auth
-            if master_authorized_networks_config is not None and not isinstance(master_authorized_networks_config, ClusterMasterAuthorizedNetworksConfigArgs):
-                master_authorized_networks_config = master_authorized_networks_config or {}
-                def _setter(key, value):
-                    master_authorized_networks_config[key] = value
-                ClusterMasterAuthorizedNetworksConfigArgs._configure(_setter, **master_authorized_networks_config)
+            master_authorized_networks_config = _utilities.configure(master_authorized_networks_config, ClusterMasterAuthorizedNetworksConfigArgs, True)
             __props__.__dict__["master_authorized_networks_config"] = master_authorized_networks_config
-            if mesh_certificates is not None and not isinstance(mesh_certificates, ClusterMeshCertificatesArgs):
-                mesh_certificates = mesh_certificates or {}
-                def _setter(key, value):
-                    mesh_certificates[key] = value
-                ClusterMeshCertificatesArgs._configure(_setter, **mesh_certificates)
+            mesh_certificates = _utilities.configure(mesh_certificates, ClusterMeshCertificatesArgs, True)
             __props__.__dict__["mesh_certificates"] = mesh_certificates
             __props__.__dict__["min_master_version"] = min_master_version
-            if monitoring_config is not None and not isinstance(monitoring_config, ClusterMonitoringConfigArgs):
-                monitoring_config = monitoring_config or {}
-                def _setter(key, value):
-                    monitoring_config[key] = value
-                ClusterMonitoringConfigArgs._configure(_setter, **monitoring_config)
+            monitoring_config = _utilities.configure(monitoring_config, ClusterMonitoringConfigArgs, True)
             __props__.__dict__["monitoring_config"] = monitoring_config
             __props__.__dict__["monitoring_service"] = monitoring_service
             __props__.__dict__["name"] = name
             __props__.__dict__["network"] = network
-            if network_policy is not None and not isinstance(network_policy, ClusterNetworkPolicyArgs):
-                network_policy = network_policy or {}
-                def _setter(key, value):
-                    network_policy[key] = value
-                ClusterNetworkPolicyArgs._configure(_setter, **network_policy)
+            network_policy = _utilities.configure(network_policy, ClusterNetworkPolicyArgs, True)
             __props__.__dict__["network_policy"] = network_policy
             __props__.__dict__["networking_mode"] = networking_mode
-            if node_config is not None and not isinstance(node_config, ClusterNodeConfigArgs):
-                node_config = node_config or {}
-                def _setter(key, value):
-                    node_config[key] = value
-                ClusterNodeConfigArgs._configure(_setter, **node_config)
+            node_config = _utilities.configure(node_config, ClusterNodeConfigArgs, True)
             __props__.__dict__["node_config"] = node_config
             __props__.__dict__["node_locations"] = node_locations
-            if node_pool_auto_config is not None and not isinstance(node_pool_auto_config, ClusterNodePoolAutoConfigArgs):
-                node_pool_auto_config = node_pool_auto_config or {}
-                def _setter(key, value):
-                    node_pool_auto_config[key] = value
-                ClusterNodePoolAutoConfigArgs._configure(_setter, **node_pool_auto_config)
+            node_pool_auto_config = _utilities.configure(node_pool_auto_config, ClusterNodePoolAutoConfigArgs, True)
             __props__.__dict__["node_pool_auto_config"] = node_pool_auto_config
-            if node_pool_defaults is not None and not isinstance(node_pool_defaults, ClusterNodePoolDefaultsArgs):
-                node_pool_defaults = node_pool_defaults or {}
-                def _setter(key, value):
-                    node_pool_defaults[key] = value
-                ClusterNodePoolDefaultsArgs._configure(_setter, **node_pool_defaults)
+            node_pool_defaults = _utilities.configure(node_pool_defaults, ClusterNodePoolDefaultsArgs, True)
             __props__.__dict__["node_pool_defaults"] = node_pool_defaults
             __props__.__dict__["node_pools"] = node_pools
             __props__.__dict__["node_version"] = node_version
-            if notification_config is not None and not isinstance(notification_config, ClusterNotificationConfigArgs):
-                notification_config = notification_config or {}
-                def _setter(key, value):
-                    notification_config[key] = value
-                ClusterNotificationConfigArgs._configure(_setter, **notification_config)
+            notification_config = _utilities.configure(notification_config, ClusterNotificationConfigArgs, True)
             __props__.__dict__["notification_config"] = notification_config
-            if pod_security_policy_config is not None and not isinstance(pod_security_policy_config, ClusterPodSecurityPolicyConfigArgs):
-                pod_security_policy_config = pod_security_policy_config or {}
-                def _setter(key, value):
-                    pod_security_policy_config[key] = value
-                ClusterPodSecurityPolicyConfigArgs._configure(_setter, **pod_security_policy_config)
+            pod_security_policy_config = _utilities.configure(pod_security_policy_config, ClusterPodSecurityPolicyConfigArgs, True)
             __props__.__dict__["pod_security_policy_config"] = pod_security_policy_config
-            if private_cluster_config is not None and not isinstance(private_cluster_config, ClusterPrivateClusterConfigArgs):
-                private_cluster_config = private_cluster_config or {}
-                def _setter(key, value):
-                    private_cluster_config[key] = value
-                ClusterPrivateClusterConfigArgs._configure(_setter, **private_cluster_config)
+            private_cluster_config = _utilities.configure(private_cluster_config, ClusterPrivateClusterConfigArgs, True)
             __props__.__dict__["private_cluster_config"] = private_cluster_config
             __props__.__dict__["private_ipv6_google_access"] = private_ipv6_google_access
             __props__.__dict__["project"] = project
-            if protect_config is not None and not isinstance(protect_config, ClusterProtectConfigArgs):
-                protect_config = protect_config or {}
-                def _setter(key, value):
-                    protect_config[key] = value
-                ClusterProtectConfigArgs._configure(_setter, **protect_config)
+            protect_config = _utilities.configure(protect_config, ClusterProtectConfigArgs, True)
             __props__.__dict__["protect_config"] = protect_config
-            if release_channel is not None and not isinstance(release_channel, ClusterReleaseChannelArgs):
-                release_channel = release_channel or {}
-                def _setter(key, value):
-                    release_channel[key] = value
-                ClusterReleaseChannelArgs._configure(_setter, **release_channel)
+            release_channel = _utilities.configure(release_channel, ClusterReleaseChannelArgs, True)
             __props__.__dict__["release_channel"] = release_channel
             __props__.__dict__["remove_default_node_pool"] = remove_default_node_pool
             __props__.__dict__["resource_labels"] = resource_labels
-            if resource_usage_export_config is not None and not isinstance(resource_usage_export_config, ClusterResourceUsageExportConfigArgs):
-                resource_usage_export_config = resource_usage_export_config or {}
-                def _setter(key, value):
-                    resource_usage_export_config[key] = value
-                ClusterResourceUsageExportConfigArgs._configure(_setter, **resource_usage_export_config)
+            resource_usage_export_config = _utilities.configure(resource_usage_export_config, ClusterResourceUsageExportConfigArgs, True)
             __props__.__dict__["resource_usage_export_config"] = resource_usage_export_config
-            if security_posture_config is not None and not isinstance(security_posture_config, ClusterSecurityPostureConfigArgs):
-                security_posture_config = security_posture_config or {}
-                def _setter(key, value):
-                    security_posture_config[key] = value
-                ClusterSecurityPostureConfigArgs._configure(_setter, **security_posture_config)
+            security_posture_config = _utilities.configure(security_posture_config, ClusterSecurityPostureConfigArgs, True)
             __props__.__dict__["security_posture_config"] = security_posture_config
-            if service_external_ips_config is not None and not isinstance(service_external_ips_config, ClusterServiceExternalIpsConfigArgs):
-                service_external_ips_config = service_external_ips_config or {}
-                def _setter(key, value):
-                    service_external_ips_config[key] = value
-                ClusterServiceExternalIpsConfigArgs._configure(_setter, **service_external_ips_config)
+            service_external_ips_config = _utilities.configure(service_external_ips_config, ClusterServiceExternalIpsConfigArgs, True)
             __props__.__dict__["service_external_ips_config"] = service_external_ips_config
             __props__.__dict__["subnetwork"] = subnetwork
-            if tpu_config is not None and not isinstance(tpu_config, ClusterTpuConfigArgs):
-                tpu_config = tpu_config or {}
-                def _setter(key, value):
-                    tpu_config[key] = value
-                ClusterTpuConfigArgs._configure(_setter, **tpu_config)
+            tpu_config = _utilities.configure(tpu_config, ClusterTpuConfigArgs, True)
             __props__.__dict__["tpu_config"] = tpu_config
-            if vertical_pod_autoscaling is not None and not isinstance(vertical_pod_autoscaling, ClusterVerticalPodAutoscalingArgs):
-                vertical_pod_autoscaling = vertical_pod_autoscaling or {}
-                def _setter(key, value):
-                    vertical_pod_autoscaling[key] = value
-                ClusterVerticalPodAutoscalingArgs._configure(_setter, **vertical_pod_autoscaling)
+            vertical_pod_autoscaling = _utilities.configure(vertical_pod_autoscaling, ClusterVerticalPodAutoscalingArgs, True)
             __props__.__dict__["vertical_pod_autoscaling"] = vertical_pod_autoscaling
-            if workload_identity_config is not None and not isinstance(workload_identity_config, ClusterWorkloadIdentityConfigArgs):
-                workload_identity_config = workload_identity_config or {}
-                def _setter(key, value):
-                    workload_identity_config[key] = value
-                ClusterWorkloadIdentityConfigArgs._configure(_setter, **workload_identity_config)
+            workload_identity_config = _utilities.configure(workload_identity_config, ClusterWorkloadIdentityConfigArgs, True)
             __props__.__dict__["workload_identity_config"] = workload_identity_config
             __props__.__dict__["endpoint"] = None
             __props__.__dict__["label_fingerprint"] = None