CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/generic-pulumi--aws

Comprehensive Amazon Web Services (AWS) infrastructure provider for Pulumi enabling multi-language infrastructure-as-code with 225+ AWS services

—

Pending
Overview
Eval results
Files

database.mddocs/

Database Services

Comprehensive database solutions including relational databases (RDS), NoSQL databases (DynamoDB), caching systems (ElastiCache), and data warehousing solutions.

Capabilities

RDS - Relational Database Service

Managed relational database service supporting MySQL, PostgreSQL, MariaDB, Oracle, and SQL Server.

/**
 * RDS database instance
 */
class rds.Instance extends pulumi.CustomResource {
    constructor(name: string, args: rds.InstanceArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Database instance ARN */
    readonly arn: pulumi.Output<string>;
    /** Database instance identifier */
    readonly identifier: pulumi.Output<string>;
    /** Database engine */
    readonly engine: pulumi.Output<string>;
    /** Engine version */
    readonly engineVersion: pulumi.Output<string>;
    /** Instance class */
    readonly instanceClass: pulumi.Output<string>;
    /** Database name */
    readonly dbName: pulumi.Output<string>;
    /** Allocated storage in GB */
    readonly allocatedStorage: pulumi.Output<number>;
    /** Storage type */
    readonly storageType: pulumi.Output<string>;
    /** Storage encrypted */
    readonly storageEncrypted: pulumi.Output<boolean>;
    /** Database endpoint */
    readonly endpoint: pulumi.Output<string>;
    /** Database port */
    readonly port: pulumi.Output<number>;
    /** Master username */
    readonly username: pulumi.Output<string>;
    /** VPC security group IDs */
    readonly vpcSecurityGroupIds: pulumi.Output<string[]>;
    /** DB subnet group name */
    readonly dbSubnetGroupName: pulumi.Output<string>;
    /** Parameter group name */
    readonly parameterGroupName: pulumi.Output<string>;
    /** Multi-AZ deployment */
    readonly multiAz: pulumi.Output<boolean>;
    /** Availability zone */
    readonly availabilityZone: pulumi.Output<string>;
    /** Backup retention period */
    readonly backupRetentionPeriod: pulumi.Output<number>;
    /** Resource tags */
    readonly tags: pulumi.Output<{[key: string]: string}>;
}

interface rds.InstanceArgs {
    /** Database instance identifier */
    identifier?: pulumi.Input<string>;
    /** Database engine (mysql, postgres, mariadb, oracle-ee, sqlserver-ex) */
    engine: pulumi.Input<string>;
    /** Engine version */
    engineVersion?: pulumi.Input<string>;
    /** Instance class (db.t3.micro, db.r5.large, etc.) */
    instanceClass: pulumi.Input<string>;
    /** Initial database name */
    dbName?: pulumi.Input<string>;
    /** Master username */
    username: pulumi.Input<string>;
    /** Master password */
    password?: pulumi.Input<string>;
    /** Manage master user password */
    manageMasterUserPassword?: pulumi.Input<boolean>;
    /** Allocated storage in GB */
    allocatedStorage?: pulumi.Input<number>;
    /** Maximum allocated storage (auto-scaling) */
    maxAllocatedStorage?: pulumi.Input<number>;
    /** Storage type (gp2, gp3, io1, standard) */
    storageType?: pulumi.Input<string>;
    /** Storage IOPS */
    iops?: pulumi.Input<number>;
    /** Enable storage encryption */
    storageEncrypted?: pulumi.Input<boolean>;
    /** KMS key ID for encryption */
    kmsKeyId?: pulumi.Input<string>;
    /** VPC security group IDs */
    vpcSecurityGroupIds?: pulumi.Input<pulumi.Input<string>[]>;
    /** DB subnet group name */
    dbSubnetGroupName?: pulumi.Input<string>;
    /** Parameter group name */
    parameterGroupName?: pulumi.Input<string>;
    /** Enable multi-AZ deployment */
    multiAz?: pulumi.Input<boolean>;
    /** Availability zone */
    availabilityZone?: pulumi.Input<string>;
    /** Backup retention period (0-35 days) */
    backupRetentionPeriod?: pulumi.Input<number>;
    /** Backup window */
    backupWindow?: pulumi.Input<string>;
    /** Maintenance window */
    maintenanceWindow?: pulumi.Input<string>;
    /** Enable auto minor version upgrade */
    autoMinorVersionUpgrade?: pulumi.Input<boolean>;
    /** Enable deletion protection */
    deletionProtection?: pulumi.Input<boolean>;
    /** Skip final snapshot */
    skipFinalSnapshot?: pulumi.Input<boolean>;
    /** Final snapshot identifier */
    finalSnapshotIdentifier?: pulumi.Input<string>;
    /** Resource tags */
    tags?: pulumi.Input<{[key: string]: pulumi.Input<string>}>;
}

/**
 * RDS subnet group for VPC deployment
 */
class rds.SubnetGroup extends pulumi.CustomResource {
    constructor(name: string, args: rds.SubnetGroupArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Subnet group name */
    readonly name: pulumi.Output<string>;
    /** Description */
    readonly description: pulumi.Output<string>;
    /** Subnet IDs */
    readonly subnetIds: pulumi.Output<string[]>;
    /** Resource tags */
    readonly tags: pulumi.Output<{[key: string]: string}>;
}

/**
 * RDS parameter group for configuration
 */
class rds.ParameterGroup extends pulumi.CustomResource {
    constructor(name: string, args: rds.ParameterGroupArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Parameter group name */
    readonly name: pulumi.Output<string>;
    /** Database family */
    readonly family: pulumi.Output<string>;
    /** Description */
    readonly description: pulumi.Output<string>;
    /** Parameters */
    readonly parameters: pulumi.Output<rds.ParameterGroupParameter[]>;
}

Usage Examples:

// Create RDS subnet group
const dbSubnetGroup = new aws.rds.SubnetGroup("db-subnet-group", {
    name: "main-db-subnet-group",
    subnetIds: privateSubnets.map(s => s.id),
    description: "Subnet group for RDS instances",
    tags: {
        Name: "MainDBSubnetGroup"
    }
});

// Create parameter group for PostgreSQL
const dbParameterGroup = new aws.rds.ParameterGroup("db-params", {
    family: "postgres14",
    description: "Custom parameter group for PostgreSQL 14",
    parameters: [
        {
            name: "shared_preload_libraries",
            value: "pg_stat_statements"
        },
        {
            name: "log_statement",
            value: "all"
        }
    ]
});

// Create RDS instance
const database = new aws.rds.Instance("main-db", {
    identifier: "main-database",
    engine: "postgres",
    engineVersion: "14.9",
    instanceClass: "db.r5.large",
    allocatedStorage: 100,
    maxAllocatedStorage: 1000,
    storageType: "gp3",
    storageEncrypted: true,
    dbName: "mainapp",
    username: "dbadmin",
    manageMasterUserPassword: true,
    dbSubnetGroupName: dbSubnetGroup.name,
    parameterGroupName: dbParameterGroup.name,
    vpcSecurityGroupIds: [dbSecurityGroup.id],
    backupRetentionPeriod: 7,
    backupWindow: "03:00-04:00",
    maintenanceWindow: "sun:04:00-sun:05:00",
    multiAz: true,
    deletionProtection: true,
    skipFinalSnapshot: false,
    finalSnapshotIdentifier: "main-db-final-snapshot",
    tags: {
        Name: "MainDatabase",
        Environment: "production"
    }
});

DynamoDB - NoSQL Database

Fully managed NoSQL database service with single-digit millisecond latency at any scale.

/**
 * DynamoDB table
 */
class dynamodb.Table extends pulumi.CustomResource {
    constructor(name: string, args: dynamodb.TableArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Table ARN */
    readonly arn: pulumi.Output<string>;
    /** Table name */
    readonly name: pulumi.Output<string>;
    /** Hash key (partition key) */
    readonly hashKey: pulumi.Output<string>;
    /** Range key (sort key) */
    readonly rangeKey: pulumi.Output<string>;
    /** Billing mode */
    readonly billingMode: pulumi.Output<string>;
    /** Read capacity units */
    readonly readCapacity: pulumi.Output<number>;
    /** Write capacity units */
    readonly writeCapacity: pulumi.Output<number>;
    /** Attribute definitions */
    readonly attributes: pulumi.Output<dynamodb.TableAttribute[]>;
    /** Global secondary indexes */
    readonly globalSecondaryIndexes: pulumi.Output<dynamodb.TableGlobalSecondaryIndex[]>;
    /** Local secondary indexes */
    readonly localSecondaryIndexes: pulumi.Output<dynamodb.TableLocalSecondaryIndex[]>;
    /** Server-side encryption */
    readonly serverSideEncryption: pulumi.Output<dynamodb.TableServerSideEncryption>;
    /** Stream specification */
    readonly streamSpecification: pulumi.Output<dynamodb.TableStreamSpecification>;
    /** Time to live */
    readonly ttl: pulumi.Output<dynamodb.TableTtl>;
    /** Point-in-time recovery */
    readonly pointInTimeRecovery: pulumi.Output<dynamodb.TablePointInTimeRecovery>;
    /** Resource tags */
    readonly tags: pulumi.Output<{[key: string]: string}>;
}

interface dynamodb.TableArgs {
    /** Table name */
    name?: pulumi.Input<string>;
    /** Hash key attribute name */
    hashKey: pulumi.Input<string>;
    /** Range key attribute name */
    rangeKey?: pulumi.Input<string>;
    /** Billing mode (PROVISIONED or PAY_PER_REQUEST) */
    billingMode?: pulumi.Input<string>;
    /** Read capacity units (for PROVISIONED) */
    readCapacity?: pulumi.Input<number>;
    /** Write capacity units (for PROVISIONED) */
    writeCapacity?: pulumi.Input<number>;
    /** Attribute definitions */
    attributes: pulumi.Input<pulumi.Input<dynamodb.TableAttribute>[]>;
    /** Global secondary indexes */
    globalSecondaryIndexes?: pulumi.Input<pulumi.Input<dynamodb.TableGlobalSecondaryIndex>[]>;
    /** Local secondary indexes */
    localSecondaryIndexes?: pulumi.Input<pulumi.Input<dynamodb.TableLocalSecondaryIndex>[]>;
    /** Server-side encryption */
    serverSideEncryption?: pulumi.Input<dynamodb.TableServerSideEncryption>;
    /** DynamoDB Streams */
    streamSpecification?: pulumi.Input<dynamodb.TableStreamSpecification>;
    /** Time to live configuration */
    ttl?: pulumi.Input<dynamodb.TableTtl>;
    /** Point-in-time recovery */
    pointInTimeRecovery?: pulumi.Input<dynamodb.TablePointInTimeRecovery>;
    /** Resource tags */
    tags?: pulumi.Input<{[key: string]: pulumi.Input<string>}>;
}

interface dynamodb.TableAttribute {
    /** Attribute name */
    name: pulumi.Input<string>;
    /** Attribute type (S, N, B) */
    type: pulumi.Input<string>;
}

interface dynamodb.TableGlobalSecondaryIndex {
    /** Index name */
    name: pulumi.Input<string>;
    /** Hash key */
    hashKey: pulumi.Input<string>;
    /** Range key */
    rangeKey?: pulumi.Input<string>;
    /** Projection type */
    projectionType: pulumi.Input<string>;
    /** Non-key attributes to project */
    nonKeyAttributes?: pulumi.Input<pulumi.Input<string>[]>;
    /** Read capacity units */
    readCapacity?: pulumi.Input<number>;
    /** Write capacity units */
    writeCapacity?: pulumi.Input<number>;
}

Usage Examples:

// Create DynamoDB table with GSI
const userTable = new aws.dynamodb.Table("users", {
    name: "users",
    billingMode: "PAY_PER_REQUEST",
    hashKey: "userId",
    attributes: [
        { name: "userId", type: "S" },
        { name: "email", type: "S" },
        { name: "createdAt", type: "N" }
    ],
    globalSecondaryIndexes: [{
        name: "email-index",
        hashKey: "email",
        projectionType: "ALL"
    }, {
        name: "created-index", 
        hashKey: "createdAt",
        projectionType: "KEYS_ONLY"
    }],
    serverSideEncryption: {
        enabled: true
    },
    pointInTimeRecovery: {
        enabled: true
    },
    ttl: {
        attributeName: "expires",
        enabled: true
    },
    tags: {
        Name: "UserTable",
        Environment: "production"
    }
});

// Provisioned capacity table
const sessionTable = new aws.dynamodb.Table("sessions", {
    name: "user-sessions",
    billingMode: "PROVISIONED",
    hashKey: "sessionId",
    readCapacity: 10,
    writeCapacity: 10,
    attributes: [
        { name: "sessionId", type: "S" }
    ],
    streamSpecification: {
        streamEnabled: true,
        streamViewType: "NEW_AND_OLD_IMAGES"
    }
});

ElastiCache - In-Memory Caching

Fully managed in-memory caching service supporting Redis and Memcached.

/**
 * ElastiCache Redis cluster
 */
class elasticache.ReplicationGroup extends pulumi.CustomResource {
    constructor(name: string, args: elasticache.ReplicationGroupArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Replication group ID */
    readonly replicationGroupId: pulumi.Output<string>;
    /** Description */
    readonly description: pulumi.Output<string>;
    /** Node type */
    readonly nodeType: pulumi.Output<string>;
    /** Port */
    readonly port: pulumi.Output<number>;
    /** Parameter group name */
    readonly parameterGroupName: pulumi.Output<string>;
    /** Subnet group name */
    readonly subnetGroupName: pulumi.Output<string>;
    /** Security group IDs */
    readonly securityGroupIds: pulumi.Output<string[]>;
    /** Number of cache clusters */
    readonly numCacheClusters: pulumi.Output<number>;
    /** Automatic failover enabled */
    readonly automaticFailoverEnabled: pulumi.Output<boolean>;
    /** Multi-AZ enabled */
    readonly multiAzEnabled: pulumi.Output<boolean>;
    /** Engine version */
    readonly engineVersion: pulumi.Output<string>;
    /** At-rest encryption enabled */
    readonly atRestEncryptionEnabled: pulumi.Output<boolean>;
    /** Transit encryption enabled */
    readonly transitEncryptionEnabled: pulumi.Output<boolean>;
    /** Auth token */
    readonly authToken: pulumi.Output<string>;
    /** Configuration endpoint */
    readonly configurationEndpoint: pulumi.Output<elasticache.ReplicationGroupConfigurationEndpoint>;
    /** Primary endpoint */
    readonly primaryEndpoint: pulumi.Output<string>;
    /** Reader endpoint */
    readonly readerEndpoint: pulumi.Output<string>;
}

/**
 * ElastiCache subnet group
 */
class elasticache.SubnetGroup extends pulumi.CustomResource {
    constructor(name: string, args: elasticache.SubnetGroupArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Subnet group name */
    readonly name: pulumi.Output<string>;
    /** Description */
    readonly description: pulumi.Output<string>;
    /** Subnet IDs */
    readonly subnetIds: pulumi.Output<string[]>;
}

/**
 * ElastiCache parameter group
 */
class elasticache.ParameterGroup extends pulumi.CustomResource {
    constructor(name: string, args: elasticache.ParameterGroupArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Parameter group name */
    readonly name: pulumi.Output<string>;
    /** Family */
    readonly family: pulumi.Output<string>;
    /** Description */
    readonly description: pulumi.Output<string>;
    /** Parameters */
    readonly parameters: pulumi.Output<elasticache.ParameterGroupParameter[]>;
}

Usage Examples:

// Create ElastiCache subnet group
const cacheSubnetGroup = new aws.elasticache.SubnetGroup("cache-subnet", {
    name: "cache-subnet-group",
    subnetIds: privateSubnets.map(s => s.id),
    description: "Subnet group for ElastiCache"
});

// Create Redis parameter group
const redisParams = new aws.elasticache.ParameterGroup("redis-params", {
    family: "redis7.x",
    description: "Custom Redis parameters",
    parameters: [
        {
            name: "maxmemory-policy",
            value: "allkeys-lru"
        }
    ]
});

// Create Redis replication group
const redisCluster = new aws.elasticache.ReplicationGroup("redis", {
    replicationGroupId: "app-redis",
    description: "Redis cluster for application caching",
    nodeType: "cache.r6g.large",
    port: 6379,
    parameterGroupName: redisParams.name,
    subnetGroupName: cacheSubnetGroup.name,
    securityGroupIds: [cacheSecurityGroup.id],
    numCacheClusters: 3,
    automaticFailoverEnabled: true,
    multiAzEnabled: true,
    engineVersion: "7.0",
    atRestEncryptionEnabled: true,
    transitEncryptionEnabled: true,
    authToken: "my-secure-auth-token",
    tags: {
        Name: "AppRedisCluster",
        Environment: "production"
    }
});

Install with Tessl CLI

npx tessl i tessl/generic-pulumi--aws@7.6.2

docs

application.md

compute.md

database.md

global-data-sources.md

index.md

networking.md

provider.md

security.md

storage.md

tile.json