diff --git a/operators/intel-device-plugins-operator/0.31.0/bundle.Dockerfile b/operators/intel-device-plugins-operator/0.31.0/bundle.Dockerfile new file mode 100644 index 00000000000..b06f62d4593 --- /dev/null +++ b/operators/intel-device-plugins-operator/0.31.0/bundle.Dockerfile @@ -0,0 +1,21 @@ +FROM scratch + +# Core bundle labels. +LABEL operators.operatorframework.io.bundle.mediatype.v1=registry+v1 +LABEL operators.operatorframework.io.bundle.manifests.v1=manifests/ +LABEL operators.operatorframework.io.bundle.metadata.v1=metadata/ +LABEL operators.operatorframework.io.bundle.package.v1=intel-device-plugins-operator +LABEL operators.operatorframework.io.bundle.channels.v1=stable +LABEL operators.operatorframework.io.bundle.channel.default.v1=stable +LABEL operators.operatorframework.io.metrics.builder=operator-sdk-v1.37.0 +LABEL operators.operatorframework.io.metrics.mediatype.v1=metrics+v1 +LABEL operators.operatorframework.io.metrics.project_layout=go.kubebuilder.io/v2 + +# Labels for testing. +LABEL operators.operatorframework.io.test.mediatype.v1=scorecard+v1 +LABEL operators.operatorframework.io.test.config.v1=tests/scorecard/ + +# Copy files to locations specified by labels. +COPY ./manifests /manifests/ +COPY ./metadata /metadata/ +COPY ./tests/scorecard /tests/scorecard/ diff --git a/operators/intel-device-plugins-operator/0.31.0/manifests/deviceplugin.intel.com_dlbdeviceplugins.yaml b/operators/intel-device-plugins-operator/0.31.0/manifests/deviceplugin.intel.com_dlbdeviceplugins.yaml new file mode 100644 index 00000000000..a25dc82edbd --- /dev/null +++ b/operators/intel-device-plugins-operator/0.31.0/manifests/deviceplugin.intel.com_dlbdeviceplugins.yaml @@ -0,0 +1,196 @@ +apiVersion: apiextensions.k8s.io/v1 +kind: CustomResourceDefinition +metadata: + annotations: + controller-gen.kubebuilder.io/version: v0.16.1 + creationTimestamp: null + name: dlbdeviceplugins.deviceplugin.intel.com +spec: + group: deviceplugin.intel.com + names: + kind: DlbDevicePlugin + listKind: DlbDevicePluginList + plural: dlbdeviceplugins + singular: dlbdeviceplugin + scope: Cluster + versions: + - additionalPrinterColumns: + - jsonPath: .status.desiredNumberScheduled + name: Desired + type: integer + - jsonPath: .status.numberReady + name: Ready + type: integer + - jsonPath: .spec.nodeSelector + name: Node Selector + type: string + - jsonPath: .metadata.creationTimestamp + name: Age + type: date + name: v1 + schema: + openAPIV3Schema: + description: |- + DlbDevicePlugin is the Schema for the dlbdeviceplugins API. It represents + the DLB device plugin responsible for advertising Intel DLB hardware resources to + the kubelet. + 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: DlbDevicePluginSpec defines the desired state of DlbDevicePlugin. + properties: + image: + description: Image is a container image with DLB device plugin executable. + type: string + initImage: + description: InitImage is a container image with a script that initializes + devices. + type: string + logLevel: + description: LogLevel sets the plugin's log level. + minimum: 0 + type: integer + nodeSelector: + additionalProperties: + type: string + description: NodeSelector provides a simple way to constrain device + plugin pods to nodes with particular labels. + type: object + tolerations: + description: Specialized nodes (e.g., with accelerators) can be Tainted + to make sure unwanted pods are not scheduled on them. Tolerations + can be set for the plugin pod to neutralize the Taint. + items: + description: |- + The pod this Toleration is attached to tolerates any taint that matches + the triple using the matching 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 + status: + description: DlbDevicePluginStatus defines the observed state of DlbDevicePlugin. + properties: + controlledDaemonSet: + description: ControlledDaemoSet references the DaemonSet controlled + by the operator. + properties: + apiVersion: + description: API version of the referent. + type: string + fieldPath: + description: |- + If referring to a piece of an object instead of an entire object, this string + should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. + For example, if the object reference is to a container within a pod, this would take on a value like: + "spec.containers{name}" (where "name" refers to the name of the container that triggered + the event) or if no container name is specified "spec.containers[2]" (container with + index 2 in this pod). This syntax is chosen only to have some well-defined way of + referencing a part of an object. + type: string + kind: + description: |- + Kind of the referent. + More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds + type: string + name: + description: |- + Name of the referent. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names + type: string + namespace: + description: |- + Namespace of the referent. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/ + type: string + resourceVersion: + description: |- + Specific resourceVersion to which this reference is made, if any. + More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency + type: string + uid: + description: |- + UID of the referent. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids + type: string + type: object + x-kubernetes-map-type: atomic + desiredNumberScheduled: + description: |- + The total number of nodes that should be running the device plugin + pod (including nodes correctly running the device plugin pod). + format: int32 + type: integer + nodeNames: + description: The list of Node names where the device plugin pods are + running. + items: + type: string + type: array + numberReady: + description: |- + The number of nodes that should be running the device plugin pod and have one + or more of the device plugin pod running and ready. + format: int32 + type: integer + required: + - desiredNumberScheduled + - numberReady + type: object + type: object + served: true + storage: true + subresources: + status: {} +status: + acceptedNames: + kind: "" + plural: "" + conditions: null + storedVersions: null diff --git a/operators/intel-device-plugins-operator/0.31.0/manifests/deviceplugin.intel.com_dsadeviceplugins.yaml b/operators/intel-device-plugins-operator/0.31.0/manifests/deviceplugin.intel.com_dsadeviceplugins.yaml new file mode 100644 index 00000000000..88d847165a2 --- /dev/null +++ b/operators/intel-device-plugins-operator/0.31.0/manifests/deviceplugin.intel.com_dsadeviceplugins.yaml @@ -0,0 +1,206 @@ +apiVersion: apiextensions.k8s.io/v1 +kind: CustomResourceDefinition +metadata: + annotations: + controller-gen.kubebuilder.io/version: v0.16.1 + creationTimestamp: null + name: dsadeviceplugins.deviceplugin.intel.com +spec: + group: deviceplugin.intel.com + names: + kind: DsaDevicePlugin + listKind: DsaDevicePluginList + plural: dsadeviceplugins + singular: dsadeviceplugin + scope: Cluster + versions: + - additionalPrinterColumns: + - jsonPath: .status.desiredNumberScheduled + name: Desired + type: integer + - jsonPath: .status.numberReady + name: Ready + type: integer + - jsonPath: .spec.nodeSelector + name: Node Selector + type: string + - jsonPath: .metadata.creationTimestamp + name: Age + type: date + name: v1 + schema: + openAPIV3Schema: + description: |- + DsaDevicePlugin is the Schema for the dsadeviceplugins API. It represents + the DSA device plugin responsible for advertising Intel DSA hardware resources to + the kubelet. + 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: DsaDevicePluginSpec defines the desired state of DsaDevicePlugin. + properties: + image: + description: Image is a container image with DSA device plugin executable. + type: string + initImage: + description: InitImage is an initcontainer image to configure and + enable DSA devices and workqueues with idxd-config (accel-config) + utility + type: string + logLevel: + description: LogLevel sets the plugin's log level. + minimum: 0 + type: integer + nodeSelector: + additionalProperties: + type: string + description: NodeSelector provides a simple way to constrain device + plugin pods to nodes with particular labels. + type: object + provisioningConfig: + description: ProvisioningConfig is a ConfigMap used to pass the DSA + devices and workqueues configuration into idxd-config initcontainer. + type: string + sharedDevNum: + description: SharedDevNum is a number of containers that can share + the same DSA device. + minimum: 1 + type: integer + tolerations: + description: Specialized nodes (e.g., with accelerators) can be Tainted + to make sure unwanted pods are not scheduled on them. Tolerations + can be set for the plugin pod to neutralize the Taint. + items: + description: |- + The pod this Toleration is attached to tolerates any taint that matches + the triple using the matching 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 + status: + description: DsaDevicePluginStatus defines the observed state of DsaDevicePlugin. + properties: + controlledDaemonSet: + description: ControlledDaemoSet references the DaemonSet controlled + by the operator. + properties: + apiVersion: + description: API version of the referent. + type: string + fieldPath: + description: |- + If referring to a piece of an object instead of an entire object, this string + should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. + For example, if the object reference is to a container within a pod, this would take on a value like: + "spec.containers{name}" (where "name" refers to the name of the container that triggered + the event) or if no container name is specified "spec.containers[2]" (container with + index 2 in this pod). This syntax is chosen only to have some well-defined way of + referencing a part of an object. + type: string + kind: + description: |- + Kind of the referent. + More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds + type: string + name: + description: |- + Name of the referent. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names + type: string + namespace: + description: |- + Namespace of the referent. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/ + type: string + resourceVersion: + description: |- + Specific resourceVersion to which this reference is made, if any. + More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency + type: string + uid: + description: |- + UID of the referent. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids + type: string + type: object + x-kubernetes-map-type: atomic + desiredNumberScheduled: + description: |- + The total number of nodes that should be running the device plugin + pod (including nodes correctly running the device plugin pod). + format: int32 + type: integer + nodeNames: + description: The list of Node names where the device plugin pods are + running. + items: + type: string + type: array + numberReady: + description: |- + The number of nodes that should be running the device plugin pod and have one + or more of the device plugin pod running and ready. + format: int32 + type: integer + required: + - desiredNumberScheduled + - numberReady + type: object + type: object + served: true + storage: true + subresources: + status: {} +status: + acceptedNames: + kind: "" + plural: "" + conditions: null + storedVersions: null diff --git a/operators/intel-device-plugins-operator/0.31.0/manifests/deviceplugin.intel.com_fpgadeviceplugins.yaml b/operators/intel-device-plugins-operator/0.31.0/manifests/deviceplugin.intel.com_fpgadeviceplugins.yaml new file mode 100644 index 00000000000..68d28cda997 --- /dev/null +++ b/operators/intel-device-plugins-operator/0.31.0/manifests/deviceplugin.intel.com_fpgadeviceplugins.yaml @@ -0,0 +1,203 @@ +apiVersion: apiextensions.k8s.io/v1 +kind: CustomResourceDefinition +metadata: + annotations: + controller-gen.kubebuilder.io/version: v0.16.1 + creationTimestamp: null + name: fpgadeviceplugins.deviceplugin.intel.com +spec: + group: deviceplugin.intel.com + names: + kind: FpgaDevicePlugin + listKind: FpgaDevicePluginList + plural: fpgadeviceplugins + singular: fpgadeviceplugin + scope: Cluster + versions: + - additionalPrinterColumns: + - jsonPath: .status.desiredNumberScheduled + name: Desired + type: integer + - jsonPath: .status.numberReady + name: Ready + type: integer + - jsonPath: .spec.nodeSelector + name: Node Selector + type: string + - jsonPath: .metadata.creationTimestamp + name: Age + type: date + name: v1 + schema: + openAPIV3Schema: + description: |- + FpgaDevicePlugin is the Schema for the fpgadeviceplugins API. It represents + the FPGA device plugin responsible for advertising Intel FPGA hardware resources to + the kubelet. + 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: FpgaDevicePluginSpec defines the desired state of FpgaDevicePlugin. + properties: + image: + description: Image is a container image with FPGA device plugin executable. + type: string + initImage: + description: InitImage is a container image with tools used to initialize + the host before starting FPGA workloads on it. + type: string + logLevel: + description: LogLevel sets the plugin's log level. + minimum: 0 + type: integer + mode: + description: Mode is a mode of the plugin's operation. + enum: + - af + - region + - regiondevel + type: string + nodeSelector: + additionalProperties: + type: string + description: NodeSelector provides a simple way to constrain device + plugin pods to nodes with particular labels. + type: object + tolerations: + description: Specialized nodes (e.g., with accelerators) can be Tainted + to make sure unwanted pods are not scheduled on them. Tolerations + can be set for the plugin pod to neutralize the Taint. + items: + description: |- + The pod this Toleration is attached to tolerates any taint that matches + the triple using the matching 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 + status: + description: FpgaDevicePluginStatus defines the observed state of FpgaDevicePlugin. + properties: + controlledDaemonSet: + description: ControlledDaemoSet references the DaemonSet controlled + by the operator. + properties: + apiVersion: + description: API version of the referent. + type: string + fieldPath: + description: |- + If referring to a piece of an object instead of an entire object, this string + should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. + For example, if the object reference is to a container within a pod, this would take on a value like: + "spec.containers{name}" (where "name" refers to the name of the container that triggered + the event) or if no container name is specified "spec.containers[2]" (container with + index 2 in this pod). This syntax is chosen only to have some well-defined way of + referencing a part of an object. + type: string + kind: + description: |- + Kind of the referent. + More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds + type: string + name: + description: |- + Name of the referent. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names + type: string + namespace: + description: |- + Namespace of the referent. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/ + type: string + resourceVersion: + description: |- + Specific resourceVersion to which this reference is made, if any. + More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency + type: string + uid: + description: |- + UID of the referent. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids + type: string + type: object + x-kubernetes-map-type: atomic + desiredNumberScheduled: + description: |- + The total number of nodes that should be running the device plugin + pod (including nodes correctly running the device plugin pod). + format: int32 + type: integer + nodeNames: + description: The list of Node names where the device plugin pods are + running. + items: + type: string + type: array + numberReady: + description: |- + The number of nodes that should be running the device plugin pod and have one + or more of the device plugin pod running and ready. + format: int32 + type: integer + required: + - desiredNumberScheduled + - numberReady + type: object + type: object + served: true + storage: true + subresources: + status: {} +status: + acceptedNames: + kind: "" + plural: "" + conditions: null + storedVersions: null diff --git a/operators/intel-device-plugins-operator/0.31.0/manifests/deviceplugin.intel.com_gpudeviceplugins.yaml b/operators/intel-device-plugins-operator/0.31.0/manifests/deviceplugin.intel.com_gpudeviceplugins.yaml new file mode 100644 index 00000000000..c9f1fab891b --- /dev/null +++ b/operators/intel-device-plugins-operator/0.31.0/manifests/deviceplugin.intel.com_gpudeviceplugins.yaml @@ -0,0 +1,220 @@ +apiVersion: apiextensions.k8s.io/v1 +kind: CustomResourceDefinition +metadata: + annotations: + controller-gen.kubebuilder.io/version: v0.16.1 + creationTimestamp: null + name: gpudeviceplugins.deviceplugin.intel.com +spec: + group: deviceplugin.intel.com + names: + kind: GpuDevicePlugin + listKind: GpuDevicePluginList + plural: gpudeviceplugins + singular: gpudeviceplugin + scope: Cluster + versions: + - additionalPrinterColumns: + - jsonPath: .status.desiredNumberScheduled + name: Desired + type: integer + - jsonPath: .status.numberReady + name: Ready + type: integer + - jsonPath: .spec.nodeSelector + name: Node Selector + type: string + - jsonPath: .metadata.creationTimestamp + name: Age + type: date + name: v1 + schema: + openAPIV3Schema: + description: |- + GpuDevicePlugin is the Schema for the gpudeviceplugins API. It represents + the GPU device plugin responsible for advertising Intel GPU hardware resources to + the kubelet. + 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: GpuDevicePluginSpec defines the desired state of GpuDevicePlugin. + properties: + enableMonitoring: + description: |- + EnableMonitoring enables the monitoring resource ('i915_monitoring') + which gives access to all GPU devices on given node. Typically used with Intel XPU-Manager. + type: boolean + image: + description: Image is a container image with GPU device plugin executable. + type: string + initImage: + description: InitImage is a container image with tools (e.g., GPU + NFD source hook) installed on each node. + type: string + logLevel: + description: LogLevel sets the plugin's log level. + minimum: 0 + type: integer + nodeSelector: + additionalProperties: + type: string + description: NodeSelector provides a simple way to constrain device + plugin pods to nodes with particular labels. + type: object + preferredAllocationPolicy: + description: |- + PreferredAllocationPolicy sets the mode of allocating GPU devices on a node. + See documentation for detailed description of the policies. Only valid when SharedDevNum > 1 is set. + Not applicable with ResourceManager. + enum: + - balanced + - packed + - none + type: string + resourceManager: + description: ResourceManager handles the fractional resource management + for multi-GPU nodes. Enable only for clusters with GPU Aware Scheduling. + type: boolean + sharedDevNum: + description: SharedDevNum is a number of containers that can share + the same GPU device. + minimum: 1 + type: integer + tolerations: + description: Specialized nodes (e.g., with accelerators) can be Tainted + to make sure unwanted pods are not scheduled on them. Tolerations + can be set for the plugin pod to neutralize the Taint. + items: + description: |- + The pod this Toleration is attached to tolerates any taint that matches + the triple using the matching 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 + status: + description: GpuDevicePluginStatus defines the observed state of GpuDevicePlugin. + properties: + controlledDaemonSet: + description: ControlledDaemoSet references the DaemonSet controlled + by the operator. + properties: + apiVersion: + description: API version of the referent. + type: string + fieldPath: + description: |- + If referring to a piece of an object instead of an entire object, this string + should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. + For example, if the object reference is to a container within a pod, this would take on a value like: + "spec.containers{name}" (where "name" refers to the name of the container that triggered + the event) or if no container name is specified "spec.containers[2]" (container with + index 2 in this pod). This syntax is chosen only to have some well-defined way of + referencing a part of an object. + type: string + kind: + description: |- + Kind of the referent. + More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds + type: string + name: + description: |- + Name of the referent. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names + type: string + namespace: + description: |- + Namespace of the referent. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/ + type: string + resourceVersion: + description: |- + Specific resourceVersion to which this reference is made, if any. + More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency + type: string + uid: + description: |- + UID of the referent. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids + type: string + type: object + x-kubernetes-map-type: atomic + desiredNumberScheduled: + description: |- + The total number of nodes that should be running the device plugin + pod (including nodes correctly running the device plugin pod). + format: int32 + type: integer + nodeNames: + description: The list of Node names where the device plugin pods are + running. + items: + type: string + type: array + numberReady: + description: |- + The number of nodes that should be running the device plugin pod and have one + or more of the device plugin pod running and ready. + format: int32 + type: integer + required: + - desiredNumberScheduled + - numberReady + type: object + type: object + served: true + storage: true + subresources: + status: {} +status: + acceptedNames: + kind: "" + plural: "" + conditions: null + storedVersions: null diff --git a/operators/intel-device-plugins-operator/0.31.0/manifests/deviceplugin.intel.com_iaadeviceplugins.yaml b/operators/intel-device-plugins-operator/0.31.0/manifests/deviceplugin.intel.com_iaadeviceplugins.yaml new file mode 100644 index 00000000000..77c6fa1d8de --- /dev/null +++ b/operators/intel-device-plugins-operator/0.31.0/manifests/deviceplugin.intel.com_iaadeviceplugins.yaml @@ -0,0 +1,205 @@ +apiVersion: apiextensions.k8s.io/v1 +kind: CustomResourceDefinition +metadata: + annotations: + controller-gen.kubebuilder.io/version: v0.16.1 + creationTimestamp: null + name: iaadeviceplugins.deviceplugin.intel.com +spec: + group: deviceplugin.intel.com + names: + kind: IaaDevicePlugin + listKind: IaaDevicePluginList + plural: iaadeviceplugins + singular: iaadeviceplugin + scope: Cluster + versions: + - additionalPrinterColumns: + - jsonPath: .status.desiredNumberScheduled + name: Desired + type: integer + - jsonPath: .status.numberReady + name: Ready + type: integer + - jsonPath: .spec.nodeSelector + name: Node Selector + type: string + - jsonPath: .metadata.creationTimestamp + name: Age + type: date + name: v1 + schema: + openAPIV3Schema: + description: |- + IaaDevicePlugin is the Schema for the iaadeviceplugins API. It represents + the IAA device plugin responsible for advertising Intel IAA hardware resources to + the kubelet. + 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: IaaDevicePluginSpec defines the desired state of IaaDevicePlugin. + properties: + image: + description: Image is a container image with IAA device plugin executable. + type: string + initImage: + description: InitImage is an initcontainer image to configure and + enable IAA devices and workqueues with accel-config utility + type: string + logLevel: + description: LogLevel sets the plugin's log level. + minimum: 0 + type: integer + nodeSelector: + additionalProperties: + type: string + description: NodeSelector provides a simple way to constrain device + plugin pods to nodes with particular labels. + type: object + provisioningConfig: + description: ProvisioningConfig is a ConfigMap used to pass the IAA + configuration into idxd initcontainer. + type: string + sharedDevNum: + description: SharedDevNum is a number of containers that can share + the same IAA device. + minimum: 1 + type: integer + tolerations: + description: Specialized nodes (e.g., with accelerators) can be Tainted + to make sure unwanted pods are not scheduled on them. Tolerations + can be set for the plugin pod to neutralize the Taint. + items: + description: |- + The pod this Toleration is attached to tolerates any taint that matches + the triple using the matching 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 + status: + description: IaaDevicePluginStatus defines the observed state of IaaDevicePlugin. + properties: + controlledDaemonSet: + description: ControlledDaemoSet references the DaemonSet controlled + by the operator. + properties: + apiVersion: + description: API version of the referent. + type: string + fieldPath: + description: |- + If referring to a piece of an object instead of an entire object, this string + should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. + For example, if the object reference is to a container within a pod, this would take on a value like: + "spec.containers{name}" (where "name" refers to the name of the container that triggered + the event) or if no container name is specified "spec.containers[2]" (container with + index 2 in this pod). This syntax is chosen only to have some well-defined way of + referencing a part of an object. + type: string + kind: + description: |- + Kind of the referent. + More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds + type: string + name: + description: |- + Name of the referent. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names + type: string + namespace: + description: |- + Namespace of the referent. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/ + type: string + resourceVersion: + description: |- + Specific resourceVersion to which this reference is made, if any. + More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency + type: string + uid: + description: |- + UID of the referent. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids + type: string + type: object + x-kubernetes-map-type: atomic + desiredNumberScheduled: + description: |- + The total number of nodes that should be running the device plugin + pod (including nodes correctly running the device plugin pod). + format: int32 + type: integer + nodeNames: + description: The list of Node names where the device plugin pods are + running. + items: + type: string + type: array + numberReady: + description: |- + The number of nodes that should be running the device plugin pod and have one + or more of the device plugin pod running and ready. + format: int32 + type: integer + required: + - desiredNumberScheduled + - numberReady + type: object + type: object + served: true + storage: true + subresources: + status: {} +status: + acceptedNames: + kind: "" + plural: "" + conditions: null + storedVersions: null diff --git a/operators/intel-device-plugins-operator/0.31.0/manifests/deviceplugin.intel.com_qatdeviceplugins.yaml b/operators/intel-device-plugins-operator/0.31.0/manifests/deviceplugin.intel.com_qatdeviceplugins.yaml new file mode 100644 index 00000000000..bc9590c92e6 --- /dev/null +++ b/operators/intel-device-plugins-operator/0.31.0/manifests/deviceplugin.intel.com_qatdeviceplugins.yaml @@ -0,0 +1,236 @@ +apiVersion: apiextensions.k8s.io/v1 +kind: CustomResourceDefinition +metadata: + annotations: + controller-gen.kubebuilder.io/version: v0.16.1 + creationTimestamp: null + name: qatdeviceplugins.deviceplugin.intel.com +spec: + group: deviceplugin.intel.com + names: + kind: QatDevicePlugin + listKind: QatDevicePluginList + plural: qatdeviceplugins + singular: qatdeviceplugin + scope: Cluster + versions: + - additionalPrinterColumns: + - jsonPath: .status.desiredNumberScheduled + name: Desired + type: integer + - jsonPath: .status.numberReady + name: Ready + type: integer + - jsonPath: .spec.nodeSelector + name: Node Selector + type: string + - jsonPath: .metadata.creationTimestamp + name: Age + type: date + name: v1 + schema: + openAPIV3Schema: + description: |- + QatDevicePlugin is the Schema for the qatdeviceplugins API. It represents the QAT device + plugin responsible for advertising Intel QuickAssist Technology hardware resources + to the kubelet. + 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: QatDevicePluginSpec defines the desired state of QatDevicePlugin. + properties: + dpdkDriver: + description: DpdkDriver is a DPDK device driver for configuring the + QAT device. + enum: + - igb_uio + - vfio-pci + type: string + image: + description: Image is a container image with QAT device plugin executable. + type: string + initImage: + description: InitImage is a container image with a script that initialize + devices. + type: string + kernelVfDrivers: + description: KernelVfDrivers is a list of VF device drivers for the + QuickAssist devices in the system. + items: + description: KernelVfDriver is a VF device driver for QuickAssist + devices. + enum: + - dh895xccvf + - c6xxvf + - c3xxxvf + - d15xxvf + - 4xxxvf + - 420xxvf + - c4xxxvf + type: string + type: array + logLevel: + description: LogLevel sets the plugin's log level. + minimum: 0 + type: integer + maxNumDevices: + description: MaxNumDevices is a maximum number of QAT devices to be + provided to the QuickAssist device plugin + minimum: 1 + type: integer + nodeSelector: + additionalProperties: + type: string + description: NodeSelector provides a simple way to constrain device + plugin pods to nodes with particular labels. + type: object + preferredAllocationPolicy: + description: |- + PreferredAllocationPolicy sets the mode of allocating QAT devices on a node. + See documentation for detailed description of the policies. + enum: + - balanced + - packed + type: string + provisioningConfig: + description: ProvisioningConfig is a ConfigMap used to pass the configuration + of QAT devices into qat initcontainer. + type: string + tolerations: + description: Specialized nodes (e.g., with accelerators) can be Tainted + to make sure unwanted pods are not scheduled on them. Tolerations + can be set for the plugin pod to neutralize the Taint. + items: + description: |- + The pod this Toleration is attached to tolerates any taint that matches + the triple using the matching 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 + status: + description: QatDevicePluginStatus defines the observed state of QatDevicePlugin. + properties: + controlledDaemonSet: + description: ControlledDaemoSet references the DaemonSet controlled + by the operator. + properties: + apiVersion: + description: API version of the referent. + type: string + fieldPath: + description: |- + If referring to a piece of an object instead of an entire object, this string + should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. + For example, if the object reference is to a container within a pod, this would take on a value like: + "spec.containers{name}" (where "name" refers to the name of the container that triggered + the event) or if no container name is specified "spec.containers[2]" (container with + index 2 in this pod). This syntax is chosen only to have some well-defined way of + referencing a part of an object. + type: string + kind: + description: |- + Kind of the referent. + More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds + type: string + name: + description: |- + Name of the referent. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names + type: string + namespace: + description: |- + Namespace of the referent. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/ + type: string + resourceVersion: + description: |- + Specific resourceVersion to which this reference is made, if any. + More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency + type: string + uid: + description: |- + UID of the referent. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids + type: string + type: object + x-kubernetes-map-type: atomic + desiredNumberScheduled: + description: |- + The total number of nodes that should be running the device plugin + pod (including nodes correctly running the device plugin pod). + format: int32 + type: integer + nodeNames: + description: The list of Node names where the device plugin pods are + running. + items: + type: string + type: array + numberReady: + description: |- + The number of nodes that should be running the device plugin pod and have one + or more of the device plugin pod running and ready. + format: int32 + type: integer + required: + - desiredNumberScheduled + - numberReady + type: object + type: object + served: true + storage: true + subresources: + status: {} +status: + acceptedNames: + kind: "" + plural: "" + conditions: null + storedVersions: null diff --git a/operators/intel-device-plugins-operator/0.31.0/manifests/deviceplugin.intel.com_sgxdeviceplugins.yaml b/operators/intel-device-plugins-operator/0.31.0/manifests/deviceplugin.intel.com_sgxdeviceplugins.yaml new file mode 100644 index 00000000000..58d7c0cd52e --- /dev/null +++ b/operators/intel-device-plugins-operator/0.31.0/manifests/deviceplugin.intel.com_sgxdeviceplugins.yaml @@ -0,0 +1,207 @@ +apiVersion: apiextensions.k8s.io/v1 +kind: CustomResourceDefinition +metadata: + annotations: + controller-gen.kubebuilder.io/version: v0.16.1 + creationTimestamp: null + name: sgxdeviceplugins.deviceplugin.intel.com +spec: + group: deviceplugin.intel.com + names: + kind: SgxDevicePlugin + listKind: SgxDevicePluginList + plural: sgxdeviceplugins + singular: sgxdeviceplugin + scope: Cluster + versions: + - additionalPrinterColumns: + - jsonPath: .status.desiredNumberScheduled + name: Desired + type: integer + - jsonPath: .status.numberReady + name: Ready + type: integer + - jsonPath: .spec.nodeSelector + name: Node Selector + type: string + - jsonPath: .metadata.creationTimestamp + name: Age + type: date + name: v1 + schema: + openAPIV3Schema: + description: |- + SgxDevicePlugin is the Schema for the sgxdeviceplugins API. It represents + the SGX device plugin responsible for advertising SGX device nodes to + the kubelet. + 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: SgxDevicePluginSpec defines the desired state of SgxDevicePlugin. + properties: + enclaveLimit: + description: EnclaveLimit is a number of containers that can share + the same SGX enclave device. + minimum: 1 + type: integer + image: + description: Image is a container image with SGX device plugin executable. + type: string + initImage: + description: |- + InitImage is a container image with tools (i.e., SGX NFD source hook) installed on each node. + Recommendation is to leave this unset and prefer the SGX NodeFeatureRule instead. + type: string + logLevel: + description: LogLevel sets the plugin's log level. + minimum: 0 + type: integer + nodeSelector: + additionalProperties: + type: string + description: NodeSelector provides a simple way to constrain device + plugin pods to nodes with particular labels. + type: object + provisionLimit: + description: ProvisionLimit is a number of containers that can share + the same SGX provision device. + minimum: 1 + type: integer + tolerations: + description: Specialized nodes (e.g., with accelerators) can be Tainted + to make sure unwanted pods are not scheduled on them. Tolerations + can be set for the plugin pod to neutralize the Taint. + items: + description: |- + The pod this Toleration is attached to tolerates any taint that matches + the triple using the matching 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 + status: + description: SgxDevicePluginStatus defines the observed state of SgxDevicePlugin. + properties: + controlledDaemonSet: + description: ControlledDaemoSet references the DaemonSet controlled + by the operator. + properties: + apiVersion: + description: API version of the referent. + type: string + fieldPath: + description: |- + If referring to a piece of an object instead of an entire object, this string + should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. + For example, if the object reference is to a container within a pod, this would take on a value like: + "spec.containers{name}" (where "name" refers to the name of the container that triggered + the event) or if no container name is specified "spec.containers[2]" (container with + index 2 in this pod). This syntax is chosen only to have some well-defined way of + referencing a part of an object. + type: string + kind: + description: |- + Kind of the referent. + More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds + type: string + name: + description: |- + Name of the referent. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names + type: string + namespace: + description: |- + Namespace of the referent. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/ + type: string + resourceVersion: + description: |- + Specific resourceVersion to which this reference is made, if any. + More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency + type: string + uid: + description: |- + UID of the referent. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids + type: string + type: object + x-kubernetes-map-type: atomic + desiredNumberScheduled: + description: |- + The total number of nodes that should be running the device plugin + pod (including nodes correctly running the device plugin pod). + format: int32 + type: integer + nodeNames: + description: The list of Node names where the device plugin pods are + running. + items: + type: string + type: array + numberReady: + description: |- + The number of nodes that should be running the device plugin pod and have one + or more of the device plugin pod running and ready. + format: int32 + type: integer + required: + - desiredNumberScheduled + - numberReady + type: object + type: object + served: true + storage: true + subresources: + status: {} +status: + acceptedNames: + kind: "" + plural: "" + conditions: null + storedVersions: null diff --git a/operators/intel-device-plugins-operator/0.31.0/manifests/fpga.intel.com_acceleratorfunctions.yaml b/operators/intel-device-plugins-operator/0.31.0/manifests/fpga.intel.com_acceleratorfunctions.yaml new file mode 100644 index 00000000000..3815f15f64e --- /dev/null +++ b/operators/intel-device-plugins-operator/0.31.0/manifests/fpga.intel.com_acceleratorfunctions.yaml @@ -0,0 +1,74 @@ +apiVersion: apiextensions.k8s.io/v1 +kind: CustomResourceDefinition +metadata: + annotations: + controller-gen.kubebuilder.io/version: v0.16.1 + creationTimestamp: null + name: acceleratorfunctions.fpga.intel.com +spec: + group: fpga.intel.com + names: + kind: AcceleratorFunction + listKind: AcceleratorFunctionList + plural: acceleratorfunctions + shortNames: + - af + singular: acceleratorfunction + scope: Namespaced + versions: + - name: v2 + schema: + openAPIV3Schema: + description: |- + AcceleratorFunction is a specification for an Accelerator Function resource + provided by a FPGA-based programmable hardware accelerator. + 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: AcceleratorFunctionSpec contains actual specs for AcceleratorFunction. + properties: + afuId: + pattern: ^[0-9a-f]{8,40}$ + type: string + interfaceId: + pattern: ^[0-9a-f]{8,32}$ + type: string + mode: + pattern: ^af|region$ + type: string + required: + - afuId + - interfaceId + - mode + type: object + status: + description: AcceleratorFunctionStatus is an empty object used to satisfy + operator-sdk. + type: object + required: + - spec + type: object + served: true + storage: true +status: + acceptedNames: + kind: "" + plural: "" + conditions: null + storedVersions: null diff --git a/operators/intel-device-plugins-operator/0.31.0/manifests/fpga.intel.com_fpgaregions.yaml b/operators/intel-device-plugins-operator/0.31.0/manifests/fpga.intel.com_fpgaregions.yaml new file mode 100644 index 00000000000..49e2ec2d128 --- /dev/null +++ b/operators/intel-device-plugins-operator/0.31.0/manifests/fpga.intel.com_fpgaregions.yaml @@ -0,0 +1,65 @@ +apiVersion: apiextensions.k8s.io/v1 +kind: CustomResourceDefinition +metadata: + annotations: + controller-gen.kubebuilder.io/version: v0.16.1 + creationTimestamp: null + name: fpgaregions.fpga.intel.com +spec: + group: fpga.intel.com + names: + kind: FpgaRegion + listKind: FpgaRegionList + plural: fpgaregions + shortNames: + - fpga + singular: fpgaregion + scope: Namespaced + versions: + - name: v2 + schema: + openAPIV3Schema: + description: |- + FpgaRegion is a specification for a FPGA region resource which can be programmed + with a bitstream. + 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: FpgaRegionSpec contains actual specs for FpgaRegion. + properties: + interfaceId: + pattern: ^[0-9a-f]{8,32}$ + type: string + required: + - interfaceId + type: object + status: + description: FpgaRegionStatus is an empty object used to satisfy operator-sdk. + type: object + required: + - spec + type: object + served: true + storage: true +status: + acceptedNames: + kind: "" + plural: "" + conditions: null + storedVersions: null diff --git a/operators/intel-device-plugins-operator/0.31.0/manifests/intel-device-plugins-operator.clusterserviceversion.yaml b/operators/intel-device-plugins-operator/0.31.0/manifests/intel-device-plugins-operator.clusterserviceversion.yaml new file mode 100644 index 00000000000..50d095fdeb3 --- /dev/null +++ b/operators/intel-device-plugins-operator/0.31.0/manifests/intel-device-plugins-operator.clusterserviceversion.yaml @@ -0,0 +1,1102 @@ +apiVersion: operators.coreos.com/v1alpha1 +kind: ClusterServiceVersion +metadata: + annotations: + alm-examples: |- + [ + { + "apiVersion": "deviceplugin.intel.com/v1", + "kind": "DlbDevicePlugin", + "metadata": { + "name": "dlbdeviceplugin-sample" + }, + "spec": { + "image": "intel/intel-dlb-plugin:0.31.0", + "initImage": "intel/intel-dlb-initcontainer:0.31.0", + "logLevel": 4, + "nodeSelector": { + "intel.feature.node.kubernetes.io/dlb": "true" + } + } + }, + { + "apiVersion": "deviceplugin.intel.com/v1", + "kind": "DsaDevicePlugin", + "metadata": { + "name": "dsadeviceplugin-sample" + }, + "spec": { + "image": "intel/intel-dsa-plugin:0.31.0", + "initImage": "intel/intel-idxd-config-initcontainer:0.31.0", + "logLevel": 4, + "nodeSelector": { + "intel.feature.node.kubernetes.io/dsa": "true" + }, + "sharedDevNum": 10 + } + }, + { + "apiVersion": "deviceplugin.intel.com/v1", + "kind": "FpgaDevicePlugin", + "metadata": { + "name": "fpgadeviceplugin-sample" + }, + "spec": { + "image": "intel/intel-fpga-plugin:0.31.0", + "initImage": "intel/intel-fpga-initcontainer:0.31.0", + "logLevel": 4, + "mode": "region", + "nodeSelector": { + "intel.feature.node.kubernetes.io/fpga-arria10": "true" + } + } + }, + { + "apiVersion": "deviceplugin.intel.com/v1", + "kind": "GpuDevicePlugin", + "metadata": { + "name": "gpudeviceplugin-sample" + }, + "spec": { + "enableMonitoring": true, + "image": "intel/intel-gpu-plugin:0.31.0", + "logLevel": 4, + "nodeSelector": { + "intel.feature.node.kubernetes.io/gpu": "true" + }, + "sharedDevNum": 10 + } + }, + { + "apiVersion": "deviceplugin.intel.com/v1", + "kind": "IaaDevicePlugin", + "metadata": { + "name": "iaadeviceplugin-sample" + }, + "spec": { + "image": "intel/intel-iaa-plugin:0.31.0", + "initImage": "intel/intel-idxd-config-initcontainer:0.31.0", + "logLevel": 4, + "nodeSelector": { + "intel.feature.node.kubernetes.io/iaa": "true" + }, + "sharedDevNum": 10 + } + }, + { + "apiVersion": "deviceplugin.intel.com/v1", + "kind": "QatDevicePlugin", + "metadata": { + "name": "qatdeviceplugin-sample" + }, + "spec": { + "dpdkDriver": "vfio-pci", + "image": "intel/intel-qat-plugin:0.31.0", + "initImage": "intel/intel-qat-initcontainer:0.31.0", + "kernelVfDrivers": [ + "4xxxvf", + "420xxvf" + ], + "logLevel": 4, + "maxNumDevices": 1, + "nodeSelector": { + "intel.feature.node.kubernetes.io/qat": "true" + } + } + }, + { + "apiVersion": "deviceplugin.intel.com/v1", + "kind": "SgxDevicePlugin", + "metadata": { + "name": "sgxdeviceplugin-sample" + }, + "spec": { + "enclaveLimit": 110, + "image": "intel/intel-sgx-plugin:0.31.0", + "logLevel": 4, + "nodeSelector": { + "intel.feature.node.kubernetes.io/sgx": "true" + }, + "provisionLimit": 110 + } + }, + { + "apiVersion": "fpga.intel.com/v2", + "kind": "AcceleratorFunction", + "metadata": { + "name": "arria10.dcp1.0-nlb0-orchestrated" + }, + "spec": { + "afuId": "d8424dc4a4a3c413f89e433683f9040b", + "interfaceId": "ce48969398f05f33946d560708be108a", + "mode": "region" + } + }, + { + "apiVersion": "fpga.intel.com/v2", + "kind": "AcceleratorFunction", + "metadata": { + "name": "arria10.dcp1.0-nlb0-preprogrammed" + }, + "spec": { + "afuId": "d8424dc4a4a3c413f89e433683f9040b", + "interfaceId": "ce48969398f05f33946d560708be108a", + "mode": "af" + } + }, + { + "apiVersion": "fpga.intel.com/v2", + "kind": "AcceleratorFunction", + "metadata": { + "name": "arria10.dcp1.0-nlb3-orchestrated" + }, + "spec": { + "afuId": "f7df405cbd7acf7222f144b0b93acd18", + "interfaceId": "ce48969398f05f33946d560708be108a", + "mode": "region" + } + }, + { + "apiVersion": "fpga.intel.com/v2", + "kind": "AcceleratorFunction", + "metadata": { + "name": "arria10.dcp1.0-nlb3-preprogrammed" + }, + "spec": { + "afuId": "f7df405cbd7acf7222f144b0b93acd18", + "interfaceId": "ce48969398f05f33946d560708be108a", + "mode": "af" + } + }, + { + "apiVersion": "fpga.intel.com/v2", + "kind": "AcceleratorFunction", + "metadata": { + "name": "arria10.dcp1.1-nlb0-orchestrated" + }, + "spec": { + "afuId": "d8424dc4a4a3c413f89e433683f9040b", + "interfaceId": "9926ab6d6c925a68aabca7d84c545738", + "mode": "region" + } + }, + { + "apiVersion": "fpga.intel.com/v2", + "kind": "AcceleratorFunction", + "metadata": { + "name": "arria10.dcp1.1-nlb0-preprogrammed" + }, + "spec": { + "afuId": "d8424dc4a4a3c413f89e433683f9040b", + "interfaceId": "9926ab6d6c925a68aabca7d84c545738", + "mode": "af" + } + }, + { + "apiVersion": "fpga.intel.com/v2", + "kind": "AcceleratorFunction", + "metadata": { + "name": "arria10.dcp1.1-nlb3-orchestrated" + }, + "spec": { + "afuId": "f7df405cbd7acf7222f144b0b93acd18", + "interfaceId": "9926ab6d6c925a68aabca7d84c545738", + "mode": "region" + } + }, + { + "apiVersion": "fpga.intel.com/v2", + "kind": "AcceleratorFunction", + "metadata": { + "name": "arria10.dcp1.1-nlb3-preprogrammed" + }, + "spec": { + "afuId": "f7df405cbd7acf7222f144b0b93acd18", + "interfaceId": "9926ab6d6c925a68aabca7d84c545738", + "mode": "af" + } + }, + { + "apiVersion": "fpga.intel.com/v2", + "kind": "AcceleratorFunction", + "metadata": { + "name": "arria10.dcp1.2-nlb0-orchestrated" + }, + "spec": { + "afuId": "d8424dc4a4a3c413f89e433683f9040b", + "interfaceId": "69528db6eb31577a8c3668f9faa081f6", + "mode": "region" + } + }, + { + "apiVersion": "fpga.intel.com/v2", + "kind": "AcceleratorFunction", + "metadata": { + "name": "arria10.dcp1.2-nlb0-preprogrammed" + }, + "spec": { + "afuId": "d8424dc4a4a3c413f89e433683f9040b", + "interfaceId": "69528db6eb31577a8c3668f9faa081f6", + "mode": "af" + } + }, + { + "apiVersion": "fpga.intel.com/v2", + "kind": "AcceleratorFunction", + "metadata": { + "name": "arria10.dcp1.2-nlb3-orchestrated" + }, + "spec": { + "afuId": "f7df405cbd7acf7222f144b0b93acd18", + "interfaceId": "69528db6eb31577a8c3668f9faa081f6", + "mode": "region" + } + }, + { + "apiVersion": "fpga.intel.com/v2", + "kind": "AcceleratorFunction", + "metadata": { + "name": "arria10.dcp1.2-nlb3-preprogrammed" + }, + "spec": { + "afuId": "f7df405cbd7acf7222f144b0b93acd18", + "interfaceId": "69528db6eb31577a8c3668f9faa081f6", + "mode": "af" + } + }, + { + "apiVersion": "fpga.intel.com/v2", + "kind": "AcceleratorFunction", + "metadata": { + "name": "d5005-matrix-mult-orchestrated" + }, + "spec": { + "afuId": "40007c0623210742000ebc58df6f5343e668b03a", + "interfaceId": "bfac4d851ee856fe8c95865ce1bbaa2d", + "mode": "region" + } + }, + { + "apiVersion": "fpga.intel.com/v2", + "kind": "AcceleratorFunction", + "metadata": { + "name": "d5005-nlb0-orchestrated" + }, + "spec": { + "afuId": "d8424dc4a4a3c413f89e433683f9040b", + "interfaceId": "bfac4d851ee856fe8c95865ce1bbaa2d", + "mode": "region" + } + }, + { + "apiVersion": "fpga.intel.com/v2", + "kind": "AcceleratorFunction", + "metadata": { + "name": "d5005-nlb0-preprogrammed" + }, + "spec": { + "afuId": "d8424dc4a4a3c413f89e433683f9040b", + "interfaceId": "bfac4d851ee856fe8c95865ce1bbaa2d", + "mode": "af" + } + }, + { + "apiVersion": "fpga.intel.com/v2", + "kind": "AcceleratorFunction", + "metadata": { + "name": "d5005-nlb3-orchestrated" + }, + "spec": { + "afuId": "f7df405cbd7acf7222f144b0b93acd18", + "interfaceId": "bfac4d851ee856fe8c95865ce1bbaa2d", + "mode": "region" + } + }, + { + "apiVersion": "fpga.intel.com/v2", + "kind": "AcceleratorFunction", + "metadata": { + "name": "d5005-nlb3-preprogrammed" + }, + "spec": { + "afuId": "f7df405cbd7acf7222f144b0b93acd18", + "interfaceId": "bfac4d851ee856fe8c95865ce1bbaa2d", + "mode": "af" + } + }, + { + "apiVersion": "fpga.intel.com/v2", + "kind": "FpgaRegion", + "metadata": { + "name": "arria10.dcp1.0" + }, + "spec": { + "interfaceId": "ce48969398f05f33946d560708be108a" + } + }, + { + "apiVersion": "fpga.intel.com/v2", + "kind": "FpgaRegion", + "metadata": { + "name": "arria10.dcp1.1" + }, + "spec": { + "interfaceId": "9926ab6d6c925a68aabca7d84c545738" + } + }, + { + "apiVersion": "fpga.intel.com/v2", + "kind": "FpgaRegion", + "metadata": { + "name": "arria10.dcp1.2" + }, + "spec": { + "interfaceId": "69528db6eb31577a8c3668f9faa081f6" + } + }, + { + "apiVersion": "fpga.intel.com/v2", + "kind": "FpgaRegion", + "metadata": { + "name": "d5005" + }, + "spec": { + "interfaceId": "bfac4d851ee856fe8c95865ce1bbaa2d" + } + } + ] + capabilities: Full Lifecycle + categories: Drivers and plugins + containerImage: docker.io/intel/intel-deviceplugin-operator@sha256:d04f4cbab05b80d53aee0456def2a11ce6574ee341991ab8e70f286c72f6b8d4 + createdAt: "2024-09-30T20:57:23Z" + description: This operator is a Kubernetes custom controller whose goal is to serve the installation and lifecycle management of Intel device plugins for Kubernetes. + operators.operatorframework.io/builder: operator-sdk-v1.37.0 + operators.operatorframework.io/project_layout: go.kubebuilder.io/v2 + repository: https://github.com/intel/intel-device-plugins-for-kubernetes + name: intel-device-plugins-operator.v0.31.0 + namespace: placeholder +spec: + apiservicedefinitions: {} + customresourcedefinitions: + owned: + - description: |- + AcceleratorFunction is a specification for an Accelerator Function resource + provided by a FPGA-based programmable hardware accelerator. + displayName: Accelerator Function + kind: AcceleratorFunction + name: acceleratorfunctions.fpga.intel.com + version: v2 + - description: DlbDevicePlugin is the Schema for the dlbdeviceplugins API. It represents the DLB device plugin responsible for advertising DLB device nodes to the kubelet. + displayName: Intel Dynamic Load Balancer Device Plugin + kind: DlbDevicePlugin + name: dlbdeviceplugins.deviceplugin.intel.com + version: v1 + - description: DsaDevicePlugin is the Schema for the dsadeviceplugins API. It represents the DSA device plugin responsible for advertising Intel DSA hardware resources to the kubelet. + displayName: Intel DSA Device Plugin + kind: DsaDevicePlugin + name: dsadeviceplugins.deviceplugin.intel.com + version: v1 + - description: |- + FpgaDevicePlugin is the Schema for the fpgadeviceplugins API. It represents + the FPGA device plugin responsible for advertising Intel FPGA hardware resources to + the kubelet. + displayName: Intel FPGA Device Plugin + kind: FpgaDevicePlugin + name: fpgadeviceplugins.deviceplugin.intel.com + version: v1 + - description: |- + FpgaRegion is a specification for a FPGA region resource which can be programmed + with a bitstream. + displayName: FPGA Region + kind: FpgaRegion + name: fpgaregions.fpga.intel.com + version: v2 + - description: |- + GpuDevicePlugin is the Schema for the gpudeviceplugins API. It represents + the GPU device plugin responsible for advertising Intel GPU hardware resources to + the kubelet. + displayName: Intel GPU Device Plugin + kind: GpuDevicePlugin + name: gpudeviceplugins.deviceplugin.intel.com + version: v1 + - description: IaaDevicePlugin is the Schema for the iaadeviceplugins API. It represents the IAA device plugin responsible for advertising Intel IAA hardware resources to the kubelet. + displayName: Intel IAA Device Plugin + kind: IaaDevicePlugin + name: iaadeviceplugins.deviceplugin.intel.com + version: v1 + - description: |- + QatDevicePlugin is the Schema for the qatdeviceplugins API. It represents the QAT device + plugin responsible for advertising Intel QuickAssist Technology hardware resources + to the kubelet. + displayName: Intel QuickAssist Technology Device Plugin + kind: QatDevicePlugin + name: qatdeviceplugins.deviceplugin.intel.com + version: v1 + - description: |- + SgxDevicePlugin is the Schema for the sgxdeviceplugins API. It represents + the SGX device plugin responsible for advertising SGX device nodes to + the kubelet. + displayName: Intel Software Guard Extensions Device Plugin + kind: SgxDevicePlugin + name: sgxdeviceplugins.deviceplugin.intel.com + version: v1 + description: | + [Intel Device Plugins for Kubernetes](https://github.com/intel/intel-device-plugins-for-kubernetes) is a collection of + [device plugins](https://kubernetes.io/docs/concepts/extend-kubernetes/compute-storage-net/device-plugins/) advertising Intel specific hardware resources + to the kubelet. Currently the operator has basic support for the QAT, GPU, FPGA, SGX, DSA, IAA device plugins: it validates container image references and extends + reported statuses. + displayName: Intel Device Plugins Operator + icon: + - base64data: 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 + mediatype: image/png + install: + spec: + clusterPermissions: + - rules: + - apiGroups: + - "" + resources: + - nodes/proxy + verbs: + - get + - list + - apiGroups: + - "" + resources: + - pods + verbs: + - get + - list + - watch + - apiGroups: + - "" + resources: + - serviceaccounts + verbs: + - create + - delete + - get + - list + - watch + - apiGroups: + - apps + resources: + - daemonsets + verbs: + - create + - delete + - get + - list + - patch + - update + - watch + - apiGroups: + - coordination.k8s.io + resources: + - leases + verbs: + - create + - apiGroups: + - coordination.k8s.io + resourceNames: + - d1c7b6d5.intel.com + resources: + - leases + verbs: + - get + - update + - apiGroups: + - deviceplugin.intel.com + resources: + - dlbdeviceplugins + - dsadeviceplugins + - fpgadeviceplugins + - gpudeviceplugins + - iaadeviceplugins + - qatdeviceplugins + - sgxdeviceplugins + verbs: + - create + - delete + - get + - list + - patch + - update + - watch + - apiGroups: + - deviceplugin.intel.com + resources: + - dlbdeviceplugins/finalizers + - dsadeviceplugins/finalizers + - fpgadeviceplugins/finalizers + - gpudeviceplugins/finalizers + - iaadeviceplugins/finalizers + - qatdeviceplugins/finalizers + - sgxdeviceplugins/finalizers + verbs: + - update + - apiGroups: + - deviceplugin.intel.com + resources: + - dlbdeviceplugins/status + - dsadeviceplugins/status + - fpgadeviceplugins/status + - gpudeviceplugins/status + - iaadeviceplugins/status + - qatdeviceplugins/status + - sgxdeviceplugins/status + verbs: + - get + - patch + - update + - apiGroups: + - fpga.intel.com + resources: + - acceleratorfunctions + - fpgaregions + verbs: + - get + - list + - watch + - apiGroups: + - rbac.authorization.k8s.io + resources: + - clusterrolebindings + verbs: + - create + - delete + - get + - list + - watch + - apiGroups: + - security.openshift.io + resources: + - securitycontextconstraints + verbs: + - use + - apiGroups: + - authentication.k8s.io + resources: + - tokenreviews + verbs: + - create + - apiGroups: + - authorization.k8s.io + resources: + - subjectaccessreviews + verbs: + - create + serviceAccountName: default + deployments: + - label: + control-plane: controller-manager + manager: intel-deviceplugin-operator + name: inteldeviceplugins-controller-manager + spec: + replicas: 1 + selector: + matchLabels: + control-plane: controller-manager + manager: intel-deviceplugin-operator + strategy: {} + template: + metadata: + labels: + control-plane: controller-manager + manager: intel-deviceplugin-operator + spec: + containers: + - args: + - --metrics-bind-address=127.0.0.1:8080 + - --leader-elect + env: + - name: DEVICEPLUGIN_NAMESPACE + valueFrom: + fieldRef: + fieldPath: metadata.namespace + - name: INTEL_DLB_PLUGIN_SHA + value: intel/intel-dlb-plugin@sha256:f2d53ebe5cc238100d99b40c118d9ccbe8a5a90a627d421b99e6f1b47c61c3e7 + - name: INTEL_DLB_INITCONTAINER_SHA + value: intel/intel-dlb-initcontainer@sha256:9f5135fcd450b011f49bc7a7d42fee4e9988d67325c736ee6616ea6a0c510fce + - name: INTEL_DSA_PLUGIN_SHA + value: intel/intel-dsa-plugin@sha256:092a372d6dd0df39054ac720f5abb245c4599a2c592d231547a640f6bdc50b18 + - name: INTEL_IDXD_CONFIG_INITCONTAINER_SHA + value: intel/intel-idxd-config-initcontainer@sha256:79f098e890d620030c45dc5f6f485f97084e2d3c151e255f9b484dbf7d94837e + - name: INTEL_FPGA_PLUGIN_SHA + value: intel/intel-fpga-plugin@sha256:092b10365ab5412657ee2fc557b213f252d736feb31f37411e5c753306168153 + - name: INTEL_FPGA_INITCONTAINER_SHA + value: intel/intel-fpga-initcontainer@sha256:c564c82603c295991d32dac458c4a128d69341da3c8a398019d17187f6e8c6ee + - name: INTEL_GPU_PLUGIN_SHA + value: intel/intel-gpu-plugin@sha256:0e9b1c383c2b6b2690a9a6143c1d613e5b809abb4c27f8a38dd0f2a29e176896 + - name: INTEL_GPU_INITCONTAINER_SHA + value: intel/intel-gpu-initcontainer@sha256:804d1f7b3a52f9d4d232878c0d97a80dc059b38447372f3d0d922767f108e878 + - name: INTEL_IAA_PLUGIN_SHA + value: intel/intel-iaa-plugin@sha256:4b8c36c35141bc397c04378a5bee09f60ff8b225e2783e09da320bb219e3e823 + - name: INTEL_QAT_PLUGIN_SHA + value: intel/intel-qat-plugin@sha256:69858421d6abd38867f61844db2c3fa7275bf6c089efd547e7de98dfc0c90a1a + - name: INTEL_QAT_INITCONTAINER_SHA + value: intel/intel-qat-initcontainer@sha256:db3f56197b481d6a3a0f1198223bceb4e6636486b95475cb1c5dc3dd95672dab + - name: INTEL_SGX_PLUGIN_SHA + value: intel/intel-sgx-plugin@sha256:eec91b2f62029998b5ceae8067fcd3506b4f957828b8f6e3061581f860862db5 + - name: INTEL_SGX_INITCONTAINER_SHA + value: intel/intel-sgx-initcontainer@sha256:12f66b26eeddcffdef1f04b7bcbb666c4c170c8ecb58ea917781c8d0697e4365 + image: docker.io/intel/intel-deviceplugin-operator@sha256:d04f4cbab05b80d53aee0456def2a11ce6574ee341991ab8e70f286c72f6b8d4 + imagePullPolicy: IfNotPresent + livenessProbe: + httpGet: + path: /healthz + port: 8081 + initialDelaySeconds: 15 + periodSeconds: 20 + name: manager + ports: + - containerPort: 9443 + name: webhook-server + protocol: TCP + readinessProbe: + httpGet: + path: /readyz + port: 8081 + initialDelaySeconds: 5 + periodSeconds: 10 + resources: + limits: + cpu: 100m + memory: 120Mi + requests: + cpu: 100m + memory: 100Mi + securityContext: + allowPrivilegeEscalation: false + capabilities: + drop: + - ALL + readOnlyRootFilesystem: true + runAsGroup: 65532 + runAsNonRoot: true + runAsUser: 65532 + seccompProfile: + type: RuntimeDefault + volumeMounts: + - mountPath: /tmp/k8s-webhook-server/serving-certs + name: cert + readOnly: true + - args: + - --secure-listen-address=0.0.0.0:8443 + - --upstream=http://127.0.0.1:8080/ + - --logtostderr=true + - --tls-cipher-suites=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 + - --v=10 + image: quay.io/brancz/kube-rbac-proxy@sha256:e6a323504999b2a4d2a6bf94f8580a050378eba0900fd31335cf9df5787d9a9b + name: kube-rbac-proxy + ports: + - containerPort: 8443 + name: https + resources: {} + securityContext: + allowPrivilegeEscalation: false + readOnlyRootFilesystem: true + runAsGroup: 1000 + runAsNonRoot: true + runAsUser: 1000 + serviceAccountName: default + terminationGracePeriodSeconds: 120 + volumes: + - name: cert + secret: + defaultMode: 420 + secretName: webhook-server-cert + permissions: + - rules: + - apiGroups: + - "" + resources: + - configmaps + verbs: + - get + - list + - watch + - create + - update + - patch + - delete + - apiGroups: + - coordination.k8s.io + resources: + - leases + verbs: + - get + - list + - watch + - create + - update + - patch + - delete + - apiGroups: + - "" + resources: + - events + verbs: + - create + - patch + serviceAccountName: default + strategy: deployment + installModes: + - supported: false + type: OwnNamespace + - supported: false + type: SingleNamespace + - supported: false + type: MultiNamespace + - supported: true + type: AllNamespaces + keywords: + - fpga + - qat + - sgx + - gpu + - dsa + - dlb + links: + - name: Intel Device Plugins Operator + url: https://github.com/intel/intel-device-plugins-for-kubernetes + maintainers: + - email: hyeongju.lee@intel.com + name: Hyeongju Lee + - email: mikko.ylinen@intel.com + name: Mikko Ylinen + maturity: alpha + minKubeVersion: 1.21.0 + provider: + name: Intel® Corporation + url: https://intel.com + relatedImages: + - image: docker.io/intel/intel-deviceplugin-operator@sha256:d04f4cbab05b80d53aee0456def2a11ce6574ee341991ab8e70f286c72f6b8d4 + name: manager + - image: quay.io/brancz/kube-rbac-proxy@sha256:e6a323504999b2a4d2a6bf94f8580a050378eba0900fd31335cf9df5787d9a9b + name: kube-rbac-proxy + - image: docker.io/intel/intel-deviceplugin-operator@sha256:d04f4cbab05b80d53aee0456def2a11ce6574ee341991ab8e70f286c72f6b8d4 + name: intel-deviceplugin-operator-d04f4cbab05b80d53aee0456def2a11ce6574ee341991ab8e70f286c72f6b8d4-annotation + replaces: intel-device-plugins-operator.v0.30.0 + version: 0.31.0 + webhookdefinitions: + - admissionReviewVersions: + - v1 + containerPort: 443 + deploymentName: inteldeviceplugins-controller-manager + failurePolicy: Ignore + generateName: fpga.mutator.webhooks.intel.com + rules: + - apiGroups: + - "" + apiVersions: + - v1 + operations: + - CREATE + resources: + - pods + sideEffects: None + targetPort: 9443 + type: MutatingAdmissionWebhook + webhookPath: /pods + - admissionReviewVersions: + - v1 + containerPort: 443 + deploymentName: inteldeviceplugins-controller-manager + failurePolicy: Fail + generateName: mdlbdeviceplugin.kb.io + rules: + - apiGroups: + - deviceplugin.intel.com + apiVersions: + - v1 + operations: + - CREATE + - UPDATE + resources: + - dlbdeviceplugins + sideEffects: None + targetPort: 9443 + type: MutatingAdmissionWebhook + webhookPath: /mutate-deviceplugin-intel-com-v1-dlbdeviceplugin + - admissionReviewVersions: + - v1 + containerPort: 443 + deploymentName: inteldeviceplugins-controller-manager + failurePolicy: Fail + generateName: mdsadeviceplugin.kb.io + rules: + - apiGroups: + - deviceplugin.intel.com + apiVersions: + - v1 + operations: + - CREATE + - UPDATE + resources: + - dsadeviceplugins + sideEffects: None + targetPort: 9443 + type: MutatingAdmissionWebhook + webhookPath: /mutate-deviceplugin-intel-com-v1-dsadeviceplugin + - admissionReviewVersions: + - v1 + containerPort: 443 + deploymentName: inteldeviceplugins-controller-manager + failurePolicy: Fail + generateName: mfpgadeviceplugin.kb.io + rules: + - apiGroups: + - deviceplugin.intel.com + apiVersions: + - v1 + operations: + - CREATE + - UPDATE + resources: + - fpgadeviceplugins + sideEffects: None + targetPort: 9443 + type: MutatingAdmissionWebhook + webhookPath: /mutate-deviceplugin-intel-com-v1-fpgadeviceplugin + - admissionReviewVersions: + - v1 + containerPort: 443 + deploymentName: inteldeviceplugins-controller-manager + failurePolicy: Fail + generateName: mgpudeviceplugin.kb.io + rules: + - apiGroups: + - deviceplugin.intel.com + apiVersions: + - v1 + operations: + - CREATE + - UPDATE + resources: + - gpudeviceplugins + sideEffects: None + targetPort: 9443 + type: MutatingAdmissionWebhook + webhookPath: /mutate-deviceplugin-intel-com-v1-gpudeviceplugin + - admissionReviewVersions: + - v1 + containerPort: 443 + deploymentName: inteldeviceplugins-controller-manager + failurePolicy: Fail + generateName: miaadeviceplugin.kb.io + rules: + - apiGroups: + - deviceplugin.intel.com + apiVersions: + - v1 + operations: + - CREATE + - UPDATE + resources: + - iaadeviceplugins + sideEffects: None + targetPort: 9443 + type: MutatingAdmissionWebhook + webhookPath: /mutate-deviceplugin-intel-com-v1-iaadeviceplugin + - admissionReviewVersions: + - v1 + containerPort: 443 + deploymentName: inteldeviceplugins-controller-manager + failurePolicy: Fail + generateName: mqatdeviceplugin.kb.io + rules: + - apiGroups: + - deviceplugin.intel.com + apiVersions: + - v1 + operations: + - CREATE + - UPDATE + resources: + - qatdeviceplugins + sideEffects: None + targetPort: 9443 + type: MutatingAdmissionWebhook + webhookPath: /mutate-deviceplugin-intel-com-v1-qatdeviceplugin + - admissionReviewVersions: + - v1 + containerPort: 443 + deploymentName: inteldeviceplugins-controller-manager + failurePolicy: Fail + generateName: msgxdeviceplugin.kb.io + reinvocationPolicy: IfNeeded + rules: + - apiGroups: + - deviceplugin.intel.com + apiVersions: + - v1 + operations: + - CREATE + - UPDATE + resources: + - sgxdeviceplugins + sideEffects: None + targetPort: 9443 + type: MutatingAdmissionWebhook + webhookPath: /mutate-deviceplugin-intel-com-v1-sgxdeviceplugin + - admissionReviewVersions: + - v1 + containerPort: 443 + deploymentName: inteldeviceplugins-controller-manager + failurePolicy: Ignore + generateName: sgx.mutator.webhooks.intel.com + reinvocationPolicy: IfNeeded + rules: + - apiGroups: + - "" + apiVersions: + - v1 + operations: + - CREATE + resources: + - pods + sideEffects: None + targetPort: 9443 + type: MutatingAdmissionWebhook + webhookPath: /mutate--v1-pod + - admissionReviewVersions: + - v1 + containerPort: 443 + deploymentName: inteldeviceplugins-controller-manager + failurePolicy: Fail + generateName: vdlbdeviceplugin.kb.io + rules: + - apiGroups: + - deviceplugin.intel.com + apiVersions: + - v1 + operations: + - CREATE + - UPDATE + resources: + - dlbdeviceplugins + sideEffects: None + targetPort: 9443 + type: ValidatingAdmissionWebhook + webhookPath: /validate-deviceplugin-intel-com-v1-dlbdeviceplugin + - admissionReviewVersions: + - v1 + containerPort: 443 + deploymentName: inteldeviceplugins-controller-manager + failurePolicy: Fail + generateName: vdsadeviceplugin.kb.io + rules: + - apiGroups: + - deviceplugin.intel.com + apiVersions: + - v1 + operations: + - CREATE + - UPDATE + resources: + - dsadeviceplugins + sideEffects: None + targetPort: 9443 + type: ValidatingAdmissionWebhook + webhookPath: /validate-deviceplugin-intel-com-v1-dsadeviceplugin + - admissionReviewVersions: + - v1 + containerPort: 443 + deploymentName: inteldeviceplugins-controller-manager + failurePolicy: Fail + generateName: vfpgadeviceplugin.kb.io + rules: + - apiGroups: + - deviceplugin.intel.com + apiVersions: + - v1 + operations: + - CREATE + - UPDATE + resources: + - fpgadeviceplugins + sideEffects: None + targetPort: 9443 + type: ValidatingAdmissionWebhook + webhookPath: /validate-deviceplugin-intel-com-v1-fpgadeviceplugin + - admissionReviewVersions: + - v1 + containerPort: 443 + deploymentName: inteldeviceplugins-controller-manager + failurePolicy: Fail + generateName: vgpudeviceplugin.kb.io + rules: + - apiGroups: + - deviceplugin.intel.com + apiVersions: + - v1 + operations: + - CREATE + - UPDATE + resources: + - gpudeviceplugins + sideEffects: None + targetPort: 9443 + type: ValidatingAdmissionWebhook + webhookPath: /validate-deviceplugin-intel-com-v1-gpudeviceplugin + - admissionReviewVersions: + - v1 + containerPort: 443 + deploymentName: inteldeviceplugins-controller-manager + failurePolicy: Fail + generateName: viaadeviceplugin.kb.io + rules: + - apiGroups: + - deviceplugin.intel.com + apiVersions: + - v1 + operations: + - CREATE + - UPDATE + resources: + - iaadeviceplugins + sideEffects: None + targetPort: 9443 + type: ValidatingAdmissionWebhook + webhookPath: /validate-deviceplugin-intel-com-v1-iaadeviceplugin + - admissionReviewVersions: + - v1 + containerPort: 443 + deploymentName: inteldeviceplugins-controller-manager + failurePolicy: Fail + generateName: vqatdeviceplugin.kb.io + rules: + - apiGroups: + - deviceplugin.intel.com + apiVersions: + - v1 + operations: + - CREATE + - UPDATE + resources: + - qatdeviceplugins + sideEffects: None + targetPort: 9443 + type: ValidatingAdmissionWebhook + webhookPath: /validate-deviceplugin-intel-com-v1-qatdeviceplugin + - admissionReviewVersions: + - v1 + containerPort: 443 + deploymentName: inteldeviceplugins-controller-manager + failurePolicy: Fail + generateName: vsgxdeviceplugin.kb.io + rules: + - apiGroups: + - deviceplugin.intel.com + apiVersions: + - v1 + operations: + - CREATE + - UPDATE + resources: + - sgxdeviceplugins + sideEffects: None + targetPort: 9443 + type: ValidatingAdmissionWebhook + webhookPath: /validate-deviceplugin-intel-com-v1-sgxdeviceplugin diff --git a/operators/intel-device-plugins-operator/0.31.0/metadata/annotations.yaml b/operators/intel-device-plugins-operator/0.31.0/metadata/annotations.yaml new file mode 100644 index 00000000000..7dbbf3e929d --- /dev/null +++ b/operators/intel-device-plugins-operator/0.31.0/metadata/annotations.yaml @@ -0,0 +1,15 @@ +annotations: + # Core bundle annotations. + operators.operatorframework.io.bundle.mediatype.v1: registry+v1 + operators.operatorframework.io.bundle.manifests.v1: manifests/ + operators.operatorframework.io.bundle.metadata.v1: metadata/ + operators.operatorframework.io.bundle.package.v1: intel-device-plugins-operator + operators.operatorframework.io.bundle.channels.v1: stable + operators.operatorframework.io.bundle.channel.default.v1: stable + operators.operatorframework.io.metrics.builder: operator-sdk-v1.37.0 + operators.operatorframework.io.metrics.mediatype.v1: metrics+v1 + operators.operatorframework.io.metrics.project_layout: go.kubebuilder.io/v2 + + # Annotations for testing. + operators.operatorframework.io.test.mediatype.v1: scorecard+v1 + operators.operatorframework.io.test.config.v1: tests/scorecard/ diff --git a/operators/intel-device-plugins-operator/0.31.0/tests/scorecard/config.yaml b/operators/intel-device-plugins-operator/0.31.0/tests/scorecard/config.yaml new file mode 100644 index 00000000000..21f1d101ef8 --- /dev/null +++ b/operators/intel-device-plugins-operator/0.31.0/tests/scorecard/config.yaml @@ -0,0 +1,70 @@ +apiVersion: scorecard.operatorframework.io/v1alpha3 +kind: Configuration +metadata: + name: config +stages: +- parallel: true + tests: + - entrypoint: + - scorecard-test + - basic-check-spec + image: quay.io/operator-framework/scorecard-test:master + labels: + suite: basic + test: basic-check-spec-test + storage: + spec: + mountPath: {} + - entrypoint: + - scorecard-test + - olm-bundle-validation + image: quay.io/operator-framework/scorecard-test:master + labels: + suite: olm + test: olm-bundle-validation-test + storage: + spec: + mountPath: {} + - entrypoint: + - scorecard-test + - olm-crds-have-validation + image: quay.io/operator-framework/scorecard-test:master + labels: + suite: olm + test: olm-crds-have-validation-test + storage: + spec: + mountPath: {} + - entrypoint: + - scorecard-test + - olm-crds-have-resources + image: quay.io/operator-framework/scorecard-test:master + labels: + suite: olm + test: olm-crds-have-resources-test + storage: + spec: + mountPath: {} + - entrypoint: + - scorecard-test + - olm-spec-descriptors + image: quay.io/operator-framework/scorecard-test:master + labels: + suite: olm + test: olm-spec-descriptors-test + storage: + spec: + mountPath: {} + - entrypoint: + - scorecard-test + - olm-status-descriptors + image: quay.io/operator-framework/scorecard-test:master + labels: + suite: olm + test: olm-status-descriptors-test + storage: + spec: + mountPath: {} +storage: + spec: + mountPath: {}