charts/node-feature-discovery/crds/nfd-api-crds.yaml

---
apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  annotations:
    controller-gen.kubebuilder.io/version: v0.12.1
  name: nodefeatures.nfd.k8s-sigs.io
spec:
  group: nfd.k8s-sigs.io
  names:
    kind: NodeFeature
    listKind: NodeFeatureList
    plural: nodefeatures
    singular: nodefeature
  scope: Namespaced
  versions:
  - name: v1alpha1
    schema:
      openAPIV3Schema:
        description: NodeFeature resource holds the features discovered for one node
          in the cluster.
        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: NodeFeatureSpec describes a NodeFeature object.
            properties:
              features:
                description: Features is the full "raw" features data that has been
                  discovered.
                properties:
                  attributes:
                    additionalProperties:
                      description: AttributeFeatureSet is a set of features having
                        string value.
                      properties:
                        elements:
                          additionalProperties:
                            type: string
                          type: object
                      required:
                      - elements
                      type: object
                    description: Attributes contains all the attribute-type features
                      of the node.
                    type: object
                  flags:
                    additionalProperties:
                      description: FlagFeatureSet is a set of simple features only
                        containing names without values.
                      properties:
                        elements:
                          additionalProperties:
                            description: Nil is a dummy empty struct for protobuf
                              compatibility
                            type: object
                          type: object
                      required:
                      - elements
                      type: object
                    description: Flags contains all the flag-type features of the
                      node.
                    type: object
                  instances:
                    additionalProperties:
                      description: InstanceFeatureSet is a set of features each of
                        which is an instance having multiple attributes.
                      properties:
                        elements:
                          items:
                            description: InstanceFeature represents one instance of
                              a complex features, e.g. a device.
                            properties:
                              attributes:
                                additionalProperties:
                                  type: string
                                type: object
                            required:
                            - attributes
                            type: object
                          type: array
                      required:
                      - elements
                      type: object
                    description: Instances contains all the instance-type features
                      of the node.
                    type: object
                type: object
              labels:
                additionalProperties:
                  type: string
                description: Labels is the set of node labels that are requested to
                  be created.
                type: object
            type: object
        required:
        - spec
        type: object
    served: true
    storage: true
---
apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  annotations:
    controller-gen.kubebuilder.io/version: v0.12.1
  name: nodefeaturerules.nfd.k8s-sigs.io
spec:
  group: nfd.k8s-sigs.io
  names:
    kind: NodeFeatureRule
    listKind: NodeFeatureRuleList
    plural: nodefeaturerules
    shortNames:
    - nfr
    singular: nodefeaturerule
  scope: Cluster
  versions:
  - name: v1alpha1
    schema:
      openAPIV3Schema:
        description: NodeFeatureRule resource specifies a configuration for feature-based
          customization of node objects, such as node labeling.
        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: NodeFeatureRuleSpec describes a NodeFeatureRule.
            properties:
              rules:
                description: Rules is a list of node customization rules.
                items:
                  description: Rule defines a rule for node customization such as
                    labeling.
                  properties:
                    annotations:
                      additionalProperties:
                        type: string
                      description: Annotations to create if the rule matches.
                      type: object
                    extendedResources:
                      additionalProperties:
                        type: string
                      description: ExtendedResources to create if the rule matches.
                      type: object
                    labels:
                      additionalProperties:
                        type: string
                      description: Labels to create if the rule matches.
                      type: object
                    labelsTemplate:
                      description: LabelsTemplate specifies a template to expand for
                        dynamically generating multiple labels. Data (after template
                        expansion) must be keys with an optional value (<key>[=<value>])
                        separated by newlines.
                      type: string
                    matchAny:
                      description: MatchAny specifies a list of matchers one of which
                        must match.
                      items:
                        description: MatchAnyElem specifies one sub-matcher of MatchAny.
                        properties:
                          matchFeatures:
                            description: MatchFeatures specifies a set of matcher
                              terms all of which must match.
                            items:
                              description: FeatureMatcherTerm defines requirements
                                against one feature set. All requirements (specified
                                as MatchExpressions) are evaluated against each element
                                in the feature set.
                              properties:
                                feature:
                                  description: Feature is the name of the feature
                                    set to match against.
                                  type: string
                                matchExpressions:
                                  additionalProperties:
                                    description: MatchExpression specifies an expression
                                      to evaluate against a set of input values. It
                                      contains an operator that is applied when matching
                                      the input and an array of values that the operator
                                      evaluates the input against.
                                    properties:
                                      op:
                                        description: Op is the operator to be applied.
                                        enum:
                                        - In
                                        - NotIn
                                        - InRegexp
                                        - Exists
                                        - DoesNotExist
                                        - Gt
                                        - Lt
                                        - GtLt
                                        - IsTrue
                                        - IsFalse
                                        type: string
                                      value:
                                        description: Value is the list of values that
                                          the operand evaluates the input against.
                                          Value should be empty if the operator is
                                          Exists, DoesNotExist, IsTrue or IsFalse.
                                          Value should contain exactly one element
                                          if the operator is Gt or Lt and exactly
                                          two elements if the operator is GtLt. In
                                          other cases Value should contain at least
                                          one element.
                                        items:
                                          type: string
                                        type: array
                                    required:
                                    - op
                                    type: object
                                  description: MatchExpressions is the set of per-element
                                    expressions evaluated. These match against the
                                    value of the specified elements.
                                  type: object
                                matchName:
                                  description: MatchName in an expression that is
                                    matched against the name of each element in the
                                    feature set.
                                  properties:
                                    op:
                                      description: Op is the operator to be applied.
                                      enum:
                                      - In
                                      - NotIn
                                      - InRegexp
                                      - Exists
                                      - DoesNotExist
                                      - Gt
                                      - Lt
                                      - GtLt
                                      - IsTrue
                                      - IsFalse
                                      type: string
                                    value:
                                      description: Value is the list of values that
                                        the operand evaluates the input against. Value
                                        should be empty if the operator is Exists,
                                        DoesNotExist, IsTrue or IsFalse. Value should
                                        contain exactly one element if the operator
                                        is Gt or Lt and exactly two elements if the
                                        operator is GtLt. In other cases Value should
                                        contain at least one element.
                                      items:
                                        type: string
                                      type: array
                                  required:
                                  - op
                                  type: object
                              required:
                              - feature
                              type: object
                            type: array
                        required:
                        - matchFeatures
                        type: object
                      type: array
                    matchFeatures:
                      description: MatchFeatures specifies a set of matcher terms
                        all of which must match.
                      items:
                        description: FeatureMatcherTerm defines requirements against
                          one feature set. All requirements (specified as MatchExpressions)
                          are evaluated against each element in the feature set.
                        properties:
                          feature:
                            description: Feature is the name of the feature set to
                              match against.
                            type: string
                          matchExpressions:
                            additionalProperties:
                              description: MatchExpression specifies an expression
                                to evaluate against a set of input values. It contains
                                an operator that is applied when matching the input
                                and an array of values that the operator evaluates
                                the input against.
                              properties:
                                op:
                                  description: Op is the operator to be applied.
                                  enum:
                                  - In
                                  - NotIn
                                  - InRegexp
                                  - Exists
                                  - DoesNotExist
                                  - Gt
                                  - Lt
                                  - GtLt
                                  - IsTrue
                                  - IsFalse
                                  type: string
                                value:
                                  description: Value is the list of values that the
                                    operand evaluates the input against. Value should
                                    be empty if the operator is Exists, DoesNotExist,
                                    IsTrue or IsFalse. Value should contain exactly
                                    one element if the operator is Gt or Lt and exactly
                                    two elements if the operator is GtLt. In other
                                    cases Value should contain at least one element.
                                  items:
                                    type: string
                                  type: array
                              required:
                              - op
                              type: object
                            description: MatchExpressions is the set of per-element
                              expressions evaluated. These match against the value
                              of the specified elements.
                            type: object
                          matchName:
                            description: MatchName in an expression that is matched
                              against the name of each element in the feature set.
                            properties:
                              op:
                                description: Op is the operator to be applied.
                                enum:
                                - In
                                - NotIn
                                - InRegexp
                                - Exists
                                - DoesNotExist
                                - Gt
                                - Lt
                                - GtLt
                                - IsTrue
                                - IsFalse
                                type: string
                              value:
                                description: Value is the list of values that the
                                  operand evaluates the input against. Value should
                                  be empty if the operator is Exists, DoesNotExist,
                                  IsTrue or IsFalse. Value should contain exactly
                                  one element if the operator is Gt or Lt and exactly
                                  two elements if the operator is GtLt. In other cases
                                  Value should contain at least one element.
                                items:
                                  type: string
                                type: array
                            required:
                            - op
                            type: object
                        required:
                        - feature
                        type: object
                      type: array
                    name:
                      description: Name of the rule.
                      type: string
                    taints:
                      description: Taints to create if the rule matches.
                      items:
                        description: The node this Taint is attached to has the "effect"
                          on any pod that does not tolerate the Taint.
                        properties:
                          effect:
                            description: Required. The effect of the taint on pods
                              that do not tolerate the taint. Valid effects are NoSchedule,
                              PreferNoSchedule and NoExecute.
                            type: string
                          key:
                            description: Required. The taint key to be applied to
                              a node.
                            type: string
                          timeAdded:
                            description: TimeAdded represents the time at which the
                              taint was added. It is only written for NoExecute taints.
                            format: date-time
                            type: string
                          value:
                            description: The taint value corresponding to the taint
                              key.
                            type: string
                        required:
                        - effect
                        - key
                        type: object
                      type: array
                    vars:
                      additionalProperties:
                        type: string
                      description: Vars is the variables to store if the rule matches.
                        Variables do not directly inflict any changes in the node
                        object. However, they can be referenced from other rules enabling
                        more complex rule hierarchies, without exposing intermediary
                        output values as labels.
                      type: object
                    varsTemplate:
                      description: VarsTemplate specifies a template to expand for
                        dynamically generating multiple variables. Data (after template
                        expansion) must be keys with an optional value (<key>[=<value>])
                        separated by newlines.
                      type: string
                  required:
                  - name
                  type: object
                type: array
            required:
            - rules
            type: object
        required:
        - spec
        type: object
    served: true
    storage: true