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

storage.mddocs/

Storage Services

Comprehensive storage solutions including object storage (S3), block storage (EBS), file systems (EFS), and data archival services for all storage needs.

Capabilities

S3 - Object Storage

Simple Storage Service provides scalable object storage with industry-leading durability and availability.

/**
 * S3 bucket for object storage
 */
class s3.Bucket extends pulumi.CustomResource {
    constructor(name: string, args?: s3.BucketArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Bucket ARN */
    readonly arn: pulumi.Output<string>;
    /** Bucket name */
    readonly bucket: pulumi.Output<string>;
    /** Bucket domain name */
    readonly bucketDomainName: pulumi.Output<string>;
    /** Regional domain name */
    readonly bucketRegionalDomainName: pulumi.Output<string>;
    /** Hosted zone ID */
    readonly hostedZoneId: pulumi.Output<string>;
    /** AWS region */
    readonly region: pulumi.Output<string>;
    /** Website endpoint */
    readonly websiteEndpoint: pulumi.Output<string>;
    /** Resource tags */
    readonly tags: pulumi.Output<{[key: string]: string}>;
}

interface s3.BucketArgs {
    /** Bucket name (globally unique) */
    bucket?: pulumi.Input<string>;
    /** Canned ACL to apply */
    acl?: pulumi.Input<string>;
    /** CORS configuration */
    corsRules?: pulumi.Input<pulumi.Input<s3.BucketCorsRule>[]>;
    /** Lifecycle configuration */
    lifecycleRules?: pulumi.Input<pulumi.Input<s3.BucketLifecycleRule>[]>;
    /** Logging configuration */
    loggings?: pulumi.Input<pulumi.Input<s3.BucketLogging>[]>;
    /** Versioning configuration */
    versioning?: pulumi.Input<s3.BucketVersioning>;
    /** Website configuration */
    website?: pulumi.Input<s3.BucketWebsite>;
    /** Server-side encryption configuration */
    serverSideEncryptionConfiguration?: pulumi.Input<s3.BucketServerSideEncryptionConfiguration>;
    /** Replication configuration */
    replicationConfiguration?: pulumi.Input<s3.BucketReplicationConfiguration>;
    /** Resource tags */
    tags?: pulumi.Input<{[key: string]: pulumi.Input<string>}>;
}

/**
 * S3 object storage
 */
class s3.BucketObject extends pulumi.CustomResource {
    constructor(name: string, args: s3.BucketObjectArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Bucket name */
    readonly bucket: pulumi.Output<string>;
    /** Object key */
    readonly key: pulumi.Output<string>;
    /** Object ETag */
    readonly etag: pulumi.Output<string>;
    /** Object size in bytes */
    readonly size: pulumi.Output<number>;
    /** Storage class */
    readonly storageClass: pulumi.Output<string>;
    /** Version ID */
    readonly versionId: pulumi.Output<string>;
    /** Object content */
    readonly source: pulumi.Output<pulumi.asset.Asset | pulumi.asset.Archive>;
}

interface s3.BucketObjectArgs {
    /** Target bucket */
    bucket: pulumi.Input<string>;
    /** Object key (path) */
    key: pulumi.Input<string>;
    /** Object content */
    source?: pulumi.Input<pulumi.asset.Asset | pulumi.asset.Archive>;
    /** Raw content string */
    content?: pulumi.Input<string>;
    /** Content type */
    contentType?: pulumi.Input<string>;
    /** Content encoding */
    contentEncoding?: pulumi.Input<string>;
    /** Cache control header */
    cacheControl?: pulumi.Input<string>;
    /** Canned ACL */
    acl?: pulumi.Input<string>;
    /** Storage class */
    storageClass?: pulumi.Input<string>;
    /** Server-side encryption */
    serverSideEncryption?: pulumi.Input<string>;
    /** KMS key ID */
    kmsKeyId?: pulumi.Input<string>;
    /** Metadata map */
    metadata?: pulumi.Input<{[key: string]: pulumi.Input<string>}>;
    /** Object tags */
    tags?: pulumi.Input<{[key: string]: pulumi.Input<string>}>;
}

/**
 * Query existing S3 buckets
 */
function s3.getBucket(args: s3.GetBucketArgs): Promise<s3.GetBucketResult>;

interface s3.GetBucketArgs {
    /** Bucket name */
    bucket: string;
}

interface s3.GetBucketResult {
    readonly arn: string;
    readonly bucket: string;
    readonly bucketDomainName: string;
    readonly hostedZoneId: string;
    readonly region: string;
    readonly websiteEndpoint: string;
}

Usage Examples:

// Create a private S3 bucket with encryption
const bucket = new aws.s3.Bucket("app-data", {
    bucket: "my-app-data-bucket-12345",
    acl: "private",
    versioning: {
        enabled: true
    },
    serverSideEncryptionConfiguration: {
        rule: {
            applyServerSideEncryptionByDefault: {
                sseAlgorithm: "AES256"
            }
        }
    },
    lifecycleRules: [{
        enabled: true,
        transitions: [{
            days: 30,
            storageClass: "STANDARD_IA"
        }, {
            days: 90,
            storageClass: "GLACIER"
        }]
    }],
    tags: {
        Environment: "production",
        Purpose: "application-data"
    }
});

// Upload files to S3
const configFile = new aws.s3.BucketObject("config", {
    bucket: bucket.bucket,
    key: "config/app.json",
    source: new pulumi.asset.FileAsset("./config/app.json"),
    contentType: "application/json"
});

const staticAssets = new aws.s3.BucketObject("assets", {
    bucket: bucket.bucket,
    key: "assets/",
    source: new pulumi.asset.FileArchive("./dist"),
    acl: "public-read"
});

// Static website hosting
const websiteBucket = new aws.s3.Bucket("website", {
    bucket: "my-website-bucket",
    acl: "public-read",
    website: {
        indexDocument: "index.html",
        errorDocument: "error.html"
    },
    corsRules: [{
        allowedHeaders: ["*"],
        allowedMethods: ["GET", "HEAD"],
        allowedOrigins: ["*"],
        maxAgeSeconds: 3000
    }]
});

EBS - Block Storage

Elastic Block Store provides high-performance block storage for EC2 instances.

/**
 * EBS volume for block storage
 */
class ebs.Volume extends pulumi.CustomResource {
    constructor(name: string, args: ebs.VolumeArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Volume ARN */
    readonly arn: pulumi.Output<string>;
    /** Availability zone */
    readonly availabilityZone: pulumi.Output<string>;
    /** Volume ID */
    readonly id: pulumi.Output<string>;
    /** Volume size in GB */
    readonly size: pulumi.Output<number>;
    /** Volume type (gp2, gp3, io1, io2, sc1, st1) */
    readonly type: pulumi.Output<string>;
    /** IOPS for provisioned IOPS volumes */
    readonly iops: pulumi.Output<number>;
    /** Throughput for gp3 volumes */
    readonly throughput: pulumi.Output<number>;
    /** Encryption status */
    readonly encrypted: pulumi.Output<boolean>;
    /** KMS key ID */
    readonly kmsKeyId: pulumi.Output<string>;
    /** Snapshot ID used to create volume */
    readonly snapshotId: pulumi.Output<string>;
}

interface ebs.VolumeArgs {
    /** Availability zone */
    availabilityZone: pulumi.Input<string>;
    /** Volume size in GB */
    size?: pulumi.Input<number>;
    /** Volume type */
    type?: pulumi.Input<string>;
    /** IOPS (for io1, io2, gp3) */
    iops?: pulumi.Input<number>;
    /** Throughput in MB/s (for gp3) */
    throughput?: pulumi.Input<number>;
    /** Enable encryption */
    encrypted?: pulumi.Input<boolean>;
    /** KMS key for encryption */
    kmsKeyId?: pulumi.Input<string>;
    /** Source snapshot ID */
    snapshotId?: pulumi.Input<string>;
    /** Volume tags */
    tags?: pulumi.Input<{[key: string]: pulumi.Input<string>}>;
}

/**
 * EBS snapshot for backups
 */
class ebs.Snapshot extends pulumi.CustomResource {
    constructor(name: string, args: ebs.SnapshotArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Snapshot ARN */
    readonly arn: pulumi.Output<string>;
    /** Snapshot description */
    readonly description: pulumi.Output<string>;
    /** Volume ID */
    readonly volumeId: pulumi.Output<string>;
    /** Volume size */
    readonly volumeSize: pulumi.Output<number>;
    /** Owner ID */
    readonly ownerId: pulumi.Output<string>;
    /** Snapshot tags */
    readonly tags: pulumi.Output<{[key: string]: string}>;
}

/**
 * Volume attachment to EC2 instance
 */
class ec2.VolumeAttachment extends pulumi.CustomResource {
    constructor(name: string, args: ec2.VolumeAttachmentArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Device name */
    readonly deviceName: pulumi.Output<string>;
    /** Instance ID */
    readonly instanceId: pulumi.Output<string>;
    /** Volume ID */
    readonly volumeId: pulumi.Output<string>;
}

Usage Examples:

// Create encrypted EBS volume
const dataVolume = new aws.ebs.Volume("data-volume", {
    availabilityZone: "us-west-2a",
    size: 100,
    type: "gp3",
    iops: 3000,
    throughput: 125,
    encrypted: true,
    tags: {
        Name: "DataVolume",
        Backup: "daily"
    }
});

// Attach volume to EC2 instance
const attachment = new aws.ec2.VolumeAttachment("data-attachment", {
    deviceName: "/dev/xvdf",
    volumeId: dataVolume.id,
    instanceId: instance.id
});

// Create snapshot for backup
const backup = new aws.ebs.Snapshot("daily-backup", {
    volumeId: dataVolume.id,
    description: `Daily backup of ${dataVolume.id}`,
    tags: {
        Name: "DailyBackup",
        Schedule: "daily"
    }
});

EFS - Elastic File System

Fully managed NFS file system for EC2 instances with automatic scaling.

/**
 * EFS file system
 */
class efs.FileSystem extends pulumi.CustomResource {
    constructor(name: string, args?: efs.FileSystemArgs, opts?: pulumi.CustomResourceOptions);
    
    /** File system ARN */
    readonly arn: pulumi.Output<string>;
    /** File system ID */
    readonly id: pulumi.Output<string>;
    /** DNS name */
    readonly dnsName: pulumi.Output<string>;
    /** Performance mode */
    readonly performanceMode: pulumi.Output<string>;
    /** Throughput mode */
    readonly throughputMode: pulumi.Output<string>;
    /** Provisioned throughput in MB/s */
    readonly provisionedThroughputInMibps: pulumi.Output<number>;
    /** Creation token */
    readonly creationToken: pulumi.Output<string>;
    /** Encryption status */
    readonly encrypted: pulumi.Output<boolean>;
    /** KMS key ID */
    readonly kmsKeyId: pulumi.Output<string>;
}

interface efs.FileSystemArgs {
    /** Creation token (unique identifier) */
    creationToken?: pulumi.Input<string>;
    /** Performance mode (generalPurpose or maxIO) */
    performanceMode?: pulumi.Input<string>;
    /** Throughput mode (provisioned or bursting) */
    throughputMode?: pulumi.Input<string>;
    /** Provisioned throughput in MB/s */
    provisionedThroughputInMibps?: pulumi.Input<number>;
    /** Enable encryption at rest */
    encrypted?: pulumi.Input<boolean>;
    /** KMS key for encryption */
    kmsKeyId?: pulumi.Input<string>;
    /** Lifecycle policy */
    lifecyclePolicy?: pulumi.Input<efs.FileSystemLifecyclePolicy>;
    /** File system tags */
    tags?: pulumi.Input<{[key: string]: pulumi.Input<string>}>;
}

/**
 * EFS mount target for subnet access
 */
class efs.MountTarget extends pulumi.CustomResource {
    constructor(name: string, args: efs.MountTargetArgs, opts?: pulumi.CustomResourceOptions);
    
    /** File system ID */
    readonly fileSystemId: pulumi.Output<string>;
    /** Subnet ID */
    readonly subnetId: pulumi.Output<string>;
    /** IP address */
    readonly ipAddress: pulumi.Output<string>;
    /** DNS name */
    readonly dnsName: pulumi.Output<string>;
    /** Security groups */
    readonly securityGroups: pulumi.Output<string[]>;
}

/**
 * EFS access point for application access
 */
class efs.AccessPoint extends pulumi.CustomResource {
    constructor(name: string, args: efs.AccessPointArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Access point ARN */
    readonly arn: pulumi.Output<string>;
    /** File system ID */
    readonly fileSystemId: pulumi.Output<string>;
    /** Root directory configuration */
    readonly rootDirectory: pulumi.Output<efs.AccessPointRootDirectory>;
    /** POSIX user configuration */
    readonly posixUser: pulumi.Output<efs.AccessPointPosixUser>;
}

Usage Examples:

// Create EFS file system with encryption
const fileSystem = new aws.efs.FileSystem("shared-storage", {
    performanceMode: "generalPurpose",
    throughputMode: "provisioned",
    provisionedThroughputInMibps: 100,
    encrypted: true,
    lifecyclePolicy: {
        transitionToIa: "AFTER_30_DAYS"
    },
    tags: {
        Name: "SharedStorage",
        Purpose: "application-data"
    }
});

// Create mount targets in multiple subnets
const mountTargets = privateSubnets.map((subnet, index) => 
    new aws.efs.MountTarget(`mount-target-${index}`, {
        fileSystemId: fileSystem.id,
        subnetId: subnet.id,
        securityGroups: [efsSecurityGroup.id]
    })
);

// Create access point for application
const accessPoint = new aws.efs.AccessPoint("app-access", {
    fileSystemId: fileSystem.id,
    rootDirectory: {
        path: "/app-data",
        creationInfo: {
            ownerUid: 1000,
            ownerGid: 1000,
            permissions: "755"
        }
    },
    posixUser: {
        uid: 1000,
        gid: 1000
    }
});

FSx - High Performance File Systems

Fully managed file systems optimized for compute-intensive workloads.

/**
 * FSx Lustre file system for HPC workloads
 */
class fsx.LustreFileSystem extends pulumi.CustomResource {
    constructor(name: string, args: fsx.LustreFileSystemArgs, opts?: pulumi.CustomResourceOptions);
    
    /** File system ARN */
    readonly arn: pulumi.Output<string>;
    /** DNS name */
    readonly dnsName: pulumi.Output<string>;
    /** Storage capacity in GB */
    readonly storageCapacity: pulumi.Output<number>;
    /** Subnet IDs */
    readonly subnetIds: pulumi.Output<string[]>;
    /** Security group IDs */
    readonly securityGroupIds: pulumi.Output<string[]>;
    /** Mount name */
    readonly mountName: pulumi.Output<string>;
}

/**
 * FSx Windows file system
 */
class fsx.WindowsFileSystem extends pulumi.CustomResource {
    constructor(name: string, args: fsx.WindowsFileSystemArgs, opts?: pulumi.CustomResourceOptions);
    
    /** File system ARN */
    readonly arn: pulumi.Output<string>;
    /** DNS name */
    readonly dnsName: pulumi.Output<string>;
    /** Active Directory ID */
    readonly activeDirectoryId: pulumi.Output<string>;
    /** Storage capacity in GB */
    readonly storageCapacity: pulumi.Output<number>;
    /** Throughput capacity in MB/s */
    readonly throughputCapacity: pulumi.Output<number>;
}

Install with Tessl CLI

npx tessl i tessl/generic-pulumi--aws

docs

application.md

compute.md

database.md

global-data-sources.md

index.md

networking.md

provider.md

security.md

storage.md

tile.json