ndb-operator.yaml

---
apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
    annotations:
        controller-gen.kubebuilder.io/version: v0.11.3
    name: ndbclusters.mysql.oracle.com
spec:
    group: mysql.oracle.com
    names:
        categories:
            - all
        kind: NdbCluster
        listKind: NdbClusterList
        plural: ndbclusters
        shortNames:
            - ndb
            - ndbc
        singular: ndbcluster
    scope: Namespaced
    versions:
        - additionalPrinterColumns:
            - description: Replica of the MySQL Cluster
              jsonPath: .spec.redundancyLevel
              name: Replica
              type: string
            - description: Number of ready MySQL Cluster Management Nodes
              jsonPath: .status.readyManagementNodes
              name: Management Nodes
              type: string
            - description: Number of ready MySQL Cluster Data Nodes
              jsonPath: .status.readyDataNodes
              name: Data Nodes
              type: string
            - description: Number of ready MySQL Servers
              jsonPath: .status.readyMySQLServers
              name: MySQL Servers
              type: string
            - description: Age of the NdbCluster resource
              jsonPath: .metadata.creationTimestamp
              name: Age
              type: date
            - description: Indicates if the MySQL Cluster configuration is up-to-date with the spec specified in the NdbCluster resource
              jsonPath: .status.conditions[?(@.type=='UpToDate')].status
              name: Up-To-Date
              type: string
          name: v1
          schema:
            openAPIV3Schema:
                description: NdbCluster is the Schema for the Ndb CRD API
                properties:
                    apiVersion:
                        description: 'APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources'
                        type: string
                    kind:
                        description: 'Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds'
                        type: string
                    metadata:
                        type: object
                    spec:
                        description: The desired state of a MySQL NDB Cluster.
                        properties:
                            dataNode:
                                description: DataNode specifies the configuration of the data node running in MySQL Cluster.
                                properties:
                                    config:
                                        additionalProperties:
                                            anyOf:
                                                - type: integer
                                                - type: string
                                            x-kubernetes-int-or-string: true
                                        description: "Config is a map of default MySQL Cluster Data node configurations. \n More info : https://dev.mysql.com/doc/refman/8.0/en/mysql-cluster-params-ndbd.html"
                                        type: object
                                    ndbPodSpec:
                                        description: NdbPodSpec contains a subset of PodSpec fields which when set will be copied into to the podSpec of Data node's statefulset definition.
                                        properties:
                                            affinity:
                                                description: If specified, the pod's scheduling constraints
                                                properties:
                                                    nodeAffinity:
                                                        description: Describes node affinity scheduling rules for the pod.
                                                        properties:
                                                            preferredDuringSchedulingIgnoredDuringExecution:
                                                                description: The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.
                                                                items:
                                                                    description: An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).
                                                                    properties:
                                                                        preference:
                                                                            description: A node selector term, associated with the corresponding weight.
                                                                            properties:
                                                                                matchExpressions:
                                                                                    description: A list of node selector requirements by node's labels.
                                                                                    items:
                                                                                        description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                        properties:
                                                                                            key:
                                                                                                description: The label key that the selector applies to.
                                                                                                type: string
                                                                                            operator:
                                                                                                description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                                                                type: string
                                                                                            values:
                                                                                                description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.
                                                                                                items:
                                                                                                    type: string
                                                                                                type: array
                                                                                        required:
                                                                                            - key
                                                                                            - operator
                                                                                        type: object
                                                                                    type: array
                                                                                matchFields:
                                                                                    description: A list of node selector requirements by node's fields.
                                                                                    items:
                                                                                        description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                        properties:
                                                                                            key:
                                                                                                description: The label key that the selector applies to.
                                                                                                type: string
                                                                                            operator:
                                                                                                description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                                                                type: string
                                                                                            values:
                                                                                                description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.
                                                                                                items:
                                                                                                    type: string
                                                                                                type: array
                                                                                        required:
                                                                                            - key
                                                                                            - operator
                                                                                        type: object
                                                                                    type: array
                                                                            type: object
                                                                            x-kubernetes-map-type: atomic
                                                                        weight:
                                                                            description: Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.
                                                                            format: int32
                                                                            type: integer
                                                                    required:
                                                                        - preference
                                                                        - weight
                                                                    type: object
                                                                type: array
                                                            requiredDuringSchedulingIgnoredDuringExecution:
                                                                description: If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.
                                                                properties:
                                                                    nodeSelectorTerms:
                                                                        description: Required. A list of node selector terms. The terms are ORed.
                                                                        items:
                                                                            description: A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.
                                                                            properties:
                                                                                matchExpressions:
                                                                                    description: A list of node selector requirements by node's labels.
                                                                                    items:
                                                                                        description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                        properties:
                                                                                            key:
                                                                                                description: The label key that the selector applies to.
                                                                                                type: string
                                                                                            operator:
                                                                                                description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                                                                type: string
                                                                                            values:
                                                                                                description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.
                                                                                                items:
                                                                                                    type: string
                                                                                                type: array
                                                                                        required:
                                                                                            - key
                                                                                            - operator
                                                                                        type: object
                                                                                    type: array
                                                                                matchFields:
                                                                                    description: A list of node selector requirements by node's fields.
                                                                                    items:
                                                                                        description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                        properties:
                                                                                            key:
                                                                                                description: The label key that the selector applies to.
                                                                                                type: string
                                                                                            operator:
                                                                                                description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                                                                type: string
                                                                                            values:
                                                                                                description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.
                                                                                                items:
                                                                                                    type: string
                                                                                                type: array
                                                                                        required:
                                                                                            - key
                                                                                            - operator
                                                                                        type: object
                                                                                    type: array
                                                                            type: object
                                                                            x-kubernetes-map-type: atomic
                                                                        type: array
                                                                required:
                                                                    - nodeSelectorTerms
                                                                type: object
                                                                x-kubernetes-map-type: atomic
                                                        type: object
                                                    podAffinity:
                                                        description: Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).
                                                        properties:
                                                            preferredDuringSchedulingIgnoredDuringExecution:
                                                                description: The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.
                                                                items:
                                                                    description: The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)
                                                                    properties:
                                                                        podAffinityTerm:
                                                                            description: Required. A pod affinity term, associated with the corresponding weight.
                                                                            properties:
                                                                                labelSelector:
                                                                                    description: A label query over a set of resources, in this case pods.
                                                                                    properties:
                                                                                        matchExpressions:
                                                                                            description: matchExpressions is a list of label selector requirements. The requirements are ANDed.
                                                                                            items:
                                                                                                description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                                properties:
                                                                                                    key:
                                                                                                        description: key is the label key that the selector applies to.
                                                                                                        type: string
                                                                                                    operator:
                                                                                                        description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                                                        type: string
                                                                                                    values:
                                                                                                        description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
                                                                                                        items:
                                                                                                            type: string
                                                                                                        type: array
                                                                                                required:
                                                                                                    - key
                                                                                                    - operator
                                                                                                type: object
                                                                                            type: array
                                                                                        matchLabels:
                                                                                            additionalProperties:
                                                                                                type: string
                                                                                            description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                                                            type: object
                                                                                    type: object
                                                                                    x-kubernetes-map-type: atomic
                                                                                namespaceSelector:
                                                                                    description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces.
                                                                                    properties:
                                                                                        matchExpressions:
                                                                                            description: matchExpressions is a list of label selector requirements. The requirements are ANDed.
                                                                                            items:
                                                                                                description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                                properties:
                                                                                                    key:
                                                                                                        description: key is the label key that the selector applies to.
                                                                                                        type: string
                                                                                                    operator:
                                                                                                        description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                                                        type: string
                                                                                                    values:
                                                                                                        description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
                                                                                                        items:
                                                                                                            type: string
                                                                                                        type: array
                                                                                                required:
                                                                                                    - key
                                                                                                    - operator
                                                                                                type: object
                                                                                            type: array
                                                                                        matchLabels:
                                                                                            additionalProperties:
                                                                                                type: string
                                                                                            description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                                                            type: object
                                                                                    type: object
                                                                                    x-kubernetes-map-type: atomic
                                                                                namespaces:
                                                                                    description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                                                    items:
                                                                                        type: string
                                                                                    type: array
                                                                                topologyKey:
                                                                                    description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.
                                                                                    type: string
                                                                            required:
                                                                                - topologyKey
                                                                            type: object
                                                                        weight:
                                                                            description: weight associated with matching the corresponding podAffinityTerm, in the range 1-100.
                                                                            format: int32
                                                                            type: integer
                                                                    required:
                                                                        - podAffinityTerm
                                                                        - weight
                                                                    type: object
                                                                type: array
                                                            requiredDuringSchedulingIgnoredDuringExecution:
                                                                description: If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.
                                                                items:
                                                                    description: Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key <topologyKey> matches that of any node on which a pod of the set of pods is running
                                                                    properties:
                                                                        labelSelector:
                                                                            description: A label query over a set of resources, in this case pods.
                                                                            properties:
                                                                                matchExpressions:
                                                                                    description: matchExpressions is a list of label selector requirements. The requirements are ANDed.
                                                                                    items:
                                                                                        description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                        properties:
                                                                                            key:
                                                                                                description: key is the label key that the selector applies to.
                                                                                                type: string
                                                                                            operator:
                                                                                                description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                                                type: string
                                                                                            values:
                                                                                                description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
                                                                                                items:
                                                                                                    type: string
                                                                                                type: array
                                                                                        required:
                                                                                            - key
                                                                                            - operator
                                                                                        type: object
                                                                                    type: array
                                                                                matchLabels:
                                                                                    additionalProperties:
                                                                                        type: string
                                                                                    description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                                                    type: object
                                                                            type: object
                                                                            x-kubernetes-map-type: atomic
                                                                        namespaceSelector:
                                                                            description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces.
                                                                            properties:
                                                                                matchExpressions:
                                                                                    description: matchExpressions is a list of label selector requirements. The requirements are ANDed.
                                                                                    items:
                                                                                        description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                        properties:
                                                                                            key:
                                                                                                description: key is the label key that the selector applies to.
                                                                                                type: string
                                                                                            operator:
                                                                                                description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                                                type: string
                                                                                            values:
                                                                                                description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
                                                                                                items:
                                                                                                    type: string
                                                                                                type: array
                                                                                        required:
                                                                                            - key
                                                                                            - operator
                                                                                        type: object
                                                                                    type: array
                                                                                matchLabels:
                                                                                    additionalProperties:
                                                                                        type: string
                                                                                    description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                                                    type: object
                                                                            type: object
                                                                            x-kubernetes-map-type: atomic
                                                                        namespaces:
                                                                            description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                                            items:
                                                                                type: string
                                                                            type: array
                                                                        topologyKey:
                                                                            description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.
                                                                            type: string
                                                                    required:
                                                                        - topologyKey
                                                                    type: object
                                                                type: array
                                                        type: object
                                                    podAntiAffinity:
                                                        description: Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).
                                                        properties:
                                                            preferredDuringSchedulingIgnoredDuringExecution:
                                                                description: The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.
                                                                items:
                                                                    description: The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)
                                                                    properties:
                                                                        podAffinityTerm:
                                                                            description: Required. A pod affinity term, associated with the corresponding weight.
                                                                            properties:
                                                                                labelSelector:
                                                                                    description: A label query over a set of resources, in this case pods.
                                                                                    properties:
                                                                                        matchExpressions:
                                                                                            description: matchExpressions is a list of label selector requirements. The requirements are ANDed.
                                                                                            items:
                                                                                                description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                                properties:
                                                                                                    key:
                                                                                                        description: key is the label key that the selector applies to.
                                                                                                        type: string
                                                                                                    operator:
                                                                                                        description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                                                        type: string
                                                                                                    values:
                                                                                                        description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
                                                                                                        items:
                                                                                                            type: string
                                                                                                        type: array
                                                                                                required:
                                                                                                    - key
                                                                                                    - operator
                                                                                                type: object
                                                                                            type: array
                                                                                        matchLabels:
                                                                                            additionalProperties:
                                                                                                type: string
                                                                                            description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                                                            type: object
                                                                                    type: object
                                                                                    x-kubernetes-map-type: atomic
                                                                                namespaceSelector:
                                                                                    description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces.
                                                                                    properties:
                                                                                        matchExpressions:
                                                                                            description: matchExpressions is a list of label selector requirements. The requirements are ANDed.
                                                                                            items:
                                                                                                description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                                properties:
                                                                                                    key:
                                                                                                        description: key is the label key that the selector applies to.
                                                                                                        type: string
                                                                                                    operator:
                                                                                                        description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                                                        type: string
                                                                                                    values:
                                                                                                        description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
                                                                                                        items:
                                                                                                            type: string
                                                                                                        type: array
                                                                                                required:
                                                                                                    - key
                                                                                                    - operator
                                                                                                type: object
                                                                                            type: array
                                                                                        matchLabels:
                                                                                            additionalProperties:
                                                                                                type: string
                                                                                            description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                                                            type: object
                                                                                    type: object
                                                                                    x-kubernetes-map-type: atomic
                                                                                namespaces:
                                                                                    description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                                                    items:
                                                                                        type: string
                                                                                    type: array
                                                                                topologyKey:
                                                                                    description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.
                                                                                    type: string
                                                                            required:
                                                                                - topologyKey
                                                                            type: object
                                                                        weight:
                                                                            description: weight associated with matching the corresponding podAffinityTerm, in the range 1-100.
                                                                            format: int32
                                                                            type: integer
                                                                    required:
                                                                        - podAffinityTerm
                                                                        - weight
                                                                    type: object
                                                                type: array
                                                            requiredDuringSchedulingIgnoredDuringExecution:
                                                                description: If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.
                                                                items:
                                                                    description: Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key <topologyKey> matches that of any node on which a pod of the set of pods is running
                                                                    properties:
                                                                        labelSelector:
                                                                            description: A label query over a set of resources, in this case pods.
                                                                            properties:
                                                                                matchExpressions:
                                                                                    description: matchExpressions is a list of label selector requirements. The requirements are ANDed.
                                                                                    items:
                                                                                        description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                        properties:
                                                                                            key:
                                                                                                description: key is the label key that the selector applies to.
                                                                                                type: string
                                                                                            operator:
                                                                                                description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                                                type: string
                                                                                            values:
                                                                                                description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
                                                                                                items:
                                                                                                    type: string
                                                                                                type: array
                                                                                        required:
                                                                                            - key
                                                                                            - operator
                                                                                        type: object
                                                                                    type: array
                                                                                matchLabels:
                                                                                    additionalProperties:
                                                                                        type: string
                                                                                    description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                                                    type: object
                                                                            type: object
                                                                            x-kubernetes-map-type: atomic
                                                                        namespaceSelector:
                                                                            description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces.
                                                                            properties:
                                                                                matchExpressions:
                                                                                    description: matchExpressions is a list of label selector requirements. The requirements are ANDed.
                                                                                    items:
                                                                                        description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                        properties:
                                                                                            key:
                                                                                                description: key is the label key that the selector applies to.
                                                                                                type: string
                                                                                            operator:
                                                                                                description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                                                type: string
                                                                                            values:
                                                                                                description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
                                                                                                items:
                                                                                                    type: string
                                                                                                type: array
                                                                                        required:
                                                                                            - key
                                                                                            - operator
                                                                                        type: object
                                                                                    type: array
                                                                                matchLabels:
                                                                                    additionalProperties:
                                                                                        type: string
                                                                                    description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                                                    type: object
                                                                            type: object
                                                                            x-kubernetes-map-type: atomic
                                                                        namespaces:
                                                                            description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                                            items:
                                                                                type: string
                                                                            type: array
                                                                        topologyKey:
                                                                            description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.
                                                                            type: string
                                                                    required:
                                                                        - topologyKey
                                                                    type: object
                                                                type: array
                                                        type: object
                                                type: object
                                            nodeSelector:
                                                additionalProperties:
                                                    type: string
                                                description: "NodeSelector is a selector which must be true for the pod to fit on a node. Selector which must match a node's labels for the pod to be scheduled on that node. \n More info: https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#nodeselector"
                                                type: object
                                            resources:
                                                description: "Total compute Resources required by this pod. Cannot be updated. \n More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/"
                                                properties:
                                                    claims:
                                                        description: "Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container. \n This is an alpha field and requires enabling the DynamicResourceAllocation feature gate. \n This field is immutable."
                                                        items:
                                                            description: ResourceClaim references one entry in PodSpec.ResourceClaims.
                                                            properties:
                                                                name:
                                                                    description: Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container.
                                                                    type: string
                                                            required:
                                                                - name
                                                            type: object
                                                        type: array
                                                        x-kubernetes-list-map-keys:
                                                            - name
                                                        x-kubernetes-list-type: map
                                                    limits:
                                                        additionalProperties:
                                                            anyOf:
                                                                - type: integer
                                                                - type: string
                                                            pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                                                            x-kubernetes-int-or-string: true
                                                        description: 'Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/'
                                                        type: object
                                                    requests:
                                                        additionalProperties:
                                                            anyOf:
                                                                - type: integer
                                                                - type: string
                                                            pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                                                            x-kubernetes-int-or-string: true
                                                        description: 'Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/'
                                                        type: object
                                                type: object
                                            schedulerName:
                                                description: If specified, the pod will be dispatched by specified scheduler. If not specified, the pod will be dispatched by default scheduler.
                                                type: string
                                            tolerations:
                                                description: If specified, the pod's tolerations.
                                                items:
                                                    description: The pod this Toleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.
                                                    properties:
                                                        effect:
                                                            description: Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.
                                                            type: string
                                                        key:
                                                            description: Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.
                                                            type: string
                                                        operator:
                                                            description: Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.
                                                            type: string
                                                        tolerationSeconds:
                                                            description: TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.
                                                            format: int64
                                                            type: integer
                                                        value:
                                                            description: Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.
                                                            type: string
                                                    type: object
                                                type: array
                                        type: object
                                    nodeCount:
                                        description: The total number of data nodes in MySQL Cluster. The node count needs to be a multiple of the redundancyLevel. A maximum of 144 data nodes are allowed to run in a single MySQL Cluster.
                                        format: int32
                                        maximum: 144
                                        minimum: 1
                                        type: integer
                                    pvcSpec:
                                        description: PVCSpec is the PersistentVolumeClaimSpec to be used as the VolumeClaimTemplate of the data node statefulset. A PVC will be created for each data node by the statefulset controller and will be loaded into the data node pod and the container.
                                        properties:
                                            accessModes:
                                                description: 'accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1'
                                                items:
                                                    type: string
                                                type: array
                                            dataSource:
                                                description: 'dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. When the AnyVolumeDataSource feature gate is enabled, dataSource contents will be copied to dataSourceRef, and dataSourceRef contents will be copied to dataSource when dataSourceRef.namespace is not specified. If the namespace is specified, then dataSourceRef will not be copied to dataSource.'
                                                properties:
                                                    apiGroup:
                                                        description: APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.
                                                        type: string
                                                    kind:
                                                        description: Kind is the type of resource being referenced
                                                        type: string
                                                    name:
                                                        description: Name is the name of resource being referenced
                                                        type: string
                                                required:
                                                    - kind
                                                    - name
                                                type: object
                                                x-kubernetes-map-type: atomic
                                            dataSourceRef:
                                                description: 'dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the dataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, when namespace isn''t specified in dataSourceRef, both fields (dataSource and dataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. When namespace is specified in dataSourceRef, dataSource isn''t set to the same value and must be empty. There are three important differences between dataSource and dataSourceRef: * While dataSource only allows two specific types of objects, dataSourceRef allows any non-core object, as well as PersistentVolumeClaim objects. * While dataSource ignores disallowed values (dropping them), dataSourceRef preserves all values, and generates an error if a disallowed value is specified. * While dataSource only allows local objects, dataSourceRef allows objects in any namespaces. (Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled. (Alpha) Using the namespace field of dataSourceRef requires the CrossNamespaceVolumeDataSource feature gate to be enabled.'
                                                properties:
                                                    apiGroup:
                                                        description: APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.
                                                        type: string
                                                    kind:
                                                        description: Kind is the type of resource being referenced
                                                        type: string
                                                    name:
                                                        description: Name is the name of resource being referenced
                                                        type: string
                                                    namespace:
                                                        description: Namespace is the namespace of resource being referenced Note that when a namespace is specified, a gateway.networking.k8s.io/ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details. (Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled.
                                                        type: string
                                                required:
                                                    - kind
                                                    - name
                                                type: object
                                            resources:
                                                description: 'resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources'
                                                properties:
                                                    claims:
                                                        description: "Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container. \n This is an alpha field and requires enabling the DynamicResourceAllocation feature gate. \n This field is immutable."
                                                        items:
                                                            description: ResourceClaim references one entry in PodSpec.ResourceClaims.
                                                            properties:
                                                                name:
                                                                    description: Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container.
                                                                    type: string
                                                            required:
                                                                - name
                                                            type: object
                                                        type: array
                                                        x-kubernetes-list-map-keys:
                                                            - name
                                                        x-kubernetes-list-type: map
                                                    limits:
                                                        additionalProperties:
                                                            anyOf:
                                                                - type: integer
                                                                - type: string
                                                            pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                                                            x-kubernetes-int-or-string: true
                                                        description: 'Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/'
                                                        type: object
                                                    requests:
                                                        additionalProperties:
                                                            anyOf:
                                                                - type: integer
                                                                - type: string
                                                            pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                                                            x-kubernetes-int-or-string: true
                                                        description: 'Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/'
                                                        type: object
                                                type: object
                                            selector:
                                                description: selector is a label query over volumes to consider for binding.
                                                properties:
                                                    matchExpressions:
                                                        description: matchExpressions is a list of label selector requirements. The requirements are ANDed.
                                                        items:
                                                            description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                            properties:
                                                                key:
                                                                    description: key is the label key that the selector applies to.
                                                                    type: string
                                                                operator:
                                                                    description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                    type: string
                                                                values:
                                                                    description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
                                                                    items:
                                                                        type: string
                                                                    type: array
                                                            required:
                                                                - key
                                                                - operator
                                                            type: object
                                                        type: array
                                                    matchLabels:
                                                        additionalProperties:
                                                            type: string
                                                        description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                        type: object
                                                type: object
                                                x-kubernetes-map-type: atomic
                                            storageClassName:
                                                description: 'storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1'
                                                type: string
                                            volumeMode:
                                                description: volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.
                                                type: string
                                            volumeName:
                                                description: volumeName is the binding reference to the PersistentVolume backing this claim.
                                                type: string
                                        type: object
                                required:
                                    - nodeCount
                                type: object
                            freeAPISlots:
                                default: 2
                                description: The number of extra API sections declared in the MySQL Cluster config, in addition to the API sections declared implicitly by the NDB Operator for the MySQL Servers. Any NDBAPI application can connect to the MySQL Cluster via these free slots.
                                format: int32
                                type: integer
                            image:
                                default: container-registry.oracle.com/mysql/community-cluster:8.4.0
                                description: The name of the MySQL Ndb Cluster image to be used. If not specified, "container-registry.oracle.com/mysql/community-cluster:8.4.0" will be used.
                                type: string
                            imagePullPolicy:
                                default: IfNotPresent
                                description: ImagePullPolicy describes a policy for if/when to pull the MySQL Cluster container image
                                enum:
                                    - Always
                                    - Never
                                    - IfNotPresent
                                type: string
                            imagePullSecretName:
                                description: ImagePullSecretName optionally specifies the name of the secret that holds the credentials required for pulling the MySQL Cluster image.
                                type: string
                            managementNode:
                                description: ManagementNode specifies the configuration of the management node running in MySQL Cluster.
                                properties:
                                    config:
                                        additionalProperties:
                                            anyOf:
                                                - type: integer
                                                - type: string
                                            x-kubernetes-int-or-string: true
                                        description: "Config is a map of default MySQL Cluster Management node configurations. \n More info : https://dev.mysql.com/doc/refman/8.0/en/mysql-cluster-params-mgmd.html"
                                        type: object
                                    enableLoadBalancer:
                                        default: false
                                        description: EnableLoadBalancer exposes the management servers externally using the kubernetes cloud provider's load balancer. By default, the operator creates a ClusterIP type service to expose the management server pods internally within the kubernetes cluster. If EnableLoadBalancer is set to true, a LoadBalancer type service will be created instead, exposing the management Servers outside the kubernetes cluster.
                                        type: boolean
                                    ndbPodSpec:
                                        description: NdbPodSpec contains a subset of PodSpec fields which when set will be copied into to the podSpec of Management node's statefulset definition.
                                        properties:
                                            affinity:
                                                description: If specified, the pod's scheduling constraints
                                                properties:
                                                    nodeAffinity:
                                                        description: Describes node affinity scheduling rules for the pod.
                                                        properties:
                                                            preferredDuringSchedulingIgnoredDuringExecution:
                                                                description: The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.
                                                                items:
                                                                    description: An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).
                                                                    properties:
                                                                        preference:
                                                                            description: A node selector term, associated with the corresponding weight.
                                                                            properties:
                                                                                matchExpressions:
                                                                                    description: A list of node selector requirements by node's labels.
                                                                                    items:
                                                                                        description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                        properties:
                                                                                            key:
                                                                                                description: The label key that the selector applies to.
                                                                                                type: string
                                                                                            operator:
                                                                                                description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                                                                type: string
                                                                                            values:
                                                                                                description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.
                                                                                                items:
                                                                                                    type: string
                                                                                                type: array
                                                                                        required:
                                                                                            - key
                                                                                            - operator
                                                                                        type: object
                                                                                    type: array
                                                                                matchFields:
                                                                                    description: A list of node selector requirements by node's fields.
                                                                                    items:
                                                                                        description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                        properties:
                                                                                            key:
                                                                                                description: The label key that the selector applies to.
                                                                                                type: string
                                                                                            operator:
                                                                                                description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                                                                type: string
                                                                                            values:
                                                                                                description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.
                                                                                                items:
                                                                                                    type: string
                                                                                                type: array
                                                                                        required:
                                                                                            - key
                                                                                            - operator
                                                                                        type: object
                                                                                    type: array
                                                                            type: object
                                                                            x-kubernetes-map-type: atomic
                                                                        weight:
                                                                            description: Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.
                                                                            format: int32
                                                                            type: integer
                                                                    required:
                                                                        - preference
                                                                        - weight
                                                                    type: object
                                                                type: array
                                                            requiredDuringSchedulingIgnoredDuringExecution:
                                                                description: If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.
                                                                properties:
                                                                    nodeSelectorTerms:
                                                                        description: Required. A list of node selector terms. The terms are ORed.
                                                                        items:
                                                                            description: A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.
                                                                            properties:
                                                                                matchExpressions:
                                                                                    description: A list of node selector requirements by node's labels.
                                                                                    items:
                                                                                        description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                        properties:
                                                                                            key:
                                                                                                description: The label key that the selector applies to.
                                                                                                type: string
                                                                                            operator:
                                                                                                description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                                                                type: string
                                                                                            values:
                                                                                                description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.
                                                                                                items:
                                                                                                    type: string
                                                                                                type: array
                                                                                        required:
                                                                                            - key
                                                                                            - operator
                                                                                        type: object
                                                                                    type: array
                                                                                matchFields:
                                                                                    description: A list of node selector requirements by node's fields.
                                                                                    items:
                                                                                        description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                        properties:
                                                                                            key:
                                                                                                description: The label key that the selector applies to.
                                                                                                type: string
                                                                                            operator:
                                                                                                description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                                                                type: string
                                                                                            values:
                                                                                                description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.
                                                                                                items:
                                                                                                    type: string
                                                                                                type: array
                                                                                        required:
                                                                                            - key
                                                                                            - operator
                                                                                        type: object
                                                                                    type: array
                                                                            type: object
                                                                            x-kubernetes-map-type: atomic
                                                                        type: array
                                                                required:
                                                                    - nodeSelectorTerms
                                                                type: object
                                                                x-kubernetes-map-type: atomic
                                                        type: object
                                                    podAffinity:
                                                        description: Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).
                                                        properties:
                                                            preferredDuringSchedulingIgnoredDuringExecution:
                                                                description: The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.
                                                                items:
                                                                    description: The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)
                                                                    properties:
                                                                        podAffinityTerm:
                                                                            description: Required. A pod affinity term, associated with the corresponding weight.
                                                                            properties:
                                                                                labelSelector:
                                                                                    description: A label query over a set of resources, in this case pods.
                                                                                    properties:
                                                                                        matchExpressions:
                                                                                            description: matchExpressions is a list of label selector requirements. The requirements are ANDed.
                                                                                            items:
                                                                                                description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                                properties:
                                                                                                    key:
                                                                                                        description: key is the label key that the selector applies to.
                                                                                                        type: string
                                                                                                    operator:
                                                                                                        description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                                                        type: string
                                                                                                    values:
                                                                                                        description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
                                                                                                        items:
                                                                                                            type: string
                                                                                                        type: array
                                                                                                required:
                                                                                                    - key
                                                                                                    - operator
                                                                                                type: object
                                                                                            type: array
                                                                                        matchLabels:
                                                                                            additionalProperties:
                                                                                                type: string
                                                                                            description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                                                            type: object
                                                                                    type: object
                                                                                    x-kubernetes-map-type: atomic
                                                                                namespaceSelector:
                                                                                    description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces.
                                                                                    properties:
                                                                                        matchExpressions:
                                                                                            description: matchExpressions is a list of label selector requirements. The requirements are ANDed.
                                                                                            items:
                                                                                                description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                                properties:
                                                                                                    key:
                                                                                                        description: key is the label key that the selector applies to.
                                                                                                        type: string
                                                                                                    operator:
                                                                                                        description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                                                        type: string
                                                                                                    values:
                                                                                                        description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
                                                                                                        items:
                                                                                                            type: string
                                                                                                        type: array
                                                                                                required:
                                                                                                    - key
                                                                                                    - operator
                                                                                                type: object
                                                                                            type: array
                                                                                        matchLabels:
                                                                                            additionalProperties:
                                                                                                type: string
                                                                                            description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                                                            type: object
                                                                                    type: object
                                                                                    x-kubernetes-map-type: atomic
                                                                                namespaces:
                                                                                    description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                                                    items:
                                                                                        type: string
                                                                                    type: array
                                                                                topologyKey:
                                                                                    description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.
                                                                                    type: string
                                                                            required:
                                                                                - topologyKey
                                                                            type: object
                                                                        weight:
                                                                            description: weight associated with matching the corresponding podAffinityTerm, in the range 1-100.
                                                                            format: int32
                                                                            type: integer
                                                                    required:
                                                                        - podAffinityTerm
                                                                        - weight
                                                                    type: object
                                                                type: array
                                                            requiredDuringSchedulingIgnoredDuringExecution:
                                                                description: If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.
                                                                items:
                                                                    description: Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key <topologyKey> matches that of any node on which a pod of the set of pods is running
                                                                    properties:
                                                                        labelSelector:
                                                                            description: A label query over a set of resources, in this case pods.
                                                                            properties:
                                                                                matchExpressions:
                                                                                    description: matchExpressions is a list of label selector requirements. The requirements are ANDed.
                                                                                    items:
                                                                                        description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                        properties:
                                                                                            key:
                                                                                                description: key is the label key that the selector applies to.
                                                                                                type: string
                                                                                            operator:
                                                                                                description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                                                type: string
                                                                                            values:
                                                                                                description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
                                                                                                items:
                                                                                                    type: string
                                                                                                type: array
                                                                                        required:
                                                                                            - key
                                                                                            - operator
                                                                                        type: object
                                                                                    type: array
                                                                                matchLabels:
                                                                                    additionalProperties:
                                                                                        type: string
                                                                                    description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                                                    type: object
                                                                            type: object
                                                                            x-kubernetes-map-type: atomic
                                                                        namespaceSelector:
                                                                            description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces.
                                                                            properties:
                                                                                matchExpressions:
                                                                                    description: matchExpressions is a list of label selector requirements. The requirements are ANDed.
                                                                                    items:
                                                                                        description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                        properties:
                                                                                            key:
                                                                                                description: key is the label key that the selector applies to.
                                                                                                type: string
                                                                                            operator:
                                                                                                description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                                                type: string
                                                                                            values:
                                                                                                description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
                                                                                                items:
                                                                                                    type: string
                                                                                                type: array
                                                                                        required:
                                                                                            - key
                                                                                            - operator
                                                                                        type: object
                                                                                    type: array
                                                                                matchLabels:
                                                                                    additionalProperties:
                                                                                        type: string
                                                                                    description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                                                    type: object
                                                                            type: object
                                                                            x-kubernetes-map-type: atomic
                                                                        namespaces:
                                                                            description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                                            items:
                                                                                type: string
                                                                            type: array
                                                                        topologyKey:
                                                                            description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.
                                                                            type: string
                                                                    required:
                                                                        - topologyKey
                                                                    type: object
                                                                type: array
                                                        type: object
                                                    podAntiAffinity:
                                                        description: Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).
                                                        properties:
                                                            preferredDuringSchedulingIgnoredDuringExecution:
                                                                description: The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.
                                                                items:
                                                                    description: The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)
                                                                    properties:
                                                                        podAffinityTerm:
                                                                            description: Required. A pod affinity term, associated with the corresponding weight.
                                                                            properties:
                                                                                labelSelector:
                                                                                    description: A label query over a set of resources, in this case pods.
                                                                                    properties:
                                                                                        matchExpressions:
                                                                                            description: matchExpressions is a list of label selector requirements. The requirements are ANDed.
                                                                                            items:
                                                                                                description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                                properties:
                                                                                                    key:
                                                                                                        description: key is the label key that the selector applies to.
                                                                                                        type: string
                                                                                                    operator:
                                                                                                        description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                                                        type: string
                                                                                                    values:
                                                                                                        description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
                                                                                                        items:
                                                                                                            type: string
                                                                                                        type: array
                                                                                                required:
                                                                                                    - key
                                                                                                    - operator
                                                                                                type: object
                                                                                            type: array
                                                                                        matchLabels:
                                                                                            additionalProperties:
                                                                                                type: string
                                                                                            description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                                                            type: object
                                                                                    type: object
                                                                                    x-kubernetes-map-type: atomic
                                                                                namespaceSelector:
                                                                                    description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces.
                                                                                    properties:
                                                                                        matchExpressions:
                                                                                            description: matchExpressions is a list of label selector requirements. The requirements are ANDed.
                                                                                            items:
                                                                                                description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                                properties:
                                                                                                    key:
                                                                                                        description: key is the label key that the selector applies to.
                                                                                                        type: string
                                                                                                    operator:
                                                                                                        description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                                                        type: string
                                                                                                    values:
                                                                                                        description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
                                                                                                        items:
                                                                                                            type: string
                                                                                                        type: array
                                                                                                required:
                                                                                                    - key
                                                                                                    - operator
                                                                                                type: object
                                                                                            type: array
                                                                                        matchLabels:
                                                                                            additionalProperties:
                                                                                                type: string
                                                                                            description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                                                            type: object
                                                                                    type: object
                                                                                    x-kubernetes-map-type: atomic
                                                                                namespaces:
                                                                                    description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                                                    items:
                                                                                        type: string
                                                                                    type: array
                                                                                topologyKey:
                                                                                    description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.
                                                                                    type: string
                                                                            required:
                                                                                - topologyKey
                                                                            type: object
                                                                        weight:
                                                                            description: weight associated with matching the corresponding podAffinityTerm, in the range 1-100.
                                                                            format: int32
                                                                            type: integer
                                                                    required:
                                                                        - podAffinityTerm
                                                                        - weight
                                                                    type: object
                                                                type: array
                                                            requiredDuringSchedulingIgnoredDuringExecution:
                                                                description: If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.
                                                                items:
                                                                    description: Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key <topologyKey> matches that of any node on which a pod of the set of pods is running
                                                                    properties:
                                                                        labelSelector:
                                                                            description: A label query over a set of resources, in this case pods.
                                                                            properties:
                                                                                matchExpressions:
                                                                                    description: matchExpressions is a list of label selector requirements. The requirements are ANDed.
                                                                                    items:
                                                                                        description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                        properties:
                                                                                            key:
                                                                                                description: key is the label key that the selector applies to.
                                                                                                type: string
                                                                                            operator:
                                                                                                description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                                                type: string
                                                                                            values:
                                                                                                description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
                                                                                                items:
                                                                                                    type: string
                                                                                                type: array
                                                                                        required:
                                                                                            - key
                                                                                            - operator
                                                                                        type: object
                                                                                    type: array
                                                                                matchLabels:
                                                                                    additionalProperties:
                                                                                        type: string
                                                                                    description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                                                    type: object
                                                                            type: object
                                                                            x-kubernetes-map-type: atomic
                                                                        namespaceSelector:
                                                                            description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces.
                                                                            properties:
                                                                                matchExpressions:
                                                                                    description: matchExpressions is a list of label selector requirements. The requirements are ANDed.
                                                                                    items:
                                                                                        description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                        properties:
                                                                                            key:
                                                                                                description: key is the label key that the selector applies to.
                                                                                                type: string
                                                                                            operator:
                                                                                                description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                                                type: string
                                                                                            values:
                                                                                                description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
                                                                                                items:
                                                                                                    type: string
                                                                                                type: array
                                                                                        required:
                                                                                            - key
                                                                                            - operator
                                                                                        type: object
                                                                                    type: array
                                                                                matchLabels:
                                                                                    additionalProperties:
                                                                                        type: string
                                                                                    description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                                                    type: object
                                                                            type: object
                                                                            x-kubernetes-map-type: atomic
                                                                        namespaces:
                                                                            description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                                            items:
                                                                                type: string
                                                                            type: array
                                                                        topologyKey:
                                                                            description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.
                                                                            type: string
                                                                    required:
                                                                        - topologyKey
                                                                    type: object
                                                                type: array
                                                        type: object
                                                type: object
                                            nodeSelector:
                                                additionalProperties:
                                                    type: string
                                                description: "NodeSelector is a selector which must be true for the pod to fit on a node. Selector which must match a node's labels for the pod to be scheduled on that node. \n More info: https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#nodeselector"
                                                type: object
                                            resources:
                                                description: "Total compute Resources required by this pod. Cannot be updated. \n More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/"
                                                properties:
                                                    claims:
                                                        description: "Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container. \n This is an alpha field and requires enabling the DynamicResourceAllocation feature gate. \n This field is immutable."
                                                        items:
                                                            description: ResourceClaim references one entry in PodSpec.ResourceClaims.
                                                            properties:
                                                                name:
                                                                    description: Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container.
                                                                    type: string
                                                            required:
                                                                - name
                                                            type: object
                                                        type: array
                                                        x-kubernetes-list-map-keys:
                                                            - name
                                                        x-kubernetes-list-type: map
                                                    limits:
                                                        additionalProperties:
                                                            anyOf:
                                                                - type: integer
                                                                - type: string
                                                            pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                                                            x-kubernetes-int-or-string: true
                                                        description: 'Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/'
                                                        type: object
                                                    requests:
                                                        additionalProperties:
                                                            anyOf:
                                                                - type: integer
                                                                - type: string
                                                            pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                                                            x-kubernetes-int-or-string: true
                                                        description: 'Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/'
                                                        type: object
                                                type: object
                                            schedulerName:
                                                description: If specified, the pod will be dispatched by specified scheduler. If not specified, the pod will be dispatched by default scheduler.
                                                type: string
                                            tolerations:
                                                description: If specified, the pod's tolerations.
                                                items:
                                                    description: The pod this Toleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.
                                                    properties:
                                                        effect:
                                                            description: Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.
                                                            type: string
                                                        key:
                                                            description: Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.
                                                            type: string
                                                        operator:
                                                            description: Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.
                                                            type: string
                                                        tolerationSeconds:
                                                            description: TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.
                                                            format: int64
                                                            type: integer
                                                        value:
                                                            description: Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.
                                                            type: string
                                                    type: object
                                                type: array
                                        type: object
                                type: object
                            mysqlNode:
                                description: MysqlNode specifies the configuration of the MySQL Servers running in the cluster. Note that the NDB Operator requires atleast one MySQL Server running in the cluster for internal operations. If no MySQL Server is specified, the operator will by default add one MySQL Server to the spec.
                                properties:
                                    connectionPoolSize:
                                        default: 1
                                        description: 'ConnectionPoolSize is the number of connections a single MySQL Server should use to connect to the MySQL Cluster nodes. More info : https://dev.mysql.com/doc/refman/8.0/en/mysql-cluster-options-variables.html#option_mysqld_ndb-cluster-connection-pool'
                                        format: int32
                                        maximum: 63
                                        minimum: 1
                                        type: integer
                                    enableLoadBalancer:
                                        default: false
                                        description: EnableLoadBalancer exposes the MySQL servers externally using the kubernetes cloud provider's load balancer. By default, the operator creates a ClusterIP type service to expose the MySQL server pods internally within the kubernetes cluster. If EnableLoadBalancer is set to true, a LoadBalancer type service will be created instead, exposing the MySQL servers outside the kubernetes cluster.
                                        type: boolean
                                    initScripts:
                                        additionalProperties:
                                            items:
                                                type: string
                                            type: array
                                        description: InitScripts is a map of configMap names from the same namespace and optionally an array of keys which store the SQL scripts to be executed during MySQL Server initialization. If key names are omitted, contents of all the keys will be treated as initialization SQL scripts. All scripts will be mounted into the MySQL pods and will be executed in the alphabetical order of configMap names and key names.
                                        type: object
                                    maxNodeCount:
                                        description: MaxNodeCount is the count up to which the MySQL Servers would be allowed to scale up without forcing a MySQL Cluster config update. If unspecified, operator will define the MySQL Cluster config with API sections for two additional MySQL Servers.
                                        format: int32
                                        type: integer
                                    myCnf:
                                        description: Configuration options to pass to the MySQL Server when it is started.
                                        type: string
                                    ndbPodSpec:
                                        description: NdbPodSpec contains a subset of K8s PodSpec fields which when set will be copied into to the podSpec of MySQL Server StatefulSet.
                                        properties:
                                            affinity:
                                                description: If specified, the pod's scheduling constraints
                                                properties:
                                                    nodeAffinity:
                                                        description: Describes node affinity scheduling rules for the pod.
                                                        properties:
                                                            preferredDuringSchedulingIgnoredDuringExecution:
                                                                description: The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.
                                                                items:
                                                                    description: An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).
                                                                    properties:
                                                                        preference:
                                                                            description: A node selector term, associated with the corresponding weight.
                                                                            properties:
                                                                                matchExpressions:
                                                                                    description: A list of node selector requirements by node's labels.
                                                                                    items:
                                                                                        description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                        properties:
                                                                                            key:
                                                                                                description: The label key that the selector applies to.
                                                                                                type: string
                                                                                            operator:
                                                                                                description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                                                                type: string
                                                                                            values:
                                                                                                description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.
                                                                                                items:
                                                                                                    type: string
                                                                                                type: array
                                                                                        required:
                                                                                            - key
                                                                                            - operator
                                                                                        type: object
                                                                                    type: array
                                                                                matchFields:
                                                                                    description: A list of node selector requirements by node's fields.
                                                                                    items:
                                                                                        description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                        properties:
                                                                                            key:
                                                                                                description: The label key that the selector applies to.
                                                                                                type: string
                                                                                            operator:
                                                                                                description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                                                                type: string
                                                                                            values:
                                                                                                description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.
                                                                                                items:
                                                                                                    type: string
                                                                                                type: array
                                                                                        required:
                                                                                            - key
                                                                                            - operator
                                                                                        type: object
                                                                                    type: array
                                                                            type: object
                                                                            x-kubernetes-map-type: atomic
                                                                        weight:
                                                                            description: Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.
                                                                            format: int32
                                                                            type: integer
                                                                    required:
                                                                        - preference
                                                                        - weight
                                                                    type: object
                                                                type: array
                                                            requiredDuringSchedulingIgnoredDuringExecution:
                                                                description: If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.
                                                                properties:
                                                                    nodeSelectorTerms:
                                                                        description: Required. A list of node selector terms. The terms are ORed.
                                                                        items:
                                                                            description: A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.
                                                                            properties:
                                                                                matchExpressions:
                                                                                    description: A list of node selector requirements by node's labels.
                                                                                    items:
                                                                                        description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                        properties:
                                                                                            key:
                                                                                                description: The label key that the selector applies to.
                                                                                                type: string
                                                                                            operator:
                                                                                                description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                                                                type: string
                                                                                            values:
                                                                                                description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.
                                                                                                items:
                                                                                                    type: string
                                                                                                type: array
                                                                                        required:
                                                                                            - key
                                                                                            - operator
                                                                                        type: object
                                                                                    type: array
                                                                                matchFields:
                                                                                    description: A list of node selector requirements by node's fields.
                                                                                    items:
                                                                                        description: A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                        properties:
                                                                                            key:
                                                                                                description: The label key that the selector applies to.
                                                                                                type: string
                                                                                            operator:
                                                                                                description: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                                                                type: string
                                                                                            values:
                                                                                                description: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.
                                                                                                items:
                                                                                                    type: string
                                                                                                type: array
                                                                                        required:
                                                                                            - key
                                                                                            - operator
                                                                                        type: object
                                                                                    type: array
                                                                            type: object
                                                                            x-kubernetes-map-type: atomic
                                                                        type: array
                                                                required:
                                                                    - nodeSelectorTerms
                                                                type: object
                                                                x-kubernetes-map-type: atomic
                                                        type: object
                                                    podAffinity:
                                                        description: Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).
                                                        properties:
                                                            preferredDuringSchedulingIgnoredDuringExecution:
                                                                description: The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.
                                                                items:
                                                                    description: The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)
                                                                    properties:
                                                                        podAffinityTerm:
                                                                            description: Required. A pod affinity term, associated with the corresponding weight.
                                                                            properties:
                                                                                labelSelector:
                                                                                    description: A label query over a set of resources, in this case pods.
                                                                                    properties:
                                                                                        matchExpressions:
                                                                                            description: matchExpressions is a list of label selector requirements. The requirements are ANDed.
                                                                                            items:
                                                                                                description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                                properties:
                                                                                                    key:
                                                                                                        description: key is the label key that the selector applies to.
                                                                                                        type: string
                                                                                                    operator:
                                                                                                        description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                                                        type: string
                                                                                                    values:
                                                                                                        description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
                                                                                                        items:
                                                                                                            type: string
                                                                                                        type: array
                                                                                                required:
                                                                                                    - key
                                                                                                    - operator
                                                                                                type: object
                                                                                            type: array
                                                                                        matchLabels:
                                                                                            additionalProperties:
                                                                                                type: string
                                                                                            description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                                                            type: object
                                                                                    type: object
                                                                                    x-kubernetes-map-type: atomic
                                                                                namespaceSelector:
                                                                                    description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces.
                                                                                    properties:
                                                                                        matchExpressions:
                                                                                            description: matchExpressions is a list of label selector requirements. The requirements are ANDed.
                                                                                            items:
                                                                                                description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                                properties:
                                                                                                    key:
                                                                                                        description: key is the label key that the selector applies to.
                                                                                                        type: string
                                                                                                    operator:
                                                                                                        description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                                                        type: string
                                                                                                    values:
                                                                                                        description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
                                                                                                        items:
                                                                                                            type: string
                                                                                                        type: array
                                                                                                required:
                                                                                                    - key
                                                                                                    - operator
                                                                                                type: object
                                                                                            type: array
                                                                                        matchLabels:
                                                                                            additionalProperties:
                                                                                                type: string
                                                                                            description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                                                            type: object
                                                                                    type: object
                                                                                    x-kubernetes-map-type: atomic
                                                                                namespaces:
                                                                                    description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                                                    items:
                                                                                        type: string
                                                                                    type: array
                                                                                topologyKey:
                                                                                    description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.
                                                                                    type: string
                                                                            required:
                                                                                - topologyKey
                                                                            type: object
                                                                        weight:
                                                                            description: weight associated with matching the corresponding podAffinityTerm, in the range 1-100.
                                                                            format: int32
                                                                            type: integer
                                                                    required:
                                                                        - podAffinityTerm
                                                                        - weight
                                                                    type: object
                                                                type: array
                                                            requiredDuringSchedulingIgnoredDuringExecution:
                                                                description: If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.
                                                                items:
                                                                    description: Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key <topologyKey> matches that of any node on which a pod of the set of pods is running
                                                                    properties:
                                                                        labelSelector:
                                                                            description: A label query over a set of resources, in this case pods.
                                                                            properties:
                                                                                matchExpressions:
                                                                                    description: matchExpressions is a list of label selector requirements. The requirements are ANDed.
                                                                                    items:
                                                                                        description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                        properties:
                                                                                            key:
                                                                                                description: key is the label key that the selector applies to.
                                                                                                type: string
                                                                                            operator:
                                                                                                description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                                                type: string
                                                                                            values:
                                                                                                description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
                                                                                                items:
                                                                                                    type: string
                                                                                                type: array
                                                                                        required:
                                                                                            - key
                                                                                            - operator
                                                                                        type: object
                                                                                    type: array
                                                                                matchLabels:
                                                                                    additionalProperties:
                                                                                        type: string
                                                                                    description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                                                    type: object
                                                                            type: object
                                                                            x-kubernetes-map-type: atomic
                                                                        namespaceSelector:
                                                                            description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces.
                                                                            properties:
                                                                                matchExpressions:
                                                                                    description: matchExpressions is a list of label selector requirements. The requirements are ANDed.
                                                                                    items:
                                                                                        description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                        properties:
                                                                                            key:
                                                                                                description: key is the label key that the selector applies to.
                                                                                                type: string
                                                                                            operator:
                                                                                                description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                                                type: string
                                                                                            values:
                                                                                                description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
                                                                                                items:
                                                                                                    type: string
                                                                                                type: array
                                                                                        required:
                                                                                            - key
                                                                                            - operator
                                                                                        type: object
                                                                                    type: array
                                                                                matchLabels:
                                                                                    additionalProperties:
                                                                                        type: string
                                                                                    description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                                                    type: object
                                                                            type: object
                                                                            x-kubernetes-map-type: atomic
                                                                        namespaces:
                                                                            description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                                            items:
                                                                                type: string
                                                                            type: array
                                                                        topologyKey:
                                                                            description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.
                                                                            type: string
                                                                    required:
                                                                        - topologyKey
                                                                    type: object
                                                                type: array
                                                        type: object
                                                    podAntiAffinity:
                                                        description: Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).
                                                        properties:
                                                            preferredDuringSchedulingIgnoredDuringExecution:
                                                                description: The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.
                                                                items:
                                                                    description: The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)
                                                                    properties:
                                                                        podAffinityTerm:
                                                                            description: Required. A pod affinity term, associated with the corresponding weight.
                                                                            properties:
                                                                                labelSelector:
                                                                                    description: A label query over a set of resources, in this case pods.
                                                                                    properties:
                                                                                        matchExpressions:
                                                                                            description: matchExpressions is a list of label selector requirements. The requirements are ANDed.
                                                                                            items:
                                                                                                description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                                properties:
                                                                                                    key:
                                                                                                        description: key is the label key that the selector applies to.
                                                                                                        type: string
                                                                                                    operator:
                                                                                                        description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                                                        type: string
                                                                                                    values:
                                                                                                        description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
                                                                                                        items:
                                                                                                            type: string
                                                                                                        type: array
                                                                                                required:
                                                                                                    - key
                                                                                                    - operator
                                                                                                type: object
                                                                                            type: array
                                                                                        matchLabels:
                                                                                            additionalProperties:
                                                                                                type: string
                                                                                            description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                                                            type: object
                                                                                    type: object
                                                                                    x-kubernetes-map-type: atomic
                                                                                namespaceSelector:
                                                                                    description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces.
                                                                                    properties:
                                                                                        matchExpressions:
                                                                                            description: matchExpressions is a list of label selector requirements. The requirements are ANDed.
                                                                                            items:
                                                                                                description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                                properties:
                                                                                                    key:
                                                                                                        description: key is the label key that the selector applies to.
                                                                                                        type: string
                                                                                                    operator:
                                                                                                        description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                                                        type: string
                                                                                                    values:
                                                                                                        description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
                                                                                                        items:
                                                                                                            type: string
                                                                                                        type: array
                                                                                                required:
                                                                                                    - key
                                                                                                    - operator
                                                                                                type: object
                                                                                            type: array
                                                                                        matchLabels:
                                                                                            additionalProperties:
                                                                                                type: string
                                                                                            description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                                                            type: object
                                                                                    type: object
                                                                                    x-kubernetes-map-type: atomic
                                                                                namespaces:
                                                                                    description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                                                    items:
                                                                                        type: string
                                                                                    type: array
                                                                                topologyKey:
                                                                                    description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.
                                                                                    type: string
                                                                            required:
                                                                                - topologyKey
                                                                            type: object
                                                                        weight:
                                                                            description: weight associated with matching the corresponding podAffinityTerm, in the range 1-100.
                                                                            format: int32
                                                                            type: integer
                                                                    required:
                                                                        - podAffinityTerm
                                                                        - weight
                                                                    type: object
                                                                type: array
                                                            requiredDuringSchedulingIgnoredDuringExecution:
                                                                description: If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.
                                                                items:
                                                                    description: Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key <topologyKey> matches that of any node on which a pod of the set of pods is running
                                                                    properties:
                                                                        labelSelector:
                                                                            description: A label query over a set of resources, in this case pods.
                                                                            properties:
                                                                                matchExpressions:
                                                                                    description: matchExpressions is a list of label selector requirements. The requirements are ANDed.
                                                                                    items:
                                                                                        description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                        properties:
                                                                                            key:
                                                                                                description: key is the label key that the selector applies to.
                                                                                                type: string
                                                                                            operator:
                                                                                                description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                                                type: string
                                                                                            values:
                                                                                                description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
                                                                                                items:
                                                                                                    type: string
                                                                                                type: array
                                                                                        required:
                                                                                            - key
                                                                                            - operator
                                                                                        type: object
                                                                                    type: array
                                                                                matchLabels:
                                                                                    additionalProperties:
                                                                                        type: string
                                                                                    description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                                                    type: object
                                                                            type: object
                                                                            x-kubernetes-map-type: atomic
                                                                        namespaceSelector:
                                                                            description: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces.
                                                                            properties:
                                                                                matchExpressions:
                                                                                    description: matchExpressions is a list of label selector requirements. The requirements are ANDed.
                                                                                    items:
                                                                                        description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                                                        properties:
                                                                                            key:
                                                                                                description: key is the label key that the selector applies to.
                                                                                                type: string
                                                                                            operator:
                                                                                                description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                                                type: string
                                                                                            values:
                                                                                                description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
                                                                                                items:
                                                                                                    type: string
                                                                                                type: array
                                                                                        required:
                                                                                            - key
                                                                                            - operator
                                                                                        type: object
                                                                                    type: array
                                                                                matchLabels:
                                                                                    additionalProperties:
                                                                                        type: string
                                                                                    description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                                                    type: object
                                                                            type: object
                                                                            x-kubernetes-map-type: atomic
                                                                        namespaces:
                                                                            description: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                                            items:
                                                                                type: string
                                                                            type: array
                                                                        topologyKey:
                                                                            description: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.
                                                                            type: string
                                                                    required:
                                                                        - topologyKey
                                                                    type: object
                                                                type: array
                                                        type: object
                                                type: object
                                            nodeSelector:
                                                additionalProperties:
                                                    type: string
                                                description: "NodeSelector is a selector which must be true for the pod to fit on a node. Selector which must match a node's labels for the pod to be scheduled on that node. \n More info: https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#nodeselector"
                                                type: object
                                            resources:
                                                description: "Total compute Resources required by this pod. Cannot be updated. \n More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/"
                                                properties:
                                                    claims:
                                                        description: "Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container. \n This is an alpha field and requires enabling the DynamicResourceAllocation feature gate. \n This field is immutable."
                                                        items:
                                                            description: ResourceClaim references one entry in PodSpec.ResourceClaims.
                                                            properties:
                                                                name:
                                                                    description: Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container.
                                                                    type: string
                                                            required:
                                                                - name
                                                            type: object
                                                        type: array
                                                        x-kubernetes-list-map-keys:
                                                            - name
                                                        x-kubernetes-list-type: map
                                                    limits:
                                                        additionalProperties:
                                                            anyOf:
                                                                - type: integer
                                                                - type: string
                                                            pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                                                            x-kubernetes-int-or-string: true
                                                        description: 'Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/'
                                                        type: object
                                                    requests:
                                                        additionalProperties:
                                                            anyOf:
                                                                - type: integer
                                                                - type: string
                                                            pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                                                            x-kubernetes-int-or-string: true
                                                        description: 'Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/'
                                                        type: object
                                                type: object
                                            schedulerName:
                                                description: If specified, the pod will be dispatched by specified scheduler. If not specified, the pod will be dispatched by default scheduler.
                                                type: string
                                            tolerations:
                                                description: If specified, the pod's tolerations.
                                                items:
                                                    description: The pod this Toleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.
                                                    properties:
                                                        effect:
                                                            description: Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.
                                                            type: string
                                                        key:
                                                            description: Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.
                                                            type: string
                                                        operator:
                                                            description: Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.
                                                            type: string
                                                        tolerationSeconds:
                                                            description: TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.
                                                            format: int64
                                                            type: integer
                                                        value:
                                                            description: Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.
                                                            type: string
                                                    type: object
                                                type: array
                                        type: object
                                    nodeCount:
                                        default: 1
                                        description: NodeCount is the number of MySQL Servers to be started by the Operator
                                        format: int32
                                        minimum: 1
                                        type: integer
                                    pvcSpec:
                                        description: PVCSpec is the PersistentVolumeClaimSpec to be used as the VolumeClaimTemplate of the mysql server statefulset. A PVC will be created for each mysql server by the statefulset controller and will be loaded into the mysql server pod and the container.
                                        properties:
                                            accessModes:
                                                description: 'accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1'
                                                items:
                                                    type: string
                                                type: array
                                            dataSource:
                                                description: 'dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. When the AnyVolumeDataSource feature gate is enabled, dataSource contents will be copied to dataSourceRef, and dataSourceRef contents will be copied to dataSource when dataSourceRef.namespace is not specified. If the namespace is specified, then dataSourceRef will not be copied to dataSource.'
                                                properties:
                                                    apiGroup:
                                                        description: APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.
                                                        type: string
                                                    kind:
                                                        description: Kind is the type of resource being referenced
                                                        type: string
                                                    name:
                                                        description: Name is the name of resource being referenced
                                                        type: string
                                                required:
                                                    - kind
                                                    - name
                                                type: object
                                                x-kubernetes-map-type: atomic
                                            dataSourceRef:
                                                description: 'dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the dataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, when namespace isn''t specified in dataSourceRef, both fields (dataSource and dataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. When namespace is specified in dataSourceRef, dataSource isn''t set to the same value and must be empty. There are three important differences between dataSource and dataSourceRef: * While dataSource only allows two specific types of objects, dataSourceRef allows any non-core object, as well as PersistentVolumeClaim objects. * While dataSource ignores disallowed values (dropping them), dataSourceRef preserves all values, and generates an error if a disallowed value is specified. * While dataSource only allows local objects, dataSourceRef allows objects in any namespaces. (Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled. (Alpha) Using the namespace field of dataSourceRef requires the CrossNamespaceVolumeDataSource feature gate to be enabled.'
                                                properties:
                                                    apiGroup:
                                                        description: APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.
                                                        type: string
                                                    kind:
                                                        description: Kind is the type of resource being referenced
                                                        type: string
                                                    name:
                                                        description: Name is the name of resource being referenced
                                                        type: string
                                                    namespace:
                                                        description: Namespace is the namespace of resource being referenced Note that when a namespace is specified, a gateway.networking.k8s.io/ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details. (Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled.
                                                        type: string
                                                required:
                                                    - kind
                                                    - name
                                                type: object
                                            resources:
                                                description: 'resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources'
                                                properties:
                                                    claims:
                                                        description: "Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container. \n This is an alpha field and requires enabling the DynamicResourceAllocation feature gate. \n This field is immutable."
                                                        items:
                                                            description: ResourceClaim references one entry in PodSpec.ResourceClaims.
                                                            properties:
                                                                name:
                                                                    description: Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container.
                                                                    type: string
                                                            required:
                                                                - name
                                                            type: object
                                                        type: array
                                                        x-kubernetes-list-map-keys:
                                                            - name
                                                        x-kubernetes-list-type: map
                                                    limits:
                                                        additionalProperties:
                                                            anyOf:
                                                                - type: integer
                                                                - type: string
                                                            pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                                                            x-kubernetes-int-or-string: true
                                                        description: 'Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/'
                                                        type: object
                                                    requests:
                                                        additionalProperties:
                                                            anyOf:
                                                                - type: integer
                                                                - type: string
                                                            pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                                                            x-kubernetes-int-or-string: true
                                                        description: 'Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/'
                                                        type: object
                                                type: object
                                            selector:
                                                description: selector is a label query over volumes to consider for binding.
                                                properties:
                                                    matchExpressions:
                                                        description: matchExpressions is a list of label selector requirements. The requirements are ANDed.
                                                        items:
                                                            description: A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
                                                            properties:
                                                                key:
                                                                    description: key is the label key that the selector applies to.
                                                                    type: string
                                                                operator:
                                                                    description: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                    type: string
                                                                values:
                                                                    description: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
                                                                    items:
                                                                        type: string
                                                                    type: array
                                                            required:
                                                                - key
                                                                - operator
                                                            type: object
                                                        type: array
                                                    matchLabels:
                                                        additionalProperties:
                                                            type: string
                                                        description: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                        type: object
                                                type: object
                                                x-kubernetes-map-type: atomic
                                            storageClassName:
                                                description: 'storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1'
                                                type: string
                                            volumeMode:
                                                description: volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.
                                                type: string
                                            volumeName:
                                                description: volumeName is the binding reference to the PersistentVolume backing this claim.
                                                type: string
                                        type: object
                                    rootHost:
                                        default: '%'
                                        description: RootHost is the host or hosts from which the root user can connect to the MySQL Server. If unspecified, root user will be able to connect from any host that can access the MySQL Server.
                                        type: string
                                    rootPasswordSecretName:
                                        description: The name of the Secret that holds the password to be set for the MySQL root accounts. The Secret should have a 'password' key that holds the password. If unspecified, a Secret will be created by the operator with a generated name of format "<ndb-resource-name>-mysqld-root-password"
                                        type: string
                                required:
                                    - nodeCount
                                type: object
                            redundancyLevel:
                                default: 2
                                description: "The number of copies of all data stored in MySQL Cluster. This also defines the number of nodes in a node group. Supported values are 1, 2, 3, and 4. Note that, setting this to 1 means that there is only a single copy of all MySQL Cluster data and failure of any Data node will cause the entire MySQL Cluster to fail. The operator also implicitly decides the number of Management nodes to be added to the MySQL Cluster configuration based on this value. For a redundancy level of 1, one Management node will be created. For 2 or higher, two Management nodes will be created. This value is immutable. \n More info : https://dev.mysql.com/doc/refman/8.0/en/mysql-cluster-ndbd-definition.html#ndbparam-ndbd-noofreplicas"
                                format: int32
                                maximum: 4
                                minimum: 1
                                type: integer
                            tdeSecretName:
                                description: The name of the Secret that holds the encryption key or password required for Transparent Data Encryption (TDE) in MySQL Cluster. If a value is provided, the ndb operator will enable TDE and utilize the password stored in the Secret as the file system password for all data nodes within the MySQL Cluster. If no value is provided, TDE will not be enabled for MySQL Cluster.
                                type: string
                        type: object
                    status:
                        description: The status of the NdbCluster resource and the MySQL Cluster managed by it.
                        properties:
                            conditions:
                                description: Conditions represent the latest available observations of the MySQL Cluster's current state.
                                items:
                                    description: NdbClusterCondition describes the state of a MySQL Cluster installation at a certain point.
                                    properties:
                                        lastTransitionTime:
                                            description: Last time the condition transitioned from one status to another.
                                            format: date-time
                                            type: string
                                        message:
                                            description: A human-readable message indicating details about the transition.
                                            type: string
                                        reason:
                                            description: The reason for the condition's last transition.
                                            type: string
                                        status:
                                            description: Status of the condition, one of True, False, Unknown.
                                            type: string
                                        type:
                                            description: Type of NdbCluster condition.
                                            type: string
                                    required:
                                        - status
                                        - type
                                    type: object
                                type: array
                            generatedRootPasswordSecretName:
                                description: GeneratedRootPasswordSecretName is the name of the secret generated by the operator to be used as the MySQL Server root account password. This will be set to nil if a secret has been already provided to the operator via spec.mysqlNode.rootPasswordSecretName.
                                type: string
                            processedGeneration:
                                description: ProcessedGeneration holds the latest generation of the Ndb resource whose specs have been successfully applied to the MySQL Cluster running inside K8s.
                                format: int64
                                type: integer
                            readyDataNodes:
                                description: The status of the MySQL Cluster Data nodes.
                                type: string
                            readyManagementNodes:
                                description: The status of the MySQL Cluster Management nodes.
                                type: string
                            readyMySQLServers:
                                description: The status of the MySQL Servers.
                                type: string
                        type: object
                required:
                    - spec
                type: object
          served: true
          storage: true
          subresources:
            status: {}
---
apiVersion: v1
kind: Namespace
metadata:
    name: ndb-operator
---
apiVersion: v1
kind: ServiceAccount
metadata:
    name: ndb-operator-webhook-sa
    namespace: ndb-operator
---
apiVersion: v1
kind: ServiceAccount
metadata:
    name: ndb-operator-app-sa
    namespace: ndb-operator
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
    name: ndb-operator-webhook-cr
rules:
    - apiGroups:
        - ""
      resources:
        - secrets
      verbs:
        - get
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
    name: ndb-operator-ndb-operator-webhook-cr
rules:
    - apiGroups:
        - admissionregistration.k8s.io
      resources:
        - validatingwebhookconfigurations
        - mutatingwebhookconfigurations
      verbs:
        - list
        - patch
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
    name: ndb-operator-cr
rules:
    - apiGroups:
        - ""
      resources:
        - pods
      verbs:
        - list
        - watch
        - delete
    - apiGroups:
        - ""
      resources:
        - serviceaccounts
      verbs:
        - list
        - watch
        - delete
        - create
    - apiGroups:
        - ""
      resources:
        - persistentvolumeclaims
      verbs:
        - list
        - watch
        - delete
    - apiGroups:
        - ""
      resources:
        - services
      verbs:
        - list
        - watch
        - create
        - patch
        - delete
    - apiGroups:
        - ""
      resources:
        - configmaps
      verbs:
        - get
        - create
        - patch
        - list
        - watch
    - apiGroups:
        - ""
      resources:
        - secrets
      verbs:
        - get
        - create
        - delete
        - list
        - watch
    - apiGroups:
        - events.k8s.io
      resources:
        - events
      verbs:
        - create
        - patch
    - apiGroups:
        - apps
      resources:
        - statefulsets
      verbs:
        - create
        - patch
        - list
        - watch
        - delete
    - apiGroups:
        - policy
      resources:
        - poddisruptionbudgets
      verbs:
        - list
        - watch
        - create
    - apiGroups:
        - mysql.oracle.com
      resources:
        - ndbclusters
        - ndbclusters/status
      verbs:
        - get
        - list
        - patch
        - update
        - watch
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
    name: ndb-operator-ndb-operator-webhook-crb
    namespace: ndb-operator
roleRef:
    apiGroup: rbac.authorization.k8s.io
    kind: ClusterRole
    name: ndb-operator-ndb-operator-webhook-cr
subjects:
    - kind: ServiceAccount
      name: ndb-operator-webhook-sa
      namespace: ndb-operator
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
    name: ndb-operator-webhook-crb
    namespace: ndb-operator
roleRef:
    apiGroup: rbac.authorization.k8s.io
    kind: ClusterRole
    name: ndb-operator-webhook-cr
subjects:
    - kind: ServiceAccount
      name: ndb-operator-webhook-sa
      namespace: ndb-operator
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
    name: ndb-operator-crb
    namespace: ndb-operator
roleRef:
    apiGroup: rbac.authorization.k8s.io
    kind: ClusterRole
    name: ndb-operator-cr
subjects:
    - kind: ServiceAccount
      name: ndb-operator-app-sa
      namespace: ndb-operator
---
apiVersion: v1
kind: Service
metadata:
    name: ndb-operator-webhook-service
    namespace: ndb-operator
spec:
    ports:
        - port: 9443
    selector:
        app: ndb-operator-webhook-server
---
apiVersion: v1
kind: Service
metadata:
    name: ndb-operator-svc
    namespace: ndb-operator
spec:
    clusterIP: None
    selector:
        app: ndb-operator
---
apiVersion: apps/v1
kind: Deployment
metadata:
    labels:
        app: ndb-operator-webhook-deployment
        release: 8.4.0-1.4.0
    name: ndb-operator-webhook-server
    namespace: ndb-operator
spec:
    selector:
        matchLabels:
            app: ndb-operator-webhook-server
    strategy:
        rollingUpdate:
            maxUnavailable: 0
    template:
        metadata:
            labels:
                app: ndb-operator-webhook-server
        spec:
            containers:
                - args:
                    - -service=ndb-operator-webhook-service
                  command:
                    - ndb-operator-webhook
                  image: container-registry.oracle.com/mysql/community-ndb-operator:8.4.0-1.4.0
                  imagePullPolicy: IfNotPresent
                  name: ndb-operator-webhook
                  ports:
                    - containerPort: 9443
                  readinessProbe:
                    httpGet:
                        path: /health
                        port: 9443
                        scheme: HTTPS
            serviceAccountName: ndb-operator-webhook-sa
---
apiVersion: apps/v1
kind: Deployment
metadata:
    labels:
        app: ndb-operator
        release: 8.4.0-1.4.0
    name: ndb-operator-app
    namespace: ndb-operator
spec:
    replicas: 1
    selector:
        matchLabels:
            app: ndb-operator
    strategy:
        rollingUpdate:
            maxUnavailable: 0
    template:
        metadata:
            labels:
                app: ndb-operator
        spec:
            containers:
                - args:
                    - -cluster-scoped=true
                  command:
                    - ndb-operator
                  env:
                    - name: NDB_OPERATOR_IMAGE
                      value: container-registry.oracle.com/mysql/community-ndb-operator:8.4.0-1.4.0
                    - name: NDB_OPERATOR_IMAGE_PULL_SECRET_NAME
                      value: null
                  image: container-registry.oracle.com/mysql/community-ndb-operator:8.4.0-1.4.0
                  imagePullPolicy: IfNotPresent
                  name: ndb-operator-controller
                  ports:
                    - containerPort: 1186
            hostname: ndb-operator-pod
            serviceAccountName: ndb-operator-app-sa
            subdomain: ndb-operator-svc
---
apiVersion: admissionregistration.k8s.io/v1
kind: MutatingWebhookConfiguration
metadata:
    labels:
        webhook-server: ndb-operator-ndb-operator-webhook-service
    name: ndb-operator-ndb-operator-mwc
webhooks:
    - admissionReviewVersions:
        - v1
      clientConfig:
        service:
            name: ndb-operator-webhook-service
            namespace: ndb-operator
            path: /ndb/mutate
            port: 9443
      failurePolicy: Fail
      name: mutating-webhook.ndbcluster.mysql.oracle.com
      rules:
        - apiGroups:
            - mysql.oracle.com
          apiVersions:
            - v1
          operations:
            - CREATE
            - UPDATE
          resources:
            - ndbclusters
      sideEffects: None
---
apiVersion: admissionregistration.k8s.io/v1
kind: ValidatingWebhookConfiguration
metadata:
    labels:
        webhook-server: ndb-operator-ndb-operator-webhook-service
    name: ndb-operator-ndb-operator-vwc
webhooks:
    - admissionReviewVersions:
        - v1
      clientConfig:
        service:
            name: ndb-operator-webhook-service
            namespace: ndb-operator
            path: /ndb/validate
            port: 9443
      failurePolicy: Fail
      name: validating-webhook.ndbcluster.mysql.oracle.com
      rules:
        - apiGroups:
            - mysql.oracle.com
          apiVersions:
            - v1
          operations:
            - CREATE
            - UPDATE
          resources:
            - ndbclusters
      sideEffects: None