feat(server): support dedicated database

build/charts/laf-server/templates/deployment.yaml

@@ -81,6 +81,8 @@ spec:
               value: {{ .Values.default_region.tls.wildcard_certificate_secret_name | quote}}
             - name: DEFAULT_REGION_PROMETHEUS_URL
               value: {{ .Values.default_region.prometheus_url }}
+            - name: DEFAULT_REGION_DEPLOY_MANIFEST
+              value: {{ .Values.default_region.deploy_manifest }}
             - name: SITE_NAME
               value: {{ .Values.siteName | quote}}
       {{- with .Values.nodeSelector }}

build/charts/laf-server/values.yaml

@@ -27,6 +27,7 @@ default_region:
   runtime_exporter_secret: ""
   # prometheus
   prometheus_url: ""
+  deploy_manifest: ""
 jwt:
   secret: laf_server_abc123
   expires_in: 7d

build/start.sh

@@ -73,6 +73,55 @@ helm install minio -n ${NAMESPACE} \
 ## 5. install laf-server
 SERVER_JWT_SECRET=$PASSWD_OR_SECRET
 RUNTIME_EXPORTER_SECRET=$PASSWD_OR_SECRET
+DEPLOY_MANIFEST='{
+    "database": "
+apiVersion: apps.kubeblocks.io/v1alpha1
+kind: Cluster
+metadata:
+  finalizers:
+    - cluster.kubeblocks.io/finalizer
+  labels:
+    clusterdefinition.kubeblocks.io/name: mongodb
+    clusterversion.kubeblocks.io/name: mongodb-5.0
+    sealos-db-provider-cr: <%- name %>
+  annotations: {}
+  name: <%- name %>
+  namespace: {namespace}
+spec:
+  affinity:
+    nodeLabels: {}
+    podAntiAffinity: Preferred
+    tenancy: SharedNode
+    topologyKeys: []
+  clusterDefinitionRef: mongodb
+  clusterVersionRef: mongodb-5.0
+  componentSpecs:
+    - componentDefRef: mongodb
+      monitor: true
+      name: mongodb
+      replicas: <%- replicas %>
+      resources:
+        limits:
+          cpu: <%- limitCPU %>m
+          memory: <%- limitMemory %>Mi
+        requests:
+          cpu: <%- requestCPU %>m
+          memory: <%- requestMemory %>Mi
+      serviceAccountName: <%- name %>
+      volumeClaimTemplates:
+        - name: data
+          spec:
+            accessModes:
+              - ReadWriteOnce
+            resources:
+              requests:
+                storage: <%- capacity %>Mi
+  terminationPolicy: Delete
+  tolerations: []
+"
+}'
+DEPLOY_MANIFEST=$(echo "$DEPLOY_MANIFEST" | sed "s/{namespace}/$NAMESPACE/g")
+
 helm install server -n ${NAMESPACE} \
     --set databaseUrl=${DATABASE_URL} \
     --set jwt.secret=${SERVER_JWT_SECRET} \
@@ -91,6 +140,7 @@ helm install server -n ${NAMESPACE} \
     --set default_region.tls.enabled=false \
     --set default_region.runtime_exporter_secret=${RUNTIME_EXPORTER_SECRET} \
     $([ "$ENABLE_MONITOR" = "true" ] && echo "--set default_region.prometheus_url=${PROMETHEUS_URL}") \
+    --set default_region.deploy_manifest=${DEPLOY_MANIFEST}
     ./charts/laf-server
 
 ## 6. install laf-web

server/package.json

@@ -35,6 +35,7 @@
     "@nestjs/common": "^9.0.0",
     "@nestjs/config": "^2.2.0",
     "@nestjs/core": "^9.2.1",
+    "@nestjs/event-emitter": "^2.0.3",
     "@nestjs/jwt": "^10.0.1",
     "@nestjs/mapped-types": "*",
     "@nestjs/passport": "^9.0.0",

server/src/app.module.ts

@@ -30,6 +30,7 @@ import { APP_INTERCEPTOR } from '@nestjs/core'
 import { AppInterceptor } from './app.interceptor'
 import { InterceptorModule } from './interceptor/interceptor.module'
 import { MonitorModule } from './monitor/monitor.module'
+import { EventEmitterModule } from '@nestjs/event-emitter'
 
 @Module({
   imports: [
@@ -76,6 +77,7 @@ import { MonitorModule } from './monitor/monitor.module'
     GroupModule,
     InterceptorModule,
     MonitorModule,
+    EventEmitterModule.forRoot(),
   ],
   controllers: [AppController],
   providers: [

server/src/application/application-task.service.ts

@@ -24,6 +24,7 @@ import { DatabasePhase } from 'src/database/entities/database'
 import { DomainPhase } from 'src/gateway/entities/runtime-domain'
 import { StoragePhase } from 'src/storage/entities/storage-user'
 import { ApplicationNamespaceMode } from 'src/region/entities/region'
+import { DedicatedDatabaseService } from 'src/database/dedicated-database/dedicated-database.service'
 
 @Injectable()
 export class ApplicationTaskService {
@@ -35,6 +36,7 @@ export class ApplicationTaskService {
     private readonly clusterService: ClusterService,
     private readonly storageService: StorageService,
     private readonly databaseService: DatabaseService,
+    private readonly dedicatedDatabaseService: DedicatedDatabaseService,
     private readonly runtimeDomainService: RuntimeDomainService,
     private readonly bucketDomainService: BucketDomainService,
     private readonly triggerService: TriggerService,
@@ -119,20 +121,27 @@ export class ApplicationTaskService {
       storage = await this.storageService.create(app.appid)
     }
 
-    // reconcile database
-    let database = await this.databaseService.findOne(appid)
-    if (!database) {
-      this.logger.log(`Creating database for application ${appid}`)
-      database = await this.databaseService.create(app.appid)
-    }
-
     // reconcile runtime domain
     let runtimeDomain = await this.runtimeDomainService.findOne(appid)
     if (!runtimeDomain) {
       this.logger.log(`Creating gateway for application ${appid}`)
       runtimeDomain = await this.runtimeDomainService.create(appid)
     }
 
+    // reconcile database
+    const dedicatedDatabase = await this.dedicatedDatabaseService.findOne(appid)
+    if (!dedicatedDatabase) {
+      let database = await this.databaseService.findOne(appid)
+      if (!database) {
+        this.logger.log(`Creating database for application ${appid}`)
+        database = await this.databaseService.create(app.appid)
+      }
+
+      if (database?.phase !== DatabasePhase.Created) {
+        return await this.unlock(appid)
+      }
+    }
+
     // waiting resources' phase to be `Created`
     if (runtimeDomain?.phase !== DomainPhase.Created) {
       return await this.unlock(appid)
@@ -142,10 +151,6 @@ export class ApplicationTaskService {
       return await this.unlock(appid)
     }
 
-    if (database?.phase !== DatabasePhase.Created) {
-      return await this.unlock(appid)
-    }
-
     // update application phase to `Created`
     await db.collection<Application>('Application').updateOne(
       { _id: app._id, phase: ApplicationPhase.Creating },
@@ -260,6 +265,12 @@ export class ApplicationTaskService {
       return await this.unlock(appid)
     }
 
+    const dedicatedDatabase = await this.dedicatedDatabaseService.findOne(appid)
+    if (dedicatedDatabase) {
+      await this.dedicatedDatabaseService.remove(appid)
+      return await this.unlock(appid)
+    }
+
     // delete application storage
     const storage = await this.storageService.findOne(appid)
     if (storage) {

server/src/application/application.controller.ts

@@ -83,7 +83,7 @@ export class ApplicationController {
   @ApiResponseObject(ApplicationWithRelations)
   @Post()
   async create(@Body() dto: CreateApplicationDto, @InjectUser() user: User) {
-    const error = dto.autoscaling.validate()
+    const error = dto.validate() || dto.autoscaling.validate()
     if (error) {
       return ResponseUtil.error(error)
     }
@@ -334,6 +334,14 @@ export class ApplicationController {
       }
     }
 
+    const origin = app.bundle
+    if (
+      (origin.resource['dedicatedDatabase.limitCPU'] && dto.databaseCapacity) ||
+      (origin.resource.databaseCapacity && dto.dedicatedDatabase)
+    ) {
+      return ResponseUtil.error('cannot change database type')
+    }
+
     const checkSpec = await this.checkResourceSpecification(dto, regionId)
     if (!checkSpec) {
       return ResponseUtil.error('invalid resource specification')
@@ -353,13 +361,29 @@ export class ApplicationController {
     const doc = await this.application.updateBundle(appid, dto, isTrialTier)
 
     // restart running application if cpu or memory changed
-    const origin = app.bundle
     const isRunning = app.phase === ApplicationPhase.Started
     const isCpuChanged = origin.resource.limitCPU !== doc.resource.limitCPU
     const isMemoryChanged =
       origin.resource.limitMemory !== doc.resource.limitMemory
     const isAutoscalingCanceled =
       !doc.autoscaling.enable && origin.autoscaling.enable
+    const isDedicatedDatabaseChanged =
+      !isEqual(
+        origin.resource['dedicatedDatabase.limitCPU'],
+        doc.resource['dedicatedDatabase.limitCPU'],
+      ) ||
+      !isEqual(
+        origin.resource['dedicatedDatabase.limitMemory'],
+        doc.resource['dedicatedDatabase.limitMemory'],
+      ) ||
+      !isEqual(
+        origin.resource['dedicatedDatabase.replicas'],
+        doc.resource['dedicatedDatabase.replicas'],
+      ) ||
+      !isEqual(
+        origin.resource['dedicatedDatabase.capacity'],
+        doc.resource['dedicatedDatabase.capacity'],
+      )
 
     if (!isEqual(doc.autoscaling, origin.autoscaling)) {
       const { hpa, app } = await this.instance.get(appid)
@@ -368,7 +392,10 @@ export class ApplicationController {
 
     if (
       isRunning &&
-      (isCpuChanged || isMemoryChanged || isAutoscalingCanceled)
+      (isCpuChanged ||
+        isMemoryChanged ||
+        isAutoscalingCanceled ||
+        isDedicatedDatabaseChanged)
     ) {
       await this.application.updateState(appid, ApplicationState.Restarting)
     }
@@ -489,15 +516,39 @@ export class ApplicationController {
         case 'memory':
           return option.specs.some((spec) => spec.value === dto.memory)
         case 'databaseCapacity':
+          if (!dto.databaseCapacity) return true
           return option.specs.some(
             (spec) => spec.value === dto.databaseCapacity,
           )
         case 'storageCapacity':
           return option.specs.some((spec) => spec.value === dto.storageCapacity)
+        // dedicated database
+        case 'dedicatedDatabase.cpu':
+          return (
+            !dto.dedicatedDatabase ||
+            option.specs.some(
+              (spec) => spec.value === dto.dedicatedDatabase.cpu,
+            )
+          )
+        case 'dedicatedDatabase.memory':
+          return (
+            !dto.dedicatedDatabase ||
+            option.specs.some(
+              (spec) => spec.value === dto.dedicatedDatabase.memory,
+            )
+          )
+        case 'dedicatedDatabase.capacity':
+          return (
+            !dto.dedicatedDatabase ||
+            option.specs.some(
+              (spec) => spec.value === dto.dedicatedDatabase.capacity,
+            )
+          )
         default:
           return true
       }
     })
+
     return checkSpec
   }
 }