`ComputeClass` is a Kubernetes Custom Resource Definition (CRD) that lets you
define configurations and fallback priorities for Google Kubernetes Engine (GKE) node scaling
decisions. To learn more, see
[About custom ComputeClasses](https://docs.cloud.google.com/kubernetes-engine/docs/concepts/about-custom-compute-classes.md.txt).

> [!NOTE]
> **Note:** The following snippet is intended only as an illustration of `ComputeClass` syntax and structure. It is not a working example.

```yaml
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: my-class
spec:
  activeMigration:
    ensureAllDaemonSetPodsRunning: false
    optimizeRulePriority: false
  allocationStrategyDefaults:
    flexStart: lowest-cost
    onDemand: lowest-cost
    spot: lowest-cost
  autoscalingPolicy:
    consolidationDelayMinutes: 1
    consolidationThreshold: 0
    gpuConsolidationThreshold: 0
  buffers:
  - provisioningStrategy: buffer.x-k8s.io/active-capacity
    limits:
      cpu: "4"
      memory: 6Gi
  description: "Short description of the ComputeClass."
  nodePoolAutoCreation:
    enabled: false
    shieldedInstanceConfig:
      enableSecureBoot: true
      enableIntegrityMonitoring: true
  nodePoolConfig:
    dra:
      networking:
        enabled: true
    imageType: ubuntu_containerd
    ipType: public
    serviceAccount: example-service-account@example-project.iam.gserviceaccount.com
    autoRepair: true
    autoUpgrade: true
    nodeLabels:
      example-label-key: example-label-value
    confidentialNodeType: SEV
    taintConfig:
      architectureTaintBehavior: ARM
    taints:
    - effect: NoSchedule
      key: example-key
      value: example-value
    imageStreaming:
      enabled: true
    gvnic:
      enabled: true
    resourceManagerTags:
    - key: example-project/example-tag-key
      value: example-tag-value
    loggingConfig:
      loggingVariantConfig:
        variant: DEFAULT
    sandbox:
      type: gvisor
    workloadMetadata: GKE_METADATA
  priorityDefaults:
    nodeSystemConfig:
      linuxNodeConfig:
        sysctls:
          net.core.somaxconn: 256
        transparentHugepageEnabled: TRANSPARENT_HUGEPAGE_ENABLED_ALWAYS
      kubeletConfig:
        cpuCfsQuota: true
        crashLoopBackOff:
          maxContainerRestartPeriod: '30s'
    location:
      zones: ['us-central1-a', 'us-central1-b']
    enableNestedVirtualization: true
  priorities:
  - machineFamily: n4
    maxRunDurationSeconds: 360
    minCores: 16
    minCpuPlatform: "Intel Emerald Rapids"
    minMemoryGb: 64
    placement:
      policyName: my-resource-policy
    reservations:
      affinity: Specific
      specific:
      - name: n4-shared-reservation
        project: reservation-project
        zones: ['us-central1-a']
        reservationBlock:
          name: reservation-block-name
          reservationSubBlock:
            name: reservation-sub-block-name
    spot: true
    storage:
      bootDiskSize: 100
      bootDiskKMSKey: projects/example/locations/us-central1/keyRings/example/cryptoKeys/key-1
      secondaryBootDisks:
      - diskImageName: pytorch-mnist
        project: k8s-staging-jobset
        mode: CONTAINER_IMAGE_CACHE
    nodeSystemConfig:
      linuxNodeConfig:
        sysctls:
          net.core.somaxconn: 512
    enableNestedVirtualization: true
  - machineType: n4-standard-32
    nodeLabels:
      example-priority-label-key: example-priority-label-value
    location:
      zones: ['us-central1-c']
      locationPolicy: ANY
    spot: true
    reservations:
      affinity: AnyBestEffort
    storage:
      bootDiskSize: 100
      bootDiskType: hyperdisk-balanced
      localSSDCount: 1
    taints:
    - effect: NoSchedule
      key: example-priority-key
      value: example-priority-value
    nodeSystemConfig:
      linuxNodeConfig:
        swapConfig:
          enabled: true
          bootDiskProfile:
            swapSizeGib: 10
  - machineType: n4-standard-32
    location:
      zoneTypes: ['STANDARD', 'AI']
  - nodepools: ['example-first-nodepool-name', 'example-second-nodepool-name']
  - podFamily:
      general-purpose
      general-purpose-arm
  - gpu:
      count: 1
      driverVersion: default
      type: nvidia-l4
      gpuSharing:
        sharingStrategy: MPS
        maxSharedClientsPerGPU: 2
  - tpu:
      count: 8
      topology: "2x4"
      type: tpu-v5-lite-podslice
  - flexStart:
      enabled: true
      nodeRecycling:
        leadTimeSeconds: 1200
  - capacityCheckWaitTimeSeconds: 3600
  - acceleratorNetworkProfile: auto
  - allocationStrategy: lowest-cost
  whenUnsatisfiable: ScaleUpAnyway
status:
  conditions:
  - lastTransitionTime: 2024-10-10T00:00:00Z
    message: example-message
    observedGeneration: 1
    reason: example-reason
    status: "True"
    type: example-type
  observedBuffers:
  - name: example-buffer-name
    namespace: gke-managed-ccc
    conditions:
    - lastTransitionTime: 2024-10-10T00:00:00Z
      message: example-message
      observedGeneration: 1
      reason: example-reason
      status: "True"
      type: example-type
```

## ComputeClass specification

```yaml
metadata:
  name: string
spec:
  activeMigration: object(activeMigration)
  allocationStrategyDefaults: object(allocationStrategyDefaults)
  autoscalingPolicy: object(autoscalingPolicy)
  buffers: [
    object(buffers)
  ]
  minimumCapacity: object(minimumCapacity)
  nodePoolAutoCreation: object(nodePoolAutoCreation)
  nodePoolGroup: object(nodePoolGroup)
  nodePoolConfig: object(nodePoolConfig)
  autopilot: object(autopilot)
  priorities: [
    object(priorities)
  ]
  priorityDefaults: object(priorityDefaults)
  whenUnsatisfiable: string
```

| Fields ||
|---|---|
| `metadata` *required* | `object` A field that identifies the ComputeClass. |
| `metadata.name` *optional* | `string` The name of the ComputeClass. |
| `spec` *required* | `object` The ComputeClass specification, which defines how the ComputeClass works. |
| `spec.activeMigration` *optional* | `object (activeMigration)` A specification that lets you choose whether GKE automatically replaces existing nodes that are lower in a ComputeClass priority list with new nodes that are higher in that priority list, or replaces existing nodes that have unschedulable DaemonSet Pods. |
| `spec.allocationStrategyDefaults` *optional* | `object (allocationStrategyDefaults)` *Requires GKE version 1.36.4-gke.1082000 or later, or 1.35.8-gke.1439000 or later* A specification that defines the default allocation strategies used for node pool selection across different provisioning models. The specified strategies apply to priorities using the corresponding provisioning model (Spot when `spot: true`, [flex-start](https://docs.cloud.google.com/kubernetes-engine/docs/concepts/dws.md.txt) when `flexStart.enabled: true`, and on-demand otherwise) when the `allocationStrategy` field is omitted from that priority rule. If not specified in a priority rule or in `allocationStrategyDefaults`, the default strategy is `lowest-cost`, which selects the node pool option with the lowest infrastructure cost based on `us-central1` list prices when scaling up, taking into account potential future scale-ups rather than only immediate cost. |
| `spec.autoscalingPolicy` *optional* | `object (autoscalingPolicy)` A specification that lets you fine-tune the timing and thresholds that cause GKE to remove underused nodes and consolidate workloads on other nodes. |
| `spec.buffers` *optional* | ` []object (buffers) ` *Requires GKE version 1.37.1-gke.3020000 or later* A list of capacity buffers that GKE creates and manages in the `gke-managed-ccc` namespace for this ComputeClass. You can specify at most one buffer for each provisioning strategy. If you omit this field, then the ComputeClass has no capacity buffers. For instructions, see [Configure capacity buffers in custom ComputeClasses](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/configure-capacity-buffers-compute-classes.md.txt). |
| `spec.minimumCapacity` *optional* | `object (minimumCapacity)` *Requires GKE version 1.36.3-gke.1253000 or later* A specification that lets you provision a declarative minimum number of nodes for the entire ComputeClass. |
| `spec.nodePoolAutoCreation` *optional* | `object(nodePoolAutoCreation)` A specification that lets you choose whether GKE can create and delete node pools in Standard mode clusters based on the ComputeClass priority rules. In GKE versions earlier than 1.33.3-gke.1136000, this specification requires [cluster-level node auto-provisioning](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/node-auto-provisioning.md.txt#enable-cluster-level) to be enabled on the cluster. |
| `spec.nodePoolGroup` *optional* | ` object(nodePoolGroup) ` *Requires GKE version 1.32.2-gke.1359000 or later* A specification that lets you group multiple node pools into a single logical unit called a *collection*. This grouping lets you apply shared configurations, such as a Service Level Objective (SLO), across all node pools within the collection. |
| `spec.nodePoolConfig` *optional* | `object(nodePoolConfig)` *Requires GKE version 1.31.4-gke.1072000 or later* A specification that lets you configure certain parameters of node pools that are used by the ComputeClass. For auto-provisioned node pools, these settings are automatically applied to newly created node pools and their nodes. Existing node pools are used only when their settings match this field. |
| `spec.autopilot` *optional* | `object(autopilot)` *Requires GKE version 1.34.1-gke.1829001 or later* Autopilot describes the autopilot settings for a given ComputeClass. Indicates whether nodes created for this compute class should be Autopilot managed. |
| `spec.priorities[]` *required* | `object (priorities)` *Requires GKE version 1.30.3-gke.1451000 or later* A list of priority rules that defines how GKE configures nodes during scaling operations. When a cluster needs to scale up, GKE tries to create nodes that match the first priority rule in this field. If GKE can't create those nodes, it attempts the next rule. The process repeats until GKE successfully creates nodes or exhausts all of the rules in the list. |
| `priorityDefaults` *optional* | `object (priorityDefaults)` *Requires GKE version 1.32.1-gke.1729000 or later* A specification that sets default values for specific fields that are omitted in entries in the `spec.priorities[]` field. The default values that you specify in the `priorityDefaults` field apply only if the corresponding field isn't set in a specific priority rule. The values in the `priorityDefaults` field don't apply to `spec.priorities.nodepools[]` fields. |
| `spec.whenUnsatisfiable` *optional* | `string` A specification that lets you define what GKE does if none of the rules in the `spec.priorities[]` field can be met. Supported values are as follows: - `ScaleUpAnyway`: create a new node that uses the default cluster node configuration. In GKE versions earlier than 1.33, this is the default behavior. - `DoNotScaleUp`: leave the Pod in the `Pending` status until GKE can create a node that meets the criteria a priority rule. In GKE version 1.33 and later, this is the default behavior. |

### `activeMigration`

Choose whether GKE migrates workloads to higher priority nodes for
the ComputeClass as resources become available, or replaces nodes that have
unschedulable DaemonSet Pods. For details, see
[Active migration](https://docs.cloud.google.com/kubernetes-engine/docs/concepts/about-custom-compute-classes.md.txt#active-migration).

```yaml
activeMigration:
  ensureAllDaemonSetPodsRunning: boolean
  optimizeRulePriority: boolean
```

| Fields ||
|---|---|
| `ensureAllDaemonSetPodsRunning` *optional* | `boolean` Choose whether GKE drains and replaces existing nodes that have unschedulable DaemonSet Pods so that all required DaemonSet Pods can be scheduled. In Standard clusters, if you omit this field, the default value is `false` unless `spec.autopilot.enabled` is `true`, in which case the default value is `true`. In Autopilot clusters, this behavior is always enabled and this field is ignored. |
| `optimizeRulePriority` *required* | `boolean` Choose whether GKE migrates workloads to higher priority nodes when resources are available. If you omit this field, the default value is `false`. |

### `allocationStrategyDefaults`

Defines the default allocation strategies used for node pool selection across different provisioning models.
The supported strategy is `lowest-cost`, which directs GKE to select the node pool option with the lowest infrastructure cost based on `us-central1` list prices when scaling up, taking into account potential future scale-ups rather than only immediate cost.
The specified strategies apply to priorities that use the corresponding provisioning model:

- `spot`: applies to priorities where `spot: true`.
- `flexStart`: applies to priorities where `flexStart.enabled: true`.
- `onDemand`: applies to all other priorities.

These default values apply to a priority rule only if the `allocationStrategy` field is omitted from that rule. If an allocation strategy is not specified in the priority rule or in `allocationStrategyDefaults`, the default strategy is `lowest-cost`.

```yaml
allocationStrategyDefaults:
  flexStart: string
  onDemand: string
  spot: string
```

| Fields ||
|---|---|
| `flexStart` *optional* | `string` *Requires GKE version 1.36.4-gke.1082000 or later, or 1.35.8-gke.1439000 or later* The default allocation strategy for node pool selection for priorities using the [flex-start](https://docs.cloud.google.com/kubernetes-engine/docs/concepts/dws.md.txt) provisioning model (priorities where `flexStart.enabled` is `true`). The supported value is `lowest-cost`, which selects the node pool option with the lowest infrastructure cost based on `us-central1` list prices when scaling up, taking into account potential future scale-ups rather than only immediate cost. If unspecified, the default strategy is `lowest-cost`. |
| `onDemand` *optional* | `string` *Requires GKE version 1.36.4-gke.1082000 or later, or 1.35.8-gke.1439000 or later* The default allocation strategy for node pool selection for on-demand priorities (priorities that don't specify `spot: true` or `flexStart.enabled: true`). The supported value is `lowest-cost`, which selects the node pool option with the lowest infrastructure cost based on `us-central1` list prices when scaling up, taking into account potential future scale-ups rather than only immediate cost. If unspecified, the default strategy is `lowest-cost`. |
| `spot` *optional* | `string` *Requires GKE version 1.36.4-gke.1082000 or later, or 1.35.8-gke.1439000 or later* The default allocation strategy for node pool selection for priorities using the [Spot VMs](https://docs.cloud.google.com/kubernetes-engine/docs/concepts/spot-vms.md.txt) provisioning model (priorities where `spot` is `true`). The supported value is `lowest-cost`, which selects the node pool option with the lowest infrastructure cost based on `us-central1` list prices when scaling up, taking into account potential future scale-ups rather than only immediate cost. If unspecified, the default strategy is `lowest-cost`. |

### `autoscalingPolicy`

```yaml
autoscalingPolicy:
  consolidationDelayMinutes: integer
  consolidationThreshold: integer
  gpuConsolidationThreshold: integer
```

| Fields ||
|---|---|
| `consolidationDelayMinutes` *optional* | `integer` The number of minutes after which GKE removes underutilized nodes. The value must be between `1` and `1440`. |
| `consolidationThreshold` *optional* | `integer` The CPU and memory utilization threshold as a percentage of the total resources on the node. A node becomes eligible for removal only when the resource utilization is less than this threshold. The value must be between `0` and `100`. |
| `gpuConsolidationThreshold` *optional* | `integer` The GPU utilization threshold as a percentage of the total GPU resources on the node. A node becomes eligible for removal only when the resource utilization is less than this threshold. The value must be between `0` and `100`. Consider setting this value to either `0` or `100` so that GKE consolidates nodes that don't use 100% of the attached GPUs. |

### `buffers`

Configure capacity buffers that GKE creates and manages in the
`gke-managed-ccc` namespace for this ComputeClass. For instructions, see
[Configure capacity buffers in custom ComputeClasses](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/configure-capacity-buffers-compute-classes.md.txt).

```yaml
buffers:
- provisioningStrategy: string
  limits:
    cpu: string
    memory: string
```

| Fields ||
|---|---|
| `spec.buffers[].provisioningStrategy` *optional* | `string` *Requires GKE version 1.37.1-gke.3020000 or later* The buffer provisioning strategy. If you omit this field, then GKE uses the `"buffer.x-k8s.io/active-capacity"` strategy. Supported values are as follows: - `"buffer.x-k8s.io/active-capacity"`: provisions an active buffer with running nodes. - `"buffer.gke.io/standby-capacity"`: provisions a standby buffer with suspended nodes. |
| `spec.buffers[].limits` *required* | `map (string: quantity)` *Requires GKE version 1.37.1-gke.3020000 or later* The maximum total CPU and memory for the buffer, specified with the `cpu` and `memory` keys (for example, `cpu: "4"` and `memory: 6Gi`). You can set the `cpu` key, the `memory` key, or both. GKE divides the buffer into units of 2 vCPUs and 2 GiB of memory and provisions as many units as fit within all of the limits that you set. If you set a value that's less than one unit (`"2"` for the `cpu` key or `2Gi` for the `memory` key), then the buffer is empty. |

### `flexStart`

```yaml
flexStart:
  enabled: boolean
  nodeRecycling: object(nodeRecycling)
```

| Fields ||
|---|---|
| `enabled` *required* | `boolean` Whether to use [flex-start](https://docs.cloud.google.com/kubernetes-engine/docs/concepts/dws.md.txt) provisioning mode. |
| `NodeRecycling` *optional* | `object(nodeRecycling)` The [node recycling](https://docs.cloud.google.com/kubernetes-engine/docs/concepts/dws.md.txt#node-recycling) configurations. |

### `gpu`

```yaml
gpu:
  count: integer
  driverVersion: string
  type: string
  topology: string
  gpuSharing: object(gpuSharing)
```

| Fields ||
|---|---|
| `count` *required* | `integer` The number of GPUs to attach to each node. The value must be at least `1`. |
| `driverVersion` *optional* | `string` *Requires GKE version 1.31.1-gke.1858000 or later* The NVIDIA driver version to install. The supported values are as follows: - `default`: install the default driver version for the node GKE version. If you omit this field, this is the default value. - `latest`: install the latest driver version for the node GKE version. - `autoinstall-disabled`: don't install the drivers. *Requires GKE version 1.36.2-gke.2064000 or later.* |
| `gpu.type` *required* | `string` The GPU type to attach to each node, such as `nvidia-l4`. |
| `topology` *optional* | `string` The physical arrangement of GPU chips within a slice. |
| `gpuSharing` *optional* | `object (gpuSharing)` *Requires GKE version 1.35.2-gke.1485000 or later* The GPU sharing configuration. |

### `gpuSharing`

```yaml
gpuSharing:
  sharingStrategy: string
  maxSharedClientsPerGPU: integer
  gpuPartitionSize: string
```

| Fields ||
|---|---|
| `sharingStrategy` *optional* | `string` *Requires GKE version 1.35.2-gke.1485000 or later* The type of GPU sharing strategy to enable on the GPU node. Supported values are the following: - `TIME_SHARING`: GPUs are time-shared between containers. - `MPS`: GPUs are shared between containers with NVIDIA MPS. |
| `maxSharedClientsPerGPU` *optional* | `integer` *Requires GKE version 1.35.2-gke.1485000 or later* The maximum number of containers that can share a physical GPU. Valid values are between 2 and 48. This field must be specified when enabling a sharing strategy. |
| `gpuPartitionSize` *optional* | `string` *Requires GKE version 1.35.2-gke.1485000 or later* Size of partitions to create on the GPU. This field sets up multi-instance GPUs, and it's compatible with both of the sharing strategies. If omitted, the GPU is not partitioned by default. The partition size must be supported by the selected GPU model. For supported partition sizes, see [Multi-instance GPU partitions](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/gpus-multi.md.txt#multi-instance_gpu_partitions). Example: `1g.5gb`. |

### `diskIoScheduler`

```yaml
diskIoScheduler:
  nodeSystemIoScheduler: string
  nodeAttachedDiskIoScheduler: string
```

| Fields ||
|---|---|
| `nodeSystemIoScheduler` *optional* | `string` *Requires GKE version 1.36.2-gke.1368000 or later* Configures the IO scheduler for the boot disk or ephemeral local SSD that runs node system workloads. The following values are supported: `mq-deadline`, `bfq`, `kyber`, `none`. |
| `nodeAttachedDiskIoScheduler` *optional* | `string` *Requires GKE version 1.36.2-gke.1368000 or later* Configures the IO scheduler for the attached disks. The following values are supported: `mq-deadline`, `bfq`, `kyber`, `none`. |

### `hugepageConfig`

```yaml
hugepageConfig:
  hugepage_size1g: integer
  hugepage_size2m: integer
```

| Fields ||
|---|---|
| `hugepage_size1g` *optional* | `integer` The number of 1 GB huge pages to allocate. Huge pages are a memory management feature that can improve performance for memory-intensive applications. By using huge pages, the system can reduce the overhead associated with Translation Lookaside Buffer (TLB) misses. Allocating 1 GB huge pages is beneficial for workloads that require large, contiguous memory allocations, such as large databases or in-memory computing. If you specify this field, the value must be at least is `1`. For limitations and requirements, see [Linux huge page configuration options](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/node-system-config.md.txt#huge-page-options). |
| `hugepage_size2m` *optional* | `integer` Number of 2 MB huge pages to allocate. Similar to 1 GB huge pages, 2 MB huge pages can also improve performance by reducing TLB misses. However, 2 MB huge pages are suitable for applications with smaller large memory requirements. They provide a balance between performance improvement and memory flexibility. If you specify this field, the value must be at least `1`. For limitations and requirements, see [Linux huge page configuration options](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/node-system-config.md.txt#huge-page-options). |

### `imageStreaming`

```yaml
imageStreaming:
  enabled: boolean
```

| Fields ||
|---|---|
| `enabled` *required* | `boolean` Specifies whether to use image streaming to pull container images. |

### `gvnic`

```yaml
gvnic:
  enabled: boolean
```

| Fields ||
|---|---|
| `enabled` *required* | `boolean` Specifies whether Google Virtual NIC (gVNIC) is enabled on the node pool. |

### `instanceMetadata`

```yaml
instanceMetadata: {
    KEY: VALUE,
    ...
}
```

| Fields ||
|---|---|
| `KEY` *optional* | `string` The custom metadata key name. Keys must be fewer than 128 characters long and can contain only alphanumeric characters, hyphens (`-`), and underscores (`_`). A maximum of 32 custom key-value pairs can be specified across `nodePoolConfig` and `priorities[]`. You cannot specify reserved GKE and Compute Engine system metadata keys (such as `kube-env`, `user-data`, `startup-script`, and `cluster-name`). |
| `VALUE` *optional* | `string` The custom metadata value associated with the key. The maximum size per value is 32 KB (32,768 bytes). The total combined size of all custom metadata key-value pairs applied to a VM instance cannot exceed 512 KB (524,288 bytes). |

### `kubeletConfig`

```yaml
kubeletConfig:
  cpuCfsQuota: boolean
  cpuCfsQuotaPeriod: string
  cpuManagerPolicy: string
  podPidsLimit: integer
  containerLogMaxSize: string
  containerLogMaxFiles: integer
  containerLogMonitorInterval: string
  containerLogMaxWorkers: integer
  imageGcLowThresholdPercent: integer
  imageGcHighThresholdPercent: integer
  imageMinimumGcAge: string
  imageMaximumGcAge: string
  allowedUnsafeSysctls: []string
  evictionMaxPodGracePeriodSeconds: integer
  evictionMinimumReclaim: object(evictionMinimumReclaim)
  evictionSoft: object(evictionSoft)
  evictionSoftGracePeriod: object(evictionSoftGracePeriod)
  maxParallelImagePulls: integer
  singleProcessOOMKill: boolean
  crashLoopBackOff: object(crashLoopBackOff)
  memoryManager: object(memoryManager)
  topologyManager: object(topologyManager)
  shutdownGracePeriodSeconds: integer
  shutdownGracePeriodCriticalPodsSeconds: integer
  reservedResourcesConfig: object(reservedResourcesConfig)
```

| Fields ||
|---|---|
| `cpuCfsQuota` *optional* | `boolean` Enables CPU Completely Fair Scheduler (CFS) quota enforcement for containers that specify CPU limits. The following values are supported: - `true`: enable CPU CFS quota enforcement. The kubelet uses the kernel CFS quota mechanism to enforce Pod CPU limits. Pods might move to different CPU cores depending on CPU throttling and core availability. - `false`: disable CPU CFS quota enforcement. Pod CPU limits are ignored, which might be useful if Pods are sensitive to CPU limits. However, disabling CPU CFS quota enforcement increases the risk of a Pod consuming more CPU resources than intended. The default value is `true`. |
| `cpuCfsQuotaPeriod` *optional* | `string` Sets the value, in microseconds, of the [CFS quota period](https://www.kernel.org/doc/html/v5.9/scheduler/sched-bwc.html#management). This period defines how often the kernel reallocates CPU resources to each control group (cgroup). You can use this value to tune CPU throttling behavior. The value must be between `1ms` and `1s`. The default value is `100ms`. |
| `cpuManagerPolicy` *optional* | `string` Controls the kubelet CPU management policy. Some Pods are more sensitive to CPU limits. In these Pods, the latency of CPU reassignment during CFS quota enforcement might impact performance. The kubelet CPU Manager feature provides exclusive CPU access to specific Pods. The kubelet doesn't enforce CPU limits for those Pods even if CPU CFS quota enforcement is enabled. The following values are supported: - `none`: disables the CPU Manager feature. The kubelet assigns CPUs to Pods based on the CFS quota settings. - `static`: provides containers that meet all of the following criteria with access to exclusive CPUs on the node: - The Pod has the `Guaranteed` Quality-of-Service (QoS) class. - The container has integer values in the `requests.cpu` field. The default value is `none`. For more information, see the Kubernetes documentation about [policies for assigning CPUs to Pods](https://kubernetes.io/docs/concepts/policy/node-resource-managers/#policies-for-assigning-cpus-to-pods). |
| `evictionMaxPodGracePeriodSeconds` *optional* | `integer` The maximum allowed grace period (in seconds) to use when terminating pods in response to a soft eviction threshold being met. The value must be between 0 and 300. |
| `evictionMinimumReclaim` *optional* | `object (evictionMinimumReclaim)` Defines minimum reclaims. |
| `evictionSoft` *optional* | `object (evictionSoft)` Defines soft eviction thresholds. |
| `evictionSoftGracePeriod` *optional* | `object (evictionSoftGracePeriod)` Defines grace periods for soft eviction thresholds. |
| `podPidsLimit` *optional* | `integer` Sets the maximum number of process IDs (PIDs) that each Pod can use. This setting controls the maximum number of processes and threads that can run simultaneously in a Pod. The value must be between `1024` and `4194304`. The default value is `4096`. |
| `containerLogMaxSize` *optional* | `string` *Requires GKE version 1.33.4-gke.1036000 or later* Defines the maximum size of the container log file before it is rotated. Specified as a positive number and a unit suffix, such as `100Ki`, `10Mi`. Valid units are `Ki`, `Mi`, and `Gi`. The value must be between `10Mi` and `500Mi`, inclusive. The total container log size (`containerLogMaxSize` \* `containerLogMaxFiles`) cannot exceed `1%` of the total storage of the node. The default value is `10Mi`. |
| `containerLogMaxFiles` *optional* | `integer` *Requires GKE version 1.33.4-gke.1036000 or later* Defines the maximum number of container log files that can be present for a container. The integer must be between `2` and `10`, inclusive. The default value is `5`. |
| `containerLogMonitorInterval` *optional* | `string` *Requires GKE version 1.37.2-gke.1159000 or later* Specifies the interval at which container logs are monitored for performing the log rotation operation. The value must be a positive duration between `3s` and `300s`, inclusive. The duration must be in seconds with the `s` suffix (for example, `10s` or `60s`). The default value is `10s`. |
| `containerLogMaxWorkers` *optional* | `integer` *Requires GKE version 1.37.2-gke.1159000 or later* Defines the maximum number of concurrent workers to rotate container log files. The integer must be between `1` and `10`, inclusive. The default value is `1`. |
| `imageGcLowThresholdPercent` *optional* | `integer` *Requires GKE version 1.33.4-gke.1036000 or later* Defines the percentage of disk usage before which image garbage collection is never run. Lowest disk usage to garbage collect to. The percentage is calculated by dividing this field value by 100. The integer must be between `10` and `85`, inclusive, and lower than `imageGcHighThresholdPercent`. The default value is `80`. |
| `imageGcHighThresholdPercent` *optional* | `integer` *Requires GKE version 1.33.4-gke.1036000 or later* Defines the percentage of disk usage after which image garbage collection is always run. The percentage is calculated by dividing this field value by 100. The integer must be between `10` and `85`, inclusive, and higher than `imageGcLowThresholdPercent`. The default value is `85`. |
| `imageMinimumGcAge` *optional* | `integer` *Requires GKE version 1.33.4-gke.1036000 or later* Defines the minimum age for an unused image before it is garbage collected. Specified as a sequence of decimal numbers, each with an optional fraction and a unit suffix, such as `300s`, `1.5m`. Valid time units are `ns`, `us` (or `µs`), `ms`, `s`, `m`, and `h`. The value cannot be greater than `2m`. The default value is `2m`. |
| `imageMaximumGcAge` *optional* | `integer` *Requires GKE version 1.33.4-gke.1036000 or later* Defines the maximum age an image can be unused before it is garbage collected. Specified as a sequence of decimal numbers, each with an optional fraction and a unit suffix, such as `300s`, `1.5m`, and `2h45m`. Valid time units are `ns`, `us` (or `µs`), `ms`, `s`, `m`, and `h`. The value must be a positive duration. The default value is `none`. |
| `allowedUnsafeSysctls` *optional* | `[]string` *Requires GKE version 1.33.4-gke.1036000 or later* Defines a comma-separated allowlist of unsafe sysctls or sysctl patterns which can be set on the Pods. The allowed sysctl groups are `kernel.shm*`, `kernel.msg*`, `kernel.sem`, `fs.mqueue.*`, and `net.*`. |
| `maxParallelImagePulls` *optional* | `integer` *Requires GKE version 1.34.1-gke.3084001 or later* This setting sets the maximum number of image pulls in parallel. The integer must be between `2` and `5`, inclusive. Default is `2` or `3`, depending on boot disk type. |
| `singleProcessOOMKill` *optional* | `boolean` *Requires GKE version 1.34.1-gke.3084001 or later* This setting enables single process OOM killer. The following values are supported: - `true`: the processes in a container are OOM killed individually instead of as a group. - `false`: the OOM Killer stops the entire cgroup where the OOMed process exists. The default value is `true` for cgroupv1 nodes, `false` for cgroupv2 nodes. |
| `crashLoopBackOff` *optional* | `object (crashLoopBackOff)` Contains the configuration to modify node level parameters for container restart behavior. |
| `memoryManager` *optional* | `object (memoryManager)` *Requires GKE version 1.36.2-gke.1368000 or later* The configuration for the kubelet Memory Manager. |
| `topologyManager` *optional* | `object (topologyManager)` *Requires GKE version 1.36.2-gke.1368000 or later* The configuration for the kubelet Topology Manager. |
| `shutdownGracePeriodSeconds` *optional* | `integer` *Requires GKE control plane version 1.36.0-gke.3204000 or later* Specifies the total duration in seconds that the node delays shutting down to gracefully terminate Pods. Allowed values are `0`, `30`, or `120`. The default value is `30`. For more information, see [Termination and graceful shutdown of Spot VMs](https://docs.cloud.google.com/kubernetes-engine/docs/concepts/spot-vms.md.txt#termination-graceful-shutdown). |
| `shutdownGracePeriodCriticalPodsSeconds` *optional* | `integer` *Requires GKE control plane version 1.36.0-gke.3204000 or later* Specifies the duration in seconds used to terminate critical Pods during a node shutdown. The value must be an integer between `0` and `120` (inclusive), and must be less than or equal to `shutdownGracePeriodSeconds`. This field is valid only if `shutdownGracePeriodSeconds` is also set. The default value is `15`. For more information, see [Termination and graceful shutdown of Spot VMs](https://docs.cloud.google.com/kubernetes-engine/docs/concepts/spot-vms.md.txt#termination-graceful-shutdown). |
| `reservedResourcesConfig` *optional* | `object (reservedResourcesConfig)` *Requires GKE version 1.37 or later* The configuration for the reserved resources on the node. |

### `evictionMinimumReclaim`

```yaml
evictionMinimumReclaim:
  imagefsAvailable: string
  imagefsInodesFree: string
  memoryAvailable: string
  nodefsAvailable: string
  nodefsInodesFree: string
  pidAvailable: string
```

| Fields ||
|---|---|
| `imagefsAvailable` *optional* | `string` The minimum reclaim for `imagefs.available`. The value must be a percentage, such as "5%". The value must be between 0% and 10%. |
| `imagefsInodesFree` *optional* | `string` The minimum reclaim for `imagefs.inodesFree`. The value must be a percentage, such as "5%". The value must be between 0% and 10%. |
| `memoryAvailable` *optional* | `string` The minimum reclaim for `memory.available`. The value must be a percentage, such as "5%". The value must be between 0% and 10%. |
| `nodefsAvailable` *optional* | `string` The minimum reclaim for `nodefs.available`. The value must be a percentage, such as "5%". The value must be between 0% and 10%. |
| `nodefsInodesFree` *optional* | `string` The minimum reclaim for `nodefs.inodesFree`. The value must be a percentage, such as "5%". The value must be between 0% and 10%. |
| `pidAvailable` *optional* | `string` The minimum reclaim for `pid.available`. The value must be a percentage, such as "5%". The value must be between 0% and 10%. |

### `evictionSoft`

```yaml
evictionSoft:
  imagefsAvailable: string
  imagefsInodesFree: string
  memoryAvailable: string
  nodefsAvailable: string
  nodefsInodesFree: string
  pidAvailable: string
```

| Fields ||
|---|---|
| `imagefsAvailable` *optional* | `string` The soft eviction threshold for `imagefs.available`. The value must be a percentage, such as "10%". The value must be between 15% and 50% inclusive. If you specify this field, you must also specify `evictionSoftGracePeriod.imagefsAvailable`. |
| `imagefsInodesFree` *optional* | `string` The soft eviction threshold for `imagefs.inodesFree`. The value must be a percentage, such as "5%". The value must be between 5% and 50% inclusive. If you specify this field, you must also specify `evictionSoftGracePeriod.imagefsInodesFree`. |
| `memoryAvailable` *optional* | `string` The soft eviction threshold for `memory.available`. The value must be a quantity, such as "100Mi". The value must be at least the GKE default hard eviction threshold of 100 Mi and less than 50% of machine memory. If you specify this field, you must also specify `evictionSoftGracePeriod.memoryAvailable`. |
| `nodefsAvailable` *optional* | `string` The soft eviction threshold for `nodefs.available`. The value must be a percentage, such as "20%". The value must be between 10% and 50% inclusive. If you specify this field, you must also specify `evictionSoftGracePeriod.nodefsAvailable`. |
| `nodefsInodesFree` *optional* | `string` The soft eviction threshold for `nodefs.inodesFree`. The value must be a percentage, such as "5%". The value must be between 5% and 50% inclusive. If you specify this field, you must also specify `evictionSoftGracePeriod.nodefsInodesFree`. |
| `pidAvailable` *optional* | `string` The soft eviction threshold for `pid.available`. The value must be a percentage, such as "10%". The value must be between 10% and 50% inclusive. If you specify this field, you must also specify `evictionSoftGracePeriod.pidAvailable`. |

### `evictionSoftGracePeriod`

```yaml
evictionSoftGracePeriod:
  imagefsAvailable: string
  imagefsInodesFree: string
  memoryAvailable: string
  nodefsAvailable: string
  nodefsInodesFree: string
  pidAvailable: string
```

| Fields ||
|---|---|
| `imagefsAvailable` *optional* | `string` The grace period for the `imagefs.available` soft eviction threshold. The value must be a duration string, such as "30s" or "1m30s". The value must be positive and less than or equal to "5m". |
| `imagefsInodesFree` *optional* | `string` The grace period for the `imagefs.inodesFree` soft eviction threshold. The value must be a duration string, such as "30s" or "1m30s". The value must be positive and less than or equal to "5m". |
| `memoryAvailable` *optional* | `string` The grace period for the `memory.available` soft eviction threshold. The value must be a duration string, such as "30s" or "1m30s". The value must be positive and less than or equal to "5m". |
| `nodefsAvailable` *optional* | `string` The grace period for the `nodefs.available` soft eviction threshold. The value must be a duration string, such as "30s" or "1m30s". The value must be positive and less than or equal to "5m". |
| `nodefsInodesFree` *optional* | `string` The grace period for the `nodefs.inodesFree` soft eviction threshold. The value must be a duration string, such as "30s" or "1m30s". The value must be positive and less than or equal to "5m". |
| `pidAvailable` *optional* | `string` The grace period for the `pid.available` soft eviction threshold. The value must be a duration string, such as "30s" or "1m30s". The value must be positive and less than or equal to "5m". |

### `crashLoopBackOff`

```yaml
crashLoopBackOff:
  maxContainerRestartPeriod: string
```

| Fields ||
|---|---|
| `maxContainerRestartPeriod` *optional* | `string` The maximum duration the backoff delay can accrue to for container restarts. If not set, defaults to the internal crashloopbackoff maximum. The value must be a duration string, such as "30s" or "1m30s". The value must be positive and less than or equal to "5m". |

### `memoryManager`

```yaml
memoryManager:
  policy: string
```

| Fields ||
|---|---|
| `policy` *optional* | `string` *Requires GKE version 1.36.2-gke.1368000 or later* Controls the Memory Manager policy on the node. The following values are supported: - `None`: the default behavior. The kubelet does not perform any memory alignment. - `Static`: the kubelet allows Pods in the Guaranteed Quality of Service (QoS) class to be allocated memory from a single NUMA node. |

### `topologyManager`

```yaml
topologyManager:
  policy: string
  scope: string
```

| Fields ||
|---|---|
| `policy` *optional* | `string` *Requires GKE version 1.36.2-gke.1368000 or later* Configures the strategy for NUMA node resource alignment. The following values are supported: - `none`: the default behavior. Does not perform any topology alignment. - `restricted`: the Topology Manager stores the preferred NUMA node affinity for the container, and rejects the Pod if the affinity is not preferred. - `best-effort`: the Topology Manager stores the preferred NUMA node affinity for the container. If the affinity is not preferred, admits the Pod to the node anyway. - `single-numa-node`: determines if single NUMA node affinity is possible. If so, stores this for Hint Providers to use when making resource allocation decisions. If not, rejects the Pod (resulting in a `Terminated` state with a Pod admission failure). |
| `scope` *optional* | `string` *Requires GKE version 1.36.2-gke.1368000 or later* Configures the resource alignment scope. The following values are supported: - `container`: the default behavior. The Topology Manager performs resource alignment for each container in a Pod. - `pod`: the Topology Manager performs resource alignment for the whole Pod. All containers in the Pod are treated as a single unit to place them on a common set of NUMA nodes. |

### `reservedResourcesConfig`

```yaml
reservedResourcesConfig:
  cpuReservedMillicore: integer
  memoryReservedMib: integer
```

| Fields ||
|---|---|
| `cpuReservedMillicore` *optional* | `integer` *Requires GKE version 1.37 or later* Specifies the amount of CPU to reserve for system components, in millicores. The value must be an integer greater than or equal to the default CPU reservation for node pools that run 1.37 or later, and less than 50% of the node's total CPU capacity. If unspecified, GKE determines the default value. For more information, see [System resource reservations](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/node-system-config.md.txt#system-resource-reservations) and [CPU reservations](https://docs.cloud.google.com/kubernetes-engine/docs/concepts/plan-node-sizes.md.txt#cpu_reservations). |
| `memoryReservedMib` *optional* | `integer` *Requires GKE version 1.37 or later* Specifies the amount of memory to reserve for system components, in mebibytes (MiB). The value must be an integer greater than or equal to the default memory reservation for node pools that run 1.37 or later, and less than 50% of the node's total memory capacity. If unspecified, GKE determines the default value. For more information, see [System resource reservations](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/node-system-config.md.txt#system-resource-reservations) and [Memory reservations](https://docs.cloud.google.com/kubernetes-engine/docs/concepts/plan-node-sizes.md.txt#memory_reservations). |

### `linuxNodeConfig`

```yaml
linuxNodeConfig:
  diskIoScheduler: object (diskIoScheduler)
  hugepageConfig: object (hugepageConfig)
  nodeVfioConfig: object (nodeVfioConfig)
  sysctls: object (sysctls)
  transparentHugepageEnabled: string
  transparentHugepageDefrag: string
  swapConfig: object (swapConfig)
```

| Fields ||
|---|---|
| `diskIoScheduler` *optional* | `object (diskIoScheduler)` *Requires GKE version 1.36.2-gke.1368000 or later* Controls the configuration for the disk IO scheduler. |
| `hugepageConfig` *optional* | `object (hugepageConfig)` The huge pages configuration for the node. |
| `nodeVfioConfig` *optional* | `object (nodeVfioConfig)` *Requires GKE version 1.36.2-gke.1368000 or later* Contains VFIO-related configurations for this node. |
| `sysctls` *optional* | `object (sysctls)` The sysctls configuration for the node. |
| `transparentHugepageEnabled` *optional* | `string` *Requires GKE version 1.34.1-gke.3084001 or later* The transparent hugepage configuration for the node. The following values are supported: - `TRANSPARENT_HUGEPAGE_ENABLED_ALWAYS`: transparent hugepage is enabled system wide. - `TRANSPARENT_HUGEPAGE_ENABLED_MADVISE`: transparent hugepage is enabled inside MADV_HUGEPAGE regions. This is the default kernel configuration. - `TRANSPARENT_HUGEPAGE_ENABLED_NEVER`: transparent hugepage is disabled. - `TRANSPARENT_HUGEPAGE_ENABLED_UNSPECIFIED`: default value. GKE does not modify the kernel configuration. |
| `transparentHugepageDefrag` *optional* | `string` *Requires GKE version 1.34.1-gke.3084001 or later* The transparent hugepage defrag configuration for the node. The following values are supported: - `TRANSPARENT_HUGEPAGE_DEFRAG_ALWAYS`: an application requesting THP stalls on allocation failure and directly reclaim pages and compact memory in an effort to allocate a THP immediately. - `TRANSPARENT_HUGEPAGE_DEFRAG_DEFER`: an application wakes kswapd in the background to reclaim pages and wake kcompactd to compact memory so that THP is available in the near future. It is the responsibility of khugepaged to then install the THP pages later. - `TRANSPARENT_HUGEPAGE_DEFRAG_DEFER_WITH_MADVISE`: an application enters direct reclaim and compaction like always, but only for regions that have used `madvise(MADV_HUGEPAGE)`; all other regions wake kswapd in the background to reclaim pages and wake kcompactd to compact memory so that THP is available in the near future. - `TRANSPARENT_HUGEPAGE_DEFRAG_MADVISE`: an application enters direct reclaim and compaction like always, but only for regions that have used `madvise(MADV_HUGEPAGE)`; all other regions wake kswapd in the background to reclaim pages and wake kcompactd to compact memory so that THP is available in the near future. - `TRANSPARENT_HUGEPAGE_DEFRAG_NEVER`: an application never enters direct reclaim or compaction. - `TRANSPARENT_HUGEPAGE_DEFRAG_UNSPECIFIED`: default value. GKE does not modify the kernel configuration. |

### `loggingConfig`

```yaml
loggingConfig:
  loggingVariantConfig: object(loggingVariantConfig)
```

| Fields ||
|---|---|
| `loggingVariantConfig` *optional* | `object (loggingVariantConfig)` Contains logging variant configuration. If you omit this field, the default logging variant configuration, with the value of `DEFAULT`, is used. For more information about logging configuration, see [Adjust log throughput](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/adjust-log-throughput.md.txt). |

### `loggingVariantConfig`

```yaml
loggingVariantConfig:
  variant: DEFAULT
```

| Fields ||
|---|---|
| `variant` *optional* | `string` Sets the logging variant to use. If you omit this field, the default logging variant configuration, with the value of `DEFAULT`, is used. The following values are supported: - `DEFAULT`: uses the standard logging agent. - `MAX_THROUGHPUT`: uses the high-throughput logging agent. For more information about logging configuration, see [Adjust log throughput](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/adjust-log-throughput.md.txt). |

### `swapConfig`

```yaml
swapConfig:
  enabled: bool
  encryptionConfig: object (encryptionConfig)
  bootDiskProfile: object (bootDiskProfile)
  ephemeralLocalSsdProfile: object (ephemeralLocalSsdProfile)
  dedicatedLocalSsdProfile: object (dedicatedLocalSsdProfile)
```

| Fields ||
|---|---|
| `enabled` *optional* | `bool` Enable memory swap for the nodes. Defaults to false. |
| `encryptionConfig` *optional* | `object (encryptionConfig)` The encryption configuration for memory swap. |
| `bootDiskProfile` *optional* | `object (bootDiskProfile)` Enable memory swap on the boot disk for the nodes. Only one of bootDiskProfile, ephemeralLocalSsdProfile, and dedicatedLocalSsdProfile can be set. |
| `ephemeralLocalSsdProfile` *optional* | `object (ephemeralLocalSsdProfile)` Not supported by custom ComputeClasses. |
| `dedicatedLocalSsdProfile` *optional* | `object (dedicatedLocalSsdProfile)` Enable memory swap on the dedicated local SSDs for the nodes. The total disk count must be available for the machine type. Only one of bootDiskProfile, ephemeralLocalSsdProfile, and dedicatedLocalSsdProfile can be set. |

### `encryptionConfig`

```yaml
encryptionConfig:
  disabled: bool
```

| Fields ||
|---|---|
| `disabled` *optional* | `bool` Enable encryption for memory swap on disk. Defaults to false (encrypted). |

### `bootDiskProfile`

```yaml
bootDiskProfile:
  swapSizeGib: int
  swapSizePercent: int
```

| Fields ||
|---|---|
| `swapSizeGib` *optional* | `int` Size of memory swap to enable on the boot disk. Up to 50% of the boot disk can be used for memory swap. Only one of swapSizeGib and swapSizePercent can be set. |
| `swapSizePercent` *optional* | `int` Percentage of the boot disk to use for memory swap. Up to 50% of the boot disk can be used for memory swap. Only one of swapSizeGib and swapSizePercent can be set. |

### `ephemeralLocalSsdProfile`

```yaml
ephemeralLocalSsdProfile:
  swapSizeGib: int
  swapSizePercent: int
```

| Fields ||
|---|---|
| `swapSizeGib` *optional* | `int` Size of memory swap to enable on the local SSDs, the remaining space are used for ephemeral storage. Only one of swapSizeGib and swapSizePercent can be set. |
| `swapSizePercent` *optional* | `int` Percentage of memory swap to enable on the local SSDs, the remaining space are used for ephemeral storage. Only one of swapSizeGib and swapSizePercent can be set. |

### `dedicatedLocalSsdProfile`

```yaml
dedicatedLocalSsdProfile:
  diskCount: int
```

| Fields ||
|---|---|
| `diskCount` *required* | `int` Number of local SSDs to provision dedicated to swap. The total number of local SSDs (including ephemeral storage local SSDs) must be supported by the machine type. |

### `minimumCapacity`

```yaml
minimumCapacity:
  targetNodeCount: integer
```

| Fields ||
|---|---|
| `targetNodeCount` *optional* | `integer` The minimum number of nodes that should be present in the cluster. If the active node count falls below the defined threshold, GKE proactively provisions capacity to satisfy the requirement. In the case of pending Pods that require more capacity, GKE can scale the node count beyond this minimum capacity threshold. Provisioning is subject to resource and quota availability. |

### `nodePoolAutoCreation`

```yaml
nodePoolAutoCreation:
  enabled: boolean
  shieldedInstanceConfig: object(shieldedInstanceConfig)
```

| Fields ||
|---|---|
| `enabled` *optional* | `boolean` Choose whether GKE can create and delete node pools in Standard mode clusters based on the ComputeClass priority rules. In GKE versions earlier than 1.33.3-gke.1136000, this specification requires [cluster-level node auto-provisioning](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/node-auto-provisioning.md.txt#enable-cluster-level) to be enabled on the cluster. If you omit this field, the default value is `false`. For more information, see [Node pool auto-creation and ComputeClasses](https://docs.cloud.google.com/kubernetes-engine/docs/concepts/about-custom-compute-classes.md.txt#autoprovisioning-and-compute-classes). |
| `shieldedInstanceConfig` *optional* | `object (shieldedInstanceConfig)` *Requires GKE version 1.36.3-gke.1244000 or later* Configures the Shielded GKE Nodes options (`enableSecureBoot` and `enableIntegrityMonitoring`) for auto-created node pools managed by this ComputeClass. For more information about conceptual details and defaults, see [Shielded GKE Nodes configuration](https://docs.cloud.google.com/kubernetes-engine/docs/concepts/about-custom-compute-classes.md.txt#shielded-instance-config). |

### `autopilot`

```yaml
autopilot:
  enabled: boolean
```

| Fields ||
|---|---|
| `enabled` *optional* | `boolean` *Requires GKE version 1.34.1-gke.1829001 or later* Indicates whether to run workloads that use this ComputeClass in Autopilot mode. Nodes that GKE creates for the ComputeClass are Autopilot-managed. |

### `nodePoolGroup`

```yaml
nodePoolGroup:
  name: string
```

| Fields ||
|---|---|
| `name` *required* | `string` Defines the name of the node pool group, which is used to share configurations between a group of node pools. This field is required if the `nodePoolGroup` is specified. |

### `nodePoolConfig`

```yaml
nodePoolConfig:
  dra: object(dra)
  imageType: string
  ipType: string
  serviceAccount: string
  autoRepair: boolean
  autoUpgrade: boolean
  workloadType: string
  nodeLabels: map
  instanceMetadata: map
  confidentialNodeType: string
  taintConfig: object(taintConfig)
  taints: [
    object (taints)
  ]
  imageStreaming: object(imageStreaming)
  gvnic: object(gvnic)
  resourceManagerTags: [
    object (resourceManagerTags)
  ]
  loggingConfig: object(loggingConfig)
  sandbox: object(sandbox)
  workloadMetadata: string
  maintenanceExclusion: string
```

| Fields ||
|---|---|
| `maintenanceExclusion` *optional* | `string` *Requires GKE version 1.36.4-gke.1082000 or later* Defines a maintenance exclusion for the node pool. For more information, see [Node pool maintenance exclusions](https://docs.cloud.google.com/kubernetes-engine/docs/concepts/maintenance-windows-and-exclusions.md.txt#node-pool-exclusions). Supported values are `UNTIL_END_OF_SUPPORT`, meaning that GKE only automatically upgrades your cluster as required when the node pool's minor version reaches the end of support. |
| `workloadMetadata` *optional* | `string` *Requires GKE version 1.36.2-gke.1368000 or later* Configures Workload Identity Federation for GKE for the node pool. Supported values are as follows: - `GCE_METADATA`: disable Workload Identity Federation for GKE for the node pool. If you specify this value in an Autopilot cluster or an Autopilot ComputeClass in a Standard cluster, then GKE rejects the ComputeClass. - `GKE_METADATA`: enable Workload Identity Federation for GKE for the node pool. To specify this value, Workload Identity Federation for GKE must be enabled for the cluster. If you omit this field, the nodes use the cluster-level Workload Identity Federation for GKE configuration. |
| `imageType` *optional* | `string` *Requires GKE version 1.32.4-gke.1198000 or later* Choose an image type for the node pools. Image type specifies the base OS that the nodes in the node pool run on. If you omit this field, the default value is `cos_containerd`. |
| `ipType` *optional* | `string` *Requires GKE version 1.35.0-gke.2398000 or later* Controls whether nodes in the node pool use public or private IP addresses. Supported values are `public` and `private`. If you omit this field, the default IP address type is used. This field manages the `cloud.google.com/private-node` node selector; do not manually apply the selector when using this field. |
| `serviceAccount` *optional* | `string` *Requires GKE version 1.31.4-gke.1072000 or later* Specifies the Google Cloud service account used by the nodes within node pools that are managed by the ComputeClass. |
| `autoRepair` *optional* | `string` *Requires GKE version 1.34.0-gke.2201000 or later* Specifies the node auto-repair setting to be used by the node pools. For more information, see [Auto-repair nodes](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/node-auto-repair.md.txt). If you omit this field, existing node pools are compatible regardless of their auto-repair setting. For auto-provisioned node pools, the default value is `true`. |
| `autoUpgrade` *optional* | `string` *Requires GKE version 1.34.0-gke.2201000 or later* Specifies the node auto-upgrade setting to be used by the node pools. For more information, see [Auto-upgrading nodes](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/node-auto-upgrades.md.txt). If you omit this field, existing node pools are compatible regardless of their auto-upgrade setting. For auto-provisioned node pools, the default value is `true`. |
| `workloadType` *optional* | `string` *Requires GKE version 1.32.2-gke.1359000 or later* Specifies the workload type for the node pools. Workload type defines the SLO for the workload. The following values are supported: - `HIGH_AVAILABILITY`: for availability-focused workloads like serving, which require most of the infrastructure to be running at all times - `HIGH_THROUGHPUT`: for batch or training jobs that need all underlying infrastructure running to make progress. This value can be set only when [nodePoolGroup](https://docs.cloud.google.com/kubernetes-engine/docs/reference/crds/computeclass.md.txt#nodepoolgroup) is also specified. |
| `nodeLabels` *optional* | `map` *Requires GKE version 1.33.2-gke.1111000 or later* Specifies the node labels, which add user-defined Kubernetes labels to all nodes in the new node pool. GKE applies these labels to the Kubernetes API node object, and you can use them in `nodeSelectors` for Pod scheduling. Kubernetes node labels are different from GKE labels. For more information, see [the comparison of GKE node pool labels and Kubernetes labels.](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/creating-managing-labels.md.txt#label_comparison) Example: ```yaml nodeLabels: { 'example-nodelabel-key': 'example-nodelabel-value', 'example-nodelabel-key-2': 'example-nodelabel-value-2', } ``` |
| `instanceMetadata` *optional* | `map (instanceMetadata)` *Requires GKE version 1.36.2-gke.1498000 or later* Specifies custom metadata key-value pairs to inject into Compute Engine VM instances in all node pools created by the ComputeClass. Supported only on GKE Standard mode clusters (`spec.autopilot.enabled: false`). If a key is also defined in `priorities[].instanceMetadata`, the priority-level value takes precedence. |
| `confidentialNodeType` *optional* | `string` *Requires GKE version 1.33.3-gke.1392000 or later* Defines the type of technology used by the confidential node. If using this, must specify `machineFamily` or `machineType` in each priority. The following values are supported: - `SEV`: AMD Secure Encrypted Virtualization. - `SEV_SNP`: AMD Secure Encrypted Virtualization - Secure Nested Paging. - `TDX`: Intel Trust Domain eXtension |
| `taintConfig` *optional* | `object (taintConfig)` *Requires GKE version 1.36.2-gke.1498000 or later* Contains the node taint configuration. You can use this field to configure architecture taint behavior. |
| `taints[]` *optional* | `object (taints)` *Requires GKE version 1.33.4-gke.1350000 or later* Applies Kubernetes taints to all nodes in a new node pool. You can use these taints with tolerations for Pod scheduling. Kubernetes won't schedule a workload to the node pool if the workload doesn't have tolerations for all taints in this field. For more information, see [node-taints](https://cloud.google.com/sdk/gcloud/reference/container/node-pools/create#--node-taints) |
| `imageStreaming` *optional* | `object (imageStreaming)` *Requires GKE version 1.34.1-gke.1279000 or later* Specifies the image streaming configuration for nodes in Standard clusters. If you omit this field, the cluster-wide default setting is used. For more information about image streaming, see [Use Image streaming to pull container images](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/image-streaming.md.txt). |
| `gvnic` *optional* | `object (gvnic)` *Requires GKE version 1.34.1-gke.3759000 or later* Google Virtual NIC settings. If you omit this field, the related machine-type default setting is used. For more information about gVNIC, see [Using Google Virtual NIC](https://docs.cloud.google.com/compute/docs/networking/using-gvnic.md.txt). |
| `resourceManagerTags[]` *optional* | `object (resourceManagerTags)` *Requires GKE version 1.34.1-gke.2541000 or later* A list of Google Cloud resource manager tags to attach to all nodes in any node pools managed by the ComputeClass. Tags must be created before you can use them in the `resourceManagerTags` field. If you want to use tags with firewall policies, they must have the purpose `GCE_FIREWALL` assigned to them. If you want to use tags for other purposes, ensure that your cluster uses version 1.35.0-gke.2398000 or later. You can specify a maximum of five tags. For more information about how to use tags in GKE, see [Selectively enforce firewall policies in GKE](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/tags-firewall-policies.md.txt). |
| `loggingConfig` *optional* | `object (loggingConfig)` *Requires GKE version 1.35.0-gke.2398000 or later* Contains logging configuration. If you omit this field, the default logging configuration, with the `DEFAULT` logging variant, is used. For more information about logging configuration, see [Adjust log throughput](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/adjust-log-throughput.md.txt). |
| `sandbox` *optional* | `object (sandbox)` *Requires GKE version 1.36.2-gke.1368000 or later.* Configures the type of GKE Sandbox environment for GKE to use to isolate workloads from the host kernel of the node. |
| `dra` *optional* | `object (dra)` *Requires GKE version 1.35.2-gke.1842000 or later* The Dynamic Resource Allocation (DRA) configuration. |

### `dra`

```yaml
dra:
  networking: object(networking)
```

| Fields ||
|---|---|
| `networking` *optional* | `object (networking)` *Requires GKE version 1.35.2-gke.1842000 or later* The networking configuration for Dynamic Resource Allocation. |

### `networking`

```yaml
networking:
  enabled: boolean
```

| Fields ||
|---|---|
| `enabled` *optional* | `boolean` *Requires GKE version 1.35.2-gke.1842000 or later* Enables the GKE managed DRANET driver for networking resources on the node pool. |

### `nodeRecycling`

```yaml
nodeRecycling:
  leadTimeSeconds: integer
```

| Fields ||
|---|---|
| `leadTimeSeconds` *required* | `integer` The amount of time, in seconds, before a node reaches the end of its run that GKE should start provisioning a replacement node. |

### `nodeSystemConfig`

```yaml
nodeSystemConfig:
  kubeletConfig: object(kubeletConfig)
  linuxNodeConfig: object(linuxNodeConfig)
```

| Fields ||
|---|---|
| `kubeletConfig` *optional* | `object (kubeletConfig)` The kubelet configuration for the node. |
| `linuxNodeConfig` *optional* | `object (linuxNodeConfig)` The Linux kernel configuration for the node. |

### `nodeVfioConfig`

```yaml
nodeVfioConfig:
  dmaEntryLimit: integer
```

| Fields ||
|---|---|
| `dmaEntryLimit` *optional* | `integer` *Requires GKE version 1.36.2-gke.1368000 or later* Specifies the maximum number of DMA entries (pages) that can be mapped by the VFIO IOMMU type 1 driver for a container. This limit affects the total amount of host memory that can be pinned for direct device access, which is often critical for high-performance devices like TPUs and GPUs. This setting corresponds to the kernel parameter at: `/sys/module/vfio_iommu_type1/parameters/dma_entry_limit`. The default value in the kernel is `65535`. Higher values may be needed for workloads mapping large memory regions. Supported values are integers between `65535` and `4194304`. |

### `placement`

```yaml
placement:
  policyName: string
```

| Fields ||
|---|---|
| `policyName` *required* | `string` The resource policy name to be used in [custom compact placement policies](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/compact-placement.md.txt#enable_a_compact_placement_policy). Must not be an empty string. |

### `location`

```yaml
location:
  locationPolicy: string
  zones: []string
  zoneTypes: []string
```

| Fields ||
|---|---|
| `locationPolicy` *optional* | `string` *Requires GKE version 1.34.1-gke.2541000 or later* Location policy specifies the strategy for selecting zones when scaling up a node pool that's managed by this ComputeClass. It can be either `ANY` or `BALANCED`. This setting controls the distribution of new nodes across zones in the node pool's region and corresponds to the node pool setting with the same name. [Read more](https://docs.cloud.google.com/kubernetes-engine/docs/concepts/cluster-autoscaler.md.txt#location_policy) about location policy and its default values. |
| `zones` *optional* | `[]string` A list of Google Cloud zones to use. In order for a node to be used, it must belong to a node pool that spans exactly the same set of zones. Optional: If you are provisioning TPU VMs, use an [AI zone](https://docs.cloud.google.com/compute/docs/regions-zones/ai-zones.md.txt), like `us-central1-ai1a`. AI zones are specialized locations that are optimized for AI/ML workloads within Google Cloud regions. <br /> |
| `zoneTypes` *optional* | `[]string` *Requires GKE version 1.35.2-gke.1842000 or later* A list of zone types that specifies a set of Google Cloud zones to use. The following values are supported: - `CLUSTER_DEFAULT`: zones specified in the cluster's autoprovisioning locations field (or the cluster's locations field if autoprovisioning locations are not specified). This is the default value. - `STANDARD`: all standard (non-AI) zones within the cluster's region. - `AI`: all [AI zones](https://docs.cloud.google.com/compute/docs/regions-zones/ai-zones.md.txt) within the cluster's region. If multiple \`zoneType\` values are specified, the resulting set of zones is the union of corresponding zone sets. This field is mutually exclusive with the `zones` and `reservations.specific` fields. When the `machineType` field is specified, the resulting set of zones includes only those zones where the specified machine type is available. For more information, see [Using location zoneTypes priority](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/gke-zonal-topology.md.txt#using-zone-types). |

### `priorities`

```yaml
priorities:
- capacityCheckWaitTimeSeconds: integer
  acceleratorNetworkProfile: string
  allocationStrategy: string
  enableNestedVirtualization: boolean
  flexStart: object(flexStart)
  gpu: object(gpu)
  location: object(location)
  machineFamily: string
  machineType: string
  maxRunDurationSeconds: integer
  minCores: integer
  minCpuPlatform: string
  minMemoryGb: integer
  minimumCapacity: object(minimumCapacity)
  nodeLabels: map
  instanceMetadata: map
  nodepools: []string
  nodeSystemConfig: object(nodeSystemConfig)
  machineType: string
  location: object(location)
  maxPodsPerNode: integer
  placement: object (placement)
  priorityScore: integer
  reservations: object(reservations)
  spot: boolean
  storage: object(storage)
  taints: [
    object (taints)
  ]
  tpu: object(tpu)
```

| Fields ||
|---|---|
| `capacityCheckWaitTimeSeconds` *optional* | `integer` *Requires GKE version 1.33.1-gke.1788000 or later* Duration, in seconds, for which GKE attempts to provision the priority before falling back to lower priorities. If unspecified, GKE falls back as soon as the initial provisioning attempt is unsuccessful. Values shorter than the time required for the initial provisioning attempt are ignored because this field only extends the timeout to allow for multiple provisioning attempts. Only supported for [flex-start](https://docs.cloud.google.com/kubernetes-engine/docs/concepts/dws.md.txt) priorities, except single-host TPUs. |
| `enableNestedVirtualization` *optional* | `boolean` *Requires GKE version 1.37.0-gke.4713000 or later* Whether to enable nested virtualization on the nodes. Defaults to `false`. For more information, see [Use nested VMs with GKE clusters](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/nested-virtualization.md.txt). |
| `flexStart` *optional* | `object (flexStart)` *Requires GKE version 1.32.2-gke.1652000 or later* The [flex-start](https://docs.cloud.google.com/kubernetes-engine/docs/concepts/dws.md.txt) provisioning mode configurations. |
| `gpu` *optional* | `object(gpu)` *Requires GKE version 1.30.3-gke.1451000 or later* The GPU configuration. |
| `machineFamily` *optional* | `string` *Requires GKE version 1.30.3-gke.1451000 or later* The [Compute Engine machine series](https://docs.cloud.google.com/compute/docs/machine-resource.md.txt) to use, such as `n4` or `c3`. If you don't specify a value, GKE uses the default machine series of the cluster. |
| `machineType` *optional* | `string` *Requires GKE version 1.30.3-gke.1451000 or later* The Compute Engine machine type to use. This value can be a predefined type, like `n4-standard-32`, or a [custom machine type](https://docs.cloud.google.com/compute/docs/instances/creating-instance-with-custom-machine-type.md.txt#create), like `n4-custom-8-20480`. Using custom machine types requires GKE version 1.33.2-gke.1111000 or later. |
| `location` *optional* | `object (location)` *Requires GKE version 1.33.1-gke.1545000 or later* The location configuration. |
| `maxPodsPerNode` *optional* | `integer` *Requires GKE version 1.32.1-gke.1159000 or later* The maximum number of Pods that GKE can place on each node. The value must be between `8` and `256`. |
| `maxRunDurationSeconds` *optional* | `integer` *Requires GKE version 1.32.1-gke.1159000 or later* The maximum duration, in seconds, that the nodes can exist before being shut down. If you omit this field, the nodes can exist indefinitely. |
| `minCores` *optional* | `integer` *Requires GKE version 1.30.3-gke.1451000 or later* The minimum number of vCPU cores that each node can have. If you omit this field, the default value is `0`. |
| `minCpuPlatform` *optional* | `string` *Requires GKE version 1.34.1-gke.2541000 or later* The minimum CPU platform of each node of this priority. For example, `Intel Sky Lake` or `Intel Cascade Lake`. For more information about all of the machine families that support a particular CPU platform, see [CPU platforms](https://docs.cloud.google.com/compute/docs/cpu-platforms.md.txt). [Read more about this field.](https://docs.cloud.google.com/compute/docs/instances/specify-min-cpu-platform.md.txt) |
| `minMemoryGb` *optional* | `integer` *Requires GKE version 1.30.3-gke.1451000 or later* The minimum memory capacity, in GiB, that each node can have. If you omit this field, the default value is `0`. |
| `minimumCapacity` *optional* | `object (minimumCapacity)` *Requires GKE version 1.36.3-gke.1253000 or later* The minimum capacity configuration for this specific priority rule. |
| `nodeLabels` *optional* | `map` *Requires GKE version 1.34.1-gke.3084002 or later* Specifies the node labels, which add user-defined Kubernetes labels to all nodes in the new node pool. These labels are applied to the Kubernetes API node object and can be used in nodeSelectors for Pod scheduling. Kubernetes node labels are different from GKE labels. For more information, see [the comparison of GKE nodepool labels and Kubernetes labels.](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/creating-managing-labels.md.txt#label_comparison) Example: ```yaml nodeLabels: { 'example-nodelabel-key': 'example-nodelabel-value', 'example-nodelabel-key-2': 'example-nodelabel-value-2', } ``` |
| `instanceMetadata` *optional* | `map (instanceMetadata)` *Requires GKE version 1.36.2-gke.1498000 or later* Specifies custom metadata key-value pairs to inject into Compute Engine VM instances when nodes are provisioned using this specific priority rule. Supported only on GKE Standard mode clusters (`spec.autopilot.enabled: false`). Overrides any matching metadata keys specified in `nodePoolConfig.instanceMetadata`. |
| `nodepools` *optional* | `[]string` *Requires GKE version 1.30.3-gke.1451000 or later* A list of existing manually created node pools in Standard mode clusters. You must associate these node pools with the ComputeClass by using node labels and node taints. GKE doesn't process the node pools in this list in any order. Example: `nodepools: ['example-first-nodepool-name', 'example-second-nodepool-name']` This field has the following restrictions: - This field is incompatible with all other fields in `priorities`, because this field is for manually created node pools. - Unsupported when the `spec.autopilot.enabled` field is set to `true`. |
| `nodeSystemConfig` *optional* | `object (nodeSystemConfig)` *Requires GKE version 1.32.1-gke.1729000 or later* The node system configuration. |
| `placement` *optional* | `object (placement)` *Requires GKE version 1.33.2-gke.1335000 or later* The placement configuration. You can specify a resource policy name to be used in [custom compact placement policies](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/compact-placement.md.txt#enable_a_compact_placement_policy). |
| `podFamily` *optional* | `string` *Requires GKE version 1.35.2-gke.1485000 or later* Use the Autopilot container-optimized compute platform to run the Pod. The supported values are `general-purpose` and `general-purpose-arm`. To use this field in a Standard cluster, you must set the `spec.autopilot.enabled` field to `true`. The `general-purpose-arm` pod family is supported in Autopilot clusters starting in GKE version *1.35.3-gke.1389000* or later, and in Standard clusters with Autopilot ComputeClass nodes starting in GKE version *1.36.0-gke.3302001* or later. |
| `priorityScore` *optional* | `integer` *Requires GKE version 1.35.2-gke.1842000 or later* The explicit priority score for the priority rule. Higher values mean higher priority. You can group multiple priority rules by assigning the same priority score to them. If you assign a priority score to a priority rule, you must set a priority score for \*all\* priority rules that are in the same ComputeClass. |
| `reservations` *optional* | `object (reservations)` *Requires GKE version 1.31.1-gke.2105000 or later* The Compute Engine capacity reservations to consume during node provisioning. |
| `spot` *optional* | `boolean` *Requires GKE version 1.30.3-gke.1451000 or later* The Spot VMs configuration. If you set this field to `true`, GKE uses Spot VMs to create your nodes. If you omit this field, the default value is `false`. |
| `storage` *optional* | `object (storage)` *Requires GKE version 1.30.3-gke.1639000 or later* The boot disk configuration of each node. |
| `taints[]` *optional* | `object (taints)` *Requires GKE version 1.34.1-gke.3084002 or later* Applies the given Kubernetes taints on all nodes in the new node pool, which can be used with tolerations for Pod scheduling. Any workload that doesn't have tolerations for all of the taints in this field won't be scheduled to the node pool. For more information, see [node-taints](https://cloud.google.com/sdk/gcloud/reference/container/node-pools/create#--node-taints) |
| `tpu` *optional* | `object (tpu)` *Requires GKE version 1.31.2-gke.1518000 or later* The TPU configuration. |
| `acceleratorNetworkProfile` *optional* | `string` *Requires GKE version 1.35.2-gke.1842000 or later* The accelerator network profile for the priority rule, such as `auto`. For more information, see [Allocate network resources by using GKE managed DRANET](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/allocate-network-resources-dra.md.txt). |
| `allocationStrategy` *optional* | `string` *Requires GKE version 1.36.4-gke.1082000 or later, or 1.35.8-gke.1439000 or later* The allocation strategy used for node pool selection. The supported value is `lowest-cost`, which directs GKE to select the node pool option with the lowest infrastructure cost based on `us-central1` list prices when scaling up, taking into account potential future scale-ups rather than only immediate cost. If omitted, GKE uses the strategy specified in `spec.allocationStrategyDefaults` for the priority's provisioning model. If not specified in the priority rule or in `spec.allocationStrategyDefaults`, the default strategy is `lowest-cost`. |

The following example configures a ComputeClass that prioritizes Spot VMs
for the `n4-custom-8-20480` custom machine type, and falls back to
on-demand VMs of the same type if Spot capacity is unavailable:

```yaml
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: custom-machine-type
spec:
  priorities:
  - machineType: n4-custom-8-20480
    spot: true
  - machineType: n4-custom-8-20480
    spot: false
  nodePoolAutoCreation:
    enabled: true
```

### `priorityDefaults`

```yaml
priorityDefaults:
  enableNestedVirtualization: boolean
  nodeSystemConfig: object(nodeSystemConfig)
  location: object(location)
```

| Fields ||
|---|---|
| `enableNestedVirtualization` *optional* | `boolean` *Requires GKE version 1.37.0-gke.4713000 or later* Default value for the nested virtualization configuration. This value applies to a priority rule in the `spec.priorities` field only if the corresponding field is omitted from that rule. |
| `nodeSystemConfig` *optional* | `object (nodeSystemConfig)` Default values for the node system configuration. These values apply to a priority rule in the `spec.priorities` field only if the corresponding fields are omitted from that rule. |
| `location` *optional* | `object (location)` *Requires GKE version 1.33.1-gke.1545000 or later* Default values for the location configuration. These values apply to a priority rule in the `spec.priorities` field only if the corresponding fields are omitted from that rule. |

### `reservations`

```yaml
reservations:
  affinity: string
  specific: [
    object(specific)
  ]
```

| Fields ||
|---|---|
| `affinity` *required* | `string` The type of reservation to consume when creating nodes. The following values are supported: - `Specific`: consume only specific named reservations. If the specified reservation doesn't have any capacity, GKE moves on to the next priority rule in the ComputeClass. If you use this value, the `specific[]` field is required. - `AnyBestEffort`: consume any reservation that matches the requirements of the priority rule. If any available reservation doesn't have capacity, GKE tries to provision an on-demand node with the priority rule configuration. - *Requires GKE version 1.36.0-gke.3204000 or later* `AnyThenFail`: consume any reservation that matches the requirements of the priority rule. If any available reservation doesn't have capacity, GKE skips provisioning an on-demand node and tries the next priority rule in the ComputeClass. If no other rules apply, the scale operation fails depending on the `whenUnsatisfiable` setting. - `None`: prevent GKE from consuming reservations when it creates nodes for that priority rule. |
| `specific` *optional\** | `object(specific)` The parameters for consuming specific reservations. If you set the `affinity` field to `Specific`, this field is required. If you set the `affinity` field to any other value, you can't specify the `specific` field. |

### `reservationBlock`

```yaml
reservationBlock:
  name: string
  reservationSubBlock: object(reservationSubBlock)
```

| Fields ||
|---|---|
| `name` *required* | `string` The name of the specific reservation block to consume. |
| `reservationSubBlock` *optional* | `object(reservationSubBlock)` *Requires GKE version 1.33.1-gke.1788000 or later* Consumes a named sub-block of capacity within the reservation block. For more information about reservation sub-block consumption, see [Consume specific reservation sub-blocks](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/consuming-reservations.md.txt#autopilot-reservation-sub-block). |

### `reservationSubBlock`

```yaml
reservationSubBlock:
  name: string
```

| Fields ||
|---|---|
| `name` *required* | `string` The name of the specific reservation sub-block to consume. |

### `secondaryBootDisks`

```yaml
secondaryBootDisks:
- diskImageName: string
  mode: string
  project: string
```

| Fields ||
|---|---|
| `diskImageName` *required* | `string` The name of the disk image. |
| `mode` *optional* | `string` The mode in which the secondary boot disk should be used. The following values are supported: - `CONTAINER_IMAGE_CACHE`: use the disk as a container image cache. - `MODE_UNSPECIFIED`: don't use a specific mode. If you omit this field, this is the default value. |
| `project` *optional* | `string` The project ID of the Google Cloud project that the disk image belongs to. If you omit this field, the default value is the project ID of the cluster project. |

### `specific`

```yaml
specific:
- name: string
  project: string
  zones: []string
  reservationBlock: object(reservationBlock)
```

| Fields ||
|---|---|
| `name` *required* | `string` The name of the specific reservation to consume. |
| `project` *optional* | The project ID of the Google Cloud project that contains the specific reservation. To use a shared reservation from a different project, this field is required. |
| `zones` *optional* | `[]string` *Requires GKE version 1.34.1-gke.3759000 or later* A list of Google Cloud zones to consume the reservations from. If you specify this field, GKE consumes matching reservations only from zones in the list. This field cannot be used if `location.zones` is specified in the same priority rule. |
| `reservationBlock` *optional* | `object(reservationBlock)` *Requires GKE version 1.31.4-gke.1072000 or later* Consumes a named block of capacity within the reservation. For details about reservation block consumption, see [Consume specific reservation blocks](https://docs.cloud.google.com/kubernetes-engine/docs/concepts/about-custom-compute-classes.md.txt#specific-reservations). |

### `storage`

```yaml
storage:
  bootDiskKMSKey: string
  bootDiskSize: integer
  bootDiskType: string
  localSSDCount: integer
  secondaryBootDisks: [
    object(secondarybootdisks)
  ]
```

| Fields ||
|---|---|
| `bootDiskKMSKey` *optional* | `string` The path to the Cloud Key Management Service key to use to encrypt the boot disk. |
| `bootDiskSize` *optional* | `integer` *Requires GKE version 1.34.1-gke.1431000 or later for `machineFamily` priority rules and version 1.30.3-gke.1639000 or later for other priority rule types.* The size, in GiB, of the boot disk for each node. The minimum value is `10`. |
| `bootDiskType` *optional* | `string` *Requires GKE version 1.34.1-gke.1431000 or later for `machineFamily` priority rules and version 1.30.3-gke.1639000 or later for other priority rule types.* The type of disk to attach to the node. The value that you specify must be supported by the machine series or the machine type in your priority rule. The following values are supported: - `pd-balanced`: balanced Persistent Disk. On Autopilot, only the `pd-balanced` type of `bootDiskType` is supported. - `pd-standard`: standard Persistent Disk. - `pd-ssd`: performance (SSD) Persistent Disk. - `hyperdisk-balanced`: Google Cloud Hyperdisk Balanced. For details about the disk types that specific machine series support, see the [Machine series comparison table](https://docs.cloud.google.com/compute/docs/machine-resource.md.txt#machine_type_comparison). Filter the table properties for "Hyperdisk" and "PD". |
| `localSSDCount` *optional* | `integer` The number of Local SSDs to attach to each node. If you specify this field, the minimum value is `1`. |
| `secondaryBootDisks[]` *optional* | `[]object(secondaryBootDisks)` *Requires GKE version 1.31.2-gke.1105000 or later* The configuration of secondary boot disks that are used to preload nodes with data, such as ML models or container images. |

### `sysctls`

```yaml
sysctls:
  kernel.core_pattern: string
  kernel.keys.maxbytes: integer
  kernel.keys.maxkeys: integer
  kernel.kptr_restrict: integer
  kernel.perf_event_paranoid: integer
  kernel.sched_rt_runtime_us: integer
  kernel.shmmni: integer
  kernel.shmmax: integer
  kernel.shmall: integer
  kernel.softlockup_panic: integer
  kernel.sysrq: integer
  kernel.yama.ptrace_scope: integer
  net.core.netdev_max_backlog: integer
  net.core.rmem_default: integer
  net.core.rmem_max: integer
  net.core.wmem_default: integer
  net.core.wmem_max: integer
  net.core.optmem_max: integer
  net.core.somaxconn: integer
  net.ipv4.neigh.default.gc_thresh1: integer
  net.ipv4.neigh.default.gc_thresh2: integer
  net.ipv4.neigh.default.gc_thresh3: integer
  net.ipv4.tcp_congestion_control: string
  net.ipv4.tcp_ecn: integer
  net.ipv4.tcp_max_orphans: integer
  net.ipv4.tcp_max_tw_buckets: integer
  net.ipv4.tcp_mtu_probing: integer
  net.ipv4.tcp_rmem: string
  net.ipv4.tcp_syn_retries: integer
  net.ipv4.tcp_tw_reuse: integer
  net.ipv4.tcp_wmem: string
  net.core.busy_poll: integer
  net.core.busy_read: integer
  net.ipv6.conf.all.disable_ipv6: boolean
  net.ipv6.conf.default.disable_ipv6: boolean
  net.netfilter.nf_conntrack_max: integer
  net.netfilter.nf_conntrack_buckets: integer
  net.netfilter.nf_conntrack_tcp_timeout_close_wait: integer
  net.netfilter.nf_conntrack_tcp_timeout_time_wait: integer
  net.netfilter.nf_conntrack_tcp_timeout_established: integer
  net.netfilter.nf_conntrack_acct: boolean
  vm.max_map_count: integer
  vm.dirty_background_bytes: integer
  vm.dirty_background_ratio: integer
  vm.dirty_bytes: integer
  vm.dirty_expire_centisecs: integer
  vm.dirty_ratio: integer
  vm.dirty_writeback_centisecs: integer
  vm.overcommit_memory: integer
  vm.overcommit_ratio: integer
  vm.vfs_cache_pressure: integer
  vm.min_free_kbytes: integer
  vm.swappiness: integer
  vm.watermark_scale_factor: integer
  fs.aio-max-nr: integer
  fs.file-max: integer
  fs.inotify.max_user_instances: integer
  fs.inotify.max_user_watches: integer
  fs.nr_open: integer
```

| Fields ||
|---|---|
| `kernel.core_pattern` *optional* | `string` *Requires GKE version 1.36.0-gke.3951000 or later* Specifies the core dump filename pattern. Piping core dumps is not allowed. The value must be a canonical absolute path that doesn't contain relative directory paths (such as `.` or `..`) and double slashes (`//`). The value has a maximum length of 128 characters. |
| `kernel.keys.maxbytes` *optional* | `integer` *Requires GKE version 1.35.3-gke.1234000 or later* The maximum number of bytes that a nonroot user can hold in the payload section of all their keys. The value must be between `20000` and `2097152`. |
| `kernel.keys.maxkeys` *optional* | `integer` *Requires GKE version 1.35.3-gke.1234000 or later* The maximum number of keys that a nonroot user can own. The value must be between `200` and `1048576`. |
| `kernel.kptr_restrict` *optional* | `integer` *Requires GKE version 1.36.0-gke.2684000 or later* Determine whether kernel pointers are exposed. The supported values are as follows: - `0`: kernel pointers are exposed. - `1`: kernel pointers are hidden unless the user has `CAP_SYSLOG`. - `2`: kernel pointers are always hidden. |
| `kernel.perf_event_paranoid` *optional* | `integer` *Requires GKE version 1.36.0-gke.2684000 or later* Controls use of the performance events system by non-privileged users. The value must be between `-1` and `3`. |
| `kernel.sched_rt_runtime_us` *optional* | `integer` *Requires GKE version 1.36.0-gke.2684000 or later* Allocated CPU time for real-time tasks, in microseconds. The value must be between `-1` and `1000000`. A value of `-1` means no limit. |
| `kernel.shmmni` *optional* | `integer` *Requires GKE version 1.33.4-gke.1036000 or later* The system-wide maximum number of shared memory segments. The value must be between `4096` and `32768`. |
| `kernel.shmmax` *optional* | `integer` *Requires GKE version 1.33.4-gke.1036000 or later* The total amount of shared memory pages that can be used on the system at one time. The value must be between `0` and `18446744073692774399`. |
| `kernel.shmall` *optional* | `integer` *Requires GKE version 1.33.4-gke.1036000 or later* The maximum size (in bytes) of a single shared memory segment allowed by the kernel. The value must be between `0` and `18446744073692774399`. |
| `kernel.softlockup_panic` *optional* | `integer` *Requires GKE version 1.36.0-gke.2684000 or later* Controls whether the kernel panics when a soft lockup is detected. The supported values are as follows: - `0`: do not panic on soft lockup. - `1`: panic on soft lockup. |
| `kernel.sysrq` *optional* | `integer` *Requires GKE version 1.36.0-gke.2684000 or later* Controls the functions allowed to be invoked by using the SysRq key. The value must be between `0` and `511`. |
| `kernel.yama.ptrace_scope` *optional* | `integer` *Requires GKE version 1.36.0-gke.2684000 or later* Controls which processes can be debugged with `ptrace`. The supported values are as follows: - `0`: all processes can be debugged. - `1`: only parent processes can debug children. - `2`: only admins can debug. - `3`: no processes can be debugged (cannot be undone without reboot). |
| `net.core.netdev_max_backlog` *optional* | `integer` The maximum number of packets, queued on the INPUT side, when the interface receives packets faster than the kernel can process them. This setting is crucial for high-traffic network interfaces. Increasing this value can help to prevent packet loss under heavy load, but it also increases memory consumption. The value must be between `1` and `2147483647`. |
| `net.core.rmem_max` *optional* | `integer` The maximum receive socket buffer size in bytes. This setting limits the amount of data that a socket can buffer when receiving data. Increasing this value can improve performance for high-bandwidth connections by allowing the socket to handle larger bursts of data. The value must be between `2304` and `2147483647`. |
| `net.core.rmem_default` *optional* | `integer` *Requires GKE version 1.33.4-gke.1036000 or later* The default receive socket buffer size in bytes. The value must be between `2304` and `2147483647`. |
| `net.core.wmem_default` *optional* | `integer` The default setting, in bytes, of the socket send buffer. This value defines the initial size of the buffer allocated for sending data on a socket. The value must be between `4608` and `2147483647`. |
| `net.core.wmem_max` *optional* | `integer` The maximum send socket buffer size in bytes. This setting limits the amount of data that a socket can buffer when it sends data. Increasing this value can improve performance for applications that send large amounts of data. The value must be between `4608` and `2147483647`. |
| `net.core.optmem_max` *optional* | `integer` The maximum ancillary buffer size allowed per socket. Ancillary data is a sequence of [cmsghdr](https://linux.die.net/man/3/cmsg) structures with appended data, which are used to send and receive control information along with socket data. The value must be between `1` and `2147483647`. |
| `net.core.somaxconn` *optional* | `integer` The maximum size of the socket `listen()` backlog. This setting defines the maximum number of pending connections that can be queued for a listening socket. You might need to increase this value for busy web servers or other network services that handle a high volume of concurrent connection requests. The value must be between `128` and `2147483647`. The default value is `128`. |
| `net.ipv4.neigh.default.gc_thresh1` *optional* | `integer` *Requires GKE version 1.35.3-gke.1234000 or later* The minimum number of entries to keep in the ARP cache. The garbage collector doesn't run if the number of entries is below this setting. The value must be between `0` and `262144`. Note, setting this value to `0` can lead to cache thrashing and degraded performance. |
| `net.ipv4.neigh.default.gc_thresh2` *optional* | `integer` *Requires GKE version 1.35.3-gke.1234000 or later* The soft maximum number of entries to keep in the ARP cache. The garbage collector allows the number of entries to exceed this value for 5 seconds before it starts soft garbage collection. The value must be between `512` and `524288`. |
| `net.ipv4.neigh.default.gc_thresh3` *optional* | `integer` *Requires GKE version 1.35.3-gke.1234000 or later* The hard maximum number of entries to keep in the ARP cache. The garbage collector is designed to always run if the number of entries exceeds this setting. The value must be between `1024` and `1048576`. |
| `net.ipv4.tcp_congestion_control` *optional* | `string` *Requires GKE version 1.36.0-gke.2684000 or later* The TCP congestion control algorithm to use. Common values include `bbr`, `cubic`, `reno`, and `htcp`. The maximum length is 10 characters. Not supported for Autopilot clusters. |
| `net.ipv4.tcp_ecn` *optional* | `integer` *Requires GKE version 1.36.0-gke.2684000 or later* Controls Explicit Congestion Notification (ECN) in TCP. The supported values are as follows: - `0`: disable ECN. - `1`: enable ECN when requested by incoming connections, and request ECN on outgoing connections. - `2`: enable ECN when requested by incoming connections, but do not request it on outgoing connections. |
| `net.ipv4.tcp_max_orphans` *optional* | `integer` *Requires GKE version 1.34.1-gke.3084001 or later* Maximal number of TCP sockets that aren't attached to any user file handle. The value must be between `16384` and `262144`. |
| `net.ipv4.tcp_max_tw_buckets` *optional* | `integer` *Requires GKE version 1.36.0-gke.2684000 or later* The maximum number of `TIME-WAIT` sockets allowed in the system. The value must be between `4096` and `2147483647`. |
| `net.ipv4.tcp_mtu_probing` *optional* | `integer` *Requires GKE version 1.36.0-gke.2684000 or later* Controls TCP Packetization Layer Path MTU Discovery. The supported values are as follows: - `0`: disabled. - `1`: enabled when a black hole is detected. - `2`: always enabled. |
| `net.ipv4.tcp_rmem` *optional* | `string` The minimum size, in bytes, of the receive buffer that's used by TCP sockets in moderation. Each TCP socket can use the size for receiving data, even if the total pages of UDP sockets exceed `udp_mem` pressure. The value in this field is a string of three integers, separated by spaces. These three integers represent the minimum, default, and maximum size of the receive buffer. For example, `'4096 87380 6291456'`. |
| `net.ipv4.tcp_syn_retries` *optional* | `integer` *Requires GKE version 1.36.0-gke.2684000 or later* The number of times to retry sending a SYN packet before abandoning a connection attempt. The value must be between `1` and `127`. |
| `net.ipv4.tcp_tw_reuse` *optional* | `integer` Reuse `TIME-WAIT` sockets for new connections when the protocol considers it safe to do so. This setting can improve performance by reducing the number of sockets in the `TIME-WAIT` state, but it also carries a risk of potential data corruption if it isn't used carefully. Don't change this setting unless a technical expect requests the change. The following values are supported: - `0` - `1` - `2` |
| `net.ipv4.tcp_wmem` *optional* | `string` The minimal size, in bytes, of the send buffer that's used by TCP sockets in moderation. Each TCP socket can use the size for sending data, even if the total pages of TCP sockets exceed `udp_mem` pressure. The value in this field is a string of three integers, separated by spaces. These three integers represent the minimum, default, and maximum size of the receive buffer. For example, `'4096 87380 6291456'`. These values control how TCP socket send buffers dynamically resize for sending. |
| `net.core.busy_poll` *optional* | `integer` The approximate time, in microseconds, to wait for packets on the device queue to do socket [polls](https://man7.org/linux/man-pages/man2/poll.2.html) or [selects](https://man7.org/linux/man-pages/man2/select.2.html). This setting is related to network performance tuning for low-latency applications. The value must be between `1024` and `2147483647`. |
| `net.core.busy_read` *optional* | `integer` The approximate time, in microseconds, to wait for packets on the device queue to perform [read](https://man7.org/linux/man-pages/man2/read.2.html) operations. This setting is used for low-latency network tuning, specifically for read operations. The value must be between `0` and `2147483647`. |
| `net.ipv6.conf.all.disable_ipv6` *optional* | `boolean` Globally disables IPv6 on all future and existing interfaces. Changing this value has the same effect as changing the `net.ipv6.conf.default.disable_ipv6` setting and all per-interface `disable_ipv6` settings to a specific value. The following values are supported: - `true`: disable IPv6. - `false`: enable IPv6. |
| `net.ipv6.conf.default.disable_ipv6` *optional* | `boolean` Disable IPv6 operations in all future network interfaces. The following values are supported: - `true`: disable IPv6. - `false`: enable IPv6. |
| `net.netfilter.nf_conntrack_max` *optional* | `integer` *Requires GKE version 1.33.4-gke.1036000 or later* The size of connection tracking table. The value must be between `65536` and `4194304`. |
| `net.netfilter.nf_conntrack_buckets` *optional* | `integer` *Requires GKE version 1.33.4-gke.1036000 or later* The size of hash table for connection tracking. The value must be between `65536` and `524288`. Recommend setting: `nf_conntrack_max = nf_conntrack_buckets * 4` |
| `net.netfilter.nf_conntrack_tcp_timeout_close_wait` *optional* | `integer` *Requires GKE version 1.33.4-gke.1036000 or later* The period for which the TCP connections can remain in the CLOSE_WAIT state, and stay in the table. The value must be between `60` and `3600`. |
| `net.netfilter.nf_conntrack_tcp_timeout_time_wait` *optional* | `integer` *Requires GKE version 1.33.4-gke.1036000 or later* The period for which the TCP connections can remain in the TIME_WAIT state, and stay in the table. The value must be between `1` and `600`. |
| `net.netfilter.nf_conntrack_tcp_timeout_established` *optional* | `integer` *Requires GKE version 1.33.4-gke.1036000 or later* The duration of dead connections before the connections are automatically deleted from connection tracking table. The value must be between `600` and `86400`. |
| `net.netfilter.nf_conntrack_acct` *optional* | `boolean` *Requires GKE version 1.33.4-gke.1036000 or later* Whether to enable connection tracking flow accounting. The value must be `true` or `false`. |
| `vm.max_map_count` *optional* | `integer` Limit the number of distinct memory regions that a process can map into its address space. You might need to increase this value for applications that require a large number of shared libraries or that perform extensive memory mapping. The value must be between `65536` and `2147483647`. |
| `vm.dirty_background_bytes` *optional* | `integer` *Requires GKE version 1.36.0-gke.2684000 or later* The amount of dirty memory (in bytes) at which the background writeback daemon will start writing dirty data to disk. The value must be between `0` and `68719476736` (64 GiB). Only one of `dirty_background_bytes` or `dirty_background_ratio` can be specified. |
| `vm.dirty_background_ratio` *optional* | `integer` *Requires GKE version 1.33.4-gke.1036000 or later* Percentage of system memory that can be filled with dirty pages (modified but not yet written to disk) before background kernel flusher threads begin writeback. This value should be less than `vm.dirty_ratio`. The value must be between `1` and `100`. |
| `vm.dirty_bytes` *optional* | `integer` *Requires GKE version 1.36.0-gke.2684000 or later* The amount of dirty memory (in bytes) at which a process generating writes will itself start writing out dirty data. The value must be between `0` and `68719476736` (64 GiB). Only one of `dirty_bytes` or `dirty_ratio` can be specified. |
| `vm.dirty_expire_centisecs` *optional* | `integer` *Requires GKE version 1.33.4-gke.1036000 or later* Maximum age (in hundredths of a second) that dirty data can remain in memory before kernel flusher threads write it to disk. Lower values result in faster, more frequent writebacks. The value must be between `0` and `6000`. |
| `vm.dirty_ratio` *optional* | `integer` *Requires GKE version 1.33.4-gke.1036000 or later* Percentage of system memory that can be filled with dirty pages before processes that perform writes are forced to block and write out dirty data synchronously. This value should be greater than `vm.dirty_background_ratio`. The value must be between `1` and `100`. |
| `vm.dirty_writeback_centisecs` *optional* | `integer` *Requires GKE version 1.33.4-gke.1036000 or later* Interval (in hundredths of a second) at which kernel flusher threads wake up to write 'old' dirty data to disk. The value must be between `0` and `1000`. |
| `vm.overcommit_memory` *optional* | `integer` *Requires GKE version 1.33.4-gke.1036000 or later* Determines the kernel's strategy for handling memory overcommitment. The following values are supported: - `0`: Rejects allocations that are obviously too large. - `1` (default value): Allows overcommit until memory is exhausted. - `2`: Prevents overcommit beyond swap space plus a percentage of RAM defined by `vm.overcommit_ratio`. This setting isn't supported on machines with less than 15 GB memory. |
| `vm.overcommit_ratio` *optional* | `integer` *Requires GKE version 1.33.4-gke.1036000 or later* Specifies the percentage of physical RAM allowed for overcommit when `vm.overcommit_memory` is set to `2`. The total committed address space cannot exceed swap plus this RAM percentage. The value must be between `0` and `100`. |
| `vm.vfs_cache_pressure` *optional* | `integer` *Requires GKE version 1.33.4-gke.1036000 or later* Adjusts the kernel's preference for reclaiming memory used for dentry (directory) and inode caches. The value must be between `0` and `100`. |
| `vm.min_free_kbytes` *optional* | `integer` *Requires GKE version 1.34.1-gke.3084001 or later* Minimum free memory before OOM. The value must be between `67584` and `1048576`. |
| `vm.swappiness` *optional* | `integer` *Requires GKE version 1.34.1-gke.3084001 or later* Controls the tendency of the kernel to move processes out of physical memory and onto the swap disk. The value must be between `0` and `200`. |
| `vm.watermark_scale_factor` *optional* | `integer` *Requires GKE version 1.34.1-gke.3084001 or later* Controls the aggressiveness of kswapd. The flag defines the amount of memory left in a node before kswapd is woken up and how much memory needs to be freed before kswapd goes back to sleep. The value must be between `10` and `3000`. |
| `fs.aio-max-nr` *optional* | `integer` *Requires GKE version 1.33.4-gke.1036000 or later* The maximum system-wide number of asynchronous io requests. The value must be between `65536` and `4194304`. |
| `fs.file-max` *optional* | `integer` *Requires GKE version 1.33.4-gke.1036000 or later* Maximum number of file-handles that the Linux kernel can allocate. The value must be between `104857` and `67108864`. |
| `fs.inotify.max_user_instances` *optional* | `integer` *Requires GKE version 1.33.4-gke.1036000 or later* The maximum number of inotify instances that a user can create. The value must be between `8192` and `1048576`. |
| `fs.inotify.max_user_watches` *optional* | `integer` *Requires GKE version 1.33.4-gke.1036000 or later* The maximum number of inotify watches that a user can create. The value must be between `8192` and `1048576`. |
| `fs.nr_open` *optional* | `integer` *Requires GKE version 1.33.4-gke.1036000 or later* The maximum number of file descriptors that can be opened by a process. The value must be between `1048576` and `2147483584`. |

### `resourceManagerTags`

```yaml
resourceManagerTags:
- key: string
  value: string
```

| Fields ||
|---|---|
| `key` *required* | `string` The key of the resource manager tag. Can be in one of the following formats: - `tagKeys/TAG_KEY_ID` - `ORGANIZATION_ID/TAG_KEY_NAME` - `PROJECT_ID/TAG_KEY_NAME` |
| `value` *required* | `string` The value of the resource manager tag. Can be in one of the following formats: - `tagValues/TAG_VALUE_ID` - `TAG_VALUE_NAME` |

### `sandbox`

```yaml
sandbox:
  type: string
```

| Fields ||
|---|---|
| `type` *optional* | `string` Specifies the type of sandbox to use for the nodes. Supported values are as follows: - `gvisor`: use gVisor to run Pods in sandboxes. Requires GKE version 1.36.2-gke.1368000 or later. - `microvm`: use microVMs to run Pods in sandboxes. Requires GKE version 1.37.0-gke.4713000 or later. If you specify `microvm`, then you must also enable nested virtualization for the nodes by using the `enableNestedVirtualization: true` property in the [`priorities` field](https://docs.cloud.google.com/kubernetes-engine/docs/reference/crds/computeclass.md.txt#priorities) or in the [`priorityDefaults` field](https://docs.cloud.google.com/kubernetes-engine/docs/reference/crds/computeclass.md.txt#priorityDefaults). For more information about these sandbox types, see [About GKE Sandbox](https://docs.cloud.google.com/kubernetes-engine/docs/concepts/sandbox-pods.md.txt#sandbox_types). |

### `taintConfig`

```yaml
taintConfig:
  architectureTaintBehavior: string
```

| Fields ||
|---|---|
| `architectureTaintBehavior` *optional* | `string` Specifies the behavior of the architecture taint. If you omit this field, the default architecture taint behavior, with the value of `ARM`, is used. The following values are supported: - `ARM`: applies the architecture taint to Arm nodes. This is the default behavior. - `NONE`: does not apply the default Arm architecture taint to the nodes. |

### `shieldedInstanceConfig`

```yaml
shieldedInstanceConfig:
  enableSecureBoot: boolean
  enableIntegrityMonitoring: boolean
```

| Fields ||
|---|---|
| `enableSecureBoot` *optional* | `boolean` Controls whether Secure Boot is enabled for the nodes. Secure Boot helps verify the digital signature of all boot components to protect nodes against boot-level and kernel-level malware. In Standard mode clusters, the default value is `false` unless explicitly set to `true`. In Autopilot clusters, this property defaults to `true` and can't be disabled. For more information, see [Secure Boot](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/shielded-gke-nodes.md.txt#secure_boot). |
| `enableIntegrityMonitoring` *optional* | `boolean` Controls whether Integrity Monitoring is enabled for the nodes. Integrity Monitoring monitors and verifies the boot integrity of the nodes by using Secure Boot and virtual Trusted Platform Module (vTPM) measurements. In Standard mode clusters, the default value is `true` unless explicitly set to `false`. In Autopilot clusters, this property defaults to `true` and can't be disabled. For more information, see [Integrity Monitoring](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/shielded-gke-nodes.md.txt#integrity_monitoring). |

### `taints`

```yaml
taints:
- key: string
  value: string
  effect: string
```

| Fields ||
|---|---|
| `key` *required* | `string` The node taint key. The key can be up to 253 characters. It must begin with a letter or number, and can contain letters, numbers, hyphens, dots, and underscores. |
| `value` *optional* | `string` The value that matches the specified taint. |
| `effect` *optional* | `string` The value that defines the taint's effect on Pods that don't have the necessary toleration. For more information, see the Kubernetes documentation about [Taints and Tolerations](https://kubernetes.io/docs/concepts/scheduling-eviction/taint-and-toleration/#concepts). Supported values are as follows: - `NoSchedule` - `NoExecute` - `PreferNoSchedule` |

### `tpu`

```yaml
- tpu:
    count: integer
    topology: string
    type: string
```

| Fields ||
|---|---|
| `count` *required* | `integer` The number of TPUs to attach to the node. |
| `topology` *required* | `string` The [TPU topology](https://docs.cloud.google.com/kubernetes-engine/docs/concepts/plan-tpus.md.txt#topology) to use, such as `"2x2x1"`. |
| `type` *required* | `string` The [TPU type](https://docs.cloud.google.com/kubernetes-engine/docs/concepts/plan-tpus.md.txt#availability) to use, such as `tpu-v6e-slice`. |

## ComputeClass status

The `status` field is a list of status messages. This field is informational and
is updated by the Kubernetes API server and the kubelet on each node.

```yaml
status:
  conditions: [
    object(conditions)
  ]
  observedBuffers: [
    object(observedBuffers)
  ]
```

| Fields ||
|---|---|
| `conditions[]` | `object(conditions)` List of status conditions for the `ComputeClass` object. |
| `status.observedBuffers` | ` []object (observedBuffers) ` *Requires GKE version 1.37.1-gke.3020000 or later* The CapacityBuffers that GKE manages for this ComputeClass. |

### `conditions`

```yaml
conditions:
- type: string
  status: boolean
  reason: string
  message: string
  lastTransitionTime: string
  observedGeneration: integer
```

| Fields ||
|---|---|
| `type` | `string` The type of condition, which helps to organize status messages. |
| `status` | `string` The status of the condition. The value is one of the following: - `True` - `False` - `Unknown` |
| `reason` | `string` A machine-readable reason why a specific condition type made its most recent transition. For the reasons that GKE reports on the `BuffersConfigured` condition, see [Check `BuffersConfigured` condition reasons](https://docs.cloud.google.com/kubernetes-engine/docs/troubleshooting/custom-computeclass.md.txt#buffersconfigured-condition). |
| `message` | `string` A human-readable message that provides details about the most recent transition. This field might be empty. |
| `lastTransitionTime` | `string` The timestamp of the most recent change to the condition. |
| `observedGeneration` | `integer` A count of how many times the ComputeClass controller observed a change to the `ComputeClass` object. The controller attempts to reconcile the value in this field with the value in the `metadata.generation` field, which the Kubernetes API server updates whenever a change is made to the `ComputeClass` API object. |

### `observedBuffers`

The `observedBuffers` field lists the CapacityBuffers that GKE
manages for this ComputeClass.

```yaml
observedBuffers:
- name: string
  namespace: string
  conditions: [
    object(conditions)
  ]
```

| Fields ||
|---|---|
| `status.observedBuffers[].name` | `string` The name of the managed CapacityBuffer. |
| `status.observedBuffers[].namespace` | `string` The namespace of the managed CapacityBuffer (the `gke-managed-ccc` namespace). |
| `status.observedBuffers[].conditions` | ` []object (conditions) ` The status conditions for this individual buffer. For built-in provisioning strategies, GKE mirrors the `ReadyForProvisioning` and `Provisioning` conditions from the managed CapacityBuffer. When the buffer specifies a custom provisioning strategy, GKE reports the `CustomProvisioningStrategy` condition. Each condition object contains the `type`, `status`, `reason`, `message`, `lastTransitionTime`, and `observedGeneration` fields described in the [`conditions` section](https://docs.cloud.google.com/kubernetes-engine/docs/reference/crds/computeclass.md.txt#conditions). |

## What's next

- [Learn about best practices for ComputeClasses](https://docs.cloud.google.com/kubernetes-engine/docs/best-practices/computeclasses.md.txt)
- [Configure capacity buffers in custom ComputeClasses](https://docs.cloud.google.com/kubernetes-engine/docs/how-to/configure-capacity-buffers-compute-classes.md.txt)