Struct SpreadRule 

pub struct SpreadRule {
    pub topology_key: String,
    pub max_skew: Option<i32>,
    pub when_unsatisfiable: Option<WhenUnsatisfiable>,
    pub scope: Option<SpreadScope>,
    pub min_domains: Option<i32>,
    pub node_affinity_policy: Option<NodeInclusionPolicy>,
    pub node_taints_policy: Option<NodeInclusionPolicy>,
}

A single topology spread rule.

Each rule becomes exactly one entry in the Pod’s spec.topologySpreadConstraints, with the labelSelector generated from SpreadScope rather than written by hand — users have no way to know the operator’s internal Pod labels, and getting the selector wrong silently produces a constraint that does nothing.

Example

spread:
  # Spread primaries across zones first — hard requirement.
  - topologyKey: topology.kubernetes.io/zone
    maxSkew: 1
    whenUnsatisfiable: DoNotSchedule
    scope: Role
  # Then, within a zone, prefer separate nodes.
  - topologyKey: kubernetes.io/hostname
    maxSkew: 1
    whenUnsatisfiable: ScheduleAnyway
    scope: Role

Fields

topology_key: String

Node label key that defines the failure domain.

Nodes sharing a value for this label are in the same domain. Any node label works, which is the point: clusters that do not use the well-known zone label can spread across whatever they do use.

Examples:

• topology.kubernetes.io/zone - availability zone (the usual choice)
• topology.kubernetes.io/region - region, for multi-region clusters
• kubernetes.io/hostname - individual nodes
• failure-domain.acme.io/rack - a custom, on-prem failure domain
• karpenter.sh/capacity-type - spot vs. on-demand capacity

Must be a valid Kubernetes qualified name, matching what the API server accepts for a node label key: an optional lowercase RFC 1123 subdomain prefix of at most 253 characters, a /, and a name segment of at most 63 characters. The maximum overall length is therefore 317.

The 253-character prefix cap is enforced by an x-kubernetes-validations rule on the parent rule rather than by the pattern below: CRD patterns are RE2, which has no lookahead, so a length bound on a variable-length prefix cannot be expressed in the regex itself.

max_skew: Option<i32>

Maximum permitted difference in Pod count between any two domains.

Default: 1 (the tightest useful value — every domain is filled before any domain doubles up).

when_unsatisfiable: Option<WhenUnsatisfiable>

What the scheduler does when the rule cannot be satisfied.

Default: ScheduleAnyway (soft). The operator defaults to soft deliberately: a hard constraint turns a single-zone cluster, or a zone outage, into Pending DNS Pods — trading an availability problem for a total outage. Set DoNotSchedule only when you know the cluster has at least as many domains as you have replicas.

scope: Option<SpreadScope>

Which Pods this rule balances. See SpreadScope.

Default: Role for a cluster-managed instance (spread all primaries of the cluster across zones), Instance for a standalone Bind9Instance (spread that instance’s own replicas).

The default is almost always what you want. Override it only when you deliberately want primaries and secondaries balanced together (Cluster), or want to opt a multi-replica standalone instance out of cluster-wide balancing (Instance).

min_domains: Option<i32>

Minimum number of domains that must be eligible.

Only meaningful together with whenUnsatisfiable: DoNotSchedule. When fewer than minDomains domains exist, the constraint is treated as unsatisfiable. Use it to fail loudly rather than silently running all your nameservers in one zone.

node_affinity_policy: Option<NodeInclusionPolicy>

Whether the Pod’s node affinity / node selector is honoured when counting domains.

Default: Honor (the Kubernetes default). Ignore counts every node, including ones this Pod could never be scheduled onto.

node_taints_policy: Option<NodeInclusionPolicy>

Whether node taints are honoured when counting domains.

Default: Ignore (the Kubernetes default).

Trait Implementations

impl Clone for SpreadRule

fn clone(&self) -> SpreadRule

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SpreadRule

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SpreadRule

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for SpreadRule

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for SpreadRule

fn eq(&self, other: &SpreadRule) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for SpreadRule

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for SpreadRule

impl StructuralPartialEq for SpreadRule