Add cluster-instances to configured resources

Author: PhiRho

examples/clusters/development/crossplane-resources.yaml

@@ -28,7 +28,7 @@ spec:
             function:
               packages:
                 - "xpkg.crossplane.io/crossplane-contrib/function-patch-and-transform:v0.8.2"
-                - "ghcr.io/amazeeio/amazeeai-k0rdent-catalog/vectordb-function:v0.0.18-crossplane"
+                - "ghcr.io/amazeeio/amazeeai-k0rdent-catalog/vectordb-function:v0.0.19-crossplane"
             provider:
               packages:
                 - "xpkg.crossplane.io/crossplane-contrib/provider-family-aws:v1.23.0" # top level provider for credential management

examples/resources/development/aws-vector-db-comp.yaml

@@ -73,6 +73,18 @@ spec:
                 type: string
                 default: "vectordb"
                 description: "Name of the cluster"
+              instanceCount:
+                type: integer
+                default: 2
+                description: "Number of instances"
+              instanceClass:
+                type: string
+                default: "db.serverless"
+                description: "Instance class"
+              publiclyAccessible:
+                type: boolean
+                default: true
+                description: "Enable public access"
             required:
             - location
     served: true

examples/resources/development/vector-db-ir1.yaml

@@ -19,3 +19,6 @@ spec:
   backupWindow: "06:42-07:12"
   maintenanceWindow: "wed:04:35-wed:05:05"
   deletionProtection: true
+  instanceCount: 1
+  instanceClass: "db.serverless"
+  publiclyAccessible: true

functions/vectordb/function/__version__.py

@@ -15,4 +15,4 @@
 """The version of the function."""
 
 # This is set at build time, using "hatch version"
-__version__ = "0.0.19"
+__version__ = "0.0.20"

functions/vectordb/function/fn.py

@@ -45,6 +45,9 @@ class VectorDBConfig:
     deletion_protection: bool = False
     namespace: str = "default"
     provider_config_ref: str = "default"
+    instance_count: int = 2
+    instance_class: str = "db.serverless"
+    publicly_accessible: bool = True
 
 
 class VectorDBFunctionRunner(grpcv1.FunctionRunnerService):
@@ -120,6 +123,11 @@ async def RunFunction(
         aurora_resource = self._create_aurora_cluster(config)
         resources.append(("aurora_cluster", aurora_resource))
 
+        # 10. Create Aurora instances (depend on cluster, subnet group, and security group)
+        aurora_instance_resources = self._create_aurora_instances(config)
+        for i, instance in enumerate(aurora_instance_resources):
+            resources.append((f"aurora_instance_{i + 1}", instance))
+
         # Add all resources to response
         for name, res in resources:
             resource.update(response_obj.desired.resources[name], res)
@@ -632,6 +640,63 @@ def _create_aurora_cluster(self, config: VectorDBConfig) -> dict:
             },
         }
 
+    def _create_aurora_instances(self, config: VectorDBConfig) -> list[dict]:
+        """Create Aurora PostgreSQL cluster instances."""
+        instances = []
+        for i in range(config.instance_count):
+            instance_name = f"{config.postgres_cluster_name}-instance-{i + 1}"
+            instance = {
+                "apiVersion": "rds.aws.upbound.io/v1beta1",
+                "kind": "ClusterInstance",
+                "spec": {
+                    "forProvider": {
+                        "region": config.region,
+                        "engine": "aurora-postgresql",
+                        "engineVersion": config.engine_version,
+                        "instanceClass": config.instance_class,
+                        "publiclyAccessible": config.publicly_accessible,
+                        "clusterIdentifierRef": {
+                            "name": config.postgres_cluster_name,
+                        },
+                        "dbSubnetGroupNameRef": {
+                            "name": f"{config.claim_name}-subnet-group-{config.environment_suffix}",
+                        },
+                        "performanceInsightsEnabled": True,
+                        "performanceInsightsRetentionPeriod": 7,
+                        "dbParameterGroupName": "default.aurora-postgresql16",
+                        "autoMinorVersionUpgrade": True,
+                        "monitoringInterval": 60,
+                        "promotionTier": i,
+                        "tags": {
+                            "Name": (
+                                f"{config.claim_name}-instance-{i + 1}-{config.environment_suffix}"
+                            ),
+                            "App": config.claim_name,
+                            "Environment": config.environment_suffix,
+                        },
+                    },
+                    "providerConfigRef": {
+                        "name": config.provider_config_ref,
+                    },
+                    "writeConnectionSecretToRef": {
+                        "name": f"{config.claim_name}-instance-{i + 1}-{config.environment_suffix}",
+                        "namespace": config.namespace,
+                    },
+                },
+                "metadata": {
+                    "name": instance_name,
+                    "labels": {
+                        "app": config.claim_name,
+                        "environment": config.environment_suffix,
+                    },
+                    "annotations": {
+                        "crossplane.io/depends-on": "aurora_cluster,subnet_group,security_group",
+                    },
+                },
+            }
+            instances.append(instance)
+        return instances
+
 
 # Keep the original FunctionRunner for backward compatibility
 class FunctionRunner(VectorDBFunctionRunner):

functions/vectordb/package/input/input.yaml

@@ -61,6 +61,15 @@ spec:
           clusterName:
             type: string
             description: "Name of the cluster"
+          instanceCount:
+            type: integer
+            description: "Number of instances"
+          instanceClass:
+            type: string
+            description: "Instance class"
+          publiclyAccessible:
+            type: boolean
+            description: "Enable public access"
         required:
         - location
         - providerConfigRef

functions/vectordb/tests/test_fn.py

@@ -29,7 +29,10 @@ def test_config_creation(self):
         self.assertEqual(config.environment_suffix, "dev")
         self.assertEqual(config.master_username, "postgres")
         self.assertEqual(config.postgres_cluster_name, "vectordb-cluster")
-        self.assertEqual(config.az_count, 3)  # Default value
+        self.assertEqual(config.az_count, 3)
+        self.assertEqual(config.instance_count, 2)
+        self.assertEqual(config.instance_class, "db.serverless")
+        self.assertTrue(config.publicly_accessible)  # Default value
         self.assertEqual(config.engine_version, "16.1")  # Default value
 
 
@@ -304,6 +307,100 @@ def test_create_aurora_cluster(self):
 
         # Connection details have been removed as they are not required
 
+    def test_create_aurora_instances(self):
+        """Test Aurora cluster instances creation."""
+        # Given: Configuration
+        config = fn.VectorDBConfig(
+            claim_name="test-claim",
+            vpc_cidr="10.10.0.0/16",
+            region="us-west-2",
+            environment_suffix="dev",
+            master_username="postgres",
+            postgres_cluster_name="vectordb-cluster",
+            instance_count=2,
+            instance_class="db.serverless",
+            publicly_accessible=True,
+        )
+        runner = fn.VectorDBFunctionRunner()
+
+        # When: Creating Aurora instances
+        aurora_instance_resources = runner._create_aurora_instances(config)
+
+        # Then: Should create the correct number of instances
+        self.assertEqual(len(aurora_instance_resources), 2)
+
+        # Check first instance
+        instance1 = aurora_instance_resources[0]
+        self.assertEqual(instance1["apiVersion"], "rds.aws.upbound.io/v1beta1")
+        self.assertEqual(instance1["kind"], "ClusterInstance")
+        self.assertEqual(instance1["metadata"]["name"], "vectordb-cluster-instance-1")
+        self.assertEqual(instance1["spec"]["forProvider"]["engine"], "aurora-postgresql")
+        self.assertEqual(instance1["spec"]["forProvider"]["engineVersion"], "16.1")
+        self.assertEqual(instance1["spec"]["forProvider"]["instanceClass"], "db.serverless")
+        self.assertTrue(instance1["spec"]["forProvider"]["publiclyAccessible"])
+        self.assertEqual(instance1["spec"]["forProvider"]["promotionTier"], 0)
+        self.assertEqual(
+            instance1["spec"]["forProvider"]["clusterIdentifierRef"]["name"], "vectordb-cluster"
+        )
+        self.assertEqual(
+            instance1["spec"]["forProvider"]["dbSubnetGroupNameRef"]["name"],
+            "test-claim-subnet-group-dev",
+        )
+        self.assertTrue(instance1["spec"]["forProvider"]["performanceInsightsEnabled"])
+        self.assertEqual(instance1["spec"]["forProvider"]["performanceInsightsRetentionPeriod"], 7)
+        self.assertEqual(
+            instance1["spec"]["forProvider"]["dbParameterGroupName"], "default.aurora-postgresql16"
+        )
+        self.assertTrue(instance1["spec"]["forProvider"]["autoMinorVersionUpgrade"])
+        self.assertEqual(instance1["spec"]["forProvider"]["monitoringInterval"], 60)
+
+        # Check second instance
+        instance2 = aurora_instance_resources[1]
+        self.assertEqual(instance2["metadata"]["name"], "vectordb-cluster-instance-2")
+        self.assertEqual(instance2["spec"]["forProvider"]["promotionTier"], 1)
+        self.assertEqual(
+            instance2["spec"]["forProvider"]["clusterIdentifierRef"]["name"], "vectordb-cluster"
+        )
+
+        # Check metadata and dependencies
+        for instance in aurora_instance_resources:
+            self.assertEqual(instance["metadata"]["labels"]["app"], "test-claim")
+            self.assertEqual(instance["metadata"]["labels"]["environment"], "dev")
+            self.assertIn("crossplane.io/depends-on", instance["metadata"]["annotations"])
+            self.assertIn(
+                "aurora_cluster",
+                instance["metadata"]["annotations"]["crossplane.io/depends-on"],
+            )
+
+    def test_create_aurora_instances_custom_config(self):
+        """Test Aurora cluster instances creation with custom configuration."""
+        # Given: Configuration with custom instance settings
+        config = fn.VectorDBConfig(
+            claim_name="test-claim",
+            vpc_cidr="10.10.0.0/16",
+            region="us-west-2",
+            environment_suffix="prod",
+            master_username="postgres",
+            postgres_cluster_name="vectordb-cluster",
+            instance_count=3,
+            instance_class="db.r6g.large",
+            publicly_accessible=False,
+        )
+        runner = fn.VectorDBFunctionRunner()
+
+        # When: Creating Aurora instances
+        aurora_instance_resources = runner._create_aurora_instances(config)
+
+        # Then: Should create the correct number of instances with custom settings
+        self.assertEqual(len(aurora_instance_resources), 3)
+
+        # Check custom settings are applied
+        for i, instance in enumerate(aurora_instance_resources):
+            self.assertEqual(instance["spec"]["forProvider"]["instanceClass"], "db.r6g.large")
+            self.assertFalse(instance["spec"]["forProvider"]["publiclyAccessible"])
+            self.assertEqual(instance["spec"]["forProvider"]["promotionTier"], i)
+            self.assertEqual(instance["metadata"]["name"], f"vectordb-cluster-instance-{i + 1}")
+
     def test_extract_config(self):
         """Test configuration extraction from request."""
         # Given: Request with configuration