---
updatedAt: 2026-10-28T15:16:38.000Z
agentTools:
  projectIndex: https://docs.cast.ai/llms.txt
---

# Gets rebalancing constraints for a cluster.

Gets rebalancing constraints for a cluster.
 This helps the UI show what can/cannot be rebalanced before creating a plan.

# OpenAPI definition

```json
{
  "openapi": "3.0.3",
  "servers": [
    {
      "url": "https://api.cast.ai/",
      "description": "US endpoint"
    },
    {
      "url": "https://api.eu.cast.ai/",
      "description": "EU endpoint"
    },
    {
      "url": "https://api.india.cast.ai/",
      "description": "India endpoint"
    }
  ],
  "info": {
    "title": "Kent",
    "version": "0.0.1"
  },
  "security": [
    {
      "BearerAuth": []
    },
    {
      "ApiKeyAuth": []
    }
  ],
  "paths": {
    "/kent/v1alpha/organizations/{organizationId}/clusters/{clusterId}/rebalancing-constraints": {
      "get": {
        "tags": [
          "RebalancingAPI"
        ],
        "summary": "Gets rebalancing constraints for a cluster.",
        "description": "Gets rebalancing constraints for a cluster.\n This helps the UI show what can/cannot be rebalanced before creating a plan.",
        "operationId": "RebalancingAPI_GetRebalancingConstraints",
        "parameters": [
          {
            "name": "organizationId",
            "in": "path",
            "description": "The ID of the Organization.",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "clusterId",
            "in": "path",
            "description": "The ID of the cluster.",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "aggressiveModeConfig.ignoreLocalPersistentVolumes",
            "in": "query",
            "description": "Rebalance workloads that use local-path Persistent Volumes.\n WARNING: THIS WILL RESULT IN DATA LOSS.",
            "schema": {
              "type": "boolean"
            }
          },
          {
            "name": "aggressiveModeConfig.ignoreProblemJobPods",
            "in": "query",
            "description": "Pods spawned by Jobs or CronJobs will not prevent the Rebalancer from deleting a node on which they run.\n WARNING: When true, pods spawned by Jobs or CronJobs will be terminated if the Rebalancer picks a node that runs them.\n As such, they are likely to lose their progress.",
            "schema": {
              "type": "boolean"
            }
          },
          {
            "name": "aggressiveModeConfig.ignoreProblemRemovalDisabledPods",
            "in": "query",
            "description": "Pods that are marked with \"removal disabled\" will not prevent the Rebalancer from deleting a node on which they run.\n WARNING: When true, such pods will be evicted and disrupted.",
            "schema": {
              "type": "boolean"
            }
          },
          {
            "name": "aggressiveModeConfig.ignoreProblemPodsWithoutController",
            "in": "query",
            "description": "Pods that don't have a controller (bare pods) will not prevent the Rebalancer from deleting a node on which they run.\n WARNING: When true, such pods might not restart, since they have no controller to do it.",
            "schema": {
              "type": "boolean"
            }
          },
          {
            "name": "aggressiveModeConfig.ignoreInstanceCriteria",
            "in": "query",
            "description": "Ignore instance criteria constraints from node pools during rebalancing.\n When true, removes requirements that constrain instance types by name patterns\n (instance-category, instance-family, instance-generation, instance-size, instance-cpu, instance-memory).\n This allows the rebalancer to select from a broader range of instance types.",
            "schema": {
              "type": "boolean"
            }
          },
          {
            "name": "aggressiveModeConfig.aggressiveEviction",
            "in": "query",
            "description": "Use aggressive eviction of NodeClaims which could block rebalancing plan execution\n When true, NodeClaims and pods on them will be forcefully deleted after a default or specified\n time interval has passed",
            "schema": {
              "type": "boolean"
            }
          },
          {
            "name": "aggressiveModeConfig.drainTimeoutSeconds",
            "in": "query",
            "description": "drain_timeout_seconds specifies the maximum time allowed for draining nodes during aggressive eviction.\n OPTIONAL: If not specified (0), nodes drain indefinitely (graceful drain).\n When specified, valid range: 60-3600 seconds (1 minute to 1 hour).\n (-- api-linter: core::0142::time-field-type=disabled\n     aip.dev/not-precedent: Using plain int64 seconds for simpler REST API client usage. --)",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "aggressiveModeConfig.ignoreBlockingPdb",
            "in": "query",
            "description": "Ignore pods blocked by PodDisruptionBudgets with 0 disruptions allowed.\n WARNING: May violate PDB guarantees during eviction.",
            "schema": {
              "type": "boolean"
            }
          },
          {
            "name": "aggressiveModeConfig.ignoreZeroNodePoolDisruptionBudgets",
            "in": "query",
            "description": "Ignore NodePool disruption budgets that allow 0 disruptions.\n When true, overrides zero-disruption NodePool budgets with the default 10% safety budget\n so rebalancing can proceed.\n WARNING: May violate NodePool disruption budget guarantees.",
            "schema": {
              "type": "boolean"
            }
          },
          {
            "name": "aggressiveModeConfig.ignoreProblemRemovalDisabledNodes",
            "in": "query",
            "description": "Nodes that are marked with \"removal disabled\" or \"do-not-disrupt\" annotations/labels\n will not prevent the Rebalancer from deleting them.\n WARNING: When true, such nodes will be disrupted despite their protection annotations.",
            "schema": {
              "type": "boolean"
            }
          },
          {
            "name": "aggressiveModeConfig.ignoreConsolidatable",
            "in": "query",
            "description": "When true, bypasses the Karpenter Consolidatable condition check during node\n candidate selection. Nodes that Karpenter has not yet marked as consolidatable\n (e.g. the ConsolidateAfter time window has not elapsed) will still be considered\n for rebalancing.\n WARNING: May disrupt nodes before Karpenter's own consolidation timing.",
            "schema": {
              "type": "boolean"
            }
          },
          {
            "name": "aggressiveModeConfig.ignoreBlockingPdbTimeout",
            "in": "query",
            "description": "ignore_blocking_pdb_timeout specifies how long to wait before force-deleting PDB-blocked pods.\n OPTIONAL: If not specified, defaults to 10m. When specified, must be a positive duration.\n (-- api-linter: core::0142::time-field-type=disabled\n     aip.dev/not-precedent: Using google.protobuf.Duration for consistency with kentroller proto. --)",
            "schema": {
              "pattern": "^-?(?:0|[1-9][0-9]{0,11})(?:\\.[0-9]{1,9})?s$",
              "type": "string",
              "description": "Represents a duration between -315,576,000,000s and 315,576,000,000s (around 10000 years). Precision is in nanoseconds. 1 nanosecond is represented as 0.000000001s"
            }
          },
          {
            "name": "aggressiveModeConfig.ignoreProblemRemovalDisabledPodsTimeout",
            "in": "query",
            "description": "ignore_problem_removal_disabled_pods_timeout specifies how long to wait before force-deleting\n pods marked karpenter.sh/do-not-disrupt=true on nodes being drained by a rebalancing plan.\n OPTIONAL: If not specified, defaults to 10m. When specified, must be a positive duration.\n (-- api-linter: core::0142::time-field-type=disabled\n     aip.dev/not-precedent: Using google.protobuf.Duration for consistency with kentroller proto. --)",
            "schema": {
              "pattern": "^-?(?:0|[1-9][0-9]{0,11})(?:\\.[0-9]{1,9})?s$",
              "type": "string",
              "description": "Represents a duration between -315,576,000,000s and 315,576,000,000s (around 10000 years). Precision is in nanoseconds. 1 nanosecond is represented as 0.000000001s"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "OK",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/RebalancingConstraints"
                }
              }
            }
          },
          "default": {
            "description": "Default error response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Status"
                }
              }
            }
          }
        }
      }
    }
  },
  "components": {
    "securitySchemes": {
      "BearerAuth": {
        "type": "http",
        "scheme": "bearer",
        "bearerFormat": "JWT"
      },
      "ApiKeyAuth": {
        "type": "apiKey",
        "in": "header",
        "name": "X-API-Key"
      }
    },
    "schemas": {
      "GoogleProtobufAny": {
        "type": "object",
        "properties": {
          "@type": {
            "type": "string",
            "description": "The type of the serialized message."
          }
        },
        "additionalProperties": true,
        "description": "Contains an arbitrary serialized message along with a @type that describes the type of the serialized message."
      },
      "ProblematicNode": {
        "type": "object",
        "properties": {
          "providerId": {
            "readOnly": true,
            "type": "string",
            "description": "The provider ID of the node (cloud provider's identifier, e.g., AWS instance ID)."
          },
          "nodeName": {
            "readOnly": true,
            "type": "string",
            "description": "The name of the node."
          },
          "problems": {
            "readOnly": true,
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "List of problems preventing this node from being rebalanced."
          }
        },
        "description": "Represents a node that prevents rebalancing."
      },
      "ProblematicWorkload": {
        "type": "object",
        "properties": {
          "name": {
            "readOnly": true,
            "type": "string",
            "description": "The name of the workload."
          },
          "namespace": {
            "readOnly": true,
            "type": "string",
            "description": "The namespace of the workload."
          },
          "kind": {
            "readOnly": true,
            "type": "string",
            "description": "The Kubernetes resource kind (Deployment, StatefulSet, DaemonSet, etc.)."
          },
          "problems": {
            "readOnly": true,
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "List of problems preventing this workload from being rebalanced."
          }
        },
        "description": "Represents a workload that prevents rebalancing."
      },
      "RebalancingConstraints": {
        "type": "object",
        "properties": {
          "canRebalance": {
            "readOnly": true,
            "type": "boolean",
            "description": "Whether the cluster can be rebalanced at all."
          },
          "problematicWorkloads": {
            "readOnly": true,
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/ProblematicWorkload"
            },
            "description": "List of problematic workloads that prevent rebalancing."
          },
          "problematicNodes": {
            "readOnly": true,
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/ProblematicNode"
            },
            "description": "List of problematic nodes that prevent rebalancing."
          },
          "totalWorkloads": {
            "readOnly": true,
            "type": "integer",
            "description": "Total number of workloads in the cluster.",
            "format": "int32"
          },
          "totalNodes": {
            "readOnly": true,
            "type": "integer",
            "description": "Total number of nodes in the cluster.",
            "format": "int32"
          }
        },
        "description": "Information about rebalancing constraints for a cluster."
      },
      "Status": {
        "type": "object",
        "properties": {
          "code": {
            "type": "integer",
            "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code].",
            "format": "int32"
          },
          "message": {
            "type": "string",
            "description": "A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the [google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client."
          },
          "details": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/GoogleProtobufAny"
            },
            "description": "A list of messages that carry the error details.  There is a common set of message types for APIs to use."
          }
        },
        "description": "The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors)."
      }
    }
  },
  "tags": [
    {
      "name": "RebalancingAPI",
      "description": "Provides an API to manage cluster rebalancing operations in Karpenter-managed clusters.\n This API simplifies the creation and management of rebalancing plans that optimize\n node configurations for cost and resource efficiency."
    }
  ]
}
```