create

{              
  "metadata": {                // [required]
    "labels": {                // [map]
                               // Labels associated with the resource.
      string: string                  
    },
    "name": string,            // Human readable name for the resource.
    "parent_id": string,       // [required]
                               // Identifier of the parent resource to which the resource belongs.
    "resource_version": int64  // Version of the resource for safe concurrent modifications and consistent reads.
                               // Positive and monotonically increases on each resource spec change (but *not* on each change of the
                               // resource's container(s) or status).
                               // Service allows zero value or current.
  },
  "spec": {                    // [required]
    "auto_repair": {   // Parameters for nodes auto repair.
      "conditions": [{         // Conditions that determine whether a node should be auto repaired.
        "disabled": bool,      // Cannot be set together with: timeout
                               // When true, disables the default auto-repair condition rules.
        "status": enum(                   // Node condition status.
          "CONDITION_STATUS_UNSPECIFIED",
          "TRUE",                        
          "FALSE",                       
          "UNKNOWN"                      
        ),
        "timeout": "2h30m10s", // [google.protobuf.Duration]
                               // Cannot be set together with: disabled
                               // The duration after which the node is automatically repaired if the condition remains in the specified status.
        "type": string         // [required]
                               // Node condition type.
      }]
    },
    "autoscaling": {           // Cannot be set together with: fixed_node_count
                               // Enables [Kubernetes Cluster Autoscaler](https://github.com/kubernetes/autoscaler/tree/master/cluster-autoscaler)
                               // for that NodeGroup, and defines autoscaling parameters.
      "max_node_count": int64,
      "min_node_count": int64 
    },
    "fixed_node_count": int64, // Cannot be set together with: autoscaling
                               // Number of nodes in the group. Can be changed manually at any time.
    "strategy": {                  // Defines deployment - roll-out, or nodes re-creation during configuration change.
                                   // Allows to setup compromise in roll-out speed, extra resources consumption and workloads disruption.
      "drain_timeout": "2h30m10s", // [google.protobuf.Duration]
                                   // Maximum amount of time that the service will spend on attempting gracefully draining a node (evicting it's pods), before
                                   // falling back to pod deletion.
                                   // By default, node can be drained unlimited time.
                                   // Important consequence of that is if PodDisruptionBudget doesn't allow to evict a pod,
                                   // then NodeGroup update with node re-creation will hung on that pod eviction.
                                   // Note, that it is different from `kubectl drain --timeout`.
      "max_surge": {      // The maximum number of additional nodes that can be provisioned above the desired number of nodes during the update process.
                          // 
                          // This value can be specified either as an absolute number (for example 3) or as a percentage of the desired
                          // number of nodes (for example 5%).
                          // 
                          // When specified as a percentage, the actual number is calculated by rounding up to the nearest whole number.
                          // This value cannot be 0 if `max_unavailable` is also set to 0.
                          // 
                          // Defaults to 1.
                          // 
                          // Example: If set to 25%, the node group can scale up by an additional 25% during the update,
                          // allowing new nodes to be added before old nodes are removed, which helps minimize workload disruption.
                          // 
                          // NOTE:
                          // 
                          // it is user responsibility to ensure that there are enough quota for provision nodes above the desired number.
                          // Available quota effectively limits `max_surge`.
                          // In case of not enough quota even for one extra node, update operation will hung because of quota exhausted error.
                          // Such error will be visible in Operation.progress_data.
        "count": int64,   // Cannot be set together with: percent
        "percent": int64  // Cannot be set together with: count
      },
      "max_unavailable": { // The maximum number of nodes that can be simultaneously unavailable during the update process.
                           // 
                           // This value can be specified either as an absolute number (for example 3) or as a percentage of the desired
                           // number of nodes (for example 5%).
                           // 
                           // When specified as a percentage, the actual number is calculated by rounding down to the nearest whole number.
                           // This value cannot be 0 if `max_surge` is also set to 0.
                           // 
                           // Defaults to 0.
                           // 
                           // Example: If set to 20%, up to 20% of the nodes can be taken offline at once during the update,
                           // ensuring that at least 80% of the desired nodes remain operational.
        "count": int64,    // Cannot be set together with: percent
        "percent": int64   // Cannot be set together with: count
      }
    },
    "template": {                     // [required]
                                      // Parameters for Kubernetes Node object and Nebius Compute Instance
                                      // If not written opposite a NodeTemplate field update will cause NodeGroup roll-out according NodeGroupDeploymentStrategy.
      "boot_disk": {               // [non_empty_default]
                                   // Parameters of a Node Nebius Compute Instance boot disk.
        "block_size_bytes": int64,
        "size_bytes": int64,       // Cannot be set together with: size_kibibytes, size_mebibytes, size_gibibytes
        "size_gibibytes": int64,   // Cannot be set together with: size_bytes, size_kibibytes, size_mebibytes
        "size_kibibytes": int64,   // Cannot be set together with: size_bytes, size_mebibytes, size_gibibytes
        "size_mebibytes": int64,   // Cannot be set together with: size_bytes, size_kibibytes, size_gibibytes
        "type": enum(                   // [non_empty_default]
          "UNSPECIFIED",               
          "NETWORK_SSD",               
          "NETWORK_HDD",               
          "NETWORK_SSD_IO_M3",         
          "NETWORK_SSD_NON_REPLICATED" 
        )
      },
      "cloud_init_user_data": string, // [sensitive]
                                      // Cloud-init user-data
                                      // Should contain at least one SSH key.
      "filesystems": [{          // Static attachments of Compute Filesystem.
                                 // Can be used as a workaround, until CSI for Compute Disk and Filesystem will be available.
        "attach_mode": enum( // [required]
          "UNSPECIFIED",    
          "READ_ONLY",      
          "READ_WRITE"      
        ),
        "existing_filesystem": {
          "id": string           // [required]
        },
        "mount_tag": string      // [required]
                                 // Specifies the user-defined identifier, allowing to use it as a device in mount command.
      }],
      "gpu_cluster": { // Nebius Compute GPUCluster ID that will be attached to node.
        "id": string  
      },
      "gpu_settings": {           // GPU-related settings.
        "drivers_preset": string  // [required]
                                  // Identifier of the predefined set of drivers included in the ComputeImage deployed on ComputeInstances that are part of the NodeGroup.
                                  // Supported presets for different platform / Kubernetes version combinations:
                                  // * `gpu-l40s-a`, `gpu-l40s-d`, `gpu-h100-sxm`, `gpu-h200-sxm`:
                                  //   * `version`: 1.30 → `"cuda12"` (CUDA 12.4)
                                  //   * `version`: 1.31 → `"cuda12"` (CUDA 12.4), `"cuda12.4"`, `"cuda12.8"`
                                  // * `gpu-b200-sxm`:
                                  //   * `version`: 1.31 → `"cuda12"` (CUDA 12.8), `"cuda12.8"`
                                  // * `gpu-b200-sxm-a`:
                                  //   * `version`: 1.31 → `"cuda12.8"`.
      },
      "local_disks": {         // Local_disks enables the provisioning of fast local drives.
                               // This type of storage is strictly ephemeral: on node restart, all data is erased, similar to RAM.
        "config": {     // [required]
                        // Config defines actions that managed Kubernetes service performs on mounted local disks
                        // to provide them inside Kubernetes cluster with a convenient interface.
          "none": bool  // None: "do nothing" - local disks will be provisioned as on a regular compute instance.
        },
        "passthrough_group": { // Requests passthrough local disks from the host.
                               // Topology of the provided disks is preserved during stop and start
                               // for every instance of a specific platform and preset in the region.
          "requested": bool    // Passthrough local disks from the underlying host.
                               // 
                               // Devices are expected to appear in the guest as NVMe devices (nvme0, nvme1, ...),
                               // but the exact number depends on the preset.
                               // Enabled only when this field is explicitly set.
        }
      },
      "metadata": {
        "labels": {        // [map]
                           // Kubernetes Node labels.
                           // 
                           // Keys and values must follow Kubernetes label syntax:
                           // https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/
                           // 
                           // For now change will not be propagated to existing nodes, so will be applied only to Kubernetes Nodes created after the field change.
                           // That behavior may change later.
                           // So, for now you will need to manually set them to existing nodes, if that is needed.
                           // 
                           // System labels containing "kubernetes.io" and "k8s.io" will be ignored.
                           // Field change will NOT trigger NodeGroup roll out.
          string: string          
        }
      },
      "network_interfaces": [{ // [non_empty_default]
        "public_ip_address": { // [meaningful_empty_value]
                               // Parameters for Public IPv4 address associated with the interface.
                               // Set to empty value, to enable it.
        },
        "subnet_id": string    // [non_empty_default]
                               // Nebius VPC Subnet ID that will be attached to a node cloud instance network interface.
                               // By default Cluster control plane subnet_id used.
                               // Subnet should be located in the same network with control plane.
      }],
      "os": string,                   // OS version that will be used to create the boot disk of Compute Instances in the NodeGroup.
                                      // Supported platform / Kubernetes version / OS / driver presets combinations
                                      // * `gpu-l40s-a`, `gpu-l40s-d`, `gpu-h100-sxm`, `gpu-h200-sxm`, `cpu-e1`, `cpu-e2`, `cpu-d3`:
                                      //   * `drivers_preset`: `""`
                                      //     * `version`: 1.30 → `"ubuntu22.04"`
                                      //     * `version`: 1.31 → `"ubuntu22.04"` (default), `"ubuntu24.04"`
                                      // * `gpu-l40s-a`, `gpu-l40s-d`, `gpu-h100-sxm`, `gpu-h200-sxm`:
                                      //   * `drivers_preset`: `"cuda12"` (CUDA 12.4)
                                      //     * `version`: 1.30, 1.31 → `"ubuntu22.04"`
                                      //   * `drivers_preset`: `"cuda12.4"`
                                      //     * `version`: 1.31 → `"ubuntu22.04"`
                                      //   * `drivers_preset`: `"cuda12.8"`
                                      //     * `version`: 1.31 → `"ubuntu24.04"`
                                      // * `gpu-b200-sxm`:
                                      //   * `drivers_preset`: `""`
                                      //     * `version`: 1.30, 1.31 → `"ubuntu24.04"`
                                      //   * `drivers_preset`: `"cuda12"` (CUDA 12.8)
                                      //     * `version`: 1.30, 1.31 → `"ubuntu24.04"`
                                      //   * `drivers_preset`: `"cuda12.8"`
                                      //     * `version`: 1.31 → `"ubuntu24.04"`
                                      // * `gpu-b200-sxm-a`:
                                      //   * `drivers_preset`: `""`
                                      //     * `version`: 1.31 → `"ubuntu24.04"`
                                      //   * `drivers_preset`: `"cuda12.8"`
                                      //     * `version`: 1.31 → `"ubuntu24.04"`.
      "preemptible": { // [meaningful_empty_value]
                       // Configures whether the nodes in the group are preemptible.
                       // Set to empty value to enable preemptible nodes.
      },
      "reservation_policy": {        // Reservation_policy is an interface of the "capacity block" (or "capacity block group") mechanism of Nebius Compute.
        "policy": enum(
          "AUTO",       // 1) Will try to launch instance in any reservation_ids if provided.
                        // 2) Will try to launch instance in any of the available capacity block.
                        // 3) Will try to launch instance in PAYG if 1 & 2 are not satisfied.
          "FORBID",     // The instance is launched only using on-demand (PAYG) capacity.
                        // No attempt is made to find or use a Capacity Block.
                        // It's an error to provide reservation_ids with policy = FORBID.
          "STRICT"      // 1) Will try to launch the instance in Capacity Blocks from reservation_ids if provided.
                        // 2) If reservation_ids are not provided will try to launch instance in suitable & available Capacity Block.
                        // 3) Fail otherwise.
        ),
        "reservation_ids": [string]  // Capacity block groups, order matters.
      },
      "resources": {        // [required]
                            // Resources that will have Nebius Compute Instance where Node kubelet will run.
        "platform": string, // [required]
        "preset": string   
      },
      "service_account_id": string,   // The Nebius service account whose credentials will be available on the nodes of the group.
                                      // With these credentials, it is possible to make `nebius` CLI or public API requests from the nodes
                                      // without the need for extra authentication.
                                      // This service account is also used to make requests to container registry.
                                      // 
                                      // `resource.serviceaccount.issueAccessToken` permission is required to use this field.
      "taints": [{       // Kubernetes Node taints.
                         // For now change will not be propagated to existing nodes, so will be applied only to Kubernetes Nodes created after the field change.
                         // That behaviour may change later.
                         // So, for now you will need to manually set them to existing nodes, if that is needed.
                         // Field change will NOT trigger NodeGroup roll out.
        "effect": enum(         // [required]
          "EFFECT_UNSPECIFIED",
          "NO_EXECUTE",        
          "NO_SCHEDULE",       
          "PREFER_NO_SCHEDULE" 
        ),
        "key": string,   // [required]
        "value": string  // [required]
      }]
    },
    "version": string          // Version is desired Kubernetes version of the cluster. For now only acceptable format is
                               // `<major>.<minor>` like "1.31". Option for patch version update will be added later.
                               // By default the cluster control plane `<major>.<minor>` version will be used.
  }
}