OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.
Python
kubernetes operator
ming luo212e64962430
diff --git a/kubernetes/operator/.gitignore b/kubernetes/operator/.gitignorenew file mode 100644index 000000000..b6be09947--- /dev/null+++ b/kubernetes/operator/.gitignore@@ -0,0 +1,6 @@+# Tool binaries downloaded by make deps+bin/++# Build output+cover.out+dist/diff --git a/kubernetes/operator/Makefile b/kubernetes/operator/Makefilenew file mode 100644index 000000000..a45ba6c80--- /dev/null+++ b/kubernetes/operator/Makefile@@ -0,0 +1,181 @@+# OpenRAG Operator Makefile+#+# Go version: managed via gvm. The Makefile auto-selects go1.26.0 when found+# under ~/.gvm/gos/go1.26.0, otherwise falls back to whatever 'go' is in PATH.+#+# Quick start:+# make deps # install controller-gen, kustomize, envtest into ./bin+# make manifests # generate CRD + RBAC YAML under config/+# make generate # regenerate zz_generated.deepcopy.go+# make build # compile the operator binary++# Image to push/pull for the operator container.+IMG ?= ghcr.io/langflow-ai/openrag-operator:latest++# Kubernetes version used by envtest.+ENVTEST_K8S_VERSION = 1.33.0++# Go 1.26.0 via gvm — set PATH and GOROOT so sub-shells pick the right toolchain.+GVM_GO_VERSION ?= go1.26.0+GVM_GO_ROOT := $(HOME)/.gvm/gos/$(GVM_GO_VERSION)+ifneq ($(wildcard $(GVM_GO_ROOT)/bin/go),)+ export GOROOT := $(GVM_GO_ROOT)+ export PATH := $(GVM_GO_ROOT)/bin:$(PATH)+endif++# Resolve GOBIN (respect GOBIN env if set, else fall back to GOPATH/bin).+ifeq (,$(shell go env GOBIN))+GOBIN=$(shell go env GOPATH)/bin+else+GOBIN=$(shell go env GOBIN)+endif++CONTAINER_TOOL ?= docker+SHELL = /usr/bin/env bash -o pipefail+.SHELLFLAGS = -ec++.PHONY: all+all: build++##@ General++.PHONY: help+help: ## Display this help.+ @awk 'BEGIN {FS = ":.*##"; printf "\nUsage:\n make \033[36m<target>\033[0m\n"} /^[a-zA-Z_0-9-]+:.*?##/ { printf " \033[36m%-15s\033[0m %s\n", $$1, $$2 } /^##@/ { printf "\n\033[1m%s\033[0m\n", substr($$0, 5) } ' $(MAKEFILE_LIST)++##@ Development++.PHONY: manifests+manifests: controller-gen ## Generate CRD and RBAC manifests from Go type markers.+ $(CONTROLLER_GEN) rbac:roleName=manager-role crd paths="./..." \+ output:crd:artifacts:config=config/crd/bases \+ output:rbac:artifacts:config=config/rbac++.PHONY: generate+generate: controller-gen ## Regenerate zz_generated.deepcopy.go from type definitions.+ $(CONTROLLER_GEN) object:headerFile="hack/boilerplate.go.txt" paths="./..."++.PHONY: fmt+fmt: ## Run go fmt.+ go fmt ./...++.PHONY: vet+vet: ## Run go vet.+ go vet ./...++.PHONY: tidy+tidy: ## Run go mod tidy.+ go mod tidy++.PHONY: lint+lint: golangci-lint ## Run golangci-lint.+ $(GOLANGCI_LINT) run ./...++.PHONY: test+test: manifests generate fmt vet envtest ## Run unit tests.+ KUBEBUILDER_ASSETS="$(shell $(ENVTEST) use $(ENVTEST_K8S_VERSION) --bin-dir $(LOCALBIN) -p path)" \+ go test $$(go list ./... | grep -v /e2e) -coverprofile cover.out++##@ Build++.PHONY: build+build: manifests generate fmt vet ## Build the operator binary to bin/manager.+ go build -o bin/manager cmd/main.go++.PHONY: run+run: manifests generate fmt vet ## Run the operator locally (uses current kubeconfig).+ go run ./cmd/main.go++.PHONY: docker-build+docker-build: ## Build the operator container image.+ $(CONTAINER_TOOL) build -t $(IMG) .++.PHONY: docker-push+docker-push: ## Push the operator container image.+ $(CONTAINER_TOOL) push $(IMG)++.PHONY: docker-buildx+docker-buildx: ## Build and push multi-arch image via buildx.+ $(CONTAINER_TOOL) buildx build --platform linux/amd64,linux/arm64 --push -t $(IMG) .++##@ Deployment++ifndef ignore-not-found+ ignore-not-found = false+endif++.PHONY: install+install: manifests kustomize ## Install CRDs into the cluster in ~/.kube/config.+ $(KUSTOMIZE) build config/crd | kubectl apply -f -++.PHONY: uninstall+uninstall: manifests kustomize ## Uninstall CRDs from the cluster.+ $(KUSTOMIZE) build config/crd | kubectl delete --ignore-not-found=$(ignore-not-found) -f -++.PHONY: deploy+deploy: manifests kustomize ## Deploy the operator to the cluster.+ cd config/manager && $(KUSTOMIZE) edit set image controller=$(IMG)+ $(KUSTOMIZE) build config/default | kubectl apply -f -++.PHONY: undeploy+undeploy: kustomize ## Remove the operator from the cluster.+ $(KUSTOMIZE) build config/default | kubectl delete --ignore-not-found=$(ignore-not-found) -f -++.PHONY: dist+dist: manifests kustomize ## Build a single-file install manifest to dist/install.yaml.+ mkdir -p dist+ $(KUSTOMIZE) build config/default > dist/install.yaml++##@ Dependencies++LOCALBIN ?= $(shell pwd)/bin+$(LOCALBIN):+ mkdir -p $(LOCALBIN)++KUBECTL ?= kubectl+KUSTOMIZE ?= $(LOCALBIN)/kustomize+CONTROLLER_GEN ?= $(LOCALBIN)/controller-gen+ENVTEST ?= $(LOCALBIN)/setup-envtest+GOLANGCI_LINT ?= $(LOCALBIN)/golangci-lint++KUSTOMIZE_VERSION ?= v5.4.3+CONTROLLER_TOOLS_VERSION ?= v0.16.4+ENVTEST_VERSION ?= release-0.19+GOLANGCI_LINT_VERSION ?= v1.64.6++.PHONY: deps+deps: controller-gen kustomize envtest golangci-lint ## Install all local tool dependencies into ./bin.++.PHONY: kustomize+kustomize: $(KUSTOMIZE) ## Download kustomize locally if necessary.+$(KUSTOMIZE): $(LOCALBIN)+ $(call go-install-tool,$(KUSTOMIZE),sigs.k8s.io/kustomize/kustomize/v5,$(KUSTOMIZE_VERSION))++.PHONY: controller-gen+controller-gen: $(CONTROLLER_GEN) ## Download controller-gen locally if necessary.+$(CONTROLLER_GEN): $(LOCALBIN)+ $(call go-install-tool,$(CONTROLLER_GEN),sigs.k8s.io/controller-tools/cmd/controller-gen,$(CONTROLLER_TOOLS_VERSION))++.PHONY: envtest+envtest: $(ENVTEST) ## Download setup-envtest locally if necessary.+$(ENVTEST): $(LOCALBIN)+ $(call go-install-tool,$(ENVTEST),sigs.k8s.io/controller-runtime/tools/setup-envtest,$(ENVTEST_VERSION))++.PHONY: golangci-lint+golangci-lint: $(GOLANGCI_LINT) ## Download golangci-lint locally if necessary.+$(GOLANGCI_LINT): $(LOCALBIN)+ $(call go-install-tool,$(GOLANGCI_LINT),github.com/golangci/golangci-lint/cmd/golangci-lint,$(GOLANGCI_LINT_VERSION))++# go-install-tool installs a versioned binary into LOCALBIN, caching by version suffix.+# Usage: $(call go-install-tool,<target-path>,<package-url>,<version>)+define go-install-tool+@[ -f "$(1)-$(3)" ] || { \+set -e; \+package=$(2)@$(3) ;\+echo "Downloading $${package}" ;\+rm -f $(1) || true ;\+GOBIN=$(LOCALBIN) go install $${package} ;\+mv $(1) $(1)-$(3) ;\+} ;\+ln -sf $(1)-$(3) $(1)+endefdiff --git a/kubernetes/operator/PROJECT b/kubernetes/operator/PROJECTnew file mode 100644index 000000000..1fafb9457--- /dev/null+++ b/kubernetes/operator/PROJECT@@ -0,0 +1,20 @@+# Code generated by tool. DO NOT EDIT.+# This file is used to track the info used to scaffold your project+# and allow the plugins properly work.+# More info: https://book.kubebuilder.io/reference/project-config.html+domain: openrag.io+layout:+- go.kubebuilder.io/v4+projectName: openrag-operator+repo: github.com/langflow-ai/openrag-operator+resources:+- api:+ crdVersion: v1+ namespaced: true+ controller: true+ domain: openrag.io+ group: openrag+ kind: OpenRAG+ path: github.com/langflow-ai/openrag-operator/api/v1alpha1+ version: v1alpha1+version: "3"diff --git a/kubernetes/operator/README.md b/kubernetes/operator/README.mdnew file mode 100644index 000000000..f41726b2a--- /dev/null+++ b/kubernetes/operator/README.md@@ -0,0 +1,61 @@+# OpenRAG Operator++A Kubernetes operator that manages OpenRAG deployments via a single `OpenRAG` custom resource.+It creates and owns the frontend, backend, and Langflow deployments, services, and service accounts.+External dependencies (OpenSearch, Docling) are referenced by connection config — not deployed by this operator.++## Prerequisites++- Go 1.26.0 (`gvm use go1.26.0`)+- kubectl pointed at a cluster++## Quick start++```bash+make deps # download controller-gen, kustomize, envtest into ./bin+make manifests # regenerate CRD + RBAC YAML (run after editing types)+make generate # regenerate DeepCopy methods (run after editing types)+make build # compile bin/manager+make install # install the CRD into the current cluster+make deploy IMG=ghcr.io/langflow-ai/openrag-operator:latest+```++Apply the sample CR:++```bash+kubectl apply -f config/samples/openrag_v1alpha1_openrag.yaml+kubectl get openrag+```++## CR overview++```yaml+apiVersion: openrag.io/v1alpha1+kind: OpenRAG+metadata:+ name: my-openrag+spec:+ frontend:+ image: langflowai/openrag-frontend:latest+ backend:+ image: langflowai/openrag-backend:latest+ envSecret: my-backend-env # Secret with a ".env" key+ storage:+ enabled: true+ size: 10Gi+ langflow:+ image: langflowai/openrag-langflow:latest+ envSecret: my-langflow-env+ storage:+ enabled: true+ size: 10Gi+ opensearch:+ host: opensearch-coordinating.opensearch.svc.cluster.local+ credentialsSecret: opensearch-credentials # keys: username, password+ # docling: # optional+ # host: docling-serve.docling.svc.cluster.local+ networkPolicy:+ enabled: false+```++See [`config/samples/openrag_v1alpha1_openrag.yaml`](config/samples/openrag_v1alpha1_openrag.yaml) for a full annotated example.diff --git a/kubernetes/operator/api/v1alpha1/groupversion_info.go b/kubernetes/operator/api/v1alpha1/groupversion_info.gonew file mode 100644index 000000000..bd038bd81--- /dev/null+++ b/kubernetes/operator/api/v1alpha1/groupversion_info.go@@ -0,0 +1,15 @@+// Package v1alpha1 contains API Schema definitions for the openrag.io v1alpha1 API group.+// +kubebuilder:object:generate=true+// +groupName=openrag.io+package v1alpha1++import (+ "k8s.io/apimachinery/pkg/runtime/schema"+ "sigs.k8s.io/controller-runtime/pkg/scheme"+)++var (+ GroupVersion = schema.GroupVersion{Group: "openrag.io", Version: "v1alpha1"}+ SchemeBuilder = &scheme.Builder{GroupVersion: GroupVersion}+ AddToScheme = SchemeBuilder.AddToScheme+)diff --git a/kubernetes/operator/api/v1alpha1/openrag_types.go b/kubernetes/operator/api/v1alpha1/openrag_types.gonew file mode 100644index 000000000..02c65d418--- /dev/null+++ b/kubernetes/operator/api/v1alpha1/openrag_types.go@@ -0,0 +1,230 @@+// Run "make manifests" to regenerate CRD manifests after modifying this file.+// Run "make generate" to regenerate DeepCopy methods after modifying this file.+package v1alpha1++import (+ corev1 "k8s.io/api/core/v1"+ "k8s.io/apimachinery/pkg/api/resource"+ metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"+)++// ComponentSpec defines common configuration shared by all three components.+type ComponentSpec struct {+ // Image is the container image (repository:tag).+ // +kubebuilder:validation:Required+ Image string `json:"image"`++ // +optional+ // +kubebuilder:default=IfNotPresent+ ImagePullPolicy corev1.PullPolicy `json:"imagePullPolicy,omitempty"`++ // +optional+ // +kubebuilder:default=1+ // +kubebuilder:validation:Minimum=0+ Replicas *int32 `json:"replicas,omitempty"`++ // +optional+ Resources corev1.ResourceRequirements `json:"resources,omitempty"`++ // Additional environment variables injected into the container.+ // +optional+ Env []corev1.EnvVar `json:"env,omitempty"`++ // +optional+ NodeSelector map[string]string `json:"nodeSelector,omitempty"`++ // +optional+ Tolerations []corev1.Toleration `json:"tolerations,omitempty"`++ // +optional+ Affinity *corev1.Affinity `json:"affinity,omitempty"`+}++// FrontendSpec configures the OpenRAG frontend (Next.js).+type FrontendSpec struct {+ ComponentSpec `json:",inline"`+}++// BackendSpec configures the OpenRAG backend (FastAPI).+type BackendSpec struct {+ ComponentSpec `json:",inline"`++ // EnvSecret is the name of a Secret whose keys are mounted as /app/.env.+ // The secret must contain a single key ".env" with the full dotenv content.+ // +optional+ EnvSecret string `json:"envSecret,omitempty"`++ // JWTSigningKeySecret references the Secret key that holds the JWT signing key.+ // If omitted the operator generates a random key and stores it in a managed Secret.+ // +optional+ JWTSigningKeySecret *corev1.SecretKeySelector `json:"jwtSigningKeySecret,omitempty"`++ // BackendDataStorage configures a PVC mounted at /app/backend-data.+ // +optional+ Storage *PersistenceSpec `json:"storage,omitempty"`+}++// LangflowSpec configures the Langflow instance.+type LangflowSpec struct {+ ComponentSpec `json:",inline"`++ // EnvSecret is the name of a Secret whose single ".env" key is mounted at /app/.env.+ // +optional+ EnvSecret string `json:"envSecret,omitempty"`++ // Storage configures a PVC mounted at /app/data (Langflow SQLite + flows).+ // +optional+ Storage *PersistenceSpec `json:"storage,omitempty"`+}++// PersistenceSpec describes a PVC to be created or reused for a component.+type PersistenceSpec struct {+ // +optional+ // +kubebuilder:default=true+ Enabled bool `json:"enabled,omitempty"`++ // StorageClassName passed to the PVC. Defaults to the cluster default.+ // +optional+ StorageClassName *string `json:"storageClassName,omitempty"`++ // Size of the PVC. Defaults to 10Gi.+ // +optional+ // +kubebuilder:default="10Gi"+ Size resource.Quantity `json:"size,omitempty"`++ // ExistingClaim reuses a pre-existing PVC instead of creating one.+ // +optional+ ExistingClaim string `json:"existingClaim,omitempty"`+}++// OpenSearchSpec points the operator at an external OpenSearch cluster.+// OpenSearch is NOT deployed by this operator.+type OpenSearchSpec struct {+ // Host is the OpenSearch endpoint hostname or IP.+ // +kubebuilder:validation:Required+ Host string `json:"host"`++ // +optional+ // +kubebuilder:default=9200+ Port int32 `json:"port,omitempty"`++ // +optional+ // +kubebuilder:default="https"+ Scheme string `json:"scheme,omitempty"`++ // IndexName used for document storage.+ // +optional+ // +kubebuilder:default="documents"+ IndexName string `json:"indexName,omitempty"`++ // CredentialsSecret is the name of a Secret with keys "username" and "password".+ // +optional+ CredentialsSecret string `json:"credentialsSecret,omitempty"`+}++// DoclingSpec points the operator at an external Docling document-conversion service.+// Docling is NOT deployed by this operator.+type DoclingSpec struct {+ // Host is the Docling service hostname or IP.+ // +kubebuilder:validation:Required+ Host string `json:"host"`++ // +optional+ // +kubebuilder:default=5001+ Port int32 `json:"port,omitempty"`++ // +optional+ // +kubebuilder:default="http"+ Scheme string `json:"scheme,omitempty"`+}++// NetworkPolicySpec controls whether the operator creates a NetworkPolicy for Langflow.+// The generated policy restricts ingress to RFC-1918 ranges and permits+// egress to Docling, DNS, OpenSearch (9200/443), and Langflow itself.+type NetworkPolicySpec struct {+ // +optional+ // +kubebuilder:default=false+ Enabled bool `json:"enabled,omitempty"`+}++// OpenRAGSpec defines the desired state of an OpenRAG instance.+type OpenRAGSpec struct {+ // ImagePullSecrets for private registries, applied to all component pods.+ // +optional+ ImagePullSecrets []corev1.LocalObjectReference `json:"imagePullSecrets,omitempty"`++ // Frontend configures the OpenRAG Next.js frontend.+ // +kubebuilder:validation:Required+ Frontend FrontendSpec `json:"frontend"`++ // Backend configures the OpenRAG FastAPI backend.+ // +kubebuilder:validation:Required+ Backend BackendSpec `json:"backend"`++ // Langflow configures the Langflow workflow engine.+ // +kubebuilder:validation:Required+ Langflow LangflowSpec `json:"langflow"`++ // OpenSearch configures the external OpenSearch connection.+ // Required unless you supply the credentials via Backend.EnvSecret.+ // +optional+ OpenSearch *OpenSearchSpec `json:"opensearch,omitempty"`++ // Docling configures an optional external document-conversion service.+ // +optional+ Docling *DoclingSpec `json:"docling,omitempty"`++ // NetworkPolicy controls creation of a NetworkPolicy for the Langflow pod.+ // +optional+ NetworkPolicy NetworkPolicySpec `json:"networkPolicy,omitempty"`+}++// OpenRAGStatus defines the observed state of an OpenRAG instance.+type OpenRAGStatus struct {+ // Conditions reflect the reconciliation state.+ // +optional+ Conditions []metav1.Condition `json:"conditions,omitempty"`++ // Phase is a short human-readable summary (Pending, Running, Degraded, Error).+ // +optional+ Phase string `json:"phase,omitempty"`++ // Message provides human-readable detail about the current phase.+ // +optional+ Message string `json:"message,omitempty"`++ // ObservedGeneration is the metadata.generation this status reflects.+ // +optional+ ObservedGeneration int64 `json:"observedGeneration,omitempty"`+}++// +kubebuilder:object:root=true+// +kubebuilder:subresource:status+// +kubebuilder:resource:shortName=or,scope=Namespaced+// +kubebuilder:printcolumn:name="Phase",type="string",JSONPath=".status.phase"+// +kubebuilder:printcolumn:name="Age",type="date",JSONPath=".metadata.creationTimestamp"+// +kubebuilder:printcolumn:name="Frontend",type="string",JSONPath=".spec.frontend.image"+// +kubebuilder:printcolumn:name="Backend",type="string",JSONPath=".spec.backend.image"+// +kubebuilder:printcolumn:name="Langflow",type="string",JSONPath=".spec.langflow.image"++// OpenRAG is the Schema for the openrags API.+type OpenRAG struct {+ metav1.TypeMeta `json:",inline"`+ metav1.ObjectMeta `json:"metadata,omitempty"`++ Spec OpenRAGSpec `json:"spec,omitempty"`+ Status OpenRAGStatus `json:"status,omitempty"`+}++// +kubebuilder:object:root=true++// OpenRAGList contains a list of OpenRAG.+type OpenRAGList struct {+ metav1.TypeMeta `json:",inline"`+ metav1.ListMeta `json:"metadata,omitempty"`+ Items []OpenRAG `json:"items"`+}++func init() {+ SchemeBuilder.Register(&OpenRAG{}, &OpenRAGList{})+}diff --git a/kubernetes/operator/api/v1alpha1/zz_generated.deepcopy.go b/kubernetes/operator/api/v1alpha1/zz_generated.deepcopy.gonew file mode 100644index 000000000..01041de9e--- /dev/null+++ b/kubernetes/operator/api/v1alpha1/zz_generated.deepcopy.go@@ -0,0 +1,318 @@+//go:build !ignore_autogenerated++/*+Copyright 2025 The OpenRAG Authors.++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.+*/++// Code generated by controller-gen. DO NOT EDIT.++package v1alpha1++import (+ "k8s.io/api/core/v1"+ metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"+ runtime "k8s.io/apimachinery/pkg/runtime"+)++// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.+func (in *BackendSpec) DeepCopyInto(out *BackendSpec) {+ *out = *in+ in.ComponentSpec.DeepCopyInto(&out.ComponentSpec)+ if in.JWTSigningKeySecret != nil {+ in, out := &in.JWTSigningKeySecret, &out.JWTSigningKeySecret+ *out = new(v1.SecretKeySelector)+ (*in).DeepCopyInto(*out)+ }+ if in.Storage != nil {+ in, out := &in.Storage, &out.Storage+ *out = new(PersistenceSpec)+ (*in).DeepCopyInto(*out)+ }+}++// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new BackendSpec.+func (in *BackendSpec) DeepCopy() *BackendSpec {+ if in == nil {+ return nil+ }+ out := new(BackendSpec)+ in.DeepCopyInto(out)+ return out+}++// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.+func (in *ComponentSpec) DeepCopyInto(out *ComponentSpec) {+ *out = *in+ if in.Replicas != nil {+ in, out := &in.Replicas, &out.Replicas+ *out = new(int32)+ **out = **in+ }+ in.Resources.DeepCopyInto(&out.Resources)+ if in.Env != nil {+ in, out := &in.Env, &out.Env+ *out = make([]v1.EnvVar, len(*in))+ for i := range *in {+ (*in)[i].DeepCopyInto(&(*out)[i])+ }+ }+ 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.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)+ }+}++// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ComponentSpec.+func (in *ComponentSpec) DeepCopy() *ComponentSpec {+ if in == nil {+ return nil+ }+ out := new(ComponentSpec)+ in.DeepCopyInto(out)+ return out+}++// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.+func (in *DoclingSpec) DeepCopyInto(out *DoclingSpec) {+ *out = *in+}++// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DoclingSpec.+func (in *DoclingSpec) DeepCopy() *DoclingSpec {+ if in == nil {+ return nil+ }+ out := new(DoclingSpec)+ in.DeepCopyInto(out)+ return out+}++// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.+func (in *FrontendSpec) DeepCopyInto(out *FrontendSpec) {+ *out = *in+ in.ComponentSpec.DeepCopyInto(&out.ComponentSpec)+}++// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FrontendSpec.+func (in *FrontendSpec) DeepCopy() *FrontendSpec {+ if in == nil {+ return nil+ }+ out := new(FrontendSpec)+ in.DeepCopyInto(out)+ return out+}++// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.+func (in *LangflowSpec) DeepCopyInto(out *LangflowSpec) {+ *out = *in+ in.ComponentSpec.DeepCopyInto(&out.ComponentSpec)+ if in.Storage != nil {+ in, out := &in.Storage, &out.Storage+ *out = new(PersistenceSpec)+ (*in).DeepCopyInto(*out)+ }+}++// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LangflowSpec.+func (in *LangflowSpec) DeepCopy() *LangflowSpec {+ if in == nil {+ return nil+ }+ out := new(LangflowSpec)+ in.DeepCopyInto(out)+ return out+}++// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.+func (in *NetworkPolicySpec) DeepCopyInto(out *NetworkPolicySpec) {+ *out = *in+}++// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NetworkPolicySpec.+func (in *NetworkPolicySpec) DeepCopy() *NetworkPolicySpec {+ if in == nil {+ return nil+ }+ out := new(NetworkPolicySpec)+ in.DeepCopyInto(out)+ return out+}++// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.+func (in *OpenRAG) DeepCopyInto(out *OpenRAG) {+ *out = *in+ out.TypeMeta = in.TypeMeta+ in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)+ in.Spec.DeepCopyInto(&out.Spec)+ in.Status.DeepCopyInto(&out.Status)+}++// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OpenRAG.+func (in *OpenRAG) DeepCopy() *OpenRAG {+ if in == nil {+ return nil+ }+ out := new(OpenRAG)+ in.DeepCopyInto(out)+ return out+}++// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.+func (in *OpenRAG) 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 *OpenRAGList) DeepCopyInto(out *OpenRAGList) {+ *out = *in+ out.TypeMeta = in.TypeMeta+ in.ListMeta.DeepCopyInto(&out.ListMeta)+ if in.Items != nil {+ in, out := &in.Items, &out.Items+ *out = make([]OpenRAG, len(*in))+ for i := range *in {+ (*in)[i].DeepCopyInto(&(*out)[i])+ }+ }+}++// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OpenRAGList.+func (in *OpenRAGList) DeepCopy() *OpenRAGList {+ if in == nil {+ return nil+ }+ out := new(OpenRAGList)+ in.DeepCopyInto(out)+ return out+}++// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.+func (in *OpenRAGList) 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 *OpenRAGSpec) DeepCopyInto(out *OpenRAGSpec) {+ *out = *in+ if in.ImagePullSecrets != nil {+ in, out := &in.ImagePullSecrets, &out.ImagePullSecrets+ *out = make([]v1.LocalObjectReference, len(*in))+ copy(*out, *in)+ }+ in.Frontend.DeepCopyInto(&out.Frontend)+ in.Backend.DeepCopyInto(&out.Backend)+ in.Langflow.DeepCopyInto(&out.Langflow)+ if in.OpenSearch != nil {+ in, out := &in.OpenSearch, &out.OpenSearch+ *out = new(OpenSearchSpec)+ **out = **in+ }+ if in.Docling != nil {+ in, out := &in.Docling, &out.Docling+ *out = new(DoclingSpec)+ **out = **in+ }+ out.NetworkPolicy = in.NetworkPolicy+}++// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OpenRAGSpec.+func (in *OpenRAGSpec) DeepCopy() *OpenRAGSpec {+ if in == nil {+ return nil+ }+ out := new(OpenRAGSpec)+ in.DeepCopyInto(out)+ return out+}++// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.+func (in *OpenRAGStatus) DeepCopyInto(out *OpenRAGStatus) {+ *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])+ }+ }+}++// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OpenRAGStatus.+func (in *OpenRAGStatus) DeepCopy() *OpenRAGStatus {+ if in == nil {+ return nil+ }+ out := new(OpenRAGStatus)+ in.DeepCopyInto(out)+ return out+}++// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.+func (in *OpenSearchSpec) DeepCopyInto(out *OpenSearchSpec) {+ *out = *in+}++// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OpenSearchSpec.+func (in *OpenSearchSpec) DeepCopy() *OpenSearchSpec {+ if in == nil {+ return nil+ }+ out := new(OpenSearchSpec)+ in.DeepCopyInto(out)+ return out+}++// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.+func (in *PersistenceSpec) DeepCopyInto(out *PersistenceSpec) {+ *out = *in+ if in.StorageClassName != nil {+ in, out := &in.StorageClassName, &out.StorageClassName+ *out = new(string)+ **out = **in+ }+ out.Size = in.Size.DeepCopy()+}++// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PersistenceSpec.+func (in *PersistenceSpec) DeepCopy() *PersistenceSpec {+ if in == nil {+ return nil+ }+ out := new(PersistenceSpec)+ in.DeepCopyInto(out)+ return out+}diff --git a/kubernetes/operator/cmd/main.go b/kubernetes/operator/cmd/main.gonew file mode 100644index 000000000..8b5bc0894--- /dev/null+++ b/kubernetes/operator/cmd/main.go@@ -0,0 +1,83 @@+package main++import (+ "flag"+ "os"++ appsv1 "k8s.io/api/apps/v1"+ corev1 "k8s.io/api/core/v1"+ networkingv1 "k8s.io/api/networking/v1"+ "k8s.io/apimachinery/pkg/runtime"+ utilruntime "k8s.io/apimachinery/pkg/util/runtime"+ clientgoscheme "k8s.io/client-go/kubernetes/scheme"+ ctrl "sigs.k8s.io/controller-runtime"+ "sigs.k8s.io/controller-runtime/pkg/healthz"+ "sigs.k8s.io/controller-runtime/pkg/log/zap"+ metricsserver "sigs.k8s.io/controller-runtime/pkg/metrics/server"++ openragv1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"+ "github.com/langflow-ai/openrag-operator/internal/controller"+)++var (+ scheme = runtime.NewScheme()+ setupLog = ctrl.Log.WithName("setup")+)++func init() {+ utilruntime.Must(clientgoscheme.AddToScheme(scheme))+ utilruntime.Must(appsv1.AddToScheme(scheme))+ utilruntime.Must(corev1.AddToScheme(scheme))+ utilruntime.Must(networkingv1.AddToScheme(scheme))+ utilruntime.Must(openragv1alpha1.AddToScheme(scheme))+}++func main() {+ var metricsAddr string+ var enableLeaderElection bool+ var probeAddr string++ flag.StringVar(&metricsAddr, "metrics-bind-address", ":8080", "The address the metric endpoint binds to.")+ flag.StringVar(&probeAddr, "health-probe-bind-address", ":8081", "The address the probe endpoint binds to.")+ flag.BoolVar(&enableLeaderElection, "leader-elect", false, "Enable leader election for controller manager.")++ opts := zap.Options{Development: true}+ opts.BindFlags(flag.CommandLine)+ flag.Parse()+ ctrl.SetLogger(zap.New(zap.UseFlagOptions(&opts)))++ mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{+ Scheme: scheme,+ Metrics: metricsserver.Options{BindAddress: metricsAddr},+ HealthProbeBindAddress: probeAddr,+ LeaderElection: enableLeaderElection,+ LeaderElectionID: "openrag-operator.openrag.io",+ })+ if err != nil {+ setupLog.Error(err, "unable to start manager")+ os.Exit(1)+ }++ if err = (&controller.OpenRAGReconciler{+ Client: mgr.GetClient(),+ Scheme: mgr.GetScheme(),+ }).SetupWithManager(mgr); err != nil {+ setupLog.Error(err, "unable to create controller", "controller", "OpenRAG")+ os.Exit(1)+ }++ if err := mgr.AddHealthzCheck("healthz", healthz.Ping); err != nil {+ setupLog.Error(err, "unable to set up health check")+ os.Exit(1)+ }+ if err := mgr.AddReadyzCheck("readyz", healthz.Ping); err != nil {+ setupLog.Error(err, "unable to set up ready check")+ os.Exit(1)+ }++ setupLog.Info("starting manager")+ if err := mgr.Start(ctrl.SetupSignalHandler()); err != nil {+ setupLog.Error(err, "problem running manager")+ os.Exit(1)+ }+}diff --git a/kubernetes/operator/config/crd/bases/.gitkeep b/kubernetes/operator/config/crd/bases/.gitkeepnew file mode 100644index 000000000..e69de29bbdiff --git a/kubernetes/operator/config/crd/bases/openrag.io_openrags.yaml b/kubernetes/operator/config/crd/bases/openrag.io_openrags.yamlnew file mode 100644index 000000000..93e162463--- /dev/null+++ b/kubernetes/operator/config/crd/bases/openrag.io_openrags.yaml@@ -0,0 +1,3779 @@+---+apiVersion: apiextensions.k8s.io/v1+kind: CustomResourceDefinition+metadata:+ annotations:+ controller-gen.kubebuilder.io/version: v0.16.4+ name: openrags.openrag.io+spec:+ group: openrag.io+ names:+ kind: OpenRAG+ listKind: OpenRAGList+ plural: openrags+ shortNames:+ - or+ singular: openrag+ scope: Namespaced+ versions:+ - additionalPrinterColumns:+ - jsonPath: .status.phase+ name: Phase+ type: string+ - jsonPath: .metadata.creationTimestamp+ name: Age+ type: date+ - jsonPath: .spec.frontend.image+ name: Frontend+ type: string+ - jsonPath: .spec.backend.image+ name: Backend+ type: string+ - jsonPath: .spec.langflow.image+ name: Langflow+ type: string+ name: v1alpha1+ schema:+ openAPIV3Schema:+ description: OpenRAG is the Schema for the openrags API.+ properties:+ apiVersion:+ description: |-+ APIVersion defines the versioned schema of this representation of an object.+ Servers should convert recognized schemas to the latest internal value, and+ may reject unrecognized values.+ More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources+ type: string+ kind:+ description: |-+ Kind is a string value representing the REST resource this object represents.+ Servers may infer this from the endpoint the client submits requests to.+ Cannot be updated.+ In CamelCase.+ More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds+ type: string+ metadata:+ type: object+ spec:+ description: OpenRAGSpec defines the desired state of an OpenRAG instance.+ properties:+ backend:+ description: Backend configures the OpenRAG FastAPI backend.+ properties:+ affinity:+ description: Affinity is a group of affinity scheduling rules.+ 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 <topologyKey> matches that of any node on which+ a pod of the set of pods is running+ properties:+ labelSelector:+ description: |-+ A label query over a set of resources, in this case pods.+ 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 <topologyKey> matches that of any node on which+ a pod of the set of pods is running+ properties:+ labelSelector:+ description: |-+ A label query over a set of resources, in this case pods.+ 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+ env:+ description: Additional environment variables injected into the+ container.+ items:+ description: EnvVar represents an environment variable present+ in a Container.+ properties:+ name:+ description: Name of the environment variable. Must be a+ C_IDENTIFIER.+ type: string+ value:+ description: |-+ Variable references $(VAR_NAME) are expanded+ using the previously defined environment variables in the container and+ any service environment variables. If a variable cannot be resolved,+ the reference in the input string will be unchanged. Double $$ are reduced+ to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e.+ "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)".+ Escaped references will never be expanded, regardless of whether the variable+ exists or not.+ Defaults to "".+ type: string+ valueFrom:+ description: Source for the environment variable's value.+ Cannot be used if value is not empty.+ properties:+ configMapKeyRef:+ description: Selects a key of a ConfigMap.+ properties:+ key:+ description: The key to select.+ type: string+ name:+ default: ""+ description: |-+ Name of the referent.+ This field is effectively required, but due to backwards compatibility is+ allowed to be empty. Instances of this type with an empty value here are+ almost certainly wrong.+ More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names+ type: string+ optional:+ description: Specify whether the ConfigMap or its+ key must be defined+ type: boolean+ required:+ - key+ type: object+ x-kubernetes-map-type: atomic+ fieldRef:+ description: |-+ Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['<KEY>']`, `metadata.annotations['<KEY>']`,+ spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.+ properties:+ apiVersion:+ description: Version of the schema the FieldPath+ is written in terms of, defaults to "v1".+ type: string+ fieldPath:+ description: Path of the field to select in the+ specified API version.+ type: string+ required:+ - fieldPath+ type: object+ x-kubernetes-map-type: atomic+ resourceFieldRef:+ description: |-+ Selects a resource of the container: only resources limits and requests+ (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.+ properties:+ containerName:+ description: 'Container name: required for volumes,+ optional for env vars'+ type: string+ divisor:+ anyOf:+ - type: integer+ - type: string+ description: Specifies the output format of the+ exposed resources, defaults to "1"+ pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$+ x-kubernetes-int-or-string: true+ resource:+ description: 'Required: resource to select'+ type: string+ required:+ - resource+ type: object+ x-kubernetes-map-type: atomic+ secretKeyRef:+ description: Selects a key of a secret in the pod's+ namespace+ properties:+ key:+ description: The key of the secret to select from. Must+ be a valid secret key.+ type: string+ name:+ default: ""+ description: |-+ Name of the referent.+ This field is effectively required, but due to backwards compatibility is+ allowed to be empty. Instances of this type with an empty value here are+ almost certainly wrong.+ More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names+ type: string+ optional:+ description: Specify whether the Secret or its key+ must be defined+ type: boolean+ required:+ - key+ type: object+ x-kubernetes-map-type: atomic+ type: object+ required:+ - name+ type: object+ type: array+ envSecret:+ description: |-+ EnvSecret is the name of a Secret whose keys are mounted as /app/.env.+ The secret must contain a single key ".env" with the full dotenv content.+ type: string+ image:+ description: Image is the container image (repository:tag).+ type: string+ imagePullPolicy:+ default: IfNotPresent+ description: PullPolicy describes a policy for if/when to pull+ a container image+ type: string+ jwtSigningKeySecret:+ description: |-+ JWTSigningKeySecret references the Secret key that holds the JWT signing key.+ If omitted the operator generates a random key and stores it in a managed Secret.+ properties:+ key:+ description: The key of the secret to select from. Must be+ a valid secret key.+ type: string+ name:+ default: ""+ description: |-+ Name of the referent.+ This field is effectively required, but due to backwards compatibility is+ allowed to be empty. Instances of this type with an empty value here are+ almost certainly wrong.+ More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names+ type: string+ optional:+ description: Specify whether the Secret or its key must be+ defined+ type: boolean+ required:+ - key+ type: object+ x-kubernetes-map-type: atomic+ nodeSelector:+ additionalProperties:+ type: string+ type: object+ replicas:+ default: 1+ format: int32+ minimum: 0+ type: integer+ resources:+ description: ResourceRequirements describes the compute resource+ requirements.+ properties:+ claims:+ description: |-+ Claims lists the names of resources, defined in spec.resourceClaims,+ that are used by this container.++ This is an alpha field and requires enabling the+ DynamicResourceAllocation feature gate.++ This field is immutable. It can only be set for containers.+ items:+ description: ResourceClaim references one entry in PodSpec.ResourceClaims.+ properties:+ name:+ description: |-+ Name must match the name of one entry in pod.spec.resourceClaims of+ the Pod where this field is used. It makes that resource available+ inside a container.+ type: string+ request:+ description: |-+ Request is the name chosen for a request in the referenced claim.+ If empty, everything from the claim is made available, otherwise+ only the result of this request.+ type: string+ required:+ - name+ type: object+ type: array+ x-kubernetes-list-map-keys:+ - name+ x-kubernetes-list-type: map+ limits:+ additionalProperties:+ anyOf:+ - type: integer+ - type: string+ pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$+ x-kubernetes-int-or-string: true+ description: |-+ Limits describes the maximum amount of compute resources allowed.+ More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/+ type: object+ requests:+ additionalProperties:+ anyOf:+ - type: integer+ - type: string+ pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$+ x-kubernetes-int-or-string: true+ description: |-+ Requests describes the minimum amount of compute resources required.+ If Requests is omitted for a container, it defaults to Limits if that is explicitly specified,+ otherwise to an implementation-defined value. Requests cannot exceed Limits.+ More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/+ type: object+ type: object+ storage:+ description: BackendDataStorage configures a PVC mounted at /app/backend-data.+ properties:+ enabled:+ default: true+ type: boolean+ existingClaim:+ description: ExistingClaim reuses a pre-existing PVC instead+ of creating one.+ type: string+ size:+ anyOf:+ - type: integer+ - type: string+ default: 10Gi+ description: Size of the PVC. Defaults to 10Gi.+ pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$+ x-kubernetes-int-or-string: true+ storageClassName:+ description: StorageClassName passed to the PVC. Defaults+ to the cluster default.+ type: string+ type: object+ tolerations:+ items:+ description: |-+ The pod this Toleration is attached to tolerates any taint that matches+ the triple <key,value,effect> using the matching operator <operator>.+ properties:+ effect:+ description: |-+ Effect indicates the taint effect to match. Empty means match all taint effects.+ When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.+ type: string+ key:+ description: |-+ Key is the taint key that the toleration applies to. Empty means match all taint keys.+ If the key is empty, operator must be Exists; this combination means to match all values and all keys.+ type: string+ operator:+ description: |-+ Operator represents a key's relationship to the value.+ Valid operators are Exists and Equal. Defaults to Equal.+ Exists is equivalent to wildcard for value, so that a pod can+ tolerate all taints of a particular category.+ type: string+ tolerationSeconds:+ description: |-+ TolerationSeconds represents the period of time the toleration (which must be+ of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default,+ it is not set, which means tolerate the taint forever (do not evict). Zero and+ negative values will be treated as 0 (evict immediately) by the system.+ format: int64+ type: integer+ value:+ description: |-+ Value is the taint value the toleration matches to.+ If the operator is Exists, the value should be empty, otherwise just a regular string.+ type: string+ type: object+ type: array+ required:+ - image+ type: object+ docling:+ description: Docling configures an optional external document-conversion+ service.+ properties:+ host:+ description: Host is the Docling service hostname or IP.+ type: string+ port:+ default: 5001+ format: int32+ type: integer+ scheme:+ default: http+ type: string+ required:+ - host+ type: object+ frontend:+ description: Frontend configures the OpenRAG Next.js frontend.+ properties:+ affinity:+ description: Affinity is a group of affinity scheduling rules.+ 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 <topologyKey> matches that of any node on which+ a pod of the set of pods is running+ properties:+ labelSelector:+ description: |-+ A label query over a set of resources, in this case pods.+ 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 <topologyKey> matches that of any node on which+ a pod of the set of pods is running+ properties:+ labelSelector:+ description: |-+ A label query over a set of resources, in this case pods.+ 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+ env:+ description: Additional environment variables injected into the+ container.+ items:+ description: EnvVar represents an environment variable present+ in a Container.+ properties:+ name:+ description: Name of the environment variable. Must be a+ C_IDENTIFIER.+ type: string+ value:+ description: |-+ Variable references $(VAR_NAME) are expanded+ using the previously defined environment variables in the container and+ any service environment variables. If a variable cannot be resolved,+ the reference in the input string will be unchanged. Double $$ are reduced+ to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e.+ "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)".+ Escaped references will never be expanded, regardless of whether the variable+ exists or not.+ Defaults to "".+ type: string+ valueFrom:+ description: Source for the environment variable's value.+ Cannot be used if value is not empty.+ properties:+ configMapKeyRef:+ description: Selects a key of a ConfigMap.+ properties:+ key:+ description: The key to select.+ type: string+ name:+ default: ""+ description: |-+ Name of the referent.+ This field is effectively required, but due to backwards compatibility is+ allowed to be empty. Instances of this type with an empty value here are+ almost certainly wrong.+ More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names+ type: string+ optional:+ description: Specify whether the ConfigMap or its+ key must be defined+ type: boolean+ required:+ - key+ type: object+ x-kubernetes-map-type: atomic+ fieldRef:+ description: |-+ Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['<KEY>']`, `metadata.annotations['<KEY>']`,+ spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.+ properties:+ apiVersion:+ description: Version of the schema the FieldPath+ is written in terms of, defaults to "v1".+ type: string+ fieldPath:+ description: Path of the field to select in the+ specified API version.+ type: string+ required:+ - fieldPath+ type: object+ x-kubernetes-map-type: atomic+ resourceFieldRef:+ description: |-+ Selects a resource of the container: only resources limits and requests+ (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.+ properties:+ containerName:+ description: 'Container name: required for volumes,+ optional for env vars'+ type: string+ divisor:+ anyOf:+ - type: integer+ - type: string+ description: Specifies the output format of the+ exposed resources, defaults to "1"+ pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$+ x-kubernetes-int-or-string: true+ resource:+ description: 'Required: resource to select'+ type: string+ required:+ - resource+ type: object+ x-kubernetes-map-type: atomic+ secretKeyRef:+ description: Selects a key of a secret in the pod's+ namespace+ properties:+ key:+ description: The key of the secret to select from. Must+ be a valid secret key.+ type: string+ name:+ default: ""+ description: |-+ Name of the referent.+ This field is effectively required, but due to backwards compatibility is+ allowed to be empty. Instances of this type with an empty value here are+ almost certainly wrong.+ More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names+ type: string+ optional:+ description: Specify whether the Secret or its key+ must be defined+ type: boolean+ required:+ - key+ type: object+ x-kubernetes-map-type: atomic+ type: object+ required:+ - name+ type: object+ type: array+ image:+ description: Image is the container image (repository:tag).+ type: string+ imagePullPolicy:+ default: IfNotPresent+ description: PullPolicy describes a policy for if/when to pull+ a container image+ type: string+ nodeSelector:+ additionalProperties:+ type: string+ type: object+ replicas:+ default: 1+ format: int32+ minimum: 0+ type: integer+ resources:+ description: ResourceRequirements describes the compute resource+ requirements.+ properties:+ claims:+ description: |-+ Claims lists the names of resources, defined in spec.resourceClaims,+ that are used by this container.++ This is an alpha field and requires enabling the+ DynamicResourceAllocation feature gate.++ This field is immutable. It can only be set for containers.+ items:+ description: ResourceClaim references one entry in PodSpec.ResourceClaims.+ properties:+ name:+ description: |-+ Name must match the name of one entry in pod.spec.resourceClaims of+ the Pod where this field is used. It makes that resource available+ inside a container.+ type: string+ request:+ description: |-+ Request is the name chosen for a request in the referenced claim.+ If empty, everything from the claim is made available, otherwise+ only the result of this request.+ type: string+ required:+ - name+ type: object+ type: array+ x-kubernetes-list-map-keys:+ - name+ x-kubernetes-list-type: map+ limits:+ additionalProperties:+ anyOf:+ - type: integer+ - type: string+ pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$+ x-kubernetes-int-or-string: true+ description: |-+ Limits describes the maximum amount of compute resources allowed.+ More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/+ type: object+ requests:+ additionalProperties:+ anyOf:+ - type: integer+ - type: string+ pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$+ x-kubernetes-int-or-string: true+ description: |-+ Requests describes the minimum amount of compute resources required.+ If Requests is omitted for a container, it defaults to Limits if that is explicitly specified,+ otherwise to an implementation-defined value. Requests cannot exceed Limits.+ More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/+ type: object+ type: object+ tolerations:+ items:+ description: |-+ The pod this Toleration is attached to tolerates any taint that matches+ the triple <key,value,effect> using the matching operator <operator>.+ properties:+ effect:+ description: |-+ Effect indicates the taint effect to match. Empty means match all taint effects.+ When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.+ type: string+ key:+ description: |-+ Key is the taint key that the toleration applies to. Empty means match all taint keys.+ If the key is empty, operator must be Exists; this combination means to match all values and all keys.+ type: string+ operator:+ description: |-+ Operator represents a key's relationship to the value.+ Valid operators are Exists and Equal. Defaults to Equal.+ Exists is equivalent to wildcard for value, so that a pod can+ tolerate all taints of a particular category.+ type: string+ tolerationSeconds:+ description: |-+ TolerationSeconds represents the period of time the toleration (which must be+ of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default,+ it is not set, which means tolerate the taint forever (do not evict). Zero and+ negative values will be treated as 0 (evict immediately) by the system.+ format: int64+ type: integer+ value:+ description: |-+ Value is the taint value the toleration matches to.+ If the operator is Exists, the value should be empty, otherwise just a regular string.+ type: string+ type: object+ type: array+ required:+ - image+ type: object+ imagePullSecrets:+ description: ImagePullSecrets for private registries, applied to all+ component pods.+ items:+ description: |-+ LocalObjectReference contains enough information to let you locate the+ referenced object inside the same namespace.+ properties:+ name:+ default: ""+ description: |-+ Name of the referent.+ This field is effectively required, but due to backwards compatibility is+ allowed to be empty. Instances of this type with an empty value here are+ almost certainly wrong.+ More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names+ type: string+ type: object+ x-kubernetes-map-type: atomic+ type: array+ langflow:+ description: Langflow configures the Langflow workflow engine.+ properties:+ affinity:+ description: Affinity is a group of affinity scheduling rules.+ 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 <topologyKey> matches that of any node on which+ a pod of the set of pods is running+ properties:+ labelSelector:+ description: |-+ A label query over a set of resources, in this case pods.+ 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 <topologyKey> matches that of any node on which+ a pod of the set of pods is running+ properties:+ labelSelector:+ description: |-+ A label query over a set of resources, in this case pods.+ 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+ env:+ description: Additional environment variables injected into the+ container.+ items:+ description: EnvVar represents an environment variable present+ in a Container.+ properties:+ name:+ description: Name of the environment variable. Must be a+ C_IDENTIFIER.+ type: string+ value:+ description: |-+ Variable references $(VAR_NAME) are expanded+ using the previously defined environment variables in the container and+ any service environment variables. If a variable cannot be resolved,+ the reference in the input string will be unchanged. Double $$ are reduced+ to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e.+ "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)".+ Escaped references will never be expanded, regardless of whether the variable+ exists or not.+ Defaults to "".+ type: string+ valueFrom:+ description: Source for the environment variable's value.+ Cannot be used if value is not empty.+ properties:+ configMapKeyRef:+ description: Selects a key of a ConfigMap.+ properties:+ key:+ description: The key to select.+ type: string+ name:+ default: ""+ description: |-+ Name of the referent.+ This field is effectively required, but due to backwards compatibility is+ allowed to be empty. Instances of this type with an empty value here are+ almost certainly wrong.+ More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names+ type: string+ optional:+ description: Specify whether the ConfigMap or its+ key must be defined+ type: boolean+ required:+ - key+ type: object+ x-kubernetes-map-type: atomic+ fieldRef:+ description: |-+ Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['<KEY>']`, `metadata.annotations['<KEY>']`,+ spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.+ properties:+ apiVersion:+ description: Version of the schema the FieldPath+ is written in terms of, defaults to "v1".+ type: string+ fieldPath:+ description: Path of the field to select in the+ specified API version.+ type: string+ required:+ - fieldPath+ type: object+ x-kubernetes-map-type: atomic+ resourceFieldRef:+ description: |-+ Selects a resource of the container: only resources limits and requests+ (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.+ properties:+ containerName:+ description: 'Container name: required for volumes,+ optional for env vars'+ type: string+ divisor:+ anyOf:+ - type: integer+ - type: string+ description: Specifies the output format of the+ exposed resources, defaults to "1"+ pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$+ x-kubernetes-int-or-string: true+ resource:+ description: 'Required: resource to select'+ type: string+ required:+ - resource+ type: object+ x-kubernetes-map-type: atomic+ secretKeyRef:+ description: Selects a key of a secret in the pod's+ namespace+ properties:+ key:+ description: The key of the secret to select from. Must+ be a valid secret key.+ type: string+ name:+ default: ""+ description: |-+ Name of the referent.+ This field is effectively required, but due to backwards compatibility is+ allowed to be empty. Instances of this type with an empty value here are+ almost certainly wrong.+ More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names+ type: string+ optional:+ description: Specify whether the Secret or its key+ must be defined+ type: boolean+ required:+ - key+ type: object+ x-kubernetes-map-type: atomic+ type: object+ required:+ - name+ type: object+ type: array+ envSecret:+ description: EnvSecret is the name of a Secret whose single ".env"+ key is mounted at /app/.env.+ type: string+ image:+ description: Image is the container image (repository:tag).+ type: string+ imagePullPolicy:+ default: IfNotPresent+ description: PullPolicy describes a policy for if/when to pull+ a container image+ type: string+ nodeSelector:+ additionalProperties:+ type: string+ type: object+ replicas:+ default: 1+ format: int32+ minimum: 0+ type: integer+ resources:+ description: ResourceRequirements describes the compute resource+ requirements.+ properties:+ claims:+ description: |-+ Claims lists the names of resources, defined in spec.resourceClaims,+ that are used by this container.++ This is an alpha field and requires enabling the+ DynamicResourceAllocation feature gate.++ This field is immutable. It can only be set for containers.+ items:+ description: ResourceClaim references one entry in PodSpec.ResourceClaims.+ properties:+ name:+ description: |-+ Name must match the name of one entry in pod.spec.resourceClaims of+ the Pod where this field is used. It makes that resource available+ inside a container.+ type: string+ request:+ description: |-+ Request is the name chosen for a request in the referenced claim.+ If empty, everything from the claim is made available, otherwise+ only the result of this request.+ type: string+ required:+ - name+ type: object+ type: array+ x-kubernetes-list-map-keys:+ - name+ x-kubernetes-list-type: map+ limits:+ additionalProperties:+ anyOf:+ - type: integer+ - type: string+ pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$+ x-kubernetes-int-or-string: true+ description: |-+ Limits describes the maximum amount of compute resources allowed.+ More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/+ type: object+ requests:+ additionalProperties:+ anyOf:+ - type: integer+ - type: string+ pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$+ x-kubernetes-int-or-string: true+ description: |-+ Requests describes the minimum amount of compute resources required.+ If Requests is omitted for a container, it defaults to Limits if that is explicitly specified,+ otherwise to an implementation-defined value. Requests cannot exceed Limits.+ More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/+ type: object+ type: object+ storage:+ description: Storage configures a PVC mounted at /app/data (Langflow+ SQLite + flows).+ properties:+ enabled:+ default: true+ type: boolean+ existingClaim:+ description: ExistingClaim reuses a pre-existing PVC instead+ of creating one.+ type: string+ size:+ anyOf:+ - type: integer+ - type: string+ default: 10Gi+ description: Size of the PVC. Defaults to 10Gi.+ pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$+ x-kubernetes-int-or-string: true+ storageClassName:+ description: StorageClassName passed to the PVC. Defaults+ to the cluster default.+ type: string+ type: object+ tolerations:+ items:+ description: |-+ The pod this Toleration is attached to tolerates any taint that matches+ the triple <key,value,effect> using the matching operator <operator>.+ properties:+ effect:+ description: |-+ Effect indicates the taint effect to match. Empty means match all taint effects.+ When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.+ type: string+ key:+ description: |-+ Key is the taint key that the toleration applies to. Empty means match all taint keys.+ If the key is empty, operator must be Exists; this combination means to match all values and all keys.+ type: string+ operator:+ description: |-+ Operator represents a key's relationship to the value.+ Valid operators are Exists and Equal. Defaults to Equal.+ Exists is equivalent to wildcard for value, so that a pod can+ tolerate all taints of a particular category.+ type: string+ tolerationSeconds:+ description: |-+ TolerationSeconds represents the period of time the toleration (which must be+ of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default,+ it is not set, which means tolerate the taint forever (do not evict). Zero and+ negative values will be treated as 0 (evict immediately) by the system.+ format: int64+ type: integer+ value:+ description: |-+ Value is the taint value the toleration matches to.+ If the operator is Exists, the value should be empty, otherwise just a regular string.+ type: string+ type: object+ type: array+ required:+ - image+ type: object+ networkPolicy:+ description: NetworkPolicy controls creation of a NetworkPolicy for+ the Langflow pod.+ properties:+ enabled:+ default: false+ type: boolean+ type: object+ opensearch:+ description: |-+ OpenSearch configures the external OpenSearch connection.+ Required unless you supply the credentials via Backend.EnvSecret.+ properties:+ credentialsSecret:+ description: CredentialsSecret is the name of a Secret with keys+ "username" and "password".+ type: string+ host:+ description: Host is the OpenSearch endpoint hostname or IP.+ type: string+ indexName:+ default: documents+ description: IndexName used for document storage.+ type: string+ port:+ default: 9200+ format: int32+ type: integer+ scheme:+ default: https+ type: string+ required:+ - host+ type: object+ required:+ - backend+ - frontend+ - langflow+ type: object+ status:+ description: OpenRAGStatus defines the observed state of an OpenRAG instance.+ properties:+ conditions:+ description: Conditions reflect the reconciliation 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+ type: array+ message:+ description: Message provides human-readable detail about the current+ phase.+ type: string+ observedGeneration:+ description: ObservedGeneration is the metadata.generation this status+ reflects.+ format: int64+ type: integer+ phase:+ description: Phase is a short human-readable summary (Pending, Running,+ Degraded, Error).+ type: string+ type: object+ type: object+ served: true+ storage: true+ subresources:+ status: {}diff --git a/kubernetes/operator/config/crd/kustomization.yaml b/kubernetes/operator/config/crd/kustomization.yamlnew file mode 100644index 000000000..6737d1d1d--- /dev/null+++ b/kubernetes/operator/config/crd/kustomization.yaml@@ -0,0 +1,12 @@+resources:+- bases/openrag.io_openrags.yaml+#+kubebuilder:scaffold:crdkustomizeresource++patches:+# [WEBHOOK] To enable webhook, uncomment all the sections with [WEBHOOK] prefix.+# patches here are for enabling the conversion webhook for each CRD+#+kubebuilder:scaffold:crdkustomizewebhookpatch++# [CERTMANAGER] To enable cert-manager, uncomment all the sections with [CERTMANAGER] prefix.+# patches here are for enabling the CA injection for each CRD+#+kubebuilder:scaffold:crdkustomizecainjectionpatchdiff --git a/kubernetes/operator/config/default/kustomization.yaml b/kubernetes/operator/config/default/kustomization.yamlnew file mode 100644index 000000000..7d361f2e6--- /dev/null+++ b/kubernetes/operator/config/default/kustomization.yaml@@ -0,0 +1,13 @@+namespace: openrag-operator-system++namePrefix: openrag-operator-++resources:+- ../rbac+- ../crd+- ../manager++patches:+- path: manager_auth_proxy_patch.yaml+ target:+ kind: Deploymentdiff --git a/kubernetes/operator/config/default/manager_auth_proxy_patch.yaml b/kubernetes/operator/config/default/manager_auth_proxy_patch.yamlnew file mode 100644index 000000000..fbe539d51--- /dev/null+++ b/kubernetes/operator/config/default/manager_auth_proxy_patch.yaml@@ -0,0 +1,17 @@+# Patches the manager Deployment to add a namespace reference.+# Extend this file to add sidecars, auth proxy, etc.+apiVersion: apps/v1+kind: Deployment+metadata:+ name: controller-manager+ namespace: system+spec:+ template:+ spec:+ containers:+ - name: manager+ env:+ - name: OPERATOR_NAMESPACE+ valueFrom:+ fieldRef:+ fieldPath: metadata.namespacediff --git a/kubernetes/operator/config/manager/kustomization.yaml b/kubernetes/operator/config/manager/kustomization.yamlnew file mode 100644index 000000000..5c5f0b84c--- /dev/null+++ b/kubernetes/operator/config/manager/kustomization.yaml@@ -0,0 +1,2 @@+resources:+- manager.yamldiff --git a/kubernetes/operator/config/manager/manager.yaml b/kubernetes/operator/config/manager/manager.yamlnew file mode 100644index 000000000..a9247896c--- /dev/null+++ b/kubernetes/operator/config/manager/manager.yaml@@ -0,0 +1,53 @@+apiVersion: apps/v1+kind: Deployment+metadata:+ name: controller-manager+ namespace: system+ labels:+ control-plane: controller-manager+ app.kubernetes.io/name: openrag-operator+ app.kubernetes.io/managed-by: kustomize+spec:+ selector:+ matchLabels:+ control-plane: controller-manager+ replicas: 1+ template:+ metadata:+ labels:+ control-plane: controller-manager+ spec:+ serviceAccountName: controller-manager+ securityContext:+ runAsNonRoot: true+ containers:+ - name: manager+ image: controller:latest+ args:+ - --leader-elect+ - --health-probe-bind-address=:8081+ securityContext:+ allowPrivilegeEscalation: false+ capabilities:+ drop:+ - ALL+ livenessProbe:+ httpGet:+ path: /healthz+ port: 8081+ initialDelaySeconds: 15+ periodSeconds: 20+ readinessProbe:+ httpGet:+ path: /readyz+ port: 8081+ initialDelaySeconds: 5+ periodSeconds: 10+ resources:+ limits:+ cpu: 500m+ memory: 128Mi+ requests:+ cpu: 10m+ memory: 64Mi+ terminationGracePeriodSeconds: 10diff --git a/kubernetes/operator/config/rbac/kustomization.yaml b/kubernetes/operator/config/rbac/kustomization.yamlnew file mode 100644index 000000000..922158614--- /dev/null+++ b/kubernetes/operator/config/rbac/kustomization.yaml@@ -0,0 +1,6 @@+resources:+- service_account.yaml+- role.yaml+- role_binding.yaml+- leader_election_role.yaml+- leader_election_role_binding.yamldiff --git a/kubernetes/operator/config/rbac/leader_election_role.yaml b/kubernetes/operator/config/rbac/leader_election_role.yamlnew file mode 100644index 000000000..941d58160--- /dev/null+++ b/kubernetes/operator/config/rbac/leader_election_role.yaml@@ -0,0 +1,15 @@+apiVersion: rbac.authorization.k8s.io/v1+kind: Role+metadata:+ name: leader-election-role+ namespace: system+rules:+- apiGroups: [""]+ resources: ["configmaps"]+ verbs: ["get","list","watch","create","update","patch","delete"]+- apiGroups: ["coordination.k8s.io"]+ resources: ["leases"]+ verbs: ["get","list","watch","create","update","patch","delete"]+- apiGroups: [""]+ resources: ["events"]+ verbs: ["create","patch"]diff --git a/kubernetes/operator/config/rbac/leader_election_role_binding.yaml b/kubernetes/operator/config/rbac/leader_election_role_binding.yamlnew file mode 100644index 000000000..2aa58a58f--- /dev/null+++ b/kubernetes/operator/config/rbac/leader_election_role_binding.yaml@@ -0,0 +1,13 @@+apiVersion: rbac.authorization.k8s.io/v1+kind: RoleBinding+metadata:+ name: leader-election-rolebinding+ namespace: system+roleRef:+ apiGroup: rbac.authorization.k8s.io+ kind: Role+ name: leader-election-role+subjects:+- kind: ServiceAccount+ name: controller-manager+ namespace: systemdiff --git a/kubernetes/operator/config/rbac/role.yaml b/kubernetes/operator/config/rbac/role.yamlnew file mode 100644index 000000000..de6c87fe8--- /dev/null+++ b/kubernetes/operator/config/rbac/role.yaml@@ -0,0 +1,71 @@+---+apiVersion: rbac.authorization.k8s.io/v1+kind: ClusterRole+metadata:+ name: manager-role+rules:+- apiGroups:+ - ""+ resources:+ - persistentvolumeclaims+ - secrets+ - serviceaccounts+ - services+ verbs:+ - create+ - delete+ - get+ - list+ - patch+ - update+ - watch+- apiGroups:+ - apps+ resources:+ - deployments+ verbs:+ - create+ - delete+ - get+ - list+ - patch+ - update+ - watch+- apiGroups:+ - networking.k8s.io+ resources:+ - networkpolicies+ verbs:+ - create+ - delete+ - get+ - list+ - patch+ - update+ - watch+- apiGroups:+ - openrag.io+ resources:+ - openrags+ verbs:+ - create+ - delete+ - get+ - list+ - patch+ - update+ - watch+- apiGroups:+ - openrag.io+ resources:+ - openrags/finalizers+ verbs:+ - update+- apiGroups:+ - openrag.io+ resources:+ - openrags/status+ verbs:+ - get+ - patch+ - updatediff --git a/kubernetes/operator/config/rbac/role_binding.yaml b/kubernetes/operator/config/rbac/role_binding.yamlnew file mode 100644index 000000000..2070ede44--- /dev/null+++ b/kubernetes/operator/config/rbac/role_binding.yaml@@ -0,0 +1,12 @@+apiVersion: rbac.authorization.k8s.io/v1+kind: ClusterRoleBinding+metadata:+ name: manager-rolebinding+roleRef:+ apiGroup: rbac.authorization.k8s.io+ kind: ClusterRole+ name: manager-role+subjects:+- kind: ServiceAccount+ name: controller-manager+ namespace: systemdiff --git a/kubernetes/operator/config/rbac/service_account.yaml b/kubernetes/operator/config/rbac/service_account.yamlnew file mode 100644index 000000000..7cd6025bf--- /dev/null+++ b/kubernetes/operator/config/rbac/service_account.yaml@@ -0,0 +1,5 @@+apiVersion: v1+kind: ServiceAccount+metadata:+ name: controller-manager+ namespace: systemdiff --git a/kubernetes/operator/config/samples/openrag_v1alpha1_openrag.yaml b/kubernetes/operator/config/samples/openrag_v1alpha1_openrag.yamlnew file mode 100644index 000000000..fce3e6eb1--- /dev/null+++ b/kubernetes/operator/config/samples/openrag_v1alpha1_openrag.yaml@@ -0,0 +1,69 @@+apiVersion: openrag.io/v1alpha1+kind: OpenRAG+metadata:+ name: my-openrag+ namespace: default+spec:+ # imagePullSecrets:+ # - name: my-registry-secret++ frontend:+ image: langflowai/openrag-frontend:latest+ resources:+ requests:+ cpu: "500m"+ memory: "512Mi"+ limits:+ cpu: "1"+ memory: "2Gi"++ backend:+ image: langflowai/openrag-backend:latest+ resources:+ requests:+ cpu: "500m"+ memory: "1Gi"+ limits:+ cpu: "2"+ memory: "8Gi"+ # envSecret: my-openrag-backend-env # Secret with ".env" key+ # jwtSigningKeySecret:+ # name: my-jwt-secret+ # key: JWT_SIGNING_KEY+ storage:+ enabled: true+ size: "10Gi"+ # storageClassName: standard++ langflow:+ image: langflowai/openrag-langflow:latest+ resources:+ requests:+ cpu: "500m"+ memory: "1Gi"+ limits:+ cpu: "4"+ memory: "8Gi"+ # envSecret: my-openrag-langflow-env # Secret with ".env" key+ storage:+ enabled: true+ size: "10Gi"+ # storageClassName: standard++ # External OpenSearch — required unless credentials are in backend envSecret+ opensearch:+ host: opensearch-coordinating.opensearch.svc.cluster.local+ port: 9200+ scheme: https+ indexName: documents+ credentialsSecret: opensearch-credentials # keys: username, password++ # External Docling — optional document conversion+ # docling:+ # host: docling-serve.docling.svc.cluster.local+ # port: 5001+ # scheme: http++ # Create a NetworkPolicy restricting Langflow egress+ networkPolicy:+ enabled: falsediff --git a/kubernetes/operator/go.mod b/kubernetes/operator/go.modnew file mode 100644index 000000000..820aeeaf4--- /dev/null+++ b/kubernetes/operator/go.mod@@ -0,0 +1,65 @@+module github.com/langflow-ai/openrag-operator++go 1.26.0++require (+ k8s.io/api v0.33.2+ k8s.io/apimachinery v0.33.2+ k8s.io/client-go v0.33.2+ sigs.k8s.io/controller-runtime v0.21.0+)++require (+ github.com/beorn7/perks v1.0.1 // indirect+ github.com/cespare/xxhash/v2 v2.3.0 // indirect+ github.com/davecgh/go-spew v1.1.1 // indirect+ github.com/emicklei/go-restful/v3 v3.11.0 // indirect+ github.com/evanphx/json-patch/v5 v5.9.11 // indirect+ github.com/fsnotify/fsnotify v1.7.0 // indirect+ github.com/fxamacker/cbor/v2 v2.7.0 // indirect+ github.com/go-logr/logr v1.4.2 // indirect+ github.com/go-logr/zapr v1.3.0 // indirect+ github.com/go-openapi/jsonpointer v0.21.0 // indirect+ github.com/go-openapi/jsonreference v0.20.2 // indirect+ github.com/go-openapi/swag v0.23.0 // indirect+ github.com/gogo/protobuf v1.3.2 // indirect+ github.com/google/btree v1.1.3 // indirect+ github.com/google/gnostic-models v0.6.9 // indirect+ github.com/google/go-cmp v0.7.0 // indirect+ github.com/google/uuid v1.6.0 // indirect+ github.com/josharian/intern v1.0.0 // indirect+ github.com/json-iterator/go v1.1.12 // indirect+ github.com/mailru/easyjson v0.7.7 // indirect+ github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect+ github.com/modern-go/reflect2 v1.0.2 // indirect+ github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect+ github.com/pkg/errors v0.9.1 // indirect+ github.com/prometheus/client_golang v1.22.0 // indirect+ github.com/prometheus/client_model v0.6.1 // indirect+ github.com/prometheus/common v0.62.0 // indirect+ github.com/prometheus/procfs v0.15.1 // indirect+ github.com/spf13/pflag v1.0.5 // indirect+ github.com/x448/float16 v0.8.4 // indirect+ go.uber.org/multierr v1.11.0 // indirect+ go.uber.org/zap v1.27.1 // indirect+ golang.org/x/net v0.38.0 // indirect+ golang.org/x/oauth2 v0.27.0 // indirect+ golang.org/x/sync v0.12.0 // indirect+ golang.org/x/sys v0.31.0 // indirect+ golang.org/x/term v0.30.0 // indirect+ golang.org/x/text v0.23.0 // indirect+ golang.org/x/time v0.9.0 // indirect+ gomodules.xyz/jsonpatch/v2 v2.4.0 // indirect+ google.golang.org/protobuf v1.36.5 // indirect+ gopkg.in/evanphx/json-patch.v4 v4.12.0 // indirect+ gopkg.in/inf.v0 v0.9.1 // indirect+ gopkg.in/yaml.v3 v3.0.1 // indirect+ k8s.io/apiextensions-apiserver v0.33.0 // indirect+ k8s.io/klog/v2 v2.130.1 // indirect+ k8s.io/kube-openapi v0.0.0-20250318190949-c8a335a9a2ff // indirect+ k8s.io/utils v0.0.0-20241104100929-3ea5e8cea738 // indirect+ sigs.k8s.io/json v0.0.0-20241010143419-9aa6b5e7a4b3 // indirect+ sigs.k8s.io/randfill v1.0.0 // indirect+ sigs.k8s.io/structured-merge-diff/v4 v4.6.0 // indirect+ sigs.k8s.io/yaml v1.4.0 // indirect+)diff --git a/kubernetes/operator/go.sum b/kubernetes/operator/go.sumnew file mode 100644index 000000000..dfd366168--- /dev/null+++ b/kubernetes/operator/go.sum@@ -0,0 +1,197 @@+github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=+github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=+github.com/blang/semver/v4 v4.0.0 h1:1PFHFE6yCCTv8C1TeyNNarDzntLi7wMI5i/pzqYIsAM=+github.com/blang/semver/v4 v4.0.0/go.mod h1:IbckMUScFkM3pff0VJDNKRiT6TG/YpiHIM2yvyW5YoQ=+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=+github.com/emicklei/go-restful/v3 v3.11.0 h1:rAQeMHw1c7zTmncogyy8VvRZwtkmkZ4FxERmMY4rD+g=+github.com/emicklei/go-restful/v3 v3.11.0/go.mod h1:6n3XBCmQQb25CM2LCACGz8ukIrRry+4bhvbpWn3mrbc=+github.com/evanphx/json-patch v0.5.2 h1:xVCHIVMUu1wtM/VkR9jVZ45N3FhZfYMMYGorLCR8P3k=+github.com/evanphx/json-patch v0.5.2/go.mod h1:ZWS5hhDbVDyob71nXKNL0+PWn6ToqBHMikGIFbs31qQ=+github.com/evanphx/json-patch/v5 v5.9.11 h1:/8HVnzMq13/3x9TPvjG08wUGqBTmZBsCWzjTM0wiaDU=+github.com/evanphx/json-patch/v5 v5.9.11/go.mod h1:3j+LviiESTElxA4p3EMKAB9HXj3/XEtnUf6OZxqIQTM=+github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=+github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=+github.com/fxamacker/cbor/v2 v2.7.0 h1:iM5WgngdRBanHcxugY4JySA0nk1wZorNOpTgCMedv5E=+github.com/fxamacker/cbor/v2 v2.7.0/go.mod h1:pxXPTn3joSm21Gbwsv0w9OSA2y1HFR9qXEeXQVeNoDQ=+github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=+github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=+github.com/go-logr/zapr v1.3.0 h1:XGdV8XW8zdwFiwOA2Dryh1gj2KRQyOOoNmBy4EplIcQ=+github.com/go-logr/zapr v1.3.0/go.mod h1:YKepepNBd1u/oyhd/yQmtjVXmm9uML4IXUgMOwR8/Gg=+github.com/go-openapi/jsonpointer v0.19.6/go.mod h1:osyAmYz/mB/C3I+WsTTSgw1ONzaLJoLCyoi6/zppojs=+github.com/go-openapi/jsonpointer v0.21.0 h1:YgdVicSA9vH5RiHs9TZW5oyafXZFc6+2Vc1rr/O9oNQ=+github.com/go-openapi/jsonpointer v0.21.0/go.mod h1:IUyH9l/+uyhIYQ/PXVA41Rexl+kOkAPDdXEYns6fzUY=+github.com/go-openapi/jsonreference v0.20.2 h1:3sVjiK66+uXK/6oQ8xgcRKcFgQ5KXa2KvnJRumpMGbE=+github.com/go-openapi/jsonreference v0.20.2/go.mod h1:Bl1zwGIM8/wsvqjsOQLJ/SH+En5Ap4rVB5KVcIDZG2k=+github.com/go-openapi/swag v0.22.3/go.mod h1:UzaqsxGiab7freDnrUUra0MwWfN/q7tE4j+VcZ0yl14=+github.com/go-openapi/swag v0.23.0 h1:vsEVJDUo2hPJ2tu0/Xc+4noaxyEffXNIs3cOULZ+GrE=+github.com/go-openapi/swag v0.23.0/go.mod h1:esZ8ITTYEsH1V2trKHjAN8Ai7xHb8RV+YSZ577vPjgQ=+github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI=+github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8=+github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=+github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=+github.com/google/btree v1.1.3 h1:CVpQJjYgC4VbzxeGVHfvZrv1ctoYCAI8vbl07Fcxlyg=+github.com/google/btree v1.1.3/go.mod h1:qOPhT0dTNdNzV6Z/lhRX0YXUafgPLFUh+gZMl761Gm4=+github.com/google/gnostic-models v0.6.9 h1:MU/8wDLif2qCXZmzncUQ/BOfxWfthHi63KqpoNbWqVw=+github.com/google/gnostic-models v0.6.9/go.mod h1:CiWsm0s6BSQd1hRn8/QmxqB6BesYcbSZxsz9b0KuDBw=+github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=+github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0=+github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=+github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db h1:097atOisP2aRj7vFgYQBbFN4U4JNXUNYpxael3UzMyo=+github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db/go.mod h1:vavhavw2zAxS5dIdcRluK6cSGGPlZynqzFM8NdvU144=+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=+github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=+github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=+github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=+github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=+github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=+github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=+github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=+github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=+github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=+github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=+github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=+github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=+github.com/onsi/ginkgo/v2 v2.22.0 h1:Yed107/8DjTr0lKCNt7Dn8yQ6ybuDRQoMGrNFKzMfHg=+github.com/onsi/ginkgo/v2 v2.22.0/go.mod h1:7Du3c42kxCUegi0IImZ1wUQzMBVecgIHjR1C+NkhLQo=+github.com/onsi/gomega v1.36.1 h1:bJDPBO7ibjxcbHMgSCoo4Yj18UWbKDlLwX1x9sybDcw=+github.com/onsi/gomega v1.36.1/go.mod h1:PvZbdDc8J6XJEpDK4HCuRBm8a6Fzp9/DmhC9C7yFlog=+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=+github.com/prometheus/client_golang v1.22.0 h1:rb93p9lokFEsctTys46VnV1kLCDpVZ0a/Y92Vm0Zc6Q=+github.com/prometheus/client_golang v1.22.0/go.mod h1:R7ljNsLXhuQXYZYtw6GAE9AZg8Y7vEW5scdCXrWRXC0=+github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=+github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=+github.com/prometheus/common v0.62.0 h1:xasJaQlnWAeyHdUBeGjXmutelfJHWMRr+Fg4QszZ2Io=+github.com/prometheus/common v0.62.0/go.mod h1:vyBcEuLSvWos9B1+CyL7JZ2up+uFzXhkqml0W5zIY1I=+github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc=+github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk=+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=+github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=+github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=+github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM=+github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg=+github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=+github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=+go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=+go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=+go.uber.org/zap v1.27.1 h1:08RqriUEv8+ArZRYSTXy1LeBScaMpVSTBhCeaZYfMYc=+go.uber.org/zap v1.27.1/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=+golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=+golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=+golang.org/x/net v0.38.0 h1:vRMAPTMaeGqVhG5QyLJHqNDwecKTomGeqbnfZyKlBI8=+golang.org/x/net v0.38.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8=+golang.org/x/oauth2 v0.27.0 h1:da9Vo7/tDv5RH/7nZDz1eMGS/q1Vv1N/7FCrBhI9I3M=+golang.org/x/oauth2 v0.27.0/go.mod h1:onh5ek6nERTohokkhCD/y2cV4Do3fxFHFuAejCkRWT8=+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=+golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=+golang.org/x/sync v0.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw=+golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=+golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=+golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=+golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=+golang.org/x/term v0.30.0 h1:PQ39fJZ+mfadBm0y5WlL4vlM7Sx1Hgf13sMIY2+QS9Y=+golang.org/x/term v0.30.0/go.mod h1:NYYFdzHoI5wRh/h5tDMdMqCqPJZEuNqVR5xJLd/n67g=+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=+golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=+golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=+golang.org/x/time v0.9.0 h1:EsRrnYcQiGH+5FfbgvV4AP7qEZstoyrHB0DzarOQ4ZY=+golang.org/x/time v0.9.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=+golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=+golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=+golang.org/x/tools v0.26.0 h1:v/60pFQmzmT9ExmjDv2gGIfi3OqfKoEP6I5+umXlbnQ=+golang.org/x/tools v0.26.0/go.mod h1:TPVVj70c7JJ3WCazhD8OdXcZg/og+b9+tH/KxylGwH0=+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=+gomodules.xyz/jsonpatch/v2 v2.4.0 h1:Ci3iUJyx9UeRx7CeFN8ARgGbkESwJK+KB9lLcWxY/Zw=+gomodules.xyz/jsonpatch/v2 v2.4.0/go.mod h1:AH3dM2RI6uoBZxn3LVrfvJ3E0/9dG4cSrbuBJT4moAY=+google.golang.org/protobuf v1.36.5 h1:tPhr+woSbjfYvY6/GPufUoYizxw1cF/yFoxJ2fmpwlM=+google.golang.org/protobuf v1.36.5/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=+gopkg.in/evanphx/json-patch.v4 v4.12.0 h1:n6jtcsulIzXPJaxegRbvFNNrZDjbij7ny3gmSPG+6V4=+gopkg.in/evanphx/json-patch.v4 v4.12.0/go.mod h1:p8EYWUEYMpynmqDbY58zCKCFZw8pRWMG4EsWvDvM72M=+gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc=+gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw=+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=+k8s.io/api v0.33.2 h1:YgwIS5jKfA+BZg//OQhkJNIfie/kmRsO0BmNaVSimvY=+k8s.io/api v0.33.2/go.mod h1:fhrbphQJSM2cXzCWgqU29xLDuks4mu7ti9vveEnpSXs=+k8s.io/apiextensions-apiserver v0.33.0 h1:d2qpYL7Mngbsc1taA4IjJPRJ9ilnsXIrndH+r9IimOs=+k8s.io/apiextensions-apiserver v0.33.0/go.mod h1:VeJ8u9dEEN+tbETo+lFkwaaZPg6uFKLGj5vyNEwwSzc=+k8s.io/apimachinery v0.33.2 h1:IHFVhqg59mb8PJWTLi8m1mAoepkUNYmptHsV+Z1m5jY=+k8s.io/apimachinery v0.33.2/go.mod h1:BHW0YOu7n22fFv/JkYOEfkUYNRN0fj0BlvMFWA7b+SM=+k8s.io/client-go v0.33.2 h1:z8CIcc0P581x/J1ZYf4CNzRKxRvQAwoAolYPbtQes+E=+k8s.io/client-go v0.33.2/go.mod h1:9mCgT4wROvL948w6f6ArJNb7yQd7QsvqavDeZHvNmHo=+k8s.io/klog/v2 v2.130.1 h1:n9Xl7H1Xvksem4KFG4PYbdQCQxqc/tTUyrgXaOhHSzk=+k8s.io/klog/v2 v2.130.1/go.mod h1:3Jpz1GvMt720eyJH1ckRHK1EDfpxISzJ7I9OYgaDtPE=+k8s.io/kube-openapi v0.0.0-20250318190949-c8a335a9a2ff h1:/usPimJzUKKu+m+TE36gUyGcf03XZEP0ZIKgKj35LS4=+k8s.io/kube-openapi v0.0.0-20250318190949-c8a335a9a2ff/go.mod h1:5jIi+8yX4RIb8wk3XwBo5Pq2ccx4FP10ohkbSKCZoK8=+k8s.io/utils v0.0.0-20241104100929-3ea5e8cea738 h1:M3sRQVHv7vB20Xc2ybTt7ODCeFj6JSWYFzOFnYeS6Ro=+k8s.io/utils v0.0.0-20241104100929-3ea5e8cea738/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0=+sigs.k8s.io/controller-runtime v0.21.0 h1:CYfjpEuicjUecRk+KAeyYh+ouUBn4llGyDYytIGcJS8=+sigs.k8s.io/controller-runtime v0.21.0/go.mod h1:OSg14+F65eWqIu4DceX7k/+QRAbTTvxeQSNSOQpukWM=+sigs.k8s.io/json v0.0.0-20241010143419-9aa6b5e7a4b3 h1:/Rv+M11QRah1itp8VhT6HoVx1Ray9eB4DBr+K+/sCJ8=+sigs.k8s.io/json v0.0.0-20241010143419-9aa6b5e7a4b3/go.mod h1:18nIHnGi6636UCz6m8i4DhaJ65T6EruyzmoQqI2BVDo=+sigs.k8s.io/randfill v0.0.0-20250304075658-069ef1bbf016/go.mod h1:XeLlZ/jmk4i1HRopwe7/aU3H5n1zNUcX6TM94b3QxOY=+sigs.k8s.io/randfill v1.0.0 h1:JfjMILfT8A6RbawdsK2JXGBR5AQVfd+9TbzrlneTyrU=+sigs.k8s.io/randfill v1.0.0/go.mod h1:XeLlZ/jmk4i1HRopwe7/aU3H5n1zNUcX6TM94b3QxOY=+sigs.k8s.io/structured-merge-diff/v4 v4.6.0 h1:IUA9nvMmnKWcj5jl84xn+T5MnlZKThmUW1TdblaLVAc=+sigs.k8s.io/structured-merge-diff/v4 v4.6.0/go.mod h1:dDy58f92j70zLsuZVuUX5Wp9vtxXpaZnkPGWeqDfCps=+sigs.k8s.io/yaml v1.4.0 h1:Mk1wCc2gy/F0THH0TAp1QYyJNzRm2KCLy3o5ASXVI5E=+sigs.k8s.io/yaml v1.4.0/go.mod h1:Ejl7/uTz7PSA4eKMyQCUTnhZYNmLIl+5c2lQPGR2BPY=diff --git a/kubernetes/operator/hack/boilerplate.go.txt b/kubernetes/operator/hack/boilerplate.go.txtnew file mode 100644index 000000000..22fa92f34--- /dev/null+++ b/kubernetes/operator/hack/boilerplate.go.txt@@ -0,0 +1,15 @@+/*+Copyright 2025 The OpenRAG Authors.++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.+*/diff --git a/kubernetes/operator/internal/controller/openrag_controller.go b/kubernetes/operator/internal/controller/openrag_controller.gonew file mode 100644index 000000000..b5aa05a75--- /dev/null+++ b/kubernetes/operator/internal/controller/openrag_controller.go@@ -0,0 +1,453 @@+package controller++import (+ "context"+ "fmt"++ appsv1 "k8s.io/api/apps/v1"+ corev1 "k8s.io/api/core/v1"+ networkingv1 "k8s.io/api/networking/v1"+ "k8s.io/apimachinery/pkg/api/errors"+ metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"+ "k8s.io/apimachinery/pkg/runtime"+ "k8s.io/apimachinery/pkg/util/intstr"+ ctrl "sigs.k8s.io/controller-runtime"+ "sigs.k8s.io/controller-runtime/pkg/client"+ "sigs.k8s.io/controller-runtime/pkg/log"++ openragv1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"+)++// OpenRAGReconciler reconciles an OpenRAG object.+type OpenRAGReconciler struct {+ client.Client+ Scheme *runtime.Scheme+}++// +kubebuilder:rbac:groups=openrag.io,resources=openrags,verbs=get;list;watch;create;update;patch;delete+// +kubebuilder:rbac:groups=openrag.io,resources=openrags/status,verbs=get;update;patch+// +kubebuilder:rbac:groups=openrag.io,resources=openrags/finalizers,verbs=update+// +kubebuilder:rbac:groups=apps,resources=deployments,verbs=get;list;watch;create;update;patch;delete+// +kubebuilder:rbac:groups=core,resources=services,verbs=get;list;watch;create;update;patch;delete+// +kubebuilder:rbac:groups=core,resources=serviceaccounts,verbs=get;list;watch;create;update;patch;delete+// +kubebuilder:rbac:groups=core,resources=secrets,verbs=get;list;watch;create;update;patch;delete+// +kubebuilder:rbac:groups=core,resources=persistentvolumeclaims,verbs=get;list;watch;create;update;patch;delete+// +kubebuilder:rbac:groups=networking.k8s.io,resources=networkpolicies,verbs=get;list;watch;create;update;patch;delete++func (r *OpenRAGReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {+ logger := log.FromContext(ctx)++ instance := &openragv1alpha1.OpenRAG{}+ if err := r.Get(ctx, req.NamespacedName, instance); err != nil {+ if errors.IsNotFound(err) {+ return ctrl.Result{}, nil+ }+ return ctrl.Result{}, err+ }++ if err := r.reconcileServiceAccounts(ctx, instance); err != nil {+ return ctrl.Result{}, fmt.Errorf("service accounts: %w", err)+ }+ if err := r.reconcileServices(ctx, instance); err != nil {+ return ctrl.Result{}, fmt.Errorf("services: %w", err)+ }+ if err := r.reconcileDeployments(ctx, instance); err != nil {+ return ctrl.Result{}, fmt.Errorf("deployments: %w", err)+ }+ if instance.Spec.NetworkPolicy.Enabled {+ if err := r.reconcileNetworkPolicy(ctx, instance); err != nil {+ return ctrl.Result{}, fmt.Errorf("network policy: %w", err)+ }+ }++ logger.Info("reconciled OpenRAG instance", "name", instance.Name)+ return ctrl.Result{}, nil+}++func (r *OpenRAGReconciler) reconcileServiceAccounts(ctx context.Context, o *openragv1alpha1.OpenRAG) error {+ for _, role := range []string{"fe", "be", "lf"} {+ sa := &corev1.ServiceAccount{+ ObjectMeta: metav1.ObjectMeta{+ Name: saName(o.Name, role),+ Namespace: o.Namespace,+ Labels: componentLabels(o.Name, role),+ },+ }+ if err := ctrl.SetControllerReference(o, sa, r.Scheme); err != nil {+ return err+ }+ if err := r.createOrUpdate(ctx, sa); err != nil {+ return err+ }+ }+ return nil+}++func (r *OpenRAGReconciler) reconcileServices(ctx context.Context, o *openragv1alpha1.OpenRAG) error {+ type svcDef struct {+ role string+ port int32+ }+ defs := []svcDef{+ {"fe", 3000},+ {"be", 8000},+ {"lf", 7860},+ }+ for _, d := range defs {+ svc := &corev1.Service{+ ObjectMeta: metav1.ObjectMeta{+ Name: resourceName(o.Name, d.role),+ Namespace: o.Namespace,+ Labels: componentLabels(o.Name, d.role),+ },+ Spec: corev1.ServiceSpec{+ Type: corev1.ServiceTypeClusterIP,+ Selector: componentLabels(o.Name, d.role),+ Ports: []corev1.ServicePort{+ {Name: "http", Port: d.port, Protocol: corev1.ProtocolTCP},+ },+ },+ }+ if err := ctrl.SetControllerReference(o, svc, r.Scheme); err != nil {+ return err+ }+ if err := r.createOrUpdate(ctx, svc); err != nil {+ return err+ }+ }+ return nil+}++func (r *OpenRAGReconciler) reconcileDeployments(ctx context.Context, o *openragv1alpha1.OpenRAG) error {+ deploys := []client.Object{+ r.frontendDeployment(o),+ r.backendDeployment(o),+ r.langflowDeployment(o),+ }+ for _, d := range deploys {+ if err := ctrl.SetControllerReference(o, d, r.Scheme); err != nil {+ return err+ }+ if err := r.createOrUpdate(ctx, d); err != nil {+ return err+ }+ }+ return nil+}++func (r *OpenRAGReconciler) frontendDeployment(o *openragv1alpha1.OpenRAG) *appsv1.Deployment {+ spec := o.Spec.Frontend+ replicas := replicasOrDefault(spec.Replicas)+ return &appsv1.Deployment{+ ObjectMeta: metav1.ObjectMeta{+ Name: resourceName(o.Name, "fe"),+ Namespace: o.Namespace,+ Labels: componentLabels(o.Name, "fe"),+ },+ Spec: appsv1.DeploymentSpec{+ Replicas: &replicas,+ Selector: &metav1.LabelSelector{MatchLabels: componentLabels(o.Name, "fe")},+ Strategy: appsv1.DeploymentStrategy{Type: appsv1.RecreateDeploymentStrategyType},+ Template: corev1.PodTemplateSpec{+ ObjectMeta: metav1.ObjectMeta{Labels: componentLabels(o.Name, "fe")},+ Spec: corev1.PodSpec{+ ServiceAccountName: saName(o.Name, "fe"),+ ImagePullSecrets: o.Spec.ImagePullSecrets,+ NodeSelector: spec.NodeSelector,+ Tolerations: spec.Tolerations,+ Affinity: spec.Affinity,+ Containers: []corev1.Container{+ {+ Name: "frontend",+ Image: spec.Image,+ ImagePullPolicy: spec.ImagePullPolicy,+ Ports: []corev1.ContainerPort{{Name: "http", ContainerPort: 3000}},+ Env: append([]corev1.EnvVar{+ {Name: "OPENRAG_BACKEND_HOST", Value: resourceName(o.Name, "be")},+ }, spec.Env...),+ Resources: spec.Resources,+ LivenessProbe: httpProbe("/", 3000, 30, 10),+ ReadinessProbe: httpProbe("/", 3000, 10, 5),+ },+ },+ },+ },+ },+ }+}++func (r *OpenRAGReconciler) backendDeployment(o *openragv1alpha1.OpenRAG) *appsv1.Deployment {+ spec := o.Spec.Backend+ replicas := replicasOrDefault(spec.Replicas)++ var volumes []corev1.Volume+ var mounts []corev1.VolumeMount++ mounts = append(mounts, corev1.VolumeMount{Name: "backend-temp", MountPath: "/tmp"})+ volumes = append(volumes, corev1.Volume{+ Name: "backend-temp",+ VolumeSource: corev1.VolumeSource{EmptyDir: &corev1.EmptyDirVolumeSource{}},+ })++ if spec.EnvSecret != "" {+ volumes = append(volumes, corev1.Volume{+ Name: "backend-env",+ VolumeSource: corev1.VolumeSource{+ Secret: &corev1.SecretVolumeSource{SecretName: spec.EnvSecret},+ },+ })+ mounts = append(mounts, corev1.VolumeMount{+ Name: "backend-env", MountPath: "/app/.env", SubPath: ".env", ReadOnly: true,+ })+ }++ var envVars []corev1.EnvVar+ if spec.JWTSigningKeySecret != nil {+ envVars = append(envVars, corev1.EnvVar{+ Name: "JWT_SIGNING_KEY",+ ValueFrom: &corev1.EnvVarSource{SecretKeyRef: spec.JWTSigningKeySecret},+ })+ }+ envVars = append(envVars, spec.Env...)++ return &appsv1.Deployment{+ ObjectMeta: metav1.ObjectMeta{+ Name: resourceName(o.Name, "be"),+ Namespace: o.Namespace,+ Labels: componentLabels(o.Name, "be"),+ },+ Spec: appsv1.DeploymentSpec{+ Replicas: &replicas,+ Selector: &metav1.LabelSelector{MatchLabels: componentLabels(o.Name, "be")},+ Strategy: appsv1.DeploymentStrategy{Type: appsv1.RecreateDeploymentStrategyType},+ Template: corev1.PodTemplateSpec{+ ObjectMeta: metav1.ObjectMeta{Labels: componentLabels(o.Name, "be")},+ Spec: corev1.PodSpec{+ ServiceAccountName: saName(o.Name, "be"),+ ImagePullSecrets: o.Spec.ImagePullSecrets,+ NodeSelector: spec.NodeSelector,+ Tolerations: spec.Tolerations,+ Affinity: spec.Affinity,+ Volumes: volumes,+ Containers: []corev1.Container{+ {+ Name: "backend",+ Image: spec.Image,+ ImagePullPolicy: spec.ImagePullPolicy,+ Ports: []corev1.ContainerPort{{Name: "http", ContainerPort: 8000}},+ Env: envVars,+ Resources: spec.Resources,+ VolumeMounts: mounts,+ LivenessProbe: httpProbe("/health", 8000, 45, 30),+ ReadinessProbe: httpProbe("/health", 8000, 45, 10),+ },+ },+ },+ },+ },+ }+}++func (r *OpenRAGReconciler) langflowDeployment(o *openragv1alpha1.OpenRAG) *appsv1.Deployment {+ spec := o.Spec.Langflow+ replicas := replicasOrDefault(spec.Replicas)++ var volumes []corev1.Volume+ var mounts []corev1.VolumeMount++ mounts = append(mounts, corev1.VolumeMount{Name: "langflow-temp", MountPath: "/tmp"})+ volumes = append(volumes, corev1.Volume{+ Name: "langflow-temp",+ VolumeSource: corev1.VolumeSource{EmptyDir: &corev1.EmptyDirVolumeSource{}},+ })++ if spec.EnvSecret != "" {+ volumes = append(volumes, corev1.Volume{+ Name: "langflow-env",+ VolumeSource: corev1.VolumeSource{+ Secret: &corev1.SecretVolumeSource{SecretName: spec.EnvSecret},+ },+ })+ mounts = append(mounts, corev1.VolumeMount{+ Name: "langflow-env", MountPath: "/app/.env", SubPath: ".env", ReadOnly: true,+ })+ }++ if spec.Storage != nil && spec.Storage.Enabled {+ pvcName := resourceName(o.Name, "lf-data")+ if spec.Storage.ExistingClaim != "" {+ pvcName = spec.Storage.ExistingClaim+ }+ volumes = append(volumes, corev1.Volume{+ Name: "langflow-data",+ VolumeSource: corev1.VolumeSource{+ PersistentVolumeClaim: &corev1.PersistentVolumeClaimVolumeSource{ClaimName: pvcName},+ },+ })+ mounts = append(mounts, corev1.VolumeMount{Name: "langflow-data", MountPath: "/app/data"})+ }++ return &appsv1.Deployment{+ ObjectMeta: metav1.ObjectMeta{+ Name: resourceName(o.Name, "lf"),+ Namespace: o.Namespace,+ Labels: componentLabels(o.Name, "lf"),+ },+ Spec: appsv1.DeploymentSpec{+ Replicas: &replicas,+ Selector: &metav1.LabelSelector{MatchLabels: componentLabels(o.Name, "lf")},+ Strategy: appsv1.DeploymentStrategy{Type: appsv1.RecreateDeploymentStrategyType},+ Template: corev1.PodTemplateSpec{+ ObjectMeta: metav1.ObjectMeta{Labels: componentLabels(o.Name, "lf")},+ Spec: corev1.PodSpec{+ ServiceAccountName: saName(o.Name, "lf"),+ ImagePullSecrets: o.Spec.ImagePullSecrets,+ NodeSelector: spec.NodeSelector,+ Tolerations: spec.Tolerations,+ Affinity: spec.Affinity,+ Volumes: volumes,+ Containers: []corev1.Container{+ {+ Name: "langflow",+ Image: spec.Image,+ ImagePullPolicy: spec.ImagePullPolicy,+ Args: []string{"run", "--env-file", "/app/.env"},+ Command: []string{"langflow"},+ Ports: []corev1.ContainerPort{{Name: "http", ContainerPort: 7860}},+ Env: spec.Env,+ Resources: spec.Resources,+ VolumeMounts: mounts,+ LivenessProbe: httpProbe("/health", 7860, 120, 30),+ ReadinessProbe: httpProbe("/health", 7860, 120, 30),+ },+ },+ },+ },+ },+ }+}++func (r *OpenRAGReconciler) reconcileNetworkPolicy(ctx context.Context, o *openragv1alpha1.OpenRAG) error {+ labels := componentLabels(o.Name, "lf")++ egress := []networkingv1.NetworkPolicyEgressRule{+ // langflow -> itself+ {+ Ports: []networkingv1.NetworkPolicyPort{tcpPort(7860)},+ To: []networkingv1.NetworkPolicyPeer{{PodSelector: &metav1.LabelSelector{MatchLabels: labels}}},+ },+ // DNS+ {Ports: []networkingv1.NetworkPolicyPort{udpPort(53), tcpPort(53)}},+ // OpenSearch + external HTTPS+ {Ports: []networkingv1.NetworkPolicyPort{tcpPort(9200), tcpPort(443)}},+ }++ if o.Spec.Docling != nil {+ egress = append(egress, networkingv1.NetworkPolicyEgressRule{+ Ports: []networkingv1.NetworkPolicyPort{tcpPort(int32(o.Spec.Docling.Port))},+ })+ }++ np := &networkingv1.NetworkPolicy{+ ObjectMeta: metav1.ObjectMeta{+ Name: resourceName(o.Name, "lf-netpol"),+ Namespace: o.Namespace,+ Labels: labels,+ },+ Spec: networkingv1.NetworkPolicySpec{+ PodSelector: metav1.LabelSelector{MatchLabels: labels},+ PolicyTypes: []networkingv1.PolicyType{networkingv1.PolicyTypeIngress, networkingv1.PolicyTypeEgress},+ Ingress: []networkingv1.NetworkPolicyIngressRule{+ {From: []networkingv1.NetworkPolicyPeer{+ {IPBlock: &networkingv1.IPBlock{CIDR: "10.0.0.0/8"}},+ {IPBlock: &networkingv1.IPBlock{CIDR: "172.16.0.0/12"}},+ {IPBlock: &networkingv1.IPBlock{CIDR: "192.168.0.0/16"}},+ }},+ },+ Egress: egress,+ },+ }+ if err := ctrl.SetControllerReference(o, np, r.Scheme); err != nil {+ return err+ }+ return r.createOrUpdate(ctx, np)+}++func (r *OpenRAGReconciler) createOrUpdate(ctx context.Context, obj client.Object) error {+ existing := obj.DeepCopyObject().(client.Object)+ err := r.Get(ctx, client.ObjectKeyFromObject(obj), existing)+ if errors.IsNotFound(err) {+ return r.Create(ctx, obj)+ }+ if err != nil {+ return err+ }+ obj.SetResourceVersion(existing.GetResourceVersion())+ return r.Update(ctx, obj)+}++// SetupWithManager registers the controller with the manager.+func (r *OpenRAGReconciler) SetupWithManager(mgr ctrl.Manager) error {+ return ctrl.NewControllerManagedBy(mgr).+ For(&openragv1alpha1.OpenRAG{}).+ Owns(&appsv1.Deployment{}).+ Owns(&corev1.Service{}).+ Owns(&corev1.ServiceAccount{}).+ Owns(&networkingv1.NetworkPolicy{}).+ Complete(r)+}++// helpers++func resourceName(crName, role string) string {+ return crName + "-openrag-" + role+}++func saName(crName, role string) string {+ return "openrag-" + crName + "-" + role+}++func componentLabels(crName, role string) map[string]string {+ return map[string]string{+ "app.kubernetes.io/name": "openrag",+ "app.kubernetes.io/instance": crName,+ "app.kubernetes.io/component": role,+ "app.kubernetes.io/managed-by": "openrag-operator",+ }+}++func replicasOrDefault(r *int32) int32 {+ if r != nil {+ return *r+ }+ return 1+}++func httpProbe(path string, port, initialDelay, period int32) *corev1.Probe {+ portVal := intstr.FromInt32(port)+ return &corev1.Probe{+ ProbeHandler: corev1.ProbeHandler{+ HTTPGet: &corev1.HTTPGetAction{+ Path: path,+ Port: portVal,+ Scheme: corev1.URISchemeHTTP,+ },+ },+ InitialDelaySeconds: initialDelay,+ PeriodSeconds: period,+ FailureThreshold: 5,+ TimeoutSeconds: 10,+ }+}++func tcpPort(p int32) networkingv1.NetworkPolicyPort {+ proto := corev1.ProtocolTCP+ v := intstr.FromInt32(p)+ return networkingv1.NetworkPolicyPort{Port: &v, Protocol: &proto}+}++func udpPort(p int32) networkingv1.NetworkPolicyPort {+ proto := corev1.ProtocolUDP+ v := intstr.FromInt32(p)+ return networkingv1.NetworkPolicyPort{Port: &v, Protocol: &proto}+}