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

compute.mddocs/

Compute Services

Comprehensive compute capabilities including virtual machines (EC2), serverless functions (Lambda), container orchestration (ECS/EKS), and auto-scaling services.

Capabilities

EC2 - Virtual Machines

Elastic Compute Cloud provides scalable virtual machine instances with full control over the computing environment.

/**
 * EC2 virtual machine instance
 */
class ec2.Instance extends pulumi.CustomResource {
    constructor(name: string, args: ec2.InstanceArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Amazon Machine Image (AMI) ID */
    readonly ami: pulumi.Output<string>;
    /** Instance type (e.g., "t3.micro", "m5.large") */
    readonly instanceType: pulumi.Output<string>;
    /** Availability zone where instance is placed */
    readonly availabilityZone: pulumi.Output<string>;
    /** Private IP address */
    readonly privateIp: pulumi.Output<string>;
    /** Public IP address (if in public subnet) */
    readonly publicIp: pulumi.Output<string>;
    /** Public DNS name */
    readonly publicDns: pulumi.Output<string>;
    /** Instance state (running, stopped, etc.) */
    readonly instanceState: pulumi.Output<string>;
    /** Security group IDs */
    readonly securityGroups: pulumi.Output<string[]>;
    /** Subnet ID where instance is placed */
    readonly subnetId: pulumi.Output<string>;
    /** VPC ID */
    readonly vpcSecurityGroupIds: pulumi.Output<string[]>;
    /** Resource tags */
    readonly tags: pulumi.Output<{[key: string]: string}>;
}

interface ec2.InstanceArgs {
    /** AMI ID to launch */
    ami: pulumi.Input<string>;
    /** Instance type */
    instanceType: pulumi.Input<string>;
    /** Availability zone (optional) */
    availabilityZone?: pulumi.Input<string>;
    /** Subnet ID (required for VPC instances) */
    subnetId?: pulumi.Input<string>;
    /** Security group IDs */
    vpcSecurityGroupIds?: pulumi.Input<pulumi.Input<string>[]>;
    /** Key pair name for SSH access */
    keyName?: pulumi.Input<string>;
    /** User data script */
    userData?: pulumi.Input<string>;
    /** IAM instance profile */
    iamInstanceProfile?: pulumi.Input<string>;
    /** Enable detailed monitoring */
    monitoring?: pulumi.Input<boolean>;
    /** Associate public IP address */
    associatePublicIpAddress?: pulumi.Input<boolean>;
    /** Root block device configuration */
    rootBlockDevice?: pulumi.Input<ec2.InstanceRootBlockDevice>;
    /** Additional EBS block devices */
    ebsBlockDevices?: pulumi.Input<pulumi.Input<ec2.InstanceEbsBlockDevice>[]>;
    /** Resource tags */
    tags?: pulumi.Input<{[key: string]: pulumi.Input<string>}>;
}

/**
 * Query existing EC2 instances
 */
function ec2.getInstance(args: ec2.GetInstanceArgs): Promise<ec2.GetInstanceResult>;

interface ec2.GetInstanceArgs {
    /** Instance ID */
    instanceId?: string;
    /** Instance tags filter */
    instanceTags?: {[key: string]: string};
    /** Additional filters */
    filters?: ec2.GetInstanceFilter[];
}

interface ec2.GetInstanceResult {
    readonly ami: string;
    readonly instanceType: string;  
    readonly privateIp: string;
    readonly publicIp: string;
    readonly securityGroups: string[];
    readonly subnetId: string;
    readonly tags: {[key: string]: string};
}

Usage Examples:

// Create a basic EC2 instance
const instance = new aws.ec2.Instance("web-server", {
    ami: "ami-0c55b159cbfafe1d0", // Amazon Linux 2
    instanceType: "t3.micro",
    keyName: "my-key-pair",
    userData: `#!/bin/bash
        yum update -y
        yum install -y httpd
        systemctl start httpd
        systemctl enable httpd
    `,
    tags: {
        Name: "WebServer",
        Environment: "production"
    }
});

// Create instance in specific subnet with security group
const webInstance = new aws.ec2.Instance("web-instance", {
    ami: ami.id,
    instanceType: "t3.small",
    subnetId: publicSubnet.id,
    vpcSecurityGroupIds: [webSecurityGroup.id],
    associatePublicIpAddress: true,
    rootBlockDevice: {
        volumeType: "gp3",
        volumeSize: 20,
        encrypted: true
    }
});

// Query existing instances
const existingInstance = await aws.ec2.getInstance({
    filters: [
        { name: "tag:Environment", values: ["production"] },
        { name: "instance-state-name", values: ["running"] }
    ]
});

Lambda - Serverless Functions

AWS Lambda runs code without managing servers, automatically scaling and charging only for compute time used.

/**
 * Lambda function resource
 */
class lambda.Function extends pulumi.CustomResource {
    constructor(name: string, args: lambda.FunctionArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Function ARN */
    readonly arn: pulumi.Output<string>;
    /** Function name */
    readonly functionName: pulumi.Output<string>;
    /** Runtime environment */
    readonly runtime: pulumi.Output<string>;
    /** Handler function entry point */
    readonly handler: pulumi.Output<string>;
    /** Function code package */
    readonly code: pulumi.Output<lambda.FunctionCode>;
    /** Execution role ARN */
    readonly role: pulumi.Output<string>;
    /** Memory allocation in MB */
    readonly memorySize: pulumi.Output<number>;
    /** Timeout in seconds */
    readonly timeout: pulumi.Output<number>;
    /** Environment variables */
    readonly environment: pulumi.Output<lambda.FunctionEnvironment>;
    /** VPC configuration */
    readonly vpcConfig: pulumi.Output<lambda.FunctionVpcConfig>;
}

interface lambda.FunctionArgs {
    /** Function name */
    functionName?: pulumi.Input<string>;
    /** Runtime (e.g., "nodejs18.x", "python3.9", "java11") */
    runtime: pulumi.Input<string>;
    /** Handler entry point */
    handler: pulumi.Input<string>;
    /** Function code */
    code: pulumi.Input<lambda.FunctionCode>;
    /** IAM role ARN for execution */
    role: pulumi.Input<string>;
    /** Memory size in MB (128-10240) */
    memorySize?: pulumi.Input<number>;
    /** Timeout in seconds (1-900) */
    timeout?: pulumi.Input<number>;
    /** Environment variables */
    environment?: pulumi.Input<lambda.FunctionEnvironment>;
    /** VPC configuration for private resources */
    vpcConfig?: pulumi.Input<lambda.FunctionVpcConfig>;
    /** Dead letter queue configuration */
    deadLetterConfig?: pulumi.Input<lambda.FunctionDeadLetterConfig>;
    /** Function description */
    description?: pulumi.Input<string>;
    /** Resource tags */
    tags?: pulumi.Input<{[key: string]: pulumi.Input<string>}>;
}

interface lambda.FunctionCode {
    /** S3 bucket containing code */
    s3Bucket?: pulumi.Input<string>;
    /** S3 object key */
    s3Key?: pulumi.Input<string>;
    /** ZIP file content (base64 encoded) */
    zipFile?: pulumi.Input<string>;
}

interface lambda.FunctionEnvironment {
    /** Environment variable map */
    variables?: pulumi.Input<{[key: string]: pulumi.Input<string>}>;
}

Usage Examples:

// Create Lambda function with inline code
const helloFunction = new aws.lambda.Function("hello", {
    runtime: "nodejs18.x",
    handler: "index.handler",
    role: lambdaRole.arn,
    code: new pulumi.asset.AssetArchive({
        "index.js": new pulumi.asset.StringAsset(`
            exports.handler = async (event) => {
                return {
                    statusCode: 200,
                    body: JSON.stringify('Hello from Lambda!')
                };
            };
        `)
    })
});

// Lambda function with S3 code and environment variables
const apiFunction = new aws.lambda.Function("api-handler", {
    functionName: "api-handler", 
    runtime: "python3.9",
    handler: "app.lambda_handler",
    role: lambdaRole.arn,
    code: {
        s3Bucket: codeBucket.bucket,
        s3Key: "api-handler.zip"
    },
    memorySize: 256,
    timeout: 30,
    environment: {
        variables: {
            TABLE_NAME: dynamoTable.name,
            REGION: "us-west-2"
        }
    },
    vpcConfig: {
        subnetIds: privateSubnets.map(s => s.id),
        securityGroupIds: [lambdaSecurityGroup.id]
    }
});

ECS - Container Service

Elastic Container Service runs Docker containers with managed cluster infrastructure.

/**
 * ECS cluster for running containers
 */
class ecs.Cluster extends pulumi.CustomResource {
    constructor(name: string, args?: ecs.ClusterArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Cluster ARN */
    readonly arn: pulumi.Output<string>;
    /** Cluster name */
    readonly name: pulumi.Output<string>;
    /** Capacity providers */
    readonly capacityProviders: pulumi.Output<string[]>;
    /** Default capacity provider strategy */
    readonly defaultCapacityProviderStrategy: pulumi.Output<ecs.ClusterDefaultCapacityProviderStrategy[]>;
}

/**
 * ECS service for running tasks
 */
class ecs.Service extends pulumi.CustomResource {
    constructor(name: string, args: ecs.ServiceArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Service ARN */
    readonly arn: pulumi.Output<string>;
    /** Service name */
    readonly name: pulumi.Output<string>;
    /** Cluster ARN */
    readonly cluster: pulumi.Output<string>;
    /** Task definition ARN */
    readonly taskDefinition: pulumi.Output<string>;
    /** Desired task count */
    readonly desiredCount: pulumi.Output<number>;
    /** Load balancer configuration */
    readonly loadBalancers: pulumi.Output<ecs.ServiceLoadBalancer[]>;
}

/**
 * ECS task definition
 */
class ecs.TaskDefinition extends pulumi.CustomResource {
    constructor(name: string, args: ecs.TaskDefinitionArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Task definition ARN */
    readonly arn: pulumi.Output<string>;
    /** Family name */
    readonly family: pulumi.Output<string>;
    /** Container definitions */
    readonly containerDefinitions: pulumi.Output<string>;
    /** Launch type compatibility */
    readonly requiresCompatibilities: pulumi.Output<string[]>;
    /** CPU allocation */
    readonly cpu: pulumi.Output<string>;
    /** Memory allocation */
    readonly memory: pulumi.Output<string>;
    /** Network mode */
    readonly networkMode: pulumi.Output<string>;
    /** Task execution role ARN */
    readonly executionRoleArn: pulumi.Output<string>;
    /** Task role ARN */
    readonly taskRoleArn: pulumi.Output<string>;
}

EKS - Kubernetes Service

Elastic Kubernetes Service provides managed Kubernetes clusters.

/**
 * EKS cluster
 */
class eks.Cluster extends pulumi.CustomResource {
    constructor(name: string, args: eks.ClusterArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Cluster ARN */
    readonly arn: pulumi.Output<string>;
    /** Cluster name */
    readonly name: pulumi.Output<string>;
    /** Kubernetes version */
    readonly version: pulumi.Output<string>;
    /** Cluster endpoint URL */
    readonly endpoint: pulumi.Output<string>;
    /** Service role ARN */
    readonly roleArn: pulumi.Output<string>;
    /** VPC configuration */
    readonly vpcConfig: pulumi.Output<eks.ClusterVpcConfig>;
    /** Certificate authority data */
    readonly certificateAuthority: pulumi.Output<eks.ClusterCertificateAuthority>;
}

/**
 * EKS node group
 */
class eks.NodeGroup extends pulumi.CustomResource {
    constructor(name: string, args: eks.NodeGroupArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Node group ARN */
    readonly arn: pulumi.Output<string>;
    /** Cluster name */
    readonly clusterName: pulumi.Output<string>;
    /** Node group name */  
    readonly nodeGroupName: pulumi.Output<string>;
    /** Instance types */
    readonly instanceTypes: pulumi.Output<string[]>;
    /** Scaling configuration */
    readonly scalingConfig: pulumi.Output<eks.NodeGroupScalingConfig>;
    /** Node role ARN */
    readonly nodeRoleArn: pulumi.Output<string>;
    /** Subnet IDs */
    readonly subnetIds: pulumi.Output<string[]>;
}

Auto Scaling

Automatically adjust compute capacity based on demand.

/**
 * Auto Scaling Group
 */
class autoscaling.Group extends pulumi.CustomResource {
    constructor(name: string, args: autoscaling.GroupArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Auto Scaling Group ARN */
    readonly arn: pulumi.Output<string>;
    /** Group name */
    readonly name: pulumi.Output<string>;
    /** Launch template specification */
    readonly launchTemplate: pulumi.Output<autoscaling.GroupLaunchTemplate>;
    /** Minimum size */
    readonly minSize: pulumi.Output<number>;
    /** Maximum size */
    readonly maxSize: pulumi.Output<number>;
    /** Desired capacity */
    readonly desiredCapacity: pulumi.Output<number>;
    /** VPC zone identifiers (subnet IDs) */
    readonly vpcZoneIdentifiers: pulumi.Output<string[]>;
    /** Health check type */
    readonly healthCheckType: pulumi.Output<string>;
    /** Target group ARNs */
    readonly targetGroupArns: pulumi.Output<string[]>;
}

/**
 * Launch template for Auto Scaling
 */
class ec2.LaunchTemplate extends pulumi.CustomResource {
    constructor(name: string, args?: ec2.LaunchTemplateArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Launch template ARN */
    readonly arn: pulumi.Output<string>;
    /** Template name */
    readonly name: pulumi.Output<string>;
    /** Latest version number */
    readonly latestVersion: pulumi.Output<number>;
    /** Image ID */
    readonly imageId: pulumi.Output<string>;
    /** Instance type */
    readonly instanceType: pulumi.Output<string>;
    /** User data */
    readonly userData: pulumi.Output<string>;
    /** Security group IDs */
    readonly securityGroupNames: pulumi.Output<string[]>;
}

Usage Examples:

// ECS cluster with Fargate service
const cluster = new aws.ecs.Cluster("app-cluster", {
    capacityProviders: ["FARGATE", "FARGATE_SPOT"]
});

const taskDefinition = new aws.ecs.TaskDefinition("app-task", {
    family: "app",
    requiresCompatibilities: ["FARGATE"],
    networkMode: "awsvpc",
    cpu: "256",
    memory: "512",
    executionRoleArn: taskExecutionRole.arn,
    containerDefinitions: JSON.stringify([{
        name: "app",
        image: "nginx:latest", 
        portMappings: [{
            containerPort: 80,
            protocol: "tcp"
        }]
    }])
});

const service = new aws.ecs.Service("app-service", {
    cluster: cluster.id,
    taskDefinition: taskDefinition.arn,
    desiredCount: 2,
    launchType: "FARGATE",
    networkConfiguration: {
        subnets: privateSubnets.map(s => s.id),
        securityGroups: [appSecurityGroup.id]
    }
});

// Auto Scaling Group with Launch Template  
const launchTemplate = new aws.ec2.LaunchTemplate("web-template", {
    imageId: ami.id,
    instanceType: "t3.micro",
    keyName: "my-key",
    vpcSecurityGroupIds: [webSecurityGroup.id],
    userData: Buffer.from(userData).toString('base64')
});

const asg = new aws.autoscaling.Group("web-asg", {
    launchTemplate: {
        id: launchTemplate.id,
        version: "$Latest"
    },
    minSize: 1,
    maxSize: 5,
    desiredCapacity: 2,
    vpcZoneIdentifiers: publicSubnets.map(s => s.id),
    targetGroupArns: [targetGroup.arn],
    healthCheckType: "ELB"
});

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