diff --git a/config/v1alpha1/register.go b/config/v1alpha1/register.go index 4b30ea380b1..f71c9b79062 100644 --- a/config/v1alpha1/register.go +++ b/config/v1alpha1/register.go @@ -40,6 +40,8 @@ func addKnownTypes(scheme *runtime.Scheme) error { &ImagePolicyList{}, &ClusterImagePolicy{}, &ClusterImagePolicyList{}, + &IngressControllerConfig{}, + &IngressControllerConfigList{}, ) metav1.AddToGroupVersion(scheme, GroupVersion) return nil diff --git a/config/v1alpha1/tests/ingresscontrollerconfigs.config.openshift.io/AAA_ungated.yaml b/config/v1alpha1/tests/ingresscontrollerconfigs.config.openshift.io/AAA_ungated.yaml new file mode 100644 index 00000000000..4e306280b89 --- /dev/null +++ b/config/v1alpha1/tests/ingresscontrollerconfigs.config.openshift.io/AAA_ungated.yaml @@ -0,0 +1,23 @@ +apiVersion: apiextensions.k8s.io/v1 # Hack because controller-gen complains if we don't have this +name: "IngressControllerConfig" +crdName: ingresscontrollerconfigs.config.openshift.io +tests: + onCreate: + - name: Should be able to create a minimal IngressControllerConfig + initial: | + apiVersion: config.openshift.io/v1alpha1 + kind: IngressControllerConfig + metadata: + name: cluster + spec: + defaultControllerConfig: + logLevel: Info + expected: | + apiVersion: config.openshift.io/v1alpha1 + kind: IngressControllerConfig + metadata: + name: cluster + spec: + defaultControllerConfig: + logLevel: Info + diff --git a/config/v1alpha1/tests/ingresscontrollerconfigs.config.openshift.io/IngressControllerConfig.yaml b/config/v1alpha1/tests/ingresscontrollerconfigs.config.openshift.io/IngressControllerConfig.yaml new file mode 100644 index 00000000000..bdc8a1fd216 --- /dev/null +++ b/config/v1alpha1/tests/ingresscontrollerconfigs.config.openshift.io/IngressControllerConfig.yaml @@ -0,0 +1,246 @@ +apiVersion: apiextensions.k8s.io/v1 # Hack because controller-gen complains if we don't have this +name: "IngressControllerConfig" +crdName: ingresscontrollerconfigs.config.openshift.io +featureGate: IngressControllerConfig +tests: + onCreate: + - name: Should be able to create a minimal IngressControllerConfig + initial: | + apiVersion: config.openshift.io/v1alpha1 + kind: IngressControllerConfig + metadata: + name: cluster + spec: + defaultControllerConfig: + logLevel: Info + expected: | + apiVersion: config.openshift.io/v1alpha1 + kind: IngressControllerConfig + metadata: + name: cluster + spec: + defaultControllerConfig: + logLevel: Info + - name: Should be able to create a comprehensive IngressControllerConfig + initial: | + apiVersion: config.openshift.io/v1alpha1 + kind: IngressControllerConfig + metadata: + name: cluster + spec: + defaultControllerConfig: + logLevel: Info + nodeSelector: + kubernetes.io/os: linux + node-role.kubernetes.io/worker: "" + resources: + - name: cpu + request: 100m + - name: memory + request: 256Mi + limit: 512Mi + replicas: 2 + tolerations: + - effect: NoSchedule + key: node-role.kubernetes.io/worker + operator: Exists + performanceTuning: + connectionLimits: + maxConnections: 20000 + maxConnectionsPerBackend: 100 + maxRequestsPerConnection: 10 + timeouts: + clientTimeout: + duration: "30s" + serverTimeout: + duration: "30s" + connectTimeout: + duration: "5s" + bufferSizes: + requestHeaderBufferSize: "8Ki" + responseBufferSize: "32Ki" + expected: | + apiVersion: config.openshift.io/v1alpha1 + kind: IngressControllerConfig + metadata: + name: cluster + spec: + defaultControllerConfig: + logLevel: Info + nodeSelector: + kubernetes.io/os: linux + node-role.kubernetes.io/worker: "" + resources: + - name: cpu + request: 100m + - name: memory + request: 256Mi + limit: 512Mi + replicas: 2 + tolerations: + - effect: NoSchedule + key: node-role.kubernetes.io/worker + operator: Exists + performanceTuning: + connectionLimits: + maxConnections: 20000 + maxConnectionsPerBackend: 100 + maxRequestsPerConnection: 10 + timeouts: + clientTimeout: + duration: "30s" + serverTimeout: + duration: "30s" + connectTimeout: + duration: "5s" + bufferSizes: + requestHeaderBufferSize: "8Ki" + responseBufferSize: "32Ki" + - name: Should reject IngressControllerConfig with replicas below minimum + initial: | + apiVersion: config.openshift.io/v1alpha1 + kind: IngressControllerConfig + metadata: + name: cluster + spec: + defaultControllerConfig: + replicas: 0 + expectedError: 'spec.defaultControllerConfig.replicas: Invalid value: 0: spec.defaultControllerConfig.replicas in body should be greater than or equal to 1' + - name: Should reject IngressControllerConfig with replicas above maximum + initial: | + apiVersion: config.openshift.io/v1alpha1 + kind: IngressControllerConfig + metadata: + name: cluster + spec: + defaultControllerConfig: + replicas: 21 + expectedError: 'spec.defaultControllerConfig.replicas: Invalid value: 21: spec.defaultControllerConfig.replicas in body should be less than or equal to 20' + - name: Should reject ContainerResource with duplicate names + initial: | + apiVersion: config.openshift.io/v1alpha1 + kind: IngressControllerConfig + metadata: + name: cluster + spec: + defaultControllerConfig: + resources: + - name: "cpu" + request: "100m" + - name: "cpu" + request: "200m" + expectedError: 'spec.defaultControllerConfig.resources[1]: Duplicate value: map[string]interface {}{"name":"cpu"}' + - name: Should reject more than 50 tolerations + initial: | + apiVersion: config.openshift.io/v1alpha1 + kind: IngressControllerConfig + metadata: + name: cluster + spec: + defaultControllerConfig: + tolerations: + - key: key-0 + effect: NoSchedule + - key: key-1 + effect: NoSchedule + - key: key-2 + effect: NoSchedule + - key: key-3 + effect: NoSchedule + - key: key-4 + effect: NoSchedule + - key: key-5 + effect: NoSchedule + - key: key-6 + effect: NoSchedule + - key: key-7 + effect: NoSchedule + - key: key-8 + effect: NoSchedule + - key: key-9 + effect: NoSchedule + - key: key-10 + effect: NoSchedule + - key: key-11 + effect: NoSchedule + - key: key-12 + effect: NoSchedule + - key: key-13 + effect: NoSchedule + - key: key-14 + effect: NoSchedule + - key: key-15 + effect: NoSchedule + - key: key-16 + effect: NoSchedule + - key: key-17 + effect: NoSchedule + - key: key-18 + effect: NoSchedule + - key: key-19 + effect: NoSchedule + - key: key-20 + effect: NoSchedule + - key: key-21 + effect: NoSchedule + - key: key-22 + effect: NoSchedule + - key: key-23 + effect: NoSchedule + - key: key-24 + effect: NoSchedule + - key: key-25 + effect: NoSchedule + - key: key-26 + effect: NoSchedule + - key: key-27 + effect: NoSchedule + - key: key-28 + effect: NoSchedule + - key: key-29 + effect: NoSchedule + - key: key-30 + effect: NoSchedule + - key: key-31 + effect: NoSchedule + - key: key-32 + effect: NoSchedule + - key: key-33 + effect: NoSchedule + - key: key-34 + effect: NoSchedule + - key: key-35 + effect: NoSchedule + - key: key-36 + effect: NoSchedule + - key: key-37 + effect: NoSchedule + - key: key-38 + effect: NoSchedule + - key: key-39 + effect: NoSchedule + - key: key-40 + effect: NoSchedule + - key: key-41 + effect: NoSchedule + - key: key-42 + effect: NoSchedule + - key: key-43 + effect: NoSchedule + - key: key-44 + effect: NoSchedule + - key: key-45 + effect: NoSchedule + - key: key-46 + effect: NoSchedule + - key: key-47 + effect: NoSchedule + - key: key-48 + effect: NoSchedule + - key: key-49 + effect: NoSchedule + - key: key-50 + effect: NoSchedule + - key: key-51 + effect: NoSchedule + expectedError: 'spec.defaultControllerConfig.tolerations: Too many: 51: must have at most 50 items' diff --git a/config/v1alpha1/types_ingress_controller.go b/config/v1alpha1/types_ingress_controller.go new file mode 100644 index 00000000000..db475ef49ee --- /dev/null +++ b/config/v1alpha1/types_ingress_controller.go @@ -0,0 +1,314 @@ +/* +Copyright 2024. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1alpha1 + +import ( + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// +genclient +// +genclient:nonNamespaced +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// IngressControllerConfig is the Custom Resource object which holds the current configuration of Ingress Controllers. +// This provides a cluster-level configuration API for managing ingress controller operational settings. +// +// Compatibility level 4: No compatibility is provided, the API can change at any point for any reason. These capabilities should not be used by applications needing long term support. +// +openshift:compatibility-gen:level=4 +// +openshift:api-approved.openshift.io=https://github.com/openshift/api/pull/XXXX +// +openshift:file-pattern=cvoRunLevel=0000_10,operatorName=config-operator,operatorOrdering=01 +// +openshift:enable:FeatureGate=IngressControllerConfig +// +kubebuilder:object:root=true +// +kubebuilder:resource:path=ingresscontrollerconfigs,scope=Cluster +// +kubebuilder:subresource:status +// +kubebuilder:metadata:annotations="description=Ingress Controller configuration API" +type IngressControllerConfig struct { + metav1.TypeMeta `json:",inline"` + + // metadata is the standard object metadata. + // +optional + metav1.ObjectMeta `json:"metadata,omitempty"` + + // spec holds user configuration for the Ingress Controllers + // +required + Spec IngressControllerConfigSpec `json:"spec,omitzero"` + // status holds observed values from the cluster. They may not be overridden. + // +optional + Status *IngressControllerConfigStatus `json:"status,omitempty"` +} + +// IngressControllerConfigStatus defines the observed state of IngressControllerConfig +type IngressControllerConfigStatus struct { + // conditions represent the latest available observations of the IngressControllerConfig's current state. + // +optional + // +listType=map + // +listMapKey=type + // +kubebuilder:validation:MaxItems=32 + Conditions []metav1.Condition `json:"conditions,omitempty"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// Compatibility level 4: No compatibility is provided, the API can change at any point for any reason. These capabilities should not be used by applications needing long term support. +// +openshift:compatibility-gen:level=4 +type IngressControllerConfigList struct { + metav1.TypeMeta `json:",inline"` + + // metadata is the standard list metadata. + // +optional + metav1.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + + // items is a list of IngressControllerConfig + // +optional + Items []IngressControllerConfig `json:"items"` +} + +// IngressControllerConfigSpec defines the desired state of Ingress Controller operational configuration +// +kubebuilder:validation:MinProperties=1 +type IngressControllerConfigSpec struct { + // defaultControllerConfig allows users to configure how the default ingress controller instance + // should be deployed and managed. + // defaultControllerConfig is optional. + // When omitted, this means no opinion and the platform is left to choose a reasonable default, that is subject to change over time. + // +optional + DefaultControllerConfig DefaultIngressControllerConfig `json:"defaultControllerConfig,omitempty,omitzero"` + + // performanceTuning provides configuration options for performance optimization of ingress controllers. + // performanceTuning is optional. + // When omitted, this means no opinion and the platform is left to choose a reasonable default, that is subject to change over time. + // +optional + PerformanceTuning IngressControllerPerformanceTuning `json:"performanceTuning,omitempty,omitzero"` +} + +// DefaultIngressControllerConfig represents the configuration for the default ingress controller deployment. +// defaultIngressControllerConfig provides configuration options for the default ingress controller instance +// that runs in the `openshift-ingress` namespace. Use this configuration to control +// how the default ingress controller is deployed, how it logs, and how its pods are scheduled. +// +kubebuilder:validation:MinProperties=1 +type DefaultIngressControllerConfig struct { + // logLevel defines the verbosity of logs emitted by the ingress controller. + // This field allows users to control the amount and severity of logs generated, which can be useful + // for debugging issues or reducing noise in production environments. + // Allowed values are Error, Warn, Info, and Debug. + // When set to Error, only errors will be logged. + // When set to Warn, both warnings and errors will be logged. + // When set to Info, general information, warnings, and errors will all be logged. + // When set to Debug, detailed debugging information will be logged. + // When omitted, this means no opinion and the platform is left to choose a reasonable default, that is subject to change over time. + // The current default value is `Info`. + // +optional + LogLevel IngressControllerLogLevel `json:"logLevel,omitempty"` + + // nodeSelector defines the nodes on which the ingress controller Pods are scheduled + // nodeSelector is optional. + // + // When omitted, this means the user has no opinion and the platform is left + // to choose reasonable defaults. These defaults are subject to change over time. + // The current default value is `kubernetes.io/os: linux`. + // +optional + // +kubebuilder:validation:MinProperties=1 + // +kubebuilder:validation:MaxProperties=10 + NodeSelector map[string]string `json:"nodeSelector,omitempty"` + + // resources defines the compute resource requests and limits for the ingress controller container. + // This includes CPU, memory and HugePages constraints to help control scheduling and resource usage. + // When not specified, defaults are used by the platform. Requests cannot exceed limits. + // This field is optional. + // More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ + // This is a simplified API that maps to Kubernetes ResourceRequirements. + // The current default values are: + // resources: + // - name: cpu + // request: 100m + // limit: null + // - name: memory + // request: 256Mi + // limit: null + // Maximum length for this list is 10. + // Minimum length for this list is 1. + // +optional + // +listType=map + // +listMapKey=name + // +kubebuilder:validation:MaxItems=10 + // +kubebuilder:validation:MinItems=1 + Resources []IngressControllerContainerResource `json:"resources,omitempty"` + + // replicas defines the desired number of ingress controller replicas. + // This field allows users to control the availability and load distribution of the ingress controller. + // When not specified, defaults are used by the platform based on the cluster topology. + // The current default behavior is: + // - SingleReplica topology: 1 replica + // - HighlyAvailable topology: 2 replicas + // +optional + // +kubebuilder:validation:Minimum=1 + // +kubebuilder:validation:Maximum=20 + Replicas int32 `json:"replicas,omitempty"` + + // tolerations defines the tolerations for ingress controller pods. + // This allows the ingress controller to be scheduled on nodes with matching taints. + // When not specified, no tolerations are applied. + // +optional + // +listType=atomic + // +kubebuilder:validation:MaxItems=50 + Tolerations []v1.Toleration `json:"tolerations,omitempty"` + + // affinity defines the affinity rules for ingress controller pods. + // This allows users to control pod placement for high availability or performance optimization. + // When not specified, no affinity rules are applied. + // +optional + Affinity *v1.Affinity `json:"affinity,omitempty"` +} + +// IngressControllerPerformanceTuning provides configuration options for performance optimization +// of ingress controllers. Use this configuration to control connection limits, timeouts, +// and other performance-related settings. +// +kubebuilder:validation:MinProperties=1 +type IngressControllerPerformanceTuning struct { + // connectionLimits defines limits on connections handled by the ingress controller. + // connectionLimits is optional. + // When omitted, this means no opinion and the platform is left to choose reasonable defaults. + // +optional + ConnectionLimits *IngressControllerConnectionLimits `json:"connectionLimits,omitempty"` + + // timeouts defines timeout settings for the ingress controller. + // timeouts is optional. + // When omitted, this means no opinion and the platform is left to choose reasonable defaults. + // +optional + Timeouts *IngressControllerTimeouts `json:"timeouts,omitempty"` + + // bufferSizes defines buffer size settings for the ingress controller. + // bufferSizes is optional. + // When omitted, this means no opinion and the platform is left to choose reasonable defaults. + // +optional + BufferSizes *IngressControllerBufferSizes `json:"bufferSizes,omitempty"` +} + +// IngressControllerConnectionLimits defines connection-related limits for ingress controllers. +type IngressControllerConnectionLimits struct { + // maxConnections defines the maximum number of concurrent connections. + // This helps prevent resource exhaustion under high load. + // When not specified, the platform default is used. + // +optional + // +kubebuilder:validation:Minimum=1 + // +kubebuilder:validation:Maximum=1000000 + MaxConnections int32 `json:"maxConnections,omitempty"` + + // maxConnectionsPerBackend defines the maximum number of connections per backend server. + // This helps distribute load evenly across backend servers. + // When not specified, the platform default is used. + // +optional + // +kubebuilder:validation:Minimum=1 + // +kubebuilder:validation:Maximum=10000 + MaxConnectionsPerBackend int32 `json:"maxConnectionsPerBackend,omitempty"` + + // maxRequestsPerConnection defines the maximum number of requests per connection. + // This controls connection reuse behavior. + // When not specified, the platform default is used. + // +optional + // +kubebuilder:validation:Minimum=1 + // +kubebuilder:validation:Maximum=1000 + MaxRequestsPerConnection int32 `json:"maxRequestsPerConnection,omitempty"` +} + +// IngressControllerTimeouts defines timeout settings for ingress controllers. +type IngressControllerTimeouts struct { + // clientTimeout defines the timeout for client connections. + // This is the maximum time to wait for a client to send a request. + // When not specified, the platform default is used. + // +optional + ClientTimeout *metav1.Duration `json:"clientTimeout,omitempty"` + + // serverTimeout defines the timeout for backend server connections. + // This is the maximum time to wait for a response from a backend server. + // When not specified, the platform default is used. + // +optional + ServerTimeout *metav1.Duration `json:"serverTimeout,omitempty"` + + // connectTimeout defines the timeout for establishing connections to backend servers. + // This is the maximum time to wait when establishing a connection to a backend. + // When not specified, the platform default is used. + // +optional + ConnectTimeout *metav1.Duration `json:"connectTimeout,omitempty"` +} + +// IngressControllerBufferSizes defines buffer size settings for ingress controllers. +type IngressControllerBufferSizes struct { + // requestHeaderBufferSize defines the size of the buffer for request headers. + // This affects the maximum size of request headers that can be processed. + // When not specified, the platform default is used. + // +optional + RequestHeaderBufferSize *resource.Quantity `json:"requestHeaderBufferSize,omitempty"` + + // responseBufferSize defines the size of the buffer for responses. + // This affects buffering behavior for responses from backend servers. + // When not specified, the platform default is used. + // +optional + ResponseBufferSize *resource.Quantity `json:"responseBufferSize,omitempty"` +} + +// IngressControllerContainerResource defines a single resource requirement for an ingress controller container. +// +kubebuilder:validation:XValidation:rule="has(self.request) || has(self.limit)",message="at least one of request or limit must be set" +// +kubebuilder:validation:XValidation:rule="!(has(self.request) && has(self.limit)) || quantity(self.limit).compareTo(quantity(self.request)) >= 0",message="limit must be greater than or equal to request" +type IngressControllerContainerResource struct { + // name of the resource (e.g. "cpu", "memory", "hugepages-2Mi"). + // This field is required. + // name must consist only of alphanumeric characters, `-`, `_` and `.` and must start and end with an alphanumeric character. + // +required + // +kubebuilder:validation:MinLength=1 + // +kubebuilder:validation:MaxLength=253 + // +kubebuilder:validation:XValidation:rule="!format.qualifiedName().validate(self).hasValue()",message="name must consist only of alphanumeric characters, `-`, `_` and `.` and must start and end with an alphanumeric character" + Name string `json:"name,omitempty"` + + // request is the minimum amount of the resource required (e.g. "2Mi", "1Gi"). + // This field is optional. + // When limit is specified, request cannot be greater than limit. + // +optional + // +kubebuilder:validation:XIntOrString + // +kubebuilder:validation:MaxLength=20 + // +kubebuilder:validation:MinLength=1 + // +kubebuilder:validation:XValidation:rule="isQuantity(self) && quantity(self).isGreaterThan(quantity('0'))",message="request must be a positive, non-zero quantity" + Request resource.Quantity `json:"request,omitempty"` + + // limit is the maximum amount of the resource allowed (e.g. "2Mi", "1Gi"). + // This field is optional. + // When request is specified, limit cannot be less than request. + // The value must be greater than 0 when specified. + // +optional + // +kubebuilder:validation:XIntOrString + // +kubebuilder:validation:MaxLength=20 + // +kubebuilder:validation:MinLength=1 + // +kubebuilder:validation:XValidation:rule="isQuantity(self) && quantity(self).isGreaterThan(quantity('0'))",message="limit must be a positive, non-zero quantity" + Limit resource.Quantity `json:"limit,omitempty"` +} + +// IngressControllerLogLevel defines the log level for ingress controllers +// +kubebuilder:validation:Enum="Error";"Warn";"Info";"Debug" +type IngressControllerLogLevel string + +const ( + // IngressControllerLogLevelError only errors will be logged. + IngressControllerLogLevelError IngressControllerLogLevel = "Error" + // IngressControllerLogLevelWarn, both warnings and errors will be logged. + IngressControllerLogLevelWarn IngressControllerLogLevel = "Warn" + // IngressControllerLogLevelInfo, general information, warnings, and errors will all be logged. + IngressControllerLogLevelInfo IngressControllerLogLevel = "Info" + // IngressControllerLogLevelDebug, detailed debugging information will be logged. + IngressControllerLogLevelDebug IngressControllerLogLevel = "Debug" +) + diff --git a/config/v1alpha1/zz_generated.crd-manifests/0000_10_config-operator_01_ingresscontrollerconfigs-CustomNoUpgrade.crd.yaml b/config/v1alpha1/zz_generated.crd-manifests/0000_10_config-operator_01_ingresscontrollerconfigs-CustomNoUpgrade.crd.yaml new file mode 100644 index 00000000000..ffc84753fd7 --- /dev/null +++ b/config/v1alpha1/zz_generated.crd-manifests/0000_10_config-operator_01_ingresscontrollerconfigs-CustomNoUpgrade.crd.yaml @@ -0,0 +1,1318 @@ +apiVersion: apiextensions.k8s.io/v1 +kind: CustomResourceDefinition +metadata: + annotations: + api-approved.openshift.io: https://github.com/openshift/api/pull/XXXX + api.openshift.io/merged-by-featuregates: "true" + description: Ingress Controller configuration API + include.release.openshift.io/ibm-cloud-managed: "true" + include.release.openshift.io/self-managed-high-availability: "true" + release.openshift.io/feature-set: CustomNoUpgrade + name: ingresscontrollerconfigs.config.openshift.io +spec: + group: config.openshift.io + names: + kind: IngressControllerConfig + listKind: IngressControllerConfigList + plural: ingresscontrollerconfigs + singular: ingresscontrollerconfig + scope: Cluster + versions: + - name: v1alpha1 + schema: + openAPIV3Schema: + description: |- + IngressControllerConfig is the Custom Resource object which holds the current configuration of Ingress Controllers. + This provides a cluster-level configuration API for managing ingress controller operational settings. + + Compatibility level 4: No compatibility is provided, the API can change at any point for any reason. These capabilities should not be used by applications needing long term support. + 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: spec holds user configuration for the Ingress Controllers + minProperties: 1 + properties: + defaultControllerConfig: + description: |- + defaultControllerConfig allows users to configure how the default ingress controller instance + should be deployed and managed. + defaultControllerConfig is optional. + When omitted, this means no opinion and the platform is left to choose a reasonable default, that is subject to change over time. + minProperties: 1 + properties: + affinity: + description: |- + affinity defines the affinity rules for ingress controller pods. + This allows users to control pod placement for high availability or performance optimization. + When not specified, no affinity rules are applied. + properties: + nodeAffinity: + description: Describes node affinity scheduling rules for + the pod. + properties: + preferredDuringSchedulingIgnoredDuringExecution: + description: |- + The scheduler will prefer to schedule pods to nodes that satisfy + the affinity expressions specified by this field, but it may choose + a node that violates one or more of the expressions. The node that is + most preferred is the one with the greatest sum of weights, i.e. + for each node that meets all of the scheduling requirements (resource + request, requiredDuringScheduling affinity expressions, etc.), + compute a sum by iterating through the elements of this field and adding + "weight" to the sum if the node matches the corresponding matchExpressions; the + node(s) with the highest sum are the most preferred. + items: + description: |- + An empty preferred scheduling term matches all objects with implicit weight 0 + (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op). + properties: + preference: + description: A node selector term, associated with + the corresponding weight. + properties: + matchExpressions: + description: A list of node selector requirements + by node's labels. + items: + description: |- + A node selector requirement is a selector that contains values, a key, and an operator + that relates the key and values. + properties: + key: + description: The label key that the selector + applies to. + type: string + operator: + description: |- + Represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. + type: string + values: + description: |- + An array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. If the operator is Gt or Lt, the values + array must have a single element, which will be interpreted as an integer. + This array is replaced during a strategic merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + matchFields: + description: A list of node selector requirements + by node's fields. + items: + description: |- + A node selector requirement is a selector that contains values, a key, and an operator + that relates the key and values. + properties: + key: + description: The label key that the selector + applies to. + type: string + operator: + description: |- + Represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. + type: string + values: + description: |- + An array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. If the operator is Gt or Lt, the values + array must have a single element, which will be interpreted as an integer. + This array is replaced during a strategic merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + type: object + x-kubernetes-map-type: atomic + weight: + description: Weight associated with matching the + corresponding nodeSelectorTerm, in the range 1-100. + format: int32 + type: integer + required: + - preference + - weight + type: object + type: array + x-kubernetes-list-type: atomic + requiredDuringSchedulingIgnoredDuringExecution: + description: |- + If the affinity requirements specified by this field are not met at + scheduling time, the pod will not be scheduled onto the node. + If the affinity requirements specified by this field cease to be met + at some point during pod execution (e.g. due to an update), the system + may or may not try to eventually evict the pod from its node. + properties: + nodeSelectorTerms: + description: Required. A list of node selector terms. + The terms are ORed. + items: + description: |- + A null or empty node selector term matches no objects. The requirements of + them are ANDed. + The TopologySelectorTerm type implements a subset of the NodeSelectorTerm. + properties: + matchExpressions: + description: A list of node selector requirements + by node's labels. + items: + description: |- + A node selector requirement is a selector that contains values, a key, and an operator + that relates the key and values. + properties: + key: + description: The label key that the selector + applies to. + type: string + operator: + description: |- + Represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. + type: string + values: + description: |- + An array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. If the operator is Gt or Lt, the values + array must have a single element, which will be interpreted as an integer. + This array is replaced during a strategic merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + matchFields: + description: A list of node selector requirements + by node's fields. + items: + description: |- + A node selector requirement is a selector that contains values, a key, and an operator + that relates the key and values. + properties: + key: + description: The label key that the selector + applies to. + type: string + operator: + description: |- + Represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. + type: string + values: + description: |- + An array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. If the operator is Gt or Lt, the values + array must have a single element, which will be interpreted as an integer. + This array is replaced during a strategic merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + type: object + x-kubernetes-map-type: atomic + type: array + x-kubernetes-list-type: atomic + required: + - nodeSelectorTerms + type: object + x-kubernetes-map-type: atomic + type: object + podAffinity: + description: Describes pod affinity scheduling rules (e.g. + co-locate this pod in the same node, zone, etc. as some + other pod(s)). + properties: + preferredDuringSchedulingIgnoredDuringExecution: + description: |- + The scheduler will prefer to schedule pods to nodes that satisfy + the affinity expressions specified by this field, but it may choose + a node that violates one or more of the expressions. The node that is + most preferred is the one with the greatest sum of weights, i.e. + for each node that meets all of the scheduling requirements (resource + request, requiredDuringScheduling affinity expressions, etc.), + compute a sum by iterating through the elements of this field and adding + "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the + node(s) with the highest sum are the most preferred. + items: + description: The weights of all of the matched WeightedPodAffinityTerm + fields are added per-node to find the most preferred + node(s) + properties: + podAffinityTerm: + description: Required. A pod affinity term, associated + with the corresponding weight. + properties: + labelSelector: + description: |- + A label query over a set of resources, in this case pods. + If it's null, this PodAffinityTerm matches with no Pods. + properties: + matchExpressions: + description: matchExpressions is a list + of label selector requirements. The requirements + are ANDed. + items: + description: |- + A label selector requirement is a selector that contains values, a key, and an operator that + relates the key and values. + properties: + key: + description: key is the label key + that the selector applies to. + type: string + operator: + description: |- + operator represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: |- + values is an array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. This array is replaced during a strategic + merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + matchLabels: + additionalProperties: + type: string + description: |- + matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels + map is equivalent to an element of matchExpressions, whose key field is "key", the + operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + type: object + x-kubernetes-map-type: atomic + matchLabelKeys: + description: |- + MatchLabelKeys is a set of pod label keys to select which pods will + be taken into consideration. The keys are used to lookup values from the + incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` + to select the group of existing pods which pods will be taken into consideration + for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming + pod labels will be ignored. The default value is empty. + The same key is forbidden to exist in both matchLabelKeys and labelSelector. + Also, matchLabelKeys cannot be set when labelSelector isn't set. + items: + type: string + type: array + x-kubernetes-list-type: atomic + mismatchLabelKeys: + description: |- + MismatchLabelKeys is a set of pod label keys to select which pods will + be taken into consideration. The keys are used to lookup values from the + incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` + to select the group of existing pods which pods will be taken into consideration + for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming + pod labels will be ignored. The default value is empty. + The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. + Also, mismatchLabelKeys cannot be set when labelSelector isn't set. + items: + type: string + type: array + x-kubernetes-list-type: atomic + namespaceSelector: + description: |- + A label query over the set of namespaces that the term applies to. + The term is applied to the union of the namespaces selected by this field + and the ones listed in the namespaces field. + null selector and null or empty namespaces list means "this pod's namespace". + An empty selector ({}) matches all namespaces. + properties: + matchExpressions: + description: matchExpressions is a list + of label selector requirements. The requirements + are ANDed. + items: + description: |- + A label selector requirement is a selector that contains values, a key, and an operator that + relates the key and values. + properties: + key: + description: key is the label key + that the selector applies to. + type: string + operator: + description: |- + operator represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: |- + values is an array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. This array is replaced during a strategic + merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + matchLabels: + additionalProperties: + type: string + description: |- + matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels + map is equivalent to an element of matchExpressions, whose key field is "key", the + operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + type: object + x-kubernetes-map-type: atomic + namespaces: + description: |- + namespaces specifies a static list of namespace names that the term applies to. + The term is applied to the union of the namespaces listed in this field + and the ones selected by namespaceSelector. + null or empty namespaces list and null namespaceSelector means "this pod's namespace". + items: + type: string + type: array + x-kubernetes-list-type: atomic + topologyKey: + description: |- + This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching + the labelSelector in the specified namespaces, where co-located is defined as running on a node + whose value of the label with key topologyKey matches that of any node on which any of the + selected pods is running. + Empty topologyKey is not allowed. + type: string + required: + - topologyKey + type: object + weight: + description: |- + weight associated with matching the corresponding podAffinityTerm, + in the range 1-100. + format: int32 + type: integer + required: + - podAffinityTerm + - weight + type: object + type: array + x-kubernetes-list-type: atomic + requiredDuringSchedulingIgnoredDuringExecution: + description: |- + If the affinity requirements specified by this field are not met at + scheduling time, the pod will not be scheduled onto the node. + If the affinity requirements specified by this field cease to be met + at some point during pod execution (e.g. due to a pod label update), the + system may or may not try to eventually evict the pod from its node. + When there are multiple elements, the lists of nodes corresponding to each + podAffinityTerm are intersected, i.e. all terms must be satisfied. + items: + description: |- + Defines a set of pods (namely those matching the labelSelector + relative to the given namespace(s)) that this pod should be + co-located (affinity) or not co-located (anti-affinity) with, + where co-located is defined as running on a node whose value of + the label with key matches that of any node on which + a pod of the set of pods is running + properties: + labelSelector: + description: |- + A label query over a set of resources, in this case pods. + If it's null, this PodAffinityTerm matches with no Pods. + properties: + matchExpressions: + description: matchExpressions is a list of label + selector requirements. The requirements are + ANDed. + items: + description: |- + A label selector requirement is a selector that contains values, a key, and an operator that + relates the key and values. + properties: + key: + description: key is the label key that + the selector applies to. + type: string + operator: + description: |- + operator represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: |- + values is an array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. This array is replaced during a strategic + merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + matchLabels: + additionalProperties: + type: string + description: |- + matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels + map is equivalent to an element of matchExpressions, whose key field is "key", the + operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + type: object + x-kubernetes-map-type: atomic + matchLabelKeys: + description: |- + MatchLabelKeys is a set of pod label keys to select which pods will + be taken into consideration. The keys are used to lookup values from the + incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` + to select the group of existing pods which pods will be taken into consideration + for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming + pod labels will be ignored. The default value is empty. + The same key is forbidden to exist in both matchLabelKeys and labelSelector. + Also, matchLabelKeys cannot be set when labelSelector isn't set. + items: + type: string + type: array + x-kubernetes-list-type: atomic + mismatchLabelKeys: + description: |- + MismatchLabelKeys is a set of pod label keys to select which pods will + be taken into consideration. The keys are used to lookup values from the + incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` + to select the group of existing pods which pods will be taken into consideration + for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming + pod labels will be ignored. The default value is empty. + The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. + Also, mismatchLabelKeys cannot be set when labelSelector isn't set. + items: + type: string + type: array + x-kubernetes-list-type: atomic + namespaceSelector: + description: |- + A label query over the set of namespaces that the term applies to. + The term is applied to the union of the namespaces selected by this field + and the ones listed in the namespaces field. + null selector and null or empty namespaces list means "this pod's namespace". + An empty selector ({}) matches all namespaces. + properties: + matchExpressions: + description: matchExpressions is a list of label + selector requirements. The requirements are + ANDed. + items: + description: |- + A label selector requirement is a selector that contains values, a key, and an operator that + relates the key and values. + properties: + key: + description: key is the label key that + the selector applies to. + type: string + operator: + description: |- + operator represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: |- + values is an array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. This array is replaced during a strategic + merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + matchLabels: + additionalProperties: + type: string + description: |- + matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels + map is equivalent to an element of matchExpressions, whose key field is "key", the + operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + type: object + x-kubernetes-map-type: atomic + namespaces: + description: |- + namespaces specifies a static list of namespace names that the term applies to. + The term is applied to the union of the namespaces listed in this field + and the ones selected by namespaceSelector. + null or empty namespaces list and null namespaceSelector means "this pod's namespace". + items: + type: string + type: array + x-kubernetes-list-type: atomic + topologyKey: + description: |- + This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching + the labelSelector in the specified namespaces, where co-located is defined as running on a node + whose value of the label with key topologyKey matches that of any node on which any of the + selected pods is running. + Empty topologyKey is not allowed. + type: string + required: + - topologyKey + type: object + type: array + x-kubernetes-list-type: atomic + type: object + podAntiAffinity: + description: Describes pod anti-affinity scheduling rules + (e.g. avoid putting this pod in the same node, zone, etc. + as some other pod(s)). + properties: + preferredDuringSchedulingIgnoredDuringExecution: + description: |- + The scheduler will prefer to schedule pods to nodes that satisfy + the anti-affinity expressions specified by this field, but it may choose + a node that violates one or more of the expressions. The node that is + most preferred is the one with the greatest sum of weights, i.e. + for each node that meets all of the scheduling requirements (resource + request, requiredDuringScheduling anti-affinity expressions, etc.), + compute a sum by iterating through the elements of this field and adding + "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the + node(s) with the highest sum are the most preferred. + items: + description: The weights of all of the matched WeightedPodAffinityTerm + fields are added per-node to find the most preferred + node(s) + properties: + podAffinityTerm: + description: Required. A pod affinity term, associated + with the corresponding weight. + properties: + labelSelector: + description: |- + A label query over a set of resources, in this case pods. + If it's null, this PodAffinityTerm matches with no Pods. + properties: + matchExpressions: + description: matchExpressions is a list + of label selector requirements. The requirements + are ANDed. + items: + description: |- + A label selector requirement is a selector that contains values, a key, and an operator that + relates the key and values. + properties: + key: + description: key is the label key + that the selector applies to. + type: string + operator: + description: |- + operator represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: |- + values is an array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. This array is replaced during a strategic + merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + matchLabels: + additionalProperties: + type: string + description: |- + matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels + map is equivalent to an element of matchExpressions, whose key field is "key", the + operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + type: object + x-kubernetes-map-type: atomic + matchLabelKeys: + description: |- + MatchLabelKeys is a set of pod label keys to select which pods will + be taken into consideration. The keys are used to lookup values from the + incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` + to select the group of existing pods which pods will be taken into consideration + for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming + pod labels will be ignored. The default value is empty. + The same key is forbidden to exist in both matchLabelKeys and labelSelector. + Also, matchLabelKeys cannot be set when labelSelector isn't set. + items: + type: string + type: array + x-kubernetes-list-type: atomic + mismatchLabelKeys: + description: |- + MismatchLabelKeys is a set of pod label keys to select which pods will + be taken into consideration. The keys are used to lookup values from the + incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` + to select the group of existing pods which pods will be taken into consideration + for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming + pod labels will be ignored. The default value is empty. + The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. + Also, mismatchLabelKeys cannot be set when labelSelector isn't set. + items: + type: string + type: array + x-kubernetes-list-type: atomic + namespaceSelector: + description: |- + A label query over the set of namespaces that the term applies to. + The term is applied to the union of the namespaces selected by this field + and the ones listed in the namespaces field. + null selector and null or empty namespaces list means "this pod's namespace". + An empty selector ({}) matches all namespaces. + properties: + matchExpressions: + description: matchExpressions is a list + of label selector requirements. The requirements + are ANDed. + items: + description: |- + A label selector requirement is a selector that contains values, a key, and an operator that + relates the key and values. + properties: + key: + description: key is the label key + that the selector applies to. + type: string + operator: + description: |- + operator represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: |- + values is an array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. This array is replaced during a strategic + merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + matchLabels: + additionalProperties: + type: string + description: |- + matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels + map is equivalent to an element of matchExpressions, whose key field is "key", the + operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + type: object + x-kubernetes-map-type: atomic + namespaces: + description: |- + namespaces specifies a static list of namespace names that the term applies to. + The term is applied to the union of the namespaces listed in this field + and the ones selected by namespaceSelector. + null or empty namespaces list and null namespaceSelector means "this pod's namespace". + items: + type: string + type: array + x-kubernetes-list-type: atomic + topologyKey: + description: |- + This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching + the labelSelector in the specified namespaces, where co-located is defined as running on a node + whose value of the label with key topologyKey matches that of any node on which any of the + selected pods is running. + Empty topologyKey is not allowed. + type: string + required: + - topologyKey + type: object + weight: + description: |- + weight associated with matching the corresponding podAffinityTerm, + in the range 1-100. + format: int32 + type: integer + required: + - podAffinityTerm + - weight + type: object + type: array + x-kubernetes-list-type: atomic + requiredDuringSchedulingIgnoredDuringExecution: + description: |- + If the anti-affinity requirements specified by this field are not met at + scheduling time, the pod will not be scheduled onto the node. + If the anti-affinity requirements specified by this field cease to be met + at some point during pod execution (e.g. due to a pod label update), the + system may or may not try to eventually evict the pod from its node. + When there are multiple elements, the lists of nodes corresponding to each + podAffinityTerm are intersected, i.e. all terms must be satisfied. + items: + description: |- + Defines a set of pods (namely those matching the labelSelector + relative to the given namespace(s)) that this pod should be + co-located (affinity) or not co-located (anti-affinity) with, + where co-located is defined as running on a node whose value of + the label with key matches that of any node on which + a pod of the set of pods is running + properties: + labelSelector: + description: |- + A label query over a set of resources, in this case pods. + If it's null, this PodAffinityTerm matches with no Pods. + properties: + matchExpressions: + description: matchExpressions is a list of label + selector requirements. The requirements are + ANDed. + items: + description: |- + A label selector requirement is a selector that contains values, a key, and an operator that + relates the key and values. + properties: + key: + description: key is the label key that + the selector applies to. + type: string + operator: + description: |- + operator represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: |- + values is an array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. This array is replaced during a strategic + merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + matchLabels: + additionalProperties: + type: string + description: |- + matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels + map is equivalent to an element of matchExpressions, whose key field is "key", the + operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + type: object + x-kubernetes-map-type: atomic + matchLabelKeys: + description: |- + MatchLabelKeys is a set of pod label keys to select which pods will + be taken into consideration. The keys are used to lookup values from the + incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` + to select the group of existing pods which pods will be taken into consideration + for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming + pod labels will be ignored. The default value is empty. + The same key is forbidden to exist in both matchLabelKeys and labelSelector. + Also, matchLabelKeys cannot be set when labelSelector isn't set. + items: + type: string + type: array + x-kubernetes-list-type: atomic + mismatchLabelKeys: + description: |- + MismatchLabelKeys is a set of pod label keys to select which pods will + be taken into consideration. The keys are used to lookup values from the + incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` + to select the group of existing pods which pods will be taken into consideration + for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming + pod labels will be ignored. The default value is empty. + The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. + Also, mismatchLabelKeys cannot be set when labelSelector isn't set. + items: + type: string + type: array + x-kubernetes-list-type: atomic + namespaceSelector: + description: |- + A label query over the set of namespaces that the term applies to. + The term is applied to the union of the namespaces selected by this field + and the ones listed in the namespaces field. + null selector and null or empty namespaces list means "this pod's namespace". + An empty selector ({}) matches all namespaces. + properties: + matchExpressions: + description: matchExpressions is a list of label + selector requirements. The requirements are + ANDed. + items: + description: |- + A label selector requirement is a selector that contains values, a key, and an operator that + relates the key and values. + properties: + key: + description: key is the label key that + the selector applies to. + type: string + operator: + description: |- + operator represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: |- + values is an array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. This array is replaced during a strategic + merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + matchLabels: + additionalProperties: + type: string + description: |- + matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels + map is equivalent to an element of matchExpressions, whose key field is "key", the + operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + type: object + x-kubernetes-map-type: atomic + namespaces: + description: |- + namespaces specifies a static list of namespace names that the term applies to. + The term is applied to the union of the namespaces listed in this field + and the ones selected by namespaceSelector. + null or empty namespaces list and null namespaceSelector means "this pod's namespace". + items: + type: string + type: array + x-kubernetes-list-type: atomic + topologyKey: + description: |- + This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching + the labelSelector in the specified namespaces, where co-located is defined as running on a node + whose value of the label with key topologyKey matches that of any node on which any of the + selected pods is running. + Empty topologyKey is not allowed. + type: string + required: + - topologyKey + type: object + type: array + x-kubernetes-list-type: atomic + type: object + type: object + logLevel: + description: |- + logLevel defines the verbosity of logs emitted by the ingress controller. + This field allows users to control the amount and severity of logs generated, which can be useful + for debugging issues or reducing noise in production environments. + Allowed values are Error, Warn, Info, and Debug. + When set to Error, only errors will be logged. + When set to Warn, both warnings and errors will be logged. + When set to Info, general information, warnings, and errors will all be logged. + When set to Debug, detailed debugging information will be logged. + When omitted, this means no opinion and the platform is left to choose a reasonable default, that is subject to change over time. + The current default value is `Info`. + enum: + - Error + - Warn + - Info + - Debug + type: string + nodeSelector: + additionalProperties: + type: string + description: |- + nodeSelector defines the nodes on which the ingress controller Pods are scheduled + nodeSelector is optional. + + When omitted, this means the user has no opinion and the platform is left + to choose reasonable defaults. These defaults are subject to change over time. + The current default value is `kubernetes.io/os: linux`. + maxProperties: 10 + minProperties: 1 + type: object + replicas: + description: |- + replicas defines the desired number of ingress controller replicas. + This field allows users to control the availability and load distribution of the ingress controller. + When not specified, defaults are used by the platform based on the cluster topology. + The current default behavior is: + - SingleReplica topology: 1 replica + - HighlyAvailable topology: 2 replicas + format: int32 + maximum: 20 + minimum: 1 + type: integer + resources: + description: |- + resources defines the compute resource requests and limits for the ingress controller container. + This includes CPU, memory and HugePages constraints to help control scheduling and resource usage. + When not specified, defaults are used by the platform. Requests cannot exceed limits. + This field is optional. + More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ + This is a simplified API that maps to Kubernetes ResourceRequirements. + The current default values are: + resources: + - name: cpu + request: 100m + limit: null + - name: memory + request: 256Mi + limit: null + Maximum length for this list is 10. + Minimum length for this list is 1. + items: + description: IngressControllerContainerResource defines a single + resource requirement for an ingress controller container. + properties: + limit: + anyOf: + - type: integer + - type: string + description: |- + limit is the maximum amount of the resource allowed (e.g. "2Mi", "1Gi"). + This field is optional. + When request is specified, limit cannot be less than request. + The value must be greater than 0 when specified. + maxLength: 20 + minLength: 1 + pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$ + x-kubernetes-int-or-string: true + x-kubernetes-validations: + - message: limit must be a positive, non-zero quantity + rule: isQuantity(self) && quantity(self).isGreaterThan(quantity('0')) + name: + description: |- + name of the resource (e.g. "cpu", "memory", "hugepages-2Mi"). + This field is required. + name must consist only of alphanumeric characters, `-`, `_` and `.` and must start and end with an alphanumeric character. + maxLength: 253 + minLength: 1 + type: string + x-kubernetes-validations: + - message: name must consist only of alphanumeric characters, + `-`, `_` and `.` and must start and end with an alphanumeric + character + rule: '!format.qualifiedName().validate(self).hasValue()' + request: + anyOf: + - type: integer + - type: string + description: |- + request is the minimum amount of the resource required (e.g. "2Mi", "1Gi"). + This field is optional. + When limit is specified, request cannot be greater than limit. + maxLength: 20 + minLength: 1 + pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$ + x-kubernetes-int-or-string: true + x-kubernetes-validations: + - message: request must be a positive, non-zero quantity + rule: isQuantity(self) && quantity(self).isGreaterThan(quantity('0')) + required: + - name + type: object + x-kubernetes-validations: + - message: at least one of request or limit must be set + rule: has(self.request) || has(self.limit) + - message: limit must be greater than or equal to request + rule: '!(has(self.request) && has(self.limit)) || quantity(self.limit).compareTo(quantity(self.request)) + >= 0' + maxItems: 10 + minItems: 1 + type: array + x-kubernetes-list-map-keys: + - name + x-kubernetes-list-type: map + tolerations: + description: |- + tolerations defines the tolerations for ingress controller pods. + This allows the ingress controller to be scheduled on nodes with matching taints. + When not specified, no tolerations are applied. + 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 + maxItems: 50 + type: array + x-kubernetes-list-type: atomic + type: object + performanceTuning: + description: |- + performanceTuning provides configuration options for performance optimization of ingress controllers. + performanceTuning is optional. + When omitted, this means no opinion and the platform is left to choose a reasonable default, that is subject to change over time. + minProperties: 1 + properties: + bufferSizes: + description: |- + bufferSizes defines buffer size settings for the ingress controller. + bufferSizes is optional. + When omitted, this means no opinion and the platform is left to choose reasonable defaults. + properties: + requestHeaderBufferSize: + anyOf: + - type: integer + - type: string + description: |- + requestHeaderBufferSize defines the size of the buffer for request headers. + This affects the maximum size of request headers that can be processed. + When not specified, the platform default is used. + pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$ + x-kubernetes-int-or-string: true + responseBufferSize: + anyOf: + - type: integer + - type: string + description: |- + responseBufferSize defines the size of the buffer for responses. + This affects buffering behavior for responses from backend servers. + When not specified, the platform default is used. + pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$ + x-kubernetes-int-or-string: true + type: object + connectionLimits: + description: |- + connectionLimits defines limits on connections handled by the ingress controller. + connectionLimits is optional. + When omitted, this means no opinion and the platform is left to choose reasonable defaults. + properties: + maxConnections: + description: |- + maxConnections defines the maximum number of concurrent connections. + This helps prevent resource exhaustion under high load. + When not specified, the platform default is used. + format: int32 + maximum: 1000000 + minimum: 1 + type: integer + maxConnectionsPerBackend: + description: |- + maxConnectionsPerBackend defines the maximum number of connections per backend server. + This helps distribute load evenly across backend servers. + When not specified, the platform default is used. + format: int32 + maximum: 10000 + minimum: 1 + type: integer + maxRequestsPerConnection: + description: |- + maxRequestsPerConnection defines the maximum number of requests per connection. + This controls connection reuse behavior. + When not specified, the platform default is used. + format: int32 + maximum: 1000 + minimum: 1 + type: integer + type: object + timeouts: + description: |- + timeouts defines timeout settings for the ingress controller. + timeouts is optional. + When omitted, this means no opinion and the platform is left to choose reasonable defaults. + properties: + clientTimeout: + description: |- + clientTimeout defines the timeout for client connections. + This is the maximum time to wait for a client to send a request. + When not specified, the platform default is used. + type: string + connectTimeout: + description: |- + connectTimeout defines the timeout for establishing connections to backend servers. + This is the maximum time to wait when establishing a connection to a backend. + When not specified, the platform default is used. + type: string + serverTimeout: + description: |- + serverTimeout defines the timeout for backend server connections. + This is the maximum time to wait for a response from a backend server. + When not specified, the platform default is used. + type: string + type: object + type: object + type: object + status: + description: status holds observed values from the cluster. They may not + be overridden. + properties: + conditions: + description: conditions represent the latest available observations + of the IngressControllerConfig's current state. + items: + description: Condition contains details for one aspect of the current + state of this API Resource. + properties: + lastTransitionTime: + description: |- + lastTransitionTime is the last time the condition transitioned from one status to another. + This should be when the underlying condition changed. If that is not known, then using the time when the API field changed is acceptable. + format: date-time + type: string + message: + description: |- + message is a human readable message indicating details about the transition. + This may be an empty string. + maxLength: 32768 + type: string + observedGeneration: + description: |- + observedGeneration represents the .metadata.generation that the condition was set based upon. + For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date + with respect to the current state of the instance. + format: int64 + minimum: 0 + type: integer + reason: + description: |- + reason contains a programmatic identifier indicating the reason for the condition's last transition. + Producers of specific condition types may define expected values and meanings for this field, + and whether the values are considered a guaranteed API. + The value should be a CamelCase string. + This field may not be empty. + maxLength: 1024 + minLength: 1 + pattern: ^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$ + type: string + status: + description: status of the condition, one of True, False, Unknown. + enum: + - "True" + - "False" + - Unknown + type: string + type: + description: type of condition in CamelCase or in foo.example.com/CamelCase. + maxLength: 316 + pattern: ^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$ + type: string + required: + - lastTransitionTime + - message + - reason + - status + - type + type: object + maxItems: 32 + type: array + x-kubernetes-list-map-keys: + - type + x-kubernetes-list-type: map + type: object + required: + - spec + type: object + served: true + storage: true + subresources: + status: {} diff --git a/config/v1alpha1/zz_generated.deepcopy.go b/config/v1alpha1/zz_generated.deepcopy.go index 6549f6cbe43..32f00ed26fb 100644 --- a/config/v1alpha1/zz_generated.deepcopy.go +++ b/config/v1alpha1/zz_generated.deepcopy.go @@ -412,6 +412,48 @@ func (in *ContainerResource) DeepCopy() *ContainerResource { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *DefaultIngressControllerConfig) DeepCopyInto(out *DefaultIngressControllerConfig) { + *out = *in + if in.NodeSelector != nil { + in, out := &in.NodeSelector, &out.NodeSelector + *out = make(map[string]string, len(*in)) + for key, val := range *in { + (*out)[key] = val + } + } + if in.Resources != nil { + in, out := &in.Resources, &out.Resources + *out = make([]IngressControllerContainerResource, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.Tolerations != nil { + in, out := &in.Tolerations, &out.Tolerations + *out = make([]v1.Toleration, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.Affinity != nil { + in, out := &in.Affinity, &out.Affinity + *out = new(v1.Affinity) + (*in).DeepCopyInto(*out) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DefaultIngressControllerConfig. +func (in *DefaultIngressControllerConfig) DeepCopy() *DefaultIngressControllerConfig { + if in == nil { + return nil + } + out := new(DefaultIngressControllerConfig) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *EtcdBackupSpec) DeepCopyInto(out *EtcdBackupSpec) { *out = *in @@ -588,6 +630,234 @@ func (in *ImagePolicyStatus) DeepCopy() *ImagePolicyStatus { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *IngressControllerBufferSizes) DeepCopyInto(out *IngressControllerBufferSizes) { + *out = *in + if in.RequestHeaderBufferSize != nil { + in, out := &in.RequestHeaderBufferSize, &out.RequestHeaderBufferSize + x := (*in).DeepCopy() + *out = &x + } + if in.ResponseBufferSize != nil { + in, out := &in.ResponseBufferSize, &out.ResponseBufferSize + x := (*in).DeepCopy() + *out = &x + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IngressControllerBufferSizes. +func (in *IngressControllerBufferSizes) DeepCopy() *IngressControllerBufferSizes { + if in == nil { + return nil + } + out := new(IngressControllerBufferSizes) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *IngressControllerConfig) DeepCopyInto(out *IngressControllerConfig) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) + if in.Status != nil { + in, out := &in.Status, &out.Status + *out = new(IngressControllerConfigStatus) + (*in).DeepCopyInto(*out) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IngressControllerConfig. +func (in *IngressControllerConfig) DeepCopy() *IngressControllerConfig { + if in == nil { + return nil + } + out := new(IngressControllerConfig) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *IngressControllerConfig) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *IngressControllerConfigList) DeepCopyInto(out *IngressControllerConfigList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]IngressControllerConfig, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IngressControllerConfigList. +func (in *IngressControllerConfigList) DeepCopy() *IngressControllerConfigList { + if in == nil { + return nil + } + out := new(IngressControllerConfigList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *IngressControllerConfigList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *IngressControllerConfigSpec) DeepCopyInto(out *IngressControllerConfigSpec) { + *out = *in + in.DefaultControllerConfig.DeepCopyInto(&out.DefaultControllerConfig) + in.PerformanceTuning.DeepCopyInto(&out.PerformanceTuning) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IngressControllerConfigSpec. +func (in *IngressControllerConfigSpec) DeepCopy() *IngressControllerConfigSpec { + if in == nil { + return nil + } + out := new(IngressControllerConfigSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *IngressControllerConfigStatus) DeepCopyInto(out *IngressControllerConfigStatus) { + *out = *in + if in.Conditions != nil { + in, out := &in.Conditions, &out.Conditions + *out = make([]metav1.Condition, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IngressControllerConfigStatus. +func (in *IngressControllerConfigStatus) DeepCopy() *IngressControllerConfigStatus { + if in == nil { + return nil + } + out := new(IngressControllerConfigStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *IngressControllerConnectionLimits) DeepCopyInto(out *IngressControllerConnectionLimits) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IngressControllerConnectionLimits. +func (in *IngressControllerConnectionLimits) DeepCopy() *IngressControllerConnectionLimits { + if in == nil { + return nil + } + out := new(IngressControllerConnectionLimits) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *IngressControllerContainerResource) DeepCopyInto(out *IngressControllerContainerResource) { + *out = *in + out.Request = in.Request.DeepCopy() + out.Limit = in.Limit.DeepCopy() + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IngressControllerContainerResource. +func (in *IngressControllerContainerResource) DeepCopy() *IngressControllerContainerResource { + if in == nil { + return nil + } + out := new(IngressControllerContainerResource) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *IngressControllerPerformanceTuning) DeepCopyInto(out *IngressControllerPerformanceTuning) { + *out = *in + if in.ConnectionLimits != nil { + in, out := &in.ConnectionLimits, &out.ConnectionLimits + *out = new(IngressControllerConnectionLimits) + **out = **in + } + if in.Timeouts != nil { + in, out := &in.Timeouts, &out.Timeouts + *out = new(IngressControllerTimeouts) + (*in).DeepCopyInto(*out) + } + if in.BufferSizes != nil { + in, out := &in.BufferSizes, &out.BufferSizes + *out = new(IngressControllerBufferSizes) + (*in).DeepCopyInto(*out) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IngressControllerPerformanceTuning. +func (in *IngressControllerPerformanceTuning) DeepCopy() *IngressControllerPerformanceTuning { + if in == nil { + return nil + } + out := new(IngressControllerPerformanceTuning) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *IngressControllerTimeouts) DeepCopyInto(out *IngressControllerTimeouts) { + *out = *in + if in.ClientTimeout != nil { + in, out := &in.ClientTimeout, &out.ClientTimeout + *out = new(metav1.Duration) + **out = **in + } + if in.ServerTimeout != nil { + in, out := &in.ServerTimeout, &out.ServerTimeout + *out = new(metav1.Duration) + **out = **in + } + if in.ConnectTimeout != nil { + in, out := &in.ConnectTimeout, &out.ConnectTimeout + *out = new(metav1.Duration) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IngressControllerTimeouts. +func (in *IngressControllerTimeouts) DeepCopy() *IngressControllerTimeouts { + if in == nil { + return nil + } + out := new(IngressControllerTimeouts) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *InsightsDataGather) DeepCopyInto(out *InsightsDataGather) { *out = *in diff --git a/config/v1alpha1/zz_generated.featuregated-crd-manifests.yaml b/config/v1alpha1/zz_generated.featuregated-crd-manifests.yaml index b9dca71a925..0d8bd5d31c6 100644 --- a/config/v1alpha1/zz_generated.featuregated-crd-manifests.yaml +++ b/config/v1alpha1/zz_generated.featuregated-crd-manifests.yaml @@ -93,6 +93,30 @@ imagepolicies.config.openshift.io: - SigstoreImageVerification Version: v1alpha1 +ingresscontrollerconfigs.config.openshift.io: + Annotations: + description: Ingress Controller configuration API + ApprovedPRNumber: https://github.com/openshift/api/pull/XXXX + CRDName: ingresscontrollerconfigs.config.openshift.io + Capability: "" + Category: "" + FeatureGates: + - IngressControllerConfig + FilenameOperatorName: config-operator + FilenameOperatorOrdering: "01" + FilenameRunLevel: "0000_10" + GroupName: config.openshift.io + HasStatus: true + KindName: IngressControllerConfig + Labels: {} + PluralName: ingresscontrollerconfigs + PrinterColumns: [] + Scope: Cluster + ShortNames: null + TopLevelFeatureGates: + - IngressControllerConfig + Version: v1alpha1 + insightsdatagathers.config.openshift.io: Annotations: {} ApprovedPRNumber: https://github.com/openshift/api/pull/1245 diff --git a/config/v1alpha1/zz_generated.featuregated-crd-manifests/ingresscontrollerconfigs.config.openshift.io/IngressControllerConfig.yaml b/config/v1alpha1/zz_generated.featuregated-crd-manifests/ingresscontrollerconfigs.config.openshift.io/IngressControllerConfig.yaml new file mode 100644 index 00000000000..04b59c8826a --- /dev/null +++ b/config/v1alpha1/zz_generated.featuregated-crd-manifests/ingresscontrollerconfigs.config.openshift.io/IngressControllerConfig.yaml @@ -0,0 +1,1318 @@ +apiVersion: apiextensions.k8s.io/v1 +kind: CustomResourceDefinition +metadata: + annotations: + api-approved.openshift.io: https://github.com/openshift/api/pull/XXXX + api.openshift.io/filename-cvo-runlevel: "0000_10" + api.openshift.io/filename-operator: config-operator + api.openshift.io/filename-ordering: "01" + description: Ingress Controller configuration API + feature-gate.release.openshift.io/IngressControllerConfig: "true" + name: ingresscontrollerconfigs.config.openshift.io +spec: + group: config.openshift.io + names: + kind: IngressControllerConfig + listKind: IngressControllerConfigList + plural: ingresscontrollerconfigs + singular: ingresscontrollerconfig + scope: Cluster + versions: + - name: v1alpha1 + schema: + openAPIV3Schema: + description: |- + IngressControllerConfig is the Custom Resource object which holds the current configuration of Ingress Controllers. + This provides a cluster-level configuration API for managing ingress controller operational settings. + + Compatibility level 4: No compatibility is provided, the API can change at any point for any reason. These capabilities should not be used by applications needing long term support. + 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: spec holds user configuration for the Ingress Controllers + minProperties: 1 + properties: + defaultControllerConfig: + description: |- + defaultControllerConfig allows users to configure how the default ingress controller instance + should be deployed and managed. + defaultControllerConfig is optional. + When omitted, this means no opinion and the platform is left to choose a reasonable default, that is subject to change over time. + minProperties: 1 + properties: + affinity: + description: |- + affinity defines the affinity rules for ingress controller pods. + This allows users to control pod placement for high availability or performance optimization. + When not specified, no affinity rules are applied. + properties: + nodeAffinity: + description: Describes node affinity scheduling rules for + the pod. + properties: + preferredDuringSchedulingIgnoredDuringExecution: + description: |- + The scheduler will prefer to schedule pods to nodes that satisfy + the affinity expressions specified by this field, but it may choose + a node that violates one or more of the expressions. The node that is + most preferred is the one with the greatest sum of weights, i.e. + for each node that meets all of the scheduling requirements (resource + request, requiredDuringScheduling affinity expressions, etc.), + compute a sum by iterating through the elements of this field and adding + "weight" to the sum if the node matches the corresponding matchExpressions; the + node(s) with the highest sum are the most preferred. + items: + description: |- + An empty preferred scheduling term matches all objects with implicit weight 0 + (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op). + properties: + preference: + description: A node selector term, associated with + the corresponding weight. + properties: + matchExpressions: + description: A list of node selector requirements + by node's labels. + items: + description: |- + A node selector requirement is a selector that contains values, a key, and an operator + that relates the key and values. + properties: + key: + description: The label key that the selector + applies to. + type: string + operator: + description: |- + Represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. + type: string + values: + description: |- + An array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. If the operator is Gt or Lt, the values + array must have a single element, which will be interpreted as an integer. + This array is replaced during a strategic merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + matchFields: + description: A list of node selector requirements + by node's fields. + items: + description: |- + A node selector requirement is a selector that contains values, a key, and an operator + that relates the key and values. + properties: + key: + description: The label key that the selector + applies to. + type: string + operator: + description: |- + Represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. + type: string + values: + description: |- + An array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. If the operator is Gt or Lt, the values + array must have a single element, which will be interpreted as an integer. + This array is replaced during a strategic merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + type: object + x-kubernetes-map-type: atomic + weight: + description: Weight associated with matching the + corresponding nodeSelectorTerm, in the range 1-100. + format: int32 + type: integer + required: + - preference + - weight + type: object + type: array + x-kubernetes-list-type: atomic + requiredDuringSchedulingIgnoredDuringExecution: + description: |- + If the affinity requirements specified by this field are not met at + scheduling time, the pod will not be scheduled onto the node. + If the affinity requirements specified by this field cease to be met + at some point during pod execution (e.g. due to an update), the system + may or may not try to eventually evict the pod from its node. + properties: + nodeSelectorTerms: + description: Required. A list of node selector terms. + The terms are ORed. + items: + description: |- + A null or empty node selector term matches no objects. The requirements of + them are ANDed. + The TopologySelectorTerm type implements a subset of the NodeSelectorTerm. + properties: + matchExpressions: + description: A list of node selector requirements + by node's labels. + items: + description: |- + A node selector requirement is a selector that contains values, a key, and an operator + that relates the key and values. + properties: + key: + description: The label key that the selector + applies to. + type: string + operator: + description: |- + Represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. + type: string + values: + description: |- + An array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. If the operator is Gt or Lt, the values + array must have a single element, which will be interpreted as an integer. + This array is replaced during a strategic merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + matchFields: + description: A list of node selector requirements + by node's fields. + items: + description: |- + A node selector requirement is a selector that contains values, a key, and an operator + that relates the key and values. + properties: + key: + description: The label key that the selector + applies to. + type: string + operator: + description: |- + Represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. + type: string + values: + description: |- + An array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. If the operator is Gt or Lt, the values + array must have a single element, which will be interpreted as an integer. + This array is replaced during a strategic merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + type: object + x-kubernetes-map-type: atomic + type: array + x-kubernetes-list-type: atomic + required: + - nodeSelectorTerms + type: object + x-kubernetes-map-type: atomic + type: object + podAffinity: + description: Describes pod affinity scheduling rules (e.g. + co-locate this pod in the same node, zone, etc. as some + other pod(s)). + properties: + preferredDuringSchedulingIgnoredDuringExecution: + description: |- + The scheduler will prefer to schedule pods to nodes that satisfy + the affinity expressions specified by this field, but it may choose + a node that violates one or more of the expressions. The node that is + most preferred is the one with the greatest sum of weights, i.e. + for each node that meets all of the scheduling requirements (resource + request, requiredDuringScheduling affinity expressions, etc.), + compute a sum by iterating through the elements of this field and adding + "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the + node(s) with the highest sum are the most preferred. + items: + description: The weights of all of the matched WeightedPodAffinityTerm + fields are added per-node to find the most preferred + node(s) + properties: + podAffinityTerm: + description: Required. A pod affinity term, associated + with the corresponding weight. + properties: + labelSelector: + description: |- + A label query over a set of resources, in this case pods. + If it's null, this PodAffinityTerm matches with no Pods. + properties: + matchExpressions: + description: matchExpressions is a list + of label selector requirements. The requirements + are ANDed. + items: + description: |- + A label selector requirement is a selector that contains values, a key, and an operator that + relates the key and values. + properties: + key: + description: key is the label key + that the selector applies to. + type: string + operator: + description: |- + operator represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: |- + values is an array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. This array is replaced during a strategic + merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + matchLabels: + additionalProperties: + type: string + description: |- + matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels + map is equivalent to an element of matchExpressions, whose key field is "key", the + operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + type: object + x-kubernetes-map-type: atomic + matchLabelKeys: + description: |- + MatchLabelKeys is a set of pod label keys to select which pods will + be taken into consideration. The keys are used to lookup values from the + incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` + to select the group of existing pods which pods will be taken into consideration + for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming + pod labels will be ignored. The default value is empty. + The same key is forbidden to exist in both matchLabelKeys and labelSelector. + Also, matchLabelKeys cannot be set when labelSelector isn't set. + items: + type: string + type: array + x-kubernetes-list-type: atomic + mismatchLabelKeys: + description: |- + MismatchLabelKeys is a set of pod label keys to select which pods will + be taken into consideration. The keys are used to lookup values from the + incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` + to select the group of existing pods which pods will be taken into consideration + for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming + pod labels will be ignored. The default value is empty. + The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. + Also, mismatchLabelKeys cannot be set when labelSelector isn't set. + items: + type: string + type: array + x-kubernetes-list-type: atomic + namespaceSelector: + description: |- + A label query over the set of namespaces that the term applies to. + The term is applied to the union of the namespaces selected by this field + and the ones listed in the namespaces field. + null selector and null or empty namespaces list means "this pod's namespace". + An empty selector ({}) matches all namespaces. + properties: + matchExpressions: + description: matchExpressions is a list + of label selector requirements. The requirements + are ANDed. + items: + description: |- + A label selector requirement is a selector that contains values, a key, and an operator that + relates the key and values. + properties: + key: + description: key is the label key + that the selector applies to. + type: string + operator: + description: |- + operator represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: |- + values is an array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. This array is replaced during a strategic + merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + matchLabels: + additionalProperties: + type: string + description: |- + matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels + map is equivalent to an element of matchExpressions, whose key field is "key", the + operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + type: object + x-kubernetes-map-type: atomic + namespaces: + description: |- + namespaces specifies a static list of namespace names that the term applies to. + The term is applied to the union of the namespaces listed in this field + and the ones selected by namespaceSelector. + null or empty namespaces list and null namespaceSelector means "this pod's namespace". + items: + type: string + type: array + x-kubernetes-list-type: atomic + topologyKey: + description: |- + This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching + the labelSelector in the specified namespaces, where co-located is defined as running on a node + whose value of the label with key topologyKey matches that of any node on which any of the + selected pods is running. + Empty topologyKey is not allowed. + type: string + required: + - topologyKey + type: object + weight: + description: |- + weight associated with matching the corresponding podAffinityTerm, + in the range 1-100. + format: int32 + type: integer + required: + - podAffinityTerm + - weight + type: object + type: array + x-kubernetes-list-type: atomic + requiredDuringSchedulingIgnoredDuringExecution: + description: |- + If the affinity requirements specified by this field are not met at + scheduling time, the pod will not be scheduled onto the node. + If the affinity requirements specified by this field cease to be met + at some point during pod execution (e.g. due to a pod label update), the + system may or may not try to eventually evict the pod from its node. + When there are multiple elements, the lists of nodes corresponding to each + podAffinityTerm are intersected, i.e. all terms must be satisfied. + items: + description: |- + Defines a set of pods (namely those matching the labelSelector + relative to the given namespace(s)) that this pod should be + co-located (affinity) or not co-located (anti-affinity) with, + where co-located is defined as running on a node whose value of + the label with key matches that of any node on which + a pod of the set of pods is running + properties: + labelSelector: + description: |- + A label query over a set of resources, in this case pods. + If it's null, this PodAffinityTerm matches with no Pods. + properties: + matchExpressions: + description: matchExpressions is a list of label + selector requirements. The requirements are + ANDed. + items: + description: |- + A label selector requirement is a selector that contains values, a key, and an operator that + relates the key and values. + properties: + key: + description: key is the label key that + the selector applies to. + type: string + operator: + description: |- + operator represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: |- + values is an array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. This array is replaced during a strategic + merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + matchLabels: + additionalProperties: + type: string + description: |- + matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels + map is equivalent to an element of matchExpressions, whose key field is "key", the + operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + type: object + x-kubernetes-map-type: atomic + matchLabelKeys: + description: |- + MatchLabelKeys is a set of pod label keys to select which pods will + be taken into consideration. The keys are used to lookup values from the + incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` + to select the group of existing pods which pods will be taken into consideration + for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming + pod labels will be ignored. The default value is empty. + The same key is forbidden to exist in both matchLabelKeys and labelSelector. + Also, matchLabelKeys cannot be set when labelSelector isn't set. + items: + type: string + type: array + x-kubernetes-list-type: atomic + mismatchLabelKeys: + description: |- + MismatchLabelKeys is a set of pod label keys to select which pods will + be taken into consideration. The keys are used to lookup values from the + incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` + to select the group of existing pods which pods will be taken into consideration + for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming + pod labels will be ignored. The default value is empty. + The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. + Also, mismatchLabelKeys cannot be set when labelSelector isn't set. + items: + type: string + type: array + x-kubernetes-list-type: atomic + namespaceSelector: + description: |- + A label query over the set of namespaces that the term applies to. + The term is applied to the union of the namespaces selected by this field + and the ones listed in the namespaces field. + null selector and null or empty namespaces list means "this pod's namespace". + An empty selector ({}) matches all namespaces. + properties: + matchExpressions: + description: matchExpressions is a list of label + selector requirements. The requirements are + ANDed. + items: + description: |- + A label selector requirement is a selector that contains values, a key, and an operator that + relates the key and values. + properties: + key: + description: key is the label key that + the selector applies to. + type: string + operator: + description: |- + operator represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: |- + values is an array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. This array is replaced during a strategic + merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + matchLabels: + additionalProperties: + type: string + description: |- + matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels + map is equivalent to an element of matchExpressions, whose key field is "key", the + operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + type: object + x-kubernetes-map-type: atomic + namespaces: + description: |- + namespaces specifies a static list of namespace names that the term applies to. + The term is applied to the union of the namespaces listed in this field + and the ones selected by namespaceSelector. + null or empty namespaces list and null namespaceSelector means "this pod's namespace". + items: + type: string + type: array + x-kubernetes-list-type: atomic + topologyKey: + description: |- + This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching + the labelSelector in the specified namespaces, where co-located is defined as running on a node + whose value of the label with key topologyKey matches that of any node on which any of the + selected pods is running. + Empty topologyKey is not allowed. + type: string + required: + - topologyKey + type: object + type: array + x-kubernetes-list-type: atomic + type: object + podAntiAffinity: + description: Describes pod anti-affinity scheduling rules + (e.g. avoid putting this pod in the same node, zone, etc. + as some other pod(s)). + properties: + preferredDuringSchedulingIgnoredDuringExecution: + description: |- + The scheduler will prefer to schedule pods to nodes that satisfy + the anti-affinity expressions specified by this field, but it may choose + a node that violates one or more of the expressions. The node that is + most preferred is the one with the greatest sum of weights, i.e. + for each node that meets all of the scheduling requirements (resource + request, requiredDuringScheduling anti-affinity expressions, etc.), + compute a sum by iterating through the elements of this field and adding + "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the + node(s) with the highest sum are the most preferred. + items: + description: The weights of all of the matched WeightedPodAffinityTerm + fields are added per-node to find the most preferred + node(s) + properties: + podAffinityTerm: + description: Required. A pod affinity term, associated + with the corresponding weight. + properties: + labelSelector: + description: |- + A label query over a set of resources, in this case pods. + If it's null, this PodAffinityTerm matches with no Pods. + properties: + matchExpressions: + description: matchExpressions is a list + of label selector requirements. The requirements + are ANDed. + items: + description: |- + A label selector requirement is a selector that contains values, a key, and an operator that + relates the key and values. + properties: + key: + description: key is the label key + that the selector applies to. + type: string + operator: + description: |- + operator represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: |- + values is an array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. This array is replaced during a strategic + merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + matchLabels: + additionalProperties: + type: string + description: |- + matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels + map is equivalent to an element of matchExpressions, whose key field is "key", the + operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + type: object + x-kubernetes-map-type: atomic + matchLabelKeys: + description: |- + MatchLabelKeys is a set of pod label keys to select which pods will + be taken into consideration. The keys are used to lookup values from the + incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` + to select the group of existing pods which pods will be taken into consideration + for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming + pod labels will be ignored. The default value is empty. + The same key is forbidden to exist in both matchLabelKeys and labelSelector. + Also, matchLabelKeys cannot be set when labelSelector isn't set. + items: + type: string + type: array + x-kubernetes-list-type: atomic + mismatchLabelKeys: + description: |- + MismatchLabelKeys is a set of pod label keys to select which pods will + be taken into consideration. The keys are used to lookup values from the + incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` + to select the group of existing pods which pods will be taken into consideration + for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming + pod labels will be ignored. The default value is empty. + The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. + Also, mismatchLabelKeys cannot be set when labelSelector isn't set. + items: + type: string + type: array + x-kubernetes-list-type: atomic + namespaceSelector: + description: |- + A label query over the set of namespaces that the term applies to. + The term is applied to the union of the namespaces selected by this field + and the ones listed in the namespaces field. + null selector and null or empty namespaces list means "this pod's namespace". + An empty selector ({}) matches all namespaces. + properties: + matchExpressions: + description: matchExpressions is a list + of label selector requirements. The requirements + are ANDed. + items: + description: |- + A label selector requirement is a selector that contains values, a key, and an operator that + relates the key and values. + properties: + key: + description: key is the label key + that the selector applies to. + type: string + operator: + description: |- + operator represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: |- + values is an array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. This array is replaced during a strategic + merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + matchLabels: + additionalProperties: + type: string + description: |- + matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels + map is equivalent to an element of matchExpressions, whose key field is "key", the + operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + type: object + x-kubernetes-map-type: atomic + namespaces: + description: |- + namespaces specifies a static list of namespace names that the term applies to. + The term is applied to the union of the namespaces listed in this field + and the ones selected by namespaceSelector. + null or empty namespaces list and null namespaceSelector means "this pod's namespace". + items: + type: string + type: array + x-kubernetes-list-type: atomic + topologyKey: + description: |- + This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching + the labelSelector in the specified namespaces, where co-located is defined as running on a node + whose value of the label with key topologyKey matches that of any node on which any of the + selected pods is running. + Empty topologyKey is not allowed. + type: string + required: + - topologyKey + type: object + weight: + description: |- + weight associated with matching the corresponding podAffinityTerm, + in the range 1-100. + format: int32 + type: integer + required: + - podAffinityTerm + - weight + type: object + type: array + x-kubernetes-list-type: atomic + requiredDuringSchedulingIgnoredDuringExecution: + description: |- + If the anti-affinity requirements specified by this field are not met at + scheduling time, the pod will not be scheduled onto the node. + If the anti-affinity requirements specified by this field cease to be met + at some point during pod execution (e.g. due to a pod label update), the + system may or may not try to eventually evict the pod from its node. + When there are multiple elements, the lists of nodes corresponding to each + podAffinityTerm are intersected, i.e. all terms must be satisfied. + items: + description: |- + Defines a set of pods (namely those matching the labelSelector + relative to the given namespace(s)) that this pod should be + co-located (affinity) or not co-located (anti-affinity) with, + where co-located is defined as running on a node whose value of + the label with key matches that of any node on which + a pod of the set of pods is running + properties: + labelSelector: + description: |- + A label query over a set of resources, in this case pods. + If it's null, this PodAffinityTerm matches with no Pods. + properties: + matchExpressions: + description: matchExpressions is a list of label + selector requirements. The requirements are + ANDed. + items: + description: |- + A label selector requirement is a selector that contains values, a key, and an operator that + relates the key and values. + properties: + key: + description: key is the label key that + the selector applies to. + type: string + operator: + description: |- + operator represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: |- + values is an array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. This array is replaced during a strategic + merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + matchLabels: + additionalProperties: + type: string + description: |- + matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels + map is equivalent to an element of matchExpressions, whose key field is "key", the + operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + type: object + x-kubernetes-map-type: atomic + matchLabelKeys: + description: |- + MatchLabelKeys is a set of pod label keys to select which pods will + be taken into consideration. The keys are used to lookup values from the + incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` + to select the group of existing pods which pods will be taken into consideration + for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming + pod labels will be ignored. The default value is empty. + The same key is forbidden to exist in both matchLabelKeys and labelSelector. + Also, matchLabelKeys cannot be set when labelSelector isn't set. + items: + type: string + type: array + x-kubernetes-list-type: atomic + mismatchLabelKeys: + description: |- + MismatchLabelKeys is a set of pod label keys to select which pods will + be taken into consideration. The keys are used to lookup values from the + incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` + to select the group of existing pods which pods will be taken into consideration + for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming + pod labels will be ignored. The default value is empty. + The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. + Also, mismatchLabelKeys cannot be set when labelSelector isn't set. + items: + type: string + type: array + x-kubernetes-list-type: atomic + namespaceSelector: + description: |- + A label query over the set of namespaces that the term applies to. + The term is applied to the union of the namespaces selected by this field + and the ones listed in the namespaces field. + null selector and null or empty namespaces list means "this pod's namespace". + An empty selector ({}) matches all namespaces. + properties: + matchExpressions: + description: matchExpressions is a list of label + selector requirements. The requirements are + ANDed. + items: + description: |- + A label selector requirement is a selector that contains values, a key, and an operator that + relates the key and values. + properties: + key: + description: key is the label key that + the selector applies to. + type: string + operator: + description: |- + operator represents a key's relationship to a set of values. + Valid operators are In, NotIn, Exists and DoesNotExist. + type: string + values: + description: |- + values is an array of string values. If the operator is In or NotIn, + the values array must be non-empty. If the operator is Exists or DoesNotExist, + the values array must be empty. This array is replaced during a strategic + merge patch. + items: + type: string + type: array + x-kubernetes-list-type: atomic + required: + - key + - operator + type: object + type: array + x-kubernetes-list-type: atomic + matchLabels: + additionalProperties: + type: string + description: |- + matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels + map is equivalent to an element of matchExpressions, whose key field is "key", the + operator is "In", and the values array contains only "value". The requirements are ANDed. + type: object + type: object + x-kubernetes-map-type: atomic + namespaces: + description: |- + namespaces specifies a static list of namespace names that the term applies to. + The term is applied to the union of the namespaces listed in this field + and the ones selected by namespaceSelector. + null or empty namespaces list and null namespaceSelector means "this pod's namespace". + items: + type: string + type: array + x-kubernetes-list-type: atomic + topologyKey: + description: |- + This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching + the labelSelector in the specified namespaces, where co-located is defined as running on a node + whose value of the label with key topologyKey matches that of any node on which any of the + selected pods is running. + Empty topologyKey is not allowed. + type: string + required: + - topologyKey + type: object + type: array + x-kubernetes-list-type: atomic + type: object + type: object + logLevel: + description: |- + logLevel defines the verbosity of logs emitted by the ingress controller. + This field allows users to control the amount and severity of logs generated, which can be useful + for debugging issues or reducing noise in production environments. + Allowed values are Error, Warn, Info, and Debug. + When set to Error, only errors will be logged. + When set to Warn, both warnings and errors will be logged. + When set to Info, general information, warnings, and errors will all be logged. + When set to Debug, detailed debugging information will be logged. + When omitted, this means no opinion and the platform is left to choose a reasonable default, that is subject to change over time. + The current default value is `Info`. + enum: + - Error + - Warn + - Info + - Debug + type: string + nodeSelector: + additionalProperties: + type: string + description: |- + nodeSelector defines the nodes on which the ingress controller Pods are scheduled + nodeSelector is optional. + + When omitted, this means the user has no opinion and the platform is left + to choose reasonable defaults. These defaults are subject to change over time. + The current default value is `kubernetes.io/os: linux`. + maxProperties: 10 + minProperties: 1 + type: object + replicas: + description: |- + replicas defines the desired number of ingress controller replicas. + This field allows users to control the availability and load distribution of the ingress controller. + When not specified, defaults are used by the platform based on the cluster topology. + The current default behavior is: + - SingleReplica topology: 1 replica + - HighlyAvailable topology: 2 replicas + format: int32 + maximum: 20 + minimum: 1 + type: integer + resources: + description: |- + resources defines the compute resource requests and limits for the ingress controller container. + This includes CPU, memory and HugePages constraints to help control scheduling and resource usage. + When not specified, defaults are used by the platform. Requests cannot exceed limits. + This field is optional. + More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ + This is a simplified API that maps to Kubernetes ResourceRequirements. + The current default values are: + resources: + - name: cpu + request: 100m + limit: null + - name: memory + request: 256Mi + limit: null + Maximum length for this list is 10. + Minimum length for this list is 1. + items: + description: IngressControllerContainerResource defines a single + resource requirement for an ingress controller container. + properties: + limit: + anyOf: + - type: integer + - type: string + description: |- + limit is the maximum amount of the resource allowed (e.g. "2Mi", "1Gi"). + This field is optional. + When request is specified, limit cannot be less than request. + The value must be greater than 0 when specified. + maxLength: 20 + minLength: 1 + pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$ + x-kubernetes-int-or-string: true + x-kubernetes-validations: + - message: limit must be a positive, non-zero quantity + rule: isQuantity(self) && quantity(self).isGreaterThan(quantity('0')) + name: + description: |- + name of the resource (e.g. "cpu", "memory", "hugepages-2Mi"). + This field is required. + name must consist only of alphanumeric characters, `-`, `_` and `.` and must start and end with an alphanumeric character. + maxLength: 253 + minLength: 1 + type: string + x-kubernetes-validations: + - message: name must consist only of alphanumeric characters, + `-`, `_` and `.` and must start and end with an alphanumeric + character + rule: '!format.qualifiedName().validate(self).hasValue()' + request: + anyOf: + - type: integer + - type: string + description: |- + request is the minimum amount of the resource required (e.g. "2Mi", "1Gi"). + This field is optional. + When limit is specified, request cannot be greater than limit. + maxLength: 20 + minLength: 1 + pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$ + x-kubernetes-int-or-string: true + x-kubernetes-validations: + - message: request must be a positive, non-zero quantity + rule: isQuantity(self) && quantity(self).isGreaterThan(quantity('0')) + required: + - name + type: object + x-kubernetes-validations: + - message: at least one of request or limit must be set + rule: has(self.request) || has(self.limit) + - message: limit must be greater than or equal to request + rule: '!(has(self.request) && has(self.limit)) || quantity(self.limit).compareTo(quantity(self.request)) + >= 0' + maxItems: 10 + minItems: 1 + type: array + x-kubernetes-list-map-keys: + - name + x-kubernetes-list-type: map + tolerations: + description: |- + tolerations defines the tolerations for ingress controller pods. + This allows the ingress controller to be scheduled on nodes with matching taints. + When not specified, no tolerations are applied. + 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 + maxItems: 50 + type: array + x-kubernetes-list-type: atomic + type: object + performanceTuning: + description: |- + performanceTuning provides configuration options for performance optimization of ingress controllers. + performanceTuning is optional. + When omitted, this means no opinion and the platform is left to choose a reasonable default, that is subject to change over time. + minProperties: 1 + properties: + bufferSizes: + description: |- + bufferSizes defines buffer size settings for the ingress controller. + bufferSizes is optional. + When omitted, this means no opinion and the platform is left to choose reasonable defaults. + properties: + requestHeaderBufferSize: + anyOf: + - type: integer + - type: string + description: |- + requestHeaderBufferSize defines the size of the buffer for request headers. + This affects the maximum size of request headers that can be processed. + When not specified, the platform default is used. + pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$ + x-kubernetes-int-or-string: true + responseBufferSize: + anyOf: + - type: integer + - type: string + description: |- + responseBufferSize defines the size of the buffer for responses. + This affects buffering behavior for responses from backend servers. + When not specified, the platform default is used. + pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$ + x-kubernetes-int-or-string: true + type: object + connectionLimits: + description: |- + connectionLimits defines limits on connections handled by the ingress controller. + connectionLimits is optional. + When omitted, this means no opinion and the platform is left to choose reasonable defaults. + properties: + maxConnections: + description: |- + maxConnections defines the maximum number of concurrent connections. + This helps prevent resource exhaustion under high load. + When not specified, the platform default is used. + format: int32 + maximum: 1000000 + minimum: 1 + type: integer + maxConnectionsPerBackend: + description: |- + maxConnectionsPerBackend defines the maximum number of connections per backend server. + This helps distribute load evenly across backend servers. + When not specified, the platform default is used. + format: int32 + maximum: 10000 + minimum: 1 + type: integer + maxRequestsPerConnection: + description: |- + maxRequestsPerConnection defines the maximum number of requests per connection. + This controls connection reuse behavior. + When not specified, the platform default is used. + format: int32 + maximum: 1000 + minimum: 1 + type: integer + type: object + timeouts: + description: |- + timeouts defines timeout settings for the ingress controller. + timeouts is optional. + When omitted, this means no opinion and the platform is left to choose reasonable defaults. + properties: + clientTimeout: + description: |- + clientTimeout defines the timeout for client connections. + This is the maximum time to wait for a client to send a request. + When not specified, the platform default is used. + type: string + connectTimeout: + description: |- + connectTimeout defines the timeout for establishing connections to backend servers. + This is the maximum time to wait when establishing a connection to a backend. + When not specified, the platform default is used. + type: string + serverTimeout: + description: |- + serverTimeout defines the timeout for backend server connections. + This is the maximum time to wait for a response from a backend server. + When not specified, the platform default is used. + type: string + type: object + type: object + type: object + status: + description: status holds observed values from the cluster. They may not + be overridden. + properties: + conditions: + description: conditions represent the latest available observations + of the IngressControllerConfig's current state. + items: + description: Condition contains details for one aspect of the current + state of this API Resource. + properties: + lastTransitionTime: + description: |- + lastTransitionTime is the last time the condition transitioned from one status to another. + This should be when the underlying condition changed. If that is not known, then using the time when the API field changed is acceptable. + format: date-time + type: string + message: + description: |- + message is a human readable message indicating details about the transition. + This may be an empty string. + maxLength: 32768 + type: string + observedGeneration: + description: |- + observedGeneration represents the .metadata.generation that the condition was set based upon. + For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date + with respect to the current state of the instance. + format: int64 + minimum: 0 + type: integer + reason: + description: |- + reason contains a programmatic identifier indicating the reason for the condition's last transition. + Producers of specific condition types may define expected values and meanings for this field, + and whether the values are considered a guaranteed API. + The value should be a CamelCase string. + This field may not be empty. + maxLength: 1024 + minLength: 1 + pattern: ^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$ + type: string + status: + description: status of the condition, one of True, False, Unknown. + enum: + - "True" + - "False" + - Unknown + type: string + type: + description: type of condition in CamelCase or in foo.example.com/CamelCase. + maxLength: 316 + pattern: ^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$ + type: string + required: + - lastTransitionTime + - message + - reason + - status + - type + type: object + maxItems: 32 + type: array + x-kubernetes-list-map-keys: + - type + x-kubernetes-list-type: map + type: object + required: + - spec + type: object + served: true + storage: true + subresources: + status: {} diff --git a/config/v1alpha1/zz_generated.swagger_doc_generated.go b/config/v1alpha1/zz_generated.swagger_doc_generated.go index 6ba6ad11f44..5417c3da054 100644 --- a/config/v1alpha1/zz_generated.swagger_doc_generated.go +++ b/config/v1alpha1/zz_generated.swagger_doc_generated.go @@ -366,6 +366,114 @@ func (PublicKey) SwaggerDoc() map[string]string { return map_PublicKey } +var map_DefaultIngressControllerConfig = map[string]string{ + "": "DefaultIngressControllerConfig represents the configuration for the default ingress controller deployment. defaultIngressControllerConfig provides configuration options for the default ingress controller instance that runs in the `openshift-ingress` namespace. Use this configuration to control how the default ingress controller is deployed, how it logs, and how its pods are scheduled.", + "logLevel": "logLevel defines the verbosity of logs emitted by the ingress controller. This field allows users to control the amount and severity of logs generated, which can be useful for debugging issues or reducing noise in production environments. Allowed values are Error, Warn, Info, and Debug. When set to Error, only errors will be logged. When set to Warn, both warnings and errors will be logged. When set to Info, general information, warnings, and errors will all be logged. When set to Debug, detailed debugging information will be logged. When omitted, this means no opinion and the platform is left to choose a reasonable default, that is subject to change over time. The current default value is `Info`.", + "nodeSelector": "nodeSelector defines the nodes on which the ingress controller Pods are scheduled nodeSelector is optional.\n\nWhen omitted, this means the user has no opinion and the platform is left to choose reasonable defaults. These defaults are subject to change over time. The current default value is `kubernetes.io/os: linux`.", + "resources": "resources defines the compute resource requests and limits for the ingress controller container. This includes CPU, memory and HugePages constraints to help control scheduling and resource usage. When not specified, defaults are used by the platform. Requests cannot exceed limits. This field is optional. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ This is a simplified API that maps to Kubernetes ResourceRequirements. The current default values are:\n resources:\n - name: cpu\n request: 100m\n limit: null\n - name: memory\n request: 256Mi\n limit: null\nMaximum length for this list is 10. Minimum length for this list is 1.", + "replicas": "replicas defines the desired number of ingress controller replicas. This field allows users to control the availability and load distribution of the ingress controller. When not specified, defaults are used by the platform based on the cluster topology. The current default behavior is: - SingleReplica topology: 1 replica - HighlyAvailable topology: 2 replicas", + "tolerations": "tolerations defines the tolerations for ingress controller pods. This allows the ingress controller to be scheduled on nodes with matching taints. When not specified, no tolerations are applied.", + "affinity": "affinity defines the affinity rules for ingress controller pods. This allows users to control pod placement for high availability or performance optimization. When not specified, no affinity rules are applied.", +} + +func (DefaultIngressControllerConfig) SwaggerDoc() map[string]string { + return map_DefaultIngressControllerConfig +} + +var map_IngressControllerBufferSizes = map[string]string{ + "": "IngressControllerBufferSizes defines buffer size settings for ingress controllers.", + "requestHeaderBufferSize": "requestHeaderBufferSize defines the size of the buffer for request headers. This affects the maximum size of request headers that can be processed. When not specified, the platform default is used.", + "responseBufferSize": "responseBufferSize defines the size of the buffer for responses. This affects buffering behavior for responses from backend servers. When not specified, the platform default is used.", +} + +func (IngressControllerBufferSizes) SwaggerDoc() map[string]string { + return map_IngressControllerBufferSizes +} + +var map_IngressControllerConfig = map[string]string{ + "": "IngressControllerConfig is the Custom Resource object which holds the current configuration of Ingress Controllers. This provides a cluster-level configuration API for managing ingress controller operational settings.\n\nCompatibility level 4: No compatibility is provided, the API can change at any point for any reason. These capabilities should not be used by applications needing long term support.", + "metadata": "metadata is the standard object metadata.", + "spec": "spec holds user configuration for the Ingress Controllers", + "status": "status holds observed values from the cluster. They may not be overridden.", +} + +func (IngressControllerConfig) SwaggerDoc() map[string]string { + return map_IngressControllerConfig +} + +var map_IngressControllerConfigList = map[string]string{ + "": "Compatibility level 4: No compatibility is provided, the API can change at any point for any reason. These capabilities should not be used by applications needing long term support.", + "metadata": "metadata is the standard list metadata.", + "items": "items is a list of IngressControllerConfig", +} + +func (IngressControllerConfigList) SwaggerDoc() map[string]string { + return map_IngressControllerConfigList +} + +var map_IngressControllerConfigSpec = map[string]string{ + "": "IngressControllerConfigSpec defines the desired state of Ingress Controller operational configuration", + "defaultControllerConfig": "defaultControllerConfig allows users to configure how the default ingress controller instance should be deployed and managed. defaultControllerConfig is optional. When omitted, this means no opinion and the platform is left to choose a reasonable default, that is subject to change over time.", + "performanceTuning": "performanceTuning provides configuration options for performance optimization of ingress controllers. performanceTuning is optional. When omitted, this means no opinion and the platform is left to choose a reasonable default, that is subject to change over time.", +} + +func (IngressControllerConfigSpec) SwaggerDoc() map[string]string { + return map_IngressControllerConfigSpec +} + +var map_IngressControllerConfigStatus = map[string]string{ + "": "IngressControllerConfigStatus defines the observed state of IngressControllerConfig", + "conditions": "conditions represent the latest available observations of the IngressControllerConfig's current state.", +} + +func (IngressControllerConfigStatus) SwaggerDoc() map[string]string { + return map_IngressControllerConfigStatus +} + +var map_IngressControllerConnectionLimits = map[string]string{ + "": "IngressControllerConnectionLimits defines connection-related limits for ingress controllers.", + "maxConnections": "maxConnections defines the maximum number of concurrent connections. This helps prevent resource exhaustion under high load. When not specified, the platform default is used.", + "maxConnectionsPerBackend": "maxConnectionsPerBackend defines the maximum number of connections per backend server. This helps distribute load evenly across backend servers. When not specified, the platform default is used.", + "maxRequestsPerConnection": "maxRequestsPerConnection defines the maximum number of requests per connection. This controls connection reuse behavior. When not specified, the platform default is used.", +} + +func (IngressControllerConnectionLimits) SwaggerDoc() map[string]string { + return map_IngressControllerConnectionLimits +} + +var map_IngressControllerContainerResource = map[string]string{ + "": "IngressControllerContainerResource defines a single resource requirement for an ingress controller container.", + "name": "name of the resource (e.g. \"cpu\", \"memory\", \"hugepages-2Mi\"). This field is required. name must consist only of alphanumeric characters, `-`, `_` and `.` and must start and end with an alphanumeric character.", + "request": "request is the minimum amount of the resource required (e.g. \"2Mi\", \"1Gi\"). This field is optional. When limit is specified, request cannot be greater than limit.", + "limit": "limit is the maximum amount of the resource allowed (e.g. \"2Mi\", \"1Gi\"). This field is optional. When request is specified, limit cannot be less than request. The value must be greater than 0 when specified.", +} + +func (IngressControllerContainerResource) SwaggerDoc() map[string]string { + return map_IngressControllerContainerResource +} + +var map_IngressControllerPerformanceTuning = map[string]string{ + "": "IngressControllerPerformanceTuning provides configuration options for performance optimization of ingress controllers. Use this configuration to control connection limits, timeouts, and other performance-related settings.", + "connectionLimits": "connectionLimits defines limits on connections handled by the ingress controller. connectionLimits is optional. When omitted, this means no opinion and the platform is left to choose reasonable defaults.", + "timeouts": "timeouts defines timeout settings for the ingress controller. timeouts is optional. When omitted, this means no opinion and the platform is left to choose reasonable defaults.", + "bufferSizes": "bufferSizes defines buffer size settings for the ingress controller. bufferSizes is optional. When omitted, this means no opinion and the platform is left to choose reasonable defaults.", +} + +func (IngressControllerPerformanceTuning) SwaggerDoc() map[string]string { + return map_IngressControllerPerformanceTuning +} + +var map_IngressControllerTimeouts = map[string]string{ + "": "IngressControllerTimeouts defines timeout settings for ingress controllers.", + "clientTimeout": "clientTimeout defines the timeout for client connections. This is the maximum time to wait for a client to send a request. When not specified, the platform default is used.", + "serverTimeout": "serverTimeout defines the timeout for backend server connections. This is the maximum time to wait for a response from a backend server. When not specified, the platform default is used.", + "connectTimeout": "connectTimeout defines the timeout for establishing connections to backend servers. This is the maximum time to wait when establishing a connection to a backend. When not specified, the platform default is used.", +} + +func (IngressControllerTimeouts) SwaggerDoc() map[string]string { + return map_IngressControllerTimeouts +} + var map_GatherConfig = map[string]string{ "": "gatherConfig provides data gathering configuration options.", "dataPolicy": "dataPolicy allows user to enable additional global obfuscation of the IP addresses and base domain in the Insights archive data. Valid values are \"None\" and \"ObfuscateNetworking\". When set to None the data is not obfuscated. When set to ObfuscateNetworking the IP addresses and the cluster domain name are obfuscated. When omitted, this means no opinion and the platform is left to choose a reasonable default, which is subject to change over time.", diff --git a/features/features.go b/features/features.go index 231bad62b67..9598912bb8e 100644 --- a/features/features.go +++ b/features/features.go @@ -589,6 +589,14 @@ var ( enableIn(configv1.DevPreviewNoUpgrade, configv1.TechPreviewNoUpgrade). mustRegister() + FeatureGateIngressControllerConfig = newFeatureGate("IngressControllerConfig"). + reportProblemsToJiraComponent("Routing"). + contactPerson("tbd"). + productScope(ocpSpecific). + enhancementPR(legacyFeatureGateWithoutEnhancement). + enableIn(configv1.DevPreviewNoUpgrade, configv1.TechPreviewNoUpgrade). + mustRegister() + FeatureGateMultiArchInstallAzure = newFeatureGate("MultiArchInstallAzure"). reportProblemsToJiraComponent("Installer"). contactPerson("r4f4"). diff --git a/openapi/generated_openapi/zz_generated.openapi.go b/openapi/generated_openapi/zz_generated.openapi.go index 77124efe23c..bcae21c427e 100644 --- a/openapi/generated_openapi/zz_generated.openapi.go +++ b/openapi/generated_openapi/zz_generated.openapi.go @@ -438,6 +438,7 @@ func GetOpenAPIDefinitions(ref common.ReferenceCallback) map[string]common.OpenA "github.com/openshift/api/config/v1alpha1.ClusterMonitoringSpec": schema_openshift_api_config_v1alpha1_ClusterMonitoringSpec(ref), "github.com/openshift/api/config/v1alpha1.ClusterMonitoringStatus": schema_openshift_api_config_v1alpha1_ClusterMonitoringStatus(ref), "github.com/openshift/api/config/v1alpha1.ContainerResource": schema_openshift_api_config_v1alpha1_ContainerResource(ref), + "github.com/openshift/api/config/v1alpha1.DefaultIngressControllerConfig": schema_openshift_api_config_v1alpha1_DefaultIngressControllerConfig(ref), "github.com/openshift/api/config/v1alpha1.EtcdBackupSpec": schema_openshift_api_config_v1alpha1_EtcdBackupSpec(ref), "github.com/openshift/api/config/v1alpha1.FulcioCAWithRekor": schema_openshift_api_config_v1alpha1_FulcioCAWithRekor(ref), "github.com/openshift/api/config/v1alpha1.GatherConfig": schema_openshift_api_config_v1alpha1_GatherConfig(ref), @@ -445,6 +446,15 @@ func GetOpenAPIDefinitions(ref common.ReferenceCallback) map[string]common.OpenA "github.com/openshift/api/config/v1alpha1.ImagePolicyList": schema_openshift_api_config_v1alpha1_ImagePolicyList(ref), "github.com/openshift/api/config/v1alpha1.ImagePolicySpec": schema_openshift_api_config_v1alpha1_ImagePolicySpec(ref), "github.com/openshift/api/config/v1alpha1.ImagePolicyStatus": schema_openshift_api_config_v1alpha1_ImagePolicyStatus(ref), + "github.com/openshift/api/config/v1alpha1.IngressControllerBufferSizes": schema_openshift_api_config_v1alpha1_IngressControllerBufferSizes(ref), + "github.com/openshift/api/config/v1alpha1.IngressControllerConfig": schema_openshift_api_config_v1alpha1_IngressControllerConfig(ref), + "github.com/openshift/api/config/v1alpha1.IngressControllerConfigList": schema_openshift_api_config_v1alpha1_IngressControllerConfigList(ref), + "github.com/openshift/api/config/v1alpha1.IngressControllerConfigSpec": schema_openshift_api_config_v1alpha1_IngressControllerConfigSpec(ref), + "github.com/openshift/api/config/v1alpha1.IngressControllerConfigStatus": schema_openshift_api_config_v1alpha1_IngressControllerConfigStatus(ref), + "github.com/openshift/api/config/v1alpha1.IngressControllerConnectionLimits": schema_openshift_api_config_v1alpha1_IngressControllerConnectionLimits(ref), + "github.com/openshift/api/config/v1alpha1.IngressControllerContainerResource": schema_openshift_api_config_v1alpha1_IngressControllerContainerResource(ref), + "github.com/openshift/api/config/v1alpha1.IngressControllerPerformanceTuning": schema_openshift_api_config_v1alpha1_IngressControllerPerformanceTuning(ref), + "github.com/openshift/api/config/v1alpha1.IngressControllerTimeouts": schema_openshift_api_config_v1alpha1_IngressControllerTimeouts(ref), "github.com/openshift/api/config/v1alpha1.InsightsDataGather": schema_openshift_api_config_v1alpha1_InsightsDataGather(ref), "github.com/openshift/api/config/v1alpha1.InsightsDataGatherList": schema_openshift_api_config_v1alpha1_InsightsDataGatherList(ref), "github.com/openshift/api/config/v1alpha1.InsightsDataGatherSpec": schema_openshift_api_config_v1alpha1_InsightsDataGatherSpec(ref), @@ -21863,6 +21873,98 @@ func schema_openshift_api_config_v1alpha1_ContainerResource(ref common.Reference } } +func schema_openshift_api_config_v1alpha1_DefaultIngressControllerConfig(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "DefaultIngressControllerConfig represents the configuration for the default ingress controller deployment. defaultIngressControllerConfig provides configuration options for the default ingress controller instance that runs in the `openshift-ingress` namespace. Use this configuration to control how the default ingress controller is deployed, how it logs, and how its pods are scheduled.", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "logLevel": { + SchemaProps: spec.SchemaProps{ + Description: "logLevel defines the verbosity of logs emitted by the ingress controller. This field allows users to control the amount and severity of logs generated, which can be useful for debugging issues or reducing noise in production environments. Allowed values are Error, Warn, Info, and Debug. When set to Error, only errors will be logged. When set to Warn, both warnings and errors will be logged. When set to Info, general information, warnings, and errors will all be logged. When set to Debug, detailed debugging information will be logged. When omitted, this means no opinion and the platform is left to choose a reasonable default, that is subject to change over time. The current default value is `Info`.", + Type: []string{"string"}, + Format: "", + }, + }, + "nodeSelector": { + SchemaProps: spec.SchemaProps{ + Description: "nodeSelector defines the nodes on which the ingress controller Pods are scheduled nodeSelector is optional.\n\nWhen omitted, this means the user has no opinion and the platform is left to choose reasonable defaults. These defaults are subject to change over time. The current default value is `kubernetes.io/os: linux`.", + Type: []string{"object"}, + AdditionalProperties: &spec.SchemaOrBool{ + Allows: true, + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + "resources": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-list-map-keys": []interface{}{ + "name", + }, + "x-kubernetes-list-type": "map", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "resources defines the compute resource requests and limits for the ingress controller container. This includes CPU, memory and HugePages constraints to help control scheduling and resource usage. When not specified, defaults are used by the platform. Requests cannot exceed limits. This field is optional. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ This is a simplified API that maps to Kubernetes ResourceRequirements. The current default values are:\n resources:\n - name: cpu\n request: 100m\n limit: null\n - name: memory\n request: 256Mi\n limit: null\nMaximum length for this list is 10. Minimum length for this list is 1.", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/openshift/api/config/v1alpha1.IngressControllerContainerResource"), + }, + }, + }, + }, + }, + "replicas": { + SchemaProps: spec.SchemaProps{ + Description: "replicas defines the desired number of ingress controller replicas. This field allows users to control the availability and load distribution of the ingress controller. When not specified, defaults are used by the platform based on the cluster topology. The current default behavior is: - SingleReplica topology: 1 replica - HighlyAvailable topology: 2 replicas", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "tolerations": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-list-type": "atomic", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "tolerations defines the tolerations for ingress controller pods. This allows the ingress controller to be scheduled on nodes with matching taints. When not specified, no tolerations are applied.", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("k8s.io/api/core/v1.Toleration"), + }, + }, + }, + }, + }, + "affinity": { + SchemaProps: spec.SchemaProps{ + Description: "affinity defines the affinity rules for ingress controller pods. This allows users to control pod placement for high availability or performance optimization. When not specified, no affinity rules are applied.", + Ref: ref("k8s.io/api/core/v1.Affinity"), + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/openshift/api/config/v1alpha1.IngressControllerContainerResource", "k8s.io/api/core/v1.Affinity", "k8s.io/api/core/v1.Toleration"}, + } +} + func schema_openshift_api_config_v1alpha1_EtcdBackupSpec(ref common.ReferenceCallback) common.OpenAPIDefinition { return common.OpenAPIDefinition{ Schema: spec.Schema{ @@ -22169,6 +22271,334 @@ func schema_openshift_api_config_v1alpha1_ImagePolicyStatus(ref common.Reference } } +func schema_openshift_api_config_v1alpha1_IngressControllerBufferSizes(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "IngressControllerBufferSizes defines buffer size settings for ingress controllers.", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "requestHeaderBufferSize": { + SchemaProps: spec.SchemaProps{ + Description: "requestHeaderBufferSize defines the size of the buffer for request headers. This affects the maximum size of request headers that can be processed. When not specified, the platform default is used.", + Ref: ref("k8s.io/apimachinery/pkg/api/resource.Quantity"), + }, + }, + "responseBufferSize": { + SchemaProps: spec.SchemaProps{ + Description: "responseBufferSize defines the size of the buffer for responses. This affects buffering behavior for responses from backend servers. When not specified, the platform default is used.", + Ref: ref("k8s.io/apimachinery/pkg/api/resource.Quantity"), + }, + }, + }, + }, + }, + Dependencies: []string{ + "k8s.io/apimachinery/pkg/api/resource.Quantity"}, + } +} + +func schema_openshift_api_config_v1alpha1_IngressControllerConfig(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "IngressControllerConfig is the Custom Resource object which holds the current configuration of Ingress Controllers. This provides a cluster-level configuration API for managing ingress controller operational settings.\n\nCompatibility level 4: No compatibility is provided, the API can change at any point for any reason. These capabilities should not be used by applications needing long term support.", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "kind": { + SchemaProps: spec.SchemaProps{ + 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{"string"}, + Format: "", + }, + }, + "apiVersion": { + SchemaProps: spec.SchemaProps{ + 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{"string"}, + Format: "", + }, + }, + "metadata": { + SchemaProps: spec.SchemaProps{ + Description: "metadata is the standard object metadata.", + Default: map[string]interface{}{}, + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.ObjectMeta"), + }, + }, + "spec": { + SchemaProps: spec.SchemaProps{ + Description: "spec holds user configuration for the Ingress Controllers", + Default: map[string]interface{}{}, + Ref: ref("github.com/openshift/api/config/v1alpha1.IngressControllerConfigSpec"), + }, + }, + "status": { + SchemaProps: spec.SchemaProps{ + Description: "status holds observed values from the cluster. They may not be overridden.", + Ref: ref("github.com/openshift/api/config/v1alpha1.IngressControllerConfigStatus"), + }, + }, + }, + Required: []string{"spec"}, + }, + }, + Dependencies: []string{ + "github.com/openshift/api/config/v1alpha1.IngressControllerConfigSpec", "github.com/openshift/api/config/v1alpha1.IngressControllerConfigStatus", "k8s.io/apimachinery/pkg/apis/meta/v1.ObjectMeta"}, + } +} + +func schema_openshift_api_config_v1alpha1_IngressControllerConfigList(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "Compatibility level 4: No compatibility is provided, the API can change at any point for any reason. These capabilities should not be used by applications needing long term support.", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "kind": { + SchemaProps: spec.SchemaProps{ + 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{"string"}, + Format: "", + }, + }, + "apiVersion": { + SchemaProps: spec.SchemaProps{ + 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{"string"}, + Format: "", + }, + }, + "metadata": { + SchemaProps: spec.SchemaProps{ + Description: "metadata is the standard list metadata.", + Default: map[string]interface{}{}, + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.ListMeta"), + }, + }, + "items": { + SchemaProps: spec.SchemaProps{ + Description: "items is a list of IngressControllerConfig", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/openshift/api/config/v1alpha1.IngressControllerConfig"), + }, + }, + }, + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/openshift/api/config/v1alpha1.IngressControllerConfig", "k8s.io/apimachinery/pkg/apis/meta/v1.ListMeta"}, + } +} + +func schema_openshift_api_config_v1alpha1_IngressControllerConfigSpec(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "IngressControllerConfigSpec defines the desired state of Ingress Controller operational configuration", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "defaultControllerConfig": { + SchemaProps: spec.SchemaProps{ + Description: "defaultControllerConfig allows users to configure how the default ingress controller instance should be deployed and managed. defaultControllerConfig is optional. When omitted, this means no opinion and the platform is left to choose a reasonable default, that is subject to change over time.", + Default: map[string]interface{}{}, + Ref: ref("github.com/openshift/api/config/v1alpha1.DefaultIngressControllerConfig"), + }, + }, + "performanceTuning": { + SchemaProps: spec.SchemaProps{ + Description: "performanceTuning provides configuration options for performance optimization of ingress controllers. performanceTuning is optional. When omitted, this means no opinion and the platform is left to choose a reasonable default, that is subject to change over time.", + Default: map[string]interface{}{}, + Ref: ref("github.com/openshift/api/config/v1alpha1.IngressControllerPerformanceTuning"), + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/openshift/api/config/v1alpha1.DefaultIngressControllerConfig", "github.com/openshift/api/config/v1alpha1.IngressControllerPerformanceTuning"}, + } +} + +func schema_openshift_api_config_v1alpha1_IngressControllerConfigStatus(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "IngressControllerConfigStatus defines the observed state of IngressControllerConfig", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "conditions": { + VendorExtensible: spec.VendorExtensible{ + Extensions: spec.Extensions{ + "x-kubernetes-list-map-keys": []interface{}{ + "type", + }, + "x-kubernetes-list-type": "map", + }, + }, + SchemaProps: spec.SchemaProps{ + Description: "conditions represent the latest available observations of the IngressControllerConfig's current state.", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.Condition"), + }, + }, + }, + }, + }, + }, + }, + }, + Dependencies: []string{ + "k8s.io/apimachinery/pkg/apis/meta/v1.Condition"}, + } +} + +func schema_openshift_api_config_v1alpha1_IngressControllerConnectionLimits(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "IngressControllerConnectionLimits defines connection-related limits for ingress controllers.", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "maxConnections": { + SchemaProps: spec.SchemaProps{ + Description: "maxConnections defines the maximum number of concurrent connections. This helps prevent resource exhaustion under high load. When not specified, the platform default is used.", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "maxConnectionsPerBackend": { + SchemaProps: spec.SchemaProps{ + Description: "maxConnectionsPerBackend defines the maximum number of connections per backend server. This helps distribute load evenly across backend servers. When not specified, the platform default is used.", + Type: []string{"integer"}, + Format: "int32", + }, + }, + "maxRequestsPerConnection": { + SchemaProps: spec.SchemaProps{ + Description: "maxRequestsPerConnection defines the maximum number of requests per connection. This controls connection reuse behavior. When not specified, the platform default is used.", + Type: []string{"integer"}, + Format: "int32", + }, + }, + }, + }, + }, + } +} + +func schema_openshift_api_config_v1alpha1_IngressControllerContainerResource(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "IngressControllerContainerResource defines a single resource requirement for an ingress controller container.", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "name": { + SchemaProps: spec.SchemaProps{ + Description: "name of the resource (e.g. \"cpu\", \"memory\", \"hugepages-2Mi\"). This field is required. name must consist only of alphanumeric characters, `-`, `_` and `.` and must start and end with an alphanumeric character.", + Type: []string{"string"}, + Format: "", + }, + }, + "request": { + SchemaProps: spec.SchemaProps{ + Description: "request is the minimum amount of the resource required (e.g. \"2Mi\", \"1Gi\"). This field is optional. When limit is specified, request cannot be greater than limit.", + Ref: ref("k8s.io/apimachinery/pkg/api/resource.Quantity"), + }, + }, + "limit": { + SchemaProps: spec.SchemaProps{ + Description: "limit is the maximum amount of the resource allowed (e.g. \"2Mi\", \"1Gi\"). This field is optional. When request is specified, limit cannot be less than request. The value must be greater than 0 when specified.", + Ref: ref("k8s.io/apimachinery/pkg/api/resource.Quantity"), + }, + }, + }, + Required: []string{"name"}, + }, + }, + Dependencies: []string{ + "k8s.io/apimachinery/pkg/api/resource.Quantity"}, + } +} + +func schema_openshift_api_config_v1alpha1_IngressControllerPerformanceTuning(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "IngressControllerPerformanceTuning provides configuration options for performance optimization of ingress controllers. Use this configuration to control connection limits, timeouts, and other performance-related settings.", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "connectionLimits": { + SchemaProps: spec.SchemaProps{ + Description: "connectionLimits defines limits on connections handled by the ingress controller. connectionLimits is optional. When omitted, this means no opinion and the platform is left to choose reasonable defaults.", + Ref: ref("github.com/openshift/api/config/v1alpha1.IngressControllerConnectionLimits"), + }, + }, + "timeouts": { + SchemaProps: spec.SchemaProps{ + Description: "timeouts defines timeout settings for the ingress controller. timeouts is optional. When omitted, this means no opinion and the platform is left to choose reasonable defaults.", + Ref: ref("github.com/openshift/api/config/v1alpha1.IngressControllerTimeouts"), + }, + }, + "bufferSizes": { + SchemaProps: spec.SchemaProps{ + Description: "bufferSizes defines buffer size settings for the ingress controller. bufferSizes is optional. When omitted, this means no opinion and the platform is left to choose reasonable defaults.", + Ref: ref("github.com/openshift/api/config/v1alpha1.IngressControllerBufferSizes"), + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/openshift/api/config/v1alpha1.IngressControllerBufferSizes", "github.com/openshift/api/config/v1alpha1.IngressControllerConnectionLimits", "github.com/openshift/api/config/v1alpha1.IngressControllerTimeouts"}, + } +} + +func schema_openshift_api_config_v1alpha1_IngressControllerTimeouts(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "IngressControllerTimeouts defines timeout settings for ingress controllers.", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "clientTimeout": { + SchemaProps: spec.SchemaProps{ + Description: "clientTimeout defines the timeout for client connections. This is the maximum time to wait for a client to send a request. When not specified, the platform default is used.", + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.Duration"), + }, + }, + "serverTimeout": { + SchemaProps: spec.SchemaProps{ + Description: "serverTimeout defines the timeout for backend server connections. This is the maximum time to wait for a response from a backend server. When not specified, the platform default is used.", + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.Duration"), + }, + }, + "connectTimeout": { + SchemaProps: spec.SchemaProps{ + Description: "connectTimeout defines the timeout for establishing connections to backend servers. This is the maximum time to wait when establishing a connection to a backend. When not specified, the platform default is used.", + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.Duration"), + }, + }, + }, + }, + }, + Dependencies: []string{ + "k8s.io/apimachinery/pkg/apis/meta/v1.Duration"}, + } +} + func schema_openshift_api_config_v1alpha1_InsightsDataGather(ref common.ReferenceCallback) common.OpenAPIDefinition { return common.OpenAPIDefinition{ Schema: spec.Schema{ diff --git a/openapi/openapi.json b/openapi/openapi.json index 169d0ceac1c..198bc8cdbf9 100644 --- a/openapi/openapi.json +++ b/openapi/openapi.json @@ -11911,6 +11911,54 @@ } } }, + "com.github.openshift.api.config.v1alpha1.DefaultIngressControllerConfig": { + "description": "DefaultIngressControllerConfig represents the configuration for the default ingress controller deployment. defaultIngressControllerConfig provides configuration options for the default ingress controller instance that runs in the `openshift-ingress` namespace. Use this configuration to control how the default ingress controller is deployed, how it logs, and how its pods are scheduled.", + "type": "object", + "properties": { + "affinity": { + "description": "affinity defines the affinity rules for ingress controller pods. This allows users to control pod placement for high availability or performance optimization. When not specified, no affinity rules are applied.", + "$ref": "#/definitions/io.k8s.api.core.v1.Affinity" + }, + "logLevel": { + "description": "logLevel defines the verbosity of logs emitted by the ingress controller. This field allows users to control the amount and severity of logs generated, which can be useful for debugging issues or reducing noise in production environments. Allowed values are Error, Warn, Info, and Debug. When set to Error, only errors will be logged. When set to Warn, both warnings and errors will be logged. When set to Info, general information, warnings, and errors will all be logged. When set to Debug, detailed debugging information will be logged. When omitted, this means no opinion and the platform is left to choose a reasonable default, that is subject to change over time. The current default value is `Info`.", + "type": "string" + }, + "nodeSelector": { + "description": "nodeSelector defines the nodes on which the ingress controller Pods are scheduled nodeSelector is optional.\n\nWhen omitted, this means the user has no opinion and the platform is left to choose reasonable defaults. These defaults are subject to change over time. The current default value is `kubernetes.io/os: linux`.", + "type": "object", + "additionalProperties": { + "type": "string", + "default": "" + } + }, + "replicas": { + "description": "replicas defines the desired number of ingress controller replicas. This field allows users to control the availability and load distribution of the ingress controller. When not specified, defaults are used by the platform based on the cluster topology. The current default behavior is: - SingleReplica topology: 1 replica - HighlyAvailable topology: 2 replicas", + "type": "integer", + "format": "int32" + }, + "resources": { + "description": "resources defines the compute resource requests and limits for the ingress controller container. This includes CPU, memory and HugePages constraints to help control scheduling and resource usage. When not specified, defaults are used by the platform. Requests cannot exceed limits. This field is optional. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ This is a simplified API that maps to Kubernetes ResourceRequirements. The current default values are:\n resources:\n - name: cpu\n request: 100m\n limit: null\n - name: memory\n request: 256Mi\n limit: null\nMaximum length for this list is 10. Minimum length for this list is 1.", + "type": "array", + "items": { + "default": {}, + "$ref": "#/definitions/com.github.openshift.api.config.v1alpha1.IngressControllerContainerResource" + }, + "x-kubernetes-list-map-keys": [ + "name" + ], + "x-kubernetes-list-type": "map" + }, + "tolerations": { + "description": "tolerations defines the tolerations for ingress controller pods. This allows the ingress controller to be scheduled on nodes with matching taints. When not specified, no tolerations are applied.", + "type": "array", + "items": { + "default": {}, + "$ref": "#/definitions/io.k8s.api.core.v1.Toleration" + }, + "x-kubernetes-list-type": "atomic" + } + } + }, "com.github.openshift.api.config.v1alpha1.EtcdBackupSpec": { "description": "EtcdBackupSpec provides configuration for automated etcd backups to the cluster-etcd-operator", "type": "object", @@ -12088,6 +12136,190 @@ } } }, + "com.github.openshift.api.config.v1alpha1.IngressControllerBufferSizes": { + "description": "IngressControllerBufferSizes defines buffer size settings for ingress controllers.", + "type": "object", + "properties": { + "requestHeaderBufferSize": { + "description": "requestHeaderBufferSize defines the size of the buffer for request headers. This affects the maximum size of request headers that can be processed. When not specified, the platform default is used.", + "$ref": "#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "responseBufferSize": { + "description": "responseBufferSize defines the size of the buffer for responses. This affects buffering behavior for responses from backend servers. When not specified, the platform default is used.", + "$ref": "#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity" + } + } + }, + "com.github.openshift.api.config.v1alpha1.IngressControllerConfig": { + "description": "IngressControllerConfig is the Custom Resource object which holds the current configuration of Ingress Controllers. This provides a cluster-level configuration API for managing ingress controller operational settings.\n\nCompatibility level 4: No compatibility is provided, the API can change at any point for any reason. These capabilities should not be used by applications needing long term support.", + "type": "object", + "required": [ + "spec" + ], + "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": { + "description": "metadata is the standard object metadata.", + "default": {}, + "$ref": "#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta" + }, + "spec": { + "description": "spec holds user configuration for the Ingress Controllers", + "default": {}, + "$ref": "#/definitions/com.github.openshift.api.config.v1alpha1.IngressControllerConfigSpec" + }, + "status": { + "description": "status holds observed values from the cluster. They may not be overridden.", + "$ref": "#/definitions/com.github.openshift.api.config.v1alpha1.IngressControllerConfigStatus" + } + } + }, + "com.github.openshift.api.config.v1alpha1.IngressControllerConfigList": { + "description": "Compatibility level 4: No compatibility is provided, the API can change at any point for any reason. These capabilities should not be used by applications needing long term support.", + "type": "object", + "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" + }, + "items": { + "description": "items is a list of IngressControllerConfig", + "type": "array", + "items": { + "default": {}, + "$ref": "#/definitions/com.github.openshift.api.config.v1alpha1.IngressControllerConfig" + } + }, + "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": { + "description": "metadata is the standard list metadata.", + "default": {}, + "$ref": "#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta" + } + } + }, + "com.github.openshift.api.config.v1alpha1.IngressControllerConfigSpec": { + "description": "IngressControllerConfigSpec defines the desired state of Ingress Controller operational configuration", + "type": "object", + "properties": { + "defaultControllerConfig": { + "description": "defaultControllerConfig allows users to configure how the default ingress controller instance should be deployed and managed. defaultControllerConfig is optional. When omitted, this means no opinion and the platform is left to choose a reasonable default, that is subject to change over time.", + "default": {}, + "$ref": "#/definitions/com.github.openshift.api.config.v1alpha1.DefaultIngressControllerConfig" + }, + "performanceTuning": { + "description": "performanceTuning provides configuration options for performance optimization of ingress controllers. performanceTuning is optional. When omitted, this means no opinion and the platform is left to choose a reasonable default, that is subject to change over time.", + "default": {}, + "$ref": "#/definitions/com.github.openshift.api.config.v1alpha1.IngressControllerPerformanceTuning" + } + } + }, + "com.github.openshift.api.config.v1alpha1.IngressControllerConfigStatus": { + "description": "IngressControllerConfigStatus defines the observed state of IngressControllerConfig", + "type": "object", + "properties": { + "conditions": { + "description": "conditions represent the latest available observations of the IngressControllerConfig's current state.", + "type": "array", + "items": { + "default": {}, + "$ref": "#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Condition" + }, + "x-kubernetes-list-map-keys": [ + "type" + ], + "x-kubernetes-list-type": "map" + } + } + }, + "com.github.openshift.api.config.v1alpha1.IngressControllerConnectionLimits": { + "description": "IngressControllerConnectionLimits defines connection-related limits for ingress controllers.", + "type": "object", + "properties": { + "maxConnections": { + "description": "maxConnections defines the maximum number of concurrent connections. This helps prevent resource exhaustion under high load. When not specified, the platform default is used.", + "type": "integer", + "format": "int32" + }, + "maxConnectionsPerBackend": { + "description": "maxConnectionsPerBackend defines the maximum number of connections per backend server. This helps distribute load evenly across backend servers. When not specified, the platform default is used.", + "type": "integer", + "format": "int32" + }, + "maxRequestsPerConnection": { + "description": "maxRequestsPerConnection defines the maximum number of requests per connection. This controls connection reuse behavior. When not specified, the platform default is used.", + "type": "integer", + "format": "int32" + } + } + }, + "com.github.openshift.api.config.v1alpha1.IngressControllerContainerResource": { + "description": "IngressControllerContainerResource defines a single resource requirement for an ingress controller container.", + "type": "object", + "required": [ + "name" + ], + "properties": { + "limit": { + "description": "limit is the maximum amount of the resource allowed (e.g. \"2Mi\", \"1Gi\"). This field is optional. When request is specified, limit cannot be less than request. The value must be greater than 0 when specified.", + "$ref": "#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity" + }, + "name": { + "description": "name of the resource (e.g. \"cpu\", \"memory\", \"hugepages-2Mi\"). This field is required. name must consist only of alphanumeric characters, `-`, `_` and `.` and must start and end with an alphanumeric character.", + "type": "string" + }, + "request": { + "description": "request is the minimum amount of the resource required (e.g. \"2Mi\", \"1Gi\"). This field is optional. When limit is specified, request cannot be greater than limit.", + "$ref": "#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity" + } + } + }, + "com.github.openshift.api.config.v1alpha1.IngressControllerPerformanceTuning": { + "description": "IngressControllerPerformanceTuning provides configuration options for performance optimization of ingress controllers. Use this configuration to control connection limits, timeouts, and other performance-related settings.", + "type": "object", + "properties": { + "bufferSizes": { + "description": "bufferSizes defines buffer size settings for the ingress controller. bufferSizes is optional. When omitted, this means no opinion and the platform is left to choose reasonable defaults.", + "$ref": "#/definitions/com.github.openshift.api.config.v1alpha1.IngressControllerBufferSizes" + }, + "connectionLimits": { + "description": "connectionLimits defines limits on connections handled by the ingress controller. connectionLimits is optional. When omitted, this means no opinion and the platform is left to choose reasonable defaults.", + "$ref": "#/definitions/com.github.openshift.api.config.v1alpha1.IngressControllerConnectionLimits" + }, + "timeouts": { + "description": "timeouts defines timeout settings for the ingress controller. timeouts is optional. When omitted, this means no opinion and the platform is left to choose reasonable defaults.", + "$ref": "#/definitions/com.github.openshift.api.config.v1alpha1.IngressControllerTimeouts" + } + } + }, + "com.github.openshift.api.config.v1alpha1.IngressControllerTimeouts": { + "description": "IngressControllerTimeouts defines timeout settings for ingress controllers.", + "type": "object", + "properties": { + "clientTimeout": { + "description": "clientTimeout defines the timeout for client connections. This is the maximum time to wait for a client to send a request. When not specified, the platform default is used.", + "$ref": "#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Duration" + }, + "connectTimeout": { + "description": "connectTimeout defines the timeout for establishing connections to backend servers. This is the maximum time to wait when establishing a connection to a backend. When not specified, the platform default is used.", + "$ref": "#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Duration" + }, + "serverTimeout": { + "description": "serverTimeout defines the timeout for backend server connections. This is the maximum time to wait for a response from a backend server. When not specified, the platform default is used.", + "$ref": "#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Duration" + } + } + }, "com.github.openshift.api.config.v1alpha1.InsightsDataGather": { "description": "InsightsDataGather provides data gather configuration options for the the Insights Operator.\n\nCompatibility level 4: No compatibility is provided, the API can change at any point for any reason. These capabilities should not be used by applications needing long term support.", "type": "object",