# coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import copy
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from ... import _utilities
from ._enums import *

__all__ = [
    'AcceleratorConfigArgs',
    'AddonsConfigArgs',
    'AdvancedMachineFeaturesArgs',
    'AuthenticatorGroupsConfigArgs',
    'AutoUpgradeOptionsArgs',
    'AutopilotArgs',
    'AutoprovisioningNodePoolDefaultsArgs',
    'BigQueryDestinationArgs',
    'BinaryAuthorizationArgs',
    'BlueGreenSettingsArgs',
    'CidrBlockArgs',
    'ClientCertificateConfigArgs',
    'CloudRunConfigArgs',
    'ClusterAutoscalingArgs',
    'ClusterTelemetryArgs',
    'ConfidentialNodesArgs',
    'ConfigConnectorConfigArgs',
    'ConsumptionMeteringConfigArgs',
    'CostManagementConfigArgs',
    'DNSConfigArgs',
    'DailyMaintenanceWindowArgs',
    'DatabaseEncryptionArgs',
    'DefaultSnatStatusArgs',
    'DnsCacheConfigArgs',
    'EphemeralStorageConfigArgs',
    'EphemeralStorageLocalSsdConfigArgs',
    'FastSocketArgs',
    'FilterArgs',
    'FleetArgs',
    'GPUSharingConfigArgs',
    'GatewayAPIConfigArgs',
    'GcePersistentDiskCsiDriverConfigArgs',
    'GcfsConfigArgs',
    'GcpFilestoreCsiDriverConfigArgs',
    'GcsFuseCsiDriverConfigArgs',
    'GkeBackupAgentConfigArgs',
    'HorizontalPodAutoscalingArgs',
    'HttpLoadBalancingArgs',
    'IPAllocationPolicyArgs',
    'IdentityServiceConfigArgs',
    'IstioConfigArgs',
    'KalmConfigArgs',
    'KubernetesDashboardArgs',
    'LegacyAbacArgs',
    'LinuxNodeConfigArgs',
    'LocalNvmeSsdBlockConfigArgs',
    'LoggingComponentConfigArgs',
    'LoggingConfigArgs',
    'LoggingVariantConfigArgs',
    'MaintenanceExclusionOptionsArgs',
    'MaintenancePolicyArgs',
    'MaintenanceWindowArgs',
    'ManagedPrometheusConfigArgs',
    'MasterAuthorizedNetworksConfigArgs',
    'MasterAuthArgs',
    'MasterArgs',
    'MaxPodsConstraintArgs',
    'MeshCertificatesArgs',
    'MonitoringComponentConfigArgs',
    'MonitoringConfigArgs',
    'NetworkConfigArgs',
    'NetworkPerformanceConfigArgs',
    'NetworkPolicyConfigArgs',
    'NetworkPolicyArgs',
    'NetworkTagsArgs',
    'NodeConfigDefaultsArgs',
    'NodeConfigArgs',
    'NodeKubeletConfigArgs',
    'NodeManagementArgs',
    'NodeNetworkConfigArgs',
    'NodePoolAutoConfigArgs',
    'NodePoolAutoscalingArgs',
    'NodePoolDefaultsArgs',
    'NodePoolLoggingConfigArgs',
    'NodePoolArgs',
    'NodeTaintArgs',
    'NotificationConfigArgs',
    'PlacementPolicyArgs',
    'PodCIDROverprovisionConfigArgs',
    'PodSecurityPolicyConfigArgs',
    'PrivateClusterConfigArgs',
    'PrivateClusterMasterGlobalAccessConfigArgs',
    'ProtectConfigArgs',
    'PubSubArgs',
    'RecurringTimeWindowArgs',
    'ReleaseChannelArgs',
    'ReservationAffinityArgs',
    'ResourceLimitArgs',
    'ResourceUsageExportConfigArgs',
    'SandboxConfigArgs',
    'ServiceExternalIPsConfigArgs',
    'ShieldedInstanceConfigArgs',
    'ShieldedNodesArgs',
    'StandardRolloutPolicyArgs',
    'StatusConditionArgs',
    'TimeWindowArgs',
    'TpuConfigArgs',
    'UpgradeSettingsArgs',
    'VerticalPodAutoscalingArgs',
    'VirtualNICArgs',
    'WindowsNodeConfigArgs',
    'WorkloadALTSConfigArgs',
    'WorkloadCertificatesArgs',
    'WorkloadConfigArgs',
    'WorkloadIdentityConfigArgs',
    'WorkloadMetadataConfigArgs',
]

@pulumi.input_type
class AcceleratorConfigArgs:
    def __init__(__self__, *,
                 accelerator_count: Optional[pulumi.Input[str]] = None,
                 accelerator_type: Optional[pulumi.Input[str]] = None,
                 gpu_partition_size: Optional[pulumi.Input[str]] = None,
                 gpu_sharing_config: Optional[pulumi.Input['GPUSharingConfigArgs']] = None,
                 max_time_shared_clients_per_gpu: Optional[pulumi.Input[str]] = None):
        """
        AcceleratorConfig represents a Hardware Accelerator request.
        :param pulumi.Input[str] accelerator_count: The number of the accelerator cards exposed to an instance.
        :param pulumi.Input[str] accelerator_type: The accelerator type resource name. List of supported accelerators [here](https://cloud.google.com/compute/docs/gpus)
        :param pulumi.Input[str] gpu_partition_size: Size of partitions to create on the GPU. Valid values are described in the NVIDIA [mig user guide](https://docs.nvidia.com/datacenter/tesla/mig-user-guide/#partitioning).
        :param pulumi.Input['GPUSharingConfigArgs'] gpu_sharing_config: The configuration for GPU sharing options.
        :param pulumi.Input[str] max_time_shared_clients_per_gpu: The number of time-shared GPU resources to expose for each physical GPU.
        """
        if accelerator_count is not None:
            pulumi.set(__self__, "accelerator_count", accelerator_count)
        if accelerator_type is not None:
            pulumi.set(__self__, "accelerator_type", accelerator_type)
        if gpu_partition_size is not None:
            pulumi.set(__self__, "gpu_partition_size", gpu_partition_size)
        if gpu_sharing_config is not None:
            pulumi.set(__self__, "gpu_sharing_config", gpu_sharing_config)
        if max_time_shared_clients_per_gpu is not None:
            pulumi.set(__self__, "max_time_shared_clients_per_gpu", max_time_shared_clients_per_gpu)

    @property
    @pulumi.getter(name="acceleratorCount")
    def accelerator_count(self) -> Optional[pulumi.Input[str]]:
        """
        The number of the accelerator cards exposed to an instance.
        """
        return pulumi.get(self, "accelerator_count")

    @accelerator_count.setter
    def accelerator_count(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "accelerator_count", value)

    @property
    @pulumi.getter(name="acceleratorType")
    def accelerator_type(self) -> Optional[pulumi.Input[str]]:
        """
        The accelerator type resource name. List of supported accelerators [here](https://cloud.google.com/compute/docs/gpus)
        """
        return pulumi.get(self, "accelerator_type")

    @accelerator_type.setter
    def accelerator_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "accelerator_type", value)

    @property
    @pulumi.getter(name="gpuPartitionSize")
    def gpu_partition_size(self) -> Optional[pulumi.Input[str]]:
        """
        Size of partitions to create on the GPU. Valid values are described in the NVIDIA [mig user guide](https://docs.nvidia.com/datacenter/tesla/mig-user-guide/#partitioning).
        """
        return pulumi.get(self, "gpu_partition_size")

    @gpu_partition_size.setter
    def gpu_partition_size(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "gpu_partition_size", value)

    @property
    @pulumi.getter(name="gpuSharingConfig")
    def gpu_sharing_config(self) -> Optional[pulumi.Input['GPUSharingConfigArgs']]:
        """
        The configuration for GPU sharing options.
        """
        return pulumi.get(self, "gpu_sharing_config")

    @gpu_sharing_config.setter
    def gpu_sharing_config(self, value: Optional[pulumi.Input['GPUSharingConfigArgs']]):
        pulumi.set(self, "gpu_sharing_config", value)

    @property
    @pulumi.getter(name="maxTimeSharedClientsPerGpu")
    def max_time_shared_clients_per_gpu(self) -> Optional[pulumi.Input[str]]:
        """
        The number of time-shared GPU resources to expose for each physical GPU.
        """
        return pulumi.get(self, "max_time_shared_clients_per_gpu")

    @max_time_shared_clients_per_gpu.setter
    def max_time_shared_clients_per_gpu(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "max_time_shared_clients_per_gpu", value)


@pulumi.input_type
class AddonsConfigArgs:
    def __init__(__self__, *,
                 cloud_run_config: Optional[pulumi.Input['CloudRunConfigArgs']] = None,
                 config_connector_config: Optional[pulumi.Input['ConfigConnectorConfigArgs']] = None,
                 dns_cache_config: Optional[pulumi.Input['DnsCacheConfigArgs']] = None,
                 gce_persistent_disk_csi_driver_config: Optional[pulumi.Input['GcePersistentDiskCsiDriverConfigArgs']] = None,
                 gcp_filestore_csi_driver_config: Optional[pulumi.Input['GcpFilestoreCsiDriverConfigArgs']] = None,
                 gcs_fuse_csi_driver_config: Optional[pulumi.Input['GcsFuseCsiDriverConfigArgs']] = None,
                 gke_backup_agent_config: Optional[pulumi.Input['GkeBackupAgentConfigArgs']] = None,
                 horizontal_pod_autoscaling: Optional[pulumi.Input['HorizontalPodAutoscalingArgs']] = None,
                 http_load_balancing: Optional[pulumi.Input['HttpLoadBalancingArgs']] = None,
                 istio_config: Optional[pulumi.Input['IstioConfigArgs']] = None,
                 kalm_config: Optional[pulumi.Input['KalmConfigArgs']] = None,
                 kubernetes_dashboard: Optional[pulumi.Input['KubernetesDashboardArgs']] = None,
                 network_policy_config: Optional[pulumi.Input['NetworkPolicyConfigArgs']] = None):
        """
        Configuration for the addons that can be automatically spun up in the cluster, enabling additional functionality.
        :param pulumi.Input['CloudRunConfigArgs'] cloud_run_config: Configuration for the Cloud Run addon. The `IstioConfig` addon must be enabled in order to enable Cloud Run addon. This option can only be enabled at cluster creation time.
        :param pulumi.Input['ConfigConnectorConfigArgs'] config_connector_config: Configuration for the ConfigConnector add-on, a Kubernetes extension to manage hosted GCP services through the Kubernetes API
        :param pulumi.Input['DnsCacheConfigArgs'] dns_cache_config: Configuration for NodeLocalDNS, a dns cache running on cluster nodes
        :param pulumi.Input['GcePersistentDiskCsiDriverConfigArgs'] gce_persistent_disk_csi_driver_config: Configuration for the Compute Engine Persistent Disk CSI driver.
        :param pulumi.Input['GcpFilestoreCsiDriverConfigArgs'] gcp_filestore_csi_driver_config: Configuration for the GCP Filestore CSI driver.
        :param pulumi.Input['GcsFuseCsiDriverConfigArgs'] gcs_fuse_csi_driver_config: Configuration for the Cloud Storage Fuse CSI driver.
        :param pulumi.Input['GkeBackupAgentConfigArgs'] gke_backup_agent_config: Configuration for the Backup for GKE agent addon.
        :param pulumi.Input['HorizontalPodAutoscalingArgs'] horizontal_pod_autoscaling: Configuration for the horizontal pod autoscaling feature, which increases or decreases the number of replica pods a replication controller has based on the resource usage of the existing pods.
        :param pulumi.Input['HttpLoadBalancingArgs'] http_load_balancing: Configuration for the HTTP (L7) load balancing controller addon, which makes it easy to set up HTTP load balancers for services in a cluster.
        :param pulumi.Input['IstioConfigArgs'] istio_config: Configuration for Istio, an open platform to connect, manage, and secure microservices.
        :param pulumi.Input['KalmConfigArgs'] kalm_config: Configuration for the KALM addon, which manages the lifecycle of k8s applications.
        :param pulumi.Input['KubernetesDashboardArgs'] kubernetes_dashboard: Configuration for the Kubernetes Dashboard. This addon is deprecated, and will be disabled in 1.15. It is recommended to use the Cloud Console to manage and monitor your Kubernetes clusters, workloads and applications. For more information, see: https://cloud.google.com/kubernetes-engine/docs/concepts/dashboards
        :param pulumi.Input['NetworkPolicyConfigArgs'] network_policy_config: Configuration for NetworkPolicy. This only tracks whether the addon is enabled or not on the Master, it does not track whether network policy is enabled for the nodes.
        """
        if cloud_run_config is not None:
            pulumi.set(__self__, "cloud_run_config", cloud_run_config)
        if config_connector_config is not None:
            pulumi.set(__self__, "config_connector_config", config_connector_config)
        if dns_cache_config is not None:
            pulumi.set(__self__, "dns_cache_config", dns_cache_config)
        if gce_persistent_disk_csi_driver_config is not None:
            pulumi.set(__self__, "gce_persistent_disk_csi_driver_config", gce_persistent_disk_csi_driver_config)
        if gcp_filestore_csi_driver_config is not None:
            pulumi.set(__self__, "gcp_filestore_csi_driver_config", gcp_filestore_csi_driver_config)
        if gcs_fuse_csi_driver_config is not None:
            pulumi.set(__self__, "gcs_fuse_csi_driver_config", gcs_fuse_csi_driver_config)
        if gke_backup_agent_config is not None:
            pulumi.set(__self__, "gke_backup_agent_config", gke_backup_agent_config)
        if horizontal_pod_autoscaling is not None:
            pulumi.set(__self__, "horizontal_pod_autoscaling", horizontal_pod_autoscaling)
        if http_load_balancing is not None:
            pulumi.set(__self__, "http_load_balancing", http_load_balancing)
        if istio_config is not None:
            pulumi.set(__self__, "istio_config", istio_config)
        if kalm_config is not None:
            pulumi.set(__self__, "kalm_config", kalm_config)
        if kubernetes_dashboard is not None:
            pulumi.set(__self__, "kubernetes_dashboard", kubernetes_dashboard)
        if network_policy_config is not None:
            pulumi.set(__self__, "network_policy_config", network_policy_config)

    @property
    @pulumi.getter(name="cloudRunConfig")
    def cloud_run_config(self) -> Optional[pulumi.Input['CloudRunConfigArgs']]:
        """
        Configuration for the Cloud Run addon. The `IstioConfig` addon must be enabled in order to enable Cloud Run addon. This option can only be enabled at cluster creation time.
        """
        return pulumi.get(self, "cloud_run_config")

    @cloud_run_config.setter
    def cloud_run_config(self, value: Optional[pulumi.Input['CloudRunConfigArgs']]):
        pulumi.set(self, "cloud_run_config", value)

    @property
    @pulumi.getter(name="configConnectorConfig")
    def config_connector_config(self) -> Optional[pulumi.Input['ConfigConnectorConfigArgs']]:
        """
        Configuration for the ConfigConnector add-on, a Kubernetes extension to manage hosted GCP services through the Kubernetes API
        """
        return pulumi.get(self, "config_connector_config")

    @config_connector_config.setter
    def config_connector_config(self, value: Optional[pulumi.Input['ConfigConnectorConfigArgs']]):
        pulumi.set(self, "config_connector_config", value)

    @property
    @pulumi.getter(name="dnsCacheConfig")
    def dns_cache_config(self) -> Optional[pulumi.Input['DnsCacheConfigArgs']]:
        """
        Configuration for NodeLocalDNS, a dns cache running on cluster nodes
        """
        return pulumi.get(self, "dns_cache_config")

    @dns_cache_config.setter
    def dns_cache_config(self, value: Optional[pulumi.Input['DnsCacheConfigArgs']]):
        pulumi.set(self, "dns_cache_config", value)

    @property
    @pulumi.getter(name="gcePersistentDiskCsiDriverConfig")
    def gce_persistent_disk_csi_driver_config(self) -> Optional[pulumi.Input['GcePersistentDiskCsiDriverConfigArgs']]:
        """
        Configuration for the Compute Engine Persistent Disk CSI driver.
        """
        return pulumi.get(self, "gce_persistent_disk_csi_driver_config")

    @gce_persistent_disk_csi_driver_config.setter
    def gce_persistent_disk_csi_driver_config(self, value: Optional[pulumi.Input['GcePersistentDiskCsiDriverConfigArgs']]):
        pulumi.set(self, "gce_persistent_disk_csi_driver_config", value)

    @property
    @pulumi.getter(name="gcpFilestoreCsiDriverConfig")
    def gcp_filestore_csi_driver_config(self) -> Optional[pulumi.Input['GcpFilestoreCsiDriverConfigArgs']]:
        """
        Configuration for the GCP Filestore CSI driver.
        """
        return pulumi.get(self, "gcp_filestore_csi_driver_config")

    @gcp_filestore_csi_driver_config.setter
    def gcp_filestore_csi_driver_config(self, value: Optional[pulumi.Input['GcpFilestoreCsiDriverConfigArgs']]):
        pulumi.set(self, "gcp_filestore_csi_driver_config", value)

    @property
    @pulumi.getter(name="gcsFuseCsiDriverConfig")
    def gcs_fuse_csi_driver_config(self) -> Optional[pulumi.Input['GcsFuseCsiDriverConfigArgs']]:
        """
        Configuration for the Cloud Storage Fuse CSI driver.
        """
        return pulumi.get(self, "gcs_fuse_csi_driver_config")

    @gcs_fuse_csi_driver_config.setter
    def gcs_fuse_csi_driver_config(self, value: Optional[pulumi.Input['GcsFuseCsiDriverConfigArgs']]):
        pulumi.set(self, "gcs_fuse_csi_driver_config", value)

    @property
    @pulumi.getter(name="gkeBackupAgentConfig")
    def gke_backup_agent_config(self) -> Optional[pulumi.Input['GkeBackupAgentConfigArgs']]:
        """
        Configuration for the Backup for GKE agent addon.
        """
        return pulumi.get(self, "gke_backup_agent_config")

    @gke_backup_agent_config.setter
    def gke_backup_agent_config(self, value: Optional[pulumi.Input['GkeBackupAgentConfigArgs']]):
        pulumi.set(self, "gke_backup_agent_config", value)

    @property
    @pulumi.getter(name="horizontalPodAutoscaling")
    def horizontal_pod_autoscaling(self) -> Optional[pulumi.Input['HorizontalPodAutoscalingArgs']]:
        """
        Configuration for the horizontal pod autoscaling feature, which increases or decreases the number of replica pods a replication controller has based on the resource usage of the existing pods.
        """
        return pulumi.get(self, "horizontal_pod_autoscaling")

    @horizontal_pod_autoscaling.setter
    def horizontal_pod_autoscaling(self, value: Optional[pulumi.Input['HorizontalPodAutoscalingArgs']]):
        pulumi.set(self, "horizontal_pod_autoscaling", value)

    @property
    @pulumi.getter(name="httpLoadBalancing")
    def http_load_balancing(self) -> Optional[pulumi.Input['HttpLoadBalancingArgs']]:
        """
        Configuration for the HTTP (L7) load balancing controller addon, which makes it easy to set up HTTP load balancers for services in a cluster.
        """
        return pulumi.get(self, "http_load_balancing")

    @http_load_balancing.setter
    def http_load_balancing(self, value: Optional[pulumi.Input['HttpLoadBalancingArgs']]):
        pulumi.set(self, "http_load_balancing", value)

    @property
    @pulumi.getter(name="istioConfig")
    def istio_config(self) -> Optional[pulumi.Input['IstioConfigArgs']]:
        """
        Configuration for Istio, an open platform to connect, manage, and secure microservices.
        """
        return pulumi.get(self, "istio_config")

    @istio_config.setter
    def istio_config(self, value: Optional[pulumi.Input['IstioConfigArgs']]):
        pulumi.set(self, "istio_config", value)

    @property
    @pulumi.getter(name="kalmConfig")
    def kalm_config(self) -> Optional[pulumi.Input['KalmConfigArgs']]:
        """
        Configuration for the KALM addon, which manages the lifecycle of k8s applications.
        """
        return pulumi.get(self, "kalm_config")

    @kalm_config.setter
    def kalm_config(self, value: Optional[pulumi.Input['KalmConfigArgs']]):
        pulumi.set(self, "kalm_config", value)

    @property
    @pulumi.getter(name="kubernetesDashboard")
    def kubernetes_dashboard(self) -> Optional[pulumi.Input['KubernetesDashboardArgs']]:
        """
        Configuration for the Kubernetes Dashboard. This addon is deprecated, and will be disabled in 1.15. It is recommended to use the Cloud Console to manage and monitor your Kubernetes clusters, workloads and applications. For more information, see: https://cloud.google.com/kubernetes-engine/docs/concepts/dashboards
        """
        return pulumi.get(self, "kubernetes_dashboard")

    @kubernetes_dashboard.setter
    def kubernetes_dashboard(self, value: Optional[pulumi.Input['KubernetesDashboardArgs']]):
        pulumi.set(self, "kubernetes_dashboard", value)

    @property
    @pulumi.getter(name="networkPolicyConfig")
    def network_policy_config(self) -> Optional[pulumi.Input['NetworkPolicyConfigArgs']]:
        """
        Configuration for NetworkPolicy. This only tracks whether the addon is enabled or not on the Master, it does not track whether network policy is enabled for the nodes.
        """
        return pulumi.get(self, "network_policy_config")

    @network_policy_config.setter
    def network_policy_config(self, value: Optional[pulumi.Input['NetworkPolicyConfigArgs']]):
        pulumi.set(self, "network_policy_config", value)


@pulumi.input_type
class AdvancedMachineFeaturesArgs:
    def __init__(__self__, *,
                 threads_per_core: Optional[pulumi.Input[str]] = None):
        """
        Specifies options for controlling advanced machine features.
        :param pulumi.Input[str] threads_per_core: The number of threads per physical core. To disable simultaneous multithreading (SMT) set this to 1. If unset, the maximum number of threads supported per core by the underlying processor is assumed.
        """
        if threads_per_core is not None:
            pulumi.set(__self__, "threads_per_core", threads_per_core)

    @property
    @pulumi.getter(name="threadsPerCore")
    def threads_per_core(self) -> Optional[pulumi.Input[str]]:
        """
        The number of threads per physical core. To disable simultaneous multithreading (SMT) set this to 1. If unset, the maximum number of threads supported per core by the underlying processor is assumed.
        """
        return pulumi.get(self, "threads_per_core")

    @threads_per_core.setter
    def threads_per_core(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "threads_per_core", value)


@pulumi.input_type
class AuthenticatorGroupsConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 security_group: Optional[pulumi.Input[str]] = None):
        """
        Configuration for returning group information from authenticators.
        :param pulumi.Input[bool] enabled: Whether this cluster should return group membership lookups during authentication using a group of security groups.
        :param pulumi.Input[str] security_group: The name of the security group-of-groups to be used. Only relevant if enabled = true.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if security_group is not None:
            pulumi.set(__self__, "security_group", security_group)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether this cluster should return group membership lookups during authentication using a group of security groups.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter(name="securityGroup")
    def security_group(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the security group-of-groups to be used. Only relevant if enabled = true.
        """
        return pulumi.get(self, "security_group")

    @security_group.setter
    def security_group(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "security_group", value)


@pulumi.input_type
class AutoUpgradeOptionsArgs:
    def __init__(__self__):
        """
        AutoUpgradeOptions defines the set of options for the user to control how the Auto Upgrades will proceed.
        """
        pass


@pulumi.input_type
class AutopilotArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Autopilot is the configuration for Autopilot settings on the cluster.
        :param pulumi.Input[bool] enabled: Enable Autopilot
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable Autopilot
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class AutoprovisioningNodePoolDefaultsArgs:
    def __init__(__self__, *,
                 boot_disk_kms_key: Optional[pulumi.Input[str]] = None,
                 disk_size_gb: Optional[pulumi.Input[int]] = None,
                 disk_type: Optional[pulumi.Input[str]] = None,
                 image_type: Optional[pulumi.Input[str]] = None,
                 management: Optional[pulumi.Input['NodeManagementArgs']] = None,
                 min_cpu_platform: Optional[pulumi.Input[str]] = None,
                 oauth_scopes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 service_account: Optional[pulumi.Input[str]] = None,
                 shielded_instance_config: Optional[pulumi.Input['ShieldedInstanceConfigArgs']] = None,
                 upgrade_settings: Optional[pulumi.Input['UpgradeSettingsArgs']] = None):
        """
        AutoprovisioningNodePoolDefaults contains defaults for a node pool created by NAP.
        :param pulumi.Input[str] boot_disk_kms_key:  The Customer Managed Encryption Key used to encrypt the boot disk attached to each node in the node pool. This should be of the form projects/[KEY_PROJECT_ID]/locations/[LOCATION]/keyRings/[RING_NAME]/cryptoKeys/[KEY_NAME]. For more information about protecting resources with Cloud KMS Keys please see: https://cloud.google.com/compute/docs/disks/customer-managed-encryption
        :param pulumi.Input[int] disk_size_gb: Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB. If unspecified, the default disk size is 100GB.
        :param pulumi.Input[str] disk_type: Type of the disk attached to each node (e.g. 'pd-standard', 'pd-ssd' or 'pd-balanced') If unspecified, the default disk type is 'pd-standard'
        :param pulumi.Input[str] image_type: The image type to use for NAP created node. Please see https://cloud.google.com/kubernetes-engine/docs/concepts/node-images for available image types.
        :param pulumi.Input['NodeManagementArgs'] management: NodeManagement configuration for this NodePool.
        :param pulumi.Input[str] min_cpu_platform: Deprecated. Minimum CPU platform to be used for NAP created node pools. The instance may be scheduled on the specified or newer CPU platform. Applicable values are the friendly names of CPU platforms, such as minCpuPlatform: Intel Haswell or minCpuPlatform: Intel Sandy Bridge. For more information, read [how to specify min CPU platform](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform). This field is deprecated, min_cpu_platform should be specified using `cloud.google.com/requested-min-cpu-platform` label selector on the pod. To unset the min cpu platform field pass "automatic" as field value.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] oauth_scopes: The set of Google API scopes to be made available on all of the node VMs under the "default" service account. The following scopes are recommended, but not required, and by default are not included: * `https://www.googleapis.com/auth/compute` is required for mounting persistent storage on your nodes. * `https://www.googleapis.com/auth/devstorage.read_only` is required for communicating with **gcr.io** (the [Google Container Registry](https://cloud.google.com/container-registry/)). If unspecified, no scopes are added, unless Cloud Logging or Cloud Monitoring are enabled, in which case their required scopes will be added.
        :param pulumi.Input[str] service_account: The Google Cloud Platform Service Account to be used by the node VMs. Specify the email address of the Service Account; otherwise, if no Service Account is specified, the "default" service account is used.
        :param pulumi.Input['ShieldedInstanceConfigArgs'] shielded_instance_config: Shielded Instance options.
        :param pulumi.Input['UpgradeSettingsArgs'] upgrade_settings: Upgrade settings control disruption and speed of the upgrade.
        """
        if boot_disk_kms_key is not None:
            pulumi.set(__self__, "boot_disk_kms_key", boot_disk_kms_key)
        if disk_size_gb is not None:
            pulumi.set(__self__, "disk_size_gb", disk_size_gb)
        if disk_type is not None:
            pulumi.set(__self__, "disk_type", disk_type)
        if image_type is not None:
            pulumi.set(__self__, "image_type", image_type)
        if management is not None:
            pulumi.set(__self__, "management", management)
        if min_cpu_platform is not None:
            warnings.warn("""Deprecated. Minimum CPU platform to be used for NAP created node pools. The instance may be scheduled on the specified or newer CPU platform. Applicable values are the friendly names of CPU platforms, such as minCpuPlatform: Intel Haswell or minCpuPlatform: Intel Sandy Bridge. For more information, read [how to specify min CPU platform](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform). This field is deprecated, min_cpu_platform should be specified using `cloud.google.com/requested-min-cpu-platform` label selector on the pod. To unset the min cpu platform field pass \"automatic\" as field value.""", DeprecationWarning)
            pulumi.log.warn("""min_cpu_platform is deprecated: Deprecated. Minimum CPU platform to be used for NAP created node pools. The instance may be scheduled on the specified or newer CPU platform. Applicable values are the friendly names of CPU platforms, such as minCpuPlatform: Intel Haswell or minCpuPlatform: Intel Sandy Bridge. For more information, read [how to specify min CPU platform](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform). This field is deprecated, min_cpu_platform should be specified using `cloud.google.com/requested-min-cpu-platform` label selector on the pod. To unset the min cpu platform field pass \"automatic\" as field value.""")
        if min_cpu_platform is not None:
            pulumi.set(__self__, "min_cpu_platform", min_cpu_platform)
        if oauth_scopes is not None:
            pulumi.set(__self__, "oauth_scopes", oauth_scopes)
        if service_account is not None:
            pulumi.set(__self__, "service_account", service_account)
        if shielded_instance_config is not None:
            pulumi.set(__self__, "shielded_instance_config", shielded_instance_config)
        if upgrade_settings is not None:
            pulumi.set(__self__, "upgrade_settings", upgrade_settings)

    @property
    @pulumi.getter(name="bootDiskKmsKey")
    def boot_disk_kms_key(self) -> Optional[pulumi.Input[str]]:
        """
         The Customer Managed Encryption Key used to encrypt the boot disk attached to each node in the node pool. This should be of the form projects/[KEY_PROJECT_ID]/locations/[LOCATION]/keyRings/[RING_NAME]/cryptoKeys/[KEY_NAME]. For more information about protecting resources with Cloud KMS Keys please see: https://cloud.google.com/compute/docs/disks/customer-managed-encryption
        """
        return pulumi.get(self, "boot_disk_kms_key")

    @boot_disk_kms_key.setter
    def boot_disk_kms_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "boot_disk_kms_key", value)

    @property
    @pulumi.getter(name="diskSizeGb")
    def disk_size_gb(self) -> Optional[pulumi.Input[int]]:
        """
        Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB. If unspecified, the default disk size is 100GB.
        """
        return pulumi.get(self, "disk_size_gb")

    @disk_size_gb.setter
    def disk_size_gb(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "disk_size_gb", value)

    @property
    @pulumi.getter(name="diskType")
    def disk_type(self) -> Optional[pulumi.Input[str]]:
        """
        Type of the disk attached to each node (e.g. 'pd-standard', 'pd-ssd' or 'pd-balanced') If unspecified, the default disk type is 'pd-standard'
        """
        return pulumi.get(self, "disk_type")

    @disk_type.setter
    def disk_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "disk_type", value)

    @property
    @pulumi.getter(name="imageType")
    def image_type(self) -> Optional[pulumi.Input[str]]:
        """
        The image type to use for NAP created node. Please see https://cloud.google.com/kubernetes-engine/docs/concepts/node-images for available image types.
        """
        return pulumi.get(self, "image_type")

    @image_type.setter
    def image_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image_type", value)

    @property
    @pulumi.getter
    def management(self) -> Optional[pulumi.Input['NodeManagementArgs']]:
        """
        NodeManagement configuration for this NodePool.
        """
        return pulumi.get(self, "management")

    @management.setter
    def management(self, value: Optional[pulumi.Input['NodeManagementArgs']]):
        pulumi.set(self, "management", value)

    @property
    @pulumi.getter(name="minCpuPlatform")
    def min_cpu_platform(self) -> Optional[pulumi.Input[str]]:
        """
        Deprecated. Minimum CPU platform to be used for NAP created node pools. The instance may be scheduled on the specified or newer CPU platform. Applicable values are the friendly names of CPU platforms, such as minCpuPlatform: Intel Haswell or minCpuPlatform: Intel Sandy Bridge. For more information, read [how to specify min CPU platform](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform). This field is deprecated, min_cpu_platform should be specified using `cloud.google.com/requested-min-cpu-platform` label selector on the pod. To unset the min cpu platform field pass "automatic" as field value.
        """
        warnings.warn("""Deprecated. Minimum CPU platform to be used for NAP created node pools. The instance may be scheduled on the specified or newer CPU platform. Applicable values are the friendly names of CPU platforms, such as minCpuPlatform: Intel Haswell or minCpuPlatform: Intel Sandy Bridge. For more information, read [how to specify min CPU platform](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform). This field is deprecated, min_cpu_platform should be specified using `cloud.google.com/requested-min-cpu-platform` label selector on the pod. To unset the min cpu platform field pass \"automatic\" as field value.""", DeprecationWarning)
        pulumi.log.warn("""min_cpu_platform is deprecated: Deprecated. Minimum CPU platform to be used for NAP created node pools. The instance may be scheduled on the specified or newer CPU platform. Applicable values are the friendly names of CPU platforms, such as minCpuPlatform: Intel Haswell or minCpuPlatform: Intel Sandy Bridge. For more information, read [how to specify min CPU platform](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform). This field is deprecated, min_cpu_platform should be specified using `cloud.google.com/requested-min-cpu-platform` label selector on the pod. To unset the min cpu platform field pass \"automatic\" as field value.""")

        return pulumi.get(self, "min_cpu_platform")

    @min_cpu_platform.setter
    def min_cpu_platform(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "min_cpu_platform", value)

    @property
    @pulumi.getter(name="oauthScopes")
    def oauth_scopes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The set of Google API scopes to be made available on all of the node VMs under the "default" service account. The following scopes are recommended, but not required, and by default are not included: * `https://www.googleapis.com/auth/compute` is required for mounting persistent storage on your nodes. * `https://www.googleapis.com/auth/devstorage.read_only` is required for communicating with **gcr.io** (the [Google Container Registry](https://cloud.google.com/container-registry/)). If unspecified, no scopes are added, unless Cloud Logging or Cloud Monitoring are enabled, in which case their required scopes will be added.
        """
        return pulumi.get(self, "oauth_scopes")

    @oauth_scopes.setter
    def oauth_scopes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "oauth_scopes", value)

    @property
    @pulumi.getter(name="serviceAccount")
    def service_account(self) -> Optional[pulumi.Input[str]]:
        """
        The Google Cloud Platform Service Account to be used by the node VMs. Specify the email address of the Service Account; otherwise, if no Service Account is specified, the "default" service account is used.
        """
        return pulumi.get(self, "service_account")

    @service_account.setter
    def service_account(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_account", value)

    @property
    @pulumi.getter(name="shieldedInstanceConfig")
    def shielded_instance_config(self) -> Optional[pulumi.Input['ShieldedInstanceConfigArgs']]:
        """
        Shielded Instance options.
        """
        return pulumi.get(self, "shielded_instance_config")

    @shielded_instance_config.setter
    def shielded_instance_config(self, value: Optional[pulumi.Input['ShieldedInstanceConfigArgs']]):
        pulumi.set(self, "shielded_instance_config", value)

    @property
    @pulumi.getter(name="upgradeSettings")
    def upgrade_settings(self) -> Optional[pulumi.Input['UpgradeSettingsArgs']]:
        """
        Upgrade settings control disruption and speed of the upgrade.
        """
        return pulumi.get(self, "upgrade_settings")

    @upgrade_settings.setter
    def upgrade_settings(self, value: Optional[pulumi.Input['UpgradeSettingsArgs']]):
        pulumi.set(self, "upgrade_settings", value)


@pulumi.input_type
class BigQueryDestinationArgs:
    def __init__(__self__, *,
                 dataset_id: Optional[pulumi.Input[str]] = None):
        """
        Parameters for using BigQuery as the destination of resource usage export.
        :param pulumi.Input[str] dataset_id: The ID of a BigQuery Dataset.
        """
        if dataset_id is not None:
            pulumi.set(__self__, "dataset_id", dataset_id)

    @property
    @pulumi.getter(name="datasetId")
    def dataset_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of a BigQuery Dataset.
        """
        return pulumi.get(self, "dataset_id")

    @dataset_id.setter
    def dataset_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dataset_id", value)


@pulumi.input_type
class BinaryAuthorizationArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 evaluation_mode: Optional[pulumi.Input['BinaryAuthorizationEvaluationMode']] = None):
        """
        Configuration for Binary Authorization.
        :param pulumi.Input[bool] enabled: This field is deprecated. Leave this unset and instead configure BinaryAuthorization using evaluation_mode. If evaluation_mode is set to anything other than EVALUATION_MODE_UNSPECIFIED, this field is ignored.
        :param pulumi.Input['BinaryAuthorizationEvaluationMode'] evaluation_mode: Mode of operation for binauthz policy evaluation. If unspecified, defaults to DISABLED.
        """
        if enabled is not None:
            warnings.warn("""This field is deprecated. Leave this unset and instead configure BinaryAuthorization using evaluation_mode. If evaluation_mode is set to anything other than EVALUATION_MODE_UNSPECIFIED, this field is ignored.""", DeprecationWarning)
            pulumi.log.warn("""enabled is deprecated: This field is deprecated. Leave this unset and instead configure BinaryAuthorization using evaluation_mode. If evaluation_mode is set to anything other than EVALUATION_MODE_UNSPECIFIED, this field is ignored.""")
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if evaluation_mode is not None:
            pulumi.set(__self__, "evaluation_mode", evaluation_mode)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        This field is deprecated. Leave this unset and instead configure BinaryAuthorization using evaluation_mode. If evaluation_mode is set to anything other than EVALUATION_MODE_UNSPECIFIED, this field is ignored.
        """
        warnings.warn("""This field is deprecated. Leave this unset and instead configure BinaryAuthorization using evaluation_mode. If evaluation_mode is set to anything other than EVALUATION_MODE_UNSPECIFIED, this field is ignored.""", DeprecationWarning)
        pulumi.log.warn("""enabled is deprecated: This field is deprecated. Leave this unset and instead configure BinaryAuthorization using evaluation_mode. If evaluation_mode is set to anything other than EVALUATION_MODE_UNSPECIFIED, this field is ignored.""")

        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter(name="evaluationMode")
    def evaluation_mode(self) -> Optional[pulumi.Input['BinaryAuthorizationEvaluationMode']]:
        """
        Mode of operation for binauthz policy evaluation. If unspecified, defaults to DISABLED.
        """
        return pulumi.get(self, "evaluation_mode")

    @evaluation_mode.setter
    def evaluation_mode(self, value: Optional[pulumi.Input['BinaryAuthorizationEvaluationMode']]):
        pulumi.set(self, "evaluation_mode", value)


@pulumi.input_type
class BlueGreenSettingsArgs:
    def __init__(__self__, *,
                 node_pool_soak_duration: Optional[pulumi.Input[str]] = None,
                 standard_rollout_policy: Optional[pulumi.Input['StandardRolloutPolicyArgs']] = None):
        """
        Settings for blue-green upgrade.
        :param pulumi.Input[str] node_pool_soak_duration: Time needed after draining entire blue pool. After this period, blue pool will be cleaned up.
        :param pulumi.Input['StandardRolloutPolicyArgs'] standard_rollout_policy: Standard policy for the blue-green upgrade.
        """
        if node_pool_soak_duration is not None:
            pulumi.set(__self__, "node_pool_soak_duration", node_pool_soak_duration)
        if standard_rollout_policy is not None:
            pulumi.set(__self__, "standard_rollout_policy", standard_rollout_policy)

    @property
    @pulumi.getter(name="nodePoolSoakDuration")
    def node_pool_soak_duration(self) -> Optional[pulumi.Input[str]]:
        """
        Time needed after draining entire blue pool. After this period, blue pool will be cleaned up.
        """
        return pulumi.get(self, "node_pool_soak_duration")

    @node_pool_soak_duration.setter
    def node_pool_soak_duration(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "node_pool_soak_duration", value)

    @property
    @pulumi.getter(name="standardRolloutPolicy")
    def standard_rollout_policy(self) -> Optional[pulumi.Input['StandardRolloutPolicyArgs']]:
        """
        Standard policy for the blue-green upgrade.
        """
        return pulumi.get(self, "standard_rollout_policy")

    @standard_rollout_policy.setter
    def standard_rollout_policy(self, value: Optional[pulumi.Input['StandardRolloutPolicyArgs']]):
        pulumi.set(self, "standard_rollout_policy", value)


@pulumi.input_type
class CidrBlockArgs:
    def __init__(__self__, *,
                 cidr_block: Optional[pulumi.Input[str]] = None,
                 display_name: Optional[pulumi.Input[str]] = None):
        """
        CidrBlock contains an optional name and one CIDR block.
        :param pulumi.Input[str] cidr_block: cidr_block must be specified in CIDR notation.
        :param pulumi.Input[str] display_name: display_name is an optional field for users to identify CIDR blocks.
        """
        if cidr_block is not None:
            pulumi.set(__self__, "cidr_block", cidr_block)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)

    @property
    @pulumi.getter(name="cidrBlock")
    def cidr_block(self) -> Optional[pulumi.Input[str]]:
        """
        cidr_block must be specified in CIDR notation.
        """
        return pulumi.get(self, "cidr_block")

    @cidr_block.setter
    def cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cidr_block", value)

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[str]]:
        """
        display_name is an optional field for users to identify CIDR blocks.
        """
        return pulumi.get(self, "display_name")

    @display_name.setter
    def display_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "display_name", value)


@pulumi.input_type
class ClientCertificateConfigArgs:
    def __init__(__self__, *,
                 issue_client_certificate: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for client certificates on the cluster.
        :param pulumi.Input[bool] issue_client_certificate: Issue a client certificate.
        """
        if issue_client_certificate is not None:
            pulumi.set(__self__, "issue_client_certificate", issue_client_certificate)

    @property
    @pulumi.getter(name="issueClientCertificate")
    def issue_client_certificate(self) -> Optional[pulumi.Input[bool]]:
        """
        Issue a client certificate.
        """
        return pulumi.get(self, "issue_client_certificate")

    @issue_client_certificate.setter
    def issue_client_certificate(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "issue_client_certificate", value)


@pulumi.input_type
class CloudRunConfigArgs:
    def __init__(__self__, *,
                 disabled: Optional[pulumi.Input[bool]] = None,
                 load_balancer_type: Optional[pulumi.Input['CloudRunConfigLoadBalancerType']] = None):
        """
        Configuration options for the Cloud Run feature.
        :param pulumi.Input[bool] disabled: Whether Cloud Run addon is enabled for this cluster.
        :param pulumi.Input['CloudRunConfigLoadBalancerType'] load_balancer_type: Which load balancer type is installed for Cloud Run.
        """
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)
        if load_balancer_type is not None:
            pulumi.set(__self__, "load_balancer_type", load_balancer_type)

    @property
    @pulumi.getter
    def disabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether Cloud Run addon is enabled for this cluster.
        """
        return pulumi.get(self, "disabled")

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disabled", value)

    @property
    @pulumi.getter(name="loadBalancerType")
    def load_balancer_type(self) -> Optional[pulumi.Input['CloudRunConfigLoadBalancerType']]:
        """
        Which load balancer type is installed for Cloud Run.
        """
        return pulumi.get(self, "load_balancer_type")

    @load_balancer_type.setter
    def load_balancer_type(self, value: Optional[pulumi.Input['CloudRunConfigLoadBalancerType']]):
        pulumi.set(self, "load_balancer_type", value)


@pulumi.input_type
class ClusterAutoscalingArgs:
    def __init__(__self__, *,
                 autoprovisioning_locations: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 autoprovisioning_node_pool_defaults: Optional[pulumi.Input['AutoprovisioningNodePoolDefaultsArgs']] = None,
                 autoscaling_profile: Optional[pulumi.Input['ClusterAutoscalingAutoscalingProfile']] = None,
                 enable_node_autoprovisioning: Optional[pulumi.Input[bool]] = None,
                 resource_limits: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceLimitArgs']]]] = None):
        """
        ClusterAutoscaling contains global, per-cluster information required by Cluster Autoscaler to automatically adjust the size of the cluster and create/delete node pools based on the current needs.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] autoprovisioning_locations: The list of Google Compute Engine [zones](https://cloud.google.com/compute/docs/zones#available) in which the NodePool's nodes can be created by NAP.
        :param pulumi.Input['AutoprovisioningNodePoolDefaultsArgs'] autoprovisioning_node_pool_defaults: AutoprovisioningNodePoolDefaults contains defaults for a node pool created by NAP.
        :param pulumi.Input['ClusterAutoscalingAutoscalingProfile'] autoscaling_profile: Defines autoscaling behaviour.
        :param pulumi.Input[bool] enable_node_autoprovisioning: Enables automatic node pool creation and deletion.
        :param pulumi.Input[Sequence[pulumi.Input['ResourceLimitArgs']]] resource_limits: Contains global constraints regarding minimum and maximum amount of resources in the cluster.
        """
        if autoprovisioning_locations is not None:
            pulumi.set(__self__, "autoprovisioning_locations", autoprovisioning_locations)
        if autoprovisioning_node_pool_defaults is not None:
            pulumi.set(__self__, "autoprovisioning_node_pool_defaults", autoprovisioning_node_pool_defaults)
        if autoscaling_profile is not None:
            pulumi.set(__self__, "autoscaling_profile", autoscaling_profile)
        if enable_node_autoprovisioning is not None:
            pulumi.set(__self__, "enable_node_autoprovisioning", enable_node_autoprovisioning)
        if resource_limits is not None:
            pulumi.set(__self__, "resource_limits", resource_limits)

    @property
    @pulumi.getter(name="autoprovisioningLocations")
    def autoprovisioning_locations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The list of Google Compute Engine [zones](https://cloud.google.com/compute/docs/zones#available) in which the NodePool's nodes can be created by NAP.
        """
        return pulumi.get(self, "autoprovisioning_locations")

    @autoprovisioning_locations.setter
    def autoprovisioning_locations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "autoprovisioning_locations", value)

    @property
    @pulumi.getter(name="autoprovisioningNodePoolDefaults")
    def autoprovisioning_node_pool_defaults(self) -> Optional[pulumi.Input['AutoprovisioningNodePoolDefaultsArgs']]:
        """
        AutoprovisioningNodePoolDefaults contains defaults for a node pool created by NAP.
        """
        return pulumi.get(self, "autoprovisioning_node_pool_defaults")

    @autoprovisioning_node_pool_defaults.setter
    def autoprovisioning_node_pool_defaults(self, value: Optional[pulumi.Input['AutoprovisioningNodePoolDefaultsArgs']]):
        pulumi.set(self, "autoprovisioning_node_pool_defaults", value)

    @property
    @pulumi.getter(name="autoscalingProfile")
    def autoscaling_profile(self) -> Optional[pulumi.Input['ClusterAutoscalingAutoscalingProfile']]:
        """
        Defines autoscaling behaviour.
        """
        return pulumi.get(self, "autoscaling_profile")

    @autoscaling_profile.setter
    def autoscaling_profile(self, value: Optional[pulumi.Input['ClusterAutoscalingAutoscalingProfile']]):
        pulumi.set(self, "autoscaling_profile", value)

    @property
    @pulumi.getter(name="enableNodeAutoprovisioning")
    def enable_node_autoprovisioning(self) -> Optional[pulumi.Input[bool]]:
        """
        Enables automatic node pool creation and deletion.
        """
        return pulumi.get(self, "enable_node_autoprovisioning")

    @enable_node_autoprovisioning.setter
    def enable_node_autoprovisioning(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_node_autoprovisioning", value)

    @property
    @pulumi.getter(name="resourceLimits")
    def resource_limits(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ResourceLimitArgs']]]]:
        """
        Contains global constraints regarding minimum and maximum amount of resources in the cluster.
        """
        return pulumi.get(self, "resource_limits")

    @resource_limits.setter
    def resource_limits(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceLimitArgs']]]]):
        pulumi.set(self, "resource_limits", value)


@pulumi.input_type
class ClusterTelemetryArgs:
    def __init__(__self__, *,
                 type: Optional[pulumi.Input['ClusterTelemetryType']] = None):
        """
        Telemetry integration for the cluster.
        :param pulumi.Input['ClusterTelemetryType'] type: Type of the integration.
        """
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input['ClusterTelemetryType']]:
        """
        Type of the integration.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input['ClusterTelemetryType']]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class ConfidentialNodesArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        ConfidentialNodes is configuration for the confidential nodes feature, which makes nodes run on confidential VMs.
        :param pulumi.Input[bool] enabled: Whether Confidential Nodes feature is enabled.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether Confidential Nodes feature is enabled.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class ConfigConnectorConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration options for the Config Connector add-on.
        :param pulumi.Input[bool] enabled: Whether Cloud Connector is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether Cloud Connector is enabled for this cluster.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class ConsumptionMeteringConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Parameters for controlling consumption metering.
        :param pulumi.Input[bool] enabled: Whether to enable consumption metering for this cluster. If enabled, a second BigQuery table will be created to hold resource consumption records.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to enable consumption metering for this cluster. If enabled, a second BigQuery table will be created to hold resource consumption records.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class CostManagementConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for fine-grained cost management feature.
        :param pulumi.Input[bool] enabled: Whether the feature is enabled or not.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the feature is enabled or not.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class DNSConfigArgs:
    def __init__(__self__, *,
                 cluster_dns: Optional[pulumi.Input['DNSConfigClusterDns']] = None,
                 cluster_dns_domain: Optional[pulumi.Input[str]] = None,
                 cluster_dns_scope: Optional[pulumi.Input['DNSConfigClusterDnsScope']] = None):
        """
        DNSConfig contains the desired set of options for configuring clusterDNS.
        :param pulumi.Input['DNSConfigClusterDns'] cluster_dns: cluster_dns indicates which in-cluster DNS provider should be used.
        :param pulumi.Input[str] cluster_dns_domain: cluster_dns_domain is the suffix used for all cluster service records.
        :param pulumi.Input['DNSConfigClusterDnsScope'] cluster_dns_scope: cluster_dns_scope indicates the scope of access to cluster DNS records.
        """
        if cluster_dns is not None:
            pulumi.set(__self__, "cluster_dns", cluster_dns)
        if cluster_dns_domain is not None:
            pulumi.set(__self__, "cluster_dns_domain", cluster_dns_domain)
        if cluster_dns_scope is not None:
            pulumi.set(__self__, "cluster_dns_scope", cluster_dns_scope)

    @property
    @pulumi.getter(name="clusterDns")
    def cluster_dns(self) -> Optional[pulumi.Input['DNSConfigClusterDns']]:
        """
        cluster_dns indicates which in-cluster DNS provider should be used.
        """
        return pulumi.get(self, "cluster_dns")

    @cluster_dns.setter
    def cluster_dns(self, value: Optional[pulumi.Input['DNSConfigClusterDns']]):
        pulumi.set(self, "cluster_dns", value)

    @property
    @pulumi.getter(name="clusterDnsDomain")
    def cluster_dns_domain(self) -> Optional[pulumi.Input[str]]:
        """
        cluster_dns_domain is the suffix used for all cluster service records.
        """
        return pulumi.get(self, "cluster_dns_domain")

    @cluster_dns_domain.setter
    def cluster_dns_domain(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_dns_domain", value)

    @property
    @pulumi.getter(name="clusterDnsScope")
    def cluster_dns_scope(self) -> Optional[pulumi.Input['DNSConfigClusterDnsScope']]:
        """
        cluster_dns_scope indicates the scope of access to cluster DNS records.
        """
        return pulumi.get(self, "cluster_dns_scope")

    @cluster_dns_scope.setter
    def cluster_dns_scope(self, value: Optional[pulumi.Input['DNSConfigClusterDnsScope']]):
        pulumi.set(self, "cluster_dns_scope", value)


@pulumi.input_type
class DailyMaintenanceWindowArgs:
    def __init__(__self__, *,
                 start_time: Optional[pulumi.Input[str]] = None):
        """
        Time window specified for daily maintenance operations.
        :param pulumi.Input[str] start_time: Time within the maintenance window to start the maintenance operations. It must be in format "HH:MM", where HH : [00-23] and MM : [00-59] GMT.
        """
        if start_time is not None:
            pulumi.set(__self__, "start_time", start_time)

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> Optional[pulumi.Input[str]]:
        """
        Time within the maintenance window to start the maintenance operations. It must be in format "HH:MM", where HH : [00-23] and MM : [00-59] GMT.
        """
        return pulumi.get(self, "start_time")

    @start_time.setter
    def start_time(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "start_time", value)


@pulumi.input_type
class DatabaseEncryptionArgs:
    def __init__(__self__, *,
                 key_name: Optional[pulumi.Input[str]] = None,
                 state: Optional[pulumi.Input['DatabaseEncryptionState']] = None):
        """
        Configuration of etcd encryption.
        :param pulumi.Input[str] key_name: Name of CloudKMS key to use for the encryption of secrets in etcd. Ex. projects/my-project/locations/global/keyRings/my-ring/cryptoKeys/my-key
        :param pulumi.Input['DatabaseEncryptionState'] state: The desired state of etcd encryption.
        """
        if key_name is not None:
            pulumi.set(__self__, "key_name", key_name)
        if state is not None:
            pulumi.set(__self__, "state", state)

    @property
    @pulumi.getter(name="keyName")
    def key_name(self) -> Optional[pulumi.Input[str]]:
        """
        Name of CloudKMS key to use for the encryption of secrets in etcd. Ex. projects/my-project/locations/global/keyRings/my-ring/cryptoKeys/my-key
        """
        return pulumi.get(self, "key_name")

    @key_name.setter
    def key_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key_name", value)

    @property
    @pulumi.getter
    def state(self) -> Optional[pulumi.Input['DatabaseEncryptionState']]:
        """
        The desired state of etcd encryption.
        """
        return pulumi.get(self, "state")

    @state.setter
    def state(self, value: Optional[pulumi.Input['DatabaseEncryptionState']]):
        pulumi.set(self, "state", value)


@pulumi.input_type
class DefaultSnatStatusArgs:
    def __init__(__self__, *,
                 disabled: Optional[pulumi.Input[bool]] = None):
        """
        DefaultSnatStatus contains the desired state of whether default sNAT should be disabled on the cluster.
        :param pulumi.Input[bool] disabled: Disables cluster default sNAT rules.
        """
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)

    @property
    @pulumi.getter
    def disabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Disables cluster default sNAT rules.
        """
        return pulumi.get(self, "disabled")

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disabled", value)


@pulumi.input_type
class DnsCacheConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for NodeLocal DNSCache
        :param pulumi.Input[bool] enabled: Whether NodeLocal DNSCache is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether NodeLocal DNSCache is enabled for this cluster.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class EphemeralStorageConfigArgs:
    def __init__(__self__, *,
                 local_ssd_count: Optional[pulumi.Input[int]] = None):
        """
        EphemeralStorageConfig contains configuration for the ephemeral storage filesystem.
        :param pulumi.Input[int] local_ssd_count: Number of local SSDs to use to back ephemeral storage. Uses NVMe interfaces. Each local SSD is 375 GB in size. If zero, it means to disable using local SSDs as ephemeral storage.
        """
        if local_ssd_count is not None:
            pulumi.set(__self__, "local_ssd_count", local_ssd_count)

    @property
    @pulumi.getter(name="localSsdCount")
    def local_ssd_count(self) -> Optional[pulumi.Input[int]]:
        """
        Number of local SSDs to use to back ephemeral storage. Uses NVMe interfaces. Each local SSD is 375 GB in size. If zero, it means to disable using local SSDs as ephemeral storage.
        """
        return pulumi.get(self, "local_ssd_count")

    @local_ssd_count.setter
    def local_ssd_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "local_ssd_count", value)


@pulumi.input_type
class EphemeralStorageLocalSsdConfigArgs:
    def __init__(__self__, *,
                 local_ssd_count: Optional[pulumi.Input[int]] = None):
        """
        EphemeralStorageLocalSsdConfig contains configuration for the node ephemeral storage using Local SSDs.
        :param pulumi.Input[int] local_ssd_count: Number of local SSDs to use to back ephemeral storage. Uses NVMe interfaces. Each local SSD is 375 GB in size. If zero, it means to disable using local SSDs as ephemeral storage. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        """
        if local_ssd_count is not None:
            pulumi.set(__self__, "local_ssd_count", local_ssd_count)

    @property
    @pulumi.getter(name="localSsdCount")
    def local_ssd_count(self) -> Optional[pulumi.Input[int]]:
        """
        Number of local SSDs to use to back ephemeral storage. Uses NVMe interfaces. Each local SSD is 375 GB in size. If zero, it means to disable using local SSDs as ephemeral storage. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        """
        return pulumi.get(self, "local_ssd_count")

    @local_ssd_count.setter
    def local_ssd_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "local_ssd_count", value)


@pulumi.input_type
class FastSocketArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration of Fast Socket feature.
        :param pulumi.Input[bool] enabled: Whether Fast Socket features are enabled in the node pool.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether Fast Socket features are enabled in the node pool.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class FilterArgs:
    def __init__(__self__, *,
                 event_type: Optional[pulumi.Input[Sequence[pulumi.Input['FilterEventTypeItem']]]] = None):
        """
        Allows filtering to one or more specific event types. If event types are present, those and only those event types will be transmitted to the cluster. Other types will be skipped. If no filter is specified, or no event types are present, all event types will be sent
        :param pulumi.Input[Sequence[pulumi.Input['FilterEventTypeItem']]] event_type: Event types to allowlist.
        """
        if event_type is not None:
            pulumi.set(__self__, "event_type", event_type)

    @property
    @pulumi.getter(name="eventType")
    def event_type(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['FilterEventTypeItem']]]]:
        """
        Event types to allowlist.
        """
        return pulumi.get(self, "event_type")

    @event_type.setter
    def event_type(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['FilterEventTypeItem']]]]):
        pulumi.set(self, "event_type", value)


@pulumi.input_type
class FleetArgs:
    def __init__(__self__, *,
                 project: Optional[pulumi.Input[str]] = None):
        """
        Fleet is the fleet configuration for the cluster.
        :param pulumi.Input[str] project: The Fleet host project(project ID or project number) where this cluster will be registered to. This field cannot be changed after the cluster has been registered.
        """
        if project is not None:
            pulumi.set(__self__, "project", project)

    @property
    @pulumi.getter
    def project(self) -> Optional[pulumi.Input[str]]:
        """
        The Fleet host project(project ID or project number) where this cluster will be registered to. This field cannot be changed after the cluster has been registered.
        """
        return pulumi.get(self, "project")

    @project.setter
    def project(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "project", value)


@pulumi.input_type
class GPUSharingConfigArgs:
    def __init__(__self__, *,
                 gpu_sharing_strategy: Optional[pulumi.Input['GPUSharingConfigGpuSharingStrategy']] = None,
                 max_shared_clients_per_gpu: Optional[pulumi.Input[str]] = None):
        """
        GPUSharingConfig represents the GPU sharing configuration for Hardware Accelerators.
        :param pulumi.Input['GPUSharingConfigGpuSharingStrategy'] gpu_sharing_strategy: The type of GPU sharing strategy to enable on the GPU node.
        :param pulumi.Input[str] max_shared_clients_per_gpu: The max number of containers that can share a physical GPU.
        """
        if gpu_sharing_strategy is not None:
            pulumi.set(__self__, "gpu_sharing_strategy", gpu_sharing_strategy)
        if max_shared_clients_per_gpu is not None:
            pulumi.set(__self__, "max_shared_clients_per_gpu", max_shared_clients_per_gpu)

    @property
    @pulumi.getter(name="gpuSharingStrategy")
    def gpu_sharing_strategy(self) -> Optional[pulumi.Input['GPUSharingConfigGpuSharingStrategy']]:
        """
        The type of GPU sharing strategy to enable on the GPU node.
        """
        return pulumi.get(self, "gpu_sharing_strategy")

    @gpu_sharing_strategy.setter
    def gpu_sharing_strategy(self, value: Optional[pulumi.Input['GPUSharingConfigGpuSharingStrategy']]):
        pulumi.set(self, "gpu_sharing_strategy", value)

    @property
    @pulumi.getter(name="maxSharedClientsPerGpu")
    def max_shared_clients_per_gpu(self) -> Optional[pulumi.Input[str]]:
        """
        The max number of containers that can share a physical GPU.
        """
        return pulumi.get(self, "max_shared_clients_per_gpu")

    @max_shared_clients_per_gpu.setter
    def max_shared_clients_per_gpu(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "max_shared_clients_per_gpu", value)


@pulumi.input_type
class GatewayAPIConfigArgs:
    def __init__(__self__, *,
                 channel: Optional[pulumi.Input['GatewayAPIConfigChannel']] = None):
        """
        GatewayAPIConfig contains the desired config of Gateway API on this cluster.
        :param pulumi.Input['GatewayAPIConfigChannel'] channel: The Gateway API release channel to use for Gateway API.
        """
        if channel is not None:
            pulumi.set(__self__, "channel", channel)

    @property
    @pulumi.getter
    def channel(self) -> Optional[pulumi.Input['GatewayAPIConfigChannel']]:
        """
        The Gateway API release channel to use for Gateway API.
        """
        return pulumi.get(self, "channel")

    @channel.setter
    def channel(self, value: Optional[pulumi.Input['GatewayAPIConfigChannel']]):
        pulumi.set(self, "channel", value)


@pulumi.input_type
class GcePersistentDiskCsiDriverConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for the Compute Engine PD CSI driver.
        :param pulumi.Input[bool] enabled: Whether the Compute Engine PD CSI driver is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the Compute Engine PD CSI driver is enabled for this cluster.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class GcfsConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        GcfsConfig contains configurations of Google Container File System.
        :param pulumi.Input[bool] enabled: Whether to use GCFS.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to use GCFS.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class GcpFilestoreCsiDriverConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for the GCP Filestore CSI driver.
        :param pulumi.Input[bool] enabled: Whether the GCP Filestore CSI driver is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the GCP Filestore CSI driver is enabled for this cluster.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class GcsFuseCsiDriverConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for the Cloud Storage Fuse CSI driver.
        :param pulumi.Input[bool] enabled: Whether the Cloud Storage Fuse CSI driver is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the Cloud Storage Fuse CSI driver is enabled for this cluster.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class GkeBackupAgentConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for the Backup for GKE Agent.
        :param pulumi.Input[bool] enabled: Whether the Backup for GKE agent is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the Backup for GKE agent is enabled for this cluster.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class HorizontalPodAutoscalingArgs:
    def __init__(__self__, *,
                 disabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration options for the horizontal pod autoscaling feature, which increases or decreases the number of replica pods a replication controller has based on the resource usage of the existing pods.
        :param pulumi.Input[bool] disabled: Whether the Horizontal Pod Autoscaling feature is enabled in the cluster. When enabled, it ensures that metrics are collected into Stackdriver Monitoring.
        """
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)

    @property
    @pulumi.getter
    def disabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the Horizontal Pod Autoscaling feature is enabled in the cluster. When enabled, it ensures that metrics are collected into Stackdriver Monitoring.
        """
        return pulumi.get(self, "disabled")

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disabled", value)


@pulumi.input_type
class HttpLoadBalancingArgs:
    def __init__(__self__, *,
                 disabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration options for the HTTP (L7) load balancing controller addon, which makes it easy to set up HTTP load balancers for services in a cluster.
        :param pulumi.Input[bool] disabled: Whether the HTTP Load Balancing controller is enabled in the cluster. When enabled, it runs a small pod in the cluster that manages the load balancers.
        """
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)

    @property
    @pulumi.getter
    def disabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the HTTP Load Balancing controller is enabled in the cluster. When enabled, it runs a small pod in the cluster that manages the load balancers.
        """
        return pulumi.get(self, "disabled")

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disabled", value)


@pulumi.input_type
class IPAllocationPolicyArgs:
    def __init__(__self__, *,
                 allow_route_overlap: Optional[pulumi.Input[bool]] = None,
                 cluster_ipv4_cidr: Optional[pulumi.Input[str]] = None,
                 cluster_ipv4_cidr_block: Optional[pulumi.Input[str]] = None,
                 cluster_secondary_range_name: Optional[pulumi.Input[str]] = None,
                 create_subnetwork: Optional[pulumi.Input[bool]] = None,
                 ipv6_access_type: Optional[pulumi.Input['IPAllocationPolicyIpv6AccessType']] = None,
                 node_ipv4_cidr: Optional[pulumi.Input[str]] = None,
                 node_ipv4_cidr_block: Optional[pulumi.Input[str]] = None,
                 pod_cidr_overprovision_config: Optional[pulumi.Input['PodCIDROverprovisionConfigArgs']] = None,
                 services_ipv4_cidr: Optional[pulumi.Input[str]] = None,
                 services_ipv4_cidr_block: Optional[pulumi.Input[str]] = None,
                 services_secondary_range_name: Optional[pulumi.Input[str]] = None,
                 stack_type: Optional[pulumi.Input['IPAllocationPolicyStackType']] = None,
                 subnetwork_name: Optional[pulumi.Input[str]] = None,
                 tpu_ipv4_cidr_block: Optional[pulumi.Input[str]] = None,
                 use_ip_aliases: Optional[pulumi.Input[bool]] = None,
                 use_routes: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for controlling how IPs are allocated in the cluster.
        :param pulumi.Input[bool] allow_route_overlap: If true, allow allocation of cluster CIDR ranges that overlap with certain kinds of network routes. By default we do not allow cluster CIDR ranges to intersect with any user declared routes. With allow_route_overlap == true, we allow overlapping with CIDR ranges that are larger than the cluster CIDR range. If this field is set to true, then cluster and services CIDRs must be fully-specified (e.g. `10.96.0.0/14`, but not `/14`), which means: 1) When `use_ip_aliases` is true, `cluster_ipv4_cidr_block` and `services_ipv4_cidr_block` must be fully-specified. 2) When `use_ip_aliases` is false, `cluster.cluster_ipv4_cidr` muse be fully-specified.
        :param pulumi.Input[str] cluster_ipv4_cidr: This field is deprecated, use cluster_ipv4_cidr_block.
        :param pulumi.Input[str] cluster_ipv4_cidr_block: The IP address range for the cluster pod IPs. If this field is set, then `cluster.cluster_ipv4_cidr` must be left blank. This field is only applicable when `use_ip_aliases` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        :param pulumi.Input[str] cluster_secondary_range_name: The name of the secondary range to be used for the cluster CIDR block. The secondary range will be used for pod IP addresses. This must be an existing secondary range associated with the cluster subnetwork. This field is only applicable with use_ip_aliases and create_subnetwork is false.
        :param pulumi.Input[bool] create_subnetwork: Whether a new subnetwork will be created automatically for the cluster. This field is only applicable when `use_ip_aliases` is true.
        :param pulumi.Input['IPAllocationPolicyIpv6AccessType'] ipv6_access_type: The ipv6 access type (internal or external) when create_subnetwork is true
        :param pulumi.Input[str] node_ipv4_cidr: This field is deprecated, use node_ipv4_cidr_block.
        :param pulumi.Input[str] node_ipv4_cidr_block: The IP address range of the instance IPs in this cluster. This is applicable only if `create_subnetwork` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        :param pulumi.Input['PodCIDROverprovisionConfigArgs'] pod_cidr_overprovision_config: [PRIVATE FIELD] Pod CIDR size overprovisioning config for the cluster. Pod CIDR size per node depends on max_pods_per_node. By default, the value of max_pods_per_node is doubled and then rounded off to next power of 2 to get the size of pod CIDR block per node. Example: max_pods_per_node of 30 would result in 64 IPs (/26). This config can disable the doubling of IPs (we still round off to next power of 2) Example: max_pods_per_node of 30 will result in 32 IPs (/27) when overprovisioning is disabled.
        :param pulumi.Input[str] services_ipv4_cidr: This field is deprecated, use services_ipv4_cidr_block.
        :param pulumi.Input[str] services_ipv4_cidr_block: The IP address range of the services IPs in this cluster. If blank, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        :param pulumi.Input[str] services_secondary_range_name: The name of the secondary range to be used as for the services CIDR block. The secondary range will be used for service ClusterIPs. This must be an existing secondary range associated with the cluster subnetwork. This field is only applicable with use_ip_aliases and create_subnetwork is false.
        :param pulumi.Input['IPAllocationPolicyStackType'] stack_type: IP stack type
        :param pulumi.Input[str] subnetwork_name: A custom subnetwork name to be used if `create_subnetwork` is true. If this field is empty, then an automatic name will be chosen for the new subnetwork.
        :param pulumi.Input[str] tpu_ipv4_cidr_block: The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.
        :param pulumi.Input[bool] use_ip_aliases: Whether alias IPs will be used for pod IPs in the cluster. This is used in conjunction with use_routes. It cannot be true if use_routes is true. If both use_ip_aliases and use_routes are false, then the server picks the default IP allocation mode
        :param pulumi.Input[bool] use_routes: Whether routes will be used for pod IPs in the cluster. This is used in conjunction with use_ip_aliases. It cannot be true if use_ip_aliases is true. If both use_ip_aliases and use_routes are false, then the server picks the default IP allocation mode
        """
        if allow_route_overlap is not None:
            pulumi.set(__self__, "allow_route_overlap", allow_route_overlap)
        if cluster_ipv4_cidr is not None:
            warnings.warn("""This field is deprecated, use cluster_ipv4_cidr_block.""", DeprecationWarning)
            pulumi.log.warn("""cluster_ipv4_cidr is deprecated: This field is deprecated, use cluster_ipv4_cidr_block.""")
        if cluster_ipv4_cidr is not None:
            pulumi.set(__self__, "cluster_ipv4_cidr", cluster_ipv4_cidr)
        if cluster_ipv4_cidr_block is not None:
            pulumi.set(__self__, "cluster_ipv4_cidr_block", cluster_ipv4_cidr_block)
        if cluster_secondary_range_name is not None:
            pulumi.set(__self__, "cluster_secondary_range_name", cluster_secondary_range_name)
        if create_subnetwork is not None:
            pulumi.set(__self__, "create_subnetwork", create_subnetwork)
        if ipv6_access_type is not None:
            pulumi.set(__self__, "ipv6_access_type", ipv6_access_type)
        if node_ipv4_cidr is not None:
            warnings.warn("""This field is deprecated, use node_ipv4_cidr_block.""", DeprecationWarning)
            pulumi.log.warn("""node_ipv4_cidr is deprecated: This field is deprecated, use node_ipv4_cidr_block.""")
        if node_ipv4_cidr is not None:
            pulumi.set(__self__, "node_ipv4_cidr", node_ipv4_cidr)
        if node_ipv4_cidr_block is not None:
            pulumi.set(__self__, "node_ipv4_cidr_block", node_ipv4_cidr_block)
        if pod_cidr_overprovision_config is not None:
            pulumi.set(__self__, "pod_cidr_overprovision_config", pod_cidr_overprovision_config)
        if services_ipv4_cidr is not None:
            warnings.warn("""This field is deprecated, use services_ipv4_cidr_block.""", DeprecationWarning)
            pulumi.log.warn("""services_ipv4_cidr is deprecated: This field is deprecated, use services_ipv4_cidr_block.""")
        if services_ipv4_cidr is not None:
            pulumi.set(__self__, "services_ipv4_cidr", services_ipv4_cidr)
        if services_ipv4_cidr_block is not None:
            pulumi.set(__self__, "services_ipv4_cidr_block", services_ipv4_cidr_block)
        if services_secondary_range_name is not None:
            pulumi.set(__self__, "services_secondary_range_name", services_secondary_range_name)
        if stack_type is not None:
            pulumi.set(__self__, "stack_type", stack_type)
        if subnetwork_name is not None:
            pulumi.set(__self__, "subnetwork_name", subnetwork_name)
        if tpu_ipv4_cidr_block is not None:
            warnings.warn("""The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.""", DeprecationWarning)
            pulumi.log.warn("""tpu_ipv4_cidr_block is deprecated: The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.""")
        if tpu_ipv4_cidr_block is not None:
            pulumi.set(__self__, "tpu_ipv4_cidr_block", tpu_ipv4_cidr_block)
        if use_ip_aliases is not None:
            pulumi.set(__self__, "use_ip_aliases", use_ip_aliases)
        if use_routes is not None:
            pulumi.set(__self__, "use_routes", use_routes)

    @property
    @pulumi.getter(name="allowRouteOverlap")
    def allow_route_overlap(self) -> Optional[pulumi.Input[bool]]:
        """
        If true, allow allocation of cluster CIDR ranges that overlap with certain kinds of network routes. By default we do not allow cluster CIDR ranges to intersect with any user declared routes. With allow_route_overlap == true, we allow overlapping with CIDR ranges that are larger than the cluster CIDR range. If this field is set to true, then cluster and services CIDRs must be fully-specified (e.g. `10.96.0.0/14`, but not `/14`), which means: 1) When `use_ip_aliases` is true, `cluster_ipv4_cidr_block` and `services_ipv4_cidr_block` must be fully-specified. 2) When `use_ip_aliases` is false, `cluster.cluster_ipv4_cidr` muse be fully-specified.
        """
        return pulumi.get(self, "allow_route_overlap")

    @allow_route_overlap.setter
    def allow_route_overlap(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "allow_route_overlap", value)

    @property
    @pulumi.getter(name="clusterIpv4Cidr")
    def cluster_ipv4_cidr(self) -> Optional[pulumi.Input[str]]:
        """
        This field is deprecated, use cluster_ipv4_cidr_block.
        """
        warnings.warn("""This field is deprecated, use cluster_ipv4_cidr_block.""", DeprecationWarning)
        pulumi.log.warn("""cluster_ipv4_cidr is deprecated: This field is deprecated, use cluster_ipv4_cidr_block.""")

        return pulumi.get(self, "cluster_ipv4_cidr")

    @cluster_ipv4_cidr.setter
    def cluster_ipv4_cidr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_ipv4_cidr", value)

    @property
    @pulumi.getter(name="clusterIpv4CidrBlock")
    def cluster_ipv4_cidr_block(self) -> Optional[pulumi.Input[str]]:
        """
        The IP address range for the cluster pod IPs. If this field is set, then `cluster.cluster_ipv4_cidr` must be left blank. This field is only applicable when `use_ip_aliases` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        """
        return pulumi.get(self, "cluster_ipv4_cidr_block")

    @cluster_ipv4_cidr_block.setter
    def cluster_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_ipv4_cidr_block", value)

    @property
    @pulumi.getter(name="clusterSecondaryRangeName")
    def cluster_secondary_range_name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the secondary range to be used for the cluster CIDR block. The secondary range will be used for pod IP addresses. This must be an existing secondary range associated with the cluster subnetwork. This field is only applicable with use_ip_aliases and create_subnetwork is false.
        """
        return pulumi.get(self, "cluster_secondary_range_name")

    @cluster_secondary_range_name.setter
    def cluster_secondary_range_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_secondary_range_name", value)

    @property
    @pulumi.getter(name="createSubnetwork")
    def create_subnetwork(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether a new subnetwork will be created automatically for the cluster. This field is only applicable when `use_ip_aliases` is true.
        """
        return pulumi.get(self, "create_subnetwork")

    @create_subnetwork.setter
    def create_subnetwork(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "create_subnetwork", value)

    @property
    @pulumi.getter(name="ipv6AccessType")
    def ipv6_access_type(self) -> Optional[pulumi.Input['IPAllocationPolicyIpv6AccessType']]:
        """
        The ipv6 access type (internal or external) when create_subnetwork is true
        """
        return pulumi.get(self, "ipv6_access_type")

    @ipv6_access_type.setter
    def ipv6_access_type(self, value: Optional[pulumi.Input['IPAllocationPolicyIpv6AccessType']]):
        pulumi.set(self, "ipv6_access_type", value)

    @property
    @pulumi.getter(name="nodeIpv4Cidr")
    def node_ipv4_cidr(self) -> Optional[pulumi.Input[str]]:
        """
        This field is deprecated, use node_ipv4_cidr_block.
        """
        warnings.warn("""This field is deprecated, use node_ipv4_cidr_block.""", DeprecationWarning)
        pulumi.log.warn("""node_ipv4_cidr is deprecated: This field is deprecated, use node_ipv4_cidr_block.""")

        return pulumi.get(self, "node_ipv4_cidr")

    @node_ipv4_cidr.setter
    def node_ipv4_cidr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "node_ipv4_cidr", value)

    @property
    @pulumi.getter(name="nodeIpv4CidrBlock")
    def node_ipv4_cidr_block(self) -> Optional[pulumi.Input[str]]:
        """
        The IP address range of the instance IPs in this cluster. This is applicable only if `create_subnetwork` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        """
        return pulumi.get(self, "node_ipv4_cidr_block")

    @node_ipv4_cidr_block.setter
    def node_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "node_ipv4_cidr_block", value)

    @property
    @pulumi.getter(name="podCidrOverprovisionConfig")
    def pod_cidr_overprovision_config(self) -> Optional[pulumi.Input['PodCIDROverprovisionConfigArgs']]:
        """
        [PRIVATE FIELD] Pod CIDR size overprovisioning config for the cluster. Pod CIDR size per node depends on max_pods_per_node. By default, the value of max_pods_per_node is doubled and then rounded off to next power of 2 to get the size of pod CIDR block per node. Example: max_pods_per_node of 30 would result in 64 IPs (/26). This config can disable the doubling of IPs (we still round off to next power of 2) Example: max_pods_per_node of 30 will result in 32 IPs (/27) when overprovisioning is disabled.
        """
        return pulumi.get(self, "pod_cidr_overprovision_config")

    @pod_cidr_overprovision_config.setter
    def pod_cidr_overprovision_config(self, value: Optional[pulumi.Input['PodCIDROverprovisionConfigArgs']]):
        pulumi.set(self, "pod_cidr_overprovision_config", value)

    @property
    @pulumi.getter(name="servicesIpv4Cidr")
    def services_ipv4_cidr(self) -> Optional[pulumi.Input[str]]:
        """
        This field is deprecated, use services_ipv4_cidr_block.
        """
        warnings.warn("""This field is deprecated, use services_ipv4_cidr_block.""", DeprecationWarning)
        pulumi.log.warn("""services_ipv4_cidr is deprecated: This field is deprecated, use services_ipv4_cidr_block.""")

        return pulumi.get(self, "services_ipv4_cidr")

    @services_ipv4_cidr.setter
    def services_ipv4_cidr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "services_ipv4_cidr", value)

    @property
    @pulumi.getter(name="servicesIpv4CidrBlock")
    def services_ipv4_cidr_block(self) -> Optional[pulumi.Input[str]]:
        """
        The IP address range of the services IPs in this cluster. If blank, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        """
        return pulumi.get(self, "services_ipv4_cidr_block")

    @services_ipv4_cidr_block.setter
    def services_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "services_ipv4_cidr_block", value)

    @property
    @pulumi.getter(name="servicesSecondaryRangeName")
    def services_secondary_range_name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the secondary range to be used as for the services CIDR block. The secondary range will be used for service ClusterIPs. This must be an existing secondary range associated with the cluster subnetwork. This field is only applicable with use_ip_aliases and create_subnetwork is false.
        """
        return pulumi.get(self, "services_secondary_range_name")

    @services_secondary_range_name.setter
    def services_secondary_range_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "services_secondary_range_name", value)

    @property
    @pulumi.getter(name="stackType")
    def stack_type(self) -> Optional[pulumi.Input['IPAllocationPolicyStackType']]:
        """
        IP stack type
        """
        return pulumi.get(self, "stack_type")

    @stack_type.setter
    def stack_type(self, value: Optional[pulumi.Input['IPAllocationPolicyStackType']]):
        pulumi.set(self, "stack_type", value)

    @property
    @pulumi.getter(name="subnetworkName")
    def subnetwork_name(self) -> Optional[pulumi.Input[str]]:
        """
        A custom subnetwork name to be used if `create_subnetwork` is true. If this field is empty, then an automatic name will be chosen for the new subnetwork.
        """
        return pulumi.get(self, "subnetwork_name")

    @subnetwork_name.setter
    def subnetwork_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subnetwork_name", value)

    @property
    @pulumi.getter(name="tpuIpv4CidrBlock")
    def tpu_ipv4_cidr_block(self) -> Optional[pulumi.Input[str]]:
        """
        The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.
        """
        warnings.warn("""The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.""", DeprecationWarning)
        pulumi.log.warn("""tpu_ipv4_cidr_block is deprecated: The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.""")

        return pulumi.get(self, "tpu_ipv4_cidr_block")

    @tpu_ipv4_cidr_block.setter
    def tpu_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "tpu_ipv4_cidr_block", value)

    @property
    @pulumi.getter(name="useIpAliases")
    def use_ip_aliases(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether alias IPs will be used for pod IPs in the cluster. This is used in conjunction with use_routes. It cannot be true if use_routes is true. If both use_ip_aliases and use_routes are false, then the server picks the default IP allocation mode
        """
        return pulumi.get(self, "use_ip_aliases")

    @use_ip_aliases.setter
    def use_ip_aliases(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_ip_aliases", value)

    @property
    @pulumi.getter(name="useRoutes")
    def use_routes(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether routes will be used for pod IPs in the cluster. This is used in conjunction with use_ip_aliases. It cannot be true if use_ip_aliases is true. If both use_ip_aliases and use_routes are false, then the server picks the default IP allocation mode
        """
        return pulumi.get(self, "use_routes")

    @use_routes.setter
    def use_routes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_routes", value)


@pulumi.input_type
class IdentityServiceConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        IdentityServiceConfig is configuration for Identity Service which allows customers to use external identity providers with the K8S API
        :param pulumi.Input[bool] enabled: Whether to enable the Identity Service component
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to enable the Identity Service component
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class IstioConfigArgs:
    def __init__(__self__, *,
                 auth: Optional[pulumi.Input['IstioConfigAuth']] = None,
                 disabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration options for Istio addon.
        :param pulumi.Input['IstioConfigAuth'] auth: The specified Istio auth mode, either none, or mutual TLS.
        :param pulumi.Input[bool] disabled: Whether Istio is enabled for this cluster.
        """
        if auth is not None:
            pulumi.set(__self__, "auth", auth)
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)

    @property
    @pulumi.getter
    def auth(self) -> Optional[pulumi.Input['IstioConfigAuth']]:
        """
        The specified Istio auth mode, either none, or mutual TLS.
        """
        return pulumi.get(self, "auth")

    @auth.setter
    def auth(self, value: Optional[pulumi.Input['IstioConfigAuth']]):
        pulumi.set(self, "auth", value)

    @property
    @pulumi.getter
    def disabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether Istio is enabled for this cluster.
        """
        return pulumi.get(self, "disabled")

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disabled", value)


@pulumi.input_type
class KalmConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration options for the KALM addon.
        :param pulumi.Input[bool] enabled: Whether KALM is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether KALM is enabled for this cluster.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class KubernetesDashboardArgs:
    def __init__(__self__, *,
                 disabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for the Kubernetes Dashboard.
        :param pulumi.Input[bool] disabled: Whether the Kubernetes Dashboard is enabled for this cluster.
        """
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)

    @property
    @pulumi.getter
    def disabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the Kubernetes Dashboard is enabled for this cluster.
        """
        return pulumi.get(self, "disabled")

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disabled", value)


@pulumi.input_type
class LegacyAbacArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for the legacy Attribute Based Access Control authorization mode.
        :param pulumi.Input[bool] enabled: Whether the ABAC authorizer is enabled for this cluster. When enabled, identities in the system, including service accounts, nodes, and controllers, will have statically granted permissions beyond those provided by the RBAC configuration or IAM.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the ABAC authorizer is enabled for this cluster. When enabled, identities in the system, including service accounts, nodes, and controllers, will have statically granted permissions beyond those provided by the RBAC configuration or IAM.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class LinuxNodeConfigArgs:
    def __init__(__self__, *,
                 cgroup_mode: Optional[pulumi.Input['LinuxNodeConfigCgroupMode']] = None,
                 sysctls: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
        """
        Parameters that can be configured on Linux nodes.
        :param pulumi.Input['LinuxNodeConfigCgroupMode'] cgroup_mode: cgroup_mode specifies the cgroup mode to be used on the node.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] sysctls: The Linux kernel parameters to be applied to the nodes and all pods running on the nodes. The following parameters are supported. net.core.busy_poll net.core.busy_read net.core.netdev_max_backlog net.core.rmem_max net.core.wmem_default net.core.wmem_max net.core.optmem_max net.core.somaxconn net.ipv4.tcp_rmem net.ipv4.tcp_wmem net.ipv4.tcp_tw_reuse
        """
        if cgroup_mode is not None:
            pulumi.set(__self__, "cgroup_mode", cgroup_mode)
        if sysctls is not None:
            pulumi.set(__self__, "sysctls", sysctls)

    @property
    @pulumi.getter(name="cgroupMode")
    def cgroup_mode(self) -> Optional[pulumi.Input['LinuxNodeConfigCgroupMode']]:
        """
        cgroup_mode specifies the cgroup mode to be used on the node.
        """
        return pulumi.get(self, "cgroup_mode")

    @cgroup_mode.setter
    def cgroup_mode(self, value: Optional[pulumi.Input['LinuxNodeConfigCgroupMode']]):
        pulumi.set(self, "cgroup_mode", value)

    @property
    @pulumi.getter
    def sysctls(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        The Linux kernel parameters to be applied to the nodes and all pods running on the nodes. The following parameters are supported. net.core.busy_poll net.core.busy_read net.core.netdev_max_backlog net.core.rmem_max net.core.wmem_default net.core.wmem_max net.core.optmem_max net.core.somaxconn net.ipv4.tcp_rmem net.ipv4.tcp_wmem net.ipv4.tcp_tw_reuse
        """
        return pulumi.get(self, "sysctls")

    @sysctls.setter
    def sysctls(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "sysctls", value)


@pulumi.input_type
class LocalNvmeSsdBlockConfigArgs:
    def __init__(__self__, *,
                 local_ssd_count: Optional[pulumi.Input[int]] = None):
        """
        LocalNvmeSsdBlockConfig contains configuration for using raw-block local NVMe SSDs
        :param pulumi.Input[int] local_ssd_count: The number of raw-block local NVMe SSD disks to be attached to the node. Each local SSD is 375 GB in size. If zero, it means no raw-block local NVMe SSD disks to be attached to the node. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        """
        if local_ssd_count is not None:
            pulumi.set(__self__, "local_ssd_count", local_ssd_count)

    @property
    @pulumi.getter(name="localSsdCount")
    def local_ssd_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of raw-block local NVMe SSD disks to be attached to the node. Each local SSD is 375 GB in size. If zero, it means no raw-block local NVMe SSD disks to be attached to the node. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        """
        return pulumi.get(self, "local_ssd_count")

    @local_ssd_count.setter
    def local_ssd_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "local_ssd_count", value)


@pulumi.input_type
class LoggingComponentConfigArgs:
    def __init__(__self__, *,
                 enable_components: Optional[pulumi.Input[Sequence[pulumi.Input['LoggingComponentConfigEnableComponentsItem']]]] = None):
        """
        LoggingComponentConfig is cluster logging component configuration.
        :param pulumi.Input[Sequence[pulumi.Input['LoggingComponentConfigEnableComponentsItem']]] enable_components: Select components to collect logs. An empty set would disable all logging.
        """
        if enable_components is not None:
            pulumi.set(__self__, "enable_components", enable_components)

    @property
    @pulumi.getter(name="enableComponents")
    def enable_components(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LoggingComponentConfigEnableComponentsItem']]]]:
        """
        Select components to collect logs. An empty set would disable all logging.
        """
        return pulumi.get(self, "enable_components")

    @enable_components.setter
    def enable_components(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LoggingComponentConfigEnableComponentsItem']]]]):
        pulumi.set(self, "enable_components", value)


@pulumi.input_type
class LoggingConfigArgs:
    def __init__(__self__, *,
                 component_config: Optional[pulumi.Input['LoggingComponentConfigArgs']] = None):
        """
        LoggingConfig is cluster logging configuration.
        :param pulumi.Input['LoggingComponentConfigArgs'] component_config: Logging components configuration
        """
        if component_config is not None:
            pulumi.set(__self__, "component_config", component_config)

    @property
    @pulumi.getter(name="componentConfig")
    def component_config(self) -> Optional[pulumi.Input['LoggingComponentConfigArgs']]:
        """
        Logging components configuration
        """
        return pulumi.get(self, "component_config")

    @component_config.setter
    def component_config(self, value: Optional[pulumi.Input['LoggingComponentConfigArgs']]):
        pulumi.set(self, "component_config", value)


@pulumi.input_type
class LoggingVariantConfigArgs:
    def __init__(__self__, *,
                 variant: Optional[pulumi.Input['LoggingVariantConfigVariant']] = None):
        """
        LoggingVariantConfig specifies the behaviour of the logging component.
        :param pulumi.Input['LoggingVariantConfigVariant'] variant: Logging variant deployed on nodes.
        """
        if variant is not None:
            pulumi.set(__self__, "variant", variant)

    @property
    @pulumi.getter
    def variant(self) -> Optional[pulumi.Input['LoggingVariantConfigVariant']]:
        """
        Logging variant deployed on nodes.
        """
        return pulumi.get(self, "variant")

    @variant.setter
    def variant(self, value: Optional[pulumi.Input['LoggingVariantConfigVariant']]):
        pulumi.set(self, "variant", value)


@pulumi.input_type
class MaintenanceExclusionOptionsArgs:
    def __init__(__self__, *,
                 scope: Optional[pulumi.Input['MaintenanceExclusionOptionsScope']] = None):
        """
        Represents the Maintenance exclusion option.
        :param pulumi.Input['MaintenanceExclusionOptionsScope'] scope: Scope specifies the upgrade scope which upgrades are blocked by the exclusion.
        """
        if scope is not None:
            pulumi.set(__self__, "scope", scope)

    @property
    @pulumi.getter
    def scope(self) -> Optional[pulumi.Input['MaintenanceExclusionOptionsScope']]:
        """
        Scope specifies the upgrade scope which upgrades are blocked by the exclusion.
        """
        return pulumi.get(self, "scope")

    @scope.setter
    def scope(self, value: Optional[pulumi.Input['MaintenanceExclusionOptionsScope']]):
        pulumi.set(self, "scope", value)


@pulumi.input_type
class MaintenancePolicyArgs:
    def __init__(__self__, *,
                 resource_version: Optional[pulumi.Input[str]] = None,
                 window: Optional[pulumi.Input['MaintenanceWindowArgs']] = None):
        """
        MaintenancePolicy defines the maintenance policy to be used for the cluster.
        :param pulumi.Input[str] resource_version: A hash identifying the version of this policy, so that updates to fields of the policy won't accidentally undo intermediate changes (and so that users of the API unaware of some fields won't accidentally remove other fields). Make a `get()` request to the cluster to get the current resource version and include it with requests to set the policy.
        :param pulumi.Input['MaintenanceWindowArgs'] window: Specifies the maintenance window in which maintenance may be performed.
        """
        if resource_version is not None:
            pulumi.set(__self__, "resource_version", resource_version)
        if window is not None:
            pulumi.set(__self__, "window", window)

    @property
    @pulumi.getter(name="resourceVersion")
    def resource_version(self) -> Optional[pulumi.Input[str]]:
        """
        A hash identifying the version of this policy, so that updates to fields of the policy won't accidentally undo intermediate changes (and so that users of the API unaware of some fields won't accidentally remove other fields). Make a `get()` request to the cluster to get the current resource version and include it with requests to set the policy.
        """
        return pulumi.get(self, "resource_version")

    @resource_version.setter
    def resource_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resource_version", value)

    @property
    @pulumi.getter
    def window(self) -> Optional[pulumi.Input['MaintenanceWindowArgs']]:
        """
        Specifies the maintenance window in which maintenance may be performed.
        """
        return pulumi.get(self, "window")

    @window.setter
    def window(self, value: Optional[pulumi.Input['MaintenanceWindowArgs']]):
        pulumi.set(self, "window", value)


@pulumi.input_type
class MaintenanceWindowArgs:
    def __init__(__self__, *,
                 daily_maintenance_window: Optional[pulumi.Input['DailyMaintenanceWindowArgs']] = None,
                 maintenance_exclusions: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 recurring_window: Optional[pulumi.Input['RecurringTimeWindowArgs']] = None):
        """
        MaintenanceWindow defines the maintenance window to be used for the cluster.
        :param pulumi.Input['DailyMaintenanceWindowArgs'] daily_maintenance_window: DailyMaintenanceWindow specifies a daily maintenance operation window.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] maintenance_exclusions: Exceptions to maintenance window. Non-emergency maintenance should not occur in these windows.
        :param pulumi.Input['RecurringTimeWindowArgs'] recurring_window: RecurringWindow specifies some number of recurring time periods for maintenance to occur. The time windows may be overlapping. If no maintenance windows are set, maintenance can occur at any time.
        """
        if daily_maintenance_window is not None:
            pulumi.set(__self__, "daily_maintenance_window", daily_maintenance_window)
        if maintenance_exclusions is not None:
            pulumi.set(__self__, "maintenance_exclusions", maintenance_exclusions)
        if recurring_window is not None:
            pulumi.set(__self__, "recurring_window", recurring_window)

    @property
    @pulumi.getter(name="dailyMaintenanceWindow")
    def daily_maintenance_window(self) -> Optional[pulumi.Input['DailyMaintenanceWindowArgs']]:
        """
        DailyMaintenanceWindow specifies a daily maintenance operation window.
        """
        return pulumi.get(self, "daily_maintenance_window")

    @daily_maintenance_window.setter
    def daily_maintenance_window(self, value: Optional[pulumi.Input['DailyMaintenanceWindowArgs']]):
        pulumi.set(self, "daily_maintenance_window", value)

    @property
    @pulumi.getter(name="maintenanceExclusions")
    def maintenance_exclusions(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        Exceptions to maintenance window. Non-emergency maintenance should not occur in these windows.
        """
        return pulumi.get(self, "maintenance_exclusions")

    @maintenance_exclusions.setter
    def maintenance_exclusions(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "maintenance_exclusions", value)

    @property
    @pulumi.getter(name="recurringWindow")
    def recurring_window(self) -> Optional[pulumi.Input['RecurringTimeWindowArgs']]:
        """
        RecurringWindow specifies some number of recurring time periods for maintenance to occur. The time windows may be overlapping. If no maintenance windows are set, maintenance can occur at any time.
        """
        return pulumi.get(self, "recurring_window")

    @recurring_window.setter
    def recurring_window(self, value: Optional[pulumi.Input['RecurringTimeWindowArgs']]):
        pulumi.set(self, "recurring_window", value)


@pulumi.input_type
class ManagedPrometheusConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        ManagedPrometheusConfig defines the configuration for Google Cloud Managed Service for Prometheus.
        :param pulumi.Input[bool] enabled: Enable Managed Collection.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable Managed Collection.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class MasterAuthorizedNetworksConfigArgs:
    def __init__(__self__, *,
                 cidr_blocks: Optional[pulumi.Input[Sequence[pulumi.Input['CidrBlockArgs']]]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 gcp_public_cidrs_access_enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration options for the master authorized networks feature. Enabled master authorized networks will disallow all external traffic to access Kubernetes master through HTTPS except traffic from the given CIDR blocks, Google Compute Engine Public IPs and Google Prod IPs.
        :param pulumi.Input[Sequence[pulumi.Input['CidrBlockArgs']]] cidr_blocks: cidr_blocks define up to 10 external networks that could access Kubernetes master through HTTPS.
        :param pulumi.Input[bool] enabled: Whether or not master authorized networks is enabled.
        :param pulumi.Input[bool] gcp_public_cidrs_access_enabled: Whether master is accessbile via Google Compute Engine Public IP addresses.
        """
        if cidr_blocks is not None:
            pulumi.set(__self__, "cidr_blocks", cidr_blocks)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if gcp_public_cidrs_access_enabled is not None:
            pulumi.set(__self__, "gcp_public_cidrs_access_enabled", gcp_public_cidrs_access_enabled)

    @property
    @pulumi.getter(name="cidrBlocks")
    def cidr_blocks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CidrBlockArgs']]]]:
        """
        cidr_blocks define up to 10 external networks that could access Kubernetes master through HTTPS.
        """
        return pulumi.get(self, "cidr_blocks")

    @cidr_blocks.setter
    def cidr_blocks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CidrBlockArgs']]]]):
        pulumi.set(self, "cidr_blocks", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether or not master authorized networks is enabled.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter(name="gcpPublicCidrsAccessEnabled")
    def gcp_public_cidrs_access_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether master is accessbile via Google Compute Engine Public IP addresses.
        """
        return pulumi.get(self, "gcp_public_cidrs_access_enabled")

    @gcp_public_cidrs_access_enabled.setter
    def gcp_public_cidrs_access_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "gcp_public_cidrs_access_enabled", value)


@pulumi.input_type
class MasterAuthArgs:
    def __init__(__self__, *,
                 client_certificate_config: Optional[pulumi.Input['ClientCertificateConfigArgs']] = None,
                 cluster_ca_certificate: Optional[pulumi.Input[str]] = None,
                 password: Optional[pulumi.Input[str]] = None,
                 username: Optional[pulumi.Input[str]] = None):
        """
        The authentication information for accessing the master endpoint. Authentication can be done using HTTP basic auth or using client certificates.
        :param pulumi.Input['ClientCertificateConfigArgs'] client_certificate_config: Configuration for client certificate authentication on the cluster. For clusters before v1.12, if no configuration is specified, a client certificate is issued.
        :param pulumi.Input[str] password: The password to use for HTTP basic authentication to the master endpoint. Because the master endpoint is open to the Internet, you should create a strong password. If a password is provided for cluster creation, username must be non-empty. Warning: basic authentication is deprecated, and will be removed in GKE control plane versions 1.19 and newer. For a list of recommended authentication methods, see: https://cloud.google.com/kubernetes-engine/docs/how-to/api-server-authentication
        :param pulumi.Input[str] username: The username to use for HTTP basic authentication to the master endpoint. For clusters v1.6.0 and later, basic authentication can be disabled by leaving username unspecified (or setting it to the empty string). Warning: basic authentication is deprecated, and will be removed in GKE control plane versions 1.19 and newer. For a list of recommended authentication methods, see: https://cloud.google.com/kubernetes-engine/docs/how-to/api-server-authentication
        """
        if client_certificate_config is not None:
            pulumi.set(__self__, "client_certificate_config", client_certificate_config)
        if cluster_ca_certificate is not None:
            pulumi.set(__self__, "cluster_ca_certificate", cluster_ca_certificate)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="clientCertificateConfig")
    def client_certificate_config(self) -> Optional[pulumi.Input['ClientCertificateConfigArgs']]:
        """
        Configuration for client certificate authentication on the cluster. For clusters before v1.12, if no configuration is specified, a client certificate is issued.
        """
        return pulumi.get(self, "client_certificate_config")

    @client_certificate_config.setter
    def client_certificate_config(self, value: Optional[pulumi.Input['ClientCertificateConfigArgs']]):
        pulumi.set(self, "client_certificate_config", value)

    @property
    @pulumi.getter(name="clusterCaCertificate")
    def cluster_ca_certificate(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cluster_ca_certificate")

    @cluster_ca_certificate.setter
    def cluster_ca_certificate(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_ca_certificate", value)

    @property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[str]]:
        """
        The password to use for HTTP basic authentication to the master endpoint. Because the master endpoint is open to the Internet, you should create a strong password. If a password is provided for cluster creation, username must be non-empty. Warning: basic authentication is deprecated, and will be removed in GKE control plane versions 1.19 and newer. For a list of recommended authentication methods, see: https://cloud.google.com/kubernetes-engine/docs/how-to/api-server-authentication
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter
    def username(self) -> Optional[pulumi.Input[str]]:
        """
        The username to use for HTTP basic authentication to the master endpoint. For clusters v1.6.0 and later, basic authentication can be disabled by leaving username unspecified (or setting it to the empty string). Warning: basic authentication is deprecated, and will be removed in GKE control plane versions 1.19 and newer. For a list of recommended authentication methods, see: https://cloud.google.com/kubernetes-engine/docs/how-to/api-server-authentication
        """
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "username", value)


@pulumi.input_type
class MasterArgs:
    def __init__(__self__):
        """
        Master is the configuration for components on master.
        """
        pass


@pulumi.input_type
class MaxPodsConstraintArgs:
    def __init__(__self__, *,
                 max_pods_per_node: Optional[pulumi.Input[str]] = None):
        """
        Constraints applied to pods.
        :param pulumi.Input[str] max_pods_per_node: Constraint enforced on the max num of pods per node.
        """
        if max_pods_per_node is not None:
            pulumi.set(__self__, "max_pods_per_node", max_pods_per_node)

    @property
    @pulumi.getter(name="maxPodsPerNode")
    def max_pods_per_node(self) -> Optional[pulumi.Input[str]]:
        """
        Constraint enforced on the max num of pods per node.
        """
        return pulumi.get(self, "max_pods_per_node")

    @max_pods_per_node.setter
    def max_pods_per_node(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "max_pods_per_node", value)


@pulumi.input_type
class MeshCertificatesArgs:
    def __init__(__self__, *,
                 enable_certificates: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for issuance of mTLS keys and certificates to Kubernetes pods.
        :param pulumi.Input[bool] enable_certificates: enable_certificates controls issuance of workload mTLS certificates. If set, the GKE Workload Identity Certificates controller and node agent will be deployed in the cluster, which can then be configured by creating a WorkloadCertificateConfig Custom Resource. Requires Workload Identity (workload_pool must be non-empty).
        """
        if enable_certificates is not None:
            pulumi.set(__self__, "enable_certificates", enable_certificates)

    @property
    @pulumi.getter(name="enableCertificates")
    def enable_certificates(self) -> Optional[pulumi.Input[bool]]:
        """
        enable_certificates controls issuance of workload mTLS certificates. If set, the GKE Workload Identity Certificates controller and node agent will be deployed in the cluster, which can then be configured by creating a WorkloadCertificateConfig Custom Resource. Requires Workload Identity (workload_pool must be non-empty).
        """
        return pulumi.get(self, "enable_certificates")

    @enable_certificates.setter
    def enable_certificates(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_certificates", value)


@pulumi.input_type
class MonitoringComponentConfigArgs:
    def __init__(__self__, *,
                 enable_components: Optional[pulumi.Input[Sequence[pulumi.Input['MonitoringComponentConfigEnableComponentsItem']]]] = None):
        """
        MonitoringComponentConfig is cluster monitoring component configuration.
        :param pulumi.Input[Sequence[pulumi.Input['MonitoringComponentConfigEnableComponentsItem']]] enable_components: Select components to collect metrics. An empty set would disable all monitoring.
        """
        if enable_components is not None:
            pulumi.set(__self__, "enable_components", enable_components)

    @property
    @pulumi.getter(name="enableComponents")
    def enable_components(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MonitoringComponentConfigEnableComponentsItem']]]]:
        """
        Select components to collect metrics. An empty set would disable all monitoring.
        """
        return pulumi.get(self, "enable_components")

    @enable_components.setter
    def enable_components(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MonitoringComponentConfigEnableComponentsItem']]]]):
        pulumi.set(self, "enable_components", value)


@pulumi.input_type
class MonitoringConfigArgs:
    def __init__(__self__, *,
                 component_config: Optional[pulumi.Input['MonitoringComponentConfigArgs']] = None,
                 managed_prometheus_config: Optional[pulumi.Input['ManagedPrometheusConfigArgs']] = None):
        """
        MonitoringConfig is cluster monitoring configuration.
        :param pulumi.Input['MonitoringComponentConfigArgs'] component_config: Monitoring components configuration
        :param pulumi.Input['ManagedPrometheusConfigArgs'] managed_prometheus_config: Enable Google Cloud Managed Service for Prometheus in the cluster.
        """
        if component_config is not None:
            pulumi.set(__self__, "component_config", component_config)
        if managed_prometheus_config is not None:
            pulumi.set(__self__, "managed_prometheus_config", managed_prometheus_config)

    @property
    @pulumi.getter(name="componentConfig")
    def component_config(self) -> Optional[pulumi.Input['MonitoringComponentConfigArgs']]:
        """
        Monitoring components configuration
        """
        return pulumi.get(self, "component_config")

    @component_config.setter
    def component_config(self, value: Optional[pulumi.Input['MonitoringComponentConfigArgs']]):
        pulumi.set(self, "component_config", value)

    @property
    @pulumi.getter(name="managedPrometheusConfig")
    def managed_prometheus_config(self) -> Optional[pulumi.Input['ManagedPrometheusConfigArgs']]:
        """
        Enable Google Cloud Managed Service for Prometheus in the cluster.
        """
        return pulumi.get(self, "managed_prometheus_config")

    @managed_prometheus_config.setter
    def managed_prometheus_config(self, value: Optional[pulumi.Input['ManagedPrometheusConfigArgs']]):
        pulumi.set(self, "managed_prometheus_config", value)


@pulumi.input_type
class NetworkConfigArgs:
    def __init__(__self__, *,
                 datapath_provider: Optional[pulumi.Input['NetworkConfigDatapathProvider']] = None,
                 default_snat_status: Optional[pulumi.Input['DefaultSnatStatusArgs']] = None,
                 dns_config: Optional[pulumi.Input['DNSConfigArgs']] = None,
                 enable_intra_node_visibility: Optional[pulumi.Input[bool]] = None,
                 enable_l4ilb_subsetting: Optional[pulumi.Input[bool]] = None,
                 gateway_api_config: Optional[pulumi.Input['GatewayAPIConfigArgs']] = None,
                 private_ipv6_google_access: Optional[pulumi.Input['NetworkConfigPrivateIpv6GoogleAccess']] = None,
                 service_external_ips_config: Optional[pulumi.Input['ServiceExternalIPsConfigArgs']] = None):
        """
        NetworkConfig reports the relative names of network & subnetwork.
        :param pulumi.Input['NetworkConfigDatapathProvider'] datapath_provider: The desired datapath provider for this cluster. By default, uses the IPTables-based kube-proxy implementation.
        :param pulumi.Input['DefaultSnatStatusArgs'] default_snat_status: Whether the cluster disables default in-node sNAT rules. In-node sNAT rules will be disabled when default_snat_status is disabled. When disabled is set to false, default IP masquerade rules will be applied to the nodes to prevent sNAT on cluster internal traffic.
        :param pulumi.Input['DNSConfigArgs'] dns_config: DNSConfig contains clusterDNS config for this cluster.
        :param pulumi.Input[bool] enable_intra_node_visibility: Whether Intra-node visibility is enabled for this cluster. This makes same node pod to pod traffic visible for VPC network.
        :param pulumi.Input[bool] enable_l4ilb_subsetting: Whether L4ILB Subsetting is enabled for this cluster.
        :param pulumi.Input['GatewayAPIConfigArgs'] gateway_api_config: GatewayAPIConfig contains the desired config of Gateway API on this cluster.
        :param pulumi.Input['NetworkConfigPrivateIpv6GoogleAccess'] private_ipv6_google_access: The desired state of IPv6 connectivity to Google Services. By default, no private IPv6 access to or from Google Services (all access will be via IPv4)
        :param pulumi.Input['ServiceExternalIPsConfigArgs'] service_external_ips_config: ServiceExternalIPsConfig specifies if services with externalIPs field are blocked or not.
        """
        if datapath_provider is not None:
            pulumi.set(__self__, "datapath_provider", datapath_provider)
        if default_snat_status is not None:
            pulumi.set(__self__, "default_snat_status", default_snat_status)
        if dns_config is not None:
            pulumi.set(__self__, "dns_config", dns_config)
        if enable_intra_node_visibility is not None:
            pulumi.set(__self__, "enable_intra_node_visibility", enable_intra_node_visibility)
        if enable_l4ilb_subsetting is not None:
            pulumi.set(__self__, "enable_l4ilb_subsetting", enable_l4ilb_subsetting)
        if gateway_api_config is not None:
            pulumi.set(__self__, "gateway_api_config", gateway_api_config)
        if private_ipv6_google_access is not None:
            pulumi.set(__self__, "private_ipv6_google_access", private_ipv6_google_access)
        if service_external_ips_config is not None:
            pulumi.set(__self__, "service_external_ips_config", service_external_ips_config)

    @property
    @pulumi.getter(name="datapathProvider")
    def datapath_provider(self) -> Optional[pulumi.Input['NetworkConfigDatapathProvider']]:
        """
        The desired datapath provider for this cluster. By default, uses the IPTables-based kube-proxy implementation.
        """
        return pulumi.get(self, "datapath_provider")

    @datapath_provider.setter
    def datapath_provider(self, value: Optional[pulumi.Input['NetworkConfigDatapathProvider']]):
        pulumi.set(self, "datapath_provider", value)

    @property
    @pulumi.getter(name="defaultSnatStatus")
    def default_snat_status(self) -> Optional[pulumi.Input['DefaultSnatStatusArgs']]:
        """
        Whether the cluster disables default in-node sNAT rules. In-node sNAT rules will be disabled when default_snat_status is disabled. When disabled is set to false, default IP masquerade rules will be applied to the nodes to prevent sNAT on cluster internal traffic.
        """
        return pulumi.get(self, "default_snat_status")

    @default_snat_status.setter
    def default_snat_status(self, value: Optional[pulumi.Input['DefaultSnatStatusArgs']]):
        pulumi.set(self, "default_snat_status", value)

    @property
    @pulumi.getter(name="dnsConfig")
    def dns_config(self) -> Optional[pulumi.Input['DNSConfigArgs']]:
        """
        DNSConfig contains clusterDNS config for this cluster.
        """
        return pulumi.get(self, "dns_config")

    @dns_config.setter
    def dns_config(self, value: Optional[pulumi.Input['DNSConfigArgs']]):
        pulumi.set(self, "dns_config", value)

    @property
    @pulumi.getter(name="enableIntraNodeVisibility")
    def enable_intra_node_visibility(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether Intra-node visibility is enabled for this cluster. This makes same node pod to pod traffic visible for VPC network.
        """
        return pulumi.get(self, "enable_intra_node_visibility")

    @enable_intra_node_visibility.setter
    def enable_intra_node_visibility(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_intra_node_visibility", value)

    @property
    @pulumi.getter(name="enableL4ilbSubsetting")
    def enable_l4ilb_subsetting(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether L4ILB Subsetting is enabled for this cluster.
        """
        return pulumi.get(self, "enable_l4ilb_subsetting")

    @enable_l4ilb_subsetting.setter
    def enable_l4ilb_subsetting(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_l4ilb_subsetting", value)

    @property
    @pulumi.getter(name="gatewayApiConfig")
    def gateway_api_config(self) -> Optional[pulumi.Input['GatewayAPIConfigArgs']]:
        """
        GatewayAPIConfig contains the desired config of Gateway API on this cluster.
        """
        return pulumi.get(self, "gateway_api_config")

    @gateway_api_config.setter
    def gateway_api_config(self, value: Optional[pulumi.Input['GatewayAPIConfigArgs']]):
        pulumi.set(self, "gateway_api_config", value)

    @property
    @pulumi.getter(name="privateIpv6GoogleAccess")
    def private_ipv6_google_access(self) -> Optional[pulumi.Input['NetworkConfigPrivateIpv6GoogleAccess']]:
        """
        The desired state of IPv6 connectivity to Google Services. By default, no private IPv6 access to or from Google Services (all access will be via IPv4)
        """
        return pulumi.get(self, "private_ipv6_google_access")

    @private_ipv6_google_access.setter
    def private_ipv6_google_access(self, value: Optional[pulumi.Input['NetworkConfigPrivateIpv6GoogleAccess']]):
        pulumi.set(self, "private_ipv6_google_access", value)

    @property
    @pulumi.getter(name="serviceExternalIpsConfig")
    def service_external_ips_config(self) -> Optional[pulumi.Input['ServiceExternalIPsConfigArgs']]:
        """
        ServiceExternalIPsConfig specifies if services with externalIPs field are blocked or not.
        """
        return pulumi.get(self, "service_external_ips_config")

    @service_external_ips_config.setter
    def service_external_ips_config(self, value: Optional[pulumi.Input['ServiceExternalIPsConfigArgs']]):
        pulumi.set(self, "service_external_ips_config", value)


@pulumi.input_type
class NetworkPerformanceConfigArgs:
    def __init__(__self__, *,
                 external_ip_egress_bandwidth_tier: Optional[pulumi.Input['NetworkPerformanceConfigExternalIpEgressBandwidthTier']] = None,
                 total_egress_bandwidth_tier: Optional[pulumi.Input['NetworkPerformanceConfigTotalEgressBandwidthTier']] = None):
        """
        Configuration of all network bandwidth tiers
        :param pulumi.Input['NetworkPerformanceConfigExternalIpEgressBandwidthTier'] external_ip_egress_bandwidth_tier: Specifies the network bandwidth tier for the NodePool for traffic to external/public IP addresses.
        :param pulumi.Input['NetworkPerformanceConfigTotalEgressBandwidthTier'] total_egress_bandwidth_tier: Specifies the total network bandwidth tier for the NodePool.
        """
        if external_ip_egress_bandwidth_tier is not None:
            pulumi.set(__self__, "external_ip_egress_bandwidth_tier", external_ip_egress_bandwidth_tier)
        if total_egress_bandwidth_tier is not None:
            pulumi.set(__self__, "total_egress_bandwidth_tier", total_egress_bandwidth_tier)

    @property
    @pulumi.getter(name="externalIpEgressBandwidthTier")
    def external_ip_egress_bandwidth_tier(self) -> Optional[pulumi.Input['NetworkPerformanceConfigExternalIpEgressBandwidthTier']]:
        """
        Specifies the network bandwidth tier for the NodePool for traffic to external/public IP addresses.
        """
        return pulumi.get(self, "external_ip_egress_bandwidth_tier")

    @external_ip_egress_bandwidth_tier.setter
    def external_ip_egress_bandwidth_tier(self, value: Optional[pulumi.Input['NetworkPerformanceConfigExternalIpEgressBandwidthTier']]):
        pulumi.set(self, "external_ip_egress_bandwidth_tier", value)

    @property
    @pulumi.getter(name="totalEgressBandwidthTier")
    def total_egress_bandwidth_tier(self) -> Optional[pulumi.Input['NetworkPerformanceConfigTotalEgressBandwidthTier']]:
        """
        Specifies the total network bandwidth tier for the NodePool.
        """
        return pulumi.get(self, "total_egress_bandwidth_tier")

    @total_egress_bandwidth_tier.setter
    def total_egress_bandwidth_tier(self, value: Optional[pulumi.Input['NetworkPerformanceConfigTotalEgressBandwidthTier']]):
        pulumi.set(self, "total_egress_bandwidth_tier", value)


@pulumi.input_type
class NetworkPolicyConfigArgs:
    def __init__(__self__, *,
                 disabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for NetworkPolicy. This only tracks whether the addon is enabled or not on the Master, it does not track whether network policy is enabled for the nodes.
        :param pulumi.Input[bool] disabled: Whether NetworkPolicy is enabled for this cluster.
        """
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)

    @property
    @pulumi.getter
    def disabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether NetworkPolicy is enabled for this cluster.
        """
        return pulumi.get(self, "disabled")

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disabled", value)


@pulumi.input_type
class NetworkPolicyArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 provider: Optional[pulumi.Input['NetworkPolicyProvider']] = None):
        """
        Configuration options for the NetworkPolicy feature. https://kubernetes.io/docs/concepts/services-networking/networkpolicies/
        :param pulumi.Input[bool] enabled: Whether network policy is enabled on the cluster.
        :param pulumi.Input['NetworkPolicyProvider'] provider: The selected network policy provider.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether network policy is enabled on the cluster.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter
    def provider(self) -> Optional[pulumi.Input['NetworkPolicyProvider']]:
        """
        The selected network policy provider.
        """
        return pulumi.get(self, "provider")

    @provider.setter
    def provider(self, value: Optional[pulumi.Input['NetworkPolicyProvider']]):
        pulumi.set(self, "provider", value)


@pulumi.input_type
class NetworkTagsArgs:
    def __init__(__self__, *,
                 tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        Collection of Compute Engine network tags that can be applied to a node's underlying VM instance. (See `tags` field in [`NodeConfig`](/kubernetes-engine/docs/reference/rest/v1/NodeConfig)).
        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: List of network tags.
        """
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

    @property
    @pulumi.getter
    def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of network tags.
        """
        return pulumi.get(self, "tags")

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "tags", value)


@pulumi.input_type
class NodeConfigDefaultsArgs:
    def __init__(__self__, *,
                 gcfs_config: Optional[pulumi.Input['GcfsConfigArgs']] = None,
                 logging_config: Optional[pulumi.Input['NodePoolLoggingConfigArgs']] = None):
        """
        Subset of NodeConfig message that has defaults.
        :param pulumi.Input['GcfsConfigArgs'] gcfs_config: GCFS (Google Container File System, also known as Riptide) options.
        :param pulumi.Input['NodePoolLoggingConfigArgs'] logging_config: Logging configuration for node pools.
        """
        if gcfs_config is not None:
            pulumi.set(__self__, "gcfs_config", gcfs_config)
        if logging_config is not None:
            pulumi.set(__self__, "logging_config", logging_config)

    @property
    @pulumi.getter(name="gcfsConfig")
    def gcfs_config(self) -> Optional[pulumi.Input['GcfsConfigArgs']]:
        """
        GCFS (Google Container File System, also known as Riptide) options.
        """
        return pulumi.get(self, "gcfs_config")

    @gcfs_config.setter
    def gcfs_config(self, value: Optional[pulumi.Input['GcfsConfigArgs']]):
        pulumi.set(self, "gcfs_config", value)

    @property
    @pulumi.getter(name="loggingConfig")
    def logging_config(self) -> Optional[pulumi.Input['NodePoolLoggingConfigArgs']]:
        """
        Logging configuration for node pools.
        """
        return pulumi.get(self, "logging_config")

    @logging_config.setter
    def logging_config(self, value: Optional[pulumi.Input['NodePoolLoggingConfigArgs']]):
        pulumi.set(self, "logging_config", value)


@pulumi.input_type
class NodeConfigArgs:
    def __init__(__self__, *,
                 accelerators: Optional[pulumi.Input[Sequence[pulumi.Input['AcceleratorConfigArgs']]]] = None,
                 advanced_machine_features: Optional[pulumi.Input['AdvancedMachineFeaturesArgs']] = None,
                 boot_disk_kms_key: Optional[pulumi.Input[str]] = None,
                 confidential_nodes: Optional[pulumi.Input['ConfidentialNodesArgs']] = None,
                 disk_size_gb: Optional[pulumi.Input[int]] = None,
                 disk_type: Optional[pulumi.Input[str]] = None,
                 ephemeral_storage_config: Optional[pulumi.Input['EphemeralStorageConfigArgs']] = None,
                 ephemeral_storage_local_ssd_config: Optional[pulumi.Input['EphemeralStorageLocalSsdConfigArgs']] = None,
                 fast_socket: Optional[pulumi.Input['FastSocketArgs']] = None,
                 gcfs_config: Optional[pulumi.Input['GcfsConfigArgs']] = None,
                 gvnic: Optional[pulumi.Input['VirtualNICArgs']] = None,
                 image_type: Optional[pulumi.Input[str]] = None,
                 kubelet_config: Optional[pulumi.Input['NodeKubeletConfigArgs']] = None,
                 labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 linux_node_config: Optional[pulumi.Input['LinuxNodeConfigArgs']] = None,
                 local_nvme_ssd_block_config: Optional[pulumi.Input['LocalNvmeSsdBlockConfigArgs']] = None,
                 local_ssd_count: Optional[pulumi.Input[int]] = None,
                 logging_config: Optional[pulumi.Input['NodePoolLoggingConfigArgs']] = None,
                 machine_type: Optional[pulumi.Input[str]] = None,
                 metadata: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 min_cpu_platform: Optional[pulumi.Input[str]] = None,
                 node_group: Optional[pulumi.Input[str]] = None,
                 oauth_scopes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 preemptible: Optional[pulumi.Input[bool]] = None,
                 reservation_affinity: Optional[pulumi.Input['ReservationAffinityArgs']] = None,
                 resource_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 sandbox_config: Optional[pulumi.Input['SandboxConfigArgs']] = None,
                 service_account: Optional[pulumi.Input[str]] = None,
                 shielded_instance_config: Optional[pulumi.Input['ShieldedInstanceConfigArgs']] = None,
                 spot: Optional[pulumi.Input[bool]] = None,
                 tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 taints: Optional[pulumi.Input[Sequence[pulumi.Input['NodeTaintArgs']]]] = None,
                 windows_node_config: Optional[pulumi.Input['WindowsNodeConfigArgs']] = None,
                 workload_metadata_config: Optional[pulumi.Input['WorkloadMetadataConfigArgs']] = None):
        """
        Parameters that describe the nodes in a cluster. GKE Autopilot clusters do not recognize parameters in `NodeConfig`. Use AutoprovisioningNodePoolDefaults instead.
        :param pulumi.Input[Sequence[pulumi.Input['AcceleratorConfigArgs']]] accelerators: A list of hardware accelerators to be attached to each node. See https://cloud.google.com/compute/docs/gpus for more information about support for GPUs.
        :param pulumi.Input['AdvancedMachineFeaturesArgs'] advanced_machine_features: Advanced features for the Compute Engine VM.
        :param pulumi.Input[str] boot_disk_kms_key:  The Customer Managed Encryption Key used to encrypt the boot disk attached to each node in the node pool. This should be of the form projects/[KEY_PROJECT_ID]/locations/[LOCATION]/keyRings/[RING_NAME]/cryptoKeys/[KEY_NAME]. For more information about protecting resources with Cloud KMS Keys please see: https://cloud.google.com/compute/docs/disks/customer-managed-encryption
        :param pulumi.Input['ConfidentialNodesArgs'] confidential_nodes: Confidential nodes config. All the nodes in the node pool will be Confidential VM once enabled.
        :param pulumi.Input[int] disk_size_gb: Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB. If unspecified, the default disk size is 100GB.
        :param pulumi.Input[str] disk_type: Type of the disk attached to each node (e.g. 'pd-standard', 'pd-ssd' or 'pd-balanced') If unspecified, the default disk type is 'pd-standard'
        :param pulumi.Input['EphemeralStorageConfigArgs'] ephemeral_storage_config: Parameters for the ephemeral storage filesystem. If unspecified, ephemeral storage is backed by the boot disk.
        :param pulumi.Input['EphemeralStorageLocalSsdConfigArgs'] ephemeral_storage_local_ssd_config: Parameters for the node ephemeral storage using Local SSDs. If unspecified, ephemeral storage is backed by the boot disk. This field is functionally equivalent to the ephemeral_storage_config
        :param pulumi.Input['FastSocketArgs'] fast_socket: Enable or disable NCCL fast socket for the node pool.
        :param pulumi.Input['GcfsConfigArgs'] gcfs_config: GCFS (Google Container File System) configs.
        :param pulumi.Input['VirtualNICArgs'] gvnic: Enable or disable gvnic on the node pool.
        :param pulumi.Input[str] image_type: The image type to use for this node. Note that for a given image type, the latest version of it will be used. Please see https://cloud.google.com/kubernetes-engine/docs/concepts/node-images for available image types.
        :param pulumi.Input['NodeKubeletConfigArgs'] kubelet_config: Node kubelet configs.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: The map of Kubernetes labels (key/value pairs) to be applied to each node. These will added in addition to any default label(s) that Kubernetes may apply to the node. In case of conflict in label keys, the applied set may differ depending on the Kubernetes version -- it's best to assume the behavior is undefined and conflicts should be avoided. For more information, including usage and the valid values, see: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/
        :param pulumi.Input['LinuxNodeConfigArgs'] linux_node_config: Parameters that can be configured on Linux nodes.
        :param pulumi.Input['LocalNvmeSsdBlockConfigArgs'] local_nvme_ssd_block_config: Parameters for using raw-block Local NVMe SSDs.
        :param pulumi.Input[int] local_ssd_count: The number of local SSD disks to be attached to the node. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        :param pulumi.Input['NodePoolLoggingConfigArgs'] logging_config: Logging configuration.
        :param pulumi.Input[str] machine_type: The name of a Google Compute Engine [machine type](https://cloud.google.com/compute/docs/machine-types). If unspecified, the default machine type is `e2-medium`.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] metadata: The metadata key/value pairs assigned to instances in the cluster. Keys must conform to the regexp `[a-zA-Z0-9-_]+` and be less than 128 bytes in length. These are reflected as part of a URL in the metadata server. Additionally, to avoid ambiguity, keys must not conflict with any other metadata keys for the project or be one of the reserved keys: - "cluster-location" - "cluster-name" - "cluster-uid" - "configure-sh" - "containerd-configure-sh" - "enable-oslogin" - "gci-ensure-gke-docker" - "gci-metrics-enabled" - "gci-update-strategy" - "instance-template" - "kube-env" - "startup-script" - "user-data" - "disable-address-manager" - "windows-startup-script-ps1" - "common-psm1" - "k8s-node-setup-psm1" - "install-ssh-psm1" - "user-profile-psm1" Values are free-form strings, and only have meaning as interpreted by the image running in the instance. The only restriction placed on them is that each value's size must be less than or equal to 32 KB. The total size of all keys and values must be less than 512 KB.
        :param pulumi.Input[str] min_cpu_platform: Minimum CPU platform to be used by this instance. The instance may be scheduled on the specified or newer CPU platform. Applicable values are the friendly names of CPU platforms, such as `minCpuPlatform: "Intel Haswell"` or `minCpuPlatform: "Intel Sandy Bridge"`. For more information, read [how to specify min CPU platform](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform).
        :param pulumi.Input[str] node_group: Setting this field will assign instances of this pool to run on the specified node group. This is useful for running workloads on [sole tenant nodes](https://cloud.google.com/compute/docs/nodes/sole-tenant-nodes).
        :param pulumi.Input[Sequence[pulumi.Input[str]]] oauth_scopes: The set of Google API scopes to be made available on all of the node VMs under the "default" service account. The following scopes are recommended, but not required, and by default are not included: * `https://www.googleapis.com/auth/compute` is required for mounting persistent storage on your nodes. * `https://www.googleapis.com/auth/devstorage.read_only` is required for communicating with **gcr.io** (the [Google Container Registry](https://cloud.google.com/container-registry/)). If unspecified, no scopes are added, unless Cloud Logging or Cloud Monitoring are enabled, in which case their required scopes will be added.
        :param pulumi.Input[bool] preemptible: Whether the nodes are created as preemptible VM instances. See: https://cloud.google.com/compute/docs/instances/preemptible for more inforamtion about preemptible VM instances.
        :param pulumi.Input['ReservationAffinityArgs'] reservation_affinity: The optional reservation affinity. Setting this field will apply the specified [Zonal Compute Reservation](https://cloud.google.com/compute/docs/instances/reserving-zonal-resources) to this node pool.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] resource_labels: The resource labels for the node pool to use to annotate any related Google Compute Engine resources.
        :param pulumi.Input['SandboxConfigArgs'] sandbox_config: Sandbox configuration for this node.
        :param pulumi.Input[str] service_account: The Google Cloud Platform Service Account to be used by the node VMs. Specify the email address of the Service Account; otherwise, if no Service Account is specified, the "default" service account is used.
        :param pulumi.Input['ShieldedInstanceConfigArgs'] shielded_instance_config: Shielded Instance options.
        :param pulumi.Input[bool] spot: Spot flag for enabling Spot VM, which is a rebrand of the existing preemptible flag.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: The list of instance tags applied to all nodes. Tags are used to identify valid sources or targets for network firewalls and are specified by the client during cluster or node pool creation. Each tag within the list must comply with RFC1035.
        :param pulumi.Input[Sequence[pulumi.Input['NodeTaintArgs']]] taints: List of kubernetes taints to be applied to each node. For more information, including usage and the valid values, see: https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/
        :param pulumi.Input['WindowsNodeConfigArgs'] windows_node_config: Parameters that can be configured on Windows nodes.
        :param pulumi.Input['WorkloadMetadataConfigArgs'] workload_metadata_config: The workload metadata configuration for this node.
        """
        if accelerators is not None:
            pulumi.set(__self__, "accelerators", accelerators)
        if advanced_machine_features is not None:
            pulumi.set(__self__, "advanced_machine_features", advanced_machine_features)
        if boot_disk_kms_key is not None:
            pulumi.set(__self__, "boot_disk_kms_key", boot_disk_kms_key)
        if confidential_nodes is not None:
            pulumi.set(__self__, "confidential_nodes", confidential_nodes)
        if disk_size_gb is not None:
            pulumi.set(__self__, "disk_size_gb", disk_size_gb)
        if disk_type is not None:
            pulumi.set(__self__, "disk_type", disk_type)
        if ephemeral_storage_config is not None:
            pulumi.set(__self__, "ephemeral_storage_config", ephemeral_storage_config)
        if ephemeral_storage_local_ssd_config is not None:
            pulumi.set(__self__, "ephemeral_storage_local_ssd_config", ephemeral_storage_local_ssd_config)
        if fast_socket is not None:
            pulumi.set(__self__, "fast_socket", fast_socket)
        if gcfs_config is not None:
            pulumi.set(__self__, "gcfs_config", gcfs_config)
        if gvnic is not None:
            pulumi.set(__self__, "gvnic", gvnic)
        if image_type is not None:
            pulumi.set(__self__, "image_type", image_type)
        if kubelet_config is not None:
            pulumi.set(__self__, "kubelet_config", kubelet_config)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if linux_node_config is not None:
            pulumi.set(__self__, "linux_node_config", linux_node_config)
        if local_nvme_ssd_block_config is not None:
            pulumi.set(__self__, "local_nvme_ssd_block_config", local_nvme_ssd_block_config)
        if local_ssd_count is not None:
            pulumi.set(__self__, "local_ssd_count", local_ssd_count)
        if logging_config is not None:
            pulumi.set(__self__, "logging_config", logging_config)
        if machine_type is not None:
            pulumi.set(__self__, "machine_type", machine_type)
        if metadata is not None:
            pulumi.set(__self__, "metadata", metadata)
        if min_cpu_platform is not None:
            pulumi.set(__self__, "min_cpu_platform", min_cpu_platform)
        if node_group is not None:
            pulumi.set(__self__, "node_group", node_group)
        if oauth_scopes is not None:
            pulumi.set(__self__, "oauth_scopes", oauth_scopes)
        if preemptible is not None:
            pulumi.set(__self__, "preemptible", preemptible)
        if reservation_affinity is not None:
            pulumi.set(__self__, "reservation_affinity", reservation_affinity)
        if resource_labels is not None:
            pulumi.set(__self__, "resource_labels", resource_labels)
        if sandbox_config is not None:
            pulumi.set(__self__, "sandbox_config", sandbox_config)
        if service_account is not None:
            pulumi.set(__self__, "service_account", service_account)
        if shielded_instance_config is not None:
            pulumi.set(__self__, "shielded_instance_config", shielded_instance_config)
        if spot is not None:
            pulumi.set(__self__, "spot", spot)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if taints is not None:
            pulumi.set(__self__, "taints", taints)
        if windows_node_config is not None:
            pulumi.set(__self__, "windows_node_config", windows_node_config)
        if workload_metadata_config is not None:
            pulumi.set(__self__, "workload_metadata_config", workload_metadata_config)

    @property
    @pulumi.getter
    def accelerators(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AcceleratorConfigArgs']]]]:
        """
        A list of hardware accelerators to be attached to each node. See https://cloud.google.com/compute/docs/gpus for more information about support for GPUs.
        """
        return pulumi.get(self, "accelerators")

    @accelerators.setter
    def accelerators(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AcceleratorConfigArgs']]]]):
        pulumi.set(self, "accelerators", value)

    @property
    @pulumi.getter(name="advancedMachineFeatures")
    def advanced_machine_features(self) -> Optional[pulumi.Input['AdvancedMachineFeaturesArgs']]:
        """
        Advanced features for the Compute Engine VM.
        """
        return pulumi.get(self, "advanced_machine_features")

    @advanced_machine_features.setter
    def advanced_machine_features(self, value: Optional[pulumi.Input['AdvancedMachineFeaturesArgs']]):
        pulumi.set(self, "advanced_machine_features", value)

    @property
    @pulumi.getter(name="bootDiskKmsKey")
    def boot_disk_kms_key(self) -> Optional[pulumi.Input[str]]:
        """
         The Customer Managed Encryption Key used to encrypt the boot disk attached to each node in the node pool. This should be of the form projects/[KEY_PROJECT_ID]/locations/[LOCATION]/keyRings/[RING_NAME]/cryptoKeys/[KEY_NAME]. For more information about protecting resources with Cloud KMS Keys please see: https://cloud.google.com/compute/docs/disks/customer-managed-encryption
        """
        return pulumi.get(self, "boot_disk_kms_key")

    @boot_disk_kms_key.setter
    def boot_disk_kms_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "boot_disk_kms_key", value)

    @property
    @pulumi.getter(name="confidentialNodes")
    def confidential_nodes(self) -> Optional[pulumi.Input['ConfidentialNodesArgs']]:
        """
        Confidential nodes config. All the nodes in the node pool will be Confidential VM once enabled.
        """
        return pulumi.get(self, "confidential_nodes")

    @confidential_nodes.setter
    def confidential_nodes(self, value: Optional[pulumi.Input['ConfidentialNodesArgs']]):
        pulumi.set(self, "confidential_nodes", value)

    @property
    @pulumi.getter(name="diskSizeGb")
    def disk_size_gb(self) -> Optional[pulumi.Input[int]]:
        """
        Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB. If unspecified, the default disk size is 100GB.
        """
        return pulumi.get(self, "disk_size_gb")

    @disk_size_gb.setter
    def disk_size_gb(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "disk_size_gb", value)

    @property
    @pulumi.getter(name="diskType")
    def disk_type(self) -> Optional[pulumi.Input[str]]:
        """
        Type of the disk attached to each node (e.g. 'pd-standard', 'pd-ssd' or 'pd-balanced') If unspecified, the default disk type is 'pd-standard'
        """
        return pulumi.get(self, "disk_type")

    @disk_type.setter
    def disk_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "disk_type", value)

    @property
    @pulumi.getter(name="ephemeralStorageConfig")
    def ephemeral_storage_config(self) -> Optional[pulumi.Input['EphemeralStorageConfigArgs']]:
        """
        Parameters for the ephemeral storage filesystem. If unspecified, ephemeral storage is backed by the boot disk.
        """
        return pulumi.get(self, "ephemeral_storage_config")

    @ephemeral_storage_config.setter
    def ephemeral_storage_config(self, value: Optional[pulumi.Input['EphemeralStorageConfigArgs']]):
        pulumi.set(self, "ephemeral_storage_config", value)

    @property
    @pulumi.getter(name="ephemeralStorageLocalSsdConfig")
    def ephemeral_storage_local_ssd_config(self) -> Optional[pulumi.Input['EphemeralStorageLocalSsdConfigArgs']]:
        """
        Parameters for the node ephemeral storage using Local SSDs. If unspecified, ephemeral storage is backed by the boot disk. This field is functionally equivalent to the ephemeral_storage_config
        """
        return pulumi.get(self, "ephemeral_storage_local_ssd_config")

    @ephemeral_storage_local_ssd_config.setter
    def ephemeral_storage_local_ssd_config(self, value: Optional[pulumi.Input['EphemeralStorageLocalSsdConfigArgs']]):
        pulumi.set(self, "ephemeral_storage_local_ssd_config", value)

    @property
    @pulumi.getter(name="fastSocket")
    def fast_socket(self) -> Optional[pulumi.Input['FastSocketArgs']]:
        """
        Enable or disable NCCL fast socket for the node pool.
        """
        return pulumi.get(self, "fast_socket")

    @fast_socket.setter
    def fast_socket(self, value: Optional[pulumi.Input['FastSocketArgs']]):
        pulumi.set(self, "fast_socket", value)

    @property
    @pulumi.getter(name="gcfsConfig")
    def gcfs_config(self) -> Optional[pulumi.Input['GcfsConfigArgs']]:
        """
        GCFS (Google Container File System) configs.
        """
        return pulumi.get(self, "gcfs_config")

    @gcfs_config.setter
    def gcfs_config(self, value: Optional[pulumi.Input['GcfsConfigArgs']]):
        pulumi.set(self, "gcfs_config", value)

    @property
    @pulumi.getter
    def gvnic(self) -> Optional[pulumi.Input['VirtualNICArgs']]:
        """
        Enable or disable gvnic on the node pool.
        """
        return pulumi.get(self, "gvnic")

    @gvnic.setter
    def gvnic(self, value: Optional[pulumi.Input['VirtualNICArgs']]):
        pulumi.set(self, "gvnic", value)

    @property
    @pulumi.getter(name="imageType")
    def image_type(self) -> Optional[pulumi.Input[str]]:
        """
        The image type to use for this node. Note that for a given image type, the latest version of it will be used. Please see https://cloud.google.com/kubernetes-engine/docs/concepts/node-images for available image types.
        """
        return pulumi.get(self, "image_type")

    @image_type.setter
    def image_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image_type", value)

    @property
    @pulumi.getter(name="kubeletConfig")
    def kubelet_config(self) -> Optional[pulumi.Input['NodeKubeletConfigArgs']]:
        """
        Node kubelet configs.
        """
        return pulumi.get(self, "kubelet_config")

    @kubelet_config.setter
    def kubelet_config(self, value: Optional[pulumi.Input['NodeKubeletConfigArgs']]):
        pulumi.set(self, "kubelet_config", value)

    @property
    @pulumi.getter
    def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        The map of Kubernetes labels (key/value pairs) to be applied to each node. These will added in addition to any default label(s) that Kubernetes may apply to the node. In case of conflict in label keys, the applied set may differ depending on the Kubernetes version -- it's best to assume the behavior is undefined and conflicts should be avoided. For more information, including usage and the valid values, see: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/
        """
        return pulumi.get(self, "labels")

    @labels.setter
    def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "labels", value)

    @property
    @pulumi.getter(name="linuxNodeConfig")
    def linux_node_config(self) -> Optional[pulumi.Input['LinuxNodeConfigArgs']]:
        """
        Parameters that can be configured on Linux nodes.
        """
        return pulumi.get(self, "linux_node_config")

    @linux_node_config.setter
    def linux_node_config(self, value: Optional[pulumi.Input['LinuxNodeConfigArgs']]):
        pulumi.set(self, "linux_node_config", value)

    @property
    @pulumi.getter(name="localNvmeSsdBlockConfig")
    def local_nvme_ssd_block_config(self) -> Optional[pulumi.Input['LocalNvmeSsdBlockConfigArgs']]:
        """
        Parameters for using raw-block Local NVMe SSDs.
        """
        return pulumi.get(self, "local_nvme_ssd_block_config")

    @local_nvme_ssd_block_config.setter
    def local_nvme_ssd_block_config(self, value: Optional[pulumi.Input['LocalNvmeSsdBlockConfigArgs']]):
        pulumi.set(self, "local_nvme_ssd_block_config", value)

    @property
    @pulumi.getter(name="localSsdCount")
    def local_ssd_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of local SSD disks to be attached to the node. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        """
        return pulumi.get(self, "local_ssd_count")

    @local_ssd_count.setter
    def local_ssd_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "local_ssd_count", value)

    @property
    @pulumi.getter(name="loggingConfig")
    def logging_config(self) -> Optional[pulumi.Input['NodePoolLoggingConfigArgs']]:
        """
        Logging configuration.
        """
        return pulumi.get(self, "logging_config")

    @logging_config.setter
    def logging_config(self, value: Optional[pulumi.Input['NodePoolLoggingConfigArgs']]):
        pulumi.set(self, "logging_config", value)

    @property
    @pulumi.getter(name="machineType")
    def machine_type(self) -> Optional[pulumi.Input[str]]:
        """
        The name of a Google Compute Engine [machine type](https://cloud.google.com/compute/docs/machine-types). If unspecified, the default machine type is `e2-medium`.
        """
        return pulumi.get(self, "machine_type")

    @machine_type.setter
    def machine_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "machine_type", value)

    @property
    @pulumi.getter
    def metadata(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        The metadata key/value pairs assigned to instances in the cluster. Keys must conform to the regexp `[a-zA-Z0-9-_]+` and be less than 128 bytes in length. These are reflected as part of a URL in the metadata server. Additionally, to avoid ambiguity, keys must not conflict with any other metadata keys for the project or be one of the reserved keys: - "cluster-location" - "cluster-name" - "cluster-uid" - "configure-sh" - "containerd-configure-sh" - "enable-oslogin" - "gci-ensure-gke-docker" - "gci-metrics-enabled" - "gci-update-strategy" - "instance-template" - "kube-env" - "startup-script" - "user-data" - "disable-address-manager" - "windows-startup-script-ps1" - "common-psm1" - "k8s-node-setup-psm1" - "install-ssh-psm1" - "user-profile-psm1" Values are free-form strings, and only have meaning as interpreted by the image running in the instance. The only restriction placed on them is that each value's size must be less than or equal to 32 KB. The total size of all keys and values must be less than 512 KB.
        """
        return pulumi.get(self, "metadata")

    @metadata.setter
    def metadata(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "metadata", value)

    @property
    @pulumi.getter(name="minCpuPlatform")
    def min_cpu_platform(self) -> Optional[pulumi.Input[str]]:
        """
        Minimum CPU platform to be used by this instance. The instance may be scheduled on the specified or newer CPU platform. Applicable values are the friendly names of CPU platforms, such as `minCpuPlatform: "Intel Haswell"` or `minCpuPlatform: "Intel Sandy Bridge"`. For more information, read [how to specify min CPU platform](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform).
        """
        return pulumi.get(self, "min_cpu_platform")

    @min_cpu_platform.setter
    def min_cpu_platform(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "min_cpu_platform", value)

    @property
    @pulumi.getter(name="nodeGroup")
    def node_group(self) -> Optional[pulumi.Input[str]]:
        """
        Setting this field will assign instances of this pool to run on the specified node group. This is useful for running workloads on [sole tenant nodes](https://cloud.google.com/compute/docs/nodes/sole-tenant-nodes).
        """
        return pulumi.get(self, "node_group")

    @node_group.setter
    def node_group(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "node_group", value)

    @property
    @pulumi.getter(name="oauthScopes")
    def oauth_scopes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The set of Google API scopes to be made available on all of the node VMs under the "default" service account. The following scopes are recommended, but not required, and by default are not included: * `https://www.googleapis.com/auth/compute` is required for mounting persistent storage on your nodes. * `https://www.googleapis.com/auth/devstorage.read_only` is required for communicating with **gcr.io** (the [Google Container Registry](https://cloud.google.com/container-registry/)). If unspecified, no scopes are added, unless Cloud Logging or Cloud Monitoring are enabled, in which case their required scopes will be added.
        """
        return pulumi.get(self, "oauth_scopes")

    @oauth_scopes.setter
    def oauth_scopes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "oauth_scopes", value)

    @property
    @pulumi.getter
    def preemptible(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the nodes are created as preemptible VM instances. See: https://cloud.google.com/compute/docs/instances/preemptible for more inforamtion about preemptible VM instances.
        """
        return pulumi.get(self, "preemptible")

    @preemptible.setter
    def preemptible(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "preemptible", value)

    @property
    @pulumi.getter(name="reservationAffinity")
    def reservation_affinity(self) -> Optional[pulumi.Input['ReservationAffinityArgs']]:
        """
        The optional reservation affinity. Setting this field will apply the specified [Zonal Compute Reservation](https://cloud.google.com/compute/docs/instances/reserving-zonal-resources) to this node pool.
        """
        return pulumi.get(self, "reservation_affinity")

    @reservation_affinity.setter
    def reservation_affinity(self, value: Optional[pulumi.Input['ReservationAffinityArgs']]):
        pulumi.set(self, "reservation_affinity", value)

    @property
    @pulumi.getter(name="resourceLabels")
    def resource_labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        The resource labels for the node pool to use to annotate any related Google Compute Engine resources.
        """
        return pulumi.get(self, "resource_labels")

    @resource_labels.setter
    def resource_labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "resource_labels", value)

    @property
    @pulumi.getter(name="sandboxConfig")
    def sandbox_config(self) -> Optional[pulumi.Input['SandboxConfigArgs']]:
        """
        Sandbox configuration for this node.
        """
        return pulumi.get(self, "sandbox_config")

    @sandbox_config.setter
    def sandbox_config(self, value: Optional[pulumi.Input['SandboxConfigArgs']]):
        pulumi.set(self, "sandbox_config", value)

    @property
    @pulumi.getter(name="serviceAccount")
    def service_account(self) -> Optional[pulumi.Input[str]]:
        """
        The Google Cloud Platform Service Account to be used by the node VMs. Specify the email address of the Service Account; otherwise, if no Service Account is specified, the "default" service account is used.
        """
        return pulumi.get(self, "service_account")

    @service_account.setter
    def service_account(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_account", value)

    @property
    @pulumi.getter(name="shieldedInstanceConfig")
    def shielded_instance_config(self) -> Optional[pulumi.Input['ShieldedInstanceConfigArgs']]:
        """
        Shielded Instance options.
        """
        return pulumi.get(self, "shielded_instance_config")

    @shielded_instance_config.setter
    def shielded_instance_config(self, value: Optional[pulumi.Input['ShieldedInstanceConfigArgs']]):
        pulumi.set(self, "shielded_instance_config", value)

    @property
    @pulumi.getter
    def spot(self) -> Optional[pulumi.Input[bool]]:
        """
        Spot flag for enabling Spot VM, which is a rebrand of the existing preemptible flag.
        """
        return pulumi.get(self, "spot")

    @spot.setter
    def spot(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "spot", value)

    @property
    @pulumi.getter
    def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The list of instance tags applied to all nodes. Tags are used to identify valid sources or targets for network firewalls and are specified by the client during cluster or node pool creation. Each tag within the list must comply with RFC1035.
        """
        return pulumi.get(self, "tags")

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "tags", value)

    @property
    @pulumi.getter
    def taints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NodeTaintArgs']]]]:
        """
        List of kubernetes taints to be applied to each node. For more information, including usage and the valid values, see: https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/
        """
        return pulumi.get(self, "taints")

    @taints.setter
    def taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NodeTaintArgs']]]]):
        pulumi.set(self, "taints", value)

    @property
    @pulumi.getter(name="windowsNodeConfig")
    def windows_node_config(self) -> Optional[pulumi.Input['WindowsNodeConfigArgs']]:
        """
        Parameters that can be configured on Windows nodes.
        """
        return pulumi.get(self, "windows_node_config")

    @windows_node_config.setter
    def windows_node_config(self, value: Optional[pulumi.Input['WindowsNodeConfigArgs']]):
        pulumi.set(self, "windows_node_config", value)

    @property
    @pulumi.getter(name="workloadMetadataConfig")
    def workload_metadata_config(self) -> Optional[pulumi.Input['WorkloadMetadataConfigArgs']]:
        """
        The workload metadata configuration for this node.
        """
        return pulumi.get(self, "workload_metadata_config")

    @workload_metadata_config.setter
    def workload_metadata_config(self, value: Optional[pulumi.Input['WorkloadMetadataConfigArgs']]):
        pulumi.set(self, "workload_metadata_config", value)


@pulumi.input_type
class NodeKubeletConfigArgs:
    def __init__(__self__, *,
                 cpu_cfs_quota: Optional[pulumi.Input[bool]] = None,
                 cpu_cfs_quota_period: Optional[pulumi.Input[str]] = None,
                 cpu_manager_policy: Optional[pulumi.Input[str]] = None,
                 pod_pids_limit: Optional[pulumi.Input[str]] = None):
        """
        Node kubelet configs.
        :param pulumi.Input[bool] cpu_cfs_quota: Enable CPU CFS quota enforcement for containers that specify CPU limits. This option is enabled by default which makes kubelet use CFS quota (https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt) to enforce container CPU limits. Otherwise, CPU limits will not be enforced at all. Disable this option to mitigate CPU throttling problems while still having your pods to be in Guaranteed QoS class by specifying the CPU limits. The default value is 'true' if unspecified.
        :param pulumi.Input[str] cpu_cfs_quota_period: Set the CPU CFS quota period value 'cpu.cfs_period_us'. The string must be a sequence of decimal numbers, each with optional fraction and a unit suffix, such as "300ms". Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h". The value must be a positive duration.
        :param pulumi.Input[str] cpu_manager_policy: Control the CPU management policy on the node. See https://kubernetes.io/docs/tasks/administer-cluster/cpu-management-policies/ The following values are allowed. * "none": the default, which represents the existing scheduling behavior. * "static": allows pods with certain resource characteristics to be granted increased CPU affinity and exclusivity on the node. The default value is 'none' if unspecified.
        :param pulumi.Input[str] pod_pids_limit: Set the Pod PID limits. See https://kubernetes.io/docs/concepts/policy/pid-limiting/#pod-pid-limits Controls the maximum number of processes allowed to run in a pod. The value must be greater than or equal to 1024 and less than 4194304.
        """
        if cpu_cfs_quota is not None:
            pulumi.set(__self__, "cpu_cfs_quota", cpu_cfs_quota)
        if cpu_cfs_quota_period is not None:
            pulumi.set(__self__, "cpu_cfs_quota_period", cpu_cfs_quota_period)
        if cpu_manager_policy is not None:
            pulumi.set(__self__, "cpu_manager_policy", cpu_manager_policy)
        if pod_pids_limit is not None:
            pulumi.set(__self__, "pod_pids_limit", pod_pids_limit)

    @property
    @pulumi.getter(name="cpuCfsQuota")
    def cpu_cfs_quota(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable CPU CFS quota enforcement for containers that specify CPU limits. This option is enabled by default which makes kubelet use CFS quota (https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt) to enforce container CPU limits. Otherwise, CPU limits will not be enforced at all. Disable this option to mitigate CPU throttling problems while still having your pods to be in Guaranteed QoS class by specifying the CPU limits. The default value is 'true' if unspecified.
        """
        return pulumi.get(self, "cpu_cfs_quota")

    @cpu_cfs_quota.setter
    def cpu_cfs_quota(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "cpu_cfs_quota", value)

    @property
    @pulumi.getter(name="cpuCfsQuotaPeriod")
    def cpu_cfs_quota_period(self) -> Optional[pulumi.Input[str]]:
        """
        Set the CPU CFS quota period value 'cpu.cfs_period_us'. The string must be a sequence of decimal numbers, each with optional fraction and a unit suffix, such as "300ms". Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h". The value must be a positive duration.
        """
        return pulumi.get(self, "cpu_cfs_quota_period")

    @cpu_cfs_quota_period.setter
    def cpu_cfs_quota_period(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cpu_cfs_quota_period", value)

    @property
    @pulumi.getter(name="cpuManagerPolicy")
    def cpu_manager_policy(self) -> Optional[pulumi.Input[str]]:
        """
        Control the CPU management policy on the node. See https://kubernetes.io/docs/tasks/administer-cluster/cpu-management-policies/ The following values are allowed. * "none": the default, which represents the existing scheduling behavior. * "static": allows pods with certain resource characteristics to be granted increased CPU affinity and exclusivity on the node. The default value is 'none' if unspecified.
        """
        return pulumi.get(self, "cpu_manager_policy")

    @cpu_manager_policy.setter
    def cpu_manager_policy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cpu_manager_policy", value)

    @property
    @pulumi.getter(name="podPidsLimit")
    def pod_pids_limit(self) -> Optional[pulumi.Input[str]]:
        """
        Set the Pod PID limits. See https://kubernetes.io/docs/concepts/policy/pid-limiting/#pod-pid-limits Controls the maximum number of processes allowed to run in a pod. The value must be greater than or equal to 1024 and less than 4194304.
        """
        return pulumi.get(self, "pod_pids_limit")

    @pod_pids_limit.setter
    def pod_pids_limit(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "pod_pids_limit", value)


@pulumi.input_type
class NodeManagementArgs:
    def __init__(__self__, *,
                 auto_repair: Optional[pulumi.Input[bool]] = None,
                 auto_upgrade: Optional[pulumi.Input[bool]] = None,
                 upgrade_options: Optional[pulumi.Input['AutoUpgradeOptionsArgs']] = None):
        """
        NodeManagement defines the set of node management services turned on for the node pool.
        :param pulumi.Input[bool] auto_repair: Whether the nodes will be automatically repaired.
        :param pulumi.Input[bool] auto_upgrade: Whether the nodes will be automatically upgraded.
        :param pulumi.Input['AutoUpgradeOptionsArgs'] upgrade_options: Specifies the Auto Upgrade knobs for the node pool.
        """
        if auto_repair is not None:
            pulumi.set(__self__, "auto_repair", auto_repair)
        if auto_upgrade is not None:
            pulumi.set(__self__, "auto_upgrade", auto_upgrade)
        if upgrade_options is not None:
            pulumi.set(__self__, "upgrade_options", upgrade_options)

    @property
    @pulumi.getter(name="autoRepair")
    def auto_repair(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the nodes will be automatically repaired.
        """
        return pulumi.get(self, "auto_repair")

    @auto_repair.setter
    def auto_repair(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "auto_repair", value)

    @property
    @pulumi.getter(name="autoUpgrade")
    def auto_upgrade(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the nodes will be automatically upgraded.
        """
        return pulumi.get(self, "auto_upgrade")

    @auto_upgrade.setter
    def auto_upgrade(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "auto_upgrade", value)

    @property
    @pulumi.getter(name="upgradeOptions")
    def upgrade_options(self) -> Optional[pulumi.Input['AutoUpgradeOptionsArgs']]:
        """
        Specifies the Auto Upgrade knobs for the node pool.
        """
        return pulumi.get(self, "upgrade_options")

    @upgrade_options.setter
    def upgrade_options(self, value: Optional[pulumi.Input['AutoUpgradeOptionsArgs']]):
        pulumi.set(self, "upgrade_options", value)


@pulumi.input_type
class NodeNetworkConfigArgs:
    def __init__(__self__, *,
                 create_pod_range: Optional[pulumi.Input[bool]] = None,
                 enable_private_nodes: Optional[pulumi.Input[bool]] = None,
                 network_performance_config: Optional[pulumi.Input['NetworkPerformanceConfigArgs']] = None,
                 pod_cidr_overprovision_config: Optional[pulumi.Input['PodCIDROverprovisionConfigArgs']] = None,
                 pod_ipv4_cidr_block: Optional[pulumi.Input[str]] = None,
                 pod_range: Optional[pulumi.Input[str]] = None):
        """
        Parameters for node pool-level network config.
        :param pulumi.Input[bool] create_pod_range: Input only. Whether to create a new range for pod IPs in this node pool. Defaults are provided for `pod_range` and `pod_ipv4_cidr_block` if they are not specified. If neither `create_pod_range` or `pod_range` are specified, the cluster-level default (`ip_allocation_policy.cluster_ipv4_cidr_block`) is used. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        :param pulumi.Input[bool] enable_private_nodes: Whether nodes have internal IP addresses only. If enable_private_nodes is not specified, then the value is derived from cluster.privateClusterConfig.enablePrivateNodes
        :param pulumi.Input['NetworkPerformanceConfigArgs'] network_performance_config: Network bandwidth tier configuration.
        :param pulumi.Input['PodCIDROverprovisionConfigArgs'] pod_cidr_overprovision_config: [PRIVATE FIELD] Pod CIDR size overprovisioning config for the nodepool. Pod CIDR size per node depends on max_pods_per_node. By default, the value of max_pods_per_node is rounded off to next power of 2 and we then double that to get the size of pod CIDR block per node. Example: max_pods_per_node of 30 would result in 64 IPs (/26). This config can disable the doubling of IPs (we still round off to next power of 2) Example: max_pods_per_node of 30 will result in 32 IPs (/27) when overprovisioning is disabled.
        :param pulumi.Input[str] pod_ipv4_cidr_block: The IP address range for pod IPs in this node pool. Only applicable if `create_pod_range` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) to pick a specific range to use. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        :param pulumi.Input[str] pod_range: The ID of the secondary range for pod IPs. If `create_pod_range` is true, this ID is used for the new range. If `create_pod_range` is false, uses an existing secondary range with this ID. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        """
        if create_pod_range is not None:
            pulumi.set(__self__, "create_pod_range", create_pod_range)
        if enable_private_nodes is not None:
            pulumi.set(__self__, "enable_private_nodes", enable_private_nodes)
        if network_performance_config is not None:
            pulumi.set(__self__, "network_performance_config", network_performance_config)
        if pod_cidr_overprovision_config is not None:
            pulumi.set(__self__, "pod_cidr_overprovision_config", pod_cidr_overprovision_config)
        if pod_ipv4_cidr_block is not None:
            pulumi.set(__self__, "pod_ipv4_cidr_block", pod_ipv4_cidr_block)
        if pod_range is not None:
            pulumi.set(__self__, "pod_range", pod_range)

    @property
    @pulumi.getter(name="createPodRange")
    def create_pod_range(self) -> Optional[pulumi.Input[bool]]:
        """
        Input only. Whether to create a new range for pod IPs in this node pool. Defaults are provided for `pod_range` and `pod_ipv4_cidr_block` if they are not specified. If neither `create_pod_range` or `pod_range` are specified, the cluster-level default (`ip_allocation_policy.cluster_ipv4_cidr_block`) is used. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        """
        return pulumi.get(self, "create_pod_range")

    @create_pod_range.setter
    def create_pod_range(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "create_pod_range", value)

    @property
    @pulumi.getter(name="enablePrivateNodes")
    def enable_private_nodes(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether nodes have internal IP addresses only. If enable_private_nodes is not specified, then the value is derived from cluster.privateClusterConfig.enablePrivateNodes
        """
        return pulumi.get(self, "enable_private_nodes")

    @enable_private_nodes.setter
    def enable_private_nodes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_private_nodes", value)

    @property
    @pulumi.getter(name="networkPerformanceConfig")
    def network_performance_config(self) -> Optional[pulumi.Input['NetworkPerformanceConfigArgs']]:
        """
        Network bandwidth tier configuration.
        """
        return pulumi.get(self, "network_performance_config")

    @network_performance_config.setter
    def network_performance_config(self, value: Optional[pulumi.Input['NetworkPerformanceConfigArgs']]):
        pulumi.set(self, "network_performance_config", value)

    @property
    @pulumi.getter(name="podCidrOverprovisionConfig")
    def pod_cidr_overprovision_config(self) -> Optional[pulumi.Input['PodCIDROverprovisionConfigArgs']]:
        """
        [PRIVATE FIELD] Pod CIDR size overprovisioning config for the nodepool. Pod CIDR size per node depends on max_pods_per_node. By default, the value of max_pods_per_node is rounded off to next power of 2 and we then double that to get the size of pod CIDR block per node. Example: max_pods_per_node of 30 would result in 64 IPs (/26). This config can disable the doubling of IPs (we still round off to next power of 2) Example: max_pods_per_node of 30 will result in 32 IPs (/27) when overprovisioning is disabled.
        """
        return pulumi.get(self, "pod_cidr_overprovision_config")

    @pod_cidr_overprovision_config.setter
    def pod_cidr_overprovision_config(self, value: Optional[pulumi.Input['PodCIDROverprovisionConfigArgs']]):
        pulumi.set(self, "pod_cidr_overprovision_config", value)

    @property
    @pulumi.getter(name="podIpv4CidrBlock")
    def pod_ipv4_cidr_block(self) -> Optional[pulumi.Input[str]]:
        """
        The IP address range for pod IPs in this node pool. Only applicable if `create_pod_range` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) to pick a specific range to use. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        """
        return pulumi.get(self, "pod_ipv4_cidr_block")

    @pod_ipv4_cidr_block.setter
    def pod_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "pod_ipv4_cidr_block", value)

    @property
    @pulumi.getter(name="podRange")
    def pod_range(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the secondary range for pod IPs. If `create_pod_range` is true, this ID is used for the new range. If `create_pod_range` is false, uses an existing secondary range with this ID. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        """
        return pulumi.get(self, "pod_range")

    @pod_range.setter
    def pod_range(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "pod_range", value)


@pulumi.input_type
class NodePoolAutoConfigArgs:
    def __init__(__self__, *,
                 network_tags: Optional[pulumi.Input['NetworkTagsArgs']] = None):
        """
        node pool configs that apply to all auto-provisioned node pools in autopilot clusters and node auto-provisioning enabled clusters
        :param pulumi.Input['NetworkTagsArgs'] network_tags: The list of instance tags applied to all nodes. Tags are used to identify valid sources or targets for network firewalls and are specified by the client during cluster creation. Each tag within the list must comply with RFC1035.
        """
        if network_tags is not None:
            pulumi.set(__self__, "network_tags", network_tags)

    @property
    @pulumi.getter(name="networkTags")
    def network_tags(self) -> Optional[pulumi.Input['NetworkTagsArgs']]:
        """
        The list of instance tags applied to all nodes. Tags are used to identify valid sources or targets for network firewalls and are specified by the client during cluster creation. Each tag within the list must comply with RFC1035.
        """
        return pulumi.get(self, "network_tags")

    @network_tags.setter
    def network_tags(self, value: Optional[pulumi.Input['NetworkTagsArgs']]):
        pulumi.set(self, "network_tags", value)


@pulumi.input_type
class NodePoolAutoscalingArgs:
    def __init__(__self__, *,
                 autoprovisioned: Optional[pulumi.Input[bool]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 location_policy: Optional[pulumi.Input['NodePoolAutoscalingLocationPolicy']] = None,
                 max_node_count: Optional[pulumi.Input[int]] = None,
                 min_node_count: Optional[pulumi.Input[int]] = None,
                 total_max_node_count: Optional[pulumi.Input[int]] = None,
                 total_min_node_count: Optional[pulumi.Input[int]] = None):
        """
        NodePoolAutoscaling contains information required by cluster autoscaler to adjust the size of the node pool to the current cluster usage.
        :param pulumi.Input[bool] autoprovisioned: Can this node pool be deleted automatically.
        :param pulumi.Input[bool] enabled: Is autoscaling enabled for this node pool.
        :param pulumi.Input['NodePoolAutoscalingLocationPolicy'] location_policy: Location policy used when scaling up a nodepool.
        :param pulumi.Input[int] max_node_count: Maximum number of nodes for one location in the NodePool. Must be >= min_node_count. There has to be enough quota to scale up the cluster.
        :param pulumi.Input[int] min_node_count: Minimum number of nodes for one location in the NodePool. Must be >= 1 and <= max_node_count.
        :param pulumi.Input[int] total_max_node_count: Maximum number of nodes in the node pool. Must be greater than total_min_node_count. There has to be enough quota to scale up the cluster. The total_*_node_count fields are mutually exclusive with the *_node_count fields.
        :param pulumi.Input[int] total_min_node_count: Minimum number of nodes in the node pool. Must be greater than 1 less than total_max_node_count. The total_*_node_count fields are mutually exclusive with the *_node_count fields.
        """
        if autoprovisioned is not None:
            pulumi.set(__self__, "autoprovisioned", autoprovisioned)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if location_policy is not None:
            pulumi.set(__self__, "location_policy", location_policy)
        if max_node_count is not None:
            pulumi.set(__self__, "max_node_count", max_node_count)
        if min_node_count is not None:
            pulumi.set(__self__, "min_node_count", min_node_count)
        if total_max_node_count is not None:
            pulumi.set(__self__, "total_max_node_count", total_max_node_count)
        if total_min_node_count is not None:
            pulumi.set(__self__, "total_min_node_count", total_min_node_count)

    @property
    @pulumi.getter
    def autoprovisioned(self) -> Optional[pulumi.Input[bool]]:
        """
        Can this node pool be deleted automatically.
        """
        return pulumi.get(self, "autoprovisioned")

    @autoprovisioned.setter
    def autoprovisioned(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "autoprovisioned", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Is autoscaling enabled for this node pool.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter(name="locationPolicy")
    def location_policy(self) -> Optional[pulumi.Input['NodePoolAutoscalingLocationPolicy']]:
        """
        Location policy used when scaling up a nodepool.
        """
        return pulumi.get(self, "location_policy")

    @location_policy.setter
    def location_policy(self, value: Optional[pulumi.Input['NodePoolAutoscalingLocationPolicy']]):
        pulumi.set(self, "location_policy", value)

    @property
    @pulumi.getter(name="maxNodeCount")
    def max_node_count(self) -> Optional[pulumi.Input[int]]:
        """
        Maximum number of nodes for one location in the NodePool. Must be >= min_node_count. There has to be enough quota to scale up the cluster.
        """
        return pulumi.get(self, "max_node_count")

    @max_node_count.setter
    def max_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_node_count", value)

    @property
    @pulumi.getter(name="minNodeCount")
    def min_node_count(self) -> Optional[pulumi.Input[int]]:
        """
        Minimum number of nodes for one location in the NodePool. Must be >= 1 and <= max_node_count.
        """
        return pulumi.get(self, "min_node_count")

    @min_node_count.setter
    def min_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "min_node_count", value)

    @property
    @pulumi.getter(name="totalMaxNodeCount")
    def total_max_node_count(self) -> Optional[pulumi.Input[int]]:
        """
        Maximum number of nodes in the node pool. Must be greater than total_min_node_count. There has to be enough quota to scale up the cluster. The total_*_node_count fields are mutually exclusive with the *_node_count fields.
        """
        return pulumi.get(self, "total_max_node_count")

    @total_max_node_count.setter
    def total_max_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "total_max_node_count", value)

    @property
    @pulumi.getter(name="totalMinNodeCount")
    def total_min_node_count(self) -> Optional[pulumi.Input[int]]:
        """
        Minimum number of nodes in the node pool. Must be greater than 1 less than total_max_node_count. The total_*_node_count fields are mutually exclusive with the *_node_count fields.
        """
        return pulumi.get(self, "total_min_node_count")

    @total_min_node_count.setter
    def total_min_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "total_min_node_count", value)


@pulumi.input_type
class NodePoolDefaultsArgs:
    def __init__(__self__, *,
                 node_config_defaults: Optional[pulumi.Input['NodeConfigDefaultsArgs']] = None):
        """
        Subset of Nodepool message that has defaults.
        :param pulumi.Input['NodeConfigDefaultsArgs'] node_config_defaults: Subset of NodeConfig message that has defaults.
        """
        if node_config_defaults is not None:
            pulumi.set(__self__, "node_config_defaults", node_config_defaults)

    @property
    @pulumi.getter(name="nodeConfigDefaults")
    def node_config_defaults(self) -> Optional[pulumi.Input['NodeConfigDefaultsArgs']]:
        """
        Subset of NodeConfig message that has defaults.
        """
        return pulumi.get(self, "node_config_defaults")

    @node_config_defaults.setter
    def node_config_defaults(self, value: Optional[pulumi.Input['NodeConfigDefaultsArgs']]):
        pulumi.set(self, "node_config_defaults", value)


@pulumi.input_type
class NodePoolLoggingConfigArgs:
    def __init__(__self__, *,
                 variant_config: Optional[pulumi.Input['LoggingVariantConfigArgs']] = None):
        """
        NodePoolLoggingConfig specifies logging configuration for nodepools.
        :param pulumi.Input['LoggingVariantConfigArgs'] variant_config: Logging variant configuration.
        """
        if variant_config is not None:
            pulumi.set(__self__, "variant_config", variant_config)

    @property
    @pulumi.getter(name="variantConfig")
    def variant_config(self) -> Optional[pulumi.Input['LoggingVariantConfigArgs']]:
        """
        Logging variant configuration.
        """
        return pulumi.get(self, "variant_config")

    @variant_config.setter
    def variant_config(self, value: Optional[pulumi.Input['LoggingVariantConfigArgs']]):
        pulumi.set(self, "variant_config", value)


@pulumi.input_type
class NodePoolArgs:
    def __init__(__self__, *,
                 autoscaling: Optional[pulumi.Input['NodePoolAutoscalingArgs']] = None,
                 conditions: Optional[pulumi.Input[Sequence[pulumi.Input['StatusConditionArgs']]]] = None,
                 config: Optional[pulumi.Input['NodeConfigArgs']] = None,
                 etag: Optional[pulumi.Input[str]] = None,
                 initial_node_count: Optional[pulumi.Input[int]] = None,
                 locations: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 management: Optional[pulumi.Input['NodeManagementArgs']] = None,
                 max_pods_constraint: Optional[pulumi.Input['MaxPodsConstraintArgs']] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 network_config: Optional[pulumi.Input['NodeNetworkConfigArgs']] = None,
                 placement_policy: Optional[pulumi.Input['PlacementPolicyArgs']] = None,
                 upgrade_settings: Optional[pulumi.Input['UpgradeSettingsArgs']] = None,
                 version: Optional[pulumi.Input[str]] = None):
        """
        NodePool contains the name and configuration for a cluster's node pool. Node pools are a set of nodes (i.e. VM's), with a common configuration and specification, under the control of the cluster master. They may have a set of Kubernetes labels applied to them, which may be used to reference them during pod scheduling. They may also be resized up or down, to accommodate the workload. These upgrade settings control the level of parallelism and the level of disruption caused by an upgrade. maxUnavailable controls the number of nodes that can be simultaneously unavailable. maxSurge controls the number of additional nodes that can be added to the node pool temporarily for the time of the upgrade to increase the number of available nodes. (maxUnavailable + maxSurge) determines the level of parallelism (how many nodes are being upgraded at the same time). Note: upgrades inevitably introduce some disruption since workloads need to be moved from old nodes to new, upgraded ones. Even if maxUnavailable=0, this holds true. (Disruption stays within the limits of PodDisruptionBudget, if it is configured.) Consider a hypothetical node pool with 5 nodes having maxSurge=2, maxUnavailable=1. This means the upgrade process upgrades 3 nodes simultaneously. It creates 2 additional (upgraded) nodes, then it brings down 3 old (not yet upgraded) nodes at the same time. This ensures that there are always at least 4 nodes available.
        :param pulumi.Input['NodePoolAutoscalingArgs'] autoscaling: Autoscaler configuration for this NodePool. Autoscaler is enabled only if a valid configuration is present.
        :param pulumi.Input[Sequence[pulumi.Input['StatusConditionArgs']]] conditions: Which conditions caused the current node pool state.
        :param pulumi.Input['NodeConfigArgs'] config: The node configuration of the pool.
        :param pulumi.Input[str] etag: This checksum is computed by the server based on the value of node pool fields, and may be sent on update requests to ensure the client has an up-to-date value before proceeding.
        :param pulumi.Input[int] initial_node_count: The initial node count for the pool. You must ensure that your Compute Engine [resource quota](https://cloud.google.com/compute/quotas) is sufficient for this number of instances. You must also have available firewall and routes quota.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] locations: The list of Google Compute Engine [zones](https://cloud.google.com/compute/docs/zones#available) in which the NodePool's nodes should be located. If this value is unspecified during node pool creation, the [Cluster.Locations](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1/projects.locations.clusters#Cluster.FIELDS.locations) value will be used, instead. Warning: changing node pool locations will result in nodes being added and/or removed.
        :param pulumi.Input['NodeManagementArgs'] management: NodeManagement configuration for this NodePool.
        :param pulumi.Input['MaxPodsConstraintArgs'] max_pods_constraint: The constraint on the maximum number of pods that can be run simultaneously on a node in the node pool.
        :param pulumi.Input[str] name: The name of the node pool.
        :param pulumi.Input['NodeNetworkConfigArgs'] network_config: Networking configuration for this NodePool. If specified, it overrides the cluster-level defaults.
        :param pulumi.Input['PlacementPolicyArgs'] placement_policy: Specifies the node placement policy.
        :param pulumi.Input['UpgradeSettingsArgs'] upgrade_settings: Upgrade settings control disruption and speed of the upgrade.
        :param pulumi.Input[str] version: The version of Kubernetes running on this NodePool's nodes. If unspecified, it defaults as described [here](https://cloud.google.com/kubernetes-engine/versioning#specifying_node_version).
        """
        if autoscaling is not None:
            pulumi.set(__self__, "autoscaling", autoscaling)
        if conditions is not None:
            pulumi.set(__self__, "conditions", conditions)
        if config is not None:
            pulumi.set(__self__, "config", config)
        if etag is not None:
            pulumi.set(__self__, "etag", etag)
        if initial_node_count is not None:
            pulumi.set(__self__, "initial_node_count", initial_node_count)
        if locations is not None:
            pulumi.set(__self__, "locations", locations)
        if management is not None:
            pulumi.set(__self__, "management", management)
        if max_pods_constraint is not None:
            pulumi.set(__self__, "max_pods_constraint", max_pods_constraint)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if network_config is not None:
            pulumi.set(__self__, "network_config", network_config)
        if placement_policy is not None:
            pulumi.set(__self__, "placement_policy", placement_policy)
        if upgrade_settings is not None:
            pulumi.set(__self__, "upgrade_settings", upgrade_settings)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def autoscaling(self) -> Optional[pulumi.Input['NodePoolAutoscalingArgs']]:
        """
        Autoscaler configuration for this NodePool. Autoscaler is enabled only if a valid configuration is present.
        """
        return pulumi.get(self, "autoscaling")

    @autoscaling.setter
    def autoscaling(self, value: Optional[pulumi.Input['NodePoolAutoscalingArgs']]):
        pulumi.set(self, "autoscaling", value)

    @property
    @pulumi.getter
    def conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StatusConditionArgs']]]]:
        """
        Which conditions caused the current node pool state.
        """
        return pulumi.get(self, "conditions")

    @conditions.setter
    def conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StatusConditionArgs']]]]):
        pulumi.set(self, "conditions", value)

    @property
    @pulumi.getter
    def config(self) -> Optional[pulumi.Input['NodeConfigArgs']]:
        """
        The node configuration of the pool.
        """
        return pulumi.get(self, "config")

    @config.setter
    def config(self, value: Optional[pulumi.Input['NodeConfigArgs']]):
        pulumi.set(self, "config", value)

    @property
    @pulumi.getter
    def etag(self) -> Optional[pulumi.Input[str]]:
        """
        This checksum is computed by the server based on the value of node pool fields, and may be sent on update requests to ensure the client has an up-to-date value before proceeding.
        """
        return pulumi.get(self, "etag")

    @etag.setter
    def etag(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "etag", value)

    @property
    @pulumi.getter(name="initialNodeCount")
    def initial_node_count(self) -> Optional[pulumi.Input[int]]:
        """
        The initial node count for the pool. You must ensure that your Compute Engine [resource quota](https://cloud.google.com/compute/quotas) is sufficient for this number of instances. You must also have available firewall and routes quota.
        """
        return pulumi.get(self, "initial_node_count")

    @initial_node_count.setter
    def initial_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "initial_node_count", value)

    @property
    @pulumi.getter
    def locations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The list of Google Compute Engine [zones](https://cloud.google.com/compute/docs/zones#available) in which the NodePool's nodes should be located. If this value is unspecified during node pool creation, the [Cluster.Locations](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1/projects.locations.clusters#Cluster.FIELDS.locations) value will be used, instead. Warning: changing node pool locations will result in nodes being added and/or removed.
        """
        return pulumi.get(self, "locations")

    @locations.setter
    def locations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "locations", value)

    @property
    @pulumi.getter
    def management(self) -> Optional[pulumi.Input['NodeManagementArgs']]:
        """
        NodeManagement configuration for this NodePool.
        """
        return pulumi.get(self, "management")

    @management.setter
    def management(self, value: Optional[pulumi.Input['NodeManagementArgs']]):
        pulumi.set(self, "management", value)

    @property
    @pulumi.getter(name="maxPodsConstraint")
    def max_pods_constraint(self) -> Optional[pulumi.Input['MaxPodsConstraintArgs']]:
        """
        The constraint on the maximum number of pods that can be run simultaneously on a node in the node pool.
        """
        return pulumi.get(self, "max_pods_constraint")

    @max_pods_constraint.setter
    def max_pods_constraint(self, value: Optional[pulumi.Input['MaxPodsConstraintArgs']]):
        pulumi.set(self, "max_pods_constraint", value)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the node pool.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="networkConfig")
    def network_config(self) -> Optional[pulumi.Input['NodeNetworkConfigArgs']]:
        """
        Networking configuration for this NodePool. If specified, it overrides the cluster-level defaults.
        """
        return pulumi.get(self, "network_config")

    @network_config.setter
    def network_config(self, value: Optional[pulumi.Input['NodeNetworkConfigArgs']]):
        pulumi.set(self, "network_config", value)

    @property
    @pulumi.getter(name="placementPolicy")
    def placement_policy(self) -> Optional[pulumi.Input['PlacementPolicyArgs']]:
        """
        Specifies the node placement policy.
        """
        return pulumi.get(self, "placement_policy")

    @placement_policy.setter
    def placement_policy(self, value: Optional[pulumi.Input['PlacementPolicyArgs']]):
        pulumi.set(self, "placement_policy", value)

    @property
    @pulumi.getter(name="upgradeSettings")
    def upgrade_settings(self) -> Optional[pulumi.Input['UpgradeSettingsArgs']]:
        """
        Upgrade settings control disruption and speed of the upgrade.
        """
        return pulumi.get(self, "upgrade_settings")

    @upgrade_settings.setter
    def upgrade_settings(self, value: Optional[pulumi.Input['UpgradeSettingsArgs']]):
        pulumi.set(self, "upgrade_settings", value)

    @property
    @pulumi.getter
    def version(self) -> Optional[pulumi.Input[str]]:
        """
        The version of Kubernetes running on this NodePool's nodes. If unspecified, it defaults as described [here](https://cloud.google.com/kubernetes-engine/versioning#specifying_node_version).
        """
        return pulumi.get(self, "version")

    @version.setter
    def version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "version", value)


@pulumi.input_type
class NodeTaintArgs:
    def __init__(__self__, *,
                 effect: Optional[pulumi.Input['NodeTaintEffect']] = None,
                 key: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        """
        Kubernetes taint is composed of three fields: key, value, and effect. Effect can only be one of three types: NoSchedule, PreferNoSchedule or NoExecute. See [here](https://kubernetes.io/docs/concepts/configuration/taint-and-toleration) for more information, including usage and the valid values.
        :param pulumi.Input['NodeTaintEffect'] effect: Effect for taint.
        :param pulumi.Input[str] key: Key for taint.
        :param pulumi.Input[str] value: Value for taint.
        """
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def effect(self) -> Optional[pulumi.Input['NodeTaintEffect']]:
        """
        Effect for taint.
        """
        return pulumi.get(self, "effect")

    @effect.setter
    def effect(self, value: Optional[pulumi.Input['NodeTaintEffect']]):
        pulumi.set(self, "effect", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        """
        Key for taint.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        """
        Value for taint.
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class NotificationConfigArgs:
    def __init__(__self__, *,
                 pubsub: Optional[pulumi.Input['PubSubArgs']] = None):
        """
        NotificationConfig is the configuration of notifications.
        :param pulumi.Input['PubSubArgs'] pubsub: Notification config for Pub/Sub.
        """
        if pubsub is not None:
            pulumi.set(__self__, "pubsub", pubsub)

    @property
    @pulumi.getter
    def pubsub(self) -> Optional[pulumi.Input['PubSubArgs']]:
        """
        Notification config for Pub/Sub.
        """
        return pulumi.get(self, "pubsub")

    @pubsub.setter
    def pubsub(self, value: Optional[pulumi.Input['PubSubArgs']]):
        pulumi.set(self, "pubsub", value)


@pulumi.input_type
class PlacementPolicyArgs:
    def __init__(__self__, *,
                 type: Optional[pulumi.Input['PlacementPolicyType']] = None):
        """
        PlacementPolicy defines the placement policy used by the node pool.
        :param pulumi.Input['PlacementPolicyType'] type: The type of placement.
        """
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input['PlacementPolicyType']]:
        """
        The type of placement.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input['PlacementPolicyType']]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class PodCIDROverprovisionConfigArgs:
    def __init__(__self__, *,
                 disable: Optional[pulumi.Input[bool]] = None):
        """
        [PRIVATE FIELD] Config for pod CIDR size overprovisioning.
        :param pulumi.Input[bool] disable: Whether Pod CIDR overprovisioning is disabled. Note: Pod CIDR overprovisioning is enabled by default.
        """
        if disable is not None:
            pulumi.set(__self__, "disable", disable)

    @property
    @pulumi.getter
    def disable(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether Pod CIDR overprovisioning is disabled. Note: Pod CIDR overprovisioning is enabled by default.
        """
        return pulumi.get(self, "disable")

    @disable.setter
    def disable(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disable", value)


@pulumi.input_type
class PodSecurityPolicyConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for the PodSecurityPolicy feature.
        :param pulumi.Input[bool] enabled: Enable the PodSecurityPolicy controller for this cluster. If enabled, pods must be valid under a PodSecurityPolicy to be created.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable the PodSecurityPolicy controller for this cluster. If enabled, pods must be valid under a PodSecurityPolicy to be created.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class PrivateClusterConfigArgs:
    def __init__(__self__, *,
                 enable_private_endpoint: Optional[pulumi.Input[bool]] = None,
                 enable_private_nodes: Optional[pulumi.Input[bool]] = None,
                 master_global_access_config: Optional[pulumi.Input['PrivateClusterMasterGlobalAccessConfigArgs']] = None,
                 master_ipv4_cidr_block: Optional[pulumi.Input[str]] = None,
                 private_endpoint_subnetwork: Optional[pulumi.Input[str]] = None):
        """
        Configuration options for private clusters.
        :param pulumi.Input[bool] enable_private_endpoint: Whether the master's internal IP address is used as the cluster endpoint.
        :param pulumi.Input[bool] enable_private_nodes: Whether nodes have internal IP addresses only. If enabled, all nodes are given only RFC 1918 private addresses and communicate with the master via private networking.
        :param pulumi.Input['PrivateClusterMasterGlobalAccessConfigArgs'] master_global_access_config: Controls master global access settings.
        :param pulumi.Input[str] master_ipv4_cidr_block: The IP range in CIDR notation to use for the hosted master network. This range will be used for assigning internal IP addresses to the master or set of masters, as well as the ILB VIP. This range must not overlap with any other ranges in use within the cluster's network.
        :param pulumi.Input[str] private_endpoint_subnetwork: Subnet to provision the master's private endpoint during cluster creation. Specified in projects/*/regions/*/subnetworks/* format.
        """
        if enable_private_endpoint is not None:
            pulumi.set(__self__, "enable_private_endpoint", enable_private_endpoint)
        if enable_private_nodes is not None:
            pulumi.set(__self__, "enable_private_nodes", enable_private_nodes)
        if master_global_access_config is not None:
            pulumi.set(__self__, "master_global_access_config", master_global_access_config)
        if master_ipv4_cidr_block is not None:
            pulumi.set(__self__, "master_ipv4_cidr_block", master_ipv4_cidr_block)
        if private_endpoint_subnetwork is not None:
            pulumi.set(__self__, "private_endpoint_subnetwork", private_endpoint_subnetwork)

    @property
    @pulumi.getter(name="enablePrivateEndpoint")
    def enable_private_endpoint(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the master's internal IP address is used as the cluster endpoint.
        """
        return pulumi.get(self, "enable_private_endpoint")

    @enable_private_endpoint.setter
    def enable_private_endpoint(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_private_endpoint", value)

    @property
    @pulumi.getter(name="enablePrivateNodes")
    def enable_private_nodes(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether nodes have internal IP addresses only. If enabled, all nodes are given only RFC 1918 private addresses and communicate with the master via private networking.
        """
        return pulumi.get(self, "enable_private_nodes")

    @enable_private_nodes.setter
    def enable_private_nodes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_private_nodes", value)

    @property
    @pulumi.getter(name="masterGlobalAccessConfig")
    def master_global_access_config(self) -> Optional[pulumi.Input['PrivateClusterMasterGlobalAccessConfigArgs']]:
        """
        Controls master global access settings.
        """
        return pulumi.get(self, "master_global_access_config")

    @master_global_access_config.setter
    def master_global_access_config(self, value: Optional[pulumi.Input['PrivateClusterMasterGlobalAccessConfigArgs']]):
        pulumi.set(self, "master_global_access_config", value)

    @property
    @pulumi.getter(name="masterIpv4CidrBlock")
    def master_ipv4_cidr_block(self) -> Optional[pulumi.Input[str]]:
        """
        The IP range in CIDR notation to use for the hosted master network. This range will be used for assigning internal IP addresses to the master or set of masters, as well as the ILB VIP. This range must not overlap with any other ranges in use within the cluster's network.
        """
        return pulumi.get(self, "master_ipv4_cidr_block")

    @master_ipv4_cidr_block.setter
    def master_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "master_ipv4_cidr_block", value)

    @property
    @pulumi.getter(name="privateEndpointSubnetwork")
    def private_endpoint_subnetwork(self) -> Optional[pulumi.Input[str]]:
        """
        Subnet to provision the master's private endpoint during cluster creation. Specified in projects/*/regions/*/subnetworks/* format.
        """
        return pulumi.get(self, "private_endpoint_subnetwork")

    @private_endpoint_subnetwork.setter
    def private_endpoint_subnetwork(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "private_endpoint_subnetwork", value)


@pulumi.input_type
class PrivateClusterMasterGlobalAccessConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for controlling master global access settings.
        :param pulumi.Input[bool] enabled: Whenever master is accessible globally or not.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whenever master is accessible globally or not.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class ProtectConfigArgs:
    def __init__(__self__, *,
                 workload_config: Optional[pulumi.Input['WorkloadConfigArgs']] = None,
                 workload_vulnerability_mode: Optional[pulumi.Input['ProtectConfigWorkloadVulnerabilityMode']] = None):
        """
        ProtectConfig defines the flags needed to enable/disable features for the Protect API.
        :param pulumi.Input['WorkloadConfigArgs'] workload_config: WorkloadConfig defines which actions are enabled for a cluster's workload configurations.
        :param pulumi.Input['ProtectConfigWorkloadVulnerabilityMode'] workload_vulnerability_mode: Sets which mode to use for Protect workload vulnerability scanning feature.
        """
        if workload_config is not None:
            pulumi.set(__self__, "workload_config", workload_config)
        if workload_vulnerability_mode is not None:
            pulumi.set(__self__, "workload_vulnerability_mode", workload_vulnerability_mode)

    @property
    @pulumi.getter(name="workloadConfig")
    def workload_config(self) -> Optional[pulumi.Input['WorkloadConfigArgs']]:
        """
        WorkloadConfig defines which actions are enabled for a cluster's workload configurations.
        """
        return pulumi.get(self, "workload_config")

    @workload_config.setter
    def workload_config(self, value: Optional[pulumi.Input['WorkloadConfigArgs']]):
        pulumi.set(self, "workload_config", value)

    @property
    @pulumi.getter(name="workloadVulnerabilityMode")
    def workload_vulnerability_mode(self) -> Optional[pulumi.Input['ProtectConfigWorkloadVulnerabilityMode']]:
        """
        Sets which mode to use for Protect workload vulnerability scanning feature.
        """
        return pulumi.get(self, "workload_vulnerability_mode")

    @workload_vulnerability_mode.setter
    def workload_vulnerability_mode(self, value: Optional[pulumi.Input['ProtectConfigWorkloadVulnerabilityMode']]):
        pulumi.set(self, "workload_vulnerability_mode", value)


@pulumi.input_type
class PubSubArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 filter: Optional[pulumi.Input['FilterArgs']] = None,
                 topic: Optional[pulumi.Input[str]] = None):
        """
        Pub/Sub specific notification config.
        :param pulumi.Input[bool] enabled: Enable notifications for Pub/Sub.
        :param pulumi.Input['FilterArgs'] filter: Allows filtering to one or more specific event types. If no filter is specified, or if a filter is specified with no event types, all event types will be sent
        :param pulumi.Input[str] topic: The desired Pub/Sub topic to which notifications will be sent by GKE. Format is `projects/{project}/topics/{topic}`.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if filter is not None:
            pulumi.set(__self__, "filter", filter)
        if topic is not None:
            pulumi.set(__self__, "topic", topic)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable notifications for Pub/Sub.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter
    def filter(self) -> Optional[pulumi.Input['FilterArgs']]:
        """
        Allows filtering to one or more specific event types. If no filter is specified, or if a filter is specified with no event types, all event types will be sent
        """
        return pulumi.get(self, "filter")

    @filter.setter
    def filter(self, value: Optional[pulumi.Input['FilterArgs']]):
        pulumi.set(self, "filter", value)

    @property
    @pulumi.getter
    def topic(self) -> Optional[pulumi.Input[str]]:
        """
        The desired Pub/Sub topic to which notifications will be sent by GKE. Format is `projects/{project}/topics/{topic}`.
        """
        return pulumi.get(self, "topic")

    @topic.setter
    def topic(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "topic", value)


@pulumi.input_type
class RecurringTimeWindowArgs:
    def __init__(__self__, *,
                 recurrence: Optional[pulumi.Input[str]] = None,
                 window: Optional[pulumi.Input['TimeWindowArgs']] = None):
        """
        Represents an arbitrary window of time that recurs.
        :param pulumi.Input[str] recurrence: An RRULE (https://tools.ietf.org/html/rfc5545#section-3.8.5.3) for how this window reccurs. They go on for the span of time between the start and end time. For example, to have something repeat every weekday, you'd use: `FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR` To repeat some window daily (equivalent to the DailyMaintenanceWindow): `FREQ=DAILY` For the first weekend of every month: `FREQ=MONTHLY;BYSETPOS=1;BYDAY=SA,SU` This specifies how frequently the window starts. Eg, if you wanted to have a 9-5 UTC-4 window every weekday, you'd use something like: ``` start time = 2019-01-01T09:00:00-0400 end time = 2019-01-01T17:00:00-0400 recurrence = FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR ``` Windows can span multiple days. Eg, to make the window encompass every weekend from midnight Saturday till the last minute of Sunday UTC: ``` start time = 2019-01-05T00:00:00Z end time = 2019-01-07T23:59:00Z recurrence = FREQ=WEEKLY;BYDAY=SA ``` Note the start and end time's specific dates are largely arbitrary except to specify duration of the window and when it first starts. The FREQ values of HOURLY, MINUTELY, and SECONDLY are not supported.
        :param pulumi.Input['TimeWindowArgs'] window: The window of the first recurrence.
        """
        if recurrence is not None:
            pulumi.set(__self__, "recurrence", recurrence)
        if window is not None:
            pulumi.set(__self__, "window", window)

    @property
    @pulumi.getter
    def recurrence(self) -> Optional[pulumi.Input[str]]:
        """
        An RRULE (https://tools.ietf.org/html/rfc5545#section-3.8.5.3) for how this window reccurs. They go on for the span of time between the start and end time. For example, to have something repeat every weekday, you'd use: `FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR` To repeat some window daily (equivalent to the DailyMaintenanceWindow): `FREQ=DAILY` For the first weekend of every month: `FREQ=MONTHLY;BYSETPOS=1;BYDAY=SA,SU` This specifies how frequently the window starts. Eg, if you wanted to have a 9-5 UTC-4 window every weekday, you'd use something like: ``` start time = 2019-01-01T09:00:00-0400 end time = 2019-01-01T17:00:00-0400 recurrence = FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR ``` Windows can span multiple days. Eg, to make the window encompass every weekend from midnight Saturday till the last minute of Sunday UTC: ``` start time = 2019-01-05T00:00:00Z end time = 2019-01-07T23:59:00Z recurrence = FREQ=WEEKLY;BYDAY=SA ``` Note the start and end time's specific dates are largely arbitrary except to specify duration of the window and when it first starts. The FREQ values of HOURLY, MINUTELY, and SECONDLY are not supported.
        """
        return pulumi.get(self, "recurrence")

    @recurrence.setter
    def recurrence(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "recurrence", value)

    @property
    @pulumi.getter
    def window(self) -> Optional[pulumi.Input['TimeWindowArgs']]:
        """
        The window of the first recurrence.
        """
        return pulumi.get(self, "window")

    @window.setter
    def window(self, value: Optional[pulumi.Input['TimeWindowArgs']]):
        pulumi.set(self, "window", value)


@pulumi.input_type
class ReleaseChannelArgs:
    def __init__(__self__, *,
                 channel: Optional[pulumi.Input['ReleaseChannelChannel']] = None):
        """
        ReleaseChannel indicates which release channel a cluster is subscribed to. Release channels are arranged in order of risk. When a cluster is subscribed to a release channel, Google maintains both the master version and the node version. Node auto-upgrade defaults to true and cannot be disabled.
        :param pulumi.Input['ReleaseChannelChannel'] channel: channel specifies which release channel the cluster is subscribed to.
        """
        if channel is not None:
            pulumi.set(__self__, "channel", channel)

    @property
    @pulumi.getter
    def channel(self) -> Optional[pulumi.Input['ReleaseChannelChannel']]:
        """
        channel specifies which release channel the cluster is subscribed to.
        """
        return pulumi.get(self, "channel")

    @channel.setter
    def channel(self, value: Optional[pulumi.Input['ReleaseChannelChannel']]):
        pulumi.set(self, "channel", value)


@pulumi.input_type
class ReservationAffinityArgs:
    def __init__(__self__, *,
                 consume_reservation_type: Optional[pulumi.Input['ReservationAffinityConsumeReservationType']] = None,
                 key: Optional[pulumi.Input[str]] = None,
                 values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        [ReservationAffinity](https://cloud.google.com/compute/docs/instances/reserving-zonal-resources) is the configuration of desired reservation which instances could take capacity from.
        :param pulumi.Input['ReservationAffinityConsumeReservationType'] consume_reservation_type: Corresponds to the type of reservation consumption.
        :param pulumi.Input[str] key: Corresponds to the label key of a reservation resource. To target a SPECIFIC_RESERVATION by name, specify "compute.googleapis.com/reservation-name" as the key and specify the name of your reservation as its value.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: Corresponds to the label value(s) of reservation resource(s).
        """
        if consume_reservation_type is not None:
            pulumi.set(__self__, "consume_reservation_type", consume_reservation_type)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter(name="consumeReservationType")
    def consume_reservation_type(self) -> Optional[pulumi.Input['ReservationAffinityConsumeReservationType']]:
        """
        Corresponds to the type of reservation consumption.
        """
        return pulumi.get(self, "consume_reservation_type")

    @consume_reservation_type.setter
    def consume_reservation_type(self, value: Optional[pulumi.Input['ReservationAffinityConsumeReservationType']]):
        pulumi.set(self, "consume_reservation_type", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        """
        Corresponds to the label key of a reservation resource. To target a SPECIFIC_RESERVATION by name, specify "compute.googleapis.com/reservation-name" as the key and specify the name of your reservation as its value.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Corresponds to the label value(s) of reservation resource(s).
        """
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class ResourceLimitArgs:
    def __init__(__self__, *,
                 maximum: Optional[pulumi.Input[str]] = None,
                 minimum: Optional[pulumi.Input[str]] = None,
                 resource_type: Optional[pulumi.Input[str]] = None):
        """
        Contains information about amount of some resource in the cluster. For memory, value should be in GB.
        :param pulumi.Input[str] maximum: Maximum amount of the resource in the cluster.
        :param pulumi.Input[str] minimum: Minimum amount of the resource in the cluster.
        :param pulumi.Input[str] resource_type: Resource name "cpu", "memory" or gpu-specific string.
        """
        if maximum is not None:
            pulumi.set(__self__, "maximum", maximum)
        if minimum is not None:
            pulumi.set(__self__, "minimum", minimum)
        if resource_type is not None:
            pulumi.set(__self__, "resource_type", resource_type)

    @property
    @pulumi.getter
    def maximum(self) -> Optional[pulumi.Input[str]]:
        """
        Maximum amount of the resource in the cluster.
        """
        return pulumi.get(self, "maximum")

    @maximum.setter
    def maximum(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "maximum", value)

    @property
    @pulumi.getter
    def minimum(self) -> Optional[pulumi.Input[str]]:
        """
        Minimum amount of the resource in the cluster.
        """
        return pulumi.get(self, "minimum")

    @minimum.setter
    def minimum(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "minimum", value)

    @property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> Optional[pulumi.Input[str]]:
        """
        Resource name "cpu", "memory" or gpu-specific string.
        """
        return pulumi.get(self, "resource_type")

    @resource_type.setter
    def resource_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resource_type", value)


@pulumi.input_type
class ResourceUsageExportConfigArgs:
    def __init__(__self__, *,
                 bigquery_destination: Optional[pulumi.Input['BigQueryDestinationArgs']] = None,
                 consumption_metering_config: Optional[pulumi.Input['ConsumptionMeteringConfigArgs']] = None,
                 enable_network_egress_metering: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for exporting cluster resource usages.
        :param pulumi.Input['BigQueryDestinationArgs'] bigquery_destination: Configuration to use BigQuery as usage export destination.
        :param pulumi.Input['ConsumptionMeteringConfigArgs'] consumption_metering_config: Configuration to enable resource consumption metering.
        :param pulumi.Input[bool] enable_network_egress_metering: Whether to enable network egress metering for this cluster. If enabled, a daemonset will be created in the cluster to meter network egress traffic.
        """
        if bigquery_destination is not None:
            pulumi.set(__self__, "bigquery_destination", bigquery_destination)
        if consumption_metering_config is not None:
            pulumi.set(__self__, "consumption_metering_config", consumption_metering_config)
        if enable_network_egress_metering is not None:
            pulumi.set(__self__, "enable_network_egress_metering", enable_network_egress_metering)

    @property
    @pulumi.getter(name="bigqueryDestination")
    def bigquery_destination(self) -> Optional[pulumi.Input['BigQueryDestinationArgs']]:
        """
        Configuration to use BigQuery as usage export destination.
        """
        return pulumi.get(self, "bigquery_destination")

    @bigquery_destination.setter
    def bigquery_destination(self, value: Optional[pulumi.Input['BigQueryDestinationArgs']]):
        pulumi.set(self, "bigquery_destination", value)

    @property
    @pulumi.getter(name="consumptionMeteringConfig")
    def consumption_metering_config(self) -> Optional[pulumi.Input['ConsumptionMeteringConfigArgs']]:
        """
        Configuration to enable resource consumption metering.
        """
        return pulumi.get(self, "consumption_metering_config")

    @consumption_metering_config.setter
    def consumption_metering_config(self, value: Optional[pulumi.Input['ConsumptionMeteringConfigArgs']]):
        pulumi.set(self, "consumption_metering_config", value)

    @property
    @pulumi.getter(name="enableNetworkEgressMetering")
    def enable_network_egress_metering(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to enable network egress metering for this cluster. If enabled, a daemonset will be created in the cluster to meter network egress traffic.
        """
        return pulumi.get(self, "enable_network_egress_metering")

    @enable_network_egress_metering.setter
    def enable_network_egress_metering(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_network_egress_metering", value)


@pulumi.input_type
class SandboxConfigArgs:
    def __init__(__self__, *,
                 sandbox_type: Optional[pulumi.Input[str]] = None,
                 type: Optional[pulumi.Input['SandboxConfigType']] = None):
        """
        SandboxConfig contains configurations of the sandbox to use for the node.
        :param pulumi.Input[str] sandbox_type: Type of the sandbox to use for the node (e.g. 'gvisor')
        :param pulumi.Input['SandboxConfigType'] type: Type of the sandbox to use for the node.
        """
        if sandbox_type is not None:
            pulumi.set(__self__, "sandbox_type", sandbox_type)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="sandboxType")
    def sandbox_type(self) -> Optional[pulumi.Input[str]]:
        """
        Type of the sandbox to use for the node (e.g. 'gvisor')
        """
        return pulumi.get(self, "sandbox_type")

    @sandbox_type.setter
    def sandbox_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sandbox_type", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input['SandboxConfigType']]:
        """
        Type of the sandbox to use for the node.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input['SandboxConfigType']]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class ServiceExternalIPsConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Config to block services with externalIPs field.
        :param pulumi.Input[bool] enabled: Whether Services with ExternalIPs field are allowed or not.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether Services with ExternalIPs field are allowed or not.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class ShieldedInstanceConfigArgs:
    def __init__(__self__, *,
                 enable_integrity_monitoring: Optional[pulumi.Input[bool]] = None,
                 enable_secure_boot: Optional[pulumi.Input[bool]] = None):
        """
        A set of Shielded Instance options.
        :param pulumi.Input[bool] enable_integrity_monitoring: Defines whether the instance has integrity monitoring enabled. Enables monitoring and attestation of the boot integrity of the instance. The attestation is performed against the integrity policy baseline. This baseline is initially derived from the implicitly trusted boot image when the instance is created.
        :param pulumi.Input[bool] enable_secure_boot: Defines whether the instance has Secure Boot enabled. Secure Boot helps ensure that the system only runs authentic software by verifying the digital signature of all boot components, and halting the boot process if signature verification fails.
        """
        if enable_integrity_monitoring is not None:
            pulumi.set(__self__, "enable_integrity_monitoring", enable_integrity_monitoring)
        if enable_secure_boot is not None:
            pulumi.set(__self__, "enable_secure_boot", enable_secure_boot)

    @property
    @pulumi.getter(name="enableIntegrityMonitoring")
    def enable_integrity_monitoring(self) -> Optional[pulumi.Input[bool]]:
        """
        Defines whether the instance has integrity monitoring enabled. Enables monitoring and attestation of the boot integrity of the instance. The attestation is performed against the integrity policy baseline. This baseline is initially derived from the implicitly trusted boot image when the instance is created.
        """
        return pulumi.get(self, "enable_integrity_monitoring")

    @enable_integrity_monitoring.setter
    def enable_integrity_monitoring(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_integrity_monitoring", value)

    @property
    @pulumi.getter(name="enableSecureBoot")
    def enable_secure_boot(self) -> Optional[pulumi.Input[bool]]:
        """
        Defines whether the instance has Secure Boot enabled. Secure Boot helps ensure that the system only runs authentic software by verifying the digital signature of all boot components, and halting the boot process if signature verification fails.
        """
        return pulumi.get(self, "enable_secure_boot")

    @enable_secure_boot.setter
    def enable_secure_boot(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_secure_boot", value)


@pulumi.input_type
class ShieldedNodesArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration of Shielded Nodes feature.
        :param pulumi.Input[bool] enabled: Whether Shielded Nodes features are enabled on all nodes in this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether Shielded Nodes features are enabled on all nodes in this cluster.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class StandardRolloutPolicyArgs:
    def __init__(__self__, *,
                 batch_node_count: Optional[pulumi.Input[int]] = None,
                 batch_percentage: Optional[pulumi.Input[float]] = None,
                 batch_soak_duration: Optional[pulumi.Input[str]] = None):
        """
        Standard rollout policy is the default policy for blue-green.
        :param pulumi.Input[int] batch_node_count: Number of blue nodes to drain in a batch.
        :param pulumi.Input[float] batch_percentage: Percentage of the blue pool nodes to drain in a batch. The range of this field should be (0.0, 1.0].
        :param pulumi.Input[str] batch_soak_duration: Soak time after each batch gets drained. Default to zero.
        """
        if batch_node_count is not None:
            pulumi.set(__self__, "batch_node_count", batch_node_count)
        if batch_percentage is not None:
            pulumi.set(__self__, "batch_percentage", batch_percentage)
        if batch_soak_duration is not None:
            pulumi.set(__self__, "batch_soak_duration", batch_soak_duration)

    @property
    @pulumi.getter(name="batchNodeCount")
    def batch_node_count(self) -> Optional[pulumi.Input[int]]:
        """
        Number of blue nodes to drain in a batch.
        """
        return pulumi.get(self, "batch_node_count")

    @batch_node_count.setter
    def batch_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "batch_node_count", value)

    @property
    @pulumi.getter(name="batchPercentage")
    def batch_percentage(self) -> Optional[pulumi.Input[float]]:
        """
        Percentage of the blue pool nodes to drain in a batch. The range of this field should be (0.0, 1.0].
        """
        return pulumi.get(self, "batch_percentage")

    @batch_percentage.setter
    def batch_percentage(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "batch_percentage", value)

    @property
    @pulumi.getter(name="batchSoakDuration")
    def batch_soak_duration(self) -> Optional[pulumi.Input[str]]:
        """
        Soak time after each batch gets drained. Default to zero.
        """
        return pulumi.get(self, "batch_soak_duration")

    @batch_soak_duration.setter
    def batch_soak_duration(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "batch_soak_duration", value)


@pulumi.input_type
class StatusConditionArgs:
    def __init__(__self__, *,
                 canonical_code: Optional[pulumi.Input['StatusConditionCanonicalCode']] = None,
                 code: Optional[pulumi.Input['StatusConditionCode']] = None,
                 message: Optional[pulumi.Input[str]] = None):
        """
        StatusCondition describes why a cluster or a node pool has a certain status (e.g., ERROR or DEGRADED).
        :param pulumi.Input['StatusConditionCanonicalCode'] canonical_code: Canonical code of the condition.
        :param pulumi.Input['StatusConditionCode'] code: Machine-friendly representation of the condition Deprecated. Use canonical_code instead.
        :param pulumi.Input[str] message: Human-friendly representation of the condition
        """
        if canonical_code is not None:
            pulumi.set(__self__, "canonical_code", canonical_code)
        if code is not None:
            warnings.warn("""Machine-friendly representation of the condition Deprecated. Use canonical_code instead.""", DeprecationWarning)
            pulumi.log.warn("""code is deprecated: Machine-friendly representation of the condition Deprecated. Use canonical_code instead.""")
        if code is not None:
            pulumi.set(__self__, "code", code)
        if message is not None:
            pulumi.set(__self__, "message", message)

    @property
    @pulumi.getter(name="canonicalCode")
    def canonical_code(self) -> Optional[pulumi.Input['StatusConditionCanonicalCode']]:
        """
        Canonical code of the condition.
        """
        return pulumi.get(self, "canonical_code")

    @canonical_code.setter
    def canonical_code(self, value: Optional[pulumi.Input['StatusConditionCanonicalCode']]):
        pulumi.set(self, "canonical_code", value)

    @property
    @pulumi.getter
    def code(self) -> Optional[pulumi.Input['StatusConditionCode']]:
        """
        Machine-friendly representation of the condition Deprecated. Use canonical_code instead.
        """
        warnings.warn("""Machine-friendly representation of the condition Deprecated. Use canonical_code instead.""", DeprecationWarning)
        pulumi.log.warn("""code is deprecated: Machine-friendly representation of the condition Deprecated. Use canonical_code instead.""")

        return pulumi.get(self, "code")

    @code.setter
    def code(self, value: Optional[pulumi.Input['StatusConditionCode']]):
        pulumi.set(self, "code", value)

    @property
    @pulumi.getter
    def message(self) -> Optional[pulumi.Input[str]]:
        """
        Human-friendly representation of the condition
        """
        return pulumi.get(self, "message")

    @message.setter
    def message(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "message", value)


@pulumi.input_type
class TimeWindowArgs:
    def __init__(__self__, *,
                 end_time: Optional[pulumi.Input[str]] = None,
                 maintenance_exclusion_options: Optional[pulumi.Input['MaintenanceExclusionOptionsArgs']] = None,
                 start_time: Optional[pulumi.Input[str]] = None):
        """
        Represents an arbitrary window of time.
        :param pulumi.Input[str] end_time: The time that the window ends. The end time should take place after the start time.
        :param pulumi.Input['MaintenanceExclusionOptionsArgs'] maintenance_exclusion_options: MaintenanceExclusionOptions provides maintenance exclusion related options.
        :param pulumi.Input[str] start_time: The time that the window first starts.
        """
        if end_time is not None:
            pulumi.set(__self__, "end_time", end_time)
        if maintenance_exclusion_options is not None:
            pulumi.set(__self__, "maintenance_exclusion_options", maintenance_exclusion_options)
        if start_time is not None:
            pulumi.set(__self__, "start_time", start_time)

    @property
    @pulumi.getter(name="endTime")
    def end_time(self) -> Optional[pulumi.Input[str]]:
        """
        The time that the window ends. The end time should take place after the start time.
        """
        return pulumi.get(self, "end_time")

    @end_time.setter
    def end_time(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "end_time", value)

    @property
    @pulumi.getter(name="maintenanceExclusionOptions")
    def maintenance_exclusion_options(self) -> Optional[pulumi.Input['MaintenanceExclusionOptionsArgs']]:
        """
        MaintenanceExclusionOptions provides maintenance exclusion related options.
        """
        return pulumi.get(self, "maintenance_exclusion_options")

    @maintenance_exclusion_options.setter
    def maintenance_exclusion_options(self, value: Optional[pulumi.Input['MaintenanceExclusionOptionsArgs']]):
        pulumi.set(self, "maintenance_exclusion_options", value)

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> Optional[pulumi.Input[str]]:
        """
        The time that the window first starts.
        """
        return pulumi.get(self, "start_time")

    @start_time.setter
    def start_time(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "start_time", value)


@pulumi.input_type
class TpuConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 ipv4_cidr_block: Optional[pulumi.Input[str]] = None,
                 use_service_networking: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for Cloud TPU.
        :param pulumi.Input[bool] enabled: Whether Cloud TPU integration is enabled or not.
        :param pulumi.Input[str] ipv4_cidr_block: IPv4 CIDR block reserved for Cloud TPU in the VPC.
        :param pulumi.Input[bool] use_service_networking: Whether to use service networking for Cloud TPU or not.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if ipv4_cidr_block is not None:
            pulumi.set(__self__, "ipv4_cidr_block", ipv4_cidr_block)
        if use_service_networking is not None:
            pulumi.set(__self__, "use_service_networking", use_service_networking)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether Cloud TPU integration is enabled or not.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter(name="ipv4CidrBlock")
    def ipv4_cidr_block(self) -> Optional[pulumi.Input[str]]:
        """
        IPv4 CIDR block reserved for Cloud TPU in the VPC.
        """
        return pulumi.get(self, "ipv4_cidr_block")

    @ipv4_cidr_block.setter
    def ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ipv4_cidr_block", value)

    @property
    @pulumi.getter(name="useServiceNetworking")
    def use_service_networking(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to use service networking for Cloud TPU or not.
        """
        return pulumi.get(self, "use_service_networking")

    @use_service_networking.setter
    def use_service_networking(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_service_networking", value)


@pulumi.input_type
class UpgradeSettingsArgs:
    def __init__(__self__, *,
                 blue_green_settings: Optional[pulumi.Input['BlueGreenSettingsArgs']] = None,
                 max_surge: Optional[pulumi.Input[int]] = None,
                 max_unavailable: Optional[pulumi.Input[int]] = None,
                 strategy: Optional[pulumi.Input['UpgradeSettingsStrategy']] = None):
        """
        These upgrade settings configure the upgrade strategy for the node pool. Use strategy to switch between the strategies applied to the node pool. If the strategy is SURGE, use max_surge and max_unavailable to control the level of parallelism and the level of disruption caused by upgrade. 1. maxSurge controls the number of additional nodes that can be added to the node pool temporarily for the time of the upgrade to increase the number of available nodes. 2. maxUnavailable controls the number of nodes that can be simultaneously unavailable. 3. (maxUnavailable + maxSurge) determines the level of parallelism (how many nodes are being upgraded at the same time). If the strategy is BLUE_GREEN, use blue_green_settings to configure the blue-green upgrade related settings. 1. standard_rollout_policy is the default policy. The policy is used to control the way blue pool gets drained. The draining is executed in the batch mode. The batch size could be specified as either percentage of the node pool size or the number of nodes. batch_soak_duration is the soak time after each batch gets drained. 2. node_pool_soak_duration is the soak time after all blue nodes are drained. After this period, the blue pool nodes will be deleted.
        :param pulumi.Input['BlueGreenSettingsArgs'] blue_green_settings: Settings for blue-green upgrade strategy.
        :param pulumi.Input[int] max_surge: The maximum number of nodes that can be created beyond the current size of the node pool during the upgrade process.
        :param pulumi.Input[int] max_unavailable: The maximum number of nodes that can be simultaneously unavailable during the upgrade process. A node is considered available if its status is Ready.
        :param pulumi.Input['UpgradeSettingsStrategy'] strategy: Update strategy of the node pool.
        """
        if blue_green_settings is not None:
            pulumi.set(__self__, "blue_green_settings", blue_green_settings)
        if max_surge is not None:
            pulumi.set(__self__, "max_surge", max_surge)
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)
        if strategy is not None:
            pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter(name="blueGreenSettings")
    def blue_green_settings(self) -> Optional[pulumi.Input['BlueGreenSettingsArgs']]:
        """
        Settings for blue-green upgrade strategy.
        """
        return pulumi.get(self, "blue_green_settings")

    @blue_green_settings.setter
    def blue_green_settings(self, value: Optional[pulumi.Input['BlueGreenSettingsArgs']]):
        pulumi.set(self, "blue_green_settings", value)

    @property
    @pulumi.getter(name="maxSurge")
    def max_surge(self) -> Optional[pulumi.Input[int]]:
        """
        The maximum number of nodes that can be created beyond the current size of the node pool during the upgrade process.
        """
        return pulumi.get(self, "max_surge")

    @max_surge.setter
    def max_surge(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_surge", value)

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[pulumi.Input[int]]:
        """
        The maximum number of nodes that can be simultaneously unavailable during the upgrade process. A node is considered available if its status is Ready.
        """
        return pulumi.get(self, "max_unavailable")

    @max_unavailable.setter
    def max_unavailable(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_unavailable", value)

    @property
    @pulumi.getter
    def strategy(self) -> Optional[pulumi.Input['UpgradeSettingsStrategy']]:
        """
        Update strategy of the node pool.
        """
        return pulumi.get(self, "strategy")

    @strategy.setter
    def strategy(self, value: Optional[pulumi.Input['UpgradeSettingsStrategy']]):
        pulumi.set(self, "strategy", value)


@pulumi.input_type
class VerticalPodAutoscalingArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        VerticalPodAutoscaling contains global, per-cluster information required by Vertical Pod Autoscaler to automatically adjust the resources of pods controlled by it.
        :param pulumi.Input[bool] enabled: Enables vertical pod autoscaling.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enables vertical pod autoscaling.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class VirtualNICArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration of gVNIC feature.
        :param pulumi.Input[bool] enabled: Whether gVNIC features are enabled in the node pool.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether gVNIC features are enabled in the node pool.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class WindowsNodeConfigArgs:
    def __init__(__self__, *,
                 os_version: Optional[pulumi.Input['WindowsNodeConfigOsVersion']] = None):
        """
        Parameters that can be configured on Windows nodes. Windows Node Config that define the parameters that will be used to configure the Windows node pool settings
        :param pulumi.Input['WindowsNodeConfigOsVersion'] os_version: OSVersion specifies the Windows node config to be used on the node
        """
        if os_version is not None:
            pulumi.set(__self__, "os_version", os_version)

    @property
    @pulumi.getter(name="osVersion")
    def os_version(self) -> Optional[pulumi.Input['WindowsNodeConfigOsVersion']]:
        """
        OSVersion specifies the Windows node config to be used on the node
        """
        return pulumi.get(self, "os_version")

    @os_version.setter
    def os_version(self, value: Optional[pulumi.Input['WindowsNodeConfigOsVersion']]):
        pulumi.set(self, "os_version", value)


@pulumi.input_type
class WorkloadALTSConfigArgs:
    def __init__(__self__, *,
                 enable_alts: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for direct-path (via ALTS) with workload identity.
        :param pulumi.Input[bool] enable_alts: enable_alts controls whether the alts handshaker should be enabled or not for direct-path. Requires Workload Identity (workload_pool must be non-empty).
        """
        if enable_alts is not None:
            pulumi.set(__self__, "enable_alts", enable_alts)

    @property
    @pulumi.getter(name="enableAlts")
    def enable_alts(self) -> Optional[pulumi.Input[bool]]:
        """
        enable_alts controls whether the alts handshaker should be enabled or not for direct-path. Requires Workload Identity (workload_pool must be non-empty).
        """
        return pulumi.get(self, "enable_alts")

    @enable_alts.setter
    def enable_alts(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_alts", value)


@pulumi.input_type
class WorkloadCertificatesArgs:
    def __init__(__self__, *,
                 enable_certificates: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for issuance of mTLS keys and certificates to Kubernetes pods.
        :param pulumi.Input[bool] enable_certificates: enable_certificates controls issuance of workload mTLS certificates. If set, the GKE Workload Identity Certificates controller and node agent will be deployed in the cluster, which can then be configured by creating a WorkloadCertificateConfig Custom Resource. Requires Workload Identity (workload_pool must be non-empty).
        """
        if enable_certificates is not None:
            pulumi.set(__self__, "enable_certificates", enable_certificates)

    @property
    @pulumi.getter(name="enableCertificates")
    def enable_certificates(self) -> Optional[pulumi.Input[bool]]:
        """
        enable_certificates controls issuance of workload mTLS certificates. If set, the GKE Workload Identity Certificates controller and node agent will be deployed in the cluster, which can then be configured by creating a WorkloadCertificateConfig Custom Resource. Requires Workload Identity (workload_pool must be non-empty).
        """
        return pulumi.get(self, "enable_certificates")

    @enable_certificates.setter
    def enable_certificates(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_certificates", value)


@pulumi.input_type
class WorkloadConfigArgs:
    def __init__(__self__, *,
                 audit_mode: Optional[pulumi.Input['WorkloadConfigAuditMode']] = None):
        """
        WorkloadConfig defines the flags to enable or disable the workload configurations for the cluster.
        :param pulumi.Input['WorkloadConfigAuditMode'] audit_mode: Sets which mode of auditing should be used for the cluster's workloads.
        """
        if audit_mode is not None:
            pulumi.set(__self__, "audit_mode", audit_mode)

    @property
    @pulumi.getter(name="auditMode")
    def audit_mode(self) -> Optional[pulumi.Input['WorkloadConfigAuditMode']]:
        """
        Sets which mode of auditing should be used for the cluster's workloads.
        """
        return pulumi.get(self, "audit_mode")

    @audit_mode.setter
    def audit_mode(self, value: Optional[pulumi.Input['WorkloadConfigAuditMode']]):
        pulumi.set(self, "audit_mode", value)


@pulumi.input_type
class WorkloadIdentityConfigArgs:
    def __init__(__self__, *,
                 identity_namespace: Optional[pulumi.Input[str]] = None,
                 identity_provider: Optional[pulumi.Input[str]] = None,
                 workload_pool: Optional[pulumi.Input[str]] = None):
        """
        Configuration for the use of Kubernetes Service Accounts in GCP IAM policies.
        :param pulumi.Input[str] identity_namespace: IAM Identity Namespace to attach all Kubernetes Service Accounts to.
        :param pulumi.Input[str] identity_provider: identity provider is the third party identity provider.
        :param pulumi.Input[str] workload_pool: The workload pool to attach all Kubernetes service accounts to.
        """
        if identity_namespace is not None:
            pulumi.set(__self__, "identity_namespace", identity_namespace)
        if identity_provider is not None:
            pulumi.set(__self__, "identity_provider", identity_provider)
        if workload_pool is not None:
            pulumi.set(__self__, "workload_pool", workload_pool)

    @property
    @pulumi.getter(name="identityNamespace")
    def identity_namespace(self) -> Optional[pulumi.Input[str]]:
        """
        IAM Identity Namespace to attach all Kubernetes Service Accounts to.
        """
        return pulumi.get(self, "identity_namespace")

    @identity_namespace.setter
    def identity_namespace(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "identity_namespace", value)

    @property
    @pulumi.getter(name="identityProvider")
    def identity_provider(self) -> Optional[pulumi.Input[str]]:
        """
        identity provider is the third party identity provider.
        """
        return pulumi.get(self, "identity_provider")

    @identity_provider.setter
    def identity_provider(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "identity_provider", value)

    @property
    @pulumi.getter(name="workloadPool")
    def workload_pool(self) -> Optional[pulumi.Input[str]]:
        """
        The workload pool to attach all Kubernetes service accounts to.
        """
        return pulumi.get(self, "workload_pool")

    @workload_pool.setter
    def workload_pool(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "workload_pool", value)


@pulumi.input_type
class WorkloadMetadataConfigArgs:
    def __init__(__self__, *,
                 mode: Optional[pulumi.Input['WorkloadMetadataConfigMode']] = None,
                 node_metadata: Optional[pulumi.Input['WorkloadMetadataConfigNodeMetadata']] = None):
        """
        WorkloadMetadataConfig defines the metadata configuration to expose to workloads on the node pool.
        :param pulumi.Input['WorkloadMetadataConfigMode'] mode: Mode is the configuration for how to expose metadata to workloads running on the node pool.
        :param pulumi.Input['WorkloadMetadataConfigNodeMetadata'] node_metadata: NodeMetadata is the configuration for how to expose metadata to the workloads running on the node.
        """
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if node_metadata is not None:
            pulumi.set(__self__, "node_metadata", node_metadata)

    @property
    @pulumi.getter
    def mode(self) -> Optional[pulumi.Input['WorkloadMetadataConfigMode']]:
        """
        Mode is the configuration for how to expose metadata to workloads running on the node pool.
        """
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: Optional[pulumi.Input['WorkloadMetadataConfigMode']]):
        pulumi.set(self, "mode", value)

    @property
    @pulumi.getter(name="nodeMetadata")
    def node_metadata(self) -> Optional[pulumi.Input['WorkloadMetadataConfigNodeMetadata']]:
        """
        NodeMetadata is the configuration for how to expose metadata to the workloads running on the node.
        """
        return pulumi.get(self, "node_metadata")

    @node_metadata.setter
    def node_metadata(self, value: Optional[pulumi.Input['WorkloadMetadataConfigNodeMetadata']]):
        pulumi.set(self, "node_metadata", value)



9432e0f297a4de0c8b1c4b871883507c67f686a3
<mask token>


@pulumi.input_type
class NodeConfigDefaultsArgs:
    <mask token>
    <mask token>

    @gcfs_config.setter
    def gcfs_config(self, value: Optional[pulumi.Input['GcfsConfigArgs']]):
        pulumi.set(self, 'gcfs_config', value)
    <mask token>

    @logging_config.setter
    def logging_config(self, value: Optional[pulumi.Input[
        'NodePoolLoggingConfigArgs']]):
        pulumi.set(self, 'logging_config', value)


@pulumi.input_type
class NodeConfigArgs:

    def __init__(__self__, *, accelerators: Optional[pulumi.Input[Sequence[
        pulumi.Input['AcceleratorConfigArgs']]]]=None,
        advanced_machine_features: Optional[pulumi.Input[
        'AdvancedMachineFeaturesArgs']]=None, boot_disk_kms_key: Optional[
        pulumi.Input[str]]=None, confidential_nodes: Optional[pulumi.Input[
        'ConfidentialNodesArgs']]=None, disk_size_gb: Optional[pulumi.Input
        [int]]=None, disk_type: Optional[pulumi.Input[str]]=None,
        ephemeral_storage_config: Optional[pulumi.Input[
        'EphemeralStorageConfigArgs']]=None,
        ephemeral_storage_local_ssd_config: Optional[pulumi.Input[
        'EphemeralStorageLocalSsdConfigArgs']]=None, fast_socket: Optional[
        pulumi.Input['FastSocketArgs']]=None, gcfs_config: Optional[pulumi.
        Input['GcfsConfigArgs']]=None, gvnic: Optional[pulumi.Input[
        'VirtualNICArgs']]=None, image_type: Optional[pulumi.Input[str]]=
        None, kubelet_config: Optional[pulumi.Input['NodeKubeletConfigArgs'
        ]]=None, labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[
        str]]]]=None, linux_node_config: Optional[pulumi.Input[
        'LinuxNodeConfigArgs']]=None, local_nvme_ssd_block_config: Optional
        [pulumi.Input['LocalNvmeSsdBlockConfigArgs']]=None, local_ssd_count:
        Optional[pulumi.Input[int]]=None, logging_config: Optional[pulumi.
        Input['NodePoolLoggingConfigArgs']]=None, machine_type: Optional[
        pulumi.Input[str]]=None, metadata: Optional[pulumi.Input[Mapping[
        str, pulumi.Input[str]]]]=None, min_cpu_platform: Optional[pulumi.
        Input[str]]=None, node_group: Optional[pulumi.Input[str]]=None,
        oauth_scopes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=
        None, preemptible: Optional[pulumi.Input[bool]]=None,
        reservation_affinity: Optional[pulumi.Input[
        'ReservationAffinityArgs']]=None, resource_labels: Optional[pulumi.
        Input[Mapping[str, pulumi.Input[str]]]]=None, sandbox_config:
        Optional[pulumi.Input['SandboxConfigArgs']]=None, service_account:
        Optional[pulumi.Input[str]]=None, shielded_instance_config:
        Optional[pulumi.Input['ShieldedInstanceConfigArgs']]=None, spot:
        Optional[pulumi.Input[bool]]=None, tags: Optional[pulumi.Input[
        Sequence[pulumi.Input[str]]]]=None, taints: Optional[pulumi.Input[
        Sequence[pulumi.Input['NodeTaintArgs']]]]=None, windows_node_config:
        Optional[pulumi.Input['WindowsNodeConfigArgs']]=None,
        workload_metadata_config: Optional[pulumi.Input[
        'WorkloadMetadataConfigArgs']]=None):
        """
        Parameters that describe the nodes in a cluster. GKE Autopilot clusters do not recognize parameters in `NodeConfig`. Use AutoprovisioningNodePoolDefaults instead.
        :param pulumi.Input[Sequence[pulumi.Input['AcceleratorConfigArgs']]] accelerators: A list of hardware accelerators to be attached to each node. See https://cloud.google.com/compute/docs/gpus for more information about support for GPUs.
        :param pulumi.Input['AdvancedMachineFeaturesArgs'] advanced_machine_features: Advanced features for the Compute Engine VM.
        :param pulumi.Input[str] boot_disk_kms_key:  The Customer Managed Encryption Key used to encrypt the boot disk attached to each node in the node pool. This should be of the form projects/[KEY_PROJECT_ID]/locations/[LOCATION]/keyRings/[RING_NAME]/cryptoKeys/[KEY_NAME]. For more information about protecting resources with Cloud KMS Keys please see: https://cloud.google.com/compute/docs/disks/customer-managed-encryption
        :param pulumi.Input['ConfidentialNodesArgs'] confidential_nodes: Confidential nodes config. All the nodes in the node pool will be Confidential VM once enabled.
        :param pulumi.Input[int] disk_size_gb: Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB. If unspecified, the default disk size is 100GB.
        :param pulumi.Input[str] disk_type: Type of the disk attached to each node (e.g. 'pd-standard', 'pd-ssd' or 'pd-balanced') If unspecified, the default disk type is 'pd-standard'
        :param pulumi.Input['EphemeralStorageConfigArgs'] ephemeral_storage_config: Parameters for the ephemeral storage filesystem. If unspecified, ephemeral storage is backed by the boot disk.
        :param pulumi.Input['EphemeralStorageLocalSsdConfigArgs'] ephemeral_storage_local_ssd_config: Parameters for the node ephemeral storage using Local SSDs. If unspecified, ephemeral storage is backed by the boot disk. This field is functionally equivalent to the ephemeral_storage_config
        :param pulumi.Input['FastSocketArgs'] fast_socket: Enable or disable NCCL fast socket for the node pool.
        :param pulumi.Input['GcfsConfigArgs'] gcfs_config: GCFS (Google Container File System) configs.
        :param pulumi.Input['VirtualNICArgs'] gvnic: Enable or disable gvnic on the node pool.
        :param pulumi.Input[str] image_type: The image type to use for this node. Note that for a given image type, the latest version of it will be used. Please see https://cloud.google.com/kubernetes-engine/docs/concepts/node-images for available image types.
        :param pulumi.Input['NodeKubeletConfigArgs'] kubelet_config: Node kubelet configs.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: The map of Kubernetes labels (key/value pairs) to be applied to each node. These will added in addition to any default label(s) that Kubernetes may apply to the node. In case of conflict in label keys, the applied set may differ depending on the Kubernetes version -- it's best to assume the behavior is undefined and conflicts should be avoided. For more information, including usage and the valid values, see: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/
        :param pulumi.Input['LinuxNodeConfigArgs'] linux_node_config: Parameters that can be configured on Linux nodes.
        :param pulumi.Input['LocalNvmeSsdBlockConfigArgs'] local_nvme_ssd_block_config: Parameters for using raw-block Local NVMe SSDs.
        :param pulumi.Input[int] local_ssd_count: The number of local SSD disks to be attached to the node. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        :param pulumi.Input['NodePoolLoggingConfigArgs'] logging_config: Logging configuration.
        :param pulumi.Input[str] machine_type: The name of a Google Compute Engine [machine type](https://cloud.google.com/compute/docs/machine-types). If unspecified, the default machine type is `e2-medium`.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] metadata: The metadata key/value pairs assigned to instances in the cluster. Keys must conform to the regexp `[a-zA-Z0-9-_]+` and be less than 128 bytes in length. These are reflected as part of a URL in the metadata server. Additionally, to avoid ambiguity, keys must not conflict with any other metadata keys for the project or be one of the reserved keys: - "cluster-location" - "cluster-name" - "cluster-uid" - "configure-sh" - "containerd-configure-sh" - "enable-oslogin" - "gci-ensure-gke-docker" - "gci-metrics-enabled" - "gci-update-strategy" - "instance-template" - "kube-env" - "startup-script" - "user-data" - "disable-address-manager" - "windows-startup-script-ps1" - "common-psm1" - "k8s-node-setup-psm1" - "install-ssh-psm1" - "user-profile-psm1" Values are free-form strings, and only have meaning as interpreted by the image running in the instance. The only restriction placed on them is that each value's size must be less than or equal to 32 KB. The total size of all keys and values must be less than 512 KB.
        :param pulumi.Input[str] min_cpu_platform: Minimum CPU platform to be used by this instance. The instance may be scheduled on the specified or newer CPU platform. Applicable values are the friendly names of CPU platforms, such as `minCpuPlatform: "Intel Haswell"` or `minCpuPlatform: "Intel Sandy Bridge"`. For more information, read [how to specify min CPU platform](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform).
        :param pulumi.Input[str] node_group: Setting this field will assign instances of this pool to run on the specified node group. This is useful for running workloads on [sole tenant nodes](https://cloud.google.com/compute/docs/nodes/sole-tenant-nodes).
        :param pulumi.Input[Sequence[pulumi.Input[str]]] oauth_scopes: The set of Google API scopes to be made available on all of the node VMs under the "default" service account. The following scopes are recommended, but not required, and by default are not included: * `https://www.googleapis.com/auth/compute` is required for mounting persistent storage on your nodes. * `https://www.googleapis.com/auth/devstorage.read_only` is required for communicating with **gcr.io** (the [Google Container Registry](https://cloud.google.com/container-registry/)). If unspecified, no scopes are added, unless Cloud Logging or Cloud Monitoring are enabled, in which case their required scopes will be added.
        :param pulumi.Input[bool] preemptible: Whether the nodes are created as preemptible VM instances. See: https://cloud.google.com/compute/docs/instances/preemptible for more inforamtion about preemptible VM instances.
        :param pulumi.Input['ReservationAffinityArgs'] reservation_affinity: The optional reservation affinity. Setting this field will apply the specified [Zonal Compute Reservation](https://cloud.google.com/compute/docs/instances/reserving-zonal-resources) to this node pool.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] resource_labels: The resource labels for the node pool to use to annotate any related Google Compute Engine resources.
        :param pulumi.Input['SandboxConfigArgs'] sandbox_config: Sandbox configuration for this node.
        :param pulumi.Input[str] service_account: The Google Cloud Platform Service Account to be used by the node VMs. Specify the email address of the Service Account; otherwise, if no Service Account is specified, the "default" service account is used.
        :param pulumi.Input['ShieldedInstanceConfigArgs'] shielded_instance_config: Shielded Instance options.
        :param pulumi.Input[bool] spot: Spot flag for enabling Spot VM, which is a rebrand of the existing preemptible flag.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: The list of instance tags applied to all nodes. Tags are used to identify valid sources or targets for network firewalls and are specified by the client during cluster or node pool creation. Each tag within the list must comply with RFC1035.
        :param pulumi.Input[Sequence[pulumi.Input['NodeTaintArgs']]] taints: List of kubernetes taints to be applied to each node. For more information, including usage and the valid values, see: https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/
        :param pulumi.Input['WindowsNodeConfigArgs'] windows_node_config: Parameters that can be configured on Windows nodes.
        :param pulumi.Input['WorkloadMetadataConfigArgs'] workload_metadata_config: The workload metadata configuration for this node.
        """
        if accelerators is not None:
            pulumi.set(__self__, 'accelerators', accelerators)
        if advanced_machine_features is not None:
            pulumi.set(__self__, 'advanced_machine_features',
                advanced_machine_features)
        if boot_disk_kms_key is not None:
            pulumi.set(__self__, 'boot_disk_kms_key', boot_disk_kms_key)
        if confidential_nodes is not None:
            pulumi.set(__self__, 'confidential_nodes', confidential_nodes)
        if disk_size_gb is not None:
            pulumi.set(__self__, 'disk_size_gb', disk_size_gb)
        if disk_type is not None:
            pulumi.set(__self__, 'disk_type', disk_type)
        if ephemeral_storage_config is not None:
            pulumi.set(__self__, 'ephemeral_storage_config',
                ephemeral_storage_config)
        if ephemeral_storage_local_ssd_config is not None:
            pulumi.set(__self__, 'ephemeral_storage_local_ssd_config',
                ephemeral_storage_local_ssd_config)
        if fast_socket is not None:
            pulumi.set(__self__, 'fast_socket', fast_socket)
        if gcfs_config is not None:
            pulumi.set(__self__, 'gcfs_config', gcfs_config)
        if gvnic is not None:
            pulumi.set(__self__, 'gvnic', gvnic)
        if image_type is not None:
            pulumi.set(__self__, 'image_type', image_type)
        if kubelet_config is not None:
            pulumi.set(__self__, 'kubelet_config', kubelet_config)
        if labels is not None:
            pulumi.set(__self__, 'labels', labels)
        if linux_node_config is not None:
            pulumi.set(__self__, 'linux_node_config', linux_node_config)
        if local_nvme_ssd_block_config is not None:
            pulumi.set(__self__, 'local_nvme_ssd_block_config',
                local_nvme_ssd_block_config)
        if local_ssd_count is not None:
            pulumi.set(__self__, 'local_ssd_count', local_ssd_count)
        if logging_config is not None:
            pulumi.set(__self__, 'logging_config', logging_config)
        if machine_type is not None:
            pulumi.set(__self__, 'machine_type', machine_type)
        if metadata is not None:
            pulumi.set(__self__, 'metadata', metadata)
        if min_cpu_platform is not None:
            pulumi.set(__self__, 'min_cpu_platform', min_cpu_platform)
        if node_group is not None:
            pulumi.set(__self__, 'node_group', node_group)
        if oauth_scopes is not None:
            pulumi.set(__self__, 'oauth_scopes', oauth_scopes)
        if preemptible is not None:
            pulumi.set(__self__, 'preemptible', preemptible)
        if reservation_affinity is not None:
            pulumi.set(__self__, 'reservation_affinity', reservation_affinity)
        if resource_labels is not None:
            pulumi.set(__self__, 'resource_labels', resource_labels)
        if sandbox_config is not None:
            pulumi.set(__self__, 'sandbox_config', sandbox_config)
        if service_account is not None:
            pulumi.set(__self__, 'service_account', service_account)
        if shielded_instance_config is not None:
            pulumi.set(__self__, 'shielded_instance_config',
                shielded_instance_config)
        if spot is not None:
            pulumi.set(__self__, 'spot', spot)
        if tags is not None:
            pulumi.set(__self__, 'tags', tags)
        if taints is not None:
            pulumi.set(__self__, 'taints', taints)
        if windows_node_config is not None:
            pulumi.set(__self__, 'windows_node_config', windows_node_config)
        if workload_metadata_config is not None:
            pulumi.set(__self__, 'workload_metadata_config',
                workload_metadata_config)

    @property
    @pulumi.getter
    def accelerators(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[
        'AcceleratorConfigArgs']]]]:
        """
        A list of hardware accelerators to be attached to each node. See https://cloud.google.com/compute/docs/gpus for more information about support for GPUs.
        """
        return pulumi.get(self, 'accelerators')

    @accelerators.setter
    def accelerators(self, value: Optional[pulumi.Input[Sequence[pulumi.
        Input['AcceleratorConfigArgs']]]]):
        pulumi.set(self, 'accelerators', value)

    @property
    @pulumi.getter(name='advancedMachineFeatures')
    def advanced_machine_features(self) ->Optional[pulumi.Input[
        'AdvancedMachineFeaturesArgs']]:
        """
        Advanced features for the Compute Engine VM.
        """
        return pulumi.get(self, 'advanced_machine_features')

    @advanced_machine_features.setter
    def advanced_machine_features(self, value: Optional[pulumi.Input[
        'AdvancedMachineFeaturesArgs']]):
        pulumi.set(self, 'advanced_machine_features', value)

    @property
    @pulumi.getter(name='bootDiskKmsKey')
    def boot_disk_kms_key(self) ->Optional[pulumi.Input[str]]:
        """
         The Customer Managed Encryption Key used to encrypt the boot disk attached to each node in the node pool. This should be of the form projects/[KEY_PROJECT_ID]/locations/[LOCATION]/keyRings/[RING_NAME]/cryptoKeys/[KEY_NAME]. For more information about protecting resources with Cloud KMS Keys please see: https://cloud.google.com/compute/docs/disks/customer-managed-encryption
        """
        return pulumi.get(self, 'boot_disk_kms_key')

    @boot_disk_kms_key.setter
    def boot_disk_kms_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'boot_disk_kms_key', value)

    @property
    @pulumi.getter(name='confidentialNodes')
    def confidential_nodes(self) ->Optional[pulumi.Input[
        'ConfidentialNodesArgs']]:
        """
        Confidential nodes config. All the nodes in the node pool will be Confidential VM once enabled.
        """
        return pulumi.get(self, 'confidential_nodes')

    @confidential_nodes.setter
    def confidential_nodes(self, value: Optional[pulumi.Input[
        'ConfidentialNodesArgs']]):
        pulumi.set(self, 'confidential_nodes', value)

    @property
    @pulumi.getter(name='diskSizeGb')
    def disk_size_gb(self) ->Optional[pulumi.Input[int]]:
        """
        Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB. If unspecified, the default disk size is 100GB.
        """
        return pulumi.get(self, 'disk_size_gb')

    @disk_size_gb.setter
    def disk_size_gb(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'disk_size_gb', value)

    @property
    @pulumi.getter(name='diskType')
    def disk_type(self) ->Optional[pulumi.Input[str]]:
        """
        Type of the disk attached to each node (e.g. 'pd-standard', 'pd-ssd' or 'pd-balanced') If unspecified, the default disk type is 'pd-standard'
        """
        return pulumi.get(self, 'disk_type')

    @disk_type.setter
    def disk_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'disk_type', value)

    @property
    @pulumi.getter(name='ephemeralStorageConfig')
    def ephemeral_storage_config(self) ->Optional[pulumi.Input[
        'EphemeralStorageConfigArgs']]:
        """
        Parameters for the ephemeral storage filesystem. If unspecified, ephemeral storage is backed by the boot disk.
        """
        return pulumi.get(self, 'ephemeral_storage_config')

    @ephemeral_storage_config.setter
    def ephemeral_storage_config(self, value: Optional[pulumi.Input[
        'EphemeralStorageConfigArgs']]):
        pulumi.set(self, 'ephemeral_storage_config', value)

    @property
    @pulumi.getter(name='ephemeralStorageLocalSsdConfig')
    def ephemeral_storage_local_ssd_config(self) ->Optional[pulumi.Input[
        'EphemeralStorageLocalSsdConfigArgs']]:
        """
        Parameters for the node ephemeral storage using Local SSDs. If unspecified, ephemeral storage is backed by the boot disk. This field is functionally equivalent to the ephemeral_storage_config
        """
        return pulumi.get(self, 'ephemeral_storage_local_ssd_config')

    @ephemeral_storage_local_ssd_config.setter
    def ephemeral_storage_local_ssd_config(self, value: Optional[pulumi.
        Input['EphemeralStorageLocalSsdConfigArgs']]):
        pulumi.set(self, 'ephemeral_storage_local_ssd_config', value)

    @property
    @pulumi.getter(name='fastSocket')
    def fast_socket(self) ->Optional[pulumi.Input['FastSocketArgs']]:
        """
        Enable or disable NCCL fast socket for the node pool.
        """
        return pulumi.get(self, 'fast_socket')

    @fast_socket.setter
    def fast_socket(self, value: Optional[pulumi.Input['FastSocketArgs']]):
        pulumi.set(self, 'fast_socket', value)

    @property
    @pulumi.getter(name='gcfsConfig')
    def gcfs_config(self) ->Optional[pulumi.Input['GcfsConfigArgs']]:
        """
        GCFS (Google Container File System) configs.
        """
        return pulumi.get(self, 'gcfs_config')

    @gcfs_config.setter
    def gcfs_config(self, value: Optional[pulumi.Input['GcfsConfigArgs']]):
        pulumi.set(self, 'gcfs_config', value)

    @property
    @pulumi.getter
    def gvnic(self) ->Optional[pulumi.Input['VirtualNICArgs']]:
        """
        Enable or disable gvnic on the node pool.
        """
        return pulumi.get(self, 'gvnic')

    @gvnic.setter
    def gvnic(self, value: Optional[pulumi.Input['VirtualNICArgs']]):
        pulumi.set(self, 'gvnic', value)

    @property
    @pulumi.getter(name='imageType')
    def image_type(self) ->Optional[pulumi.Input[str]]:
        """
        The image type to use for this node. Note that for a given image type, the latest version of it will be used. Please see https://cloud.google.com/kubernetes-engine/docs/concepts/node-images for available image types.
        """
        return pulumi.get(self, 'image_type')

    @image_type.setter
    def image_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'image_type', value)

    @property
    @pulumi.getter(name='kubeletConfig')
    def kubelet_config(self) ->Optional[pulumi.Input['NodeKubeletConfigArgs']]:
        """
        Node kubelet configs.
        """
        return pulumi.get(self, 'kubelet_config')

    @kubelet_config.setter
    def kubelet_config(self, value: Optional[pulumi.Input[
        'NodeKubeletConfigArgs']]):
        pulumi.set(self, 'kubelet_config', value)

    @property
    @pulumi.getter
    def labels(self) ->Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        The map of Kubernetes labels (key/value pairs) to be applied to each node. These will added in addition to any default label(s) that Kubernetes may apply to the node. In case of conflict in label keys, the applied set may differ depending on the Kubernetes version -- it's best to assume the behavior is undefined and conflicts should be avoided. For more information, including usage and the valid values, see: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/
        """
        return pulumi.get(self, 'labels')

    @labels.setter
    def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input
        [str]]]]):
        pulumi.set(self, 'labels', value)

    @property
    @pulumi.getter(name='linuxNodeConfig')
    def linux_node_config(self) ->Optional[pulumi.Input['LinuxNodeConfigArgs']
        ]:
        """
        Parameters that can be configured on Linux nodes.
        """
        return pulumi.get(self, 'linux_node_config')

    @linux_node_config.setter
    def linux_node_config(self, value: Optional[pulumi.Input[
        'LinuxNodeConfigArgs']]):
        pulumi.set(self, 'linux_node_config', value)

    @property
    @pulumi.getter(name='localNvmeSsdBlockConfig')
    def local_nvme_ssd_block_config(self) ->Optional[pulumi.Input[
        'LocalNvmeSsdBlockConfigArgs']]:
        """
        Parameters for using raw-block Local NVMe SSDs.
        """
        return pulumi.get(self, 'local_nvme_ssd_block_config')

    @local_nvme_ssd_block_config.setter
    def local_nvme_ssd_block_config(self, value: Optional[pulumi.Input[
        'LocalNvmeSsdBlockConfigArgs']]):
        pulumi.set(self, 'local_nvme_ssd_block_config', value)

    @property
    @pulumi.getter(name='localSsdCount')
    def local_ssd_count(self) ->Optional[pulumi.Input[int]]:
        """
        The number of local SSD disks to be attached to the node. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        """
        return pulumi.get(self, 'local_ssd_count')

    @local_ssd_count.setter
    def local_ssd_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'local_ssd_count', value)

    @property
    @pulumi.getter(name='loggingConfig')
    def logging_config(self) ->Optional[pulumi.Input[
        'NodePoolLoggingConfigArgs']]:
        """
        Logging configuration.
        """
        return pulumi.get(self, 'logging_config')

    @logging_config.setter
    def logging_config(self, value: Optional[pulumi.Input[
        'NodePoolLoggingConfigArgs']]):
        pulumi.set(self, 'logging_config', value)

    @property
    @pulumi.getter(name='machineType')
    def machine_type(self) ->Optional[pulumi.Input[str]]:
        """
        The name of a Google Compute Engine [machine type](https://cloud.google.com/compute/docs/machine-types). If unspecified, the default machine type is `e2-medium`.
        """
        return pulumi.get(self, 'machine_type')

    @machine_type.setter
    def machine_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'machine_type', value)

    @property
    @pulumi.getter
    def metadata(self) ->Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]
        ]:
        """
        The metadata key/value pairs assigned to instances in the cluster. Keys must conform to the regexp `[a-zA-Z0-9-_]+` and be less than 128 bytes in length. These are reflected as part of a URL in the metadata server. Additionally, to avoid ambiguity, keys must not conflict with any other metadata keys for the project or be one of the reserved keys: - "cluster-location" - "cluster-name" - "cluster-uid" - "configure-sh" - "containerd-configure-sh" - "enable-oslogin" - "gci-ensure-gke-docker" - "gci-metrics-enabled" - "gci-update-strategy" - "instance-template" - "kube-env" - "startup-script" - "user-data" - "disable-address-manager" - "windows-startup-script-ps1" - "common-psm1" - "k8s-node-setup-psm1" - "install-ssh-psm1" - "user-profile-psm1" Values are free-form strings, and only have meaning as interpreted by the image running in the instance. The only restriction placed on them is that each value's size must be less than or equal to 32 KB. The total size of all keys and values must be less than 512 KB.
        """
        return pulumi.get(self, 'metadata')

    @metadata.setter
    def metadata(self, value: Optional[pulumi.Input[Mapping[str, pulumi.
        Input[str]]]]):
        pulumi.set(self, 'metadata', value)

    @property
    @pulumi.getter(name='minCpuPlatform')
    def min_cpu_platform(self) ->Optional[pulumi.Input[str]]:
        """
        Minimum CPU platform to be used by this instance. The instance may be scheduled on the specified or newer CPU platform. Applicable values are the friendly names of CPU platforms, such as `minCpuPlatform: "Intel Haswell"` or `minCpuPlatform: "Intel Sandy Bridge"`. For more information, read [how to specify min CPU platform](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform).
        """
        return pulumi.get(self, 'min_cpu_platform')

    @min_cpu_platform.setter
    def min_cpu_platform(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'min_cpu_platform', value)

    @property
    @pulumi.getter(name='nodeGroup')
    def node_group(self) ->Optional[pulumi.Input[str]]:
        """
        Setting this field will assign instances of this pool to run on the specified node group. This is useful for running workloads on [sole tenant nodes](https://cloud.google.com/compute/docs/nodes/sole-tenant-nodes).
        """
        return pulumi.get(self, 'node_group')

    @node_group.setter
    def node_group(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'node_group', value)

    @property
    @pulumi.getter(name='oauthScopes')
    def oauth_scopes(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[str]]]
        ]:
        """
        The set of Google API scopes to be made available on all of the node VMs under the "default" service account. The following scopes are recommended, but not required, and by default are not included: * `https://www.googleapis.com/auth/compute` is required for mounting persistent storage on your nodes. * `https://www.googleapis.com/auth/devstorage.read_only` is required for communicating with **gcr.io** (the [Google Container Registry](https://cloud.google.com/container-registry/)). If unspecified, no scopes are added, unless Cloud Logging or Cloud Monitoring are enabled, in which case their required scopes will be added.
        """
        return pulumi.get(self, 'oauth_scopes')

    @oauth_scopes.setter
    def oauth_scopes(self, value: Optional[pulumi.Input[Sequence[pulumi.
        Input[str]]]]):
        pulumi.set(self, 'oauth_scopes', value)

    @property
    @pulumi.getter
    def preemptible(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the nodes are created as preemptible VM instances. See: https://cloud.google.com/compute/docs/instances/preemptible for more inforamtion about preemptible VM instances.
        """
        return pulumi.get(self, 'preemptible')

    @preemptible.setter
    def preemptible(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'preemptible', value)

    @property
    @pulumi.getter(name='reservationAffinity')
    def reservation_affinity(self) ->Optional[pulumi.Input[
        'ReservationAffinityArgs']]:
        """
        The optional reservation affinity. Setting this field will apply the specified [Zonal Compute Reservation](https://cloud.google.com/compute/docs/instances/reserving-zonal-resources) to this node pool.
        """
        return pulumi.get(self, 'reservation_affinity')

    @reservation_affinity.setter
    def reservation_affinity(self, value: Optional[pulumi.Input[
        'ReservationAffinityArgs']]):
        pulumi.set(self, 'reservation_affinity', value)

    @property
    @pulumi.getter(name='resourceLabels')
    def resource_labels(self) ->Optional[pulumi.Input[Mapping[str, pulumi.
        Input[str]]]]:
        """
        The resource labels for the node pool to use to annotate any related Google Compute Engine resources.
        """
        return pulumi.get(self, 'resource_labels')

    @resource_labels.setter
    def resource_labels(self, value: Optional[pulumi.Input[Mapping[str,
        pulumi.Input[str]]]]):
        pulumi.set(self, 'resource_labels', value)

    @property
    @pulumi.getter(name='sandboxConfig')
    def sandbox_config(self) ->Optional[pulumi.Input['SandboxConfigArgs']]:
        """
        Sandbox configuration for this node.
        """
        return pulumi.get(self, 'sandbox_config')

    @sandbox_config.setter
    def sandbox_config(self, value: Optional[pulumi.Input['SandboxConfigArgs']]
        ):
        pulumi.set(self, 'sandbox_config', value)

    @property
    @pulumi.getter(name='serviceAccount')
    def service_account(self) ->Optional[pulumi.Input[str]]:
        """
        The Google Cloud Platform Service Account to be used by the node VMs. Specify the email address of the Service Account; otherwise, if no Service Account is specified, the "default" service account is used.
        """
        return pulumi.get(self, 'service_account')

    @service_account.setter
    def service_account(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'service_account', value)

    @property
    @pulumi.getter(name='shieldedInstanceConfig')
    def shielded_instance_config(self) ->Optional[pulumi.Input[
        'ShieldedInstanceConfigArgs']]:
        """
        Shielded Instance options.
        """
        return pulumi.get(self, 'shielded_instance_config')

    @shielded_instance_config.setter
    def shielded_instance_config(self, value: Optional[pulumi.Input[
        'ShieldedInstanceConfigArgs']]):
        pulumi.set(self, 'shielded_instance_config', value)

    @property
    @pulumi.getter
    def spot(self) ->Optional[pulumi.Input[bool]]:
        """
        Spot flag for enabling Spot VM, which is a rebrand of the existing preemptible flag.
        """
        return pulumi.get(self, 'spot')

    @spot.setter
    def spot(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'spot', value)

    @property
    @pulumi.getter
    def tags(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The list of instance tags applied to all nodes. Tags are used to identify valid sources or targets for network firewalls and are specified by the client during cluster or node pool creation. Each tag within the list must comply with RFC1035.
        """
        return pulumi.get(self, 'tags')

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, 'tags', value)

    @property
    @pulumi.getter
    def taints(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[
        'NodeTaintArgs']]]]:
        """
        List of kubernetes taints to be applied to each node. For more information, including usage and the valid values, see: https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/
        """
        return pulumi.get(self, 'taints')

    @taints.setter
    def taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
        'NodeTaintArgs']]]]):
        pulumi.set(self, 'taints', value)

    @property
    @pulumi.getter(name='windowsNodeConfig')
    def windows_node_config(self) ->Optional[pulumi.Input[
        'WindowsNodeConfigArgs']]:
        """
        Parameters that can be configured on Windows nodes.
        """
        return pulumi.get(self, 'windows_node_config')

    @windows_node_config.setter
    def windows_node_config(self, value: Optional[pulumi.Input[
        'WindowsNodeConfigArgs']]):
        pulumi.set(self, 'windows_node_config', value)

    @property
    @pulumi.getter(name='workloadMetadataConfig')
    def workload_metadata_config(self) ->Optional[pulumi.Input[
        'WorkloadMetadataConfigArgs']]:
        """
        The workload metadata configuration for this node.
        """
        return pulumi.get(self, 'workload_metadata_config')

    @workload_metadata_config.setter
    def workload_metadata_config(self, value: Optional[pulumi.Input[
        'WorkloadMetadataConfigArgs']]):
        pulumi.set(self, 'workload_metadata_config', value)


@pulumi.input_type
class NodeKubeletConfigArgs:

    def __init__(__self__, *, cpu_cfs_quota: Optional[pulumi.Input[bool]]=
        None, cpu_cfs_quota_period: Optional[pulumi.Input[str]]=None,
        cpu_manager_policy: Optional[pulumi.Input[str]]=None,
        pod_pids_limit: Optional[pulumi.Input[str]]=None):
        """
        Node kubelet configs.
        :param pulumi.Input[bool] cpu_cfs_quota: Enable CPU CFS quota enforcement for containers that specify CPU limits. This option is enabled by default which makes kubelet use CFS quota (https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt) to enforce container CPU limits. Otherwise, CPU limits will not be enforced at all. Disable this option to mitigate CPU throttling problems while still having your pods to be in Guaranteed QoS class by specifying the CPU limits. The default value is 'true' if unspecified.
        :param pulumi.Input[str] cpu_cfs_quota_period: Set the CPU CFS quota period value 'cpu.cfs_period_us'. The string must be a sequence of decimal numbers, each with optional fraction and a unit suffix, such as "300ms". Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h". The value must be a positive duration.
        :param pulumi.Input[str] cpu_manager_policy: Control the CPU management policy on the node. See https://kubernetes.io/docs/tasks/administer-cluster/cpu-management-policies/ The following values are allowed. * "none": the default, which represents the existing scheduling behavior. * "static": allows pods with certain resource characteristics to be granted increased CPU affinity and exclusivity on the node. The default value is 'none' if unspecified.
        :param pulumi.Input[str] pod_pids_limit: Set the Pod PID limits. See https://kubernetes.io/docs/concepts/policy/pid-limiting/#pod-pid-limits Controls the maximum number of processes allowed to run in a pod. The value must be greater than or equal to 1024 and less than 4194304.
        """
        if cpu_cfs_quota is not None:
            pulumi.set(__self__, 'cpu_cfs_quota', cpu_cfs_quota)
        if cpu_cfs_quota_period is not None:
            pulumi.set(__self__, 'cpu_cfs_quota_period', cpu_cfs_quota_period)
        if cpu_manager_policy is not None:
            pulumi.set(__self__, 'cpu_manager_policy', cpu_manager_policy)
        if pod_pids_limit is not None:
            pulumi.set(__self__, 'pod_pids_limit', pod_pids_limit)

    @property
    @pulumi.getter(name='cpuCfsQuota')
    def cpu_cfs_quota(self) ->Optional[pulumi.Input[bool]]:
        """
        Enable CPU CFS quota enforcement for containers that specify CPU limits. This option is enabled by default which makes kubelet use CFS quota (https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt) to enforce container CPU limits. Otherwise, CPU limits will not be enforced at all. Disable this option to mitigate CPU throttling problems while still having your pods to be in Guaranteed QoS class by specifying the CPU limits. The default value is 'true' if unspecified.
        """
        return pulumi.get(self, 'cpu_cfs_quota')

    @cpu_cfs_quota.setter
    def cpu_cfs_quota(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'cpu_cfs_quota', value)

    @property
    @pulumi.getter(name='cpuCfsQuotaPeriod')
    def cpu_cfs_quota_period(self) ->Optional[pulumi.Input[str]]:
        """
        Set the CPU CFS quota period value 'cpu.cfs_period_us'. The string must be a sequence of decimal numbers, each with optional fraction and a unit suffix, such as "300ms". Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h". The value must be a positive duration.
        """
        return pulumi.get(self, 'cpu_cfs_quota_period')

    @cpu_cfs_quota_period.setter
    def cpu_cfs_quota_period(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'cpu_cfs_quota_period', value)

    @property
    @pulumi.getter(name='cpuManagerPolicy')
    def cpu_manager_policy(self) ->Optional[pulumi.Input[str]]:
        """
        Control the CPU management policy on the node. See https://kubernetes.io/docs/tasks/administer-cluster/cpu-management-policies/ The following values are allowed. * "none": the default, which represents the existing scheduling behavior. * "static": allows pods with certain resource characteristics to be granted increased CPU affinity and exclusivity on the node. The default value is 'none' if unspecified.
        """
        return pulumi.get(self, 'cpu_manager_policy')

    @cpu_manager_policy.setter
    def cpu_manager_policy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'cpu_manager_policy', value)

    @property
    @pulumi.getter(name='podPidsLimit')
    def pod_pids_limit(self) ->Optional[pulumi.Input[str]]:
        """
        Set the Pod PID limits. See https://kubernetes.io/docs/concepts/policy/pid-limiting/#pod-pid-limits Controls the maximum number of processes allowed to run in a pod. The value must be greater than or equal to 1024 and less than 4194304.
        """
        return pulumi.get(self, 'pod_pids_limit')

    @pod_pids_limit.setter
    def pod_pids_limit(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'pod_pids_limit', value)


@pulumi.input_type
class NodeManagementArgs:

    def __init__(__self__, *, auto_repair: Optional[pulumi.Input[bool]]=
        None, auto_upgrade: Optional[pulumi.Input[bool]]=None,
        upgrade_options: Optional[pulumi.Input['AutoUpgradeOptionsArgs']]=None
        ):
        """
        NodeManagement defines the set of node management services turned on for the node pool.
        :param pulumi.Input[bool] auto_repair: Whether the nodes will be automatically repaired.
        :param pulumi.Input[bool] auto_upgrade: Whether the nodes will be automatically upgraded.
        :param pulumi.Input['AutoUpgradeOptionsArgs'] upgrade_options: Specifies the Auto Upgrade knobs for the node pool.
        """
        if auto_repair is not None:
            pulumi.set(__self__, 'auto_repair', auto_repair)
        if auto_upgrade is not None:
            pulumi.set(__self__, 'auto_upgrade', auto_upgrade)
        if upgrade_options is not None:
            pulumi.set(__self__, 'upgrade_options', upgrade_options)

    @property
    @pulumi.getter(name='autoRepair')
    def auto_repair(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the nodes will be automatically repaired.
        """
        return pulumi.get(self, 'auto_repair')

    @auto_repair.setter
    def auto_repair(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'auto_repair', value)

    @property
    @pulumi.getter(name='autoUpgrade')
    def auto_upgrade(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the nodes will be automatically upgraded.
        """
        return pulumi.get(self, 'auto_upgrade')

    @auto_upgrade.setter
    def auto_upgrade(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'auto_upgrade', value)

    @property
    @pulumi.getter(name='upgradeOptions')
    def upgrade_options(self) ->Optional[pulumi.Input['AutoUpgradeOptionsArgs']
        ]:
        """
        Specifies the Auto Upgrade knobs for the node pool.
        """
        return pulumi.get(self, 'upgrade_options')

    @upgrade_options.setter
    def upgrade_options(self, value: Optional[pulumi.Input[
        'AutoUpgradeOptionsArgs']]):
        pulumi.set(self, 'upgrade_options', value)


@pulumi.input_type
class NodeNetworkConfigArgs:

    def __init__(__self__, *, create_pod_range: Optional[pulumi.Input[bool]
        ]=None, enable_private_nodes: Optional[pulumi.Input[bool]]=None,
        network_performance_config: Optional[pulumi.Input[
        'NetworkPerformanceConfigArgs']]=None,
        pod_cidr_overprovision_config: Optional[pulumi.Input[
        'PodCIDROverprovisionConfigArgs']]=None, pod_ipv4_cidr_block:
        Optional[pulumi.Input[str]]=None, pod_range: Optional[pulumi.Input[
        str]]=None):
        """
        Parameters for node pool-level network config.
        :param pulumi.Input[bool] create_pod_range: Input only. Whether to create a new range for pod IPs in this node pool. Defaults are provided for `pod_range` and `pod_ipv4_cidr_block` if they are not specified. If neither `create_pod_range` or `pod_range` are specified, the cluster-level default (`ip_allocation_policy.cluster_ipv4_cidr_block`) is used. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        :param pulumi.Input[bool] enable_private_nodes: Whether nodes have internal IP addresses only. If enable_private_nodes is not specified, then the value is derived from cluster.privateClusterConfig.enablePrivateNodes
        :param pulumi.Input['NetworkPerformanceConfigArgs'] network_performance_config: Network bandwidth tier configuration.
        :param pulumi.Input['PodCIDROverprovisionConfigArgs'] pod_cidr_overprovision_config: [PRIVATE FIELD] Pod CIDR size overprovisioning config for the nodepool. Pod CIDR size per node depends on max_pods_per_node. By default, the value of max_pods_per_node is rounded off to next power of 2 and we then double that to get the size of pod CIDR block per node. Example: max_pods_per_node of 30 would result in 64 IPs (/26). This config can disable the doubling of IPs (we still round off to next power of 2) Example: max_pods_per_node of 30 will result in 32 IPs (/27) when overprovisioning is disabled.
        :param pulumi.Input[str] pod_ipv4_cidr_block: The IP address range for pod IPs in this node pool. Only applicable if `create_pod_range` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) to pick a specific range to use. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        :param pulumi.Input[str] pod_range: The ID of the secondary range for pod IPs. If `create_pod_range` is true, this ID is used for the new range. If `create_pod_range` is false, uses an existing secondary range with this ID. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        """
        if create_pod_range is not None:
            pulumi.set(__self__, 'create_pod_range', create_pod_range)
        if enable_private_nodes is not None:
            pulumi.set(__self__, 'enable_private_nodes', enable_private_nodes)
        if network_performance_config is not None:
            pulumi.set(__self__, 'network_performance_config',
                network_performance_config)
        if pod_cidr_overprovision_config is not None:
            pulumi.set(__self__, 'pod_cidr_overprovision_config',
                pod_cidr_overprovision_config)
        if pod_ipv4_cidr_block is not None:
            pulumi.set(__self__, 'pod_ipv4_cidr_block', pod_ipv4_cidr_block)
        if pod_range is not None:
            pulumi.set(__self__, 'pod_range', pod_range)

    @property
    @pulumi.getter(name='createPodRange')
    def create_pod_range(self) ->Optional[pulumi.Input[bool]]:
        """
        Input only. Whether to create a new range for pod IPs in this node pool. Defaults are provided for `pod_range` and `pod_ipv4_cidr_block` if they are not specified. If neither `create_pod_range` or `pod_range` are specified, the cluster-level default (`ip_allocation_policy.cluster_ipv4_cidr_block`) is used. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        """
        return pulumi.get(self, 'create_pod_range')

    @create_pod_range.setter
    def create_pod_range(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'create_pod_range', value)

    @property
    @pulumi.getter(name='enablePrivateNodes')
    def enable_private_nodes(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether nodes have internal IP addresses only. If enable_private_nodes is not specified, then the value is derived from cluster.privateClusterConfig.enablePrivateNodes
        """
        return pulumi.get(self, 'enable_private_nodes')

    @enable_private_nodes.setter
    def enable_private_nodes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_private_nodes', value)

    @property
    @pulumi.getter(name='networkPerformanceConfig')
    def network_performance_config(self) ->Optional[pulumi.Input[
        'NetworkPerformanceConfigArgs']]:
        """
        Network bandwidth tier configuration.
        """
        return pulumi.get(self, 'network_performance_config')

    @network_performance_config.setter
    def network_performance_config(self, value: Optional[pulumi.Input[
        'NetworkPerformanceConfigArgs']]):
        pulumi.set(self, 'network_performance_config', value)

    @property
    @pulumi.getter(name='podCidrOverprovisionConfig')
    def pod_cidr_overprovision_config(self) ->Optional[pulumi.Input[
        'PodCIDROverprovisionConfigArgs']]:
        """
        [PRIVATE FIELD] Pod CIDR size overprovisioning config for the nodepool. Pod CIDR size per node depends on max_pods_per_node. By default, the value of max_pods_per_node is rounded off to next power of 2 and we then double that to get the size of pod CIDR block per node. Example: max_pods_per_node of 30 would result in 64 IPs (/26). This config can disable the doubling of IPs (we still round off to next power of 2) Example: max_pods_per_node of 30 will result in 32 IPs (/27) when overprovisioning is disabled.
        """
        return pulumi.get(self, 'pod_cidr_overprovision_config')

    @pod_cidr_overprovision_config.setter
    def pod_cidr_overprovision_config(self, value: Optional[pulumi.Input[
        'PodCIDROverprovisionConfigArgs']]):
        pulumi.set(self, 'pod_cidr_overprovision_config', value)

    @property
    @pulumi.getter(name='podIpv4CidrBlock')
    def pod_ipv4_cidr_block(self) ->Optional[pulumi.Input[str]]:
        """
        The IP address range for pod IPs in this node pool. Only applicable if `create_pod_range` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) to pick a specific range to use. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        """
        return pulumi.get(self, 'pod_ipv4_cidr_block')

    @pod_ipv4_cidr_block.setter
    def pod_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'pod_ipv4_cidr_block', value)

    @property
    @pulumi.getter(name='podRange')
    def pod_range(self) ->Optional[pulumi.Input[str]]:
        """
        The ID of the secondary range for pod IPs. If `create_pod_range` is true, this ID is used for the new range. If `create_pod_range` is false, uses an existing secondary range with this ID. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        """
        return pulumi.get(self, 'pod_range')

    @pod_range.setter
    def pod_range(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'pod_range', value)


@pulumi.input_type
class NodePoolAutoConfigArgs:

    def __init__(__self__, *, network_tags: Optional[pulumi.Input[
        'NetworkTagsArgs']]=None):
        """
        node pool configs that apply to all auto-provisioned node pools in autopilot clusters and node auto-provisioning enabled clusters
        :param pulumi.Input['NetworkTagsArgs'] network_tags: The list of instance tags applied to all nodes. Tags are used to identify valid sources or targets for network firewalls and are specified by the client during cluster creation. Each tag within the list must comply with RFC1035.
        """
        if network_tags is not None:
            pulumi.set(__self__, 'network_tags', network_tags)

    @property
    @pulumi.getter(name='networkTags')
    def network_tags(self) ->Optional[pulumi.Input['NetworkTagsArgs']]:
        """
        The list of instance tags applied to all nodes. Tags are used to identify valid sources or targets for network firewalls and are specified by the client during cluster creation. Each tag within the list must comply with RFC1035.
        """
        return pulumi.get(self, 'network_tags')

    @network_tags.setter
    def network_tags(self, value: Optional[pulumi.Input['NetworkTagsArgs']]):
        pulumi.set(self, 'network_tags', value)


@pulumi.input_type
class NodePoolAutoscalingArgs:

    def __init__(__self__, *, autoprovisioned: Optional[pulumi.Input[bool]]
        =None, enabled: Optional[pulumi.Input[bool]]=None, location_policy:
        Optional[pulumi.Input['NodePoolAutoscalingLocationPolicy']]=None,
        max_node_count: Optional[pulumi.Input[int]]=None, min_node_count:
        Optional[pulumi.Input[int]]=None, total_max_node_count: Optional[
        pulumi.Input[int]]=None, total_min_node_count: Optional[pulumi.
        Input[int]]=None):
        """
        NodePoolAutoscaling contains information required by cluster autoscaler to adjust the size of the node pool to the current cluster usage.
        :param pulumi.Input[bool] autoprovisioned: Can this node pool be deleted automatically.
        :param pulumi.Input[bool] enabled: Is autoscaling enabled for this node pool.
        :param pulumi.Input['NodePoolAutoscalingLocationPolicy'] location_policy: Location policy used when scaling up a nodepool.
        :param pulumi.Input[int] max_node_count: Maximum number of nodes for one location in the NodePool. Must be >= min_node_count. There has to be enough quota to scale up the cluster.
        :param pulumi.Input[int] min_node_count: Minimum number of nodes for one location in the NodePool. Must be >= 1 and <= max_node_count.
        :param pulumi.Input[int] total_max_node_count: Maximum number of nodes in the node pool. Must be greater than total_min_node_count. There has to be enough quota to scale up the cluster. The total_*_node_count fields are mutually exclusive with the *_node_count fields.
        :param pulumi.Input[int] total_min_node_count: Minimum number of nodes in the node pool. Must be greater than 1 less than total_max_node_count. The total_*_node_count fields are mutually exclusive with the *_node_count fields.
        """
        if autoprovisioned is not None:
            pulumi.set(__self__, 'autoprovisioned', autoprovisioned)
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)
        if location_policy is not None:
            pulumi.set(__self__, 'location_policy', location_policy)
        if max_node_count is not None:
            pulumi.set(__self__, 'max_node_count', max_node_count)
        if min_node_count is not None:
            pulumi.set(__self__, 'min_node_count', min_node_count)
        if total_max_node_count is not None:
            pulumi.set(__self__, 'total_max_node_count', total_max_node_count)
        if total_min_node_count is not None:
            pulumi.set(__self__, 'total_min_node_count', total_min_node_count)

    @property
    @pulumi.getter
    def autoprovisioned(self) ->Optional[pulumi.Input[bool]]:
        """
        Can this node pool be deleted automatically.
        """
        return pulumi.get(self, 'autoprovisioned')

    @autoprovisioned.setter
    def autoprovisioned(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'autoprovisioned', value)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Is autoscaling enabled for this node pool.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)

    @property
    @pulumi.getter(name='locationPolicy')
    def location_policy(self) ->Optional[pulumi.Input[
        'NodePoolAutoscalingLocationPolicy']]:
        """
        Location policy used when scaling up a nodepool.
        """
        return pulumi.get(self, 'location_policy')

    @location_policy.setter
    def location_policy(self, value: Optional[pulumi.Input[
        'NodePoolAutoscalingLocationPolicy']]):
        pulumi.set(self, 'location_policy', value)

    @property
    @pulumi.getter(name='maxNodeCount')
    def max_node_count(self) ->Optional[pulumi.Input[int]]:
        """
        Maximum number of nodes for one location in the NodePool. Must be >= min_node_count. There has to be enough quota to scale up the cluster.
        """
        return pulumi.get(self, 'max_node_count')

    @max_node_count.setter
    def max_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'max_node_count', value)

    @property
    @pulumi.getter(name='minNodeCount')
    def min_node_count(self) ->Optional[pulumi.Input[int]]:
        """
        Minimum number of nodes for one location in the NodePool. Must be >= 1 and <= max_node_count.
        """
        return pulumi.get(self, 'min_node_count')

    @min_node_count.setter
    def min_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'min_node_count', value)

    @property
    @pulumi.getter(name='totalMaxNodeCount')
    def total_max_node_count(self) ->Optional[pulumi.Input[int]]:
        """
        Maximum number of nodes in the node pool. Must be greater than total_min_node_count. There has to be enough quota to scale up the cluster. The total_*_node_count fields are mutually exclusive with the *_node_count fields.
        """
        return pulumi.get(self, 'total_max_node_count')

    @total_max_node_count.setter
    def total_max_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'total_max_node_count', value)

    @property
    @pulumi.getter(name='totalMinNodeCount')
    def total_min_node_count(self) ->Optional[pulumi.Input[int]]:
        """
        Minimum number of nodes in the node pool. Must be greater than 1 less than total_max_node_count. The total_*_node_count fields are mutually exclusive with the *_node_count fields.
        """
        return pulumi.get(self, 'total_min_node_count')

    @total_min_node_count.setter
    def total_min_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'total_min_node_count', value)


@pulumi.input_type
class NodePoolDefaultsArgs:

    def __init__(__self__, *, node_config_defaults: Optional[pulumi.Input[
        'NodeConfigDefaultsArgs']]=None):
        """
        Subset of Nodepool message that has defaults.
        :param pulumi.Input['NodeConfigDefaultsArgs'] node_config_defaults: Subset of NodeConfig message that has defaults.
        """
        if node_config_defaults is not None:
            pulumi.set(__self__, 'node_config_defaults', node_config_defaults)

    @property
    @pulumi.getter(name='nodeConfigDefaults')
    def node_config_defaults(self) ->Optional[pulumi.Input[
        'NodeConfigDefaultsArgs']]:
        """
        Subset of NodeConfig message that has defaults.
        """
        return pulumi.get(self, 'node_config_defaults')

    @node_config_defaults.setter
    def node_config_defaults(self, value: Optional[pulumi.Input[
        'NodeConfigDefaultsArgs']]):
        pulumi.set(self, 'node_config_defaults', value)


@pulumi.input_type
class NodePoolLoggingConfigArgs:

    def __init__(__self__, *, variant_config: Optional[pulumi.Input[
        'LoggingVariantConfigArgs']]=None):
        """
        NodePoolLoggingConfig specifies logging configuration for nodepools.
        :param pulumi.Input['LoggingVariantConfigArgs'] variant_config: Logging variant configuration.
        """
        if variant_config is not None:
            pulumi.set(__self__, 'variant_config', variant_config)

    @property
    @pulumi.getter(name='variantConfig')
    def variant_config(self) ->Optional[pulumi.Input[
        'LoggingVariantConfigArgs']]:
        """
        Logging variant configuration.
        """
        return pulumi.get(self, 'variant_config')

    @variant_config.setter
    def variant_config(self, value: Optional[pulumi.Input[
        'LoggingVariantConfigArgs']]):
        pulumi.set(self, 'variant_config', value)


@pulumi.input_type
class NodePoolArgs:

    def __init__(__self__, *, autoscaling: Optional[pulumi.Input[
        'NodePoolAutoscalingArgs']]=None, conditions: Optional[pulumi.Input
        [Sequence[pulumi.Input['StatusConditionArgs']]]]=None, config:
        Optional[pulumi.Input['NodeConfigArgs']]=None, etag: Optional[
        pulumi.Input[str]]=None, initial_node_count: Optional[pulumi.Input[
        int]]=None, locations: Optional[pulumi.Input[Sequence[pulumi.Input[
        str]]]]=None, management: Optional[pulumi.Input[
        'NodeManagementArgs']]=None, max_pods_constraint: Optional[pulumi.
        Input['MaxPodsConstraintArgs']]=None, name: Optional[pulumi.Input[
        str]]=None, network_config: Optional[pulumi.Input[
        'NodeNetworkConfigArgs']]=None, placement_policy: Optional[pulumi.
        Input['PlacementPolicyArgs']]=None, upgrade_settings: Optional[
        pulumi.Input['UpgradeSettingsArgs']]=None, version: Optional[pulumi
        .Input[str]]=None):
        """
        NodePool contains the name and configuration for a cluster's node pool. Node pools are a set of nodes (i.e. VM's), with a common configuration and specification, under the control of the cluster master. They may have a set of Kubernetes labels applied to them, which may be used to reference them during pod scheduling. They may also be resized up or down, to accommodate the workload. These upgrade settings control the level of parallelism and the level of disruption caused by an upgrade. maxUnavailable controls the number of nodes that can be simultaneously unavailable. maxSurge controls the number of additional nodes that can be added to the node pool temporarily for the time of the upgrade to increase the number of available nodes. (maxUnavailable + maxSurge) determines the level of parallelism (how many nodes are being upgraded at the same time). Note: upgrades inevitably introduce some disruption since workloads need to be moved from old nodes to new, upgraded ones. Even if maxUnavailable=0, this holds true. (Disruption stays within the limits of PodDisruptionBudget, if it is configured.) Consider a hypothetical node pool with 5 nodes having maxSurge=2, maxUnavailable=1. This means the upgrade process upgrades 3 nodes simultaneously. It creates 2 additional (upgraded) nodes, then it brings down 3 old (not yet upgraded) nodes at the same time. This ensures that there are always at least 4 nodes available.
        :param pulumi.Input['NodePoolAutoscalingArgs'] autoscaling: Autoscaler configuration for this NodePool. Autoscaler is enabled only if a valid configuration is present.
        :param pulumi.Input[Sequence[pulumi.Input['StatusConditionArgs']]] conditions: Which conditions caused the current node pool state.
        :param pulumi.Input['NodeConfigArgs'] config: The node configuration of the pool.
        :param pulumi.Input[str] etag: This checksum is computed by the server based on the value of node pool fields, and may be sent on update requests to ensure the client has an up-to-date value before proceeding.
        :param pulumi.Input[int] initial_node_count: The initial node count for the pool. You must ensure that your Compute Engine [resource quota](https://cloud.google.com/compute/quotas) is sufficient for this number of instances. You must also have available firewall and routes quota.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] locations: The list of Google Compute Engine [zones](https://cloud.google.com/compute/docs/zones#available) in which the NodePool's nodes should be located. If this value is unspecified during node pool creation, the [Cluster.Locations](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1/projects.locations.clusters#Cluster.FIELDS.locations) value will be used, instead. Warning: changing node pool locations will result in nodes being added and/or removed.
        :param pulumi.Input['NodeManagementArgs'] management: NodeManagement configuration for this NodePool.
        :param pulumi.Input['MaxPodsConstraintArgs'] max_pods_constraint: The constraint on the maximum number of pods that can be run simultaneously on a node in the node pool.
        :param pulumi.Input[str] name: The name of the node pool.
        :param pulumi.Input['NodeNetworkConfigArgs'] network_config: Networking configuration for this NodePool. If specified, it overrides the cluster-level defaults.
        :param pulumi.Input['PlacementPolicyArgs'] placement_policy: Specifies the node placement policy.
        :param pulumi.Input['UpgradeSettingsArgs'] upgrade_settings: Upgrade settings control disruption and speed of the upgrade.
        :param pulumi.Input[str] version: The version of Kubernetes running on this NodePool's nodes. If unspecified, it defaults as described [here](https://cloud.google.com/kubernetes-engine/versioning#specifying_node_version).
        """
        if autoscaling is not None:
            pulumi.set(__self__, 'autoscaling', autoscaling)
        if conditions is not None:
            pulumi.set(__self__, 'conditions', conditions)
        if config is not None:
            pulumi.set(__self__, 'config', config)
        if etag is not None:
            pulumi.set(__self__, 'etag', etag)
        if initial_node_count is not None:
            pulumi.set(__self__, 'initial_node_count', initial_node_count)
        if locations is not None:
            pulumi.set(__self__, 'locations', locations)
        if management is not None:
            pulumi.set(__self__, 'management', management)
        if max_pods_constraint is not None:
            pulumi.set(__self__, 'max_pods_constraint', max_pods_constraint)
        if name is not None:
            pulumi.set(__self__, 'name', name)
        if network_config is not None:
            pulumi.set(__self__, 'network_config', network_config)
        if placement_policy is not None:
            pulumi.set(__self__, 'placement_policy', placement_policy)
        if upgrade_settings is not None:
            pulumi.set(__self__, 'upgrade_settings', upgrade_settings)
        if version is not None:
            pulumi.set(__self__, 'version', version)

    @property
    @pulumi.getter
    def autoscaling(self) ->Optional[pulumi.Input['NodePoolAutoscalingArgs']]:
        """
        Autoscaler configuration for this NodePool. Autoscaler is enabled only if a valid configuration is present.
        """
        return pulumi.get(self, 'autoscaling')

    @autoscaling.setter
    def autoscaling(self, value: Optional[pulumi.Input[
        'NodePoolAutoscalingArgs']]):
        pulumi.set(self, 'autoscaling', value)

    @property
    @pulumi.getter
    def conditions(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[
        'StatusConditionArgs']]]]:
        """
        Which conditions caused the current node pool state.
        """
        return pulumi.get(self, 'conditions')

    @conditions.setter
    def conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input
        ['StatusConditionArgs']]]]):
        pulumi.set(self, 'conditions', value)

    @property
    @pulumi.getter
    def config(self) ->Optional[pulumi.Input['NodeConfigArgs']]:
        """
        The node configuration of the pool.
        """
        return pulumi.get(self, 'config')

    @config.setter
    def config(self, value: Optional[pulumi.Input['NodeConfigArgs']]):
        pulumi.set(self, 'config', value)

    @property
    @pulumi.getter
    def etag(self) ->Optional[pulumi.Input[str]]:
        """
        This checksum is computed by the server based on the value of node pool fields, and may be sent on update requests to ensure the client has an up-to-date value before proceeding.
        """
        return pulumi.get(self, 'etag')

    @etag.setter
    def etag(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'etag', value)

    @property
    @pulumi.getter(name='initialNodeCount')
    def initial_node_count(self) ->Optional[pulumi.Input[int]]:
        """
        The initial node count for the pool. You must ensure that your Compute Engine [resource quota](https://cloud.google.com/compute/quotas) is sufficient for this number of instances. You must also have available firewall and routes quota.
        """
        return pulumi.get(self, 'initial_node_count')

    @initial_node_count.setter
    def initial_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'initial_node_count', value)

    @property
    @pulumi.getter
    def locations(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The list of Google Compute Engine [zones](https://cloud.google.com/compute/docs/zones#available) in which the NodePool's nodes should be located. If this value is unspecified during node pool creation, the [Cluster.Locations](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1/projects.locations.clusters#Cluster.FIELDS.locations) value will be used, instead. Warning: changing node pool locations will result in nodes being added and/or removed.
        """
        return pulumi.get(self, 'locations')

    @locations.setter
    def locations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
        str]]]]):
        pulumi.set(self, 'locations', value)

    @property
    @pulumi.getter
    def management(self) ->Optional[pulumi.Input['NodeManagementArgs']]:
        """
        NodeManagement configuration for this NodePool.
        """
        return pulumi.get(self, 'management')

    @management.setter
    def management(self, value: Optional[pulumi.Input['NodeManagementArgs']]):
        pulumi.set(self, 'management', value)

    @property
    @pulumi.getter(name='maxPodsConstraint')
    def max_pods_constraint(self) ->Optional[pulumi.Input[
        'MaxPodsConstraintArgs']]:
        """
        The constraint on the maximum number of pods that can be run simultaneously on a node in the node pool.
        """
        return pulumi.get(self, 'max_pods_constraint')

    @max_pods_constraint.setter
    def max_pods_constraint(self, value: Optional[pulumi.Input[
        'MaxPodsConstraintArgs']]):
        pulumi.set(self, 'max_pods_constraint', value)

    @property
    @pulumi.getter
    def name(self) ->Optional[pulumi.Input[str]]:
        """
        The name of the node pool.
        """
        return pulumi.get(self, 'name')

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'name', value)

    @property
    @pulumi.getter(name='networkConfig')
    def network_config(self) ->Optional[pulumi.Input['NodeNetworkConfigArgs']]:
        """
        Networking configuration for this NodePool. If specified, it overrides the cluster-level defaults.
        """
        return pulumi.get(self, 'network_config')

    @network_config.setter
    def network_config(self, value: Optional[pulumi.Input[
        'NodeNetworkConfigArgs']]):
        pulumi.set(self, 'network_config', value)

    @property
    @pulumi.getter(name='placementPolicy')
    def placement_policy(self) ->Optional[pulumi.Input['PlacementPolicyArgs']]:
        """
        Specifies the node placement policy.
        """
        return pulumi.get(self, 'placement_policy')

    @placement_policy.setter
    def placement_policy(self, value: Optional[pulumi.Input[
        'PlacementPolicyArgs']]):
        pulumi.set(self, 'placement_policy', value)

    @property
    @pulumi.getter(name='upgradeSettings')
    def upgrade_settings(self) ->Optional[pulumi.Input['UpgradeSettingsArgs']]:
        """
        Upgrade settings control disruption and speed of the upgrade.
        """
        return pulumi.get(self, 'upgrade_settings')

    @upgrade_settings.setter
    def upgrade_settings(self, value: Optional[pulumi.Input[
        'UpgradeSettingsArgs']]):
        pulumi.set(self, 'upgrade_settings', value)

    @property
    @pulumi.getter
    def version(self) ->Optional[pulumi.Input[str]]:
        """
        The version of Kubernetes running on this NodePool's nodes. If unspecified, it defaults as described [here](https://cloud.google.com/kubernetes-engine/versioning#specifying_node_version).
        """
        return pulumi.get(self, 'version')

    @version.setter
    def version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'version', value)


@pulumi.input_type
class NodeTaintArgs:

    def __init__(__self__, *, effect: Optional[pulumi.Input[
        'NodeTaintEffect']]=None, key: Optional[pulumi.Input[str]]=None,
        value: Optional[pulumi.Input[str]]=None):
        """
        Kubernetes taint is composed of three fields: key, value, and effect. Effect can only be one of three types: NoSchedule, PreferNoSchedule or NoExecute. See [here](https://kubernetes.io/docs/concepts/configuration/taint-and-toleration) for more information, including usage and the valid values.
        :param pulumi.Input['NodeTaintEffect'] effect: Effect for taint.
        :param pulumi.Input[str] key: Key for taint.
        :param pulumi.Input[str] value: Value for taint.
        """
        if effect is not None:
            pulumi.set(__self__, 'effect', effect)
        if key is not None:
            pulumi.set(__self__, 'key', key)
        if value is not None:
            pulumi.set(__self__, 'value', value)

    @property
    @pulumi.getter
    def effect(self) ->Optional[pulumi.Input['NodeTaintEffect']]:
        """
        Effect for taint.
        """
        return pulumi.get(self, 'effect')

    @effect.setter
    def effect(self, value: Optional[pulumi.Input['NodeTaintEffect']]):
        pulumi.set(self, 'effect', value)

    @property
    @pulumi.getter
    def key(self) ->Optional[pulumi.Input[str]]:
        """
        Key for taint.
        """
        return pulumi.get(self, 'key')

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'key', value)

    @property
    @pulumi.getter
    def value(self) ->Optional[pulumi.Input[str]]:
        """
        Value for taint.
        """
        return pulumi.get(self, 'value')

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'value', value)


@pulumi.input_type
class NotificationConfigArgs:

    def __init__(__self__, *, pubsub: Optional[pulumi.Input['PubSubArgs']]=None
        ):
        """
        NotificationConfig is the configuration of notifications.
        :param pulumi.Input['PubSubArgs'] pubsub: Notification config for Pub/Sub.
        """
        if pubsub is not None:
            pulumi.set(__self__, 'pubsub', pubsub)

    @property
    @pulumi.getter
    def pubsub(self) ->Optional[pulumi.Input['PubSubArgs']]:
        """
        Notification config for Pub/Sub.
        """
        return pulumi.get(self, 'pubsub')

    @pubsub.setter
    def pubsub(self, value: Optional[pulumi.Input['PubSubArgs']]):
        pulumi.set(self, 'pubsub', value)


@pulumi.input_type
class PlacementPolicyArgs:

    def __init__(__self__, *, type: Optional[pulumi.Input[
        'PlacementPolicyType']]=None):
        """
        PlacementPolicy defines the placement policy used by the node pool.
        :param pulumi.Input['PlacementPolicyType'] type: The type of placement.
        """
        if type is not None:
            pulumi.set(__self__, 'type', type)

    @property
    @pulumi.getter
    def type(self) ->Optional[pulumi.Input['PlacementPolicyType']]:
        """
        The type of placement.
        """
        return pulumi.get(self, 'type')

    @type.setter
    def type(self, value: Optional[pulumi.Input['PlacementPolicyType']]):
        pulumi.set(self, 'type', value)


@pulumi.input_type
class PodCIDROverprovisionConfigArgs:

    def __init__(__self__, *, disable: Optional[pulumi.Input[bool]]=None):
        """
        [PRIVATE FIELD] Config for pod CIDR size overprovisioning.
        :param pulumi.Input[bool] disable: Whether Pod CIDR overprovisioning is disabled. Note: Pod CIDR overprovisioning is enabled by default.
        """
        if disable is not None:
            pulumi.set(__self__, 'disable', disable)

    @property
    @pulumi.getter
    def disable(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Pod CIDR overprovisioning is disabled. Note: Pod CIDR overprovisioning is enabled by default.
        """
        return pulumi.get(self, 'disable')

    @disable.setter
    def disable(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'disable', value)


@pulumi.input_type
class PodSecurityPolicyConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for the PodSecurityPolicy feature.
        :param pulumi.Input[bool] enabled: Enable the PodSecurityPolicy controller for this cluster. If enabled, pods must be valid under a PodSecurityPolicy to be created.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Enable the PodSecurityPolicy controller for this cluster. If enabled, pods must be valid under a PodSecurityPolicy to be created.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class PrivateClusterConfigArgs:

    def __init__(__self__, *, enable_private_endpoint: Optional[pulumi.
        Input[bool]]=None, enable_private_nodes: Optional[pulumi.Input[bool
        ]]=None, master_global_access_config: Optional[pulumi.Input[
        'PrivateClusterMasterGlobalAccessConfigArgs']]=None,
        master_ipv4_cidr_block: Optional[pulumi.Input[str]]=None,
        private_endpoint_subnetwork: Optional[pulumi.Input[str]]=None):
        """
        Configuration options for private clusters.
        :param pulumi.Input[bool] enable_private_endpoint: Whether the master's internal IP address is used as the cluster endpoint.
        :param pulumi.Input[bool] enable_private_nodes: Whether nodes have internal IP addresses only. If enabled, all nodes are given only RFC 1918 private addresses and communicate with the master via private networking.
        :param pulumi.Input['PrivateClusterMasterGlobalAccessConfigArgs'] master_global_access_config: Controls master global access settings.
        :param pulumi.Input[str] master_ipv4_cidr_block: The IP range in CIDR notation to use for the hosted master network. This range will be used for assigning internal IP addresses to the master or set of masters, as well as the ILB VIP. This range must not overlap with any other ranges in use within the cluster's network.
        :param pulumi.Input[str] private_endpoint_subnetwork: Subnet to provision the master's private endpoint during cluster creation. Specified in projects/*/regions/*/subnetworks/* format.
        """
        if enable_private_endpoint is not None:
            pulumi.set(__self__, 'enable_private_endpoint',
                enable_private_endpoint)
        if enable_private_nodes is not None:
            pulumi.set(__self__, 'enable_private_nodes', enable_private_nodes)
        if master_global_access_config is not None:
            pulumi.set(__self__, 'master_global_access_config',
                master_global_access_config)
        if master_ipv4_cidr_block is not None:
            pulumi.set(__self__, 'master_ipv4_cidr_block',
                master_ipv4_cidr_block)
        if private_endpoint_subnetwork is not None:
            pulumi.set(__self__, 'private_endpoint_subnetwork',
                private_endpoint_subnetwork)

    @property
    @pulumi.getter(name='enablePrivateEndpoint')
    def enable_private_endpoint(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the master's internal IP address is used as the cluster endpoint.
        """
        return pulumi.get(self, 'enable_private_endpoint')

    @enable_private_endpoint.setter
    def enable_private_endpoint(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_private_endpoint', value)

    @property
    @pulumi.getter(name='enablePrivateNodes')
    def enable_private_nodes(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether nodes have internal IP addresses only. If enabled, all nodes are given only RFC 1918 private addresses and communicate with the master via private networking.
        """
        return pulumi.get(self, 'enable_private_nodes')

    @enable_private_nodes.setter
    def enable_private_nodes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_private_nodes', value)

    @property
    @pulumi.getter(name='masterGlobalAccessConfig')
    def master_global_access_config(self) ->Optional[pulumi.Input[
        'PrivateClusterMasterGlobalAccessConfigArgs']]:
        """
        Controls master global access settings.
        """
        return pulumi.get(self, 'master_global_access_config')

    @master_global_access_config.setter
    def master_global_access_config(self, value: Optional[pulumi.Input[
        'PrivateClusterMasterGlobalAccessConfigArgs']]):
        pulumi.set(self, 'master_global_access_config', value)

    @property
    @pulumi.getter(name='masterIpv4CidrBlock')
    def master_ipv4_cidr_block(self) ->Optional[pulumi.Input[str]]:
        """
        The IP range in CIDR notation to use for the hosted master network. This range will be used for assigning internal IP addresses to the master or set of masters, as well as the ILB VIP. This range must not overlap with any other ranges in use within the cluster's network.
        """
        return pulumi.get(self, 'master_ipv4_cidr_block')

    @master_ipv4_cidr_block.setter
    def master_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'master_ipv4_cidr_block', value)

    @property
    @pulumi.getter(name='privateEndpointSubnetwork')
    def private_endpoint_subnetwork(self) ->Optional[pulumi.Input[str]]:
        """
        Subnet to provision the master's private endpoint during cluster creation. Specified in projects/*/regions/*/subnetworks/* format.
        """
        return pulumi.get(self, 'private_endpoint_subnetwork')

    @private_endpoint_subnetwork.setter
    def private_endpoint_subnetwork(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'private_endpoint_subnetwork', value)


@pulumi.input_type
class PrivateClusterMasterGlobalAccessConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for controlling master global access settings.
        :param pulumi.Input[bool] enabled: Whenever master is accessible globally or not.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whenever master is accessible globally or not.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class ProtectConfigArgs:

    def __init__(__self__, *, workload_config: Optional[pulumi.Input[
        'WorkloadConfigArgs']]=None, workload_vulnerability_mode: Optional[
        pulumi.Input['ProtectConfigWorkloadVulnerabilityMode']]=None):
        """
        ProtectConfig defines the flags needed to enable/disable features for the Protect API.
        :param pulumi.Input['WorkloadConfigArgs'] workload_config: WorkloadConfig defines which actions are enabled for a cluster's workload configurations.
        :param pulumi.Input['ProtectConfigWorkloadVulnerabilityMode'] workload_vulnerability_mode: Sets which mode to use for Protect workload vulnerability scanning feature.
        """
        if workload_config is not None:
            pulumi.set(__self__, 'workload_config', workload_config)
        if workload_vulnerability_mode is not None:
            pulumi.set(__self__, 'workload_vulnerability_mode',
                workload_vulnerability_mode)

    @property
    @pulumi.getter(name='workloadConfig')
    def workload_config(self) ->Optional[pulumi.Input['WorkloadConfigArgs']]:
        """
        WorkloadConfig defines which actions are enabled for a cluster's workload configurations.
        """
        return pulumi.get(self, 'workload_config')

    @workload_config.setter
    def workload_config(self, value: Optional[pulumi.Input[
        'WorkloadConfigArgs']]):
        pulumi.set(self, 'workload_config', value)

    @property
    @pulumi.getter(name='workloadVulnerabilityMode')
    def workload_vulnerability_mode(self) ->Optional[pulumi.Input[
        'ProtectConfigWorkloadVulnerabilityMode']]:
        """
        Sets which mode to use for Protect workload vulnerability scanning feature.
        """
        return pulumi.get(self, 'workload_vulnerability_mode')

    @workload_vulnerability_mode.setter
    def workload_vulnerability_mode(self, value: Optional[pulumi.Input[
        'ProtectConfigWorkloadVulnerabilityMode']]):
        pulumi.set(self, 'workload_vulnerability_mode', value)


@pulumi.input_type
class PubSubArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None,
        filter: Optional[pulumi.Input['FilterArgs']]=None, topic: Optional[
        pulumi.Input[str]]=None):
        """
        Pub/Sub specific notification config.
        :param pulumi.Input[bool] enabled: Enable notifications for Pub/Sub.
        :param pulumi.Input['FilterArgs'] filter: Allows filtering to one or more specific event types. If no filter is specified, or if a filter is specified with no event types, all event types will be sent
        :param pulumi.Input[str] topic: The desired Pub/Sub topic to which notifications will be sent by GKE. Format is `projects/{project}/topics/{topic}`.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)
        if filter is not None:
            pulumi.set(__self__, 'filter', filter)
        if topic is not None:
            pulumi.set(__self__, 'topic', topic)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Enable notifications for Pub/Sub.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)

    @property
    @pulumi.getter
    def filter(self) ->Optional[pulumi.Input['FilterArgs']]:
        """
        Allows filtering to one or more specific event types. If no filter is specified, or if a filter is specified with no event types, all event types will be sent
        """
        return pulumi.get(self, 'filter')

    @filter.setter
    def filter(self, value: Optional[pulumi.Input['FilterArgs']]):
        pulumi.set(self, 'filter', value)

    @property
    @pulumi.getter
    def topic(self) ->Optional[pulumi.Input[str]]:
        """
        The desired Pub/Sub topic to which notifications will be sent by GKE. Format is `projects/{project}/topics/{topic}`.
        """
        return pulumi.get(self, 'topic')

    @topic.setter
    def topic(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'topic', value)


@pulumi.input_type
class RecurringTimeWindowArgs:

    def __init__(__self__, *, recurrence: Optional[pulumi.Input[str]]=None,
        window: Optional[pulumi.Input['TimeWindowArgs']]=None):
        """
        Represents an arbitrary window of time that recurs.
        :param pulumi.Input[str] recurrence: An RRULE (https://tools.ietf.org/html/rfc5545#section-3.8.5.3) for how this window reccurs. They go on for the span of time between the start and end time. For example, to have something repeat every weekday, you'd use: `FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR` To repeat some window daily (equivalent to the DailyMaintenanceWindow): `FREQ=DAILY` For the first weekend of every month: `FREQ=MONTHLY;BYSETPOS=1;BYDAY=SA,SU` This specifies how frequently the window starts. Eg, if you wanted to have a 9-5 UTC-4 window every weekday, you'd use something like: ``` start time = 2019-01-01T09:00:00-0400 end time = 2019-01-01T17:00:00-0400 recurrence = FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR ``` Windows can span multiple days. Eg, to make the window encompass every weekend from midnight Saturday till the last minute of Sunday UTC: ``` start time = 2019-01-05T00:00:00Z end time = 2019-01-07T23:59:00Z recurrence = FREQ=WEEKLY;BYDAY=SA ``` Note the start and end time's specific dates are largely arbitrary except to specify duration of the window and when it first starts. The FREQ values of HOURLY, MINUTELY, and SECONDLY are not supported.
        :param pulumi.Input['TimeWindowArgs'] window: The window of the first recurrence.
        """
        if recurrence is not None:
            pulumi.set(__self__, 'recurrence', recurrence)
        if window is not None:
            pulumi.set(__self__, 'window', window)

    @property
    @pulumi.getter
    def recurrence(self) ->Optional[pulumi.Input[str]]:
        """
        An RRULE (https://tools.ietf.org/html/rfc5545#section-3.8.5.3) for how this window reccurs. They go on for the span of time between the start and end time. For example, to have something repeat every weekday, you'd use: `FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR` To repeat some window daily (equivalent to the DailyMaintenanceWindow): `FREQ=DAILY` For the first weekend of every month: `FREQ=MONTHLY;BYSETPOS=1;BYDAY=SA,SU` This specifies how frequently the window starts. Eg, if you wanted to have a 9-5 UTC-4 window every weekday, you'd use something like: ``` start time = 2019-01-01T09:00:00-0400 end time = 2019-01-01T17:00:00-0400 recurrence = FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR ``` Windows can span multiple days. Eg, to make the window encompass every weekend from midnight Saturday till the last minute of Sunday UTC: ``` start time = 2019-01-05T00:00:00Z end time = 2019-01-07T23:59:00Z recurrence = FREQ=WEEKLY;BYDAY=SA ``` Note the start and end time's specific dates are largely arbitrary except to specify duration of the window and when it first starts. The FREQ values of HOURLY, MINUTELY, and SECONDLY are not supported.
        """
        return pulumi.get(self, 'recurrence')

    @recurrence.setter
    def recurrence(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'recurrence', value)

    @property
    @pulumi.getter
    def window(self) ->Optional[pulumi.Input['TimeWindowArgs']]:
        """
        The window of the first recurrence.
        """
        return pulumi.get(self, 'window')

    @window.setter
    def window(self, value: Optional[pulumi.Input['TimeWindowArgs']]):
        pulumi.set(self, 'window', value)


@pulumi.input_type
class ReleaseChannelArgs:

    def __init__(__self__, *, channel: Optional[pulumi.Input[
        'ReleaseChannelChannel']]=None):
        """
        ReleaseChannel indicates which release channel a cluster is subscribed to. Release channels are arranged in order of risk. When a cluster is subscribed to a release channel, Google maintains both the master version and the node version. Node auto-upgrade defaults to true and cannot be disabled.
        :param pulumi.Input['ReleaseChannelChannel'] channel: channel specifies which release channel the cluster is subscribed to.
        """
        if channel is not None:
            pulumi.set(__self__, 'channel', channel)

    @property
    @pulumi.getter
    def channel(self) ->Optional[pulumi.Input['ReleaseChannelChannel']]:
        """
        channel specifies which release channel the cluster is subscribed to.
        """
        return pulumi.get(self, 'channel')

    @channel.setter
    def channel(self, value: Optional[pulumi.Input['ReleaseChannelChannel']]):
        pulumi.set(self, 'channel', value)


@pulumi.input_type
class ReservationAffinityArgs:

    def __init__(__self__, *, consume_reservation_type: Optional[pulumi.
        Input['ReservationAffinityConsumeReservationType']]=None, key:
        Optional[pulumi.Input[str]]=None, values: Optional[pulumi.Input[
        Sequence[pulumi.Input[str]]]]=None):
        """
        [ReservationAffinity](https://cloud.google.com/compute/docs/instances/reserving-zonal-resources) is the configuration of desired reservation which instances could take capacity from.
        :param pulumi.Input['ReservationAffinityConsumeReservationType'] consume_reservation_type: Corresponds to the type of reservation consumption.
        :param pulumi.Input[str] key: Corresponds to the label key of a reservation resource. To target a SPECIFIC_RESERVATION by name, specify "compute.googleapis.com/reservation-name" as the key and specify the name of your reservation as its value.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: Corresponds to the label value(s) of reservation resource(s).
        """
        if consume_reservation_type is not None:
            pulumi.set(__self__, 'consume_reservation_type',
                consume_reservation_type)
        if key is not None:
            pulumi.set(__self__, 'key', key)
        if values is not None:
            pulumi.set(__self__, 'values', values)

    @property
    @pulumi.getter(name='consumeReservationType')
    def consume_reservation_type(self) ->Optional[pulumi.Input[
        'ReservationAffinityConsumeReservationType']]:
        """
        Corresponds to the type of reservation consumption.
        """
        return pulumi.get(self, 'consume_reservation_type')

    @consume_reservation_type.setter
    def consume_reservation_type(self, value: Optional[pulumi.Input[
        'ReservationAffinityConsumeReservationType']]):
        pulumi.set(self, 'consume_reservation_type', value)

    @property
    @pulumi.getter
    def key(self) ->Optional[pulumi.Input[str]]:
        """
        Corresponds to the label key of a reservation resource. To target a SPECIFIC_RESERVATION by name, specify "compute.googleapis.com/reservation-name" as the key and specify the name of your reservation as its value.
        """
        return pulumi.get(self, 'key')

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'key', value)

    @property
    @pulumi.getter
    def values(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Corresponds to the label value(s) of reservation resource(s).
        """
        return pulumi.get(self, 'values')

    @values.setter
    def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]
        ):
        pulumi.set(self, 'values', value)


@pulumi.input_type
class ResourceLimitArgs:

    def __init__(__self__, *, maximum: Optional[pulumi.Input[str]]=None,
        minimum: Optional[pulumi.Input[str]]=None, resource_type: Optional[
        pulumi.Input[str]]=None):
        """
        Contains information about amount of some resource in the cluster. For memory, value should be in GB.
        :param pulumi.Input[str] maximum: Maximum amount of the resource in the cluster.
        :param pulumi.Input[str] minimum: Minimum amount of the resource in the cluster.
        :param pulumi.Input[str] resource_type: Resource name "cpu", "memory" or gpu-specific string.
        """
        if maximum is not None:
            pulumi.set(__self__, 'maximum', maximum)
        if minimum is not None:
            pulumi.set(__self__, 'minimum', minimum)
        if resource_type is not None:
            pulumi.set(__self__, 'resource_type', resource_type)

    @property
    @pulumi.getter
    def maximum(self) ->Optional[pulumi.Input[str]]:
        """
        Maximum amount of the resource in the cluster.
        """
        return pulumi.get(self, 'maximum')

    @maximum.setter
    def maximum(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'maximum', value)

    @property
    @pulumi.getter
    def minimum(self) ->Optional[pulumi.Input[str]]:
        """
        Minimum amount of the resource in the cluster.
        """
        return pulumi.get(self, 'minimum')

    @minimum.setter
    def minimum(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'minimum', value)

    @property
    @pulumi.getter(name='resourceType')
    def resource_type(self) ->Optional[pulumi.Input[str]]:
        """
        Resource name "cpu", "memory" or gpu-specific string.
        """
        return pulumi.get(self, 'resource_type')

    @resource_type.setter
    def resource_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'resource_type', value)


@pulumi.input_type
class ResourceUsageExportConfigArgs:

    def __init__(__self__, *, bigquery_destination: Optional[pulumi.Input[
        'BigQueryDestinationArgs']]=None, consumption_metering_config:
        Optional[pulumi.Input['ConsumptionMeteringConfigArgs']]=None,
        enable_network_egress_metering: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for exporting cluster resource usages.
        :param pulumi.Input['BigQueryDestinationArgs'] bigquery_destination: Configuration to use BigQuery as usage export destination.
        :param pulumi.Input['ConsumptionMeteringConfigArgs'] consumption_metering_config: Configuration to enable resource consumption metering.
        :param pulumi.Input[bool] enable_network_egress_metering: Whether to enable network egress metering for this cluster. If enabled, a daemonset will be created in the cluster to meter network egress traffic.
        """
        if bigquery_destination is not None:
            pulumi.set(__self__, 'bigquery_destination', bigquery_destination)
        if consumption_metering_config is not None:
            pulumi.set(__self__, 'consumption_metering_config',
                consumption_metering_config)
        if enable_network_egress_metering is not None:
            pulumi.set(__self__, 'enable_network_egress_metering',
                enable_network_egress_metering)

    @property
    @pulumi.getter(name='bigqueryDestination')
    def bigquery_destination(self) ->Optional[pulumi.Input[
        'BigQueryDestinationArgs']]:
        """
        Configuration to use BigQuery as usage export destination.
        """
        return pulumi.get(self, 'bigquery_destination')

    @bigquery_destination.setter
    def bigquery_destination(self, value: Optional[pulumi.Input[
        'BigQueryDestinationArgs']]):
        pulumi.set(self, 'bigquery_destination', value)

    @property
    @pulumi.getter(name='consumptionMeteringConfig')
    def consumption_metering_config(self) ->Optional[pulumi.Input[
        'ConsumptionMeteringConfigArgs']]:
        """
        Configuration to enable resource consumption metering.
        """
        return pulumi.get(self, 'consumption_metering_config')

    @consumption_metering_config.setter
    def consumption_metering_config(self, value: Optional[pulumi.Input[
        'ConsumptionMeteringConfigArgs']]):
        pulumi.set(self, 'consumption_metering_config', value)

    @property
    @pulumi.getter(name='enableNetworkEgressMetering')
    def enable_network_egress_metering(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether to enable network egress metering for this cluster. If enabled, a daemonset will be created in the cluster to meter network egress traffic.
        """
        return pulumi.get(self, 'enable_network_egress_metering')

    @enable_network_egress_metering.setter
    def enable_network_egress_metering(self, value: Optional[pulumi.Input[
        bool]]):
        pulumi.set(self, 'enable_network_egress_metering', value)


@pulumi.input_type
class SandboxConfigArgs:

    def __init__(__self__, *, sandbox_type: Optional[pulumi.Input[str]]=
        None, type: Optional[pulumi.Input['SandboxConfigType']]=None):
        """
        SandboxConfig contains configurations of the sandbox to use for the node.
        :param pulumi.Input[str] sandbox_type: Type of the sandbox to use for the node (e.g. 'gvisor')
        :param pulumi.Input['SandboxConfigType'] type: Type of the sandbox to use for the node.
        """
        if sandbox_type is not None:
            pulumi.set(__self__, 'sandbox_type', sandbox_type)
        if type is not None:
            pulumi.set(__self__, 'type', type)

    @property
    @pulumi.getter(name='sandboxType')
    def sandbox_type(self) ->Optional[pulumi.Input[str]]:
        """
        Type of the sandbox to use for the node (e.g. 'gvisor')
        """
        return pulumi.get(self, 'sandbox_type')

    @sandbox_type.setter
    def sandbox_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'sandbox_type', value)

    @property
    @pulumi.getter
    def type(self) ->Optional[pulumi.Input['SandboxConfigType']]:
        """
        Type of the sandbox to use for the node.
        """
        return pulumi.get(self, 'type')

    @type.setter
    def type(self, value: Optional[pulumi.Input['SandboxConfigType']]):
        pulumi.set(self, 'type', value)


@pulumi.input_type
class ServiceExternalIPsConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Config to block services with externalIPs field.
        :param pulumi.Input[bool] enabled: Whether Services with ExternalIPs field are allowed or not.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Services with ExternalIPs field are allowed or not.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class ShieldedInstanceConfigArgs:

    def __init__(__self__, *, enable_integrity_monitoring: Optional[pulumi.
        Input[bool]]=None, enable_secure_boot: Optional[pulumi.Input[bool]]
        =None):
        """
        A set of Shielded Instance options.
        :param pulumi.Input[bool] enable_integrity_monitoring: Defines whether the instance has integrity monitoring enabled. Enables monitoring and attestation of the boot integrity of the instance. The attestation is performed against the integrity policy baseline. This baseline is initially derived from the implicitly trusted boot image when the instance is created.
        :param pulumi.Input[bool] enable_secure_boot: Defines whether the instance has Secure Boot enabled. Secure Boot helps ensure that the system only runs authentic software by verifying the digital signature of all boot components, and halting the boot process if signature verification fails.
        """
        if enable_integrity_monitoring is not None:
            pulumi.set(__self__, 'enable_integrity_monitoring',
                enable_integrity_monitoring)
        if enable_secure_boot is not None:
            pulumi.set(__self__, 'enable_secure_boot', enable_secure_boot)

    @property
    @pulumi.getter(name='enableIntegrityMonitoring')
    def enable_integrity_monitoring(self) ->Optional[pulumi.Input[bool]]:
        """
        Defines whether the instance has integrity monitoring enabled. Enables monitoring and attestation of the boot integrity of the instance. The attestation is performed against the integrity policy baseline. This baseline is initially derived from the implicitly trusted boot image when the instance is created.
        """
        return pulumi.get(self, 'enable_integrity_monitoring')

    @enable_integrity_monitoring.setter
    def enable_integrity_monitoring(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_integrity_monitoring', value)

    @property
    @pulumi.getter(name='enableSecureBoot')
    def enable_secure_boot(self) ->Optional[pulumi.Input[bool]]:
        """
        Defines whether the instance has Secure Boot enabled. Secure Boot helps ensure that the system only runs authentic software by verifying the digital signature of all boot components, and halting the boot process if signature verification fails.
        """
        return pulumi.get(self, 'enable_secure_boot')

    @enable_secure_boot.setter
    def enable_secure_boot(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_secure_boot', value)


@pulumi.input_type
class ShieldedNodesArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration of Shielded Nodes feature.
        :param pulumi.Input[bool] enabled: Whether Shielded Nodes features are enabled on all nodes in this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Shielded Nodes features are enabled on all nodes in this cluster.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class StandardRolloutPolicyArgs:

    def __init__(__self__, *, batch_node_count: Optional[pulumi.Input[int]]
        =None, batch_percentage: Optional[pulumi.Input[float]]=None,
        batch_soak_duration: Optional[pulumi.Input[str]]=None):
        """
        Standard rollout policy is the default policy for blue-green.
        :param pulumi.Input[int] batch_node_count: Number of blue nodes to drain in a batch.
        :param pulumi.Input[float] batch_percentage: Percentage of the blue pool nodes to drain in a batch. The range of this field should be (0.0, 1.0].
        :param pulumi.Input[str] batch_soak_duration: Soak time after each batch gets drained. Default to zero.
        """
        if batch_node_count is not None:
            pulumi.set(__self__, 'batch_node_count', batch_node_count)
        if batch_percentage is not None:
            pulumi.set(__self__, 'batch_percentage', batch_percentage)
        if batch_soak_duration is not None:
            pulumi.set(__self__, 'batch_soak_duration', batch_soak_duration)

    @property
    @pulumi.getter(name='batchNodeCount')
    def batch_node_count(self) ->Optional[pulumi.Input[int]]:
        """
        Number of blue nodes to drain in a batch.
        """
        return pulumi.get(self, 'batch_node_count')

    @batch_node_count.setter
    def batch_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'batch_node_count', value)

    @property
    @pulumi.getter(name='batchPercentage')
    def batch_percentage(self) ->Optional[pulumi.Input[float]]:
        """
        Percentage of the blue pool nodes to drain in a batch. The range of this field should be (0.0, 1.0].
        """
        return pulumi.get(self, 'batch_percentage')

    @batch_percentage.setter
    def batch_percentage(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, 'batch_percentage', value)

    @property
    @pulumi.getter(name='batchSoakDuration')
    def batch_soak_duration(self) ->Optional[pulumi.Input[str]]:
        """
        Soak time after each batch gets drained. Default to zero.
        """
        return pulumi.get(self, 'batch_soak_duration')

    @batch_soak_duration.setter
    def batch_soak_duration(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'batch_soak_duration', value)


@pulumi.input_type
class StatusConditionArgs:

    def __init__(__self__, *, canonical_code: Optional[pulumi.Input[
        'StatusConditionCanonicalCode']]=None, code: Optional[pulumi.Input[
        'StatusConditionCode']]=None, message: Optional[pulumi.Input[str]]=None
        ):
        """
        StatusCondition describes why a cluster or a node pool has a certain status (e.g., ERROR or DEGRADED).
        :param pulumi.Input['StatusConditionCanonicalCode'] canonical_code: Canonical code of the condition.
        :param pulumi.Input['StatusConditionCode'] code: Machine-friendly representation of the condition Deprecated. Use canonical_code instead.
        :param pulumi.Input[str] message: Human-friendly representation of the condition
        """
        if canonical_code is not None:
            pulumi.set(__self__, 'canonical_code', canonical_code)
        if code is not None:
            warnings.warn(
                'Machine-friendly representation of the condition Deprecated. Use canonical_code instead.'
                , DeprecationWarning)
            pulumi.log.warn(
                'code is deprecated: Machine-friendly representation of the condition Deprecated. Use canonical_code instead.'
                )
        if code is not None:
            pulumi.set(__self__, 'code', code)
        if message is not None:
            pulumi.set(__self__, 'message', message)

    @property
    @pulumi.getter(name='canonicalCode')
    def canonical_code(self) ->Optional[pulumi.Input[
        'StatusConditionCanonicalCode']]:
        """
        Canonical code of the condition.
        """
        return pulumi.get(self, 'canonical_code')

    @canonical_code.setter
    def canonical_code(self, value: Optional[pulumi.Input[
        'StatusConditionCanonicalCode']]):
        pulumi.set(self, 'canonical_code', value)

    @property
    @pulumi.getter
    def code(self) ->Optional[pulumi.Input['StatusConditionCode']]:
        """
        Machine-friendly representation of the condition Deprecated. Use canonical_code instead.
        """
        warnings.warn(
            'Machine-friendly representation of the condition Deprecated. Use canonical_code instead.'
            , DeprecationWarning)
        pulumi.log.warn(
            'code is deprecated: Machine-friendly representation of the condition Deprecated. Use canonical_code instead.'
            )
        return pulumi.get(self, 'code')

    @code.setter
    def code(self, value: Optional[pulumi.Input['StatusConditionCode']]):
        pulumi.set(self, 'code', value)

    @property
    @pulumi.getter
    def message(self) ->Optional[pulumi.Input[str]]:
        """
        Human-friendly representation of the condition
        """
        return pulumi.get(self, 'message')

    @message.setter
    def message(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'message', value)


@pulumi.input_type
class TimeWindowArgs:

    def __init__(__self__, *, end_time: Optional[pulumi.Input[str]]=None,
        maintenance_exclusion_options: Optional[pulumi.Input[
        'MaintenanceExclusionOptionsArgs']]=None, start_time: Optional[
        pulumi.Input[str]]=None):
        """
        Represents an arbitrary window of time.
        :param pulumi.Input[str] end_time: The time that the window ends. The end time should take place after the start time.
        :param pulumi.Input['MaintenanceExclusionOptionsArgs'] maintenance_exclusion_options: MaintenanceExclusionOptions provides maintenance exclusion related options.
        :param pulumi.Input[str] start_time: The time that the window first starts.
        """
        if end_time is not None:
            pulumi.set(__self__, 'end_time', end_time)
        if maintenance_exclusion_options is not None:
            pulumi.set(__self__, 'maintenance_exclusion_options',
                maintenance_exclusion_options)
        if start_time is not None:
            pulumi.set(__self__, 'start_time', start_time)

    @property
    @pulumi.getter(name='endTime')
    def end_time(self) ->Optional[pulumi.Input[str]]:
        """
        The time that the window ends. The end time should take place after the start time.
        """
        return pulumi.get(self, 'end_time')

    @end_time.setter
    def end_time(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'end_time', value)

    @property
    @pulumi.getter(name='maintenanceExclusionOptions')
    def maintenance_exclusion_options(self) ->Optional[pulumi.Input[
        'MaintenanceExclusionOptionsArgs']]:
        """
        MaintenanceExclusionOptions provides maintenance exclusion related options.
        """
        return pulumi.get(self, 'maintenance_exclusion_options')

    @maintenance_exclusion_options.setter
    def maintenance_exclusion_options(self, value: Optional[pulumi.Input[
        'MaintenanceExclusionOptionsArgs']]):
        pulumi.set(self, 'maintenance_exclusion_options', value)

    @property
    @pulumi.getter(name='startTime')
    def start_time(self) ->Optional[pulumi.Input[str]]:
        """
        The time that the window first starts.
        """
        return pulumi.get(self, 'start_time')

    @start_time.setter
    def start_time(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'start_time', value)


@pulumi.input_type
class TpuConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None,
        ipv4_cidr_block: Optional[pulumi.Input[str]]=None,
        use_service_networking: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for Cloud TPU.
        :param pulumi.Input[bool] enabled: Whether Cloud TPU integration is enabled or not.
        :param pulumi.Input[str] ipv4_cidr_block: IPv4 CIDR block reserved for Cloud TPU in the VPC.
        :param pulumi.Input[bool] use_service_networking: Whether to use service networking for Cloud TPU or not.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)
        if ipv4_cidr_block is not None:
            pulumi.set(__self__, 'ipv4_cidr_block', ipv4_cidr_block)
        if use_service_networking is not None:
            pulumi.set(__self__, 'use_service_networking',
                use_service_networking)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Cloud TPU integration is enabled or not.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)

    @property
    @pulumi.getter(name='ipv4CidrBlock')
    def ipv4_cidr_block(self) ->Optional[pulumi.Input[str]]:
        """
        IPv4 CIDR block reserved for Cloud TPU in the VPC.
        """
        return pulumi.get(self, 'ipv4_cidr_block')

    @ipv4_cidr_block.setter
    def ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'ipv4_cidr_block', value)

    @property
    @pulumi.getter(name='useServiceNetworking')
    def use_service_networking(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether to use service networking for Cloud TPU or not.
        """
        return pulumi.get(self, 'use_service_networking')

    @use_service_networking.setter
    def use_service_networking(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'use_service_networking', value)


@pulumi.input_type
class UpgradeSettingsArgs:

    def __init__(__self__, *, blue_green_settings: Optional[pulumi.Input[
        'BlueGreenSettingsArgs']]=None, max_surge: Optional[pulumi.Input[
        int]]=None, max_unavailable: Optional[pulumi.Input[int]]=None,
        strategy: Optional[pulumi.Input['UpgradeSettingsStrategy']]=None):
        """
        These upgrade settings configure the upgrade strategy for the node pool. Use strategy to switch between the strategies applied to the node pool. If the strategy is SURGE, use max_surge and max_unavailable to control the level of parallelism and the level of disruption caused by upgrade. 1. maxSurge controls the number of additional nodes that can be added to the node pool temporarily for the time of the upgrade to increase the number of available nodes. 2. maxUnavailable controls the number of nodes that can be simultaneously unavailable. 3. (maxUnavailable + maxSurge) determines the level of parallelism (how many nodes are being upgraded at the same time). If the strategy is BLUE_GREEN, use blue_green_settings to configure the blue-green upgrade related settings. 1. standard_rollout_policy is the default policy. The policy is used to control the way blue pool gets drained. The draining is executed in the batch mode. The batch size could be specified as either percentage of the node pool size or the number of nodes. batch_soak_duration is the soak time after each batch gets drained. 2. node_pool_soak_duration is the soak time after all blue nodes are drained. After this period, the blue pool nodes will be deleted.
        :param pulumi.Input['BlueGreenSettingsArgs'] blue_green_settings: Settings for blue-green upgrade strategy.
        :param pulumi.Input[int] max_surge: The maximum number of nodes that can be created beyond the current size of the node pool during the upgrade process.
        :param pulumi.Input[int] max_unavailable: The maximum number of nodes that can be simultaneously unavailable during the upgrade process. A node is considered available if its status is Ready.
        :param pulumi.Input['UpgradeSettingsStrategy'] strategy: Update strategy of the node pool.
        """
        if blue_green_settings is not None:
            pulumi.set(__self__, 'blue_green_settings', blue_green_settings)
        if max_surge is not None:
            pulumi.set(__self__, 'max_surge', max_surge)
        if max_unavailable is not None:
            pulumi.set(__self__, 'max_unavailable', max_unavailable)
        if strategy is not None:
            pulumi.set(__self__, 'strategy', strategy)

    @property
    @pulumi.getter(name='blueGreenSettings')
    def blue_green_settings(self) ->Optional[pulumi.Input[
        'BlueGreenSettingsArgs']]:
        """
        Settings for blue-green upgrade strategy.
        """
        return pulumi.get(self, 'blue_green_settings')

    @blue_green_settings.setter
    def blue_green_settings(self, value: Optional[pulumi.Input[
        'BlueGreenSettingsArgs']]):
        pulumi.set(self, 'blue_green_settings', value)

    @property
    @pulumi.getter(name='maxSurge')
    def max_surge(self) ->Optional[pulumi.Input[int]]:
        """
        The maximum number of nodes that can be created beyond the current size of the node pool during the upgrade process.
        """
        return pulumi.get(self, 'max_surge')

    @max_surge.setter
    def max_surge(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'max_surge', value)

    @property
    @pulumi.getter(name='maxUnavailable')
    def max_unavailable(self) ->Optional[pulumi.Input[int]]:
        """
        The maximum number of nodes that can be simultaneously unavailable during the upgrade process. A node is considered available if its status is Ready.
        """
        return pulumi.get(self, 'max_unavailable')

    @max_unavailable.setter
    def max_unavailable(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'max_unavailable', value)

    @property
    @pulumi.getter
    def strategy(self) ->Optional[pulumi.Input['UpgradeSettingsStrategy']]:
        """
        Update strategy of the node pool.
        """
        return pulumi.get(self, 'strategy')

    @strategy.setter
    def strategy(self, value: Optional[pulumi.Input['UpgradeSettingsStrategy']]
        ):
        pulumi.set(self, 'strategy', value)


@pulumi.input_type
class VerticalPodAutoscalingArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        VerticalPodAutoscaling contains global, per-cluster information required by Vertical Pod Autoscaler to automatically adjust the resources of pods controlled by it.
        :param pulumi.Input[bool] enabled: Enables vertical pod autoscaling.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Enables vertical pod autoscaling.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class VirtualNICArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration of gVNIC feature.
        :param pulumi.Input[bool] enabled: Whether gVNIC features are enabled in the node pool.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether gVNIC features are enabled in the node pool.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class WindowsNodeConfigArgs:

    def __init__(__self__, *, os_version: Optional[pulumi.Input[
        'WindowsNodeConfigOsVersion']]=None):
        """
        Parameters that can be configured on Windows nodes. Windows Node Config that define the parameters that will be used to configure the Windows node pool settings
        :param pulumi.Input['WindowsNodeConfigOsVersion'] os_version: OSVersion specifies the Windows node config to be used on the node
        """
        if os_version is not None:
            pulumi.set(__self__, 'os_version', os_version)

    @property
    @pulumi.getter(name='osVersion')
    def os_version(self) ->Optional[pulumi.Input['WindowsNodeConfigOsVersion']
        ]:
        """
        OSVersion specifies the Windows node config to be used on the node
        """
        return pulumi.get(self, 'os_version')

    @os_version.setter
    def os_version(self, value: Optional[pulumi.Input[
        'WindowsNodeConfigOsVersion']]):
        pulumi.set(self, 'os_version', value)


@pulumi.input_type
class WorkloadALTSConfigArgs:

    def __init__(__self__, *, enable_alts: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for direct-path (via ALTS) with workload identity.
        :param pulumi.Input[bool] enable_alts: enable_alts controls whether the alts handshaker should be enabled or not for direct-path. Requires Workload Identity (workload_pool must be non-empty).
        """
        if enable_alts is not None:
            pulumi.set(__self__, 'enable_alts', enable_alts)

    @property
    @pulumi.getter(name='enableAlts')
    def enable_alts(self) ->Optional[pulumi.Input[bool]]:
        """
        enable_alts controls whether the alts handshaker should be enabled or not for direct-path. Requires Workload Identity (workload_pool must be non-empty).
        """
        return pulumi.get(self, 'enable_alts')

    @enable_alts.setter
    def enable_alts(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_alts', value)


@pulumi.input_type
class WorkloadCertificatesArgs:

    def __init__(__self__, *, enable_certificates: Optional[pulumi.Input[
        bool]]=None):
        """
        Configuration for issuance of mTLS keys and certificates to Kubernetes pods.
        :param pulumi.Input[bool] enable_certificates: enable_certificates controls issuance of workload mTLS certificates. If set, the GKE Workload Identity Certificates controller and node agent will be deployed in the cluster, which can then be configured by creating a WorkloadCertificateConfig Custom Resource. Requires Workload Identity (workload_pool must be non-empty).
        """
        if enable_certificates is not None:
            pulumi.set(__self__, 'enable_certificates', enable_certificates)

    @property
    @pulumi.getter(name='enableCertificates')
    def enable_certificates(self) ->Optional[pulumi.Input[bool]]:
        """
        enable_certificates controls issuance of workload mTLS certificates. If set, the GKE Workload Identity Certificates controller and node agent will be deployed in the cluster, which can then be configured by creating a WorkloadCertificateConfig Custom Resource. Requires Workload Identity (workload_pool must be non-empty).
        """
        return pulumi.get(self, 'enable_certificates')

    @enable_certificates.setter
    def enable_certificates(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_certificates', value)


@pulumi.input_type
class WorkloadConfigArgs:

    def __init__(__self__, *, audit_mode: Optional[pulumi.Input[
        'WorkloadConfigAuditMode']]=None):
        """
        WorkloadConfig defines the flags to enable or disable the workload configurations for the cluster.
        :param pulumi.Input['WorkloadConfigAuditMode'] audit_mode: Sets which mode of auditing should be used for the cluster's workloads.
        """
        if audit_mode is not None:
            pulumi.set(__self__, 'audit_mode', audit_mode)

    @property
    @pulumi.getter(name='auditMode')
    def audit_mode(self) ->Optional[pulumi.Input['WorkloadConfigAuditMode']]:
        """
        Sets which mode of auditing should be used for the cluster's workloads.
        """
        return pulumi.get(self, 'audit_mode')

    @audit_mode.setter
    def audit_mode(self, value: Optional[pulumi.Input[
        'WorkloadConfigAuditMode']]):
        pulumi.set(self, 'audit_mode', value)


@pulumi.input_type
class WorkloadIdentityConfigArgs:

    def __init__(__self__, *, identity_namespace: Optional[pulumi.Input[str
        ]]=None, identity_provider: Optional[pulumi.Input[str]]=None,
        workload_pool: Optional[pulumi.Input[str]]=None):
        """
        Configuration for the use of Kubernetes Service Accounts in GCP IAM policies.
        :param pulumi.Input[str] identity_namespace: IAM Identity Namespace to attach all Kubernetes Service Accounts to.
        :param pulumi.Input[str] identity_provider: identity provider is the third party identity provider.
        :param pulumi.Input[str] workload_pool: The workload pool to attach all Kubernetes service accounts to.
        """
        if identity_namespace is not None:
            pulumi.set(__self__, 'identity_namespace', identity_namespace)
        if identity_provider is not None:
            pulumi.set(__self__, 'identity_provider', identity_provider)
        if workload_pool is not None:
            pulumi.set(__self__, 'workload_pool', workload_pool)

    @property
    @pulumi.getter(name='identityNamespace')
    def identity_namespace(self) ->Optional[pulumi.Input[str]]:
        """
        IAM Identity Namespace to attach all Kubernetes Service Accounts to.
        """
        return pulumi.get(self, 'identity_namespace')

    @identity_namespace.setter
    def identity_namespace(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'identity_namespace', value)

    @property
    @pulumi.getter(name='identityProvider')
    def identity_provider(self) ->Optional[pulumi.Input[str]]:
        """
        identity provider is the third party identity provider.
        """
        return pulumi.get(self, 'identity_provider')

    @identity_provider.setter
    def identity_provider(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'identity_provider', value)

    @property
    @pulumi.getter(name='workloadPool')
    def workload_pool(self) ->Optional[pulumi.Input[str]]:
        """
        The workload pool to attach all Kubernetes service accounts to.
        """
        return pulumi.get(self, 'workload_pool')

    @workload_pool.setter
    def workload_pool(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'workload_pool', value)


@pulumi.input_type
class WorkloadMetadataConfigArgs:

    def __init__(__self__, *, mode: Optional[pulumi.Input[
        'WorkloadMetadataConfigMode']]=None, node_metadata: Optional[pulumi
        .Input['WorkloadMetadataConfigNodeMetadata']]=None):
        """
        WorkloadMetadataConfig defines the metadata configuration to expose to workloads on the node pool.
        :param pulumi.Input['WorkloadMetadataConfigMode'] mode: Mode is the configuration for how to expose metadata to workloads running on the node pool.
        :param pulumi.Input['WorkloadMetadataConfigNodeMetadata'] node_metadata: NodeMetadata is the configuration for how to expose metadata to the workloads running on the node.
        """
        if mode is not None:
            pulumi.set(__self__, 'mode', mode)
        if node_metadata is not None:
            pulumi.set(__self__, 'node_metadata', node_metadata)

    @property
    @pulumi.getter
    def mode(self) ->Optional[pulumi.Input['WorkloadMetadataConfigMode']]:
        """
        Mode is the configuration for how to expose metadata to workloads running on the node pool.
        """
        return pulumi.get(self, 'mode')

    @mode.setter
    def mode(self, value: Optional[pulumi.Input['WorkloadMetadataConfigMode']]
        ):
        pulumi.set(self, 'mode', value)

    @property
    @pulumi.getter(name='nodeMetadata')
    def node_metadata(self) ->Optional[pulumi.Input[
        'WorkloadMetadataConfigNodeMetadata']]:
        """
        NodeMetadata is the configuration for how to expose metadata to the workloads running on the node.
        """
        return pulumi.get(self, 'node_metadata')

    @node_metadata.setter
    def node_metadata(self, value: Optional[pulumi.Input[
        'WorkloadMetadataConfigNodeMetadata']]):
        pulumi.set(self, 'node_metadata', value)

<mask token>


@pulumi.input_type
class HorizontalPodAutoscalingArgs:
    <mask token>
    <mask token>
    <mask token>


@pulumi.input_type
class HttpLoadBalancingArgs:

    def __init__(__self__, *, disabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration options for the HTTP (L7) load balancing controller addon, which makes it easy to set up HTTP load balancers for services in a cluster.
        :param pulumi.Input[bool] disabled: Whether the HTTP Load Balancing controller is enabled in the cluster. When enabled, it runs a small pod in the cluster that manages the load balancers.
        """
        if disabled is not None:
            pulumi.set(__self__, 'disabled', disabled)

    @property
    @pulumi.getter
    def disabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the HTTP Load Balancing controller is enabled in the cluster. When enabled, it runs a small pod in the cluster that manages the load balancers.
        """
        return pulumi.get(self, 'disabled')

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'disabled', value)


@pulumi.input_type
class IPAllocationPolicyArgs:

    def __init__(__self__, *, allow_route_overlap: Optional[pulumi.Input[
        bool]]=None, cluster_ipv4_cidr: Optional[pulumi.Input[str]]=None,
        cluster_ipv4_cidr_block: Optional[pulumi.Input[str]]=None,
        cluster_secondary_range_name: Optional[pulumi.Input[str]]=None,
        create_subnetwork: Optional[pulumi.Input[bool]]=None,
        ipv6_access_type: Optional[pulumi.Input[
        'IPAllocationPolicyIpv6AccessType']]=None, node_ipv4_cidr: Optional
        [pulumi.Input[str]]=None, node_ipv4_cidr_block: Optional[pulumi.
        Input[str]]=None, pod_cidr_overprovision_config: Optional[pulumi.
        Input['PodCIDROverprovisionConfigArgs']]=None, services_ipv4_cidr:
        Optional[pulumi.Input[str]]=None, services_ipv4_cidr_block:
        Optional[pulumi.Input[str]]=None, services_secondary_range_name:
        Optional[pulumi.Input[str]]=None, stack_type: Optional[pulumi.Input
        ['IPAllocationPolicyStackType']]=None, subnetwork_name: Optional[
        pulumi.Input[str]]=None, tpu_ipv4_cidr_block: Optional[pulumi.Input
        [str]]=None, use_ip_aliases: Optional[pulumi.Input[bool]]=None,
        use_routes: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for controlling how IPs are allocated in the cluster.
        :param pulumi.Input[bool] allow_route_overlap: If true, allow allocation of cluster CIDR ranges that overlap with certain kinds of network routes. By default we do not allow cluster CIDR ranges to intersect with any user declared routes. With allow_route_overlap == true, we allow overlapping with CIDR ranges that are larger than the cluster CIDR range. If this field is set to true, then cluster and services CIDRs must be fully-specified (e.g. `10.96.0.0/14`, but not `/14`), which means: 1) When `use_ip_aliases` is true, `cluster_ipv4_cidr_block` and `services_ipv4_cidr_block` must be fully-specified. 2) When `use_ip_aliases` is false, `cluster.cluster_ipv4_cidr` muse be fully-specified.
        :param pulumi.Input[str] cluster_ipv4_cidr: This field is deprecated, use cluster_ipv4_cidr_block.
        :param pulumi.Input[str] cluster_ipv4_cidr_block: The IP address range for the cluster pod IPs. If this field is set, then `cluster.cluster_ipv4_cidr` must be left blank. This field is only applicable when `use_ip_aliases` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        :param pulumi.Input[str] cluster_secondary_range_name: The name of the secondary range to be used for the cluster CIDR block. The secondary range will be used for pod IP addresses. This must be an existing secondary range associated with the cluster subnetwork. This field is only applicable with use_ip_aliases and create_subnetwork is false.
        :param pulumi.Input[bool] create_subnetwork: Whether a new subnetwork will be created automatically for the cluster. This field is only applicable when `use_ip_aliases` is true.
        :param pulumi.Input['IPAllocationPolicyIpv6AccessType'] ipv6_access_type: The ipv6 access type (internal or external) when create_subnetwork is true
        :param pulumi.Input[str] node_ipv4_cidr: This field is deprecated, use node_ipv4_cidr_block.
        :param pulumi.Input[str] node_ipv4_cidr_block: The IP address range of the instance IPs in this cluster. This is applicable only if `create_subnetwork` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        :param pulumi.Input['PodCIDROverprovisionConfigArgs'] pod_cidr_overprovision_config: [PRIVATE FIELD] Pod CIDR size overprovisioning config for the cluster. Pod CIDR size per node depends on max_pods_per_node. By default, the value of max_pods_per_node is doubled and then rounded off to next power of 2 to get the size of pod CIDR block per node. Example: max_pods_per_node of 30 would result in 64 IPs (/26). This config can disable the doubling of IPs (we still round off to next power of 2) Example: max_pods_per_node of 30 will result in 32 IPs (/27) when overprovisioning is disabled.
        :param pulumi.Input[str] services_ipv4_cidr: This field is deprecated, use services_ipv4_cidr_block.
        :param pulumi.Input[str] services_ipv4_cidr_block: The IP address range of the services IPs in this cluster. If blank, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        :param pulumi.Input[str] services_secondary_range_name: The name of the secondary range to be used as for the services CIDR block. The secondary range will be used for service ClusterIPs. This must be an existing secondary range associated with the cluster subnetwork. This field is only applicable with use_ip_aliases and create_subnetwork is false.
        :param pulumi.Input['IPAllocationPolicyStackType'] stack_type: IP stack type
        :param pulumi.Input[str] subnetwork_name: A custom subnetwork name to be used if `create_subnetwork` is true. If this field is empty, then an automatic name will be chosen for the new subnetwork.
        :param pulumi.Input[str] tpu_ipv4_cidr_block: The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.
        :param pulumi.Input[bool] use_ip_aliases: Whether alias IPs will be used for pod IPs in the cluster. This is used in conjunction with use_routes. It cannot be true if use_routes is true. If both use_ip_aliases and use_routes are false, then the server picks the default IP allocation mode
        :param pulumi.Input[bool] use_routes: Whether routes will be used for pod IPs in the cluster. This is used in conjunction with use_ip_aliases. It cannot be true if use_ip_aliases is true. If both use_ip_aliases and use_routes are false, then the server picks the default IP allocation mode
        """
        if allow_route_overlap is not None:
            pulumi.set(__self__, 'allow_route_overlap', allow_route_overlap)
        if cluster_ipv4_cidr is not None:
            warnings.warn(
                'This field is deprecated, use cluster_ipv4_cidr_block.',
                DeprecationWarning)
            pulumi.log.warn(
                'cluster_ipv4_cidr is deprecated: This field is deprecated, use cluster_ipv4_cidr_block.'
                )
        if cluster_ipv4_cidr is not None:
            pulumi.set(__self__, 'cluster_ipv4_cidr', cluster_ipv4_cidr)
        if cluster_ipv4_cidr_block is not None:
            pulumi.set(__self__, 'cluster_ipv4_cidr_block',
                cluster_ipv4_cidr_block)
        if cluster_secondary_range_name is not None:
            pulumi.set(__self__, 'cluster_secondary_range_name',
                cluster_secondary_range_name)
        if create_subnetwork is not None:
            pulumi.set(__self__, 'create_subnetwork', create_subnetwork)
        if ipv6_access_type is not None:
            pulumi.set(__self__, 'ipv6_access_type', ipv6_access_type)
        if node_ipv4_cidr is not None:
            warnings.warn('This field is deprecated, use node_ipv4_cidr_block.'
                , DeprecationWarning)
            pulumi.log.warn(
                'node_ipv4_cidr is deprecated: This field is deprecated, use node_ipv4_cidr_block.'
                )
        if node_ipv4_cidr is not None:
            pulumi.set(__self__, 'node_ipv4_cidr', node_ipv4_cidr)
        if node_ipv4_cidr_block is not None:
            pulumi.set(__self__, 'node_ipv4_cidr_block', node_ipv4_cidr_block)
        if pod_cidr_overprovision_config is not None:
            pulumi.set(__self__, 'pod_cidr_overprovision_config',
                pod_cidr_overprovision_config)
        if services_ipv4_cidr is not None:
            warnings.warn(
                'This field is deprecated, use services_ipv4_cidr_block.',
                DeprecationWarning)
            pulumi.log.warn(
                'services_ipv4_cidr is deprecated: This field is deprecated, use services_ipv4_cidr_block.'
                )
        if services_ipv4_cidr is not None:
            pulumi.set(__self__, 'services_ipv4_cidr', services_ipv4_cidr)
        if services_ipv4_cidr_block is not None:
            pulumi.set(__self__, 'services_ipv4_cidr_block',
                services_ipv4_cidr_block)
        if services_secondary_range_name is not None:
            pulumi.set(__self__, 'services_secondary_range_name',
                services_secondary_range_name)
        if stack_type is not None:
            pulumi.set(__self__, 'stack_type', stack_type)
        if subnetwork_name is not None:
            pulumi.set(__self__, 'subnetwork_name', subnetwork_name)
        if tpu_ipv4_cidr_block is not None:
            warnings.warn(
                'The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.'
                , DeprecationWarning)
            pulumi.log.warn(
                'tpu_ipv4_cidr_block is deprecated: The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.'
                )
        if tpu_ipv4_cidr_block is not None:
            pulumi.set(__self__, 'tpu_ipv4_cidr_block', tpu_ipv4_cidr_block)
        if use_ip_aliases is not None:
            pulumi.set(__self__, 'use_ip_aliases', use_ip_aliases)
        if use_routes is not None:
            pulumi.set(__self__, 'use_routes', use_routes)

    @property
    @pulumi.getter(name='allowRouteOverlap')
    def allow_route_overlap(self) ->Optional[pulumi.Input[bool]]:
        """
        If true, allow allocation of cluster CIDR ranges that overlap with certain kinds of network routes. By default we do not allow cluster CIDR ranges to intersect with any user declared routes. With allow_route_overlap == true, we allow overlapping with CIDR ranges that are larger than the cluster CIDR range. If this field is set to true, then cluster and services CIDRs must be fully-specified (e.g. `10.96.0.0/14`, but not `/14`), which means: 1) When `use_ip_aliases` is true, `cluster_ipv4_cidr_block` and `services_ipv4_cidr_block` must be fully-specified. 2) When `use_ip_aliases` is false, `cluster.cluster_ipv4_cidr` muse be fully-specified.
        """
        return pulumi.get(self, 'allow_route_overlap')

    @allow_route_overlap.setter
    def allow_route_overlap(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'allow_route_overlap', value)

    @property
    @pulumi.getter(name='clusterIpv4Cidr')
    def cluster_ipv4_cidr(self) ->Optional[pulumi.Input[str]]:
        """
        This field is deprecated, use cluster_ipv4_cidr_block.
        """
        warnings.warn('This field is deprecated, use cluster_ipv4_cidr_block.',
            DeprecationWarning)
        pulumi.log.warn(
            'cluster_ipv4_cidr is deprecated: This field is deprecated, use cluster_ipv4_cidr_block.'
            )
        return pulumi.get(self, 'cluster_ipv4_cidr')

    @cluster_ipv4_cidr.setter
    def cluster_ipv4_cidr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'cluster_ipv4_cidr', value)

    @property
    @pulumi.getter(name='clusterIpv4CidrBlock')
    def cluster_ipv4_cidr_block(self) ->Optional[pulumi.Input[str]]:
        """
        The IP address range for the cluster pod IPs. If this field is set, then `cluster.cluster_ipv4_cidr` must be left blank. This field is only applicable when `use_ip_aliases` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        """
        return pulumi.get(self, 'cluster_ipv4_cidr_block')

    @cluster_ipv4_cidr_block.setter
    def cluster_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'cluster_ipv4_cidr_block', value)

    @property
    @pulumi.getter(name='clusterSecondaryRangeName')
    def cluster_secondary_range_name(self) ->Optional[pulumi.Input[str]]:
        """
        The name of the secondary range to be used for the cluster CIDR block. The secondary range will be used for pod IP addresses. This must be an existing secondary range associated with the cluster subnetwork. This field is only applicable with use_ip_aliases and create_subnetwork is false.
        """
        return pulumi.get(self, 'cluster_secondary_range_name')

    @cluster_secondary_range_name.setter
    def cluster_secondary_range_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'cluster_secondary_range_name', value)

    @property
    @pulumi.getter(name='createSubnetwork')
    def create_subnetwork(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether a new subnetwork will be created automatically for the cluster. This field is only applicable when `use_ip_aliases` is true.
        """
        return pulumi.get(self, 'create_subnetwork')

    @create_subnetwork.setter
    def create_subnetwork(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'create_subnetwork', value)

    @property
    @pulumi.getter(name='ipv6AccessType')
    def ipv6_access_type(self) ->Optional[pulumi.Input[
        'IPAllocationPolicyIpv6AccessType']]:
        """
        The ipv6 access type (internal or external) when create_subnetwork is true
        """
        return pulumi.get(self, 'ipv6_access_type')

    @ipv6_access_type.setter
    def ipv6_access_type(self, value: Optional[pulumi.Input[
        'IPAllocationPolicyIpv6AccessType']]):
        pulumi.set(self, 'ipv6_access_type', value)

    @property
    @pulumi.getter(name='nodeIpv4Cidr')
    def node_ipv4_cidr(self) ->Optional[pulumi.Input[str]]:
        """
        This field is deprecated, use node_ipv4_cidr_block.
        """
        warnings.warn('This field is deprecated, use node_ipv4_cidr_block.',
            DeprecationWarning)
        pulumi.log.warn(
            'node_ipv4_cidr is deprecated: This field is deprecated, use node_ipv4_cidr_block.'
            )
        return pulumi.get(self, 'node_ipv4_cidr')

    @node_ipv4_cidr.setter
    def node_ipv4_cidr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'node_ipv4_cidr', value)

    @property
    @pulumi.getter(name='nodeIpv4CidrBlock')
    def node_ipv4_cidr_block(self) ->Optional[pulumi.Input[str]]:
        """
        The IP address range of the instance IPs in this cluster. This is applicable only if `create_subnetwork` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        """
        return pulumi.get(self, 'node_ipv4_cidr_block')

    @node_ipv4_cidr_block.setter
    def node_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'node_ipv4_cidr_block', value)

    @property
    @pulumi.getter(name='podCidrOverprovisionConfig')
    def pod_cidr_overprovision_config(self) ->Optional[pulumi.Input[
        'PodCIDROverprovisionConfigArgs']]:
        """
        [PRIVATE FIELD] Pod CIDR size overprovisioning config for the cluster. Pod CIDR size per node depends on max_pods_per_node. By default, the value of max_pods_per_node is doubled and then rounded off to next power of 2 to get the size of pod CIDR block per node. Example: max_pods_per_node of 30 would result in 64 IPs (/26). This config can disable the doubling of IPs (we still round off to next power of 2) Example: max_pods_per_node of 30 will result in 32 IPs (/27) when overprovisioning is disabled.
        """
        return pulumi.get(self, 'pod_cidr_overprovision_config')

    @pod_cidr_overprovision_config.setter
    def pod_cidr_overprovision_config(self, value: Optional[pulumi.Input[
        'PodCIDROverprovisionConfigArgs']]):
        pulumi.set(self, 'pod_cidr_overprovision_config', value)

    @property
    @pulumi.getter(name='servicesIpv4Cidr')
    def services_ipv4_cidr(self) ->Optional[pulumi.Input[str]]:
        """
        This field is deprecated, use services_ipv4_cidr_block.
        """
        warnings.warn('This field is deprecated, use services_ipv4_cidr_block.'
            , DeprecationWarning)
        pulumi.log.warn(
            'services_ipv4_cidr is deprecated: This field is deprecated, use services_ipv4_cidr_block.'
            )
        return pulumi.get(self, 'services_ipv4_cidr')

    @services_ipv4_cidr.setter
    def services_ipv4_cidr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'services_ipv4_cidr', value)

    @property
    @pulumi.getter(name='servicesIpv4CidrBlock')
    def services_ipv4_cidr_block(self) ->Optional[pulumi.Input[str]]:
        """
        The IP address range of the services IPs in this cluster. If blank, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        """
        return pulumi.get(self, 'services_ipv4_cidr_block')

    @services_ipv4_cidr_block.setter
    def services_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'services_ipv4_cidr_block', value)

    @property
    @pulumi.getter(name='servicesSecondaryRangeName')
    def services_secondary_range_name(self) ->Optional[pulumi.Input[str]]:
        """
        The name of the secondary range to be used as for the services CIDR block. The secondary range will be used for service ClusterIPs. This must be an existing secondary range associated with the cluster subnetwork. This field is only applicable with use_ip_aliases and create_subnetwork is false.
        """
        return pulumi.get(self, 'services_secondary_range_name')

    @services_secondary_range_name.setter
    def services_secondary_range_name(self, value: Optional[pulumi.Input[str]]
        ):
        pulumi.set(self, 'services_secondary_range_name', value)

    @property
    @pulumi.getter(name='stackType')
    def stack_type(self) ->Optional[pulumi.Input['IPAllocationPolicyStackType']
        ]:
        """
        IP stack type
        """
        return pulumi.get(self, 'stack_type')

    @stack_type.setter
    def stack_type(self, value: Optional[pulumi.Input[
        'IPAllocationPolicyStackType']]):
        pulumi.set(self, 'stack_type', value)

    @property
    @pulumi.getter(name='subnetworkName')
    def subnetwork_name(self) ->Optional[pulumi.Input[str]]:
        """
        A custom subnetwork name to be used if `create_subnetwork` is true. If this field is empty, then an automatic name will be chosen for the new subnetwork.
        """
        return pulumi.get(self, 'subnetwork_name')

    @subnetwork_name.setter
    def subnetwork_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'subnetwork_name', value)

    @property
    @pulumi.getter(name='tpuIpv4CidrBlock')
    def tpu_ipv4_cidr_block(self) ->Optional[pulumi.Input[str]]:
        """
        The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.
        """
        warnings.warn(
            'The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.'
            , DeprecationWarning)
        pulumi.log.warn(
            'tpu_ipv4_cidr_block is deprecated: The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.'
            )
        return pulumi.get(self, 'tpu_ipv4_cidr_block')

    @tpu_ipv4_cidr_block.setter
    def tpu_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'tpu_ipv4_cidr_block', value)

    @property
    @pulumi.getter(name='useIpAliases')
    def use_ip_aliases(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether alias IPs will be used for pod IPs in the cluster. This is used in conjunction with use_routes. It cannot be true if use_routes is true. If both use_ip_aliases and use_routes are false, then the server picks the default IP allocation mode
        """
        return pulumi.get(self, 'use_ip_aliases')

    @use_ip_aliases.setter
    def use_ip_aliases(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'use_ip_aliases', value)

    @property
    @pulumi.getter(name='useRoutes')
    def use_routes(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether routes will be used for pod IPs in the cluster. This is used in conjunction with use_ip_aliases. It cannot be true if use_ip_aliases is true. If both use_ip_aliases and use_routes are false, then the server picks the default IP allocation mode
        """
        return pulumi.get(self, 'use_routes')

    @use_routes.setter
    def use_routes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'use_routes', value)


@pulumi.input_type
class IdentityServiceConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        IdentityServiceConfig is configuration for Identity Service which allows customers to use external identity providers with the K8S API
        :param pulumi.Input[bool] enabled: Whether to enable the Identity Service component
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether to enable the Identity Service component
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class IstioConfigArgs:

    def __init__(__self__, *, auth: Optional[pulumi.Input['IstioConfigAuth'
        ]]=None, disabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration options for Istio addon.
        :param pulumi.Input['IstioConfigAuth'] auth: The specified Istio auth mode, either none, or mutual TLS.
        :param pulumi.Input[bool] disabled: Whether Istio is enabled for this cluster.
        """
        if auth is not None:
            pulumi.set(__self__, 'auth', auth)
        if disabled is not None:
            pulumi.set(__self__, 'disabled', disabled)

    @property
    @pulumi.getter
    def auth(self) ->Optional[pulumi.Input['IstioConfigAuth']]:
        """
        The specified Istio auth mode, either none, or mutual TLS.
        """
        return pulumi.get(self, 'auth')

    @auth.setter
    def auth(self, value: Optional[pulumi.Input['IstioConfigAuth']]):
        pulumi.set(self, 'auth', value)

    @property
    @pulumi.getter
    def disabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Istio is enabled for this cluster.
        """
        return pulumi.get(self, 'disabled')

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'disabled', value)


@pulumi.input_type
class KalmConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration options for the KALM addon.
        :param pulumi.Input[bool] enabled: Whether KALM is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether KALM is enabled for this cluster.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class KubernetesDashboardArgs:

    def __init__(__self__, *, disabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for the Kubernetes Dashboard.
        :param pulumi.Input[bool] disabled: Whether the Kubernetes Dashboard is enabled for this cluster.
        """
        if disabled is not None:
            pulumi.set(__self__, 'disabled', disabled)

    @property
    @pulumi.getter
    def disabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the Kubernetes Dashboard is enabled for this cluster.
        """
        return pulumi.get(self, 'disabled')

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'disabled', value)


@pulumi.input_type
class LegacyAbacArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for the legacy Attribute Based Access Control authorization mode.
        :param pulumi.Input[bool] enabled: Whether the ABAC authorizer is enabled for this cluster. When enabled, identities in the system, including service accounts, nodes, and controllers, will have statically granted permissions beyond those provided by the RBAC configuration or IAM.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the ABAC authorizer is enabled for this cluster. When enabled, identities in the system, including service accounts, nodes, and controllers, will have statically granted permissions beyond those provided by the RBAC configuration or IAM.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class LinuxNodeConfigArgs:

    def __init__(__self__, *, cgroup_mode: Optional[pulumi.Input[
        'LinuxNodeConfigCgroupMode']]=None, sysctls: Optional[pulumi.Input[
        Mapping[str, pulumi.Input[str]]]]=None):
        """
        Parameters that can be configured on Linux nodes.
        :param pulumi.Input['LinuxNodeConfigCgroupMode'] cgroup_mode: cgroup_mode specifies the cgroup mode to be used on the node.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] sysctls: The Linux kernel parameters to be applied to the nodes and all pods running on the nodes. The following parameters are supported. net.core.busy_poll net.core.busy_read net.core.netdev_max_backlog net.core.rmem_max net.core.wmem_default net.core.wmem_max net.core.optmem_max net.core.somaxconn net.ipv4.tcp_rmem net.ipv4.tcp_wmem net.ipv4.tcp_tw_reuse
        """
        if cgroup_mode is not None:
            pulumi.set(__self__, 'cgroup_mode', cgroup_mode)
        if sysctls is not None:
            pulumi.set(__self__, 'sysctls', sysctls)

    @property
    @pulumi.getter(name='cgroupMode')
    def cgroup_mode(self) ->Optional[pulumi.Input['LinuxNodeConfigCgroupMode']
        ]:
        """
        cgroup_mode specifies the cgroup mode to be used on the node.
        """
        return pulumi.get(self, 'cgroup_mode')

    @cgroup_mode.setter
    def cgroup_mode(self, value: Optional[pulumi.Input[
        'LinuxNodeConfigCgroupMode']]):
        pulumi.set(self, 'cgroup_mode', value)

    @property
    @pulumi.getter
    def sysctls(self) ->Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]
        ]:
        """
        The Linux kernel parameters to be applied to the nodes and all pods running on the nodes. The following parameters are supported. net.core.busy_poll net.core.busy_read net.core.netdev_max_backlog net.core.rmem_max net.core.wmem_default net.core.wmem_max net.core.optmem_max net.core.somaxconn net.ipv4.tcp_rmem net.ipv4.tcp_wmem net.ipv4.tcp_tw_reuse
        """
        return pulumi.get(self, 'sysctls')

    @sysctls.setter
    def sysctls(self, value: Optional[pulumi.Input[Mapping[str, pulumi.
        Input[str]]]]):
        pulumi.set(self, 'sysctls', value)


@pulumi.input_type
class LocalNvmeSsdBlockConfigArgs:

    def __init__(__self__, *, local_ssd_count: Optional[pulumi.Input[int]]=None
        ):
        """
        LocalNvmeSsdBlockConfig contains configuration for using raw-block local NVMe SSDs
        :param pulumi.Input[int] local_ssd_count: The number of raw-block local NVMe SSD disks to be attached to the node. Each local SSD is 375 GB in size. If zero, it means no raw-block local NVMe SSD disks to be attached to the node. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        """
        if local_ssd_count is not None:
            pulumi.set(__self__, 'local_ssd_count', local_ssd_count)

    @property
    @pulumi.getter(name='localSsdCount')
    def local_ssd_count(self) ->Optional[pulumi.Input[int]]:
        """
        The number of raw-block local NVMe SSD disks to be attached to the node. Each local SSD is 375 GB in size. If zero, it means no raw-block local NVMe SSD disks to be attached to the node. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        """
        return pulumi.get(self, 'local_ssd_count')

    @local_ssd_count.setter
    def local_ssd_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'local_ssd_count', value)


@pulumi.input_type
class LoggingComponentConfigArgs:

    def __init__(__self__, *, enable_components: Optional[pulumi.Input[
        Sequence[pulumi.Input['LoggingComponentConfigEnableComponentsItem']
        ]]]=None):
        """
        LoggingComponentConfig is cluster logging component configuration.
        :param pulumi.Input[Sequence[pulumi.Input['LoggingComponentConfigEnableComponentsItem']]] enable_components: Select components to collect logs. An empty set would disable all logging.
        """
        if enable_components is not None:
            pulumi.set(__self__, 'enable_components', enable_components)

    @property
    @pulumi.getter(name='enableComponents')
    def enable_components(self) ->Optional[pulumi.Input[Sequence[pulumi.
        Input['LoggingComponentConfigEnableComponentsItem']]]]:
        """
        Select components to collect logs. An empty set would disable all logging.
        """
        return pulumi.get(self, 'enable_components')

    @enable_components.setter
    def enable_components(self, value: Optional[pulumi.Input[Sequence[
        pulumi.Input['LoggingComponentConfigEnableComponentsItem']]]]):
        pulumi.set(self, 'enable_components', value)


@pulumi.input_type
class LoggingConfigArgs:

    def __init__(__self__, *, component_config: Optional[pulumi.Input[
        'LoggingComponentConfigArgs']]=None):
        """
        LoggingConfig is cluster logging configuration.
        :param pulumi.Input['LoggingComponentConfigArgs'] component_config: Logging components configuration
        """
        if component_config is not None:
            pulumi.set(__self__, 'component_config', component_config)

    @property
    @pulumi.getter(name='componentConfig')
    def component_config(self) ->Optional[pulumi.Input[
        'LoggingComponentConfigArgs']]:
        """
        Logging components configuration
        """
        return pulumi.get(self, 'component_config')

    @component_config.setter
    def component_config(self, value: Optional[pulumi.Input[
        'LoggingComponentConfigArgs']]):
        pulumi.set(self, 'component_config', value)


@pulumi.input_type
class LoggingVariantConfigArgs:

    def __init__(__self__, *, variant: Optional[pulumi.Input[
        'LoggingVariantConfigVariant']]=None):
        """
        LoggingVariantConfig specifies the behaviour of the logging component.
        :param pulumi.Input['LoggingVariantConfigVariant'] variant: Logging variant deployed on nodes.
        """
        if variant is not None:
            pulumi.set(__self__, 'variant', variant)

    @property
    @pulumi.getter
    def variant(self) ->Optional[pulumi.Input['LoggingVariantConfigVariant']]:
        """
        Logging variant deployed on nodes.
        """
        return pulumi.get(self, 'variant')

    @variant.setter
    def variant(self, value: Optional[pulumi.Input[
        'LoggingVariantConfigVariant']]):
        pulumi.set(self, 'variant', value)


@pulumi.input_type
class MaintenanceExclusionOptionsArgs:

    def __init__(__self__, *, scope: Optional[pulumi.Input[
        'MaintenanceExclusionOptionsScope']]=None):
        """
        Represents the Maintenance exclusion option.
        :param pulumi.Input['MaintenanceExclusionOptionsScope'] scope: Scope specifies the upgrade scope which upgrades are blocked by the exclusion.
        """
        if scope is not None:
            pulumi.set(__self__, 'scope', scope)

    @property
    @pulumi.getter
    def scope(self) ->Optional[pulumi.Input['MaintenanceExclusionOptionsScope']
        ]:
        """
        Scope specifies the upgrade scope which upgrades are blocked by the exclusion.
        """
        return pulumi.get(self, 'scope')

    @scope.setter
    def scope(self, value: Optional[pulumi.Input[
        'MaintenanceExclusionOptionsScope']]):
        pulumi.set(self, 'scope', value)


@pulumi.input_type
class MaintenancePolicyArgs:

    def __init__(__self__, *, resource_version: Optional[pulumi.Input[str]]
        =None, window: Optional[pulumi.Input['MaintenanceWindowArgs']]=None):
        """
        MaintenancePolicy defines the maintenance policy to be used for the cluster.
        :param pulumi.Input[str] resource_version: A hash identifying the version of this policy, so that updates to fields of the policy won't accidentally undo intermediate changes (and so that users of the API unaware of some fields won't accidentally remove other fields). Make a `get()` request to the cluster to get the current resource version and include it with requests to set the policy.
        :param pulumi.Input['MaintenanceWindowArgs'] window: Specifies the maintenance window in which maintenance may be performed.
        """
        if resource_version is not None:
            pulumi.set(__self__, 'resource_version', resource_version)
        if window is not None:
            pulumi.set(__self__, 'window', window)

    @property
    @pulumi.getter(name='resourceVersion')
    def resource_version(self) ->Optional[pulumi.Input[str]]:
        """
        A hash identifying the version of this policy, so that updates to fields of the policy won't accidentally undo intermediate changes (and so that users of the API unaware of some fields won't accidentally remove other fields). Make a `get()` request to the cluster to get the current resource version and include it with requests to set the policy.
        """
        return pulumi.get(self, 'resource_version')

    @resource_version.setter
    def resource_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'resource_version', value)

    @property
    @pulumi.getter
    def window(self) ->Optional[pulumi.Input['MaintenanceWindowArgs']]:
        """
        Specifies the maintenance window in which maintenance may be performed.
        """
        return pulumi.get(self, 'window')

    @window.setter
    def window(self, value: Optional[pulumi.Input['MaintenanceWindowArgs']]):
        pulumi.set(self, 'window', value)


@pulumi.input_type
class MaintenanceWindowArgs:

    def __init__(__self__, *, daily_maintenance_window: Optional[pulumi.
        Input['DailyMaintenanceWindowArgs']]=None, maintenance_exclusions:
        Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]=None,
        recurring_window: Optional[pulumi.Input['RecurringTimeWindowArgs']]
        =None):
        """
        MaintenanceWindow defines the maintenance window to be used for the cluster.
        :param pulumi.Input['DailyMaintenanceWindowArgs'] daily_maintenance_window: DailyMaintenanceWindow specifies a daily maintenance operation window.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] maintenance_exclusions: Exceptions to maintenance window. Non-emergency maintenance should not occur in these windows.
        :param pulumi.Input['RecurringTimeWindowArgs'] recurring_window: RecurringWindow specifies some number of recurring time periods for maintenance to occur. The time windows may be overlapping. If no maintenance windows are set, maintenance can occur at any time.
        """
        if daily_maintenance_window is not None:
            pulumi.set(__self__, 'daily_maintenance_window',
                daily_maintenance_window)
        if maintenance_exclusions is not None:
            pulumi.set(__self__, 'maintenance_exclusions',
                maintenance_exclusions)
        if recurring_window is not None:
            pulumi.set(__self__, 'recurring_window', recurring_window)

    @property
    @pulumi.getter(name='dailyMaintenanceWindow')
    def daily_maintenance_window(self) ->Optional[pulumi.Input[
        'DailyMaintenanceWindowArgs']]:
        """
        DailyMaintenanceWindow specifies a daily maintenance operation window.
        """
        return pulumi.get(self, 'daily_maintenance_window')

    @daily_maintenance_window.setter
    def daily_maintenance_window(self, value: Optional[pulumi.Input[
        'DailyMaintenanceWindowArgs']]):
        pulumi.set(self, 'daily_maintenance_window', value)

    @property
    @pulumi.getter(name='maintenanceExclusions')
    def maintenance_exclusions(self) ->Optional[pulumi.Input[Mapping[str,
        pulumi.Input[str]]]]:
        """
        Exceptions to maintenance window. Non-emergency maintenance should not occur in these windows.
        """
        return pulumi.get(self, 'maintenance_exclusions')

    @maintenance_exclusions.setter
    def maintenance_exclusions(self, value: Optional[pulumi.Input[Mapping[
        str, pulumi.Input[str]]]]):
        pulumi.set(self, 'maintenance_exclusions', value)

    @property
    @pulumi.getter(name='recurringWindow')
    def recurring_window(self) ->Optional[pulumi.Input[
        'RecurringTimeWindowArgs']]:
        """
        RecurringWindow specifies some number of recurring time periods for maintenance to occur. The time windows may be overlapping. If no maintenance windows are set, maintenance can occur at any time.
        """
        return pulumi.get(self, 'recurring_window')

    @recurring_window.setter
    def recurring_window(self, value: Optional[pulumi.Input[
        'RecurringTimeWindowArgs']]):
        pulumi.set(self, 'recurring_window', value)


@pulumi.input_type
class ManagedPrometheusConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        ManagedPrometheusConfig defines the configuration for Google Cloud Managed Service for Prometheus.
        :param pulumi.Input[bool] enabled: Enable Managed Collection.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Enable Managed Collection.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class MasterAuthorizedNetworksConfigArgs:

    def __init__(__self__, *, cidr_blocks: Optional[pulumi.Input[Sequence[
        pulumi.Input['CidrBlockArgs']]]]=None, enabled: Optional[pulumi.
        Input[bool]]=None, gcp_public_cidrs_access_enabled: Optional[pulumi
        .Input[bool]]=None):
        """
        Configuration options for the master authorized networks feature. Enabled master authorized networks will disallow all external traffic to access Kubernetes master through HTTPS except traffic from the given CIDR blocks, Google Compute Engine Public IPs and Google Prod IPs.
        :param pulumi.Input[Sequence[pulumi.Input['CidrBlockArgs']]] cidr_blocks: cidr_blocks define up to 10 external networks that could access Kubernetes master through HTTPS.
        :param pulumi.Input[bool] enabled: Whether or not master authorized networks is enabled.
        :param pulumi.Input[bool] gcp_public_cidrs_access_enabled: Whether master is accessbile via Google Compute Engine Public IP addresses.
        """
        if cidr_blocks is not None:
            pulumi.set(__self__, 'cidr_blocks', cidr_blocks)
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)
        if gcp_public_cidrs_access_enabled is not None:
            pulumi.set(__self__, 'gcp_public_cidrs_access_enabled',
                gcp_public_cidrs_access_enabled)

    @property
    @pulumi.getter(name='cidrBlocks')
    def cidr_blocks(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[
        'CidrBlockArgs']]]]:
        """
        cidr_blocks define up to 10 external networks that could access Kubernetes master through HTTPS.
        """
        return pulumi.get(self, 'cidr_blocks')

    @cidr_blocks.setter
    def cidr_blocks(self, value: Optional[pulumi.Input[Sequence[pulumi.
        Input['CidrBlockArgs']]]]):
        pulumi.set(self, 'cidr_blocks', value)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether or not master authorized networks is enabled.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)

    @property
    @pulumi.getter(name='gcpPublicCidrsAccessEnabled')
    def gcp_public_cidrs_access_enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether master is accessbile via Google Compute Engine Public IP addresses.
        """
        return pulumi.get(self, 'gcp_public_cidrs_access_enabled')

    @gcp_public_cidrs_access_enabled.setter
    def gcp_public_cidrs_access_enabled(self, value: Optional[pulumi.Input[
        bool]]):
        pulumi.set(self, 'gcp_public_cidrs_access_enabled', value)


@pulumi.input_type
class MasterAuthArgs:

    def __init__(__self__, *, client_certificate_config: Optional[pulumi.
        Input['ClientCertificateConfigArgs']]=None, cluster_ca_certificate:
        Optional[pulumi.Input[str]]=None, password: Optional[pulumi.Input[
        str]]=None, username: Optional[pulumi.Input[str]]=None):
        """
        The authentication information for accessing the master endpoint. Authentication can be done using HTTP basic auth or using client certificates.
        :param pulumi.Input['ClientCertificateConfigArgs'] client_certificate_config: Configuration for client certificate authentication on the cluster. For clusters before v1.12, if no configuration is specified, a client certificate is issued.
        :param pulumi.Input[str] password: The password to use for HTTP basic authentication to the master endpoint. Because the master endpoint is open to the Internet, you should create a strong password. If a password is provided for cluster creation, username must be non-empty. Warning: basic authentication is deprecated, and will be removed in GKE control plane versions 1.19 and newer. For a list of recommended authentication methods, see: https://cloud.google.com/kubernetes-engine/docs/how-to/api-server-authentication
        :param pulumi.Input[str] username: The username to use for HTTP basic authentication to the master endpoint. For clusters v1.6.0 and later, basic authentication can be disabled by leaving username unspecified (or setting it to the empty string). Warning: basic authentication is deprecated, and will be removed in GKE control plane versions 1.19 and newer. For a list of recommended authentication methods, see: https://cloud.google.com/kubernetes-engine/docs/how-to/api-server-authentication
        """
        if client_certificate_config is not None:
            pulumi.set(__self__, 'client_certificate_config',
                client_certificate_config)
        if cluster_ca_certificate is not None:
            pulumi.set(__self__, 'cluster_ca_certificate',
                cluster_ca_certificate)
        if password is not None:
            pulumi.set(__self__, 'password', password)
        if username is not None:
            pulumi.set(__self__, 'username', username)

    @property
    @pulumi.getter(name='clientCertificateConfig')
    def client_certificate_config(self) ->Optional[pulumi.Input[
        'ClientCertificateConfigArgs']]:
        """
        Configuration for client certificate authentication on the cluster. For clusters before v1.12, if no configuration is specified, a client certificate is issued.
        """
        return pulumi.get(self, 'client_certificate_config')

    @client_certificate_config.setter
    def client_certificate_config(self, value: Optional[pulumi.Input[
        'ClientCertificateConfigArgs']]):
        pulumi.set(self, 'client_certificate_config', value)

    @property
    @pulumi.getter(name='clusterCaCertificate')
    def cluster_ca_certificate(self) ->Optional[pulumi.Input[str]]:
        return pulumi.get(self, 'cluster_ca_certificate')

    @cluster_ca_certificate.setter
    def cluster_ca_certificate(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'cluster_ca_certificate', value)

    @property
    @pulumi.getter
    def password(self) ->Optional[pulumi.Input[str]]:
        """
        The password to use for HTTP basic authentication to the master endpoint. Because the master endpoint is open to the Internet, you should create a strong password. If a password is provided for cluster creation, username must be non-empty. Warning: basic authentication is deprecated, and will be removed in GKE control plane versions 1.19 and newer. For a list of recommended authentication methods, see: https://cloud.google.com/kubernetes-engine/docs/how-to/api-server-authentication
        """
        return pulumi.get(self, 'password')

    @password.setter
    def password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'password', value)

    @property
    @pulumi.getter
    def username(self) ->Optional[pulumi.Input[str]]:
        """
        The username to use for HTTP basic authentication to the master endpoint. For clusters v1.6.0 and later, basic authentication can be disabled by leaving username unspecified (or setting it to the empty string). Warning: basic authentication is deprecated, and will be removed in GKE control plane versions 1.19 and newer. For a list of recommended authentication methods, see: https://cloud.google.com/kubernetes-engine/docs/how-to/api-server-authentication
        """
        return pulumi.get(self, 'username')

    @username.setter
    def username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'username', value)


@pulumi.input_type
class MasterArgs:

    def __init__(__self__):
        """
        Master is the configuration for components on master.
        """
        pass


@pulumi.input_type
class MaxPodsConstraintArgs:

    def __init__(__self__, *, max_pods_per_node: Optional[pulumi.Input[str]
        ]=None):
        """
        Constraints applied to pods.
        :param pulumi.Input[str] max_pods_per_node: Constraint enforced on the max num of pods per node.
        """
        if max_pods_per_node is not None:
            pulumi.set(__self__, 'max_pods_per_node', max_pods_per_node)

    @property
    @pulumi.getter(name='maxPodsPerNode')
    def max_pods_per_node(self) ->Optional[pulumi.Input[str]]:
        """
        Constraint enforced on the max num of pods per node.
        """
        return pulumi.get(self, 'max_pods_per_node')

    @max_pods_per_node.setter
    def max_pods_per_node(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'max_pods_per_node', value)


@pulumi.input_type
class MeshCertificatesArgs:

    def __init__(__self__, *, enable_certificates: Optional[pulumi.Input[
        bool]]=None):
        """
        Configuration for issuance of mTLS keys and certificates to Kubernetes pods.
        :param pulumi.Input[bool] enable_certificates: enable_certificates controls issuance of workload mTLS certificates. If set, the GKE Workload Identity Certificates controller and node agent will be deployed in the cluster, which can then be configured by creating a WorkloadCertificateConfig Custom Resource. Requires Workload Identity (workload_pool must be non-empty).
        """
        if enable_certificates is not None:
            pulumi.set(__self__, 'enable_certificates', enable_certificates)

    @property
    @pulumi.getter(name='enableCertificates')
    def enable_certificates(self) ->Optional[pulumi.Input[bool]]:
        """
        enable_certificates controls issuance of workload mTLS certificates. If set, the GKE Workload Identity Certificates controller and node agent will be deployed in the cluster, which can then be configured by creating a WorkloadCertificateConfig Custom Resource. Requires Workload Identity (workload_pool must be non-empty).
        """
        return pulumi.get(self, 'enable_certificates')

    @enable_certificates.setter
    def enable_certificates(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_certificates', value)


@pulumi.input_type
class MonitoringComponentConfigArgs:

    def __init__(__self__, *, enable_components: Optional[pulumi.Input[
        Sequence[pulumi.Input[
        'MonitoringComponentConfigEnableComponentsItem']]]]=None):
        """
        MonitoringComponentConfig is cluster monitoring component configuration.
        :param pulumi.Input[Sequence[pulumi.Input['MonitoringComponentConfigEnableComponentsItem']]] enable_components: Select components to collect metrics. An empty set would disable all monitoring.
        """
        if enable_components is not None:
            pulumi.set(__self__, 'enable_components', enable_components)

    @property
    @pulumi.getter(name='enableComponents')
    def enable_components(self) ->Optional[pulumi.Input[Sequence[pulumi.
        Input['MonitoringComponentConfigEnableComponentsItem']]]]:
        """
        Select components to collect metrics. An empty set would disable all monitoring.
        """
        return pulumi.get(self, 'enable_components')

    @enable_components.setter
    def enable_components(self, value: Optional[pulumi.Input[Sequence[
        pulumi.Input['MonitoringComponentConfigEnableComponentsItem']]]]):
        pulumi.set(self, 'enable_components', value)


@pulumi.input_type
class MonitoringConfigArgs:

    def __init__(__self__, *, component_config: Optional[pulumi.Input[
        'MonitoringComponentConfigArgs']]=None, managed_prometheus_config:
        Optional[pulumi.Input['ManagedPrometheusConfigArgs']]=None):
        """
        MonitoringConfig is cluster monitoring configuration.
        :param pulumi.Input['MonitoringComponentConfigArgs'] component_config: Monitoring components configuration
        :param pulumi.Input['ManagedPrometheusConfigArgs'] managed_prometheus_config: Enable Google Cloud Managed Service for Prometheus in the cluster.
        """
        if component_config is not None:
            pulumi.set(__self__, 'component_config', component_config)
        if managed_prometheus_config is not None:
            pulumi.set(__self__, 'managed_prometheus_config',
                managed_prometheus_config)

    @property
    @pulumi.getter(name='componentConfig')
    def component_config(self) ->Optional[pulumi.Input[
        'MonitoringComponentConfigArgs']]:
        """
        Monitoring components configuration
        """
        return pulumi.get(self, 'component_config')

    @component_config.setter
    def component_config(self, value: Optional[pulumi.Input[
        'MonitoringComponentConfigArgs']]):
        pulumi.set(self, 'component_config', value)

    @property
    @pulumi.getter(name='managedPrometheusConfig')
    def managed_prometheus_config(self) ->Optional[pulumi.Input[
        'ManagedPrometheusConfigArgs']]:
        """
        Enable Google Cloud Managed Service for Prometheus in the cluster.
        """
        return pulumi.get(self, 'managed_prometheus_config')

    @managed_prometheus_config.setter
    def managed_prometheus_config(self, value: Optional[pulumi.Input[
        'ManagedPrometheusConfigArgs']]):
        pulumi.set(self, 'managed_prometheus_config', value)


@pulumi.input_type
class NetworkConfigArgs:

    def __init__(__self__, *, datapath_provider: Optional[pulumi.Input[
        'NetworkConfigDatapathProvider']]=None, default_snat_status:
        Optional[pulumi.Input['DefaultSnatStatusArgs']]=None, dns_config:
        Optional[pulumi.Input['DNSConfigArgs']]=None,
        enable_intra_node_visibility: Optional[pulumi.Input[bool]]=None,
        enable_l4ilb_subsetting: Optional[pulumi.Input[bool]]=None,
        gateway_api_config: Optional[pulumi.Input['GatewayAPIConfigArgs']]=
        None, private_ipv6_google_access: Optional[pulumi.Input[
        'NetworkConfigPrivateIpv6GoogleAccess']]=None,
        service_external_ips_config: Optional[pulumi.Input[
        'ServiceExternalIPsConfigArgs']]=None):
        """
        NetworkConfig reports the relative names of network & subnetwork.
        :param pulumi.Input['NetworkConfigDatapathProvider'] datapath_provider: The desired datapath provider for this cluster. By default, uses the IPTables-based kube-proxy implementation.
        :param pulumi.Input['DefaultSnatStatusArgs'] default_snat_status: Whether the cluster disables default in-node sNAT rules. In-node sNAT rules will be disabled when default_snat_status is disabled. When disabled is set to false, default IP masquerade rules will be applied to the nodes to prevent sNAT on cluster internal traffic.
        :param pulumi.Input['DNSConfigArgs'] dns_config: DNSConfig contains clusterDNS config for this cluster.
        :param pulumi.Input[bool] enable_intra_node_visibility: Whether Intra-node visibility is enabled for this cluster. This makes same node pod to pod traffic visible for VPC network.
        :param pulumi.Input[bool] enable_l4ilb_subsetting: Whether L4ILB Subsetting is enabled for this cluster.
        :param pulumi.Input['GatewayAPIConfigArgs'] gateway_api_config: GatewayAPIConfig contains the desired config of Gateway API on this cluster.
        :param pulumi.Input['NetworkConfigPrivateIpv6GoogleAccess'] private_ipv6_google_access: The desired state of IPv6 connectivity to Google Services. By default, no private IPv6 access to or from Google Services (all access will be via IPv4)
        :param pulumi.Input['ServiceExternalIPsConfigArgs'] service_external_ips_config: ServiceExternalIPsConfig specifies if services with externalIPs field are blocked or not.
        """
        if datapath_provider is not None:
            pulumi.set(__self__, 'datapath_provider', datapath_provider)
        if default_snat_status is not None:
            pulumi.set(__self__, 'default_snat_status', default_snat_status)
        if dns_config is not None:
            pulumi.set(__self__, 'dns_config', dns_config)
        if enable_intra_node_visibility is not None:
            pulumi.set(__self__, 'enable_intra_node_visibility',
                enable_intra_node_visibility)
        if enable_l4ilb_subsetting is not None:
            pulumi.set(__self__, 'enable_l4ilb_subsetting',
                enable_l4ilb_subsetting)
        if gateway_api_config is not None:
            pulumi.set(__self__, 'gateway_api_config', gateway_api_config)
        if private_ipv6_google_access is not None:
            pulumi.set(__self__, 'private_ipv6_google_access',
                private_ipv6_google_access)
        if service_external_ips_config is not None:
            pulumi.set(__self__, 'service_external_ips_config',
                service_external_ips_config)

    @property
    @pulumi.getter(name='datapathProvider')
    def datapath_provider(self) ->Optional[pulumi.Input[
        'NetworkConfigDatapathProvider']]:
        """
        The desired datapath provider for this cluster. By default, uses the IPTables-based kube-proxy implementation.
        """
        return pulumi.get(self, 'datapath_provider')

    @datapath_provider.setter
    def datapath_provider(self, value: Optional[pulumi.Input[
        'NetworkConfigDatapathProvider']]):
        pulumi.set(self, 'datapath_provider', value)

    @property
    @pulumi.getter(name='defaultSnatStatus')
    def default_snat_status(self) ->Optional[pulumi.Input[
        'DefaultSnatStatusArgs']]:
        """
        Whether the cluster disables default in-node sNAT rules. In-node sNAT rules will be disabled when default_snat_status is disabled. When disabled is set to false, default IP masquerade rules will be applied to the nodes to prevent sNAT on cluster internal traffic.
        """
        return pulumi.get(self, 'default_snat_status')

    @default_snat_status.setter
    def default_snat_status(self, value: Optional[pulumi.Input[
        'DefaultSnatStatusArgs']]):
        pulumi.set(self, 'default_snat_status', value)

    @property
    @pulumi.getter(name='dnsConfig')
    def dns_config(self) ->Optional[pulumi.Input['DNSConfigArgs']]:
        """
        DNSConfig contains clusterDNS config for this cluster.
        """
        return pulumi.get(self, 'dns_config')

    @dns_config.setter
    def dns_config(self, value: Optional[pulumi.Input['DNSConfigArgs']]):
        pulumi.set(self, 'dns_config', value)

    @property
    @pulumi.getter(name='enableIntraNodeVisibility')
    def enable_intra_node_visibility(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Intra-node visibility is enabled for this cluster. This makes same node pod to pod traffic visible for VPC network.
        """
        return pulumi.get(self, 'enable_intra_node_visibility')

    @enable_intra_node_visibility.setter
    def enable_intra_node_visibility(self, value: Optional[pulumi.Input[bool]]
        ):
        pulumi.set(self, 'enable_intra_node_visibility', value)

    @property
    @pulumi.getter(name='enableL4ilbSubsetting')
    def enable_l4ilb_subsetting(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether L4ILB Subsetting is enabled for this cluster.
        """
        return pulumi.get(self, 'enable_l4ilb_subsetting')

    @enable_l4ilb_subsetting.setter
    def enable_l4ilb_subsetting(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_l4ilb_subsetting', value)

    @property
    @pulumi.getter(name='gatewayApiConfig')
    def gateway_api_config(self) ->Optional[pulumi.Input[
        'GatewayAPIConfigArgs']]:
        """
        GatewayAPIConfig contains the desired config of Gateway API on this cluster.
        """
        return pulumi.get(self, 'gateway_api_config')

    @gateway_api_config.setter
    def gateway_api_config(self, value: Optional[pulumi.Input[
        'GatewayAPIConfigArgs']]):
        pulumi.set(self, 'gateway_api_config', value)

    @property
    @pulumi.getter(name='privateIpv6GoogleAccess')
    def private_ipv6_google_access(self) ->Optional[pulumi.Input[
        'NetworkConfigPrivateIpv6GoogleAccess']]:
        """
        The desired state of IPv6 connectivity to Google Services. By default, no private IPv6 access to or from Google Services (all access will be via IPv4)
        """
        return pulumi.get(self, 'private_ipv6_google_access')

    @private_ipv6_google_access.setter
    def private_ipv6_google_access(self, value: Optional[pulumi.Input[
        'NetworkConfigPrivateIpv6GoogleAccess']]):
        pulumi.set(self, 'private_ipv6_google_access', value)

    @property
    @pulumi.getter(name='serviceExternalIpsConfig')
    def service_external_ips_config(self) ->Optional[pulumi.Input[
        'ServiceExternalIPsConfigArgs']]:
        """
        ServiceExternalIPsConfig specifies if services with externalIPs field are blocked or not.
        """
        return pulumi.get(self, 'service_external_ips_config')

    @service_external_ips_config.setter
    def service_external_ips_config(self, value: Optional[pulumi.Input[
        'ServiceExternalIPsConfigArgs']]):
        pulumi.set(self, 'service_external_ips_config', value)


@pulumi.input_type
class NetworkPerformanceConfigArgs:

    def __init__(__self__, *, external_ip_egress_bandwidth_tier: Optional[
        pulumi.Input[
        'NetworkPerformanceConfigExternalIpEgressBandwidthTier']]=None,
        total_egress_bandwidth_tier: Optional[pulumi.Input[
        'NetworkPerformanceConfigTotalEgressBandwidthTier']]=None):
        """
        Configuration of all network bandwidth tiers
        :param pulumi.Input['NetworkPerformanceConfigExternalIpEgressBandwidthTier'] external_ip_egress_bandwidth_tier: Specifies the network bandwidth tier for the NodePool for traffic to external/public IP addresses.
        :param pulumi.Input['NetworkPerformanceConfigTotalEgressBandwidthTier'] total_egress_bandwidth_tier: Specifies the total network bandwidth tier for the NodePool.
        """
        if external_ip_egress_bandwidth_tier is not None:
            pulumi.set(__self__, 'external_ip_egress_bandwidth_tier',
                external_ip_egress_bandwidth_tier)
        if total_egress_bandwidth_tier is not None:
            pulumi.set(__self__, 'total_egress_bandwidth_tier',
                total_egress_bandwidth_tier)

    @property
    @pulumi.getter(name='externalIpEgressBandwidthTier')
    def external_ip_egress_bandwidth_tier(self) ->Optional[pulumi.Input[
        'NetworkPerformanceConfigExternalIpEgressBandwidthTier']]:
        """
        Specifies the network bandwidth tier for the NodePool for traffic to external/public IP addresses.
        """
        return pulumi.get(self, 'external_ip_egress_bandwidth_tier')

    @external_ip_egress_bandwidth_tier.setter
    def external_ip_egress_bandwidth_tier(self, value: Optional[pulumi.
        Input['NetworkPerformanceConfigExternalIpEgressBandwidthTier']]):
        pulumi.set(self, 'external_ip_egress_bandwidth_tier', value)

    @property
    @pulumi.getter(name='totalEgressBandwidthTier')
    def total_egress_bandwidth_tier(self) ->Optional[pulumi.Input[
        'NetworkPerformanceConfigTotalEgressBandwidthTier']]:
        """
        Specifies the total network bandwidth tier for the NodePool.
        """
        return pulumi.get(self, 'total_egress_bandwidth_tier')

    @total_egress_bandwidth_tier.setter
    def total_egress_bandwidth_tier(self, value: Optional[pulumi.Input[
        'NetworkPerformanceConfigTotalEgressBandwidthTier']]):
        pulumi.set(self, 'total_egress_bandwidth_tier', value)


@pulumi.input_type
class NetworkPolicyConfigArgs:

    def __init__(__self__, *, disabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for NetworkPolicy. This only tracks whether the addon is enabled or not on the Master, it does not track whether network policy is enabled for the nodes.
        :param pulumi.Input[bool] disabled: Whether NetworkPolicy is enabled for this cluster.
        """
        if disabled is not None:
            pulumi.set(__self__, 'disabled', disabled)

    @property
    @pulumi.getter
    def disabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether NetworkPolicy is enabled for this cluster.
        """
        return pulumi.get(self, 'disabled')

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'disabled', value)


@pulumi.input_type
class NetworkPolicyArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None,
        provider: Optional[pulumi.Input['NetworkPolicyProvider']]=None):
        """
        Configuration options for the NetworkPolicy feature. https://kubernetes.io/docs/concepts/services-networking/networkpolicies/
        :param pulumi.Input[bool] enabled: Whether network policy is enabled on the cluster.
        :param pulumi.Input['NetworkPolicyProvider'] provider: The selected network policy provider.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)
        if provider is not None:
            pulumi.set(__self__, 'provider', provider)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether network policy is enabled on the cluster.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)

    @property
    @pulumi.getter
    def provider(self) ->Optional[pulumi.Input['NetworkPolicyProvider']]:
        """
        The selected network policy provider.
        """
        return pulumi.get(self, 'provider')

    @provider.setter
    def provider(self, value: Optional[pulumi.Input['NetworkPolicyProvider']]):
        pulumi.set(self, 'provider', value)


@pulumi.input_type
class NetworkTagsArgs:

    def __init__(__self__, *, tags: Optional[pulumi.Input[Sequence[pulumi.
        Input[str]]]]=None):
        """
        Collection of Compute Engine network tags that can be applied to a node's underlying VM instance. (See `tags` field in [`NodeConfig`](/kubernetes-engine/docs/reference/rest/v1/NodeConfig)).
        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: List of network tags.
        """
        if tags is not None:
            pulumi.set(__self__, 'tags', tags)

    @property
    @pulumi.getter
    def tags(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of network tags.
        """
        return pulumi.get(self, 'tags')

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, 'tags', value)


@pulumi.input_type
class NodeConfigDefaultsArgs:

    def __init__(__self__, *, gcfs_config: Optional[pulumi.Input[
        'GcfsConfigArgs']]=None, logging_config: Optional[pulumi.Input[
        'NodePoolLoggingConfigArgs']]=None):
        """
        Subset of NodeConfig message that has defaults.
        :param pulumi.Input['GcfsConfigArgs'] gcfs_config: GCFS (Google Container File System, also known as Riptide) options.
        :param pulumi.Input['NodePoolLoggingConfigArgs'] logging_config: Logging configuration for node pools.
        """
        if gcfs_config is not None:
            pulumi.set(__self__, 'gcfs_config', gcfs_config)
        if logging_config is not None:
            pulumi.set(__self__, 'logging_config', logging_config)

    @property
    @pulumi.getter(name='gcfsConfig')
    def gcfs_config(self) ->Optional[pulumi.Input['GcfsConfigArgs']]:
        """
        GCFS (Google Container File System, also known as Riptide) options.
        """
        return pulumi.get(self, 'gcfs_config')

    @gcfs_config.setter
    def gcfs_config(self, value: Optional[pulumi.Input['GcfsConfigArgs']]):
        pulumi.set(self, 'gcfs_config', value)

    @property
    @pulumi.getter(name='loggingConfig')
    def logging_config(self) ->Optional[pulumi.Input[
        'NodePoolLoggingConfigArgs']]:
        """
        Logging configuration for node pools.
        """
        return pulumi.get(self, 'logging_config')

    @logging_config.setter
    def logging_config(self, value: Optional[pulumi.Input[
        'NodePoolLoggingConfigArgs']]):
        pulumi.set(self, 'logging_config', value)


@pulumi.input_type
class NodeConfigArgs:

    def __init__(__self__, *, accelerators: Optional[pulumi.Input[Sequence[
        pulumi.Input['AcceleratorConfigArgs']]]]=None,
        advanced_machine_features: Optional[pulumi.Input[
        'AdvancedMachineFeaturesArgs']]=None, boot_disk_kms_key: Optional[
        pulumi.Input[str]]=None, confidential_nodes: Optional[pulumi.Input[
        'ConfidentialNodesArgs']]=None, disk_size_gb: Optional[pulumi.Input
        [int]]=None, disk_type: Optional[pulumi.Input[str]]=None,
        ephemeral_storage_config: Optional[pulumi.Input[
        'EphemeralStorageConfigArgs']]=None,
        ephemeral_storage_local_ssd_config: Optional[pulumi.Input[
        'EphemeralStorageLocalSsdConfigArgs']]=None, fast_socket: Optional[
        pulumi.Input['FastSocketArgs']]=None, gcfs_config: Optional[pulumi.
        Input['GcfsConfigArgs']]=None, gvnic: Optional[pulumi.Input[
        'VirtualNICArgs']]=None, image_type: Optional[pulumi.Input[str]]=
        None, kubelet_config: Optional[pulumi.Input['NodeKubeletConfigArgs'
        ]]=None, labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[
        str]]]]=None, linux_node_config: Optional[pulumi.Input[
        'LinuxNodeConfigArgs']]=None, local_nvme_ssd_block_config: Optional
        [pulumi.Input['LocalNvmeSsdBlockConfigArgs']]=None, local_ssd_count:
        Optional[pulumi.Input[int]]=None, logging_config: Optional[pulumi.
        Input['NodePoolLoggingConfigArgs']]=None, machine_type: Optional[
        pulumi.Input[str]]=None, metadata: Optional[pulumi.Input[Mapping[
        str, pulumi.Input[str]]]]=None, min_cpu_platform: Optional[pulumi.
        Input[str]]=None, node_group: Optional[pulumi.Input[str]]=None,
        oauth_scopes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=
        None, preemptible: Optional[pulumi.Input[bool]]=None,
        reservation_affinity: Optional[pulumi.Input[
        'ReservationAffinityArgs']]=None, resource_labels: Optional[pulumi.
        Input[Mapping[str, pulumi.Input[str]]]]=None, sandbox_config:
        Optional[pulumi.Input['SandboxConfigArgs']]=None, service_account:
        Optional[pulumi.Input[str]]=None, shielded_instance_config:
        Optional[pulumi.Input['ShieldedInstanceConfigArgs']]=None, spot:
        Optional[pulumi.Input[bool]]=None, tags: Optional[pulumi.Input[
        Sequence[pulumi.Input[str]]]]=None, taints: Optional[pulumi.Input[
        Sequence[pulumi.Input['NodeTaintArgs']]]]=None, windows_node_config:
        Optional[pulumi.Input['WindowsNodeConfigArgs']]=None,
        workload_metadata_config: Optional[pulumi.Input[
        'WorkloadMetadataConfigArgs']]=None):
        """
        Parameters that describe the nodes in a cluster. GKE Autopilot clusters do not recognize parameters in `NodeConfig`. Use AutoprovisioningNodePoolDefaults instead.
        :param pulumi.Input[Sequence[pulumi.Input['AcceleratorConfigArgs']]] accelerators: A list of hardware accelerators to be attached to each node. See https://cloud.google.com/compute/docs/gpus for more information about support for GPUs.
        :param pulumi.Input['AdvancedMachineFeaturesArgs'] advanced_machine_features: Advanced features for the Compute Engine VM.
        :param pulumi.Input[str] boot_disk_kms_key:  The Customer Managed Encryption Key used to encrypt the boot disk attached to each node in the node pool. This should be of the form projects/[KEY_PROJECT_ID]/locations/[LOCATION]/keyRings/[RING_NAME]/cryptoKeys/[KEY_NAME]. For more information about protecting resources with Cloud KMS Keys please see: https://cloud.google.com/compute/docs/disks/customer-managed-encryption
        :param pulumi.Input['ConfidentialNodesArgs'] confidential_nodes: Confidential nodes config. All the nodes in the node pool will be Confidential VM once enabled.
        :param pulumi.Input[int] disk_size_gb: Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB. If unspecified, the default disk size is 100GB.
        :param pulumi.Input[str] disk_type: Type of the disk attached to each node (e.g. 'pd-standard', 'pd-ssd' or 'pd-balanced') If unspecified, the default disk type is 'pd-standard'
        :param pulumi.Input['EphemeralStorageConfigArgs'] ephemeral_storage_config: Parameters for the ephemeral storage filesystem. If unspecified, ephemeral storage is backed by the boot disk.
        :param pulumi.Input['EphemeralStorageLocalSsdConfigArgs'] ephemeral_storage_local_ssd_config: Parameters for the node ephemeral storage using Local SSDs. If unspecified, ephemeral storage is backed by the boot disk. This field is functionally equivalent to the ephemeral_storage_config
        :param pulumi.Input['FastSocketArgs'] fast_socket: Enable or disable NCCL fast socket for the node pool.
        :param pulumi.Input['GcfsConfigArgs'] gcfs_config: GCFS (Google Container File System) configs.
        :param pulumi.Input['VirtualNICArgs'] gvnic: Enable or disable gvnic on the node pool.
        :param pulumi.Input[str] image_type: The image type to use for this node. Note that for a given image type, the latest version of it will be used. Please see https://cloud.google.com/kubernetes-engine/docs/concepts/node-images for available image types.
        :param pulumi.Input['NodeKubeletConfigArgs'] kubelet_config: Node kubelet configs.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: The map of Kubernetes labels (key/value pairs) to be applied to each node. These will added in addition to any default label(s) that Kubernetes may apply to the node. In case of conflict in label keys, the applied set may differ depending on the Kubernetes version -- it's best to assume the behavior is undefined and conflicts should be avoided. For more information, including usage and the valid values, see: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/
        :param pulumi.Input['LinuxNodeConfigArgs'] linux_node_config: Parameters that can be configured on Linux nodes.
        :param pulumi.Input['LocalNvmeSsdBlockConfigArgs'] local_nvme_ssd_block_config: Parameters for using raw-block Local NVMe SSDs.
        :param pulumi.Input[int] local_ssd_count: The number of local SSD disks to be attached to the node. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        :param pulumi.Input['NodePoolLoggingConfigArgs'] logging_config: Logging configuration.
        :param pulumi.Input[str] machine_type: The name of a Google Compute Engine [machine type](https://cloud.google.com/compute/docs/machine-types). If unspecified, the default machine type is `e2-medium`.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] metadata: The metadata key/value pairs assigned to instances in the cluster. Keys must conform to the regexp `[a-zA-Z0-9-_]+` and be less than 128 bytes in length. These are reflected as part of a URL in the metadata server. Additionally, to avoid ambiguity, keys must not conflict with any other metadata keys for the project or be one of the reserved keys: - "cluster-location" - "cluster-name" - "cluster-uid" - "configure-sh" - "containerd-configure-sh" - "enable-oslogin" - "gci-ensure-gke-docker" - "gci-metrics-enabled" - "gci-update-strategy" - "instance-template" - "kube-env" - "startup-script" - "user-data" - "disable-address-manager" - "windows-startup-script-ps1" - "common-psm1" - "k8s-node-setup-psm1" - "install-ssh-psm1" - "user-profile-psm1" Values are free-form strings, and only have meaning as interpreted by the image running in the instance. The only restriction placed on them is that each value's size must be less than or equal to 32 KB. The total size of all keys and values must be less than 512 KB.
        :param pulumi.Input[str] min_cpu_platform: Minimum CPU platform to be used by this instance. The instance may be scheduled on the specified or newer CPU platform. Applicable values are the friendly names of CPU platforms, such as `minCpuPlatform: "Intel Haswell"` or `minCpuPlatform: "Intel Sandy Bridge"`. For more information, read [how to specify min CPU platform](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform).
        :param pulumi.Input[str] node_group: Setting this field will assign instances of this pool to run on the specified node group. This is useful for running workloads on [sole tenant nodes](https://cloud.google.com/compute/docs/nodes/sole-tenant-nodes).
        :param pulumi.Input[Sequence[pulumi.Input[str]]] oauth_scopes: The set of Google API scopes to be made available on all of the node VMs under the "default" service account. The following scopes are recommended, but not required, and by default are not included: * `https://www.googleapis.com/auth/compute` is required for mounting persistent storage on your nodes. * `https://www.googleapis.com/auth/devstorage.read_only` is required for communicating with **gcr.io** (the [Google Container Registry](https://cloud.google.com/container-registry/)). If unspecified, no scopes are added, unless Cloud Logging or Cloud Monitoring are enabled, in which case their required scopes will be added.
        :param pulumi.Input[bool] preemptible: Whether the nodes are created as preemptible VM instances. See: https://cloud.google.com/compute/docs/instances/preemptible for more inforamtion about preemptible VM instances.
        :param pulumi.Input['ReservationAffinityArgs'] reservation_affinity: The optional reservation affinity. Setting this field will apply the specified [Zonal Compute Reservation](https://cloud.google.com/compute/docs/instances/reserving-zonal-resources) to this node pool.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] resource_labels: The resource labels for the node pool to use to annotate any related Google Compute Engine resources.
        :param pulumi.Input['SandboxConfigArgs'] sandbox_config: Sandbox configuration for this node.
        :param pulumi.Input[str] service_account: The Google Cloud Platform Service Account to be used by the node VMs. Specify the email address of the Service Account; otherwise, if no Service Account is specified, the "default" service account is used.
        :param pulumi.Input['ShieldedInstanceConfigArgs'] shielded_instance_config: Shielded Instance options.
        :param pulumi.Input[bool] spot: Spot flag for enabling Spot VM, which is a rebrand of the existing preemptible flag.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: The list of instance tags applied to all nodes. Tags are used to identify valid sources or targets for network firewalls and are specified by the client during cluster or node pool creation. Each tag within the list must comply with RFC1035.
        :param pulumi.Input[Sequence[pulumi.Input['NodeTaintArgs']]] taints: List of kubernetes taints to be applied to each node. For more information, including usage and the valid values, see: https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/
        :param pulumi.Input['WindowsNodeConfigArgs'] windows_node_config: Parameters that can be configured on Windows nodes.
        :param pulumi.Input['WorkloadMetadataConfigArgs'] workload_metadata_config: The workload metadata configuration for this node.
        """
        if accelerators is not None:
            pulumi.set(__self__, 'accelerators', accelerators)
        if advanced_machine_features is not None:
            pulumi.set(__self__, 'advanced_machine_features',
                advanced_machine_features)
        if boot_disk_kms_key is not None:
            pulumi.set(__self__, 'boot_disk_kms_key', boot_disk_kms_key)
        if confidential_nodes is not None:
            pulumi.set(__self__, 'confidential_nodes', confidential_nodes)
        if disk_size_gb is not None:
            pulumi.set(__self__, 'disk_size_gb', disk_size_gb)
        if disk_type is not None:
            pulumi.set(__self__, 'disk_type', disk_type)
        if ephemeral_storage_config is not None:
            pulumi.set(__self__, 'ephemeral_storage_config',
                ephemeral_storage_config)
        if ephemeral_storage_local_ssd_config is not None:
            pulumi.set(__self__, 'ephemeral_storage_local_ssd_config',
                ephemeral_storage_local_ssd_config)
        if fast_socket is not None:
            pulumi.set(__self__, 'fast_socket', fast_socket)
        if gcfs_config is not None:
            pulumi.set(__self__, 'gcfs_config', gcfs_config)
        if gvnic is not None:
            pulumi.set(__self__, 'gvnic', gvnic)
        if image_type is not None:
            pulumi.set(__self__, 'image_type', image_type)
        if kubelet_config is not None:
            pulumi.set(__self__, 'kubelet_config', kubelet_config)
        if labels is not None:
            pulumi.set(__self__, 'labels', labels)
        if linux_node_config is not None:
            pulumi.set(__self__, 'linux_node_config', linux_node_config)
        if local_nvme_ssd_block_config is not None:
            pulumi.set(__self__, 'local_nvme_ssd_block_config',
                local_nvme_ssd_block_config)
        if local_ssd_count is not None:
            pulumi.set(__self__, 'local_ssd_count', local_ssd_count)
        if logging_config is not None:
            pulumi.set(__self__, 'logging_config', logging_config)
        if machine_type is not None:
            pulumi.set(__self__, 'machine_type', machine_type)
        if metadata is not None:
            pulumi.set(__self__, 'metadata', metadata)
        if min_cpu_platform is not None:
            pulumi.set(__self__, 'min_cpu_platform', min_cpu_platform)
        if node_group is not None:
            pulumi.set(__self__, 'node_group', node_group)
        if oauth_scopes is not None:
            pulumi.set(__self__, 'oauth_scopes', oauth_scopes)
        if preemptible is not None:
            pulumi.set(__self__, 'preemptible', preemptible)
        if reservation_affinity is not None:
            pulumi.set(__self__, 'reservation_affinity', reservation_affinity)
        if resource_labels is not None:
            pulumi.set(__self__, 'resource_labels', resource_labels)
        if sandbox_config is not None:
            pulumi.set(__self__, 'sandbox_config', sandbox_config)
        if service_account is not None:
            pulumi.set(__self__, 'service_account', service_account)
        if shielded_instance_config is not None:
            pulumi.set(__self__, 'shielded_instance_config',
                shielded_instance_config)
        if spot is not None:
            pulumi.set(__self__, 'spot', spot)
        if tags is not None:
            pulumi.set(__self__, 'tags', tags)
        if taints is not None:
            pulumi.set(__self__, 'taints', taints)
        if windows_node_config is not None:
            pulumi.set(__self__, 'windows_node_config', windows_node_config)
        if workload_metadata_config is not None:
            pulumi.set(__self__, 'workload_metadata_config',
                workload_metadata_config)

    @property
    @pulumi.getter
    def accelerators(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[
        'AcceleratorConfigArgs']]]]:
        """
        A list of hardware accelerators to be attached to each node. See https://cloud.google.com/compute/docs/gpus for more information about support for GPUs.
        """
        return pulumi.get(self, 'accelerators')

    @accelerators.setter
    def accelerators(self, value: Optional[pulumi.Input[Sequence[pulumi.
        Input['AcceleratorConfigArgs']]]]):
        pulumi.set(self, 'accelerators', value)

    @property
    @pulumi.getter(name='advancedMachineFeatures')
    def advanced_machine_features(self) ->Optional[pulumi.Input[
        'AdvancedMachineFeaturesArgs']]:
        """
        Advanced features for the Compute Engine VM.
        """
        return pulumi.get(self, 'advanced_machine_features')

    @advanced_machine_features.setter
    def advanced_machine_features(self, value: Optional[pulumi.Input[
        'AdvancedMachineFeaturesArgs']]):
        pulumi.set(self, 'advanced_machine_features', value)

    @property
    @pulumi.getter(name='bootDiskKmsKey')
    def boot_disk_kms_key(self) ->Optional[pulumi.Input[str]]:
        """
         The Customer Managed Encryption Key used to encrypt the boot disk attached to each node in the node pool. This should be of the form projects/[KEY_PROJECT_ID]/locations/[LOCATION]/keyRings/[RING_NAME]/cryptoKeys/[KEY_NAME]. For more information about protecting resources with Cloud KMS Keys please see: https://cloud.google.com/compute/docs/disks/customer-managed-encryption
        """
        return pulumi.get(self, 'boot_disk_kms_key')

    @boot_disk_kms_key.setter
    def boot_disk_kms_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'boot_disk_kms_key', value)

    @property
    @pulumi.getter(name='confidentialNodes')
    def confidential_nodes(self) ->Optional[pulumi.Input[
        'ConfidentialNodesArgs']]:
        """
        Confidential nodes config. All the nodes in the node pool will be Confidential VM once enabled.
        """
        return pulumi.get(self, 'confidential_nodes')

    @confidential_nodes.setter
    def confidential_nodes(self, value: Optional[pulumi.Input[
        'ConfidentialNodesArgs']]):
        pulumi.set(self, 'confidential_nodes', value)

    @property
    @pulumi.getter(name='diskSizeGb')
    def disk_size_gb(self) ->Optional[pulumi.Input[int]]:
        """
        Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB. If unspecified, the default disk size is 100GB.
        """
        return pulumi.get(self, 'disk_size_gb')

    @disk_size_gb.setter
    def disk_size_gb(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'disk_size_gb', value)

    @property
    @pulumi.getter(name='diskType')
    def disk_type(self) ->Optional[pulumi.Input[str]]:
        """
        Type of the disk attached to each node (e.g. 'pd-standard', 'pd-ssd' or 'pd-balanced') If unspecified, the default disk type is 'pd-standard'
        """
        return pulumi.get(self, 'disk_type')

    @disk_type.setter
    def disk_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'disk_type', value)

    @property
    @pulumi.getter(name='ephemeralStorageConfig')
    def ephemeral_storage_config(self) ->Optional[pulumi.Input[
        'EphemeralStorageConfigArgs']]:
        """
        Parameters for the ephemeral storage filesystem. If unspecified, ephemeral storage is backed by the boot disk.
        """
        return pulumi.get(self, 'ephemeral_storage_config')

    @ephemeral_storage_config.setter
    def ephemeral_storage_config(self, value: Optional[pulumi.Input[
        'EphemeralStorageConfigArgs']]):
        pulumi.set(self, 'ephemeral_storage_config', value)

    @property
    @pulumi.getter(name='ephemeralStorageLocalSsdConfig')
    def ephemeral_storage_local_ssd_config(self) ->Optional[pulumi.Input[
        'EphemeralStorageLocalSsdConfigArgs']]:
        """
        Parameters for the node ephemeral storage using Local SSDs. If unspecified, ephemeral storage is backed by the boot disk. This field is functionally equivalent to the ephemeral_storage_config
        """
        return pulumi.get(self, 'ephemeral_storage_local_ssd_config')

    @ephemeral_storage_local_ssd_config.setter
    def ephemeral_storage_local_ssd_config(self, value: Optional[pulumi.
        Input['EphemeralStorageLocalSsdConfigArgs']]):
        pulumi.set(self, 'ephemeral_storage_local_ssd_config', value)

    @property
    @pulumi.getter(name='fastSocket')
    def fast_socket(self) ->Optional[pulumi.Input['FastSocketArgs']]:
        """
        Enable or disable NCCL fast socket for the node pool.
        """
        return pulumi.get(self, 'fast_socket')

    @fast_socket.setter
    def fast_socket(self, value: Optional[pulumi.Input['FastSocketArgs']]):
        pulumi.set(self, 'fast_socket', value)

    @property
    @pulumi.getter(name='gcfsConfig')
    def gcfs_config(self) ->Optional[pulumi.Input['GcfsConfigArgs']]:
        """
        GCFS (Google Container File System) configs.
        """
        return pulumi.get(self, 'gcfs_config')

    @gcfs_config.setter
    def gcfs_config(self, value: Optional[pulumi.Input['GcfsConfigArgs']]):
        pulumi.set(self, 'gcfs_config', value)

    @property
    @pulumi.getter
    def gvnic(self) ->Optional[pulumi.Input['VirtualNICArgs']]:
        """
        Enable or disable gvnic on the node pool.
        """
        return pulumi.get(self, 'gvnic')

    @gvnic.setter
    def gvnic(self, value: Optional[pulumi.Input['VirtualNICArgs']]):
        pulumi.set(self, 'gvnic', value)

    @property
    @pulumi.getter(name='imageType')
    def image_type(self) ->Optional[pulumi.Input[str]]:
        """
        The image type to use for this node. Note that for a given image type, the latest version of it will be used. Please see https://cloud.google.com/kubernetes-engine/docs/concepts/node-images for available image types.
        """
        return pulumi.get(self, 'image_type')

    @image_type.setter
    def image_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'image_type', value)

    @property
    @pulumi.getter(name='kubeletConfig')
    def kubelet_config(self) ->Optional[pulumi.Input['NodeKubeletConfigArgs']]:
        """
        Node kubelet configs.
        """
        return pulumi.get(self, 'kubelet_config')

    @kubelet_config.setter
    def kubelet_config(self, value: Optional[pulumi.Input[
        'NodeKubeletConfigArgs']]):
        pulumi.set(self, 'kubelet_config', value)

    @property
    @pulumi.getter
    def labels(self) ->Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        The map of Kubernetes labels (key/value pairs) to be applied to each node. These will added in addition to any default label(s) that Kubernetes may apply to the node. In case of conflict in label keys, the applied set may differ depending on the Kubernetes version -- it's best to assume the behavior is undefined and conflicts should be avoided. For more information, including usage and the valid values, see: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/
        """
        return pulumi.get(self, 'labels')

    @labels.setter
    def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input
        [str]]]]):
        pulumi.set(self, 'labels', value)

    @property
    @pulumi.getter(name='linuxNodeConfig')
    def linux_node_config(self) ->Optional[pulumi.Input['LinuxNodeConfigArgs']
        ]:
        """
        Parameters that can be configured on Linux nodes.
        """
        return pulumi.get(self, 'linux_node_config')

    @linux_node_config.setter
    def linux_node_config(self, value: Optional[pulumi.Input[
        'LinuxNodeConfigArgs']]):
        pulumi.set(self, 'linux_node_config', value)

    @property
    @pulumi.getter(name='localNvmeSsdBlockConfig')
    def local_nvme_ssd_block_config(self) ->Optional[pulumi.Input[
        'LocalNvmeSsdBlockConfigArgs']]:
        """
        Parameters for using raw-block Local NVMe SSDs.
        """
        return pulumi.get(self, 'local_nvme_ssd_block_config')

    @local_nvme_ssd_block_config.setter
    def local_nvme_ssd_block_config(self, value: Optional[pulumi.Input[
        'LocalNvmeSsdBlockConfigArgs']]):
        pulumi.set(self, 'local_nvme_ssd_block_config', value)

    @property
    @pulumi.getter(name='localSsdCount')
    def local_ssd_count(self) ->Optional[pulumi.Input[int]]:
        """
        The number of local SSD disks to be attached to the node. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        """
        return pulumi.get(self, 'local_ssd_count')

    @local_ssd_count.setter
    def local_ssd_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'local_ssd_count', value)

    @property
    @pulumi.getter(name='loggingConfig')
    def logging_config(self) ->Optional[pulumi.Input[
        'NodePoolLoggingConfigArgs']]:
        """
        Logging configuration.
        """
        return pulumi.get(self, 'logging_config')

    @logging_config.setter
    def logging_config(self, value: Optional[pulumi.Input[
        'NodePoolLoggingConfigArgs']]):
        pulumi.set(self, 'logging_config', value)

    @property
    @pulumi.getter(name='machineType')
    def machine_type(self) ->Optional[pulumi.Input[str]]:
        """
        The name of a Google Compute Engine [machine type](https://cloud.google.com/compute/docs/machine-types). If unspecified, the default machine type is `e2-medium`.
        """
        return pulumi.get(self, 'machine_type')

    @machine_type.setter
    def machine_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'machine_type', value)

    @property
    @pulumi.getter
    def metadata(self) ->Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]
        ]:
        """
        The metadata key/value pairs assigned to instances in the cluster. Keys must conform to the regexp `[a-zA-Z0-9-_]+` and be less than 128 bytes in length. These are reflected as part of a URL in the metadata server. Additionally, to avoid ambiguity, keys must not conflict with any other metadata keys for the project or be one of the reserved keys: - "cluster-location" - "cluster-name" - "cluster-uid" - "configure-sh" - "containerd-configure-sh" - "enable-oslogin" - "gci-ensure-gke-docker" - "gci-metrics-enabled" - "gci-update-strategy" - "instance-template" - "kube-env" - "startup-script" - "user-data" - "disable-address-manager" - "windows-startup-script-ps1" - "common-psm1" - "k8s-node-setup-psm1" - "install-ssh-psm1" - "user-profile-psm1" Values are free-form strings, and only have meaning as interpreted by the image running in the instance. The only restriction placed on them is that each value's size must be less than or equal to 32 KB. The total size of all keys and values must be less than 512 KB.
        """
        return pulumi.get(self, 'metadata')

    @metadata.setter
    def metadata(self, value: Optional[pulumi.Input[Mapping[str, pulumi.
        Input[str]]]]):
        pulumi.set(self, 'metadata', value)

    @property
    @pulumi.getter(name='minCpuPlatform')
    def min_cpu_platform(self) ->Optional[pulumi.Input[str]]:
        """
        Minimum CPU platform to be used by this instance. The instance may be scheduled on the specified or newer CPU platform. Applicable values are the friendly names of CPU platforms, such as `minCpuPlatform: "Intel Haswell"` or `minCpuPlatform: "Intel Sandy Bridge"`. For more information, read [how to specify min CPU platform](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform).
        """
        return pulumi.get(self, 'min_cpu_platform')

    @min_cpu_platform.setter
    def min_cpu_platform(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'min_cpu_platform', value)

    @property
    @pulumi.getter(name='nodeGroup')
    def node_group(self) ->Optional[pulumi.Input[str]]:
        """
        Setting this field will assign instances of this pool to run on the specified node group. This is useful for running workloads on [sole tenant nodes](https://cloud.google.com/compute/docs/nodes/sole-tenant-nodes).
        """
        return pulumi.get(self, 'node_group')

    @node_group.setter
    def node_group(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'node_group', value)

    @property
    @pulumi.getter(name='oauthScopes')
    def oauth_scopes(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[str]]]
        ]:
        """
        The set of Google API scopes to be made available on all of the node VMs under the "default" service account. The following scopes are recommended, but not required, and by default are not included: * `https://www.googleapis.com/auth/compute` is required for mounting persistent storage on your nodes. * `https://www.googleapis.com/auth/devstorage.read_only` is required for communicating with **gcr.io** (the [Google Container Registry](https://cloud.google.com/container-registry/)). If unspecified, no scopes are added, unless Cloud Logging or Cloud Monitoring are enabled, in which case their required scopes will be added.
        """
        return pulumi.get(self, 'oauth_scopes')

    @oauth_scopes.setter
    def oauth_scopes(self, value: Optional[pulumi.Input[Sequence[pulumi.
        Input[str]]]]):
        pulumi.set(self, 'oauth_scopes', value)

    @property
    @pulumi.getter
    def preemptible(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the nodes are created as preemptible VM instances. See: https://cloud.google.com/compute/docs/instances/preemptible for more inforamtion about preemptible VM instances.
        """
        return pulumi.get(self, 'preemptible')

    @preemptible.setter
    def preemptible(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'preemptible', value)

    @property
    @pulumi.getter(name='reservationAffinity')
    def reservation_affinity(self) ->Optional[pulumi.Input[
        'ReservationAffinityArgs']]:
        """
        The optional reservation affinity. Setting this field will apply the specified [Zonal Compute Reservation](https://cloud.google.com/compute/docs/instances/reserving-zonal-resources) to this node pool.
        """
        return pulumi.get(self, 'reservation_affinity')

    @reservation_affinity.setter
    def reservation_affinity(self, value: Optional[pulumi.Input[
        'ReservationAffinityArgs']]):
        pulumi.set(self, 'reservation_affinity', value)

    @property
    @pulumi.getter(name='resourceLabels')
    def resource_labels(self) ->Optional[pulumi.Input[Mapping[str, pulumi.
        Input[str]]]]:
        """
        The resource labels for the node pool to use to annotate any related Google Compute Engine resources.
        """
        return pulumi.get(self, 'resource_labels')

    @resource_labels.setter
    def resource_labels(self, value: Optional[pulumi.Input[Mapping[str,
        pulumi.Input[str]]]]):
        pulumi.set(self, 'resource_labels', value)

    @property
    @pulumi.getter(name='sandboxConfig')
    def sandbox_config(self) ->Optional[pulumi.Input['SandboxConfigArgs']]:
        """
        Sandbox configuration for this node.
        """
        return pulumi.get(self, 'sandbox_config')

    @sandbox_config.setter
    def sandbox_config(self, value: Optional[pulumi.Input['SandboxConfigArgs']]
        ):
        pulumi.set(self, 'sandbox_config', value)

    @property
    @pulumi.getter(name='serviceAccount')
    def service_account(self) ->Optional[pulumi.Input[str]]:
        """
        The Google Cloud Platform Service Account to be used by the node VMs. Specify the email address of the Service Account; otherwise, if no Service Account is specified, the "default" service account is used.
        """
        return pulumi.get(self, 'service_account')

    @service_account.setter
    def service_account(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'service_account', value)

    @property
    @pulumi.getter(name='shieldedInstanceConfig')
    def shielded_instance_config(self) ->Optional[pulumi.Input[
        'ShieldedInstanceConfigArgs']]:
        """
        Shielded Instance options.
        """
        return pulumi.get(self, 'shielded_instance_config')

    @shielded_instance_config.setter
    def shielded_instance_config(self, value: Optional[pulumi.Input[
        'ShieldedInstanceConfigArgs']]):
        pulumi.set(self, 'shielded_instance_config', value)

    @property
    @pulumi.getter
    def spot(self) ->Optional[pulumi.Input[bool]]:
        """
        Spot flag for enabling Spot VM, which is a rebrand of the existing preemptible flag.
        """
        return pulumi.get(self, 'spot')

    @spot.setter
    def spot(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'spot', value)

    @property
    @pulumi.getter
    def tags(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The list of instance tags applied to all nodes. Tags are used to identify valid sources or targets for network firewalls and are specified by the client during cluster or node pool creation. Each tag within the list must comply with RFC1035.
        """
        return pulumi.get(self, 'tags')

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, 'tags', value)

    @property
    @pulumi.getter
    def taints(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[
        'NodeTaintArgs']]]]:
        """
        List of kubernetes taints to be applied to each node. For more information, including usage and the valid values, see: https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/
        """
        return pulumi.get(self, 'taints')

    @taints.setter
    def taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
        'NodeTaintArgs']]]]):
        pulumi.set(self, 'taints', value)

    @property
    @pulumi.getter(name='windowsNodeConfig')
    def windows_node_config(self) ->Optional[pulumi.Input[
        'WindowsNodeConfigArgs']]:
        """
        Parameters that can be configured on Windows nodes.
        """
        return pulumi.get(self, 'windows_node_config')

    @windows_node_config.setter
    def windows_node_config(self, value: Optional[pulumi.Input[
        'WindowsNodeConfigArgs']]):
        pulumi.set(self, 'windows_node_config', value)

    @property
    @pulumi.getter(name='workloadMetadataConfig')
    def workload_metadata_config(self) ->Optional[pulumi.Input[
        'WorkloadMetadataConfigArgs']]:
        """
        The workload metadata configuration for this node.
        """
        return pulumi.get(self, 'workload_metadata_config')

    @workload_metadata_config.setter
    def workload_metadata_config(self, value: Optional[pulumi.Input[
        'WorkloadMetadataConfigArgs']]):
        pulumi.set(self, 'workload_metadata_config', value)


@pulumi.input_type
class NodeKubeletConfigArgs:

    def __init__(__self__, *, cpu_cfs_quota: Optional[pulumi.Input[bool]]=
        None, cpu_cfs_quota_period: Optional[pulumi.Input[str]]=None,
        cpu_manager_policy: Optional[pulumi.Input[str]]=None,
        pod_pids_limit: Optional[pulumi.Input[str]]=None):
        """
        Node kubelet configs.
        :param pulumi.Input[bool] cpu_cfs_quota: Enable CPU CFS quota enforcement for containers that specify CPU limits. This option is enabled by default which makes kubelet use CFS quota (https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt) to enforce container CPU limits. Otherwise, CPU limits will not be enforced at all. Disable this option to mitigate CPU throttling problems while still having your pods to be in Guaranteed QoS class by specifying the CPU limits. The default value is 'true' if unspecified.
        :param pulumi.Input[str] cpu_cfs_quota_period: Set the CPU CFS quota period value 'cpu.cfs_period_us'. The string must be a sequence of decimal numbers, each with optional fraction and a unit suffix, such as "300ms". Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h". The value must be a positive duration.
        :param pulumi.Input[str] cpu_manager_policy: Control the CPU management policy on the node. See https://kubernetes.io/docs/tasks/administer-cluster/cpu-management-policies/ The following values are allowed. * "none": the default, which represents the existing scheduling behavior. * "static": allows pods with certain resource characteristics to be granted increased CPU affinity and exclusivity on the node. The default value is 'none' if unspecified.
        :param pulumi.Input[str] pod_pids_limit: Set the Pod PID limits. See https://kubernetes.io/docs/concepts/policy/pid-limiting/#pod-pid-limits Controls the maximum number of processes allowed to run in a pod. The value must be greater than or equal to 1024 and less than 4194304.
        """
        if cpu_cfs_quota is not None:
            pulumi.set(__self__, 'cpu_cfs_quota', cpu_cfs_quota)
        if cpu_cfs_quota_period is not None:
            pulumi.set(__self__, 'cpu_cfs_quota_period', cpu_cfs_quota_period)
        if cpu_manager_policy is not None:
            pulumi.set(__self__, 'cpu_manager_policy', cpu_manager_policy)
        if pod_pids_limit is not None:
            pulumi.set(__self__, 'pod_pids_limit', pod_pids_limit)

    @property
    @pulumi.getter(name='cpuCfsQuota')
    def cpu_cfs_quota(self) ->Optional[pulumi.Input[bool]]:
        """
        Enable CPU CFS quota enforcement for containers that specify CPU limits. This option is enabled by default which makes kubelet use CFS quota (https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt) to enforce container CPU limits. Otherwise, CPU limits will not be enforced at all. Disable this option to mitigate CPU throttling problems while still having your pods to be in Guaranteed QoS class by specifying the CPU limits. The default value is 'true' if unspecified.
        """
        return pulumi.get(self, 'cpu_cfs_quota')

    @cpu_cfs_quota.setter
    def cpu_cfs_quota(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'cpu_cfs_quota', value)

    @property
    @pulumi.getter(name='cpuCfsQuotaPeriod')
    def cpu_cfs_quota_period(self) ->Optional[pulumi.Input[str]]:
        """
        Set the CPU CFS quota period value 'cpu.cfs_period_us'. The string must be a sequence of decimal numbers, each with optional fraction and a unit suffix, such as "300ms". Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h". The value must be a positive duration.
        """
        return pulumi.get(self, 'cpu_cfs_quota_period')

    @cpu_cfs_quota_period.setter
    def cpu_cfs_quota_period(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'cpu_cfs_quota_period', value)

    @property
    @pulumi.getter(name='cpuManagerPolicy')
    def cpu_manager_policy(self) ->Optional[pulumi.Input[str]]:
        """
        Control the CPU management policy on the node. See https://kubernetes.io/docs/tasks/administer-cluster/cpu-management-policies/ The following values are allowed. * "none": the default, which represents the existing scheduling behavior. * "static": allows pods with certain resource characteristics to be granted increased CPU affinity and exclusivity on the node. The default value is 'none' if unspecified.
        """
        return pulumi.get(self, 'cpu_manager_policy')

    @cpu_manager_policy.setter
    def cpu_manager_policy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'cpu_manager_policy', value)

    @property
    @pulumi.getter(name='podPidsLimit')
    def pod_pids_limit(self) ->Optional[pulumi.Input[str]]:
        """
        Set the Pod PID limits. See https://kubernetes.io/docs/concepts/policy/pid-limiting/#pod-pid-limits Controls the maximum number of processes allowed to run in a pod. The value must be greater than or equal to 1024 and less than 4194304.
        """
        return pulumi.get(self, 'pod_pids_limit')

    @pod_pids_limit.setter
    def pod_pids_limit(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'pod_pids_limit', value)


@pulumi.input_type
class NodeManagementArgs:

    def __init__(__self__, *, auto_repair: Optional[pulumi.Input[bool]]=
        None, auto_upgrade: Optional[pulumi.Input[bool]]=None,
        upgrade_options: Optional[pulumi.Input['AutoUpgradeOptionsArgs']]=None
        ):
        """
        NodeManagement defines the set of node management services turned on for the node pool.
        :param pulumi.Input[bool] auto_repair: Whether the nodes will be automatically repaired.
        :param pulumi.Input[bool] auto_upgrade: Whether the nodes will be automatically upgraded.
        :param pulumi.Input['AutoUpgradeOptionsArgs'] upgrade_options: Specifies the Auto Upgrade knobs for the node pool.
        """
        if auto_repair is not None:
            pulumi.set(__self__, 'auto_repair', auto_repair)
        if auto_upgrade is not None:
            pulumi.set(__self__, 'auto_upgrade', auto_upgrade)
        if upgrade_options is not None:
            pulumi.set(__self__, 'upgrade_options', upgrade_options)

    @property
    @pulumi.getter(name='autoRepair')
    def auto_repair(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the nodes will be automatically repaired.
        """
        return pulumi.get(self, 'auto_repair')

    @auto_repair.setter
    def auto_repair(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'auto_repair', value)

    @property
    @pulumi.getter(name='autoUpgrade')
    def auto_upgrade(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the nodes will be automatically upgraded.
        """
        return pulumi.get(self, 'auto_upgrade')

    @auto_upgrade.setter
    def auto_upgrade(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'auto_upgrade', value)

    @property
    @pulumi.getter(name='upgradeOptions')
    def upgrade_options(self) ->Optional[pulumi.Input['AutoUpgradeOptionsArgs']
        ]:
        """
        Specifies the Auto Upgrade knobs for the node pool.
        """
        return pulumi.get(self, 'upgrade_options')

    @upgrade_options.setter
    def upgrade_options(self, value: Optional[pulumi.Input[
        'AutoUpgradeOptionsArgs']]):
        pulumi.set(self, 'upgrade_options', value)


@pulumi.input_type
class NodeNetworkConfigArgs:

    def __init__(__self__, *, create_pod_range: Optional[pulumi.Input[bool]
        ]=None, enable_private_nodes: Optional[pulumi.Input[bool]]=None,
        network_performance_config: Optional[pulumi.Input[
        'NetworkPerformanceConfigArgs']]=None,
        pod_cidr_overprovision_config: Optional[pulumi.Input[
        'PodCIDROverprovisionConfigArgs']]=None, pod_ipv4_cidr_block:
        Optional[pulumi.Input[str]]=None, pod_range: Optional[pulumi.Input[
        str]]=None):
        """
        Parameters for node pool-level network config.
        :param pulumi.Input[bool] create_pod_range: Input only. Whether to create a new range for pod IPs in this node pool. Defaults are provided for `pod_range` and `pod_ipv4_cidr_block` if they are not specified. If neither `create_pod_range` or `pod_range` are specified, the cluster-level default (`ip_allocation_policy.cluster_ipv4_cidr_block`) is used. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        :param pulumi.Input[bool] enable_private_nodes: Whether nodes have internal IP addresses only. If enable_private_nodes is not specified, then the value is derived from cluster.privateClusterConfig.enablePrivateNodes
        :param pulumi.Input['NetworkPerformanceConfigArgs'] network_performance_config: Network bandwidth tier configuration.
        :param pulumi.Input['PodCIDROverprovisionConfigArgs'] pod_cidr_overprovision_config: [PRIVATE FIELD] Pod CIDR size overprovisioning config for the nodepool. Pod CIDR size per node depends on max_pods_per_node. By default, the value of max_pods_per_node is rounded off to next power of 2 and we then double that to get the size of pod CIDR block per node. Example: max_pods_per_node of 30 would result in 64 IPs (/26). This config can disable the doubling of IPs (we still round off to next power of 2) Example: max_pods_per_node of 30 will result in 32 IPs (/27) when overprovisioning is disabled.
        :param pulumi.Input[str] pod_ipv4_cidr_block: The IP address range for pod IPs in this node pool. Only applicable if `create_pod_range` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) to pick a specific range to use. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        :param pulumi.Input[str] pod_range: The ID of the secondary range for pod IPs. If `create_pod_range` is true, this ID is used for the new range. If `create_pod_range` is false, uses an existing secondary range with this ID. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        """
        if create_pod_range is not None:
            pulumi.set(__self__, 'create_pod_range', create_pod_range)
        if enable_private_nodes is not None:
            pulumi.set(__self__, 'enable_private_nodes', enable_private_nodes)
        if network_performance_config is not None:
            pulumi.set(__self__, 'network_performance_config',
                network_performance_config)
        if pod_cidr_overprovision_config is not None:
            pulumi.set(__self__, 'pod_cidr_overprovision_config',
                pod_cidr_overprovision_config)
        if pod_ipv4_cidr_block is not None:
            pulumi.set(__self__, 'pod_ipv4_cidr_block', pod_ipv4_cidr_block)
        if pod_range is not None:
            pulumi.set(__self__, 'pod_range', pod_range)

    @property
    @pulumi.getter(name='createPodRange')
    def create_pod_range(self) ->Optional[pulumi.Input[bool]]:
        """
        Input only. Whether to create a new range for pod IPs in this node pool. Defaults are provided for `pod_range` and `pod_ipv4_cidr_block` if they are not specified. If neither `create_pod_range` or `pod_range` are specified, the cluster-level default (`ip_allocation_policy.cluster_ipv4_cidr_block`) is used. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        """
        return pulumi.get(self, 'create_pod_range')

    @create_pod_range.setter
    def create_pod_range(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'create_pod_range', value)

    @property
    @pulumi.getter(name='enablePrivateNodes')
    def enable_private_nodes(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether nodes have internal IP addresses only. If enable_private_nodes is not specified, then the value is derived from cluster.privateClusterConfig.enablePrivateNodes
        """
        return pulumi.get(self, 'enable_private_nodes')

    @enable_private_nodes.setter
    def enable_private_nodes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_private_nodes', value)

    @property
    @pulumi.getter(name='networkPerformanceConfig')
    def network_performance_config(self) ->Optional[pulumi.Input[
        'NetworkPerformanceConfigArgs']]:
        """
        Network bandwidth tier configuration.
        """
        return pulumi.get(self, 'network_performance_config')

    @network_performance_config.setter
    def network_performance_config(self, value: Optional[pulumi.Input[
        'NetworkPerformanceConfigArgs']]):
        pulumi.set(self, 'network_performance_config', value)

    @property
    @pulumi.getter(name='podCidrOverprovisionConfig')
    def pod_cidr_overprovision_config(self) ->Optional[pulumi.Input[
        'PodCIDROverprovisionConfigArgs']]:
        """
        [PRIVATE FIELD] Pod CIDR size overprovisioning config for the nodepool. Pod CIDR size per node depends on max_pods_per_node. By default, the value of max_pods_per_node is rounded off to next power of 2 and we then double that to get the size of pod CIDR block per node. Example: max_pods_per_node of 30 would result in 64 IPs (/26). This config can disable the doubling of IPs (we still round off to next power of 2) Example: max_pods_per_node of 30 will result in 32 IPs (/27) when overprovisioning is disabled.
        """
        return pulumi.get(self, 'pod_cidr_overprovision_config')

    @pod_cidr_overprovision_config.setter
    def pod_cidr_overprovision_config(self, value: Optional[pulumi.Input[
        'PodCIDROverprovisionConfigArgs']]):
        pulumi.set(self, 'pod_cidr_overprovision_config', value)

    @property
    @pulumi.getter(name='podIpv4CidrBlock')
    def pod_ipv4_cidr_block(self) ->Optional[pulumi.Input[str]]:
        """
        The IP address range for pod IPs in this node pool. Only applicable if `create_pod_range` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) to pick a specific range to use. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        """
        return pulumi.get(self, 'pod_ipv4_cidr_block')

    @pod_ipv4_cidr_block.setter
    def pod_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'pod_ipv4_cidr_block', value)

    @property
    @pulumi.getter(name='podRange')
    def pod_range(self) ->Optional[pulumi.Input[str]]:
        """
        The ID of the secondary range for pod IPs. If `create_pod_range` is true, this ID is used for the new range. If `create_pod_range` is false, uses an existing secondary range with this ID. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        """
        return pulumi.get(self, 'pod_range')

    @pod_range.setter
    def pod_range(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'pod_range', value)


@pulumi.input_type
class NodePoolAutoConfigArgs:

    def __init__(__self__, *, network_tags: Optional[pulumi.Input[
        'NetworkTagsArgs']]=None):
        """
        node pool configs that apply to all auto-provisioned node pools in autopilot clusters and node auto-provisioning enabled clusters
        :param pulumi.Input['NetworkTagsArgs'] network_tags: The list of instance tags applied to all nodes. Tags are used to identify valid sources or targets for network firewalls and are specified by the client during cluster creation. Each tag within the list must comply with RFC1035.
        """
        if network_tags is not None:
            pulumi.set(__self__, 'network_tags', network_tags)

    @property
    @pulumi.getter(name='networkTags')
    def network_tags(self) ->Optional[pulumi.Input['NetworkTagsArgs']]:
        """
        The list of instance tags applied to all nodes. Tags are used to identify valid sources or targets for network firewalls and are specified by the client during cluster creation. Each tag within the list must comply with RFC1035.
        """
        return pulumi.get(self, 'network_tags')

    @network_tags.setter
    def network_tags(self, value: Optional[pulumi.Input['NetworkTagsArgs']]):
        pulumi.set(self, 'network_tags', value)


@pulumi.input_type
class NodePoolAutoscalingArgs:

    def __init__(__self__, *, autoprovisioned: Optional[pulumi.Input[bool]]
        =None, enabled: Optional[pulumi.Input[bool]]=None, location_policy:
        Optional[pulumi.Input['NodePoolAutoscalingLocationPolicy']]=None,
        max_node_count: Optional[pulumi.Input[int]]=None, min_node_count:
        Optional[pulumi.Input[int]]=None, total_max_node_count: Optional[
        pulumi.Input[int]]=None, total_min_node_count: Optional[pulumi.
        Input[int]]=None):
        """
        NodePoolAutoscaling contains information required by cluster autoscaler to adjust the size of the node pool to the current cluster usage.
        :param pulumi.Input[bool] autoprovisioned: Can this node pool be deleted automatically.
        :param pulumi.Input[bool] enabled: Is autoscaling enabled for this node pool.
        :param pulumi.Input['NodePoolAutoscalingLocationPolicy'] location_policy: Location policy used when scaling up a nodepool.
        :param pulumi.Input[int] max_node_count: Maximum number of nodes for one location in the NodePool. Must be >= min_node_count. There has to be enough quota to scale up the cluster.
        :param pulumi.Input[int] min_node_count: Minimum number of nodes for one location in the NodePool. Must be >= 1 and <= max_node_count.
        :param pulumi.Input[int] total_max_node_count: Maximum number of nodes in the node pool. Must be greater than total_min_node_count. There has to be enough quota to scale up the cluster. The total_*_node_count fields are mutually exclusive with the *_node_count fields.
        :param pulumi.Input[int] total_min_node_count: Minimum number of nodes in the node pool. Must be greater than 1 less than total_max_node_count. The total_*_node_count fields are mutually exclusive with the *_node_count fields.
        """
        if autoprovisioned is not None:
            pulumi.set(__self__, 'autoprovisioned', autoprovisioned)
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)
        if location_policy is not None:
            pulumi.set(__self__, 'location_policy', location_policy)
        if max_node_count is not None:
            pulumi.set(__self__, 'max_node_count', max_node_count)
        if min_node_count is not None:
            pulumi.set(__self__, 'min_node_count', min_node_count)
        if total_max_node_count is not None:
            pulumi.set(__self__, 'total_max_node_count', total_max_node_count)
        if total_min_node_count is not None:
            pulumi.set(__self__, 'total_min_node_count', total_min_node_count)

    @property
    @pulumi.getter
    def autoprovisioned(self) ->Optional[pulumi.Input[bool]]:
        """
        Can this node pool be deleted automatically.
        """
        return pulumi.get(self, 'autoprovisioned')

    @autoprovisioned.setter
    def autoprovisioned(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'autoprovisioned', value)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Is autoscaling enabled for this node pool.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)

    @property
    @pulumi.getter(name='locationPolicy')
    def location_policy(self) ->Optional[pulumi.Input[
        'NodePoolAutoscalingLocationPolicy']]:
        """
        Location policy used when scaling up a nodepool.
        """
        return pulumi.get(self, 'location_policy')

    @location_policy.setter
    def location_policy(self, value: Optional[pulumi.Input[
        'NodePoolAutoscalingLocationPolicy']]):
        pulumi.set(self, 'location_policy', value)

    @property
    @pulumi.getter(name='maxNodeCount')
    def max_node_count(self) ->Optional[pulumi.Input[int]]:
        """
        Maximum number of nodes for one location in the NodePool. Must be >= min_node_count. There has to be enough quota to scale up the cluster.
        """
        return pulumi.get(self, 'max_node_count')

    @max_node_count.setter
    def max_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'max_node_count', value)

    @property
    @pulumi.getter(name='minNodeCount')
    def min_node_count(self) ->Optional[pulumi.Input[int]]:
        """
        Minimum number of nodes for one location in the NodePool. Must be >= 1 and <= max_node_count.
        """
        return pulumi.get(self, 'min_node_count')

    @min_node_count.setter
    def min_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'min_node_count', value)

    @property
    @pulumi.getter(name='totalMaxNodeCount')
    def total_max_node_count(self) ->Optional[pulumi.Input[int]]:
        """
        Maximum number of nodes in the node pool. Must be greater than total_min_node_count. There has to be enough quota to scale up the cluster. The total_*_node_count fields are mutually exclusive with the *_node_count fields.
        """
        return pulumi.get(self, 'total_max_node_count')

    @total_max_node_count.setter
    def total_max_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'total_max_node_count', value)

    @property
    @pulumi.getter(name='totalMinNodeCount')
    def total_min_node_count(self) ->Optional[pulumi.Input[int]]:
        """
        Minimum number of nodes in the node pool. Must be greater than 1 less than total_max_node_count. The total_*_node_count fields are mutually exclusive with the *_node_count fields.
        """
        return pulumi.get(self, 'total_min_node_count')

    @total_min_node_count.setter
    def total_min_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'total_min_node_count', value)


@pulumi.input_type
class NodePoolDefaultsArgs:

    def __init__(__self__, *, node_config_defaults: Optional[pulumi.Input[
        'NodeConfigDefaultsArgs']]=None):
        """
        Subset of Nodepool message that has defaults.
        :param pulumi.Input['NodeConfigDefaultsArgs'] node_config_defaults: Subset of NodeConfig message that has defaults.
        """
        if node_config_defaults is not None:
            pulumi.set(__self__, 'node_config_defaults', node_config_defaults)

    @property
    @pulumi.getter(name='nodeConfigDefaults')
    def node_config_defaults(self) ->Optional[pulumi.Input[
        'NodeConfigDefaultsArgs']]:
        """
        Subset of NodeConfig message that has defaults.
        """
        return pulumi.get(self, 'node_config_defaults')

    @node_config_defaults.setter
    def node_config_defaults(self, value: Optional[pulumi.Input[
        'NodeConfigDefaultsArgs']]):
        pulumi.set(self, 'node_config_defaults', value)


@pulumi.input_type
class NodePoolLoggingConfigArgs:

    def __init__(__self__, *, variant_config: Optional[pulumi.Input[
        'LoggingVariantConfigArgs']]=None):
        """
        NodePoolLoggingConfig specifies logging configuration for nodepools.
        :param pulumi.Input['LoggingVariantConfigArgs'] variant_config: Logging variant configuration.
        """
        if variant_config is not None:
            pulumi.set(__self__, 'variant_config', variant_config)

    @property
    @pulumi.getter(name='variantConfig')
    def variant_config(self) ->Optional[pulumi.Input[
        'LoggingVariantConfigArgs']]:
        """
        Logging variant configuration.
        """
        return pulumi.get(self, 'variant_config')

    @variant_config.setter
    def variant_config(self, value: Optional[pulumi.Input[
        'LoggingVariantConfigArgs']]):
        pulumi.set(self, 'variant_config', value)


@pulumi.input_type
class NodePoolArgs:

    def __init__(__self__, *, autoscaling: Optional[pulumi.Input[
        'NodePoolAutoscalingArgs']]=None, conditions: Optional[pulumi.Input
        [Sequence[pulumi.Input['StatusConditionArgs']]]]=None, config:
        Optional[pulumi.Input['NodeConfigArgs']]=None, etag: Optional[
        pulumi.Input[str]]=None, initial_node_count: Optional[pulumi.Input[
        int]]=None, locations: Optional[pulumi.Input[Sequence[pulumi.Input[
        str]]]]=None, management: Optional[pulumi.Input[
        'NodeManagementArgs']]=None, max_pods_constraint: Optional[pulumi.
        Input['MaxPodsConstraintArgs']]=None, name: Optional[pulumi.Input[
        str]]=None, network_config: Optional[pulumi.Input[
        'NodeNetworkConfigArgs']]=None, placement_policy: Optional[pulumi.
        Input['PlacementPolicyArgs']]=None, upgrade_settings: Optional[
        pulumi.Input['UpgradeSettingsArgs']]=None, version: Optional[pulumi
        .Input[str]]=None):
        """
        NodePool contains the name and configuration for a cluster's node pool. Node pools are a set of nodes (i.e. VM's), with a common configuration and specification, under the control of the cluster master. They may have a set of Kubernetes labels applied to them, which may be used to reference them during pod scheduling. They may also be resized up or down, to accommodate the workload. These upgrade settings control the level of parallelism and the level of disruption caused by an upgrade. maxUnavailable controls the number of nodes that can be simultaneously unavailable. maxSurge controls the number of additional nodes that can be added to the node pool temporarily for the time of the upgrade to increase the number of available nodes. (maxUnavailable + maxSurge) determines the level of parallelism (how many nodes are being upgraded at the same time). Note: upgrades inevitably introduce some disruption since workloads need to be moved from old nodes to new, upgraded ones. Even if maxUnavailable=0, this holds true. (Disruption stays within the limits of PodDisruptionBudget, if it is configured.) Consider a hypothetical node pool with 5 nodes having maxSurge=2, maxUnavailable=1. This means the upgrade process upgrades 3 nodes simultaneously. It creates 2 additional (upgraded) nodes, then it brings down 3 old (not yet upgraded) nodes at the same time. This ensures that there are always at least 4 nodes available.
        :param pulumi.Input['NodePoolAutoscalingArgs'] autoscaling: Autoscaler configuration for this NodePool. Autoscaler is enabled only if a valid configuration is present.
        :param pulumi.Input[Sequence[pulumi.Input['StatusConditionArgs']]] conditions: Which conditions caused the current node pool state.
        :param pulumi.Input['NodeConfigArgs'] config: The node configuration of the pool.
        :param pulumi.Input[str] etag: This checksum is computed by the server based on the value of node pool fields, and may be sent on update requests to ensure the client has an up-to-date value before proceeding.
        :param pulumi.Input[int] initial_node_count: The initial node count for the pool. You must ensure that your Compute Engine [resource quota](https://cloud.google.com/compute/quotas) is sufficient for this number of instances. You must also have available firewall and routes quota.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] locations: The list of Google Compute Engine [zones](https://cloud.google.com/compute/docs/zones#available) in which the NodePool's nodes should be located. If this value is unspecified during node pool creation, the [Cluster.Locations](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1/projects.locations.clusters#Cluster.FIELDS.locations) value will be used, instead. Warning: changing node pool locations will result in nodes being added and/or removed.
        :param pulumi.Input['NodeManagementArgs'] management: NodeManagement configuration for this NodePool.
        :param pulumi.Input['MaxPodsConstraintArgs'] max_pods_constraint: The constraint on the maximum number of pods that can be run simultaneously on a node in the node pool.
        :param pulumi.Input[str] name: The name of the node pool.
        :param pulumi.Input['NodeNetworkConfigArgs'] network_config: Networking configuration for this NodePool. If specified, it overrides the cluster-level defaults.
        :param pulumi.Input['PlacementPolicyArgs'] placement_policy: Specifies the node placement policy.
        :param pulumi.Input['UpgradeSettingsArgs'] upgrade_settings: Upgrade settings control disruption and speed of the upgrade.
        :param pulumi.Input[str] version: The version of Kubernetes running on this NodePool's nodes. If unspecified, it defaults as described [here](https://cloud.google.com/kubernetes-engine/versioning#specifying_node_version).
        """
        if autoscaling is not None:
            pulumi.set(__self__, 'autoscaling', autoscaling)
        if conditions is not None:
            pulumi.set(__self__, 'conditions', conditions)
        if config is not None:
            pulumi.set(__self__, 'config', config)
        if etag is not None:
            pulumi.set(__self__, 'etag', etag)
        if initial_node_count is not None:
            pulumi.set(__self__, 'initial_node_count', initial_node_count)
        if locations is not None:
            pulumi.set(__self__, 'locations', locations)
        if management is not None:
            pulumi.set(__self__, 'management', management)
        if max_pods_constraint is not None:
            pulumi.set(__self__, 'max_pods_constraint', max_pods_constraint)
        if name is not None:
            pulumi.set(__self__, 'name', name)
        if network_config is not None:
            pulumi.set(__self__, 'network_config', network_config)
        if placement_policy is not None:
            pulumi.set(__self__, 'placement_policy', placement_policy)
        if upgrade_settings is not None:
            pulumi.set(__self__, 'upgrade_settings', upgrade_settings)
        if version is not None:
            pulumi.set(__self__, 'version', version)

    @property
    @pulumi.getter
    def autoscaling(self) ->Optional[pulumi.Input['NodePoolAutoscalingArgs']]:
        """
        Autoscaler configuration for this NodePool. Autoscaler is enabled only if a valid configuration is present.
        """
        return pulumi.get(self, 'autoscaling')

    @autoscaling.setter
    def autoscaling(self, value: Optional[pulumi.Input[
        'NodePoolAutoscalingArgs']]):
        pulumi.set(self, 'autoscaling', value)

    @property
    @pulumi.getter
    def conditions(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[
        'StatusConditionArgs']]]]:
        """
        Which conditions caused the current node pool state.
        """
        return pulumi.get(self, 'conditions')

    @conditions.setter
    def conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input
        ['StatusConditionArgs']]]]):
        pulumi.set(self, 'conditions', value)

    @property
    @pulumi.getter
    def config(self) ->Optional[pulumi.Input['NodeConfigArgs']]:
        """
        The node configuration of the pool.
        """
        return pulumi.get(self, 'config')

    @config.setter
    def config(self, value: Optional[pulumi.Input['NodeConfigArgs']]):
        pulumi.set(self, 'config', value)

    @property
    @pulumi.getter
    def etag(self) ->Optional[pulumi.Input[str]]:
        """
        This checksum is computed by the server based on the value of node pool fields, and may be sent on update requests to ensure the client has an up-to-date value before proceeding.
        """
        return pulumi.get(self, 'etag')

    @etag.setter
    def etag(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'etag', value)

    @property
    @pulumi.getter(name='initialNodeCount')
    def initial_node_count(self) ->Optional[pulumi.Input[int]]:
        """
        The initial node count for the pool. You must ensure that your Compute Engine [resource quota](https://cloud.google.com/compute/quotas) is sufficient for this number of instances. You must also have available firewall and routes quota.
        """
        return pulumi.get(self, 'initial_node_count')

    @initial_node_count.setter
    def initial_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'initial_node_count', value)

    @property
    @pulumi.getter
    def locations(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The list of Google Compute Engine [zones](https://cloud.google.com/compute/docs/zones#available) in which the NodePool's nodes should be located. If this value is unspecified during node pool creation, the [Cluster.Locations](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1/projects.locations.clusters#Cluster.FIELDS.locations) value will be used, instead. Warning: changing node pool locations will result in nodes being added and/or removed.
        """
        return pulumi.get(self, 'locations')

    @locations.setter
    def locations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
        str]]]]):
        pulumi.set(self, 'locations', value)

    @property
    @pulumi.getter
    def management(self) ->Optional[pulumi.Input['NodeManagementArgs']]:
        """
        NodeManagement configuration for this NodePool.
        """
        return pulumi.get(self, 'management')

    @management.setter
    def management(self, value: Optional[pulumi.Input['NodeManagementArgs']]):
        pulumi.set(self, 'management', value)

    @property
    @pulumi.getter(name='maxPodsConstraint')
    def max_pods_constraint(self) ->Optional[pulumi.Input[
        'MaxPodsConstraintArgs']]:
        """
        The constraint on the maximum number of pods that can be run simultaneously on a node in the node pool.
        """
        return pulumi.get(self, 'max_pods_constraint')

    @max_pods_constraint.setter
    def max_pods_constraint(self, value: Optional[pulumi.Input[
        'MaxPodsConstraintArgs']]):
        pulumi.set(self, 'max_pods_constraint', value)

    @property
    @pulumi.getter
    def name(self) ->Optional[pulumi.Input[str]]:
        """
        The name of the node pool.
        """
        return pulumi.get(self, 'name')

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'name', value)

    @property
    @pulumi.getter(name='networkConfig')
    def network_config(self) ->Optional[pulumi.Input['NodeNetworkConfigArgs']]:
        """
        Networking configuration for this NodePool. If specified, it overrides the cluster-level defaults.
        """
        return pulumi.get(self, 'network_config')

    @network_config.setter
    def network_config(self, value: Optional[pulumi.Input[
        'NodeNetworkConfigArgs']]):
        pulumi.set(self, 'network_config', value)

    @property
    @pulumi.getter(name='placementPolicy')
    def placement_policy(self) ->Optional[pulumi.Input['PlacementPolicyArgs']]:
        """
        Specifies the node placement policy.
        """
        return pulumi.get(self, 'placement_policy')

    @placement_policy.setter
    def placement_policy(self, value: Optional[pulumi.Input[
        'PlacementPolicyArgs']]):
        pulumi.set(self, 'placement_policy', value)

    @property
    @pulumi.getter(name='upgradeSettings')
    def upgrade_settings(self) ->Optional[pulumi.Input['UpgradeSettingsArgs']]:
        """
        Upgrade settings control disruption and speed of the upgrade.
        """
        return pulumi.get(self, 'upgrade_settings')

    @upgrade_settings.setter
    def upgrade_settings(self, value: Optional[pulumi.Input[
        'UpgradeSettingsArgs']]):
        pulumi.set(self, 'upgrade_settings', value)

    @property
    @pulumi.getter
    def version(self) ->Optional[pulumi.Input[str]]:
        """
        The version of Kubernetes running on this NodePool's nodes. If unspecified, it defaults as described [here](https://cloud.google.com/kubernetes-engine/versioning#specifying_node_version).
        """
        return pulumi.get(self, 'version')

    @version.setter
    def version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'version', value)


@pulumi.input_type
class NodeTaintArgs:

    def __init__(__self__, *, effect: Optional[pulumi.Input[
        'NodeTaintEffect']]=None, key: Optional[pulumi.Input[str]]=None,
        value: Optional[pulumi.Input[str]]=None):
        """
        Kubernetes taint is composed of three fields: key, value, and effect. Effect can only be one of three types: NoSchedule, PreferNoSchedule or NoExecute. See [here](https://kubernetes.io/docs/concepts/configuration/taint-and-toleration) for more information, including usage and the valid values.
        :param pulumi.Input['NodeTaintEffect'] effect: Effect for taint.
        :param pulumi.Input[str] key: Key for taint.
        :param pulumi.Input[str] value: Value for taint.
        """
        if effect is not None:
            pulumi.set(__self__, 'effect', effect)
        if key is not None:
            pulumi.set(__self__, 'key', key)
        if value is not None:
            pulumi.set(__self__, 'value', value)

    @property
    @pulumi.getter
    def effect(self) ->Optional[pulumi.Input['NodeTaintEffect']]:
        """
        Effect for taint.
        """
        return pulumi.get(self, 'effect')

    @effect.setter
    def effect(self, value: Optional[pulumi.Input['NodeTaintEffect']]):
        pulumi.set(self, 'effect', value)

    @property
    @pulumi.getter
    def key(self) ->Optional[pulumi.Input[str]]:
        """
        Key for taint.
        """
        return pulumi.get(self, 'key')

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'key', value)

    @property
    @pulumi.getter
    def value(self) ->Optional[pulumi.Input[str]]:
        """
        Value for taint.
        """
        return pulumi.get(self, 'value')

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'value', value)


@pulumi.input_type
class NotificationConfigArgs:

    def __init__(__self__, *, pubsub: Optional[pulumi.Input['PubSubArgs']]=None
        ):
        """
        NotificationConfig is the configuration of notifications.
        :param pulumi.Input['PubSubArgs'] pubsub: Notification config for Pub/Sub.
        """
        if pubsub is not None:
            pulumi.set(__self__, 'pubsub', pubsub)

    @property
    @pulumi.getter
    def pubsub(self) ->Optional[pulumi.Input['PubSubArgs']]:
        """
        Notification config for Pub/Sub.
        """
        return pulumi.get(self, 'pubsub')

    @pubsub.setter
    def pubsub(self, value: Optional[pulumi.Input['PubSubArgs']]):
        pulumi.set(self, 'pubsub', value)


@pulumi.input_type
class PlacementPolicyArgs:

    def __init__(__self__, *, type: Optional[pulumi.Input[
        'PlacementPolicyType']]=None):
        """
        PlacementPolicy defines the placement policy used by the node pool.
        :param pulumi.Input['PlacementPolicyType'] type: The type of placement.
        """
        if type is not None:
            pulumi.set(__self__, 'type', type)

    @property
    @pulumi.getter
    def type(self) ->Optional[pulumi.Input['PlacementPolicyType']]:
        """
        The type of placement.
        """
        return pulumi.get(self, 'type')

    @type.setter
    def type(self, value: Optional[pulumi.Input['PlacementPolicyType']]):
        pulumi.set(self, 'type', value)


@pulumi.input_type
class PodCIDROverprovisionConfigArgs:

    def __init__(__self__, *, disable: Optional[pulumi.Input[bool]]=None):
        """
        [PRIVATE FIELD] Config for pod CIDR size overprovisioning.
        :param pulumi.Input[bool] disable: Whether Pod CIDR overprovisioning is disabled. Note: Pod CIDR overprovisioning is enabled by default.
        """
        if disable is not None:
            pulumi.set(__self__, 'disable', disable)

    @property
    @pulumi.getter
    def disable(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Pod CIDR overprovisioning is disabled. Note: Pod CIDR overprovisioning is enabled by default.
        """
        return pulumi.get(self, 'disable')

    @disable.setter
    def disable(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'disable', value)


@pulumi.input_type
class PodSecurityPolicyConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for the PodSecurityPolicy feature.
        :param pulumi.Input[bool] enabled: Enable the PodSecurityPolicy controller for this cluster. If enabled, pods must be valid under a PodSecurityPolicy to be created.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Enable the PodSecurityPolicy controller for this cluster. If enabled, pods must be valid under a PodSecurityPolicy to be created.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class PrivateClusterConfigArgs:

    def __init__(__self__, *, enable_private_endpoint: Optional[pulumi.
        Input[bool]]=None, enable_private_nodes: Optional[pulumi.Input[bool
        ]]=None, master_global_access_config: Optional[pulumi.Input[
        'PrivateClusterMasterGlobalAccessConfigArgs']]=None,
        master_ipv4_cidr_block: Optional[pulumi.Input[str]]=None,
        private_endpoint_subnetwork: Optional[pulumi.Input[str]]=None):
        """
        Configuration options for private clusters.
        :param pulumi.Input[bool] enable_private_endpoint: Whether the master's internal IP address is used as the cluster endpoint.
        :param pulumi.Input[bool] enable_private_nodes: Whether nodes have internal IP addresses only. If enabled, all nodes are given only RFC 1918 private addresses and communicate with the master via private networking.
        :param pulumi.Input['PrivateClusterMasterGlobalAccessConfigArgs'] master_global_access_config: Controls master global access settings.
        :param pulumi.Input[str] master_ipv4_cidr_block: The IP range in CIDR notation to use for the hosted master network. This range will be used for assigning internal IP addresses to the master or set of masters, as well as the ILB VIP. This range must not overlap with any other ranges in use within the cluster's network.
        :param pulumi.Input[str] private_endpoint_subnetwork: Subnet to provision the master's private endpoint during cluster creation. Specified in projects/*/regions/*/subnetworks/* format.
        """
        if enable_private_endpoint is not None:
            pulumi.set(__self__, 'enable_private_endpoint',
                enable_private_endpoint)
        if enable_private_nodes is not None:
            pulumi.set(__self__, 'enable_private_nodes', enable_private_nodes)
        if master_global_access_config is not None:
            pulumi.set(__self__, 'master_global_access_config',
                master_global_access_config)
        if master_ipv4_cidr_block is not None:
            pulumi.set(__self__, 'master_ipv4_cidr_block',
                master_ipv4_cidr_block)
        if private_endpoint_subnetwork is not None:
            pulumi.set(__self__, 'private_endpoint_subnetwork',
                private_endpoint_subnetwork)

    @property
    @pulumi.getter(name='enablePrivateEndpoint')
    def enable_private_endpoint(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the master's internal IP address is used as the cluster endpoint.
        """
        return pulumi.get(self, 'enable_private_endpoint')

    @enable_private_endpoint.setter
    def enable_private_endpoint(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_private_endpoint', value)

    @property
    @pulumi.getter(name='enablePrivateNodes')
    def enable_private_nodes(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether nodes have internal IP addresses only. If enabled, all nodes are given only RFC 1918 private addresses and communicate with the master via private networking.
        """
        return pulumi.get(self, 'enable_private_nodes')

    @enable_private_nodes.setter
    def enable_private_nodes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_private_nodes', value)

    @property
    @pulumi.getter(name='masterGlobalAccessConfig')
    def master_global_access_config(self) ->Optional[pulumi.Input[
        'PrivateClusterMasterGlobalAccessConfigArgs']]:
        """
        Controls master global access settings.
        """
        return pulumi.get(self, 'master_global_access_config')

    @master_global_access_config.setter
    def master_global_access_config(self, value: Optional[pulumi.Input[
        'PrivateClusterMasterGlobalAccessConfigArgs']]):
        pulumi.set(self, 'master_global_access_config', value)

    @property
    @pulumi.getter(name='masterIpv4CidrBlock')
    def master_ipv4_cidr_block(self) ->Optional[pulumi.Input[str]]:
        """
        The IP range in CIDR notation to use for the hosted master network. This range will be used for assigning internal IP addresses to the master or set of masters, as well as the ILB VIP. This range must not overlap with any other ranges in use within the cluster's network.
        """
        return pulumi.get(self, 'master_ipv4_cidr_block')

    @master_ipv4_cidr_block.setter
    def master_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'master_ipv4_cidr_block', value)

    @property
    @pulumi.getter(name='privateEndpointSubnetwork')
    def private_endpoint_subnetwork(self) ->Optional[pulumi.Input[str]]:
        """
        Subnet to provision the master's private endpoint during cluster creation. Specified in projects/*/regions/*/subnetworks/* format.
        """
        return pulumi.get(self, 'private_endpoint_subnetwork')

    @private_endpoint_subnetwork.setter
    def private_endpoint_subnetwork(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'private_endpoint_subnetwork', value)


@pulumi.input_type
class PrivateClusterMasterGlobalAccessConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for controlling master global access settings.
        :param pulumi.Input[bool] enabled: Whenever master is accessible globally or not.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whenever master is accessible globally or not.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class ProtectConfigArgs:

    def __init__(__self__, *, workload_config: Optional[pulumi.Input[
        'WorkloadConfigArgs']]=None, workload_vulnerability_mode: Optional[
        pulumi.Input['ProtectConfigWorkloadVulnerabilityMode']]=None):
        """
        ProtectConfig defines the flags needed to enable/disable features for the Protect API.
        :param pulumi.Input['WorkloadConfigArgs'] workload_config: WorkloadConfig defines which actions are enabled for a cluster's workload configurations.
        :param pulumi.Input['ProtectConfigWorkloadVulnerabilityMode'] workload_vulnerability_mode: Sets which mode to use for Protect workload vulnerability scanning feature.
        """
        if workload_config is not None:
            pulumi.set(__self__, 'workload_config', workload_config)
        if workload_vulnerability_mode is not None:
            pulumi.set(__self__, 'workload_vulnerability_mode',
                workload_vulnerability_mode)

    @property
    @pulumi.getter(name='workloadConfig')
    def workload_config(self) ->Optional[pulumi.Input['WorkloadConfigArgs']]:
        """
        WorkloadConfig defines which actions are enabled for a cluster's workload configurations.
        """
        return pulumi.get(self, 'workload_config')

    @workload_config.setter
    def workload_config(self, value: Optional[pulumi.Input[
        'WorkloadConfigArgs']]):
        pulumi.set(self, 'workload_config', value)

    @property
    @pulumi.getter(name='workloadVulnerabilityMode')
    def workload_vulnerability_mode(self) ->Optional[pulumi.Input[
        'ProtectConfigWorkloadVulnerabilityMode']]:
        """
        Sets which mode to use for Protect workload vulnerability scanning feature.
        """
        return pulumi.get(self, 'workload_vulnerability_mode')

    @workload_vulnerability_mode.setter
    def workload_vulnerability_mode(self, value: Optional[pulumi.Input[
        'ProtectConfigWorkloadVulnerabilityMode']]):
        pulumi.set(self, 'workload_vulnerability_mode', value)


@pulumi.input_type
class PubSubArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None,
        filter: Optional[pulumi.Input['FilterArgs']]=None, topic: Optional[
        pulumi.Input[str]]=None):
        """
        Pub/Sub specific notification config.
        :param pulumi.Input[bool] enabled: Enable notifications for Pub/Sub.
        :param pulumi.Input['FilterArgs'] filter: Allows filtering to one or more specific event types. If no filter is specified, or if a filter is specified with no event types, all event types will be sent
        :param pulumi.Input[str] topic: The desired Pub/Sub topic to which notifications will be sent by GKE. Format is `projects/{project}/topics/{topic}`.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)
        if filter is not None:
            pulumi.set(__self__, 'filter', filter)
        if topic is not None:
            pulumi.set(__self__, 'topic', topic)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Enable notifications for Pub/Sub.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)

    @property
    @pulumi.getter
    def filter(self) ->Optional[pulumi.Input['FilterArgs']]:
        """
        Allows filtering to one or more specific event types. If no filter is specified, or if a filter is specified with no event types, all event types will be sent
        """
        return pulumi.get(self, 'filter')

    @filter.setter
    def filter(self, value: Optional[pulumi.Input['FilterArgs']]):
        pulumi.set(self, 'filter', value)

    @property
    @pulumi.getter
    def topic(self) ->Optional[pulumi.Input[str]]:
        """
        The desired Pub/Sub topic to which notifications will be sent by GKE. Format is `projects/{project}/topics/{topic}`.
        """
        return pulumi.get(self, 'topic')

    @topic.setter
    def topic(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'topic', value)


@pulumi.input_type
class RecurringTimeWindowArgs:

    def __init__(__self__, *, recurrence: Optional[pulumi.Input[str]]=None,
        window: Optional[pulumi.Input['TimeWindowArgs']]=None):
        """
        Represents an arbitrary window of time that recurs.
        :param pulumi.Input[str] recurrence: An RRULE (https://tools.ietf.org/html/rfc5545#section-3.8.5.3) for how this window reccurs. They go on for the span of time between the start and end time. For example, to have something repeat every weekday, you'd use: `FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR` To repeat some window daily (equivalent to the DailyMaintenanceWindow): `FREQ=DAILY` For the first weekend of every month: `FREQ=MONTHLY;BYSETPOS=1;BYDAY=SA,SU` This specifies how frequently the window starts. Eg, if you wanted to have a 9-5 UTC-4 window every weekday, you'd use something like: ``` start time = 2019-01-01T09:00:00-0400 end time = 2019-01-01T17:00:00-0400 recurrence = FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR ``` Windows can span multiple days. Eg, to make the window encompass every weekend from midnight Saturday till the last minute of Sunday UTC: ``` start time = 2019-01-05T00:00:00Z end time = 2019-01-07T23:59:00Z recurrence = FREQ=WEEKLY;BYDAY=SA ``` Note the start and end time's specific dates are largely arbitrary except to specify duration of the window and when it first starts. The FREQ values of HOURLY, MINUTELY, and SECONDLY are not supported.
        :param pulumi.Input['TimeWindowArgs'] window: The window of the first recurrence.
        """
        if recurrence is not None:
            pulumi.set(__self__, 'recurrence', recurrence)
        if window is not None:
            pulumi.set(__self__, 'window', window)

    @property
    @pulumi.getter
    def recurrence(self) ->Optional[pulumi.Input[str]]:
        """
        An RRULE (https://tools.ietf.org/html/rfc5545#section-3.8.5.3) for how this window reccurs. They go on for the span of time between the start and end time. For example, to have something repeat every weekday, you'd use: `FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR` To repeat some window daily (equivalent to the DailyMaintenanceWindow): `FREQ=DAILY` For the first weekend of every month: `FREQ=MONTHLY;BYSETPOS=1;BYDAY=SA,SU` This specifies how frequently the window starts. Eg, if you wanted to have a 9-5 UTC-4 window every weekday, you'd use something like: ``` start time = 2019-01-01T09:00:00-0400 end time = 2019-01-01T17:00:00-0400 recurrence = FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR ``` Windows can span multiple days. Eg, to make the window encompass every weekend from midnight Saturday till the last minute of Sunday UTC: ``` start time = 2019-01-05T00:00:00Z end time = 2019-01-07T23:59:00Z recurrence = FREQ=WEEKLY;BYDAY=SA ``` Note the start and end time's specific dates are largely arbitrary except to specify duration of the window and when it first starts. The FREQ values of HOURLY, MINUTELY, and SECONDLY are not supported.
        """
        return pulumi.get(self, 'recurrence')

    @recurrence.setter
    def recurrence(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'recurrence', value)

    @property
    @pulumi.getter
    def window(self) ->Optional[pulumi.Input['TimeWindowArgs']]:
        """
        The window of the first recurrence.
        """
        return pulumi.get(self, 'window')

    @window.setter
    def window(self, value: Optional[pulumi.Input['TimeWindowArgs']]):
        pulumi.set(self, 'window', value)


@pulumi.input_type
class ReleaseChannelArgs:

    def __init__(__self__, *, channel: Optional[pulumi.Input[
        'ReleaseChannelChannel']]=None):
        """
        ReleaseChannel indicates which release channel a cluster is subscribed to. Release channels are arranged in order of risk. When a cluster is subscribed to a release channel, Google maintains both the master version and the node version. Node auto-upgrade defaults to true and cannot be disabled.
        :param pulumi.Input['ReleaseChannelChannel'] channel: channel specifies which release channel the cluster is subscribed to.
        """
        if channel is not None:
            pulumi.set(__self__, 'channel', channel)

    @property
    @pulumi.getter
    def channel(self) ->Optional[pulumi.Input['ReleaseChannelChannel']]:
        """
        channel specifies which release channel the cluster is subscribed to.
        """
        return pulumi.get(self, 'channel')

    @channel.setter
    def channel(self, value: Optional[pulumi.Input['ReleaseChannelChannel']]):
        pulumi.set(self, 'channel', value)


@pulumi.input_type
class ReservationAffinityArgs:

    def __init__(__self__, *, consume_reservation_type: Optional[pulumi.
        Input['ReservationAffinityConsumeReservationType']]=None, key:
        Optional[pulumi.Input[str]]=None, values: Optional[pulumi.Input[
        Sequence[pulumi.Input[str]]]]=None):
        """
        [ReservationAffinity](https://cloud.google.com/compute/docs/instances/reserving-zonal-resources) is the configuration of desired reservation which instances could take capacity from.
        :param pulumi.Input['ReservationAffinityConsumeReservationType'] consume_reservation_type: Corresponds to the type of reservation consumption.
        :param pulumi.Input[str] key: Corresponds to the label key of a reservation resource. To target a SPECIFIC_RESERVATION by name, specify "compute.googleapis.com/reservation-name" as the key and specify the name of your reservation as its value.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: Corresponds to the label value(s) of reservation resource(s).
        """
        if consume_reservation_type is not None:
            pulumi.set(__self__, 'consume_reservation_type',
                consume_reservation_type)
        if key is not None:
            pulumi.set(__self__, 'key', key)
        if values is not None:
            pulumi.set(__self__, 'values', values)

    @property
    @pulumi.getter(name='consumeReservationType')
    def consume_reservation_type(self) ->Optional[pulumi.Input[
        'ReservationAffinityConsumeReservationType']]:
        """
        Corresponds to the type of reservation consumption.
        """
        return pulumi.get(self, 'consume_reservation_type')

    @consume_reservation_type.setter
    def consume_reservation_type(self, value: Optional[pulumi.Input[
        'ReservationAffinityConsumeReservationType']]):
        pulumi.set(self, 'consume_reservation_type', value)

    @property
    @pulumi.getter
    def key(self) ->Optional[pulumi.Input[str]]:
        """
        Corresponds to the label key of a reservation resource. To target a SPECIFIC_RESERVATION by name, specify "compute.googleapis.com/reservation-name" as the key and specify the name of your reservation as its value.
        """
        return pulumi.get(self, 'key')

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'key', value)

    @property
    @pulumi.getter
    def values(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Corresponds to the label value(s) of reservation resource(s).
        """
        return pulumi.get(self, 'values')

    @values.setter
    def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]
        ):
        pulumi.set(self, 'values', value)


@pulumi.input_type
class ResourceLimitArgs:

    def __init__(__self__, *, maximum: Optional[pulumi.Input[str]]=None,
        minimum: Optional[pulumi.Input[str]]=None, resource_type: Optional[
        pulumi.Input[str]]=None):
        """
        Contains information about amount of some resource in the cluster. For memory, value should be in GB.
        :param pulumi.Input[str] maximum: Maximum amount of the resource in the cluster.
        :param pulumi.Input[str] minimum: Minimum amount of the resource in the cluster.
        :param pulumi.Input[str] resource_type: Resource name "cpu", "memory" or gpu-specific string.
        """
        if maximum is not None:
            pulumi.set(__self__, 'maximum', maximum)
        if minimum is not None:
            pulumi.set(__self__, 'minimum', minimum)
        if resource_type is not None:
            pulumi.set(__self__, 'resource_type', resource_type)

    @property
    @pulumi.getter
    def maximum(self) ->Optional[pulumi.Input[str]]:
        """
        Maximum amount of the resource in the cluster.
        """
        return pulumi.get(self, 'maximum')

    @maximum.setter
    def maximum(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'maximum', value)

    @property
    @pulumi.getter
    def minimum(self) ->Optional[pulumi.Input[str]]:
        """
        Minimum amount of the resource in the cluster.
        """
        return pulumi.get(self, 'minimum')

    @minimum.setter
    def minimum(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'minimum', value)

    @property
    @pulumi.getter(name='resourceType')
    def resource_type(self) ->Optional[pulumi.Input[str]]:
        """
        Resource name "cpu", "memory" or gpu-specific string.
        """
        return pulumi.get(self, 'resource_type')

    @resource_type.setter
    def resource_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'resource_type', value)


@pulumi.input_type
class ResourceUsageExportConfigArgs:

    def __init__(__self__, *, bigquery_destination: Optional[pulumi.Input[
        'BigQueryDestinationArgs']]=None, consumption_metering_config:
        Optional[pulumi.Input['ConsumptionMeteringConfigArgs']]=None,
        enable_network_egress_metering: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for exporting cluster resource usages.
        :param pulumi.Input['BigQueryDestinationArgs'] bigquery_destination: Configuration to use BigQuery as usage export destination.
        :param pulumi.Input['ConsumptionMeteringConfigArgs'] consumption_metering_config: Configuration to enable resource consumption metering.
        :param pulumi.Input[bool] enable_network_egress_metering: Whether to enable network egress metering for this cluster. If enabled, a daemonset will be created in the cluster to meter network egress traffic.
        """
        if bigquery_destination is not None:
            pulumi.set(__self__, 'bigquery_destination', bigquery_destination)
        if consumption_metering_config is not None:
            pulumi.set(__self__, 'consumption_metering_config',
                consumption_metering_config)
        if enable_network_egress_metering is not None:
            pulumi.set(__self__, 'enable_network_egress_metering',
                enable_network_egress_metering)

    @property
    @pulumi.getter(name='bigqueryDestination')
    def bigquery_destination(self) ->Optional[pulumi.Input[
        'BigQueryDestinationArgs']]:
        """
        Configuration to use BigQuery as usage export destination.
        """
        return pulumi.get(self, 'bigquery_destination')

    @bigquery_destination.setter
    def bigquery_destination(self, value: Optional[pulumi.Input[
        'BigQueryDestinationArgs']]):
        pulumi.set(self, 'bigquery_destination', value)

    @property
    @pulumi.getter(name='consumptionMeteringConfig')
    def consumption_metering_config(self) ->Optional[pulumi.Input[
        'ConsumptionMeteringConfigArgs']]:
        """
        Configuration to enable resource consumption metering.
        """
        return pulumi.get(self, 'consumption_metering_config')

    @consumption_metering_config.setter
    def consumption_metering_config(self, value: Optional[pulumi.Input[
        'ConsumptionMeteringConfigArgs']]):
        pulumi.set(self, 'consumption_metering_config', value)

    @property
    @pulumi.getter(name='enableNetworkEgressMetering')
    def enable_network_egress_metering(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether to enable network egress metering for this cluster. If enabled, a daemonset will be created in the cluster to meter network egress traffic.
        """
        return pulumi.get(self, 'enable_network_egress_metering')

    @enable_network_egress_metering.setter
    def enable_network_egress_metering(self, value: Optional[pulumi.Input[
        bool]]):
        pulumi.set(self, 'enable_network_egress_metering', value)


@pulumi.input_type
class SandboxConfigArgs:

    def __init__(__self__, *, sandbox_type: Optional[pulumi.Input[str]]=
        None, type: Optional[pulumi.Input['SandboxConfigType']]=None):
        """
        SandboxConfig contains configurations of the sandbox to use for the node.
        :param pulumi.Input[str] sandbox_type: Type of the sandbox to use for the node (e.g. 'gvisor')
        :param pulumi.Input['SandboxConfigType'] type: Type of the sandbox to use for the node.
        """
        if sandbox_type is not None:
            pulumi.set(__self__, 'sandbox_type', sandbox_type)
        if type is not None:
            pulumi.set(__self__, 'type', type)

    @property
    @pulumi.getter(name='sandboxType')
    def sandbox_type(self) ->Optional[pulumi.Input[str]]:
        """
        Type of the sandbox to use for the node (e.g. 'gvisor')
        """
        return pulumi.get(self, 'sandbox_type')

    @sandbox_type.setter
    def sandbox_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'sandbox_type', value)

    @property
    @pulumi.getter
    def type(self) ->Optional[pulumi.Input['SandboxConfigType']]:
        """
        Type of the sandbox to use for the node.
        """
        return pulumi.get(self, 'type')

    @type.setter
    def type(self, value: Optional[pulumi.Input['SandboxConfigType']]):
        pulumi.set(self, 'type', value)


@pulumi.input_type
class ServiceExternalIPsConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Config to block services with externalIPs field.
        :param pulumi.Input[bool] enabled: Whether Services with ExternalIPs field are allowed or not.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Services with ExternalIPs field are allowed or not.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class ShieldedInstanceConfigArgs:

    def __init__(__self__, *, enable_integrity_monitoring: Optional[pulumi.
        Input[bool]]=None, enable_secure_boot: Optional[pulumi.Input[bool]]
        =None):
        """
        A set of Shielded Instance options.
        :param pulumi.Input[bool] enable_integrity_monitoring: Defines whether the instance has integrity monitoring enabled. Enables monitoring and attestation of the boot integrity of the instance. The attestation is performed against the integrity policy baseline. This baseline is initially derived from the implicitly trusted boot image when the instance is created.
        :param pulumi.Input[bool] enable_secure_boot: Defines whether the instance has Secure Boot enabled. Secure Boot helps ensure that the system only runs authentic software by verifying the digital signature of all boot components, and halting the boot process if signature verification fails.
        """
        if enable_integrity_monitoring is not None:
            pulumi.set(__self__, 'enable_integrity_monitoring',
                enable_integrity_monitoring)
        if enable_secure_boot is not None:
            pulumi.set(__self__, 'enable_secure_boot', enable_secure_boot)

    @property
    @pulumi.getter(name='enableIntegrityMonitoring')
    def enable_integrity_monitoring(self) ->Optional[pulumi.Input[bool]]:
        """
        Defines whether the instance has integrity monitoring enabled. Enables monitoring and attestation of the boot integrity of the instance. The attestation is performed against the integrity policy baseline. This baseline is initially derived from the implicitly trusted boot image when the instance is created.
        """
        return pulumi.get(self, 'enable_integrity_monitoring')

    @enable_integrity_monitoring.setter
    def enable_integrity_monitoring(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_integrity_monitoring', value)

    @property
    @pulumi.getter(name='enableSecureBoot')
    def enable_secure_boot(self) ->Optional[pulumi.Input[bool]]:
        """
        Defines whether the instance has Secure Boot enabled. Secure Boot helps ensure that the system only runs authentic software by verifying the digital signature of all boot components, and halting the boot process if signature verification fails.
        """
        return pulumi.get(self, 'enable_secure_boot')

    @enable_secure_boot.setter
    def enable_secure_boot(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_secure_boot', value)


@pulumi.input_type
class ShieldedNodesArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration of Shielded Nodes feature.
        :param pulumi.Input[bool] enabled: Whether Shielded Nodes features are enabled on all nodes in this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Shielded Nodes features are enabled on all nodes in this cluster.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class StandardRolloutPolicyArgs:

    def __init__(__self__, *, batch_node_count: Optional[pulumi.Input[int]]
        =None, batch_percentage: Optional[pulumi.Input[float]]=None,
        batch_soak_duration: Optional[pulumi.Input[str]]=None):
        """
        Standard rollout policy is the default policy for blue-green.
        :param pulumi.Input[int] batch_node_count: Number of blue nodes to drain in a batch.
        :param pulumi.Input[float] batch_percentage: Percentage of the blue pool nodes to drain in a batch. The range of this field should be (0.0, 1.0].
        :param pulumi.Input[str] batch_soak_duration: Soak time after each batch gets drained. Default to zero.
        """
        if batch_node_count is not None:
            pulumi.set(__self__, 'batch_node_count', batch_node_count)
        if batch_percentage is not None:
            pulumi.set(__self__, 'batch_percentage', batch_percentage)
        if batch_soak_duration is not None:
            pulumi.set(__self__, 'batch_soak_duration', batch_soak_duration)

    @property
    @pulumi.getter(name='batchNodeCount')
    def batch_node_count(self) ->Optional[pulumi.Input[int]]:
        """
        Number of blue nodes to drain in a batch.
        """
        return pulumi.get(self, 'batch_node_count')

    @batch_node_count.setter
    def batch_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'batch_node_count', value)

    @property
    @pulumi.getter(name='batchPercentage')
    def batch_percentage(self) ->Optional[pulumi.Input[float]]:
        """
        Percentage of the blue pool nodes to drain in a batch. The range of this field should be (0.0, 1.0].
        """
        return pulumi.get(self, 'batch_percentage')

    @batch_percentage.setter
    def batch_percentage(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, 'batch_percentage', value)

    @property
    @pulumi.getter(name='batchSoakDuration')
    def batch_soak_duration(self) ->Optional[pulumi.Input[str]]:
        """
        Soak time after each batch gets drained. Default to zero.
        """
        return pulumi.get(self, 'batch_soak_duration')

    @batch_soak_duration.setter
    def batch_soak_duration(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'batch_soak_duration', value)


@pulumi.input_type
class StatusConditionArgs:

    def __init__(__self__, *, canonical_code: Optional[pulumi.Input[
        'StatusConditionCanonicalCode']]=None, code: Optional[pulumi.Input[
        'StatusConditionCode']]=None, message: Optional[pulumi.Input[str]]=None
        ):
        """
        StatusCondition describes why a cluster or a node pool has a certain status (e.g., ERROR or DEGRADED).
        :param pulumi.Input['StatusConditionCanonicalCode'] canonical_code: Canonical code of the condition.
        :param pulumi.Input['StatusConditionCode'] code: Machine-friendly representation of the condition Deprecated. Use canonical_code instead.
        :param pulumi.Input[str] message: Human-friendly representation of the condition
        """
        if canonical_code is not None:
            pulumi.set(__self__, 'canonical_code', canonical_code)
        if code is not None:
            warnings.warn(
                'Machine-friendly representation of the condition Deprecated. Use canonical_code instead.'
                , DeprecationWarning)
            pulumi.log.warn(
                'code is deprecated: Machine-friendly representation of the condition Deprecated. Use canonical_code instead.'
                )
        if code is not None:
            pulumi.set(__self__, 'code', code)
        if message is not None:
            pulumi.set(__self__, 'message', message)

    @property
    @pulumi.getter(name='canonicalCode')
    def canonical_code(self) ->Optional[pulumi.Input[
        'StatusConditionCanonicalCode']]:
        """
        Canonical code of the condition.
        """
        return pulumi.get(self, 'canonical_code')

    @canonical_code.setter
    def canonical_code(self, value: Optional[pulumi.Input[
        'StatusConditionCanonicalCode']]):
        pulumi.set(self, 'canonical_code', value)

    @property
    @pulumi.getter
    def code(self) ->Optional[pulumi.Input['StatusConditionCode']]:
        """
        Machine-friendly representation of the condition Deprecated. Use canonical_code instead.
        """
        warnings.warn(
            'Machine-friendly representation of the condition Deprecated. Use canonical_code instead.'
            , DeprecationWarning)
        pulumi.log.warn(
            'code is deprecated: Machine-friendly representation of the condition Deprecated. Use canonical_code instead.'
            )
        return pulumi.get(self, 'code')

    @code.setter
    def code(self, value: Optional[pulumi.Input['StatusConditionCode']]):
        pulumi.set(self, 'code', value)

    @property
    @pulumi.getter
    def message(self) ->Optional[pulumi.Input[str]]:
        """
        Human-friendly representation of the condition
        """
        return pulumi.get(self, 'message')

    @message.setter
    def message(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'message', value)


@pulumi.input_type
class TimeWindowArgs:

    def __init__(__self__, *, end_time: Optional[pulumi.Input[str]]=None,
        maintenance_exclusion_options: Optional[pulumi.Input[
        'MaintenanceExclusionOptionsArgs']]=None, start_time: Optional[
        pulumi.Input[str]]=None):
        """
        Represents an arbitrary window of time.
        :param pulumi.Input[str] end_time: The time that the window ends. The end time should take place after the start time.
        :param pulumi.Input['MaintenanceExclusionOptionsArgs'] maintenance_exclusion_options: MaintenanceExclusionOptions provides maintenance exclusion related options.
        :param pulumi.Input[str] start_time: The time that the window first starts.
        """
        if end_time is not None:
            pulumi.set(__self__, 'end_time', end_time)
        if maintenance_exclusion_options is not None:
            pulumi.set(__self__, 'maintenance_exclusion_options',
                maintenance_exclusion_options)
        if start_time is not None:
            pulumi.set(__self__, 'start_time', start_time)

    @property
    @pulumi.getter(name='endTime')
    def end_time(self) ->Optional[pulumi.Input[str]]:
        """
        The time that the window ends. The end time should take place after the start time.
        """
        return pulumi.get(self, 'end_time')

    @end_time.setter
    def end_time(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'end_time', value)

    @property
    @pulumi.getter(name='maintenanceExclusionOptions')
    def maintenance_exclusion_options(self) ->Optional[pulumi.Input[
        'MaintenanceExclusionOptionsArgs']]:
        """
        MaintenanceExclusionOptions provides maintenance exclusion related options.
        """
        return pulumi.get(self, 'maintenance_exclusion_options')

    @maintenance_exclusion_options.setter
    def maintenance_exclusion_options(self, value: Optional[pulumi.Input[
        'MaintenanceExclusionOptionsArgs']]):
        pulumi.set(self, 'maintenance_exclusion_options', value)

    @property
    @pulumi.getter(name='startTime')
    def start_time(self) ->Optional[pulumi.Input[str]]:
        """
        The time that the window first starts.
        """
        return pulumi.get(self, 'start_time')

    @start_time.setter
    def start_time(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'start_time', value)


@pulumi.input_type
class TpuConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None,
        ipv4_cidr_block: Optional[pulumi.Input[str]]=None,
        use_service_networking: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for Cloud TPU.
        :param pulumi.Input[bool] enabled: Whether Cloud TPU integration is enabled or not.
        :param pulumi.Input[str] ipv4_cidr_block: IPv4 CIDR block reserved for Cloud TPU in the VPC.
        :param pulumi.Input[bool] use_service_networking: Whether to use service networking for Cloud TPU or not.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)
        if ipv4_cidr_block is not None:
            pulumi.set(__self__, 'ipv4_cidr_block', ipv4_cidr_block)
        if use_service_networking is not None:
            pulumi.set(__self__, 'use_service_networking',
                use_service_networking)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Cloud TPU integration is enabled or not.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)

    @property
    @pulumi.getter(name='ipv4CidrBlock')
    def ipv4_cidr_block(self) ->Optional[pulumi.Input[str]]:
        """
        IPv4 CIDR block reserved for Cloud TPU in the VPC.
        """
        return pulumi.get(self, 'ipv4_cidr_block')

    @ipv4_cidr_block.setter
    def ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'ipv4_cidr_block', value)

    @property
    @pulumi.getter(name='useServiceNetworking')
    def use_service_networking(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether to use service networking for Cloud TPU or not.
        """
        return pulumi.get(self, 'use_service_networking')

    @use_service_networking.setter
    def use_service_networking(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'use_service_networking', value)


@pulumi.input_type
class UpgradeSettingsArgs:

    def __init__(__self__, *, blue_green_settings: Optional[pulumi.Input[
        'BlueGreenSettingsArgs']]=None, max_surge: Optional[pulumi.Input[
        int]]=None, max_unavailable: Optional[pulumi.Input[int]]=None,
        strategy: Optional[pulumi.Input['UpgradeSettingsStrategy']]=None):
        """
        These upgrade settings configure the upgrade strategy for the node pool. Use strategy to switch between the strategies applied to the node pool. If the strategy is SURGE, use max_surge and max_unavailable to control the level of parallelism and the level of disruption caused by upgrade. 1. maxSurge controls the number of additional nodes that can be added to the node pool temporarily for the time of the upgrade to increase the number of available nodes. 2. maxUnavailable controls the number of nodes that can be simultaneously unavailable. 3. (maxUnavailable + maxSurge) determines the level of parallelism (how many nodes are being upgraded at the same time). If the strategy is BLUE_GREEN, use blue_green_settings to configure the blue-green upgrade related settings. 1. standard_rollout_policy is the default policy. The policy is used to control the way blue pool gets drained. The draining is executed in the batch mode. The batch size could be specified as either percentage of the node pool size or the number of nodes. batch_soak_duration is the soak time after each batch gets drained. 2. node_pool_soak_duration is the soak time after all blue nodes are drained. After this period, the blue pool nodes will be deleted.
        :param pulumi.Input['BlueGreenSettingsArgs'] blue_green_settings: Settings for blue-green upgrade strategy.
        :param pulumi.Input[int] max_surge: The maximum number of nodes that can be created beyond the current size of the node pool during the upgrade process.
        :param pulumi.Input[int] max_unavailable: The maximum number of nodes that can be simultaneously unavailable during the upgrade process. A node is considered available if its status is Ready.
        :param pulumi.Input['UpgradeSettingsStrategy'] strategy: Update strategy of the node pool.
        """
        if blue_green_settings is not None:
            pulumi.set(__self__, 'blue_green_settings', blue_green_settings)
        if max_surge is not None:
            pulumi.set(__self__, 'max_surge', max_surge)
        if max_unavailable is not None:
            pulumi.set(__self__, 'max_unavailable', max_unavailable)
        if strategy is not None:
            pulumi.set(__self__, 'strategy', strategy)

    @property
    @pulumi.getter(name='blueGreenSettings')
    def blue_green_settings(self) ->Optional[pulumi.Input[
        'BlueGreenSettingsArgs']]:
        """
        Settings for blue-green upgrade strategy.
        """
        return pulumi.get(self, 'blue_green_settings')

    @blue_green_settings.setter
    def blue_green_settings(self, value: Optional[pulumi.Input[
        'BlueGreenSettingsArgs']]):
        pulumi.set(self, 'blue_green_settings', value)

    @property
    @pulumi.getter(name='maxSurge')
    def max_surge(self) ->Optional[pulumi.Input[int]]:
        """
        The maximum number of nodes that can be created beyond the current size of the node pool during the upgrade process.
        """
        return pulumi.get(self, 'max_surge')

    @max_surge.setter
    def max_surge(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'max_surge', value)

    @property
    @pulumi.getter(name='maxUnavailable')
    def max_unavailable(self) ->Optional[pulumi.Input[int]]:
        """
        The maximum number of nodes that can be simultaneously unavailable during the upgrade process. A node is considered available if its status is Ready.
        """
        return pulumi.get(self, 'max_unavailable')

    @max_unavailable.setter
    def max_unavailable(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'max_unavailable', value)

    @property
    @pulumi.getter
    def strategy(self) ->Optional[pulumi.Input['UpgradeSettingsStrategy']]:
        """
        Update strategy of the node pool.
        """
        return pulumi.get(self, 'strategy')

    @strategy.setter
    def strategy(self, value: Optional[pulumi.Input['UpgradeSettingsStrategy']]
        ):
        pulumi.set(self, 'strategy', value)


@pulumi.input_type
class VerticalPodAutoscalingArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        VerticalPodAutoscaling contains global, per-cluster information required by Vertical Pod Autoscaler to automatically adjust the resources of pods controlled by it.
        :param pulumi.Input[bool] enabled: Enables vertical pod autoscaling.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Enables vertical pod autoscaling.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class VirtualNICArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration of gVNIC feature.
        :param pulumi.Input[bool] enabled: Whether gVNIC features are enabled in the node pool.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether gVNIC features are enabled in the node pool.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class WindowsNodeConfigArgs:

    def __init__(__self__, *, os_version: Optional[pulumi.Input[
        'WindowsNodeConfigOsVersion']]=None):
        """
        Parameters that can be configured on Windows nodes. Windows Node Config that define the parameters that will be used to configure the Windows node pool settings
        :param pulumi.Input['WindowsNodeConfigOsVersion'] os_version: OSVersion specifies the Windows node config to be used on the node
        """
        if os_version is not None:
            pulumi.set(__self__, 'os_version', os_version)

    @property
    @pulumi.getter(name='osVersion')
    def os_version(self) ->Optional[pulumi.Input['WindowsNodeConfigOsVersion']
        ]:
        """
        OSVersion specifies the Windows node config to be used on the node
        """
        return pulumi.get(self, 'os_version')

    @os_version.setter
    def os_version(self, value: Optional[pulumi.Input[
        'WindowsNodeConfigOsVersion']]):
        pulumi.set(self, 'os_version', value)


@pulumi.input_type
class WorkloadALTSConfigArgs:

    def __init__(__self__, *, enable_alts: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for direct-path (via ALTS) with workload identity.
        :param pulumi.Input[bool] enable_alts: enable_alts controls whether the alts handshaker should be enabled or not for direct-path. Requires Workload Identity (workload_pool must be non-empty).
        """
        if enable_alts is not None:
            pulumi.set(__self__, 'enable_alts', enable_alts)

    @property
    @pulumi.getter(name='enableAlts')
    def enable_alts(self) ->Optional[pulumi.Input[bool]]:
        """
        enable_alts controls whether the alts handshaker should be enabled or not for direct-path. Requires Workload Identity (workload_pool must be non-empty).
        """
        return pulumi.get(self, 'enable_alts')

    @enable_alts.setter
    def enable_alts(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_alts', value)


@pulumi.input_type
class WorkloadCertificatesArgs:

    def __init__(__self__, *, enable_certificates: Optional[pulumi.Input[
        bool]]=None):
        """
        Configuration for issuance of mTLS keys and certificates to Kubernetes pods.
        :param pulumi.Input[bool] enable_certificates: enable_certificates controls issuance of workload mTLS certificates. If set, the GKE Workload Identity Certificates controller and node agent will be deployed in the cluster, which can then be configured by creating a WorkloadCertificateConfig Custom Resource. Requires Workload Identity (workload_pool must be non-empty).
        """
        if enable_certificates is not None:
            pulumi.set(__self__, 'enable_certificates', enable_certificates)

    @property
    @pulumi.getter(name='enableCertificates')
    def enable_certificates(self) ->Optional[pulumi.Input[bool]]:
        """
        enable_certificates controls issuance of workload mTLS certificates. If set, the GKE Workload Identity Certificates controller and node agent will be deployed in the cluster, which can then be configured by creating a WorkloadCertificateConfig Custom Resource. Requires Workload Identity (workload_pool must be non-empty).
        """
        return pulumi.get(self, 'enable_certificates')

    @enable_certificates.setter
    def enable_certificates(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_certificates', value)


@pulumi.input_type
class WorkloadConfigArgs:

    def __init__(__self__, *, audit_mode: Optional[pulumi.Input[
        'WorkloadConfigAuditMode']]=None):
        """
        WorkloadConfig defines the flags to enable or disable the workload configurations for the cluster.
        :param pulumi.Input['WorkloadConfigAuditMode'] audit_mode: Sets which mode of auditing should be used for the cluster's workloads.
        """
        if audit_mode is not None:
            pulumi.set(__self__, 'audit_mode', audit_mode)

    @property
    @pulumi.getter(name='auditMode')
    def audit_mode(self) ->Optional[pulumi.Input['WorkloadConfigAuditMode']]:
        """
        Sets which mode of auditing should be used for the cluster's workloads.
        """
        return pulumi.get(self, 'audit_mode')

    @audit_mode.setter
    def audit_mode(self, value: Optional[pulumi.Input[
        'WorkloadConfigAuditMode']]):
        pulumi.set(self, 'audit_mode', value)


@pulumi.input_type
class WorkloadIdentityConfigArgs:

    def __init__(__self__, *, identity_namespace: Optional[pulumi.Input[str
        ]]=None, identity_provider: Optional[pulumi.Input[str]]=None,
        workload_pool: Optional[pulumi.Input[str]]=None):
        """
        Configuration for the use of Kubernetes Service Accounts in GCP IAM policies.
        :param pulumi.Input[str] identity_namespace: IAM Identity Namespace to attach all Kubernetes Service Accounts to.
        :param pulumi.Input[str] identity_provider: identity provider is the third party identity provider.
        :param pulumi.Input[str] workload_pool: The workload pool to attach all Kubernetes service accounts to.
        """
        if identity_namespace is not None:
            pulumi.set(__self__, 'identity_namespace', identity_namespace)
        if identity_provider is not None:
            pulumi.set(__self__, 'identity_provider', identity_provider)
        if workload_pool is not None:
            pulumi.set(__self__, 'workload_pool', workload_pool)

    @property
    @pulumi.getter(name='identityNamespace')
    def identity_namespace(self) ->Optional[pulumi.Input[str]]:
        """
        IAM Identity Namespace to attach all Kubernetes Service Accounts to.
        """
        return pulumi.get(self, 'identity_namespace')

    @identity_namespace.setter
    def identity_namespace(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'identity_namespace', value)

    @property
    @pulumi.getter(name='identityProvider')
    def identity_provider(self) ->Optional[pulumi.Input[str]]:
        """
        identity provider is the third party identity provider.
        """
        return pulumi.get(self, 'identity_provider')

    @identity_provider.setter
    def identity_provider(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'identity_provider', value)

    @property
    @pulumi.getter(name='workloadPool')
    def workload_pool(self) ->Optional[pulumi.Input[str]]:
        """
        The workload pool to attach all Kubernetes service accounts to.
        """
        return pulumi.get(self, 'workload_pool')

    @workload_pool.setter
    def workload_pool(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'workload_pool', value)


@pulumi.input_type
class WorkloadMetadataConfigArgs:

    def __init__(__self__, *, mode: Optional[pulumi.Input[
        'WorkloadMetadataConfigMode']]=None, node_metadata: Optional[pulumi
        .Input['WorkloadMetadataConfigNodeMetadata']]=None):
        """
        WorkloadMetadataConfig defines the metadata configuration to expose to workloads on the node pool.
        :param pulumi.Input['WorkloadMetadataConfigMode'] mode: Mode is the configuration for how to expose metadata to workloads running on the node pool.
        :param pulumi.Input['WorkloadMetadataConfigNodeMetadata'] node_metadata: NodeMetadata is the configuration for how to expose metadata to the workloads running on the node.
        """
        if mode is not None:
            pulumi.set(__self__, 'mode', mode)
        if node_metadata is not None:
            pulumi.set(__self__, 'node_metadata', node_metadata)

    @property
    @pulumi.getter
    def mode(self) ->Optional[pulumi.Input['WorkloadMetadataConfigMode']]:
        """
        Mode is the configuration for how to expose metadata to workloads running on the node pool.
        """
        return pulumi.get(self, 'mode')

    @mode.setter
    def mode(self, value: Optional[pulumi.Input['WorkloadMetadataConfigMode']]
        ):
        pulumi.set(self, 'mode', value)

    @property
    @pulumi.getter(name='nodeMetadata')
    def node_metadata(self) ->Optional[pulumi.Input[
        'WorkloadMetadataConfigNodeMetadata']]:
        """
        NodeMetadata is the configuration for how to expose metadata to the workloads running on the node.
        """
        return pulumi.get(self, 'node_metadata')

    @node_metadata.setter
    def node_metadata(self, value: Optional[pulumi.Input[
        'WorkloadMetadataConfigNodeMetadata']]):
        pulumi.set(self, 'node_metadata', value)

<mask token>


@pulumi.input_type
class DatabaseEncryptionArgs:

    def __init__(__self__, *, key_name: Optional[pulumi.Input[str]]=None,
        state: Optional[pulumi.Input['DatabaseEncryptionState']]=None):
        """
        Configuration of etcd encryption.
        :param pulumi.Input[str] key_name: Name of CloudKMS key to use for the encryption of secrets in etcd. Ex. projects/my-project/locations/global/keyRings/my-ring/cryptoKeys/my-key
        :param pulumi.Input['DatabaseEncryptionState'] state: The desired state of etcd encryption.
        """
        if key_name is not None:
            pulumi.set(__self__, 'key_name', key_name)
        if state is not None:
            pulumi.set(__self__, 'state', state)
    <mask token>

    @key_name.setter
    def key_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'key_name', value)

    @property
    @pulumi.getter
    def state(self) ->Optional[pulumi.Input['DatabaseEncryptionState']]:
        """
        The desired state of etcd encryption.
        """
        return pulumi.get(self, 'state')

    @state.setter
    def state(self, value: Optional[pulumi.Input['DatabaseEncryptionState']]):
        pulumi.set(self, 'state', value)


@pulumi.input_type
class DefaultSnatStatusArgs:

    def __init__(__self__, *, disabled: Optional[pulumi.Input[bool]]=None):
        """
        DefaultSnatStatus contains the desired state of whether default sNAT should be disabled on the cluster.
        :param pulumi.Input[bool] disabled: Disables cluster default sNAT rules.
        """
        if disabled is not None:
            pulumi.set(__self__, 'disabled', disabled)

    @property
    @pulumi.getter
    def disabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Disables cluster default sNAT rules.
        """
        return pulumi.get(self, 'disabled')

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'disabled', value)


@pulumi.input_type
class DnsCacheConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for NodeLocal DNSCache
        :param pulumi.Input[bool] enabled: Whether NodeLocal DNSCache is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether NodeLocal DNSCache is enabled for this cluster.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class EphemeralStorageConfigArgs:

    def __init__(__self__, *, local_ssd_count: Optional[pulumi.Input[int]]=None
        ):
        """
        EphemeralStorageConfig contains configuration for the ephemeral storage filesystem.
        :param pulumi.Input[int] local_ssd_count: Number of local SSDs to use to back ephemeral storage. Uses NVMe interfaces. Each local SSD is 375 GB in size. If zero, it means to disable using local SSDs as ephemeral storage.
        """
        if local_ssd_count is not None:
            pulumi.set(__self__, 'local_ssd_count', local_ssd_count)

    @property
    @pulumi.getter(name='localSsdCount')
    def local_ssd_count(self) ->Optional[pulumi.Input[int]]:
        """
        Number of local SSDs to use to back ephemeral storage. Uses NVMe interfaces. Each local SSD is 375 GB in size. If zero, it means to disable using local SSDs as ephemeral storage.
        """
        return pulumi.get(self, 'local_ssd_count')

    @local_ssd_count.setter
    def local_ssd_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'local_ssd_count', value)


@pulumi.input_type
class EphemeralStorageLocalSsdConfigArgs:

    def __init__(__self__, *, local_ssd_count: Optional[pulumi.Input[int]]=None
        ):
        """
        EphemeralStorageLocalSsdConfig contains configuration for the node ephemeral storage using Local SSDs.
        :param pulumi.Input[int] local_ssd_count: Number of local SSDs to use to back ephemeral storage. Uses NVMe interfaces. Each local SSD is 375 GB in size. If zero, it means to disable using local SSDs as ephemeral storage. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        """
        if local_ssd_count is not None:
            pulumi.set(__self__, 'local_ssd_count', local_ssd_count)

    @property
    @pulumi.getter(name='localSsdCount')
    def local_ssd_count(self) ->Optional[pulumi.Input[int]]:
        """
        Number of local SSDs to use to back ephemeral storage. Uses NVMe interfaces. Each local SSD is 375 GB in size. If zero, it means to disable using local SSDs as ephemeral storage. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        """
        return pulumi.get(self, 'local_ssd_count')

    @local_ssd_count.setter
    def local_ssd_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'local_ssd_count', value)


@pulumi.input_type
class FastSocketArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration of Fast Socket feature.
        :param pulumi.Input[bool] enabled: Whether Fast Socket features are enabled in the node pool.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Fast Socket features are enabled in the node pool.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class FilterArgs:

    def __init__(__self__, *, event_type: Optional[pulumi.Input[Sequence[
        pulumi.Input['FilterEventTypeItem']]]]=None):
        """
        Allows filtering to one or more specific event types. If event types are present, those and only those event types will be transmitted to the cluster. Other types will be skipped. If no filter is specified, or no event types are present, all event types will be sent
        :param pulumi.Input[Sequence[pulumi.Input['FilterEventTypeItem']]] event_type: Event types to allowlist.
        """
        if event_type is not None:
            pulumi.set(__self__, 'event_type', event_type)

    @property
    @pulumi.getter(name='eventType')
    def event_type(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[
        'FilterEventTypeItem']]]]:
        """
        Event types to allowlist.
        """
        return pulumi.get(self, 'event_type')

    @event_type.setter
    def event_type(self, value: Optional[pulumi.Input[Sequence[pulumi.Input
        ['FilterEventTypeItem']]]]):
        pulumi.set(self, 'event_type', value)


@pulumi.input_type
class FleetArgs:

    def __init__(__self__, *, project: Optional[pulumi.Input[str]]=None):
        """
        Fleet is the fleet configuration for the cluster.
        :param pulumi.Input[str] project: The Fleet host project(project ID or project number) where this cluster will be registered to. This field cannot be changed after the cluster has been registered.
        """
        if project is not None:
            pulumi.set(__self__, 'project', project)

    @property
    @pulumi.getter
    def project(self) ->Optional[pulumi.Input[str]]:
        """
        The Fleet host project(project ID or project number) where this cluster will be registered to. This field cannot be changed after the cluster has been registered.
        """
        return pulumi.get(self, 'project')

    @project.setter
    def project(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'project', value)


@pulumi.input_type
class GPUSharingConfigArgs:

    def __init__(__self__, *, gpu_sharing_strategy: Optional[pulumi.Input[
        'GPUSharingConfigGpuSharingStrategy']]=None,
        max_shared_clients_per_gpu: Optional[pulumi.Input[str]]=None):
        """
        GPUSharingConfig represents the GPU sharing configuration for Hardware Accelerators.
        :param pulumi.Input['GPUSharingConfigGpuSharingStrategy'] gpu_sharing_strategy: The type of GPU sharing strategy to enable on the GPU node.
        :param pulumi.Input[str] max_shared_clients_per_gpu: The max number of containers that can share a physical GPU.
        """
        if gpu_sharing_strategy is not None:
            pulumi.set(__self__, 'gpu_sharing_strategy', gpu_sharing_strategy)
        if max_shared_clients_per_gpu is not None:
            pulumi.set(__self__, 'max_shared_clients_per_gpu',
                max_shared_clients_per_gpu)

    @property
    @pulumi.getter(name='gpuSharingStrategy')
    def gpu_sharing_strategy(self) ->Optional[pulumi.Input[
        'GPUSharingConfigGpuSharingStrategy']]:
        """
        The type of GPU sharing strategy to enable on the GPU node.
        """
        return pulumi.get(self, 'gpu_sharing_strategy')

    @gpu_sharing_strategy.setter
    def gpu_sharing_strategy(self, value: Optional[pulumi.Input[
        'GPUSharingConfigGpuSharingStrategy']]):
        pulumi.set(self, 'gpu_sharing_strategy', value)

    @property
    @pulumi.getter(name='maxSharedClientsPerGpu')
    def max_shared_clients_per_gpu(self) ->Optional[pulumi.Input[str]]:
        """
        The max number of containers that can share a physical GPU.
        """
        return pulumi.get(self, 'max_shared_clients_per_gpu')

    @max_shared_clients_per_gpu.setter
    def max_shared_clients_per_gpu(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'max_shared_clients_per_gpu', value)


@pulumi.input_type
class GatewayAPIConfigArgs:

    def __init__(__self__, *, channel: Optional[pulumi.Input[
        'GatewayAPIConfigChannel']]=None):
        """
        GatewayAPIConfig contains the desired config of Gateway API on this cluster.
        :param pulumi.Input['GatewayAPIConfigChannel'] channel: The Gateway API release channel to use for Gateway API.
        """
        if channel is not None:
            pulumi.set(__self__, 'channel', channel)

    @property
    @pulumi.getter
    def channel(self) ->Optional[pulumi.Input['GatewayAPIConfigChannel']]:
        """
        The Gateway API release channel to use for Gateway API.
        """
        return pulumi.get(self, 'channel')

    @channel.setter
    def channel(self, value: Optional[pulumi.Input['GatewayAPIConfigChannel']]
        ):
        pulumi.set(self, 'channel', value)


@pulumi.input_type
class GcePersistentDiskCsiDriverConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for the Compute Engine PD CSI driver.
        :param pulumi.Input[bool] enabled: Whether the Compute Engine PD CSI driver is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the Compute Engine PD CSI driver is enabled for this cluster.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class GcfsConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        GcfsConfig contains configurations of Google Container File System.
        :param pulumi.Input[bool] enabled: Whether to use GCFS.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether to use GCFS.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class GcpFilestoreCsiDriverConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for the GCP Filestore CSI driver.
        :param pulumi.Input[bool] enabled: Whether the GCP Filestore CSI driver is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the GCP Filestore CSI driver is enabled for this cluster.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class GcsFuseCsiDriverConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for the Cloud Storage Fuse CSI driver.
        :param pulumi.Input[bool] enabled: Whether the Cloud Storage Fuse CSI driver is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the Cloud Storage Fuse CSI driver is enabled for this cluster.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class GkeBackupAgentConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for the Backup for GKE Agent.
        :param pulumi.Input[bool] enabled: Whether the Backup for GKE agent is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the Backup for GKE agent is enabled for this cluster.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class HorizontalPodAutoscalingArgs:

    def __init__(__self__, *, disabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration options for the horizontal pod autoscaling feature, which increases or decreases the number of replica pods a replication controller has based on the resource usage of the existing pods.
        :param pulumi.Input[bool] disabled: Whether the Horizontal Pod Autoscaling feature is enabled in the cluster. When enabled, it ensures that metrics are collected into Stackdriver Monitoring.
        """
        if disabled is not None:
            pulumi.set(__self__, 'disabled', disabled)

    @property
    @pulumi.getter
    def disabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the Horizontal Pod Autoscaling feature is enabled in the cluster. When enabled, it ensures that metrics are collected into Stackdriver Monitoring.
        """
        return pulumi.get(self, 'disabled')

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'disabled', value)


@pulumi.input_type
class HttpLoadBalancingArgs:

    def __init__(__self__, *, disabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration options for the HTTP (L7) load balancing controller addon, which makes it easy to set up HTTP load balancers for services in a cluster.
        :param pulumi.Input[bool] disabled: Whether the HTTP Load Balancing controller is enabled in the cluster. When enabled, it runs a small pod in the cluster that manages the load balancers.
        """
        if disabled is not None:
            pulumi.set(__self__, 'disabled', disabled)

    @property
    @pulumi.getter
    def disabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the HTTP Load Balancing controller is enabled in the cluster. When enabled, it runs a small pod in the cluster that manages the load balancers.
        """
        return pulumi.get(self, 'disabled')

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'disabled', value)


@pulumi.input_type
class IPAllocationPolicyArgs:

    def __init__(__self__, *, allow_route_overlap: Optional[pulumi.Input[
        bool]]=None, cluster_ipv4_cidr: Optional[pulumi.Input[str]]=None,
        cluster_ipv4_cidr_block: Optional[pulumi.Input[str]]=None,
        cluster_secondary_range_name: Optional[pulumi.Input[str]]=None,
        create_subnetwork: Optional[pulumi.Input[bool]]=None,
        ipv6_access_type: Optional[pulumi.Input[
        'IPAllocationPolicyIpv6AccessType']]=None, node_ipv4_cidr: Optional
        [pulumi.Input[str]]=None, node_ipv4_cidr_block: Optional[pulumi.
        Input[str]]=None, pod_cidr_overprovision_config: Optional[pulumi.
        Input['PodCIDROverprovisionConfigArgs']]=None, services_ipv4_cidr:
        Optional[pulumi.Input[str]]=None, services_ipv4_cidr_block:
        Optional[pulumi.Input[str]]=None, services_secondary_range_name:
        Optional[pulumi.Input[str]]=None, stack_type: Optional[pulumi.Input
        ['IPAllocationPolicyStackType']]=None, subnetwork_name: Optional[
        pulumi.Input[str]]=None, tpu_ipv4_cidr_block: Optional[pulumi.Input
        [str]]=None, use_ip_aliases: Optional[pulumi.Input[bool]]=None,
        use_routes: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for controlling how IPs are allocated in the cluster.
        :param pulumi.Input[bool] allow_route_overlap: If true, allow allocation of cluster CIDR ranges that overlap with certain kinds of network routes. By default we do not allow cluster CIDR ranges to intersect with any user declared routes. With allow_route_overlap == true, we allow overlapping with CIDR ranges that are larger than the cluster CIDR range. If this field is set to true, then cluster and services CIDRs must be fully-specified (e.g. `10.96.0.0/14`, but not `/14`), which means: 1) When `use_ip_aliases` is true, `cluster_ipv4_cidr_block` and `services_ipv4_cidr_block` must be fully-specified. 2) When `use_ip_aliases` is false, `cluster.cluster_ipv4_cidr` muse be fully-specified.
        :param pulumi.Input[str] cluster_ipv4_cidr: This field is deprecated, use cluster_ipv4_cidr_block.
        :param pulumi.Input[str] cluster_ipv4_cidr_block: The IP address range for the cluster pod IPs. If this field is set, then `cluster.cluster_ipv4_cidr` must be left blank. This field is only applicable when `use_ip_aliases` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        :param pulumi.Input[str] cluster_secondary_range_name: The name of the secondary range to be used for the cluster CIDR block. The secondary range will be used for pod IP addresses. This must be an existing secondary range associated with the cluster subnetwork. This field is only applicable with use_ip_aliases and create_subnetwork is false.
        :param pulumi.Input[bool] create_subnetwork: Whether a new subnetwork will be created automatically for the cluster. This field is only applicable when `use_ip_aliases` is true.
        :param pulumi.Input['IPAllocationPolicyIpv6AccessType'] ipv6_access_type: The ipv6 access type (internal or external) when create_subnetwork is true
        :param pulumi.Input[str] node_ipv4_cidr: This field is deprecated, use node_ipv4_cidr_block.
        :param pulumi.Input[str] node_ipv4_cidr_block: The IP address range of the instance IPs in this cluster. This is applicable only if `create_subnetwork` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        :param pulumi.Input['PodCIDROverprovisionConfigArgs'] pod_cidr_overprovision_config: [PRIVATE FIELD] Pod CIDR size overprovisioning config for the cluster. Pod CIDR size per node depends on max_pods_per_node. By default, the value of max_pods_per_node is doubled and then rounded off to next power of 2 to get the size of pod CIDR block per node. Example: max_pods_per_node of 30 would result in 64 IPs (/26). This config can disable the doubling of IPs (we still round off to next power of 2) Example: max_pods_per_node of 30 will result in 32 IPs (/27) when overprovisioning is disabled.
        :param pulumi.Input[str] services_ipv4_cidr: This field is deprecated, use services_ipv4_cidr_block.
        :param pulumi.Input[str] services_ipv4_cidr_block: The IP address range of the services IPs in this cluster. If blank, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        :param pulumi.Input[str] services_secondary_range_name: The name of the secondary range to be used as for the services CIDR block. The secondary range will be used for service ClusterIPs. This must be an existing secondary range associated with the cluster subnetwork. This field is only applicable with use_ip_aliases and create_subnetwork is false.
        :param pulumi.Input['IPAllocationPolicyStackType'] stack_type: IP stack type
        :param pulumi.Input[str] subnetwork_name: A custom subnetwork name to be used if `create_subnetwork` is true. If this field is empty, then an automatic name will be chosen for the new subnetwork.
        :param pulumi.Input[str] tpu_ipv4_cidr_block: The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.
        :param pulumi.Input[bool] use_ip_aliases: Whether alias IPs will be used for pod IPs in the cluster. This is used in conjunction with use_routes. It cannot be true if use_routes is true. If both use_ip_aliases and use_routes are false, then the server picks the default IP allocation mode
        :param pulumi.Input[bool] use_routes: Whether routes will be used for pod IPs in the cluster. This is used in conjunction with use_ip_aliases. It cannot be true if use_ip_aliases is true. If both use_ip_aliases and use_routes are false, then the server picks the default IP allocation mode
        """
        if allow_route_overlap is not None:
            pulumi.set(__self__, 'allow_route_overlap', allow_route_overlap)
        if cluster_ipv4_cidr is not None:
            warnings.warn(
                'This field is deprecated, use cluster_ipv4_cidr_block.',
                DeprecationWarning)
            pulumi.log.warn(
                'cluster_ipv4_cidr is deprecated: This field is deprecated, use cluster_ipv4_cidr_block.'
                )
        if cluster_ipv4_cidr is not None:
            pulumi.set(__self__, 'cluster_ipv4_cidr', cluster_ipv4_cidr)
        if cluster_ipv4_cidr_block is not None:
            pulumi.set(__self__, 'cluster_ipv4_cidr_block',
                cluster_ipv4_cidr_block)
        if cluster_secondary_range_name is not None:
            pulumi.set(__self__, 'cluster_secondary_range_name',
                cluster_secondary_range_name)
        if create_subnetwork is not None:
            pulumi.set(__self__, 'create_subnetwork', create_subnetwork)
        if ipv6_access_type is not None:
            pulumi.set(__self__, 'ipv6_access_type', ipv6_access_type)
        if node_ipv4_cidr is not None:
            warnings.warn('This field is deprecated, use node_ipv4_cidr_block.'
                , DeprecationWarning)
            pulumi.log.warn(
                'node_ipv4_cidr is deprecated: This field is deprecated, use node_ipv4_cidr_block.'
                )
        if node_ipv4_cidr is not None:
            pulumi.set(__self__, 'node_ipv4_cidr', node_ipv4_cidr)
        if node_ipv4_cidr_block is not None:
            pulumi.set(__self__, 'node_ipv4_cidr_block', node_ipv4_cidr_block)
        if pod_cidr_overprovision_config is not None:
            pulumi.set(__self__, 'pod_cidr_overprovision_config',
                pod_cidr_overprovision_config)
        if services_ipv4_cidr is not None:
            warnings.warn(
                'This field is deprecated, use services_ipv4_cidr_block.',
                DeprecationWarning)
            pulumi.log.warn(
                'services_ipv4_cidr is deprecated: This field is deprecated, use services_ipv4_cidr_block.'
                )
        if services_ipv4_cidr is not None:
            pulumi.set(__self__, 'services_ipv4_cidr', services_ipv4_cidr)
        if services_ipv4_cidr_block is not None:
            pulumi.set(__self__, 'services_ipv4_cidr_block',
                services_ipv4_cidr_block)
        if services_secondary_range_name is not None:
            pulumi.set(__self__, 'services_secondary_range_name',
                services_secondary_range_name)
        if stack_type is not None:
            pulumi.set(__self__, 'stack_type', stack_type)
        if subnetwork_name is not None:
            pulumi.set(__self__, 'subnetwork_name', subnetwork_name)
        if tpu_ipv4_cidr_block is not None:
            warnings.warn(
                'The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.'
                , DeprecationWarning)
            pulumi.log.warn(
                'tpu_ipv4_cidr_block is deprecated: The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.'
                )
        if tpu_ipv4_cidr_block is not None:
            pulumi.set(__self__, 'tpu_ipv4_cidr_block', tpu_ipv4_cidr_block)
        if use_ip_aliases is not None:
            pulumi.set(__self__, 'use_ip_aliases', use_ip_aliases)
        if use_routes is not None:
            pulumi.set(__self__, 'use_routes', use_routes)

    @property
    @pulumi.getter(name='allowRouteOverlap')
    def allow_route_overlap(self) ->Optional[pulumi.Input[bool]]:
        """
        If true, allow allocation of cluster CIDR ranges that overlap with certain kinds of network routes. By default we do not allow cluster CIDR ranges to intersect with any user declared routes. With allow_route_overlap == true, we allow overlapping with CIDR ranges that are larger than the cluster CIDR range. If this field is set to true, then cluster and services CIDRs must be fully-specified (e.g. `10.96.0.0/14`, but not `/14`), which means: 1) When `use_ip_aliases` is true, `cluster_ipv4_cidr_block` and `services_ipv4_cidr_block` must be fully-specified. 2) When `use_ip_aliases` is false, `cluster.cluster_ipv4_cidr` muse be fully-specified.
        """
        return pulumi.get(self, 'allow_route_overlap')

    @allow_route_overlap.setter
    def allow_route_overlap(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'allow_route_overlap', value)

    @property
    @pulumi.getter(name='clusterIpv4Cidr')
    def cluster_ipv4_cidr(self) ->Optional[pulumi.Input[str]]:
        """
        This field is deprecated, use cluster_ipv4_cidr_block.
        """
        warnings.warn('This field is deprecated, use cluster_ipv4_cidr_block.',
            DeprecationWarning)
        pulumi.log.warn(
            'cluster_ipv4_cidr is deprecated: This field is deprecated, use cluster_ipv4_cidr_block.'
            )
        return pulumi.get(self, 'cluster_ipv4_cidr')

    @cluster_ipv4_cidr.setter
    def cluster_ipv4_cidr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'cluster_ipv4_cidr', value)

    @property
    @pulumi.getter(name='clusterIpv4CidrBlock')
    def cluster_ipv4_cidr_block(self) ->Optional[pulumi.Input[str]]:
        """
        The IP address range for the cluster pod IPs. If this field is set, then `cluster.cluster_ipv4_cidr` must be left blank. This field is only applicable when `use_ip_aliases` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        """
        return pulumi.get(self, 'cluster_ipv4_cidr_block')

    @cluster_ipv4_cidr_block.setter
    def cluster_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'cluster_ipv4_cidr_block', value)

    @property
    @pulumi.getter(name='clusterSecondaryRangeName')
    def cluster_secondary_range_name(self) ->Optional[pulumi.Input[str]]:
        """
        The name of the secondary range to be used for the cluster CIDR block. The secondary range will be used for pod IP addresses. This must be an existing secondary range associated with the cluster subnetwork. This field is only applicable with use_ip_aliases and create_subnetwork is false.
        """
        return pulumi.get(self, 'cluster_secondary_range_name')

    @cluster_secondary_range_name.setter
    def cluster_secondary_range_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'cluster_secondary_range_name', value)

    @property
    @pulumi.getter(name='createSubnetwork')
    def create_subnetwork(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether a new subnetwork will be created automatically for the cluster. This field is only applicable when `use_ip_aliases` is true.
        """
        return pulumi.get(self, 'create_subnetwork')

    @create_subnetwork.setter
    def create_subnetwork(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'create_subnetwork', value)

    @property
    @pulumi.getter(name='ipv6AccessType')
    def ipv6_access_type(self) ->Optional[pulumi.Input[
        'IPAllocationPolicyIpv6AccessType']]:
        """
        The ipv6 access type (internal or external) when create_subnetwork is true
        """
        return pulumi.get(self, 'ipv6_access_type')

    @ipv6_access_type.setter
    def ipv6_access_type(self, value: Optional[pulumi.Input[
        'IPAllocationPolicyIpv6AccessType']]):
        pulumi.set(self, 'ipv6_access_type', value)

    @property
    @pulumi.getter(name='nodeIpv4Cidr')
    def node_ipv4_cidr(self) ->Optional[pulumi.Input[str]]:
        """
        This field is deprecated, use node_ipv4_cidr_block.
        """
        warnings.warn('This field is deprecated, use node_ipv4_cidr_block.',
            DeprecationWarning)
        pulumi.log.warn(
            'node_ipv4_cidr is deprecated: This field is deprecated, use node_ipv4_cidr_block.'
            )
        return pulumi.get(self, 'node_ipv4_cidr')

    @node_ipv4_cidr.setter
    def node_ipv4_cidr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'node_ipv4_cidr', value)

    @property
    @pulumi.getter(name='nodeIpv4CidrBlock')
    def node_ipv4_cidr_block(self) ->Optional[pulumi.Input[str]]:
        """
        The IP address range of the instance IPs in this cluster. This is applicable only if `create_subnetwork` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        """
        return pulumi.get(self, 'node_ipv4_cidr_block')

    @node_ipv4_cidr_block.setter
    def node_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'node_ipv4_cidr_block', value)

    @property
    @pulumi.getter(name='podCidrOverprovisionConfig')
    def pod_cidr_overprovision_config(self) ->Optional[pulumi.Input[
        'PodCIDROverprovisionConfigArgs']]:
        """
        [PRIVATE FIELD] Pod CIDR size overprovisioning config for the cluster. Pod CIDR size per node depends on max_pods_per_node. By default, the value of max_pods_per_node is doubled and then rounded off to next power of 2 to get the size of pod CIDR block per node. Example: max_pods_per_node of 30 would result in 64 IPs (/26). This config can disable the doubling of IPs (we still round off to next power of 2) Example: max_pods_per_node of 30 will result in 32 IPs (/27) when overprovisioning is disabled.
        """
        return pulumi.get(self, 'pod_cidr_overprovision_config')

    @pod_cidr_overprovision_config.setter
    def pod_cidr_overprovision_config(self, value: Optional[pulumi.Input[
        'PodCIDROverprovisionConfigArgs']]):
        pulumi.set(self, 'pod_cidr_overprovision_config', value)

    @property
    @pulumi.getter(name='servicesIpv4Cidr')
    def services_ipv4_cidr(self) ->Optional[pulumi.Input[str]]:
        """
        This field is deprecated, use services_ipv4_cidr_block.
        """
        warnings.warn('This field is deprecated, use services_ipv4_cidr_block.'
            , DeprecationWarning)
        pulumi.log.warn(
            'services_ipv4_cidr is deprecated: This field is deprecated, use services_ipv4_cidr_block.'
            )
        return pulumi.get(self, 'services_ipv4_cidr')

    @services_ipv4_cidr.setter
    def services_ipv4_cidr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'services_ipv4_cidr', value)

    @property
    @pulumi.getter(name='servicesIpv4CidrBlock')
    def services_ipv4_cidr_block(self) ->Optional[pulumi.Input[str]]:
        """
        The IP address range of the services IPs in this cluster. If blank, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        """
        return pulumi.get(self, 'services_ipv4_cidr_block')

    @services_ipv4_cidr_block.setter
    def services_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'services_ipv4_cidr_block', value)

    @property
    @pulumi.getter(name='servicesSecondaryRangeName')
    def services_secondary_range_name(self) ->Optional[pulumi.Input[str]]:
        """
        The name of the secondary range to be used as for the services CIDR block. The secondary range will be used for service ClusterIPs. This must be an existing secondary range associated with the cluster subnetwork. This field is only applicable with use_ip_aliases and create_subnetwork is false.
        """
        return pulumi.get(self, 'services_secondary_range_name')

    @services_secondary_range_name.setter
    def services_secondary_range_name(self, value: Optional[pulumi.Input[str]]
        ):
        pulumi.set(self, 'services_secondary_range_name', value)

    @property
    @pulumi.getter(name='stackType')
    def stack_type(self) ->Optional[pulumi.Input['IPAllocationPolicyStackType']
        ]:
        """
        IP stack type
        """
        return pulumi.get(self, 'stack_type')

    @stack_type.setter
    def stack_type(self, value: Optional[pulumi.Input[
        'IPAllocationPolicyStackType']]):
        pulumi.set(self, 'stack_type', value)

    @property
    @pulumi.getter(name='subnetworkName')
    def subnetwork_name(self) ->Optional[pulumi.Input[str]]:
        """
        A custom subnetwork name to be used if `create_subnetwork` is true. If this field is empty, then an automatic name will be chosen for the new subnetwork.
        """
        return pulumi.get(self, 'subnetwork_name')

    @subnetwork_name.setter
    def subnetwork_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'subnetwork_name', value)

    @property
    @pulumi.getter(name='tpuIpv4CidrBlock')
    def tpu_ipv4_cidr_block(self) ->Optional[pulumi.Input[str]]:
        """
        The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.
        """
        warnings.warn(
            'The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.'
            , DeprecationWarning)
        pulumi.log.warn(
            'tpu_ipv4_cidr_block is deprecated: The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.'
            )
        return pulumi.get(self, 'tpu_ipv4_cidr_block')

    @tpu_ipv4_cidr_block.setter
    def tpu_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'tpu_ipv4_cidr_block', value)

    @property
    @pulumi.getter(name='useIpAliases')
    def use_ip_aliases(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether alias IPs will be used for pod IPs in the cluster. This is used in conjunction with use_routes. It cannot be true if use_routes is true. If both use_ip_aliases and use_routes are false, then the server picks the default IP allocation mode
        """
        return pulumi.get(self, 'use_ip_aliases')

    @use_ip_aliases.setter
    def use_ip_aliases(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'use_ip_aliases', value)

    @property
    @pulumi.getter(name='useRoutes')
    def use_routes(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether routes will be used for pod IPs in the cluster. This is used in conjunction with use_ip_aliases. It cannot be true if use_ip_aliases is true. If both use_ip_aliases and use_routes are false, then the server picks the default IP allocation mode
        """
        return pulumi.get(self, 'use_routes')

    @use_routes.setter
    def use_routes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'use_routes', value)


@pulumi.input_type
class IdentityServiceConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        IdentityServiceConfig is configuration for Identity Service which allows customers to use external identity providers with the K8S API
        :param pulumi.Input[bool] enabled: Whether to enable the Identity Service component
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether to enable the Identity Service component
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class IstioConfigArgs:

    def __init__(__self__, *, auth: Optional[pulumi.Input['IstioConfigAuth'
        ]]=None, disabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration options for Istio addon.
        :param pulumi.Input['IstioConfigAuth'] auth: The specified Istio auth mode, either none, or mutual TLS.
        :param pulumi.Input[bool] disabled: Whether Istio is enabled for this cluster.
        """
        if auth is not None:
            pulumi.set(__self__, 'auth', auth)
        if disabled is not None:
            pulumi.set(__self__, 'disabled', disabled)

    @property
    @pulumi.getter
    def auth(self) ->Optional[pulumi.Input['IstioConfigAuth']]:
        """
        The specified Istio auth mode, either none, or mutual TLS.
        """
        return pulumi.get(self, 'auth')

    @auth.setter
    def auth(self, value: Optional[pulumi.Input['IstioConfigAuth']]):
        pulumi.set(self, 'auth', value)

    @property
    @pulumi.getter
    def disabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Istio is enabled for this cluster.
        """
        return pulumi.get(self, 'disabled')

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'disabled', value)


@pulumi.input_type
class KalmConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration options for the KALM addon.
        :param pulumi.Input[bool] enabled: Whether KALM is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether KALM is enabled for this cluster.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class KubernetesDashboardArgs:

    def __init__(__self__, *, disabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for the Kubernetes Dashboard.
        :param pulumi.Input[bool] disabled: Whether the Kubernetes Dashboard is enabled for this cluster.
        """
        if disabled is not None:
            pulumi.set(__self__, 'disabled', disabled)

    @property
    @pulumi.getter
    def disabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the Kubernetes Dashboard is enabled for this cluster.
        """
        return pulumi.get(self, 'disabled')

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'disabled', value)


@pulumi.input_type
class LegacyAbacArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for the legacy Attribute Based Access Control authorization mode.
        :param pulumi.Input[bool] enabled: Whether the ABAC authorizer is enabled for this cluster. When enabled, identities in the system, including service accounts, nodes, and controllers, will have statically granted permissions beyond those provided by the RBAC configuration or IAM.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the ABAC authorizer is enabled for this cluster. When enabled, identities in the system, including service accounts, nodes, and controllers, will have statically granted permissions beyond those provided by the RBAC configuration or IAM.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class LinuxNodeConfigArgs:

    def __init__(__self__, *, cgroup_mode: Optional[pulumi.Input[
        'LinuxNodeConfigCgroupMode']]=None, sysctls: Optional[pulumi.Input[
        Mapping[str, pulumi.Input[str]]]]=None):
        """
        Parameters that can be configured on Linux nodes.
        :param pulumi.Input['LinuxNodeConfigCgroupMode'] cgroup_mode: cgroup_mode specifies the cgroup mode to be used on the node.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] sysctls: The Linux kernel parameters to be applied to the nodes and all pods running on the nodes. The following parameters are supported. net.core.busy_poll net.core.busy_read net.core.netdev_max_backlog net.core.rmem_max net.core.wmem_default net.core.wmem_max net.core.optmem_max net.core.somaxconn net.ipv4.tcp_rmem net.ipv4.tcp_wmem net.ipv4.tcp_tw_reuse
        """
        if cgroup_mode is not None:
            pulumi.set(__self__, 'cgroup_mode', cgroup_mode)
        if sysctls is not None:
            pulumi.set(__self__, 'sysctls', sysctls)

    @property
    @pulumi.getter(name='cgroupMode')
    def cgroup_mode(self) ->Optional[pulumi.Input['LinuxNodeConfigCgroupMode']
        ]:
        """
        cgroup_mode specifies the cgroup mode to be used on the node.
        """
        return pulumi.get(self, 'cgroup_mode')

    @cgroup_mode.setter
    def cgroup_mode(self, value: Optional[pulumi.Input[
        'LinuxNodeConfigCgroupMode']]):
        pulumi.set(self, 'cgroup_mode', value)

    @property
    @pulumi.getter
    def sysctls(self) ->Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]
        ]:
        """
        The Linux kernel parameters to be applied to the nodes and all pods running on the nodes. The following parameters are supported. net.core.busy_poll net.core.busy_read net.core.netdev_max_backlog net.core.rmem_max net.core.wmem_default net.core.wmem_max net.core.optmem_max net.core.somaxconn net.ipv4.tcp_rmem net.ipv4.tcp_wmem net.ipv4.tcp_tw_reuse
        """
        return pulumi.get(self, 'sysctls')

    @sysctls.setter
    def sysctls(self, value: Optional[pulumi.Input[Mapping[str, pulumi.
        Input[str]]]]):
        pulumi.set(self, 'sysctls', value)


@pulumi.input_type
class LocalNvmeSsdBlockConfigArgs:

    def __init__(__self__, *, local_ssd_count: Optional[pulumi.Input[int]]=None
        ):
        """
        LocalNvmeSsdBlockConfig contains configuration for using raw-block local NVMe SSDs
        :param pulumi.Input[int] local_ssd_count: The number of raw-block local NVMe SSD disks to be attached to the node. Each local SSD is 375 GB in size. If zero, it means no raw-block local NVMe SSD disks to be attached to the node. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        """
        if local_ssd_count is not None:
            pulumi.set(__self__, 'local_ssd_count', local_ssd_count)

    @property
    @pulumi.getter(name='localSsdCount')
    def local_ssd_count(self) ->Optional[pulumi.Input[int]]:
        """
        The number of raw-block local NVMe SSD disks to be attached to the node. Each local SSD is 375 GB in size. If zero, it means no raw-block local NVMe SSD disks to be attached to the node. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        """
        return pulumi.get(self, 'local_ssd_count')

    @local_ssd_count.setter
    def local_ssd_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'local_ssd_count', value)


@pulumi.input_type
class LoggingComponentConfigArgs:

    def __init__(__self__, *, enable_components: Optional[pulumi.Input[
        Sequence[pulumi.Input['LoggingComponentConfigEnableComponentsItem']
        ]]]=None):
        """
        LoggingComponentConfig is cluster logging component configuration.
        :param pulumi.Input[Sequence[pulumi.Input['LoggingComponentConfigEnableComponentsItem']]] enable_components: Select components to collect logs. An empty set would disable all logging.
        """
        if enable_components is not None:
            pulumi.set(__self__, 'enable_components', enable_components)

    @property
    @pulumi.getter(name='enableComponents')
    def enable_components(self) ->Optional[pulumi.Input[Sequence[pulumi.
        Input['LoggingComponentConfigEnableComponentsItem']]]]:
        """
        Select components to collect logs. An empty set would disable all logging.
        """
        return pulumi.get(self, 'enable_components')

    @enable_components.setter
    def enable_components(self, value: Optional[pulumi.Input[Sequence[
        pulumi.Input['LoggingComponentConfigEnableComponentsItem']]]]):
        pulumi.set(self, 'enable_components', value)


@pulumi.input_type
class LoggingConfigArgs:

    def __init__(__self__, *, component_config: Optional[pulumi.Input[
        'LoggingComponentConfigArgs']]=None):
        """
        LoggingConfig is cluster logging configuration.
        :param pulumi.Input['LoggingComponentConfigArgs'] component_config: Logging components configuration
        """
        if component_config is not None:
            pulumi.set(__self__, 'component_config', component_config)

    @property
    @pulumi.getter(name='componentConfig')
    def component_config(self) ->Optional[pulumi.Input[
        'LoggingComponentConfigArgs']]:
        """
        Logging components configuration
        """
        return pulumi.get(self, 'component_config')

    @component_config.setter
    def component_config(self, value: Optional[pulumi.Input[
        'LoggingComponentConfigArgs']]):
        pulumi.set(self, 'component_config', value)


@pulumi.input_type
class LoggingVariantConfigArgs:

    def __init__(__self__, *, variant: Optional[pulumi.Input[
        'LoggingVariantConfigVariant']]=None):
        """
        LoggingVariantConfig specifies the behaviour of the logging component.
        :param pulumi.Input['LoggingVariantConfigVariant'] variant: Logging variant deployed on nodes.
        """
        if variant is not None:
            pulumi.set(__self__, 'variant', variant)

    @property
    @pulumi.getter
    def variant(self) ->Optional[pulumi.Input['LoggingVariantConfigVariant']]:
        """
        Logging variant deployed on nodes.
        """
        return pulumi.get(self, 'variant')

    @variant.setter
    def variant(self, value: Optional[pulumi.Input[
        'LoggingVariantConfigVariant']]):
        pulumi.set(self, 'variant', value)


@pulumi.input_type
class MaintenanceExclusionOptionsArgs:

    def __init__(__self__, *, scope: Optional[pulumi.Input[
        'MaintenanceExclusionOptionsScope']]=None):
        """
        Represents the Maintenance exclusion option.
        :param pulumi.Input['MaintenanceExclusionOptionsScope'] scope: Scope specifies the upgrade scope which upgrades are blocked by the exclusion.
        """
        if scope is not None:
            pulumi.set(__self__, 'scope', scope)

    @property
    @pulumi.getter
    def scope(self) ->Optional[pulumi.Input['MaintenanceExclusionOptionsScope']
        ]:
        """
        Scope specifies the upgrade scope which upgrades are blocked by the exclusion.
        """
        return pulumi.get(self, 'scope')

    @scope.setter
    def scope(self, value: Optional[pulumi.Input[
        'MaintenanceExclusionOptionsScope']]):
        pulumi.set(self, 'scope', value)


@pulumi.input_type
class MaintenancePolicyArgs:

    def __init__(__self__, *, resource_version: Optional[pulumi.Input[str]]
        =None, window: Optional[pulumi.Input['MaintenanceWindowArgs']]=None):
        """
        MaintenancePolicy defines the maintenance policy to be used for the cluster.
        :param pulumi.Input[str] resource_version: A hash identifying the version of this policy, so that updates to fields of the policy won't accidentally undo intermediate changes (and so that users of the API unaware of some fields won't accidentally remove other fields). Make a `get()` request to the cluster to get the current resource version and include it with requests to set the policy.
        :param pulumi.Input['MaintenanceWindowArgs'] window: Specifies the maintenance window in which maintenance may be performed.
        """
        if resource_version is not None:
            pulumi.set(__self__, 'resource_version', resource_version)
        if window is not None:
            pulumi.set(__self__, 'window', window)

    @property
    @pulumi.getter(name='resourceVersion')
    def resource_version(self) ->Optional[pulumi.Input[str]]:
        """
        A hash identifying the version of this policy, so that updates to fields of the policy won't accidentally undo intermediate changes (and so that users of the API unaware of some fields won't accidentally remove other fields). Make a `get()` request to the cluster to get the current resource version and include it with requests to set the policy.
        """
        return pulumi.get(self, 'resource_version')

    @resource_version.setter
    def resource_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'resource_version', value)

    @property
    @pulumi.getter
    def window(self) ->Optional[pulumi.Input['MaintenanceWindowArgs']]:
        """
        Specifies the maintenance window in which maintenance may be performed.
        """
        return pulumi.get(self, 'window')

    @window.setter
    def window(self, value: Optional[pulumi.Input['MaintenanceWindowArgs']]):
        pulumi.set(self, 'window', value)


@pulumi.input_type
class MaintenanceWindowArgs:

    def __init__(__self__, *, daily_maintenance_window: Optional[pulumi.
        Input['DailyMaintenanceWindowArgs']]=None, maintenance_exclusions:
        Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]=None,
        recurring_window: Optional[pulumi.Input['RecurringTimeWindowArgs']]
        =None):
        """
        MaintenanceWindow defines the maintenance window to be used for the cluster.
        :param pulumi.Input['DailyMaintenanceWindowArgs'] daily_maintenance_window: DailyMaintenanceWindow specifies a daily maintenance operation window.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] maintenance_exclusions: Exceptions to maintenance window. Non-emergency maintenance should not occur in these windows.
        :param pulumi.Input['RecurringTimeWindowArgs'] recurring_window: RecurringWindow specifies some number of recurring time periods for maintenance to occur. The time windows may be overlapping. If no maintenance windows are set, maintenance can occur at any time.
        """
        if daily_maintenance_window is not None:
            pulumi.set(__self__, 'daily_maintenance_window',
                daily_maintenance_window)
        if maintenance_exclusions is not None:
            pulumi.set(__self__, 'maintenance_exclusions',
                maintenance_exclusions)
        if recurring_window is not None:
            pulumi.set(__self__, 'recurring_window', recurring_window)

    @property
    @pulumi.getter(name='dailyMaintenanceWindow')
    def daily_maintenance_window(self) ->Optional[pulumi.Input[
        'DailyMaintenanceWindowArgs']]:
        """
        DailyMaintenanceWindow specifies a daily maintenance operation window.
        """
        return pulumi.get(self, 'daily_maintenance_window')

    @daily_maintenance_window.setter
    def daily_maintenance_window(self, value: Optional[pulumi.Input[
        'DailyMaintenanceWindowArgs']]):
        pulumi.set(self, 'daily_maintenance_window', value)

    @property
    @pulumi.getter(name='maintenanceExclusions')
    def maintenance_exclusions(self) ->Optional[pulumi.Input[Mapping[str,
        pulumi.Input[str]]]]:
        """
        Exceptions to maintenance window. Non-emergency maintenance should not occur in these windows.
        """
        return pulumi.get(self, 'maintenance_exclusions')

    @maintenance_exclusions.setter
    def maintenance_exclusions(self, value: Optional[pulumi.Input[Mapping[
        str, pulumi.Input[str]]]]):
        pulumi.set(self, 'maintenance_exclusions', value)

    @property
    @pulumi.getter(name='recurringWindow')
    def recurring_window(self) ->Optional[pulumi.Input[
        'RecurringTimeWindowArgs']]:
        """
        RecurringWindow specifies some number of recurring time periods for maintenance to occur. The time windows may be overlapping. If no maintenance windows are set, maintenance can occur at any time.
        """
        return pulumi.get(self, 'recurring_window')

    @recurring_window.setter
    def recurring_window(self, value: Optional[pulumi.Input[
        'RecurringTimeWindowArgs']]):
        pulumi.set(self, 'recurring_window', value)


@pulumi.input_type
class ManagedPrometheusConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        ManagedPrometheusConfig defines the configuration for Google Cloud Managed Service for Prometheus.
        :param pulumi.Input[bool] enabled: Enable Managed Collection.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Enable Managed Collection.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class MasterAuthorizedNetworksConfigArgs:

    def __init__(__self__, *, cidr_blocks: Optional[pulumi.Input[Sequence[
        pulumi.Input['CidrBlockArgs']]]]=None, enabled: Optional[pulumi.
        Input[bool]]=None, gcp_public_cidrs_access_enabled: Optional[pulumi
        .Input[bool]]=None):
        """
        Configuration options for the master authorized networks feature. Enabled master authorized networks will disallow all external traffic to access Kubernetes master through HTTPS except traffic from the given CIDR blocks, Google Compute Engine Public IPs and Google Prod IPs.
        :param pulumi.Input[Sequence[pulumi.Input['CidrBlockArgs']]] cidr_blocks: cidr_blocks define up to 10 external networks that could access Kubernetes master through HTTPS.
        :param pulumi.Input[bool] enabled: Whether or not master authorized networks is enabled.
        :param pulumi.Input[bool] gcp_public_cidrs_access_enabled: Whether master is accessbile via Google Compute Engine Public IP addresses.
        """
        if cidr_blocks is not None:
            pulumi.set(__self__, 'cidr_blocks', cidr_blocks)
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)
        if gcp_public_cidrs_access_enabled is not None:
            pulumi.set(__self__, 'gcp_public_cidrs_access_enabled',
                gcp_public_cidrs_access_enabled)

    @property
    @pulumi.getter(name='cidrBlocks')
    def cidr_blocks(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[
        'CidrBlockArgs']]]]:
        """
        cidr_blocks define up to 10 external networks that could access Kubernetes master through HTTPS.
        """
        return pulumi.get(self, 'cidr_blocks')

    @cidr_blocks.setter
    def cidr_blocks(self, value: Optional[pulumi.Input[Sequence[pulumi.
        Input['CidrBlockArgs']]]]):
        pulumi.set(self, 'cidr_blocks', value)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether or not master authorized networks is enabled.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)

    @property
    @pulumi.getter(name='gcpPublicCidrsAccessEnabled')
    def gcp_public_cidrs_access_enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether master is accessbile via Google Compute Engine Public IP addresses.
        """
        return pulumi.get(self, 'gcp_public_cidrs_access_enabled')

    @gcp_public_cidrs_access_enabled.setter
    def gcp_public_cidrs_access_enabled(self, value: Optional[pulumi.Input[
        bool]]):
        pulumi.set(self, 'gcp_public_cidrs_access_enabled', value)


@pulumi.input_type
class MasterAuthArgs:

    def __init__(__self__, *, client_certificate_config: Optional[pulumi.
        Input['ClientCertificateConfigArgs']]=None, cluster_ca_certificate:
        Optional[pulumi.Input[str]]=None, password: Optional[pulumi.Input[
        str]]=None, username: Optional[pulumi.Input[str]]=None):
        """
        The authentication information for accessing the master endpoint. Authentication can be done using HTTP basic auth or using client certificates.
        :param pulumi.Input['ClientCertificateConfigArgs'] client_certificate_config: Configuration for client certificate authentication on the cluster. For clusters before v1.12, if no configuration is specified, a client certificate is issued.
        :param pulumi.Input[str] password: The password to use for HTTP basic authentication to the master endpoint. Because the master endpoint is open to the Internet, you should create a strong password. If a password is provided for cluster creation, username must be non-empty. Warning: basic authentication is deprecated, and will be removed in GKE control plane versions 1.19 and newer. For a list of recommended authentication methods, see: https://cloud.google.com/kubernetes-engine/docs/how-to/api-server-authentication
        :param pulumi.Input[str] username: The username to use for HTTP basic authentication to the master endpoint. For clusters v1.6.0 and later, basic authentication can be disabled by leaving username unspecified (or setting it to the empty string). Warning: basic authentication is deprecated, and will be removed in GKE control plane versions 1.19 and newer. For a list of recommended authentication methods, see: https://cloud.google.com/kubernetes-engine/docs/how-to/api-server-authentication
        """
        if client_certificate_config is not None:
            pulumi.set(__self__, 'client_certificate_config',
                client_certificate_config)
        if cluster_ca_certificate is not None:
            pulumi.set(__self__, 'cluster_ca_certificate',
                cluster_ca_certificate)
        if password is not None:
            pulumi.set(__self__, 'password', password)
        if username is not None:
            pulumi.set(__self__, 'username', username)

    @property
    @pulumi.getter(name='clientCertificateConfig')
    def client_certificate_config(self) ->Optional[pulumi.Input[
        'ClientCertificateConfigArgs']]:
        """
        Configuration for client certificate authentication on the cluster. For clusters before v1.12, if no configuration is specified, a client certificate is issued.
        """
        return pulumi.get(self, 'client_certificate_config')

    @client_certificate_config.setter
    def client_certificate_config(self, value: Optional[pulumi.Input[
        'ClientCertificateConfigArgs']]):
        pulumi.set(self, 'client_certificate_config', value)

    @property
    @pulumi.getter(name='clusterCaCertificate')
    def cluster_ca_certificate(self) ->Optional[pulumi.Input[str]]:
        return pulumi.get(self, 'cluster_ca_certificate')

    @cluster_ca_certificate.setter
    def cluster_ca_certificate(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'cluster_ca_certificate', value)

    @property
    @pulumi.getter
    def password(self) ->Optional[pulumi.Input[str]]:
        """
        The password to use for HTTP basic authentication to the master endpoint. Because the master endpoint is open to the Internet, you should create a strong password. If a password is provided for cluster creation, username must be non-empty. Warning: basic authentication is deprecated, and will be removed in GKE control plane versions 1.19 and newer. For a list of recommended authentication methods, see: https://cloud.google.com/kubernetes-engine/docs/how-to/api-server-authentication
        """
        return pulumi.get(self, 'password')

    @password.setter
    def password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'password', value)

    @property
    @pulumi.getter
    def username(self) ->Optional[pulumi.Input[str]]:
        """
        The username to use for HTTP basic authentication to the master endpoint. For clusters v1.6.0 and later, basic authentication can be disabled by leaving username unspecified (or setting it to the empty string). Warning: basic authentication is deprecated, and will be removed in GKE control plane versions 1.19 and newer. For a list of recommended authentication methods, see: https://cloud.google.com/kubernetes-engine/docs/how-to/api-server-authentication
        """
        return pulumi.get(self, 'username')

    @username.setter
    def username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'username', value)


@pulumi.input_type
class MasterArgs:

    def __init__(__self__):
        """
        Master is the configuration for components on master.
        """
        pass


@pulumi.input_type
class MaxPodsConstraintArgs:

    def __init__(__self__, *, max_pods_per_node: Optional[pulumi.Input[str]
        ]=None):
        """
        Constraints applied to pods.
        :param pulumi.Input[str] max_pods_per_node: Constraint enforced on the max num of pods per node.
        """
        if max_pods_per_node is not None:
            pulumi.set(__self__, 'max_pods_per_node', max_pods_per_node)

    @property
    @pulumi.getter(name='maxPodsPerNode')
    def max_pods_per_node(self) ->Optional[pulumi.Input[str]]:
        """
        Constraint enforced on the max num of pods per node.
        """
        return pulumi.get(self, 'max_pods_per_node')

    @max_pods_per_node.setter
    def max_pods_per_node(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'max_pods_per_node', value)


@pulumi.input_type
class MeshCertificatesArgs:

    def __init__(__self__, *, enable_certificates: Optional[pulumi.Input[
        bool]]=None):
        """
        Configuration for issuance of mTLS keys and certificates to Kubernetes pods.
        :param pulumi.Input[bool] enable_certificates: enable_certificates controls issuance of workload mTLS certificates. If set, the GKE Workload Identity Certificates controller and node agent will be deployed in the cluster, which can then be configured by creating a WorkloadCertificateConfig Custom Resource. Requires Workload Identity (workload_pool must be non-empty).
        """
        if enable_certificates is not None:
            pulumi.set(__self__, 'enable_certificates', enable_certificates)

    @property
    @pulumi.getter(name='enableCertificates')
    def enable_certificates(self) ->Optional[pulumi.Input[bool]]:
        """
        enable_certificates controls issuance of workload mTLS certificates. If set, the GKE Workload Identity Certificates controller and node agent will be deployed in the cluster, which can then be configured by creating a WorkloadCertificateConfig Custom Resource. Requires Workload Identity (workload_pool must be non-empty).
        """
        return pulumi.get(self, 'enable_certificates')

    @enable_certificates.setter
    def enable_certificates(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_certificates', value)


@pulumi.input_type
class MonitoringComponentConfigArgs:

    def __init__(__self__, *, enable_components: Optional[pulumi.Input[
        Sequence[pulumi.Input[
        'MonitoringComponentConfigEnableComponentsItem']]]]=None):
        """
        MonitoringComponentConfig is cluster monitoring component configuration.
        :param pulumi.Input[Sequence[pulumi.Input['MonitoringComponentConfigEnableComponentsItem']]] enable_components: Select components to collect metrics. An empty set would disable all monitoring.
        """
        if enable_components is not None:
            pulumi.set(__self__, 'enable_components', enable_components)

    @property
    @pulumi.getter(name='enableComponents')
    def enable_components(self) ->Optional[pulumi.Input[Sequence[pulumi.
        Input['MonitoringComponentConfigEnableComponentsItem']]]]:
        """
        Select components to collect metrics. An empty set would disable all monitoring.
        """
        return pulumi.get(self, 'enable_components')

    @enable_components.setter
    def enable_components(self, value: Optional[pulumi.Input[Sequence[
        pulumi.Input['MonitoringComponentConfigEnableComponentsItem']]]]):
        pulumi.set(self, 'enable_components', value)


@pulumi.input_type
class MonitoringConfigArgs:

    def __init__(__self__, *, component_config: Optional[pulumi.Input[
        'MonitoringComponentConfigArgs']]=None, managed_prometheus_config:
        Optional[pulumi.Input['ManagedPrometheusConfigArgs']]=None):
        """
        MonitoringConfig is cluster monitoring configuration.
        :param pulumi.Input['MonitoringComponentConfigArgs'] component_config: Monitoring components configuration
        :param pulumi.Input['ManagedPrometheusConfigArgs'] managed_prometheus_config: Enable Google Cloud Managed Service for Prometheus in the cluster.
        """
        if component_config is not None:
            pulumi.set(__self__, 'component_config', component_config)
        if managed_prometheus_config is not None:
            pulumi.set(__self__, 'managed_prometheus_config',
                managed_prometheus_config)

    @property
    @pulumi.getter(name='componentConfig')
    def component_config(self) ->Optional[pulumi.Input[
        'MonitoringComponentConfigArgs']]:
        """
        Monitoring components configuration
        """
        return pulumi.get(self, 'component_config')

    @component_config.setter
    def component_config(self, value: Optional[pulumi.Input[
        'MonitoringComponentConfigArgs']]):
        pulumi.set(self, 'component_config', value)

    @property
    @pulumi.getter(name='managedPrometheusConfig')
    def managed_prometheus_config(self) ->Optional[pulumi.Input[
        'ManagedPrometheusConfigArgs']]:
        """
        Enable Google Cloud Managed Service for Prometheus in the cluster.
        """
        return pulumi.get(self, 'managed_prometheus_config')

    @managed_prometheus_config.setter
    def managed_prometheus_config(self, value: Optional[pulumi.Input[
        'ManagedPrometheusConfigArgs']]):
        pulumi.set(self, 'managed_prometheus_config', value)


@pulumi.input_type
class NetworkConfigArgs:

    def __init__(__self__, *, datapath_provider: Optional[pulumi.Input[
        'NetworkConfigDatapathProvider']]=None, default_snat_status:
        Optional[pulumi.Input['DefaultSnatStatusArgs']]=None, dns_config:
        Optional[pulumi.Input['DNSConfigArgs']]=None,
        enable_intra_node_visibility: Optional[pulumi.Input[bool]]=None,
        enable_l4ilb_subsetting: Optional[pulumi.Input[bool]]=None,
        gateway_api_config: Optional[pulumi.Input['GatewayAPIConfigArgs']]=
        None, private_ipv6_google_access: Optional[pulumi.Input[
        'NetworkConfigPrivateIpv6GoogleAccess']]=None,
        service_external_ips_config: Optional[pulumi.Input[
        'ServiceExternalIPsConfigArgs']]=None):
        """
        NetworkConfig reports the relative names of network & subnetwork.
        :param pulumi.Input['NetworkConfigDatapathProvider'] datapath_provider: The desired datapath provider for this cluster. By default, uses the IPTables-based kube-proxy implementation.
        :param pulumi.Input['DefaultSnatStatusArgs'] default_snat_status: Whether the cluster disables default in-node sNAT rules. In-node sNAT rules will be disabled when default_snat_status is disabled. When disabled is set to false, default IP masquerade rules will be applied to the nodes to prevent sNAT on cluster internal traffic.
        :param pulumi.Input['DNSConfigArgs'] dns_config: DNSConfig contains clusterDNS config for this cluster.
        :param pulumi.Input[bool] enable_intra_node_visibility: Whether Intra-node visibility is enabled for this cluster. This makes same node pod to pod traffic visible for VPC network.
        :param pulumi.Input[bool] enable_l4ilb_subsetting: Whether L4ILB Subsetting is enabled for this cluster.
        :param pulumi.Input['GatewayAPIConfigArgs'] gateway_api_config: GatewayAPIConfig contains the desired config of Gateway API on this cluster.
        :param pulumi.Input['NetworkConfigPrivateIpv6GoogleAccess'] private_ipv6_google_access: The desired state of IPv6 connectivity to Google Services. By default, no private IPv6 access to or from Google Services (all access will be via IPv4)
        :param pulumi.Input['ServiceExternalIPsConfigArgs'] service_external_ips_config: ServiceExternalIPsConfig specifies if services with externalIPs field are blocked or not.
        """
        if datapath_provider is not None:
            pulumi.set(__self__, 'datapath_provider', datapath_provider)
        if default_snat_status is not None:
            pulumi.set(__self__, 'default_snat_status', default_snat_status)
        if dns_config is not None:
            pulumi.set(__self__, 'dns_config', dns_config)
        if enable_intra_node_visibility is not None:
            pulumi.set(__self__, 'enable_intra_node_visibility',
                enable_intra_node_visibility)
        if enable_l4ilb_subsetting is not None:
            pulumi.set(__self__, 'enable_l4ilb_subsetting',
                enable_l4ilb_subsetting)
        if gateway_api_config is not None:
            pulumi.set(__self__, 'gateway_api_config', gateway_api_config)
        if private_ipv6_google_access is not None:
            pulumi.set(__self__, 'private_ipv6_google_access',
                private_ipv6_google_access)
        if service_external_ips_config is not None:
            pulumi.set(__self__, 'service_external_ips_config',
                service_external_ips_config)

    @property
    @pulumi.getter(name='datapathProvider')
    def datapath_provider(self) ->Optional[pulumi.Input[
        'NetworkConfigDatapathProvider']]:
        """
        The desired datapath provider for this cluster. By default, uses the IPTables-based kube-proxy implementation.
        """
        return pulumi.get(self, 'datapath_provider')

    @datapath_provider.setter
    def datapath_provider(self, value: Optional[pulumi.Input[
        'NetworkConfigDatapathProvider']]):
        pulumi.set(self, 'datapath_provider', value)

    @property
    @pulumi.getter(name='defaultSnatStatus')
    def default_snat_status(self) ->Optional[pulumi.Input[
        'DefaultSnatStatusArgs']]:
        """
        Whether the cluster disables default in-node sNAT rules. In-node sNAT rules will be disabled when default_snat_status is disabled. When disabled is set to false, default IP masquerade rules will be applied to the nodes to prevent sNAT on cluster internal traffic.
        """
        return pulumi.get(self, 'default_snat_status')

    @default_snat_status.setter
    def default_snat_status(self, value: Optional[pulumi.Input[
        'DefaultSnatStatusArgs']]):
        pulumi.set(self, 'default_snat_status', value)

    @property
    @pulumi.getter(name='dnsConfig')
    def dns_config(self) ->Optional[pulumi.Input['DNSConfigArgs']]:
        """
        DNSConfig contains clusterDNS config for this cluster.
        """
        return pulumi.get(self, 'dns_config')

    @dns_config.setter
    def dns_config(self, value: Optional[pulumi.Input['DNSConfigArgs']]):
        pulumi.set(self, 'dns_config', value)

    @property
    @pulumi.getter(name='enableIntraNodeVisibility')
    def enable_intra_node_visibility(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Intra-node visibility is enabled for this cluster. This makes same node pod to pod traffic visible for VPC network.
        """
        return pulumi.get(self, 'enable_intra_node_visibility')

    @enable_intra_node_visibility.setter
    def enable_intra_node_visibility(self, value: Optional[pulumi.Input[bool]]
        ):
        pulumi.set(self, 'enable_intra_node_visibility', value)

    @property
    @pulumi.getter(name='enableL4ilbSubsetting')
    def enable_l4ilb_subsetting(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether L4ILB Subsetting is enabled for this cluster.
        """
        return pulumi.get(self, 'enable_l4ilb_subsetting')

    @enable_l4ilb_subsetting.setter
    def enable_l4ilb_subsetting(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_l4ilb_subsetting', value)

    @property
    @pulumi.getter(name='gatewayApiConfig')
    def gateway_api_config(self) ->Optional[pulumi.Input[
        'GatewayAPIConfigArgs']]:
        """
        GatewayAPIConfig contains the desired config of Gateway API on this cluster.
        """
        return pulumi.get(self, 'gateway_api_config')

    @gateway_api_config.setter
    def gateway_api_config(self, value: Optional[pulumi.Input[
        'GatewayAPIConfigArgs']]):
        pulumi.set(self, 'gateway_api_config', value)

    @property
    @pulumi.getter(name='privateIpv6GoogleAccess')
    def private_ipv6_google_access(self) ->Optional[pulumi.Input[
        'NetworkConfigPrivateIpv6GoogleAccess']]:
        """
        The desired state of IPv6 connectivity to Google Services. By default, no private IPv6 access to or from Google Services (all access will be via IPv4)
        """
        return pulumi.get(self, 'private_ipv6_google_access')

    @private_ipv6_google_access.setter
    def private_ipv6_google_access(self, value: Optional[pulumi.Input[
        'NetworkConfigPrivateIpv6GoogleAccess']]):
        pulumi.set(self, 'private_ipv6_google_access', value)

    @property
    @pulumi.getter(name='serviceExternalIpsConfig')
    def service_external_ips_config(self) ->Optional[pulumi.Input[
        'ServiceExternalIPsConfigArgs']]:
        """
        ServiceExternalIPsConfig specifies if services with externalIPs field are blocked or not.
        """
        return pulumi.get(self, 'service_external_ips_config')

    @service_external_ips_config.setter
    def service_external_ips_config(self, value: Optional[pulumi.Input[
        'ServiceExternalIPsConfigArgs']]):
        pulumi.set(self, 'service_external_ips_config', value)


@pulumi.input_type
class NetworkPerformanceConfigArgs:

    def __init__(__self__, *, external_ip_egress_bandwidth_tier: Optional[
        pulumi.Input[
        'NetworkPerformanceConfigExternalIpEgressBandwidthTier']]=None,
        total_egress_bandwidth_tier: Optional[pulumi.Input[
        'NetworkPerformanceConfigTotalEgressBandwidthTier']]=None):
        """
        Configuration of all network bandwidth tiers
        :param pulumi.Input['NetworkPerformanceConfigExternalIpEgressBandwidthTier'] external_ip_egress_bandwidth_tier: Specifies the network bandwidth tier for the NodePool for traffic to external/public IP addresses.
        :param pulumi.Input['NetworkPerformanceConfigTotalEgressBandwidthTier'] total_egress_bandwidth_tier: Specifies the total network bandwidth tier for the NodePool.
        """
        if external_ip_egress_bandwidth_tier is not None:
            pulumi.set(__self__, 'external_ip_egress_bandwidth_tier',
                external_ip_egress_bandwidth_tier)
        if total_egress_bandwidth_tier is not None:
            pulumi.set(__self__, 'total_egress_bandwidth_tier',
                total_egress_bandwidth_tier)

    @property
    @pulumi.getter(name='externalIpEgressBandwidthTier')
    def external_ip_egress_bandwidth_tier(self) ->Optional[pulumi.Input[
        'NetworkPerformanceConfigExternalIpEgressBandwidthTier']]:
        """
        Specifies the network bandwidth tier for the NodePool for traffic to external/public IP addresses.
        """
        return pulumi.get(self, 'external_ip_egress_bandwidth_tier')

    @external_ip_egress_bandwidth_tier.setter
    def external_ip_egress_bandwidth_tier(self, value: Optional[pulumi.
        Input['NetworkPerformanceConfigExternalIpEgressBandwidthTier']]):
        pulumi.set(self, 'external_ip_egress_bandwidth_tier', value)

    @property
    @pulumi.getter(name='totalEgressBandwidthTier')
    def total_egress_bandwidth_tier(self) ->Optional[pulumi.Input[
        'NetworkPerformanceConfigTotalEgressBandwidthTier']]:
        """
        Specifies the total network bandwidth tier for the NodePool.
        """
        return pulumi.get(self, 'total_egress_bandwidth_tier')

    @total_egress_bandwidth_tier.setter
    def total_egress_bandwidth_tier(self, value: Optional[pulumi.Input[
        'NetworkPerformanceConfigTotalEgressBandwidthTier']]):
        pulumi.set(self, 'total_egress_bandwidth_tier', value)


@pulumi.input_type
class NetworkPolicyConfigArgs:

    def __init__(__self__, *, disabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for NetworkPolicy. This only tracks whether the addon is enabled or not on the Master, it does not track whether network policy is enabled for the nodes.
        :param pulumi.Input[bool] disabled: Whether NetworkPolicy is enabled for this cluster.
        """
        if disabled is not None:
            pulumi.set(__self__, 'disabled', disabled)

    @property
    @pulumi.getter
    def disabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether NetworkPolicy is enabled for this cluster.
        """
        return pulumi.get(self, 'disabled')

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'disabled', value)


@pulumi.input_type
class NetworkPolicyArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None,
        provider: Optional[pulumi.Input['NetworkPolicyProvider']]=None):
        """
        Configuration options for the NetworkPolicy feature. https://kubernetes.io/docs/concepts/services-networking/networkpolicies/
        :param pulumi.Input[bool] enabled: Whether network policy is enabled on the cluster.
        :param pulumi.Input['NetworkPolicyProvider'] provider: The selected network policy provider.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)
        if provider is not None:
            pulumi.set(__self__, 'provider', provider)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether network policy is enabled on the cluster.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)

    @property
    @pulumi.getter
    def provider(self) ->Optional[pulumi.Input['NetworkPolicyProvider']]:
        """
        The selected network policy provider.
        """
        return pulumi.get(self, 'provider')

    @provider.setter
    def provider(self, value: Optional[pulumi.Input['NetworkPolicyProvider']]):
        pulumi.set(self, 'provider', value)


@pulumi.input_type
class NetworkTagsArgs:

    def __init__(__self__, *, tags: Optional[pulumi.Input[Sequence[pulumi.
        Input[str]]]]=None):
        """
        Collection of Compute Engine network tags that can be applied to a node's underlying VM instance. (See `tags` field in [`NodeConfig`](/kubernetes-engine/docs/reference/rest/v1/NodeConfig)).
        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: List of network tags.
        """
        if tags is not None:
            pulumi.set(__self__, 'tags', tags)

    @property
    @pulumi.getter
    def tags(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of network tags.
        """
        return pulumi.get(self, 'tags')

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, 'tags', value)


@pulumi.input_type
class NodeConfigDefaultsArgs:

    def __init__(__self__, *, gcfs_config: Optional[pulumi.Input[
        'GcfsConfigArgs']]=None, logging_config: Optional[pulumi.Input[
        'NodePoolLoggingConfigArgs']]=None):
        """
        Subset of NodeConfig message that has defaults.
        :param pulumi.Input['GcfsConfigArgs'] gcfs_config: GCFS (Google Container File System, also known as Riptide) options.
        :param pulumi.Input['NodePoolLoggingConfigArgs'] logging_config: Logging configuration for node pools.
        """
        if gcfs_config is not None:
            pulumi.set(__self__, 'gcfs_config', gcfs_config)
        if logging_config is not None:
            pulumi.set(__self__, 'logging_config', logging_config)

    @property
    @pulumi.getter(name='gcfsConfig')
    def gcfs_config(self) ->Optional[pulumi.Input['GcfsConfigArgs']]:
        """
        GCFS (Google Container File System, also known as Riptide) options.
        """
        return pulumi.get(self, 'gcfs_config')

    @gcfs_config.setter
    def gcfs_config(self, value: Optional[pulumi.Input['GcfsConfigArgs']]):
        pulumi.set(self, 'gcfs_config', value)

    @property
    @pulumi.getter(name='loggingConfig')
    def logging_config(self) ->Optional[pulumi.Input[
        'NodePoolLoggingConfigArgs']]:
        """
        Logging configuration for node pools.
        """
        return pulumi.get(self, 'logging_config')

    @logging_config.setter
    def logging_config(self, value: Optional[pulumi.Input[
        'NodePoolLoggingConfigArgs']]):
        pulumi.set(self, 'logging_config', value)


@pulumi.input_type
class NodeConfigArgs:

    def __init__(__self__, *, accelerators: Optional[pulumi.Input[Sequence[
        pulumi.Input['AcceleratorConfigArgs']]]]=None,
        advanced_machine_features: Optional[pulumi.Input[
        'AdvancedMachineFeaturesArgs']]=None, boot_disk_kms_key: Optional[
        pulumi.Input[str]]=None, confidential_nodes: Optional[pulumi.Input[
        'ConfidentialNodesArgs']]=None, disk_size_gb: Optional[pulumi.Input
        [int]]=None, disk_type: Optional[pulumi.Input[str]]=None,
        ephemeral_storage_config: Optional[pulumi.Input[
        'EphemeralStorageConfigArgs']]=None,
        ephemeral_storage_local_ssd_config: Optional[pulumi.Input[
        'EphemeralStorageLocalSsdConfigArgs']]=None, fast_socket: Optional[
        pulumi.Input['FastSocketArgs']]=None, gcfs_config: Optional[pulumi.
        Input['GcfsConfigArgs']]=None, gvnic: Optional[pulumi.Input[
        'VirtualNICArgs']]=None, image_type: Optional[pulumi.Input[str]]=
        None, kubelet_config: Optional[pulumi.Input['NodeKubeletConfigArgs'
        ]]=None, labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[
        str]]]]=None, linux_node_config: Optional[pulumi.Input[
        'LinuxNodeConfigArgs']]=None, local_nvme_ssd_block_config: Optional
        [pulumi.Input['LocalNvmeSsdBlockConfigArgs']]=None, local_ssd_count:
        Optional[pulumi.Input[int]]=None, logging_config: Optional[pulumi.
        Input['NodePoolLoggingConfigArgs']]=None, machine_type: Optional[
        pulumi.Input[str]]=None, metadata: Optional[pulumi.Input[Mapping[
        str, pulumi.Input[str]]]]=None, min_cpu_platform: Optional[pulumi.
        Input[str]]=None, node_group: Optional[pulumi.Input[str]]=None,
        oauth_scopes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=
        None, preemptible: Optional[pulumi.Input[bool]]=None,
        reservation_affinity: Optional[pulumi.Input[
        'ReservationAffinityArgs']]=None, resource_labels: Optional[pulumi.
        Input[Mapping[str, pulumi.Input[str]]]]=None, sandbox_config:
        Optional[pulumi.Input['SandboxConfigArgs']]=None, service_account:
        Optional[pulumi.Input[str]]=None, shielded_instance_config:
        Optional[pulumi.Input['ShieldedInstanceConfigArgs']]=None, spot:
        Optional[pulumi.Input[bool]]=None, tags: Optional[pulumi.Input[
        Sequence[pulumi.Input[str]]]]=None, taints: Optional[pulumi.Input[
        Sequence[pulumi.Input['NodeTaintArgs']]]]=None, windows_node_config:
        Optional[pulumi.Input['WindowsNodeConfigArgs']]=None,
        workload_metadata_config: Optional[pulumi.Input[
        'WorkloadMetadataConfigArgs']]=None):
        """
        Parameters that describe the nodes in a cluster. GKE Autopilot clusters do not recognize parameters in `NodeConfig`. Use AutoprovisioningNodePoolDefaults instead.
        :param pulumi.Input[Sequence[pulumi.Input['AcceleratorConfigArgs']]] accelerators: A list of hardware accelerators to be attached to each node. See https://cloud.google.com/compute/docs/gpus for more information about support for GPUs.
        :param pulumi.Input['AdvancedMachineFeaturesArgs'] advanced_machine_features: Advanced features for the Compute Engine VM.
        :param pulumi.Input[str] boot_disk_kms_key:  The Customer Managed Encryption Key used to encrypt the boot disk attached to each node in the node pool. This should be of the form projects/[KEY_PROJECT_ID]/locations/[LOCATION]/keyRings/[RING_NAME]/cryptoKeys/[KEY_NAME]. For more information about protecting resources with Cloud KMS Keys please see: https://cloud.google.com/compute/docs/disks/customer-managed-encryption
        :param pulumi.Input['ConfidentialNodesArgs'] confidential_nodes: Confidential nodes config. All the nodes in the node pool will be Confidential VM once enabled.
        :param pulumi.Input[int] disk_size_gb: Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB. If unspecified, the default disk size is 100GB.
        :param pulumi.Input[str] disk_type: Type of the disk attached to each node (e.g. 'pd-standard', 'pd-ssd' or 'pd-balanced') If unspecified, the default disk type is 'pd-standard'
        :param pulumi.Input['EphemeralStorageConfigArgs'] ephemeral_storage_config: Parameters for the ephemeral storage filesystem. If unspecified, ephemeral storage is backed by the boot disk.
        :param pulumi.Input['EphemeralStorageLocalSsdConfigArgs'] ephemeral_storage_local_ssd_config: Parameters for the node ephemeral storage using Local SSDs. If unspecified, ephemeral storage is backed by the boot disk. This field is functionally equivalent to the ephemeral_storage_config
        :param pulumi.Input['FastSocketArgs'] fast_socket: Enable or disable NCCL fast socket for the node pool.
        :param pulumi.Input['GcfsConfigArgs'] gcfs_config: GCFS (Google Container File System) configs.
        :param pulumi.Input['VirtualNICArgs'] gvnic: Enable or disable gvnic on the node pool.
        :param pulumi.Input[str] image_type: The image type to use for this node. Note that for a given image type, the latest version of it will be used. Please see https://cloud.google.com/kubernetes-engine/docs/concepts/node-images for available image types.
        :param pulumi.Input['NodeKubeletConfigArgs'] kubelet_config: Node kubelet configs.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: The map of Kubernetes labels (key/value pairs) to be applied to each node. These will added in addition to any default label(s) that Kubernetes may apply to the node. In case of conflict in label keys, the applied set may differ depending on the Kubernetes version -- it's best to assume the behavior is undefined and conflicts should be avoided. For more information, including usage and the valid values, see: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/
        :param pulumi.Input['LinuxNodeConfigArgs'] linux_node_config: Parameters that can be configured on Linux nodes.
        :param pulumi.Input['LocalNvmeSsdBlockConfigArgs'] local_nvme_ssd_block_config: Parameters for using raw-block Local NVMe SSDs.
        :param pulumi.Input[int] local_ssd_count: The number of local SSD disks to be attached to the node. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        :param pulumi.Input['NodePoolLoggingConfigArgs'] logging_config: Logging configuration.
        :param pulumi.Input[str] machine_type: The name of a Google Compute Engine [machine type](https://cloud.google.com/compute/docs/machine-types). If unspecified, the default machine type is `e2-medium`.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] metadata: The metadata key/value pairs assigned to instances in the cluster. Keys must conform to the regexp `[a-zA-Z0-9-_]+` and be less than 128 bytes in length. These are reflected as part of a URL in the metadata server. Additionally, to avoid ambiguity, keys must not conflict with any other metadata keys for the project or be one of the reserved keys: - "cluster-location" - "cluster-name" - "cluster-uid" - "configure-sh" - "containerd-configure-sh" - "enable-oslogin" - "gci-ensure-gke-docker" - "gci-metrics-enabled" - "gci-update-strategy" - "instance-template" - "kube-env" - "startup-script" - "user-data" - "disable-address-manager" - "windows-startup-script-ps1" - "common-psm1" - "k8s-node-setup-psm1" - "install-ssh-psm1" - "user-profile-psm1" Values are free-form strings, and only have meaning as interpreted by the image running in the instance. The only restriction placed on them is that each value's size must be less than or equal to 32 KB. The total size of all keys and values must be less than 512 KB.
        :param pulumi.Input[str] min_cpu_platform: Minimum CPU platform to be used by this instance. The instance may be scheduled on the specified or newer CPU platform. Applicable values are the friendly names of CPU platforms, such as `minCpuPlatform: "Intel Haswell"` or `minCpuPlatform: "Intel Sandy Bridge"`. For more information, read [how to specify min CPU platform](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform).
        :param pulumi.Input[str] node_group: Setting this field will assign instances of this pool to run on the specified node group. This is useful for running workloads on [sole tenant nodes](https://cloud.google.com/compute/docs/nodes/sole-tenant-nodes).
        :param pulumi.Input[Sequence[pulumi.Input[str]]] oauth_scopes: The set of Google API scopes to be made available on all of the node VMs under the "default" service account. The following scopes are recommended, but not required, and by default are not included: * `https://www.googleapis.com/auth/compute` is required for mounting persistent storage on your nodes. * `https://www.googleapis.com/auth/devstorage.read_only` is required for communicating with **gcr.io** (the [Google Container Registry](https://cloud.google.com/container-registry/)). If unspecified, no scopes are added, unless Cloud Logging or Cloud Monitoring are enabled, in which case their required scopes will be added.
        :param pulumi.Input[bool] preemptible: Whether the nodes are created as preemptible VM instances. See: https://cloud.google.com/compute/docs/instances/preemptible for more inforamtion about preemptible VM instances.
        :param pulumi.Input['ReservationAffinityArgs'] reservation_affinity: The optional reservation affinity. Setting this field will apply the specified [Zonal Compute Reservation](https://cloud.google.com/compute/docs/instances/reserving-zonal-resources) to this node pool.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] resource_labels: The resource labels for the node pool to use to annotate any related Google Compute Engine resources.
        :param pulumi.Input['SandboxConfigArgs'] sandbox_config: Sandbox configuration for this node.
        :param pulumi.Input[str] service_account: The Google Cloud Platform Service Account to be used by the node VMs. Specify the email address of the Service Account; otherwise, if no Service Account is specified, the "default" service account is used.
        :param pulumi.Input['ShieldedInstanceConfigArgs'] shielded_instance_config: Shielded Instance options.
        :param pulumi.Input[bool] spot: Spot flag for enabling Spot VM, which is a rebrand of the existing preemptible flag.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: The list of instance tags applied to all nodes. Tags are used to identify valid sources or targets for network firewalls and are specified by the client during cluster or node pool creation. Each tag within the list must comply with RFC1035.
        :param pulumi.Input[Sequence[pulumi.Input['NodeTaintArgs']]] taints: List of kubernetes taints to be applied to each node. For more information, including usage and the valid values, see: https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/
        :param pulumi.Input['WindowsNodeConfigArgs'] windows_node_config: Parameters that can be configured on Windows nodes.
        :param pulumi.Input['WorkloadMetadataConfigArgs'] workload_metadata_config: The workload metadata configuration for this node.
        """
        if accelerators is not None:
            pulumi.set(__self__, 'accelerators', accelerators)
        if advanced_machine_features is not None:
            pulumi.set(__self__, 'advanced_machine_features',
                advanced_machine_features)
        if boot_disk_kms_key is not None:
            pulumi.set(__self__, 'boot_disk_kms_key', boot_disk_kms_key)
        if confidential_nodes is not None:
            pulumi.set(__self__, 'confidential_nodes', confidential_nodes)
        if disk_size_gb is not None:
            pulumi.set(__self__, 'disk_size_gb', disk_size_gb)
        if disk_type is not None:
            pulumi.set(__self__, 'disk_type', disk_type)
        if ephemeral_storage_config is not None:
            pulumi.set(__self__, 'ephemeral_storage_config',
                ephemeral_storage_config)
        if ephemeral_storage_local_ssd_config is not None:
            pulumi.set(__self__, 'ephemeral_storage_local_ssd_config',
                ephemeral_storage_local_ssd_config)
        if fast_socket is not None:
            pulumi.set(__self__, 'fast_socket', fast_socket)
        if gcfs_config is not None:
            pulumi.set(__self__, 'gcfs_config', gcfs_config)
        if gvnic is not None:
            pulumi.set(__self__, 'gvnic', gvnic)
        if image_type is not None:
            pulumi.set(__self__, 'image_type', image_type)
        if kubelet_config is not None:
            pulumi.set(__self__, 'kubelet_config', kubelet_config)
        if labels is not None:
            pulumi.set(__self__, 'labels', labels)
        if linux_node_config is not None:
            pulumi.set(__self__, 'linux_node_config', linux_node_config)
        if local_nvme_ssd_block_config is not None:
            pulumi.set(__self__, 'local_nvme_ssd_block_config',
                local_nvme_ssd_block_config)
        if local_ssd_count is not None:
            pulumi.set(__self__, 'local_ssd_count', local_ssd_count)
        if logging_config is not None:
            pulumi.set(__self__, 'logging_config', logging_config)
        if machine_type is not None:
            pulumi.set(__self__, 'machine_type', machine_type)
        if metadata is not None:
            pulumi.set(__self__, 'metadata', metadata)
        if min_cpu_platform is not None:
            pulumi.set(__self__, 'min_cpu_platform', min_cpu_platform)
        if node_group is not None:
            pulumi.set(__self__, 'node_group', node_group)
        if oauth_scopes is not None:
            pulumi.set(__self__, 'oauth_scopes', oauth_scopes)
        if preemptible is not None:
            pulumi.set(__self__, 'preemptible', preemptible)
        if reservation_affinity is not None:
            pulumi.set(__self__, 'reservation_affinity', reservation_affinity)
        if resource_labels is not None:
            pulumi.set(__self__, 'resource_labels', resource_labels)
        if sandbox_config is not None:
            pulumi.set(__self__, 'sandbox_config', sandbox_config)
        if service_account is not None:
            pulumi.set(__self__, 'service_account', service_account)
        if shielded_instance_config is not None:
            pulumi.set(__self__, 'shielded_instance_config',
                shielded_instance_config)
        if spot is not None:
            pulumi.set(__self__, 'spot', spot)
        if tags is not None:
            pulumi.set(__self__, 'tags', tags)
        if taints is not None:
            pulumi.set(__self__, 'taints', taints)
        if windows_node_config is not None:
            pulumi.set(__self__, 'windows_node_config', windows_node_config)
        if workload_metadata_config is not None:
            pulumi.set(__self__, 'workload_metadata_config',
                workload_metadata_config)

    @property
    @pulumi.getter
    def accelerators(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[
        'AcceleratorConfigArgs']]]]:
        """
        A list of hardware accelerators to be attached to each node. See https://cloud.google.com/compute/docs/gpus for more information about support for GPUs.
        """
        return pulumi.get(self, 'accelerators')

    @accelerators.setter
    def accelerators(self, value: Optional[pulumi.Input[Sequence[pulumi.
        Input['AcceleratorConfigArgs']]]]):
        pulumi.set(self, 'accelerators', value)

    @property
    @pulumi.getter(name='advancedMachineFeatures')
    def advanced_machine_features(self) ->Optional[pulumi.Input[
        'AdvancedMachineFeaturesArgs']]:
        """
        Advanced features for the Compute Engine VM.
        """
        return pulumi.get(self, 'advanced_machine_features')

    @advanced_machine_features.setter
    def advanced_machine_features(self, value: Optional[pulumi.Input[
        'AdvancedMachineFeaturesArgs']]):
        pulumi.set(self, 'advanced_machine_features', value)

    @property
    @pulumi.getter(name='bootDiskKmsKey')
    def boot_disk_kms_key(self) ->Optional[pulumi.Input[str]]:
        """
         The Customer Managed Encryption Key used to encrypt the boot disk attached to each node in the node pool. This should be of the form projects/[KEY_PROJECT_ID]/locations/[LOCATION]/keyRings/[RING_NAME]/cryptoKeys/[KEY_NAME]. For more information about protecting resources with Cloud KMS Keys please see: https://cloud.google.com/compute/docs/disks/customer-managed-encryption
        """
        return pulumi.get(self, 'boot_disk_kms_key')

    @boot_disk_kms_key.setter
    def boot_disk_kms_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'boot_disk_kms_key', value)

    @property
    @pulumi.getter(name='confidentialNodes')
    def confidential_nodes(self) ->Optional[pulumi.Input[
        'ConfidentialNodesArgs']]:
        """
        Confidential nodes config. All the nodes in the node pool will be Confidential VM once enabled.
        """
        return pulumi.get(self, 'confidential_nodes')

    @confidential_nodes.setter
    def confidential_nodes(self, value: Optional[pulumi.Input[
        'ConfidentialNodesArgs']]):
        pulumi.set(self, 'confidential_nodes', value)

    @property
    @pulumi.getter(name='diskSizeGb')
    def disk_size_gb(self) ->Optional[pulumi.Input[int]]:
        """
        Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB. If unspecified, the default disk size is 100GB.
        """
        return pulumi.get(self, 'disk_size_gb')

    @disk_size_gb.setter
    def disk_size_gb(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'disk_size_gb', value)

    @property
    @pulumi.getter(name='diskType')
    def disk_type(self) ->Optional[pulumi.Input[str]]:
        """
        Type of the disk attached to each node (e.g. 'pd-standard', 'pd-ssd' or 'pd-balanced') If unspecified, the default disk type is 'pd-standard'
        """
        return pulumi.get(self, 'disk_type')

    @disk_type.setter
    def disk_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'disk_type', value)

    @property
    @pulumi.getter(name='ephemeralStorageConfig')
    def ephemeral_storage_config(self) ->Optional[pulumi.Input[
        'EphemeralStorageConfigArgs']]:
        """
        Parameters for the ephemeral storage filesystem. If unspecified, ephemeral storage is backed by the boot disk.
        """
        return pulumi.get(self, 'ephemeral_storage_config')

    @ephemeral_storage_config.setter
    def ephemeral_storage_config(self, value: Optional[pulumi.Input[
        'EphemeralStorageConfigArgs']]):
        pulumi.set(self, 'ephemeral_storage_config', value)

    @property
    @pulumi.getter(name='ephemeralStorageLocalSsdConfig')
    def ephemeral_storage_local_ssd_config(self) ->Optional[pulumi.Input[
        'EphemeralStorageLocalSsdConfigArgs']]:
        """
        Parameters for the node ephemeral storage using Local SSDs. If unspecified, ephemeral storage is backed by the boot disk. This field is functionally equivalent to the ephemeral_storage_config
        """
        return pulumi.get(self, 'ephemeral_storage_local_ssd_config')

    @ephemeral_storage_local_ssd_config.setter
    def ephemeral_storage_local_ssd_config(self, value: Optional[pulumi.
        Input['EphemeralStorageLocalSsdConfigArgs']]):
        pulumi.set(self, 'ephemeral_storage_local_ssd_config', value)

    @property
    @pulumi.getter(name='fastSocket')
    def fast_socket(self) ->Optional[pulumi.Input['FastSocketArgs']]:
        """
        Enable or disable NCCL fast socket for the node pool.
        """
        return pulumi.get(self, 'fast_socket')

    @fast_socket.setter
    def fast_socket(self, value: Optional[pulumi.Input['FastSocketArgs']]):
        pulumi.set(self, 'fast_socket', value)

    @property
    @pulumi.getter(name='gcfsConfig')
    def gcfs_config(self) ->Optional[pulumi.Input['GcfsConfigArgs']]:
        """
        GCFS (Google Container File System) configs.
        """
        return pulumi.get(self, 'gcfs_config')

    @gcfs_config.setter
    def gcfs_config(self, value: Optional[pulumi.Input['GcfsConfigArgs']]):
        pulumi.set(self, 'gcfs_config', value)

    @property
    @pulumi.getter
    def gvnic(self) ->Optional[pulumi.Input['VirtualNICArgs']]:
        """
        Enable or disable gvnic on the node pool.
        """
        return pulumi.get(self, 'gvnic')

    @gvnic.setter
    def gvnic(self, value: Optional[pulumi.Input['VirtualNICArgs']]):
        pulumi.set(self, 'gvnic', value)

    @property
    @pulumi.getter(name='imageType')
    def image_type(self) ->Optional[pulumi.Input[str]]:
        """
        The image type to use for this node. Note that for a given image type, the latest version of it will be used. Please see https://cloud.google.com/kubernetes-engine/docs/concepts/node-images for available image types.
        """
        return pulumi.get(self, 'image_type')

    @image_type.setter
    def image_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'image_type', value)

    @property
    @pulumi.getter(name='kubeletConfig')
    def kubelet_config(self) ->Optional[pulumi.Input['NodeKubeletConfigArgs']]:
        """
        Node kubelet configs.
        """
        return pulumi.get(self, 'kubelet_config')

    @kubelet_config.setter
    def kubelet_config(self, value: Optional[pulumi.Input[
        'NodeKubeletConfigArgs']]):
        pulumi.set(self, 'kubelet_config', value)

    @property
    @pulumi.getter
    def labels(self) ->Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        The map of Kubernetes labels (key/value pairs) to be applied to each node. These will added in addition to any default label(s) that Kubernetes may apply to the node. In case of conflict in label keys, the applied set may differ depending on the Kubernetes version -- it's best to assume the behavior is undefined and conflicts should be avoided. For more information, including usage and the valid values, see: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/
        """
        return pulumi.get(self, 'labels')

    @labels.setter
    def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input
        [str]]]]):
        pulumi.set(self, 'labels', value)

    @property
    @pulumi.getter(name='linuxNodeConfig')
    def linux_node_config(self) ->Optional[pulumi.Input['LinuxNodeConfigArgs']
        ]:
        """
        Parameters that can be configured on Linux nodes.
        """
        return pulumi.get(self, 'linux_node_config')

    @linux_node_config.setter
    def linux_node_config(self, value: Optional[pulumi.Input[
        'LinuxNodeConfigArgs']]):
        pulumi.set(self, 'linux_node_config', value)

    @property
    @pulumi.getter(name='localNvmeSsdBlockConfig')
    def local_nvme_ssd_block_config(self) ->Optional[pulumi.Input[
        'LocalNvmeSsdBlockConfigArgs']]:
        """
        Parameters for using raw-block Local NVMe SSDs.
        """
        return pulumi.get(self, 'local_nvme_ssd_block_config')

    @local_nvme_ssd_block_config.setter
    def local_nvme_ssd_block_config(self, value: Optional[pulumi.Input[
        'LocalNvmeSsdBlockConfigArgs']]):
        pulumi.set(self, 'local_nvme_ssd_block_config', value)

    @property
    @pulumi.getter(name='localSsdCount')
    def local_ssd_count(self) ->Optional[pulumi.Input[int]]:
        """
        The number of local SSD disks to be attached to the node. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        """
        return pulumi.get(self, 'local_ssd_count')

    @local_ssd_count.setter
    def local_ssd_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'local_ssd_count', value)

    @property
    @pulumi.getter(name='loggingConfig')
    def logging_config(self) ->Optional[pulumi.Input[
        'NodePoolLoggingConfigArgs']]:
        """
        Logging configuration.
        """
        return pulumi.get(self, 'logging_config')

    @logging_config.setter
    def logging_config(self, value: Optional[pulumi.Input[
        'NodePoolLoggingConfigArgs']]):
        pulumi.set(self, 'logging_config', value)

    @property
    @pulumi.getter(name='machineType')
    def machine_type(self) ->Optional[pulumi.Input[str]]:
        """
        The name of a Google Compute Engine [machine type](https://cloud.google.com/compute/docs/machine-types). If unspecified, the default machine type is `e2-medium`.
        """
        return pulumi.get(self, 'machine_type')

    @machine_type.setter
    def machine_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'machine_type', value)

    @property
    @pulumi.getter
    def metadata(self) ->Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]
        ]:
        """
        The metadata key/value pairs assigned to instances in the cluster. Keys must conform to the regexp `[a-zA-Z0-9-_]+` and be less than 128 bytes in length. These are reflected as part of a URL in the metadata server. Additionally, to avoid ambiguity, keys must not conflict with any other metadata keys for the project or be one of the reserved keys: - "cluster-location" - "cluster-name" - "cluster-uid" - "configure-sh" - "containerd-configure-sh" - "enable-oslogin" - "gci-ensure-gke-docker" - "gci-metrics-enabled" - "gci-update-strategy" - "instance-template" - "kube-env" - "startup-script" - "user-data" - "disable-address-manager" - "windows-startup-script-ps1" - "common-psm1" - "k8s-node-setup-psm1" - "install-ssh-psm1" - "user-profile-psm1" Values are free-form strings, and only have meaning as interpreted by the image running in the instance. The only restriction placed on them is that each value's size must be less than or equal to 32 KB. The total size of all keys and values must be less than 512 KB.
        """
        return pulumi.get(self, 'metadata')

    @metadata.setter
    def metadata(self, value: Optional[pulumi.Input[Mapping[str, pulumi.
        Input[str]]]]):
        pulumi.set(self, 'metadata', value)

    @property
    @pulumi.getter(name='minCpuPlatform')
    def min_cpu_platform(self) ->Optional[pulumi.Input[str]]:
        """
        Minimum CPU platform to be used by this instance. The instance may be scheduled on the specified or newer CPU platform. Applicable values are the friendly names of CPU platforms, such as `minCpuPlatform: "Intel Haswell"` or `minCpuPlatform: "Intel Sandy Bridge"`. For more information, read [how to specify min CPU platform](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform).
        """
        return pulumi.get(self, 'min_cpu_platform')

    @min_cpu_platform.setter
    def min_cpu_platform(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'min_cpu_platform', value)

    @property
    @pulumi.getter(name='nodeGroup')
    def node_group(self) ->Optional[pulumi.Input[str]]:
        """
        Setting this field will assign instances of this pool to run on the specified node group. This is useful for running workloads on [sole tenant nodes](https://cloud.google.com/compute/docs/nodes/sole-tenant-nodes).
        """
        return pulumi.get(self, 'node_group')

    @node_group.setter
    def node_group(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'node_group', value)

    @property
    @pulumi.getter(name='oauthScopes')
    def oauth_scopes(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[str]]]
        ]:
        """
        The set of Google API scopes to be made available on all of the node VMs under the "default" service account. The following scopes are recommended, but not required, and by default are not included: * `https://www.googleapis.com/auth/compute` is required for mounting persistent storage on your nodes. * `https://www.googleapis.com/auth/devstorage.read_only` is required for communicating with **gcr.io** (the [Google Container Registry](https://cloud.google.com/container-registry/)). If unspecified, no scopes are added, unless Cloud Logging or Cloud Monitoring are enabled, in which case their required scopes will be added.
        """
        return pulumi.get(self, 'oauth_scopes')

    @oauth_scopes.setter
    def oauth_scopes(self, value: Optional[pulumi.Input[Sequence[pulumi.
        Input[str]]]]):
        pulumi.set(self, 'oauth_scopes', value)

    @property
    @pulumi.getter
    def preemptible(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the nodes are created as preemptible VM instances. See: https://cloud.google.com/compute/docs/instances/preemptible for more inforamtion about preemptible VM instances.
        """
        return pulumi.get(self, 'preemptible')

    @preemptible.setter
    def preemptible(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'preemptible', value)

    @property
    @pulumi.getter(name='reservationAffinity')
    def reservation_affinity(self) ->Optional[pulumi.Input[
        'ReservationAffinityArgs']]:
        """
        The optional reservation affinity. Setting this field will apply the specified [Zonal Compute Reservation](https://cloud.google.com/compute/docs/instances/reserving-zonal-resources) to this node pool.
        """
        return pulumi.get(self, 'reservation_affinity')

    @reservation_affinity.setter
    def reservation_affinity(self, value: Optional[pulumi.Input[
        'ReservationAffinityArgs']]):
        pulumi.set(self, 'reservation_affinity', value)

    @property
    @pulumi.getter(name='resourceLabels')
    def resource_labels(self) ->Optional[pulumi.Input[Mapping[str, pulumi.
        Input[str]]]]:
        """
        The resource labels for the node pool to use to annotate any related Google Compute Engine resources.
        """
        return pulumi.get(self, 'resource_labels')

    @resource_labels.setter
    def resource_labels(self, value: Optional[pulumi.Input[Mapping[str,
        pulumi.Input[str]]]]):
        pulumi.set(self, 'resource_labels', value)

    @property
    @pulumi.getter(name='sandboxConfig')
    def sandbox_config(self) ->Optional[pulumi.Input['SandboxConfigArgs']]:
        """
        Sandbox configuration for this node.
        """
        return pulumi.get(self, 'sandbox_config')

    @sandbox_config.setter
    def sandbox_config(self, value: Optional[pulumi.Input['SandboxConfigArgs']]
        ):
        pulumi.set(self, 'sandbox_config', value)

    @property
    @pulumi.getter(name='serviceAccount')
    def service_account(self) ->Optional[pulumi.Input[str]]:
        """
        The Google Cloud Platform Service Account to be used by the node VMs. Specify the email address of the Service Account; otherwise, if no Service Account is specified, the "default" service account is used.
        """
        return pulumi.get(self, 'service_account')

    @service_account.setter
    def service_account(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'service_account', value)

    @property
    @pulumi.getter(name='shieldedInstanceConfig')
    def shielded_instance_config(self) ->Optional[pulumi.Input[
        'ShieldedInstanceConfigArgs']]:
        """
        Shielded Instance options.
        """
        return pulumi.get(self, 'shielded_instance_config')

    @shielded_instance_config.setter
    def shielded_instance_config(self, value: Optional[pulumi.Input[
        'ShieldedInstanceConfigArgs']]):
        pulumi.set(self, 'shielded_instance_config', value)

    @property
    @pulumi.getter
    def spot(self) ->Optional[pulumi.Input[bool]]:
        """
        Spot flag for enabling Spot VM, which is a rebrand of the existing preemptible flag.
        """
        return pulumi.get(self, 'spot')

    @spot.setter
    def spot(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'spot', value)

    @property
    @pulumi.getter
    def tags(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The list of instance tags applied to all nodes. Tags are used to identify valid sources or targets for network firewalls and are specified by the client during cluster or node pool creation. Each tag within the list must comply with RFC1035.
        """
        return pulumi.get(self, 'tags')

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, 'tags', value)

    @property
    @pulumi.getter
    def taints(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[
        'NodeTaintArgs']]]]:
        """
        List of kubernetes taints to be applied to each node. For more information, including usage and the valid values, see: https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/
        """
        return pulumi.get(self, 'taints')

    @taints.setter
    def taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
        'NodeTaintArgs']]]]):
        pulumi.set(self, 'taints', value)

    @property
    @pulumi.getter(name='windowsNodeConfig')
    def windows_node_config(self) ->Optional[pulumi.Input[
        'WindowsNodeConfigArgs']]:
        """
        Parameters that can be configured on Windows nodes.
        """
        return pulumi.get(self, 'windows_node_config')

    @windows_node_config.setter
    def windows_node_config(self, value: Optional[pulumi.Input[
        'WindowsNodeConfigArgs']]):
        pulumi.set(self, 'windows_node_config', value)

    @property
    @pulumi.getter(name='workloadMetadataConfig')
    def workload_metadata_config(self) ->Optional[pulumi.Input[
        'WorkloadMetadataConfigArgs']]:
        """
        The workload metadata configuration for this node.
        """
        return pulumi.get(self, 'workload_metadata_config')

    @workload_metadata_config.setter
    def workload_metadata_config(self, value: Optional[pulumi.Input[
        'WorkloadMetadataConfigArgs']]):
        pulumi.set(self, 'workload_metadata_config', value)


@pulumi.input_type
class NodeKubeletConfigArgs:

    def __init__(__self__, *, cpu_cfs_quota: Optional[pulumi.Input[bool]]=
        None, cpu_cfs_quota_period: Optional[pulumi.Input[str]]=None,
        cpu_manager_policy: Optional[pulumi.Input[str]]=None,
        pod_pids_limit: Optional[pulumi.Input[str]]=None):
        """
        Node kubelet configs.
        :param pulumi.Input[bool] cpu_cfs_quota: Enable CPU CFS quota enforcement for containers that specify CPU limits. This option is enabled by default which makes kubelet use CFS quota (https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt) to enforce container CPU limits. Otherwise, CPU limits will not be enforced at all. Disable this option to mitigate CPU throttling problems while still having your pods to be in Guaranteed QoS class by specifying the CPU limits. The default value is 'true' if unspecified.
        :param pulumi.Input[str] cpu_cfs_quota_period: Set the CPU CFS quota period value 'cpu.cfs_period_us'. The string must be a sequence of decimal numbers, each with optional fraction and a unit suffix, such as "300ms". Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h". The value must be a positive duration.
        :param pulumi.Input[str] cpu_manager_policy: Control the CPU management policy on the node. See https://kubernetes.io/docs/tasks/administer-cluster/cpu-management-policies/ The following values are allowed. * "none": the default, which represents the existing scheduling behavior. * "static": allows pods with certain resource characteristics to be granted increased CPU affinity and exclusivity on the node. The default value is 'none' if unspecified.
        :param pulumi.Input[str] pod_pids_limit: Set the Pod PID limits. See https://kubernetes.io/docs/concepts/policy/pid-limiting/#pod-pid-limits Controls the maximum number of processes allowed to run in a pod. The value must be greater than or equal to 1024 and less than 4194304.
        """
        if cpu_cfs_quota is not None:
            pulumi.set(__self__, 'cpu_cfs_quota', cpu_cfs_quota)
        if cpu_cfs_quota_period is not None:
            pulumi.set(__self__, 'cpu_cfs_quota_period', cpu_cfs_quota_period)
        if cpu_manager_policy is not None:
            pulumi.set(__self__, 'cpu_manager_policy', cpu_manager_policy)
        if pod_pids_limit is not None:
            pulumi.set(__self__, 'pod_pids_limit', pod_pids_limit)

    @property
    @pulumi.getter(name='cpuCfsQuota')
    def cpu_cfs_quota(self) ->Optional[pulumi.Input[bool]]:
        """
        Enable CPU CFS quota enforcement for containers that specify CPU limits. This option is enabled by default which makes kubelet use CFS quota (https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt) to enforce container CPU limits. Otherwise, CPU limits will not be enforced at all. Disable this option to mitigate CPU throttling problems while still having your pods to be in Guaranteed QoS class by specifying the CPU limits. The default value is 'true' if unspecified.
        """
        return pulumi.get(self, 'cpu_cfs_quota')

    @cpu_cfs_quota.setter
    def cpu_cfs_quota(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'cpu_cfs_quota', value)

    @property
    @pulumi.getter(name='cpuCfsQuotaPeriod')
    def cpu_cfs_quota_period(self) ->Optional[pulumi.Input[str]]:
        """
        Set the CPU CFS quota period value 'cpu.cfs_period_us'. The string must be a sequence of decimal numbers, each with optional fraction and a unit suffix, such as "300ms". Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h". The value must be a positive duration.
        """
        return pulumi.get(self, 'cpu_cfs_quota_period')

    @cpu_cfs_quota_period.setter
    def cpu_cfs_quota_period(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'cpu_cfs_quota_period', value)

    @property
    @pulumi.getter(name='cpuManagerPolicy')
    def cpu_manager_policy(self) ->Optional[pulumi.Input[str]]:
        """
        Control the CPU management policy on the node. See https://kubernetes.io/docs/tasks/administer-cluster/cpu-management-policies/ The following values are allowed. * "none": the default, which represents the existing scheduling behavior. * "static": allows pods with certain resource characteristics to be granted increased CPU affinity and exclusivity on the node. The default value is 'none' if unspecified.
        """
        return pulumi.get(self, 'cpu_manager_policy')

    @cpu_manager_policy.setter
    def cpu_manager_policy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'cpu_manager_policy', value)

    @property
    @pulumi.getter(name='podPidsLimit')
    def pod_pids_limit(self) ->Optional[pulumi.Input[str]]:
        """
        Set the Pod PID limits. See https://kubernetes.io/docs/concepts/policy/pid-limiting/#pod-pid-limits Controls the maximum number of processes allowed to run in a pod. The value must be greater than or equal to 1024 and less than 4194304.
        """
        return pulumi.get(self, 'pod_pids_limit')

    @pod_pids_limit.setter
    def pod_pids_limit(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'pod_pids_limit', value)


@pulumi.input_type
class NodeManagementArgs:

    def __init__(__self__, *, auto_repair: Optional[pulumi.Input[bool]]=
        None, auto_upgrade: Optional[pulumi.Input[bool]]=None,
        upgrade_options: Optional[pulumi.Input['AutoUpgradeOptionsArgs']]=None
        ):
        """
        NodeManagement defines the set of node management services turned on for the node pool.
        :param pulumi.Input[bool] auto_repair: Whether the nodes will be automatically repaired.
        :param pulumi.Input[bool] auto_upgrade: Whether the nodes will be automatically upgraded.
        :param pulumi.Input['AutoUpgradeOptionsArgs'] upgrade_options: Specifies the Auto Upgrade knobs for the node pool.
        """
        if auto_repair is not None:
            pulumi.set(__self__, 'auto_repair', auto_repair)
        if auto_upgrade is not None:
            pulumi.set(__self__, 'auto_upgrade', auto_upgrade)
        if upgrade_options is not None:
            pulumi.set(__self__, 'upgrade_options', upgrade_options)

    @property
    @pulumi.getter(name='autoRepair')
    def auto_repair(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the nodes will be automatically repaired.
        """
        return pulumi.get(self, 'auto_repair')

    @auto_repair.setter
    def auto_repair(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'auto_repair', value)

    @property
    @pulumi.getter(name='autoUpgrade')
    def auto_upgrade(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the nodes will be automatically upgraded.
        """
        return pulumi.get(self, 'auto_upgrade')

    @auto_upgrade.setter
    def auto_upgrade(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'auto_upgrade', value)

    @property
    @pulumi.getter(name='upgradeOptions')
    def upgrade_options(self) ->Optional[pulumi.Input['AutoUpgradeOptionsArgs']
        ]:
        """
        Specifies the Auto Upgrade knobs for the node pool.
        """
        return pulumi.get(self, 'upgrade_options')

    @upgrade_options.setter
    def upgrade_options(self, value: Optional[pulumi.Input[
        'AutoUpgradeOptionsArgs']]):
        pulumi.set(self, 'upgrade_options', value)


@pulumi.input_type
class NodeNetworkConfigArgs:

    def __init__(__self__, *, create_pod_range: Optional[pulumi.Input[bool]
        ]=None, enable_private_nodes: Optional[pulumi.Input[bool]]=None,
        network_performance_config: Optional[pulumi.Input[
        'NetworkPerformanceConfigArgs']]=None,
        pod_cidr_overprovision_config: Optional[pulumi.Input[
        'PodCIDROverprovisionConfigArgs']]=None, pod_ipv4_cidr_block:
        Optional[pulumi.Input[str]]=None, pod_range: Optional[pulumi.Input[
        str]]=None):
        """
        Parameters for node pool-level network config.
        :param pulumi.Input[bool] create_pod_range: Input only. Whether to create a new range for pod IPs in this node pool. Defaults are provided for `pod_range` and `pod_ipv4_cidr_block` if they are not specified. If neither `create_pod_range` or `pod_range` are specified, the cluster-level default (`ip_allocation_policy.cluster_ipv4_cidr_block`) is used. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        :param pulumi.Input[bool] enable_private_nodes: Whether nodes have internal IP addresses only. If enable_private_nodes is not specified, then the value is derived from cluster.privateClusterConfig.enablePrivateNodes
        :param pulumi.Input['NetworkPerformanceConfigArgs'] network_performance_config: Network bandwidth tier configuration.
        :param pulumi.Input['PodCIDROverprovisionConfigArgs'] pod_cidr_overprovision_config: [PRIVATE FIELD] Pod CIDR size overprovisioning config for the nodepool. Pod CIDR size per node depends on max_pods_per_node. By default, the value of max_pods_per_node is rounded off to next power of 2 and we then double that to get the size of pod CIDR block per node. Example: max_pods_per_node of 30 would result in 64 IPs (/26). This config can disable the doubling of IPs (we still round off to next power of 2) Example: max_pods_per_node of 30 will result in 32 IPs (/27) when overprovisioning is disabled.
        :param pulumi.Input[str] pod_ipv4_cidr_block: The IP address range for pod IPs in this node pool. Only applicable if `create_pod_range` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) to pick a specific range to use. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        :param pulumi.Input[str] pod_range: The ID of the secondary range for pod IPs. If `create_pod_range` is true, this ID is used for the new range. If `create_pod_range` is false, uses an existing secondary range with this ID. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        """
        if create_pod_range is not None:
            pulumi.set(__self__, 'create_pod_range', create_pod_range)
        if enable_private_nodes is not None:
            pulumi.set(__self__, 'enable_private_nodes', enable_private_nodes)
        if network_performance_config is not None:
            pulumi.set(__self__, 'network_performance_config',
                network_performance_config)
        if pod_cidr_overprovision_config is not None:
            pulumi.set(__self__, 'pod_cidr_overprovision_config',
                pod_cidr_overprovision_config)
        if pod_ipv4_cidr_block is not None:
            pulumi.set(__self__, 'pod_ipv4_cidr_block', pod_ipv4_cidr_block)
        if pod_range is not None:
            pulumi.set(__self__, 'pod_range', pod_range)

    @property
    @pulumi.getter(name='createPodRange')
    def create_pod_range(self) ->Optional[pulumi.Input[bool]]:
        """
        Input only. Whether to create a new range for pod IPs in this node pool. Defaults are provided for `pod_range` and `pod_ipv4_cidr_block` if they are not specified. If neither `create_pod_range` or `pod_range` are specified, the cluster-level default (`ip_allocation_policy.cluster_ipv4_cidr_block`) is used. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        """
        return pulumi.get(self, 'create_pod_range')

    @create_pod_range.setter
    def create_pod_range(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'create_pod_range', value)

    @property
    @pulumi.getter(name='enablePrivateNodes')
    def enable_private_nodes(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether nodes have internal IP addresses only. If enable_private_nodes is not specified, then the value is derived from cluster.privateClusterConfig.enablePrivateNodes
        """
        return pulumi.get(self, 'enable_private_nodes')

    @enable_private_nodes.setter
    def enable_private_nodes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_private_nodes', value)

    @property
    @pulumi.getter(name='networkPerformanceConfig')
    def network_performance_config(self) ->Optional[pulumi.Input[
        'NetworkPerformanceConfigArgs']]:
        """
        Network bandwidth tier configuration.
        """
        return pulumi.get(self, 'network_performance_config')

    @network_performance_config.setter
    def network_performance_config(self, value: Optional[pulumi.Input[
        'NetworkPerformanceConfigArgs']]):
        pulumi.set(self, 'network_performance_config', value)

    @property
    @pulumi.getter(name='podCidrOverprovisionConfig')
    def pod_cidr_overprovision_config(self) ->Optional[pulumi.Input[
        'PodCIDROverprovisionConfigArgs']]:
        """
        [PRIVATE FIELD] Pod CIDR size overprovisioning config for the nodepool. Pod CIDR size per node depends on max_pods_per_node. By default, the value of max_pods_per_node is rounded off to next power of 2 and we then double that to get the size of pod CIDR block per node. Example: max_pods_per_node of 30 would result in 64 IPs (/26). This config can disable the doubling of IPs (we still round off to next power of 2) Example: max_pods_per_node of 30 will result in 32 IPs (/27) when overprovisioning is disabled.
        """
        return pulumi.get(self, 'pod_cidr_overprovision_config')

    @pod_cidr_overprovision_config.setter
    def pod_cidr_overprovision_config(self, value: Optional[pulumi.Input[
        'PodCIDROverprovisionConfigArgs']]):
        pulumi.set(self, 'pod_cidr_overprovision_config', value)

    @property
    @pulumi.getter(name='podIpv4CidrBlock')
    def pod_ipv4_cidr_block(self) ->Optional[pulumi.Input[str]]:
        """
        The IP address range for pod IPs in this node pool. Only applicable if `create_pod_range` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) to pick a specific range to use. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        """
        return pulumi.get(self, 'pod_ipv4_cidr_block')

    @pod_ipv4_cidr_block.setter
    def pod_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'pod_ipv4_cidr_block', value)

    @property
    @pulumi.getter(name='podRange')
    def pod_range(self) ->Optional[pulumi.Input[str]]:
        """
        The ID of the secondary range for pod IPs. If `create_pod_range` is true, this ID is used for the new range. If `create_pod_range` is false, uses an existing secondary range with this ID. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        """
        return pulumi.get(self, 'pod_range')

    @pod_range.setter
    def pod_range(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'pod_range', value)


@pulumi.input_type
class NodePoolAutoConfigArgs:

    def __init__(__self__, *, network_tags: Optional[pulumi.Input[
        'NetworkTagsArgs']]=None):
        """
        node pool configs that apply to all auto-provisioned node pools in autopilot clusters and node auto-provisioning enabled clusters
        :param pulumi.Input['NetworkTagsArgs'] network_tags: The list of instance tags applied to all nodes. Tags are used to identify valid sources or targets for network firewalls and are specified by the client during cluster creation. Each tag within the list must comply with RFC1035.
        """
        if network_tags is not None:
            pulumi.set(__self__, 'network_tags', network_tags)

    @property
    @pulumi.getter(name='networkTags')
    def network_tags(self) ->Optional[pulumi.Input['NetworkTagsArgs']]:
        """
        The list of instance tags applied to all nodes. Tags are used to identify valid sources or targets for network firewalls and are specified by the client during cluster creation. Each tag within the list must comply with RFC1035.
        """
        return pulumi.get(self, 'network_tags')

    @network_tags.setter
    def network_tags(self, value: Optional[pulumi.Input['NetworkTagsArgs']]):
        pulumi.set(self, 'network_tags', value)


@pulumi.input_type
class NodePoolAutoscalingArgs:

    def __init__(__self__, *, autoprovisioned: Optional[pulumi.Input[bool]]
        =None, enabled: Optional[pulumi.Input[bool]]=None, location_policy:
        Optional[pulumi.Input['NodePoolAutoscalingLocationPolicy']]=None,
        max_node_count: Optional[pulumi.Input[int]]=None, min_node_count:
        Optional[pulumi.Input[int]]=None, total_max_node_count: Optional[
        pulumi.Input[int]]=None, total_min_node_count: Optional[pulumi.
        Input[int]]=None):
        """
        NodePoolAutoscaling contains information required by cluster autoscaler to adjust the size of the node pool to the current cluster usage.
        :param pulumi.Input[bool] autoprovisioned: Can this node pool be deleted automatically.
        :param pulumi.Input[bool] enabled: Is autoscaling enabled for this node pool.
        :param pulumi.Input['NodePoolAutoscalingLocationPolicy'] location_policy: Location policy used when scaling up a nodepool.
        :param pulumi.Input[int] max_node_count: Maximum number of nodes for one location in the NodePool. Must be >= min_node_count. There has to be enough quota to scale up the cluster.
        :param pulumi.Input[int] min_node_count: Minimum number of nodes for one location in the NodePool. Must be >= 1 and <= max_node_count.
        :param pulumi.Input[int] total_max_node_count: Maximum number of nodes in the node pool. Must be greater than total_min_node_count. There has to be enough quota to scale up the cluster. The total_*_node_count fields are mutually exclusive with the *_node_count fields.
        :param pulumi.Input[int] total_min_node_count: Minimum number of nodes in the node pool. Must be greater than 1 less than total_max_node_count. The total_*_node_count fields are mutually exclusive with the *_node_count fields.
        """
        if autoprovisioned is not None:
            pulumi.set(__self__, 'autoprovisioned', autoprovisioned)
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)
        if location_policy is not None:
            pulumi.set(__self__, 'location_policy', location_policy)
        if max_node_count is not None:
            pulumi.set(__self__, 'max_node_count', max_node_count)
        if min_node_count is not None:
            pulumi.set(__self__, 'min_node_count', min_node_count)
        if total_max_node_count is not None:
            pulumi.set(__self__, 'total_max_node_count', total_max_node_count)
        if total_min_node_count is not None:
            pulumi.set(__self__, 'total_min_node_count', total_min_node_count)

    @property
    @pulumi.getter
    def autoprovisioned(self) ->Optional[pulumi.Input[bool]]:
        """
        Can this node pool be deleted automatically.
        """
        return pulumi.get(self, 'autoprovisioned')

    @autoprovisioned.setter
    def autoprovisioned(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'autoprovisioned', value)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Is autoscaling enabled for this node pool.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)

    @property
    @pulumi.getter(name='locationPolicy')
    def location_policy(self) ->Optional[pulumi.Input[
        'NodePoolAutoscalingLocationPolicy']]:
        """
        Location policy used when scaling up a nodepool.
        """
        return pulumi.get(self, 'location_policy')

    @location_policy.setter
    def location_policy(self, value: Optional[pulumi.Input[
        'NodePoolAutoscalingLocationPolicy']]):
        pulumi.set(self, 'location_policy', value)

    @property
    @pulumi.getter(name='maxNodeCount')
    def max_node_count(self) ->Optional[pulumi.Input[int]]:
        """
        Maximum number of nodes for one location in the NodePool. Must be >= min_node_count. There has to be enough quota to scale up the cluster.
        """
        return pulumi.get(self, 'max_node_count')

    @max_node_count.setter
    def max_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'max_node_count', value)

    @property
    @pulumi.getter(name='minNodeCount')
    def min_node_count(self) ->Optional[pulumi.Input[int]]:
        """
        Minimum number of nodes for one location in the NodePool. Must be >= 1 and <= max_node_count.
        """
        return pulumi.get(self, 'min_node_count')

    @min_node_count.setter
    def min_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'min_node_count', value)

    @property
    @pulumi.getter(name='totalMaxNodeCount')
    def total_max_node_count(self) ->Optional[pulumi.Input[int]]:
        """
        Maximum number of nodes in the node pool. Must be greater than total_min_node_count. There has to be enough quota to scale up the cluster. The total_*_node_count fields are mutually exclusive with the *_node_count fields.
        """
        return pulumi.get(self, 'total_max_node_count')

    @total_max_node_count.setter
    def total_max_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'total_max_node_count', value)

    @property
    @pulumi.getter(name='totalMinNodeCount')
    def total_min_node_count(self) ->Optional[pulumi.Input[int]]:
        """
        Minimum number of nodes in the node pool. Must be greater than 1 less than total_max_node_count. The total_*_node_count fields are mutually exclusive with the *_node_count fields.
        """
        return pulumi.get(self, 'total_min_node_count')

    @total_min_node_count.setter
    def total_min_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'total_min_node_count', value)


@pulumi.input_type
class NodePoolDefaultsArgs:

    def __init__(__self__, *, node_config_defaults: Optional[pulumi.Input[
        'NodeConfigDefaultsArgs']]=None):
        """
        Subset of Nodepool message that has defaults.
        :param pulumi.Input['NodeConfigDefaultsArgs'] node_config_defaults: Subset of NodeConfig message that has defaults.
        """
        if node_config_defaults is not None:
            pulumi.set(__self__, 'node_config_defaults', node_config_defaults)

    @property
    @pulumi.getter(name='nodeConfigDefaults')
    def node_config_defaults(self) ->Optional[pulumi.Input[
        'NodeConfigDefaultsArgs']]:
        """
        Subset of NodeConfig message that has defaults.
        """
        return pulumi.get(self, 'node_config_defaults')

    @node_config_defaults.setter
    def node_config_defaults(self, value: Optional[pulumi.Input[
        'NodeConfigDefaultsArgs']]):
        pulumi.set(self, 'node_config_defaults', value)


@pulumi.input_type
class NodePoolLoggingConfigArgs:

    def __init__(__self__, *, variant_config: Optional[pulumi.Input[
        'LoggingVariantConfigArgs']]=None):
        """
        NodePoolLoggingConfig specifies logging configuration for nodepools.
        :param pulumi.Input['LoggingVariantConfigArgs'] variant_config: Logging variant configuration.
        """
        if variant_config is not None:
            pulumi.set(__self__, 'variant_config', variant_config)

    @property
    @pulumi.getter(name='variantConfig')
    def variant_config(self) ->Optional[pulumi.Input[
        'LoggingVariantConfigArgs']]:
        """
        Logging variant configuration.
        """
        return pulumi.get(self, 'variant_config')

    @variant_config.setter
    def variant_config(self, value: Optional[pulumi.Input[
        'LoggingVariantConfigArgs']]):
        pulumi.set(self, 'variant_config', value)


@pulumi.input_type
class NodePoolArgs:

    def __init__(__self__, *, autoscaling: Optional[pulumi.Input[
        'NodePoolAutoscalingArgs']]=None, conditions: Optional[pulumi.Input
        [Sequence[pulumi.Input['StatusConditionArgs']]]]=None, config:
        Optional[pulumi.Input['NodeConfigArgs']]=None, etag: Optional[
        pulumi.Input[str]]=None, initial_node_count: Optional[pulumi.Input[
        int]]=None, locations: Optional[pulumi.Input[Sequence[pulumi.Input[
        str]]]]=None, management: Optional[pulumi.Input[
        'NodeManagementArgs']]=None, max_pods_constraint: Optional[pulumi.
        Input['MaxPodsConstraintArgs']]=None, name: Optional[pulumi.Input[
        str]]=None, network_config: Optional[pulumi.Input[
        'NodeNetworkConfigArgs']]=None, placement_policy: Optional[pulumi.
        Input['PlacementPolicyArgs']]=None, upgrade_settings: Optional[
        pulumi.Input['UpgradeSettingsArgs']]=None, version: Optional[pulumi
        .Input[str]]=None):
        """
        NodePool contains the name and configuration for a cluster's node pool. Node pools are a set of nodes (i.e. VM's), with a common configuration and specification, under the control of the cluster master. They may have a set of Kubernetes labels applied to them, which may be used to reference them during pod scheduling. They may also be resized up or down, to accommodate the workload. These upgrade settings control the level of parallelism and the level of disruption caused by an upgrade. maxUnavailable controls the number of nodes that can be simultaneously unavailable. maxSurge controls the number of additional nodes that can be added to the node pool temporarily for the time of the upgrade to increase the number of available nodes. (maxUnavailable + maxSurge) determines the level of parallelism (how many nodes are being upgraded at the same time). Note: upgrades inevitably introduce some disruption since workloads need to be moved from old nodes to new, upgraded ones. Even if maxUnavailable=0, this holds true. (Disruption stays within the limits of PodDisruptionBudget, if it is configured.) Consider a hypothetical node pool with 5 nodes having maxSurge=2, maxUnavailable=1. This means the upgrade process upgrades 3 nodes simultaneously. It creates 2 additional (upgraded) nodes, then it brings down 3 old (not yet upgraded) nodes at the same time. This ensures that there are always at least 4 nodes available.
        :param pulumi.Input['NodePoolAutoscalingArgs'] autoscaling: Autoscaler configuration for this NodePool. Autoscaler is enabled only if a valid configuration is present.
        :param pulumi.Input[Sequence[pulumi.Input['StatusConditionArgs']]] conditions: Which conditions caused the current node pool state.
        :param pulumi.Input['NodeConfigArgs'] config: The node configuration of the pool.
        :param pulumi.Input[str] etag: This checksum is computed by the server based on the value of node pool fields, and may be sent on update requests to ensure the client has an up-to-date value before proceeding.
        :param pulumi.Input[int] initial_node_count: The initial node count for the pool. You must ensure that your Compute Engine [resource quota](https://cloud.google.com/compute/quotas) is sufficient for this number of instances. You must also have available firewall and routes quota.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] locations: The list of Google Compute Engine [zones](https://cloud.google.com/compute/docs/zones#available) in which the NodePool's nodes should be located. If this value is unspecified during node pool creation, the [Cluster.Locations](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1/projects.locations.clusters#Cluster.FIELDS.locations) value will be used, instead. Warning: changing node pool locations will result in nodes being added and/or removed.
        :param pulumi.Input['NodeManagementArgs'] management: NodeManagement configuration for this NodePool.
        :param pulumi.Input['MaxPodsConstraintArgs'] max_pods_constraint: The constraint on the maximum number of pods that can be run simultaneously on a node in the node pool.
        :param pulumi.Input[str] name: The name of the node pool.
        :param pulumi.Input['NodeNetworkConfigArgs'] network_config: Networking configuration for this NodePool. If specified, it overrides the cluster-level defaults.
        :param pulumi.Input['PlacementPolicyArgs'] placement_policy: Specifies the node placement policy.
        :param pulumi.Input['UpgradeSettingsArgs'] upgrade_settings: Upgrade settings control disruption and speed of the upgrade.
        :param pulumi.Input[str] version: The version of Kubernetes running on this NodePool's nodes. If unspecified, it defaults as described [here](https://cloud.google.com/kubernetes-engine/versioning#specifying_node_version).
        """
        if autoscaling is not None:
            pulumi.set(__self__, 'autoscaling', autoscaling)
        if conditions is not None:
            pulumi.set(__self__, 'conditions', conditions)
        if config is not None:
            pulumi.set(__self__, 'config', config)
        if etag is not None:
            pulumi.set(__self__, 'etag', etag)
        if initial_node_count is not None:
            pulumi.set(__self__, 'initial_node_count', initial_node_count)
        if locations is not None:
            pulumi.set(__self__, 'locations', locations)
        if management is not None:
            pulumi.set(__self__, 'management', management)
        if max_pods_constraint is not None:
            pulumi.set(__self__, 'max_pods_constraint', max_pods_constraint)
        if name is not None:
            pulumi.set(__self__, 'name', name)
        if network_config is not None:
            pulumi.set(__self__, 'network_config', network_config)
        if placement_policy is not None:
            pulumi.set(__self__, 'placement_policy', placement_policy)
        if upgrade_settings is not None:
            pulumi.set(__self__, 'upgrade_settings', upgrade_settings)
        if version is not None:
            pulumi.set(__self__, 'version', version)

    @property
    @pulumi.getter
    def autoscaling(self) ->Optional[pulumi.Input['NodePoolAutoscalingArgs']]:
        """
        Autoscaler configuration for this NodePool. Autoscaler is enabled only if a valid configuration is present.
        """
        return pulumi.get(self, 'autoscaling')

    @autoscaling.setter
    def autoscaling(self, value: Optional[pulumi.Input[
        'NodePoolAutoscalingArgs']]):
        pulumi.set(self, 'autoscaling', value)

    @property
    @pulumi.getter
    def conditions(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[
        'StatusConditionArgs']]]]:
        """
        Which conditions caused the current node pool state.
        """
        return pulumi.get(self, 'conditions')

    @conditions.setter
    def conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input
        ['StatusConditionArgs']]]]):
        pulumi.set(self, 'conditions', value)

    @property
    @pulumi.getter
    def config(self) ->Optional[pulumi.Input['NodeConfigArgs']]:
        """
        The node configuration of the pool.
        """
        return pulumi.get(self, 'config')

    @config.setter
    def config(self, value: Optional[pulumi.Input['NodeConfigArgs']]):
        pulumi.set(self, 'config', value)

    @property
    @pulumi.getter
    def etag(self) ->Optional[pulumi.Input[str]]:
        """
        This checksum is computed by the server based on the value of node pool fields, and may be sent on update requests to ensure the client has an up-to-date value before proceeding.
        """
        return pulumi.get(self, 'etag')

    @etag.setter
    def etag(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'etag', value)

    @property
    @pulumi.getter(name='initialNodeCount')
    def initial_node_count(self) ->Optional[pulumi.Input[int]]:
        """
        The initial node count for the pool. You must ensure that your Compute Engine [resource quota](https://cloud.google.com/compute/quotas) is sufficient for this number of instances. You must also have available firewall and routes quota.
        """
        return pulumi.get(self, 'initial_node_count')

    @initial_node_count.setter
    def initial_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'initial_node_count', value)

    @property
    @pulumi.getter
    def locations(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The list of Google Compute Engine [zones](https://cloud.google.com/compute/docs/zones#available) in which the NodePool's nodes should be located. If this value is unspecified during node pool creation, the [Cluster.Locations](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1/projects.locations.clusters#Cluster.FIELDS.locations) value will be used, instead. Warning: changing node pool locations will result in nodes being added and/or removed.
        """
        return pulumi.get(self, 'locations')

    @locations.setter
    def locations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
        str]]]]):
        pulumi.set(self, 'locations', value)

    @property
    @pulumi.getter
    def management(self) ->Optional[pulumi.Input['NodeManagementArgs']]:
        """
        NodeManagement configuration for this NodePool.
        """
        return pulumi.get(self, 'management')

    @management.setter
    def management(self, value: Optional[pulumi.Input['NodeManagementArgs']]):
        pulumi.set(self, 'management', value)

    @property
    @pulumi.getter(name='maxPodsConstraint')
    def max_pods_constraint(self) ->Optional[pulumi.Input[
        'MaxPodsConstraintArgs']]:
        """
        The constraint on the maximum number of pods that can be run simultaneously on a node in the node pool.
        """
        return pulumi.get(self, 'max_pods_constraint')

    @max_pods_constraint.setter
    def max_pods_constraint(self, value: Optional[pulumi.Input[
        'MaxPodsConstraintArgs']]):
        pulumi.set(self, 'max_pods_constraint', value)

    @property
    @pulumi.getter
    def name(self) ->Optional[pulumi.Input[str]]:
        """
        The name of the node pool.
        """
        return pulumi.get(self, 'name')

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'name', value)

    @property
    @pulumi.getter(name='networkConfig')
    def network_config(self) ->Optional[pulumi.Input['NodeNetworkConfigArgs']]:
        """
        Networking configuration for this NodePool. If specified, it overrides the cluster-level defaults.
        """
        return pulumi.get(self, 'network_config')

    @network_config.setter
    def network_config(self, value: Optional[pulumi.Input[
        'NodeNetworkConfigArgs']]):
        pulumi.set(self, 'network_config', value)

    @property
    @pulumi.getter(name='placementPolicy')
    def placement_policy(self) ->Optional[pulumi.Input['PlacementPolicyArgs']]:
        """
        Specifies the node placement policy.
        """
        return pulumi.get(self, 'placement_policy')

    @placement_policy.setter
    def placement_policy(self, value: Optional[pulumi.Input[
        'PlacementPolicyArgs']]):
        pulumi.set(self, 'placement_policy', value)

    @property
    @pulumi.getter(name='upgradeSettings')
    def upgrade_settings(self) ->Optional[pulumi.Input['UpgradeSettingsArgs']]:
        """
        Upgrade settings control disruption and speed of the upgrade.
        """
        return pulumi.get(self, 'upgrade_settings')

    @upgrade_settings.setter
    def upgrade_settings(self, value: Optional[pulumi.Input[
        'UpgradeSettingsArgs']]):
        pulumi.set(self, 'upgrade_settings', value)

    @property
    @pulumi.getter
    def version(self) ->Optional[pulumi.Input[str]]:
        """
        The version of Kubernetes running on this NodePool's nodes. If unspecified, it defaults as described [here](https://cloud.google.com/kubernetes-engine/versioning#specifying_node_version).
        """
        return pulumi.get(self, 'version')

    @version.setter
    def version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'version', value)


@pulumi.input_type
class NodeTaintArgs:

    def __init__(__self__, *, effect: Optional[pulumi.Input[
        'NodeTaintEffect']]=None, key: Optional[pulumi.Input[str]]=None,
        value: Optional[pulumi.Input[str]]=None):
        """
        Kubernetes taint is composed of three fields: key, value, and effect. Effect can only be one of three types: NoSchedule, PreferNoSchedule or NoExecute. See [here](https://kubernetes.io/docs/concepts/configuration/taint-and-toleration) for more information, including usage and the valid values.
        :param pulumi.Input['NodeTaintEffect'] effect: Effect for taint.
        :param pulumi.Input[str] key: Key for taint.
        :param pulumi.Input[str] value: Value for taint.
        """
        if effect is not None:
            pulumi.set(__self__, 'effect', effect)
        if key is not None:
            pulumi.set(__self__, 'key', key)
        if value is not None:
            pulumi.set(__self__, 'value', value)

    @property
    @pulumi.getter
    def effect(self) ->Optional[pulumi.Input['NodeTaintEffect']]:
        """
        Effect for taint.
        """
        return pulumi.get(self, 'effect')

    @effect.setter
    def effect(self, value: Optional[pulumi.Input['NodeTaintEffect']]):
        pulumi.set(self, 'effect', value)

    @property
    @pulumi.getter
    def key(self) ->Optional[pulumi.Input[str]]:
        """
        Key for taint.
        """
        return pulumi.get(self, 'key')

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'key', value)

    @property
    @pulumi.getter
    def value(self) ->Optional[pulumi.Input[str]]:
        """
        Value for taint.
        """
        return pulumi.get(self, 'value')

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'value', value)


@pulumi.input_type
class NotificationConfigArgs:

    def __init__(__self__, *, pubsub: Optional[pulumi.Input['PubSubArgs']]=None
        ):
        """
        NotificationConfig is the configuration of notifications.
        :param pulumi.Input['PubSubArgs'] pubsub: Notification config for Pub/Sub.
        """
        if pubsub is not None:
            pulumi.set(__self__, 'pubsub', pubsub)

    @property
    @pulumi.getter
    def pubsub(self) ->Optional[pulumi.Input['PubSubArgs']]:
        """
        Notification config for Pub/Sub.
        """
        return pulumi.get(self, 'pubsub')

    @pubsub.setter
    def pubsub(self, value: Optional[pulumi.Input['PubSubArgs']]):
        pulumi.set(self, 'pubsub', value)


@pulumi.input_type
class PlacementPolicyArgs:

    def __init__(__self__, *, type: Optional[pulumi.Input[
        'PlacementPolicyType']]=None):
        """
        PlacementPolicy defines the placement policy used by the node pool.
        :param pulumi.Input['PlacementPolicyType'] type: The type of placement.
        """
        if type is not None:
            pulumi.set(__self__, 'type', type)

    @property
    @pulumi.getter
    def type(self) ->Optional[pulumi.Input['PlacementPolicyType']]:
        """
        The type of placement.
        """
        return pulumi.get(self, 'type')

    @type.setter
    def type(self, value: Optional[pulumi.Input['PlacementPolicyType']]):
        pulumi.set(self, 'type', value)


@pulumi.input_type
class PodCIDROverprovisionConfigArgs:

    def __init__(__self__, *, disable: Optional[pulumi.Input[bool]]=None):
        """
        [PRIVATE FIELD] Config for pod CIDR size overprovisioning.
        :param pulumi.Input[bool] disable: Whether Pod CIDR overprovisioning is disabled. Note: Pod CIDR overprovisioning is enabled by default.
        """
        if disable is not None:
            pulumi.set(__self__, 'disable', disable)

    @property
    @pulumi.getter
    def disable(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Pod CIDR overprovisioning is disabled. Note: Pod CIDR overprovisioning is enabled by default.
        """
        return pulumi.get(self, 'disable')

    @disable.setter
    def disable(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'disable', value)


@pulumi.input_type
class PodSecurityPolicyConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for the PodSecurityPolicy feature.
        :param pulumi.Input[bool] enabled: Enable the PodSecurityPolicy controller for this cluster. If enabled, pods must be valid under a PodSecurityPolicy to be created.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Enable the PodSecurityPolicy controller for this cluster. If enabled, pods must be valid under a PodSecurityPolicy to be created.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class PrivateClusterConfigArgs:

    def __init__(__self__, *, enable_private_endpoint: Optional[pulumi.
        Input[bool]]=None, enable_private_nodes: Optional[pulumi.Input[bool
        ]]=None, master_global_access_config: Optional[pulumi.Input[
        'PrivateClusterMasterGlobalAccessConfigArgs']]=None,
        master_ipv4_cidr_block: Optional[pulumi.Input[str]]=None,
        private_endpoint_subnetwork: Optional[pulumi.Input[str]]=None):
        """
        Configuration options for private clusters.
        :param pulumi.Input[bool] enable_private_endpoint: Whether the master's internal IP address is used as the cluster endpoint.
        :param pulumi.Input[bool] enable_private_nodes: Whether nodes have internal IP addresses only. If enabled, all nodes are given only RFC 1918 private addresses and communicate with the master via private networking.
        :param pulumi.Input['PrivateClusterMasterGlobalAccessConfigArgs'] master_global_access_config: Controls master global access settings.
        :param pulumi.Input[str] master_ipv4_cidr_block: The IP range in CIDR notation to use for the hosted master network. This range will be used for assigning internal IP addresses to the master or set of masters, as well as the ILB VIP. This range must not overlap with any other ranges in use within the cluster's network.
        :param pulumi.Input[str] private_endpoint_subnetwork: Subnet to provision the master's private endpoint during cluster creation. Specified in projects/*/regions/*/subnetworks/* format.
        """
        if enable_private_endpoint is not None:
            pulumi.set(__self__, 'enable_private_endpoint',
                enable_private_endpoint)
        if enable_private_nodes is not None:
            pulumi.set(__self__, 'enable_private_nodes', enable_private_nodes)
        if master_global_access_config is not None:
            pulumi.set(__self__, 'master_global_access_config',
                master_global_access_config)
        if master_ipv4_cidr_block is not None:
            pulumi.set(__self__, 'master_ipv4_cidr_block',
                master_ipv4_cidr_block)
        if private_endpoint_subnetwork is not None:
            pulumi.set(__self__, 'private_endpoint_subnetwork',
                private_endpoint_subnetwork)

    @property
    @pulumi.getter(name='enablePrivateEndpoint')
    def enable_private_endpoint(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the master's internal IP address is used as the cluster endpoint.
        """
        return pulumi.get(self, 'enable_private_endpoint')

    @enable_private_endpoint.setter
    def enable_private_endpoint(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_private_endpoint', value)

    @property
    @pulumi.getter(name='enablePrivateNodes')
    def enable_private_nodes(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether nodes have internal IP addresses only. If enabled, all nodes are given only RFC 1918 private addresses and communicate with the master via private networking.
        """
        return pulumi.get(self, 'enable_private_nodes')

    @enable_private_nodes.setter
    def enable_private_nodes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_private_nodes', value)

    @property
    @pulumi.getter(name='masterGlobalAccessConfig')
    def master_global_access_config(self) ->Optional[pulumi.Input[
        'PrivateClusterMasterGlobalAccessConfigArgs']]:
        """
        Controls master global access settings.
        """
        return pulumi.get(self, 'master_global_access_config')

    @master_global_access_config.setter
    def master_global_access_config(self, value: Optional[pulumi.Input[
        'PrivateClusterMasterGlobalAccessConfigArgs']]):
        pulumi.set(self, 'master_global_access_config', value)

    @property
    @pulumi.getter(name='masterIpv4CidrBlock')
    def master_ipv4_cidr_block(self) ->Optional[pulumi.Input[str]]:
        """
        The IP range in CIDR notation to use for the hosted master network. This range will be used for assigning internal IP addresses to the master or set of masters, as well as the ILB VIP. This range must not overlap with any other ranges in use within the cluster's network.
        """
        return pulumi.get(self, 'master_ipv4_cidr_block')

    @master_ipv4_cidr_block.setter
    def master_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'master_ipv4_cidr_block', value)

    @property
    @pulumi.getter(name='privateEndpointSubnetwork')
    def private_endpoint_subnetwork(self) ->Optional[pulumi.Input[str]]:
        """
        Subnet to provision the master's private endpoint during cluster creation. Specified in projects/*/regions/*/subnetworks/* format.
        """
        return pulumi.get(self, 'private_endpoint_subnetwork')

    @private_endpoint_subnetwork.setter
    def private_endpoint_subnetwork(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'private_endpoint_subnetwork', value)


@pulumi.input_type
class PrivateClusterMasterGlobalAccessConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for controlling master global access settings.
        :param pulumi.Input[bool] enabled: Whenever master is accessible globally or not.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whenever master is accessible globally or not.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class ProtectConfigArgs:

    def __init__(__self__, *, workload_config: Optional[pulumi.Input[
        'WorkloadConfigArgs']]=None, workload_vulnerability_mode: Optional[
        pulumi.Input['ProtectConfigWorkloadVulnerabilityMode']]=None):
        """
        ProtectConfig defines the flags needed to enable/disable features for the Protect API.
        :param pulumi.Input['WorkloadConfigArgs'] workload_config: WorkloadConfig defines which actions are enabled for a cluster's workload configurations.
        :param pulumi.Input['ProtectConfigWorkloadVulnerabilityMode'] workload_vulnerability_mode: Sets which mode to use for Protect workload vulnerability scanning feature.
        """
        if workload_config is not None:
            pulumi.set(__self__, 'workload_config', workload_config)
        if workload_vulnerability_mode is not None:
            pulumi.set(__self__, 'workload_vulnerability_mode',
                workload_vulnerability_mode)

    @property
    @pulumi.getter(name='workloadConfig')
    def workload_config(self) ->Optional[pulumi.Input['WorkloadConfigArgs']]:
        """
        WorkloadConfig defines which actions are enabled for a cluster's workload configurations.
        """
        return pulumi.get(self, 'workload_config')

    @workload_config.setter
    def workload_config(self, value: Optional[pulumi.Input[
        'WorkloadConfigArgs']]):
        pulumi.set(self, 'workload_config', value)

    @property
    @pulumi.getter(name='workloadVulnerabilityMode')
    def workload_vulnerability_mode(self) ->Optional[pulumi.Input[
        'ProtectConfigWorkloadVulnerabilityMode']]:
        """
        Sets which mode to use for Protect workload vulnerability scanning feature.
        """
        return pulumi.get(self, 'workload_vulnerability_mode')

    @workload_vulnerability_mode.setter
    def workload_vulnerability_mode(self, value: Optional[pulumi.Input[
        'ProtectConfigWorkloadVulnerabilityMode']]):
        pulumi.set(self, 'workload_vulnerability_mode', value)


@pulumi.input_type
class PubSubArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None,
        filter: Optional[pulumi.Input['FilterArgs']]=None, topic: Optional[
        pulumi.Input[str]]=None):
        """
        Pub/Sub specific notification config.
        :param pulumi.Input[bool] enabled: Enable notifications for Pub/Sub.
        :param pulumi.Input['FilterArgs'] filter: Allows filtering to one or more specific event types. If no filter is specified, or if a filter is specified with no event types, all event types will be sent
        :param pulumi.Input[str] topic: The desired Pub/Sub topic to which notifications will be sent by GKE. Format is `projects/{project}/topics/{topic}`.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)
        if filter is not None:
            pulumi.set(__self__, 'filter', filter)
        if topic is not None:
            pulumi.set(__self__, 'topic', topic)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Enable notifications for Pub/Sub.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)

    @property
    @pulumi.getter
    def filter(self) ->Optional[pulumi.Input['FilterArgs']]:
        """
        Allows filtering to one or more specific event types. If no filter is specified, or if a filter is specified with no event types, all event types will be sent
        """
        return pulumi.get(self, 'filter')

    @filter.setter
    def filter(self, value: Optional[pulumi.Input['FilterArgs']]):
        pulumi.set(self, 'filter', value)

    @property
    @pulumi.getter
    def topic(self) ->Optional[pulumi.Input[str]]:
        """
        The desired Pub/Sub topic to which notifications will be sent by GKE. Format is `projects/{project}/topics/{topic}`.
        """
        return pulumi.get(self, 'topic')

    @topic.setter
    def topic(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'topic', value)


@pulumi.input_type
class RecurringTimeWindowArgs:

    def __init__(__self__, *, recurrence: Optional[pulumi.Input[str]]=None,
        window: Optional[pulumi.Input['TimeWindowArgs']]=None):
        """
        Represents an arbitrary window of time that recurs.
        :param pulumi.Input[str] recurrence: An RRULE (https://tools.ietf.org/html/rfc5545#section-3.8.5.3) for how this window reccurs. They go on for the span of time between the start and end time. For example, to have something repeat every weekday, you'd use: `FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR` To repeat some window daily (equivalent to the DailyMaintenanceWindow): `FREQ=DAILY` For the first weekend of every month: `FREQ=MONTHLY;BYSETPOS=1;BYDAY=SA,SU` This specifies how frequently the window starts. Eg, if you wanted to have a 9-5 UTC-4 window every weekday, you'd use something like: ``` start time = 2019-01-01T09:00:00-0400 end time = 2019-01-01T17:00:00-0400 recurrence = FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR ``` Windows can span multiple days. Eg, to make the window encompass every weekend from midnight Saturday till the last minute of Sunday UTC: ``` start time = 2019-01-05T00:00:00Z end time = 2019-01-07T23:59:00Z recurrence = FREQ=WEEKLY;BYDAY=SA ``` Note the start and end time's specific dates are largely arbitrary except to specify duration of the window and when it first starts. The FREQ values of HOURLY, MINUTELY, and SECONDLY are not supported.
        :param pulumi.Input['TimeWindowArgs'] window: The window of the first recurrence.
        """
        if recurrence is not None:
            pulumi.set(__self__, 'recurrence', recurrence)
        if window is not None:
            pulumi.set(__self__, 'window', window)

    @property
    @pulumi.getter
    def recurrence(self) ->Optional[pulumi.Input[str]]:
        """
        An RRULE (https://tools.ietf.org/html/rfc5545#section-3.8.5.3) for how this window reccurs. They go on for the span of time between the start and end time. For example, to have something repeat every weekday, you'd use: `FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR` To repeat some window daily (equivalent to the DailyMaintenanceWindow): `FREQ=DAILY` For the first weekend of every month: `FREQ=MONTHLY;BYSETPOS=1;BYDAY=SA,SU` This specifies how frequently the window starts. Eg, if you wanted to have a 9-5 UTC-4 window every weekday, you'd use something like: ``` start time = 2019-01-01T09:00:00-0400 end time = 2019-01-01T17:00:00-0400 recurrence = FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR ``` Windows can span multiple days. Eg, to make the window encompass every weekend from midnight Saturday till the last minute of Sunday UTC: ``` start time = 2019-01-05T00:00:00Z end time = 2019-01-07T23:59:00Z recurrence = FREQ=WEEKLY;BYDAY=SA ``` Note the start and end time's specific dates are largely arbitrary except to specify duration of the window and when it first starts. The FREQ values of HOURLY, MINUTELY, and SECONDLY are not supported.
        """
        return pulumi.get(self, 'recurrence')

    @recurrence.setter
    def recurrence(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'recurrence', value)

    @property
    @pulumi.getter
    def window(self) ->Optional[pulumi.Input['TimeWindowArgs']]:
        """
        The window of the first recurrence.
        """
        return pulumi.get(self, 'window')

    @window.setter
    def window(self, value: Optional[pulumi.Input['TimeWindowArgs']]):
        pulumi.set(self, 'window', value)


@pulumi.input_type
class ReleaseChannelArgs:

    def __init__(__self__, *, channel: Optional[pulumi.Input[
        'ReleaseChannelChannel']]=None):
        """
        ReleaseChannel indicates which release channel a cluster is subscribed to. Release channels are arranged in order of risk. When a cluster is subscribed to a release channel, Google maintains both the master version and the node version. Node auto-upgrade defaults to true and cannot be disabled.
        :param pulumi.Input['ReleaseChannelChannel'] channel: channel specifies which release channel the cluster is subscribed to.
        """
        if channel is not None:
            pulumi.set(__self__, 'channel', channel)

    @property
    @pulumi.getter
    def channel(self) ->Optional[pulumi.Input['ReleaseChannelChannel']]:
        """
        channel specifies which release channel the cluster is subscribed to.
        """
        return pulumi.get(self, 'channel')

    @channel.setter
    def channel(self, value: Optional[pulumi.Input['ReleaseChannelChannel']]):
        pulumi.set(self, 'channel', value)


@pulumi.input_type
class ReservationAffinityArgs:

    def __init__(__self__, *, consume_reservation_type: Optional[pulumi.
        Input['ReservationAffinityConsumeReservationType']]=None, key:
        Optional[pulumi.Input[str]]=None, values: Optional[pulumi.Input[
        Sequence[pulumi.Input[str]]]]=None):
        """
        [ReservationAffinity](https://cloud.google.com/compute/docs/instances/reserving-zonal-resources) is the configuration of desired reservation which instances could take capacity from.
        :param pulumi.Input['ReservationAffinityConsumeReservationType'] consume_reservation_type: Corresponds to the type of reservation consumption.
        :param pulumi.Input[str] key: Corresponds to the label key of a reservation resource. To target a SPECIFIC_RESERVATION by name, specify "compute.googleapis.com/reservation-name" as the key and specify the name of your reservation as its value.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: Corresponds to the label value(s) of reservation resource(s).
        """
        if consume_reservation_type is not None:
            pulumi.set(__self__, 'consume_reservation_type',
                consume_reservation_type)
        if key is not None:
            pulumi.set(__self__, 'key', key)
        if values is not None:
            pulumi.set(__self__, 'values', values)

    @property
    @pulumi.getter(name='consumeReservationType')
    def consume_reservation_type(self) ->Optional[pulumi.Input[
        'ReservationAffinityConsumeReservationType']]:
        """
        Corresponds to the type of reservation consumption.
        """
        return pulumi.get(self, 'consume_reservation_type')

    @consume_reservation_type.setter
    def consume_reservation_type(self, value: Optional[pulumi.Input[
        'ReservationAffinityConsumeReservationType']]):
        pulumi.set(self, 'consume_reservation_type', value)

    @property
    @pulumi.getter
    def key(self) ->Optional[pulumi.Input[str]]:
        """
        Corresponds to the label key of a reservation resource. To target a SPECIFIC_RESERVATION by name, specify "compute.googleapis.com/reservation-name" as the key and specify the name of your reservation as its value.
        """
        return pulumi.get(self, 'key')

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'key', value)

    @property
    @pulumi.getter
    def values(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Corresponds to the label value(s) of reservation resource(s).
        """
        return pulumi.get(self, 'values')

    @values.setter
    def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]
        ):
        pulumi.set(self, 'values', value)


@pulumi.input_type
class ResourceLimitArgs:

    def __init__(__self__, *, maximum: Optional[pulumi.Input[str]]=None,
        minimum: Optional[pulumi.Input[str]]=None, resource_type: Optional[
        pulumi.Input[str]]=None):
        """
        Contains information about amount of some resource in the cluster. For memory, value should be in GB.
        :param pulumi.Input[str] maximum: Maximum amount of the resource in the cluster.
        :param pulumi.Input[str] minimum: Minimum amount of the resource in the cluster.
        :param pulumi.Input[str] resource_type: Resource name "cpu", "memory" or gpu-specific string.
        """
        if maximum is not None:
            pulumi.set(__self__, 'maximum', maximum)
        if minimum is not None:
            pulumi.set(__self__, 'minimum', minimum)
        if resource_type is not None:
            pulumi.set(__self__, 'resource_type', resource_type)

    @property
    @pulumi.getter
    def maximum(self) ->Optional[pulumi.Input[str]]:
        """
        Maximum amount of the resource in the cluster.
        """
        return pulumi.get(self, 'maximum')

    @maximum.setter
    def maximum(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'maximum', value)

    @property
    @pulumi.getter
    def minimum(self) ->Optional[pulumi.Input[str]]:
        """
        Minimum amount of the resource in the cluster.
        """
        return pulumi.get(self, 'minimum')

    @minimum.setter
    def minimum(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'minimum', value)

    @property
    @pulumi.getter(name='resourceType')
    def resource_type(self) ->Optional[pulumi.Input[str]]:
        """
        Resource name "cpu", "memory" or gpu-specific string.
        """
        return pulumi.get(self, 'resource_type')

    @resource_type.setter
    def resource_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'resource_type', value)


@pulumi.input_type
class ResourceUsageExportConfigArgs:

    def __init__(__self__, *, bigquery_destination: Optional[pulumi.Input[
        'BigQueryDestinationArgs']]=None, consumption_metering_config:
        Optional[pulumi.Input['ConsumptionMeteringConfigArgs']]=None,
        enable_network_egress_metering: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for exporting cluster resource usages.
        :param pulumi.Input['BigQueryDestinationArgs'] bigquery_destination: Configuration to use BigQuery as usage export destination.
        :param pulumi.Input['ConsumptionMeteringConfigArgs'] consumption_metering_config: Configuration to enable resource consumption metering.
        :param pulumi.Input[bool] enable_network_egress_metering: Whether to enable network egress metering for this cluster. If enabled, a daemonset will be created in the cluster to meter network egress traffic.
        """
        if bigquery_destination is not None:
            pulumi.set(__self__, 'bigquery_destination', bigquery_destination)
        if consumption_metering_config is not None:
            pulumi.set(__self__, 'consumption_metering_config',
                consumption_metering_config)
        if enable_network_egress_metering is not None:
            pulumi.set(__self__, 'enable_network_egress_metering',
                enable_network_egress_metering)

    @property
    @pulumi.getter(name='bigqueryDestination')
    def bigquery_destination(self) ->Optional[pulumi.Input[
        'BigQueryDestinationArgs']]:
        """
        Configuration to use BigQuery as usage export destination.
        """
        return pulumi.get(self, 'bigquery_destination')

    @bigquery_destination.setter
    def bigquery_destination(self, value: Optional[pulumi.Input[
        'BigQueryDestinationArgs']]):
        pulumi.set(self, 'bigquery_destination', value)

    @property
    @pulumi.getter(name='consumptionMeteringConfig')
    def consumption_metering_config(self) ->Optional[pulumi.Input[
        'ConsumptionMeteringConfigArgs']]:
        """
        Configuration to enable resource consumption metering.
        """
        return pulumi.get(self, 'consumption_metering_config')

    @consumption_metering_config.setter
    def consumption_metering_config(self, value: Optional[pulumi.Input[
        'ConsumptionMeteringConfigArgs']]):
        pulumi.set(self, 'consumption_metering_config', value)

    @property
    @pulumi.getter(name='enableNetworkEgressMetering')
    def enable_network_egress_metering(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether to enable network egress metering for this cluster. If enabled, a daemonset will be created in the cluster to meter network egress traffic.
        """
        return pulumi.get(self, 'enable_network_egress_metering')

    @enable_network_egress_metering.setter
    def enable_network_egress_metering(self, value: Optional[pulumi.Input[
        bool]]):
        pulumi.set(self, 'enable_network_egress_metering', value)


@pulumi.input_type
class SandboxConfigArgs:

    def __init__(__self__, *, sandbox_type: Optional[pulumi.Input[str]]=
        None, type: Optional[pulumi.Input['SandboxConfigType']]=None):
        """
        SandboxConfig contains configurations of the sandbox to use for the node.
        :param pulumi.Input[str] sandbox_type: Type of the sandbox to use for the node (e.g. 'gvisor')
        :param pulumi.Input['SandboxConfigType'] type: Type of the sandbox to use for the node.
        """
        if sandbox_type is not None:
            pulumi.set(__self__, 'sandbox_type', sandbox_type)
        if type is not None:
            pulumi.set(__self__, 'type', type)

    @property
    @pulumi.getter(name='sandboxType')
    def sandbox_type(self) ->Optional[pulumi.Input[str]]:
        """
        Type of the sandbox to use for the node (e.g. 'gvisor')
        """
        return pulumi.get(self, 'sandbox_type')

    @sandbox_type.setter
    def sandbox_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'sandbox_type', value)

    @property
    @pulumi.getter
    def type(self) ->Optional[pulumi.Input['SandboxConfigType']]:
        """
        Type of the sandbox to use for the node.
        """
        return pulumi.get(self, 'type')

    @type.setter
    def type(self, value: Optional[pulumi.Input['SandboxConfigType']]):
        pulumi.set(self, 'type', value)


@pulumi.input_type
class ServiceExternalIPsConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Config to block services with externalIPs field.
        :param pulumi.Input[bool] enabled: Whether Services with ExternalIPs field are allowed or not.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Services with ExternalIPs field are allowed or not.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class ShieldedInstanceConfigArgs:

    def __init__(__self__, *, enable_integrity_monitoring: Optional[pulumi.
        Input[bool]]=None, enable_secure_boot: Optional[pulumi.Input[bool]]
        =None):
        """
        A set of Shielded Instance options.
        :param pulumi.Input[bool] enable_integrity_monitoring: Defines whether the instance has integrity monitoring enabled. Enables monitoring and attestation of the boot integrity of the instance. The attestation is performed against the integrity policy baseline. This baseline is initially derived from the implicitly trusted boot image when the instance is created.
        :param pulumi.Input[bool] enable_secure_boot: Defines whether the instance has Secure Boot enabled. Secure Boot helps ensure that the system only runs authentic software by verifying the digital signature of all boot components, and halting the boot process if signature verification fails.
        """
        if enable_integrity_monitoring is not None:
            pulumi.set(__self__, 'enable_integrity_monitoring',
                enable_integrity_monitoring)
        if enable_secure_boot is not None:
            pulumi.set(__self__, 'enable_secure_boot', enable_secure_boot)

    @property
    @pulumi.getter(name='enableIntegrityMonitoring')
    def enable_integrity_monitoring(self) ->Optional[pulumi.Input[bool]]:
        """
        Defines whether the instance has integrity monitoring enabled. Enables monitoring and attestation of the boot integrity of the instance. The attestation is performed against the integrity policy baseline. This baseline is initially derived from the implicitly trusted boot image when the instance is created.
        """
        return pulumi.get(self, 'enable_integrity_monitoring')

    @enable_integrity_monitoring.setter
    def enable_integrity_monitoring(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_integrity_monitoring', value)

    @property
    @pulumi.getter(name='enableSecureBoot')
    def enable_secure_boot(self) ->Optional[pulumi.Input[bool]]:
        """
        Defines whether the instance has Secure Boot enabled. Secure Boot helps ensure that the system only runs authentic software by verifying the digital signature of all boot components, and halting the boot process if signature verification fails.
        """
        return pulumi.get(self, 'enable_secure_boot')

    @enable_secure_boot.setter
    def enable_secure_boot(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_secure_boot', value)


@pulumi.input_type
class ShieldedNodesArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration of Shielded Nodes feature.
        :param pulumi.Input[bool] enabled: Whether Shielded Nodes features are enabled on all nodes in this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Shielded Nodes features are enabled on all nodes in this cluster.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class StandardRolloutPolicyArgs:

    def __init__(__self__, *, batch_node_count: Optional[pulumi.Input[int]]
        =None, batch_percentage: Optional[pulumi.Input[float]]=None,
        batch_soak_duration: Optional[pulumi.Input[str]]=None):
        """
        Standard rollout policy is the default policy for blue-green.
        :param pulumi.Input[int] batch_node_count: Number of blue nodes to drain in a batch.
        :param pulumi.Input[float] batch_percentage: Percentage of the blue pool nodes to drain in a batch. The range of this field should be (0.0, 1.0].
        :param pulumi.Input[str] batch_soak_duration: Soak time after each batch gets drained. Default to zero.
        """
        if batch_node_count is not None:
            pulumi.set(__self__, 'batch_node_count', batch_node_count)
        if batch_percentage is not None:
            pulumi.set(__self__, 'batch_percentage', batch_percentage)
        if batch_soak_duration is not None:
            pulumi.set(__self__, 'batch_soak_duration', batch_soak_duration)

    @property
    @pulumi.getter(name='batchNodeCount')
    def batch_node_count(self) ->Optional[pulumi.Input[int]]:
        """
        Number of blue nodes to drain in a batch.
        """
        return pulumi.get(self, 'batch_node_count')

    @batch_node_count.setter
    def batch_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'batch_node_count', value)

    @property
    @pulumi.getter(name='batchPercentage')
    def batch_percentage(self) ->Optional[pulumi.Input[float]]:
        """
        Percentage of the blue pool nodes to drain in a batch. The range of this field should be (0.0, 1.0].
        """
        return pulumi.get(self, 'batch_percentage')

    @batch_percentage.setter
    def batch_percentage(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, 'batch_percentage', value)

    @property
    @pulumi.getter(name='batchSoakDuration')
    def batch_soak_duration(self) ->Optional[pulumi.Input[str]]:
        """
        Soak time after each batch gets drained. Default to zero.
        """
        return pulumi.get(self, 'batch_soak_duration')

    @batch_soak_duration.setter
    def batch_soak_duration(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'batch_soak_duration', value)


@pulumi.input_type
class StatusConditionArgs:

    def __init__(__self__, *, canonical_code: Optional[pulumi.Input[
        'StatusConditionCanonicalCode']]=None, code: Optional[pulumi.Input[
        'StatusConditionCode']]=None, message: Optional[pulumi.Input[str]]=None
        ):
        """
        StatusCondition describes why a cluster or a node pool has a certain status (e.g., ERROR or DEGRADED).
        :param pulumi.Input['StatusConditionCanonicalCode'] canonical_code: Canonical code of the condition.
        :param pulumi.Input['StatusConditionCode'] code: Machine-friendly representation of the condition Deprecated. Use canonical_code instead.
        :param pulumi.Input[str] message: Human-friendly representation of the condition
        """
        if canonical_code is not None:
            pulumi.set(__self__, 'canonical_code', canonical_code)
        if code is not None:
            warnings.warn(
                'Machine-friendly representation of the condition Deprecated. Use canonical_code instead.'
                , DeprecationWarning)
            pulumi.log.warn(
                'code is deprecated: Machine-friendly representation of the condition Deprecated. Use canonical_code instead.'
                )
        if code is not None:
            pulumi.set(__self__, 'code', code)
        if message is not None:
            pulumi.set(__self__, 'message', message)

    @property
    @pulumi.getter(name='canonicalCode')
    def canonical_code(self) ->Optional[pulumi.Input[
        'StatusConditionCanonicalCode']]:
        """
        Canonical code of the condition.
        """
        return pulumi.get(self, 'canonical_code')

    @canonical_code.setter
    def canonical_code(self, value: Optional[pulumi.Input[
        'StatusConditionCanonicalCode']]):
        pulumi.set(self, 'canonical_code', value)

    @property
    @pulumi.getter
    def code(self) ->Optional[pulumi.Input['StatusConditionCode']]:
        """
        Machine-friendly representation of the condition Deprecated. Use canonical_code instead.
        """
        warnings.warn(
            'Machine-friendly representation of the condition Deprecated. Use canonical_code instead.'
            , DeprecationWarning)
        pulumi.log.warn(
            'code is deprecated: Machine-friendly representation of the condition Deprecated. Use canonical_code instead.'
            )
        return pulumi.get(self, 'code')

    @code.setter
    def code(self, value: Optional[pulumi.Input['StatusConditionCode']]):
        pulumi.set(self, 'code', value)

    @property
    @pulumi.getter
    def message(self) ->Optional[pulumi.Input[str]]:
        """
        Human-friendly representation of the condition
        """
        return pulumi.get(self, 'message')

    @message.setter
    def message(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'message', value)


@pulumi.input_type
class TimeWindowArgs:

    def __init__(__self__, *, end_time: Optional[pulumi.Input[str]]=None,
        maintenance_exclusion_options: Optional[pulumi.Input[
        'MaintenanceExclusionOptionsArgs']]=None, start_time: Optional[
        pulumi.Input[str]]=None):
        """
        Represents an arbitrary window of time.
        :param pulumi.Input[str] end_time: The time that the window ends. The end time should take place after the start time.
        :param pulumi.Input['MaintenanceExclusionOptionsArgs'] maintenance_exclusion_options: MaintenanceExclusionOptions provides maintenance exclusion related options.
        :param pulumi.Input[str] start_time: The time that the window first starts.
        """
        if end_time is not None:
            pulumi.set(__self__, 'end_time', end_time)
        if maintenance_exclusion_options is not None:
            pulumi.set(__self__, 'maintenance_exclusion_options',
                maintenance_exclusion_options)
        if start_time is not None:
            pulumi.set(__self__, 'start_time', start_time)

    @property
    @pulumi.getter(name='endTime')
    def end_time(self) ->Optional[pulumi.Input[str]]:
        """
        The time that the window ends. The end time should take place after the start time.
        """
        return pulumi.get(self, 'end_time')

    @end_time.setter
    def end_time(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'end_time', value)

    @property
    @pulumi.getter(name='maintenanceExclusionOptions')
    def maintenance_exclusion_options(self) ->Optional[pulumi.Input[
        'MaintenanceExclusionOptionsArgs']]:
        """
        MaintenanceExclusionOptions provides maintenance exclusion related options.
        """
        return pulumi.get(self, 'maintenance_exclusion_options')

    @maintenance_exclusion_options.setter
    def maintenance_exclusion_options(self, value: Optional[pulumi.Input[
        'MaintenanceExclusionOptionsArgs']]):
        pulumi.set(self, 'maintenance_exclusion_options', value)

    @property
    @pulumi.getter(name='startTime')
    def start_time(self) ->Optional[pulumi.Input[str]]:
        """
        The time that the window first starts.
        """
        return pulumi.get(self, 'start_time')

    @start_time.setter
    def start_time(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'start_time', value)


@pulumi.input_type
class TpuConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None,
        ipv4_cidr_block: Optional[pulumi.Input[str]]=None,
        use_service_networking: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for Cloud TPU.
        :param pulumi.Input[bool] enabled: Whether Cloud TPU integration is enabled or not.
        :param pulumi.Input[str] ipv4_cidr_block: IPv4 CIDR block reserved for Cloud TPU in the VPC.
        :param pulumi.Input[bool] use_service_networking: Whether to use service networking for Cloud TPU or not.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)
        if ipv4_cidr_block is not None:
            pulumi.set(__self__, 'ipv4_cidr_block', ipv4_cidr_block)
        if use_service_networking is not None:
            pulumi.set(__self__, 'use_service_networking',
                use_service_networking)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Cloud TPU integration is enabled or not.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)

    @property
    @pulumi.getter(name='ipv4CidrBlock')
    def ipv4_cidr_block(self) ->Optional[pulumi.Input[str]]:
        """
        IPv4 CIDR block reserved for Cloud TPU in the VPC.
        """
        return pulumi.get(self, 'ipv4_cidr_block')

    @ipv4_cidr_block.setter
    def ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'ipv4_cidr_block', value)

    @property
    @pulumi.getter(name='useServiceNetworking')
    def use_service_networking(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether to use service networking for Cloud TPU or not.
        """
        return pulumi.get(self, 'use_service_networking')

    @use_service_networking.setter
    def use_service_networking(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'use_service_networking', value)


@pulumi.input_type
class UpgradeSettingsArgs:

    def __init__(__self__, *, blue_green_settings: Optional[pulumi.Input[
        'BlueGreenSettingsArgs']]=None, max_surge: Optional[pulumi.Input[
        int]]=None, max_unavailable: Optional[pulumi.Input[int]]=None,
        strategy: Optional[pulumi.Input['UpgradeSettingsStrategy']]=None):
        """
        These upgrade settings configure the upgrade strategy for the node pool. Use strategy to switch between the strategies applied to the node pool. If the strategy is SURGE, use max_surge and max_unavailable to control the level of parallelism and the level of disruption caused by upgrade. 1. maxSurge controls the number of additional nodes that can be added to the node pool temporarily for the time of the upgrade to increase the number of available nodes. 2. maxUnavailable controls the number of nodes that can be simultaneously unavailable. 3. (maxUnavailable + maxSurge) determines the level of parallelism (how many nodes are being upgraded at the same time). If the strategy is BLUE_GREEN, use blue_green_settings to configure the blue-green upgrade related settings. 1. standard_rollout_policy is the default policy. The policy is used to control the way blue pool gets drained. The draining is executed in the batch mode. The batch size could be specified as either percentage of the node pool size or the number of nodes. batch_soak_duration is the soak time after each batch gets drained. 2. node_pool_soak_duration is the soak time after all blue nodes are drained. After this period, the blue pool nodes will be deleted.
        :param pulumi.Input['BlueGreenSettingsArgs'] blue_green_settings: Settings for blue-green upgrade strategy.
        :param pulumi.Input[int] max_surge: The maximum number of nodes that can be created beyond the current size of the node pool during the upgrade process.
        :param pulumi.Input[int] max_unavailable: The maximum number of nodes that can be simultaneously unavailable during the upgrade process. A node is considered available if its status is Ready.
        :param pulumi.Input['UpgradeSettingsStrategy'] strategy: Update strategy of the node pool.
        """
        if blue_green_settings is not None:
            pulumi.set(__self__, 'blue_green_settings', blue_green_settings)
        if max_surge is not None:
            pulumi.set(__self__, 'max_surge', max_surge)
        if max_unavailable is not None:
            pulumi.set(__self__, 'max_unavailable', max_unavailable)
        if strategy is not None:
            pulumi.set(__self__, 'strategy', strategy)

    @property
    @pulumi.getter(name='blueGreenSettings')
    def blue_green_settings(self) ->Optional[pulumi.Input[
        'BlueGreenSettingsArgs']]:
        """
        Settings for blue-green upgrade strategy.
        """
        return pulumi.get(self, 'blue_green_settings')

    @blue_green_settings.setter
    def blue_green_settings(self, value: Optional[pulumi.Input[
        'BlueGreenSettingsArgs']]):
        pulumi.set(self, 'blue_green_settings', value)

    @property
    @pulumi.getter(name='maxSurge')
    def max_surge(self) ->Optional[pulumi.Input[int]]:
        """
        The maximum number of nodes that can be created beyond the current size of the node pool during the upgrade process.
        """
        return pulumi.get(self, 'max_surge')

    @max_surge.setter
    def max_surge(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'max_surge', value)

    @property
    @pulumi.getter(name='maxUnavailable')
    def max_unavailable(self) ->Optional[pulumi.Input[int]]:
        """
        The maximum number of nodes that can be simultaneously unavailable during the upgrade process. A node is considered available if its status is Ready.
        """
        return pulumi.get(self, 'max_unavailable')

    @max_unavailable.setter
    def max_unavailable(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'max_unavailable', value)

    @property
    @pulumi.getter
    def strategy(self) ->Optional[pulumi.Input['UpgradeSettingsStrategy']]:
        """
        Update strategy of the node pool.
        """
        return pulumi.get(self, 'strategy')

    @strategy.setter
    def strategy(self, value: Optional[pulumi.Input['UpgradeSettingsStrategy']]
        ):
        pulumi.set(self, 'strategy', value)


@pulumi.input_type
class VerticalPodAutoscalingArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        VerticalPodAutoscaling contains global, per-cluster information required by Vertical Pod Autoscaler to automatically adjust the resources of pods controlled by it.
        :param pulumi.Input[bool] enabled: Enables vertical pod autoscaling.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Enables vertical pod autoscaling.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class VirtualNICArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration of gVNIC feature.
        :param pulumi.Input[bool] enabled: Whether gVNIC features are enabled in the node pool.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether gVNIC features are enabled in the node pool.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class WindowsNodeConfigArgs:

    def __init__(__self__, *, os_version: Optional[pulumi.Input[
        'WindowsNodeConfigOsVersion']]=None):
        """
        Parameters that can be configured on Windows nodes. Windows Node Config that define the parameters that will be used to configure the Windows node pool settings
        :param pulumi.Input['WindowsNodeConfigOsVersion'] os_version: OSVersion specifies the Windows node config to be used on the node
        """
        if os_version is not None:
            pulumi.set(__self__, 'os_version', os_version)

    @property
    @pulumi.getter(name='osVersion')
    def os_version(self) ->Optional[pulumi.Input['WindowsNodeConfigOsVersion']
        ]:
        """
        OSVersion specifies the Windows node config to be used on the node
        """
        return pulumi.get(self, 'os_version')

    @os_version.setter
    def os_version(self, value: Optional[pulumi.Input[
        'WindowsNodeConfigOsVersion']]):
        pulumi.set(self, 'os_version', value)


@pulumi.input_type
class WorkloadALTSConfigArgs:

    def __init__(__self__, *, enable_alts: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for direct-path (via ALTS) with workload identity.
        :param pulumi.Input[bool] enable_alts: enable_alts controls whether the alts handshaker should be enabled or not for direct-path. Requires Workload Identity (workload_pool must be non-empty).
        """
        if enable_alts is not None:
            pulumi.set(__self__, 'enable_alts', enable_alts)

    @property
    @pulumi.getter(name='enableAlts')
    def enable_alts(self) ->Optional[pulumi.Input[bool]]:
        """
        enable_alts controls whether the alts handshaker should be enabled or not for direct-path. Requires Workload Identity (workload_pool must be non-empty).
        """
        return pulumi.get(self, 'enable_alts')

    @enable_alts.setter
    def enable_alts(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_alts', value)


@pulumi.input_type
class WorkloadCertificatesArgs:

    def __init__(__self__, *, enable_certificates: Optional[pulumi.Input[
        bool]]=None):
        """
        Configuration for issuance of mTLS keys and certificates to Kubernetes pods.
        :param pulumi.Input[bool] enable_certificates: enable_certificates controls issuance of workload mTLS certificates. If set, the GKE Workload Identity Certificates controller and node agent will be deployed in the cluster, which can then be configured by creating a WorkloadCertificateConfig Custom Resource. Requires Workload Identity (workload_pool must be non-empty).
        """
        if enable_certificates is not None:
            pulumi.set(__self__, 'enable_certificates', enable_certificates)

    @property
    @pulumi.getter(name='enableCertificates')
    def enable_certificates(self) ->Optional[pulumi.Input[bool]]:
        """
        enable_certificates controls issuance of workload mTLS certificates. If set, the GKE Workload Identity Certificates controller and node agent will be deployed in the cluster, which can then be configured by creating a WorkloadCertificateConfig Custom Resource. Requires Workload Identity (workload_pool must be non-empty).
        """
        return pulumi.get(self, 'enable_certificates')

    @enable_certificates.setter
    def enable_certificates(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_certificates', value)


@pulumi.input_type
class WorkloadConfigArgs:

    def __init__(__self__, *, audit_mode: Optional[pulumi.Input[
        'WorkloadConfigAuditMode']]=None):
        """
        WorkloadConfig defines the flags to enable or disable the workload configurations for the cluster.
        :param pulumi.Input['WorkloadConfigAuditMode'] audit_mode: Sets which mode of auditing should be used for the cluster's workloads.
        """
        if audit_mode is not None:
            pulumi.set(__self__, 'audit_mode', audit_mode)

    @property
    @pulumi.getter(name='auditMode')
    def audit_mode(self) ->Optional[pulumi.Input['WorkloadConfigAuditMode']]:
        """
        Sets which mode of auditing should be used for the cluster's workloads.
        """
        return pulumi.get(self, 'audit_mode')

    @audit_mode.setter
    def audit_mode(self, value: Optional[pulumi.Input[
        'WorkloadConfigAuditMode']]):
        pulumi.set(self, 'audit_mode', value)


@pulumi.input_type
class WorkloadIdentityConfigArgs:

    def __init__(__self__, *, identity_namespace: Optional[pulumi.Input[str
        ]]=None, identity_provider: Optional[pulumi.Input[str]]=None,
        workload_pool: Optional[pulumi.Input[str]]=None):
        """
        Configuration for the use of Kubernetes Service Accounts in GCP IAM policies.
        :param pulumi.Input[str] identity_namespace: IAM Identity Namespace to attach all Kubernetes Service Accounts to.
        :param pulumi.Input[str] identity_provider: identity provider is the third party identity provider.
        :param pulumi.Input[str] workload_pool: The workload pool to attach all Kubernetes service accounts to.
        """
        if identity_namespace is not None:
            pulumi.set(__self__, 'identity_namespace', identity_namespace)
        if identity_provider is not None:
            pulumi.set(__self__, 'identity_provider', identity_provider)
        if workload_pool is not None:
            pulumi.set(__self__, 'workload_pool', workload_pool)

    @property
    @pulumi.getter(name='identityNamespace')
    def identity_namespace(self) ->Optional[pulumi.Input[str]]:
        """
        IAM Identity Namespace to attach all Kubernetes Service Accounts to.
        """
        return pulumi.get(self, 'identity_namespace')

    @identity_namespace.setter
    def identity_namespace(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'identity_namespace', value)

    @property
    @pulumi.getter(name='identityProvider')
    def identity_provider(self) ->Optional[pulumi.Input[str]]:
        """
        identity provider is the third party identity provider.
        """
        return pulumi.get(self, 'identity_provider')

    @identity_provider.setter
    def identity_provider(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'identity_provider', value)

    @property
    @pulumi.getter(name='workloadPool')
    def workload_pool(self) ->Optional[pulumi.Input[str]]:
        """
        The workload pool to attach all Kubernetes service accounts to.
        """
        return pulumi.get(self, 'workload_pool')

    @workload_pool.setter
    def workload_pool(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'workload_pool', value)


@pulumi.input_type
class WorkloadMetadataConfigArgs:

    def __init__(__self__, *, mode: Optional[pulumi.Input[
        'WorkloadMetadataConfigMode']]=None, node_metadata: Optional[pulumi
        .Input['WorkloadMetadataConfigNodeMetadata']]=None):
        """
        WorkloadMetadataConfig defines the metadata configuration to expose to workloads on the node pool.
        :param pulumi.Input['WorkloadMetadataConfigMode'] mode: Mode is the configuration for how to expose metadata to workloads running on the node pool.
        :param pulumi.Input['WorkloadMetadataConfigNodeMetadata'] node_metadata: NodeMetadata is the configuration for how to expose metadata to the workloads running on the node.
        """
        if mode is not None:
            pulumi.set(__self__, 'mode', mode)
        if node_metadata is not None:
            pulumi.set(__self__, 'node_metadata', node_metadata)

    @property
    @pulumi.getter
    def mode(self) ->Optional[pulumi.Input['WorkloadMetadataConfigMode']]:
        """
        Mode is the configuration for how to expose metadata to workloads running on the node pool.
        """
        return pulumi.get(self, 'mode')

    @mode.setter
    def mode(self, value: Optional[pulumi.Input['WorkloadMetadataConfigMode']]
        ):
        pulumi.set(self, 'mode', value)

    @property
    @pulumi.getter(name='nodeMetadata')
    def node_metadata(self) ->Optional[pulumi.Input[
        'WorkloadMetadataConfigNodeMetadata']]:
        """
        NodeMetadata is the configuration for how to expose metadata to the workloads running on the node.
        """
        return pulumi.get(self, 'node_metadata')

    @node_metadata.setter
    def node_metadata(self, value: Optional[pulumi.Input[
        'WorkloadMetadataConfigNodeMetadata']]):
        pulumi.set(self, 'node_metadata', value)

<mask token>


@pulumi.input_type
class BlueGreenSettingsArgs:
    <mask token>
    <mask token>
    <mask token>
    <mask token>

    @standard_rollout_policy.setter
    def standard_rollout_policy(self, value: Optional[pulumi.Input[
        'StandardRolloutPolicyArgs']]):
        pulumi.set(self, 'standard_rollout_policy', value)


@pulumi.input_type
class CidrBlockArgs:

    def __init__(__self__, *, cidr_block: Optional[pulumi.Input[str]]=None,
        display_name: Optional[pulumi.Input[str]]=None):
        """
        CidrBlock contains an optional name and one CIDR block.
        :param pulumi.Input[str] cidr_block: cidr_block must be specified in CIDR notation.
        :param pulumi.Input[str] display_name: display_name is an optional field for users to identify CIDR blocks.
        """
        if cidr_block is not None:
            pulumi.set(__self__, 'cidr_block', cidr_block)
        if display_name is not None:
            pulumi.set(__self__, 'display_name', display_name)

    @property
    @pulumi.getter(name='cidrBlock')
    def cidr_block(self) ->Optional[pulumi.Input[str]]:
        """
        cidr_block must be specified in CIDR notation.
        """
        return pulumi.get(self, 'cidr_block')

    @cidr_block.setter
    def cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'cidr_block', value)

    @property
    @pulumi.getter(name='displayName')
    def display_name(self) ->Optional[pulumi.Input[str]]:
        """
        display_name is an optional field for users to identify CIDR blocks.
        """
        return pulumi.get(self, 'display_name')

    @display_name.setter
    def display_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'display_name', value)


@pulumi.input_type
class ClientCertificateConfigArgs:

    def __init__(__self__, *, issue_client_certificate: Optional[pulumi.
        Input[bool]]=None):
        """
        Configuration for client certificates on the cluster.
        :param pulumi.Input[bool] issue_client_certificate: Issue a client certificate.
        """
        if issue_client_certificate is not None:
            pulumi.set(__self__, 'issue_client_certificate',
                issue_client_certificate)

    @property
    @pulumi.getter(name='issueClientCertificate')
    def issue_client_certificate(self) ->Optional[pulumi.Input[bool]]:
        """
        Issue a client certificate.
        """
        return pulumi.get(self, 'issue_client_certificate')

    @issue_client_certificate.setter
    def issue_client_certificate(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'issue_client_certificate', value)


@pulumi.input_type
class CloudRunConfigArgs:

    def __init__(__self__, *, disabled: Optional[pulumi.Input[bool]]=None,
        load_balancer_type: Optional[pulumi.Input[
        'CloudRunConfigLoadBalancerType']]=None):
        """
        Configuration options for the Cloud Run feature.
        :param pulumi.Input[bool] disabled: Whether Cloud Run addon is enabled for this cluster.
        :param pulumi.Input['CloudRunConfigLoadBalancerType'] load_balancer_type: Which load balancer type is installed for Cloud Run.
        """
        if disabled is not None:
            pulumi.set(__self__, 'disabled', disabled)
        if load_balancer_type is not None:
            pulumi.set(__self__, 'load_balancer_type', load_balancer_type)

    @property
    @pulumi.getter
    def disabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Cloud Run addon is enabled for this cluster.
        """
        return pulumi.get(self, 'disabled')

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'disabled', value)

    @property
    @pulumi.getter(name='loadBalancerType')
    def load_balancer_type(self) ->Optional[pulumi.Input[
        'CloudRunConfigLoadBalancerType']]:
        """
        Which load balancer type is installed for Cloud Run.
        """
        return pulumi.get(self, 'load_balancer_type')

    @load_balancer_type.setter
    def load_balancer_type(self, value: Optional[pulumi.Input[
        'CloudRunConfigLoadBalancerType']]):
        pulumi.set(self, 'load_balancer_type', value)


@pulumi.input_type
class ClusterAutoscalingArgs:

    def __init__(__self__, *, autoprovisioning_locations: Optional[pulumi.
        Input[Sequence[pulumi.Input[str]]]]=None,
        autoprovisioning_node_pool_defaults: Optional[pulumi.Input[
        'AutoprovisioningNodePoolDefaultsArgs']]=None, autoscaling_profile:
        Optional[pulumi.Input['ClusterAutoscalingAutoscalingProfile']]=None,
        enable_node_autoprovisioning: Optional[pulumi.Input[bool]]=None,
        resource_limits: Optional[pulumi.Input[Sequence[pulumi.Input[
        'ResourceLimitArgs']]]]=None):
        """
        ClusterAutoscaling contains global, per-cluster information required by Cluster Autoscaler to automatically adjust the size of the cluster and create/delete node pools based on the current needs.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] autoprovisioning_locations: The list of Google Compute Engine [zones](https://cloud.google.com/compute/docs/zones#available) in which the NodePool's nodes can be created by NAP.
        :param pulumi.Input['AutoprovisioningNodePoolDefaultsArgs'] autoprovisioning_node_pool_defaults: AutoprovisioningNodePoolDefaults contains defaults for a node pool created by NAP.
        :param pulumi.Input['ClusterAutoscalingAutoscalingProfile'] autoscaling_profile: Defines autoscaling behaviour.
        :param pulumi.Input[bool] enable_node_autoprovisioning: Enables automatic node pool creation and deletion.
        :param pulumi.Input[Sequence[pulumi.Input['ResourceLimitArgs']]] resource_limits: Contains global constraints regarding minimum and maximum amount of resources in the cluster.
        """
        if autoprovisioning_locations is not None:
            pulumi.set(__self__, 'autoprovisioning_locations',
                autoprovisioning_locations)
        if autoprovisioning_node_pool_defaults is not None:
            pulumi.set(__self__, 'autoprovisioning_node_pool_defaults',
                autoprovisioning_node_pool_defaults)
        if autoscaling_profile is not None:
            pulumi.set(__self__, 'autoscaling_profile', autoscaling_profile)
        if enable_node_autoprovisioning is not None:
            pulumi.set(__self__, 'enable_node_autoprovisioning',
                enable_node_autoprovisioning)
        if resource_limits is not None:
            pulumi.set(__self__, 'resource_limits', resource_limits)

    @property
    @pulumi.getter(name='autoprovisioningLocations')
    def autoprovisioning_locations(self) ->Optional[pulumi.Input[Sequence[
        pulumi.Input[str]]]]:
        """
        The list of Google Compute Engine [zones](https://cloud.google.com/compute/docs/zones#available) in which the NodePool's nodes can be created by NAP.
        """
        return pulumi.get(self, 'autoprovisioning_locations')

    @autoprovisioning_locations.setter
    def autoprovisioning_locations(self, value: Optional[pulumi.Input[
        Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, 'autoprovisioning_locations', value)

    @property
    @pulumi.getter(name='autoprovisioningNodePoolDefaults')
    def autoprovisioning_node_pool_defaults(self) ->Optional[pulumi.Input[
        'AutoprovisioningNodePoolDefaultsArgs']]:
        """
        AutoprovisioningNodePoolDefaults contains defaults for a node pool created by NAP.
        """
        return pulumi.get(self, 'autoprovisioning_node_pool_defaults')

    @autoprovisioning_node_pool_defaults.setter
    def autoprovisioning_node_pool_defaults(self, value: Optional[pulumi.
        Input['AutoprovisioningNodePoolDefaultsArgs']]):
        pulumi.set(self, 'autoprovisioning_node_pool_defaults', value)

    @property
    @pulumi.getter(name='autoscalingProfile')
    def autoscaling_profile(self) ->Optional[pulumi.Input[
        'ClusterAutoscalingAutoscalingProfile']]:
        """
        Defines autoscaling behaviour.
        """
        return pulumi.get(self, 'autoscaling_profile')

    @autoscaling_profile.setter
    def autoscaling_profile(self, value: Optional[pulumi.Input[
        'ClusterAutoscalingAutoscalingProfile']]):
        pulumi.set(self, 'autoscaling_profile', value)

    @property
    @pulumi.getter(name='enableNodeAutoprovisioning')
    def enable_node_autoprovisioning(self) ->Optional[pulumi.Input[bool]]:
        """
        Enables automatic node pool creation and deletion.
        """
        return pulumi.get(self, 'enable_node_autoprovisioning')

    @enable_node_autoprovisioning.setter
    def enable_node_autoprovisioning(self, value: Optional[pulumi.Input[bool]]
        ):
        pulumi.set(self, 'enable_node_autoprovisioning', value)

    @property
    @pulumi.getter(name='resourceLimits')
    def resource_limits(self) ->Optional[pulumi.Input[Sequence[pulumi.Input
        ['ResourceLimitArgs']]]]:
        """
        Contains global constraints regarding minimum and maximum amount of resources in the cluster.
        """
        return pulumi.get(self, 'resource_limits')

    @resource_limits.setter
    def resource_limits(self, value: Optional[pulumi.Input[Sequence[pulumi.
        Input['ResourceLimitArgs']]]]):
        pulumi.set(self, 'resource_limits', value)


@pulumi.input_type
class ClusterTelemetryArgs:

    def __init__(__self__, *, type: Optional[pulumi.Input[
        'ClusterTelemetryType']]=None):
        """
        Telemetry integration for the cluster.
        :param pulumi.Input['ClusterTelemetryType'] type: Type of the integration.
        """
        if type is not None:
            pulumi.set(__self__, 'type', type)

    @property
    @pulumi.getter
    def type(self) ->Optional[pulumi.Input['ClusterTelemetryType']]:
        """
        Type of the integration.
        """
        return pulumi.get(self, 'type')

    @type.setter
    def type(self, value: Optional[pulumi.Input['ClusterTelemetryType']]):
        pulumi.set(self, 'type', value)


@pulumi.input_type
class ConfidentialNodesArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        ConfidentialNodes is configuration for the confidential nodes feature, which makes nodes run on confidential VMs.
        :param pulumi.Input[bool] enabled: Whether Confidential Nodes feature is enabled.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Confidential Nodes feature is enabled.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class ConfigConnectorConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration options for the Config Connector add-on.
        :param pulumi.Input[bool] enabled: Whether Cloud Connector is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Cloud Connector is enabled for this cluster.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class ConsumptionMeteringConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Parameters for controlling consumption metering.
        :param pulumi.Input[bool] enabled: Whether to enable consumption metering for this cluster. If enabled, a second BigQuery table will be created to hold resource consumption records.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether to enable consumption metering for this cluster. If enabled, a second BigQuery table will be created to hold resource consumption records.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class CostManagementConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for fine-grained cost management feature.
        :param pulumi.Input[bool] enabled: Whether the feature is enabled or not.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the feature is enabled or not.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class DNSConfigArgs:

    def __init__(__self__, *, cluster_dns: Optional[pulumi.Input[
        'DNSConfigClusterDns']]=None, cluster_dns_domain: Optional[pulumi.
        Input[str]]=None, cluster_dns_scope: Optional[pulumi.Input[
        'DNSConfigClusterDnsScope']]=None):
        """
        DNSConfig contains the desired set of options for configuring clusterDNS.
        :param pulumi.Input['DNSConfigClusterDns'] cluster_dns: cluster_dns indicates which in-cluster DNS provider should be used.
        :param pulumi.Input[str] cluster_dns_domain: cluster_dns_domain is the suffix used for all cluster service records.
        :param pulumi.Input['DNSConfigClusterDnsScope'] cluster_dns_scope: cluster_dns_scope indicates the scope of access to cluster DNS records.
        """
        if cluster_dns is not None:
            pulumi.set(__self__, 'cluster_dns', cluster_dns)
        if cluster_dns_domain is not None:
            pulumi.set(__self__, 'cluster_dns_domain', cluster_dns_domain)
        if cluster_dns_scope is not None:
            pulumi.set(__self__, 'cluster_dns_scope', cluster_dns_scope)

    @property
    @pulumi.getter(name='clusterDns')
    def cluster_dns(self) ->Optional[pulumi.Input['DNSConfigClusterDns']]:
        """
        cluster_dns indicates which in-cluster DNS provider should be used.
        """
        return pulumi.get(self, 'cluster_dns')

    @cluster_dns.setter
    def cluster_dns(self, value: Optional[pulumi.Input['DNSConfigClusterDns']]
        ):
        pulumi.set(self, 'cluster_dns', value)

    @property
    @pulumi.getter(name='clusterDnsDomain')
    def cluster_dns_domain(self) ->Optional[pulumi.Input[str]]:
        """
        cluster_dns_domain is the suffix used for all cluster service records.
        """
        return pulumi.get(self, 'cluster_dns_domain')

    @cluster_dns_domain.setter
    def cluster_dns_domain(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'cluster_dns_domain', value)

    @property
    @pulumi.getter(name='clusterDnsScope')
    def cluster_dns_scope(self) ->Optional[pulumi.Input[
        'DNSConfigClusterDnsScope']]:
        """
        cluster_dns_scope indicates the scope of access to cluster DNS records.
        """
        return pulumi.get(self, 'cluster_dns_scope')

    @cluster_dns_scope.setter
    def cluster_dns_scope(self, value: Optional[pulumi.Input[
        'DNSConfigClusterDnsScope']]):
        pulumi.set(self, 'cluster_dns_scope', value)


@pulumi.input_type
class DailyMaintenanceWindowArgs:

    def __init__(__self__, *, start_time: Optional[pulumi.Input[str]]=None):
        """
        Time window specified for daily maintenance operations.
        :param pulumi.Input[str] start_time: Time within the maintenance window to start the maintenance operations. It must be in format "HH:MM", where HH : [00-23] and MM : [00-59] GMT.
        """
        if start_time is not None:
            pulumi.set(__self__, 'start_time', start_time)

    @property
    @pulumi.getter(name='startTime')
    def start_time(self) ->Optional[pulumi.Input[str]]:
        """
        Time within the maintenance window to start the maintenance operations. It must be in format "HH:MM", where HH : [00-23] and MM : [00-59] GMT.
        """
        return pulumi.get(self, 'start_time')

    @start_time.setter
    def start_time(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'start_time', value)


@pulumi.input_type
class DatabaseEncryptionArgs:

    def __init__(__self__, *, key_name: Optional[pulumi.Input[str]]=None,
        state: Optional[pulumi.Input['DatabaseEncryptionState']]=None):
        """
        Configuration of etcd encryption.
        :param pulumi.Input[str] key_name: Name of CloudKMS key to use for the encryption of secrets in etcd. Ex. projects/my-project/locations/global/keyRings/my-ring/cryptoKeys/my-key
        :param pulumi.Input['DatabaseEncryptionState'] state: The desired state of etcd encryption.
        """
        if key_name is not None:
            pulumi.set(__self__, 'key_name', key_name)
        if state is not None:
            pulumi.set(__self__, 'state', state)

    @property
    @pulumi.getter(name='keyName')
    def key_name(self) ->Optional[pulumi.Input[str]]:
        """
        Name of CloudKMS key to use for the encryption of secrets in etcd. Ex. projects/my-project/locations/global/keyRings/my-ring/cryptoKeys/my-key
        """
        return pulumi.get(self, 'key_name')

    @key_name.setter
    def key_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'key_name', value)

    @property
    @pulumi.getter
    def state(self) ->Optional[pulumi.Input['DatabaseEncryptionState']]:
        """
        The desired state of etcd encryption.
        """
        return pulumi.get(self, 'state')

    @state.setter
    def state(self, value: Optional[pulumi.Input['DatabaseEncryptionState']]):
        pulumi.set(self, 'state', value)


@pulumi.input_type
class DefaultSnatStatusArgs:

    def __init__(__self__, *, disabled: Optional[pulumi.Input[bool]]=None):
        """
        DefaultSnatStatus contains the desired state of whether default sNAT should be disabled on the cluster.
        :param pulumi.Input[bool] disabled: Disables cluster default sNAT rules.
        """
        if disabled is not None:
            pulumi.set(__self__, 'disabled', disabled)

    @property
    @pulumi.getter
    def disabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Disables cluster default sNAT rules.
        """
        return pulumi.get(self, 'disabled')

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'disabled', value)


@pulumi.input_type
class DnsCacheConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for NodeLocal DNSCache
        :param pulumi.Input[bool] enabled: Whether NodeLocal DNSCache is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether NodeLocal DNSCache is enabled for this cluster.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class EphemeralStorageConfigArgs:

    def __init__(__self__, *, local_ssd_count: Optional[pulumi.Input[int]]=None
        ):
        """
        EphemeralStorageConfig contains configuration for the ephemeral storage filesystem.
        :param pulumi.Input[int] local_ssd_count: Number of local SSDs to use to back ephemeral storage. Uses NVMe interfaces. Each local SSD is 375 GB in size. If zero, it means to disable using local SSDs as ephemeral storage.
        """
        if local_ssd_count is not None:
            pulumi.set(__self__, 'local_ssd_count', local_ssd_count)

    @property
    @pulumi.getter(name='localSsdCount')
    def local_ssd_count(self) ->Optional[pulumi.Input[int]]:
        """
        Number of local SSDs to use to back ephemeral storage. Uses NVMe interfaces. Each local SSD is 375 GB in size. If zero, it means to disable using local SSDs as ephemeral storage.
        """
        return pulumi.get(self, 'local_ssd_count')

    @local_ssd_count.setter
    def local_ssd_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'local_ssd_count', value)


@pulumi.input_type
class EphemeralStorageLocalSsdConfigArgs:

    def __init__(__self__, *, local_ssd_count: Optional[pulumi.Input[int]]=None
        ):
        """
        EphemeralStorageLocalSsdConfig contains configuration for the node ephemeral storage using Local SSDs.
        :param pulumi.Input[int] local_ssd_count: Number of local SSDs to use to back ephemeral storage. Uses NVMe interfaces. Each local SSD is 375 GB in size. If zero, it means to disable using local SSDs as ephemeral storage. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        """
        if local_ssd_count is not None:
            pulumi.set(__self__, 'local_ssd_count', local_ssd_count)

    @property
    @pulumi.getter(name='localSsdCount')
    def local_ssd_count(self) ->Optional[pulumi.Input[int]]:
        """
        Number of local SSDs to use to back ephemeral storage. Uses NVMe interfaces. Each local SSD is 375 GB in size. If zero, it means to disable using local SSDs as ephemeral storage. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        """
        return pulumi.get(self, 'local_ssd_count')

    @local_ssd_count.setter
    def local_ssd_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'local_ssd_count', value)


@pulumi.input_type
class FastSocketArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration of Fast Socket feature.
        :param pulumi.Input[bool] enabled: Whether Fast Socket features are enabled in the node pool.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Fast Socket features are enabled in the node pool.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class FilterArgs:

    def __init__(__self__, *, event_type: Optional[pulumi.Input[Sequence[
        pulumi.Input['FilterEventTypeItem']]]]=None):
        """
        Allows filtering to one or more specific event types. If event types are present, those and only those event types will be transmitted to the cluster. Other types will be skipped. If no filter is specified, or no event types are present, all event types will be sent
        :param pulumi.Input[Sequence[pulumi.Input['FilterEventTypeItem']]] event_type: Event types to allowlist.
        """
        if event_type is not None:
            pulumi.set(__self__, 'event_type', event_type)

    @property
    @pulumi.getter(name='eventType')
    def event_type(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[
        'FilterEventTypeItem']]]]:
        """
        Event types to allowlist.
        """
        return pulumi.get(self, 'event_type')

    @event_type.setter
    def event_type(self, value: Optional[pulumi.Input[Sequence[pulumi.Input
        ['FilterEventTypeItem']]]]):
        pulumi.set(self, 'event_type', value)


@pulumi.input_type
class FleetArgs:

    def __init__(__self__, *, project: Optional[pulumi.Input[str]]=None):
        """
        Fleet is the fleet configuration for the cluster.
        :param pulumi.Input[str] project: The Fleet host project(project ID or project number) where this cluster will be registered to. This field cannot be changed after the cluster has been registered.
        """
        if project is not None:
            pulumi.set(__self__, 'project', project)

    @property
    @pulumi.getter
    def project(self) ->Optional[pulumi.Input[str]]:
        """
        The Fleet host project(project ID or project number) where this cluster will be registered to. This field cannot be changed after the cluster has been registered.
        """
        return pulumi.get(self, 'project')

    @project.setter
    def project(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'project', value)


@pulumi.input_type
class GPUSharingConfigArgs:

    def __init__(__self__, *, gpu_sharing_strategy: Optional[pulumi.Input[
        'GPUSharingConfigGpuSharingStrategy']]=None,
        max_shared_clients_per_gpu: Optional[pulumi.Input[str]]=None):
        """
        GPUSharingConfig represents the GPU sharing configuration for Hardware Accelerators.
        :param pulumi.Input['GPUSharingConfigGpuSharingStrategy'] gpu_sharing_strategy: The type of GPU sharing strategy to enable on the GPU node.
        :param pulumi.Input[str] max_shared_clients_per_gpu: The max number of containers that can share a physical GPU.
        """
        if gpu_sharing_strategy is not None:
            pulumi.set(__self__, 'gpu_sharing_strategy', gpu_sharing_strategy)
        if max_shared_clients_per_gpu is not None:
            pulumi.set(__self__, 'max_shared_clients_per_gpu',
                max_shared_clients_per_gpu)

    @property
    @pulumi.getter(name='gpuSharingStrategy')
    def gpu_sharing_strategy(self) ->Optional[pulumi.Input[
        'GPUSharingConfigGpuSharingStrategy']]:
        """
        The type of GPU sharing strategy to enable on the GPU node.
        """
        return pulumi.get(self, 'gpu_sharing_strategy')

    @gpu_sharing_strategy.setter
    def gpu_sharing_strategy(self, value: Optional[pulumi.Input[
        'GPUSharingConfigGpuSharingStrategy']]):
        pulumi.set(self, 'gpu_sharing_strategy', value)

    @property
    @pulumi.getter(name='maxSharedClientsPerGpu')
    def max_shared_clients_per_gpu(self) ->Optional[pulumi.Input[str]]:
        """
        The max number of containers that can share a physical GPU.
        """
        return pulumi.get(self, 'max_shared_clients_per_gpu')

    @max_shared_clients_per_gpu.setter
    def max_shared_clients_per_gpu(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'max_shared_clients_per_gpu', value)


@pulumi.input_type
class GatewayAPIConfigArgs:

    def __init__(__self__, *, channel: Optional[pulumi.Input[
        'GatewayAPIConfigChannel']]=None):
        """
        GatewayAPIConfig contains the desired config of Gateway API on this cluster.
        :param pulumi.Input['GatewayAPIConfigChannel'] channel: The Gateway API release channel to use for Gateway API.
        """
        if channel is not None:
            pulumi.set(__self__, 'channel', channel)

    @property
    @pulumi.getter
    def channel(self) ->Optional[pulumi.Input['GatewayAPIConfigChannel']]:
        """
        The Gateway API release channel to use for Gateway API.
        """
        return pulumi.get(self, 'channel')

    @channel.setter
    def channel(self, value: Optional[pulumi.Input['GatewayAPIConfigChannel']]
        ):
        pulumi.set(self, 'channel', value)


@pulumi.input_type
class GcePersistentDiskCsiDriverConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for the Compute Engine PD CSI driver.
        :param pulumi.Input[bool] enabled: Whether the Compute Engine PD CSI driver is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the Compute Engine PD CSI driver is enabled for this cluster.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class GcfsConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        GcfsConfig contains configurations of Google Container File System.
        :param pulumi.Input[bool] enabled: Whether to use GCFS.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether to use GCFS.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class GcpFilestoreCsiDriverConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for the GCP Filestore CSI driver.
        :param pulumi.Input[bool] enabled: Whether the GCP Filestore CSI driver is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the GCP Filestore CSI driver is enabled for this cluster.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class GcsFuseCsiDriverConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for the Cloud Storage Fuse CSI driver.
        :param pulumi.Input[bool] enabled: Whether the Cloud Storage Fuse CSI driver is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the Cloud Storage Fuse CSI driver is enabled for this cluster.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class GkeBackupAgentConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for the Backup for GKE Agent.
        :param pulumi.Input[bool] enabled: Whether the Backup for GKE agent is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the Backup for GKE agent is enabled for this cluster.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class HorizontalPodAutoscalingArgs:

    def __init__(__self__, *, disabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration options for the horizontal pod autoscaling feature, which increases or decreases the number of replica pods a replication controller has based on the resource usage of the existing pods.
        :param pulumi.Input[bool] disabled: Whether the Horizontal Pod Autoscaling feature is enabled in the cluster. When enabled, it ensures that metrics are collected into Stackdriver Monitoring.
        """
        if disabled is not None:
            pulumi.set(__self__, 'disabled', disabled)

    @property
    @pulumi.getter
    def disabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the Horizontal Pod Autoscaling feature is enabled in the cluster. When enabled, it ensures that metrics are collected into Stackdriver Monitoring.
        """
        return pulumi.get(self, 'disabled')

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'disabled', value)


@pulumi.input_type
class HttpLoadBalancingArgs:

    def __init__(__self__, *, disabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration options for the HTTP (L7) load balancing controller addon, which makes it easy to set up HTTP load balancers for services in a cluster.
        :param pulumi.Input[bool] disabled: Whether the HTTP Load Balancing controller is enabled in the cluster. When enabled, it runs a small pod in the cluster that manages the load balancers.
        """
        if disabled is not None:
            pulumi.set(__self__, 'disabled', disabled)

    @property
    @pulumi.getter
    def disabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the HTTP Load Balancing controller is enabled in the cluster. When enabled, it runs a small pod in the cluster that manages the load balancers.
        """
        return pulumi.get(self, 'disabled')

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'disabled', value)


@pulumi.input_type
class IPAllocationPolicyArgs:

    def __init__(__self__, *, allow_route_overlap: Optional[pulumi.Input[
        bool]]=None, cluster_ipv4_cidr: Optional[pulumi.Input[str]]=None,
        cluster_ipv4_cidr_block: Optional[pulumi.Input[str]]=None,
        cluster_secondary_range_name: Optional[pulumi.Input[str]]=None,
        create_subnetwork: Optional[pulumi.Input[bool]]=None,
        ipv6_access_type: Optional[pulumi.Input[
        'IPAllocationPolicyIpv6AccessType']]=None, node_ipv4_cidr: Optional
        [pulumi.Input[str]]=None, node_ipv4_cidr_block: Optional[pulumi.
        Input[str]]=None, pod_cidr_overprovision_config: Optional[pulumi.
        Input['PodCIDROverprovisionConfigArgs']]=None, services_ipv4_cidr:
        Optional[pulumi.Input[str]]=None, services_ipv4_cidr_block:
        Optional[pulumi.Input[str]]=None, services_secondary_range_name:
        Optional[pulumi.Input[str]]=None, stack_type: Optional[pulumi.Input
        ['IPAllocationPolicyStackType']]=None, subnetwork_name: Optional[
        pulumi.Input[str]]=None, tpu_ipv4_cidr_block: Optional[pulumi.Input
        [str]]=None, use_ip_aliases: Optional[pulumi.Input[bool]]=None,
        use_routes: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for controlling how IPs are allocated in the cluster.
        :param pulumi.Input[bool] allow_route_overlap: If true, allow allocation of cluster CIDR ranges that overlap with certain kinds of network routes. By default we do not allow cluster CIDR ranges to intersect with any user declared routes. With allow_route_overlap == true, we allow overlapping with CIDR ranges that are larger than the cluster CIDR range. If this field is set to true, then cluster and services CIDRs must be fully-specified (e.g. `10.96.0.0/14`, but not `/14`), which means: 1) When `use_ip_aliases` is true, `cluster_ipv4_cidr_block` and `services_ipv4_cidr_block` must be fully-specified. 2) When `use_ip_aliases` is false, `cluster.cluster_ipv4_cidr` muse be fully-specified.
        :param pulumi.Input[str] cluster_ipv4_cidr: This field is deprecated, use cluster_ipv4_cidr_block.
        :param pulumi.Input[str] cluster_ipv4_cidr_block: The IP address range for the cluster pod IPs. If this field is set, then `cluster.cluster_ipv4_cidr` must be left blank. This field is only applicable when `use_ip_aliases` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        :param pulumi.Input[str] cluster_secondary_range_name: The name of the secondary range to be used for the cluster CIDR block. The secondary range will be used for pod IP addresses. This must be an existing secondary range associated with the cluster subnetwork. This field is only applicable with use_ip_aliases and create_subnetwork is false.
        :param pulumi.Input[bool] create_subnetwork: Whether a new subnetwork will be created automatically for the cluster. This field is only applicable when `use_ip_aliases` is true.
        :param pulumi.Input['IPAllocationPolicyIpv6AccessType'] ipv6_access_type: The ipv6 access type (internal or external) when create_subnetwork is true
        :param pulumi.Input[str] node_ipv4_cidr: This field is deprecated, use node_ipv4_cidr_block.
        :param pulumi.Input[str] node_ipv4_cidr_block: The IP address range of the instance IPs in this cluster. This is applicable only if `create_subnetwork` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        :param pulumi.Input['PodCIDROverprovisionConfigArgs'] pod_cidr_overprovision_config: [PRIVATE FIELD] Pod CIDR size overprovisioning config for the cluster. Pod CIDR size per node depends on max_pods_per_node. By default, the value of max_pods_per_node is doubled and then rounded off to next power of 2 to get the size of pod CIDR block per node. Example: max_pods_per_node of 30 would result in 64 IPs (/26). This config can disable the doubling of IPs (we still round off to next power of 2) Example: max_pods_per_node of 30 will result in 32 IPs (/27) when overprovisioning is disabled.
        :param pulumi.Input[str] services_ipv4_cidr: This field is deprecated, use services_ipv4_cidr_block.
        :param pulumi.Input[str] services_ipv4_cidr_block: The IP address range of the services IPs in this cluster. If blank, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        :param pulumi.Input[str] services_secondary_range_name: The name of the secondary range to be used as for the services CIDR block. The secondary range will be used for service ClusterIPs. This must be an existing secondary range associated with the cluster subnetwork. This field is only applicable with use_ip_aliases and create_subnetwork is false.
        :param pulumi.Input['IPAllocationPolicyStackType'] stack_type: IP stack type
        :param pulumi.Input[str] subnetwork_name: A custom subnetwork name to be used if `create_subnetwork` is true. If this field is empty, then an automatic name will be chosen for the new subnetwork.
        :param pulumi.Input[str] tpu_ipv4_cidr_block: The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.
        :param pulumi.Input[bool] use_ip_aliases: Whether alias IPs will be used for pod IPs in the cluster. This is used in conjunction with use_routes. It cannot be true if use_routes is true. If both use_ip_aliases and use_routes are false, then the server picks the default IP allocation mode
        :param pulumi.Input[bool] use_routes: Whether routes will be used for pod IPs in the cluster. This is used in conjunction with use_ip_aliases. It cannot be true if use_ip_aliases is true. If both use_ip_aliases and use_routes are false, then the server picks the default IP allocation mode
        """
        if allow_route_overlap is not None:
            pulumi.set(__self__, 'allow_route_overlap', allow_route_overlap)
        if cluster_ipv4_cidr is not None:
            warnings.warn(
                'This field is deprecated, use cluster_ipv4_cidr_block.',
                DeprecationWarning)
            pulumi.log.warn(
                'cluster_ipv4_cidr is deprecated: This field is deprecated, use cluster_ipv4_cidr_block.'
                )
        if cluster_ipv4_cidr is not None:
            pulumi.set(__self__, 'cluster_ipv4_cidr', cluster_ipv4_cidr)
        if cluster_ipv4_cidr_block is not None:
            pulumi.set(__self__, 'cluster_ipv4_cidr_block',
                cluster_ipv4_cidr_block)
        if cluster_secondary_range_name is not None:
            pulumi.set(__self__, 'cluster_secondary_range_name',
                cluster_secondary_range_name)
        if create_subnetwork is not None:
            pulumi.set(__self__, 'create_subnetwork', create_subnetwork)
        if ipv6_access_type is not None:
            pulumi.set(__self__, 'ipv6_access_type', ipv6_access_type)
        if node_ipv4_cidr is not None:
            warnings.warn('This field is deprecated, use node_ipv4_cidr_block.'
                , DeprecationWarning)
            pulumi.log.warn(
                'node_ipv4_cidr is deprecated: This field is deprecated, use node_ipv4_cidr_block.'
                )
        if node_ipv4_cidr is not None:
            pulumi.set(__self__, 'node_ipv4_cidr', node_ipv4_cidr)
        if node_ipv4_cidr_block is not None:
            pulumi.set(__self__, 'node_ipv4_cidr_block', node_ipv4_cidr_block)
        if pod_cidr_overprovision_config is not None:
            pulumi.set(__self__, 'pod_cidr_overprovision_config',
                pod_cidr_overprovision_config)
        if services_ipv4_cidr is not None:
            warnings.warn(
                'This field is deprecated, use services_ipv4_cidr_block.',
                DeprecationWarning)
            pulumi.log.warn(
                'services_ipv4_cidr is deprecated: This field is deprecated, use services_ipv4_cidr_block.'
                )
        if services_ipv4_cidr is not None:
            pulumi.set(__self__, 'services_ipv4_cidr', services_ipv4_cidr)
        if services_ipv4_cidr_block is not None:
            pulumi.set(__self__, 'services_ipv4_cidr_block',
                services_ipv4_cidr_block)
        if services_secondary_range_name is not None:
            pulumi.set(__self__, 'services_secondary_range_name',
                services_secondary_range_name)
        if stack_type is not None:
            pulumi.set(__self__, 'stack_type', stack_type)
        if subnetwork_name is not None:
            pulumi.set(__self__, 'subnetwork_name', subnetwork_name)
        if tpu_ipv4_cidr_block is not None:
            warnings.warn(
                'The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.'
                , DeprecationWarning)
            pulumi.log.warn(
                'tpu_ipv4_cidr_block is deprecated: The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.'
                )
        if tpu_ipv4_cidr_block is not None:
            pulumi.set(__self__, 'tpu_ipv4_cidr_block', tpu_ipv4_cidr_block)
        if use_ip_aliases is not None:
            pulumi.set(__self__, 'use_ip_aliases', use_ip_aliases)
        if use_routes is not None:
            pulumi.set(__self__, 'use_routes', use_routes)

    @property
    @pulumi.getter(name='allowRouteOverlap')
    def allow_route_overlap(self) ->Optional[pulumi.Input[bool]]:
        """
        If true, allow allocation of cluster CIDR ranges that overlap with certain kinds of network routes. By default we do not allow cluster CIDR ranges to intersect with any user declared routes. With allow_route_overlap == true, we allow overlapping with CIDR ranges that are larger than the cluster CIDR range. If this field is set to true, then cluster and services CIDRs must be fully-specified (e.g. `10.96.0.0/14`, but not `/14`), which means: 1) When `use_ip_aliases` is true, `cluster_ipv4_cidr_block` and `services_ipv4_cidr_block` must be fully-specified. 2) When `use_ip_aliases` is false, `cluster.cluster_ipv4_cidr` muse be fully-specified.
        """
        return pulumi.get(self, 'allow_route_overlap')

    @allow_route_overlap.setter
    def allow_route_overlap(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'allow_route_overlap', value)

    @property
    @pulumi.getter(name='clusterIpv4Cidr')
    def cluster_ipv4_cidr(self) ->Optional[pulumi.Input[str]]:
        """
        This field is deprecated, use cluster_ipv4_cidr_block.
        """
        warnings.warn('This field is deprecated, use cluster_ipv4_cidr_block.',
            DeprecationWarning)
        pulumi.log.warn(
            'cluster_ipv4_cidr is deprecated: This field is deprecated, use cluster_ipv4_cidr_block.'
            )
        return pulumi.get(self, 'cluster_ipv4_cidr')

    @cluster_ipv4_cidr.setter
    def cluster_ipv4_cidr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'cluster_ipv4_cidr', value)

    @property
    @pulumi.getter(name='clusterIpv4CidrBlock')
    def cluster_ipv4_cidr_block(self) ->Optional[pulumi.Input[str]]:
        """
        The IP address range for the cluster pod IPs. If this field is set, then `cluster.cluster_ipv4_cidr` must be left blank. This field is only applicable when `use_ip_aliases` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        """
        return pulumi.get(self, 'cluster_ipv4_cidr_block')

    @cluster_ipv4_cidr_block.setter
    def cluster_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'cluster_ipv4_cidr_block', value)

    @property
    @pulumi.getter(name='clusterSecondaryRangeName')
    def cluster_secondary_range_name(self) ->Optional[pulumi.Input[str]]:
        """
        The name of the secondary range to be used for the cluster CIDR block. The secondary range will be used for pod IP addresses. This must be an existing secondary range associated with the cluster subnetwork. This field is only applicable with use_ip_aliases and create_subnetwork is false.
        """
        return pulumi.get(self, 'cluster_secondary_range_name')

    @cluster_secondary_range_name.setter
    def cluster_secondary_range_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'cluster_secondary_range_name', value)

    @property
    @pulumi.getter(name='createSubnetwork')
    def create_subnetwork(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether a new subnetwork will be created automatically for the cluster. This field is only applicable when `use_ip_aliases` is true.
        """
        return pulumi.get(self, 'create_subnetwork')

    @create_subnetwork.setter
    def create_subnetwork(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'create_subnetwork', value)

    @property
    @pulumi.getter(name='ipv6AccessType')
    def ipv6_access_type(self) ->Optional[pulumi.Input[
        'IPAllocationPolicyIpv6AccessType']]:
        """
        The ipv6 access type (internal or external) when create_subnetwork is true
        """
        return pulumi.get(self, 'ipv6_access_type')

    @ipv6_access_type.setter
    def ipv6_access_type(self, value: Optional[pulumi.Input[
        'IPAllocationPolicyIpv6AccessType']]):
        pulumi.set(self, 'ipv6_access_type', value)

    @property
    @pulumi.getter(name='nodeIpv4Cidr')
    def node_ipv4_cidr(self) ->Optional[pulumi.Input[str]]:
        """
        This field is deprecated, use node_ipv4_cidr_block.
        """
        warnings.warn('This field is deprecated, use node_ipv4_cidr_block.',
            DeprecationWarning)
        pulumi.log.warn(
            'node_ipv4_cidr is deprecated: This field is deprecated, use node_ipv4_cidr_block.'
            )
        return pulumi.get(self, 'node_ipv4_cidr')

    @node_ipv4_cidr.setter
    def node_ipv4_cidr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'node_ipv4_cidr', value)

    @property
    @pulumi.getter(name='nodeIpv4CidrBlock')
    def node_ipv4_cidr_block(self) ->Optional[pulumi.Input[str]]:
        """
        The IP address range of the instance IPs in this cluster. This is applicable only if `create_subnetwork` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        """
        return pulumi.get(self, 'node_ipv4_cidr_block')

    @node_ipv4_cidr_block.setter
    def node_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'node_ipv4_cidr_block', value)

    @property
    @pulumi.getter(name='podCidrOverprovisionConfig')
    def pod_cidr_overprovision_config(self) ->Optional[pulumi.Input[
        'PodCIDROverprovisionConfigArgs']]:
        """
        [PRIVATE FIELD] Pod CIDR size overprovisioning config for the cluster. Pod CIDR size per node depends on max_pods_per_node. By default, the value of max_pods_per_node is doubled and then rounded off to next power of 2 to get the size of pod CIDR block per node. Example: max_pods_per_node of 30 would result in 64 IPs (/26). This config can disable the doubling of IPs (we still round off to next power of 2) Example: max_pods_per_node of 30 will result in 32 IPs (/27) when overprovisioning is disabled.
        """
        return pulumi.get(self, 'pod_cidr_overprovision_config')

    @pod_cidr_overprovision_config.setter
    def pod_cidr_overprovision_config(self, value: Optional[pulumi.Input[
        'PodCIDROverprovisionConfigArgs']]):
        pulumi.set(self, 'pod_cidr_overprovision_config', value)

    @property
    @pulumi.getter(name='servicesIpv4Cidr')
    def services_ipv4_cidr(self) ->Optional[pulumi.Input[str]]:
        """
        This field is deprecated, use services_ipv4_cidr_block.
        """
        warnings.warn('This field is deprecated, use services_ipv4_cidr_block.'
            , DeprecationWarning)
        pulumi.log.warn(
            'services_ipv4_cidr is deprecated: This field is deprecated, use services_ipv4_cidr_block.'
            )
        return pulumi.get(self, 'services_ipv4_cidr')

    @services_ipv4_cidr.setter
    def services_ipv4_cidr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'services_ipv4_cidr', value)

    @property
    @pulumi.getter(name='servicesIpv4CidrBlock')
    def services_ipv4_cidr_block(self) ->Optional[pulumi.Input[str]]:
        """
        The IP address range of the services IPs in this cluster. If blank, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        """
        return pulumi.get(self, 'services_ipv4_cidr_block')

    @services_ipv4_cidr_block.setter
    def services_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'services_ipv4_cidr_block', value)

    @property
    @pulumi.getter(name='servicesSecondaryRangeName')
    def services_secondary_range_name(self) ->Optional[pulumi.Input[str]]:
        """
        The name of the secondary range to be used as for the services CIDR block. The secondary range will be used for service ClusterIPs. This must be an existing secondary range associated with the cluster subnetwork. This field is only applicable with use_ip_aliases and create_subnetwork is false.
        """
        return pulumi.get(self, 'services_secondary_range_name')

    @services_secondary_range_name.setter
    def services_secondary_range_name(self, value: Optional[pulumi.Input[str]]
        ):
        pulumi.set(self, 'services_secondary_range_name', value)

    @property
    @pulumi.getter(name='stackType')
    def stack_type(self) ->Optional[pulumi.Input['IPAllocationPolicyStackType']
        ]:
        """
        IP stack type
        """
        return pulumi.get(self, 'stack_type')

    @stack_type.setter
    def stack_type(self, value: Optional[pulumi.Input[
        'IPAllocationPolicyStackType']]):
        pulumi.set(self, 'stack_type', value)

    @property
    @pulumi.getter(name='subnetworkName')
    def subnetwork_name(self) ->Optional[pulumi.Input[str]]:
        """
        A custom subnetwork name to be used if `create_subnetwork` is true. If this field is empty, then an automatic name will be chosen for the new subnetwork.
        """
        return pulumi.get(self, 'subnetwork_name')

    @subnetwork_name.setter
    def subnetwork_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'subnetwork_name', value)

    @property
    @pulumi.getter(name='tpuIpv4CidrBlock')
    def tpu_ipv4_cidr_block(self) ->Optional[pulumi.Input[str]]:
        """
        The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.
        """
        warnings.warn(
            'The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.'
            , DeprecationWarning)
        pulumi.log.warn(
            'tpu_ipv4_cidr_block is deprecated: The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.'
            )
        return pulumi.get(self, 'tpu_ipv4_cidr_block')

    @tpu_ipv4_cidr_block.setter
    def tpu_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'tpu_ipv4_cidr_block', value)

    @property
    @pulumi.getter(name='useIpAliases')
    def use_ip_aliases(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether alias IPs will be used for pod IPs in the cluster. This is used in conjunction with use_routes. It cannot be true if use_routes is true. If both use_ip_aliases and use_routes are false, then the server picks the default IP allocation mode
        """
        return pulumi.get(self, 'use_ip_aliases')

    @use_ip_aliases.setter
    def use_ip_aliases(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'use_ip_aliases', value)

    @property
    @pulumi.getter(name='useRoutes')
    def use_routes(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether routes will be used for pod IPs in the cluster. This is used in conjunction with use_ip_aliases. It cannot be true if use_ip_aliases is true. If both use_ip_aliases and use_routes are false, then the server picks the default IP allocation mode
        """
        return pulumi.get(self, 'use_routes')

    @use_routes.setter
    def use_routes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'use_routes', value)


@pulumi.input_type
class IdentityServiceConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        IdentityServiceConfig is configuration for Identity Service which allows customers to use external identity providers with the K8S API
        :param pulumi.Input[bool] enabled: Whether to enable the Identity Service component
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether to enable the Identity Service component
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class IstioConfigArgs:

    def __init__(__self__, *, auth: Optional[pulumi.Input['IstioConfigAuth'
        ]]=None, disabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration options for Istio addon.
        :param pulumi.Input['IstioConfigAuth'] auth: The specified Istio auth mode, either none, or mutual TLS.
        :param pulumi.Input[bool] disabled: Whether Istio is enabled for this cluster.
        """
        if auth is not None:
            pulumi.set(__self__, 'auth', auth)
        if disabled is not None:
            pulumi.set(__self__, 'disabled', disabled)

    @property
    @pulumi.getter
    def auth(self) ->Optional[pulumi.Input['IstioConfigAuth']]:
        """
        The specified Istio auth mode, either none, or mutual TLS.
        """
        return pulumi.get(self, 'auth')

    @auth.setter
    def auth(self, value: Optional[pulumi.Input['IstioConfigAuth']]):
        pulumi.set(self, 'auth', value)

    @property
    @pulumi.getter
    def disabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Istio is enabled for this cluster.
        """
        return pulumi.get(self, 'disabled')

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'disabled', value)


@pulumi.input_type
class KalmConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration options for the KALM addon.
        :param pulumi.Input[bool] enabled: Whether KALM is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether KALM is enabled for this cluster.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class KubernetesDashboardArgs:

    def __init__(__self__, *, disabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for the Kubernetes Dashboard.
        :param pulumi.Input[bool] disabled: Whether the Kubernetes Dashboard is enabled for this cluster.
        """
        if disabled is not None:
            pulumi.set(__self__, 'disabled', disabled)

    @property
    @pulumi.getter
    def disabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the Kubernetes Dashboard is enabled for this cluster.
        """
        return pulumi.get(self, 'disabled')

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'disabled', value)


@pulumi.input_type
class LegacyAbacArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for the legacy Attribute Based Access Control authorization mode.
        :param pulumi.Input[bool] enabled: Whether the ABAC authorizer is enabled for this cluster. When enabled, identities in the system, including service accounts, nodes, and controllers, will have statically granted permissions beyond those provided by the RBAC configuration or IAM.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the ABAC authorizer is enabled for this cluster. When enabled, identities in the system, including service accounts, nodes, and controllers, will have statically granted permissions beyond those provided by the RBAC configuration or IAM.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class LinuxNodeConfigArgs:

    def __init__(__self__, *, cgroup_mode: Optional[pulumi.Input[
        'LinuxNodeConfigCgroupMode']]=None, sysctls: Optional[pulumi.Input[
        Mapping[str, pulumi.Input[str]]]]=None):
        """
        Parameters that can be configured on Linux nodes.
        :param pulumi.Input['LinuxNodeConfigCgroupMode'] cgroup_mode: cgroup_mode specifies the cgroup mode to be used on the node.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] sysctls: The Linux kernel parameters to be applied to the nodes and all pods running on the nodes. The following parameters are supported. net.core.busy_poll net.core.busy_read net.core.netdev_max_backlog net.core.rmem_max net.core.wmem_default net.core.wmem_max net.core.optmem_max net.core.somaxconn net.ipv4.tcp_rmem net.ipv4.tcp_wmem net.ipv4.tcp_tw_reuse
        """
        if cgroup_mode is not None:
            pulumi.set(__self__, 'cgroup_mode', cgroup_mode)
        if sysctls is not None:
            pulumi.set(__self__, 'sysctls', sysctls)

    @property
    @pulumi.getter(name='cgroupMode')
    def cgroup_mode(self) ->Optional[pulumi.Input['LinuxNodeConfigCgroupMode']
        ]:
        """
        cgroup_mode specifies the cgroup mode to be used on the node.
        """
        return pulumi.get(self, 'cgroup_mode')

    @cgroup_mode.setter
    def cgroup_mode(self, value: Optional[pulumi.Input[
        'LinuxNodeConfigCgroupMode']]):
        pulumi.set(self, 'cgroup_mode', value)

    @property
    @pulumi.getter
    def sysctls(self) ->Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]
        ]:
        """
        The Linux kernel parameters to be applied to the nodes and all pods running on the nodes. The following parameters are supported. net.core.busy_poll net.core.busy_read net.core.netdev_max_backlog net.core.rmem_max net.core.wmem_default net.core.wmem_max net.core.optmem_max net.core.somaxconn net.ipv4.tcp_rmem net.ipv4.tcp_wmem net.ipv4.tcp_tw_reuse
        """
        return pulumi.get(self, 'sysctls')

    @sysctls.setter
    def sysctls(self, value: Optional[pulumi.Input[Mapping[str, pulumi.
        Input[str]]]]):
        pulumi.set(self, 'sysctls', value)


@pulumi.input_type
class LocalNvmeSsdBlockConfigArgs:

    def __init__(__self__, *, local_ssd_count: Optional[pulumi.Input[int]]=None
        ):
        """
        LocalNvmeSsdBlockConfig contains configuration for using raw-block local NVMe SSDs
        :param pulumi.Input[int] local_ssd_count: The number of raw-block local NVMe SSD disks to be attached to the node. Each local SSD is 375 GB in size. If zero, it means no raw-block local NVMe SSD disks to be attached to the node. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        """
        if local_ssd_count is not None:
            pulumi.set(__self__, 'local_ssd_count', local_ssd_count)

    @property
    @pulumi.getter(name='localSsdCount')
    def local_ssd_count(self) ->Optional[pulumi.Input[int]]:
        """
        The number of raw-block local NVMe SSD disks to be attached to the node. Each local SSD is 375 GB in size. If zero, it means no raw-block local NVMe SSD disks to be attached to the node. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        """
        return pulumi.get(self, 'local_ssd_count')

    @local_ssd_count.setter
    def local_ssd_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'local_ssd_count', value)


@pulumi.input_type
class LoggingComponentConfigArgs:

    def __init__(__self__, *, enable_components: Optional[pulumi.Input[
        Sequence[pulumi.Input['LoggingComponentConfigEnableComponentsItem']
        ]]]=None):
        """
        LoggingComponentConfig is cluster logging component configuration.
        :param pulumi.Input[Sequence[pulumi.Input['LoggingComponentConfigEnableComponentsItem']]] enable_components: Select components to collect logs. An empty set would disable all logging.
        """
        if enable_components is not None:
            pulumi.set(__self__, 'enable_components', enable_components)

    @property
    @pulumi.getter(name='enableComponents')
    def enable_components(self) ->Optional[pulumi.Input[Sequence[pulumi.
        Input['LoggingComponentConfigEnableComponentsItem']]]]:
        """
        Select components to collect logs. An empty set would disable all logging.
        """
        return pulumi.get(self, 'enable_components')

    @enable_components.setter
    def enable_components(self, value: Optional[pulumi.Input[Sequence[
        pulumi.Input['LoggingComponentConfigEnableComponentsItem']]]]):
        pulumi.set(self, 'enable_components', value)


@pulumi.input_type
class LoggingConfigArgs:

    def __init__(__self__, *, component_config: Optional[pulumi.Input[
        'LoggingComponentConfigArgs']]=None):
        """
        LoggingConfig is cluster logging configuration.
        :param pulumi.Input['LoggingComponentConfigArgs'] component_config: Logging components configuration
        """
        if component_config is not None:
            pulumi.set(__self__, 'component_config', component_config)

    @property
    @pulumi.getter(name='componentConfig')
    def component_config(self) ->Optional[pulumi.Input[
        'LoggingComponentConfigArgs']]:
        """
        Logging components configuration
        """
        return pulumi.get(self, 'component_config')

    @component_config.setter
    def component_config(self, value: Optional[pulumi.Input[
        'LoggingComponentConfigArgs']]):
        pulumi.set(self, 'component_config', value)


@pulumi.input_type
class LoggingVariantConfigArgs:

    def __init__(__self__, *, variant: Optional[pulumi.Input[
        'LoggingVariantConfigVariant']]=None):
        """
        LoggingVariantConfig specifies the behaviour of the logging component.
        :param pulumi.Input['LoggingVariantConfigVariant'] variant: Logging variant deployed on nodes.
        """
        if variant is not None:
            pulumi.set(__self__, 'variant', variant)

    @property
    @pulumi.getter
    def variant(self) ->Optional[pulumi.Input['LoggingVariantConfigVariant']]:
        """
        Logging variant deployed on nodes.
        """
        return pulumi.get(self, 'variant')

    @variant.setter
    def variant(self, value: Optional[pulumi.Input[
        'LoggingVariantConfigVariant']]):
        pulumi.set(self, 'variant', value)


@pulumi.input_type
class MaintenanceExclusionOptionsArgs:

    def __init__(__self__, *, scope: Optional[pulumi.Input[
        'MaintenanceExclusionOptionsScope']]=None):
        """
        Represents the Maintenance exclusion option.
        :param pulumi.Input['MaintenanceExclusionOptionsScope'] scope: Scope specifies the upgrade scope which upgrades are blocked by the exclusion.
        """
        if scope is not None:
            pulumi.set(__self__, 'scope', scope)

    @property
    @pulumi.getter
    def scope(self) ->Optional[pulumi.Input['MaintenanceExclusionOptionsScope']
        ]:
        """
        Scope specifies the upgrade scope which upgrades are blocked by the exclusion.
        """
        return pulumi.get(self, 'scope')

    @scope.setter
    def scope(self, value: Optional[pulumi.Input[
        'MaintenanceExclusionOptionsScope']]):
        pulumi.set(self, 'scope', value)


@pulumi.input_type
class MaintenancePolicyArgs:

    def __init__(__self__, *, resource_version: Optional[pulumi.Input[str]]
        =None, window: Optional[pulumi.Input['MaintenanceWindowArgs']]=None):
        """
        MaintenancePolicy defines the maintenance policy to be used for the cluster.
        :param pulumi.Input[str] resource_version: A hash identifying the version of this policy, so that updates to fields of the policy won't accidentally undo intermediate changes (and so that users of the API unaware of some fields won't accidentally remove other fields). Make a `get()` request to the cluster to get the current resource version and include it with requests to set the policy.
        :param pulumi.Input['MaintenanceWindowArgs'] window: Specifies the maintenance window in which maintenance may be performed.
        """
        if resource_version is not None:
            pulumi.set(__self__, 'resource_version', resource_version)
        if window is not None:
            pulumi.set(__self__, 'window', window)

    @property
    @pulumi.getter(name='resourceVersion')
    def resource_version(self) ->Optional[pulumi.Input[str]]:
        """
        A hash identifying the version of this policy, so that updates to fields of the policy won't accidentally undo intermediate changes (and so that users of the API unaware of some fields won't accidentally remove other fields). Make a `get()` request to the cluster to get the current resource version and include it with requests to set the policy.
        """
        return pulumi.get(self, 'resource_version')

    @resource_version.setter
    def resource_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'resource_version', value)

    @property
    @pulumi.getter
    def window(self) ->Optional[pulumi.Input['MaintenanceWindowArgs']]:
        """
        Specifies the maintenance window in which maintenance may be performed.
        """
        return pulumi.get(self, 'window')

    @window.setter
    def window(self, value: Optional[pulumi.Input['MaintenanceWindowArgs']]):
        pulumi.set(self, 'window', value)


@pulumi.input_type
class MaintenanceWindowArgs:

    def __init__(__self__, *, daily_maintenance_window: Optional[pulumi.
        Input['DailyMaintenanceWindowArgs']]=None, maintenance_exclusions:
        Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]=None,
        recurring_window: Optional[pulumi.Input['RecurringTimeWindowArgs']]
        =None):
        """
        MaintenanceWindow defines the maintenance window to be used for the cluster.
        :param pulumi.Input['DailyMaintenanceWindowArgs'] daily_maintenance_window: DailyMaintenanceWindow specifies a daily maintenance operation window.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] maintenance_exclusions: Exceptions to maintenance window. Non-emergency maintenance should not occur in these windows.
        :param pulumi.Input['RecurringTimeWindowArgs'] recurring_window: RecurringWindow specifies some number of recurring time periods for maintenance to occur. The time windows may be overlapping. If no maintenance windows are set, maintenance can occur at any time.
        """
        if daily_maintenance_window is not None:
            pulumi.set(__self__, 'daily_maintenance_window',
                daily_maintenance_window)
        if maintenance_exclusions is not None:
            pulumi.set(__self__, 'maintenance_exclusions',
                maintenance_exclusions)
        if recurring_window is not None:
            pulumi.set(__self__, 'recurring_window', recurring_window)

    @property
    @pulumi.getter(name='dailyMaintenanceWindow')
    def daily_maintenance_window(self) ->Optional[pulumi.Input[
        'DailyMaintenanceWindowArgs']]:
        """
        DailyMaintenanceWindow specifies a daily maintenance operation window.
        """
        return pulumi.get(self, 'daily_maintenance_window')

    @daily_maintenance_window.setter
    def daily_maintenance_window(self, value: Optional[pulumi.Input[
        'DailyMaintenanceWindowArgs']]):
        pulumi.set(self, 'daily_maintenance_window', value)

    @property
    @pulumi.getter(name='maintenanceExclusions')
    def maintenance_exclusions(self) ->Optional[pulumi.Input[Mapping[str,
        pulumi.Input[str]]]]:
        """
        Exceptions to maintenance window. Non-emergency maintenance should not occur in these windows.
        """
        return pulumi.get(self, 'maintenance_exclusions')

    @maintenance_exclusions.setter
    def maintenance_exclusions(self, value: Optional[pulumi.Input[Mapping[
        str, pulumi.Input[str]]]]):
        pulumi.set(self, 'maintenance_exclusions', value)

    @property
    @pulumi.getter(name='recurringWindow')
    def recurring_window(self) ->Optional[pulumi.Input[
        'RecurringTimeWindowArgs']]:
        """
        RecurringWindow specifies some number of recurring time periods for maintenance to occur. The time windows may be overlapping. If no maintenance windows are set, maintenance can occur at any time.
        """
        return pulumi.get(self, 'recurring_window')

    @recurring_window.setter
    def recurring_window(self, value: Optional[pulumi.Input[
        'RecurringTimeWindowArgs']]):
        pulumi.set(self, 'recurring_window', value)


@pulumi.input_type
class ManagedPrometheusConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        ManagedPrometheusConfig defines the configuration for Google Cloud Managed Service for Prometheus.
        :param pulumi.Input[bool] enabled: Enable Managed Collection.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Enable Managed Collection.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class MasterAuthorizedNetworksConfigArgs:

    def __init__(__self__, *, cidr_blocks: Optional[pulumi.Input[Sequence[
        pulumi.Input['CidrBlockArgs']]]]=None, enabled: Optional[pulumi.
        Input[bool]]=None, gcp_public_cidrs_access_enabled: Optional[pulumi
        .Input[bool]]=None):
        """
        Configuration options for the master authorized networks feature. Enabled master authorized networks will disallow all external traffic to access Kubernetes master through HTTPS except traffic from the given CIDR blocks, Google Compute Engine Public IPs and Google Prod IPs.
        :param pulumi.Input[Sequence[pulumi.Input['CidrBlockArgs']]] cidr_blocks: cidr_blocks define up to 10 external networks that could access Kubernetes master through HTTPS.
        :param pulumi.Input[bool] enabled: Whether or not master authorized networks is enabled.
        :param pulumi.Input[bool] gcp_public_cidrs_access_enabled: Whether master is accessbile via Google Compute Engine Public IP addresses.
        """
        if cidr_blocks is not None:
            pulumi.set(__self__, 'cidr_blocks', cidr_blocks)
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)
        if gcp_public_cidrs_access_enabled is not None:
            pulumi.set(__self__, 'gcp_public_cidrs_access_enabled',
                gcp_public_cidrs_access_enabled)

    @property
    @pulumi.getter(name='cidrBlocks')
    def cidr_blocks(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[
        'CidrBlockArgs']]]]:
        """
        cidr_blocks define up to 10 external networks that could access Kubernetes master through HTTPS.
        """
        return pulumi.get(self, 'cidr_blocks')

    @cidr_blocks.setter
    def cidr_blocks(self, value: Optional[pulumi.Input[Sequence[pulumi.
        Input['CidrBlockArgs']]]]):
        pulumi.set(self, 'cidr_blocks', value)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether or not master authorized networks is enabled.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)

    @property
    @pulumi.getter(name='gcpPublicCidrsAccessEnabled')
    def gcp_public_cidrs_access_enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether master is accessbile via Google Compute Engine Public IP addresses.
        """
        return pulumi.get(self, 'gcp_public_cidrs_access_enabled')

    @gcp_public_cidrs_access_enabled.setter
    def gcp_public_cidrs_access_enabled(self, value: Optional[pulumi.Input[
        bool]]):
        pulumi.set(self, 'gcp_public_cidrs_access_enabled', value)


@pulumi.input_type
class MasterAuthArgs:

    def __init__(__self__, *, client_certificate_config: Optional[pulumi.
        Input['ClientCertificateConfigArgs']]=None, cluster_ca_certificate:
        Optional[pulumi.Input[str]]=None, password: Optional[pulumi.Input[
        str]]=None, username: Optional[pulumi.Input[str]]=None):
        """
        The authentication information for accessing the master endpoint. Authentication can be done using HTTP basic auth or using client certificates.
        :param pulumi.Input['ClientCertificateConfigArgs'] client_certificate_config: Configuration for client certificate authentication on the cluster. For clusters before v1.12, if no configuration is specified, a client certificate is issued.
        :param pulumi.Input[str] password: The password to use for HTTP basic authentication to the master endpoint. Because the master endpoint is open to the Internet, you should create a strong password. If a password is provided for cluster creation, username must be non-empty. Warning: basic authentication is deprecated, and will be removed in GKE control plane versions 1.19 and newer. For a list of recommended authentication methods, see: https://cloud.google.com/kubernetes-engine/docs/how-to/api-server-authentication
        :param pulumi.Input[str] username: The username to use for HTTP basic authentication to the master endpoint. For clusters v1.6.0 and later, basic authentication can be disabled by leaving username unspecified (or setting it to the empty string). Warning: basic authentication is deprecated, and will be removed in GKE control plane versions 1.19 and newer. For a list of recommended authentication methods, see: https://cloud.google.com/kubernetes-engine/docs/how-to/api-server-authentication
        """
        if client_certificate_config is not None:
            pulumi.set(__self__, 'client_certificate_config',
                client_certificate_config)
        if cluster_ca_certificate is not None:
            pulumi.set(__self__, 'cluster_ca_certificate',
                cluster_ca_certificate)
        if password is not None:
            pulumi.set(__self__, 'password', password)
        if username is not None:
            pulumi.set(__self__, 'username', username)

    @property
    @pulumi.getter(name='clientCertificateConfig')
    def client_certificate_config(self) ->Optional[pulumi.Input[
        'ClientCertificateConfigArgs']]:
        """
        Configuration for client certificate authentication on the cluster. For clusters before v1.12, if no configuration is specified, a client certificate is issued.
        """
        return pulumi.get(self, 'client_certificate_config')

    @client_certificate_config.setter
    def client_certificate_config(self, value: Optional[pulumi.Input[
        'ClientCertificateConfigArgs']]):
        pulumi.set(self, 'client_certificate_config', value)

    @property
    @pulumi.getter(name='clusterCaCertificate')
    def cluster_ca_certificate(self) ->Optional[pulumi.Input[str]]:
        return pulumi.get(self, 'cluster_ca_certificate')

    @cluster_ca_certificate.setter
    def cluster_ca_certificate(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'cluster_ca_certificate', value)

    @property
    @pulumi.getter
    def password(self) ->Optional[pulumi.Input[str]]:
        """
        The password to use for HTTP basic authentication to the master endpoint. Because the master endpoint is open to the Internet, you should create a strong password. If a password is provided for cluster creation, username must be non-empty. Warning: basic authentication is deprecated, and will be removed in GKE control plane versions 1.19 and newer. For a list of recommended authentication methods, see: https://cloud.google.com/kubernetes-engine/docs/how-to/api-server-authentication
        """
        return pulumi.get(self, 'password')

    @password.setter
    def password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'password', value)

    @property
    @pulumi.getter
    def username(self) ->Optional[pulumi.Input[str]]:
        """
        The username to use for HTTP basic authentication to the master endpoint. For clusters v1.6.0 and later, basic authentication can be disabled by leaving username unspecified (or setting it to the empty string). Warning: basic authentication is deprecated, and will be removed in GKE control plane versions 1.19 and newer. For a list of recommended authentication methods, see: https://cloud.google.com/kubernetes-engine/docs/how-to/api-server-authentication
        """
        return pulumi.get(self, 'username')

    @username.setter
    def username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'username', value)


@pulumi.input_type
class MasterArgs:

    def __init__(__self__):
        """
        Master is the configuration for components on master.
        """
        pass


@pulumi.input_type
class MaxPodsConstraintArgs:

    def __init__(__self__, *, max_pods_per_node: Optional[pulumi.Input[str]
        ]=None):
        """
        Constraints applied to pods.
        :param pulumi.Input[str] max_pods_per_node: Constraint enforced on the max num of pods per node.
        """
        if max_pods_per_node is not None:
            pulumi.set(__self__, 'max_pods_per_node', max_pods_per_node)

    @property
    @pulumi.getter(name='maxPodsPerNode')
    def max_pods_per_node(self) ->Optional[pulumi.Input[str]]:
        """
        Constraint enforced on the max num of pods per node.
        """
        return pulumi.get(self, 'max_pods_per_node')

    @max_pods_per_node.setter
    def max_pods_per_node(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'max_pods_per_node', value)


@pulumi.input_type
class MeshCertificatesArgs:

    def __init__(__self__, *, enable_certificates: Optional[pulumi.Input[
        bool]]=None):
        """
        Configuration for issuance of mTLS keys and certificates to Kubernetes pods.
        :param pulumi.Input[bool] enable_certificates: enable_certificates controls issuance of workload mTLS certificates. If set, the GKE Workload Identity Certificates controller and node agent will be deployed in the cluster, which can then be configured by creating a WorkloadCertificateConfig Custom Resource. Requires Workload Identity (workload_pool must be non-empty).
        """
        if enable_certificates is not None:
            pulumi.set(__self__, 'enable_certificates', enable_certificates)

    @property
    @pulumi.getter(name='enableCertificates')
    def enable_certificates(self) ->Optional[pulumi.Input[bool]]:
        """
        enable_certificates controls issuance of workload mTLS certificates. If set, the GKE Workload Identity Certificates controller and node agent will be deployed in the cluster, which can then be configured by creating a WorkloadCertificateConfig Custom Resource. Requires Workload Identity (workload_pool must be non-empty).
        """
        return pulumi.get(self, 'enable_certificates')

    @enable_certificates.setter
    def enable_certificates(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_certificates', value)


@pulumi.input_type
class MonitoringComponentConfigArgs:

    def __init__(__self__, *, enable_components: Optional[pulumi.Input[
        Sequence[pulumi.Input[
        'MonitoringComponentConfigEnableComponentsItem']]]]=None):
        """
        MonitoringComponentConfig is cluster monitoring component configuration.
        :param pulumi.Input[Sequence[pulumi.Input['MonitoringComponentConfigEnableComponentsItem']]] enable_components: Select components to collect metrics. An empty set would disable all monitoring.
        """
        if enable_components is not None:
            pulumi.set(__self__, 'enable_components', enable_components)

    @property
    @pulumi.getter(name='enableComponents')
    def enable_components(self) ->Optional[pulumi.Input[Sequence[pulumi.
        Input['MonitoringComponentConfigEnableComponentsItem']]]]:
        """
        Select components to collect metrics. An empty set would disable all monitoring.
        """
        return pulumi.get(self, 'enable_components')

    @enable_components.setter
    def enable_components(self, value: Optional[pulumi.Input[Sequence[
        pulumi.Input['MonitoringComponentConfigEnableComponentsItem']]]]):
        pulumi.set(self, 'enable_components', value)


@pulumi.input_type
class MonitoringConfigArgs:

    def __init__(__self__, *, component_config: Optional[pulumi.Input[
        'MonitoringComponentConfigArgs']]=None, managed_prometheus_config:
        Optional[pulumi.Input['ManagedPrometheusConfigArgs']]=None):
        """
        MonitoringConfig is cluster monitoring configuration.
        :param pulumi.Input['MonitoringComponentConfigArgs'] component_config: Monitoring components configuration
        :param pulumi.Input['ManagedPrometheusConfigArgs'] managed_prometheus_config: Enable Google Cloud Managed Service for Prometheus in the cluster.
        """
        if component_config is not None:
            pulumi.set(__self__, 'component_config', component_config)
        if managed_prometheus_config is not None:
            pulumi.set(__self__, 'managed_prometheus_config',
                managed_prometheus_config)

    @property
    @pulumi.getter(name='componentConfig')
    def component_config(self) ->Optional[pulumi.Input[
        'MonitoringComponentConfigArgs']]:
        """
        Monitoring components configuration
        """
        return pulumi.get(self, 'component_config')

    @component_config.setter
    def component_config(self, value: Optional[pulumi.Input[
        'MonitoringComponentConfigArgs']]):
        pulumi.set(self, 'component_config', value)

    @property
    @pulumi.getter(name='managedPrometheusConfig')
    def managed_prometheus_config(self) ->Optional[pulumi.Input[
        'ManagedPrometheusConfigArgs']]:
        """
        Enable Google Cloud Managed Service for Prometheus in the cluster.
        """
        return pulumi.get(self, 'managed_prometheus_config')

    @managed_prometheus_config.setter
    def managed_prometheus_config(self, value: Optional[pulumi.Input[
        'ManagedPrometheusConfigArgs']]):
        pulumi.set(self, 'managed_prometheus_config', value)


@pulumi.input_type
class NetworkConfigArgs:

    def __init__(__self__, *, datapath_provider: Optional[pulumi.Input[
        'NetworkConfigDatapathProvider']]=None, default_snat_status:
        Optional[pulumi.Input['DefaultSnatStatusArgs']]=None, dns_config:
        Optional[pulumi.Input['DNSConfigArgs']]=None,
        enable_intra_node_visibility: Optional[pulumi.Input[bool]]=None,
        enable_l4ilb_subsetting: Optional[pulumi.Input[bool]]=None,
        gateway_api_config: Optional[pulumi.Input['GatewayAPIConfigArgs']]=
        None, private_ipv6_google_access: Optional[pulumi.Input[
        'NetworkConfigPrivateIpv6GoogleAccess']]=None,
        service_external_ips_config: Optional[pulumi.Input[
        'ServiceExternalIPsConfigArgs']]=None):
        """
        NetworkConfig reports the relative names of network & subnetwork.
        :param pulumi.Input['NetworkConfigDatapathProvider'] datapath_provider: The desired datapath provider for this cluster. By default, uses the IPTables-based kube-proxy implementation.
        :param pulumi.Input['DefaultSnatStatusArgs'] default_snat_status: Whether the cluster disables default in-node sNAT rules. In-node sNAT rules will be disabled when default_snat_status is disabled. When disabled is set to false, default IP masquerade rules will be applied to the nodes to prevent sNAT on cluster internal traffic.
        :param pulumi.Input['DNSConfigArgs'] dns_config: DNSConfig contains clusterDNS config for this cluster.
        :param pulumi.Input[bool] enable_intra_node_visibility: Whether Intra-node visibility is enabled for this cluster. This makes same node pod to pod traffic visible for VPC network.
        :param pulumi.Input[bool] enable_l4ilb_subsetting: Whether L4ILB Subsetting is enabled for this cluster.
        :param pulumi.Input['GatewayAPIConfigArgs'] gateway_api_config: GatewayAPIConfig contains the desired config of Gateway API on this cluster.
        :param pulumi.Input['NetworkConfigPrivateIpv6GoogleAccess'] private_ipv6_google_access: The desired state of IPv6 connectivity to Google Services. By default, no private IPv6 access to or from Google Services (all access will be via IPv4)
        :param pulumi.Input['ServiceExternalIPsConfigArgs'] service_external_ips_config: ServiceExternalIPsConfig specifies if services with externalIPs field are blocked or not.
        """
        if datapath_provider is not None:
            pulumi.set(__self__, 'datapath_provider', datapath_provider)
        if default_snat_status is not None:
            pulumi.set(__self__, 'default_snat_status', default_snat_status)
        if dns_config is not None:
            pulumi.set(__self__, 'dns_config', dns_config)
        if enable_intra_node_visibility is not None:
            pulumi.set(__self__, 'enable_intra_node_visibility',
                enable_intra_node_visibility)
        if enable_l4ilb_subsetting is not None:
            pulumi.set(__self__, 'enable_l4ilb_subsetting',
                enable_l4ilb_subsetting)
        if gateway_api_config is not None:
            pulumi.set(__self__, 'gateway_api_config', gateway_api_config)
        if private_ipv6_google_access is not None:
            pulumi.set(__self__, 'private_ipv6_google_access',
                private_ipv6_google_access)
        if service_external_ips_config is not None:
            pulumi.set(__self__, 'service_external_ips_config',
                service_external_ips_config)

    @property
    @pulumi.getter(name='datapathProvider')
    def datapath_provider(self) ->Optional[pulumi.Input[
        'NetworkConfigDatapathProvider']]:
        """
        The desired datapath provider for this cluster. By default, uses the IPTables-based kube-proxy implementation.
        """
        return pulumi.get(self, 'datapath_provider')

    @datapath_provider.setter
    def datapath_provider(self, value: Optional[pulumi.Input[
        'NetworkConfigDatapathProvider']]):
        pulumi.set(self, 'datapath_provider', value)

    @property
    @pulumi.getter(name='defaultSnatStatus')
    def default_snat_status(self) ->Optional[pulumi.Input[
        'DefaultSnatStatusArgs']]:
        """
        Whether the cluster disables default in-node sNAT rules. In-node sNAT rules will be disabled when default_snat_status is disabled. When disabled is set to false, default IP masquerade rules will be applied to the nodes to prevent sNAT on cluster internal traffic.
        """
        return pulumi.get(self, 'default_snat_status')

    @default_snat_status.setter
    def default_snat_status(self, value: Optional[pulumi.Input[
        'DefaultSnatStatusArgs']]):
        pulumi.set(self, 'default_snat_status', value)

    @property
    @pulumi.getter(name='dnsConfig')
    def dns_config(self) ->Optional[pulumi.Input['DNSConfigArgs']]:
        """
        DNSConfig contains clusterDNS config for this cluster.
        """
        return pulumi.get(self, 'dns_config')

    @dns_config.setter
    def dns_config(self, value: Optional[pulumi.Input['DNSConfigArgs']]):
        pulumi.set(self, 'dns_config', value)

    @property
    @pulumi.getter(name='enableIntraNodeVisibility')
    def enable_intra_node_visibility(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Intra-node visibility is enabled for this cluster. This makes same node pod to pod traffic visible for VPC network.
        """
        return pulumi.get(self, 'enable_intra_node_visibility')

    @enable_intra_node_visibility.setter
    def enable_intra_node_visibility(self, value: Optional[pulumi.Input[bool]]
        ):
        pulumi.set(self, 'enable_intra_node_visibility', value)

    @property
    @pulumi.getter(name='enableL4ilbSubsetting')
    def enable_l4ilb_subsetting(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether L4ILB Subsetting is enabled for this cluster.
        """
        return pulumi.get(self, 'enable_l4ilb_subsetting')

    @enable_l4ilb_subsetting.setter
    def enable_l4ilb_subsetting(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_l4ilb_subsetting', value)

    @property
    @pulumi.getter(name='gatewayApiConfig')
    def gateway_api_config(self) ->Optional[pulumi.Input[
        'GatewayAPIConfigArgs']]:
        """
        GatewayAPIConfig contains the desired config of Gateway API on this cluster.
        """
        return pulumi.get(self, 'gateway_api_config')

    @gateway_api_config.setter
    def gateway_api_config(self, value: Optional[pulumi.Input[
        'GatewayAPIConfigArgs']]):
        pulumi.set(self, 'gateway_api_config', value)

    @property
    @pulumi.getter(name='privateIpv6GoogleAccess')
    def private_ipv6_google_access(self) ->Optional[pulumi.Input[
        'NetworkConfigPrivateIpv6GoogleAccess']]:
        """
        The desired state of IPv6 connectivity to Google Services. By default, no private IPv6 access to or from Google Services (all access will be via IPv4)
        """
        return pulumi.get(self, 'private_ipv6_google_access')

    @private_ipv6_google_access.setter
    def private_ipv6_google_access(self, value: Optional[pulumi.Input[
        'NetworkConfigPrivateIpv6GoogleAccess']]):
        pulumi.set(self, 'private_ipv6_google_access', value)

    @property
    @pulumi.getter(name='serviceExternalIpsConfig')
    def service_external_ips_config(self) ->Optional[pulumi.Input[
        'ServiceExternalIPsConfigArgs']]:
        """
        ServiceExternalIPsConfig specifies if services with externalIPs field are blocked or not.
        """
        return pulumi.get(self, 'service_external_ips_config')

    @service_external_ips_config.setter
    def service_external_ips_config(self, value: Optional[pulumi.Input[
        'ServiceExternalIPsConfigArgs']]):
        pulumi.set(self, 'service_external_ips_config', value)


@pulumi.input_type
class NetworkPerformanceConfigArgs:

    def __init__(__self__, *, external_ip_egress_bandwidth_tier: Optional[
        pulumi.Input[
        'NetworkPerformanceConfigExternalIpEgressBandwidthTier']]=None,
        total_egress_bandwidth_tier: Optional[pulumi.Input[
        'NetworkPerformanceConfigTotalEgressBandwidthTier']]=None):
        """
        Configuration of all network bandwidth tiers
        :param pulumi.Input['NetworkPerformanceConfigExternalIpEgressBandwidthTier'] external_ip_egress_bandwidth_tier: Specifies the network bandwidth tier for the NodePool for traffic to external/public IP addresses.
        :param pulumi.Input['NetworkPerformanceConfigTotalEgressBandwidthTier'] total_egress_bandwidth_tier: Specifies the total network bandwidth tier for the NodePool.
        """
        if external_ip_egress_bandwidth_tier is not None:
            pulumi.set(__self__, 'external_ip_egress_bandwidth_tier',
                external_ip_egress_bandwidth_tier)
        if total_egress_bandwidth_tier is not None:
            pulumi.set(__self__, 'total_egress_bandwidth_tier',
                total_egress_bandwidth_tier)

    @property
    @pulumi.getter(name='externalIpEgressBandwidthTier')
    def external_ip_egress_bandwidth_tier(self) ->Optional[pulumi.Input[
        'NetworkPerformanceConfigExternalIpEgressBandwidthTier']]:
        """
        Specifies the network bandwidth tier for the NodePool for traffic to external/public IP addresses.
        """
        return pulumi.get(self, 'external_ip_egress_bandwidth_tier')

    @external_ip_egress_bandwidth_tier.setter
    def external_ip_egress_bandwidth_tier(self, value: Optional[pulumi.
        Input['NetworkPerformanceConfigExternalIpEgressBandwidthTier']]):
        pulumi.set(self, 'external_ip_egress_bandwidth_tier', value)

    @property
    @pulumi.getter(name='totalEgressBandwidthTier')
    def total_egress_bandwidth_tier(self) ->Optional[pulumi.Input[
        'NetworkPerformanceConfigTotalEgressBandwidthTier']]:
        """
        Specifies the total network bandwidth tier for the NodePool.
        """
        return pulumi.get(self, 'total_egress_bandwidth_tier')

    @total_egress_bandwidth_tier.setter
    def total_egress_bandwidth_tier(self, value: Optional[pulumi.Input[
        'NetworkPerformanceConfigTotalEgressBandwidthTier']]):
        pulumi.set(self, 'total_egress_bandwidth_tier', value)


@pulumi.input_type
class NetworkPolicyConfigArgs:

    def __init__(__self__, *, disabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for NetworkPolicy. This only tracks whether the addon is enabled or not on the Master, it does not track whether network policy is enabled for the nodes.
        :param pulumi.Input[bool] disabled: Whether NetworkPolicy is enabled for this cluster.
        """
        if disabled is not None:
            pulumi.set(__self__, 'disabled', disabled)

    @property
    @pulumi.getter
    def disabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether NetworkPolicy is enabled for this cluster.
        """
        return pulumi.get(self, 'disabled')

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'disabled', value)


@pulumi.input_type
class NetworkPolicyArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None,
        provider: Optional[pulumi.Input['NetworkPolicyProvider']]=None):
        """
        Configuration options for the NetworkPolicy feature. https://kubernetes.io/docs/concepts/services-networking/networkpolicies/
        :param pulumi.Input[bool] enabled: Whether network policy is enabled on the cluster.
        :param pulumi.Input['NetworkPolicyProvider'] provider: The selected network policy provider.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)
        if provider is not None:
            pulumi.set(__self__, 'provider', provider)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether network policy is enabled on the cluster.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)

    @property
    @pulumi.getter
    def provider(self) ->Optional[pulumi.Input['NetworkPolicyProvider']]:
        """
        The selected network policy provider.
        """
        return pulumi.get(self, 'provider')

    @provider.setter
    def provider(self, value: Optional[pulumi.Input['NetworkPolicyProvider']]):
        pulumi.set(self, 'provider', value)


@pulumi.input_type
class NetworkTagsArgs:

    def __init__(__self__, *, tags: Optional[pulumi.Input[Sequence[pulumi.
        Input[str]]]]=None):
        """
        Collection of Compute Engine network tags that can be applied to a node's underlying VM instance. (See `tags` field in [`NodeConfig`](/kubernetes-engine/docs/reference/rest/v1/NodeConfig)).
        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: List of network tags.
        """
        if tags is not None:
            pulumi.set(__self__, 'tags', tags)

    @property
    @pulumi.getter
    def tags(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of network tags.
        """
        return pulumi.get(self, 'tags')

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, 'tags', value)


@pulumi.input_type
class NodeConfigDefaultsArgs:

    def __init__(__self__, *, gcfs_config: Optional[pulumi.Input[
        'GcfsConfigArgs']]=None, logging_config: Optional[pulumi.Input[
        'NodePoolLoggingConfigArgs']]=None):
        """
        Subset of NodeConfig message that has defaults.
        :param pulumi.Input['GcfsConfigArgs'] gcfs_config: GCFS (Google Container File System, also known as Riptide) options.
        :param pulumi.Input['NodePoolLoggingConfigArgs'] logging_config: Logging configuration for node pools.
        """
        if gcfs_config is not None:
            pulumi.set(__self__, 'gcfs_config', gcfs_config)
        if logging_config is not None:
            pulumi.set(__self__, 'logging_config', logging_config)

    @property
    @pulumi.getter(name='gcfsConfig')
    def gcfs_config(self) ->Optional[pulumi.Input['GcfsConfigArgs']]:
        """
        GCFS (Google Container File System, also known as Riptide) options.
        """
        return pulumi.get(self, 'gcfs_config')

    @gcfs_config.setter
    def gcfs_config(self, value: Optional[pulumi.Input['GcfsConfigArgs']]):
        pulumi.set(self, 'gcfs_config', value)

    @property
    @pulumi.getter(name='loggingConfig')
    def logging_config(self) ->Optional[pulumi.Input[
        'NodePoolLoggingConfigArgs']]:
        """
        Logging configuration for node pools.
        """
        return pulumi.get(self, 'logging_config')

    @logging_config.setter
    def logging_config(self, value: Optional[pulumi.Input[
        'NodePoolLoggingConfigArgs']]):
        pulumi.set(self, 'logging_config', value)


@pulumi.input_type
class NodeConfigArgs:

    def __init__(__self__, *, accelerators: Optional[pulumi.Input[Sequence[
        pulumi.Input['AcceleratorConfigArgs']]]]=None,
        advanced_machine_features: Optional[pulumi.Input[
        'AdvancedMachineFeaturesArgs']]=None, boot_disk_kms_key: Optional[
        pulumi.Input[str]]=None, confidential_nodes: Optional[pulumi.Input[
        'ConfidentialNodesArgs']]=None, disk_size_gb: Optional[pulumi.Input
        [int]]=None, disk_type: Optional[pulumi.Input[str]]=None,
        ephemeral_storage_config: Optional[pulumi.Input[
        'EphemeralStorageConfigArgs']]=None,
        ephemeral_storage_local_ssd_config: Optional[pulumi.Input[
        'EphemeralStorageLocalSsdConfigArgs']]=None, fast_socket: Optional[
        pulumi.Input['FastSocketArgs']]=None, gcfs_config: Optional[pulumi.
        Input['GcfsConfigArgs']]=None, gvnic: Optional[pulumi.Input[
        'VirtualNICArgs']]=None, image_type: Optional[pulumi.Input[str]]=
        None, kubelet_config: Optional[pulumi.Input['NodeKubeletConfigArgs'
        ]]=None, labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[
        str]]]]=None, linux_node_config: Optional[pulumi.Input[
        'LinuxNodeConfigArgs']]=None, local_nvme_ssd_block_config: Optional
        [pulumi.Input['LocalNvmeSsdBlockConfigArgs']]=None, local_ssd_count:
        Optional[pulumi.Input[int]]=None, logging_config: Optional[pulumi.
        Input['NodePoolLoggingConfigArgs']]=None, machine_type: Optional[
        pulumi.Input[str]]=None, metadata: Optional[pulumi.Input[Mapping[
        str, pulumi.Input[str]]]]=None, min_cpu_platform: Optional[pulumi.
        Input[str]]=None, node_group: Optional[pulumi.Input[str]]=None,
        oauth_scopes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=
        None, preemptible: Optional[pulumi.Input[bool]]=None,
        reservation_affinity: Optional[pulumi.Input[
        'ReservationAffinityArgs']]=None, resource_labels: Optional[pulumi.
        Input[Mapping[str, pulumi.Input[str]]]]=None, sandbox_config:
        Optional[pulumi.Input['SandboxConfigArgs']]=None, service_account:
        Optional[pulumi.Input[str]]=None, shielded_instance_config:
        Optional[pulumi.Input['ShieldedInstanceConfigArgs']]=None, spot:
        Optional[pulumi.Input[bool]]=None, tags: Optional[pulumi.Input[
        Sequence[pulumi.Input[str]]]]=None, taints: Optional[pulumi.Input[
        Sequence[pulumi.Input['NodeTaintArgs']]]]=None, windows_node_config:
        Optional[pulumi.Input['WindowsNodeConfigArgs']]=None,
        workload_metadata_config: Optional[pulumi.Input[
        'WorkloadMetadataConfigArgs']]=None):
        """
        Parameters that describe the nodes in a cluster. GKE Autopilot clusters do not recognize parameters in `NodeConfig`. Use AutoprovisioningNodePoolDefaults instead.
        :param pulumi.Input[Sequence[pulumi.Input['AcceleratorConfigArgs']]] accelerators: A list of hardware accelerators to be attached to each node. See https://cloud.google.com/compute/docs/gpus for more information about support for GPUs.
        :param pulumi.Input['AdvancedMachineFeaturesArgs'] advanced_machine_features: Advanced features for the Compute Engine VM.
        :param pulumi.Input[str] boot_disk_kms_key:  The Customer Managed Encryption Key used to encrypt the boot disk attached to each node in the node pool. This should be of the form projects/[KEY_PROJECT_ID]/locations/[LOCATION]/keyRings/[RING_NAME]/cryptoKeys/[KEY_NAME]. For more information about protecting resources with Cloud KMS Keys please see: https://cloud.google.com/compute/docs/disks/customer-managed-encryption
        :param pulumi.Input['ConfidentialNodesArgs'] confidential_nodes: Confidential nodes config. All the nodes in the node pool will be Confidential VM once enabled.
        :param pulumi.Input[int] disk_size_gb: Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB. If unspecified, the default disk size is 100GB.
        :param pulumi.Input[str] disk_type: Type of the disk attached to each node (e.g. 'pd-standard', 'pd-ssd' or 'pd-balanced') If unspecified, the default disk type is 'pd-standard'
        :param pulumi.Input['EphemeralStorageConfigArgs'] ephemeral_storage_config: Parameters for the ephemeral storage filesystem. If unspecified, ephemeral storage is backed by the boot disk.
        :param pulumi.Input['EphemeralStorageLocalSsdConfigArgs'] ephemeral_storage_local_ssd_config: Parameters for the node ephemeral storage using Local SSDs. If unspecified, ephemeral storage is backed by the boot disk. This field is functionally equivalent to the ephemeral_storage_config
        :param pulumi.Input['FastSocketArgs'] fast_socket: Enable or disable NCCL fast socket for the node pool.
        :param pulumi.Input['GcfsConfigArgs'] gcfs_config: GCFS (Google Container File System) configs.
        :param pulumi.Input['VirtualNICArgs'] gvnic: Enable or disable gvnic on the node pool.
        :param pulumi.Input[str] image_type: The image type to use for this node. Note that for a given image type, the latest version of it will be used. Please see https://cloud.google.com/kubernetes-engine/docs/concepts/node-images for available image types.
        :param pulumi.Input['NodeKubeletConfigArgs'] kubelet_config: Node kubelet configs.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: The map of Kubernetes labels (key/value pairs) to be applied to each node. These will added in addition to any default label(s) that Kubernetes may apply to the node. In case of conflict in label keys, the applied set may differ depending on the Kubernetes version -- it's best to assume the behavior is undefined and conflicts should be avoided. For more information, including usage and the valid values, see: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/
        :param pulumi.Input['LinuxNodeConfigArgs'] linux_node_config: Parameters that can be configured on Linux nodes.
        :param pulumi.Input['LocalNvmeSsdBlockConfigArgs'] local_nvme_ssd_block_config: Parameters for using raw-block Local NVMe SSDs.
        :param pulumi.Input[int] local_ssd_count: The number of local SSD disks to be attached to the node. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        :param pulumi.Input['NodePoolLoggingConfigArgs'] logging_config: Logging configuration.
        :param pulumi.Input[str] machine_type: The name of a Google Compute Engine [machine type](https://cloud.google.com/compute/docs/machine-types). If unspecified, the default machine type is `e2-medium`.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] metadata: The metadata key/value pairs assigned to instances in the cluster. Keys must conform to the regexp `[a-zA-Z0-9-_]+` and be less than 128 bytes in length. These are reflected as part of a URL in the metadata server. Additionally, to avoid ambiguity, keys must not conflict with any other metadata keys for the project or be one of the reserved keys: - "cluster-location" - "cluster-name" - "cluster-uid" - "configure-sh" - "containerd-configure-sh" - "enable-oslogin" - "gci-ensure-gke-docker" - "gci-metrics-enabled" - "gci-update-strategy" - "instance-template" - "kube-env" - "startup-script" - "user-data" - "disable-address-manager" - "windows-startup-script-ps1" - "common-psm1" - "k8s-node-setup-psm1" - "install-ssh-psm1" - "user-profile-psm1" Values are free-form strings, and only have meaning as interpreted by the image running in the instance. The only restriction placed on them is that each value's size must be less than or equal to 32 KB. The total size of all keys and values must be less than 512 KB.
        :param pulumi.Input[str] min_cpu_platform: Minimum CPU platform to be used by this instance. The instance may be scheduled on the specified or newer CPU platform. Applicable values are the friendly names of CPU platforms, such as `minCpuPlatform: "Intel Haswell"` or `minCpuPlatform: "Intel Sandy Bridge"`. For more information, read [how to specify min CPU platform](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform).
        :param pulumi.Input[str] node_group: Setting this field will assign instances of this pool to run on the specified node group. This is useful for running workloads on [sole tenant nodes](https://cloud.google.com/compute/docs/nodes/sole-tenant-nodes).
        :param pulumi.Input[Sequence[pulumi.Input[str]]] oauth_scopes: The set of Google API scopes to be made available on all of the node VMs under the "default" service account. The following scopes are recommended, but not required, and by default are not included: * `https://www.googleapis.com/auth/compute` is required for mounting persistent storage on your nodes. * `https://www.googleapis.com/auth/devstorage.read_only` is required for communicating with **gcr.io** (the [Google Container Registry](https://cloud.google.com/container-registry/)). If unspecified, no scopes are added, unless Cloud Logging or Cloud Monitoring are enabled, in which case their required scopes will be added.
        :param pulumi.Input[bool] preemptible: Whether the nodes are created as preemptible VM instances. See: https://cloud.google.com/compute/docs/instances/preemptible for more inforamtion about preemptible VM instances.
        :param pulumi.Input['ReservationAffinityArgs'] reservation_affinity: The optional reservation affinity. Setting this field will apply the specified [Zonal Compute Reservation](https://cloud.google.com/compute/docs/instances/reserving-zonal-resources) to this node pool.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] resource_labels: The resource labels for the node pool to use to annotate any related Google Compute Engine resources.
        :param pulumi.Input['SandboxConfigArgs'] sandbox_config: Sandbox configuration for this node.
        :param pulumi.Input[str] service_account: The Google Cloud Platform Service Account to be used by the node VMs. Specify the email address of the Service Account; otherwise, if no Service Account is specified, the "default" service account is used.
        :param pulumi.Input['ShieldedInstanceConfigArgs'] shielded_instance_config: Shielded Instance options.
        :param pulumi.Input[bool] spot: Spot flag for enabling Spot VM, which is a rebrand of the existing preemptible flag.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: The list of instance tags applied to all nodes. Tags are used to identify valid sources or targets for network firewalls and are specified by the client during cluster or node pool creation. Each tag within the list must comply with RFC1035.
        :param pulumi.Input[Sequence[pulumi.Input['NodeTaintArgs']]] taints: List of kubernetes taints to be applied to each node. For more information, including usage and the valid values, see: https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/
        :param pulumi.Input['WindowsNodeConfigArgs'] windows_node_config: Parameters that can be configured on Windows nodes.
        :param pulumi.Input['WorkloadMetadataConfigArgs'] workload_metadata_config: The workload metadata configuration for this node.
        """
        if accelerators is not None:
            pulumi.set(__self__, 'accelerators', accelerators)
        if advanced_machine_features is not None:
            pulumi.set(__self__, 'advanced_machine_features',
                advanced_machine_features)
        if boot_disk_kms_key is not None:
            pulumi.set(__self__, 'boot_disk_kms_key', boot_disk_kms_key)
        if confidential_nodes is not None:
            pulumi.set(__self__, 'confidential_nodes', confidential_nodes)
        if disk_size_gb is not None:
            pulumi.set(__self__, 'disk_size_gb', disk_size_gb)
        if disk_type is not None:
            pulumi.set(__self__, 'disk_type', disk_type)
        if ephemeral_storage_config is not None:
            pulumi.set(__self__, 'ephemeral_storage_config',
                ephemeral_storage_config)
        if ephemeral_storage_local_ssd_config is not None:
            pulumi.set(__self__, 'ephemeral_storage_local_ssd_config',
                ephemeral_storage_local_ssd_config)
        if fast_socket is not None:
            pulumi.set(__self__, 'fast_socket', fast_socket)
        if gcfs_config is not None:
            pulumi.set(__self__, 'gcfs_config', gcfs_config)
        if gvnic is not None:
            pulumi.set(__self__, 'gvnic', gvnic)
        if image_type is not None:
            pulumi.set(__self__, 'image_type', image_type)
        if kubelet_config is not None:
            pulumi.set(__self__, 'kubelet_config', kubelet_config)
        if labels is not None:
            pulumi.set(__self__, 'labels', labels)
        if linux_node_config is not None:
            pulumi.set(__self__, 'linux_node_config', linux_node_config)
        if local_nvme_ssd_block_config is not None:
            pulumi.set(__self__, 'local_nvme_ssd_block_config',
                local_nvme_ssd_block_config)
        if local_ssd_count is not None:
            pulumi.set(__self__, 'local_ssd_count', local_ssd_count)
        if logging_config is not None:
            pulumi.set(__self__, 'logging_config', logging_config)
        if machine_type is not None:
            pulumi.set(__self__, 'machine_type', machine_type)
        if metadata is not None:
            pulumi.set(__self__, 'metadata', metadata)
        if min_cpu_platform is not None:
            pulumi.set(__self__, 'min_cpu_platform', min_cpu_platform)
        if node_group is not None:
            pulumi.set(__self__, 'node_group', node_group)
        if oauth_scopes is not None:
            pulumi.set(__self__, 'oauth_scopes', oauth_scopes)
        if preemptible is not None:
            pulumi.set(__self__, 'preemptible', preemptible)
        if reservation_affinity is not None:
            pulumi.set(__self__, 'reservation_affinity', reservation_affinity)
        if resource_labels is not None:
            pulumi.set(__self__, 'resource_labels', resource_labels)
        if sandbox_config is not None:
            pulumi.set(__self__, 'sandbox_config', sandbox_config)
        if service_account is not None:
            pulumi.set(__self__, 'service_account', service_account)
        if shielded_instance_config is not None:
            pulumi.set(__self__, 'shielded_instance_config',
                shielded_instance_config)
        if spot is not None:
            pulumi.set(__self__, 'spot', spot)
        if tags is not None:
            pulumi.set(__self__, 'tags', tags)
        if taints is not None:
            pulumi.set(__self__, 'taints', taints)
        if windows_node_config is not None:
            pulumi.set(__self__, 'windows_node_config', windows_node_config)
        if workload_metadata_config is not None:
            pulumi.set(__self__, 'workload_metadata_config',
                workload_metadata_config)

    @property
    @pulumi.getter
    def accelerators(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[
        'AcceleratorConfigArgs']]]]:
        """
        A list of hardware accelerators to be attached to each node. See https://cloud.google.com/compute/docs/gpus for more information about support for GPUs.
        """
        return pulumi.get(self, 'accelerators')

    @accelerators.setter
    def accelerators(self, value: Optional[pulumi.Input[Sequence[pulumi.
        Input['AcceleratorConfigArgs']]]]):
        pulumi.set(self, 'accelerators', value)

    @property
    @pulumi.getter(name='advancedMachineFeatures')
    def advanced_machine_features(self) ->Optional[pulumi.Input[
        'AdvancedMachineFeaturesArgs']]:
        """
        Advanced features for the Compute Engine VM.
        """
        return pulumi.get(self, 'advanced_machine_features')

    @advanced_machine_features.setter
    def advanced_machine_features(self, value: Optional[pulumi.Input[
        'AdvancedMachineFeaturesArgs']]):
        pulumi.set(self, 'advanced_machine_features', value)

    @property
    @pulumi.getter(name='bootDiskKmsKey')
    def boot_disk_kms_key(self) ->Optional[pulumi.Input[str]]:
        """
         The Customer Managed Encryption Key used to encrypt the boot disk attached to each node in the node pool. This should be of the form projects/[KEY_PROJECT_ID]/locations/[LOCATION]/keyRings/[RING_NAME]/cryptoKeys/[KEY_NAME]. For more information about protecting resources with Cloud KMS Keys please see: https://cloud.google.com/compute/docs/disks/customer-managed-encryption
        """
        return pulumi.get(self, 'boot_disk_kms_key')

    @boot_disk_kms_key.setter
    def boot_disk_kms_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'boot_disk_kms_key', value)

    @property
    @pulumi.getter(name='confidentialNodes')
    def confidential_nodes(self) ->Optional[pulumi.Input[
        'ConfidentialNodesArgs']]:
        """
        Confidential nodes config. All the nodes in the node pool will be Confidential VM once enabled.
        """
        return pulumi.get(self, 'confidential_nodes')

    @confidential_nodes.setter
    def confidential_nodes(self, value: Optional[pulumi.Input[
        'ConfidentialNodesArgs']]):
        pulumi.set(self, 'confidential_nodes', value)

    @property
    @pulumi.getter(name='diskSizeGb')
    def disk_size_gb(self) ->Optional[pulumi.Input[int]]:
        """
        Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB. If unspecified, the default disk size is 100GB.
        """
        return pulumi.get(self, 'disk_size_gb')

    @disk_size_gb.setter
    def disk_size_gb(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'disk_size_gb', value)

    @property
    @pulumi.getter(name='diskType')
    def disk_type(self) ->Optional[pulumi.Input[str]]:
        """
        Type of the disk attached to each node (e.g. 'pd-standard', 'pd-ssd' or 'pd-balanced') If unspecified, the default disk type is 'pd-standard'
        """
        return pulumi.get(self, 'disk_type')

    @disk_type.setter
    def disk_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'disk_type', value)

    @property
    @pulumi.getter(name='ephemeralStorageConfig')
    def ephemeral_storage_config(self) ->Optional[pulumi.Input[
        'EphemeralStorageConfigArgs']]:
        """
        Parameters for the ephemeral storage filesystem. If unspecified, ephemeral storage is backed by the boot disk.
        """
        return pulumi.get(self, 'ephemeral_storage_config')

    @ephemeral_storage_config.setter
    def ephemeral_storage_config(self, value: Optional[pulumi.Input[
        'EphemeralStorageConfigArgs']]):
        pulumi.set(self, 'ephemeral_storage_config', value)

    @property
    @pulumi.getter(name='ephemeralStorageLocalSsdConfig')
    def ephemeral_storage_local_ssd_config(self) ->Optional[pulumi.Input[
        'EphemeralStorageLocalSsdConfigArgs']]:
        """
        Parameters for the node ephemeral storage using Local SSDs. If unspecified, ephemeral storage is backed by the boot disk. This field is functionally equivalent to the ephemeral_storage_config
        """
        return pulumi.get(self, 'ephemeral_storage_local_ssd_config')

    @ephemeral_storage_local_ssd_config.setter
    def ephemeral_storage_local_ssd_config(self, value: Optional[pulumi.
        Input['EphemeralStorageLocalSsdConfigArgs']]):
        pulumi.set(self, 'ephemeral_storage_local_ssd_config', value)

    @property
    @pulumi.getter(name='fastSocket')
    def fast_socket(self) ->Optional[pulumi.Input['FastSocketArgs']]:
        """
        Enable or disable NCCL fast socket for the node pool.
        """
        return pulumi.get(self, 'fast_socket')

    @fast_socket.setter
    def fast_socket(self, value: Optional[pulumi.Input['FastSocketArgs']]):
        pulumi.set(self, 'fast_socket', value)

    @property
    @pulumi.getter(name='gcfsConfig')
    def gcfs_config(self) ->Optional[pulumi.Input['GcfsConfigArgs']]:
        """
        GCFS (Google Container File System) configs.
        """
        return pulumi.get(self, 'gcfs_config')

    @gcfs_config.setter
    def gcfs_config(self, value: Optional[pulumi.Input['GcfsConfigArgs']]):
        pulumi.set(self, 'gcfs_config', value)

    @property
    @pulumi.getter
    def gvnic(self) ->Optional[pulumi.Input['VirtualNICArgs']]:
        """
        Enable or disable gvnic on the node pool.
        """
        return pulumi.get(self, 'gvnic')

    @gvnic.setter
    def gvnic(self, value: Optional[pulumi.Input['VirtualNICArgs']]):
        pulumi.set(self, 'gvnic', value)

    @property
    @pulumi.getter(name='imageType')
    def image_type(self) ->Optional[pulumi.Input[str]]:
        """
        The image type to use for this node. Note that for a given image type, the latest version of it will be used. Please see https://cloud.google.com/kubernetes-engine/docs/concepts/node-images for available image types.
        """
        return pulumi.get(self, 'image_type')

    @image_type.setter
    def image_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'image_type', value)

    @property
    @pulumi.getter(name='kubeletConfig')
    def kubelet_config(self) ->Optional[pulumi.Input['NodeKubeletConfigArgs']]:
        """
        Node kubelet configs.
        """
        return pulumi.get(self, 'kubelet_config')

    @kubelet_config.setter
    def kubelet_config(self, value: Optional[pulumi.Input[
        'NodeKubeletConfigArgs']]):
        pulumi.set(self, 'kubelet_config', value)

    @property
    @pulumi.getter
    def labels(self) ->Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        The map of Kubernetes labels (key/value pairs) to be applied to each node. These will added in addition to any default label(s) that Kubernetes may apply to the node. In case of conflict in label keys, the applied set may differ depending on the Kubernetes version -- it's best to assume the behavior is undefined and conflicts should be avoided. For more information, including usage and the valid values, see: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/
        """
        return pulumi.get(self, 'labels')

    @labels.setter
    def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input
        [str]]]]):
        pulumi.set(self, 'labels', value)

    @property
    @pulumi.getter(name='linuxNodeConfig')
    def linux_node_config(self) ->Optional[pulumi.Input['LinuxNodeConfigArgs']
        ]:
        """
        Parameters that can be configured on Linux nodes.
        """
        return pulumi.get(self, 'linux_node_config')

    @linux_node_config.setter
    def linux_node_config(self, value: Optional[pulumi.Input[
        'LinuxNodeConfigArgs']]):
        pulumi.set(self, 'linux_node_config', value)

    @property
    @pulumi.getter(name='localNvmeSsdBlockConfig')
    def local_nvme_ssd_block_config(self) ->Optional[pulumi.Input[
        'LocalNvmeSsdBlockConfigArgs']]:
        """
        Parameters for using raw-block Local NVMe SSDs.
        """
        return pulumi.get(self, 'local_nvme_ssd_block_config')

    @local_nvme_ssd_block_config.setter
    def local_nvme_ssd_block_config(self, value: Optional[pulumi.Input[
        'LocalNvmeSsdBlockConfigArgs']]):
        pulumi.set(self, 'local_nvme_ssd_block_config', value)

    @property
    @pulumi.getter(name='localSsdCount')
    def local_ssd_count(self) ->Optional[pulumi.Input[int]]:
        """
        The number of local SSD disks to be attached to the node. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        """
        return pulumi.get(self, 'local_ssd_count')

    @local_ssd_count.setter
    def local_ssd_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'local_ssd_count', value)

    @property
    @pulumi.getter(name='loggingConfig')
    def logging_config(self) ->Optional[pulumi.Input[
        'NodePoolLoggingConfigArgs']]:
        """
        Logging configuration.
        """
        return pulumi.get(self, 'logging_config')

    @logging_config.setter
    def logging_config(self, value: Optional[pulumi.Input[
        'NodePoolLoggingConfigArgs']]):
        pulumi.set(self, 'logging_config', value)

    @property
    @pulumi.getter(name='machineType')
    def machine_type(self) ->Optional[pulumi.Input[str]]:
        """
        The name of a Google Compute Engine [machine type](https://cloud.google.com/compute/docs/machine-types). If unspecified, the default machine type is `e2-medium`.
        """
        return pulumi.get(self, 'machine_type')

    @machine_type.setter
    def machine_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'machine_type', value)

    @property
    @pulumi.getter
    def metadata(self) ->Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]
        ]:
        """
        The metadata key/value pairs assigned to instances in the cluster. Keys must conform to the regexp `[a-zA-Z0-9-_]+` and be less than 128 bytes in length. These are reflected as part of a URL in the metadata server. Additionally, to avoid ambiguity, keys must not conflict with any other metadata keys for the project or be one of the reserved keys: - "cluster-location" - "cluster-name" - "cluster-uid" - "configure-sh" - "containerd-configure-sh" - "enable-oslogin" - "gci-ensure-gke-docker" - "gci-metrics-enabled" - "gci-update-strategy" - "instance-template" - "kube-env" - "startup-script" - "user-data" - "disable-address-manager" - "windows-startup-script-ps1" - "common-psm1" - "k8s-node-setup-psm1" - "install-ssh-psm1" - "user-profile-psm1" Values are free-form strings, and only have meaning as interpreted by the image running in the instance. The only restriction placed on them is that each value's size must be less than or equal to 32 KB. The total size of all keys and values must be less than 512 KB.
        """
        return pulumi.get(self, 'metadata')

    @metadata.setter
    def metadata(self, value: Optional[pulumi.Input[Mapping[str, pulumi.
        Input[str]]]]):
        pulumi.set(self, 'metadata', value)

    @property
    @pulumi.getter(name='minCpuPlatform')
    def min_cpu_platform(self) ->Optional[pulumi.Input[str]]:
        """
        Minimum CPU platform to be used by this instance. The instance may be scheduled on the specified or newer CPU platform. Applicable values are the friendly names of CPU platforms, such as `minCpuPlatform: "Intel Haswell"` or `minCpuPlatform: "Intel Sandy Bridge"`. For more information, read [how to specify min CPU platform](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform).
        """
        return pulumi.get(self, 'min_cpu_platform')

    @min_cpu_platform.setter
    def min_cpu_platform(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'min_cpu_platform', value)

    @property
    @pulumi.getter(name='nodeGroup')
    def node_group(self) ->Optional[pulumi.Input[str]]:
        """
        Setting this field will assign instances of this pool to run on the specified node group. This is useful for running workloads on [sole tenant nodes](https://cloud.google.com/compute/docs/nodes/sole-tenant-nodes).
        """
        return pulumi.get(self, 'node_group')

    @node_group.setter
    def node_group(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'node_group', value)

    @property
    @pulumi.getter(name='oauthScopes')
    def oauth_scopes(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[str]]]
        ]:
        """
        The set of Google API scopes to be made available on all of the node VMs under the "default" service account. The following scopes are recommended, but not required, and by default are not included: * `https://www.googleapis.com/auth/compute` is required for mounting persistent storage on your nodes. * `https://www.googleapis.com/auth/devstorage.read_only` is required for communicating with **gcr.io** (the [Google Container Registry](https://cloud.google.com/container-registry/)). If unspecified, no scopes are added, unless Cloud Logging or Cloud Monitoring are enabled, in which case their required scopes will be added.
        """
        return pulumi.get(self, 'oauth_scopes')

    @oauth_scopes.setter
    def oauth_scopes(self, value: Optional[pulumi.Input[Sequence[pulumi.
        Input[str]]]]):
        pulumi.set(self, 'oauth_scopes', value)

    @property
    @pulumi.getter
    def preemptible(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the nodes are created as preemptible VM instances. See: https://cloud.google.com/compute/docs/instances/preemptible for more inforamtion about preemptible VM instances.
        """
        return pulumi.get(self, 'preemptible')

    @preemptible.setter
    def preemptible(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'preemptible', value)

    @property
    @pulumi.getter(name='reservationAffinity')
    def reservation_affinity(self) ->Optional[pulumi.Input[
        'ReservationAffinityArgs']]:
        """
        The optional reservation affinity. Setting this field will apply the specified [Zonal Compute Reservation](https://cloud.google.com/compute/docs/instances/reserving-zonal-resources) to this node pool.
        """
        return pulumi.get(self, 'reservation_affinity')

    @reservation_affinity.setter
    def reservation_affinity(self, value: Optional[pulumi.Input[
        'ReservationAffinityArgs']]):
        pulumi.set(self, 'reservation_affinity', value)

    @property
    @pulumi.getter(name='resourceLabels')
    def resource_labels(self) ->Optional[pulumi.Input[Mapping[str, pulumi.
        Input[str]]]]:
        """
        The resource labels for the node pool to use to annotate any related Google Compute Engine resources.
        """
        return pulumi.get(self, 'resource_labels')

    @resource_labels.setter
    def resource_labels(self, value: Optional[pulumi.Input[Mapping[str,
        pulumi.Input[str]]]]):
        pulumi.set(self, 'resource_labels', value)

    @property
    @pulumi.getter(name='sandboxConfig')
    def sandbox_config(self) ->Optional[pulumi.Input['SandboxConfigArgs']]:
        """
        Sandbox configuration for this node.
        """
        return pulumi.get(self, 'sandbox_config')

    @sandbox_config.setter
    def sandbox_config(self, value: Optional[pulumi.Input['SandboxConfigArgs']]
        ):
        pulumi.set(self, 'sandbox_config', value)

    @property
    @pulumi.getter(name='serviceAccount')
    def service_account(self) ->Optional[pulumi.Input[str]]:
        """
        The Google Cloud Platform Service Account to be used by the node VMs. Specify the email address of the Service Account; otherwise, if no Service Account is specified, the "default" service account is used.
        """
        return pulumi.get(self, 'service_account')

    @service_account.setter
    def service_account(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'service_account', value)

    @property
    @pulumi.getter(name='shieldedInstanceConfig')
    def shielded_instance_config(self) ->Optional[pulumi.Input[
        'ShieldedInstanceConfigArgs']]:
        """
        Shielded Instance options.
        """
        return pulumi.get(self, 'shielded_instance_config')

    @shielded_instance_config.setter
    def shielded_instance_config(self, value: Optional[pulumi.Input[
        'ShieldedInstanceConfigArgs']]):
        pulumi.set(self, 'shielded_instance_config', value)

    @property
    @pulumi.getter
    def spot(self) ->Optional[pulumi.Input[bool]]:
        """
        Spot flag for enabling Spot VM, which is a rebrand of the existing preemptible flag.
        """
        return pulumi.get(self, 'spot')

    @spot.setter
    def spot(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'spot', value)

    @property
    @pulumi.getter
    def tags(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The list of instance tags applied to all nodes. Tags are used to identify valid sources or targets for network firewalls and are specified by the client during cluster or node pool creation. Each tag within the list must comply with RFC1035.
        """
        return pulumi.get(self, 'tags')

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, 'tags', value)

    @property
    @pulumi.getter
    def taints(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[
        'NodeTaintArgs']]]]:
        """
        List of kubernetes taints to be applied to each node. For more information, including usage and the valid values, see: https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/
        """
        return pulumi.get(self, 'taints')

    @taints.setter
    def taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
        'NodeTaintArgs']]]]):
        pulumi.set(self, 'taints', value)

    @property
    @pulumi.getter(name='windowsNodeConfig')
    def windows_node_config(self) ->Optional[pulumi.Input[
        'WindowsNodeConfigArgs']]:
        """
        Parameters that can be configured on Windows nodes.
        """
        return pulumi.get(self, 'windows_node_config')

    @windows_node_config.setter
    def windows_node_config(self, value: Optional[pulumi.Input[
        'WindowsNodeConfigArgs']]):
        pulumi.set(self, 'windows_node_config', value)

    @property
    @pulumi.getter(name='workloadMetadataConfig')
    def workload_metadata_config(self) ->Optional[pulumi.Input[
        'WorkloadMetadataConfigArgs']]:
        """
        The workload metadata configuration for this node.
        """
        return pulumi.get(self, 'workload_metadata_config')

    @workload_metadata_config.setter
    def workload_metadata_config(self, value: Optional[pulumi.Input[
        'WorkloadMetadataConfigArgs']]):
        pulumi.set(self, 'workload_metadata_config', value)


@pulumi.input_type
class NodeKubeletConfigArgs:

    def __init__(__self__, *, cpu_cfs_quota: Optional[pulumi.Input[bool]]=
        None, cpu_cfs_quota_period: Optional[pulumi.Input[str]]=None,
        cpu_manager_policy: Optional[pulumi.Input[str]]=None,
        pod_pids_limit: Optional[pulumi.Input[str]]=None):
        """
        Node kubelet configs.
        :param pulumi.Input[bool] cpu_cfs_quota: Enable CPU CFS quota enforcement for containers that specify CPU limits. This option is enabled by default which makes kubelet use CFS quota (https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt) to enforce container CPU limits. Otherwise, CPU limits will not be enforced at all. Disable this option to mitigate CPU throttling problems while still having your pods to be in Guaranteed QoS class by specifying the CPU limits. The default value is 'true' if unspecified.
        :param pulumi.Input[str] cpu_cfs_quota_period: Set the CPU CFS quota period value 'cpu.cfs_period_us'. The string must be a sequence of decimal numbers, each with optional fraction and a unit suffix, such as "300ms". Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h". The value must be a positive duration.
        :param pulumi.Input[str] cpu_manager_policy: Control the CPU management policy on the node. See https://kubernetes.io/docs/tasks/administer-cluster/cpu-management-policies/ The following values are allowed. * "none": the default, which represents the existing scheduling behavior. * "static": allows pods with certain resource characteristics to be granted increased CPU affinity and exclusivity on the node. The default value is 'none' if unspecified.
        :param pulumi.Input[str] pod_pids_limit: Set the Pod PID limits. See https://kubernetes.io/docs/concepts/policy/pid-limiting/#pod-pid-limits Controls the maximum number of processes allowed to run in a pod. The value must be greater than or equal to 1024 and less than 4194304.
        """
        if cpu_cfs_quota is not None:
            pulumi.set(__self__, 'cpu_cfs_quota', cpu_cfs_quota)
        if cpu_cfs_quota_period is not None:
            pulumi.set(__self__, 'cpu_cfs_quota_period', cpu_cfs_quota_period)
        if cpu_manager_policy is not None:
            pulumi.set(__self__, 'cpu_manager_policy', cpu_manager_policy)
        if pod_pids_limit is not None:
            pulumi.set(__self__, 'pod_pids_limit', pod_pids_limit)

    @property
    @pulumi.getter(name='cpuCfsQuota')
    def cpu_cfs_quota(self) ->Optional[pulumi.Input[bool]]:
        """
        Enable CPU CFS quota enforcement for containers that specify CPU limits. This option is enabled by default which makes kubelet use CFS quota (https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt) to enforce container CPU limits. Otherwise, CPU limits will not be enforced at all. Disable this option to mitigate CPU throttling problems while still having your pods to be in Guaranteed QoS class by specifying the CPU limits. The default value is 'true' if unspecified.
        """
        return pulumi.get(self, 'cpu_cfs_quota')

    @cpu_cfs_quota.setter
    def cpu_cfs_quota(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'cpu_cfs_quota', value)

    @property
    @pulumi.getter(name='cpuCfsQuotaPeriod')
    def cpu_cfs_quota_period(self) ->Optional[pulumi.Input[str]]:
        """
        Set the CPU CFS quota period value 'cpu.cfs_period_us'. The string must be a sequence of decimal numbers, each with optional fraction and a unit suffix, such as "300ms". Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h". The value must be a positive duration.
        """
        return pulumi.get(self, 'cpu_cfs_quota_period')

    @cpu_cfs_quota_period.setter
    def cpu_cfs_quota_period(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'cpu_cfs_quota_period', value)

    @property
    @pulumi.getter(name='cpuManagerPolicy')
    def cpu_manager_policy(self) ->Optional[pulumi.Input[str]]:
        """
        Control the CPU management policy on the node. See https://kubernetes.io/docs/tasks/administer-cluster/cpu-management-policies/ The following values are allowed. * "none": the default, which represents the existing scheduling behavior. * "static": allows pods with certain resource characteristics to be granted increased CPU affinity and exclusivity on the node. The default value is 'none' if unspecified.
        """
        return pulumi.get(self, 'cpu_manager_policy')

    @cpu_manager_policy.setter
    def cpu_manager_policy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'cpu_manager_policy', value)

    @property
    @pulumi.getter(name='podPidsLimit')
    def pod_pids_limit(self) ->Optional[pulumi.Input[str]]:
        """
        Set the Pod PID limits. See https://kubernetes.io/docs/concepts/policy/pid-limiting/#pod-pid-limits Controls the maximum number of processes allowed to run in a pod. The value must be greater than or equal to 1024 and less than 4194304.
        """
        return pulumi.get(self, 'pod_pids_limit')

    @pod_pids_limit.setter
    def pod_pids_limit(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'pod_pids_limit', value)


@pulumi.input_type
class NodeManagementArgs:

    def __init__(__self__, *, auto_repair: Optional[pulumi.Input[bool]]=
        None, auto_upgrade: Optional[pulumi.Input[bool]]=None,
        upgrade_options: Optional[pulumi.Input['AutoUpgradeOptionsArgs']]=None
        ):
        """
        NodeManagement defines the set of node management services turned on for the node pool.
        :param pulumi.Input[bool] auto_repair: Whether the nodes will be automatically repaired.
        :param pulumi.Input[bool] auto_upgrade: Whether the nodes will be automatically upgraded.
        :param pulumi.Input['AutoUpgradeOptionsArgs'] upgrade_options: Specifies the Auto Upgrade knobs for the node pool.
        """
        if auto_repair is not None:
            pulumi.set(__self__, 'auto_repair', auto_repair)
        if auto_upgrade is not None:
            pulumi.set(__self__, 'auto_upgrade', auto_upgrade)
        if upgrade_options is not None:
            pulumi.set(__self__, 'upgrade_options', upgrade_options)

    @property
    @pulumi.getter(name='autoRepair')
    def auto_repair(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the nodes will be automatically repaired.
        """
        return pulumi.get(self, 'auto_repair')

    @auto_repair.setter
    def auto_repair(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'auto_repair', value)

    @property
    @pulumi.getter(name='autoUpgrade')
    def auto_upgrade(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the nodes will be automatically upgraded.
        """
        return pulumi.get(self, 'auto_upgrade')

    @auto_upgrade.setter
    def auto_upgrade(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'auto_upgrade', value)

    @property
    @pulumi.getter(name='upgradeOptions')
    def upgrade_options(self) ->Optional[pulumi.Input['AutoUpgradeOptionsArgs']
        ]:
        """
        Specifies the Auto Upgrade knobs for the node pool.
        """
        return pulumi.get(self, 'upgrade_options')

    @upgrade_options.setter
    def upgrade_options(self, value: Optional[pulumi.Input[
        'AutoUpgradeOptionsArgs']]):
        pulumi.set(self, 'upgrade_options', value)


@pulumi.input_type
class NodeNetworkConfigArgs:

    def __init__(__self__, *, create_pod_range: Optional[pulumi.Input[bool]
        ]=None, enable_private_nodes: Optional[pulumi.Input[bool]]=None,
        network_performance_config: Optional[pulumi.Input[
        'NetworkPerformanceConfigArgs']]=None,
        pod_cidr_overprovision_config: Optional[pulumi.Input[
        'PodCIDROverprovisionConfigArgs']]=None, pod_ipv4_cidr_block:
        Optional[pulumi.Input[str]]=None, pod_range: Optional[pulumi.Input[
        str]]=None):
        """
        Parameters for node pool-level network config.
        :param pulumi.Input[bool] create_pod_range: Input only. Whether to create a new range for pod IPs in this node pool. Defaults are provided for `pod_range` and `pod_ipv4_cidr_block` if they are not specified. If neither `create_pod_range` or `pod_range` are specified, the cluster-level default (`ip_allocation_policy.cluster_ipv4_cidr_block`) is used. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        :param pulumi.Input[bool] enable_private_nodes: Whether nodes have internal IP addresses only. If enable_private_nodes is not specified, then the value is derived from cluster.privateClusterConfig.enablePrivateNodes
        :param pulumi.Input['NetworkPerformanceConfigArgs'] network_performance_config: Network bandwidth tier configuration.
        :param pulumi.Input['PodCIDROverprovisionConfigArgs'] pod_cidr_overprovision_config: [PRIVATE FIELD] Pod CIDR size overprovisioning config for the nodepool. Pod CIDR size per node depends on max_pods_per_node. By default, the value of max_pods_per_node is rounded off to next power of 2 and we then double that to get the size of pod CIDR block per node. Example: max_pods_per_node of 30 would result in 64 IPs (/26). This config can disable the doubling of IPs (we still round off to next power of 2) Example: max_pods_per_node of 30 will result in 32 IPs (/27) when overprovisioning is disabled.
        :param pulumi.Input[str] pod_ipv4_cidr_block: The IP address range for pod IPs in this node pool. Only applicable if `create_pod_range` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) to pick a specific range to use. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        :param pulumi.Input[str] pod_range: The ID of the secondary range for pod IPs. If `create_pod_range` is true, this ID is used for the new range. If `create_pod_range` is false, uses an existing secondary range with this ID. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        """
        if create_pod_range is not None:
            pulumi.set(__self__, 'create_pod_range', create_pod_range)
        if enable_private_nodes is not None:
            pulumi.set(__self__, 'enable_private_nodes', enable_private_nodes)
        if network_performance_config is not None:
            pulumi.set(__self__, 'network_performance_config',
                network_performance_config)
        if pod_cidr_overprovision_config is not None:
            pulumi.set(__self__, 'pod_cidr_overprovision_config',
                pod_cidr_overprovision_config)
        if pod_ipv4_cidr_block is not None:
            pulumi.set(__self__, 'pod_ipv4_cidr_block', pod_ipv4_cidr_block)
        if pod_range is not None:
            pulumi.set(__self__, 'pod_range', pod_range)

    @property
    @pulumi.getter(name='createPodRange')
    def create_pod_range(self) ->Optional[pulumi.Input[bool]]:
        """
        Input only. Whether to create a new range for pod IPs in this node pool. Defaults are provided for `pod_range` and `pod_ipv4_cidr_block` if they are not specified. If neither `create_pod_range` or `pod_range` are specified, the cluster-level default (`ip_allocation_policy.cluster_ipv4_cidr_block`) is used. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        """
        return pulumi.get(self, 'create_pod_range')

    @create_pod_range.setter
    def create_pod_range(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'create_pod_range', value)

    @property
    @pulumi.getter(name='enablePrivateNodes')
    def enable_private_nodes(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether nodes have internal IP addresses only. If enable_private_nodes is not specified, then the value is derived from cluster.privateClusterConfig.enablePrivateNodes
        """
        return pulumi.get(self, 'enable_private_nodes')

    @enable_private_nodes.setter
    def enable_private_nodes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_private_nodes', value)

    @property
    @pulumi.getter(name='networkPerformanceConfig')
    def network_performance_config(self) ->Optional[pulumi.Input[
        'NetworkPerformanceConfigArgs']]:
        """
        Network bandwidth tier configuration.
        """
        return pulumi.get(self, 'network_performance_config')

    @network_performance_config.setter
    def network_performance_config(self, value: Optional[pulumi.Input[
        'NetworkPerformanceConfigArgs']]):
        pulumi.set(self, 'network_performance_config', value)

    @property
    @pulumi.getter(name='podCidrOverprovisionConfig')
    def pod_cidr_overprovision_config(self) ->Optional[pulumi.Input[
        'PodCIDROverprovisionConfigArgs']]:
        """
        [PRIVATE FIELD] Pod CIDR size overprovisioning config for the nodepool. Pod CIDR size per node depends on max_pods_per_node. By default, the value of max_pods_per_node is rounded off to next power of 2 and we then double that to get the size of pod CIDR block per node. Example: max_pods_per_node of 30 would result in 64 IPs (/26). This config can disable the doubling of IPs (we still round off to next power of 2) Example: max_pods_per_node of 30 will result in 32 IPs (/27) when overprovisioning is disabled.
        """
        return pulumi.get(self, 'pod_cidr_overprovision_config')

    @pod_cidr_overprovision_config.setter
    def pod_cidr_overprovision_config(self, value: Optional[pulumi.Input[
        'PodCIDROverprovisionConfigArgs']]):
        pulumi.set(self, 'pod_cidr_overprovision_config', value)

    @property
    @pulumi.getter(name='podIpv4CidrBlock')
    def pod_ipv4_cidr_block(self) ->Optional[pulumi.Input[str]]:
        """
        The IP address range for pod IPs in this node pool. Only applicable if `create_pod_range` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) to pick a specific range to use. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        """
        return pulumi.get(self, 'pod_ipv4_cidr_block')

    @pod_ipv4_cidr_block.setter
    def pod_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'pod_ipv4_cidr_block', value)

    @property
    @pulumi.getter(name='podRange')
    def pod_range(self) ->Optional[pulumi.Input[str]]:
        """
        The ID of the secondary range for pod IPs. If `create_pod_range` is true, this ID is used for the new range. If `create_pod_range` is false, uses an existing secondary range with this ID. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        """
        return pulumi.get(self, 'pod_range')

    @pod_range.setter
    def pod_range(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'pod_range', value)


@pulumi.input_type
class NodePoolAutoConfigArgs:

    def __init__(__self__, *, network_tags: Optional[pulumi.Input[
        'NetworkTagsArgs']]=None):
        """
        node pool configs that apply to all auto-provisioned node pools in autopilot clusters and node auto-provisioning enabled clusters
        :param pulumi.Input['NetworkTagsArgs'] network_tags: The list of instance tags applied to all nodes. Tags are used to identify valid sources or targets for network firewalls and are specified by the client during cluster creation. Each tag within the list must comply with RFC1035.
        """
        if network_tags is not None:
            pulumi.set(__self__, 'network_tags', network_tags)

    @property
    @pulumi.getter(name='networkTags')
    def network_tags(self) ->Optional[pulumi.Input['NetworkTagsArgs']]:
        """
        The list of instance tags applied to all nodes. Tags are used to identify valid sources or targets for network firewalls and are specified by the client during cluster creation. Each tag within the list must comply with RFC1035.
        """
        return pulumi.get(self, 'network_tags')

    @network_tags.setter
    def network_tags(self, value: Optional[pulumi.Input['NetworkTagsArgs']]):
        pulumi.set(self, 'network_tags', value)


@pulumi.input_type
class NodePoolAutoscalingArgs:

    def __init__(__self__, *, autoprovisioned: Optional[pulumi.Input[bool]]
        =None, enabled: Optional[pulumi.Input[bool]]=None, location_policy:
        Optional[pulumi.Input['NodePoolAutoscalingLocationPolicy']]=None,
        max_node_count: Optional[pulumi.Input[int]]=None, min_node_count:
        Optional[pulumi.Input[int]]=None, total_max_node_count: Optional[
        pulumi.Input[int]]=None, total_min_node_count: Optional[pulumi.
        Input[int]]=None):
        """
        NodePoolAutoscaling contains information required by cluster autoscaler to adjust the size of the node pool to the current cluster usage.
        :param pulumi.Input[bool] autoprovisioned: Can this node pool be deleted automatically.
        :param pulumi.Input[bool] enabled: Is autoscaling enabled for this node pool.
        :param pulumi.Input['NodePoolAutoscalingLocationPolicy'] location_policy: Location policy used when scaling up a nodepool.
        :param pulumi.Input[int] max_node_count: Maximum number of nodes for one location in the NodePool. Must be >= min_node_count. There has to be enough quota to scale up the cluster.
        :param pulumi.Input[int] min_node_count: Minimum number of nodes for one location in the NodePool. Must be >= 1 and <= max_node_count.
        :param pulumi.Input[int] total_max_node_count: Maximum number of nodes in the node pool. Must be greater than total_min_node_count. There has to be enough quota to scale up the cluster. The total_*_node_count fields are mutually exclusive with the *_node_count fields.
        :param pulumi.Input[int] total_min_node_count: Minimum number of nodes in the node pool. Must be greater than 1 less than total_max_node_count. The total_*_node_count fields are mutually exclusive with the *_node_count fields.
        """
        if autoprovisioned is not None:
            pulumi.set(__self__, 'autoprovisioned', autoprovisioned)
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)
        if location_policy is not None:
            pulumi.set(__self__, 'location_policy', location_policy)
        if max_node_count is not None:
            pulumi.set(__self__, 'max_node_count', max_node_count)
        if min_node_count is not None:
            pulumi.set(__self__, 'min_node_count', min_node_count)
        if total_max_node_count is not None:
            pulumi.set(__self__, 'total_max_node_count', total_max_node_count)
        if total_min_node_count is not None:
            pulumi.set(__self__, 'total_min_node_count', total_min_node_count)

    @property
    @pulumi.getter
    def autoprovisioned(self) ->Optional[pulumi.Input[bool]]:
        """
        Can this node pool be deleted automatically.
        """
        return pulumi.get(self, 'autoprovisioned')

    @autoprovisioned.setter
    def autoprovisioned(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'autoprovisioned', value)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Is autoscaling enabled for this node pool.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)

    @property
    @pulumi.getter(name='locationPolicy')
    def location_policy(self) ->Optional[pulumi.Input[
        'NodePoolAutoscalingLocationPolicy']]:
        """
        Location policy used when scaling up a nodepool.
        """
        return pulumi.get(self, 'location_policy')

    @location_policy.setter
    def location_policy(self, value: Optional[pulumi.Input[
        'NodePoolAutoscalingLocationPolicy']]):
        pulumi.set(self, 'location_policy', value)

    @property
    @pulumi.getter(name='maxNodeCount')
    def max_node_count(self) ->Optional[pulumi.Input[int]]:
        """
        Maximum number of nodes for one location in the NodePool. Must be >= min_node_count. There has to be enough quota to scale up the cluster.
        """
        return pulumi.get(self, 'max_node_count')

    @max_node_count.setter
    def max_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'max_node_count', value)

    @property
    @pulumi.getter(name='minNodeCount')
    def min_node_count(self) ->Optional[pulumi.Input[int]]:
        """
        Minimum number of nodes for one location in the NodePool. Must be >= 1 and <= max_node_count.
        """
        return pulumi.get(self, 'min_node_count')

    @min_node_count.setter
    def min_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'min_node_count', value)

    @property
    @pulumi.getter(name='totalMaxNodeCount')
    def total_max_node_count(self) ->Optional[pulumi.Input[int]]:
        """
        Maximum number of nodes in the node pool. Must be greater than total_min_node_count. There has to be enough quota to scale up the cluster. The total_*_node_count fields are mutually exclusive with the *_node_count fields.
        """
        return pulumi.get(self, 'total_max_node_count')

    @total_max_node_count.setter
    def total_max_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'total_max_node_count', value)

    @property
    @pulumi.getter(name='totalMinNodeCount')
    def total_min_node_count(self) ->Optional[pulumi.Input[int]]:
        """
        Minimum number of nodes in the node pool. Must be greater than 1 less than total_max_node_count. The total_*_node_count fields are mutually exclusive with the *_node_count fields.
        """
        return pulumi.get(self, 'total_min_node_count')

    @total_min_node_count.setter
    def total_min_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'total_min_node_count', value)


@pulumi.input_type
class NodePoolDefaultsArgs:

    def __init__(__self__, *, node_config_defaults: Optional[pulumi.Input[
        'NodeConfigDefaultsArgs']]=None):
        """
        Subset of Nodepool message that has defaults.
        :param pulumi.Input['NodeConfigDefaultsArgs'] node_config_defaults: Subset of NodeConfig message that has defaults.
        """
        if node_config_defaults is not None:
            pulumi.set(__self__, 'node_config_defaults', node_config_defaults)

    @property
    @pulumi.getter(name='nodeConfigDefaults')
    def node_config_defaults(self) ->Optional[pulumi.Input[
        'NodeConfigDefaultsArgs']]:
        """
        Subset of NodeConfig message that has defaults.
        """
        return pulumi.get(self, 'node_config_defaults')

    @node_config_defaults.setter
    def node_config_defaults(self, value: Optional[pulumi.Input[
        'NodeConfigDefaultsArgs']]):
        pulumi.set(self, 'node_config_defaults', value)


@pulumi.input_type
class NodePoolLoggingConfigArgs:

    def __init__(__self__, *, variant_config: Optional[pulumi.Input[
        'LoggingVariantConfigArgs']]=None):
        """
        NodePoolLoggingConfig specifies logging configuration for nodepools.
        :param pulumi.Input['LoggingVariantConfigArgs'] variant_config: Logging variant configuration.
        """
        if variant_config is not None:
            pulumi.set(__self__, 'variant_config', variant_config)

    @property
    @pulumi.getter(name='variantConfig')
    def variant_config(self) ->Optional[pulumi.Input[
        'LoggingVariantConfigArgs']]:
        """
        Logging variant configuration.
        """
        return pulumi.get(self, 'variant_config')

    @variant_config.setter
    def variant_config(self, value: Optional[pulumi.Input[
        'LoggingVariantConfigArgs']]):
        pulumi.set(self, 'variant_config', value)


@pulumi.input_type
class NodePoolArgs:

    def __init__(__self__, *, autoscaling: Optional[pulumi.Input[
        'NodePoolAutoscalingArgs']]=None, conditions: Optional[pulumi.Input
        [Sequence[pulumi.Input['StatusConditionArgs']]]]=None, config:
        Optional[pulumi.Input['NodeConfigArgs']]=None, etag: Optional[
        pulumi.Input[str]]=None, initial_node_count: Optional[pulumi.Input[
        int]]=None, locations: Optional[pulumi.Input[Sequence[pulumi.Input[
        str]]]]=None, management: Optional[pulumi.Input[
        'NodeManagementArgs']]=None, max_pods_constraint: Optional[pulumi.
        Input['MaxPodsConstraintArgs']]=None, name: Optional[pulumi.Input[
        str]]=None, network_config: Optional[pulumi.Input[
        'NodeNetworkConfigArgs']]=None, placement_policy: Optional[pulumi.
        Input['PlacementPolicyArgs']]=None, upgrade_settings: Optional[
        pulumi.Input['UpgradeSettingsArgs']]=None, version: Optional[pulumi
        .Input[str]]=None):
        """
        NodePool contains the name and configuration for a cluster's node pool. Node pools are a set of nodes (i.e. VM's), with a common configuration and specification, under the control of the cluster master. They may have a set of Kubernetes labels applied to them, which may be used to reference them during pod scheduling. They may also be resized up or down, to accommodate the workload. These upgrade settings control the level of parallelism and the level of disruption caused by an upgrade. maxUnavailable controls the number of nodes that can be simultaneously unavailable. maxSurge controls the number of additional nodes that can be added to the node pool temporarily for the time of the upgrade to increase the number of available nodes. (maxUnavailable + maxSurge) determines the level of parallelism (how many nodes are being upgraded at the same time). Note: upgrades inevitably introduce some disruption since workloads need to be moved from old nodes to new, upgraded ones. Even if maxUnavailable=0, this holds true. (Disruption stays within the limits of PodDisruptionBudget, if it is configured.) Consider a hypothetical node pool with 5 nodes having maxSurge=2, maxUnavailable=1. This means the upgrade process upgrades 3 nodes simultaneously. It creates 2 additional (upgraded) nodes, then it brings down 3 old (not yet upgraded) nodes at the same time. This ensures that there are always at least 4 nodes available.
        :param pulumi.Input['NodePoolAutoscalingArgs'] autoscaling: Autoscaler configuration for this NodePool. Autoscaler is enabled only if a valid configuration is present.
        :param pulumi.Input[Sequence[pulumi.Input['StatusConditionArgs']]] conditions: Which conditions caused the current node pool state.
        :param pulumi.Input['NodeConfigArgs'] config: The node configuration of the pool.
        :param pulumi.Input[str] etag: This checksum is computed by the server based on the value of node pool fields, and may be sent on update requests to ensure the client has an up-to-date value before proceeding.
        :param pulumi.Input[int] initial_node_count: The initial node count for the pool. You must ensure that your Compute Engine [resource quota](https://cloud.google.com/compute/quotas) is sufficient for this number of instances. You must also have available firewall and routes quota.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] locations: The list of Google Compute Engine [zones](https://cloud.google.com/compute/docs/zones#available) in which the NodePool's nodes should be located. If this value is unspecified during node pool creation, the [Cluster.Locations](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1/projects.locations.clusters#Cluster.FIELDS.locations) value will be used, instead. Warning: changing node pool locations will result in nodes being added and/or removed.
        :param pulumi.Input['NodeManagementArgs'] management: NodeManagement configuration for this NodePool.
        :param pulumi.Input['MaxPodsConstraintArgs'] max_pods_constraint: The constraint on the maximum number of pods that can be run simultaneously on a node in the node pool.
        :param pulumi.Input[str] name: The name of the node pool.
        :param pulumi.Input['NodeNetworkConfigArgs'] network_config: Networking configuration for this NodePool. If specified, it overrides the cluster-level defaults.
        :param pulumi.Input['PlacementPolicyArgs'] placement_policy: Specifies the node placement policy.
        :param pulumi.Input['UpgradeSettingsArgs'] upgrade_settings: Upgrade settings control disruption and speed of the upgrade.
        :param pulumi.Input[str] version: The version of Kubernetes running on this NodePool's nodes. If unspecified, it defaults as described [here](https://cloud.google.com/kubernetes-engine/versioning#specifying_node_version).
        """
        if autoscaling is not None:
            pulumi.set(__self__, 'autoscaling', autoscaling)
        if conditions is not None:
            pulumi.set(__self__, 'conditions', conditions)
        if config is not None:
            pulumi.set(__self__, 'config', config)
        if etag is not None:
            pulumi.set(__self__, 'etag', etag)
        if initial_node_count is not None:
            pulumi.set(__self__, 'initial_node_count', initial_node_count)
        if locations is not None:
            pulumi.set(__self__, 'locations', locations)
        if management is not None:
            pulumi.set(__self__, 'management', management)
        if max_pods_constraint is not None:
            pulumi.set(__self__, 'max_pods_constraint', max_pods_constraint)
        if name is not None:
            pulumi.set(__self__, 'name', name)
        if network_config is not None:
            pulumi.set(__self__, 'network_config', network_config)
        if placement_policy is not None:
            pulumi.set(__self__, 'placement_policy', placement_policy)
        if upgrade_settings is not None:
            pulumi.set(__self__, 'upgrade_settings', upgrade_settings)
        if version is not None:
            pulumi.set(__self__, 'version', version)

    @property
    @pulumi.getter
    def autoscaling(self) ->Optional[pulumi.Input['NodePoolAutoscalingArgs']]:
        """
        Autoscaler configuration for this NodePool. Autoscaler is enabled only if a valid configuration is present.
        """
        return pulumi.get(self, 'autoscaling')

    @autoscaling.setter
    def autoscaling(self, value: Optional[pulumi.Input[
        'NodePoolAutoscalingArgs']]):
        pulumi.set(self, 'autoscaling', value)

    @property
    @pulumi.getter
    def conditions(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[
        'StatusConditionArgs']]]]:
        """
        Which conditions caused the current node pool state.
        """
        return pulumi.get(self, 'conditions')

    @conditions.setter
    def conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input
        ['StatusConditionArgs']]]]):
        pulumi.set(self, 'conditions', value)

    @property
    @pulumi.getter
    def config(self) ->Optional[pulumi.Input['NodeConfigArgs']]:
        """
        The node configuration of the pool.
        """
        return pulumi.get(self, 'config')

    @config.setter
    def config(self, value: Optional[pulumi.Input['NodeConfigArgs']]):
        pulumi.set(self, 'config', value)

    @property
    @pulumi.getter
    def etag(self) ->Optional[pulumi.Input[str]]:
        """
        This checksum is computed by the server based on the value of node pool fields, and may be sent on update requests to ensure the client has an up-to-date value before proceeding.
        """
        return pulumi.get(self, 'etag')

    @etag.setter
    def etag(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'etag', value)

    @property
    @pulumi.getter(name='initialNodeCount')
    def initial_node_count(self) ->Optional[pulumi.Input[int]]:
        """
        The initial node count for the pool. You must ensure that your Compute Engine [resource quota](https://cloud.google.com/compute/quotas) is sufficient for this number of instances. You must also have available firewall and routes quota.
        """
        return pulumi.get(self, 'initial_node_count')

    @initial_node_count.setter
    def initial_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'initial_node_count', value)

    @property
    @pulumi.getter
    def locations(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The list of Google Compute Engine [zones](https://cloud.google.com/compute/docs/zones#available) in which the NodePool's nodes should be located. If this value is unspecified during node pool creation, the [Cluster.Locations](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1/projects.locations.clusters#Cluster.FIELDS.locations) value will be used, instead. Warning: changing node pool locations will result in nodes being added and/or removed.
        """
        return pulumi.get(self, 'locations')

    @locations.setter
    def locations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
        str]]]]):
        pulumi.set(self, 'locations', value)

    @property
    @pulumi.getter
    def management(self) ->Optional[pulumi.Input['NodeManagementArgs']]:
        """
        NodeManagement configuration for this NodePool.
        """
        return pulumi.get(self, 'management')

    @management.setter
    def management(self, value: Optional[pulumi.Input['NodeManagementArgs']]):
        pulumi.set(self, 'management', value)

    @property
    @pulumi.getter(name='maxPodsConstraint')
    def max_pods_constraint(self) ->Optional[pulumi.Input[
        'MaxPodsConstraintArgs']]:
        """
        The constraint on the maximum number of pods that can be run simultaneously on a node in the node pool.
        """
        return pulumi.get(self, 'max_pods_constraint')

    @max_pods_constraint.setter
    def max_pods_constraint(self, value: Optional[pulumi.Input[
        'MaxPodsConstraintArgs']]):
        pulumi.set(self, 'max_pods_constraint', value)

    @property
    @pulumi.getter
    def name(self) ->Optional[pulumi.Input[str]]:
        """
        The name of the node pool.
        """
        return pulumi.get(self, 'name')

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'name', value)

    @property
    @pulumi.getter(name='networkConfig')
    def network_config(self) ->Optional[pulumi.Input['NodeNetworkConfigArgs']]:
        """
        Networking configuration for this NodePool. If specified, it overrides the cluster-level defaults.
        """
        return pulumi.get(self, 'network_config')

    @network_config.setter
    def network_config(self, value: Optional[pulumi.Input[
        'NodeNetworkConfigArgs']]):
        pulumi.set(self, 'network_config', value)

    @property
    @pulumi.getter(name='placementPolicy')
    def placement_policy(self) ->Optional[pulumi.Input['PlacementPolicyArgs']]:
        """
        Specifies the node placement policy.
        """
        return pulumi.get(self, 'placement_policy')

    @placement_policy.setter
    def placement_policy(self, value: Optional[pulumi.Input[
        'PlacementPolicyArgs']]):
        pulumi.set(self, 'placement_policy', value)

    @property
    @pulumi.getter(name='upgradeSettings')
    def upgrade_settings(self) ->Optional[pulumi.Input['UpgradeSettingsArgs']]:
        """
        Upgrade settings control disruption and speed of the upgrade.
        """
        return pulumi.get(self, 'upgrade_settings')

    @upgrade_settings.setter
    def upgrade_settings(self, value: Optional[pulumi.Input[
        'UpgradeSettingsArgs']]):
        pulumi.set(self, 'upgrade_settings', value)

    @property
    @pulumi.getter
    def version(self) ->Optional[pulumi.Input[str]]:
        """
        The version of Kubernetes running on this NodePool's nodes. If unspecified, it defaults as described [here](https://cloud.google.com/kubernetes-engine/versioning#specifying_node_version).
        """
        return pulumi.get(self, 'version')

    @version.setter
    def version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'version', value)


@pulumi.input_type
class NodeTaintArgs:

    def __init__(__self__, *, effect: Optional[pulumi.Input[
        'NodeTaintEffect']]=None, key: Optional[pulumi.Input[str]]=None,
        value: Optional[pulumi.Input[str]]=None):
        """
        Kubernetes taint is composed of three fields: key, value, and effect. Effect can only be one of three types: NoSchedule, PreferNoSchedule or NoExecute. See [here](https://kubernetes.io/docs/concepts/configuration/taint-and-toleration) for more information, including usage and the valid values.
        :param pulumi.Input['NodeTaintEffect'] effect: Effect for taint.
        :param pulumi.Input[str] key: Key for taint.
        :param pulumi.Input[str] value: Value for taint.
        """
        if effect is not None:
            pulumi.set(__self__, 'effect', effect)
        if key is not None:
            pulumi.set(__self__, 'key', key)
        if value is not None:
            pulumi.set(__self__, 'value', value)

    @property
    @pulumi.getter
    def effect(self) ->Optional[pulumi.Input['NodeTaintEffect']]:
        """
        Effect for taint.
        """
        return pulumi.get(self, 'effect')

    @effect.setter
    def effect(self, value: Optional[pulumi.Input['NodeTaintEffect']]):
        pulumi.set(self, 'effect', value)

    @property
    @pulumi.getter
    def key(self) ->Optional[pulumi.Input[str]]:
        """
        Key for taint.
        """
        return pulumi.get(self, 'key')

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'key', value)

    @property
    @pulumi.getter
    def value(self) ->Optional[pulumi.Input[str]]:
        """
        Value for taint.
        """
        return pulumi.get(self, 'value')

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'value', value)


@pulumi.input_type
class NotificationConfigArgs:

    def __init__(__self__, *, pubsub: Optional[pulumi.Input['PubSubArgs']]=None
        ):
        """
        NotificationConfig is the configuration of notifications.
        :param pulumi.Input['PubSubArgs'] pubsub: Notification config for Pub/Sub.
        """
        if pubsub is not None:
            pulumi.set(__self__, 'pubsub', pubsub)

    @property
    @pulumi.getter
    def pubsub(self) ->Optional[pulumi.Input['PubSubArgs']]:
        """
        Notification config for Pub/Sub.
        """
        return pulumi.get(self, 'pubsub')

    @pubsub.setter
    def pubsub(self, value: Optional[pulumi.Input['PubSubArgs']]):
        pulumi.set(self, 'pubsub', value)


@pulumi.input_type
class PlacementPolicyArgs:

    def __init__(__self__, *, type: Optional[pulumi.Input[
        'PlacementPolicyType']]=None):
        """
        PlacementPolicy defines the placement policy used by the node pool.
        :param pulumi.Input['PlacementPolicyType'] type: The type of placement.
        """
        if type is not None:
            pulumi.set(__self__, 'type', type)

    @property
    @pulumi.getter
    def type(self) ->Optional[pulumi.Input['PlacementPolicyType']]:
        """
        The type of placement.
        """
        return pulumi.get(self, 'type')

    @type.setter
    def type(self, value: Optional[pulumi.Input['PlacementPolicyType']]):
        pulumi.set(self, 'type', value)


@pulumi.input_type
class PodCIDROverprovisionConfigArgs:

    def __init__(__self__, *, disable: Optional[pulumi.Input[bool]]=None):
        """
        [PRIVATE FIELD] Config for pod CIDR size overprovisioning.
        :param pulumi.Input[bool] disable: Whether Pod CIDR overprovisioning is disabled. Note: Pod CIDR overprovisioning is enabled by default.
        """
        if disable is not None:
            pulumi.set(__self__, 'disable', disable)

    @property
    @pulumi.getter
    def disable(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Pod CIDR overprovisioning is disabled. Note: Pod CIDR overprovisioning is enabled by default.
        """
        return pulumi.get(self, 'disable')

    @disable.setter
    def disable(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'disable', value)


@pulumi.input_type
class PodSecurityPolicyConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for the PodSecurityPolicy feature.
        :param pulumi.Input[bool] enabled: Enable the PodSecurityPolicy controller for this cluster. If enabled, pods must be valid under a PodSecurityPolicy to be created.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Enable the PodSecurityPolicy controller for this cluster. If enabled, pods must be valid under a PodSecurityPolicy to be created.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class PrivateClusterConfigArgs:

    def __init__(__self__, *, enable_private_endpoint: Optional[pulumi.
        Input[bool]]=None, enable_private_nodes: Optional[pulumi.Input[bool
        ]]=None, master_global_access_config: Optional[pulumi.Input[
        'PrivateClusterMasterGlobalAccessConfigArgs']]=None,
        master_ipv4_cidr_block: Optional[pulumi.Input[str]]=None,
        private_endpoint_subnetwork: Optional[pulumi.Input[str]]=None):
        """
        Configuration options for private clusters.
        :param pulumi.Input[bool] enable_private_endpoint: Whether the master's internal IP address is used as the cluster endpoint.
        :param pulumi.Input[bool] enable_private_nodes: Whether nodes have internal IP addresses only. If enabled, all nodes are given only RFC 1918 private addresses and communicate with the master via private networking.
        :param pulumi.Input['PrivateClusterMasterGlobalAccessConfigArgs'] master_global_access_config: Controls master global access settings.
        :param pulumi.Input[str] master_ipv4_cidr_block: The IP range in CIDR notation to use for the hosted master network. This range will be used for assigning internal IP addresses to the master or set of masters, as well as the ILB VIP. This range must not overlap with any other ranges in use within the cluster's network.
        :param pulumi.Input[str] private_endpoint_subnetwork: Subnet to provision the master's private endpoint during cluster creation. Specified in projects/*/regions/*/subnetworks/* format.
        """
        if enable_private_endpoint is not None:
            pulumi.set(__self__, 'enable_private_endpoint',
                enable_private_endpoint)
        if enable_private_nodes is not None:
            pulumi.set(__self__, 'enable_private_nodes', enable_private_nodes)
        if master_global_access_config is not None:
            pulumi.set(__self__, 'master_global_access_config',
                master_global_access_config)
        if master_ipv4_cidr_block is not None:
            pulumi.set(__self__, 'master_ipv4_cidr_block',
                master_ipv4_cidr_block)
        if private_endpoint_subnetwork is not None:
            pulumi.set(__self__, 'private_endpoint_subnetwork',
                private_endpoint_subnetwork)

    @property
    @pulumi.getter(name='enablePrivateEndpoint')
    def enable_private_endpoint(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether the master's internal IP address is used as the cluster endpoint.
        """
        return pulumi.get(self, 'enable_private_endpoint')

    @enable_private_endpoint.setter
    def enable_private_endpoint(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_private_endpoint', value)

    @property
    @pulumi.getter(name='enablePrivateNodes')
    def enable_private_nodes(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether nodes have internal IP addresses only. If enabled, all nodes are given only RFC 1918 private addresses and communicate with the master via private networking.
        """
        return pulumi.get(self, 'enable_private_nodes')

    @enable_private_nodes.setter
    def enable_private_nodes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_private_nodes', value)

    @property
    @pulumi.getter(name='masterGlobalAccessConfig')
    def master_global_access_config(self) ->Optional[pulumi.Input[
        'PrivateClusterMasterGlobalAccessConfigArgs']]:
        """
        Controls master global access settings.
        """
        return pulumi.get(self, 'master_global_access_config')

    @master_global_access_config.setter
    def master_global_access_config(self, value: Optional[pulumi.Input[
        'PrivateClusterMasterGlobalAccessConfigArgs']]):
        pulumi.set(self, 'master_global_access_config', value)

    @property
    @pulumi.getter(name='masterIpv4CidrBlock')
    def master_ipv4_cidr_block(self) ->Optional[pulumi.Input[str]]:
        """
        The IP range in CIDR notation to use for the hosted master network. This range will be used for assigning internal IP addresses to the master or set of masters, as well as the ILB VIP. This range must not overlap with any other ranges in use within the cluster's network.
        """
        return pulumi.get(self, 'master_ipv4_cidr_block')

    @master_ipv4_cidr_block.setter
    def master_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'master_ipv4_cidr_block', value)

    @property
    @pulumi.getter(name='privateEndpointSubnetwork')
    def private_endpoint_subnetwork(self) ->Optional[pulumi.Input[str]]:
        """
        Subnet to provision the master's private endpoint during cluster creation. Specified in projects/*/regions/*/subnetworks/* format.
        """
        return pulumi.get(self, 'private_endpoint_subnetwork')

    @private_endpoint_subnetwork.setter
    def private_endpoint_subnetwork(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'private_endpoint_subnetwork', value)


@pulumi.input_type
class PrivateClusterMasterGlobalAccessConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for controlling master global access settings.
        :param pulumi.Input[bool] enabled: Whenever master is accessible globally or not.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whenever master is accessible globally or not.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class ProtectConfigArgs:

    def __init__(__self__, *, workload_config: Optional[pulumi.Input[
        'WorkloadConfigArgs']]=None, workload_vulnerability_mode: Optional[
        pulumi.Input['ProtectConfigWorkloadVulnerabilityMode']]=None):
        """
        ProtectConfig defines the flags needed to enable/disable features for the Protect API.
        :param pulumi.Input['WorkloadConfigArgs'] workload_config: WorkloadConfig defines which actions are enabled for a cluster's workload configurations.
        :param pulumi.Input['ProtectConfigWorkloadVulnerabilityMode'] workload_vulnerability_mode: Sets which mode to use for Protect workload vulnerability scanning feature.
        """
        if workload_config is not None:
            pulumi.set(__self__, 'workload_config', workload_config)
        if workload_vulnerability_mode is not None:
            pulumi.set(__self__, 'workload_vulnerability_mode',
                workload_vulnerability_mode)

    @property
    @pulumi.getter(name='workloadConfig')
    def workload_config(self) ->Optional[pulumi.Input['WorkloadConfigArgs']]:
        """
        WorkloadConfig defines which actions are enabled for a cluster's workload configurations.
        """
        return pulumi.get(self, 'workload_config')

    @workload_config.setter
    def workload_config(self, value: Optional[pulumi.Input[
        'WorkloadConfigArgs']]):
        pulumi.set(self, 'workload_config', value)

    @property
    @pulumi.getter(name='workloadVulnerabilityMode')
    def workload_vulnerability_mode(self) ->Optional[pulumi.Input[
        'ProtectConfigWorkloadVulnerabilityMode']]:
        """
        Sets which mode to use for Protect workload vulnerability scanning feature.
        """
        return pulumi.get(self, 'workload_vulnerability_mode')

    @workload_vulnerability_mode.setter
    def workload_vulnerability_mode(self, value: Optional[pulumi.Input[
        'ProtectConfigWorkloadVulnerabilityMode']]):
        pulumi.set(self, 'workload_vulnerability_mode', value)


@pulumi.input_type
class PubSubArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None,
        filter: Optional[pulumi.Input['FilterArgs']]=None, topic: Optional[
        pulumi.Input[str]]=None):
        """
        Pub/Sub specific notification config.
        :param pulumi.Input[bool] enabled: Enable notifications for Pub/Sub.
        :param pulumi.Input['FilterArgs'] filter: Allows filtering to one or more specific event types. If no filter is specified, or if a filter is specified with no event types, all event types will be sent
        :param pulumi.Input[str] topic: The desired Pub/Sub topic to which notifications will be sent by GKE. Format is `projects/{project}/topics/{topic}`.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)
        if filter is not None:
            pulumi.set(__self__, 'filter', filter)
        if topic is not None:
            pulumi.set(__self__, 'topic', topic)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Enable notifications for Pub/Sub.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)

    @property
    @pulumi.getter
    def filter(self) ->Optional[pulumi.Input['FilterArgs']]:
        """
        Allows filtering to one or more specific event types. If no filter is specified, or if a filter is specified with no event types, all event types will be sent
        """
        return pulumi.get(self, 'filter')

    @filter.setter
    def filter(self, value: Optional[pulumi.Input['FilterArgs']]):
        pulumi.set(self, 'filter', value)

    @property
    @pulumi.getter
    def topic(self) ->Optional[pulumi.Input[str]]:
        """
        The desired Pub/Sub topic to which notifications will be sent by GKE. Format is `projects/{project}/topics/{topic}`.
        """
        return pulumi.get(self, 'topic')

    @topic.setter
    def topic(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'topic', value)


@pulumi.input_type
class RecurringTimeWindowArgs:

    def __init__(__self__, *, recurrence: Optional[pulumi.Input[str]]=None,
        window: Optional[pulumi.Input['TimeWindowArgs']]=None):
        """
        Represents an arbitrary window of time that recurs.
        :param pulumi.Input[str] recurrence: An RRULE (https://tools.ietf.org/html/rfc5545#section-3.8.5.3) for how this window reccurs. They go on for the span of time between the start and end time. For example, to have something repeat every weekday, you'd use: `FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR` To repeat some window daily (equivalent to the DailyMaintenanceWindow): `FREQ=DAILY` For the first weekend of every month: `FREQ=MONTHLY;BYSETPOS=1;BYDAY=SA,SU` This specifies how frequently the window starts. Eg, if you wanted to have a 9-5 UTC-4 window every weekday, you'd use something like: ``` start time = 2019-01-01T09:00:00-0400 end time = 2019-01-01T17:00:00-0400 recurrence = FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR ``` Windows can span multiple days. Eg, to make the window encompass every weekend from midnight Saturday till the last minute of Sunday UTC: ``` start time = 2019-01-05T00:00:00Z end time = 2019-01-07T23:59:00Z recurrence = FREQ=WEEKLY;BYDAY=SA ``` Note the start and end time's specific dates are largely arbitrary except to specify duration of the window and when it first starts. The FREQ values of HOURLY, MINUTELY, and SECONDLY are not supported.
        :param pulumi.Input['TimeWindowArgs'] window: The window of the first recurrence.
        """
        if recurrence is not None:
            pulumi.set(__self__, 'recurrence', recurrence)
        if window is not None:
            pulumi.set(__self__, 'window', window)

    @property
    @pulumi.getter
    def recurrence(self) ->Optional[pulumi.Input[str]]:
        """
        An RRULE (https://tools.ietf.org/html/rfc5545#section-3.8.5.3) for how this window reccurs. They go on for the span of time between the start and end time. For example, to have something repeat every weekday, you'd use: `FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR` To repeat some window daily (equivalent to the DailyMaintenanceWindow): `FREQ=DAILY` For the first weekend of every month: `FREQ=MONTHLY;BYSETPOS=1;BYDAY=SA,SU` This specifies how frequently the window starts. Eg, if you wanted to have a 9-5 UTC-4 window every weekday, you'd use something like: ``` start time = 2019-01-01T09:00:00-0400 end time = 2019-01-01T17:00:00-0400 recurrence = FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR ``` Windows can span multiple days. Eg, to make the window encompass every weekend from midnight Saturday till the last minute of Sunday UTC: ``` start time = 2019-01-05T00:00:00Z end time = 2019-01-07T23:59:00Z recurrence = FREQ=WEEKLY;BYDAY=SA ``` Note the start and end time's specific dates are largely arbitrary except to specify duration of the window and when it first starts. The FREQ values of HOURLY, MINUTELY, and SECONDLY are not supported.
        """
        return pulumi.get(self, 'recurrence')

    @recurrence.setter
    def recurrence(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'recurrence', value)

    @property
    @pulumi.getter
    def window(self) ->Optional[pulumi.Input['TimeWindowArgs']]:
        """
        The window of the first recurrence.
        """
        return pulumi.get(self, 'window')

    @window.setter
    def window(self, value: Optional[pulumi.Input['TimeWindowArgs']]):
        pulumi.set(self, 'window', value)


@pulumi.input_type
class ReleaseChannelArgs:

    def __init__(__self__, *, channel: Optional[pulumi.Input[
        'ReleaseChannelChannel']]=None):
        """
        ReleaseChannel indicates which release channel a cluster is subscribed to. Release channels are arranged in order of risk. When a cluster is subscribed to a release channel, Google maintains both the master version and the node version. Node auto-upgrade defaults to true and cannot be disabled.
        :param pulumi.Input['ReleaseChannelChannel'] channel: channel specifies which release channel the cluster is subscribed to.
        """
        if channel is not None:
            pulumi.set(__self__, 'channel', channel)

    @property
    @pulumi.getter
    def channel(self) ->Optional[pulumi.Input['ReleaseChannelChannel']]:
        """
        channel specifies which release channel the cluster is subscribed to.
        """
        return pulumi.get(self, 'channel')

    @channel.setter
    def channel(self, value: Optional[pulumi.Input['ReleaseChannelChannel']]):
        pulumi.set(self, 'channel', value)


@pulumi.input_type
class ReservationAffinityArgs:

    def __init__(__self__, *, consume_reservation_type: Optional[pulumi.
        Input['ReservationAffinityConsumeReservationType']]=None, key:
        Optional[pulumi.Input[str]]=None, values: Optional[pulumi.Input[
        Sequence[pulumi.Input[str]]]]=None):
        """
        [ReservationAffinity](https://cloud.google.com/compute/docs/instances/reserving-zonal-resources) is the configuration of desired reservation which instances could take capacity from.
        :param pulumi.Input['ReservationAffinityConsumeReservationType'] consume_reservation_type: Corresponds to the type of reservation consumption.
        :param pulumi.Input[str] key: Corresponds to the label key of a reservation resource. To target a SPECIFIC_RESERVATION by name, specify "compute.googleapis.com/reservation-name" as the key and specify the name of your reservation as its value.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: Corresponds to the label value(s) of reservation resource(s).
        """
        if consume_reservation_type is not None:
            pulumi.set(__self__, 'consume_reservation_type',
                consume_reservation_type)
        if key is not None:
            pulumi.set(__self__, 'key', key)
        if values is not None:
            pulumi.set(__self__, 'values', values)

    @property
    @pulumi.getter(name='consumeReservationType')
    def consume_reservation_type(self) ->Optional[pulumi.Input[
        'ReservationAffinityConsumeReservationType']]:
        """
        Corresponds to the type of reservation consumption.
        """
        return pulumi.get(self, 'consume_reservation_type')

    @consume_reservation_type.setter
    def consume_reservation_type(self, value: Optional[pulumi.Input[
        'ReservationAffinityConsumeReservationType']]):
        pulumi.set(self, 'consume_reservation_type', value)

    @property
    @pulumi.getter
    def key(self) ->Optional[pulumi.Input[str]]:
        """
        Corresponds to the label key of a reservation resource. To target a SPECIFIC_RESERVATION by name, specify "compute.googleapis.com/reservation-name" as the key and specify the name of your reservation as its value.
        """
        return pulumi.get(self, 'key')

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'key', value)

    @property
    @pulumi.getter
    def values(self) ->Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Corresponds to the label value(s) of reservation resource(s).
        """
        return pulumi.get(self, 'values')

    @values.setter
    def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]
        ):
        pulumi.set(self, 'values', value)


@pulumi.input_type
class ResourceLimitArgs:

    def __init__(__self__, *, maximum: Optional[pulumi.Input[str]]=None,
        minimum: Optional[pulumi.Input[str]]=None, resource_type: Optional[
        pulumi.Input[str]]=None):
        """
        Contains information about amount of some resource in the cluster. For memory, value should be in GB.
        :param pulumi.Input[str] maximum: Maximum amount of the resource in the cluster.
        :param pulumi.Input[str] minimum: Minimum amount of the resource in the cluster.
        :param pulumi.Input[str] resource_type: Resource name "cpu", "memory" or gpu-specific string.
        """
        if maximum is not None:
            pulumi.set(__self__, 'maximum', maximum)
        if minimum is not None:
            pulumi.set(__self__, 'minimum', minimum)
        if resource_type is not None:
            pulumi.set(__self__, 'resource_type', resource_type)

    @property
    @pulumi.getter
    def maximum(self) ->Optional[pulumi.Input[str]]:
        """
        Maximum amount of the resource in the cluster.
        """
        return pulumi.get(self, 'maximum')

    @maximum.setter
    def maximum(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'maximum', value)

    @property
    @pulumi.getter
    def minimum(self) ->Optional[pulumi.Input[str]]:
        """
        Minimum amount of the resource in the cluster.
        """
        return pulumi.get(self, 'minimum')

    @minimum.setter
    def minimum(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'minimum', value)

    @property
    @pulumi.getter(name='resourceType')
    def resource_type(self) ->Optional[pulumi.Input[str]]:
        """
        Resource name "cpu", "memory" or gpu-specific string.
        """
        return pulumi.get(self, 'resource_type')

    @resource_type.setter
    def resource_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'resource_type', value)


@pulumi.input_type
class ResourceUsageExportConfigArgs:

    def __init__(__self__, *, bigquery_destination: Optional[pulumi.Input[
        'BigQueryDestinationArgs']]=None, consumption_metering_config:
        Optional[pulumi.Input['ConsumptionMeteringConfigArgs']]=None,
        enable_network_egress_metering: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for exporting cluster resource usages.
        :param pulumi.Input['BigQueryDestinationArgs'] bigquery_destination: Configuration to use BigQuery as usage export destination.
        :param pulumi.Input['ConsumptionMeteringConfigArgs'] consumption_metering_config: Configuration to enable resource consumption metering.
        :param pulumi.Input[bool] enable_network_egress_metering: Whether to enable network egress metering for this cluster. If enabled, a daemonset will be created in the cluster to meter network egress traffic.
        """
        if bigquery_destination is not None:
            pulumi.set(__self__, 'bigquery_destination', bigquery_destination)
        if consumption_metering_config is not None:
            pulumi.set(__self__, 'consumption_metering_config',
                consumption_metering_config)
        if enable_network_egress_metering is not None:
            pulumi.set(__self__, 'enable_network_egress_metering',
                enable_network_egress_metering)

    @property
    @pulumi.getter(name='bigqueryDestination')
    def bigquery_destination(self) ->Optional[pulumi.Input[
        'BigQueryDestinationArgs']]:
        """
        Configuration to use BigQuery as usage export destination.
        """
        return pulumi.get(self, 'bigquery_destination')

    @bigquery_destination.setter
    def bigquery_destination(self, value: Optional[pulumi.Input[
        'BigQueryDestinationArgs']]):
        pulumi.set(self, 'bigquery_destination', value)

    @property
    @pulumi.getter(name='consumptionMeteringConfig')
    def consumption_metering_config(self) ->Optional[pulumi.Input[
        'ConsumptionMeteringConfigArgs']]:
        """
        Configuration to enable resource consumption metering.
        """
        return pulumi.get(self, 'consumption_metering_config')

    @consumption_metering_config.setter
    def consumption_metering_config(self, value: Optional[pulumi.Input[
        'ConsumptionMeteringConfigArgs']]):
        pulumi.set(self, 'consumption_metering_config', value)

    @property
    @pulumi.getter(name='enableNetworkEgressMetering')
    def enable_network_egress_metering(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether to enable network egress metering for this cluster. If enabled, a daemonset will be created in the cluster to meter network egress traffic.
        """
        return pulumi.get(self, 'enable_network_egress_metering')

    @enable_network_egress_metering.setter
    def enable_network_egress_metering(self, value: Optional[pulumi.Input[
        bool]]):
        pulumi.set(self, 'enable_network_egress_metering', value)


@pulumi.input_type
class SandboxConfigArgs:

    def __init__(__self__, *, sandbox_type: Optional[pulumi.Input[str]]=
        None, type: Optional[pulumi.Input['SandboxConfigType']]=None):
        """
        SandboxConfig contains configurations of the sandbox to use for the node.
        :param pulumi.Input[str] sandbox_type: Type of the sandbox to use for the node (e.g. 'gvisor')
        :param pulumi.Input['SandboxConfigType'] type: Type of the sandbox to use for the node.
        """
        if sandbox_type is not None:
            pulumi.set(__self__, 'sandbox_type', sandbox_type)
        if type is not None:
            pulumi.set(__self__, 'type', type)

    @property
    @pulumi.getter(name='sandboxType')
    def sandbox_type(self) ->Optional[pulumi.Input[str]]:
        """
        Type of the sandbox to use for the node (e.g. 'gvisor')
        """
        return pulumi.get(self, 'sandbox_type')

    @sandbox_type.setter
    def sandbox_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'sandbox_type', value)

    @property
    @pulumi.getter
    def type(self) ->Optional[pulumi.Input['SandboxConfigType']]:
        """
        Type of the sandbox to use for the node.
        """
        return pulumi.get(self, 'type')

    @type.setter
    def type(self, value: Optional[pulumi.Input['SandboxConfigType']]):
        pulumi.set(self, 'type', value)


@pulumi.input_type
class ServiceExternalIPsConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Config to block services with externalIPs field.
        :param pulumi.Input[bool] enabled: Whether Services with ExternalIPs field are allowed or not.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Services with ExternalIPs field are allowed or not.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class ShieldedInstanceConfigArgs:

    def __init__(__self__, *, enable_integrity_monitoring: Optional[pulumi.
        Input[bool]]=None, enable_secure_boot: Optional[pulumi.Input[bool]]
        =None):
        """
        A set of Shielded Instance options.
        :param pulumi.Input[bool] enable_integrity_monitoring: Defines whether the instance has integrity monitoring enabled. Enables monitoring and attestation of the boot integrity of the instance. The attestation is performed against the integrity policy baseline. This baseline is initially derived from the implicitly trusted boot image when the instance is created.
        :param pulumi.Input[bool] enable_secure_boot: Defines whether the instance has Secure Boot enabled. Secure Boot helps ensure that the system only runs authentic software by verifying the digital signature of all boot components, and halting the boot process if signature verification fails.
        """
        if enable_integrity_monitoring is not None:
            pulumi.set(__self__, 'enable_integrity_monitoring',
                enable_integrity_monitoring)
        if enable_secure_boot is not None:
            pulumi.set(__self__, 'enable_secure_boot', enable_secure_boot)

    @property
    @pulumi.getter(name='enableIntegrityMonitoring')
    def enable_integrity_monitoring(self) ->Optional[pulumi.Input[bool]]:
        """
        Defines whether the instance has integrity monitoring enabled. Enables monitoring and attestation of the boot integrity of the instance. The attestation is performed against the integrity policy baseline. This baseline is initially derived from the implicitly trusted boot image when the instance is created.
        """
        return pulumi.get(self, 'enable_integrity_monitoring')

    @enable_integrity_monitoring.setter
    def enable_integrity_monitoring(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_integrity_monitoring', value)

    @property
    @pulumi.getter(name='enableSecureBoot')
    def enable_secure_boot(self) ->Optional[pulumi.Input[bool]]:
        """
        Defines whether the instance has Secure Boot enabled. Secure Boot helps ensure that the system only runs authentic software by verifying the digital signature of all boot components, and halting the boot process if signature verification fails.
        """
        return pulumi.get(self, 'enable_secure_boot')

    @enable_secure_boot.setter
    def enable_secure_boot(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_secure_boot', value)


@pulumi.input_type
class ShieldedNodesArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration of Shielded Nodes feature.
        :param pulumi.Input[bool] enabled: Whether Shielded Nodes features are enabled on all nodes in this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Shielded Nodes features are enabled on all nodes in this cluster.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class StandardRolloutPolicyArgs:

    def __init__(__self__, *, batch_node_count: Optional[pulumi.Input[int]]
        =None, batch_percentage: Optional[pulumi.Input[float]]=None,
        batch_soak_duration: Optional[pulumi.Input[str]]=None):
        """
        Standard rollout policy is the default policy for blue-green.
        :param pulumi.Input[int] batch_node_count: Number of blue nodes to drain in a batch.
        :param pulumi.Input[float] batch_percentage: Percentage of the blue pool nodes to drain in a batch. The range of this field should be (0.0, 1.0].
        :param pulumi.Input[str] batch_soak_duration: Soak time after each batch gets drained. Default to zero.
        """
        if batch_node_count is not None:
            pulumi.set(__self__, 'batch_node_count', batch_node_count)
        if batch_percentage is not None:
            pulumi.set(__self__, 'batch_percentage', batch_percentage)
        if batch_soak_duration is not None:
            pulumi.set(__self__, 'batch_soak_duration', batch_soak_duration)

    @property
    @pulumi.getter(name='batchNodeCount')
    def batch_node_count(self) ->Optional[pulumi.Input[int]]:
        """
        Number of blue nodes to drain in a batch.
        """
        return pulumi.get(self, 'batch_node_count')

    @batch_node_count.setter
    def batch_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'batch_node_count', value)

    @property
    @pulumi.getter(name='batchPercentage')
    def batch_percentage(self) ->Optional[pulumi.Input[float]]:
        """
        Percentage of the blue pool nodes to drain in a batch. The range of this field should be (0.0, 1.0].
        """
        return pulumi.get(self, 'batch_percentage')

    @batch_percentage.setter
    def batch_percentage(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, 'batch_percentage', value)

    @property
    @pulumi.getter(name='batchSoakDuration')
    def batch_soak_duration(self) ->Optional[pulumi.Input[str]]:
        """
        Soak time after each batch gets drained. Default to zero.
        """
        return pulumi.get(self, 'batch_soak_duration')

    @batch_soak_duration.setter
    def batch_soak_duration(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'batch_soak_duration', value)


@pulumi.input_type
class StatusConditionArgs:

    def __init__(__self__, *, canonical_code: Optional[pulumi.Input[
        'StatusConditionCanonicalCode']]=None, code: Optional[pulumi.Input[
        'StatusConditionCode']]=None, message: Optional[pulumi.Input[str]]=None
        ):
        """
        StatusCondition describes why a cluster or a node pool has a certain status (e.g., ERROR or DEGRADED).
        :param pulumi.Input['StatusConditionCanonicalCode'] canonical_code: Canonical code of the condition.
        :param pulumi.Input['StatusConditionCode'] code: Machine-friendly representation of the condition Deprecated. Use canonical_code instead.
        :param pulumi.Input[str] message: Human-friendly representation of the condition
        """
        if canonical_code is not None:
            pulumi.set(__self__, 'canonical_code', canonical_code)
        if code is not None:
            warnings.warn(
                'Machine-friendly representation of the condition Deprecated. Use canonical_code instead.'
                , DeprecationWarning)
            pulumi.log.warn(
                'code is deprecated: Machine-friendly representation of the condition Deprecated. Use canonical_code instead.'
                )
        if code is not None:
            pulumi.set(__self__, 'code', code)
        if message is not None:
            pulumi.set(__self__, 'message', message)

    @property
    @pulumi.getter(name='canonicalCode')
    def canonical_code(self) ->Optional[pulumi.Input[
        'StatusConditionCanonicalCode']]:
        """
        Canonical code of the condition.
        """
        return pulumi.get(self, 'canonical_code')

    @canonical_code.setter
    def canonical_code(self, value: Optional[pulumi.Input[
        'StatusConditionCanonicalCode']]):
        pulumi.set(self, 'canonical_code', value)

    @property
    @pulumi.getter
    def code(self) ->Optional[pulumi.Input['StatusConditionCode']]:
        """
        Machine-friendly representation of the condition Deprecated. Use canonical_code instead.
        """
        warnings.warn(
            'Machine-friendly representation of the condition Deprecated. Use canonical_code instead.'
            , DeprecationWarning)
        pulumi.log.warn(
            'code is deprecated: Machine-friendly representation of the condition Deprecated. Use canonical_code instead.'
            )
        return pulumi.get(self, 'code')

    @code.setter
    def code(self, value: Optional[pulumi.Input['StatusConditionCode']]):
        pulumi.set(self, 'code', value)

    @property
    @pulumi.getter
    def message(self) ->Optional[pulumi.Input[str]]:
        """
        Human-friendly representation of the condition
        """
        return pulumi.get(self, 'message')

    @message.setter
    def message(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'message', value)


@pulumi.input_type
class TimeWindowArgs:

    def __init__(__self__, *, end_time: Optional[pulumi.Input[str]]=None,
        maintenance_exclusion_options: Optional[pulumi.Input[
        'MaintenanceExclusionOptionsArgs']]=None, start_time: Optional[
        pulumi.Input[str]]=None):
        """
        Represents an arbitrary window of time.
        :param pulumi.Input[str] end_time: The time that the window ends. The end time should take place after the start time.
        :param pulumi.Input['MaintenanceExclusionOptionsArgs'] maintenance_exclusion_options: MaintenanceExclusionOptions provides maintenance exclusion related options.
        :param pulumi.Input[str] start_time: The time that the window first starts.
        """
        if end_time is not None:
            pulumi.set(__self__, 'end_time', end_time)
        if maintenance_exclusion_options is not None:
            pulumi.set(__self__, 'maintenance_exclusion_options',
                maintenance_exclusion_options)
        if start_time is not None:
            pulumi.set(__self__, 'start_time', start_time)

    @property
    @pulumi.getter(name='endTime')
    def end_time(self) ->Optional[pulumi.Input[str]]:
        """
        The time that the window ends. The end time should take place after the start time.
        """
        return pulumi.get(self, 'end_time')

    @end_time.setter
    def end_time(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'end_time', value)

    @property
    @pulumi.getter(name='maintenanceExclusionOptions')
    def maintenance_exclusion_options(self) ->Optional[pulumi.Input[
        'MaintenanceExclusionOptionsArgs']]:
        """
        MaintenanceExclusionOptions provides maintenance exclusion related options.
        """
        return pulumi.get(self, 'maintenance_exclusion_options')

    @maintenance_exclusion_options.setter
    def maintenance_exclusion_options(self, value: Optional[pulumi.Input[
        'MaintenanceExclusionOptionsArgs']]):
        pulumi.set(self, 'maintenance_exclusion_options', value)

    @property
    @pulumi.getter(name='startTime')
    def start_time(self) ->Optional[pulumi.Input[str]]:
        """
        The time that the window first starts.
        """
        return pulumi.get(self, 'start_time')

    @start_time.setter
    def start_time(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'start_time', value)


@pulumi.input_type
class TpuConfigArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None,
        ipv4_cidr_block: Optional[pulumi.Input[str]]=None,
        use_service_networking: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for Cloud TPU.
        :param pulumi.Input[bool] enabled: Whether Cloud TPU integration is enabled or not.
        :param pulumi.Input[str] ipv4_cidr_block: IPv4 CIDR block reserved for Cloud TPU in the VPC.
        :param pulumi.Input[bool] use_service_networking: Whether to use service networking for Cloud TPU or not.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)
        if ipv4_cidr_block is not None:
            pulumi.set(__self__, 'ipv4_cidr_block', ipv4_cidr_block)
        if use_service_networking is not None:
            pulumi.set(__self__, 'use_service_networking',
                use_service_networking)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether Cloud TPU integration is enabled or not.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)

    @property
    @pulumi.getter(name='ipv4CidrBlock')
    def ipv4_cidr_block(self) ->Optional[pulumi.Input[str]]:
        """
        IPv4 CIDR block reserved for Cloud TPU in the VPC.
        """
        return pulumi.get(self, 'ipv4_cidr_block')

    @ipv4_cidr_block.setter
    def ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'ipv4_cidr_block', value)

    @property
    @pulumi.getter(name='useServiceNetworking')
    def use_service_networking(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether to use service networking for Cloud TPU or not.
        """
        return pulumi.get(self, 'use_service_networking')

    @use_service_networking.setter
    def use_service_networking(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'use_service_networking', value)


@pulumi.input_type
class UpgradeSettingsArgs:

    def __init__(__self__, *, blue_green_settings: Optional[pulumi.Input[
        'BlueGreenSettingsArgs']]=None, max_surge: Optional[pulumi.Input[
        int]]=None, max_unavailable: Optional[pulumi.Input[int]]=None,
        strategy: Optional[pulumi.Input['UpgradeSettingsStrategy']]=None):
        """
        These upgrade settings configure the upgrade strategy for the node pool. Use strategy to switch between the strategies applied to the node pool. If the strategy is SURGE, use max_surge and max_unavailable to control the level of parallelism and the level of disruption caused by upgrade. 1. maxSurge controls the number of additional nodes that can be added to the node pool temporarily for the time of the upgrade to increase the number of available nodes. 2. maxUnavailable controls the number of nodes that can be simultaneously unavailable. 3. (maxUnavailable + maxSurge) determines the level of parallelism (how many nodes are being upgraded at the same time). If the strategy is BLUE_GREEN, use blue_green_settings to configure the blue-green upgrade related settings. 1. standard_rollout_policy is the default policy. The policy is used to control the way blue pool gets drained. The draining is executed in the batch mode. The batch size could be specified as either percentage of the node pool size or the number of nodes. batch_soak_duration is the soak time after each batch gets drained. 2. node_pool_soak_duration is the soak time after all blue nodes are drained. After this period, the blue pool nodes will be deleted.
        :param pulumi.Input['BlueGreenSettingsArgs'] blue_green_settings: Settings for blue-green upgrade strategy.
        :param pulumi.Input[int] max_surge: The maximum number of nodes that can be created beyond the current size of the node pool during the upgrade process.
        :param pulumi.Input[int] max_unavailable: The maximum number of nodes that can be simultaneously unavailable during the upgrade process. A node is considered available if its status is Ready.
        :param pulumi.Input['UpgradeSettingsStrategy'] strategy: Update strategy of the node pool.
        """
        if blue_green_settings is not None:
            pulumi.set(__self__, 'blue_green_settings', blue_green_settings)
        if max_surge is not None:
            pulumi.set(__self__, 'max_surge', max_surge)
        if max_unavailable is not None:
            pulumi.set(__self__, 'max_unavailable', max_unavailable)
        if strategy is not None:
            pulumi.set(__self__, 'strategy', strategy)

    @property
    @pulumi.getter(name='blueGreenSettings')
    def blue_green_settings(self) ->Optional[pulumi.Input[
        'BlueGreenSettingsArgs']]:
        """
        Settings for blue-green upgrade strategy.
        """
        return pulumi.get(self, 'blue_green_settings')

    @blue_green_settings.setter
    def blue_green_settings(self, value: Optional[pulumi.Input[
        'BlueGreenSettingsArgs']]):
        pulumi.set(self, 'blue_green_settings', value)

    @property
    @pulumi.getter(name='maxSurge')
    def max_surge(self) ->Optional[pulumi.Input[int]]:
        """
        The maximum number of nodes that can be created beyond the current size of the node pool during the upgrade process.
        """
        return pulumi.get(self, 'max_surge')

    @max_surge.setter
    def max_surge(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'max_surge', value)

    @property
    @pulumi.getter(name='maxUnavailable')
    def max_unavailable(self) ->Optional[pulumi.Input[int]]:
        """
        The maximum number of nodes that can be simultaneously unavailable during the upgrade process. A node is considered available if its status is Ready.
        """
        return pulumi.get(self, 'max_unavailable')

    @max_unavailable.setter
    def max_unavailable(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, 'max_unavailable', value)

    @property
    @pulumi.getter
    def strategy(self) ->Optional[pulumi.Input['UpgradeSettingsStrategy']]:
        """
        Update strategy of the node pool.
        """
        return pulumi.get(self, 'strategy')

    @strategy.setter
    def strategy(self, value: Optional[pulumi.Input['UpgradeSettingsStrategy']]
        ):
        pulumi.set(self, 'strategy', value)


@pulumi.input_type
class VerticalPodAutoscalingArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        VerticalPodAutoscaling contains global, per-cluster information required by Vertical Pod Autoscaler to automatically adjust the resources of pods controlled by it.
        :param pulumi.Input[bool] enabled: Enables vertical pod autoscaling.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Enables vertical pod autoscaling.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class VirtualNICArgs:

    def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None):
        """
        Configuration of gVNIC feature.
        :param pulumi.Input[bool] enabled: Whether gVNIC features are enabled in the node pool.
        """
        if enabled is not None:
            pulumi.set(__self__, 'enabled', enabled)

    @property
    @pulumi.getter
    def enabled(self) ->Optional[pulumi.Input[bool]]:
        """
        Whether gVNIC features are enabled in the node pool.
        """
        return pulumi.get(self, 'enabled')

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enabled', value)


@pulumi.input_type
class WindowsNodeConfigArgs:

    def __init__(__self__, *, os_version: Optional[pulumi.Input[
        'WindowsNodeConfigOsVersion']]=None):
        """
        Parameters that can be configured on Windows nodes. Windows Node Config that define the parameters that will be used to configure the Windows node pool settings
        :param pulumi.Input['WindowsNodeConfigOsVersion'] os_version: OSVersion specifies the Windows node config to be used on the node
        """
        if os_version is not None:
            pulumi.set(__self__, 'os_version', os_version)

    @property
    @pulumi.getter(name='osVersion')
    def os_version(self) ->Optional[pulumi.Input['WindowsNodeConfigOsVersion']
        ]:
        """
        OSVersion specifies the Windows node config to be used on the node
        """
        return pulumi.get(self, 'os_version')

    @os_version.setter
    def os_version(self, value: Optional[pulumi.Input[
        'WindowsNodeConfigOsVersion']]):
        pulumi.set(self, 'os_version', value)


@pulumi.input_type
class WorkloadALTSConfigArgs:

    def __init__(__self__, *, enable_alts: Optional[pulumi.Input[bool]]=None):
        """
        Configuration for direct-path (via ALTS) with workload identity.
        :param pulumi.Input[bool] enable_alts: enable_alts controls whether the alts handshaker should be enabled or not for direct-path. Requires Workload Identity (workload_pool must be non-empty).
        """
        if enable_alts is not None:
            pulumi.set(__self__, 'enable_alts', enable_alts)

    @property
    @pulumi.getter(name='enableAlts')
    def enable_alts(self) ->Optional[pulumi.Input[bool]]:
        """
        enable_alts controls whether the alts handshaker should be enabled or not for direct-path. Requires Workload Identity (workload_pool must be non-empty).
        """
        return pulumi.get(self, 'enable_alts')

    @enable_alts.setter
    def enable_alts(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_alts', value)


@pulumi.input_type
class WorkloadCertificatesArgs:

    def __init__(__self__, *, enable_certificates: Optional[pulumi.Input[
        bool]]=None):
        """
        Configuration for issuance of mTLS keys and certificates to Kubernetes pods.
        :param pulumi.Input[bool] enable_certificates: enable_certificates controls issuance of workload mTLS certificates. If set, the GKE Workload Identity Certificates controller and node agent will be deployed in the cluster, which can then be configured by creating a WorkloadCertificateConfig Custom Resource. Requires Workload Identity (workload_pool must be non-empty).
        """
        if enable_certificates is not None:
            pulumi.set(__self__, 'enable_certificates', enable_certificates)

    @property
    @pulumi.getter(name='enableCertificates')
    def enable_certificates(self) ->Optional[pulumi.Input[bool]]:
        """
        enable_certificates controls issuance of workload mTLS certificates. If set, the GKE Workload Identity Certificates controller and node agent will be deployed in the cluster, which can then be configured by creating a WorkloadCertificateConfig Custom Resource. Requires Workload Identity (workload_pool must be non-empty).
        """
        return pulumi.get(self, 'enable_certificates')

    @enable_certificates.setter
    def enable_certificates(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, 'enable_certificates', value)


@pulumi.input_type
class WorkloadConfigArgs:

    def __init__(__self__, *, audit_mode: Optional[pulumi.Input[
        'WorkloadConfigAuditMode']]=None):
        """
        WorkloadConfig defines the flags to enable or disable the workload configurations for the cluster.
        :param pulumi.Input['WorkloadConfigAuditMode'] audit_mode: Sets which mode of auditing should be used for the cluster's workloads.
        """
        if audit_mode is not None:
            pulumi.set(__self__, 'audit_mode', audit_mode)

    @property
    @pulumi.getter(name='auditMode')
    def audit_mode(self) ->Optional[pulumi.Input['WorkloadConfigAuditMode']]:
        """
        Sets which mode of auditing should be used for the cluster's workloads.
        """
        return pulumi.get(self, 'audit_mode')

    @audit_mode.setter
    def audit_mode(self, value: Optional[pulumi.Input[
        'WorkloadConfigAuditMode']]):
        pulumi.set(self, 'audit_mode', value)


@pulumi.input_type
class WorkloadIdentityConfigArgs:

    def __init__(__self__, *, identity_namespace: Optional[pulumi.Input[str
        ]]=None, identity_provider: Optional[pulumi.Input[str]]=None,
        workload_pool: Optional[pulumi.Input[str]]=None):
        """
        Configuration for the use of Kubernetes Service Accounts in GCP IAM policies.
        :param pulumi.Input[str] identity_namespace: IAM Identity Namespace to attach all Kubernetes Service Accounts to.
        :param pulumi.Input[str] identity_provider: identity provider is the third party identity provider.
        :param pulumi.Input[str] workload_pool: The workload pool to attach all Kubernetes service accounts to.
        """
        if identity_namespace is not None:
            pulumi.set(__self__, 'identity_namespace', identity_namespace)
        if identity_provider is not None:
            pulumi.set(__self__, 'identity_provider', identity_provider)
        if workload_pool is not None:
            pulumi.set(__self__, 'workload_pool', workload_pool)

    @property
    @pulumi.getter(name='identityNamespace')
    def identity_namespace(self) ->Optional[pulumi.Input[str]]:
        """
        IAM Identity Namespace to attach all Kubernetes Service Accounts to.
        """
        return pulumi.get(self, 'identity_namespace')

    @identity_namespace.setter
    def identity_namespace(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'identity_namespace', value)

    @property
    @pulumi.getter(name='identityProvider')
    def identity_provider(self) ->Optional[pulumi.Input[str]]:
        """
        identity provider is the third party identity provider.
        """
        return pulumi.get(self, 'identity_provider')

    @identity_provider.setter
    def identity_provider(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'identity_provider', value)

    @property
    @pulumi.getter(name='workloadPool')
    def workload_pool(self) ->Optional[pulumi.Input[str]]:
        """
        The workload pool to attach all Kubernetes service accounts to.
        """
        return pulumi.get(self, 'workload_pool')

    @workload_pool.setter
    def workload_pool(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, 'workload_pool', value)


@pulumi.input_type
class WorkloadMetadataConfigArgs:

    def __init__(__self__, *, mode: Optional[pulumi.Input[
        'WorkloadMetadataConfigMode']]=None, node_metadata: Optional[pulumi
        .Input['WorkloadMetadataConfigNodeMetadata']]=None):
        """
        WorkloadMetadataConfig defines the metadata configuration to expose to workloads on the node pool.
        :param pulumi.Input['WorkloadMetadataConfigMode'] mode: Mode is the configuration for how to expose metadata to workloads running on the node pool.
        :param pulumi.Input['WorkloadMetadataConfigNodeMetadata'] node_metadata: NodeMetadata is the configuration for how to expose metadata to the workloads running on the node.
        """
        if mode is not None:
            pulumi.set(__self__, 'mode', mode)
        if node_metadata is not None:
            pulumi.set(__self__, 'node_metadata', node_metadata)

    @property
    @pulumi.getter
    def mode(self) ->Optional[pulumi.Input['WorkloadMetadataConfigMode']]:
        """
        Mode is the configuration for how to expose metadata to workloads running on the node pool.
        """
        return pulumi.get(self, 'mode')

    @mode.setter
    def mode(self, value: Optional[pulumi.Input['WorkloadMetadataConfigMode']]
        ):
        pulumi.set(self, 'mode', value)

    @property
    @pulumi.getter(name='nodeMetadata')
    def node_metadata(self) ->Optional[pulumi.Input[
        'WorkloadMetadataConfigNodeMetadata']]:
        """
        NodeMetadata is the configuration for how to expose metadata to the workloads running on the node.
        """
        return pulumi.get(self, 'node_metadata')

    @node_metadata.setter
    def node_metadata(self, value: Optional[pulumi.Input[
        'WorkloadMetadataConfigNodeMetadata']]):
        pulumi.set(self, 'node_metadata', value)

# coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import copy
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from ... import _utilities
from ._enums import *

__all__ = [
    'AcceleratorConfigArgs',
    'AddonsConfigArgs',
    'AdvancedMachineFeaturesArgs',
    'AuthenticatorGroupsConfigArgs',
    'AutoUpgradeOptionsArgs',
    'AutopilotArgs',
    'AutoprovisioningNodePoolDefaultsArgs',
    'BigQueryDestinationArgs',
    'BinaryAuthorizationArgs',
    'BlueGreenSettingsArgs',
    'CidrBlockArgs',
    'ClientCertificateConfigArgs',
    'CloudRunConfigArgs',
    'ClusterAutoscalingArgs',
    'ClusterTelemetryArgs',
    'ConfidentialNodesArgs',
    'ConfigConnectorConfigArgs',
    'ConsumptionMeteringConfigArgs',
    'CostManagementConfigArgs',
    'DNSConfigArgs',
    'DailyMaintenanceWindowArgs',
    'DatabaseEncryptionArgs',
    'DefaultSnatStatusArgs',
    'DnsCacheConfigArgs',
    'EphemeralStorageConfigArgs',
    'EphemeralStorageLocalSsdConfigArgs',
    'FastSocketArgs',
    'FilterArgs',
    'FleetArgs',
    'GPUSharingConfigArgs',
    'GatewayAPIConfigArgs',
    'GcePersistentDiskCsiDriverConfigArgs',
    'GcfsConfigArgs',
    'GcpFilestoreCsiDriverConfigArgs',
    'GcsFuseCsiDriverConfigArgs',
    'GkeBackupAgentConfigArgs',
    'HorizontalPodAutoscalingArgs',
    'HttpLoadBalancingArgs',
    'IPAllocationPolicyArgs',
    'IdentityServiceConfigArgs',
    'IstioConfigArgs',
    'KalmConfigArgs',
    'KubernetesDashboardArgs',
    'LegacyAbacArgs',
    'LinuxNodeConfigArgs',
    'LocalNvmeSsdBlockConfigArgs',
    'LoggingComponentConfigArgs',
    'LoggingConfigArgs',
    'LoggingVariantConfigArgs',
    'MaintenanceExclusionOptionsArgs',
    'MaintenancePolicyArgs',
    'MaintenanceWindowArgs',
    'ManagedPrometheusConfigArgs',
    'MasterAuthorizedNetworksConfigArgs',
    'MasterAuthArgs',
    'MasterArgs',
    'MaxPodsConstraintArgs',
    'MeshCertificatesArgs',
    'MonitoringComponentConfigArgs',
    'MonitoringConfigArgs',
    'NetworkConfigArgs',
    'NetworkPerformanceConfigArgs',
    'NetworkPolicyConfigArgs',
    'NetworkPolicyArgs',
    'NetworkTagsArgs',
    'NodeConfigDefaultsArgs',
    'NodeConfigArgs',
    'NodeKubeletConfigArgs',
    'NodeManagementArgs',
    'NodeNetworkConfigArgs',
    'NodePoolAutoConfigArgs',
    'NodePoolAutoscalingArgs',
    'NodePoolDefaultsArgs',
    'NodePoolLoggingConfigArgs',
    'NodePoolArgs',
    'NodeTaintArgs',
    'NotificationConfigArgs',
    'PlacementPolicyArgs',
    'PodCIDROverprovisionConfigArgs',
    'PodSecurityPolicyConfigArgs',
    'PrivateClusterConfigArgs',
    'PrivateClusterMasterGlobalAccessConfigArgs',
    'ProtectConfigArgs',
    'PubSubArgs',
    'RecurringTimeWindowArgs',
    'ReleaseChannelArgs',
    'ReservationAffinityArgs',
    'ResourceLimitArgs',
    'ResourceUsageExportConfigArgs',
    'SandboxConfigArgs',
    'ServiceExternalIPsConfigArgs',
    'ShieldedInstanceConfigArgs',
    'ShieldedNodesArgs',
    'StandardRolloutPolicyArgs',
    'StatusConditionArgs',
    'TimeWindowArgs',
    'TpuConfigArgs',
    'UpgradeSettingsArgs',
    'VerticalPodAutoscalingArgs',
    'VirtualNICArgs',
    'WindowsNodeConfigArgs',
    'WorkloadALTSConfigArgs',
    'WorkloadCertificatesArgs',
    'WorkloadConfigArgs',
    'WorkloadIdentityConfigArgs',
    'WorkloadMetadataConfigArgs',
]

@pulumi.input_type
class AcceleratorConfigArgs:
    def __init__(__self__, *,
                 accelerator_count: Optional[pulumi.Input[str]] = None,
                 accelerator_type: Optional[pulumi.Input[str]] = None,
                 gpu_partition_size: Optional[pulumi.Input[str]] = None,
                 gpu_sharing_config: Optional[pulumi.Input['GPUSharingConfigArgs']] = None,
                 max_time_shared_clients_per_gpu: Optional[pulumi.Input[str]] = None):
        """
        AcceleratorConfig represents a Hardware Accelerator request.
        :param pulumi.Input[str] accelerator_count: The number of the accelerator cards exposed to an instance.
        :param pulumi.Input[str] accelerator_type: The accelerator type resource name. List of supported accelerators [here](https://cloud.google.com/compute/docs/gpus)
        :param pulumi.Input[str] gpu_partition_size: Size of partitions to create on the GPU. Valid values are described in the NVIDIA [mig user guide](https://docs.nvidia.com/datacenter/tesla/mig-user-guide/#partitioning).
        :param pulumi.Input['GPUSharingConfigArgs'] gpu_sharing_config: The configuration for GPU sharing options.
        :param pulumi.Input[str] max_time_shared_clients_per_gpu: The number of time-shared GPU resources to expose for each physical GPU.
        """
        if accelerator_count is not None:
            pulumi.set(__self__, "accelerator_count", accelerator_count)
        if accelerator_type is not None:
            pulumi.set(__self__, "accelerator_type", accelerator_type)
        if gpu_partition_size is not None:
            pulumi.set(__self__, "gpu_partition_size", gpu_partition_size)
        if gpu_sharing_config is not None:
            pulumi.set(__self__, "gpu_sharing_config", gpu_sharing_config)
        if max_time_shared_clients_per_gpu is not None:
            pulumi.set(__self__, "max_time_shared_clients_per_gpu", max_time_shared_clients_per_gpu)

    @property
    @pulumi.getter(name="acceleratorCount")
    def accelerator_count(self) -> Optional[pulumi.Input[str]]:
        """
        The number of the accelerator cards exposed to an instance.
        """
        return pulumi.get(self, "accelerator_count")

    @accelerator_count.setter
    def accelerator_count(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "accelerator_count", value)

    @property
    @pulumi.getter(name="acceleratorType")
    def accelerator_type(self) -> Optional[pulumi.Input[str]]:
        """
        The accelerator type resource name. List of supported accelerators [here](https://cloud.google.com/compute/docs/gpus)
        """
        return pulumi.get(self, "accelerator_type")

    @accelerator_type.setter
    def accelerator_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "accelerator_type", value)

    @property
    @pulumi.getter(name="gpuPartitionSize")
    def gpu_partition_size(self) -> Optional[pulumi.Input[str]]:
        """
        Size of partitions to create on the GPU. Valid values are described in the NVIDIA [mig user guide](https://docs.nvidia.com/datacenter/tesla/mig-user-guide/#partitioning).
        """
        return pulumi.get(self, "gpu_partition_size")

    @gpu_partition_size.setter
    def gpu_partition_size(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "gpu_partition_size", value)

    @property
    @pulumi.getter(name="gpuSharingConfig")
    def gpu_sharing_config(self) -> Optional[pulumi.Input['GPUSharingConfigArgs']]:
        """
        The configuration for GPU sharing options.
        """
        return pulumi.get(self, "gpu_sharing_config")

    @gpu_sharing_config.setter
    def gpu_sharing_config(self, value: Optional[pulumi.Input['GPUSharingConfigArgs']]):
        pulumi.set(self, "gpu_sharing_config", value)

    @property
    @pulumi.getter(name="maxTimeSharedClientsPerGpu")
    def max_time_shared_clients_per_gpu(self) -> Optional[pulumi.Input[str]]:
        """
        The number of time-shared GPU resources to expose for each physical GPU.
        """
        return pulumi.get(self, "max_time_shared_clients_per_gpu")

    @max_time_shared_clients_per_gpu.setter
    def max_time_shared_clients_per_gpu(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "max_time_shared_clients_per_gpu", value)


@pulumi.input_type
class AddonsConfigArgs:
    def __init__(__self__, *,
                 cloud_run_config: Optional[pulumi.Input['CloudRunConfigArgs']] = None,
                 config_connector_config: Optional[pulumi.Input['ConfigConnectorConfigArgs']] = None,
                 dns_cache_config: Optional[pulumi.Input['DnsCacheConfigArgs']] = None,
                 gce_persistent_disk_csi_driver_config: Optional[pulumi.Input['GcePersistentDiskCsiDriverConfigArgs']] = None,
                 gcp_filestore_csi_driver_config: Optional[pulumi.Input['GcpFilestoreCsiDriverConfigArgs']] = None,
                 gcs_fuse_csi_driver_config: Optional[pulumi.Input['GcsFuseCsiDriverConfigArgs']] = None,
                 gke_backup_agent_config: Optional[pulumi.Input['GkeBackupAgentConfigArgs']] = None,
                 horizontal_pod_autoscaling: Optional[pulumi.Input['HorizontalPodAutoscalingArgs']] = None,
                 http_load_balancing: Optional[pulumi.Input['HttpLoadBalancingArgs']] = None,
                 istio_config: Optional[pulumi.Input['IstioConfigArgs']] = None,
                 kalm_config: Optional[pulumi.Input['KalmConfigArgs']] = None,
                 kubernetes_dashboard: Optional[pulumi.Input['KubernetesDashboardArgs']] = None,
                 network_policy_config: Optional[pulumi.Input['NetworkPolicyConfigArgs']] = None):
        """
        Configuration for the addons that can be automatically spun up in the cluster, enabling additional functionality.
        :param pulumi.Input['CloudRunConfigArgs'] cloud_run_config: Configuration for the Cloud Run addon. The `IstioConfig` addon must be enabled in order to enable Cloud Run addon. This option can only be enabled at cluster creation time.
        :param pulumi.Input['ConfigConnectorConfigArgs'] config_connector_config: Configuration for the ConfigConnector add-on, a Kubernetes extension to manage hosted GCP services through the Kubernetes API
        :param pulumi.Input['DnsCacheConfigArgs'] dns_cache_config: Configuration for NodeLocalDNS, a dns cache running on cluster nodes
        :param pulumi.Input['GcePersistentDiskCsiDriverConfigArgs'] gce_persistent_disk_csi_driver_config: Configuration for the Compute Engine Persistent Disk CSI driver.
        :param pulumi.Input['GcpFilestoreCsiDriverConfigArgs'] gcp_filestore_csi_driver_config: Configuration for the GCP Filestore CSI driver.
        :param pulumi.Input['GcsFuseCsiDriverConfigArgs'] gcs_fuse_csi_driver_config: Configuration for the Cloud Storage Fuse CSI driver.
        :param pulumi.Input['GkeBackupAgentConfigArgs'] gke_backup_agent_config: Configuration for the Backup for GKE agent addon.
        :param pulumi.Input['HorizontalPodAutoscalingArgs'] horizontal_pod_autoscaling: Configuration for the horizontal pod autoscaling feature, which increases or decreases the number of replica pods a replication controller has based on the resource usage of the existing pods.
        :param pulumi.Input['HttpLoadBalancingArgs'] http_load_balancing: Configuration for the HTTP (L7) load balancing controller addon, which makes it easy to set up HTTP load balancers for services in a cluster.
        :param pulumi.Input['IstioConfigArgs'] istio_config: Configuration for Istio, an open platform to connect, manage, and secure microservices.
        :param pulumi.Input['KalmConfigArgs'] kalm_config: Configuration for the KALM addon, which manages the lifecycle of k8s applications.
        :param pulumi.Input['KubernetesDashboardArgs'] kubernetes_dashboard: Configuration for the Kubernetes Dashboard. This addon is deprecated, and will be disabled in 1.15. It is recommended to use the Cloud Console to manage and monitor your Kubernetes clusters, workloads and applications. For more information, see: https://cloud.google.com/kubernetes-engine/docs/concepts/dashboards
        :param pulumi.Input['NetworkPolicyConfigArgs'] network_policy_config: Configuration for NetworkPolicy. This only tracks whether the addon is enabled or not on the Master, it does not track whether network policy is enabled for the nodes.
        """
        if cloud_run_config is not None:
            pulumi.set(__self__, "cloud_run_config", cloud_run_config)
        if config_connector_config is not None:
            pulumi.set(__self__, "config_connector_config", config_connector_config)
        if dns_cache_config is not None:
            pulumi.set(__self__, "dns_cache_config", dns_cache_config)
        if gce_persistent_disk_csi_driver_config is not None:
            pulumi.set(__self__, "gce_persistent_disk_csi_driver_config", gce_persistent_disk_csi_driver_config)
        if gcp_filestore_csi_driver_config is not None:
            pulumi.set(__self__, "gcp_filestore_csi_driver_config", gcp_filestore_csi_driver_config)
        if gcs_fuse_csi_driver_config is not None:
            pulumi.set(__self__, "gcs_fuse_csi_driver_config", gcs_fuse_csi_driver_config)
        if gke_backup_agent_config is not None:
            pulumi.set(__self__, "gke_backup_agent_config", gke_backup_agent_config)
        if horizontal_pod_autoscaling is not None:
            pulumi.set(__self__, "horizontal_pod_autoscaling", horizontal_pod_autoscaling)
        if http_load_balancing is not None:
            pulumi.set(__self__, "http_load_balancing", http_load_balancing)
        if istio_config is not None:
            pulumi.set(__self__, "istio_config", istio_config)
        if kalm_config is not None:
            pulumi.set(__self__, "kalm_config", kalm_config)
        if kubernetes_dashboard is not None:
            pulumi.set(__self__, "kubernetes_dashboard", kubernetes_dashboard)
        if network_policy_config is not None:
            pulumi.set(__self__, "network_policy_config", network_policy_config)

    @property
    @pulumi.getter(name="cloudRunConfig")
    def cloud_run_config(self) -> Optional[pulumi.Input['CloudRunConfigArgs']]:
        """
        Configuration for the Cloud Run addon. The `IstioConfig` addon must be enabled in order to enable Cloud Run addon. This option can only be enabled at cluster creation time.
        """
        return pulumi.get(self, "cloud_run_config")

    @cloud_run_config.setter
    def cloud_run_config(self, value: Optional[pulumi.Input['CloudRunConfigArgs']]):
        pulumi.set(self, "cloud_run_config", value)

    @property
    @pulumi.getter(name="configConnectorConfig")
    def config_connector_config(self) -> Optional[pulumi.Input['ConfigConnectorConfigArgs']]:
        """
        Configuration for the ConfigConnector add-on, a Kubernetes extension to manage hosted GCP services through the Kubernetes API
        """
        return pulumi.get(self, "config_connector_config")

    @config_connector_config.setter
    def config_connector_config(self, value: Optional[pulumi.Input['ConfigConnectorConfigArgs']]):
        pulumi.set(self, "config_connector_config", value)

    @property
    @pulumi.getter(name="dnsCacheConfig")
    def dns_cache_config(self) -> Optional[pulumi.Input['DnsCacheConfigArgs']]:
        """
        Configuration for NodeLocalDNS, a dns cache running on cluster nodes
        """
        return pulumi.get(self, "dns_cache_config")

    @dns_cache_config.setter
    def dns_cache_config(self, value: Optional[pulumi.Input['DnsCacheConfigArgs']]):
        pulumi.set(self, "dns_cache_config", value)

    @property
    @pulumi.getter(name="gcePersistentDiskCsiDriverConfig")
    def gce_persistent_disk_csi_driver_config(self) -> Optional[pulumi.Input['GcePersistentDiskCsiDriverConfigArgs']]:
        """
        Configuration for the Compute Engine Persistent Disk CSI driver.
        """
        return pulumi.get(self, "gce_persistent_disk_csi_driver_config")

    @gce_persistent_disk_csi_driver_config.setter
    def gce_persistent_disk_csi_driver_config(self, value: Optional[pulumi.Input['GcePersistentDiskCsiDriverConfigArgs']]):
        pulumi.set(self, "gce_persistent_disk_csi_driver_config", value)

    @property
    @pulumi.getter(name="gcpFilestoreCsiDriverConfig")
    def gcp_filestore_csi_driver_config(self) -> Optional[pulumi.Input['GcpFilestoreCsiDriverConfigArgs']]:
        """
        Configuration for the GCP Filestore CSI driver.
        """
        return pulumi.get(self, "gcp_filestore_csi_driver_config")

    @gcp_filestore_csi_driver_config.setter
    def gcp_filestore_csi_driver_config(self, value: Optional[pulumi.Input['GcpFilestoreCsiDriverConfigArgs']]):
        pulumi.set(self, "gcp_filestore_csi_driver_config", value)

    @property
    @pulumi.getter(name="gcsFuseCsiDriverConfig")
    def gcs_fuse_csi_driver_config(self) -> Optional[pulumi.Input['GcsFuseCsiDriverConfigArgs']]:
        """
        Configuration for the Cloud Storage Fuse CSI driver.
        """
        return pulumi.get(self, "gcs_fuse_csi_driver_config")

    @gcs_fuse_csi_driver_config.setter
    def gcs_fuse_csi_driver_config(self, value: Optional[pulumi.Input['GcsFuseCsiDriverConfigArgs']]):
        pulumi.set(self, "gcs_fuse_csi_driver_config", value)

    @property
    @pulumi.getter(name="gkeBackupAgentConfig")
    def gke_backup_agent_config(self) -> Optional[pulumi.Input['GkeBackupAgentConfigArgs']]:
        """
        Configuration for the Backup for GKE agent addon.
        """
        return pulumi.get(self, "gke_backup_agent_config")

    @gke_backup_agent_config.setter
    def gke_backup_agent_config(self, value: Optional[pulumi.Input['GkeBackupAgentConfigArgs']]):
        pulumi.set(self, "gke_backup_agent_config", value)

    @property
    @pulumi.getter(name="horizontalPodAutoscaling")
    def horizontal_pod_autoscaling(self) -> Optional[pulumi.Input['HorizontalPodAutoscalingArgs']]:
        """
        Configuration for the horizontal pod autoscaling feature, which increases or decreases the number of replica pods a replication controller has based on the resource usage of the existing pods.
        """
        return pulumi.get(self, "horizontal_pod_autoscaling")

    @horizontal_pod_autoscaling.setter
    def horizontal_pod_autoscaling(self, value: Optional[pulumi.Input['HorizontalPodAutoscalingArgs']]):
        pulumi.set(self, "horizontal_pod_autoscaling", value)

    @property
    @pulumi.getter(name="httpLoadBalancing")
    def http_load_balancing(self) -> Optional[pulumi.Input['HttpLoadBalancingArgs']]:
        """
        Configuration for the HTTP (L7) load balancing controller addon, which makes it easy to set up HTTP load balancers for services in a cluster.
        """
        return pulumi.get(self, "http_load_balancing")

    @http_load_balancing.setter
    def http_load_balancing(self, value: Optional[pulumi.Input['HttpLoadBalancingArgs']]):
        pulumi.set(self, "http_load_balancing", value)

    @property
    @pulumi.getter(name="istioConfig")
    def istio_config(self) -> Optional[pulumi.Input['IstioConfigArgs']]:
        """
        Configuration for Istio, an open platform to connect, manage, and secure microservices.
        """
        return pulumi.get(self, "istio_config")

    @istio_config.setter
    def istio_config(self, value: Optional[pulumi.Input['IstioConfigArgs']]):
        pulumi.set(self, "istio_config", value)

    @property
    @pulumi.getter(name="kalmConfig")
    def kalm_config(self) -> Optional[pulumi.Input['KalmConfigArgs']]:
        """
        Configuration for the KALM addon, which manages the lifecycle of k8s applications.
        """
        return pulumi.get(self, "kalm_config")

    @kalm_config.setter
    def kalm_config(self, value: Optional[pulumi.Input['KalmConfigArgs']]):
        pulumi.set(self, "kalm_config", value)

    @property
    @pulumi.getter(name="kubernetesDashboard")
    def kubernetes_dashboard(self) -> Optional[pulumi.Input['KubernetesDashboardArgs']]:
        """
        Configuration for the Kubernetes Dashboard. This addon is deprecated, and will be disabled in 1.15. It is recommended to use the Cloud Console to manage and monitor your Kubernetes clusters, workloads and applications. For more information, see: https://cloud.google.com/kubernetes-engine/docs/concepts/dashboards
        """
        return pulumi.get(self, "kubernetes_dashboard")

    @kubernetes_dashboard.setter
    def kubernetes_dashboard(self, value: Optional[pulumi.Input['KubernetesDashboardArgs']]):
        pulumi.set(self, "kubernetes_dashboard", value)

    @property
    @pulumi.getter(name="networkPolicyConfig")
    def network_policy_config(self) -> Optional[pulumi.Input['NetworkPolicyConfigArgs']]:
        """
        Configuration for NetworkPolicy. This only tracks whether the addon is enabled or not on the Master, it does not track whether network policy is enabled for the nodes.
        """
        return pulumi.get(self, "network_policy_config")

    @network_policy_config.setter
    def network_policy_config(self, value: Optional[pulumi.Input['NetworkPolicyConfigArgs']]):
        pulumi.set(self, "network_policy_config", value)


@pulumi.input_type
class AdvancedMachineFeaturesArgs:
    def __init__(__self__, *,
                 threads_per_core: Optional[pulumi.Input[str]] = None):
        """
        Specifies options for controlling advanced machine features.
        :param pulumi.Input[str] threads_per_core: The number of threads per physical core. To disable simultaneous multithreading (SMT) set this to 1. If unset, the maximum number of threads supported per core by the underlying processor is assumed.
        """
        if threads_per_core is not None:
            pulumi.set(__self__, "threads_per_core", threads_per_core)

    @property
    @pulumi.getter(name="threadsPerCore")
    def threads_per_core(self) -> Optional[pulumi.Input[str]]:
        """
        The number of threads per physical core. To disable simultaneous multithreading (SMT) set this to 1. If unset, the maximum number of threads supported per core by the underlying processor is assumed.
        """
        return pulumi.get(self, "threads_per_core")

    @threads_per_core.setter
    def threads_per_core(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "threads_per_core", value)


@pulumi.input_type
class AuthenticatorGroupsConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 security_group: Optional[pulumi.Input[str]] = None):
        """
        Configuration for returning group information from authenticators.
        :param pulumi.Input[bool] enabled: Whether this cluster should return group membership lookups during authentication using a group of security groups.
        :param pulumi.Input[str] security_group: The name of the security group-of-groups to be used. Only relevant if enabled = true.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if security_group is not None:
            pulumi.set(__self__, "security_group", security_group)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether this cluster should return group membership lookups during authentication using a group of security groups.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter(name="securityGroup")
    def security_group(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the security group-of-groups to be used. Only relevant if enabled = true.
        """
        return pulumi.get(self, "security_group")

    @security_group.setter
    def security_group(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "security_group", value)


@pulumi.input_type
class AutoUpgradeOptionsArgs:
    def __init__(__self__):
        """
        AutoUpgradeOptions defines the set of options for the user to control how the Auto Upgrades will proceed.
        """
        pass


@pulumi.input_type
class AutopilotArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Autopilot is the configuration for Autopilot settings on the cluster.
        :param pulumi.Input[bool] enabled: Enable Autopilot
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable Autopilot
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class AutoprovisioningNodePoolDefaultsArgs:
    def __init__(__self__, *,
                 boot_disk_kms_key: Optional[pulumi.Input[str]] = None,
                 disk_size_gb: Optional[pulumi.Input[int]] = None,
                 disk_type: Optional[pulumi.Input[str]] = None,
                 image_type: Optional[pulumi.Input[str]] = None,
                 management: Optional[pulumi.Input['NodeManagementArgs']] = None,
                 min_cpu_platform: Optional[pulumi.Input[str]] = None,
                 oauth_scopes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 service_account: Optional[pulumi.Input[str]] = None,
                 shielded_instance_config: Optional[pulumi.Input['ShieldedInstanceConfigArgs']] = None,
                 upgrade_settings: Optional[pulumi.Input['UpgradeSettingsArgs']] = None):
        """
        AutoprovisioningNodePoolDefaults contains defaults for a node pool created by NAP.
        :param pulumi.Input[str] boot_disk_kms_key:  The Customer Managed Encryption Key used to encrypt the boot disk attached to each node in the node pool. This should be of the form projects/[KEY_PROJECT_ID]/locations/[LOCATION]/keyRings/[RING_NAME]/cryptoKeys/[KEY_NAME]. For more information about protecting resources with Cloud KMS Keys please see: https://cloud.google.com/compute/docs/disks/customer-managed-encryption
        :param pulumi.Input[int] disk_size_gb: Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB. If unspecified, the default disk size is 100GB.
        :param pulumi.Input[str] disk_type: Type of the disk attached to each node (e.g. 'pd-standard', 'pd-ssd' or 'pd-balanced') If unspecified, the default disk type is 'pd-standard'
        :param pulumi.Input[str] image_type: The image type to use for NAP created node. Please see https://cloud.google.com/kubernetes-engine/docs/concepts/node-images for available image types.
        :param pulumi.Input['NodeManagementArgs'] management: NodeManagement configuration for this NodePool.
        :param pulumi.Input[str] min_cpu_platform: Deprecated. Minimum CPU platform to be used for NAP created node pools. The instance may be scheduled on the specified or newer CPU platform. Applicable values are the friendly names of CPU platforms, such as minCpuPlatform: Intel Haswell or minCpuPlatform: Intel Sandy Bridge. For more information, read [how to specify min CPU platform](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform). This field is deprecated, min_cpu_platform should be specified using `cloud.google.com/requested-min-cpu-platform` label selector on the pod. To unset the min cpu platform field pass "automatic" as field value.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] oauth_scopes: The set of Google API scopes to be made available on all of the node VMs under the "default" service account. The following scopes are recommended, but not required, and by default are not included: * `https://www.googleapis.com/auth/compute` is required for mounting persistent storage on your nodes. * `https://www.googleapis.com/auth/devstorage.read_only` is required for communicating with **gcr.io** (the [Google Container Registry](https://cloud.google.com/container-registry/)). If unspecified, no scopes are added, unless Cloud Logging or Cloud Monitoring are enabled, in which case their required scopes will be added.
        :param pulumi.Input[str] service_account: The Google Cloud Platform Service Account to be used by the node VMs. Specify the email address of the Service Account; otherwise, if no Service Account is specified, the "default" service account is used.
        :param pulumi.Input['ShieldedInstanceConfigArgs'] shielded_instance_config: Shielded Instance options.
        :param pulumi.Input['UpgradeSettingsArgs'] upgrade_settings: Upgrade settings control disruption and speed of the upgrade.
        """
        if boot_disk_kms_key is not None:
            pulumi.set(__self__, "boot_disk_kms_key", boot_disk_kms_key)
        if disk_size_gb is not None:
            pulumi.set(__self__, "disk_size_gb", disk_size_gb)
        if disk_type is not None:
            pulumi.set(__self__, "disk_type", disk_type)
        if image_type is not None:
            pulumi.set(__self__, "image_type", image_type)
        if management is not None:
            pulumi.set(__self__, "management", management)
        if min_cpu_platform is not None:
            warnings.warn("""Deprecated. Minimum CPU platform to be used for NAP created node pools. The instance may be scheduled on the specified or newer CPU platform. Applicable values are the friendly names of CPU platforms, such as minCpuPlatform: Intel Haswell or minCpuPlatform: Intel Sandy Bridge. For more information, read [how to specify min CPU platform](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform). This field is deprecated, min_cpu_platform should be specified using `cloud.google.com/requested-min-cpu-platform` label selector on the pod. To unset the min cpu platform field pass \"automatic\" as field value.""", DeprecationWarning)
            pulumi.log.warn("""min_cpu_platform is deprecated: Deprecated. Minimum CPU platform to be used for NAP created node pools. The instance may be scheduled on the specified or newer CPU platform. Applicable values are the friendly names of CPU platforms, such as minCpuPlatform: Intel Haswell or minCpuPlatform: Intel Sandy Bridge. For more information, read [how to specify min CPU platform](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform). This field is deprecated, min_cpu_platform should be specified using `cloud.google.com/requested-min-cpu-platform` label selector on the pod. To unset the min cpu platform field pass \"automatic\" as field value.""")
        if min_cpu_platform is not None:
            pulumi.set(__self__, "min_cpu_platform", min_cpu_platform)
        if oauth_scopes is not None:
            pulumi.set(__self__, "oauth_scopes", oauth_scopes)
        if service_account is not None:
            pulumi.set(__self__, "service_account", service_account)
        if shielded_instance_config is not None:
            pulumi.set(__self__, "shielded_instance_config", shielded_instance_config)
        if upgrade_settings is not None:
            pulumi.set(__self__, "upgrade_settings", upgrade_settings)

    @property
    @pulumi.getter(name="bootDiskKmsKey")
    def boot_disk_kms_key(self) -> Optional[pulumi.Input[str]]:
        """
         The Customer Managed Encryption Key used to encrypt the boot disk attached to each node in the node pool. This should be of the form projects/[KEY_PROJECT_ID]/locations/[LOCATION]/keyRings/[RING_NAME]/cryptoKeys/[KEY_NAME]. For more information about protecting resources with Cloud KMS Keys please see: https://cloud.google.com/compute/docs/disks/customer-managed-encryption
        """
        return pulumi.get(self, "boot_disk_kms_key")

    @boot_disk_kms_key.setter
    def boot_disk_kms_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "boot_disk_kms_key", value)

    @property
    @pulumi.getter(name="diskSizeGb")
    def disk_size_gb(self) -> Optional[pulumi.Input[int]]:
        """
        Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB. If unspecified, the default disk size is 100GB.
        """
        return pulumi.get(self, "disk_size_gb")

    @disk_size_gb.setter
    def disk_size_gb(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "disk_size_gb", value)

    @property
    @pulumi.getter(name="diskType")
    def disk_type(self) -> Optional[pulumi.Input[str]]:
        """
        Type of the disk attached to each node (e.g. 'pd-standard', 'pd-ssd' or 'pd-balanced') If unspecified, the default disk type is 'pd-standard'
        """
        return pulumi.get(self, "disk_type")

    @disk_type.setter
    def disk_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "disk_type", value)

    @property
    @pulumi.getter(name="imageType")
    def image_type(self) -> Optional[pulumi.Input[str]]:
        """
        The image type to use for NAP created node. Please see https://cloud.google.com/kubernetes-engine/docs/concepts/node-images for available image types.
        """
        return pulumi.get(self, "image_type")

    @image_type.setter
    def image_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image_type", value)

    @property
    @pulumi.getter
    def management(self) -> Optional[pulumi.Input['NodeManagementArgs']]:
        """
        NodeManagement configuration for this NodePool.
        """
        return pulumi.get(self, "management")

    @management.setter
    def management(self, value: Optional[pulumi.Input['NodeManagementArgs']]):
        pulumi.set(self, "management", value)

    @property
    @pulumi.getter(name="minCpuPlatform")
    def min_cpu_platform(self) -> Optional[pulumi.Input[str]]:
        """
        Deprecated. Minimum CPU platform to be used for NAP created node pools. The instance may be scheduled on the specified or newer CPU platform. Applicable values are the friendly names of CPU platforms, such as minCpuPlatform: Intel Haswell or minCpuPlatform: Intel Sandy Bridge. For more information, read [how to specify min CPU platform](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform). This field is deprecated, min_cpu_platform should be specified using `cloud.google.com/requested-min-cpu-platform` label selector on the pod. To unset the min cpu platform field pass "automatic" as field value.
        """
        warnings.warn("""Deprecated. Minimum CPU platform to be used for NAP created node pools. The instance may be scheduled on the specified or newer CPU platform. Applicable values are the friendly names of CPU platforms, such as minCpuPlatform: Intel Haswell or minCpuPlatform: Intel Sandy Bridge. For more information, read [how to specify min CPU platform](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform). This field is deprecated, min_cpu_platform should be specified using `cloud.google.com/requested-min-cpu-platform` label selector on the pod. To unset the min cpu platform field pass \"automatic\" as field value.""", DeprecationWarning)
        pulumi.log.warn("""min_cpu_platform is deprecated: Deprecated. Minimum CPU platform to be used for NAP created node pools. The instance may be scheduled on the specified or newer CPU platform. Applicable values are the friendly names of CPU platforms, such as minCpuPlatform: Intel Haswell or minCpuPlatform: Intel Sandy Bridge. For more information, read [how to specify min CPU platform](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform). This field is deprecated, min_cpu_platform should be specified using `cloud.google.com/requested-min-cpu-platform` label selector on the pod. To unset the min cpu platform field pass \"automatic\" as field value.""")

        return pulumi.get(self, "min_cpu_platform")

    @min_cpu_platform.setter
    def min_cpu_platform(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "min_cpu_platform", value)

    @property
    @pulumi.getter(name="oauthScopes")
    def oauth_scopes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The set of Google API scopes to be made available on all of the node VMs under the "default" service account. The following scopes are recommended, but not required, and by default are not included: * `https://www.googleapis.com/auth/compute` is required for mounting persistent storage on your nodes. * `https://www.googleapis.com/auth/devstorage.read_only` is required for communicating with **gcr.io** (the [Google Container Registry](https://cloud.google.com/container-registry/)). If unspecified, no scopes are added, unless Cloud Logging or Cloud Monitoring are enabled, in which case their required scopes will be added.
        """
        return pulumi.get(self, "oauth_scopes")

    @oauth_scopes.setter
    def oauth_scopes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "oauth_scopes", value)

    @property
    @pulumi.getter(name="serviceAccount")
    def service_account(self) -> Optional[pulumi.Input[str]]:
        """
        The Google Cloud Platform Service Account to be used by the node VMs. Specify the email address of the Service Account; otherwise, if no Service Account is specified, the "default" service account is used.
        """
        return pulumi.get(self, "service_account")

    @service_account.setter
    def service_account(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_account", value)

    @property
    @pulumi.getter(name="shieldedInstanceConfig")
    def shielded_instance_config(self) -> Optional[pulumi.Input['ShieldedInstanceConfigArgs']]:
        """
        Shielded Instance options.
        """
        return pulumi.get(self, "shielded_instance_config")

    @shielded_instance_config.setter
    def shielded_instance_config(self, value: Optional[pulumi.Input['ShieldedInstanceConfigArgs']]):
        pulumi.set(self, "shielded_instance_config", value)

    @property
    @pulumi.getter(name="upgradeSettings")
    def upgrade_settings(self) -> Optional[pulumi.Input['UpgradeSettingsArgs']]:
        """
        Upgrade settings control disruption and speed of the upgrade.
        """
        return pulumi.get(self, "upgrade_settings")

    @upgrade_settings.setter
    def upgrade_settings(self, value: Optional[pulumi.Input['UpgradeSettingsArgs']]):
        pulumi.set(self, "upgrade_settings", value)


@pulumi.input_type
class BigQueryDestinationArgs:
    def __init__(__self__, *,
                 dataset_id: Optional[pulumi.Input[str]] = None):
        """
        Parameters for using BigQuery as the destination of resource usage export.
        :param pulumi.Input[str] dataset_id: The ID of a BigQuery Dataset.
        """
        if dataset_id is not None:
            pulumi.set(__self__, "dataset_id", dataset_id)

    @property
    @pulumi.getter(name="datasetId")
    def dataset_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of a BigQuery Dataset.
        """
        return pulumi.get(self, "dataset_id")

    @dataset_id.setter
    def dataset_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dataset_id", value)


@pulumi.input_type
class BinaryAuthorizationArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 evaluation_mode: Optional[pulumi.Input['BinaryAuthorizationEvaluationMode']] = None):
        """
        Configuration for Binary Authorization.
        :param pulumi.Input[bool] enabled: This field is deprecated. Leave this unset and instead configure BinaryAuthorization using evaluation_mode. If evaluation_mode is set to anything other than EVALUATION_MODE_UNSPECIFIED, this field is ignored.
        :param pulumi.Input['BinaryAuthorizationEvaluationMode'] evaluation_mode: Mode of operation for binauthz policy evaluation. If unspecified, defaults to DISABLED.
        """
        if enabled is not None:
            warnings.warn("""This field is deprecated. Leave this unset and instead configure BinaryAuthorization using evaluation_mode. If evaluation_mode is set to anything other than EVALUATION_MODE_UNSPECIFIED, this field is ignored.""", DeprecationWarning)
            pulumi.log.warn("""enabled is deprecated: This field is deprecated. Leave this unset and instead configure BinaryAuthorization using evaluation_mode. If evaluation_mode is set to anything other than EVALUATION_MODE_UNSPECIFIED, this field is ignored.""")
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if evaluation_mode is not None:
            pulumi.set(__self__, "evaluation_mode", evaluation_mode)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        This field is deprecated. Leave this unset and instead configure BinaryAuthorization using evaluation_mode. If evaluation_mode is set to anything other than EVALUATION_MODE_UNSPECIFIED, this field is ignored.
        """
        warnings.warn("""This field is deprecated. Leave this unset and instead configure BinaryAuthorization using evaluation_mode. If evaluation_mode is set to anything other than EVALUATION_MODE_UNSPECIFIED, this field is ignored.""", DeprecationWarning)
        pulumi.log.warn("""enabled is deprecated: This field is deprecated. Leave this unset and instead configure BinaryAuthorization using evaluation_mode. If evaluation_mode is set to anything other than EVALUATION_MODE_UNSPECIFIED, this field is ignored.""")

        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter(name="evaluationMode")
    def evaluation_mode(self) -> Optional[pulumi.Input['BinaryAuthorizationEvaluationMode']]:
        """
        Mode of operation for binauthz policy evaluation. If unspecified, defaults to DISABLED.
        """
        return pulumi.get(self, "evaluation_mode")

    @evaluation_mode.setter
    def evaluation_mode(self, value: Optional[pulumi.Input['BinaryAuthorizationEvaluationMode']]):
        pulumi.set(self, "evaluation_mode", value)


@pulumi.input_type
class BlueGreenSettingsArgs:
    def __init__(__self__, *,
                 node_pool_soak_duration: Optional[pulumi.Input[str]] = None,
                 standard_rollout_policy: Optional[pulumi.Input['StandardRolloutPolicyArgs']] = None):
        """
        Settings for blue-green upgrade.
        :param pulumi.Input[str] node_pool_soak_duration: Time needed after draining entire blue pool. After this period, blue pool will be cleaned up.
        :param pulumi.Input['StandardRolloutPolicyArgs'] standard_rollout_policy: Standard policy for the blue-green upgrade.
        """
        if node_pool_soak_duration is not None:
            pulumi.set(__self__, "node_pool_soak_duration", node_pool_soak_duration)
        if standard_rollout_policy is not None:
            pulumi.set(__self__, "standard_rollout_policy", standard_rollout_policy)

    @property
    @pulumi.getter(name="nodePoolSoakDuration")
    def node_pool_soak_duration(self) -> Optional[pulumi.Input[str]]:
        """
        Time needed after draining entire blue pool. After this period, blue pool will be cleaned up.
        """
        return pulumi.get(self, "node_pool_soak_duration")

    @node_pool_soak_duration.setter
    def node_pool_soak_duration(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "node_pool_soak_duration", value)

    @property
    @pulumi.getter(name="standardRolloutPolicy")
    def standard_rollout_policy(self) -> Optional[pulumi.Input['StandardRolloutPolicyArgs']]:
        """
        Standard policy for the blue-green upgrade.
        """
        return pulumi.get(self, "standard_rollout_policy")

    @standard_rollout_policy.setter
    def standard_rollout_policy(self, value: Optional[pulumi.Input['StandardRolloutPolicyArgs']]):
        pulumi.set(self, "standard_rollout_policy", value)


@pulumi.input_type
class CidrBlockArgs:
    def __init__(__self__, *,
                 cidr_block: Optional[pulumi.Input[str]] = None,
                 display_name: Optional[pulumi.Input[str]] = None):
        """
        CidrBlock contains an optional name and one CIDR block.
        :param pulumi.Input[str] cidr_block: cidr_block must be specified in CIDR notation.
        :param pulumi.Input[str] display_name: display_name is an optional field for users to identify CIDR blocks.
        """
        if cidr_block is not None:
            pulumi.set(__self__, "cidr_block", cidr_block)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)

    @property
    @pulumi.getter(name="cidrBlock")
    def cidr_block(self) -> Optional[pulumi.Input[str]]:
        """
        cidr_block must be specified in CIDR notation.
        """
        return pulumi.get(self, "cidr_block")

    @cidr_block.setter
    def cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cidr_block", value)

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[str]]:
        """
        display_name is an optional field for users to identify CIDR blocks.
        """
        return pulumi.get(self, "display_name")

    @display_name.setter
    def display_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "display_name", value)


@pulumi.input_type
class ClientCertificateConfigArgs:
    def __init__(__self__, *,
                 issue_client_certificate: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for client certificates on the cluster.
        :param pulumi.Input[bool] issue_client_certificate: Issue a client certificate.
        """
        if issue_client_certificate is not None:
            pulumi.set(__self__, "issue_client_certificate", issue_client_certificate)

    @property
    @pulumi.getter(name="issueClientCertificate")
    def issue_client_certificate(self) -> Optional[pulumi.Input[bool]]:
        """
        Issue a client certificate.
        """
        return pulumi.get(self, "issue_client_certificate")

    @issue_client_certificate.setter
    def issue_client_certificate(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "issue_client_certificate", value)


@pulumi.input_type
class CloudRunConfigArgs:
    def __init__(__self__, *,
                 disabled: Optional[pulumi.Input[bool]] = None,
                 load_balancer_type: Optional[pulumi.Input['CloudRunConfigLoadBalancerType']] = None):
        """
        Configuration options for the Cloud Run feature.
        :param pulumi.Input[bool] disabled: Whether Cloud Run addon is enabled for this cluster.
        :param pulumi.Input['CloudRunConfigLoadBalancerType'] load_balancer_type: Which load balancer type is installed for Cloud Run.
        """
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)
        if load_balancer_type is not None:
            pulumi.set(__self__, "load_balancer_type", load_balancer_type)

    @property
    @pulumi.getter
    def disabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether Cloud Run addon is enabled for this cluster.
        """
        return pulumi.get(self, "disabled")

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disabled", value)

    @property
    @pulumi.getter(name="loadBalancerType")
    def load_balancer_type(self) -> Optional[pulumi.Input['CloudRunConfigLoadBalancerType']]:
        """
        Which load balancer type is installed for Cloud Run.
        """
        return pulumi.get(self, "load_balancer_type")

    @load_balancer_type.setter
    def load_balancer_type(self, value: Optional[pulumi.Input['CloudRunConfigLoadBalancerType']]):
        pulumi.set(self, "load_balancer_type", value)


@pulumi.input_type
class ClusterAutoscalingArgs:
    def __init__(__self__, *,
                 autoprovisioning_locations: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 autoprovisioning_node_pool_defaults: Optional[pulumi.Input['AutoprovisioningNodePoolDefaultsArgs']] = None,
                 autoscaling_profile: Optional[pulumi.Input['ClusterAutoscalingAutoscalingProfile']] = None,
                 enable_node_autoprovisioning: Optional[pulumi.Input[bool]] = None,
                 resource_limits: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceLimitArgs']]]] = None):
        """
        ClusterAutoscaling contains global, per-cluster information required by Cluster Autoscaler to automatically adjust the size of the cluster and create/delete node pools based on the current needs.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] autoprovisioning_locations: The list of Google Compute Engine [zones](https://cloud.google.com/compute/docs/zones#available) in which the NodePool's nodes can be created by NAP.
        :param pulumi.Input['AutoprovisioningNodePoolDefaultsArgs'] autoprovisioning_node_pool_defaults: AutoprovisioningNodePoolDefaults contains defaults for a node pool created by NAP.
        :param pulumi.Input['ClusterAutoscalingAutoscalingProfile'] autoscaling_profile: Defines autoscaling behaviour.
        :param pulumi.Input[bool] enable_node_autoprovisioning: Enables automatic node pool creation and deletion.
        :param pulumi.Input[Sequence[pulumi.Input['ResourceLimitArgs']]] resource_limits: Contains global constraints regarding minimum and maximum amount of resources in the cluster.
        """
        if autoprovisioning_locations is not None:
            pulumi.set(__self__, "autoprovisioning_locations", autoprovisioning_locations)
        if autoprovisioning_node_pool_defaults is not None:
            pulumi.set(__self__, "autoprovisioning_node_pool_defaults", autoprovisioning_node_pool_defaults)
        if autoscaling_profile is not None:
            pulumi.set(__self__, "autoscaling_profile", autoscaling_profile)
        if enable_node_autoprovisioning is not None:
            pulumi.set(__self__, "enable_node_autoprovisioning", enable_node_autoprovisioning)
        if resource_limits is not None:
            pulumi.set(__self__, "resource_limits", resource_limits)

    @property
    @pulumi.getter(name="autoprovisioningLocations")
    def autoprovisioning_locations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The list of Google Compute Engine [zones](https://cloud.google.com/compute/docs/zones#available) in which the NodePool's nodes can be created by NAP.
        """
        return pulumi.get(self, "autoprovisioning_locations")

    @autoprovisioning_locations.setter
    def autoprovisioning_locations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "autoprovisioning_locations", value)

    @property
    @pulumi.getter(name="autoprovisioningNodePoolDefaults")
    def autoprovisioning_node_pool_defaults(self) -> Optional[pulumi.Input['AutoprovisioningNodePoolDefaultsArgs']]:
        """
        AutoprovisioningNodePoolDefaults contains defaults for a node pool created by NAP.
        """
        return pulumi.get(self, "autoprovisioning_node_pool_defaults")

    @autoprovisioning_node_pool_defaults.setter
    def autoprovisioning_node_pool_defaults(self, value: Optional[pulumi.Input['AutoprovisioningNodePoolDefaultsArgs']]):
        pulumi.set(self, "autoprovisioning_node_pool_defaults", value)

    @property
    @pulumi.getter(name="autoscalingProfile")
    def autoscaling_profile(self) -> Optional[pulumi.Input['ClusterAutoscalingAutoscalingProfile']]:
        """
        Defines autoscaling behaviour.
        """
        return pulumi.get(self, "autoscaling_profile")

    @autoscaling_profile.setter
    def autoscaling_profile(self, value: Optional[pulumi.Input['ClusterAutoscalingAutoscalingProfile']]):
        pulumi.set(self, "autoscaling_profile", value)

    @property
    @pulumi.getter(name="enableNodeAutoprovisioning")
    def enable_node_autoprovisioning(self) -> Optional[pulumi.Input[bool]]:
        """
        Enables automatic node pool creation and deletion.
        """
        return pulumi.get(self, "enable_node_autoprovisioning")

    @enable_node_autoprovisioning.setter
    def enable_node_autoprovisioning(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_node_autoprovisioning", value)

    @property
    @pulumi.getter(name="resourceLimits")
    def resource_limits(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ResourceLimitArgs']]]]:
        """
        Contains global constraints regarding minimum and maximum amount of resources in the cluster.
        """
        return pulumi.get(self, "resource_limits")

    @resource_limits.setter
    def resource_limits(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceLimitArgs']]]]):
        pulumi.set(self, "resource_limits", value)


@pulumi.input_type
class ClusterTelemetryArgs:
    def __init__(__self__, *,
                 type: Optional[pulumi.Input['ClusterTelemetryType']] = None):
        """
        Telemetry integration for the cluster.
        :param pulumi.Input['ClusterTelemetryType'] type: Type of the integration.
        """
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input['ClusterTelemetryType']]:
        """
        Type of the integration.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input['ClusterTelemetryType']]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class ConfidentialNodesArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        ConfidentialNodes is configuration for the confidential nodes feature, which makes nodes run on confidential VMs.
        :param pulumi.Input[bool] enabled: Whether Confidential Nodes feature is enabled.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether Confidential Nodes feature is enabled.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class ConfigConnectorConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration options for the Config Connector add-on.
        :param pulumi.Input[bool] enabled: Whether Cloud Connector is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether Cloud Connector is enabled for this cluster.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class ConsumptionMeteringConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Parameters for controlling consumption metering.
        :param pulumi.Input[bool] enabled: Whether to enable consumption metering for this cluster. If enabled, a second BigQuery table will be created to hold resource consumption records.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to enable consumption metering for this cluster. If enabled, a second BigQuery table will be created to hold resource consumption records.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class CostManagementConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for fine-grained cost management feature.
        :param pulumi.Input[bool] enabled: Whether the feature is enabled or not.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the feature is enabled or not.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class DNSConfigArgs:
    def __init__(__self__, *,
                 cluster_dns: Optional[pulumi.Input['DNSConfigClusterDns']] = None,
                 cluster_dns_domain: Optional[pulumi.Input[str]] = None,
                 cluster_dns_scope: Optional[pulumi.Input['DNSConfigClusterDnsScope']] = None):
        """
        DNSConfig contains the desired set of options for configuring clusterDNS.
        :param pulumi.Input['DNSConfigClusterDns'] cluster_dns: cluster_dns indicates which in-cluster DNS provider should be used.
        :param pulumi.Input[str] cluster_dns_domain: cluster_dns_domain is the suffix used for all cluster service records.
        :param pulumi.Input['DNSConfigClusterDnsScope'] cluster_dns_scope: cluster_dns_scope indicates the scope of access to cluster DNS records.
        """
        if cluster_dns is not None:
            pulumi.set(__self__, "cluster_dns", cluster_dns)
        if cluster_dns_domain is not None:
            pulumi.set(__self__, "cluster_dns_domain", cluster_dns_domain)
        if cluster_dns_scope is not None:
            pulumi.set(__self__, "cluster_dns_scope", cluster_dns_scope)

    @property
    @pulumi.getter(name="clusterDns")
    def cluster_dns(self) -> Optional[pulumi.Input['DNSConfigClusterDns']]:
        """
        cluster_dns indicates which in-cluster DNS provider should be used.
        """
        return pulumi.get(self, "cluster_dns")

    @cluster_dns.setter
    def cluster_dns(self, value: Optional[pulumi.Input['DNSConfigClusterDns']]):
        pulumi.set(self, "cluster_dns", value)

    @property
    @pulumi.getter(name="clusterDnsDomain")
    def cluster_dns_domain(self) -> Optional[pulumi.Input[str]]:
        """
        cluster_dns_domain is the suffix used for all cluster service records.
        """
        return pulumi.get(self, "cluster_dns_domain")

    @cluster_dns_domain.setter
    def cluster_dns_domain(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_dns_domain", value)

    @property
    @pulumi.getter(name="clusterDnsScope")
    def cluster_dns_scope(self) -> Optional[pulumi.Input['DNSConfigClusterDnsScope']]:
        """
        cluster_dns_scope indicates the scope of access to cluster DNS records.
        """
        return pulumi.get(self, "cluster_dns_scope")

    @cluster_dns_scope.setter
    def cluster_dns_scope(self, value: Optional[pulumi.Input['DNSConfigClusterDnsScope']]):
        pulumi.set(self, "cluster_dns_scope", value)


@pulumi.input_type
class DailyMaintenanceWindowArgs:
    def __init__(__self__, *,
                 start_time: Optional[pulumi.Input[str]] = None):
        """
        Time window specified for daily maintenance operations.
        :param pulumi.Input[str] start_time: Time within the maintenance window to start the maintenance operations. It must be in format "HH:MM", where HH : [00-23] and MM : [00-59] GMT.
        """
        if start_time is not None:
            pulumi.set(__self__, "start_time", start_time)

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> Optional[pulumi.Input[str]]:
        """
        Time within the maintenance window to start the maintenance operations. It must be in format "HH:MM", where HH : [00-23] and MM : [00-59] GMT.
        """
        return pulumi.get(self, "start_time")

    @start_time.setter
    def start_time(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "start_time", value)


@pulumi.input_type
class DatabaseEncryptionArgs:
    def __init__(__self__, *,
                 key_name: Optional[pulumi.Input[str]] = None,
                 state: Optional[pulumi.Input['DatabaseEncryptionState']] = None):
        """
        Configuration of etcd encryption.
        :param pulumi.Input[str] key_name: Name of CloudKMS key to use for the encryption of secrets in etcd. Ex. projects/my-project/locations/global/keyRings/my-ring/cryptoKeys/my-key
        :param pulumi.Input['DatabaseEncryptionState'] state: The desired state of etcd encryption.
        """
        if key_name is not None:
            pulumi.set(__self__, "key_name", key_name)
        if state is not None:
            pulumi.set(__self__, "state", state)

    @property
    @pulumi.getter(name="keyName")
    def key_name(self) -> Optional[pulumi.Input[str]]:
        """
        Name of CloudKMS key to use for the encryption of secrets in etcd. Ex. projects/my-project/locations/global/keyRings/my-ring/cryptoKeys/my-key
        """
        return pulumi.get(self, "key_name")

    @key_name.setter
    def key_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key_name", value)

    @property
    @pulumi.getter
    def state(self) -> Optional[pulumi.Input['DatabaseEncryptionState']]:
        """
        The desired state of etcd encryption.
        """
        return pulumi.get(self, "state")

    @state.setter
    def state(self, value: Optional[pulumi.Input['DatabaseEncryptionState']]):
        pulumi.set(self, "state", value)


@pulumi.input_type
class DefaultSnatStatusArgs:
    def __init__(__self__, *,
                 disabled: Optional[pulumi.Input[bool]] = None):
        """
        DefaultSnatStatus contains the desired state of whether default sNAT should be disabled on the cluster.
        :param pulumi.Input[bool] disabled: Disables cluster default sNAT rules.
        """
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)

    @property
    @pulumi.getter
    def disabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Disables cluster default sNAT rules.
        """
        return pulumi.get(self, "disabled")

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disabled", value)


@pulumi.input_type
class DnsCacheConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for NodeLocal DNSCache
        :param pulumi.Input[bool] enabled: Whether NodeLocal DNSCache is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether NodeLocal DNSCache is enabled for this cluster.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class EphemeralStorageConfigArgs:
    def __init__(__self__, *,
                 local_ssd_count: Optional[pulumi.Input[int]] = None):
        """
        EphemeralStorageConfig contains configuration for the ephemeral storage filesystem.
        :param pulumi.Input[int] local_ssd_count: Number of local SSDs to use to back ephemeral storage. Uses NVMe interfaces. Each local SSD is 375 GB in size. If zero, it means to disable using local SSDs as ephemeral storage.
        """
        if local_ssd_count is not None:
            pulumi.set(__self__, "local_ssd_count", local_ssd_count)

    @property
    @pulumi.getter(name="localSsdCount")
    def local_ssd_count(self) -> Optional[pulumi.Input[int]]:
        """
        Number of local SSDs to use to back ephemeral storage. Uses NVMe interfaces. Each local SSD is 375 GB in size. If zero, it means to disable using local SSDs as ephemeral storage.
        """
        return pulumi.get(self, "local_ssd_count")

    @local_ssd_count.setter
    def local_ssd_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "local_ssd_count", value)


@pulumi.input_type
class EphemeralStorageLocalSsdConfigArgs:
    def __init__(__self__, *,
                 local_ssd_count: Optional[pulumi.Input[int]] = None):
        """
        EphemeralStorageLocalSsdConfig contains configuration for the node ephemeral storage using Local SSDs.
        :param pulumi.Input[int] local_ssd_count: Number of local SSDs to use to back ephemeral storage. Uses NVMe interfaces. Each local SSD is 375 GB in size. If zero, it means to disable using local SSDs as ephemeral storage. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        """
        if local_ssd_count is not None:
            pulumi.set(__self__, "local_ssd_count", local_ssd_count)

    @property
    @pulumi.getter(name="localSsdCount")
    def local_ssd_count(self) -> Optional[pulumi.Input[int]]:
        """
        Number of local SSDs to use to back ephemeral storage. Uses NVMe interfaces. Each local SSD is 375 GB in size. If zero, it means to disable using local SSDs as ephemeral storage. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        """
        return pulumi.get(self, "local_ssd_count")

    @local_ssd_count.setter
    def local_ssd_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "local_ssd_count", value)


@pulumi.input_type
class FastSocketArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration of Fast Socket feature.
        :param pulumi.Input[bool] enabled: Whether Fast Socket features are enabled in the node pool.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether Fast Socket features are enabled in the node pool.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class FilterArgs:
    def __init__(__self__, *,
                 event_type: Optional[pulumi.Input[Sequence[pulumi.Input['FilterEventTypeItem']]]] = None):
        """
        Allows filtering to one or more specific event types. If event types are present, those and only those event types will be transmitted to the cluster. Other types will be skipped. If no filter is specified, or no event types are present, all event types will be sent
        :param pulumi.Input[Sequence[pulumi.Input['FilterEventTypeItem']]] event_type: Event types to allowlist.
        """
        if event_type is not None:
            pulumi.set(__self__, "event_type", event_type)

    @property
    @pulumi.getter(name="eventType")
    def event_type(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['FilterEventTypeItem']]]]:
        """
        Event types to allowlist.
        """
        return pulumi.get(self, "event_type")

    @event_type.setter
    def event_type(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['FilterEventTypeItem']]]]):
        pulumi.set(self, "event_type", value)


@pulumi.input_type
class FleetArgs:
    def __init__(__self__, *,
                 project: Optional[pulumi.Input[str]] = None):
        """
        Fleet is the fleet configuration for the cluster.
        :param pulumi.Input[str] project: The Fleet host project(project ID or project number) where this cluster will be registered to. This field cannot be changed after the cluster has been registered.
        """
        if project is not None:
            pulumi.set(__self__, "project", project)

    @property
    @pulumi.getter
    def project(self) -> Optional[pulumi.Input[str]]:
        """
        The Fleet host project(project ID or project number) where this cluster will be registered to. This field cannot be changed after the cluster has been registered.
        """
        return pulumi.get(self, "project")

    @project.setter
    def project(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "project", value)


@pulumi.input_type
class GPUSharingConfigArgs:
    def __init__(__self__, *,
                 gpu_sharing_strategy: Optional[pulumi.Input['GPUSharingConfigGpuSharingStrategy']] = None,
                 max_shared_clients_per_gpu: Optional[pulumi.Input[str]] = None):
        """
        GPUSharingConfig represents the GPU sharing configuration for Hardware Accelerators.
        :param pulumi.Input['GPUSharingConfigGpuSharingStrategy'] gpu_sharing_strategy: The type of GPU sharing strategy to enable on the GPU node.
        :param pulumi.Input[str] max_shared_clients_per_gpu: The max number of containers that can share a physical GPU.
        """
        if gpu_sharing_strategy is not None:
            pulumi.set(__self__, "gpu_sharing_strategy", gpu_sharing_strategy)
        if max_shared_clients_per_gpu is not None:
            pulumi.set(__self__, "max_shared_clients_per_gpu", max_shared_clients_per_gpu)

    @property
    @pulumi.getter(name="gpuSharingStrategy")
    def gpu_sharing_strategy(self) -> Optional[pulumi.Input['GPUSharingConfigGpuSharingStrategy']]:
        """
        The type of GPU sharing strategy to enable on the GPU node.
        """
        return pulumi.get(self, "gpu_sharing_strategy")

    @gpu_sharing_strategy.setter
    def gpu_sharing_strategy(self, value: Optional[pulumi.Input['GPUSharingConfigGpuSharingStrategy']]):
        pulumi.set(self, "gpu_sharing_strategy", value)

    @property
    @pulumi.getter(name="maxSharedClientsPerGpu")
    def max_shared_clients_per_gpu(self) -> Optional[pulumi.Input[str]]:
        """
        The max number of containers that can share a physical GPU.
        """
        return pulumi.get(self, "max_shared_clients_per_gpu")

    @max_shared_clients_per_gpu.setter
    def max_shared_clients_per_gpu(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "max_shared_clients_per_gpu", value)


@pulumi.input_type
class GatewayAPIConfigArgs:
    def __init__(__self__, *,
                 channel: Optional[pulumi.Input['GatewayAPIConfigChannel']] = None):
        """
        GatewayAPIConfig contains the desired config of Gateway API on this cluster.
        :param pulumi.Input['GatewayAPIConfigChannel'] channel: The Gateway API release channel to use for Gateway API.
        """
        if channel is not None:
            pulumi.set(__self__, "channel", channel)

    @property
    @pulumi.getter
    def channel(self) -> Optional[pulumi.Input['GatewayAPIConfigChannel']]:
        """
        The Gateway API release channel to use for Gateway API.
        """
        return pulumi.get(self, "channel")

    @channel.setter
    def channel(self, value: Optional[pulumi.Input['GatewayAPIConfigChannel']]):
        pulumi.set(self, "channel", value)


@pulumi.input_type
class GcePersistentDiskCsiDriverConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for the Compute Engine PD CSI driver.
        :param pulumi.Input[bool] enabled: Whether the Compute Engine PD CSI driver is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the Compute Engine PD CSI driver is enabled for this cluster.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class GcfsConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        GcfsConfig contains configurations of Google Container File System.
        :param pulumi.Input[bool] enabled: Whether to use GCFS.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to use GCFS.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class GcpFilestoreCsiDriverConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for the GCP Filestore CSI driver.
        :param pulumi.Input[bool] enabled: Whether the GCP Filestore CSI driver is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the GCP Filestore CSI driver is enabled for this cluster.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class GcsFuseCsiDriverConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for the Cloud Storage Fuse CSI driver.
        :param pulumi.Input[bool] enabled: Whether the Cloud Storage Fuse CSI driver is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the Cloud Storage Fuse CSI driver is enabled for this cluster.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class GkeBackupAgentConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for the Backup for GKE Agent.
        :param pulumi.Input[bool] enabled: Whether the Backup for GKE agent is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the Backup for GKE agent is enabled for this cluster.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class HorizontalPodAutoscalingArgs:
    def __init__(__self__, *,
                 disabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration options for the horizontal pod autoscaling feature, which increases or decreases the number of replica pods a replication controller has based on the resource usage of the existing pods.
        :param pulumi.Input[bool] disabled: Whether the Horizontal Pod Autoscaling feature is enabled in the cluster. When enabled, it ensures that metrics are collected into Stackdriver Monitoring.
        """
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)

    @property
    @pulumi.getter
    def disabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the Horizontal Pod Autoscaling feature is enabled in the cluster. When enabled, it ensures that metrics are collected into Stackdriver Monitoring.
        """
        return pulumi.get(self, "disabled")

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disabled", value)


@pulumi.input_type
class HttpLoadBalancingArgs:
    def __init__(__self__, *,
                 disabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration options for the HTTP (L7) load balancing controller addon, which makes it easy to set up HTTP load balancers for services in a cluster.
        :param pulumi.Input[bool] disabled: Whether the HTTP Load Balancing controller is enabled in the cluster. When enabled, it runs a small pod in the cluster that manages the load balancers.
        """
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)

    @property
    @pulumi.getter
    def disabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the HTTP Load Balancing controller is enabled in the cluster. When enabled, it runs a small pod in the cluster that manages the load balancers.
        """
        return pulumi.get(self, "disabled")

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disabled", value)


@pulumi.input_type
class IPAllocationPolicyArgs:
    def __init__(__self__, *,
                 allow_route_overlap: Optional[pulumi.Input[bool]] = None,
                 cluster_ipv4_cidr: Optional[pulumi.Input[str]] = None,
                 cluster_ipv4_cidr_block: Optional[pulumi.Input[str]] = None,
                 cluster_secondary_range_name: Optional[pulumi.Input[str]] = None,
                 create_subnetwork: Optional[pulumi.Input[bool]] = None,
                 ipv6_access_type: Optional[pulumi.Input['IPAllocationPolicyIpv6AccessType']] = None,
                 node_ipv4_cidr: Optional[pulumi.Input[str]] = None,
                 node_ipv4_cidr_block: Optional[pulumi.Input[str]] = None,
                 pod_cidr_overprovision_config: Optional[pulumi.Input['PodCIDROverprovisionConfigArgs']] = None,
                 services_ipv4_cidr: Optional[pulumi.Input[str]] = None,
                 services_ipv4_cidr_block: Optional[pulumi.Input[str]] = None,
                 services_secondary_range_name: Optional[pulumi.Input[str]] = None,
                 stack_type: Optional[pulumi.Input['IPAllocationPolicyStackType']] = None,
                 subnetwork_name: Optional[pulumi.Input[str]] = None,
                 tpu_ipv4_cidr_block: Optional[pulumi.Input[str]] = None,
                 use_ip_aliases: Optional[pulumi.Input[bool]] = None,
                 use_routes: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for controlling how IPs are allocated in the cluster.
        :param pulumi.Input[bool] allow_route_overlap: If true, allow allocation of cluster CIDR ranges that overlap with certain kinds of network routes. By default we do not allow cluster CIDR ranges to intersect with any user declared routes. With allow_route_overlap == true, we allow overlapping with CIDR ranges that are larger than the cluster CIDR range. If this field is set to true, then cluster and services CIDRs must be fully-specified (e.g. `10.96.0.0/14`, but not `/14`), which means: 1) When `use_ip_aliases` is true, `cluster_ipv4_cidr_block` and `services_ipv4_cidr_block` must be fully-specified. 2) When `use_ip_aliases` is false, `cluster.cluster_ipv4_cidr` muse be fully-specified.
        :param pulumi.Input[str] cluster_ipv4_cidr: This field is deprecated, use cluster_ipv4_cidr_block.
        :param pulumi.Input[str] cluster_ipv4_cidr_block: The IP address range for the cluster pod IPs. If this field is set, then `cluster.cluster_ipv4_cidr` must be left blank. This field is only applicable when `use_ip_aliases` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        :param pulumi.Input[str] cluster_secondary_range_name: The name of the secondary range to be used for the cluster CIDR block. The secondary range will be used for pod IP addresses. This must be an existing secondary range associated with the cluster subnetwork. This field is only applicable with use_ip_aliases and create_subnetwork is false.
        :param pulumi.Input[bool] create_subnetwork: Whether a new subnetwork will be created automatically for the cluster. This field is only applicable when `use_ip_aliases` is true.
        :param pulumi.Input['IPAllocationPolicyIpv6AccessType'] ipv6_access_type: The ipv6 access type (internal or external) when create_subnetwork is true
        :param pulumi.Input[str] node_ipv4_cidr: This field is deprecated, use node_ipv4_cidr_block.
        :param pulumi.Input[str] node_ipv4_cidr_block: The IP address range of the instance IPs in this cluster. This is applicable only if `create_subnetwork` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        :param pulumi.Input['PodCIDROverprovisionConfigArgs'] pod_cidr_overprovision_config: [PRIVATE FIELD] Pod CIDR size overprovisioning config for the cluster. Pod CIDR size per node depends on max_pods_per_node. By default, the value of max_pods_per_node is doubled and then rounded off to next power of 2 to get the size of pod CIDR block per node. Example: max_pods_per_node of 30 would result in 64 IPs (/26). This config can disable the doubling of IPs (we still round off to next power of 2) Example: max_pods_per_node of 30 will result in 32 IPs (/27) when overprovisioning is disabled.
        :param pulumi.Input[str] services_ipv4_cidr: This field is deprecated, use services_ipv4_cidr_block.
        :param pulumi.Input[str] services_ipv4_cidr_block: The IP address range of the services IPs in this cluster. If blank, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        :param pulumi.Input[str] services_secondary_range_name: The name of the secondary range to be used as for the services CIDR block. The secondary range will be used for service ClusterIPs. This must be an existing secondary range associated with the cluster subnetwork. This field is only applicable with use_ip_aliases and create_subnetwork is false.
        :param pulumi.Input['IPAllocationPolicyStackType'] stack_type: IP stack type
        :param pulumi.Input[str] subnetwork_name: A custom subnetwork name to be used if `create_subnetwork` is true. If this field is empty, then an automatic name will be chosen for the new subnetwork.
        :param pulumi.Input[str] tpu_ipv4_cidr_block: The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.
        :param pulumi.Input[bool] use_ip_aliases: Whether alias IPs will be used for pod IPs in the cluster. This is used in conjunction with use_routes. It cannot be true if use_routes is true. If both use_ip_aliases and use_routes are false, then the server picks the default IP allocation mode
        :param pulumi.Input[bool] use_routes: Whether routes will be used for pod IPs in the cluster. This is used in conjunction with use_ip_aliases. It cannot be true if use_ip_aliases is true. If both use_ip_aliases and use_routes are false, then the server picks the default IP allocation mode
        """
        if allow_route_overlap is not None:
            pulumi.set(__self__, "allow_route_overlap", allow_route_overlap)
        if cluster_ipv4_cidr is not None:
            warnings.warn("""This field is deprecated, use cluster_ipv4_cidr_block.""", DeprecationWarning)
            pulumi.log.warn("""cluster_ipv4_cidr is deprecated: This field is deprecated, use cluster_ipv4_cidr_block.""")
        if cluster_ipv4_cidr is not None:
            pulumi.set(__self__, "cluster_ipv4_cidr", cluster_ipv4_cidr)
        if cluster_ipv4_cidr_block is not None:
            pulumi.set(__self__, "cluster_ipv4_cidr_block", cluster_ipv4_cidr_block)
        if cluster_secondary_range_name is not None:
            pulumi.set(__self__, "cluster_secondary_range_name", cluster_secondary_range_name)
        if create_subnetwork is not None:
            pulumi.set(__self__, "create_subnetwork", create_subnetwork)
        if ipv6_access_type is not None:
            pulumi.set(__self__, "ipv6_access_type", ipv6_access_type)
        if node_ipv4_cidr is not None:
            warnings.warn("""This field is deprecated, use node_ipv4_cidr_block.""", DeprecationWarning)
            pulumi.log.warn("""node_ipv4_cidr is deprecated: This field is deprecated, use node_ipv4_cidr_block.""")
        if node_ipv4_cidr is not None:
            pulumi.set(__self__, "node_ipv4_cidr", node_ipv4_cidr)
        if node_ipv4_cidr_block is not None:
            pulumi.set(__self__, "node_ipv4_cidr_block", node_ipv4_cidr_block)
        if pod_cidr_overprovision_config is not None:
            pulumi.set(__self__, "pod_cidr_overprovision_config", pod_cidr_overprovision_config)
        if services_ipv4_cidr is not None:
            warnings.warn("""This field is deprecated, use services_ipv4_cidr_block.""", DeprecationWarning)
            pulumi.log.warn("""services_ipv4_cidr is deprecated: This field is deprecated, use services_ipv4_cidr_block.""")
        if services_ipv4_cidr is not None:
            pulumi.set(__self__, "services_ipv4_cidr", services_ipv4_cidr)
        if services_ipv4_cidr_block is not None:
            pulumi.set(__self__, "services_ipv4_cidr_block", services_ipv4_cidr_block)
        if services_secondary_range_name is not None:
            pulumi.set(__self__, "services_secondary_range_name", services_secondary_range_name)
        if stack_type is not None:
            pulumi.set(__self__, "stack_type", stack_type)
        if subnetwork_name is not None:
            pulumi.set(__self__, "subnetwork_name", subnetwork_name)
        if tpu_ipv4_cidr_block is not None:
            warnings.warn("""The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.""", DeprecationWarning)
            pulumi.log.warn("""tpu_ipv4_cidr_block is deprecated: The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.""")
        if tpu_ipv4_cidr_block is not None:
            pulumi.set(__self__, "tpu_ipv4_cidr_block", tpu_ipv4_cidr_block)
        if use_ip_aliases is not None:
            pulumi.set(__self__, "use_ip_aliases", use_ip_aliases)
        if use_routes is not None:
            pulumi.set(__self__, "use_routes", use_routes)

    @property
    @pulumi.getter(name="allowRouteOverlap")
    def allow_route_overlap(self) -> Optional[pulumi.Input[bool]]:
        """
        If true, allow allocation of cluster CIDR ranges that overlap with certain kinds of network routes. By default we do not allow cluster CIDR ranges to intersect with any user declared routes. With allow_route_overlap == true, we allow overlapping with CIDR ranges that are larger than the cluster CIDR range. If this field is set to true, then cluster and services CIDRs must be fully-specified (e.g. `10.96.0.0/14`, but not `/14`), which means: 1) When `use_ip_aliases` is true, `cluster_ipv4_cidr_block` and `services_ipv4_cidr_block` must be fully-specified. 2) When `use_ip_aliases` is false, `cluster.cluster_ipv4_cidr` muse be fully-specified.
        """
        return pulumi.get(self, "allow_route_overlap")

    @allow_route_overlap.setter
    def allow_route_overlap(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "allow_route_overlap", value)

    @property
    @pulumi.getter(name="clusterIpv4Cidr")
    def cluster_ipv4_cidr(self) -> Optional[pulumi.Input[str]]:
        """
        This field is deprecated, use cluster_ipv4_cidr_block.
        """
        warnings.warn("""This field is deprecated, use cluster_ipv4_cidr_block.""", DeprecationWarning)
        pulumi.log.warn("""cluster_ipv4_cidr is deprecated: This field is deprecated, use cluster_ipv4_cidr_block.""")

        return pulumi.get(self, "cluster_ipv4_cidr")

    @cluster_ipv4_cidr.setter
    def cluster_ipv4_cidr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_ipv4_cidr", value)

    @property
    @pulumi.getter(name="clusterIpv4CidrBlock")
    def cluster_ipv4_cidr_block(self) -> Optional[pulumi.Input[str]]:
        """
        The IP address range for the cluster pod IPs. If this field is set, then `cluster.cluster_ipv4_cidr` must be left blank. This field is only applicable when `use_ip_aliases` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        """
        return pulumi.get(self, "cluster_ipv4_cidr_block")

    @cluster_ipv4_cidr_block.setter
    def cluster_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_ipv4_cidr_block", value)

    @property
    @pulumi.getter(name="clusterSecondaryRangeName")
    def cluster_secondary_range_name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the secondary range to be used for the cluster CIDR block. The secondary range will be used for pod IP addresses. This must be an existing secondary range associated with the cluster subnetwork. This field is only applicable with use_ip_aliases and create_subnetwork is false.
        """
        return pulumi.get(self, "cluster_secondary_range_name")

    @cluster_secondary_range_name.setter
    def cluster_secondary_range_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_secondary_range_name", value)

    @property
    @pulumi.getter(name="createSubnetwork")
    def create_subnetwork(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether a new subnetwork will be created automatically for the cluster. This field is only applicable when `use_ip_aliases` is true.
        """
        return pulumi.get(self, "create_subnetwork")

    @create_subnetwork.setter
    def create_subnetwork(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "create_subnetwork", value)

    @property
    @pulumi.getter(name="ipv6AccessType")
    def ipv6_access_type(self) -> Optional[pulumi.Input['IPAllocationPolicyIpv6AccessType']]:
        """
        The ipv6 access type (internal or external) when create_subnetwork is true
        """
        return pulumi.get(self, "ipv6_access_type")

    @ipv6_access_type.setter
    def ipv6_access_type(self, value: Optional[pulumi.Input['IPAllocationPolicyIpv6AccessType']]):
        pulumi.set(self, "ipv6_access_type", value)

    @property
    @pulumi.getter(name="nodeIpv4Cidr")
    def node_ipv4_cidr(self) -> Optional[pulumi.Input[str]]:
        """
        This field is deprecated, use node_ipv4_cidr_block.
        """
        warnings.warn("""This field is deprecated, use node_ipv4_cidr_block.""", DeprecationWarning)
        pulumi.log.warn("""node_ipv4_cidr is deprecated: This field is deprecated, use node_ipv4_cidr_block.""")

        return pulumi.get(self, "node_ipv4_cidr")

    @node_ipv4_cidr.setter
    def node_ipv4_cidr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "node_ipv4_cidr", value)

    @property
    @pulumi.getter(name="nodeIpv4CidrBlock")
    def node_ipv4_cidr_block(self) -> Optional[pulumi.Input[str]]:
        """
        The IP address range of the instance IPs in this cluster. This is applicable only if `create_subnetwork` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        """
        return pulumi.get(self, "node_ipv4_cidr_block")

    @node_ipv4_cidr_block.setter
    def node_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "node_ipv4_cidr_block", value)

    @property
    @pulumi.getter(name="podCidrOverprovisionConfig")
    def pod_cidr_overprovision_config(self) -> Optional[pulumi.Input['PodCIDROverprovisionConfigArgs']]:
        """
        [PRIVATE FIELD] Pod CIDR size overprovisioning config for the cluster. Pod CIDR size per node depends on max_pods_per_node. By default, the value of max_pods_per_node is doubled and then rounded off to next power of 2 to get the size of pod CIDR block per node. Example: max_pods_per_node of 30 would result in 64 IPs (/26). This config can disable the doubling of IPs (we still round off to next power of 2) Example: max_pods_per_node of 30 will result in 32 IPs (/27) when overprovisioning is disabled.
        """
        return pulumi.get(self, "pod_cidr_overprovision_config")

    @pod_cidr_overprovision_config.setter
    def pod_cidr_overprovision_config(self, value: Optional[pulumi.Input['PodCIDROverprovisionConfigArgs']]):
        pulumi.set(self, "pod_cidr_overprovision_config", value)

    @property
    @pulumi.getter(name="servicesIpv4Cidr")
    def services_ipv4_cidr(self) -> Optional[pulumi.Input[str]]:
        """
        This field is deprecated, use services_ipv4_cidr_block.
        """
        warnings.warn("""This field is deprecated, use services_ipv4_cidr_block.""", DeprecationWarning)
        pulumi.log.warn("""services_ipv4_cidr is deprecated: This field is deprecated, use services_ipv4_cidr_block.""")

        return pulumi.get(self, "services_ipv4_cidr")

    @services_ipv4_cidr.setter
    def services_ipv4_cidr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "services_ipv4_cidr", value)

    @property
    @pulumi.getter(name="servicesIpv4CidrBlock")
    def services_ipv4_cidr_block(self) -> Optional[pulumi.Input[str]]:
        """
        The IP address range of the services IPs in this cluster. If blank, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use.
        """
        return pulumi.get(self, "services_ipv4_cidr_block")

    @services_ipv4_cidr_block.setter
    def services_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "services_ipv4_cidr_block", value)

    @property
    @pulumi.getter(name="servicesSecondaryRangeName")
    def services_secondary_range_name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the secondary range to be used as for the services CIDR block. The secondary range will be used for service ClusterIPs. This must be an existing secondary range associated with the cluster subnetwork. This field is only applicable with use_ip_aliases and create_subnetwork is false.
        """
        return pulumi.get(self, "services_secondary_range_name")

    @services_secondary_range_name.setter
    def services_secondary_range_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "services_secondary_range_name", value)

    @property
    @pulumi.getter(name="stackType")
    def stack_type(self) -> Optional[pulumi.Input['IPAllocationPolicyStackType']]:
        """
        IP stack type
        """
        return pulumi.get(self, "stack_type")

    @stack_type.setter
    def stack_type(self, value: Optional[pulumi.Input['IPAllocationPolicyStackType']]):
        pulumi.set(self, "stack_type", value)

    @property
    @pulumi.getter(name="subnetworkName")
    def subnetwork_name(self) -> Optional[pulumi.Input[str]]:
        """
        A custom subnetwork name to be used if `create_subnetwork` is true. If this field is empty, then an automatic name will be chosen for the new subnetwork.
        """
        return pulumi.get(self, "subnetwork_name")

    @subnetwork_name.setter
    def subnetwork_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subnetwork_name", value)

    @property
    @pulumi.getter(name="tpuIpv4CidrBlock")
    def tpu_ipv4_cidr_block(self) -> Optional[pulumi.Input[str]]:
        """
        The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.
        """
        warnings.warn("""The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.""", DeprecationWarning)
        pulumi.log.warn("""tpu_ipv4_cidr_block is deprecated: The IP address range of the Cloud TPUs in this cluster. If unspecified, a range will be automatically chosen with the default size. This field is only applicable when `use_ip_aliases` is true. If unspecified, the range will use the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range to use. This field is deprecated, use cluster.tpu_config.ipv4_cidr_block instead.""")

        return pulumi.get(self, "tpu_ipv4_cidr_block")

    @tpu_ipv4_cidr_block.setter
    def tpu_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "tpu_ipv4_cidr_block", value)

    @property
    @pulumi.getter(name="useIpAliases")
    def use_ip_aliases(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether alias IPs will be used for pod IPs in the cluster. This is used in conjunction with use_routes. It cannot be true if use_routes is true. If both use_ip_aliases and use_routes are false, then the server picks the default IP allocation mode
        """
        return pulumi.get(self, "use_ip_aliases")

    @use_ip_aliases.setter
    def use_ip_aliases(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_ip_aliases", value)

    @property
    @pulumi.getter(name="useRoutes")
    def use_routes(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether routes will be used for pod IPs in the cluster. This is used in conjunction with use_ip_aliases. It cannot be true if use_ip_aliases is true. If both use_ip_aliases and use_routes are false, then the server picks the default IP allocation mode
        """
        return pulumi.get(self, "use_routes")

    @use_routes.setter
    def use_routes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_routes", value)


@pulumi.input_type
class IdentityServiceConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        IdentityServiceConfig is configuration for Identity Service which allows customers to use external identity providers with the K8S API
        :param pulumi.Input[bool] enabled: Whether to enable the Identity Service component
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to enable the Identity Service component
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class IstioConfigArgs:
    def __init__(__self__, *,
                 auth: Optional[pulumi.Input['IstioConfigAuth']] = None,
                 disabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration options for Istio addon.
        :param pulumi.Input['IstioConfigAuth'] auth: The specified Istio auth mode, either none, or mutual TLS.
        :param pulumi.Input[bool] disabled: Whether Istio is enabled for this cluster.
        """
        if auth is not None:
            pulumi.set(__self__, "auth", auth)
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)

    @property
    @pulumi.getter
    def auth(self) -> Optional[pulumi.Input['IstioConfigAuth']]:
        """
        The specified Istio auth mode, either none, or mutual TLS.
        """
        return pulumi.get(self, "auth")

    @auth.setter
    def auth(self, value: Optional[pulumi.Input['IstioConfigAuth']]):
        pulumi.set(self, "auth", value)

    @property
    @pulumi.getter
    def disabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether Istio is enabled for this cluster.
        """
        return pulumi.get(self, "disabled")

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disabled", value)


@pulumi.input_type
class KalmConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration options for the KALM addon.
        :param pulumi.Input[bool] enabled: Whether KALM is enabled for this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether KALM is enabled for this cluster.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class KubernetesDashboardArgs:
    def __init__(__self__, *,
                 disabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for the Kubernetes Dashboard.
        :param pulumi.Input[bool] disabled: Whether the Kubernetes Dashboard is enabled for this cluster.
        """
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)

    @property
    @pulumi.getter
    def disabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the Kubernetes Dashboard is enabled for this cluster.
        """
        return pulumi.get(self, "disabled")

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disabled", value)


@pulumi.input_type
class LegacyAbacArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for the legacy Attribute Based Access Control authorization mode.
        :param pulumi.Input[bool] enabled: Whether the ABAC authorizer is enabled for this cluster. When enabled, identities in the system, including service accounts, nodes, and controllers, will have statically granted permissions beyond those provided by the RBAC configuration or IAM.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the ABAC authorizer is enabled for this cluster. When enabled, identities in the system, including service accounts, nodes, and controllers, will have statically granted permissions beyond those provided by the RBAC configuration or IAM.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class LinuxNodeConfigArgs:
    def __init__(__self__, *,
                 cgroup_mode: Optional[pulumi.Input['LinuxNodeConfigCgroupMode']] = None,
                 sysctls: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
        """
        Parameters that can be configured on Linux nodes.
        :param pulumi.Input['LinuxNodeConfigCgroupMode'] cgroup_mode: cgroup_mode specifies the cgroup mode to be used on the node.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] sysctls: The Linux kernel parameters to be applied to the nodes and all pods running on the nodes. The following parameters are supported. net.core.busy_poll net.core.busy_read net.core.netdev_max_backlog net.core.rmem_max net.core.wmem_default net.core.wmem_max net.core.optmem_max net.core.somaxconn net.ipv4.tcp_rmem net.ipv4.tcp_wmem net.ipv4.tcp_tw_reuse
        """
        if cgroup_mode is not None:
            pulumi.set(__self__, "cgroup_mode", cgroup_mode)
        if sysctls is not None:
            pulumi.set(__self__, "sysctls", sysctls)

    @property
    @pulumi.getter(name="cgroupMode")
    def cgroup_mode(self) -> Optional[pulumi.Input['LinuxNodeConfigCgroupMode']]:
        """
        cgroup_mode specifies the cgroup mode to be used on the node.
        """
        return pulumi.get(self, "cgroup_mode")

    @cgroup_mode.setter
    def cgroup_mode(self, value: Optional[pulumi.Input['LinuxNodeConfigCgroupMode']]):
        pulumi.set(self, "cgroup_mode", value)

    @property
    @pulumi.getter
    def sysctls(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        The Linux kernel parameters to be applied to the nodes and all pods running on the nodes. The following parameters are supported. net.core.busy_poll net.core.busy_read net.core.netdev_max_backlog net.core.rmem_max net.core.wmem_default net.core.wmem_max net.core.optmem_max net.core.somaxconn net.ipv4.tcp_rmem net.ipv4.tcp_wmem net.ipv4.tcp_tw_reuse
        """
        return pulumi.get(self, "sysctls")

    @sysctls.setter
    def sysctls(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "sysctls", value)


@pulumi.input_type
class LocalNvmeSsdBlockConfigArgs:
    def __init__(__self__, *,
                 local_ssd_count: Optional[pulumi.Input[int]] = None):
        """
        LocalNvmeSsdBlockConfig contains configuration for using raw-block local NVMe SSDs
        :param pulumi.Input[int] local_ssd_count: The number of raw-block local NVMe SSD disks to be attached to the node. Each local SSD is 375 GB in size. If zero, it means no raw-block local NVMe SSD disks to be attached to the node. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        """
        if local_ssd_count is not None:
            pulumi.set(__self__, "local_ssd_count", local_ssd_count)

    @property
    @pulumi.getter(name="localSsdCount")
    def local_ssd_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of raw-block local NVMe SSD disks to be attached to the node. Each local SSD is 375 GB in size. If zero, it means no raw-block local NVMe SSD disks to be attached to the node. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        """
        return pulumi.get(self, "local_ssd_count")

    @local_ssd_count.setter
    def local_ssd_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "local_ssd_count", value)


@pulumi.input_type
class LoggingComponentConfigArgs:
    def __init__(__self__, *,
                 enable_components: Optional[pulumi.Input[Sequence[pulumi.Input['LoggingComponentConfigEnableComponentsItem']]]] = None):
        """
        LoggingComponentConfig is cluster logging component configuration.
        :param pulumi.Input[Sequence[pulumi.Input['LoggingComponentConfigEnableComponentsItem']]] enable_components: Select components to collect logs. An empty set would disable all logging.
        """
        if enable_components is not None:
            pulumi.set(__self__, "enable_components", enable_components)

    @property
    @pulumi.getter(name="enableComponents")
    def enable_components(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LoggingComponentConfigEnableComponentsItem']]]]:
        """
        Select components to collect logs. An empty set would disable all logging.
        """
        return pulumi.get(self, "enable_components")

    @enable_components.setter
    def enable_components(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LoggingComponentConfigEnableComponentsItem']]]]):
        pulumi.set(self, "enable_components", value)


@pulumi.input_type
class LoggingConfigArgs:
    def __init__(__self__, *,
                 component_config: Optional[pulumi.Input['LoggingComponentConfigArgs']] = None):
        """
        LoggingConfig is cluster logging configuration.
        :param pulumi.Input['LoggingComponentConfigArgs'] component_config: Logging components configuration
        """
        if component_config is not None:
            pulumi.set(__self__, "component_config", component_config)

    @property
    @pulumi.getter(name="componentConfig")
    def component_config(self) -> Optional[pulumi.Input['LoggingComponentConfigArgs']]:
        """
        Logging components configuration
        """
        return pulumi.get(self, "component_config")

    @component_config.setter
    def component_config(self, value: Optional[pulumi.Input['LoggingComponentConfigArgs']]):
        pulumi.set(self, "component_config", value)


@pulumi.input_type
class LoggingVariantConfigArgs:
    def __init__(__self__, *,
                 variant: Optional[pulumi.Input['LoggingVariantConfigVariant']] = None):
        """
        LoggingVariantConfig specifies the behaviour of the logging component.
        :param pulumi.Input['LoggingVariantConfigVariant'] variant: Logging variant deployed on nodes.
        """
        if variant is not None:
            pulumi.set(__self__, "variant", variant)

    @property
    @pulumi.getter
    def variant(self) -> Optional[pulumi.Input['LoggingVariantConfigVariant']]:
        """
        Logging variant deployed on nodes.
        """
        return pulumi.get(self, "variant")

    @variant.setter
    def variant(self, value: Optional[pulumi.Input['LoggingVariantConfigVariant']]):
        pulumi.set(self, "variant", value)


@pulumi.input_type
class MaintenanceExclusionOptionsArgs:
    def __init__(__self__, *,
                 scope: Optional[pulumi.Input['MaintenanceExclusionOptionsScope']] = None):
        """
        Represents the Maintenance exclusion option.
        :param pulumi.Input['MaintenanceExclusionOptionsScope'] scope: Scope specifies the upgrade scope which upgrades are blocked by the exclusion.
        """
        if scope is not None:
            pulumi.set(__self__, "scope", scope)

    @property
    @pulumi.getter
    def scope(self) -> Optional[pulumi.Input['MaintenanceExclusionOptionsScope']]:
        """
        Scope specifies the upgrade scope which upgrades are blocked by the exclusion.
        """
        return pulumi.get(self, "scope")

    @scope.setter
    def scope(self, value: Optional[pulumi.Input['MaintenanceExclusionOptionsScope']]):
        pulumi.set(self, "scope", value)


@pulumi.input_type
class MaintenancePolicyArgs:
    def __init__(__self__, *,
                 resource_version: Optional[pulumi.Input[str]] = None,
                 window: Optional[pulumi.Input['MaintenanceWindowArgs']] = None):
        """
        MaintenancePolicy defines the maintenance policy to be used for the cluster.
        :param pulumi.Input[str] resource_version: A hash identifying the version of this policy, so that updates to fields of the policy won't accidentally undo intermediate changes (and so that users of the API unaware of some fields won't accidentally remove other fields). Make a `get()` request to the cluster to get the current resource version and include it with requests to set the policy.
        :param pulumi.Input['MaintenanceWindowArgs'] window: Specifies the maintenance window in which maintenance may be performed.
        """
        if resource_version is not None:
            pulumi.set(__self__, "resource_version", resource_version)
        if window is not None:
            pulumi.set(__self__, "window", window)

    @property
    @pulumi.getter(name="resourceVersion")
    def resource_version(self) -> Optional[pulumi.Input[str]]:
        """
        A hash identifying the version of this policy, so that updates to fields of the policy won't accidentally undo intermediate changes (and so that users of the API unaware of some fields won't accidentally remove other fields). Make a `get()` request to the cluster to get the current resource version and include it with requests to set the policy.
        """
        return pulumi.get(self, "resource_version")

    @resource_version.setter
    def resource_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resource_version", value)

    @property
    @pulumi.getter
    def window(self) -> Optional[pulumi.Input['MaintenanceWindowArgs']]:
        """
        Specifies the maintenance window in which maintenance may be performed.
        """
        return pulumi.get(self, "window")

    @window.setter
    def window(self, value: Optional[pulumi.Input['MaintenanceWindowArgs']]):
        pulumi.set(self, "window", value)


@pulumi.input_type
class MaintenanceWindowArgs:
    def __init__(__self__, *,
                 daily_maintenance_window: Optional[pulumi.Input['DailyMaintenanceWindowArgs']] = None,
                 maintenance_exclusions: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 recurring_window: Optional[pulumi.Input['RecurringTimeWindowArgs']] = None):
        """
        MaintenanceWindow defines the maintenance window to be used for the cluster.
        :param pulumi.Input['DailyMaintenanceWindowArgs'] daily_maintenance_window: DailyMaintenanceWindow specifies a daily maintenance operation window.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] maintenance_exclusions: Exceptions to maintenance window. Non-emergency maintenance should not occur in these windows.
        :param pulumi.Input['RecurringTimeWindowArgs'] recurring_window: RecurringWindow specifies some number of recurring time periods for maintenance to occur. The time windows may be overlapping. If no maintenance windows are set, maintenance can occur at any time.
        """
        if daily_maintenance_window is not None:
            pulumi.set(__self__, "daily_maintenance_window", daily_maintenance_window)
        if maintenance_exclusions is not None:
            pulumi.set(__self__, "maintenance_exclusions", maintenance_exclusions)
        if recurring_window is not None:
            pulumi.set(__self__, "recurring_window", recurring_window)

    @property
    @pulumi.getter(name="dailyMaintenanceWindow")
    def daily_maintenance_window(self) -> Optional[pulumi.Input['DailyMaintenanceWindowArgs']]:
        """
        DailyMaintenanceWindow specifies a daily maintenance operation window.
        """
        return pulumi.get(self, "daily_maintenance_window")

    @daily_maintenance_window.setter
    def daily_maintenance_window(self, value: Optional[pulumi.Input['DailyMaintenanceWindowArgs']]):
        pulumi.set(self, "daily_maintenance_window", value)

    @property
    @pulumi.getter(name="maintenanceExclusions")
    def maintenance_exclusions(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        Exceptions to maintenance window. Non-emergency maintenance should not occur in these windows.
        """
        return pulumi.get(self, "maintenance_exclusions")

    @maintenance_exclusions.setter
    def maintenance_exclusions(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "maintenance_exclusions", value)

    @property
    @pulumi.getter(name="recurringWindow")
    def recurring_window(self) -> Optional[pulumi.Input['RecurringTimeWindowArgs']]:
        """
        RecurringWindow specifies some number of recurring time periods for maintenance to occur. The time windows may be overlapping. If no maintenance windows are set, maintenance can occur at any time.
        """
        return pulumi.get(self, "recurring_window")

    @recurring_window.setter
    def recurring_window(self, value: Optional[pulumi.Input['RecurringTimeWindowArgs']]):
        pulumi.set(self, "recurring_window", value)


@pulumi.input_type
class ManagedPrometheusConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        ManagedPrometheusConfig defines the configuration for Google Cloud Managed Service for Prometheus.
        :param pulumi.Input[bool] enabled: Enable Managed Collection.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable Managed Collection.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class MasterAuthorizedNetworksConfigArgs:
    def __init__(__self__, *,
                 cidr_blocks: Optional[pulumi.Input[Sequence[pulumi.Input['CidrBlockArgs']]]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 gcp_public_cidrs_access_enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration options for the master authorized networks feature. Enabled master authorized networks will disallow all external traffic to access Kubernetes master through HTTPS except traffic from the given CIDR blocks, Google Compute Engine Public IPs and Google Prod IPs.
        :param pulumi.Input[Sequence[pulumi.Input['CidrBlockArgs']]] cidr_blocks: cidr_blocks define up to 10 external networks that could access Kubernetes master through HTTPS.
        :param pulumi.Input[bool] enabled: Whether or not master authorized networks is enabled.
        :param pulumi.Input[bool] gcp_public_cidrs_access_enabled: Whether master is accessbile via Google Compute Engine Public IP addresses.
        """
        if cidr_blocks is not None:
            pulumi.set(__self__, "cidr_blocks", cidr_blocks)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if gcp_public_cidrs_access_enabled is not None:
            pulumi.set(__self__, "gcp_public_cidrs_access_enabled", gcp_public_cidrs_access_enabled)

    @property
    @pulumi.getter(name="cidrBlocks")
    def cidr_blocks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CidrBlockArgs']]]]:
        """
        cidr_blocks define up to 10 external networks that could access Kubernetes master through HTTPS.
        """
        return pulumi.get(self, "cidr_blocks")

    @cidr_blocks.setter
    def cidr_blocks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CidrBlockArgs']]]]):
        pulumi.set(self, "cidr_blocks", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether or not master authorized networks is enabled.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter(name="gcpPublicCidrsAccessEnabled")
    def gcp_public_cidrs_access_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether master is accessbile via Google Compute Engine Public IP addresses.
        """
        return pulumi.get(self, "gcp_public_cidrs_access_enabled")

    @gcp_public_cidrs_access_enabled.setter
    def gcp_public_cidrs_access_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "gcp_public_cidrs_access_enabled", value)


@pulumi.input_type
class MasterAuthArgs:
    def __init__(__self__, *,
                 client_certificate_config: Optional[pulumi.Input['ClientCertificateConfigArgs']] = None,
                 cluster_ca_certificate: Optional[pulumi.Input[str]] = None,
                 password: Optional[pulumi.Input[str]] = None,
                 username: Optional[pulumi.Input[str]] = None):
        """
        The authentication information for accessing the master endpoint. Authentication can be done using HTTP basic auth or using client certificates.
        :param pulumi.Input['ClientCertificateConfigArgs'] client_certificate_config: Configuration for client certificate authentication on the cluster. For clusters before v1.12, if no configuration is specified, a client certificate is issued.
        :param pulumi.Input[str] password: The password to use for HTTP basic authentication to the master endpoint. Because the master endpoint is open to the Internet, you should create a strong password. If a password is provided for cluster creation, username must be non-empty. Warning: basic authentication is deprecated, and will be removed in GKE control plane versions 1.19 and newer. For a list of recommended authentication methods, see: https://cloud.google.com/kubernetes-engine/docs/how-to/api-server-authentication
        :param pulumi.Input[str] username: The username to use for HTTP basic authentication to the master endpoint. For clusters v1.6.0 and later, basic authentication can be disabled by leaving username unspecified (or setting it to the empty string). Warning: basic authentication is deprecated, and will be removed in GKE control plane versions 1.19 and newer. For a list of recommended authentication methods, see: https://cloud.google.com/kubernetes-engine/docs/how-to/api-server-authentication
        """
        if client_certificate_config is not None:
            pulumi.set(__self__, "client_certificate_config", client_certificate_config)
        if cluster_ca_certificate is not None:
            pulumi.set(__self__, "cluster_ca_certificate", cluster_ca_certificate)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="clientCertificateConfig")
    def client_certificate_config(self) -> Optional[pulumi.Input['ClientCertificateConfigArgs']]:
        """
        Configuration for client certificate authentication on the cluster. For clusters before v1.12, if no configuration is specified, a client certificate is issued.
        """
        return pulumi.get(self, "client_certificate_config")

    @client_certificate_config.setter
    def client_certificate_config(self, value: Optional[pulumi.Input['ClientCertificateConfigArgs']]):
        pulumi.set(self, "client_certificate_config", value)

    @property
    @pulumi.getter(name="clusterCaCertificate")
    def cluster_ca_certificate(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cluster_ca_certificate")

    @cluster_ca_certificate.setter
    def cluster_ca_certificate(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_ca_certificate", value)

    @property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[str]]:
        """
        The password to use for HTTP basic authentication to the master endpoint. Because the master endpoint is open to the Internet, you should create a strong password. If a password is provided for cluster creation, username must be non-empty. Warning: basic authentication is deprecated, and will be removed in GKE control plane versions 1.19 and newer. For a list of recommended authentication methods, see: https://cloud.google.com/kubernetes-engine/docs/how-to/api-server-authentication
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter
    def username(self) -> Optional[pulumi.Input[str]]:
        """
        The username to use for HTTP basic authentication to the master endpoint. For clusters v1.6.0 and later, basic authentication can be disabled by leaving username unspecified (or setting it to the empty string). Warning: basic authentication is deprecated, and will be removed in GKE control plane versions 1.19 and newer. For a list of recommended authentication methods, see: https://cloud.google.com/kubernetes-engine/docs/how-to/api-server-authentication
        """
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "username", value)


@pulumi.input_type
class MasterArgs:
    def __init__(__self__):
        """
        Master is the configuration for components on master.
        """
        pass


@pulumi.input_type
class MaxPodsConstraintArgs:
    def __init__(__self__, *,
                 max_pods_per_node: Optional[pulumi.Input[str]] = None):
        """
        Constraints applied to pods.
        :param pulumi.Input[str] max_pods_per_node: Constraint enforced on the max num of pods per node.
        """
        if max_pods_per_node is not None:
            pulumi.set(__self__, "max_pods_per_node", max_pods_per_node)

    @property
    @pulumi.getter(name="maxPodsPerNode")
    def max_pods_per_node(self) -> Optional[pulumi.Input[str]]:
        """
        Constraint enforced on the max num of pods per node.
        """
        return pulumi.get(self, "max_pods_per_node")

    @max_pods_per_node.setter
    def max_pods_per_node(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "max_pods_per_node", value)


@pulumi.input_type
class MeshCertificatesArgs:
    def __init__(__self__, *,
                 enable_certificates: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for issuance of mTLS keys and certificates to Kubernetes pods.
        :param pulumi.Input[bool] enable_certificates: enable_certificates controls issuance of workload mTLS certificates. If set, the GKE Workload Identity Certificates controller and node agent will be deployed in the cluster, which can then be configured by creating a WorkloadCertificateConfig Custom Resource. Requires Workload Identity (workload_pool must be non-empty).
        """
        if enable_certificates is not None:
            pulumi.set(__self__, "enable_certificates", enable_certificates)

    @property
    @pulumi.getter(name="enableCertificates")
    def enable_certificates(self) -> Optional[pulumi.Input[bool]]:
        """
        enable_certificates controls issuance of workload mTLS certificates. If set, the GKE Workload Identity Certificates controller and node agent will be deployed in the cluster, which can then be configured by creating a WorkloadCertificateConfig Custom Resource. Requires Workload Identity (workload_pool must be non-empty).
        """
        return pulumi.get(self, "enable_certificates")

    @enable_certificates.setter
    def enable_certificates(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_certificates", value)


@pulumi.input_type
class MonitoringComponentConfigArgs:
    def __init__(__self__, *,
                 enable_components: Optional[pulumi.Input[Sequence[pulumi.Input['MonitoringComponentConfigEnableComponentsItem']]]] = None):
        """
        MonitoringComponentConfig is cluster monitoring component configuration.
        :param pulumi.Input[Sequence[pulumi.Input['MonitoringComponentConfigEnableComponentsItem']]] enable_components: Select components to collect metrics. An empty set would disable all monitoring.
        """
        if enable_components is not None:
            pulumi.set(__self__, "enable_components", enable_components)

    @property
    @pulumi.getter(name="enableComponents")
    def enable_components(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MonitoringComponentConfigEnableComponentsItem']]]]:
        """
        Select components to collect metrics. An empty set would disable all monitoring.
        """
        return pulumi.get(self, "enable_components")

    @enable_components.setter
    def enable_components(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MonitoringComponentConfigEnableComponentsItem']]]]):
        pulumi.set(self, "enable_components", value)


@pulumi.input_type
class MonitoringConfigArgs:
    def __init__(__self__, *,
                 component_config: Optional[pulumi.Input['MonitoringComponentConfigArgs']] = None,
                 managed_prometheus_config: Optional[pulumi.Input['ManagedPrometheusConfigArgs']] = None):
        """
        MonitoringConfig is cluster monitoring configuration.
        :param pulumi.Input['MonitoringComponentConfigArgs'] component_config: Monitoring components configuration
        :param pulumi.Input['ManagedPrometheusConfigArgs'] managed_prometheus_config: Enable Google Cloud Managed Service for Prometheus in the cluster.
        """
        if component_config is not None:
            pulumi.set(__self__, "component_config", component_config)
        if managed_prometheus_config is not None:
            pulumi.set(__self__, "managed_prometheus_config", managed_prometheus_config)

    @property
    @pulumi.getter(name="componentConfig")
    def component_config(self) -> Optional[pulumi.Input['MonitoringComponentConfigArgs']]:
        """
        Monitoring components configuration
        """
        return pulumi.get(self, "component_config")

    @component_config.setter
    def component_config(self, value: Optional[pulumi.Input['MonitoringComponentConfigArgs']]):
        pulumi.set(self, "component_config", value)

    @property
    @pulumi.getter(name="managedPrometheusConfig")
    def managed_prometheus_config(self) -> Optional[pulumi.Input['ManagedPrometheusConfigArgs']]:
        """
        Enable Google Cloud Managed Service for Prometheus in the cluster.
        """
        return pulumi.get(self, "managed_prometheus_config")

    @managed_prometheus_config.setter
    def managed_prometheus_config(self, value: Optional[pulumi.Input['ManagedPrometheusConfigArgs']]):
        pulumi.set(self, "managed_prometheus_config", value)


@pulumi.input_type
class NetworkConfigArgs:
    def __init__(__self__, *,
                 datapath_provider: Optional[pulumi.Input['NetworkConfigDatapathProvider']] = None,
                 default_snat_status: Optional[pulumi.Input['DefaultSnatStatusArgs']] = None,
                 dns_config: Optional[pulumi.Input['DNSConfigArgs']] = None,
                 enable_intra_node_visibility: Optional[pulumi.Input[bool]] = None,
                 enable_l4ilb_subsetting: Optional[pulumi.Input[bool]] = None,
                 gateway_api_config: Optional[pulumi.Input['GatewayAPIConfigArgs']] = None,
                 private_ipv6_google_access: Optional[pulumi.Input['NetworkConfigPrivateIpv6GoogleAccess']] = None,
                 service_external_ips_config: Optional[pulumi.Input['ServiceExternalIPsConfigArgs']] = None):
        """
        NetworkConfig reports the relative names of network & subnetwork.
        :param pulumi.Input['NetworkConfigDatapathProvider'] datapath_provider: The desired datapath provider for this cluster. By default, uses the IPTables-based kube-proxy implementation.
        :param pulumi.Input['DefaultSnatStatusArgs'] default_snat_status: Whether the cluster disables default in-node sNAT rules. In-node sNAT rules will be disabled when default_snat_status is disabled. When disabled is set to false, default IP masquerade rules will be applied to the nodes to prevent sNAT on cluster internal traffic.
        :param pulumi.Input['DNSConfigArgs'] dns_config: DNSConfig contains clusterDNS config for this cluster.
        :param pulumi.Input[bool] enable_intra_node_visibility: Whether Intra-node visibility is enabled for this cluster. This makes same node pod to pod traffic visible for VPC network.
        :param pulumi.Input[bool] enable_l4ilb_subsetting: Whether L4ILB Subsetting is enabled for this cluster.
        :param pulumi.Input['GatewayAPIConfigArgs'] gateway_api_config: GatewayAPIConfig contains the desired config of Gateway API on this cluster.
        :param pulumi.Input['NetworkConfigPrivateIpv6GoogleAccess'] private_ipv6_google_access: The desired state of IPv6 connectivity to Google Services. By default, no private IPv6 access to or from Google Services (all access will be via IPv4)
        :param pulumi.Input['ServiceExternalIPsConfigArgs'] service_external_ips_config: ServiceExternalIPsConfig specifies if services with externalIPs field are blocked or not.
        """
        if datapath_provider is not None:
            pulumi.set(__self__, "datapath_provider", datapath_provider)
        if default_snat_status is not None:
            pulumi.set(__self__, "default_snat_status", default_snat_status)
        if dns_config is not None:
            pulumi.set(__self__, "dns_config", dns_config)
        if enable_intra_node_visibility is not None:
            pulumi.set(__self__, "enable_intra_node_visibility", enable_intra_node_visibility)
        if enable_l4ilb_subsetting is not None:
            pulumi.set(__self__, "enable_l4ilb_subsetting", enable_l4ilb_subsetting)
        if gateway_api_config is not None:
            pulumi.set(__self__, "gateway_api_config", gateway_api_config)
        if private_ipv6_google_access is not None:
            pulumi.set(__self__, "private_ipv6_google_access", private_ipv6_google_access)
        if service_external_ips_config is not None:
            pulumi.set(__self__, "service_external_ips_config", service_external_ips_config)

    @property
    @pulumi.getter(name="datapathProvider")
    def datapath_provider(self) -> Optional[pulumi.Input['NetworkConfigDatapathProvider']]:
        """
        The desired datapath provider for this cluster. By default, uses the IPTables-based kube-proxy implementation.
        """
        return pulumi.get(self, "datapath_provider")

    @datapath_provider.setter
    def datapath_provider(self, value: Optional[pulumi.Input['NetworkConfigDatapathProvider']]):
        pulumi.set(self, "datapath_provider", value)

    @property
    @pulumi.getter(name="defaultSnatStatus")
    def default_snat_status(self) -> Optional[pulumi.Input['DefaultSnatStatusArgs']]:
        """
        Whether the cluster disables default in-node sNAT rules. In-node sNAT rules will be disabled when default_snat_status is disabled. When disabled is set to false, default IP masquerade rules will be applied to the nodes to prevent sNAT on cluster internal traffic.
        """
        return pulumi.get(self, "default_snat_status")

    @default_snat_status.setter
    def default_snat_status(self, value: Optional[pulumi.Input['DefaultSnatStatusArgs']]):
        pulumi.set(self, "default_snat_status", value)

    @property
    @pulumi.getter(name="dnsConfig")
    def dns_config(self) -> Optional[pulumi.Input['DNSConfigArgs']]:
        """
        DNSConfig contains clusterDNS config for this cluster.
        """
        return pulumi.get(self, "dns_config")

    @dns_config.setter
    def dns_config(self, value: Optional[pulumi.Input['DNSConfigArgs']]):
        pulumi.set(self, "dns_config", value)

    @property
    @pulumi.getter(name="enableIntraNodeVisibility")
    def enable_intra_node_visibility(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether Intra-node visibility is enabled for this cluster. This makes same node pod to pod traffic visible for VPC network.
        """
        return pulumi.get(self, "enable_intra_node_visibility")

    @enable_intra_node_visibility.setter
    def enable_intra_node_visibility(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_intra_node_visibility", value)

    @property
    @pulumi.getter(name="enableL4ilbSubsetting")
    def enable_l4ilb_subsetting(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether L4ILB Subsetting is enabled for this cluster.
        """
        return pulumi.get(self, "enable_l4ilb_subsetting")

    @enable_l4ilb_subsetting.setter
    def enable_l4ilb_subsetting(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_l4ilb_subsetting", value)

    @property
    @pulumi.getter(name="gatewayApiConfig")
    def gateway_api_config(self) -> Optional[pulumi.Input['GatewayAPIConfigArgs']]:
        """
        GatewayAPIConfig contains the desired config of Gateway API on this cluster.
        """
        return pulumi.get(self, "gateway_api_config")

    @gateway_api_config.setter
    def gateway_api_config(self, value: Optional[pulumi.Input['GatewayAPIConfigArgs']]):
        pulumi.set(self, "gateway_api_config", value)

    @property
    @pulumi.getter(name="privateIpv6GoogleAccess")
    def private_ipv6_google_access(self) -> Optional[pulumi.Input['NetworkConfigPrivateIpv6GoogleAccess']]:
        """
        The desired state of IPv6 connectivity to Google Services. By default, no private IPv6 access to or from Google Services (all access will be via IPv4)
        """
        return pulumi.get(self, "private_ipv6_google_access")

    @private_ipv6_google_access.setter
    def private_ipv6_google_access(self, value: Optional[pulumi.Input['NetworkConfigPrivateIpv6GoogleAccess']]):
        pulumi.set(self, "private_ipv6_google_access", value)

    @property
    @pulumi.getter(name="serviceExternalIpsConfig")
    def service_external_ips_config(self) -> Optional[pulumi.Input['ServiceExternalIPsConfigArgs']]:
        """
        ServiceExternalIPsConfig specifies if services with externalIPs field are blocked or not.
        """
        return pulumi.get(self, "service_external_ips_config")

    @service_external_ips_config.setter
    def service_external_ips_config(self, value: Optional[pulumi.Input['ServiceExternalIPsConfigArgs']]):
        pulumi.set(self, "service_external_ips_config", value)


@pulumi.input_type
class NetworkPerformanceConfigArgs:
    def __init__(__self__, *,
                 external_ip_egress_bandwidth_tier: Optional[pulumi.Input['NetworkPerformanceConfigExternalIpEgressBandwidthTier']] = None,
                 total_egress_bandwidth_tier: Optional[pulumi.Input['NetworkPerformanceConfigTotalEgressBandwidthTier']] = None):
        """
        Configuration of all network bandwidth tiers
        :param pulumi.Input['NetworkPerformanceConfigExternalIpEgressBandwidthTier'] external_ip_egress_bandwidth_tier: Specifies the network bandwidth tier for the NodePool for traffic to external/public IP addresses.
        :param pulumi.Input['NetworkPerformanceConfigTotalEgressBandwidthTier'] total_egress_bandwidth_tier: Specifies the total network bandwidth tier for the NodePool.
        """
        if external_ip_egress_bandwidth_tier is not None:
            pulumi.set(__self__, "external_ip_egress_bandwidth_tier", external_ip_egress_bandwidth_tier)
        if total_egress_bandwidth_tier is not None:
            pulumi.set(__self__, "total_egress_bandwidth_tier", total_egress_bandwidth_tier)

    @property
    @pulumi.getter(name="externalIpEgressBandwidthTier")
    def external_ip_egress_bandwidth_tier(self) -> Optional[pulumi.Input['NetworkPerformanceConfigExternalIpEgressBandwidthTier']]:
        """
        Specifies the network bandwidth tier for the NodePool for traffic to external/public IP addresses.
        """
        return pulumi.get(self, "external_ip_egress_bandwidth_tier")

    @external_ip_egress_bandwidth_tier.setter
    def external_ip_egress_bandwidth_tier(self, value: Optional[pulumi.Input['NetworkPerformanceConfigExternalIpEgressBandwidthTier']]):
        pulumi.set(self, "external_ip_egress_bandwidth_tier", value)

    @property
    @pulumi.getter(name="totalEgressBandwidthTier")
    def total_egress_bandwidth_tier(self) -> Optional[pulumi.Input['NetworkPerformanceConfigTotalEgressBandwidthTier']]:
        """
        Specifies the total network bandwidth tier for the NodePool.
        """
        return pulumi.get(self, "total_egress_bandwidth_tier")

    @total_egress_bandwidth_tier.setter
    def total_egress_bandwidth_tier(self, value: Optional[pulumi.Input['NetworkPerformanceConfigTotalEgressBandwidthTier']]):
        pulumi.set(self, "total_egress_bandwidth_tier", value)


@pulumi.input_type
class NetworkPolicyConfigArgs:
    def __init__(__self__, *,
                 disabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for NetworkPolicy. This only tracks whether the addon is enabled or not on the Master, it does not track whether network policy is enabled for the nodes.
        :param pulumi.Input[bool] disabled: Whether NetworkPolicy is enabled for this cluster.
        """
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)

    @property
    @pulumi.getter
    def disabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether NetworkPolicy is enabled for this cluster.
        """
        return pulumi.get(self, "disabled")

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disabled", value)


@pulumi.input_type
class NetworkPolicyArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 provider: Optional[pulumi.Input['NetworkPolicyProvider']] = None):
        """
        Configuration options for the NetworkPolicy feature. https://kubernetes.io/docs/concepts/services-networking/networkpolicies/
        :param pulumi.Input[bool] enabled: Whether network policy is enabled on the cluster.
        :param pulumi.Input['NetworkPolicyProvider'] provider: The selected network policy provider.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether network policy is enabled on the cluster.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter
    def provider(self) -> Optional[pulumi.Input['NetworkPolicyProvider']]:
        """
        The selected network policy provider.
        """
        return pulumi.get(self, "provider")

    @provider.setter
    def provider(self, value: Optional[pulumi.Input['NetworkPolicyProvider']]):
        pulumi.set(self, "provider", value)


@pulumi.input_type
class NetworkTagsArgs:
    def __init__(__self__, *,
                 tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        Collection of Compute Engine network tags that can be applied to a node's underlying VM instance. (See `tags` field in [`NodeConfig`](/kubernetes-engine/docs/reference/rest/v1/NodeConfig)).
        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: List of network tags.
        """
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

    @property
    @pulumi.getter
    def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of network tags.
        """
        return pulumi.get(self, "tags")

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "tags", value)


@pulumi.input_type
class NodeConfigDefaultsArgs:
    def __init__(__self__, *,
                 gcfs_config: Optional[pulumi.Input['GcfsConfigArgs']] = None,
                 logging_config: Optional[pulumi.Input['NodePoolLoggingConfigArgs']] = None):
        """
        Subset of NodeConfig message that has defaults.
        :param pulumi.Input['GcfsConfigArgs'] gcfs_config: GCFS (Google Container File System, also known as Riptide) options.
        :param pulumi.Input['NodePoolLoggingConfigArgs'] logging_config: Logging configuration for node pools.
        """
        if gcfs_config is not None:
            pulumi.set(__self__, "gcfs_config", gcfs_config)
        if logging_config is not None:
            pulumi.set(__self__, "logging_config", logging_config)

    @property
    @pulumi.getter(name="gcfsConfig")
    def gcfs_config(self) -> Optional[pulumi.Input['GcfsConfigArgs']]:
        """
        GCFS (Google Container File System, also known as Riptide) options.
        """
        return pulumi.get(self, "gcfs_config")

    @gcfs_config.setter
    def gcfs_config(self, value: Optional[pulumi.Input['GcfsConfigArgs']]):
        pulumi.set(self, "gcfs_config", value)

    @property
    @pulumi.getter(name="loggingConfig")
    def logging_config(self) -> Optional[pulumi.Input['NodePoolLoggingConfigArgs']]:
        """
        Logging configuration for node pools.
        """
        return pulumi.get(self, "logging_config")

    @logging_config.setter
    def logging_config(self, value: Optional[pulumi.Input['NodePoolLoggingConfigArgs']]):
        pulumi.set(self, "logging_config", value)


@pulumi.input_type
class NodeConfigArgs:
    def __init__(__self__, *,
                 accelerators: Optional[pulumi.Input[Sequence[pulumi.Input['AcceleratorConfigArgs']]]] = None,
                 advanced_machine_features: Optional[pulumi.Input['AdvancedMachineFeaturesArgs']] = None,
                 boot_disk_kms_key: Optional[pulumi.Input[str]] = None,
                 confidential_nodes: Optional[pulumi.Input['ConfidentialNodesArgs']] = None,
                 disk_size_gb: Optional[pulumi.Input[int]] = None,
                 disk_type: Optional[pulumi.Input[str]] = None,
                 ephemeral_storage_config: Optional[pulumi.Input['EphemeralStorageConfigArgs']] = None,
                 ephemeral_storage_local_ssd_config: Optional[pulumi.Input['EphemeralStorageLocalSsdConfigArgs']] = None,
                 fast_socket: Optional[pulumi.Input['FastSocketArgs']] = None,
                 gcfs_config: Optional[pulumi.Input['GcfsConfigArgs']] = None,
                 gvnic: Optional[pulumi.Input['VirtualNICArgs']] = None,
                 image_type: Optional[pulumi.Input[str]] = None,
                 kubelet_config: Optional[pulumi.Input['NodeKubeletConfigArgs']] = None,
                 labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 linux_node_config: Optional[pulumi.Input['LinuxNodeConfigArgs']] = None,
                 local_nvme_ssd_block_config: Optional[pulumi.Input['LocalNvmeSsdBlockConfigArgs']] = None,
                 local_ssd_count: Optional[pulumi.Input[int]] = None,
                 logging_config: Optional[pulumi.Input['NodePoolLoggingConfigArgs']] = None,
                 machine_type: Optional[pulumi.Input[str]] = None,
                 metadata: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 min_cpu_platform: Optional[pulumi.Input[str]] = None,
                 node_group: Optional[pulumi.Input[str]] = None,
                 oauth_scopes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 preemptible: Optional[pulumi.Input[bool]] = None,
                 reservation_affinity: Optional[pulumi.Input['ReservationAffinityArgs']] = None,
                 resource_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 sandbox_config: Optional[pulumi.Input['SandboxConfigArgs']] = None,
                 service_account: Optional[pulumi.Input[str]] = None,
                 shielded_instance_config: Optional[pulumi.Input['ShieldedInstanceConfigArgs']] = None,
                 spot: Optional[pulumi.Input[bool]] = None,
                 tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 taints: Optional[pulumi.Input[Sequence[pulumi.Input['NodeTaintArgs']]]] = None,
                 windows_node_config: Optional[pulumi.Input['WindowsNodeConfigArgs']] = None,
                 workload_metadata_config: Optional[pulumi.Input['WorkloadMetadataConfigArgs']] = None):
        """
        Parameters that describe the nodes in a cluster. GKE Autopilot clusters do not recognize parameters in `NodeConfig`. Use AutoprovisioningNodePoolDefaults instead.
        :param pulumi.Input[Sequence[pulumi.Input['AcceleratorConfigArgs']]] accelerators: A list of hardware accelerators to be attached to each node. See https://cloud.google.com/compute/docs/gpus for more information about support for GPUs.
        :param pulumi.Input['AdvancedMachineFeaturesArgs'] advanced_machine_features: Advanced features for the Compute Engine VM.
        :param pulumi.Input[str] boot_disk_kms_key:  The Customer Managed Encryption Key used to encrypt the boot disk attached to each node in the node pool. This should be of the form projects/[KEY_PROJECT_ID]/locations/[LOCATION]/keyRings/[RING_NAME]/cryptoKeys/[KEY_NAME]. For more information about protecting resources with Cloud KMS Keys please see: https://cloud.google.com/compute/docs/disks/customer-managed-encryption
        :param pulumi.Input['ConfidentialNodesArgs'] confidential_nodes: Confidential nodes config. All the nodes in the node pool will be Confidential VM once enabled.
        :param pulumi.Input[int] disk_size_gb: Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB. If unspecified, the default disk size is 100GB.
        :param pulumi.Input[str] disk_type: Type of the disk attached to each node (e.g. 'pd-standard', 'pd-ssd' or 'pd-balanced') If unspecified, the default disk type is 'pd-standard'
        :param pulumi.Input['EphemeralStorageConfigArgs'] ephemeral_storage_config: Parameters for the ephemeral storage filesystem. If unspecified, ephemeral storage is backed by the boot disk.
        :param pulumi.Input['EphemeralStorageLocalSsdConfigArgs'] ephemeral_storage_local_ssd_config: Parameters for the node ephemeral storage using Local SSDs. If unspecified, ephemeral storage is backed by the boot disk. This field is functionally equivalent to the ephemeral_storage_config
        :param pulumi.Input['FastSocketArgs'] fast_socket: Enable or disable NCCL fast socket for the node pool.
        :param pulumi.Input['GcfsConfigArgs'] gcfs_config: GCFS (Google Container File System) configs.
        :param pulumi.Input['VirtualNICArgs'] gvnic: Enable or disable gvnic on the node pool.
        :param pulumi.Input[str] image_type: The image type to use for this node. Note that for a given image type, the latest version of it will be used. Please see https://cloud.google.com/kubernetes-engine/docs/concepts/node-images for available image types.
        :param pulumi.Input['NodeKubeletConfigArgs'] kubelet_config: Node kubelet configs.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: The map of Kubernetes labels (key/value pairs) to be applied to each node. These will added in addition to any default label(s) that Kubernetes may apply to the node. In case of conflict in label keys, the applied set may differ depending on the Kubernetes version -- it's best to assume the behavior is undefined and conflicts should be avoided. For more information, including usage and the valid values, see: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/
        :param pulumi.Input['LinuxNodeConfigArgs'] linux_node_config: Parameters that can be configured on Linux nodes.
        :param pulumi.Input['LocalNvmeSsdBlockConfigArgs'] local_nvme_ssd_block_config: Parameters for using raw-block Local NVMe SSDs.
        :param pulumi.Input[int] local_ssd_count: The number of local SSD disks to be attached to the node. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        :param pulumi.Input['NodePoolLoggingConfigArgs'] logging_config: Logging configuration.
        :param pulumi.Input[str] machine_type: The name of a Google Compute Engine [machine type](https://cloud.google.com/compute/docs/machine-types). If unspecified, the default machine type is `e2-medium`.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] metadata: The metadata key/value pairs assigned to instances in the cluster. Keys must conform to the regexp `[a-zA-Z0-9-_]+` and be less than 128 bytes in length. These are reflected as part of a URL in the metadata server. Additionally, to avoid ambiguity, keys must not conflict with any other metadata keys for the project or be one of the reserved keys: - "cluster-location" - "cluster-name" - "cluster-uid" - "configure-sh" - "containerd-configure-sh" - "enable-oslogin" - "gci-ensure-gke-docker" - "gci-metrics-enabled" - "gci-update-strategy" - "instance-template" - "kube-env" - "startup-script" - "user-data" - "disable-address-manager" - "windows-startup-script-ps1" - "common-psm1" - "k8s-node-setup-psm1" - "install-ssh-psm1" - "user-profile-psm1" Values are free-form strings, and only have meaning as interpreted by the image running in the instance. The only restriction placed on them is that each value's size must be less than or equal to 32 KB. The total size of all keys and values must be less than 512 KB.
        :param pulumi.Input[str] min_cpu_platform: Minimum CPU platform to be used by this instance. The instance may be scheduled on the specified or newer CPU platform. Applicable values are the friendly names of CPU platforms, such as `minCpuPlatform: "Intel Haswell"` or `minCpuPlatform: "Intel Sandy Bridge"`. For more information, read [how to specify min CPU platform](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform).
        :param pulumi.Input[str] node_group: Setting this field will assign instances of this pool to run on the specified node group. This is useful for running workloads on [sole tenant nodes](https://cloud.google.com/compute/docs/nodes/sole-tenant-nodes).
        :param pulumi.Input[Sequence[pulumi.Input[str]]] oauth_scopes: The set of Google API scopes to be made available on all of the node VMs under the "default" service account. The following scopes are recommended, but not required, and by default are not included: * `https://www.googleapis.com/auth/compute` is required for mounting persistent storage on your nodes. * `https://www.googleapis.com/auth/devstorage.read_only` is required for communicating with **gcr.io** (the [Google Container Registry](https://cloud.google.com/container-registry/)). If unspecified, no scopes are added, unless Cloud Logging or Cloud Monitoring are enabled, in which case their required scopes will be added.
        :param pulumi.Input[bool] preemptible: Whether the nodes are created as preemptible VM instances. See: https://cloud.google.com/compute/docs/instances/preemptible for more inforamtion about preemptible VM instances.
        :param pulumi.Input['ReservationAffinityArgs'] reservation_affinity: The optional reservation affinity. Setting this field will apply the specified [Zonal Compute Reservation](https://cloud.google.com/compute/docs/instances/reserving-zonal-resources) to this node pool.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] resource_labels: The resource labels for the node pool to use to annotate any related Google Compute Engine resources.
        :param pulumi.Input['SandboxConfigArgs'] sandbox_config: Sandbox configuration for this node.
        :param pulumi.Input[str] service_account: The Google Cloud Platform Service Account to be used by the node VMs. Specify the email address of the Service Account; otherwise, if no Service Account is specified, the "default" service account is used.
        :param pulumi.Input['ShieldedInstanceConfigArgs'] shielded_instance_config: Shielded Instance options.
        :param pulumi.Input[bool] spot: Spot flag for enabling Spot VM, which is a rebrand of the existing preemptible flag.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: The list of instance tags applied to all nodes. Tags are used to identify valid sources or targets for network firewalls and are specified by the client during cluster or node pool creation. Each tag within the list must comply with RFC1035.
        :param pulumi.Input[Sequence[pulumi.Input['NodeTaintArgs']]] taints: List of kubernetes taints to be applied to each node. For more information, including usage and the valid values, see: https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/
        :param pulumi.Input['WindowsNodeConfigArgs'] windows_node_config: Parameters that can be configured on Windows nodes.
        :param pulumi.Input['WorkloadMetadataConfigArgs'] workload_metadata_config: The workload metadata configuration for this node.
        """
        if accelerators is not None:
            pulumi.set(__self__, "accelerators", accelerators)
        if advanced_machine_features is not None:
            pulumi.set(__self__, "advanced_machine_features", advanced_machine_features)
        if boot_disk_kms_key is not None:
            pulumi.set(__self__, "boot_disk_kms_key", boot_disk_kms_key)
        if confidential_nodes is not None:
            pulumi.set(__self__, "confidential_nodes", confidential_nodes)
        if disk_size_gb is not None:
            pulumi.set(__self__, "disk_size_gb", disk_size_gb)
        if disk_type is not None:
            pulumi.set(__self__, "disk_type", disk_type)
        if ephemeral_storage_config is not None:
            pulumi.set(__self__, "ephemeral_storage_config", ephemeral_storage_config)
        if ephemeral_storage_local_ssd_config is not None:
            pulumi.set(__self__, "ephemeral_storage_local_ssd_config", ephemeral_storage_local_ssd_config)
        if fast_socket is not None:
            pulumi.set(__self__, "fast_socket", fast_socket)
        if gcfs_config is not None:
            pulumi.set(__self__, "gcfs_config", gcfs_config)
        if gvnic is not None:
            pulumi.set(__self__, "gvnic", gvnic)
        if image_type is not None:
            pulumi.set(__self__, "image_type", image_type)
        if kubelet_config is not None:
            pulumi.set(__self__, "kubelet_config", kubelet_config)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if linux_node_config is not None:
            pulumi.set(__self__, "linux_node_config", linux_node_config)
        if local_nvme_ssd_block_config is not None:
            pulumi.set(__self__, "local_nvme_ssd_block_config", local_nvme_ssd_block_config)
        if local_ssd_count is not None:
            pulumi.set(__self__, "local_ssd_count", local_ssd_count)
        if logging_config is not None:
            pulumi.set(__self__, "logging_config", logging_config)
        if machine_type is not None:
            pulumi.set(__self__, "machine_type", machine_type)
        if metadata is not None:
            pulumi.set(__self__, "metadata", metadata)
        if min_cpu_platform is not None:
            pulumi.set(__self__, "min_cpu_platform", min_cpu_platform)
        if node_group is not None:
            pulumi.set(__self__, "node_group", node_group)
        if oauth_scopes is not None:
            pulumi.set(__self__, "oauth_scopes", oauth_scopes)
        if preemptible is not None:
            pulumi.set(__self__, "preemptible", preemptible)
        if reservation_affinity is not None:
            pulumi.set(__self__, "reservation_affinity", reservation_affinity)
        if resource_labels is not None:
            pulumi.set(__self__, "resource_labels", resource_labels)
        if sandbox_config is not None:
            pulumi.set(__self__, "sandbox_config", sandbox_config)
        if service_account is not None:
            pulumi.set(__self__, "service_account", service_account)
        if shielded_instance_config is not None:
            pulumi.set(__self__, "shielded_instance_config", shielded_instance_config)
        if spot is not None:
            pulumi.set(__self__, "spot", spot)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if taints is not None:
            pulumi.set(__self__, "taints", taints)
        if windows_node_config is not None:
            pulumi.set(__self__, "windows_node_config", windows_node_config)
        if workload_metadata_config is not None:
            pulumi.set(__self__, "workload_metadata_config", workload_metadata_config)

    @property
    @pulumi.getter
    def accelerators(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AcceleratorConfigArgs']]]]:
        """
        A list of hardware accelerators to be attached to each node. See https://cloud.google.com/compute/docs/gpus for more information about support for GPUs.
        """
        return pulumi.get(self, "accelerators")

    @accelerators.setter
    def accelerators(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AcceleratorConfigArgs']]]]):
        pulumi.set(self, "accelerators", value)

    @property
    @pulumi.getter(name="advancedMachineFeatures")
    def advanced_machine_features(self) -> Optional[pulumi.Input['AdvancedMachineFeaturesArgs']]:
        """
        Advanced features for the Compute Engine VM.
        """
        return pulumi.get(self, "advanced_machine_features")

    @advanced_machine_features.setter
    def advanced_machine_features(self, value: Optional[pulumi.Input['AdvancedMachineFeaturesArgs']]):
        pulumi.set(self, "advanced_machine_features", value)

    @property
    @pulumi.getter(name="bootDiskKmsKey")
    def boot_disk_kms_key(self) -> Optional[pulumi.Input[str]]:
        """
         The Customer Managed Encryption Key used to encrypt the boot disk attached to each node in the node pool. This should be of the form projects/[KEY_PROJECT_ID]/locations/[LOCATION]/keyRings/[RING_NAME]/cryptoKeys/[KEY_NAME]. For more information about protecting resources with Cloud KMS Keys please see: https://cloud.google.com/compute/docs/disks/customer-managed-encryption
        """
        return pulumi.get(self, "boot_disk_kms_key")

    @boot_disk_kms_key.setter
    def boot_disk_kms_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "boot_disk_kms_key", value)

    @property
    @pulumi.getter(name="confidentialNodes")
    def confidential_nodes(self) -> Optional[pulumi.Input['ConfidentialNodesArgs']]:
        """
        Confidential nodes config. All the nodes in the node pool will be Confidential VM once enabled.
        """
        return pulumi.get(self, "confidential_nodes")

    @confidential_nodes.setter
    def confidential_nodes(self, value: Optional[pulumi.Input['ConfidentialNodesArgs']]):
        pulumi.set(self, "confidential_nodes", value)

    @property
    @pulumi.getter(name="diskSizeGb")
    def disk_size_gb(self) -> Optional[pulumi.Input[int]]:
        """
        Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB. If unspecified, the default disk size is 100GB.
        """
        return pulumi.get(self, "disk_size_gb")

    @disk_size_gb.setter
    def disk_size_gb(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "disk_size_gb", value)

    @property
    @pulumi.getter(name="diskType")
    def disk_type(self) -> Optional[pulumi.Input[str]]:
        """
        Type of the disk attached to each node (e.g. 'pd-standard', 'pd-ssd' or 'pd-balanced') If unspecified, the default disk type is 'pd-standard'
        """
        return pulumi.get(self, "disk_type")

    @disk_type.setter
    def disk_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "disk_type", value)

    @property
    @pulumi.getter(name="ephemeralStorageConfig")
    def ephemeral_storage_config(self) -> Optional[pulumi.Input['EphemeralStorageConfigArgs']]:
        """
        Parameters for the ephemeral storage filesystem. If unspecified, ephemeral storage is backed by the boot disk.
        """
        return pulumi.get(self, "ephemeral_storage_config")

    @ephemeral_storage_config.setter
    def ephemeral_storage_config(self, value: Optional[pulumi.Input['EphemeralStorageConfigArgs']]):
        pulumi.set(self, "ephemeral_storage_config", value)

    @property
    @pulumi.getter(name="ephemeralStorageLocalSsdConfig")
    def ephemeral_storage_local_ssd_config(self) -> Optional[pulumi.Input['EphemeralStorageLocalSsdConfigArgs']]:
        """
        Parameters for the node ephemeral storage using Local SSDs. If unspecified, ephemeral storage is backed by the boot disk. This field is functionally equivalent to the ephemeral_storage_config
        """
        return pulumi.get(self, "ephemeral_storage_local_ssd_config")

    @ephemeral_storage_local_ssd_config.setter
    def ephemeral_storage_local_ssd_config(self, value: Optional[pulumi.Input['EphemeralStorageLocalSsdConfigArgs']]):
        pulumi.set(self, "ephemeral_storage_local_ssd_config", value)

    @property
    @pulumi.getter(name="fastSocket")
    def fast_socket(self) -> Optional[pulumi.Input['FastSocketArgs']]:
        """
        Enable or disable NCCL fast socket for the node pool.
        """
        return pulumi.get(self, "fast_socket")

    @fast_socket.setter
    def fast_socket(self, value: Optional[pulumi.Input['FastSocketArgs']]):
        pulumi.set(self, "fast_socket", value)

    @property
    @pulumi.getter(name="gcfsConfig")
    def gcfs_config(self) -> Optional[pulumi.Input['GcfsConfigArgs']]:
        """
        GCFS (Google Container File System) configs.
        """
        return pulumi.get(self, "gcfs_config")

    @gcfs_config.setter
    def gcfs_config(self, value: Optional[pulumi.Input['GcfsConfigArgs']]):
        pulumi.set(self, "gcfs_config", value)

    @property
    @pulumi.getter
    def gvnic(self) -> Optional[pulumi.Input['VirtualNICArgs']]:
        """
        Enable or disable gvnic on the node pool.
        """
        return pulumi.get(self, "gvnic")

    @gvnic.setter
    def gvnic(self, value: Optional[pulumi.Input['VirtualNICArgs']]):
        pulumi.set(self, "gvnic", value)

    @property
    @pulumi.getter(name="imageType")
    def image_type(self) -> Optional[pulumi.Input[str]]:
        """
        The image type to use for this node. Note that for a given image type, the latest version of it will be used. Please see https://cloud.google.com/kubernetes-engine/docs/concepts/node-images for available image types.
        """
        return pulumi.get(self, "image_type")

    @image_type.setter
    def image_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image_type", value)

    @property
    @pulumi.getter(name="kubeletConfig")
    def kubelet_config(self) -> Optional[pulumi.Input['NodeKubeletConfigArgs']]:
        """
        Node kubelet configs.
        """
        return pulumi.get(self, "kubelet_config")

    @kubelet_config.setter
    def kubelet_config(self, value: Optional[pulumi.Input['NodeKubeletConfigArgs']]):
        pulumi.set(self, "kubelet_config", value)

    @property
    @pulumi.getter
    def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        The map of Kubernetes labels (key/value pairs) to be applied to each node. These will added in addition to any default label(s) that Kubernetes may apply to the node. In case of conflict in label keys, the applied set may differ depending on the Kubernetes version -- it's best to assume the behavior is undefined and conflicts should be avoided. For more information, including usage and the valid values, see: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/
        """
        return pulumi.get(self, "labels")

    @labels.setter
    def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "labels", value)

    @property
    @pulumi.getter(name="linuxNodeConfig")
    def linux_node_config(self) -> Optional[pulumi.Input['LinuxNodeConfigArgs']]:
        """
        Parameters that can be configured on Linux nodes.
        """
        return pulumi.get(self, "linux_node_config")

    @linux_node_config.setter
    def linux_node_config(self, value: Optional[pulumi.Input['LinuxNodeConfigArgs']]):
        pulumi.set(self, "linux_node_config", value)

    @property
    @pulumi.getter(name="localNvmeSsdBlockConfig")
    def local_nvme_ssd_block_config(self) -> Optional[pulumi.Input['LocalNvmeSsdBlockConfigArgs']]:
        """
        Parameters for using raw-block Local NVMe SSDs.
        """
        return pulumi.get(self, "local_nvme_ssd_block_config")

    @local_nvme_ssd_block_config.setter
    def local_nvme_ssd_block_config(self, value: Optional[pulumi.Input['LocalNvmeSsdBlockConfigArgs']]):
        pulumi.set(self, "local_nvme_ssd_block_config", value)

    @property
    @pulumi.getter(name="localSsdCount")
    def local_ssd_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of local SSD disks to be attached to the node. The limit for this value is dependent upon the maximum number of disks available on a machine per zone. See: https://cloud.google.com/compute/docs/disks/local-ssd for more information.
        """
        return pulumi.get(self, "local_ssd_count")

    @local_ssd_count.setter
    def local_ssd_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "local_ssd_count", value)

    @property
    @pulumi.getter(name="loggingConfig")
    def logging_config(self) -> Optional[pulumi.Input['NodePoolLoggingConfigArgs']]:
        """
        Logging configuration.
        """
        return pulumi.get(self, "logging_config")

    @logging_config.setter
    def logging_config(self, value: Optional[pulumi.Input['NodePoolLoggingConfigArgs']]):
        pulumi.set(self, "logging_config", value)

    @property
    @pulumi.getter(name="machineType")
    def machine_type(self) -> Optional[pulumi.Input[str]]:
        """
        The name of a Google Compute Engine [machine type](https://cloud.google.com/compute/docs/machine-types). If unspecified, the default machine type is `e2-medium`.
        """
        return pulumi.get(self, "machine_type")

    @machine_type.setter
    def machine_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "machine_type", value)

    @property
    @pulumi.getter
    def metadata(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        The metadata key/value pairs assigned to instances in the cluster. Keys must conform to the regexp `[a-zA-Z0-9-_]+` and be less than 128 bytes in length. These are reflected as part of a URL in the metadata server. Additionally, to avoid ambiguity, keys must not conflict with any other metadata keys for the project or be one of the reserved keys: - "cluster-location" - "cluster-name" - "cluster-uid" - "configure-sh" - "containerd-configure-sh" - "enable-oslogin" - "gci-ensure-gke-docker" - "gci-metrics-enabled" - "gci-update-strategy" - "instance-template" - "kube-env" - "startup-script" - "user-data" - "disable-address-manager" - "windows-startup-script-ps1" - "common-psm1" - "k8s-node-setup-psm1" - "install-ssh-psm1" - "user-profile-psm1" Values are free-form strings, and only have meaning as interpreted by the image running in the instance. The only restriction placed on them is that each value's size must be less than or equal to 32 KB. The total size of all keys and values must be less than 512 KB.
        """
        return pulumi.get(self, "metadata")

    @metadata.setter
    def metadata(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "metadata", value)

    @property
    @pulumi.getter(name="minCpuPlatform")
    def min_cpu_platform(self) -> Optional[pulumi.Input[str]]:
        """
        Minimum CPU platform to be used by this instance. The instance may be scheduled on the specified or newer CPU platform. Applicable values are the friendly names of CPU platforms, such as `minCpuPlatform: "Intel Haswell"` or `minCpuPlatform: "Intel Sandy Bridge"`. For more information, read [how to specify min CPU platform](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform).
        """
        return pulumi.get(self, "min_cpu_platform")

    @min_cpu_platform.setter
    def min_cpu_platform(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "min_cpu_platform", value)

    @property
    @pulumi.getter(name="nodeGroup")
    def node_group(self) -> Optional[pulumi.Input[str]]:
        """
        Setting this field will assign instances of this pool to run on the specified node group. This is useful for running workloads on [sole tenant nodes](https://cloud.google.com/compute/docs/nodes/sole-tenant-nodes).
        """
        return pulumi.get(self, "node_group")

    @node_group.setter
    def node_group(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "node_group", value)

    @property
    @pulumi.getter(name="oauthScopes")
    def oauth_scopes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The set of Google API scopes to be made available on all of the node VMs under the "default" service account. The following scopes are recommended, but not required, and by default are not included: * `https://www.googleapis.com/auth/compute` is required for mounting persistent storage on your nodes. * `https://www.googleapis.com/auth/devstorage.read_only` is required for communicating with **gcr.io** (the [Google Container Registry](https://cloud.google.com/container-registry/)). If unspecified, no scopes are added, unless Cloud Logging or Cloud Monitoring are enabled, in which case their required scopes will be added.
        """
        return pulumi.get(self, "oauth_scopes")

    @oauth_scopes.setter
    def oauth_scopes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "oauth_scopes", value)

    @property
    @pulumi.getter
    def preemptible(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the nodes are created as preemptible VM instances. See: https://cloud.google.com/compute/docs/instances/preemptible for more inforamtion about preemptible VM instances.
        """
        return pulumi.get(self, "preemptible")

    @preemptible.setter
    def preemptible(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "preemptible", value)

    @property
    @pulumi.getter(name="reservationAffinity")
    def reservation_affinity(self) -> Optional[pulumi.Input['ReservationAffinityArgs']]:
        """
        The optional reservation affinity. Setting this field will apply the specified [Zonal Compute Reservation](https://cloud.google.com/compute/docs/instances/reserving-zonal-resources) to this node pool.
        """
        return pulumi.get(self, "reservation_affinity")

    @reservation_affinity.setter
    def reservation_affinity(self, value: Optional[pulumi.Input['ReservationAffinityArgs']]):
        pulumi.set(self, "reservation_affinity", value)

    @property
    @pulumi.getter(name="resourceLabels")
    def resource_labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        The resource labels for the node pool to use to annotate any related Google Compute Engine resources.
        """
        return pulumi.get(self, "resource_labels")

    @resource_labels.setter
    def resource_labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "resource_labels", value)

    @property
    @pulumi.getter(name="sandboxConfig")
    def sandbox_config(self) -> Optional[pulumi.Input['SandboxConfigArgs']]:
        """
        Sandbox configuration for this node.
        """
        return pulumi.get(self, "sandbox_config")

    @sandbox_config.setter
    def sandbox_config(self, value: Optional[pulumi.Input['SandboxConfigArgs']]):
        pulumi.set(self, "sandbox_config", value)

    @property
    @pulumi.getter(name="serviceAccount")
    def service_account(self) -> Optional[pulumi.Input[str]]:
        """
        The Google Cloud Platform Service Account to be used by the node VMs. Specify the email address of the Service Account; otherwise, if no Service Account is specified, the "default" service account is used.
        """
        return pulumi.get(self, "service_account")

    @service_account.setter
    def service_account(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_account", value)

    @property
    @pulumi.getter(name="shieldedInstanceConfig")
    def shielded_instance_config(self) -> Optional[pulumi.Input['ShieldedInstanceConfigArgs']]:
        """
        Shielded Instance options.
        """
        return pulumi.get(self, "shielded_instance_config")

    @shielded_instance_config.setter
    def shielded_instance_config(self, value: Optional[pulumi.Input['ShieldedInstanceConfigArgs']]):
        pulumi.set(self, "shielded_instance_config", value)

    @property
    @pulumi.getter
    def spot(self) -> Optional[pulumi.Input[bool]]:
        """
        Spot flag for enabling Spot VM, which is a rebrand of the existing preemptible flag.
        """
        return pulumi.get(self, "spot")

    @spot.setter
    def spot(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "spot", value)

    @property
    @pulumi.getter
    def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The list of instance tags applied to all nodes. Tags are used to identify valid sources or targets for network firewalls and are specified by the client during cluster or node pool creation. Each tag within the list must comply with RFC1035.
        """
        return pulumi.get(self, "tags")

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "tags", value)

    @property
    @pulumi.getter
    def taints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NodeTaintArgs']]]]:
        """
        List of kubernetes taints to be applied to each node. For more information, including usage and the valid values, see: https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/
        """
        return pulumi.get(self, "taints")

    @taints.setter
    def taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NodeTaintArgs']]]]):
        pulumi.set(self, "taints", value)

    @property
    @pulumi.getter(name="windowsNodeConfig")
    def windows_node_config(self) -> Optional[pulumi.Input['WindowsNodeConfigArgs']]:
        """
        Parameters that can be configured on Windows nodes.
        """
        return pulumi.get(self, "windows_node_config")

    @windows_node_config.setter
    def windows_node_config(self, value: Optional[pulumi.Input['WindowsNodeConfigArgs']]):
        pulumi.set(self, "windows_node_config", value)

    @property
    @pulumi.getter(name="workloadMetadataConfig")
    def workload_metadata_config(self) -> Optional[pulumi.Input['WorkloadMetadataConfigArgs']]:
        """
        The workload metadata configuration for this node.
        """
        return pulumi.get(self, "workload_metadata_config")

    @workload_metadata_config.setter
    def workload_metadata_config(self, value: Optional[pulumi.Input['WorkloadMetadataConfigArgs']]):
        pulumi.set(self, "workload_metadata_config", value)


@pulumi.input_type
class NodeKubeletConfigArgs:
    def __init__(__self__, *,
                 cpu_cfs_quota: Optional[pulumi.Input[bool]] = None,
                 cpu_cfs_quota_period: Optional[pulumi.Input[str]] = None,
                 cpu_manager_policy: Optional[pulumi.Input[str]] = None,
                 pod_pids_limit: Optional[pulumi.Input[str]] = None):
        """
        Node kubelet configs.
        :param pulumi.Input[bool] cpu_cfs_quota: Enable CPU CFS quota enforcement for containers that specify CPU limits. This option is enabled by default which makes kubelet use CFS quota (https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt) to enforce container CPU limits. Otherwise, CPU limits will not be enforced at all. Disable this option to mitigate CPU throttling problems while still having your pods to be in Guaranteed QoS class by specifying the CPU limits. The default value is 'true' if unspecified.
        :param pulumi.Input[str] cpu_cfs_quota_period: Set the CPU CFS quota period value 'cpu.cfs_period_us'. The string must be a sequence of decimal numbers, each with optional fraction and a unit suffix, such as "300ms". Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h". The value must be a positive duration.
        :param pulumi.Input[str] cpu_manager_policy: Control the CPU management policy on the node. See https://kubernetes.io/docs/tasks/administer-cluster/cpu-management-policies/ The following values are allowed. * "none": the default, which represents the existing scheduling behavior. * "static": allows pods with certain resource characteristics to be granted increased CPU affinity and exclusivity on the node. The default value is 'none' if unspecified.
        :param pulumi.Input[str] pod_pids_limit: Set the Pod PID limits. See https://kubernetes.io/docs/concepts/policy/pid-limiting/#pod-pid-limits Controls the maximum number of processes allowed to run in a pod. The value must be greater than or equal to 1024 and less than 4194304.
        """
        if cpu_cfs_quota is not None:
            pulumi.set(__self__, "cpu_cfs_quota", cpu_cfs_quota)
        if cpu_cfs_quota_period is not None:
            pulumi.set(__self__, "cpu_cfs_quota_period", cpu_cfs_quota_period)
        if cpu_manager_policy is not None:
            pulumi.set(__self__, "cpu_manager_policy", cpu_manager_policy)
        if pod_pids_limit is not None:
            pulumi.set(__self__, "pod_pids_limit", pod_pids_limit)

    @property
    @pulumi.getter(name="cpuCfsQuota")
    def cpu_cfs_quota(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable CPU CFS quota enforcement for containers that specify CPU limits. This option is enabled by default which makes kubelet use CFS quota (https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt) to enforce container CPU limits. Otherwise, CPU limits will not be enforced at all. Disable this option to mitigate CPU throttling problems while still having your pods to be in Guaranteed QoS class by specifying the CPU limits. The default value is 'true' if unspecified.
        """
        return pulumi.get(self, "cpu_cfs_quota")

    @cpu_cfs_quota.setter
    def cpu_cfs_quota(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "cpu_cfs_quota", value)

    @property
    @pulumi.getter(name="cpuCfsQuotaPeriod")
    def cpu_cfs_quota_period(self) -> Optional[pulumi.Input[str]]:
        """
        Set the CPU CFS quota period value 'cpu.cfs_period_us'. The string must be a sequence of decimal numbers, each with optional fraction and a unit suffix, such as "300ms". Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h". The value must be a positive duration.
        """
        return pulumi.get(self, "cpu_cfs_quota_period")

    @cpu_cfs_quota_period.setter
    def cpu_cfs_quota_period(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cpu_cfs_quota_period", value)

    @property
    @pulumi.getter(name="cpuManagerPolicy")
    def cpu_manager_policy(self) -> Optional[pulumi.Input[str]]:
        """
        Control the CPU management policy on the node. See https://kubernetes.io/docs/tasks/administer-cluster/cpu-management-policies/ The following values are allowed. * "none": the default, which represents the existing scheduling behavior. * "static": allows pods with certain resource characteristics to be granted increased CPU affinity and exclusivity on the node. The default value is 'none' if unspecified.
        """
        return pulumi.get(self, "cpu_manager_policy")

    @cpu_manager_policy.setter
    def cpu_manager_policy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cpu_manager_policy", value)

    @property
    @pulumi.getter(name="podPidsLimit")
    def pod_pids_limit(self) -> Optional[pulumi.Input[str]]:
        """
        Set the Pod PID limits. See https://kubernetes.io/docs/concepts/policy/pid-limiting/#pod-pid-limits Controls the maximum number of processes allowed to run in a pod. The value must be greater than or equal to 1024 and less than 4194304.
        """
        return pulumi.get(self, "pod_pids_limit")

    @pod_pids_limit.setter
    def pod_pids_limit(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "pod_pids_limit", value)


@pulumi.input_type
class NodeManagementArgs:
    def __init__(__self__, *,
                 auto_repair: Optional[pulumi.Input[bool]] = None,
                 auto_upgrade: Optional[pulumi.Input[bool]] = None,
                 upgrade_options: Optional[pulumi.Input['AutoUpgradeOptionsArgs']] = None):
        """
        NodeManagement defines the set of node management services turned on for the node pool.
        :param pulumi.Input[bool] auto_repair: Whether the nodes will be automatically repaired.
        :param pulumi.Input[bool] auto_upgrade: Whether the nodes will be automatically upgraded.
        :param pulumi.Input['AutoUpgradeOptionsArgs'] upgrade_options: Specifies the Auto Upgrade knobs for the node pool.
        """
        if auto_repair is not None:
            pulumi.set(__self__, "auto_repair", auto_repair)
        if auto_upgrade is not None:
            pulumi.set(__self__, "auto_upgrade", auto_upgrade)
        if upgrade_options is not None:
            pulumi.set(__self__, "upgrade_options", upgrade_options)

    @property
    @pulumi.getter(name="autoRepair")
    def auto_repair(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the nodes will be automatically repaired.
        """
        return pulumi.get(self, "auto_repair")

    @auto_repair.setter
    def auto_repair(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "auto_repair", value)

    @property
    @pulumi.getter(name="autoUpgrade")
    def auto_upgrade(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the nodes will be automatically upgraded.
        """
        return pulumi.get(self, "auto_upgrade")

    @auto_upgrade.setter
    def auto_upgrade(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "auto_upgrade", value)

    @property
    @pulumi.getter(name="upgradeOptions")
    def upgrade_options(self) -> Optional[pulumi.Input['AutoUpgradeOptionsArgs']]:
        """
        Specifies the Auto Upgrade knobs for the node pool.
        """
        return pulumi.get(self, "upgrade_options")

    @upgrade_options.setter
    def upgrade_options(self, value: Optional[pulumi.Input['AutoUpgradeOptionsArgs']]):
        pulumi.set(self, "upgrade_options", value)


@pulumi.input_type
class NodeNetworkConfigArgs:
    def __init__(__self__, *,
                 create_pod_range: Optional[pulumi.Input[bool]] = None,
                 enable_private_nodes: Optional[pulumi.Input[bool]] = None,
                 network_performance_config: Optional[pulumi.Input['NetworkPerformanceConfigArgs']] = None,
                 pod_cidr_overprovision_config: Optional[pulumi.Input['PodCIDROverprovisionConfigArgs']] = None,
                 pod_ipv4_cidr_block: Optional[pulumi.Input[str]] = None,
                 pod_range: Optional[pulumi.Input[str]] = None):
        """
        Parameters for node pool-level network config.
        :param pulumi.Input[bool] create_pod_range: Input only. Whether to create a new range for pod IPs in this node pool. Defaults are provided for `pod_range` and `pod_ipv4_cidr_block` if they are not specified. If neither `create_pod_range` or `pod_range` are specified, the cluster-level default (`ip_allocation_policy.cluster_ipv4_cidr_block`) is used. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        :param pulumi.Input[bool] enable_private_nodes: Whether nodes have internal IP addresses only. If enable_private_nodes is not specified, then the value is derived from cluster.privateClusterConfig.enablePrivateNodes
        :param pulumi.Input['NetworkPerformanceConfigArgs'] network_performance_config: Network bandwidth tier configuration.
        :param pulumi.Input['PodCIDROverprovisionConfigArgs'] pod_cidr_overprovision_config: [PRIVATE FIELD] Pod CIDR size overprovisioning config for the nodepool. Pod CIDR size per node depends on max_pods_per_node. By default, the value of max_pods_per_node is rounded off to next power of 2 and we then double that to get the size of pod CIDR block per node. Example: max_pods_per_node of 30 would result in 64 IPs (/26). This config can disable the doubling of IPs (we still round off to next power of 2) Example: max_pods_per_node of 30 will result in 32 IPs (/27) when overprovisioning is disabled.
        :param pulumi.Input[str] pod_ipv4_cidr_block: The IP address range for pod IPs in this node pool. Only applicable if `create_pod_range` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) to pick a specific range to use. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        :param pulumi.Input[str] pod_range: The ID of the secondary range for pod IPs. If `create_pod_range` is true, this ID is used for the new range. If `create_pod_range` is false, uses an existing secondary range with this ID. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        """
        if create_pod_range is not None:
            pulumi.set(__self__, "create_pod_range", create_pod_range)
        if enable_private_nodes is not None:
            pulumi.set(__self__, "enable_private_nodes", enable_private_nodes)
        if network_performance_config is not None:
            pulumi.set(__self__, "network_performance_config", network_performance_config)
        if pod_cidr_overprovision_config is not None:
            pulumi.set(__self__, "pod_cidr_overprovision_config", pod_cidr_overprovision_config)
        if pod_ipv4_cidr_block is not None:
            pulumi.set(__self__, "pod_ipv4_cidr_block", pod_ipv4_cidr_block)
        if pod_range is not None:
            pulumi.set(__self__, "pod_range", pod_range)

    @property
    @pulumi.getter(name="createPodRange")
    def create_pod_range(self) -> Optional[pulumi.Input[bool]]:
        """
        Input only. Whether to create a new range for pod IPs in this node pool. Defaults are provided for `pod_range` and `pod_ipv4_cidr_block` if they are not specified. If neither `create_pod_range` or `pod_range` are specified, the cluster-level default (`ip_allocation_policy.cluster_ipv4_cidr_block`) is used. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        """
        return pulumi.get(self, "create_pod_range")

    @create_pod_range.setter
    def create_pod_range(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "create_pod_range", value)

    @property
    @pulumi.getter(name="enablePrivateNodes")
    def enable_private_nodes(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether nodes have internal IP addresses only. If enable_private_nodes is not specified, then the value is derived from cluster.privateClusterConfig.enablePrivateNodes
        """
        return pulumi.get(self, "enable_private_nodes")

    @enable_private_nodes.setter
    def enable_private_nodes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_private_nodes", value)

    @property
    @pulumi.getter(name="networkPerformanceConfig")
    def network_performance_config(self) -> Optional[pulumi.Input['NetworkPerformanceConfigArgs']]:
        """
        Network bandwidth tier configuration.
        """
        return pulumi.get(self, "network_performance_config")

    @network_performance_config.setter
    def network_performance_config(self, value: Optional[pulumi.Input['NetworkPerformanceConfigArgs']]):
        pulumi.set(self, "network_performance_config", value)

    @property
    @pulumi.getter(name="podCidrOverprovisionConfig")
    def pod_cidr_overprovision_config(self) -> Optional[pulumi.Input['PodCIDROverprovisionConfigArgs']]:
        """
        [PRIVATE FIELD] Pod CIDR size overprovisioning config for the nodepool. Pod CIDR size per node depends on max_pods_per_node. By default, the value of max_pods_per_node is rounded off to next power of 2 and we then double that to get the size of pod CIDR block per node. Example: max_pods_per_node of 30 would result in 64 IPs (/26). This config can disable the doubling of IPs (we still round off to next power of 2) Example: max_pods_per_node of 30 will result in 32 IPs (/27) when overprovisioning is disabled.
        """
        return pulumi.get(self, "pod_cidr_overprovision_config")

    @pod_cidr_overprovision_config.setter
    def pod_cidr_overprovision_config(self, value: Optional[pulumi.Input['PodCIDROverprovisionConfigArgs']]):
        pulumi.set(self, "pod_cidr_overprovision_config", value)

    @property
    @pulumi.getter(name="podIpv4CidrBlock")
    def pod_ipv4_cidr_block(self) -> Optional[pulumi.Input[str]]:
        """
        The IP address range for pod IPs in this node pool. Only applicable if `create_pod_range` is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. `/14`) to have a range chosen with a specific netmask. Set to a [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) notation (e.g. `10.96.0.0/14`) to pick a specific range to use. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        """
        return pulumi.get(self, "pod_ipv4_cidr_block")

    @pod_ipv4_cidr_block.setter
    def pod_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "pod_ipv4_cidr_block", value)

    @property
    @pulumi.getter(name="podRange")
    def pod_range(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the secondary range for pod IPs. If `create_pod_range` is true, this ID is used for the new range. If `create_pod_range` is false, uses an existing secondary range with this ID. Only applicable if `ip_allocation_policy.use_ip_aliases` is true. This field cannot be changed after the node pool has been created.
        """
        return pulumi.get(self, "pod_range")

    @pod_range.setter
    def pod_range(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "pod_range", value)


@pulumi.input_type
class NodePoolAutoConfigArgs:
    def __init__(__self__, *,
                 network_tags: Optional[pulumi.Input['NetworkTagsArgs']] = None):
        """
        node pool configs that apply to all auto-provisioned node pools in autopilot clusters and node auto-provisioning enabled clusters
        :param pulumi.Input['NetworkTagsArgs'] network_tags: The list of instance tags applied to all nodes. Tags are used to identify valid sources or targets for network firewalls and are specified by the client during cluster creation. Each tag within the list must comply with RFC1035.
        """
        if network_tags is not None:
            pulumi.set(__self__, "network_tags", network_tags)

    @property
    @pulumi.getter(name="networkTags")
    def network_tags(self) -> Optional[pulumi.Input['NetworkTagsArgs']]:
        """
        The list of instance tags applied to all nodes. Tags are used to identify valid sources or targets for network firewalls and are specified by the client during cluster creation. Each tag within the list must comply with RFC1035.
        """
        return pulumi.get(self, "network_tags")

    @network_tags.setter
    def network_tags(self, value: Optional[pulumi.Input['NetworkTagsArgs']]):
        pulumi.set(self, "network_tags", value)


@pulumi.input_type
class NodePoolAutoscalingArgs:
    def __init__(__self__, *,
                 autoprovisioned: Optional[pulumi.Input[bool]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 location_policy: Optional[pulumi.Input['NodePoolAutoscalingLocationPolicy']] = None,
                 max_node_count: Optional[pulumi.Input[int]] = None,
                 min_node_count: Optional[pulumi.Input[int]] = None,
                 total_max_node_count: Optional[pulumi.Input[int]] = None,
                 total_min_node_count: Optional[pulumi.Input[int]] = None):
        """
        NodePoolAutoscaling contains information required by cluster autoscaler to adjust the size of the node pool to the current cluster usage.
        :param pulumi.Input[bool] autoprovisioned: Can this node pool be deleted automatically.
        :param pulumi.Input[bool] enabled: Is autoscaling enabled for this node pool.
        :param pulumi.Input['NodePoolAutoscalingLocationPolicy'] location_policy: Location policy used when scaling up a nodepool.
        :param pulumi.Input[int] max_node_count: Maximum number of nodes for one location in the NodePool. Must be >= min_node_count. There has to be enough quota to scale up the cluster.
        :param pulumi.Input[int] min_node_count: Minimum number of nodes for one location in the NodePool. Must be >= 1 and <= max_node_count.
        :param pulumi.Input[int] total_max_node_count: Maximum number of nodes in the node pool. Must be greater than total_min_node_count. There has to be enough quota to scale up the cluster. The total_*_node_count fields are mutually exclusive with the *_node_count fields.
        :param pulumi.Input[int] total_min_node_count: Minimum number of nodes in the node pool. Must be greater than 1 less than total_max_node_count. The total_*_node_count fields are mutually exclusive with the *_node_count fields.
        """
        if autoprovisioned is not None:
            pulumi.set(__self__, "autoprovisioned", autoprovisioned)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if location_policy is not None:
            pulumi.set(__self__, "location_policy", location_policy)
        if max_node_count is not None:
            pulumi.set(__self__, "max_node_count", max_node_count)
        if min_node_count is not None:
            pulumi.set(__self__, "min_node_count", min_node_count)
        if total_max_node_count is not None:
            pulumi.set(__self__, "total_max_node_count", total_max_node_count)
        if total_min_node_count is not None:
            pulumi.set(__self__, "total_min_node_count", total_min_node_count)

    @property
    @pulumi.getter
    def autoprovisioned(self) -> Optional[pulumi.Input[bool]]:
        """
        Can this node pool be deleted automatically.
        """
        return pulumi.get(self, "autoprovisioned")

    @autoprovisioned.setter
    def autoprovisioned(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "autoprovisioned", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Is autoscaling enabled for this node pool.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter(name="locationPolicy")
    def location_policy(self) -> Optional[pulumi.Input['NodePoolAutoscalingLocationPolicy']]:
        """
        Location policy used when scaling up a nodepool.
        """
        return pulumi.get(self, "location_policy")

    @location_policy.setter
    def location_policy(self, value: Optional[pulumi.Input['NodePoolAutoscalingLocationPolicy']]):
        pulumi.set(self, "location_policy", value)

    @property
    @pulumi.getter(name="maxNodeCount")
    def max_node_count(self) -> Optional[pulumi.Input[int]]:
        """
        Maximum number of nodes for one location in the NodePool. Must be >= min_node_count. There has to be enough quota to scale up the cluster.
        """
        return pulumi.get(self, "max_node_count")

    @max_node_count.setter
    def max_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_node_count", value)

    @property
    @pulumi.getter(name="minNodeCount")
    def min_node_count(self) -> Optional[pulumi.Input[int]]:
        """
        Minimum number of nodes for one location in the NodePool. Must be >= 1 and <= max_node_count.
        """
        return pulumi.get(self, "min_node_count")

    @min_node_count.setter
    def min_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "min_node_count", value)

    @property
    @pulumi.getter(name="totalMaxNodeCount")
    def total_max_node_count(self) -> Optional[pulumi.Input[int]]:
        """
        Maximum number of nodes in the node pool. Must be greater than total_min_node_count. There has to be enough quota to scale up the cluster. The total_*_node_count fields are mutually exclusive with the *_node_count fields.
        """
        return pulumi.get(self, "total_max_node_count")

    @total_max_node_count.setter
    def total_max_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "total_max_node_count", value)

    @property
    @pulumi.getter(name="totalMinNodeCount")
    def total_min_node_count(self) -> Optional[pulumi.Input[int]]:
        """
        Minimum number of nodes in the node pool. Must be greater than 1 less than total_max_node_count. The total_*_node_count fields are mutually exclusive with the *_node_count fields.
        """
        return pulumi.get(self, "total_min_node_count")

    @total_min_node_count.setter
    def total_min_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "total_min_node_count", value)


@pulumi.input_type
class NodePoolDefaultsArgs:
    def __init__(__self__, *,
                 node_config_defaults: Optional[pulumi.Input['NodeConfigDefaultsArgs']] = None):
        """
        Subset of Nodepool message that has defaults.
        :param pulumi.Input['NodeConfigDefaultsArgs'] node_config_defaults: Subset of NodeConfig message that has defaults.
        """
        if node_config_defaults is not None:
            pulumi.set(__self__, "node_config_defaults", node_config_defaults)

    @property
    @pulumi.getter(name="nodeConfigDefaults")
    def node_config_defaults(self) -> Optional[pulumi.Input['NodeConfigDefaultsArgs']]:
        """
        Subset of NodeConfig message that has defaults.
        """
        return pulumi.get(self, "node_config_defaults")

    @node_config_defaults.setter
    def node_config_defaults(self, value: Optional[pulumi.Input['NodeConfigDefaultsArgs']]):
        pulumi.set(self, "node_config_defaults", value)


@pulumi.input_type
class NodePoolLoggingConfigArgs:
    def __init__(__self__, *,
                 variant_config: Optional[pulumi.Input['LoggingVariantConfigArgs']] = None):
        """
        NodePoolLoggingConfig specifies logging configuration for nodepools.
        :param pulumi.Input['LoggingVariantConfigArgs'] variant_config: Logging variant configuration.
        """
        if variant_config is not None:
            pulumi.set(__self__, "variant_config", variant_config)

    @property
    @pulumi.getter(name="variantConfig")
    def variant_config(self) -> Optional[pulumi.Input['LoggingVariantConfigArgs']]:
        """
        Logging variant configuration.
        """
        return pulumi.get(self, "variant_config")

    @variant_config.setter
    def variant_config(self, value: Optional[pulumi.Input['LoggingVariantConfigArgs']]):
        pulumi.set(self, "variant_config", value)


@pulumi.input_type
class NodePoolArgs:
    def __init__(__self__, *,
                 autoscaling: Optional[pulumi.Input['NodePoolAutoscalingArgs']] = None,
                 conditions: Optional[pulumi.Input[Sequence[pulumi.Input['StatusConditionArgs']]]] = None,
                 config: Optional[pulumi.Input['NodeConfigArgs']] = None,
                 etag: Optional[pulumi.Input[str]] = None,
                 initial_node_count: Optional[pulumi.Input[int]] = None,
                 locations: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 management: Optional[pulumi.Input['NodeManagementArgs']] = None,
                 max_pods_constraint: Optional[pulumi.Input['MaxPodsConstraintArgs']] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 network_config: Optional[pulumi.Input['NodeNetworkConfigArgs']] = None,
                 placement_policy: Optional[pulumi.Input['PlacementPolicyArgs']] = None,
                 upgrade_settings: Optional[pulumi.Input['UpgradeSettingsArgs']] = None,
                 version: Optional[pulumi.Input[str]] = None):
        """
        NodePool contains the name and configuration for a cluster's node pool. Node pools are a set of nodes (i.e. VM's), with a common configuration and specification, under the control of the cluster master. They may have a set of Kubernetes labels applied to them, which may be used to reference them during pod scheduling. They may also be resized up or down, to accommodate the workload. These upgrade settings control the level of parallelism and the level of disruption caused by an upgrade. maxUnavailable controls the number of nodes that can be simultaneously unavailable. maxSurge controls the number of additional nodes that can be added to the node pool temporarily for the time of the upgrade to increase the number of available nodes. (maxUnavailable + maxSurge) determines the level of parallelism (how many nodes are being upgraded at the same time). Note: upgrades inevitably introduce some disruption since workloads need to be moved from old nodes to new, upgraded ones. Even if maxUnavailable=0, this holds true. (Disruption stays within the limits of PodDisruptionBudget, if it is configured.) Consider a hypothetical node pool with 5 nodes having maxSurge=2, maxUnavailable=1. This means the upgrade process upgrades 3 nodes simultaneously. It creates 2 additional (upgraded) nodes, then it brings down 3 old (not yet upgraded) nodes at the same time. This ensures that there are always at least 4 nodes available.
        :param pulumi.Input['NodePoolAutoscalingArgs'] autoscaling: Autoscaler configuration for this NodePool. Autoscaler is enabled only if a valid configuration is present.
        :param pulumi.Input[Sequence[pulumi.Input['StatusConditionArgs']]] conditions: Which conditions caused the current node pool state.
        :param pulumi.Input['NodeConfigArgs'] config: The node configuration of the pool.
        :param pulumi.Input[str] etag: This checksum is computed by the server based on the value of node pool fields, and may be sent on update requests to ensure the client has an up-to-date value before proceeding.
        :param pulumi.Input[int] initial_node_count: The initial node count for the pool. You must ensure that your Compute Engine [resource quota](https://cloud.google.com/compute/quotas) is sufficient for this number of instances. You must also have available firewall and routes quota.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] locations: The list of Google Compute Engine [zones](https://cloud.google.com/compute/docs/zones#available) in which the NodePool's nodes should be located. If this value is unspecified during node pool creation, the [Cluster.Locations](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1/projects.locations.clusters#Cluster.FIELDS.locations) value will be used, instead. Warning: changing node pool locations will result in nodes being added and/or removed.
        :param pulumi.Input['NodeManagementArgs'] management: NodeManagement configuration for this NodePool.
        :param pulumi.Input['MaxPodsConstraintArgs'] max_pods_constraint: The constraint on the maximum number of pods that can be run simultaneously on a node in the node pool.
        :param pulumi.Input[str] name: The name of the node pool.
        :param pulumi.Input['NodeNetworkConfigArgs'] network_config: Networking configuration for this NodePool. If specified, it overrides the cluster-level defaults.
        :param pulumi.Input['PlacementPolicyArgs'] placement_policy: Specifies the node placement policy.
        :param pulumi.Input['UpgradeSettingsArgs'] upgrade_settings: Upgrade settings control disruption and speed of the upgrade.
        :param pulumi.Input[str] version: The version of Kubernetes running on this NodePool's nodes. If unspecified, it defaults as described [here](https://cloud.google.com/kubernetes-engine/versioning#specifying_node_version).
        """
        if autoscaling is not None:
            pulumi.set(__self__, "autoscaling", autoscaling)
        if conditions is not None:
            pulumi.set(__self__, "conditions", conditions)
        if config is not None:
            pulumi.set(__self__, "config", config)
        if etag is not None:
            pulumi.set(__self__, "etag", etag)
        if initial_node_count is not None:
            pulumi.set(__self__, "initial_node_count", initial_node_count)
        if locations is not None:
            pulumi.set(__self__, "locations", locations)
        if management is not None:
            pulumi.set(__self__, "management", management)
        if max_pods_constraint is not None:
            pulumi.set(__self__, "max_pods_constraint", max_pods_constraint)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if network_config is not None:
            pulumi.set(__self__, "network_config", network_config)
        if placement_policy is not None:
            pulumi.set(__self__, "placement_policy", placement_policy)
        if upgrade_settings is not None:
            pulumi.set(__self__, "upgrade_settings", upgrade_settings)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def autoscaling(self) -> Optional[pulumi.Input['NodePoolAutoscalingArgs']]:
        """
        Autoscaler configuration for this NodePool. Autoscaler is enabled only if a valid configuration is present.
        """
        return pulumi.get(self, "autoscaling")

    @autoscaling.setter
    def autoscaling(self, value: Optional[pulumi.Input['NodePoolAutoscalingArgs']]):
        pulumi.set(self, "autoscaling", value)

    @property
    @pulumi.getter
    def conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StatusConditionArgs']]]]:
        """
        Which conditions caused the current node pool state.
        """
        return pulumi.get(self, "conditions")

    @conditions.setter
    def conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StatusConditionArgs']]]]):
        pulumi.set(self, "conditions", value)

    @property
    @pulumi.getter
    def config(self) -> Optional[pulumi.Input['NodeConfigArgs']]:
        """
        The node configuration of the pool.
        """
        return pulumi.get(self, "config")

    @config.setter
    def config(self, value: Optional[pulumi.Input['NodeConfigArgs']]):
        pulumi.set(self, "config", value)

    @property
    @pulumi.getter
    def etag(self) -> Optional[pulumi.Input[str]]:
        """
        This checksum is computed by the server based on the value of node pool fields, and may be sent on update requests to ensure the client has an up-to-date value before proceeding.
        """
        return pulumi.get(self, "etag")

    @etag.setter
    def etag(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "etag", value)

    @property
    @pulumi.getter(name="initialNodeCount")
    def initial_node_count(self) -> Optional[pulumi.Input[int]]:
        """
        The initial node count for the pool. You must ensure that your Compute Engine [resource quota](https://cloud.google.com/compute/quotas) is sufficient for this number of instances. You must also have available firewall and routes quota.
        """
        return pulumi.get(self, "initial_node_count")

    @initial_node_count.setter
    def initial_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "initial_node_count", value)

    @property
    @pulumi.getter
    def locations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The list of Google Compute Engine [zones](https://cloud.google.com/compute/docs/zones#available) in which the NodePool's nodes should be located. If this value is unspecified during node pool creation, the [Cluster.Locations](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1/projects.locations.clusters#Cluster.FIELDS.locations) value will be used, instead. Warning: changing node pool locations will result in nodes being added and/or removed.
        """
        return pulumi.get(self, "locations")

    @locations.setter
    def locations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "locations", value)

    @property
    @pulumi.getter
    def management(self) -> Optional[pulumi.Input['NodeManagementArgs']]:
        """
        NodeManagement configuration for this NodePool.
        """
        return pulumi.get(self, "management")

    @management.setter
    def management(self, value: Optional[pulumi.Input['NodeManagementArgs']]):
        pulumi.set(self, "management", value)

    @property
    @pulumi.getter(name="maxPodsConstraint")
    def max_pods_constraint(self) -> Optional[pulumi.Input['MaxPodsConstraintArgs']]:
        """
        The constraint on the maximum number of pods that can be run simultaneously on a node in the node pool.
        """
        return pulumi.get(self, "max_pods_constraint")

    @max_pods_constraint.setter
    def max_pods_constraint(self, value: Optional[pulumi.Input['MaxPodsConstraintArgs']]):
        pulumi.set(self, "max_pods_constraint", value)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the node pool.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="networkConfig")
    def network_config(self) -> Optional[pulumi.Input['NodeNetworkConfigArgs']]:
        """
        Networking configuration for this NodePool. If specified, it overrides the cluster-level defaults.
        """
        return pulumi.get(self, "network_config")

    @network_config.setter
    def network_config(self, value: Optional[pulumi.Input['NodeNetworkConfigArgs']]):
        pulumi.set(self, "network_config", value)

    @property
    @pulumi.getter(name="placementPolicy")
    def placement_policy(self) -> Optional[pulumi.Input['PlacementPolicyArgs']]:
        """
        Specifies the node placement policy.
        """
        return pulumi.get(self, "placement_policy")

    @placement_policy.setter
    def placement_policy(self, value: Optional[pulumi.Input['PlacementPolicyArgs']]):
        pulumi.set(self, "placement_policy", value)

    @property
    @pulumi.getter(name="upgradeSettings")
    def upgrade_settings(self) -> Optional[pulumi.Input['UpgradeSettingsArgs']]:
        """
        Upgrade settings control disruption and speed of the upgrade.
        """
        return pulumi.get(self, "upgrade_settings")

    @upgrade_settings.setter
    def upgrade_settings(self, value: Optional[pulumi.Input['UpgradeSettingsArgs']]):
        pulumi.set(self, "upgrade_settings", value)

    @property
    @pulumi.getter
    def version(self) -> Optional[pulumi.Input[str]]:
        """
        The version of Kubernetes running on this NodePool's nodes. If unspecified, it defaults as described [here](https://cloud.google.com/kubernetes-engine/versioning#specifying_node_version).
        """
        return pulumi.get(self, "version")

    @version.setter
    def version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "version", value)


@pulumi.input_type
class NodeTaintArgs:
    def __init__(__self__, *,
                 effect: Optional[pulumi.Input['NodeTaintEffect']] = None,
                 key: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        """
        Kubernetes taint is composed of three fields: key, value, and effect. Effect can only be one of three types: NoSchedule, PreferNoSchedule or NoExecute. See [here](https://kubernetes.io/docs/concepts/configuration/taint-and-toleration) for more information, including usage and the valid values.
        :param pulumi.Input['NodeTaintEffect'] effect: Effect for taint.
        :param pulumi.Input[str] key: Key for taint.
        :param pulumi.Input[str] value: Value for taint.
        """
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def effect(self) -> Optional[pulumi.Input['NodeTaintEffect']]:
        """
        Effect for taint.
        """
        return pulumi.get(self, "effect")

    @effect.setter
    def effect(self, value: Optional[pulumi.Input['NodeTaintEffect']]):
        pulumi.set(self, "effect", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        """
        Key for taint.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        """
        Value for taint.
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class NotificationConfigArgs:
    def __init__(__self__, *,
                 pubsub: Optional[pulumi.Input['PubSubArgs']] = None):
        """
        NotificationConfig is the configuration of notifications.
        :param pulumi.Input['PubSubArgs'] pubsub: Notification config for Pub/Sub.
        """
        if pubsub is not None:
            pulumi.set(__self__, "pubsub", pubsub)

    @property
    @pulumi.getter
    def pubsub(self) -> Optional[pulumi.Input['PubSubArgs']]:
        """
        Notification config for Pub/Sub.
        """
        return pulumi.get(self, "pubsub")

    @pubsub.setter
    def pubsub(self, value: Optional[pulumi.Input['PubSubArgs']]):
        pulumi.set(self, "pubsub", value)


@pulumi.input_type
class PlacementPolicyArgs:
    def __init__(__self__, *,
                 type: Optional[pulumi.Input['PlacementPolicyType']] = None):
        """
        PlacementPolicy defines the placement policy used by the node pool.
        :param pulumi.Input['PlacementPolicyType'] type: The type of placement.
        """
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input['PlacementPolicyType']]:
        """
        The type of placement.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input['PlacementPolicyType']]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class PodCIDROverprovisionConfigArgs:
    def __init__(__self__, *,
                 disable: Optional[pulumi.Input[bool]] = None):
        """
        [PRIVATE FIELD] Config for pod CIDR size overprovisioning.
        :param pulumi.Input[bool] disable: Whether Pod CIDR overprovisioning is disabled. Note: Pod CIDR overprovisioning is enabled by default.
        """
        if disable is not None:
            pulumi.set(__self__, "disable", disable)

    @property
    @pulumi.getter
    def disable(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether Pod CIDR overprovisioning is disabled. Note: Pod CIDR overprovisioning is enabled by default.
        """
        return pulumi.get(self, "disable")

    @disable.setter
    def disable(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disable", value)


@pulumi.input_type
class PodSecurityPolicyConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for the PodSecurityPolicy feature.
        :param pulumi.Input[bool] enabled: Enable the PodSecurityPolicy controller for this cluster. If enabled, pods must be valid under a PodSecurityPolicy to be created.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable the PodSecurityPolicy controller for this cluster. If enabled, pods must be valid under a PodSecurityPolicy to be created.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class PrivateClusterConfigArgs:
    def __init__(__self__, *,
                 enable_private_endpoint: Optional[pulumi.Input[bool]] = None,
                 enable_private_nodes: Optional[pulumi.Input[bool]] = None,
                 master_global_access_config: Optional[pulumi.Input['PrivateClusterMasterGlobalAccessConfigArgs']] = None,
                 master_ipv4_cidr_block: Optional[pulumi.Input[str]] = None,
                 private_endpoint_subnetwork: Optional[pulumi.Input[str]] = None):
        """
        Configuration options for private clusters.
        :param pulumi.Input[bool] enable_private_endpoint: Whether the master's internal IP address is used as the cluster endpoint.
        :param pulumi.Input[bool] enable_private_nodes: Whether nodes have internal IP addresses only. If enabled, all nodes are given only RFC 1918 private addresses and communicate with the master via private networking.
        :param pulumi.Input['PrivateClusterMasterGlobalAccessConfigArgs'] master_global_access_config: Controls master global access settings.
        :param pulumi.Input[str] master_ipv4_cidr_block: The IP range in CIDR notation to use for the hosted master network. This range will be used for assigning internal IP addresses to the master or set of masters, as well as the ILB VIP. This range must not overlap with any other ranges in use within the cluster's network.
        :param pulumi.Input[str] private_endpoint_subnetwork: Subnet to provision the master's private endpoint during cluster creation. Specified in projects/*/regions/*/subnetworks/* format.
        """
        if enable_private_endpoint is not None:
            pulumi.set(__self__, "enable_private_endpoint", enable_private_endpoint)
        if enable_private_nodes is not None:
            pulumi.set(__self__, "enable_private_nodes", enable_private_nodes)
        if master_global_access_config is not None:
            pulumi.set(__self__, "master_global_access_config", master_global_access_config)
        if master_ipv4_cidr_block is not None:
            pulumi.set(__self__, "master_ipv4_cidr_block", master_ipv4_cidr_block)
        if private_endpoint_subnetwork is not None:
            pulumi.set(__self__, "private_endpoint_subnetwork", private_endpoint_subnetwork)

    @property
    @pulumi.getter(name="enablePrivateEndpoint")
    def enable_private_endpoint(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the master's internal IP address is used as the cluster endpoint.
        """
        return pulumi.get(self, "enable_private_endpoint")

    @enable_private_endpoint.setter
    def enable_private_endpoint(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_private_endpoint", value)

    @property
    @pulumi.getter(name="enablePrivateNodes")
    def enable_private_nodes(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether nodes have internal IP addresses only. If enabled, all nodes are given only RFC 1918 private addresses and communicate with the master via private networking.
        """
        return pulumi.get(self, "enable_private_nodes")

    @enable_private_nodes.setter
    def enable_private_nodes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_private_nodes", value)

    @property
    @pulumi.getter(name="masterGlobalAccessConfig")
    def master_global_access_config(self) -> Optional[pulumi.Input['PrivateClusterMasterGlobalAccessConfigArgs']]:
        """
        Controls master global access settings.
        """
        return pulumi.get(self, "master_global_access_config")

    @master_global_access_config.setter
    def master_global_access_config(self, value: Optional[pulumi.Input['PrivateClusterMasterGlobalAccessConfigArgs']]):
        pulumi.set(self, "master_global_access_config", value)

    @property
    @pulumi.getter(name="masterIpv4CidrBlock")
    def master_ipv4_cidr_block(self) -> Optional[pulumi.Input[str]]:
        """
        The IP range in CIDR notation to use for the hosted master network. This range will be used for assigning internal IP addresses to the master or set of masters, as well as the ILB VIP. This range must not overlap with any other ranges in use within the cluster's network.
        """
        return pulumi.get(self, "master_ipv4_cidr_block")

    @master_ipv4_cidr_block.setter
    def master_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "master_ipv4_cidr_block", value)

    @property
    @pulumi.getter(name="privateEndpointSubnetwork")
    def private_endpoint_subnetwork(self) -> Optional[pulumi.Input[str]]:
        """
        Subnet to provision the master's private endpoint during cluster creation. Specified in projects/*/regions/*/subnetworks/* format.
        """
        return pulumi.get(self, "private_endpoint_subnetwork")

    @private_endpoint_subnetwork.setter
    def private_endpoint_subnetwork(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "private_endpoint_subnetwork", value)


@pulumi.input_type
class PrivateClusterMasterGlobalAccessConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for controlling master global access settings.
        :param pulumi.Input[bool] enabled: Whenever master is accessible globally or not.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whenever master is accessible globally or not.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class ProtectConfigArgs:
    def __init__(__self__, *,
                 workload_config: Optional[pulumi.Input['WorkloadConfigArgs']] = None,
                 workload_vulnerability_mode: Optional[pulumi.Input['ProtectConfigWorkloadVulnerabilityMode']] = None):
        """
        ProtectConfig defines the flags needed to enable/disable features for the Protect API.
        :param pulumi.Input['WorkloadConfigArgs'] workload_config: WorkloadConfig defines which actions are enabled for a cluster's workload configurations.
        :param pulumi.Input['ProtectConfigWorkloadVulnerabilityMode'] workload_vulnerability_mode: Sets which mode to use for Protect workload vulnerability scanning feature.
        """
        if workload_config is not None:
            pulumi.set(__self__, "workload_config", workload_config)
        if workload_vulnerability_mode is not None:
            pulumi.set(__self__, "workload_vulnerability_mode", workload_vulnerability_mode)

    @property
    @pulumi.getter(name="workloadConfig")
    def workload_config(self) -> Optional[pulumi.Input['WorkloadConfigArgs']]:
        """
        WorkloadConfig defines which actions are enabled for a cluster's workload configurations.
        """
        return pulumi.get(self, "workload_config")

    @workload_config.setter
    def workload_config(self, value: Optional[pulumi.Input['WorkloadConfigArgs']]):
        pulumi.set(self, "workload_config", value)

    @property
    @pulumi.getter(name="workloadVulnerabilityMode")
    def workload_vulnerability_mode(self) -> Optional[pulumi.Input['ProtectConfigWorkloadVulnerabilityMode']]:
        """
        Sets which mode to use for Protect workload vulnerability scanning feature.
        """
        return pulumi.get(self, "workload_vulnerability_mode")

    @workload_vulnerability_mode.setter
    def workload_vulnerability_mode(self, value: Optional[pulumi.Input['ProtectConfigWorkloadVulnerabilityMode']]):
        pulumi.set(self, "workload_vulnerability_mode", value)


@pulumi.input_type
class PubSubArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 filter: Optional[pulumi.Input['FilterArgs']] = None,
                 topic: Optional[pulumi.Input[str]] = None):
        """
        Pub/Sub specific notification config.
        :param pulumi.Input[bool] enabled: Enable notifications for Pub/Sub.
        :param pulumi.Input['FilterArgs'] filter: Allows filtering to one or more specific event types. If no filter is specified, or if a filter is specified with no event types, all event types will be sent
        :param pulumi.Input[str] topic: The desired Pub/Sub topic to which notifications will be sent by GKE. Format is `projects/{project}/topics/{topic}`.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if filter is not None:
            pulumi.set(__self__, "filter", filter)
        if topic is not None:
            pulumi.set(__self__, "topic", topic)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable notifications for Pub/Sub.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter
    def filter(self) -> Optional[pulumi.Input['FilterArgs']]:
        """
        Allows filtering to one or more specific event types. If no filter is specified, or if a filter is specified with no event types, all event types will be sent
        """
        return pulumi.get(self, "filter")

    @filter.setter
    def filter(self, value: Optional[pulumi.Input['FilterArgs']]):
        pulumi.set(self, "filter", value)

    @property
    @pulumi.getter
    def topic(self) -> Optional[pulumi.Input[str]]:
        """
        The desired Pub/Sub topic to which notifications will be sent by GKE. Format is `projects/{project}/topics/{topic}`.
        """
        return pulumi.get(self, "topic")

    @topic.setter
    def topic(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "topic", value)


@pulumi.input_type
class RecurringTimeWindowArgs:
    def __init__(__self__, *,
                 recurrence: Optional[pulumi.Input[str]] = None,
                 window: Optional[pulumi.Input['TimeWindowArgs']] = None):
        """
        Represents an arbitrary window of time that recurs.
        :param pulumi.Input[str] recurrence: An RRULE (https://tools.ietf.org/html/rfc5545#section-3.8.5.3) for how this window reccurs. They go on for the span of time between the start and end time. For example, to have something repeat every weekday, you'd use: `FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR` To repeat some window daily (equivalent to the DailyMaintenanceWindow): `FREQ=DAILY` For the first weekend of every month: `FREQ=MONTHLY;BYSETPOS=1;BYDAY=SA,SU` This specifies how frequently the window starts. Eg, if you wanted to have a 9-5 UTC-4 window every weekday, you'd use something like: ``` start time = 2019-01-01T09:00:00-0400 end time = 2019-01-01T17:00:00-0400 recurrence = FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR ``` Windows can span multiple days. Eg, to make the window encompass every weekend from midnight Saturday till the last minute of Sunday UTC: ``` start time = 2019-01-05T00:00:00Z end time = 2019-01-07T23:59:00Z recurrence = FREQ=WEEKLY;BYDAY=SA ``` Note the start and end time's specific dates are largely arbitrary except to specify duration of the window and when it first starts. The FREQ values of HOURLY, MINUTELY, and SECONDLY are not supported.
        :param pulumi.Input['TimeWindowArgs'] window: The window of the first recurrence.
        """
        if recurrence is not None:
            pulumi.set(__self__, "recurrence", recurrence)
        if window is not None:
            pulumi.set(__self__, "window", window)

    @property
    @pulumi.getter
    def recurrence(self) -> Optional[pulumi.Input[str]]:
        """
        An RRULE (https://tools.ietf.org/html/rfc5545#section-3.8.5.3) for how this window reccurs. They go on for the span of time between the start and end time. For example, to have something repeat every weekday, you'd use: `FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR` To repeat some window daily (equivalent to the DailyMaintenanceWindow): `FREQ=DAILY` For the first weekend of every month: `FREQ=MONTHLY;BYSETPOS=1;BYDAY=SA,SU` This specifies how frequently the window starts. Eg, if you wanted to have a 9-5 UTC-4 window every weekday, you'd use something like: ``` start time = 2019-01-01T09:00:00-0400 end time = 2019-01-01T17:00:00-0400 recurrence = FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR ``` Windows can span multiple days. Eg, to make the window encompass every weekend from midnight Saturday till the last minute of Sunday UTC: ``` start time = 2019-01-05T00:00:00Z end time = 2019-01-07T23:59:00Z recurrence = FREQ=WEEKLY;BYDAY=SA ``` Note the start and end time's specific dates are largely arbitrary except to specify duration of the window and when it first starts. The FREQ values of HOURLY, MINUTELY, and SECONDLY are not supported.
        """
        return pulumi.get(self, "recurrence")

    @recurrence.setter
    def recurrence(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "recurrence", value)

    @property
    @pulumi.getter
    def window(self) -> Optional[pulumi.Input['TimeWindowArgs']]:
        """
        The window of the first recurrence.
        """
        return pulumi.get(self, "window")

    @window.setter
    def window(self, value: Optional[pulumi.Input['TimeWindowArgs']]):
        pulumi.set(self, "window", value)


@pulumi.input_type
class ReleaseChannelArgs:
    def __init__(__self__, *,
                 channel: Optional[pulumi.Input['ReleaseChannelChannel']] = None):
        """
        ReleaseChannel indicates which release channel a cluster is subscribed to. Release channels are arranged in order of risk. When a cluster is subscribed to a release channel, Google maintains both the master version and the node version. Node auto-upgrade defaults to true and cannot be disabled.
        :param pulumi.Input['ReleaseChannelChannel'] channel: channel specifies which release channel the cluster is subscribed to.
        """
        if channel is not None:
            pulumi.set(__self__, "channel", channel)

    @property
    @pulumi.getter
    def channel(self) -> Optional[pulumi.Input['ReleaseChannelChannel']]:
        """
        channel specifies which release channel the cluster is subscribed to.
        """
        return pulumi.get(self, "channel")

    @channel.setter
    def channel(self, value: Optional[pulumi.Input['ReleaseChannelChannel']]):
        pulumi.set(self, "channel", value)


@pulumi.input_type
class ReservationAffinityArgs:
    def __init__(__self__, *,
                 consume_reservation_type: Optional[pulumi.Input['ReservationAffinityConsumeReservationType']] = None,
                 key: Optional[pulumi.Input[str]] = None,
                 values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        [ReservationAffinity](https://cloud.google.com/compute/docs/instances/reserving-zonal-resources) is the configuration of desired reservation which instances could take capacity from.
        :param pulumi.Input['ReservationAffinityConsumeReservationType'] consume_reservation_type: Corresponds to the type of reservation consumption.
        :param pulumi.Input[str] key: Corresponds to the label key of a reservation resource. To target a SPECIFIC_RESERVATION by name, specify "compute.googleapis.com/reservation-name" as the key and specify the name of your reservation as its value.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: Corresponds to the label value(s) of reservation resource(s).
        """
        if consume_reservation_type is not None:
            pulumi.set(__self__, "consume_reservation_type", consume_reservation_type)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter(name="consumeReservationType")
    def consume_reservation_type(self) -> Optional[pulumi.Input['ReservationAffinityConsumeReservationType']]:
        """
        Corresponds to the type of reservation consumption.
        """
        return pulumi.get(self, "consume_reservation_type")

    @consume_reservation_type.setter
    def consume_reservation_type(self, value: Optional[pulumi.Input['ReservationAffinityConsumeReservationType']]):
        pulumi.set(self, "consume_reservation_type", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        """
        Corresponds to the label key of a reservation resource. To target a SPECIFIC_RESERVATION by name, specify "compute.googleapis.com/reservation-name" as the key and specify the name of your reservation as its value.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Corresponds to the label value(s) of reservation resource(s).
        """
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class ResourceLimitArgs:
    def __init__(__self__, *,
                 maximum: Optional[pulumi.Input[str]] = None,
                 minimum: Optional[pulumi.Input[str]] = None,
                 resource_type: Optional[pulumi.Input[str]] = None):
        """
        Contains information about amount of some resource in the cluster. For memory, value should be in GB.
        :param pulumi.Input[str] maximum: Maximum amount of the resource in the cluster.
        :param pulumi.Input[str] minimum: Minimum amount of the resource in the cluster.
        :param pulumi.Input[str] resource_type: Resource name "cpu", "memory" or gpu-specific string.
        """
        if maximum is not None:
            pulumi.set(__self__, "maximum", maximum)
        if minimum is not None:
            pulumi.set(__self__, "minimum", minimum)
        if resource_type is not None:
            pulumi.set(__self__, "resource_type", resource_type)

    @property
    @pulumi.getter
    def maximum(self) -> Optional[pulumi.Input[str]]:
        """
        Maximum amount of the resource in the cluster.
        """
        return pulumi.get(self, "maximum")

    @maximum.setter
    def maximum(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "maximum", value)

    @property
    @pulumi.getter
    def minimum(self) -> Optional[pulumi.Input[str]]:
        """
        Minimum amount of the resource in the cluster.
        """
        return pulumi.get(self, "minimum")

    @minimum.setter
    def minimum(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "minimum", value)

    @property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> Optional[pulumi.Input[str]]:
        """
        Resource name "cpu", "memory" or gpu-specific string.
        """
        return pulumi.get(self, "resource_type")

    @resource_type.setter
    def resource_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resource_type", value)


@pulumi.input_type
class ResourceUsageExportConfigArgs:
    def __init__(__self__, *,
                 bigquery_destination: Optional[pulumi.Input['BigQueryDestinationArgs']] = None,
                 consumption_metering_config: Optional[pulumi.Input['ConsumptionMeteringConfigArgs']] = None,
                 enable_network_egress_metering: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for exporting cluster resource usages.
        :param pulumi.Input['BigQueryDestinationArgs'] bigquery_destination: Configuration to use BigQuery as usage export destination.
        :param pulumi.Input['ConsumptionMeteringConfigArgs'] consumption_metering_config: Configuration to enable resource consumption metering.
        :param pulumi.Input[bool] enable_network_egress_metering: Whether to enable network egress metering for this cluster. If enabled, a daemonset will be created in the cluster to meter network egress traffic.
        """
        if bigquery_destination is not None:
            pulumi.set(__self__, "bigquery_destination", bigquery_destination)
        if consumption_metering_config is not None:
            pulumi.set(__self__, "consumption_metering_config", consumption_metering_config)
        if enable_network_egress_metering is not None:
            pulumi.set(__self__, "enable_network_egress_metering", enable_network_egress_metering)

    @property
    @pulumi.getter(name="bigqueryDestination")
    def bigquery_destination(self) -> Optional[pulumi.Input['BigQueryDestinationArgs']]:
        """
        Configuration to use BigQuery as usage export destination.
        """
        return pulumi.get(self, "bigquery_destination")

    @bigquery_destination.setter
    def bigquery_destination(self, value: Optional[pulumi.Input['BigQueryDestinationArgs']]):
        pulumi.set(self, "bigquery_destination", value)

    @property
    @pulumi.getter(name="consumptionMeteringConfig")
    def consumption_metering_config(self) -> Optional[pulumi.Input['ConsumptionMeteringConfigArgs']]:
        """
        Configuration to enable resource consumption metering.
        """
        return pulumi.get(self, "consumption_metering_config")

    @consumption_metering_config.setter
    def consumption_metering_config(self, value: Optional[pulumi.Input['ConsumptionMeteringConfigArgs']]):
        pulumi.set(self, "consumption_metering_config", value)

    @property
    @pulumi.getter(name="enableNetworkEgressMetering")
    def enable_network_egress_metering(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to enable network egress metering for this cluster. If enabled, a daemonset will be created in the cluster to meter network egress traffic.
        """
        return pulumi.get(self, "enable_network_egress_metering")

    @enable_network_egress_metering.setter
    def enable_network_egress_metering(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_network_egress_metering", value)


@pulumi.input_type
class SandboxConfigArgs:
    def __init__(__self__, *,
                 sandbox_type: Optional[pulumi.Input[str]] = None,
                 type: Optional[pulumi.Input['SandboxConfigType']] = None):
        """
        SandboxConfig contains configurations of the sandbox to use for the node.
        :param pulumi.Input[str] sandbox_type: Type of the sandbox to use for the node (e.g. 'gvisor')
        :param pulumi.Input['SandboxConfigType'] type: Type of the sandbox to use for the node.
        """
        if sandbox_type is not None:
            pulumi.set(__self__, "sandbox_type", sandbox_type)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="sandboxType")
    def sandbox_type(self) -> Optional[pulumi.Input[str]]:
        """
        Type of the sandbox to use for the node (e.g. 'gvisor')
        """
        return pulumi.get(self, "sandbox_type")

    @sandbox_type.setter
    def sandbox_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sandbox_type", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input['SandboxConfigType']]:
        """
        Type of the sandbox to use for the node.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input['SandboxConfigType']]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class ServiceExternalIPsConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Config to block services with externalIPs field.
        :param pulumi.Input[bool] enabled: Whether Services with ExternalIPs field are allowed or not.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether Services with ExternalIPs field are allowed or not.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class ShieldedInstanceConfigArgs:
    def __init__(__self__, *,
                 enable_integrity_monitoring: Optional[pulumi.Input[bool]] = None,
                 enable_secure_boot: Optional[pulumi.Input[bool]] = None):
        """
        A set of Shielded Instance options.
        :param pulumi.Input[bool] enable_integrity_monitoring: Defines whether the instance has integrity monitoring enabled. Enables monitoring and attestation of the boot integrity of the instance. The attestation is performed against the integrity policy baseline. This baseline is initially derived from the implicitly trusted boot image when the instance is created.
        :param pulumi.Input[bool] enable_secure_boot: Defines whether the instance has Secure Boot enabled. Secure Boot helps ensure that the system only runs authentic software by verifying the digital signature of all boot components, and halting the boot process if signature verification fails.
        """
        if enable_integrity_monitoring is not None:
            pulumi.set(__self__, "enable_integrity_monitoring", enable_integrity_monitoring)
        if enable_secure_boot is not None:
            pulumi.set(__self__, "enable_secure_boot", enable_secure_boot)

    @property
    @pulumi.getter(name="enableIntegrityMonitoring")
    def enable_integrity_monitoring(self) -> Optional[pulumi.Input[bool]]:
        """
        Defines whether the instance has integrity monitoring enabled. Enables monitoring and attestation of the boot integrity of the instance. The attestation is performed against the integrity policy baseline. This baseline is initially derived from the implicitly trusted boot image when the instance is created.
        """
        return pulumi.get(self, "enable_integrity_monitoring")

    @enable_integrity_monitoring.setter
    def enable_integrity_monitoring(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_integrity_monitoring", value)

    @property
    @pulumi.getter(name="enableSecureBoot")
    def enable_secure_boot(self) -> Optional[pulumi.Input[bool]]:
        """
        Defines whether the instance has Secure Boot enabled. Secure Boot helps ensure that the system only runs authentic software by verifying the digital signature of all boot components, and halting the boot process if signature verification fails.
        """
        return pulumi.get(self, "enable_secure_boot")

    @enable_secure_boot.setter
    def enable_secure_boot(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_secure_boot", value)


@pulumi.input_type
class ShieldedNodesArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration of Shielded Nodes feature.
        :param pulumi.Input[bool] enabled: Whether Shielded Nodes features are enabled on all nodes in this cluster.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether Shielded Nodes features are enabled on all nodes in this cluster.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class StandardRolloutPolicyArgs:
    def __init__(__self__, *,
                 batch_node_count: Optional[pulumi.Input[int]] = None,
                 batch_percentage: Optional[pulumi.Input[float]] = None,
                 batch_soak_duration: Optional[pulumi.Input[str]] = None):
        """
        Standard rollout policy is the default policy for blue-green.
        :param pulumi.Input[int] batch_node_count: Number of blue nodes to drain in a batch.
        :param pulumi.Input[float] batch_percentage: Percentage of the blue pool nodes to drain in a batch. The range of this field should be (0.0, 1.0].
        :param pulumi.Input[str] batch_soak_duration: Soak time after each batch gets drained. Default to zero.
        """
        if batch_node_count is not None:
            pulumi.set(__self__, "batch_node_count", batch_node_count)
        if batch_percentage is not None:
            pulumi.set(__self__, "batch_percentage", batch_percentage)
        if batch_soak_duration is not None:
            pulumi.set(__self__, "batch_soak_duration", batch_soak_duration)

    @property
    @pulumi.getter(name="batchNodeCount")
    def batch_node_count(self) -> Optional[pulumi.Input[int]]:
        """
        Number of blue nodes to drain in a batch.
        """
        return pulumi.get(self, "batch_node_count")

    @batch_node_count.setter
    def batch_node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "batch_node_count", value)

    @property
    @pulumi.getter(name="batchPercentage")
    def batch_percentage(self) -> Optional[pulumi.Input[float]]:
        """
        Percentage of the blue pool nodes to drain in a batch. The range of this field should be (0.0, 1.0].
        """
        return pulumi.get(self, "batch_percentage")

    @batch_percentage.setter
    def batch_percentage(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "batch_percentage", value)

    @property
    @pulumi.getter(name="batchSoakDuration")
    def batch_soak_duration(self) -> Optional[pulumi.Input[str]]:
        """
        Soak time after each batch gets drained. Default to zero.
        """
        return pulumi.get(self, "batch_soak_duration")

    @batch_soak_duration.setter
    def batch_soak_duration(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "batch_soak_duration", value)


@pulumi.input_type
class StatusConditionArgs:
    def __init__(__self__, *,
                 canonical_code: Optional[pulumi.Input['StatusConditionCanonicalCode']] = None,
                 code: Optional[pulumi.Input['StatusConditionCode']] = None,
                 message: Optional[pulumi.Input[str]] = None):
        """
        StatusCondition describes why a cluster or a node pool has a certain status (e.g., ERROR or DEGRADED).
        :param pulumi.Input['StatusConditionCanonicalCode'] canonical_code: Canonical code of the condition.
        :param pulumi.Input['StatusConditionCode'] code: Machine-friendly representation of the condition Deprecated. Use canonical_code instead.
        :param pulumi.Input[str] message: Human-friendly representation of the condition
        """
        if canonical_code is not None:
            pulumi.set(__self__, "canonical_code", canonical_code)
        if code is not None:
            warnings.warn("""Machine-friendly representation of the condition Deprecated. Use canonical_code instead.""", DeprecationWarning)
            pulumi.log.warn("""code is deprecated: Machine-friendly representation of the condition Deprecated. Use canonical_code instead.""")
        if code is not None:
            pulumi.set(__self__, "code", code)
        if message is not None:
            pulumi.set(__self__, "message", message)

    @property
    @pulumi.getter(name="canonicalCode")
    def canonical_code(self) -> Optional[pulumi.Input['StatusConditionCanonicalCode']]:
        """
        Canonical code of the condition.
        """
        return pulumi.get(self, "canonical_code")

    @canonical_code.setter
    def canonical_code(self, value: Optional[pulumi.Input['StatusConditionCanonicalCode']]):
        pulumi.set(self, "canonical_code", value)

    @property
    @pulumi.getter
    def code(self) -> Optional[pulumi.Input['StatusConditionCode']]:
        """
        Machine-friendly representation of the condition Deprecated. Use canonical_code instead.
        """
        warnings.warn("""Machine-friendly representation of the condition Deprecated. Use canonical_code instead.""", DeprecationWarning)
        pulumi.log.warn("""code is deprecated: Machine-friendly representation of the condition Deprecated. Use canonical_code instead.""")

        return pulumi.get(self, "code")

    @code.setter
    def code(self, value: Optional[pulumi.Input['StatusConditionCode']]):
        pulumi.set(self, "code", value)

    @property
    @pulumi.getter
    def message(self) -> Optional[pulumi.Input[str]]:
        """
        Human-friendly representation of the condition
        """
        return pulumi.get(self, "message")

    @message.setter
    def message(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "message", value)


@pulumi.input_type
class TimeWindowArgs:
    def __init__(__self__, *,
                 end_time: Optional[pulumi.Input[str]] = None,
                 maintenance_exclusion_options: Optional[pulumi.Input['MaintenanceExclusionOptionsArgs']] = None,
                 start_time: Optional[pulumi.Input[str]] = None):
        """
        Represents an arbitrary window of time.
        :param pulumi.Input[str] end_time: The time that the window ends. The end time should take place after the start time.
        :param pulumi.Input['MaintenanceExclusionOptionsArgs'] maintenance_exclusion_options: MaintenanceExclusionOptions provides maintenance exclusion related options.
        :param pulumi.Input[str] start_time: The time that the window first starts.
        """
        if end_time is not None:
            pulumi.set(__self__, "end_time", end_time)
        if maintenance_exclusion_options is not None:
            pulumi.set(__self__, "maintenance_exclusion_options", maintenance_exclusion_options)
        if start_time is not None:
            pulumi.set(__self__, "start_time", start_time)

    @property
    @pulumi.getter(name="endTime")
    def end_time(self) -> Optional[pulumi.Input[str]]:
        """
        The time that the window ends. The end time should take place after the start time.
        """
        return pulumi.get(self, "end_time")

    @end_time.setter
    def end_time(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "end_time", value)

    @property
    @pulumi.getter(name="maintenanceExclusionOptions")
    def maintenance_exclusion_options(self) -> Optional[pulumi.Input['MaintenanceExclusionOptionsArgs']]:
        """
        MaintenanceExclusionOptions provides maintenance exclusion related options.
        """
        return pulumi.get(self, "maintenance_exclusion_options")

    @maintenance_exclusion_options.setter
    def maintenance_exclusion_options(self, value: Optional[pulumi.Input['MaintenanceExclusionOptionsArgs']]):
        pulumi.set(self, "maintenance_exclusion_options", value)

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> Optional[pulumi.Input[str]]:
        """
        The time that the window first starts.
        """
        return pulumi.get(self, "start_time")

    @start_time.setter
    def start_time(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "start_time", value)


@pulumi.input_type
class TpuConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 ipv4_cidr_block: Optional[pulumi.Input[str]] = None,
                 use_service_networking: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for Cloud TPU.
        :param pulumi.Input[bool] enabled: Whether Cloud TPU integration is enabled or not.
        :param pulumi.Input[str] ipv4_cidr_block: IPv4 CIDR block reserved for Cloud TPU in the VPC.
        :param pulumi.Input[bool] use_service_networking: Whether to use service networking for Cloud TPU or not.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if ipv4_cidr_block is not None:
            pulumi.set(__self__, "ipv4_cidr_block", ipv4_cidr_block)
        if use_service_networking is not None:
            pulumi.set(__self__, "use_service_networking", use_service_networking)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether Cloud TPU integration is enabled or not.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter(name="ipv4CidrBlock")
    def ipv4_cidr_block(self) -> Optional[pulumi.Input[str]]:
        """
        IPv4 CIDR block reserved for Cloud TPU in the VPC.
        """
        return pulumi.get(self, "ipv4_cidr_block")

    @ipv4_cidr_block.setter
    def ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ipv4_cidr_block", value)

    @property
    @pulumi.getter(name="useServiceNetworking")
    def use_service_networking(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to use service networking for Cloud TPU or not.
        """
        return pulumi.get(self, "use_service_networking")

    @use_service_networking.setter
    def use_service_networking(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_service_networking", value)


@pulumi.input_type
class UpgradeSettingsArgs:
    def __init__(__self__, *,
                 blue_green_settings: Optional[pulumi.Input['BlueGreenSettingsArgs']] = None,
                 max_surge: Optional[pulumi.Input[int]] = None,
                 max_unavailable: Optional[pulumi.Input[int]] = None,
                 strategy: Optional[pulumi.Input['UpgradeSettingsStrategy']] = None):
        """
        These upgrade settings configure the upgrade strategy for the node pool. Use strategy to switch between the strategies applied to the node pool. If the strategy is SURGE, use max_surge and max_unavailable to control the level of parallelism and the level of disruption caused by upgrade. 1. maxSurge controls the number of additional nodes that can be added to the node pool temporarily for the time of the upgrade to increase the number of available nodes. 2. maxUnavailable controls the number of nodes that can be simultaneously unavailable. 3. (maxUnavailable + maxSurge) determines the level of parallelism (how many nodes are being upgraded at the same time). If the strategy is BLUE_GREEN, use blue_green_settings to configure the blue-green upgrade related settings. 1. standard_rollout_policy is the default policy. The policy is used to control the way blue pool gets drained. The draining is executed in the batch mode. The batch size could be specified as either percentage of the node pool size or the number of nodes. batch_soak_duration is the soak time after each batch gets drained. 2. node_pool_soak_duration is the soak time after all blue nodes are drained. After this period, the blue pool nodes will be deleted.
        :param pulumi.Input['BlueGreenSettingsArgs'] blue_green_settings: Settings for blue-green upgrade strategy.
        :param pulumi.Input[int] max_surge: The maximum number of nodes that can be created beyond the current size of the node pool during the upgrade process.
        :param pulumi.Input[int] max_unavailable: The maximum number of nodes that can be simultaneously unavailable during the upgrade process. A node is considered available if its status is Ready.
        :param pulumi.Input['UpgradeSettingsStrategy'] strategy: Update strategy of the node pool.
        """
        if blue_green_settings is not None:
            pulumi.set(__self__, "blue_green_settings", blue_green_settings)
        if max_surge is not None:
            pulumi.set(__self__, "max_surge", max_surge)
        if max_unavailable is not None:
            pulumi.set(__self__, "max_unavailable", max_unavailable)
        if strategy is not None:
            pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter(name="blueGreenSettings")
    def blue_green_settings(self) -> Optional[pulumi.Input['BlueGreenSettingsArgs']]:
        """
        Settings for blue-green upgrade strategy.
        """
        return pulumi.get(self, "blue_green_settings")

    @blue_green_settings.setter
    def blue_green_settings(self, value: Optional[pulumi.Input['BlueGreenSettingsArgs']]):
        pulumi.set(self, "blue_green_settings", value)

    @property
    @pulumi.getter(name="maxSurge")
    def max_surge(self) -> Optional[pulumi.Input[int]]:
        """
        The maximum number of nodes that can be created beyond the current size of the node pool during the upgrade process.
        """
        return pulumi.get(self, "max_surge")

    @max_surge.setter
    def max_surge(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_surge", value)

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[pulumi.Input[int]]:
        """
        The maximum number of nodes that can be simultaneously unavailable during the upgrade process. A node is considered available if its status is Ready.
        """
        return pulumi.get(self, "max_unavailable")

    @max_unavailable.setter
    def max_unavailable(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_unavailable", value)

    @property
    @pulumi.getter
    def strategy(self) -> Optional[pulumi.Input['UpgradeSettingsStrategy']]:
        """
        Update strategy of the node pool.
        """
        return pulumi.get(self, "strategy")

    @strategy.setter
    def strategy(self, value: Optional[pulumi.Input['UpgradeSettingsStrategy']]):
        pulumi.set(self, "strategy", value)


@pulumi.input_type
class VerticalPodAutoscalingArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        VerticalPodAutoscaling contains global, per-cluster information required by Vertical Pod Autoscaler to automatically adjust the resources of pods controlled by it.
        :param pulumi.Input[bool] enabled: Enables vertical pod autoscaling.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enables vertical pod autoscaling.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class VirtualNICArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        Configuration of gVNIC feature.
        :param pulumi.Input[bool] enabled: Whether gVNIC features are enabled in the node pool.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether gVNIC features are enabled in the node pool.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class WindowsNodeConfigArgs:
    def __init__(__self__, *,
                 os_version: Optional[pulumi.Input['WindowsNodeConfigOsVersion']] = None):
        """
        Parameters that can be configured on Windows nodes. Windows Node Config that define the parameters that will be used to configure the Windows node pool settings
        :param pulumi.Input['WindowsNodeConfigOsVersion'] os_version: OSVersion specifies the Windows node config to be used on the node
        """
        if os_version is not None:
            pulumi.set(__self__, "os_version", os_version)

    @property
    @pulumi.getter(name="osVersion")
    def os_version(self) -> Optional[pulumi.Input['WindowsNodeConfigOsVersion']]:
        """
        OSVersion specifies the Windows node config to be used on the node
        """
        return pulumi.get(self, "os_version")

    @os_version.setter
    def os_version(self, value: Optional[pulumi.Input['WindowsNodeConfigOsVersion']]):
        pulumi.set(self, "os_version", value)


@pulumi.input_type
class WorkloadALTSConfigArgs:
    def __init__(__self__, *,
                 enable_alts: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for direct-path (via ALTS) with workload identity.
        :param pulumi.Input[bool] enable_alts: enable_alts controls whether the alts handshaker should be enabled or not for direct-path. Requires Workload Identity (workload_pool must be non-empty).
        """
        if enable_alts is not None:
            pulumi.set(__self__, "enable_alts", enable_alts)

    @property
    @pulumi.getter(name="enableAlts")
    def enable_alts(self) -> Optional[pulumi.Input[bool]]:
        """
        enable_alts controls whether the alts handshaker should be enabled or not for direct-path. Requires Workload Identity (workload_pool must be non-empty).
        """
        return pulumi.get(self, "enable_alts")

    @enable_alts.setter
    def enable_alts(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_alts", value)


@pulumi.input_type
class WorkloadCertificatesArgs:
    def __init__(__self__, *,
                 enable_certificates: Optional[pulumi.Input[bool]] = None):
        """
        Configuration for issuance of mTLS keys and certificates to Kubernetes pods.
        :param pulumi.Input[bool] enable_certificates: enable_certificates controls issuance of workload mTLS certificates. If set, the GKE Workload Identity Certificates controller and node agent will be deployed in the cluster, which can then be configured by creating a WorkloadCertificateConfig Custom Resource. Requires Workload Identity (workload_pool must be non-empty).
        """
        if enable_certificates is not None:
            pulumi.set(__self__, "enable_certificates", enable_certificates)

    @property
    @pulumi.getter(name="enableCertificates")
    def enable_certificates(self) -> Optional[pulumi.Input[bool]]:
        """
        enable_certificates controls issuance of workload mTLS certificates. If set, the GKE Workload Identity Certificates controller and node agent will be deployed in the cluster, which can then be configured by creating a WorkloadCertificateConfig Custom Resource. Requires Workload Identity (workload_pool must be non-empty).
        """
        return pulumi.get(self, "enable_certificates")

    @enable_certificates.setter
    def enable_certificates(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_certificates", value)


@pulumi.input_type
class WorkloadConfigArgs:
    def __init__(__self__, *,
                 audit_mode: Optional[pulumi.Input['WorkloadConfigAuditMode']] = None):
        """
        WorkloadConfig defines the flags to enable or disable the workload configurations for the cluster.
        :param pulumi.Input['WorkloadConfigAuditMode'] audit_mode: Sets which mode of auditing should be used for the cluster's workloads.
        """
        if audit_mode is not None:
            pulumi.set(__self__, "audit_mode", audit_mode)

    @property
    @pulumi.getter(name="auditMode")
    def audit_mode(self) -> Optional[pulumi.Input['WorkloadConfigAuditMode']]:
        """
        Sets which mode of auditing should be used for the cluster's workloads.
        """
        return pulumi.get(self, "audit_mode")

    @audit_mode.setter
    def audit_mode(self, value: Optional[pulumi.Input['WorkloadConfigAuditMode']]):
        pulumi.set(self, "audit_mode", value)


@pulumi.input_type
class WorkloadIdentityConfigArgs:
    def __init__(__self__, *,
                 identity_namespace: Optional[pulumi.Input[str]] = None,
                 identity_provider: Optional[pulumi.Input[str]] = None,
                 workload_pool: Optional[pulumi.Input[str]] = None):
        """
        Configuration for the use of Kubernetes Service Accounts in GCP IAM policies.
        :param pulumi.Input[str] identity_namespace: IAM Identity Namespace to attach all Kubernetes Service Accounts to.
        :param pulumi.Input[str] identity_provider: identity provider is the third party identity provider.
        :param pulumi.Input[str] workload_pool: The workload pool to attach all Kubernetes service accounts to.
        """
        if identity_namespace is not None:
            pulumi.set(__self__, "identity_namespace", identity_namespace)
        if identity_provider is not None:
            pulumi.set(__self__, "identity_provider", identity_provider)
        if workload_pool is not None:
            pulumi.set(__self__, "workload_pool", workload_pool)

    @property
    @pulumi.getter(name="identityNamespace")
    def identity_namespace(self) -> Optional[pulumi.Input[str]]:
        """
        IAM Identity Namespace to attach all Kubernetes Service Accounts to.
        """
        return pulumi.get(self, "identity_namespace")

    @identity_namespace.setter
    def identity_namespace(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "identity_namespace", value)

    @property
    @pulumi.getter(name="identityProvider")
    def identity_provider(self) -> Optional[pulumi.Input[str]]:
        """
        identity provider is the third party identity provider.
        """
        return pulumi.get(self, "identity_provider")

    @identity_provider.setter
    def identity_provider(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "identity_provider", value)

    @property
    @pulumi.getter(name="workloadPool")
    def workload_pool(self) -> Optional[pulumi.Input[str]]:
        """
        The workload pool to attach all Kubernetes service accounts to.
        """
        return pulumi.get(self, "workload_pool")

    @workload_pool.setter
    def workload_pool(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "workload_pool", value)


@pulumi.input_type
class WorkloadMetadataConfigArgs:
    def __init__(__self__, *,
                 mode: Optional[pulumi.Input['WorkloadMetadataConfigMode']] = None,
                 node_metadata: Optional[pulumi.Input['WorkloadMetadataConfigNodeMetadata']] = None):
        """
        WorkloadMetadataConfig defines the metadata configuration to expose to workloads on the node pool.
        :param pulumi.Input['WorkloadMetadataConfigMode'] mode: Mode is the configuration for how to expose metadata to workloads running on the node pool.
        :param pulumi.Input['WorkloadMetadataConfigNodeMetadata'] node_metadata: NodeMetadata is the configuration for how to expose metadata to the workloads running on the node.
        """
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if node_metadata is not None:
            pulumi.set(__self__, "node_metadata", node_metadata)

    @property
    @pulumi.getter
    def mode(self) -> Optional[pulumi.Input['WorkloadMetadataConfigMode']]:
        """
        Mode is the configuration for how to expose metadata to workloads running on the node pool.
        """
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: Optional[pulumi.Input['WorkloadMetadataConfigMode']]):
        pulumi.set(self, "mode", value)

    @property
    @pulumi.getter(name="nodeMetadata")
    def node_metadata(self) -> Optional[pulumi.Input['WorkloadMetadataConfigNodeMetadata']]:
        """
        NodeMetadata is the configuration for how to expose metadata to the workloads running on the node.
        """
        return pulumi.get(self, "node_metadata")

    @node_metadata.setter
    def node_metadata(self, value: Optional[pulumi.Input['WorkloadMetadataConfigNodeMetadata']]):
        pulumi.set(self, "node_metadata", value)


