RDS Instance

import { RdsInstance } from "@fjall/components-infrastructure/lib/resources/aws/database/rdsInstance";

const database = new RdsInstance(this, "MyDatabase", {
  vpc: myVpc,
  databaseName: "myapp",
  instanceType: "t4g.medium",
});

const database = new RdsInstance(this, "RestoredDB", {
  vpc: myVpc,
  databaseName: "restored",
  snapshotIdentifier: "rds:my-production-snapshot",
  snapshotUsername: "postgres",
});

fjall add database --app api --name RestoredDB --type Instance \
  --snapshot-identifier rds:my-production-snapshot \
  --snapshot-username postgres

const devDatabase = new RdsInstance(this, "DevDB", {
  vpc: vpc,
  databaseName: "development",
  instanceType: "t4g.micro", // 2 vCPU, 1 GB RAM
});

const prodDatabase = new RdsInstance(this, "ProdDB", {
  vpc: vpc,
  databaseName: "production",
  instanceType: "m6g.large", // 2 vCPU, 8 GB RAM
});

const perfDatabase = new RdsInstance(this, "PerfDB", {
  vpc: vpc,
  databaseName: "performance",
  instanceType: "r6g.xlarge", // 4 vCPU, 32 GB RAM
});

const database = new RdsInstance(this, "AutoScaleDB", {
  vpc: vpc,
  databaseName: "autoscale",
  allocatedStorage: 100, // Start with 100 GB
  maxAllocatedStorage: 1000, // Scale up to 1 TB
});

const database = new RdsInstance(this, "EncryptedDB", {
  vpc: vpc,
  databaseName: "secure",
});

const database = new RdsInstance(this, "SecureDB", {
  vpc: vpc,
  databaseName: "secure",
});

// Allow access from the application
app.connections.allowTo(database, Port.tcp(35255), "Application to database");

// Add additional security groups
const adminDatabase = new RdsInstance(this, "MultiSecDB", {
  vpc: vpc,
  databaseName: "multisec",
  securityGroupIds: [adminSG.securityGroupId],
});

const database = new RdsInstance(this, "HADB", {
  vpc: vpc,
  databaseName: "highavail",
  // multiAz: true (default)
});

const database = new RdsInstance(this, "ProxyDB", {
  vpc: vpc,
  databaseName: "pooled",
  proxy: {
    requireTLS: true,
  },
});

// getHostEndpoint() returns the proxy endpoint when a proxy is enabled
const endpoint = database.getHostEndpoint();

const database = new RdsInstance(this, "ScaledDB", {
  vpc: vpc,
  databaseName: "scaled",
  readReplica: {
    instanceType: "t4g.large",
  },
});

const database = new RdsInstance(this, "MonitoredDB", {
  vpc: vpc,
  databaseName: "monitored",
  databaseInsights: {
    mode: "advanced",
  },
});

const database = new RdsInstance(this, "BackupDB", {
  vpc: vpc,
  databaseName: "backup",
  backupRetention: Duration.days(30), // 30-day retention
});

const endpoint = database.getHostEndpoint();
// Returns the proxy endpoint if a proxy is enabled, otherwise the instance endpoint

const port = database.getHostPort();
// Returns "35255" (default, as a string)

const credentials = database.getCredentials();
// Returns a Secret object containing the username and password

const connections = database.connections;
// Use for network access control

const securityGroup = database.databaseSecurityGroup;
// Access the database security group

import { RdsInstance } from "@fjall/components-infrastructure/lib/resources/aws/database/rdsInstance";
import { Duration, CfnOutput } from "aws-cdk-lib";
import { Vpc, Port } from "aws-cdk-lib/aws-ec2";

// Create VPC
const vpc = new Vpc(this, "AppVpc", {
  maxAzs: 2,
  natGateways: 1,
});

// Create production database
const database = new RdsInstance(this, "ProductionDatabase", {
  vpc: vpc,
  databaseName: "production",

  // Instance configuration
  instanceType: "r6g.large", // Memory optimised
  allocatedStorage: 200, // 200 GB initial
  maxAllocatedStorage: 1000, // Scale to 1 TB

  // High availability
  proxy: {
    // Connection pooling
    requireTLS: true,
  },
  readReplica: {
    // Read scaling
    instanceType: "r6g.large",
  },

  // Monitoring
  databaseInsights: {
    mode: "advanced",
  },
  monitoringInterval: Duration.seconds(10),

  // Backup
  backupRetention: Duration.days(30),
  preferredMaintenanceWindow: "Sun:03:00-Sun:04:00",
});

// Create application
const app = new EcsCluster(this, "App", {
  vpc: vpc,
  serviceName: "app",
  containerEnvironment: {
    DB_HOST: database.getHostEndpoint(),
    DB_PORT: database.getHostPort(),
    DB_NAME: "production",
  },
  containerSecretsImport: {
    DB_PASSWORD: database.getCredentials().getImport("password"),
  },
});

// Allow connection
app.connections.allowTo(database, Port.tcp(35255), "Application to database");

// Output endpoint
new CfnOutput(this, "DatabaseEndpoint", {
  value: database.getHostEndpoint(),
  description: "Database connection endpoint",
});