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

application.mddocs/

Application Services

Application integration and management services including API Gateway for APIs, SNS/SQS for messaging, Step Functions for workflows, and CloudWatch for monitoring.

Capabilities

API Gateway - REST and HTTP APIs

Amazon API Gateway creates, publishes, maintains, and monitors secure APIs at any scale.

/**
 * API Gateway REST API
 */
class apigateway.RestApi extends pulumi.CustomResource {
    constructor(name: string, args?: apigateway.RestApiArgs, opts?: pulumi.CustomResourceOptions);
    
    /** API ARN */
    readonly arn: pulumi.Output<string>;
    /** API ID */
    readonly id: pulumi.Output<string>;
    /** API name */
    readonly name: pulumi.Output<string>;
    /** Description */
    readonly description: pulumi.Output<string>;
    /** Execution ARN */
    readonly executionArn: pulumi.Output<string>;
    /** Root resource ID */
    readonly rootResourceId: pulumi.Output<string>;
    /** API policy */
    readonly policy: pulumi.Output<string>;
    /** Binary media types */
    readonly binaryMediaTypes: pulumi.Output<string[]>;
    /** Endpoint configuration */
    readonly endpointConfiguration: pulumi.Output<apigateway.RestApiEndpointConfiguration>;
    /** Resource tags */
    readonly tags: pulumi.Output<{[key: string]: string}>;
}

interface apigateway.RestApiArgs {
    /** API name */
    name?: pulumi.Input<string>;
    /** Description */
    description?: pulumi.Input<string>;
    /** API policy document (JSON) */
    policy?: pulumi.Input<string>;
    /** Binary media types */
    binaryMediaTypes?: pulumi.Input<pulumi.Input<string>[]>;
    /** Minimum compression size */
    minimumCompressionSize?: pulumi.Input<number>;
    /** API key source */
    apiKeySource?: pulumi.Input<string>;
    /** Endpoint configuration */
    endpointConfiguration?: pulumi.Input<apigateway.RestApiEndpointConfiguration>;
    /** Disable execute API endpoint */
    disableExecuteApiEndpoint?: pulumi.Input<boolean>;
    /** Resource tags */
    tags?: pulumi.Input<{[key: string]: pulumi.Input<string>}>;
}

/**
 * API Gateway Resource
 */
class apigateway.Resource extends pulumi.CustomResource {
    constructor(name: string, args: apigateway.ResourceArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Resource ID */
    readonly id: pulumi.Output<string>;
    /** REST API ID */
    readonly restApi: pulumi.Output<string>;
    /** Parent resource ID */
    readonly parentId: pulumi.Output<string>;
    /** Path part */
    readonly pathPart: pulumi.Output<string>;
    /** Full path */
    readonly path: pulumi.Output<string>;
}

interface apigateway.ResourceArgs {
    /** REST API ID */
    restApi: pulumi.Input<string>;
    /** Parent resource ID */
    parentId: pulumi.Input<string>;
    /** Path part (e.g., "users", "{id}") */
    pathPart: pulumi.Input<string>;
}

/**
 * API Gateway Method
 */
class apigateway.Method extends pulumi.CustomResource {
    constructor(name: string, args: apigateway.MethodArgs, opts?: pulumi.CustomResourceOptions);
    
    /** REST API ID */
    readonly restApi: pulumi.Output<string>;
    /** Resource ID */
    readonly resourceId: pulumi.Output<string>;
    /** HTTP method */
    readonly httpMethod: pulumi.Output<string>;
    /** Authorization type */
    readonly authorization: pulumi.Output<string>;
    /** Authorizer ID */
    readonly authorizerId: pulumi.Output<string>;
    /** API key required */
    readonly apiKeyRequired: pulumi.Output<boolean>;
    /** Request parameters */
    readonly requestParameters: pulumi.Output<{[key: string]: boolean}>;
    /** Request models */
    readonly requestModels: pulumi.Output<{[key: string]: string}>;
}

interface apigateway.MethodArgs {
    /** REST API ID */
    restApi: pulumi.Input<string>;
    /** Resource ID */
    resourceId: pulumi.Input<string>;
    /** HTTP method (GET, POST, PUT, DELETE, etc.) */
    httpMethod: pulumi.Input<string>;
    /** Authorization type (NONE, AWS_IAM, CUSTOM, COGNITO_USER_POOLS) */
    authorization: pulumi.Input<string>;
    /** Authorizer ID */
    authorizerId?: pulumi.Input<string>;
    /** API key required */
    apiKeyRequired?: pulumi.Input<boolean>;
    /** Request parameters */
    requestParameters?: pulumi.Input<{[key: string]: pulumi.Input<boolean>}>;
    /** Request models */
    requestModels?: pulumi.Input<{[key: string]: pulumi.Input<string>}>;
    /** Request validator ID */
    requestValidatorId?: pulumi.Input<string>;
}

/**
 * API Gateway Integration
 */
class apigateway.Integration extends pulumi.CustomResource {
    constructor(name: string, args: apigateway.IntegrationArgs, opts?: pulumi.CustomResourceOptions);
    
    /** REST API ID */
    readonly restApi: pulumi.Output<string>;
    /** Resource ID */
    readonly resourceId: pulumi.Output<string>;
    /** HTTP method */
    readonly httpMethod: pulumi.Output<string>;
    /** Integration type */
    readonly type: pulumi.Output<string>;
    /** Integration HTTP method */
    readonly integrationHttpMethod: pulumi.Output<string>;
    /** URI */
    readonly uri: pulumi.Output<string>;
    /** Connection type */
    readonly connectionType: pulumi.Output<string>;
    /** Connection ID */
    readonly connectionId: pulumi.Output<string>;
    /** Credentials */
    readonly credentials: pulumi.Output<string>;
}

/**
 * API Gateway Deployment
 */
class apigateway.Deployment extends pulumi.CustomResource {
    constructor(name: string, args: apigateway.DeploymentArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Deployment ID */
    readonly id: pulumi.Output<string>;
    /** REST API ID */
    readonly restApi: pulumi.Output<string>;
    /** Description */
    readonly description: pulumi.Output<string>;
    /** Stage name */
    readonly stageName: pulumi.Output<string>;
    /** Invoke URL */
    readonly invokeUrl: pulumi.Output<string>;
    /** Execution ARN */
    readonly executionArn: pulumi.Output<string>;
}

Usage Examples:

// Create REST API
const api = new aws.apigateway.RestApi("user-api", {
    name: "user-management-api",
    description: "API for user management operations",
    endpointConfiguration: {
        types: ["REGIONAL"]
    },
    binaryMediaTypes: ["application/octet-stream"],
    tags: {
        Name: "UserAPI",
        Environment: "production"
    }
});

// Create resource
const usersResource = new aws.apigateway.Resource("users-resource", {
    restApi: api.id,
    parentId: api.rootResourceId,
    pathPart: "users"
});

const userResource = new aws.apigateway.Resource("user-resource", {
    restApi: api.id,
    parentId: usersResource.id,
    pathPart: "{id}"
});

// Create GET method
const getUserMethod = new aws.apigateway.Method("get-user", {
    restApi: api.id,
    resourceId: userResource.id,
    httpMethod: "GET",
    authorization: "AWS_IAM",
    requestParameters: {
        "method.request.path.id": true
    }
});

// Create Lambda integration
const getUserIntegration = new aws.apigateway.Integration("get-user-integration", {
    restApi: api.id,
    resourceId: userResource.id,
    httpMethod: getUserMethod.httpMethod,
    type: "AWS_PROXY",
    integrationHttpMethod: "POST",
    uri: getUserFunction.invokeArn,
    credentials: apiGatewayRole.arn
});

// Create deployment
const deployment = new aws.apigateway.Deployment("api-deployment", {
    restApi: api.id,
    stageName: "prod",
    description: "Production deployment"
}, {
    dependsOn: [getUserIntegration]
});

// Grant API Gateway permission to invoke Lambda
const lambdaPermission = new aws.lambda.Permission("api-lambda-permission", {
    action: "lambda:InvokeFunction",
    function: getUserFunction.name,
    principal: "apigateway.amazonaws.com",
    sourceArn: pulumi.interpolate`${api.executionArn}/*/*`
});

SNS - Simple Notification Service

Amazon Simple Notification Service is a pub/sub messaging service for application-to-application and application-to-person communication.

/**
 * SNS Topic
 */
class sns.Topic extends pulumi.CustomResource {
    constructor(name: string, args?: sns.TopicArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Topic ARN */
    readonly arn: pulumi.Output<string>;
    /** Topic name */
    readonly name: pulumi.Output<string>;
    /** Display name */
    readonly displayName: pulumi.Output<string>;
    /** Policy */
    readonly policy: pulumi.Output<string>;
    /** Delivery policy */
    readonly deliveryPolicy: pulumi.Output<string>;
    /** KMS master key ID */
    readonly kmsMasterKeyId: pulumi.Output<string>;
    /** FIFO topic */
    readonly fifoTopic: pulumi.Output<boolean>;
    /** Content-based deduplication */
    readonly contentBasedDeduplication: pulumi.Output<boolean>;
    /** Resource tags */
    readonly tags: pulumi.Output<{[key: string]: string}>;
}

interface sns.TopicArgs {
    /** Topic name */
    name?: pulumi.Input<string>;
    /** Display name */
    displayName?: pulumi.Input<string>;
    /** Topic policy (JSON) */
    policy?: pulumi.Input<string>;
    /** Delivery policy (JSON) */
    deliveryPolicy?: pulumi.Input<string>;
    /** KMS key ID for encryption */
    kmsMasterKeyId?: pulumi.Input<string>;
    /** FIFO topic */
    fifoTopic?: pulumi.Input<boolean>;
    /** Content-based deduplication */
    contentBasedDeduplication?: pulumi.Input<boolean>;
    /** Resource tags */
    tags?: pulumi.Input<{[key: string]: pulumi.Input<string>}>;
}

/**
 * SNS Topic Subscription
 */
class sns.TopicSubscription extends pulumi.CustomResource {
    constructor(name: string, args: sns.TopicSubscriptionArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Subscription ARN */
    readonly arn: pulumi.Output<string>;
    /** Topic ARN */
    readonly topicArn: pulumi.Output<string>;
    /** Protocol */
    readonly protocol: pulumi.Output<string>;
    /** Endpoint */
    readonly endpoint: pulumi.Output<string>;
    /** Raw message delivery */
    readonly rawMessageDelivery: pulumi.Output<boolean>;
    /** Filter policy */
    readonly filterPolicy: pulumi.Output<string>;
    /** Confirmation timeout */
    readonly confirmationTimeoutInMinutes: pulumi.Output<number>;
}

interface sns.TopicSubscriptionArgs {
    /** Topic ARN */
    topicArn: pulumi.Input<string>;
    /** Protocol (sqs, lambda, email, sms, http, https) */
    protocol: pulumi.Input<string>;
    /** Endpoint (queue ARN, function ARN, email, etc.) */
    endpoint: pulumi.Input<string>;
    /** Raw message delivery */
    rawMessageDelivery?: pulumi.Input<boolean>;
    /** Filter policy (JSON) */
    filterPolicy?: pulumi.Input<string>;
    /** Confirmation timeout in minutes */
    confirmationTimeoutInMinutes?: pulumi.Input<number>;
    /** Subscription role ARN */
    subscriptionRoleArn?: pulumi.Input<string>;
}

Usage Examples:

// Create SNS topic
const notificationTopic = new aws.sns.Topic("notifications", {
    name: "user-notifications",
    displayName: "User Notifications",
    kmsMasterKeyId: encryptionKey.arn,
    tags: {
        Name: "UserNotifications",
        Environment: "production"
    }
});

// Subscribe Lambda function to topic
const lambdaSubscription = new aws.sns.TopicSubscription("lambda-subscription", {
    topicArn: notificationTopic.arn,
    protocol: "lambda",
    endpoint: notificationFunction.arn
});

// Subscribe SQS queue to topic
const sqsSubscription = new aws.sns.TopicSubscription("sqs-subscription", {
    topicArn: notificationTopic.arn,
    protocol: "sqs",
    endpoint: notificationQueue.arn,
    rawMessageDelivery: true,
    filterPolicy: JSON.stringify({
        event_type: ["user_created", "user_updated"]
    })
});

// Subscribe email to topic
const emailSubscription = new aws.sns.TopicSubscription("email-subscription", {
    topicArn: notificationTopic.arn,
    protocol: "email",
    endpoint: "admin@example.com"
});

// Grant SNS permission to invoke Lambda
const snsLambdaPermission = new aws.lambda.Permission("sns-lambda-permission", {
    action: "lambda:InvokeFunction",
    function: notificationFunction.name,
    principal: "sns.amazonaws.com",
    sourceArn: notificationTopic.arn
});

SQS - Simple Queue Service

Amazon Simple Queue Service is a fully managed message queuing service for decoupling applications.

/**
 * SQS Queue
 */
class sqs.Queue extends pulumi.CustomResource {
    constructor(name: string, args?: sqs.QueueArgs, opts?: pulumi.CustomResourceOptions);
    
    /** Queue ARN */
    readonly arn: pulumi.Output<string>;
    /** Queue ID */
    readonly id: pulumi.Output<string>;
    /** Queue name */
    readonly name: pulumi.Output<string>;
    /** Queue URL */
    readonly url: pulumi.Output<string>;
    /** Visibility timeout */
    readonly visibilityTimeoutSeconds: pulumi.Output<number>;
    /** Message retention period */
    readonly messageRetentionSeconds: pulumi.Output<number>;
    /** Max message size */
    readonly maxMessageSize: pulumi.Output<number>;
    /** Delay seconds */
    readonly delaySeconds: pulumi.Output<number>;
    /** Receive wait time */
    readonly receiveWaitTimeSeconds: pulumi.Output<number>;
    /** Policy */
    readonly policy: pulumi.Output<string>;
    /** Redrive policy */
    readonly redrivePolicy: pulumi.Output<string>;
    /** FIFO queue */
    readonly fifoQueue: pulumi.Output<boolean>;
    /** Content-based deduplication */
    readonly contentBasedDeduplication: pulumi.Output<boolean>;
    /** KMS master key ID */
    readonly kmsMasterKeyId: pulumi.Output<string>;
    /** Resource tags */
    readonly tags: pulumi.Output<{[key: string]: string}>;
}

interface sqs.QueueArgs {
    /** Queue name */
    name?: pulumi.Input<string>;
    /** Visibility timeout in seconds */
    visibilityTimeoutSeconds?: pulumi.Input<number>;
    /** Message retention period in seconds */
    messageRetentionSeconds?: pulumi.Input<number>;
    /** Maximum message size in bytes */
    maxMessageSize?: pulumi.Input<number>;
    /** Message delay in seconds */
    delaySeconds?: pulumi.Input<number>;
    /** Long polling wait time in seconds */
    receiveWaitTimeSeconds?: pulumi.Input<number>;
    /** Queue policy (JSON) */
    policy?: pulumi.Input<string>;
    /** Dead letter queue redrive policy (JSON) */
    redrivePolicy?: pulumi.Input<string>;
    /** FIFO queue */
    fifoQueue?: pulumi.Input<boolean>;
    /** Content-based deduplication */
    contentBasedDeduplication?: pulumi.Input<boolean>;
    /** KMS key ID for encryption */
    kmsMasterKeyId?: pulumi.Input<string>;
    /** KMS data key reuse period in seconds */
    kmsDataKeyReusePeriodSeconds?: pulumi.Input<number>;
    /** Resource tags */
    tags?: pulumi.Input<{[key: string]: pulumi.Input<string>}>;
}

Usage Examples:

// Create dead letter queue
const deadLetterQueue = new aws.sqs.Queue("dlq", {
    name: "processing-dlq",
    messageRetentionSeconds: 1209600, // 14 days
    tags: {
        Name: "ProcessingDLQ",
        Purpose: "dead-letter"
    }
});

// Create main processing queue
const processingQueue = new aws.sqs.Queue("processing-queue", {
    name: "user-processing-queue",
    visibilityTimeoutSeconds: 300,
    messageRetentionSeconds: 345600, // 4 days
    receiveWaitTimeSeconds: 20, // Long polling
    redrivePolicy: JSON.stringify({
        deadLetterTargetArn: deadLetterQueue.arn,
        maxReceiveCount: 3
    }),
    kmsMasterKeyId: encryptionKey.arn,
    tags: {
        Name: "UserProcessingQueue",
        Environment: "production"
    }
});

// Create FIFO queue for ordered processing
const orderedQueue = new aws.sqs.Queue("ordered-queue", {
    name: "ordered-processing.fifo",
    fifoQueue: true,
    contentBasedDeduplication: true,
    visibilityTimeoutSeconds: 60,
    tags: {
        Name: "OrderedProcessingQueue",
        Type: "fifo"
    }
});

// Grant Lambda permission to receive messages
const queuePolicy = new aws.sqs.QueuePolicy("queue-policy", {
    queueUrl: processingQueue.url,
    policy: JSON.stringify({
        Version: "2012-10-17",
        Statement: [{
            Effect: "Allow",
            Principal: {
                AWS: lambdaRole.arn
            },
            Action: [
                "sqs:ReceiveMessage",
                "sqs:DeleteMessage",
                "sqs:GetQueueAttributes"
            ],
            Resource: processingQueue.arn
        }]
    })
});

Step Functions - Workflow Orchestration

AWS Step Functions coordinates multiple AWS services into serverless workflows.

/**
 * Step Functions State Machine
 */
class sfn.StateMachine extends pulumi.CustomResource {
    constructor(name: string, args: sfn.StateMachineArgs, opts?: pulumi.CustomResourceOptions);
    
    /** State machine ARN */
    readonly arn: pulumi.Output<string>;
    /** State machine name */
    readonly name: pulumi.Output<string>;
    /** Definition */
    readonly definition: pulumi.Output<string>;
    /** Role ARN */
    readonly roleArn: pulumi.Output<string>;
    /** Type */
    readonly type: pulumi.Output<string>;
    /** Logging configuration */
    readonly loggingConfiguration: pulumi.Output<sfn.StateMachineLoggingConfiguration>;
    /** Tracing configuration */
    readonly tracingConfiguration: pulumi.Output<sfn.StateMachineTracingConfiguration>;
    /** Resource tags */
    readonly tags: pulumi.Output<{[key: string]: string}>;
}

interface sfn.StateMachineArgs {
    /** State machine name */
    name?: pulumi.Input<string>;
    /** State machine definition (JSON) */
    definition: pulumi.Input<string>;
    /** IAM role ARN */
    roleArn: pulumi.Input<string>;
    /** Type (STANDARD or EXPRESS) */
    type?: pulumi.Input<string>;
    /** Logging configuration */
    loggingConfiguration?: pulumi.Input<sfn.StateMachineLoggingConfiguration>;
    /** Tracing configuration */
    tracingConfiguration?: pulumi.Input<sfn.StateMachineTracingConfiguration>;
    /** Resource tags */
    tags?: pulumi.Input<{[key: string]: pulumi.Input<string>}>;
}

Usage Examples:

// Create Step Functions execution role
const stepFunctionRole = new aws.iam.Role("step-function-role", {
    assumeRolePolicy: JSON.stringify({
        Version: "2012-10-17",
        Statement: [{
            Action: "sts:AssumeRole",
            Effect: "Allow",
            Principal: {
                Service: "states.amazonaws.com"
            }
        }]
    })
});

// Create state machine for user processing workflow
const userProcessingWorkflow = new aws.sfn.StateMachine("user-processing", {
    name: "user-processing-workflow",
    roleArn: stepFunctionRole.arn,
    type: "STANDARD",
    definition: JSON.stringify({
        Comment: "User processing workflow",
        StartAt: "ValidateUser",
        States: {
            ValidateUser: {
                Type: "Task",
                Resource: validateUserFunction.arn,
                Next: "ProcessUser",
                Catch: [{
                    ErrorEquals: ["States.TaskFailed"],
                    Next: "HandleError"
                }]
            },
            ProcessUser: {
                Type: "Task", 
                Resource: processUserFunction.arn,
                Next: "SendNotification"
            },
            SendNotification: {
                Type: "Task",
                Resource: `arn:aws:states:::sns:publish`,
                Parameters: {
                    TopicArn: notificationTopic.arn,
                    Message: "User processing completed"
                },
                End: true
            },
            HandleError: {
                Type: "Task",
                Resource: errorHandlerFunction.arn,
                End: true
            }
        }
    }),
    loggingConfiguration: {
        logDestination: `${logGroup.arn}:*`,
        includeExecutionData: true,
        level: "ALL"
    },
    tags: {
        Name: "UserProcessingWorkflow",
        Environment: "production"
    }
});

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