Skip to content

OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.

Python

feat: Operator config and new domain name (#1509)

mingcb5acc049792
diff --git a/.github/workflows/operator-ci.yml b/.github/workflows/operator-ci.yml
index 2c72188f9..612483d3f 100644
--- a/.github/workflows/operator-ci.yml
+++ b/.github/workflows/operator-ci.yml
@@ -54,6 +54,9 @@ jobs:
./bin/controller-gen object:headerFile="hack/boilerplate.go.txt" paths="./..."
git diff --exit-code api/
+ - name: go test
+ run: go test ./... -race -coverprofile=cover.out
+
- name: golangci-lint
uses: golangci/golangci-lint-action@v7
with:
diff --git a/kubernetes/operator/PROJECT b/kubernetes/operator/PROJECT
index 1fafb9457..e5bd12dbe 100644
--- a/kubernetes/operator/PROJECT
+++ b/kubernetes/operator/PROJECT
@@ -2,7 +2,7 @@
# 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
+domain: openr.ag
layout:
- go.kubebuilder.io/v4
projectName: openrag-operator
@@ -12,7 +12,7 @@ resources:
crdVersion: v1
namespaced: true
controller: true
- domain: openrag.io
+ domain: openr.ag
group: openrag
kind: OpenRAG
path: github.com/langflow-ai/openrag-operator/api/v1alpha1
diff --git a/kubernetes/operator/README.md b/kubernetes/operator/README.md
index f41726b2a..f8d04b4a6 100644
--- a/kubernetes/operator/README.md
+++ b/kubernetes/operator/README.md
@@ -9,6 +9,50 @@ External dependencies (OpenSearch, Docling) are referenced by connection config
- Go 1.26.0 (`gvm use go1.26.0`)
- kubectl pointed at a cluster
+## Local development cluster (kind + podman)
+
+### 1. Start the podman machine
+
+```bash
+podman machine start
+```
+
+### 2. Configure kind to use podman
+
+```bash
+export KIND_EXPERIMENTAL_PROVIDER=podman
+```
+
+Add this to your shell profile (`~/.zshrc` or `~/.bashrc`) to make it permanent.
+
+### 3. Create the cluster
+
+```bash
+kind create cluster --name openrag
+```
+
+Verify it is running:
+
+```bash
+kubectl cluster-info --context kind-openrag
+kubectl get nodes
+```
+
+### 4. Load a locally built operator image (optional)
+
+If you built the image locally instead of pulling from GHCR:
+
+```bash
+make docker-build IMG=openrag-operator:dev
+podman save openrag-operator:dev | kind load image-archive /dev/stdin --name openrag
+```
+
+### 5. Tear down
+
+```bash
+kind delete cluster --name openrag
+```
+
## Quick start
```bash
@@ -30,7 +74,7 @@ kubectl get openrag
## CR overview
```yaml
-apiVersion: openrag.io/v1alpha1
+apiVersion: openr.ag/v1alpha1
kind: OpenRAG
metadata:
name: my-openrag
diff --git a/kubernetes/operator/api/v1alpha1/groupversion_info.go b/kubernetes/operator/api/v1alpha1/groupversion_info.go
index bd038bd81..50ab17b42 100644
--- a/kubernetes/operator/api/v1alpha1/groupversion_info.go
+++ b/kubernetes/operator/api/v1alpha1/groupversion_info.go
@@ -1,6 +1,6 @@
-// Package v1alpha1 contains API Schema definitions for the openrag.io v1alpha1 API group.
+// Package v1alpha1 contains API Schema definitions for the openr.ag v1alpha1 API group.
// +kubebuilder:object:generate=true
-// +groupName=openrag.io
+// +groupName=openr.ag
package v1alpha1
import (
@@ -9,7 +9,7 @@ import (
)
var (
- GroupVersion = schema.GroupVersion{Group: "openrag.io", Version: "v1alpha1"}
+ GroupVersion = schema.GroupVersion{Group: "openr.ag", 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.go
index 02c65d418..444dc7686 100644
--- a/kubernetes/operator/api/v1alpha1/openrag_types.go
+++ b/kubernetes/operator/api/v1alpha1/openrag_types.go
@@ -149,6 +149,14 @@ type NetworkPolicySpec struct {
// OpenRAGSpec defines the desired state of an OpenRAG instance.
type OpenRAGSpec struct {
+ // TargetNamespace is the namespace where all OpenRAG resources (deployments,
+ // services, service accounts) are created. The operator creates this namespace
+ // if it does not exist and deletes it when the CR is deleted.
+ // Defaults to the namespace of the CR itself. Cannot be "default".
+ // +optional
+ // +kubebuilder:validation:XValidation:rule="self != 'default'",message="targetNamespace must not be 'default'"
+ TargetNamespace string `json:"targetNamespace,omitempty"`
+
// ImagePullSecrets for private registries, applied to all component pods.
// +optional
ImagePullSecrets []corev1.LocalObjectReference `json:"imagePullSecrets,omitempty"`
diff --git a/kubernetes/operator/cmd/main.go b/kubernetes/operator/cmd/main.go
index 8b5bc0894..c834f6aed 100644
--- a/kubernetes/operator/cmd/main.go
+++ b/kubernetes/operator/cmd/main.go
@@ -16,6 +16,7 @@ import (
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/config"
"github.com/langflow-ai/openrag-operator/internal/controller"
)
@@ -33,35 +34,26 @@ func init() {
}
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.")
+ cfg := config.NewOperatorConfig()
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",
+ Metrics: metricsserver.Options{BindAddress: cfg.MetricsBindAddress},
+ HealthProbeBindAddress: cfg.HealthProbeBindAddress,
+ LeaderElection: cfg.LeaderElectionEnabled,
+ LeaderElectionID: "openrag-operator.openr.ag",
})
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 {
+ err = controller.NewOpenRAGReconciler(mgr.GetClient(), mgr.GetScheme()).SetupWithManager(mgr)
+ if err != nil {
setupLog.Error(err, "unable to create controller", "controller", "OpenRAG")
os.Exit(1)
}
diff --git a/kubernetes/operator/config/crd/bases/openrag.io_openrags.yaml b/kubernetes/operator/config/crd/bases/openr.ag_openrags.yaml
similarity index 99%
rename from kubernetes/operator/config/crd/bases/openrag.io_openrags.yaml
rename to kubernetes/operator/config/crd/bases/openr.ag_openrags.yaml
index 93e162463..41f5d13ff 100644
--- a/kubernetes/operator/config/crd/bases/openrag.io_openrags.yaml
+++ b/kubernetes/operator/config/crd/bases/openr.ag_openrags.yaml
@@ -4,9 +4,9 @@ kind: CustomResourceDefinition
metadata:
annotations:
controller-gen.kubebuilder.io/version: v0.16.4
- name: openrags.openrag.io
+ name: openrags.openr.ag
spec:
- group: openrag.io
+ group: openr.ag
names:
kind: OpenRAG
listKind: OpenRAGList
@@ -3693,6 +3693,16 @@ spec:
required:
- host
type: object
+ targetNamespace:
+ description: |-
+ TargetNamespace is the namespace where all OpenRAG resources (deployments,
+ services, service accounts) are created. The operator creates this namespace
+ if it does not exist and deletes it when the CR is deleted.
+ Defaults to the namespace of the CR itself. Cannot be "default".
+ type: string
+ x-kubernetes-validations:
+ - message: targetNamespace must not be 'default'
+ rule: self != 'default'
required:
- backend
- frontend
diff --git a/kubernetes/operator/config/crd/kustomization.yaml b/kubernetes/operator/config/crd/kustomization.yaml
index 6737d1d1d..946d421b9 100644
--- a/kubernetes/operator/config/crd/kustomization.yaml
+++ b/kubernetes/operator/config/crd/kustomization.yaml
@@ -1,5 +1,5 @@
resources:
-- bases/openrag.io_openrags.yaml
+- bases/openr.ag_openrags.yaml
#+kubebuilder:scaffold:crdkustomizeresource
patches:
diff --git a/kubernetes/operator/config/rbac/role.yaml b/kubernetes/operator/config/rbac/role.yaml
index de6c87fe8..067febe1e 100644
--- a/kubernetes/operator/config/rbac/role.yaml
+++ b/kubernetes/operator/config/rbac/role.yaml
@@ -4,6 +4,16 @@ kind: ClusterRole
metadata:
name: manager-role
rules:
+- apiGroups:
+ - ""
+ resources:
+ - namespaces
+ verbs:
+ - create
+ - delete
+ - get
+ - list
+ - watch
- apiGroups:
- ""
resources:
@@ -44,7 +54,7 @@ rules:
- update
- watch
- apiGroups:
- - openrag.io
+ - openr.ag
resources:
- openrags
verbs:
@@ -56,13 +66,13 @@ rules:
- update
- watch
- apiGroups:
- - openrag.io
+ - openr.ag
resources:
- openrags/finalizers
verbs:
- update
- apiGroups:
- - openrag.io
+ - openr.ag
resources:
- openrags/status
verbs:
diff --git a/kubernetes/operator/config/samples/openrag_v1alpha1_openrag.yaml b/kubernetes/operator/config/samples/openrag_v1alpha1_openrag.yaml
index fce3e6eb1..78fdccb41 100644
--- a/kubernetes/operator/config/samples/openrag_v1alpha1_openrag.yaml
+++ b/kubernetes/operator/config/samples/openrag_v1alpha1_openrag.yaml
@@ -1,4 +1,4 @@
-apiVersion: openrag.io/v1alpha1
+apiVersion: openr.ag/v1alpha1
kind: OpenRAG
metadata:
name: my-openrag
diff --git a/kubernetes/operator/go.mod b/kubernetes/operator/go.mod
index 820aeeaf4..2bd836ec7 100644
--- a/kubernetes/operator/go.mod
+++ b/kubernetes/operator/go.mod
@@ -3,6 +3,7 @@ module github.com/langflow-ai/openrag-operator
go 1.26.0
require (
+ github.com/stretchr/testify v1.11.1
k8s.io/api v0.33.2
k8s.io/apimachinery v0.33.2
k8s.io/client-go v0.33.2
@@ -34,6 +35,7 @@ require (
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/pmezard/go-difflib v1.0.0 // 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
diff --git a/kubernetes/operator/go.sum b/kubernetes/operator/go.sum
index dfd366168..bd5293434 100644
--- a/kubernetes/operator/go.sum
+++ b/kubernetes/operator/go.sum
@@ -103,8 +103,8 @@ github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UV
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/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
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=
diff --git a/kubernetes/operator/internal/config/config.go b/kubernetes/operator/internal/config/config.go
new file mode 100644
index 000000000..9abb882a7
--- /dev/null
+++ b/kubernetes/operator/internal/config/config.go
@@ -0,0 +1,46 @@
+package config
+
+import (
+ "os"
+ "strings"
+)
+
+const (
+ DefaultNamespace = "openrag-control"
+ metricsBindAddressEnv = "METRICS_BIND_ADDRESS"
+ healthProbeBindAddressEnv = "HEALTH_PROBE_BIND_ADDRESS"
+ leaderElectionNamespaceEnv = "LEADER_ELECTION_NAMESPACE"
+ enableHTTP2Env = "ENABLE_HTTP2"
+ secureMetricsEnv = "SECURE_METRICS"
+ environment = "Environment"
+)
+
+type OperatorConfig struct {
+ HealthProbeBindAddress string
+ MetricsBindAddress string
+ LeaderElectionNamespace string
+ LeaderElectionEnabled bool
+ EnableHTTP2 bool
+ SecureMetrics bool
+ Environment string
+}
+
+func NewOperatorConfig() OperatorConfig {
+ return OperatorConfig{
+ MetricsBindAddress: getEnv(metricsBindAddressEnv, ":9090"),
+ HealthProbeBindAddress: getEnv(healthProbeBindAddressEnv, ":8080"),
+ LeaderElectionNamespace: getEnv(leaderElectionNamespaceEnv, ""),
+ LeaderElectionEnabled: getEnv(leaderElectionNamespaceEnv, "") != "",
+ EnableHTTP2: strings.ToLower(getEnv(enableHTTP2Env, "false")) == "true",
+ SecureMetrics: strings.ToLower(getEnv(secureMetricsEnv, "false")) == "true",
+ Environment: getEnv(environment, "dev"),
+ }
+}
+
+// getEnv reads an environment variable or returns a default value
+func getEnv(key, defaultValue string) string {
+ if value, exists := os.LookupEnv(key); exists {
+ return value
+ }
+ return defaultValue
+}
diff --git a/kubernetes/operator/internal/controller/openrag_controller.go b/kubernetes/operator/internal/controller/openrag_controller.go
index dc73eeae8..cabdbb8d6 100644
--- a/kubernetes/operator/internal/controller/openrag_controller.go
+++ b/kubernetes/operator/internal/controller/openrag_controller.go
@@ -13,21 +13,29 @@ import (
"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/controller/controllerutil"
"sigs.k8s.io/controller-runtime/pkg/log"
openragv1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"
)
+const finalizer = "openr.ag/namespace-cleanup"
+
// 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
+func NewOpenRAGReconciler(c client.Client, s *runtime.Scheme) *OpenRAGReconciler {
+ return &OpenRAGReconciler{Client: c, Scheme: s}
+}
+
+// +kubebuilder:rbac:groups=openr.ag,resources=openrags,verbs=get;list;watch;create;update;patch;delete
+// +kubebuilder:rbac:groups=openr.ag,resources=openrags/status,verbs=get;update;patch
+// +kubebuilder:rbac:groups=openr.ag,resources=openrags/finalizers,verbs=update
// +kubebuilder:rbac:groups=apps,resources=deployments,verbs=get;list;watch;create;update;patch;delete
+// +kubebuilder:rbac:groups=core,resources=namespaces,verbs=get;list;watch;create;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
@@ -45,35 +53,104 @@ func (r *OpenRAGReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
return ctrl.Result{}, err
}
- if err := r.reconcileServiceAccounts(ctx, instance); err != nil {
+ // Handle deletion when a TargetNamespace was managed by the operator.
+ if !instance.DeletionTimestamp.IsZero() {
+ return ctrl.Result{}, r.handleDeletion(ctx, instance)
+ }
+
+ // Add finalizer when we own a target namespace distinct from the CR namespace.
+ if instance.Spec.TargetNamespace != "" && instance.Spec.TargetNamespace != instance.Namespace {
+ if !controllerutil.ContainsFinalizer(instance, finalizer) {
+ controllerutil.AddFinalizer(instance, finalizer)
+ if err := r.Update(ctx, instance); err != nil {
+ return ctrl.Result{}, err
+ }
+ }
+ }
+
+ targetNS := targetNamespace(instance)
+
+ if err := r.reconcileNamespace(ctx, instance, targetNS); err != nil {
+ return ctrl.Result{}, fmt.Errorf("namespace: %w", err)
+ }
+ if err := r.reconcileServiceAccounts(ctx, instance, targetNS); err != nil {
return ctrl.Result{}, fmt.Errorf("service accounts: %w", err)
}
- if err := r.reconcileServices(ctx, instance); err != nil {
+ if err := r.reconcileServices(ctx, instance, targetNS); err != nil {
return ctrl.Result{}, fmt.Errorf("services: %w", err)
}
- if err := r.reconcileDeployments(ctx, instance); err != nil {
+ if err := r.reconcileDeployments(ctx, instance, targetNS); err != nil {
return ctrl.Result{}, fmt.Errorf("deployments: %w", err)
}
if instance.Spec.NetworkPolicy.Enabled {
- if err := r.reconcileNetworkPolicy(ctx, instance); err != nil {
+ if err := r.reconcileNetworkPolicy(ctx, instance, targetNS); err != nil {
return ctrl.Result{}, fmt.Errorf("network policy: %w", err)
}
}
- logger.Info("reconciled OpenRAG instance", "name", instance.Name)
+ logger.Info("reconciled OpenRAG instance", "name", instance.Name, "targetNamespace", targetNS)
return ctrl.Result{}, nil
}
-func (r *OpenRAGReconciler) reconcileServiceAccounts(ctx context.Context, o *openragv1alpha1.OpenRAG) error {
+// handleDeletion removes the target namespace (and all resources within it) when
+// the CR is deleted, then strips the finalizer so the CR itself can be removed.
+func (r *OpenRAGReconciler) handleDeletion(ctx context.Context, o *openragv1alpha1.OpenRAG) error {
+ if !controllerutil.ContainsFinalizer(o, finalizer) {
+ return nil
+ }
+
+ ns := &corev1.Namespace{}
+ err := r.Get(ctx, client.ObjectKey{Name: o.Spec.TargetNamespace}, ns)
+ if err != nil && !errors.IsNotFound(err) {
+ return err
+ }
+ if err == nil {
+ // Only delete if the namespace was created by this operator for this CR.
+ if ns.Labels[managedByLabel] == o.Name {
+ if err := r.Delete(ctx, ns); err != nil && !errors.IsNotFound(err) {
+ return err
+ }
+ }
+ }
+
+ controllerutil.RemoveFinalizer(o, finalizer)
+ return r.Update(ctx, o)
+}
+
+// reconcileNamespace ensures the target namespace exists, labelled as managed by
+// this CR. It is a no-op when targetNS equals the CR's own namespace.
+func (r *OpenRAGReconciler) reconcileNamespace(ctx context.Context, o *openragv1alpha1.OpenRAG, targetNS string) error {
+ if targetNS == o.Namespace {
+ return nil
+ }
+
+ ns := &corev1.Namespace{}
+ err := r.Get(ctx, client.ObjectKey{Name: targetNS}, ns)
+ if errors.IsNotFound(err) {
+ ns = &corev1.Namespace{
+ ObjectMeta: metav1.ObjectMeta{
+ Name: targetNS,
+ Labels: map[string]string{
+ managedByLabel: o.Name,
+ "app.kubernetes.io/managed-by": "openrag-operator",
+ },
+ },
+ }
+ return r.Create(ctx, ns)
+ }
+ return err
+}
+
+func (r *OpenRAGReconciler) reconcileServiceAccounts(ctx context.Context, o *openragv1alpha1.OpenRAG, targetNS string) error {
for _, role := range []string{"fe", "be", "lf"} {
sa := &corev1.ServiceAccount{
ObjectMeta: metav1.ObjectMeta{
Name: saName(o.Name, role),
- Namespace: o.Namespace,
+ Namespace: targetNS,
Labels: componentLabels(o.Name, role),
},
}
- if err := ctrl.SetControllerReference(o, sa, r.Scheme); err != nil {
+ if err := r.setOwnerOrLabel(o, sa, targetNS); err != nil {
return err
}
if err := r.createOrUpdate(ctx, sa); err != nil {
@@ -83,7 +160,7 @@ func (r *OpenRAGReconciler) reconcileServiceAccounts(ctx context.Context, o *ope
return nil
}
-func (r *OpenRAGReconciler) reconcileServices(ctx context.Context, o *openragv1alpha1.OpenRAG) error {
+func (r *OpenRAGReconciler) reconcileServices(ctx context.Context, o *openragv1alpha1.OpenRAG, targetNS string) error {
type svcDef struct {
role string
port int32
@@ -97,7 +174,7 @@ func (r *OpenRAGReconciler) reconcileServices(ctx context.Context, o *openragv1a
svc := &corev1.Service{
ObjectMeta: metav1.ObjectMeta{
Name: resourceName(o.Name, d.role),
- Namespace: o.Namespace,
+ Namespace: targetNS,
Labels: componentLabels(o.Name, d.role),
},
Spec: corev1.ServiceSpec{
@@ -108,7 +185,7 @@ func (r *OpenRAGReconciler) reconcileServices(ctx context.Context, o *openragv1a
},
},
}
- if err := ctrl.SetControllerReference(o, svc, r.Scheme); err != nil {
+ if err := r.setOwnerOrLabel(o, svc, targetNS); err != nil {
return err
}
if err := r.createOrUpdate(ctx, svc); err != nil {
@@ -118,14 +195,14 @@ func (r *OpenRAGReconciler) reconcileServices(ctx context.Context, o *openragv1a
return nil
}
-func (r *OpenRAGReconciler) reconcileDeployments(ctx context.Context, o *openragv1alpha1.OpenRAG) error {
+func (r *OpenRAGReconciler) reconcileDeployments(ctx context.Context, o *openragv1alpha1.OpenRAG, targetNS string) error {
deploys := []client.Object{
- r.frontendDeployment(o),
- r.backendDeployment(o),
- r.langflowDeployment(o),
+ r.frontendDeployment(o, targetNS),
+ r.backendDeployment(o, targetNS),
+ r.langflowDeployment(o, targetNS),
}
for _, d := range deploys {
- if err := ctrl.SetControllerReference(o, d, r.Scheme); err != nil {
+ if err := r.setOwnerOrLabel(o, d, targetNS); err != nil {
return err
}
if err := r.createOrUpdate(ctx, d); err != nil {
@@ -135,13 +212,13 @@ func (r *OpenRAGReconciler) reconcileDeployments(ctx context.Context, o *openrag
return nil
}
-func (r *OpenRAGReconciler) frontendDeployment(o *openragv1alpha1.OpenRAG) *appsv1.Deployment {
+func (r *OpenRAGReconciler) frontendDeployment(o *openragv1alpha1.OpenRAG, targetNS string) *appsv1.Deployment {
spec := o.Spec.Frontend
replicas := replicasOrDefault(spec.Replicas)
return &appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{
Name: resourceName(o.Name, "fe"),
- Namespace: o.Namespace,
+ Namespace: targetNS,
Labels: componentLabels(o.Name, "fe"),
},
Spec: appsv1.DeploymentSpec{
@@ -176,7 +253,7 @@ func (r *OpenRAGReconciler) frontendDeployment(o *openragv1alpha1.OpenRAG) *apps
}
}
-func (r *OpenRAGReconciler) backendDeployment(o *openragv1alpha1.OpenRAG) *appsv1.Deployment {
+func (r *OpenRAGReconciler) backendDeployment(o *openragv1alpha1.OpenRAG, targetNS string) *appsv1.Deployment {
spec := o.Spec.Backend
replicas := replicasOrDefault(spec.Replicas)
@@ -213,7 +290,7 @@ func (r *OpenRAGReconciler) backendDeployment(o *openragv1alpha1.OpenRAG) *appsv
return &appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{
Name: resourceName(o.Name, "be"),
- Namespace: o.Namespace,
+ Namespace: targetNS,
Labels: componentLabels(o.Name, "be"),
},
Spec: appsv1.DeploymentSpec{
@@ -248,7 +325,7 @@ func (r *OpenRAGReconciler) backendDeployment(o *openragv1alpha1.OpenRAG) *appsv
}
}
-func (r *OpenRAGReconciler) langflowDeployment(o *openragv1alpha1.OpenRAG) *appsv1.Deployment {
+func (r *OpenRAGReconciler) langflowDeployment(o *openragv1alpha1.OpenRAG, targetNS string) *appsv1.Deployment {
spec := o.Spec.Langflow
replicas := replicasOrDefault(spec.Replicas)
@@ -290,7 +367,7 @@ func (r *OpenRAGReconciler) langflowDeployment(o *openragv1alpha1.OpenRAG) *apps
return &appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{
Name: resourceName(o.Name, "lf"),
- Namespace: o.Namespace,
+ Namespace: targetNS,
Labels: componentLabels(o.Name, "lf"),
},
Spec: appsv1.DeploymentSpec{
@@ -327,18 +404,15 @@ func (r *OpenRAGReconciler) langflowDeployment(o *openragv1alpha1.OpenRAG) *apps
}
}
-func (r *OpenRAGReconciler) reconcileNetworkPolicy(ctx context.Context, o *openragv1alpha1.OpenRAG) error {
+func (r *OpenRAGReconciler) reconcileNetworkPolicy(ctx context.Context, o *openragv1alpha1.OpenRAG, targetNS string) 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)}},
}
@@ -351,7 +425,7 @@ func (r *OpenRAGReconciler) reconcileNetworkPolicy(ctx context.Context, o *openr
np := &networkingv1.NetworkPolicy{
ObjectMeta: metav1.ObjectMeta{
Name: resourceName(o.Name, "lf-netpol"),
- Namespace: o.Namespace,
+ Namespace: targetNS,
Labels: labels,
},
Spec: networkingv1.NetworkPolicySpec{
@@ -367,12 +441,28 @@ func (r *OpenRAGReconciler) reconcileNetworkPolicy(ctx context.Context, o *openr
Egress: egress,
},
}
- if err := ctrl.SetControllerReference(o, np, r.Scheme); err != nil {
+ if err := r.setOwnerOrLabel(o, np, targetNS); err != nil {
return err
}
return r.createOrUpdate(ctx, np)
}
+// setOwnerOrLabel sets a controller owner reference when the resource lives in the
+// same namespace as the CR. For cross-namespace resources it falls back to a label
+// since Kubernetes forbids cross-namespace owner references.
+func (r *OpenRAGReconciler) setOwnerOrLabel(o *openragv1alpha1.OpenRAG, obj client.Object, targetNS string) error {
+ if targetNS == o.Namespace {
+ return ctrl.SetControllerReference(o, obj, r.Scheme)
+ }
+ labels := obj.GetLabels()
+ if labels == nil {
+ labels = make(map[string]string)
+ }
+ labels[managedByLabel] = o.Name
+ obj.SetLabels(labels)
+ return nil
+}
+
func (r *OpenRAGReconciler) createOrUpdate(ctx context.Context, obj client.Object) error {
existing := obj.DeepCopyObject().(client.Object)
err := r.Get(ctx, client.ObjectKeyFromObject(obj), existing)
@@ -399,6 +489,15 @@ func (r *OpenRAGReconciler) SetupWithManager(mgr ctrl.Manager) error {
// helpers
+const managedByLabel = "openr.ag/managed-by"
+
+func targetNamespace(o *openragv1alpha1.OpenRAG) string {
+ if o.Spec.TargetNamespace != "" {
+ return o.Spec.TargetNamespace
+ }
+ return o.Namespace
+}
+
func resourceName(crName, role string) string {
return crName + "-openrag-" + role
}
diff --git a/kubernetes/operator/internal/controller/openrag_controller_test.go b/kubernetes/operator/internal/controller/openrag_controller_test.go
new file mode 100644
index 000000000..2e68858c5
--- /dev/null
+++ b/kubernetes/operator/internal/controller/openrag_controller_test.go
@@ -0,0 +1,366 @@
+package controller
+
+import (
+ "context"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+ appsv1 "k8s.io/api/apps/v1"
+ corev1 "k8s.io/api/core/v1"
+ "k8s.io/apimachinery/pkg/api/resource"
+ metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+ "k8s.io/apimachinery/pkg/runtime"
+ "k8s.io/apimachinery/pkg/types"
+ clientgoscheme "k8s.io/client-go/kubernetes/scheme"
+ ctrl "sigs.k8s.io/controller-runtime"
+ "sigs.k8s.io/controller-runtime/pkg/client"
+ "sigs.k8s.io/controller-runtime/pkg/client/fake"
+ "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
+
+ openragv1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"
+)
+
+// newScheme builds a scheme with all types the controller needs.
+func newScheme(t *testing.T) *runtime.Scheme {
+ t.Helper()
+ s := runtime.NewScheme()
+ require.NoError(t, clientgoscheme.AddToScheme(s))
+ require.NoError(t, appsv1.AddToScheme(s))
+ require.NoError(t, corev1.AddToScheme(s))
+ require.NoError(t, openragv1alpha1.AddToScheme(s))
+ return s
+}
+
+// minimalCR returns a valid OpenRAG CR with the minimum required fields set.
+func minimalCR(name, namespace string) *openragv1alpha1.OpenRAG {
+ return &openragv1alpha1.OpenRAG{
+ ObjectMeta: metav1.ObjectMeta{
+ Name: name,
+ Namespace: namespace,
+ },
+ Spec: openragv1alpha1.OpenRAGSpec{
+ Frontend: openragv1alpha1.FrontendSpec{
+ ComponentSpec: openragv1alpha1.ComponentSpec{Image: "langflowai/openrag-frontend:latest"},
+ },
+ Backend: openragv1alpha1.BackendSpec{
+ ComponentSpec: openragv1alpha1.ComponentSpec{Image: "langflowai/openrag-backend:latest"},
+ },
+ Langflow: openragv1alpha1.LangflowSpec{
+ ComponentSpec: openragv1alpha1.ComponentSpec{Image: "langflowai/openrag-langflow:latest"},
+ },
+ },
+ }
+}
+
+func reconciler(s *runtime.Scheme, objs ...client.Object) (*OpenRAGReconciler, client.Client) {
+ c := fake.NewClientBuilder().WithScheme(s).WithObjects(objs...).WithStatusSubresource(&openragv1alpha1.OpenRAG{}).Build()
+ return NewOpenRAGReconciler(c, s), c
+}
+
+func reconcileOnce(t *testing.T, r *OpenRAGReconciler, cr *openragv1alpha1.OpenRAG) ctrl.Result {
+ t.Helper()
+ res, err := r.Reconcile(context.Background(), ctrl.Request{
+ NamespacedName: types.NamespacedName{Name: cr.Name, Namespace: cr.Namespace},
+ })
+ require.NoError(t, err)
+ return res
+}
+
+// ---------------------------------------------------------------------------
+// targetNamespace helper
+// ---------------------------------------------------------------------------
+
+func TestTargetNamespace_DefaultsToCRNamespace(t *testing.T) {
+ cr := minimalCR("my-openrag", "my-ns")
+ assert.Equal(t, "my-ns", targetNamespace(cr))
+}
+
+func TestTargetNamespace_UsesSpecField(t *testing.T) {
+ cr := minimalCR("my-openrag", "my-ns")
+ cr.Spec.TargetNamespace = "tenant-ns"
+ assert.Equal(t, "tenant-ns", targetNamespace(cr))
+}
+
+// ---------------------------------------------------------------------------
+// resourceName / saName helpers
+// ---------------------------------------------------------------------------
+
+func TestResourceName(t *testing.T) {
+ assert.Equal(t, "my-openrag-openrag-fe", resourceName("my-openrag", "fe"))
+ assert.Equal(t, "my-openrag-openrag-be", resourceName("my-openrag", "be"))
+ assert.Equal(t, "my-openrag-openrag-lf", resourceName("my-openrag", "lf"))
+}
+
+func TestSAName(t *testing.T) {
+ assert.Equal(t, "openrag-my-openrag-fe", saName("my-openrag", "fe"))
+}
+
+// ---------------------------------------------------------------------------
+// Reconcile — same namespace (no targetNamespace)
+// ---------------------------------------------------------------------------
+
+func TestReconcile_CreatesDeployments(t *testing.T) {
+ s := newScheme(t)
+ cr := minimalCR("my-openrag", "my-ns")
+ r, c := reconciler(s, cr)
+
+ reconcileOnce(t, r, cr)
+
+ for _, role := range []string{"fe", "be", "lf"} {
+ d := &appsv1.Deployment{}
+ require.NoError(t, c.Get(context.Background(),
+ types.NamespacedName{Name: resourceName(cr.Name, role), Namespace: "my-ns"}, d),
+ "deployment for role %s should exist", role)
+ }
+}
+
+func TestReconcile_CreatesServices(t *testing.T) {
+ s := newScheme(t)
+ cr := minimalCR("my-openrag", "my-ns")
+ r, c := reconciler(s, cr)
+
+ reconcileOnce(t, r, cr)
+
+ ports := map[string]int32{"fe": 3000, "be": 8000, "lf": 7860}
+ for role, port := range ports {
+ svc := &corev1.Service{}
+ require.NoError(t, c.Get(context.Background(),
+ types.NamespacedName{Name: resourceName(cr.Name, role), Namespace: "my-ns"}, svc))
+ assert.Equal(t, port, svc.Spec.Ports[0].Port, "service port for role %s", role)
+ }
+}
+
+func TestReconcile_CreatesServiceAccounts(t *testing.T) {
+ s := newScheme(t)
+ cr := minimalCR("my-openrag", "my-ns")
+ r, c := reconciler(s, cr)
+
+ reconcileOnce(t, r, cr)
+
+ for _, role := range []string{"fe", "be", "lf"} {
+ sa := &corev1.ServiceAccount{}
+ require.NoError(t, c.Get(context.Background(),
+ types.NamespacedName{Name: saName(cr.Name, role), Namespace: "my-ns"}, sa),
+ "service account for role %s should exist", role)
+ }
+}
+
+func TestReconcile_SetsOwnerReferences_SameNamespace(t *testing.T) {
+ s := newScheme(t)
+ cr := minimalCR("my-openrag", "my-ns")
+ r, c := reconciler(s, cr)
+
+ reconcileOnce(t, r, cr)
+
+ d := &appsv1.Deployment{}
+ require.NoError(t, c.Get(context.Background(),
+ types.NamespacedName{Name: resourceName(cr.Name, "fe"), Namespace: "my-ns"}, d))
+ require.Len(t, d.OwnerReferences, 1)
+ assert.Equal(t, cr.Name, d.OwnerReferences[0].Name)
+}
+
+func TestReconcile_FrontendEnvContainsBackendHost(t *testing.T) {
+ s := newScheme(t)
+ cr := minimalCR("my-openrag", "my-ns")
+ r, c := reconciler(s, cr)
+
+ reconcileOnce(t, r, cr)
+
+ d := &appsv1.Deployment{}
+ require.NoError(t, c.Get(context.Background(),
+ types.NamespacedName{Name: resourceName(cr.Name, "fe"), Namespace: "my-ns"}, d))
+
+ var backendHost string
+ for _, e := range d.Spec.Template.Spec.Containers[0].Env {
+ if e.Name == "OPENRAG_BACKEND_HOST" {
+ backendHost = e.Value
+ }
+ }
+ assert.Equal(t, resourceName(cr.Name, "be"), backendHost)
+}
+
+func TestReconcile_BackendMountsEnvSecret(t *testing.T) {
+ s := newScheme(t)
+ cr := minimalCR("my-openrag", "my-ns")
+ cr.Spec.Backend.EnvSecret = "my-backend-secret"
+ r, c := reconciler(s, cr)
+
+ reconcileOnce(t, r, cr)
+
+ d := &appsv1.Deployment{}
+ require.NoError(t, c.Get(context.Background(),
+ types.NamespacedName{Name: resourceName(cr.Name, "be"), Namespace: "my-ns"}, d))
+
+ var found bool
+ for _, v := range d.Spec.Template.Spec.Volumes {
+ if v.Name == "backend-env" {
+ assert.Equal(t, "my-backend-secret", v.Secret.SecretName)
+ found = true
+ }
+ }
+ assert.True(t, found, "backend-env volume should exist")
+}
+
+func TestReconcile_LangflowMountsPVC(t *testing.T) {
+ s := newScheme(t)
+ cr := minimalCR("my-openrag", "my-ns")
+ size := resource.MustParse("10Gi")
+ cr.Spec.Langflow.Storage = &openragv1alpha1.PersistenceSpec{Enabled: true, Size: size}
+ r, c := reconciler(s, cr)
+
+ reconcileOnce(t, r, cr)
+
+ d := &appsv1.Deployment{}
+ require.NoError(t, c.Get(context.Background(),
+ types.NamespacedName{Name: resourceName(cr.Name, "lf"), Namespace: "my-ns"}, d))
+
+ var found bool
+ for _, v := range d.Spec.Template.Spec.Volumes {
+ if v.Name == "langflow-data" {
+ assert.Equal(t, resourceName(cr.Name, "lf-data"), v.PersistentVolumeClaim.ClaimName)
+ found = true
+ }
+ }
+ assert.True(t, found, "langflow-data volume should exist")
+}
+
+// ---------------------------------------------------------------------------
+// Reconcile — target namespace
+// ---------------------------------------------------------------------------
+
+func TestReconcile_CreatesTargetNamespace(t *testing.T) {
+ s := newScheme(t)
+ cr := minimalCR("my-openrag", "operator-ns")
+ cr.Spec.TargetNamespace = "tenant-ns"
+ r, c := reconciler(s, cr)
+
+ reconcileOnce(t, r, cr)
+
+ ns := &corev1.Namespace{}
+ require.NoError(t, c.Get(context.Background(), types.NamespacedName{Name: "tenant-ns"}, ns))
+ assert.Equal(t, cr.Name, ns.Labels[managedByLabel])
+}
+
+func TestReconcile_AddsFinalizer_WhenTargetNamespaceDiffers(t *testing.T) {
+ s := newScheme(t)
+ cr := minimalCR("my-openrag", "operator-ns")
+ cr.Spec.TargetNamespace = "tenant-ns"
+ r, c := reconciler(s, cr)
+
+ reconcileOnce(t, r, cr)
+
+ updated := &openragv1alpha1.OpenRAG{}
+ require.NoError(t, c.Get(context.Background(),
+ types.NamespacedName{Name: cr.Name, Namespace: cr.Namespace}, updated))
+ assert.True(t, controllerutil.ContainsFinalizer(updated, finalizer))
+}
+
+func TestReconcile_NoFinalizer_WhenSameNamespace(t *testing.T) {
+ s := newScheme(t)
+ cr := minimalCR("my-openrag", "my-ns")
+ r, c := reconciler(s, cr)
+
+ reconcileOnce(t, r, cr)
+
+ updated := &openragv1alpha1.OpenRAG{}
+ require.NoError(t, c.Get(context.Background(),
+ types.NamespacedName{Name: cr.Name, Namespace: cr.Namespace}, updated))
+ assert.False(t, controllerutil.ContainsFinalizer(updated, finalizer))
+}
+
+func TestReconcile_ResourcesInTargetNamespace(t *testing.T) {
+ s := newScheme(t)
+ cr := minimalCR("my-openrag", "operator-ns")
+ cr.Spec.TargetNamespace = "tenant-ns"
+ r, c := reconciler(s, cr)
+
+ reconcileOnce(t, r, cr)
+
+ d := &appsv1.Deployment{}
+ require.NoError(t, c.Get(context.Background(),
+ types.NamespacedName{Name: resourceName(cr.Name, "fe"), Namespace: "tenant-ns"}, d))
+ // Cross-namespace: no owner references, managed-by label instead.
+ assert.Empty(t, d.OwnerReferences)
+ assert.Equal(t, cr.Name, d.Labels[managedByLabel])
+}
+
+func TestReconcile_SkipsNamespaceCreation_WhenSameAsCR(t *testing.T) {
+ s := newScheme(t)
+ cr := minimalCR("my-openrag", "my-ns")
+ r, c := reconciler(s, cr)
+
+ reconcileOnce(t, r, cr)
+
+ // Only the CR namespace should exist, not a separate one.
+ nsList := &corev1.NamespaceList{}
+ require.NoError(t, c.List(context.Background(), nsList))
+ for _, ns := range nsList.Items {
+ assert.NotEqual(t, "openrag-operator", ns.Labels["app.kubernetes.io/managed-by"],
+ "operator should not have created a new namespace")
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Deletion handling
+// ---------------------------------------------------------------------------
+
+func TestReconcile_Deletion_DeletesOwnedNamespace(t *testing.T) {
+ s := newScheme(t)
+ cr := minimalCR("my-openrag", "operator-ns")
+ cr.Spec.TargetNamespace = "tenant-ns"
+ now := metav1.Now()
+ cr.DeletionTimestamp = &now
+ controllerutil.AddFinalizer(cr, finalizer)
+
+ // Pre-create the target namespace labelled as owned by this CR.
+ ns := &corev1.Namespace{
+ ObjectMeta: metav1.ObjectMeta{
+ Name: "tenant-ns",
+ Labels: map[string]string{managedByLabel: cr.Name},
+ },
+ }
+
+ r, c := reconciler(s, cr, ns)
+ _, err := r.Reconcile(context.Background(), ctrl.Request{
+ NamespacedName: types.NamespacedName{Name: cr.Name, Namespace: cr.Namespace},
+ })
+ require.NoError(t, err)
+
+ // Namespace should be deleted.
+ remaining := &corev1.Namespace{}
+ err = c.Get(context.Background(), types.NamespacedName{Name: "tenant-ns"}, remaining)
+ assert.True(t, err != nil, "namespace should have been deleted")
+
+ // After the finalizer is removed the fake client deletes the CR — NotFound is correct.
+ updated := &openragv1alpha1.OpenRAG{}
+ err = c.Get(context.Background(), types.NamespacedName{Name: cr.Name, Namespace: cr.Namespace}, updated)
+ assert.True(t, err != nil, "CR should be gone after finalizer removal")
+}
+
+func TestReconcile_Deletion_SkipsUnmanagedNamespace(t *testing.T) {
+ s := newScheme(t)
+ cr := minimalCR("my-openrag", "operator-ns")
+ cr.Spec.TargetNamespace = "tenant-ns"
+ now := metav1.Now()
+ cr.DeletionTimestamp = &now
+ controllerutil.AddFinalizer(cr, finalizer)
+
+ // Namespace exists but belongs to someone else.
+ ns := &corev1.Namespace{
+ ObjectMeta: metav1.ObjectMeta{
+ Name: "tenant-ns",
+ Labels: map[string]string{managedByLabel: "other-cr"},
+ },
+ }
+
+ r, c := reconciler(s, cr, ns)
+ _, err := r.Reconcile(context.Background(), ctrl.Request{
+ NamespacedName: types.NamespacedName{Name: cr.Name, Namespace: cr.Namespace},
+ })
+ require.NoError(t, err)
+
+ // Namespace should NOT be deleted.
+ remaining := &corev1.Namespace{}
+ require.NoError(t, c.Get(context.Background(), types.NamespacedName{Name: "tenant-ns"}, remaining))
+}